Commit 6a05aa30 authored by Johannes Weiner's avatar Johannes Weiner Committed by Andrew Morton
Browse files

zpool: clean out dead code 

There is a lot of provision for flexibility that isn't actually needed or
used.  Zswap (the only zpool user) always passes zpool_ops with an .evict
method set.  The backends who reclaim only do so for zswap, so they can
also directly call zpool_ops without indirection or checks.

Finally, there is no need to check the retries parameters and bail with
-EINVAL in the reclaim function, when that's called just a few lines below
with a hard-coded 8.  There is no need to duplicate the evictable and
sleep_mapped attrs from the driver in zpool_ops.

Link: https://lkml.kernel.org/r/20221128191616.1261026-3-nphamcs@gmail.com


Reviewed-by: default avatarSergey Senozhatsky <senozhatsky@chromium.org>
Signed-off-by: default avatarJohannes Weiner <hannes@cmpxchg.org>
Signed-off-by: default avatarNhat Pham <nphamcs@gmail.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Seth Jennings <sjenning@redhat.com>
Cc: Vitaly Wool <vitaly.wool@konsulko.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 6b3379e8

mm/z3fold.c

+5 −31
Original line number Diff line number Diff line
@@ -68,9 +68,6 @@ 
 * Structures

*****************/

struct z3fold_pool;

struct z3fold_ops {

	int (*evict)(struct z3fold_pool *pool, unsigned long handle);

};



enum buddy {

	HEADLESS = 0,
@@ -138,8 +135,6 @@ struct z3fold_header { 
 * @stale:	list of pages marked for freeing

 * @pages_nr:	number of z3fold pages in the pool.

 * @c_handle:	cache for z3fold_buddy_slots allocation

 * @ops:	pointer to a structure of user defined operations specified at

 *		pool creation time.

 * @zpool:	zpool driver

 * @zpool_ops:	zpool operations structure with an evict callback

 * @compact_wq:	workqueue for page layout background optimization
@@ -158,7 +153,6 @@ struct z3fold_pool { 
	struct list_head stale;

	atomic64_t pages_nr;

	struct kmem_cache *c_handle;

	const struct z3fold_ops *ops;

	struct zpool *zpool;

	const struct zpool_ops *zpool_ops;

	struct workqueue_struct *compact_wq;
@@ -907,13 +901,11 @@ static inline struct z3fold_header *__z3fold_alloc(struct z3fold_pool *pool, 
 * z3fold_create_pool() - create a new z3fold pool

 * @name:	pool name

 * @gfp:	gfp flags when allocating the z3fold pool structure

 * @ops:	user-defined operations for the z3fold pool

 *

 * Return: pointer to the new z3fold pool or NULL if the metadata allocation

 * failed.

 */

static struct z3fold_pool *z3fold_create_pool(const char *name, gfp_t gfp,

		const struct z3fold_ops *ops)

static struct z3fold_pool *z3fold_create_pool(const char *name, gfp_t gfp)

{

	struct z3fold_pool *pool = NULL;

	int i, cpu;
@@ -949,7 +941,6 @@ static struct z3fold_pool *z3fold_create_pool(const char *name, gfp_t gfp, 
	if (!pool->release_wq)

		goto out_wq;

	INIT_WORK(&pool->work, free_pages_work);

	pool->ops = ops;

	return pool;



out_wq:
@@ -1230,10 +1221,6 @@ static int z3fold_reclaim_page(struct z3fold_pool *pool, unsigned int retries) 
	slots.pool = (unsigned long)pool | (1 << HANDLES_NOFREE);



	spin_lock(&pool->lock);

	if (!pool->ops || !pool->ops->evict || retries == 0) {

		spin_unlock(&pool->lock);

		return -EINVAL;

	}

	for (i = 0; i < retries; i++) {

		if (list_empty(&pool->lru)) {

			spin_unlock(&pool->lock);
@@ -1319,17 +1306,17 @@ static int z3fold_reclaim_page(struct z3fold_pool *pool, unsigned int retries) 
		}

		/* Issue the eviction callback(s) */

		if (middle_handle) {

			ret = pool->ops->evict(pool, middle_handle);

			ret = pool->zpool_ops->evict(pool->zpool, middle_handle);

			if (ret)

				goto next;

		}

		if (first_handle) {

			ret = pool->ops->evict(pool, first_handle);

			ret = pool->zpool_ops->evict(pool->zpool, first_handle);

			if (ret)

				goto next;

		}

		if (last_handle) {

			ret = pool->ops->evict(pool, last_handle);

			ret = pool->zpool_ops->evict(pool->zpool, last_handle);

			if (ret)

				goto next;

		}
@@ -1593,26 +1580,13 @@ static const struct movable_operations z3fold_mops = { 
 * zpool

 ****************/



static int z3fold_zpool_evict(struct z3fold_pool *pool, unsigned long handle)

{

	if (pool->zpool && pool->zpool_ops && pool->zpool_ops->evict)

		return pool->zpool_ops->evict(pool->zpool, handle);

	else

		return -ENOENT;

}



static const struct z3fold_ops z3fold_zpool_ops = {

	.evict =	z3fold_zpool_evict

};



static void *z3fold_zpool_create(const char *name, gfp_t gfp,

			       const struct zpool_ops *zpool_ops,

			       struct zpool *zpool)

{

	struct z3fold_pool *pool;



	pool = z3fold_create_pool(name, gfp,

				zpool_ops ? &z3fold_zpool_ops : NULL);

	pool = z3fold_create_pool(name, gfp);

	if (pool) {

		pool->zpool = zpool;

		pool->zpool_ops = zpool_ops;

mm/zbud.c

+5 −27
Original line number Diff line number Diff line
@@ -74,10 +74,6 @@ 


struct zbud_pool;



struct zbud_ops {

	int (*evict)(struct zbud_pool *pool, unsigned long handle);

};



/**

 * struct zbud_pool - stores metadata for each zbud pool

 * @lock:	protects all pool fields and first|last_chunk fields of any
@@ -90,8 +86,6 @@ struct zbud_ops { 
 * @lru:	list tracking the zbud pages in LRU order by most recently

 *		added buddy.

 * @pages_nr:	number of zbud pages in the pool.

 * @ops:	pointer to a structure of user defined operations specified at

 *		pool creation time.

 * @zpool:	zpool driver

 * @zpool_ops:	zpool operations structure with an evict callback

 *
@@ -110,7 +104,6 @@ struct zbud_pool { 
	};

	struct list_head lru;

	u64 pages_nr;

	const struct zbud_ops *ops;

	struct zpool *zpool;

	const struct zpool_ops *zpool_ops;

};
@@ -212,12 +205,11 @@ static int num_free_chunks(struct zbud_header *zhdr) 
/**

 * zbud_create_pool() - create a new zbud pool

 * @gfp:	gfp flags when allocating the zbud pool structure

 * @ops:	user-defined operations for the zbud pool

 *

 * Return: pointer to the new zbud pool or NULL if the metadata allocation

 * failed.

 */

static struct zbud_pool *zbud_create_pool(gfp_t gfp, const struct zbud_ops *ops)

static struct zbud_pool *zbud_create_pool(gfp_t gfp)

{

	struct zbud_pool *pool;

	int i;
@@ -231,7 +223,6 @@ static struct zbud_pool *zbud_create_pool(gfp_t gfp, const struct zbud_ops *ops) 
	INIT_LIST_HEAD(&pool->buddied);

	INIT_LIST_HEAD(&pool->lru);

	pool->pages_nr = 0;

	pool->ops = ops;

	return pool;

}
@@ -419,8 +410,7 @@ static int zbud_reclaim_page(struct zbud_pool *pool, unsigned int retries) 
	unsigned long first_handle = 0, last_handle = 0;



	spin_lock(&pool->lock);

	if (!pool->ops || !pool->ops->evict || list_empty(&pool->lru) ||

			retries == 0) {

	if (list_empty(&pool->lru)) {

		spin_unlock(&pool->lock);

		return -EINVAL;

	}
@@ -444,12 +434,12 @@ static int zbud_reclaim_page(struct zbud_pool *pool, unsigned int retries) 


		/* Issue the eviction callback(s) */

		if (first_handle) {

			ret = pool->ops->evict(pool, first_handle);

			ret = pool->zpool_ops->evict(pool->zpool, first_handle);

			if (ret)

				goto next;

		}

		if (last_handle) {

			ret = pool->ops->evict(pool, last_handle);

			ret = pool->zpool_ops->evict(pool->zpool, last_handle);

			if (ret)

				goto next;

		}
@@ -524,25 +514,13 @@ static u64 zbud_get_pool_size(struct zbud_pool *pool) 
 * zpool

 ****************/



static int zbud_zpool_evict(struct zbud_pool *pool, unsigned long handle)

{

	if (pool->zpool && pool->zpool_ops && pool->zpool_ops->evict)

		return pool->zpool_ops->evict(pool->zpool, handle);

	else

		return -ENOENT;

}



static const struct zbud_ops zbud_zpool_ops = {

	.evict =	zbud_zpool_evict

};



static void *zbud_zpool_create(const char *name, gfp_t gfp,

			       const struct zpool_ops *zpool_ops,

			       struct zpool *zpool)

{

	struct zbud_pool *pool;



	pool = zbud_create_pool(gfp, zpool_ops ? &zbud_zpool_ops : NULL);

	pool = zbud_create_pool(gfp);

	if (pool) {

		pool->zpool = zpool;

		pool->zpool_ops = zpool_ops;

mm/zpool.c

+2 −8
Original line number Diff line number Diff line
@@ -21,9 +21,6 @@ 
struct zpool {

	struct zpool_driver *driver;

	void *pool;

	const struct zpool_ops *ops;

	bool evictable;

	bool can_sleep_mapped;

};



static LIST_HEAD(drivers_head);
@@ -177,9 +174,6 @@ struct zpool *zpool_create_pool(const char *type, const char *name, gfp_t gfp, 


	zpool->driver = driver;

	zpool->pool = driver->create(name, gfp, ops, zpool);

	zpool->ops = ops;

	zpool->evictable = driver->shrink && ops && ops->evict;

	zpool->can_sleep_mapped = driver->sleep_mapped;



	if (!zpool->pool) {

		pr_err("couldn't create %s pool\n", type);
@@ -380,7 +374,7 @@ u64 zpool_get_total_size(struct zpool *zpool) 
 */

bool zpool_evictable(struct zpool *zpool)

{

	return zpool->evictable;

	return zpool->driver->shrink;

}



/**
@@ -398,7 +392,7 @@ bool zpool_evictable(struct zpool *zpool) 
 */

bool zpool_can_sleep_mapped(struct zpool *zpool)

{

	return zpool->can_sleep_mapped;

	return zpool->driver->sleep_mapped;

}



MODULE_LICENSE("GPL");