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