arch/x86/kernel/dumpstack_32.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/hardirq.h>
   9 #include <linux/kdebug.h>
  10 #include <linux/export.h>
  11 #include <linux/ptrace.h>
  12 #include <linux/kexec.h>
  13 #include <linux/sysfs.h>
  14 #include <linux/bug.h>
  15 #include <linux/nmi.h>
  16
  17 #include <asm/stacktrace.h>
  18
  19 void stack_type_str(enum stack_type type, const char **begin, const char **end)
  20 {
  21         switch (type) {
  22         case STACK_TYPE_IRQ:
  23         case STACK_TYPE_SOFTIRQ:
  24                 *begin = "IRQ";
  25                 *end   = "EOI";
  26                 break;
  27         default:
  28                 *begin = NULL;
  29                 *end   = NULL;
  30         }
  31 }
  32
  33 static bool in_hardirq_stack(unsigned long *stack, struct stack_info *info)
  34 {
  35         unsigned long *begin = (unsigned long *)this_cpu_read(hardirq_stack);
  36         unsigned long *end   = begin + (THREAD_SIZE / sizeof(long));
  37
  38         /*
  39          * This is a software stack, so 'end' can be a valid stack pointer.
  40          * It just means the stack is empty.
  41          */
  42         if (stack < begin || stack > end)
  43                 return false;
  44
  45         info->type      = STACK_TYPE_IRQ;
  46         info->begin     = begin;
  47         info->end       = end;
  48
  49         /*
  50          * See irq_32.c -- the next stack pointer is stored at the beginning of
  51          * the stack.
  52          */
  53         info->next_sp   = (unsigned long *)*begin;
  54
  55         return true;
  56 }
  57
  58 static bool in_softirq_stack(unsigned long *stack, struct stack_info *info)
  59 {
  60         unsigned long *begin = (unsigned long *)this_cpu_read(softirq_stack);
  61         unsigned long *end   = begin + (THREAD_SIZE / sizeof(long));
  62
  63         /*
  64          * This is a software stack, so 'end' can be a valid stack pointer.
  65          * It just means the stack is empty.
  66          */
  67         if (stack < begin || stack > end)
  68                 return false;
  69
  70         info->type      = STACK_TYPE_SOFTIRQ;
  71         info->begin     = begin;
  72         info->end       = end;
  73
  74         /*
  75          * The next stack pointer is stored at the beginning of the stack.
  76          * See irq_32.c.
  77          */
  78         info->next_sp   = (unsigned long *)*begin;
  79
  80         return true;
  81 }
  82
  83 int get_stack_info(unsigned long *stack, struct task_struct *task,
  84                    struct stack_info *info, unsigned long *visit_mask)
  85 {
  86         if (!stack)
  87                 goto unknown;
  88
  89         task = task ? : current;
  90
  91         if (in_task_stack(stack, task, info))
  92                 goto recursion_check;
  93
  94         if (task != current)
  95                 goto unknown;
  96
  97         if (in_hardirq_stack(stack, info))
  98                 goto recursion_check;
  99
 100         if (in_softirq_stack(stack, info))
 101                 goto recursion_check;
 102
 103         goto unknown;
 104
 105 recursion_check:
 106         /*
 107          * Make sure we don't iterate through any given stack more than once.
 108          * If it comes up a second time then there's something wrong going on:
 109          * just break out and report an unknown stack type.
 110          */
 111         if (visit_mask) {
 112                 if (*visit_mask & (1UL << info->type))
 113                         goto unknown;
 114                 *visit_mask |= 1UL << info->type;
 115         }
 116
 117         return 0;
 118
 119 unknown:
 120         info->type = STACK_TYPE_UNKNOWN;
 121         return -EINVAL;
 122 }
 123
 124 void show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,
 125                         unsigned long *sp, char *log_lvl)
 126 {
 127         unsigned long *stack;
 128         int i;
 129
 130         if (!try_get_task_stack(task))
 131                 return;
 132
 133         sp = sp ? : get_stack_pointer(task, regs);
 134
 135         stack = sp;
 136         for (i = 0; i < kstack_depth_to_print; i++) {
 137                 if (kstack_end(stack))
 138                         break;
 139                 if ((i % STACKSLOTS_PER_LINE) == 0) {
 140                         if (i != 0)
 141                                 pr_cont("\n");
 142                         printk("%s %08lx", log_lvl, *stack++);
 143                 } else
 144                         pr_cont(" %08lx", *stack++);
 145                 touch_nmi_watchdog();
 146         }
 147         pr_cont("\n");
 148         show_trace_log_lvl(task, regs, sp, log_lvl);
 149
 150         put_task_stack(task);
 151 }
 152
 153
 154 void show_regs(struct pt_regs *regs)
 155 {
 156         int i;
 157
 158         show_regs_print_info(KERN_EMERG);
 159         __show_regs(regs, !user_mode(regs));
 160
 161         /*
 162          * When in-kernel, we also print out the stack and code at the
 163          * time of the fault..
 164          */
 165         if (!user_mode(regs)) {
 166                 unsigned int code_prologue = code_bytes * 43 / 64;
 167                 unsigned int code_len = code_bytes;
 168                 unsigned char c;
 169                 u8 *ip;
 170
 171                 pr_emerg("Stack:\n");
 172                 show_stack_log_lvl(current, regs, NULL, KERN_EMERG);
 173
 174                 pr_emerg("Code:");
 175
 176                 ip = (u8 *)regs->ip - code_prologue;
 177                 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
 178                         /* try starting at IP */
 179                         ip = (u8 *)regs->ip;
 180                         code_len = code_len - code_prologue + 1;
 181                 }
 182                 for (i = 0; i < code_len; i++, ip++) {
 183                         if (ip < (u8 *)PAGE_OFFSET ||
 184                                         probe_kernel_address(ip, c)) {
 185                                 pr_cont("  Bad EIP value.");
 186                                 break;
 187                         }
 188                         if (ip == (u8 *)regs->ip)
 189                                 pr_cont(" <%02x>", c);
 190                         else
 191                                 pr_cont(" %02x", c);
 192                 }
 193         }
 194         pr_cont("\n");
 195 }
 196
 197 int is_valid_bugaddr(unsigned long ip)
 198 {
 199         unsigned short ud2;
 200
 201         if (ip < PAGE_OFFSET)
 202                 return 0;
 203         if (probe_kernel_address((unsigned short *)ip, ud2))
 204                 return 0;
 205
 206         return ud2 == 0x0b0f;
 207 }