2 * Copyright (C) 1991, 1992 Linus Torvalds
3 * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
5 #include <linux/kallsyms.h>
6 #include <linux/kprobes.h>
7 #include <linux/uaccess.h>
8 #include <linux/hardirq.h>
9 #include <linux/kdebug.h>
10 #include <linux/export.h>
11 #include <linux/ptrace.h>
12 #include <linux/kexec.h>
13 #include <linux/sysfs.h>
14 #include <linux/bug.h>
15 #include <linux/nmi.h>
17 #include <asm/stacktrace.h>
19 static char *exception_stack_names[N_EXCEPTION_STACKS] = {
20 [ DOUBLEFAULT_STACK-1 ] = "#DF",
21 [ NMI_STACK-1 ] = "NMI",
22 [ DEBUG_STACK-1 ] = "#DB",
23 [ MCE_STACK-1 ] = "#MC",
26 static unsigned long exception_stack_sizes[N_EXCEPTION_STACKS] = {
27 [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STKSZ,
28 [DEBUG_STACK - 1] = DEBUG_STKSZ
31 const char *stack_type_name(enum stack_type type)
33 BUILD_BUG_ON(N_EXCEPTION_STACKS != 4);
35 if (type == STACK_TYPE_IRQ)
38 if (type >= STACK_TYPE_EXCEPTION && type <= STACK_TYPE_EXCEPTION_LAST)
39 return exception_stack_names[type - STACK_TYPE_EXCEPTION];
44 static bool in_exception_stack(unsigned long *stack, struct stack_info *info)
46 unsigned long *begin, *end;
50 BUILD_BUG_ON(N_EXCEPTION_STACKS != 4);
52 for (k = 0; k < N_EXCEPTION_STACKS; k++) {
53 end = (unsigned long *)raw_cpu_ptr(&orig_ist)->ist[k];
54 begin = end - (exception_stack_sizes[k] / sizeof(long));
55 regs = (struct pt_regs *)end - 1;
57 if (stack < begin || stack >= end)
60 info->type = STACK_TYPE_EXCEPTION + k;
63 info->next_sp = (unsigned long *)regs->sp;
71 static bool in_irq_stack(unsigned long *stack, struct stack_info *info)
73 unsigned long *end = (unsigned long *)this_cpu_read(irq_stack_ptr);
74 unsigned long *begin = end - (IRQ_STACK_SIZE / sizeof(long));
77 * This is a software stack, so 'end' can be a valid stack pointer.
78 * It just means the stack is empty.
80 if (stack < begin || stack > end)
83 info->type = STACK_TYPE_IRQ;
88 * The next stack pointer is the first thing pushed by the entry code
89 * after switching to the irq stack.
91 info->next_sp = (unsigned long *)*(end - 1);
96 int get_stack_info(unsigned long *stack, struct task_struct *task,
97 struct stack_info *info, unsigned long *visit_mask)
102 task = task ? : current;
104 if (in_task_stack(stack, task, info))
105 goto recursion_check;
110 if (in_exception_stack(stack, info))
111 goto recursion_check;
113 if (in_irq_stack(stack, info))
114 goto recursion_check;
120 * Make sure we don't iterate through any given stack more than once.
121 * If it comes up a second time then there's something wrong going on:
122 * just break out and report an unknown stack type.
125 if (*visit_mask & (1UL << info->type)) {
126 printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type);
129 *visit_mask |= 1UL << info->type;
135 info->type = STACK_TYPE_UNKNOWN;
139 void show_regs(struct pt_regs *regs)
143 show_regs_print_info(KERN_DEFAULT);
144 __show_regs(regs, 1);
147 * When in-kernel, we also print out the stack and code at the
148 * time of the fault..
150 if (!user_mode(regs)) {
151 unsigned int code_prologue = code_bytes * 43 / 64;
152 unsigned int code_len = code_bytes;
156 show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT);
158 printk(KERN_DEFAULT "Code: ");
160 ip = (u8 *)regs->ip - code_prologue;
161 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
162 /* try starting at IP */
164 code_len = code_len - code_prologue + 1;
166 for (i = 0; i < code_len; i++, ip++) {
167 if (ip < (u8 *)PAGE_OFFSET ||
168 probe_kernel_address(ip, c)) {
169 pr_cont(" Bad RIP value.");
172 if (ip == (u8 *)regs->ip)
173 pr_cont("<%02x> ", c);
181 int is_valid_bugaddr(unsigned long ip)
185 if (__copy_from_user(&ud2, (const void __user *) ip, sizeof(ud2)))
188 return ud2 == 0x0b0f;