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
  19 #include "base.h"
  20
  21 static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
  22
  23 static int cpu_subsys_match(struct device *dev, struct device_driver *drv)
  24 {
  25         /* ACPI style match is the only one that may succeed. */
  26         if (acpi_driver_match_device(dev, drv))
  27                 return 1;
  28
  29         return 0;
  30 }
  31
  32 #ifdef CONFIG_HOTPLUG_CPU
  33 static void change_cpu_under_node(struct cpu *cpu,
  34                         unsigned int from_nid, unsigned int to_nid)
  35 {
  36         int cpuid = cpu->dev.id;
  37         unregister_cpu_under_node(cpuid, from_nid);
  38         register_cpu_under_node(cpuid, to_nid);
  39         cpu->node_id = to_nid;
  40 }
  41
  42 static int __ref cpu_subsys_online(struct device *dev)
  43 {
  44         struct cpu *cpu = container_of(dev, struct cpu, dev);
  45         int cpuid = dev->id;
  46         int from_nid, to_nid;
  47         int ret;
  48
  49         cpu_hotplug_driver_lock();
  50
  51         from_nid = cpu_to_node(cpuid);
  52         ret = cpu_up(cpuid);
  53         /*
  54          * When hot adding memory to memoryless node and enabling a cpu
  55          * on the node, node number of the cpu may internally change.
  56          */
  57         to_nid = cpu_to_node(cpuid);
  58         if (from_nid != to_nid)
  59                 change_cpu_under_node(cpu, from_nid, to_nid);
  60
  61         cpu_hotplug_driver_unlock();
  62         return ret;
  63 }
  64
  65 static int cpu_subsys_offline(struct device *dev)
  66 {
  67         int ret;
  68
  69         cpu_hotplug_driver_lock();
  70         ret = cpu_down(dev->id);
  71         cpu_hotplug_driver_unlock();
  72         return ret;
  73 }
  74
  75 void unregister_cpu(struct cpu *cpu)
  76 {
  77         int logical_cpu = cpu->dev.id;
  78
  79         unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
  80
  81         device_unregister(&cpu->dev);
  82         per_cpu(cpu_sys_devices, logical_cpu) = NULL;
  83         return;
  84 }
  85
  86 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
  87 static ssize_t cpu_probe_store(struct device *dev,
  88                                struct device_attribute *attr,
  89                                const char *buf,
  90                                size_t count)
  91 {
  92         return arch_cpu_probe(buf, count);
  93 }
  94
  95 static ssize_t cpu_release_store(struct device *dev,
  96                                  struct device_attribute *attr,
  97                                  const char *buf,
  98                                  size_t count)
  99 {
 100         return arch_cpu_release(buf, count);
 101 }
 102
 103 static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
 104 static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
 105 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
 106 #endif /* CONFIG_HOTPLUG_CPU */
 107
 108 struct bus_type cpu_subsys = {
 109         .name = "cpu",
 110         .dev_name = "cpu",
 111         .match = cpu_subsys_match,
 112 #ifdef CONFIG_HOTPLUG_CPU
 113         .online = cpu_subsys_online,
 114         .offline = cpu_subsys_offline,
 115 #endif
 116 };
 117 EXPORT_SYMBOL_GPL(cpu_subsys);
 118
 119 #ifdef CONFIG_KEXEC
 120 #include <linux/kexec.h>
 121
 122 static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
 123                                 char *buf)
 124 {
 125         struct cpu *cpu = container_of(dev, struct cpu, dev);
 126         ssize_t rc;
 127         unsigned long long addr;
 128         int cpunum;
 129
 130         cpunum = cpu->dev.id;
 131
 132         /*
 133          * Might be reading other cpu's data based on which cpu read thread
 134          * has been scheduled. But cpu data (memory) is allocated once during
 135          * boot up and this data does not change there after. Hence this
 136          * operation should be safe. No locking required.
 137          */
 138         addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
 139         rc = sprintf(buf, "%Lx\n", addr);
 140         return rc;
 141 }
 142 static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
 143
 144 static ssize_t show_crash_notes_size(struct device *dev,
 145                                      struct device_attribute *attr,
 146                                      char *buf)
 147 {
 148         ssize_t rc;
 149
 150         rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
 151         return rc;
 152 }
 153 static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
 154
 155 static struct attribute *crash_note_cpu_attrs[] = {
 156         &dev_attr_crash_notes.attr,
 157         &dev_attr_crash_notes_size.attr,
 158         NULL
 159 };
 160
 161 static struct attribute_group crash_note_cpu_attr_group = {
 162         .attrs = crash_note_cpu_attrs,
 163 };
 164 #endif
 165
 166 static const struct attribute_group *common_cpu_attr_groups[] = {
 167 #ifdef CONFIG_KEXEC
 168         &crash_note_cpu_attr_group,
 169 #endif
 170         NULL
 171 };
 172
 173 static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
 174 #ifdef CONFIG_KEXEC
 175         &crash_note_cpu_attr_group,
 176 #endif
 177         NULL
 178 };
 179
 180 /*
 181  * Print cpu online, possible, present, and system maps
 182  */
 183
 184 struct cpu_attr {
 185         struct device_attribute attr;
 186         const struct cpumask *const * const map;
 187 };
 188
 189 static ssize_t show_cpus_attr(struct device *dev,
 190                               struct device_attribute *attr,
 191                               char *buf)
 192 {
 193         struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
 194         int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *(ca->map));
 195
 196         buf[n++] = '\n';
 197         buf[n] = '\0';
 198         return n;
 199 }
 200
 201 #define _CPU_ATTR(name, map) \
 202         { __ATTR(name, 0444, show_cpus_attr, NULL), map }
 203
 204 /* Keep in sync with cpu_subsys_attrs */
 205 static struct cpu_attr cpu_attrs[] = {
 206         _CPU_ATTR(online, &cpu_online_mask),
 207         _CPU_ATTR(possible, &cpu_possible_mask),
 208         _CPU_ATTR(present, &cpu_present_mask),
 209 };
 210
 211 /*
 212  * Print values for NR_CPUS and offlined cpus
 213  */
 214 static ssize_t print_cpus_kernel_max(struct device *dev,
 215                                      struct device_attribute *attr, char *buf)
 216 {
 217         int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
 218         return n;
 219 }
 220 static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
 221
 222 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
 223 unsigned int total_cpus;
 224
 225 static ssize_t print_cpus_offline(struct device *dev,
 226                                   struct device_attribute *attr, char *buf)
 227 {
 228         int n = 0, len = PAGE_SIZE-2;
 229         cpumask_var_t offline;
 230
 231         /* display offline cpus < nr_cpu_ids */
 232         if (!alloc_cpumask_var(&offline, GFP_KERNEL))
 233                 return -ENOMEM;
 234         cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
 235         n = cpulist_scnprintf(buf, len, offline);
 236         free_cpumask_var(offline);
 237
 238         /* display offline cpus >= nr_cpu_ids */
 239         if (total_cpus && nr_cpu_ids < total_cpus) {
 240                 if (n && n < len)
 241                         buf[n++] = ',';
 242
 243                 if (nr_cpu_ids == total_cpus-1)
 244                         n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
 245                 else
 246                         n += snprintf(&buf[n], len - n, "%d-%d",
 247                                                       nr_cpu_ids, total_cpus-1);
 248         }
 249
 250         n += snprintf(&buf[n], len - n, "\n");
 251         return n;
 252 }
 253 static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
 254
 255 static void cpu_device_release(struct device *dev)
 256 {
 257         /*
 258          * This is an empty function to prevent the driver core from spitting a
 259          * warning at us.  Yes, I know this is directly opposite of what the
 260          * documentation for the driver core and kobjects say, and the author
 261          * of this code has already been publically ridiculed for doing
 262          * something as foolish as this.  However, at this point in time, it is
 263          * the only way to handle the issue of statically allocated cpu
 264          * devices.  The different architectures will have their cpu device
 265          * code reworked to properly handle this in the near future, so this
 266          * function will then be changed to correctly free up the memory held
 267          * by the cpu device.
 268          *
 269          * Never copy this way of doing things, or you too will be made fun of
 270          * on the linux-kernel list, you have been warned.
 271          */
 272 }
 273
 274 /*
 275  * register_cpu - Setup a sysfs device for a CPU.
 276  * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
 277  *        sysfs for this CPU.
 278  * @num - CPU number to use when creating the device.
 279  *
 280  * Initialize and register the CPU device.
 281  */
 282 int register_cpu(struct cpu *cpu, int num)
 283 {
 284         int error;
 285
 286         cpu->node_id = cpu_to_node(num);
 287         memset(&cpu->dev, 0x00, sizeof(struct device));
 288         cpu->dev.id = num;
 289         cpu->dev.bus = &cpu_subsys;
 290         cpu->dev.release = cpu_device_release;
 291         cpu->dev.offline_disabled = !cpu->hotpluggable;
 292         cpu->dev.offline = !cpu_online(num);
 293         cpu->dev.of_node = of_get_cpu_node(num, NULL);
 294 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
 295         cpu->dev.bus->uevent = arch_cpu_uevent;
 296 #endif
 297         cpu->dev.groups = common_cpu_attr_groups;
 298         if (cpu->hotpluggable)
 299                 cpu->dev.groups = hotplugable_cpu_attr_groups;
 300         error = device_register(&cpu->dev);
 301         if (!error)
 302                 per_cpu(cpu_sys_devices, num) = &cpu->dev;
 303         if (!error)
 304                 register_cpu_under_node(num, cpu_to_node(num));
 305
 306         return error;
 307 }
 308
 309 struct device *get_cpu_device(unsigned cpu)
 310 {
 311         if (cpu < nr_cpu_ids && cpu_possible(cpu))
 312                 return per_cpu(cpu_sys_devices, cpu);
 313         else
 314                 return NULL;
 315 }
 316 EXPORT_SYMBOL_GPL(get_cpu_device);
 317
 318 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
 319 static DEVICE_ATTR(modalias, 0444, arch_print_cpu_modalias, NULL);
 320 #endif
 321
 322 static struct attribute *cpu_root_attrs[] = {
 323 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
 324         &dev_attr_probe.attr,
 325         &dev_attr_release.attr,
 326 #endif
 327         &cpu_attrs[0].attr.attr,
 328         &cpu_attrs[1].attr.attr,
 329         &cpu_attrs[2].attr.attr,
 330         &dev_attr_kernel_max.attr,
 331         &dev_attr_offline.attr,
 332 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
 333         &dev_attr_modalias.attr,
 334 #endif
 335         NULL
 336 };
 337
 338 static struct attribute_group cpu_root_attr_group = {
 339         .attrs = cpu_root_attrs,
 340 };
 341
 342 static const struct attribute_group *cpu_root_attr_groups[] = {
 343         &cpu_root_attr_group,
 344         NULL,
 345 };
 346
 347 bool cpu_is_hotpluggable(unsigned cpu)
 348 {
 349         struct device *dev = get_cpu_device(cpu);
 350         return dev && container_of(dev, struct cpu, dev)->hotpluggable;
 351 }
 352 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
 353
 354 #ifdef CONFIG_GENERIC_CPU_DEVICES
 355 static DEFINE_PER_CPU(struct cpu, cpu_devices);
 356 #endif
 357
 358 static void __init cpu_dev_register_generic(void)
 359 {
 360 #ifdef CONFIG_GENERIC_CPU_DEVICES
 361         int i;
 362
 363         for_each_possible_cpu(i) {
 364                 if (register_cpu(&per_cpu(cpu_devices, i), i))
 365                         panic("Failed to register CPU device");
 366         }
 367 #endif
 368 }
 369
 370 void __init cpu_dev_init(void)
 371 {
 372         if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
 373                 panic("Failed to register CPU subsystem");
 374
 375         cpu_dev_register_generic();
 376 }