1 /* 2 * include/linux/cpu.h - generic cpu definition 3 * 4 * This is mainly for topological representation. We define the 5 * basic 'struct cpu' here, which can be embedded in per-arch 6 * definitions of processors. 7 * 8 * Basic handling of the devices is done in drivers/base/cpu.c 9 * and system devices are handled in drivers/base/sys.c. 10 * 11 * CPUs are exported via sysfs in the class/cpu/devices/ 12 * directory. 13 */ 14 #ifndef _LINUX_CPU_H_ 15 #define _LINUX_CPU_H_ 16 17 #include <linux/sysdev.h> 18 #include <linux/node.h> 19 #include <linux/compiler.h> 20 #include <linux/cpumask.h> 21 22 struct cpu { 23 int node_id; /* The node which contains the CPU */ 24 int hotpluggable; /* creates sysfs control file if hotpluggable */ 25 struct sys_device sysdev; 26 }; 27 28 extern int register_cpu(struct cpu *cpu, int num); 29 extern struct sys_device *get_cpu_sysdev(unsigned cpu); 30 31 extern int cpu_add_sysdev_attr(struct sysdev_attribute *attr); 32 extern void cpu_remove_sysdev_attr(struct sysdev_attribute *attr); 33 34 extern int cpu_add_sysdev_attr_group(struct attribute_group *attrs); 35 extern void cpu_remove_sysdev_attr_group(struct attribute_group *attrs); 36 37 extern int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls); 38 39 #ifdef CONFIG_HOTPLUG_CPU 40 extern void unregister_cpu(struct cpu *cpu); 41 extern ssize_t arch_cpu_probe(const char *, size_t); 42 extern ssize_t arch_cpu_release(const char *, size_t); 43 #endif 44 struct notifier_block; 45 46 /* 47 * CPU notifier priorities. 48 */ 49 enum { 50 /* 51 * SCHED_ACTIVE marks a cpu which is coming up active during 52 * CPU_ONLINE and CPU_DOWN_FAILED and must be the first 53 * notifier. CPUSET_ACTIVE adjusts cpuset according to 54 * cpu_active mask right after SCHED_ACTIVE. During 55 * CPU_DOWN_PREPARE, SCHED_INACTIVE and CPUSET_INACTIVE are 56 * ordered in the similar way. 57 * 58 * This ordering guarantees consistent cpu_active mask and 59 * migration behavior to all cpu notifiers. 60 */ 61 CPU_PRI_SCHED_ACTIVE = INT_MAX, 62 CPU_PRI_CPUSET_ACTIVE = INT_MAX - 1, 63 CPU_PRI_SCHED_INACTIVE = INT_MIN + 1, 64 CPU_PRI_CPUSET_INACTIVE = INT_MIN, 65 66 /* migration should happen before other stuff but after perf */ 67 CPU_PRI_PERF = 20, 68 CPU_PRI_MIGRATION = 10, 69 /* prepare workqueues for other notifiers */ 70 CPU_PRI_WORKQUEUE = 5, 71 }; 72 73 #ifdef CONFIG_SMP 74 /* Need to know about CPUs going up/down? */ 75 #if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE) 76 #define cpu_notifier(fn, pri) { \ 77 static struct notifier_block fn##_nb __cpuinitdata = \ 78 { .notifier_call = fn, .priority = pri }; \ 79 register_cpu_notifier(&fn##_nb); \ 80 } 81 #else /* #if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE) */ 82 #define cpu_notifier(fn, pri) do { (void)(fn); } while (0) 83 #endif /* #else #if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE) */ 84 #ifdef CONFIG_HOTPLUG_CPU 85 extern int register_cpu_notifier(struct notifier_block *nb); 86 extern void unregister_cpu_notifier(struct notifier_block *nb); 87 #else 88 89 #ifndef MODULE 90 extern int register_cpu_notifier(struct notifier_block *nb); 91 #else 92 static inline int register_cpu_notifier(struct notifier_block *nb) 93 { 94 return 0; 95 } 96 #endif 97 98 static inline void unregister_cpu_notifier(struct notifier_block *nb) 99 { 100 } 101 #endif 102 103 int cpu_up(unsigned int cpu); 104 void notify_cpu_starting(unsigned int cpu); 105 extern void cpu_maps_update_begin(void); 106 extern void cpu_maps_update_done(void); 107 108 #else /* CONFIG_SMP */ 109 110 #define cpu_notifier(fn, pri) do { (void)(fn); } while (0) 111 112 static inline int register_cpu_notifier(struct notifier_block *nb) 113 { 114 return 0; 115 } 116 117 static inline void unregister_cpu_notifier(struct notifier_block *nb) 118 { 119 } 120 121 static inline void cpu_maps_update_begin(void) 122 { 123 } 124 125 static inline void cpu_maps_update_done(void) 126 { 127 } 128 129 #endif /* CONFIG_SMP */ 130 extern struct sysdev_class cpu_sysdev_class; 131 132 #ifdef CONFIG_HOTPLUG_CPU 133 /* Stop CPUs going up and down. */ 134 135 extern void get_online_cpus(void); 136 extern void put_online_cpus(void); 137 #define hotcpu_notifier(fn, pri) cpu_notifier(fn, pri) 138 #define register_hotcpu_notifier(nb) register_cpu_notifier(nb) 139 #define unregister_hotcpu_notifier(nb) unregister_cpu_notifier(nb) 140 int cpu_down(unsigned int cpu); 141 142 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 143 extern void cpu_hotplug_driver_lock(void); 144 extern void cpu_hotplug_driver_unlock(void); 145 #else 146 static inline void cpu_hotplug_driver_lock(void) 147 { 148 } 149 150 static inline void cpu_hotplug_driver_unlock(void) 151 { 152 } 153 #endif 154 155 #else /* CONFIG_HOTPLUG_CPU */ 156 157 #define get_online_cpus() do { } while (0) 158 #define put_online_cpus() do { } while (0) 159 #define hotcpu_notifier(fn, pri) do { (void)(fn); } while (0) 160 /* These aren't inline functions due to a GCC bug. */ 161 #define register_hotcpu_notifier(nb) ({ (void)(nb); 0; }) 162 #define unregister_hotcpu_notifier(nb) ({ (void)(nb); }) 163 #endif /* CONFIG_HOTPLUG_CPU */ 164 165 #ifdef CONFIG_PM_SLEEP_SMP 166 extern int suspend_cpu_hotplug; 167 168 extern int disable_nonboot_cpus(void); 169 extern void enable_nonboot_cpus(void); 170 #else /* !CONFIG_PM_SLEEP_SMP */ 171 #define suspend_cpu_hotplug 0 172 173 static inline int disable_nonboot_cpus(void) { return 0; } 174 static inline void enable_nonboot_cpus(void) {} 175 #endif /* !CONFIG_PM_SLEEP_SMP */ 176 177 #endif /* _LINUX_CPU_H_ */ 178