Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / arch / sh / mm / fault_32.c
1 /*
2  * Page fault handler for SH with an MMU.
3  *
4  *  Copyright (C) 1999  Niibe Yutaka
5  *  Copyright (C) 2003 - 2009  Paul Mundt
6  *
7  *  Based on linux/arch/i386/mm/fault.c:
8  *   Copyright (C) 1995  Linus Torvalds
9  *
10  * This file is subject to the terms and conditions of the GNU General Public
11  * License.  See the file "COPYING" in the main directory of this archive
12  * for more details.
13  */
14 #include <linux/kernel.h>
15 #include <linux/mm.h>
16 #include <linux/hardirq.h>
17 #include <linux/kprobes.h>
18 #include <linux/perf_event.h>
19 #include <asm/io_trapped.h>
20 #include <asm/system.h>
21 #include <asm/mmu_context.h>
22 #include <asm/tlbflush.h>
23
24 static inline int notify_page_fault(struct pt_regs *regs, int trap)
25 {
26         int ret = 0;
27
28         if (kprobes_built_in() && !user_mode(regs)) {
29                 preempt_disable();
30                 if (kprobe_running() && kprobe_fault_handler(regs, trap))
31                         ret = 1;
32                 preempt_enable();
33         }
34
35         return ret;
36 }
37
38 static inline pmd_t *vmalloc_sync_one(pgd_t *pgd, unsigned long address)
39 {
40         unsigned index = pgd_index(address);
41         pgd_t *pgd_k;
42         pud_t *pud, *pud_k;
43         pmd_t *pmd, *pmd_k;
44
45         pgd += index;
46         pgd_k = init_mm.pgd + index;
47
48         if (!pgd_present(*pgd_k))
49                 return NULL;
50
51         pud = pud_offset(pgd, address);
52         pud_k = pud_offset(pgd_k, address);
53         if (!pud_present(*pud_k))
54                 return NULL;
55
56         if (!pud_present(*pud))
57             set_pud(pud, *pud_k);
58
59         pmd = pmd_offset(pud, address);
60         pmd_k = pmd_offset(pud_k, address);
61         if (!pmd_present(*pmd_k))
62                 return NULL;
63
64         if (!pmd_present(*pmd))
65                 set_pmd(pmd, *pmd_k);
66         else {
67                 /*
68                  * The page tables are fully synchronised so there must
69                  * be another reason for the fault. Return NULL here to
70                  * signal that we have not taken care of the fault.
71                  */
72                 BUG_ON(pmd_page(*pmd) != pmd_page(*pmd_k));
73                 return NULL;
74         }
75
76         return pmd_k;
77 }
78
79 /*
80  * Handle a fault on the vmalloc or module mapping area
81  */
82 static noinline int vmalloc_fault(unsigned long address)
83 {
84         pgd_t *pgd_k;
85         pmd_t *pmd_k;
86         pte_t *pte_k;
87
88         /* Make sure we are in vmalloc/module/P3 area: */
89         if (!(address >= VMALLOC_START && address < P3_ADDR_MAX))
90                 return -1;
91
92         /*
93          * Synchronize this task's top level page-table
94          * with the 'reference' page table.
95          *
96          * Do _not_ use "current" here. We might be inside
97          * an interrupt in the middle of a task switch..
98          */
99         pgd_k = get_TTB();
100         pmd_k = vmalloc_sync_one(pgd_k, address);
101         if (!pmd_k)
102                 return -1;
103
104         pte_k = pte_offset_kernel(pmd_k, address);
105         if (!pte_present(*pte_k))
106                 return -1;
107
108         return 0;
109 }
110
111 static int fault_in_kernel_space(unsigned long address)
112 {
113         return address >= TASK_SIZE;
114 }
115
116 /*
117  * This routine handles page faults.  It determines the address,
118  * and the problem, and then passes it off to one of the appropriate
119  * routines.
120  */
121 asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
122                                         unsigned long writeaccess,
123                                         unsigned long address)
124 {
125         unsigned long vec;
126         struct task_struct *tsk;
127         struct mm_struct *mm;
128         struct vm_area_struct * vma;
129         int si_code;
130         int fault;
131         siginfo_t info;
132
133         tsk = current;
134         mm = tsk->mm;
135         si_code = SEGV_MAPERR;
136         vec = lookup_exception_vector();
137
138         /*
139          * We fault-in kernel-space virtual memory on-demand. The
140          * 'reference' page table is init_mm.pgd.
141          *
142          * NOTE! We MUST NOT take any locks for this case. We may
143          * be in an interrupt or a critical region, and should
144          * only copy the information from the master page table,
145          * nothing more.
146          */
147         if (unlikely(fault_in_kernel_space(address))) {
148                 if (vmalloc_fault(address) >= 0)
149                         return;
150                 if (notify_page_fault(regs, vec))
151                         return;
152
153                 goto bad_area_nosemaphore;
154         }
155
156         if (unlikely(notify_page_fault(regs, vec)))
157                 return;
158
159         /* Only enable interrupts if they were on before the fault */
160         if ((regs->sr & SR_IMASK) != SR_IMASK)
161                 local_irq_enable();
162
163         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, 0, regs, address);
164
165         /*
166          * If we're in an interrupt, have no user context or are running
167          * in an atomic region then we must not take the fault:
168          */
169         if (in_atomic() || !mm)
170                 goto no_context;
171
172         down_read(&mm->mmap_sem);
173
174         vma = find_vma(mm, address);
175         if (!vma)
176                 goto bad_area;
177         if (vma->vm_start <= address)
178                 goto good_area;
179         if (!(vma->vm_flags & VM_GROWSDOWN))
180                 goto bad_area;
181         if (expand_stack(vma, address))
182                 goto bad_area;
183
184         /*
185          * Ok, we have a good vm_area for this memory access, so
186          * we can handle it..
187          */
188 good_area:
189         si_code = SEGV_ACCERR;
190         if (writeaccess) {
191                 if (!(vma->vm_flags & VM_WRITE))
192                         goto bad_area;
193         } else {
194                 if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
195                         goto bad_area;
196         }
197
198         /*
199          * If for any reason at all we couldn't handle the fault,
200          * make sure we exit gracefully rather than endlessly redo
201          * the fault.
202          */
203 survive:
204         fault = handle_mm_fault(mm, vma, address, writeaccess ? FAULT_FLAG_WRITE : 0);
205         if (unlikely(fault & VM_FAULT_ERROR)) {
206                 if (fault & VM_FAULT_OOM)
207                         goto out_of_memory;
208                 else if (fault & VM_FAULT_SIGBUS)
209                         goto do_sigbus;
210                 BUG();
211         }
212         if (fault & VM_FAULT_MAJOR) {
213                 tsk->maj_flt++;
214                 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, 0,
215                                      regs, address);
216         } else {
217                 tsk->min_flt++;
218                 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, 0,
219                                      regs, address);
220         }
221
222         up_read(&mm->mmap_sem);
223         return;
224
225         /*
226          * Something tried to access memory that isn't in our memory map..
227          * Fix it, but check if it's kernel or user first..
228          */
229 bad_area:
230         up_read(&mm->mmap_sem);
231
232 bad_area_nosemaphore:
233         if (user_mode(regs)) {
234                 info.si_signo = SIGSEGV;
235                 info.si_errno = 0;
236                 info.si_code = si_code;
237                 info.si_addr = (void *) address;
238                 force_sig_info(SIGSEGV, &info, tsk);
239                 return;
240         }
241
242 no_context:
243         /* Are we prepared to handle this kernel fault?  */
244         if (fixup_exception(regs))
245                 return;
246
247         if (handle_trapped_io(regs, address))
248                 return;
249 /*
250  * Oops. The kernel tried to access some bad page. We'll have to
251  * terminate things with extreme prejudice.
252  *
253  */
254
255         bust_spinlocks(1);
256
257         if (oops_may_print()) {
258                 unsigned long page;
259
260                 if (address < PAGE_SIZE)
261                         printk(KERN_ALERT "Unable to handle kernel NULL "
262                                           "pointer dereference");
263                 else
264                         printk(KERN_ALERT "Unable to handle kernel paging "
265                                           "request");
266                 printk(" at virtual address %08lx\n", address);
267                 printk(KERN_ALERT "pc = %08lx\n", regs->pc);
268                 page = (unsigned long)get_TTB();
269                 if (page) {
270                         page = ((__typeof__(page) *)page)[address >> PGDIR_SHIFT];
271                         printk(KERN_ALERT "*pde = %08lx\n", page);
272                         if (page & _PAGE_PRESENT) {
273                                 page &= PAGE_MASK;
274                                 address &= 0x003ff000;
275                                 page = ((__typeof__(page) *)
276                                                 __va(page))[address >>
277                                                             PAGE_SHIFT];
278                                 printk(KERN_ALERT "*pte = %08lx\n", page);
279                         }
280                 }
281         }
282
283         die("Oops", regs, writeaccess);
284         bust_spinlocks(0);
285         do_exit(SIGKILL);
286
287 /*
288  * We ran out of memory, or some other thing happened to us that made
289  * us unable to handle the page fault gracefully.
290  */
291 out_of_memory:
292         up_read(&mm->mmap_sem);
293         if (is_global_init(current)) {
294                 yield();
295                 down_read(&mm->mmap_sem);
296                 goto survive;
297         }
298         printk("VM: killing process %s\n", tsk->comm);
299         if (user_mode(regs))
300                 do_group_exit(SIGKILL);
301         goto no_context;
302
303 do_sigbus:
304         up_read(&mm->mmap_sem);
305
306         /*
307          * Send a sigbus, regardless of whether we were in kernel
308          * or user mode.
309          */
310         info.si_signo = SIGBUS;
311         info.si_errno = 0;
312         info.si_code = BUS_ADRERR;
313         info.si_addr = (void *)address;
314         force_sig_info(SIGBUS, &info, tsk);
315
316         /* Kernel mode? Handle exceptions or die */
317         if (!user_mode(regs))
318                 goto no_context;
319 }
320
321 /*
322  * Called with interrupts disabled.
323  */
324 asmlinkage int __kprobes
325 handle_tlbmiss(struct pt_regs *regs, unsigned long writeaccess,
326                unsigned long address)
327 {
328         pgd_t *pgd;
329         pud_t *pud;
330         pmd_t *pmd;
331         pte_t *pte;
332         pte_t entry;
333
334         /*
335          * We don't take page faults for P1, P2, and parts of P4, these
336          * are always mapped, whether it be due to legacy behaviour in
337          * 29-bit mode, or due to PMB configuration in 32-bit mode.
338          */
339         if (address >= P3SEG && address < P3_ADDR_MAX) {
340                 pgd = pgd_offset_k(address);
341         } else {
342                 if (unlikely(address >= TASK_SIZE || !current->mm))
343                         return 1;
344
345                 pgd = pgd_offset(current->mm, address);
346         }
347
348         pud = pud_offset(pgd, address);
349         if (pud_none_or_clear_bad(pud))
350                 return 1;
351         pmd = pmd_offset(pud, address);
352         if (pmd_none_or_clear_bad(pmd))
353                 return 1;
354         pte = pte_offset_kernel(pmd, address);
355         entry = *pte;
356         if (unlikely(pte_none(entry) || pte_not_present(entry)))
357                 return 1;
358         if (unlikely(writeaccess && !pte_write(entry)))
359                 return 1;
360
361         if (writeaccess)
362                 entry = pte_mkdirty(entry);
363         entry = pte_mkyoung(entry);
364
365         set_pte(pte, entry);
366
367 #if defined(CONFIG_CPU_SH4) && !defined(CONFIG_SMP)
368         /*
369          * SH-4 does not set MMUCR.RC to the corresponding TLB entry in
370          * the case of an initial page write exception, so we need to
371          * flush it in order to avoid potential TLB entry duplication.
372          */
373         if (writeaccess == 2)
374                 local_flush_tlb_one(get_asid(), address & PAGE_MASK);
375 #endif
376
377         update_mmu_cache(NULL, address, pte);
378
379         return 0;
380 }