Linux-2.6.12-rc2
[linux-3.10.git] / arch / arm26 / mm / fault.c
1 /*
2  *  linux/arch/arm26/mm/fault.c
3  *
4  *  Copyright (C) 1995  Linus Torvalds
5  *  Modifications for ARM processor (c) 1995-2001 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/config.h>
12 #include <linux/signal.h>
13 #include <linux/sched.h>
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/string.h>
17 #include <linux/types.h>
18 #include <linux/ptrace.h>
19 #include <linux/mman.h>
20 #include <linux/mm.h>
21 #include <linux/interrupt.h>
22 #include <linux/proc_fs.h>
23 #include <linux/init.h>
24
25 #include <asm/system.h>
26 #include <asm/pgtable.h>
27 #include <asm/uaccess.h> //FIXME this header may be bogusly included
28
29 #include "fault.h"
30
31 #define FAULT_CODE_LDRSTRPOST   0x80
32 #define FAULT_CODE_LDRSTRPRE    0x40
33 #define FAULT_CODE_LDRSTRREG    0x20
34 #define FAULT_CODE_LDMSTM       0x10
35 #define FAULT_CODE_LDCSTC       0x08
36 #define FAULT_CODE_PREFETCH     0x04
37 #define FAULT_CODE_WRITE        0x02
38 #define FAULT_CODE_FORCECOW     0x01
39
40 #define DO_COW(m)               ((m) & (FAULT_CODE_WRITE|FAULT_CODE_FORCECOW))
41 #define READ_FAULT(m)           (!((m) & FAULT_CODE_WRITE))
42 #define DEBUG
43 /*
44  * This is useful to dump out the page tables associated with
45  * 'addr' in mm 'mm'.
46  */
47 void show_pte(struct mm_struct *mm, unsigned long addr)
48 {
49         pgd_t *pgd;
50
51         if (!mm)
52                 mm = &init_mm;
53
54         printk(KERN_ALERT "pgd = %p\n", mm->pgd);
55         pgd = pgd_offset(mm, addr);
56         printk(KERN_ALERT "[%08lx] *pgd=%08lx", addr, pgd_val(*pgd));
57
58         do {
59                 pmd_t *pmd;
60                 pte_t *pte;
61
62                 pmd = pmd_offset(pgd, addr);
63
64                 if (pmd_none(*pmd))
65                         break;
66
67                 if (pmd_bad(*pmd)) {
68                         printk("(bad)");
69                         break;
70                 }
71
72                 /* We must not map this if we have highmem enabled */
73                 /* FIXME */
74                 pte = pte_offset_map(pmd, addr);
75                 printk(", *pte=%08lx", pte_val(*pte));
76                 pte_unmap(pte);
77         } while(0);
78
79         printk("\n");
80 }
81
82 /*
83  * Oops.  The kernel tried to access some page that wasn't present.
84  */
85 static void
86 __do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
87                   struct pt_regs *regs)
88 {
89         /*
90          * Are we prepared to handle this kernel fault?
91          */
92         if (fixup_exception(regs))
93                 return;
94
95         /*
96          * No handler, we'll have to terminate things with extreme prejudice.
97          */
98         bust_spinlocks(1);
99         printk(KERN_ALERT
100                 "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, fsr);
106         bust_spinlocks(0);
107         do_exit(SIGKILL);
108 }
109
110 /*
111  * Something tried to access memory that isn't in our memory map..
112  * User mode accesses just cause a SIGSEGV
113  */
114 static void
115 __do_user_fault(struct task_struct *tsk, unsigned long addr,
116                 unsigned int fsr, int code, struct pt_regs *regs)
117 {
118         struct siginfo si;
119
120 #ifdef CONFIG_DEBUG_USER
121         printk("%s: unhandled page fault at 0x%08lx, code 0x%03x\n",
122                tsk->comm, addr, fsr);
123         show_pte(tsk->mm, addr);
124         show_regs(regs);
125         //dump_backtrace(regs, tsk); // FIXME ARM32 dropped this - why?
126         while(1); //FIXME - hack to stop debug going nutso
127 #endif
128
129         tsk->thread.address = addr;
130         tsk->thread.error_code = fsr;
131         tsk->thread.trap_no = 14;
132         si.si_signo = SIGSEGV;
133         si.si_errno = 0;
134         si.si_code = code;
135         si.si_addr = (void *)addr;
136         force_sig_info(SIGSEGV, &si, tsk);
137 }
138
139 static int
140 __do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
141                 struct task_struct *tsk)
142 {
143         struct vm_area_struct *vma;
144         int fault, mask;
145
146         vma = find_vma(mm, addr);
147         fault = -2; /* bad map area */
148         if (!vma)
149                 goto out;
150         if (vma->vm_start > addr)
151                 goto check_stack;
152
153         /*
154          * Ok, we have a good vm_area for this
155          * memory access, so we can handle it.
156          */
157 good_area:
158         if (READ_FAULT(fsr)) /* read? */
159                 mask = VM_READ|VM_EXEC;
160         else
161                 mask = VM_WRITE;
162
163         fault = -1; /* bad access type */
164         if (!(vma->vm_flags & mask))
165                 goto out;
166
167         /*
168          * If for any reason at all we couldn't handle
169          * the fault, make sure we exit gracefully rather
170          * than endlessly redo the fault.
171          */
172 survive:
173         fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, DO_COW(fsr));
174
175         /*
176          * Handle the "normal" cases first - successful and sigbus
177          */
178         switch (fault) {
179         case 2:
180                 tsk->maj_flt++;
181                 return fault;
182         case 1:
183                 tsk->min_flt++;
184         case 0:
185                 return fault;
186         }
187
188         fault = -3; /* out of memory */
189         if (tsk->pid != 1)
190                 goto out;
191
192         /*
193          * If we are out of memory for pid1,
194          * sleep for a while and retry
195          */
196         yield();
197         goto survive;
198
199 check_stack:
200         if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
201                 goto good_area;
202 out:
203         return fault;
204 }
205
206 int do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
207 {
208         struct task_struct *tsk;
209         struct mm_struct *mm;
210         int fault;
211
212         tsk = current;
213         mm  = tsk->mm;
214
215         /*
216          * If we're in an interrupt or have no user
217          * context, we must not take the fault..
218          */
219         if (in_interrupt() || !mm)
220                 goto no_context;
221
222         down_read(&mm->mmap_sem);
223         fault = __do_page_fault(mm, addr, fsr, tsk);
224         up_read(&mm->mmap_sem);
225
226         /*
227          * Handle the "normal" case first
228          */
229         if (fault > 0)
230                 return 0;
231
232         /*
233          * We had some memory, but were unable to
234          * successfully fix up this page fault.
235          */
236         if (fault == 0){
237                 goto do_sigbus;
238         }
239
240         /*
241          * If we are in kernel mode at this point, we
242          * have no context to handle this fault with.
243          * FIXME - is this test right?
244          */
245         if (!user_mode(regs)){
246                 goto no_context;
247         }
248
249         if (fault == -3) {
250                 /*
251                  * We ran out of memory, or some other thing happened to
252                  * us that made us unable to handle the page fault gracefully.
253                  */
254                 printk("VM: killing process %s\n", tsk->comm);
255                 do_exit(SIGKILL);
256         }
257         else{
258                 __do_user_fault(tsk, addr, fsr, fault == -1 ? SEGV_ACCERR : SEGV_MAPERR, regs);
259         }
260
261         return 0;
262
263
264 /*
265  * We ran out of memory, or some other thing happened to us that made
266  * us unable to handle the page fault gracefully.
267  */
268 do_sigbus:
269         /*
270          * Send a sigbus, regardless of whether we were in kernel
271          * or user mode.
272          */
273         tsk->thread.address = addr;  //FIXME - need other bits setting?
274         tsk->thread.error_code = fsr;
275         tsk->thread.trap_no = 14;
276         force_sig(SIGBUS, tsk);
277 #ifdef CONFIG_DEBUG_USER
278         printk(KERN_DEBUG "%s: sigbus at 0x%08lx, pc=0x%08lx\n",
279                 current->comm, addr, instruction_pointer(regs));
280 #endif
281
282         /* Kernel mode? Handle exceptions or die */
283         if (user_mode(regs))
284                 return 0;
285
286 no_context:
287         __do_kernel_fault(mm, addr, fsr, regs);
288         return 0;
289 }
290
291 /*
292  * Handle a data abort.  Note that we have to handle a range of addresses
293  * on ARM2/3 for ldm.  If both pages are zero-mapped, then we have to force
294  * a copy-on-write.  However, on the second page, we always force COW.
295  */
296 asmlinkage void
297 do_DataAbort(unsigned long min_addr, unsigned long max_addr, int mode, struct pt_regs *regs)
298 {
299         do_page_fault(min_addr, mode, regs);
300
301         if ((min_addr ^ max_addr) >> PAGE_SHIFT){
302                do_page_fault(max_addr, mode | FAULT_CODE_FORCECOW, regs);
303         }
304 }
305
306 asmlinkage int
307 do_PrefetchAbort(unsigned long addr, struct pt_regs *regs)
308 {
309 #if 0
310         if (the memc mapping for this page exists) {
311                 printk ("Page in, but got abort (undefined instruction?)\n");
312                 return 0;
313         }
314 #endif
315         do_page_fault(addr, FAULT_CODE_PREFETCH, regs);
316         return 1;
317 }
318