Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * include/linux/cpu.h - generic cpu definition
       4             :  *
       5             :  * This is mainly for topological representation. We define the 
       6             :  * basic 'struct cpu' here, which can be embedded in per-arch 
       7             :  * definitions of processors.
       8             :  *
       9             :  * Basic handling of the devices is done in drivers/base/cpu.c
      10             :  *
      11             :  * CPUs are exported via sysfs in the devices/system/cpu
      12             :  * directory. 
      13             :  */
      14             : #ifndef _LINUX_CPU_H_
      15             : #define _LINUX_CPU_H_
      16             : 
      17             : #include <linux/node.h>
      18             : #include <linux/compiler.h>
      19             : #include <linux/cpumask.h>
      20             : #include <linux/cpuhotplug.h>
      21             : 
      22             : struct device;
      23             : struct device_node;
      24             : struct attribute_group;
      25             : 
      26             : struct cpu {
      27             :         int node_id;            /* The node which contains the CPU */
      28             :         int hotpluggable;       /* creates sysfs control file if hotpluggable */
      29             :         struct device dev;
      30             : };
      31             : 
      32             : extern void boot_cpu_init(void);
      33             : extern void boot_cpu_hotplug_init(void);
      34             : extern void cpu_init(void);
      35             : extern void trap_init(void);
      36             : 
      37             : extern int register_cpu(struct cpu *cpu, int num);
      38             : extern struct device *get_cpu_device(unsigned cpu);
      39             : extern bool cpu_is_hotpluggable(unsigned cpu);
      40             : extern bool arch_match_cpu_phys_id(int cpu, u64 phys_id);
      41             : extern bool arch_find_n_match_cpu_physical_id(struct device_node *cpun,
      42             :                                               int cpu, unsigned int *thread);
      43             : 
      44             : extern int cpu_add_dev_attr(struct device_attribute *attr);
      45             : extern void cpu_remove_dev_attr(struct device_attribute *attr);
      46             : 
      47             : extern int cpu_add_dev_attr_group(struct attribute_group *attrs);
      48             : extern void cpu_remove_dev_attr_group(struct attribute_group *attrs);
      49             : 
      50             : extern ssize_t cpu_show_meltdown(struct device *dev,
      51             :                                  struct device_attribute *attr, char *buf);
      52             : extern ssize_t cpu_show_spectre_v1(struct device *dev,
      53             :                                    struct device_attribute *attr, char *buf);
      54             : extern ssize_t cpu_show_spectre_v2(struct device *dev,
      55             :                                    struct device_attribute *attr, char *buf);
      56             : extern ssize_t cpu_show_spec_store_bypass(struct device *dev,
      57             :                                           struct device_attribute *attr, char *buf);
      58             : extern ssize_t cpu_show_l1tf(struct device *dev,
      59             :                              struct device_attribute *attr, char *buf);
      60             : extern ssize_t cpu_show_mds(struct device *dev,
      61             :                             struct device_attribute *attr, char *buf);
      62             : extern ssize_t cpu_show_tsx_async_abort(struct device *dev,
      63             :                                         struct device_attribute *attr,
      64             :                                         char *buf);
      65             : extern ssize_t cpu_show_itlb_multihit(struct device *dev,
      66             :                                       struct device_attribute *attr, char *buf);
      67             : extern ssize_t cpu_show_srbds(struct device *dev, struct device_attribute *attr, char *buf);
      68             : 
      69             : extern __printf(4, 5)
      70             : struct device *cpu_device_create(struct device *parent, void *drvdata,
      71             :                                  const struct attribute_group **groups,
      72             :                                  const char *fmt, ...);
      73             : #ifdef CONFIG_HOTPLUG_CPU
      74             : extern void unregister_cpu(struct cpu *cpu);
      75             : extern ssize_t arch_cpu_probe(const char *, size_t);
      76             : extern ssize_t arch_cpu_release(const char *, size_t);
      77             : #endif
      78             : 
      79             : /*
      80             :  * These states are not related to the core CPU hotplug mechanism. They are
      81             :  * used by various (sub)architectures to track internal state
      82             :  */
      83             : #define CPU_ONLINE              0x0002 /* CPU is up */
      84             : #define CPU_UP_PREPARE          0x0003 /* CPU coming up */
      85             : #define CPU_DEAD                0x0007 /* CPU dead */
      86             : #define CPU_DEAD_FROZEN         0x0008 /* CPU timed out on unplug */
      87             : #define CPU_POST_DEAD           0x0009 /* CPU successfully unplugged */
      88             : #define CPU_BROKEN              0x000B /* CPU did not die properly */
      89             : 
      90             : #ifdef CONFIG_SMP
      91             : extern bool cpuhp_tasks_frozen;
      92             : int add_cpu(unsigned int cpu);
      93             : int cpu_device_up(struct device *dev);
      94             : void notify_cpu_starting(unsigned int cpu);
      95             : extern void cpu_maps_update_begin(void);
      96             : extern void cpu_maps_update_done(void);
      97             : int bringup_hibernate_cpu(unsigned int sleep_cpu);
      98             : void bringup_nonboot_cpus(unsigned int setup_max_cpus);
      99             : 
     100             : #else   /* CONFIG_SMP */
     101             : #define cpuhp_tasks_frozen      0
     102             : 
     103             : static inline void cpu_maps_update_begin(void)
     104             : {
     105             : }
     106             : 
     107             : static inline void cpu_maps_update_done(void)
     108             : {
     109             : }
     110             : 
     111             : static inline int add_cpu(unsigned int cpu) { return 0;}
     112             : 
     113             : #endif /* CONFIG_SMP */
     114             : extern struct bus_type cpu_subsys;
     115             : 
     116             : extern int lockdep_is_cpus_held(void);
     117             : 
     118             : #ifdef CONFIG_HOTPLUG_CPU
     119             : extern void cpus_write_lock(void);
     120             : extern void cpus_write_unlock(void);
     121             : extern void cpus_read_lock(void);
     122             : extern void cpus_read_unlock(void);
     123             : extern int  cpus_read_trylock(void);
     124             : extern void lockdep_assert_cpus_held(void);
     125             : extern void cpu_hotplug_disable(void);
     126             : extern void cpu_hotplug_enable(void);
     127             : void clear_tasks_mm_cpumask(int cpu);
     128             : int remove_cpu(unsigned int cpu);
     129             : int cpu_device_down(struct device *dev);
     130             : extern void smp_shutdown_nonboot_cpus(unsigned int primary_cpu);
     131             : 
     132             : #else /* CONFIG_HOTPLUG_CPU */
     133             : 
     134             : static inline void cpus_write_lock(void) { }
     135             : static inline void cpus_write_unlock(void) { }
     136             : static inline void cpus_read_lock(void) { }
     137             : static inline void cpus_read_unlock(void) { }
     138             : static inline int  cpus_read_trylock(void) { return true; }
     139             : static inline void lockdep_assert_cpus_held(void) { }
     140             : static inline void cpu_hotplug_disable(void) { }
     141             : static inline void cpu_hotplug_enable(void) { }
     142             : static inline int remove_cpu(unsigned int cpu) { return -EPERM; }
     143             : static inline void smp_shutdown_nonboot_cpus(unsigned int primary_cpu) { }
     144             : #endif  /* !CONFIG_HOTPLUG_CPU */
     145             : 
     146             : /* Wrappers which go away once all code is converted */
     147             : static inline void cpu_hotplug_begin(void) { cpus_write_lock(); }
     148             : static inline void cpu_hotplug_done(void) { cpus_write_unlock(); }
     149          50 : static inline void get_online_cpus(void) { cpus_read_lock(); }
     150          50 : static inline void put_online_cpus(void) { cpus_read_unlock(); }
     151             : 
     152             : #ifdef CONFIG_PM_SLEEP_SMP
     153             : extern int freeze_secondary_cpus(int primary);
     154             : extern void thaw_secondary_cpus(void);
     155             : 
     156             : static inline int suspend_disable_secondary_cpus(void)
     157             : {
     158             :         int cpu = 0;
     159             : 
     160             :         if (IS_ENABLED(CONFIG_PM_SLEEP_SMP_NONZERO_CPU))
     161             :                 cpu = -1;
     162             : 
     163             :         return freeze_secondary_cpus(cpu);
     164             : }
     165             : static inline void suspend_enable_secondary_cpus(void)
     166             : {
     167             :         return thaw_secondary_cpus();
     168             : }
     169             : 
     170             : #else /* !CONFIG_PM_SLEEP_SMP */
     171             : static inline void thaw_secondary_cpus(void) {}
     172             : static inline int suspend_disable_secondary_cpus(void) { return 0; }
     173             : static inline void suspend_enable_secondary_cpus(void) { }
     174             : #endif /* !CONFIG_PM_SLEEP_SMP */
     175             : 
     176             : void cpu_startup_entry(enum cpuhp_state state);
     177             : 
     178             : void cpu_idle_poll_ctrl(bool enable);
     179             : 
     180             : /* Attach to any functions which should be considered cpuidle. */
     181             : #define __cpuidle       __section(".cpuidle.text")
     182             : 
     183             : bool cpu_in_idle(unsigned long pc);
     184             : 
     185             : void arch_cpu_idle(void);
     186             : void arch_cpu_idle_prepare(void);
     187             : void arch_cpu_idle_enter(void);
     188             : void arch_cpu_idle_exit(void);
     189             : void arch_cpu_idle_dead(void);
     190             : 
     191             : int cpu_report_state(int cpu);
     192             : int cpu_check_up_prepare(int cpu);
     193             : void cpu_set_state_online(int cpu);
     194             : void play_idle_precise(u64 duration_ns, u64 latency_ns);
     195             : 
     196             : static inline void play_idle(unsigned long duration_us)
     197             : {
     198             :         play_idle_precise(duration_us * NSEC_PER_USEC, U64_MAX);
     199             : }
     200             : 
     201             : #ifdef CONFIG_HOTPLUG_CPU
     202             : bool cpu_wait_death(unsigned int cpu, int seconds);
     203             : bool cpu_report_death(void);
     204             : void cpuhp_report_idle_dead(void);
     205             : #else
     206             : static inline void cpuhp_report_idle_dead(void) { }
     207             : #endif /* #ifdef CONFIG_HOTPLUG_CPU */
     208             : 
     209             : enum cpuhp_smt_control {
     210             :         CPU_SMT_ENABLED,
     211             :         CPU_SMT_DISABLED,
     212             :         CPU_SMT_FORCE_DISABLED,
     213             :         CPU_SMT_NOT_SUPPORTED,
     214             :         CPU_SMT_NOT_IMPLEMENTED,
     215             : };
     216             : 
     217             : #if defined(CONFIG_SMP) && defined(CONFIG_HOTPLUG_SMT)
     218             : extern enum cpuhp_smt_control cpu_smt_control;
     219             : extern void cpu_smt_disable(bool force);
     220             : extern void cpu_smt_check_topology(void);
     221             : extern bool cpu_smt_possible(void);
     222             : extern int cpuhp_smt_enable(void);
     223             : extern int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval);
     224             : #else
     225             : # define cpu_smt_control                (CPU_SMT_NOT_IMPLEMENTED)
     226             : static inline void cpu_smt_disable(bool force) { }
     227             : static inline void cpu_smt_check_topology(void) { }
     228             : static inline bool cpu_smt_possible(void) { return false; }
     229             : static inline int cpuhp_smt_enable(void) { return 0; }
     230             : static inline int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval) { return 0; }
     231             : #endif
     232             : 
     233             : extern bool cpu_mitigations_off(void);
     234             : extern bool cpu_mitigations_auto_nosmt(void);
     235             : 
     236             : #endif /* _LINUX_CPU_H_ */