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                 return 0;
  93
  94         if (task != current)
  95                 goto unknown;
  96
  97         if (in_hardirq_stack(stack, info))
  98                 return 0;
  99
 100         if (in_softirq_stack(stack, info))
 101                 return 0;
 102
 103 unknown:
 104         info->type = STACK_TYPE_UNKNOWN;
 105         return -EINVAL;
 106 }
 107
 108 void dump_trace(struct task_struct *task, struct pt_regs *regs,
 109                 unsigned long *stack, unsigned long bp,
 110                 const struct stacktrace_ops *ops, void *data)
 111 {
 112         unsigned long visit_mask = 0;
 113         int graph = 0;
 114
 115         task = task ? : current;
 116         stack = stack ? : get_stack_pointer(task, regs);
 117         bp = bp ? : (unsigned long)get_frame_pointer(task, regs);
 118
 119         for (;;) {
 120                 const char *begin_str, *end_str;
 121                 struct stack_info info;
 122
 123                 if (get_stack_info(stack, task, &info, &visit_mask))
 124                         break;
 125
 126                 stack_type_str(info.type, &begin_str, &end_str);
 127
 128                 if (begin_str && ops->stack(data, begin_str) < 0)
 129                         break;
 130
 131                 bp = ops->walk_stack(task, stack, bp, ops, data, &info, &graph);
 132
 133                 if (end_str && ops->stack(data, end_str) < 0)
 134                         break;
 135
 136                 stack = info.next_sp;
 137
 138                 touch_nmi_watchdog();
 139         }
 140 }
 141 EXPORT_SYMBOL(dump_trace);
 142
 143 void
 144 show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,
 145                    unsigned long *sp, unsigned long bp, char *log_lvl)
 146 {
 147         unsigned long *stack;
 148         int i;
 149
 150         sp = sp ? : get_stack_pointer(task, regs);
 151
 152         stack = sp;
 153         for (i = 0; i < kstack_depth_to_print; i++) {
 154                 if (kstack_end(stack))
 155                         break;
 156                 if ((i % STACKSLOTS_PER_LINE) == 0) {
 157                         if (i != 0)
 158                                 pr_cont("\n");
 159                         printk("%s %08lx", log_lvl, *stack++);
 160                 } else
 161                         pr_cont(" %08lx", *stack++);
 162                 touch_nmi_watchdog();
 163         }
 164         pr_cont("\n");
 165         show_trace_log_lvl(task, regs, sp, bp, log_lvl);
 166 }
 167
 168
 169 void show_regs(struct pt_regs *regs)
 170 {
 171         int i;
 172
 173         show_regs_print_info(KERN_EMERG);
 174         __show_regs(regs, !user_mode(regs));
 175
 176         /*
 177          * When in-kernel, we also print out the stack and code at the
 178          * time of the fault..
 179          */
 180         if (!user_mode(regs)) {
 181                 unsigned int code_prologue = code_bytes * 43 / 64;
 182                 unsigned int code_len = code_bytes;
 183                 unsigned char c;
 184                 u8 *ip;
 185
 186                 pr_emerg("Stack:\n");
 187                 show_stack_log_lvl(NULL, regs, NULL, 0, KERN_EMERG);
 188
 189                 pr_emerg("Code:");
 190
 191                 ip = (u8 *)regs->ip - code_prologue;
 192                 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
 193                         /* try starting at IP */
 194                         ip = (u8 *)regs->ip;
 195                         code_len = code_len - code_prologue + 1;
 196                 }
 197                 for (i = 0; i < code_len; i++, ip++) {
 198                         if (ip < (u8 *)PAGE_OFFSET ||
 199                                         probe_kernel_address(ip, c)) {
 200                                 pr_cont("  Bad EIP value.");
 201                                 break;
 202                         }
 203                         if (ip == (u8 *)regs->ip)
 204                                 pr_cont(" <%02x>", c);
 205                         else
 206                                 pr_cont(" %02x", c);
 207                 }
 208         }
 209         pr_cont("\n");
 210 }
 211
 212 int is_valid_bugaddr(unsigned long ip)
 213 {
 214         unsigned short ud2;
 215
 216         if (ip < PAGE_OFFSET)
 217                 return 0;
 218         if (probe_kernel_address((unsigned short *)ip, ud2))
 219                 return 0;
 220
 221         return ud2 == 0x0b0f;
 222 }