info.si_signo = SIGSEGV; info.si_errno = 0; info.si_code = code; info.si_addr = (void __user *) address; force_sig_info(SIGSEGV, &info, current); 
_exception(SIGSEGV, regs, code, address); 
int 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;#if defined(CONFIG_4xx) || defined (CONFIG_BOOKE)	int is_write = error_code & ESR_DST;#else	int is_write = 0;	/*	 * 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(regs) == 0x400)		error_code &= 0x48200000;	else		is_write = error_code & 0x02000000;#endif /* CONFIG_4xx || CONFIG_BOOKE */#if defined(CONFIG_XMON) || defined(CONFIG_KGDB)	if (debugger_fault_handler && TRAP(regs) == 0x300) {		debugger_fault_handler(regs);		return 0;	}#if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))	if (error_code & 0x00400000) {		/* DABR match */		if (debugger_dabr_match(regs))			return 0;	}#endif /* !(CONFIG_4xx || CONFIG_BOOKE)*/#endif /* CONFIG_XMON || CONFIG_KGDB */	if (in_atomic() || mm == NULL)		return SIGSEGV;	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 (!is_write)                goto bad_area;	/*	 * N.B. The rs6000/xcoff ABI allows programs to access up to	 * a few hundred 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 */	/* a write */	if (is_write) {		if (!(vma->vm_flags & VM_WRITE))			goto bad_area;#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)	/* an exec  - 4xx/Book-E allows for per-page execute permission */	} else if (TRAP(regs) == 0x400) {		pte_t *ptep;#if 0		/* It would be nice to actually enforce the VM execute		   permission on CPUs which can do so, but far too		   much stuff in userspace doesn't get the permissions		   right, so we let any page be executed for now. */		if (! (vma->vm_flags & VM_EXEC))			goto bad_area;#endif		/* Since 4xx/Book-E supports per-page execute permission,		 * we lazily flush dcache to icache. */		ptep = NULL;		if (get_pteptr(mm, address, &ptep) && pte_present(*ptep)) {			struct page *page = pte_page(*ptep);			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(ptep);			up_read(&mm->mmap_sem);			return 0;		}		if (ptep != NULL)			pte_unmap(ptep);#endif	/* a read */	} else {		/* protection fault */		if (error_code & 0x08000000)			goto bad_area;		if (!(vma->vm_flags & (VM_READ | VM_EXEC)))			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);	/*	 * keep track of tlb+htab misses that are good addrs but	 * just need pte's created via handle_mm_fault()	 * -- Cort	 */	pte_misses++;	return 0;bad_area:	up_read(&mm->mmap_sem);	pte_errors++;	/* User mode accesses cause a SIGSEGV */	if (user_mode(regs)) {		info.si_signo = SIGSEGV;		info.si_errno = 0;		info.si_code = code;		info.si_addr = (void __user *) address;		force_sig_info(SIGSEGV, &info, current);		return 0;	}	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);	if (current->pid == 1) {		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);	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);	if (!user_mode(regs))		return SIGBUS;	return 0;}
10457	/local/tlutelli/issta_data/temp/c/2005_temp/2005/10457/bb0bb3b6596cdb08adb0b72453cc67d48e139c2c/fault.c/clean/arch/ppc/mm/fault.c