kernel/stop_machine.c

   1 /*
   2  * kernel/stop_machine.c
   3  *
   4  * Copyright (C) 2008, 2005     IBM Corporation.
   5  * Copyright (C) 2008, 2005     Rusty Russell rusty@rustcorp.com.au
   6  * Copyright (C) 2010           SUSE Linux Products GmbH
   7  * Copyright (C) 2010           Tejun Heo <tj@kernel.org>
   8  *
   9  * This file is released under the GPLv2 and any later version.
  10  */
  11 #include <linux/completion.h>
  12 #include <linux/cpu.h>
  13 #include <linux/init.h>
  14 #include <linux/kthread.h>
  15 #include <linux/export.h>
  16 #include <linux/percpu.h>
  17 #include <linux/sched.h>
  18 #include <linux/stop_machine.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/kallsyms.h>
  21 #include <linux/smpboot.h>
  22 #include <linux/atomic.h>
  23 #include <linux/lglock.h>
  24
  25 /*
  26  * Structure to determine completion condition and record errors.  May
  27  * be shared by works on different cpus.
  28  */
  29 struct cpu_stop_done {
  30         atomic_t                nr_todo;        /* nr left to execute */
  31         int                     ret;            /* collected return value */
  32         struct completion       completion;     /* fired if nr_todo reaches 0 */
  33 };
  34
  35 /* the actual stopper, one per every possible cpu, enabled on online cpus */
  36 struct cpu_stopper {
  37         struct task_struct      *thread;
  38
  39         spinlock_t              lock;
  40         bool                    enabled;        /* is this stopper enabled? */
  41         struct list_head        works;          /* list of pending works */
  42
  43         struct cpu_stop_work    stop_work;      /* for stop_cpus */
  44 };
  45
  46 static DEFINE_PER_CPU(struct cpu_stopper, cpu_stopper);
  47 static bool stop_machine_initialized = false;
  48
  49 /*
  50  * Avoids a race between stop_two_cpus and global stop_cpus, where
  51  * the stoppers could get queued up in reverse order, leading to
  52  * system deadlock. Using an lglock means stop_two_cpus remains
  53  * relatively cheap.
  54  */
  55 DEFINE_STATIC_LGLOCK(stop_cpus_lock);
  56
  57 static void cpu_stop_init_done(struct cpu_stop_done *done, unsigned int nr_todo)
  58 {
  59         memset(done, 0, sizeof(*done));
  60         atomic_set(&done->nr_todo, nr_todo);
  61         init_completion(&done->completion);
  62 }
  63
  64 /* signal completion unless @done is NULL */
  65 static void cpu_stop_signal_done(struct cpu_stop_done *done)
  66 {
  67         if (done) {
  68                 if (atomic_dec_and_test(&done->nr_todo))
  69                         complete(&done->completion);
  70         }
  71 }
  72
  73 static void __cpu_stop_queue_work(struct cpu_stopper *stopper,
  74                                         struct cpu_stop_work *work)
  75 {
  76         list_add_tail(&work->list, &stopper->works);
  77         wake_up_process(stopper->thread);
  78 }
  79
  80 /* queue @work to @stopper.  if offline, @work is completed immediately */
  81 static bool cpu_stop_queue_work(unsigned int cpu, struct cpu_stop_work *work)
  82 {
  83         struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
  84         unsigned long flags;
  85         bool enabled;
  86
  87         spin_lock_irqsave(&stopper->lock, flags);
  88         enabled = stopper->enabled;
  89         if (enabled)
  90                 __cpu_stop_queue_work(stopper, work);
  91         else
  92                 cpu_stop_signal_done(work->done);
  93         spin_unlock_irqrestore(&stopper->lock, flags);
  94
  95         return enabled;
  96 }
  97
  98 /**
  99  * stop_one_cpu - stop a cpu
 100  * @cpu: cpu to stop
 101  * @fn: function to execute
 102  * @arg: argument to @fn
 103  *
 104  * Execute @fn(@arg) on @cpu.  @fn is run in a process context with
 105  * the highest priority preempting any task on the cpu and
 106  * monopolizing it.  This function returns after the execution is
 107  * complete.
 108  *
 109  * This function doesn't guarantee @cpu stays online till @fn
 110  * completes.  If @cpu goes down in the middle, execution may happen
 111  * partially or fully on different cpus.  @fn should either be ready
 112  * for that or the caller should ensure that @cpu stays online until
 113  * this function completes.
 114  *
 115  * CONTEXT:
 116  * Might sleep.
 117  *
 118  * RETURNS:
 119  * -ENOENT if @fn(@arg) was not executed because @cpu was offline;
 120  * otherwise, the return value of @fn.
 121  */
 122 int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg)
 123 {
 124         struct cpu_stop_done done;
 125         struct cpu_stop_work work = { .fn = fn, .arg = arg, .done = &done };
 126
 127         cpu_stop_init_done(&done, 1);
 128         if (!cpu_stop_queue_work(cpu, &work))
 129                 return -ENOENT;
 130         wait_for_completion(&done.completion);
 131         return done.ret;
 132 }
 133
 134 /* This controls the threads on each CPU. */
 135 enum multi_stop_state {
 136         /* Dummy starting state for thread. */
 137         MULTI_STOP_NONE,
 138         /* Awaiting everyone to be scheduled. */
 139         MULTI_STOP_PREPARE,
 140         /* Disable interrupts. */
 141         MULTI_STOP_DISABLE_IRQ,
 142         /* Run the function */
 143         MULTI_STOP_RUN,
 144         /* Exit */
 145         MULTI_STOP_EXIT,
 146 };
 147
 148 struct multi_stop_data {
 149         cpu_stop_fn_t           fn;
 150         void                    *data;
 151         /* Like num_online_cpus(), but hotplug cpu uses us, so we need this. */
 152         unsigned int            num_threads;
 153         const struct cpumask    *active_cpus;
 154
 155         enum multi_stop_state   state;
 156         atomic_t                thread_ack;
 157 };
 158
 159 static void set_state(struct multi_stop_data *msdata,
 160                       enum multi_stop_state newstate)
 161 {
 162         /* Reset ack counter. */
 163         atomic_set(&msdata->thread_ack, msdata->num_threads);
 164         smp_wmb();
 165         msdata->state = newstate;
 166 }
 167
 168 /* Last one to ack a state moves to the next state. */
 169 static void ack_state(struct multi_stop_data *msdata)
 170 {
 171         if (atomic_dec_and_test(&msdata->thread_ack))
 172                 set_state(msdata, msdata->state + 1);
 173 }
 174
 175 /* This is the cpu_stop function which stops the CPU. */
 176 static int multi_cpu_stop(void *data)
 177 {
 178         struct multi_stop_data *msdata = data;
 179         enum multi_stop_state curstate = MULTI_STOP_NONE;
 180         int cpu = smp_processor_id(), err = 0;
 181         unsigned long flags;
 182         bool is_active;
 183
 184         /*
 185          * When called from stop_machine_from_inactive_cpu(), irq might
 186          * already be disabled.  Save the state and restore it on exit.
 187          */
 188         local_save_flags(flags);
 189
 190         if (!msdata->active_cpus)
 191                 is_active = cpu == cpumask_first(cpu_online_mask);
 192         else
 193                 is_active = cpumask_test_cpu(cpu, msdata->active_cpus);
 194
 195         /* Simple state machine */
 196         do {
 197                 /* Chill out and ensure we re-read multi_stop_state. */
 198                 cpu_relax();
 199                 if (msdata->state != curstate) {
 200                         curstate = msdata->state;
 201                         switch (curstate) {
 202                         case MULTI_STOP_DISABLE_IRQ:
 203                                 local_irq_disable();
 204                                 hard_irq_disable();
 205                                 break;
 206                         case MULTI_STOP_RUN:
 207                                 if (is_active)
 208                                         err = msdata->fn(msdata->data);
 209                                 break;
 210                         default:
 211                                 break;
 212                         }
 213                         ack_state(msdata);
 214                 }
 215         } while (curstate != MULTI_STOP_EXIT);
 216
 217         local_irq_restore(flags);
 218         return err;
 219 }
 220
 221 static int cpu_stop_queue_two_works(int cpu1, struct cpu_stop_work *work1,
 222                                     int cpu2, struct cpu_stop_work *work2)
 223 {
 224         struct cpu_stopper *stopper1 = per_cpu_ptr(&cpu_stopper, cpu1);
 225         struct cpu_stopper *stopper2 = per_cpu_ptr(&cpu_stopper, cpu2);
 226         int err;
 227
 228         lg_double_lock(&stop_cpus_lock, cpu1, cpu2);
 229         spin_lock_irq(&stopper1->lock);
 230         spin_lock_nested(&stopper2->lock, SINGLE_DEPTH_NESTING);
 231
 232         err = -ENOENT;
 233         if (!stopper1->enabled || !stopper2->enabled)
 234                 goto unlock;
 235
 236         err = 0;
 237         __cpu_stop_queue_work(stopper1, work1);
 238         __cpu_stop_queue_work(stopper2, work2);
 239 unlock:
 240         spin_unlock(&stopper2->lock);
 241         spin_unlock_irq(&stopper1->lock);
 242         lg_double_unlock(&stop_cpus_lock, cpu1, cpu2);
 243
 244         return err;
 245 }
 246 /**
 247  * stop_two_cpus - stops two cpus
 248  * @cpu1: the cpu to stop
 249  * @cpu2: the other cpu to stop
 250  * @fn: function to execute
 251  * @arg: argument to @fn
 252  *
 253  * Stops both the current and specified CPU and runs @fn on one of them.
 254  *
 255  * returns when both are completed.
 256  */
 257 int stop_two_cpus(unsigned int cpu1, unsigned int cpu2, cpu_stop_fn_t fn, void *arg)
 258 {
 259         struct cpu_stop_done done;
 260         struct cpu_stop_work work1, work2;
 261         struct multi_stop_data msdata;
 262
 263         msdata = (struct multi_stop_data){
 264                 .fn = fn,
 265                 .data = arg,
 266                 .num_threads = 2,
 267                 .active_cpus = cpumask_of(cpu1),
 268         };
 269
 270         work1 = work2 = (struct cpu_stop_work){
 271                 .fn = multi_cpu_stop,
 272                 .arg = &msdata,
 273                 .done = &done
 274         };
 275
 276         cpu_stop_init_done(&done, 2);
 277         set_state(&msdata, MULTI_STOP_PREPARE);
 278
 279         if (cpu1 > cpu2)
 280                 swap(cpu1, cpu2);
 281         if (cpu_stop_queue_two_works(cpu1, &work1, cpu2, &work2))
 282                 return -ENOENT;
 283
 284         wait_for_completion(&done.completion);
 285         return done.ret;
 286 }
 287
 288 /**
 289  * stop_one_cpu_nowait - stop a cpu but don't wait for completion
 290  * @cpu: cpu to stop
 291  * @fn: function to execute
 292  * @arg: argument to @fn
 293  * @work_buf: pointer to cpu_stop_work structure
 294  *
 295  * Similar to stop_one_cpu() but doesn't wait for completion.  The
 296  * caller is responsible for ensuring @work_buf is currently unused
 297  * and will remain untouched until stopper starts executing @fn.
 298  *
 299  * CONTEXT:
 300  * Don't care.
 301  *
 302  * RETURNS:
 303  * true if cpu_stop_work was queued successfully and @fn will be called,
 304  * false otherwise.
 305  */
 306 bool stop_one_cpu_nowait(unsigned int cpu, cpu_stop_fn_t fn, void *arg,
 307                         struct cpu_stop_work *work_buf)
 308 {
 309         *work_buf = (struct cpu_stop_work){ .fn = fn, .arg = arg, };
 310         return cpu_stop_queue_work(cpu, work_buf);
 311 }
 312
 313 /* static data for stop_cpus */
 314 static DEFINE_MUTEX(stop_cpus_mutex);
 315
 316 static bool queue_stop_cpus_work(const struct cpumask *cpumask,
 317                                  cpu_stop_fn_t fn, void *arg,
 318                                  struct cpu_stop_done *done)
 319 {
 320         struct cpu_stop_work *work;
 321         unsigned int cpu;
 322         bool queued = false;
 323
 324         /*
 325          * Disable preemption while queueing to avoid getting
 326          * preempted by a stopper which might wait for other stoppers
 327          * to enter @fn which can lead to deadlock.
 328          */
 329         lg_global_lock(&stop_cpus_lock);
 330         for_each_cpu(cpu, cpumask) {
 331                 work = &per_cpu(cpu_stopper.stop_work, cpu);
 332                 work->fn = fn;
 333                 work->arg = arg;
 334                 work->done = done;
 335                 if (cpu_stop_queue_work(cpu, work))
 336                         queued = true;
 337         }
 338         lg_global_unlock(&stop_cpus_lock);
 339
 340         return queued;
 341 }
 342
 343 static int __stop_cpus(const struct cpumask *cpumask,
 344                        cpu_stop_fn_t fn, void *arg)
 345 {
 346         struct cpu_stop_done done;
 347
 348         cpu_stop_init_done(&done, cpumask_weight(cpumask));
 349         if (!queue_stop_cpus_work(cpumask, fn, arg, &done))
 350                 return -ENOENT;
 351         wait_for_completion(&done.completion);
 352         return done.ret;
 353 }
 354
 355 /**
 356  * stop_cpus - stop multiple cpus
 357  * @cpumask: cpus to stop
 358  * @fn: function to execute
 359  * @arg: argument to @fn
 360  *
 361  * Execute @fn(@arg) on online cpus in @cpumask.  On each target cpu,
 362  * @fn is run in a process context with the highest priority
 363  * preempting any task on the cpu and monopolizing it.  This function
 364  * returns after all executions are complete.
 365  *
 366  * This function doesn't guarantee the cpus in @cpumask stay online
 367  * till @fn completes.  If some cpus go down in the middle, execution
 368  * on the cpu may happen partially or fully on different cpus.  @fn
 369  * should either be ready for that or the caller should ensure that
 370  * the cpus stay online until this function completes.
 371  *
 372  * All stop_cpus() calls are serialized making it safe for @fn to wait
 373  * for all cpus to start executing it.
 374  *
 375  * CONTEXT:
 376  * Might sleep.
 377  *
 378  * RETURNS:
 379  * -ENOENT if @fn(@arg) was not executed at all because all cpus in
 380  * @cpumask were offline; otherwise, 0 if all executions of @fn
 381  * returned 0, any non zero return value if any returned non zero.
 382  */
 383 int stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg)
 384 {
 385         int ret;
 386
 387         /* static works are used, process one request at a time */
 388         mutex_lock(&stop_cpus_mutex);
 389         ret = __stop_cpus(cpumask, fn, arg);
 390         mutex_unlock(&stop_cpus_mutex);
 391         return ret;
 392 }
 393
 394 /**
 395  * try_stop_cpus - try to stop multiple cpus
 396  * @cpumask: cpus to stop
 397  * @fn: function to execute
 398  * @arg: argument to @fn
 399  *
 400  * Identical to stop_cpus() except that it fails with -EAGAIN if
 401  * someone else is already using the facility.
 402  *
 403  * CONTEXT:
 404  * Might sleep.
 405  *
 406  * RETURNS:
 407  * -EAGAIN if someone else is already stopping cpus, -ENOENT if
 408  * @fn(@arg) was not executed at all because all cpus in @cpumask were
 409  * offline; otherwise, 0 if all executions of @fn returned 0, any non
 410  * zero return value if any returned non zero.
 411  */
 412 int try_stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg)
 413 {
 414         int ret;
 415
 416         /* static works are used, process one request at a time */
 417         if (!mutex_trylock(&stop_cpus_mutex))
 418                 return -EAGAIN;
 419         ret = __stop_cpus(cpumask, fn, arg);
 420         mutex_unlock(&stop_cpus_mutex);
 421         return ret;
 422 }
 423
 424 static int cpu_stop_should_run(unsigned int cpu)
 425 {
 426         struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
 427         unsigned long flags;
 428         int run;
 429
 430         spin_lock_irqsave(&stopper->lock, flags);
 431         run = !list_empty(&stopper->works);
 432         spin_unlock_irqrestore(&stopper->lock, flags);
 433         return run;
 434 }
 435
 436 static void cpu_stopper_thread(unsigned int cpu)
 437 {
 438         struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
 439         struct cpu_stop_work *work;
 440         int ret;
 441
 442 repeat:
 443         work = NULL;
 444         spin_lock_irq(&stopper->lock);
 445         if (!list_empty(&stopper->works)) {
 446                 work = list_first_entry(&stopper->works,
 447                                         struct cpu_stop_work, list);
 448                 list_del_init(&work->list);
 449         }
 450         spin_unlock_irq(&stopper->lock);
 451
 452         if (work) {
 453                 cpu_stop_fn_t fn = work->fn;
 454                 void *arg = work->arg;
 455                 struct cpu_stop_done *done = work->done;
 456                 char ksym_buf[KSYM_NAME_LEN] __maybe_unused;
 457
 458                 /* cpu stop callbacks are not allowed to sleep */
 459                 preempt_disable();
 460
 461                 ret = fn(arg);
 462                 if (ret && done)
 463                         done->ret = ret;
 464                 cpu_stop_signal_done(done);
 465
 466                 /* restore preemption and check it's still balanced */
 467                 preempt_enable();
 468                 WARN_ONCE(preempt_count(),
 469                           "cpu_stop: %s(%p) leaked preempt count\n",
 470                           kallsyms_lookup((unsigned long)fn, NULL, NULL, NULL,
 471                                           ksym_buf), arg);
 472
 473                 goto repeat;
 474         }
 475 }
 476
 477 void stop_machine_park(int cpu)
 478 {
 479         struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
 480         /*
 481          * Lockless. cpu_stopper_thread() will take stopper->lock and flush
 482          * the pending works before it parks, until then it is fine to queue
 483          * the new works.
 484          */
 485         stopper->enabled = false;
 486         kthread_park(stopper->thread);
 487 }
 488
 489 extern void sched_set_stop_task(int cpu, struct task_struct *stop);
 490
 491 static void cpu_stop_create(unsigned int cpu)
 492 {
 493         sched_set_stop_task(cpu, per_cpu(cpu_stopper.thread, cpu));
 494 }
 495
 496 static void cpu_stop_park(unsigned int cpu)
 497 {
 498         struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
 499
 500         WARN_ON(!list_empty(&stopper->works));
 501 }
 502
 503 void stop_machine_unpark(int cpu)
 504 {
 505         struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
 506
 507         stopper->enabled = true;
 508         kthread_unpark(stopper->thread);
 509 }
 510
 511 static struct smp_hotplug_thread cpu_stop_threads = {
 512         .store                  = &cpu_stopper.thread,
 513         .thread_should_run      = cpu_stop_should_run,
 514         .thread_fn              = cpu_stopper_thread,
 515         .thread_comm            = "migration/%u",
 516         .create                 = cpu_stop_create,
 517         .park                   = cpu_stop_park,
 518         .selfparking            = true,
 519 };
 520
 521 static int __init cpu_stop_init(void)
 522 {
 523         unsigned int cpu;
 524
 525         for_each_possible_cpu(cpu) {
 526                 struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
 527
 528                 spin_lock_init(&stopper->lock);
 529                 INIT_LIST_HEAD(&stopper->works);
 530         }
 531
 532         BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads));
 533         stop_machine_unpark(raw_smp_processor_id());
 534         stop_machine_initialized = true;
 535         return 0;
 536 }
 537 early_initcall(cpu_stop_init);
 538
 539 #ifdef CONFIG_STOP_MACHINE
 540
 541 static int __stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus)
 542 {
 543         struct multi_stop_data msdata = {
 544                 .fn = fn,
 545                 .data = data,
 546                 .num_threads = num_online_cpus(),
 547                 .active_cpus = cpus,
 548         };
 549
 550         if (!stop_machine_initialized) {
 551                 /*
 552                  * Handle the case where stop_machine() is called
 553                  * early in boot before stop_machine() has been
 554                  * initialized.
 555                  */
 556                 unsigned long flags;
 557                 int ret;
 558
 559                 WARN_ON_ONCE(msdata.num_threads != 1);
 560
 561                 local_irq_save(flags);
 562                 hard_irq_disable();
 563                 ret = (*fn)(data);
 564                 local_irq_restore(flags);
 565
 566                 return ret;
 567         }
 568
 569         /* Set the initial state and stop all online cpus. */
 570         set_state(&msdata, MULTI_STOP_PREPARE);
 571         return stop_cpus(cpu_online_mask, multi_cpu_stop, &msdata);
 572 }
 573
 574 int stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus)
 575 {
 576         int ret;
 577
 578         /* No CPUs can come up or down during this. */
 579         get_online_cpus();
 580         ret = __stop_machine(fn, data, cpus);
 581         put_online_cpus();
 582         return ret;
 583 }
 584 EXPORT_SYMBOL_GPL(stop_machine);
 585
 586 /**
 587  * stop_machine_from_inactive_cpu - stop_machine() from inactive CPU
 588  * @fn: the function to run
 589  * @data: the data ptr for the @fn()
 590  * @cpus: the cpus to run the @fn() on (NULL = any online cpu)
 591  *
 592  * This is identical to stop_machine() but can be called from a CPU which
 593  * is not active.  The local CPU is in the process of hotplug (so no other
 594  * CPU hotplug can start) and not marked active and doesn't have enough
 595  * context to sleep.
 596  *
 597  * This function provides stop_machine() functionality for such state by
 598  * using busy-wait for synchronization and executing @fn directly for local
 599  * CPU.
 600  *
 601  * CONTEXT:
 602  * Local CPU is inactive.  Temporarily stops all active CPUs.
 603  *
 604  * RETURNS:
 605  * 0 if all executions of @fn returned 0, any non zero return value if any
 606  * returned non zero.
 607  */
 608 int stop_machine_from_inactive_cpu(cpu_stop_fn_t fn, void *data,
 609                                   const struct cpumask *cpus)
 610 {
 611         struct multi_stop_data msdata = { .fn = fn, .data = data,
 612                                             .active_cpus = cpus };
 613         struct cpu_stop_done done;
 614         int ret;
 615
 616         /* Local CPU must be inactive and CPU hotplug in progress. */
 617         BUG_ON(cpu_active(raw_smp_processor_id()));
 618         msdata.num_threads = num_active_cpus() + 1;     /* +1 for local */
 619
 620         /* No proper task established and can't sleep - busy wait for lock. */
 621         while (!mutex_trylock(&stop_cpus_mutex))
 622                 cpu_relax();
 623
 624         /* Schedule work on other CPUs and execute directly for local CPU */
 625         set_state(&msdata, MULTI_STOP_PREPARE);
 626         cpu_stop_init_done(&done, num_active_cpus());
 627         queue_stop_cpus_work(cpu_active_mask, multi_cpu_stop, &msdata,
 628                              &done);
 629         ret = multi_cpu_stop(&msdata);
 630
 631         /* Busy wait for completion. */
 632         while (!completion_done(&done.completion))
 633                 cpu_relax();
 634
 635         mutex_unlock(&stop_cpus_mutex);
 636         return ret ?: done.ret;
 637 }
 638
 639 #endif  /* CONFIG_STOP_MACHINE */