?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Fix find tids routine by excluding "." and ".."
[cris-mirror.git] / arch / arm / mm / fault.c
blob92f5801f99c1d09c735fb586c9c44bc5df802f13
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 */
11 #include <linux/module.h>
12 #include <linux/signal.h>
13 #include <linux/mm.h>
14 #include <linux/hardirq.h>
15 #include <linux/init.h>
16 #include <linux/kprobes.h>
17 #include <linux/uaccess.h>
18 #include <linux/page-flags.h>
19 #include <linux/sched.h>
20 #include <linux/highmem.h>
21 #include <linux/perf_event.h>
22
23 #include <asm/system.h>
24 #include <asm/pgtable.h>
25 #include <asm/tlbflush.h>
26
27 #include "fault.h"
28
29 /*
30 * Fault status register encodings. We steal bit 31 for our own purposes.
31 */
32 #define FSR_LNX_PF (1 << 31)
33 #define FSR_WRITE (1 << 11)
34 #define FSR_FS4 (1 << 10)
35 #define FSR_FS3_0 (15)
36
37 static inline int fsr_fs(unsigned int fsr)
38 {
39 return (fsr & FSR_FS3_0) | (fsr & FSR_FS4) >> 6;
40 }
41
42 #ifdef CONFIG_MMU
43
44 #ifdef CONFIG_KPROBES
45 static 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
60 static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
61 {
62 return 0;
63 }
64 #endif
65
66 /*
67 * This is useful to dump out the page tables associated with
68 * 'addr' in mm 'mm'.
69 */
70 void 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);
94 if (PTRS_PER_PMD != 1)
95 printk(", *pmd=%08lx", pmd_val(*pmd));
96
97 if (pmd_none(*pmd))
98 break;
99
100 if (pmd_bad(*pmd)) {
101 printk("(bad)");
102 break;
103 }
104
105 /* We must not map this if we have highmem enabled */
106 if (PageHighMem(pfn_to_page(pmd_val(*pmd) >> PAGE_SHIFT)))
107 break;
108
109 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);
113 } while(0);
114
115 printk("\n");
116 }
117 #else /* CONFIG_MMU */
118 void show_pte(struct mm_struct *mm, unsigned long addr)
119 { }
120 #endif /* CONFIG_MMU */
121
122 /*
123 * Oops. The kernel tried to access some page that wasn't present.
124 */
125 static 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 */
154 static void
155 __do_user_fault(struct task_struct *tsk, unsigned long addr,
156 unsigned int fsr, unsigned int sig, int code,
157 struct pt_regs *regs)
158 {
159 struct siginfo si;
160
161 #ifdef CONFIG_DEBUG_USER
162 if (user_debug & UDBG_SEGV) {
163 printk(KERN_DEBUG "%s: unhandled page fault (%d) at 0x%08lx, code 0x%03x\n",
164 tsk->comm, sig, addr, fsr);
165 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;
173 si.si_signo = sig;
174 si.si_errno = 0;
175 si.si_code = code;
176 si.si_addr = (void __user *)addr;
177 force_sig_info(sig, &si, tsk);
178 }
179
180 void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
181 {
182 struct task_struct *tsk = current;
183 struct mm_struct *mm = tsk->active_mm;
184
185 /*
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))
190 __do_user_fault(tsk, addr, fsr, SIGSEGV, SEGV_MAPERR, regs);
191 else
192 __do_kernel_fault(mm, addr, fsr, regs);
193 }
194
195 #ifdef CONFIG_MMU
196 #define VM_FAULT_BADMAP 0x010000
197 #define VM_FAULT_BADACCESS 0x020000
198
199 /*
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 */
204 static 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;
210 if (fsr & FSR_LNX_PF)
211 mask = VM_EXEC;
212
213 return vma->vm_flags & mask ? false : true;
214 }
215
216 static int __kprobes
217 __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;
221 int fault;
222
223 vma = find_vma(mm, addr);
224 fault = VM_FAULT_BADMAP;
225 if (unlikely(!vma))
226 goto out;
227 if (unlikely(vma->vm_start > addr))
228 goto check_stack;
229
230 /*
231 * Ok, we have a good vm_area for this
232 * memory access, so we can handle it.
233 */
234 good_area:
235 if (access_error(fsr, vma)) {
236 fault = VM_FAULT_BADACCESS;
237 goto out;
238 }
239
240 /*
241 * If for any reason at all we couldn't handle the fault, make
242 * sure we exit gracefully rather than endlessly redo the fault.
243 */
244 fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, (fsr & FSR_WRITE) ? FAULT_FLAG_WRITE : 0);
245 if (unlikely(fault & VM_FAULT_ERROR))
246 return fault;
247 if (fault & VM_FAULT_MAJOR)
248 tsk->maj_flt++;
249 else
250 tsk->min_flt++;
251 return fault;
252
253 check_stack:
254 if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
255 goto good_area;
256 out:
257 return fault;
258 }
259
260 static int __kprobes
261 do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
262 {
263 struct task_struct *tsk;
264 struct mm_struct *mm;
265 int fault, sig, code;
266
267 if (notify_page_fault(regs, fsr))
268 return 0;
269
270 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 */
277 if (in_atomic() || !mm)
278 goto no_context;
279
280 /*
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);
289 } 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();
296 #ifdef CONFIG_DEBUG_VM
297 if (!user_mode(regs) &&
298 !search_exception_tables(regs->ARM_pc))
299 goto no_context;
300 #endif
301 }
302
303 fault = __do_page_fault(mm, addr, fsr, tsk);
304 up_read(&mm->mmap_sem);
305
306 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
312 /*
313 * Handle the "normal" case first - VM_FAULT_MAJOR / VM_FAULT_MINOR
314 */
315 if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP | VM_FAULT_BADACCESS))))
316 return 0;
317
318 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
328 /*
329 * 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
335 if (fault & VM_FAULT_SIGBUS) {
336 /*
337 * We had some memory, but were unable to
338 * successfully fix up this page fault.
339 */
340 sig = SIGBUS;
341 code = BUS_ADRERR;
342 } else {
343 /*
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;
350 }
351
352 __do_user_fault(tsk, addr, fsr, sig, code, regs);
353 return 0;
354
355 no_context:
356 __do_kernel_fault(mm, addr, fsr, regs);
357 return 0;
358 }
359 #else /* CONFIG_MMU */
360 static int
361 do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
362 {
363 return 0;
364 }
365 #endif /* CONFIG_MMU */
366
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 */
384 #ifdef CONFIG_MMU
385 static int __kprobes
386 do_translation_fault(unsigned long addr, unsigned int fsr,
387 struct pt_regs *regs)
388 {
389 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
396 index = pgd_index(addr);
397
398 /*
399 * FIXME: CP15 C1 is write only on ARMv3 architectures.
400 */
401 pgd = cpu_get_pgd() + index;
402 pgd_k = init_mm.pgd + index;
403
404 if (pgd_none(*pgd_k))
405 goto bad_area;
406
407 if (!pgd_present(*pgd))
408 set_pgd(pgd, *pgd_k);
409
410 pmd_k = pmd_offset(pgd_k, addr);
411 pmd = pmd_offset(pgd, addr);
412
413 if (pmd_none(*pmd_k))
414 goto bad_area;
415
416 copy_pmd(pmd, pmd_k);
417 return 0;
418
419 bad_area:
420 do_bad_area(addr, fsr, regs);
421 return 0;
422 }
423 #else /* CONFIG_MMU */
424 static int
425 do_translation_fault(unsigned long addr, unsigned int fsr,
426 struct pt_regs *regs)
427 {
428 return 0;
429 }
430 #endif /* CONFIG_MMU */
431
432 /*
433 * Some section permission faults need to be handled gracefully.
434 * They can happen due to a __{get,put}_user during an oops.
435 */
436 static int
437 do_sect_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
438 {
439 do_bad_area(addr, fsr, regs);
440 return 0;
441 }
442
443 /*
444 * This abort handler always returns "fault".
445 */
446 static int
447 do_bad(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
448 {
449 return 1;
450 }
451
452 static struct fsr_info {
453 int (*fn)(unsigned long addr, unsigned int fsr, struct pt_regs *regs);
454 int sig;
455 int code;
456 const char *name;
457 } fsr_info[] = {
458 /*
459 * The following are the standard ARMv3 and ARMv4 aborts. ARMv5
460 * defines these to be "precise" aborts.
461 */
462 { do_bad, SIGSEGV, 0, "vector exception" },
463 { do_bad, SIGILL, BUS_ADRALN, "alignment exception" },
464 { do_bad, SIGKILL, 0, "terminal exception" },
465 { do_bad, SIGILL, BUS_ADRALN, "alignment exception" },
466 /* Do we need runtime check ? */
467 #if __LINUX_ARM_ARCH__ < 6
468 { do_bad, SIGBUS, 0, "external abort on linefetch" },
469 #else
470 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "I-cache maintenance fault" },
471 #endif
472 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "section translation fault" },
473 { do_bad, SIGBUS, 0, "external abort on linefetch" },
474 { do_page_fault, SIGSEGV, SEGV_MAPERR, "page translation fault" },
475 { do_bad, SIGBUS, 0, "external abort on non-linefetch" },
476 { do_bad, SIGSEGV, SEGV_ACCERR, "section domain fault" },
477 { do_bad, SIGBUS, 0, "external abort on non-linefetch" },
478 { do_bad, SIGSEGV, SEGV_ACCERR, "page domain fault" },
479 { do_bad, SIGBUS, 0, "external abort on translation" },
480 { do_sect_fault, SIGSEGV, SEGV_ACCERR, "section permission fault" },
481 { do_bad, SIGBUS, 0, "external abort on translation" },
482 { do_page_fault, SIGSEGV, SEGV_ACCERR, "page permission fault" },
483 /*
484 * The following are "imprecise" aborts, which are signalled by bit
485 * 10 of the FSR, and may not be recoverable. These are only
486 * supported if the CPU abort handler supports bit 10.
487 */
488 { do_bad, SIGBUS, 0, "unknown 16" },
489 { do_bad, SIGBUS, 0, "unknown 17" },
490 { do_bad, SIGBUS, 0, "unknown 18" },
491 { do_bad, SIGBUS, 0, "unknown 19" },
492 { do_bad, SIGBUS, 0, "lock abort" }, /* xscale */
493 { do_bad, SIGBUS, 0, "unknown 21" },
494 { do_bad, SIGBUS, BUS_OBJERR, "imprecise external abort" }, /* xscale */
495 { do_bad, SIGBUS, 0, "unknown 23" },
496 { do_bad, SIGBUS, 0, "dcache parity error" }, /* xscale */
497 { do_bad, SIGBUS, 0, "unknown 25" },
498 { do_bad, SIGBUS, 0, "unknown 26" },
499 { do_bad, SIGBUS, 0, "unknown 27" },
500 { do_bad, SIGBUS, 0, "unknown 28" },
501 { do_bad, SIGBUS, 0, "unknown 29" },
502 { do_bad, SIGBUS, 0, "unknown 30" },
503 { do_bad, SIGBUS, 0, "unknown 31" }
504 };
505
506 void __init
507 hook_fault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *),
508 int sig, const char *name)
509 {
510 if (nr >= 0 && nr < ARRAY_SIZE(fsr_info)) {
511 fsr_info[nr].fn = fn;
512 fsr_info[nr].sig = sig;
513 fsr_info[nr].name = name;
514 }
515 }
516
517 /*
518 * Dispatch a data abort to the relevant handler.
519 */
520 asmlinkage void __exception
521 do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
522 {
523 const struct fsr_info *inf = fsr_info + fsr_fs(fsr);
524 struct siginfo info;
525
526 if (!inf->fn(addr, fsr & ~FSR_LNX_PF, regs))
527 return;
528
529 printk(KERN_ALERT "Unhandled fault: %s (0x%03x) at 0x%08lx\n",
530 inf->name, fsr, addr);
531
532 info.si_signo = inf->sig;
533 info.si_errno = 0;
534 info.si_code = inf->code;
535 info.si_addr = (void __user *)addr;
536 arm_notify_die("", regs, &info, fsr, 0);
537 }
538
539
540 static struct fsr_info ifsr_info[] = {
541 { do_bad, SIGBUS, 0, "unknown 0" },
542 { do_bad, SIGBUS, 0, "unknown 1" },
543 { do_bad, SIGBUS, 0, "debug event" },
544 { do_bad, SIGSEGV, SEGV_ACCERR, "section access flag fault" },
545 { do_bad, SIGBUS, 0, "unknown 4" },
546 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "section translation fault" },
547 { do_bad, SIGSEGV, SEGV_ACCERR, "page access flag fault" },
548 { do_page_fault, SIGSEGV, SEGV_MAPERR, "page translation fault" },
549 { do_bad, SIGBUS, 0, "external abort on non-linefetch" },
550 { do_bad, SIGSEGV, SEGV_ACCERR, "section domain fault" },
551 { do_bad, SIGBUS, 0, "unknown 10" },
552 { do_bad, SIGSEGV, SEGV_ACCERR, "page domain fault" },
553 { do_bad, SIGBUS, 0, "external abort on translation" },
554 { do_sect_fault, SIGSEGV, SEGV_ACCERR, "section permission fault" },
555 { do_bad, SIGBUS, 0, "external abort on translation" },
556 { do_page_fault, SIGSEGV, SEGV_ACCERR, "page permission fault" },
557 { do_bad, SIGBUS, 0, "unknown 16" },
558 { do_bad, SIGBUS, 0, "unknown 17" },
559 { do_bad, SIGBUS, 0, "unknown 18" },
560 { do_bad, SIGBUS, 0, "unknown 19" },
561 { do_bad, SIGBUS, 0, "unknown 20" },
562 { do_bad, SIGBUS, 0, "unknown 21" },
563 { do_bad, SIGBUS, 0, "unknown 22" },
564 { do_bad, SIGBUS, 0, "unknown 23" },
565 { do_bad, SIGBUS, 0, "unknown 24" },
566 { do_bad, SIGBUS, 0, "unknown 25" },
567 { do_bad, SIGBUS, 0, "unknown 26" },
568 { do_bad, SIGBUS, 0, "unknown 27" },
569 { do_bad, SIGBUS, 0, "unknown 28" },
570 { do_bad, SIGBUS, 0, "unknown 29" },
571 { do_bad, SIGBUS, 0, "unknown 30" },
572 { do_bad, SIGBUS, 0, "unknown 31" },
573 };
574
575 asmlinkage void __exception
576 do_PrefetchAbort(unsigned long addr, unsigned int ifsr, struct pt_regs *regs)
577 {
578 const struct fsr_info *inf = ifsr_info + fsr_fs(ifsr);
579 struct siginfo info;
580
581 if (!inf->fn(addr, ifsr | FSR_LNX_PF, regs))
582 return;
583
584 printk(KERN_ALERT "Unhandled prefetch abort: %s (0x%03x) at 0x%08lx\n",
585 inf->name, ifsr, addr);
586
587 info.si_signo = inf->sig;
588 info.si_errno = 0;
589 info.si_code = inf->code;
590 info.si_addr = (void __user *)addr;
591 arm_notify_die("", regs, &info, ifsr, 0);
592 }
593
CRIS linux kernel tree