2008-10-23 16:40:06 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
* Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
|
|
|
|
*/
|
|
|
|
#include <linux/kallsyms.h>
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/utsname.h>
|
|
|
|
#include <linux/hardirq.h>
|
|
|
|
#include <linux/kdebug.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/ptrace.h>
|
2009-02-09 19:54:03 +01:00
|
|
|
#include <linux/ftrace.h>
|
2008-10-23 16:40:06 +02:00
|
|
|
#include <linux/kexec.h>
|
|
|
|
#include <linux/bug.h>
|
|
|
|
#include <linux/nmi.h>
|
|
|
|
#include <linux/sysfs.h>
|
|
|
|
|
|
|
|
#include <asm/stacktrace.h>
|
|
|
|
|
|
|
|
|
|
|
|
int panic_on_unrecovered_nmi;
|
2009-06-24 23:32:11 +02:00
|
|
|
int panic_on_io_nmi;
|
2008-10-23 16:40:06 +02:00
|
|
|
unsigned int code_bytes = 64;
|
|
|
|
int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE;
|
|
|
|
static int die_counter;
|
|
|
|
|
|
|
|
void printk_address(unsigned long address, int reliable)
|
|
|
|
{
|
2011-03-24 03:42:30 +01:00
|
|
|
printk(" [<%p>] %s%pB\n", (void *) address,
|
2008-10-23 16:40:06 +02:00
|
|
|
reliable ? "" : "? ", (void *) address);
|
|
|
|
}
|
|
|
|
|
2008-12-03 05:50:04 +01:00
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
|
|
|
static void
|
|
|
|
print_ftrace_graph_addr(unsigned long addr, void *data,
|
|
|
|
const struct stacktrace_ops *ops,
|
|
|
|
struct thread_info *tinfo, int *graph)
|
|
|
|
{
|
|
|
|
struct task_struct *task = tinfo->task;
|
|
|
|
unsigned long ret_addr;
|
|
|
|
int index = task->curr_ret_stack;
|
|
|
|
|
|
|
|
if (addr != (unsigned long)return_to_handler)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!task->ret_stack || index < *graph)
|
|
|
|
return;
|
|
|
|
|
|
|
|
index -= *graph;
|
|
|
|
ret_addr = task->ret_stack[index].ret;
|
|
|
|
|
|
|
|
ops->address(data, ret_addr, 1);
|
|
|
|
|
|
|
|
(*graph)++;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void
|
|
|
|
print_ftrace_graph_addr(unsigned long addr, void *data,
|
|
|
|
const struct stacktrace_ops *ops,
|
|
|
|
struct thread_info *tinfo, int *graph)
|
|
|
|
{ }
|
|
|
|
#endif
|
|
|
|
|
2008-10-23 16:40:06 +02:00
|
|
|
/*
|
|
|
|
* x86-64 can have up to 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, unsigned int size, void *end)
|
|
|
|
{
|
|
|
|
void *t = tinfo;
|
|
|
|
if (end) {
|
|
|
|
if (p < end && p >= (end-THREAD_SIZE))
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return p > t && p < t + THREAD_SIZE - size;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long
|
|
|
|
print_context_stack(struct thread_info *tinfo,
|
|
|
|
unsigned long *stack, unsigned long bp,
|
|
|
|
const struct stacktrace_ops *ops, void *data,
|
2008-12-03 05:50:04 +01:00
|
|
|
unsigned long *end, int *graph)
|
2008-10-23 16:40:06 +02:00
|
|
|
{
|
|
|
|
struct stack_frame *frame = (struct stack_frame *)bp;
|
|
|
|
|
|
|
|
while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) {
|
|
|
|
unsigned long addr;
|
|
|
|
|
|
|
|
addr = *stack;
|
|
|
|
if (__kernel_text_address(addr)) {
|
|
|
|
if ((unsigned long) stack == bp + sizeof(long)) {
|
|
|
|
ops->address(data, addr, 1);
|
|
|
|
frame = frame->next_frame;
|
|
|
|
bp = (unsigned long) frame;
|
|
|
|
} else {
|
2009-02-07 21:23:37 +01:00
|
|
|
ops->address(data, addr, 0);
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
2008-12-03 05:50:04 +01:00
|
|
|
print_ftrace_graph_addr(addr, data, ops, tinfo, graph);
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
|
|
|
stack++;
|
|
|
|
}
|
|
|
|
return bp;
|
|
|
|
}
|
2009-12-17 05:40:34 +01:00
|
|
|
EXPORT_SYMBOL_GPL(print_context_stack);
|
|
|
|
|
|
|
|
unsigned long
|
|
|
|
print_context_stack_bp(struct thread_info *tinfo,
|
|
|
|
unsigned long *stack, unsigned long bp,
|
|
|
|
const struct stacktrace_ops *ops, void *data,
|
|
|
|
unsigned long *end, int *graph)
|
|
|
|
{
|
|
|
|
struct stack_frame *frame = (struct stack_frame *)bp;
|
|
|
|
unsigned long *ret_addr = &frame->return_address;
|
|
|
|
|
|
|
|
while (valid_stack_ptr(tinfo, ret_addr, sizeof(*ret_addr), end)) {
|
|
|
|
unsigned long addr = *ret_addr;
|
|
|
|
|
2009-12-31 03:52:25 +01:00
|
|
|
if (!__kernel_text_address(addr))
|
|
|
|
break;
|
|
|
|
|
|
|
|
ops->address(data, addr, 1);
|
|
|
|
frame = frame->next_frame;
|
|
|
|
ret_addr = &frame->return_address;
|
|
|
|
print_ftrace_graph_addr(addr, data, ops, tinfo, graph);
|
2009-12-17 05:40:34 +01:00
|
|
|
}
|
2009-12-31 03:52:25 +01:00
|
|
|
|
2009-12-17 05:40:34 +01:00
|
|
|
return (unsigned long)frame;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(print_context_stack_bp);
|
2008-10-23 16:40:06 +02:00
|
|
|
|
|
|
|
static int print_trace_stack(void *data, char *name)
|
|
|
|
{
|
|
|
|
printk("%s <%s> ", (char *)data, name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print one address/symbol entries per line.
|
|
|
|
*/
|
|
|
|
static void print_trace_address(void *data, unsigned long addr, int reliable)
|
|
|
|
{
|
|
|
|
touch_nmi_watchdog();
|
|
|
|
printk(data);
|
|
|
|
printk_address(addr, reliable);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct stacktrace_ops print_trace_ops = {
|
2009-12-17 05:40:34 +01:00
|
|
|
.stack = print_trace_stack,
|
|
|
|
.address = print_trace_address,
|
2009-12-17 05:40:33 +01:00
|
|
|
.walk_stack = print_context_stack,
|
2008-10-23 16:40:06 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
|
2011-03-18 03:40:06 +01:00
|
|
|
unsigned long *stack, unsigned long bp, char *log_lvl)
|
2008-10-23 16:40:06 +02:00
|
|
|
{
|
|
|
|
printk("%sCall Trace:\n", log_lvl);
|
2011-03-18 03:40:06 +01:00
|
|
|
dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl);
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void show_trace(struct task_struct *task, struct pt_regs *regs,
|
2011-03-18 03:40:06 +01:00
|
|
|
unsigned long *stack, unsigned long bp)
|
2008-10-23 16:40:06 +02:00
|
|
|
{
|
2011-03-18 03:40:06 +01:00
|
|
|
show_trace_log_lvl(task, regs, stack, bp, "");
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void show_stack(struct task_struct *task, unsigned long *sp)
|
|
|
|
{
|
2011-03-18 03:40:06 +01:00
|
|
|
show_stack_log_lvl(task, NULL, sp, 0, "");
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The architecture-independent dump_stack generator
|
|
|
|
*/
|
|
|
|
void dump_stack(void)
|
|
|
|
{
|
2011-03-18 03:40:06 +01:00
|
|
|
unsigned long bp;
|
2008-10-23 16:40:06 +02:00
|
|
|
unsigned long stack;
|
|
|
|
|
2011-03-18 03:40:06 +01:00
|
|
|
bp = stack_frame(current, NULL);
|
2008-10-23 16:40:06 +02:00
|
|
|
printk("Pid: %d, comm: %.20s %s %s %.*s\n",
|
|
|
|
current->pid, current->comm, print_tainted(),
|
|
|
|
init_utsname()->release,
|
|
|
|
(int)strcspn(init_utsname()->version, " "),
|
|
|
|
init_utsname()->version);
|
2011-03-18 03:40:06 +01:00
|
|
|
show_trace(NULL, NULL, &stack, bp);
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dump_stack);
|
|
|
|
|
2009-12-03 12:38:57 +01:00
|
|
|
static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED;
|
2008-10-23 16:40:06 +02:00
|
|
|
static int die_owner = -1;
|
|
|
|
static unsigned int die_nest_count;
|
|
|
|
|
|
|
|
unsigned __kprobes long oops_begin(void)
|
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
oops_enter();
|
|
|
|
|
|
|
|
/* racy, but better than risking deadlock. */
|
|
|
|
raw_local_irq_save(flags);
|
|
|
|
cpu = smp_processor_id();
|
2009-12-02 20:01:25 +01:00
|
|
|
if (!arch_spin_trylock(&die_lock)) {
|
2008-10-23 16:40:06 +02:00
|
|
|
if (cpu == die_owner)
|
|
|
|
/* nested oops. should stop eventually */;
|
|
|
|
else
|
2009-12-02 20:01:25 +01:00
|
|
|
arch_spin_lock(&die_lock);
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
|
|
|
die_nest_count++;
|
|
|
|
die_owner = cpu;
|
|
|
|
console_verbose();
|
|
|
|
bust_spinlocks(1);
|
|
|
|
return flags;
|
|
|
|
}
|
ACPI, APEI, Generic Hardware Error Source POLL/IRQ/NMI notification type support
Generic Hardware Error Source provides a way to report platform
hardware errors (such as that from chipset). It works in so called
"Firmware First" mode, that is, hardware errors are reported to
firmware firstly, then reported to Linux by firmware. This way, some
non-standard hardware error registers or non-standard hardware link
can be checked by firmware to produce more valuable hardware error
information for Linux.
This patch adds POLL/IRQ/NMI notification types support.
Because the memory area used to transfer hardware error information
from BIOS to Linux can be determined only in NMI, IRQ or timer
handler, but general ioremap can not be used in atomic context, so a
special version of atomic ioremap is implemented for that.
Known issue:
- Error information can not be printed for recoverable errors notified
via NMI, because printk is not NMI-safe. Will fix this via delay
printing to IRQ context via irq_work or make printk NMI-safe.
v2:
- adjust printk format per comments.
Signed-off-by: Huang Ying <ying.huang@intel.com>
Reviewed-by: Andi Kleen <ak@linux.intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2011-01-12 07:44:55 +01:00
|
|
|
EXPORT_SYMBOL_GPL(oops_begin);
|
2008-10-23 16:40:06 +02:00
|
|
|
|
|
|
|
void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr)
|
|
|
|
{
|
|
|
|
if (regs && kexec_should_crash(current))
|
|
|
|
crash_kexec(regs);
|
|
|
|
|
|
|
|
bust_spinlocks(0);
|
|
|
|
die_owner = -1;
|
|
|
|
add_taint(TAINT_DIE);
|
|
|
|
die_nest_count--;
|
|
|
|
if (!die_nest_count)
|
|
|
|
/* Nest count reaches zero, release the lock. */
|
2009-12-02 20:01:25 +01:00
|
|
|
arch_spin_unlock(&die_lock);
|
2008-10-23 16:40:06 +02:00
|
|
|
raw_local_irq_restore(flags);
|
|
|
|
oops_exit();
|
|
|
|
|
|
|
|
if (!signr)
|
|
|
|
return;
|
|
|
|
if (in_interrupt())
|
|
|
|
panic("Fatal exception in interrupt");
|
|
|
|
if (panic_on_oops)
|
|
|
|
panic("Fatal exception");
|
|
|
|
do_exit(signr);
|
|
|
|
}
|
|
|
|
|
|
|
|
int __kprobes __die(const char *str, struct pt_regs *regs, long err)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
unsigned short ss;
|
|
|
|
unsigned long sp;
|
|
|
|
#endif
|
bugs, x86: Fix printk levels for panic, softlockups and stack dumps
rsyslog will display KERN_EMERG messages on a connected
terminal. However, these messages are useless/undecipherable
for a general user.
For example, after a softlockup we get:
Message from syslogd@intel-s3e37-04 at Jan 25 14:18:06 ...
kernel:Stack:
Message from syslogd@intel-s3e37-04 at Jan 25 14:18:06 ...
kernel:Call Trace:
Message from syslogd@intel-s3e37-04 at Jan 25 14:18:06 ...
kernel:Code: ff ff a8 08 75 25 31 d2 48 8d 86 38 e0 ff ff 48 89
d1 0f 01 c8 0f ae f0 48 8b 86 38 e0 ff ff a8 08 75 08 b1 01 4c 89 e0 0f 01 c9 <e8> ea 69 dd ff 4c 29 e8 48 89 c7 e8 0f bc da ff 49 89 c4 49 89
This happens because the printk levels for these messages are
incorrect. Only an informational message should be displayed on
a terminal.
I modified the printk levels for various messages in the kernel
and tested the output by using the drivers/misc/lkdtm.c kernel
modules (ie, softlockups, panics, hard lockups, etc.) and
confirmed that the console output was still the same and that
the output to the terminals was correct.
For example, in the case of a softlockup we now see the much
more informative:
Message from syslogd@intel-s3e37-04 at Jan 25 10:18:06 ...
BUG: soft lockup - CPU4 stuck for 60s!
instead of the above confusing messages.
AFAICT, the messages no longer have to be KERN_EMERG. In the
most important case of a panic we set console_verbose(). As for
the other less severe cases the correct data is output to the
console and /var/log/messages.
Successfully tested by me using the drivers/misc/lkdtm.c module.
Signed-off-by: Prarit Bhargava <prarit@redhat.com>
Cc: dzickus@redhat.com
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: http://lkml.kernel.org/r/1327586134-11926-1-git-send-email-prarit@redhat.com
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2012-01-26 14:55:34 +01:00
|
|
|
printk(KERN_DEFAULT
|
|
|
|
"%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
|
2008-10-23 16:40:06 +02:00
|
|
|
#ifdef CONFIG_PREEMPT
|
|
|
|
printk("PREEMPT ");
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
printk("SMP ");
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
printk("DEBUG_PAGEALLOC");
|
|
|
|
#endif
|
|
|
|
printk("\n");
|
|
|
|
if (notify_die(DIE_OOPS, str, regs, err,
|
|
|
|
current->thread.trap_no, SIGSEGV) == NOTIFY_STOP)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
show_registers(regs);
|
|
|
|
#ifdef CONFIG_X86_32
|
2009-10-12 23:11:09 +02:00
|
|
|
if (user_mode_vm(regs)) {
|
2008-10-23 16:40:06 +02:00
|
|
|
sp = regs->sp;
|
|
|
|
ss = regs->ss & 0xffff;
|
2009-10-12 23:11:09 +02:00
|
|
|
} else {
|
|
|
|
sp = kernel_stack_pointer(regs);
|
|
|
|
savesegment(ss, ss);
|
2008-10-23 16:40:06 +02:00
|
|
|
}
|
|
|
|
printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip);
|
|
|
|
print_symbol("%s", regs->ip);
|
|
|
|
printk(" SS:ESP %04x:%08lx\n", ss, sp);
|
|
|
|
#else
|
|
|
|
/* Executive summary in case the oops scrolled away */
|
|
|
|
printk(KERN_ALERT "RIP ");
|
|
|
|
printk_address(regs->ip, 1);
|
|
|
|
printk(" RSP <%016lx>\n", regs->sp);
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
unsigned long flags = oops_begin();
|
|
|
|
int sig = SIGSEGV;
|
|
|
|
|
|
|
|
if (!user_mode_vm(regs))
|
|
|
|
report_bug(regs->ip, regs);
|
|
|
|
|
|
|
|
if (__die(str, regs, err))
|
|
|
|
sig = 0;
|
|
|
|
oops_end(flags, regs, sig);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
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);
|