/* *  arch/s390/mm/fault.c * *  S390 version *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation *    Author(s): Hartmut Penner (hp@de.ibm.com) *               Ulrich Weigand (uweigand@de.ibm.com) * *  Derived from "arch/i386/mm/fault.c" *    Copyright (C) 1995  Linus Torvalds */#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/smp.h>#include <linux/smp_lock.h>#include <linux/compatmac.h>#include <linux/init.h>#include <linux/console.h>#include <asm/system.h>#include <asm/uaccess.h>#include <asm/pgtable.h>#include <asm/hardirq.h>#ifdef CONFIG_SYSCTLextern int sysctl_userprocess_debug;#endifextern void die(const char *,struct pt_regs *,long);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;	} else {		int loglevel_save = console_loglevel;		oops_in_progress = 0;		console_unblank();		/*		 * 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;		printk(" ");		console_loglevel = loglevel_save;	}}/* * Check which address space is addressed by the access * register in S390_lowcore.exc_access_id. * Returns 1 for user space and 0 for kernel space. */static int __check_access_register(struct pt_regs *regs, int error_code){	int areg = S390_lowcore.exc_access_id;	if (areg == 0)		/* Access via access register 0 -> kernel address */		return 0;	if (regs && areg < NUM_ACRS && regs->acrs[areg] <= 1)		/*		 * access register contains 0 -> kernel address,		 * access register contains 1 -> user space address		 */		return regs->acrs[areg];	/* Something unhealthy was done with the access registers... */	die("page fault via unknown access register", regs, error_code);	do_exit(SIGKILL);	return 0;}/* * Check which address space the address belongs to. * Returns 1 for user space and 0 for kernel space. */static inline int check_user_space(struct pt_regs *regs, int error_code){	/*	 * The lowest two bits of S390_lowcore.trans_exc_code indicate	 * which paging table was used:	 *   0: Primary Segment Table Descriptor	 *   1: STD determined via access register	 *   2: Secondary Segment Table Descriptor	 *   3: Home Segment Table Descriptor	 */	int descriptor = S390_lowcore.trans_exc_code & 3;	if (descriptor == 1)		return __check_access_register(regs, error_code);	return descriptor >> 1;}/* * Send SIGSEGV to task.  This is an external routine * to keep the stack usage of do_page_fault small. */static void force_sigsegv(struct pt_regs *regs, unsigned long error_code,			  int si_code, unsigned long address){	struct siginfo si;#if defined(CONFIG_SYSCTL) || defined(CONFIG_PROCESS_DEBUG)#if defined(CONFIG_SYSCTL)	if (sysctl_userprocess_debug)#endif	{		printk("User process fault: interruption code 0x%lX\n",		       error_code);		printk("failing address: %lX\n", address);		show_regs(regs);	}#endif	si.si_signo = SIGSEGV;	si.si_code = si_code;	si.si_addr = (void *) address;	force_sig_info(SIGSEGV, &si, current);}/* * This routine handles page faults.  It determines the address, * and the problem, and then passes it off to one of the appropriate * routines. * * error_code: *   04       Protection           ->  Write-Protection  (suprression) *   10       Segment translation  ->  Not present       (nullification) *   11       Page translation     ->  Not present       (nullification) */extern inline void do_exception(struct pt_regs *regs, unsigned long error_code){        struct task_struct *tsk;        struct mm_struct *mm;        struct vm_area_struct * vma;        unsigned long address;	int user_address;        unsigned long fixup;	int si_code = SEGV_MAPERR;        tsk = current;        mm = tsk->mm;		/*          * Check for low-address protection.  This needs to be treated	 * as a special case because the translation exception code 	 * field is not guaranteed to contain valid data in this case.	 */	if (error_code == 4 && !(S390_lowcore.trans_exc_code & 4)) {		/* Low-address protection hit in kernel mode means 		   NULL pointer write access in kernel mode.  */ 		if (!(regs->psw.mask & PSW_PROBLEM_STATE)) {			address = 0;			user_address = 0;			goto no_context;		}		/* Low-address protection hit in user mode 'cannot happen'.  */		die ("Low-address protection", regs, error_code);        	do_exit(SIGKILL);	}        /*          * get the failing address          * more specific the segment and page table portion of          * the address          */        address = S390_lowcore.trans_exc_code&0x7ffff000;	user_address = check_user_space(regs, error_code);	/*	 * Verify that the fault happened in user space, that	 * we are not in an interrupt and that there is a 	 * user context.	 */        if (user_address == 0 || in_interrupt() || !mm)                goto no_context;	/*	 * When we get here, the fault happened in the current	 * task's user address space, so we can switch on the	 * interrupts again and then search the VMAs	 */	__sti();        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:	si_code = SEGV_ACCERR;	if (error_code != 4) {		/* page not present, check vm flags */		if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))			goto bad_area;	} else {		if (!(vma->vm_flags & VM_WRITE))			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, error_code == 4)) {	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);        /* User mode accesses just cause a SIGSEGV */        if (regs->psw.mask & PSW_PROBLEM_STATE) {                tsk->thread.prot_addr = address;                tsk->thread.trap_no = error_code;		force_sigsegv(regs, error_code, si_code, address);                return;	}no_context:        /* Are we prepared to handle this kernel fault?  */        if ((fixup = search_exception_table(regs->psw.addr)) != 0) {                regs->psw.addr = fixup;                return;        }/* * Oops. The kernel tried to access some bad page. We'll have to * terminate things with extreme prejudice. */        if (user_address == 0)                printk(KERN_ALERT "Unable to handle kernel pointer dereference"        	       " at virtual kernel address %08lx\n", address);        else                printk(KERN_ALERT "Unable to handle kernel paging request"		       " at virtual user address %08lx\n", address);