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