zswap: only save zswap header when necessary (9c3760eb) · Commits · 戴 / test

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);

Admin message