2008-10-23 22:40:06 +08: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>
|
2017-02-09 01:51:35 +08:00
|
|
|
#include <linux/sched/debug.h>
|
2017-02-09 01:51:37 +08:00
|
|
|
#include <linux/sched/task_stack.h>
|
2009-02-10 02:54:03 +08:00
|
|
|
#include <linux/ftrace.h>
|
2008-10-23 22:40:06 +08:00
|
|
|
#include <linux/kexec.h>
|
|
|
|
|
#include <linux/bug.h>
|
|
|
|
|
#include <linux/nmi.h>
|
|
|
|
|
#include <linux/sysfs.h>
|
|
|
|
|
|
2017-12-21 01:51:31 +08:00
|
|
|
#include <asm/cpu_entry_area.h>
|
2008-10-23 22:40:06 +08:00
|
|
|
#include <asm/stacktrace.h>
|
2016-09-17 03:18:16 +08:00
|
|
|
#include <asm/unwind.h>
|
2008-10-23 22:40:06 +08:00
|
|
|
|
|
|
|
|
int panic_on_unrecovered_nmi;
|
2009-06-25 05:32:11 +08:00
|
|
|
int panic_on_io_nmi;
|
2018-03-06 17:49:14 +08:00
|
|
|
static unsigned int code_bytes = 64;
|
2008-10-23 22:40:06 +08:00
|
|
|
static int die_counter;
|
|
|
|
|
|
2016-09-15 10:07:42 +08:00
|
|
|
bool in_task_stack(unsigned long *stack, struct task_struct *task,
|
|
|
|
|
struct stack_info *info)
|
|
|
|
|
{
|
|
|
|
|
unsigned long *begin = task_stack_page(task);
|
|
|
|
|
unsigned long *end = task_stack_page(task) + THREAD_SIZE;
|
|
|
|
|
|
|
|
|
|
if (stack < begin || stack >= end)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
info->type = STACK_TYPE_TASK;
|
|
|
|
|
info->begin = begin;
|
|
|
|
|
info->end = end;
|
|
|
|
|
info->next_sp = NULL;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-05 09:25:07 +08:00
|
|
|
bool in_entry_stack(unsigned long *stack, struct stack_info *info)
|
2017-12-04 22:07:13 +08:00
|
|
|
{
|
2017-12-05 09:25:07 +08:00
|
|
|
struct entry_stack *ss = cpu_entry_stack(smp_processor_id());
|
2017-12-04 22:07:13 +08:00
|
|
|
|
2017-12-04 22:07:28 +08:00
|
|
|
void *begin = ss;
|
|
|
|
|
void *end = ss + 1;
|
2017-12-04 22:07:13 +08:00
|
|
|
|
|
|
|
|
if ((void *)stack < begin || (void *)stack >= end)
|
|
|
|
|
return false;
|
|
|
|
|
|
2017-12-05 09:25:07 +08:00
|
|
|
info->type = STACK_TYPE_ENTRY;
|
2017-12-04 22:07:13 +08:00
|
|
|
info->begin = begin;
|
|
|
|
|
info->end = end;
|
|
|
|
|
info->next_sp = NULL;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-20 10:34:21 +08:00
|
|
|
static void printk_stack_address(unsigned long address, int reliable,
|
2016-08-25 00:50:16 +08:00
|
|
|
char *log_lvl)
|
2008-10-23 22:40:06 +08:00
|
|
|
{
|
2016-08-25 00:50:16 +08:00
|
|
|
touch_nmi_watchdog();
|
2016-10-25 22:51:12 +08:00
|
|
|
printk("%s %s%pB\n", log_lvl, reliable ? "" : "? ", (void *)address);
|
2013-10-25 21:06:58 +08:00
|
|
|
}
|
|
|
|
|
|
2017-12-04 22:07:09 +08:00
|
|
|
void show_iret_regs(struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
printk(KERN_DEFAULT "RIP: %04x:%pS\n", (int)regs->cs, (void *)regs->ip);
|
|
|
|
|
printk(KERN_DEFAULT "RSP: %04x:%016lx EFLAGS: %08lx", (int)regs->ss,
|
|
|
|
|
regs->sp, regs->flags);
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-01 00:18:06 +08:00
|
|
|
static void show_regs_if_on_stack(struct stack_info *info, struct pt_regs *regs,
|
|
|
|
|
bool partial)
|
2017-12-04 22:07:09 +08:00
|
|
|
{
|
2018-01-01 00:18:06 +08:00
|
|
|
/*
|
|
|
|
|
* These on_stack() checks aren't strictly necessary: the unwind code
|
|
|
|
|
* has already validated the 'regs' pointer. The checks are done for
|
|
|
|
|
* ordering reasons: if the registers are on the next stack, we don't
|
|
|
|
|
* want to print them out yet. Otherwise they'll be shown as part of
|
|
|
|
|
* the wrong stack. Later, when show_trace_log_lvl() switches to the
|
|
|
|
|
* next stack, this function will be called again with the same regs so
|
|
|
|
|
* they can be printed in the right context.
|
|
|
|
|
*/
|
|
|
|
|
if (!partial && on_stack(info, regs, sizeof(*regs))) {
|
2017-12-04 22:07:09 +08:00
|
|
|
__show_regs(regs, 0);
|
2018-01-01 00:18:06 +08:00
|
|
|
|
|
|
|
|
} else if (partial && on_stack(info, (void *)regs + IRET_FRAME_OFFSET,
|
|
|
|
|
IRET_FRAME_SIZE)) {
|
2017-12-04 22:07:09 +08:00
|
|
|
/*
|
|
|
|
|
* When an interrupt or exception occurs in entry code, the
|
|
|
|
|
* full pt_regs might not have been saved yet. In that case
|
|
|
|
|
* just print the iret frame.
|
|
|
|
|
*/
|
|
|
|
|
show_iret_regs(regs);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-17 03:18:16 +08:00
|
|
|
void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
|
|
|
|
|
unsigned long *stack, char *log_lvl)
|
2008-10-23 22:40:06 +08:00
|
|
|
{
|
2016-09-17 03:18:16 +08:00
|
|
|
struct unwind_state state;
|
|
|
|
|
struct stack_info stack_info = {0};
|
|
|
|
|
unsigned long visit_mask = 0;
|
|
|
|
|
int graph_idx = 0;
|
2018-02-02 22:56:17 +08:00
|
|
|
bool partial = false;
|
2008-10-23 22:40:06 +08:00
|
|
|
|
2016-09-17 03:18:16 +08:00
|
|
|
printk("%sCall Trace:\n", log_lvl);
|
2008-10-23 22:40:06 +08:00
|
|
|
|
2016-09-17 03:18:16 +08:00
|
|
|
unwind_start(&state, task, regs, stack);
|
2016-11-17 14:04:58 +08:00
|
|
|
stack = stack ? : get_stack_pointer(task, regs);
|
2018-01-01 00:18:07 +08:00
|
|
|
regs = unwind_get_entry_regs(&state, &partial);
|
2008-10-23 22:40:06 +08:00
|
|
|
|
2016-09-17 03:18:16 +08:00
|
|
|
/*
|
|
|
|
|
* Iterate through the stacks, starting with the current stack pointer.
|
|
|
|
|
* Each stack has a pointer to the next one.
|
|
|
|
|
*
|
|
|
|
|
* x86-64 can have several stacks:
|
|
|
|
|
* - task stack
|
|
|
|
|
* - interrupt stack
|
|
|
|
|
* - HW exception stacks (double fault, nmi, debug, mce)
|
2017-12-05 09:25:07 +08:00
|
|
|
* - entry stack
|
2016-09-17 03:18:16 +08:00
|
|
|
*
|
2017-12-04 22:07:18 +08:00
|
|
|
* x86-32 can have up to four stacks:
|
2016-09-17 03:18:16 +08:00
|
|
|
* - task stack
|
|
|
|
|
* - softirq stack
|
|
|
|
|
* - hardirq stack
|
2017-12-05 09:25:07 +08:00
|
|
|
* - entry stack
|
2016-09-17 03:18:16 +08:00
|
|
|
*/
|
2018-01-01 00:18:07 +08:00
|
|
|
for ( ; stack; stack = PTR_ALIGN(stack_info.next_sp, sizeof(long))) {
|
2016-11-19 01:46:23 +08:00
|
|
|
const char *stack_name;
|
2016-09-17 03:18:16 +08:00
|
|
|
|
2017-12-04 22:07:18 +08:00
|
|
|
if (get_stack_info(stack, task, &stack_info, &visit_mask)) {
|
|
|
|
|
/*
|
|
|
|
|
* We weren't on a valid stack. It's possible that
|
|
|
|
|
* we overflowed a valid stack into a guard page.
|
|
|
|
|
* See if the next page up is valid so that we can
|
|
|
|
|
* generate some kind of backtrace if this happens.
|
|
|
|
|
*/
|
|
|
|
|
stack = (unsigned long *)PAGE_ALIGN((unsigned long)stack);
|
|
|
|
|
if (get_stack_info(stack, task, &stack_info, &visit_mask))
|
|
|
|
|
break;
|
|
|
|
|
}
|
2016-09-17 03:18:16 +08:00
|
|
|
|
2016-11-19 01:46:23 +08:00
|
|
|
stack_name = stack_type_name(stack_info.type);
|
|
|
|
|
if (stack_name)
|
|
|
|
|
printk("%s <%s>\n", log_lvl, stack_name);
|
2016-09-17 03:18:16 +08:00
|
|
|
|
2017-12-04 22:07:09 +08:00
|
|
|
if (regs)
|
2018-01-01 00:18:06 +08:00
|
|
|
show_regs_if_on_stack(&stack_info, regs, partial);
|
2017-07-11 23:33:40 +08:00
|
|
|
|
2016-09-17 03:18:16 +08:00
|
|
|
/*
|
|
|
|
|
* Scan the stack, printing any text addresses we find. At the
|
|
|
|
|
* same time, follow proper stack frames with the unwinder.
|
|
|
|
|
*
|
|
|
|
|
* Addresses found during the scan which are not reported by
|
|
|
|
|
* the unwinder are considered to be additional clues which are
|
|
|
|
|
* sometimes useful for debugging and are prefixed with '?'.
|
|
|
|
|
* This also serves as a failsafe option in case the unwinder
|
|
|
|
|
* goes off in the weeds.
|
|
|
|
|
*/
|
|
|
|
|
for (; stack < stack_info.end; stack++) {
|
|
|
|
|
unsigned long real_addr;
|
|
|
|
|
int reliable = 0;
|
2016-11-17 23:57:24 +08:00
|
|
|
unsigned long addr = READ_ONCE_NOCHECK(*stack);
|
2016-09-17 03:18:16 +08:00
|
|
|
unsigned long *ret_addr_p =
|
|
|
|
|
unwind_get_return_address_ptr(&state);
|
|
|
|
|
|
|
|
|
|
if (!__kernel_text_address(addr))
|
|
|
|
|
continue;
|
|
|
|
|
|
2016-10-21 00:34:43 +08:00
|
|
|
/*
|
|
|
|
|
* Don't print regs->ip again if it was already printed
|
2018-01-01 00:18:06 +08:00
|
|
|
* by show_regs_if_on_stack().
|
2016-10-21 00:34:43 +08:00
|
|
|
*/
|
2017-07-11 23:33:40 +08:00
|
|
|
if (regs && stack == ®s->ip)
|
|
|
|
|
goto next;
|
2016-10-21 00:34:43 +08:00
|
|
|
|
2016-09-17 03:18:16 +08:00
|
|
|
if (stack == ret_addr_p)
|
|
|
|
|
reliable = 1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* When function graph tracing is enabled for a
|
|
|
|
|
* function, its return address on the stack is
|
|
|
|
|
* replaced with the address of an ftrace handler
|
|
|
|
|
* (return_to_handler). In that case, before printing
|
|
|
|
|
* the "real" address, we want to print the handler
|
|
|
|
|
* address as an "unreliable" hint that function graph
|
|
|
|
|
* tracing was involved.
|
|
|
|
|
*/
|
|
|
|
|
real_addr = ftrace_graph_ret_addr(task, &graph_idx,
|
|
|
|
|
addr, stack);
|
|
|
|
|
if (real_addr != addr)
|
|
|
|
|
printk_stack_address(addr, 0, log_lvl);
|
|
|
|
|
printk_stack_address(real_addr, reliable, log_lvl);
|
|
|
|
|
|
|
|
|
|
if (!reliable)
|
|
|
|
|
continue;
|
|
|
|
|
|
2017-07-11 23:33:40 +08:00
|
|
|
next:
|
2016-09-17 03:18:16 +08:00
|
|
|
/*
|
|
|
|
|
* Get the next frame from the unwinder. No need to
|
|
|
|
|
* check for an error: if anything goes wrong, the rest
|
|
|
|
|
* of the addresses will just be printed as unreliable.
|
|
|
|
|
*/
|
|
|
|
|
unwind_next_frame(&state);
|
2016-10-21 00:34:43 +08:00
|
|
|
|
|
|
|
|
/* if the frame has entry regs, print them */
|
2018-01-01 00:18:06 +08:00
|
|
|
regs = unwind_get_entry_regs(&state, &partial);
|
2017-12-04 22:07:09 +08:00
|
|
|
if (regs)
|
2018-01-01 00:18:06 +08:00
|
|
|
show_regs_if_on_stack(&stack_info, regs, partial);
|
2016-09-17 03:18:16 +08:00
|
|
|
}
|
|
|
|
|
|
2016-11-19 01:46:23 +08:00
|
|
|
if (stack_name)
|
|
|
|
|
printk("%s </%s>\n", log_lvl, stack_name);
|
2016-09-17 03:18:16 +08:00
|
|
|
}
|
2008-10-23 22:40:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void show_stack(struct task_struct *task, unsigned long *sp)
|
|
|
|
|
{
|
2016-09-16 21:05:20 +08:00
|
|
|
task = task ? : current;
|
|
|
|
|
|
x86: don't show trace beyond show_stack(NULL, NULL)
There are multiple ways a task can be dumped - explicit call to
dump_stack(), triggering WARN() or BUG(), through sysrq-t and so on.
Most of what gets printed is upto each architecture and the current
state is not particularly pretty. Different pieces of information are
presented differently depending on which path the dump takes and which
architecture it's running on. This is messy for no good reason and
makes it exceedingly difficult to add or modify debug information to
task dumps.
In all archs except for s390, there's nothing arch-specific about the
printed debug information. This patchset updates all those archs to use
the same helpers to consistently print out the same debug information.
An example WARN dump after this patchset.
WARNING: at kernel/workqueue.c:4841 init_workqueues+0x35/0x505()
Modules linked in:
CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.9.0-rc1-work+ #3
Hardware name: empty empty/S3992, BIOS 080011 10/26/2007
0000000000000009 ffff88007c861e08 ffffffff81c614dc ffff88007c861e48
ffffffff8108f500 ffffffff82228240 0000000000000040 ffffffff8234a08e
0000000000000000 0000000000000000 0000000000000000 ffff88007c861e58
Call Trace:
[<ffffffff81c614dc>] dump_stack+0x19/0x1b
[<ffffffff8108f500>] warn_slowpath_common+0x70/0xa0
[<ffffffff8108f54a>] warn_slowpath_null+0x1a/0x20
[<ffffffff8234a0c3>] init_workqueues+0x35/0x505
...
And BUG dump.
kernel BUG at kernel/workqueue.c:4841!
invalid opcode: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC
Modules linked in:
CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.9.0-rc1-work+ #7
Hardware name: empty empty/S3992, BIOS 080011 10/26/2007
task: ffff88007c85e040 ti: ffff88007c860000 task.ti: ffff88007c860000
RIP: 0010:[<ffffffff8234a07e>] [<ffffffff8234a07e>] init_workqueues+0x4/0x6
RSP: 0000:ffff88007c861ec8 EFLAGS: 00010246
RAX: ffff88007c861fd8 RBX: ffffffff824466a8 RCX: 0000000000000001
RDX: 0000000000000046 RSI: 0000000000000001 RDI: ffffffff8234a07a
RBP: ffff88007c861ec8 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000001 R11: 0000000000000000 R12: ffffffff8234a07a
R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88007dc00000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffff88015f7ff000 CR3: 00000000021f1000 CR4: 00000000000007f0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Stack:
ffff88007c861ef8 ffffffff81000312 ffffffff824466a8 ffff88007c85e650
0000000000000003 0000000000000000 ffff88007c861f38 ffffffff82335e5d
ffff88007c862080 ffffffff8223d8c0 ffff88007c862080 ffffffff81c47760
Call Trace:
[<ffffffff81000312>] do_one_initcall+0x122/0x170
[<ffffffff82335e5d>] kernel_init_freeable+0x9b/0x1c8
[<ffffffff81c47760>] ? rest_init+0x140/0x140
[<ffffffff81c4776e>] kernel_init+0xe/0xf0
[<ffffffff81c6be9c>] ret_from_fork+0x7c/0xb0
[<ffffffff81c47760>] ? rest_init+0x140/0x140
...
This patchset contains the following seven patches.
0001-x86-don-t-show-trace-beyond-show_stack-NULL-NULL.patch
0002-sparc32-make-show_stack-acquire-fp-if-_ksp-is-not-sp.patch
0003-dump_stack-consolidate-dump_stack-implementations-an.patch
0004-dmi-morph-dmi_dump_ids-into-dmi_format_ids-which-for.patch
0005-dump_stack-implement-arch-specific-hardware-descript.patch
0006-dump_stack-unify-debug-information-printed-by-show_r.patch
0007-arc-print-fatal-signals-reduce-duplicated-informatio.patch
0001-0002 update stack dumping functions in x86 and sparc32 in
preparation.
0003 makes all arches except blackfin use generic dump_stack().
blackfin still uses the generic helper to print the same info.
0004-0005 properly abstract DMI identifier printing in WARN() and
show_regs() so that all dumps print out the information. This enables
show_regs() to use the same debug info message.
0006 updates show_regs() of all arches to use a common generic helper
to print debug info.
0007 removes somem duplicate information from arc dumps.
While this patchset changes how debug info is printed on some archs,
the printed information is always superset of what used to be there.
This patchset makes task dump debug messages consistent and enables
adding more information. Workqueue is scheduled to add worker
information including the workqueue in use and work item specific
description.
While this patch touches a lot of archs, it isn't too likely to cause
non-trivial conflicts with arch-specfic changes and would probably be
best to route together either through -mm.
x86 is tested but other archs are either only compile tested or not
tested at all. Changes to most archs are generally trivial.
This patch:
show_stack(current or NULL, NULL) is used to print the backtrace of the
current task. As trace beyond the function itself isn't of much
interest to anyone, don't show it by determining sp and bp in
show_stack()'s frame and passing them to show_stack_log_lvl().
This brings show_stack(NULL, NULL)'s behavior in line with
dump_stack().
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Fengguang Wu <fengguang.wu@intel.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Jesper Nilsson <jesper.nilsson@axis.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Mike Frysinger <vapier@gentoo.org>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-01 06:27:09 +08:00
|
|
|
/*
|
|
|
|
|
* Stack frames below this one aren't interesting. Don't show them
|
|
|
|
|
* if we're printing for %current.
|
|
|
|
|
*/
|
2016-09-17 03:18:16 +08:00
|
|
|
if (!sp && task == current)
|
2016-08-25 00:50:17 +08:00
|
|
|
sp = get_stack_pointer(current, NULL);
|
x86: don't show trace beyond show_stack(NULL, NULL)
There are multiple ways a task can be dumped - explicit call to
dump_stack(), triggering WARN() or BUG(), through sysrq-t and so on.
Most of what gets printed is upto each architecture and the current
state is not particularly pretty. Different pieces of information are
presented differently depending on which path the dump takes and which
architecture it's running on. This is messy for no good reason and
makes it exceedingly difficult to add or modify debug information to
task dumps.
In all archs except for s390, there's nothing arch-specific about the
printed debug information. This patchset updates all those archs to use
the same helpers to consistently print out the same debug information.
An example WARN dump after this patchset.
WARNING: at kernel/workqueue.c:4841 init_workqueues+0x35/0x505()
Modules linked in:
CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.9.0-rc1-work+ #3
Hardware name: empty empty/S3992, BIOS 080011 10/26/2007
0000000000000009 ffff88007c861e08 ffffffff81c614dc ffff88007c861e48
ffffffff8108f500 ffffffff82228240 0000000000000040 ffffffff8234a08e
0000000000000000 0000000000000000 0000000000000000 ffff88007c861e58
Call Trace:
[<ffffffff81c614dc>] dump_stack+0x19/0x1b
[<ffffffff8108f500>] warn_slowpath_common+0x70/0xa0
[<ffffffff8108f54a>] warn_slowpath_null+0x1a/0x20
[<ffffffff8234a0c3>] init_workqueues+0x35/0x505
...
And BUG dump.
kernel BUG at kernel/workqueue.c:4841!
invalid opcode: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC
Modules linked in:
CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.9.0-rc1-work+ #7
Hardware name: empty empty/S3992, BIOS 080011 10/26/2007
task: ffff88007c85e040 ti: ffff88007c860000 task.ti: ffff88007c860000
RIP: 0010:[<ffffffff8234a07e>] [<ffffffff8234a07e>] init_workqueues+0x4/0x6
RSP: 0000:ffff88007c861ec8 EFLAGS: 00010246
RAX: ffff88007c861fd8 RBX: ffffffff824466a8 RCX: 0000000000000001
RDX: 0000000000000046 RSI: 0000000000000001 RDI: ffffffff8234a07a
RBP: ffff88007c861ec8 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000001 R11: 0000000000000000 R12: ffffffff8234a07a
R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88007dc00000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: ffff88015f7ff000 CR3: 00000000021f1000 CR4: 00000000000007f0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Stack:
ffff88007c861ef8 ffffffff81000312 ffffffff824466a8 ffff88007c85e650
0000000000000003 0000000000000000 ffff88007c861f38 ffffffff82335e5d
ffff88007c862080 ffffffff8223d8c0 ffff88007c862080 ffffffff81c47760
Call Trace:
[<ffffffff81000312>] do_one_initcall+0x122/0x170
[<ffffffff82335e5d>] kernel_init_freeable+0x9b/0x1c8
[<ffffffff81c47760>] ? rest_init+0x140/0x140
[<ffffffff81c4776e>] kernel_init+0xe/0xf0
[<ffffffff81c6be9c>] ret_from_fork+0x7c/0xb0
[<ffffffff81c47760>] ? rest_init+0x140/0x140
...
This patchset contains the following seven patches.
0001-x86-don-t-show-trace-beyond-show_stack-NULL-NULL.patch
0002-sparc32-make-show_stack-acquire-fp-if-_ksp-is-not-sp.patch
0003-dump_stack-consolidate-dump_stack-implementations-an.patch
0004-dmi-morph-dmi_dump_ids-into-dmi_format_ids-which-for.patch
0005-dump_stack-implement-arch-specific-hardware-descript.patch
0006-dump_stack-unify-debug-information-printed-by-show_r.patch
0007-arc-print-fatal-signals-reduce-duplicated-informatio.patch
0001-0002 update stack dumping functions in x86 and sparc32 in
preparation.
0003 makes all arches except blackfin use generic dump_stack().
blackfin still uses the generic helper to print the same info.
0004-0005 properly abstract DMI identifier printing in WARN() and
show_regs() so that all dumps print out the information. This enables
show_regs() to use the same debug info message.
0006 updates show_regs() of all arches to use a common generic helper
to print debug info.
0007 removes somem duplicate information from arc dumps.
While this patchset changes how debug info is printed on some archs,
the printed information is always superset of what used to be there.
This patchset makes task dump debug messages consistent and enables
adding more information. Workqueue is scheduled to add worker
information including the workqueue in use and work item specific
description.
While this patch touches a lot of archs, it isn't too likely to cause
non-trivial conflicts with arch-specfic changes and would probably be
best to route together either through -mm.
x86 is tested but other archs are either only compile tested or not
tested at all. Changes to most archs are generally trivial.
This patch:
show_stack(current or NULL, NULL) is used to print the backtrace of the
current task. As trace beyond the function itself isn't of much
interest to anyone, don't show it by determining sp and bp in
show_stack()'s frame and passing them to show_stack_log_lvl().
This brings show_stack(NULL, NULL)'s behavior in line with
dump_stack().
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Fengguang Wu <fengguang.wu@intel.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Jesper Nilsson <jesper.nilsson@axis.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Mike Frysinger <vapier@gentoo.org>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-01 06:27:09 +08:00
|
|
|
|
2016-10-25 22:51:13 +08:00
|
|
|
show_trace_log_lvl(task, NULL, sp, KERN_DEFAULT);
|
2008-10-23 22:40:06 +08:00
|
|
|
}
|
|
|
|
|
|
2016-07-05 06:31:27 +08:00
|
|
|
void show_stack_regs(struct pt_regs *regs)
|
|
|
|
|
{
|
2016-10-25 22:51:13 +08:00
|
|
|
show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT);
|
2016-07-05 06:31:27 +08:00
|
|
|
}
|
|
|
|
|
|
2009-12-03 19:38:57 +08:00
|
|
|
static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED;
|
2008-10-23 22:40:06 +08:00
|
|
|
static int die_owner = -1;
|
|
|
|
|
static unsigned int die_nest_count;
|
|
|
|
|
|
2014-04-17 16:18:14 +08:00
|
|
|
unsigned long oops_begin(void)
|
2008-10-23 22:40:06 +08:00
|
|
|
{
|
|
|
|
|
int cpu;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
oops_enter();
|
|
|
|
|
|
|
|
|
|
/* racy, but better than risking deadlock. */
|
|
|
|
|
raw_local_irq_save(flags);
|
|
|
|
|
cpu = smp_processor_id();
|
2009-12-03 03:01:25 +08:00
|
|
|
if (!arch_spin_trylock(&die_lock)) {
|
2008-10-23 22:40:06 +08:00
|
|
|
if (cpu == die_owner)
|
|
|
|
|
/* nested oops. should stop eventually */;
|
|
|
|
|
else
|
2009-12-03 03:01:25 +08:00
|
|
|
arch_spin_lock(&die_lock);
|
2008-10-23 22:40:06 +08: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 14:44:55 +08:00
|
|
|
EXPORT_SYMBOL_GPL(oops_begin);
|
2014-04-17 16:18:14 +08:00
|
|
|
NOKPROBE_SYMBOL(oops_begin);
|
2008-10-23 22:40:06 +08:00
|
|
|
|
2016-07-15 04:22:55 +08:00
|
|
|
void __noreturn rewind_stack_do_exit(int signr);
|
|
|
|
|
|
2014-04-17 16:18:14 +08:00
|
|
|
void oops_end(unsigned long flags, struct pt_regs *regs, int signr)
|
2008-10-23 22:40:06 +08:00
|
|
|
{
|
|
|
|
|
if (regs && kexec_should_crash(current))
|
|
|
|
|
crash_kexec(regs);
|
|
|
|
|
|
|
|
|
|
bust_spinlocks(0);
|
|
|
|
|
die_owner = -1;
|
2013-01-21 14:47:39 +08:00
|
|
|
add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
|
2008-10-23 22:40:06 +08:00
|
|
|
die_nest_count--;
|
|
|
|
|
if (!die_nest_count)
|
|
|
|
|
/* Nest count reaches zero, release the lock. */
|
2009-12-03 03:01:25 +08:00
|
|
|
arch_spin_unlock(&die_lock);
|
2008-10-23 22:40:06 +08: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");
|
2016-07-15 04:22:55 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We're not going to return, but we might be on an IST stack or
|
|
|
|
|
* have very little stack space left. Rewind the stack and kill
|
|
|
|
|
* the task.
|
|
|
|
|
*/
|
|
|
|
|
rewind_stack_do_exit(signr);
|
2008-10-23 22:40:06 +08:00
|
|
|
}
|
2014-04-17 16:18:14 +08:00
|
|
|
NOKPROBE_SYMBOL(oops_end);
|
2008-10-23 22:40:06 +08:00
|
|
|
|
2014-04-17 16:18:14 +08:00
|
|
|
int __die(const char *str, struct pt_regs *regs, long err)
|
2008-10-23 22:40:06 +08:00
|
|
|
{
|
|
|
|
|
#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 21:55:34 +08:00
|
|
|
printk(KERN_DEFAULT
|
2017-12-20 05:33:46 +08:00
|
|
|
"%s: %04lx [#%d]%s%s%s%s%s\n", str, err & 0xffff, ++die_counter,
|
2016-03-27 04:40:16 +08:00
|
|
|
IS_ENABLED(CONFIG_PREEMPT) ? " PREEMPT" : "",
|
|
|
|
|
IS_ENABLED(CONFIG_SMP) ? " SMP" : "",
|
|
|
|
|
debug_pagealloc_enabled() ? " DEBUG_PAGEALLOC" : "",
|
2017-12-20 05:33:46 +08:00
|
|
|
IS_ENABLED(CONFIG_KASAN) ? " KASAN" : "",
|
|
|
|
|
IS_ENABLED(CONFIG_PAGE_TABLE_ISOLATION) ?
|
|
|
|
|
(boot_cpu_has(X86_FEATURE_PTI) ? " PTI" : " NOPTI") : "");
|
2016-03-27 04:40:16 +08:00
|
|
|
|
2008-10-23 22:40:06 +08:00
|
|
|
if (notify_die(DIE_OOPS, str, regs, err,
|
2012-03-12 17:25:55 +08:00
|
|
|
current->thread.trap_nr, SIGSEGV) == NOTIFY_STOP)
|
2008-10-23 22:40:06 +08:00
|
|
|
return 1;
|
|
|
|
|
|
2012-06-18 18:40:04 +08:00
|
|
|
print_modules();
|
2012-05-09 15:47:37 +08:00
|
|
|
show_regs(regs);
|
2008-10-23 22:40:06 +08:00
|
|
|
#ifdef CONFIG_X86_32
|
2015-03-19 09:33:33 +08:00
|
|
|
if (user_mode(regs)) {
|
2008-10-23 22:40:06 +08:00
|
|
|
sp = regs->sp;
|
2017-07-28 21:00:32 +08:00
|
|
|
ss = regs->ss;
|
2009-10-13 05:11:09 +08:00
|
|
|
} else {
|
|
|
|
|
sp = kernel_stack_pointer(regs);
|
|
|
|
|
savesegment(ss, ss);
|
2008-10-23 22:40:06 +08:00
|
|
|
}
|
2016-10-25 22:51:12 +08:00
|
|
|
printk(KERN_EMERG "EIP: %pS SS:ESP: %04x:%08lx\n",
|
|
|
|
|
(void *)regs->ip, ss, sp);
|
2008-10-23 22:40:06 +08:00
|
|
|
#else
|
|
|
|
|
/* Executive summary in case the oops scrolled away */
|
2016-10-25 22:51:12 +08:00
|
|
|
printk(KERN_ALERT "RIP: %pS RSP: %016lx\n", (void *)regs->ip, regs->sp);
|
2008-10-23 22:40:06 +08:00
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2014-04-17 16:18:14 +08:00
|
|
|
NOKPROBE_SYMBOL(__die);
|
2008-10-23 22:40:06 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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 (__die(str, regs, err))
|
|
|
|
|
sig = 0;
|
|
|
|
|
oops_end(flags, regs, sig);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init code_bytes_setup(char *s)
|
|
|
|
|
{
|
2012-05-07 01:58:04 +08:00
|
|
|
ssize_t ret;
|
|
|
|
|
unsigned long val;
|
|
|
|
|
|
|
|
|
|
if (!s)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
ret = kstrtoul(s, 0, &val);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
code_bytes = val;
|
2008-10-23 22:40:06 +08:00
|
|
|
if (code_bytes > 8192)
|
|
|
|
|
code_bytes = 8192;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
__setup("code_bytes=", code_bytes_setup);
|
2018-03-06 17:49:14 +08:00
|
|
|
|
|
|
|
|
void show_regs(struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
bool all = true;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
show_regs_print_info(KERN_DEFAULT);
|
|
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_X86_32))
|
|
|
|
|
all = !user_mode(regs);
|
|
|
|
|
|
|
|
|
|
__show_regs(regs, all);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* When in-kernel, we also print out the stack and code at the
|
|
|
|
|
* time of the fault..
|
|
|
|
|
*/
|
|
|
|
|
if (!user_mode(regs)) {
|
|
|
|
|
unsigned int code_prologue = code_bytes * 43 / 64;
|
|
|
|
|
unsigned int code_len = code_bytes;
|
|
|
|
|
unsigned char c;
|
|
|
|
|
u8 *ip;
|
|
|
|
|
|
|
|
|
|
show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT);
|
|
|
|
|
|
|
|
|
|
printk(KERN_DEFAULT "Code: ");
|
|
|
|
|
|
|
|
|
|
ip = (u8 *)regs->ip - code_prologue;
|
|
|
|
|
if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
|
|
|
|
|
/* try starting at IP */
|
|
|
|
|
ip = (u8 *)regs->ip;
|
|
|
|
|
code_len = code_len - code_prologue + 1;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < code_len; i++, ip++) {
|
|
|
|
|
if (ip < (u8 *)PAGE_OFFSET ||
|
|
|
|
|
probe_kernel_address(ip, c)) {
|
|
|
|
|
pr_cont(" Bad RIP value.");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (ip == (u8 *)regs->ip)
|
|
|
|
|
pr_cont("<%02x> ", c);
|
|
|
|
|
else
|
|
|
|
|
pr_cont("%02x ", c);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
pr_cont("\n");
|
|
|
|
|
}
|