1/*
2 *  PowerPC version
3 *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
4 *
5 *  Derived from "arch/i386/mm/fault.c"
6 *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
7 *
8 *  Modified by Cort Dougan and Paul Mackerras.
9 *
10 *  Modified for PPC64 by Dave Engebretsen (engebret@ibm.com)
11 *
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.
16 */
17
18#include <linux/signal.h>
19#include <linux/sched.h>
20#include <linux/kernel.h>
21#include <linux/errno.h>
22#include <linux/string.h>
23#include <linux/types.h>
24#include <linux/ptrace.h>
25#include <linux/mman.h>
26#include <linux/mm.h>
27#include <linux/interrupt.h>
28#include <linux/highmem.h>
29#include <linux/module.h>
30#include <linux/kprobes.h>
31#include <linux/kdebug.h>
32
33#include <asm/page.h>
34#include <asm/pgtable.h>
35#include <asm/mmu.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/siginfo.h>
41
42
43#ifdef CONFIG_KPROBES
44static inline int notify_page_fault(struct pt_regs *regs)
45{
46	int ret = 0;
47
48	/* kprobe_running() needs smp_processor_id() */
49	if (!user_mode(regs)) {
50		preempt_disable();
51		if (kprobe_running() && kprobe_fault_handler(regs, 11))
52			ret = 1;
53		preempt_enable();
54	}
55
56	return ret;
57}
58#else
59static inline int notify_page_fault(struct pt_regs *regs)
60{
61	return 0;
62}
63#endif
64
65/*
66 * Check whether the instruction at regs->nip is a store using
67 * an update addressing form which will update r1.
68 */
69static int store_updates_sp(struct pt_regs *regs)
70{
71	unsigned int inst;
72
73	if (get_user(inst, (unsigned int __user *)regs->nip))
74		return 0;
75	/* check for 1 in the rA field */
76	if (((inst >> 16) & 0x1f) != 1)
77		return 0;
78	/* check major opcode */
79	switch (inst >> 26) {
80	case 37:	/* stwu */
81	case 39:	/* stbu */
82	case 45:	/* sthu */
83	case 53:	/* stfsu */
84	case 55:	/* stfdu */
85		return 1;
86	case 62:	/* std or stdu */
87		return (inst & 3) == 1;
88	case 31:
89		/* check minor opcode */
90		switch ((inst >> 1) & 0x3ff) {
91		case 181:	/* stdux */
92		case 183:	/* stwux */
93		case 247:	/* stbux */
94		case 439:	/* sthux */
95		case 695:	/* stfsux */
96		case 759:	/* stfdux */
97			return 1;
98		}
99	}
100	return 0;
101}
102
103#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
104static void do_dabr(struct pt_regs *regs, unsigned long address,
105		    unsigned long error_code)
106{
107	siginfo_t info;
108
109	if (notify_die(DIE_DABR_MATCH, "dabr_match", regs, error_code,
110			11, SIGSEGV) == NOTIFY_STOP)
111		return;
112
113	if (debugger_dabr_match(regs))
114		return;
115
116	/* Clear the DABR */
117	set_dabr(0);
118
119	/* Deliver the signal to userspace */
120	info.si_signo = SIGTRAP;
121	info.si_errno = 0;
122	info.si_code = TRAP_HWBKPT;
123	info.si_addr = (void __user *)address;
124	force_sig_info(SIGTRAP, &info, current);
125}
126#endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
127
128/*
129 * For 600- and 800-family processors, the error_code parameter is DSISR
130 * for a data fault, SRR1 for an instruction fault. For 400-family processors
131 * the error_code parameter is ESR for a data fault, 0 for an instruction
132 * fault.
133 * For 64-bit processors, the error_code parameter is
134 *  - DSISR for a non-SLB data access fault,
135 *  - SRR1 & 0x08000000 for a non-SLB instruction access fault
136 *  - 0 any SLB fault.
137 *
138 * The return value is 0 if the fault was handled, or the signal
139 * number if this is a kernel fault that can't be handled here.
140 */
141int __kprobes do_page_fault(struct pt_regs *regs, unsigned long address,
142			    unsigned long error_code)
143{
144	struct vm_area_struct * vma;
145	struct mm_struct *mm = current->mm;
146	siginfo_t info;
147	int code = SEGV_MAPERR;
148	int is_write = 0;
149	int trap = TRAP(regs);
150 	int is_exec = trap == 0x400;
151
152#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
153	/*
154	 * Fortunately the bit assignments in SRR1 for an instruction
155	 * fault and DSISR for a data fault are mostly the same for the
156	 * bits we are interested in.  But there are some bits which
157	 * indicate errors in DSISR but can validly be set in SRR1.
158	 */
159	if (trap == 0x400)
160		error_code &= 0x48200000;
161	else
162		is_write = error_code & DSISR_ISSTORE;
163#else
164	is_write = error_code & ESR_DST;
165#endif /* CONFIG_4xx || CONFIG_BOOKE */
166
167	if (notify_page_fault(regs))
168		return 0;
169
170	if (trap == 0x300) {
171		if (debugger_fault_handler(regs))
172			return 0;
173	}
174
175	/* On a kernel SLB miss we can only check for a valid exception entry */
176	if (!user_mode(regs) && (address >= TASK_SIZE))
177		return SIGSEGV;
178
179#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
180  	if (error_code & DSISR_DABRMATCH) {
181		/* DABR match */
182		do_dabr(regs, address, error_code);
183		return 0;
184	}
185#endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
186
187	if (in_atomic() || mm == NULL) {
188		if (!user_mode(regs))
189			return SIGSEGV;
190		/* in_atomic() in user mode is really bad,
191		   as is current->mm == NULL. */
192		printk(KERN_EMERG "Page fault in user mode with"
193		       "in_atomic() = %d mm = %p\n", in_atomic(), mm);
194		printk(KERN_EMERG "NIP = %lx  MSR = %lx\n",
195		       regs->nip, regs->msr);
196		die("Weird page fault", regs, SIGSEGV);
197	}
198
199	/* When running in the kernel we expect faults to occur only to
200	 * addresses in user space.  All other faults represent errors in the
201	 * kernel and should generate an OOPS.  Unfortunately, in the case of an
202	 * erroneous fault occurring in a code path which already holds mmap_sem
203	 * we will deadlock attempting to validate the fault against the
204	 * address space.  Luckily the kernel only validly references user
205	 * space from well defined areas of code, which are listed in the
206	 * exceptions table.
207	 *
208	 * As the vast majority of faults will be valid we will only perform
209	 * the source reference check when there is a possibility of a deadlock.
210	 * Attempt to lock the address space, if we cannot we then validate the
211	 * source.  If this is invalid we can skip the address space check,
212	 * thus avoiding the deadlock.
213	 */
214	if (!down_read_trylock(&mm->mmap_sem)) {
215		if (!user_mode(regs) && !search_exception_tables(regs->nip))
216			goto bad_area_nosemaphore;
217
218		down_read(&mm->mmap_sem);
219	}
220
221	vma = find_vma(mm, address);
222	if (!vma)
223		goto bad_area;
224	if (vma->vm_start <= address)
225		goto good_area;
226	if (!(vma->vm_flags & VM_GROWSDOWN))
227		goto bad_area;
228
229	/*
230	 * N.B. The POWER/Open ABI allows programs to access up to
231	 * 288 bytes below the stack pointer.
232	 * The kernel signal delivery code writes up to about 1.5kB
233	 * below the stack pointer (r1) before decrementing it.
234	 * The exec code can write slightly over 640kB to the stack
235	 * before setting the user r1.  Thus we allow the stack to
236	 * expand to 1MB without further checks.
237	 */
238	if (address + 0x100000 < vma->vm_end) {
239		/* get user regs even if this fault is in kernel mode */
240		struct pt_regs *uregs = current->thread.regs;
241		if (uregs == NULL)
242			goto bad_area;
243
244		/*
245		 * A user-mode access to an address a long way below
246		 * the stack pointer is only valid if the instruction
247		 * is one which would update the stack pointer to the
248		 * address accessed if the instruction completed,
249		 * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
250		 * (or the byte, halfword, float or double forms).
251		 *
252		 * If we don't check this then any write to the area
253		 * between the last mapped region and the stack will
254		 * expand the stack rather than segfaulting.
255		 */
256		if (address + 2048 < uregs->gpr[1]
257		    && (!user_mode(regs) || !store_updates_sp(regs)))
258			goto bad_area;
259	}
260	if (expand_stack(vma, address))
261		goto bad_area;
262
263good_area:
264	code = SEGV_ACCERR;
265#if defined(CONFIG_6xx)
266	if (error_code & 0x95700000)
267		/* an error such as lwarx to I/O controller space,
268		   address matching DABR, eciwx, etc. */
269		goto bad_area;
270#endif /* CONFIG_6xx */
271#if defined(CONFIG_8xx)
272        /* The MPC8xx seems to always set 0x80000000, which is
273         * "undefined".  Of those that can be set, this is the only
274         * one which seems bad.
275         */
276	if (error_code & 0x10000000)
277                /* Guarded storage error. */
278		goto bad_area;
279#endif /* CONFIG_8xx */
280
281	if (is_exec) {
282#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
283		/* protection fault */
284		if (error_code & DSISR_PROTFAULT)
285			goto bad_area;
286		if (!(vma->vm_flags & VM_EXEC))
287			goto bad_area;
288#else
289		pte_t *ptep;
290		pmd_t *pmdp;
291
292		/* Since 4xx/Book-E supports per-page execute permission,
293		 * we lazily flush dcache to icache. */
294		ptep = NULL;
295		if (get_pteptr(mm, address, &ptep, &pmdp)) {
296			spinlock_t *ptl = pte_lockptr(mm, pmdp);
297			spin_lock(ptl);
298			if (pte_present(*ptep)) {
299				struct page *page = pte_page(*ptep);
300
301				if (!test_bit(PG_arch_1, &page->flags)) {
302					flush_dcache_icache_page(page);
303					set_bit(PG_arch_1, &page->flags);
304				}
305				pte_update(ptep, 0, _PAGE_HWEXEC);
306				_tlbie(address);
307				pte_unmap_unlock(ptep, ptl);
308				up_read(&mm->mmap_sem);
309				return 0;
310			}
311			pte_unmap_unlock(ptep, ptl);
312		}
313#endif
314	/* a write */
315	} else if (is_write) {
316		if (!(vma->vm_flags & VM_WRITE))
317			goto bad_area;
318	/* a read */
319	} else {
320		/* protection fault */
321		if (error_code & 0x08000000)
322			goto bad_area;
323		if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
324			goto bad_area;
325	}
326
327	/*
328	 * If for any reason at all we couldn't handle the fault,
329	 * make sure we exit gracefully rather than endlessly redo
330	 * the fault.
331	 */
332 survive:
333	switch (handle_mm_fault(mm, vma, address, is_write)) {
334
335	case VM_FAULT_MINOR:
336		current->min_flt++;
337		break;
338	case VM_FAULT_MAJOR:
339		current->maj_flt++;
340		break;
341	case VM_FAULT_SIGBUS:
342		goto do_sigbus;
343	case VM_FAULT_OOM:
344		goto out_of_memory;
345	default:
346		BUG();
347	}
348
349	up_read(&mm->mmap_sem);
350	return 0;
351
352bad_area:
353	up_read(&mm->mmap_sem);
354
355bad_area_nosemaphore:
356	/* User mode accesses cause a SIGSEGV */
357	if (user_mode(regs)) {
358		_exception(SIGSEGV, regs, code, address);
359		return 0;
360	}
361
362	if (is_exec && (error_code & DSISR_PROTFAULT)
363	    && printk_ratelimit())
364		printk(KERN_CRIT "kernel tried to execute NX-protected"
365		       " page (%lx) - exploit attempt? (uid: %d)\n",
366		       address, current->uid);
367
368	return SIGSEGV;
369
370/*
371 * We ran out of memory, or some other thing happened to us that made
372 * us unable to handle the page fault gracefully.
373 */
374out_of_memory:
375	up_read(&mm->mmap_sem);
376	if (is_init(current)) {
377		yield();
378		down_read(&mm->mmap_sem);
379		goto survive;
380	}
381	printk("VM: killing process %s\n", current->comm);
382	if (user_mode(regs))
383		do_exit(SIGKILL);
384	return SIGKILL;
385
386do_sigbus:
387	up_read(&mm->mmap_sem);
388	if (user_mode(regs)) {
389		info.si_signo = SIGBUS;
390		info.si_errno = 0;
391		info.si_code = BUS_ADRERR;
392		info.si_addr = (void __user *)address;
393		force_sig_info(SIGBUS, &info, current);
394		return 0;
395	}
396	return SIGBUS;
397}
398
399/*
400 * bad_page_fault is called when we have a bad access from the kernel.
401 * It is called from the DSI and ISI handlers in head.S and from some
402 * of the procedures in traps.c.
403 */
404void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
405{
406	const struct exception_table_entry *entry;
407
408	/* Are we prepared to handle this fault?  */
409	if ((entry = search_exception_tables(regs->nip)) != NULL) {
410		regs->nip = entry->fixup;
411		return;
412	}
413
414	/* kernel has accessed a bad area */
415
416	switch (regs->trap) {
417	case 0x300:
418	case 0x380:
419		printk(KERN_ALERT "Unable to handle kernel paging request for "
420			"data at address 0x%08lx\n", regs->dar);
421		break;
422	case 0x400:
423	case 0x480:
424		printk(KERN_ALERT "Unable to handle kernel paging request for "
425			"instruction fetch\n");
426		break;
427	default:
428		printk(KERN_ALERT "Unable to handle kernel paging request for "
429			"unknown fault\n");
430		break;
431	}
432	printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n",
433		regs->nip);
434
435	die("Kernel access of bad area", regs, sig);
436}
437