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 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 #ifdef CONFIG_GENERIC_CPU_VULNERABILITIES
 502
 503 ssize_t __weak cpu_show_meltdown(struct device *dev,
 504                                  struct device_attribute *attr, char *buf)
 505 {
 506         return sprintf(buf, "Not affected\n");
 507 }
 508
 509 ssize_t __weak cpu_show_spectre_v1(struct device *dev,
 510                                    struct device_attribute *attr, char *buf)
 511 {
 512         return sprintf(buf, "Not affected\n");
 513 }
 514
 515 ssize_t __weak cpu_show_spectre_v2(struct device *dev,
 516                                    struct device_attribute *attr, char *buf)
 517 {
 518         return sprintf(buf, "Not affected\n");
 519 }
 520
 521 ssize_t __weak cpu_show_spec_store_bypass(struct device *dev,
 522                                           struct device_attribute *attr, char *buf)
 523 {
 524         return sprintf(buf, "Not affected\n");
 525 }
 526
 527 ssize_t __weak cpu_show_l1tf(struct device *dev,
 528                              struct device_attribute *attr, char *buf)
 529 {
 530         return sprintf(buf, "Not affected\n");
 531 }
 532
 533 static DEVICE_ATTR(meltdown, 0444, cpu_show_meltdown, NULL);
 534 static DEVICE_ATTR(spectre_v1, 0444, cpu_show_spectre_v1, NULL);
 535 static DEVICE_ATTR(spectre_v2, 0444, cpu_show_spectre_v2, NULL);
 536 static DEVICE_ATTR(spec_store_bypass, 0444, cpu_show_spec_store_bypass, NULL);
 537 static DEVICE_ATTR(l1tf, 0444, cpu_show_l1tf, NULL);
 538
 539 static struct attribute *cpu_root_vulnerabilities_attrs[] = {
 540         &dev_attr_meltdown.attr,
 541         &dev_attr_spectre_v1.attr,
 542         &dev_attr_spectre_v2.attr,
 543         &dev_attr_spec_store_bypass.attr,
 544         &dev_attr_l1tf.attr,
 545         NULL
 546 };
 547
 548 static const struct attribute_group cpu_root_vulnerabilities_group = {
 549         .name  = "vulnerabilities",
 550         .attrs = cpu_root_vulnerabilities_attrs,
 551 };
 552
 553 static void __init cpu_register_vulnerabilities(void)
 554 {
 555         if (sysfs_create_group(&cpu_subsys.dev_root->kobj,
 556                                &cpu_root_vulnerabilities_group))
 557                 pr_err("Unable to register CPU vulnerabilities\n");
 558 }
 559
 560 #else
 561 static inline void cpu_register_vulnerabilities(void) { }
 562 #endif
 563
 564 void __init cpu_dev_init(void)
 565 {
 566         if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
 567                 panic("Failed to register CPU subsystem");
 568
 569         cpu_dev_register_generic();
 570         cpu_register_vulnerabilities();
 571 }