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, 381 PM_QOS_RESUME_LATENCY_NO_CONSTRAINT); 382 383 return 0; 384 } 385 386 struct device *get_cpu_device(unsigned cpu) 387 { 388 if (cpu < nr_cpu_ids && cpu_possible(cpu)) 389 return per_cpu(cpu_sys_devices, cpu); 390 else 391 return NULL; 392 } 393 EXPORT_SYMBOL_GPL(get_cpu_device); 394 395 static void device_create_release(struct device *dev) 396 { 397 kfree(dev); 398 } 399 400 static struct device * 401 __cpu_device_create(struct device *parent, void *drvdata, 402 const struct attribute_group **groups, 403 const char *fmt, va_list args) 404 { 405 struct device *dev = NULL; 406 int retval = -ENODEV; 407 408 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 409 if (!dev) { 410 retval = -ENOMEM; 411 goto error; 412 } 413 414 device_initialize(dev); 415 dev->parent = parent; 416 dev->groups = groups; 417 dev->release = device_create_release; 418 dev_set_drvdata(dev, drvdata); 419 420 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 421 if (retval) 422 goto error; 423 424 retval = device_add(dev); 425 if (retval) 426 goto error; 427 428 return dev; 429 430 error: 431 put_device(dev); 432 return ERR_PTR(retval); 433 } 434 435 struct device *cpu_device_create(struct device *parent, void *drvdata, 436 const struct attribute_group **groups, 437 const char *fmt, ...) 438 { 439 va_list vargs; 440 struct device *dev; 441 442 va_start(vargs, fmt); 443 dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs); 444 va_end(vargs); 445 return dev; 446 } 447 EXPORT_SYMBOL_GPL(cpu_device_create); 448 449 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 450 static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL); 451 #endif 452 453 static struct attribute *cpu_root_attrs[] = { 454 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 455 &dev_attr_probe.attr, 456 &dev_attr_release.attr, 457 #endif 458 &cpu_attrs[0].attr.attr, 459 &cpu_attrs[1].attr.attr, 460 &cpu_attrs[2].attr.attr, 461 &dev_attr_kernel_max.attr, 462 &dev_attr_offline.attr, 463 &dev_attr_isolated.attr, 464 #ifdef CONFIG_NO_HZ_FULL 465 &dev_attr_nohz_full.attr, 466 #endif 467 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 468 &dev_attr_modalias.attr, 469 #endif 470 NULL 471 }; 472 473 static struct attribute_group cpu_root_attr_group = { 474 .attrs = cpu_root_attrs, 475 }; 476 477 static const struct attribute_group *cpu_root_attr_groups[] = { 478 &cpu_root_attr_group, 479 NULL, 480 }; 481 482 bool cpu_is_hotpluggable(unsigned cpu) 483 { 484 struct device *dev = get_cpu_device(cpu); 485 return dev && container_of(dev, struct cpu, dev)->hotpluggable; 486 } 487 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable); 488 489 #ifdef CONFIG_GENERIC_CPU_DEVICES 490 static DEFINE_PER_CPU(struct cpu, cpu_devices); 491 #endif 492 493 static void __init cpu_dev_register_generic(void) 494 { 495 #ifdef CONFIG_GENERIC_CPU_DEVICES 496 int i; 497 498 for_each_possible_cpu(i) { 499 if (register_cpu(&per_cpu(cpu_devices, i), i)) 500 panic("Failed to register CPU device"); 501 } 502 #endif 503 } 504 505 void __init cpu_dev_init(void) 506 { 507 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups)) 508 panic("Failed to register CPU subsystem"); 509 510 cpu_dev_register_generic(); 511 } 512