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: Sergey Senozhatsky <senozhatsky@chromium.org> Signed-off-by: Johannes Weiner <hannes@cmpxchg.org> Signed-off-by: Nhat 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: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
Johannes Weiner
Andrew Morton
parent
6b3379e8dc
commit
6a05aa3010
36
mm/z3fold.c
36
mm/z3fold.c
|
|
@ -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 @@ out_fail:
|
|||
* 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;
|
||||
|
|
|
|||
32
mm/zbud.c
32
mm/zbud.c
|
|
@ -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;
|
||||
|
|
|
|||
10
mm/zpool.c
10
mm/zpool.c
|
|
@ -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");
|
||||
|
|
|
|||
Loading…
Reference in New Issue