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 static char *exception_stack_names[N_EXCEPTION_STACKS] = { 20 [ DOUBLEFAULT_STACK-1 ] = "#DF", 21 [ NMI_STACK-1 ] = "NMI", 22 [ DEBUG_STACK-1 ] = "#DB", 23 [ MCE_STACK-1 ] = "#MC", 24 }; 25 26 static unsigned long exception_stack_sizes[N_EXCEPTION_STACKS] = { 27 [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STKSZ, 28 [DEBUG_STACK - 1] = DEBUG_STKSZ 29 }; 30 31 const char *stack_type_name(enum stack_type type) 32 { 33 BUILD_BUG_ON(N_EXCEPTION_STACKS != 4); 34 35 if (type == STACK_TYPE_IRQ) 36 return "IRQ"; 37 38 if (type >= STACK_TYPE_EXCEPTION && type <= STACK_TYPE_EXCEPTION_LAST) 39 return exception_stack_names[type - STACK_TYPE_EXCEPTION]; 40 41 return NULL; 42 } 43 44 static bool in_exception_stack(unsigned long *stack, struct stack_info *info) 45 { 46 unsigned long *begin, *end; 47 struct pt_regs *regs; 48 unsigned k; 49 50 BUILD_BUG_ON(N_EXCEPTION_STACKS != 4); 51 52 for (k = 0; k < N_EXCEPTION_STACKS; k++) { 53 end = (unsigned long *)raw_cpu_ptr(&orig_ist)->ist[k]; 54 begin = end - (exception_stack_sizes[k] / sizeof(long)); 55 regs = (struct pt_regs *)end - 1; 56 57 if (stack < begin || stack >= end) 58 continue; 59 60 info->type = STACK_TYPE_EXCEPTION + k; 61 info->begin = begin; 62 info->end = end; 63 info->next_sp = (unsigned long *)regs->sp; 64 65 return true; 66 } 67 68 return false; 69 } 70 71 static bool in_irq_stack(unsigned long *stack, struct stack_info *info) 72 { 73 unsigned long *end = (unsigned long *)this_cpu_read(irq_stack_ptr); 74 unsigned long *begin = end - (IRQ_STACK_SIZE / sizeof(long)); 75 76 /* 77 * This is a software stack, so 'end' can be a valid stack pointer. 78 * It just means the stack is empty. 79 */ 80 if (stack < begin || stack > end) 81 return false; 82 83 info->type = STACK_TYPE_IRQ; 84 info->begin = begin; 85 info->end = end; 86 87 /* 88 * The next stack pointer is the first thing pushed by the entry code 89 * after switching to the irq stack. 90 */ 91 info->next_sp = (unsigned long *)*(end - 1); 92 93 return true; 94 } 95 96 int get_stack_info(unsigned long *stack, struct task_struct *task, 97 struct stack_info *info, unsigned long *visit_mask) 98 { 99 if (!stack) 100 goto unknown; 101 102 task = task ? : current; 103 104 if (in_task_stack(stack, task, info)) 105 goto recursion_check; 106 107 if (task != current) 108 goto unknown; 109 110 if (in_exception_stack(stack, info)) 111 goto recursion_check; 112 113 if (in_irq_stack(stack, info)) 114 goto recursion_check; 115 116 goto unknown; 117 118 recursion_check: 119 /* 120 * Make sure we don't iterate through any given stack more than once. 121 * If it comes up a second time then there's something wrong going on: 122 * just break out and report an unknown stack type. 123 */ 124 if (visit_mask) { 125 if (*visit_mask & (1UL << info->type)) { 126 printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type); 127 goto unknown; 128 } 129 *visit_mask |= 1UL << info->type; 130 } 131 132 return 0; 133 134 unknown: 135 info->type = STACK_TYPE_UNKNOWN; 136 return -EINVAL; 137 } 138 139 void show_regs(struct pt_regs *regs) 140 { 141 int i; 142 143 show_regs_print_info(KERN_DEFAULT); 144 __show_regs(regs, 1); 145 146 /* 147 * When in-kernel, we also print out the stack and code at the 148 * time of the fault.. 149 */ 150 if (!user_mode(regs)) { 151 unsigned int code_prologue = code_bytes * 43 / 64; 152 unsigned int code_len = code_bytes; 153 unsigned char c; 154 u8 *ip; 155 156 show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT); 157 158 printk(KERN_DEFAULT "Code: "); 159 160 ip = (u8 *)regs->ip - code_prologue; 161 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) { 162 /* try starting at IP */ 163 ip = (u8 *)regs->ip; 164 code_len = code_len - code_prologue + 1; 165 } 166 for (i = 0; i < code_len; i++, ip++) { 167 if (ip < (u8 *)PAGE_OFFSET || 168 probe_kernel_address(ip, c)) { 169 pr_cont(" Bad RIP value."); 170 break; 171 } 172 if (ip == (u8 *)regs->ip) 173 pr_cont("<%02x> ", c); 174 else 175 pr_cont("%02x ", c); 176 } 177 } 178 pr_cont("\n"); 179 } 180 181 int is_valid_bugaddr(unsigned long ip) 182 { 183 unsigned short ud2; 184 185 if (__copy_from_user(&ud2, (const void __user *) ip, sizeof(ud2))) 186 return 0; 187 188 return ud2 == 0x0b0f; 189 } 190