From: Alexander Nyberg Makes kexec_crashdump() take a pt_regs * as an argument. This allows to get exact register state at the point of the crash. If we come from direct panic assertion NULL will be passed and the current registers saved before crashdump. This hooks into two places: die(): check the conditions under which we will panic when calling do_exit and go there directly with the pt_regs that caused the fatal fault. die_nmi(): If we receive an NMI lockup while in the kernel use the pt_regs and go directly to crash_kexec(). We're probably nested up badly at this point so this might be the only chance to escape with proper information. Signed-off-by: Alexander Nyberg Cc: Signed-off-by: Andrew Morton --- arch/i386/kernel/crash.c | 36 ++++++++++++++++++++++++------------ arch/i386/kernel/traps.c | 17 +++++++++++++++++ drivers/char/sysrq.c | 2 +- include/linux/kexec.h | 6 ++++-- include/linux/reboot.h | 2 +- kernel/kexec.c | 11 +++++++++-- kernel/panic.c | 2 +- 7 files changed, 57 insertions(+), 19 deletions(-) diff -puN arch/i386/kernel/crash.c~kdump-use-real-pt_regs-from-exception arch/i386/kernel/crash.c --- 25/arch/i386/kernel/crash.c~kdump-use-real-pt_regs-from-exception 2005-05-25 00:53:55.000000000 -0700 +++ 25-akpm/arch/i386/kernel/crash.c 2005-05-25 00:53:55.000000000 -0700 @@ -100,12 +100,31 @@ static void crash_get_current_regs(struc regs->eip = (unsigned long)current_text_addr(); } -static void crash_save_self(void) +/* 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;"); + __asm__ __volatile__ ("movw %%ss, %%ax;" :"=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(); - crash_get_current_regs(®s); + + if (saved_regs) + crash_setup_regs(®s, saved_regs); + else + crash_get_current_regs(®s); crash_save_this_cpu(®s, cpu); } @@ -124,15 +143,8 @@ static int crash_nmi_callback(struct pt_ return 1; local_irq_disable(); - /* 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. - */ if (!user_mode(regs)) { - memcpy(&fixed_regs, regs, sizeof(*regs)); - fixed_regs.esp = (unsigned long)&(regs->esp); - __asm__ __volatile__("xorl %eax, %eax;"); - __asm__ __volatile__ ("movw %%ss, %%ax;" :"=a"(fixed_regs.xss)); + crash_setup_regs(&fixed_regs, regs); regs = &fixed_regs; } crash_save_this_cpu(regs, cpu); @@ -184,7 +196,7 @@ static void nmi_shootdown_cpus(void) } #endif -void machine_crash_shutdown(void) +void machine_crash_shutdown(struct pt_regs *regs) { /* This function is only called after the system * has paniced or is otherwise in a critical state. @@ -204,5 +216,5 @@ void machine_crash_shutdown(void) #if defined(CONFIG_X86_IO_APIC) disable_IO_APIC(); #endif - crash_save_self(); + crash_save_self(regs); } diff -puN arch/i386/kernel/traps.c~kdump-use-real-pt_regs-from-exception arch/i386/kernel/traps.c --- 25/arch/i386/kernel/traps.c~kdump-use-real-pt_regs-from-exception 2005-05-25 00:53:55.000000000 -0700 +++ 25-akpm/arch/i386/kernel/traps.c 2005-05-25 00:53:55.000000000 -0700 @@ -27,6 +27,7 @@ #include #include #include +#include #ifdef CONFIG_EISA #include @@ -327,6 +328,9 @@ bug: printk("Kernel BUG\n"); } +/* This is gone through when something in the kernel + * has done something bad and is about to be terminated. +*/ void die(const char * str, struct pt_regs * regs, long err) { static struct { @@ -383,6 +387,10 @@ void die(const char * str, struct pt_reg bust_spinlocks(0); die.lock_owner = -1; spin_unlock_irq(&die.lock); + + if (kexec_should_crash(current)) + crash_kexec(regs); + if (in_interrupt()) panic("Fatal exception in interrupt"); @@ -617,6 +625,15 @@ void die_nmi (struct pt_regs *regs, cons console_silent(); spin_unlock(&nmi_print_lock); bust_spinlocks(0); + + /* If we are in kernel we are probably nested up pretty bad + * and might aswell get out now while we still can. + */ + if (!user_mode(regs)) { + current->thread.trap_no = 2; + crash_kexec(regs); + } + do_exit(SIGSEGV); } diff -puN drivers/char/sysrq.c~kdump-use-real-pt_regs-from-exception drivers/char/sysrq.c --- 25/drivers/char/sysrq.c~kdump-use-real-pt_regs-from-exception 2005-05-25 00:53:55.000000000 -0700 +++ 25-akpm/drivers/char/sysrq.c 2005-05-25 00:53:55.000000000 -0700 @@ -119,7 +119,7 @@ static struct sysrq_key_op sysrq_unraw_o static void sysrq_handle_crashdump(int key, struct pt_regs *pt_regs, struct tty_struct *tty) { - crash_kexec(); + crash_kexec(pt_regs); } static struct sysrq_key_op sysrq_crashdump_op = { .handler = sysrq_handle_crashdump, diff -puN include/linux/kexec.h~kdump-use-real-pt_regs-from-exception include/linux/kexec.h --- 25/include/linux/kexec.h~kdump-use-real-pt_regs-from-exception 2005-05-25 00:53:55.000000000 -0700 +++ 25-akpm/include/linux/kexec.h 2005-05-25 00:53:55.000000000 -0700 @@ -99,7 +99,8 @@ extern asmlinkage long compat_sys_kexec_ unsigned long flags); #endif extern struct page *kimage_alloc_control_pages(struct kimage *image, unsigned int order); -extern void crash_kexec(void); +extern void crash_kexec(struct pt_regs *); +int kexec_should_crash(struct task_struct *); extern struct kimage *kexec_image; #define KEXEC_ON_CRASH 0x00000001 @@ -123,6 +124,7 @@ extern struct kimage *kexec_image; extern struct resource crashk_res; #else /* !CONFIG_KEXEC */ -static inline void crash_kexec(void) { } +static inline void crash_kexec(struct pt_regs *regs) { } +static inline int kexec_should_crash(struct task_struct *p) { return 0; } #endif /* CONFIG_KEXEC */ #endif /* LINUX_KEXEC_H */ diff -puN include/linux/reboot.h~kdump-use-real-pt_regs-from-exception include/linux/reboot.h --- 25/include/linux/reboot.h~kdump-use-real-pt_regs-from-exception 2005-05-25 00:53:55.000000000 -0700 +++ 25-akpm/include/linux/reboot.h 2005-05-25 00:53:55.000000000 -0700 @@ -52,7 +52,7 @@ extern void machine_halt(void); extern void machine_power_off(void); extern void machine_shutdown(void); -extern void machine_crash_shutdown(void); +extern void machine_crash_shutdown(struct pt_regs *); #endif diff -puN kernel/kexec.c~kdump-use-real-pt_regs-from-exception kernel/kexec.c --- 25/kernel/kexec.c~kdump-use-real-pt_regs-from-exception 2005-05-25 00:53:55.000000000 -0700 +++ 25-akpm/kernel/kexec.c 2005-05-25 00:53:55.000000000 -0700 @@ -32,6 +32,13 @@ struct resource crashk_res = { .flags = IORESOURCE_BUSY | IORESOURCE_MEM }; +int kexec_should_crash(struct task_struct *p) +{ + if (in_interrupt() || !p->pid || p->pid == 1 || panic_on_oops) + return 1; + return 0; +} + /* * When kexec transitions to the new kernel there is a one-to-one * mapping between physical and virtual addresses. On processors @@ -1010,7 +1017,7 @@ asmlinkage long compat_sys_kexec_load(un } #endif -void crash_kexec(void) +void crash_kexec(struct pt_regs *regs) { struct kimage *image; int locked; @@ -1028,7 +1035,7 @@ void crash_kexec(void) if (!locked) { image = xchg(&kexec_crash_image, NULL); if (image) { - machine_crash_shutdown(); + machine_crash_shutdown(regs); machine_kexec(image); } xchg(&kexec_lock, 0); diff -puN kernel/panic.c~kdump-use-real-pt_regs-from-exception kernel/panic.c --- 25/kernel/panic.c~kdump-use-real-pt_regs-from-exception 2005-05-25 00:53:55.000000000 -0700 +++ 25-akpm/kernel/panic.c 2005-05-25 00:53:55.000000000 -0700 @@ -83,7 +83,7 @@ NORET_TYPE void panic(const char * fmt, * everything else. * Do we want to call this before we try to display a message? */ - crash_kexec(); + crash_kexec(NULL); #ifdef CONFIG_SMP /* _