kernel/smp.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Generic helpers for smp ipi calls
   4  *
   5  * (C) Jens Axboe <jens.axboe@oracle.com> 2008
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/irq_work.h>
  11 #include <linux/rcupdate.h>
  12 #include <linux/rculist.h>
  13 #include <linux/kernel.h>
  14 #include <linux/export.h>
  15 #include <linux/percpu.h>
  16 #include <linux/init.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/gfp.h>
  19 #include <linux/smp.h>
  20 #include <linux/cpu.h>
  21 #include <linux/sched.h>
  22 #include <linux/sched/idle.h>
  23 #include <linux/hypervisor.h>
  24 #include <linux/sched/clock.h>
  25 #include <linux/nmi.h>
  26 #include <linux/sched/debug.h>
  27 #include <linux/jump_label.h>
  28
  29 #include "smpboot.h"
  30 #include "sched/smp.h"
  31
  32 #define CSD_TYPE(_csd)  ((_csd)->node.u_flags & CSD_FLAG_TYPE_MASK)
  33
  34 struct cfd_percpu {
  35         call_single_data_t      csd;
  36 };
  37
  38 struct call_function_data {
  39         struct cfd_percpu       __percpu *pcpu;
  40         cpumask_var_t           cpumask;
  41         cpumask_var_t           cpumask_ipi;
  42 };
  43
  44 static DEFINE_PER_CPU_ALIGNED(struct call_function_data, cfd_data);
  45
  46 static DEFINE_PER_CPU_SHARED_ALIGNED(struct llist_head, call_single_queue);
  47
  48 static void __flush_smp_call_function_queue(bool warn_cpu_offline);
  49
  50 int smpcfd_prepare_cpu(unsigned int cpu)
  51 {
  52         struct call_function_data *cfd = &per_cpu(cfd_data, cpu);
  53
  54         if (!zalloc_cpumask_var_node(&cfd->cpumask, GFP_KERNEL,
  55                                      cpu_to_node(cpu)))
  56                 return -ENOMEM;
  57         if (!zalloc_cpumask_var_node(&cfd->cpumask_ipi, GFP_KERNEL,
  58                                      cpu_to_node(cpu))) {
  59                 free_cpumask_var(cfd->cpumask);
  60                 return -ENOMEM;
  61         }
  62         cfd->pcpu = alloc_percpu(struct cfd_percpu);
  63         if (!cfd->pcpu) {
  64                 free_cpumask_var(cfd->cpumask);
  65                 free_cpumask_var(cfd->cpumask_ipi);
  66                 return -ENOMEM;
  67         }
  68
  69         return 0;
  70 }
  71
  72 int smpcfd_dead_cpu(unsigned int cpu)
  73 {
  74         struct call_function_data *cfd = &per_cpu(cfd_data, cpu);
  75
  76         free_cpumask_var(cfd->cpumask);
  77         free_cpumask_var(cfd->cpumask_ipi);
  78         free_percpu(cfd->pcpu);
  79         return 0;
  80 }
  81
  82 int smpcfd_dying_cpu(unsigned int cpu)
  83 {
  84         /*
  85          * The IPIs for the smp-call-function callbacks queued by other
  86          * CPUs might arrive late, either due to hardware latencies or
  87          * because this CPU disabled interrupts (inside stop-machine)
  88          * before the IPIs were sent. So flush out any pending callbacks
  89          * explicitly (without waiting for the IPIs to arrive), to
  90          * ensure that the outgoing CPU doesn't go offline with work
  91          * still pending.
  92          */
  93         __flush_smp_call_function_queue(false);
  94         irq_work_run();
  95         return 0;
  96 }
  97
  98 void __init call_function_init(void)
  99 {
 100         int i;
 101
 102         for_each_possible_cpu(i)
 103                 init_llist_head(&per_cpu(call_single_queue, i));
 104
 105         smpcfd_prepare_cpu(smp_processor_id());
 106 }
 107
 108 #ifdef CONFIG_CSD_LOCK_WAIT_DEBUG
 109
 110 static DEFINE_STATIC_KEY_MAYBE(CONFIG_CSD_LOCK_WAIT_DEBUG_DEFAULT, csdlock_debug_enabled);
 111
 112 /*
 113  * Parse the csdlock_debug= kernel boot parameter.
 114  *
 115  * If you need to restore the old "ext" value that once provided
 116  * additional debugging information, reapply the following commits:
 117  *
 118  * de7b09ef658d ("locking/csd_lock: Prepare more CSD lock debugging")
 119  * a5aabace5fb8 ("locking/csd_lock: Add more data to CSD lock debugging")
 120  */
 121 static int __init csdlock_debug(char *str)
 122 {
 123         unsigned int val = 0;
 124
 125         get_option(&str, &val);
 126         if (val)
 127                 static_branch_enable(&csdlock_debug_enabled);
 128
 129         return 1;
 130 }
 131 __setup("csdlock_debug=", csdlock_debug);
 132
 133 static DEFINE_PER_CPU(call_single_data_t *, cur_csd);
 134 static DEFINE_PER_CPU(smp_call_func_t, cur_csd_func);
 135 static DEFINE_PER_CPU(void *, cur_csd_info);
 136
 137 static ulong csd_lock_timeout = 5000;  /* CSD lock timeout in milliseconds. */
 138 module_param(csd_lock_timeout, ulong, 0444);
 139
 140 static atomic_t csd_bug_count = ATOMIC_INIT(0);
 141
 142 /* Record current CSD work for current CPU, NULL to erase. */
 143 static void __csd_lock_record(struct __call_single_data *csd)
 144 {
 145         if (!csd) {
 146                 smp_mb(); /* NULL cur_csd after unlock. */
 147                 __this_cpu_write(cur_csd, NULL);
 148                 return;
 149         }
 150         __this_cpu_write(cur_csd_func, csd->func);
 151         __this_cpu_write(cur_csd_info, csd->info);
 152         smp_wmb(); /* func and info before csd. */
 153         __this_cpu_write(cur_csd, csd);
 154         smp_mb(); /* Update cur_csd before function call. */
 155                   /* Or before unlock, as the case may be. */
 156 }
 157
 158 static __always_inline void csd_lock_record(struct __call_single_data *csd)
 159 {
 160         if (static_branch_unlikely(&csdlock_debug_enabled))
 161                 __csd_lock_record(csd);
 162 }
 163
 164 static int csd_lock_wait_getcpu(struct __call_single_data *csd)
 165 {
 166         unsigned int csd_type;
 167
 168         csd_type = CSD_TYPE(csd);
 169         if (csd_type == CSD_TYPE_ASYNC || csd_type == CSD_TYPE_SYNC)
 170                 return csd->node.dst; /* Other CSD_TYPE_ values might not have ->dst. */
 171         return -1;
 172 }
 173
 174 /*
 175  * Complain if too much time spent waiting.  Note that only
 176  * the CSD_TYPE_SYNC/ASYNC types provide the destination CPU,
 177  * so waiting on other types gets much less information.
 178  */
 179 static bool csd_lock_wait_toolong(struct __call_single_data *csd, u64 ts0, u64 *ts1, int *bug_id)
 180 {
 181         int cpu = -1;
 182         int cpux;
 183         bool firsttime;
 184         u64 ts2, ts_delta;
 185         call_single_data_t *cpu_cur_csd;
 186         unsigned int flags = READ_ONCE(csd->node.u_flags);
 187         unsigned long long csd_lock_timeout_ns = csd_lock_timeout * NSEC_PER_MSEC;
 188
 189         if (!(flags & CSD_FLAG_LOCK)) {
 190                 if (!unlikely(*bug_id))
 191                         return true;
 192                 cpu = csd_lock_wait_getcpu(csd);
 193                 pr_alert("csd: CSD lock (#%d) got unstuck on CPU#%02d, CPU#%02d released the lock.\n",
 194                          *bug_id, raw_smp_processor_id(), cpu);
 195                 return true;
 196         }
 197
 198         ts2 = sched_clock();
 199         ts_delta = ts2 - *ts1;
 200         if (likely(ts_delta <= csd_lock_timeout_ns || csd_lock_timeout_ns == 0))
 201                 return false;
 202
 203         firsttime = !*bug_id;
 204         if (firsttime)
 205                 *bug_id = atomic_inc_return(&csd_bug_count);
 206         cpu = csd_lock_wait_getcpu(csd);
 207         if (WARN_ONCE(cpu < 0 || cpu >= nr_cpu_ids, "%s: cpu = %d\n", __func__, cpu))
 208                 cpux = 0;
 209         else
 210                 cpux = cpu;
 211         cpu_cur_csd = smp_load_acquire(&per_cpu(cur_csd, cpux)); /* Before func and info. */
 212         pr_alert("csd: %s non-responsive CSD lock (#%d) on CPU#%d, waiting %llu ns for CPU#%02d %pS(%ps).\n",
 213                  firsttime ? "Detected" : "Continued", *bug_id, raw_smp_processor_id(), ts2 - ts0,
 214                  cpu, csd->func, csd->info);
 215         if (cpu_cur_csd && csd != cpu_cur_csd) {
 216                 pr_alert("\tcsd: CSD lock (#%d) handling prior %pS(%ps) request.\n",
 217                          *bug_id, READ_ONCE(per_cpu(cur_csd_func, cpux)),
 218                          READ_ONCE(per_cpu(cur_csd_info, cpux)));
 219         } else {
 220                 pr_alert("\tcsd: CSD lock (#%d) %s.\n",
 221                          *bug_id, !cpu_cur_csd ? "unresponsive" : "handling this request");
 222         }
 223         if (cpu >= 0) {
 224                 dump_cpu_task(cpu);
 225                 if (!cpu_cur_csd) {
 226                         pr_alert("csd: Re-sending CSD lock (#%d) IPI from CPU#%02d to CPU#%02d\n", *bug_id, raw_smp_processor_id(), cpu);
 227                         arch_send_call_function_single_ipi(cpu);
 228                 }
 229         }
 230         dump_stack();
 231         *ts1 = ts2;
 232
 233         return false;
 234 }
 235
 236 /*
 237  * csd_lock/csd_unlock used to serialize access to per-cpu csd resources
 238  *
 239  * For non-synchronous ipi calls the csd can still be in use by the
 240  * previous function call. For multi-cpu calls its even more interesting
 241  * as we'll have to ensure no other cpu is observing our csd.
 242  */
 243 static void __csd_lock_wait(struct __call_single_data *csd)
 244 {
 245         int bug_id = 0;
 246         u64 ts0, ts1;
 247
 248         ts1 = ts0 = sched_clock();
 249         for (;;) {
 250                 if (csd_lock_wait_toolong(csd, ts0, &ts1, &bug_id))
 251                         break;
 252                 cpu_relax();
 253         }
 254         smp_acquire__after_ctrl_dep();
 255 }
 256
 257 static __always_inline void csd_lock_wait(struct __call_single_data *csd)
 258 {
 259         if (static_branch_unlikely(&csdlock_debug_enabled)) {
 260                 __csd_lock_wait(csd);
 261                 return;
 262         }
 263
 264         smp_cond_load_acquire(&csd->node.u_flags, !(VAL & CSD_FLAG_LOCK));
 265 }
 266 #else
 267 static void csd_lock_record(struct __call_single_data *csd)
 268 {
 269 }
 270
 271 static __always_inline void csd_lock_wait(struct __call_single_data *csd)
 272 {
 273         smp_cond_load_acquire(&csd->node.u_flags, !(VAL & CSD_FLAG_LOCK));
 274 }
 275 #endif
 276
 277 static __always_inline void csd_lock(struct __call_single_data *csd)
 278 {
 279         csd_lock_wait(csd);
 280         csd->node.u_flags |= CSD_FLAG_LOCK;
 281
 282         /*
 283          * prevent CPU from reordering the above assignment
 284          * to ->flags with any subsequent assignments to other
 285          * fields of the specified call_single_data_t structure:
 286          */
 287         smp_wmb();
 288 }
 289
 290 static __always_inline void csd_unlock(struct __call_single_data *csd)
 291 {
 292         WARN_ON(!(csd->node.u_flags & CSD_FLAG_LOCK));
 293
 294         /*
 295          * ensure we're all done before releasing data:
 296          */
 297         smp_store_release(&csd->node.u_flags, 0);
 298 }
 299
 300 static DEFINE_PER_CPU_SHARED_ALIGNED(call_single_data_t, csd_data);
 301
 302 void __smp_call_single_queue(int cpu, struct llist_node *node)
 303 {
 304         /*
 305          * The list addition should be visible before sending the IPI
 306          * handler locks the list to pull the entry off it because of
 307          * normal cache coherency rules implied by spinlocks.
 308          *
 309          * If IPIs can go out of order to the cache coherency protocol
 310          * in an architecture, sufficient synchronisation should be added
 311          * to arch code to make it appear to obey cache coherency WRT
 312          * locking and barrier primitives. Generic code isn't really
 313          * equipped to do the right thing...
 314          */
 315         if (llist_add(node, &per_cpu(call_single_queue, cpu)))
 316                 send_call_function_single_ipi(cpu);
 317 }
 318
 319 /*
 320  * Insert a previously allocated call_single_data_t element
 321  * for execution on the given CPU. data must already have
 322  * ->func, ->info, and ->flags set.
 323  */
 324 static int generic_exec_single(int cpu, struct __call_single_data *csd)
 325 {
 326         if (cpu == smp_processor_id()) {
 327                 smp_call_func_t func = csd->func;
 328                 void *info = csd->info;
 329                 unsigned long flags;
 330
 331                 /*
 332                  * We can unlock early even for the synchronous on-stack case,
 333                  * since we're doing this from the same CPU..
 334                  */
 335                 csd_lock_record(csd);
 336                 csd_unlock(csd);
 337                 local_irq_save(flags);
 338                 func(info);
 339                 csd_lock_record(NULL);
 340                 local_irq_restore(flags);
 341                 return 0;
 342         }
 343
 344         if ((unsigned)cpu >= nr_cpu_ids || !cpu_online(cpu)) {
 345                 csd_unlock(csd);
 346                 return -ENXIO;
 347         }
 348
 349         __smp_call_single_queue(cpu, &csd->node.llist);
 350
 351         return 0;
 352 }
 353
 354 /**
 355  * generic_smp_call_function_single_interrupt - Execute SMP IPI callbacks
 356  *
 357  * Invoked by arch to handle an IPI for call function single.
 358  * Must be called with interrupts disabled.
 359  */
 360 void generic_smp_call_function_single_interrupt(void)
 361 {
 362         __flush_smp_call_function_queue(true);
 363 }
 364
 365 /**
 366  * __flush_smp_call_function_queue - Flush pending smp-call-function callbacks
 367  *
 368  * @warn_cpu_offline: If set to 'true', warn if callbacks were queued on an
 369  *                    offline CPU. Skip this check if set to 'false'.
 370  *
 371  * Flush any pending smp-call-function callbacks queued on this CPU. This is
 372  * invoked by the generic IPI handler, as well as by a CPU about to go offline,
 373  * to ensure that all pending IPI callbacks are run before it goes completely
 374  * offline.
 375  *
 376  * Loop through the call_single_queue and run all the queued callbacks.
 377  * Must be called with interrupts disabled.
 378  */
 379 static void __flush_smp_call_function_queue(bool warn_cpu_offline)
 380 {
 381         call_single_data_t *csd, *csd_next;
 382         struct llist_node *entry, *prev;
 383         struct llist_head *head;
 384         static bool warned;
 385
 386         lockdep_assert_irqs_disabled();
 387
 388         head = this_cpu_ptr(&call_single_queue);
 389         entry = llist_del_all(head);
 390         entry = llist_reverse_order(entry);
 391
 392         /* There shouldn't be any pending callbacks on an offline CPU. */
 393         if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) &&
 394                      !warned && entry != NULL)) {
 395                 warned = true;
 396                 WARN(1, "IPI on offline CPU %d\n", smp_processor_id());
 397
 398                 /*
 399                  * We don't have to use the _safe() variant here
 400                  * because we are not invoking the IPI handlers yet.
 401                  */
 402                 llist_for_each_entry(csd, entry, node.llist) {
 403                         switch (CSD_TYPE(csd)) {
 404                         case CSD_TYPE_ASYNC:
 405                         case CSD_TYPE_SYNC:
 406                         case CSD_TYPE_IRQ_WORK:
 407                                 pr_warn("IPI callback %pS sent to offline CPU\n",
 408                                         csd->func);
 409                                 break;
 410
 411                         case CSD_TYPE_TTWU:
 412                                 pr_warn("IPI task-wakeup sent to offline CPU\n");
 413                                 break;
 414
 415                         default:
 416                                 pr_warn("IPI callback, unknown type %d, sent to offline CPU\n",
 417                                         CSD_TYPE(csd));
 418                                 break;
 419                         }
 420                 }
 421         }
 422
 423         /*
 424          * First; run all SYNC callbacks, people are waiting for us.
 425          */
 426         prev = NULL;
 427         llist_for_each_entry_safe(csd, csd_next, entry, node.llist) {
 428                 /* Do we wait until *after* callback? */
 429                 if (CSD_TYPE(csd) == CSD_TYPE_SYNC) {
 430                         smp_call_func_t func = csd->func;
 431                         void *info = csd->info;
 432
 433                         if (prev) {
 434                                 prev->next = &csd_next->node.llist;
 435                         } else {
 436                                 entry = &csd_next->node.llist;
 437                         }
 438
 439                         csd_lock_record(csd);
 440                         func(info);
 441                         csd_unlock(csd);
 442                         csd_lock_record(NULL);
 443                 } else {
 444                         prev = &csd->node.llist;
 445                 }
 446         }
 447
 448         if (!entry)
 449                 return;
 450
 451         /*
 452          * Second; run all !SYNC callbacks.
 453          */
 454         prev = NULL;
 455         llist_for_each_entry_safe(csd, csd_next, entry, node.llist) {
 456                 int type = CSD_TYPE(csd);
 457
 458                 if (type != CSD_TYPE_TTWU) {
 459                         if (prev) {
 460                                 prev->next = &csd_next->node.llist;
 461                         } else {
 462                                 entry = &csd_next->node.llist;
 463                         }
 464
 465                         if (type == CSD_TYPE_ASYNC) {
 466                                 smp_call_func_t func = csd->func;
 467                                 void *info = csd->info;
 468
 469                                 csd_lock_record(csd);
 470                                 csd_unlock(csd);
 471                                 func(info);
 472                                 csd_lock_record(NULL);
 473                         } else if (type == CSD_TYPE_IRQ_WORK) {
 474                                 irq_work_single(csd);
 475                         }
 476
 477                 } else {
 478                         prev = &csd->node.llist;
 479                 }
 480         }
 481
 482         /*
 483          * Third; only CSD_TYPE_TTWU is left, issue those.
 484          */
 485         if (entry)
 486                 sched_ttwu_pending(entry);
 487 }
 488
 489
 490 /**
 491  * flush_smp_call_function_queue - Flush pending smp-call-function callbacks
 492  *                                 from task context (idle, migration thread)
 493  *
 494  * When TIF_POLLING_NRFLAG is supported and a CPU is in idle and has it
 495  * set, then remote CPUs can avoid sending IPIs and wake the idle CPU by
 496  * setting TIF_NEED_RESCHED. The idle task on the woken up CPU has to
 497  * handle queued SMP function calls before scheduling.
 498  *
 499  * The migration thread has to ensure that an eventually pending wakeup has
 500  * been handled before it migrates a task.
 501  */
 502 void flush_smp_call_function_queue(void)
 503 {
 504         unsigned int was_pending;
 505         unsigned long flags;
 506
 507         if (llist_empty(this_cpu_ptr(&call_single_queue)))
 508                 return;
 509
 510         local_irq_save(flags);
 511         /* Get the already pending soft interrupts for RT enabled kernels */
 512         was_pending = local_softirq_pending();
 513         __flush_smp_call_function_queue(true);
 514         if (local_softirq_pending())
 515                 do_softirq_post_smp_call_flush(was_pending);
 516
 517         local_irq_restore(flags);
 518 }
 519
 520 /*
 521  * smp_call_function_single - Run a function on a specific CPU
 522  * @func: The function to run. This must be fast and non-blocking.
 523  * @info: An arbitrary pointer to pass to the function.
 524  * @wait: If true, wait until function has completed on other CPUs.
 525  *
 526  * Returns 0 on success, else a negative status code.
 527  */
 528 int smp_call_function_single(int cpu, smp_call_func_t func, void *info,
 529                              int wait)
 530 {
 531         call_single_data_t *csd;
 532         call_single_data_t csd_stack = {
 533                 .node = { .u_flags = CSD_FLAG_LOCK | CSD_TYPE_SYNC, },
 534         };
 535         int this_cpu;
 536         int err;
 537
 538         /*
 539          * prevent preemption and reschedule on another processor,
 540          * as well as CPU removal
 541          */
 542         this_cpu = get_cpu();
 543
 544         /*
 545          * Can deadlock when called with interrupts disabled.
 546          * We allow cpu's that are not yet online though, as no one else can
 547          * send smp call function interrupt to this cpu and as such deadlocks
 548          * can't happen.
 549          */
 550         WARN_ON_ONCE(cpu_online(this_cpu) && irqs_disabled()
 551                      && !oops_in_progress);
 552
 553         /*
 554          * When @wait we can deadlock when we interrupt between llist_add() and
 555          * arch_send_call_function_ipi*(); when !@wait we can deadlock due to
 556          * csd_lock() on because the interrupt context uses the same csd
 557          * storage.
 558          */
 559         WARN_ON_ONCE(!in_task());
 560
 561         csd = &csd_stack;
 562         if (!wait) {
 563                 csd = this_cpu_ptr(&csd_data);
 564                 csd_lock(csd);
 565         }
 566
 567         csd->func = func;
 568         csd->info = info;
 569 #ifdef CONFIG_CSD_LOCK_WAIT_DEBUG
 570         csd->node.src = smp_processor_id();
 571         csd->node.dst = cpu;
 572 #endif
 573
 574         err = generic_exec_single(cpu, csd);
 575
 576         if (wait)
 577                 csd_lock_wait(csd);
 578
 579         put_cpu();
 580
 581         return err;
 582 }
 583 EXPORT_SYMBOL(smp_call_function_single);
 584
 585 /**
 586  * smp_call_function_single_async() - Run an asynchronous function on a
 587  *                               specific CPU.
 588  * @cpu: The CPU to run on.
 589  * @csd: Pre-allocated and setup data structure
 590  *
 591  * Like smp_call_function_single(), but the call is asynchonous and
 592  * can thus be done from contexts with disabled interrupts.
 593  *
 594  * The caller passes his own pre-allocated data structure
 595  * (ie: embedded in an object) and is responsible for synchronizing it
 596  * such that the IPIs performed on the @csd are strictly serialized.
 597  *
 598  * If the function is called with one csd which has not yet been
 599  * processed by previous call to smp_call_function_single_async(), the
 600  * function will return immediately with -EBUSY showing that the csd
 601  * object is still in progress.
 602  *
 603  * NOTE: Be careful, there is unfortunately no current debugging facility to
 604  * validate the correctness of this serialization.
 605  *
 606  * Return: %0 on success or negative errno value on error
 607  */
 608 int smp_call_function_single_async(int cpu, struct __call_single_data *csd)
 609 {
 610         int err = 0;
 611
 612         preempt_disable();
 613
 614         if (csd->node.u_flags & CSD_FLAG_LOCK) {
 615                 err = -EBUSY;
 616                 goto out;
 617         }
 618
 619         csd->node.u_flags = CSD_FLAG_LOCK;
 620         smp_wmb();
 621
 622         err = generic_exec_single(cpu, csd);
 623
 624 out:
 625         preempt_enable();
 626
 627         return err;
 628 }
 629 EXPORT_SYMBOL_GPL(smp_call_function_single_async);
 630
 631 /*
 632  * smp_call_function_any - Run a function on any of the given cpus
 633  * @mask: The mask of cpus it can run on.
 634  * @func: The function to run. This must be fast and non-blocking.
 635  * @info: An arbitrary pointer to pass to the function.
 636  * @wait: If true, wait until function has completed.
 637  *
 638  * Returns 0 on success, else a negative status code (if no cpus were online).
 639  *
 640  * Selection preference:
 641  *      1) current cpu if in @mask
 642  *      2) any cpu of current node if in @mask
 643  *      3) any other online cpu in @mask
 644  */
 645 int smp_call_function_any(const struct cpumask *mask,
 646                           smp_call_func_t func, void *info, int wait)
 647 {
 648         unsigned int cpu;
 649         const struct cpumask *nodemask;
 650         int ret;
 651
 652         /* Try for same CPU (cheapest) */
 653         cpu = get_cpu();
 654         if (cpumask_test_cpu(cpu, mask))
 655                 goto call;
 656
 657         /* Try for same node. */
 658         nodemask = cpumask_of_node(cpu_to_node(cpu));
 659         for (cpu = cpumask_first_and(nodemask, mask); cpu < nr_cpu_ids;
 660              cpu = cpumask_next_and(cpu, nodemask, mask)) {
 661                 if (cpu_online(cpu))
 662                         goto call;
 663         }
 664
 665         /* Any online will do: smp_call_function_single handles nr_cpu_ids. */
 666         cpu = cpumask_any_and(mask, cpu_online_mask);
 667 call:
 668         ret = smp_call_function_single(cpu, func, info, wait);
 669         put_cpu();
 670         return ret;
 671 }
 672 EXPORT_SYMBOL_GPL(smp_call_function_any);
 673
 674 /*
 675  * Flags to be used as scf_flags argument of smp_call_function_many_cond().
 676  *
 677  * %SCF_WAIT:           Wait until function execution is completed
 678  * %SCF_RUN_LOCAL:      Run also locally if local cpu is set in cpumask
 679  */
 680 #define SCF_WAIT        (1U << 0)
 681 #define SCF_RUN_LOCAL   (1U << 1)
 682
 683 static void smp_call_function_many_cond(const struct cpumask *mask,
 684                                         smp_call_func_t func, void *info,
 685                                         unsigned int scf_flags,
 686                                         smp_cond_func_t cond_func)
 687 {
 688         int cpu, last_cpu, this_cpu = smp_processor_id();
 689         struct call_function_data *cfd;
 690         bool wait = scf_flags & SCF_WAIT;
 691         bool run_remote = false;
 692         bool run_local = false;
 693         int nr_cpus = 0;
 694
 695         lockdep_assert_preemption_disabled();
 696
 697         /*
 698          * Can deadlock when called with interrupts disabled.
 699          * We allow cpu's that are not yet online though, as no one else can
 700          * send smp call function interrupt to this cpu and as such deadlocks
 701          * can't happen.
 702          */
 703         if (cpu_online(this_cpu) && !oops_in_progress &&
 704             !early_boot_irqs_disabled)
 705                 lockdep_assert_irqs_enabled();
 706
 707         /*
 708          * When @wait we can deadlock when we interrupt between llist_add() and
 709          * arch_send_call_function_ipi*(); when !@wait we can deadlock due to
 710          * csd_lock() on because the interrupt context uses the same csd
 711          * storage.
 712          */
 713         WARN_ON_ONCE(!in_task());
 714
 715         /* Check if we need local execution. */
 716         if ((scf_flags & SCF_RUN_LOCAL) && cpumask_test_cpu(this_cpu, mask))
 717                 run_local = true;
 718
 719         /* Check if we need remote execution, i.e., any CPU excluding this one. */
 720         cpu = cpumask_first_and(mask, cpu_online_mask);
 721         if (cpu == this_cpu)
 722                 cpu = cpumask_next_and(cpu, mask, cpu_online_mask);
 723         if (cpu < nr_cpu_ids)
 724                 run_remote = true;
 725
 726         if (run_remote) {
 727                 cfd = this_cpu_ptr(&cfd_data);
 728                 cpumask_and(cfd->cpumask, mask, cpu_online_mask);
 729                 __cpumask_clear_cpu(this_cpu, cfd->cpumask);
 730
 731                 cpumask_clear(cfd->cpumask_ipi);
 732                 for_each_cpu(cpu, cfd->cpumask) {
 733                         call_single_data_t *csd = &per_cpu_ptr(cfd->pcpu, cpu)->csd;
 734
 735                         if (cond_func && !cond_func(cpu, info))
 736                                 continue;
 737
 738                         csd_lock(csd);
 739                         if (wait)
 740                                 csd->node.u_flags |= CSD_TYPE_SYNC;
 741                         csd->func = func;
 742                         csd->info = info;
 743 #ifdef CONFIG_CSD_LOCK_WAIT_DEBUG
 744                         csd->node.src = smp_processor_id();
 745                         csd->node.dst = cpu;
 746 #endif
 747                         if (llist_add(&csd->node.llist, &per_cpu(call_single_queue, cpu))) {
 748                                 __cpumask_set_cpu(cpu, cfd->cpumask_ipi);
 749                                 nr_cpus++;
 750                                 last_cpu = cpu;
 751                         }
 752                 }
 753
 754                 /*
 755                  * Choose the most efficient way to send an IPI. Note that the
 756                  * number of CPUs might be zero due to concurrent changes to the
 757                  * provided mask.
 758                  */
 759                 if (nr_cpus == 1)
 760                         send_call_function_single_ipi(last_cpu);
 761                 else if (likely(nr_cpus > 1))
 762                         arch_send_call_function_ipi_mask(cfd->cpumask_ipi);
 763         }
 764
 765         if (run_local && (!cond_func || cond_func(this_cpu, info))) {
 766                 unsigned long flags;
 767
 768                 local_irq_save(flags);
 769                 func(info);
 770                 local_irq_restore(flags);
 771         }
 772
 773         if (run_remote && wait) {
 774                 for_each_cpu(cpu, cfd->cpumask) {
 775                         call_single_data_t *csd;
 776
 777                         csd = &per_cpu_ptr(cfd->pcpu, cpu)->csd;
 778                         csd_lock_wait(csd);
 779                 }
 780         }
 781 }
 782
 783 /**
 784  * smp_call_function_many(): Run a function on a set of CPUs.
 785  * @mask: The set of cpus to run on (only runs on online subset).
 786  * @func: The function to run. This must be fast and non-blocking.
 787  * @info: An arbitrary pointer to pass to the function.
 788  * @wait: Bitmask that controls the operation. If %SCF_WAIT is set, wait
 789  *        (atomically) until function has completed on other CPUs. If
 790  *        %SCF_RUN_LOCAL is set, the function will also be run locally
 791  *        if the local CPU is set in the @cpumask.
 792  *
 793  * If @wait is true, then returns once @func has returned.
 794  *
 795  * You must not call this function with disabled interrupts or from a
 796  * hardware interrupt handler or from a bottom half handler. Preemption
 797  * must be disabled when calling this function.
 798  */
 799 void smp_call_function_many(const struct cpumask *mask,
 800                             smp_call_func_t func, void *info, bool wait)
 801 {
 802         smp_call_function_many_cond(mask, func, info, wait * SCF_WAIT, NULL);
 803 }
 804 EXPORT_SYMBOL(smp_call_function_many);
 805
 806 /**
 807  * smp_call_function(): Run a function on all other CPUs.
 808  * @func: The function to run. This must be fast and non-blocking.
 809  * @info: An arbitrary pointer to pass to the function.
 810  * @wait: If true, wait (atomically) until function has completed
 811  *        on other CPUs.
 812  *
 813  * Returns 0.
 814  *
 815  * If @wait is true, then returns once @func has returned; otherwise
 816  * it returns just before the target cpu calls @func.
 817  *
 818  * You must not call this function with disabled interrupts or from a
 819  * hardware interrupt handler or from a bottom half handler.
 820  */
 821 void smp_call_function(smp_call_func_t func, void *info, int wait)
 822 {
 823         preempt_disable();
 824         smp_call_function_many(cpu_online_mask, func, info, wait);
 825         preempt_enable();
 826 }
 827 EXPORT_SYMBOL(smp_call_function);
 828
 829 /* Setup configured maximum number of CPUs to activate */
 830 unsigned int setup_max_cpus = NR_CPUS;
 831 EXPORT_SYMBOL(setup_max_cpus);
 832
 833
 834 /*
 835  * Setup routine for controlling SMP activation
 836  *
 837  * Command-line option of "nosmp" or "maxcpus=0" will disable SMP
 838  * activation entirely (the MPS table probe still happens, though).
 839  *
 840  * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer
 841  * greater than 0, limits the maximum number of CPUs activated in
 842  * SMP mode to <NUM>.
 843  */
 844
 845 void __weak arch_disable_smp_support(void) { }
 846
 847 static int __init nosmp(char *str)
 848 {
 849         setup_max_cpus = 0;
 850         arch_disable_smp_support();
 851
 852         return 0;
 853 }
 854
 855 early_param("nosmp", nosmp);
 856
 857 /* this is hard limit */
 858 static int __init nrcpus(char *str)
 859 {
 860         int nr_cpus;
 861
 862         if (get_option(&str, &nr_cpus) && nr_cpus > 0 && nr_cpus < nr_cpu_ids)
 863                 set_nr_cpu_ids(nr_cpus);
 864
 865         return 0;
 866 }
 867
 868 early_param("nr_cpus", nrcpus);
 869
 870 static int __init maxcpus(char *str)
 871 {
 872         get_option(&str, &setup_max_cpus);
 873         if (setup_max_cpus == 0)
 874                 arch_disable_smp_support();
 875
 876         return 0;
 877 }
 878
 879 early_param("maxcpus", maxcpus);
 880
 881 #if (NR_CPUS > 1) && !defined(CONFIG_FORCE_NR_CPUS)
 882 /* Setup number of possible processor ids */
 883 unsigned int nr_cpu_ids __read_mostly = NR_CPUS;
 884 EXPORT_SYMBOL(nr_cpu_ids);
 885 #endif
 886
 887 /* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */
 888 void __init setup_nr_cpu_ids(void)
 889 {
 890         set_nr_cpu_ids(find_last_bit(cpumask_bits(cpu_possible_mask), NR_CPUS) + 1);
 891 }
 892
 893 /* Called by boot processor to activate the rest. */
 894 void __init smp_init(void)
 895 {
 896         int num_nodes, num_cpus;
 897
 898         idle_threads_init();
 899         cpuhp_threads_init();
 900
 901         pr_info("Bringing up secondary CPUs ...\n");
 902
 903         bringup_nonboot_cpus(setup_max_cpus);
 904
 905         num_nodes = num_online_nodes();
 906         num_cpus  = num_online_cpus();
 907         pr_info("Brought up %d node%s, %d CPU%s\n",
 908                 num_nodes, (num_nodes > 1 ? "s" : ""),
 909                 num_cpus,  (num_cpus  > 1 ? "s" : ""));
 910
 911         /* Any cleanup work */
 912         smp_cpus_done(setup_max_cpus);
 913 }
 914
 915 /*
 916  * on_each_cpu_cond(): Call a function on each processor for which
 917  * the supplied function cond_func returns true, optionally waiting
 918  * for all the required CPUs to finish. This may include the local
 919  * processor.
 920  * @cond_func:  A callback function that is passed a cpu id and
 921  *              the info parameter. The function is called
 922  *              with preemption disabled. The function should
 923  *              return a blooean value indicating whether to IPI
 924  *              the specified CPU.
 925  * @func:       The function to run on all applicable CPUs.
 926  *              This must be fast and non-blocking.
 927  * @info:       An arbitrary pointer to pass to both functions.
 928  * @wait:       If true, wait (atomically) until function has
 929  *              completed on other CPUs.
 930  *
 931  * Preemption is disabled to protect against CPUs going offline but not online.
 932  * CPUs going online during the call will not be seen or sent an IPI.
 933  *
 934  * You must not call this function with disabled interrupts or
 935  * from a hardware interrupt handler or from a bottom half handler.
 936  */
 937 void on_each_cpu_cond_mask(smp_cond_func_t cond_func, smp_call_func_t func,
 938                            void *info, bool wait, const struct cpumask *mask)
 939 {
 940         unsigned int scf_flags = SCF_RUN_LOCAL;
 941
 942         if (wait)
 943                 scf_flags |= SCF_WAIT;
 944
 945         preempt_disable();
 946         smp_call_function_many_cond(mask, func, info, scf_flags, cond_func);
 947         preempt_enable();
 948 }
 949 EXPORT_SYMBOL(on_each_cpu_cond_mask);
 950
 951 static void do_nothing(void *unused)
 952 {
 953 }
 954
 955 /**
 956  * kick_all_cpus_sync - Force all cpus out of idle
 957  *
 958  * Used to synchronize the update of pm_idle function pointer. It's
 959  * called after the pointer is updated and returns after the dummy
 960  * callback function has been executed on all cpus. The execution of
 961  * the function can only happen on the remote cpus after they have
 962  * left the idle function which had been called via pm_idle function
 963  * pointer. So it's guaranteed that nothing uses the previous pointer
 964  * anymore.
 965  */
 966 void kick_all_cpus_sync(void)
 967 {
 968         /* Make sure the change is visible before we kick the cpus */
 969         smp_mb();
 970         smp_call_function(do_nothing, NULL, 1);
 971 }
 972 EXPORT_SYMBOL_GPL(kick_all_cpus_sync);
 973
 974 /**
 975  * wake_up_all_idle_cpus - break all cpus out of idle
 976  * wake_up_all_idle_cpus try to break all cpus which is in idle state even
 977  * including idle polling cpus, for non-idle cpus, we will do nothing
 978  * for them.
 979  */
 980 void wake_up_all_idle_cpus(void)
 981 {
 982         int cpu;
 983
 984         for_each_possible_cpu(cpu) {
 985                 preempt_disable();
 986                 if (cpu != smp_processor_id() && cpu_online(cpu))
 987                         wake_up_if_idle(cpu);
 988                 preempt_enable();
 989         }
 990 }
 991 EXPORT_SYMBOL_GPL(wake_up_all_idle_cpus);
 992
 993 /**
 994  * struct smp_call_on_cpu_struct - Call a function on a specific CPU
 995  * @work: &work_struct
 996  * @done: &completion to signal
 997  * @func: function to call
 998  * @data: function's data argument
 999  * @ret: return value from @func
1000  * @cpu: target CPU (%-1 for any CPU)
1001  *
1002  * Used to call a function on a specific cpu and wait for it to return.
1003  * Optionally make sure the call is done on a specified physical cpu via vcpu
1004  * pinning in order to support virtualized environments.
1005  */
1006 struct smp_call_on_cpu_struct {
1007         struct work_struct      work;
1008         struct completion       done;
1009         int                     (*func)(void *);
1010         void                    *data;
1011         int                     ret;
1012         int                     cpu;
1013 };
1014
1015 static void smp_call_on_cpu_callback(struct work_struct *work)
1016 {
1017         struct smp_call_on_cpu_struct *sscs;
1018
1019         sscs = container_of(work, struct smp_call_on_cpu_struct, work);
1020         if (sscs->cpu >= 0)
1021                 hypervisor_pin_vcpu(sscs->cpu);
1022         sscs->ret = sscs->func(sscs->data);
1023         if (sscs->cpu >= 0)
1024                 hypervisor_pin_vcpu(-1);
1025
1026         complete(&sscs->done);
1027 }
1028
1029 int smp_call_on_cpu(unsigned int cpu, int (*func)(void *), void *par, bool phys)
1030 {
1031         struct smp_call_on_cpu_struct sscs = {
1032                 .done = COMPLETION_INITIALIZER_ONSTACK(sscs.done),
1033                 .func = func,
1034                 .data = par,
1035                 .cpu  = phys ? cpu : -1,
1036         };
1037
1038         INIT_WORK_ONSTACK(&sscs.work, smp_call_on_cpu_callback);
1039
1040         if (cpu >= nr_cpu_ids || !cpu_online(cpu))
1041                 return -ENXIO;
1042
1043         queue_work_on(cpu, system_wq, &sscs.work);
1044         wait_for_completion(&sscs.done);
1045
1046         return sscs.ret;
1047 }
1048 EXPORT_SYMBOL_GPL(smp_call_on_cpu);