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 dump_trace(struct task_struct *task, struct pt_regs *regs,
 125                 unsigned long *stack, unsigned long bp,
 126                 const struct stacktrace_ops *ops, void *data)
 127 {
 128         unsigned long visit_mask = 0;
 129         int graph = 0;
 130
 131         task = task ? : current;
 132         stack = stack ? : get_stack_pointer(task, regs);
 133         bp = bp ? : (unsigned long)get_frame_pointer(task, regs);
 134
 135         for (;;) {
 136                 const char *begin_str, *end_str;
 137                 struct stack_info info;
 138
 139                 if (get_stack_info(stack, task, &info, &visit_mask))
 140                         break;
 141
 142                 stack_type_str(info.type, &begin_str, &end_str);
 143
 144                 if (begin_str && ops->stack(data, begin_str) < 0)
 145                         break;
 146
 147                 bp = ops->walk_stack(task, stack, bp, ops, data, &info, &graph);
 148
 149                 if (end_str && ops->stack(data, end_str) < 0)
 150                         break;
 151
 152                 stack = info.next_sp;
 153
 154                 touch_nmi_watchdog();
 155         }
 156 }
 157 EXPORT_SYMBOL(dump_trace);
 158
 159 void show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,
 160                         unsigned long *sp, char *log_lvl)
 161 {
 162         unsigned long *stack;
 163         int i;
 164
 165         if (!try_get_task_stack(task))
 166                 return;
 167
 168         sp = sp ? : get_stack_pointer(task, regs);
 169
 170         stack = sp;
 171         for (i = 0; i < kstack_depth_to_print; i++) {
 172                 if (kstack_end(stack))
 173                         break;
 174                 if ((i % STACKSLOTS_PER_LINE) == 0) {
 175                         if (i != 0)
 176                                 pr_cont("\n");
 177                         printk("%s %08lx", log_lvl, *stack++);
 178                 } else
 179                         pr_cont(" %08lx", *stack++);
 180                 touch_nmi_watchdog();
 181         }
 182         pr_cont("\n");
 183         show_trace_log_lvl(task, regs, sp, log_lvl);
 184
 185         put_task_stack(task);
 186 }
 187
 188
 189 void show_regs(struct pt_regs *regs)
 190 {
 191         int i;
 192
 193         show_regs_print_info(KERN_EMERG);
 194         __show_regs(regs, !user_mode(regs));
 195
 196         /*
 197          * When in-kernel, we also print out the stack and code at the
 198          * time of the fault..
 199          */
 200         if (!user_mode(regs)) {
 201                 unsigned int code_prologue = code_bytes * 43 / 64;
 202                 unsigned int code_len = code_bytes;
 203                 unsigned char c;
 204                 u8 *ip;
 205
 206                 pr_emerg("Stack:\n");
 207                 show_stack_log_lvl(current, regs, NULL, KERN_EMERG);
 208
 209                 pr_emerg("Code:");
 210
 211                 ip = (u8 *)regs->ip - code_prologue;
 212                 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
 213                         /* try starting at IP */
 214                         ip = (u8 *)regs->ip;
 215                         code_len = code_len - code_prologue + 1;
 216                 }
 217                 for (i = 0; i < code_len; i++, ip++) {
 218                         if (ip < (u8 *)PAGE_OFFSET ||
 219                                         probe_kernel_address(ip, c)) {
 220                                 pr_cont("  Bad EIP value.");
 221                                 break;
 222                         }
 223                         if (ip == (u8 *)regs->ip)
 224                                 pr_cont(" <%02x>", c);
 225                         else
 226                                 pr_cont(" %02x", c);
 227                 }
 228         }
 229         pr_cont("\n");
 230 }
 231
 232 int is_valid_bugaddr(unsigned long ip)
 233 {
 234         unsigned short ud2;
 235
 236         if (ip < PAGE_OFFSET)
 237                 return 0;
 238         if (probe_kernel_address((unsigned short *)ip, ud2))
 239                 return 0;
 240
 241         return ud2 == 0x0b0f;
 242 }