1 /* 2 * CPU subsystem support 3 */ 4 5 #include <linux/kernel.h> 6 #include <linux/module.h> 7 #include <linux/init.h> 8 #include <linux/sched.h> 9 #include <linux/cpu.h> 10 #include <linux/topology.h> 11 #include <linux/device.h> 12 #include <linux/node.h> 13 #include <linux/gfp.h> 14 #include <linux/slab.h> 15 #include <linux/percpu.h> 16 17 #include "base.h" 18 19 struct bus_type cpu_subsys = { 20 .name = "cpu", 21 .dev_name = "cpu", 22 }; 23 EXPORT_SYMBOL_GPL(cpu_subsys); 24 25 static DEFINE_PER_CPU(struct device *, cpu_sys_devices); 26 27 #ifdef CONFIG_HOTPLUG_CPU 28 static void change_cpu_under_node(struct cpu *cpu, 29 unsigned int from_nid, unsigned int to_nid) 30 { 31 int cpuid = cpu->dev.id; 32 unregister_cpu_under_node(cpuid, from_nid); 33 register_cpu_under_node(cpuid, to_nid); 34 cpu->node_id = to_nid; 35 } 36 37 static ssize_t show_online(struct device *dev, 38 struct device_attribute *attr, 39 char *buf) 40 { 41 struct cpu *cpu = container_of(dev, struct cpu, dev); 42 43 return sprintf(buf, "%u\n", !!cpu_online(cpu->dev.id)); 44 } 45 46 static ssize_t __ref store_online(struct device *dev, 47 struct device_attribute *attr, 48 const char *buf, size_t count) 49 { 50 struct cpu *cpu = container_of(dev, struct cpu, dev); 51 int cpuid = cpu->dev.id; 52 int from_nid, to_nid; 53 ssize_t ret; 54 55 cpu_hotplug_driver_lock(); 56 switch (buf[0]) { 57 case '0': 58 ret = cpu_down(cpuid); 59 if (!ret) 60 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 61 break; 62 case '1': 63 from_nid = cpu_to_node(cpuid); 64 ret = cpu_up(cpuid); 65 66 /* 67 * When hot adding memory to memoryless node and enabling a cpu 68 * on the node, node number of the cpu may internally change. 69 */ 70 to_nid = cpu_to_node(cpuid); 71 if (from_nid != to_nid) 72 change_cpu_under_node(cpu, from_nid, to_nid); 73 74 if (!ret) 75 kobject_uevent(&dev->kobj, KOBJ_ONLINE); 76 break; 77 default: 78 ret = -EINVAL; 79 } 80 cpu_hotplug_driver_unlock(); 81 82 if (ret >= 0) 83 ret = count; 84 return ret; 85 } 86 static DEVICE_ATTR(online, 0644, show_online, store_online); 87 88 static struct attribute *hotplug_cpu_attrs[] = { 89 &dev_attr_online.attr, 90 NULL 91 }; 92 93 static struct attribute_group hotplug_cpu_attr_group = { 94 .attrs = hotplug_cpu_attrs, 95 }; 96 97 void unregister_cpu(struct cpu *cpu) 98 { 99 int logical_cpu = cpu->dev.id; 100 101 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu)); 102 103 device_unregister(&cpu->dev); 104 per_cpu(cpu_sys_devices, logical_cpu) = NULL; 105 return; 106 } 107 108 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 109 static ssize_t cpu_probe_store(struct device *dev, 110 struct device_attribute *attr, 111 const char *buf, 112 size_t count) 113 { 114 return arch_cpu_probe(buf, count); 115 } 116 117 static ssize_t cpu_release_store(struct device *dev, 118 struct device_attribute *attr, 119 const char *buf, 120 size_t count) 121 { 122 return arch_cpu_release(buf, count); 123 } 124 125 static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store); 126 static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store); 127 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ 128 #endif /* CONFIG_HOTPLUG_CPU */ 129 130 #ifdef CONFIG_KEXEC 131 #include <linux/kexec.h> 132 133 static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr, 134 char *buf) 135 { 136 struct cpu *cpu = container_of(dev, struct cpu, dev); 137 ssize_t rc; 138 unsigned long long addr; 139 int cpunum; 140 141 cpunum = cpu->dev.id; 142 143 /* 144 * Might be reading other cpu's data based on which cpu read thread 145 * has been scheduled. But cpu data (memory) is allocated once during 146 * boot up and this data does not change there after. Hence this 147 * operation should be safe. No locking required. 148 */ 149 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum)); 150 rc = sprintf(buf, "%Lx\n", addr); 151 return rc; 152 } 153 static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL); 154 155 static ssize_t show_crash_notes_size(struct device *dev, 156 struct device_attribute *attr, 157 char *buf) 158 { 159 ssize_t rc; 160 161 rc = sprintf(buf, "%zu\n", sizeof(note_buf_t)); 162 return rc; 163 } 164 static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL); 165 166 static struct attribute *crash_note_cpu_attrs[] = { 167 &dev_attr_crash_notes.attr, 168 &dev_attr_crash_notes_size.attr, 169 NULL 170 }; 171 172 static struct attribute_group crash_note_cpu_attr_group = { 173 .attrs = crash_note_cpu_attrs, 174 }; 175 #endif 176 177 static const struct attribute_group *common_cpu_attr_groups[] = { 178 #ifdef CONFIG_KEXEC 179 &crash_note_cpu_attr_group, 180 #endif 181 NULL 182 }; 183 184 static const struct attribute_group *hotplugable_cpu_attr_groups[] = { 185 #ifdef CONFIG_KEXEC 186 &crash_note_cpu_attr_group, 187 #endif 188 #ifdef CONFIG_HOTPLUG_CPU 189 &hotplug_cpu_attr_group, 190 #endif 191 NULL 192 }; 193 194 /* 195 * Print cpu online, possible, present, and system maps 196 */ 197 198 struct cpu_attr { 199 struct device_attribute attr; 200 const struct cpumask *const * const map; 201 }; 202 203 static ssize_t show_cpus_attr(struct device *dev, 204 struct device_attribute *attr, 205 char *buf) 206 { 207 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr); 208 int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *(ca->map)); 209 210 buf[n++] = '\n'; 211 buf[n] = '\0'; 212 return n; 213 } 214 215 #define _CPU_ATTR(name, map) \ 216 { __ATTR(name, 0444, show_cpus_attr, NULL), map } 217 218 /* Keep in sync with cpu_subsys_attrs */ 219 static struct cpu_attr cpu_attrs[] = { 220 _CPU_ATTR(online, &cpu_online_mask), 221 _CPU_ATTR(possible, &cpu_possible_mask), 222 _CPU_ATTR(present, &cpu_present_mask), 223 }; 224 225 /* 226 * Print values for NR_CPUS and offlined cpus 227 */ 228 static ssize_t print_cpus_kernel_max(struct device *dev, 229 struct device_attribute *attr, char *buf) 230 { 231 int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1); 232 return n; 233 } 234 static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL); 235 236 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */ 237 unsigned int total_cpus; 238 239 static ssize_t print_cpus_offline(struct device *dev, 240 struct device_attribute *attr, char *buf) 241 { 242 int n = 0, len = PAGE_SIZE-2; 243 cpumask_var_t offline; 244 245 /* display offline cpus < nr_cpu_ids */ 246 if (!alloc_cpumask_var(&offline, GFP_KERNEL)) 247 return -ENOMEM; 248 cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask); 249 n = cpulist_scnprintf(buf, len, offline); 250 free_cpumask_var(offline); 251 252 /* display offline cpus >= nr_cpu_ids */ 253 if (total_cpus && nr_cpu_ids < total_cpus) { 254 if (n && n < len) 255 buf[n++] = ','; 256 257 if (nr_cpu_ids == total_cpus-1) 258 n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids); 259 else 260 n += snprintf(&buf[n], len - n, "%d-%d", 261 nr_cpu_ids, total_cpus-1); 262 } 263 264 n += snprintf(&buf[n], len - n, "\n"); 265 return n; 266 } 267 static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL); 268 269 static void cpu_device_release(struct device *dev) 270 { 271 /* 272 * This is an empty function to prevent the driver core from spitting a 273 * warning at us. Yes, I know this is directly opposite of what the 274 * documentation for the driver core and kobjects say, and the author 275 * of this code has already been publically ridiculed for doing 276 * something as foolish as this. However, at this point in time, it is 277 * the only way to handle the issue of statically allocated cpu 278 * devices. The different architectures will have their cpu device 279 * code reworked to properly handle this in the near future, so this 280 * function will then be changed to correctly free up the memory held 281 * by the cpu device. 282 * 283 * Never copy this way of doing things, or you too will be made fun of 284 * on the linux-kernel list, you have been warned. 285 */ 286 } 287 288 /* 289 * register_cpu - Setup a sysfs device for a CPU. 290 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in 291 * sysfs for this CPU. 292 * @num - CPU number to use when creating the device. 293 * 294 * Initialize and register the CPU device. 295 */ 296 int __cpuinit register_cpu(struct cpu *cpu, int num) 297 { 298 int error; 299 300 cpu->node_id = cpu_to_node(num); 301 memset(&cpu->dev, 0x00, sizeof(struct device)); 302 cpu->dev.id = num; 303 cpu->dev.bus = &cpu_subsys; 304 cpu->dev.release = cpu_device_release; 305 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE 306 cpu->dev.bus->uevent = arch_cpu_uevent; 307 #endif 308 cpu->dev.groups = common_cpu_attr_groups; 309 if (cpu->hotpluggable) 310 cpu->dev.groups = hotplugable_cpu_attr_groups; 311 error = device_register(&cpu->dev); 312 if (!error) 313 per_cpu(cpu_sys_devices, num) = &cpu->dev; 314 if (!error) 315 register_cpu_under_node(num, cpu_to_node(num)); 316 317 return error; 318 } 319 320 struct device *get_cpu_device(unsigned cpu) 321 { 322 if (cpu < nr_cpu_ids && cpu_possible(cpu)) 323 return per_cpu(cpu_sys_devices, cpu); 324 else 325 return NULL; 326 } 327 EXPORT_SYMBOL_GPL(get_cpu_device); 328 329 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE 330 static DEVICE_ATTR(modalias, 0444, arch_print_cpu_modalias, NULL); 331 #endif 332 333 static struct attribute *cpu_root_attrs[] = { 334 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 335 &dev_attr_probe.attr, 336 &dev_attr_release.attr, 337 #endif 338 &cpu_attrs[0].attr.attr, 339 &cpu_attrs[1].attr.attr, 340 &cpu_attrs[2].attr.attr, 341 &dev_attr_kernel_max.attr, 342 &dev_attr_offline.attr, 343 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE 344 &dev_attr_modalias.attr, 345 #endif 346 NULL 347 }; 348 349 static struct attribute_group cpu_root_attr_group = { 350 .attrs = cpu_root_attrs, 351 }; 352 353 static const struct attribute_group *cpu_root_attr_groups[] = { 354 &cpu_root_attr_group, 355 NULL, 356 }; 357 358 bool cpu_is_hotpluggable(unsigned cpu) 359 { 360 struct device *dev = get_cpu_device(cpu); 361 return dev && container_of(dev, struct cpu, dev)->hotpluggable; 362 } 363 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable); 364 365 #ifdef CONFIG_GENERIC_CPU_DEVICES 366 static DEFINE_PER_CPU(struct cpu, cpu_devices); 367 #endif 368 369 static void __init cpu_dev_register_generic(void) 370 { 371 #ifdef CONFIG_GENERIC_CPU_DEVICES 372 int i; 373 374 for_each_possible_cpu(i) { 375 if (register_cpu(&per_cpu(cpu_devices, i), i)) 376 panic("Failed to register CPU device"); 377 } 378 #endif 379 } 380 381 void __init cpu_dev_init(void) 382 { 383 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups)) 384 panic("Failed to register CPU subsystem"); 385 386 cpu_dev_register_generic(); 387 } 388