Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit faa8b6c3c2e1454175609167a25ae525d075f045

Authored by Linus Torvalds 2007-05-15 06:24:24 +0800

Exists in master and in 7 other branches

Revert "ipmi: add new IPMI nmi watchdog handling"

This reverts commit f64da958dfc83335de1d2bef9d3868f30feb4e53.

Andi Kleen is unhappy with the changes, and they really do not seem
worth it.  IPMI could use DIE_NMI_IPI instead of the new callback, even
though that ends up having its own set of problems too, mainly because
the IPMI code cannot really know the NMI was from IPMI or not.

Manually fix up conflicts in arch/x86_64/kernel/traps.c and
drivers/char/ipmi/ipmi_watchdog.c.

Cc: Andi Kleen <ak@suse.de>
Cc: Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
Cc: Corey Minyard <minyard@acm.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 5 changed files with 42 additions and 102 deletions Inline Diff

arch/i386/kernel/traps.c
arch/x86_64/kernel/traps.c
drivers/char/ipmi/ipmi_watchdog.c
include/asm-i386/kdebug.h
include/asm-x86_64/kdebug.h

arch/i386/kernel/traps.c

Diff comments View file @ faa8b6c

 /*
  *  linux/arch/i386/traps.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  Pentium III FXSR, SSE support
  *	Gareth Hughes <gareth@valinux.com>, May 2000
  */
 /*
  * 'Traps.c' handles hardware traps and faults after we have saved some
  * state in 'asm.s'.
  */
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <linux/highmem.h>
 #include <linux/kallsyms.h>
 #include <linux/ptrace.h>
 #include <linux/utsname.h>
 #include <linux/kprobes.h>
 #include <linux/kexec.h>
 #include <linux/unwind.h>
 #include <linux/uaccess.h>
 #include <linux/nmi.h>
 #include <linux/bug.h>
 #ifdef CONFIG_EISA
 #include <linux/ioport.h>
 #include <linux/eisa.h>
 #endif
 #ifdef CONFIG_MCA
 #include <linux/mca.h>
 #endif
 #include <asm/processor.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/atomic.h>
 #include <asm/debugreg.h>
 #include <asm/desc.h>
 #include <asm/i387.h>
 #include <asm/nmi.h>
 #include <asm/unwind.h>
 #include <asm/smp.h>
 #include <asm/arch_hooks.h>
 #include <linux/kdebug.h>
 #include <asm/stacktrace.h>
 #include <linux/module.h>
 #include "mach_traps.h"
 int panic_on_unrecovered_nmi;
 asmlinkage int system_call(void);
 /* Do we ignore FPU interrupts ? */
 char ignore_fpu_irq = 0;
 /*
  * The IDT has to be page-aligned to simplify the Pentium
  * F0 0F bug workaround.. We have a special link segment
  * for this.
  */
 struct desc_struct idt_table[256] __attribute__((__section__(".data.idt"))) = { {0, 0}, };
 asmlinkage void divide_error(void);
 asmlinkage void debug(void);
 asmlinkage void nmi(void);
 asmlinkage void int3(void);
 asmlinkage void overflow(void);
 asmlinkage void bounds(void);
 asmlinkage void invalid_op(void);
 asmlinkage void device_not_available(void);
 asmlinkage void coprocessor_segment_overrun(void);
 asmlinkage void invalid_TSS(void);
 asmlinkage void segment_not_present(void);
 asmlinkage void stack_segment(void);
 asmlinkage void general_protection(void);
 asmlinkage void page_fault(void);
 asmlinkage void coprocessor_error(void);
 asmlinkage void simd_coprocessor_error(void);
 asmlinkage void alignment_check(void);
 asmlinkage void spurious_interrupt_bug(void);
 asmlinkage void machine_check(void);
 int kstack_depth_to_print = 24;
 static unsigned int code_bytes = 64;
 static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)
 {
 	return	p > (void *)tinfo &&
 		p < (void *)tinfo + THREAD_SIZE - 3;
 }
 static inline unsigned long print_context_stack(struct thread_info *tinfo,
 				unsigned long *stack, unsigned long ebp,
 				struct stacktrace_ops *ops, void *data)
 {
 	unsigned long addr;
 #ifdef	CONFIG_FRAME_POINTER
 	while (valid_stack_ptr(tinfo, (void *)ebp)) {
 		unsigned long new_ebp;
 		addr = *(unsigned long *)(ebp + 4);
 		ops->address(data, addr);
 		/*
 		 * break out of recursive entries (such as
 		 * end_of_stack_stop_unwind_function). Also,
 		 * we can never allow a frame pointer to
 		 * move downwards!
 	 	 */
 	 	new_ebp = *(unsigned long *)ebp;
 		if (new_ebp <= ebp)
 			break;
 		ebp = new_ebp;
 	}
 #else
 	while (valid_stack_ptr(tinfo, stack)) {
 		addr = *stack++;
 		if (__kernel_text_address(addr))
 			ops->address(data, addr);
 	}
 #endif
 	return ebp;
 }
 #define MSG(msg) ops->warning(data, msg)
 void dump_trace(struct task_struct *task, struct pt_regs *regs,
 	        unsigned long *stack,
 		struct stacktrace_ops *ops, void *data)
 {
 	unsigned long ebp = 0;
 	if (!task)
 		task = current;
 	if (!stack) {
 		unsigned long dummy;
 		stack = &dummy;
 		if (task && task != current)
 			stack = (unsigned long *)task->thread.esp;
 	}
 #ifdef CONFIG_FRAME_POINTER
 	if (!ebp) {
 		if (task == current) {
 			/* Grab ebp right from our regs */
 			asm ("movl %%ebp, %0" : "=r" (ebp) : );
 		} else {
 			/* ebp is the last reg pushed by switch_to */
 			ebp = *(unsigned long *) task->thread.esp;
 		}
 	}
 #endif
 	while (1) {
 		struct thread_info *context;
 		context = (struct thread_info *)
 			((unsigned long)stack & (~(THREAD_SIZE - 1)));
 		ebp = print_context_stack(context, stack, ebp, ops, data);
 		/* Should be after the line below, but somewhere
 		   in early boot context comes out corrupted and we
 		   can't reference it -AK */
 		if (ops->stack(data, "IRQ") < 0)
 			break;
 		stack = (unsigned long*)context->previous_esp;
 		if (!stack)
 			break;
 		touch_nmi_watchdog();
 	}
 }
 EXPORT_SYMBOL(dump_trace);
 static void
 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
 {
 	printk(data);
 	print_symbol(msg, symbol);
 	printk("\n");
 }
 static void print_trace_warning(void *data, char *msg)
 {
 	printk("%s%s\n", (char *)data, msg);
 }
 static int print_trace_stack(void *data, char *name)
 {
 	return 0;
 }
 /*
  * Print one address/symbol entries per line.
  */
 static void print_trace_address(void *data, unsigned long addr)
 {
 	printk("%s [<%08lx>] ", (char *)data, addr);
 	print_symbol("%s\n", addr);
 }
 static struct stacktrace_ops print_trace_ops = {
 	.warning = print_trace_warning,
 	.warning_symbol = print_trace_warning_symbol,
 	.stack = print_trace_stack,
 	.address = print_trace_address,
 };
 static void
 show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
 		   unsigned long * stack, char *log_lvl)
 {
 	dump_trace(task, regs, stack, &print_trace_ops, log_lvl);
 	printk("%s =======================\n", log_lvl);
 }
 void show_trace(struct task_struct *task, struct pt_regs *regs,
 		unsigned long * stack)
 {
 	show_trace_log_lvl(task, regs, stack, "");
 }
 static void show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,
 			       unsigned long *esp, char *log_lvl)
 {
 	unsigned long *stack;
 	int i;
 	if (esp == NULL) {
 		if (task)
 			esp = (unsigned long*)task->thread.esp;
 		else
 			esp = (unsigned long *)&esp;
 	}
 	stack = esp;
 	for(i = 0; i < kstack_depth_to_print; i++) {
 		if (kstack_end(stack))
 			break;
 		if (i && ((i % 8) == 0))
 			printk("\n%s       ", log_lvl);
 		printk("%08lx ", *stack++);
 	}
 	printk("\n%sCall Trace:\n", log_lvl);
 	show_trace_log_lvl(task, regs, esp, log_lvl);
 }
 void show_stack(struct task_struct *task, unsigned long *esp)
 {
 	printk("       ");
 	show_stack_log_lvl(task, NULL, esp, "");
 }
 /*
  * The architecture-independent dump_stack generator
  */
 void dump_stack(void)
 {
 	unsigned long stack;
 	show_trace(current, NULL, &stack);
 }
 EXPORT_SYMBOL(dump_stack);
 void show_registers(struct pt_regs *regs)
 {
 	int i;
 	int in_kernel = 1;
 	unsigned long esp;
 	unsigned short ss, gs;
 	esp = (unsigned long) (&regs->esp);
 	savesegment(ss, ss);
 	savesegment(gs, gs);
 	if (user_mode_vm(regs)) {
 		in_kernel = 0;
 		esp = regs->esp;
 		ss = regs->xss & 0xffff;
 	}
 	print_modules();
 	printk(KERN_EMERG "CPU:    %d\n"
 		KERN_EMERG "EIP:    %04x:[<%08lx>]    %s VLI\n"
 		KERN_EMERG "EFLAGS: %08lx   (%s %.*s)\n",
 		smp_processor_id(), 0xffff & regs->xcs, regs->eip,
 		print_tainted(), regs->eflags, init_utsname()->release,
 		(int)strcspn(init_utsname()->version, " "),
 		init_utsname()->version);
 	print_symbol(KERN_EMERG "EIP is at %s\n", regs->eip);
 	printk(KERN_EMERG "eax: %08lx   ebx: %08lx   ecx: %08lx   edx: %08lx\n",
 		regs->eax, regs->ebx, regs->ecx, regs->edx);
 	printk(KERN_EMERG "esi: %08lx   edi: %08lx   ebp: %08lx   esp: %08lx\n",
 		regs->esi, regs->edi, regs->ebp, esp);
 	printk(KERN_EMERG "ds: %04x   es: %04x   fs: %04x  gs: %04x  ss: %04x\n",
 	       regs->xds & 0xffff, regs->xes & 0xffff, regs->xfs & 0xffff, gs, ss);
 	printk(KERN_EMERG "Process %.*s (pid: %d, ti=%p task=%p task.ti=%p)",
 		TASK_COMM_LEN, current->comm, current->pid,
 		current_thread_info(), current, task_thread_info(current));
 	/*
 	 * When in-kernel, we also print out the stack and code at the
 	 * time of the fault..
 	 */
 	if (in_kernel) {
 		u8 *eip;
 		unsigned int code_prologue = code_bytes * 43 / 64;
 		unsigned int code_len = code_bytes;
 		unsigned char c;
 		printk("\n" KERN_EMERG "Stack: ");
 		show_stack_log_lvl(NULL, regs, (unsigned long *)esp, KERN_EMERG);
 		printk(KERN_EMERG "Code: ");
 		eip = (u8 *)regs->eip - code_prologue;
 		if (eip < (u8 *)PAGE_OFFSET ||
 			probe_kernel_address(eip, c)) {
 			/* try starting at EIP */
 			eip = (u8 *)regs->eip;
 			code_len = code_len - code_prologue + 1;
 		}
 		for (i = 0; i < code_len; i++, eip++) {
 			if (eip < (u8 *)PAGE_OFFSET ||
 				probe_kernel_address(eip, c)) {
 				printk(" Bad EIP value.");
 				break;
 			}
 			if (eip == (u8 *)regs->eip)
 				printk("<%02x> ", c);
 			else
 				printk("%02x ", c);
 		}
 	}
 	printk("\n");
 }
 int is_valid_bugaddr(unsigned long eip)
 {
 	unsigned short ud2;
 	if (eip < PAGE_OFFSET)
 		return 0;
 	if (probe_kernel_address((unsigned short *)eip, ud2))
 		return 0;
 	return ud2 == 0x0b0f;
 }
 /*
  * 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 {
 		spinlock_t lock;
 		u32 lock_owner;
 		int lock_owner_depth;
 	} die = {
 		.lock =			__SPIN_LOCK_UNLOCKED(die.lock),
 		.lock_owner =		-1,
 		.lock_owner_depth =	0
 	};
 	static int die_counter;
 	unsigned long flags;
 	oops_enter();
 	if (die.lock_owner != raw_smp_processor_id()) {
 		console_verbose();
 		spin_lock_irqsave(&die.lock, flags);
 		die.lock_owner = smp_processor_id();
 		die.lock_owner_depth = 0;
 		bust_spinlocks(1);
 	}
 	else
 		local_save_flags(flags);
 	if (++die.lock_owner_depth < 3) {
 		int nl = 0;
 		unsigned long esp;
 		unsigned short ss;
 		report_bug(regs->eip);
 		printk(KERN_EMERG "%s: %04lx [#%d]\n", str, err & 0xffff, ++die_counter);
 #ifdef CONFIG_PREEMPT
 		printk(KERN_EMERG "PREEMPT ");
 		nl = 1;
 #endif
 #ifdef CONFIG_SMP
 		if (!nl)
 			printk(KERN_EMERG);
 		printk("SMP ");
 		nl = 1;
 #endif
 #ifdef CONFIG_DEBUG_PAGEALLOC
 		if (!nl)
 			printk(KERN_EMERG);
 		printk("DEBUG_PAGEALLOC");
 		nl = 1;
 #endif
 		if (nl)
 			printk("\n");
 		if (notify_die(DIE_OOPS, str, regs, err,
 					current->thread.trap_no, SIGSEGV) !=
 				NOTIFY_STOP) {
 			show_registers(regs);
 			/* Executive summary in case the oops scrolled away */
 			esp = (unsigned long) (&regs->esp);
 			savesegment(ss, ss);
 			if (user_mode(regs)) {
 				esp = regs->esp;
 				ss = regs->xss & 0xffff;
 			}
 			printk(KERN_EMERG "EIP: [<%08lx>] ", regs->eip);
 			print_symbol("%s", regs->eip);
 			printk(" SS:ESP %04x:%08lx\n", ss, esp);
 		}
 		else
 			regs = NULL;
   	} else
 		printk(KERN_EMERG "Recursive die() failure, output suppressed\n");
 	bust_spinlocks(0);
 	die.lock_owner = -1;
 	spin_unlock_irqrestore(&die.lock, flags);
 	if (!regs)
 		return;
 	if (kexec_should_crash(current))
 		crash_kexec(regs);
 	if (in_interrupt())
 		panic("Fatal exception in interrupt");
 	if (panic_on_oops)
 		panic("Fatal exception");
 	oops_exit();
 	do_exit(SIGSEGV);
 }
 static inline void die_if_kernel(const char * str, struct pt_regs * regs, long err)
 {
 	if (!user_mode_vm(regs))
 		die(str, regs, err);
 }
 static void __kprobes do_trap(int trapnr, int signr, char *str, int vm86,
 			      struct pt_regs * regs, long error_code,
 			      siginfo_t *info)
 {
 	struct task_struct *tsk = current;
 	if (regs->eflags & VM_MASK) {
 		if (vm86)
 			goto vm86_trap;
 		goto trap_signal;
 	}
 	if (!user_mode(regs))
 		goto kernel_trap;
 	trap_signal: {
 		/*
 		 * We want error_code and trap_no set for userspace faults and
 		 * kernelspace faults which result in die(), but not
 		 * kernelspace faults which are fixed up.  die() gives the
 		 * process no chance to handle the signal and notice the
 		 * kernel fault information, so that won't result in polluting
 		 * the information about previously queued, but not yet
 		 * delivered, faults.  See also do_general_protection below.
 		 */
 		tsk->thread.error_code = error_code;
 		tsk->thread.trap_no = trapnr;
 		if (info)
 			force_sig_info(signr, info, tsk);
 		else
 			force_sig(signr, tsk);
 		return;
 	}
 	kernel_trap: {
 		if (!fixup_exception(regs)) {
 			tsk->thread.error_code = error_code;
 			tsk->thread.trap_no = trapnr;
 			die(str, regs, error_code);
 		}
 		return;
 	}
 	vm86_trap: {
 		int ret = handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, trapnr);
 		if (ret) goto trap_signal;
 		return;
 	}
 }
 #define DO_ERROR(trapnr, signr, str, name) \
 fastcall void do_##name(struct pt_regs * regs, long error_code) \
 { \
 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
 						== NOTIFY_STOP) \
 		return; \
 	do_trap(trapnr, signr, str, 0, regs, error_code, NULL); \
 }
 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
 fastcall void do_##name(struct pt_regs * regs, long error_code) \
 { \
 	siginfo_t info; \
 	info.si_signo = signr; \
 	info.si_errno = 0; \
 	info.si_code = sicode; \
 	info.si_addr = (void __user *)siaddr; \
 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
 						== NOTIFY_STOP) \
 		return; \
 	do_trap(trapnr, signr, str, 0, regs, error_code, &info); \
 }
 #define DO_VM86_ERROR(trapnr, signr, str, name) \
 fastcall void do_##name(struct pt_regs * regs, long error_code) \
 { \
 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
 						== NOTIFY_STOP) \
 		return; \
 	do_trap(trapnr, signr, str, 1, regs, error_code, NULL); \
 }
 #define DO_VM86_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
 fastcall void do_##name(struct pt_regs * regs, long error_code) \
 { \
 	siginfo_t info; \
 	info.si_signo = signr; \
 	info.si_errno = 0; \
 	info.si_code = sicode; \
 	info.si_addr = (void __user *)siaddr; \
 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
 						== NOTIFY_STOP) \
 		return; \
 	do_trap(trapnr, signr, str, 1, regs, error_code, &info); \
 }
 DO_VM86_ERROR_INFO( 0, SIGFPE,  "divide error", divide_error, FPE_INTDIV, regs->eip)
 #ifndef CONFIG_KPROBES
 DO_VM86_ERROR( 3, SIGTRAP, "int3", int3)
 #endif
 DO_VM86_ERROR( 4, SIGSEGV, "overflow", overflow)
 DO_VM86_ERROR( 5, SIGSEGV, "bounds", bounds)
 DO_ERROR_INFO( 6, SIGILL,  "invalid opcode", invalid_op, ILL_ILLOPN, regs->eip)
 DO_ERROR( 9, SIGFPE,  "coprocessor segment overrun", coprocessor_segment_overrun)
 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
 DO_ERROR(11, SIGBUS,  "segment not present", segment_not_present)
 DO_ERROR(12, SIGBUS,  "stack segment", stack_segment)
 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
 DO_ERROR_INFO(32, SIGSEGV, "iret exception", iret_error, ILL_BADSTK, 0)
 fastcall void __kprobes do_general_protection(struct pt_regs * regs,
 					      long error_code)
 {
 	int cpu = get_cpu();
 	struct tss_struct *tss = &per_cpu(init_tss, cpu);
 	struct thread_struct *thread = &current->thread;
 	/*
 	 * Perform the lazy TSS's I/O bitmap copy. If the TSS has an
 	 * invalid offset set (the LAZY one) and the faulting thread has
 	 * a valid I/O bitmap pointer, we copy the I/O bitmap in the TSS
 	 * and we set the offset field correctly. Then we let the CPU to
 	 * restart the faulting instruction.
 	 */
 	if (tss->x86_tss.io_bitmap_base == INVALID_IO_BITMAP_OFFSET_LAZY &&
 	    thread->io_bitmap_ptr) {
 		memcpy(tss->io_bitmap, thread->io_bitmap_ptr,
 		       thread->io_bitmap_max);
 		/*
 		 * If the previously set map was extending to higher ports
 		 * than the current one, pad extra space with 0xff (no access).
 		 */
 		if (thread->io_bitmap_max < tss->io_bitmap_max)
 			memset((char *) tss->io_bitmap +
 				thread->io_bitmap_max, 0xff,
 				tss->io_bitmap_max - thread->io_bitmap_max);
 		tss->io_bitmap_max = thread->io_bitmap_max;
 		tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET;
 		tss->io_bitmap_owner = thread;
 		put_cpu();
 		return;
 	}
 	put_cpu();
 	if (regs->eflags & VM_MASK)
 		goto gp_in_vm86;
 	if (!user_mode(regs))
 		goto gp_in_kernel;
 	current->thread.error_code = error_code;
 	current->thread.trap_no = 13;
 	force_sig(SIGSEGV, current);
 	return;
 gp_in_vm86:
 	local_irq_enable();
 	handle_vm86_fault((struct kernel_vm86_regs *) regs, error_code);
 	return;
 gp_in_kernel:
 	if (!fixup_exception(regs)) {
 		current->thread.error_code = error_code;
 		current->thread.trap_no = 13;
 		if (notify_die(DIE_GPF, "general protection fault", regs,
 				error_code, 13, SIGSEGV) == NOTIFY_STOP)
 			return;
 		die("general protection fault", regs, error_code);
 	}
 }
 static __kprobes void
 mem_parity_error(unsigned char reason, struct pt_regs * regs)
 {
 	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x on "
 		"CPU %d.\n", reason, smp_processor_id());
 	printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
 	if (panic_on_unrecovered_nmi)
                 panic("NMI: Not continuing");
 	printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
 	/* Clear and disable the memory parity error line. */
 	clear_mem_error(reason);
 }
 static __kprobes void
 io_check_error(unsigned char reason, struct pt_regs * regs)
 {
 	unsigned long i;
 	printk(KERN_EMERG "NMI: IOCK error (debug interrupt?)\n");
 	show_registers(regs);
 	/* Re-enable the IOCK line, wait for a few seconds */
 	reason = (reason & 0xf) | 8;
 	outb(reason, 0x61);
 	i = 2000;
 	while (--i) udelay(1000);
 	reason &= ~8;
 	outb(reason, 0x61);
 }
 static __kprobes void
 unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
 {
 #ifdef CONFIG_MCA
 	/* Might actually be able to figure out what the guilty party
 	* is. */
 	if( MCA_bus ) {
 		mca_handle_nmi();
 		return;
 	}
 #endif
 	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x on "
 		"CPU %d.\n", reason, smp_processor_id());
 	printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n");
 	if (panic_on_unrecovered_nmi)
                 panic("NMI: Not continuing");
 	printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
 }
 static DEFINE_SPINLOCK(nmi_print_lock);
 void __kprobes die_nmi(struct pt_regs *regs, const char *msg)
 {
 	if (notify_die(DIE_NMIWATCHDOG, msg, regs, 0, 2, SIGINT) ==
 	    NOTIFY_STOP)
 		return;
 	spin_lock(&nmi_print_lock);
 	/*
 	* We are in trouble anyway, lets at least try
 	* to get a message out.
 	*/
 	bust_spinlocks(1);
 	printk(KERN_EMERG "%s", msg);
 	printk(" on CPU%d, eip %08lx, registers:\n",
 		smp_processor_id(), regs->eip);
 	show_registers(regs);
 	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_vm(regs)) {
 		current->thread.trap_no = 2;
 		crash_kexec(regs);
 	}
 	do_exit(SIGSEGV);
 }
 static __kprobes void default_do_nmi(struct pt_regs * regs)
 {
 	unsigned char reason = 0;
 	/* Only the BSP gets external NMIs from the system.  */
 	if (!smp_processor_id())
 		reason = get_nmi_reason();
 	if (!(reason & 0xc0)) {
 		if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT)
 							== NOTIFY_STOP)
 			return;
 #ifdef CONFIG_X86_LOCAL_APIC
 		/*
 		 * Ok, so this is none of the documented NMI sources,
 		 * so it must be the NMI watchdog.
 		 */
 		if (nmi_watchdog_tick(regs, reason))
 			return;
-#endif
-		if (notify_die(DIE_NMI_POST, "nmi_post", regs, reason, 2, 0)
-							== NOTIFY_STOP)
-			return;
-#ifdef CONFIG_X86_LOCAL_APIC
 		if (!do_nmi_callback(regs, smp_processor_id()))
 #endif
 			unknown_nmi_error(reason, regs);
 		return;
 	}
 	if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
 		return;
 	if (reason & 0x80)
 		mem_parity_error(reason, regs);
 	if (reason & 0x40)
 		io_check_error(reason, regs);
 	/*
 	 * Reassert NMI in case it became active meanwhile
 	 * as it's edge-triggered.
 	 */
 	reassert_nmi();
 }
 fastcall __kprobes void do_nmi(struct pt_regs * regs, long error_code)
 {
 	int cpu;
 	nmi_enter();
 	cpu = smp_processor_id();
 	++nmi_count(cpu);
 	default_do_nmi(regs);
 	nmi_exit();
 }
 #ifdef CONFIG_KPROBES
 fastcall void __kprobes do_int3(struct pt_regs *regs, long error_code)
 {
 	if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP)
 			== NOTIFY_STOP)
 		return;
 	/* This is an interrupt gate, because kprobes wants interrupts
 	disabled.  Normal trap handlers don't. */
 	restore_interrupts(regs);
 	do_trap(3, SIGTRAP, "int3", 1, regs, error_code, NULL);
 }
 #endif
 /*
  * Our handling of the processor debug registers is non-trivial.
  * We do not clear them on entry and exit from the kernel. Therefore
  * it is possible to get a watchpoint trap here from inside the kernel.
  * However, the code in ./ptrace.c has ensured that the user can
  * only set watchpoints on userspace addresses. Therefore the in-kernel
  * watchpoint trap can only occur in code which is reading/writing
  * from user space. Such code must not hold kernel locks (since it
  * can equally take a page fault), therefore it is safe to call
  * force_sig_info even though that claims and releases locks.
  *
  * Code in ./signal.c ensures that the debug control register
  * is restored before we deliver any signal, and therefore that
  * user code runs with the correct debug control register even though
  * we clear it here.
  *
  * Being careful here means that we don't have to be as careful in a
  * lot of more complicated places (task switching can be a bit lazy
  * about restoring all the debug state, and ptrace doesn't have to
  * find every occurrence of the TF bit that could be saved away even
  * by user code)
  */
 fastcall void __kprobes do_debug(struct pt_regs * regs, long error_code)
 {
 	unsigned int condition;
 	struct task_struct *tsk = current;
 	get_debugreg(condition, 6);
 	if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
 					SIGTRAP) == NOTIFY_STOP)
 		return;
 	/* It's safe to allow irq's after DR6 has been saved */
 	if (regs->eflags & X86_EFLAGS_IF)
 		local_irq_enable();
 	/* Mask out spurious debug traps due to lazy DR7 setting */
 	if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
 		if (!tsk->thread.debugreg[7])
 			goto clear_dr7;
 	}
 	if (regs->eflags & VM_MASK)
 		goto debug_vm86;
 	/* Save debug status register where ptrace can see it */
 	tsk->thread.debugreg[6] = condition;
 	/*
 	 * Single-stepping through TF: make sure we ignore any events in
 	 * kernel space (but re-enable TF when returning to user mode).
 	 */
 	if (condition & DR_STEP) {
 		/*
 		 * We already checked v86 mode above, so we can
 		 * check for kernel mode by just checking the CPL
 		 * of CS.
 		 */
 		if (!user_mode(regs))
 			goto clear_TF_reenable;
 	}
 	/* Ok, finally something we can handle */
 	send_sigtrap(tsk, regs, error_code);
 	/* Disable additional traps. They'll be re-enabled when
 	 * the signal is delivered.
 	 */
 clear_dr7:
 	set_debugreg(0, 7);
 	return;
 debug_vm86:
 	handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, 1);
 	return;
 clear_TF_reenable:
 	set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
 	regs->eflags &= ~TF_MASK;
 	return;
 }
 /*
  * Note that we play around with the 'TS' bit in an attempt to get
  * the correct behaviour even in the presence of the asynchronous
  * IRQ13 behaviour
  */
 void math_error(void __user *eip)
 {
 	struct task_struct * task;
 	siginfo_t info;
 	unsigned short cwd, swd;
 	/*
 	 * Save the info for the exception handler and clear the error.
 	 */
 	task = current;
 	save_init_fpu(task);
 	task->thread.trap_no = 16;
 	task->thread.error_code = 0;
 	info.si_signo = SIGFPE;
 	info.si_errno = 0;
 	info.si_code = __SI_FAULT;
 	info.si_addr = eip;
 	/*
 	 * (~cwd & swd) will mask out exceptions that are not set to unmasked
 	 * status.  0x3f is the exception bits in these regs, 0x200 is the
 	 * C1 reg you need in case of a stack fault, 0x040 is the stack
 	 * fault bit.  We should only be taking one exception at a time,
 	 * so if this combination doesn't produce any single exception,
 	 * then we have a bad program that isn't syncronizing its FPU usage
 	 * and it will suffer the consequences since we won't be able to
 	 * fully reproduce the context of the exception
 	 */
 	cwd = get_fpu_cwd(task);
 	swd = get_fpu_swd(task);
 	switch (swd & ~cwd & 0x3f) {
 		case 0x000: /* No unmasked exception */
 			return;
 		default:    /* Multiple exceptions */
 			break;
 		case 0x001: /* Invalid Op */
 			/*
 			 * swd & 0x240 == 0x040: Stack Underflow
 			 * swd & 0x240 == 0x240: Stack Overflow
 			 * User must clear the SF bit (0x40) if set
 			 */
 			info.si_code = FPE_FLTINV;
 			break;
 		case 0x002: /* Denormalize */
 		case 0x010: /* Underflow */
 			info.si_code = FPE_FLTUND;
 			break;
 		case 0x004: /* Zero Divide */
 			info.si_code = FPE_FLTDIV;
 			break;
 		case 0x008: /* Overflow */
 			info.si_code = FPE_FLTOVF;
 			break;
 		case 0x020: /* Precision */
 			info.si_code = FPE_FLTRES;
 			break;
 	}
 	force_sig_info(SIGFPE, &info, task);
 }
 fastcall void do_coprocessor_error(struct pt_regs * regs, long error_code)
 {
 	ignore_fpu_irq = 1;
 	math_error((void __user *)regs->eip);
 }
 static void simd_math_error(void __user *eip)
 {
 	struct task_struct * task;
 	siginfo_t info;
 	unsigned short mxcsr;
 	/*
 	 * Save the info for the exception handler and clear the error.
 	 */
 	task = current;
 	save_init_fpu(task);
 	task->thread.trap_no = 19;
 	task->thread.error_code = 0;
 	info.si_signo = SIGFPE;
 	info.si_errno = 0;
 	info.si_code = __SI_FAULT;
 	info.si_addr = eip;
 	/*
 	 * The SIMD FPU exceptions are handled a little differently, as there
 	 * is only a single status/control register.  Thus, to determine which
 	 * unmasked exception was caught we must mask the exception mask bits
 	 * at 0x1f80, and then use these to mask the exception bits at 0x3f.
 	 */
 	mxcsr = get_fpu_mxcsr(task);
 	switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
 		case 0x000:
 		default:
 			break;
 		case 0x001: /* Invalid Op */
 			info.si_code = FPE_FLTINV;
 			break;
 		case 0x002: /* Denormalize */
 		case 0x010: /* Underflow */
 			info.si_code = FPE_FLTUND;
 			break;
 		case 0x004: /* Zero Divide */
 			info.si_code = FPE_FLTDIV;
 			break;
 		case 0x008: /* Overflow */
 			info.si_code = FPE_FLTOVF;
 			break;
 		case 0x020: /* Precision */
 			info.si_code = FPE_FLTRES;
 			break;
 	}
 	force_sig_info(SIGFPE, &info, task);
 }
 fastcall void do_simd_coprocessor_error(struct pt_regs * regs,
 					  long error_code)
 {
 	if (cpu_has_xmm) {
 		/* Handle SIMD FPU exceptions on PIII+ processors. */
 		ignore_fpu_irq = 1;
 		simd_math_error((void __user *)regs->eip);
 	} else {
 		/*
 		 * Handle strange cache flush from user space exception
 		 * in all other cases.  This is undocumented behaviour.
 		 */
 		if (regs->eflags & VM_MASK) {
 			handle_vm86_fault((struct kernel_vm86_regs *)regs,
 					  error_code);
 			return;
 		}
 		current->thread.trap_no = 19;
 		current->thread.error_code = error_code;
 		die_if_kernel("cache flush denied", regs, error_code);
 		force_sig(SIGSEGV, current);
 	}
 }
 fastcall void do_spurious_interrupt_bug(struct pt_regs * regs,
 					  long error_code)
 {
 #if 0
 	/* No need to warn about this any longer. */
 	printk("Ignoring P6 Local APIC Spurious Interrupt Bug...\n");
 #endif
 }
 fastcall unsigned long patch_espfix_desc(unsigned long uesp,
 					  unsigned long kesp)
 {
 	struct desc_struct *gdt = __get_cpu_var(gdt_page).gdt;
 	unsigned long base = (kesp - uesp) & -THREAD_SIZE;
 	unsigned long new_kesp = kesp - base;
 	unsigned long lim_pages = (new_kesp | (THREAD_SIZE - 1)) >> PAGE_SHIFT;
 	__u64 desc = *(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS];
 	/* Set up base for espfix segment */
  	desc &= 0x00f0ff0000000000ULL;
  	desc |=	((((__u64)base) << 16) & 0x000000ffffff0000ULL) |
 		((((__u64)base) << 32) & 0xff00000000000000ULL) |
 		((((__u64)lim_pages) << 32) & 0x000f000000000000ULL) |
 		(lim_pages & 0xffff);
 	*(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS] = desc;
 	return new_kesp;
 }
 /*
  *  'math_state_restore()' saves the current math information in the
  * old math state array, and gets the new ones from the current task
  *
  * Careful.. There are problems with IBM-designed IRQ13 behaviour.
  * Don't touch unless you *really* know how it works.
  *
  * Must be called with kernel preemption disabled (in this case,
  * local interrupts are disabled at the call-site in entry.S).
  */
 asmlinkage void math_state_restore(void)
 {
 	struct thread_info *thread = current_thread_info();
 	struct task_struct *tsk = thread->task;
 	clts();		/* Allow maths ops (or we recurse) */
 	if (!tsk_used_math(tsk))
 		init_fpu(tsk);
 	restore_fpu(tsk);
 	thread->status |= TS_USEDFPU;	/* So we fnsave on switch_to() */
 	tsk->fpu_counter++;
 }
 #ifndef CONFIG_MATH_EMULATION
 asmlinkage void math_emulate(long arg)
 {
 	printk(KERN_EMERG "math-emulation not enabled and no coprocessor found.\n");
 	printk(KERN_EMERG "killing %s.\n",current->comm);
 	force_sig(SIGFPE,current);
 	schedule();
 }
 #endif /* CONFIG_MATH_EMULATION */
 #ifdef CONFIG_X86_F00F_BUG
 void __init trap_init_f00f_bug(void)
 {
 	__set_fixmap(FIX_F00F_IDT, __pa(&idt_table), PAGE_KERNEL_RO);
 	/*
 	 * Update the IDT descriptor and reload the IDT so that
 	 * it uses the read-only mapped virtual address.
 	 */
 	idt_descr.address = fix_to_virt(FIX_F00F_IDT);
 	load_idt(&idt_descr);
 }
 #endif
 /*
  * This needs to use 'idt_table' rather than 'idt', and
  * thus use the _nonmapped_ version of the IDT, as the
  * Pentium F0 0F bugfix can have resulted in the mapped
  * IDT being write-protected.
  */
 void set_intr_gate(unsigned int n, void *addr)
 {
 	_set_gate(n, DESCTYPE_INT, addr, __KERNEL_CS);
 }
 /*
  * This routine sets up an interrupt gate at directory privilege level 3.
  */
 static inline void set_system_intr_gate(unsigned int n, void *addr)
 {
 	_set_gate(n, DESCTYPE_INT | DESCTYPE_DPL3, addr, __KERNEL_CS);
 }
 static void __init set_trap_gate(unsigned int n, void *addr)
 {
 	_set_gate(n, DESCTYPE_TRAP, addr, __KERNEL_CS);
 }
 static void __init set_system_gate(unsigned int n, void *addr)
 {
 	_set_gate(n, DESCTYPE_TRAP | DESCTYPE_DPL3, addr, __KERNEL_CS);
 }
 static void __init set_task_gate(unsigned int n, unsigned int gdt_entry)
 {
 	_set_gate(n, DESCTYPE_TASK, (void *)0, (gdt_entry<<3));
 }
 void __init trap_init(void)
 {
 #ifdef CONFIG_EISA
 	void __iomem *p = ioremap(0x0FFFD9, 4);
 	if (readl(p) == 'E'+('I'<<8)+('S'<<16)+('A'<<24)) {
 		EISA_bus = 1;
 	}
 	iounmap(p);
 #endif
 #ifdef CONFIG_X86_LOCAL_APIC
 	init_apic_mappings();
 #endif
 	set_trap_gate(0,&divide_error);
 	set_intr_gate(1,&debug);
 	set_intr_gate(2,&nmi);
 	set_system_intr_gate(3, &int3); /* int3/4 can be called from all */
 	set_system_gate(4,&overflow);
 	set_trap_gate(5,&bounds);
 	set_trap_gate(6,&invalid_op);
 	set_trap_gate(7,&device_not_available);
 	set_task_gate(8,GDT_ENTRY_DOUBLEFAULT_TSS);
 	set_trap_gate(9,&coprocessor_segment_overrun);
 	set_trap_gate(10,&invalid_TSS);
 	set_trap_gate(11,&segment_not_present);
 	set_trap_gate(12,&stack_segment);
 	set_trap_gate(13,&general_protection);
 	set_intr_gate(14,&page_fault);
 	set_trap_gate(15,&spurious_interrupt_bug);
 	set_trap_gate(16,&coprocessor_error);
 	set_trap_gate(17,&alignment_check);
 #ifdef CONFIG_X86_MCE
 	set_trap_gate(18,&machine_check);
 #endif
 	set_trap_gate(19,&simd_coprocessor_error);
 	if (cpu_has_fxsr) {
 		/*
 		 * Verify that the FXSAVE/FXRSTOR data will be 16-byte aligned.
 		 * Generates a compile-time "error: zero width for bit-field" if
 		 * the alignment is wrong.
 		 */
 		struct fxsrAlignAssert {
 			int _:!(offsetof(struct task_struct,
 					thread.i387.fxsave) & 15);
 		};
 		printk(KERN_INFO "Enabling fast FPU save and restore... ");
 		set_in_cr4(X86_CR4_OSFXSR);
 		printk("done.\n");
 	}
 	if (cpu_has_xmm) {
 		printk(KERN_INFO "Enabling unmasked SIMD FPU exception "
 				"support... ");
 		set_in_cr4(X86_CR4_OSXMMEXCPT);
 		printk("done.\n");
 	}
 	set_system_gate(SYSCALL_VECTOR,&system_call);
 	/*
 	 * Should be a barrier for any external CPU state.
 	 */
 	cpu_init();
 	trap_init_hook();
 }
 static int __init kstack_setup(char *s)
 {
 	kstack_depth_to_print = simple_strtoul(s, NULL, 0);
 	return 1;
 }
 __setup("kstack=", kstack_setup);
 static int __init code_bytes_setup(char *s)
 {
 	code_bytes = simple_strtoul(s, NULL, 0);
 	if (code_bytes > 8192)
 		code_bytes = 8192;
 	return 1;
 }
 __setup("code_bytes=", code_bytes_setup);

arch/x86_64/kernel/traps.c

Diff comments View file @ faa8b6c

 /*
  *  linux/arch/x86-64/traps.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
  *
  *  Pentium III FXSR, SSE support
  *	Gareth Hughes <gareth@valinux.com>, May 2000
  */
 /*
  * 'Traps.c' handles hardware traps and faults after we have saved some
  * state in 'entry.S'.
  */
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/ptrace.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <linux/kallsyms.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/nmi.h>
 #include <linux/kprobes.h>
 #include <linux/kexec.h>
 #include <linux/unwind.h>
 #include <linux/uaccess.h>
 #include <linux/bug.h>
 #include <linux/kdebug.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/atomic.h>
 #include <asm/debugreg.h>
 #include <asm/desc.h>
 #include <asm/i387.h>
 #include <asm/processor.h>
 #include <asm/unwind.h>
 #include <asm/smp.h>
 #include <asm/pgalloc.h>
 #include <asm/pda.h>
 #include <asm/proto.h>
 #include <asm/nmi.h>
 #include <asm/stacktrace.h>
 asmlinkage void divide_error(void);
 asmlinkage void debug(void);
 asmlinkage void nmi(void);
 asmlinkage void int3(void);
 asmlinkage void overflow(void);
 asmlinkage void bounds(void);
 asmlinkage void invalid_op(void);
 asmlinkage void device_not_available(void);
 asmlinkage void double_fault(void);
 asmlinkage void coprocessor_segment_overrun(void);
 asmlinkage void invalid_TSS(void);
 asmlinkage void segment_not_present(void);
 asmlinkage void stack_segment(void);
 asmlinkage void general_protection(void);
 asmlinkage void page_fault(void);
 asmlinkage void coprocessor_error(void);
 asmlinkage void simd_coprocessor_error(void);
 asmlinkage void reserved(void);
 asmlinkage void alignment_check(void);
 asmlinkage void machine_check(void);
 asmlinkage void spurious_interrupt_bug(void);
 static inline void conditional_sti(struct pt_regs *regs)
 {
 	if (regs->eflags & X86_EFLAGS_IF)
 		local_irq_enable();
 }
 static inline void preempt_conditional_sti(struct pt_regs *regs)
 {
 	preempt_disable();
 	if (regs->eflags & X86_EFLAGS_IF)
 		local_irq_enable();
 }
 static inline void preempt_conditional_cli(struct pt_regs *regs)
 {
 	if (regs->eflags & X86_EFLAGS_IF)
 		local_irq_disable();
 	/* Make sure to not schedule here because we could be running
 	   on an exception stack. */
 	preempt_enable_no_resched();
 }
 int kstack_depth_to_print = 12;
 #ifdef CONFIG_KALLSYMS
 void printk_address(unsigned long address)
 {
 	unsigned long offset = 0, symsize;
 	const char *symname;
 	char *modname;
 	char *delim = ":";
 	char namebuf[128];
 	symname = kallsyms_lookup(address, &symsize, &offset,
 					&modname, namebuf);
 	if (!symname) {
 		printk(" [<%016lx>]\n", address);
 		return;
 	}
 	if (!modname)
 		modname = delim = "";
 	printk(" [<%016lx>] %s%s%s%s+0x%lx/0x%lx\n",
 		address, delim, modname, delim, symname, offset, symsize);
 }
 #else
 void printk_address(unsigned long address)
 {
 	printk(" [<%016lx>]\n", address);
 }
 #endif
 static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
 					unsigned *usedp, char **idp)
 {
 	static char ids[][8] = {
 		[DEBUG_STACK - 1] = "#DB",
 		[NMI_STACK - 1] = "NMI",
 		[DOUBLEFAULT_STACK - 1] = "#DF",
 		[STACKFAULT_STACK - 1] = "#SS",
 		[MCE_STACK - 1] = "#MC",
 #if DEBUG_STKSZ > EXCEPTION_STKSZ
 		[N_EXCEPTION_STACKS ... N_EXCEPTION_STACKS + DEBUG_STKSZ / EXCEPTION_STKSZ - 2] = "#DB[?]"
 #endif
 	};
 	unsigned k;
 	/*
 	 * Iterate over all exception stacks, and figure out whether
 	 * 'stack' is in one of them:
 	 */
 	for (k = 0; k < N_EXCEPTION_STACKS; k++) {
 		unsigned long end = per_cpu(orig_ist, cpu).ist[k];
 		/*
 		 * Is 'stack' above this exception frame's end?
 		 * If yes then skip to the next frame.
 		 */
 		if (stack >= end)
 			continue;
 		/*
 		 * Is 'stack' above this exception frame's start address?
 		 * If yes then we found the right frame.
 		 */
 		if (stack >= end - EXCEPTION_STKSZ) {
 			/*
 			 * Make sure we only iterate through an exception
 			 * stack once. If it comes up for the second time
 			 * then there's something wrong going on - just
 			 * break out and return NULL:
 			 */
 			if (*usedp & (1U << k))
 				break;
 			*usedp |= 1U << k;
 			*idp = ids[k];
 			return (unsigned long *)end;
 		}
 		/*
 		 * If this is a debug stack, and if it has a larger size than
 		 * the usual exception stacks, then 'stack' might still
 		 * be within the lower portion of the debug stack:
 		 */
 #if DEBUG_STKSZ > EXCEPTION_STKSZ
 		if (k == DEBUG_STACK - 1 && stack >= end - DEBUG_STKSZ) {
 			unsigned j = N_EXCEPTION_STACKS - 1;
 			/*
 			 * Black magic. A large debug stack is composed of
 			 * multiple exception stack entries, which we
 			 * iterate through now. Dont look:
 			 */
 			do {
 				++j;
 				end -= EXCEPTION_STKSZ;
 				ids[j][4] = '1' + (j - N_EXCEPTION_STACKS);
 			} while (stack < end - EXCEPTION_STKSZ);
 			if (*usedp & (1U << j))
 				break;
 			*usedp |= 1U << j;
 			*idp = ids[j];
 			return (unsigned long *)end;
 		}
 #endif
 	}
 	return NULL;
 }
 #define MSG(txt) ops->warning(data, txt)
 /*
  * x86-64 can have upto three kernel stacks:
  * process stack
  * interrupt stack
  * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
  */
 static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)
 {
 	void *t = (void *)tinfo;
         return p > t && p < t + THREAD_SIZE - 3;
 }
 void dump_trace(struct task_struct *tsk, struct pt_regs *regs,
 		unsigned long *stack,
 		struct stacktrace_ops *ops, void *data)
 {
 	const unsigned cpu = get_cpu();
 	unsigned long *irqstack_end = (unsigned long*)cpu_pda(cpu)->irqstackptr;
 	unsigned used = 0;
 	struct thread_info *tinfo;
 	if (!tsk)
 		tsk = current;
 	if (!stack) {
 		unsigned long dummy;
 		stack = &dummy;
 		if (tsk && tsk != current)
 			stack = (unsigned long *)tsk->thread.rsp;
 	}
 	/*
 	 * Print function call entries within a stack. 'cond' is the
 	 * "end of stackframe" condition, that the 'stack++'
 	 * iteration will eventually trigger.
 	 */
 #define HANDLE_STACK(cond) \
 	do while (cond) { \
 		unsigned long addr = *stack++; \
 		/* Use unlocked access here because except for NMIs	\
 		   we should be already protected against module unloads */ \
 		if (__kernel_text_address(addr)) { \
 			/* \
 			 * If the address is either in the text segment of the \
 			 * kernel, or in the region which contains vmalloc'ed \
 			 * memory, it *may* be the address of a calling \
 			 * routine; if so, print it so that someone tracing \
 			 * down the cause of the crash will be able to figure \
 			 * out the call path that was taken. \
 			 */ \
 			ops->address(data, addr);   \
 		} \
 	} while (0)
 	/*
 	 * Print function call entries in all stacks, starting at the
 	 * current stack address. If the stacks consist of nested
 	 * exceptions
 	 */
 	for (;;) {
 		char *id;
 		unsigned long *estack_end;
 		estack_end = in_exception_stack(cpu, (unsigned long)stack,
 						&used, &id);
 		if (estack_end) {
 			if (ops->stack(data, id) < 0)
 				break;
 			HANDLE_STACK (stack < estack_end);
 			ops->stack(data, "<EOE>");
 			/*
 			 * We link to the next stack via the
 			 * second-to-last pointer (index -2 to end) in the
 			 * exception stack:
 			 */
 			stack = (unsigned long *) estack_end[-2];
 			continue;
 		}
 		if (irqstack_end) {
 			unsigned long *irqstack;
 			irqstack = irqstack_end -
 				(IRQSTACKSIZE - 64) / sizeof(*irqstack);
 			if (stack >= irqstack && stack < irqstack_end) {
 				if (ops->stack(data, "IRQ") < 0)
 					break;
 				HANDLE_STACK (stack < irqstack_end);
 				/*
 				 * We link to the next stack (which would be
 				 * the process stack normally) the last
 				 * pointer (index -1 to end) in the IRQ stack:
 				 */
 				stack = (unsigned long *) (irqstack_end[-1]);
 				irqstack_end = NULL;
 				ops->stack(data, "EOI");
 				continue;
 			}
 		}
 		break;
 	}
 	/*
 	 * This handles the process stack:
 	 */
 	tinfo = task_thread_info(tsk);
 	HANDLE_STACK (valid_stack_ptr(tinfo, stack));
 #undef HANDLE_STACK
 	put_cpu();
 }
 EXPORT_SYMBOL(dump_trace);
 static void
 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
 {
 	print_symbol(msg, symbol);
 	printk("\n");
 }
 static void print_trace_warning(void *data, char *msg)
 {
 	printk("%s\n", msg);
 }
 static int print_trace_stack(void *data, char *name)
 {
 	printk(" <%s> ", name);
 	return 0;
 }
 static void print_trace_address(void *data, unsigned long addr)
 {
 	printk_address(addr);
 }
 static struct stacktrace_ops print_trace_ops = {
 	.warning = print_trace_warning,
 	.warning_symbol = print_trace_warning_symbol,
 	.stack = print_trace_stack,
 	.address = print_trace_address,
 };
 void
 show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long *stack)
 {
 	printk("\nCall Trace:\n");
 	dump_trace(tsk, regs, stack, &print_trace_ops, NULL);
 	printk("\n");
 }
 static void
 _show_stack(struct task_struct *tsk, struct pt_regs *regs, unsigned long *rsp)
 {
 	unsigned long *stack;
 	int i;
 	const int cpu = smp_processor_id();
 	unsigned long *irqstack_end = (unsigned long *) (cpu_pda(cpu)->irqstackptr);
 	unsigned long *irqstack = (unsigned long *) (cpu_pda(cpu)->irqstackptr - IRQSTACKSIZE);
 	// debugging aid: "show_stack(NULL, NULL);" prints the
 	// back trace for this cpu.
 	if (rsp == NULL) {
 		if (tsk)
 			rsp = (unsigned long *)tsk->thread.rsp;
 		else
 			rsp = (unsigned long *)&rsp;
 	}
 	stack = rsp;
 	for(i=0; i < kstack_depth_to_print; i++) {
 		if (stack >= irqstack && stack <= irqstack_end) {
 			if (stack == irqstack_end) {
 				stack = (unsigned long *) (irqstack_end[-1]);
 				printk(" <EOI> ");
 			}
 		} else {
 		if (((long) stack & (THREAD_SIZE-1)) == 0)
 			break;
 		}
 		if (i && ((i % 4) == 0))
 			printk("\n");
 		printk(" %016lx", *stack++);
 		touch_nmi_watchdog();
 	}
 	show_trace(tsk, regs, rsp);
 }
 void show_stack(struct task_struct *tsk, unsigned long * rsp)
 {
 	_show_stack(tsk, NULL, rsp);
 }
 /*
  * The architecture-independent dump_stack generator
  */
 void dump_stack(void)
 {
 	unsigned long dummy;
 	show_trace(NULL, NULL, &dummy);
 }
 EXPORT_SYMBOL(dump_stack);
 void show_registers(struct pt_regs *regs)
 {
 	int i;
 	int in_kernel = !user_mode(regs);
 	unsigned long rsp;
 	const int cpu = smp_processor_id();
 	struct task_struct *cur = cpu_pda(cpu)->pcurrent;
 	rsp = regs->rsp;
 	printk("CPU %d ", cpu);
 	__show_regs(regs);
 	printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
 		cur->comm, cur->pid, task_thread_info(cur), cur);
 	/*
 	 * When in-kernel, we also print out the stack and code at the
 	 * time of the fault..
 	 */
 	if (in_kernel) {
 		printk("Stack: ");
 		_show_stack(NULL, regs, (unsigned long*)rsp);
 		printk("\nCode: ");
 		if (regs->rip < PAGE_OFFSET)
 			goto bad;
 		for (i=0; i<20; i++) {
 			unsigned char c;
 			if (__get_user(c, &((unsigned char*)regs->rip)[i])) {
 bad:
 				printk(" Bad RIP value.");
 				break;
 			}
 			printk("%02x ", c);
 		}
 	}
 	printk("\n");
 }
 int is_valid_bugaddr(unsigned long rip)
 {
 	unsigned short ud2;
 	if (__copy_from_user(&ud2, (const void __user *) rip, sizeof(ud2)))
 		return 0;
 	return ud2 == 0x0b0f;
 }
 #ifdef CONFIG_BUG
 void out_of_line_bug(void)
 {
 	BUG();
 }
 EXPORT_SYMBOL(out_of_line_bug);
 #endif
 static DEFINE_SPINLOCK(die_lock);
 static int die_owner = -1;
 static unsigned int die_nest_count;
 unsigned __kprobes long oops_begin(void)
 {
 	int cpu = smp_processor_id();
 	unsigned long flags;
 	oops_enter();
 	/* racy, but better than risking deadlock. */
 	local_irq_save(flags);
 	if (!spin_trylock(&die_lock)) {
 		if (cpu == die_owner)
 			/* nested oops. should stop eventually */;
 		else
 			spin_lock(&die_lock);
 	}
 	die_nest_count++;
 	die_owner = cpu;
 	console_verbose();
 	bust_spinlocks(1);
 	return flags;
 }
 void __kprobes oops_end(unsigned long flags)
 {
 	die_owner = -1;
 	bust_spinlocks(0);
 	die_nest_count--;
 	if (die_nest_count)
 		/* We still own the lock */
 		local_irq_restore(flags);
 	else
 		/* Nest count reaches zero, release the lock. */
 		spin_unlock_irqrestore(&die_lock, flags);
 	if (panic_on_oops)
 		panic("Fatal exception");
 	oops_exit();
 }
 void __kprobes __die(const char * str, struct pt_regs * regs, long err)
 {
 	static int die_counter;
 	printk(KERN_EMERG "%s: %04lx [%u] ", str, err & 0xffff,++die_counter);
 #ifdef CONFIG_PREEMPT
 	printk("PREEMPT ");
 #endif
 #ifdef CONFIG_SMP
 	printk("SMP ");
 #endif
 #ifdef CONFIG_DEBUG_PAGEALLOC
 	printk("DEBUG_PAGEALLOC");
 #endif
 	printk("\n");
 	notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
 	show_registers(regs);
 	/* Executive summary in case the oops scrolled away */
 	printk(KERN_ALERT "RIP ");
 	printk_address(regs->rip);
 	printk(" RSP <%016lx>\n", regs->rsp);
 	if (kexec_should_crash(current))
 		crash_kexec(regs);
 }
 void die(const char * str, struct pt_regs * regs, long err)
 {
 	unsigned long flags = oops_begin();
 	if (!user_mode(regs))
 		report_bug(regs->rip);
 	__die(str, regs, err);
 	oops_end(flags);
 	do_exit(SIGSEGV);
 }
 void __kprobes die_nmi(char *str, struct pt_regs *regs, int do_panic)
 {
 	unsigned long flags = oops_begin();
 	/*
 	 * We are in trouble anyway, lets at least try
 	 * to get a message out.
 	 */
 	printk(str, smp_processor_id());
 	show_registers(regs);
 	if (kexec_should_crash(current))
 		crash_kexec(regs);
 	if (do_panic || panic_on_oops)
 		panic("Non maskable interrupt");
 	oops_end(flags);
 	nmi_exit();
 	local_irq_enable();
 	do_exit(SIGSEGV);
 }
 static void __kprobes do_trap(int trapnr, int signr, char *str,
 			      struct pt_regs * regs, long error_code,
 			      siginfo_t *info)
 {
 	struct task_struct *tsk = current;
 	if (user_mode(regs)) {
 		/*
 		 * We want error_code and trap_no set for userspace
 		 * faults and kernelspace faults which result in
 		 * die(), but not kernelspace faults which are fixed
 		 * up.  die() gives the process no chance to handle
 		 * the signal and notice the kernel fault information,
 		 * so that won't result in polluting the information
 		 * about previously queued, but not yet delivered,
 		 * faults.  See also do_general_protection below.
 		 */
 		tsk->thread.error_code = error_code;
 		tsk->thread.trap_no = trapnr;
 		if (exception_trace && unhandled_signal(tsk, signr))
 			printk(KERN_INFO
 			       "%s[%d] trap %s rip:%lx rsp:%lx error:%lx\n",
 			       tsk->comm, tsk->pid, str,
 			       regs->rip, regs->rsp, error_code);
 		if (info)
 			force_sig_info(signr, info, tsk);
 		else
 			force_sig(signr, tsk);
 		return;
 	}
 	/* kernel trap */
 	{
 		const struct exception_table_entry *fixup;
 		fixup = search_exception_tables(regs->rip);
 		if (fixup)
 			regs->rip = fixup->fixup;
 		else {
 			tsk->thread.error_code = error_code;
 			tsk->thread.trap_no = trapnr;
 			die(str, regs, error_code);
 		}
 		return;
 	}
 }
 #define DO_ERROR(trapnr, signr, str, name) \
 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
 { \
 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
 							== NOTIFY_STOP) \
 		return; \
 	conditional_sti(regs);						\
 	do_trap(trapnr, signr, str, regs, error_code, NULL); \
 }
 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
 { \
 	siginfo_t info; \
 	info.si_signo = signr; \
 	info.si_errno = 0; \
 	info.si_code = sicode; \
 	info.si_addr = (void __user *)siaddr; \
 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
 							== NOTIFY_STOP) \
 		return; \
 	conditional_sti(regs);						\
 	do_trap(trapnr, signr, str, regs, error_code, &info); \
 }
 DO_ERROR_INFO( 0, SIGFPE,  "divide error", divide_error, FPE_INTDIV, regs->rip)
 DO_ERROR( 4, SIGSEGV, "overflow", overflow)
 DO_ERROR( 5, SIGSEGV, "bounds", bounds)
 DO_ERROR_INFO( 6, SIGILL,  "invalid opcode", invalid_op, ILL_ILLOPN, regs->rip)
 DO_ERROR( 7, SIGSEGV, "device not available", device_not_available)
 DO_ERROR( 9, SIGFPE,  "coprocessor segment overrun", coprocessor_segment_overrun)
 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
 DO_ERROR(11, SIGBUS,  "segment not present", segment_not_present)
 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
 DO_ERROR(18, SIGSEGV, "reserved", reserved)
 /* Runs on IST stack */
 asmlinkage void do_stack_segment(struct pt_regs *regs, long error_code)
 {
 	if (notify_die(DIE_TRAP, "stack segment", regs, error_code,
 			12, SIGBUS) == NOTIFY_STOP)
 		return;
 	preempt_conditional_sti(regs);
 	do_trap(12, SIGBUS, "stack segment", regs, error_code, NULL);
 	preempt_conditional_cli(regs);
 }
 asmlinkage void do_double_fault(struct pt_regs * regs, long error_code)
 {
 	static const char str[] = "double fault";
 	struct task_struct *tsk = current;
 	/* Return not checked because double check cannot be ignored */
 	notify_die(DIE_TRAP, str, regs, error_code, 8, SIGSEGV);
 	tsk->thread.error_code = error_code;
 	tsk->thread.trap_no = 8;
 	/* This is always a kernel trap and never fixable (and thus must
 	   never return). */
 	for (;;)
 		die(str, regs, error_code);
 }
 asmlinkage void __kprobes do_general_protection(struct pt_regs * regs,
 						long error_code)
 {
 	struct task_struct *tsk = current;
 	conditional_sti(regs);
 	if (user_mode(regs)) {
 		tsk->thread.error_code = error_code;
 		tsk->thread.trap_no = 13;
 		if (exception_trace && unhandled_signal(tsk, SIGSEGV))
 			printk(KERN_INFO
 		       "%s[%d] general protection rip:%lx rsp:%lx error:%lx\n",
 			       tsk->comm, tsk->pid,
 			       regs->rip, regs->rsp, error_code);
 		force_sig(SIGSEGV, tsk);
 		return;
 	}
 	/* kernel gp */
 	{
 		const struct exception_table_entry *fixup;
 		fixup = search_exception_tables(regs->rip);
 		if (fixup) {
 			regs->rip = fixup->fixup;
 			return;
 		}
 		tsk->thread.error_code = error_code;
 		tsk->thread.trap_no = 13;
 		if (notify_die(DIE_GPF, "general protection fault", regs,
 					error_code, 13, SIGSEGV) == NOTIFY_STOP)
 			return;
 		die("general protection fault", regs, error_code);
 	}
 }
 static __kprobes void
 mem_parity_error(unsigned char reason, struct pt_regs * regs)
 {
 	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
 		reason);
 	printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
 	if (panic_on_unrecovered_nmi)
 		panic("NMI: Not continuing");
 	printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
 	/* Clear and disable the memory parity error line. */
 	reason = (reason & 0xf) | 4;
 	outb(reason, 0x61);
 }
 static __kprobes void
 io_check_error(unsigned char reason, struct pt_regs * regs)
 {
 	printk("NMI: IOCK error (debug interrupt?)\n");
 	show_registers(regs);
 	/* Re-enable the IOCK line, wait for a few seconds */
 	reason = (reason & 0xf) | 8;
 	outb(reason, 0x61);
 	mdelay(2000);
 	reason &= ~8;
 	outb(reason, 0x61);
 }
 static __kprobes void
 unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
 {
 	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
 		reason);
 	printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n");
 	if (panic_on_unrecovered_nmi)
 		panic("NMI: Not continuing");
 	printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
 }
 /* Runs on IST stack. This code must keep interrupts off all the time.
    Nested NMIs are prevented by the CPU. */
 asmlinkage __kprobes void default_do_nmi(struct pt_regs *regs)
 {
 	unsigned char reason = 0;
 	int cpu;
 	cpu = smp_processor_id();
 	/* Only the BSP gets external NMIs from the system.  */
 	if (!cpu)
 		reason = get_nmi_reason();
 	if (!(reason & 0xc0)) {
 		if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT)
 								== NOTIFY_STOP)
 			return;
 		/*
 		 * Ok, so this is none of the documented NMI sources,
 		 * so it must be the NMI watchdog.
 		 */
 		if (nmi_watchdog_tick(regs,reason))
 			return;
-		if (notify_die(DIE_NMI_POST, "nmi_post", regs, reason, 2, 0)
-								== NOTIFY_STOP)
-			return;
 		if (!do_nmi_callback(regs,cpu))
 			unknown_nmi_error(reason, regs);
 		return;
 	}
 	if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
 		return;
 	/* AK: following checks seem to be broken on modern chipsets. FIXME */
 	if (reason & 0x80)
 		mem_parity_error(reason, regs);
 	if (reason & 0x40)
 		io_check_error(reason, regs);
 }
 /* runs on IST stack. */
 asmlinkage void __kprobes do_int3(struct pt_regs * regs, long error_code)
 {
 	if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) == NOTIFY_STOP) {
 		return;
 	}
 	preempt_conditional_sti(regs);
 	do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
 	preempt_conditional_cli(regs);
 }
 /* Help handler running on IST stack to switch back to user stack
    for scheduling or signal handling. The actual stack switch is done in
    entry.S */
 asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
 {
 	struct pt_regs *regs = eregs;
 	/* Did already sync */
 	if (eregs == (struct pt_regs *)eregs->rsp)
 		;
 	/* Exception from user space */
 	else if (user_mode(eregs))
 		regs = task_pt_regs(current);
 	/* Exception from kernel and interrupts are enabled. Move to
  	   kernel process stack. */
 	else if (eregs->eflags & X86_EFLAGS_IF)
 		regs = (struct pt_regs *)(eregs->rsp -= sizeof(struct pt_regs));
 	if (eregs != regs)
 		*regs = *eregs;
 	return regs;
 }
 /* runs on IST stack. */
 asmlinkage void __kprobes do_debug(struct pt_regs * regs,
 				   unsigned long error_code)
 {
 	unsigned long condition;
 	struct task_struct *tsk = current;
 	siginfo_t info;
 	get_debugreg(condition, 6);
 	if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
 						SIGTRAP) == NOTIFY_STOP)
 		return;
 	preempt_conditional_sti(regs);
 	/* Mask out spurious debug traps due to lazy DR7 setting */
 	if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
 		if (!tsk->thread.debugreg7) {
 			goto clear_dr7;
 		}
 	}
 	tsk->thread.debugreg6 = condition;
 	/* Mask out spurious TF errors due to lazy TF clearing */
 	if (condition & DR_STEP) {
 		/*
 		 * The TF error should be masked out only if the current
 		 * process is not traced and if the TRAP flag has been set
 		 * previously by a tracing process (condition detected by
 		 * the PT_DTRACE flag); remember that the i386 TRAP flag
 		 * can be modified by the process itself in user mode,
 		 * allowing programs to debug themselves without the ptrace()
 		 * interface.
 		 */
                 if (!user_mode(regs))
                        goto clear_TF_reenable;
 		/*
 		 * Was the TF flag set by a debugger? If so, clear it now,
 		 * so that register information is correct.
 		 */
 		if (tsk->ptrace & PT_DTRACE) {
 			regs->eflags &= ~TF_MASK;
 			tsk->ptrace &= ~PT_DTRACE;
 		}
 	}
 	/* Ok, finally something we can handle */
 	tsk->thread.trap_no = 1;
 	tsk->thread.error_code = error_code;
 	info.si_signo = SIGTRAP;
 	info.si_errno = 0;
 	info.si_code = TRAP_BRKPT;
 	info.si_addr = user_mode(regs) ? (void __user *)regs->rip : NULL;
 	force_sig_info(SIGTRAP, &info, tsk);
 clear_dr7:
 	set_debugreg(0UL, 7);
 	preempt_conditional_cli(regs);
 	return;
 clear_TF_reenable:
 	set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
 	regs->eflags &= ~TF_MASK;
 	preempt_conditional_cli(regs);
 }
 static int kernel_math_error(struct pt_regs *regs, const char *str, int trapnr)
 {
 	const struct exception_table_entry *fixup;
 	fixup = search_exception_tables(regs->rip);
 	if (fixup) {
 		regs->rip = fixup->fixup;
 		return 1;
 	}
 	notify_die(DIE_GPF, str, regs, 0, trapnr, SIGFPE);
 	/* Illegal floating point operation in the kernel */
 	current->thread.trap_no = trapnr;
 	die(str, regs, 0);
 	return 0;
 }
 /*
  * Note that we play around with the 'TS' bit in an attempt to get
  * the correct behaviour even in the presence of the asynchronous
  * IRQ13 behaviour
  */
 asmlinkage void do_coprocessor_error(struct pt_regs *regs)
 {
 	void __user *rip = (void __user *)(regs->rip);
 	struct task_struct * task;
 	siginfo_t info;
 	unsigned short cwd, swd;
 	conditional_sti(regs);
 	if (!user_mode(regs) &&
 	    kernel_math_error(regs, "kernel x87 math error", 16))
 		return;
 	/*
 	 * Save the info for the exception handler and clear the error.
 	 */
 	task = current;
 	save_init_fpu(task);
 	task->thread.trap_no = 16;
 	task->thread.error_code = 0;
 	info.si_signo = SIGFPE;
 	info.si_errno = 0;
 	info.si_code = __SI_FAULT;
 	info.si_addr = rip;
 	/*
 	 * (~cwd & swd) will mask out exceptions that are not set to unmasked
 	 * status.  0x3f is the exception bits in these regs, 0x200 is the
 	 * C1 reg you need in case of a stack fault, 0x040 is the stack
 	 * fault bit.  We should only be taking one exception at a time,
 	 * so if this combination doesn't produce any single exception,
 	 * then we have a bad program that isn't synchronizing its FPU usage
 	 * and it will suffer the consequences since we won't be able to
 	 * fully reproduce the context of the exception
 	 */
 	cwd = get_fpu_cwd(task);
 	swd = get_fpu_swd(task);
 	switch (swd & ~cwd & 0x3f) {
 		case 0x000:
 		default:
 			break;
 		case 0x001: /* Invalid Op */
 			/*
 			 * swd & 0x240 == 0x040: Stack Underflow
 			 * swd & 0x240 == 0x240: Stack Overflow
 			 * User must clear the SF bit (0x40) if set
 			 */
 			info.si_code = FPE_FLTINV;
 			break;
 		case 0x002: /* Denormalize */
 		case 0x010: /* Underflow */
 			info.si_code = FPE_FLTUND;
 			break;
 		case 0x004: /* Zero Divide */
 			info.si_code = FPE_FLTDIV;
 			break;
 		case 0x008: /* Overflow */
 			info.si_code = FPE_FLTOVF;
 			break;
 		case 0x020: /* Precision */
 			info.si_code = FPE_FLTRES;
 			break;
 	}
 	force_sig_info(SIGFPE, &info, task);
 }
 asmlinkage void bad_intr(void)
 {
 	printk("bad interrupt");
 }
 asmlinkage void do_simd_coprocessor_error(struct pt_regs *regs)
 {
 	void __user *rip = (void __user *)(regs->rip);
 	struct task_struct * task;
 	siginfo_t info;
 	unsigned short mxcsr;
 	conditional_sti(regs);
 	if (!user_mode(regs) &&
         	kernel_math_error(regs, "kernel simd math error", 19))
 		return;
 	/*
 	 * Save the info for the exception handler and clear the error.
 	 */
 	task = current;
 	save_init_fpu(task);
 	task->thread.trap_no = 19;
 	task->thread.error_code = 0;
 	info.si_signo = SIGFPE;
 	info.si_errno = 0;
 	info.si_code = __SI_FAULT;
 	info.si_addr = rip;
 	/*
 	 * The SIMD FPU exceptions are handled a little differently, as there
 	 * is only a single status/control register.  Thus, to determine which
 	 * unmasked exception was caught we must mask the exception mask bits
 	 * at 0x1f80, and then use these to mask the exception bits at 0x3f.
 	 */
 	mxcsr = get_fpu_mxcsr(task);
 	switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
 		case 0x000:
 		default:
 			break;
 		case 0x001: /* Invalid Op */
 			info.si_code = FPE_FLTINV;
 			break;
 		case 0x002: /* Denormalize */
 		case 0x010: /* Underflow */
 			info.si_code = FPE_FLTUND;
 			break;
 		case 0x004: /* Zero Divide */
 			info.si_code = FPE_FLTDIV;
 			break;
 		case 0x008: /* Overflow */
 			info.si_code = FPE_FLTOVF;
 			break;
 		case 0x020: /* Precision */
 			info.si_code = FPE_FLTRES;
 			break;
 	}
 	force_sig_info(SIGFPE, &info, task);
 }
 asmlinkage void do_spurious_interrupt_bug(struct pt_regs * regs)
 {
 }
 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void)
 {
 }
 asmlinkage void __attribute__((weak)) mce_threshold_interrupt(void)
 {
 }
 /*
  *  'math_state_restore()' saves the current math information in the
  * old math state array, and gets the new ones from the current task
  *
  * Careful.. There are problems with IBM-designed IRQ13 behaviour.
  * Don't touch unless you *really* know how it works.
  */
 asmlinkage void math_state_restore(void)
 {
 	struct task_struct *me = current;
 	clts();			/* Allow maths ops (or we recurse) */
 	if (!used_math())
 		init_fpu(me);
 	restore_fpu_checking(&me->thread.i387.fxsave);
 	task_thread_info(me)->status |= TS_USEDFPU;
 	me->fpu_counter++;
 }
 void __init trap_init(void)
 {
 	set_intr_gate(0,&divide_error);
 	set_intr_gate_ist(1,&debug,DEBUG_STACK);
 	set_intr_gate_ist(2,&nmi,NMI_STACK);
  	set_system_gate_ist(3,&int3,DEBUG_STACK); /* int3 can be called from all */
 	set_system_gate(4,&overflow);	/* int4 can be called from all */
 	set_intr_gate(5,&bounds);
 	set_intr_gate(6,&invalid_op);
 	set_intr_gate(7,&device_not_available);
 	set_intr_gate_ist(8,&double_fault, DOUBLEFAULT_STACK);
 	set_intr_gate(9,&coprocessor_segment_overrun);
 	set_intr_gate(10,&invalid_TSS);
 	set_intr_gate(11,&segment_not_present);
 	set_intr_gate_ist(12,&stack_segment,STACKFAULT_STACK);
 	set_intr_gate(13,&general_protection);
 	set_intr_gate(14,&page_fault);
 	set_intr_gate(15,&spurious_interrupt_bug);
 	set_intr_gate(16,&coprocessor_error);
 	set_intr_gate(17,&alignment_check);
 #ifdef CONFIG_X86_MCE
 	set_intr_gate_ist(18,&machine_check, MCE_STACK);
 #endif
 	set_intr_gate(19,&simd_coprocessor_error);
 #ifdef CONFIG_IA32_EMULATION
 	set_system_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
 #endif
 	/*
 	 * Should be a barrier for any external CPU state.
 	 */
 	cpu_init();
 }
 static int __init oops_setup(char *s)
 {
 	if (!s)
 		return -EINVAL;
 	if (!strcmp(s, "panic"))
 		panic_on_oops = 1;
 	return 0;
 }
 early_param("oops", oops_setup);
 static int __init kstack_setup(char *s)
 {
 	if (!s)
 		return -EINVAL;
 	kstack_depth_to_print = simple_strtoul(s,NULL,0);
 	return 0;
 }
 early_param("kstack", kstack_setup);

drivers/char/ipmi/ipmi_watchdog.c

Diff comments View file @ faa8b6c

 /*
  * ipmi_watchdog.c
  *
  * A watchdog timer based upon the IPMI interface.
  *
  * Author: MontaVista Software, Inc.
  *         Corey Minyard <minyard@mvista.com>
  *         source@mvista.com
  *
  * Copyright 2002 MontaVista Software Inc.
  *
  *  This program is free software; you can redistribute it and/or modify it
  *  under the terms of the GNU General Public License as published by the
  *  Free Software Foundation; either version 2 of the License, or (at your
  *  option) any later version.
  *
  *
  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  *  You should have received a copy of the GNU General Public License along
  *  with this program; if not, write to the Free Software Foundation, Inc.,
  *  675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/ipmi.h>
 #include <linux/ipmi_smi.h>
 #include <linux/watchdog.h>
 #include <linux/miscdevice.h>
 #include <linux/init.h>
 #include <linux/completion.h>
 #include <linux/kdebug.h>
 #include <linux/rwsem.h>
 #include <linux/errno.h>
 #include <asm/uaccess.h>
 #include <linux/notifier.h>
 #include <linux/nmi.h>
 #include <linux/reboot.h>
 #include <linux/wait.h>
 #include <linux/poll.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
-#include <linux/delay.h>
 #include <asm/atomic.h>
-#ifdef CONFIG_X86
+#ifdef CONFIG_X86_LOCAL_APIC
-/* This is ugly, but I've determined that x86 is the only architecture
+#include <asm/apic.h>
-   that can reasonably support the IPMI NMI watchdog timeout at this
-   time.  If another architecture adds this capability somehow, it
-   will have to be a somewhat different mechanism and I have no idea
-   how it will work.  So in the unlikely event that another
-   architecture supports this, we can figure out a good generic
-   mechanism for it at that time. */
-#define HAVE_DIE_NMI_POST
 #endif
 #define	PFX "IPMI Watchdog: "
 /*
  * The IPMI command/response information for the watchdog timer.
  */
 /* values for byte 1 of the set command, byte 2 of the get response. */
 #define WDOG_DONT_LOG		(1 << 7)
 #define WDOG_DONT_STOP_ON_SET	(1 << 6)
 #define WDOG_SET_TIMER_USE(byte, use) \
 	byte = ((byte) & 0xf8) | ((use) & 0x7)
 #define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7)
 #define WDOG_TIMER_USE_BIOS_FRB2	1
 #define WDOG_TIMER_USE_BIOS_POST	2
 #define WDOG_TIMER_USE_OS_LOAD		3
 #define WDOG_TIMER_USE_SMS_OS		4
 #define WDOG_TIMER_USE_OEM		5
 /* values for byte 2 of the set command, byte 3 of the get response. */
 #define WDOG_SET_PRETIMEOUT_ACT(byte, use) \
 	byte = ((byte) & 0x8f) | (((use) & 0x7) << 4)
 #define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7)
 #define WDOG_PRETIMEOUT_NONE		0
 #define WDOG_PRETIMEOUT_SMI		1
 #define WDOG_PRETIMEOUT_NMI		2
 #define WDOG_PRETIMEOUT_MSG_INT		3
 /* Operations that can be performed on a pretimout. */
 #define WDOG_PREOP_NONE		0
 #define WDOG_PREOP_PANIC	1
 #define WDOG_PREOP_GIVE_DATA	2 /* Cause data to be available to
                                      read.  Doesn't work in NMI
                                      mode. */
 /* Actions to perform on a full timeout. */
 #define WDOG_SET_TIMEOUT_ACT(byte, use) \
 	byte = ((byte) & 0xf8) | ((use) & 0x7)
 #define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7)
 #define WDOG_TIMEOUT_NONE		0
 #define WDOG_TIMEOUT_RESET		1
 #define WDOG_TIMEOUT_POWER_DOWN		2
 #define WDOG_TIMEOUT_POWER_CYCLE	3
 /* Byte 3 of the get command, byte 4 of the get response is the
    pre-timeout in seconds. */
 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */
 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2	(1 << 1)
 #define WDOG_EXPIRE_CLEAR_BIOS_POST	(1 << 2)
 #define WDOG_EXPIRE_CLEAR_OS_LOAD	(1 << 3)
 #define WDOG_EXPIRE_CLEAR_SMS_OS	(1 << 4)
 #define WDOG_EXPIRE_CLEAR_OEM		(1 << 5)
 /* Setting/getting the watchdog timer value.  This is for bytes 5 and
    6 (the timeout time) of the set command, and bytes 6 and 7 (the
    timeout time) and 8 and 9 (the current countdown value) of the
    response.  The timeout value is given in seconds (in the command it
    is 100ms intervals). */
 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \
 	(byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
 #define WDOG_GET_TIMEOUT(byte1, byte2) \
 	(((byte1) | ((byte2) << 8)) / 10)
 #define IPMI_WDOG_RESET_TIMER		0x22
 #define IPMI_WDOG_SET_TIMER		0x24
 #define IPMI_WDOG_GET_TIMER		0x25
 /* These are here until the real ones get into the watchdog.h interface. */
 #ifndef WDIOC_GETTIMEOUT
 #define	WDIOC_GETTIMEOUT        _IOW(WATCHDOG_IOCTL_BASE, 20, int)
 #endif
 #ifndef WDIOC_SET_PRETIMEOUT
 #define	WDIOC_SET_PRETIMEOUT     _IOW(WATCHDOG_IOCTL_BASE, 21, int)
 #endif
 #ifndef WDIOC_GET_PRETIMEOUT
 #define	WDIOC_GET_PRETIMEOUT     _IOW(WATCHDOG_IOCTL_BASE, 22, int)
 #endif
 static int nowayout = WATCHDOG_NOWAYOUT;
 static ipmi_user_t watchdog_user;
 static int watchdog_ifnum;
 /* Default the timeout to 10 seconds. */
 static int timeout = 10;
 /* The pre-timeout is disabled by default. */
 static int pretimeout;
 /* Default action is to reset the board on a timeout. */
 static unsigned char action_val = WDOG_TIMEOUT_RESET;
 static char action[16] = "reset";
 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
 static char preaction[16] = "pre_none";
 static unsigned char preop_val = WDOG_PREOP_NONE;
 static char preop[16] = "preop_none";
 static DEFINE_SPINLOCK(ipmi_read_lock);
 static char data_to_read;
 static DECLARE_WAIT_QUEUE_HEAD(read_q);
 static struct fasync_struct *fasync_q;
 static char pretimeout_since_last_heartbeat;
 static char expect_close;
 static int ifnum_to_use = -1;
 static DECLARE_RWSEM(register_sem);
 /* Parameters to ipmi_set_timeout */
 #define IPMI_SET_TIMEOUT_NO_HB			0
 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY	1
 #define IPMI_SET_TIMEOUT_FORCE_HB		2
 static int ipmi_set_timeout(int do_heartbeat);
 static void ipmi_register_watchdog(int ipmi_intf);
 static void ipmi_unregister_watchdog(int ipmi_intf);
 /* If true, the driver will start running as soon as it is configured
    and ready. */
 static int start_now;
 static int set_param_int(const char *val, struct kernel_param *kp)
 {
 	char *endp;
 	int  l;
 	int  rv = 0;
 	if (!val)
 		return -EINVAL;
 	l = simple_strtoul(val, &endp, 0);
 	if (endp == val)
 		return -EINVAL;
 	down_read(&register_sem);
 	*((int *)kp->arg) = l;
 	if (watchdog_user)
 		rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 	up_read(&register_sem);
 	return rv;
 }
 static int get_param_int(char *buffer, struct kernel_param *kp)
 {
 	return sprintf(buffer, "%i", *((int *)kp->arg));
 }
 typedef int (*action_fn)(const char *intval, char *outval);
 static int action_op(const char *inval, char *outval);
 static int preaction_op(const char *inval, char *outval);
 static int preop_op(const char *inval, char *outval);
 static void check_parms(void);
 static int set_param_str(const char *val, struct kernel_param *kp)
 {
 	action_fn  fn = (action_fn) kp->arg;
 	int        rv = 0;
 	char       valcp[16];
 	char       *s;
 	strncpy(valcp, val, 16);
 	valcp[15] = '\0';
 	s = strstrip(valcp);
 	down_read(&register_sem);
 	rv = fn(s, NULL);
 	if (rv)
 		goto out_unlock;
 	check_parms();
 	if (watchdog_user)
 		rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
  out_unlock:
 	up_read(&register_sem);
 	return rv;
 }
 static int get_param_str(char *buffer, struct kernel_param *kp)
 {
 	action_fn fn = (action_fn) kp->arg;
 	int       rv;
 	rv = fn(NULL, buffer);
 	if (rv)
 		return rv;
 	return strlen(buffer);
 }
 static int set_param_wdog_ifnum(const char *val, struct kernel_param *kp)
 {
 	int rv = param_set_int(val, kp);
 	if (rv)
 		return rv;
 	if ((ifnum_to_use < 0) || (ifnum_to_use == watchdog_ifnum))
 		return 0;
 	ipmi_unregister_watchdog(watchdog_ifnum);
 	ipmi_register_watchdog(ifnum_to_use);
 	return 0;
 }
 module_param_call(ifnum_to_use, set_param_wdog_ifnum, get_param_int,
 		  &ifnum_to_use, 0644);
 MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
 		 "timer.  Setting to -1 defaults to the first registered "
 		 "interface");
 module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
 module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644);
 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
 module_param_call(action, set_param_str, get_param_str, action_op, 0644);
 MODULE_PARM_DESC(action, "Timeout action. One of: "
 		 "reset, none, power_cycle, power_off.");
 module_param_call(preaction, set_param_str, get_param_str, preaction_op, 0644);
 MODULE_PARM_DESC(preaction, "Pretimeout action.  One of: "
 		 "pre_none, pre_smi, pre_nmi, pre_int.");
 module_param_call(preop, set_param_str, get_param_str, preop_op, 0644);
 MODULE_PARM_DESC(preop, "Pretimeout driver operation.  One of: "
 		 "preop_none, preop_panic, preop_give_data.");
 module_param(start_now, int, 0444);
 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
 		 "soon as the driver is loaded.");
 module_param(nowayout, int, 0644);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
 		 "(default=CONFIG_WATCHDOG_NOWAYOUT)");
 /* Default state of the timer. */
 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 /* If shutting down via IPMI, we ignore the heartbeat. */
 static int ipmi_ignore_heartbeat;
 /* Is someone using the watchdog?  Only one user is allowed. */
 static unsigned long ipmi_wdog_open;
 /* If set to 1, the heartbeat command will set the state to reset and
    start the timer.  The timer doesn't normally run when the driver is
    first opened until the heartbeat is set the first time, this
    variable is used to accomplish this. */
 static int ipmi_start_timer_on_heartbeat;
 /* IPMI version of the BMC. */
 static unsigned char ipmi_version_major;
 static unsigned char ipmi_version_minor;
 /* If a pretimeout occurs, this is used to allow only one panic to happen. */
 static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
-#ifdef HAVE_DIE_NMI_POST
-static int testing_nmi;
-static int nmi_handler_registered;
-#endif
 static int ipmi_heartbeat(void);
 static void panic_halt_ipmi_heartbeat(void);
 /* We use a mutex to make sure that only one thing can send a set
    timeout at one time, because we only have one copy of the data.
    The mutex is claimed when the set_timeout is sent and freed
    when both messages are free. */
 static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
 static DEFINE_MUTEX(set_timeout_lock);
 static DECLARE_COMPLETION(set_timeout_wait);
 static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
 {
     if (atomic_dec_and_test(&set_timeout_tofree))
 	    complete(&set_timeout_wait);
 }
 static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
 {
     if (atomic_dec_and_test(&set_timeout_tofree))
 	    complete(&set_timeout_wait);
 }
 static struct ipmi_smi_msg set_timeout_smi_msg =
 {
 	.done = set_timeout_free_smi
 };
 static struct ipmi_recv_msg set_timeout_recv_msg =
 {
 	.done = set_timeout_free_recv
 };
 static int i_ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
 			      struct ipmi_recv_msg *recv_msg,
 			      int                  *send_heartbeat_now)
 {
 	struct kernel_ipmi_msg            msg;
 	unsigned char                     data[6];
 	int                               rv;
 	struct ipmi_system_interface_addr addr;
 	int                               hbnow = 0;
-	/* These can be cleared as we are setting the timeout. */
-	ipmi_start_timer_on_heartbeat = 0;
-	pretimeout_since_last_heartbeat = 0;
 	data[0] = 0;
 	WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
 	if ((ipmi_version_major > 1)
 	    || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5)))
 	{
 		/* This is an IPMI 1.5-only feature. */
 		data[0] |= WDOG_DONT_STOP_ON_SET;
 	} else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
 		/* In ipmi 1.0, setting the timer stops the watchdog, we
 		   need to start it back up again. */
 		hbnow = 1;
 	}
 	data[1] = 0;
 	WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
 	if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
 	    WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
 	    data[2] = pretimeout;
 	} else {
 	    WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE);
 	    data[2] = 0; /* No pretimeout. */
 	}
 	data[3] = 0;
 	WDOG_SET_TIMEOUT(data[4], data[5], timeout);
 	addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
 	addr.channel = IPMI_BMC_CHANNEL;
 	addr.lun = 0;
 	msg.netfn = 0x06;
 	msg.cmd = IPMI_WDOG_SET_TIMER;
 	msg.data = data;
 	msg.data_len = sizeof(data);
 	rv = ipmi_request_supply_msgs(watchdog_user,
 				      (struct ipmi_addr *) &addr,
 				      0,
 				      &msg,
 				      NULL,
 				      smi_msg,
 				      recv_msg,
 				      1);
 	if (rv) {
 		printk(KERN_WARNING PFX "set timeout error: %d\n",
 		       rv);
 	}
 	if (send_heartbeat_now)
 	    *send_heartbeat_now = hbnow;
 	return rv;
 }
 static int ipmi_set_timeout(int do_heartbeat)
 {
 	int send_heartbeat_now;
 	int rv;
 	/* We can only send one of these at a time. */
 	mutex_lock(&set_timeout_lock);
 	atomic_set(&set_timeout_tofree, 2);
 	rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
 				&set_timeout_recv_msg,
 				&send_heartbeat_now);
 	if (rv) {
 		mutex_unlock(&set_timeout_lock);
 		goto out;
 	}
 	wait_for_completion(&set_timeout_wait);
-	mutex_unlock(&set_timeout_lock);
 	if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
 	    || ((send_heartbeat_now)
 		&& (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
+	{
 		rv = ipmi_heartbeat();
+	}
+	mutex_unlock(&set_timeout_lock);
 out:
 	return rv;
 }
 static void dummy_smi_free(struct ipmi_smi_msg *msg)
 {
 }
 static void dummy_recv_free(struct ipmi_recv_msg *msg)
 {
 }
 static struct ipmi_smi_msg panic_halt_smi_msg =
 {
 	.done = dummy_smi_free
 };
 static struct ipmi_recv_msg panic_halt_recv_msg =
 {
 	.done = dummy_recv_free
 };
 /* Special call, doesn't claim any locks.  This is only to be called
    at panic or halt time, in run-to-completion mode, when the caller
    is the only CPU and the only thing that will be going is these IPMI
    calls. */
 static void panic_halt_ipmi_set_timeout(void)
 {
 	int send_heartbeat_now;
 	int rv;
 	rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
 				&panic_halt_recv_msg,
 				&send_heartbeat_now);
 	if (!rv) {
 		if (send_heartbeat_now)
 			panic_halt_ipmi_heartbeat();
 	}
 }
 /* We use a semaphore to make sure that only one thing can send a
    heartbeat at one time, because we only have one copy of the data.
    The semaphore is claimed when the set_timeout is sent and freed
    when both messages are free. */
 static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
 static DEFINE_MUTEX(heartbeat_lock);
 static DECLARE_COMPLETION(heartbeat_wait);
 static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
 {
     if (atomic_dec_and_test(&heartbeat_tofree))
 	    complete(&heartbeat_wait);
 }
 static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
 {
     if (atomic_dec_and_test(&heartbeat_tofree))
 	    complete(&heartbeat_wait);
 }
 static struct ipmi_smi_msg heartbeat_smi_msg =
 {
 	.done = heartbeat_free_smi
 };
 static struct ipmi_recv_msg heartbeat_recv_msg =
 {
 	.done = heartbeat_free_recv
 };
 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg =
 {
 	.done = dummy_smi_free
 };
 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg =
 {
 	.done = dummy_recv_free
 };
 static int ipmi_heartbeat(void)
 {
 	struct kernel_ipmi_msg            msg;
 	int                               rv;
 	struct ipmi_system_interface_addr addr;
-	if (ipmi_ignore_heartbeat)
+	if (ipmi_ignore_heartbeat) {
 		return 0;
+	}
 	if (ipmi_start_timer_on_heartbeat) {
+		ipmi_start_timer_on_heartbeat = 0;
 		ipmi_watchdog_state = action_val;
 		return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 	} else if (pretimeout_since_last_heartbeat) {
 		/* A pretimeout occurred, make sure we set the timeout.
 		   We don't want to set the action, though, we want to
 		   leave that alone (thus it can't be combined with the
 		   above operation. */
+		pretimeout_since_last_heartbeat = 0;
 		return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 	}
 	mutex_lock(&heartbeat_lock);
 	atomic_set(&heartbeat_tofree, 2);
 	/* Don't reset the timer if we have the timer turned off, that
            re-enables the watchdog. */
 	if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) {
 		mutex_unlock(&heartbeat_lock);
 		return 0;
 	}
 	addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
 	addr.channel = IPMI_BMC_CHANNEL;
 	addr.lun = 0;
 	msg.netfn = 0x06;
 	msg.cmd = IPMI_WDOG_RESET_TIMER;
 	msg.data = NULL;
 	msg.data_len = 0;
 	rv = ipmi_request_supply_msgs(watchdog_user,
 				      (struct ipmi_addr *) &addr,
 				      0,
 				      &msg,
 				      NULL,
 				      &heartbeat_smi_msg,
 				      &heartbeat_recv_msg,
 				      1);
 	if (rv) {
 		mutex_unlock(&heartbeat_lock);
 		printk(KERN_WARNING PFX "heartbeat failure: %d\n",
 		       rv);
 		return rv;
 	}
 	/* Wait for the heartbeat to be sent. */
 	wait_for_completion(&heartbeat_wait);
 	if (heartbeat_recv_msg.msg.data[0] != 0) {
 	    /* Got an error in the heartbeat response.  It was already
 	       reported in ipmi_wdog_msg_handler, but we should return
 	       an error here. */
 	    rv = -EINVAL;
 	}
 	mutex_unlock(&heartbeat_lock);
 	return rv;
 }
 static void panic_halt_ipmi_heartbeat(void)
 {
 	struct kernel_ipmi_msg             msg;
 	struct ipmi_system_interface_addr addr;
 	/* Don't reset the timer if we have the timer turned off, that
            re-enables the watchdog. */
 	if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
 		return;
 	addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
 	addr.channel = IPMI_BMC_CHANNEL;
 	addr.lun = 0;
 	msg.netfn = 0x06;
 	msg.cmd = IPMI_WDOG_RESET_TIMER;
 	msg.data = NULL;
 	msg.data_len = 0;
 	ipmi_request_supply_msgs(watchdog_user,
 				 (struct ipmi_addr *) &addr,
 				 0,
 				 &msg,
 				 NULL,
 				 &panic_halt_heartbeat_smi_msg,
 				 &panic_halt_heartbeat_recv_msg,
 				 1);
 }
 static struct watchdog_info ident =
 {
 	.options	= 0,	/* WDIOF_SETTIMEOUT, */
 	.firmware_version = 1,
 	.identity	= "IPMI"
 };
 static int ipmi_ioctl(struct inode *inode, struct file *file,
 		      unsigned int cmd, unsigned long arg)
 {
 	void __user *argp = (void __user *)arg;
 	int i;
 	int val;
 	switch(cmd) {
 	case WDIOC_GETSUPPORT:
 		i = copy_to_user(argp, &ident, sizeof(ident));
 		return i ? -EFAULT : 0;
 	case WDIOC_SETTIMEOUT:
 		i = copy_from_user(&val, argp, sizeof(int));
 		if (i)
 			return -EFAULT;
 		timeout = val;
 		return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 	case WDIOC_GETTIMEOUT:
 		i = copy_to_user(argp, &timeout, sizeof(timeout));
 		if (i)
 			return -EFAULT;
 		return 0;
 	case WDIOC_SET_PRETIMEOUT:
 		i = copy_from_user(&val, argp, sizeof(int));
 		if (i)
 			return -EFAULT;
 		pretimeout = val;
 		return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 	case WDIOC_GET_PRETIMEOUT:
 		i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
 		if (i)
 			return -EFAULT;
 		return 0;
 	case WDIOC_KEEPALIVE:
 		return ipmi_heartbeat();
 	case WDIOC_SETOPTIONS:
 		i = copy_from_user(&val, argp, sizeof(int));
 		if (i)
 			return -EFAULT;
 		if (val & WDIOS_DISABLECARD)
 		{
 			ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 			ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 			ipmi_start_timer_on_heartbeat = 0;
 		}
 		if (val & WDIOS_ENABLECARD)
 		{
 			ipmi_watchdog_state = action_val;
 			ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 		}
 		return 0;
 	case WDIOC_GETSTATUS:
 		val = 0;
 		i = copy_to_user(argp, &val, sizeof(val));
 		if (i)
 			return -EFAULT;
 		return 0;
 	default:
 		return -ENOIOCTLCMD;
 	}
 }
 static ssize_t ipmi_write(struct file *file,
 			  const char  __user *buf,
 			  size_t      len,
 			  loff_t      *ppos)
 {
 	int rv;
 	if (len) {
 	    	if (!nowayout) {
 		    	size_t i;
 			/* In case it was set long ago */
 			expect_close = 0;
     			for (i = 0; i != len; i++) {
 				char c;
 				if (get_user(c, buf + i))
 					return -EFAULT;
 				if (c == 'V')
 					expect_close = 42;
 			}
 		}
 		rv = ipmi_heartbeat();
 		if (rv)
 			return rv;
 		return 1;
 	}
 	return 0;
 }
 static ssize_t ipmi_read(struct file *file,
 			 char        __user *buf,
 			 size_t      count,
 			 loff_t      *ppos)
 {
 	int          rv = 0;
 	wait_queue_t wait;
 	if (count <= 0)
 		return 0;
 	/* Reading returns if the pretimeout has gone off, and it only does
 	   it once per pretimeout. */
 	spin_lock(&ipmi_read_lock);
 	if (!data_to_read) {
 		if (file->f_flags & O_NONBLOCK) {
 			rv = -EAGAIN;
 			goto out;
 		}
 		init_waitqueue_entry(&wait, current);
 		add_wait_queue(&read_q, &wait);
 		while (!data_to_read) {
 			set_current_state(TASK_INTERRUPTIBLE);
 			spin_unlock(&ipmi_read_lock);
 			schedule();
 			spin_lock(&ipmi_read_lock);
 		}
 		remove_wait_queue(&read_q, &wait);
 		if (signal_pending(current)) {
 			rv = -ERESTARTSYS;
 			goto out;
 		}
 	}
 	data_to_read = 0;
  out:
 	spin_unlock(&ipmi_read_lock);
 	if (rv == 0) {
 		if (copy_to_user(buf, &data_to_read, 1))
 			rv = -EFAULT;
 		else
 			rv = 1;
 	}
 	return rv;
 }
 static int ipmi_open(struct inode *ino, struct file *filep)
 {
         switch (iminor(ino)) {
         case WATCHDOG_MINOR:
 		if (test_and_set_bit(0, &ipmi_wdog_open))
                         return -EBUSY;
 		/* Don't start the timer now, let it start on the
 		   first heartbeat. */
 		ipmi_start_timer_on_heartbeat = 1;
 		return nonseekable_open(ino, filep);
 	default:
 		return (-ENODEV);
         }
 }
 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
 {
 	unsigned int mask = 0;
 	poll_wait(file, &read_q, wait);
 	spin_lock(&ipmi_read_lock);
 	if (data_to_read)
 		mask |= (POLLIN | POLLRDNORM);
 	spin_unlock(&ipmi_read_lock);
 	return mask;
 }
 static int ipmi_fasync(int fd, struct file *file, int on)
 {
 	int result;
 	result = fasync_helper(fd, file, on, &fasync_q);
 	return (result);
 }
 static int ipmi_close(struct inode *ino, struct file *filep)
 {
 	if (iminor(ino) == WATCHDOG_MINOR) {
 		if (expect_close == 42) {
 			ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 			ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 		} else {
 			printk(KERN_CRIT PFX
 			       "Unexpected close, not stopping watchdog!\n");
 			ipmi_heartbeat();
 		}
 		clear_bit(0, &ipmi_wdog_open);
 	}
 	ipmi_fasync (-1, filep, 0);
 	expect_close = 0;
 	return 0;
 }
 static const struct file_operations ipmi_wdog_fops = {
 	.owner   = THIS_MODULE,
 	.read    = ipmi_read,
 	.poll    = ipmi_poll,
 	.write   = ipmi_write,
 	.ioctl   = ipmi_ioctl,
 	.open    = ipmi_open,
 	.release = ipmi_close,
 	.fasync  = ipmi_fasync,
 };
 static struct miscdevice ipmi_wdog_miscdev = {
 	.minor		= WATCHDOG_MINOR,
 	.name		= "watchdog",
 	.fops		= &ipmi_wdog_fops
 };
 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
 				  void                 *handler_data)
 {
 	if (msg->msg.data[0] != 0) {
 		printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
 		       msg->msg.data[0],
 		       msg->msg.cmd);
 	}
 	ipmi_free_recv_msg(msg);
 }
 static void ipmi_wdog_pretimeout_handler(void *handler_data)
 {
 	if (preaction_val != WDOG_PRETIMEOUT_NONE) {
 		if (preop_val == WDOG_PREOP_PANIC) {
 			if (atomic_inc_and_test(&preop_panic_excl))
 				panic("Watchdog pre-timeout");
 		} else if (preop_val == WDOG_PREOP_GIVE_DATA) {
 			spin_lock(&ipmi_read_lock);
 			data_to_read = 1;
 			wake_up_interruptible(&read_q);
 			kill_fasync(&fasync_q, SIGIO, POLL_IN);
 			spin_unlock(&ipmi_read_lock);
 		}
 	}
 	/* On some machines, the heartbeat will give
 	   an error and not work unless we re-enable
 	   the timer.   So do so. */
 	pretimeout_since_last_heartbeat = 1;
 }
 static struct ipmi_user_hndl ipmi_hndlrs =
 {
 	.ipmi_recv_hndl           = ipmi_wdog_msg_handler,
 	.ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
 };
 static void ipmi_register_watchdog(int ipmi_intf)
 {
 	int rv = -EBUSY;
 	down_write(&register_sem);
 	if (watchdog_user)
 		goto out;
 	if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
 		goto out;
 	watchdog_ifnum = ipmi_intf;
 	rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
 	if (rv < 0) {
 		printk(KERN_CRIT PFX "Unable to register with ipmi\n");
 		goto out;
 	}
 	ipmi_get_version(watchdog_user,
 			 &ipmi_version_major,
 			 &ipmi_version_minor);
 	rv = misc_register(&ipmi_wdog_miscdev);
 	if (rv < 0) {
 		ipmi_destroy_user(watchdog_user);
 		watchdog_user = NULL;
 		printk(KERN_CRIT PFX "Unable to register misc device\n");
 	}
-#ifdef HAVE_DIE_NMI_POST
-	if (nmi_handler_registered) {
-		int old_pretimeout = pretimeout;
-		int old_timeout = timeout;
-		int old_preop_val = preop_val;
-		/* Set the pretimeout to go off in a second and give
-		   ourselves plenty of time to stop the timer. */
-		ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
-		preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
-		pretimeout = 99;
-		timeout = 100;
-		testing_nmi = 1;
-		rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
-		if (rv) {
-			printk(KERN_WARNING PFX "Error starting timer to"
-			       " test NMI: 0x%x.  The NMI pretimeout will"
-			       " likely not work\n", rv);
-			rv = 0;
-			goto out_restore;
-		}
-		msleep(1500);
-		if (testing_nmi != 2) {
-			printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
-			       " occur.  The NMI pretimeout will"
-			       " likely not work\n");
-		}
-	out_restore:
-		testing_nmi = 0;
-		preop_val = old_preop_val;
-		pretimeout = old_pretimeout;
-		timeout = old_timeout;
-	}
-#endif
  out:
 	up_write(&register_sem);
 	if ((start_now) && (rv == 0)) {
 		/* Run from startup, so start the timer now. */
 		start_now = 0; /* Disable this function after first startup. */
 		ipmi_watchdog_state = action_val;
 		ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 		printk(KERN_INFO PFX "Starting now!\n");
-	} else {
-		/* Stop the timer now. */
-		ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
-		ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 	}
 }
 static void ipmi_unregister_watchdog(int ipmi_intf)
 {
 	int rv;
 	down_write(&register_sem);
 	if (!watchdog_user)
 		goto out;
 	if (watchdog_ifnum != ipmi_intf)
 		goto out;
 	/* Make sure no one can call us any more. */
 	misc_deregister(&ipmi_wdog_miscdev);
 	/* Wait to make sure the message makes it out.  The lower layer has
 	   pointers to our buffers, we want to make sure they are done before
 	   we release our memory. */
 	while (atomic_read(&set_timeout_tofree))
 		schedule_timeout_uninterruptible(1);
 	/* Disconnect from IPMI. */
 	rv = ipmi_destroy_user(watchdog_user);
 	if (rv) {
 		printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
 		       rv);
 	}
 	watchdog_user = NULL;
  out:
 	up_write(&register_sem);
 }
-#ifdef HAVE_DIE_NMI_POST
+#ifdef HAVE_NMI_HANDLER
 static int
-ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
+ipmi_nmi(void *dev_id, int cpu, int handled)
 {
-	if (val != DIE_NMI_POST)
-		return NOTIFY_OK;
-	if (testing_nmi) {
-		testing_nmi = 2;
-		return NOTIFY_STOP;
-	}
         /* If we are not expecting a timeout, ignore it. */
 	if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
-		return NOTIFY_OK;
+		return NOTIFY_DONE;
-	if (preaction_val != WDOG_PRETIMEOUT_NMI)
-		return NOTIFY_OK;
 	/* If no one else handled the NMI, we assume it was the IPMI
            watchdog. */
-	if (preop_val == WDOG_PREOP_PANIC) {
+	if ((!handled) && (preop_val == WDOG_PREOP_PANIC)) {
 		/* On some machines, the heartbeat will give
 		   an error and not work unless we re-enable
 		   the timer.   So do so. */
 		pretimeout_since_last_heartbeat = 1;
 		if (atomic_inc_and_test(&preop_panic_excl))
 			panic(PFX "pre-timeout");
 	}
-	return NOTIFY_STOP;
+	return NOTIFY_DONE;
 }
-static struct notifier_block ipmi_nmi_handler = {
+static struct nmi_handler ipmi_nmi_handler =
-	.notifier_call = ipmi_nmi
+{
+	.link     = LIST_HEAD_INIT(ipmi_nmi_handler.link),
+	.dev_name = "ipmi_watchdog",
+	.dev_id   = NULL,
+	.handler  = ipmi_nmi,
+	.priority = 0, /* Call us last. */
 };
+int nmi_handler_registered;
 #endif
 static int wdog_reboot_handler(struct notifier_block *this,
 			       unsigned long         code,
 			       void                  *unused)
 {
 	static int reboot_event_handled = 0;
 	if ((watchdog_user) && (!reboot_event_handled)) {
 		/* Make sure we only do this once. */
 		reboot_event_handled = 1;
 		if (code == SYS_DOWN || code == SYS_HALT) {
 			/* Disable the WDT if we are shutting down. */
 			ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 			panic_halt_ipmi_set_timeout();
 		} else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
 			/* Set a long timer to let the reboot happens, but
 			   reboot if it hangs, but only if the watchdog
 			   timer was already running. */
 			timeout = 120;
 			pretimeout = 0;
 			ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
 			panic_halt_ipmi_set_timeout();
 		}
 	}
 	return NOTIFY_OK;
 }
 static struct notifier_block wdog_reboot_notifier = {
 	.notifier_call	= wdog_reboot_handler,
 	.next		= NULL,
 	.priority	= 0
 };
 static int wdog_panic_handler(struct notifier_block *this,
 			      unsigned long         event,
 			      void                  *unused)
 {
 	static int panic_event_handled = 0;
 	/* On a panic, if we have a panic timeout, make sure to extend
 	   the watchdog timer to a reasonable value to complete the
 	   panic, if the watchdog timer is running.  Plus the
 	   pretimeout is meaningless at panic time. */
 	if (watchdog_user && !panic_event_handled &&
 	    ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
 		/* Make sure we do this only once. */
 		panic_event_handled = 1;
 		timeout = 255;
 		pretimeout = 0;
 		panic_halt_ipmi_set_timeout();
 	}
 	return NOTIFY_OK;
 }
 static struct notifier_block wdog_panic_notifier = {
 	.notifier_call	= wdog_panic_handler,
 	.next		= NULL,
 	.priority	= 150	/* priority: INT_MAX >= x >= 0 */
 };
 static void ipmi_new_smi(int if_num, struct device *device)
 {
 	ipmi_register_watchdog(if_num);
 }
 static void ipmi_smi_gone(int if_num)
 {
 	ipmi_unregister_watchdog(if_num);
 }
 static struct ipmi_smi_watcher smi_watcher =
 {
 	.owner    = THIS_MODULE,
 	.new_smi  = ipmi_new_smi,
 	.smi_gone = ipmi_smi_gone
 };
 static int action_op(const char *inval, char *outval)
 {
 	if (outval)
 		strcpy(outval, action);
 	if (!inval)
 		return 0;
 	if (strcmp(inval, "reset") == 0)
 		action_val = WDOG_TIMEOUT_RESET;
 	else if (strcmp(inval, "none") == 0)
 		action_val = WDOG_TIMEOUT_NONE;
 	else if (strcmp(inval, "power_cycle") == 0)
 		action_val = WDOG_TIMEOUT_POWER_CYCLE;
 	else if (strcmp(inval, "power_off") == 0)
 		action_val = WDOG_TIMEOUT_POWER_DOWN;
 	else
 		return -EINVAL;
 	strcpy(action, inval);
 	return 0;
 }
 static int preaction_op(const char *inval, char *outval)
 {
 	if (outval)
 		strcpy(outval, preaction);
 	if (!inval)
 		return 0;
 	if (strcmp(inval, "pre_none") == 0)
 		preaction_val = WDOG_PRETIMEOUT_NONE;
 	else if (strcmp(inval, "pre_smi") == 0)
 		preaction_val = WDOG_PRETIMEOUT_SMI;
-#ifdef HAVE_DIE_NMI_POST
+#ifdef HAVE_NMI_HANDLER
 	else if (strcmp(inval, "pre_nmi") == 0)
 		preaction_val = WDOG_PRETIMEOUT_NMI;
 #endif
 	else if (strcmp(inval, "pre_int") == 0)
 		preaction_val = WDOG_PRETIMEOUT_MSG_INT;
 	else
 		return -EINVAL;
 	strcpy(preaction, inval);
 	return 0;
 }
 static int preop_op(const char *inval, char *outval)
 {
 	if (outval)
 		strcpy(outval, preop);
 	if (!inval)
 		return 0;
 	if (strcmp(inval, "preop_none") == 0)
 		preop_val = WDOG_PREOP_NONE;
 	else if (strcmp(inval, "preop_panic") == 0)
 		preop_val = WDOG_PREOP_PANIC;
 	else if (strcmp(inval, "preop_give_data") == 0)
 		preop_val = WDOG_PREOP_GIVE_DATA;
 	else
 		return -EINVAL;
 	strcpy(preop, inval);
 	return 0;
 }
 static void check_parms(void)
 {
-#ifdef HAVE_DIE_NMI_POST
+#ifdef HAVE_NMI_HANDLER
 	int do_nmi = 0;
 	int rv;
 	if (preaction_val == WDOG_PRETIMEOUT_NMI) {
 		do_nmi = 1;
 		if (preop_val == WDOG_PREOP_GIVE_DATA) {
 			printk(KERN_WARNING PFX "Pretimeout op is to give data"
 			       " but NMI pretimeout is enabled, setting"
 			       " pretimeout op to none\n");
 			preop_op("preop_none", NULL);
 			do_nmi = 0;
 		}
+#ifdef CONFIG_X86_LOCAL_APIC
+		if (nmi_watchdog == NMI_IO_APIC) {
+			printk(KERN_WARNING PFX "nmi_watchdog is set to IO APIC"
+			       " mode (value is %d), that is incompatible"
+			       " with using NMI in the IPMI watchdog."
+			       " Disabling IPMI nmi pretimeout.\n",
+			       nmi_watchdog);
+			preaction_val = WDOG_PRETIMEOUT_NONE;
+			do_nmi = 0;
+		}
+#endif
 	}
 	if (do_nmi && !nmi_handler_registered) {
-		rv = register_die_notifier(&ipmi_nmi_handler);
+		rv = request_nmi(&ipmi_nmi_handler);
 		if (rv) {
 			printk(KERN_WARNING PFX
 			       "Can't register nmi handler\n");
 			return;
 		} else
 			nmi_handler_registered = 1;
 	} else if (!do_nmi && nmi_handler_registered) {
-		unregister_die_notifier(&ipmi_nmi_handler);
+		release_nmi(&ipmi_nmi_handler);
 		nmi_handler_registered = 0;
 	}
 #endif
 }
 static int __init ipmi_wdog_init(void)
 {
 	int rv;
 	if (action_op(action, NULL)) {
 		action_op("reset", NULL);
 		printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
 		       " reset\n", action);
 	}
 	if (preaction_op(preaction, NULL)) {
 		preaction_op("pre_none", NULL);
 		printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
 		       " none\n", preaction);
 	}
 	if (preop_op(preop, NULL)) {
 		preop_op("preop_none", NULL);
 		printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
 		       " none\n", preop);
 	}
 	check_parms();
 	register_reboot_notifier(&wdog_reboot_notifier);
 	atomic_notifier_chain_register(&panic_notifier_list,
 			&wdog_panic_notifier);
 	rv = ipmi_smi_watcher_register(&smi_watcher);
 	if (rv) {
-#ifdef HAVE_DIE_NMI_POST
+#ifdef HAVE_NMI_HANDLER
-		if (nmi_handler_registered)
+		if (preaction_val == WDOG_PRETIMEOUT_NMI)
-			unregister_die_notifier(&ipmi_nmi_handler);
+			release_nmi(&ipmi_nmi_handler);
 #endif
 		atomic_notifier_chain_unregister(&panic_notifier_list,
 						 &wdog_panic_notifier);
 		unregister_reboot_notifier(&wdog_reboot_notifier);
 		printk(KERN_WARNING PFX "can't register smi watcher\n");
 		return rv;
 	}
 	printk(KERN_INFO PFX "driver initialized\n");

include/asm-i386/kdebug.h

Diff comments View file @ faa8b6c

 #ifndef _I386_KDEBUG_H
 #define _I386_KDEBUG_H 1
 /*
  * Aug-05 2004 Ported by Prasanna S Panchamukhi <prasanna@in.ibm.com>
  * from x86_64 architecture.
  */
 #include <linux/notifier.h>
 struct pt_regs;
 extern int register_page_fault_notifier(struct notifier_block *);
 extern int unregister_page_fault_notifier(struct notifier_block *);
 /* Grossly misnamed. */
 enum die_val {
 	DIE_OOPS = 1,
 	DIE_INT3,
 	DIE_DEBUG,
 	DIE_PANIC,
 	DIE_NMI,
 	DIE_DIE,
 	DIE_NMIWATCHDOG,
 	DIE_KERNELDEBUG,
 	DIE_TRAP,
 	DIE_GPF,
 	DIE_CALL,
 	DIE_NMI_IPI,
-	DIE_NMI_POST,
 	DIE_PAGE_FAULT,
 };
 #endif

include/asm-x86_64/kdebug.h

Diff comments View file @ faa8b6c

 #ifndef _X86_64_KDEBUG_H
 #define _X86_64_KDEBUG_H 1
 #include <linux/notifier.h>
 struct pt_regs;
 extern int register_page_fault_notifier(struct notifier_block *);
 extern int unregister_page_fault_notifier(struct notifier_block *);
 /* Grossly misnamed. */
 enum die_val {
 	DIE_OOPS = 1,
 	DIE_INT3,
 	DIE_DEBUG,
 	DIE_PANIC,
 	DIE_NMI,
 	DIE_DIE,
 	DIE_NMIWATCHDOG,
 	DIE_KERNELDEBUG,
 	DIE_TRAP,
 	DIE_GPF,
 	DIE_CALL,
 	DIE_NMI_IPI,
-	DIE_NMI_POST,
 	DIE_PAGE_FAULT,
 };
 extern void printk_address(unsigned long address);
 extern void die(const char *,struct pt_regs *,long);
 extern void __die(const char *,struct pt_regs *,long);
 extern void show_registers(struct pt_regs *regs);
 extern void dump_pagetable(unsigned long);
 extern unsigned long oops_begin(void);
 extern void oops_end(unsigned long);
 #endif