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 }