From nobody Tue Dec 2 02:04:56 2025 Received: from mail-pf1-f172.google.com (mail-pf1-f172.google.com [209.85.210.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C3D72369980 for ; Thu, 20 Nov 2025 15:22:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652131; cv=none; b=p9xZkZ0dGKzFnPte+w7fNKpyA/c/osmzFDO6LFNC2scYJ5a8RBIrbMlsJabg5BYauevfAINzLbIrDK13N0CsiVfoby9iZwZ/7FtM95h0RtETZ8NCEyQGRaJkuXVBUG9buc5KYu3w/BnanV/VB9UwKD7IqxVv0EqvtF6uKUz9zXE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652131; c=relaxed/simple; bh=5+AU9S/f5polyQyYvakR9BB1IIFdi+/V+avVO9Xt2j4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=liY8CV/YhAoda9vE43BKAfmHppwr20iPCkzzMr/nUwZZRx/3UEQ5qbWTHR4fjRRqvIOwAzQlPerxrCjWPy4X7v4PVL5+bjah/6BzbRU/52T2Gxa/dEJVh7v3jiCioh5N0eaMImovZwka/VZ6xe0LZX1JjqwVsnOX9LFY6OLDcTc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org; spf=pass smtp.mailfrom=chromium.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b=UFEXDB/1; arc=none smtp.client-ip=209.85.210.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=chromium.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="UFEXDB/1" Received: by mail-pf1-f172.google.com with SMTP id d2e1a72fcca58-7bb710d1d1dso1491481b3a.1 for ; Thu, 20 Nov 2025 07:22:09 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; t=1763652129; x=1764256929; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=DQMGDA1+u1LPAuL+BCiFc4Yo1PBFGHEJGqJGazuFeIc=; b=UFEXDB/1Sb2IIrmjGyVphMUR2Pnt1cf+YARbMVuRW9soR7jCbiW/GL6FJT5yKuUfJd JrlKyCRX96HfDvIWLrWbMnKJ5tUgoOPlXj/pznmUHPV/V4npZFtEIl9NOh4EliK31qQj 9uNXHlXnV97VDGJGDJ3sEI5knQZMP9KZxnCSs= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1763652129; x=1764256929; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=DQMGDA1+u1LPAuL+BCiFc4Yo1PBFGHEJGqJGazuFeIc=; b=JuevZJzrLgmaxpwdEP8DNld8BJQAfpfsL6N69PyzrczwpFa6aVra8I3KKFjij+32Ul QWSGc04OEk1V9UEBQNncI4Jpu/KKchAVa+gTxINEkunkacAM9OC4w2gdeXeQDo2PNDOr JrsO8su5RPcxoMK9f6+1A6qBpopIhitmPFYRAx9xyyAxwXQSKduGRbjklECHCl2rKoei KZ2vlMu79NNO9rw31/MERtsuqN64WD57KRoIkkqm/aKkqOSlHxnh8qBcBlXrmvIh4qTR jDzoi5SXc/zx3eEuu91owFxn8wqTd6wXiHT7iOP5w0wqVpRueh+TTQ5Z1AtW7GBHUJwm 8n2g== X-Forwarded-Encrypted: i=1; AJvYcCWW+0LwCWr/WcI5Neq6QVTpIX6nitr0AJNVdEfpqn4VvVvUGtx18dp6USGSLf+3kgU8k5I1tz8eLrHGpkY=@vger.kernel.org X-Gm-Message-State: AOJu0Yz7EFBmpUNLMqwOdxXinU5Bk7w1lDuvV78TX47kvSrJ4SZwcrzW xzRTc9gkhUWK5nwfN6FcNMZXz6GnOxwXxxVxpF9B72YGWa0WKviPqsrF3FiD+/S5LA== X-Gm-Gg: ASbGnctYtoahiFBZBz6yqXqCjWMK1WuIx8BmJWkFqsYoJh3EK+j1my3Ru505+3zdUGW AVVhF0Kw6jf+ABxxjj8sKLOtPCio1V54ju+3Mn0UqjWFdFIdNaAWgHo/2Xbw/n5wJY2vdLNjA+S 6tepHr+w9yljOYKzQ5Maihqltn2gem6irXP+t6KJEnYHSVcarJg2W8bgSFDTAdjCFamPqT3dnTc +WbbR3V9vm1RxXKYux7ukiXlJXiyyACSCsfacgUp4TmqeH0+wqgJRXVK1dHQHQLP7QkDdACgTWL qfy1/nLOnMH1b6Lk8TOgHzhknbSCfykTakAXucfaF1YuizeEBx1WxAU8DXPI5YhZ4raaAJvscY1 5aRnO0OKzXR8vWECENzpKEQDzF08cZCzjjL4KmBGqjUYBhs+VW99yMYOs3bVzxk+enjV7mcsEts LNqEihA8IXtQX519GfiKLAtC4ov1bGWoGXhdTk9Q== X-Google-Smtp-Source: AGHT+IH4Kqb6jdeCprkIAeBP8l5L/2bdYTnDn0ERK7+4rx4S17p67ukAm1nlmWjmMsyD/cMn7l50fA== X-Received: by 2002:a05:6a00:1248:b0:7ad:386e:3b6d with SMTP id d2e1a72fcca58-7c3f07656fbmr4373751b3a.21.1763652129027; Thu, 20 Nov 2025 07:22:09 -0800 (PST) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:6762:7dba:8487:43a1]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7c3f023f968sm3179642b3a.38.2025.11.20.07.22.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Nov 2025 07:22:08 -0800 (PST) From: Sergey Senozhatsky To: Andrew Morton , Minchan Kim , Yuwen Chen , Richard Chang Cc: Brian Geffon , Fengyu Lian , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-block@vger.kernel.org, Sergey Senozhatsky , Minchan Kim Subject: [RFC PATCHv5 1/6] zram: introduce writeback bio batching Date: Fri, 21 Nov 2025 00:21:21 +0900 Message-ID: <20251120152126.3126298-2-senozhatsky@chromium.org> X-Mailer: git-send-email 2.52.0.rc1.455.g30608eb744-goog In-Reply-To: <20251120152126.3126298-1-senozhatsky@chromium.org> References: <20251120152126.3126298-1-senozhatsky@chromium.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Currently, zram writeback supports only a single bio writeback operation, waiting for bio completion before post-processing next pp-slot. This works, in general, but has certain throughput limitations. Introduce batched (multiple) bio writeback support to take advantage of parallel requests processing and better requests scheduling. For the time being the writeback batch size (maximum number of in-flight bio requests) is set to 32 for all devices. A follow up patch adds a writeback_batch_size device attribute, so the batch size becomes run-time configurable. Signed-off-by: Sergey Senozhatsky Co-developed-by: Yuwen Chen Co-developed-by: Richard Chang Suggested-by: Minchan Kim --- drivers/block/zram/zram_drv.c | 366 +++++++++++++++++++++++++++------- 1 file changed, 298 insertions(+), 68 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index a43074657531..37c1416ac902 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -500,6 +500,24 @@ static ssize_t idle_store(struct device *dev, } =20 #ifdef CONFIG_ZRAM_WRITEBACK +struct zram_wb_ctl { + struct list_head idle_reqs; + struct list_head done_reqs; + wait_queue_head_t done_wait; + spinlock_t done_lock; + atomic_t num_inflight; +}; + +struct zram_wb_req { + unsigned long blk_idx; + struct page *page; + struct zram_pp_slot *pps; + struct bio_vec bio_vec; + struct bio bio; + + struct list_head entry; +}; + static ssize_t writeback_limit_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { @@ -734,19 +752,220 @@ static void read_from_bdev_async(struct zram *zram, = struct page *page, submit_bio(bio); } =20 -static int zram_writeback_slots(struct zram *zram, struct zram_pp_ctl *ctl) +static void release_wb_req(struct zram_wb_req *req) { - unsigned long blk_idx =3D 0; - struct page *page =3D NULL; - struct zram_pp_slot *pps; - struct bio_vec bio_vec; - struct bio bio; + __free_page(req->page); + kfree(req); +} + +static void release_wb_ctl(struct zram_wb_ctl *wb_ctl) +{ + if (!wb_ctl) + return; + + /* We should never have inflight requests at this point */ + WARN_ON(atomic_read(&wb_ctl->num_inflight)); + WARN_ON(!list_empty(&wb_ctl->done_reqs)); + + while (!list_empty(&wb_ctl->idle_reqs)) { + struct zram_wb_req *req; + + req =3D list_first_entry(&wb_ctl->idle_reqs, + struct zram_wb_req, entry); + list_del(&req->entry); + release_wb_req(req); + } + + kfree(wb_ctl); +} + +/* XXX: should be a per-device sysfs attr */ +#define ZRAM_WB_REQ_CNT 32 + +static struct zram_wb_ctl *init_wb_ctl(void) +{ + struct zram_wb_ctl *wb_ctl; + int i; + + wb_ctl =3D kmalloc(sizeof(*wb_ctl), GFP_KERNEL); + if (!wb_ctl) + return NULL; + + INIT_LIST_HEAD(&wb_ctl->idle_reqs); + INIT_LIST_HEAD(&wb_ctl->done_reqs); + atomic_set(&wb_ctl->num_inflight, 0); + init_waitqueue_head(&wb_ctl->done_wait); + spin_lock_init(&wb_ctl->done_lock); + + for (i =3D 0; i < ZRAM_WB_REQ_CNT; i++) { + struct zram_wb_req *req; + + /* + * This is fatal condition only if we couldn't allocate + * any requests at all. Otherwise we just work with the + * requests that we have successfully allocated, so that + * writeback can still proceed, even if there is only one + * request on the idle list. + */ + req =3D kzalloc(sizeof(*req), GFP_KERNEL | __GFP_NOWARN); + if (!req) + break; + + req->page =3D alloc_page(GFP_KERNEL | __GFP_NOWARN); + if (!req->page) { + kfree(req); + break; + } + + list_add(&req->entry, &wb_ctl->idle_reqs); + } + + /* We couldn't allocate any requests, so writeabck is not possible */ + if (list_empty(&wb_ctl->idle_reqs)) + goto release_wb_ctl; + + return wb_ctl; + +release_wb_ctl: + release_wb_ctl(wb_ctl); + return NULL; +} + +static void zram_account_writeback_rollback(struct zram *zram) +{ + spin_lock(&zram->wb_limit_lock); + if (zram->wb_limit_enable) + zram->bd_wb_limit +=3D 1UL << (PAGE_SHIFT - 12); + spin_unlock(&zram->wb_limit_lock); +} + +static void zram_account_writeback_submit(struct zram *zram) +{ + spin_lock(&zram->wb_limit_lock); + if (zram->wb_limit_enable && zram->bd_wb_limit > 0) + zram->bd_wb_limit -=3D 1UL << (PAGE_SHIFT - 12); + spin_unlock(&zram->wb_limit_lock); +} + +static int zram_writeback_complete(struct zram *zram, struct zram_wb_req *= req) +{ + u32 index =3D req->pps->index; + int err; + + err =3D blk_status_to_errno(req->bio.bi_status); + if (err) { + /* + * Failed wb requests should not be accounted in wb_limit + * (if enabled). + */ + zram_account_writeback_rollback(zram); + free_block_bdev(zram, req->blk_idx); + return err; + } + + atomic64_inc(&zram->stats.bd_writes); + zram_slot_lock(zram, index); + /* + * We release slot lock during writeback so slot can change under us: + * slot_free() or slot_free() and zram_write_page(). In both cases + * slot loses ZRAM_PP_SLOT flag. No concurrent post-processing can + * set ZRAM_PP_SLOT on such slots until current post-processing + * finishes. + */ + if (!zram_test_flag(zram, index, ZRAM_PP_SLOT)) { + free_block_bdev(zram, req->blk_idx); + goto out; + } + + zram_free_page(zram, index); + zram_set_flag(zram, index, ZRAM_WB); + zram_set_handle(zram, index, req->blk_idx); + atomic64_inc(&zram->stats.pages_stored); + +out: + zram_slot_unlock(zram, index); + return 0; +} + +static void zram_writeback_endio(struct bio *bio) +{ + struct zram_wb_req *req =3D container_of(bio, struct zram_wb_req, bio); + struct zram_wb_ctl *wb_ctl =3D bio->bi_private; + unsigned long flags; + + spin_lock_irqsave(&wb_ctl->done_lock, flags); + list_add(&req->entry, &wb_ctl->done_reqs); + spin_unlock_irqrestore(&wb_ctl->done_lock, flags); + + wake_up(&wb_ctl->done_wait); +} + +static void zram_submit_wb_request(struct zram *zram, + struct zram_wb_ctl *wb_ctl, + struct zram_wb_req *req) +{ + /* + * wb_limit (if enabled) should be adjusted before submission, + * so that we don't over-submit. + */ + zram_account_writeback_submit(zram); + atomic_inc(&wb_ctl->num_inflight); + req->bio.bi_private =3D wb_ctl; + submit_bio(&req->bio); +} + +static int zram_complete_done_reqs(struct zram *zram, + struct zram_wb_ctl *wb_ctl) +{ + struct zram_wb_req *req; + unsigned long flags; int ret =3D 0, err; - u32 index; =20 - page =3D alloc_page(GFP_KERNEL); - if (!page) - return -ENOMEM; + while (1) { + spin_lock_irqsave(&wb_ctl->done_lock, flags); + req =3D list_first_entry_or_null(&wb_ctl->done_reqs, + struct zram_wb_req, entry); + if (req) + list_del(&req->entry); + spin_unlock_irqrestore(&wb_ctl->done_lock, flags); + + if (!req) + break; + + err =3D zram_writeback_complete(zram, req); + if (err) + ret =3D err; + + atomic_dec(&wb_ctl->num_inflight); + release_pp_slot(zram, req->pps); + req->pps =3D NULL; + + list_add(&req->entry, &wb_ctl->idle_reqs); + } + + return ret; +} + +static struct zram_wb_req *zram_select_idle_req(struct zram_wb_ctl *wb_ctl) +{ + struct zram_wb_req *req; + + req =3D list_first_entry_or_null(&wb_ctl->idle_reqs, + struct zram_wb_req, entry); + if (req) + list_del(&req->entry); + return req; +} + +static int zram_writeback_slots(struct zram *zram, + struct zram_pp_ctl *ctl, + struct zram_wb_ctl *wb_ctl) +{ + struct zram_wb_req *req =3D NULL; + unsigned long blk_idx =3D 0; + struct zram_pp_slot *pps; + int ret =3D 0, err =3D 0; + u32 index =3D 0; =20 while ((pps =3D select_pp_slot(ctl))) { spin_lock(&zram->wb_limit_lock); @@ -757,6 +976,27 @@ static int zram_writeback_slots(struct zram *zram, str= uct zram_pp_ctl *ctl) } spin_unlock(&zram->wb_limit_lock); =20 + while (!req) { + req =3D zram_select_idle_req(wb_ctl); + if (req) + break; + + wait_event(wb_ctl->done_wait, + !list_empty(&wb_ctl->done_reqs)); + + err =3D zram_complete_done_reqs(zram, wb_ctl); + /* + * BIO errors are not fatal, we continue and simply + * attempt to writeback the remaining objects (pages). + * At the same time we need to signal user-space that + * some writes (at least one, but also could be all of + * them) were not successful and we do so by returning + * the most recent BIO error. + */ + if (err) + ret =3D err; + } + if (!blk_idx) { blk_idx =3D alloc_block_bdev(zram); if (!blk_idx) { @@ -775,67 +1015,47 @@ static int zram_writeback_slots(struct zram *zram, s= truct zram_pp_ctl *ctl) */ if (!zram_test_flag(zram, index, ZRAM_PP_SLOT)) goto next; - if (zram_read_from_zspool(zram, page, index)) + if (zram_read_from_zspool(zram, req->page, index)) goto next; zram_slot_unlock(zram, index); =20 - bio_init(&bio, zram->bdev, &bio_vec, 1, - REQ_OP_WRITE | REQ_SYNC); - bio.bi_iter.bi_sector =3D blk_idx * (PAGE_SIZE >> 9); - __bio_add_page(&bio, page, PAGE_SIZE, 0); - /* - * XXX: A single page IO would be inefficient for write - * but it would be not bad as starter. + * From now on pp-slot is owned by the req, remove it from + * its pp bucket. */ - err =3D submit_bio_wait(&bio); - if (err) { - release_pp_slot(zram, pps); - /* - * BIO errors are not fatal, we continue and simply - * attempt to writeback the remaining objects (pages). - * At the same time we need to signal user-space that - * some writes (at least one, but also could be all of - * them) were not successful and we do so by returning - * the most recent BIO error. - */ - ret =3D err; - continue; - } + list_del_init(&pps->entry); =20 - atomic64_inc(&zram->stats.bd_writes); - zram_slot_lock(zram, index); - /* - * Same as above, we release slot lock during writeback so - * slot can change under us: slot_free() or slot_free() and - * reallocation (zram_write_page()). In both cases slot loses - * ZRAM_PP_SLOT flag. No concurrent post-processing can set - * ZRAM_PP_SLOT on such slots until current post-processing - * finishes. - */ - if (!zram_test_flag(zram, index, ZRAM_PP_SLOT)) - goto next; + req->blk_idx =3D blk_idx; + req->pps =3D pps; + bio_init(&req->bio, zram->bdev, &req->bio_vec, 1, REQ_OP_WRITE); + req->bio.bi_iter.bi_sector =3D req->blk_idx * (PAGE_SIZE >> 9); + req->bio.bi_end_io =3D zram_writeback_endio; + __bio_add_page(&req->bio, req->page, PAGE_SIZE, 0); =20 - zram_free_page(zram, index); - zram_set_flag(zram, index, ZRAM_WB); - zram_set_handle(zram, index, blk_idx); + zram_submit_wb_request(zram, wb_ctl, req); blk_idx =3D 0; - atomic64_inc(&zram->stats.pages_stored); - spin_lock(&zram->wb_limit_lock); - if (zram->wb_limit_enable && zram->bd_wb_limit > 0) - zram->bd_wb_limit -=3D 1UL << (PAGE_SHIFT - 12); - spin_unlock(&zram->wb_limit_lock); + req =3D NULL; + cond_resched(); + continue; + next: zram_slot_unlock(zram, index); release_pp_slot(zram, pps); - - cond_resched(); } =20 - if (blk_idx) - free_block_bdev(zram, blk_idx); - if (page) - __free_page(page); + /* + * Selected idle req, but never submitted it due to some error or + * wb limit. + */ + if (req) + release_wb_req(req); + + while (atomic_read(&wb_ctl->num_inflight) > 0) { + wait_event(wb_ctl->done_wait, !list_empty(&wb_ctl->done_reqs)); + err =3D zram_complete_done_reqs(zram, wb_ctl); + if (err) + ret =3D err; + } =20 return ret; } @@ -948,7 +1168,8 @@ static ssize_t writeback_store(struct device *dev, struct zram *zram =3D dev_to_zram(dev); u64 nr_pages =3D zram->disksize >> PAGE_SHIFT; unsigned long lo =3D 0, hi =3D nr_pages; - struct zram_pp_ctl *ctl =3D NULL; + struct zram_pp_ctl *pp_ctl =3D NULL; + struct zram_wb_ctl *wb_ctl =3D NULL; char *args, *param, *val; ssize_t ret =3D len; int err, mode =3D 0; @@ -970,8 +1191,14 @@ static ssize_t writeback_store(struct device *dev, goto release_init_lock; } =20 - ctl =3D init_pp_ctl(); - if (!ctl) { + pp_ctl =3D init_pp_ctl(); + if (!pp_ctl) { + ret =3D -ENOMEM; + goto release_init_lock; + } + + wb_ctl =3D init_wb_ctl(); + if (!wb_ctl) { ret =3D -ENOMEM; goto release_init_lock; } @@ -1000,7 +1227,7 @@ static ssize_t writeback_store(struct device *dev, goto release_init_lock; } =20 - scan_slots_for_writeback(zram, mode, lo, hi, ctl); + scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); break; } =20 @@ -1011,7 +1238,7 @@ static ssize_t writeback_store(struct device *dev, goto release_init_lock; } =20 - scan_slots_for_writeback(zram, mode, lo, hi, ctl); + scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); break; } =20 @@ -1022,7 +1249,7 @@ static ssize_t writeback_store(struct device *dev, goto release_init_lock; } =20 - scan_slots_for_writeback(zram, mode, lo, hi, ctl); + scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); continue; } =20 @@ -1033,17 +1260,18 @@ static ssize_t writeback_store(struct device *dev, goto release_init_lock; } =20 - scan_slots_for_writeback(zram, mode, lo, hi, ctl); + scan_slots_for_writeback(zram, mode, lo, hi, pp_ctl); continue; } } =20 - err =3D zram_writeback_slots(zram, ctl); + err =3D zram_writeback_slots(zram, pp_ctl, wb_ctl); if (err) ret =3D err; =20 release_init_lock: - release_pp_ctl(zram, ctl); + release_pp_ctl(zram, pp_ctl); + release_wb_ctl(wb_ctl); atomic_set(&zram->pp_in_progress, 0); up_read(&zram->init_lock); =20 @@ -1112,7 +1340,9 @@ static int read_from_bdev(struct zram *zram, struct p= age *page, return -EIO; } =20 -static void free_block_bdev(struct zram *zram, unsigned long blk_idx) {}; +static void free_block_bdev(struct zram *zram, unsigned long blk_idx) +{ +} #endif =20 #ifdef CONFIG_ZRAM_MEMORY_TRACKING --=20 2.52.0.rc1.455.g30608eb744-goog From nobody Tue Dec 2 02:04:56 2025 Received: from mail-pj1-f47.google.com (mail-pj1-f47.google.com [209.85.216.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1A1BB36C0CE for ; Thu, 20 Nov 2025 15:22:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652133; cv=none; b=ZvlKndIIWKe/y77op+y70qCmFjkrW81ncPF1Pagy9rRyjWJkq5uXAp08wNO/699myyBbKbOzSxTQUoKJ1zYox9uyH/zLei8g3aBWZQnojr1qBwnikhd0lzmT1UA4x8eeABkmxbg4uLshGMG7nSMtkXn3LpfaqLpR3IRnXp5LqoA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652133; c=relaxed/simple; bh=QWWiZ4tHfeSo/6PGZPwYSUTo9cWJq/8Qx6JfMxUueJY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=IThddJrovOXtBgfFds+W0H3heGZFiWpvioXyMieNzBdbB/8VeCYqF8eMLiqMaOH3eR6joJC3po4arQF4tdd+Mz0LZH0s+KCSzYBENRpPqDmP1w2Awu/ztji1nCzPARMKEI8Q82ADgHGzbMfvmnJ1EzCrKNyru3RWpAp6Sp6pecM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org; spf=pass smtp.mailfrom=chromium.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b=RWe0yvJM; arc=none smtp.client-ip=209.85.216.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=chromium.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="RWe0yvJM" Received: by mail-pj1-f47.google.com with SMTP id 98e67ed59e1d1-34381ec9197so911614a91.1 for ; Thu, 20 Nov 2025 07:22:11 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; t=1763652131; x=1764256931; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ZAmKATgpNu/alXOGtuyOI3W/oFMTAwgOBJmF8/nzO6s=; b=RWe0yvJM4/Wq+vwCaQja9061Q+DPoK07YROLAfRCAjw19SO0s1SJ9U7WS8fBox8jQC lY4B3qu4qKVXAZuiF421G3ZE2RcDxWZTOrRw0d+vHIXtq2Zjoy4I8LGIDEO6oI+GA/TT jnxq8RkZYWscvyuC+SyZa3AeSFby59ALdTwXI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1763652131; x=1764256931; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=ZAmKATgpNu/alXOGtuyOI3W/oFMTAwgOBJmF8/nzO6s=; b=D9VuByll3UaKrJlcb8X+kcny/1fkk75ySmnn0fTtqWrThDFgzLHxRAAHIvF85K8SoY ZxPZ3UL/5nuwa39nncOGjP9ZcaxvE+m7AahOP0UFgZ77YFywWz0idtcOKktbWbBKECpe q9+QYzwIGJcrkf6VWJZAxOhtSEvS8Zp+bScrjyhJBkyphuIi4x+9BFTvH2CAuYNIRd1j Mf3peRn66VQONNlyhuxBBRpMXMAJBMkSAX/ereIIF5HaIc0Pjp53ZpPUZZjnAQt4DSOA uybbhrEjzhpaYIdTXKEshBwucKsBtTbgII0MD0aCNyDSNgrZWPBJlTQDtyb5d32OYEvR +4bA== X-Forwarded-Encrypted: i=1; AJvYcCVjPOd0S8BXdOpoJj6DGbNTdK4Nv9SUjluyniHh4iYegXk98XxoXoDBq88vdU4bQuH8sViW9Fj9yTbpOug=@vger.kernel.org X-Gm-Message-State: AOJu0YxCFXxBx6V3a/ezdfhDWyZmzv8O+WtqCyljIpHEfO1mLfaflk5L k4hTmjSnXehkj4qlc5XwqJDg57IeaYt5eEu0Mbh8Fd2eAINl6up1Hx72S13n33AKdA== X-Gm-Gg: ASbGncs3tp6IM6Mzwhn01CXNC1i33Vm44JKTy3WjXpwScQ1t1e1AsH1XnWANLHHAt3m MIbTvwV0qo7Z4uHeDNO8/aea5EVJQ+s6OqFM2HLR6zUdwc0Hvqcpp1WsPiK1rpaO5ki9n/azjUU GL549Ecizph5IQLW0ncyMcaKPr7A+cW9I5L7lOZSfCeu5gfhqZW6Q2ueftuMrLufWDHmwXX7ut0 B4dQ0T9zJKg31uoHzPjqdj/dCAhQiH5AumK9/XpNPgIjhOdoSO8KTjcytQ7kfxOOkvZl1BDMQPJ nvhIK8L5GfPQ2pY0xAOXWuM2svNgbeIvX9yVKWlsaB2tnEC8jxbOmv39vgGRfG58T0zrnrfSZs3 y1YmlcsljCWGsbra9mFEhlXkyapmAv3ROF21aZ7Br54kk5lBUngPnrMUUp7N31P6BeTxkGnDNK/ BCFB+7v7jJQV0bTd9f3q32yHAEV6pMpjVS7pFjBw== X-Google-Smtp-Source: AGHT+IGXx99ORaMc9c2Jm3Uyx2w4g0SNrUulESpO10c9NwCK4Ja79Nw8/lRM5g2x9jRJA1DHlD8CCA== X-Received: by 2002:a17:90b:53c8:b0:340:be44:dd0b with SMTP id 98e67ed59e1d1-34727d5233emr3818884a91.34.1763652131431; Thu, 20 Nov 2025 07:22:11 -0800 (PST) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:6762:7dba:8487:43a1]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7c3f023f968sm3179642b3a.38.2025.11.20.07.22.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Nov 2025 07:22:11 -0800 (PST) From: Sergey Senozhatsky To: Andrew Morton , Minchan Kim , Yuwen Chen , Richard Chang Cc: Brian Geffon , Fengyu Lian , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-block@vger.kernel.org, Sergey Senozhatsky Subject: [RFC PATCHv5 2/6] zram: add writeback batch size device attr Date: Fri, 21 Nov 2025 00:21:22 +0900 Message-ID: <20251120152126.3126298-3-senozhatsky@chromium.org> X-Mailer: git-send-email 2.52.0.rc1.455.g30608eb744-goog In-Reply-To: <20251120152126.3126298-1-senozhatsky@chromium.org> References: <20251120152126.3126298-1-senozhatsky@chromium.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Introduce writeback_batch_size device attribute so that the maximum number of in-flight writeback bio requests can be configured at run-time per-device. This essentially enables batched bio writeback. Signed-off-by: Sergey Senozhatsky --- drivers/block/zram/zram_drv.c | 48 ++++++++++++++++++++++++++++++----- drivers/block/zram/zram_drv.h | 1 + 2 files changed, 43 insertions(+), 6 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 37c1416ac902..7904159e9226 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -588,6 +588,42 @@ static ssize_t writeback_limit_show(struct device *dev, return sysfs_emit(buf, "%llu\n", val); } =20 +static ssize_t writeback_batch_size_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t len) +{ + struct zram *zram =3D dev_to_zram(dev); + u32 val; + ssize_t ret =3D -EINVAL; + + if (kstrtouint(buf, 10, &val)) + return ret; + + if (!val) + val =3D 1; + + down_read(&zram->init_lock); + zram->wb_batch_size =3D val; + up_read(&zram->init_lock); + ret =3D len; + + return ret; +} + +static ssize_t writeback_batch_size_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + u32 val; + struct zram *zram =3D dev_to_zram(dev); + + down_read(&zram->init_lock); + val =3D zram->wb_batch_size; + up_read(&zram->init_lock); + + return sysfs_emit(buf, "%u\n", val); +} + static void reset_bdev(struct zram *zram) { if (!zram->backing_dev) @@ -779,10 +815,7 @@ static void release_wb_ctl(struct zram_wb_ctl *wb_ctl) kfree(wb_ctl); } =20 -/* XXX: should be a per-device sysfs attr */ -#define ZRAM_WB_REQ_CNT 32 - -static struct zram_wb_ctl *init_wb_ctl(void) +static struct zram_wb_ctl *init_wb_ctl(struct zram *zram) { struct zram_wb_ctl *wb_ctl; int i; @@ -797,7 +830,7 @@ static struct zram_wb_ctl *init_wb_ctl(void) init_waitqueue_head(&wb_ctl->done_wait); spin_lock_init(&wb_ctl->done_lock); =20 - for (i =3D 0; i < ZRAM_WB_REQ_CNT; i++) { + for (i =3D 0; i < zram->wb_batch_size; i++) { struct zram_wb_req *req; =20 /* @@ -1197,7 +1230,7 @@ static ssize_t writeback_store(struct device *dev, goto release_init_lock; } =20 - wb_ctl =3D init_wb_ctl(); + wb_ctl =3D init_wb_ctl(zram); if (!wb_ctl) { ret =3D -ENOMEM; goto release_init_lock; @@ -2840,6 +2873,7 @@ static DEVICE_ATTR_RW(backing_dev); static DEVICE_ATTR_WO(writeback); static DEVICE_ATTR_RW(writeback_limit); static DEVICE_ATTR_RW(writeback_limit_enable); +static DEVICE_ATTR_RW(writeback_batch_size); #endif #ifdef CONFIG_ZRAM_MULTI_COMP static DEVICE_ATTR_RW(recomp_algorithm); @@ -2861,6 +2895,7 @@ static struct attribute *zram_disk_attrs[] =3D { &dev_attr_writeback.attr, &dev_attr_writeback_limit.attr, &dev_attr_writeback_limit_enable.attr, + &dev_attr_writeback_batch_size.attr, #endif &dev_attr_io_stat.attr, &dev_attr_mm_stat.attr, @@ -2922,6 +2957,7 @@ static int zram_add(void) =20 init_rwsem(&zram->init_lock); #ifdef CONFIG_ZRAM_WRITEBACK + zram->wb_batch_size =3D 32; spin_lock_init(&zram->wb_limit_lock); #endif =20 diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h index 6cee93f9c0d0..1a647f42c1a4 100644 --- a/drivers/block/zram/zram_drv.h +++ b/drivers/block/zram/zram_drv.h @@ -129,6 +129,7 @@ struct zram { struct file *backing_dev; spinlock_t wb_limit_lock; bool wb_limit_enable; + u32 wb_batch_size; u64 bd_wb_limit; struct block_device *bdev; unsigned long *bitmap; --=20 2.52.0.rc1.455.g30608eb744-goog From nobody Tue Dec 2 02:04:56 2025 Received: from mail-pf1-f173.google.com (mail-pf1-f173.google.com [209.85.210.173]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B76D336CDF0 for ; Thu, 20 Nov 2025 15:22:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.173 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652136; cv=none; b=OUJQQfH1mJgr9Fuu/wf3YRpYpuGmjNil9NnO+vMB/a1ntZ6B0KhtoMlXFkMOzknPPXtRd94og4ss+vTaTKBWtjb56kerbfgpeTyuKPmIseet1N7oWNxy6nG4AgHeXz2sW6nLy/2U8f1mISTohrXtdBtd9gR46hTBZlfDKJ+ETX8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652136; c=relaxed/simple; bh=6i9wyNhqOFWWngjT8KYDQjhuLYLHg4Vp188ljYoAL/4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=MX47XmObLtvm0OFdX5qp7fsrhnrO7npRYJOp2etW8CvYQbTZjXlrG73jzRfFqhmO2hTruAWYj0iJycpRjsTRilwyTJ2Ma5MxVo8krIhUuF5CeNiBXjej1vSmqVJTDna57YzltvcufaFKyQYFRaxJuBC+PzmnzoIAW6sLYBkWvWU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org; spf=pass smtp.mailfrom=chromium.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b=fKcwbqMt; arc=none smtp.client-ip=209.85.210.173 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=chromium.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="fKcwbqMt" Received: by mail-pf1-f173.google.com with SMTP id d2e1a72fcca58-7acd9a03ba9so1139864b3a.1 for ; Thu, 20 Nov 2025 07:22:14 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; t=1763652134; x=1764256934; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=f8KDeSPboQyenPsR88PS7oH+E8JUyOLPtZOOBoNoQpo=; b=fKcwbqMt5yajV115c7lIH/xC73BJoY9KcDmK6vnpSYuiKp0rScnmzIQF2c6Gyg+X+r BLEPll733fLPWDQVXldKpP/84XN9ebdEcnbIAc3F0vhZKWdye0gm1ITZaxhifqelT1O4 wwYEVh5t2/iJ+nx7ld4XIFCEICzDSwja1UmGA= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1763652134; x=1764256934; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=f8KDeSPboQyenPsR88PS7oH+E8JUyOLPtZOOBoNoQpo=; b=gI/zja4kVL5oOYboq3VY/CodSJOomNdsmN0KuYQ5L+NNGeMob2ue6MoDtKJirO7/PX qfSpueIpEJDNrTP91Ksn1/PTrBLrHFgRXe/KRx6PALop7elMn2Vt0zjdtHPPYjDODoLw nUZnxkaJp8NhRV8UmHBACZjrdQpToUHe+XxVIjDt1DAHNnlmQzIcNdQ/Es9s10oXOHrB Z1fW3j5EOQyUbYRcLQo0Ju5tSgwUkLuJOx5R/vYT1MBoP6Qxtdi3XXX867vyHioQTx5L tZ62jHP9mwgIgUFz2k7wCScQ2EJ37EsUmp7bB1LN//KPdxaNqqh4Dj5IjaVR/qIKCfrr lQxw== X-Forwarded-Encrypted: i=1; AJvYcCX2pJLZqphXFgsmNYxh9Hh9dlfmX4V5eK4MRp1pyudQy3LZc7WtHQMOv2qcbbxerEaBzQA8NJvL6cKvfkI=@vger.kernel.org X-Gm-Message-State: AOJu0YwAOSQGHC3wqizjZo/FY0gn4p48Y7POWnODc9ESKJZwmh2GRjcW NxpA5EFyubMms7LbYU/mRjZiDNTBDwZrVr4i7GlSoZbLVx3J+vxd4ui0RXMdQ1oS7f6/lef+kjp ueeI= X-Gm-Gg: ASbGnctw9FUsIbaTCtI9lxIkAEKaM+Kh2TXEFSRJL1bUnssKdOmhsczGGI78SGu18At gVGi0CCb7buo0ZCT18c5DedlowS4f/2p+jGtCzFeFG4/6xXqLgpQCL9CXf6CMbBTNgtfUg9YK1r 4GD8Juys8+NJCgBuzyMJIclSrGyTlDrXRfzlveZfTxkmNVSIhEDd8HC2ATyK4C1K4btaZDVqXb3 cad3la12bobjxbdyjrZwYF2IODP++4JQPYOh2Ze8wE9aTe1GUvxI5opPB1dRSFO+RA8UDNqnUwL 1A/8F5Qi2SMJYddkPu+5u4WwWiOaEXZG9aWnKtakyaaWDJcV9/WrWWcOG+SzbDbLxV/RdKAiKTY yv8f3YuqibmHC4a/Gx0xPDvJJWUBMEGzcNdf7dxHinJWE26wbq6e/pdDtZdBOu3kYPCqUCorD+j yYip0YTsgbWt8/RXR6qaoEngH6wkRUjqstmhznHg== X-Google-Smtp-Source: AGHT+IG2i3ZVAyerpko0bG5HQErQy5GRVNKpfeYhSDmo+oadwIZX5NPw7Ys6zkScWliwVzH5YQeGVg== X-Received: by 2002:a05:6a00:3a0d:b0:7ab:6fdb:1d1f with SMTP id d2e1a72fcca58-7c3f7695779mr4532606b3a.29.1763652133881; Thu, 20 Nov 2025 07:22:13 -0800 (PST) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:6762:7dba:8487:43a1]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7c3f023f968sm3179642b3a.38.2025.11.20.07.22.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Nov 2025 07:22:13 -0800 (PST) From: Sergey Senozhatsky To: Andrew Morton , Minchan Kim , Yuwen Chen , Richard Chang Cc: Brian Geffon , Fengyu Lian , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-block@vger.kernel.org, Sergey Senozhatsky Subject: [RFC PATCHv5 3/6] zram: take write lock in wb limit store handlers Date: Fri, 21 Nov 2025 00:21:23 +0900 Message-ID: <20251120152126.3126298-4-senozhatsky@chromium.org> X-Mailer: git-send-email 2.52.0.rc1.455.g30608eb744-goog In-Reply-To: <20251120152126.3126298-1-senozhatsky@chromium.org> References: <20251120152126.3126298-1-senozhatsky@chromium.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Write device attrs handlers should take write zram init_lock. While at it, fixup coding styles. Signed-off-by: Sergey Senozhatsky Reviewed-by: Brian Geffon --- drivers/block/zram/zram_drv.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 7904159e9226..71f37b960812 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -519,7 +519,8 @@ struct zram_wb_req { }; =20 static ssize_t writeback_limit_enable_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t len) + struct device_attribute *attr, + const char *buf, size_t len) { struct zram *zram =3D dev_to_zram(dev); u64 val; @@ -528,18 +529,19 @@ static ssize_t writeback_limit_enable_store(struct de= vice *dev, if (kstrtoull(buf, 10, &val)) return ret; =20 - down_read(&zram->init_lock); + down_write(&zram->init_lock); spin_lock(&zram->wb_limit_lock); zram->wb_limit_enable =3D val; spin_unlock(&zram->wb_limit_lock); - up_read(&zram->init_lock); + up_write(&zram->init_lock); ret =3D len; =20 return ret; } =20 static ssize_t writeback_limit_enable_show(struct device *dev, - struct device_attribute *attr, char *buf) + struct device_attribute *attr, + char *buf) { bool val; struct zram *zram =3D dev_to_zram(dev); @@ -554,7 +556,8 @@ static ssize_t writeback_limit_enable_show(struct devic= e *dev, } =20 static ssize_t writeback_limit_store(struct device *dev, - struct device_attribute *attr, const char *buf, size_t len) + struct device_attribute *attr, + const char *buf, size_t len) { struct zram *zram =3D dev_to_zram(dev); u64 val; @@ -563,11 +566,11 @@ static ssize_t writeback_limit_store(struct device *d= ev, if (kstrtoull(buf, 10, &val)) return ret; =20 - down_read(&zram->init_lock); + down_write(&zram->init_lock); spin_lock(&zram->wb_limit_lock); zram->bd_wb_limit =3D val; spin_unlock(&zram->wb_limit_lock); - up_read(&zram->init_lock); + up_write(&zram->init_lock); ret =3D len; =20 return ret; --=20 2.52.0.rc1.455.g30608eb744-goog From nobody Tue Dec 2 02:04:56 2025 Received: from mail-pf1-f175.google.com (mail-pf1-f175.google.com [209.85.210.175]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1029936CDF1 for ; Thu, 20 Nov 2025 15:22:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652138; cv=none; b=gAux9XjfunGy70XggMEiilZvkZwFTeYImZlGOYo9gn1QyO249eHppM02Tt1z8oaq7KZcuuyrZdOJAkbovnvTF+Q8AAXSHRSO+TFAoqgRVVg0Fc1lOfSqDpaNKMgJQjuV3Fz1V8okkjc5j+MRRVUsu6YsfAmLOjSlesPR/SSG6Cs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652138; c=relaxed/simple; bh=PRNpmIyzIQt6oDSuT13eKGI1o2cKI4pCtHaFoUAiu9s=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=EiAAfm9lSWtVnaHqJZzACnldFLAfSRpMEnWOHJLb4wHFMpEfd2xQnF0zmosUDhqWwACiX8HHx9c1COHZ3y62mE25xEVn9yvgwmTQ3ts+RKLDaBisMHNnFEF6YYxiSC/o7pViD49pg+D3NY9a0keKrFADdl8UnBN09UpKs0vg/Pk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org; spf=pass smtp.mailfrom=chromium.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b=CGd4azZR; arc=none smtp.client-ip=209.85.210.175 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=chromium.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="CGd4azZR" Received: by mail-pf1-f175.google.com with SMTP id d2e1a72fcca58-7b89c1ce9easo1158278b3a.2 for ; Thu, 20 Nov 2025 07:22:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; t=1763652136; x=1764256936; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=7bqQNyl0EBA1tCBIt5a+Z0GgRe/Buq+cexkkYbJh4q8=; b=CGd4azZRvFKin1+X23aed5sdzldklguJzf4PHguUpnbYmw2mPluv5pJvJrXEwPV1cN i+bHR1GTUDckO0iAf+VFpPO9l6n4ARbygxgot4IHTpbZkOPIRSh1oJ2p2HYX4xnezIht 6753luCxzOzQLdGDOBIjSXJyxFdYzjx4OSzo4= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1763652136; x=1764256936; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=7bqQNyl0EBA1tCBIt5a+Z0GgRe/Buq+cexkkYbJh4q8=; b=nWpLNVspw++cLG8qAcA5Uo/Db7QOly+1cs/qXKSOjt3eJsEhF/F40qSnql/H4IGwGI vEIRMU+1fDetSv5ej/Mi384rbYjMWnk+/Txzu0gbP8fMKcKMRnlid/+Ikp3WNvTPCfa2 ZII68fXm3XlbJ1qdAzru9G+pdApY89gkJYBLE0r+QayybOvsMA6Ebh/iIOn4CkBI3tRB M59dLGfYfl8RTV6ElX4gOaha6xR1M0h8oZv3aDqKLoCJASP/Pj5IHZ4fdf3+3ZWA/yxu FVJQmaE2RihKHJRUM7qeCAOlZX/GBz4XWfK8yfsFcUVOmT4A59TzGLbfst7MjqN63Nur IaOQ== X-Forwarded-Encrypted: i=1; AJvYcCWulaaUwP+nck0uOVXbLNnr81pu68LN+ZBLTRQDChM2lCKex/IWt/iuiVz1OSllLBw+4wj9Lu9my4GNSqw=@vger.kernel.org X-Gm-Message-State: AOJu0Yw+4/W6FgGJZaiBiO++eslUk2u6yAHQLmjMsY5rr2M1tAfkIV60 CO8/HClCaimnJooYGA8H7RPEVGieH8MWgV1P6+2kl9GNusVTxqjBlEjaoAcidjhcXg== X-Gm-Gg: ASbGncvYrnUkvybjYsOIidkajzEf1Usip3TIm0fGjV8KCBK3QbrpXooPmh+hEhSAYiF V/efTmsU9/YGnDGuIPEJVKnwQxNtbEGhGtdusEilNH2Wrs2+lpzH1j5BAkNjciSj+8mFGxNlPPP ZeCLu1oaHdHBDZWrzUEBETWeDjtEGmh/HCS8ToNz3PkA62UMTTpxVA6wIyNkVzHCUjRB02gQuaw jb94GxelcEvvdGR5Bp4InMNE4nlP/qFgp2zQw/utkzDOVAHHH20ielN1s5j0EUid30zLwHokbVy 1oXl9l0hBdPOOmSNDv8+XkG0jUYGsJgWnSxlh1H5rE2F4FnU/xssX3dwnvxA1uWLOUTmPeAhvk3 CX8YjIqq3uHcd9y6sa0jZ7ZKY9xq37yPp6Y5V30EI5qkzG/rHVaJ3AUEZ6KCEtGrSW+sFisHSF3 /Il0+8WgZU4v65h5VSxghTqxH7nfoLukzAh9k9ErnFas64cyfb X-Google-Smtp-Source: AGHT+IE03gD53APBfw1EXEVlOEjEP8sWWJxhTauo8qfdCA6G5JLbr6CU65y8SGc2126/gbRkzxoUKg== X-Received: by 2002:a05:6a00:23c3:b0:7aa:d7dd:b7dc with SMTP id d2e1a72fcca58-7c3f0b62fe1mr4912657b3a.31.1763652136376; Thu, 20 Nov 2025 07:22:16 -0800 (PST) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:6762:7dba:8487:43a1]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7c3f023f968sm3179642b3a.38.2025.11.20.07.22.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Nov 2025 07:22:16 -0800 (PST) From: Sergey Senozhatsky To: Andrew Morton , Minchan Kim , Yuwen Chen , Richard Chang Cc: Brian Geffon , Fengyu Lian , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-block@vger.kernel.org, Sergey Senozhatsky Subject: [RFC PATCHv5 4/6] zram: drop wb_limit_lock Date: Fri, 21 Nov 2025 00:21:24 +0900 Message-ID: <20251120152126.3126298-5-senozhatsky@chromium.org> X-Mailer: git-send-email 2.52.0.rc1.455.g30608eb744-goog In-Reply-To: <20251120152126.3126298-1-senozhatsky@chromium.org> References: <20251120152126.3126298-1-senozhatsky@chromium.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" We don't need wb_limit_lock. Writeback limit setters take an exclusive write zram init_lock, while wb_limit modifications happen only from a single task and under zram read init_lock. No concurrent wb_limit modifications are possible (we permit only one post-processing task at a time). Add lockdep assertions to wb_limit mutators. While at it, fixup coding styles. Signed-off-by: Sergey Senozhatsky Reviewed-by: Brian Geffon --- drivers/block/zram/zram_drv.c | 22 +++++----------------- drivers/block/zram/zram_drv.h | 1 - 2 files changed, 5 insertions(+), 18 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 71f37b960812..671ef2ec9b11 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -530,9 +530,7 @@ static ssize_t writeback_limit_enable_store(struct devi= ce *dev, return ret; =20 down_write(&zram->init_lock); - spin_lock(&zram->wb_limit_lock); zram->wb_limit_enable =3D val; - spin_unlock(&zram->wb_limit_lock); up_write(&zram->init_lock); ret =3D len; =20 @@ -547,9 +545,7 @@ static ssize_t writeback_limit_enable_show(struct devic= e *dev, struct zram *zram =3D dev_to_zram(dev); =20 down_read(&zram->init_lock); - spin_lock(&zram->wb_limit_lock); val =3D zram->wb_limit_enable; - spin_unlock(&zram->wb_limit_lock); up_read(&zram->init_lock); =20 return sysfs_emit(buf, "%d\n", val); @@ -567,9 +563,7 @@ static ssize_t writeback_limit_store(struct device *dev, return ret; =20 down_write(&zram->init_lock); - spin_lock(&zram->wb_limit_lock); zram->bd_wb_limit =3D val; - spin_unlock(&zram->wb_limit_lock); up_write(&zram->init_lock); ret =3D len; =20 @@ -577,15 +571,13 @@ static ssize_t writeback_limit_store(struct device *d= ev, } =20 static ssize_t writeback_limit_show(struct device *dev, - struct device_attribute *attr, char *buf) + struct device_attribute *attr, char *buf) { u64 val; struct zram *zram =3D dev_to_zram(dev); =20 down_read(&zram->init_lock); - spin_lock(&zram->wb_limit_lock); val =3D zram->bd_wb_limit; - spin_unlock(&zram->wb_limit_lock); up_read(&zram->init_lock); =20 return sysfs_emit(buf, "%llu\n", val); @@ -869,18 +861,18 @@ static struct zram_wb_ctl *init_wb_ctl(struct zram *z= ram) =20 static void zram_account_writeback_rollback(struct zram *zram) { - spin_lock(&zram->wb_limit_lock); + lockdep_assert_held_read(&zram->init_lock); + if (zram->wb_limit_enable) zram->bd_wb_limit +=3D 1UL << (PAGE_SHIFT - 12); - spin_unlock(&zram->wb_limit_lock); } =20 static void zram_account_writeback_submit(struct zram *zram) { - spin_lock(&zram->wb_limit_lock); + lockdep_assert_held_read(&zram->init_lock); + if (zram->wb_limit_enable && zram->bd_wb_limit > 0) zram->bd_wb_limit -=3D 1UL << (PAGE_SHIFT - 12); - spin_unlock(&zram->wb_limit_lock); } =20 static int zram_writeback_complete(struct zram *zram, struct zram_wb_req *= req) @@ -1004,13 +996,10 @@ static int zram_writeback_slots(struct zram *zram, u32 index =3D 0; =20 while ((pps =3D select_pp_slot(ctl))) { - spin_lock(&zram->wb_limit_lock); if (zram->wb_limit_enable && !zram->bd_wb_limit) { - spin_unlock(&zram->wb_limit_lock); ret =3D -EIO; break; } - spin_unlock(&zram->wb_limit_lock); =20 while (!req) { req =3D zram_select_idle_req(wb_ctl); @@ -2961,7 +2950,6 @@ static int zram_add(void) init_rwsem(&zram->init_lock); #ifdef CONFIG_ZRAM_WRITEBACK zram->wb_batch_size =3D 32; - spin_lock_init(&zram->wb_limit_lock); #endif =20 /* gendisk structure */ diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h index 1a647f42c1a4..c6d94501376c 100644 --- a/drivers/block/zram/zram_drv.h +++ b/drivers/block/zram/zram_drv.h @@ -127,7 +127,6 @@ struct zram { bool claim; /* Protected by disk->open_mutex */ #ifdef CONFIG_ZRAM_WRITEBACK struct file *backing_dev; - spinlock_t wb_limit_lock; bool wb_limit_enable; u32 wb_batch_size; u64 bd_wb_limit; --=20 2.52.0.rc1.455.g30608eb744-goog From nobody Tue Dec 2 02:04:56 2025 Received: from mail-pf1-f178.google.com (mail-pf1-f178.google.com [209.85.210.178]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id ABB52393DEE for ; Thu, 20 Nov 2025 15:22:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652141; cv=none; b=fr7MYSy+HWRz1jSPybfKulAk3Hww/IEhoLmckDzI+yJxlQGpuEarIpQOkojUV0u13skmje+inmJBV2qHqvoSRYnfTyN9MciGzzQiNd3BE+4kMhJSy+oGFd5KOWKT1VsdizR3jS5WyzOWJF7wZEOIZH9soMXsrn9i8SNBXytv0ZA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652141; c=relaxed/simple; bh=xh0wq/JDXVle3NdWYWWXd4nwFWgCl9HcbB9h7Lb+cJA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Rd36ORu8o8r7OUz8/0yiSmSOySn3plyrUY5EyAXc4Pgbg+oOS9IMZ+nGRiPvIe4S8E05Qsx5QaGQ8UidQFtJBjkH/k7Ysme+YRfqoCbDwkD+AotsA0SUG7N3i91cf0V5shBaFjc/rpNJFbZJ/GAP3UUC1E2YLZxrdAhrRit/M+k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org; spf=pass smtp.mailfrom=chromium.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b=Bx4+J/1w; arc=none smtp.client-ip=209.85.210.178 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=chromium.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="Bx4+J/1w" Received: by mail-pf1-f178.google.com with SMTP id d2e1a72fcca58-7bc0cd6a13aso696528b3a.0 for ; Thu, 20 Nov 2025 07:22:19 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; t=1763652139; x=1764256939; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=60qtdCMZp80VF5yuM/N6mmuFIve0x6cnvVTEq7lRrcI=; b=Bx4+J/1ww1iXgppJjZ05YjtolM993qrUwcDTgpNBI+DNaSysJnaccmlRxtCa25IwPa umhm79wbQyBCWcoTU0sedYw2OhcpF7xd0sjxU1QaUMdEsXNdYguoWfBd6TVJpzs5xcLR IIqwhbe20RqrpmNfXxn2SGZXJWYh5/OZ+WqBE= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1763652139; x=1764256939; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=60qtdCMZp80VF5yuM/N6mmuFIve0x6cnvVTEq7lRrcI=; b=rmKe45Hb/bzyKVMlptUEmx2RZM0nFPIsq8Jvmwo+vucqMP+kki1jFnELkH+KKiw/vk 2OHuBziHB0FCHkkNxfZqeJpb3ueNZvjfVNmXP82j+ZfXVWuM8FVRlBnIYHJOLN0zKmU/ VEMRvj55AMprCl5BhLo3EIa0xv9lY0SKK4JNyGtIxPATY8gt+eZG99OZ9w7ykJ+mgzUu Rg+QFWtEHaU/1nZpPU4L8ksfiDonjtvejQjhbHz+ki+r0+ogmOWdjoLJEf7/fHwwTUud Nkn8XYKN3yGAULOcTkaZSkJdvCI4dJa2jbZ7uaX10jTXKuqL+sLbfIajV/MJeXPXg2mU 1dkg== X-Forwarded-Encrypted: i=1; AJvYcCVbyw9r/lOmmmK4+IhSFN/nALaHkCT+rh9oF4AJm39BbE9PuejNsq35eU1lD1Z5gyPwzPlJ5zudOqwZEzA=@vger.kernel.org X-Gm-Message-State: AOJu0YzZp4aWoX9Y+ReCEWanIWzAaer18aNVuQbvtVRMQ69w80fKEqrx tPHrHG1vmvS/mkRdogbRnR7jij7XonPaIk1z4Y47/e+mH6QP2SJ0dUReOEmN1j394tx3P0JtesB nSO0= X-Gm-Gg: ASbGncsaN37P3xbeXFwHK9VoftiCUFmMtnEebT43SARbYwVQqa7IXwHAf3q89wJNiUJ 6ikXmlSEeApazYpoa4OpRS6WyIB/H46HqYfeuQ+dufmhJfoj+pusF1/lgnGD7Joq3mPtrwhXTmu u48s4UHuG3wqpEmjKid7DiQm87lrsW9r2x89MTHmPYeOhicN6O1K4OSqD40hc+5KJE6NQROJJhy hXhZeWnW5JOn/PjKyCcfINqHV687io9NP/0nwpIY9JOWNp2R7ebdFhyiLQUxWW5Xi5yXEI/9WQp Xcx6UZPMedxVg1W3F74EkbRTDBkqBSDVPnH9AkOzyIVqB6dsjaUcyFTu5RlsgM0Xg1yCnkM/TYP rMntn2/X+sgeHhBSCqNSw7E2NL/Y01MdfMPkAkaAdJRxXQlGEYvRbYZ0pN0vGMCtcsHhoRg2X7s T1hgg27pRXnk7hpuZf8XovO19V9zEIn/0HxO8TbA== X-Google-Smtp-Source: AGHT+IF55sfvtR57vKBk+ytDZecrzkU4GEMllnIDmAZESJWF3inRrxqebY2ATzJpA3aK4tJ/iPpEuw== X-Received: by 2002:a05:6a00:ae09:b0:77d:c625:f5d3 with SMTP id d2e1a72fcca58-7c41dd0b2f7mr3534869b3a.1.1763652138839; Thu, 20 Nov 2025 07:22:18 -0800 (PST) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:6762:7dba:8487:43a1]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7c3f023f968sm3179642b3a.38.2025.11.20.07.22.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Nov 2025 07:22:18 -0800 (PST) From: Sergey Senozhatsky To: Andrew Morton , Minchan Kim , Yuwen Chen , Richard Chang Cc: Brian Geffon , Fengyu Lian , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-block@vger.kernel.org, Sergey Senozhatsky Subject: [RFC PATCHv5 5/6] zram: rework bdev block allocation Date: Fri, 21 Nov 2025 00:21:25 +0900 Message-ID: <20251120152126.3126298-6-senozhatsky@chromium.org> X-Mailer: git-send-email 2.52.0.rc1.455.g30608eb744-goog In-Reply-To: <20251120152126.3126298-1-senozhatsky@chromium.org> References: <20251120152126.3126298-1-senozhatsky@chromium.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" First, writeback bdev ->bitmap bits are set only from one context, as we can have only one single task performing writeback, so we cannot race with anything else. Remove retry path. Second, we always check ZRAM_WB flag to distinguish writtenback slots, so we should not confuse 0 bdev block index and 0 handle. We can use first bdev block (0 bit) for writeback as well. While at it, give functions slightly more accurate names, as we don't alloc/free anything there, we reserve a block for async writeback or release the block. Signed-off-by: Sergey Senozhatsky Reviewed-by: Brian Geffon --- drivers/block/zram/zram_drv.c | 37 +++++++++++++++++------------------ 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index 671ef2ec9b11..ecbd9b25dfed 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -500,6 +500,8 @@ static ssize_t idle_store(struct device *dev, } =20 #ifdef CONFIG_ZRAM_WRITEBACK +#define INVALID_BDEV_BLOCK (~0UL) + struct zram_wb_ctl { struct list_head idle_reqs; struct list_head done_reqs; @@ -746,23 +748,20 @@ static ssize_t backing_dev_store(struct device *dev, return err; } =20 -static unsigned long alloc_block_bdev(struct zram *zram) +static unsigned long zram_reserve_bdev_block(struct zram *zram) { - unsigned long blk_idx =3D 1; -retry: - /* skip 0 bit to confuse zram.handle =3D 0 */ - blk_idx =3D find_next_zero_bit(zram->bitmap, zram->nr_pages, blk_idx); - if (blk_idx =3D=3D zram->nr_pages) - return 0; + unsigned long blk_idx; =20 - if (test_and_set_bit(blk_idx, zram->bitmap)) - goto retry; + blk_idx =3D find_next_zero_bit(zram->bitmap, zram->nr_pages, 0); + if (blk_idx =3D=3D zram->nr_pages) + return INVALID_BDEV_BLOCK; =20 + set_bit(blk_idx, zram->bitmap); atomic64_inc(&zram->stats.bd_count); return blk_idx; } =20 -static void free_block_bdev(struct zram *zram, unsigned long blk_idx) +static void zram_release_bdev_block(struct zram *zram, unsigned long blk_i= dx) { int was_set; =20 @@ -887,7 +886,7 @@ static int zram_writeback_complete(struct zram *zram, s= truct zram_wb_req *req) * (if enabled). */ zram_account_writeback_rollback(zram); - free_block_bdev(zram, req->blk_idx); + zram_release_bdev_block(zram, req->blk_idx); return err; } =20 @@ -901,7 +900,7 @@ static int zram_writeback_complete(struct zram *zram, s= truct zram_wb_req *req) * finishes. */ if (!zram_test_flag(zram, index, ZRAM_PP_SLOT)) { - free_block_bdev(zram, req->blk_idx); + zram_release_bdev_block(zram, req->blk_idx); goto out; } =20 @@ -989,8 +988,8 @@ static int zram_writeback_slots(struct zram *zram, struct zram_pp_ctl *ctl, struct zram_wb_ctl *wb_ctl) { + unsigned long blk_idx =3D INVALID_BDEV_BLOCK; struct zram_wb_req *req =3D NULL; - unsigned long blk_idx =3D 0; struct zram_pp_slot *pps; int ret =3D 0, err =3D 0; u32 index =3D 0; @@ -1022,9 +1021,9 @@ static int zram_writeback_slots(struct zram *zram, ret =3D err; } =20 - if (!blk_idx) { - blk_idx =3D alloc_block_bdev(zram); - if (!blk_idx) { + if (blk_idx =3D=3D INVALID_BDEV_BLOCK) { + blk_idx =3D zram_reserve_bdev_block(zram); + if (blk_idx =3D=3D INVALID_BDEV_BLOCK) { ret =3D -ENOSPC; break; } @@ -1058,7 +1057,7 @@ static int zram_writeback_slots(struct zram *zram, __bio_add_page(&req->bio, req->page, PAGE_SIZE, 0); =20 zram_submit_wb_request(zram, wb_ctl, req); - blk_idx =3D 0; + blk_idx =3D INVALID_BDEV_BLOCK; req =3D NULL; cond_resched(); continue; @@ -1365,7 +1364,7 @@ static int read_from_bdev(struct zram *zram, struct p= age *page, return -EIO; } =20 -static void free_block_bdev(struct zram *zram, unsigned long blk_idx) +static void zram_release_bdev_block(struct zram *zram, unsigned long blk_i= dx) { } #endif @@ -1889,7 +1888,7 @@ static void zram_free_page(struct zram *zram, size_t = index) =20 if (zram_test_flag(zram, index, ZRAM_WB)) { zram_clear_flag(zram, index, ZRAM_WB); - free_block_bdev(zram, zram_get_handle(zram, index)); + zram_release_bdev_block(zram, zram_get_handle(zram, index)); goto out; } =20 --=20 2.52.0.rc1.455.g30608eb744-goog From nobody Tue Dec 2 02:04:56 2025 Received: from mail-pf1-f181.google.com (mail-pf1-f181.google.com [209.85.210.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3FED43A5E65 for ; Thu, 20 Nov 2025 15:22:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652143; cv=none; b=O04kENuxHOKTXMsrC9odqWJQzZSxwLyMYVMUaV6dmSKFsZVCv8tB59DpkseM7MvXpzyU+c+jyCa6ZsvG7edURv7STUMBLMMLL6op+fpPGiS6/ZuKtdh/g4Xoc3RS/eIMlRkhRe1KM5fxuml5/iGzRm7YzC9J3ejURf6kFYrZ9Yk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763652143; c=relaxed/simple; bh=y+gm9Kdn13Kq1FR94zZcC/GIw4xAbbRNUeEu8hUgXDE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=uWzSdoKHIkBl5AjdAbMoJwkl+AJpaQQMA0LViGQG0NYbOsnOxHI03GGgqpBAC4+P//WaLvs/Mk4BpjsOLOKMsWdcB7FznUuX3tuSiTpePIw6E9hVhIj0CoPpxaH+S+cwrSrLLYrhhQHyCHIBBAh1A/h3gtbsM1M71/oUwyVKVw0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org; spf=pass smtp.mailfrom=chromium.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b=FsL92oxF; arc=none smtp.client-ip=209.85.210.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=chromium.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=chromium.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="FsL92oxF" Received: by mail-pf1-f181.google.com with SMTP id d2e1a72fcca58-7acd9a03ba9so1140033b3a.1 for ; Thu, 20 Nov 2025 07:22:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; t=1763652141; x=1764256941; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=hNBO1q43Z4HLMo3u95PxV7vGEr2bqJ5I/H/pDo2xib0=; b=FsL92oxFlAkFyG1yYpdi5f7rwrv94UkVJ5KsBnfNqYgljA0aIRi4Z4gqVeawSVsSGy TiroerSCAfQgvBT6oDFPKV8QbvBg2XKCqDNfRmQhLhyQSLmrcFJr3SQAtXX3VrE7q6uT KpuHf6QusGD3ZKN8wvYT3XMbNIFqMMqsza8o4= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1763652141; x=1764256941; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=hNBO1q43Z4HLMo3u95PxV7vGEr2bqJ5I/H/pDo2xib0=; b=wUScK+iJJ1YEBoS8dp5onA9jt0aASklf3f26Hnx9BWTg/z+BZNA8hCU/G032O7P5zL 2Z2CThLKSLjKJjSXo4SB0m60IyjKu59BLueSzOGoca331ht3vQItKFXxbgeEpRABO3lQ Fs0CkLdIqroUfd3F1GeXwRpCOV8Z/ZpM6z5c0gKp8LAf6QmhSL6e9KPqAtpWgBc+/Aei 6ZsqSnVJnzUnkUj7PBEyi1/IN/RvYO9na9U/488Ax2RUZe3UfJrux92JdhOkLVDfA181 TKSIDtOtD/4iYrSk5KyfHhqpJzAUuq2xioGP97qwXSiD3bmvAdDOpogdtbVOX+ywTDvS wXJQ== X-Forwarded-Encrypted: i=1; AJvYcCWRU0g2VSdC9A1CCU4utNUZJiD3VwDqipiVjiMX8+vWvggQgaTMNOCMIi1/R1qUDBoGXPrbMrKqb8SR6V8=@vger.kernel.org X-Gm-Message-State: AOJu0Yxxqt5MN6biTRDiyTrelAm8BZIs0js6dc3PHNlc/BELJBFqztW5 Yy0ld1ABWOwCjEbwH88QWxrUHo7vHcr+l8BwY+8NRyD5XBkIaATWRhBQ7m9EFbdRUA== X-Gm-Gg: ASbGnct5bXPe2YXfA9KkGMi7hdqHFO5Mvh/ggGyNTzZfRojHX9Mwil/bdD5hf0Mc+ln H2oGaTu0GZ9zMfqbz9joq+7xr1LONF8AvbH0j9FKJznOLZlMjxBSi+fO8OBq3rrKHQvk4mbrpAY PKS7Ujpc9uW2EICVwf55BGC8W4ejv+Uk8iz48mK4onnwKhAlj12PMtxhMTRFHiSQ4QGbU1DoMCW fAq8Vvtn4TvkIL4ApW2X4ZxXHBCnh+iCAieBwTlCmU4t1AvmPOqvzKC79bvy+e25OTyjb6G55Bw IjSkRmJKLGlMZx801rmSQAEt9ZqUfMQxXzMIYmlJ7Q6nEBWjC32QbJhCqksnpiWW2sbGy0LOtfF r9WeJI86I11FPww0ranpSN8rjkjWJq1g4mC6UbucWcTXTYTTfz3YlneZjqsc/U8IlYte5dUF64r lTUdSXbFMHyE6kWrDxuNb78CekqJ1UYEyiBrVEyQ== X-Google-Smtp-Source: AGHT+IGM/LtK9fM0SsN5LsA6eyPljhRQtoqszEcAtB8Xy29m8uMD4FUL1K10u/XIZzdHc9yqVpK3Kw== X-Received: by 2002:a05:6a00:3926:b0:7aa:2d04:ccf6 with SMTP id d2e1a72fcca58-7c3f211a3femr4367565b3a.0.1763652141473; Thu, 20 Nov 2025 07:22:21 -0800 (PST) Received: from tigerii.tok.corp.google.com ([2401:fa00:8f:203:6762:7dba:8487:43a1]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7c3f023f968sm3179642b3a.38.2025.11.20.07.22.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Nov 2025 07:22:21 -0800 (PST) From: Sergey Senozhatsky To: Andrew Morton , Minchan Kim , Yuwen Chen , Richard Chang Cc: Brian Geffon , Fengyu Lian , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-block@vger.kernel.org, Sergey Senozhatsky Subject: [RFC PATCHv5 6/6] zram: read slot block idx under slot lock Date: Fri, 21 Nov 2025 00:21:26 +0900 Message-ID: <20251120152126.3126298-7-senozhatsky@chromium.org> X-Mailer: git-send-email 2.52.0.rc1.455.g30608eb744-goog In-Reply-To: <20251120152126.3126298-1-senozhatsky@chromium.org> References: <20251120152126.3126298-1-senozhatsky@chromium.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Read slot's block id under slot-lock. We release the slot-lock for bdev read so, technically, slot still can get freed in the meantime, but at least we will read bdev block (page) that holds previous know slot data, not from slot->handle bdev block, which can be anything at that point. Signed-off-by: Sergey Senozhatsky Reviewed-by: Brian Geffon --- drivers/block/zram/zram_drv.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index ecbd9b25dfed..1f2867cd587e 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -1994,14 +1994,14 @@ static int zram_read_page(struct zram *zram, struct= page *page, u32 index, ret =3D zram_read_from_zspool(zram, page, index); zram_slot_unlock(zram, index); } else { + unsigned long blk_idx =3D zram_get_handle(zram, index); + /* * The slot should be unlocked before reading from the backing * device. */ zram_slot_unlock(zram, index); - - ret =3D read_from_bdev(zram, page, zram_get_handle(zram, index), - parent); + ret =3D read_from_bdev(zram, page, blk_idx, parent); } =20 /* Should NEVER happen. Return bio error if it does. */ --=20 2.52.0.rc1.455.g30608eb744-goog