1 // SPDX-License-Identifier: GPL-2.0
3 * CPU subsystem support
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/sched.h>
10 #include <linux/cpu.h>
11 #include <linux/topology.h>
12 #include <linux/device.h>
13 #include <linux/node.h>
14 #include <linux/gfp.h>
15 #include <linux/slab.h>
16 #include <linux/percpu.h>
17 #include <linux/acpi.h>
19 #include <linux/cpufeature.h>
20 #include <linux/tick.h>
21 #include <linux/pm_qos.h>
22 #include <linux/sched/isolation.h>
26 static DEFINE_PER_CPU(struct device
*, cpu_sys_devices
);
28 static int cpu_subsys_match(struct device
*dev
, struct device_driver
*drv
)
30 /* ACPI style match is the only one that may succeed. */
31 if (acpi_driver_match_device(dev
, drv
))
37 #ifdef CONFIG_HOTPLUG_CPU
38 static void change_cpu_under_node(struct cpu
*cpu
,
39 unsigned int from_nid
, unsigned int to_nid
)
41 int cpuid
= cpu
->dev
.id
;
42 unregister_cpu_under_node(cpuid
, from_nid
);
43 register_cpu_under_node(cpuid
, to_nid
);
44 cpu
->node_id
= to_nid
;
47 static int cpu_subsys_online(struct device
*dev
)
49 struct cpu
*cpu
= container_of(dev
, struct cpu
, dev
);
54 from_nid
= cpu_to_node(cpuid
);
55 if (from_nid
== NUMA_NO_NODE
)
60 * When hot adding memory to memoryless node and enabling a cpu
61 * on the node, node number of the cpu may internally change.
63 to_nid
= cpu_to_node(cpuid
);
64 if (from_nid
!= to_nid
)
65 change_cpu_under_node(cpu
, from_nid
, to_nid
);
70 static int cpu_subsys_offline(struct device
*dev
)
72 return cpu_down(dev
->id
);
75 void unregister_cpu(struct cpu
*cpu
)
77 int logical_cpu
= cpu
->dev
.id
;
79 unregister_cpu_under_node(logical_cpu
, cpu_to_node(logical_cpu
));
81 device_unregister(&cpu
->dev
);
82 per_cpu(cpu_sys_devices
, logical_cpu
) = NULL
;
86 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
87 static ssize_t
cpu_probe_store(struct device
*dev
,
88 struct device_attribute
*attr
,
95 ret
= lock_device_hotplug_sysfs();
99 cnt
= arch_cpu_probe(buf
, count
);
101 unlock_device_hotplug();
105 static ssize_t
cpu_release_store(struct device
*dev
,
106 struct device_attribute
*attr
,
113 ret
= lock_device_hotplug_sysfs();
117 cnt
= arch_cpu_release(buf
, count
);
119 unlock_device_hotplug();
123 static DEVICE_ATTR(probe
, S_IWUSR
, NULL
, cpu_probe_store
);
124 static DEVICE_ATTR(release
, S_IWUSR
, NULL
, cpu_release_store
);
125 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
126 #endif /* CONFIG_HOTPLUG_CPU */
128 struct bus_type cpu_subsys
= {
131 .match
= cpu_subsys_match
,
132 #ifdef CONFIG_HOTPLUG_CPU
133 .online
= cpu_subsys_online
,
134 .offline
= cpu_subsys_offline
,
137 EXPORT_SYMBOL_GPL(cpu_subsys
);
140 #include <linux/kexec.h>
142 static ssize_t
show_crash_notes(struct device
*dev
, struct device_attribute
*attr
,
145 struct cpu
*cpu
= container_of(dev
, struct cpu
, dev
);
147 unsigned long long addr
;
150 cpunum
= cpu
->dev
.id
;
153 * Might be reading other cpu's data based on which cpu read thread
154 * has been scheduled. But cpu data (memory) is allocated once during
155 * boot up and this data does not change there after. Hence this
156 * operation should be safe. No locking required.
158 addr
= per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes
, cpunum
));
159 rc
= sprintf(buf
, "%Lx\n", addr
);
162 static DEVICE_ATTR(crash_notes
, 0400, show_crash_notes
, NULL
);
164 static ssize_t
show_crash_notes_size(struct device
*dev
,
165 struct device_attribute
*attr
,
170 rc
= sprintf(buf
, "%zu\n", sizeof(note_buf_t
));
173 static DEVICE_ATTR(crash_notes_size
, 0400, show_crash_notes_size
, NULL
);
175 static struct attribute
*crash_note_cpu_attrs
[] = {
176 &dev_attr_crash_notes
.attr
,
177 &dev_attr_crash_notes_size
.attr
,
181 static struct attribute_group crash_note_cpu_attr_group
= {
182 .attrs
= crash_note_cpu_attrs
,
186 static const struct attribute_group
*common_cpu_attr_groups
[] = {
188 &crash_note_cpu_attr_group
,
193 static const struct attribute_group
*hotplugable_cpu_attr_groups
[] = {
195 &crash_note_cpu_attr_group
,
201 * Print cpu online, possible, present, and system maps
205 struct device_attribute attr
;
206 const struct cpumask
*const map
;
209 static ssize_t
show_cpus_attr(struct device
*dev
,
210 struct device_attribute
*attr
,
213 struct cpu_attr
*ca
= container_of(attr
, struct cpu_attr
, attr
);
215 return cpumap_print_to_pagebuf(true, buf
, ca
->map
);
218 #define _CPU_ATTR(name, map) \
219 { __ATTR(name, 0444, show_cpus_attr, NULL), map }
221 /* Keep in sync with cpu_subsys_attrs */
222 static struct cpu_attr cpu_attrs
[] = {
223 _CPU_ATTR(online
, &__cpu_online_mask
),
224 _CPU_ATTR(possible
, &__cpu_possible_mask
),
225 _CPU_ATTR(present
, &__cpu_present_mask
),
229 * Print values for NR_CPUS and offlined cpus
231 static ssize_t
print_cpus_kernel_max(struct device
*dev
,
232 struct device_attribute
*attr
, char *buf
)
234 int n
= snprintf(buf
, PAGE_SIZE
-2, "%d\n", NR_CPUS
- 1);
237 static DEVICE_ATTR(kernel_max
, 0444, print_cpus_kernel_max
, NULL
);
239 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
240 unsigned int total_cpus
;
242 static ssize_t
print_cpus_offline(struct device
*dev
,
243 struct device_attribute
*attr
, char *buf
)
245 int n
= 0, len
= PAGE_SIZE
-2;
246 cpumask_var_t offline
;
248 /* display offline cpus < nr_cpu_ids */
249 if (!alloc_cpumask_var(&offline
, GFP_KERNEL
))
251 cpumask_andnot(offline
, cpu_possible_mask
, cpu_online_mask
);
252 n
= scnprintf(buf
, len
, "%*pbl", cpumask_pr_args(offline
));
253 free_cpumask_var(offline
);
255 /* display offline cpus >= nr_cpu_ids */
256 if (total_cpus
&& nr_cpu_ids
< total_cpus
) {
260 if (nr_cpu_ids
== total_cpus
-1)
261 n
+= snprintf(&buf
[n
], len
- n
, "%u", nr_cpu_ids
);
263 n
+= snprintf(&buf
[n
], len
- n
, "%u-%d",
264 nr_cpu_ids
, total_cpus
-1);
267 n
+= snprintf(&buf
[n
], len
- n
, "\n");
270 static DEVICE_ATTR(offline
, 0444, print_cpus_offline
, NULL
);
272 static ssize_t
print_cpus_isolated(struct device
*dev
,
273 struct device_attribute
*attr
, char *buf
)
275 int n
= 0, len
= PAGE_SIZE
-2;
276 cpumask_var_t isolated
;
278 if (!alloc_cpumask_var(&isolated
, GFP_KERNEL
))
281 cpumask_andnot(isolated
, cpu_possible_mask
,
282 housekeeping_cpumask(HK_FLAG_DOMAIN
));
283 n
= scnprintf(buf
, len
, "%*pbl\n", cpumask_pr_args(isolated
));
285 free_cpumask_var(isolated
);
289 static DEVICE_ATTR(isolated
, 0444, print_cpus_isolated
, NULL
);
291 #ifdef CONFIG_NO_HZ_FULL
292 static ssize_t
print_cpus_nohz_full(struct device
*dev
,
293 struct device_attribute
*attr
, char *buf
)
295 int n
= 0, len
= PAGE_SIZE
-2;
297 n
= scnprintf(buf
, len
, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask
));
301 static DEVICE_ATTR(nohz_full
, 0444, print_cpus_nohz_full
, NULL
);
304 static void cpu_device_release(struct device
*dev
)
307 * This is an empty function to prevent the driver core from spitting a
308 * warning at us. Yes, I know this is directly opposite of what the
309 * documentation for the driver core and kobjects say, and the author
310 * of this code has already been publically ridiculed for doing
311 * something as foolish as this. However, at this point in time, it is
312 * the only way to handle the issue of statically allocated cpu
313 * devices. The different architectures will have their cpu device
314 * code reworked to properly handle this in the near future, so this
315 * function will then be changed to correctly free up the memory held
318 * Never copy this way of doing things, or you too will be made fun of
319 * on the linux-kernel list, you have been warned.
323 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
324 static ssize_t
print_cpu_modalias(struct device
*dev
,
325 struct device_attribute
*attr
,
331 n
= sprintf(buf
, "cpu:type:" CPU_FEATURE_TYPEFMT
":feature:",
332 CPU_FEATURE_TYPEVAL
);
334 for (i
= 0; i
< MAX_CPU_FEATURES
; i
++)
335 if (cpu_have_feature(i
)) {
336 if (PAGE_SIZE
< n
+ sizeof(",XXXX\n")) {
337 WARN(1, "CPU features overflow page\n");
340 n
+= sprintf(&buf
[n
], ",%04X", i
);
346 static int cpu_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
348 char *buf
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
350 print_cpu_modalias(NULL
, NULL
, buf
);
351 add_uevent_var(env
, "MODALIAS=%s", buf
);
359 * register_cpu - Setup a sysfs device for a CPU.
360 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
361 * sysfs for this CPU.
362 * @num - CPU number to use when creating the device.
364 * Initialize and register the CPU device.
366 int register_cpu(struct cpu
*cpu
, int num
)
370 cpu
->node_id
= cpu_to_node(num
);
371 memset(&cpu
->dev
, 0x00, sizeof(struct device
));
373 cpu
->dev
.bus
= &cpu_subsys
;
374 cpu
->dev
.release
= cpu_device_release
;
375 cpu
->dev
.offline_disabled
= !cpu
->hotpluggable
;
376 cpu
->dev
.offline
= !cpu_online(num
);
377 cpu
->dev
.of_node
= of_get_cpu_node(num
, NULL
);
378 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
379 cpu
->dev
.bus
->uevent
= cpu_uevent
;
381 cpu
->dev
.groups
= common_cpu_attr_groups
;
382 if (cpu
->hotpluggable
)
383 cpu
->dev
.groups
= hotplugable_cpu_attr_groups
;
384 error
= device_register(&cpu
->dev
);
388 per_cpu(cpu_sys_devices
, num
) = &cpu
->dev
;
389 register_cpu_under_node(num
, cpu_to_node(num
));
390 dev_pm_qos_expose_latency_limit(&cpu
->dev
,
391 PM_QOS_RESUME_LATENCY_NO_CONSTRAINT
);
396 struct device
*get_cpu_device(unsigned cpu
)
398 if (cpu
< nr_cpu_ids
&& cpu_possible(cpu
))
399 return per_cpu(cpu_sys_devices
, cpu
);
403 EXPORT_SYMBOL_GPL(get_cpu_device
);
405 static void device_create_release(struct device
*dev
)
410 static struct device
*
411 __cpu_device_create(struct device
*parent
, void *drvdata
,
412 const struct attribute_group
**groups
,
413 const char *fmt
, va_list args
)
415 struct device
*dev
= NULL
;
416 int retval
= -ENODEV
;
418 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
424 device_initialize(dev
);
425 dev
->parent
= parent
;
426 dev
->groups
= groups
;
427 dev
->release
= device_create_release
;
428 dev_set_drvdata(dev
, drvdata
);
430 retval
= kobject_set_name_vargs(&dev
->kobj
, fmt
, args
);
434 retval
= device_add(dev
);
442 return ERR_PTR(retval
);
445 struct device
*cpu_device_create(struct device
*parent
, void *drvdata
,
446 const struct attribute_group
**groups
,
447 const char *fmt
, ...)
452 va_start(vargs
, fmt
);
453 dev
= __cpu_device_create(parent
, drvdata
, groups
, fmt
, vargs
);
457 EXPORT_SYMBOL_GPL(cpu_device_create
);
459 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
460 static DEVICE_ATTR(modalias
, 0444, print_cpu_modalias
, NULL
);
463 static struct attribute
*cpu_root_attrs
[] = {
464 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
465 &dev_attr_probe
.attr
,
466 &dev_attr_release
.attr
,
468 &cpu_attrs
[0].attr
.attr
,
469 &cpu_attrs
[1].attr
.attr
,
470 &cpu_attrs
[2].attr
.attr
,
471 &dev_attr_kernel_max
.attr
,
472 &dev_attr_offline
.attr
,
473 &dev_attr_isolated
.attr
,
474 #ifdef CONFIG_NO_HZ_FULL
475 &dev_attr_nohz_full
.attr
,
477 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
478 &dev_attr_modalias
.attr
,
483 static struct attribute_group cpu_root_attr_group
= {
484 .attrs
= cpu_root_attrs
,
487 static const struct attribute_group
*cpu_root_attr_groups
[] = {
488 &cpu_root_attr_group
,
492 bool cpu_is_hotpluggable(unsigned cpu
)
494 struct device
*dev
= get_cpu_device(cpu
);
495 return dev
&& container_of(dev
, struct cpu
, dev
)->hotpluggable
;
497 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable
);
499 #ifdef CONFIG_GENERIC_CPU_DEVICES
500 static DEFINE_PER_CPU(struct cpu
, cpu_devices
);
503 static void __init
cpu_dev_register_generic(void)
505 #ifdef CONFIG_GENERIC_CPU_DEVICES
508 for_each_possible_cpu(i
) {
509 if (register_cpu(&per_cpu(cpu_devices
, i
), i
))
510 panic("Failed to register CPU device");
515 #ifdef CONFIG_GENERIC_CPU_VULNERABILITIES
517 ssize_t __weak
cpu_show_meltdown(struct device
*dev
,
518 struct device_attribute
*attr
, char *buf
)
520 return sprintf(buf
, "Not affected\n");
523 ssize_t __weak
cpu_show_spectre_v1(struct device
*dev
,
524 struct device_attribute
*attr
, char *buf
)
526 return sprintf(buf
, "Not affected\n");
529 ssize_t __weak
cpu_show_spectre_v2(struct device
*dev
,
530 struct device_attribute
*attr
, char *buf
)
532 return sprintf(buf
, "Not affected\n");
535 ssize_t __weak
cpu_show_spec_store_bypass(struct device
*dev
,
536 struct device_attribute
*attr
, char *buf
)
538 return sprintf(buf
, "Not affected\n");
541 static DEVICE_ATTR(meltdown
, 0444, cpu_show_meltdown
, NULL
);
542 static DEVICE_ATTR(spectre_v1
, 0444, cpu_show_spectre_v1
, NULL
);
543 static DEVICE_ATTR(spectre_v2
, 0444, cpu_show_spectre_v2
, NULL
);
544 static DEVICE_ATTR(spec_store_bypass
, 0444, cpu_show_spec_store_bypass
, NULL
);
546 static struct attribute
*cpu_root_vulnerabilities_attrs
[] = {
547 &dev_attr_meltdown
.attr
,
548 &dev_attr_spectre_v1
.attr
,
549 &dev_attr_spectre_v2
.attr
,
550 &dev_attr_spec_store_bypass
.attr
,
554 static const struct attribute_group cpu_root_vulnerabilities_group
= {
555 .name
= "vulnerabilities",
556 .attrs
= cpu_root_vulnerabilities_attrs
,
559 static void __init
cpu_register_vulnerabilities(void)
561 if (sysfs_create_group(&cpu_subsys
.dev_root
->kobj
,
562 &cpu_root_vulnerabilities_group
))
563 pr_err("Unable to register CPU vulnerabilities\n");
567 static inline void cpu_register_vulnerabilities(void) { }
570 void __init
cpu_dev_init(void)
572 if (subsys_system_register(&cpu_subsys
, cpu_root_attr_groups
))
573 panic("Failed to register CPU subsystem");
575 cpu_dev_register_generic();
576 cpu_register_vulnerabilities();