/*
   *  linux/mm/vmscan.c
   *
   *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
   *
   *  Swap reorganised 29.12.95, Stephen Tweedie.
   *  kswapd added: 7.1.96  sct
   *  Removed kswapd_ctl limits, and swap out as many pages as needed
   *  to bring the system back to freepages.high: 2.4.97, Rik van Riel.
   *  Zone aware kswapd started 02/00, Kanoj Sarcar (kanoj@sgi.com).
   *  Multiqueue VM started 5.8.00, Rik van Riel.
   */
  
  #include <linux/mm.h>
  #include <linux/module.h>
  #include <linux/slab.h>
  #include <linux/kernel_stat.h>
  #include <linux/swap.h>
  #include <linux/pagemap.h>
  #include <linux/init.h>
  #include <linux/highmem.h>

  #include <linux/vmstat.h>

  #include <linux/file.h>
  #include <linux/writeback.h>
  #include <linux/blkdev.h>
  #include <linux/buffer_head.h>	/* for try_to_release_page(),
  					buffer_heads_over_limit */
  #include <linux/mm_inline.h>
  #include <linux/pagevec.h>
  #include <linux/backing-dev.h>
  #include <linux/rmap.h>
  #include <linux/topology.h>
  #include <linux/cpu.h>
  #include <linux/cpuset.h>
  #include <linux/notifier.h>
  #include <linux/rwsem.h>

  #include <linux/delay.h>

  #include <linux/kthread.h>

  
  #include <asm/tlbflush.h>
  #include <asm/div64.h>
  
  #include <linux/swapops.h>

  #include "internal.h"

  struct scan_control {

  	/* Incremented by the number of inactive pages that were scanned */
  	unsigned long nr_scanned;

  	/* This context's GFP mask */

  	gfp_t gfp_mask;

  
  	int may_writepage;

  	/* Can pages be swapped as part of reclaim? */
  	int may_swap;

  	/* This context's SWAP_CLUSTER_MAX. If freeing memory for
  	 * suspend, we effectively ignore SWAP_CLUSTER_MAX.
  	 * In this context, it doesn't matter that we scan the
  	 * whole list at once. */
  	int swap_cluster_max;

  
  	int swappiness;

  
  	int all_unreclaimable;

  };
  
  /*
   * The list of shrinker callbacks used by to apply pressure to
   * ageable caches.
   */
  struct shrinker {
  	shrinker_t		shrinker;
  	struct list_head	list;
  	int			seeks;	/* seeks to recreate an obj */
  	long			nr;	/* objs pending delete */
  };
  
  #define lru_to_page(_head) (list_entry((_head)->prev, struct page, lru))
  
  #ifdef ARCH_HAS_PREFETCH
  #define prefetch_prev_lru_page(_page, _base, _field)			\
  	do {								\
  		if ((_page)->lru.prev != _base) {			\
  			struct page *prev;				\
  									\
  			prev = lru_to_page(&(_page->lru));		\
  			prefetch(&prev->_field);			\
  		}							\
  	} while (0)
  #else
  #define prefetch_prev_lru_page(_page, _base, _field) do { } while (0)
  #endif
  
  #ifdef ARCH_HAS_PREFETCHW
  #define prefetchw_prev_lru_page(_page, _base, _field)			\
  	do {								\
  		if ((_page)->lru.prev != _base) {			\
  			struct page *prev;				\
  									\
  			prev = lru_to_page(&(_page->lru));		\
  			prefetchw(&prev->_field);			\
  		}							\
  	} while (0)
  #else
  #define prefetchw_prev_lru_page(_page, _base, _field) do { } while (0)
  #endif
  
  /*
   * From 0 .. 100.  Higher means more swappy.
   */
  int vm_swappiness = 60;

  long vm_total_pages;	/* The total number of pages which the VM controls */

  
  static LIST_HEAD(shrinker_list);
  static DECLARE_RWSEM(shrinker_rwsem);
  
  /*
   * Add a shrinker callback to be called from the vm
   */
  struct shrinker *set_shrinker(int seeks, shrinker_t theshrinker)
  {
          struct shrinker *shrinker;
  
          shrinker = kmalloc(sizeof(*shrinker), GFP_KERNEL);
          if (shrinker) {
  	        shrinker->shrinker = theshrinker;
  	        shrinker->seeks = seeks;
  	        shrinker->nr = 0;
  	        down_write(&shrinker_rwsem);
  	        list_add_tail(&shrinker->list, &shrinker_list);
  	        up_write(&shrinker_rwsem);
  	}
  	return shrinker;
  }
  EXPORT_SYMBOL(set_shrinker);
  
  /*
   * Remove one
   */
  void remove_shrinker(struct shrinker *shrinker)
  {
  	down_write(&shrinker_rwsem);
  	list_del(&shrinker->list);
  	up_write(&shrinker_rwsem);
  	kfree(shrinker);
  }
  EXPORT_SYMBOL(remove_shrinker);
  
  #define SHRINK_BATCH 128
  /*
   * Call the shrink functions to age shrinkable caches
   *
   * Here we assume it costs one seek to replace a lru page and that it also
   * takes a seek to recreate a cache object.  With this in mind we age equal
   * percentages of the lru and ageable caches.  This should balance the seeks
   * generated by these structures.
   *
   * If the vm encounted mapped pages on the LRU it increase the pressure on
   * slab to avoid swapping.
   *
   * We do weird things to avoid (scanned*seeks*entries) overflowing 32 bits.
   *
   * `lru_pages' represents the number of on-LRU pages in all the zones which
   * are eligible for the caller's allocation attempt.  It is used for balancing
   * slab reclaim versus page reclaim.

   *
   * Returns the number of slab objects which we shrunk.

   */

  unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
  			unsigned long lru_pages)

  {
  	struct shrinker *shrinker;

  	unsigned long ret = 0;

  
  	if (scanned == 0)
  		scanned = SWAP_CLUSTER_MAX;
  
  	if (!down_read_trylock(&shrinker_rwsem))

  		return 1;	/* Assume we'll be able to shrink next time */

  
  	list_for_each_entry(shrinker, &shrinker_list, list) {
  		unsigned long long delta;
  		unsigned long total_scan;

  		unsigned long max_pass = (*shrinker->shrinker)(0, gfp_mask);

  
  		delta = (4 * scanned) / shrinker->seeks;

  		delta *= max_pass;

  		do_div(delta, lru_pages + 1);
  		shrinker->nr += delta;

  		if (shrinker->nr < 0) {
  			printk(KERN_ERR "%s: nr=%ld
  ",
  					__FUNCTION__, shrinker->nr);
  			shrinker->nr = max_pass;
  		}
  
  		/*
  		 * Avoid risking looping forever due to too large nr value:
  		 * never try to free more than twice the estimate number of
  		 * freeable entries.
  		 */
  		if (shrinker->nr > max_pass * 2)
  			shrinker->nr = max_pass * 2;

  
  		total_scan = shrinker->nr;
  		shrinker->nr = 0;
  
  		while (total_scan >= SHRINK_BATCH) {
  			long this_scan = SHRINK_BATCH;
  			int shrink_ret;

  			int nr_before;

  			nr_before = (*shrinker->shrinker)(0, gfp_mask);

  			shrink_ret = (*shrinker->shrinker)(this_scan, gfp_mask);
  			if (shrink_ret == -1)
  				break;

  			if (shrink_ret < nr_before)
  				ret += nr_before - shrink_ret;

  			count_vm_events(SLABS_SCANNED, this_scan);

  			total_scan -= this_scan;
  
  			cond_resched();
  		}
  
  		shrinker->nr += total_scan;
  	}
  	up_read(&shrinker_rwsem);

  	return ret;

  }
  
  /* Called without lock on whether page is mapped, so answer is unstable */
  static inline int page_mapping_inuse(struct page *page)
  {
  	struct address_space *mapping;
  
  	/* Page is in somebody's page tables. */
  	if (page_mapped(page))
  		return 1;
  
  	/* Be more reluctant to reclaim swapcache than pagecache */
  	if (PageSwapCache(page))
  		return 1;
  
  	mapping = page_mapping(page);
  	if (!mapping)
  		return 0;
  
  	/* File is mmap'd by somebody? */
  	return mapping_mapped(mapping);
  }
  
  static inline int is_page_cache_freeable(struct page *page)
  {
  	return page_count(page) - !!PagePrivate(page) == 2;
  }
  
  static int may_write_to_queue(struct backing_dev_info *bdi)
  {

  	if (current->flags & PF_SWAPWRITE)

  		return 1;
  	if (!bdi_write_congested(bdi))
  		return 1;
  	if (bdi == current->backing_dev_info)
  		return 1;
  	return 0;
  }
  
  /*
   * We detected a synchronous write error writing a page out.  Probably
   * -ENOSPC.  We need to propagate that into the address_space for a subsequent
   * fsync(), msync() or close().
   *
   * The tricky part is that after writepage we cannot touch the mapping: nothing
   * prevents it from being freed up.  But we have a ref on the page and once
   * that page is locked, the mapping is pinned.
   *
   * We're allowed to run sleeping lock_page() here because we know the caller has
   * __GFP_FS.
   */
  static void handle_write_error(struct address_space *mapping,
  				struct page *page, int error)
  {
  	lock_page(page);
  	if (page_mapping(page) == mapping) {
  		if (error == -ENOSPC)
  			set_bit(AS_ENOSPC, &mapping->flags);
  		else
  			set_bit(AS_EIO, &mapping->flags);
  	}
  	unlock_page(page);
  }

  /* possible outcome of pageout() */
  typedef enum {
  	/* failed to write page out, page is locked */
  	PAGE_KEEP,
  	/* move page to the active list, page is locked */
  	PAGE_ACTIVATE,
  	/* page has been sent to the disk successfully, page is unlocked */
  	PAGE_SUCCESS,
  	/* page is clean and locked */
  	PAGE_CLEAN,
  } pageout_t;

  /*

   * pageout is called by shrink_page_list() for each dirty page.
   * Calls ->writepage().

   */

  static pageout_t pageout(struct page *page, struct address_space *mapping)

  {
  	/*
  	 * If the page is dirty, only perform writeback if that write
  	 * will be non-blocking.  To prevent this allocation from being
  	 * stalled by pagecache activity.  But note that there may be
  	 * stalls if we need to run get_block().  We could test
  	 * PagePrivate for that.
  	 *
  	 * If this process is currently in generic_file_write() against
  	 * this page's queue, we can perform writeback even if that
  	 * will block.
  	 *
  	 * If the page is swapcache, write it back even if that would
  	 * block, for some throttling. This happens by accident, because
  	 * swap_backing_dev_info is bust: it doesn't reflect the
  	 * congestion state of the swapdevs.  Easy to fix, if needed.
  	 * See swapfile.c:page_queue_congested().
  	 */
  	if (!is_page_cache_freeable(page))
  		return PAGE_KEEP;
  	if (!mapping) {
  		/*
  		 * Some data journaling orphaned pages can have
  		 * page->mapping == NULL while being dirty with clean buffers.
  		 */

  		if (PagePrivate(page)) {

  			if (try_to_free_buffers(page)) {
  				ClearPageDirty(page);
  				printk("%s: orphaned page
  ", __FUNCTION__);
  				return PAGE_CLEAN;
  			}
  		}
  		return PAGE_KEEP;
  	}
  	if (mapping->a_ops->writepage == NULL)
  		return PAGE_ACTIVATE;
  	if (!may_write_to_queue(mapping->backing_dev_info))
  		return PAGE_KEEP;
  
  	if (clear_page_dirty_for_io(page)) {
  		int res;
  		struct writeback_control wbc = {
  			.sync_mode = WB_SYNC_NONE,
  			.nr_to_write = SWAP_CLUSTER_MAX,

  			.range_start = 0,
  			.range_end = LLONG_MAX,

  			.nonblocking = 1,
  			.for_reclaim = 1,
  		};
  
  		SetPageReclaim(page);
  		res = mapping->a_ops->writepage(page, &wbc);
  		if (res < 0)
  			handle_write_error(mapping, page, res);

  		if (res == AOP_WRITEPAGE_ACTIVATE) {

  			ClearPageReclaim(page);
  			return PAGE_ACTIVATE;
  		}
  		if (!PageWriteback(page)) {
  			/* synchronous write or broken a_ops? */
  			ClearPageReclaim(page);
  		}

  		inc_zone_page_state(page, NR_VMSCAN_WRITE);

  		return PAGE_SUCCESS;
  	}
  
  	return PAGE_CLEAN;
  }

  int remove_mapping(struct address_space *mapping, struct page *page)

  {

  	BUG_ON(!PageLocked(page));
  	BUG_ON(mapping != page_mapping(page));

  
  	write_lock_irq(&mapping->tree_lock);

  	/*

  	 * The non racy check for a busy page.
  	 *
  	 * Must be careful with the order of the tests. When someone has
  	 * a ref to the page, it may be possible that they dirty it then
  	 * drop the reference. So if PageDirty is tested before page_count
  	 * here, then the following race may occur:
  	 *
  	 * get_user_pages(&page);
  	 * [user mapping goes away]
  	 * write_to(page);
  	 *				!PageDirty(page)    [good]
  	 * SetPageDirty(page);
  	 * put_page(page);
  	 *				!page_count(page)   [good, discard it]
  	 *
  	 * [oops, our write_to data is lost]
  	 *
  	 * Reversing the order of the tests ensures such a situation cannot
  	 * escape unnoticed. The smp_rmb is needed to ensure the page->flags
  	 * load is not satisfied before that of page->_count.
  	 *
  	 * Note that if SetPageDirty is always performed via set_page_dirty,
  	 * and thus under tree_lock, then this ordering is not required.

  	 */
  	if (unlikely(page_count(page) != 2))
  		goto cannot_free;
  	smp_rmb();
  	if (unlikely(PageDirty(page)))
  		goto cannot_free;
  
  	if (PageSwapCache(page)) {
  		swp_entry_t swap = { .val = page_private(page) };
  		__delete_from_swap_cache(page);
  		write_unlock_irq(&mapping->tree_lock);
  		swap_free(swap);
  		__put_page(page);	/* The pagecache ref */
  		return 1;
  	}
  
  	__remove_from_page_cache(page);
  	write_unlock_irq(&mapping->tree_lock);
  	__put_page(page);
  	return 1;
  
  cannot_free:
  	write_unlock_irq(&mapping->tree_lock);
  	return 0;
  }

  /*

   * shrink_page_list() returns the number of reclaimed pages

   */

  static unsigned long shrink_page_list(struct list_head *page_list,
  					struct scan_control *sc)

  {
  	LIST_HEAD(ret_pages);
  	struct pagevec freed_pvec;
  	int pgactivate = 0;

  	unsigned long nr_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;

  		VM_BUG_ON(PageActive(page));

  
  		sc->nr_scanned++;

  
  		if (!sc->may_swap && page_mapped(page))
  			goto keep_locked;

  		/* 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);

  		/* 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 (!add_to_swap(page, GFP_ATOMIC))

  				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, 0)) {

  			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 (!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 || !remove_mapping(mapping, page))

  			goto keep_locked;

  
  free_it:
  		unlock_page(page);

  		nr_reclaimed++;

  		if (!pagevec_add(&freed_pvec, page))
  			__pagevec_release_nonlru(&freed_pvec);
  		continue;
  
  activate_locked:
  		SetPageActive(page);
  		pgactivate++;
  keep_locked:
  		unlock_page(page);
  keep:
  		list_add(&page->lru, &ret_pages);

  		VM_BUG_ON(PageLRU(page));

  	}
  	list_splice(&ret_pages, page_list);
  	if (pagevec_count(&freed_pvec))
  		__pagevec_release_nonlru(&freed_pvec);

  	count_vm_events(PGACTIVATE, pgactivate);

  	return nr_reclaimed;

  }

  /*

   * zone->lru_lock is heavily contended.  Some of the functions that
   * shrink the lists perform better by taking out a batch of pages
   * and working on them outside the LRU lock.
   *
   * For pagecache intensive workloads, this function is the hottest
   * spot in the kernel (apart from copy_*_user functions).
   *
   * Appropriate locks must be held before calling this function.
   *
   * @nr_to_scan:	The number of pages to look through on the list.
   * @src:	The LRU list to pull pages off.
   * @dst:	The temp list to put pages on to.
   * @scanned:	The number of pages that were scanned.
   *
   * returns how many pages were moved onto *@dst.
   */

  static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
  		struct list_head *src, struct list_head *dst,
  		unsigned long *scanned)

  {

  	unsigned long nr_taken = 0;

  	struct page *page;

  	unsigned long scan;

  	for (scan = 0; scan < nr_to_scan && !list_empty(src); scan++) {

  		struct list_head *target;

  		page = lru_to_page(src);
  		prefetchw_prev_lru_page(page, src, flags);

  		VM_BUG_ON(!PageLRU(page));

  		list_del(&page->lru);

  		target = src;
  		if (likely(get_page_unless_zero(page))) {

  			/*

  			 * Be careful not to clear PageLRU until after we're
  			 * sure the page is not being freed elsewhere -- the
  			 * page release code relies on it.

  			 */

  			ClearPageLRU(page);
  			target = dst;
  			nr_taken++;
  		} /* else it is being freed elsewhere */

  		list_add(&page->lru, target);

  	}
  
  	*scanned = scan;
  	return nr_taken;
  }
  
  /*

   * shrink_inactive_list() is a helper for shrink_zone().  It returns the number
   * of reclaimed pages

   */

  static unsigned long shrink_inactive_list(unsigned long max_scan,
  				struct zone *zone, struct scan_control *sc)

  {
  	LIST_HEAD(page_list);
  	struct pagevec pvec;

  	unsigned long nr_scanned = 0;

  	unsigned long nr_reclaimed = 0;

  
  	pagevec_init(&pvec, 1);
  
  	lru_add_drain();
  	spin_lock_irq(&zone->lru_lock);

  	do {

  		struct page *page;

  		unsigned long nr_taken;
  		unsigned long nr_scan;
  		unsigned long nr_freed;

  
  		nr_taken = isolate_lru_pages(sc->swap_cluster_max,
  					     &zone->inactive_list,
  					     &page_list, &nr_scan);
  		zone->nr_inactive -= nr_taken;
  		zone->pages_scanned += nr_scan;
  		spin_unlock_irq(&zone->lru_lock);

  		nr_scanned += nr_scan;

  		nr_freed = shrink_page_list(&page_list, sc);

  		nr_reclaimed += nr_freed;

  		local_irq_disable();
  		if (current_is_kswapd()) {

  			__count_zone_vm_events(PGSCAN_KSWAPD, zone, nr_scan);
  			__count_vm_events(KSWAPD_STEAL, nr_freed);

  		} else

  			__count_zone_vm_events(PGSCAN_DIRECT, zone, nr_scan);
  		__count_vm_events(PGACTIVATE, nr_freed);

  		if (nr_taken == 0)
  			goto done;

  		spin_lock(&zone->lru_lock);

  		/*
  		 * Put back any unfreeable pages.
  		 */
  		while (!list_empty(&page_list)) {
  			page = lru_to_page(&page_list);

  			VM_BUG_ON(PageLRU(page));

  			SetPageLRU(page);

  			list_del(&page->lru);
  			if (PageActive(page))
  				add_page_to_active_list(zone, page);
  			else
  				add_page_to_inactive_list(zone, page);
  			if (!pagevec_add(&pvec, page)) {
  				spin_unlock_irq(&zone->lru_lock);
  				__pagevec_release(&pvec);
  				spin_lock_irq(&zone->lru_lock);
  			}
  		}

    	} while (nr_scanned < max_scan);

  	spin_unlock(&zone->lru_lock);

  done:

  	local_irq_enable();

  	pagevec_release(&pvec);

  	return nr_reclaimed;

  }

  static inline int zone_is_near_oom(struct zone *zone)
  {
  	return zone->pages_scanned >= (zone->nr_active + zone->nr_inactive)*3;
  }

  /*
   * This moves pages from the active list to the inactive list.
   *
   * We move them the other way if the page is referenced by one or more
   * processes, from rmap.
   *
   * If the pages are mostly unmapped, the processing is fast and it is
   * appropriate to hold zone->lru_lock across the whole operation.  But if
   * the pages are mapped, the processing is slow (page_referenced()) so we
   * should drop zone->lru_lock around each page.  It's impossible to balance
   * this, so instead we remove the pages from the LRU while processing them.
   * It is safe to rely on PG_active against the non-LRU pages in here because
   * nobody will play with that bit on a non-LRU page.
   *
   * The downside is that we have to touch page->_count against each page.
   * But we had to alter page->flags anyway.
   */

  static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
  				struct scan_control *sc)

  {

  	unsigned long pgmoved;

  	int pgdeactivate = 0;

  	unsigned long pgscanned;

  	LIST_HEAD(l_hold);	/* The pages which were snipped off */
  	LIST_HEAD(l_inactive);	/* Pages to go onto the inactive_list */
  	LIST_HEAD(l_active);	/* Pages to go onto the active_list */
  	struct page *page;
  	struct pagevec pvec;
  	int reclaim_mapped = 0;

  	if (sc->may_swap) {

  		long mapped_ratio;
  		long distress;
  		long swap_tendency;

  		if (zone_is_near_oom(zone))
  			goto force_reclaim_mapped;

  		/*
  		 * `distress' is a measure of how much trouble we're having
  		 * reclaiming pages.  0 -> no problems.  100 -> great trouble.
  		 */
  		distress = 100 >> zone->prev_priority;
  
  		/*
  		 * The point of this algorithm is to decide when to start
  		 * reclaiming mapped memory instead of just pagecache.  Work out
  		 * how much memory
  		 * is mapped.
  		 */

  		mapped_ratio = ((global_page_state(NR_FILE_MAPPED) +
  				global_page_state(NR_ANON_PAGES)) * 100) /

  					vm_total_pages;

  
  		/*
  		 * Now decide how much we really want to unmap some pages.  The
  		 * mapped ratio is downgraded - just because there's a lot of
  		 * mapped memory doesn't necessarily mean that page reclaim
  		 * isn't succeeding.
  		 *
  		 * The distress ratio is important - we don't want to start
  		 * going oom.
  		 *
  		 * A 100% value of vm_swappiness overrides this algorithm
  		 * altogether.
  		 */

  		swap_tendency = mapped_ratio / 2 + distress + sc->swappiness;

  
  		/*
  		 * Now use this metric to decide whether to start moving mapped
  		 * memory onto the inactive list.
  		 */
  		if (swap_tendency >= 100)

  force_reclaim_mapped:

  			reclaim_mapped = 1;
  	}

  
  	lru_add_drain();
  	spin_lock_irq(&zone->lru_lock);
  	pgmoved = isolate_lru_pages(nr_pages, &zone->active_list,
  				    &l_hold, &pgscanned);
  	zone->pages_scanned += pgscanned;
  	zone->nr_active -= pgmoved;
  	spin_unlock_irq(&zone->lru_lock);

  	while (!list_empty(&l_hold)) {
  		cond_resched();
  		page = lru_to_page(&l_hold);
  		list_del(&page->lru);
  		if (page_mapped(page)) {
  			if (!reclaim_mapped ||
  			    (total_swap_pages == 0 && PageAnon(page)) ||

  			    page_referenced(page, 0)) {

  				list_add(&page->lru, &l_active);
  				continue;
  			}
  		}
  		list_add(&page->lru, &l_inactive);
  	}
  
  	pagevec_init(&pvec, 1);
  	pgmoved = 0;
  	spin_lock_irq(&zone->lru_lock);
  	while (!list_empty(&l_inactive)) {
  		page = lru_to_page(&l_inactive);
  		prefetchw_prev_lru_page(page, &l_inactive, flags);

  		VM_BUG_ON(PageLRU(page));

  		SetPageLRU(page);

  		VM_BUG_ON(!PageActive(page));

  		ClearPageActive(page);

  		list_move(&page->lru, &zone->inactive_list);
  		pgmoved++;
  		if (!pagevec_add(&pvec, page)) {
  			zone->nr_inactive += pgmoved;
  			spin_unlock_irq(&zone->lru_lock);
  			pgdeactivate += pgmoved;
  			pgmoved = 0;
  			if (buffer_heads_over_limit)
  				pagevec_strip(&pvec);
  			__pagevec_release(&pvec);
  			spin_lock_irq(&zone->lru_lock);
  		}
  	}
  	zone->nr_inactive += pgmoved;
  	pgdeactivate += pgmoved;
  	if (buffer_heads_over_limit) {
  		spin_unlock_irq(&zone->lru_lock);
  		pagevec_strip(&pvec);
  		spin_lock_irq(&zone->lru_lock);
  	}
  
  	pgmoved = 0;
  	while (!list_empty(&l_active)) {
  		page = lru_to_page(&l_active);
  		prefetchw_prev_lru_page(page, &l_active, flags);

  		VM_BUG_ON(PageLRU(page));

  		SetPageLRU(page);

  		VM_BUG_ON(!PageActive(page));

  		list_move(&page->lru, &zone->active_list);
  		pgmoved++;
  		if (!pagevec_add(&pvec, page)) {
  			zone->nr_active += pgmoved;
  			pgmoved = 0;
  			spin_unlock_irq(&zone->lru_lock);
  			__pagevec_release(&pvec);
  			spin_lock_irq(&zone->lru_lock);
  		}
  	}
  	zone->nr_active += pgmoved;

  	__count_zone_vm_events(PGREFILL, zone, pgscanned);
  	__count_vm_events(PGDEACTIVATE, pgdeactivate);
  	spin_unlock_irq(&zone->lru_lock);

  	pagevec_release(&pvec);

  }
  
  /*
   * This is a basic per-zone page freer.  Used by both kswapd and direct reclaim.
   */

  static unsigned long shrink_zone(int priority, struct zone *zone,
  				struct scan_control *sc)

  {
  	unsigned long nr_active;
  	unsigned long nr_inactive;

  	unsigned long nr_to_scan;

  	unsigned long nr_reclaimed = 0;

  	atomic_inc(&zone->reclaim_in_progress);

  	/*
  	 * Add one to `nr_to_scan' just to make sure that the kernel will
  	 * slowly sift through the active list.
  	 */

  	zone->nr_scan_active += (zone->nr_active >> priority) + 1;

  	nr_active = zone->nr_scan_active;
  	if (nr_active >= sc->swap_cluster_max)
  		zone->nr_scan_active = 0;
  	else
  		nr_active = 0;

  	zone->nr_scan_inactive += (zone->nr_inactive >> priority) + 1;

  	nr_inactive = zone->nr_scan_inactive;
  	if (nr_inactive >= sc->swap_cluster_max)
  		zone->nr_scan_inactive = 0;
  	else
  		nr_inactive = 0;

  	while (nr_active || nr_inactive) {
  		if (nr_active) {

  			nr_to_scan = min(nr_active,

  					(unsigned long)sc->swap_cluster_max);

  			nr_active -= nr_to_scan;

  			shrink_active_list(nr_to_scan, zone, sc);

  		}
  
  		if (nr_inactive) {

  			nr_to_scan = min(nr_inactive,

  					(unsigned long)sc->swap_cluster_max);

  			nr_inactive -= nr_to_scan;

  			nr_reclaimed += shrink_inactive_list(nr_to_scan, zone,
  								sc);

  		}
  	}
  
  	throttle_vm_writeout();

  
  	atomic_dec(&zone->reclaim_in_progress);

  	return nr_reclaimed;

  }
  
  /*
   * This is the direct reclaim path, for page-allocating processes.  We only
   * try to reclaim pages from zones which will satisfy the caller's allocation
   * request.
   *
   * We reclaim from a zone even if that zone is over pages_high.  Because:
   * a) The caller may be trying to free *extra* pages to satisfy a higher-order
   *    allocation or
   * b) The zones may be over pages_high but they must go *over* pages_high to
   *    satisfy the `incremental min' zone defense algorithm.
   *
   * Returns the number of reclaimed pages.
   *
   * If a zone is deemed to be full of pinned pages then just give it a light
   * scan then give up on it.
   */

  static unsigned long shrink_zones(int priority, struct zone **zones,

  					struct scan_control *sc)

  {

  	unsigned long nr_reclaimed = 0;

  	int i;

  	sc->all_unreclaimable = 1;

  	for (i = 0; zones[i] != NULL; i++) {
  		struct zone *zone = zones[i];

  		if (!populated_zone(zone))

  			continue;

  		if (!cpuset_zone_allowed(zone, __GFP_HARDWALL))

  			continue;

  		zone->temp_priority = priority;
  		if (zone->prev_priority > priority)
  			zone->prev_priority = priority;

  		if (zone->all_unreclaimable && priority != DEF_PRIORITY)

  			continue;	/* Let kswapd poll it */

  		sc->all_unreclaimable = 0;

  		nr_reclaimed += shrink_zone(priority, zone, sc);

  	}

  	return nr_reclaimed;

  }
   
  /*
   * This is the main entry point to direct page reclaim.
   *
   * If a full scan of the inactive list fails to free enough memory then we
   * are "out of memory" and something needs to be killed.
   *
   * If the caller is !__GFP_FS then the probability of a failure is reasonably
   * high - the zone may be full of dirty or under-writeback pages, which this
   * caller can't do much about.  We kick pdflush and take explicit naps in the
   * hope that some of these pages can be written.  But if the allocating task
   * holds filesystem locks which prevent writeout this might not work, and the
   * allocation attempt will fail.
   */

  unsigned long try_to_free_pages(struct zone **zones, gfp_t gfp_mask)

  {
  	int priority;
  	int ret = 0;

  	unsigned long total_scanned = 0;

  	unsigned long nr_reclaimed = 0;

  	struct reclaim_state *reclaim_state = current->reclaim_state;

  	unsigned long lru_pages = 0;
  	int i;

  	struct scan_control sc = {
  		.gfp_mask = gfp_mask,
  		.may_writepage = !laptop_mode,
  		.swap_cluster_max = SWAP_CLUSTER_MAX,
  		.may_swap = 1,

  		.swappiness = vm_swappiness,

  	};

  	count_vm_event(ALLOCSTALL);

  
  	for (i = 0; zones[i] != NULL; i++) {
  		struct zone *zone = zones[i];

  		if (!cpuset_zone_allowed(zone, __GFP_HARDWALL))

  			continue;
  
  		zone->temp_priority = DEF_PRIORITY;
  		lru_pages += zone->nr_active + zone->nr_inactive;
  	}
  
  	for (priority = DEF_PRIORITY; priority >= 0; priority--) {

  		sc.nr_scanned = 0;

  		if (!priority)
  			disable_swap_token();

  		nr_reclaimed += shrink_zones(priority, zones, &sc);

  		shrink_slab(sc.nr_scanned, gfp_mask, lru_pages);
  		if (reclaim_state) {

  			nr_reclaimed += reclaim_state->reclaimed_slab;

  			reclaim_state->reclaimed_slab = 0;
  		}
  		total_scanned += sc.nr_scanned;

  		if (nr_reclaimed >= sc.swap_cluster_max) {

  			ret = 1;
  			goto out;
  		}
  
  		/*
  		 * Try to write back as many pages as we just scanned.  This
  		 * tends to cause slow streaming writers to write data to the
  		 * disk smoothly, at the dirtying rate, which is nice.   But
  		 * that's undesirable in laptop mode, where we *want* lumpy
  		 * writeout.  So in laptop mode, write out the whole world.
  		 */

  		if (total_scanned > sc.swap_cluster_max +
  					sc.swap_cluster_max / 2) {

  			wakeup_pdflush(laptop_mode ? 0 : total_scanned);

  			sc.may_writepage = 1;
  		}
  
  		/* Take a nap, wait for some writeback to complete */
  		if (sc.nr_scanned && priority < DEF_PRIORITY - 2)
  			blk_congestion_wait(WRITE, HZ/10);
  	}

  	/* top priority shrink_caches still had more to do? don't OOM, then */
  	if (!sc.all_unreclaimable)
  		ret = 1;

  out:
  	for (i = 0; zones[i] != 0; i++) {
  		struct zone *zone = zones[i];

  		if (!cpuset_zone_allowed(zone, __GFP_HARDWALL))

  			continue;
  
  		zone->prev_priority = zone->temp_priority;
  	}
  	return ret;
  }
  
  /*
   * For kswapd, balance_pgdat() will work across all this node's zones until
   * they are all at pages_high.
   *

   * Returns the number of pages which were actually freed.
   *
   * There is special handling here for zones which are full of pinned pages.
   * This can happen if the pages are all mlocked, or if they are all used by
   * device drivers (say, ZONE_DMA).  Or if they are all in use by hugetlb.
   * What we do is to detect the case where all pages in the zone have been
   * scanned twice and there has been zero successful reclaim.  Mark the zone as
   * dead and from now on, only perform a short scan.  Basically we're polling
   * the zone for when the problem goes away.
   *
   * kswapd scans the zones in the highmem->normal->dma direction.  It skips
   * zones which have free_pages > pages_high, but once a zone is found to have
   * free_pages <= pages_high, we scan that zone and the lower zones regardless
   * of the number of free pages in the lower zones.  This interoperates with
   * the page allocator fallback scheme to ensure that aging of pages is balanced
   * across the zones.
   */

  static unsigned long balance_pgdat(pg_data_t *pgdat, int order)

  {

  	int all_zones_ok;
  	int priority;
  	int i;

  	unsigned long total_scanned;

  	unsigned long nr_reclaimed;

  	struct reclaim_state *reclaim_state = current->reclaim_state;

  	struct scan_control sc = {
  		.gfp_mask = GFP_KERNEL,
  		.may_swap = 1,

  		.swap_cluster_max = SWAP_CLUSTER_MAX,
  		.swappiness = vm_swappiness,

  	};

  
  loop_again:
  	total_scanned = 0;

  	nr_reclaimed = 0;

  	sc.may_writepage = !laptop_mode;

  	count_vm_event(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;

  		/* The swap token gets in the way of swapout... */
  		if (!priority)
  			disable_swap_token();

  		all_zones_ok = 1;

  		/*
  		 * 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 (!populated_zone(zone))
  				continue;

  			if (zone->all_unreclaimable && priority != DEF_PRIORITY)
  				continue;

  			if (!zone_watermark_ok(zone, order, zone->pages_high,
  					       0, 0)) {
  				end_zone = i;
  				goto scan;

  			}

  		}

  		goto out;

  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 (!populated_zone(zone))

  				continue;
  
  			if (zone->all_unreclaimable && priority != DEF_PRIORITY)
  				continue;

  			if (!zone_watermark_ok(zone, order, zone->pages_high,
  					       end_zone, 0))
  				all_zones_ok = 0;

  			zone->temp_priority = priority;
  			if (zone->prev_priority > priority)
  				zone->prev_priority = priority;
  			sc.nr_scanned = 0;

  			nr_reclaimed += shrink_zone(priority, zone, &sc);

  			reclaim_state->reclaimed_slab = 0;

  			nr_slab = shrink_slab(sc.nr_scanned, GFP_KERNEL,
  						lru_pages);

  			nr_reclaimed += reclaim_state->reclaimed_slab;

  			total_scanned += sc.nr_scanned;
  			if (zone->all_unreclaimable)
  				continue;

  			if (nr_slab == 0 && zone->pages_scanned >=

  				    (zone->nr_active + zone->nr_inactive) * 6)

  				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 > nr_reclaimed + nr_reclaimed / 2)

  				sc.may_writepage = 1;
  		}

  		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 (nr_reclaimed >= SWAP_CLUSTER_MAX)

  			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 nr_reclaimed;

  }
  
  /*
   * The background pageout daemon, started as a kernel thread
   * from the init process. 
   *
   * This basically trickles out pages so that we have _some_
   * free memory available even if there is no other activity
   * that frees anything up. This is needed for things like routing
   * etc, where we otherwise might have all activity going on in
   * asynchronous contexts that cannot page things out.
   *
   * If there are applications that are active memory-allocators
   * (most normal use), this basically shouldn't matter.
   */
  static int kswapd(void *p)
  {
  	unsigned long order;
  	pg_data_t *pgdat = (pg_data_t*)p;
  	struct task_struct *tsk = current;
  	DEFINE_WAIT(wait);
  	struct reclaim_state reclaim_state = {
  		.reclaimed_slab = 0,
  	};
  	cpumask_t cpumask;

  	cpumask = node_to_cpumask(pgdat->node_id);
  	if (!cpus_empty(cpumask))
  		set_cpus_allowed(tsk, cpumask);
  	current->reclaim_state = &reclaim_state;
  
  	/*
  	 * Tell the memory management that we're a "memory allocator",
  	 * and that if we need more memory we should get access to it
  	 * regardless (see "__alloc_pages()"). "kswapd" should
  	 * never get caught in the normal page freeing logic.
  	 *
  	 * (Kswapd normally doesn't need memory anyway, but sometimes
  	 * you need a small amount of memory in order to be able to
  	 * page out something else, and this flag essentially protects
  	 * us from recursively trying to free more memory as we're
  	 * trying to free the first piece of memory in the first place).
  	 */

  	tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;

  
  	order = 0;
  	for ( ; ; ) {
  		unsigned long new_order;

  
  		try_to_freeze();

  
  		prepare_to_wait(&pgdat->kswapd_wait, &wait, TASK_INTERRUPTIBLE);
  		new_order = pgdat->kswapd_max_order;
  		pgdat->kswapd_max_order = 0;
  		if (order < new_order) {
  			/*
  			 * Don't sleep if someone wants a larger 'order'
  			 * allocation
  			 */
  			order = new_order;
  		} else {
  			schedule();
  			order = pgdat->kswapd_max_order;
  		}
  		finish_wait(&pgdat->kswapd_wait, &wait);

  		balance_pgdat(pgdat, order);

  	}
  	return 0;
  }
  
  /*
   * A zone is low on free memory, so wake its kswapd task to service it.
   */
  void wakeup_kswapd(struct zone *zone, int order)
  {
  	pg_data_t *pgdat;

  	if (!populated_zone(zone))

  		return;
  
  	pgdat = zone->zone_pgdat;

  	if (zone_watermark_ok(zone, order, zone->pages_low, 0, 0))

  		return;
  	if (pgdat->kswapd_max_order < order)
  		pgdat->kswapd_max_order = order;

  	if (!cpuset_zone_allowed(zone, __GFP_HARDWALL))

  		return;

  	if (!waitqueue_active(&pgdat->kswapd_wait))

  		return;

  	wake_up_interruptible(&pgdat->kswapd_wait);

  }
  
  #ifdef CONFIG_PM
  /*

   * Helper function for shrink_all_memory().  Tries to reclaim 'nr_pages' pages
   * from LRU lists system-wide, for given pass and priority, and returns the
   * number of reclaimed pages
   *
   * For pass > 3 we also try to shrink the LRU lists that contain a few pages
   */
  static unsigned long shrink_all_zones(unsigned long nr_pages, int pass,
  				      int prio, struct scan_control *sc)
  {
  	struct zone *zone;
  	unsigned long nr_to_scan, ret = 0;
  
  	for_each_zone(zone) {
  
  		if (!populated_zone(zone))
  			continue;
  
  		if (zone->all_unreclaimable && prio != DEF_PRIORITY)
  			continue;
  
  		/* For pass = 0 we don't shrink the active list */
  		if (pass > 0) {
  			zone->nr_scan_active += (zone->nr_active >> prio) + 1;
  			if (zone->nr_scan_active >= nr_pages || pass > 3) {
  				zone->nr_scan_active = 0;
  				nr_to_scan = min(nr_pages, zone->nr_active);
  				shrink_active_list(nr_to_scan, zone, sc);
  			}
  		}
  
  		zone->nr_scan_inactive += (zone->nr_inactive >> prio) + 1;
  		if (zone->nr_scan_inactive >= nr_pages || pass > 3) {
  			zone->nr_scan_inactive = 0;
  			nr_to_scan = min(nr_pages, zone->nr_inactive);
  			ret += shrink_inactive_list(nr_to_scan, zone, sc);
  			if (ret >= nr_pages)
  				return ret;
  		}
  	}
  
  	return ret;
  }
  
  /*
   * Try to free `nr_pages' of memory, system-wide, and return the number of
   * freed pages.
   *
   * Rather than trying to age LRUs the aim is to preserve the overall
   * LRU order by reclaiming preferentially
   * inactive > active > active referenced > active mapped

   */

  unsigned long shrink_all_memory(unsigned long nr_pages)

  {

  	unsigned long lru_pages, nr_slab;

  	unsigned long ret = 0;

  	int pass;
  	struct reclaim_state reclaim_state;
  	struct zone *zone;
  	struct scan_control sc = {
  		.gfp_mask = GFP_KERNEL,
  		.may_swap = 0,
  		.swap_cluster_max = nr_pages,
  		.may_writepage = 1,
  		.swappiness = vm_swappiness,

  	};
  
  	current->reclaim_state = &reclaim_state;

  	lru_pages = 0;
  	for_each_zone(zone)
  		lru_pages += zone->nr_active + zone->nr_inactive;

  	nr_slab = global_page_state(NR_SLAB_RECLAIMABLE);

  	/* If slab caches are huge, it's better to hit them first */
  	while (nr_slab >= lru_pages) {
  		reclaim_state.reclaimed_slab = 0;
  		shrink_slab(nr_pages, sc.gfp_mask, lru_pages);
  		if (!reclaim_state.reclaimed_slab)

  			break;

  
  		ret += reclaim_state.reclaimed_slab;
  		if (ret >= nr_pages)
  			goto out;
  
  		nr_slab -= reclaim_state.reclaimed_slab;

  	}

  
  	/*
  	 * We try to shrink LRUs in 5 passes:
  	 * 0 = Reclaim from inactive_list only
  	 * 1 = Reclaim from active list but don't reclaim mapped
  	 * 2 = 2nd pass of type 1
  	 * 3 = Reclaim mapped (normal reclaim)
  	 * 4 = 2nd pass of type 3
  	 */
  	for (pass = 0; pass < 5; pass++) {
  		int prio;
  
  		/* Needed for shrinking slab caches later on */
  		if (!lru_pages)
  			for_each_zone(zone) {
  				lru_pages += zone->nr_active;
  				lru_pages += zone->nr_inactive;
  			}
  
  		/* Force reclaiming mapped pages in the passes #3 and #4 */
  		if (pass > 2) {
  			sc.may_swap = 1;
  			sc.swappiness = 100;
  		}
  
  		for (prio = DEF_PRIORITY; prio >= 0; prio--) {
  			unsigned long nr_to_scan = nr_pages - ret;

  			sc.nr_scanned = 0;

  			ret += shrink_all_zones(nr_to_scan, prio, pass, &sc);
  			if (ret >= nr_pages)
  				goto out;
  
  			reclaim_state.reclaimed_slab = 0;
  			shrink_slab(sc.nr_scanned, sc.gfp_mask, lru_pages);
  			ret += reclaim_state.reclaimed_slab;
  			if (ret >= nr_pages)
  				goto out;
  
  			if (sc.nr_scanned && prio < DEF_PRIORITY - 2)
  				blk_congestion_wait(WRITE, HZ / 10);
  		}
  
  		lru_pages = 0;

  	}

  
  	/*
  	 * If ret = 0, we could not shrink LRUs, but there may be something
  	 * in slab caches
  	 */
  	if (!ret)
  		do {
  			reclaim_state.reclaimed_slab = 0;
  			shrink_slab(nr_pages, sc.gfp_mask, lru_pages);
  			ret += reclaim_state.reclaimed_slab;
  		} while (ret < nr_pages && reclaim_state.reclaimed_slab > 0);
  
  out:

  	current->reclaim_state = NULL;

  	return ret;
  }
  #endif
  
  #ifdef CONFIG_HOTPLUG_CPU
  /* It's optimal to keep kswapds on the same CPUs as their memory, but
     not required for correctness.  So if the last cpu in a node goes
     away, we get changed to run anywhere: as the first one comes back,
     restore their cpu bindings. */

  static int __devinit cpu_callback(struct notifier_block *nfb,

  				  unsigned long action, void *hcpu)

  {
  	pg_data_t *pgdat;
  	cpumask_t mask;
  
  	if (action == CPU_ONLINE) {

  		for_each_online_pgdat(pgdat) {

  			mask = node_to_cpumask(pgdat->node_id);
  			if (any_online_cpu(mask) != NR_CPUS)
  				/* One of our CPUs online: restore mask */
  				set_cpus_allowed(pgdat->kswapd, mask);
  		}
  	}
  	return NOTIFY_OK;
  }
  #endif /* CONFIG_HOTPLUG_CPU */

  /*
   * This kswapd start function will be called by init and node-hot-add.
   * On node-hot-add, kswapd will moved to proper cpus if cpus are hot-added.
   */
  int kswapd_run(int nid)
  {
  	pg_data_t *pgdat = NODE_DATA(nid);
  	int ret = 0;
  
  	if (pgdat->kswapd)
  		return 0;
  
  	pgdat->kswapd = kthread_run(kswapd, pgdat, "kswapd%d", nid);
  	if (IS_ERR(pgdat->kswapd)) {
  		/* failure at boot is fatal */
  		BUG_ON(system_state == SYSTEM_BOOTING);
  		printk("Failed to start kswapd on node %d
  ",nid);
  		ret = -1;
  	}
  	return ret;
  }

  static int __init kswapd_init(void)
  {

  	int nid;

  	swap_setup();

  	for_each_online_node(nid)
   		kswapd_run(nid);

  	hotcpu_notifier(cpu_callback, 0);
  	return 0;
  }
  
  module_init(kswapd_init)

  
  #ifdef CONFIG_NUMA
  /*
   * Zone reclaim mode
   *
   * If non-zero call zone_reclaim when the number of free pages falls below
   * the watermarks.

   */
  int zone_reclaim_mode __read_mostly;

  #define RECLAIM_OFF 0
  #define RECLAIM_ZONE (1<<0)	/* Run shrink_cache on the zone */
  #define RECLAIM_WRITE (1<<1)	/* Writeout pages during reclaim */
  #define RECLAIM_SWAP (1<<2)	/* Swap pages out during reclaim */

  /*

   * Priority for ZONE_RECLAIM. This determines the fraction of pages
   * of a node considered for each zone_reclaim. 4 scans 1/16th of
   * a zone.
   */
  #define ZONE_RECLAIM_PRIORITY 4

  /*

   * Percentage of pages in a zone that must be unmapped for zone_reclaim to
   * occur.
   */
  int sysctl_min_unmapped_ratio = 1;
  
  /*

   * If the number of slab pages in a zone grows beyond this percentage then
   * slab reclaim needs to occur.
   */
  int sysctl_min_slab_ratio = 5;
  
  /*

   * Try to free up some pages from this zone through reclaim.
   */

  static int __zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)

  {

  	/* Minimum pages needed in order to stay on node */

  	const unsigned long nr_pages = 1 << order;

  	struct task_struct *p = current;
  	struct reclaim_state reclaim_state;

  	int priority;

  	unsigned long nr_reclaimed = 0;

  	struct scan_control sc = {
  		.may_writepage = !!(zone_reclaim_mode & RECLAIM_WRITE),
  		.may_swap = !!(zone_reclaim_mode & RECLAIM_SWAP),

  		.swap_cluster_max = max_t(unsigned long, nr_pages,
  					SWAP_CLUSTER_MAX),

  		.gfp_mask = gfp_mask,

  		.swappiness = vm_swappiness,

  	};

  	unsigned long slab_reclaimable;

  
  	disable_swap_token();

  	cond_resched();

  	/*
  	 * We need to be able to allocate from the reserves for RECLAIM_SWAP
  	 * and we also need to be able to write out pages for RECLAIM_WRITE
  	 * and RECLAIM_SWAP.
  	 */
  	p->flags |= PF_MEMALLOC | PF_SWAPWRITE;

  	reclaim_state.reclaimed_slab = 0;
  	p->reclaim_state = &reclaim_state;

  	if (zone_page_state(zone, NR_FILE_PAGES) -
  		zone_page_state(zone, NR_FILE_MAPPED) >
  		zone->min_unmapped_pages) {
  		/*
  		 * Free memory by calling shrink zone with increasing
  		 * priorities until we have enough memory freed.
  		 */
  		priority = ZONE_RECLAIM_PRIORITY;
  		do {
  			nr_reclaimed += shrink_zone(priority, zone, &sc);
  			priority--;
  		} while (priority >= 0 && nr_reclaimed < nr_pages);
  	}

  	slab_reclaimable = zone_page_state(zone, NR_SLAB_RECLAIMABLE);
  	if (slab_reclaimable > zone->min_slab_pages) {

  		/*

  		 * shrink_slab() does not currently allow us to determine how

  		 * many pages were freed in this zone. So we take the current
  		 * number of slab pages and shake the slab until it is reduced
  		 * by the same nr_pages that we used for reclaiming unmapped
  		 * pages.

  		 *

  		 * Note that shrink_slab will free memory on all zones and may
  		 * take a long time.

  		 */

  		while (shrink_slab(sc.nr_scanned, gfp_mask, order) &&

  			zone_page_state(zone, NR_SLAB_RECLAIMABLE) >
  				slab_reclaimable - nr_pages)

  			;

  
  		/*
  		 * Update nr_reclaimed by the number of slab pages we
  		 * reclaimed from this zone.
  		 */
  		nr_reclaimed += slab_reclaimable -
  			zone_page_state(zone, NR_SLAB_RECLAIMABLE);

  	}

  	p->reclaim_state = NULL;

  	current->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE);

  	return nr_reclaimed >= nr_pages;

  }

  
  int zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
  {
  	cpumask_t mask;
  	int node_id;
  
  	/*

  	 * Zone reclaim reclaims unmapped file backed pages and
  	 * slab pages if we are over the defined limits.

  	 *

  	 * A small portion of unmapped file backed pages is needed for
  	 * file I/O otherwise pages read by file I/O will be immediately
  	 * thrown out if the zone is overallocated. So we do not reclaim
  	 * if less than a specified percentage of the zone is used by
  	 * unmapped file backed pages.

  	 */

  	if (zone_page_state(zone, NR_FILE_PAGES) -

  	    zone_page_state(zone, NR_FILE_MAPPED) <= zone->min_unmapped_pages
  	    && zone_page_state(zone, NR_SLAB_RECLAIMABLE)
  			<= zone->min_slab_pages)

  		return 0;

  
  	/*
  	 * Avoid concurrent zone reclaims, do not reclaim in a zone that does
  	 * not have reclaimable pages and if we should not delay the allocation
  	 * then do not scan.
  	 */
  	if (!(gfp_mask & __GFP_WAIT) ||
  		zone->all_unreclaimable ||
  		atomic_read(&zone->reclaim_in_progress) > 0 ||
  		(current->flags & PF_MEMALLOC))
  			return 0;
  
  	/*
  	 * Only run zone reclaim on the local zone or on zones that do not
  	 * have associated processors. This will favor the local processor
  	 * over remote processors and spread off node memory allocations
  	 * as wide as possible.
  	 */

  	node_id = zone_to_nid(zone);

  	mask = node_to_cpumask(node_id);
  	if (!cpus_empty(mask) && node_id != numa_node_id())
  		return 0;
  	return __zone_reclaim(zone, gfp_mask, order);
  }

  #endif