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/ftrace.h> 14 #include <linux/kexec.h> 15 #include <linux/bug.h> 16 #include <linux/nmi.h> 17 #include <linux/sysfs.h> 18 #include <linux/ftrace.h> 19 20 #include <asm/stacktrace.h> 21 22 #include "dumpstack.h" 23 24 int panic_on_unrecovered_nmi; 25 int panic_on_io_nmi; 26 unsigned int code_bytes = 64; 27 int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE; 28 static int die_counter; 29 30 void printk_address(unsigned long address, int reliable) 31 { 32 printk(" [<%p>] %s%pS\n", (void *) address, 33 reliable ? "" : "? ", (void *) address); 34 } 35 36 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 37 static void 38 print_ftrace_graph_addr(unsigned long addr, void *data, 39 const struct stacktrace_ops *ops, 40 struct thread_info *tinfo, int *graph) 41 { 42 struct task_struct *task = tinfo->task; 43 unsigned long ret_addr; 44 int index = task->curr_ret_stack; 45 46 if (addr != (unsigned long)return_to_handler) 47 return; 48 49 if (!task->ret_stack || index < *graph) 50 return; 51 52 index -= *graph; 53 ret_addr = task->ret_stack[index].ret; 54 55 ops->address(data, ret_addr, 1); 56 57 (*graph)++; 58 } 59 #else 60 static inline void 61 print_ftrace_graph_addr(unsigned long addr, void *data, 62 const struct stacktrace_ops *ops, 63 struct thread_info *tinfo, int *graph) 64 { } 65 #endif 66 67 /* 68 * x86-64 can have up to three kernel stacks: 69 * process stack 70 * interrupt stack 71 * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack 72 */ 73 74 static inline int valid_stack_ptr(struct thread_info *tinfo, 75 void *p, unsigned int size, void *end) 76 { 77 void *t = tinfo; 78 if (end) { 79 if (p < end && p >= (end-THREAD_SIZE)) 80 return 1; 81 else 82 return 0; 83 } 84 return p > t && p < t + THREAD_SIZE - size; 85 } 86 87 unsigned long 88 print_context_stack(struct thread_info *tinfo, 89 unsigned long *stack, unsigned long bp, 90 const struct stacktrace_ops *ops, void *data, 91 unsigned long *end, int *graph) 92 { 93 struct stack_frame *frame = (struct stack_frame *)bp; 94 95 while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) { 96 unsigned long addr; 97 98 addr = *stack; 99 if (__kernel_text_address(addr)) { 100 if ((unsigned long) stack == bp + sizeof(long)) { 101 ops->address(data, addr, 1); 102 frame = frame->next_frame; 103 bp = (unsigned long) frame; 104 } else { 105 ops->address(data, addr, 0); 106 } 107 print_ftrace_graph_addr(addr, data, ops, tinfo, graph); 108 } 109 stack++; 110 } 111 return bp; 112 } 113 114 115 static void 116 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol) 117 { 118 printk(data); 119 print_symbol(msg, symbol); 120 printk("\n"); 121 } 122 123 static void print_trace_warning(void *data, char *msg) 124 { 125 printk("%s%s\n", (char *)data, msg); 126 } 127 128 static int print_trace_stack(void *data, char *name) 129 { 130 printk("%s <%s> ", (char *)data, name); 131 return 0; 132 } 133 134 /* 135 * Print one address/symbol entries per line. 136 */ 137 static void print_trace_address(void *data, unsigned long addr, int reliable) 138 { 139 touch_nmi_watchdog(); 140 printk(data); 141 printk_address(addr, reliable); 142 } 143 144 static const struct stacktrace_ops print_trace_ops = { 145 .warning = print_trace_warning, 146 .warning_symbol = print_trace_warning_symbol, 147 .stack = print_trace_stack, 148 .address = print_trace_address, 149 }; 150 151 void 152 show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs, 153 unsigned long *stack, unsigned long bp, char *log_lvl) 154 { 155 printk("%sCall Trace:\n", log_lvl); 156 dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl); 157 } 158 159 void show_trace(struct task_struct *task, struct pt_regs *regs, 160 unsigned long *stack, unsigned long bp) 161 { 162 show_trace_log_lvl(task, regs, stack, bp, ""); 163 } 164 165 void show_stack(struct task_struct *task, unsigned long *sp) 166 { 167 show_stack_log_lvl(task, NULL, sp, 0, ""); 168 } 169 170 /* 171 * The architecture-independent dump_stack generator 172 */ 173 void dump_stack(void) 174 { 175 unsigned long bp = 0; 176 unsigned long stack; 177 178 #ifdef CONFIG_FRAME_POINTER 179 if (!bp) 180 get_bp(bp); 181 #endif 182 183 printk("Pid: %d, comm: %.20s %s %s %.*s\n", 184 current->pid, current->comm, print_tainted(), 185 init_utsname()->release, 186 (int)strcspn(init_utsname()->version, " "), 187 init_utsname()->version); 188 show_trace(NULL, NULL, &stack, bp); 189 } 190 EXPORT_SYMBOL(dump_stack); 191 192 static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED; 193 static int die_owner = -1; 194 static unsigned int die_nest_count; 195 196 unsigned __kprobes long oops_begin(void) 197 { 198 int cpu; 199 unsigned long flags; 200 201 /* notify the hw-branch tracer so it may disable tracing and 202 add the last trace to the trace buffer - 203 the earlier this happens, the more useful the trace. */ 204 trace_hw_branch_oops(); 205 206 oops_enter(); 207 208 /* racy, but better than risking deadlock. */ 209 raw_local_irq_save(flags); 210 cpu = smp_processor_id(); 211 if (!__raw_spin_trylock(&die_lock)) { 212 if (cpu == die_owner) 213 /* nested oops. should stop eventually */; 214 else 215 __raw_spin_lock(&die_lock); 216 } 217 die_nest_count++; 218 die_owner = cpu; 219 console_verbose(); 220 bust_spinlocks(1); 221 return flags; 222 } 223 224 void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr) 225 { 226 if (regs && kexec_should_crash(current)) 227 crash_kexec(regs); 228 229 bust_spinlocks(0); 230 die_owner = -1; 231 add_taint(TAINT_DIE); 232 die_nest_count--; 233 if (!die_nest_count) 234 /* Nest count reaches zero, release the lock. */ 235 __raw_spin_unlock(&die_lock); 236 raw_local_irq_restore(flags); 237 oops_exit(); 238 239 if (!signr) 240 return; 241 if (in_interrupt()) 242 panic("Fatal exception in interrupt"); 243 if (panic_on_oops) 244 panic("Fatal exception"); 245 do_exit(signr); 246 } 247 248 int __kprobes __die(const char *str, struct pt_regs *regs, long err) 249 { 250 #ifdef CONFIG_X86_32 251 unsigned short ss; 252 unsigned long sp; 253 #endif 254 printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter); 255 #ifdef CONFIG_PREEMPT 256 printk("PREEMPT "); 257 #endif 258 #ifdef CONFIG_SMP 259 printk("SMP "); 260 #endif 261 #ifdef CONFIG_DEBUG_PAGEALLOC 262 printk("DEBUG_PAGEALLOC"); 263 #endif 264 printk("\n"); 265 sysfs_printk_last_file(); 266 if (notify_die(DIE_OOPS, str, regs, err, 267 current->thread.trap_no, SIGSEGV) == NOTIFY_STOP) 268 return 1; 269 270 show_registers(regs); 271 #ifdef CONFIG_X86_32 272 sp = (unsigned long) (®s->sp); 273 savesegment(ss, ss); 274 if (user_mode(regs)) { 275 sp = regs->sp; 276 ss = regs->ss & 0xffff; 277 } 278 printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip); 279 print_symbol("%s", regs->ip); 280 printk(" SS:ESP %04x:%08lx\n", ss, sp); 281 #else 282 /* Executive summary in case the oops scrolled away */ 283 printk(KERN_ALERT "RIP "); 284 printk_address(regs->ip, 1); 285 printk(" RSP <%016lx>\n", regs->sp); 286 #endif 287 return 0; 288 } 289 290 /* 291 * This is gone through when something in the kernel has done something bad 292 * and is about to be terminated: 293 */ 294 void die(const char *str, struct pt_regs *regs, long err) 295 { 296 unsigned long flags = oops_begin(); 297 int sig = SIGSEGV; 298 299 if (!user_mode_vm(regs)) 300 report_bug(regs->ip, regs); 301 302 if (__die(str, regs, err)) 303 sig = 0; 304 oops_end(flags, regs, sig); 305 } 306 307 void notrace __kprobes 308 die_nmi(char *str, struct pt_regs *regs, int do_panic) 309 { 310 unsigned long flags; 311 312 if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP) 313 return; 314 315 /* 316 * We are in trouble anyway, lets at least try 317 * to get a message out. 318 */ 319 flags = oops_begin(); 320 printk(KERN_EMERG "%s", str); 321 printk(" on CPU%d, ip %08lx, registers:\n", 322 smp_processor_id(), regs->ip); 323 show_registers(regs); 324 oops_end(flags, regs, 0); 325 if (do_panic || panic_on_oops) 326 panic("Non maskable interrupt"); 327 nmi_exit(); 328 local_irq_enable(); 329 do_exit(SIGBUS); 330 } 331 332 static int __init oops_setup(char *s) 333 { 334 if (!s) 335 return -EINVAL; 336 if (!strcmp(s, "panic")) 337 panic_on_oops = 1; 338 return 0; 339 } 340 early_param("oops", oops_setup); 341 342 static int __init kstack_setup(char *s) 343 { 344 if (!s) 345 return -EINVAL; 346 kstack_depth_to_print = simple_strtoul(s, NULL, 0); 347 return 0; 348 } 349 early_param("kstack", kstack_setup); 350 351 static int __init code_bytes_setup(char *s) 352 { 353 code_bytes = simple_strtoul(s, NULL, 0); 354 if (code_bytes > 8192) 355 code_bytes = 8192; 356 357 return 1; 358 } 359 __setup("code_bytes=", code_bytes_setup); 360