Commit 35499e2b authored by Domenico Cerasuolo's avatar Domenico Cerasuolo Committed by Andrew Morton
Browse files

mm: zswap: remove shrink from zpool interface 

Now that all three zswap backends have removed their shrink code, it is
no longer necessary for the zpool interface to include shrink/writeback
endpoints.

Link: https://lkml.kernel.org/r/20230612093815.133504-6-cerasuolodomenico@gmail.com


Signed-off-by: default avatarDomenico Cerasuolo <cerasuolodomenico@gmail.com>
Reviewed-by: default avatarYosry Ahmed <yosryahmed@google.com>
Acked-by: default avatarNhat Pham <nphamcs@gmail.com>
Acked-by: default avatarJohannes Weiner <hannes@cmpxchg.org>
Reviewed-by: default avatarSergey Senozhatsky <senozhatsky@chromium.org>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Minchan Kim <minchan@kernel.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 b3067742

include/linux/zpool.h

+2 −18
Original line number Diff line number Diff line
@@ -14,10 +14,6 @@ 


struct zpool;



struct zpool_ops {

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

};



/*

 * Control how a handle is mapped.  It will be ignored if the

 * implementation does not support it.  Its use is optional.
@@ -39,8 +35,7 @@ enum zpool_mapmode { 


bool zpool_has_pool(char *type);



struct zpool *zpool_create_pool(const char *type, const char *name,

			gfp_t gfp, const struct zpool_ops *ops);

struct zpool *zpool_create_pool(const char *type, const char *name, gfp_t gfp);



const char *zpool_get_type(struct zpool *pool);
@@ -53,9 +48,6 @@ int zpool_malloc(struct zpool *pool, size_t size, gfp_t gfp, 


void zpool_free(struct zpool *pool, unsigned long handle);



int zpool_shrink(struct zpool *pool, unsigned int pages,

			unsigned int *reclaimed);



void *zpool_map_handle(struct zpool *pool, unsigned long handle,

			enum zpool_mapmode mm);
@@ -72,7 +64,6 @@ u64 zpool_get_total_size(struct zpool *pool); 
 * @destroy:	destroy a pool.

 * @malloc:	allocate mem from a pool.

 * @free:	free mem from a pool.

 * @shrink:	shrink the pool.

 * @sleep_mapped: whether zpool driver can sleep during map.

 * @map:	map a handle.

 * @unmap:	unmap a handle.
@@ -87,10 +78,7 @@ struct zpool_driver { 
	atomic_t refcount;

	struct list_head list;



	void *(*create)(const char *name,

			gfp_t gfp,

			const struct zpool_ops *ops,

			struct zpool *zpool);

	void *(*create)(const char *name, gfp_t gfp);

	void (*destroy)(void *pool);



	bool malloc_support_movable;
@@ -98,9 +86,6 @@ struct zpool_driver { 
				unsigned long *handle);

	void (*free)(void *pool, unsigned long handle);



	int (*shrink)(void *pool, unsigned int pages,

				unsigned int *reclaimed);



	bool sleep_mapped;

	void *(*map)(void *pool, unsigned long handle,

				enum zpool_mapmode mm);
@@ -113,7 +98,6 @@ void zpool_register_driver(struct zpool_driver *driver); 


int zpool_unregister_driver(struct zpool_driver *driver);



bool zpool_evictable(struct zpool *pool);

bool zpool_can_sleep_mapped(struct zpool *pool);



#endif

mm/z3fold.c

+1 −3
Original line number Diff line number Diff line
@@ -1364,9 +1364,7 @@ static const struct movable_operations z3fold_mops = { 
 * zpool

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



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

			       const struct zpool_ops *zpool_ops,

			       struct zpool *zpool)

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

{

	return z3fold_create_pool(name, gfp);

}

mm/zbud.c

+1 −3
Original line number Diff line number Diff line
@@ -380,9 +380,7 @@ static u64 zbud_get_pool_size(struct zbud_pool *pool) 
 * zpool

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



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

			       const struct zpool_ops *zpool_ops,

			       struct zpool *zpool)

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

{

	return zbud_create_pool(gfp);

}

mm/zpool.c

+2 −46
Original line number Diff line number Diff line
@@ -133,7 +133,6 @@ EXPORT_SYMBOL(zpool_has_pool); 
 * @type:	The type of the zpool to create (e.g. zbud, zsmalloc)

 * @name:	The name of the zpool (e.g. zram0, zswap)

 * @gfp:	The GFP flags to use when allocating the pool.

 * @ops:	The optional ops callback.

 *

 * This creates a new zpool of the specified type.  The gfp flags will be

 * used when allocating memory, if the implementation supports it.  If the
@@ -145,8 +144,7 @@ EXPORT_SYMBOL(zpool_has_pool); 
 *

 * Returns: New zpool on success, NULL on failure.

 */

struct zpool *zpool_create_pool(const char *type, const char *name, gfp_t gfp,

		const struct zpool_ops *ops)

struct zpool *zpool_create_pool(const char *type, const char *name, gfp_t gfp)

{

	struct zpool_driver *driver;

	struct zpool *zpool;
@@ -173,7 +171,7 @@ 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->pool = driver->create(name, gfp);



	if (!zpool->pool) {

		pr_err("couldn't create %s pool\n", type);
@@ -279,30 +277,6 @@ void zpool_free(struct zpool *zpool, unsigned long handle) 
	zpool->driver->free(zpool->pool, handle);

}



/**

 * zpool_shrink() - Shrink the pool size

 * @zpool:	The zpool to shrink.

 * @pages:	The number of pages to shrink the pool.

 * @reclaimed:	The number of pages successfully evicted.

 *

 * This attempts to shrink the actual memory size of the pool

 * by evicting currently used handle(s).  If the pool was

 * created with no zpool_ops, or the evict call fails for any

 * of the handles, this will fail.  If non-NULL, the @reclaimed

 * parameter will be set to the number of pages reclaimed,

 * which may be more than the number of pages requested.

 *

 * Implementations must guarantee this to be thread-safe.

 *

 * Returns: 0 on success, negative value on error/failure.

 */

int zpool_shrink(struct zpool *zpool, unsigned int pages,

			unsigned int *reclaimed)

{

	return zpool->driver->shrink ?

	       zpool->driver->shrink(zpool->pool, pages, reclaimed) : -EINVAL;

}



/**

 * zpool_map_handle() - Map a previously allocated handle into memory

 * @zpool:	The zpool that the handle was allocated from
@@ -359,24 +333,6 @@ u64 zpool_get_total_size(struct zpool *zpool) 
	return zpool->driver->total_size(zpool->pool);

}



/**

 * zpool_evictable() - Test if zpool is potentially evictable

 * @zpool:	The zpool to test

 *

 * Zpool is only potentially evictable when it's created with struct

 * zpool_ops.evict and its driver implements struct zpool_driver.shrink.

 *

 * However, it doesn't necessarily mean driver will use zpool_ops.evict

 * in its implementation of zpool_driver.shrink. It could do internal

 * defragmentation instead.

 *

 * Returns: true if potentially evictable; false otherwise.

 */

bool zpool_evictable(struct zpool *zpool)

{

	return zpool->driver->shrink;

}



/**

 * zpool_can_sleep_mapped - Test if zpool can sleep when do mapped.

 * @zpool:	The zpool to test

mm/zsmalloc.c

+1 −3
Original line number Diff line number Diff line
@@ -351,9 +351,7 @@ static void record_obj(unsigned long handle, unsigned long obj) 


#ifdef CONFIG_ZPOOL



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

			     const struct zpool_ops *zpool_ops,

			     struct zpool *zpool)

static void *zs_zpool_create(const char *name, gfp_t gfp)

{

	/*

	 * Ignore global gfp flags: zs_malloc() may be invoked from