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#include <linux/cpufeature.h>
19
20#include "base.h"
21
22static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
23
24static 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
33#ifdef CONFIG_HOTPLUG_CPU
34static 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
43static int __ref cpu_subsys_online(struct device *dev)
44{
45	struct cpu *cpu = container_of(dev, struct cpu, dev);
46	int cpuid = dev->id;
47	int from_nid, to_nid;
48	int ret;
49
50	from_nid = cpu_to_node(cpuid);
51	if (from_nid == NUMA_NO_NODE)
52		return -ENODEV;
53
54	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);
62
63	return ret;
64}
65
66static int cpu_subsys_offline(struct device *dev)
67{
68	return cpu_down(dev->id);
69}
70
71void unregister_cpu(struct cpu *cpu)
72{
73	int logical_cpu = cpu->dev.id;
74
75	unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
76
77	device_unregister(&cpu->dev);
78	per_cpu(cpu_sys_devices, logical_cpu) = NULL;
79	return;
80}
81
82#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
83static ssize_t cpu_probe_store(struct device *dev,
84			       struct device_attribute *attr,
85			       const char *buf,
86			       size_t count)
87{
88	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;
99}
100
101static ssize_t cpu_release_store(struct device *dev,
102				 struct device_attribute *attr,
103				 const char *buf,
104				 size_t count)
105{
106	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;
117}
118
119static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
120static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
121#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
122#endif /* CONFIG_HOTPLUG_CPU */
123
124struct bus_type cpu_subsys = {
125	.name = "cpu",
126	.dev_name = "cpu",
127	.match = cpu_subsys_match,
128#ifdef CONFIG_HOTPLUG_CPU
129	.online = cpu_subsys_online,
130	.offline = cpu_subsys_offline,
131#endif
132};
133EXPORT_SYMBOL_GPL(cpu_subsys);
134
135#ifdef CONFIG_KEXEC
136#include <linux/kexec.h>
137
138static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
139				char *buf)
140{
141	struct cpu *cpu = container_of(dev, struct cpu, dev);
142	ssize_t rc;
143	unsigned long long addr;
144	int cpunum;
145
146	cpunum = cpu->dev.id;
147
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	 */
154	addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
155	rc = sprintf(buf, "%Lx\n", addr);
156	return rc;
157}
158static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
159
160static ssize_t show_crash_notes_size(struct device *dev,
161				     struct device_attribute *attr,
162				     char *buf)
163{
164	ssize_t rc;
165
166	rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
167	return rc;
168}
169static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
170
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};
180#endif
181
182static const struct attribute_group *common_cpu_attr_groups[] = {
183#ifdef CONFIG_KEXEC
184	&crash_note_cpu_attr_group,
185#endif
186	NULL
187};
188
189static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
190#ifdef CONFIG_KEXEC
191	&crash_note_cpu_attr_group,
192#endif
193	NULL
194};
195
196/*
197 * Print cpu online, possible, present, and system maps
198 */
199
200struct cpu_attr {
201	struct device_attribute attr;
202	const struct cpumask *const * const map;
203};
204
205static ssize_t show_cpus_attr(struct device *dev,
206			      struct device_attribute *attr,
207			      char *buf)
208{
209	struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
210
211	return cpumap_print_to_pagebuf(true, buf, *ca->map);
212}
213
214#define _CPU_ATTR(name, map) \
215	{ __ATTR(name, 0444, show_cpus_attr, NULL), map }
216
217/* Keep in sync with cpu_subsys_attrs */
218static 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};
223
224/*
225 * Print values for NR_CPUS and offlined cpus
226 */
227static ssize_t print_cpus_kernel_max(struct device *dev,
228				     struct device_attribute *attr, char *buf)
229{
230	int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
231	return n;
232}
233static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
234
235/* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
236unsigned int total_cpus;
237
238static ssize_t print_cpus_offline(struct device *dev,
239				  struct device_attribute *attr, char *buf)
240{
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;
247	cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
248	n = scnprintf(buf, len, "%*pbl", cpumask_pr_args(offline));
249	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}
266static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
267
268static 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
283	 * on the linux-kernel list, you have been warned.
284	 */
285}
286
287#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}
309
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
322/*
323 * register_cpu - Setup a sysfs device for a CPU.
324 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
325 *	  sysfs for this CPU.
326 * @num - CPU number to use when creating the device.
327 *
328 * Initialize and register the CPU device.
329 */
330int register_cpu(struct cpu *cpu, int num)
331{
332	int error;
333
334	cpu->node_id = cpu_to_node(num);
335	memset(&cpu->dev, 0x00, sizeof(struct device));
336	cpu->dev.id = num;
337	cpu->dev.bus = &cpu_subsys;
338	cpu->dev.release = cpu_device_release;
339	cpu->dev.offline_disabled = !cpu->hotpluggable;
340	cpu->dev.offline = !cpu_online(num);
341	cpu->dev.of_node = of_get_cpu_node(num, NULL);
342#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
343	cpu->dev.bus->uevent = cpu_uevent;
344#endif
345	cpu->dev.groups = common_cpu_attr_groups;
346	if (cpu->hotpluggable)
347		cpu->dev.groups = hotplugable_cpu_attr_groups;
348	error = device_register(&cpu->dev);
349	if (!error)
350		per_cpu(cpu_sys_devices, num) = &cpu->dev;
351	if (!error)
352		register_cpu_under_node(num, cpu_to_node(num));
353
354	return error;
355}
356
357struct device *get_cpu_device(unsigned cpu)
358{
359	if (cpu < nr_cpu_ids && cpu_possible(cpu))
360		return per_cpu(cpu_sys_devices, cpu);
361	else
362		return NULL;
363}
364EXPORT_SYMBOL_GPL(get_cpu_device);
365
366static 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
420#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
421static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
422#endif
423
424static 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,
434#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
435	&dev_attr_modalias.attr,
436#endif
437	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};
448
449bool cpu_is_hotpluggable(unsigned cpu)
450{
451	struct device *dev = get_cpu_device(cpu);
452	return dev && container_of(dev, struct cpu, dev)->hotpluggable;
453}
454EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
455
456#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
472void __init cpu_dev_init(void)
473{
474	if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
475		panic("Failed to register CPU subsystem");
476
477	cpu_dev_register_generic();
478}
479