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