1 | /* |
2 | * Copyright (C) 1991, 1992 Linus Torvalds |
3 | * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs |
4 | */ |
5 | #include <linux/kallsyms.h> |
6 | #include <linux/kprobes.h> |
7 | #include <linux/uaccess.h> |
8 | #include <linux/utsname.h> |
9 | #include <linux/hardirq.h> |
10 | #include <linux/kdebug.h> |
11 | #include <linux/module.h> |
12 | #include <linux/ptrace.h> |
13 | #include <linux/sched/debug.h> |
14 | #include <linux/sched/task_stack.h> |
15 | #include <linux/ftrace.h> |
16 | #include <linux/kexec.h> |
17 | #include <linux/bug.h> |
18 | #include <linux/nmi.h> |
19 | #include <linux/sysfs.h> |
20 | #include <linux/kasan.h> |
21 | |
22 | #include <asm/cpu_entry_area.h> |
23 | #include <asm/stacktrace.h> |
24 | #include <asm/unwind.h> |
25 | |
26 | static int die_counter; |
27 | |
28 | static struct pt_regs exec_summary_regs; |
29 | |
30 | bool noinstr in_task_stack(unsigned long *stack, struct task_struct *task, |
31 | struct stack_info *info) |
32 | { |
33 | unsigned long *begin = task_stack_page(task); |
34 | unsigned long *end = task_stack_page(task) + THREAD_SIZE; |
35 | |
36 | if (stack < begin || stack >= end) |
37 | return false; |
38 | |
39 | info->type = STACK_TYPE_TASK; |
40 | info->begin = begin; |
41 | info->end = end; |
42 | info->next_sp = NULL; |
43 | |
44 | return true; |
45 | } |
46 | |
47 | /* Called from get_stack_info_noinstr - so must be noinstr too */ |
48 | bool noinstr in_entry_stack(unsigned long *stack, struct stack_info *info) |
49 | { |
50 | struct entry_stack *ss = cpu_entry_stack(smp_processor_id()); |
51 | |
52 | void *begin = ss; |
53 | void *end = ss + 1; |
54 | |
55 | if ((void *)stack < begin || (void *)stack >= end) |
56 | return false; |
57 | |
58 | info->type = STACK_TYPE_ENTRY; |
59 | info->begin = begin; |
60 | info->end = end; |
61 | info->next_sp = NULL; |
62 | |
63 | return true; |
64 | } |
65 | |
66 | static void printk_stack_address(unsigned long address, int reliable, |
67 | const char *log_lvl) |
68 | { |
69 | touch_nmi_watchdog(); |
70 | printk("%s %s%pBb\n" , log_lvl, reliable ? "" : "? " , (void *)address); |
71 | } |
72 | |
73 | static int copy_code(struct pt_regs *regs, u8 *buf, unsigned long src, |
74 | unsigned int nbytes) |
75 | { |
76 | if (!user_mode(regs)) |
77 | return copy_from_kernel_nofault(dst: buf, src: (u8 *)src, size: nbytes); |
78 | |
79 | /* The user space code from other tasks cannot be accessed. */ |
80 | if (regs != task_pt_regs(current)) |
81 | return -EPERM; |
82 | |
83 | /* |
84 | * Even if named copy_from_user_nmi() this can be invoked from |
85 | * other contexts and will not try to resolve a pagefault, which is |
86 | * the correct thing to do here as this code can be called from any |
87 | * context. |
88 | */ |
89 | return copy_from_user_nmi(to: buf, from: (void __user *)src, n: nbytes); |
90 | } |
91 | |
92 | /* |
93 | * There are a couple of reasons for the 2/3rd prologue, courtesy of Linus: |
94 | * |
95 | * In case where we don't have the exact kernel image (which, if we did, we can |
96 | * simply disassemble and navigate to the RIP), the purpose of the bigger |
97 | * prologue is to have more context and to be able to correlate the code from |
98 | * the different toolchains better. |
99 | * |
100 | * In addition, it helps in recreating the register allocation of the failing |
101 | * kernel and thus make sense of the register dump. |
102 | * |
103 | * What is more, the additional complication of a variable length insn arch like |
104 | * x86 warrants having longer byte sequence before rIP so that the disassembler |
105 | * can "sync" up properly and find instruction boundaries when decoding the |
106 | * opcode bytes. |
107 | * |
108 | * Thus, the 2/3rds prologue and 64 byte OPCODE_BUFSIZE is just a random |
109 | * guesstimate in attempt to achieve all of the above. |
110 | */ |
111 | void show_opcodes(struct pt_regs *regs, const char *loglvl) |
112 | { |
113 | #define PROLOGUE_SIZE 42 |
114 | #define EPILOGUE_SIZE 21 |
115 | #define OPCODE_BUFSIZE (PROLOGUE_SIZE + 1 + EPILOGUE_SIZE) |
116 | u8 opcodes[OPCODE_BUFSIZE]; |
117 | unsigned long prologue = regs->ip - PROLOGUE_SIZE; |
118 | |
119 | switch (copy_code(regs, buf: opcodes, src: prologue, nbytes: sizeof(opcodes))) { |
120 | case 0: |
121 | printk("%sCode: %" __stringify(PROLOGUE_SIZE) "ph <%02x> %" |
122 | __stringify(EPILOGUE_SIZE) "ph\n" , loglvl, opcodes, |
123 | opcodes[PROLOGUE_SIZE], opcodes + PROLOGUE_SIZE + 1); |
124 | break; |
125 | case -EPERM: |
126 | /* No access to the user space stack of other tasks. Ignore. */ |
127 | break; |
128 | default: |
129 | printk("%sCode: Unable to access opcode bytes at 0x%lx.\n" , |
130 | loglvl, prologue); |
131 | break; |
132 | } |
133 | } |
134 | |
135 | void show_ip(struct pt_regs *regs, const char *loglvl) |
136 | { |
137 | #ifdef CONFIG_X86_32 |
138 | printk("%sEIP: %pS\n" , loglvl, (void *)regs->ip); |
139 | #else |
140 | printk("%sRIP: %04x:%pS\n" , loglvl, (int)regs->cs, (void *)regs->ip); |
141 | #endif |
142 | show_opcodes(regs, loglvl); |
143 | } |
144 | |
145 | void show_iret_regs(struct pt_regs *regs, const char *log_lvl) |
146 | { |
147 | show_ip(regs, loglvl: log_lvl); |
148 | printk("%sRSP: %04x:%016lx EFLAGS: %08lx" , log_lvl, (int)regs->ss, |
149 | regs->sp, regs->flags); |
150 | } |
151 | |
152 | static void show_regs_if_on_stack(struct stack_info *info, struct pt_regs *regs, |
153 | bool partial, const char *log_lvl) |
154 | { |
155 | /* |
156 | * These on_stack() checks aren't strictly necessary: the unwind code |
157 | * has already validated the 'regs' pointer. The checks are done for |
158 | * ordering reasons: if the registers are on the next stack, we don't |
159 | * want to print them out yet. Otherwise they'll be shown as part of |
160 | * the wrong stack. Later, when show_trace_log_lvl() switches to the |
161 | * next stack, this function will be called again with the same regs so |
162 | * they can be printed in the right context. |
163 | */ |
164 | if (!partial && on_stack(info, addr: regs, len: sizeof(*regs))) { |
165 | __show_regs(regs, SHOW_REGS_SHORT, log_lvl); |
166 | |
167 | } else if (partial && on_stack(info, addr: (void *)regs + IRET_FRAME_OFFSET, |
168 | IRET_FRAME_SIZE)) { |
169 | /* |
170 | * When an interrupt or exception occurs in entry code, the |
171 | * full pt_regs might not have been saved yet. In that case |
172 | * just print the iret frame. |
173 | */ |
174 | show_iret_regs(regs, log_lvl); |
175 | } |
176 | } |
177 | |
178 | /* |
179 | * This function reads pointers from the stack and dereferences them. The |
180 | * pointers may not have their KMSAN shadow set up properly, which may result |
181 | * in false positive reports. Disable instrumentation to avoid those. |
182 | */ |
183 | __no_kmsan_checks |
184 | static void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs, |
185 | unsigned long *stack, const char *log_lvl) |
186 | { |
187 | struct unwind_state state; |
188 | struct stack_info stack_info = {0}; |
189 | unsigned long visit_mask = 0; |
190 | int graph_idx = 0; |
191 | bool partial = false; |
192 | |
193 | printk("%sCall Trace:\n" , log_lvl); |
194 | |
195 | unwind_start(state: &state, task, regs, first_frame: stack); |
196 | stack = stack ?: get_stack_pointer(task, regs); |
197 | regs = unwind_get_entry_regs(state: &state, partial: &partial); |
198 | |
199 | /* |
200 | * Iterate through the stacks, starting with the current stack pointer. |
201 | * Each stack has a pointer to the next one. |
202 | * |
203 | * x86-64 can have several stacks: |
204 | * - task stack |
205 | * - interrupt stack |
206 | * - HW exception stacks (double fault, nmi, debug, mce) |
207 | * - entry stack |
208 | * |
209 | * x86-32 can have up to four stacks: |
210 | * - task stack |
211 | * - softirq stack |
212 | * - hardirq stack |
213 | * - entry stack |
214 | */ |
215 | for (; stack; stack = stack_info.next_sp) { |
216 | const char *stack_name; |
217 | |
218 | stack = PTR_ALIGN(stack, sizeof(long)); |
219 | |
220 | if (get_stack_info(stack, task, info: &stack_info, visit_mask: &visit_mask)) { |
221 | /* |
222 | * We weren't on a valid stack. It's possible that |
223 | * we overflowed a valid stack into a guard page. |
224 | * See if the next page up is valid so that we can |
225 | * generate some kind of backtrace if this happens. |
226 | */ |
227 | stack = (unsigned long *)PAGE_ALIGN((unsigned long)stack); |
228 | if (get_stack_info(stack, task, info: &stack_info, visit_mask: &visit_mask)) |
229 | break; |
230 | } |
231 | |
232 | stack_name = stack_type_name(type: stack_info.type); |
233 | if (stack_name) |
234 | printk("%s <%s>\n" , log_lvl, stack_name); |
235 | |
236 | if (regs) |
237 | show_regs_if_on_stack(info: &stack_info, regs, partial, log_lvl); |
238 | |
239 | /* |
240 | * Scan the stack, printing any text addresses we find. At the |
241 | * same time, follow proper stack frames with the unwinder. |
242 | * |
243 | * Addresses found during the scan which are not reported by |
244 | * the unwinder are considered to be additional clues which are |
245 | * sometimes useful for debugging and are prefixed with '?'. |
246 | * This also serves as a failsafe option in case the unwinder |
247 | * goes off in the weeds. |
248 | */ |
249 | for (; stack < stack_info.end; stack++) { |
250 | unsigned long real_addr; |
251 | int reliable = 0; |
252 | unsigned long addr = READ_ONCE_NOCHECK(*stack); |
253 | unsigned long *ret_addr_p = |
254 | unwind_get_return_address_ptr(state: &state); |
255 | |
256 | if (!__kernel_text_address(addr)) |
257 | continue; |
258 | |
259 | /* |
260 | * Don't print regs->ip again if it was already printed |
261 | * by show_regs_if_on_stack(). |
262 | */ |
263 | if (regs && stack == ®s->ip) |
264 | goto next; |
265 | |
266 | if (stack == ret_addr_p) |
267 | reliable = 1; |
268 | |
269 | /* |
270 | * When function graph tracing is enabled for a |
271 | * function, its return address on the stack is |
272 | * replaced with the address of an ftrace handler |
273 | * (return_to_handler). In that case, before printing |
274 | * the "real" address, we want to print the handler |
275 | * address as an "unreliable" hint that function graph |
276 | * tracing was involved. |
277 | */ |
278 | real_addr = ftrace_graph_ret_addr(task, idx: &graph_idx, |
279 | ret: addr, retp: stack); |
280 | if (real_addr != addr) |
281 | printk_stack_address(address: addr, reliable: 0, log_lvl); |
282 | printk_stack_address(address: real_addr, reliable, log_lvl); |
283 | |
284 | if (!reliable) |
285 | continue; |
286 | |
287 | next: |
288 | /* |
289 | * Get the next frame from the unwinder. No need to |
290 | * check for an error: if anything goes wrong, the rest |
291 | * of the addresses will just be printed as unreliable. |
292 | */ |
293 | unwind_next_frame(state: &state); |
294 | |
295 | /* if the frame has entry regs, print them */ |
296 | regs = unwind_get_entry_regs(state: &state, partial: &partial); |
297 | if (regs) |
298 | show_regs_if_on_stack(info: &stack_info, regs, partial, log_lvl); |
299 | } |
300 | |
301 | if (stack_name) |
302 | printk("%s </%s>\n" , log_lvl, stack_name); |
303 | } |
304 | } |
305 | |
306 | void show_stack(struct task_struct *task, unsigned long *sp, |
307 | const char *loglvl) |
308 | { |
309 | task = task ? : current; |
310 | |
311 | /* |
312 | * Stack frames below this one aren't interesting. Don't show them |
313 | * if we're printing for %current. |
314 | */ |
315 | if (!sp && task == current) |
316 | sp = get_stack_pointer(current, NULL); |
317 | |
318 | show_trace_log_lvl(task, NULL, stack: sp, log_lvl: loglvl); |
319 | } |
320 | |
321 | void show_stack_regs(struct pt_regs *regs) |
322 | { |
323 | show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT); |
324 | } |
325 | |
326 | static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED; |
327 | static int die_owner = -1; |
328 | static unsigned int die_nest_count; |
329 | |
330 | unsigned long oops_begin(void) |
331 | { |
332 | int cpu; |
333 | unsigned long flags; |
334 | |
335 | oops_enter(); |
336 | |
337 | /* racy, but better than risking deadlock. */ |
338 | raw_local_irq_save(flags); |
339 | cpu = smp_processor_id(); |
340 | if (!arch_spin_trylock(&die_lock)) { |
341 | if (cpu == die_owner) |
342 | /* nested oops. should stop eventually */; |
343 | else |
344 | arch_spin_lock(&die_lock); |
345 | } |
346 | die_nest_count++; |
347 | die_owner = cpu; |
348 | console_verbose(); |
349 | bust_spinlocks(yes: 1); |
350 | return flags; |
351 | } |
352 | NOKPROBE_SYMBOL(oops_begin); |
353 | |
354 | void __noreturn rewind_stack_and_make_dead(int signr); |
355 | |
356 | void oops_end(unsigned long flags, struct pt_regs *regs, int signr) |
357 | { |
358 | if (regs && kexec_should_crash(current)) |
359 | crash_kexec(regs); |
360 | |
361 | bust_spinlocks(yes: 0); |
362 | die_owner = -1; |
363 | add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); |
364 | die_nest_count--; |
365 | if (!die_nest_count) |
366 | /* Nest count reaches zero, release the lock. */ |
367 | arch_spin_unlock(&die_lock); |
368 | raw_local_irq_restore(flags); |
369 | oops_exit(); |
370 | |
371 | /* Executive summary in case the oops scrolled away */ |
372 | __show_regs(regs: &exec_summary_regs, SHOW_REGS_ALL, KERN_DEFAULT); |
373 | |
374 | if (!signr) |
375 | return; |
376 | if (in_interrupt()) |
377 | panic(fmt: "Fatal exception in interrupt" ); |
378 | if (panic_on_oops) |
379 | panic(fmt: "Fatal exception" ); |
380 | |
381 | /* |
382 | * We're not going to return, but we might be on an IST stack or |
383 | * have very little stack space left. Rewind the stack and kill |
384 | * the task. |
385 | * Before we rewind the stack, we have to tell KASAN that we're going to |
386 | * reuse the task stack and that existing poisons are invalid. |
387 | */ |
388 | kasan_unpoison_task_stack(current); |
389 | rewind_stack_and_make_dead(signr); |
390 | } |
391 | NOKPROBE_SYMBOL(oops_end); |
392 | |
393 | static void (const char *str, struct pt_regs *regs, long err) |
394 | { |
395 | /* Save the regs of the first oops for the executive summary later. */ |
396 | if (!die_counter) |
397 | exec_summary_regs = *regs; |
398 | |
399 | printk(KERN_DEFAULT |
400 | "Oops: %s: %04lx [#%d]%s%s%s%s\n" , str, err & 0xffff, |
401 | ++die_counter, |
402 | IS_ENABLED(CONFIG_SMP) ? " SMP" : "" , |
403 | debug_pagealloc_enabled() ? " DEBUG_PAGEALLOC" : "" , |
404 | IS_ENABLED(CONFIG_KASAN) ? " KASAN" : "" , |
405 | IS_ENABLED(CONFIG_MITIGATION_PAGE_TABLE_ISOLATION) ? |
406 | (boot_cpu_has(X86_FEATURE_PTI) ? " PTI" : " NOPTI" ) : "" ); |
407 | } |
408 | NOKPROBE_SYMBOL(__die_header); |
409 | |
410 | static int __die_body(const char *str, struct pt_regs *regs, long err) |
411 | { |
412 | show_regs(regs); |
413 | print_modules(); |
414 | |
415 | if (notify_die(val: DIE_OOPS, str, regs, err, |
416 | current->thread.trap_nr, SIGSEGV) == NOTIFY_STOP) |
417 | return 1; |
418 | |
419 | return 0; |
420 | } |
421 | NOKPROBE_SYMBOL(__die_body); |
422 | |
423 | int __die(const char *str, struct pt_regs *regs, long err) |
424 | { |
425 | __die_header(str, regs, err); |
426 | return __die_body(str, regs, err); |
427 | } |
428 | NOKPROBE_SYMBOL(__die); |
429 | |
430 | /* |
431 | * This is gone through when something in the kernel has done something bad |
432 | * and is about to be terminated: |
433 | */ |
434 | void die(const char *str, struct pt_regs *regs, long err) |
435 | { |
436 | unsigned long flags = oops_begin(); |
437 | int sig = SIGSEGV; |
438 | |
439 | if (__die(str, regs, err)) |
440 | sig = 0; |
441 | oops_end(flags, regs, signr: sig); |
442 | } |
443 | |
444 | void die_addr(const char *str, struct pt_regs *regs, long err, long gp_addr) |
445 | { |
446 | unsigned long flags = oops_begin(); |
447 | int sig = SIGSEGV; |
448 | |
449 | __die_header(str, regs, err); |
450 | if (gp_addr) |
451 | kasan_non_canonical_hook(addr: gp_addr); |
452 | if (__die_body(str, regs, err)) |
453 | sig = 0; |
454 | oops_end(flags, regs, signr: sig); |
455 | } |
456 | |
457 | void show_regs(struct pt_regs *regs) |
458 | { |
459 | enum show_regs_mode print_kernel_regs; |
460 | |
461 | show_regs_print_info(KERN_DEFAULT); |
462 | |
463 | print_kernel_regs = user_mode(regs) ? SHOW_REGS_USER : SHOW_REGS_ALL; |
464 | __show_regs(regs, print_kernel_regs, KERN_DEFAULT); |
465 | |
466 | /* |
467 | * When in-kernel, we also print out the stack at the time of the fault.. |
468 | */ |
469 | if (!user_mode(regs)) |
470 | show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT); |
471 | } |
472 | |