mm: new shrinker API

/*

 * This struct is used to pass information from page reclaim to the shrinkers.

 * We consolidate the values for easier extention later.

 *

 * The 'gfpmask' refers to the allocation we are currently trying to

 * fulfil.

 *

 * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is

 * querying the cache size, so a fastpath for that case is appropriate.

 */

struct shrink_control {

	gfp_t gfp_mask;

	unsigned long nr_to_scan;

};

#define SHRINK_STOP (~0UL)

/*

 * A callback you can register to apply pressure to ageable caches.

 *

 * 'sc' is passed shrink_control which includes a count 'nr_to_scan'

 * and a 'gfpmask'.  It should look through the least-recently-used

 * 'nr_to_scan' entries and attempt to free them up.  It should return

 * the number of objects which remain in the cache.  If it returns -1, it means

 * it cannot do any scanning at this time (eg. there is a risk of deadlock).

 * @shrink() should look through the least-recently-used 'nr_to_scan' entries

 * and attempt to free them up.  It should return the number of objects which

 * remain in the cache.  If it returns -1, it means it cannot do any scanning at

 * this time (eg. there is a risk of deadlock).

 *

 * The 'gfpmask' refers to the allocation we are currently trying to

 * fulfil.

 * @count_objects should return the number of freeable items in the cache. If

 * there are no objects to free or the number of freeable items cannot be

 * determined, it should return 0. No deadlock checks should be done during the

 * count callback - the shrinker relies on aggregating scan counts that couldn't

 * be executed due to potential deadlocks to be run at a later call when the

 * deadlock condition is no longer pending.

 *

 * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is

 * querying the cache size, so a fastpath for that case is appropriate.

 * @scan_objects will only be called if @count_objects returned a non-zero

 * value for the number of freeable objects. The callout should scan the cache

 * and attempt to free items from the cache. It should then return the number

 * of objects freed during the scan, or SHRINK_STOP if progress cannot be made

 * due to potential deadlocks. If SHRINK_STOP is returned, then no further

 * attempts to call the @scan_objects will be made from the current reclaim

 * context.

 */

struct shrinker {

	int (*shrink)(struct shrinker *, struct shrink_control *sc);

	unsigned long (*count_objects)(struct shrinker *,

				       struct shrink_control *sc);

	unsigned long (*scan_objects)(struct shrinker *,

				      struct shrink_control *sc);

	int seeks;	/* seeks to recreate an obj */

	long batch;	/* reclaim batch size, 0 = default */

 *

 * Returns the number of slab objects which we shrunk.

 */

unsigned long shrink_slab(struct shrink_control *shrink,

unsigned long shrink_slab(struct shrink_control *shrinkctl,

			  unsigned long nr_pages_scanned,

			  unsigned long lru_pages)

{

	struct shrinker *shrinker;

	unsigned long ret = 0;

	unsigned long freed = 0;

	if (nr_pages_scanned == 0)

		nr_pages_scanned = SWAP_CLUSTER_MAX;

	if (!down_read_trylock(&shrinker_rwsem)) {

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

		ret = 1;

		/*

		 * If we would return 0, our callers would understand that we

		 * have nothing else to shrink and give up trying. By returning

		 * 1 we keep it going and assume we'll be able to shrink next

		 * time.

		 */

		freed = 1;

		goto out;

	}

		unsigned long long delta;

		long total_scan;

		long max_pass;

		int shrink_ret = 0;

		long nr;

		long new_nr;

		long batch_size = shrinker->batch ? shrinker->batch

						  : SHRINK_BATCH;

		max_pass = do_shrinker_shrink(shrinker, shrink, 0);

		if (max_pass <= 0)

		if (shrinker->count_objects)

			max_pass = shrinker->count_objects(shrinker, shrinkctl);

		else

			max_pass = do_shrinker_shrink(shrinker, shrinkctl, 0);

		if (max_pass == 0)

			continue;

		/*

		do_div(delta, lru_pages + 1);

		total_scan += delta;

		if (total_scan < 0) {

			printk(KERN_ERR "shrink_slab: %pF negative objects to "

			       "delete nr=%ld\n",

			printk(KERN_ERR

			"shrink_slab: %pF negative objects to delete nr=%ld\n",

			       shrinker->shrink, total_scan);

			total_scan = max_pass;

		}

		if (total_scan > max_pass * 2)

			total_scan = max_pass * 2;

		trace_mm_shrink_slab_start(shrinker, shrink, nr,

		trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,

					nr_pages_scanned, lru_pages,

					max_pass, delta, total_scan);

		while (total_scan >= batch_size) {

			if (shrinker->scan_objects) {

				unsigned long ret;

				shrinkctl->nr_to_scan = batch_size;

				ret = shrinker->scan_objects(shrinker, shrinkctl);

				if (ret == SHRINK_STOP)

					break;

				freed += ret;

			} else {

				int nr_before;

				long ret;

			nr_before = do_shrinker_shrink(shrinker, shrink, 0);

			shrink_ret = do_shrinker_shrink(shrinker, shrink,

				nr_before = do_shrinker_shrink(shrinker, shrinkctl, 0);

				ret = do_shrinker_shrink(shrinker, shrinkctl,

								batch_size);

			if (shrink_ret == -1)

				if (ret == -1)

					break;

			if (shrink_ret < nr_before)

				ret += nr_before - shrink_ret;

				if (ret < nr_before)

					freed += nr_before - ret;

			}

			count_vm_events(SLABS_SCANNED, batch_size);

			total_scan -= batch_size;

		else

			new_nr = atomic_long_read(&shrinker->nr_in_batch);

		trace_mm_shrink_slab_end(shrinker, shrink_ret, nr, new_nr);

		trace_mm_shrink_slab_end(shrinker, freed, nr, new_nr);

	}

	up_read(&shrinker_rwsem);

out:

	cond_resched();

	return ret;

	return freed;

}

static inline int is_page_cache_freeable(struct page *page)