arm: Invalidate BTB on prefetch abort outside of user mapping on Cortex A8, A9, A12...
[linux-3.10.git] / arch / arm / mm / fault.c
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/cp15.h>
24 #include <asm/exception.h>
25 #include <asm/pgtable.h>
26 #include <asm/system_misc.h>
27 #include <asm/system_info.h>
28 #include <asm/tlbflush.h>
29
30 #include "fault.h"
31
32 #ifdef CONFIG_MMU
33
34 #ifdef CONFIG_KPROBES
35 static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
36 {
37         int ret = 0;
38
39         if (!user_mode(regs)) {
40                 /* kprobe_running() needs smp_processor_id() */
41                 preempt_disable();
42                 if (kprobe_running() && kprobe_fault_handler(regs, fsr))
43                         ret = 1;
44                 preempt_enable();
45         }
46
47         return ret;
48 }
49 #else
50 static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
51 {
52         return 0;
53 }
54 #endif
55
56 /*
57  * This is useful to dump out the page tables associated with
58  * 'addr' in mm 'mm'.
59  */
60 void show_pte(struct mm_struct *mm, unsigned long addr)
61 {
62         pgd_t *pgd;
63
64         if (!mm)
65                 mm = &init_mm;
66
67         printk(KERN_ALERT "pgd = %p\n", mm->pgd);
68         pgd = pgd_offset(mm, addr);
69         printk(KERN_ALERT "[%08lx] *pgd=%08llx",
70                         addr, (long long)pgd_val(*pgd));
71
72         do {
73                 pud_t *pud;
74                 pmd_t *pmd;
75                 pte_t *pte;
76
77                 if (pgd_none(*pgd))
78                         break;
79
80                 if (pgd_bad(*pgd)) {
81                         printk("(bad)");
82                         break;
83                 }
84
85                 pud = pud_offset(pgd, addr);
86                 if (PTRS_PER_PUD != 1)
87                         printk(", *pud=%08llx", (long long)pud_val(*pud));
88
89                 if (pud_none(*pud))
90                         break;
91
92                 if (pud_bad(*pud)) {
93                         printk("(bad)");
94                         break;
95                 }
96
97                 pmd = pmd_offset(pud, addr);
98                 if (PTRS_PER_PMD != 1)
99                         printk(", *pmd=%08llx", (long long)pmd_val(*pmd));
100
101                 if (pmd_none(*pmd))
102                         break;
103
104                 if (pmd_bad(*pmd)) {
105                         printk("(bad)");
106                         break;
107                 }
108
109                 /* We must not map this if we have highmem enabled */
110                 if (PageHighMem(pfn_to_page(pmd_val(*pmd) >> PAGE_SHIFT)))
111                         break;
112
113                 pte = pte_offset_map(pmd, addr);
114                 printk(", *pte=%08llx", (long long)pte_val(*pte));
115 #ifndef CONFIG_ARM_LPAE
116                 printk(", *ppte=%08llx",
117                        (long long)pte_val(pte[PTE_HWTABLE_PTRS]));
118 #endif
119                 pte_unmap(pte);
120         } while(0);
121
122         printk("\n");
123 }
124 #else                                   /* CONFIG_MMU */
125 void show_pte(struct mm_struct *mm, unsigned long addr)
126 { }
127 #endif                                  /* CONFIG_MMU */
128
129 /*
130  * Oops.  The kernel tried to access some page that wasn't present.
131  */
132 static void
133 __do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
134                   struct pt_regs *regs)
135 {
136         /*
137          * Are we prepared to handle this kernel fault?
138          */
139         if (fixup_exception(regs))
140                 return;
141
142         /*
143          * No handler, we'll have to terminate things with extreme prejudice.
144          */
145         bust_spinlocks(1);
146         printk(KERN_ALERT
147                 "Unable to handle kernel %s at virtual address %08lx\n",
148                 (addr < PAGE_SIZE) ? "NULL pointer dereference" :
149                 "paging request", addr);
150
151         show_pte(mm, addr);
152         die("Oops", regs, fsr);
153         bust_spinlocks(0);
154         do_exit(SIGKILL);
155 }
156
157 /*
158  * Something tried to access memory that isn't in our memory map..
159  * User mode accesses just cause a SIGSEGV
160  */
161 static void
162 __do_user_fault(struct task_struct *tsk, unsigned long addr,
163                 unsigned int fsr, unsigned int sig, int code,
164                 struct pt_regs *regs)
165 {
166         struct siginfo si;
167
168 #ifdef CONFIG_DEBUG_USER
169         if (((user_debug & UDBG_SEGV) && (sig == SIGSEGV)) ||
170             ((user_debug & UDBG_BUS)  && (sig == SIGBUS))) {
171                 printk(KERN_DEBUG "%s: unhandled page fault (%d) at 0x%08lx, code 0x%03x\n",
172                        tsk->comm, sig, addr, fsr);
173                 show_pte(tsk->mm, addr);
174                 show_regs(regs);
175         }
176 #endif
177
178         tsk->thread.address = addr;
179         tsk->thread.error_code = fsr;
180         tsk->thread.trap_no = 14;
181         si.si_signo = sig;
182         si.si_errno = 0;
183         si.si_code = code;
184         si.si_addr = (void __user *)addr;
185         force_sig_info(sig, &si, tsk);
186 }
187
188 void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
189 {
190         struct task_struct *tsk = current;
191         struct mm_struct *mm = tsk->active_mm;
192
193         /*
194          * If we are in kernel mode at this point, we
195          * have no context to handle this fault with.
196          */
197         if (user_mode(regs))
198                 __do_user_fault(tsk, addr, fsr, SIGSEGV, SEGV_MAPERR, regs);
199         else
200                 __do_kernel_fault(mm, addr, fsr, regs);
201 }
202
203 #ifdef CONFIG_MMU
204 #define VM_FAULT_BADMAP         0x010000
205 #define VM_FAULT_BADACCESS      0x020000
206
207 /*
208  * Check that the permissions on the VMA allow for the fault which occurred.
209  * If we encountered a write fault, we must have write permission, otherwise
210  * we allow any permission.
211  */
212 static inline bool access_error(unsigned int fsr, struct vm_area_struct *vma)
213 {
214         unsigned int mask = VM_READ | VM_WRITE | VM_EXEC;
215
216         if (fsr & FSR_WRITE)
217                 mask = VM_WRITE;
218         if (fsr & FSR_LNX_PF)
219                 mask = VM_EXEC;
220
221         return vma->vm_flags & mask ? false : true;
222 }
223
224 static int __kprobes
225 __do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
226                 unsigned int flags, struct task_struct *tsk)
227 {
228         struct vm_area_struct *vma;
229         int fault;
230
231         vma = find_vma(mm, addr);
232         fault = VM_FAULT_BADMAP;
233         if (unlikely(!vma))
234                 goto out;
235         if (unlikely(vma->vm_start > addr))
236                 goto check_stack;
237
238         /*
239          * Ok, we have a good vm_area for this
240          * memory access, so we can handle it.
241          */
242 good_area:
243         if (access_error(fsr, vma)) {
244                 fault = VM_FAULT_BADACCESS;
245                 goto out;
246         }
247
248         return handle_mm_fault(mm, vma, addr & PAGE_MASK, flags);
249
250 check_stack:
251         /* Don't allow expansion below FIRST_USER_ADDRESS */
252         if (vma->vm_flags & VM_GROWSDOWN &&
253             addr >= FIRST_USER_ADDRESS && !expand_stack(vma, addr))
254                 goto good_area;
255 out:
256         return fault;
257 }
258
259 static int __kprobes
260 do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
261 {
262         struct task_struct *tsk;
263         struct mm_struct *mm;
264         int fault, sig, code;
265         unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
266
267         if (notify_page_fault(regs, fsr))
268                 return 0;
269
270         tsk = current;
271         mm  = tsk->mm;
272
273         /* Enable interrupts if they were enabled in the parent context. */
274         if (interrupts_enabled(regs))
275                 local_irq_enable();
276
277         /*
278          * If we're in an interrupt, or have no irqs, or have no user
279          * context, we must not take the fault..
280          */
281         if (in_atomic() || irqs_disabled() || !mm)
282                 goto no_context;
283
284         if (user_mode(regs))
285                 flags |= FAULT_FLAG_USER;
286         if (fsr & FSR_WRITE)
287                 flags |= FAULT_FLAG_WRITE;
288
289         /*
290          * As per x86, we may deadlock here.  However, since the kernel only
291          * validly references user space from well defined areas of the code,
292          * we can bug out early if this is from code which shouldn't.
293          */
294         if (!down_read_trylock(&mm->mmap_sem)) {
295                 if (!user_mode(regs) && !search_exception_tables(regs->ARM_pc))
296                         goto no_context;
297 retry:
298                 down_read(&mm->mmap_sem);
299         } else {
300                 /*
301                  * The above down_read_trylock() might have succeeded in
302                  * which case, we'll have missed the might_sleep() from
303                  * down_read()
304                  */
305                 might_sleep();
306 #ifdef CONFIG_DEBUG_VM
307                 if (!user_mode(regs) &&
308                     !search_exception_tables(regs->ARM_pc))
309                         goto no_context;
310 #endif
311         }
312
313         fault = __do_page_fault(mm, addr, fsr, flags, tsk);
314
315         /* If we need to retry but a fatal signal is pending, handle the
316          * signal first. We do not need to release the mmap_sem because
317          * it would already be released in __lock_page_or_retry in
318          * mm/filemap.c. */
319         if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
320                 return 0;
321
322         /*
323          * Major/minor page fault accounting is only done on the
324          * initial attempt. If we go through a retry, it is extremely
325          * likely that the page will be found in page cache at that point.
326          */
327
328         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, addr);
329         if (!(fault & VM_FAULT_ERROR) && flags & FAULT_FLAG_ALLOW_RETRY) {
330                 if (fault & VM_FAULT_MAJOR) {
331                         tsk->maj_flt++;
332                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1,
333                                         regs, addr);
334                 } else {
335                         tsk->min_flt++;
336                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1,
337                                         regs, addr);
338                 }
339                 if (fault & VM_FAULT_RETRY) {
340                         /* Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk
341                         * of starvation. */
342                         flags &= ~FAULT_FLAG_ALLOW_RETRY;
343                         flags |= FAULT_FLAG_TRIED;
344                         goto retry;
345                 }
346         }
347
348         up_read(&mm->mmap_sem);
349
350         /*
351          * Handle the "normal" case first - VM_FAULT_MAJOR / VM_FAULT_MINOR
352          */
353         if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP | VM_FAULT_BADACCESS))))
354                 return 0;
355
356         /*
357          * If we are in kernel mode at this point, we
358          * have no context to handle this fault with.
359          */
360         if (!user_mode(regs))
361                 goto no_context;
362
363         if (fault & VM_FAULT_OOM) {
364                 /*
365                  * We ran out of memory, call the OOM killer, and return to
366                  * userspace (which will retry the fault, or kill us if we
367                  * got oom-killed)
368                  */
369                 pagefault_out_of_memory();
370                 return 0;
371         }
372
373         if (fault & VM_FAULT_SIGBUS) {
374                 /*
375                  * We had some memory, but were unable to
376                  * successfully fix up this page fault.
377                  */
378                 sig = SIGBUS;
379                 code = BUS_ADRERR;
380         } else {
381                 /*
382                  * Something tried to access memory that
383                  * isn't in our memory map..
384                  */
385                 sig = SIGSEGV;
386                 code = fault == VM_FAULT_BADACCESS ?
387                         SEGV_ACCERR : SEGV_MAPERR;
388         }
389
390         __do_user_fault(tsk, addr, fsr, sig, code, regs);
391         return 0;
392
393 no_context:
394         __do_kernel_fault(mm, addr, fsr, regs);
395         return 0;
396 }
397
398 static int __maybe_unused
399 do_pabt_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
400 {
401 #ifdef CONFIG_HARDEN_BRANCH_PREDICTOR
402         if (addr > TASK_SIZE) {
403                 switch (read_cpuid_part_number()) {
404                 }
405         }
406 #endif
407         return do_page_fault(addr, fsr, regs);
408 }
409 #else                                   /* CONFIG_MMU */
410 static int
411 do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
412 {
413         return 0;
414 }
415
416 static int
417 do_pabt_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
418 {
419         return 0;
420 }
421 #endif                                  /* CONFIG_MMU */
422
423 /*
424  * First Level Translation Fault Handler
425  *
426  * We enter here because the first level page table doesn't contain
427  * a valid entry for the address.
428  *
429  * If the address is in kernel space (>= TASK_SIZE), then we are
430  * probably faulting in the vmalloc() area.
431  *
432  * If the init_task's first level page tables contains the relevant
433  * entry, we copy the it to this task.  If not, we send the process
434  * a signal, fixup the exception, or oops the kernel.
435  *
436  * NOTE! We MUST NOT take any locks for this case. We may be in an
437  * interrupt or a critical region, and should only copy the information
438  * from the master page table, nothing more.
439  */
440 #ifdef CONFIG_MMU
441 static int __kprobes
442 do_translation_fault(unsigned long addr, unsigned int fsr,
443                      struct pt_regs *regs)
444 {
445         unsigned int index;
446         pgd_t *pgd, *pgd_k;
447         pud_t *pud, *pud_k;
448         pmd_t *pmd, *pmd_k;
449
450         if (addr < TASK_SIZE)
451                 return do_page_fault(addr, fsr, regs);
452
453         if (user_mode(regs))
454                 goto bad_area;
455
456         index = pgd_index(addr);
457
458         pgd = cpu_get_pgd() + index;
459         pgd_k = init_mm.pgd + index;
460
461         if (pgd_none(*pgd_k))
462                 goto bad_area;
463         if (!pgd_present(*pgd))
464                 set_pgd(pgd, *pgd_k);
465
466         pud = pud_offset(pgd, addr);
467         pud_k = pud_offset(pgd_k, addr);
468
469         if (pud_none(*pud_k))
470                 goto bad_area;
471         if (!pud_present(*pud)) {
472                 set_pud(pud, *pud_k);
473                 /*
474                  * There is a small window during free_pgtables() where the
475                  * user *pud entry is 0 but the TLB has not been invalidated
476                  * and we get a level 2 (pmd) translation fault caused by the
477                  * intermediate TLB caching of the old level 1 (pud) entry.
478                  */
479                 flush_tlb_kernel_page(addr);
480         }
481
482         pmd = pmd_offset(pud, addr);
483         pmd_k = pmd_offset(pud_k, addr);
484
485 #ifdef CONFIG_ARM_LPAE
486         /*
487          * Only one hardware entry per PMD with LPAE.
488          */
489         index = 0;
490 #else
491         /*
492          * On ARM one Linux PGD entry contains two hardware entries (see page
493          * tables layout in pgtable.h). We normally guarantee that we always
494          * fill both L1 entries. But create_mapping() doesn't follow the rule.
495          * It can create inidividual L1 entries, so here we have to call
496          * pmd_none() check for the entry really corresponded to address, not
497          * for the first of pair.
498          */
499         index = (addr >> SECTION_SHIFT) & 1;
500 #endif
501         if (pmd_none(pmd_k[index]))
502                 goto bad_area;
503         if (!pmd_present(pmd[index]))
504                 copy_pmd(pmd, pmd_k);
505
506         return 0;
507
508 bad_area:
509         do_bad_area(addr, fsr, regs);
510         return 0;
511 }
512 #else                                   /* CONFIG_MMU */
513 static int
514 do_translation_fault(unsigned long addr, unsigned int fsr,
515                      struct pt_regs *regs)
516 {
517         return 0;
518 }
519 #endif                                  /* CONFIG_MMU */
520
521 /*
522  * Some section permission faults need to be handled gracefully.
523  * They can happen due to a __{get,put}_user during an oops.
524  */
525 static int
526 do_sect_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
527 {
528         do_bad_area(addr, fsr, regs);
529         return 0;
530 }
531
532 /*
533  * This abort handler always returns "fault".
534  */
535 static int
536 do_bad(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
537 {
538         return 1;
539 }
540
541 struct fsr_info {
542         int     (*fn)(unsigned long addr, unsigned int fsr, struct pt_regs *regs);
543         int     sig;
544         int     code;
545         const char *name;
546 };
547
548 /* FSR definition */
549 #ifdef CONFIG_ARM_LPAE
550 #include "fsr-3level.c"
551 #else
552 #include "fsr-2level.c"
553 #endif
554
555 void __init
556 hook_fault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *),
557                 int sig, int code, const char *name)
558 {
559         if (nr < 0 || nr >= ARRAY_SIZE(fsr_info))
560                 BUG();
561
562         fsr_info[nr].fn   = fn;
563         fsr_info[nr].sig  = sig;
564         fsr_info[nr].code = code;
565         fsr_info[nr].name = name;
566 }
567
568 /*
569  * Dispatch a data abort to the relevant handler.
570  */
571 asmlinkage void __exception
572 do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
573 {
574         const struct fsr_info *inf = fsr_info + fsr_fs(fsr);
575         struct siginfo info;
576
577         if (!inf->fn(addr, fsr & ~FSR_LNX_PF, regs))
578                 return;
579
580         printk(KERN_ALERT "Unhandled fault: %s (0x%03x) at 0x%08lx\n",
581                 inf->name, fsr, addr);
582
583         info.si_signo = inf->sig;
584         info.si_errno = 0;
585         info.si_code  = inf->code;
586         info.si_addr  = (void __user *)addr;
587         arm_notify_die("", regs, &info, fsr, 0);
588 }
589
590 void __init
591 hook_ifault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *),
592                  int sig, int code, const char *name)
593 {
594         if (nr < 0 || nr >= ARRAY_SIZE(ifsr_info))
595                 BUG();
596
597         ifsr_info[nr].fn   = fn;
598         ifsr_info[nr].sig  = sig;
599         ifsr_info[nr].code = code;
600         ifsr_info[nr].name = name;
601 }
602
603 asmlinkage void __exception
604 do_PrefetchAbort(unsigned long addr, unsigned int ifsr, struct pt_regs *regs)
605 {
606         const struct fsr_info *inf = ifsr_info + fsr_fs(ifsr);
607         struct siginfo info;
608
609         if (!inf->fn(addr, ifsr | FSR_LNX_PF, regs))
610                 return;
611
612         printk(KERN_ALERT "Unhandled prefetch abort: %s (0x%03x) at 0x%08lx\n",
613                 inf->name, ifsr, addr);
614
615         info.si_signo = inf->sig;
616         info.si_errno = 0;
617         info.si_code  = inf->code;
618         info.si_addr  = (void __user *)addr;
619         arm_notify_die("", regs, &info, ifsr, 0);
620 }
621
622 #ifndef CONFIG_ARM_LPAE
623 static int __init exceptions_init(void)
624 {
625         if (cpu_architecture() >= CPU_ARCH_ARMv6) {
626                 hook_fault_code(4, do_translation_fault, SIGSEGV, SEGV_MAPERR,
627                                 "I-cache maintenance fault");
628         }
629
630         if (cpu_architecture() >= CPU_ARCH_ARMv7) {
631                 /*
632                  * TODO: Access flag faults introduced in ARMv6K.
633                  * Runtime check for 'K' extension is needed
634                  */
635                 hook_fault_code(3, do_bad, SIGSEGV, SEGV_MAPERR,
636                                 "section access flag fault");
637                 hook_fault_code(6, do_bad, SIGSEGV, SEGV_MAPERR,
638                                 "section access flag fault");
639         }
640
641         return 0;
642 }
643
644 arch_initcall(exceptions_init);
645 #endif