PPC32: This changeset adds preemptible kernel support for ppc32
[opensuse:kernel.git] / arch / ppc / mm / fault.c
1 /*
2  * BK Id: %F% %I% %G% %U% %#%
3  */
4 /*
5  *  arch/ppc/mm/fault.c
6  *
7  *  PowerPC version 
8  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
9  *
10  *  Derived from "arch/i386/mm/fault.c"
11  *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
12  *
13  *  Modified by Cort Dougan and Paul Mackerras.
14  *
15  *  This program is free software; you can redistribute it and/or
16  *  modify it under the terms of the GNU General Public License
17  *  as published by the Free Software Foundation; either version
18  *  2 of the License, or (at your option) any later version.
19  */
20
21 #include <linux/config.h>
22 #include <linux/signal.h>
23 #include <linux/sched.h>
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/string.h>
27 #include <linux/types.h>
28 #include <linux/ptrace.h>
29 #include <linux/mman.h>
30 #include <linux/mm.h>
31 #include <linux/interrupt.h>
32 #include <linux/highmem.h>
33
34 #include <asm/page.h>
35 #include <asm/pgtable.h>
36 #include <asm/mmu.h>
37 #include <asm/mmu_context.h>
38 #include <asm/system.h>
39 #include <asm/uaccess.h>
40 #include <asm/tlbflush.h>
41
42 #if defined(CONFIG_XMON) || defined(CONFIG_KGDB)
43 extern void (*debugger)(struct pt_regs *);
44 extern void (*debugger_fault_handler)(struct pt_regs *);
45 extern int (*debugger_dabr_match)(struct pt_regs *);
46 int debugger_kernel_faults = 1;
47 #endif
48
49 unsigned long htab_reloads;     /* updated by hashtable.S:hash_page() */
50 unsigned long htab_evicts;      /* updated by hashtable.S:hash_page() */
51 unsigned long htab_preloads;    /* updated by hashtable.S:add_hash_page() */
52 unsigned long pte_misses;       /* updated by do_page_fault() */
53 unsigned long pte_errors;       /* updated by do_page_fault() */
54 unsigned int probingmem;
55
56 extern void die_if_kernel(char *, struct pt_regs *, long);
57 void bad_page_fault(struct pt_regs *, unsigned long, int sig);
58 void do_page_fault(struct pt_regs *, unsigned long, unsigned long);
59 extern int get_pteptr(struct mm_struct *mm, unsigned long addr, pte_t **ptep);
60
61 /*
62  * For 600- and 800-family processors, the error_code parameter is DSISR
63  * for a data fault, SRR1 for an instruction fault. For 400-family processors
64  * the error_code parameter is ESR for a data fault, 0 for an instruction
65  * fault.
66  */
67 void do_page_fault(struct pt_regs *regs, unsigned long address,
68                    unsigned long error_code)
69 {
70         struct vm_area_struct * vma;
71         struct mm_struct *mm = current->mm;
72         siginfo_t info;
73         int code = SEGV_MAPERR;
74 #if defined(CONFIG_4xx)
75         int is_write = error_code & ESR_DST;
76 #else
77         int is_write = 0;
78
79         /*
80          * Fortunately the bit assignments in SRR1 for an instruction
81          * fault and DSISR for a data fault are mostly the same for the
82          * bits we are interested in.  But there are some bits which
83          * indicate errors in DSISR but can validly be set in SRR1.
84          */
85         if (TRAP(regs) == 0x400)
86                 error_code &= 0x48200000;
87         else
88                 is_write = error_code & 0x02000000;
89 #endif /* CONFIG_4xx */
90
91 #if defined(CONFIG_XMON) || defined(CONFIG_KGDB)
92         if (debugger_fault_handler && TRAP(regs) == 0x300) {
93                 debugger_fault_handler(regs);
94                 return;
95         }
96 #if !defined(CONFIG_4xx)
97         if (error_code & 0x00400000) {
98                 /* DABR match */
99                 if (debugger_dabr_match(regs))
100                         return;
101         }
102 #endif /* !CONFIG_4xx */
103 #endif /* CONFIG_XMON || CONFIG_KGDB */
104
105         if (in_interrupt() || mm == NULL) {
106                 bad_page_fault(regs, address, SIGSEGV);
107                 return;
108         }
109         down_read(&mm->mmap_sem);
110         vma = find_vma(mm, address);
111         if (!vma)
112                 goto bad_area;
113         if (vma->vm_start <= address)
114                 goto good_area;
115         if (!(vma->vm_flags & VM_GROWSDOWN))
116                 goto bad_area;
117         if (expand_stack(vma, address))
118                 goto bad_area;
119
120 good_area:
121         code = SEGV_ACCERR;
122 #if defined(CONFIG_6xx)
123         if (error_code & 0x95700000)
124                 /* an error such as lwarx to I/O controller space,
125                    address matching DABR, eciwx, etc. */
126                 goto bad_area;
127 #endif /* CONFIG_6xx */
128 #if defined(CONFIG_8xx)
129         /* The MPC8xx seems to always set 0x80000000, which is
130          * "undefined".  Of those that can be set, this is the only
131          * one which seems bad.
132          */
133         if (error_code & 0x10000000)
134                 /* Guarded storage error. */
135                 goto bad_area;
136 #endif /* CONFIG_8xx */
137         
138         /* a write */
139         if (is_write) {
140                 if (!(vma->vm_flags & VM_WRITE))
141                         goto bad_area;
142 #if defined(CONFIG_4xx)
143         /* an exec  - 4xx allows for per-page execute permission */
144         } else if (TRAP(regs) == 0x400) {
145                 pte_t *ptep;
146
147 #if 0
148                 /* It would be nice to actually enforce the VM execute
149                    permission on CPUs which can do so, but far too
150                    much stuff in userspace doesn't get the permissions
151                    right, so we let any page be executed for now. */
152                 if (! (vma->vm_flags & VM_EXEC))
153                         goto bad_area;
154 #endif
155
156                 /* Since 4xx supports per-page execute permission,
157                  * we lazily flush dcache to icache. */
158                 ptep = NULL;
159                 if (get_pteptr(mm, address, &ptep) && pte_present(*ptep)) {
160                         struct page *page = pte_page(*ptep);
161
162                         if (! test_bit(PG_arch_1, &page->flags)) {
163                                 unsigned long phys = page_to_pfn(page) << PAGE_SHIFT;
164                                 __flush_dcache_icache_phys(phys);
165                                 set_bit(PG_arch_1, &page->flags);
166                         }
167                         pte_update(ptep, 0, _PAGE_HWEXEC);
168                         _tlbie(address);
169                         pte_unmap(ptep);
170                         up_read(&mm->mmap_sem);
171                         return;
172                 }
173                 if (ptep != NULL)
174                         pte_unmap(ptep);
175 #endif
176         /* a read */
177         } else {
178                 /* protection fault */
179                 if (error_code & 0x08000000)
180                         goto bad_area;
181                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
182                         goto bad_area;
183         }
184
185         /*
186          * If for any reason at all we couldn't handle the fault,
187          * make sure we exit gracefully rather than endlessly redo
188          * the fault.
189          */
190  survive:
191         switch (handle_mm_fault(mm, vma, address, is_write)) {
192         case 1:
193                 current->min_flt++;
194                 break;
195         case 2:
196                 current->maj_flt++;
197                 break;
198         case 0:
199                 goto do_sigbus;
200         default:
201                 goto out_of_memory;
202         }
203
204         up_read(&mm->mmap_sem);
205         /*
206          * keep track of tlb+htab misses that are good addrs but
207          * just need pte's created via handle_mm_fault()
208          * -- Cort
209          */
210         pte_misses++;
211         return;
212
213 bad_area:
214         up_read(&mm->mmap_sem);
215         pte_errors++;   
216
217         /* User mode accesses cause a SIGSEGV */
218         if (user_mode(regs)) {
219                 info.si_signo = SIGSEGV;
220                 info.si_errno = 0;
221                 info.si_code = code;
222                 info.si_addr = (void *) address;
223                 force_sig_info(SIGSEGV, &info, current);
224                 return;
225         }
226
227         bad_page_fault(regs, address, SIGSEGV);
228         return;
229
230 /*
231  * We ran out of memory, or some other thing happened to us that made
232  * us unable to handle the page fault gracefully.
233  */
234 out_of_memory:
235         up_read(&mm->mmap_sem);
236         if (current->pid == 1) {
237                 yield();
238                 down_read(&mm->mmap_sem);
239                 goto survive;
240         }
241         printk("VM: killing process %s\n", current->comm);
242         if (user_mode(regs))
243                 do_exit(SIGKILL);
244         bad_page_fault(regs, address, SIGKILL);
245         return;
246
247 do_sigbus:
248         up_read(&mm->mmap_sem);
249         info.si_signo = SIGBUS;
250         info.si_errno = 0;
251         info.si_code = BUS_ADRERR;
252         info.si_addr = (void *)address;
253         force_sig_info (SIGBUS, &info, current);
254         if (!user_mode(regs))
255                 bad_page_fault(regs, address, SIGBUS);
256 }
257
258 /*
259  * bad_page_fault is called when we have a bad access from the kernel.
260  * It is called from do_page_fault above and from some of the procedures
261  * in traps.c.
262  */
263 void
264 bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
265 {
266         extern void die(const char *,struct pt_regs *,long);
267
268         unsigned long fixup;
269
270         /* Are we prepared to handle this fault?  */
271         if ((fixup = search_exception_table(regs->nip)) != 0) {
272                 regs->nip = fixup;
273                 return;
274         }
275
276         /* kernel has accessed a bad area */
277 #if defined(CONFIG_XMON) || defined(CONFIG_KGDB)
278         if (debugger_kernel_faults)
279                 debugger(regs);
280 #endif
281         die("kernel access of bad area", regs, sig);
282 }
283
284 #ifdef CONFIG_8xx
285
286 /* The pgtable.h claims some functions generically exist, but I
287  * can't find them......
288  */
289 pte_t *va_to_pte(unsigned long address)
290 {
291         pgd_t *dir;
292         pmd_t *pmd;
293         pte_t *pte;
294         struct mm_struct *mm;
295
296         if (address < TASK_SIZE)
297                 return NULL;
298
299         dir = pgd_offset(&init_mm, address);
300         if (dir) {
301                 pmd = pmd_offset(dir, address & PAGE_MASK);
302                 if (pmd && pmd_present(*pmd)) {
303                         pte = pte_offset_kernel(pmd, address & PAGE_MASK);
304                         if (pte && pte_present(*pte))
305                                 return(pte);
306                 }
307         }
308         return NULL;
309 }
310
311 unsigned long va_to_phys(unsigned long address)
312 {
313         pte_t *pte;
314         
315         pte = va_to_pte(address);
316         if (pte)
317                 return(((unsigned long)(pte_val(*pte)) & PAGE_MASK) | (address & ~(PAGE_MASK)));
318         return (0);
319 }
320
321 void
322 print_8xx_pte(struct mm_struct *mm, unsigned long addr)
323 {
324         pgd_t * pgd;
325         pmd_t * pmd;
326         pte_t * pte;
327
328         printk(" pte @ 0x%8lx: ", addr);
329         pgd = pgd_offset(mm, addr & PAGE_MASK);
330         if (pgd) {
331                 pmd = pmd_offset(pgd, addr & PAGE_MASK);
332                 if (pmd && pmd_present(*pmd)) {
333                         pte = pte_offset_kernel(pmd, addr & PAGE_MASK);
334                         if (pte) {
335                                 printk(" (0x%08lx)->(0x%08lx)->0x%08lx\n",
336                                         (long)pgd, (long)pte, (long)pte_val(*pte));
337 #define pp ((long)pte_val(*pte))                                
338                                 printk(" RPN: %05lx PP: %lx SPS: %lx SH: %lx "
339                                        "CI: %lx v: %lx\n",
340                                        pp>>12,    /* rpn */
341                                        (pp>>10)&3, /* pp */
342                                        (pp>>3)&1, /* small */
343                                        (pp>>2)&1, /* shared */
344                                        (pp>>1)&1, /* cache inhibit */
345                                        pp&1       /* valid */
346                                        );
347 #undef pp                               
348                         }
349                         else {
350                                 printk("no pte\n");
351                         }
352                 }
353                 else {
354                         printk("no pmd\n");
355                 }
356         }
357         else {
358                 printk("no pgd\n");
359         }
360 }
361
362 int
363 get_8xx_pte(struct mm_struct *mm, unsigned long addr)
364 {
365         pgd_t * pgd;
366         pmd_t * pmd;
367         pte_t * pte;
368         int     retval = 0;
369
370         pgd = pgd_offset(mm, addr & PAGE_MASK);
371         if (pgd) {
372                 pmd = pmd_offset(pgd, addr & PAGE_MASK);
373                 if (pmd && pmd_present(*pmd)) {
374                         pte = pte_offset_kernel(pmd, addr & PAGE_MASK);
375                         if (pte) {
376                                 retval = (int)pte_val(*pte);
377                         }
378                 }
379         }
380         return(retval);
381 }
382 #endif /* CONFIG_8xx */