[PATCH] lock PTE before updating it in 440/BookE page fault handler
[linux-3.10.git] / arch / ppc / 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  *  This program is free software; you can redistribute it and/or
11  *  modify it under the terms of the GNU General Public License
12  *  as published by the Free Software Foundation; either version
13  *  2 of the License, or (at your option) any later version.
14  */
15
16 #include <linux/config.h>
17 #include <linux/signal.h>
18 #include <linux/sched.h>
19 #include <linux/kernel.h>
20 #include <linux/errno.h>
21 #include <linux/string.h>
22 #include <linux/types.h>
23 #include <linux/ptrace.h>
24 #include <linux/mman.h>
25 #include <linux/mm.h>
26 #include <linux/interrupt.h>
27 #include <linux/highmem.h>
28 #include <linux/module.h>
29
30 #include <asm/page.h>
31 #include <asm/pgtable.h>
32 #include <asm/mmu.h>
33 #include <asm/mmu_context.h>
34 #include <asm/system.h>
35 #include <asm/uaccess.h>
36 #include <asm/tlbflush.h>
37
38 #if defined(CONFIG_XMON) || defined(CONFIG_KGDB)
39 extern void (*debugger)(struct pt_regs *);
40 extern void (*debugger_fault_handler)(struct pt_regs *);
41 extern int (*debugger_dabr_match)(struct pt_regs *);
42 int debugger_kernel_faults = 1;
43 #endif
44
45 unsigned long htab_reloads;     /* updated by hashtable.S:hash_page() */
46 unsigned long htab_evicts;      /* updated by hashtable.S:hash_page() */
47 unsigned long htab_preloads;    /* updated by hashtable.S:add_hash_page() */
48 unsigned long pte_misses;       /* updated by do_page_fault() */
49 unsigned long pte_errors;       /* updated by do_page_fault() */
50 unsigned int probingmem;
51
52 /*
53  * Check whether the instruction at regs->nip is a store using
54  * an update addressing form which will update r1.
55  */
56 static int store_updates_sp(struct pt_regs *regs)
57 {
58         unsigned int inst;
59
60         if (get_user(inst, (unsigned int __user *)regs->nip))
61                 return 0;
62         /* check for 1 in the rA field */
63         if (((inst >> 16) & 0x1f) != 1)
64                 return 0;
65         /* check major opcode */
66         switch (inst >> 26) {
67         case 37:        /* stwu */
68         case 39:        /* stbu */
69         case 45:        /* sthu */
70         case 53:        /* stfsu */
71         case 55:        /* stfdu */
72                 return 1;
73         case 31:
74                 /* check minor opcode */
75                 switch ((inst >> 1) & 0x3ff) {
76                 case 183:       /* stwux */
77                 case 247:       /* stbux */
78                 case 439:       /* sthux */
79                 case 695:       /* stfsux */
80                 case 759:       /* stfdux */
81                         return 1;
82                 }
83         }
84         return 0;
85 }
86
87 /*
88  * For 600- and 800-family processors, the error_code parameter is DSISR
89  * for a data fault, SRR1 for an instruction fault. For 400-family processors
90  * the error_code parameter is ESR for a data fault, 0 for an instruction
91  * fault.
92  */
93 int do_page_fault(struct pt_regs *regs, unsigned long address,
94                   unsigned long error_code)
95 {
96         struct vm_area_struct * vma;
97         struct mm_struct *mm = current->mm;
98         siginfo_t info;
99         int code = SEGV_MAPERR;
100 #if defined(CONFIG_4xx) || defined (CONFIG_BOOKE)
101         int is_write = error_code & ESR_DST;
102 #else
103         int is_write = 0;
104
105         /*
106          * Fortunately the bit assignments in SRR1 for an instruction
107          * fault and DSISR for a data fault are mostly the same for the
108          * bits we are interested in.  But there are some bits which
109          * indicate errors in DSISR but can validly be set in SRR1.
110          */
111         if (TRAP(regs) == 0x400)
112                 error_code &= 0x48200000;
113         else
114                 is_write = error_code & 0x02000000;
115 #endif /* CONFIG_4xx || CONFIG_BOOKE */
116
117 #if defined(CONFIG_XMON) || defined(CONFIG_KGDB)
118         if (debugger_fault_handler && TRAP(regs) == 0x300) {
119                 debugger_fault_handler(regs);
120                 return 0;
121         }
122 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
123         if (error_code & 0x00400000) {
124                 /* DABR match */
125                 if (debugger_dabr_match(regs))
126                         return 0;
127         }
128 #endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
129 #endif /* CONFIG_XMON || CONFIG_KGDB */
130
131         if (in_atomic() || mm == NULL)
132                 return SIGSEGV;
133
134         down_read(&mm->mmap_sem);
135         vma = find_vma(mm, address);
136         if (!vma)
137                 goto bad_area;
138         if (vma->vm_start <= address)
139                 goto good_area;
140         if (!(vma->vm_flags & VM_GROWSDOWN))
141                 goto bad_area;
142         if (!is_write)
143                 goto bad_area;
144
145         /*
146          * N.B. The rs6000/xcoff ABI allows programs to access up to
147          * a few hundred bytes below the stack pointer.
148          * The kernel signal delivery code writes up to about 1.5kB
149          * below the stack pointer (r1) before decrementing it.
150          * The exec code can write slightly over 640kB to the stack
151          * before setting the user r1.  Thus we allow the stack to
152          * expand to 1MB without further checks.
153          */
154         if (address + 0x100000 < vma->vm_end) {
155                 /* get user regs even if this fault is in kernel mode */
156                 struct pt_regs *uregs = current->thread.regs;
157                 if (uregs == NULL)
158                         goto bad_area;
159
160                 /*
161                  * A user-mode access to an address a long way below
162                  * the stack pointer is only valid if the instruction
163                  * is one which would update the stack pointer to the
164                  * address accessed if the instruction completed,
165                  * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
166                  * (or the byte, halfword, float or double forms).
167                  *
168                  * If we don't check this then any write to the area
169                  * between the last mapped region and the stack will
170                  * expand the stack rather than segfaulting.
171                  */
172                 if (address + 2048 < uregs->gpr[1]
173                     && (!user_mode(regs) || !store_updates_sp(regs)))
174                         goto bad_area;
175         }
176         if (expand_stack(vma, address))
177                 goto bad_area;
178
179 good_area:
180         code = SEGV_ACCERR;
181 #if defined(CONFIG_6xx)
182         if (error_code & 0x95700000)
183                 /* an error such as lwarx to I/O controller space,
184                    address matching DABR, eciwx, etc. */
185                 goto bad_area;
186 #endif /* CONFIG_6xx */
187 #if defined(CONFIG_8xx)
188         /* The MPC8xx seems to always set 0x80000000, which is
189          * "undefined".  Of those that can be set, this is the only
190          * one which seems bad.
191          */
192         if (error_code & 0x10000000)
193                 /* Guarded storage error. */
194                 goto bad_area;
195 #endif /* CONFIG_8xx */
196
197         /* a write */
198         if (is_write) {
199                 if (!(vma->vm_flags & VM_WRITE))
200                         goto bad_area;
201 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
202         /* an exec  - 4xx/Book-E allows for per-page execute permission */
203         } else if (TRAP(regs) == 0x400) {
204                 pte_t *ptep;
205                 pmd_t *pmdp;
206
207 #if 0
208                 /* It would be nice to actually enforce the VM execute
209                    permission on CPUs which can do so, but far too
210                    much stuff in userspace doesn't get the permissions
211                    right, so we let any page be executed for now. */
212                 if (! (vma->vm_flags & VM_EXEC))
213                         goto bad_area;
214 #endif
215
216                 /* Since 4xx/Book-E supports per-page execute permission,
217                  * we lazily flush dcache to icache. */
218                 ptep = NULL;
219                 if (get_pteptr(mm, address, &ptep, &pmdp)) {
220                         spinlock_t *ptl = pte_lockptr(mm, pmdp);
221                         spin_lock(ptl);
222                         if (pte_present(*ptep)) {
223                                 struct page *page = pte_page(*ptep);
224
225                                 if (!test_bit(PG_arch_1, &page->flags)) {
226                                         flush_dcache_icache_page(page);
227                                         set_bit(PG_arch_1, &page->flags);
228                                 }
229                                 pte_update(ptep, 0, _PAGE_HWEXEC);
230                                 _tlbie(address);
231                                 pte_unmap_unlock(ptep, ptl);
232                                 up_read(&mm->mmap_sem);
233                                 return 0;
234                         }
235                         pte_unmap_unlock(ptep, ptl);
236                 }
237 #endif
238         /* a read */
239         } else {
240                 /* protection fault */
241                 if (error_code & 0x08000000)
242                         goto bad_area;
243                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
244                         goto bad_area;
245         }
246
247         /*
248          * If for any reason at all we couldn't handle the fault,
249          * make sure we exit gracefully rather than endlessly redo
250          * the fault.
251          */
252  survive:
253         switch (handle_mm_fault(mm, vma, address, is_write)) {
254         case VM_FAULT_MINOR:
255                 current->min_flt++;
256                 break;
257         case VM_FAULT_MAJOR:
258                 current->maj_flt++;
259                 break;
260         case VM_FAULT_SIGBUS:
261                 goto do_sigbus;
262         case VM_FAULT_OOM:
263                 goto out_of_memory;
264         default:
265                 BUG();
266         }
267
268         up_read(&mm->mmap_sem);
269         /*
270          * keep track of tlb+htab misses that are good addrs but
271          * just need pte's created via handle_mm_fault()
272          * -- Cort
273          */
274         pte_misses++;
275         return 0;
276
277 bad_area:
278         up_read(&mm->mmap_sem);
279         pte_errors++;
280
281         /* User mode accesses cause a SIGSEGV */
282         if (user_mode(regs)) {
283                 _exception(SIGSEGV, regs, code, address);
284                 return 0;
285         }
286
287         return SIGSEGV;
288
289 /*
290  * We ran out of memory, or some other thing happened to us that made
291  * us unable to handle the page fault gracefully.
292  */
293 out_of_memory:
294         up_read(&mm->mmap_sem);
295         if (current->pid == 1) {
296                 yield();
297                 down_read(&mm->mmap_sem);
298                 goto survive;
299         }
300         printk("VM: killing process %s\n", current->comm);
301         if (user_mode(regs))
302                 do_exit(SIGKILL);
303         return SIGKILL;
304
305 do_sigbus:
306         up_read(&mm->mmap_sem);
307         info.si_signo = SIGBUS;
308         info.si_errno = 0;
309         info.si_code = BUS_ADRERR;
310         info.si_addr = (void __user *)address;
311         force_sig_info (SIGBUS, &info, current);
312         if (!user_mode(regs))
313                 return SIGBUS;
314         return 0;
315 }
316
317 /*
318  * bad_page_fault is called when we have a bad access from the kernel.
319  * It is called from the DSI and ISI handlers in head.S and from some
320  * of the procedures in traps.c.
321  */
322 void
323 bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
324 {
325         const struct exception_table_entry *entry;
326
327         /* Are we prepared to handle this fault?  */
328         if ((entry = search_exception_tables(regs->nip)) != NULL) {
329                 regs->nip = entry->fixup;
330                 return;
331         }
332
333         /* kernel has accessed a bad area */
334 #if defined(CONFIG_XMON) || defined(CONFIG_KGDB)
335         if (debugger_kernel_faults)
336                 debugger(regs);
337 #endif
338         die("kernel access of bad area", regs, sig);
339 }
340
341 #ifdef CONFIG_8xx
342
343 /* The pgtable.h claims some functions generically exist, but I
344  * can't find them......
345  */
346 pte_t *va_to_pte(unsigned long address)
347 {
348         pgd_t *dir;
349         pmd_t *pmd;
350         pte_t *pte;
351
352         if (address < TASK_SIZE)
353                 return NULL;
354
355         dir = pgd_offset(&init_mm, address);
356         if (dir) {
357                 pmd = pmd_offset(dir, address & PAGE_MASK);
358                 if (pmd && pmd_present(*pmd)) {
359                         pte = pte_offset_kernel(pmd, address & PAGE_MASK);
360                         if (pte && pte_present(*pte))
361                                 return(pte);
362                 }
363         }
364         return NULL;
365 }
366
367 unsigned long va_to_phys(unsigned long address)
368 {
369         pte_t *pte;
370
371         pte = va_to_pte(address);
372         if (pte)
373                 return(((unsigned long)(pte_val(*pte)) & PAGE_MASK) | (address & ~(PAGE_MASK)));
374         return (0);
375 }
376
377 void
378 print_8xx_pte(struct mm_struct *mm, unsigned long addr)
379 {
380         pgd_t * pgd;
381         pmd_t * pmd;
382         pte_t * pte;
383
384         printk(" pte @ 0x%8lx: ", addr);
385         pgd = pgd_offset(mm, addr & PAGE_MASK);
386         if (pgd) {
387                 pmd = pmd_offset(pgd, addr & PAGE_MASK);
388                 if (pmd && pmd_present(*pmd)) {
389                         pte = pte_offset_kernel(pmd, addr & PAGE_MASK);
390                         if (pte) {
391                                 printk(" (0x%08lx)->(0x%08lx)->0x%08lx\n",
392                                         (long)pgd, (long)pte, (long)pte_val(*pte));
393 #define pp ((long)pte_val(*pte))                        
394                                 printk(" RPN: %05lx PP: %lx SPS: %lx SH: %lx "
395                                        "CI: %lx v: %lx\n",
396                                        pp>>12,    /* rpn */
397                                        (pp>>10)&3, /* pp */
398                                        (pp>>3)&1, /* small */
399                                        (pp>>2)&1, /* shared */
400                                        (pp>>1)&1, /* cache inhibit */
401                                        pp&1       /* valid */
402                                        );
403 #undef pp                       
404                         }
405                         else {
406                                 printk("no pte\n");
407                         }
408                 }
409                 else {
410                         printk("no pmd\n");
411                 }
412         }
413         else {
414                 printk("no pgd\n");
415         }
416 }
417
418 int
419 get_8xx_pte(struct mm_struct *mm, unsigned long addr)
420 {
421         pgd_t * pgd;
422         pmd_t * pmd;
423         pte_t * pte;
424         int     retval = 0;
425
426         pgd = pgd_offset(mm, addr & PAGE_MASK);
427         if (pgd) {
428                 pmd = pmd_offset(pgd, addr & PAGE_MASK);
429                 if (pmd && pmd_present(*pmd)) {
430                         pte = pte_offset_kernel(pmd, addr & PAGE_MASK);
431                         if (pte) {
432                                 retval = (int)pte_val(*pte);
433                         }
434                 }
435         }
436         return(retval);
437 }
438 #endif /* CONFIG_8xx */