1 files changed, 84 insertions, 17 deletions

diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
index 5a574296ace..a07ca050112 100644
--- a/arch/arm/kernel/smp.c
+++ b/arch/arm/kernel/smp.c
@@ -27,7 +27,7 @@
 #include <linux/clockchips.h>
 #include <linux/completion.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/cacheflush.h>
 #include <asm/cpu.h>
 #include <asm/cputype.h>
@@ -55,6 +55,7 @@ enum ipi_msg_type {
         IPI_CALL_FUNC,
         IPI_CALL_FUNC_SINGLE,
         IPI_CPU_STOP,
+        IPI_CPU_BACKTRACE,
 };
 
 int __cpuinit __cpu_up(unsigned int cpu)
@@ -303,17 +304,7 @@ asmlinkage void __cpuinit secondary_start_kernel(void)
          */
         platform_secondary_init(cpu);
 
-        /*
-         * Enable local interrupts.
-         */
         notify_cpu_starting(cpu);
-        local_irq_enable();
-        local_fiq_enable();
-
-        /*
-         * Setup the percpu timer for this CPU.
-         */
-        percpu_timer_setup();
 
         calibrate_delay();
 
@@ -325,8 +316,14 @@ asmlinkage void __cpuinit secondary_start_kernel(void)
          * before we continue.
          */
         set_cpu_online(cpu, true);
-        while (!cpu_active(cpu))
-                cpu_relax();
+
+        /*
+         * Setup the percpu timer for this CPU.
+         */
+        percpu_timer_setup();
+
+        local_irq_enable();
+        local_fiq_enable();
 
         /*
          * OK, it's off to the idle thread for us
@@ -367,8 +364,7 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
          */
         if (max_cpus > ncores)
                 max_cpus = ncores;
-
-        if (max_cpus > 1) {
+        if (ncores > 1 && max_cpus) {
                 /*
                  * Enable the local timer or broadcast device for the
                  * boot CPU, but only if we have more than one CPU.
@@ -376,6 +372,14 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
                 percpu_timer_setup();
 
                 /*
+                 * Initialise the present map, which describes the set of CPUs
+                 * actually populated at the present time. A platform should
+                 * re-initialize the map in platform_smp_prepare_cpus() if
+                 * present != possible (e.g. physical hotplug).
+                 */
+                init_cpu_present(&cpu_possible_map);
+
+                /*
                  * Initialise the SCU if there are more than one CPU
                  * and let them know where to start.
                  */
@@ -407,6 +411,7 @@ static const char *ipi_types[NR_IPI] = {
         S(IPI_CALL_FUNC, "Function call interrupts"),
         S(IPI_CALL_FUNC_SINGLE, "Single function call interrupts"),
         S(IPI_CPU_STOP, "CPU stop interrupts"),
+        S(IPI_CPU_BACKTRACE, "CPU backtrace"),
 };
 
 void show_ipi_list(struct seq_file *p, int prec)
@@ -447,9 +452,7 @@ static DEFINE_PER_CPU(struct clock_event_device, percpu_clockevent);
 static void ipi_timer(void)
 {
         struct clock_event_device *evt = &__get_cpu_var(percpu_clockevent);
-        irq_enter();
         evt->event_handler(evt);
-        irq_exit();
 }
 
 #ifdef CONFIG_LOCAL_TIMERS
@@ -557,6 +560,58 @@ static void ipi_cpu_stop(unsigned int cpu)
                 cpu_relax();
 }
 
+static cpumask_t backtrace_mask;
+static DEFINE_RAW_SPINLOCK(backtrace_lock);
+
+/* "in progress" flag of arch_trigger_all_cpu_backtrace */
+static unsigned long backtrace_flag;
+
+void smp_send_all_cpu_backtrace(void)
+{
+        unsigned int this_cpu = smp_processor_id();
+        int i;
+
+        if (test_and_set_bit(0, &backtrace_flag))
+                /*
+                 * If there is already a trigger_all_cpu_backtrace() in progress
+                 * (backtrace_flag == 1), don't output double cpu dump infos.
+                 */
+                return;
+
+        cpumask_copy(&backtrace_mask, cpu_online_mask);
+        cpu_clear(this_cpu, backtrace_mask);
+
+        pr_info("Backtrace for cpu %d (current):\n", this_cpu);
+        dump_stack();
+
+        pr_info("\nsending IPI to all other CPUs:\n");
+        smp_cross_call(&backtrace_mask, IPI_CPU_BACKTRACE);
+
+        /* Wait for up to 10 seconds for all other CPUs to do the backtrace */
+        for (i = 0; i < 10 * 1000; i++) {
+                if (cpumask_empty(&backtrace_mask))
+                        break;
+                mdelay(1);
+        }
+
+        clear_bit(0, &backtrace_flag);
+        smp_mb__after_clear_bit();
+}
+
+/*
+ * ipi_cpu_backtrace - handle IPI from smp_send_all_cpu_backtrace()
+ */
+static void ipi_cpu_backtrace(unsigned int cpu, struct pt_regs *regs)
+{
+        if (cpu_isset(cpu, backtrace_mask)) {
+                raw_spin_lock(&backtrace_lock);
+                pr_warning("IPI backtrace for cpu %d\n", cpu);
+                show_regs(regs);
+                raw_spin_unlock(&backtrace_lock);
+                cpu_clear(cpu, backtrace_mask);
+        }
+}
+
 /*
  * Main handler for inter-processor interrupts
  */
@@ -570,7 +625,9 @@ asmlinkage void __exception_irq_entry do_IPI(int ipinr, struct pt_regs *regs)
 
         switch (ipinr) {
         case IPI_TIMER:
+                irq_enter();
                 ipi_timer();
+                irq_exit();
                 break;
 
         case IPI_RESCHEDULE:
@@ -580,15 +637,25 @@ asmlinkage void __exception_irq_entry do_IPI(int ipinr, struct pt_regs *regs)
                 break;
 
         case IPI_CALL_FUNC:
+                irq_enter();
                 generic_smp_call_function_interrupt();
+                irq_exit();
                 break;
 
         case IPI_CALL_FUNC_SINGLE:
+                irq_enter();
                 generic_smp_call_function_single_interrupt();
+                irq_exit();
                 break;
 
         case IPI_CPU_STOP:
+                irq_enter();
                 ipi_cpu_stop(cpu);
+                irq_exit();
+                break;
+
+        case IPI_CPU_BACKTRACE:
+                ipi_cpu_backtrace(cpu, regs);
                 break;
 
         default: