Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/arch/arm/mm/fault.c |
| 3 | * |
| 4 | * Copyright (C) 1995 Linus Torvalds |
| 5 | * Modifications for ARM processor (c) 1995-2004 Russell King |
| 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include <linux/module.h> |
| 12 | #include <linux/signal.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/mm.h> |
Russell King | 67306da | 2008-12-14 18:01:44 +0000 | [diff] [blame] | 14 | #include <linux/hardirq.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/init.h> |
Nicolas Pitre | 25ce1dd | 2007-12-03 15:21:57 -0500 | [diff] [blame] | 16 | #include <linux/kprobes.h> |
Russell King | 33fa9b1 | 2008-09-06 11:35:55 +0100 | [diff] [blame] | 17 | #include <linux/uaccess.h> |
Nicolas Pitre | 252d4c2 | 2008-09-11 11:52:02 -0400 | [diff] [blame] | 18 | #include <linux/page-flags.h> |
Russell King | 65cec8e | 2009-08-17 20:02:06 +0100 | [diff] [blame] | 19 | #include <linux/highmem.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | |
| 21 | #include <asm/system.h> |
| 22 | #include <asm/pgtable.h> |
| 23 | #include <asm/tlbflush.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | |
| 25 | #include "fault.h" |
| 26 | |
Nicolas Pitre | 25ce1dd | 2007-12-03 15:21:57 -0500 | [diff] [blame] | 27 | |
| 28 | #ifdef CONFIG_KPROBES |
| 29 | static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr) |
| 30 | { |
| 31 | int ret = 0; |
| 32 | |
| 33 | if (!user_mode(regs)) { |
| 34 | /* kprobe_running() needs smp_processor_id() */ |
| 35 | preempt_disable(); |
| 36 | if (kprobe_running() && kprobe_fault_handler(regs, fsr)) |
| 37 | ret = 1; |
| 38 | preempt_enable(); |
| 39 | } |
| 40 | |
| 41 | return ret; |
| 42 | } |
| 43 | #else |
| 44 | static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr) |
| 45 | { |
| 46 | return 0; |
| 47 | } |
| 48 | #endif |
| 49 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | /* |
| 51 | * This is useful to dump out the page tables associated with |
| 52 | * 'addr' in mm 'mm'. |
| 53 | */ |
| 54 | void show_pte(struct mm_struct *mm, unsigned long addr) |
| 55 | { |
| 56 | pgd_t *pgd; |
| 57 | |
| 58 | if (!mm) |
| 59 | mm = &init_mm; |
| 60 | |
| 61 | printk(KERN_ALERT "pgd = %p\n", mm->pgd); |
| 62 | pgd = pgd_offset(mm, addr); |
| 63 | printk(KERN_ALERT "[%08lx] *pgd=%08lx", addr, pgd_val(*pgd)); |
| 64 | |
| 65 | do { |
| 66 | pmd_t *pmd; |
| 67 | pte_t *pte; |
| 68 | |
| 69 | if (pgd_none(*pgd)) |
| 70 | break; |
| 71 | |
| 72 | if (pgd_bad(*pgd)) { |
| 73 | printk("(bad)"); |
| 74 | break; |
| 75 | } |
| 76 | |
| 77 | pmd = pmd_offset(pgd, addr); |
Nicolas Pitre | da46c79 | 2008-09-30 16:10:11 +0100 | [diff] [blame] | 78 | if (PTRS_PER_PMD != 1) |
| 79 | printk(", *pmd=%08lx", pmd_val(*pmd)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | |
| 81 | if (pmd_none(*pmd)) |
| 82 | break; |
| 83 | |
| 84 | if (pmd_bad(*pmd)) { |
| 85 | printk("(bad)"); |
| 86 | break; |
| 87 | } |
| 88 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | /* We must not map this if we have highmem enabled */ |
Nicolas Pitre | 252d4c2 | 2008-09-11 11:52:02 -0400 | [diff] [blame] | 90 | if (PageHighMem(pfn_to_page(pmd_val(*pmd) >> PAGE_SHIFT))) |
| 91 | break; |
| 92 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | pte = pte_offset_map(pmd, addr); |
| 94 | printk(", *pte=%08lx", pte_val(*pte)); |
| 95 | printk(", *ppte=%08lx", pte_val(pte[-PTRS_PER_PTE])); |
| 96 | pte_unmap(pte); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | } while(0); |
| 98 | |
| 99 | printk("\n"); |
| 100 | } |
| 101 | |
| 102 | /* |
| 103 | * Oops. The kernel tried to access some page that wasn't present. |
| 104 | */ |
| 105 | static void |
| 106 | __do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr, |
| 107 | struct pt_regs *regs) |
| 108 | { |
| 109 | /* |
| 110 | * Are we prepared to handle this kernel fault? |
| 111 | */ |
| 112 | if (fixup_exception(regs)) |
| 113 | return; |
| 114 | |
| 115 | /* |
| 116 | * No handler, we'll have to terminate things with extreme prejudice. |
| 117 | */ |
| 118 | bust_spinlocks(1); |
| 119 | printk(KERN_ALERT |
| 120 | "Unable to handle kernel %s at virtual address %08lx\n", |
| 121 | (addr < PAGE_SIZE) ? "NULL pointer dereference" : |
| 122 | "paging request", addr); |
| 123 | |
| 124 | show_pte(mm, addr); |
| 125 | die("Oops", regs, fsr); |
| 126 | bust_spinlocks(0); |
| 127 | do_exit(SIGKILL); |
| 128 | } |
| 129 | |
| 130 | /* |
| 131 | * Something tried to access memory that isn't in our memory map.. |
| 132 | * User mode accesses just cause a SIGSEGV |
| 133 | */ |
| 134 | static void |
| 135 | __do_user_fault(struct task_struct *tsk, unsigned long addr, |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 136 | unsigned int fsr, unsigned int sig, int code, |
| 137 | struct pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | { |
| 139 | struct siginfo si; |
| 140 | |
| 141 | #ifdef CONFIG_DEBUG_USER |
| 142 | if (user_debug & UDBG_SEGV) { |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 143 | printk(KERN_DEBUG "%s: unhandled page fault (%d) at 0x%08lx, code 0x%03x\n", |
| 144 | tsk->comm, sig, addr, fsr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | show_pte(tsk->mm, addr); |
| 146 | show_regs(regs); |
| 147 | } |
| 148 | #endif |
| 149 | |
| 150 | tsk->thread.address = addr; |
| 151 | tsk->thread.error_code = fsr; |
| 152 | tsk->thread.trap_no = 14; |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 153 | si.si_signo = sig; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | si.si_errno = 0; |
| 155 | si.si_code = code; |
| 156 | si.si_addr = (void __user *)addr; |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 157 | force_sig_info(sig, &si, tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Russell King | e5beac3 | 2006-09-27 16:13:48 +0100 | [diff] [blame] | 160 | void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | { |
Russell King | e5beac3 | 2006-09-27 16:13:48 +0100 | [diff] [blame] | 162 | struct task_struct *tsk = current; |
| 163 | struct mm_struct *mm = tsk->active_mm; |
| 164 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | /* |
| 166 | * If we are in kernel mode at this point, we |
| 167 | * have no context to handle this fault with. |
| 168 | */ |
| 169 | if (user_mode(regs)) |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 170 | __do_user_fault(tsk, addr, fsr, SIGSEGV, SEGV_MAPERR, regs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | else |
| 172 | __do_kernel_fault(mm, addr, fsr, regs); |
| 173 | } |
| 174 | |
Nick Piggin | 5c72fc5 | 2007-07-20 09:21:06 +0200 | [diff] [blame] | 175 | #define VM_FAULT_BADMAP 0x010000 |
| 176 | #define VM_FAULT_BADACCESS 0x020000 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | |
| 178 | static int |
| 179 | __do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr, |
| 180 | struct task_struct *tsk) |
| 181 | { |
| 182 | struct vm_area_struct *vma; |
| 183 | int fault, mask; |
| 184 | |
| 185 | vma = find_vma(mm, addr); |
| 186 | fault = VM_FAULT_BADMAP; |
| 187 | if (!vma) |
| 188 | goto out; |
| 189 | if (vma->vm_start > addr) |
| 190 | goto check_stack; |
| 191 | |
| 192 | /* |
| 193 | * Ok, we have a good vm_area for this |
| 194 | * memory access, so we can handle it. |
| 195 | */ |
| 196 | good_area: |
| 197 | if (fsr & (1 << 11)) /* write? */ |
| 198 | mask = VM_WRITE; |
| 199 | else |
Jason Baron | df67b3d | 2006-09-29 01:58:58 -0700 | [diff] [blame] | 200 | mask = VM_READ|VM_EXEC|VM_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | |
| 202 | fault = VM_FAULT_BADACCESS; |
| 203 | if (!(vma->vm_flags & mask)) |
| 204 | goto out; |
| 205 | |
| 206 | /* |
| 207 | * If for any reason at all we couldn't handle |
| 208 | * the fault, make sure we exit gracefully rather |
| 209 | * than endlessly redo the fault. |
| 210 | */ |
| 211 | survive: |
Linus Torvalds | d06063c | 2009-04-10 09:01:23 -0700 | [diff] [blame] | 212 | fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, (fsr & (1 << 11)) ? FAULT_FLAG_WRITE : 0); |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 213 | if (unlikely(fault & VM_FAULT_ERROR)) { |
| 214 | if (fault & VM_FAULT_OOM) |
| 215 | goto out_of_memory; |
| 216 | else if (fault & VM_FAULT_SIGBUS) |
| 217 | return fault; |
| 218 | BUG(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | } |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 220 | if (fault & VM_FAULT_MAJOR) |
| 221 | tsk->maj_flt++; |
| 222 | else |
| 223 | tsk->min_flt++; |
| 224 | return fault; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 226 | out_of_memory: |
Serge E. Hallyn | b460cbc | 2007-10-18 23:39:52 -0700 | [diff] [blame] | 227 | if (!is_global_init(tsk)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | goto out; |
| 229 | |
| 230 | /* |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 231 | * If we are out of memory for pid1, sleep for a while and retry |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | */ |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 233 | up_read(&mm->mmap_sem); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | yield(); |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 235 | down_read(&mm->mmap_sem); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | goto survive; |
| 237 | |
| 238 | check_stack: |
| 239 | if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr)) |
| 240 | goto good_area; |
| 241 | out: |
| 242 | return fault; |
| 243 | } |
| 244 | |
Nicolas Pitre | 785d3cd | 2007-12-03 15:27:56 -0500 | [diff] [blame] | 245 | static int __kprobes |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs) |
| 247 | { |
| 248 | struct task_struct *tsk; |
| 249 | struct mm_struct *mm; |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 250 | int fault, sig, code; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | |
Nicolas Pitre | 25ce1dd | 2007-12-03 15:21:57 -0500 | [diff] [blame] | 252 | if (notify_page_fault(regs, fsr)) |
| 253 | return 0; |
| 254 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | tsk = current; |
| 256 | mm = tsk->mm; |
| 257 | |
| 258 | /* |
| 259 | * If we're in an interrupt or have no user |
| 260 | * context, we must not take the fault.. |
| 261 | */ |
Peter Zijlstra | 6edaf68 | 2006-12-06 20:32:18 -0800 | [diff] [blame] | 262 | if (in_atomic() || !mm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | goto no_context; |
| 264 | |
Russell King | 840ff6a | 2005-09-20 17:52:13 +0100 | [diff] [blame] | 265 | /* |
| 266 | * As per x86, we may deadlock here. However, since the kernel only |
| 267 | * validly references user space from well defined areas of the code, |
| 268 | * we can bug out early if this is from code which shouldn't. |
| 269 | */ |
| 270 | if (!down_read_trylock(&mm->mmap_sem)) { |
| 271 | if (!user_mode(regs) && !search_exception_tables(regs->ARM_pc)) |
| 272 | goto no_context; |
| 273 | down_read(&mm->mmap_sem); |
| 274 | } |
| 275 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | fault = __do_page_fault(mm, addr, fsr, tsk); |
| 277 | up_read(&mm->mmap_sem); |
| 278 | |
| 279 | /* |
Russell King | ff2afb9 | 2005-08-04 14:17:33 +0100 | [diff] [blame] | 280 | * Handle the "normal" case first - VM_FAULT_MAJOR / VM_FAULT_MINOR |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | */ |
Nick Piggin | 5c72fc5 | 2007-07-20 09:21:06 +0200 | [diff] [blame] | 282 | if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP | VM_FAULT_BADACCESS)))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | return 0; |
| 284 | |
| 285 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 286 | * If we are in kernel mode at this point, we |
| 287 | * have no context to handle this fault with. |
| 288 | */ |
| 289 | if (!user_mode(regs)) |
| 290 | goto no_context; |
| 291 | |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 292 | if (fault & VM_FAULT_OOM) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 293 | /* |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 294 | * We ran out of memory, or some other thing |
| 295 | * happened to us that made us unable to handle |
| 296 | * the page fault gracefully. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | */ |
| 298 | printk("VM: killing process %s\n", tsk->comm); |
Will Schmidt | dcca2bd | 2007-10-16 01:24:18 -0700 | [diff] [blame] | 299 | do_group_exit(SIGKILL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | return 0; |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 301 | } |
| 302 | if (fault & VM_FAULT_SIGBUS) { |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 303 | /* |
| 304 | * We had some memory, but were unable to |
| 305 | * successfully fix up this page fault. |
| 306 | */ |
| 307 | sig = SIGBUS; |
| 308 | code = BUS_ADRERR; |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 309 | } else { |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 310 | /* |
| 311 | * Something tried to access memory that |
| 312 | * isn't in our memory map.. |
| 313 | */ |
| 314 | sig = SIGSEGV; |
| 315 | code = fault == VM_FAULT_BADACCESS ? |
| 316 | SEGV_ACCERR : SEGV_MAPERR; |
akpm@osdl.org | 2d137c2 | 2005-04-16 15:23:55 -0700 | [diff] [blame] | 317 | } |
| 318 | |
| 319 | __do_user_fault(tsk, addr, fsr, sig, code, regs); |
| 320 | return 0; |
| 321 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | no_context: |
| 323 | __do_kernel_fault(mm, addr, fsr, regs); |
| 324 | return 0; |
| 325 | } |
| 326 | |
| 327 | /* |
| 328 | * First Level Translation Fault Handler |
| 329 | * |
| 330 | * We enter here because the first level page table doesn't contain |
| 331 | * a valid entry for the address. |
| 332 | * |
| 333 | * If the address is in kernel space (>= TASK_SIZE), then we are |
| 334 | * probably faulting in the vmalloc() area. |
| 335 | * |
| 336 | * If the init_task's first level page tables contains the relevant |
| 337 | * entry, we copy the it to this task. If not, we send the process |
| 338 | * a signal, fixup the exception, or oops the kernel. |
| 339 | * |
| 340 | * NOTE! We MUST NOT take any locks for this case. We may be in an |
| 341 | * interrupt or a critical region, and should only copy the information |
| 342 | * from the master page table, nothing more. |
| 343 | */ |
Nicolas Pitre | 785d3cd | 2007-12-03 15:27:56 -0500 | [diff] [blame] | 344 | static int __kprobes |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | do_translation_fault(unsigned long addr, unsigned int fsr, |
| 346 | struct pt_regs *regs) |
| 347 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | unsigned int index; |
| 349 | pgd_t *pgd, *pgd_k; |
| 350 | pmd_t *pmd, *pmd_k; |
| 351 | |
| 352 | if (addr < TASK_SIZE) |
| 353 | return do_page_fault(addr, fsr, regs); |
| 354 | |
| 355 | index = pgd_index(addr); |
| 356 | |
| 357 | /* |
| 358 | * FIXME: CP15 C1 is write only on ARMv3 architectures. |
| 359 | */ |
| 360 | pgd = cpu_get_pgd() + index; |
| 361 | pgd_k = init_mm.pgd + index; |
| 362 | |
| 363 | if (pgd_none(*pgd_k)) |
| 364 | goto bad_area; |
| 365 | |
| 366 | if (!pgd_present(*pgd)) |
| 367 | set_pgd(pgd, *pgd_k); |
| 368 | |
| 369 | pmd_k = pmd_offset(pgd_k, addr); |
| 370 | pmd = pmd_offset(pgd, addr); |
| 371 | |
| 372 | if (pmd_none(*pmd_k)) |
| 373 | goto bad_area; |
| 374 | |
| 375 | copy_pmd(pmd, pmd_k); |
| 376 | return 0; |
| 377 | |
| 378 | bad_area: |
Russell King | e5beac3 | 2006-09-27 16:13:48 +0100 | [diff] [blame] | 379 | do_bad_area(addr, fsr, regs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 380 | return 0; |
| 381 | } |
| 382 | |
| 383 | /* |
| 384 | * Some section permission faults need to be handled gracefully. |
| 385 | * They can happen due to a __{get,put}_user during an oops. |
| 386 | */ |
| 387 | static int |
| 388 | do_sect_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs) |
| 389 | { |
Russell King | e5beac3 | 2006-09-27 16:13:48 +0100 | [diff] [blame] | 390 | do_bad_area(addr, fsr, regs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | return 0; |
| 392 | } |
| 393 | |
| 394 | /* |
| 395 | * This abort handler always returns "fault". |
| 396 | */ |
| 397 | static int |
| 398 | do_bad(unsigned long addr, unsigned int fsr, struct pt_regs *regs) |
| 399 | { |
| 400 | return 1; |
| 401 | } |
| 402 | |
| 403 | static struct fsr_info { |
| 404 | int (*fn)(unsigned long addr, unsigned int fsr, struct pt_regs *regs); |
| 405 | int sig; |
Russell King | cfb0810 | 2005-06-30 11:06:49 +0100 | [diff] [blame] | 406 | int code; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 407 | const char *name; |
| 408 | } fsr_info[] = { |
| 409 | /* |
| 410 | * The following are the standard ARMv3 and ARMv4 aborts. ARMv5 |
| 411 | * defines these to be "precise" aborts. |
| 412 | */ |
Russell King | cfb0810 | 2005-06-30 11:06:49 +0100 | [diff] [blame] | 413 | { do_bad, SIGSEGV, 0, "vector exception" }, |
| 414 | { do_bad, SIGILL, BUS_ADRALN, "alignment exception" }, |
| 415 | { do_bad, SIGKILL, 0, "terminal exception" }, |
| 416 | { do_bad, SIGILL, BUS_ADRALN, "alignment exception" }, |
| 417 | { do_bad, SIGBUS, 0, "external abort on linefetch" }, |
| 418 | { do_translation_fault, SIGSEGV, SEGV_MAPERR, "section translation fault" }, |
| 419 | { do_bad, SIGBUS, 0, "external abort on linefetch" }, |
| 420 | { do_page_fault, SIGSEGV, SEGV_MAPERR, "page translation fault" }, |
| 421 | { do_bad, SIGBUS, 0, "external abort on non-linefetch" }, |
| 422 | { do_bad, SIGSEGV, SEGV_ACCERR, "section domain fault" }, |
| 423 | { do_bad, SIGBUS, 0, "external abort on non-linefetch" }, |
| 424 | { do_bad, SIGSEGV, SEGV_ACCERR, "page domain fault" }, |
| 425 | { do_bad, SIGBUS, 0, "external abort on translation" }, |
| 426 | { do_sect_fault, SIGSEGV, SEGV_ACCERR, "section permission fault" }, |
| 427 | { do_bad, SIGBUS, 0, "external abort on translation" }, |
| 428 | { do_page_fault, SIGSEGV, SEGV_ACCERR, "page permission fault" }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | /* |
| 430 | * The following are "imprecise" aborts, which are signalled by bit |
| 431 | * 10 of the FSR, and may not be recoverable. These are only |
| 432 | * supported if the CPU abort handler supports bit 10. |
| 433 | */ |
Russell King | cfb0810 | 2005-06-30 11:06:49 +0100 | [diff] [blame] | 434 | { do_bad, SIGBUS, 0, "unknown 16" }, |
| 435 | { do_bad, SIGBUS, 0, "unknown 17" }, |
| 436 | { do_bad, SIGBUS, 0, "unknown 18" }, |
| 437 | { do_bad, SIGBUS, 0, "unknown 19" }, |
| 438 | { do_bad, SIGBUS, 0, "lock abort" }, /* xscale */ |
| 439 | { do_bad, SIGBUS, 0, "unknown 21" }, |
| 440 | { do_bad, SIGBUS, BUS_OBJERR, "imprecise external abort" }, /* xscale */ |
| 441 | { do_bad, SIGBUS, 0, "unknown 23" }, |
| 442 | { do_bad, SIGBUS, 0, "dcache parity error" }, /* xscale */ |
| 443 | { do_bad, SIGBUS, 0, "unknown 25" }, |
| 444 | { do_bad, SIGBUS, 0, "unknown 26" }, |
| 445 | { do_bad, SIGBUS, 0, "unknown 27" }, |
| 446 | { do_bad, SIGBUS, 0, "unknown 28" }, |
| 447 | { do_bad, SIGBUS, 0, "unknown 29" }, |
| 448 | { do_bad, SIGBUS, 0, "unknown 30" }, |
| 449 | { do_bad, SIGBUS, 0, "unknown 31" } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 450 | }; |
| 451 | |
| 452 | void __init |
| 453 | hook_fault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *), |
| 454 | int sig, const char *name) |
| 455 | { |
| 456 | if (nr >= 0 && nr < ARRAY_SIZE(fsr_info)) { |
| 457 | fsr_info[nr].fn = fn; |
| 458 | fsr_info[nr].sig = sig; |
| 459 | fsr_info[nr].name = name; |
| 460 | } |
| 461 | } |
| 462 | |
| 463 | /* |
| 464 | * Dispatch a data abort to the relevant handler. |
| 465 | */ |
Russell King | 7ab3f8d | 2007-03-02 15:01:36 +0000 | [diff] [blame] | 466 | asmlinkage void __exception |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 467 | do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs *regs) |
| 468 | { |
| 469 | const struct fsr_info *inf = fsr_info + (fsr & 15) + ((fsr & (1 << 10)) >> 6); |
Russell King | cfb0810 | 2005-06-30 11:06:49 +0100 | [diff] [blame] | 470 | struct siginfo info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 471 | |
| 472 | if (!inf->fn(addr, fsr, regs)) |
| 473 | return; |
| 474 | |
| 475 | printk(KERN_ALERT "Unhandled fault: %s (0x%03x) at 0x%08lx\n", |
| 476 | inf->name, fsr, addr); |
Russell King | cfb0810 | 2005-06-30 11:06:49 +0100 | [diff] [blame] | 477 | |
| 478 | info.si_signo = inf->sig; |
| 479 | info.si_errno = 0; |
| 480 | info.si_code = inf->code; |
| 481 | info.si_addr = (void __user *)addr; |
Christoph Hellwig | 1eeb66a | 2007-05-08 00:27:03 -0700 | [diff] [blame] | 482 | arm_notify_die("", regs, &info, fsr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | } |
| 484 | |
Russell King | 7ab3f8d | 2007-03-02 15:01:36 +0000 | [diff] [blame] | 485 | asmlinkage void __exception |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | do_PrefetchAbort(unsigned long addr, struct pt_regs *regs) |
| 487 | { |
| 488 | do_translation_fault(addr, 0, regs); |
| 489 | } |
| 490 | |