Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
6fcbede3 AH |
2 | /* |
3 | * Copyright (C) 1991, 1992 Linus Torvalds | |
4 | * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs | |
5 | */ | |
b17b0153 | 6 | #include <linux/sched/debug.h> |
6fcbede3 AH |
7 | #include <linux/kallsyms.h> |
8 | #include <linux/kprobes.h> | |
9 | #include <linux/uaccess.h> | |
6fcbede3 AH |
10 | #include <linux/hardirq.h> |
11 | #include <linux/kdebug.h> | |
186f4360 | 12 | #include <linux/export.h> |
6fcbede3 AH |
13 | #include <linux/ptrace.h> |
14 | #include <linux/kexec.h> | |
b8030906 | 15 | #include <linux/sysfs.h> |
6fcbede3 AH |
16 | #include <linux/bug.h> |
17 | #include <linux/nmi.h> | |
18 | ||
19 | #include <asm/stacktrace.h> | |
20 | ||
9c003907 JP |
21 | static char *exception_stack_names[N_EXCEPTION_STACKS] = { |
22 | [ DOUBLEFAULT_STACK-1 ] = "#DF", | |
23 | [ NMI_STACK-1 ] = "NMI", | |
24 | [ DEBUG_STACK-1 ] = "#DB", | |
25 | [ MCE_STACK-1 ] = "#MC", | |
26 | }; | |
6fcbede3 | 27 | |
9c003907 JP |
28 | static unsigned long exception_stack_sizes[N_EXCEPTION_STACKS] = { |
29 | [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STKSZ, | |
30 | [DEBUG_STACK - 1] = DEBUG_STKSZ | |
b8030906 | 31 | }; |
0406ca6d | 32 | |
3d02a9c4 | 33 | const char *stack_type_name(enum stack_type type) |
0406ca6d | 34 | { |
cb76c939 JP |
35 | BUILD_BUG_ON(N_EXCEPTION_STACKS != 4); |
36 | ||
3d02a9c4 JP |
37 | if (type == STACK_TYPE_IRQ) |
38 | return "IRQ"; | |
39 | ||
4fe2d8b1 DH |
40 | if (type == STACK_TYPE_ENTRY) { |
41 | /* | |
42 | * On 64-bit, we have a generic entry stack that we | |
43 | * use for all the kernel entry points, including | |
44 | * SYSENTER. | |
45 | */ | |
46 | return "ENTRY_TRAMPOLINE"; | |
47 | } | |
33a2f1a6 | 48 | |
3d02a9c4 JP |
49 | if (type >= STACK_TYPE_EXCEPTION && type <= STACK_TYPE_EXCEPTION_LAST) |
50 | return exception_stack_names[type - STACK_TYPE_EXCEPTION]; | |
51 | ||
52 | return NULL; | |
cb76c939 JP |
53 | } |
54 | ||
fcd709ef | 55 | static bool in_exception_stack(unsigned long *stack, struct stack_info *info) |
cb76c939 JP |
56 | { |
57 | unsigned long *begin, *end; | |
58 | struct pt_regs *regs; | |
6fcbede3 AH |
59 | unsigned k; |
60 | ||
9c003907 JP |
61 | BUILD_BUG_ON(N_EXCEPTION_STACKS != 4); |
62 | ||
6fcbede3 | 63 | for (k = 0; k < N_EXCEPTION_STACKS; k++) { |
cb76c939 JP |
64 | end = (unsigned long *)raw_cpu_ptr(&orig_ist)->ist[k]; |
65 | begin = end - (exception_stack_sizes[k] / sizeof(long)); | |
66 | regs = (struct pt_regs *)end - 1; | |
9c003907 | 67 | |
5a3cf869 | 68 | if (stack <= begin || stack >= end) |
6fcbede3 | 69 | continue; |
9c003907 | 70 | |
cb76c939 JP |
71 | info->type = STACK_TYPE_EXCEPTION + k; |
72 | info->begin = begin; | |
73 | info->end = end; | |
74 | info->next_sp = (unsigned long *)regs->sp; | |
75 | ||
76 | return true; | |
6fcbede3 | 77 | } |
9c003907 | 78 | |
cb76c939 | 79 | return false; |
6fcbede3 AH |
80 | } |
81 | ||
cb76c939 | 82 | static bool in_irq_stack(unsigned long *stack, struct stack_info *info) |
af2d8289 | 83 | { |
cb76c939 JP |
84 | unsigned long *end = (unsigned long *)this_cpu_read(irq_stack_ptr); |
85 | unsigned long *begin = end - (IRQ_STACK_SIZE / sizeof(long)); | |
af2d8289 | 86 | |
5fe599e0 JP |
87 | /* |
88 | * This is a software stack, so 'end' can be a valid stack pointer. | |
89 | * It just means the stack is empty. | |
90 | */ | |
5a3cf869 | 91 | if (stack <= begin || stack > end) |
cb76c939 | 92 | return false; |
2223f6f6 | 93 | |
cb76c939 JP |
94 | info->type = STACK_TYPE_IRQ; |
95 | info->begin = begin; | |
96 | info->end = end; | |
97 | ||
98 | /* | |
99 | * The next stack pointer is the first thing pushed by the entry code | |
100 | * after switching to the irq stack. | |
101 | */ | |
102 | info->next_sp = (unsigned long *)*(end - 1); | |
103 | ||
104 | return true; | |
105 | } | |
106 | ||
107 | int get_stack_info(unsigned long *stack, struct task_struct *task, | |
108 | struct stack_info *info, unsigned long *visit_mask) | |
2223f6f6 | 109 | { |
cb76c939 JP |
110 | if (!stack) |
111 | goto unknown; | |
112 | ||
113 | task = task ? : current; | |
2223f6f6 | 114 | |
cb76c939 | 115 | if (in_task_stack(stack, task, info)) |
fcd709ef | 116 | goto recursion_check; |
2223f6f6 | 117 | |
cb76c939 JP |
118 | if (task != current) |
119 | goto unknown; | |
2223f6f6 | 120 | |
fcd709ef JP |
121 | if (in_exception_stack(stack, info)) |
122 | goto recursion_check; | |
2223f6f6 | 123 | |
cb76c939 | 124 | if (in_irq_stack(stack, info)) |
fcd709ef JP |
125 | goto recursion_check; |
126 | ||
4fe2d8b1 | 127 | if (in_entry_stack(stack, info)) |
33a2f1a6 AL |
128 | goto recursion_check; |
129 | ||
fcd709ef JP |
130 | goto unknown; |
131 | ||
132 | recursion_check: | |
133 | /* | |
134 | * Make sure we don't iterate through any given stack more than once. | |
135 | * If it comes up a second time then there's something wrong going on: | |
136 | * just break out and report an unknown stack type. | |
137 | */ | |
138 | if (visit_mask) { | |
0d2b8579 JP |
139 | if (*visit_mask & (1UL << info->type)) { |
140 | printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type); | |
fcd709ef | 141 | goto unknown; |
0d2b8579 | 142 | } |
fcd709ef JP |
143 | *visit_mask |= 1UL << info->type; |
144 | } | |
2223f6f6 | 145 | |
cb76c939 | 146 | return 0; |
2223f6f6 | 147 | |
cb76c939 JP |
148 | unknown: |
149 | info->type = STACK_TYPE_UNKNOWN; | |
150 | return -EINVAL; | |
2223f6f6 SR |
151 | } |
152 | ||
57da8b96 | 153 | void show_regs(struct pt_regs *regs) |
6fcbede3 AH |
154 | { |
155 | int i; | |
6fcbede3 | 156 | |
a43cb95d | 157 | show_regs_print_info(KERN_DEFAULT); |
6fcbede3 | 158 | __show_regs(regs, 1); |
6fcbede3 AH |
159 | |
160 | /* | |
161 | * When in-kernel, we also print out the stack and code at the | |
162 | * time of the fault.. | |
163 | */ | |
164 | if (!user_mode(regs)) { | |
165 | unsigned int code_prologue = code_bytes * 43 / 64; | |
166 | unsigned int code_len = code_bytes; | |
167 | unsigned char c; | |
168 | u8 *ip; | |
169 | ||
0ee1dd9f | 170 | show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT); |
6fcbede3 | 171 | |
b0f4c4b3 | 172 | printk(KERN_DEFAULT "Code: "); |
6fcbede3 AH |
173 | |
174 | ip = (u8 *)regs->ip - code_prologue; | |
175 | if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) { | |
8a541665 | 176 | /* try starting at IP */ |
6fcbede3 AH |
177 | ip = (u8 *)regs->ip; |
178 | code_len = code_len - code_prologue + 1; | |
179 | } | |
180 | for (i = 0; i < code_len; i++, ip++) { | |
181 | if (ip < (u8 *)PAGE_OFFSET || | |
182 | probe_kernel_address(ip, c)) { | |
c767a54b | 183 | pr_cont(" Bad RIP value."); |
6fcbede3 AH |
184 | break; |
185 | } | |
186 | if (ip == (u8 *)regs->ip) | |
c767a54b | 187 | pr_cont("<%02x> ", c); |
6fcbede3 | 188 | else |
c767a54b | 189 | pr_cont("%02x ", c); |
6fcbede3 AH |
190 | } |
191 | } | |
c767a54b | 192 | pr_cont("\n"); |
6fcbede3 | 193 | } |