blob: 848ebbd25717269fa0ef34e1632e502eb29f4aeb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Kay Sievers8a25a2f2011-12-21 14:29:42 -08002 * CPU subsystem support
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 */
4
Ben Hutchings024f7842012-01-10 02:59:49 +00005#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include <linux/module.h>
7#include <linux/init.h>
Al Virof6a57032006-10-18 01:47:25 -04008#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/cpu.h>
10#include <linux/topology.h>
11#include <linux/device.h>
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -070012#include <linux/node.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090013#include <linux/gfp.h>
Thomas Renningerfad12ac2012-01-26 00:09:14 +010014#include <linux/slab.h>
Ben Hutchings9f13a1f2012-01-10 03:04:32 +000015#include <linux/percpu.h>
Rafael J. Wysockiac212b62013-05-03 00:26:22 +020016#include <linux/acpi.h>
Sudeep KarkadaNageshaf86e4712013-06-17 12:58:45 +010017#include <linux/of.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Ben Dooksa1bdc7a2005-10-13 17:54:41 +010019#include "base.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
Kay Sievers8a25a2f2011-12-21 14:29:42 -080021static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
Ashok Rajad745572005-10-30 14:59:49 -080022
Rafael J. Wysockiac212b62013-05-03 00:26:22 +020023static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#ifdef CONFIG_HOTPLUG_CPU
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070033static 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
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020042static int __ref cpu_subsys_online(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070043{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080044 struct cpu *cpu = container_of(dev, struct cpu, dev);
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020045 int cpuid = dev->id;
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070046 int from_nid, to_nid;
Rafael J. Wysockic7991b02013-08-13 02:39:30 +020047 int ret = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Gautham R Shenoy51badeb2009-11-26 09:59:05 +000049 cpu_hotplug_driver_lock();
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070050
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020051 from_nid = cpu_to_node(cpuid);
Rafael J. Wysockic7991b02013-08-13 02:39:30 +020052 if (from_nid == NUMA_NO_NODE)
53 goto out;
54
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020055 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);
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070063
Rafael J. Wysockic7991b02013-08-13 02:39:30 +020064 out:
Gautham R Shenoy51badeb2009-11-26 09:59:05 +000065 cpu_hotplug_driver_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 return ret;
67}
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020069static int cpu_subsys_offline(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020071 int ret;
Igor Mammedov1c4e2d72013-05-14 16:46:07 +020072
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020073 cpu_hotplug_driver_lock();
74 ret = cpu_down(dev->id);
75 cpu_hotplug_driver_unlock();
76 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077}
Igor Mammedov1c4e2d72013-05-14 16:46:07 +020078
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -070079void unregister_cpu(struct cpu *cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080081 int logical_cpu = cpu->dev.id;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -070083 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
84
Kay Sievers8a25a2f2011-12-21 14:29:42 -080085 device_unregister(&cpu->dev);
Mike Travise37d05d2008-05-01 04:35:16 -070086 per_cpu(cpu_sys_devices, logical_cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 return;
88}
Nathan Fontenot12633e82009-11-25 17:23:25 +000089
90#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
Kay Sievers8a25a2f2011-12-21 14:29:42 -080091static ssize_t cpu_probe_store(struct device *dev,
92 struct device_attribute *attr,
Stephen Rothwell67fc2332010-03-16 10:33:32 +110093 const char *buf,
Nathan Fontenot12633e82009-11-25 17:23:25 +000094 size_t count)
95{
96 return arch_cpu_probe(buf, count);
97}
98
Kay Sievers8a25a2f2011-12-21 14:29:42 -080099static ssize_t cpu_release_store(struct device *dev,
100 struct device_attribute *attr,
Stephen Rothwell67fc2332010-03-16 10:33:32 +1100101 const char *buf,
Nathan Fontenot12633e82009-11-25 17:23:25 +0000102 size_t count)
103{
104 return arch_cpu_release(buf, count);
105}
106
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800107static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
108static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
Nathan Fontenot12633e82009-11-25 17:23:25 +0000109#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110#endif /* CONFIG_HOTPLUG_CPU */
111
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200112struct bus_type cpu_subsys = {
113 .name = "cpu",
114 .dev_name = "cpu",
Rafael J. Wysockiac212b62013-05-03 00:26:22 +0200115 .match = cpu_subsys_match,
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200116#ifdef CONFIG_HOTPLUG_CPU
117 .online = cpu_subsys_online,
118 .offline = cpu_subsys_offline,
119#endif
120};
121EXPORT_SYMBOL_GPL(cpu_subsys);
122
Vivek Goyal51be5602006-01-09 20:51:42 -0800123#ifdef CONFIG_KEXEC
124#include <linux/kexec.h>
125
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800126static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200127 char *buf)
Vivek Goyal51be5602006-01-09 20:51:42 -0800128{
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800129 struct cpu *cpu = container_of(dev, struct cpu, dev);
Vivek Goyal51be5602006-01-09 20:51:42 -0800130 ssize_t rc;
131 unsigned long long addr;
132 int cpunum;
133
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800134 cpunum = cpu->dev.id;
Vivek Goyal51be5602006-01-09 20:51:42 -0800135
136 /*
137 * Might be reading other cpu's data based on which cpu read thread
138 * has been scheduled. But cpu data (memory) is allocated once during
139 * boot up and this data does not change there after. Hence this
140 * operation should be safe. No locking required.
141 */
Vivek Goyal3b034b02009-11-24 15:50:03 +0900142 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
Vivek Goyal51be5602006-01-09 20:51:42 -0800143 rc = sprintf(buf, "%Lx\n", addr);
Vivek Goyal51be5602006-01-09 20:51:42 -0800144 return rc;
145}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800146static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
Zhang Yanfeieca45492013-03-28 16:15:35 +0800147
148static ssize_t show_crash_notes_size(struct device *dev,
149 struct device_attribute *attr,
150 char *buf)
151{
152 ssize_t rc;
153
Arnd Bergmannbcfb87f2013-04-03 15:18:24 +0000154 rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
Zhang Yanfeieca45492013-03-28 16:15:35 +0800155 return rc;
156}
157static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
Igor Mammedovc055da92013-05-14 16:46:06 +0200158
159static struct attribute *crash_note_cpu_attrs[] = {
160 &dev_attr_crash_notes.attr,
161 &dev_attr_crash_notes_size.attr,
162 NULL
163};
164
165static struct attribute_group crash_note_cpu_attr_group = {
166 .attrs = crash_note_cpu_attrs,
167};
Vivek Goyal51be5602006-01-09 20:51:42 -0800168#endif
169
Igor Mammedovc055da92013-05-14 16:46:06 +0200170static const struct attribute_group *common_cpu_attr_groups[] = {
171#ifdef CONFIG_KEXEC
172 &crash_note_cpu_attr_group,
173#endif
174 NULL
175};
176
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200177static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
178#ifdef CONFIG_KEXEC
179 &crash_note_cpu_attr_group,
180#endif
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200181 NULL
182};
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184/*
Mike Travis9d1fe3232008-04-08 11:43:04 -0700185 * Print cpu online, possible, present, and system maps
186 */
Andi Kleen265d2e22010-01-05 12:48:00 +0100187
188struct cpu_attr {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800189 struct device_attribute attr;
Andi Kleen265d2e22010-01-05 12:48:00 +0100190 const struct cpumask *const * const map;
191};
192
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800193static ssize_t show_cpus_attr(struct device *dev,
194 struct device_attribute *attr,
Andi Kleen265d2e22010-01-05 12:48:00 +0100195 char *buf)
Mike Travis9d1fe3232008-04-08 11:43:04 -0700196{
Andi Kleen265d2e22010-01-05 12:48:00 +0100197 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
198 int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *(ca->map));
Mike Travis9d1fe3232008-04-08 11:43:04 -0700199
200 buf[n++] = '\n';
201 buf[n] = '\0';
202 return n;
203}
204
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800205#define _CPU_ATTR(name, map) \
206 { __ATTR(name, 0444, show_cpus_attr, NULL), map }
Mike Travis9d1fe3232008-04-08 11:43:04 -0700207
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800208/* Keep in sync with cpu_subsys_attrs */
Andi Kleen265d2e22010-01-05 12:48:00 +0100209static struct cpu_attr cpu_attrs[] = {
210 _CPU_ATTR(online, &cpu_online_mask),
211 _CPU_ATTR(possible, &cpu_possible_mask),
212 _CPU_ATTR(present, &cpu_present_mask),
213};
Mike Travis9d1fe3232008-04-08 11:43:04 -0700214
Mike Travise057d7a2008-12-15 20:26:48 -0800215/*
216 * Print values for NR_CPUS and offlined cpus
217 */
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800218static ssize_t print_cpus_kernel_max(struct device *dev,
219 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800220{
Mike Travis8fd2d2d2008-12-31 18:08:48 -0800221 int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
Mike Travise057d7a2008-12-15 20:26:48 -0800222 return n;
223}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800224static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800225
226/* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
227unsigned int total_cpus;
228
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800229static ssize_t print_cpus_offline(struct device *dev,
230 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800231{
232 int n = 0, len = PAGE_SIZE-2;
233 cpumask_var_t offline;
234
235 /* display offline cpus < nr_cpu_ids */
236 if (!alloc_cpumask_var(&offline, GFP_KERNEL))
237 return -ENOMEM;
Jan Beulichcdc6e3d2010-04-27 14:01:20 -0700238 cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
Mike Travise057d7a2008-12-15 20:26:48 -0800239 n = cpulist_scnprintf(buf, len, offline);
240 free_cpumask_var(offline);
241
242 /* display offline cpus >= nr_cpu_ids */
243 if (total_cpus && nr_cpu_ids < total_cpus) {
244 if (n && n < len)
245 buf[n++] = ',';
246
247 if (nr_cpu_ids == total_cpus-1)
248 n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
249 else
250 n += snprintf(&buf[n], len - n, "%d-%d",
251 nr_cpu_ids, total_cpus-1);
252 }
253
254 n += snprintf(&buf[n], len - n, "\n");
255 return n;
256}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800257static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800258
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800259static void cpu_device_release(struct device *dev)
260{
261 /*
262 * This is an empty function to prevent the driver core from spitting a
263 * warning at us. Yes, I know this is directly opposite of what the
264 * documentation for the driver core and kobjects say, and the author
265 * of this code has already been publically ridiculed for doing
266 * something as foolish as this. However, at this point in time, it is
267 * the only way to handle the issue of statically allocated cpu
268 * devices. The different architectures will have their cpu device
269 * code reworked to properly handle this in the near future, so this
270 * function will then be changed to correctly free up the memory held
271 * by the cpu device.
272 *
273 * Never copy this way of doing things, or you too will be made fun of
Ralf Baechle30a48402013-01-15 15:27:46 +0100274 * on the linux-kernel list, you have been warned.
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800275 */
276}
277
Mike Travis9d1fe3232008-04-08 11:43:04 -0700278/*
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100279 * register_cpu - Setup a sysfs device for a CPU.
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100280 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
281 * sysfs for this CPU.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 * @num - CPU number to use when creating the device.
283 *
284 * Initialize and register the CPU device.
285 */
Paul Gortmakera83048e2013-06-19 15:22:41 -0400286int register_cpu(struct cpu *cpu, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 int error;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 cpu->node_id = cpu_to_node(num);
Greg Kroah-Hartman29bb5d42012-02-08 15:11:17 -0800291 memset(&cpu->dev, 0x00, sizeof(struct device));
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800292 cpu->dev.id = num;
293 cpu->dev.bus = &cpu_subsys;
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800294 cpu->dev.release = cpu_device_release;
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200295 cpu->dev.offline_disabled = !cpu->hotpluggable;
Toshi Kani1001b4d2013-05-30 00:30:05 +0200296 cpu->dev.offline = !cpu_online(num);
Sudeep KarkadaNageshaf86e4712013-06-17 12:58:45 +0100297 cpu->dev.of_node = of_get_cpu_node(num, NULL);
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100298#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
299 cpu->dev.bus->uevent = arch_cpu_uevent;
300#endif
Igor Mammedovc055da92013-05-14 16:46:06 +0200301 cpu->dev.groups = common_cpu_attr_groups;
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200302 if (cpu->hotpluggable)
303 cpu->dev.groups = hotplugable_cpu_attr_groups;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800304 error = device_register(&cpu->dev);
Ashok Rajad745572005-10-30 14:59:49 -0800305 if (!error)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800306 per_cpu(cpu_sys_devices, num) = &cpu->dev;
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -0700307 if (!error)
308 register_cpu_under_node(num, cpu_to_node(num));
Vivek Goyal51be5602006-01-09 20:51:42 -0800309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return error;
311}
312
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800313struct device *get_cpu_device(unsigned cpu)
Ashok Rajad745572005-10-30 14:59:49 -0800314{
Mike Travise37d05d2008-05-01 04:35:16 -0700315 if (cpu < nr_cpu_ids && cpu_possible(cpu))
316 return per_cpu(cpu_sys_devices, cpu);
Ashok Rajad745572005-10-30 14:59:49 -0800317 else
318 return NULL;
319}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800320EXPORT_SYMBOL_GPL(get_cpu_device);
321
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100322#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
323static DEVICE_ATTR(modalias, 0444, arch_print_cpu_modalias, NULL);
324#endif
325
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800326static struct attribute *cpu_root_attrs[] = {
327#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
328 &dev_attr_probe.attr,
329 &dev_attr_release.attr,
330#endif
331 &cpu_attrs[0].attr.attr,
332 &cpu_attrs[1].attr.attr,
333 &cpu_attrs[2].attr.attr,
334 &dev_attr_kernel_max.attr,
335 &dev_attr_offline.attr,
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100336#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
337 &dev_attr_modalias.attr,
338#endif
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800339 NULL
340};
341
342static struct attribute_group cpu_root_attr_group = {
343 .attrs = cpu_root_attrs,
344};
345
346static const struct attribute_group *cpu_root_attr_groups[] = {
347 &cpu_root_attr_group,
348 NULL,
349};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
Josh Triplett29875572011-12-03 13:06:50 -0800351bool cpu_is_hotpluggable(unsigned cpu)
352{
Linus Torvalds7affca32012-01-07 12:03:30 -0800353 struct device *dev = get_cpu_device(cpu);
354 return dev && container_of(dev, struct cpu, dev)->hotpluggable;
Josh Triplett29875572011-12-03 13:06:50 -0800355}
356EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
357
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000358#ifdef CONFIG_GENERIC_CPU_DEVICES
359static DEFINE_PER_CPU(struct cpu, cpu_devices);
360#endif
361
362static void __init cpu_dev_register_generic(void)
363{
364#ifdef CONFIG_GENERIC_CPU_DEVICES
365 int i;
366
367 for_each_possible_cpu(i) {
368 if (register_cpu(&per_cpu(cpu_devices, i), i))
369 panic("Failed to register CPU device");
370 }
371#endif
372}
373
Ben Hutchings024f7842012-01-10 02:59:49 +0000374void __init cpu_dev_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
Ben Hutchings024f7842012-01-10 02:59:49 +0000376 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
377 panic("Failed to register CPU subsystem");
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700378
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000379 cpu_dev_register_generic();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380}