forked from luck/tmp_suning_uos_patched
316 lines
7.1 KiB
C
316 lines
7.1 KiB
C
/*
|
|
* linux/arch/arm26/mm/fault.c
|
|
*
|
|
* Copyright (C) 1995 Linus Torvalds
|
|
* Modifications for ARM processor (c) 1995-2001 Russell King
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
#include <linux/config.h>
|
|
#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/proc_fs.h>
|
|
#include <linux/init.h>
|
|
|
|
#include <asm/system.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/uaccess.h> //FIXME this header may be bogusly included
|
|
|
|
#include "fault.h"
|
|
|
|
#define FAULT_CODE_LDRSTRPOST 0x80
|
|
#define FAULT_CODE_LDRSTRPRE 0x40
|
|
#define FAULT_CODE_LDRSTRREG 0x20
|
|
#define FAULT_CODE_LDMSTM 0x10
|
|
#define FAULT_CODE_LDCSTC 0x08
|
|
#define FAULT_CODE_PREFETCH 0x04
|
|
#define FAULT_CODE_WRITE 0x02
|
|
#define FAULT_CODE_FORCECOW 0x01
|
|
|
|
#define DO_COW(m) ((m) & (FAULT_CODE_WRITE|FAULT_CODE_FORCECOW))
|
|
#define READ_FAULT(m) (!((m) & FAULT_CODE_WRITE))
|
|
#define DEBUG
|
|
/*
|
|
* This is useful to dump out the page tables associated with
|
|
* 'addr' in mm 'mm'.
|
|
*/
|
|
void show_pte(struct mm_struct *mm, unsigned long addr)
|
|
{
|
|
pgd_t *pgd;
|
|
|
|
if (!mm)
|
|
mm = &init_mm;
|
|
|
|
printk(KERN_ALERT "pgd = %p\n", mm->pgd);
|
|
pgd = pgd_offset(mm, addr);
|
|
printk(KERN_ALERT "[%08lx] *pgd=%08lx", addr, pgd_val(*pgd));
|
|
|
|
do {
|
|
pmd_t *pmd;
|
|
pte_t *pte;
|
|
|
|
pmd = pmd_offset(pgd, addr);
|
|
|
|
if (pmd_none(*pmd))
|
|
break;
|
|
|
|
if (pmd_bad(*pmd)) {
|
|
printk("(bad)");
|
|
break;
|
|
}
|
|
|
|
/* We must not map this if we have highmem enabled */
|
|
/* FIXME */
|
|
pte = pte_offset_map(pmd, addr);
|
|
printk(", *pte=%08lx", pte_val(*pte));
|
|
pte_unmap(pte);
|
|
} while(0);
|
|
|
|
printk("\n");
|
|
}
|
|
|
|
/*
|
|
* Oops. The kernel tried to access some page that wasn't present.
|
|
*/
|
|
static void
|
|
__do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
|
|
struct pt_regs *regs)
|
|
{
|
|
/*
|
|
* Are we prepared to handle this kernel fault?
|
|
*/
|
|
if (fixup_exception(regs))
|
|
return;
|
|
|
|
/*
|
|
* No handler, we'll have to terminate things with extreme prejudice.
|
|
*/
|
|
bust_spinlocks(1);
|
|
printk(KERN_ALERT
|
|
"Unable to handle kernel %s at virtual address %08lx\n",
|
|
(addr < PAGE_SIZE) ? "NULL pointer dereference" :
|
|
"paging request", addr);
|
|
|
|
show_pte(mm, addr);
|
|
die("Oops", regs, fsr);
|
|
bust_spinlocks(0);
|
|
do_exit(SIGKILL);
|
|
}
|
|
|
|
/*
|
|
* Something tried to access memory that isn't in our memory map..
|
|
* User mode accesses just cause a SIGSEGV
|
|
*/
|
|
static void
|
|
__do_user_fault(struct task_struct *tsk, unsigned long addr,
|
|
unsigned int fsr, int code, struct pt_regs *regs)
|
|
{
|
|
struct siginfo si;
|
|
|
|
#ifdef CONFIG_DEBUG_USER
|
|
printk("%s: unhandled page fault at 0x%08lx, code 0x%03x\n",
|
|
tsk->comm, addr, fsr);
|
|
show_pte(tsk->mm, addr);
|
|
show_regs(regs);
|
|
//dump_backtrace(regs, tsk); // FIXME ARM32 dropped this - why?
|
|
while(1); //FIXME - hack to stop debug going nutso
|
|
#endif
|
|
|
|
tsk->thread.address = addr;
|
|
tsk->thread.error_code = fsr;
|
|
tsk->thread.trap_no = 14;
|
|
si.si_signo = SIGSEGV;
|
|
si.si_errno = 0;
|
|
si.si_code = code;
|
|
si.si_addr = (void *)addr;
|
|
force_sig_info(SIGSEGV, &si, tsk);
|
|
}
|
|
|
|
static int
|
|
__do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
|
|
struct task_struct *tsk)
|
|
{
|
|
struct vm_area_struct *vma;
|
|
int fault, mask;
|
|
|
|
vma = find_vma(mm, addr);
|
|
fault = -2; /* bad map area */
|
|
if (!vma)
|
|
goto out;
|
|
if (vma->vm_start > addr)
|
|
goto check_stack;
|
|
|
|
/*
|
|
* Ok, we have a good vm_area for this
|
|
* memory access, so we can handle it.
|
|
*/
|
|
good_area:
|
|
if (READ_FAULT(fsr)) /* read? */
|
|
mask = VM_READ|VM_EXEC;
|
|
else
|
|
mask = VM_WRITE;
|
|
|
|
fault = -1; /* bad access type */
|
|
if (!(vma->vm_flags & mask))
|
|
goto out;
|
|
|
|
/*
|
|
* If for any reason at all we couldn't handle
|
|
* the fault, make sure we exit gracefully rather
|
|
* than endlessly redo the fault.
|
|
*/
|
|
survive:
|
|
fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, DO_COW(fsr));
|
|
|
|
/*
|
|
* Handle the "normal" cases first - successful and sigbus
|
|
*/
|
|
switch (fault) {
|
|
case VM_FAULT_MAJOR:
|
|
tsk->maj_flt++;
|
|
return fault;
|
|
case VM_FAULT_MINOR:
|
|
tsk->min_flt++;
|
|
case VM_FAULT_SIGBUS:
|
|
return fault;
|
|
}
|
|
|
|
fault = -3; /* out of memory */
|
|
if (tsk->pid != 1)
|
|
goto out;
|
|
|
|
/*
|
|
* If we are out of memory for pid1,
|
|
* sleep for a while and retry
|
|
*/
|
|
yield();
|
|
goto survive;
|
|
|
|
check_stack:
|
|
if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
|
|
goto good_area;
|
|
out:
|
|
return fault;
|
|
}
|
|
|
|
int do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
|
|
{
|
|
struct task_struct *tsk;
|
|
struct mm_struct *mm;
|
|
int fault;
|
|
|
|
tsk = current;
|
|
mm = tsk->mm;
|
|
|
|
/*
|
|
* If we're in an interrupt or have no user
|
|
* context, we must not take the fault..
|
|
*/
|
|
if (in_interrupt() || !mm)
|
|
goto no_context;
|
|
|
|
down_read(&mm->mmap_sem);
|
|
fault = __do_page_fault(mm, addr, fsr, tsk);
|
|
up_read(&mm->mmap_sem);
|
|
|
|
/*
|
|
* Handle the "normal" case first
|
|
*/
|
|
switch (fault) {
|
|
case VM_FAULT_MINOR:
|
|
case VM_FAULT_MAJOR:
|
|
return 0;
|
|
case VM_FAULT_SIGBUS:
|
|
goto do_sigbus;
|
|
}
|
|
|
|
/*
|
|
* If we are in kernel mode at this point, we
|
|
* have no context to handle this fault with.
|
|
* FIXME - is this test right?
|
|
*/
|
|
if (!user_mode(regs)){
|
|
goto no_context;
|
|
}
|
|
|
|
if (fault == -3) {
|
|
/*
|
|
* We ran out of memory, or some other thing happened to
|
|
* us that made us unable to handle the page fault gracefully.
|
|
*/
|
|
printk("VM: killing process %s\n", tsk->comm);
|
|
do_exit(SIGKILL);
|
|
}
|
|
else{
|
|
__do_user_fault(tsk, addr, fsr, fault == -1 ? SEGV_ACCERR : SEGV_MAPERR, regs);
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
/*
|
|
* We ran out of memory, or some other thing happened to us that made
|
|
* us unable to handle the page fault gracefully.
|
|
*/
|
|
do_sigbus:
|
|
/*
|
|
* Send a sigbus, regardless of whether we were in kernel
|
|
* or user mode.
|
|
*/
|
|
tsk->thread.address = addr; //FIXME - need other bits setting?
|
|
tsk->thread.error_code = fsr;
|
|
tsk->thread.trap_no = 14;
|
|
force_sig(SIGBUS, tsk);
|
|
#ifdef CONFIG_DEBUG_USER
|
|
printk(KERN_DEBUG "%s: sigbus at 0x%08lx, pc=0x%08lx\n",
|
|
current->comm, addr, instruction_pointer(regs));
|
|
#endif
|
|
|
|
/* Kernel mode? Handle exceptions or die */
|
|
if (user_mode(regs))
|
|
return 0;
|
|
|
|
no_context:
|
|
__do_kernel_fault(mm, addr, fsr, regs);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Handle a data abort. Note that we have to handle a range of addresses
|
|
* on ARM2/3 for ldm. If both pages are zero-mapped, then we have to force
|
|
* a copy-on-write. However, on the second page, we always force COW.
|
|
*/
|
|
asmlinkage void
|
|
do_DataAbort(unsigned long min_addr, unsigned long max_addr, int mode, struct pt_regs *regs)
|
|
{
|
|
do_page_fault(min_addr, mode, regs);
|
|
|
|
if ((min_addr ^ max_addr) >> PAGE_SHIFT){
|
|
do_page_fault(max_addr, mode | FAULT_CODE_FORCECOW, regs);
|
|
}
|
|
}
|
|
|
|
asmlinkage int
|
|
do_PrefetchAbort(unsigned long addr, struct pt_regs *regs)
|
|
{
|
|
#if 0
|
|
if (the memc mapping for this page exists) {
|
|
printk ("Page in, but got abort (undefined instruction?)\n");
|
|
return 0;
|
|
}
|
|
#endif
|
|
do_page_fault(addr, FAULT_CODE_PREFETCH, regs);
|
|
return 1;
|
|
}
|
|
|