blob: 1e21e125fe3a833fadcc932c8fcf01177d7ba8f2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/module.h>
12#include <linux/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/mm.h>
Russell King67306da2008-12-14 18:01:44 +000014#include <linux/hardirq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/init.h>
Nicolas Pitre25ce1dd2007-12-03 15:21:57 -050016#include <linux/kprobes.h>
Russell King33fa9b12008-09-06 11:35:55 +010017#include <linux/uaccess.h>
Nicolas Pitre252d4c22008-09-11 11:52:02 -040018#include <linux/page-flags.h>
Catalin Marinas412bb0a2009-07-24 12:37:09 +010019#include <linux/sched.h>
Russell King65cec8e2009-08-17 20:02:06 +010020#include <linux/highmem.h>
Jamie Iles7ada1892010-02-02 20:24:58 +010021#include <linux/perf_event.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23#include <asm/system.h>
24#include <asm/pgtable.h>
25#include <asm/tlbflush.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#include "fault.h"
28
Russell Kingc88d6aa2009-09-20 12:41:58 +010029/*
Russell Kingdf297bf2009-09-20 13:18:47 +010030 * Fault status register encodings. We steal bit 31 for our own purposes.
Russell Kingc88d6aa2009-09-20 12:41:58 +010031 */
Russell Kingdf297bf2009-09-20 13:18:47 +010032#define FSR_LNX_PF (1 << 31)
Russell Kingc88d6aa2009-09-20 12:41:58 +010033#define FSR_WRITE (1 << 11)
34#define FSR_FS4 (1 << 10)
35#define FSR_FS3_0 (15)
36
37static inline int fsr_fs(unsigned int fsr)
38{
39 return (fsr & FSR_FS3_0) | (fsr & FSR_FS4) >> 6;
40}
41
Catalin Marinas09529f72009-07-24 12:34:55 +010042#ifdef CONFIG_MMU
Nicolas Pitre25ce1dd2007-12-03 15:21:57 -050043
44#ifdef CONFIG_KPROBES
45static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
46{
47 int ret = 0;
48
49 if (!user_mode(regs)) {
50 /* kprobe_running() needs smp_processor_id() */
51 preempt_disable();
52 if (kprobe_running() && kprobe_fault_handler(regs, fsr))
53 ret = 1;
54 preempt_enable();
55 }
56
57 return ret;
58}
59#else
60static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
61{
62 return 0;
63}
64#endif
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066/*
67 * This is useful to dump out the page tables associated with
68 * 'addr' in mm 'mm'.
69 */
70void show_pte(struct mm_struct *mm, unsigned long addr)
71{
72 pgd_t *pgd;
73
74 if (!mm)
75 mm = &init_mm;
76
77 printk(KERN_ALERT "pgd = %p\n", mm->pgd);
78 pgd = pgd_offset(mm, addr);
79 printk(KERN_ALERT "[%08lx] *pgd=%08lx", addr, pgd_val(*pgd));
80
81 do {
82 pmd_t *pmd;
83 pte_t *pte;
84
85 if (pgd_none(*pgd))
86 break;
87
88 if (pgd_bad(*pgd)) {
89 printk("(bad)");
90 break;
91 }
92
93 pmd = pmd_offset(pgd, addr);
Nicolas Pitreda46c792008-09-30 16:10:11 +010094 if (PTRS_PER_PMD != 1)
95 printk(", *pmd=%08lx", pmd_val(*pmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
97 if (pmd_none(*pmd))
98 break;
99
100 if (pmd_bad(*pmd)) {
101 printk("(bad)");
102 break;
103 }
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 /* We must not map this if we have highmem enabled */
Nicolas Pitre252d4c22008-09-11 11:52:02 -0400106 if (PageHighMem(pfn_to_page(pmd_val(*pmd) >> PAGE_SHIFT)))
107 break;
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 pte = pte_offset_map(pmd, addr);
110 printk(", *pte=%08lx", pte_val(*pte));
111 printk(", *ppte=%08lx", pte_val(pte[-PTRS_PER_PTE]));
112 pte_unmap(pte);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 } while(0);
114
115 printk("\n");
116}
Catalin Marinas09529f72009-07-24 12:34:55 +0100117#else /* CONFIG_MMU */
118void show_pte(struct mm_struct *mm, unsigned long addr)
119{ }
120#endif /* CONFIG_MMU */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
122/*
123 * Oops. The kernel tried to access some page that wasn't present.
124 */
125static void
126__do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
127 struct pt_regs *regs)
128{
129 /*
130 * Are we prepared to handle this kernel fault?
131 */
132 if (fixup_exception(regs))
133 return;
134
135 /*
136 * No handler, we'll have to terminate things with extreme prejudice.
137 */
138 bust_spinlocks(1);
139 printk(KERN_ALERT
140 "Unable to handle kernel %s at virtual address %08lx\n",
141 (addr < PAGE_SIZE) ? "NULL pointer dereference" :
142 "paging request", addr);
143
144 show_pte(mm, addr);
145 die("Oops", regs, fsr);
146 bust_spinlocks(0);
147 do_exit(SIGKILL);
148}
149
150/*
151 * Something tried to access memory that isn't in our memory map..
152 * User mode accesses just cause a SIGSEGV
153 */
154static void
155__do_user_fault(struct task_struct *tsk, unsigned long addr,
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700156 unsigned int fsr, unsigned int sig, int code,
157 struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158{
159 struct siginfo si;
160
161#ifdef CONFIG_DEBUG_USER
162 if (user_debug & UDBG_SEGV) {
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700163 printk(KERN_DEBUG "%s: unhandled page fault (%d) at 0x%08lx, code 0x%03x\n",
164 tsk->comm, sig, addr, fsr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 show_pte(tsk->mm, addr);
166 show_regs(regs);
167 }
168#endif
169
170 tsk->thread.address = addr;
171 tsk->thread.error_code = fsr;
172 tsk->thread.trap_no = 14;
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700173 si.si_signo = sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 si.si_errno = 0;
175 si.si_code = code;
176 si.si_addr = (void __user *)addr;
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700177 force_sig_info(sig, &si, tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
Russell Kinge5beac32006-09-27 16:13:48 +0100180void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
Russell Kinge5beac32006-09-27 16:13:48 +0100182 struct task_struct *tsk = current;
183 struct mm_struct *mm = tsk->active_mm;
184
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 /*
186 * If we are in kernel mode at this point, we
187 * have no context to handle this fault with.
188 */
189 if (user_mode(regs))
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700190 __do_user_fault(tsk, addr, fsr, SIGSEGV, SEGV_MAPERR, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 else
192 __do_kernel_fault(mm, addr, fsr, regs);
193}
194
Catalin Marinas09529f72009-07-24 12:34:55 +0100195#ifdef CONFIG_MMU
Nick Piggin5c72fc52007-07-20 09:21:06 +0200196#define VM_FAULT_BADMAP 0x010000
197#define VM_FAULT_BADACCESS 0x020000
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Russell Kingd374bf12009-09-20 12:53:01 +0100199/*
200 * Check that the permissions on the VMA allow for the fault which occurred.
201 * If we encountered a write fault, we must have write permission, otherwise
202 * we allow any permission.
203 */
204static inline bool access_error(unsigned int fsr, struct vm_area_struct *vma)
205{
206 unsigned int mask = VM_READ | VM_WRITE | VM_EXEC;
207
208 if (fsr & FSR_WRITE)
209 mask = VM_WRITE;
Russell Kingdf297bf2009-09-20 13:18:47 +0100210 if (fsr & FSR_LNX_PF)
211 mask = VM_EXEC;
Russell Kingd374bf12009-09-20 12:53:01 +0100212
213 return vma->vm_flags & mask ? false : true;
214}
215
216static int __kprobes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217__do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
218 struct task_struct *tsk)
219{
220 struct vm_area_struct *vma;
Russell Kingd374bf12009-09-20 12:53:01 +0100221 int fault;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 vma = find_vma(mm, addr);
224 fault = VM_FAULT_BADMAP;
Russell Kingd374bf12009-09-20 12:53:01 +0100225 if (unlikely(!vma))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 goto out;
Russell Kingd374bf12009-09-20 12:53:01 +0100227 if (unlikely(vma->vm_start > addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 goto check_stack;
229
230 /*
231 * Ok, we have a good vm_area for this
232 * memory access, so we can handle it.
233 */
234good_area:
Russell Kingd374bf12009-09-20 12:53:01 +0100235 if (access_error(fsr, vma)) {
236 fault = VM_FAULT_BADACCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 goto out;
Russell Kingd374bf12009-09-20 12:53:01 +0100238 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
240 /*
Russell Kingb42c6342009-09-20 12:47:40 +0100241 * If for any reason at all we couldn't handle the fault, make
242 * sure we exit gracefully rather than endlessly redo the fault.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 */
Russell Kingc88d6aa2009-09-20 12:41:58 +0100244 fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, (fsr & FSR_WRITE) ? FAULT_FLAG_WRITE : 0);
Russell Kingb42c6342009-09-20 12:47:40 +0100245 if (unlikely(fault & VM_FAULT_ERROR))
246 return fault;
Nick Piggin83c54072007-07-19 01:47:05 -0700247 if (fault & VM_FAULT_MAJOR)
248 tsk->maj_flt++;
249 else
250 tsk->min_flt++;
251 return fault;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253check_stack:
254 if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
255 goto good_area;
256out:
257 return fault;
258}
259
Nicolas Pitre785d3cd2007-12-03 15:27:56 -0500260static int __kprobes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
262{
263 struct task_struct *tsk;
264 struct mm_struct *mm;
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700265 int fault, sig, code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Nicolas Pitre25ce1dd2007-12-03 15:21:57 -0500267 if (notify_page_fault(regs, fsr))
268 return 0;
269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 tsk = current;
271 mm = tsk->mm;
272
273 /*
274 * If we're in an interrupt or have no user
275 * context, we must not take the fault..
276 */
Peter Zijlstra6edaf682006-12-06 20:32:18 -0800277 if (in_atomic() || !mm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 goto no_context;
279
Russell King840ff6a2005-09-20 17:52:13 +0100280 /*
281 * As per x86, we may deadlock here. However, since the kernel only
282 * validly references user space from well defined areas of the code,
283 * we can bug out early if this is from code which shouldn't.
284 */
285 if (!down_read_trylock(&mm->mmap_sem)) {
286 if (!user_mode(regs) && !search_exception_tables(regs->ARM_pc))
287 goto no_context;
288 down_read(&mm->mmap_sem);
Russell Kingbf4569922009-09-20 12:52:19 +0100289 } else {
290 /*
291 * The above down_read_trylock() might have succeeded in
292 * which case, we'll have missed the might_sleep() from
293 * down_read()
294 */
295 might_sleep();
Imre Deak1d212712009-10-05 13:40:44 +0100296#ifdef CONFIG_DEBUG_VM
297 if (!user_mode(regs) &&
298 !search_exception_tables(regs->ARM_pc))
299 goto no_context;
300#endif
Russell King840ff6a2005-09-20 17:52:13 +0100301 }
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 fault = __do_page_fault(mm, addr, fsr, tsk);
304 up_read(&mm->mmap_sem);
305
Jamie Iles7ada1892010-02-02 20:24:58 +0100306 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, 0, regs, addr);
307 if (fault & VM_FAULT_MAJOR)
308 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, 0, regs, addr);
309 else if (fault & VM_FAULT_MINOR)
310 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, 0, regs, addr);
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 /*
Russell Kingff2afb92005-08-04 14:17:33 +0100313 * Handle the "normal" case first - VM_FAULT_MAJOR / VM_FAULT_MINOR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 */
Nick Piggin5c72fc52007-07-20 09:21:06 +0200315 if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP | VM_FAULT_BADACCESS))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 return 0;
317
Russell Kingb42c6342009-09-20 12:47:40 +0100318 if (fault & VM_FAULT_OOM) {
319 /*
320 * We ran out of memory, call the OOM killer, and return to
321 * userspace (which will retry the fault, or kill us if we
322 * got oom-killed)
323 */
324 pagefault_out_of_memory();
325 return 0;
326 }
327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 * If we are in kernel mode at this point, we
330 * have no context to handle this fault with.
331 */
332 if (!user_mode(regs))
333 goto no_context;
334
Nick Piggin83c54072007-07-19 01:47:05 -0700335 if (fault & VM_FAULT_SIGBUS) {
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700336 /*
337 * We had some memory, but were unable to
338 * successfully fix up this page fault.
339 */
340 sig = SIGBUS;
341 code = BUS_ADRERR;
Nick Piggin83c54072007-07-19 01:47:05 -0700342 } else {
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700343 /*
344 * Something tried to access memory that
345 * isn't in our memory map..
346 */
347 sig = SIGSEGV;
348 code = fault == VM_FAULT_BADACCESS ?
349 SEGV_ACCERR : SEGV_MAPERR;
akpm@osdl.org2d137c22005-04-16 15:23:55 -0700350 }
351
352 __do_user_fault(tsk, addr, fsr, sig, code, regs);
353 return 0;
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355no_context:
356 __do_kernel_fault(mm, addr, fsr, regs);
357 return 0;
358}
Catalin Marinas09529f72009-07-24 12:34:55 +0100359#else /* CONFIG_MMU */
360static int
361do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
362{
363 return 0;
364}
365#endif /* CONFIG_MMU */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367/*
368 * First Level Translation Fault Handler
369 *
370 * We enter here because the first level page table doesn't contain
371 * a valid entry for the address.
372 *
373 * If the address is in kernel space (>= TASK_SIZE), then we are
374 * probably faulting in the vmalloc() area.
375 *
376 * If the init_task's first level page tables contains the relevant
377 * entry, we copy the it to this task. If not, we send the process
378 * a signal, fixup the exception, or oops the kernel.
379 *
380 * NOTE! We MUST NOT take any locks for this case. We may be in an
381 * interrupt or a critical region, and should only copy the information
382 * from the master page table, nothing more.
383 */
Catalin Marinas09529f72009-07-24 12:34:55 +0100384#ifdef CONFIG_MMU
Nicolas Pitre785d3cd2007-12-03 15:27:56 -0500385static int __kprobes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386do_translation_fault(unsigned long addr, unsigned int fsr,
387 struct pt_regs *regs)
388{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 unsigned int index;
390 pgd_t *pgd, *pgd_k;
391 pmd_t *pmd, *pmd_k;
392
393 if (addr < TASK_SIZE)
394 return do_page_fault(addr, fsr, regs);
395
Anfei5e27fb72010-06-08 15:16:49 +0100396 if (user_mode(regs))
397 goto bad_area;
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 index = pgd_index(addr);
400
401 /*
402 * FIXME: CP15 C1 is write only on ARMv3 architectures.
403 */
404 pgd = cpu_get_pgd() + index;
405 pgd_k = init_mm.pgd + index;
406
407 if (pgd_none(*pgd_k))
408 goto bad_area;
409
410 if (!pgd_present(*pgd))
411 set_pgd(pgd, *pgd_k);
412
413 pmd_k = pmd_offset(pgd_k, addr);
414 pmd = pmd_offset(pgd, addr);
415
Kirill A. Shutemov33a9c412010-07-22 13:20:22 +0100416 /*
417 * On ARM one Linux PGD entry contains two hardware entries (see page
418 * tables layout in pgtable.h). We normally guarantee that we always
419 * fill both L1 entries. But create_mapping() doesn't follow the rule.
420 * It can create inidividual L1 entries, so here we have to call
421 * pmd_none() check for the entry really corresponded to address, not
422 * for the first of pair.
423 */
424 index = (addr >> SECTION_SHIFT) & 1;
425 if (pmd_none(pmd_k[index]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 goto bad_area;
427
428 copy_pmd(pmd, pmd_k);
429 return 0;
430
431bad_area:
Russell Kinge5beac32006-09-27 16:13:48 +0100432 do_bad_area(addr, fsr, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 return 0;
434}
Catalin Marinas09529f72009-07-24 12:34:55 +0100435#else /* CONFIG_MMU */
436static int
437do_translation_fault(unsigned long addr, unsigned int fsr,
438 struct pt_regs *regs)
439{
440 return 0;
441}
442#endif /* CONFIG_MMU */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444/*
445 * Some section permission faults need to be handled gracefully.
446 * They can happen due to a __{get,put}_user during an oops.
447 */
448static int
449do_sect_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
450{
Russell Kinge5beac32006-09-27 16:13:48 +0100451 do_bad_area(addr, fsr, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return 0;
453}
454
455/*
456 * This abort handler always returns "fault".
457 */
458static int
459do_bad(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
460{
461 return 1;
462}
463
464static struct fsr_info {
465 int (*fn)(unsigned long addr, unsigned int fsr, struct pt_regs *regs);
466 int sig;
Russell Kingcfb08102005-06-30 11:06:49 +0100467 int code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 const char *name;
469} fsr_info[] = {
470 /*
471 * The following are the standard ARMv3 and ARMv4 aborts. ARMv5
472 * defines these to be "precise" aborts.
473 */
Russell Kingcfb08102005-06-30 11:06:49 +0100474 { do_bad, SIGSEGV, 0, "vector exception" },
Kirill A. Shutemov3dc91af2010-07-22 13:16:49 +0100475 { do_bad, SIGBUS, BUS_ADRALN, "alignment exception" },
Russell Kingcfb08102005-06-30 11:06:49 +0100476 { do_bad, SIGKILL, 0, "terminal exception" },
Kirill A. Shutemov3dc91af2010-07-22 13:16:49 +0100477 { do_bad, SIGBUS, BUS_ADRALN, "alignment exception" },
Russell Kingcfb08102005-06-30 11:06:49 +0100478 { do_bad, SIGBUS, 0, "external abort on linefetch" },
479 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "section translation fault" },
480 { do_bad, SIGBUS, 0, "external abort on linefetch" },
481 { do_page_fault, SIGSEGV, SEGV_MAPERR, "page translation fault" },
482 { do_bad, SIGBUS, 0, "external abort on non-linefetch" },
483 { do_bad, SIGSEGV, SEGV_ACCERR, "section domain fault" },
484 { do_bad, SIGBUS, 0, "external abort on non-linefetch" },
485 { do_bad, SIGSEGV, SEGV_ACCERR, "page domain fault" },
486 { do_bad, SIGBUS, 0, "external abort on translation" },
487 { do_sect_fault, SIGSEGV, SEGV_ACCERR, "section permission fault" },
488 { do_bad, SIGBUS, 0, "external abort on translation" },
489 { do_page_fault, SIGSEGV, SEGV_ACCERR, "page permission fault" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 /*
491 * The following are "imprecise" aborts, which are signalled by bit
492 * 10 of the FSR, and may not be recoverable. These are only
493 * supported if the CPU abort handler supports bit 10.
494 */
Russell Kingcfb08102005-06-30 11:06:49 +0100495 { do_bad, SIGBUS, 0, "unknown 16" },
496 { do_bad, SIGBUS, 0, "unknown 17" },
497 { do_bad, SIGBUS, 0, "unknown 18" },
498 { do_bad, SIGBUS, 0, "unknown 19" },
499 { do_bad, SIGBUS, 0, "lock abort" }, /* xscale */
500 { do_bad, SIGBUS, 0, "unknown 21" },
501 { do_bad, SIGBUS, BUS_OBJERR, "imprecise external abort" }, /* xscale */
502 { do_bad, SIGBUS, 0, "unknown 23" },
503 { do_bad, SIGBUS, 0, "dcache parity error" }, /* xscale */
504 { do_bad, SIGBUS, 0, "unknown 25" },
505 { do_bad, SIGBUS, 0, "unknown 26" },
506 { do_bad, SIGBUS, 0, "unknown 27" },
507 { do_bad, SIGBUS, 0, "unknown 28" },
508 { do_bad, SIGBUS, 0, "unknown 29" },
509 { do_bad, SIGBUS, 0, "unknown 30" },
510 { do_bad, SIGBUS, 0, "unknown 31" }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511};
512
513void __init
514hook_fault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *),
Kirill A. Shutemov6338a6a2010-07-22 13:18:19 +0100515 int sig, int code, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
Kirill A. Shutemov6338a6a2010-07-22 13:18:19 +0100517 if (nr < 0 || nr >= ARRAY_SIZE(fsr_info))
518 BUG();
519
520 fsr_info[nr].fn = fn;
521 fsr_info[nr].sig = sig;
522 fsr_info[nr].code = code;
523 fsr_info[nr].name = name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
526/*
527 * Dispatch a data abort to the relevant handler.
528 */
Russell King7ab3f8d2007-03-02 15:01:36 +0000529asmlinkage void __exception
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
531{
Russell Kingc88d6aa2009-09-20 12:41:58 +0100532 const struct fsr_info *inf = fsr_info + fsr_fs(fsr);
Russell Kingcfb08102005-06-30 11:06:49 +0100533 struct siginfo info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Russell Kingdf297bf2009-09-20 13:18:47 +0100535 if (!inf->fn(addr, fsr & ~FSR_LNX_PF, regs))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 return;
537
538 printk(KERN_ALERT "Unhandled fault: %s (0x%03x) at 0x%08lx\n",
539 inf->name, fsr, addr);
Russell Kingcfb08102005-06-30 11:06:49 +0100540
541 info.si_signo = inf->sig;
542 info.si_errno = 0;
543 info.si_code = inf->code;
544 info.si_addr = (void __user *)addr;
Christoph Hellwig1eeb66a2007-05-08 00:27:03 -0700545 arm_notify_die("", regs, &info, fsr, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
Kirill A. Shutemovd25ef8b2009-09-25 13:40:49 +0100548
549static struct fsr_info ifsr_info[] = {
550 { do_bad, SIGBUS, 0, "unknown 0" },
551 { do_bad, SIGBUS, 0, "unknown 1" },
552 { do_bad, SIGBUS, 0, "debug event" },
553 { do_bad, SIGSEGV, SEGV_ACCERR, "section access flag fault" },
554 { do_bad, SIGBUS, 0, "unknown 4" },
555 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "section translation fault" },
556 { do_bad, SIGSEGV, SEGV_ACCERR, "page access flag fault" },
557 { do_page_fault, SIGSEGV, SEGV_MAPERR, "page translation fault" },
558 { do_bad, SIGBUS, 0, "external abort on non-linefetch" },
559 { do_bad, SIGSEGV, SEGV_ACCERR, "section domain fault" },
560 { do_bad, SIGBUS, 0, "unknown 10" },
561 { do_bad, SIGSEGV, SEGV_ACCERR, "page domain fault" },
562 { do_bad, SIGBUS, 0, "external abort on translation" },
563 { do_sect_fault, SIGSEGV, SEGV_ACCERR, "section permission fault" },
564 { do_bad, SIGBUS, 0, "external abort on translation" },
565 { do_page_fault, SIGSEGV, SEGV_ACCERR, "page permission fault" },
566 { do_bad, SIGBUS, 0, "unknown 16" },
567 { do_bad, SIGBUS, 0, "unknown 17" },
568 { do_bad, SIGBUS, 0, "unknown 18" },
569 { do_bad, SIGBUS, 0, "unknown 19" },
570 { do_bad, SIGBUS, 0, "unknown 20" },
571 { do_bad, SIGBUS, 0, "unknown 21" },
572 { do_bad, SIGBUS, 0, "unknown 22" },
573 { do_bad, SIGBUS, 0, "unknown 23" },
574 { do_bad, SIGBUS, 0, "unknown 24" },
575 { do_bad, SIGBUS, 0, "unknown 25" },
576 { do_bad, SIGBUS, 0, "unknown 26" },
577 { do_bad, SIGBUS, 0, "unknown 27" },
578 { do_bad, SIGBUS, 0, "unknown 28" },
579 { do_bad, SIGBUS, 0, "unknown 29" },
580 { do_bad, SIGBUS, 0, "unknown 30" },
581 { do_bad, SIGBUS, 0, "unknown 31" },
582};
583
Will Deacon3a4b5dc2010-09-03 10:39:59 +0100584void __init
585hook_ifault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *),
586 int sig, int code, const char *name)
587{
588 if (nr < 0 || nr >= ARRAY_SIZE(ifsr_info))
589 BUG();
590
591 ifsr_info[nr].fn = fn;
592 ifsr_info[nr].sig = sig;
593 ifsr_info[nr].code = code;
594 ifsr_info[nr].name = name;
595}
596
Russell King7ab3f8d2007-03-02 15:01:36 +0000597asmlinkage void __exception
Kirill A. Shutemov4fb28472009-09-25 13:39:47 +0100598do_PrefetchAbort(unsigned long addr, unsigned int ifsr, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599{
Kirill A. Shutemovd25ef8b2009-09-25 13:40:49 +0100600 const struct fsr_info *inf = ifsr_info + fsr_fs(ifsr);
601 struct siginfo info;
602
603 if (!inf->fn(addr, ifsr | FSR_LNX_PF, regs))
604 return;
605
606 printk(KERN_ALERT "Unhandled prefetch abort: %s (0x%03x) at 0x%08lx\n",
607 inf->name, ifsr, addr);
608
609 info.si_signo = inf->sig;
610 info.si_errno = 0;
611 info.si_code = inf->code;
612 info.si_addr = (void __user *)addr;
613 arm_notify_die("", regs, &info, ifsr, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614}
615
Kirill A. Shutemov993bf4e2010-07-22 13:23:25 +0100616static int __init exceptions_init(void)
617{
618 if (cpu_architecture() >= CPU_ARCH_ARMv6) {
619 hook_fault_code(4, do_translation_fault, SIGSEGV, SEGV_MAPERR,
620 "I-cache maintenance fault");
621 }
622
Kirill A. Shutemovb8ab5392010-07-26 11:20:41 +0100623 if (cpu_architecture() >= CPU_ARCH_ARMv7) {
624 /*
625 * TODO: Access flag faults introduced in ARMv6K.
626 * Runtime check for 'K' extension is needed
627 */
628 hook_fault_code(3, do_bad, SIGSEGV, SEGV_MAPERR,
629 "section access flag fault");
630 hook_fault_code(6, do_bad, SIGSEGV, SEGV_MAPERR,
631 "section access flag fault");
632 }
633
Kirill A. Shutemov993bf4e2010-07-22 13:23:25 +0100634 return 0;
635}
636
637arch_initcall(exceptions_init);