Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 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> |
Steven Rostedt | 712406a | 2009-02-09 10:54:03 -0800 | [diff] [blame] | 13 | #include <linux/ftrace.h> |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 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> |
Josh Poimboeuf | e18bccc | 2016-09-16 14:18:16 -0500 | [diff] [blame] | 20 | #include <asm/unwind.h> |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 21 | |
| 22 | int panic_on_unrecovered_nmi; |
Kurt Garloff | 5211a24 | 2009-06-24 14:32:11 -0700 | [diff] [blame] | 23 | int panic_on_io_nmi; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 24 | unsigned int code_bytes = 64; |
| 25 | int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE; |
| 26 | static int die_counter; |
| 27 | |
Josh Poimboeuf | cb76c93 | 2016-09-14 21:07:42 -0500 | [diff] [blame] | 28 | bool in_task_stack(unsigned long *stack, struct task_struct *task, |
| 29 | struct stack_info *info) |
| 30 | { |
| 31 | unsigned long *begin = task_stack_page(task); |
| 32 | unsigned long *end = task_stack_page(task) + THREAD_SIZE; |
| 33 | |
| 34 | if (stack < begin || stack >= end) |
| 35 | return false; |
| 36 | |
| 37 | info->type = STACK_TYPE_TASK; |
| 38 | info->begin = begin; |
| 39 | info->end = end; |
| 40 | info->next_sp = NULL; |
| 41 | |
| 42 | return true; |
| 43 | } |
| 44 | |
Adrien Schildknecht | 1fc7f61 | 2015-02-20 03:34:21 +0100 | [diff] [blame] | 45 | static void printk_stack_address(unsigned long address, int reliable, |
Josh Poimboeuf | d438f5f | 2016-08-24 11:50:16 -0500 | [diff] [blame] | 46 | char *log_lvl) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 47 | { |
Josh Poimboeuf | d438f5f | 2016-08-24 11:50:16 -0500 | [diff] [blame] | 48 | touch_nmi_watchdog(); |
Adrien Schildknecht | 1fc7f61 | 2015-02-20 03:34:21 +0100 | [diff] [blame] | 49 | printk("%s [<%p>] %s%pB\n", |
Josh Poimboeuf | d438f5f | 2016-08-24 11:50:16 -0500 | [diff] [blame] | 50 | log_lvl, (void *)address, reliable ? "" : "? ", |
Adrien Schildknecht | 1fc7f61 | 2015-02-20 03:34:21 +0100 | [diff] [blame] | 51 | (void *)address); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 52 | } |
| 53 | |
Jiri Slaby | 5f01c98 | 2013-10-25 15:06:58 +0200 | [diff] [blame] | 54 | void printk_address(unsigned long address) |
| 55 | { |
| 56 | pr_cont(" [<%p>] %pS\n", (void *)address, (void *)address); |
| 57 | } |
| 58 | |
Josh Poimboeuf | e18bccc | 2016-09-16 14:18:16 -0500 | [diff] [blame] | 59 | void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs, |
| 60 | unsigned long *stack, char *log_lvl) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 61 | { |
Josh Poimboeuf | e18bccc | 2016-09-16 14:18:16 -0500 | [diff] [blame] | 62 | struct unwind_state state; |
| 63 | struct stack_info stack_info = {0}; |
| 64 | unsigned long visit_mask = 0; |
| 65 | int graph_idx = 0; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 66 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 67 | printk("%sCall Trace:\n", log_lvl); |
Josh Poimboeuf | e18bccc | 2016-09-16 14:18:16 -0500 | [diff] [blame] | 68 | |
| 69 | unwind_start(&state, task, regs, stack); |
| 70 | |
| 71 | /* |
| 72 | * Iterate through the stacks, starting with the current stack pointer. |
| 73 | * Each stack has a pointer to the next one. |
| 74 | * |
| 75 | * x86-64 can have several stacks: |
| 76 | * - task stack |
| 77 | * - interrupt stack |
| 78 | * - HW exception stacks (double fault, nmi, debug, mce) |
| 79 | * |
| 80 | * x86-32 can have up to three stacks: |
| 81 | * - task stack |
| 82 | * - softirq stack |
| 83 | * - hardirq stack |
| 84 | */ |
| 85 | for (; stack; stack = stack_info.next_sp) { |
| 86 | const char *str_begin, *str_end; |
| 87 | |
| 88 | /* |
| 89 | * If we overflowed the task stack into a guard page, jump back |
| 90 | * to the bottom of the usable stack. |
| 91 | */ |
| 92 | if (task_stack_page(task) - (void *)stack < PAGE_SIZE) |
| 93 | stack = task_stack_page(task); |
| 94 | |
| 95 | if (get_stack_info(stack, task, &stack_info, &visit_mask)) |
| 96 | break; |
| 97 | |
| 98 | stack_type_str(stack_info.type, &str_begin, &str_end); |
| 99 | if (str_begin) |
| 100 | printk("%s <%s> ", log_lvl, str_begin); |
| 101 | |
| 102 | /* |
| 103 | * Scan the stack, printing any text addresses we find. At the |
| 104 | * same time, follow proper stack frames with the unwinder. |
| 105 | * |
| 106 | * Addresses found during the scan which are not reported by |
| 107 | * the unwinder are considered to be additional clues which are |
| 108 | * sometimes useful for debugging and are prefixed with '?'. |
| 109 | * This also serves as a failsafe option in case the unwinder |
| 110 | * goes off in the weeds. |
| 111 | */ |
| 112 | for (; stack < stack_info.end; stack++) { |
| 113 | unsigned long real_addr; |
| 114 | int reliable = 0; |
| 115 | unsigned long addr = *stack; |
| 116 | unsigned long *ret_addr_p = |
| 117 | unwind_get_return_address_ptr(&state); |
| 118 | |
| 119 | if (!__kernel_text_address(addr)) |
| 120 | continue; |
| 121 | |
| 122 | if (stack == ret_addr_p) |
| 123 | reliable = 1; |
| 124 | |
| 125 | /* |
| 126 | * When function graph tracing is enabled for a |
| 127 | * function, its return address on the stack is |
| 128 | * replaced with the address of an ftrace handler |
| 129 | * (return_to_handler). In that case, before printing |
| 130 | * the "real" address, we want to print the handler |
| 131 | * address as an "unreliable" hint that function graph |
| 132 | * tracing was involved. |
| 133 | */ |
| 134 | real_addr = ftrace_graph_ret_addr(task, &graph_idx, |
| 135 | addr, stack); |
| 136 | if (real_addr != addr) |
| 137 | printk_stack_address(addr, 0, log_lvl); |
| 138 | printk_stack_address(real_addr, reliable, log_lvl); |
| 139 | |
| 140 | if (!reliable) |
| 141 | continue; |
| 142 | |
| 143 | /* |
| 144 | * Get the next frame from the unwinder. No need to |
| 145 | * check for an error: if anything goes wrong, the rest |
| 146 | * of the addresses will just be printed as unreliable. |
| 147 | */ |
| 148 | unwind_next_frame(&state); |
| 149 | } |
| 150 | |
| 151 | if (str_end) |
| 152 | printk("%s <%s> ", log_lvl, str_end); |
| 153 | } |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 154 | } |
| 155 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 156 | void show_stack(struct task_struct *task, unsigned long *sp) |
| 157 | { |
Josh Poimboeuf | 8153916 | 2016-09-16 08:05:20 -0500 | [diff] [blame] | 158 | task = task ? : current; |
| 159 | |
Tejun Heo | a77f2a4 | 2013-04-30 15:27:09 -0700 | [diff] [blame] | 160 | /* |
| 161 | * Stack frames below this one aren't interesting. Don't show them |
| 162 | * if we're printing for %current. |
| 163 | */ |
Josh Poimboeuf | e18bccc | 2016-09-16 14:18:16 -0500 | [diff] [blame] | 164 | if (!sp && task == current) |
Josh Poimboeuf | 4b8afaf | 2016-08-24 11:50:17 -0500 | [diff] [blame] | 165 | sp = get_stack_pointer(current, NULL); |
Tejun Heo | a77f2a4 | 2013-04-30 15:27:09 -0700 | [diff] [blame] | 166 | |
Josh Poimboeuf | 71f5443 | 2016-09-20 10:53:40 -0500 | [diff] [blame] | 167 | show_stack_log_lvl(task, NULL, sp, ""); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 168 | } |
| 169 | |
Borislav Petkov | 81c2949 | 2016-07-05 00:31:27 +0200 | [diff] [blame] | 170 | void show_stack_regs(struct pt_regs *regs) |
| 171 | { |
Josh Poimboeuf | e18bccc | 2016-09-16 14:18:16 -0500 | [diff] [blame] | 172 | show_stack_log_lvl(current, regs, NULL, ""); |
Borislav Petkov | 81c2949 | 2016-07-05 00:31:27 +0200 | [diff] [blame] | 173 | } |
| 174 | |
Thomas Gleixner | edc35bd | 2009-12-03 12:38:57 +0100 | [diff] [blame] | 175 | static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 176 | static int die_owner = -1; |
| 177 | static unsigned int die_nest_count; |
| 178 | |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 179 | unsigned long oops_begin(void) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 180 | { |
| 181 | int cpu; |
| 182 | unsigned long flags; |
| 183 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 184 | oops_enter(); |
| 185 | |
| 186 | /* racy, but better than risking deadlock. */ |
| 187 | raw_local_irq_save(flags); |
| 188 | cpu = smp_processor_id(); |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 189 | if (!arch_spin_trylock(&die_lock)) { |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 190 | if (cpu == die_owner) |
| 191 | /* nested oops. should stop eventually */; |
| 192 | else |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 193 | arch_spin_lock(&die_lock); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 194 | } |
| 195 | die_nest_count++; |
| 196 | die_owner = cpu; |
| 197 | console_verbose(); |
| 198 | bust_spinlocks(1); |
| 199 | return flags; |
| 200 | } |
Huang Ying | 81e88fd | 2011-01-12 14:44:55 +0800 | [diff] [blame] | 201 | EXPORT_SYMBOL_GPL(oops_begin); |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 202 | NOKPROBE_SYMBOL(oops_begin); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 203 | |
Andy Lutomirski | 2deb4be | 2016-07-14 13:22:55 -0700 | [diff] [blame] | 204 | void __noreturn rewind_stack_do_exit(int signr); |
| 205 | |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 206 | void oops_end(unsigned long flags, struct pt_regs *regs, int signr) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 207 | { |
| 208 | if (regs && kexec_should_crash(current)) |
| 209 | crash_kexec(regs); |
| 210 | |
| 211 | bust_spinlocks(0); |
| 212 | die_owner = -1; |
Rusty Russell | 373d4d0 | 2013-01-21 17:17:39 +1030 | [diff] [blame] | 213 | add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 214 | die_nest_count--; |
| 215 | if (!die_nest_count) |
| 216 | /* Nest count reaches zero, release the lock. */ |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 217 | arch_spin_unlock(&die_lock); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 218 | raw_local_irq_restore(flags); |
| 219 | oops_exit(); |
| 220 | |
| 221 | if (!signr) |
| 222 | return; |
| 223 | if (in_interrupt()) |
| 224 | panic("Fatal exception in interrupt"); |
| 225 | if (panic_on_oops) |
| 226 | panic("Fatal exception"); |
Andy Lutomirski | 2deb4be | 2016-07-14 13:22:55 -0700 | [diff] [blame] | 227 | |
| 228 | /* |
| 229 | * We're not going to return, but we might be on an IST stack or |
| 230 | * have very little stack space left. Rewind the stack and kill |
| 231 | * the task. |
| 232 | */ |
| 233 | rewind_stack_do_exit(signr); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 234 | } |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 235 | NOKPROBE_SYMBOL(oops_end); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 236 | |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 237 | int __die(const char *str, struct pt_regs *regs, long err) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 238 | { |
| 239 | #ifdef CONFIG_X86_32 |
| 240 | unsigned short ss; |
| 241 | unsigned long sp; |
| 242 | #endif |
Prarit Bhargava | b0f4c4b | 2012-01-26 08:55:34 -0500 | [diff] [blame] | 243 | printk(KERN_DEFAULT |
Rasmus Villemoes | 8fad7ec | 2016-03-26 21:40:16 +0100 | [diff] [blame] | 244 | "%s: %04lx [#%d]%s%s%s%s\n", str, err & 0xffff, ++die_counter, |
| 245 | IS_ENABLED(CONFIG_PREEMPT) ? " PREEMPT" : "", |
| 246 | IS_ENABLED(CONFIG_SMP) ? " SMP" : "", |
| 247 | debug_pagealloc_enabled() ? " DEBUG_PAGEALLOC" : "", |
| 248 | IS_ENABLED(CONFIG_KASAN) ? " KASAN" : ""); |
| 249 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 250 | if (notify_die(DIE_OOPS, str, regs, err, |
Srikar Dronamraju | 51e7dc7 | 2012-03-12 14:55:55 +0530 | [diff] [blame] | 251 | current->thread.trap_nr, SIGSEGV) == NOTIFY_STOP) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 252 | return 1; |
| 253 | |
Jan Beulich | 0fa0e2f | 2012-06-18 11:40:04 +0100 | [diff] [blame] | 254 | print_modules(); |
Jan Beulich | 57da8b9 | 2012-05-09 08:47:37 +0100 | [diff] [blame] | 255 | show_regs(regs); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 256 | #ifdef CONFIG_X86_32 |
Andy Lutomirski | f39b6f0 | 2015-03-18 18:33:33 -0700 | [diff] [blame] | 257 | if (user_mode(regs)) { |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 258 | sp = regs->sp; |
| 259 | ss = regs->ss & 0xffff; |
H. Peter Anvin | a343c75 | 2009-10-12 14:11:09 -0700 | [diff] [blame] | 260 | } else { |
| 261 | sp = kernel_stack_pointer(regs); |
| 262 | savesegment(ss, ss); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 263 | } |
| 264 | printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip); |
| 265 | print_symbol("%s", regs->ip); |
| 266 | printk(" SS:ESP %04x:%08lx\n", ss, sp); |
| 267 | #else |
| 268 | /* Executive summary in case the oops scrolled away */ |
| 269 | printk(KERN_ALERT "RIP "); |
Jiri Slaby | 5f01c98 | 2013-10-25 15:06:58 +0200 | [diff] [blame] | 270 | printk_address(regs->ip); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 271 | printk(" RSP <%016lx>\n", regs->sp); |
| 272 | #endif |
| 273 | return 0; |
| 274 | } |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 275 | NOKPROBE_SYMBOL(__die); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 276 | |
| 277 | /* |
| 278 | * This is gone through when something in the kernel has done something bad |
| 279 | * and is about to be terminated: |
| 280 | */ |
| 281 | void die(const char *str, struct pt_regs *regs, long err) |
| 282 | { |
| 283 | unsigned long flags = oops_begin(); |
| 284 | int sig = SIGSEGV; |
| 285 | |
Andy Lutomirski | f39b6f0 | 2015-03-18 18:33:33 -0700 | [diff] [blame] | 286 | if (!user_mode(regs)) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 287 | report_bug(regs->ip, regs); |
| 288 | |
| 289 | if (__die(str, regs, err)) |
| 290 | sig = 0; |
| 291 | oops_end(flags, regs, sig); |
| 292 | } |
| 293 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 294 | static int __init kstack_setup(char *s) |
| 295 | { |
Shuah Khan | 363f7ce | 2012-05-06 11:58:04 -0600 | [diff] [blame] | 296 | ssize_t ret; |
| 297 | unsigned long val; |
| 298 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 299 | if (!s) |
| 300 | return -EINVAL; |
Shuah Khan | 363f7ce | 2012-05-06 11:58:04 -0600 | [diff] [blame] | 301 | |
| 302 | ret = kstrtoul(s, 0, &val); |
| 303 | if (ret) |
| 304 | return ret; |
| 305 | kstack_depth_to_print = val; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 306 | return 0; |
| 307 | } |
| 308 | early_param("kstack", kstack_setup); |
| 309 | |
| 310 | static int __init code_bytes_setup(char *s) |
| 311 | { |
Shuah Khan | 363f7ce | 2012-05-06 11:58:04 -0600 | [diff] [blame] | 312 | ssize_t ret; |
| 313 | unsigned long val; |
| 314 | |
| 315 | if (!s) |
| 316 | return -EINVAL; |
| 317 | |
| 318 | ret = kstrtoul(s, 0, &val); |
| 319 | if (ret) |
| 320 | return ret; |
| 321 | |
| 322 | code_bytes = val; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 323 | if (code_bytes > 8192) |
| 324 | code_bytes = 8192; |
| 325 | |
| 326 | return 1; |
| 327 | } |
| 328 | __setup("code_bytes=", code_bytes_setup); |