[PATCH] kdump: save registers early (inline functions)

- If system panics then cpu register states are captured through funciton
  crash_get_current_regs().  This is not a inline function hence a stack frame
  is pushed on to the stack and then cpu register state is captured.  Later
  this frame is popped and new frames are pushed (machine_kexec).

- In theory this is not very right as we are capturing register states for a
  frame and that frame is no more valid.  This seems to have created back
  trace problems for ppc64.

- This patch fixes it up.  The very first thing it does after entering
  crash_kexec() is to capture the register states.  Anyway we don't want the
  back trace beyond crash_kexec().  crash_get_current_regs() has been made
  inline

- crash_setup_regs() is the top architecture dependent function which should
  be responsible for capturing the register states as well as to do some
  architecture dependent tricks.  For ex.  fixing up ss and esp for i386.
  crash_setup_regs() has also been made inline to ensure no new call frame is
  pushed onto stack.

Signed-off-by: Vivek Goyal <vgoyal@in.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 3 insertions, 44 deletions

diff --git a/arch/i386/kernel/crash.c b/arch/i386/kernel/crash.c
index f1e65c2ead6e..d49dbe8dc96b 100644
--- a/arch/i386/kernel/crash.c
+++ b/arch/i386/kernel/crash.c
@@ -82,53 +82,12 @@ static void crash_save_this_cpu(struct pt_regs *regs, int cpu)
         final_note(buf);
 }
 
-static void crash_get_current_regs(struct pt_regs *regs)
+static void crash_save_self(struct pt_regs *regs)
 {
-        __asm__ __volatile__("movl %%ebx,%0" : "=m"(regs->ebx));
-        __asm__ __volatile__("movl %%ecx,%0" : "=m"(regs->ecx));
-        __asm__ __volatile__("movl %%edx,%0" : "=m"(regs->edx));
-        __asm__ __volatile__("movl %%esi,%0" : "=m"(regs->esi));
-        __asm__ __volatile__("movl %%edi,%0" : "=m"(regs->edi));
-        __asm__ __volatile__("movl %%ebp,%0" : "=m"(regs->ebp));
-        __asm__ __volatile__("movl %%eax,%0" : "=m"(regs->eax));
-        __asm__ __volatile__("movl %%esp,%0" : "=m"(regs->esp));
-        __asm__ __volatile__("movw %%ss, %%ax;" :"=a"(regs->xss));
-        __asm__ __volatile__("movw %%cs, %%ax;" :"=a"(regs->xcs));
-        __asm__ __volatile__("movw %%ds, %%ax;" :"=a"(regs->xds));
-        __asm__ __volatile__("movw %%es, %%ax;" :"=a"(regs->xes));
-        __asm__ __volatile__("pushfl; popl %0" :"=m"(regs->eflags));
-
-        regs->eip = (unsigned long)current_text_addr();
-}
-
-/* CPU does not save ss and esp on stack if execution is already
- * running in kernel mode at the time of NMI occurrence. This code
- * fixes it.
- */
-static void crash_setup_regs(struct pt_regs *newregs, struct pt_regs *oldregs)
-{
-        memcpy(newregs, oldregs, sizeof(*newregs));
-        newregs->esp = (unsigned long)&(oldregs->esp);
-        __asm__ __volatile__(
-                        "xorl %%eax, %%eax\n\t"
-                        "movw %%ss, %%ax\n\t"
-                        :"=a"(newregs->xss));
-}
-
-/* We may have saved_regs from where the error came from
- * or it is NULL if via a direct panic().
- */
-static void crash_save_self(struct pt_regs *saved_regs)
-{
-        struct pt_regs regs;
         int cpu;
 
         cpu = smp_processor_id();
-        if (saved_regs)
-                crash_setup_regs(&regs, saved_regs);
-        else
-                crash_get_current_regs(&regs);
-        crash_save_this_cpu(&regs, cpu);
+        crash_save_this_cpu(regs, cpu);
 }
 
 #ifdef CONFIG_SMP
@@ -147,7 +106,7 @@ static int crash_nmi_callback(struct pt_regs *regs, int cpu)
         local_irq_disable();
 
         if (!user_mode(regs)) {
-                crash_setup_regs(&fixed_regs, regs);
+                crash_fixup_ss_esp(&fixed_regs, regs);
                 regs = &fixed_regs;
         }
         crash_save_this_cpu(regs, cpu);