pte_unmap(page_table); 
do_no_page(struct mm_struct *mm, struct vm_area_struct *vma,	unsigned long address, int write_access, pte_t *page_table, pmd_t *pmd){	struct page * new_page;	struct address_space *mapping = NULL;	pte_t entry;	unsigned int sequence = 0;	int ret = VM_FAULT_MINOR;	int anon = 0;	if (!vma->vm_ops || !vma->vm_ops->nopage)		return do_anonymous_page(mm, vma, page_table,					pmd, write_access, address);	pte_unmap(page_table);	spin_unlock(&mm->page_table_lock);	if (vma->vm_file) {		mapping = vma->vm_file->f_mapping;		sequence = mapping->truncate_count;		smp_rmb(); /* serializes i_size against truncate_count */	}retry:	cond_resched();	new_page = vma->vm_ops->nopage(vma, address & PAGE_MASK, &ret);	/*	 * No smp_rmb is needed here as long as there's a full	 * spin_lock/unlock sequence inside the ->nopage callback	 * (for the pagecache lookup) that acts as an implicit	 * smp_mb() and prevents the i_size read to happen	 * after the next truncate_count read.	 */	/* no page was available -- either SIGBUS or OOM */	if (new_page == NOPAGE_SIGBUS)		return VM_FAULT_SIGBUS;	if (new_page == NOPAGE_OOM)		return VM_FAULT_OOM;	/*	 * Should we do an early C-O-W break?	 */	if (write_access && !(vma->vm_flags & VM_SHARED)) {		struct page *page;		if (unlikely(anon_vma_prepare(vma)))			goto oom;		page = alloc_page_vma(GFP_HIGHUSER, vma, address);		if (!page)			goto oom;		copy_user_highpage(page, new_page, address);		page_cache_release(new_page);		new_page = page;		anon = 1;	}	spin_lock(&mm->page_table_lock);	/*	 * For a file-backed vma, someone could have truncated or otherwise	 * invalidated this page.  If unmap_mapping_range got called,	 * retry getting the page.	 */	if (mapping && unlikely(sequence != mapping->truncate_count)) {		sequence = mapping->truncate_count;		spin_unlock(&mm->page_table_lock);		page_cache_release(new_page);		goto retry;	}	page_table = pte_offset_map(pmd, address);	/*	 * This silly early PAGE_DIRTY setting removes a race	 * due to the bad i386 page protection. But it's valid	 * for other architectures too.	 *	 * Note that if write_access is true, we either now have	 * an exclusive copy of the page, or this is a shared mapping,	 * so we can make it writable and dirty to avoid having to	 * handle that later.	 */	/* Only go through if we didn't race with anybody else... */	if (pte_none(*page_table)) {		if (!PageReserved(new_page))			inc_mm_counter(mm, rss);		flush_icache_page(vma, new_page);		entry = mk_pte(new_page, vma->vm_page_prot);		if (write_access)			entry = maybe_mkwrite(pte_mkdirty(entry), vma);		set_pte_at(mm, address, page_table, entry);		if (anon) {			lru_cache_add_active(new_page);			page_add_anon_rmap(new_page, vma, address);		} else			page_add_file_rmap(new_page);		pte_unmap(page_table);	} else {		/* One of our sibling threads was faster, back out. */		pte_unmap(page_table);		page_cache_release(new_page);		spin_unlock(&mm->page_table_lock);		goto out;	}	/* no need to invalidate: a not-present page shouldn't be cached */	update_mmu_cache(vma, address, entry);	lazy_mmu_prot_update(entry);	spin_unlock(&mm->page_table_lock);out:	return ret;oom:	page_cache_release(new_page);	ret = VM_FAULT_OOM;	goto out;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/65500d234e74fc4e8f18e1a429bc24e51e75de4a/memory.c/buggy/mm/memory.c