/* * This file is subject to the terms and conditions of the GNU General Public * License.  See the file "COPYING" in the main directory of this archive * for more details. * * Copyright (C) 1995 - 2000 by Ralf Baechle */#include <linux/config.h>#include <linux/signal.h>#include <linux/sched.h>#include <linux/interrupt.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/smp.h>#include <linux/smp_lock.h>#include <linux/version.h>#include <asm/branch.h>#include <asm/hardirq.h>#include <asm/pgalloc.h>#include <asm/mmu_context.h>#include <asm/softirq.h>#include <asm/system.h>#include <asm/uaccess.h>#define development_version (LINUX_VERSION_CODE & 0x100)/* * Macro for exception fixup code to access integer registers. */#define dpf_reg(r) (regs->regs[r])extern spinlock_t timerlist_lock;/* * Unlock any spinlocks which will prevent us from getting the * message out (timerlist_lock is acquired through the * console unblank code) */void bust_spinlocks(int yes){	spin_lock_init(&timerlist_lock);	if (yes) {		oops_in_progress = 1;#ifdef CONFIG_SMP		/* Many serial drivers do __global_cli() */		global_irq_lock = SPIN_LOCK_UNLOCKED;#endif	} else {		int loglevel_save = console_loglevel;#ifdef CONFIG_VT		unblank_screen();#endif		oops_in_progress = 0;		/*		 * OK, the message is on the console.  Now we call printk()		 * without oops_in_progress set so that printk will give klogd		 * a poke.  Hold onto your hats...		 */		console_loglevel = 15;		/* NMI oopser may have shut the console up */		printk(" ");		console_loglevel = loglevel_save;	}}/* * This routine handles page faults.  It determines the address, * and the problem, and then passes it off to one of the appropriate * routines. */asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write,			      unsigned long address){	struct vm_area_struct * vma;	struct task_struct *tsk = current;	struct mm_struct *mm = tsk->mm;	unsigned long fixup;	siginfo_t info;	/*	 * We fault-in kernel-space virtual memory on-demand. The	 * 'reference' page table is init_mm.pgd.	 *	 * NOTE! We MUST NOT take any locks for this case. We may	 * be in an interrupt or a critical region, and should	 * only copy the information from the master page table,	 * nothing more.	 */	if (address >= VMALLOC_START)		goto vmalloc_fault;	info.si_code = SEGV_MAPERR;	/*	 * If we're in an interrupt or have no user	 * context, we must not take the fault..	 */	if (in_interrupt() || !mm)		goto no_context;#if 0	printk("[%s:%d:%08lx:%ld:%08lx]\n", current->comm, current->pid,	       address, write, regs->cp0_epc);#endif	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;	if (expand_stack(vma, address))		goto bad_area;/* * Ok, we have a good vm_area for this memory access, so * we can handle it.. */good_area:	info.si_code = SEGV_ACCERR;	if (write) {		if (!(vma->vm_flags & VM_WRITE))			goto bad_area;	} else {		if (!(vma->vm_flags & (VM_READ | VM_EXEC)))			goto bad_area;	}survive:	/*	 * If for any reason at all we couldn't handle the fault,	 * make sure we exit gracefully rather than endlessly redo	 * the fault.	 */	switch (handle_mm_fault(mm, vma, address, write)) {	case 1:		tsk->min_flt++;		break;	case 2:		tsk->maj_flt++;		break;	case 0:		goto do_sigbus;	default:		goto out_of_memory;	}	up_read(&mm->mmap_sem);	return;/* * Something tried to access memory that isn't in our memory map.. * Fix it, but check if it's kernel or user first.. */bad_area:	up_read(&mm->mmap_sem);bad_area_nosemaphore:	/* User mode accesses just cause a SIGSEGV */	if (user_mode(regs)) {		tsk->thread.cp0_badvaddr = address;		tsk->thread.error_code = write;#if 0		printk("do_page_fault() #2: sending SIGSEGV to %s for illegal %s\n"		       "%08lx (epc == %08lx, ra == %08lx)\n",		       tsk->comm,		       write ? "write access to" : "read access from",		       address,		       (unsigned long) regs->cp0_epc,		       (unsigned long) regs->regs[31]);#endif		info.si_signo = SIGSEGV;		info.si_errno = 0;		/* info.si_code has been set above */		info.si_addr = (void *) address;		force_sig_info(SIGSEGV, &info, tsk);		return;	}no_context:	/* Are we prepared to handle this kernel fault?  */	fixup = search_exception_table(exception_epc(regs));	if (fixup) {		long new_epc;		tsk->thread.cp0_baduaddr = address;		new_epc = fixup_exception(dpf_reg, fixup, regs->cp0_epc);		if (development_version)			printk(KERN_DEBUG "%s: Exception at [<%lx>] (%lx)\n",			       tsk->comm, regs->cp0_epc, new_epc);		regs->cp0_epc = new_epc;		return;	}	/*	 * Oops. The kernel tried to access some bad page. We'll have to	 * terminate things with extreme prejudice.	 */	printk(KERN_ALERT "Unable to handle kernel paging request at virtual "	       "address %08lx, epc == %08lx, ra == %08lx\n",	       address, regs->cp0_epc, regs->regs[31]);	die("Oops", regs);	/* Game over.  *//* * 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:	if (tsk->pid == 1) {		yield();		goto survive;	}	up_read(&mm->mmap_sem);	printk(KERN_NOTICE "VM: killing process %s\n", tsk->comm);	if (user_mode(regs))		do_exit(SIGKILL);	goto no_context;do_sigbus:	up_read(&mm->mmap_sem);	/*	 * Send a sigbus, regardless of whether we were in kernel	 * or user mode.	 */	tsk->thread.cp0_badvaddr = address;	info.si_signo = SIGBUS;	info.si_errno = 0;	info.si_code = BUS_ADRERR;	info.si_addr = (void *) address;	force_sig_info(SIGBUS, &info, tsk);	/* Kernel mode? Handle exceptions or die */	if (!user_mode(regs))		goto no_context;	return;vmalloc_fault:	{		/*		 * Synchronize this task's top level page-table		 * with the 'reference' page table.		 */		int offset = pgd_index(address);		pgd_t *pgd, *pgd_k;		pmd_t *pmd, *pmd_k;		pgd = tsk->active_mm->pgd + offset;		pgd_k = init_mm.pgd + offset;		if (!pgd_present(*pgd)) {			if (!pgd_present(*pgd_k))				goto bad_area_nosemaphore;			set_pgd(pgd, *pgd_k);			return;		}		pmd = pmd_offset(pgd, address);		pmd_k = pmd_offset(pgd_k, address);		if (pmd_present(*pmd) || !pmd_present(*pmd_k))			goto bad_area_nosemaphore;		set_pmd(pmd, *pmd_k);	}}