Branch data Line data Source code
1 : : /* CPU control.
2 : : * (C) 2001, 2002, 2003, 2004 Rusty Russell
3 : : *
4 : : * This code is licenced under the GPL.
5 : : */
6 : : #include <linux/sched/mm.h>
7 : : #include <linux/proc_fs.h>
8 : : #include <linux/smp.h>
9 : : #include <linux/init.h>
10 : : #include <linux/notifier.h>
11 : : #include <linux/sched/signal.h>
12 : : #include <linux/sched/hotplug.h>
13 : : #include <linux/sched/isolation.h>
14 : : #include <linux/sched/task.h>
15 : : #include <linux/sched/smt.h>
16 : : #include <linux/unistd.h>
17 : : #include <linux/cpu.h>
18 : : #include <linux/oom.h>
19 : : #include <linux/rcupdate.h>
20 : : #include <linux/export.h>
21 : : #include <linux/bug.h>
22 : : #include <linux/kthread.h>
23 : : #include <linux/stop_machine.h>
24 : : #include <linux/mutex.h>
25 : : #include <linux/gfp.h>
26 : : #include <linux/suspend.h>
27 : : #include <linux/lockdep.h>
28 : : #include <linux/tick.h>
29 : : #include <linux/irq.h>
30 : : #include <linux/nmi.h>
31 : : #include <linux/smpboot.h>
32 : : #include <linux/relay.h>
33 : : #include <linux/slab.h>
34 : : #include <linux/percpu-rwsem.h>
35 : :
36 : : #include <trace/events/power.h>
37 : : #define CREATE_TRACE_POINTS
38 : : #include <trace/events/cpuhp.h>
39 : :
40 : : #include "smpboot.h"
41 : :
42 : : /**
43 : : * cpuhp_cpu_state - Per cpu hotplug state storage
44 : : * @state: The current cpu state
45 : : * @target: The target state
46 : : * @thread: Pointer to the hotplug thread
47 : : * @should_run: Thread should execute
48 : : * @rollback: Perform a rollback
49 : : * @single: Single callback invocation
50 : : * @bringup: Single callback bringup or teardown selector
51 : : * @cb_state: The state for a single callback (install/uninstall)
52 : : * @result: Result of the operation
53 : : * @done_up: Signal completion to the issuer of the task for cpu-up
54 : : * @done_down: Signal completion to the issuer of the task for cpu-down
55 : : */
56 : : struct cpuhp_cpu_state {
57 : : enum cpuhp_state state;
58 : : enum cpuhp_state target;
59 : : enum cpuhp_state fail;
60 : : #ifdef CONFIG_SMP
61 : : struct task_struct *thread;
62 : : bool should_run;
63 : : bool rollback;
64 : : bool single;
65 : : bool bringup;
66 : : struct hlist_node *node;
67 : : struct hlist_node *last;
68 : : enum cpuhp_state cb_state;
69 : : int result;
70 : : struct completion done_up;
71 : : struct completion done_down;
72 : : #endif
73 : : };
74 : :
75 : : static DEFINE_PER_CPU(struct cpuhp_cpu_state, cpuhp_state) = {
76 : : .fail = CPUHP_INVALID,
77 : : };
78 : :
79 : : #ifdef CONFIG_SMP
80 : : cpumask_t cpus_booted_once_mask;
81 : : #endif
82 : :
83 : : #if defined(CONFIG_LOCKDEP) && defined(CONFIG_SMP)
84 : : static struct lockdep_map cpuhp_state_up_map =
85 : : STATIC_LOCKDEP_MAP_INIT("cpuhp_state-up", &cpuhp_state_up_map);
86 : : static struct lockdep_map cpuhp_state_down_map =
87 : : STATIC_LOCKDEP_MAP_INIT("cpuhp_state-down", &cpuhp_state_down_map);
88 : :
89 : :
90 : : static inline void cpuhp_lock_acquire(bool bringup)
91 : : {
92 : : lock_map_acquire(bringup ? &cpuhp_state_up_map : &cpuhp_state_down_map);
93 : : }
94 : :
95 : : static inline void cpuhp_lock_release(bool bringup)
96 : : {
97 : : lock_map_release(bringup ? &cpuhp_state_up_map : &cpuhp_state_down_map);
98 : : }
99 : : #else
100 : :
101 : : static inline void cpuhp_lock_acquire(bool bringup) { }
102 : : static inline void cpuhp_lock_release(bool bringup) { }
103 : :
104 : : #endif
105 : :
106 : : /**
107 : : * cpuhp_step - Hotplug state machine step
108 : : * @name: Name of the step
109 : : * @startup: Startup function of the step
110 : : * @teardown: Teardown function of the step
111 : : * @cant_stop: Bringup/teardown can't be stopped at this step
112 : : */
113 : : struct cpuhp_step {
114 : : const char *name;
115 : : union {
116 : : int (*single)(unsigned int cpu);
117 : : int (*multi)(unsigned int cpu,
118 : : struct hlist_node *node);
119 : : } startup;
120 : : union {
121 : : int (*single)(unsigned int cpu);
122 : : int (*multi)(unsigned int cpu,
123 : : struct hlist_node *node);
124 : : } teardown;
125 : : struct hlist_head list;
126 : : bool cant_stop;
127 : : bool multi_instance;
128 : : };
129 : :
130 : : static DEFINE_MUTEX(cpuhp_state_mutex);
131 : : static struct cpuhp_step cpuhp_hp_states[];
132 : :
133 : : static struct cpuhp_step *cpuhp_get_step(enum cpuhp_state state)
134 : : {
135 : 3 : return cpuhp_hp_states + state;
136 : : }
137 : :
138 : : /**
139 : : * cpuhp_invoke_callback _ Invoke the callbacks for a given state
140 : : * @cpu: The cpu for which the callback should be invoked
141 : : * @state: The state to do callbacks for
142 : : * @bringup: True if the bringup callback should be invoked
143 : : * @node: For multi-instance, do a single entry callback for install/remove
144 : : * @lastp: For multi-instance rollback, remember how far we got
145 : : *
146 : : * Called from cpu hotplug and from the state register machinery.
147 : : */
148 : 3 : static int cpuhp_invoke_callback(unsigned int cpu, enum cpuhp_state state,
149 : : bool bringup, struct hlist_node *node,
150 : : struct hlist_node **lastp)
151 : : {
152 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
153 : : struct cpuhp_step *step = cpuhp_get_step(state);
154 : : int (*cbm)(unsigned int cpu, struct hlist_node *node);
155 : : int (*cb)(unsigned int cpu);
156 : : int ret, cnt;
157 : :
158 : 3 : if (st->fail == state) {
159 : 0 : st->fail = CPUHP_INVALID;
160 : :
161 : 0 : if (!(bringup ? step->startup.single : step->teardown.single))
162 : : return 0;
163 : :
164 : 0 : return -EAGAIN;
165 : : }
166 : :
167 : 3 : if (!step->multi_instance) {
168 : 3 : WARN_ON_ONCE(lastp && *lastp);
169 : 3 : cb = bringup ? step->startup.single : step->teardown.single;
170 : 3 : if (!cb)
171 : : return 0;
172 : 3 : trace_cpuhp_enter(cpu, st->target, state, cb);
173 : 3 : ret = cb(cpu);
174 : 3 : trace_cpuhp_exit(cpu, st->state, state, ret);
175 : 3 : return ret;
176 : : }
177 : 3 : cbm = bringup ? step->startup.multi : step->teardown.multi;
178 : 3 : if (!cbm)
179 : : return 0;
180 : :
181 : : /* Single invocation for instance add/remove */
182 : 3 : if (node) {
183 : 3 : WARN_ON_ONCE(lastp && *lastp);
184 : 3 : trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
185 : 3 : ret = cbm(cpu, node);
186 : 3 : trace_cpuhp_exit(cpu, st->state, state, ret);
187 : 3 : return ret;
188 : : }
189 : :
190 : : /* State transition. Invoke on all instances */
191 : : cnt = 0;
192 : 3 : hlist_for_each(node, &step->list) {
193 : 3 : if (lastp && node == *lastp)
194 : : break;
195 : :
196 : 3 : trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
197 : 3 : ret = cbm(cpu, node);
198 : 3 : trace_cpuhp_exit(cpu, st->state, state, ret);
199 : 3 : if (ret) {
200 : 0 : if (!lastp)
201 : : goto err;
202 : :
203 : 0 : *lastp = node;
204 : 0 : return ret;
205 : : }
206 : 3 : cnt++;
207 : : }
208 : 3 : if (lastp)
209 : 0 : *lastp = NULL;
210 : : return 0;
211 : : err:
212 : : /* Rollback the instances if one failed */
213 : 0 : cbm = !bringup ? step->startup.multi : step->teardown.multi;
214 : 0 : if (!cbm)
215 : 0 : return ret;
216 : :
217 : 0 : hlist_for_each(node, &step->list) {
218 : 0 : if (!cnt--)
219 : : break;
220 : :
221 : 0 : trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
222 : 0 : ret = cbm(cpu, node);
223 : 0 : trace_cpuhp_exit(cpu, st->state, state, ret);
224 : : /*
225 : : * Rollback must not fail,
226 : : */
227 : 0 : WARN_ON_ONCE(ret);
228 : : }
229 : 0 : return ret;
230 : : }
231 : :
232 : : #ifdef CONFIG_SMP
233 : : static bool cpuhp_is_ap_state(enum cpuhp_state state)
234 : : {
235 : : /*
236 : : * The extra check for CPUHP_TEARDOWN_CPU is only for documentation
237 : : * purposes as that state is handled explicitly in cpu_down.
238 : : */
239 : 3 : return state > CPUHP_BRINGUP_CPU && state != CPUHP_TEARDOWN_CPU;
240 : : }
241 : :
242 : : static inline void wait_for_ap_thread(struct cpuhp_cpu_state *st, bool bringup)
243 : : {
244 : 3 : struct completion *done = bringup ? &st->done_up : &st->done_down;
245 : 3 : wait_for_completion(done);
246 : : }
247 : :
248 : : static inline void complete_ap_thread(struct cpuhp_cpu_state *st, bool bringup)
249 : : {
250 : 3 : struct completion *done = bringup ? &st->done_up : &st->done_down;
251 : 3 : complete(done);
252 : : }
253 : :
254 : : /*
255 : : * The former STARTING/DYING states, ran with IRQs disabled and must not fail.
256 : : */
257 : : static bool cpuhp_is_atomic_state(enum cpuhp_state state)
258 : : {
259 : 3 : return CPUHP_AP_IDLE_DEAD <= state && state < CPUHP_AP_ONLINE;
260 : : }
261 : :
262 : : /* Serializes the updates to cpu_online_mask, cpu_present_mask */
263 : : static DEFINE_MUTEX(cpu_add_remove_lock);
264 : : bool cpuhp_tasks_frozen;
265 : : EXPORT_SYMBOL_GPL(cpuhp_tasks_frozen);
266 : :
267 : : /*
268 : : * The following two APIs (cpu_maps_update_begin/done) must be used when
269 : : * attempting to serialize the updates to cpu_online_mask & cpu_present_mask.
270 : : */
271 : 0 : void cpu_maps_update_begin(void)
272 : : {
273 : 3 : mutex_lock(&cpu_add_remove_lock);
274 : 0 : }
275 : :
276 : 0 : void cpu_maps_update_done(void)
277 : : {
278 : 3 : mutex_unlock(&cpu_add_remove_lock);
279 : 0 : }
280 : :
281 : : /*
282 : : * If set, cpu_up and cpu_down will return -EBUSY and do nothing.
283 : : * Should always be manipulated under cpu_add_remove_lock
284 : : */
285 : : static int cpu_hotplug_disabled;
286 : :
287 : : #ifdef CONFIG_HOTPLUG_CPU
288 : :
289 : : DEFINE_STATIC_PERCPU_RWSEM(cpu_hotplug_lock);
290 : :
291 : : void cpus_read_lock(void)
292 : : {
293 : : percpu_down_read(&cpu_hotplug_lock);
294 : : }
295 : : EXPORT_SYMBOL_GPL(cpus_read_lock);
296 : :
297 : : int cpus_read_trylock(void)
298 : : {
299 : : return percpu_down_read_trylock(&cpu_hotplug_lock);
300 : : }
301 : : EXPORT_SYMBOL_GPL(cpus_read_trylock);
302 : :
303 : : void cpus_read_unlock(void)
304 : : {
305 : : percpu_up_read(&cpu_hotplug_lock);
306 : : }
307 : : EXPORT_SYMBOL_GPL(cpus_read_unlock);
308 : :
309 : : void cpus_write_lock(void)
310 : : {
311 : : percpu_down_write(&cpu_hotplug_lock);
312 : : }
313 : :
314 : : void cpus_write_unlock(void)
315 : : {
316 : : percpu_up_write(&cpu_hotplug_lock);
317 : : }
318 : :
319 : : void lockdep_assert_cpus_held(void)
320 : : {
321 : : /*
322 : : * We can't have hotplug operations before userspace starts running,
323 : : * and some init codepaths will knowingly not take the hotplug lock.
324 : : * This is all valid, so mute lockdep until it makes sense to report
325 : : * unheld locks.
326 : : */
327 : : if (system_state < SYSTEM_RUNNING)
328 : : return;
329 : :
330 : : percpu_rwsem_assert_held(&cpu_hotplug_lock);
331 : : }
332 : :
333 : : static void lockdep_acquire_cpus_lock(void)
334 : : {
335 : : rwsem_acquire(&cpu_hotplug_lock.rw_sem.dep_map, 0, 0, _THIS_IP_);
336 : : }
337 : :
338 : : static void lockdep_release_cpus_lock(void)
339 : : {
340 : : rwsem_release(&cpu_hotplug_lock.rw_sem.dep_map, 1, _THIS_IP_);
341 : : }
342 : :
343 : : /*
344 : : * Wait for currently running CPU hotplug operations to complete (if any) and
345 : : * disable future CPU hotplug (from sysfs). The 'cpu_add_remove_lock' protects
346 : : * the 'cpu_hotplug_disabled' flag. The same lock is also acquired by the
347 : : * hotplug path before performing hotplug operations. So acquiring that lock
348 : : * guarantees mutual exclusion from any currently running hotplug operations.
349 : : */
350 : : void cpu_hotplug_disable(void)
351 : : {
352 : : cpu_maps_update_begin();
353 : : cpu_hotplug_disabled++;
354 : : cpu_maps_update_done();
355 : : }
356 : : EXPORT_SYMBOL_GPL(cpu_hotplug_disable);
357 : :
358 : : static void __cpu_hotplug_enable(void)
359 : : {
360 : : if (WARN_ONCE(!cpu_hotplug_disabled, "Unbalanced cpu hotplug enable\n"))
361 : : return;
362 : : cpu_hotplug_disabled--;
363 : : }
364 : :
365 : : void cpu_hotplug_enable(void)
366 : : {
367 : : cpu_maps_update_begin();
368 : : __cpu_hotplug_enable();
369 : : cpu_maps_update_done();
370 : : }
371 : : EXPORT_SYMBOL_GPL(cpu_hotplug_enable);
372 : :
373 : : #else
374 : :
375 : : static void lockdep_acquire_cpus_lock(void)
376 : : {
377 : : }
378 : :
379 : : static void lockdep_release_cpus_lock(void)
380 : : {
381 : : }
382 : :
383 : : #endif /* CONFIG_HOTPLUG_CPU */
384 : :
385 : : /*
386 : : * Architectures that need SMT-specific errata handling during SMT hotplug
387 : : * should override this.
388 : : */
389 : 3 : void __weak arch_smt_update(void) { }
390 : :
391 : : #ifdef CONFIG_HOTPLUG_SMT
392 : : enum cpuhp_smt_control cpu_smt_control __read_mostly = CPU_SMT_ENABLED;
393 : :
394 : : void __init cpu_smt_disable(bool force)
395 : : {
396 : : if (!cpu_smt_possible())
397 : : return;
398 : :
399 : : if (force) {
400 : : pr_info("SMT: Force disabled\n");
401 : : cpu_smt_control = CPU_SMT_FORCE_DISABLED;
402 : : } else {
403 : : pr_info("SMT: disabled\n");
404 : : cpu_smt_control = CPU_SMT_DISABLED;
405 : : }
406 : : }
407 : :
408 : : /*
409 : : * The decision whether SMT is supported can only be done after the full
410 : : * CPU identification. Called from architecture code.
411 : : */
412 : : void __init cpu_smt_check_topology(void)
413 : : {
414 : : if (!topology_smt_supported())
415 : : cpu_smt_control = CPU_SMT_NOT_SUPPORTED;
416 : : }
417 : :
418 : : static int __init smt_cmdline_disable(char *str)
419 : : {
420 : : cpu_smt_disable(str && !strcmp(str, "force"));
421 : : return 0;
422 : : }
423 : : early_param("nosmt", smt_cmdline_disable);
424 : :
425 : : static inline bool cpu_smt_allowed(unsigned int cpu)
426 : : {
427 : : if (cpu_smt_control == CPU_SMT_ENABLED)
428 : : return true;
429 : :
430 : : if (topology_is_primary_thread(cpu))
431 : : return true;
432 : :
433 : : /*
434 : : * On x86 it's required to boot all logical CPUs at least once so
435 : : * that the init code can get a chance to set CR4.MCE on each
436 : : * CPU. Otherwise, a broadacasted MCE observing CR4.MCE=0b on any
437 : : * core will shutdown the machine.
438 : : */
439 : : return !cpumask_test_cpu(cpu, &cpus_booted_once_mask);
440 : : }
441 : :
442 : : /* Returns true if SMT is not supported of forcefully (irreversibly) disabled */
443 : : bool cpu_smt_possible(void)
444 : : {
445 : : return cpu_smt_control != CPU_SMT_FORCE_DISABLED &&
446 : : cpu_smt_control != CPU_SMT_NOT_SUPPORTED;
447 : : }
448 : : EXPORT_SYMBOL_GPL(cpu_smt_possible);
449 : : #else
450 : : static inline bool cpu_smt_allowed(unsigned int cpu) { return true; }
451 : : #endif
452 : :
453 : : static inline enum cpuhp_state
454 : : cpuhp_set_state(struct cpuhp_cpu_state *st, enum cpuhp_state target)
455 : : {
456 : 3 : enum cpuhp_state prev_state = st->state;
457 : :
458 : 3 : st->rollback = false;
459 : 3 : st->last = NULL;
460 : :
461 : 3 : st->target = target;
462 : 3 : st->single = false;
463 : 3 : st->bringup = st->state < target;
464 : :
465 : : return prev_state;
466 : : }
467 : :
468 : : static inline void
469 : : cpuhp_reset_state(struct cpuhp_cpu_state *st, enum cpuhp_state prev_state)
470 : : {
471 : 0 : st->rollback = true;
472 : :
473 : : /*
474 : : * If we have st->last we need to undo partial multi_instance of this
475 : : * state first. Otherwise start undo at the previous state.
476 : : */
477 : 0 : if (!st->last) {
478 : 0 : if (st->bringup)
479 : 0 : st->state--;
480 : : else
481 : 0 : st->state++;
482 : : }
483 : :
484 : 0 : st->target = prev_state;
485 : 0 : st->bringup = !st->bringup;
486 : : }
487 : :
488 : : /* Regular hotplug invocation of the AP hotplug thread */
489 : 3 : static void __cpuhp_kick_ap(struct cpuhp_cpu_state *st)
490 : : {
491 : 3 : if (!st->single && st->state == st->target)
492 : 3 : return;
493 : :
494 : 3 : st->result = 0;
495 : : /*
496 : : * Make sure the above stores are visible before should_run becomes
497 : : * true. Paired with the mb() above in cpuhp_thread_fun()
498 : : */
499 : 3 : smp_mb();
500 : 3 : st->should_run = true;
501 : 3 : wake_up_process(st->thread);
502 : 3 : wait_for_ap_thread(st, st->bringup);
503 : : }
504 : :
505 : 3 : static int cpuhp_kick_ap(struct cpuhp_cpu_state *st, enum cpuhp_state target)
506 : : {
507 : : enum cpuhp_state prev_state;
508 : : int ret;
509 : :
510 : : prev_state = cpuhp_set_state(st, target);
511 : 3 : __cpuhp_kick_ap(st);
512 : 3 : if ((ret = st->result)) {
513 : : cpuhp_reset_state(st, prev_state);
514 : 0 : __cpuhp_kick_ap(st);
515 : : }
516 : :
517 : 3 : return ret;
518 : : }
519 : :
520 : 3 : static int bringup_wait_for_ap(unsigned int cpu)
521 : : {
522 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
523 : :
524 : : /* Wait for the CPU to reach CPUHP_AP_ONLINE_IDLE */
525 : : wait_for_ap_thread(st, true);
526 : 3 : if (WARN_ON_ONCE((!cpu_online(cpu))))
527 : : return -ECANCELED;
528 : :
529 : : /* Unpark the hotplug thread of the target cpu */
530 : 3 : kthread_unpark(st->thread);
531 : :
532 : : /*
533 : : * SMT soft disabling on X86 requires to bring the CPU out of the
534 : : * BIOS 'wait for SIPI' state in order to set the CR4.MCE bit. The
535 : : * CPU marked itself as booted_once in notify_cpu_starting() so the
536 : : * cpu_smt_allowed() check will now return false if this is not the
537 : : * primary sibling.
538 : : */
539 : : if (!cpu_smt_allowed(cpu))
540 : : return -ECANCELED;
541 : :
542 : 3 : if (st->target <= CPUHP_AP_ONLINE_IDLE)
543 : : return 0;
544 : :
545 : 3 : return cpuhp_kick_ap(st, st->target);
546 : : }
547 : :
548 : 3 : static int bringup_cpu(unsigned int cpu)
549 : : {
550 : 3 : struct task_struct *idle = idle_thread_get(cpu);
551 : : int ret;
552 : :
553 : : /*
554 : : * Some architectures have to walk the irq descriptors to
555 : : * setup the vector space for the cpu which comes online.
556 : : * Prevent irq alloc/free across the bringup.
557 : : */
558 : 3 : irq_lock_sparse();
559 : :
560 : : /* Arch-specific enabling code. */
561 : 3 : ret = __cpu_up(cpu, idle);
562 : 3 : irq_unlock_sparse();
563 : 3 : if (ret)
564 : : return ret;
565 : 3 : return bringup_wait_for_ap(cpu);
566 : : }
567 : :
568 : 0 : static int finish_cpu(unsigned int cpu)
569 : : {
570 : 0 : struct task_struct *idle = idle_thread_get(cpu);
571 : 0 : struct mm_struct *mm = idle->active_mm;
572 : :
573 : : /*
574 : : * idle_task_exit() will have switched to &init_mm, now
575 : : * clean up any remaining active_mm state.
576 : : */
577 : 0 : if (mm != &init_mm)
578 : 0 : idle->active_mm = &init_mm;
579 : 0 : mmdrop(mm);
580 : 0 : return 0;
581 : : }
582 : :
583 : : /*
584 : : * Hotplug state machine related functions
585 : : */
586 : :
587 : 0 : static void undo_cpu_up(unsigned int cpu, struct cpuhp_cpu_state *st)
588 : : {
589 : 0 : for (st->state--; st->state > st->target; st->state--)
590 : 0 : cpuhp_invoke_callback(cpu, st->state, false, NULL, NULL);
591 : 0 : }
592 : :
593 : : static inline bool can_rollback_cpu(struct cpuhp_cpu_state *st)
594 : : {
595 : : if (IS_ENABLED(CONFIG_HOTPLUG_CPU))
596 : : return true;
597 : : /*
598 : : * When CPU hotplug is disabled, then taking the CPU down is not
599 : : * possible because takedown_cpu() and the architecture and
600 : : * subsystem specific mechanisms are not available. So the CPU
601 : : * which would be completely unplugged again needs to stay around
602 : : * in the current state.
603 : : */
604 : 0 : return st->state <= CPUHP_BRINGUP_CPU;
605 : : }
606 : :
607 : 3 : static int cpuhp_up_callbacks(unsigned int cpu, struct cpuhp_cpu_state *st,
608 : : enum cpuhp_state target)
609 : : {
610 : 3 : enum cpuhp_state prev_state = st->state;
611 : : int ret = 0;
612 : :
613 : 3 : while (st->state < target) {
614 : 3 : st->state++;
615 : 3 : ret = cpuhp_invoke_callback(cpu, st->state, true, NULL, NULL);
616 : 3 : if (ret) {
617 : 0 : if (can_rollback_cpu(st)) {
618 : 0 : st->target = prev_state;
619 : 0 : undo_cpu_up(cpu, st);
620 : : }
621 : : break;
622 : : }
623 : : }
624 : 3 : return ret;
625 : : }
626 : :
627 : : /*
628 : : * The cpu hotplug threads manage the bringup and teardown of the cpus
629 : : */
630 : 3 : static void cpuhp_create(unsigned int cpu)
631 : : {
632 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
633 : :
634 : : init_completion(&st->done_up);
635 : : init_completion(&st->done_down);
636 : 3 : }
637 : :
638 : 3 : static int cpuhp_should_run(unsigned int cpu)
639 : : {
640 : 3 : struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
641 : :
642 : 3 : return st->should_run;
643 : : }
644 : :
645 : : /*
646 : : * Execute teardown/startup callbacks on the plugged cpu. Also used to invoke
647 : : * callbacks when a state gets [un]installed at runtime.
648 : : *
649 : : * Each invocation of this function by the smpboot thread does a single AP
650 : : * state callback.
651 : : *
652 : : * It has 3 modes of operation:
653 : : * - single: runs st->cb_state
654 : : * - up: runs ++st->state, while st->state < st->target
655 : : * - down: runs st->state--, while st->state > st->target
656 : : *
657 : : * When complete or on error, should_run is cleared and the completion is fired.
658 : : */
659 : 3 : static void cpuhp_thread_fun(unsigned int cpu)
660 : : {
661 : 3 : struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
662 : 3 : bool bringup = st->bringup;
663 : : enum cpuhp_state state;
664 : :
665 : 3 : if (WARN_ON_ONCE(!st->should_run))
666 : 3 : return;
667 : :
668 : : /*
669 : : * ACQUIRE for the cpuhp_should_run() load of ->should_run. Ensures
670 : : * that if we see ->should_run we also see the rest of the state.
671 : : */
672 : 3 : smp_mb();
673 : :
674 : : /*
675 : : * The BP holds the hotplug lock, but we're now running on the AP,
676 : : * ensure that anybody asserting the lock is held, will actually find
677 : : * it so.
678 : : */
679 : : lockdep_acquire_cpus_lock();
680 : : cpuhp_lock_acquire(bringup);
681 : :
682 : 3 : if (st->single) {
683 : 3 : state = st->cb_state;
684 : 3 : st->should_run = false;
685 : : } else {
686 : 3 : if (bringup) {
687 : 3 : st->state++;
688 : : state = st->state;
689 : 3 : st->should_run = (st->state < st->target);
690 : 3 : WARN_ON_ONCE(st->state > st->target);
691 : : } else {
692 : 0 : state = st->state;
693 : 0 : st->state--;
694 : 0 : st->should_run = (st->state > st->target);
695 : 0 : WARN_ON_ONCE(st->state < st->target);
696 : : }
697 : : }
698 : :
699 : 3 : WARN_ON_ONCE(!cpuhp_is_ap_state(state));
700 : :
701 : 3 : if (cpuhp_is_atomic_state(state)) {
702 : 3 : local_irq_disable();
703 : 3 : st->result = cpuhp_invoke_callback(cpu, state, bringup, st->node, &st->last);
704 : 3 : local_irq_enable();
705 : :
706 : : /*
707 : : * STARTING/DYING must not fail!
708 : : */
709 : 3 : WARN_ON_ONCE(st->result);
710 : : } else {
711 : 3 : st->result = cpuhp_invoke_callback(cpu, state, bringup, st->node, &st->last);
712 : : }
713 : :
714 : 3 : if (st->result) {
715 : : /*
716 : : * If we fail on a rollback, we're up a creek without no
717 : : * paddle, no way forward, no way back. We loose, thanks for
718 : : * playing.
719 : : */
720 : 3 : WARN_ON_ONCE(st->rollback);
721 : 3 : st->should_run = false;
722 : : }
723 : :
724 : : cpuhp_lock_release(bringup);
725 : : lockdep_release_cpus_lock();
726 : :
727 : 3 : if (!st->should_run)
728 : : complete_ap_thread(st, bringup);
729 : : }
730 : :
731 : : /* Invoke a single callback on a remote cpu */
732 : : static int
733 : 3 : cpuhp_invoke_ap_callback(int cpu, enum cpuhp_state state, bool bringup,
734 : : struct hlist_node *node)
735 : : {
736 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
737 : : int ret;
738 : :
739 : 3 : if (!cpu_online(cpu))
740 : : return 0;
741 : :
742 : : cpuhp_lock_acquire(false);
743 : : cpuhp_lock_release(false);
744 : :
745 : : cpuhp_lock_acquire(true);
746 : : cpuhp_lock_release(true);
747 : :
748 : : /*
749 : : * If we are up and running, use the hotplug thread. For early calls
750 : : * we invoke the thread function directly.
751 : : */
752 : 3 : if (!st->thread)
753 : 3 : return cpuhp_invoke_callback(cpu, state, bringup, node, NULL);
754 : :
755 : 3 : st->rollback = false;
756 : 3 : st->last = NULL;
757 : :
758 : 3 : st->node = node;
759 : 3 : st->bringup = bringup;
760 : 3 : st->cb_state = state;
761 : 3 : st->single = true;
762 : :
763 : 3 : __cpuhp_kick_ap(st);
764 : :
765 : : /*
766 : : * If we failed and did a partial, do a rollback.
767 : : */
768 : 3 : if ((ret = st->result) && st->last) {
769 : 0 : st->rollback = true;
770 : 0 : st->bringup = !bringup;
771 : :
772 : 0 : __cpuhp_kick_ap(st);
773 : : }
774 : :
775 : : /*
776 : : * Clean up the leftovers so the next hotplug operation wont use stale
777 : : * data.
778 : : */
779 : 3 : st->node = st->last = NULL;
780 : 3 : return ret;
781 : : }
782 : :
783 : 0 : static int cpuhp_kick_ap_work(unsigned int cpu)
784 : : {
785 : 0 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
786 : 0 : enum cpuhp_state prev_state = st->state;
787 : : int ret;
788 : :
789 : : cpuhp_lock_acquire(false);
790 : : cpuhp_lock_release(false);
791 : :
792 : : cpuhp_lock_acquire(true);
793 : : cpuhp_lock_release(true);
794 : :
795 : 0 : trace_cpuhp_enter(cpu, st->target, prev_state, cpuhp_kick_ap_work);
796 : 0 : ret = cpuhp_kick_ap(st, st->target);
797 : 0 : trace_cpuhp_exit(cpu, st->state, prev_state, ret);
798 : :
799 : 0 : return ret;
800 : : }
801 : :
802 : : static struct smp_hotplug_thread cpuhp_threads = {
803 : : .store = &cpuhp_state.thread,
804 : : .create = &cpuhp_create,
805 : : .thread_should_run = cpuhp_should_run,
806 : : .thread_fn = cpuhp_thread_fun,
807 : : .thread_comm = "cpuhp/%u",
808 : : .selfparking = true,
809 : : };
810 : :
811 : 3 : void __init cpuhp_threads_init(void)
812 : : {
813 : 3 : BUG_ON(smpboot_register_percpu_thread(&cpuhp_threads));
814 : 3 : kthread_unpark(this_cpu_read(cpuhp_state.thread));
815 : 3 : }
816 : :
817 : : #ifdef CONFIG_HOTPLUG_CPU
818 : : /**
819 : : * clear_tasks_mm_cpumask - Safely clear tasks' mm_cpumask for a CPU
820 : : * @cpu: a CPU id
821 : : *
822 : : * This function walks all processes, finds a valid mm struct for each one and
823 : : * then clears a corresponding bit in mm's cpumask. While this all sounds
824 : : * trivial, there are various non-obvious corner cases, which this function
825 : : * tries to solve in a safe manner.
826 : : *
827 : : * Also note that the function uses a somewhat relaxed locking scheme, so it may
828 : : * be called only for an already offlined CPU.
829 : : */
830 : : void clear_tasks_mm_cpumask(int cpu)
831 : : {
832 : : struct task_struct *p;
833 : :
834 : : /*
835 : : * This function is called after the cpu is taken down and marked
836 : : * offline, so its not like new tasks will ever get this cpu set in
837 : : * their mm mask. -- Peter Zijlstra
838 : : * Thus, we may use rcu_read_lock() here, instead of grabbing
839 : : * full-fledged tasklist_lock.
840 : : */
841 : : WARN_ON(cpu_online(cpu));
842 : : rcu_read_lock();
843 : : for_each_process(p) {
844 : : struct task_struct *t;
845 : :
846 : : /*
847 : : * Main thread might exit, but other threads may still have
848 : : * a valid mm. Find one.
849 : : */
850 : : t = find_lock_task_mm(p);
851 : : if (!t)
852 : : continue;
853 : : cpumask_clear_cpu(cpu, mm_cpumask(t->mm));
854 : : task_unlock(t);
855 : : }
856 : : rcu_read_unlock();
857 : : }
858 : :
859 : : /* Take this CPU down. */
860 : : static int take_cpu_down(void *_param)
861 : : {
862 : : struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
863 : : enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE);
864 : : int err, cpu = smp_processor_id();
865 : : int ret;
866 : :
867 : : /* Ensure this CPU doesn't handle any more interrupts. */
868 : : err = __cpu_disable();
869 : : if (err < 0)
870 : : return err;
871 : :
872 : : /*
873 : : * We get here while we are in CPUHP_TEARDOWN_CPU state and we must not
874 : : * do this step again.
875 : : */
876 : : WARN_ON(st->state != CPUHP_TEARDOWN_CPU);
877 : : st->state--;
878 : : /* Invoke the former CPU_DYING callbacks */
879 : : for (; st->state > target; st->state--) {
880 : : ret = cpuhp_invoke_callback(cpu, st->state, false, NULL, NULL);
881 : : /*
882 : : * DYING must not fail!
883 : : */
884 : : WARN_ON_ONCE(ret);
885 : : }
886 : :
887 : : /* Give up timekeeping duties */
888 : : tick_handover_do_timer();
889 : : /* Remove CPU from timer broadcasting */
890 : : tick_offline_cpu(cpu);
891 : : /* Park the stopper thread */
892 : : stop_machine_park(cpu);
893 : : return 0;
894 : : }
895 : :
896 : : static int takedown_cpu(unsigned int cpu)
897 : : {
898 : : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
899 : : int err;
900 : :
901 : : /* Park the smpboot threads */
902 : : kthread_park(per_cpu_ptr(&cpuhp_state, cpu)->thread);
903 : :
904 : : /*
905 : : * Prevent irq alloc/free while the dying cpu reorganizes the
906 : : * interrupt affinities.
907 : : */
908 : : irq_lock_sparse();
909 : :
910 : : /*
911 : : * So now all preempt/rcu users must observe !cpu_active().
912 : : */
913 : : err = stop_machine_cpuslocked(take_cpu_down, NULL, cpumask_of(cpu));
914 : : if (err) {
915 : : /* CPU refused to die */
916 : : irq_unlock_sparse();
917 : : /* Unpark the hotplug thread so we can rollback there */
918 : : kthread_unpark(per_cpu_ptr(&cpuhp_state, cpu)->thread);
919 : : return err;
920 : : }
921 : : BUG_ON(cpu_online(cpu));
922 : :
923 : : /*
924 : : * The teardown callback for CPUHP_AP_SCHED_STARTING will have removed
925 : : * all runnable tasks from the CPU, there's only the idle task left now
926 : : * that the migration thread is done doing the stop_machine thing.
927 : : *
928 : : * Wait for the stop thread to go away.
929 : : */
930 : : wait_for_ap_thread(st, false);
931 : : BUG_ON(st->state != CPUHP_AP_IDLE_DEAD);
932 : :
933 : : /* Interrupts are moved away from the dying cpu, reenable alloc/free */
934 : : irq_unlock_sparse();
935 : :
936 : : hotplug_cpu__broadcast_tick_pull(cpu);
937 : : /* This actually kills the CPU. */
938 : : __cpu_die(cpu);
939 : :
940 : : tick_cleanup_dead_cpu(cpu);
941 : : rcutree_migrate_callbacks(cpu);
942 : : return 0;
943 : : }
944 : :
945 : : static void cpuhp_complete_idle_dead(void *arg)
946 : : {
947 : : struct cpuhp_cpu_state *st = arg;
948 : :
949 : : complete_ap_thread(st, false);
950 : : }
951 : :
952 : : void cpuhp_report_idle_dead(void)
953 : : {
954 : : struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
955 : :
956 : : BUG_ON(st->state != CPUHP_AP_OFFLINE);
957 : : rcu_report_dead(smp_processor_id());
958 : : st->state = CPUHP_AP_IDLE_DEAD;
959 : : /*
960 : : * We cannot call complete after rcu_report_dead() so we delegate it
961 : : * to an online cpu.
962 : : */
963 : : smp_call_function_single(cpumask_first(cpu_online_mask),
964 : : cpuhp_complete_idle_dead, st, 0);
965 : : }
966 : :
967 : : static void undo_cpu_down(unsigned int cpu, struct cpuhp_cpu_state *st)
968 : : {
969 : : for (st->state++; st->state < st->target; st->state++)
970 : : cpuhp_invoke_callback(cpu, st->state, true, NULL, NULL);
971 : : }
972 : :
973 : : static int cpuhp_down_callbacks(unsigned int cpu, struct cpuhp_cpu_state *st,
974 : : enum cpuhp_state target)
975 : : {
976 : : enum cpuhp_state prev_state = st->state;
977 : : int ret = 0;
978 : :
979 : : for (; st->state > target; st->state--) {
980 : : ret = cpuhp_invoke_callback(cpu, st->state, false, NULL, NULL);
981 : : if (ret) {
982 : : st->target = prev_state;
983 : : if (st->state < prev_state)
984 : : undo_cpu_down(cpu, st);
985 : : break;
986 : : }
987 : : }
988 : : return ret;
989 : : }
990 : :
991 : : /* Requires cpu_add_remove_lock to be held */
992 : : static int __ref _cpu_down(unsigned int cpu, int tasks_frozen,
993 : : enum cpuhp_state target)
994 : : {
995 : : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
996 : : int prev_state, ret = 0;
997 : :
998 : : if (num_online_cpus() == 1)
999 : : return -EBUSY;
1000 : :
1001 : : if (!cpu_present(cpu))
1002 : : return -EINVAL;
1003 : :
1004 : : cpus_write_lock();
1005 : :
1006 : : cpuhp_tasks_frozen = tasks_frozen;
1007 : :
1008 : : prev_state = cpuhp_set_state(st, target);
1009 : : /*
1010 : : * If the current CPU state is in the range of the AP hotplug thread,
1011 : : * then we need to kick the thread.
1012 : : */
1013 : : if (st->state > CPUHP_TEARDOWN_CPU) {
1014 : : st->target = max((int)target, CPUHP_TEARDOWN_CPU);
1015 : : ret = cpuhp_kick_ap_work(cpu);
1016 : : /*
1017 : : * The AP side has done the error rollback already. Just
1018 : : * return the error code..
1019 : : */
1020 : : if (ret)
1021 : : goto out;
1022 : :
1023 : : /*
1024 : : * We might have stopped still in the range of the AP hotplug
1025 : : * thread. Nothing to do anymore.
1026 : : */
1027 : : if (st->state > CPUHP_TEARDOWN_CPU)
1028 : : goto out;
1029 : :
1030 : : st->target = target;
1031 : : }
1032 : : /*
1033 : : * The AP brought itself down to CPUHP_TEARDOWN_CPU. So we need
1034 : : * to do the further cleanups.
1035 : : */
1036 : : ret = cpuhp_down_callbacks(cpu, st, target);
1037 : : if (ret && st->state == CPUHP_TEARDOWN_CPU && st->state < prev_state) {
1038 : : cpuhp_reset_state(st, prev_state);
1039 : : __cpuhp_kick_ap(st);
1040 : : }
1041 : :
1042 : : out:
1043 : : cpus_write_unlock();
1044 : : /*
1045 : : * Do post unplug cleanup. This is still protected against
1046 : : * concurrent CPU hotplug via cpu_add_remove_lock.
1047 : : */
1048 : : lockup_detector_cleanup();
1049 : : arch_smt_update();
1050 : : return ret;
1051 : : }
1052 : :
1053 : : static int cpu_down_maps_locked(unsigned int cpu, enum cpuhp_state target)
1054 : : {
1055 : : if (cpu_hotplug_disabled)
1056 : : return -EBUSY;
1057 : : return _cpu_down(cpu, 0, target);
1058 : : }
1059 : :
1060 : : static int do_cpu_down(unsigned int cpu, enum cpuhp_state target)
1061 : : {
1062 : : int err;
1063 : :
1064 : : cpu_maps_update_begin();
1065 : : err = cpu_down_maps_locked(cpu, target);
1066 : : cpu_maps_update_done();
1067 : : return err;
1068 : : }
1069 : :
1070 : : int cpu_down(unsigned int cpu)
1071 : : {
1072 : : return do_cpu_down(cpu, CPUHP_OFFLINE);
1073 : : }
1074 : : EXPORT_SYMBOL(cpu_down);
1075 : :
1076 : : #else
1077 : : #define takedown_cpu NULL
1078 : : #endif /*CONFIG_HOTPLUG_CPU*/
1079 : :
1080 : : /**
1081 : : * notify_cpu_starting(cpu) - Invoke the callbacks on the starting CPU
1082 : : * @cpu: cpu that just started
1083 : : *
1084 : : * It must be called by the arch code on the new cpu, before the new cpu
1085 : : * enables interrupts and before the "boot" cpu returns from __cpu_up().
1086 : : */
1087 : 3 : void notify_cpu_starting(unsigned int cpu)
1088 : : {
1089 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1090 : 3 : enum cpuhp_state target = min((int)st->target, CPUHP_AP_ONLINE);
1091 : : int ret;
1092 : :
1093 : 3 : rcu_cpu_starting(cpu); /* Enables RCU usage on this CPU. */
1094 : : cpumask_set_cpu(cpu, &cpus_booted_once_mask);
1095 : 3 : while (st->state < target) {
1096 : 3 : st->state++;
1097 : 3 : ret = cpuhp_invoke_callback(cpu, st->state, true, NULL, NULL);
1098 : : /*
1099 : : * STARTING must not fail!
1100 : : */
1101 : 3 : WARN_ON_ONCE(ret);
1102 : : }
1103 : 3 : }
1104 : :
1105 : : /*
1106 : : * Called from the idle task. Wake up the controlling task which brings the
1107 : : * hotplug thread of the upcoming CPU up and then delegates the rest of the
1108 : : * online bringup to the hotplug thread.
1109 : : */
1110 : 3 : void cpuhp_online_idle(enum cpuhp_state state)
1111 : : {
1112 : 3 : struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
1113 : :
1114 : : /* Happens for the boot cpu */
1115 : 3 : if (state != CPUHP_AP_ONLINE_IDLE)
1116 : 3 : return;
1117 : :
1118 : : /*
1119 : : * Unpart the stopper thread before we start the idle loop (and start
1120 : : * scheduling); this ensures the stopper task is always available.
1121 : : */
1122 : 3 : stop_machine_unpark(smp_processor_id());
1123 : :
1124 : 3 : st->state = CPUHP_AP_ONLINE_IDLE;
1125 : : complete_ap_thread(st, true);
1126 : : }
1127 : :
1128 : : /* Requires cpu_add_remove_lock to be held */
1129 : 3 : static int _cpu_up(unsigned int cpu, int tasks_frozen, enum cpuhp_state target)
1130 : : {
1131 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1132 : : struct task_struct *idle;
1133 : : int ret = 0;
1134 : :
1135 : : cpus_write_lock();
1136 : :
1137 : 3 : if (!cpu_present(cpu)) {
1138 : : ret = -EINVAL;
1139 : : goto out;
1140 : : }
1141 : :
1142 : : /*
1143 : : * The caller of do_cpu_up might have raced with another
1144 : : * caller. Ignore it for now.
1145 : : */
1146 : 3 : if (st->state >= target)
1147 : : goto out;
1148 : :
1149 : 3 : if (st->state == CPUHP_OFFLINE) {
1150 : : /* Let it fail before we try to bring the cpu up */
1151 : 3 : idle = idle_thread_get(cpu);
1152 : 3 : if (IS_ERR(idle)) {
1153 : : ret = PTR_ERR(idle);
1154 : 0 : goto out;
1155 : : }
1156 : : }
1157 : :
1158 : 3 : cpuhp_tasks_frozen = tasks_frozen;
1159 : :
1160 : : cpuhp_set_state(st, target);
1161 : : /*
1162 : : * If the current CPU state is in the range of the AP hotplug thread,
1163 : : * then we need to kick the thread once more.
1164 : : */
1165 : 3 : if (st->state > CPUHP_BRINGUP_CPU) {
1166 : 0 : ret = cpuhp_kick_ap_work(cpu);
1167 : : /*
1168 : : * The AP side has done the error rollback already. Just
1169 : : * return the error code..
1170 : : */
1171 : 0 : if (ret)
1172 : : goto out;
1173 : : }
1174 : :
1175 : : /*
1176 : : * Try to reach the target state. We max out on the BP at
1177 : : * CPUHP_BRINGUP_CPU. After that the AP hotplug thread is
1178 : : * responsible for bringing it up to the target state.
1179 : : */
1180 : 3 : target = min((int)target, CPUHP_BRINGUP_CPU);
1181 : 3 : ret = cpuhp_up_callbacks(cpu, st, target);
1182 : : out:
1183 : : cpus_write_unlock();
1184 : 3 : arch_smt_update();
1185 : 3 : return ret;
1186 : : }
1187 : :
1188 : 3 : static int do_cpu_up(unsigned int cpu, enum cpuhp_state target)
1189 : : {
1190 : : int err = 0;
1191 : :
1192 : 3 : if (!cpu_possible(cpu)) {
1193 : 0 : pr_err("can't online cpu %d because it is not configured as may-hotadd at boot time\n",
1194 : : cpu);
1195 : : #if defined(CONFIG_IA64)
1196 : : pr_err("please check additional_cpus= boot parameter\n");
1197 : : #endif
1198 : 0 : return -EINVAL;
1199 : : }
1200 : :
1201 : : err = try_online_node(cpu_to_node(cpu));
1202 : : if (err)
1203 : : return err;
1204 : :
1205 : : cpu_maps_update_begin();
1206 : :
1207 : 3 : if (cpu_hotplug_disabled) {
1208 : : err = -EBUSY;
1209 : : goto out;
1210 : : }
1211 : : if (!cpu_smt_allowed(cpu)) {
1212 : : err = -EPERM;
1213 : : goto out;
1214 : : }
1215 : :
1216 : 3 : err = _cpu_up(cpu, 0, target);
1217 : : out:
1218 : : cpu_maps_update_done();
1219 : 3 : return err;
1220 : : }
1221 : :
1222 : 3 : int cpu_up(unsigned int cpu)
1223 : : {
1224 : 3 : return do_cpu_up(cpu, CPUHP_ONLINE);
1225 : : }
1226 : : EXPORT_SYMBOL_GPL(cpu_up);
1227 : :
1228 : : #ifdef CONFIG_PM_SLEEP_SMP
1229 : : static cpumask_var_t frozen_cpus;
1230 : :
1231 : : int __freeze_secondary_cpus(int primary, bool suspend)
1232 : : {
1233 : : int cpu, error = 0;
1234 : :
1235 : : cpu_maps_update_begin();
1236 : : if (primary == -1) {
1237 : : primary = cpumask_first(cpu_online_mask);
1238 : : if (!housekeeping_cpu(primary, HK_FLAG_TIMER))
1239 : : primary = housekeeping_any_cpu(HK_FLAG_TIMER);
1240 : : } else {
1241 : : if (!cpu_online(primary))
1242 : : primary = cpumask_first(cpu_online_mask);
1243 : : }
1244 : :
1245 : : /*
1246 : : * We take down all of the non-boot CPUs in one shot to avoid races
1247 : : * with the userspace trying to use the CPU hotplug at the same time
1248 : : */
1249 : : cpumask_clear(frozen_cpus);
1250 : :
1251 : : pr_info("Disabling non-boot CPUs ...\n");
1252 : : for_each_online_cpu(cpu) {
1253 : : if (cpu == primary)
1254 : : continue;
1255 : :
1256 : : if (suspend && pm_wakeup_pending()) {
1257 : : pr_info("Wakeup pending. Abort CPU freeze\n");
1258 : : error = -EBUSY;
1259 : : break;
1260 : : }
1261 : :
1262 : : trace_suspend_resume(TPS("CPU_OFF"), cpu, true);
1263 : : error = _cpu_down(cpu, 1, CPUHP_OFFLINE);
1264 : : trace_suspend_resume(TPS("CPU_OFF"), cpu, false);
1265 : : if (!error)
1266 : : cpumask_set_cpu(cpu, frozen_cpus);
1267 : : else {
1268 : : pr_err("Error taking CPU%d down: %d\n", cpu, error);
1269 : : break;
1270 : : }
1271 : : }
1272 : :
1273 : : if (!error)
1274 : : BUG_ON(num_online_cpus() > 1);
1275 : : else
1276 : : pr_err("Non-boot CPUs are not disabled\n");
1277 : :
1278 : : /*
1279 : : * Make sure the CPUs won't be enabled by someone else. We need to do
1280 : : * this even in case of failure as all disable_nonboot_cpus() users are
1281 : : * supposed to do enable_nonboot_cpus() on the failure path.
1282 : : */
1283 : : cpu_hotplug_disabled++;
1284 : :
1285 : : cpu_maps_update_done();
1286 : : return error;
1287 : : }
1288 : :
1289 : : void __weak arch_enable_nonboot_cpus_begin(void)
1290 : : {
1291 : : }
1292 : :
1293 : : void __weak arch_enable_nonboot_cpus_end(void)
1294 : : {
1295 : : }
1296 : :
1297 : : void enable_nonboot_cpus(void)
1298 : : {
1299 : : int cpu, error;
1300 : :
1301 : : /* Allow everyone to use the CPU hotplug again */
1302 : : cpu_maps_update_begin();
1303 : : __cpu_hotplug_enable();
1304 : : if (cpumask_empty(frozen_cpus))
1305 : : goto out;
1306 : :
1307 : : pr_info("Enabling non-boot CPUs ...\n");
1308 : :
1309 : : arch_enable_nonboot_cpus_begin();
1310 : :
1311 : : for_each_cpu(cpu, frozen_cpus) {
1312 : : trace_suspend_resume(TPS("CPU_ON"), cpu, true);
1313 : : error = _cpu_up(cpu, 1, CPUHP_ONLINE);
1314 : : trace_suspend_resume(TPS("CPU_ON"), cpu, false);
1315 : : if (!error) {
1316 : : pr_info("CPU%d is up\n", cpu);
1317 : : continue;
1318 : : }
1319 : : pr_warn("Error taking CPU%d up: %d\n", cpu, error);
1320 : : }
1321 : :
1322 : : arch_enable_nonboot_cpus_end();
1323 : :
1324 : : cpumask_clear(frozen_cpus);
1325 : : out:
1326 : : cpu_maps_update_done();
1327 : : }
1328 : :
1329 : : static int __init alloc_frozen_cpus(void)
1330 : : {
1331 : : if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
1332 : : return -ENOMEM;
1333 : : return 0;
1334 : : }
1335 : : core_initcall(alloc_frozen_cpus);
1336 : :
1337 : : /*
1338 : : * When callbacks for CPU hotplug notifications are being executed, we must
1339 : : * ensure that the state of the system with respect to the tasks being frozen
1340 : : * or not, as reported by the notification, remains unchanged *throughout the
1341 : : * duration* of the execution of the callbacks.
1342 : : * Hence we need to prevent the freezer from racing with regular CPU hotplug.
1343 : : *
1344 : : * This synchronization is implemented by mutually excluding regular CPU
1345 : : * hotplug and Suspend/Hibernate call paths by hooking onto the Suspend/
1346 : : * Hibernate notifications.
1347 : : */
1348 : : static int
1349 : : cpu_hotplug_pm_callback(struct notifier_block *nb,
1350 : : unsigned long action, void *ptr)
1351 : : {
1352 : : switch (action) {
1353 : :
1354 : : case PM_SUSPEND_PREPARE:
1355 : : case PM_HIBERNATION_PREPARE:
1356 : : cpu_hotplug_disable();
1357 : : break;
1358 : :
1359 : : case PM_POST_SUSPEND:
1360 : : case PM_POST_HIBERNATION:
1361 : : cpu_hotplug_enable();
1362 : : break;
1363 : :
1364 : : default:
1365 : : return NOTIFY_DONE;
1366 : : }
1367 : :
1368 : : return NOTIFY_OK;
1369 : : }
1370 : :
1371 : :
1372 : : static int __init cpu_hotplug_pm_sync_init(void)
1373 : : {
1374 : : /*
1375 : : * cpu_hotplug_pm_callback has higher priority than x86
1376 : : * bsp_pm_callback which depends on cpu_hotplug_pm_callback
1377 : : * to disable cpu hotplug to avoid cpu hotplug race.
1378 : : */
1379 : : pm_notifier(cpu_hotplug_pm_callback, 0);
1380 : : return 0;
1381 : : }
1382 : : core_initcall(cpu_hotplug_pm_sync_init);
1383 : :
1384 : : #endif /* CONFIG_PM_SLEEP_SMP */
1385 : :
1386 : : int __boot_cpu_id;
1387 : :
1388 : : #endif /* CONFIG_SMP */
1389 : :
1390 : : /* Boot processor state steps */
1391 : : static struct cpuhp_step cpuhp_hp_states[] = {
1392 : : [CPUHP_OFFLINE] = {
1393 : : .name = "offline",
1394 : : .startup.single = NULL,
1395 : : .teardown.single = NULL,
1396 : : },
1397 : : #ifdef CONFIG_SMP
1398 : : [CPUHP_CREATE_THREADS]= {
1399 : : .name = "threads:prepare",
1400 : : .startup.single = smpboot_create_threads,
1401 : : .teardown.single = NULL,
1402 : : .cant_stop = true,
1403 : : },
1404 : : [CPUHP_PERF_PREPARE] = {
1405 : : .name = "perf:prepare",
1406 : : .startup.single = perf_event_init_cpu,
1407 : : .teardown.single = perf_event_exit_cpu,
1408 : : },
1409 : : [CPUHP_WORKQUEUE_PREP] = {
1410 : : .name = "workqueue:prepare",
1411 : : .startup.single = workqueue_prepare_cpu,
1412 : : .teardown.single = NULL,
1413 : : },
1414 : : [CPUHP_HRTIMERS_PREPARE] = {
1415 : : .name = "hrtimers:prepare",
1416 : : .startup.single = hrtimers_prepare_cpu,
1417 : : .teardown.single = hrtimers_dead_cpu,
1418 : : },
1419 : : [CPUHP_SMPCFD_PREPARE] = {
1420 : : .name = "smpcfd:prepare",
1421 : : .startup.single = smpcfd_prepare_cpu,
1422 : : .teardown.single = smpcfd_dead_cpu,
1423 : : },
1424 : : [CPUHP_RELAY_PREPARE] = {
1425 : : .name = "relay:prepare",
1426 : : .startup.single = relay_prepare_cpu,
1427 : : .teardown.single = NULL,
1428 : : },
1429 : : [CPUHP_SLAB_PREPARE] = {
1430 : : .name = "slab:prepare",
1431 : : .startup.single = slab_prepare_cpu,
1432 : : .teardown.single = slab_dead_cpu,
1433 : : },
1434 : : [CPUHP_RCUTREE_PREP] = {
1435 : : .name = "RCU/tree:prepare",
1436 : : .startup.single = rcutree_prepare_cpu,
1437 : : .teardown.single = rcutree_dead_cpu,
1438 : : },
1439 : : /*
1440 : : * On the tear-down path, timers_dead_cpu() must be invoked
1441 : : * before blk_mq_queue_reinit_notify() from notify_dead(),
1442 : : * otherwise a RCU stall occurs.
1443 : : */
1444 : : [CPUHP_TIMERS_PREPARE] = {
1445 : : .name = "timers:prepare",
1446 : : .startup.single = timers_prepare_cpu,
1447 : : .teardown.single = timers_dead_cpu,
1448 : : },
1449 : : /* Kicks the plugged cpu into life */
1450 : : [CPUHP_BRINGUP_CPU] = {
1451 : : .name = "cpu:bringup",
1452 : : .startup.single = bringup_cpu,
1453 : : .teardown.single = finish_cpu,
1454 : : .cant_stop = true,
1455 : : },
1456 : : /* Final state before CPU kills itself */
1457 : : [CPUHP_AP_IDLE_DEAD] = {
1458 : : .name = "idle:dead",
1459 : : },
1460 : : /*
1461 : : * Last state before CPU enters the idle loop to die. Transient state
1462 : : * for synchronization.
1463 : : */
1464 : : [CPUHP_AP_OFFLINE] = {
1465 : : .name = "ap:offline",
1466 : : .cant_stop = true,
1467 : : },
1468 : : /* First state is scheduler control. Interrupts are disabled */
1469 : : [CPUHP_AP_SCHED_STARTING] = {
1470 : : .name = "sched:starting",
1471 : : .startup.single = sched_cpu_starting,
1472 : : .teardown.single = sched_cpu_dying,
1473 : : },
1474 : : [CPUHP_AP_RCUTREE_DYING] = {
1475 : : .name = "RCU/tree:dying",
1476 : : .startup.single = NULL,
1477 : : .teardown.single = rcutree_dying_cpu,
1478 : : },
1479 : : [CPUHP_AP_SMPCFD_DYING] = {
1480 : : .name = "smpcfd:dying",
1481 : : .startup.single = NULL,
1482 : : .teardown.single = smpcfd_dying_cpu,
1483 : : },
1484 : : /* Entry state on starting. Interrupts enabled from here on. Transient
1485 : : * state for synchronsization */
1486 : : [CPUHP_AP_ONLINE] = {
1487 : : .name = "ap:online",
1488 : : },
1489 : : /*
1490 : : * Handled on controll processor until the plugged processor manages
1491 : : * this itself.
1492 : : */
1493 : : [CPUHP_TEARDOWN_CPU] = {
1494 : : .name = "cpu:teardown",
1495 : : .startup.single = NULL,
1496 : : .teardown.single = takedown_cpu,
1497 : : .cant_stop = true,
1498 : : },
1499 : : /* Handle smpboot threads park/unpark */
1500 : : [CPUHP_AP_SMPBOOT_THREADS] = {
1501 : : .name = "smpboot/threads:online",
1502 : : .startup.single = smpboot_unpark_threads,
1503 : : .teardown.single = smpboot_park_threads,
1504 : : },
1505 : : [CPUHP_AP_IRQ_AFFINITY_ONLINE] = {
1506 : : .name = "irq/affinity:online",
1507 : : .startup.single = irq_affinity_online_cpu,
1508 : : .teardown.single = NULL,
1509 : : },
1510 : : [CPUHP_AP_PERF_ONLINE] = {
1511 : : .name = "perf:online",
1512 : : .startup.single = perf_event_init_cpu,
1513 : : .teardown.single = perf_event_exit_cpu,
1514 : : },
1515 : : [CPUHP_AP_WATCHDOG_ONLINE] = {
1516 : : .name = "lockup_detector:online",
1517 : : .startup.single = lockup_detector_online_cpu,
1518 : : .teardown.single = lockup_detector_offline_cpu,
1519 : : },
1520 : : [CPUHP_AP_WORKQUEUE_ONLINE] = {
1521 : : .name = "workqueue:online",
1522 : : .startup.single = workqueue_online_cpu,
1523 : : .teardown.single = workqueue_offline_cpu,
1524 : : },
1525 : : [CPUHP_AP_RCUTREE_ONLINE] = {
1526 : : .name = "RCU/tree:online",
1527 : : .startup.single = rcutree_online_cpu,
1528 : : .teardown.single = rcutree_offline_cpu,
1529 : : },
1530 : : #endif
1531 : : /*
1532 : : * The dynamically registered state space is here
1533 : : */
1534 : :
1535 : : #ifdef CONFIG_SMP
1536 : : /* Last state is scheduler control setting the cpu active */
1537 : : [CPUHP_AP_ACTIVE] = {
1538 : : .name = "sched:active",
1539 : : .startup.single = sched_cpu_activate,
1540 : : .teardown.single = sched_cpu_deactivate,
1541 : : },
1542 : : #endif
1543 : :
1544 : : /* CPU is fully up and running. */
1545 : : [CPUHP_ONLINE] = {
1546 : : .name = "online",
1547 : : .startup.single = NULL,
1548 : : .teardown.single = NULL,
1549 : : },
1550 : : };
1551 : :
1552 : : /* Sanity check for callbacks */
1553 : : static int cpuhp_cb_check(enum cpuhp_state state)
1554 : : {
1555 : 3 : if (state <= CPUHP_OFFLINE || state >= CPUHP_ONLINE)
1556 : : return -EINVAL;
1557 : : return 0;
1558 : : }
1559 : :
1560 : : /*
1561 : : * Returns a free for dynamic slot assignment of the Online state. The states
1562 : : * are protected by the cpuhp_slot_states mutex and an empty slot is identified
1563 : : * by having no name assigned.
1564 : : */
1565 : 3 : static int cpuhp_reserve_state(enum cpuhp_state state)
1566 : : {
1567 : : enum cpuhp_state i, end;
1568 : : struct cpuhp_step *step;
1569 : :
1570 : 3 : switch (state) {
1571 : : case CPUHP_AP_ONLINE_DYN:
1572 : : step = cpuhp_hp_states + CPUHP_AP_ONLINE_DYN;
1573 : : end = CPUHP_AP_ONLINE_DYN_END;
1574 : : break;
1575 : : case CPUHP_BP_PREPARE_DYN:
1576 : : step = cpuhp_hp_states + CPUHP_BP_PREPARE_DYN;
1577 : : end = CPUHP_BP_PREPARE_DYN_END;
1578 : 0 : break;
1579 : : default:
1580 : : return -EINVAL;
1581 : : }
1582 : :
1583 : 3 : for (i = state; i <= end; i++, step++) {
1584 : 3 : if (!step->name)
1585 : 3 : return i;
1586 : : }
1587 : 0 : WARN(1, "No more dynamic states available for CPU hotplug\n");
1588 : 0 : return -ENOSPC;
1589 : : }
1590 : :
1591 : 3 : static int cpuhp_store_callbacks(enum cpuhp_state state, const char *name,
1592 : : int (*startup)(unsigned int cpu),
1593 : : int (*teardown)(unsigned int cpu),
1594 : : bool multi_instance)
1595 : : {
1596 : : /* (Un)Install the callbacks for further cpu hotplug operations */
1597 : : struct cpuhp_step *sp;
1598 : : int ret = 0;
1599 : :
1600 : : /*
1601 : : * If name is NULL, then the state gets removed.
1602 : : *
1603 : : * CPUHP_AP_ONLINE_DYN and CPUHP_BP_PREPARE_DYN are handed out on
1604 : : * the first allocation from these dynamic ranges, so the removal
1605 : : * would trigger a new allocation and clear the wrong (already
1606 : : * empty) state, leaving the callbacks of the to be cleared state
1607 : : * dangling, which causes wreckage on the next hotplug operation.
1608 : : */
1609 : 3 : if (name && (state == CPUHP_AP_ONLINE_DYN ||
1610 : 3 : state == CPUHP_BP_PREPARE_DYN)) {
1611 : 3 : ret = cpuhp_reserve_state(state);
1612 : 3 : if (ret < 0)
1613 : : return ret;
1614 : : state = ret;
1615 : : }
1616 : : sp = cpuhp_get_step(state);
1617 : 3 : if (name && sp->name)
1618 : : return -EBUSY;
1619 : :
1620 : 3 : sp->startup.single = startup;
1621 : 3 : sp->teardown.single = teardown;
1622 : 3 : sp->name = name;
1623 : 3 : sp->multi_instance = multi_instance;
1624 : 3 : INIT_HLIST_HEAD(&sp->list);
1625 : 3 : return ret;
1626 : : }
1627 : :
1628 : : static void *cpuhp_get_teardown_cb(enum cpuhp_state state)
1629 : : {
1630 : 0 : return cpuhp_get_step(state)->teardown.single;
1631 : : }
1632 : :
1633 : : /*
1634 : : * Call the startup/teardown function for a step either on the AP or
1635 : : * on the current CPU.
1636 : : */
1637 : 3 : static int cpuhp_issue_call(int cpu, enum cpuhp_state state, bool bringup,
1638 : : struct hlist_node *node)
1639 : : {
1640 : : struct cpuhp_step *sp = cpuhp_get_step(state);
1641 : : int ret;
1642 : :
1643 : : /*
1644 : : * If there's nothing to do, we done.
1645 : : * Relies on the union for multi_instance.
1646 : : */
1647 : 3 : if ((bringup && !sp->startup.single) ||
1648 : 0 : (!bringup && !sp->teardown.single))
1649 : : return 0;
1650 : : /*
1651 : : * The non AP bound callbacks can fail on bringup. On teardown
1652 : : * e.g. module removal we crash for now.
1653 : : */
1654 : : #ifdef CONFIG_SMP
1655 : 3 : if (cpuhp_is_ap_state(state))
1656 : 3 : ret = cpuhp_invoke_ap_callback(cpu, state, bringup, node);
1657 : : else
1658 : 3 : ret = cpuhp_invoke_callback(cpu, state, bringup, node, NULL);
1659 : : #else
1660 : : ret = cpuhp_invoke_callback(cpu, state, bringup, node, NULL);
1661 : : #endif
1662 : 3 : BUG_ON(ret && !bringup);
1663 : : return ret;
1664 : : }
1665 : :
1666 : : /*
1667 : : * Called from __cpuhp_setup_state on a recoverable failure.
1668 : : *
1669 : : * Note: The teardown callbacks for rollback are not allowed to fail!
1670 : : */
1671 : 3 : static void cpuhp_rollback_install(int failedcpu, enum cpuhp_state state,
1672 : : struct hlist_node *node)
1673 : : {
1674 : : int cpu;
1675 : :
1676 : : /* Roll back the already executed steps on the other cpus */
1677 : 3 : for_each_present_cpu(cpu) {
1678 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1679 : 3 : int cpustate = st->state;
1680 : :
1681 : 3 : if (cpu >= failedcpu)
1682 : : break;
1683 : :
1684 : : /* Did we invoke the startup call on that cpu ? */
1685 : 0 : if (cpustate >= state)
1686 : 0 : cpuhp_issue_call(cpu, state, false, node);
1687 : : }
1688 : 3 : }
1689 : :
1690 : 3 : int __cpuhp_state_add_instance_cpuslocked(enum cpuhp_state state,
1691 : : struct hlist_node *node,
1692 : : bool invoke)
1693 : : {
1694 : : struct cpuhp_step *sp;
1695 : : int cpu;
1696 : : int ret;
1697 : :
1698 : : lockdep_assert_cpus_held();
1699 : :
1700 : : sp = cpuhp_get_step(state);
1701 : 3 : if (sp->multi_instance == false)
1702 : : return -EINVAL;
1703 : :
1704 : 3 : mutex_lock(&cpuhp_state_mutex);
1705 : :
1706 : 3 : if (!invoke || !sp->startup.multi)
1707 : : goto add_node;
1708 : :
1709 : : /*
1710 : : * Try to call the startup callback for each present cpu
1711 : : * depending on the hotplug state of the cpu.
1712 : : */
1713 : 3 : for_each_present_cpu(cpu) {
1714 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1715 : 3 : int cpustate = st->state;
1716 : :
1717 : 3 : if (cpustate < state)
1718 : 0 : continue;
1719 : :
1720 : 3 : ret = cpuhp_issue_call(cpu, state, true, node);
1721 : 3 : if (ret) {
1722 : 0 : if (sp->teardown.multi)
1723 : 0 : cpuhp_rollback_install(cpu, state, node);
1724 : : goto unlock;
1725 : : }
1726 : : }
1727 : : add_node:
1728 : : ret = 0;
1729 : : hlist_add_head(node, &sp->list);
1730 : : unlock:
1731 : 3 : mutex_unlock(&cpuhp_state_mutex);
1732 : 3 : return ret;
1733 : : }
1734 : :
1735 : 3 : int __cpuhp_state_add_instance(enum cpuhp_state state, struct hlist_node *node,
1736 : : bool invoke)
1737 : : {
1738 : : int ret;
1739 : :
1740 : : cpus_read_lock();
1741 : 3 : ret = __cpuhp_state_add_instance_cpuslocked(state, node, invoke);
1742 : : cpus_read_unlock();
1743 : 3 : return ret;
1744 : : }
1745 : : EXPORT_SYMBOL_GPL(__cpuhp_state_add_instance);
1746 : :
1747 : : /**
1748 : : * __cpuhp_setup_state_cpuslocked - Setup the callbacks for an hotplug machine state
1749 : : * @state: The state to setup
1750 : : * @invoke: If true, the startup function is invoked for cpus where
1751 : : * cpu state >= @state
1752 : : * @startup: startup callback function
1753 : : * @teardown: teardown callback function
1754 : : * @multi_instance: State is set up for multiple instances which get
1755 : : * added afterwards.
1756 : : *
1757 : : * The caller needs to hold cpus read locked while calling this function.
1758 : : * Returns:
1759 : : * On success:
1760 : : * Positive state number if @state is CPUHP_AP_ONLINE_DYN
1761 : : * 0 for all other states
1762 : : * On failure: proper (negative) error code
1763 : : */
1764 : 3 : int __cpuhp_setup_state_cpuslocked(enum cpuhp_state state,
1765 : : const char *name, bool invoke,
1766 : : int (*startup)(unsigned int cpu),
1767 : : int (*teardown)(unsigned int cpu),
1768 : : bool multi_instance)
1769 : : {
1770 : : int cpu, ret = 0;
1771 : : bool dynstate;
1772 : :
1773 : : lockdep_assert_cpus_held();
1774 : :
1775 : 3 : if (cpuhp_cb_check(state) || !name)
1776 : : return -EINVAL;
1777 : :
1778 : 3 : mutex_lock(&cpuhp_state_mutex);
1779 : :
1780 : 3 : ret = cpuhp_store_callbacks(state, name, startup, teardown,
1781 : : multi_instance);
1782 : :
1783 : 3 : dynstate = state == CPUHP_AP_ONLINE_DYN;
1784 : 3 : if (ret > 0 && dynstate) {
1785 : : state = ret;
1786 : : ret = 0;
1787 : : }
1788 : :
1789 : 3 : if (ret || !invoke || !startup)
1790 : : goto out;
1791 : :
1792 : : /*
1793 : : * Try to call the startup callback for each present cpu
1794 : : * depending on the hotplug state of the cpu.
1795 : : */
1796 : 3 : for_each_present_cpu(cpu) {
1797 : 3 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1798 : 3 : int cpustate = st->state;
1799 : :
1800 : 3 : if (cpustate < state)
1801 : 3 : continue;
1802 : :
1803 : 3 : ret = cpuhp_issue_call(cpu, state, true, NULL);
1804 : 3 : if (ret) {
1805 : 3 : if (teardown)
1806 : 3 : cpuhp_rollback_install(cpu, state, NULL);
1807 : 3 : cpuhp_store_callbacks(state, NULL, NULL, NULL, false);
1808 : 3 : goto out;
1809 : : }
1810 : : }
1811 : : out:
1812 : 3 : mutex_unlock(&cpuhp_state_mutex);
1813 : : /*
1814 : : * If the requested state is CPUHP_AP_ONLINE_DYN, return the
1815 : : * dynamically allocated state in case of success.
1816 : : */
1817 : 3 : if (!ret && dynstate)
1818 : : return state;
1819 : 3 : return ret;
1820 : : }
1821 : : EXPORT_SYMBOL(__cpuhp_setup_state_cpuslocked);
1822 : :
1823 : 3 : int __cpuhp_setup_state(enum cpuhp_state state,
1824 : : const char *name, bool invoke,
1825 : : int (*startup)(unsigned int cpu),
1826 : : int (*teardown)(unsigned int cpu),
1827 : : bool multi_instance)
1828 : : {
1829 : : int ret;
1830 : :
1831 : : cpus_read_lock();
1832 : 3 : ret = __cpuhp_setup_state_cpuslocked(state, name, invoke, startup,
1833 : : teardown, multi_instance);
1834 : : cpus_read_unlock();
1835 : 3 : return ret;
1836 : : }
1837 : : EXPORT_SYMBOL(__cpuhp_setup_state);
1838 : :
1839 : 0 : int __cpuhp_state_remove_instance(enum cpuhp_state state,
1840 : : struct hlist_node *node, bool invoke)
1841 : : {
1842 : : struct cpuhp_step *sp = cpuhp_get_step(state);
1843 : : int cpu;
1844 : :
1845 : 0 : BUG_ON(cpuhp_cb_check(state));
1846 : :
1847 : 0 : if (!sp->multi_instance)
1848 : : return -EINVAL;
1849 : :
1850 : : cpus_read_lock();
1851 : 0 : mutex_lock(&cpuhp_state_mutex);
1852 : :
1853 : 0 : if (!invoke || !cpuhp_get_teardown_cb(state))
1854 : : goto remove;
1855 : : /*
1856 : : * Call the teardown callback for each present cpu depending
1857 : : * on the hotplug state of the cpu. This function is not
1858 : : * allowed to fail currently!
1859 : : */
1860 : 0 : for_each_present_cpu(cpu) {
1861 : 0 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1862 : 0 : int cpustate = st->state;
1863 : :
1864 : 0 : if (cpustate >= state)
1865 : 0 : cpuhp_issue_call(cpu, state, false, node);
1866 : : }
1867 : :
1868 : : remove:
1869 : : hlist_del(node);
1870 : 0 : mutex_unlock(&cpuhp_state_mutex);
1871 : : cpus_read_unlock();
1872 : :
1873 : 0 : return 0;
1874 : : }
1875 : : EXPORT_SYMBOL_GPL(__cpuhp_state_remove_instance);
1876 : :
1877 : : /**
1878 : : * __cpuhp_remove_state_cpuslocked - Remove the callbacks for an hotplug machine state
1879 : : * @state: The state to remove
1880 : : * @invoke: If true, the teardown function is invoked for cpus where
1881 : : * cpu state >= @state
1882 : : *
1883 : : * The caller needs to hold cpus read locked while calling this function.
1884 : : * The teardown callback is currently not allowed to fail. Think
1885 : : * about module removal!
1886 : : */
1887 : 1 : void __cpuhp_remove_state_cpuslocked(enum cpuhp_state state, bool invoke)
1888 : : {
1889 : : struct cpuhp_step *sp = cpuhp_get_step(state);
1890 : : int cpu;
1891 : :
1892 : 1 : BUG_ON(cpuhp_cb_check(state));
1893 : :
1894 : : lockdep_assert_cpus_held();
1895 : :
1896 : 1 : mutex_lock(&cpuhp_state_mutex);
1897 : 1 : if (sp->multi_instance) {
1898 : 0 : WARN(!hlist_empty(&sp->list),
1899 : : "Error: Removing state %d which has instances left.\n",
1900 : : state);
1901 : : goto remove;
1902 : : }
1903 : :
1904 : 1 : if (!invoke || !cpuhp_get_teardown_cb(state))
1905 : : goto remove;
1906 : :
1907 : : /*
1908 : : * Call the teardown callback for each present cpu depending
1909 : : * on the hotplug state of the cpu. This function is not
1910 : : * allowed to fail currently!
1911 : : */
1912 : 0 : for_each_present_cpu(cpu) {
1913 : 0 : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1914 : 0 : int cpustate = st->state;
1915 : :
1916 : 0 : if (cpustate >= state)
1917 : 0 : cpuhp_issue_call(cpu, state, false, NULL);
1918 : : }
1919 : : remove:
1920 : 1 : cpuhp_store_callbacks(state, NULL, NULL, NULL, false);
1921 : 1 : mutex_unlock(&cpuhp_state_mutex);
1922 : 1 : }
1923 : : EXPORT_SYMBOL(__cpuhp_remove_state_cpuslocked);
1924 : :
1925 : 0 : void __cpuhp_remove_state(enum cpuhp_state state, bool invoke)
1926 : : {
1927 : : cpus_read_lock();
1928 : 0 : __cpuhp_remove_state_cpuslocked(state, invoke);
1929 : : cpus_read_unlock();
1930 : 0 : }
1931 : : EXPORT_SYMBOL(__cpuhp_remove_state);
1932 : :
1933 : : #ifdef CONFIG_HOTPLUG_SMT
1934 : : static void cpuhp_offline_cpu_device(unsigned int cpu)
1935 : : {
1936 : : struct device *dev = get_cpu_device(cpu);
1937 : :
1938 : : dev->offline = true;
1939 : : /* Tell user space about the state change */
1940 : : kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
1941 : : }
1942 : :
1943 : : static void cpuhp_online_cpu_device(unsigned int cpu)
1944 : : {
1945 : : struct device *dev = get_cpu_device(cpu);
1946 : :
1947 : : dev->offline = false;
1948 : : /* Tell user space about the state change */
1949 : : kobject_uevent(&dev->kobj, KOBJ_ONLINE);
1950 : : }
1951 : :
1952 : : int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval)
1953 : : {
1954 : : int cpu, ret = 0;
1955 : :
1956 : : cpu_maps_update_begin();
1957 : : for_each_online_cpu(cpu) {
1958 : : if (topology_is_primary_thread(cpu))
1959 : : continue;
1960 : : ret = cpu_down_maps_locked(cpu, CPUHP_OFFLINE);
1961 : : if (ret)
1962 : : break;
1963 : : /*
1964 : : * As this needs to hold the cpu maps lock it's impossible
1965 : : * to call device_offline() because that ends up calling
1966 : : * cpu_down() which takes cpu maps lock. cpu maps lock
1967 : : * needs to be held as this might race against in kernel
1968 : : * abusers of the hotplug machinery (thermal management).
1969 : : *
1970 : : * So nothing would update device:offline state. That would
1971 : : * leave the sysfs entry stale and prevent onlining after
1972 : : * smt control has been changed to 'off' again. This is
1973 : : * called under the sysfs hotplug lock, so it is properly
1974 : : * serialized against the regular offline usage.
1975 : : */
1976 : : cpuhp_offline_cpu_device(cpu);
1977 : : }
1978 : : if (!ret)
1979 : : cpu_smt_control = ctrlval;
1980 : : cpu_maps_update_done();
1981 : : return ret;
1982 : : }
1983 : :
1984 : : int cpuhp_smt_enable(void)
1985 : : {
1986 : : int cpu, ret = 0;
1987 : :
1988 : : cpu_maps_update_begin();
1989 : : cpu_smt_control = CPU_SMT_ENABLED;
1990 : : for_each_present_cpu(cpu) {
1991 : : /* Skip online CPUs and CPUs on offline nodes */
1992 : : if (cpu_online(cpu) || !node_online(cpu_to_node(cpu)))
1993 : : continue;
1994 : : ret = _cpu_up(cpu, 0, CPUHP_ONLINE);
1995 : : if (ret)
1996 : : break;
1997 : : /* See comment in cpuhp_smt_disable() */
1998 : : cpuhp_online_cpu_device(cpu);
1999 : : }
2000 : : cpu_maps_update_done();
2001 : : return ret;
2002 : : }
2003 : : #endif
2004 : :
2005 : : #if defined(CONFIG_SYSFS) && defined(CONFIG_HOTPLUG_CPU)
2006 : : static ssize_t show_cpuhp_state(struct device *dev,
2007 : : struct device_attribute *attr, char *buf)
2008 : : {
2009 : : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2010 : :
2011 : : return sprintf(buf, "%d\n", st->state);
2012 : : }
2013 : : static DEVICE_ATTR(state, 0444, show_cpuhp_state, NULL);
2014 : :
2015 : : static ssize_t write_cpuhp_target(struct device *dev,
2016 : : struct device_attribute *attr,
2017 : : const char *buf, size_t count)
2018 : : {
2019 : : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2020 : : struct cpuhp_step *sp;
2021 : : int target, ret;
2022 : :
2023 : : ret = kstrtoint(buf, 10, &target);
2024 : : if (ret)
2025 : : return ret;
2026 : :
2027 : : #ifdef CONFIG_CPU_HOTPLUG_STATE_CONTROL
2028 : : if (target < CPUHP_OFFLINE || target > CPUHP_ONLINE)
2029 : : return -EINVAL;
2030 : : #else
2031 : : if (target != CPUHP_OFFLINE && target != CPUHP_ONLINE)
2032 : : return -EINVAL;
2033 : : #endif
2034 : :
2035 : : ret = lock_device_hotplug_sysfs();
2036 : : if (ret)
2037 : : return ret;
2038 : :
2039 : : mutex_lock(&cpuhp_state_mutex);
2040 : : sp = cpuhp_get_step(target);
2041 : : ret = !sp->name || sp->cant_stop ? -EINVAL : 0;
2042 : : mutex_unlock(&cpuhp_state_mutex);
2043 : : if (ret)
2044 : : goto out;
2045 : :
2046 : : if (st->state < target)
2047 : : ret = do_cpu_up(dev->id, target);
2048 : : else
2049 : : ret = do_cpu_down(dev->id, target);
2050 : : out:
2051 : : unlock_device_hotplug();
2052 : : return ret ? ret : count;
2053 : : }
2054 : :
2055 : : static ssize_t show_cpuhp_target(struct device *dev,
2056 : : struct device_attribute *attr, char *buf)
2057 : : {
2058 : : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2059 : :
2060 : : return sprintf(buf, "%d\n", st->target);
2061 : : }
2062 : : static DEVICE_ATTR(target, 0644, show_cpuhp_target, write_cpuhp_target);
2063 : :
2064 : :
2065 : : static ssize_t write_cpuhp_fail(struct device *dev,
2066 : : struct device_attribute *attr,
2067 : : const char *buf, size_t count)
2068 : : {
2069 : : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2070 : : struct cpuhp_step *sp;
2071 : : int fail, ret;
2072 : :
2073 : : ret = kstrtoint(buf, 10, &fail);
2074 : : if (ret)
2075 : : return ret;
2076 : :
2077 : : if (fail < CPUHP_OFFLINE || fail > CPUHP_ONLINE)
2078 : : return -EINVAL;
2079 : :
2080 : : /*
2081 : : * Cannot fail STARTING/DYING callbacks.
2082 : : */
2083 : : if (cpuhp_is_atomic_state(fail))
2084 : : return -EINVAL;
2085 : :
2086 : : /*
2087 : : * Cannot fail anything that doesn't have callbacks.
2088 : : */
2089 : : mutex_lock(&cpuhp_state_mutex);
2090 : : sp = cpuhp_get_step(fail);
2091 : : if (!sp->startup.single && !sp->teardown.single)
2092 : : ret = -EINVAL;
2093 : : mutex_unlock(&cpuhp_state_mutex);
2094 : : if (ret)
2095 : : return ret;
2096 : :
2097 : : st->fail = fail;
2098 : :
2099 : : return count;
2100 : : }
2101 : :
2102 : : static ssize_t show_cpuhp_fail(struct device *dev,
2103 : : struct device_attribute *attr, char *buf)
2104 : : {
2105 : : struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2106 : :
2107 : : return sprintf(buf, "%d\n", st->fail);
2108 : : }
2109 : :
2110 : : static DEVICE_ATTR(fail, 0644, show_cpuhp_fail, write_cpuhp_fail);
2111 : :
2112 : : static struct attribute *cpuhp_cpu_attrs[] = {
2113 : : &dev_attr_state.attr,
2114 : : &dev_attr_target.attr,
2115 : : &dev_attr_fail.attr,
2116 : : NULL
2117 : : };
2118 : :
2119 : : static const struct attribute_group cpuhp_cpu_attr_group = {
2120 : : .attrs = cpuhp_cpu_attrs,
2121 : : .name = "hotplug",
2122 : : NULL
2123 : : };
2124 : :
2125 : : static ssize_t show_cpuhp_states(struct device *dev,
2126 : : struct device_attribute *attr, char *buf)
2127 : : {
2128 : : ssize_t cur, res = 0;
2129 : : int i;
2130 : :
2131 : : mutex_lock(&cpuhp_state_mutex);
2132 : : for (i = CPUHP_OFFLINE; i <= CPUHP_ONLINE; i++) {
2133 : : struct cpuhp_step *sp = cpuhp_get_step(i);
2134 : :
2135 : : if (sp->name) {
2136 : : cur = sprintf(buf, "%3d: %s\n", i, sp->name);
2137 : : buf += cur;
2138 : : res += cur;
2139 : : }
2140 : : }
2141 : : mutex_unlock(&cpuhp_state_mutex);
2142 : : return res;
2143 : : }
2144 : : static DEVICE_ATTR(states, 0444, show_cpuhp_states, NULL);
2145 : :
2146 : : static struct attribute *cpuhp_cpu_root_attrs[] = {
2147 : : &dev_attr_states.attr,
2148 : : NULL
2149 : : };
2150 : :
2151 : : static const struct attribute_group cpuhp_cpu_root_attr_group = {
2152 : : .attrs = cpuhp_cpu_root_attrs,
2153 : : .name = "hotplug",
2154 : : NULL
2155 : : };
2156 : :
2157 : : #ifdef CONFIG_HOTPLUG_SMT
2158 : :
2159 : : static ssize_t
2160 : : __store_smt_control(struct device *dev, struct device_attribute *attr,
2161 : : const char *buf, size_t count)
2162 : : {
2163 : : int ctrlval, ret;
2164 : :
2165 : : if (sysfs_streq(buf, "on"))
2166 : : ctrlval = CPU_SMT_ENABLED;
2167 : : else if (sysfs_streq(buf, "off"))
2168 : : ctrlval = CPU_SMT_DISABLED;
2169 : : else if (sysfs_streq(buf, "forceoff"))
2170 : : ctrlval = CPU_SMT_FORCE_DISABLED;
2171 : : else
2172 : : return -EINVAL;
2173 : :
2174 : : if (cpu_smt_control == CPU_SMT_FORCE_DISABLED)
2175 : : return -EPERM;
2176 : :
2177 : : if (cpu_smt_control == CPU_SMT_NOT_SUPPORTED)
2178 : : return -ENODEV;
2179 : :
2180 : : ret = lock_device_hotplug_sysfs();
2181 : : if (ret)
2182 : : return ret;
2183 : :
2184 : : if (ctrlval != cpu_smt_control) {
2185 : : switch (ctrlval) {
2186 : : case CPU_SMT_ENABLED:
2187 : : ret = cpuhp_smt_enable();
2188 : : break;
2189 : : case CPU_SMT_DISABLED:
2190 : : case CPU_SMT_FORCE_DISABLED:
2191 : : ret = cpuhp_smt_disable(ctrlval);
2192 : : break;
2193 : : }
2194 : : }
2195 : :
2196 : : unlock_device_hotplug();
2197 : : return ret ? ret : count;
2198 : : }
2199 : :
2200 : : #else /* !CONFIG_HOTPLUG_SMT */
2201 : : static ssize_t
2202 : : __store_smt_control(struct device *dev, struct device_attribute *attr,
2203 : : const char *buf, size_t count)
2204 : : {
2205 : : return -ENODEV;
2206 : : }
2207 : : #endif /* CONFIG_HOTPLUG_SMT */
2208 : :
2209 : : static const char *smt_states[] = {
2210 : : [CPU_SMT_ENABLED] = "on",
2211 : : [CPU_SMT_DISABLED] = "off",
2212 : : [CPU_SMT_FORCE_DISABLED] = "forceoff",
2213 : : [CPU_SMT_NOT_SUPPORTED] = "notsupported",
2214 : : [CPU_SMT_NOT_IMPLEMENTED] = "notimplemented",
2215 : : };
2216 : :
2217 : : static ssize_t
2218 : : show_smt_control(struct device *dev, struct device_attribute *attr, char *buf)
2219 : : {
2220 : : const char *state = smt_states[cpu_smt_control];
2221 : :
2222 : : return snprintf(buf, PAGE_SIZE - 2, "%s\n", state);
2223 : : }
2224 : :
2225 : : static ssize_t
2226 : : store_smt_control(struct device *dev, struct device_attribute *attr,
2227 : : const char *buf, size_t count)
2228 : : {
2229 : : return __store_smt_control(dev, attr, buf, count);
2230 : : }
2231 : : static DEVICE_ATTR(control, 0644, show_smt_control, store_smt_control);
2232 : :
2233 : : static ssize_t
2234 : : show_smt_active(struct device *dev, struct device_attribute *attr, char *buf)
2235 : : {
2236 : : return snprintf(buf, PAGE_SIZE - 2, "%d\n", sched_smt_active());
2237 : : }
2238 : : static DEVICE_ATTR(active, 0444, show_smt_active, NULL);
2239 : :
2240 : : static struct attribute *cpuhp_smt_attrs[] = {
2241 : : &dev_attr_control.attr,
2242 : : &dev_attr_active.attr,
2243 : : NULL
2244 : : };
2245 : :
2246 : : static const struct attribute_group cpuhp_smt_attr_group = {
2247 : : .attrs = cpuhp_smt_attrs,
2248 : : .name = "smt",
2249 : : NULL
2250 : : };
2251 : :
2252 : : static int __init cpu_smt_sysfs_init(void)
2253 : : {
2254 : : return sysfs_create_group(&cpu_subsys.dev_root->kobj,
2255 : : &cpuhp_smt_attr_group);
2256 : : }
2257 : :
2258 : : static int __init cpuhp_sysfs_init(void)
2259 : : {
2260 : : int cpu, ret;
2261 : :
2262 : : ret = cpu_smt_sysfs_init();
2263 : : if (ret)
2264 : : return ret;
2265 : :
2266 : : ret = sysfs_create_group(&cpu_subsys.dev_root->kobj,
2267 : : &cpuhp_cpu_root_attr_group);
2268 : : if (ret)
2269 : : return ret;
2270 : :
2271 : : for_each_possible_cpu(cpu) {
2272 : : struct device *dev = get_cpu_device(cpu);
2273 : :
2274 : : if (!dev)
2275 : : continue;
2276 : : ret = sysfs_create_group(&dev->kobj, &cpuhp_cpu_attr_group);
2277 : : if (ret)
2278 : : return ret;
2279 : : }
2280 : : return 0;
2281 : : }
2282 : : device_initcall(cpuhp_sysfs_init);
2283 : : #endif /* CONFIG_SYSFS && CONFIG_HOTPLUG_CPU */
2284 : :
2285 : : /*
2286 : : * cpu_bit_bitmap[] is a special, "compressed" data structure that
2287 : : * represents all NR_CPUS bits binary values of 1<<nr.
2288 : : *
2289 : : * It is used by cpumask_of() to get a constant address to a CPU
2290 : : * mask value that has a single bit set only.
2291 : : */
2292 : :
2293 : : /* cpu_bit_bitmap[0] is empty - so we can back into it */
2294 : : #define MASK_DECLARE_1(x) [x+1][0] = (1UL << (x))
2295 : : #define MASK_DECLARE_2(x) MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
2296 : : #define MASK_DECLARE_4(x) MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
2297 : : #define MASK_DECLARE_8(x) MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
2298 : :
2299 : : const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
2300 : :
2301 : : MASK_DECLARE_8(0), MASK_DECLARE_8(8),
2302 : : MASK_DECLARE_8(16), MASK_DECLARE_8(24),
2303 : : #if BITS_PER_LONG > 32
2304 : : MASK_DECLARE_8(32), MASK_DECLARE_8(40),
2305 : : MASK_DECLARE_8(48), MASK_DECLARE_8(56),
2306 : : #endif
2307 : : };
2308 : : EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
2309 : :
2310 : : const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
2311 : : EXPORT_SYMBOL(cpu_all_bits);
2312 : :
2313 : : #ifdef CONFIG_INIT_ALL_POSSIBLE
2314 : : struct cpumask __cpu_possible_mask __read_mostly
2315 : : = {CPU_BITS_ALL};
2316 : : #else
2317 : : struct cpumask __cpu_possible_mask __read_mostly;
2318 : : #endif
2319 : : EXPORT_SYMBOL(__cpu_possible_mask);
2320 : :
2321 : : struct cpumask __cpu_online_mask __read_mostly;
2322 : : EXPORT_SYMBOL(__cpu_online_mask);
2323 : :
2324 : : struct cpumask __cpu_present_mask __read_mostly;
2325 : : EXPORT_SYMBOL(__cpu_present_mask);
2326 : :
2327 : : struct cpumask __cpu_active_mask __read_mostly;
2328 : : EXPORT_SYMBOL(__cpu_active_mask);
2329 : :
2330 : : atomic_t __num_online_cpus __read_mostly;
2331 : : EXPORT_SYMBOL(__num_online_cpus);
2332 : :
2333 : 3 : void init_cpu_present(const struct cpumask *src)
2334 : : {
2335 : : cpumask_copy(&__cpu_present_mask, src);
2336 : 3 : }
2337 : :
2338 : 0 : void init_cpu_possible(const struct cpumask *src)
2339 : : {
2340 : : cpumask_copy(&__cpu_possible_mask, src);
2341 : 0 : }
2342 : :
2343 : 0 : void init_cpu_online(const struct cpumask *src)
2344 : : {
2345 : : cpumask_copy(&__cpu_online_mask, src);
2346 : 0 : }
2347 : :
2348 : 3 : void set_cpu_online(unsigned int cpu, bool online)
2349 : : {
2350 : : /*
2351 : : * atomic_inc/dec() is required to handle the horrid abuse of this
2352 : : * function by the reboot and kexec code which invoke it from
2353 : : * IPI/NMI broadcasts when shutting down CPUs. Invocation from
2354 : : * regular CPU hotplug is properly serialized.
2355 : : *
2356 : : * Note, that the fact that __num_online_cpus is of type atomic_t
2357 : : * does not protect readers which are not serialized against
2358 : : * concurrent hotplug operations.
2359 : : */
2360 : 3 : if (online) {
2361 : 3 : if (!cpumask_test_and_set_cpu(cpu, &__cpu_online_mask))
2362 : : atomic_inc(&__num_online_cpus);
2363 : : } else {
2364 : 0 : if (cpumask_test_and_clear_cpu(cpu, &__cpu_online_mask))
2365 : : atomic_dec(&__num_online_cpus);
2366 : : }
2367 : 3 : }
2368 : :
2369 : : /*
2370 : : * Activate the first processor.
2371 : : */
2372 : 3 : void __init boot_cpu_init(void)
2373 : : {
2374 : 3 : int cpu = smp_processor_id();
2375 : :
2376 : : /* Mark the boot cpu "present", "online" etc for SMP and UP case */
2377 : 3 : set_cpu_online(cpu, true);
2378 : 3 : set_cpu_active(cpu, true);
2379 : 3 : set_cpu_present(cpu, true);
2380 : 3 : set_cpu_possible(cpu, true);
2381 : :
2382 : : #ifdef CONFIG_SMP
2383 : 3 : __boot_cpu_id = cpu;
2384 : : #endif
2385 : 3 : }
2386 : :
2387 : : /*
2388 : : * Must be called _AFTER_ setting up the per_cpu areas
2389 : : */
2390 : 3 : void __init boot_cpu_hotplug_init(void)
2391 : : {
2392 : : #ifdef CONFIG_SMP
2393 : 3 : cpumask_set_cpu(smp_processor_id(), &cpus_booted_once_mask);
2394 : : #endif
2395 : 3 : this_cpu_write(cpuhp_state.state, CPUHP_ONLINE);
2396 : 3 : }
2397 : :
2398 : : /*
2399 : : * These are used for a global "mitigations=" cmdline option for toggling
2400 : : * optional CPU mitigations.
2401 : : */
2402 : : enum cpu_mitigations {
2403 : : CPU_MITIGATIONS_OFF,
2404 : : CPU_MITIGATIONS_AUTO,
2405 : : CPU_MITIGATIONS_AUTO_NOSMT,
2406 : : };
2407 : :
2408 : : static enum cpu_mitigations cpu_mitigations __ro_after_init =
2409 : : CPU_MITIGATIONS_AUTO;
2410 : :
2411 : 0 : static int __init mitigations_parse_cmdline(char *arg)
2412 : : {
2413 : 0 : if (!strcmp(arg, "off"))
2414 : 0 : cpu_mitigations = CPU_MITIGATIONS_OFF;
2415 : 0 : else if (!strcmp(arg, "auto"))
2416 : 0 : cpu_mitigations = CPU_MITIGATIONS_AUTO;
2417 : 0 : else if (!strcmp(arg, "auto,nosmt"))
2418 : 0 : cpu_mitigations = CPU_MITIGATIONS_AUTO_NOSMT;
2419 : : else
2420 : 0 : pr_crit("Unsupported mitigations=%s, system may still be vulnerable\n",
2421 : : arg);
2422 : :
2423 : 0 : return 0;
2424 : : }
2425 : : early_param("mitigations", mitigations_parse_cmdline);
2426 : :
2427 : : /* mitigations=off */
2428 : 0 : bool cpu_mitigations_off(void)
2429 : : {
2430 : 0 : return cpu_mitigations == CPU_MITIGATIONS_OFF;
2431 : : }
2432 : : EXPORT_SYMBOL_GPL(cpu_mitigations_off);
2433 : :
2434 : : /* mitigations=auto,nosmt */
2435 : 0 : bool cpu_mitigations_auto_nosmt(void)
2436 : : {
2437 : 0 : return cpu_mitigations == CPU_MITIGATIONS_AUTO_NOSMT;
2438 : : }
2439 : : EXPORT_SYMBOL_GPL(cpu_mitigations_auto_nosmt);
|
