drivers/base/cpu.c

   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 #ifdef CONFIG_HOTPLUG_CPU
 184
 185 static ssize_t isolate_show(struct device *dev,
 186                             struct device_attribute *attr, char *buf)
 187 {
 188         struct cpu *cpu = container_of(dev, struct cpu, dev);
 189         ssize_t rc;
 190         int cpuid = cpu->dev.id;
 191         unsigned int isolated = cpu_isolated(cpuid);
 192
 193         rc = snprintf(buf, PAGE_SIZE-2, "%d\n", isolated);
 194
 195         return rc;
 196 }
 197
 198 static DEVICE_ATTR_RO(isolate);
 199
 200 static struct attribute *cpu_isolated_attrs[] = {
 201         &dev_attr_isolate.attr,
 202         NULL
 203 };
 204
 205 static struct attribute_group cpu_isolated_attr_group = {
 206         .attrs = cpu_isolated_attrs,
 207 };
 208
 209 #endif
 210
 211 #ifdef CONFIG_SCHED_HMP
 212
 213 static ssize_t show_sched_static_cpu_pwr_cost(struct device *dev,
 214                                 struct device_attribute *attr, char *buf)
 215 {
 216         struct cpu *cpu = container_of(dev, struct cpu, dev);
 217         ssize_t rc;
 218         int cpuid = cpu->dev.id;
 219         unsigned int pwr_cost;
 220
 221         pwr_cost = sched_get_static_cpu_pwr_cost(cpuid);
 222
 223         rc = snprintf(buf, PAGE_SIZE-2, "%d\n", pwr_cost);
 224
 225         return rc;
 226 }
 227
 228 static ssize_t __ref store_sched_static_cpu_pwr_cost(struct device *dev,
 229                                 struct device_attribute *attr,
 230                                 const char *buf, size_t count)
 231 {
 232         struct cpu *cpu = container_of(dev, struct cpu, dev);
 233         int err;
 234         int cpuid = cpu->dev.id;
 235         unsigned int pwr_cost;
 236
 237         err = kstrtouint(strstrip((char *)buf), 0, &pwr_cost);
 238         if (err)
 239                 return err;
 240
 241         err = sched_set_static_cpu_pwr_cost(cpuid, pwr_cost);
 242
 243         if (err >= 0)
 244                 err = count;
 245
 246         return err;
 247 }
 248
 249 static ssize_t show_sched_static_cluster_pwr_cost(struct device *dev,
 250                                 struct device_attribute *attr, char *buf)
 251 {
 252         struct cpu *cpu = container_of(dev, struct cpu, dev);
 253         ssize_t rc;
 254         int cpuid = cpu->dev.id;
 255         unsigned int pwr_cost;
 256
 257         pwr_cost = sched_get_static_cluster_pwr_cost(cpuid);
 258
 259         rc = snprintf(buf, PAGE_SIZE-2, "%d\n", pwr_cost);
 260
 261         return rc;
 262 }
 263
 264 static ssize_t __ref store_sched_static_cluster_pwr_cost(struct device *dev,
 265                                 struct device_attribute *attr,
 266                                 const char *buf, size_t count)
 267 {
 268         struct cpu *cpu = container_of(dev, struct cpu, dev);
 269         int err;
 270         int cpuid = cpu->dev.id;
 271         unsigned int pwr_cost;
 272
 273         err = kstrtouint(strstrip((char *)buf), 0, &pwr_cost);
 274         if (err)
 275                 return err;
 276
 277         err = sched_set_static_cluster_pwr_cost(cpuid, pwr_cost);
 278
 279         if (err >= 0)
 280                 err = count;
 281
 282         return err;
 283 }
 284
 285 static ssize_t show_sched_cluser_wake_idle(struct device *dev,
 286                                 struct device_attribute *attr, char *buf)
 287 {
 288         struct cpu *cpu = container_of(dev, struct cpu, dev);
 289         ssize_t rc;
 290         int cpuid = cpu->dev.id;
 291         unsigned int wake_up_idle;
 292
 293         wake_up_idle = sched_get_cluster_wake_idle(cpuid);
 294
 295         rc = scnprintf(buf, PAGE_SIZE-2, "%d\n", wake_up_idle);
 296
 297         return rc;
 298 }
 299
 300 static ssize_t __ref store_sched_cluster_wake_idle(struct device *dev,
 301                                 struct device_attribute *attr,
 302                                 const char *buf, size_t count)
 303 {
 304         struct cpu *cpu = container_of(dev, struct cpu, dev);
 305         int err;
 306         int cpuid = cpu->dev.id;
 307         unsigned int wake_up_idle;
 308
 309         err = kstrtouint(strstrip((char *)buf), 0, &wake_up_idle);
 310         if (err)
 311                 return err;
 312
 313         err = sched_set_cluster_wake_idle(cpuid, wake_up_idle);
 314
 315         if (err >= 0)
 316                 err = count;
 317
 318         return err;
 319 }
 320
 321 static DEVICE_ATTR(sched_static_cpu_pwr_cost, 0644,
 322                                         show_sched_static_cpu_pwr_cost,
 323                                         store_sched_static_cpu_pwr_cost);
 324 static DEVICE_ATTR(sched_static_cluster_pwr_cost, 0644,
 325                                         show_sched_static_cluster_pwr_cost,
 326                                         store_sched_static_cluster_pwr_cost);
 327 static DEVICE_ATTR(sched_cluster_wake_up_idle, 0644,
 328                                         show_sched_cluser_wake_idle,
 329                                         store_sched_cluster_wake_idle);
 330
 331 static struct attribute *hmp_sched_cpu_attrs[] = {
 332         &dev_attr_sched_static_cpu_pwr_cost.attr,
 333         &dev_attr_sched_static_cluster_pwr_cost.attr,
 334         &dev_attr_sched_cluster_wake_up_idle.attr,
 335         NULL
 336 };
 337
 338 static struct attribute_group sched_hmp_cpu_attr_group = {
 339         .attrs = hmp_sched_cpu_attrs,
 340 };
 341
 342 #endif /* CONFIG_SCHED_HMP */
 343
 344 static const struct attribute_group *common_cpu_attr_groups[] = {
 345 #ifdef CONFIG_KEXEC
 346         &crash_note_cpu_attr_group,
 347 #endif
 348 #ifdef CONFIG_SCHED_HMP
 349         &sched_hmp_cpu_attr_group,
 350 #endif
 351 #ifdef CONFIG_HOTPLUG_CPU
 352         &cpu_isolated_attr_group,
 353 #endif
 354         NULL
 355 };
 356
 357 static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
 358 #ifdef CONFIG_KEXEC
 359         &crash_note_cpu_attr_group,
 360 #endif
 361 #ifdef CONFIG_SCHED_HMP
 362         &sched_hmp_cpu_attr_group,
 363 #endif
 364 #ifdef CONFIG_HOTPLUG_CPU
 365         &cpu_isolated_attr_group,
 366 #endif
 367         NULL
 368 };
 369
 370 /*
 371  * Print cpu online, possible, present, and system maps
 372  */
 373
 374 struct cpu_attr {
 375         struct device_attribute attr;
 376         const struct cpumask *const * const map;
 377 };
 378
 379 static ssize_t show_cpus_attr(struct device *dev,
 380                               struct device_attribute *attr,
 381                               char *buf)
 382 {
 383         struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
 384
 385         return cpumap_print_to_pagebuf(true, buf, *ca->map);
 386 }
 387
 388 #define _CPU_ATTR(name, map) \
 389         { __ATTR(name, 0444, show_cpus_attr, NULL), map }
 390
 391 /* Keep in sync with cpu_subsys_attrs */
 392 static struct cpu_attr cpu_attrs[] = {
 393         _CPU_ATTR(online, &cpu_online_mask),
 394         _CPU_ATTR(possible, &cpu_possible_mask),
 395         _CPU_ATTR(present, &cpu_present_mask),
 396         _CPU_ATTR(core_ctl_isolated, &cpu_isolated_mask),
 397 };
 398
 399 /*
 400  * Print values for NR_CPUS and offlined cpus
 401  */
 402 static ssize_t print_cpus_kernel_max(struct device *dev,
 403                                      struct device_attribute *attr, char *buf)
 404 {
 405         int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
 406         return n;
 407 }
 408 static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
 409
 410 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
 411 unsigned int total_cpus;
 412
 413 static ssize_t print_cpus_offline(struct device *dev,
 414                                   struct device_attribute *attr, char *buf)
 415 {
 416         int n = 0, len = PAGE_SIZE-2;
 417         cpumask_var_t offline;
 418
 419         /* display offline cpus < nr_cpu_ids */
 420         if (!alloc_cpumask_var(&offline, GFP_KERNEL))
 421                 return -ENOMEM;
 422         cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
 423         n = scnprintf(buf, len, "%*pbl", cpumask_pr_args(offline));
 424         free_cpumask_var(offline);
 425
 426         /* display offline cpus >= nr_cpu_ids */
 427         if (total_cpus && nr_cpu_ids < total_cpus) {
 428                 if (n && n < len)
 429                         buf[n++] = ',';
 430
 431                 if (nr_cpu_ids == total_cpus-1)
 432                         n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
 433                 else
 434                         n += snprintf(&buf[n], len - n, "%d-%d",
 435                                                       nr_cpu_ids, total_cpus-1);
 436         }
 437
 438         n += snprintf(&buf[n], len - n, "\n");
 439         return n;
 440 }
 441 static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
 442
 443 static ssize_t print_cpus_isolated(struct device *dev,
 444                                   struct device_attribute *attr, char *buf)
 445 {
 446         int n = 0, len = PAGE_SIZE-2;
 447
 448         n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(cpu_isolated_map));
 449
 450         return n;
 451 }
 452 static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL);
 453
 454 #ifdef CONFIG_NO_HZ_FULL
 455 static ssize_t print_cpus_nohz_full(struct device *dev,
 456                                   struct device_attribute *attr, char *buf)
 457 {
 458         int n = 0, len = PAGE_SIZE-2;
 459
 460         n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask));
 461
 462         return n;
 463 }
 464 static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL);
 465 #endif
 466
 467 static void cpu_device_release(struct device *dev)
 468 {
 469         /*
 470          * This is an empty function to prevent the driver core from spitting a
 471          * warning at us.  Yes, I know this is directly opposite of what the
 472          * documentation for the driver core and kobjects say, and the author
 473          * of this code has already been publically ridiculed for doing
 474          * something as foolish as this.  However, at this point in time, it is
 475          * the only way to handle the issue of statically allocated cpu
 476          * devices.  The different architectures will have their cpu device
 477          * code reworked to properly handle this in the near future, so this
 478          * function will then be changed to correctly free up the memory held
 479          * by the cpu device.
 480          *
 481          * Never copy this way of doing things, or you too will be made fun of
 482          * on the linux-kernel list, you have been warned.
 483          */
 484 }
 485
 486 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
 487 static ssize_t print_cpu_modalias(struct device *dev,
 488                                   struct device_attribute *attr,
 489                                   char *buf)
 490 {
 491         ssize_t n;
 492         u32 i;
 493
 494         n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
 495                     CPU_FEATURE_TYPEVAL);
 496
 497         for (i = 0; i < MAX_CPU_FEATURES; i++)
 498                 if (cpu_have_feature(i)) {
 499                         if (PAGE_SIZE < n + sizeof(",XXXX\n")) {
 500                                 WARN(1, "CPU features overflow page\n");
 501                                 break;
 502                         }
 503                         n += sprintf(&buf[n], ",%04X", i);
 504                 }
 505         buf[n++] = '\n';
 506         return n;
 507 }
 508
 509 static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env)
 510 {
 511         char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
 512         if (buf) {
 513                 print_cpu_modalias(NULL, NULL, buf);
 514                 add_uevent_var(env, "MODALIAS=%s", buf);
 515                 kfree(buf);
 516         }
 517         return 0;
 518 }
 519 #endif
 520
 521 /*
 522  * register_cpu - Setup a sysfs device for a CPU.
 523  * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
 524  *        sysfs for this CPU.
 525  * @num - CPU number to use when creating the device.
 526  *
 527  * Initialize and register the CPU device.
 528  */
 529 int register_cpu(struct cpu *cpu, int num)
 530 {
 531         int error;
 532
 533         cpu->node_id = cpu_to_node(num);
 534         memset(&cpu->dev, 0x00, sizeof(struct device));
 535         cpu->dev.id = num;
 536         cpu->dev.bus = &cpu_subsys;
 537         cpu->dev.release = cpu_device_release;
 538         cpu->dev.offline_disabled = !cpu->hotpluggable;
 539         cpu->dev.offline = !cpu_online(num);
 540         cpu->dev.of_node = of_get_cpu_node(num, NULL);
 541 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
 542         cpu->dev.bus->uevent = cpu_uevent;
 543 #endif
 544         cpu->dev.groups = common_cpu_attr_groups;
 545         if (cpu->hotpluggable)
 546                 cpu->dev.groups = hotplugable_cpu_attr_groups;
 547         error = device_register(&cpu->dev);
 548         if (!error)
 549                 per_cpu(cpu_sys_devices, num) = &cpu->dev;
 550         if (!error)
 551                 register_cpu_under_node(num, cpu_to_node(num));
 552
 553         return error;
 554 }
 555
 556 struct device *get_cpu_device(unsigned cpu)
 557 {
 558         if (cpu < nr_cpu_ids && cpu_possible(cpu))
 559                 return per_cpu(cpu_sys_devices, cpu);
 560         else
 561                 return NULL;
 562 }
 563 EXPORT_SYMBOL_GPL(get_cpu_device);
 564
 565 static void device_create_release(struct device *dev)
 566 {
 567         kfree(dev);
 568 }
 569
 570 static struct device *
 571 __cpu_device_create(struct device *parent, void *drvdata,
 572                     const struct attribute_group **groups,
 573                     const char *fmt, va_list args)
 574 {
 575         struct device *dev = NULL;
 576         int retval = -ENODEV;
 577
 578         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 579         if (!dev) {
 580                 retval = -ENOMEM;
 581                 goto error;
 582         }
 583
 584         device_initialize(dev);
 585         dev->parent = parent;
 586         dev->groups = groups;
 587         dev->release = device_create_release;
 588         dev_set_drvdata(dev, drvdata);
 589
 590         retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
 591         if (retval)
 592                 goto error;
 593
 594         retval = device_add(dev);
 595         if (retval)
 596                 goto error;
 597
 598         return dev;
 599
 600 error:
 601         put_device(dev);
 602         return ERR_PTR(retval);
 603 }
 604
 605 struct device *cpu_device_create(struct device *parent, void *drvdata,
 606                                  const struct attribute_group **groups,
 607                                  const char *fmt, ...)
 608 {
 609         va_list vargs;
 610         struct device *dev;
 611
 612         va_start(vargs, fmt);
 613         dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs);
 614         va_end(vargs);
 615         return dev;
 616 }
 617 EXPORT_SYMBOL_GPL(cpu_device_create);
 618
 619 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
 620 static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
 621 #endif
 622
 623 static struct attribute *cpu_root_attrs[] = {
 624 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
 625         &dev_attr_probe.attr,
 626         &dev_attr_release.attr,
 627 #endif
 628         &cpu_attrs[0].attr.attr,
 629         &cpu_attrs[1].attr.attr,
 630         &cpu_attrs[2].attr.attr,
 631         &cpu_attrs[3].attr.attr,
 632         &dev_attr_kernel_max.attr,
 633         &dev_attr_offline.attr,
 634         &dev_attr_isolated.attr,
 635 #ifdef CONFIG_NO_HZ_FULL
 636         &dev_attr_nohz_full.attr,
 637 #endif
 638 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
 639         &dev_attr_modalias.attr,
 640 #endif
 641         NULL
 642 };
 643
 644 static struct attribute_group cpu_root_attr_group = {
 645         .attrs = cpu_root_attrs,
 646 };
 647
 648 static const struct attribute_group *cpu_root_attr_groups[] = {
 649         &cpu_root_attr_group,
 650         NULL,
 651 };
 652
 653 bool cpu_is_hotpluggable(unsigned cpu)
 654 {
 655         struct device *dev = get_cpu_device(cpu);
 656         return dev && container_of(dev, struct cpu, dev)->hotpluggable;
 657 }
 658 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
 659
 660 #ifdef CONFIG_GENERIC_CPU_DEVICES
 661 static DEFINE_PER_CPU(struct cpu, cpu_devices);
 662 #endif
 663
 664 static void __init cpu_dev_register_generic(void)
 665 {
 666 #ifdef CONFIG_GENERIC_CPU_DEVICES
 667         int i;
 668
 669         for_each_possible_cpu(i) {
 670                 if (register_cpu(&per_cpu(cpu_devices, i), i))
 671                         panic("Failed to register CPU device");
 672         }
 673 #endif
 674 }
 675
 676 #ifdef CONFIG_GENERIC_CPU_VULNERABILITIES
 677
 678 ssize_t __weak cpu_show_meltdown(struct device *dev,
 679                                  struct device_attribute *attr, char *buf)
 680 {
 681         return sprintf(buf, "Not affected\n");
 682 }
 683
 684 ssize_t __weak cpu_show_spectre_v1(struct device *dev,
 685                                    struct device_attribute *attr, char *buf)
 686 {
 687         return sprintf(buf, "Not affected\n");
 688 }
 689
 690 ssize_t __weak cpu_show_spectre_v2(struct device *dev,
 691                                    struct device_attribute *attr, char *buf)
 692 {
 693         return sprintf(buf, "Not affected\n");
 694 }
 695
 696 ssize_t __weak cpu_show_spec_store_bypass(struct device *dev,
 697                                           struct device_attribute *attr, char *buf)
 698 {
 699         return sprintf(buf, "Not affected\n");
 700 }
 701
 702 ssize_t __weak cpu_show_l1tf(struct device *dev,
 703                              struct device_attribute *attr, char *buf)
 704 {
 705         return sprintf(buf, "Not affected\n");
 706 }
 707
 708 ssize_t __weak cpu_show_mds(struct device *dev,
 709                             struct device_attribute *attr, char *buf)
 710 {
 711         return sprintf(buf, "Not affected\n");
 712 }
 713
 714 static DEVICE_ATTR(meltdown, 0444, cpu_show_meltdown, NULL);
 715 static DEVICE_ATTR(spectre_v1, 0444, cpu_show_spectre_v1, NULL);
 716 static DEVICE_ATTR(spectre_v2, 0444, cpu_show_spectre_v2, NULL);
 717 static DEVICE_ATTR(spec_store_bypass, 0444, cpu_show_spec_store_bypass, NULL);
 718 static DEVICE_ATTR(l1tf, 0444, cpu_show_l1tf, NULL);
 719 static DEVICE_ATTR(mds, 0444, cpu_show_mds, NULL);
 720
 721 static struct attribute *cpu_root_vulnerabilities_attrs[] = {
 722         &dev_attr_meltdown.attr,
 723         &dev_attr_spectre_v1.attr,
 724         &dev_attr_spectre_v2.attr,
 725         &dev_attr_spec_store_bypass.attr,
 726         &dev_attr_l1tf.attr,
 727         &dev_attr_mds.attr,
 728         NULL
 729 };
 730
 731 static const struct attribute_group cpu_root_vulnerabilities_group = {
 732         .name  = "vulnerabilities",
 733         .attrs = cpu_root_vulnerabilities_attrs,
 734 };
 735
 736 static void __init cpu_register_vulnerabilities(void)
 737 {
 738         if (sysfs_create_group(&cpu_subsys.dev_root->kobj,
 739                                &cpu_root_vulnerabilities_group))
 740                 pr_err("Unable to register CPU vulnerabilities\n");
 741 }
 742
 743 #else
 744 static inline void cpu_register_vulnerabilities(void) { }
 745 #endif
 746
 747 void __init cpu_dev_init(void)
 748 {
 749         if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
 750                 panic("Failed to register CPU subsystem");
 751
 752         cpu_dev_register_generic();
 753         cpu_register_vulnerabilities();
 754 }