bec0cce79a78f6c1db3671c611ae83a7230170a0
[sfrench/cifs-2.6.git] / arch / powerpc / mm / fault.c
1 /*
2  *  PowerPC version
3  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
4  *
5  *  Derived from "arch/i386/mm/fault.c"
6  *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
7  *
8  *  Modified by Cort Dougan and Paul Mackerras.
9  *
10  *  Modified for PPC64 by Dave Engebretsen (engebret@ibm.com)
11  *
12  *  This program is free software; you can redistribute it and/or
13  *  modify it under the terms of the GNU General Public License
14  *  as published by the Free Software Foundation; either version
15  *  2 of the License, or (at your option) any later version.
16  */
17
18 #include <linux/signal.h>
19 #include <linux/sched.h>
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/string.h>
23 #include <linux/types.h>
24 #include <linux/ptrace.h>
25 #include <linux/mman.h>
26 #include <linux/mm.h>
27 #include <linux/interrupt.h>
28 #include <linux/highmem.h>
29 #include <linux/module.h>
30 #include <linux/kprobes.h>
31 #include <linux/kdebug.h>
32
33 #include <asm/page.h>
34 #include <asm/pgtable.h>
35 #include <asm/mmu.h>
36 #include <asm/mmu_context.h>
37 #include <asm/system.h>
38 #include <asm/uaccess.h>
39 #include <asm/tlbflush.h>
40 #include <asm/siginfo.h>
41
42 #ifdef CONFIG_KPROBES
43 ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
44
45 /* Hook to register for page fault notifications */
46 int register_page_fault_notifier(struct notifier_block *nb)
47 {
48         return atomic_notifier_chain_register(&notify_page_fault_chain, nb);
49 }
50
51 int unregister_page_fault_notifier(struct notifier_block *nb)
52 {
53         return atomic_notifier_chain_unregister(&notify_page_fault_chain, nb);
54 }
55
56 static inline int notify_page_fault(enum die_val val, const char *str,
57                         struct pt_regs *regs, long err, int trap, int sig)
58 {
59         struct die_args args = {
60                 .regs = regs,
61                 .str = str,
62                 .err = err,
63                 .trapnr = trap,
64                 .signr = sig
65         };
66         return atomic_notifier_call_chain(&notify_page_fault_chain, val, &args);
67 }
68 #else
69 static inline int notify_page_fault(enum die_val val, const char *str,
70                         struct pt_regs *regs, long err, int trap, int sig)
71 {
72         return NOTIFY_DONE;
73 }
74 #endif
75
76 /*
77  * Check whether the instruction at regs->nip is a store using
78  * an update addressing form which will update r1.
79  */
80 static int store_updates_sp(struct pt_regs *regs)
81 {
82         unsigned int inst;
83
84         if (get_user(inst, (unsigned int __user *)regs->nip))
85                 return 0;
86         /* check for 1 in the rA field */
87         if (((inst >> 16) & 0x1f) != 1)
88                 return 0;
89         /* check major opcode */
90         switch (inst >> 26) {
91         case 37:        /* stwu */
92         case 39:        /* stbu */
93         case 45:        /* sthu */
94         case 53:        /* stfsu */
95         case 55:        /* stfdu */
96                 return 1;
97         case 62:        /* std or stdu */
98                 return (inst & 3) == 1;
99         case 31:
100                 /* check minor opcode */
101                 switch ((inst >> 1) & 0x3ff) {
102                 case 181:       /* stdux */
103                 case 183:       /* stwux */
104                 case 247:       /* stbux */
105                 case 439:       /* sthux */
106                 case 695:       /* stfsux */
107                 case 759:       /* stfdux */
108                         return 1;
109                 }
110         }
111         return 0;
112 }
113
114 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
115 static void do_dabr(struct pt_regs *regs, unsigned long address,
116                     unsigned long error_code)
117 {
118         siginfo_t info;
119
120         if (notify_die(DIE_DABR_MATCH, "dabr_match", regs, error_code,
121                         11, SIGSEGV) == NOTIFY_STOP)
122                 return;
123
124         if (debugger_dabr_match(regs))
125                 return;
126
127         /* Clear the DABR */
128         set_dabr(0);
129
130         /* Deliver the signal to userspace */
131         info.si_signo = SIGTRAP;
132         info.si_errno = 0;
133         info.si_code = TRAP_HWBKPT;
134         info.si_addr = (void __user *)address;
135         force_sig_info(SIGTRAP, &info, current);
136 }
137 #endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
138
139 /*
140  * For 600- and 800-family processors, the error_code parameter is DSISR
141  * for a data fault, SRR1 for an instruction fault. For 400-family processors
142  * the error_code parameter is ESR for a data fault, 0 for an instruction
143  * fault.
144  * For 64-bit processors, the error_code parameter is
145  *  - DSISR for a non-SLB data access fault,
146  *  - SRR1 & 0x08000000 for a non-SLB instruction access fault
147  *  - 0 any SLB fault.
148  *
149  * The return value is 0 if the fault was handled, or the signal
150  * number if this is a kernel fault that can't be handled here.
151  */
152 int __kprobes do_page_fault(struct pt_regs *regs, unsigned long address,
153                             unsigned long error_code)
154 {
155         struct vm_area_struct * vma;
156         struct mm_struct *mm = current->mm;
157         siginfo_t info;
158         int code = SEGV_MAPERR;
159         int is_write = 0;
160         int trap = TRAP(regs);
161         int is_exec = trap == 0x400;
162
163 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
164         /*
165          * Fortunately the bit assignments in SRR1 for an instruction
166          * fault and DSISR for a data fault are mostly the same for the
167          * bits we are interested in.  But there are some bits which
168          * indicate errors in DSISR but can validly be set in SRR1.
169          */
170         if (trap == 0x400)
171                 error_code &= 0x48200000;
172         else
173                 is_write = error_code & DSISR_ISSTORE;
174 #else
175         is_write = error_code & ESR_DST;
176 #endif /* CONFIG_4xx || CONFIG_BOOKE */
177
178         if (notify_page_fault(DIE_PAGE_FAULT, "page_fault", regs, error_code,
179                                 11, SIGSEGV) == NOTIFY_STOP)
180                 return 0;
181
182         if (trap == 0x300) {
183                 if (debugger_fault_handler(regs))
184                         return 0;
185         }
186
187         /* On a kernel SLB miss we can only check for a valid exception entry */
188         if (!user_mode(regs) && (address >= TASK_SIZE))
189                 return SIGSEGV;
190
191 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
192         if (error_code & DSISR_DABRMATCH) {
193                 /* DABR match */
194                 do_dabr(regs, address, error_code);
195                 return 0;
196         }
197 #endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
198
199         if (in_atomic() || mm == NULL) {
200                 if (!user_mode(regs))
201                         return SIGSEGV;
202                 /* in_atomic() in user mode is really bad,
203                    as is current->mm == NULL. */
204                 printk(KERN_EMERG "Page fault in user mode with"
205                        "in_atomic() = %d mm = %p\n", in_atomic(), mm);
206                 printk(KERN_EMERG "NIP = %lx  MSR = %lx\n",
207                        regs->nip, regs->msr);
208                 die("Weird page fault", regs, SIGSEGV);
209         }
210
211         /* When running in the kernel we expect faults to occur only to
212          * addresses in user space.  All other faults represent errors in the
213          * kernel and should generate an OOPS.  Unfortunately, in the case of an
214          * erroneous fault occurring in a code path which already holds mmap_sem
215          * we will deadlock attempting to validate the fault against the
216          * address space.  Luckily the kernel only validly references user
217          * space from well defined areas of code, which are listed in the
218          * exceptions table.
219          *
220          * As the vast majority of faults will be valid we will only perform
221          * the source reference check when there is a possibility of a deadlock.
222          * Attempt to lock the address space, if we cannot we then validate the
223          * source.  If this is invalid we can skip the address space check,
224          * thus avoiding the deadlock.
225          */
226         if (!down_read_trylock(&mm->mmap_sem)) {
227                 if (!user_mode(regs) && !search_exception_tables(regs->nip))
228                         goto bad_area_nosemaphore;
229
230                 down_read(&mm->mmap_sem);
231         }
232
233         vma = find_vma(mm, address);
234         if (!vma)
235                 goto bad_area;
236         if (vma->vm_start <= address)
237                 goto good_area;
238         if (!(vma->vm_flags & VM_GROWSDOWN))
239                 goto bad_area;
240
241         /*
242          * N.B. The POWER/Open ABI allows programs to access up to
243          * 288 bytes below the stack pointer.
244          * The kernel signal delivery code writes up to about 1.5kB
245          * below the stack pointer (r1) before decrementing it.
246          * The exec code can write slightly over 640kB to the stack
247          * before setting the user r1.  Thus we allow the stack to
248          * expand to 1MB without further checks.
249          */
250         if (address + 0x100000 < vma->vm_end) {
251                 /* get user regs even if this fault is in kernel mode */
252                 struct pt_regs *uregs = current->thread.regs;
253                 if (uregs == NULL)
254                         goto bad_area;
255
256                 /*
257                  * A user-mode access to an address a long way below
258                  * the stack pointer is only valid if the instruction
259                  * is one which would update the stack pointer to the
260                  * address accessed if the instruction completed,
261                  * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
262                  * (or the byte, halfword, float or double forms).
263                  *
264                  * If we don't check this then any write to the area
265                  * between the last mapped region and the stack will
266                  * expand the stack rather than segfaulting.
267                  */
268                 if (address + 2048 < uregs->gpr[1]
269                     && (!user_mode(regs) || !store_updates_sp(regs)))
270                         goto bad_area;
271         }
272         if (expand_stack(vma, address))
273                 goto bad_area;
274
275 good_area:
276         code = SEGV_ACCERR;
277 #if defined(CONFIG_6xx)
278         if (error_code & 0x95700000)
279                 /* an error such as lwarx to I/O controller space,
280                    address matching DABR, eciwx, etc. */
281                 goto bad_area;
282 #endif /* CONFIG_6xx */
283 #if defined(CONFIG_8xx)
284         /* The MPC8xx seems to always set 0x80000000, which is
285          * "undefined".  Of those that can be set, this is the only
286          * one which seems bad.
287          */
288         if (error_code & 0x10000000)
289                 /* Guarded storage error. */
290                 goto bad_area;
291 #endif /* CONFIG_8xx */
292
293         if (is_exec) {
294 #ifdef CONFIG_PPC64
295                 /* protection fault */
296                 if (error_code & DSISR_PROTFAULT)
297                         goto bad_area;
298                 if (!(vma->vm_flags & VM_EXEC))
299                         goto bad_area;
300 #endif
301 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
302                 pte_t *ptep;
303                 pmd_t *pmdp;
304
305                 /* Since 4xx/Book-E supports per-page execute permission,
306                  * we lazily flush dcache to icache. */
307                 ptep = NULL;
308                 if (get_pteptr(mm, address, &ptep, &pmdp)) {
309                         spinlock_t *ptl = pte_lockptr(mm, pmdp);
310                         spin_lock(ptl);
311                         if (pte_present(*ptep)) {
312                                 struct page *page = pte_page(*ptep);
313
314                                 if (!test_bit(PG_arch_1, &page->flags)) {
315                                         flush_dcache_icache_page(page);
316                                         set_bit(PG_arch_1, &page->flags);
317                                 }
318                                 pte_update(ptep, 0, _PAGE_HWEXEC);
319                                 _tlbie(address);
320                                 pte_unmap_unlock(ptep, ptl);
321                                 up_read(&mm->mmap_sem);
322                                 return 0;
323                         }
324                         pte_unmap_unlock(ptep, ptl);
325                 }
326 #endif
327         /* a write */
328         } else if (is_write) {
329                 if (!(vma->vm_flags & VM_WRITE))
330                         goto bad_area;
331         /* a read */
332         } else {
333                 /* protection fault */
334                 if (error_code & 0x08000000)
335                         goto bad_area;
336                 if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
337                         goto bad_area;
338         }
339
340         /*
341          * If for any reason at all we couldn't handle the fault,
342          * make sure we exit gracefully rather than endlessly redo
343          * the fault.
344          */
345  survive:
346         switch (handle_mm_fault(mm, vma, address, is_write)) {
347
348         case VM_FAULT_MINOR:
349                 current->min_flt++;
350                 break;
351         case VM_FAULT_MAJOR:
352                 current->maj_flt++;
353                 break;
354         case VM_FAULT_SIGBUS:
355                 goto do_sigbus;
356         case VM_FAULT_OOM:
357                 goto out_of_memory;
358         default:
359                 BUG();
360         }
361
362         up_read(&mm->mmap_sem);
363         return 0;
364
365 bad_area:
366         up_read(&mm->mmap_sem);
367
368 bad_area_nosemaphore:
369         /* User mode accesses cause a SIGSEGV */
370         if (user_mode(regs)) {
371                 _exception(SIGSEGV, regs, code, address);
372                 return 0;
373         }
374
375         if (is_exec && (error_code & DSISR_PROTFAULT)
376             && printk_ratelimit())
377                 printk(KERN_CRIT "kernel tried to execute NX-protected"
378                        " page (%lx) - exploit attempt? (uid: %d)\n",
379                        address, current->uid);
380
381         return SIGSEGV;
382
383 /*
384  * We ran out of memory, or some other thing happened to us that made
385  * us unable to handle the page fault gracefully.
386  */
387 out_of_memory:
388         up_read(&mm->mmap_sem);
389         if (is_init(current)) {
390                 yield();
391                 down_read(&mm->mmap_sem);
392                 goto survive;
393         }
394         printk("VM: killing process %s\n", current->comm);
395         if (user_mode(regs))
396                 do_exit(SIGKILL);
397         return SIGKILL;
398
399 do_sigbus:
400         up_read(&mm->mmap_sem);
401         if (user_mode(regs)) {
402                 info.si_signo = SIGBUS;
403                 info.si_errno = 0;
404                 info.si_code = BUS_ADRERR;
405                 info.si_addr = (void __user *)address;
406                 force_sig_info(SIGBUS, &info, current);
407                 return 0;
408         }
409         return SIGBUS;
410 }
411
412 /*
413  * bad_page_fault is called when we have a bad access from the kernel.
414  * It is called from the DSI and ISI handlers in head.S and from some
415  * of the procedures in traps.c.
416  */
417 void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
418 {
419         const struct exception_table_entry *entry;
420
421         /* Are we prepared to handle this fault?  */
422         if ((entry = search_exception_tables(regs->nip)) != NULL) {
423                 regs->nip = entry->fixup;
424                 return;
425         }
426
427         /* kernel has accessed a bad area */
428
429         switch (regs->trap) {
430         case 0x300:
431         case 0x380:
432                 printk(KERN_ALERT "Unable to handle kernel paging request for "
433                         "data at address 0x%08lx\n", regs->dar);
434                 break;
435         case 0x400:
436         case 0x480:
437                 printk(KERN_ALERT "Unable to handle kernel paging request for "
438                         "instruction fetch\n");
439                 break;
440         default:
441                 printk(KERN_ALERT "Unable to handle kernel paging request for "
442                         "unknown fault\n");
443                 break;
444         }
445         printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n",
446                 regs->nip);
447
448         die("Kernel access of bad area", regs, sig);
449 }