1 /* 2 * Based on arch/arm/kernel/traps.c 3 * 4 * Copyright (C) 1995-2009 Russell King 5 * Copyright (C) 2012 ARM Ltd. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include <linux/bug.h> 21 #include <linux/signal.h> 22 #include <linux/personality.h> 23 #include <linux/kallsyms.h> 24 #include <linux/spinlock.h> 25 #include <linux/uaccess.h> 26 #include <linux/hardirq.h> 27 #include <linux/kdebug.h> 28 #include <linux/module.h> 29 #include <linux/kexec.h> 30 #include <linux/delay.h> 31 #include <linux/init.h> 32 #include <linux/sched.h> 33 #include <linux/syscalls.h> 34 35 #include <asm/atomic.h> 36 #include <asm/bug.h> 37 #include <asm/debug-monitors.h> 38 #include <asm/esr.h> 39 #include <asm/insn.h> 40 #include <asm/traps.h> 41 #include <asm/stacktrace.h> 42 #include <asm/exception.h> 43 #include <asm/system_misc.h> 44 45 static const char *handler[]= { 46 "Synchronous Abort", 47 "IRQ", 48 "FIQ", 49 "Error" 50 }; 51 52 int show_unhandled_signals = 1; 53 54 /* 55 * Dump out the contents of some memory nicely... 56 */ 57 static void dump_mem(const char *lvl, const char *str, unsigned long bottom, 58 unsigned long top, bool compat) 59 { 60 unsigned long first; 61 mm_segment_t fs; 62 int i; 63 unsigned int width = compat ? 4 : 8; 64 65 /* 66 * We need to switch to kernel mode so that we can use __get_user 67 * to safely read from kernel space. Note that we now dump the 68 * code first, just in case the backtrace kills us. 69 */ 70 fs = get_fs(); 71 set_fs(KERNEL_DS); 72 73 printk("%s%s(0x%016lx to 0x%016lx)\n", lvl, str, bottom, top); 74 75 for (first = bottom & ~31; first < top; first += 32) { 76 unsigned long p; 77 char str[sizeof(" 12345678") * 8 + 1]; 78 79 memset(str, ' ', sizeof(str)); 80 str[sizeof(str) - 1] = '\0'; 81 82 for (p = first, i = 0; i < (32 / width) 83 && p < top; i++, p += width) { 84 if (p >= bottom && p < top) { 85 unsigned long val; 86 87 if (width == 8) { 88 if (__get_user(val, (unsigned long *)p) == 0) 89 sprintf(str + i * 17, " %016lx", val); 90 else 91 sprintf(str + i * 17, " ????????????????"); 92 } else { 93 if (__get_user(val, (unsigned int *)p) == 0) 94 sprintf(str + i * 9, " %08lx", val); 95 else 96 sprintf(str + i * 9, " ????????"); 97 } 98 } 99 } 100 printk("%s%04lx:%s\n", lvl, first & 0xffff, str); 101 } 102 103 set_fs(fs); 104 } 105 106 static void dump_backtrace_entry(unsigned long where) 107 { 108 /* 109 * Note that 'where' can have a physical address, but it's not handled. 110 */ 111 print_ip_sym(where); 112 } 113 114 static void dump_instr(const char *lvl, struct pt_regs *regs) 115 { 116 unsigned long addr = instruction_pointer(regs); 117 mm_segment_t fs; 118 char str[sizeof("00000000 ") * 5 + 2 + 1], *p = str; 119 int i; 120 121 /* 122 * We need to switch to kernel mode so that we can use __get_user 123 * to safely read from kernel space. Note that we now dump the 124 * code first, just in case the backtrace kills us. 125 */ 126 fs = get_fs(); 127 set_fs(KERNEL_DS); 128 129 for (i = -4; i < 1; i++) { 130 unsigned int val, bad; 131 132 bad = __get_user(val, &((u32 *)addr)[i]); 133 134 if (!bad) 135 p += sprintf(p, i == 0 ? "(%08x) " : "%08x ", val); 136 else { 137 p += sprintf(p, "bad PC value"); 138 break; 139 } 140 } 141 printk("%sCode: %s\n", lvl, str); 142 143 set_fs(fs); 144 } 145 146 static void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk) 147 { 148 struct stackframe frame; 149 150 pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk); 151 152 if (!tsk) 153 tsk = current; 154 155 if (regs) { 156 frame.fp = regs->regs[29]; 157 frame.sp = regs->sp; 158 frame.pc = regs->pc; 159 } else if (tsk == current) { 160 frame.fp = (unsigned long)__builtin_frame_address(0); 161 frame.sp = current_stack_pointer; 162 frame.pc = (unsigned long)dump_backtrace; 163 } else { 164 /* 165 * task blocked in __switch_to 166 */ 167 frame.fp = thread_saved_fp(tsk); 168 frame.sp = thread_saved_sp(tsk); 169 frame.pc = thread_saved_pc(tsk); 170 } 171 172 pr_emerg("Call trace:\n"); 173 while (1) { 174 unsigned long where = frame.pc; 175 unsigned long stack; 176 int ret; 177 178 dump_backtrace_entry(where); 179 ret = unwind_frame(&frame); 180 if (ret < 0) 181 break; 182 stack = frame.sp; 183 if (in_exception_text(where)) 184 dump_mem("", "Exception stack", stack, 185 stack + sizeof(struct pt_regs), false); 186 } 187 } 188 189 void show_stack(struct task_struct *tsk, unsigned long *sp) 190 { 191 dump_backtrace(NULL, tsk); 192 barrier(); 193 } 194 195 #ifdef CONFIG_PREEMPT 196 #define S_PREEMPT " PREEMPT" 197 #else 198 #define S_PREEMPT "" 199 #endif 200 #define S_SMP " SMP" 201 202 static int __die(const char *str, int err, struct thread_info *thread, 203 struct pt_regs *regs) 204 { 205 struct task_struct *tsk = thread->task; 206 static int die_counter; 207 int ret; 208 209 pr_emerg("Internal error: %s: %x [#%d]" S_PREEMPT S_SMP "\n", 210 str, err, ++die_counter); 211 212 /* trap and error numbers are mostly meaningless on ARM */ 213 ret = notify_die(DIE_OOPS, str, regs, err, 0, SIGSEGV); 214 if (ret == NOTIFY_STOP) 215 return ret; 216 217 print_modules(); 218 __show_regs(regs); 219 pr_emerg("Process %.*s (pid: %d, stack limit = 0x%p)\n", 220 TASK_COMM_LEN, tsk->comm, task_pid_nr(tsk), thread + 1); 221 222 if (!user_mode(regs) || in_interrupt()) { 223 dump_mem(KERN_EMERG, "Stack: ", regs->sp, 224 THREAD_SIZE + (unsigned long)task_stack_page(tsk), 225 compat_user_mode(regs)); 226 dump_backtrace(regs, tsk); 227 dump_instr(KERN_EMERG, regs); 228 } 229 230 return ret; 231 } 232 233 static DEFINE_RAW_SPINLOCK(die_lock); 234 235 /* 236 * This function is protected against re-entrancy. 237 */ 238 void die(const char *str, struct pt_regs *regs, int err) 239 { 240 struct thread_info *thread = current_thread_info(); 241 int ret; 242 243 oops_enter(); 244 245 raw_spin_lock_irq(&die_lock); 246 console_verbose(); 247 bust_spinlocks(1); 248 ret = __die(str, err, thread, regs); 249 250 if (regs && kexec_should_crash(thread->task)) 251 crash_kexec(regs); 252 253 bust_spinlocks(0); 254 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); 255 raw_spin_unlock_irq(&die_lock); 256 oops_exit(); 257 258 if (in_interrupt()) 259 panic("Fatal exception in interrupt"); 260 if (panic_on_oops) 261 panic("Fatal exception"); 262 if (ret != NOTIFY_STOP) 263 do_exit(SIGSEGV); 264 } 265 266 void arm64_notify_die(const char *str, struct pt_regs *regs, 267 struct siginfo *info, int err) 268 { 269 if (user_mode(regs)) { 270 current->thread.fault_address = 0; 271 current->thread.fault_code = err; 272 force_sig_info(info->si_signo, info, current); 273 } else { 274 die(str, regs, err); 275 } 276 } 277 278 static LIST_HEAD(undef_hook); 279 static DEFINE_RAW_SPINLOCK(undef_lock); 280 281 void register_undef_hook(struct undef_hook *hook) 282 { 283 unsigned long flags; 284 285 raw_spin_lock_irqsave(&undef_lock, flags); 286 list_add(&hook->node, &undef_hook); 287 raw_spin_unlock_irqrestore(&undef_lock, flags); 288 } 289 290 void unregister_undef_hook(struct undef_hook *hook) 291 { 292 unsigned long flags; 293 294 raw_spin_lock_irqsave(&undef_lock, flags); 295 list_del(&hook->node); 296 raw_spin_unlock_irqrestore(&undef_lock, flags); 297 } 298 299 static int call_undef_hook(struct pt_regs *regs) 300 { 301 struct undef_hook *hook; 302 unsigned long flags; 303 u32 instr; 304 int (*fn)(struct pt_regs *regs, u32 instr) = NULL; 305 void __user *pc = (void __user *)instruction_pointer(regs); 306 307 if (!user_mode(regs)) 308 return 1; 309 310 if (compat_thumb_mode(regs)) { 311 /* 16-bit Thumb instruction */ 312 if (get_user(instr, (u16 __user *)pc)) 313 goto exit; 314 instr = le16_to_cpu(instr); 315 if (aarch32_insn_is_wide(instr)) { 316 u32 instr2; 317 318 if (get_user(instr2, (u16 __user *)(pc + 2))) 319 goto exit; 320 instr2 = le16_to_cpu(instr2); 321 instr = (instr << 16) | instr2; 322 } 323 } else { 324 /* 32-bit ARM instruction */ 325 if (get_user(instr, (u32 __user *)pc)) 326 goto exit; 327 instr = le32_to_cpu(instr); 328 } 329 330 raw_spin_lock_irqsave(&undef_lock, flags); 331 list_for_each_entry(hook, &undef_hook, node) 332 if ((instr & hook->instr_mask) == hook->instr_val && 333 (regs->pstate & hook->pstate_mask) == hook->pstate_val) 334 fn = hook->fn; 335 336 raw_spin_unlock_irqrestore(&undef_lock, flags); 337 exit: 338 return fn ? fn(regs, instr) : 1; 339 } 340 341 asmlinkage void __exception do_undefinstr(struct pt_regs *regs) 342 { 343 siginfo_t info; 344 void __user *pc = (void __user *)instruction_pointer(regs); 345 346 /* check for AArch32 breakpoint instructions */ 347 if (!aarch32_break_handler(regs)) 348 return; 349 350 if (call_undef_hook(regs) == 0) 351 return; 352 353 if (unhandled_signal(current, SIGILL) && show_unhandled_signals_ratelimited()) { 354 pr_info("%s[%d]: undefined instruction: pc=%p\n", 355 current->comm, task_pid_nr(current), pc); 356 dump_instr(KERN_INFO, regs); 357 } 358 359 info.si_signo = SIGILL; 360 info.si_errno = 0; 361 info.si_code = ILL_ILLOPC; 362 info.si_addr = pc; 363 364 arm64_notify_die("Oops - undefined instruction", regs, &info, 0); 365 } 366 367 long compat_arm_syscall(struct pt_regs *regs); 368 369 asmlinkage long do_ni_syscall(struct pt_regs *regs) 370 { 371 #ifdef CONFIG_COMPAT 372 long ret; 373 if (is_compat_task()) { 374 ret = compat_arm_syscall(regs); 375 if (ret != -ENOSYS) 376 return ret; 377 } 378 #endif 379 380 if (show_unhandled_signals_ratelimited()) { 381 pr_info("%s[%d]: syscall %d\n", current->comm, 382 task_pid_nr(current), (int)regs->syscallno); 383 dump_instr("", regs); 384 if (user_mode(regs)) 385 __show_regs(regs); 386 } 387 388 return sys_ni_syscall(); 389 } 390 391 static const char *esr_class_str[] = { 392 [0 ... ESR_ELx_EC_MAX] = "UNRECOGNIZED EC", 393 [ESR_ELx_EC_UNKNOWN] = "Unknown/Uncategorized", 394 [ESR_ELx_EC_WFx] = "WFI/WFE", 395 [ESR_ELx_EC_CP15_32] = "CP15 MCR/MRC", 396 [ESR_ELx_EC_CP15_64] = "CP15 MCRR/MRRC", 397 [ESR_ELx_EC_CP14_MR] = "CP14 MCR/MRC", 398 [ESR_ELx_EC_CP14_LS] = "CP14 LDC/STC", 399 [ESR_ELx_EC_FP_ASIMD] = "ASIMD", 400 [ESR_ELx_EC_CP10_ID] = "CP10 MRC/VMRS", 401 [ESR_ELx_EC_CP14_64] = "CP14 MCRR/MRRC", 402 [ESR_ELx_EC_ILL] = "PSTATE.IL", 403 [ESR_ELx_EC_SVC32] = "SVC (AArch32)", 404 [ESR_ELx_EC_HVC32] = "HVC (AArch32)", 405 [ESR_ELx_EC_SMC32] = "SMC (AArch32)", 406 [ESR_ELx_EC_SVC64] = "SVC (AArch64)", 407 [ESR_ELx_EC_HVC64] = "HVC (AArch64)", 408 [ESR_ELx_EC_SMC64] = "SMC (AArch64)", 409 [ESR_ELx_EC_SYS64] = "MSR/MRS (AArch64)", 410 [ESR_ELx_EC_IMP_DEF] = "EL3 IMP DEF", 411 [ESR_ELx_EC_IABT_LOW] = "IABT (lower EL)", 412 [ESR_ELx_EC_IABT_CUR] = "IABT (current EL)", 413 [ESR_ELx_EC_PC_ALIGN] = "PC Alignment", 414 [ESR_ELx_EC_DABT_LOW] = "DABT (lower EL)", 415 [ESR_ELx_EC_DABT_CUR] = "DABT (current EL)", 416 [ESR_ELx_EC_SP_ALIGN] = "SP Alignment", 417 [ESR_ELx_EC_FP_EXC32] = "FP (AArch32)", 418 [ESR_ELx_EC_FP_EXC64] = "FP (AArch64)", 419 [ESR_ELx_EC_SERROR] = "SError", 420 [ESR_ELx_EC_BREAKPT_LOW] = "Breakpoint (lower EL)", 421 [ESR_ELx_EC_BREAKPT_CUR] = "Breakpoint (current EL)", 422 [ESR_ELx_EC_SOFTSTP_LOW] = "Software Step (lower EL)", 423 [ESR_ELx_EC_SOFTSTP_CUR] = "Software Step (current EL)", 424 [ESR_ELx_EC_WATCHPT_LOW] = "Watchpoint (lower EL)", 425 [ESR_ELx_EC_WATCHPT_CUR] = "Watchpoint (current EL)", 426 [ESR_ELx_EC_BKPT32] = "BKPT (AArch32)", 427 [ESR_ELx_EC_VECTOR32] = "Vector catch (AArch32)", 428 [ESR_ELx_EC_BRK64] = "BRK (AArch64)", 429 }; 430 431 const char *esr_get_class_string(u32 esr) 432 { 433 return esr_class_str[esr >> ESR_ELx_EC_SHIFT]; 434 } 435 436 /* 437 * bad_mode handles the impossible case in the exception vector. 438 */ 439 asmlinkage void bad_mode(struct pt_regs *regs, int reason, unsigned int esr) 440 { 441 siginfo_t info; 442 void __user *pc = (void __user *)instruction_pointer(regs); 443 console_verbose(); 444 445 pr_crit("Bad mode in %s handler detected, code 0x%08x -- %s\n", 446 handler[reason], esr, esr_get_class_string(esr)); 447 __show_regs(regs); 448 449 info.si_signo = SIGILL; 450 info.si_errno = 0; 451 info.si_code = ILL_ILLOPC; 452 info.si_addr = pc; 453 454 arm64_notify_die("Oops - bad mode", regs, &info, 0); 455 } 456 457 void __pte_error(const char *file, int line, unsigned long val) 458 { 459 pr_crit("%s:%d: bad pte %016lx.\n", file, line, val); 460 } 461 462 void __pmd_error(const char *file, int line, unsigned long val) 463 { 464 pr_crit("%s:%d: bad pmd %016lx.\n", file, line, val); 465 } 466 467 void __pud_error(const char *file, int line, unsigned long val) 468 { 469 pr_crit("%s:%d: bad pud %016lx.\n", file, line, val); 470 } 471 472 void __pgd_error(const char *file, int line, unsigned long val) 473 { 474 pr_crit("%s:%d: bad pgd %016lx.\n", file, line, val); 475 } 476 477 /* GENERIC_BUG traps */ 478 479 int is_valid_bugaddr(unsigned long addr) 480 { 481 /* 482 * bug_handler() only called for BRK #BUG_BRK_IMM. 483 * So the answer is trivial -- any spurious instances with no 484 * bug table entry will be rejected by report_bug() and passed 485 * back to the debug-monitors code and handled as a fatal 486 * unexpected debug exception. 487 */ 488 return 1; 489 } 490 491 static int bug_handler(struct pt_regs *regs, unsigned int esr) 492 { 493 if (user_mode(regs)) 494 return DBG_HOOK_ERROR; 495 496 switch (report_bug(regs->pc, regs)) { 497 case BUG_TRAP_TYPE_BUG: 498 die("Oops - BUG", regs, 0); 499 break; 500 501 case BUG_TRAP_TYPE_WARN: 502 /* Ideally, report_bug() should backtrace for us... but no. */ 503 dump_backtrace(regs, NULL); 504 break; 505 506 default: 507 /* unknown/unrecognised bug trap type */ 508 return DBG_HOOK_ERROR; 509 } 510 511 /* If thread survives, skip over the BUG instruction and continue: */ 512 regs->pc += AARCH64_INSN_SIZE; /* skip BRK and resume */ 513 return DBG_HOOK_HANDLED; 514 } 515 516 static struct break_hook bug_break_hook = { 517 .esr_val = 0xf2000000 | BUG_BRK_IMM, 518 .esr_mask = 0xffffffff, 519 .fn = bug_handler, 520 }; 521 522 /* 523 * Initial handler for AArch64 BRK exceptions 524 * This handler only used until debug_traps_init(). 525 */ 526 int __init early_brk64(unsigned long addr, unsigned int esr, 527 struct pt_regs *regs) 528 { 529 return bug_handler(regs, esr) != DBG_HOOK_HANDLED; 530 } 531 532 /* This registration must happen early, before debug_traps_init(). */ 533 void __init trap_init(void) 534 { 535 register_break_hook(&bug_break_hook); 536 } 537