LCOV - code coverage report
Current view: top level - kernel - stop_machine.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 157 248 63.3 %
Date: 2022-04-01 14:35:51 Functions: 15 23 65.2 %
Branches: 29 77 37.7 %

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

Generated by: LCOV version 1.14