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