sc.may_swap = 1; 
static int balance_pgdat(pg_data_t *pgdat, int nr_pages, int order){	int to_free = nr_pages;	int all_zones_ok;	int priority;	int i;	int total_scanned, total_reclaimed;	struct reclaim_state *reclaim_state = current->reclaim_state;	struct scan_control sc;loop_again:	total_scanned = 0;	total_reclaimed = 0;	sc.gfp_mask = GFP_KERNEL;	sc.may_writepage = 0;	sc.nr_mapped = read_page_state(nr_mapped);	inc_page_state(pageoutrun);	for (i = 0; i < pgdat->nr_zones; i++) {		struct zone *zone = pgdat->node_zones + i;		zone->temp_priority = DEF_PRIORITY;	}	for (priority = DEF_PRIORITY; priority >= 0; priority--) {		int end_zone = 0;	/* Inclusive.  0 = ZONE_DMA */		unsigned long lru_pages = 0;		all_zones_ok = 1;		if (nr_pages == 0) {			/*			 * Scan in the highmem->dma direction for the highest			 * zone which needs scanning			 */			for (i = pgdat->nr_zones - 1; i >= 0; i--) {				struct zone *zone = pgdat->node_zones + i;				if (zone->present_pages == 0)					continue;				if (zone->all_unreclaimable &&						priority != DEF_PRIORITY)					continue;				if (!zone_watermark_ok(zone, order,						zone->pages_high, 0, 0, 0)) {					end_zone = i;					goto scan;				}			}			goto out;		} else {			end_zone = pgdat->nr_zones - 1;		}scan:		for (i = 0; i <= end_zone; i++) {			struct zone *zone = pgdat->node_zones + i;			lru_pages += zone->nr_active + zone->nr_inactive;		}		/*		 * Now scan the zone in the dma->highmem direction, stopping		 * at the last zone which needs scanning.		 *		 * We do this because the page allocator works in the opposite		 * direction.  This prevents the page allocator from allocating		 * pages behind kswapd's direction of progress, which would		 * cause too much scanning of the lower zones.		 */		for (i = 0; i <= end_zone; i++) {			struct zone *zone = pgdat->node_zones + i;			int nr_slab;			if (zone->present_pages == 0)				continue;			if (zone->all_unreclaimable && priority != DEF_PRIORITY)				continue;			if (nr_pages == 0) {	/* Not software suspend */				if (!zone_watermark_ok(zone, order,						zone->pages_high, end_zone, 0, 0))					all_zones_ok = 0;			}			zone->temp_priority = priority;			if (zone->prev_priority > priority)				zone->prev_priority = priority;			sc.nr_scanned = 0;			sc.nr_reclaimed = 0;			sc.priority = priority;			sc.swap_cluster_max = nr_pages? nr_pages : SWAP_CLUSTER_MAX;			shrink_zone(zone, &sc);			reclaim_state->reclaimed_slab = 0;			nr_slab = shrink_slab(sc.nr_scanned, GFP_KERNEL,						lru_pages);			sc.nr_reclaimed += reclaim_state->reclaimed_slab;			total_reclaimed += sc.nr_reclaimed;			total_scanned += sc.nr_scanned;			if (zone->all_unreclaimable)				continue;			if (nr_slab == 0 && zone->pages_scanned >=				    (zone->nr_active + zone->nr_inactive) * 4)				zone->all_unreclaimable = 1;			/*			 * If we've done a decent amount of scanning and			 * the reclaim ratio is low, start doing writepage			 * even in laptop mode			 */			if (total_scanned > SWAP_CLUSTER_MAX * 2 &&			    total_scanned > total_reclaimed+total_reclaimed/2)				sc.may_writepage = 1;		}		if (nr_pages && to_free > total_reclaimed)			continue;	/* swsusp: need to do more work */		if (all_zones_ok)			break;		/* kswapd: all done */		/*		 * OK, kswapd is getting into trouble.  Take a nap, then take		 * another pass across the zones.		 */		if (total_scanned && priority < DEF_PRIORITY - 2)			blk_congestion_wait(WRITE, HZ/10);		/*		 * We do this so kswapd doesn't build up large priorities for		 * example when it is freeing in parallel with allocators. It		 * matches the direct reclaim path behaviour in terms of impact		 * on zone->*_priority.		 */		if ((total_reclaimed >= SWAP_CLUSTER_MAX) && (!nr_pages))			break;	}out:	for (i = 0; i < pgdat->nr_zones; i++) {		struct zone *zone = pgdat->node_zones + i;		zone->prev_priority = zone->temp_priority;	}	if (!all_zones_ok) {		cond_resched();		goto loop_again;	}	return total_reclaimed;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/bfbb38fb808ac23ef44472d05d9bb36edfb49ed0/vmscan.c/clean/mm/vmscan.c