video: tegra: dc: have proper of_node_put
[linux-3.10.git] / arch / arm64 / mm / fault.c
1 /*
2  * Based on arch/arm/mm/fault.c
3  *
4  * Copyright (C) 1995  Linus Torvalds
5  * Copyright (C) 1995-2004 Russell King
6  * Copyright (C) 2012 ARM Ltd.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <linux/module.h>
22 #include <linux/signal.h>
23 #include <linux/mm.h>
24 #include <linux/hardirq.h>
25 #include <linux/init.h>
26 #include <linux/kprobes.h>
27 #include <linux/uaccess.h>
28 #include <linux/page-flags.h>
29 #include <linux/sched.h>
30 #include <linux/highmem.h>
31 #include <linux/perf_event.h>
32 #include <linux/fs.h>
33
34 #include <asm/exception.h>
35 #include <asm/debug-monitors.h>
36 #include <asm/system_misc.h>
37 #include <asm/pgtable.h>
38 #include <asm/tlbflush.h>
39
40 #define CREATE_TRACE_POINTS
41 #include <trace/events/pagefault.h>
42
43 static const char *fault_name(unsigned int esr);
44
45 /*
46  * Dump out the page tables associated with 'addr' in mm 'mm'.
47  */
48 void show_pte(struct mm_struct *mm, unsigned long addr)
49 {
50         pgd_t *pgd;
51
52         if (!mm)
53                 mm = &init_mm;
54
55         pr_alert("pgd = %p\n", mm->pgd);
56         pgd = pgd_offset(mm, addr);
57         pr_alert("[%08lx] *pgd=%016llx", addr, pgd_val(*pgd));
58
59         do {
60                 pud_t *pud;
61                 pmd_t *pmd;
62                 pte_t *pte;
63
64                 if (pgd_none(*pgd) || pgd_bad(*pgd))
65                         break;
66
67                 pud = pud_offset(pgd, addr);
68                 if (pud_none(*pud) || pud_bad(*pud))
69                         break;
70
71                 pmd = pmd_offset(pud, addr);
72                 printk(", *pmd=%016llx", pmd_val(*pmd));
73                 if (pmd_none(*pmd) || pmd_bad(*pmd))
74                         break;
75
76                 pte = pte_offset_map(pmd, addr);
77                 printk(", *pte=%016llx", pte_val(*pte));
78                 pte_unmap(pte);
79         } while(0);
80
81         printk("\n");
82 }
83
84 /*
85  * The kernel tried to access some page that wasn't present.
86  */
87 static void __do_kernel_fault(struct mm_struct *mm, unsigned long addr,
88                               unsigned int esr, struct pt_regs *regs)
89 {
90         /*
91          * Are we prepared to handle this kernel fault?
92          */
93         if (fixup_exception(regs))
94                 return;
95
96         /*
97          * No handler, we'll have to terminate things with extreme prejudice.
98          */
99         bust_spinlocks(1);
100         pr_alert("Unable to handle kernel %s at virtual address %08lx\n",
101                  (addr < PAGE_SIZE) ? "NULL pointer dereference" :
102                  "paging request", addr);
103
104         show_pte(mm, addr);
105         die("Oops", regs, esr);
106         bust_spinlocks(0);
107         do_exit(SIGKILL);
108 }
109
110 static void show_map(struct task_struct *tsk, u64 addr)
111 {
112         struct vm_area_struct *vma;
113         struct file *file;
114         struct mm_struct *mm = tsk->mm;
115         char path[64];
116         char *p;
117
118         vma = find_vma(mm, addr);
119         if (!vma)
120                 return;
121         file = vma->vm_file;
122         if (!file)
123                 return;
124         p = d_path(&file->f_path, &path[0], 64);
125         if (IS_ERR(p))
126                 return;
127         pr_alert("Library at 0x%llx: 0x%lx %s\n", addr, vma->vm_start, p);
128 }
129 /*
130  * Something tried to access memory that isn't in our memory map. User mode
131  * accesses just cause a SIGSEGV
132  */
133 static void __do_user_fault(struct task_struct *tsk, unsigned long addr,
134                             unsigned int esr, unsigned int sig, int code,
135                             struct pt_regs *regs)
136 {
137         struct siginfo si;
138
139         if (show_unhandled_signals && unhandled_signal(tsk, sig) &&
140             printk_ratelimit()) {
141                 pr_info("%s[%d]: unhandled %s (%d) at 0x%08lx, esr 0x%03x\n",
142                         tsk->comm, task_pid_nr(tsk), fault_name(esr), sig,
143                         addr, esr);
144                 show_pte(tsk->mm, addr);
145                 show_regs(regs);
146                 show_map(tsk, instruction_pointer(regs));
147                 if (compat_user_mode(regs))
148                         show_map(tsk, regs->compat_lr);
149                 else
150                         show_map(tsk, regs->regs[30]);
151                 pr_alert("vdso base = 0x%lx\n", (unsigned long)tsk->mm->context.vdso);
152         }
153
154         tsk->thread.fault_address = addr;
155         si.si_signo = sig;
156         si.si_errno = 0;
157         si.si_code = code;
158         si.si_addr = (void __user *)addr;
159         force_sig_info(sig, &si, tsk);
160 }
161
162 static void do_bad_area(unsigned long addr, unsigned int esr, struct pt_regs *regs)
163 {
164         struct task_struct *tsk = current;
165         struct mm_struct *mm = tsk->active_mm;
166
167         /*
168          * If we are in kernel mode at this point, we have no context to
169          * handle this fault with.
170          */
171         if (user_mode(regs))
172                 __do_user_fault(tsk, addr, esr, SIGSEGV, SEGV_MAPERR, regs);
173         else
174                 __do_kernel_fault(mm, addr, esr, regs);
175 }
176
177 #define VM_FAULT_BADMAP         0x010000
178 #define VM_FAULT_BADACCESS      0x020000
179
180 #define ESR_WRITE               (1 << 6)
181 #define ESR_CM                  (1 << 8)
182 #define ESR_LNX_EXEC            (1 << 24)
183
184 static int __do_page_fault(struct mm_struct *mm, unsigned long addr,
185                            unsigned int mm_flags, unsigned long vm_flags,
186                            struct task_struct *tsk)
187 {
188         struct vm_area_struct *vma;
189         int fault;
190
191         vma = find_vma(mm, addr);
192         fault = VM_FAULT_BADMAP;
193         if (unlikely(!vma))
194                 goto out;
195         if (unlikely(vma->vm_start > addr))
196                 goto check_stack;
197
198         /*
199          * Ok, we have a good vm_area for this memory access, so we can handle
200          * it.
201          */
202 good_area:
203         /*
204          * Check that the permissions on the VMA allow for the fault which
205          * occurred. If we encountered a write or exec fault, we must have
206          * appropriate permissions, otherwise we allow any permission.
207          */
208         if (!(vma->vm_flags & vm_flags)) {
209                 fault = VM_FAULT_BADACCESS;
210                 goto out;
211         }
212
213         return handle_mm_fault(mm, vma, addr & PAGE_MASK, mm_flags);
214
215 check_stack:
216         if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
217                 goto good_area;
218 out:
219         return fault;
220 }
221
222 static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,
223                                    struct pt_regs *regs)
224 {
225         struct task_struct *tsk;
226         struct mm_struct *mm;
227         int fault, sig, code;
228         unsigned long vm_flags = VM_READ | VM_WRITE | VM_EXEC;
229         unsigned int mm_flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
230
231         trace_pagefault_entry(addr);
232
233         tsk = current;
234         mm  = tsk->mm;
235
236         /* Enable interrupts if they were enabled in the parent context. */
237         if (interrupts_enabled(regs))
238                 local_irq_enable();
239
240         /*
241          * If we're in an interrupt or have no user context, we must not take
242          * the fault.
243          */
244         if (in_atomic() || !mm)
245                 goto no_context;
246
247         if (user_mode(regs))
248                 mm_flags |= FAULT_FLAG_USER;
249
250         if (esr & ESR_LNX_EXEC) {
251                 vm_flags = VM_EXEC;
252         } else if ((esr & ESR_WRITE) && !(esr & ESR_CM)) {
253                 vm_flags = VM_WRITE;
254                 mm_flags |= FAULT_FLAG_WRITE;
255         }
256
257         /*
258          * As per x86, we may deadlock here. However, since the kernel only
259          * validly references user space from well defined areas of the code,
260          * we can bug out early if this is from code which shouldn't.
261          */
262         if (!down_read_trylock(&mm->mmap_sem)) {
263                 if (!user_mode(regs) && !search_exception_tables(regs->pc))
264                         goto no_context;
265 retry:
266                 down_read(&mm->mmap_sem);
267         } else {
268                 /*
269                  * The above down_read_trylock() might have succeeded in which
270                  * case, we'll have missed the might_sleep() from down_read().
271                  */
272                 might_sleep();
273 #ifdef CONFIG_DEBUG_VM
274                 if (!user_mode(regs) && !search_exception_tables(regs->pc))
275                         goto no_context;
276 #endif
277         }
278
279         fault = __do_page_fault(mm, addr, mm_flags, vm_flags, tsk);
280
281         /*
282          * If we need to retry but a fatal signal is pending, handle the
283          * signal first. We do not need to release the mmap_sem because it
284          * would already be released in __lock_page_or_retry in mm/filemap.c.
285          */
286         if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
287                 goto return0;
288
289         /*
290          * Major/minor page fault accounting is only done on the initial
291          * attempt. If we go through a retry, it is extremely likely that the
292          * page will be found in page cache at that point.
293          */
294
295         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, addr);
296         if (mm_flags & FAULT_FLAG_ALLOW_RETRY) {
297                 if (fault & VM_FAULT_MAJOR) {
298                         tsk->maj_flt++;
299                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, regs,
300                                       addr);
301                 } else {
302                         tsk->min_flt++;
303                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs,
304                                       addr);
305                 }
306                 if (fault & VM_FAULT_RETRY) {
307                         /*
308                          * Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk of
309                          * starvation.
310                          */
311                         mm_flags &= ~FAULT_FLAG_ALLOW_RETRY;
312                         goto retry;
313                 }
314         }
315
316         up_read(&mm->mmap_sem);
317
318         /*
319          * Handle the "normal" case first - VM_FAULT_MAJOR / VM_FAULT_MINOR
320          */
321         if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP |
322                               VM_FAULT_BADACCESS))))
323                 goto return0;
324
325         /*
326          * If we are in kernel mode at this point, we have no context to
327          * handle this fault with.
328          */
329         if (!user_mode(regs))
330                 goto no_context;
331
332         if (fault & VM_FAULT_OOM) {
333                 /*
334                  * We ran out of memory, call the OOM killer, and return to
335                  * userspace (which will retry the fault, or kill us if we got
336                  * oom-killed).
337                  */
338                 pagefault_out_of_memory();
339                 goto return0;
340         }
341
342         if (fault & VM_FAULT_SIGBUS) {
343                 /*
344                  * We had some memory, but were unable to successfully fix up
345                  * this page fault.
346                  */
347                 sig = SIGBUS;
348                 code = BUS_ADRERR;
349         } else {
350                 /*
351                  * Something tried to access memory that isn't in our memory
352                  * map.
353                  */
354                 sig = SIGSEGV;
355                 code = fault == VM_FAULT_BADACCESS ?
356                         SEGV_ACCERR : SEGV_MAPERR;
357         }
358
359         __do_user_fault(tsk, addr, esr, sig, code, regs);
360         goto return0;
361
362 no_context:
363         __do_kernel_fault(mm, addr, esr, regs);
364 return0:
365         trace_pagefault_exit(addr);
366         return 0;
367 }
368
369 /*
370  * First Level Translation Fault Handler
371  *
372  * We enter here because the first level page table doesn't contain a valid
373  * entry for the address.
374  *
375  * If the address is in kernel space (>= TASK_SIZE), then we are probably
376  * faulting in the vmalloc() area.
377  *
378  * If the init_task's first level page tables contains the relevant entry, we
379  * copy the it to this task.  If not, we send the process a signal, fixup the
380  * exception, or oops the kernel.
381  *
382  * NOTE! We MUST NOT take any locks for this case. We may be in an interrupt
383  * or a critical region, and should only copy the information from the master
384  * page table, nothing more.
385  */
386 static int __kprobes do_translation_fault(unsigned long addr,
387                                           unsigned int esr,
388                                           struct pt_regs *regs)
389 {
390         if (addr < TASK_SIZE)
391                 return do_page_fault(addr, esr, regs);
392
393         do_bad_area(addr, esr, regs);
394         return 0;
395 }
396
397 /*
398  * Some section permission faults need to be handled gracefully.  They can
399  * happen due to a __{get,put}_user during an oops.
400  */
401 static int do_sect_fault(unsigned long addr, unsigned int esr,
402                          struct pt_regs *regs)
403 {
404         do_bad_area(addr, esr, regs);
405         return 0;
406 }
407
408 /*
409  * This abort handler always returns "fault".
410  */
411 static int do_bad(unsigned long addr, unsigned int esr, struct pt_regs *regs)
412 {
413         return 1;
414 }
415
416 static struct fault_info {
417         int     (*fn)(unsigned long addr, unsigned int esr, struct pt_regs *regs);
418         int     sig;
419         int     code;
420         const char *name;
421 } fault_info[] = {
422         { do_bad,               SIGBUS,  0,             "ttbr address size fault"       },
423         { do_bad,               SIGBUS,  0,             "level 1 address size fault"    },
424         { do_bad,               SIGBUS,  0,             "level 2 address size fault"    },
425         { do_bad,               SIGBUS,  0,             "level 3 address size fault"    },
426         { do_translation_fault, SIGSEGV, SEGV_MAPERR,   "input address range fault"     },
427         { do_translation_fault, SIGSEGV, SEGV_MAPERR,   "level 1 translation fault"     },
428         { do_translation_fault, SIGSEGV, SEGV_MAPERR,   "level 2 translation fault"     },
429         { do_page_fault,        SIGSEGV, SEGV_MAPERR,   "level 3 translation fault"     },
430         { do_bad,               SIGBUS,  0,             "reserved access flag fault"    },
431         { do_bad,               SIGSEGV, SEGV_ACCERR,   "level 1 access flag fault"     },
432         { do_bad,               SIGSEGV, SEGV_ACCERR,   "level 2 access flag fault"     },
433         { do_page_fault,        SIGSEGV, SEGV_ACCERR,   "level 3 access flag fault"     },
434         { do_bad,               SIGBUS,  0,             "reserved permission fault"     },
435         { do_bad,               SIGSEGV, SEGV_ACCERR,   "level 1 permission fault"      },
436         { do_sect_fault,        SIGSEGV, SEGV_ACCERR,   "level 2 permission fault"      },
437         { do_page_fault,        SIGSEGV, SEGV_ACCERR,   "level 3 permission fault"      },
438         { do_bad,               SIGBUS,  0,             "synchronous external abort"    },
439         { do_bad,               SIGBUS,  0,             "asynchronous external abort"   },
440         { do_bad,               SIGBUS,  0,             "unknown 18"                    },
441         { do_bad,               SIGBUS,  0,             "unknown 19"                    },
442         { do_bad,               SIGBUS,  0,             "synchronous abort (translation table walk)" },
443         { do_bad,               SIGBUS,  0,             "synchronous abort (translation table walk)" },
444         { do_bad,               SIGBUS,  0,             "synchronous abort (translation table walk)" },
445         { do_bad,               SIGBUS,  0,             "synchronous abort (translation table walk)" },
446         { do_bad,               SIGBUS,  0,             "synchronous parity error"      },
447         { do_bad,               SIGBUS,  0,             "asynchronous parity error"     },
448         { do_bad,               SIGBUS,  0,             "unknown 26"                    },
449         { do_bad,               SIGBUS,  0,             "unknown 27"                    },
450         { do_bad,               SIGBUS,  0,             "synchronous parity error (translation table walk" },
451         { do_bad,               SIGBUS,  0,             "synchronous parity error (translation table walk" },
452         { do_bad,               SIGBUS,  0,             "synchronous parity error (translation table walk" },
453         { do_bad,               SIGBUS,  0,             "synchronous parity error (translation table walk" },
454         { do_bad,               SIGBUS,  0,             "unknown 32"                    },
455         { do_bad,               SIGBUS,  BUS_ADRALN,    "alignment fault"               },
456         { do_bad,               SIGBUS,  0,             "debug event"                   },
457         { do_bad,               SIGBUS,  0,             "unknown 35"                    },
458         { do_bad,               SIGBUS,  0,             "unknown 36"                    },
459         { do_bad,               SIGBUS,  0,             "unknown 37"                    },
460         { do_bad,               SIGBUS,  0,             "unknown 38"                    },
461         { do_bad,               SIGBUS,  0,             "unknown 39"                    },
462         { do_bad,               SIGBUS,  0,             "unknown 40"                    },
463         { do_bad,               SIGBUS,  0,             "unknown 41"                    },
464         { do_bad,               SIGBUS,  0,             "unknown 42"                    },
465         { do_bad,               SIGBUS,  0,             "unknown 43"                    },
466         { do_bad,               SIGBUS,  0,             "unknown 44"                    },
467         { do_bad,               SIGBUS,  0,             "unknown 45"                    },
468         { do_bad,               SIGBUS,  0,             "unknown 46"                    },
469         { do_bad,               SIGBUS,  0,             "unknown 47"                    },
470         { do_bad,               SIGBUS,  0,             "unknown 48"                    },
471         { do_bad,               SIGBUS,  0,             "unknown 49"                    },
472         { do_bad,               SIGBUS,  0,             "unknown 50"                    },
473         { do_bad,               SIGBUS,  0,             "unknown 51"                    },
474         { do_bad,               SIGBUS,  0,             "implementation fault (lockdown abort)" },
475         { do_bad,               SIGBUS,  0,             "unknown 53"                    },
476         { do_bad,               SIGBUS,  0,             "unknown 54"                    },
477         { do_bad,               SIGBUS,  0,             "unknown 55"                    },
478         { do_bad,               SIGBUS,  0,             "unknown 56"                    },
479         { do_bad,               SIGBUS,  0,             "unknown 57"                    },
480         { do_bad,               SIGBUS,  0,             "implementation fault (coprocessor abort)" },
481         { do_bad,               SIGBUS,  0,             "unknown 59"                    },
482         { do_bad,               SIGBUS,  0,             "unknown 60"                    },
483         { do_bad,               SIGBUS,  0,             "unknown 61"                    },
484         { do_bad,               SIGBUS,  0,             "unknown 62"                    },
485         { do_bad,               SIGBUS,  0,             "unknown 63"                    },
486 };
487
488 static const char *fault_name(unsigned int esr)
489 {
490         const struct fault_info *inf = fault_info + (esr & 63);
491         return inf->name;
492 }
493
494 /*
495  * Dispatch a data abort to the relevant handler.
496  */
497 asmlinkage void __exception do_mem_abort(unsigned long addr, unsigned int esr,
498                                          struct pt_regs *regs)
499 {
500         const struct fault_info *inf = fault_info + (esr & 63);
501         struct siginfo info;
502
503         if (!inf->fn(addr, esr, regs))
504                 return;
505
506         pr_alert("Unhandled fault: %s (0x%08x) at 0x%016lx\n",
507                  inf->name, esr, addr);
508
509         info.si_signo = inf->sig;
510         info.si_errno = 0;
511         info.si_code  = inf->code;
512         info.si_addr  = (void __user *)addr;
513         arm64_notify_die("", regs, &info, esr);
514 }
515
516 /*
517  * Handle stack alignment exceptions.
518  */
519 asmlinkage void __exception do_sp_pc_abort(unsigned long addr,
520                                            unsigned int esr,
521                                            struct pt_regs *regs)
522 {
523         struct siginfo info;
524
525         info.si_signo = SIGBUS;
526         info.si_errno = 0;
527         info.si_code  = BUS_ADRALN;
528         info.si_addr  = (void __user *)addr;
529         arm64_notify_die("", regs, &info, esr);
530 }
531
532 static struct fault_info debug_fault_info[] = {
533         { do_bad,       SIGTRAP,        TRAP_HWBKPT,    "hardware breakpoint"   },
534         { do_bad,       SIGTRAP,        TRAP_HWBKPT,    "hardware single-step"  },
535         { do_bad,       SIGTRAP,        TRAP_HWBKPT,    "hardware watchpoint"   },
536         { do_bad,       SIGBUS,         0,              "unknown 3"             },
537         { do_bad,       SIGTRAP,        TRAP_BRKPT,     "aarch32 BKPT"          },
538         { do_bad,       SIGTRAP,        0,              "aarch32 vector catch"  },
539         { do_bad,       SIGTRAP,        TRAP_BRKPT,     "aarch64 BRK"           },
540         { do_bad,       SIGBUS,         0,              "unknown 7"             },
541 };
542
543 void __init hook_debug_fault_code(int nr,
544                                   int (*fn)(unsigned long, unsigned int, struct pt_regs *),
545                                   int sig, int code, const char *name)
546 {
547         BUG_ON(nr < 0 || nr >= ARRAY_SIZE(debug_fault_info));
548
549         debug_fault_info[nr].fn         = fn;
550         debug_fault_info[nr].sig        = sig;
551         debug_fault_info[nr].code       = code;
552         debug_fault_info[nr].name       = name;
553 }
554
555 asmlinkage int __exception do_debug_exception(unsigned long addr,
556                                               unsigned int esr,
557                                               struct pt_regs *regs)
558 {
559         const struct fault_info *inf = debug_fault_info + DBG_ESR_EVT(esr);
560         struct siginfo info;
561
562         if (!inf->fn(addr, esr, regs))
563                 return 1;
564
565         pr_alert("Unhandled debug exception: %s (0x%08x) at 0x%016lx\n",
566                  inf->name, esr, addr);
567
568         info.si_signo = inf->sig;
569         info.si_errno = 0;
570         info.si_code  = inf->code;
571         info.si_addr  = (void __user *)addr;
572         arm64_notify_die("", regs, &info, esr);
573
574         return 0;
575 }