blob: 4c28e1a0978666e3f228a005661981e44205bd49 [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>
Rik van Riel6570a9a2015-04-24 15:24:28 -040019#include <linux/tick.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
Ben Dooksa1bdc7a2005-10-13 17:54:41 +010021#include "base.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
Kay Sievers8a25a2f2011-12-21 14:29:42 -080023static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
Ashok Rajad745572005-10-30 14:59:49 -080024
Rafael J. Wysockiac212b62013-05-03 00:26:22 +020025static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#ifdef CONFIG_HOTPLUG_CPU
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070035static 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
Mathias Krauseeda58672015-07-19 20:06:21 +020044static int cpu_subsys_online(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080046 struct cpu *cpu = container_of(dev, struct cpu, dev);
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020047 int cpuid = dev->id;
Yasuaki Ishimatsu34640462013-04-29 15:08:50 -070048 int from_nid, to_nid;
Toshi Kani6dedcca2013-09-25 15:08:27 -060049 int ret;
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)
Toshi Kani6dedcca2013-09-25 15:08:27 -060053 return -ENODEV;
Rafael J. Wysockic7991b02013-08-13 02:39:30 +020054
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 return ret;
65}
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Rafael J. Wysocki0902a902013-05-03 00:25:49 +020067static int cpu_subsys_offline(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068{
Toshi Kani6dedcca2013-09-25 15:08:27 -060069 return cpu_down(dev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070}
Igor Mammedov1c4e2d72013-05-14 16:46:07 +020071
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -070072void unregister_cpu(struct cpu *cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080074 int logical_cpu = cpu->dev.id;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
KAMEZAWA Hiroyuki76b67ed92006-06-27 02:53:41 -070076 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
77
Kay Sievers8a25a2f2011-12-21 14:29:42 -080078 device_unregister(&cpu->dev);
Mike Travise37d05d2008-05-01 04:35:16 -070079 per_cpu(cpu_sys_devices, logical_cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 return;
81}
Nathan Fontenot12633e82009-11-25 17:23:25 +000082
83#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
Kay Sievers8a25a2f2011-12-21 14:29:42 -080084static ssize_t cpu_probe_store(struct device *dev,
85 struct device_attribute *attr,
Stephen Rothwell67fc2332010-03-16 10:33:32 +110086 const char *buf,
Nathan Fontenot12633e82009-11-25 17:23:25 +000087 size_t count)
88{
Toshi Kani574b8512013-08-29 18:22:07 -060089 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;
Nathan Fontenot12633e82009-11-25 17:23:25 +0000100}
101
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800102static ssize_t cpu_release_store(struct device *dev,
103 struct device_attribute *attr,
Stephen Rothwell67fc2332010-03-16 10:33:32 +1100104 const char *buf,
Nathan Fontenot12633e82009-11-25 17:23:25 +0000105 size_t count)
106{
Toshi Kani574b8512013-08-29 18:22:07 -0600107 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;
Nathan Fontenot12633e82009-11-25 17:23:25 +0000118}
119
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800120static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
121static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
Nathan Fontenot12633e82009-11-25 17:23:25 +0000122#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123#endif /* CONFIG_HOTPLUG_CPU */
124
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200125struct bus_type cpu_subsys = {
126 .name = "cpu",
127 .dev_name = "cpu",
Rafael J. Wysockiac212b62013-05-03 00:26:22 +0200128 .match = cpu_subsys_match,
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200129#ifdef CONFIG_HOTPLUG_CPU
130 .online = cpu_subsys_online,
131 .offline = cpu_subsys_offline,
132#endif
133};
134EXPORT_SYMBOL_GPL(cpu_subsys);
135
Vivek Goyal51be5602006-01-09 20:51:42 -0800136#ifdef CONFIG_KEXEC
137#include <linux/kexec.h>
138
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800139static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200140 char *buf)
Vivek Goyal51be5602006-01-09 20:51:42 -0800141{
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800142 struct cpu *cpu = container_of(dev, struct cpu, dev);
Vivek Goyal51be5602006-01-09 20:51:42 -0800143 ssize_t rc;
144 unsigned long long addr;
145 int cpunum;
146
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800147 cpunum = cpu->dev.id;
Vivek Goyal51be5602006-01-09 20:51:42 -0800148
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 */
Vivek Goyal3b034b02009-11-24 15:50:03 +0900155 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
Vivek Goyal51be5602006-01-09 20:51:42 -0800156 rc = sprintf(buf, "%Lx\n", addr);
Vivek Goyal51be5602006-01-09 20:51:42 -0800157 return rc;
158}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800159static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
Zhang Yanfeieca45492013-03-28 16:15:35 +0800160
161static ssize_t show_crash_notes_size(struct device *dev,
162 struct device_attribute *attr,
163 char *buf)
164{
165 ssize_t rc;
166
Arnd Bergmannbcfb87f2013-04-03 15:18:24 +0000167 rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
Zhang Yanfeieca45492013-03-28 16:15:35 +0800168 return rc;
169}
170static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
Igor Mammedovc055da92013-05-14 16:46:06 +0200171
172static struct attribute *crash_note_cpu_attrs[] = {
173 &dev_attr_crash_notes.attr,
174 &dev_attr_crash_notes_size.attr,
175 NULL
176};
177
178static struct attribute_group crash_note_cpu_attr_group = {
179 .attrs = crash_note_cpu_attrs,
180};
Vivek Goyal51be5602006-01-09 20:51:42 -0800181#endif
182
Igor Mammedovc055da92013-05-14 16:46:06 +0200183static const struct attribute_group *common_cpu_attr_groups[] = {
184#ifdef CONFIG_KEXEC
185 &crash_note_cpu_attr_group,
186#endif
187 NULL
188};
189
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200190static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
191#ifdef CONFIG_KEXEC
192 &crash_note_cpu_attr_group,
193#endif
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200194 NULL
195};
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197/*
Mike Travis9d1fe3232008-04-08 11:43:04 -0700198 * Print cpu online, possible, present, and system maps
199 */
Andi Kleen265d2e22010-01-05 12:48:00 +0100200
201struct cpu_attr {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800202 struct device_attribute attr;
Rasmus Villemoes848e2392016-01-20 15:00:22 -0800203 const struct cpumask *const map;
Andi Kleen265d2e22010-01-05 12:48:00 +0100204};
205
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800206static ssize_t show_cpus_attr(struct device *dev,
207 struct device_attribute *attr,
Andi Kleen265d2e22010-01-05 12:48:00 +0100208 char *buf)
Mike Travis9d1fe3232008-04-08 11:43:04 -0700209{
Andi Kleen265d2e22010-01-05 12:48:00 +0100210 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
Mike Travis9d1fe3232008-04-08 11:43:04 -0700211
Rasmus Villemoes848e2392016-01-20 15:00:22 -0800212 return cpumap_print_to_pagebuf(true, buf, ca->map);
Mike Travis9d1fe3232008-04-08 11:43:04 -0700213}
214
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800215#define _CPU_ATTR(name, map) \
216 { __ATTR(name, 0444, show_cpus_attr, NULL), map }
Mike Travis9d1fe3232008-04-08 11:43:04 -0700217
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800218/* Keep in sync with cpu_subsys_attrs */
Andi Kleen265d2e22010-01-05 12:48:00 +0100219static struct cpu_attr cpu_attrs[] = {
Rasmus Villemoes848e2392016-01-20 15:00:22 -0800220 _CPU_ATTR(online, &__cpu_online_mask),
221 _CPU_ATTR(possible, &__cpu_possible_mask),
222 _CPU_ATTR(present, &__cpu_present_mask),
Andi Kleen265d2e22010-01-05 12:48:00 +0100223};
Mike Travis9d1fe3232008-04-08 11:43:04 -0700224
Mike Travise057d7a2008-12-15 20:26:48 -0800225/*
226 * Print values for NR_CPUS and offlined cpus
227 */
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800228static ssize_t print_cpus_kernel_max(struct device *dev,
229 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800230{
Mike Travis8fd2d2d2008-12-31 18:08:48 -0800231 int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
Mike Travise057d7a2008-12-15 20:26:48 -0800232 return n;
233}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800234static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800235
236/* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
237unsigned int total_cpus;
238
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800239static ssize_t print_cpus_offline(struct device *dev,
240 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800241{
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;
Jan Beulichcdc6e3d2010-04-27 14:01:20 -0700248 cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
Tejun Heof799b1a2015-02-13 14:37:56 -0800249 n = scnprintf(buf, len, "%*pbl", cpumask_pr_args(offline));
Mike Travise057d7a2008-12-15 20:26:48 -0800250 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}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800267static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800268
Rik van Riel59f30ab2015-04-24 15:24:27 -0400269static 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}
278static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL);
279
Rik van Riel6570a9a2015-04-24 15:24:28 -0400280#ifdef CONFIG_NO_HZ_FULL
281static 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}
290static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL);
291#endif
292
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800293static 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
Ralf Baechle30a48402013-01-15 15:27:46 +0100308 * on the linux-kernel list, you have been warned.
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800309 */
310}
311
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100312#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
313static 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}
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100334
335static 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
Mike Travis9d1fe3232008-04-08 11:43:04 -0700347/*
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100348 * register_cpu - Setup a sysfs device for a CPU.
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100349 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
350 * sysfs for this CPU.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 * @num - CPU number to use when creating the device.
352 *
353 * Initialize and register the CPU device.
354 */
Paul Gortmakera83048e2013-06-19 15:22:41 -0400355int register_cpu(struct cpu *cpu, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
357 int error;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 cpu->node_id = cpu_to_node(num);
Greg Kroah-Hartman29bb5d42012-02-08 15:11:17 -0800360 memset(&cpu->dev, 0x00, sizeof(struct device));
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800361 cpu->dev.id = num;
362 cpu->dev.bus = &cpu_subsys;
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800363 cpu->dev.release = cpu_device_release;
Rafael J. Wysocki0902a902013-05-03 00:25:49 +0200364 cpu->dev.offline_disabled = !cpu->hotpluggable;
Toshi Kani1001b4d2013-05-30 00:30:05 +0200365 cpu->dev.offline = !cpu_online(num);
Sudeep KarkadaNageshaf86e4712013-06-17 12:58:45 +0100366 cpu->dev.of_node = of_get_cpu_node(num, NULL);
Ard Biesheuvel2b9c1f02014-02-08 13:34:10 +0100367#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100368 cpu->dev.bus->uevent = cpu_uevent;
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100369#endif
Igor Mammedovc055da92013-05-14 16:46:06 +0200370 cpu->dev.groups = common_cpu_attr_groups;
Igor Mammedov1c4e2d72013-05-14 16:46:07 +0200371 if (cpu->hotpluggable)
372 cpu->dev.groups = hotplugable_cpu_attr_groups;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800373 error = device_register(&cpu->dev);
Alex Shi59fffa32016-08-25 16:42:39 +0800374 if (error)
375 return error;
Vivek Goyal51be5602006-01-09 20:51:42 -0800376
Alex Shi59fffa32016-08-25 16:42:39 +0800377 per_cpu(cpu_sys_devices, num) = &cpu->dev;
378 register_cpu_under_node(num, cpu_to_node(num));
379
380 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381}
382
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800383struct device *get_cpu_device(unsigned cpu)
Ashok Rajad745572005-10-30 14:59:49 -0800384{
Mike Travise37d05d2008-05-01 04:35:16 -0700385 if (cpu < nr_cpu_ids && cpu_possible(cpu))
386 return per_cpu(cpu_sys_devices, cpu);
Ashok Rajad745572005-10-30 14:59:49 -0800387 else
388 return NULL;
389}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800390EXPORT_SYMBOL_GPL(get_cpu_device);
391
Sudeep Holla3d529432014-09-30 14:48:24 +0100392static void device_create_release(struct device *dev)
393{
394 kfree(dev);
395}
396
397static struct device *
398__cpu_device_create(struct device *parent, void *drvdata,
399 const struct attribute_group **groups,
400 const char *fmt, va_list args)
401{
402 struct device *dev = NULL;
403 int retval = -ENODEV;
404
405 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
406 if (!dev) {
407 retval = -ENOMEM;
408 goto error;
409 }
410
411 device_initialize(dev);
412 dev->parent = parent;
413 dev->groups = groups;
414 dev->release = device_create_release;
415 dev_set_drvdata(dev, drvdata);
416
417 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
418 if (retval)
419 goto error;
420
421 retval = device_add(dev);
422 if (retval)
423 goto error;
424
425 return dev;
426
427error:
428 put_device(dev);
429 return ERR_PTR(retval);
430}
431
432struct device *cpu_device_create(struct device *parent, void *drvdata,
433 const struct attribute_group **groups,
434 const char *fmt, ...)
435{
436 va_list vargs;
437 struct device *dev;
438
439 va_start(vargs, fmt);
440 dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs);
441 va_end(vargs);
442 return dev;
443}
444EXPORT_SYMBOL_GPL(cpu_device_create);
445
Ard Biesheuvel2b9c1f02014-02-08 13:34:10 +0100446#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
Ard Biesheuvel67bad2f2014-02-08 13:34:09 +0100447static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100448#endif
449
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800450static struct attribute *cpu_root_attrs[] = {
451#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
452 &dev_attr_probe.attr,
453 &dev_attr_release.attr,
454#endif
455 &cpu_attrs[0].attr.attr,
456 &cpu_attrs[1].attr.attr,
457 &cpu_attrs[2].attr.attr,
458 &dev_attr_kernel_max.attr,
459 &dev_attr_offline.attr,
Rik van Riel59f30ab2015-04-24 15:24:27 -0400460 &dev_attr_isolated.attr,
Rik van Riel6570a9a2015-04-24 15:24:28 -0400461#ifdef CONFIG_NO_HZ_FULL
462 &dev_attr_nohz_full.attr,
463#endif
Ard Biesheuvel2b9c1f02014-02-08 13:34:10 +0100464#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
Thomas Renningerfad12ac2012-01-26 00:09:14 +0100465 &dev_attr_modalias.attr,
466#endif
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800467 NULL
468};
469
470static struct attribute_group cpu_root_attr_group = {
471 .attrs = cpu_root_attrs,
472};
473
474static const struct attribute_group *cpu_root_attr_groups[] = {
475 &cpu_root_attr_group,
476 NULL,
477};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Josh Triplett29875572011-12-03 13:06:50 -0800479bool cpu_is_hotpluggable(unsigned cpu)
480{
Linus Torvalds7affca32012-01-07 12:03:30 -0800481 struct device *dev = get_cpu_device(cpu);
482 return dev && container_of(dev, struct cpu, dev)->hotpluggable;
Josh Triplett29875572011-12-03 13:06:50 -0800483}
484EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
485
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000486#ifdef CONFIG_GENERIC_CPU_DEVICES
487static DEFINE_PER_CPU(struct cpu, cpu_devices);
488#endif
489
490static void __init cpu_dev_register_generic(void)
491{
492#ifdef CONFIG_GENERIC_CPU_DEVICES
493 int i;
494
495 for_each_possible_cpu(i) {
496 if (register_cpu(&per_cpu(cpu_devices, i), i))
497 panic("Failed to register CPU device");
498 }
499#endif
500}
501
Ben Hutchings024f7842012-01-10 02:59:49 +0000502void __init cpu_dev_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503{
Ben Hutchings024f7842012-01-10 02:59:49 +0000504 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
505 panic("Failed to register CPU subsystem");
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700506
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000507 cpu_dev_register_generic();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508}