blob: f160ea44a86d68a26b689b5ff7c5f0bcaf5ec74e [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>
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +010018#include <linux/cpufeature.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
Ben Dooksa1bdc7a2005-10-13 17:54:41 +010020#include "base.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Kay Sievers8a25a2f2011-12-21 14:29:42 -080022static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
Ashok Rajad745572005-10-30 14:59:49 -080023
Rafael J. Wysockiac212b62013-05-03 00:26:22 +020024static int cpu_subsys_match(struct device *dev, struct device_driver *drv)
25{
26 /* ACPI style match is the only one that may succeed. */
27 if (acpi_driver_match_device(dev, drv))
28 return 1;
29
30 return 0;
31}
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#ifdef CONFIG_HOTPLUG_CPU
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070034static void change_cpu_under_node(struct cpu *cpu,
35 unsigned int from_nid, unsigned int to_nid)
36{
37 int cpuid = cpu->dev.id;
38 unregister_cpu_under_node(cpuid, from_nid);
39 register_cpu_under_node(cpuid, to_nid);
40 cpu->node_id = to_nid;
41}
42
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020043static int __ref cpu_subsys_online(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080045 struct cpu *cpu = container_of(dev, struct cpu, dev);
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020046 int cpuid = dev->id;
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070047 int from_nid, to_nid;
Toshi Kani6dedcca2013-09-25 15:08:27 -060048 int ret;
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070049
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020050 from_nid = cpu_to_node(cpuid);
Rafael J. Wysockic7991b02013-08-13 02:39:30 +020051 if (from_nid == NUMA_NO_NODE)
Toshi Kani6dedcca2013-09-25 15:08:27 -060052 return -ENODEV;
Rafael J. Wysockic7991b02013-08-13 02:39:30 +020053
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020054 ret = cpu_up(cpuid);
55 /*
56 * When hot adding memory to memoryless node and enabling a cpu
57 * on the node, node number of the cpu may internally change.
58 */
59 to_nid = cpu_to_node(cpuid);
60 if (from_nid != to_nid)
61 change_cpu_under_node(cpu, from_nid, to_nid);
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070062
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 return ret;
64}
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020066static int cpu_subsys_offline(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
Toshi Kani6dedcca2013-09-25 15:08:27 -060068 return cpu_down(dev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069}
Igor Mammedov1c4e2d72013-05-14 16:46:07 +020070
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -070071void unregister_cpu(struct cpu *cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080073 int logical_cpu = cpu->dev.id;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -070075 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
76
Kay Sievers8a25a2f2011-12-21 14:29:42 -080077 device_unregister(&cpu->dev);
Mike Travise37d05d2008-05-01 04:35:16 -070078 per_cpu(cpu_sys_devices, logical_cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 return;
80}
Nathan Fontenot12633e82009-11-25 17:23:25 +000081
82#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
Kay Sievers8a25a2f2011-12-21 14:29:42 -080083static ssize_t cpu_probe_store(struct device *dev,
84 struct device_attribute *attr,
Stephen Rothwell67fc2332010-03-16 10:33:32 +110085 const char *buf,
Nathan Fontenot12633e82009-11-25 17:23:25 +000086 size_t count)
87{
Toshi Kani574b8512013-08-29 18:22:07 -060088 ssize_t cnt;
89 int ret;
90
91 ret = lock_device_hotplug_sysfs();
92 if (ret)
93 return ret;
94
95 cnt = arch_cpu_probe(buf, count);
96
97 unlock_device_hotplug();
98 return cnt;
Nathan Fontenot12633e82009-11-25 17:23:25 +000099}
100
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800101static ssize_t cpu_release_store(struct device *dev,
102 struct device_attribute *attr,
Stephen Rothwell67fc2332010-03-16 10:33:32 +1100103 const char *buf,
Nathan Fontenot12633e82009-11-25 17:23:25 +0000104 size_t count)
105{
Toshi Kani574b8512013-08-29 18:22:07 -0600106 ssize_t cnt;
107 int ret;
108
109 ret = lock_device_hotplug_sysfs();
110 if (ret)
111 return ret;
112
113 cnt = arch_cpu_release(buf, count);
114
115 unlock_device_hotplug();
116 return cnt;
Nathan Fontenot12633e82009-11-25 17:23:25 +0000117}
118
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800119static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
120static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
Nathan Fontenot12633e82009-11-25 17:23:25 +0000121#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122#endif /* CONFIG_HOTPLUG_CPU */
123
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200124struct bus_type cpu_subsys = {
125 .name = "cpu",
126 .dev_name = "cpu",
Rafael J. Wysockiac212b62013-05-03 00:26:22 +0200127 .match = cpu_subsys_match,
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200128#ifdef CONFIG_HOTPLUG_CPU
129 .online = cpu_subsys_online,
130 .offline = cpu_subsys_offline,
131#endif
132};
133EXPORT_SYMBOL_GPL(cpu_subsys);
134
Vivek Goyal51be5602006-01-09 20:51:42 -0800135#ifdef CONFIG_KEXEC
136#include <linux/kexec.h>
137
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800138static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200139 char *buf)
Vivek Goyal51be5602006-01-09 20:51:42 -0800140{
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800141 struct cpu *cpu = container_of(dev, struct cpu, dev);
Vivek Goyal51be5602006-01-09 20:51:42 -0800142 ssize_t rc;
143 unsigned long long addr;
144 int cpunum;
145
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800146 cpunum = cpu->dev.id;
Vivek Goyal51be5602006-01-09 20:51:42 -0800147
148 /*
149 * Might be reading other cpu's data based on which cpu read thread
150 * has been scheduled. But cpu data (memory) is allocated once during
151 * boot up and this data does not change there after. Hence this
152 * operation should be safe. No locking required.
153 */
Vivek Goyal3b034b02009-11-24 15:50:03 +0900154 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
Vivek Goyal51be5602006-01-09 20:51:42 -0800155 rc = sprintf(buf, "%Lx\n", addr);
Vivek Goyal51be5602006-01-09 20:51:42 -0800156 return rc;
157}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800158static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
Zhang Yanfeieca45492013-03-28 16:15:35 +0800159
160static ssize_t show_crash_notes_size(struct device *dev,
161 struct device_attribute *attr,
162 char *buf)
163{
164 ssize_t rc;
165
Arnd Bergmannbcfb87f2013-04-03 15:18:24 +0000166 rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
Zhang Yanfeieca45492013-03-28 16:15:35 +0800167 return rc;
168}
169static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
Igor Mammedovc055da92013-05-14 16:46:06 +0200170
171static struct attribute *crash_note_cpu_attrs[] = {
172 &dev_attr_crash_notes.attr,
173 &dev_attr_crash_notes_size.attr,
174 NULL
175};
176
177static struct attribute_group crash_note_cpu_attr_group = {
178 .attrs = crash_note_cpu_attrs,
179};
Vivek Goyal51be5602006-01-09 20:51:42 -0800180#endif
181
Igor Mammedovc055da92013-05-14 16:46:06 +0200182static const struct attribute_group *common_cpu_attr_groups[] = {
183#ifdef CONFIG_KEXEC
184 &crash_note_cpu_attr_group,
185#endif
186 NULL
187};
188
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200189static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
190#ifdef CONFIG_KEXEC
191 &crash_note_cpu_attr_group,
192#endif
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200193 NULL
194};
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196/*
Mike Travis9d1fe3232008-04-08 11:43:04 -0700197 * Print cpu online, possible, present, and system maps
198 */
Andi Kleen265d2e22010-01-05 12:48:00 +0100199
200struct cpu_attr {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800201 struct device_attribute attr;
Andi Kleen265d2e22010-01-05 12:48:00 +0100202 const struct cpumask *const * const map;
203};
204
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800205static ssize_t show_cpus_attr(struct device *dev,
206 struct device_attribute *attr,
Andi Kleen265d2e22010-01-05 12:48:00 +0100207 char *buf)
Mike Travis9d1fe3232008-04-08 11:43:04 -0700208{
Andi Kleen265d2e22010-01-05 12:48:00 +0100209 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
Mike Travis9d1fe3232008-04-08 11:43:04 -0700210
Sudeep Holla5aaba362014-09-30 14:48:22 +0100211 return cpumap_print_to_pagebuf(true, buf, *ca->map);
Mike Travis9d1fe3232008-04-08 11:43:04 -0700212}
213
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800214#define _CPU_ATTR(name, map) \
215 { __ATTR(name, 0444, show_cpus_attr, NULL), map }
Mike Travis9d1fe3232008-04-08 11:43:04 -0700216
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800217/* Keep in sync with cpu_subsys_attrs */
Andi Kleen265d2e22010-01-05 12:48:00 +0100218static struct cpu_attr cpu_attrs[] = {
219 _CPU_ATTR(online, &cpu_online_mask),
220 _CPU_ATTR(possible, &cpu_possible_mask),
221 _CPU_ATTR(present, &cpu_present_mask),
222};
Mike Travis9d1fe3232008-04-08 11:43:04 -0700223
Mike Travise057d7a2008-12-15 20:26:48 -0800224/*
225 * Print values for NR_CPUS and offlined cpus
226 */
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800227static ssize_t print_cpus_kernel_max(struct device *dev,
228 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800229{
Mike Travis8fd2d2d2008-12-31 18:08:48 -0800230 int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
Mike Travise057d7a2008-12-15 20:26:48 -0800231 return n;
232}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800233static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800234
235/* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
236unsigned int total_cpus;
237
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800238static ssize_t print_cpus_offline(struct device *dev,
239 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800240{
241 int n = 0, len = PAGE_SIZE-2;
242 cpumask_var_t offline;
243
244 /* display offline cpus < nr_cpu_ids */
245 if (!alloc_cpumask_var(&offline, GFP_KERNEL))
246 return -ENOMEM;
Jan Beulichcdc6e3d2010-04-27 14:01:20 -0700247 cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
Tejun Heof799b1a2015-02-13 14:37:56 -0800248 n = scnprintf(buf, len, "%*pbl", cpumask_pr_args(offline));
Mike Travise057d7a2008-12-15 20:26:48 -0800249 free_cpumask_var(offline);
250
251 /* display offline cpus >= nr_cpu_ids */
252 if (total_cpus && nr_cpu_ids < total_cpus) {
253 if (n && n < len)
254 buf[n++] = ',';
255
256 if (nr_cpu_ids == total_cpus-1)
257 n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
258 else
259 n += snprintf(&buf[n], len - n, "%d-%d",
260 nr_cpu_ids, total_cpus-1);
261 }
262
263 n += snprintf(&buf[n], len - n, "\n");
264 return n;
265}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800266static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800267
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800268static void cpu_device_release(struct device *dev)
269{
270 /*
271 * This is an empty function to prevent the driver core from spitting a
272 * warning at us. Yes, I know this is directly opposite of what the
273 * documentation for the driver core and kobjects say, and the author
274 * of this code has already been publically ridiculed for doing
275 * something as foolish as this. However, at this point in time, it is
276 * the only way to handle the issue of statically allocated cpu
277 * devices. The different architectures will have their cpu device
278 * code reworked to properly handle this in the near future, so this
279 * function will then be changed to correctly free up the memory held
280 * by the cpu device.
281 *
282 * Never copy this way of doing things, or you too will be made fun of
Ralf Baechle30a48402013-01-15 15:27:46 +0100283 * on the linux-kernel list, you have been warned.
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800284 */
285}
286
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100287#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
288static ssize_t print_cpu_modalias(struct device *dev,
289 struct device_attribute *attr,
290 char *buf)
291{
292 ssize_t n;
293 u32 i;
294
295 n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
296 CPU_FEATURE_TYPEVAL);
297
298 for (i = 0; i < MAX_CPU_FEATURES; i++)
299 if (cpu_have_feature(i)) {
300 if (PAGE_SIZE < n + sizeof(",XXXX\n")) {
301 WARN(1, "CPU features overflow page\n");
302 break;
303 }
304 n += sprintf(&buf[n], ",%04X", i);
305 }
306 buf[n++] = '\n';
307 return n;
308}
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100309
310static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env)
311{
312 char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
313 if (buf) {
314 print_cpu_modalias(NULL, NULL, buf);
315 add_uevent_var(env, "MODALIAS=%s", buf);
316 kfree(buf);
317 }
318 return 0;
319}
320#endif
321
Mike Travis9d1fe3232008-04-08 11:43:04 -0700322/*
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100323 * register_cpu - Setup a sysfs device for a CPU.
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100324 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
325 * sysfs for this CPU.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 * @num - CPU number to use when creating the device.
327 *
328 * Initialize and register the CPU device.
329 */
Paul Gortmakera83048e2013-06-19 15:22:41 -0400330int register_cpu(struct cpu *cpu, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331{
332 int error;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 cpu->node_id = cpu_to_node(num);
Greg Kroah-Hartman29bb5d42012-02-08 15:11:17 -0800335 memset(&cpu->dev, 0x00, sizeof(struct device));
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800336 cpu->dev.id = num;
337 cpu->dev.bus = &cpu_subsys;
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800338 cpu->dev.release = cpu_device_release;
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200339 cpu->dev.offline_disabled = !cpu->hotpluggable;
Toshi Kani1001b4d2013-05-30 00:30:05 +0200340 cpu->dev.offline = !cpu_online(num);
Sudeep KarkadaNageshaf86e4712013-06-17 12:58:45 +0100341 cpu->dev.of_node = of_get_cpu_node(num, NULL);
Ard Biesheuvel2b9c1f02014-02-08 13:34:10 +0100342#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100343 cpu->dev.bus->uevent = cpu_uevent;
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100344#endif
Igor Mammedovc055da92013-05-14 16:46:06 +0200345 cpu->dev.groups = common_cpu_attr_groups;
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200346 if (cpu->hotpluggable)
347 cpu->dev.groups = hotplugable_cpu_attr_groups;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800348 error = device_register(&cpu->dev);
Ashok Rajad745572005-10-30 14:59:49 -0800349 if (!error)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800350 per_cpu(cpu_sys_devices, num) = &cpu->dev;
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -0700351 if (!error)
352 register_cpu_under_node(num, cpu_to_node(num));
Vivek Goyal51be5602006-01-09 20:51:42 -0800353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return error;
355}
356
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800357struct device *get_cpu_device(unsigned cpu)
Ashok Rajad745572005-10-30 14:59:49 -0800358{
Mike Travise37d05d2008-05-01 04:35:16 -0700359 if (cpu < nr_cpu_ids && cpu_possible(cpu))
360 return per_cpu(cpu_sys_devices, cpu);
Ashok Rajad745572005-10-30 14:59:49 -0800361 else
362 return NULL;
363}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800364EXPORT_SYMBOL_GPL(get_cpu_device);
365
Sudeep Holla3d529432014-09-30 14:48:24 +0100366static void device_create_release(struct device *dev)
367{
368 kfree(dev);
369}
370
371static struct device *
372__cpu_device_create(struct device *parent, void *drvdata,
373 const struct attribute_group **groups,
374 const char *fmt, va_list args)
375{
376 struct device *dev = NULL;
377 int retval = -ENODEV;
378
379 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
380 if (!dev) {
381 retval = -ENOMEM;
382 goto error;
383 }
384
385 device_initialize(dev);
386 dev->parent = parent;
387 dev->groups = groups;
388 dev->release = device_create_release;
389 dev_set_drvdata(dev, drvdata);
390
391 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
392 if (retval)
393 goto error;
394
395 retval = device_add(dev);
396 if (retval)
397 goto error;
398
399 return dev;
400
401error:
402 put_device(dev);
403 return ERR_PTR(retval);
404}
405
406struct device *cpu_device_create(struct device *parent, void *drvdata,
407 const struct attribute_group **groups,
408 const char *fmt, ...)
409{
410 va_list vargs;
411 struct device *dev;
412
413 va_start(vargs, fmt);
414 dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs);
415 va_end(vargs);
416 return dev;
417}
418EXPORT_SYMBOL_GPL(cpu_device_create);
419
Ard Biesheuvel2b9c1f02014-02-08 13:34:10 +0100420#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100421static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100422#endif
423
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800424static struct attribute *cpu_root_attrs[] = {
425#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
426 &dev_attr_probe.attr,
427 &dev_attr_release.attr,
428#endif
429 &cpu_attrs[0].attr.attr,
430 &cpu_attrs[1].attr.attr,
431 &cpu_attrs[2].attr.attr,
432 &dev_attr_kernel_max.attr,
433 &dev_attr_offline.attr,
Ard Biesheuvel2b9c1f02014-02-08 13:34:10 +0100434#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100435 &dev_attr_modalias.attr,
436#endif
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800437 NULL
438};
439
440static struct attribute_group cpu_root_attr_group = {
441 .attrs = cpu_root_attrs,
442};
443
444static const struct attribute_group *cpu_root_attr_groups[] = {
445 &cpu_root_attr_group,
446 NULL,
447};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Josh Triplett29875572011-12-03 13:06:50 -0800449bool cpu_is_hotpluggable(unsigned cpu)
450{
Linus Torvalds7affca32012-01-07 12:03:30 -0800451 struct device *dev = get_cpu_device(cpu);
452 return dev && container_of(dev, struct cpu, dev)->hotpluggable;
Josh Triplett29875572011-12-03 13:06:50 -0800453}
454EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
455
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000456#ifdef CONFIG_GENERIC_CPU_DEVICES
457static DEFINE_PER_CPU(struct cpu, cpu_devices);
458#endif
459
460static void __init cpu_dev_register_generic(void)
461{
462#ifdef CONFIG_GENERIC_CPU_DEVICES
463 int i;
464
465 for_each_possible_cpu(i) {
466 if (register_cpu(&per_cpu(cpu_devices, i), i))
467 panic("Failed to register CPU device");
468 }
469#endif
470}
471
Ben Hutchings024f7842012-01-10 02:59:49 +0000472void __init cpu_dev_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473{
Ben Hutchings024f7842012-01-10 02:59:49 +0000474 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
475 panic("Failed to register CPU subsystem");
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700476
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000477 cpu_dev_register_generic();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478}