smp, idle: Allocate idle thread for each possible cpu during boot

percpu areas are already allocated during boot for each possible cpu.
percpu idle threads can be considered as an extension of the percpu areas,
and allocate them for each possible cpu during boot.

This will eliminate the need for workqueue based idle thread allocation.
In future we can move the idle thread area into the percpu area too.

[ tglx: Moved the loop into smpboot.c and added an error check when
  the init code failed to allocate an idle thread for a cpu which
  should be onlined ]

Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: David Rientjes <rientjes@google.com>
Cc: venki@google.com
Link: http://lkml.kernel.org/r/1334966930.28674.245.camel@sbsiddha-desk.sc.intel.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

diff --git a/kernel/cpu.c b/kernel/cpu.c
index 05c46bae5e55ba920d342e9e0247d65f4d76e36a..0e6353cf147abf51c4f760054971915063ece928 100644 (file)
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -297,15 +297,18 @@ static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
        int ret, nr_calls = 0;
        void *hcpu = (void *)(long)cpu;
        unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
+       struct task_struct *idle;
 
        if (cpu_online(cpu) || !cpu_present(cpu))
                return -EINVAL;
 
        cpu_hotplug_begin();
 
-       ret = smpboot_prepare(cpu);
-       if (ret)
+       idle = idle_thread_get(cpu);
+       if (IS_ERR(idle)) {
+               ret = PTR_ERR(idle);
                goto out;
+       }
 
        ret = __cpu_notify(CPU_UP_PREPARE | mod, hcpu, -1, &nr_calls);
        if (ret) {
@@ -316,7 +319,7 @@ static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
        }
 
        /* Arch-specific enabling code. */
-       ret = __cpu_up(cpu, idle_thread_get(cpu));
+       ret = __cpu_up(cpu, idle);
        if (ret != 0)
                goto out_notify;
        BUG_ON(!cpu_online(cpu));

diff --git a/kernel/smp.c b/kernel/smp.c
index 2f8b10ecf75996c1bf40feb78bf2a0c1d5471489..a61294c07f3f005aa041721b9f2b83e3026a81bf 100644 (file)
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -13,6 +13,8 @@
 #include <linux/smp.h>
 #include <linux/cpu.h>
 
+#include "smpboot.h"
+
 #ifdef CONFIG_USE_GENERIC_SMP_HELPERS
 static struct {
        struct list_head        queue;
@@ -669,6 +671,8 @@ void __init smp_init(void)
 {
        unsigned int cpu;
 
+       idle_threads_init();
+
        /* FIXME: This should be done in userspace --RR */
        for_each_present_cpu(cpu) {
                if (num_online_cpus() >= setup_max_cpus)

diff --git a/kernel/smpboot.c b/kernel/smpboot.c
index ed1576981801858a9e83185d018d716194d69084..e1a797e028a320d62c01e77a47f533e0998adaa3 100644 (file)
--- a/kernel/smpboot.c
+++ b/kernel/smpboot.c
@@ -6,64 +6,42 @@
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/percpu.h>
-#include <linux/workqueue.h>
 
 #include "smpboot.h"
 
 #ifdef CONFIG_GENERIC_SMP_IDLE_THREAD
-struct create_idle {
-       struct work_struct      work;
-       struct task_struct      *idle;
-       struct completion       done;
-       unsigned int cpu;
-};
-
-static void __cpuinit do_fork_idle(struct work_struct *work)
-{
-       struct create_idle *c = container_of(work, struct create_idle, work);
-
-       c->idle = fork_idle(c->cpu);
-       complete(&c->done);
-}
-
-static struct task_struct * __cpuinit idle_thread_create(unsigned int cpu)
-{
-       struct create_idle c_idle = {
-               .cpu    = cpu,
-               .done   = COMPLETION_INITIALIZER_ONSTACK(c_idle.done),
-       };
-
-       INIT_WORK_ONSTACK(&c_idle.work, do_fork_idle);
-       schedule_work(&c_idle.work);
-       wait_for_completion(&c_idle.done);
-       destroy_work_on_stack(&c_idle.work);
-       return c_idle.idle;
-}
-
 /*
  * For the hotplug case we keep the task structs around and reuse
  * them.
  */
 static DEFINE_PER_CPU(struct task_struct *, idle_threads);
 
-static inline struct task_struct *get_idle_for_cpu(unsigned int cpu)
+struct task_struct * __cpuinit idle_thread_get(unsigned int cpu)
 {
        struct task_struct *tsk = per_cpu(idle_threads, cpu);
 
        if (!tsk)
-               return idle_thread_create(cpu);
+               return ERR_PTR(-ENOMEM);
        init_idle(tsk, cpu);
        return tsk;
 }
 
-struct task_struct * __cpuinit idle_thread_get(unsigned int cpu)
+void __init idle_thread_set_boot_cpu(void)
 {
-       return per_cpu(idle_threads, cpu);
+       per_cpu(idle_threads, smp_processor_id()) = current;
 }
 
-void __init idle_thread_set_boot_cpu(void)
+static inline void idle_init(unsigned int cpu)
 {
-       per_cpu(idle_threads, smp_processor_id()) = current;
+       struct task_struct *tsk = per_cpu(idle_threads, cpu);
+
+       if (!tsk) {
+               tsk = fork_idle(cpu);
+               if (IS_ERR(tsk))
+                       pr_err("SMP: fork_idle() failed for CPU %u\n", cpu);
+               else
+                       per_cpu(idle_threads, cpu) = tsk;
+       }
 }
 
 /**
@@ -72,25 +50,13 @@ void __init idle_thread_set_boot_cpu(void)
  *
  * Creates the thread if it does not exist.
  */
-static int __cpuinit idle_thread_init(unsigned int cpu)
+void __init idle_threads_init(void)
 {
-       struct task_struct *idle = get_idle_for_cpu(cpu);
+       unsigned int cpu;
 
-       if (IS_ERR(idle)) {
-               printk(KERN_ERR "failed fork for CPU %u\n", cpu);
-               return PTR_ERR(idle);
+       for_each_possible_cpu(cpu) {
+               if (cpu != smp_processor_id())
+                       idle_init(cpu);
        }
-       per_cpu(idle_threads, cpu) = idle;
-       return 0;
 }
-#else
-static inline int idle_thread_init(unsigned int cpu) { return 0; }
 #endif
-
-/**
- * smpboot_prepare - generic smpboot preparation
- */
-int __cpuinit smpboot_prepare(unsigned int cpu)
-{
-       return idle_thread_init(cpu);
-}

diff --git a/kernel/smpboot.h b/kernel/smpboot.h
index 7943bbbab917fcdfb7cd9220fde6c3009b397534..4cfbcb8a8362ad3ae480b824a01bf434f7e21f75 100644 (file)
--- a/kernel/smpboot.h
+++ b/kernel/smpboot.h
@@ -8,9 +8,11 @@ int smpboot_prepare(unsigned int cpu);
 #ifdef CONFIG_GENERIC_SMP_IDLE_THREAD
 struct task_struct *idle_thread_get(unsigned int cpu);
 void idle_thread_set_boot_cpu(void);
+void idle_threads_init(void);
 #else
 static inline struct task_struct *idle_thread_get(unsigned int cpu) { return NULL; }
 static inline void idle_thread_set_boot_cpu(void) { }
+static inline void idle_threads_init(unsigned int cpu) { }
 #endif
 
 #endif