Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * Common SMP CPU bringup/teardown functions
       4                 :            :  */
       5                 :            : #include <linux/cpu.h>
       6                 :            : #include <linux/err.h>
       7                 :            : #include <linux/smp.h>
       8                 :            : #include <linux/delay.h>
       9                 :            : #include <linux/init.h>
      10                 :            : #include <linux/list.h>
      11                 :            : #include <linux/slab.h>
      12                 :            : #include <linux/sched.h>
      13                 :            : #include <linux/sched/task.h>
      14                 :            : #include <linux/export.h>
      15                 :            : #include <linux/percpu.h>
      16                 :            : #include <linux/kthread.h>
      17                 :            : #include <linux/smpboot.h>
      18                 :            : 
      19                 :            : #include "smpboot.h"
      20                 :            : 
      21                 :            : #ifdef CONFIG_SMP
      22                 :            : 
      23                 :            : #ifdef CONFIG_GENERIC_SMP_IDLE_THREAD
      24                 :            : /*
      25                 :            :  * For the hotplug case we keep the task structs around and reuse
      26                 :            :  * them.
      27                 :            :  */
      28                 :            : static DEFINE_PER_CPU(struct task_struct *, idle_threads);
      29                 :            : 
      30                 :          3 : struct task_struct *idle_thread_get(unsigned int cpu)
      31                 :            : {
      32                 :          3 :         struct task_struct *tsk = per_cpu(idle_threads, cpu);
      33                 :            : 
      34                 :          3 :         if (!tsk)
      35                 :            :                 return ERR_PTR(-ENOMEM);
      36                 :          3 :         init_idle(tsk, cpu);
      37                 :          3 :         return tsk;
      38                 :            : }
      39                 :            : 
      40                 :          3 : void __init idle_thread_set_boot_cpu(void)
      41                 :            : {
      42                 :          3 :         per_cpu(idle_threads, smp_processor_id()) = current;
      43                 :          3 : }
      44                 :            : 
      45                 :            : /**
      46                 :            :  * idle_init - Initialize the idle thread for a cpu
      47                 :            :  * @cpu:        The cpu for which the idle thread should be initialized
      48                 :            :  *
      49                 :            :  * Creates the thread if it does not exist.
      50                 :            :  */
      51                 :          3 : static inline void idle_init(unsigned int cpu)
      52                 :            : {
      53                 :          3 :         struct task_struct *tsk = per_cpu(idle_threads, cpu);
      54                 :            : 
      55                 :          3 :         if (!tsk) {
      56                 :          3 :                 tsk = fork_idle(cpu);
      57                 :          3 :                 if (IS_ERR(tsk))
      58                 :          0 :                         pr_err("SMP: fork_idle() failed for CPU %u\n", cpu);
      59                 :            :                 else
      60                 :          3 :                         per_cpu(idle_threads, cpu) = tsk;
      61                 :            :         }
      62                 :          3 : }
      63                 :            : 
      64                 :            : /**
      65                 :            :  * idle_threads_init - Initialize idle threads for all cpus
      66                 :            :  */
      67                 :          3 : void __init idle_threads_init(void)
      68                 :            : {
      69                 :            :         unsigned int cpu, boot_cpu;
      70                 :            : 
      71                 :          3 :         boot_cpu = smp_processor_id();
      72                 :            : 
      73                 :          3 :         for_each_possible_cpu(cpu) {
      74                 :          3 :                 if (cpu != boot_cpu)
      75                 :          3 :                         idle_init(cpu);
      76                 :            :         }
      77                 :          3 : }
      78                 :            : #endif
      79                 :            : 
      80                 :            : #endif /* #ifdef CONFIG_SMP */
      81                 :            : 
      82                 :            : static LIST_HEAD(hotplug_threads);
      83                 :            : static DEFINE_MUTEX(smpboot_threads_lock);
      84                 :            : 
      85                 :            : struct smpboot_thread_data {
      86                 :            :         unsigned int                    cpu;
      87                 :            :         unsigned int                    status;
      88                 :            :         struct smp_hotplug_thread       *ht;
      89                 :            : };
      90                 :            : 
      91                 :            : enum {
      92                 :            :         HP_THREAD_NONE = 0,
      93                 :            :         HP_THREAD_ACTIVE,
      94                 :            :         HP_THREAD_PARKED,
      95                 :            : };
      96                 :            : 
      97                 :            : /**
      98                 :            :  * smpboot_thread_fn - percpu hotplug thread loop function
      99                 :            :  * @data:       thread data pointer
     100                 :            :  *
     101                 :            :  * Checks for thread stop and park conditions. Calls the necessary
     102                 :            :  * setup, cleanup, park and unpark functions for the registered
     103                 :            :  * thread.
     104                 :            :  *
     105                 :            :  * Returns 1 when the thread should exit, 0 otherwise.
     106                 :            :  */
     107                 :          3 : static int smpboot_thread_fn(void *data)
     108                 :            : {
     109                 :            :         struct smpboot_thread_data *td = data;
     110                 :          3 :         struct smp_hotplug_thread *ht = td->ht;
     111                 :            : 
     112                 :            :         while (1) {
     113                 :          3 :                 set_current_state(TASK_INTERRUPTIBLE);
     114                 :          3 :                 preempt_disable();
     115                 :          3 :                 if (kthread_should_stop()) {
     116                 :          0 :                         __set_current_state(TASK_RUNNING);
     117                 :          0 :                         preempt_enable();
     118                 :            :                         /* cleanup must mirror setup */
     119                 :          0 :                         if (ht->cleanup && td->status != HP_THREAD_NONE)
     120                 :          0 :                                 ht->cleanup(td->cpu, cpu_online(td->cpu));
     121                 :          0 :                         kfree(td);
     122                 :          0 :                         return 0;
     123                 :            :                 }
     124                 :            : 
     125                 :          3 :                 if (kthread_should_park()) {
     126                 :          0 :                         __set_current_state(TASK_RUNNING);
     127                 :          0 :                         preempt_enable();
     128                 :          0 :                         if (ht->park && td->status == HP_THREAD_ACTIVE) {
     129                 :          0 :                                 BUG_ON(td->cpu != smp_processor_id());
     130                 :          0 :                                 ht->park(td->cpu);
     131                 :          0 :                                 td->status = HP_THREAD_PARKED;
     132                 :            :                         }
     133                 :          0 :                         kthread_parkme();
     134                 :            :                         /* We might have been woken for stop */
     135                 :          0 :                         continue;
     136                 :            :                 }
     137                 :            : 
     138                 :          3 :                 BUG_ON(td->cpu != smp_processor_id());
     139                 :            : 
     140                 :            :                 /* Check for state change setup */
     141                 :          3 :                 switch (td->status) {
     142                 :            :                 case HP_THREAD_NONE:
     143                 :          3 :                         __set_current_state(TASK_RUNNING);
     144                 :          3 :                         preempt_enable();
     145                 :          3 :                         if (ht->setup)
     146                 :          0 :                                 ht->setup(td->cpu);
     147                 :          3 :                         td->status = HP_THREAD_ACTIVE;
     148                 :          3 :                         continue;
     149                 :            : 
     150                 :            :                 case HP_THREAD_PARKED:
     151                 :          0 :                         __set_current_state(TASK_RUNNING);
     152                 :          0 :                         preempt_enable();
     153                 :          0 :                         if (ht->unpark)
     154                 :          0 :                                 ht->unpark(td->cpu);
     155                 :          0 :                         td->status = HP_THREAD_ACTIVE;
     156                 :          0 :                         continue;
     157                 :            :                 }
     158                 :            : 
     159                 :          3 :                 if (!ht->thread_should_run(td->cpu)) {
     160                 :          3 :                         preempt_enable_no_resched();
     161                 :          3 :                         schedule();
     162                 :            :                 } else {
     163                 :          3 :                         __set_current_state(TASK_RUNNING);
     164                 :          3 :                         preempt_enable();
     165                 :          3 :                         ht->thread_fn(td->cpu);
     166                 :            :                 }
     167                 :            :         }
     168                 :            : }
     169                 :            : 
     170                 :            : static int
     171                 :          3 : __smpboot_create_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
     172                 :            : {
     173                 :          3 :         struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
     174                 :            :         struct smpboot_thread_data *td;
     175                 :            : 
     176                 :          3 :         if (tsk)
     177                 :            :                 return 0;
     178                 :            : 
     179                 :          3 :         td = kzalloc_node(sizeof(*td), GFP_KERNEL, cpu_to_node(cpu));
     180                 :          3 :         if (!td)
     181                 :            :                 return -ENOMEM;
     182                 :          3 :         td->cpu = cpu;
     183                 :          3 :         td->ht = ht;
     184                 :            : 
     185                 :          3 :         tsk = kthread_create_on_cpu(smpboot_thread_fn, td, cpu,
     186                 :            :                                     ht->thread_comm);
     187                 :          3 :         if (IS_ERR(tsk)) {
     188                 :          0 :                 kfree(td);
     189                 :          0 :                 return PTR_ERR(tsk);
     190                 :            :         }
     191                 :            :         /*
     192                 :            :          * Park the thread so that it could start right on the CPU
     193                 :            :          * when it is available.
     194                 :            :          */
     195                 :          3 :         kthread_park(tsk);
     196                 :            :         get_task_struct(tsk);
     197                 :          3 :         *per_cpu_ptr(ht->store, cpu) = tsk;
     198                 :          3 :         if (ht->create) {
     199                 :            :                 /*
     200                 :            :                  * Make sure that the task has actually scheduled out
     201                 :            :                  * into park position, before calling the create
     202                 :            :                  * callback. At least the migration thread callback
     203                 :            :                  * requires that the task is off the runqueue.
     204                 :            :                  */
     205                 :          3 :                 if (!wait_task_inactive(tsk, TASK_PARKED))
     206                 :          0 :                         WARN_ON(1);
     207                 :            :                 else
     208                 :          3 :                         ht->create(cpu);
     209                 :            :         }
     210                 :            :         return 0;
     211                 :            : }
     212                 :            : 
     213                 :          3 : int smpboot_create_threads(unsigned int cpu)
     214                 :            : {
     215                 :            :         struct smp_hotplug_thread *cur;
     216                 :            :         int ret = 0;
     217                 :            : 
     218                 :          3 :         mutex_lock(&smpboot_threads_lock);
     219                 :          3 :         list_for_each_entry(cur, &hotplug_threads, list) {
     220                 :          3 :                 ret = __smpboot_create_thread(cur, cpu);
     221                 :          3 :                 if (ret)
     222                 :            :                         break;
     223                 :            :         }
     224                 :          3 :         mutex_unlock(&smpboot_threads_lock);
     225                 :          3 :         return ret;
     226                 :            : }
     227                 :            : 
     228                 :            : static void smpboot_unpark_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
     229                 :            : {
     230                 :          3 :         struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
     231                 :            : 
     232                 :          3 :         if (!ht->selfparking)
     233                 :          3 :                 kthread_unpark(tsk);
     234                 :            : }
     235                 :            : 
     236                 :          3 : int smpboot_unpark_threads(unsigned int cpu)
     237                 :            : {
     238                 :            :         struct smp_hotplug_thread *cur;
     239                 :            : 
     240                 :          3 :         mutex_lock(&smpboot_threads_lock);
     241                 :          3 :         list_for_each_entry(cur, &hotplug_threads, list)
     242                 :            :                 smpboot_unpark_thread(cur, cpu);
     243                 :          3 :         mutex_unlock(&smpboot_threads_lock);
     244                 :          3 :         return 0;
     245                 :            : }
     246                 :            : 
     247                 :          0 : static void smpboot_park_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
     248                 :            : {
     249                 :          0 :         struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
     250                 :            : 
     251                 :          0 :         if (tsk && !ht->selfparking)
     252                 :          0 :                 kthread_park(tsk);
     253                 :          0 : }
     254                 :            : 
     255                 :          0 : int smpboot_park_threads(unsigned int cpu)
     256                 :            : {
     257                 :            :         struct smp_hotplug_thread *cur;
     258                 :            : 
     259                 :          0 :         mutex_lock(&smpboot_threads_lock);
     260                 :          0 :         list_for_each_entry_reverse(cur, &hotplug_threads, list)
     261                 :          0 :                 smpboot_park_thread(cur, cpu);
     262                 :          0 :         mutex_unlock(&smpboot_threads_lock);
     263                 :          0 :         return 0;
     264                 :            : }
     265                 :            : 
     266                 :          0 : static void smpboot_destroy_threads(struct smp_hotplug_thread *ht)
     267                 :            : {
     268                 :            :         unsigned int cpu;
     269                 :            : 
     270                 :            :         /* We need to destroy also the parked threads of offline cpus */
     271                 :          0 :         for_each_possible_cpu(cpu) {
     272                 :          0 :                 struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
     273                 :            : 
     274                 :          0 :                 if (tsk) {
     275                 :          0 :                         kthread_stop(tsk);
     276                 :          0 :                         put_task_struct(tsk);
     277                 :          0 :                         *per_cpu_ptr(ht->store, cpu) = NULL;
     278                 :            :                 }
     279                 :            :         }
     280                 :          0 : }
     281                 :            : 
     282                 :            : /**
     283                 :            :  * smpboot_register_percpu_thread - Register a per_cpu thread related
     284                 :            :  *                                          to hotplug
     285                 :            :  * @plug_thread:        Hotplug thread descriptor
     286                 :            :  *
     287                 :            :  * Creates and starts the threads on all online cpus.
     288                 :            :  */
     289                 :          3 : int smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread)
     290                 :            : {
     291                 :            :         unsigned int cpu;
     292                 :            :         int ret = 0;
     293                 :            : 
     294                 :            :         get_online_cpus();
     295                 :          3 :         mutex_lock(&smpboot_threads_lock);
     296                 :          3 :         for_each_online_cpu(cpu) {
     297                 :          3 :                 ret = __smpboot_create_thread(plug_thread, cpu);
     298                 :          3 :                 if (ret) {
     299                 :          0 :                         smpboot_destroy_threads(plug_thread);
     300                 :          0 :                         goto out;
     301                 :            :                 }
     302                 :            :                 smpboot_unpark_thread(plug_thread, cpu);
     303                 :            :         }
     304                 :          3 :         list_add(&plug_thread->list, &hotplug_threads);
     305                 :            : out:
     306                 :          3 :         mutex_unlock(&smpboot_threads_lock);
     307                 :            :         put_online_cpus();
     308                 :          3 :         return ret;
     309                 :            : }
     310                 :            : EXPORT_SYMBOL_GPL(smpboot_register_percpu_thread);
     311                 :            : 
     312                 :            : /**
     313                 :            :  * smpboot_unregister_percpu_thread - Unregister a per_cpu thread related to hotplug
     314                 :            :  * @plug_thread:        Hotplug thread descriptor
     315                 :            :  *
     316                 :            :  * Stops all threads on all possible cpus.
     317                 :            :  */
     318                 :          0 : void smpboot_unregister_percpu_thread(struct smp_hotplug_thread *plug_thread)
     319                 :            : {
     320                 :            :         get_online_cpus();
     321                 :          0 :         mutex_lock(&smpboot_threads_lock);
     322                 :            :         list_del(&plug_thread->list);
     323                 :          0 :         smpboot_destroy_threads(plug_thread);
     324                 :          0 :         mutex_unlock(&smpboot_threads_lock);
     325                 :            :         put_online_cpus();
     326                 :          0 : }
     327                 :            : EXPORT_SYMBOL_GPL(smpboot_unregister_percpu_thread);
     328                 :            : 
     329                 :            : static DEFINE_PER_CPU(atomic_t, cpu_hotplug_state) = ATOMIC_INIT(CPU_POST_DEAD);
     330                 :            : 
     331                 :            : /*
     332                 :            :  * Called to poll specified CPU's state, for example, when waiting for
     333                 :            :  * a CPU to come online.
     334                 :            :  */
     335                 :          0 : int cpu_report_state(int cpu)
     336                 :            : {
     337                 :          0 :         return atomic_read(&per_cpu(cpu_hotplug_state, cpu));
     338                 :            : }
     339                 :            : 
     340                 :            : /*
     341                 :            :  * If CPU has died properly, set its state to CPU_UP_PREPARE and
     342                 :            :  * return success.  Otherwise, return -EBUSY if the CPU died after
     343                 :            :  * cpu_wait_death() timed out.  And yet otherwise again, return -EAGAIN
     344                 :            :  * if cpu_wait_death() timed out and the CPU still hasn't gotten around
     345                 :            :  * to dying.  In the latter two cases, the CPU might not be set up
     346                 :            :  * properly, but it is up to the arch-specific code to decide.
     347                 :            :  * Finally, -EIO indicates an unanticipated problem.
     348                 :            :  *
     349                 :            :  * Note that it is permissible to omit this call entirely, as is
     350                 :            :  * done in architectures that do no CPU-hotplug error checking.
     351                 :            :  */
     352                 :          0 : int cpu_check_up_prepare(int cpu)
     353                 :            : {
     354                 :            :         if (!IS_ENABLED(CONFIG_HOTPLUG_CPU)) {
     355                 :          0 :                 atomic_set(&per_cpu(cpu_hotplug_state, cpu), CPU_UP_PREPARE);
     356                 :            :                 return 0;
     357                 :            :         }
     358                 :            : 
     359                 :            :         switch (atomic_read(&per_cpu(cpu_hotplug_state, cpu))) {
     360                 :            : 
     361                 :            :         case CPU_POST_DEAD:
     362                 :            : 
     363                 :            :                 /* The CPU died properly, so just start it up again. */
     364                 :            :                 atomic_set(&per_cpu(cpu_hotplug_state, cpu), CPU_UP_PREPARE);
     365                 :            :                 return 0;
     366                 :            : 
     367                 :            :         case CPU_DEAD_FROZEN:
     368                 :            : 
     369                 :            :                 /*
     370                 :            :                  * Timeout during CPU death, so let caller know.
     371                 :            :                  * The outgoing CPU completed its processing, but after
     372                 :            :                  * cpu_wait_death() timed out and reported the error. The
     373                 :            :                  * caller is free to proceed, in which case the state
     374                 :            :                  * will be reset properly by cpu_set_state_online().
     375                 :            :                  * Proceeding despite this -EBUSY return makes sense
     376                 :            :                  * for systems where the outgoing CPUs take themselves
     377                 :            :                  * offline, with no post-death manipulation required from
     378                 :            :                  * a surviving CPU.
     379                 :            :                  */
     380                 :            :                 return -EBUSY;
     381                 :            : 
     382                 :            :         case CPU_BROKEN:
     383                 :            : 
     384                 :            :                 /*
     385                 :            :                  * The most likely reason we got here is that there was
     386                 :            :                  * a timeout during CPU death, and the outgoing CPU never
     387                 :            :                  * did complete its processing.  This could happen on
     388                 :            :                  * a virtualized system if the outgoing VCPU gets preempted
     389                 :            :                  * for more than five seconds, and the user attempts to
     390                 :            :                  * immediately online that same CPU.  Trying again later
     391                 :            :                  * might return -EBUSY above, hence -EAGAIN.
     392                 :            :                  */
     393                 :            :                 return -EAGAIN;
     394                 :            : 
     395                 :            :         default:
     396                 :            : 
     397                 :            :                 /* Should not happen.  Famous last words. */
     398                 :            :                 return -EIO;
     399                 :            :         }
     400                 :            : }
     401                 :            : 
     402                 :            : /*
     403                 :            :  * Mark the specified CPU online.
     404                 :            :  *
     405                 :            :  * Note that it is permissible to omit this call entirely, as is
     406                 :            :  * done in architectures that do no CPU-hotplug error checking.
     407                 :            :  */
     408                 :          0 : void cpu_set_state_online(int cpu)
     409                 :            : {
     410                 :          0 :         (void)atomic_xchg(&per_cpu(cpu_hotplug_state, cpu), CPU_ONLINE);
     411                 :          0 : }
     412                 :            : 
     413                 :            : #ifdef CONFIG_HOTPLUG_CPU
     414                 :            : 
     415                 :            : /*
     416                 :            :  * Wait for the specified CPU to exit the idle loop and die.
     417                 :            :  */
     418                 :            : bool cpu_wait_death(unsigned int cpu, int seconds)
     419                 :            : {
     420                 :            :         int jf_left = seconds * HZ;
     421                 :            :         int oldstate;
     422                 :            :         bool ret = true;
     423                 :            :         int sleep_jf = 1;
     424                 :            : 
     425                 :            :         might_sleep();
     426                 :            : 
     427                 :            :         /* The outgoing CPU will normally get done quite quickly. */
     428                 :            :         if (atomic_read(&per_cpu(cpu_hotplug_state, cpu)) == CPU_DEAD)
     429                 :            :                 goto update_state;
     430                 :            :         udelay(5);
     431                 :            : 
     432                 :            :         /* But if the outgoing CPU dawdles, wait increasingly long times. */
     433                 :            :         while (atomic_read(&per_cpu(cpu_hotplug_state, cpu)) != CPU_DEAD) {
     434                 :            :                 schedule_timeout_uninterruptible(sleep_jf);
     435                 :            :                 jf_left -= sleep_jf;
     436                 :            :                 if (jf_left <= 0)
     437                 :            :                         break;
     438                 :            :                 sleep_jf = DIV_ROUND_UP(sleep_jf * 11, 10);
     439                 :            :         }
     440                 :            : update_state:
     441                 :            :         oldstate = atomic_read(&per_cpu(cpu_hotplug_state, cpu));
     442                 :            :         if (oldstate == CPU_DEAD) {
     443                 :            :                 /* Outgoing CPU died normally, update state. */
     444                 :            :                 smp_mb(); /* atomic_read() before update. */
     445                 :            :                 atomic_set(&per_cpu(cpu_hotplug_state, cpu), CPU_POST_DEAD);
     446                 :            :         } else {
     447                 :            :                 /* Outgoing CPU still hasn't died, set state accordingly. */
     448                 :            :                 if (atomic_cmpxchg(&per_cpu(cpu_hotplug_state, cpu),
     449                 :            :                                    oldstate, CPU_BROKEN) != oldstate)
     450                 :            :                         goto update_state;
     451                 :            :                 ret = false;
     452                 :            :         }
     453                 :            :         return ret;
     454                 :            : }
     455                 :            : 
     456                 :            : /*
     457                 :            :  * Called by the outgoing CPU to report its successful death.  Return
     458                 :            :  * false if this report follows the surviving CPU's timing out.
     459                 :            :  *
     460                 :            :  * A separate "CPU_DEAD_FROZEN" is used when the surviving CPU
     461                 :            :  * timed out.  This approach allows architectures to omit calls to
     462                 :            :  * cpu_check_up_prepare() and cpu_set_state_online() without defeating
     463                 :            :  * the next cpu_wait_death()'s polling loop.
     464                 :            :  */
     465                 :            : bool cpu_report_death(void)
     466                 :            : {
     467                 :            :         int oldstate;
     468                 :            :         int newstate;
     469                 :            :         int cpu = smp_processor_id();
     470                 :            : 
     471                 :            :         do {
     472                 :            :                 oldstate = atomic_read(&per_cpu(cpu_hotplug_state, cpu));
     473                 :            :                 if (oldstate != CPU_BROKEN)
     474                 :            :                         newstate = CPU_DEAD;
     475                 :            :                 else
     476                 :            :                         newstate = CPU_DEAD_FROZEN;
     477                 :            :         } while (atomic_cmpxchg(&per_cpu(cpu_hotplug_state, cpu),
     478                 :            :                                 oldstate, newstate) != oldstate);
     479                 :            :         return newstate == CPU_DEAD;
     480                 :            : }
     481                 :            : 
     482                 :            : #endif /* #ifdef CONFIG_HOTPLUG_CPU */