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