Merge branch 'smp-hotplug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[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 struct cpuhp_step *cpuhp_get_step(enum cpuhp_state state)
130 {
131         return cpuhp_hp_states + state;
132 }
133
134 /**
135  * cpuhp_invoke_callback _ Invoke the callbacks for a given state
136  * @cpu:        The cpu for which the callback should be invoked
137  * @state:      The state to do callbacks for
138  * @bringup:    True if the bringup callback should be invoked
139  * @node:       For multi-instance, do a single entry callback for install/remove
140  * @lastp:      For multi-instance rollback, remember how far we got
141  *
142  * Called from cpu hotplug and from the state register machinery.
143  */
144 static int cpuhp_invoke_callback(unsigned int cpu, enum cpuhp_state state,
145                                  bool bringup, struct hlist_node *node,
146                                  struct hlist_node **lastp)
147 {
148         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
149         struct cpuhp_step *step = cpuhp_get_step(state);
150         int (*cbm)(unsigned int cpu, struct hlist_node *node);
151         int (*cb)(unsigned int cpu);
152         int ret, cnt;
153
154         if (st->fail == state) {
155                 st->fail = CPUHP_INVALID;
156
157                 if (!(bringup ? step->startup.single : step->teardown.single))
158                         return 0;
159
160                 return -EAGAIN;
161         }
162
163         if (!step->multi_instance) {
164                 WARN_ON_ONCE(lastp && *lastp);
165                 cb = bringup ? step->startup.single : step->teardown.single;
166                 if (!cb)
167                         return 0;
168                 trace_cpuhp_enter(cpu, st->target, state, cb);
169                 ret = cb(cpu);
170                 trace_cpuhp_exit(cpu, st->state, state, ret);
171                 return ret;
172         }
173         cbm = bringup ? step->startup.multi : step->teardown.multi;
174         if (!cbm)
175                 return 0;
176
177         /* Single invocation for instance add/remove */
178         if (node) {
179                 WARN_ON_ONCE(lastp && *lastp);
180                 trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
181                 ret = cbm(cpu, node);
182                 trace_cpuhp_exit(cpu, st->state, state, ret);
183                 return ret;
184         }
185
186         /* State transition. Invoke on all instances */
187         cnt = 0;
188         hlist_for_each(node, &step->list) {
189                 if (lastp && node == *lastp)
190                         break;
191
192                 trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
193                 ret = cbm(cpu, node);
194                 trace_cpuhp_exit(cpu, st->state, state, ret);
195                 if (ret) {
196                         if (!lastp)
197                                 goto err;
198
199                         *lastp = node;
200                         return ret;
201                 }
202                 cnt++;
203         }
204         if (lastp)
205                 *lastp = NULL;
206         return 0;
207 err:
208         /* Rollback the instances if one failed */
209         cbm = !bringup ? step->startup.multi : step->teardown.multi;
210         if (!cbm)
211                 return ret;
212
213         hlist_for_each(node, &step->list) {
214                 if (!cnt--)
215                         break;
216
217                 trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
218                 ret = cbm(cpu, node);
219                 trace_cpuhp_exit(cpu, st->state, state, ret);
220                 /*
221                  * Rollback must not fail,
222                  */
223                 WARN_ON_ONCE(ret);
224         }
225         return ret;
226 }
227
228 #ifdef CONFIG_SMP
229 static bool cpuhp_is_ap_state(enum cpuhp_state state)
230 {
231         /*
232          * The extra check for CPUHP_TEARDOWN_CPU is only for documentation
233          * purposes as that state is handled explicitly in cpu_down.
234          */
235         return state > CPUHP_BRINGUP_CPU && state != CPUHP_TEARDOWN_CPU;
236 }
237
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:prepare",
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_WATCHDOG_ONLINE] = {
1348                 .name                   = "lockup_detector:online",
1349                 .startup.single         = lockup_detector_online_cpu,
1350                 .teardown.single        = lockup_detector_offline_cpu,
1351         },
1352         [CPUHP_AP_WORKQUEUE_ONLINE] = {
1353                 .name                   = "workqueue:online",
1354                 .startup.single         = workqueue_online_cpu,
1355                 .teardown.single        = workqueue_offline_cpu,
1356         },
1357         [CPUHP_AP_RCUTREE_ONLINE] = {
1358                 .name                   = "RCU/tree:online",
1359                 .startup.single         = rcutree_online_cpu,
1360                 .teardown.single        = rcutree_offline_cpu,
1361         },
1362 #endif
1363         /*
1364          * The dynamically registered state space is here
1365          */
1366
1367 #ifdef CONFIG_SMP
1368         /* Last state is scheduler control setting the cpu active */
1369         [CPUHP_AP_ACTIVE] = {
1370                 .name                   = "sched:active",
1371                 .startup.single         = sched_cpu_activate,
1372                 .teardown.single        = sched_cpu_deactivate,
1373         },
1374 #endif
1375
1376         /* CPU is fully up and running. */
1377         [CPUHP_ONLINE] = {
1378                 .name                   = "online",
1379                 .startup.single         = NULL,
1380                 .teardown.single        = NULL,
1381         },
1382 };
1383
1384 /* Sanity check for callbacks */
1385 static int cpuhp_cb_check(enum cpuhp_state state)
1386 {
1387         if (state <= CPUHP_OFFLINE || state >= CPUHP_ONLINE)
1388                 return -EINVAL;
1389         return 0;
1390 }
1391
1392 /*
1393  * Returns a free for dynamic slot assignment of the Online state. The states
1394  * are protected by the cpuhp_slot_states mutex and an empty slot is identified
1395  * by having no name assigned.
1396  */
1397 static int cpuhp_reserve_state(enum cpuhp_state state)
1398 {
1399         enum cpuhp_state i, end;
1400         struct cpuhp_step *step;
1401
1402         switch (state) {
1403         case CPUHP_AP_ONLINE_DYN:
1404                 step = cpuhp_hp_states + CPUHP_AP_ONLINE_DYN;
1405                 end = CPUHP_AP_ONLINE_DYN_END;
1406                 break;
1407         case CPUHP_BP_PREPARE_DYN:
1408                 step = cpuhp_hp_states + CPUHP_BP_PREPARE_DYN;
1409                 end = CPUHP_BP_PREPARE_DYN_END;
1410                 break;
1411         default:
1412                 return -EINVAL;
1413         }
1414
1415         for (i = state; i <= end; i++, step++) {
1416                 if (!step->name)
1417                         return i;
1418         }
1419         WARN(1, "No more dynamic states available for CPU hotplug\n");
1420         return -ENOSPC;
1421 }
1422
1423 static int cpuhp_store_callbacks(enum cpuhp_state state, const char *name,
1424                                  int (*startup)(unsigned int cpu),
1425                                  int (*teardown)(unsigned int cpu),
1426                                  bool multi_instance)
1427 {
1428         /* (Un)Install the callbacks for further cpu hotplug operations */
1429         struct cpuhp_step *sp;
1430         int ret = 0;
1431
1432         /*
1433          * If name is NULL, then the state gets removed.
1434          *
1435          * CPUHP_AP_ONLINE_DYN and CPUHP_BP_PREPARE_DYN are handed out on
1436          * the first allocation from these dynamic ranges, so the removal
1437          * would trigger a new allocation and clear the wrong (already
1438          * empty) state, leaving the callbacks of the to be cleared state
1439          * dangling, which causes wreckage on the next hotplug operation.
1440          */
1441         if (name && (state == CPUHP_AP_ONLINE_DYN ||
1442                      state == CPUHP_BP_PREPARE_DYN)) {
1443                 ret = cpuhp_reserve_state(state);
1444                 if (ret < 0)
1445                         return ret;
1446                 state = ret;
1447         }
1448         sp = cpuhp_get_step(state);
1449         if (name && sp->name)
1450                 return -EBUSY;
1451
1452         sp->startup.single = startup;
1453         sp->teardown.single = teardown;
1454         sp->name = name;
1455         sp->multi_instance = multi_instance;
1456         INIT_HLIST_HEAD(&sp->list);
1457         return ret;
1458 }
1459
1460 static void *cpuhp_get_teardown_cb(enum cpuhp_state state)
1461 {
1462         return cpuhp_get_step(state)->teardown.single;
1463 }
1464
1465 /*
1466  * Call the startup/teardown function for a step either on the AP or
1467  * on the current CPU.
1468  */
1469 static int cpuhp_issue_call(int cpu, enum cpuhp_state state, bool bringup,
1470                             struct hlist_node *node)
1471 {
1472         struct cpuhp_step *sp = cpuhp_get_step(state);
1473         int ret;
1474
1475         /*
1476          * If there's nothing to do, we done.
1477          * Relies on the union for multi_instance.
1478          */
1479         if ((bringup && !sp->startup.single) ||
1480             (!bringup && !sp->teardown.single))
1481                 return 0;
1482         /*
1483          * The non AP bound callbacks can fail on bringup. On teardown
1484          * e.g. module removal we crash for now.
1485          */
1486 #ifdef CONFIG_SMP
1487         if (cpuhp_is_ap_state(state))
1488                 ret = cpuhp_invoke_ap_callback(cpu, state, bringup, node);
1489         else
1490                 ret = cpuhp_invoke_callback(cpu, state, bringup, node, NULL);
1491 #else
1492         ret = cpuhp_invoke_callback(cpu, state, bringup, node, NULL);
1493 #endif
1494         BUG_ON(ret && !bringup);
1495         return ret;
1496 }
1497
1498 /*
1499  * Called from __cpuhp_setup_state on a recoverable failure.
1500  *
1501  * Note: The teardown callbacks for rollback are not allowed to fail!
1502  */
1503 static void cpuhp_rollback_install(int failedcpu, enum cpuhp_state state,
1504                                    struct hlist_node *node)
1505 {
1506         int cpu;
1507
1508         /* Roll back the already executed steps on the other cpus */
1509         for_each_present_cpu(cpu) {
1510                 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1511                 int cpustate = st->state;
1512
1513                 if (cpu >= failedcpu)
1514                         break;
1515
1516                 /* Did we invoke the startup call on that cpu ? */
1517                 if (cpustate >= state)
1518                         cpuhp_issue_call(cpu, state, false, node);
1519         }
1520 }
1521
1522 int __cpuhp_state_add_instance_cpuslocked(enum cpuhp_state state,
1523                                           struct hlist_node *node,
1524                                           bool invoke)
1525 {
1526         struct cpuhp_step *sp;
1527         int cpu;
1528         int ret;
1529
1530         lockdep_assert_cpus_held();
1531
1532         sp = cpuhp_get_step(state);
1533         if (sp->multi_instance == false)
1534                 return -EINVAL;
1535
1536         mutex_lock(&cpuhp_state_mutex);
1537
1538         if (!invoke || !sp->startup.multi)
1539                 goto add_node;
1540
1541         /*
1542          * Try to call the startup callback for each present cpu
1543          * depending on the hotplug state of the cpu.
1544          */
1545         for_each_present_cpu(cpu) {
1546                 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1547                 int cpustate = st->state;
1548
1549                 if (cpustate < state)
1550                         continue;
1551
1552                 ret = cpuhp_issue_call(cpu, state, true, node);
1553                 if (ret) {
1554                         if (sp->teardown.multi)
1555                                 cpuhp_rollback_install(cpu, state, node);
1556                         goto unlock;
1557                 }
1558         }
1559 add_node:
1560         ret = 0;
1561         hlist_add_head(node, &sp->list);
1562 unlock:
1563         mutex_unlock(&cpuhp_state_mutex);
1564         return ret;
1565 }
1566
1567 int __cpuhp_state_add_instance(enum cpuhp_state state, struct hlist_node *node,
1568                                bool invoke)
1569 {
1570         int ret;
1571
1572         cpus_read_lock();
1573         ret = __cpuhp_state_add_instance_cpuslocked(state, node, invoke);
1574         cpus_read_unlock();
1575         return ret;
1576 }
1577 EXPORT_SYMBOL_GPL(__cpuhp_state_add_instance);
1578
1579 /**
1580  * __cpuhp_setup_state_cpuslocked - Setup the callbacks for an hotplug machine state
1581  * @state:              The state to setup
1582  * @invoke:             If true, the startup function is invoked for cpus where
1583  *                      cpu state >= @state
1584  * @startup:            startup callback function
1585  * @teardown:           teardown callback function
1586  * @multi_instance:     State is set up for multiple instances which get
1587  *                      added afterwards.
1588  *
1589  * The caller needs to hold cpus read locked while calling this function.
1590  * Returns:
1591  *   On success:
1592  *      Positive state number if @state is CPUHP_AP_ONLINE_DYN
1593  *      0 for all other states
1594  *   On failure: proper (negative) error code
1595  */
1596 int __cpuhp_setup_state_cpuslocked(enum cpuhp_state state,
1597                                    const char *name, bool invoke,
1598                                    int (*startup)(unsigned int cpu),
1599                                    int (*teardown)(unsigned int cpu),
1600                                    bool multi_instance)
1601 {
1602         int cpu, ret = 0;
1603         bool dynstate;
1604
1605         lockdep_assert_cpus_held();
1606
1607         if (cpuhp_cb_check(state) || !name)
1608                 return -EINVAL;
1609
1610         mutex_lock(&cpuhp_state_mutex);
1611
1612         ret = cpuhp_store_callbacks(state, name, startup, teardown,
1613                                     multi_instance);
1614
1615         dynstate = state == CPUHP_AP_ONLINE_DYN;
1616         if (ret > 0 && dynstate) {
1617                 state = ret;
1618                 ret = 0;
1619         }
1620
1621         if (ret || !invoke || !startup)
1622                 goto out;
1623
1624         /*
1625          * Try to call the startup callback for each present cpu
1626          * depending on the hotplug state of the cpu.
1627          */
1628         for_each_present_cpu(cpu) {
1629                 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1630                 int cpustate = st->state;
1631
1632                 if (cpustate < state)
1633                         continue;
1634
1635                 ret = cpuhp_issue_call(cpu, state, true, NULL);
1636                 if (ret) {
1637                         if (teardown)
1638                                 cpuhp_rollback_install(cpu, state, NULL);
1639                         cpuhp_store_callbacks(state, NULL, NULL, NULL, false);
1640                         goto out;
1641                 }
1642         }
1643 out:
1644         mutex_unlock(&cpuhp_state_mutex);
1645         /*
1646          * If the requested state is CPUHP_AP_ONLINE_DYN, return the
1647          * dynamically allocated state in case of success.
1648          */
1649         if (!ret && dynstate)
1650                 return state;
1651         return ret;
1652 }
1653 EXPORT_SYMBOL(__cpuhp_setup_state_cpuslocked);
1654
1655 int __cpuhp_setup_state(enum cpuhp_state state,
1656                         const char *name, bool invoke,
1657                         int (*startup)(unsigned int cpu),
1658                         int (*teardown)(unsigned int cpu),
1659                         bool multi_instance)
1660 {
1661         int ret;
1662
1663         cpus_read_lock();
1664         ret = __cpuhp_setup_state_cpuslocked(state, name, invoke, startup,
1665                                              teardown, multi_instance);
1666         cpus_read_unlock();
1667         return ret;
1668 }
1669 EXPORT_SYMBOL(__cpuhp_setup_state);
1670
1671 int __cpuhp_state_remove_instance(enum cpuhp_state state,
1672                                   struct hlist_node *node, bool invoke)
1673 {
1674         struct cpuhp_step *sp = cpuhp_get_step(state);
1675         int cpu;
1676
1677         BUG_ON(cpuhp_cb_check(state));
1678
1679         if (!sp->multi_instance)
1680                 return -EINVAL;
1681
1682         cpus_read_lock();
1683         mutex_lock(&cpuhp_state_mutex);
1684
1685         if (!invoke || !cpuhp_get_teardown_cb(state))
1686                 goto remove;
1687         /*
1688          * Call the teardown callback for each present cpu depending
1689          * on the hotplug state of the cpu. This function is not
1690          * allowed to fail currently!
1691          */
1692         for_each_present_cpu(cpu) {
1693                 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1694                 int cpustate = st->state;
1695
1696                 if (cpustate >= state)
1697                         cpuhp_issue_call(cpu, state, false, node);
1698         }
1699
1700 remove:
1701         hlist_del(node);
1702         mutex_unlock(&cpuhp_state_mutex);
1703         cpus_read_unlock();
1704
1705         return 0;
1706 }
1707 EXPORT_SYMBOL_GPL(__cpuhp_state_remove_instance);
1708
1709 /**
1710  * __cpuhp_remove_state_cpuslocked - Remove the callbacks for an hotplug machine state
1711  * @state:      The state to remove
1712  * @invoke:     If true, the teardown function is invoked for cpus where
1713  *              cpu state >= @state
1714  *
1715  * The caller needs to hold cpus read locked while calling this function.
1716  * The teardown callback is currently not allowed to fail. Think
1717  * about module removal!
1718  */
1719 void __cpuhp_remove_state_cpuslocked(enum cpuhp_state state, bool invoke)
1720 {
1721         struct cpuhp_step *sp = cpuhp_get_step(state);
1722         int cpu;
1723
1724         BUG_ON(cpuhp_cb_check(state));
1725
1726         lockdep_assert_cpus_held();
1727
1728         mutex_lock(&cpuhp_state_mutex);
1729         if (sp->multi_instance) {
1730                 WARN(!hlist_empty(&sp->list),
1731                      "Error: Removing state %d which has instances left.\n",
1732                      state);
1733                 goto remove;
1734         }
1735
1736         if (!invoke || !cpuhp_get_teardown_cb(state))
1737                 goto remove;
1738
1739         /*
1740          * Call the teardown callback for each present cpu depending
1741          * on the hotplug state of the cpu. This function is not
1742          * allowed to fail currently!
1743          */
1744         for_each_present_cpu(cpu) {
1745                 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1746                 int cpustate = st->state;
1747
1748                 if (cpustate >= state)
1749                         cpuhp_issue_call(cpu, state, false, NULL);
1750         }
1751 remove:
1752         cpuhp_store_callbacks(state, NULL, NULL, NULL, false);
1753         mutex_unlock(&cpuhp_state_mutex);
1754 }
1755 EXPORT_SYMBOL(__cpuhp_remove_state_cpuslocked);
1756
1757 void __cpuhp_remove_state(enum cpuhp_state state, bool invoke)
1758 {
1759         cpus_read_lock();
1760         __cpuhp_remove_state_cpuslocked(state, invoke);
1761         cpus_read_unlock();
1762 }
1763 EXPORT_SYMBOL(__cpuhp_remove_state);
1764
1765 #if defined(CONFIG_SYSFS) && defined(CONFIG_HOTPLUG_CPU)
1766 static ssize_t show_cpuhp_state(struct device *dev,
1767                                 struct device_attribute *attr, char *buf)
1768 {
1769         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
1770
1771         return sprintf(buf, "%d\n", st->state);
1772 }
1773 static DEVICE_ATTR(state, 0444, show_cpuhp_state, NULL);
1774
1775 static ssize_t write_cpuhp_target(struct device *dev,
1776                                   struct device_attribute *attr,
1777                                   const char *buf, size_t count)
1778 {
1779         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
1780         struct cpuhp_step *sp;
1781         int target, ret;
1782
1783         ret = kstrtoint(buf, 10, &target);
1784         if (ret)
1785                 return ret;
1786
1787 #ifdef CONFIG_CPU_HOTPLUG_STATE_CONTROL
1788         if (target < CPUHP_OFFLINE || target > CPUHP_ONLINE)
1789                 return -EINVAL;
1790 #else
1791         if (target != CPUHP_OFFLINE && target != CPUHP_ONLINE)
1792                 return -EINVAL;
1793 #endif
1794
1795         ret = lock_device_hotplug_sysfs();
1796         if (ret)
1797                 return ret;
1798
1799         mutex_lock(&cpuhp_state_mutex);
1800         sp = cpuhp_get_step(target);
1801         ret = !sp->name || sp->cant_stop ? -EINVAL : 0;
1802         mutex_unlock(&cpuhp_state_mutex);
1803         if (ret)
1804                 goto out;
1805
1806         if (st->state < target)
1807                 ret = do_cpu_up(dev->id, target);
1808         else
1809                 ret = do_cpu_down(dev->id, target);
1810 out:
1811         unlock_device_hotplug();
1812         return ret ? ret : count;
1813 }
1814
1815 static ssize_t show_cpuhp_target(struct device *dev,
1816                                  struct device_attribute *attr, char *buf)
1817 {
1818         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
1819
1820         return sprintf(buf, "%d\n", st->target);
1821 }
1822 static DEVICE_ATTR(target, 0644, show_cpuhp_target, write_cpuhp_target);
1823
1824
1825 static ssize_t write_cpuhp_fail(struct device *dev,
1826                                 struct device_attribute *attr,
1827                                 const char *buf, size_t count)
1828 {
1829         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
1830         struct cpuhp_step *sp;
1831         int fail, ret;
1832
1833         ret = kstrtoint(buf, 10, &fail);
1834         if (ret)
1835                 return ret;
1836
1837         /*
1838          * Cannot fail STARTING/DYING callbacks.
1839          */
1840         if (cpuhp_is_atomic_state(fail))
1841                 return -EINVAL;
1842
1843         /*
1844          * Cannot fail anything that doesn't have callbacks.
1845          */
1846         mutex_lock(&cpuhp_state_mutex);
1847         sp = cpuhp_get_step(fail);
1848         if (!sp->startup.single && !sp->teardown.single)
1849                 ret = -EINVAL;
1850         mutex_unlock(&cpuhp_state_mutex);
1851         if (ret)
1852                 return ret;
1853
1854         st->fail = fail;
1855
1856         return count;
1857 }
1858
1859 static ssize_t show_cpuhp_fail(struct device *dev,
1860                                struct device_attribute *attr, char *buf)
1861 {
1862         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
1863
1864         return sprintf(buf, "%d\n", st->fail);
1865 }
1866
1867 static DEVICE_ATTR(fail, 0644, show_cpuhp_fail, write_cpuhp_fail);
1868
1869 static struct attribute *cpuhp_cpu_attrs[] = {
1870         &dev_attr_state.attr,
1871         &dev_attr_target.attr,
1872         &dev_attr_fail.attr,
1873         NULL
1874 };
1875
1876 static const struct attribute_group cpuhp_cpu_attr_group = {
1877         .attrs = cpuhp_cpu_attrs,
1878         .name = "hotplug",
1879         NULL
1880 };
1881
1882 static ssize_t show_cpuhp_states(struct device *dev,
1883                                  struct device_attribute *attr, char *buf)
1884 {
1885         ssize_t cur, res = 0;
1886         int i;
1887
1888         mutex_lock(&cpuhp_state_mutex);
1889         for (i = CPUHP_OFFLINE; i <= CPUHP_ONLINE; i++) {
1890                 struct cpuhp_step *sp = cpuhp_get_step(i);
1891
1892                 if (sp->name) {
1893                         cur = sprintf(buf, "%3d: %s\n", i, sp->name);
1894                         buf += cur;
1895                         res += cur;
1896                 }
1897         }
1898         mutex_unlock(&cpuhp_state_mutex);
1899         return res;
1900 }
1901 static DEVICE_ATTR(states, 0444, show_cpuhp_states, NULL);
1902
1903 static struct attribute *cpuhp_cpu_root_attrs[] = {
1904         &dev_attr_states.attr,
1905         NULL
1906 };
1907
1908 static const struct attribute_group cpuhp_cpu_root_attr_group = {
1909         .attrs = cpuhp_cpu_root_attrs,
1910         .name = "hotplug",
1911         NULL
1912 };
1913
1914 static int __init cpuhp_sysfs_init(void)
1915 {
1916         int cpu, ret;
1917
1918         ret = sysfs_create_group(&cpu_subsys.dev_root->kobj,
1919                                  &cpuhp_cpu_root_attr_group);
1920         if (ret)
1921                 return ret;
1922
1923         for_each_possible_cpu(cpu) {
1924                 struct device *dev = get_cpu_device(cpu);
1925
1926                 if (!dev)
1927                         continue;
1928                 ret = sysfs_create_group(&dev->kobj, &cpuhp_cpu_attr_group);
1929                 if (ret)
1930                         return ret;
1931         }
1932         return 0;
1933 }
1934 device_initcall(cpuhp_sysfs_init);
1935 #endif
1936
1937 /*
1938  * cpu_bit_bitmap[] is a special, "compressed" data structure that
1939  * represents all NR_CPUS bits binary values of 1<<nr.
1940  *
1941  * It is used by cpumask_of() to get a constant address to a CPU
1942  * mask value that has a single bit set only.
1943  */
1944
1945 /* cpu_bit_bitmap[0] is empty - so we can back into it */
1946 #define MASK_DECLARE_1(x)       [x+1][0] = (1UL << (x))
1947 #define MASK_DECLARE_2(x)       MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
1948 #define MASK_DECLARE_4(x)       MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
1949 #define MASK_DECLARE_8(x)       MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
1950
1951 const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
1952
1953         MASK_DECLARE_8(0),      MASK_DECLARE_8(8),
1954         MASK_DECLARE_8(16),     MASK_DECLARE_8(24),
1955 #if BITS_PER_LONG > 32
1956         MASK_DECLARE_8(32),     MASK_DECLARE_8(40),
1957         MASK_DECLARE_8(48),     MASK_DECLARE_8(56),
1958 #endif
1959 };
1960 EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
1961
1962 const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
1963 EXPORT_SYMBOL(cpu_all_bits);
1964
1965 #ifdef CONFIG_INIT_ALL_POSSIBLE
1966 struct cpumask __cpu_possible_mask __read_mostly
1967         = {CPU_BITS_ALL};
1968 #else
1969 struct cpumask __cpu_possible_mask __read_mostly;
1970 #endif
1971 EXPORT_SYMBOL(__cpu_possible_mask);
1972
1973 struct cpumask __cpu_online_mask __read_mostly;
1974 EXPORT_SYMBOL(__cpu_online_mask);
1975
1976 struct cpumask __cpu_present_mask __read_mostly;
1977 EXPORT_SYMBOL(__cpu_present_mask);
1978
1979 struct cpumask __cpu_active_mask __read_mostly;
1980 EXPORT_SYMBOL(__cpu_active_mask);
1981
1982 void init_cpu_present(const struct cpumask *src)
1983 {
1984         cpumask_copy(&__cpu_present_mask, src);
1985 }
1986
1987 void init_cpu_possible(const struct cpumask *src)
1988 {
1989         cpumask_copy(&__cpu_possible_mask, src);
1990 }
1991
1992 void init_cpu_online(const struct cpumask *src)
1993 {
1994         cpumask_copy(&__cpu_online_mask, src);
1995 }
1996
1997 /*
1998  * Activate the first processor.
1999  */
2000 void __init boot_cpu_init(void)
2001 {
2002         int cpu = smp_processor_id();
2003
2004         /* Mark the boot cpu "present", "online" etc for SMP and UP case */
2005         set_cpu_online(cpu, true);
2006         set_cpu_active(cpu, true);
2007         set_cpu_present(cpu, true);
2008         set_cpu_possible(cpu, true);
2009
2010 #ifdef CONFIG_SMP
2011         __boot_cpu_id = cpu;
2012 #endif
2013 }
2014
2015 /*
2016  * Must be called _AFTER_ setting up the per_cpu areas
2017  */
2018 void __init boot_cpu_hotplug_init(void)
2019 {
2020         per_cpu_ptr(&cpuhp_state, smp_processor_id())->state = CPUHP_ONLINE;
2021 }