Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9c3760eb authored by Yu Zhao's avatar Yu Zhao Committed by Linus Torvalds
Browse files

zswap: only save zswap header when necessary 

We waste sizeof(swp_entry_t) for zswap header when using zsmalloc as
zpool driver because zsmalloc doesn't support eviction.

Add zpool_evictable() to detect if zpool is potentially evictable, and
use it in zswap to avoid waste memory for zswap header.

[yuzhao@google.com: The zpool->" prefix is a result of copy & paste]
  Link: http://lkml.kernel.org/r/20180110225626.110330-1-yuzhao@google.com
Link: http://lkml.kernel.org/r/20180110224741.83751-1-yuzhao@google.com


Signed-off-by: default avatarYu Zhao <yuzhao@google.com>
Acked-by: default avatarDan Streetman <ddstreet@ieee.org>
Reviewed-by: default avatarSergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Seth Jennings <sjenning@redhat.com>
Cc: Minchan Kim <minchan@kernel.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent a7ab400d

include/linux/zpool.h

+2 −0
Original line number Diff line number Diff line
@@ -108,4 +108,6 @@ void zpool_register_driver(struct zpool_driver *driver); 


int zpool_unregister_driver(struct zpool_driver *driver);



bool zpool_evictable(struct zpool *pool);



#endif

mm/zpool.c

+23 −2
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ struct zpool { 
	struct zpool_driver *driver;

	void *pool;

	const struct zpool_ops *ops;

	bool evictable;



	struct list_head list;

};
@@ -142,7 +143,7 @@ EXPORT_SYMBOL(zpool_has_pool); 
 *

 * 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

 * ops param is NULL, then the created zpool will not be shrinkable.

 * ops param is NULL, then the created zpool will not be evictable.

 *

 * Implementations must guarantee this to be thread-safe.

 *
@@ -180,6 +181,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->ops = ops;

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



	if (!zpool->pool) {

		pr_err("couldn't create %s pool\n", type);
@@ -296,7 +298,8 @@ void zpool_free(struct zpool *zpool, unsigned long handle) 
int zpool_shrink(struct zpool *zpool, unsigned int pages,

			unsigned int *reclaimed)

{

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

	return zpool->driver->shrink ?

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

}



/**
@@ -355,6 +358,24 @@ u64 zpool_get_total_size(struct zpool *zpool) 
	return zpool->driver->total_size(zpool->pool);

}



/**

 * zpool_evictable() - Test if zpool is potentially evictable

 * @pool	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->evictable;

}



MODULE_LICENSE("GPL");

MODULE_AUTHOR("Dan Streetman <ddstreet@ieee.org>");

MODULE_DESCRIPTION("Common API for compressed memory storage");

mm/zsmalloc.c

+0 −7
Original line number Diff line number Diff line
@@ -404,12 +404,6 @@ static void zs_zpool_free(void *pool, unsigned long handle) 
	zs_free(pool, handle);

}



static int zs_zpool_shrink(void *pool, unsigned int pages,

			unsigned int *reclaimed)

{

	return -EINVAL;

}



static void *zs_zpool_map(void *pool, unsigned long handle,

			enum zpool_mapmode mm)

{
@@ -447,7 +441,6 @@ static struct zpool_driver zs_zpool_driver = { 
	.destroy =	zs_zpool_destroy,

	.malloc =	zs_zpool_malloc,

	.free =		zs_zpool_free,

	.shrink =	zs_zpool_shrink,

	.map =		zs_zpool_map,

	.unmap =	zs_zpool_unmap,

	.total_size =	zs_zpool_total_size,

mm/zswap.c

+10 −10
Original line number Diff line number Diff line
@@ -1001,11 +1001,11 @@ static int zswap_frontswap_store(unsigned type, pgoff_t offset, 
	struct zswap_entry *entry, *dupentry;

	struct crypto_comp *tfm;

	int ret;

	unsigned int dlen = PAGE_SIZE, len;

	unsigned int hlen, dlen = PAGE_SIZE;

	unsigned long handle, value;

	char *buf;

	u8 *src, *dst;

	struct zswap_header *zhdr;

	struct zswap_header zhdr = { .swpentry = swp_entry(type, offset) };



	if (!zswap_enabled || !tree) {

		ret = -ENODEV;
@@ -1063,8 +1063,8 @@ static int zswap_frontswap_store(unsigned type, pgoff_t offset, 
	}



	/* store */

	len = dlen + sizeof(struct zswap_header);

	ret = zpool_malloc(entry->pool->zpool, len,

	hlen = zpool_evictable(entry->pool->zpool) ? sizeof(zhdr) : 0;

	ret = zpool_malloc(entry->pool->zpool, hlen + dlen,

			   __GFP_NORETRY | __GFP_NOWARN | __GFP_KSWAPD_RECLAIM,

			   &handle);

	if (ret == -ENOSPC) {
@@ -1075,10 +1075,9 @@ static int zswap_frontswap_store(unsigned type, pgoff_t offset, 
		zswap_reject_alloc_fail++;

		goto put_dstmem;

	}

	zhdr = zpool_map_handle(entry->pool->zpool, handle, ZPOOL_MM_RW);

	zhdr->swpentry = swp_entry(type, offset);

	buf = (u8 *)(zhdr + 1);

	memcpy(buf, dst, dlen);

	buf = zpool_map_handle(entry->pool->zpool, handle, ZPOOL_MM_RW);

	memcpy(buf, &zhdr, hlen);

	memcpy(buf + hlen, dst, dlen);

	zpool_unmap_handle(entry->pool->zpool, handle);

	put_cpu_var(zswap_dstmem);
@@ -1149,8 +1148,9 @@ static int zswap_frontswap_load(unsigned type, pgoff_t offset, 


	/* decompress */

	dlen = PAGE_SIZE;

	src = (u8 *)zpool_map_handle(entry->pool->zpool, entry->handle,

			ZPOOL_MM_RO) + sizeof(struct zswap_header);

	src = zpool_map_handle(entry->pool->zpool, entry->handle, ZPOOL_MM_RO);

	if (zpool_evictable(entry->pool->zpool))

		src += sizeof(struct zswap_header);

	dst = kmap_atomic(page);

	tfm = *get_cpu_ptr(entry->pool->tfm);

	ret = crypto_comp_decompress(tfm, src, entry->length, dst, &dlen);