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 #include <linux/acpi.h> 17 #include <linux/of.h> 18 #include <linux/cpufeature.h> 19 #include <linux/tick.h> 20 21 #include "base.h" 22 23 static DEFINE_PER_CPU(struct device *, cpu_sys_devices); 24 25 static int cpu_subsys_match(struct device *dev, struct device_driver *drv) 26 { 27 /* ACPI style match is the only one that may succeed. */ 28 if (acpi_driver_match_device(dev, drv)) 29 return 1; 30 31 return 0; 32 } 33 34 #ifdef CONFIG_HOTPLUG_CPU 35 static void change_cpu_under_node(struct cpu *cpu, 36 unsigned int from_nid, unsigned int to_nid) 37 { 38 int cpuid = cpu->dev.id; 39 unregister_cpu_under_node(cpuid, from_nid); 40 register_cpu_under_node(cpuid, to_nid); 41 cpu->node_id = to_nid; 42 } 43 44 static int cpu_subsys_online(struct device *dev) 45 { 46 struct cpu *cpu = container_of(dev, struct cpu, dev); 47 int cpuid = dev->id; 48 int from_nid, to_nid; 49 int ret; 50 51 from_nid = cpu_to_node(cpuid); 52 if (from_nid == NUMA_NO_NODE) 53 return -ENODEV; 54 55 ret = cpu_up(cpuid); 56 /* 57 * When hot adding memory to memoryless node and enabling a cpu 58 * on the node, node number of the cpu may internally change. 59 */ 60 to_nid = cpu_to_node(cpuid); 61 if (from_nid != to_nid) 62 change_cpu_under_node(cpu, from_nid, to_nid); 63 64 return ret; 65 } 66 67 static int cpu_subsys_offline(struct device *dev) 68 { 69 return cpu_down(dev->id); 70 } 71 72 void unregister_cpu(struct cpu *cpu) 73 { 74 int logical_cpu = cpu->dev.id; 75 76 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu)); 77 78 device_unregister(&cpu->dev); 79 per_cpu(cpu_sys_devices, logical_cpu) = NULL; 80 return; 81 } 82 83 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 84 static ssize_t cpu_probe_store(struct device *dev, 85 struct device_attribute *attr, 86 const char *buf, 87 size_t count) 88 { 89 ssize_t cnt; 90 int ret; 91 92 ret = lock_device_hotplug_sysfs(); 93 if (ret) 94 return ret; 95 96 cnt = arch_cpu_probe(buf, count); 97 98 unlock_device_hotplug(); 99 return cnt; 100 } 101 102 static ssize_t cpu_release_store(struct device *dev, 103 struct device_attribute *attr, 104 const char *buf, 105 size_t count) 106 { 107 ssize_t cnt; 108 int ret; 109 110 ret = lock_device_hotplug_sysfs(); 111 if (ret) 112 return ret; 113 114 cnt = arch_cpu_release(buf, count); 115 116 unlock_device_hotplug(); 117 return cnt; 118 } 119 120 static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store); 121 static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store); 122 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ 123 #endif /* CONFIG_HOTPLUG_CPU */ 124 125 struct bus_type cpu_subsys = { 126 .name = "cpu", 127 .dev_name = "cpu", 128 .match = cpu_subsys_match, 129 #ifdef CONFIG_HOTPLUG_CPU 130 .online = cpu_subsys_online, 131 .offline = cpu_subsys_offline, 132 #endif 133 }; 134 EXPORT_SYMBOL_GPL(cpu_subsys); 135 136 #ifdef CONFIG_KEXEC 137 #include <linux/kexec.h> 138 139 static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr, 140 char *buf) 141 { 142 struct cpu *cpu = container_of(dev, struct cpu, dev); 143 ssize_t rc; 144 unsigned long long addr; 145 int cpunum; 146 147 cpunum = cpu->dev.id; 148 149 /* 150 * Might be reading other cpu's data based on which cpu read thread 151 * has been scheduled. But cpu data (memory) is allocated once during 152 * boot up and this data does not change there after. Hence this 153 * operation should be safe. No locking required. 154 */ 155 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum)); 156 rc = sprintf(buf, "%Lx\n", addr); 157 return rc; 158 } 159 static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL); 160 161 static ssize_t show_crash_notes_size(struct device *dev, 162 struct device_attribute *attr, 163 char *buf) 164 { 165 ssize_t rc; 166 167 rc = sprintf(buf, "%zu\n", sizeof(note_buf_t)); 168 return rc; 169 } 170 static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL); 171 172 static struct attribute *crash_note_cpu_attrs[] = { 173 &dev_attr_crash_notes.attr, 174 &dev_attr_crash_notes_size.attr, 175 NULL 176 }; 177 178 static struct attribute_group crash_note_cpu_attr_group = { 179 .attrs = crash_note_cpu_attrs, 180 }; 181 #endif 182 183 static const struct attribute_group *common_cpu_attr_groups[] = { 184 #ifdef CONFIG_KEXEC 185 &crash_note_cpu_attr_group, 186 #endif 187 NULL 188 }; 189 190 static const struct attribute_group *hotplugable_cpu_attr_groups[] = { 191 #ifdef CONFIG_KEXEC 192 &crash_note_cpu_attr_group, 193 #endif 194 NULL 195 }; 196 197 /* 198 * Print cpu online, possible, present, and system maps 199 */ 200 201 struct cpu_attr { 202 struct device_attribute attr; 203 const struct cpumask *const * const map; 204 }; 205 206 static ssize_t show_cpus_attr(struct device *dev, 207 struct device_attribute *attr, 208 char *buf) 209 { 210 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr); 211 212 return cpumap_print_to_pagebuf(true, buf, *ca->map); 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 = scnprintf(buf, len, "%*pbl", cpumask_pr_args(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 ssize_t print_cpus_isolated(struct device *dev, 270 struct device_attribute *attr, char *buf) 271 { 272 int n = 0, len = PAGE_SIZE-2; 273 274 n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(cpu_isolated_map)); 275 276 return n; 277 } 278 static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL); 279 280 #ifdef CONFIG_NO_HZ_FULL 281 static ssize_t print_cpus_nohz_full(struct device *dev, 282 struct device_attribute *attr, char *buf) 283 { 284 int n = 0, len = PAGE_SIZE-2; 285 286 n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask)); 287 288 return n; 289 } 290 static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL); 291 #endif 292 293 static void cpu_device_release(struct device *dev) 294 { 295 /* 296 * This is an empty function to prevent the driver core from spitting a 297 * warning at us. Yes, I know this is directly opposite of what the 298 * documentation for the driver core and kobjects say, and the author 299 * of this code has already been publically ridiculed for doing 300 * something as foolish as this. However, at this point in time, it is 301 * the only way to handle the issue of statically allocated cpu 302 * devices. The different architectures will have their cpu device 303 * code reworked to properly handle this in the near future, so this 304 * function will then be changed to correctly free up the memory held 305 * by the cpu device. 306 * 307 * Never copy this way of doing things, or you too will be made fun of 308 * on the linux-kernel list, you have been warned. 309 */ 310 } 311 312 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 313 static ssize_t print_cpu_modalias(struct device *dev, 314 struct device_attribute *attr, 315 char *buf) 316 { 317 ssize_t n; 318 u32 i; 319 320 n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:", 321 CPU_FEATURE_TYPEVAL); 322 323 for (i = 0; i < MAX_CPU_FEATURES; i++) 324 if (cpu_have_feature(i)) { 325 if (PAGE_SIZE < n + sizeof(",XXXX\n")) { 326 WARN(1, "CPU features overflow page\n"); 327 break; 328 } 329 n += sprintf(&buf[n], ",%04X", i); 330 } 331 buf[n++] = '\n'; 332 return n; 333 } 334 335 static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env) 336 { 337 char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL); 338 if (buf) { 339 print_cpu_modalias(NULL, NULL, buf); 340 add_uevent_var(env, "MODALIAS=%s", buf); 341 kfree(buf); 342 } 343 return 0; 344 } 345 #endif 346 347 /* 348 * register_cpu - Setup a sysfs device for a CPU. 349 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in 350 * sysfs for this CPU. 351 * @num - CPU number to use when creating the device. 352 * 353 * Initialize and register the CPU device. 354 */ 355 int register_cpu(struct cpu *cpu, int num) 356 { 357 int error; 358 359 cpu->node_id = cpu_to_node(num); 360 memset(&cpu->dev, 0x00, sizeof(struct device)); 361 cpu->dev.id = num; 362 cpu->dev.bus = &cpu_subsys; 363 cpu->dev.release = cpu_device_release; 364 cpu->dev.offline_disabled = !cpu->hotpluggable; 365 cpu->dev.offline = !cpu_online(num); 366 cpu->dev.of_node = of_get_cpu_node(num, NULL); 367 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 368 cpu->dev.bus->uevent = cpu_uevent; 369 #endif 370 cpu->dev.groups = common_cpu_attr_groups; 371 if (cpu->hotpluggable) 372 cpu->dev.groups = hotplugable_cpu_attr_groups; 373 error = device_register(&cpu->dev); 374 if (!error) 375 per_cpu(cpu_sys_devices, num) = &cpu->dev; 376 if (!error) 377 register_cpu_under_node(num, cpu_to_node(num)); 378 379 return error; 380 } 381 382 struct device *get_cpu_device(unsigned cpu) 383 { 384 if (cpu < nr_cpu_ids && cpu_possible(cpu)) 385 return per_cpu(cpu_sys_devices, cpu); 386 else 387 return NULL; 388 } 389 EXPORT_SYMBOL_GPL(get_cpu_device); 390 391 static void device_create_release(struct device *dev) 392 { 393 kfree(dev); 394 } 395 396 static struct device * 397 __cpu_device_create(struct device *parent, void *drvdata, 398 const struct attribute_group **groups, 399 const char *fmt, va_list args) 400 { 401 struct device *dev = NULL; 402 int retval = -ENODEV; 403 404 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 405 if (!dev) { 406 retval = -ENOMEM; 407 goto error; 408 } 409 410 device_initialize(dev); 411 dev->parent = parent; 412 dev->groups = groups; 413 dev->release = device_create_release; 414 dev_set_drvdata(dev, drvdata); 415 416 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 417 if (retval) 418 goto error; 419 420 retval = device_add(dev); 421 if (retval) 422 goto error; 423 424 return dev; 425 426 error: 427 put_device(dev); 428 return ERR_PTR(retval); 429 } 430 431 struct device *cpu_device_create(struct device *parent, void *drvdata, 432 const struct attribute_group **groups, 433 const char *fmt, ...) 434 { 435 va_list vargs; 436 struct device *dev; 437 438 va_start(vargs, fmt); 439 dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs); 440 va_end(vargs); 441 return dev; 442 } 443 EXPORT_SYMBOL_GPL(cpu_device_create); 444 445 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 446 static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL); 447 #endif 448 449 static struct attribute *cpu_root_attrs[] = { 450 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 451 &dev_attr_probe.attr, 452 &dev_attr_release.attr, 453 #endif 454 &cpu_attrs[0].attr.attr, 455 &cpu_attrs[1].attr.attr, 456 &cpu_attrs[2].attr.attr, 457 &dev_attr_kernel_max.attr, 458 &dev_attr_offline.attr, 459 &dev_attr_isolated.attr, 460 #ifdef CONFIG_NO_HZ_FULL 461 &dev_attr_nohz_full.attr, 462 #endif 463 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 464 &dev_attr_modalias.attr, 465 #endif 466 NULL 467 }; 468 469 static struct attribute_group cpu_root_attr_group = { 470 .attrs = cpu_root_attrs, 471 }; 472 473 static const struct attribute_group *cpu_root_attr_groups[] = { 474 &cpu_root_attr_group, 475 NULL, 476 }; 477 478 bool cpu_is_hotpluggable(unsigned cpu) 479 { 480 struct device *dev = get_cpu_device(cpu); 481 return dev && container_of(dev, struct cpu, dev)->hotpluggable; 482 } 483 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable); 484 485 #ifdef CONFIG_GENERIC_CPU_DEVICES 486 static DEFINE_PER_CPU(struct cpu, cpu_devices); 487 #endif 488 489 static void __init cpu_dev_register_generic(void) 490 { 491 #ifdef CONFIG_GENERIC_CPU_DEVICES 492 int i; 493 494 for_each_possible_cpu(i) { 495 if (register_cpu(&per_cpu(cpu_devices, i), i)) 496 panic("Failed to register CPU device"); 497 } 498 #endif 499 } 500 501 void __init cpu_dev_init(void) 502 { 503 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups)) 504 panic("Failed to register CPU subsystem"); 505 506 cpu_dev_register_generic(); 507 } 508