1 /* 2 * linux/arch/arm/kernel/traps.c 3 * 4 * Copyright (C) 1995-2002 Russell King 5 * Fragments that appear the same as linux/arch/i386/kernel/traps.c (C) Linus Torvalds 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 * 'traps.c' handles hardware exceptions after we have saved some state in 12 * 'linux/arch/arm/lib/traps.S'. Mostly a debugging aid, but will probably 13 * kill the offending process. 14 */ 15 #include <linux/config.h> 16 #include <linux/module.h> 17 #include <linux/signal.h> 18 #include <linux/spinlock.h> 19 #include <linux/personality.h> 20 #include <linux/ptrace.h> 21 #include <linux/kallsyms.h> 22 #include <linux/init.h> 23 24 #include <asm/atomic.h> 25 #include <asm/cacheflush.h> 26 #include <asm/io.h> 27 #include <asm/system.h> 28 #include <asm/uaccess.h> 29 #include <asm/unistd.h> 30 #include <asm/traps.h> 31 32 #include "ptrace.h" 33 #include "signal.h" 34 35 const char *processor_modes[]= 36 { "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" , 37 "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26", 38 "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "UK6_32" , "ABT_32" , 39 "UK8_32" , "UK9_32" , "UK10_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32" 40 }; 41 42 static const char *handler[]= { "prefetch abort", "data abort", "address exception", "interrupt" }; 43 44 #ifdef CONFIG_DEBUG_USER 45 unsigned int user_debug; 46 47 static int __init user_debug_setup(char *str) 48 { 49 get_option(&str, &user_debug); 50 return 1; 51 } 52 __setup("user_debug=", user_debug_setup); 53 #endif 54 55 void dump_backtrace_entry(unsigned long where, unsigned long from) 56 { 57 #ifdef CONFIG_KALLSYMS 58 printk("[<%08lx>] ", where); 59 print_symbol("(%s) ", where); 60 printk("from [<%08lx>] ", from); 61 print_symbol("(%s)\n", from); 62 #else 63 printk("Function entered at [<%08lx>] from [<%08lx>]\n", where, from); 64 #endif 65 } 66 67 /* 68 * Stack pointers should always be within the kernels view of 69 * physical memory. If it is not there, then we can't dump 70 * out any information relating to the stack. 71 */ 72 static int verify_stack(unsigned long sp) 73 { 74 if (sp < PAGE_OFFSET || (sp > (unsigned long)high_memory && high_memory != 0)) 75 return -EFAULT; 76 77 return 0; 78 } 79 80 /* 81 * Dump out the contents of some memory nicely... 82 */ 83 static void dump_mem(const char *str, unsigned long bottom, unsigned long top) 84 { 85 unsigned long p = bottom & ~31; 86 mm_segment_t fs; 87 int i; 88 89 /* 90 * We need to switch to kernel mode so that we can use __get_user 91 * to safely read from kernel space. Note that we now dump the 92 * code first, just in case the backtrace kills us. 93 */ 94 fs = get_fs(); 95 set_fs(KERNEL_DS); 96 97 printk("%s(0x%08lx to 0x%08lx)\n", str, bottom, top); 98 99 for (p = bottom & ~31; p < top;) { 100 printk("%04lx: ", p & 0xffff); 101 102 for (i = 0; i < 8; i++, p += 4) { 103 unsigned int val; 104 105 if (p < bottom || p >= top) 106 printk(" "); 107 else { 108 __get_user(val, (unsigned long *)p); 109 printk("%08x ", val); 110 } 111 } 112 printk ("\n"); 113 } 114 115 set_fs(fs); 116 } 117 118 static void dump_instr(struct pt_regs *regs) 119 { 120 unsigned long addr = instruction_pointer(regs); 121 const int thumb = thumb_mode(regs); 122 const int width = thumb ? 4 : 8; 123 mm_segment_t fs; 124 int i; 125 126 /* 127 * We need to switch to kernel mode so that we can use __get_user 128 * to safely read from kernel space. Note that we now dump the 129 * code first, just in case the backtrace kills us. 130 */ 131 fs = get_fs(); 132 set_fs(KERNEL_DS); 133 134 printk("Code: "); 135 for (i = -4; i < 1; i++) { 136 unsigned int val, bad; 137 138 if (thumb) 139 bad = __get_user(val, &((u16 *)addr)[i]); 140 else 141 bad = __get_user(val, &((u32 *)addr)[i]); 142 143 if (!bad) 144 printk(i == 0 ? "(%0*x) " : "%0*x ", width, val); 145 else { 146 printk("bad PC value."); 147 break; 148 } 149 } 150 printk("\n"); 151 152 set_fs(fs); 153 } 154 155 static void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk) 156 { 157 unsigned int fp; 158 int ok = 1; 159 160 printk("Backtrace: "); 161 fp = regs->ARM_fp; 162 if (!fp) { 163 printk("no frame pointer"); 164 ok = 0; 165 } else if (verify_stack(fp)) { 166 printk("invalid frame pointer 0x%08x", fp); 167 ok = 0; 168 } else if (fp < (unsigned long)(tsk->thread_info + 1)) 169 printk("frame pointer underflow"); 170 printk("\n"); 171 172 if (ok) 173 c_backtrace(fp, processor_mode(regs)); 174 } 175 176 void dump_stack(void) 177 { 178 #ifdef CONFIG_DEBUG_ERRORS 179 __backtrace(); 180 #endif 181 } 182 183 EXPORT_SYMBOL(dump_stack); 184 185 void show_stack(struct task_struct *tsk, unsigned long *sp) 186 { 187 unsigned long fp; 188 189 if (!tsk) 190 tsk = current; 191 192 if (tsk != current) 193 fp = thread_saved_fp(tsk); 194 else 195 asm("mov%? %0, fp" : "=r" (fp)); 196 197 c_backtrace(fp, 0x10); 198 barrier(); 199 } 200 201 static void __die(const char *str, int err, struct thread_info *thread, struct pt_regs *regs) 202 { 203 struct task_struct *tsk = thread->task; 204 static int die_counter; 205 206 printk("Internal error: %s: %x [#%d]\n", str, err, ++die_counter); 207 print_modules(); 208 __show_regs(regs); 209 printk("Process %s (pid: %d, stack limit = 0x%p)\n", 210 tsk->comm, tsk->pid, thread + 1); 211 212 if (!user_mode(regs) || in_interrupt()) { 213 dump_mem("Stack: ", regs->ARM_sp, 214 THREAD_SIZE + (unsigned long)tsk->thread_info); 215 dump_backtrace(regs, tsk); 216 dump_instr(regs); 217 } 218 } 219 220 DEFINE_SPINLOCK(die_lock); 221 222 /* 223 * This function is protected against re-entrancy. 224 */ 225 NORET_TYPE void die(const char *str, struct pt_regs *regs, int err) 226 { 227 struct thread_info *thread = current_thread_info(); 228 229 console_verbose(); 230 spin_lock_irq(&die_lock); 231 bust_spinlocks(1); 232 __die(str, err, thread, regs); 233 bust_spinlocks(0); 234 spin_unlock_irq(&die_lock); 235 do_exit(SIGSEGV); 236 } 237 238 void notify_die(const char *str, struct pt_regs *regs, struct siginfo *info, 239 unsigned long err, unsigned long trap) 240 { 241 if (user_mode(regs)) { 242 current->thread.error_code = err; 243 current->thread.trap_no = trap; 244 245 force_sig_info(info->si_signo, info, current); 246 } else { 247 die(str, regs, err); 248 } 249 } 250 251 static LIST_HEAD(undef_hook); 252 static DEFINE_SPINLOCK(undef_lock); 253 254 void register_undef_hook(struct undef_hook *hook) 255 { 256 unsigned long flags; 257 258 spin_lock_irqsave(&undef_lock, flags); 259 list_add(&hook->node, &undef_hook); 260 spin_unlock_irqrestore(&undef_lock, flags); 261 } 262 263 void unregister_undef_hook(struct undef_hook *hook) 264 { 265 unsigned long flags; 266 267 spin_lock_irqsave(&undef_lock, flags); 268 list_del(&hook->node); 269 spin_unlock_irqrestore(&undef_lock, flags); 270 } 271 272 asmlinkage void do_undefinstr(struct pt_regs *regs) 273 { 274 unsigned int correction = thumb_mode(regs) ? 2 : 4; 275 unsigned int instr; 276 struct undef_hook *hook; 277 siginfo_t info; 278 void __user *pc; 279 280 /* 281 * According to the ARM ARM, PC is 2 or 4 bytes ahead, 282 * depending whether we're in Thumb mode or not. 283 * Correct this offset. 284 */ 285 regs->ARM_pc -= correction; 286 287 pc = (void __user *)instruction_pointer(regs); 288 if (thumb_mode(regs)) { 289 get_user(instr, (u16 __user *)pc); 290 } else { 291 get_user(instr, (u32 __user *)pc); 292 } 293 294 spin_lock_irq(&undef_lock); 295 list_for_each_entry(hook, &undef_hook, node) { 296 if ((instr & hook->instr_mask) == hook->instr_val && 297 (regs->ARM_cpsr & hook->cpsr_mask) == hook->cpsr_val) { 298 if (hook->fn(regs, instr) == 0) { 299 spin_unlock_irq(&undef_lock); 300 return; 301 } 302 } 303 } 304 spin_unlock_irq(&undef_lock); 305 306 #ifdef CONFIG_DEBUG_USER 307 if (user_debug & UDBG_UNDEFINED) { 308 printk(KERN_INFO "%s (%d): undefined instruction: pc=%p\n", 309 current->comm, current->pid, pc); 310 dump_instr(regs); 311 } 312 #endif 313 314 info.si_signo = SIGILL; 315 info.si_errno = 0; 316 info.si_code = ILL_ILLOPC; 317 info.si_addr = pc; 318 319 notify_die("Oops - undefined instruction", regs, &info, 0, 6); 320 } 321 322 asmlinkage void do_unexp_fiq (struct pt_regs *regs) 323 { 324 #ifndef CONFIG_IGNORE_FIQ 325 printk("Hmm. Unexpected FIQ received, but trying to continue\n"); 326 printk("You may have a hardware problem...\n"); 327 #endif 328 } 329 330 /* 331 * bad_mode handles the impossible case in the vectors. If you see one of 332 * these, then it's extremely serious, and could mean you have buggy hardware. 333 * It never returns, and never tries to sync. We hope that we can at least 334 * dump out some state information... 335 */ 336 asmlinkage void bad_mode(struct pt_regs *regs, int reason, int proc_mode) 337 { 338 console_verbose(); 339 340 printk(KERN_CRIT "Bad mode in %s handler detected: mode %s\n", 341 handler[reason], processor_modes[proc_mode]); 342 343 die("Oops - bad mode", regs, 0); 344 local_irq_disable(); 345 panic("bad mode"); 346 } 347 348 static int bad_syscall(int n, struct pt_regs *regs) 349 { 350 struct thread_info *thread = current_thread_info(); 351 siginfo_t info; 352 353 if (current->personality != PER_LINUX && 354 current->personality != PER_LINUX_32BIT && 355 thread->exec_domain->handler) { 356 thread->exec_domain->handler(n, regs); 357 return regs->ARM_r0; 358 } 359 360 #ifdef CONFIG_DEBUG_USER 361 if (user_debug & UDBG_SYSCALL) { 362 printk(KERN_ERR "[%d] %s: obsolete system call %08x.\n", 363 current->pid, current->comm, n); 364 dump_instr(regs); 365 } 366 #endif 367 368 info.si_signo = SIGILL; 369 info.si_errno = 0; 370 info.si_code = ILL_ILLTRP; 371 info.si_addr = (void __user *)instruction_pointer(regs) - 372 (thumb_mode(regs) ? 2 : 4); 373 374 notify_die("Oops - bad syscall", regs, &info, n, 0); 375 376 return regs->ARM_r0; 377 } 378 379 static inline void 380 do_cache_op(unsigned long start, unsigned long end, int flags) 381 { 382 struct vm_area_struct *vma; 383 384 if (end < start || flags) 385 return; 386 387 vma = find_vma(current->active_mm, start); 388 if (vma && vma->vm_start < end) { 389 if (start < vma->vm_start) 390 start = vma->vm_start; 391 if (end > vma->vm_end) 392 end = vma->vm_end; 393 394 flush_cache_user_range(vma, start, end); 395 } 396 } 397 398 /* 399 * Handle all unrecognised system calls. 400 * 0x9f0000 - 0x9fffff are some more esoteric system calls 401 */ 402 #define NR(x) ((__ARM_NR_##x) - __ARM_NR_BASE) 403 asmlinkage int arm_syscall(int no, struct pt_regs *regs) 404 { 405 struct thread_info *thread = current_thread_info(); 406 siginfo_t info; 407 408 if ((no >> 16) != 0x9f) 409 return bad_syscall(no, regs); 410 411 switch (no & 0xffff) { 412 case 0: /* branch through 0 */ 413 info.si_signo = SIGSEGV; 414 info.si_errno = 0; 415 info.si_code = SEGV_MAPERR; 416 info.si_addr = NULL; 417 418 notify_die("branch through zero", regs, &info, 0, 0); 419 return 0; 420 421 case NR(breakpoint): /* SWI BREAK_POINT */ 422 regs->ARM_pc -= thumb_mode(regs) ? 2 : 4; 423 ptrace_break(current, regs); 424 return regs->ARM_r0; 425 426 /* 427 * Flush a region from virtual address 'r0' to virtual address 'r1' 428 * _exclusive_. There is no alignment requirement on either address; 429 * user space does not need to know the hardware cache layout. 430 * 431 * r2 contains flags. It should ALWAYS be passed as ZERO until it 432 * is defined to be something else. For now we ignore it, but may 433 * the fires of hell burn in your belly if you break this rule. ;) 434 * 435 * (at a later date, we may want to allow this call to not flush 436 * various aspects of the cache. Passing '0' will guarantee that 437 * everything necessary gets flushed to maintain consistency in 438 * the specified region). 439 */ 440 case NR(cacheflush): 441 do_cache_op(regs->ARM_r0, regs->ARM_r1, regs->ARM_r2); 442 return 0; 443 444 case NR(usr26): 445 if (!(elf_hwcap & HWCAP_26BIT)) 446 break; 447 regs->ARM_cpsr &= ~MODE32_BIT; 448 return regs->ARM_r0; 449 450 case NR(usr32): 451 if (!(elf_hwcap & HWCAP_26BIT)) 452 break; 453 regs->ARM_cpsr |= MODE32_BIT; 454 return regs->ARM_r0; 455 456 case NR(set_tls): 457 thread->tp_value = regs->ARM_r0; 458 #if defined(CONFIG_HAS_TLS_REG) 459 asm ("mcr p15, 0, %0, c13, c0, 3" : : "r" (regs->ARM_r0) ); 460 #elif !defined(CONFIG_TLS_REG_EMUL) 461 /* 462 * User space must never try to access this directly. 463 * Expect your app to break eventually if you do so. 464 * The user helper at 0xffff0fe0 must be used instead. 465 * (see entry-armv.S for details) 466 */ 467 *((unsigned int *)0xffff0ff0) = regs->ARM_r0; 468 #endif 469 return 0; 470 471 #ifdef CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG 472 /* 473 * Atomically store r1 in *r2 if *r2 is equal to r0 for user space. 474 * Return zero in r0 if *MEM was changed or non-zero if no exchange 475 * happened. Also set the user C flag accordingly. 476 * If access permissions have to be fixed up then non-zero is 477 * returned and the operation has to be re-attempted. 478 * 479 * *NOTE*: This is a ghost syscall private to the kernel. Only the 480 * __kuser_cmpxchg code in entry-armv.S should be aware of its 481 * existence. Don't ever use this from user code. 482 */ 483 case 0xfff0: 484 { 485 extern void do_DataAbort(unsigned long addr, unsigned int fsr, 486 struct pt_regs *regs); 487 unsigned long val; 488 unsigned long addr = regs->ARM_r2; 489 struct mm_struct *mm = current->mm; 490 pgd_t *pgd; pmd_t *pmd; pte_t *pte; 491 spinlock_t *ptl; 492 493 regs->ARM_cpsr &= ~PSR_C_BIT; 494 down_read(&mm->mmap_sem); 495 pgd = pgd_offset(mm, addr); 496 if (!pgd_present(*pgd)) 497 goto bad_access; 498 pmd = pmd_offset(pgd, addr); 499 if (!pmd_present(*pmd)) 500 goto bad_access; 501 pte = pte_offset_map_lock(mm, pmd, addr, &ptl); 502 if (!pte_present(*pte) || !pte_write(*pte)) { 503 pte_unmap_unlock(pte, ptl); 504 goto bad_access; 505 } 506 val = *(unsigned long *)addr; 507 val -= regs->ARM_r0; 508 if (val == 0) { 509 *(unsigned long *)addr = regs->ARM_r1; 510 regs->ARM_cpsr |= PSR_C_BIT; 511 } 512 pte_unmap_unlock(pte, ptl); 513 up_read(&mm->mmap_sem); 514 return val; 515 516 bad_access: 517 up_read(&mm->mmap_sem); 518 /* simulate a write access fault */ 519 do_DataAbort(addr, 15 + (1 << 11), regs); 520 return -1; 521 } 522 #endif 523 524 default: 525 /* Calls 9f00xx..9f07ff are defined to return -ENOSYS 526 if not implemented, rather than raising SIGILL. This 527 way the calling program can gracefully determine whether 528 a feature is supported. */ 529 if (no <= 0x7ff) 530 return -ENOSYS; 531 break; 532 } 533 #ifdef CONFIG_DEBUG_USER 534 /* 535 * experience shows that these seem to indicate that 536 * something catastrophic has happened 537 */ 538 if (user_debug & UDBG_SYSCALL) { 539 printk("[%d] %s: arm syscall %d\n", 540 current->pid, current->comm, no); 541 dump_instr(regs); 542 if (user_mode(regs)) { 543 __show_regs(regs); 544 c_backtrace(regs->ARM_fp, processor_mode(regs)); 545 } 546 } 547 #endif 548 info.si_signo = SIGILL; 549 info.si_errno = 0; 550 info.si_code = ILL_ILLTRP; 551 info.si_addr = (void __user *)instruction_pointer(regs) - 552 (thumb_mode(regs) ? 2 : 4); 553 554 notify_die("Oops - bad syscall(2)", regs, &info, no, 0); 555 return 0; 556 } 557 558 #ifdef CONFIG_TLS_REG_EMUL 559 560 /* 561 * We might be running on an ARMv6+ processor which should have the TLS 562 * register but for some reason we can't use it, or maybe an SMP system 563 * using a pre-ARMv6 processor (there are apparently a few prototypes like 564 * that in existence) and therefore access to that register must be 565 * emulated. 566 */ 567 568 static int get_tp_trap(struct pt_regs *regs, unsigned int instr) 569 { 570 int reg = (instr >> 12) & 15; 571 if (reg == 15) 572 return 1; 573 regs->uregs[reg] = current_thread_info()->tp_value; 574 regs->ARM_pc += 4; 575 return 0; 576 } 577 578 static struct undef_hook arm_mrc_hook = { 579 .instr_mask = 0x0fff0fff, 580 .instr_val = 0x0e1d0f70, 581 .cpsr_mask = PSR_T_BIT, 582 .cpsr_val = 0, 583 .fn = get_tp_trap, 584 }; 585 586 static int __init arm_mrc_hook_init(void) 587 { 588 register_undef_hook(&arm_mrc_hook); 589 return 0; 590 } 591 592 late_initcall(arm_mrc_hook_init); 593 594 #endif 595 596 void __bad_xchg(volatile void *ptr, int size) 597 { 598 printk("xchg: bad data size: pc 0x%p, ptr 0x%p, size %d\n", 599 __builtin_return_address(0), ptr, size); 600 BUG(); 601 } 602 EXPORT_SYMBOL(__bad_xchg); 603 604 /* 605 * A data abort trap was taken, but we did not handle the instruction. 606 * Try to abort the user program, or panic if it was the kernel. 607 */ 608 asmlinkage void 609 baddataabort(int code, unsigned long instr, struct pt_regs *regs) 610 { 611 unsigned long addr = instruction_pointer(regs); 612 siginfo_t info; 613 614 #ifdef CONFIG_DEBUG_USER 615 if (user_debug & UDBG_BADABORT) { 616 printk(KERN_ERR "[%d] %s: bad data abort: code %d instr 0x%08lx\n", 617 current->pid, current->comm, code, instr); 618 dump_instr(regs); 619 show_pte(current->mm, addr); 620 } 621 #endif 622 623 info.si_signo = SIGILL; 624 info.si_errno = 0; 625 info.si_code = ILL_ILLOPC; 626 info.si_addr = (void __user *)addr; 627 628 notify_die("unknown data abort code", regs, &info, instr, 0); 629 } 630 631 void __attribute__((noreturn)) __bug(const char *file, int line, void *data) 632 { 633 printk(KERN_CRIT"kernel BUG at %s:%d!", file, line); 634 if (data) 635 printk(" - extra data = %p", data); 636 printk("\n"); 637 *(int *)0 = 0; 638 639 /* Avoid "noreturn function does return" */ 640 for (;;); 641 } 642 EXPORT_SYMBOL(__bug); 643 644 void __readwrite_bug(const char *fn) 645 { 646 printk("%s called, but not implemented\n", fn); 647 BUG(); 648 } 649 EXPORT_SYMBOL(__readwrite_bug); 650 651 void __pte_error(const char *file, int line, unsigned long val) 652 { 653 printk("%s:%d: bad pte %08lx.\n", file, line, val); 654 } 655 656 void __pmd_error(const char *file, int line, unsigned long val) 657 { 658 printk("%s:%d: bad pmd %08lx.\n", file, line, val); 659 } 660 661 void __pgd_error(const char *file, int line, unsigned long val) 662 { 663 printk("%s:%d: bad pgd %08lx.\n", file, line, val); 664 } 665 666 asmlinkage void __div0(void) 667 { 668 printk("Division by zero in kernel.\n"); 669 dump_stack(); 670 } 671 EXPORT_SYMBOL(__div0); 672 673 void abort(void) 674 { 675 BUG(); 676 677 /* if that doesn't kill us, halt */ 678 panic("Oops failed to kill thread"); 679 } 680 EXPORT_SYMBOL(abort); 681 682 void __init trap_init(void) 683 { 684 extern char __stubs_start[], __stubs_end[]; 685 extern char __vectors_start[], __vectors_end[]; 686 extern char __kuser_helper_start[], __kuser_helper_end[]; 687 int kuser_sz = __kuser_helper_end - __kuser_helper_start; 688 689 /* 690 * Copy the vectors, stubs and kuser helpers (in entry-armv.S) 691 * into the vector page, mapped at 0xffff0000, and ensure these 692 * are visible to the instruction stream. 693 */ 694 memcpy((void *)0xffff0000, __vectors_start, __vectors_end - __vectors_start); 695 memcpy((void *)0xffff0200, __stubs_start, __stubs_end - __stubs_start); 696 memcpy((void *)0xffff1000 - kuser_sz, __kuser_helper_start, kuser_sz); 697 698 /* 699 * Copy signal return handlers into the vector page, and 700 * set sigreturn to be a pointer to these. 701 */ 702 memcpy((void *)KERN_SIGRETURN_CODE, sigreturn_codes, 703 sizeof(sigreturn_codes)); 704 705 flush_icache_range(0xffff0000, 0xffff0000 + PAGE_SIZE); 706 modify_domain(DOMAIN_USER, DOMAIN_CLIENT); 707 } 708