From nobody Mon Apr 6 17:08:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6C7F6C6FA86 for ; Mon, 5 Sep 2022 08:23:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236939AbiIEIXh (ORCPT ); Mon, 5 Sep 2022 04:23:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44780 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235793AbiIEIXe (ORCPT ); Mon, 5 Sep 2022 04:23:34 -0400 Received: from mail-pg1-x52d.google.com (mail-pg1-x52d.google.com [IPv6:2607:f8b0:4864:20::52d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0009431DFE for ; Mon, 5 Sep 2022 01:23:32 -0700 (PDT) Received: by mail-pg1-x52d.google.com with SMTP id t70so1693165pgc.5 for ; Mon, 05 Sep 2022 01:23:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=I2ruIR+eUek6TMRHPcruq5I+ZauP5l3LGhFsa5khFHo=; b=JiG1Df0pwfk7mK6N/jxlhWm0M0z0mOXOeoRBEvASwb6EK7YtuPkI27Rq2xglIN+VtU +nVGhLvH4eyFMuPrOUrCWi3Q1hC4JZwzuWyzurDbGKxw3A5IjHq87CMBf/gyrW7LU9bS lOjHkP/jU4+YyFYOFylSHrXH7goETnEgciETg= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=I2ruIR+eUek6TMRHPcruq5I+ZauP5l3LGhFsa5khFHo=; b=EAG45Qp7Y8IkiaFBR9gXDINlUAReVDCmXeemlVI7xYeCAsWuMqe1xTsTICJJA04Agn 76fXkdjzbFb0H/ABHSEgDiyHKq3loj1d0iM985kqdwUVq70DuX5TIXDwh+2lO7l0D38r BSETZjZry5dcVGPjpDcMmqFj5wD0i9zqd1A8orrEae9jMS34YtfrrMgxPM+zwcWgx1Ii oDBmaAq6JBx6gpV8Liw7Y0/AeB//dgYkScIytsns/acFI/Ee8+8HuDiO6e8C5CCQTMos NsdLW7ufk/CFYugqyqQyy0wgXx8Xq+8wVxLqD/GkEcKCQyfRleSo+IfFG/vyg9Py8FL9 MP7g== X-Gm-Message-State: ACgBeo1eCJGX5JH2ZDclKS5iC7aDk3TnUbHhozdhJVwjPqyiBzPDBM+f h1kNioL6KKR1AC5UkOkPKh8VHQ== X-Google-Smtp-Source: AA6agR5xP0qb+Cdg/AttC8eGwZRrpPmdJkJKWBftIG6lIEfHEHnSH/0nD//J42SoXMOC441QvDUdBA== X-Received: by 2002:a62:ea14:0:b0:535:c678:8106 with SMTP id t20-20020a62ea14000000b00535c6788106mr49550293pfh.9.1662366212331; Mon, 05 Sep 2022 01:23:32 -0700 (PDT) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:71e2:8444:42d9:4bb0]) by smtp.gmail.com with ESMTPSA id p14-20020a170902e74e00b001641b2d61d4sm6807093plf.30.2022.09.05.01.23.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Sep 2022 01:23:31 -0700 (PDT) From: Sergey Senozhatsky To: Minchan Kim , Andrew Morton Cc: Nitin Gupta , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Sergey Senozhatsky Subject: [PATCH RFC 1/7] zram: Preparation for multi-zcomp support Date: Mon, 5 Sep 2022 17:23:17 +0900 Message-Id: <20220905082323.2742399-2-senozhatsky@chromium.org> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog In-Reply-To: <20220905082323.2742399-1-senozhatsky@chromium.org> References: <20220905082323.2742399-1-senozhatsky@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The patch turns compression streams and compressor algorithm name struct zram members into arrays, so that we can have multiple compression streams support (in the next patches). The patch uses a rather explicit API for compressor selection: - Get primary (default) compression stream zcomp_stream_get(zram->comps[ZRAM_PRIMARY_ZCOMP]) - Get secondary compression stream zcomp_stream_get(zram->comps[ZRAM_SECONDARY_ZCOMP]) We use similar API for compression streams put(). At this point we always have just one compression stream, since CONFIG_ZRAM_MULTI_COMP is not yet defined. Signed-off-by: Sergey Senozhatsky --- drivers/block/zram/zcomp.c | 6 +-- drivers/block/zram/zcomp.h | 2 +- drivers/block/zram/zram_drv.c | 87 ++++++++++++++++++++++++----------- drivers/block/zram/zram_drv.h | 14 +++++- 4 files changed, 77 insertions(+), 32 deletions(-) diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c index 0916de952e09..55af4efd7983 100644 --- a/drivers/block/zram/zcomp.c +++ b/drivers/block/zram/zcomp.c @@ -206,7 +206,7 @@ void zcomp_destroy(struct zcomp *comp) * case of allocation error, or any other error potentially * returned by zcomp_init(). */ -struct zcomp *zcomp_create(const char *compress) +struct zcomp *zcomp_create(const char *alg) { struct zcomp *comp; int error; @@ -216,14 +216,14 @@ struct zcomp *zcomp_create(const char *compress) * is not loaded yet. We must do it here, otherwise we are about to * call /sbin/modprobe under CPU hot-plug lock. */ - if (!zcomp_available_algorithm(compress)) + if (!zcomp_available_algorithm(alg)) return ERR_PTR(-EINVAL); =20 comp =3D kzalloc(sizeof(struct zcomp), GFP_KERNEL); if (!comp) return ERR_PTR(-ENOMEM); =20 - comp->name =3D compress; + comp->name =3D alg; error =3D zcomp_init(comp); if (error) { kfree(comp); diff --git a/drivers/block/zram/zcomp.h b/drivers/block/zram/zcomp.h index 40f6420f4b2e..cdefdef93da8 100644 --- a/drivers/block/zram/zcomp.h +++ b/drivers/block/zram/zcomp.h @@ -27,7 +27,7 @@ int zcomp_cpu_dead(unsigned int cpu, struct hlist_node *n= ode); ssize_t zcomp_available_show(const char *comp, char *buf); bool zcomp_available_algorithm(const char *comp); =20 -struct zcomp *zcomp_create(const char *comp); +struct zcomp *zcomp_create(const char *alg); void zcomp_destroy(struct zcomp *comp); =20 struct zcomp_strm *zcomp_stream_get(struct zcomp *comp); diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 607f4634c27d..4ad1daa1283e 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -1018,36 +1018,53 @@ static ssize_t comp_algorithm_show(struct device *d= ev, struct zram *zram =3D dev_to_zram(dev); =20 down_read(&zram->init_lock); - sz =3D zcomp_available_show(zram->compressor, buf); + sz =3D zcomp_available_show(zram->comp_algs[ZRAM_PRIMARY_ZCOMP], buf); up_read(&zram->init_lock); =20 return sz; } =20 +static void comp_algorithm_set(struct zram *zram, u32 idx, const char *alg) +{ + /* Do not kfree() algs that we didn't allocate, IOW the default ones */ + if (zram->comp_algs[idx] !=3D default_compressor) + kfree(zram->comp_algs[idx]); + zram->comp_algs[idx] =3D alg; +} + static ssize_t comp_algorithm_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct zram *zram =3D dev_to_zram(dev); - char compressor[ARRAY_SIZE(zram->compressor)]; + char *compressor; size_t sz; =20 - strlcpy(compressor, buf, sizeof(compressor)); + sz =3D strlen(buf); + if (sz >=3D CRYPTO_MAX_ALG_NAME) + return -E2BIG; + + compressor =3D kstrdup(buf, GFP_KERNEL); + if (!compressor) + return -ENOMEM; + /* ignore trailing newline */ - sz =3D strlen(compressor); if (sz > 0 && compressor[sz - 1] =3D=3D '\n') compressor[sz - 1] =3D 0x00; =20 - if (!zcomp_available_algorithm(compressor)) + if (!zcomp_available_algorithm(compressor)) { + kfree(compressor); return -EINVAL; + } =20 down_write(&zram->init_lock); if (init_done(zram)) { up_write(&zram->init_lock); + kfree(compressor); pr_info("Can't change algorithm for initialized device\n"); return -EBUSY; } =20 - strcpy(zram->compressor, compressor); + comp_algorithm_set(zram, ZRAM_PRIMARY_ZCOMP, compressor); up_write(&zram->init_lock); return len; } @@ -1292,7 +1309,7 @@ static int __zram_bvec_read(struct zram *zram, struct= page *page, u32 index, size =3D zram_get_obj_size(zram, index); =20 if (size !=3D PAGE_SIZE) - zstrm =3D zcomp_stream_get(zram->comp); + zstrm =3D zcomp_stream_get(zram->comps[ZRAM_PRIMARY_ZCOMP]); =20 src =3D zs_map_object(zram->mem_pool, handle, ZS_MM_RO); if (size =3D=3D PAGE_SIZE) { @@ -1304,7 +1321,7 @@ static int __zram_bvec_read(struct zram *zram, struct= page *page, u32 index, dst =3D kmap_atomic(page); ret =3D zcomp_decompress(zstrm, src, size, dst); kunmap_atomic(dst); - zcomp_stream_put(zram->comp); + zcomp_stream_put(zram->comps[ZRAM_PRIMARY_ZCOMP]); } zs_unmap_object(zram->mem_pool, handle); zram_slot_unlock(zram, index); @@ -1371,13 +1388,13 @@ static int __zram_bvec_write(struct zram *zram, str= uct bio_vec *bvec, kunmap_atomic(mem); =20 compress_again: - zstrm =3D zcomp_stream_get(zram->comp); + zstrm =3D zcomp_stream_get(zram->comps[ZRAM_PRIMARY_ZCOMP]); src =3D kmap_atomic(page); ret =3D zcomp_compress(zstrm, src, &comp_len); kunmap_atomic(src); =20 if (unlikely(ret)) { - zcomp_stream_put(zram->comp); + zcomp_stream_put(zram->comps[ZRAM_PRIMARY_ZCOMP]); pr_err("Compression failed! err=3D%d\n", ret); zs_free(zram->mem_pool, handle); return ret; @@ -1405,7 +1422,7 @@ static int __zram_bvec_write(struct zram *zram, struc= t bio_vec *bvec, __GFP_HIGHMEM | __GFP_MOVABLE); if (IS_ERR((void *)handle)) { - zcomp_stream_put(zram->comp); + zcomp_stream_put(zram->comps[ZRAM_PRIMARY_ZCOMP]); atomic64_inc(&zram->stats.writestall); handle =3D zs_malloc(zram->mem_pool, comp_len, GFP_NOIO | __GFP_HIGHMEM | @@ -1422,14 +1439,14 @@ static int __zram_bvec_write(struct zram *zram, str= uct bio_vec *bvec, * It is necessary that the dereferencing of the zstrm variable below * occurs correctly. */ - zstrm =3D zcomp_stream_get(zram->comp); + zstrm =3D zcomp_stream_get(zram->comps[ZRAM_PRIMARY_ZCOMP]); } =20 alloced_pages =3D zs_get_total_pages(zram->mem_pool); update_used_max(zram, alloced_pages); =20 if (zram->limit_pages && alloced_pages > zram->limit_pages) { - zcomp_stream_put(zram->comp); + zcomp_stream_put(zram->comps[ZRAM_PRIMARY_ZCOMP]); zs_free(zram->mem_pool, handle); return -ENOMEM; } @@ -1443,7 +1460,7 @@ static int __zram_bvec_write(struct zram *zram, struc= t bio_vec *bvec, if (comp_len =3D=3D PAGE_SIZE) kunmap_atomic(src); =20 - zcomp_stream_put(zram->comp); + zcomp_stream_put(zram->comps[ZRAM_PRIMARY_ZCOMP]); zs_unmap_object(zram->mem_pool, handle); atomic64_add(comp_len, &zram->stats.compr_data_size); out: @@ -1718,6 +1735,20 @@ static int zram_rw_page(struct block_device *bdev, s= ector_t sector, return ret; } =20 +static void zram_destroy_comps(struct zram *zram) +{ + u32 idx; + + for (idx =3D 0; idx < ZRAM_MAX_ZCOMPS; idx++) { + struct zcomp *comp =3D zram->comps[idx]; + + zram->comps[idx] =3D NULL; + if (IS_ERR_OR_NULL(comp)) + continue; + zcomp_destroy(comp); + } +} + static void zram_reset_device(struct zram *zram) { down_write(&zram->init_lock); @@ -1735,11 +1766,11 @@ static void zram_reset_device(struct zram *zram) /* I/O operation under all of CPU are done so let's free */ zram_meta_free(zram, zram->disksize); zram->disksize =3D 0; + zram_destroy_comps(zram); memset(&zram->stats, 0, sizeof(zram->stats)); - zcomp_destroy(zram->comp); - zram->comp =3D NULL; reset_bdev(zram); =20 + comp_algorithm_set(zram, ZRAM_PRIMARY_ZCOMP, default_compressor); up_write(&zram->init_lock); } =20 @@ -1750,6 +1781,7 @@ static ssize_t disksize_store(struct device *dev, struct zcomp *comp; struct zram *zram =3D dev_to_zram(dev); int err; + u32 idx; =20 disksize =3D memparse(buf, NULL); if (!disksize) @@ -1768,22 +1800,25 @@ static ssize_t disksize_store(struct device *dev, goto out_unlock; } =20 - comp =3D zcomp_create(zram->compressor); - if (IS_ERR(comp)) { - pr_err("Cannot initialise %s compressing backend\n", - zram->compressor); - err =3D PTR_ERR(comp); - goto out_free_meta; - } + for (idx =3D 0; idx < ZRAM_MAX_ZCOMPS; idx++) { + comp =3D zcomp_create(zram->comp_algs[idx]); + if (IS_ERR(comp)) { + pr_err("Cannot initialise %s compressing backend\n", + zram->comp_algs[idx]); + err =3D PTR_ERR(comp); + goto out_free_comps; + } =20 - zram->comp =3D comp; + zram->comps[idx] =3D comp; + } zram->disksize =3D disksize; set_capacity_and_notify(zram->disk, zram->disksize >> SECTOR_SHIFT); up_write(&zram->init_lock); =20 return len; =20 -out_free_meta: +out_free_comps: + zram_destroy_comps(zram); zram_meta_free(zram, disksize); out_unlock: up_write(&zram->init_lock); @@ -1979,7 +2014,7 @@ static int zram_add(void) if (ret) goto out_cleanup_disk; =20 - strlcpy(zram->compressor, default_compressor, sizeof(zram->compressor)); + zram->comp_algs[ZRAM_PRIMARY_ZCOMP] =3D default_compressor; =20 zram_debugfs_register(zram); pr_info("Added device: %s\n", zram->disk->disk_name); diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h index 80c3b43b4828..af3d6f6bfcff 100644 --- a/drivers/block/zram/zram_drv.h +++ b/drivers/block/zram/zram_drv.h @@ -90,10 +90,20 @@ struct zram_stats { #endif }; =20 +#ifdef CONFIG_ZRAM_MULTI_COMP +#define ZRAM_PRIMARY_ZCOMP 0 +#define ZRAM_SECONDARY_ZCOMP 1 +#define ZRAM_MAX_ZCOMPS 2 +#else +#define ZRAM_PRIMARY_ZCOMP 0 +#define ZRAM_SECONDARY_ZCOMP 0 +#define ZRAM_MAX_ZCOMPS 1 +#endif + struct zram { struct zram_table_entry *table; struct zs_pool *mem_pool; - struct zcomp *comp; + struct zcomp *comps[ZRAM_MAX_ZCOMPS]; struct gendisk *disk; /* Prevent concurrent execution of device init */ struct rw_semaphore init_lock; @@ -108,7 +118,7 @@ struct zram { * we can store in a disk. */ u64 disksize; /* bytes */ - char compressor[CRYPTO_MAX_ALG_NAME]; + const char *comp_algs[ZRAM_MAX_ZCOMPS]; /* * zram is claimed so open request will be failed */ --=20 2.37.2.789.g6183377224-goog From nobody Mon Apr 6 17:08:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2CDB9ECAAA1 for ; Mon, 5 Sep 2022 08:24:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237494AbiIEIYD (ORCPT ); Mon, 5 Sep 2022 04:24:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44804 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236847AbiIEIXg (ORCPT ); Mon, 5 Sep 2022 04:23:36 -0400 Received: from mail-pl1-x633.google.com (mail-pl1-x633.google.com [IPv6:2607:f8b0:4864:20::633]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A13E032073 for ; Mon, 5 Sep 2022 01:23:35 -0700 (PDT) Received: by mail-pl1-x633.google.com with SMTP id t3so2773199ply.2 for ; Mon, 05 Sep 2022 01:23:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=osBqiJaYCcdSOMrgUz97U3jA0MdVQ300bRjV6yXUVIc=; b=Dj8l0GVOcH4FsUVnxL4tY09OuUF7plVKGT36GD2zseXqHCVAoWzqC2wyYGRnwKkNVu iBgy2FIh5hALHQRL0BZwivTaMCDPYseK+lZDWWS5Jzyy5wgDArZezc3vpw08Z1BCcI+N 9D4avvixlHeN3+YHVLR5hRRZkQnMwy742gYmU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=osBqiJaYCcdSOMrgUz97U3jA0MdVQ300bRjV6yXUVIc=; b=ulca21SdxbMJKcz8AXBcUXiR0JM0yZRaqNtMXF8SzKJJSc3l7+vw+w4fjltTnpRg9M EFDwmFjm0RIWvU23fWY5JxRZ+KLXtoVft1WcHAE6s+w1XFVm+BEBMQbbCDcSZCHrTQnZ DRCWsum+vqfjmJDTVJ/u0seA6pmpUA1/JGtRxsD2yH/MaWYRCNPt9Km1pF4Zo7eEkd0j RKI6XHIccudtnWKZXyqrYp51GG/7kGCePPI7YDWAXy4atDSs2BRjdrB2atv5TuHLBETl aSTPQ3DAtUe0nRUN5Vp8nYlKPc55cireERZC4q1uoGqjHjMpU91a4NMi23m170UBmIvE RSAw== X-Gm-Message-State: ACgBeo3k5Qs812hKbqD0i6OF0wV5vuz4YNzggyRLuiK6hM+iQumlTiPt PCD+sHsfHpATMAdzEooW+bPb0knYHwxTTA== X-Google-Smtp-Source: AA6agR7g8dFTB0VArIVTxGYq1Z4Rv7IOKVS5+1nZdI6tf1siXXlu2O6JpvShJE42fy847+SkNmM3Zw== X-Received: by 2002:a17:90b:4f45:b0:1f5:6554:d555 with SMTP id pj5-20020a17090b4f4500b001f56554d555mr18729225pjb.226.1662366215186; Mon, 05 Sep 2022 01:23:35 -0700 (PDT) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:71e2:8444:42d9:4bb0]) by smtp.gmail.com with ESMTPSA id p14-20020a170902e74e00b001641b2d61d4sm6807093plf.30.2022.09.05.01.23.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Sep 2022 01:23:34 -0700 (PDT) From: Sergey Senozhatsky To: Minchan Kim , Andrew Morton Cc: Nitin Gupta , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Sergey Senozhatsky Subject: [PATCH RFC 2/7] zram: Add recompression algorithm sysfs knob Date: Mon, 5 Sep 2022 17:23:18 +0900 Message-Id: <20220905082323.2742399-3-senozhatsky@chromium.org> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog In-Reply-To: <20220905082323.2742399-1-senozhatsky@chromium.org> References: <20220905082323.2742399-1-senozhatsky@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Introduce recomp_algorithm sysfs knob that controls secondary algorithm selection used for recompression. This device attribute works in a similar way with comp_algorithm attribute. Signed-off-by: Sergey Senozhatsky --- drivers/block/zram/zram_drv.c | 111 +++++++++++++++++++++++++++------- 1 file changed, 90 insertions(+), 21 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 4ad1daa1283e..694c8c426cb2 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -41,7 +41,12 @@ static DEFINE_IDR(zram_index_idr); static DEFINE_MUTEX(zram_index_mutex); =20 static int zram_major; -static const char *default_compressor =3D CONFIG_ZRAM_DEF_COMP; +static const char *default_comp_algs[ZRAM_MAX_ZCOMPS] =3D { + CONFIG_ZRAM_DEF_COMP, +#ifdef CONFIG_ZRAM_MULTI_COMP + "zstd", +#endif +}; =20 /* Module params (documentation at end) */ static unsigned int num_devices =3D 1; @@ -1011,31 +1016,37 @@ static ssize_t max_comp_streams_store(struct device= *dev, return len; } =20 -static ssize_t comp_algorithm_show(struct device *dev, - struct device_attribute *attr, char *buf) +static void comp_algorithm_set(struct zram *zram, u32 idx, const char *alg) { - size_t sz; - struct zram *zram =3D dev_to_zram(dev); + bool default_alg =3D false; + int i; =20 - down_read(&zram->init_lock); - sz =3D zcomp_available_show(zram->comp_algs[ZRAM_PRIMARY_ZCOMP], buf); - up_read(&zram->init_lock); + /* Do not kfree() algs that we didn't allocate, IOW the default ones */ + for (i =3D 0; i < ZRAM_MAX_ZCOMPS; i++) { + if (zram->comp_algs[idx] =3D=3D default_comp_algs[i]) { + default_alg =3D true; + break; + } + } =20 - return sz; + if (!default_alg) + kfree(zram->comp_algs[idx]); + zram->comp_algs[idx] =3D alg; } =20 -static void comp_algorithm_set(struct zram *zram, u32 idx, const char *alg) +static ssize_t __comp_algorithm_show(struct zram *zram, u32 idx, char *buf) { - /* Do not kfree() algs that we didn't allocate, IOW the default ones */ - if (zram->comp_algs[idx] !=3D default_compressor) - kfree(zram->comp_algs[idx]); - zram->comp_algs[idx] =3D alg; + ssize_t sz; + + down_read(&zram->init_lock); + sz =3D zcomp_available_show(zram->comp_algs[idx], buf); + up_read(&zram->init_lock); + + return sz; } =20 -static ssize_t comp_algorithm_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t len) +static int __comp_algorithm_store(struct zram *zram, u32 idx, const char *= buf) { - struct zram *zram =3D dev_to_zram(dev); char *compressor; size_t sz; =20 @@ -1064,11 +1075,55 @@ static ssize_t comp_algorithm_store(struct device *= dev, return -EBUSY; } =20 - comp_algorithm_set(zram, ZRAM_PRIMARY_ZCOMP, compressor); + comp_algorithm_set(zram, idx, compressor); up_write(&zram->init_lock); - return len; + return 0; +} + +static ssize_t comp_algorithm_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct zram *zram =3D dev_to_zram(dev); + + return __comp_algorithm_show(zram, ZRAM_PRIMARY_ZCOMP, buf); +} + +static ssize_t comp_algorithm_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t len) +{ + struct zram *zram =3D dev_to_zram(dev); + int ret; + + ret =3D __comp_algorithm_store(zram, ZRAM_PRIMARY_ZCOMP, buf); + return ret ? ret : len; } =20 +#ifdef CONFIG_ZRAM_MULTI_COMP +static ssize_t recomp_algorithm_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct zram *zram =3D dev_to_zram(dev); + + return __comp_algorithm_show(zram, ZRAM_SECONDARY_ZCOMP, buf); +} + +static ssize_t recomp_algorithm_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t len) +{ + struct zram *zram =3D dev_to_zram(dev); + int ret; + + ret =3D __comp_algorithm_store(zram, ZRAM_SECONDARY_ZCOMP, buf); + return ret ? ret : len; +} +#endif + static ssize_t compact_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { @@ -1770,7 +1825,11 @@ static void zram_reset_device(struct zram *zram) memset(&zram->stats, 0, sizeof(zram->stats)); reset_bdev(zram); =20 - comp_algorithm_set(zram, ZRAM_PRIMARY_ZCOMP, default_compressor); + comp_algorithm_set(zram, ZRAM_PRIMARY_ZCOMP, + default_comp_algs[ZRAM_PRIMARY_ZCOMP]); + if (IS_ENABLED(CONFIG_ZRAM_MULTI_COMP)) + comp_algorithm_set(zram, ZRAM_SECONDARY_ZCOMP, + default_comp_algs[ZRAM_SECONDARY_ZCOMP]); up_write(&zram->init_lock); } =20 @@ -1912,6 +1971,9 @@ static DEVICE_ATTR_WO(writeback); static DEVICE_ATTR_RW(writeback_limit); static DEVICE_ATTR_RW(writeback_limit_enable); #endif +#ifdef CONFIG_ZRAM_MULTI_COMP +static DEVICE_ATTR_RW(recomp_algorithm); +#endif =20 static struct attribute *zram_disk_attrs[] =3D { &dev_attr_disksize.attr, @@ -1935,6 +1997,9 @@ static struct attribute *zram_disk_attrs[] =3D { &dev_attr_bd_stat.attr, #endif &dev_attr_debug_stat.attr, +#ifdef CONFIG_ZRAM_MULTI_COMP + &dev_attr_recomp_algorithm.attr, +#endif NULL, }; =20 @@ -2014,7 +2079,11 @@ static int zram_add(void) if (ret) goto out_cleanup_disk; =20 - zram->comp_algs[ZRAM_PRIMARY_ZCOMP] =3D default_compressor; + zram->comp_algs[ZRAM_PRIMARY_ZCOMP] =3D + default_comp_algs[ZRAM_PRIMARY_ZCOMP]; + if (IS_ENABLED(CONFIG_ZRAM_MULTI_COMP)) + zram->comp_algs[ZRAM_SECONDARY_ZCOMP] =3D + default_comp_algs[ZRAM_SECONDARY_ZCOMP]; =20 zram_debugfs_register(zram); pr_info("Added device: %s\n", zram->disk->disk_name); --=20 2.37.2.789.g6183377224-goog From nobody Mon Apr 6 17:08:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8B52CECAAA1 for ; Mon, 5 Sep 2022 08:23:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237468AbiIEIX4 (ORCPT ); Mon, 5 Sep 2022 04:23:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44814 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237124AbiIEIXj (ORCPT ); Mon, 5 Sep 2022 04:23:39 -0400 Received: from mail-pj1-x1034.google.com (mail-pj1-x1034.google.com [IPv6:2607:f8b0:4864:20::1034]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E835C32BAD for ; Mon, 5 Sep 2022 01:23:38 -0700 (PDT) Received: by mail-pj1-x1034.google.com with SMTP id u9-20020a17090a1f0900b001fde6477464so11468698pja.4 for ; Mon, 05 Sep 2022 01:23:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=MkTg5zDd6KOHOk4vuhlZ6bZv6q468yLoqf3LP8Ucpys=; b=aBW0CzvUuC+9cpiQKHMHT4SxOa0dqdX9qcC0OeaH2oTG9UqvrH0ukdB3JZ7lmnZaK1 VdAc05X22+fwuejVr/A6GdinKG1g1K1SBS7ez9ArjHcla+rPv8ipxo8Yi9oPbQwCQgJv UU9+00W+8lN1ehv0b8sc1WMusT8LsTHOLvdtI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=MkTg5zDd6KOHOk4vuhlZ6bZv6q468yLoqf3LP8Ucpys=; b=O9xiXVJzl3KQrlyyw+UMrb7c5E+69cnVdQ6lpaOLhCnNsWeOCUZpH1fF+GInFc/s7l lgKigL0kl6jI7wG+VKvOHWSu3HzdH4Ozf9FIqJi6VNKfb0ebHWQo3oak2n9X9kmtMOhm VlFwsazfgyCDM3xiJzhazKqTJngC2nD910ODX9HAQhNfY/4pBJeJCBy2VpmSybKybYm0 W+8Pjk0PH6lLQlhq6eoMTCA/jxxlO1K6y2aMGEWCs2BKceP5GM/QJSUxU/wfVE1lhlTh dyd+9Mu4eS/3ICm8I373dHxUwbGQLMMvn59xEAtYpDG0cR3a7DsfGqfWwWXIwu3pvJt/ Zx/w== X-Gm-Message-State: ACgBeo0knC+6vgjPe4Iw0v6fZwEzTeJ2up6H6BI6o1cl/y1hgIyETUL7 ZfhKv+W2tL/NdZuEVC0WAM0oCA== X-Google-Smtp-Source: AA6agR4lNcvveVFlXXdtwEAmkiYZqSZRN9hbkPQmEKvUm6TBQRaHKnlN12fNUgikdMzmOnrz5ExqYg== X-Received: by 2002:a17:902:ab55:b0:176:8906:a3c5 with SMTP id ij21-20020a170902ab5500b001768906a3c5mr9869367plb.72.1662366217811; Mon, 05 Sep 2022 01:23:37 -0700 (PDT) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:71e2:8444:42d9:4bb0]) by smtp.gmail.com with ESMTPSA id p14-20020a170902e74e00b001641b2d61d4sm6807093plf.30.2022.09.05.01.23.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Sep 2022 01:23:37 -0700 (PDT) From: Sergey Senozhatsky To: Minchan Kim , Andrew Morton Cc: Nitin Gupta , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Sergey Senozhatsky Subject: [PATCH RFC 3/7] zram: Factor out WB and non-WB zram read functions Date: Mon, 5 Sep 2022 17:23:19 +0900 Message-Id: <20220905082323.2742399-4-senozhatsky@chromium.org> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog In-Reply-To: <20220905082323.2742399-1-senozhatsky@chromium.org> References: <20220905082323.2742399-1-senozhatsky@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" We will use non-WB variant in ZRAM page recompression path. Signed-off-by: Sergey Senozhatsky --- drivers/block/zram/zram_drv.c | 66 +++++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 19 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 694c8c426cb2..de2970865b7b 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -1325,8 +1325,33 @@ static void zram_free_page(struct zram *zram, size_t= index) ~(1UL << ZRAM_LOCK | 1UL << ZRAM_UNDER_WB)); } =20 -static int __zram_bvec_read(struct zram *zram, struct page *page, u32 inde= x, - struct bio *bio, bool partial_io) +/* + * Reads a page from the writeback devices. Corresponding ZRAM slot + * should be unlocked. + */ +static int zram_read_from_writeback(struct zram *zram, + struct page *page, + u32 index, + struct bio *bio, + bool partial_io) +{ + struct bio_vec bvec; + + bvec.bv_page =3D page; + bvec.bv_len =3D PAGE_SIZE; + bvec.bv_offset =3D 0; + return read_from_bdev(zram, &bvec, + zram_get_element(zram, index), + bio, partial_io); +} + +/* + * Reads (decompresses if needed) a page from zspool (zsmalloc). + * Corresponding ZRAM slot should be locked. + */ +static int zram_read_from_zspool(struct zram *zram, + struct page *page, + u32 index) { struct zcomp_strm *zstrm; unsigned long handle; @@ -1334,20 +1359,6 @@ static int __zram_bvec_read(struct zram *zram, struc= t page *page, u32 index, void *src, *dst; int ret; =20 - zram_slot_lock(zram, index); - if (zram_test_flag(zram, index, ZRAM_WB)) { - struct bio_vec bvec; - - zram_slot_unlock(zram, index); - - bvec.bv_page =3D page; - bvec.bv_len =3D PAGE_SIZE; - bvec.bv_offset =3D 0; - return read_from_bdev(zram, &bvec, - zram_get_element(zram, index), - bio, partial_io); - } - handle =3D zram_get_handle(zram, index); if (!handle || zram_test_flag(zram, index, ZRAM_SAME)) { unsigned long value; @@ -1357,7 +1368,6 @@ static int __zram_bvec_read(struct zram *zram, struct= page *page, u32 index, mem =3D kmap_atomic(page); zram_fill_page(mem, PAGE_SIZE, value); kunmap_atomic(mem); - zram_slot_unlock(zram, index); return 0; } =20 @@ -1379,7 +1389,25 @@ static int __zram_bvec_read(struct zram *zram, struc= t page *page, u32 index, zcomp_stream_put(zram->comps[ZRAM_PRIMARY_ZCOMP]); } zs_unmap_object(zram->mem_pool, handle); - zram_slot_unlock(zram, index); + return ret; +} + +static int __zram_bvec_read(struct zram *zram, struct page *page, u32 inde= x, + struct bio *bio, bool partial_io) +{ + int ret; + + zram_slot_lock(zram, index); + if (!zram_test_flag(zram, index, ZRAM_WB)) { + /* Slot should be locked through out the function call */ + ret =3D zram_read_from_zspool(zram, page, index); + zram_slot_unlock(zram, index); + } else { + /* Slot should be unlocked before the function call */ + zram_slot_unlock(zram, index); + ret =3D zram_read_from_writeback(zram, page, index, bio, + partial_io); + } =20 /* Should NEVER happen. Return bio error if it does. */ if (WARN_ON(ret)) @@ -1389,7 +1417,7 @@ static int __zram_bvec_read(struct zram *zram, struct= page *page, u32 index, } =20 static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec, - u32 index, int offset, struct bio *bio) + u32 index, int offset, struct bio *bio) { int ret; struct page *page; --=20 2.37.2.789.g6183377224-goog From nobody Mon Apr 6 17:08:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9A3FCECAAA1 for ; Mon, 5 Sep 2022 08:24:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237520AbiIEIYI (ORCPT ); Mon, 5 Sep 2022 04:24:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44838 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237323AbiIEIXm (ORCPT ); Mon, 5 Sep 2022 04:23:42 -0400 Received: from mail-pf1-x436.google.com (mail-pf1-x436.google.com [IPv6:2607:f8b0:4864:20::436]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2CAA532073 for ; Mon, 5 Sep 2022 01:23:41 -0700 (PDT) Received: by mail-pf1-x436.google.com with SMTP id y29so8021806pfq.0 for ; Mon, 05 Sep 2022 01:23:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=apGSrKTgwETbH2CMEGMydpnHgs87JcMdkEf7eiEN8iQ=; b=VRDy1szZ9nnuVMFP2jEsr44BTUpa7HJpnUeDpWZYq4+kd5uGGaAsO0gGm3+j61YLP5 sf5jIAhuKTmgCnCDUdFfPsMP4tFGusfPPuzHyUwaKElCJNtSasBKAuFq4k5PrSQRfgLQ ii9eg8V8vwqGeczBZcWzrUDfERA+n2T6GEUbA= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=apGSrKTgwETbH2CMEGMydpnHgs87JcMdkEf7eiEN8iQ=; b=MtADBVGGHK1m+0fddtk9BUOajjxDjS++ghtSQJw70Hug5V4Pl/qDwernZ8czGfm5vW K0o2vimM14abCTpbx3dvTfS9/WMV32DDl4eNo5+U8FnyjZ34d8hdfSVfkcwtIsEZOqY1 THmbBoYrYeFLJyqbMCrsFm8UzPqPpRX4nM5QsDqiDQqZWWH/q8DQDhYqa3eNWOQQvHGt eFzRdEsS7enn4DGsCsSa4zjGxojW5KFn4t8yW5oZxgzesBnLecfPZQ799OSbM8PPFKyk zMUpBLgXsnwt7F3IFegYQPgXluGMxMgOUvw2r+nX83Vm7taj3+9FNAbP9rXFWjIIhleq nwPA== X-Gm-Message-State: ACgBeo30KvNHG0EQOQITyXy5c9Z2jaiCcDUSvMLeNqZ8ARvdgla7NOsO X5scOIJSl9yanpadahzQIGGi+w== X-Google-Smtp-Source: AA6agR5+1trg1E9uYHkTVeFZhTHW7WWvLhizMSoy0I3OoqZ93WSRvvMs+OfOOqN9ywMTHwWypooTrA== X-Received: by 2002:a63:f74c:0:b0:42b:77c2:ce7c with SMTP id f12-20020a63f74c000000b0042b77c2ce7cmr40708150pgk.473.1662366220625; Mon, 05 Sep 2022 01:23:40 -0700 (PDT) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:71e2:8444:42d9:4bb0]) by smtp.gmail.com with ESMTPSA id p14-20020a170902e74e00b001641b2d61d4sm6807093plf.30.2022.09.05.01.23.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Sep 2022 01:23:40 -0700 (PDT) From: Sergey Senozhatsky To: Minchan Kim , Andrew Morton Cc: Nitin Gupta , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Sergey Senozhatsky Subject: [PATCH RFC 4/7] zram: Introduce recompress sysfs knob Date: Mon, 5 Sep 2022 17:23:20 +0900 Message-Id: <20220905082323.2742399-5-senozhatsky@chromium.org> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog In-Reply-To: <20220905082323.2742399-1-senozhatsky@chromium.org> References: <20220905082323.2742399-1-senozhatsky@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Allow zram to recompress (using secondary compression streams) pages. We support three modes: 1) IDLE pages recompression is activated by `idle` mode echo idle > /sys/block/zram0/recompress 2) Since there may be many idle pages user-space may pass a size watermark value and we will recompress IDLE pages only of equal or greater size: echo 888 > /sys/block/zram0/recompress 3) HUGE pages recompression is activated by `huge` mode echo huge > /sys/block/zram0/recompress 4) HUGE_IDLE pages recompression is activated by `huge_idle` mode echo huge_idle > /sys/block/zram0/recompress Signed-off-by: Sergey Senozhatsky --- drivers/block/zram/Kconfig | 11 ++ drivers/block/zram/zram_drv.c | 191 +++++++++++++++++++++++++++++++++- drivers/block/zram/zram_drv.h | 1 + 3 files changed, 200 insertions(+), 3 deletions(-) diff --git a/drivers/block/zram/Kconfig b/drivers/block/zram/Kconfig index d4100b0c083e..81ae4b96ec1a 100644 --- a/drivers/block/zram/Kconfig +++ b/drivers/block/zram/Kconfig @@ -78,3 +78,14 @@ config ZRAM_MEMORY_TRACKING /sys/kernel/debug/zram/zramX/block_state. =20 See Documentation/admin-guide/blockdev/zram.rst for more information. + +config ZRAM_MULTI_COMP + bool "Enable multiple per-CPU compression streams" + depends on ZRAM + help + This will enable per-CPU multi-compression streams, so that ZRAM + can re-compress IDLE pages, using a potentially slower but more + effective compression algorithm. + + echo TIMEOUT > /sys/block/zramX/idle + echo SIZE > /sys/block/zramX/recompress diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index de2970865b7b..386e49a13806 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -1293,6 +1293,9 @@ static void zram_free_page(struct zram *zram, size_t = index) atomic64_dec(&zram->stats.huge_pages); } =20 + if (zram_test_flag(zram, index, ZRAM_RECOMP)) + zram_clear_flag(zram, index, ZRAM_RECOMP); + if (zram_test_flag(zram, index, ZRAM_WB)) { zram_clear_flag(zram, index, ZRAM_WB); free_block_bdev(zram, zram_get_element(zram, index)); @@ -1357,6 +1360,7 @@ static int zram_read_from_zspool(struct zram *zram, unsigned long handle; unsigned int size; void *src, *dst; + u32 idx; int ret; =20 handle =3D zram_get_handle(zram, index); @@ -1373,8 +1377,13 @@ static int zram_read_from_zspool(struct zram *zram, =20 size =3D zram_get_obj_size(zram, index); =20 - if (size !=3D PAGE_SIZE) - zstrm =3D zcomp_stream_get(zram->comps[ZRAM_PRIMARY_ZCOMP]); + if (size !=3D PAGE_SIZE) { + idx =3D ZRAM_PRIMARY_ZCOMP; + if (zram_test_flag(zram, index, ZRAM_RECOMP)) + idx =3D ZRAM_SECONDARY_ZCOMP; + + zstrm =3D zcomp_stream_get(zram->comps[idx]); + } =20 src =3D zs_map_object(zram->mem_pool, handle, ZS_MM_RO); if (size =3D=3D PAGE_SIZE) { @@ -1386,7 +1395,7 @@ static int zram_read_from_zspool(struct zram *zram, dst =3D kmap_atomic(page); ret =3D zcomp_decompress(zstrm, src, size, dst); kunmap_atomic(dst); - zcomp_stream_put(zram->comps[ZRAM_PRIMARY_ZCOMP]); + zcomp_stream_put(zram->comps[idx]); } zs_unmap_object(zram->mem_pool, handle); return ret; @@ -1612,6 +1621,180 @@ static int zram_bvec_write(struct zram *zram, struc= t bio_vec *bvec, return ret; } =20 +#ifdef CONFIG_ZRAM_MULTI_COMP +/* + * This function will decompress (unless it's ZRAM_HUGE) the page and then + * attempt to compress it using secondary compression algorithm (which is + * potentially more effective). + * + * Corresponding ZRAM slot should be locked. + */ +static int zram_recompress(struct zram *zram, + u32 index, + struct page *page, + int size_watermark) +{ + unsigned long handle_prev; + unsigned long handle_next; + unsigned int comp_len_next; + unsigned int comp_len_prev; + struct zcomp_strm *zstrm; + void *src, *dst; + int ret; + + handle_prev =3D zram_get_handle(zram, index); + if (!handle_prev) + return -EINVAL; + + comp_len_prev =3D zram_get_obj_size(zram, index); + /* + * Do not recompress objects that are already "small enough". + */ + if (comp_len_prev < size_watermark) + return 0; + + ret =3D zram_read_from_zspool(zram, page, index); + if (ret) + return ret; + + zstrm =3D zcomp_stream_get(zram->comps[ZRAM_SECONDARY_ZCOMP]); + src =3D kmap_atomic(page); + ret =3D zcomp_compress(zstrm, src, &comp_len_next); + kunmap_atomic(src); + + /* + * Either a compression error or we failed to compressed the object + * in a way that will save us memory. Mark object as "recompressed" + * if it's huge, so that we don't try to recompress it again. Ideally + * we want to set some bit for all such objects, but we for now do so + * only for huge ones (we are out of bits in flags on 32-bit systems). + */ + if (comp_len_next >=3D huge_class_size || + comp_len_next >=3D comp_len_prev || + ret) { + if (zram_test_flag(zram, index, ZRAM_HUGE)) + zram_set_flag(zram, index, ZRAM_RECOMP); + zram_clear_flag(zram, index, ZRAM_IDLE); + zcomp_stream_put(zram->comps[ZRAM_SECONDARY_ZCOMP]); + return ret; + } + + /* + * No direct reclaim (slow path) for handle allocation and no + * re-compression attempt (unlike in __zram_bvec_write()) since + * we already stored that object in zsmalloc. If we cannot alloc + * memory then me bail out. + */ + handle_next =3D zs_malloc(zram->mem_pool, comp_len_next, + __GFP_KSWAPD_RECLAIM | + __GFP_NOWARN | + __GFP_HIGHMEM | + __GFP_MOVABLE); + if (IS_ERR((void *)handle_next)) { + zcomp_stream_put(zram->comps[ZRAM_SECONDARY_ZCOMP]); + return -ENOMEM; + } + + dst =3D zs_map_object(zram->mem_pool, handle_next, ZS_MM_WO); + memcpy(dst, zstrm->buffer, comp_len_next); + zcomp_stream_put(zram->comps[ZRAM_SECONDARY_ZCOMP]); + + zs_unmap_object(zram->mem_pool, handle_next); + + zram_free_page(zram, index); + zram_set_handle(zram, index, handle_next); + zram_set_obj_size(zram, index, comp_len_next); + + zram_set_flag(zram, index, ZRAM_RECOMP); + atomic64_add(comp_len_next, &zram->stats.compr_data_size); + atomic64_inc(&zram->stats.pages_stored); + + return 0; +} + +#define RECOMPRESS_IDLE (1 << 0) +#define RECOMPRESS_HUGE (1 << 1) + +static ssize_t recompress_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t len) +{ + struct zram *zram =3D dev_to_zram(dev); + unsigned long nr_pages =3D zram->disksize >> PAGE_SHIFT; + unsigned long index; + struct page *page; + ssize_t ret =3D 0; + int mode, size_watermark =3D 0; + + if (sysfs_streq(buf, "idle")) { + mode =3D RECOMPRESS_IDLE; + } else if (sysfs_streq(buf, "huge")) { + mode =3D RECOMPRESS_HUGE; + } else if (sysfs_streq(buf, "huge_idle")) { + mode =3D RECOMPRESS_IDLE | RECOMPRESS_HUGE; + } else { + /* + * We will re-compress only idle objects equal or greater + * in size than watermark. + */ + ret =3D kstrtoint(buf, 10, &size_watermark); + if (ret) + return ret; + mode =3D RECOMPRESS_IDLE; + } + + if (size_watermark > PAGE_SIZE) + return ret; + + down_read(&zram->init_lock); + if (!init_done(zram)) { + ret =3D -EINVAL; + goto release_init_lock; + } + + page =3D alloc_page(GFP_KERNEL); + if (!page) { + ret =3D -ENOMEM; + goto release_init_lock; + } + + for (index =3D 0; index < nr_pages; index++) { + zram_slot_lock(zram, index); + + if (!zram_allocated(zram, index)) + goto next; + + if (mode & RECOMPRESS_IDLE && + !zram_test_flag(zram, index, ZRAM_IDLE)) + goto next; + + if (mode & RECOMPRESS_HUGE && + !zram_test_flag(zram, index, ZRAM_HUGE)) + goto next; + + if (zram_test_flag(zram, index, ZRAM_WB) || + zram_test_flag(zram, index, ZRAM_UNDER_WB) || + zram_test_flag(zram, index, ZRAM_SAME) || + zram_test_flag(zram, index, ZRAM_RECOMP)) + goto next; + + ret =3D zram_recompress(zram, index, page, size_watermark); +next: + zram_slot_unlock(zram, index); + if (ret) + break; + } + + ret =3D len; + __free_page(page); + +release_init_lock: + up_read(&zram->init_lock); + return ret; +} +#endif + /* * zram_bio_discard - handler on discard request * @index: physical block index in PAGE_SIZE units @@ -2001,6 +2184,7 @@ static DEVICE_ATTR_RW(writeback_limit_enable); #endif #ifdef CONFIG_ZRAM_MULTI_COMP static DEVICE_ATTR_RW(recomp_algorithm); +static DEVICE_ATTR_WO(recompress); #endif =20 static struct attribute *zram_disk_attrs[] =3D { @@ -2027,6 +2211,7 @@ static struct attribute *zram_disk_attrs[] =3D { &dev_attr_debug_stat.attr, #ifdef CONFIG_ZRAM_MULTI_COMP &dev_attr_recomp_algorithm.attr, + &dev_attr_recompress.attr, #endif NULL, }; diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h index af3d6f6bfcff..b4eecef2a11f 100644 --- a/drivers/block/zram/zram_drv.h +++ b/drivers/block/zram/zram_drv.h @@ -50,6 +50,7 @@ enum zram_pageflags { ZRAM_UNDER_WB, /* page is under writeback */ ZRAM_HUGE, /* Incompressible page */ ZRAM_IDLE, /* not accessed page since last idle marking */ + ZRAM_RECOMP, /* page was recompressed */ =20 __NR_ZRAM_PAGEFLAGS, }; --=20 2.37.2.789.g6183377224-goog From nobody Mon Apr 6 17:08:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3BEFFECAAD5 for ; Mon, 5 Sep 2022 08:24:17 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237502AbiIEIYO (ORCPT ); Mon, 5 Sep 2022 04:24:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44868 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237411AbiIEIXq (ORCPT ); Mon, 5 Sep 2022 04:23:46 -0400 Received: from mail-pl1-x634.google.com (mail-pl1-x634.google.com [IPv6:2607:f8b0:4864:20::634]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1FED332BAD for ; Mon, 5 Sep 2022 01:23:46 -0700 (PDT) Received: by mail-pl1-x634.google.com with SMTP id x23so7845230pll.7 for ; Mon, 05 Sep 2022 01:23:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=ARMalt43cGQStsEP0fAYz16MOL60Ugpll7VhrHzWrN4=; b=AbhuZG4cLnD4jAtfo2ZO07aIOwcJJvwIZESzjpZ5Ee+82ZNdfngwPfiuw6v9PXi/eR /BxJ0orFnk5MpMZv+Y+LnbYJFKUzam+yFwSFhDCiAYDY6+eOU2UMsM9y+K0yq02gvGO5 3LeNv89oR7dUBGGFpFwPExYtdVrQijvYiu+Lo= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=ARMalt43cGQStsEP0fAYz16MOL60Ugpll7VhrHzWrN4=; b=WaqjuneOI+Gfb6Y/kKcC37JT9Wkf1PZSC0lIf63lQXnvA09iew9Im7c85sfEoZUv5t CZKaQMJM5QJiwYcr2pN8LR5hSkkk9JCNyNpdRJUe5BC53QP7dUPI+BAHFZ1ELjvWN5wt 4AqizSu8E7B30gmiaU/o5YgKe55uH4pvCm4N9DQsQ5tnrC0Q6gFzWqOIbuQ3LpxFnaE8 dmLglXQu22FfTCNLUTWl+1Zz7R1lffuVcm/8iB9eTCQsD4Pyg/GYoILUGIGmo8HNAMXe NEV2y7ihcbRw4LxW6s/yufXcPqdsYbS+0GsvGWo02CT4K6TtAc5VNTAzvnJWBt5p3pvS 1Jzw== X-Gm-Message-State: ACgBeo1KqFsOUCKnEP0FW9RrVOxb2PxSs6nQ6cBqkWis2gXnr2v4aW/Z ZT5DrL9gG/odDuRJb2pdHasDeA== X-Google-Smtp-Source: AA6agR6MdV0jQOWw7gPUNPTuBQ7N8UC1YJh59UXImF2+oeIhZoDkkXTWCLMASpJ6FNqJ5k4s2QvS5A== X-Received: by 2002:a17:90b:1652:b0:1fd:eca8:d2be with SMTP id il18-20020a17090b165200b001fdeca8d2bemr18456213pjb.79.1662366225603; Mon, 05 Sep 2022 01:23:45 -0700 (PDT) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:71e2:8444:42d9:4bb0]) by smtp.gmail.com with ESMTPSA id p14-20020a170902e74e00b001641b2d61d4sm6807093plf.30.2022.09.05.01.23.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Sep 2022 01:23:44 -0700 (PDT) From: Sergey Senozhatsky To: Minchan Kim , Andrew Morton Cc: Nitin Gupta , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Sergey Senozhatsky Subject: [PATCH RFC 5/7] documentation: Add recompression documentation Date: Mon, 5 Sep 2022 17:23:21 +0900 Message-Id: <20220905082323.2742399-6-senozhatsky@chromium.org> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog In-Reply-To: <20220905082323.2742399-1-senozhatsky@chromium.org> References: <20220905082323.2742399-1-senozhatsky@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Document user-space visible device attributes that are enabled by ZRAM_MULTI_COMP. Signed-off-by: Sergey Senozhatsky --- Documentation/admin-guide/blockdev/zram.rst | 55 +++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/Documentation/admin-guide/blockdev/zram.rst b/Documentation/ad= min-guide/blockdev/zram.rst index c73b16930449..88957fcb6ad7 100644 --- a/Documentation/admin-guide/blockdev/zram.rst +++ b/Documentation/admin-guide/blockdev/zram.rst @@ -401,6 +401,61 @@ budget in next setting is user's job. If admin wants to measure writeback count in a certain period, they could know it via /sys/block/zram0/bd_stat's 3rd column. =20 +recompression +------------- + +With CONFIG_ZRAM_MULTI_COMP, zram can recompress idle/huge pages using +alternative (secondary) compression algorithm. The basic idea is that +alternative compression algorithm can provide better compression ratio +at a price of (potentially) slower compression/decompression speeds. +Alternative compression algorithm can, for example, be more successful +compressing huge pages (those that default algorithm failed to compress). +Another application is idle pages recompression - pages that are cold and +sit in the memory can be recompressed using more effective algorithm and, +hence, reduce zsmalloc memory usage. + +With CONFIG_ZRAM_MULTI_COMP, zram will setup two compression algorithms +per-CPU: primary and secondary ones. Primary zram compressor is explained +in "3) Select compression algorithm", the secondary algorithm is configured +in a similar way, using recomp_algorithm device attribute: + +Examples:: + + #show supported recompression algorithms + cat /sys/block/zramX/recomp_algorithm + zstd [lzo] + + #select zstd recompression algorithm + echo zstd > /sys/block/zramX/recomp_algorithm + +Another device attribute that CONFIG_ZRAM_MULTI_COMP enables is recompress, +which controls recompression: + +Examples:: + + #IDLE pages recompression is activated by `idle` mode + echo idle > /sys/block/zramX/recompress + + #HUGE pages recompression is activated by `huge` mode + echo huge > /sys/block/zram0/recompress + + #HUGE_IDLE pages recompression is activated by `huge_idle` mode + echo huge_idle > /sys/block/zramX/recompress + +The number of idle pages can be significant, so user-space can pass a size +watermark value to the recompress knob, to filter out idle pages for +recompression: zram will recompress only idle pages of equal or greater +size::: + + #recompress idle pages larger than 3000 bytes + echo 3000 > /sys/block/zramX/recompress + + #recompress idle pages larger than 2000 bytes + echo 2000 > /sys/block/zramX/recompress + +Recompression is mostly focused on idle pages (except for huge pages +recompression), so it works better in conjunction with memory tracking. + memory tracking =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =20 --=20 2.37.2.789.g6183377224-goog From nobody Mon Apr 6 17:08:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 57E05ECAAD5 for ; Mon, 5 Sep 2022 08:24:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237536AbiIEIYT (ORCPT ); Mon, 5 Sep 2022 04:24:19 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44874 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237452AbiIEIXt (ORCPT ); Mon, 5 Sep 2022 04:23:49 -0400 Received: from mail-pg1-x530.google.com (mail-pg1-x530.google.com [IPv6:2607:f8b0:4864:20::530]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BCFFE2AF8 for ; Mon, 5 Sep 2022 01:23:48 -0700 (PDT) Received: by mail-pg1-x530.google.com with SMTP id bh13so7521131pgb.4 for ; Mon, 05 Sep 2022 01:23:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=/AdpGVT0N/8ncggFEAw2LdRk7MFt3IthPSmEwk0XZqA=; b=LiL4ic6qnwShH+vKAAfDpVgTQC0FxSPXFggKOMKQNFzrWxx/1FeDNFEhP9z1ZoIO2f Wd8EYKuaIk6ket1LJsvuXUY4AKFZe10HIuW6YGeD4RCNyM+xZjuqWjyZvTo7lmuz4JqP sL+P+IsNne+r1gmoWf77QeKPbpDCA0nP5YR4c= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=/AdpGVT0N/8ncggFEAw2LdRk7MFt3IthPSmEwk0XZqA=; b=6iB7z8xUaPle4xgijp3eTHvUAFfpIYFUG4YSx/HTkaPI2spXJc34Eg/26E5RorOrmW 551gumYl88WEeeGLZ2fICGJJueLUdi6359ZPW4Sjdytp7FPZGwZzMpzgBUIY3Y7nxtZR 1fNbQxXt8fOyR/m7RK8/dJKuUn+Sr3N2Nx2PFs+RrsZ21QOHou16L/+u/cA+8EfnQ7f7 6NSz38UrTa3gG6kSu+lo/n/lSINplMG2mx22Ra+bI0mxHHYDZoadlBPpKBbk/R7Sayj9 Wh08GeuOzmQOVvWmWq9mkAtbROjrEtDfVP/RJ6oCJ8ZbMSg5toCV1KTtc6Au/+YEPByX ueJw== X-Gm-Message-State: ACgBeo002eaZdvvKe+n946HmbKDu+GzPkbaH1X/MDgJ7DoJ2hQfyP1hr m6zu+NeCNCqzGyrLXwWLRpvvtg== X-Google-Smtp-Source: AA6agR4UZ885aB4mUVeDufZQeCtDSZclJbHMwybgeqEVVnMUNj3OcY1loqHdvf0STXrAMJAluHjgsA== X-Received: by 2002:a65:6c07:0:b0:41d:9ddd:4266 with SMTP id y7-20020a656c07000000b0041d9ddd4266mr40872332pgu.326.1662366228315; Mon, 05 Sep 2022 01:23:48 -0700 (PDT) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:71e2:8444:42d9:4bb0]) by smtp.gmail.com with ESMTPSA id p14-20020a170902e74e00b001641b2d61d4sm6807093plf.30.2022.09.05.01.23.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Sep 2022 01:23:47 -0700 (PDT) From: Sergey Senozhatsky To: Minchan Kim , Andrew Morton Cc: Nitin Gupta , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Sergey Senozhatsky Subject: [PATCH RFC 6/7] zram: Add recompression algorithm choice to Kconfig Date: Mon, 5 Sep 2022 17:23:22 +0900 Message-Id: <20220905082323.2742399-7-senozhatsky@chromium.org> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog In-Reply-To: <20220905082323.2742399-1-senozhatsky@chromium.org> References: <20220905082323.2742399-1-senozhatsky@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Make (secondary) recompression algorithm selectable just like we do it for the (primary) default one. Signed-off-by: Sergey Senozhatsky --- drivers/block/zram/Kconfig | 40 +++++++++++++++++++++++++++++++++++ drivers/block/zram/zram_drv.c | 2 +- 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/drivers/block/zram/Kconfig b/drivers/block/zram/Kconfig index 81ae4b96ec1a..fc2d4d66c484 100644 --- a/drivers/block/zram/Kconfig +++ b/drivers/block/zram/Kconfig @@ -89,3 +89,43 @@ config ZRAM_MULTI_COMP =20 echo TIMEOUT > /sys/block/zramX/idle echo SIZE > /sys/block/zramX/recompress + +choice + prompt "Default zram recompression algorithm" + default ZRAM_DEF_RECOMP_ZSTD + depends on ZRAM && ZRAM_MULTI_COMP + +config ZRAM_DEF_RECOMP_LZORLE + bool "lzo-rle" + depends on CRYPTO_LZO + +config ZRAM_DEF_RECOMP_ZSTD + bool "zstd" + depends on CRYPTO_ZSTD + +config ZRAM_DEF_RECOMP_LZ4 + bool "lz4" + depends on CRYPTO_LZ4 + +config ZRAM_DEF_RECOMP_LZO + bool "lzo" + depends on CRYPTO_LZO + +config ZRAM_DEF_RECOMP_LZ4HC + bool "lz4hc" + depends on CRYPTO_LZ4HC + +config ZRAM_DEF_RECOMP_842 + bool "842" + depends on CRYPTO_842 + +endchoice + +config ZRAM_DEF_RECOMP + string + default "lzo-rle" if ZRAM_DEF_RECOMP_LZORLE + default "zstd" if ZRAM_DEF_RECOMP_ZSTD + default "lz4" if ZRAM_DEF_RECOMP_LZ4 + default "lzo" if ZRAM_DEF_RECOMP_LZO + default "lz4hc" if ZRAM_DEF_RECOMP_LZ4HC + default "842" if ZRAM_DEF_RECOMP_842 diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 386e49a13806..8ed41514b8f0 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -44,7 +44,7 @@ static int zram_major; static const char *default_comp_algs[ZRAM_MAX_ZCOMPS] =3D { CONFIG_ZRAM_DEF_COMP, #ifdef CONFIG_ZRAM_MULTI_COMP - "zstd", + CONFIG_ZRAM_DEF_RECOMP, #endif }; =20 --=20 2.37.2.789.g6183377224-goog From nobody Mon Apr 6 17:08:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 43A2EECAAA1 for ; Mon, 5 Sep 2022 08:24:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237566AbiIEIY0 (ORCPT ); Mon, 5 Sep 2022 04:24:26 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44886 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237338AbiIEIXy (ORCPT ); Mon, 5 Sep 2022 04:23:54 -0400 Received: from mail-pf1-x42a.google.com (mail-pf1-x42a.google.com [IPv6:2607:f8b0:4864:20::42a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 80ADE31344 for ; Mon, 5 Sep 2022 01:23:51 -0700 (PDT) Received: by mail-pf1-x42a.google.com with SMTP id q15so7950187pfn.11 for ; Mon, 05 Sep 2022 01:23:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=E05eGk8Ts+47tHWXcyTeAoJzHa+CPKznHpzjFQelL1A=; b=acK8pXsPob7Y5s+Bg0YkKeVygfkxhsWVef1JJLtRM5ezbfg1jCdDeReYhs5vLFpc3+ 7C2+UY0wr24vSRkT3J9v1mb++EIgdgPbFzDQep88QpoFUDw9Mx7FNM1NK9g3unavDjvT ZwrREvj/gc8m4PHJNEjGYalq9yyae/RaZt7Mg= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=E05eGk8Ts+47tHWXcyTeAoJzHa+CPKznHpzjFQelL1A=; b=Rl2Vc0zYgZgHPtrYteREFzJhrs+Qe5zeo8k/3lXsqf4GU6EgFo4pOmMNe40LxQ//7I Kox6z16zUhn99WUiULUYEJRdM/EHrYdbxM86rh0nN/KXhbBWPXGo79LHUuVzkoAyQ0Q/ 6hnmYj9HT24/RY8CLpfBrpMUcE683M09K5E91lmOhn8n7TNqomlo/Ultdxz3GNSwKWyK chJ1ksEPETUQJxz3+Es+BcAsmucJeKVbqqeQEwEUVbFtaWNcPPRvvr6dcinMohnmUI6g yEJlAJ3YoDoSaMr/p7k1tDP2PY+OTCuWymmZrWpTe/6Lt1XI+l9fs71nYC+aDi+Rstha sEIg== X-Gm-Message-State: ACgBeo07K1TfwWZ4GDeaNqTmAU73HqJc4GRQBecGAVu78eF1OMXWOdNb trHLKLgZZ3+D0Tky2jYuaV0+GJSkDpwaNQ== X-Google-Smtp-Source: AA6agR7apkwdHRSEq/AOrRxCZYMadHNajCXFhmfCQuwClOVZjsqItLs1Hn/U6/65l19Q0gXR//E8EA== X-Received: by 2002:a63:d1f:0:b0:422:7774:1969 with SMTP id c31-20020a630d1f000000b0042277741969mr40307627pgl.88.1662366231066; Mon, 05 Sep 2022 01:23:51 -0700 (PDT) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:71e2:8444:42d9:4bb0]) by smtp.gmail.com with ESMTPSA id p14-20020a170902e74e00b001641b2d61d4sm6807093plf.30.2022.09.05.01.23.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Sep 2022 01:23:50 -0700 (PDT) From: Sergey Senozhatsky To: Minchan Kim , Andrew Morton Cc: Nitin Gupta , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Sergey Senozhatsky Subject: [PATCH RFC 7/7] zram: Add recompress flag to read_block_state() Date: Mon, 5 Sep 2022 17:23:23 +0900 Message-Id: <20220905082323.2742399-8-senozhatsky@chromium.org> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog In-Reply-To: <20220905082323.2742399-1-senozhatsky@chromium.org> References: <20220905082323.2742399-1-senozhatsky@chromium.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add a new flag to zram block state that shows if the page was recompressed (using alternative compression algorithm). Signed-off-by: Sergey Senozhatsky --- Documentation/admin-guide/blockdev/zram.rst | 9 ++++++--- drivers/block/zram/zram_drv.c | 5 +++-- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/Documentation/admin-guide/blockdev/zram.rst b/Documentation/ad= min-guide/blockdev/zram.rst index 88957fcb6ad7..70a3d0243b45 100644 --- a/Documentation/admin-guide/blockdev/zram.rst +++ b/Documentation/admin-guide/blockdev/zram.rst @@ -466,9 +466,10 @@ pages of the process with*pagemap. If you enable the feature, you could see block state via /sys/kernel/debug/zram/zram0/block_state". The output is as follows:: =20 - 300 75.033841 .wh. - 301 63.806904 s... - 302 63.806919 ..hi + 300 75.033841 .wh.. + 301 63.806904 s.... + 302 63.806919 ..hi. + 303 62.801919 ....r =20 First column zram's block index. @@ -485,6 +486,8 @@ Third column huge page i: idle page + r: + recompressed page (secondary compression algorithm) =20 First line of above example says 300th block is accessed at 75.033841sec and the block's state is huge so it is written back to the backing diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 8ed41514b8f0..f3948abce2f7 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -936,13 +936,14 @@ static ssize_t read_block_state(struct file *file, ch= ar __user *buf, =20 ts =3D ktime_to_timespec64(zram->table[index].ac_time); copied =3D snprintf(kbuf + written, count, - "%12zd %12lld.%06lu %c%c%c%c\n", + "%12zd %12lld.%06lu %c%c%c%c%c\n", index, (s64)ts.tv_sec, ts.tv_nsec / NSEC_PER_USEC, zram_test_flag(zram, index, ZRAM_SAME) ? 's' : '.', zram_test_flag(zram, index, ZRAM_WB) ? 'w' : '.', zram_test_flag(zram, index, ZRAM_HUGE) ? 'h' : '.', - zram_test_flag(zram, index, ZRAM_IDLE) ? 'i' : '.'); + zram_test_flag(zram, index, ZRAM_IDLE) ? 'i' : '.', + zram_test_flag(zram, index, ZRAM_RECOMP) ? 'r' : '.'); =20 if (count <=3D copied) { zram_slot_unlock(zram, index); --=20 2.37.2.789.g6183377224-goog