Commit | Line | Data |
---|---|---|
6fcbede3 AH |
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/kexec.h> | |
14 | #include <linux/bug.h> | |
15 | #include <linux/nmi.h> | |
16 | ||
17 | #include <asm/stacktrace.h> | |
18 | ||
8a541665 | 19 | #define STACKSLOTS_PER_LINE 4 |
6a2ae2d9 | 20 | #define get_bp(bp) asm("movq %%rbp, %0" : "=r" (bp) :) |
8a541665 | 21 | |
6fcbede3 | 22 | int panic_on_unrecovered_nmi; |
8a541665 | 23 | int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE; |
6fcbede3 AH |
24 | static unsigned int code_bytes = 64; |
25 | static int die_counter; | |
26 | ||
27 | void printk_address(unsigned long address, int reliable) | |
28 | { | |
16182790 AH |
29 | printk(" [<%p>] %s%pS\n", (void *) address, |
30 | reliable ? "" : "? ", (void *) address); | |
6fcbede3 AH |
31 | } |
32 | ||
33 | static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack, | |
34 | unsigned *usedp, char **idp) | |
35 | { | |
36 | static char ids[][8] = { | |
37 | [DEBUG_STACK - 1] = "#DB", | |
38 | [NMI_STACK - 1] = "NMI", | |
39 | [DOUBLEFAULT_STACK - 1] = "#DF", | |
40 | [STACKFAULT_STACK - 1] = "#SS", | |
41 | [MCE_STACK - 1] = "#MC", | |
42 | #if DEBUG_STKSZ > EXCEPTION_STKSZ | |
43 | [N_EXCEPTION_STACKS ... | |
44 | N_EXCEPTION_STACKS + DEBUG_STKSZ / EXCEPTION_STKSZ - 2] = "#DB[?]" | |
45 | #endif | |
46 | }; | |
47 | unsigned k; | |
48 | ||
49 | /* | |
50 | * Iterate over all exception stacks, and figure out whether | |
51 | * 'stack' is in one of them: | |
52 | */ | |
53 | for (k = 0; k < N_EXCEPTION_STACKS; k++) { | |
54 | unsigned long end = per_cpu(orig_ist, cpu).ist[k]; | |
55 | /* | |
56 | * Is 'stack' above this exception frame's end? | |
57 | * If yes then skip to the next frame. | |
58 | */ | |
59 | if (stack >= end) | |
60 | continue; | |
61 | /* | |
62 | * Is 'stack' above this exception frame's start address? | |
63 | * If yes then we found the right frame. | |
64 | */ | |
65 | if (stack >= end - EXCEPTION_STKSZ) { | |
66 | /* | |
67 | * Make sure we only iterate through an exception | |
68 | * stack once. If it comes up for the second time | |
69 | * then there's something wrong going on - just | |
70 | * break out and return NULL: | |
71 | */ | |
72 | if (*usedp & (1U << k)) | |
73 | break; | |
74 | *usedp |= 1U << k; | |
75 | *idp = ids[k]; | |
76 | return (unsigned long *)end; | |
77 | } | |
78 | /* | |
79 | * If this is a debug stack, and if it has a larger size than | |
80 | * the usual exception stacks, then 'stack' might still | |
81 | * be within the lower portion of the debug stack: | |
82 | */ | |
83 | #if DEBUG_STKSZ > EXCEPTION_STKSZ | |
84 | if (k == DEBUG_STACK - 1 && stack >= end - DEBUG_STKSZ) { | |
85 | unsigned j = N_EXCEPTION_STACKS - 1; | |
86 | ||
87 | /* | |
88 | * Black magic. A large debug stack is composed of | |
89 | * multiple exception stack entries, which we | |
90 | * iterate through now. Dont look: | |
91 | */ | |
92 | do { | |
93 | ++j; | |
94 | end -= EXCEPTION_STKSZ; | |
95 | ids[j][4] = '1' + (j - N_EXCEPTION_STACKS); | |
96 | } while (stack < end - EXCEPTION_STKSZ); | |
97 | if (*usedp & (1U << j)) | |
98 | break; | |
99 | *usedp |= 1U << j; | |
100 | *idp = ids[j]; | |
101 | return (unsigned long *)end; | |
102 | } | |
103 | #endif | |
104 | } | |
105 | return NULL; | |
106 | } | |
107 | ||
108 | /* | |
109 | * x86-64 can have up to three kernel stacks: | |
110 | * process stack | |
111 | * interrupt stack | |
112 | * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack | |
113 | */ | |
114 | ||
115 | static inline int valid_stack_ptr(struct thread_info *tinfo, | |
116 | void *p, unsigned int size, void *end) | |
117 | { | |
118 | void *t = tinfo; | |
119 | if (end) { | |
120 | if (p < end && p >= (end-THREAD_SIZE)) | |
121 | return 1; | |
122 | else | |
123 | return 0; | |
124 | } | |
125 | return p > t && p < t + THREAD_SIZE - size; | |
126 | } | |
127 | ||
128 | /* The form of the top of the frame on the stack */ | |
129 | struct stack_frame { | |
130 | struct stack_frame *next_frame; | |
131 | unsigned long return_address; | |
132 | }; | |
133 | ||
134 | static inline unsigned long | |
135 | print_context_stack(struct thread_info *tinfo, | |
136 | unsigned long *stack, unsigned long bp, | |
137 | const struct stacktrace_ops *ops, void *data, | |
138 | unsigned long *end) | |
139 | { | |
140 | struct stack_frame *frame = (struct stack_frame *)bp; | |
141 | ||
142 | while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) { | |
143 | unsigned long addr; | |
144 | ||
145 | addr = *stack; | |
146 | if (__kernel_text_address(addr)) { | |
3a18512d | 147 | if ((unsigned long) stack == bp + sizeof(long)) { |
6fcbede3 AH |
148 | ops->address(data, addr, 1); |
149 | frame = frame->next_frame; | |
150 | bp = (unsigned long) frame; | |
151 | } else { | |
152 | ops->address(data, addr, bp == 0); | |
153 | } | |
154 | } | |
155 | stack++; | |
156 | } | |
157 | return bp; | |
158 | } | |
159 | ||
160 | void dump_trace(struct task_struct *task, struct pt_regs *regs, | |
161 | unsigned long *stack, unsigned long bp, | |
162 | const struct stacktrace_ops *ops, void *data) | |
163 | { | |
164 | const unsigned cpu = get_cpu(); | |
165 | unsigned long *irqstack_end = (unsigned long *)cpu_pda(cpu)->irqstackptr; | |
166 | unsigned used = 0; | |
167 | struct thread_info *tinfo; | |
168 | ||
169 | if (!task) | |
170 | task = current; | |
171 | ||
172 | if (!stack) { | |
173 | unsigned long dummy; | |
174 | stack = &dummy; | |
175 | if (task && task != current) | |
176 | stack = (unsigned long *)task->thread.sp; | |
177 | } | |
178 | ||
179 | #ifdef CONFIG_FRAME_POINTER | |
180 | if (!bp) { | |
181 | if (task == current) { | |
182 | /* Grab bp right from our regs */ | |
8a541665 | 183 | get_bp(bp); |
6fcbede3 AH |
184 | } else { |
185 | /* bp is the last reg pushed by switch_to */ | |
186 | bp = *(unsigned long *) task->thread.sp; | |
187 | } | |
188 | } | |
189 | #endif | |
190 | ||
191 | /* | |
192 | * Print function call entries in all stacks, starting at the | |
193 | * current stack address. If the stacks consist of nested | |
194 | * exceptions | |
195 | */ | |
196 | tinfo = task_thread_info(task); | |
197 | for (;;) { | |
198 | char *id; | |
199 | unsigned long *estack_end; | |
200 | estack_end = in_exception_stack(cpu, (unsigned long)stack, | |
201 | &used, &id); | |
202 | ||
203 | if (estack_end) { | |
204 | if (ops->stack(data, id) < 0) | |
205 | break; | |
206 | ||
207 | bp = print_context_stack(tinfo, stack, bp, ops, | |
208 | data, estack_end); | |
209 | ops->stack(data, "<EOE>"); | |
210 | /* | |
211 | * We link to the next stack via the | |
212 | * second-to-last pointer (index -2 to end) in the | |
213 | * exception stack: | |
214 | */ | |
215 | stack = (unsigned long *) estack_end[-2]; | |
216 | continue; | |
217 | } | |
218 | if (irqstack_end) { | |
219 | unsigned long *irqstack; | |
220 | irqstack = irqstack_end - | |
221 | (IRQSTACKSIZE - 64) / sizeof(*irqstack); | |
222 | ||
223 | if (stack >= irqstack && stack < irqstack_end) { | |
224 | if (ops->stack(data, "IRQ") < 0) | |
225 | break; | |
226 | bp = print_context_stack(tinfo, stack, bp, | |
227 | ops, data, irqstack_end); | |
228 | /* | |
229 | * We link to the next stack (which would be | |
230 | * the process stack normally) the last | |
231 | * pointer (index -1 to end) in the IRQ stack: | |
232 | */ | |
233 | stack = (unsigned long *) (irqstack_end[-1]); | |
234 | irqstack_end = NULL; | |
235 | ops->stack(data, "EOI"); | |
236 | continue; | |
237 | } | |
238 | } | |
239 | break; | |
240 | } | |
241 | ||
242 | /* | |
243 | * This handles the process stack: | |
244 | */ | |
245 | bp = print_context_stack(tinfo, stack, bp, ops, data, NULL); | |
246 | put_cpu(); | |
247 | } | |
248 | EXPORT_SYMBOL(dump_trace); | |
249 | ||
250 | static void | |
251 | print_trace_warning_symbol(void *data, char *msg, unsigned long symbol) | |
252 | { | |
2ac53721 | 253 | printk(data); |
6fcbede3 AH |
254 | print_symbol(msg, symbol); |
255 | printk("\n"); | |
256 | } | |
257 | ||
258 | static void print_trace_warning(void *data, char *msg) | |
259 | { | |
2ac53721 | 260 | printk("%s%s\n", (char *)data, msg); |
6fcbede3 AH |
261 | } |
262 | ||
263 | static int print_trace_stack(void *data, char *name) | |
264 | { | |
2ac53721 | 265 | printk("%s <%s> ", (char *)data, name); |
6fcbede3 AH |
266 | return 0; |
267 | } | |
268 | ||
2ac53721 AH |
269 | /* |
270 | * Print one address/symbol entries per line. | |
271 | */ | |
6fcbede3 AH |
272 | static void print_trace_address(void *data, unsigned long addr, int reliable) |
273 | { | |
274 | touch_nmi_watchdog(); | |
2ac53721 | 275 | printk(data); |
6fcbede3 AH |
276 | printk_address(addr, reliable); |
277 | } | |
278 | ||
279 | static const struct stacktrace_ops print_trace_ops = { | |
280 | .warning = print_trace_warning, | |
281 | .warning_symbol = print_trace_warning_symbol, | |
282 | .stack = print_trace_stack, | |
283 | .address = print_trace_address, | |
284 | }; | |
285 | ||
286 | static void | |
287 | show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs, | |
288 | unsigned long *stack, unsigned long bp, char *log_lvl) | |
289 | { | |
ca0a8164 | 290 | printk("%sCall Trace:\n", log_lvl); |
6fcbede3 AH |
291 | dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl); |
292 | } | |
293 | ||
294 | void show_trace(struct task_struct *task, struct pt_regs *regs, | |
295 | unsigned long *stack, unsigned long bp) | |
296 | { | |
297 | show_trace_log_lvl(task, regs, stack, bp, ""); | |
298 | } | |
299 | ||
300 | static void | |
301 | show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs, | |
302 | unsigned long *sp, unsigned long bp, char *log_lvl) | |
303 | { | |
304 | unsigned long *stack; | |
305 | int i; | |
306 | const int cpu = smp_processor_id(); | |
307 | unsigned long *irqstack_end = | |
308 | (unsigned long *) (cpu_pda(cpu)->irqstackptr); | |
309 | unsigned long *irqstack = | |
310 | (unsigned long *) (cpu_pda(cpu)->irqstackptr - IRQSTACKSIZE); | |
311 | ||
312 | /* | |
313 | * debugging aid: "show_stack(NULL, NULL);" prints the | |
314 | * back trace for this cpu. | |
315 | */ | |
316 | ||
317 | if (sp == NULL) { | |
318 | if (task) | |
319 | sp = (unsigned long *)task->thread.sp; | |
320 | else | |
321 | sp = (unsigned long *)&sp; | |
322 | } | |
323 | ||
324 | stack = sp; | |
325 | for (i = 0; i < kstack_depth_to_print; i++) { | |
326 | if (stack >= irqstack && stack <= irqstack_end) { | |
327 | if (stack == irqstack_end) { | |
328 | stack = (unsigned long *) (irqstack_end[-1]); | |
329 | printk(" <EOI> "); | |
330 | } | |
331 | } else { | |
332 | if (((long) stack & (THREAD_SIZE-1)) == 0) | |
333 | break; | |
334 | } | |
8a541665 | 335 | if (i && ((i % STACKSLOTS_PER_LINE) == 0)) |
ca0a8164 | 336 | printk("\n%s", log_lvl); |
6fcbede3 AH |
337 | printk(" %016lx", *stack++); |
338 | touch_nmi_watchdog(); | |
339 | } | |
340 | printk("\n"); | |
341 | show_trace_log_lvl(task, regs, sp, bp, log_lvl); | |
342 | } | |
343 | ||
344 | void show_stack(struct task_struct *task, unsigned long *sp) | |
345 | { | |
346 | show_stack_log_lvl(task, NULL, sp, 0, ""); | |
347 | } | |
348 | ||
349 | /* | |
350 | * The architecture-independent dump_stack generator | |
351 | */ | |
352 | void dump_stack(void) | |
353 | { | |
354 | unsigned long bp = 0; | |
355 | unsigned long stack; | |
356 | ||
357 | #ifdef CONFIG_FRAME_POINTER | |
358 | if (!bp) | |
8a541665 | 359 | get_bp(bp); |
6fcbede3 AH |
360 | #endif |
361 | ||
362 | printk("Pid: %d, comm: %.20s %s %s %.*s\n", | |
363 | current->pid, current->comm, print_tainted(), | |
364 | init_utsname()->release, | |
365 | (int)strcspn(init_utsname()->version, " "), | |
366 | init_utsname()->version); | |
367 | show_trace(NULL, NULL, &stack, bp); | |
368 | } | |
369 | EXPORT_SYMBOL(dump_stack); | |
370 | ||
371 | void show_registers(struct pt_regs *regs) | |
372 | { | |
373 | int i; | |
374 | unsigned long sp; | |
375 | const int cpu = smp_processor_id(); | |
376 | struct task_struct *cur = cpu_pda(cpu)->pcurrent; | |
377 | ||
378 | sp = regs->sp; | |
379 | printk("CPU %d ", cpu); | |
380 | __show_regs(regs, 1); | |
381 | printk("Process %s (pid: %d, threadinfo %p, task %p)\n", | |
382 | cur->comm, cur->pid, task_thread_info(cur), cur); | |
383 | ||
384 | /* | |
385 | * When in-kernel, we also print out the stack and code at the | |
386 | * time of the fault.. | |
387 | */ | |
388 | if (!user_mode(regs)) { | |
389 | unsigned int code_prologue = code_bytes * 43 / 64; | |
390 | unsigned int code_len = code_bytes; | |
391 | unsigned char c; | |
392 | u8 *ip; | |
393 | ||
ca0a8164 | 394 | printk(KERN_EMERG "Stack:\n"); |
6fcbede3 | 395 | show_stack_log_lvl(NULL, regs, (unsigned long *)sp, |
ca0a8164 | 396 | regs->bp, KERN_EMERG); |
6fcbede3 AH |
397 | |
398 | printk(KERN_EMERG "Code: "); | |
399 | ||
400 | ip = (u8 *)regs->ip - code_prologue; | |
401 | if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) { | |
8a541665 | 402 | /* try starting at IP */ |
6fcbede3 AH |
403 | ip = (u8 *)regs->ip; |
404 | code_len = code_len - code_prologue + 1; | |
405 | } | |
406 | for (i = 0; i < code_len; i++, ip++) { | |
407 | if (ip < (u8 *)PAGE_OFFSET || | |
408 | probe_kernel_address(ip, c)) { | |
409 | printk(" Bad RIP value."); | |
410 | break; | |
411 | } | |
412 | if (ip == (u8 *)regs->ip) | |
413 | printk("<%02x> ", c); | |
414 | else | |
415 | printk("%02x ", c); | |
416 | } | |
417 | } | |
418 | printk("\n"); | |
419 | } | |
420 | ||
421 | int is_valid_bugaddr(unsigned long ip) | |
422 | { | |
423 | unsigned short ud2; | |
424 | ||
425 | if (__copy_from_user(&ud2, (const void __user *) ip, sizeof(ud2))) | |
426 | return 0; | |
427 | ||
428 | return ud2 == 0x0b0f; | |
429 | } | |
430 | ||
431 | static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED; | |
432 | static int die_owner = -1; | |
433 | static unsigned int die_nest_count; | |
434 | ||
435 | unsigned __kprobes long oops_begin(void) | |
436 | { | |
437 | int cpu; | |
438 | unsigned long flags; | |
439 | ||
440 | oops_enter(); | |
441 | ||
442 | /* racy, but better than risking deadlock. */ | |
443 | raw_local_irq_save(flags); | |
444 | cpu = smp_processor_id(); | |
445 | if (!__raw_spin_trylock(&die_lock)) { | |
446 | if (cpu == die_owner) | |
447 | /* nested oops. should stop eventually */; | |
448 | else | |
449 | __raw_spin_lock(&die_lock); | |
450 | } | |
451 | die_nest_count++; | |
452 | die_owner = cpu; | |
453 | console_verbose(); | |
454 | bust_spinlocks(1); | |
455 | return flags; | |
456 | } | |
457 | ||
458 | void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr) | |
459 | { | |
460 | die_owner = -1; | |
461 | bust_spinlocks(0); | |
462 | die_nest_count--; | |
463 | if (!die_nest_count) | |
464 | /* Nest count reaches zero, release the lock. */ | |
465 | __raw_spin_unlock(&die_lock); | |
466 | raw_local_irq_restore(flags); | |
467 | if (!regs) { | |
468 | oops_exit(); | |
469 | return; | |
470 | } | |
471 | if (in_interrupt()) | |
472 | panic("Fatal exception in interrupt"); | |
473 | if (panic_on_oops) | |
474 | panic("Fatal exception"); | |
475 | oops_exit(); | |
476 | do_exit(signr); | |
477 | } | |
478 | ||
479 | int __kprobes __die(const char *str, struct pt_regs *regs, long err) | |
480 | { | |
8a541665 | 481 | printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter); |
6fcbede3 AH |
482 | #ifdef CONFIG_PREEMPT |
483 | printk("PREEMPT "); | |
484 | #endif | |
485 | #ifdef CONFIG_SMP | |
486 | printk("SMP "); | |
487 | #endif | |
488 | #ifdef CONFIG_DEBUG_PAGEALLOC | |
489 | printk("DEBUG_PAGEALLOC"); | |
490 | #endif | |
491 | printk("\n"); | |
492 | if (notify_die(DIE_OOPS, str, regs, err, | |
493 | current->thread.trap_no, SIGSEGV) == NOTIFY_STOP) | |
494 | return 1; | |
495 | ||
496 | show_registers(regs); | |
497 | add_taint(TAINT_DIE); | |
498 | /* Executive summary in case the oops scrolled away */ | |
499 | printk(KERN_ALERT "RIP "); | |
500 | printk_address(regs->ip, 1); | |
501 | printk(" RSP <%016lx>\n", regs->sp); | |
502 | if (kexec_should_crash(current)) | |
503 | crash_kexec(regs); | |
504 | return 0; | |
505 | } | |
506 | ||
507 | void die(const char *str, struct pt_regs *regs, long err) | |
508 | { | |
509 | unsigned long flags = oops_begin(); | |
510 | ||
511 | if (!user_mode(regs)) | |
512 | report_bug(regs->ip, regs); | |
513 | ||
514 | if (__die(str, regs, err)) | |
515 | regs = NULL; | |
516 | oops_end(flags, regs, SIGSEGV); | |
517 | } | |
518 | ||
519 | notrace __kprobes void | |
520 | die_nmi(char *str, struct pt_regs *regs, int do_panic) | |
521 | { | |
522 | unsigned long flags; | |
523 | ||
524 | if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP) | |
525 | return; | |
526 | ||
527 | flags = oops_begin(); | |
528 | /* | |
529 | * We are in trouble anyway, lets at least try | |
530 | * to get a message out. | |
531 | */ | |
532 | printk(KERN_EMERG "%s", str); | |
533 | printk(" on CPU%d, ip %08lx, registers:\n", | |
534 | smp_processor_id(), regs->ip); | |
535 | show_registers(regs); | |
536 | if (kexec_should_crash(current)) | |
537 | crash_kexec(regs); | |
538 | if (do_panic || panic_on_oops) | |
539 | panic("Non maskable interrupt"); | |
540 | oops_end(flags, NULL, SIGBUS); | |
541 | nmi_exit(); | |
542 | local_irq_enable(); | |
543 | do_exit(SIGBUS); | |
544 | } | |
545 | ||
546 | static int __init oops_setup(char *s) | |
547 | { | |
548 | if (!s) | |
549 | return -EINVAL; | |
550 | if (!strcmp(s, "panic")) | |
551 | panic_on_oops = 1; | |
552 | return 0; | |
553 | } | |
554 | early_param("oops", oops_setup); | |
555 | ||
556 | static int __init kstack_setup(char *s) | |
557 | { | |
558 | if (!s) | |
559 | return -EINVAL; | |
560 | kstack_depth_to_print = simple_strtoul(s, NULL, 0); | |
561 | return 0; | |
562 | } | |
563 | early_param("kstack", kstack_setup); | |
564 | ||
565 | static int __init code_bytes_setup(char *s) | |
566 | { | |
567 | code_bytes = simple_strtoul(s, NULL, 0); | |
568 | if (code_bytes > 8192) | |
569 | code_bytes = 8192; | |
570 | ||
571 | return 1; | |
572 | } | |
573 | __setup("code_bytes=", code_bytes_setup); |