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 22 int panic_on_unrecovered_nmi; 23 int panic_on_io_nmi; 24 unsigned int code_bytes = 64; 25 int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE; 26 static int die_counter; 27 28 static void printk_stack_address(unsigned long address, int reliable, 29 void *data) 30 { 31 printk("%s [<%p>] %s%pB\n", 32 (char *)data, (void *)address, reliable ? "" : "? ", 33 (void *)address); 34 } 35 36 void printk_address(unsigned long address) 37 { 38 pr_cont(" [<%p>] %pS\n", (void *)address, (void *)address); 39 } 40 41 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 42 static void 43 print_ftrace_graph_addr(unsigned long addr, void *data, 44 const struct stacktrace_ops *ops, 45 struct task_struct *task, int *graph) 46 { 47 unsigned long ret_addr; 48 int index; 49 50 if (addr != (unsigned long)return_to_handler) 51 return; 52 53 index = task->curr_ret_stack; 54 55 if (!task->ret_stack || index < *graph) 56 return; 57 58 index -= *graph; 59 ret_addr = task->ret_stack[index].ret; 60 61 ops->address(data, ret_addr, 1); 62 63 (*graph)++; 64 } 65 #else 66 static inline void 67 print_ftrace_graph_addr(unsigned long addr, void *data, 68 const struct stacktrace_ops *ops, 69 struct task_struct *task, int *graph) 70 { } 71 #endif 72 73 /* 74 * x86-64 can have up to three kernel stacks: 75 * process stack 76 * interrupt stack 77 * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack 78 */ 79 80 static inline int valid_stack_ptr(struct task_struct *task, 81 void *p, unsigned int size, void *end) 82 { 83 void *t = task_stack_page(task); 84 if (end) { 85 if (p < end && p >= (end-THREAD_SIZE)) 86 return 1; 87 else 88 return 0; 89 } 90 return p >= t && p < t + THREAD_SIZE - size; 91 } 92 93 unsigned long 94 print_context_stack(struct task_struct *task, 95 unsigned long *stack, unsigned long bp, 96 const struct stacktrace_ops *ops, void *data, 97 unsigned long *end, int *graph) 98 { 99 struct stack_frame *frame = (struct stack_frame *)bp; 100 101 /* 102 * If we overflowed the stack into a guard page, jump back to the 103 * bottom of the usable stack. 104 */ 105 if ((unsigned long)task_stack_page(task) - (unsigned long)stack < 106 PAGE_SIZE) 107 stack = (unsigned long *)task_stack_page(task); 108 109 while (valid_stack_ptr(task, stack, sizeof(*stack), end)) { 110 unsigned long addr; 111 112 addr = *stack; 113 if (__kernel_text_address(addr)) { 114 if ((unsigned long) stack == bp + sizeof(long)) { 115 ops->address(data, addr, 1); 116 frame = frame->next_frame; 117 bp = (unsigned long) frame; 118 } else { 119 ops->address(data, addr, 0); 120 } 121 print_ftrace_graph_addr(addr, data, ops, task, graph); 122 } 123 stack++; 124 } 125 return bp; 126 } 127 EXPORT_SYMBOL_GPL(print_context_stack); 128 129 unsigned long 130 print_context_stack_bp(struct task_struct *task, 131 unsigned long *stack, unsigned long bp, 132 const struct stacktrace_ops *ops, void *data, 133 unsigned long *end, int *graph) 134 { 135 struct stack_frame *frame = (struct stack_frame *)bp; 136 unsigned long *ret_addr = &frame->return_address; 137 138 while (valid_stack_ptr(task, ret_addr, sizeof(*ret_addr), end)) { 139 unsigned long addr = *ret_addr; 140 141 if (!__kernel_text_address(addr)) 142 break; 143 144 if (ops->address(data, addr, 1)) 145 break; 146 frame = frame->next_frame; 147 ret_addr = &frame->return_address; 148 print_ftrace_graph_addr(addr, data, ops, task, graph); 149 } 150 151 return (unsigned long)frame; 152 } 153 EXPORT_SYMBOL_GPL(print_context_stack_bp); 154 155 static int print_trace_stack(void *data, char *name) 156 { 157 printk("%s <%s> ", (char *)data, name); 158 return 0; 159 } 160 161 /* 162 * Print one address/symbol entries per line. 163 */ 164 static int print_trace_address(void *data, unsigned long addr, int reliable) 165 { 166 touch_nmi_watchdog(); 167 printk_stack_address(addr, reliable, data); 168 return 0; 169 } 170 171 static const struct stacktrace_ops print_trace_ops = { 172 .stack = print_trace_stack, 173 .address = print_trace_address, 174 .walk_stack = print_context_stack, 175 }; 176 177 void 178 show_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 185 void 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 191 void show_stack(struct task_struct *task, unsigned long *sp) 192 { 193 unsigned long bp = 0; 194 unsigned long stack; 195 196 /* 197 * Stack frames below this one aren't interesting. Don't show them 198 * if we're printing for %current. 199 */ 200 if (!sp && (!task || task == current)) { 201 sp = &stack; 202 bp = stack_frame(current, NULL); 203 } 204 205 show_stack_log_lvl(task, NULL, sp, bp, ""); 206 } 207 208 void show_stack_regs(struct pt_regs *regs) 209 { 210 show_stack_log_lvl(current, regs, (unsigned long *)regs->sp, regs->bp, ""); 211 } 212 213 static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED; 214 static int die_owner = -1; 215 static unsigned int die_nest_count; 216 217 unsigned long oops_begin(void) 218 { 219 int cpu; 220 unsigned long flags; 221 222 oops_enter(); 223 224 /* racy, but better than risking deadlock. */ 225 raw_local_irq_save(flags); 226 cpu = smp_processor_id(); 227 if (!arch_spin_trylock(&die_lock)) { 228 if (cpu == die_owner) 229 /* nested oops. should stop eventually */; 230 else 231 arch_spin_lock(&die_lock); 232 } 233 die_nest_count++; 234 die_owner = cpu; 235 console_verbose(); 236 bust_spinlocks(1); 237 return flags; 238 } 239 EXPORT_SYMBOL_GPL(oops_begin); 240 NOKPROBE_SYMBOL(oops_begin); 241 242 void __noreturn rewind_stack_do_exit(int signr); 243 244 void oops_end(unsigned long flags, struct pt_regs *regs, int signr) 245 { 246 if (regs && kexec_should_crash(current)) 247 crash_kexec(regs); 248 249 bust_spinlocks(0); 250 die_owner = -1; 251 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); 252 die_nest_count--; 253 if (!die_nest_count) 254 /* Nest count reaches zero, release the lock. */ 255 arch_spin_unlock(&die_lock); 256 raw_local_irq_restore(flags); 257 oops_exit(); 258 259 if (!signr) 260 return; 261 if (in_interrupt()) 262 panic("Fatal exception in interrupt"); 263 if (panic_on_oops) 264 panic("Fatal exception"); 265 266 /* 267 * We're not going to return, but we might be on an IST stack or 268 * have very little stack space left. Rewind the stack and kill 269 * the task. 270 */ 271 rewind_stack_do_exit(signr); 272 } 273 NOKPROBE_SYMBOL(oops_end); 274 275 int __die(const char *str, struct pt_regs *regs, long err) 276 { 277 #ifdef CONFIG_X86_32 278 unsigned short ss; 279 unsigned long sp; 280 #endif 281 printk(KERN_DEFAULT 282 "%s: %04lx [#%d]%s%s%s%s\n", str, err & 0xffff, ++die_counter, 283 IS_ENABLED(CONFIG_PREEMPT) ? " PREEMPT" : "", 284 IS_ENABLED(CONFIG_SMP) ? " SMP" : "", 285 debug_pagealloc_enabled() ? " DEBUG_PAGEALLOC" : "", 286 IS_ENABLED(CONFIG_KASAN) ? " KASAN" : ""); 287 288 if (notify_die(DIE_OOPS, str, regs, err, 289 current->thread.trap_nr, SIGSEGV) == NOTIFY_STOP) 290 return 1; 291 292 print_modules(); 293 show_regs(regs); 294 #ifdef CONFIG_X86_32 295 if (user_mode(regs)) { 296 sp = regs->sp; 297 ss = regs->ss & 0xffff; 298 } else { 299 sp = kernel_stack_pointer(regs); 300 savesegment(ss, ss); 301 } 302 printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip); 303 print_symbol("%s", regs->ip); 304 printk(" SS:ESP %04x:%08lx\n", ss, sp); 305 #else 306 /* Executive summary in case the oops scrolled away */ 307 printk(KERN_ALERT "RIP "); 308 printk_address(regs->ip); 309 printk(" RSP <%016lx>\n", regs->sp); 310 #endif 311 return 0; 312 } 313 NOKPROBE_SYMBOL(__die); 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(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 static int __init kstack_setup(char *s) 333 { 334 ssize_t ret; 335 unsigned long val; 336 337 if (!s) 338 return -EINVAL; 339 340 ret = kstrtoul(s, 0, &val); 341 if (ret) 342 return ret; 343 kstack_depth_to_print = val; 344 return 0; 345 } 346 early_param("kstack", kstack_setup); 347 348 static int __init code_bytes_setup(char *s) 349 { 350 ssize_t ret; 351 unsigned long val; 352 353 if (!s) 354 return -EINVAL; 355 356 ret = kstrtoul(s, 0, &val); 357 if (ret) 358 return ret; 359 360 code_bytes = val; 361 if (code_bytes > 8192) 362 code_bytes = 8192; 363 364 return 1; 365 } 366 __setup("code_bytes=", code_bytes_setup); 367