projects/linux·blob v4.13 · refs

510 lines · 11.9 KiB

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#include <linux/tick.h>
20#include <linux/pm_qos.h>
21
22#include "base.h"
23
24static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
25
26static int cpu_subsys_match(struct device *dev, struct device_driver *drv)
27{
28 /* ACPI style match is the only one that may succeed. */
29 if (acpi_driver_match_device(dev, drv))
30 return 1;
31
32 return 0;
33}
34
35#ifdef CONFIG_HOTPLUG_CPU
36static void change_cpu_under_node(struct cpu *cpu,
37 unsigned int from_nid, unsigned int to_nid)
38{
39 int cpuid = cpu->dev.id;
40 unregister_cpu_under_node(cpuid, from_nid);
41 register_cpu_under_node(cpuid, to_nid);
42 cpu->node_id = to_nid;
43}
44
45static int cpu_subsys_online(struct device *dev)
46{
47 struct cpu *cpu = container_of(dev, struct cpu, dev);
48 int cpuid = dev->id;
49 int from_nid, to_nid;
50 int ret;
51
52 from_nid = cpu_to_node(cpuid);
53 if (from_nid == NUMA_NO_NODE)
54 return -ENODEV;
55
56 ret = cpu_up(cpuid);
57 /*
58 * When hot adding memory to memoryless node and enabling a cpu
59 * on the node, node number of the cpu may internally change.
60 */
61 to_nid = cpu_to_node(cpuid);
62 if (from_nid != to_nid)
63 change_cpu_under_node(cpu, from_nid, to_nid);
64
65 return ret;
66}
67
68static int cpu_subsys_offline(struct device *dev)
69{
70 return cpu_down(dev->id);
71}
72
73void unregister_cpu(struct cpu *cpu)
74{
75 int logical_cpu = cpu->dev.id;
76
77 unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
78
79 device_unregister(&cpu->dev);
80 per_cpu(cpu_sys_devices, logical_cpu) = NULL;
81 return;
82}
83
84#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
85static ssize_t cpu_probe_store(struct device *dev,
86 struct device_attribute *attr,
87 const char *buf,
88 size_t count)
89{
90 ssize_t cnt;
91 int ret;
92
93 ret = lock_device_hotplug_sysfs();
94 if (ret)
95 return ret;
96
97 cnt = arch_cpu_probe(buf, count);
98
99 unlock_device_hotplug();
100 return cnt;
101}
102
103static ssize_t cpu_release_store(struct device *dev,
104 struct device_attribute *attr,
105 const char *buf,
106 size_t count)
107{
108 ssize_t cnt;
109 int ret;
110
111 ret = lock_device_hotplug_sysfs();
112 if (ret)
113 return ret;
114
115 cnt = arch_cpu_release(buf, count);
116
117 unlock_device_hotplug();
118 return cnt;
119}
120
121static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
122static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
123#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
124#endif /* CONFIG_HOTPLUG_CPU */
125
126struct bus_type cpu_subsys = {
127 .name = "cpu",
128 .dev_name = "cpu",
129 .match = cpu_subsys_match,
130#ifdef CONFIG_HOTPLUG_CPU
131 .online = cpu_subsys_online,
132 .offline = cpu_subsys_offline,
133#endif
134};
135EXPORT_SYMBOL_GPL(cpu_subsys);
136
137#ifdef CONFIG_KEXEC
138#include <linux/kexec.h>
139
140static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
141 char *buf)
142{
143 struct cpu *cpu = container_of(dev, struct cpu, dev);
144 ssize_t rc;
145 unsigned long long addr;
146 int cpunum;
147
148 cpunum = cpu->dev.id;
149
150 /*
151 * Might be reading other cpu's data based on which cpu read thread
152 * has been scheduled. But cpu data (memory) is allocated once during
153 * boot up and this data does not change there after. Hence this
154 * operation should be safe. No locking required.
155 */
156 addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
157 rc = sprintf(buf, "%Lx\n", addr);
158 return rc;
159}
160static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
161
162static ssize_t show_crash_notes_size(struct device *dev,
163 struct device_attribute *attr,
164 char *buf)
165{
166 ssize_t rc;
167
168 rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
169 return rc;
170}
171static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
172
173static struct attribute *crash_note_cpu_attrs[] = {
174 &dev_attr_crash_notes.attr,
175 &dev_attr_crash_notes_size.attr,
176 NULL
177};
178
179static struct attribute_group crash_note_cpu_attr_group = {
180 .attrs = crash_note_cpu_attrs,
181};
182#endif
183
184static const struct attribute_group *common_cpu_attr_groups[] = {
185#ifdef CONFIG_KEXEC
186 &crash_note_cpu_attr_group,
187#endif
188 NULL
189};
190
191static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
192#ifdef CONFIG_KEXEC
193 &crash_note_cpu_attr_group,
194#endif
195 NULL
196};
197
198/*
199 * Print cpu online, possible, present, and system maps
200 */
201
202struct cpu_attr {
203 struct device_attribute attr;
204 const struct cpumask *const map;
205};
206
207static ssize_t show_cpus_attr(struct device *dev,
208 struct device_attribute *attr,
209 char *buf)
210{
211 struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
212
213 return cpumap_print_to_pagebuf(true, buf, ca->map);
214}
215
216#define _CPU_ATTR(name, map) \
217 { __ATTR(name, 0444, show_cpus_attr, NULL), map }
218
219/* Keep in sync with cpu_subsys_attrs */
220static struct cpu_attr cpu_attrs[] = {
221 _CPU_ATTR(online, &__cpu_online_mask),
222 _CPU_ATTR(possible, &__cpu_possible_mask),
223 _CPU_ATTR(present, &__cpu_present_mask),
224};
225
226/*
227 * Print values for NR_CPUS and offlined cpus
228 */
229static ssize_t print_cpus_kernel_max(struct device *dev,
230 struct device_attribute *attr, char *buf)
231{
232 int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
233 return n;
234}
235static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
236
237/* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
238unsigned int total_cpus;
239
240static ssize_t print_cpus_offline(struct device *dev,
241 struct device_attribute *attr, char *buf)
242{
243 int n = 0, len = PAGE_SIZE-2;
244 cpumask_var_t offline;
245
246 /* display offline cpus < nr_cpu_ids */
247 if (!alloc_cpumask_var(&offline, GFP_KERNEL))
248 return -ENOMEM;
249 cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
250 n = scnprintf(buf, len, "%*pbl", cpumask_pr_args(offline));
251 free_cpumask_var(offline);
252
253 /* display offline cpus >= nr_cpu_ids */
254 if (total_cpus && nr_cpu_ids < total_cpus) {
255 if (n && n < len)
256 buf[n++] = ',';
257
258 if (nr_cpu_ids == total_cpus-1)
259 n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
260 else
261 n += snprintf(&buf[n], len - n, "%d-%d",
262 nr_cpu_ids, total_cpus-1);
263 }
264
265 n += snprintf(&buf[n], len - n, "\n");
266 return n;
267}
268static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
269
270static ssize_t print_cpus_isolated(struct device *dev,
271 struct device_attribute *attr, char *buf)
272{
273 int n = 0, len = PAGE_SIZE-2;
274
275 n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(cpu_isolated_map));
276
277 return n;
278}
279static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL);
280
281#ifdef CONFIG_NO_HZ_FULL
282static ssize_t print_cpus_nohz_full(struct device *dev,
283 struct device_attribute *attr, char *buf)
284{
285 int n = 0, len = PAGE_SIZE-2;
286
287 n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask));
288
289 return n;
290}
291static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL);
292#endif
293
294static void cpu_device_release(struct device *dev)
295{
296 /*
297 * This is an empty function to prevent the driver core from spitting a
298 * warning at us. Yes, I know this is directly opposite of what the
299 * documentation for the driver core and kobjects say, and the author
300 * of this code has already been publically ridiculed for doing
301 * something as foolish as this. However, at this point in time, it is
302 * the only way to handle the issue of statically allocated cpu
303 * devices. The different architectures will have their cpu device
304 * code reworked to properly handle this in the near future, so this
305 * function will then be changed to correctly free up the memory held
306 * by the cpu device.
307 *
308 * Never copy this way of doing things, or you too will be made fun of
309 * on the linux-kernel list, you have been warned.
310 */
311}
312
313#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
314static ssize_t print_cpu_modalias(struct device *dev,
315 struct device_attribute *attr,
316 char *buf)
317{
318 ssize_t n;
319 u32 i;
320
321 n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
322 CPU_FEATURE_TYPEVAL);
323
324 for (i = 0; i < MAX_CPU_FEATURES; i++)
325 if (cpu_have_feature(i)) {
326 if (PAGE_SIZE < n + sizeof(",XXXX\n")) {
327 WARN(1, "CPU features overflow page\n");
328 break;
329 }
330 n += sprintf(&buf[n], ",%04X", i);
331 }
332 buf[n++] = '\n';
333 return n;
334}
335
336static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env)
337{
338 char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
339 if (buf) {
340 print_cpu_modalias(NULL, NULL, buf);
341 add_uevent_var(env, "MODALIAS=%s", buf);
342 kfree(buf);
343 }
344 return 0;
345}
346#endif
347
348/*
349 * register_cpu - Setup a sysfs device for a CPU.
350 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
351 * sysfs for this CPU.
352 * @num - CPU number to use when creating the device.
353 *
354 * Initialize and register the CPU device.
355 */
356int register_cpu(struct cpu *cpu, int num)
357{
358 int error;
359
360 cpu->node_id = cpu_to_node(num);
361 memset(&cpu->dev, 0x00, sizeof(struct device));
362 cpu->dev.id = num;
363 cpu->dev.bus = &cpu_subsys;
364 cpu->dev.release = cpu_device_release;
365 cpu->dev.offline_disabled = !cpu->hotpluggable;
366 cpu->dev.offline = !cpu_online(num);
367 cpu->dev.of_node = of_get_cpu_node(num, NULL);
368#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
369 cpu->dev.bus->uevent = cpu_uevent;
370#endif
371 cpu->dev.groups = common_cpu_attr_groups;
372 if (cpu->hotpluggable)
373 cpu->dev.groups = hotplugable_cpu_attr_groups;
374 error = device_register(&cpu->dev);
375 if (error)
376 return error;
377
378 per_cpu(cpu_sys_devices, num) = &cpu->dev;
379 register_cpu_under_node(num, cpu_to_node(num));
380 dev_pm_qos_expose_latency_limit(&cpu->dev, 0);
381
382 return 0;
383}
384
385struct device *get_cpu_device(unsigned cpu)
386{
387 if (cpu < nr_cpu_ids && cpu_possible(cpu))
388 return per_cpu(cpu_sys_devices, cpu);
389 else
390 return NULL;
391}
392EXPORT_SYMBOL_GPL(get_cpu_device);
393
394static void device_create_release(struct device *dev)
395{
396 kfree(dev);
397}
398
399static struct device *
400__cpu_device_create(struct device *parent, void *drvdata,
401 const struct attribute_group **groups,
402 const char *fmt, va_list args)
403{
404 struct device *dev = NULL;
405 int retval = -ENODEV;
406
407 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
408 if (!dev) {
409 retval = -ENOMEM;
410 goto error;
411 }
412
413 device_initialize(dev);
414 dev->parent = parent;
415 dev->groups = groups;
416 dev->release = device_create_release;
417 dev_set_drvdata(dev, drvdata);
418
419 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
420 if (retval)
421 goto error;
422
423 retval = device_add(dev);
424 if (retval)
425 goto error;
426
427 return dev;
428
429error:
430 put_device(dev);
431 return ERR_PTR(retval);
432}
433
434struct device *cpu_device_create(struct device *parent, void *drvdata,
435 const struct attribute_group **groups,
436 const char *fmt, ...)
437{
438 va_list vargs;
439 struct device *dev;
440
441 va_start(vargs, fmt);
442 dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs);
443 va_end(vargs);
444 return dev;
445}
446EXPORT_SYMBOL_GPL(cpu_device_create);
447
448#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
449static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
450#endif
451
452static struct attribute *cpu_root_attrs[] = {
453#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
454 &dev_attr_probe.attr,
455 &dev_attr_release.attr,
456#endif
457 &cpu_attrs[0].attr.attr,
458 &cpu_attrs[1].attr.attr,
459 &cpu_attrs[2].attr.attr,
460 &dev_attr_kernel_max.attr,
461 &dev_attr_offline.attr,
462 &dev_attr_isolated.attr,
463#ifdef CONFIG_NO_HZ_FULL
464 &dev_attr_nohz_full.attr,
465#endif
466#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
467 &dev_attr_modalias.attr,
468#endif
469 NULL
470};
471
472static struct attribute_group cpu_root_attr_group = {
473 .attrs = cpu_root_attrs,
474};
475
476static const struct attribute_group *cpu_root_attr_groups[] = {
477 &cpu_root_attr_group,
478 NULL,
479};
480
481bool cpu_is_hotpluggable(unsigned cpu)
482{
483 struct device *dev = get_cpu_device(cpu);
484 return dev && container_of(dev, struct cpu, dev)->hotpluggable;
485}
486EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
487
488#ifdef CONFIG_GENERIC_CPU_DEVICES
489static DEFINE_PER_CPU(struct cpu, cpu_devices);
490#endif
491
492static void __init cpu_dev_register_generic(void)
493{
494#ifdef CONFIG_GENERIC_CPU_DEVICES
495 int i;
496
497 for_each_possible_cpu(i) {
498 if (register_cpu(&per_cpu(cpu_devices, i), i))
499 panic("Failed to register CPU device");
500 }
501#endif
502}
503
504void __init cpu_dev_init(void)
505{
506 if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
507 panic("Failed to register CPU subsystem");
508
509 cpu_dev_register_generic();
510}