blob: 76993941cac95a12f7c95972eb55f9e0b00fe769 [file] [log] [blame]
Paul Mackerras14cf11a2005-09-26 16:04:21 +10001/*
Paul Mackerras14cf11a2005-09-26 16:04:21 +10002 * 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
Paul Mackerras14cf11a2005-09-26 16:04:21 +100018#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>
Christoph Hellwig1eeb66a2007-05-08 00:27:03 -070031#include <linux/kdebug.h>
Paul Mackerras14cf11a2005-09-26 16:04:21 +100032
Brian King40900192008-10-22 05:53:45 +000033#include <asm/firmware.h>
Paul Mackerras14cf11a2005-09-26 16:04:21 +100034#include <asm/page.h>
35#include <asm/pgtable.h>
36#include <asm/mmu.h>
37#include <asm/mmu_context.h>
38#include <asm/system.h>
39#include <asm/uaccess.h>
40#include <asm/tlbflush.h>
Paul Mackerras14cf11a2005-09-26 16:04:21 +100041#include <asm/siginfo.h>
42
Christoph Hellwig9f90b992007-04-30 11:56:46 +010043
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070044#ifdef CONFIG_KPROBES
Christoph Hellwig9f90b992007-04-30 11:56:46 +010045static inline int notify_page_fault(struct pt_regs *regs)
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070046{
Christoph Hellwig9f90b992007-04-30 11:56:46 +010047 int ret = 0;
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070048
Christoph Hellwig9f90b992007-04-30 11:56:46 +010049 /* kprobe_running() needs smp_processor_id() */
50 if (!user_mode(regs)) {
51 preempt_disable();
52 if (kprobe_running() && kprobe_fault_handler(regs, 11))
53 ret = 1;
54 preempt_enable();
55 }
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070056
Christoph Hellwig9f90b992007-04-30 11:56:46 +010057 return ret;
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070058}
59#else
Christoph Hellwig9f90b992007-04-30 11:56:46 +010060static inline int notify_page_fault(struct pt_regs *regs)
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070061{
Christoph Hellwig9f90b992007-04-30 11:56:46 +010062 return 0;
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070063}
64#endif
65
Paul Mackerras14cf11a2005-09-26 16:04:21 +100066/*
67 * Check whether the instruction at regs->nip is a store using
68 * an update addressing form which will update r1.
69 */
70static int store_updates_sp(struct pt_regs *regs)
71{
72 unsigned int inst;
73
74 if (get_user(inst, (unsigned int __user *)regs->nip))
75 return 0;
76 /* check for 1 in the rA field */
77 if (((inst >> 16) & 0x1f) != 1)
78 return 0;
79 /* check major opcode */
80 switch (inst >> 26) {
81 case 37: /* stwu */
82 case 39: /* stbu */
83 case 45: /* sthu */
84 case 53: /* stfsu */
85 case 55: /* stfdu */
86 return 1;
87 case 62: /* std or stdu */
88 return (inst & 3) == 1;
89 case 31:
90 /* check minor opcode */
91 switch ((inst >> 1) & 0x3ff) {
92 case 181: /* stdux */
93 case 183: /* stwux */
94 case 247: /* stbux */
95 case 439: /* sthux */
96 case 695: /* stfsux */
97 case 759: /* stfdux */
98 return 1;
99 }
100 }
101 return 0;
102}
103
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000104/*
105 * For 600- and 800-family processors, the error_code parameter is DSISR
106 * for a data fault, SRR1 for an instruction fault. For 400-family processors
107 * the error_code parameter is ESR for a data fault, 0 for an instruction
108 * fault.
109 * For 64-bit processors, the error_code parameter is
110 * - DSISR for a non-SLB data access fault,
111 * - SRR1 & 0x08000000 for a non-SLB instruction access fault
112 * - 0 any SLB fault.
113 *
114 * The return value is 0 if the fault was handled, or the signal
115 * number if this is a kernel fault that can't be handled here.
116 */
117int __kprobes do_page_fault(struct pt_regs *regs, unsigned long address,
118 unsigned long error_code)
119{
120 struct vm_area_struct * vma;
121 struct mm_struct *mm = current->mm;
122 siginfo_t info;
123 int code = SEGV_MAPERR;
Nick Piggin83c54072007-07-19 01:47:05 -0700124 int is_write = 0, ret;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000125 int trap = TRAP(regs);
126 int is_exec = trap == 0x400;
127
128#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
129 /*
130 * Fortunately the bit assignments in SRR1 for an instruction
131 * fault and DSISR for a data fault are mostly the same for the
132 * bits we are interested in. But there are some bits which
133 * indicate errors in DSISR but can validly be set in SRR1.
134 */
135 if (trap == 0x400)
136 error_code &= 0x48200000;
137 else
138 is_write = error_code & DSISR_ISSTORE;
139#else
140 is_write = error_code & ESR_DST;
141#endif /* CONFIG_4xx || CONFIG_BOOKE */
142
Christoph Hellwig9f90b992007-04-30 11:56:46 +0100143 if (notify_page_fault(regs))
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000144 return 0;
145
Michael Neulingc3b75bd2008-01-18 15:50:30 +1100146 if (unlikely(debugger_fault_handler(regs)))
147 return 0;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000148
149 /* On a kernel SLB miss we can only check for a valid exception entry */
150 if (!user_mode(regs) && (address >= TASK_SIZE))
151 return SIGSEGV;
152
153#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
154 if (error_code & DSISR_DABRMATCH) {
155 /* DABR match */
Anton Blanchardbce6c5f2006-01-09 15:47:04 +1100156 do_dabr(regs, address, error_code);
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000157 return 0;
158 }
159#endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
160
161 if (in_atomic() || mm == NULL) {
162 if (!user_mode(regs))
163 return SIGSEGV;
164 /* in_atomic() in user mode is really bad,
165 as is current->mm == NULL. */
joe@perches.comdf3c9012007-11-20 12:47:55 +1100166 printk(KERN_EMERG "Page fault in user mode with "
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000167 "in_atomic() = %d mm = %p\n", in_atomic(), mm);
168 printk(KERN_EMERG "NIP = %lx MSR = %lx\n",
169 regs->nip, regs->msr);
170 die("Weird page fault", regs, SIGSEGV);
171 }
172
173 /* When running in the kernel we expect faults to occur only to
174 * addresses in user space. All other faults represent errors in the
Anton Blanchardfc5266e2006-04-01 11:33:12 +1100175 * kernel and should generate an OOPS. Unfortunately, in the case of an
176 * erroneous fault occurring in a code path which already holds mmap_sem
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000177 * we will deadlock attempting to validate the fault against the
178 * address space. Luckily the kernel only validly references user
179 * space from well defined areas of code, which are listed in the
180 * exceptions table.
181 *
182 * As the vast majority of faults will be valid we will only perform
Anton Blanchardfc5266e2006-04-01 11:33:12 +1100183 * the source reference check when there is a possibility of a deadlock.
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000184 * Attempt to lock the address space, if we cannot we then validate the
185 * source. If this is invalid we can skip the address space check,
186 * thus avoiding the deadlock.
187 */
188 if (!down_read_trylock(&mm->mmap_sem)) {
189 if (!user_mode(regs) && !search_exception_tables(regs->nip))
190 goto bad_area_nosemaphore;
191
192 down_read(&mm->mmap_sem);
193 }
194
195 vma = find_vma(mm, address);
196 if (!vma)
197 goto bad_area;
198 if (vma->vm_start <= address)
199 goto good_area;
200 if (!(vma->vm_flags & VM_GROWSDOWN))
201 goto bad_area;
202
203 /*
204 * N.B. The POWER/Open ABI allows programs to access up to
205 * 288 bytes below the stack pointer.
206 * The kernel signal delivery code writes up to about 1.5kB
207 * below the stack pointer (r1) before decrementing it.
208 * The exec code can write slightly over 640kB to the stack
209 * before setting the user r1. Thus we allow the stack to
210 * expand to 1MB without further checks.
211 */
212 if (address + 0x100000 < vma->vm_end) {
213 /* get user regs even if this fault is in kernel mode */
214 struct pt_regs *uregs = current->thread.regs;
215 if (uregs == NULL)
216 goto bad_area;
217
218 /*
219 * A user-mode access to an address a long way below
220 * the stack pointer is only valid if the instruction
221 * is one which would update the stack pointer to the
222 * address accessed if the instruction completed,
223 * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
224 * (or the byte, halfword, float or double forms).
225 *
226 * If we don't check this then any write to the area
227 * between the last mapped region and the stack will
228 * expand the stack rather than segfaulting.
229 */
230 if (address + 2048 < uregs->gpr[1]
231 && (!user_mode(regs) || !store_updates_sp(regs)))
232 goto bad_area;
233 }
234 if (expand_stack(vma, address))
235 goto bad_area;
236
237good_area:
238 code = SEGV_ACCERR;
239#if defined(CONFIG_6xx)
240 if (error_code & 0x95700000)
241 /* an error such as lwarx to I/O controller space,
242 address matching DABR, eciwx, etc. */
243 goto bad_area;
244#endif /* CONFIG_6xx */
245#if defined(CONFIG_8xx)
246 /* The MPC8xx seems to always set 0x80000000, which is
247 * "undefined". Of those that can be set, this is the only
248 * one which seems bad.
249 */
250 if (error_code & 0x10000000)
251 /* Guarded storage error. */
252 goto bad_area;
253#endif /* CONFIG_8xx */
254
255 if (is_exec) {
Benjamin Herrenschmidt8d30c142009-02-10 16:02:37 +0000256#ifdef CONFIG_PPC_STD_MMU
257 /* Protection fault on exec go straight to failure on
258 * Hash based MMUs as they either don't support per-page
259 * execute permission, or if they do, it's handled already
260 * at the hash level. This test would probably have to
261 * be removed if we change the way this works to make hash
262 * processors use the same I/D cache coherency mechanism
263 * as embedded.
264 */
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000265 if (error_code & DSISR_PROTFAULT)
266 goto bad_area;
Benjamin Herrenschmidt8d30c142009-02-10 16:02:37 +0000267#endif /* CONFIG_PPC_STD_MMU */
268
Paul Mackerras08ae6cc2007-07-19 10:00:20 +1000269 /*
270 * Allow execution from readable areas if the MMU does not
271 * provide separate controls over reading and executing.
Benjamin Herrenschmidt8d30c142009-02-10 16:02:37 +0000272 *
273 * Note: That code used to not be enabled for 4xx/BookE.
274 * It is now as I/D cache coherency for these is done at
275 * set_pte_at() time and I see no reason why the test
276 * below wouldn't be valid on those processors. This -may-
277 * break programs compiled with a really old ABI though.
Paul Mackerras08ae6cc2007-07-19 10:00:20 +1000278 */
279 if (!(vma->vm_flags & VM_EXEC) &&
280 (cpu_has_feature(CPU_FTR_NOEXECUTE) ||
281 !(vma->vm_flags & (VM_READ | VM_WRITE))))
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000282 goto bad_area;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000283 /* a write */
284 } else if (is_write) {
285 if (!(vma->vm_flags & VM_WRITE))
286 goto bad_area;
287 /* a read */
288 } else {
289 /* protection fault */
290 if (error_code & 0x08000000)
291 goto bad_area;
Jason Barondf67b3d2006-09-29 01:58:58 -0700292 if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000293 goto bad_area;
294 }
295
296 /*
297 * If for any reason at all we couldn't handle the fault,
298 * make sure we exit gracefully rather than endlessly redo
299 * the fault.
300 */
301 survive:
Nick Piggin83c54072007-07-19 01:47:05 -0700302 ret = handle_mm_fault(mm, vma, address, is_write);
303 if (unlikely(ret & VM_FAULT_ERROR)) {
304 if (ret & VM_FAULT_OOM)
305 goto out_of_memory;
306 else if (ret & VM_FAULT_SIGBUS)
307 goto do_sigbus;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000308 BUG();
309 }
Brian King40900192008-10-22 05:53:45 +0000310 if (ret & VM_FAULT_MAJOR) {
Nick Piggin83c54072007-07-19 01:47:05 -0700311 current->maj_flt++;
Brian King40900192008-10-22 05:53:45 +0000312#ifdef CONFIG_PPC_SMLPAR
313 if (firmware_has_feature(FW_FEATURE_CMO)) {
314 preempt_disable();
Robert Jenningsa6326e92008-11-14 12:07:34 +0000315 get_lppaca()->page_ins += (1 << PAGE_FACTOR);
Brian King40900192008-10-22 05:53:45 +0000316 preempt_enable();
317 }
318#endif
319 } else
Nick Piggin83c54072007-07-19 01:47:05 -0700320 current->min_flt++;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000321 up_read(&mm->mmap_sem);
322 return 0;
323
324bad_area:
325 up_read(&mm->mmap_sem);
326
327bad_area_nosemaphore:
328 /* User mode accesses cause a SIGSEGV */
329 if (user_mode(regs)) {
330 _exception(SIGSEGV, regs, code, address);
331 return 0;
332 }
333
334 if (is_exec && (error_code & DSISR_PROTFAULT)
335 && printk_ratelimit())
336 printk(KERN_CRIT "kernel tried to execute NX-protected"
337 " page (%lx) - exploit attempt? (uid: %d)\n",
David Howells1330deb2008-11-14 10:38:39 +1100338 address, current_uid());
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000339
340 return SIGSEGV;
341
342/*
343 * We ran out of memory, or some other thing happened to us that made
344 * us unable to handle the page fault gracefully.
345 */
346out_of_memory:
347 up_read(&mm->mmap_sem);
Serge E. Hallynb460cbc2007-10-18 23:39:52 -0700348 if (is_global_init(current)) {
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000349 yield();
350 down_read(&mm->mmap_sem);
351 goto survive;
352 }
353 printk("VM: killing process %s\n", current->comm);
354 if (user_mode(regs))
will schmidteffe24bd2007-06-13 01:19:01 +1000355 do_group_exit(SIGKILL);
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000356 return SIGKILL;
357
358do_sigbus:
359 up_read(&mm->mmap_sem);
360 if (user_mode(regs)) {
361 info.si_signo = SIGBUS;
362 info.si_errno = 0;
363 info.si_code = BUS_ADRERR;
364 info.si_addr = (void __user *)address;
365 force_sig_info(SIGBUS, &info, current);
366 return 0;
367 }
368 return SIGBUS;
369}
370
371/*
372 * bad_page_fault is called when we have a bad access from the kernel.
373 * It is called from the DSI and ISI handlers in head.S and from some
374 * of the procedures in traps.c.
375 */
376void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
377{
378 const struct exception_table_entry *entry;
379
380 /* Are we prepared to handle this fault? */
381 if ((entry = search_exception_tables(regs->nip)) != NULL) {
382 regs->nip = entry->fixup;
383 return;
384 }
385
386 /* kernel has accessed a bad area */
Olof Johansson723925b2005-11-06 14:54:36 -0800387
Olof Johansson723925b2005-11-06 14:54:36 -0800388 switch (regs->trap) {
Michael Ellermana416dd82006-11-08 10:22:59 +1100389 case 0x300:
390 case 0x380:
391 printk(KERN_ALERT "Unable to handle kernel paging request for "
392 "data at address 0x%08lx\n", regs->dar);
393 break;
394 case 0x400:
395 case 0x480:
396 printk(KERN_ALERT "Unable to handle kernel paging request for "
397 "instruction fetch\n");
398 break;
399 default:
400 printk(KERN_ALERT "Unable to handle kernel paging request for "
401 "unknown fault\n");
402 break;
Olof Johansson723925b2005-11-06 14:54:36 -0800403 }
404 printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n",
405 regs->nip);
406
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000407 die("Kernel access of bad area", regs, sig);
408}