Merge branch 'smp-hotplug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[deliverable/linux.git] / kernel / cpu.c

diff --git a/kernel/cpu.c b/kernel/cpu.c
index f1f880fac83217dfcb6cc7a3b0446ee50f36d89a..6ea42e8da861b05077d01a23e15bb140afffa605 100644 (file)
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -688,6 +688,7 @@ static int take_cpu_down(void *_param)
 
 static int takedown_cpu(unsigned int cpu)
 {
+       struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
        int err;
 
        /*
@@ -705,8 +706,9 @@ static int takedown_cpu(unsigned int cpu)
        else
                synchronize_rcu();
 
-       /* Park the hotplug thread */
+       /* Park the smpboot threads */
        kthread_park(per_cpu_ptr(&cpuhp_state, cpu)->thread);
+       smpboot_park_threads(cpu);
 
        /*
         * Prevent irq alloc/free while the dying cpu reorganizes the
@@ -733,10 +735,8 @@ static int takedown_cpu(unsigned int cpu)
         *
         * Wait for the stop thread to go away.
         */
-       while (!per_cpu(cpu_dead_idle, cpu))
-               cpu_relax();
-       smp_mb(); /* Read from cpu_dead_idle before __cpu_die(). */
-       per_cpu(cpu_dead_idle, cpu) = false;
+       wait_for_completion(&st->done);
+       BUG_ON(st->state != CPUHP_AP_IDLE_DEAD);
 
        /* Interrupts are moved away from the dying cpu, reenable alloc/free */
        irq_unlock_sparse();
@@ -756,6 +756,28 @@ static int notify_dead(unsigned int cpu)
        return 0;
 }
 
+static void cpuhp_complete_idle_dead(void *arg)
+{
+       struct cpuhp_cpu_state *st = arg;
+
+       complete(&st->done);
+}
+
+void cpuhp_report_idle_dead(void)
+{
+       struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
+
+       BUG_ON(st->state != CPUHP_AP_OFFLINE);
+       rcu_report_dead(smp_processor_id());
+       st->state = CPUHP_AP_IDLE_DEAD;
+       /*
+        * We cannot call complete after rcu_report_dead() so we delegate it
+        * to an online cpu.
+        */
+       smp_call_function_single(cpumask_first(cpu_online_mask),
+                                cpuhp_complete_idle_dead, st, 0);
+}
+
 #else
 #define notify_down_prepare    NULL
 #define takedown_cpu           NULL
@@ -1150,6 +1172,10 @@ static struct cpuhp_step cpuhp_bp_states[] = {
                .teardown               = NULL,
                .cant_stop              = true,
        },
+       /*
+        * Preparatory and dead notifiers. Will be replaced once the notifiers
+        * are converted to states.
+        */
        [CPUHP_NOTIFY_PREPARE] = {
                .name                   = "notify:prepare",
                .startup                = notify_prepare,
@@ -1157,12 +1183,17 @@ static struct cpuhp_step cpuhp_bp_states[] = {
                .skip_onerr             = true,
                .cant_stop              = true,
        },
+       /* Kicks the plugged cpu into life */
        [CPUHP_BRINGUP_CPU] = {
                .name                   = "cpu:bringup",
                .startup                = bringup_cpu,
                .teardown               = NULL,
                .cant_stop              = true,
        },
+       /*
+        * Handled on controll processor until the plugged processor manages
+        * this itself.
+        */
        [CPUHP_TEARDOWN_CPU] = {
                .name                   = "cpu:teardown",
                .startup                = NULL,
@@ -1175,6 +1206,23 @@ static struct cpuhp_step cpuhp_bp_states[] = {
 /* Application processor state steps */
 static struct cpuhp_step cpuhp_ap_states[] = {
 #ifdef CONFIG_SMP
+       /* Final state before CPU kills itself */
+       [CPUHP_AP_IDLE_DEAD] = {
+               .name                   = "idle:dead",
+       },
+       /*
+        * Last state before CPU enters the idle loop to die. Transient state
+        * for synchronization.
+        */
+       [CPUHP_AP_OFFLINE] = {
+               .name                   = "ap:offline",
+               .cant_stop              = true,
+       },
+       /*
+        * Low level startup/teardown notifiers. Run with interrupts
+        * disabled. Will be removed once the notifiers are converted to
+        * states.
+        */
        [CPUHP_AP_NOTIFY_STARTING] = {
                .name                   = "notify:starting",
                .startup                = notify_starting,
@@ -1182,17 +1230,32 @@ static struct cpuhp_step cpuhp_ap_states[] = {
                .skip_onerr             = true,
                .cant_stop              = true,
        },
+       /* Entry state on starting. Interrupts enabled from here on. Transient
+        * state for synchronsization */
+       [CPUHP_AP_ONLINE] = {
+               .name                   = "ap:online",
+       },
+       /* Handle smpboot threads park/unpark */
        [CPUHP_AP_SMPBOOT_THREADS] = {
                .name                   = "smpboot:threads",
                .startup                = smpboot_unpark_threads,
-               .teardown               = smpboot_park_threads,
+               .teardown               = NULL,
        },
+       /*
+        * Online/down_prepare notifiers. Will be removed once the notifiers
+        * are converted to states.
+        */
        [CPUHP_AP_NOTIFY_ONLINE] = {
                .name                   = "notify:online",
                .startup                = notify_online,
                .teardown               = notify_down_prepare,
        },
 #endif
+       /*
+        * The dynamically registered state space is here
+        */
+
+       /* CPU is fully up and running. */
        [CPUHP_ONLINE] = {
                .name                   = "online",
                .startup                = NULL,
@@ -1210,9 +1273,11 @@ static int cpuhp_cb_check(enum cpuhp_state state)
 
 static bool cpuhp_is_ap_state(enum cpuhp_state state)
 {
-       if (state >= CPUHP_AP_OFFLINE && state <= CPUHP_AP_ONLINE)
-               return true;
-       return state > CPUHP_BRINGUP_CPU;
+       /*
+        * The extra check for CPUHP_TEARDOWN_CPU is only for documentation
+        * purposes as that state is handled explicitely in cpu_down.
+        */
+       return state > CPUHP_BRINGUP_CPU && state != CPUHP_TEARDOWN_CPU;
 }
 
 static struct cpuhp_step *cpuhp_get_step(enum cpuhp_state state)