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