blob: 3a8489a354e94d16cb6d0ad6f165fbc1870f53c1 [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>
Ingo Molnarcdd6c482009-09-21 12:02:48 +020032#include <linux/perf_event.h>
Anton Blanchard28b54992010-08-24 13:15:28 +000033#include <linux/magic.h>
Christian Dietrich76462232011-06-04 05:36:54 +000034#include <linux/ratelimit.h>
Paul Mackerras14cf11a2005-09-26 16:04:21 +100035
Brian King40900192008-10-22 05:53:45 +000036#include <asm/firmware.h>
Paul Mackerras14cf11a2005-09-26 16:04:21 +100037#include <asm/page.h>
38#include <asm/pgtable.h>
39#include <asm/mmu.h>
40#include <asm/mmu_context.h>
Paul Mackerras14cf11a2005-09-26 16:04:21 +100041#include <asm/uaccess.h>
42#include <asm/tlbflush.h>
Paul Mackerras14cf11a2005-09-26 16:04:21 +100043#include <asm/siginfo.h>
David Howellsae3a1972012-03-28 18:30:02 +010044#include <asm/debug.h>
Joakim Tjernlund5efab4a2009-11-20 00:21:02 +000045#include <mm/mmu_decl.h>
Christoph Hellwig9f90b992007-04-30 11:56:46 +010046
Jimi Xenidisc3dcf532011-09-29 10:55:14 +000047#include "icswx.h"
48
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070049#ifdef CONFIG_KPROBES
Christoph Hellwig9f90b992007-04-30 11:56:46 +010050static inline int notify_page_fault(struct pt_regs *regs)
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070051{
Christoph Hellwig9f90b992007-04-30 11:56:46 +010052 int ret = 0;
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070053
Christoph Hellwig9f90b992007-04-30 11:56:46 +010054 /* kprobe_running() needs smp_processor_id() */
55 if (!user_mode(regs)) {
56 preempt_disable();
57 if (kprobe_running() && kprobe_fault_handler(regs, 11))
58 ret = 1;
59 preempt_enable();
60 }
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070061
Christoph Hellwig9f90b992007-04-30 11:56:46 +010062 return ret;
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070063}
64#else
Christoph Hellwig9f90b992007-04-30 11:56:46 +010065static inline int notify_page_fault(struct pt_regs *regs)
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070066{
Christoph Hellwig9f90b992007-04-30 11:56:46 +010067 return 0;
Anil S Keshavamurthy4f9e87c2006-06-26 00:25:27 -070068}
69#endif
70
Paul Mackerras14cf11a2005-09-26 16:04:21 +100071/*
72 * Check whether the instruction at regs->nip is a store using
73 * an update addressing form which will update r1.
74 */
75static int store_updates_sp(struct pt_regs *regs)
76{
77 unsigned int inst;
78
79 if (get_user(inst, (unsigned int __user *)regs->nip))
80 return 0;
81 /* check for 1 in the rA field */
82 if (((inst >> 16) & 0x1f) != 1)
83 return 0;
84 /* check major opcode */
85 switch (inst >> 26) {
86 case 37: /* stwu */
87 case 39: /* stbu */
88 case 45: /* sthu */
89 case 53: /* stfsu */
90 case 55: /* stfdu */
91 return 1;
92 case 62: /* std or stdu */
93 return (inst & 3) == 1;
94 case 31:
95 /* check minor opcode */
96 switch ((inst >> 1) & 0x3ff) {
97 case 181: /* stdux */
98 case 183: /* stwux */
99 case 247: /* stbux */
100 case 439: /* sthux */
101 case 695: /* stfsux */
102 case 759: /* stfdux */
103 return 1;
104 }
105 }
106 return 0;
107}
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100108/*
109 * do_page_fault error handling helpers
110 */
111
112#define MM_FAULT_RETURN 0
113#define MM_FAULT_CONTINUE -1
114#define MM_FAULT_ERR(sig) (sig)
115
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100116static int do_sigbus(struct pt_regs *regs, unsigned long address)
117{
118 siginfo_t info;
119
120 up_read(&current->mm->mmap_sem);
121
122 if (user_mode(regs)) {
Ananth N Mavinakayanahalli41ab5262012-08-23 21:27:09 +0000123 current->thread.trap_nr = BUS_ADRERR;
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100124 info.si_signo = SIGBUS;
125 info.si_errno = 0;
126 info.si_code = BUS_ADRERR;
127 info.si_addr = (void __user *)address;
128 force_sig_info(SIGBUS, &info, current);
129 return MM_FAULT_RETURN;
130 }
131 return MM_FAULT_ERR(SIGBUS);
132}
133
134static int mm_fault_error(struct pt_regs *regs, unsigned long addr, int fault)
135{
136 /*
137 * Pagefault was interrupted by SIGKILL. We have no reason to
138 * continue the pagefault.
139 */
140 if (fatal_signal_pending(current)) {
141 /*
142 * If we have retry set, the mmap semaphore will have
143 * alrady been released in __lock_page_or_retry(). Else
144 * we release it now.
145 */
146 if (!(fault & VM_FAULT_RETRY))
147 up_read(&current->mm->mmap_sem);
148 /* Coming from kernel, we need to deal with uaccess fixups */
149 if (user_mode(regs))
150 return MM_FAULT_RETURN;
151 return MM_FAULT_ERR(SIGKILL);
152 }
153
154 /* No fault: be happy */
155 if (!(fault & VM_FAULT_ERROR))
156 return MM_FAULT_CONTINUE;
157
158 /* Out of memory */
David Rientjesc2d23f92012-12-12 13:52:10 -0800159 if (fault & VM_FAULT_OOM) {
160 up_read(&current->mm->mmap_sem);
161
162 /*
163 * We ran out of memory, or some other thing happened to us that
164 * made us unable to handle the page fault gracefully.
165 */
166 if (!user_mode(regs))
167 return MM_FAULT_ERR(SIGKILL);
168 pagefault_out_of_memory();
169 return MM_FAULT_RETURN;
170 }
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100171
172 /* Bus error. x86 handles HWPOISON here, we'll add this if/when
173 * we support the feature in HW
174 */
175 if (fault & VM_FAULT_SIGBUS)
176 return do_sigbus(regs, addr);
177
178 /* We don't understand the fault code, this is fatal */
179 BUG();
180 return MM_FAULT_CONTINUE;
181}
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000182
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000183/*
184 * For 600- and 800-family processors, the error_code parameter is DSISR
185 * for a data fault, SRR1 for an instruction fault. For 400-family processors
186 * the error_code parameter is ESR for a data fault, 0 for an instruction
187 * fault.
188 * For 64-bit processors, the error_code parameter is
189 * - DSISR for a non-SLB data access fault,
190 * - SRR1 & 0x08000000 for a non-SLB instruction access fault
191 * - 0 any SLB fault.
192 *
193 * The return value is 0 if the fault was handled, or the signal
194 * number if this is a kernel fault that can't be handled here.
195 */
196int __kprobes do_page_fault(struct pt_regs *regs, unsigned long address,
197 unsigned long error_code)
198{
199 struct vm_area_struct * vma;
200 struct mm_struct *mm = current->mm;
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100201 unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000202 int code = SEGV_MAPERR;
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100203 int is_write = 0;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000204 int trap = TRAP(regs);
205 int is_exec = trap == 0x400;
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100206 int fault;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000207
208#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
209 /*
210 * Fortunately the bit assignments in SRR1 for an instruction
211 * fault and DSISR for a data fault are mostly the same for the
212 * bits we are interested in. But there are some bits which
213 * indicate errors in DSISR but can validly be set in SRR1.
214 */
215 if (trap == 0x400)
216 error_code &= 0x48200000;
217 else
218 is_write = error_code & DSISR_ISSTORE;
219#else
220 is_write = error_code & ESR_DST;
221#endif /* CONFIG_4xx || CONFIG_BOOKE */
222
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100223 if (is_write)
224 flags |= FAULT_FLAG_WRITE;
225
Jimi Xenidisc3dcf532011-09-29 10:55:14 +0000226#ifdef CONFIG_PPC_ICSWX
227 /*
228 * we need to do this early because this "data storage
229 * interrupt" does not update the DAR/DEAR so we don't want to
230 * look at it
231 */
232 if (error_code & ICSWX_DSI_UCT) {
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100233 int rc = acop_handle_fault(regs, address, error_code);
234 if (rc)
235 return rc;
Jimi Xenidisc3dcf532011-09-29 10:55:14 +0000236 }
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100237#endif /* CONFIG_PPC_ICSWX */
Jimi Xenidisc3dcf532011-09-29 10:55:14 +0000238
Christoph Hellwig9f90b992007-04-30 11:56:46 +0100239 if (notify_page_fault(regs))
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000240 return 0;
241
Michael Neulingc3b75bd2008-01-18 15:50:30 +1100242 if (unlikely(debugger_fault_handler(regs)))
243 return 0;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000244
245 /* On a kernel SLB miss we can only check for a valid exception entry */
246 if (!user_mode(regs) && (address >= TASK_SIZE))
247 return SIGSEGV;
248
K.Prasad9c7cc232010-03-29 23:59:25 +0000249#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE) || \
250 defined(CONFIG_PPC_BOOK3S_64))
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000251 if (error_code & DSISR_DABRMATCH) {
252 /* DABR match */
Anton Blanchardbce6c5f2006-01-09 15:47:04 +1100253 do_dabr(regs, address, error_code);
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000254 return 0;
255 }
K.Prasad9c7cc232010-03-29 23:59:25 +0000256#endif
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000257
Benjamin Herrenschmidta5464982012-03-07 16:48:45 +1100258 /* We restore the interrupt state now */
259 if (!arch_irq_disabled_regs(regs))
260 local_irq_enable();
261
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000262 if (in_atomic() || mm == NULL) {
263 if (!user_mode(regs))
264 return SIGSEGV;
265 /* in_atomic() in user mode is really bad,
266 as is current->mm == NULL. */
joe@perches.comdf3c9012007-11-20 12:47:55 +1100267 printk(KERN_EMERG "Page fault in user mode with "
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000268 "in_atomic() = %d mm = %p\n", in_atomic(), mm);
269 printk(KERN_EMERG "NIP = %lx MSR = %lx\n",
270 regs->nip, regs->msr);
271 die("Weird page fault", regs, SIGSEGV);
272 }
273
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +0200274 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
Peter Zijlstra7dd1fcc2009-03-13 12:21:33 +0100275
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000276 /* When running in the kernel we expect faults to occur only to
277 * addresses in user space. All other faults represent errors in the
Anton Blanchardfc5266e2006-04-01 11:33:12 +1100278 * kernel and should generate an OOPS. Unfortunately, in the case of an
279 * erroneous fault occurring in a code path which already holds mmap_sem
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000280 * we will deadlock attempting to validate the fault against the
281 * address space. Luckily the kernel only validly references user
282 * space from well defined areas of code, which are listed in the
283 * exceptions table.
284 *
285 * As the vast majority of faults will be valid we will only perform
Anton Blanchardfc5266e2006-04-01 11:33:12 +1100286 * the source reference check when there is a possibility of a deadlock.
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000287 * Attempt to lock the address space, if we cannot we then validate the
288 * source. If this is invalid we can skip the address space check,
289 * thus avoiding the deadlock.
290 */
291 if (!down_read_trylock(&mm->mmap_sem)) {
292 if (!user_mode(regs) && !search_exception_tables(regs->nip))
293 goto bad_area_nosemaphore;
294
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100295retry:
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000296 down_read(&mm->mmap_sem);
Benjamin Herrenschmidta5464982012-03-07 16:48:45 +1100297 } else {
298 /*
299 * The above down_read_trylock() might have succeeded in
300 * which case we'll have missed the might_sleep() from
301 * down_read():
302 */
303 might_sleep();
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000304 }
305
306 vma = find_vma(mm, address);
307 if (!vma)
308 goto bad_area;
309 if (vma->vm_start <= address)
310 goto good_area;
311 if (!(vma->vm_flags & VM_GROWSDOWN))
312 goto bad_area;
313
314 /*
315 * N.B. The POWER/Open ABI allows programs to access up to
316 * 288 bytes below the stack pointer.
317 * The kernel signal delivery code writes up to about 1.5kB
318 * below the stack pointer (r1) before decrementing it.
319 * The exec code can write slightly over 640kB to the stack
320 * before setting the user r1. Thus we allow the stack to
321 * expand to 1MB without further checks.
322 */
323 if (address + 0x100000 < vma->vm_end) {
324 /* get user regs even if this fault is in kernel mode */
325 struct pt_regs *uregs = current->thread.regs;
326 if (uregs == NULL)
327 goto bad_area;
328
329 /*
330 * A user-mode access to an address a long way below
331 * the stack pointer is only valid if the instruction
332 * is one which would update the stack pointer to the
333 * address accessed if the instruction completed,
334 * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
335 * (or the byte, halfword, float or double forms).
336 *
337 * If we don't check this then any write to the area
338 * between the last mapped region and the stack will
339 * expand the stack rather than segfaulting.
340 */
341 if (address + 2048 < uregs->gpr[1]
342 && (!user_mode(regs) || !store_updates_sp(regs)))
343 goto bad_area;
344 }
345 if (expand_stack(vma, address))
346 goto bad_area;
347
348good_area:
349 code = SEGV_ACCERR;
350#if defined(CONFIG_6xx)
351 if (error_code & 0x95700000)
352 /* an error such as lwarx to I/O controller space,
353 address matching DABR, eciwx, etc. */
354 goto bad_area;
355#endif /* CONFIG_6xx */
356#if defined(CONFIG_8xx)
Joakim Tjernlund5efab4a2009-11-20 00:21:02 +0000357 /* 8xx sometimes need to load a invalid/non-present TLBs.
358 * These must be invalidated separately as linux mm don't.
359 */
360 if (error_code & 0x40000000) /* no translation? */
361 _tlbil_va(address, 0, 0, 0);
362
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000363 /* The MPC8xx seems to always set 0x80000000, which is
364 * "undefined". Of those that can be set, this is the only
365 * one which seems bad.
366 */
367 if (error_code & 0x10000000)
368 /* Guarded storage error. */
369 goto bad_area;
370#endif /* CONFIG_8xx */
371
372 if (is_exec) {
Benjamin Herrenschmidt8d30c142009-02-10 16:02:37 +0000373#ifdef CONFIG_PPC_STD_MMU
374 /* Protection fault on exec go straight to failure on
375 * Hash based MMUs as they either don't support per-page
376 * execute permission, or if they do, it's handled already
377 * at the hash level. This test would probably have to
378 * be removed if we change the way this works to make hash
379 * processors use the same I/D cache coherency mechanism
380 * as embedded.
381 */
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000382 if (error_code & DSISR_PROTFAULT)
383 goto bad_area;
Benjamin Herrenschmidt8d30c142009-02-10 16:02:37 +0000384#endif /* CONFIG_PPC_STD_MMU */
385
Paul Mackerras08ae6cc2007-07-19 10:00:20 +1000386 /*
387 * Allow execution from readable areas if the MMU does not
388 * provide separate controls over reading and executing.
Benjamin Herrenschmidt8d30c142009-02-10 16:02:37 +0000389 *
390 * Note: That code used to not be enabled for 4xx/BookE.
391 * It is now as I/D cache coherency for these is done at
392 * set_pte_at() time and I see no reason why the test
393 * below wouldn't be valid on those processors. This -may-
394 * break programs compiled with a really old ABI though.
Paul Mackerras08ae6cc2007-07-19 10:00:20 +1000395 */
396 if (!(vma->vm_flags & VM_EXEC) &&
397 (cpu_has_feature(CPU_FTR_NOEXECUTE) ||
398 !(vma->vm_flags & (VM_READ | VM_WRITE))))
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000399 goto bad_area;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000400 /* a write */
401 } else if (is_write) {
402 if (!(vma->vm_flags & VM_WRITE))
403 goto bad_area;
404 /* a read */
405 } else {
406 /* protection fault */
407 if (error_code & 0x08000000)
408 goto bad_area;
Jason Barondf67b3d2006-09-29 01:58:58 -0700409 if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000410 goto bad_area;
411 }
412
413 /*
414 * If for any reason at all we couldn't handle the fault,
415 * make sure we exit gracefully rather than endlessly redo
416 * the fault.
417 */
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100418 fault = handle_mm_fault(mm, vma, address, flags);
419 if (unlikely(fault & (VM_FAULT_RETRY|VM_FAULT_ERROR))) {
420 int rc = mm_fault_error(regs, address, fault);
421 if (rc >= MM_FAULT_RETURN)
422 return rc;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000423 }
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100424
425 /*
426 * Major/minor page fault accounting is only done on the
427 * initial attempt. If we go through a retry, it is extremely
428 * likely that the page will be found in page cache at that point.
429 */
430 if (flags & FAULT_FLAG_ALLOW_RETRY) {
431 if (fault & VM_FAULT_MAJOR) {
432 current->maj_flt++;
433 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1,
434 regs, address);
Brian King40900192008-10-22 05:53:45 +0000435#ifdef CONFIG_PPC_SMLPAR
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100436 if (firmware_has_feature(FW_FEATURE_CMO)) {
437 preempt_disable();
438 get_lppaca()->page_ins += (1 << PAGE_FACTOR);
439 preempt_enable();
440 }
441#endif /* CONFIG_PPC_SMLPAR */
442 } else {
443 current->min_flt++;
444 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1,
445 regs, address);
Brian King40900192008-10-22 05:53:45 +0000446 }
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100447 if (fault & VM_FAULT_RETRY) {
448 /* Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk
449 * of starvation. */
450 flags &= ~FAULT_FLAG_ALLOW_RETRY;
Shaohua Li45cac652012-10-08 16:32:19 -0700451 flags |= FAULT_FLAG_TRIED;
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100452 goto retry;
453 }
Peter Zijlstraac17dc82009-03-13 12:21:34 +0100454 }
Benjamin Herrenschmidt9be72572012-03-01 18:14:45 +1100455
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000456 up_read(&mm->mmap_sem);
457 return 0;
458
459bad_area:
460 up_read(&mm->mmap_sem);
461
462bad_area_nosemaphore:
463 /* User mode accesses cause a SIGSEGV */
464 if (user_mode(regs)) {
465 _exception(SIGSEGV, regs, code, address);
466 return 0;
467 }
468
Christian Dietrich76462232011-06-04 05:36:54 +0000469 if (is_exec && (error_code & DSISR_PROTFAULT))
470 printk_ratelimited(KERN_CRIT "kernel tried to execute NX-protected"
471 " page (%lx) - exploit attempt? (uid: %d)\n",
Eric W. Biederman9e184e02012-08-07 03:59:47 -0700472 address, from_kuid(&init_user_ns, current_uid()));
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000473
474 return SIGSEGV;
475
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000476}
477
478/*
479 * bad_page_fault is called when we have a bad access from the kernel.
480 * It is called from the DSI and ISI handlers in head.S and from some
481 * of the procedures in traps.c.
482 */
483void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
484{
485 const struct exception_table_entry *entry;
Anton Blanchard28b54992010-08-24 13:15:28 +0000486 unsigned long *stackend;
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000487
488 /* Are we prepared to handle this fault? */
489 if ((entry = search_exception_tables(regs->nip)) != NULL) {
490 regs->nip = entry->fixup;
491 return;
492 }
493
494 /* kernel has accessed a bad area */
Olof Johansson723925b2005-11-06 14:54:36 -0800495
Olof Johansson723925b2005-11-06 14:54:36 -0800496 switch (regs->trap) {
Michael Ellermana416dd82006-11-08 10:22:59 +1100497 case 0x300:
498 case 0x380:
499 printk(KERN_ALERT "Unable to handle kernel paging request for "
500 "data at address 0x%08lx\n", regs->dar);
501 break;
502 case 0x400:
503 case 0x480:
504 printk(KERN_ALERT "Unable to handle kernel paging request for "
505 "instruction fetch\n");
506 break;
507 default:
508 printk(KERN_ALERT "Unable to handle kernel paging request for "
509 "unknown fault\n");
510 break;
Olof Johansson723925b2005-11-06 14:54:36 -0800511 }
512 printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n",
513 regs->nip);
514
Anton Blanchard28b54992010-08-24 13:15:28 +0000515 stackend = end_of_stack(current);
516 if (current != &init_task && *stackend != STACK_END_MAGIC)
517 printk(KERN_ALERT "Thread overran stack, or stack corrupted\n");
518
Paul Mackerras14cf11a2005-09-26 16:04:21 +1000519 die("Kernel access of bad area", regs, sig);
520}