Merge branch 'x86/crashdump' into cpus4096

Conflicts:
	arch/x86/kernel/crash.c

Merged for semantic conflict:
	arch/x86/kernel/reboot.c

diff --cc arch/x86/kernel/reboot.c
index 0e3dbc7,c3cd512..ba7b9a0
--- 1/arch/x86/kernel/reboot.c
--- 2/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@@ -548,3 -517,95 +551,92 @@@ void machine_crash_shutdown(struct pt_r
        machine_ops.crash_shutdown(regs);
  }
  #endif
 -      cpumask_t mask = cpu_online_map;
 -      cpu_clear(safe_smp_processor_id(), mask);
 -      if (!cpus_empty(mask))
 -              send_IPI_mask(mask, NMI_VECTOR);
+ 
+ 
+ #if defined(CONFIG_SMP)
+ 
+ /* This keeps a track of which one is crashing cpu. */
+ static int crashing_cpu;
+ static nmi_shootdown_cb shootdown_callback;
+ 
+ static atomic_t waiting_for_crash_ipi;
+ 
+ static int crash_nmi_callback(struct notifier_block *self,
+                       unsigned long val, void *data)
+ {
+       int cpu;
+ 
+       if (val != DIE_NMI_IPI)
+               return NOTIFY_OK;
+ 
+       cpu = raw_smp_processor_id();
+ 
+       /* Don't do anything if this handler is invoked on crashing cpu.
+        * Otherwise, system will completely hang. Crashing cpu can get
+        * an NMI if system was initially booted with nmi_watchdog parameter.
+        */
+       if (cpu == crashing_cpu)
+               return NOTIFY_STOP;
+       local_irq_disable();
+ 
+       shootdown_callback(cpu, (struct die_args *)data);
+ 
+       atomic_dec(&waiting_for_crash_ipi);
+       /* Assume hlt works */
+       halt();
+       for (;;)
+               cpu_relax();
+ 
+       return 1;
+ }
+ 
+ static void smp_send_nmi_allbutself(void)
+ {
++      send_IPI_allbutself(NMI_VECTOR);
+ }
+ 
+ static struct notifier_block crash_nmi_nb = {
+       .notifier_call = crash_nmi_callback,
+ };
+ 
+ /* Halt all other CPUs, calling the specified function on each of them
+  *
+  * This function can be used to halt all other CPUs on crash
+  * or emergency reboot time. The function passed as parameter
+  * will be called inside a NMI handler on all CPUs.
+  */
+ void nmi_shootdown_cpus(nmi_shootdown_cb callback)
+ {
+       unsigned long msecs;
+       local_irq_disable();
+ 
+       /* Make a note of crashing cpu. Will be used in NMI callback.*/
+       crashing_cpu = safe_smp_processor_id();
+ 
+       shootdown_callback = callback;
+ 
+       atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
+       /* Would it be better to replace the trap vector here? */
+       if (register_die_notifier(&crash_nmi_nb))
+               return;         /* return what? */
+       /* Ensure the new callback function is set before sending
+        * out the NMI
+        */
+       wmb();
+ 
+       smp_send_nmi_allbutself();
+ 
+       msecs = 1000; /* Wait at most a second for the other cpus to stop */
+       while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) {
+               mdelay(1);
+               msecs--;
+       }
+ 
+       /* Leave the nmi callback set */
+ }
+ #else /* !CONFIG_SMP */
+ void nmi_shootdown_cpus(nmi_shootdown_cb callback)
+ {
+       /* No other CPUs to shoot down */
+ }
+ #endif