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