arch/m68k/mm/motorola.c: Eliminate NULL test and memset after alloc_bootmem
[linux-3.10.git] / arch / m68k / mm / fault.c
1 /*
2  *  linux/arch/m68k/mm/fault.c
3  *
4  *  Copyright (C) 1995  Hamish Macdonald
5  */
6
7 #include <linux/mman.h>
8 #include <linux/mm.h>
9 #include <linux/kernel.h>
10 #include <linux/ptrace.h>
11 #include <linux/interrupt.h>
12 #include <linux/module.h>
13
14 #include <asm/setup.h>
15 #include <asm/traps.h>
16 #include <asm/system.h>
17 #include <asm/uaccess.h>
18 #include <asm/pgalloc.h>
19
20 extern void die_if_kernel(char *, struct pt_regs *, long);
21 extern const int frame_extra_sizes[]; /* in m68k/kernel/signal.c */
22
23 int send_fault_sig(struct pt_regs *regs)
24 {
25         siginfo_t siginfo = { 0, 0, 0, };
26
27         siginfo.si_signo = current->thread.signo;
28         siginfo.si_code = current->thread.code;
29         siginfo.si_addr = (void *)current->thread.faddr;
30 #ifdef DEBUG
31         printk("send_fault_sig: %p,%d,%d\n", siginfo.si_addr, siginfo.si_signo, siginfo.si_code);
32 #endif
33
34         if (user_mode(regs)) {
35                 force_sig_info(siginfo.si_signo,
36                                &siginfo, current);
37         } else {
38                 const struct exception_table_entry *fixup;
39
40                 /* Are we prepared to handle this kernel fault? */
41                 if ((fixup = search_exception_tables(regs->pc))) {
42                         struct pt_regs *tregs;
43                         /* Create a new four word stack frame, discarding the old
44                            one.  */
45                         regs->stkadj = frame_extra_sizes[regs->format];
46                         tregs = (struct pt_regs *)((ulong)regs + regs->stkadj);
47                         tregs->vector = regs->vector;
48                         tregs->format = 0;
49                         tregs->pc = fixup->fixup;
50                         tregs->sr = regs->sr;
51                         return -1;
52                 }
53
54                 //if (siginfo.si_signo == SIGBUS)
55                 //      force_sig_info(siginfo.si_signo,
56                 //                     &siginfo, current);
57
58                 /*
59                  * Oops. The kernel tried to access some bad page. We'll have to
60                  * terminate things with extreme prejudice.
61                  */
62                 if ((unsigned long)siginfo.si_addr < PAGE_SIZE)
63                         printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
64                 else
65                         printk(KERN_ALERT "Unable to handle kernel access");
66                 printk(" at virtual address %p\n", siginfo.si_addr);
67                 die_if_kernel("Oops", regs, 0 /*error_code*/);
68                 do_exit(SIGKILL);
69         }
70
71         return 1;
72 }
73
74 /*
75  * This routine handles page faults.  It determines the problem, and
76  * then passes it off to one of the appropriate routines.
77  *
78  * error_code:
79  *      bit 0 == 0 means no page found, 1 means protection fault
80  *      bit 1 == 0 means read, 1 means write
81  *
82  * If this routine detects a bad access, it returns 1, otherwise it
83  * returns 0.
84  */
85 int do_page_fault(struct pt_regs *regs, unsigned long address,
86                               unsigned long error_code)
87 {
88         struct mm_struct *mm = current->mm;
89         struct vm_area_struct * vma;
90         int write, fault;
91
92 #ifdef DEBUG
93         printk ("do page fault:\nregs->sr=%#x, regs->pc=%#lx, address=%#lx, %ld, %p\n",
94                 regs->sr, regs->pc, address, error_code,
95                 current->mm->pgd);
96 #endif
97
98         /*
99          * If we're in an interrupt or have no user
100          * context, we must not take the fault..
101          */
102         if (in_atomic() || !mm)
103                 goto no_context;
104
105         down_read(&mm->mmap_sem);
106
107         vma = find_vma(mm, address);
108         if (!vma)
109                 goto map_err;
110         if (vma->vm_flags & VM_IO)
111                 goto acc_err;
112         if (vma->vm_start <= address)
113                 goto good_area;
114         if (!(vma->vm_flags & VM_GROWSDOWN))
115                 goto map_err;
116         if (user_mode(regs)) {
117                 /* Accessing the stack below usp is always a bug.  The
118                    "+ 256" is there due to some instructions doing
119                    pre-decrement on the stack and that doesn't show up
120                    until later.  */
121                 if (address + 256 < rdusp())
122                         goto map_err;
123         }
124         if (expand_stack(vma, address))
125                 goto map_err;
126
127 /*
128  * Ok, we have a good vm_area for this memory access, so
129  * we can handle it..
130  */
131 good_area:
132 #ifdef DEBUG
133         printk("do_page_fault: good_area\n");
134 #endif
135         write = 0;
136         switch (error_code & 3) {
137                 default:        /* 3: write, present */
138                         /* fall through */
139                 case 2:         /* write, not present */
140                         if (!(vma->vm_flags & VM_WRITE))
141                                 goto acc_err;
142                         write++;
143                         break;
144                 case 1:         /* read, present */
145                         goto acc_err;
146                 case 0:         /* read, not present */
147                         if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
148                                 goto acc_err;
149         }
150
151         /*
152          * If for any reason at all we couldn't handle the fault,
153          * make sure we exit gracefully rather than endlessly redo
154          * the fault.
155          */
156
157  survive:
158         fault = handle_mm_fault(mm, vma, address, write);
159 #ifdef DEBUG
160         printk("handle_mm_fault returns %d\n",fault);
161 #endif
162         if (unlikely(fault & VM_FAULT_ERROR)) {
163                 if (fault & VM_FAULT_OOM)
164                         goto out_of_memory;
165                 else if (fault & VM_FAULT_SIGBUS)
166                         goto bus_err;
167                 BUG();
168         }
169         if (fault & VM_FAULT_MAJOR)
170                 current->maj_flt++;
171         else
172                 current->min_flt++;
173
174         up_read(&mm->mmap_sem);
175         return 0;
176
177 /*
178  * We ran out of memory, or some other thing happened to us that made
179  * us unable to handle the page fault gracefully.
180  */
181 out_of_memory:
182         up_read(&mm->mmap_sem);
183         if (is_global_init(current)) {
184                 yield();
185                 down_read(&mm->mmap_sem);
186                 goto survive;
187         }
188
189         printk("VM: killing process %s\n", current->comm);
190         if (user_mode(regs))
191                 do_group_exit(SIGKILL);
192
193 no_context:
194         current->thread.signo = SIGBUS;
195         current->thread.faddr = address;
196         return send_fault_sig(regs);
197
198 bus_err:
199         current->thread.signo = SIGBUS;
200         current->thread.code = BUS_ADRERR;
201         current->thread.faddr = address;
202         goto send_sig;
203
204 map_err:
205         current->thread.signo = SIGSEGV;
206         current->thread.code = SEGV_MAPERR;
207         current->thread.faddr = address;
208         goto send_sig;
209
210 acc_err:
211         current->thread.signo = SIGSEGV;
212         current->thread.code = SEGV_ACCERR;
213         current->thread.faddr = address;
214
215 send_sig:
216         up_read(&mm->mmap_sem);
217         return send_fault_sig(regs);
218 }