3 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
5 * Derived from "arch/i386/mm/fault.c"
6 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
8 * Modified by Cort Dougan and Paul Mackerras.
10 * Modified for PPC64 by Dave Engebretsen (engebret@ibm.com)
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
18 #include <linux/config.h>
19 #include <linux/signal.h>
20 #include <linux/sched.h>
21 #include <linux/kernel.h>
22 #include <linux/errno.h>
23 #include <linux/string.h>
24 #include <linux/types.h>
25 #include <linux/ptrace.h>
26 #include <linux/mman.h>
28 #include <linux/interrupt.h>
29 #include <linux/highmem.h>
30 #include <linux/module.h>
31 #include <linux/kprobes.h>
34 #include <asm/pgtable.h>
36 #include <asm/mmu_context.h>
37 #include <asm/system.h>
38 #include <asm/uaccess.h>
39 #include <asm/tlbflush.h>
40 #include <asm/kdebug.h>
41 #include <asm/siginfo.h>
44 ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
46 /* Hook to register for page fault notifications */
47 int register_page_fault_notifier(struct notifier_block *nb)
49 return atomic_notifier_chain_register(¬ify_page_fault_chain, nb);
52 int unregister_page_fault_notifier(struct notifier_block *nb)
54 return atomic_notifier_chain_unregister(¬ify_page_fault_chain, nb);
57 static inline int notify_page_fault(enum die_val val, const char *str,
58 struct pt_regs *regs, long err, int trap, int sig)
60 struct die_args args = {
67 return atomic_notifier_call_chain(¬ify_page_fault_chain, val, &args);
70 static inline int notify_page_fault(enum die_val val, const char *str,
71 struct pt_regs *regs, long err, int trap, int sig)
78 * Check whether the instruction at regs->nip is a store using
79 * an update addressing form which will update r1.
81 static int store_updates_sp(struct pt_regs *regs)
85 if (get_user(inst, (unsigned int __user *)regs->nip))
87 /* check for 1 in the rA field */
88 if (((inst >> 16) & 0x1f) != 1)
90 /* check major opcode */
98 case 62: /* std or stdu */
99 return (inst & 3) == 1;
101 /* check minor opcode */
102 switch ((inst >> 1) & 0x3ff) {
103 case 181: /* stdux */
104 case 183: /* stwux */
105 case 247: /* stbux */
106 case 439: /* sthux */
107 case 695: /* stfsux */
108 case 759: /* stfdux */
115 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
116 static void do_dabr(struct pt_regs *regs, unsigned long address,
117 unsigned long error_code)
121 if (notify_die(DIE_DABR_MATCH, "dabr_match", regs, error_code,
122 11, SIGSEGV) == NOTIFY_STOP)
125 if (debugger_dabr_match(regs))
131 /* Deliver the signal to userspace */
132 info.si_signo = SIGTRAP;
134 info.si_code = TRAP_HWBKPT;
135 info.si_addr = (void __user *)address;
136 force_sig_info(SIGTRAP, &info, current);
138 #endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
141 * For 600- and 800-family processors, the error_code parameter is DSISR
142 * for a data fault, SRR1 for an instruction fault. For 400-family processors
143 * the error_code parameter is ESR for a data fault, 0 for an instruction
145 * For 64-bit processors, the error_code parameter is
146 * - DSISR for a non-SLB data access fault,
147 * - SRR1 & 0x08000000 for a non-SLB instruction access fault
150 * The return value is 0 if the fault was handled, or the signal
151 * number if this is a kernel fault that can't be handled here.
153 int __kprobes do_page_fault(struct pt_regs *regs, unsigned long address,
154 unsigned long error_code)
156 struct vm_area_struct * vma;
157 struct mm_struct *mm = current->mm;
159 int code = SEGV_MAPERR;
161 int trap = TRAP(regs);
162 int is_exec = trap == 0x400;
164 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
166 * Fortunately the bit assignments in SRR1 for an instruction
167 * fault and DSISR for a data fault are mostly the same for the
168 * bits we are interested in. But there are some bits which
169 * indicate errors in DSISR but can validly be set in SRR1.
172 error_code &= 0x48200000;
174 is_write = error_code & DSISR_ISSTORE;
176 is_write = error_code & ESR_DST;
177 #endif /* CONFIG_4xx || CONFIG_BOOKE */
179 if (notify_page_fault(DIE_PAGE_FAULT, "page_fault", regs, error_code,
180 11, SIGSEGV) == NOTIFY_STOP)
184 if (debugger_fault_handler(regs))
188 /* On a kernel SLB miss we can only check for a valid exception entry */
189 if (!user_mode(regs) && (address >= TASK_SIZE))
192 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
193 if (error_code & DSISR_DABRMATCH) {
195 do_dabr(regs, address, error_code);
198 #endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
200 if (in_atomic() || mm == NULL) {
201 if (!user_mode(regs))
203 /* in_atomic() in user mode is really bad,
204 as is current->mm == NULL. */
205 printk(KERN_EMERG "Page fault in user mode with"
206 "in_atomic() = %d mm = %p\n", in_atomic(), mm);
207 printk(KERN_EMERG "NIP = %lx MSR = %lx\n",
208 regs->nip, regs->msr);
209 die("Weird page fault", regs, SIGSEGV);
212 /* When running in the kernel we expect faults to occur only to
213 * addresses in user space. All other faults represent errors in the
214 * kernel and should generate an OOPS. Unfortunately, in the case of an
215 * erroneous fault occurring in a code path which already holds mmap_sem
216 * we will deadlock attempting to validate the fault against the
217 * address space. Luckily the kernel only validly references user
218 * space from well defined areas of code, which are listed in the
221 * As the vast majority of faults will be valid we will only perform
222 * the source reference check when there is a possibility of a deadlock.
223 * Attempt to lock the address space, if we cannot we then validate the
224 * source. If this is invalid we can skip the address space check,
225 * thus avoiding the deadlock.
227 if (!down_read_trylock(&mm->mmap_sem)) {
228 if (!user_mode(regs) && !search_exception_tables(regs->nip))
229 goto bad_area_nosemaphore;
231 down_read(&mm->mmap_sem);
234 vma = find_vma(mm, address);
237 if (vma->vm_start <= address)
239 if (!(vma->vm_flags & VM_GROWSDOWN))
243 * N.B. The POWER/Open ABI allows programs to access up to
244 * 288 bytes below the stack pointer.
245 * The kernel signal delivery code writes up to about 1.5kB
246 * below the stack pointer (r1) before decrementing it.
247 * The exec code can write slightly over 640kB to the stack
248 * before setting the user r1. Thus we allow the stack to
249 * expand to 1MB without further checks.
251 if (address + 0x100000 < vma->vm_end) {
252 /* get user regs even if this fault is in kernel mode */
253 struct pt_regs *uregs = current->thread.regs;
258 * A user-mode access to an address a long way below
259 * the stack pointer is only valid if the instruction
260 * is one which would update the stack pointer to the
261 * address accessed if the instruction completed,
262 * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
263 * (or the byte, halfword, float or double forms).
265 * If we don't check this then any write to the area
266 * between the last mapped region and the stack will
267 * expand the stack rather than segfaulting.
269 if (address + 2048 < uregs->gpr[1]
270 && (!user_mode(regs) || !store_updates_sp(regs)))
273 if (expand_stack(vma, address))
278 #if defined(CONFIG_6xx)
279 if (error_code & 0x95700000)
280 /* an error such as lwarx to I/O controller space,
281 address matching DABR, eciwx, etc. */
283 #endif /* CONFIG_6xx */
284 #if defined(CONFIG_8xx)
285 /* The MPC8xx seems to always set 0x80000000, which is
286 * "undefined". Of those that can be set, this is the only
287 * one which seems bad.
289 if (error_code & 0x10000000)
290 /* Guarded storage error. */
292 #endif /* CONFIG_8xx */
296 /* protection fault */
297 if (error_code & DSISR_PROTFAULT)
299 if (!(vma->vm_flags & VM_EXEC))
302 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
306 /* Since 4xx/Book-E supports per-page execute permission,
307 * we lazily flush dcache to icache. */
309 if (get_pteptr(mm, address, &ptep, &pmdp)) {
310 spinlock_t *ptl = pte_lockptr(mm, pmdp);
312 if (pte_present(*ptep)) {
313 struct page *page = pte_page(*ptep);
315 if (!test_bit(PG_arch_1, &page->flags)) {
316 flush_dcache_icache_page(page);
317 set_bit(PG_arch_1, &page->flags);
319 pte_update(ptep, 0, _PAGE_HWEXEC);
321 pte_unmap_unlock(ptep, ptl);
322 up_read(&mm->mmap_sem);
325 pte_unmap_unlock(ptep, ptl);
329 } else if (is_write) {
330 if (!(vma->vm_flags & VM_WRITE))
334 /* protection fault */
335 if (error_code & 0x08000000)
337 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
342 * If for any reason at all we couldn't handle the fault,
343 * make sure we exit gracefully rather than endlessly redo
347 switch (handle_mm_fault(mm, vma, address, is_write)) {
355 case VM_FAULT_SIGBUS:
363 up_read(&mm->mmap_sem);
367 up_read(&mm->mmap_sem);
369 bad_area_nosemaphore:
370 /* User mode accesses cause a SIGSEGV */
371 if (user_mode(regs)) {
372 _exception(SIGSEGV, regs, code, address);
376 if (is_exec && (error_code & DSISR_PROTFAULT)
377 && printk_ratelimit())
378 printk(KERN_CRIT "kernel tried to execute NX-protected"
379 " page (%lx) - exploit attempt? (uid: %d)\n",
380 address, current->uid);
385 * We ran out of memory, or some other thing happened to us that made
386 * us unable to handle the page fault gracefully.
389 up_read(&mm->mmap_sem);
390 if (current->pid == 1) {
392 down_read(&mm->mmap_sem);
395 printk("VM: killing process %s\n", current->comm);
401 up_read(&mm->mmap_sem);
402 if (user_mode(regs)) {
403 info.si_signo = SIGBUS;
405 info.si_code = BUS_ADRERR;
406 info.si_addr = (void __user *)address;
407 force_sig_info(SIGBUS, &info, current);
414 * bad_page_fault is called when we have a bad access from the kernel.
415 * It is called from the DSI and ISI handlers in head.S and from some
416 * of the procedures in traps.c.
418 void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
420 const struct exception_table_entry *entry;
422 /* Are we prepared to handle this fault? */
423 if ((entry = search_exception_tables(regs->nip)) != NULL) {
424 regs->nip = entry->fixup;
428 /* kernel has accessed a bad area */
430 printk(KERN_ALERT "Unable to handle kernel paging request for ");
431 switch (regs->trap) {
434 printk("data at address 0x%08lx\n", regs->dar);
438 printk("instruction fetch\n");
441 printk("unknown fault\n");
443 printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n",
446 die("Kernel access of bad area", regs, sig);