2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* 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>
|
2006-10-05 10:07:26 -07:00
|
|
|
#include <linux/kallsyms.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
2005-04-16 15:24:54 -07:00
|
|
|
#include <linux/nmi.h>
|
2005-09-06 15:19:28 -07:00
|
|
|
#include <linux/kprobes.h>
|
2006-04-18 03:35:13 -07:00
|
|
|
#include <linux/kexec.h>
|
2006-06-26 04:57:32 -07:00
|
|
|
#include <linux/unwind.h>
|
2006-12-06 18:14:06 -07:00
|
|
|
#include <linux/uaccess.h>
|
2006-12-08 03:36:22 -07:00
|
|
|
#include <linux/bug.h>
|
2007-05-08 00:27:03 -07:00
|
|
|
#include <linux/kdebug.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-07-19 01:49:46 -07:00
|
|
|
#if defined(CONFIG_EDAC)
|
|
|
|
#include <linux/edac.h>
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
#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>
|
2006-06-26 04:57:32 -07:00
|
|
|
#include <asm/unwind.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
#include <asm/pda.h>
|
|
|
|
#include <asm/proto.h>
|
|
|
|
#include <asm/nmi.h>
|
2006-09-26 01:52:34 -07:00
|
|
|
#include <asm/stacktrace.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
[PATCH] arch/x86_64/kernel/traps.c PTRACE_SINGLESTEP oops
We found a problem with x86_64 kernels with preemption enabled, where
having multiple tasks doing ptrace singlesteps around the same time will
cause the system to 'oops'. The problem seems that a task can get
preempted out of the do_debug() processing while it is running on the
DEBUG_STACK stack. If another task on that same cpu then enters do_debug()
and uses the same per-cpu DEBUG_STACK stack, the previous preempted tasks's
stack contents can be corrupted, and the system will oops when the
preempted task is context switched back in again.
The typical oops looks like the following:
Unable to handle kernel paging request at ffffffffffffffae RIP: <ffffffff805452a1>{thread_return+34}
PGD 103027 PUD 102429067 PMD 0
Oops: 0002 [1] PREEMPT SMP
CPU 0
Modules linked in:
Pid: 3786, comm: ssdd Not tainted 2.6.15.2 #1
RIP: 0010:[<ffffffff805452a1>] <ffffffff805452a1>{thread_return+34}
RSP: 0018:ffffffff80824058 EFLAGS: 000136c2
RAX: ffff81017e12cea0 RBX: 0000000000000000 RCX: 00000000c0000100
RDX: 0000000000000000 RSI: ffff8100f7856e20 RDI: ffff81017e12cea0
RBP: 0000000000000046 R08: ffff8100f68a6000 R09: 0000000000000000
R10: 0000000000000000 R11: ffff81017e12cea0 R12: ffff81000c2d53e8
R13: ffff81017f5b3be8 R14: ffff81000c0036e0 R15: 000001056cbfc899
FS: 00002aaaaaad9b00(0000) GS:ffffffff80883800(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffffffffffffffae CR3: 00000000f6fcf000 CR4: 00000000000006e0
Process ssdd (pid: 3786, threadinfo ffff8100f68a6000, task ffff8100f7856e20)
Stack: ffffffff808240d8 ffffffff8012a84a ffff8100055f6c00 0000000000000020
0000000000000001 ffff81000c0036e0 ffffffff808240b8 0000000000000000
0000000000000000 0000000000000000
Call Trace: <#DB>
<ffffffff8012a84a>{try_to_wake_up+985}
<ffffffff8012c0d3>{kick_process+87}
<ffffffff8013b262>{signal_wake_up+48}
<ffffffff8013b5ce>{specific_send_sig_info+179}
<ffffffff80546abc>{_spin_unlock_irqrestore+27}
<ffffffff8013b67c>{force_sig_info+159}
<ffffffff801103a0>{do_debug+289} <ffffffff80110278>{sync_regs+103}
<ffffffff8010ed9a>{paranoid_userspace+35}
Unable to handle kernel paging request at 00007fffffb7d000 RIP: <ffffffff8010f2e4>{show_trace+465}
PGD f6f25067 PUD f6fcc067 PMD f6957067 PTE 0
Oops: 0000 [2] PREEMPT SMP
This patch disables preemptions for the task upon entry to do_debug(), before
interrupts are reenabled, and then disables preemption before exiting
do_debug(), after disabling interrupts. I've noticed that the task can be
preempted either at the end of an interrupt, or on the call to
force_sig_info() on the spin_unlock_irqrestore() processing. It might be
better to attempt to code a fix in entry.S around the code that calls
do_debug().
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-12 15:34:58 -07:00
|
|
|
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();
|
2006-05-15 09:19:47 -07:00
|
|
|
/* Make sure to not schedule here because we could be running
|
|
|
|
on an exception stack. */
|
[PATCH] arch/x86_64/kernel/traps.c PTRACE_SINGLESTEP oops
We found a problem with x86_64 kernels with preemption enabled, where
having multiple tasks doing ptrace singlesteps around the same time will
cause the system to 'oops'. The problem seems that a task can get
preempted out of the do_debug() processing while it is running on the
DEBUG_STACK stack. If another task on that same cpu then enters do_debug()
and uses the same per-cpu DEBUG_STACK stack, the previous preempted tasks's
stack contents can be corrupted, and the system will oops when the
preempted task is context switched back in again.
The typical oops looks like the following:
Unable to handle kernel paging request at ffffffffffffffae RIP: <ffffffff805452a1>{thread_return+34}
PGD 103027 PUD 102429067 PMD 0
Oops: 0002 [1] PREEMPT SMP
CPU 0
Modules linked in:
Pid: 3786, comm: ssdd Not tainted 2.6.15.2 #1
RIP: 0010:[<ffffffff805452a1>] <ffffffff805452a1>{thread_return+34}
RSP: 0018:ffffffff80824058 EFLAGS: 000136c2
RAX: ffff81017e12cea0 RBX: 0000000000000000 RCX: 00000000c0000100
RDX: 0000000000000000 RSI: ffff8100f7856e20 RDI: ffff81017e12cea0
RBP: 0000000000000046 R08: ffff8100f68a6000 R09: 0000000000000000
R10: 0000000000000000 R11: ffff81017e12cea0 R12: ffff81000c2d53e8
R13: ffff81017f5b3be8 R14: ffff81000c0036e0 R15: 000001056cbfc899
FS: 00002aaaaaad9b00(0000) GS:ffffffff80883800(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffffffffffffffae CR3: 00000000f6fcf000 CR4: 00000000000006e0
Process ssdd (pid: 3786, threadinfo ffff8100f68a6000, task ffff8100f7856e20)
Stack: ffffffff808240d8 ffffffff8012a84a ffff8100055f6c00 0000000000000020
0000000000000001 ffff81000c0036e0 ffffffff808240b8 0000000000000000
0000000000000000 0000000000000000
Call Trace: <#DB>
<ffffffff8012a84a>{try_to_wake_up+985}
<ffffffff8012c0d3>{kick_process+87}
<ffffffff8013b262>{signal_wake_up+48}
<ffffffff8013b5ce>{specific_send_sig_info+179}
<ffffffff80546abc>{_spin_unlock_irqrestore+27}
<ffffffff8013b67c>{force_sig_info+159}
<ffffffff801103a0>{do_debug+289} <ffffffff80110278>{sync_regs+103}
<ffffffff8010ed9a>{paranoid_userspace+35}
Unable to handle kernel paging request at 00007fffffb7d000 RIP: <ffffffff8010f2e4>{show_trace+465}
PGD f6f25067 PUD f6fcc067 PMD f6957067 PTE 0
Oops: 0000 [2] PREEMPT SMP
This patch disables preemptions for the task upon entry to do_debug(), before
interrupts are reenabled, and then disables preemption before exiting
do_debug(), after disabling interrupts. I've noticed that the task can be
preempted either at the end of an interrupt, or on the call to
force_sig_info() on the spin_unlock_irqrestore() processing. It might be
better to attempt to code a fix in entry.S around the code that calls
do_debug().
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-12 15:34:58 -07:00
|
|
|
preempt_enable_no_resched();
|
|
|
|
}
|
|
|
|
|
2006-12-06 18:14:11 -07:00
|
|
|
int kstack_depth_to_print = 12;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_KALLSYMS
|
2006-07-03 00:24:36 -07:00
|
|
|
void printk_address(unsigned long address)
|
|
|
|
{
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned long offset = 0, symsize;
|
|
|
|
const char *symname;
|
|
|
|
char *modname;
|
2006-07-03 00:24:36 -07:00
|
|
|
char *delim = ":";
|
2005-04-16 15:20:36 -07:00
|
|
|
char namebuf[128];
|
|
|
|
|
2006-07-03 00:24:36 -07:00
|
|
|
symname = kallsyms_lookup(address, &symsize, &offset,
|
|
|
|
&modname, namebuf);
|
|
|
|
if (!symname) {
|
|
|
|
printk(" [<%016lx>]\n", address);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!modname)
|
2005-04-16 15:20:36 -07:00
|
|
|
modname = delim = "";
|
2006-07-03 00:24:36 -07:00
|
|
|
printk(" [<%016lx>] %s%s%s%s+0x%lx/0x%lx\n",
|
|
|
|
address, delim, modname, delim, symname, offset, symsize);
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
#else
|
2006-07-03 00:24:36 -07:00
|
|
|
void printk_address(unsigned long address)
|
|
|
|
{
|
|
|
|
printk(" [<%016lx>]\n", address);
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 15:25:17 -07:00
|
|
|
static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
|
2006-09-26 01:52:34 -07:00
|
|
|
unsigned *usedp, char **idp)
|
2005-04-16 15:25:17 -07:00
|
|
|
{
|
2006-01-11 14:43:00 -07:00
|
|
|
static char ids[][8] = {
|
2005-04-16 15:25:17 -07:00
|
|
|
[DEBUG_STACK - 1] = "#DB",
|
|
|
|
[NMI_STACK - 1] = "NMI",
|
|
|
|
[DOUBLEFAULT_STACK - 1] = "#DF",
|
|
|
|
[STACKFAULT_STACK - 1] = "#SS",
|
|
|
|
[MCE_STACK - 1] = "#MC",
|
2006-01-11 14:43:00 -07:00
|
|
|
#if DEBUG_STKSZ > EXCEPTION_STKSZ
|
|
|
|
[N_EXCEPTION_STACKS ... N_EXCEPTION_STACKS + DEBUG_STKSZ / EXCEPTION_STKSZ - 2] = "#DB[?]"
|
|
|
|
#endif
|
2005-04-16 15:25:17 -07:00
|
|
|
};
|
|
|
|
unsigned k;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* Iterate over all exception stacks, and figure out whether
|
|
|
|
* 'stack' is in one of them:
|
|
|
|
*/
|
2005-04-16 15:25:17 -07:00
|
|
|
for (k = 0; k < N_EXCEPTION_STACKS; k++) {
|
2006-09-26 01:52:38 -07:00
|
|
|
unsigned long end = per_cpu(orig_ist, cpu).ist[k];
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* Is 'stack' above this exception frame's end?
|
|
|
|
* If yes then skip to the next frame.
|
|
|
|
*/
|
2005-04-16 15:25:17 -07:00
|
|
|
if (stack >= end)
|
|
|
|
continue;
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* Is 'stack' above this exception frame's start address?
|
|
|
|
* If yes then we found the right frame.
|
|
|
|
*/
|
2005-04-16 15:25:17 -07:00
|
|
|
if (stack >= end - EXCEPTION_STKSZ) {
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* 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:
|
|
|
|
*/
|
2005-04-16 15:25:17 -07:00
|
|
|
if (*usedp & (1U << k))
|
|
|
|
break;
|
|
|
|
*usedp |= 1U << k;
|
|
|
|
*idp = ids[k];
|
|
|
|
return (unsigned long *)end;
|
|
|
|
}
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* 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:
|
|
|
|
*/
|
2006-01-11 14:43:00 -07:00
|
|
|
#if DEBUG_STKSZ > EXCEPTION_STKSZ
|
|
|
|
if (k == DEBUG_STACK - 1 && stack >= end - DEBUG_STKSZ) {
|
|
|
|
unsigned j = N_EXCEPTION_STACKS - 1;
|
|
|
|
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* Black magic. A large debug stack is composed of
|
|
|
|
* multiple exception stack entries, which we
|
|
|
|
* iterate through now. Dont look:
|
|
|
|
*/
|
2006-01-11 14:43:00 -07:00
|
|
|
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
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
return NULL;
|
2005-04-16 15:25:17 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-12-06 18:14:00 -07:00
|
|
|
#define MSG(txt) ops->warning(data, txt)
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
2007-10-19 16:25:36 -07:00
|
|
|
* x86-64 can have up to three kernel stacks:
|
2005-04-16 15:20:36 -07:00
|
|
|
* process stack
|
|
|
|
* interrupt stack
|
2005-04-16 15:25:17 -07:00
|
|
|
* severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
|
2005-04-16 15:20:36 -07:00
|
|
|
*/
|
|
|
|
|
2006-11-28 12:12:59 -07:00
|
|
|
static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)
|
|
|
|
{
|
|
|
|
void *t = (void *)tinfo;
|
|
|
|
return p > t && p < t + THREAD_SIZE - 3;
|
|
|
|
}
|
|
|
|
|
2006-12-06 18:14:00 -07:00
|
|
|
void dump_trace(struct task_struct *tsk, struct pt_regs *regs,
|
|
|
|
unsigned long *stack,
|
2007-10-17 09:04:37 -07:00
|
|
|
const struct stacktrace_ops *ops, void *data)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-12-06 18:14:02 -07:00
|
|
|
const unsigned cpu = get_cpu();
|
2006-12-06 18:14:00 -07:00
|
|
|
unsigned long *irqstack_end = (unsigned long*)cpu_pda(cpu)->irqstackptr;
|
2005-04-16 15:25:17 -07:00
|
|
|
unsigned used = 0;
|
2006-11-28 12:12:59 -07:00
|
|
|
struct thread_info *tinfo;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-06-26 04:57:32 -07:00
|
|
|
if (!tsk)
|
|
|
|
tsk = current;
|
|
|
|
|
2006-09-26 01:52:34 -07:00
|
|
|
if (!stack) {
|
|
|
|
unsigned long dummy;
|
|
|
|
stack = &dummy;
|
|
|
|
if (tsk && tsk != current)
|
|
|
|
stack = (unsigned long *)tsk->thread.rsp;
|
2006-06-26 04:57:32 -07:00
|
|
|
}
|
|
|
|
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* Print function call entries within a stack. 'cond' is the
|
|
|
|
* "end of stackframe" condition, that the 'stack++'
|
|
|
|
* iteration will eventually trigger.
|
|
|
|
*/
|
2005-04-16 15:25:17 -07:00
|
|
|
#define HANDLE_STACK(cond) \
|
|
|
|
do while (cond) { \
|
2006-01-11 14:46:45 -07:00
|
|
|
unsigned long addr = *stack++; \
|
2006-12-06 18:14:12 -07:00
|
|
|
/* Use unlocked access here because except for NMIs \
|
|
|
|
we should be already protected against module unloads */ \
|
|
|
|
if (__kernel_text_address(addr)) { \
|
2005-04-16 15:25:17 -07:00
|
|
|
/* \
|
|
|
|
* 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. \
|
|
|
|
*/ \
|
2006-09-26 01:52:34 -07:00
|
|
|
ops->address(data, addr); \
|
2005-04-16 15:25:17 -07:00
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* Print function call entries in all stacks, starting at the
|
|
|
|
* current stack address. If the stacks consist of nested
|
|
|
|
* exceptions
|
|
|
|
*/
|
2006-09-26 01:52:34 -07:00
|
|
|
for (;;) {
|
|
|
|
char *id;
|
2005-04-16 15:25:17 -07:00
|
|
|
unsigned long *estack_end;
|
|
|
|
estack_end = in_exception_stack(cpu, (unsigned long)stack,
|
|
|
|
&used, &id);
|
|
|
|
|
|
|
|
if (estack_end) {
|
2006-09-26 01:52:34 -07:00
|
|
|
if (ops->stack(data, id) < 0)
|
|
|
|
break;
|
2005-04-16 15:25:17 -07:00
|
|
|
HANDLE_STACK (stack < estack_end);
|
2006-09-26 01:52:34 -07:00
|
|
|
ops->stack(data, "<EOE>");
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* We link to the next stack via the
|
|
|
|
* second-to-last pointer (index -2 to end) in the
|
|
|
|
* exception stack:
|
|
|
|
*/
|
2005-04-16 15:25:17 -07:00
|
|
|
stack = (unsigned long *) estack_end[-2];
|
|
|
|
continue;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2005-04-16 15:25:17 -07:00
|
|
|
if (irqstack_end) {
|
|
|
|
unsigned long *irqstack;
|
|
|
|
irqstack = irqstack_end -
|
|
|
|
(IRQSTACKSIZE - 64) / sizeof(*irqstack);
|
|
|
|
|
|
|
|
if (stack >= irqstack && stack < irqstack_end) {
|
2006-09-26 01:52:34 -07:00
|
|
|
if (ops->stack(data, "IRQ") < 0)
|
|
|
|
break;
|
2005-04-16 15:25:17 -07:00
|
|
|
HANDLE_STACK (stack < irqstack_end);
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
|
|
|
* We link to the next stack (which would be
|
|
|
|
* the process stack normally) the last
|
|
|
|
* pointer (index -1 to end) in the IRQ stack:
|
|
|
|
*/
|
2005-04-16 15:25:17 -07:00
|
|
|
stack = (unsigned long *) (irqstack_end[-1]);
|
|
|
|
irqstack_end = NULL;
|
2006-09-26 01:52:34 -07:00
|
|
|
ops->stack(data, "EOI");
|
2005-04-16 15:25:17 -07:00
|
|
|
continue;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 15:25:17 -07:00
|
|
|
break;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2005-04-16 15:25:17 -07:00
|
|
|
|
2006-07-03 00:24:36 -07:00
|
|
|
/*
|
2006-09-26 01:52:34 -07:00
|
|
|
* This handles the process stack:
|
2006-07-03 00:24:36 -07:00
|
|
|
*/
|
2007-01-03 09:21:28 -07:00
|
|
|
tinfo = task_thread_info(tsk);
|
2006-11-28 12:12:59 -07:00
|
|
|
HANDLE_STACK (valid_stack_ptr(tinfo, stack));
|
2005-04-16 15:25:17 -07:00
|
|
|
#undef HANDLE_STACK
|
2006-12-06 18:14:02 -07:00
|
|
|
put_cpu();
|
2006-09-26 01:52:34 -07:00
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
2006-07-03 00:24:36 -07:00
|
|
|
|
2006-09-26 01:52:34 -07:00
|
|
|
static void print_trace_address(void *data, unsigned long addr)
|
|
|
|
{
|
2007-07-17 04:03:56 -07:00
|
|
|
touch_nmi_watchdog();
|
2006-09-26 01:52:34 -07:00
|
|
|
printk_address(addr);
|
|
|
|
}
|
|
|
|
|
2007-10-17 09:04:37 -07:00
|
|
|
static const struct stacktrace_ops print_trace_ops = {
|
2006-09-26 01:52:34 -07:00
|
|
|
.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);
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
|
2006-09-26 01:52:34 -07:00
|
|
|
static void
|
|
|
|
_show_stack(struct task_struct *tsk, struct pt_regs *regs, unsigned long *rsp)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
unsigned long *stack;
|
|
|
|
int i;
|
2006-09-26 01:52:37 -07:00
|
|
|
const int cpu = smp_processor_id();
|
2006-01-11 14:45:39 -07:00
|
|
|
unsigned long *irqstack_end = (unsigned long *) (cpu_pda(cpu)->irqstackptr);
|
|
|
|
unsigned long *irqstack = (unsigned long *) (cpu_pda(cpu)->irqstackptr - IRQSTACKSIZE);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
// 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))
|
2006-07-03 00:24:36 -07:00
|
|
|
printk("\n");
|
|
|
|
printk(" %016lx", *stack++);
|
2005-04-16 15:24:54 -07:00
|
|
|
touch_nmi_watchdog();
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2006-06-26 04:57:32 -07:00
|
|
|
show_trace(tsk, regs, rsp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void show_stack(struct task_struct *tsk, unsigned long * rsp)
|
|
|
|
{
|
|
|
|
_show_stack(tsk, NULL, rsp);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The architecture-independent dump_stack generator
|
|
|
|
*/
|
|
|
|
void dump_stack(void)
|
|
|
|
{
|
|
|
|
unsigned long dummy;
|
2006-06-26 04:57:32 -07:00
|
|
|
show_trace(NULL, NULL, &dummy);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(dump_stack);
|
|
|
|
|
|
|
|
void show_registers(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
int i;
|
2005-06-23 00:08:46 -07:00
|
|
|
int in_kernel = !user_mode(regs);
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned long rsp;
|
2006-09-26 01:52:37 -07:00
|
|
|
const int cpu = smp_processor_id();
|
2006-01-11 14:45:39 -07:00
|
|
|
struct task_struct *cur = cpu_pda(cpu)->pcurrent;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-05-02 10:27:08 -07:00
|
|
|
rsp = regs->rsp;
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("CPU %d ", cpu);
|
|
|
|
__show_regs(regs);
|
|
|
|
printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
|
2006-01-12 02:05:38 -07:00
|
|
|
cur->comm, cur->pid, task_thread_info(cur), cur);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* When in-kernel, we also print out the stack and code at the
|
|
|
|
* time of the fault..
|
|
|
|
*/
|
|
|
|
if (in_kernel) {
|
|
|
|
printk("Stack: ");
|
2006-06-26 04:57:32 -07:00
|
|
|
_show_stack(NULL, regs, (unsigned long*)rsp);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
printk("\nCode: ");
|
2006-03-25 08:29:55 -07:00
|
|
|
if (regs->rip < PAGE_OFFSET)
|
2005-04-16 15:20:36 -07:00
|
|
|
goto bad;
|
|
|
|
|
2006-03-25 08:29:55 -07:00
|
|
|
for (i=0; i<20; i++) {
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned char c;
|
2006-03-25 08:29:55 -07:00
|
|
|
if (__get_user(c, &((unsigned char*)regs->rip)[i])) {
|
2005-04-16 15:20:36 -07:00
|
|
|
bad:
|
|
|
|
printk(" Bad RIP value.");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
printk("%02x ", c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
|
2006-12-08 03:36:22 -07:00
|
|
|
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;
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-05-25 12:31:28 -07:00
|
|
|
#ifdef CONFIG_BUG
|
2005-04-16 15:20:36 -07:00
|
|
|
void out_of_line_bug(void)
|
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
}
|
2006-06-26 04:59:44 -07:00
|
|
|
EXPORT_SYMBOL(out_of_line_bug);
|
2005-05-25 12:31:28 -07:00
|
|
|
#endif
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-10-19 11:35:03 -07:00
|
|
|
static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED;
|
2005-04-16 15:20:36 -07:00
|
|
|
static int die_owner = -1;
|
2006-05-08 06:17:22 -07:00
|
|
|
static unsigned int die_nest_count;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-02-03 13:50:41 -07:00
|
|
|
unsigned __kprobes long oops_begin(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2007-06-08 13:47:01 -07:00
|
|
|
int cpu;
|
2005-09-12 09:49:24 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-09-26 01:52:36 -07:00
|
|
|
oops_enter();
|
|
|
|
|
2005-09-12 09:49:24 -07:00
|
|
|
/* racy, but better than risking deadlock. */
|
2007-10-19 11:35:03 -07:00
|
|
|
raw_local_irq_save(flags);
|
2007-06-08 13:47:01 -07:00
|
|
|
cpu = smp_processor_id();
|
2007-10-19 11:35:03 -07:00
|
|
|
if (!__raw_spin_trylock(&die_lock)) {
|
2005-04-16 15:20:36 -07:00
|
|
|
if (cpu == die_owner)
|
|
|
|
/* nested oops. should stop eventually */;
|
|
|
|
else
|
2007-10-19 11:35:03 -07:00
|
|
|
__raw_spin_lock(&die_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2006-05-08 06:17:22 -07:00
|
|
|
die_nest_count++;
|
2005-09-12 09:49:24 -07:00
|
|
|
die_owner = cpu;
|
2005-04-16 15:20:36 -07:00
|
|
|
console_verbose();
|
2005-09-12 09:49:24 -07:00
|
|
|
bust_spinlocks(1);
|
|
|
|
return flags;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2006-02-03 13:50:41 -07:00
|
|
|
void __kprobes oops_end(unsigned long flags)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
die_owner = -1;
|
2005-09-12 09:49:24 -07:00
|
|
|
bust_spinlocks(0);
|
2006-05-08 06:17:22 -07:00
|
|
|
die_nest_count--;
|
2007-10-19 11:35:03 -07:00
|
|
|
if (!die_nest_count)
|
2006-05-08 06:17:22 -07:00
|
|
|
/* Nest count reaches zero, release the lock. */
|
2007-10-19 11:35:03 -07:00
|
|
|
__raw_spin_unlock(&die_lock);
|
|
|
|
raw_local_irq_restore(flags);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (panic_on_oops)
|
2006-08-13 23:24:22 -07:00
|
|
|
panic("Fatal exception");
|
2006-09-26 01:52:36 -07:00
|
|
|
oops_exit();
|
2005-09-12 09:49:24 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-02-03 13:50:41 -07:00
|
|
|
void __kprobes __die(const char * str, struct pt_regs * regs, long err)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
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");
|
2006-01-11 14:42:14 -07:00
|
|
|
notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
|
2005-04-16 15:20:36 -07:00
|
|
|
show_registers(regs);
|
2007-07-17 04:03:42 -07:00
|
|
|
add_taint(TAINT_DIE);
|
2005-04-16 15:20:36 -07:00
|
|
|
/* Executive summary in case the oops scrolled away */
|
|
|
|
printk(KERN_ALERT "RIP ");
|
|
|
|
printk_address(regs->rip);
|
|
|
|
printk(" RSP <%016lx>\n", regs->rsp);
|
2006-04-18 03:35:13 -07:00
|
|
|
if (kexec_should_crash(current))
|
|
|
|
crash_kexec(regs);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void die(const char * str, struct pt_regs * regs, long err)
|
|
|
|
{
|
2005-09-12 09:49:24 -07:00
|
|
|
unsigned long flags = oops_begin();
|
|
|
|
|
2006-12-08 03:36:22 -07:00
|
|
|
if (!user_mode(regs))
|
2007-07-15 23:41:39 -07:00
|
|
|
report_bug(regs->rip, regs);
|
2006-12-08 03:36:22 -07:00
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
__die(str, regs, err);
|
2005-09-12 09:49:24 -07:00
|
|
|
oops_end(flags);
|
2005-04-16 15:20:36 -07:00
|
|
|
do_exit(SIGSEGV);
|
|
|
|
}
|
|
|
|
|
2006-09-26 01:52:27 -07:00
|
|
|
void __kprobes die_nmi(char *str, struct pt_regs *regs, int do_panic)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2005-09-12 09:49:24 -07:00
|
|
|
unsigned long flags = oops_begin();
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* We are in trouble anyway, lets at least try
|
|
|
|
* to get a message out.
|
|
|
|
*/
|
2006-09-26 01:52:37 -07:00
|
|
|
printk(str, smp_processor_id());
|
2005-04-16 15:20:36 -07:00
|
|
|
show_registers(regs);
|
2006-04-18 03:35:13 -07:00
|
|
|
if (kexec_should_crash(current))
|
|
|
|
crash_kexec(regs);
|
2006-09-26 01:52:27 -07:00
|
|
|
if (do_panic || panic_on_oops)
|
|
|
|
panic("Non maskable interrupt");
|
2005-09-12 09:49:24 -07:00
|
|
|
oops_end(flags);
|
2006-05-08 06:17:25 -07:00
|
|
|
nmi_exit();
|
|
|
|
local_irq_enable();
|
2005-04-16 15:20:36 -07:00
|
|
|
do_exit(SIGSEGV);
|
|
|
|
}
|
|
|
|
|
2005-09-06 15:19:28 -07:00
|
|
|
static void __kprobes do_trap(int trapnr, int signr, char *str,
|
|
|
|
struct pt_regs * regs, long error_code,
|
|
|
|
siginfo_t *info)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-01-11 14:42:14 -07:00
|
|
|
struct task_struct *tsk = current;
|
|
|
|
|
|
|
|
if (user_mode(regs)) {
|
2007-05-02 10:27:05 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2007-07-22 02:12:28 -07:00
|
|
|
if (show_unhandled_signals && unhandled_signal(tsk, signr) &&
|
|
|
|
printk_ratelimit())
|
2005-04-16 15:20:36 -07:00
|
|
|
printk(KERN_INFO
|
|
|
|
"%s[%d] trap %s rip:%lx rsp:%lx error:%lx\n",
|
|
|
|
tsk->comm, tsk->pid, str,
|
2006-03-25 08:29:55 -07:00
|
|
|
regs->rip, regs->rsp, error_code);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
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);
|
2006-03-25 08:29:55 -07:00
|
|
|
if (fixup)
|
2005-04-16 15:20:36 -07:00
|
|
|
regs->rip = fixup->fixup;
|
2007-05-02 10:27:05 -07:00
|
|
|
else {
|
|
|
|
tsk->thread.error_code = error_code;
|
|
|
|
tsk->thread.trap_no = trapnr;
|
2005-04-16 15:20:36 -07:00
|
|
|
die(str, regs, error_code);
|
2007-05-02 10:27:05 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
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; \
|
2006-05-15 09:19:47 -07:00
|
|
|
conditional_sti(regs); \
|
2005-04-16 15:20:36 -07:00
|
|
|
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; \
|
2006-05-15 09:19:47 -07:00
|
|
|
conditional_sti(regs); \
|
2005-04-16 15:20:36 -07:00
|
|
|
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)
|
2006-01-11 14:46:00 -07:00
|
|
|
DO_ERROR_INFO( 6, SIGILL, "invalid opcode", invalid_op, ILL_ILLOPN, regs->rip)
|
2005-04-16 15:20:36 -07:00
|
|
|
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)
|
2006-05-15 09:19:47 -07:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
}
|
2006-01-11 14:42:17 -07:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-09-06 15:19:28 -07:00
|
|
|
asmlinkage void __kprobes do_general_protection(struct pt_regs * regs,
|
|
|
|
long error_code)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-01-11 14:42:14 -07:00
|
|
|
struct task_struct *tsk = current;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
conditional_sti(regs);
|
|
|
|
|
2006-01-11 14:42:14 -07:00
|
|
|
if (user_mode(regs)) {
|
2007-05-02 10:27:05 -07:00
|
|
|
tsk->thread.error_code = error_code;
|
|
|
|
tsk->thread.trap_no = 13;
|
|
|
|
|
2007-07-22 02:12:28 -07:00
|
|
|
if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
|
|
|
|
printk_ratelimit())
|
2005-04-16 15:20:36 -07:00
|
|
|
printk(KERN_INFO
|
|
|
|
"%s[%d] general protection rip:%lx rsp:%lx error:%lx\n",
|
|
|
|
tsk->comm, tsk->pid,
|
2006-03-25 08:29:55 -07:00
|
|
|
regs->rip, regs->rsp, error_code);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2007-05-02 10:27:05 -07:00
|
|
|
|
|
|
|
tsk->thread.error_code = error_code;
|
|
|
|
tsk->thread.trap_no = 13;
|
2005-04-16 15:20:36 -07:00
|
|
|
if (notify_die(DIE_GPF, "general protection fault", regs,
|
|
|
|
error_code, 13, SIGSEGV) == NOTIFY_STOP)
|
|
|
|
return;
|
|
|
|
die("general protection fault", regs, error_code);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-03 13:50:41 -07:00
|
|
|
static __kprobes void
|
|
|
|
mem_parity_error(unsigned char reason, struct pt_regs * regs)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-09-26 01:52:27 -07:00
|
|
|
printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
|
|
|
|
reason);
|
2006-12-06 18:14:03 -07:00
|
|
|
printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
|
2006-09-26 01:52:27 -07:00
|
|
|
|
2007-07-19 01:49:46 -07:00
|
|
|
#if defined(CONFIG_EDAC)
|
|
|
|
if(edac_handler_set()) {
|
|
|
|
edac_atomic_assert_error();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-09-26 01:52:27 -07:00
|
|
|
if (panic_on_unrecovered_nmi)
|
2006-09-26 01:52:27 -07:00
|
|
|
panic("NMI: Not continuing");
|
|
|
|
|
|
|
|
printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Clear and disable the memory parity error line. */
|
|
|
|
reason = (reason & 0xf) | 4;
|
|
|
|
outb(reason, 0x61);
|
|
|
|
}
|
|
|
|
|
2006-02-03 13:50:41 -07:00
|
|
|
static __kprobes void
|
|
|
|
io_check_error(unsigned char reason, struct pt_regs * regs)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-02-03 13:50:41 -07:00
|
|
|
static __kprobes void
|
|
|
|
unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
|
2006-09-26 01:52:27 -07:00
|
|
|
{
|
|
|
|
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");
|
2006-09-26 01:52:27 -07:00
|
|
|
|
|
|
|
if (panic_on_unrecovered_nmi)
|
2006-09-26 01:52:27 -07:00
|
|
|
panic("NMI: Not continuing");
|
2006-09-26 01:52:27 -07:00
|
|
|
|
2006-09-26 01:52:27 -07:00
|
|
|
printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 15:25:03 -07:00
|
|
|
/* Runs on IST stack. This code must keep interrupts off all the time.
|
|
|
|
Nested NMIs are prevented by the CPU. */
|
2006-02-03 13:50:41 -07:00
|
|
|
asmlinkage __kprobes void default_do_nmi(struct pt_regs *regs)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
unsigned char reason = 0;
|
2005-06-25 14:55:00 -07:00
|
|
|
int cpu;
|
|
|
|
|
|
|
|
cpu = smp_processor_id();
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Only the BSP gets external NMIs from the system. */
|
2005-06-25 14:55:00 -07:00
|
|
|
if (!cpu)
|
2005-04-16 15:20:36 -07:00
|
|
|
reason = get_nmi_reason();
|
|
|
|
|
|
|
|
if (!(reason & 0xc0)) {
|
2006-01-11 14:42:14 -07:00
|
|
|
if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT)
|
2005-04-16 15:20:36 -07:00
|
|
|
== NOTIFY_STOP)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Ok, so this is none of the documented NMI sources,
|
|
|
|
* so it must be the NMI watchdog.
|
|
|
|
*/
|
2006-09-26 01:52:26 -07:00
|
|
|
if (nmi_watchdog_tick(regs,reason))
|
2005-04-16 15:20:36 -07:00
|
|
|
return;
|
2006-09-26 01:52:26 -07:00
|
|
|
if (!do_nmi_callback(regs,cpu))
|
|
|
|
unknown_nmi_error(reason, regs);
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
return;
|
|
|
|
}
|
2006-01-11 14:42:14 -07:00
|
|
|
if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
|
2005-04-16 15:20:36 -07:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-01-11 14:43:00 -07:00
|
|
|
/* runs on IST stack. */
|
2005-09-06 15:19:28 -07:00
|
|
|
asmlinkage void __kprobes do_int3(struct pt_regs * regs, long error_code)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2007-10-25 05:01:10 -07:00
|
|
|
trace_hardirqs_fixup();
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) == NOTIFY_STOP) {
|
|
|
|
return;
|
|
|
|
}
|
2006-05-15 09:19:47 -07:00
|
|
|
preempt_conditional_sti(regs);
|
2005-04-16 15:20:36 -07:00
|
|
|
do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
|
2006-05-15 09:19:47 -07:00
|
|
|
preempt_conditional_cli(regs);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 15:25:03 -07:00
|
|
|
/* 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 */
|
2006-02-03 13:50:41 -07:00
|
|
|
asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
|
2005-04-16 15:25:03 -07:00
|
|
|
{
|
|
|
|
struct pt_regs *regs = eregs;
|
|
|
|
/* Did already sync */
|
|
|
|
if (eregs == (struct pt_regs *)eregs->rsp)
|
|
|
|
;
|
|
|
|
/* Exception from user space */
|
2005-06-23 00:08:46 -07:00
|
|
|
else if (user_mode(eregs))
|
2006-01-12 02:05:38 -07:00
|
|
|
regs = task_pt_regs(current);
|
2005-04-16 15:25:03 -07:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/* runs on IST stack. */
|
2005-09-06 15:19:28 -07:00
|
|
|
asmlinkage void __kprobes do_debug(struct pt_regs * regs,
|
|
|
|
unsigned long error_code)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
unsigned long condition;
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
siginfo_t info;
|
|
|
|
|
2005-06-23 00:08:46 -07:00
|
|
|
get_debugreg(condition, 6);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
|
2005-04-16 15:25:13 -07:00
|
|
|
SIGTRAP) == NOTIFY_STOP)
|
2005-04-16 15:25:03 -07:00
|
|
|
return;
|
2005-04-16 15:25:13 -07:00
|
|
|
|
[PATCH] arch/x86_64/kernel/traps.c PTRACE_SINGLESTEP oops
We found a problem with x86_64 kernels with preemption enabled, where
having multiple tasks doing ptrace singlesteps around the same time will
cause the system to 'oops'. The problem seems that a task can get
preempted out of the do_debug() processing while it is running on the
DEBUG_STACK stack. If another task on that same cpu then enters do_debug()
and uses the same per-cpu DEBUG_STACK stack, the previous preempted tasks's
stack contents can be corrupted, and the system will oops when the
preempted task is context switched back in again.
The typical oops looks like the following:
Unable to handle kernel paging request at ffffffffffffffae RIP: <ffffffff805452a1>{thread_return+34}
PGD 103027 PUD 102429067 PMD 0
Oops: 0002 [1] PREEMPT SMP
CPU 0
Modules linked in:
Pid: 3786, comm: ssdd Not tainted 2.6.15.2 #1
RIP: 0010:[<ffffffff805452a1>] <ffffffff805452a1>{thread_return+34}
RSP: 0018:ffffffff80824058 EFLAGS: 000136c2
RAX: ffff81017e12cea0 RBX: 0000000000000000 RCX: 00000000c0000100
RDX: 0000000000000000 RSI: ffff8100f7856e20 RDI: ffff81017e12cea0
RBP: 0000000000000046 R08: ffff8100f68a6000 R09: 0000000000000000
R10: 0000000000000000 R11: ffff81017e12cea0 R12: ffff81000c2d53e8
R13: ffff81017f5b3be8 R14: ffff81000c0036e0 R15: 000001056cbfc899
FS: 00002aaaaaad9b00(0000) GS:ffffffff80883800(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffffffffffffffae CR3: 00000000f6fcf000 CR4: 00000000000006e0
Process ssdd (pid: 3786, threadinfo ffff8100f68a6000, task ffff8100f7856e20)
Stack: ffffffff808240d8 ffffffff8012a84a ffff8100055f6c00 0000000000000020
0000000000000001 ffff81000c0036e0 ffffffff808240b8 0000000000000000
0000000000000000 0000000000000000
Call Trace: <#DB>
<ffffffff8012a84a>{try_to_wake_up+985}
<ffffffff8012c0d3>{kick_process+87}
<ffffffff8013b262>{signal_wake_up+48}
<ffffffff8013b5ce>{specific_send_sig_info+179}
<ffffffff80546abc>{_spin_unlock_irqrestore+27}
<ffffffff8013b67c>{force_sig_info+159}
<ffffffff801103a0>{do_debug+289} <ffffffff80110278>{sync_regs+103}
<ffffffff8010ed9a>{paranoid_userspace+35}
Unable to handle kernel paging request at 00007fffffb7d000 RIP: <ffffffff8010f2e4>{show_trace+465}
PGD f6f25067 PUD f6fcc067 PMD f6957067 PTE 0
Oops: 0000 [2] PREEMPT SMP
This patch disables preemptions for the task upon entry to do_debug(), before
interrupts are reenabled, and then disables preemption before exiting
do_debug(), after disabling interrupts. I've noticed that the task can be
preempted either at the end of an interrupt, or on the call to
force_sig_info() on the spin_unlock_irqrestore() processing. It might be
better to attempt to code a fix in entry.S around the code that calls
do_debug().
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-12 15:34:58 -07:00
|
|
|
preempt_conditional_sti(regs);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* 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 */
|
2005-04-16 15:25:13 -07:00
|
|
|
if (condition & DR_STEP) {
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-06-23 00:08:46 -07:00
|
|
|
if (!user_mode(regs))
|
2005-04-16 15:20:36 -07:00
|
|
|
goto clear_TF_reenable;
|
2005-04-16 15:24:57 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
[PATCH] x86_64: Report hardware breakpoints in user space when triggered by the kernel
I would like to throw out a suggestion for a possible change in the way that
the debug register traps are handled in do_debug() when the trap occurs
in kernel-mode.
In the x86_64 version of do_debug(), the code will skip around sending
a SIGTRAP to the current task if the trap occurred while in kernel mode.
On the i386-side of things, if the access happens to occur in kernel mode
(say during a read(2) of user's buffer that matches the address of a
debug register trap), then the do_debug() routine for i386 will go ahead
and call send_sigtrap() and send the SIGTRAP signal. The send_sigtrap()
code will also set the info.si_addr to NULL in this case (even though I
don't understand why, since the SIGTRAP siginfo processing doesn't use
the si_addr field...).
So I would like to suggest that the x86_64 do_debug() routine also
follow this type of behavior and have it go ahead and send the
SIGTRAP signal to the current task, even if the debug register trap
happens to have occurred in kernel mode. I have taken a stab at
a patch for this change below. (It includes the i386-ish change
for setting si_addr to NULL when the trap occurred in kernel mode.)
It seems like a useful feature to be able to 'watch' a user location that
might also be modified in the kernel via a system service call, and have the
debugger report that information back to the user, rather than to just
silently ignore the trap.
Additionally, I realize that users that pull in a kernel debugger such as
KGDB into their kernel might want to remove this change below when they add
in KGDB support. However, they could alternatively look at the current
task's thread.debugreg[] values to see if the trap occurred due to KGDB
or instead because of a user-space debugger trap, and still honor the
user SIGTRAP processing (instead of the KGDB breakpoint processing)
if the trap matches up with the thread.debugreg[] registers.
Signed-off-by: Andi Kleen <ak@suse.de>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-11 14:44:15 -07:00
|
|
|
info.si_addr = user_mode(regs) ? (void __user *)regs->rip : NULL;
|
|
|
|
force_sig_info(SIGTRAP, &info, tsk);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
clear_dr7:
|
2005-06-23 00:08:46 -07:00
|
|
|
set_debugreg(0UL, 7);
|
[PATCH] arch/x86_64/kernel/traps.c PTRACE_SINGLESTEP oops
We found a problem with x86_64 kernels with preemption enabled, where
having multiple tasks doing ptrace singlesteps around the same time will
cause the system to 'oops'. The problem seems that a task can get
preempted out of the do_debug() processing while it is running on the
DEBUG_STACK stack. If another task on that same cpu then enters do_debug()
and uses the same per-cpu DEBUG_STACK stack, the previous preempted tasks's
stack contents can be corrupted, and the system will oops when the
preempted task is context switched back in again.
The typical oops looks like the following:
Unable to handle kernel paging request at ffffffffffffffae RIP: <ffffffff805452a1>{thread_return+34}
PGD 103027 PUD 102429067 PMD 0
Oops: 0002 [1] PREEMPT SMP
CPU 0
Modules linked in:
Pid: 3786, comm: ssdd Not tainted 2.6.15.2 #1
RIP: 0010:[<ffffffff805452a1>] <ffffffff805452a1>{thread_return+34}
RSP: 0018:ffffffff80824058 EFLAGS: 000136c2
RAX: ffff81017e12cea0 RBX: 0000000000000000 RCX: 00000000c0000100
RDX: 0000000000000000 RSI: ffff8100f7856e20 RDI: ffff81017e12cea0
RBP: 0000000000000046 R08: ffff8100f68a6000 R09: 0000000000000000
R10: 0000000000000000 R11: ffff81017e12cea0 R12: ffff81000c2d53e8
R13: ffff81017f5b3be8 R14: ffff81000c0036e0 R15: 000001056cbfc899
FS: 00002aaaaaad9b00(0000) GS:ffffffff80883800(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffffffffffffffae CR3: 00000000f6fcf000 CR4: 00000000000006e0
Process ssdd (pid: 3786, threadinfo ffff8100f68a6000, task ffff8100f7856e20)
Stack: ffffffff808240d8 ffffffff8012a84a ffff8100055f6c00 0000000000000020
0000000000000001 ffff81000c0036e0 ffffffff808240b8 0000000000000000
0000000000000000 0000000000000000
Call Trace: <#DB>
<ffffffff8012a84a>{try_to_wake_up+985}
<ffffffff8012c0d3>{kick_process+87}
<ffffffff8013b262>{signal_wake_up+48}
<ffffffff8013b5ce>{specific_send_sig_info+179}
<ffffffff80546abc>{_spin_unlock_irqrestore+27}
<ffffffff8013b67c>{force_sig_info+159}
<ffffffff801103a0>{do_debug+289} <ffffffff80110278>{sync_regs+103}
<ffffffff8010ed9a>{paranoid_userspace+35}
Unable to handle kernel paging request at 00007fffffb7d000 RIP: <ffffffff8010f2e4>{show_trace+465}
PGD f6f25067 PUD f6fcc067 PMD f6957067 PTE 0
Oops: 0000 [2] PREEMPT SMP
This patch disables preemptions for the task upon entry to do_debug(), before
interrupts are reenabled, and then disables preemption before exiting
do_debug(), after disabling interrupts. I've noticed that the task can be
preempted either at the end of an interrupt, or on the call to
force_sig_info() on the spin_unlock_irqrestore() processing. It might be
better to attempt to code a fix in entry.S around the code that calls
do_debug().
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-12 15:34:58 -07:00
|
|
|
preempt_conditional_cli(regs);
|
2005-04-16 15:25:03 -07:00
|
|
|
return;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
clear_TF_reenable:
|
|
|
|
set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
|
|
|
|
regs->eflags &= ~TF_MASK;
|
[PATCH] arch/x86_64/kernel/traps.c PTRACE_SINGLESTEP oops
We found a problem with x86_64 kernels with preemption enabled, where
having multiple tasks doing ptrace singlesteps around the same time will
cause the system to 'oops'. The problem seems that a task can get
preempted out of the do_debug() processing while it is running on the
DEBUG_STACK stack. If another task on that same cpu then enters do_debug()
and uses the same per-cpu DEBUG_STACK stack, the previous preempted tasks's
stack contents can be corrupted, and the system will oops when the
preempted task is context switched back in again.
The typical oops looks like the following:
Unable to handle kernel paging request at ffffffffffffffae RIP: <ffffffff805452a1>{thread_return+34}
PGD 103027 PUD 102429067 PMD 0
Oops: 0002 [1] PREEMPT SMP
CPU 0
Modules linked in:
Pid: 3786, comm: ssdd Not tainted 2.6.15.2 #1
RIP: 0010:[<ffffffff805452a1>] <ffffffff805452a1>{thread_return+34}
RSP: 0018:ffffffff80824058 EFLAGS: 000136c2
RAX: ffff81017e12cea0 RBX: 0000000000000000 RCX: 00000000c0000100
RDX: 0000000000000000 RSI: ffff8100f7856e20 RDI: ffff81017e12cea0
RBP: 0000000000000046 R08: ffff8100f68a6000 R09: 0000000000000000
R10: 0000000000000000 R11: ffff81017e12cea0 R12: ffff81000c2d53e8
R13: ffff81017f5b3be8 R14: ffff81000c0036e0 R15: 000001056cbfc899
FS: 00002aaaaaad9b00(0000) GS:ffffffff80883800(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffffffffffffffae CR3: 00000000f6fcf000 CR4: 00000000000006e0
Process ssdd (pid: 3786, threadinfo ffff8100f68a6000, task ffff8100f7856e20)
Stack: ffffffff808240d8 ffffffff8012a84a ffff8100055f6c00 0000000000000020
0000000000000001 ffff81000c0036e0 ffffffff808240b8 0000000000000000
0000000000000000 0000000000000000
Call Trace: <#DB>
<ffffffff8012a84a>{try_to_wake_up+985}
<ffffffff8012c0d3>{kick_process+87}
<ffffffff8013b262>{signal_wake_up+48}
<ffffffff8013b5ce>{specific_send_sig_info+179}
<ffffffff80546abc>{_spin_unlock_irqrestore+27}
<ffffffff8013b67c>{force_sig_info+159}
<ffffffff801103a0>{do_debug+289} <ffffffff80110278>{sync_regs+103}
<ffffffff8010ed9a>{paranoid_userspace+35}
Unable to handle kernel paging request at 00007fffffb7d000 RIP: <ffffffff8010f2e4>{show_trace+465}
PGD f6f25067 PUD f6fcc067 PMD f6957067 PTE 0
Oops: 0000 [2] PREEMPT SMP
This patch disables preemptions for the task upon entry to do_debug(), before
interrupts are reenabled, and then disables preemption before exiting
do_debug(), after disabling interrupts. I've noticed that the task can be
preempted either at the end of an interrupt, or on the call to
force_sig_info() on the spin_unlock_irqrestore() processing. It might be
better to attempt to code a fix in entry.S around the code that calls
do_debug().
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-12 15:34:58 -07:00
|
|
|
preempt_conditional_cli(regs);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2006-01-11 14:42:14 -07:00
|
|
|
static int kernel_math_error(struct pt_regs *regs, const char *str, int trapnr)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
const struct exception_table_entry *fixup;
|
|
|
|
fixup = search_exception_tables(regs->rip);
|
|
|
|
if (fixup) {
|
|
|
|
regs->rip = fixup->fixup;
|
|
|
|
return 1;
|
|
|
|
}
|
2006-01-11 14:42:14 -07:00
|
|
|
notify_die(DIE_GPF, str, regs, 0, trapnr, SIGFPE);
|
2005-04-16 15:25:06 -07:00
|
|
|
/* Illegal floating point operation in the kernel */
|
2006-01-11 14:42:14 -07:00
|
|
|
current->thread.trap_no = trapnr;
|
2005-04-16 15:20:36 -07:00
|
|
|
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);
|
2005-06-23 00:08:46 -07:00
|
|
|
if (!user_mode(regs) &&
|
2006-01-11 14:42:14 -07:00
|
|
|
kernel_math_error(regs, "kernel x87 math error", 16))
|
2005-04-16 15:20:36 -07:00
|
|
|
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);
|
[PATCH] x86-64: Fix incorrect FP signals
This is the same patch that went into i386 just before 2.6.13
came out. I still can't build 64-bit user apps, so I tested
with program (see below) in 32-bit mode on 64-bit kernel:
Before:
$ fpsig
handler: nr = 8, si = 0x0804bc90, vuc = 0x0804bd10
handler: altstack is at 0x0804b000, ebp = 0x0804bc7c
handler: si_signo = 8, si_errno = 0, si_code = 0 [unknown]
handler: fpu cwd = 0xb40, fpu swd = 0xbaa0
handler: i387 unmasked precision exception, rounded up
After:
$ fpsig
handler: nr = 8, si = 0x0804bc90, vuc = 0x0804bd10
handler: altstack is at 0x0804b000, ebp = 0x0804bc7c
handler: si_signo = 8, si_errno = 0, si_code = 6 [inexact result]
handler: fpu cwd = 0xb40, fpu swd = 0xbaa0
handler: i387 unmasked precision exception, rounded up
Signed-off-by: Chuck Ebbert <76306.1226@compuserve.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-12 09:49:25 -07:00
|
|
|
switch (swd & ~cwd & 0x3f) {
|
2005-04-16 15:20:36 -07:00
|
|
|
case 0x000:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case 0x001: /* Invalid Op */
|
[PATCH] x86-64: Fix incorrect FP signals
This is the same patch that went into i386 just before 2.6.13
came out. I still can't build 64-bit user apps, so I tested
with program (see below) in 32-bit mode on 64-bit kernel:
Before:
$ fpsig
handler: nr = 8, si = 0x0804bc90, vuc = 0x0804bd10
handler: altstack is at 0x0804b000, ebp = 0x0804bc7c
handler: si_signo = 8, si_errno = 0, si_code = 0 [unknown]
handler: fpu cwd = 0xb40, fpu swd = 0xbaa0
handler: i387 unmasked precision exception, rounded up
After:
$ fpsig
handler: nr = 8, si = 0x0804bc90, vuc = 0x0804bd10
handler: altstack is at 0x0804b000, ebp = 0x0804bc7c
handler: si_signo = 8, si_errno = 0, si_code = 6 [inexact result]
handler: fpu cwd = 0xb40, fpu swd = 0xbaa0
handler: i387 unmasked precision exception, rounded up
Signed-off-by: Chuck Ebbert <76306.1226@compuserve.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-12 09:49:25 -07:00
|
|
|
/*
|
|
|
|
* swd & 0x240 == 0x040: Stack Underflow
|
|
|
|
* swd & 0x240 == 0x240: Stack Overflow
|
|
|
|
* User must clear the SF bit (0x40) if set
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
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);
|
2005-06-23 00:08:46 -07:00
|
|
|
if (!user_mode(regs) &&
|
2006-01-11 14:42:14 -07:00
|
|
|
kernel_math_error(regs, "kernel simd math error", 19))
|
2005-04-16 15:20:36 -07:00
|
|
|
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)
|
2005-11-05 09:25:53 -07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage void __attribute__((weak)) mce_threshold_interrupt(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* '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);
|
2006-01-12 02:05:38 -07:00
|
|
|
task_thread_info(me)->status |= TS_USEDFPU;
|
2006-09-26 01:52:36 -07:00
|
|
|
me->fpu_counter++;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void __init trap_init(void)
|
|
|
|
{
|
|
|
|
set_intr_gate(0,÷_error);
|
|
|
|
set_intr_gate_ist(1,&debug,DEBUG_STACK);
|
|
|
|
set_intr_gate_ist(2,&nmi,NMI_STACK);
|
2006-01-11 14:43:00 -07:00
|
|
|
set_system_gate_ist(3,&int3,DEBUG_STACK); /* int3 can be called from all */
|
2006-01-11 14:42:08 -07:00
|
|
|
set_system_gate(4,&overflow); /* int4 can be called from all */
|
|
|
|
set_intr_gate(5,&bounds);
|
2005-04-16 15:20:36 -07:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-09-26 01:52:32 -07:00
|
|
|
static int __init oops_setup(char *s)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-09-26 01:52:32 -07:00
|
|
|
if (!s)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!strcmp(s, "panic"))
|
|
|
|
panic_on_oops = 1;
|
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2006-09-26 01:52:32 -07:00
|
|
|
early_param("oops", oops_setup);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
static int __init kstack_setup(char *s)
|
|
|
|
{
|
2006-09-26 01:52:32 -07:00
|
|
|
if (!s)
|
|
|
|
return -EINVAL;
|
2005-04-16 15:20:36 -07:00
|
|
|
kstack_depth_to_print = simple_strtoul(s,NULL,0);
|
2006-09-26 01:52:32 -07:00
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2006-09-26 01:52:32 -07:00
|
|
|
early_param("kstack", kstack_setup);
|