swp_entry_t swap = { .val = page->private }; 
swp_entry_t swap = { .val = page_private(page) }; 
static int shrink_list(struct list_head *page_list, struct scan_control *sc){	LIST_HEAD(ret_pages);	struct pagevec freed_pvec;	int pgactivate = 0;	int reclaimed = 0;	cond_resched();	pagevec_init(&freed_pvec, 1);	while (!list_empty(page_list)) {		struct address_space *mapping;		struct page *page;		int may_enter_fs;		int referenced;		cond_resched();		page = lru_to_page(page_list);		list_del(&page->lru);		if (TestSetPageLocked(page))			goto keep;		BUG_ON(PageActive(page));		sc->nr_scanned++;		/* Double the slab pressure for mapped and swapcache pages */		if (page_mapped(page) || PageSwapCache(page))			sc->nr_scanned++;		if (PageWriteback(page))			goto keep_locked;		referenced = page_referenced(page, 1, sc->priority <= 0);		/* In active use or really unfreeable?  Activate it. */		if (referenced && page_mapping_inuse(page))			goto activate_locked;#ifdef CONFIG_SWAP		/*		 * Anonymous process memory has backing store?		 * Try to allocate it some swap space here.		 */		if (PageAnon(page) && !PageSwapCache(page)) {			if (!sc->may_swap)				goto keep_locked;			if (!add_to_swap(page))				goto activate_locked;		}#endif /* CONFIG_SWAP */		mapping = page_mapping(page);		may_enter_fs = (sc->gfp_mask & __GFP_FS) ||			(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));		/*		 * The page is mapped into the page tables of one or more		 * processes. Try to unmap it here.		 */		if (page_mapped(page) && mapping) {			switch (try_to_unmap(page)) {			case SWAP_FAIL:				goto activate_locked;			case SWAP_AGAIN:				goto keep_locked;			case SWAP_SUCCESS:				; /* try to free the page below */			}		}		if (PageDirty(page)) {			if (referenced)				goto keep_locked;			if (!may_enter_fs)				goto keep_locked;			if (laptop_mode && !sc->may_writepage)				goto keep_locked;			/* Page is dirty, try to write it out here */			switch(pageout(page, mapping)) {			case PAGE_KEEP:				goto keep_locked;			case PAGE_ACTIVATE:				goto activate_locked;			case PAGE_SUCCESS:				if (PageWriteback(page) || PageDirty(page))					goto keep;				/*				 * A synchronous write - probably a ramdisk.  Go				 * ahead and try to reclaim the page.				 */				if (TestSetPageLocked(page))					goto keep;				if (PageDirty(page) || PageWriteback(page))					goto keep_locked;				mapping = page_mapping(page);			case PAGE_CLEAN:				; /* try to free the page below */			}		}		/*		 * If the page has buffers, try to free the buffer mappings		 * associated with this page. If we succeed we try to free		 * the page as well.		 *		 * We do this even if the page is PageDirty().		 * try_to_release_page() does not perform I/O, but it is		 * possible for a page to have PageDirty set, but it is actually		 * clean (all its buffers are clean).  This happens if the		 * buffers were written out directly, with submit_bh(). ext3		 * will do this, as well as the blockdev mapping. 		 * try_to_release_page() will discover that cleanness and will		 * drop the buffers and mark the page clean - it can be freed.		 *		 * Rarely, pages can have buffers and no ->mapping.  These are		 * the pages which were not successfully invalidated in		 * truncate_complete_page().  We try to drop those buffers here		 * and if that worked, and the page is no longer mapped into		 * process address space (page_count == 1) it can be freed.		 * Otherwise, leave the page on the LRU so it is swappable.		 */		if (PagePrivate(page)) {			if (!try_to_release_page(page, sc->gfp_mask))				goto activate_locked;			if (!mapping && page_count(page) == 1)				goto free_it;		}		if (!mapping)			goto keep_locked;	/* truncate got there first */		write_lock_irq(&mapping->tree_lock);		/*		 * The non-racy check for busy page.  It is critical to check		 * PageDirty _after_ making sure that the page is freeable and		 * not in use by anybody. 	(pagecache + us == 2)		 */		if (unlikely(page_count(page) != 2))			goto cannot_free;		smp_rmb();		if (unlikely(PageDirty(page)))			goto cannot_free;#ifdef CONFIG_SWAP		if (PageSwapCache(page)) {			swp_entry_t swap = { .val = page->private };			__delete_from_swap_cache(page);			write_unlock_irq(&mapping->tree_lock);			swap_free(swap);			__put_page(page);	/* The pagecache ref */			goto free_it;		}#endif /* CONFIG_SWAP */		__remove_from_page_cache(page);		write_unlock_irq(&mapping->tree_lock);		__put_page(page);free_it:		unlock_page(page);		reclaimed++;		if (!pagevec_add(&freed_pvec, page))			__pagevec_release_nonlru(&freed_pvec);		continue;cannot_free:		write_unlock_irq(&mapping->tree_lock);		goto keep_locked;activate_locked:		SetPageActive(page);		pgactivate++;keep_locked:		unlock_page(page);keep:		list_add(&page->lru, &ret_pages);		BUG_ON(PageLRU(page));	}	list_splice(&ret_pages, page_list);	if (pagevec_count(&freed_pvec))		__pagevec_release_nonlru(&freed_pvec);	mod_page_state(pgactivate, pgactivate);	sc->nr_reclaimed += reclaimed;	return reclaimed;}
10457	/local/tlutelli/issta_data/temp/c/2005_temp/2005/10457/4c21e2f2441dc5fbb957b030333f5a3f2d02dea7/vmscan.c/buggy/mm/vmscan.c