1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * CPU subsystem support 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/init.h> 9 #include <linux/sched.h> 10 #include <linux/cpu.h> 11 #include <linux/topology.h> 12 #include <linux/device.h> 13 #include <linux/node.h> 14 #include <linux/gfp.h> 15 #include <linux/slab.h> 16 #include <linux/percpu.h> 17 #include <linux/acpi.h> 18 #include <linux/of.h> 19 #include <linux/cpufeature.h> 20 #include <linux/tick.h> 21 #include <linux/pm_qos.h> 22 #include <linux/delay.h> 23 #include <linux/sched/isolation.h> 24 25 #include "base.h" 26 27 static DEFINE_PER_CPU(struct device *, cpu_sys_devices); 28 29 static int cpu_subsys_match(struct device *dev, const struct device_driver *drv) 30 { 31 /* ACPI style match is the only one that may succeed. */ 32 if (acpi_driver_match_device(dev, drv)) 33 return 1; 34 35 return 0; 36 } 37 38 #ifdef CONFIG_HOTPLUG_CPU 39 static void change_cpu_under_node(struct cpu *cpu, 40 unsigned int from_nid, unsigned int to_nid) 41 { 42 int cpuid = cpu->dev.id; 43 unregister_cpu_under_node(cpuid, from_nid); 44 register_cpu_under_node(cpuid, to_nid); 45 cpu->node_id = to_nid; 46 } 47 48 static int cpu_subsys_online(struct device *dev) 49 { 50 struct cpu *cpu = container_of(dev, struct cpu, dev); 51 int cpuid = dev->id; 52 int from_nid, to_nid; 53 int ret; 54 int retries = 0; 55 56 from_nid = cpu_to_node(cpuid); 57 if (from_nid == NUMA_NO_NODE) 58 return -ENODEV; 59 60 retry: 61 ret = cpu_device_up(dev); 62 63 /* 64 * If -EBUSY is returned, it is likely that hotplug is temporarily 65 * disabled when cpu_hotplug_disable() was called. This condition is 66 * transient. So we retry after waiting for an exponentially 67 * increasing delay up to a total of at least 620ms as some PCI 68 * device initialization can take quite a while. 69 */ 70 if (ret == -EBUSY) { 71 retries++; 72 if (retries > 5) 73 return ret; 74 msleep(10 * (1 << retries)); 75 goto retry; 76 } 77 78 /* 79 * When hot adding memory to memoryless node and enabling a cpu 80 * on the node, node number of the cpu may internally change. 81 */ 82 to_nid = cpu_to_node(cpuid); 83 if (from_nid != to_nid) 84 change_cpu_under_node(cpu, from_nid, to_nid); 85 86 return ret; 87 } 88 89 static int cpu_subsys_offline(struct device *dev) 90 { 91 return cpu_device_down(dev); 92 } 93 94 void unregister_cpu(struct cpu *cpu) 95 { 96 int logical_cpu = cpu->dev.id; 97 98 set_cpu_enabled(logical_cpu, false); 99 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu)); 100 101 device_unregister(&cpu->dev); 102 per_cpu(cpu_sys_devices, logical_cpu) = NULL; 103 return; 104 } 105 106 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 107 static ssize_t cpu_probe_store(struct device *dev, 108 struct device_attribute *attr, 109 const char *buf, 110 size_t count) 111 { 112 ssize_t cnt; 113 int ret; 114 115 ret = lock_device_hotplug_sysfs(); 116 if (ret) 117 return ret; 118 119 cnt = arch_cpu_probe(buf, count); 120 121 unlock_device_hotplug(); 122 return cnt; 123 } 124 125 static ssize_t cpu_release_store(struct device *dev, 126 struct device_attribute *attr, 127 const char *buf, 128 size_t count) 129 { 130 ssize_t cnt; 131 int ret; 132 133 ret = lock_device_hotplug_sysfs(); 134 if (ret) 135 return ret; 136 137 cnt = arch_cpu_release(buf, count); 138 139 unlock_device_hotplug(); 140 return cnt; 141 } 142 143 static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store); 144 static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store); 145 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ 146 #endif /* CONFIG_HOTPLUG_CPU */ 147 148 #ifdef CONFIG_CRASH_DUMP 149 #include <linux/kexec.h> 150 151 static ssize_t crash_notes_show(struct device *dev, 152 struct device_attribute *attr, 153 char *buf) 154 { 155 struct cpu *cpu = container_of(dev, struct cpu, dev); 156 unsigned long long addr; 157 int cpunum; 158 159 cpunum = cpu->dev.id; 160 161 /* 162 * Might be reading other cpu's data based on which cpu read thread 163 * has been scheduled. But cpu data (memory) is allocated once during 164 * boot up and this data does not change there after. Hence this 165 * operation should be safe. No locking required. 166 */ 167 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum)); 168 169 return sysfs_emit(buf, "%llx\n", addr); 170 } 171 static DEVICE_ATTR_ADMIN_RO(crash_notes); 172 173 static ssize_t crash_notes_size_show(struct device *dev, 174 struct device_attribute *attr, 175 char *buf) 176 { 177 return sysfs_emit(buf, "%zu\n", sizeof(note_buf_t)); 178 } 179 static DEVICE_ATTR_ADMIN_RO(crash_notes_size); 180 181 static struct attribute *crash_note_cpu_attrs[] = { 182 &dev_attr_crash_notes.attr, 183 &dev_attr_crash_notes_size.attr, 184 NULL 185 }; 186 187 static const struct attribute_group crash_note_cpu_attr_group = { 188 .attrs = crash_note_cpu_attrs, 189 }; 190 #endif 191 192 static const struct attribute_group *common_cpu_attr_groups[] = { 193 #ifdef CONFIG_CRASH_DUMP 194 &crash_note_cpu_attr_group, 195 #endif 196 NULL 197 }; 198 199 static const struct attribute_group *hotplugable_cpu_attr_groups[] = { 200 #ifdef CONFIG_CRASH_DUMP 201 &crash_note_cpu_attr_group, 202 #endif 203 NULL 204 }; 205 206 /* 207 * Print cpu online, possible, present, and system maps 208 */ 209 210 struct cpu_attr { 211 struct device_attribute attr; 212 const struct cpumask *const map; 213 }; 214 215 static ssize_t show_cpus_attr(struct device *dev, 216 struct device_attribute *attr, 217 char *buf) 218 { 219 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr); 220 221 return sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(ca->map)); 222 } 223 224 #define _CPU_ATTR(name, map) \ 225 { __ATTR(name, 0444, show_cpus_attr, NULL), map } 226 227 /* Keep in sync with cpu_subsys_attrs */ 228 static struct cpu_attr cpu_attrs[] = { 229 _CPU_ATTR(online, &__cpu_online_mask), 230 _CPU_ATTR(possible, &__cpu_possible_mask), 231 _CPU_ATTR(present, &__cpu_present_mask), 232 }; 233 234 /* 235 * Print values for NR_CPUS and offlined cpus 236 */ 237 static ssize_t print_cpus_kernel_max(struct device *dev, 238 struct device_attribute *attr, char *buf) 239 { 240 return sysfs_emit(buf, "%d\n", NR_CPUS - 1); 241 } 242 static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL); 243 244 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */ 245 unsigned int total_cpus; 246 247 static ssize_t print_cpus_offline(struct device *dev, 248 struct device_attribute *attr, char *buf) 249 { 250 int len = 0; 251 cpumask_var_t offline; 252 253 /* display offline cpus < nr_cpu_ids */ 254 if (!alloc_cpumask_var(&offline, GFP_KERNEL)) 255 return -ENOMEM; 256 cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask); 257 len += sysfs_emit_at(buf, len, "%*pbl", cpumask_pr_args(offline)); 258 free_cpumask_var(offline); 259 260 /* display offline cpus >= nr_cpu_ids */ 261 if (total_cpus && nr_cpu_ids < total_cpus) { 262 len += sysfs_emit_at(buf, len, ","); 263 264 if (nr_cpu_ids == total_cpus-1) 265 len += sysfs_emit_at(buf, len, "%u", nr_cpu_ids); 266 else 267 len += sysfs_emit_at(buf, len, "%u-%d", 268 nr_cpu_ids, total_cpus - 1); 269 } 270 271 len += sysfs_emit_at(buf, len, "\n"); 272 273 return len; 274 } 275 static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL); 276 277 static ssize_t print_cpus_enabled(struct device *dev, 278 struct device_attribute *attr, char *buf) 279 { 280 return sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(cpu_enabled_mask)); 281 } 282 static DEVICE_ATTR(enabled, 0444, print_cpus_enabled, NULL); 283 284 static ssize_t print_cpus_isolated(struct device *dev, 285 struct device_attribute *attr, char *buf) 286 { 287 int len; 288 cpumask_var_t isolated; 289 290 if (!alloc_cpumask_var(&isolated, GFP_KERNEL)) 291 return -ENOMEM; 292 293 cpumask_andnot(isolated, cpu_possible_mask, 294 housekeeping_cpumask(HK_TYPE_DOMAIN_BOOT)); 295 len = sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(isolated)); 296 297 free_cpumask_var(isolated); 298 299 return len; 300 } 301 static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL); 302 303 static ssize_t housekeeping_show(struct device *dev, 304 struct device_attribute *attr, char *buf) 305 { 306 const struct cpumask *hk_mask; 307 308 hk_mask = housekeeping_cpumask(HK_TYPE_KERNEL_NOISE); 309 310 if (housekeeping_enabled(HK_TYPE_KERNEL_NOISE)) 311 return sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(hk_mask)); 312 return sysfs_emit(buf, "\n"); 313 } 314 static DEVICE_ATTR_RO(housekeeping); 315 316 #ifdef CONFIG_NO_HZ_FULL 317 static ssize_t nohz_full_show(struct device *dev, 318 struct device_attribute *attr, 319 char *buf) 320 { 321 if (cpumask_available(tick_nohz_full_mask)) 322 return sysfs_emit(buf, "%*pbl\n", 323 cpumask_pr_args(tick_nohz_full_mask)); 324 return sysfs_emit(buf, "\n"); 325 } 326 static DEVICE_ATTR_RO(nohz_full); 327 #endif 328 329 #ifdef CONFIG_CRASH_HOTPLUG 330 static ssize_t crash_hotplug_show(struct device *dev, 331 struct device_attribute *attr, 332 char *buf) 333 { 334 return sysfs_emit(buf, "%d\n", crash_check_hotplug_support()); 335 } 336 static DEVICE_ATTR_RO(crash_hotplug); 337 #endif 338 339 static void cpu_device_release(struct device *dev) 340 { 341 /* 342 * This is an empty function to prevent the driver core from spitting a 343 * warning at us. Yes, I know this is directly opposite of what the 344 * documentation for the driver core and kobjects say, and the author 345 * of this code has already been publicly ridiculed for doing 346 * something as foolish as this. However, at this point in time, it is 347 * the only way to handle the issue of statically allocated cpu 348 * devices. The different architectures will have their cpu device 349 * code reworked to properly handle this in the near future, so this 350 * function will then be changed to correctly free up the memory held 351 * by the cpu device. 352 * 353 * Never copy this way of doing things, or you too will be made fun of 354 * on the linux-kernel list, you have been warned. 355 */ 356 } 357 358 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 359 static ssize_t print_cpu_modalias(struct device *dev, 360 struct device_attribute *attr, 361 char *buf) 362 { 363 int len = 0; 364 u32 i; 365 366 len += sysfs_emit_at(buf, len, 367 "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:", 368 CPU_FEATURE_TYPEVAL); 369 370 for (i = 0; i < MAX_CPU_FEATURES; i++) 371 if (cpu_have_feature(i)) { 372 if (len + sizeof(",XXXX\n") >= PAGE_SIZE) { 373 WARN(1, "CPU features overflow page\n"); 374 break; 375 } 376 len += sysfs_emit_at(buf, len, ",%04X", i); 377 } 378 len += sysfs_emit_at(buf, len, "\n"); 379 return len; 380 } 381 382 static int cpu_uevent(const struct device *dev, struct kobj_uevent_env *env) 383 { 384 char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL); 385 if (buf) { 386 print_cpu_modalias(NULL, NULL, buf); 387 add_uevent_var(env, "MODALIAS=%s", buf); 388 kfree(buf); 389 } 390 return 0; 391 } 392 #endif 393 394 #ifdef CONFIG_PREFERRED_CPU 395 static ssize_t preferred_show(struct device *dev, 396 struct device_attribute *attr, char *buf) 397 { 398 return sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(cpu_preferred_mask)); 399 } 400 static DEVICE_ATTR_RO(preferred); 401 #endif 402 403 const struct bus_type cpu_subsys = { 404 .name = "cpu", 405 .dev_name = "cpu", 406 .match = cpu_subsys_match, 407 #ifdef CONFIG_HOTPLUG_CPU 408 .online = cpu_subsys_online, 409 .offline = cpu_subsys_offline, 410 #endif 411 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 412 .uevent = cpu_uevent, 413 #endif 414 }; 415 EXPORT_SYMBOL_GPL(cpu_subsys); 416 417 /* 418 * register_cpu - Setup a sysfs device for a CPU. 419 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in 420 * sysfs for this CPU. 421 * @num - CPU number to use when creating the device. 422 * 423 * Initialize and register the CPU device. 424 */ 425 int register_cpu(struct cpu *cpu, int num) 426 { 427 int error; 428 429 cpu->node_id = cpu_to_node(num); 430 memset(&cpu->dev, 0x00, sizeof(struct device)); 431 cpu->dev.id = num; 432 cpu->dev.bus = &cpu_subsys; 433 cpu->dev.release = cpu_device_release; 434 dev_assign_offline_disabled(&cpu->dev, !cpu->hotpluggable); 435 dev_assign_offline(&cpu->dev, !cpu_online(num)); 436 cpu->dev.of_node = of_get_cpu_node(num, NULL); 437 cpu->dev.groups = common_cpu_attr_groups; 438 if (cpu->hotpluggable) 439 cpu->dev.groups = hotplugable_cpu_attr_groups; 440 error = device_register(&cpu->dev); 441 if (error) { 442 put_device(&cpu->dev); 443 return error; 444 } 445 446 per_cpu(cpu_sys_devices, num) = &cpu->dev; 447 register_cpu_under_node(num, cpu_to_node(num)); 448 dev_pm_qos_expose_latency_limit(&cpu->dev, 449 PM_QOS_RESUME_LATENCY_NO_CONSTRAINT); 450 set_cpu_enabled(num, true); 451 452 return 0; 453 } 454 455 struct device *get_cpu_device(unsigned int cpu) 456 { 457 if (cpu < nr_cpu_ids && cpu_possible(cpu)) 458 return per_cpu(cpu_sys_devices, cpu); 459 else 460 return NULL; 461 } 462 EXPORT_SYMBOL_GPL(get_cpu_device); 463 464 static void device_create_release(struct device *dev) 465 { 466 kfree(dev); 467 } 468 469 __printf(4, 0) 470 static struct device * 471 __cpu_device_create(struct device *parent, void *drvdata, 472 const struct attribute_group **groups, 473 const char *fmt, va_list args) 474 { 475 struct device *dev = NULL; 476 int retval = -ENOMEM; 477 478 dev = kzalloc_obj(*dev); 479 if (!dev) 480 goto error; 481 482 device_initialize(dev); 483 dev->parent = parent; 484 dev->groups = groups; 485 dev->release = device_create_release; 486 device_set_pm_not_required(dev); 487 dev_set_drvdata(dev, drvdata); 488 489 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 490 if (retval) 491 goto error; 492 493 retval = device_add(dev); 494 if (retval) 495 goto error; 496 497 return dev; 498 499 error: 500 put_device(dev); 501 return ERR_PTR(retval); 502 } 503 504 struct device *cpu_device_create(struct device *parent, void *drvdata, 505 const struct attribute_group **groups, 506 const char *fmt, ...) 507 { 508 va_list vargs; 509 struct device *dev; 510 511 va_start(vargs, fmt); 512 dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs); 513 va_end(vargs); 514 return dev; 515 } 516 EXPORT_SYMBOL_GPL(cpu_device_create); 517 518 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 519 static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL); 520 #endif 521 522 static struct attribute *cpu_root_attrs[] = { 523 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 524 &dev_attr_probe.attr, 525 &dev_attr_release.attr, 526 #endif 527 &cpu_attrs[0].attr.attr, 528 &cpu_attrs[1].attr.attr, 529 &cpu_attrs[2].attr.attr, 530 &dev_attr_kernel_max.attr, 531 &dev_attr_offline.attr, 532 &dev_attr_enabled.attr, 533 &dev_attr_isolated.attr, 534 &dev_attr_housekeeping.attr, 535 #ifdef CONFIG_NO_HZ_FULL 536 &dev_attr_nohz_full.attr, 537 #endif 538 #ifdef CONFIG_CRASH_HOTPLUG 539 &dev_attr_crash_hotplug.attr, 540 #endif 541 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE 542 &dev_attr_modalias.attr, 543 #endif 544 #ifdef CONFIG_PREFERRED_CPU 545 &dev_attr_preferred.attr, 546 #endif 547 NULL 548 }; 549 550 static const struct attribute_group cpu_root_attr_group = { 551 .attrs = cpu_root_attrs, 552 }; 553 554 static const struct attribute_group *cpu_root_attr_groups[] = { 555 &cpu_root_attr_group, 556 NULL, 557 }; 558 559 bool cpu_is_hotpluggable(unsigned int cpu) 560 { 561 struct device *dev = get_cpu_device(cpu); 562 return dev && container_of(dev, struct cpu, dev)->hotpluggable 563 && tick_nohz_cpu_hotpluggable(cpu); 564 } 565 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable); 566 567 #ifdef CONFIG_GENERIC_CPU_DEVICES 568 DEFINE_PER_CPU(struct cpu, cpu_devices); 569 570 bool __weak arch_cpu_is_hotpluggable(int cpu) 571 { 572 return false; 573 } 574 575 int __weak arch_register_cpu(int cpu) 576 { 577 struct cpu *c = &per_cpu(cpu_devices, cpu); 578 579 c->hotpluggable = arch_cpu_is_hotpluggable(cpu); 580 581 return register_cpu(c, cpu); 582 } 583 584 #ifdef CONFIG_HOTPLUG_CPU 585 void __weak arch_unregister_cpu(int num) 586 { 587 unregister_cpu(&per_cpu(cpu_devices, num)); 588 } 589 #endif /* CONFIG_HOTPLUG_CPU */ 590 #endif /* CONFIG_GENERIC_CPU_DEVICES */ 591 592 static void __init cpu_dev_register_generic(void) 593 { 594 int i, ret; 595 596 if (!IS_ENABLED(CONFIG_GENERIC_CPU_DEVICES)) 597 return; 598 599 for_each_present_cpu(i) { 600 ret = arch_register_cpu(i); 601 if (ret && ret != -EPROBE_DEFER) 602 pr_warn("register_cpu %d failed (%d)\n", i, ret); 603 } 604 } 605 606 #ifdef CONFIG_GENERIC_CPU_VULNERABILITIES 607 static ssize_t cpu_show_not_affected(struct device *dev, 608 struct device_attribute *attr, char *buf) 609 { 610 return sysfs_emit(buf, "Not affected\n"); 611 } 612 613 #define CPU_SHOW_VULN_FALLBACK(func) \ 614 ssize_t cpu_show_##func(struct device *, \ 615 struct device_attribute *, char *) \ 616 __attribute__((weak, alias("cpu_show_not_affected"))) 617 618 CPU_SHOW_VULN_FALLBACK(meltdown); 619 CPU_SHOW_VULN_FALLBACK(spectre_v1); 620 CPU_SHOW_VULN_FALLBACK(spectre_v2); 621 CPU_SHOW_VULN_FALLBACK(spec_store_bypass); 622 CPU_SHOW_VULN_FALLBACK(l1tf); 623 CPU_SHOW_VULN_FALLBACK(mds); 624 CPU_SHOW_VULN_FALLBACK(tsx_async_abort); 625 CPU_SHOW_VULN_FALLBACK(itlb_multihit); 626 CPU_SHOW_VULN_FALLBACK(srbds); 627 CPU_SHOW_VULN_FALLBACK(mmio_stale_data); 628 CPU_SHOW_VULN_FALLBACK(retbleed); 629 CPU_SHOW_VULN_FALLBACK(spec_rstack_overflow); 630 CPU_SHOW_VULN_FALLBACK(gds); 631 CPU_SHOW_VULN_FALLBACK(reg_file_data_sampling); 632 CPU_SHOW_VULN_FALLBACK(ghostwrite); 633 CPU_SHOW_VULN_FALLBACK(old_microcode); 634 CPU_SHOW_VULN_FALLBACK(indirect_target_selection); 635 CPU_SHOW_VULN_FALLBACK(tsa); 636 CPU_SHOW_VULN_FALLBACK(vmscape); 637 638 static DEVICE_ATTR(meltdown, 0444, cpu_show_meltdown, NULL); 639 static DEVICE_ATTR(spectre_v1, 0444, cpu_show_spectre_v1, NULL); 640 static DEVICE_ATTR(spectre_v2, 0444, cpu_show_spectre_v2, NULL); 641 static DEVICE_ATTR(spec_store_bypass, 0444, cpu_show_spec_store_bypass, NULL); 642 static DEVICE_ATTR(l1tf, 0444, cpu_show_l1tf, NULL); 643 static DEVICE_ATTR(mds, 0444, cpu_show_mds, NULL); 644 static DEVICE_ATTR(tsx_async_abort, 0444, cpu_show_tsx_async_abort, NULL); 645 static DEVICE_ATTR(itlb_multihit, 0444, cpu_show_itlb_multihit, NULL); 646 static DEVICE_ATTR(srbds, 0444, cpu_show_srbds, NULL); 647 static DEVICE_ATTR(mmio_stale_data, 0444, cpu_show_mmio_stale_data, NULL); 648 static DEVICE_ATTR(retbleed, 0444, cpu_show_retbleed, NULL); 649 static DEVICE_ATTR(spec_rstack_overflow, 0444, cpu_show_spec_rstack_overflow, NULL); 650 static DEVICE_ATTR(gather_data_sampling, 0444, cpu_show_gds, NULL); 651 static DEVICE_ATTR(reg_file_data_sampling, 0444, cpu_show_reg_file_data_sampling, NULL); 652 static DEVICE_ATTR(ghostwrite, 0444, cpu_show_ghostwrite, NULL); 653 static DEVICE_ATTR(old_microcode, 0444, cpu_show_old_microcode, NULL); 654 static DEVICE_ATTR(indirect_target_selection, 0444, cpu_show_indirect_target_selection, NULL); 655 static DEVICE_ATTR(tsa, 0444, cpu_show_tsa, NULL); 656 static DEVICE_ATTR(vmscape, 0444, cpu_show_vmscape, NULL); 657 658 static struct attribute *cpu_root_vulnerabilities_attrs[] = { 659 &dev_attr_meltdown.attr, 660 &dev_attr_spectre_v1.attr, 661 &dev_attr_spectre_v2.attr, 662 &dev_attr_spec_store_bypass.attr, 663 &dev_attr_l1tf.attr, 664 &dev_attr_mds.attr, 665 &dev_attr_tsx_async_abort.attr, 666 &dev_attr_itlb_multihit.attr, 667 &dev_attr_srbds.attr, 668 &dev_attr_mmio_stale_data.attr, 669 &dev_attr_retbleed.attr, 670 &dev_attr_spec_rstack_overflow.attr, 671 &dev_attr_gather_data_sampling.attr, 672 &dev_attr_reg_file_data_sampling.attr, 673 &dev_attr_ghostwrite.attr, 674 &dev_attr_old_microcode.attr, 675 &dev_attr_indirect_target_selection.attr, 676 &dev_attr_tsa.attr, 677 &dev_attr_vmscape.attr, 678 NULL 679 }; 680 681 static const struct attribute_group cpu_root_vulnerabilities_group = { 682 .name = "vulnerabilities", 683 .attrs = cpu_root_vulnerabilities_attrs, 684 }; 685 686 static void __init cpu_register_vulnerabilities(void) 687 { 688 struct device *dev = bus_get_dev_root(&cpu_subsys); 689 690 if (dev) { 691 if (sysfs_create_group(&dev->kobj, &cpu_root_vulnerabilities_group)) 692 pr_err("Unable to register CPU vulnerabilities\n"); 693 put_device(dev); 694 } 695 } 696 697 #else 698 static inline void cpu_register_vulnerabilities(void) { } 699 #endif 700 701 void __init cpu_dev_init(void) 702 { 703 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups)) 704 panic("Failed to register CPU subsystem"); 705 706 cpu_dev_register_generic(); 707 cpu_register_vulnerabilities(); 708 } 709