blob: 4dabf5077c48575b06a4a25041fca33a8a8fb344 [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 Hiroyuki76b67ed2006-06-27 02:53:41 -070012#include <linux/node.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090013#include <linux/gfp.h>
Ben Hutchings9f13a1f2012-01-10 03:04:32 +000014#include <linux/percpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Ben Dooksa1bdc7a2005-10-13 17:54:41 +010016#include "base.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
Kay Sievers8a25a2f2011-12-21 14:29:42 -080018struct bus_type cpu_subsys = {
Kay Sieversaf5ca3f2007-12-20 02:09:39 +010019 .name = "cpu",
Kay Sievers8a25a2f2011-12-21 14:29:42 -080020 .dev_name = "cpu",
Linus Torvalds1da177e2005-04-16 15:20:36 -070021};
Kay Sievers8a25a2f2011-12-21 14:29:42 -080022EXPORT_SYMBOL_GPL(cpu_subsys);
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
Kay Sievers8a25a2f2011-12-21 14:29:42 -080024static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
Ashok Rajad745572005-10-30 14:59:49 -080025
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#ifdef CONFIG_HOTPLUG_CPU
Kay Sievers8a25a2f2011-12-21 14:29:42 -080027static ssize_t show_online(struct device *dev,
28 struct device_attribute *attr,
Andi Kleen4a0b2b42008-07-01 18:48:41 +020029 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070030{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080031 struct cpu *cpu = container_of(dev, struct cpu, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Kay Sievers8a25a2f2011-12-21 14:29:42 -080033 return sprintf(buf, "%u\n", !!cpu_online(cpu->dev.id));
Linus Torvalds1da177e2005-04-16 15:20:36 -070034}
35
Kay Sievers8a25a2f2011-12-21 14:29:42 -080036static ssize_t __ref store_online(struct device *dev,
37 struct device_attribute *attr,
38 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070039{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080040 struct cpu *cpu = container_of(dev, struct cpu, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 ssize_t ret;
42
Gautham R Shenoy51badeb2009-11-26 09:59:05 +000043 cpu_hotplug_driver_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 switch (buf[0]) {
45 case '0':
Kay Sievers8a25a2f2011-12-21 14:29:42 -080046 ret = cpu_down(cpu->dev.id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 if (!ret)
Kay Sievers312c0042005-11-16 09:00:00 +010048 kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 break;
50 case '1':
Kay Sievers8a25a2f2011-12-21 14:29:42 -080051 ret = cpu_up(cpu->dev.id);
Nathan Lynchfb69c392005-06-25 14:55:05 -070052 if (!ret)
Kay Sievers312c0042005-11-16 09:00:00 +010053 kobject_uevent(&dev->kobj, KOBJ_ONLINE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 break;
55 default:
56 ret = -EINVAL;
57 }
Gautham R Shenoy51badeb2009-11-26 09:59:05 +000058 cpu_hotplug_driver_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60 if (ret >= 0)
61 ret = count;
62 return ret;
63}
Kay Sievers8a25a2f2011-12-21 14:29:42 -080064static DEVICE_ATTR(online, 0644, show_online, store_online);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Sam Ravnborg6c847402008-03-04 15:09:05 -080066static void __cpuinit register_cpu_control(struct cpu *cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080068 device_create_file(&cpu->dev, &dev_attr_online);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069}
KAMEZAWA Hiroyuki76b67ed2006-06-27 02:53:41 -070070void unregister_cpu(struct cpu *cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080072 int logical_cpu = cpu->dev.id;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
KAMEZAWA Hiroyuki76b67ed2006-06-27 02:53:41 -070074 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
75
Kay Sievers8a25a2f2011-12-21 14:29:42 -080076 device_remove_file(&cpu->dev, &dev_attr_online);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
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{
89 return arch_cpu_probe(buf, count);
90}
91
Kay Sievers8a25a2f2011-12-21 14:29:42 -080092static ssize_t cpu_release_store(struct device *dev,
93 struct device_attribute *attr,
Stephen Rothwell67fc2332010-03-16 10:33:32 +110094 const char *buf,
Nathan Fontenot12633e82009-11-25 17:23:25 +000095 size_t count)
96{
97 return arch_cpu_release(buf, count);
98}
99
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800100static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
101static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
Nathan Fontenot12633e82009-11-25 17:23:25 +0000102#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104#else /* ... !CONFIG_HOTPLUG_CPU */
105static inline void register_cpu_control(struct cpu *cpu)
106{
107}
108#endif /* CONFIG_HOTPLUG_CPU */
109
Vivek Goyal51be5602006-01-09 20:51:42 -0800110#ifdef CONFIG_KEXEC
111#include <linux/kexec.h>
112
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800113static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200114 char *buf)
Vivek Goyal51be5602006-01-09 20:51:42 -0800115{
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800116 struct cpu *cpu = container_of(dev, struct cpu, dev);
Vivek Goyal51be5602006-01-09 20:51:42 -0800117 ssize_t rc;
118 unsigned long long addr;
119 int cpunum;
120
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800121 cpunum = cpu->dev.id;
Vivek Goyal51be5602006-01-09 20:51:42 -0800122
123 /*
124 * Might be reading other cpu's data based on which cpu read thread
125 * has been scheduled. But cpu data (memory) is allocated once during
126 * boot up and this data does not change there after. Hence this
127 * operation should be safe. No locking required.
128 */
Vivek Goyal3b034b02009-11-24 15:50:03 +0900129 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
Vivek Goyal51be5602006-01-09 20:51:42 -0800130 rc = sprintf(buf, "%Lx\n", addr);
Vivek Goyal51be5602006-01-09 20:51:42 -0800131 return rc;
132}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800133static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
Vivek Goyal51be5602006-01-09 20:51:42 -0800134#endif
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136/*
Mike Travis9d1fe322008-04-08 11:43:04 -0700137 * Print cpu online, possible, present, and system maps
138 */
Andi Kleen265d2e22010-01-05 12:48:00 +0100139
140struct cpu_attr {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800141 struct device_attribute attr;
Andi Kleen265d2e22010-01-05 12:48:00 +0100142 const struct cpumask *const * const map;
143};
144
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800145static ssize_t show_cpus_attr(struct device *dev,
146 struct device_attribute *attr,
Andi Kleen265d2e22010-01-05 12:48:00 +0100147 char *buf)
Mike Travis9d1fe322008-04-08 11:43:04 -0700148{
Andi Kleen265d2e22010-01-05 12:48:00 +0100149 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
150 int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *(ca->map));
Mike Travis9d1fe322008-04-08 11:43:04 -0700151
152 buf[n++] = '\n';
153 buf[n] = '\0';
154 return n;
155}
156
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800157#define _CPU_ATTR(name, map) \
158 { __ATTR(name, 0444, show_cpus_attr, NULL), map }
Mike Travis9d1fe322008-04-08 11:43:04 -0700159
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800160/* Keep in sync with cpu_subsys_attrs */
Andi Kleen265d2e22010-01-05 12:48:00 +0100161static struct cpu_attr cpu_attrs[] = {
162 _CPU_ATTR(online, &cpu_online_mask),
163 _CPU_ATTR(possible, &cpu_possible_mask),
164 _CPU_ATTR(present, &cpu_present_mask),
165};
Mike Travis9d1fe322008-04-08 11:43:04 -0700166
Mike Travise057d7a2008-12-15 20:26:48 -0800167/*
168 * Print values for NR_CPUS and offlined cpus
169 */
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800170static ssize_t print_cpus_kernel_max(struct device *dev,
171 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800172{
Mike Travis8fd2d2d2008-12-31 18:08:48 -0800173 int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
Mike Travise057d7a2008-12-15 20:26:48 -0800174 return n;
175}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800176static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800177
178/* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
179unsigned int total_cpus;
180
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800181static ssize_t print_cpus_offline(struct device *dev,
182 struct device_attribute *attr, char *buf)
Mike Travise057d7a2008-12-15 20:26:48 -0800183{
184 int n = 0, len = PAGE_SIZE-2;
185 cpumask_var_t offline;
186
187 /* display offline cpus < nr_cpu_ids */
188 if (!alloc_cpumask_var(&offline, GFP_KERNEL))
189 return -ENOMEM;
Jan Beulichcdc6e3d2010-04-27 14:01:20 -0700190 cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
Mike Travise057d7a2008-12-15 20:26:48 -0800191 n = cpulist_scnprintf(buf, len, offline);
192 free_cpumask_var(offline);
193
194 /* display offline cpus >= nr_cpu_ids */
195 if (total_cpus && nr_cpu_ids < total_cpus) {
196 if (n && n < len)
197 buf[n++] = ',';
198
199 if (nr_cpu_ids == total_cpus-1)
200 n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
201 else
202 n += snprintf(&buf[n], len - n, "%d-%d",
203 nr_cpu_ids, total_cpus-1);
204 }
205
206 n += snprintf(&buf[n], len - n, "\n");
207 return n;
208}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800209static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
Mike Travise057d7a2008-12-15 20:26:48 -0800210
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800211static void cpu_device_release(struct device *dev)
212{
213 /*
214 * This is an empty function to prevent the driver core from spitting a
215 * warning at us. Yes, I know this is directly opposite of what the
216 * documentation for the driver core and kobjects say, and the author
217 * of this code has already been publically ridiculed for doing
218 * something as foolish as this. However, at this point in time, it is
219 * the only way to handle the issue of statically allocated cpu
220 * devices. The different architectures will have their cpu device
221 * code reworked to properly handle this in the near future, so this
222 * function will then be changed to correctly free up the memory held
223 * by the cpu device.
224 *
225 * Never copy this way of doing things, or you too will be made fun of
226 * on the linux-kerenl list, you have been warned.
227 */
228}
229
Mike Travis9d1fe322008-04-08 11:43:04 -0700230/*
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100231 * register_cpu - Setup a sysfs device for a CPU.
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100232 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
233 * sysfs for this CPU.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 * @num - CPU number to use when creating the device.
235 *
236 * Initialize and register the CPU device.
237 */
Randy Dunlap33b5f312008-02-06 01:36:28 -0800238int __cpuinit register_cpu(struct cpu *cpu, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239{
240 int error;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 cpu->node_id = cpu_to_node(num);
Greg Kroah-Hartman29bb5d42012-02-08 15:11:17 -0800243 memset(&cpu->dev, 0x00, sizeof(struct device));
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800244 cpu->dev.id = num;
245 cpu->dev.bus = &cpu_subsys;
Greg Kroah-Hartman2885e252012-02-02 10:36:33 -0800246 cpu->dev.release = cpu_device_release;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800247 error = device_register(&cpu->dev);
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100248 if (!error && cpu->hotpluggable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 register_cpu_control(cpu);
Ashok Rajad745572005-10-30 14:59:49 -0800250 if (!error)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800251 per_cpu(cpu_sys_devices, num) = &cpu->dev;
KAMEZAWA Hiroyuki76b67ed2006-06-27 02:53:41 -0700252 if (!error)
253 register_cpu_under_node(num, cpu_to_node(num));
Vivek Goyal51be5602006-01-09 20:51:42 -0800254
255#ifdef CONFIG_KEXEC
256 if (!error)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800257 error = device_create_file(&cpu->dev, &dev_attr_crash_notes);
Vivek Goyal51be5602006-01-09 20:51:42 -0800258#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 return error;
260}
261
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800262struct device *get_cpu_device(unsigned cpu)
Ashok Rajad745572005-10-30 14:59:49 -0800263{
Mike Travise37d05d2008-05-01 04:35:16 -0700264 if (cpu < nr_cpu_ids && cpu_possible(cpu))
265 return per_cpu(cpu_sys_devices, cpu);
Ashok Rajad745572005-10-30 14:59:49 -0800266 else
267 return NULL;
268}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800269EXPORT_SYMBOL_GPL(get_cpu_device);
270
271static struct attribute *cpu_root_attrs[] = {
272#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
273 &dev_attr_probe.attr,
274 &dev_attr_release.attr,
275#endif
276 &cpu_attrs[0].attr.attr,
277 &cpu_attrs[1].attr.attr,
278 &cpu_attrs[2].attr.attr,
279 &dev_attr_kernel_max.attr,
280 &dev_attr_offline.attr,
281 NULL
282};
283
284static struct attribute_group cpu_root_attr_group = {
285 .attrs = cpu_root_attrs,
286};
287
288static const struct attribute_group *cpu_root_attr_groups[] = {
289 &cpu_root_attr_group,
290 NULL,
291};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Josh Triplett29875572011-12-03 13:06:50 -0800293bool cpu_is_hotpluggable(unsigned cpu)
294{
Linus Torvalds7affca32012-01-07 12:03:30 -0800295 struct device *dev = get_cpu_device(cpu);
296 return dev && container_of(dev, struct cpu, dev)->hotpluggable;
Josh Triplett29875572011-12-03 13:06:50 -0800297}
298EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
299
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000300#ifdef CONFIG_GENERIC_CPU_DEVICES
301static DEFINE_PER_CPU(struct cpu, cpu_devices);
302#endif
303
304static void __init cpu_dev_register_generic(void)
305{
306#ifdef CONFIG_GENERIC_CPU_DEVICES
307 int i;
308
309 for_each_possible_cpu(i) {
310 if (register_cpu(&per_cpu(cpu_devices, i), i))
311 panic("Failed to register CPU device");
312 }
313#endif
314}
315
Ben Hutchings024f7842012-01-10 02:59:49 +0000316void __init cpu_dev_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
Ben Hutchings024f7842012-01-10 02:59:49 +0000318 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
319 panic("Failed to register CPU subsystem");
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700320
Ben Hutchings9f13a1f2012-01-10 03:04:32 +0000321 cpu_dev_register_generic();
322
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800323#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
Ben Hutchings024f7842012-01-10 02:59:49 +0000324 sched_create_sysfs_power_savings_entries(cpu_subsys.dev_root);
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800325#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}