2005-09-25 23:04:21 -07:00
|
|
|
/*
|
|
|
|
* PowerPC version
|
|
|
|
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
|
|
|
|
*
|
|
|
|
* Derived from "arch/i386/mm/fault.c"
|
|
|
|
* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Modified by Cort Dougan and Paul Mackerras.
|
|
|
|
*
|
|
|
|
* Modified for PPC64 by Dave Engebretsen (engebret@ibm.com)
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/mman.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kprobes.h>
|
2007-05-08 00:27:03 -07:00
|
|
|
#include <linux/kdebug.h>
|
2005-09-25 23:04:21 -07:00
|
|
|
|
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/mmu.h>
|
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/siginfo.h>
|
|
|
|
|
2006-06-26 00:25:27 -07:00
|
|
|
|
2007-04-30 03:56:46 -07:00
|
|
|
#ifdef CONFIG_KPROBES
|
|
|
|
static inline int notify_page_fault(struct pt_regs *regs)
|
2006-06-26 00:25:27 -07:00
|
|
|
{
|
2007-04-30 03:56:46 -07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* kprobe_running() needs smp_processor_id() */
|
|
|
|
if (!user_mode(regs)) {
|
|
|
|
preempt_disable();
|
|
|
|
if (kprobe_running() && kprobe_fault_handler(regs, 11))
|
|
|
|
ret = 1;
|
|
|
|
preempt_enable();
|
|
|
|
}
|
2006-06-26 00:25:27 -07:00
|
|
|
|
2007-04-30 03:56:46 -07:00
|
|
|
return ret;
|
2006-06-26 00:25:27 -07:00
|
|
|
}
|
|
|
|
#else
|
2007-04-30 03:56:46 -07:00
|
|
|
static inline int notify_page_fault(struct pt_regs *regs)
|
2006-06-26 00:25:27 -07:00
|
|
|
{
|
2007-04-30 03:56:46 -07:00
|
|
|
return 0;
|
2006-06-26 00:25:27 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-09-25 23:04:21 -07:00
|
|
|
/*
|
|
|
|
* Check whether the instruction at regs->nip is a store using
|
|
|
|
* an update addressing form which will update r1.
|
|
|
|
*/
|
|
|
|
static int store_updates_sp(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
unsigned int inst;
|
|
|
|
|
|
|
|
if (get_user(inst, (unsigned int __user *)regs->nip))
|
|
|
|
return 0;
|
|
|
|
/* check for 1 in the rA field */
|
|
|
|
if (((inst >> 16) & 0x1f) != 1)
|
|
|
|
return 0;
|
|
|
|
/* check major opcode */
|
|
|
|
switch (inst >> 26) {
|
|
|
|
case 37: /* stwu */
|
|
|
|
case 39: /* stbu */
|
|
|
|
case 45: /* sthu */
|
|
|
|
case 53: /* stfsu */
|
|
|
|
case 55: /* stfdu */
|
|
|
|
return 1;
|
|
|
|
case 62: /* std or stdu */
|
|
|
|
return (inst & 3) == 1;
|
|
|
|
case 31:
|
|
|
|
/* check minor opcode */
|
|
|
|
switch ((inst >> 1) & 0x3ff) {
|
|
|
|
case 181: /* stdux */
|
|
|
|
case 183: /* stwux */
|
|
|
|
case 247: /* stbux */
|
|
|
|
case 439: /* sthux */
|
|
|
|
case 695: /* stfsux */
|
|
|
|
case 759: /* stfdux */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-26 07:55:41 -07:00
|
|
|
#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
|
2006-01-08 21:47:04 -07:00
|
|
|
static void do_dabr(struct pt_regs *regs, unsigned long address,
|
|
|
|
unsigned long error_code)
|
2005-09-25 23:04:21 -07:00
|
|
|
{
|
|
|
|
siginfo_t info;
|
|
|
|
|
|
|
|
if (notify_die(DIE_DABR_MATCH, "dabr_match", regs, error_code,
|
|
|
|
11, SIGSEGV) == NOTIFY_STOP)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (debugger_dabr_match(regs))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Clear the DABR */
|
|
|
|
set_dabr(0);
|
|
|
|
|
|
|
|
/* Deliver the signal to userspace */
|
|
|
|
info.si_signo = SIGTRAP;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TRAP_HWBKPT;
|
2006-01-08 21:47:04 -07:00
|
|
|
info.si_addr = (void __user *)address;
|
2005-09-25 23:04:21 -07:00
|
|
|
force_sig_info(SIGTRAP, &info, current);
|
|
|
|
}
|
2005-10-26 07:55:41 -07:00
|
|
|
#endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
|
2005-09-25 23:04:21 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For 600- and 800-family processors, the error_code parameter is DSISR
|
|
|
|
* for a data fault, SRR1 for an instruction fault. For 400-family processors
|
|
|
|
* the error_code parameter is ESR for a data fault, 0 for an instruction
|
|
|
|
* fault.
|
|
|
|
* For 64-bit processors, the error_code parameter is
|
|
|
|
* - DSISR for a non-SLB data access fault,
|
|
|
|
* - SRR1 & 0x08000000 for a non-SLB instruction access fault
|
|
|
|
* - 0 any SLB fault.
|
|
|
|
*
|
|
|
|
* The return value is 0 if the fault was handled, or the signal
|
|
|
|
* number if this is a kernel fault that can't be handled here.
|
|
|
|
*/
|
|
|
|
int __kprobes do_page_fault(struct pt_regs *regs, unsigned long address,
|
|
|
|
unsigned long error_code)
|
|
|
|
{
|
|
|
|
struct vm_area_struct * vma;
|
|
|
|
struct mm_struct *mm = current->mm;
|
|
|
|
siginfo_t info;
|
|
|
|
int code = SEGV_MAPERR;
|
|
|
|
int is_write = 0;
|
|
|
|
int trap = TRAP(regs);
|
|
|
|
int is_exec = trap == 0x400;
|
|
|
|
|
|
|
|
#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
|
|
|
|
/*
|
|
|
|
* Fortunately the bit assignments in SRR1 for an instruction
|
|
|
|
* fault and DSISR for a data fault are mostly the same for the
|
|
|
|
* bits we are interested in. But there are some bits which
|
|
|
|
* indicate errors in DSISR but can validly be set in SRR1.
|
|
|
|
*/
|
|
|
|
if (trap == 0x400)
|
|
|
|
error_code &= 0x48200000;
|
|
|
|
else
|
|
|
|
is_write = error_code & DSISR_ISSTORE;
|
|
|
|
#else
|
|
|
|
is_write = error_code & ESR_DST;
|
|
|
|
#endif /* CONFIG_4xx || CONFIG_BOOKE */
|
|
|
|
|
2007-04-30 03:56:46 -07:00
|
|
|
if (notify_page_fault(regs))
|
2005-09-25 23:04:21 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (trap == 0x300) {
|
|
|
|
if (debugger_fault_handler(regs))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* On a kernel SLB miss we can only check for a valid exception entry */
|
|
|
|
if (!user_mode(regs) && (address >= TASK_SIZE))
|
|
|
|
return SIGSEGV;
|
|
|
|
|
|
|
|
#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
|
|
|
|
if (error_code & DSISR_DABRMATCH) {
|
|
|
|
/* DABR match */
|
2006-01-08 21:47:04 -07:00
|
|
|
do_dabr(regs, address, error_code);
|
2005-09-25 23:04:21 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/
|
|
|
|
|
|
|
|
if (in_atomic() || mm == NULL) {
|
|
|
|
if (!user_mode(regs))
|
|
|
|
return SIGSEGV;
|
|
|
|
/* in_atomic() in user mode is really bad,
|
|
|
|
as is current->mm == NULL. */
|
|
|
|
printk(KERN_EMERG "Page fault in user mode with"
|
|
|
|
"in_atomic() = %d mm = %p\n", in_atomic(), mm);
|
|
|
|
printk(KERN_EMERG "NIP = %lx MSR = %lx\n",
|
|
|
|
regs->nip, regs->msr);
|
|
|
|
die("Weird page fault", regs, SIGSEGV);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* When running in the kernel we expect faults to occur only to
|
|
|
|
* addresses in user space. All other faults represent errors in the
|
2006-03-31 17:33:12 -07:00
|
|
|
* kernel and should generate an OOPS. Unfortunately, in the case of an
|
|
|
|
* erroneous fault occurring in a code path which already holds mmap_sem
|
2005-09-25 23:04:21 -07:00
|
|
|
* we will deadlock attempting to validate the fault against the
|
|
|
|
* address space. Luckily the kernel only validly references user
|
|
|
|
* space from well defined areas of code, which are listed in the
|
|
|
|
* exceptions table.
|
|
|
|
*
|
|
|
|
* As the vast majority of faults will be valid we will only perform
|
2006-03-31 17:33:12 -07:00
|
|
|
* the source reference check when there is a possibility of a deadlock.
|
2005-09-25 23:04:21 -07:00
|
|
|
* Attempt to lock the address space, if we cannot we then validate the
|
|
|
|
* source. If this is invalid we can skip the address space check,
|
|
|
|
* thus avoiding the deadlock.
|
|
|
|
*/
|
|
|
|
if (!down_read_trylock(&mm->mmap_sem)) {
|
|
|
|
if (!user_mode(regs) && !search_exception_tables(regs->nip))
|
|
|
|
goto bad_area_nosemaphore;
|
|
|
|
|
|
|
|
down_read(&mm->mmap_sem);
|
|
|
|
}
|
|
|
|
|
|
|
|
vma = find_vma(mm, address);
|
|
|
|
if (!vma)
|
|
|
|
goto bad_area;
|
|
|
|
if (vma->vm_start <= address)
|
|
|
|
goto good_area;
|
|
|
|
if (!(vma->vm_flags & VM_GROWSDOWN))
|
|
|
|
goto bad_area;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* N.B. The POWER/Open ABI allows programs to access up to
|
|
|
|
* 288 bytes below the stack pointer.
|
|
|
|
* The kernel signal delivery code writes up to about 1.5kB
|
|
|
|
* below the stack pointer (r1) before decrementing it.
|
|
|
|
* The exec code can write slightly over 640kB to the stack
|
|
|
|
* before setting the user r1. Thus we allow the stack to
|
|
|
|
* expand to 1MB without further checks.
|
|
|
|
*/
|
|
|
|
if (address + 0x100000 < vma->vm_end) {
|
|
|
|
/* get user regs even if this fault is in kernel mode */
|
|
|
|
struct pt_regs *uregs = current->thread.regs;
|
|
|
|
if (uregs == NULL)
|
|
|
|
goto bad_area;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A user-mode access to an address a long way below
|
|
|
|
* the stack pointer is only valid if the instruction
|
|
|
|
* is one which would update the stack pointer to the
|
|
|
|
* address accessed if the instruction completed,
|
|
|
|
* i.e. either stwu rs,n(r1) or stwux rs,r1,rb
|
|
|
|
* (or the byte, halfword, float or double forms).
|
|
|
|
*
|
|
|
|
* If we don't check this then any write to the area
|
|
|
|
* between the last mapped region and the stack will
|
|
|
|
* expand the stack rather than segfaulting.
|
|
|
|
*/
|
|
|
|
if (address + 2048 < uregs->gpr[1]
|
|
|
|
&& (!user_mode(regs) || !store_updates_sp(regs)))
|
|
|
|
goto bad_area;
|
|
|
|
}
|
|
|
|
if (expand_stack(vma, address))
|
|
|
|
goto bad_area;
|
|
|
|
|
|
|
|
good_area:
|
|
|
|
code = SEGV_ACCERR;
|
|
|
|
#if defined(CONFIG_6xx)
|
|
|
|
if (error_code & 0x95700000)
|
|
|
|
/* an error such as lwarx to I/O controller space,
|
|
|
|
address matching DABR, eciwx, etc. */
|
|
|
|
goto bad_area;
|
|
|
|
#endif /* CONFIG_6xx */
|
|
|
|
#if defined(CONFIG_8xx)
|
|
|
|
/* The MPC8xx seems to always set 0x80000000, which is
|
|
|
|
* "undefined". Of those that can be set, this is the only
|
|
|
|
* one which seems bad.
|
|
|
|
*/
|
|
|
|
if (error_code & 0x10000000)
|
|
|
|
/* Guarded storage error. */
|
|
|
|
goto bad_area;
|
|
|
|
#endif /* CONFIG_8xx */
|
|
|
|
|
|
|
|
if (is_exec) {
|
2007-06-19 08:07:04 -07:00
|
|
|
#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
|
2005-09-25 23:04:21 -07:00
|
|
|
/* protection fault */
|
|
|
|
if (error_code & DSISR_PROTFAULT)
|
|
|
|
goto bad_area;
|
|
|
|
if (!(vma->vm_flags & VM_EXEC))
|
|
|
|
goto bad_area;
|
2007-06-19 08:07:04 -07:00
|
|
|
#else
|
2005-09-25 23:04:21 -07:00
|
|
|
pte_t *ptep;
|
2006-03-28 11:13:12 -07:00
|
|
|
pmd_t *pmdp;
|
2005-09-25 23:04:21 -07:00
|
|
|
|
|
|
|
/* Since 4xx/Book-E supports per-page execute permission,
|
|
|
|
* we lazily flush dcache to icache. */
|
|
|
|
ptep = NULL;
|
2006-03-28 11:13:12 -07:00
|
|
|
if (get_pteptr(mm, address, &ptep, &pmdp)) {
|
|
|
|
spinlock_t *ptl = pte_lockptr(mm, pmdp);
|
|
|
|
spin_lock(ptl);
|
|
|
|
if (pte_present(*ptep)) {
|
|
|
|
struct page *page = pte_page(*ptep);
|
2005-09-25 23:04:21 -07:00
|
|
|
|
2006-03-28 11:13:12 -07:00
|
|
|
if (!test_bit(PG_arch_1, &page->flags)) {
|
|
|
|
flush_dcache_icache_page(page);
|
|
|
|
set_bit(PG_arch_1, &page->flags);
|
|
|
|
}
|
|
|
|
pte_update(ptep, 0, _PAGE_HWEXEC);
|
|
|
|
_tlbie(address);
|
|
|
|
pte_unmap_unlock(ptep, ptl);
|
|
|
|
up_read(&mm->mmap_sem);
|
|
|
|
return 0;
|
2005-09-25 23:04:21 -07:00
|
|
|
}
|
2006-03-28 11:13:12 -07:00
|
|
|
pte_unmap_unlock(ptep, ptl);
|
2005-09-25 23:04:21 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* a write */
|
|
|
|
} else if (is_write) {
|
|
|
|
if (!(vma->vm_flags & VM_WRITE))
|
|
|
|
goto bad_area;
|
|
|
|
/* a read */
|
|
|
|
} else {
|
|
|
|
/* protection fault */
|
|
|
|
if (error_code & 0x08000000)
|
|
|
|
goto bad_area;
|
[PATCH] make PROT_WRITE imply PROT_READ
Make PROT_WRITE imply PROT_READ for a number of architectures which don't
support write only in hardware.
While looking at this, I noticed that some architectures which do not
support write only mappings already take the exact same approach. For
example, in arch/alpha/mm/fault.c:
"
if (cause < 0) {
if (!(vma->vm_flags & VM_EXEC))
goto bad_area;
} else if (!cause) {
/* Allow reads even for write-only mappings */
if (!(vma->vm_flags & (VM_READ | VM_WRITE)))
goto bad_area;
} else {
if (!(vma->vm_flags & VM_WRITE))
goto bad_area;
}
"
Thus, this patch brings other architectures which do not support write only
mappings in-line and consistent with the rest. I've verified the patch on
ia64, x86_64 and x86.
Additional discussion:
Several architectures, including x86, can not support write-only mappings.
The pte for x86 reserves a single bit for protection and its two states are
read only or read/write. Thus, write only is not supported in h/w.
Currently, if i 'mmap' a page write-only, the first read attempt on that page
creates a page fault and will SEGV. That check is enforced in
arch/blah/mm/fault.c. However, if i first write that page it will fault in
and the pte will be set to read/write. Thus, any subsequent reads to the page
will succeed. It is this inconsistency in behavior that this patch is
attempting to address. Furthermore, if the page is swapped out, and then
brought back the first read will also cause a SEGV. Thus, any arbitrary read
on a page can potentially result in a SEGV.
According to the SuSv3 spec, "if the application requests only PROT_WRITE, the
implementation may also allow read access." Also as mentioned, some
archtectures, such as alpha, shown above already take the approach that i am
suggesting.
The counter-argument to this raised by Arjan, is that the kernel is enforcing
the write only mapping the best it can given the h/w limitations. This is
true, however Alan Cox, and myself would argue that the inconsitency in
behavior, that is applications can sometimes work/sometimes fails is highly
undesireable. If you read through the thread, i think people, came to an
agreement on the last patch i posted, as nobody has objected to it...
Signed-off-by: Jason Baron <jbaron@redhat.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: "Luck, Tony" <tony.luck@intel.com>
Cc: Hugh Dickins <hugh@veritas.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Acked-by: Andi Kleen <ak@muc.de>
Acked-by: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Acked-by: Paul Mundt <lethal@linux-sh.org>
Cc: Kazumoto Kojima <kkojima@rr.iij4u.or.jp>
Cc: Ian Molton <spyro@f2s.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-29 01:58:58 -07:00
|
|
|
if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
|
2005-09-25 23:04:21 -07:00
|
|
|
goto bad_area;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If for any reason at all we couldn't handle the fault,
|
|
|
|
* make sure we exit gracefully rather than endlessly redo
|
|
|
|
* the fault.
|
|
|
|
*/
|
|
|
|
survive:
|
|
|
|
switch (handle_mm_fault(mm, vma, address, is_write)) {
|
|
|
|
|
|
|
|
case VM_FAULT_MINOR:
|
|
|
|
current->min_flt++;
|
|
|
|
break;
|
|
|
|
case VM_FAULT_MAJOR:
|
|
|
|
current->maj_flt++;
|
|
|
|
break;
|
|
|
|
case VM_FAULT_SIGBUS:
|
|
|
|
goto do_sigbus;
|
|
|
|
case VM_FAULT_OOM:
|
|
|
|
goto out_of_memory;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
up_read(&mm->mmap_sem);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bad_area:
|
|
|
|
up_read(&mm->mmap_sem);
|
|
|
|
|
|
|
|
bad_area_nosemaphore:
|
|
|
|
/* User mode accesses cause a SIGSEGV */
|
|
|
|
if (user_mode(regs)) {
|
|
|
|
_exception(SIGSEGV, regs, code, address);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_exec && (error_code & DSISR_PROTFAULT)
|
|
|
|
&& printk_ratelimit())
|
|
|
|
printk(KERN_CRIT "kernel tried to execute NX-protected"
|
|
|
|
" page (%lx) - exploit attempt? (uid: %d)\n",
|
|
|
|
address, current->uid);
|
|
|
|
|
|
|
|
return SIGSEGV;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We ran out of memory, or some other thing happened to us that made
|
|
|
|
* us unable to handle the page fault gracefully.
|
|
|
|
*/
|
|
|
|
out_of_memory:
|
|
|
|
up_read(&mm->mmap_sem);
|
2006-09-29 02:00:07 -07:00
|
|
|
if (is_init(current)) {
|
2005-09-25 23:04:21 -07:00
|
|
|
yield();
|
|
|
|
down_read(&mm->mmap_sem);
|
|
|
|
goto survive;
|
|
|
|
}
|
|
|
|
printk("VM: killing process %s\n", current->comm);
|
|
|
|
if (user_mode(regs))
|
|
|
|
do_exit(SIGKILL);
|
|
|
|
return SIGKILL;
|
|
|
|
|
|
|
|
do_sigbus:
|
|
|
|
up_read(&mm->mmap_sem);
|
|
|
|
if (user_mode(regs)) {
|
|
|
|
info.si_signo = SIGBUS;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = BUS_ADRERR;
|
|
|
|
info.si_addr = (void __user *)address;
|
|
|
|
force_sig_info(SIGBUS, &info, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return SIGBUS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bad_page_fault is called when we have a bad access from the kernel.
|
|
|
|
* It is called from the DSI and ISI handlers in head.S and from some
|
|
|
|
* of the procedures in traps.c.
|
|
|
|
*/
|
|
|
|
void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
|
|
|
|
{
|
|
|
|
const struct exception_table_entry *entry;
|
|
|
|
|
|
|
|
/* Are we prepared to handle this fault? */
|
|
|
|
if ((entry = search_exception_tables(regs->nip)) != NULL) {
|
|
|
|
regs->nip = entry->fixup;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* kernel has accessed a bad area */
|
2005-11-06 15:54:36 -07:00
|
|
|
|
|
|
|
switch (regs->trap) {
|
2006-11-07 16:22:59 -07:00
|
|
|
case 0x300:
|
|
|
|
case 0x380:
|
|
|
|
printk(KERN_ALERT "Unable to handle kernel paging request for "
|
|
|
|
"data at address 0x%08lx\n", regs->dar);
|
|
|
|
break;
|
|
|
|
case 0x400:
|
|
|
|
case 0x480:
|
|
|
|
printk(KERN_ALERT "Unable to handle kernel paging request for "
|
|
|
|
"instruction fetch\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ALERT "Unable to handle kernel paging request for "
|
|
|
|
"unknown fault\n");
|
|
|
|
break;
|
2005-11-06 15:54:36 -07:00
|
|
|
}
|
|
|
|
printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n",
|
|
|
|
regs->nip);
|
|
|
|
|
2005-09-25 23:04:21 -07:00
|
|
|
die("Kernel access of bad area", regs, sig);
|
|
|
|
}
|