if (expand_backing_store(vma, address)) 
/* * Since the register backing store is accessed sequentially, * we disallow growing it by more than a page at a time. */ if (address > vma->vm_end + PAGE_SIZE - sizeof(long)) goto bad_area; if (expand_upwards(vma, address)) 
ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *regs){	int signal = SIGSEGV, code = SEGV_MAPERR;	struct vm_area_struct *vma, *prev_vma;	struct mm_struct *mm = current->mm;	struct siginfo si;	unsigned long mask;	/*	 * If we're in an interrupt or have no user context, we must not take the fault..	 */	if (in_atomic() || !mm)		goto no_context;#ifdef CONFIG_VIRTUAL_MEM_MAP	/*	 * If fault is in region 5 and we are in the kernel, we may already	 * have the mmap_sem (pfn_valid macro is called during mmap). There	 * is no vma for region 5 addr's anyway, so skip getting the semaphore	 * and go directly to the exception handling code.	 */	if ((REGION_NUMBER(address) == 5) && !user_mode(regs))		goto bad_area_no_up;#endif	/*	 * This is to handle the kprobes on user space access instructions	 */	if (notify_die(DIE_PAGE_FAULT, "page fault", regs, code, TRAP_BRKPT,					SIGSEGV) == NOTIFY_STOP)		return;	down_read(&mm->mmap_sem);	vma = find_vma_prev(mm, address, &prev_vma);	if (!vma)		goto bad_area;	/* find_vma_prev() returns vma such that address < vma->vm_end or NULL */	if (address < vma->vm_start)		goto check_expansion;  good_area:	code = SEGV_ACCERR;	/* OK, we've got a good vm_area for this memory area.  Check the access permissions: */#	define VM_READ_BIT	0#	define VM_WRITE_BIT	1#	define VM_EXEC_BIT	2#	if (((1 << VM_READ_BIT) != VM_READ || (1 << VM_WRITE_BIT) != VM_WRITE) \	    || (1 << VM_EXEC_BIT) != VM_EXEC)#		error File is out of sync with <linux/mm.h>.  Please update.#	endif	mask = (  (((isr >> IA64_ISR_X_BIT) & 1UL) << VM_EXEC_BIT)		| (((isr >> IA64_ISR_W_BIT) & 1UL) << VM_WRITE_BIT)		| (((isr >> IA64_ISR_R_BIT) & 1UL) << VM_READ_BIT));	if ((vma->vm_flags & mask) != mask)		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, (mask & VM_WRITE) != 0)) {	      case VM_FAULT_MINOR:		++current->min_flt;		break;	      case VM_FAULT_MAJOR:		++current->maj_flt;		break;	      case VM_FAULT_SIGBUS:		/*		 * We ran out of memory, or some other thing happened		 * to us that made us unable to handle the page fault		 * gracefully.		 */		signal = SIGBUS;		goto bad_area;	      case VM_FAULT_OOM:		goto out_of_memory;	      default:		BUG();	}	up_read(&mm->mmap_sem);	return;  check_expansion:	if (!(prev_vma && (prev_vma->vm_flags & VM_GROWSUP) && (address == prev_vma->vm_end))) {		if (!(vma->vm_flags & VM_GROWSDOWN))			goto bad_area;		if (REGION_NUMBER(address) != REGION_NUMBER(vma->vm_start)		    || REGION_OFFSET(address) >= RGN_MAP_LIMIT)			goto bad_area;		if (expand_stack(vma, address))			goto bad_area;	} else {		vma = prev_vma;		if (REGION_NUMBER(address) != REGION_NUMBER(vma->vm_start)		    || REGION_OFFSET(address) >= RGN_MAP_LIMIT)			goto bad_area;		if (expand_backing_store(vma, address))			goto bad_area;	}	goto good_area;  bad_area:	up_read(&mm->mmap_sem);#ifdef CONFIG_VIRTUAL_MEM_MAP  bad_area_no_up:#endif	if ((isr & IA64_ISR_SP)	    || ((isr & IA64_ISR_NA) && (isr & IA64_ISR_CODE_MASK) == IA64_ISR_CODE_LFETCH))	{		/*		 * This fault was due to a speculative load or lfetch.fault, set the "ed"		 * bit in the psr to ensure forward progress.  (Target register will get a		 * NaT for ld.s, lfetch will be canceled.)		 */		ia64_psr(regs)->ed = 1;		return;	}	if (user_mode(regs)) {		si.si_signo = signal;		si.si_errno = 0;		si.si_code = code;		si.si_addr = (void __user *) address;		si.si_isr = isr;		si.si_flags = __ISR_VALID;		force_sig_info(signal, &si, current);		return;	}  no_context:	if ((isr & IA64_ISR_SP)	    || ((isr & IA64_ISR_NA) && (isr & IA64_ISR_CODE_MASK) == IA64_ISR_CODE_LFETCH))	{		/*		 * This fault was due to a speculative load or lfetch.fault, set the "ed"		 * bit in the psr to ensure forward progress.  (Target register will get a		 * NaT for ld.s, lfetch will be canceled.)		 */		ia64_psr(regs)->ed = 1;		return;	}	/*	 * Since we have no vma's for region 5, we might get here even if the address is	 * valid, due to the VHPT walker inserting a non present translation that becomes	 * stale. If that happens, the non present fault handler already purged the stale	 * translation, which fixed the problem. So, we check to see if the translation is	 * valid, and return if it is.	 */	if (REGION_NUMBER(address) == 5 && mapped_kernel_page_is_present(address))		return;	if (ia64_done_with_exception(regs))		return;	/*	 * Oops. The kernel tried to access some bad page. We'll have to terminate things	 * with extreme prejudice.	 */	bust_spinlocks(1);	if (address < PAGE_SIZE)		printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference (address %016lx)\n", address);	else		printk(KERN_ALERT "Unable to handle kernel paging request at "		       "virtual address %016lx\n", address);	die("Oops", regs, isr);	bust_spinlocks(0);	do_exit(SIGKILL);	return;  out_of_memory:	up_read(&mm->mmap_sem);	if (current->pid == 1) {		yield();		down_read(&mm->mmap_sem);		goto survive;	}	printk(KERN_CRIT "VM: killing process %s\n", current->comm);	if (user_mode(regs))		do_exit(SIGKILL);	goto no_context;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/46dea3d092d23a58b42499cc8a21de0fad079f4a/fault.c/buggy/arch/ia64/mm/fault.c