dumpstack_64.c revision 161827903bdc124655f4cd976b9f0a5ac6ebf21c
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 19int panic_on_unrecovered_nmi; 20int kstack_depth_to_print = 12; 21static unsigned int code_bytes = 64; 22static int die_counter; 23 24void printk_address(unsigned long address, int reliable) 25{ 26 printk(" [<%p>] %s%pS\n", (void *) address, 27 reliable ? "" : "? ", (void *) address); 28} 29 30static 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 112static 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 */ 126struct stack_frame { 127 struct stack_frame *next_frame; 128 unsigned long return_address; 129}; 130 131static inline unsigned long 132print_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 157void 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} 245EXPORT_SYMBOL(dump_trace); 246 247static void 248print_trace_warning_symbol(void *data, char *msg, unsigned long symbol) 249{ 250 print_symbol(msg, symbol); 251 printk("\n"); 252} 253 254static void print_trace_warning(void *data, char *msg) 255{ 256 printk("%s\n", msg); 257} 258 259static int print_trace_stack(void *data, char *name) 260{ 261 printk(" <%s> ", name); 262 return 0; 263} 264 265static void print_trace_address(void *data, unsigned long addr, int reliable) 266{ 267 touch_nmi_watchdog(); 268 printk_address(addr, reliable); 269} 270 271static 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 278static void 279show_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 286void 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 292static void 293show_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 336void 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 */ 344void 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} 361EXPORT_SYMBOL(dump_stack); 362 363void 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 413int 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 423static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED; 424static int die_owner = -1; 425static unsigned int die_nest_count; 426 427unsigned __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 450void __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 471int __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 499void 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 511notrace __kprobes void 512die_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 538static 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} 546early_param("oops", oops_setup); 547 548static 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} 555early_param("kstack", kstack_setup); 556 557static 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); 566