/arch/x86/kernel/dumpstack.c
C | 381 lines | 303 code | 51 blank | 27 comment | 39 complexity | 3d54fecf35eff523cff11d946fda1ca8 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
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 23int panic_on_unrecovered_nmi; 24int panic_on_io_nmi; 25unsigned int code_bytes = 64; 26int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE; 27static int die_counter; 28 29void 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 36static void 37print_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 59static inline void 60print_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 73static 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 86unsigned long 87print_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} 112EXPORT_SYMBOL_GPL(print_context_stack); 113 114unsigned long 115print_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 break; 128 129 ops->address(data, addr, 1); 130 frame = frame->next_frame; 131 ret_addr = &frame->return_address; 132 print_ftrace_graph_addr(addr, data, ops, tinfo, graph); 133 } 134 135 return (unsigned long)frame; 136} 137EXPORT_SYMBOL_GPL(print_context_stack_bp); 138 139 140static void 141print_trace_warning_symbol(void *data, char *msg, unsigned long symbol) 142{ 143 printk(data); 144 print_symbol(msg, symbol); 145 printk("\n"); 146} 147 148static void print_trace_warning(void *data, char *msg) 149{ 150 printk("%s%s\n", (char *)data, msg); 151} 152 153static int print_trace_stack(void *data, char *name) 154{ 155 printk("%s <%s> ", (char *)data, name); 156 return 0; 157} 158 159/* 160 * Print one address/symbol entries per line. 161 */ 162static void print_trace_address(void *data, unsigned long addr, int reliable) 163{ 164 touch_nmi_watchdog(); 165 printk(data); 166 printk_address(addr, reliable); 167} 168 169static const struct stacktrace_ops print_trace_ops = { 170 .warning = print_trace_warning, 171 .warning_symbol = print_trace_warning_symbol, 172 .stack = print_trace_stack, 173 .address = print_trace_address, 174 .walk_stack = print_context_stack, 175}; 176 177void 178show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs, 179 unsigned long *stack, unsigned long bp, char *log_lvl) 180{ 181 printk("%sCall Trace:\n", log_lvl); 182 dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl); 183} 184 185void show_trace(struct task_struct *task, struct pt_regs *regs, 186 unsigned long *stack, unsigned long bp) 187{ 188 show_trace_log_lvl(task, regs, stack, bp, ""); 189} 190 191void show_stack(struct task_struct *task, unsigned long *sp) 192{ 193 show_stack_log_lvl(task, NULL, sp, 0, ""); 194} 195 196/* 197 * The architecture-independent dump_stack generator 198 */ 199void dump_stack(void) 200{ 201 unsigned long bp = 0; 202 unsigned long stack; 203 204#ifdef CONFIG_FRAME_POINTER 205 if (!bp) 206 get_bp(bp); 207#endif 208 209 printk("Pid: %d, comm: %.20s %s %s %.*s\n", 210 current->pid, current->comm, print_tainted(), 211 init_utsname()->release, 212 (int)strcspn(init_utsname()->version, " "), 213 init_utsname()->version); 214 show_trace(NULL, NULL, &stack, bp); 215} 216EXPORT_SYMBOL(dump_stack); 217 218static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED; 219static int die_owner = -1; 220static unsigned int die_nest_count; 221 222unsigned __kprobes long oops_begin(void) 223{ 224 int cpu; 225 unsigned long flags; 226 227 oops_enter(); 228 229 /* racy, but better than risking deadlock. */ 230 raw_local_irq_save(flags); 231 cpu = smp_processor_id(); 232 if (!arch_spin_trylock(&die_lock)) { 233 if (cpu == die_owner) 234 /* nested oops. should stop eventually */; 235 else 236 arch_spin_lock(&die_lock); 237 } 238 die_nest_count++; 239 die_owner = cpu; 240 console_verbose(); 241 bust_spinlocks(1); 242 return flags; 243} 244 245void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr) 246{ 247 if (regs && kexec_should_crash(current)) 248 crash_kexec(regs); 249 250 bust_spinlocks(0); 251 die_owner = -1; 252 add_taint(TAINT_DIE); 253 die_nest_count--; 254 if (!die_nest_count) 255 /* Nest count reaches zero, release the lock. */ 256 arch_spin_unlock(&die_lock); 257 raw_local_irq_restore(flags); 258 oops_exit(); 259 260 if (!signr) 261 return; 262 if (in_interrupt()) 263 panic("Fatal exception in interrupt"); 264 if (panic_on_oops) 265 panic("Fatal exception"); 266 do_exit(signr); 267} 268 269int __kprobes __die(const char *str, struct pt_regs *regs, long err) 270{ 271#ifdef CONFIG_X86_32 272 unsigned short ss; 273 unsigned long sp; 274#endif 275 printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter); 276#ifdef CONFIG_PREEMPT 277 printk("PREEMPT "); 278#endif 279#ifdef CONFIG_SMP 280 printk("SMP "); 281#endif 282#ifdef CONFIG_DEBUG_PAGEALLOC 283 printk("DEBUG_PAGEALLOC"); 284#endif 285 printk("\n"); 286 sysfs_printk_last_file(); 287 if (notify_die(DIE_OOPS, str, regs, err, 288 current->thread.trap_no, SIGSEGV) == NOTIFY_STOP) 289 return 1; 290 291 show_registers(regs); 292#ifdef CONFIG_X86_32 293 if (user_mode_vm(regs)) { 294 sp = regs->sp; 295 ss = regs->ss & 0xffff; 296 } else { 297 sp = kernel_stack_pointer(regs); 298 savesegment(ss, ss); 299 } 300 printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip); 301 print_symbol("%s", regs->ip); 302 printk(" SS:ESP %04x:%08lx\n", ss, sp); 303#else 304 /* Executive summary in case the oops scrolled away */ 305 printk(KERN_ALERT "RIP "); 306 printk_address(regs->ip, 1); 307 printk(" RSP <%016lx>\n", regs->sp); 308#endif 309 return 0; 310} 311 312/* 313 * This is gone through when something in the kernel has done something bad 314 * and is about to be terminated: 315 */ 316void die(const char *str, struct pt_regs *regs, long err) 317{ 318 unsigned long flags = oops_begin(); 319 int sig = SIGSEGV; 320 321 if (!user_mode_vm(regs)) 322 report_bug(regs->ip, regs); 323 324 if (__die(str, regs, err)) 325 sig = 0; 326 oops_end(flags, regs, sig); 327} 328 329void notrace __kprobes 330die_nmi(char *str, struct pt_regs *regs, int do_panic) 331{ 332 unsigned long flags; 333 334 if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP) 335 return; 336 337 /* 338 * We are in trouble anyway, lets at least try 339 * to get a message out. 340 */ 341 flags = oops_begin(); 342 printk(KERN_EMERG "%s", str); 343 printk(" on CPU%d, ip %08lx, registers:\n", 344 smp_processor_id(), regs->ip); 345 show_registers(regs); 346 oops_end(flags, regs, 0); 347 if (do_panic || panic_on_oops) 348 panic("Non maskable interrupt"); 349 nmi_exit(); 350 local_irq_enable(); 351 do_exit(SIGBUS); 352} 353 354static int __init oops_setup(char *s) 355{ 356 if (!s) 357 return -EINVAL; 358 if (!strcmp(s, "panic")) 359 panic_on_oops = 1; 360 return 0; 361} 362early_param("oops", oops_setup); 363 364static int __init kstack_setup(char *s) 365{ 366 if (!s) 367 return -EINVAL; 368 kstack_depth_to_print = simple_strtoul(s, NULL, 0); 369 return 0; 370} 371early_param("kstack", kstack_setup); 372 373static int __init code_bytes_setup(char *s) 374{ 375 code_bytes = simple_strtoul(s, NULL, 0); 376 if (code_bytes > 8192) 377 code_bytes = 8192; 378 379 return 1; 380} 381__setup("code_bytes=", code_bytes_setup);