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