From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001027; cv=none; d=zohomail.com; s=zohoarc; b=CVtaajscP5bhpsIC/nRaKHMRQB9T9WKd8/mT1Z+HODAW9ziFCen5xgu0hXbHPSK25FWgtCH4tVZAwoFokYyL4xOeNSdPvaCPg63zY1KotyqOV8jfZvnHzOn4AWjtHiqlPWbYGBHMVsa9C64P9OQKQJ3FQJkEHF2f45jbQWmV4YA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001027; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=LU+u3wXpBsOqhW2nYURVaQWmnYwQHrHOufAXLgAFDPU=; b=T/uZ53xwsmUXQUgPwJrLriBm7XrDlL7jf8wPxOpOreT3ukQLE2OcgJ4+effaFnepbJMAXrxo2bIG2OMrAFFpbs9WupVYJfuyXTngpjC59XCOUaezsmfIvWaMVUCD9ZbZVU/BpeNLPBcPczJ8N5oVep2s5rxWU7lz+JIYpeh3vlA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001027809197.8981486005937; Mon, 21 Sep 2026 07:30:27 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f1n-0002MR-UU; Mon, 21 Sep 2026 10:29:57 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0k-0001vp-SZ; Mon, 21 Sep 2026 10:28:53 -0400 Received: from sea.source.kernel.org ([172.234.252.31]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0j-00006O-5R; Mon, 21 Sep 2026 10:28:50 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 2B885419F3; Mon, 21 Sep 2026 14:28:39 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 336D11F000FF; Mon, 21 Sep 2026 14:28:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000919; bh=LU+u3wXpBsOqhW2nYURVaQWmnYwQHrHOufAXLgAFDPU=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Wys6/WOrc6+Myq6kEOJiN/B0CU8vMA5zYQQG1thDj0B4Y6fqOzHR4xsYS4OE3Lhh3 vzGOp64kBLrJZ+T2fBQ9nQW8w/VfM94o7WDnewAInVv4wueR9EL4VM6wuWeVXVVxvr i7SPSStZdnxoUfbVshzYcTdxfsdgegOM4URZG9JqpQDJm7J8Rp2dae0DdPEcC6KVU6 tkAdk1hiaaxwAeonsqKxD+pBMf6+ohd73106Np4cPv93lh+kTxFVlGzlusoifqyoV5 2nER45MejY+O+rWfU/1vZcnff9rhdhJ2vkaNGViz3znUXoPbJuMaosH/b04H/6Enbd KYB+JP8ZodAQA== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 01/15] block: widen BlockLimits.zone_size to uint64_t Date: Mon, 21 Sep 2026 16:28:03 +0200 Message-ID: <20260921142819.2916043-2-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.234.252.31; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001028173158500 Content-Type: text/plain; charset="utf-8" From: Sam Li The zone-size field in BlockLimits is currently uint32_t, capping expressible zone sizes at 4 GiB. Real zoned-device protocols like NVMe ZNS allow larger zones. Widen BlockLimits.zone_size to uint64_t to match. Signed-off-by: Sam Li Reviewed-by: Niklas Cassel Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- block/file-posix.c | 2 +- include/block/block_int-common.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/block/file-posix.c b/block/file-posix.c index 9aad156aad..c0d6ee30e4 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -3598,7 +3598,7 @@ raw_co_zone_append(BlockDriverState *bs, =20 if (*offset & zone_size_mask) { error_report("sector offset %" PRId64 " is not aligned to zone siz= e " - "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512); + "%" PRId64 "", *offset / 512, bs->bl.zone_size / 512); return -EINVAL; } =20 diff --git a/include/block/block_int-common.h b/include/block/block_int-com= mon.h index 147c08155f..7571ed9968 100644 --- a/include/block/block_int-common.h +++ b/include/block/block_int-common.h @@ -901,7 +901,7 @@ typedef struct BlockLimits { BlockZoneModel zoned; =20 /* zone size expressed in bytes */ - uint32_t zone_size; + uint64_t zone_size; =20 /* total number of zones */ uint32_t nr_zones; --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001036; cv=none; d=zohomail.com; s=zohoarc; b=oJ+0GUj0BtzB/Sr7R1MjNam+9+DnQ7jMLkFu5f7FeXGjKYTlXVqJeQzP5X4ksUQqJGmq31I+7jOJXKXGRzQC7oi5froGZciFjw+o57MnrjIUX28HoHQNWpW0VOz0mCZscWpIY1U5GE+3DzHooYt/qtVMnGVzDj5TjG+3nyPNmfw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001036; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=73VXbOmIWKrxxbLYFyatApK8x2l7ryOhTMdeyx8DgzQ=; b=imPR62vgcZTpCaMwEA62AXAY5m1qrnHVbFpRUcuPXXalDz/7d10leoBRasG3NsQwGdyTk2Y7Rrk2GpU0iqS4KMOIpXiaW1bbkCcAB0nOTaclu9lO8UtFQSmLLI8X9umPF8DLKdorqLv3LLP57RrahXqm0qUnCLx94HIL7qyjkQY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001036193924.7791009065461; Mon, 21 Sep 2026 07:30:36 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2E-00033K-1i; Mon, 21 Sep 2026 10:30:22 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0k-0001vo-TP; Mon, 21 Sep 2026 10:28:55 -0400 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0h-000073-7H; Mon, 21 Sep 2026 10:28:50 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id BFFB540803; Mon, 21 Sep 2026 14:28:41 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 99B771F000FF; Mon, 21 Sep 2026 14:28:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000921; bh=73VXbOmIWKrxxbLYFyatApK8x2l7ryOhTMdeyx8DgzQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=XLKGWLoniOw/NENbRyFbzOXYD56qDSBXR39sfXBMaLOjr0tDzudmUaZvt4XUYIE7n Czq7bDP83/SBqXhclRXIx1R5vNoHCh0VVG2UN9Agip5SvWPQ7qrP4sBsUjMVP1RIbQ UKS25ID6jnaRE0yYyM5gVSbBjtYt0/6u2AewBRTtriagDHPkHccnwofQWK2xI+Dzlp z2EFJiiYbwHf/8+qIfVxGuFRx94AB2cu0uWi6HYu/IC6NArK2b37dhSUC/bKyJGhSK CEpjnKaHwF+soadlkqu3YV/tL8IkuMgHATABgk8/Lvbc5WIdTXTwty0cUbb+po0v6z GkKeNz+Eo/LUw== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Hanna Reitz , "Michael S. Tsirkin" Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 02/15] virtio-blk: do not merge requests across a zone boundary Date: Mon, 21 Sep 2026 16:28:04 +0200 Message-ID: <20260921142819.2916043-3-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=2600:3c0a:e001:78e:0:1991:8:25; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001038475158500 Content-Type: text/plain; charset="utf-8" From: Sam Li virtio_blk_submit_multireq() fuses adjacent in-zone requests into a single request. On a zoned backend, a merged zone append request that straddles a zone boundary is rejected by the device because each write/read must stay within a single zone (virtio 1.4, 5.2.6.1). Add a bail condition to the merge coalescer: if combining the candidate request into the current batch would cross a zone boundary, flush the current batch and start a new one. Signed-off-by: Sam Li Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Reviewed-by: Niklas Cassel Signed-off-by: Niklas Cassel --- block/block-backend.c | 11 +++++++++++ hw/block/virtio-blk.c | 22 +++++++++++++++++++++- include/system/block-backend-io.h | 1 + 3 files changed, 33 insertions(+), 1 deletion(-) diff --git a/block/block-backend.c b/block/block-backend.c index 37ba7e9fc4..049e70ddcb 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -2326,6 +2326,17 @@ uint32_t blk_get_request_alignment(BlockBackend *blk) return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE; } =20 +/* + * Returns the zone size in bytes for a zoned backend, or 0 if @blk does + * not present zoned geometry. + */ +uint64_t blk_get_zone_size(BlockBackend *blk) +{ + BlockDriverState *bs =3D blk_bs(blk); + IO_CODE(); + return bs ? bs->bl.zone_size : 0; +} + /* Returns the optimal write zeroes alignment, in bytes; guaranteed nonzer= o */ uint32_t blk_get_pwrite_zeroes_alignment(BlockBackend *blk) { diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 61c341ce2c..1b93364b24 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -288,6 +288,9 @@ static void virtio_blk_submit_multireq(VirtIOBlock *s, = MultiReqBuffer *mrb) int i =3D 0, start =3D 0, num_reqs =3D 0, niov =3D 0, nb_sectors =3D 0; uint32_t max_transfer; int64_t sector_num =3D 0; + uint64_t zone_size =3D blk_get_zone_size(s->blk); + bool zone_cross; + int64_t zone_nr_sectors, end_sector; =20 if (mrb->num_reqs =3D=3D 1) { submit_requests(s, mrb, 0, 1, -1); @@ -303,17 +306,34 @@ static void virtio_blk_submit_multireq(VirtIOBlock *s= , MultiReqBuffer *mrb) for (i =3D 0; i < mrb->num_reqs; i++) { VirtIOBlockReq *req =3D mrb->reqs[i]; if (num_reqs > 0) { + /* + * On zoned backends, a single backend write/read must not span + * a zone boundary. Bail out of merging if combining req into + * the current batch would straddle a zone. + */ + if (zone_size > 0) { + zone_nr_sectors =3D zone_size / BDRV_SECTOR_SIZE; + end_sector =3D req->sector_num + + req->qiov.size / BDRV_SECTOR_SIZE - 1; + zone_cross =3D (sector_num / zone_nr_sectors) !=3D + (end_sector / zone_nr_sectors); + } else { + zone_cross =3D false; + } + /* * NOTE: We cannot merge the requests in below situations: * 1. requests are not sequential * 2. merge would exceed maximum number of IOVs * 3. merge would exceed maximum transfer length of backend de= vice + * 4. merge would cross a zone boundary on a zoned backend */ if (sector_num + nb_sectors !=3D req->sector_num || niov > blk_get_max_iov(s->blk) - req->qiov.niov || req->qiov.size > max_transfer || nb_sectors > (max_transfer - - req->qiov.size) / BDRV_SECTOR_SIZE) { + req->qiov.size) / BDRV_SECTOR_SIZE || + zone_cross) { submit_requests(s, mrb, start, num_reqs, niov); num_reqs =3D 0; } diff --git a/include/system/block-backend-io.h b/include/system/block-backe= nd-io.h index fd84723d9d..78d410b8df 100644 --- a/include/system/block-backend-io.h +++ b/include/system/block-backend-io.h @@ -121,6 +121,7 @@ uint32_t blk_get_request_alignment(BlockBackend *blk); uint32_t blk_get_pwrite_zeroes_alignment(BlockBackend *blk); uint32_t blk_get_max_transfer(BlockBackend *blk); uint64_t blk_get_max_hw_transfer(BlockBackend *blk); +uint64_t blk_get_zone_size(BlockBackend *blk); =20 int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in, BlockBackend *blk_out, int64_t off_out, --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001027; cv=none; d=zohomail.com; s=zohoarc; b=bW7X1eOMU1Uibgoe9uCbcvLIlAh8zZbxO08dMeTNVMoEoxciXNFQaHgZN68cJDbrkhgAiydhfqeadcfunsBGPFbDKx1SpDs/ocYhrFeK5ez0YdCZO4+w2MYh3lrBqE+xnpPNixbhSX4KLBnj+Hq3sq4mmWW++MwexQNvCfHcgbE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001027; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=0TseXxKZ6YAMQgEAEJHSB6EEf6dzHi76syAM7LVVolc=; b=T3DX+jjTZevfIp597Rey/vlLbdlPisNYWWfg1f83IMxNNPsXlXTuyssJ5yy2C15aZTMmwgaWg894WQYJfaa2mdFgcykKlU6A32BsH9LFuZN9c78Uvmms5A90PUx37jGpo0k/2xsaXPbwBaTNVXoc/Y1VNSPL4omElVkA0fQ08aQ= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001027326590.3899097180093; Mon, 21 Sep 2026 07:30:27 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f1s-0002Nt-44; Mon, 21 Sep 2026 10:30:00 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0k-0001vn-RF; Mon, 21 Sep 2026 10:28:53 -0400 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0h-00007M-7s; Mon, 21 Sep 2026 10:28:50 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id C036760120; Mon, 21 Sep 2026 14:28:44 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 416751F000FF; Mon, 21 Sep 2026 14:28:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000924; bh=0TseXxKZ6YAMQgEAEJHSB6EEf6dzHi76syAM7LVVolc=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=E7FMqybQDJdZbkUnaKo+NXF3fjZ4EiZcw86OhzfIPYRBuCdDXFNt5iEUDCseAmzvu mOxgiuQgDy/VOg3VOjN9Le2YzxVheE4Ac+gOAzYDjfxPLDD5HZ3d09Midm9BJ67ZpC JJ3jfzcXqvPMzSx/9uSVuA/61PeYuyYLZYfZ12n5MuRha3zkOpHunt7XYk1Aq87OaS KY2ulMqkJA9/4Sw2l6Q/iddZoqZ/kUz8UlKUJs5ZDl50VfLGs+RsJq0nWo2BV7QDYl R+uCNuOcZJnNSUrWTjju4XgOqtBTlONnYGEg6ogKCIUbR3v2zm00O92qwo1TMyqzxF b1NjA527jdnVg== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Hanna Reitz , Fam Zheng , "Michael S. Tsirkin" Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 03/15] block: add a helper for the index of the zone an offset falls in Date: Mon, 21 Sep 2026 16:28:05 +0200 Message-ID: <20260921142819.2916043-4-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=2600:3c04:e001:324:0:1991:8:25; envelope-from=cassel@kernel.org; helo=tor.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001028257158501 Content-Type: text/plain; charset="utf-8" Deriving the zone that an offset belongs to is open coded in five places, in two files, as a division of the offset by BlockLimits.zone_size. The zone size of a zoned device is always a power of two. Linux requires that of every zoned device it accepts, in blk_revalidate_disk_zones() and in each of the drivers that report one, and qcow2 rejects an image whose header says otherwise. So the division is a shift, and the shift is worth deriving once rather than at every use: record it in BlockLimits as zone_size_bits, next to the size it comes from, and assert the property that it relies on where it is computed. Add bdrv_zone_index() and use it. No functional change; the count of zones that a management operation spans stays a division, since it is a length rather than an offset. Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- block/file-posix.c | 8 ++++---- block/io.c | 12 ++++++++++++ hw/block/virtio-blk.c | 2 +- include/block/block-io.h | 2 ++ include/block/block_int-common.h | 7 +++++++ 5 files changed, 26 insertions(+), 5 deletions(-) diff --git a/block/file-posix.c b/block/file-posix.c index c0d6ee30e4..00323f7a9f 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -1359,7 +1359,7 @@ static int get_zones_wp(BlockDriverState *bs, int fd,= int64_t offset, size_t rep_size; uint64_t sector =3D offset >> BDRV_SECTOR_BITS; BlockZoneWps *wps =3D bs->wps; - unsigned int j =3D offset / bs->bl.zone_size; + unsigned int j =3D bdrv_zone_index(bs, offset); unsigned int n =3D 0, i =3D 0; int ret; rep_size =3D sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_= zone); @@ -2560,7 +2560,7 @@ raw_co_prw(BlockDriverState *bs, int64_t *offset_ptr,= uint64_t bytes, bs->bl.zoned !=3D BLK_Z_NONE) { qemu_co_mutex_lock(&bs->wps->colock); if (type & QEMU_AIO_ZONE_APPEND) { - int index =3D offset / bs->bl.zone_size; + int index =3D bdrv_zone_index(bs, offset); offset =3D bs->wps->wp[index]; } } @@ -2615,7 +2615,7 @@ out: bs->bl.zoned !=3D BLK_Z_NONE) { BlockZoneWps *wps =3D bs->wps; if (ret =3D=3D 0) { - uint64_t *wp =3D &wps->wp[offset / bs->bl.zone_size]; + uint64_t *wp =3D &wps->wp[bdrv_zone_index(bs, offset)]; if (!BDRV_ZT_IS_CONV(*wp)) { if (type & QEMU_AIO_ZONE_APPEND) { *offset_ptr =3D *wp; @@ -3513,7 +3513,7 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverS= tate *bs, BlockZoneOp op, return -EINVAL; } =20 - uint32_t i =3D offset / bs->bl.zone_size; + uint32_t i =3D bdrv_zone_index(bs, offset); uint32_t nrz =3D len / bs->bl.zone_size; uint64_t *wp =3D &wps->wp[i]; if (BDRV_ZT_IS_CONV(*wp) && len !=3D capacity) { diff --git a/block/io.c b/block/io.c index a916b236c3..cef23ee5bc 100644 --- a/block/io.c +++ b/block/io.c @@ -227,6 +227,11 @@ void bdrv_refresh_limits(BlockDriverState *bs, Transac= tion *tran, Error **errp) } } =20 + if (bs->bl.zone_size) { + assert(is_power_of_2(bs->bl.zone_size)); + bs->bl.zone_size_bits =3D ctz64(bs->bl.zone_size); + } + if (bs->bl.request_alignment > BDRV_MAX_ALIGNMENT) { error_setg(errp, "Driver requires too large request alignment"); } @@ -3361,6 +3366,13 @@ out: return co.ret; } =20 +uint32_t bdrv_zone_index(BlockDriverState *bs, uint64_t offset) +{ + IO_CODE(); + + return offset >> bs->bl.zone_size_bits; +} + void *qemu_blockalign(BlockDriverState *bs, size_t size) { IO_CODE(); diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 1b93364b24..6e4a7a4076 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -523,7 +523,7 @@ static bool check_zoned_request(VirtIOBlock *s, int64_t= offset, int64_t len, } } =20 - index =3D offset / bs->bl.zone_size; + index =3D bdrv_zone_index(bs, offset); if (BDRV_ZT_IS_CONV(bs->wps->wp[index])) { *status =3D VIRTIO_BLK_S_ZONE_INVALID_CMD; return false; diff --git a/include/block/block-io.h b/include/block/block-io.h index d34d846bb2..9d1c0eb7fb 100644 --- a/include/block/block-io.h +++ b/include/block/block-io.h @@ -126,6 +126,8 @@ int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_append(Block= DriverState *bs, int64_t *offset, QEMUIOVector *qiov, BdrvRequestFlags flags); +/* The index of the zone that @offset falls in. */ +uint32_t bdrv_zone_index(BlockDriverState *bs, uint64_t offset); =20 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs); =20 diff --git a/include/block/block_int-common.h b/include/block/block_int-com= mon.h index 7571ed9968..82aa0c1a6e 100644 --- a/include/block/block_int-common.h +++ b/include/block/block_int-common.h @@ -903,6 +903,13 @@ typedef struct BlockLimits { /* zone size expressed in bytes */ uint64_t zone_size; =20 + /* + * log2 of zone_size, derived by bdrv_refresh_limits(). A zoned device + * always has a zone size that is a power of two, so the zone an offset + * falls in is a shift rather than a division. See bdrv_zone_index(). + */ + uint32_t zone_size_bits; + /* total number of zones */ uint32_t nr_zones; =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001074; cv=none; d=zohomail.com; s=zohoarc; b=TzDaY+Q/ZXKUZbGXCDbrtxcPT6r22LVG9Vo1+9tzBSi1rB9Njo0jEbthCuyS6AVaWfB+leqoAC9iO8ZVXY6tkNvdJ9g+vxdUbZOXbd2iaSPP7NPKyF8QgdjkG+h5CM7v9l7oiQGT65cgWB5hCYBKS3hAC0iZGxH/ywyd946mYIs= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001074; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=PTZ+yrhR+/MJNKDSkwD+F+glze+MmD3SwdgrHQBQnJY=; b=mQdELacuk7+lrw9YwkkpSz3ffn4+cwyV6ixEt2LGqSFBmBhCUemC5ut/ZgDaoj9NcB3QbQE+Gcj4u6/XKo3cXLw3iBVMfB42916nzFelQYFLbBGicZ1O7qxgjQD9QYA54OKytiH4O1q959cOqgTUwxAgQpLWNW7bQAGJ0kYR27Y= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 17900010749901023.1195657752659; Mon, 21 Sep 2026 07:31:14 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2A-0002jf-FJ; Mon, 21 Sep 2026 10:30:18 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0l-0001vu-Vq; Mon, 21 Sep 2026 10:28:55 -0400 Received: from sea.source.kernel.org ([172.234.252.31]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0j-00007k-5s; Mon, 21 Sep 2026 10:28:51 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 65C9A43583; Mon, 21 Sep 2026 14:28:47 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0FED41F000FF; Mon, 21 Sep 2026 14:28:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000927; bh=PTZ+yrhR+/MJNKDSkwD+F+glze+MmD3SwdgrHQBQnJY=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=K48At27Dad9lwj18HOVAIVwiNc+RQtvLkLX/NCVvKMV1KzHA4kNOY/4IfqhSfTXrl c2ARDgZscliOcmFp9t8bLJtXtS5rp5jveKcxIeNRnmIEP8xWn4THwYeFYtfLklDRXr w72xsx+dj1+LLTMSgx8KO9V4vAMCHd+nrhH+WRPNzK0KmoHF6+2oXkeLzQQfZ+uaxO Lu73NN2HoR/0+JdKnn+W4B4BS6sgeFSZThAhnKiAENr2fII1R7mJC/baTCBmgK8fZx +W77x2SOUoCOWHH8R4YFkCHslrXmFbB9CdlS8kBVqJJ7RGUMxhDkMXl614dzaOm1s2 L2dB/UoBntPkw== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Fam Zheng , Hanna Reitz , "Michael S. Tsirkin" Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 04/15] block: add a helper to check if a zone is conventional Date: Mon, 21 Sep 2026 16:28:06 +0200 Message-ID: <20260921142819.2916043-5-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.234.252.31; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001076618158500 Content-Type: text/plain; charset="utf-8" Whether a zone is conventional is encoded in the most significant bit of the write pointer that the block layer keeps for it, so a caller that wants to know has to reach into bs->wps->wp[] and apply BDRV_ZT_IS_CONV() to the raw value. virtio-blk does that, which means a device model both knows how a block driver stores its write pointers and knows what one of the bits of a write pointer means. Add an accessor next to bdrv_zone_index() and use it there, so that the encoding stays with the code that chose it. Unlike bdrv_zone_is_full(), this does not need the write pointer lock. get_zones_wp() only ever sets the bit for a conventional zone and never clears it, and a zone does not change type, so the answer cannot become stale. The rest of the word does change, on every write, which is what the lock is there for. Signed-off-by: Niklas Cassel Reviewed-by: Stefan Hajnoczi --- block/io.c | 7 +++++++ hw/block/virtio-blk.c | 2 +- include/block/block-io.h | 6 ++++++ 3 files changed, 14 insertions(+), 1 deletion(-) diff --git a/block/io.c b/block/io.c index cef23ee5bc..da61e641ac 100644 --- a/block/io.c +++ b/block/io.c @@ -3373,6 +3373,13 @@ uint32_t bdrv_zone_index(BlockDriverState *bs, uint6= 4_t offset) return offset >> bs->bl.zone_size_bits; } =20 +bool bdrv_zone_is_conv(BlockDriverState *bs, uint32_t index) +{ + IO_CODE(); + + return BDRV_ZT_IS_CONV(bs->wps->wp[index]); +} + void *qemu_blockalign(BlockDriverState *bs, size_t size) { IO_CODE(); diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 6e4a7a4076..dd69d81532 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -524,7 +524,7 @@ static bool check_zoned_request(VirtIOBlock *s, int64_t= offset, int64_t len, } =20 index =3D bdrv_zone_index(bs, offset); - if (BDRV_ZT_IS_CONV(bs->wps->wp[index])) { + if (bdrv_zone_is_conv(bs, index)) { *status =3D VIRTIO_BLK_S_ZONE_INVALID_CMD; return false; } diff --git a/include/block/block-io.h b/include/block/block-io.h index 9d1c0eb7fb..e469df7061 100644 --- a/include/block/block-io.h +++ b/include/block/block-io.h @@ -128,6 +128,12 @@ int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_append(Bloc= kDriverState *bs, BdrvRequestFlags flags); /* The index of the zone that @offset falls in. */ uint32_t bdrv_zone_index(BlockDriverState *bs, uint64_t offset); +/* + * True if the zone at @index is a conventional zone, which can be written + * anywhere in any order. The type of a zone does not change, so unlike + * bdrv_zone_is_full() this does not need the write pointer lock. + */ +bool bdrv_zone_is_conv(BlockDriverState *bs, uint32_t index); =20 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs); =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001039; cv=none; d=zohomail.com; s=zohoarc; b=j9VrStdri29TLNs6cElFKHqWz6cRN5sSqtg0HcWPSTcLlxxKCKLgKBHYDQKq3Ne1hqPvutHVtXDJFOX/kSPsDsx7mPCjdRmR+1KgVEftftXbGGlJSYLYMBOj4/4w6v73KgzbBcCnYPhw4kKPQk20LjWcEfLbrnhNWeFBbtg0NEA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001039; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=BaGydPCSUAeNb0eWyHPI3N0R/c7Ye/3rI6LSXHt3/po=; b=MeezCQKraosttXsXRTPRoIszSR5rUAlgswDzKdsk3mAHL45HB2PdmwdHY0bhbBlhACTxEIIABxe+agXCHqJVMH28QRsvd2J4Y50VDan6VcJEGMRunjMrZDbBNmNwcUlOfsptmN3HOT1rwRnbusr7Hjx3W8WhKxIx6kc7jWV1Dic= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 179000103983130.20176171621665; Mon, 21 Sep 2026 07:30:39 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2C-0002yM-8r; Mon, 21 Sep 2026 10:30:20 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0p-0001wk-Ua; Mon, 21 Sep 2026 10:29:01 -0400 Received: from sea.source.kernel.org ([172.234.252.31]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0l-00008C-M0; Mon, 21 Sep 2026 10:28:54 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 65F1843C33; Mon, 21 Sep 2026 14:28:50 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id D7A341F00898; Mon, 21 Sep 2026 14:28:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000930; bh=BaGydPCSUAeNb0eWyHPI3N0R/c7Ye/3rI6LSXHt3/po=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=L7qfATPe5BbDxhSN8gK04Nz9j++muofh+WKHGEGkG+aTRo5tJ++888mo1Sl1Uq9EB FkjqA4MgMoM5hluoeYhqav0KFNXpPWvZ62+OXhtnwMp0fFDY5pUNL2R01DOpnj5Ps8 ncZerkQQEsess/7seQanlRcG3ikbi6z+naBwfLzKbyFI3VAwHo14TLEWvIcPZmI2d5 sbGE8vvUNMZ+OJc1by8OHPmG0SDkYS331XVQaghVvBNu5g9OIvOiPhzTBYdau/LEUn tCMj5VjGyf5G7O9ge8gI4fYJFpYjUNlOwDEi9TGhq7ToigAo5RmoMVeRqbWSDqDFx2 +8jF2P5cEybBg== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , John Snow , "Denis V. Lunev" , Hanna Reitz , "Michael S. Tsirkin" Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 05/15] hw/block: derive the zone write granularity from the block sizes Date: Mon, 21 Sep 2026 16:28:07 +0200 Message-ID: <20260921142819.2916043-6-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.234.252.31; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001040414158500 Content-Type: text/plain; charset="utf-8" For ZBC/ZAC devices the write granularity is the physical block size, so a 512e SMR disk exposed through a host_device backend has a logical block size of 512 and a zone write granularity of 4096. We told the guest driver 512 while raw_co_zone_append() rejects anything that is not 4096 byte aligned, so the driver saw a plain I/O error for a request it had been told was valid. Report the larger of the logical and the physical block size instead. Both are properties of the device model, so the value that a guest is given does not change when it is migrated to a host whose disks differ, which a value taken from BlockLimits would. It is also what a guest derives for itself: blk_validate_zoned_limits() raises zone_write_granularity to the logical block size, and for a SCSI disk sd_zbc_read_zones() takes it from the physical block size. blkconf_blocksizes() rejects a logical block size larger than the physical block size, so this is the physical block size in practice. It is expressed as the larger of the two because that is the constraint which applies: a guest cannot issue a write finer than the logical block size, and the medium cannot take one finer than the physical block size. Add it as a helper next to blkconf_blocksizes(), since it is derived from a BlockConf, and use it for the zone append offset check in check_zoned_request(), which validated against bs->bl.write_granularity. The value reported to the driver and the value that requests are validated against then cannot drift apart. The helper cannot return zero because blkconf_blocksizes() always leaves a logical block size behind, so the check no longer needs to guard against an unset granularity. Fixes: 4f7366506a96 ("virtio-blk: add zoned storage emulation for zoned dev= ices") Signed-off-by: Niklas Cassel Reviewed-by: Stefan Hajnoczi --- hw/block/block.c | 5 +++++ hw/block/virtio-blk.c | 13 +++++++------ include/block/block_int-common.h | 7 +++++++ include/hw/block/block.h | 13 +++++++++++++ 4 files changed, 32 insertions(+), 6 deletions(-) diff --git a/hw/block/block.c b/hw/block/block.c index f187fa025d..79b0a67cea 100644 --- a/hw/block/block.c +++ b/hw/block/block.c @@ -201,6 +201,11 @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp) return true; } =20 +uint32_t blkconf_zone_write_granularity(BlockConf *conf) +{ + return MAX(conf->logical_block_size, conf->physical_block_size); +} + bool blkconf_apply_backend_options(BlockConf *conf, bool readonly, bool resizable, Error **errp) { diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index dd69d81532..6bf1049aea 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -516,11 +516,11 @@ static bool check_zoned_request(VirtIOBlock *s, int64= _t offset, int64_t len, } =20 if (append) { - if (bs->bl.write_granularity) { - if ((offset % bs->bl.write_granularity) !=3D 0) { - *status =3D VIRTIO_BLK_S_ZONE_UNALIGNED_WP; - return false; - } + uint32_t wg_mask =3D blkconf_zone_write_granularity(&s->conf.conf)= - 1; + + if (offset & wg_mask) { + *status =3D VIRTIO_BLK_S_ZONE_UNALIGNED_WP; + return false; } =20 index =3D bdrv_zone_index(bs, offset); @@ -1276,7 +1276,8 @@ static void virtio_blk_update_config(VirtIODevice *vd= ev, uint8_t *config) bs->bl.max_active_zones); virtio_stl_p(vdev, &blkcfg.zoned.max_open_zones, bs->bl.max_open_zones); - virtio_stl_p(vdev, &blkcfg.zoned.write_granularity, blk_size); + virtio_stl_p(vdev, &blkcfg.zoned.write_granularity, + blkconf_zone_write_granularity(conf)); virtio_stl_p(vdev, &blkcfg.zoned.max_append_sectors, bs->bl.max_append_sectors); } else { diff --git a/include/block/block_int-common.h b/include/block/block_int-com= mon.h index 82aa0c1a6e..7abd2b12bb 100644 --- a/include/block/block_int-common.h +++ b/include/block/block_int-common.h @@ -922,6 +922,13 @@ typedef struct BlockLimits { /* maximum number of active zones */ uint32_t max_active_zones; =20 + /* + * The granularity that the backend requires of a write to a sequential + * zone, in bytes, or zero if it has none. This describes the host, so= it + * must not be reported to a guest: a frontend reports + * blkconf_zone_write_granularity() and checks this against it when the + * device is realized. + */ uint32_t write_granularity; } BlockLimits; =20 diff --git a/include/hw/block/block.h b/include/hw/block/block.h index df941df19f..c769b1297d 100644 --- a/include/hw/block/block.h +++ b/include/hw/block/block.h @@ -114,6 +114,19 @@ bool blkconf_geometry(BlockConf *conf, int *trans, unsigned cyls_max, unsigned heads_max, unsigned secs= _max, Error **errp); bool blkconf_blocksizes(BlockConf *conf, Error **errp); +/* + * The alignment constraint that applies to writes to a sequential zone. A= guest + * cannot issue a write finer than the logical block size, and the medium = cannot + * take one finer than the physical block size, so the constraint that app= lies + * is the larger of the two. A frontend must report this value to its gues= t and + * validate requests against it. + * + * It is derived from the configuration and not from the backend, so that a + * guest is not given a property of the host, which would differ after + * migration. blkconf_blocksizes() rejects a logical block size larger tha= n the + * physical block size, so this is the physical block size in practice. + */ +uint32_t blkconf_zone_write_granularity(BlockConf *conf); bool blkconf_apply_backend_options(BlockConf *conf, bool readonly, bool resizable, Error **errp); =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001054; cv=none; d=zohomail.com; s=zohoarc; b=ZiUmUqhDirOQH4FUA5+bw8CNtMkdLYu33S3Tjb7pAoZ9oHKGG6z1L0PL8W5RaHT60VKTH7UzzKhxeOZ8vsgFaM9C/eLfMCfPTTtwgqXB6CE+ptmBWlxXWCoi2J6Lm3sjznJgSlp5E9I1g0O2JhZN868/RFVc6FcHJk0EvmJcpUY= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001054; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=4r/SaucnpBOavEClkEVL9hzC9PZEiZbcsuE88gfYWSE=; b=Wxmj5NL9k1BYOLqMc5iFXpazdcuLtrQwUqbxz+KJDdpVgE3aBVYxxFdd86BZU6oRSvmQZZiCb35Cm0YJ0Lrrx9/t1kf1ElVlHCQ4ZMeWSBwUJviXigKpLcQqHWPRVMfRvfi4l2HF4dXlPXloe+tGbjs4zxJ/r/vTfF3WXUrgw6I= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001054004200.6593342673806; Mon, 21 Sep 2026 07:30:54 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2B-0002wa-VX; Mon, 21 Sep 2026 10:30:20 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0p-0001wl-V2; Mon, 21 Sep 2026 10:29:01 -0400 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0o-00008m-47; Mon, 21 Sep 2026 10:28:55 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 2BB3E600C8; Mon, 21 Sep 2026 14:28:53 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id CDFB91F000FF; Mon, 21 Sep 2026 14:28:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000932; bh=4r/SaucnpBOavEClkEVL9hzC9PZEiZbcsuE88gfYWSE=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=cLquR0s043VDphJuLCsFQAMug3d+xh2WgwzTSI8jXXXGGbHh4fLGnRvuCV3VrayXf 4eTwq4PnMYQaX98Gj1xPgD1C8bzNzm7jE1xaGRot7Y5MeSuW+xnHzKQdQ11rjdlkek KhRQr3zcNXkKBcDSiRVLmSUhRvKZlBeZ1U8caFV7O4rt/jHlMgpk1ljo2jhRNpPVbM ePOi4i9q8rILmXUmFFHahDwAYD7Ufo4JcwW1qYjldkVvGAyara3ISoYMLr7NLx79OG 8wOPGUzlJ6PSzjePjvyAi5exnhHLEahtD5zFx1xYVdfdYI/MUCrO0suvWpbf40GAB6 sYqDQe3SkBpuQ== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , "Michael S. Tsirkin" , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 06/15] virtio-blk: check the write granularity of writes to sequential zones Date: Mon, 21 Sep 2026 16:28:08 +0200 Message-ID: <20260921142819.2916043-7-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=cassel@kernel.org; helo=tor.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001054554158500 Content-Type: text/plain; charset="utf-8" All VIRTIO_BLK_T_OUT requests issued to sequential zones and all VIRTIO_BLK_T_ZONE_APPEND requests must have an offset and a data size that are multiples of the write granularity reported by the device (virtio 1.4, 5.2.6.1), and a violation is reported as VIRTIO_BLK_S_ZONE_UNALIGNED_WP (virtio 1.4, 5.2.6). Neither request type was fully checked. Zone appends validated only the offset, while writes were not checked at all. Check the size of the appended data, and both the offset and the size of a write, against blkconf_zone_write_granularity(), so that every request the device accepts is one that the guest driver was told is valid. Writes to conventional zones keep no alignment constraint beyond the logical block size. The write path performs the check after virtio_blk_sect_range_ok() so that the zone index derived from the guest supplied sector is known to be in range. Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- hw/block/virtio-blk.c | 38 +++++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 6bf1049aea..449de307b4 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -392,6 +392,33 @@ static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, return true; } =20 +/* + * Both the offset and the size of a write to a sequential zone must be a + * multiple of the write granularity that the device reports. Conventional + * zones are not constrained. The zone index is derived from a guest suppl= ied + * sector, so this must only be called once virtio_blk_sect_range_ok() has + * bounded it. + */ +static bool virtio_blk_zone_write_granularity_ok(VirtIOBlock *dev, + uint64_t sector, size_t s= ize) +{ + BlockDriverState *bs =3D blk_bs(dev->blk); + uint64_t offset =3D sector << BDRV_SECTOR_BITS; + uint32_t wg_mask; + + if (bs->bl.zoned =3D=3D BLK_Z_NONE) { + return true; + } + + if (bdrv_zone_is_conv(bs, bdrv_zone_index(bs, offset))) { + return true; + } + + wg_mask =3D blkconf_zone_write_granularity(&dev->conf.conf) - 1; + + return !(offset & wg_mask) && !(size & wg_mask); +} + static uint8_t virtio_blk_handle_discard_write_zeroes(VirtIOBlockReq *req, struct virtio_blk_discard_write_zeroes *dwz_hdr, bool is_write_zeroes) { @@ -518,7 +545,7 @@ static bool check_zoned_request(VirtIOBlock *s, int64_t= offset, int64_t len, if (append) { uint32_t wg_mask =3D blkconf_zone_write_granularity(&s->conf.conf)= - 1; =20 - if (offset & wg_mask) { + if (offset & wg_mask || len & wg_mask) { *status =3D VIRTIO_BLK_S_ZONE_UNALIGNED_WP; return false; } @@ -913,6 +940,15 @@ static int virtio_blk_handle_request(VirtIOBlockReq *r= eq, MultiReqBuffer *mrb) return 0; } =20 + if (is_write && + !virtio_blk_zone_write_granularity_ok(s, req->sector_num, + req->qiov.size)) { + virtio_blk_req_complete(req, VIRTIO_BLK_S_ZONE_UNALIGNED_WP); + block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_WRITE); + g_free(req); + return 0; + } + block_acct_start(blk_get_stats(s->blk), &req->acct, req->qiov.size, is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ); =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001104; cv=none; d=zohomail.com; s=zohoarc; b=dhaHWmFR+avgOPLZDhY0Gpn5Ex43/ezRF1LISTNzJQatnlWG1YqwU5AGht5DSkuaYPYy/b9FhR98hmuoFBCZA0RYU+YQtxc5BsxOQ9Sw927E7I7n/bK7YSNuxeYApRbf3+y2ceguXjiRX9n7D2UUWYtfOL4RuKBlcUclYBp06GA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001104; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=HE4fbtBVZ7BN13xy8oo7npZAX2OBj52IgG8zDIJZros=; b=W5q2fl3zSA/6NEMy6gxH0JLFMqJwdvvNrxB+V5euinJDJLsNhV1sQTSakoGPanyBI3ojHMS052ayy3hA4fCQELiQMndmD9XEXacr9vOI5U7lgFn5sdQpxf2eCTpZZwUQriZgKxpHXfER0vYBlYtFkEup/3L6txX+3Vtwes+Mois= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 179000110468857.436127182241535; Mon, 21 Sep 2026 07:31:44 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2N-0003bX-B5; Mon, 21 Sep 2026 10:30:31 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0t-0001xB-SC; Mon, 21 Sep 2026 10:29:03 -0400 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0r-000093-2Q; Mon, 21 Sep 2026 10:28:59 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 29B80600C8; Mon, 21 Sep 2026 14:28:56 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 700A71F000FF; Mon, 21 Sep 2026 14:28:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000935; bh=HE4fbtBVZ7BN13xy8oo7npZAX2OBj52IgG8zDIJZros=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=XzkZaf/LzgCyfuzUeA0rS9nbFGmxKAUUxR/szwPs6FRJ7SyBWdTSgyecwV7+B+Fnp S3j+KwjSK6owK6uE+sIodhT2g0g2TmBDseyHi1FUGxThigYbqD974T/XnhStjTFF+m hzAoZ2fw19VoXkMYPYSD5j2wg3ilbG5U+mT+LXev18LRFDHTxyivJFNOPvigiUbUK6 tA0ztRdZH2fqo4gG4JYC8RxcDe56UurR6z8N6QabzP8unN1lWIQIsd404k6cIibH82 lfuek8HxnwU11V3bCgpxjdt6KZcLuFkfWzfl5xAU6HmczsEHuLxX+xvct5qmtnWquo y1TpsIh+l9ZNg== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , John Snow , "Denis V. Lunev" , Hanna Reitz , "Michael S. Tsirkin" Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 07/15] hw/block: reject a zoned device that the block sizes cannot address Date: Mon, 21 Sep 2026 16:28:09 +0200 Message-ID: <20260921142819.2916043-8-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=2600:3c04:e001:324:0:1991:8:25; envelope-from=cassel@kernel.org; helo=tor.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001107076158500 Content-Type: text/plain; charset="utf-8" The write granularity that a frontend reports is derived from the logical and the physical block size, which are properties of the device model, while the granularity that the medium requires and the write pointers that it holds belong to the backend. Nothing ties them together, and where they disagree a guest is told about a device it cannot use. A backend can require a coarser granularity than the block sizes express. A 512e host managed disk has a logical block size of 512 and requires writes to a sequential zone to be a multiple of 4096, so attaching it with a finer physical block size reports a granularity that the disk will not accept, and the guest is given a plain I/O error for a request that it was told was valid. The write pointers can disagree in the same way. They outlive any particular use of the device, while the block sizes are chosen afresh every time it is attached, so a zone written with logical_block_size=3D512 leaves a write pointer that logical_block_size=3D4096 cannot address. A zone report expresses it in 512 byte sectors, so the guest is told about a position that does not fall on a logical block boundary, which it can neither read nor write, and the zone can then only be recovered by resetting it. The reverse is harmless: a pointer laid down with a larger logical block size is still a multiple of a smaller one. Check both at realize time, along with the zone size and the zone capacity, and refuse to start otherwise. The write pointers are already held in memory by the driver, so this costs no I/O. The check uses blkconf_zone_write_granularity(), the same value that a frontend reports to its guest and validates requests against, so the three cannot disagree. Signed-off-by: Niklas Cassel Reviewed-by: Stefan Hajnoczi --- hw/block/block.c | 63 ++++++++++++++++++++++++++++++++++++++++ hw/block/virtio-blk.c | 4 +++ include/hw/block/block.h | 1 + 3 files changed, 68 insertions(+) diff --git a/hw/block/block.c b/hw/block/block.c index 79b0a67cea..3bb8121e9e 100644 --- a/hw/block/block.c +++ b/hw/block/block.c @@ -206,6 +206,69 @@ uint32_t blkconf_zone_write_granularity(BlockConf *con= f) return MAX(conf->logical_block_size, conf->physical_block_size); } =20 +bool blkconf_check_zoned_geometry(BlockConf *conf, Error **errp) +{ + BlockDriverState *bs =3D blk_bs(conf->blk); + uint32_t wg; + + if (bs->bl.zoned =3D=3D BLK_Z_NONE) { + return true; + } + + wg =3D blkconf_zone_write_granularity(conf); + + /* + * A backend that requires a coarser granularity than the one that is = about + * to be reported would reject writes that the guest has been told are + * valid, leaving it with a plain I/O error. + */ + if (bs->bl.write_granularity > wg) { + error_setg(errp, "the backend requires writes to sequential zones = to " + "be a multiple of %" PRIu32 " bytes, which is coarser t= han " + "the zone write granularity %" PRIu32 " that would be " + "reported", bs->bl.write_granularity, wg); + error_append_hint(errp, "Set physical_block_size=3D%" PRIu32 ".\n", + bs->bl.write_granularity); + return false; + } + + if (!QEMU_IS_ALIGNED(bs->bl.zone_size, wg)) { + error_setg(errp, "zone size %" PRIu64 " is not a multiple of the z= one " + "write granularity %" PRIu32, bs->bl.zone_size, wg); + return false; + } + + /* + * A write pointer that is not a multiple of the write granularity doe= s not + * fall on a logical block boundary, so the guest can neither read nor= write + * at it and the zone can only be recovered by resetting it. A backend= that + * records its write pointers, rather than reading them back from a de= vice, + * can hand us such a pointer when the zones were written while the de= vice + * was configured with a smaller logical block size. + */ + for (uint32_t i =3D 0; i < bs->bl.nr_zones; i++) { + uint64_t wp; + + if (bdrv_zone_is_conv(bs, i)) { + continue; + } + + wp =3D bs->wps->wp[i]; + if (!QEMU_IS_ALIGNED(wp, wg)) { + error_setg(errp, "write pointer 0x%" PRIx64 " of zone %" PRIu32 + " is not a multiple of the zone write granularity %" + PRIu32, wp, i, wg); + error_append_hint(errp, "The zones were written with a finer z= one " + "write granularity. Reset them, or attach th= e " + "device with the block sizes that they were " + "written with.\n"); + return false; + } + } + + return true; +} + bool blkconf_apply_backend_options(BlockConf *conf, bool readonly, bool resizable, Error **errp) { diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 449de307b4..74bd08b0ec 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -1840,6 +1840,10 @@ static void virtio_blk_device_realize(DeviceState *d= ev, Error **errp) return; } =20 + if (!blkconf_check_zoned_geometry(&conf->conf, errp)) { + return; + } + bs =3D blk_bs(conf->conf.blk); if (bs->bl.zoned !=3D BLK_Z_NONE) { virtio_add_feature(&s->host_features, VIRTIO_BLK_F_ZONED); diff --git a/include/hw/block/block.h b/include/hw/block/block.h index c769b1297d..c0a8b84df1 100644 --- a/include/hw/block/block.h +++ b/include/hw/block/block.h @@ -127,6 +127,7 @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp); * physical block size, so this is the physical block size in practice. */ uint32_t blkconf_zone_write_granularity(BlockConf *conf); +bool blkconf_check_zoned_geometry(BlockConf *conf, Error **errp); bool blkconf_apply_backend_options(BlockConf *conf, bool readonly, bool resizable, Error **errp); =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001028; cv=none; d=zohomail.com; s=zohoarc; b=epM7v8/c1dpwt6nC4gx7baTRqZP0NRid55+QNpN7hXQRZgNc9DLXBRB9+Vwnt98AxH/AChdKKUplsd/0/kuJiNGuWANnR7a3VxbqlU0AWuoMAh+OoJwPFrXVyrGD+/PsWTlXd0Co9NUae2uh0Sje5IKqZQothXwaG/+ol/0Tcuo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001028; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=K/E7mfkyMsocMU2GeW0n4nAwhy2Ey6wmw7TpzmiJTl4=; b=FPNMeBmE5qGaZGqtvpOGeCJLrqVU3jR6Ikid0y7fEzfw6zQopFq9/P/sNitKuvH6a06NLE4UDR1XhvIf1lA5S9Atamjc97t9h4M8lTahX/rAPbwdgn+jKeuw8ZvqIEsY41lIE5X4DaouqVFKdcBGCOSGYQvTf/zVH+tVIqMafqo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001028527875.6295314022368; Mon, 21 Sep 2026 07:30:28 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f1s-0002Qj-9h; Mon, 21 Sep 2026 10:30:00 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0v-0001xv-Ci; Mon, 21 Sep 2026 10:29:05 -0400 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0t-00009g-Ox; Mon, 21 Sep 2026 10:29:01 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id B6103600D1; Mon, 21 Sep 2026 14:28:58 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 65DBE1F000FF; Mon, 21 Sep 2026 14:28:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000938; bh=K/E7mfkyMsocMU2GeW0n4nAwhy2Ey6wmw7TpzmiJTl4=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=GoptpolYDnux9B6aLDHVS3i21VZgVzq8P1se4medbHluDatBkPzedepcWpsNkJhrj Cmup3wxE9dCM6G/LPRi172/WC5zirrE34UDwBa1ZbAAhLvIpaPhxL1BzZJ4jqoY/HD y2w0yUL7vWpAJ9ZI0YfCrsxo6kx45ye9zBvPI0dbZ8na7Bb9Q/EcU2MZyyLcTYHjNq p47mA0kl2RApWyOnELihVidEC2JWoIWVihePABr3re9Sd5S+iU4WN2/7TngVk4kmX9 C4DQCrGLiCV0Rady6QUtnk5SRmcQm8TbQuDKXCPO+IOyrIEcnWM7q+YqLeiiK9hUZv gR7W9uClzB74w== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Fam Zheng , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 08/15] block: reject zone appends that are not a multiple of the sector size Date: Mon, 21 Sep 2026 16:28:10 +0200 Message-ID: <20260921142819.2916043-9-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=cassel@kernel.org; helo=tor.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001030216158501 Content-Type: text/plain; charset="utf-8" Zone write pointers are tracked and reported in units of BDRV_SECTOR_SIZE, so an append whose data size is not a multiple of it would leave a write pointer that cannot be represented, neither in a BlockZoneDescriptor nor in the virtio and NVMe zone reports derived from one. Nothing states that invariant. file-posix, the only driver that carries out an append itself, does enforce it, but only as a side effect of checking each iovec against BlockLimits.write_granularity, which is never smaller than the sector size. That conflates two constraints: the sector granularity holds for every driver, whereas write_granularity describes a coarser requirement of the medium below a driver, and only a driver that has such a medium should express it. Check the invariant once in bdrv_co_zone_append(), so that it no longer rests on a driver that happens to have a granularity of its own to report. This is a lower bound, not the alignment that a guest has to observe. The block layer cannot know that one, because it also depends on the logical block size the device is configured with, which is a property of the frontend. The alignment that applies to a guest is the larger of the two, and it is the frontend that reports it, that validates requests against it, and that has to refuse a device whose write pointers do not satisfy it. Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- block/io.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/block/io.c b/block/io.c index da61e641ac..b9d0b3fd7b 100644 --- a/block/io.c +++ b/block/io.c @@ -3355,6 +3355,16 @@ int coroutine_fn bdrv_co_zone_append(BlockDriverStat= e *bs, int64_t *offset, return ret; } =20 + /* + * Zone write pointers are kept and reported in units of BDRV_SECTOR_S= IZE, + * so an append that would leave a write pointer at a finer granularity + * cannot be represented. Drivers may impose a coarser granularity of = their + * own, see BlockLimits.write_granularity. + */ + if (!QEMU_IS_ALIGNED(qiov->size, BDRV_SECTOR_SIZE)) { + return -EINVAL; + } + bdrv_inc_in_flight(bs); if (!drv || !drv->bdrv_co_zone_append || bs->bl.zoned =3D=3D BLK_Z_NON= E) { co.ret =3D -ENOTSUP; --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001052; cv=none; d=zohomail.com; s=zohoarc; b=YG0Vx02wKDa29AZXbBX46MvMgQSgTYfLaF8anS2z/EfMSriDNkww0rCEdPBiRWWR89N2pkEq1E9uAJtT8jzgyOtkXGFBUxsdPe9vrcRB9z2j+Gbj9kfSkV8WdvKUiGuhlyV+ohiSGNrEIJMRsPgUcDcKSDefNWulgZxsUqhNfI8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001052; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=QXQW7Tj/vJ/h2pt+4J+vyvcuNjENXHEnBN7dKAAkOdE=; b=nC9QJldB8njFwRfU1RtD8BePee6sRhiXIEO0NUHrhkkB8PWBUBR6ltFb+vxPNEhdDN4peRj6BOOfS+USH66Bmzi2b74+HnGLTJ5+WxbuHl0r2IjZZVqdfmqveZPEMLUX22vpQrpiJPEkKyCNxbC24Q4nxzZ5MsuCGO+VjZnfHMw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001052978555.351857302294; Mon, 21 Sep 2026 07:30:52 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2G-0003BJ-JJ; Mon, 21 Sep 2026 10:30:24 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0x-0001yU-Uw; Mon, 21 Sep 2026 10:29:05 -0400 Received: from sea.source.kernel.org ([172.234.252.31]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0w-0000DH-Eo; Mon, 21 Sep 2026 10:29:03 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 420B643583; Mon, 21 Sep 2026 14:29:01 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id F0EC31F000FF; Mon, 21 Sep 2026 14:28:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000941; bh=QXQW7Tj/vJ/h2pt+4J+vyvcuNjENXHEnBN7dKAAkOdE=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=E1qXfFPKZdpmZWb71hwmUki4gBAASEXhh7RUnnEV8j+gvI7B5w7now+7AdxS5u6m3 WByspSSP81JspCxKKZnfDy5b3UuDoZFYZRjEQiSnLO0N13HPukobac/AalAaCKZRYC 844ZLUHwocVNIvjz+NJVJJLf0MK0dkicv34MbHtj65+v0IHR/HcJbaa7yKy74fELui w2Gz24TdfxK6o7gV9QuIKyOykzW/wHp5M59xj5bhtTEjaroJ3Gq7bGwM3naRzb20K2 cAtCSw0jzCaIQyV4MSxppEFyxLpqkr7HE7V1PQXB29dns8k3iGDHfFT1AdGWcQa23o kDi3ALkwe0gHQ== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Fam Zheng , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 09/15] block: reject a zone append that is larger than a zone Date: Mon, 21 Sep 2026 16:28:11 +0200 Message-ID: <20260921142819.2916043-10-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.234.252.31; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001054558158501 Content-Type: text/plain; charset="utf-8" A zone append cannot cross a zone boundary, so a request larger than a zone can never be carried out. Nothing rejects one. The block layer does not look at the length at all, and raw_co_zone_append() writes qiov->size bytes at the write pointer once it has validated the offset, so the write runs past the end of the zone: on a disk with 8 MiB zones, an append of 8 MiB plus one block fills the zone and advances the write pointer of the zone after it. virtio-blk does compare the length, but against BlockLimits.max_append_sectors, which is how much the backend takes in one command and not how large a zone is. For a Linux block device that value is never larger than a zone, so virtio-blk is protected by what the backend happens to report rather than by the check it makes. Check the length in bdrv_co_zone_append(), next to the check that an append is a multiple of the sector size. Both are conditions of the operation rather than of a medium, so the block layer is where they hold for every caller and where no driver has to repeat them. The exact bound is tighter: a request also has to fit in the part of the zone that is still writable, which depends on the write pointer and so stays with the drivers. Signed-off-by: Niklas Cassel Reviewed-by: Stefan Hajnoczi --- block/io.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/block/io.c b/block/io.c index b9d0b3fd7b..d7c403bc08 100644 --- a/block/io.c +++ b/block/io.c @@ -3365,6 +3365,18 @@ int coroutine_fn bdrv_co_zone_append(BlockDriverStat= e *bs, int64_t *offset, return -EINVAL; } =20 + /* + * An append cannot cross a zone boundary, so one that is larger than a + * zone can never be carried out, wherever the write pointer of the zo= ne + * is. The exact bound is the part of the zone that is still writable, + * which only a driver can check, as only it holds the write pointer. + * zone_size is zero when the device is not zoned, which is reported as + * unsupported below. + */ + if (bs->bl.zone_size && qiov->size > bs->bl.zone_size) { + return -EINVAL; + } + bdrv_inc_in_flight(bs); if (!drv || !drv->bdrv_co_zone_append || bs->bl.zoned =3D=3D BLK_Z_NON= E) { co.ret =3D -ENOTSUP; --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001052; cv=none; d=zohomail.com; s=zohoarc; b=RSRLQ+Dr/lLsUIhIxv14aTZI4DnmdL45AogS8sHlb2El8KOdM77PzAqu08oKbtN9SFDdFugHSTkhXTo2BGWckcU3zVf45PV/eSydaK8nX20ebGXxxA1jeL0rDvamq2TbCICloWD6jCz9h8sVjFOyHpfhow27v148AKmRJAHvz9A= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001052; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=kO8IHCng71x3mgW5KJPsYGi6K2oavSzDgmdvQLPLOrA=; b=YX82mWh6HuvOuUn7r1ohVAd+unDhyN57RGF20HwbNqTeZg0JVYJNVt+BrQeXu6eg1ySC+eHFNTtY0Lrwdmg8UGS2t5j09pmYO6twJ02Nnv22zs+okg1A9yZs5STYTmhFYIXvtGj2WbLBPMXD9SkmzagisKFcEaKQ6UvyYx2FwwE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001052718752.020417844086; Mon, 21 Sep 2026 07:30:52 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2F-00039J-SV; Mon, 21 Sep 2026 10:30:23 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f11-000229-54; Mon, 21 Sep 2026 10:29:07 -0400 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f0z-0000Fu-Fq; Mon, 21 Sep 2026 10:29:06 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id A42E1411D4; Mon, 21 Sep 2026 14:29:03 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id AA1C71F000FF; Mon, 21 Sep 2026 14:29:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000943; bh=kO8IHCng71x3mgW5KJPsYGi6K2oavSzDgmdvQLPLOrA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=h+B9+lLlIxMqmAaWsOe6S2DRJ2cLJsweDccWJ8WAw6lDYbK366LY6hAsU51bsHTE9 v3hx6C7bx7FJTHyIaVhld6JO0Ugltf1N7PWkbPi4osS36fazBOZs7+f5e36bN/UieP RsEKv1ZLjJMP145GXKsAX11z45Fu0Vv5ZogEI713iijwhKzL1d7sVD/e0Zg/FyOLZe +j40aa4FWjxMqcnSD+xNGEVdyBlhAo/7w+Dk9GbeflkRvhXzUW/ni3yW/ni7bi07Pt cxcFa/+nz0dIMGvg06+7n+6UE0gXjxV9joyaFb713JWQIqwkTtZYpyWCEtwF5O4cxW APXAiKS+sFjFg== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 10/15] file-posix: remove the zone append write granularity check Date: Mon, 21 Sep 2026 16:28:12 +0200 Message-ID: <20260921142819.2916043-11-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=2600:3c0a:e001:78e:0:1991:8:25; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001054558158500 Content-Type: text/plain; charset="utf-8" The check rejects a zone append whose individual iovec lengths are not multiples of the zone write granularity. That is stricter than the constraint it is meant to enforce, which applies to the size of the request as a whole. A request whose total is properly aligned but which is split across, say, a 512 byte and a 3584 byte iovec is refused here, even though the iovec boundaries do not survive into the scatter gather list that reaches the device. Nor is the driver the right place to enforce it. The granularity that holds for every backend is the sector granularity, which is now checked once in bdrv_co_zone_append(). The coarser granularity that a guest has to observe depends on the logical block size that the device was configured with, so only a frontend can know it, and a frontend both reports it to its guest and validates requests against it. Drop the check. BlockLimits.write_granularity is then set in one place, by this driver from the zone_write_granularity queue attribute, and read in one place, where a device whose granularity the configured block sizes cannot express is refused. Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- block/file-posix.c | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/block/file-posix.c b/block/file-posix.c index 00323f7a9f..c1ac49d23d 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -3593,8 +3593,6 @@ raw_co_zone_append(BlockDriverState *bs, BdrvRequestFlags flags) { assert(flags =3D=3D 0); int64_t zone_size_mask =3D bs->bl.zone_size - 1; - int64_t iov_len =3D 0; - int64_t len =3D 0; =20 if (*offset & zone_size_mask) { error_report("sector offset %" PRId64 " is not aligned to zone siz= e " @@ -3602,20 +3600,8 @@ raw_co_zone_append(BlockDriverState *bs, return -EINVAL; } =20 - int64_t wg =3D bs->bl.write_granularity; - int64_t wg_mask =3D wg - 1; - for (int i =3D 0; i < qiov->niov; i++) { - iov_len =3D qiov->iov[i].iov_len; - if (iov_len & wg_mask) { - error_report("len of IOVector[%d] %" PRId64 " is not aligned t= o " - "block size %" PRId64 "", i, iov_len, wg); - return -EINVAL; - } - len +=3D iov_len; - } - trace_zbd_zone_append(bs, *offset >> BDRV_SECTOR_BITS); - return raw_co_prw(bs, offset, len, qiov, QEMU_AIO_ZONE_APPEND, 0); + return raw_co_prw(bs, offset, qiov->size, qiov, QEMU_AIO_ZONE_APPEND, = 0); } #endif =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001086; cv=none; d=zohomail.com; s=zohoarc; b=YF1+s+qMAmZyYKTYuIb6bayTSdbNzDiAkU1pdsnENUw8nstS5HuWbPwEodCkb2WZj+z4bSSFRq/NEenWPL5acurkHM85WJai0rcetsCS9RyzBp3Z2YcsYeaL8u+PzJK70Xf7ZTRFY4avyNyMR1tET6Y/ivUm8PY2xn3UKB5a+Ws= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001086; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=x6bE+olBOh1kMqLDv9SDGWtLLE/Wqq+0hgO1K5YKxWM=; b=S4DD1hyN0ko7/op7AW0Al6sS9saXhw3qMQxrL+SUPro169CGKcEIbL1rB6y6uwg+w4C2Y7zpo5aQ3AfuhkdMoVQoLNMJhuG3zCovHT0uSwZ4WSz15qD+Ffo6QrItz8oDotw1UNE+/WL/rcbu5XymhvyzsZbcjyQ5GbXjX3voKjY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001086303160.0238054133598; Mon, 21 Sep 2026 07:31:26 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2T-00049Y-RS; Mon, 21 Sep 2026 10:30:38 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f18-00023f-2F; Mon, 21 Sep 2026 10:29:15 -0400 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f11-0000LV-B9; Mon, 21 Sep 2026 10:29:11 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 6C453601F0; Mon, 21 Sep 2026 14:29:06 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1AF571F000FF; Mon, 21 Sep 2026 14:29:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000946; bh=x6bE+olBOh1kMqLDv9SDGWtLLE/Wqq+0hgO1K5YKxWM=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=FQW6bSiU21yrWGYEFrVBLSsp/N2CZHJHemLqAAATNRpyi7T36i5riNpLRi3CoYNXH PmgHDc3bqiXbA9mEb4FUV/9u0x7eTg8dD/qKeu/IQXTlPFXUCqG2+sBemGFDHMR6nC N/lZWcL/WCbtnTcl9QMB+C4gDRMSVWPs68Cltu/BtuGAixOy5gyH0/H10s8vgik1iJ JxEVfG8uiYLcWQ/sYRdvbsVsu2VkIdTLAPk10URtFzGooK/z+L8IKDWrIgNSGUgGke 38PfbbDYiwuKsejkBhQByRdln2VLTNBkfPvlqpkWOeCkFccS1h6MghLcp6sqajmOKS 9h+v+sCyR2Arg== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , "Michael S. Tsirkin" , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 11/15] virtio-blk: add a max-append-sectors property Date: Mon, 21 Sep 2026 16:28:13 +0200 Message-ID: <20260921142819.2916043-12-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=cassel@kernel.org; helo=tor.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001086781158500 Content-Type: text/plain; charset="utf-8" The maximum zone append size that the device reports to its driver was taken from BlockLimits.max_append_sectors, a limit of the host disk that the backend happens to sit on. A guest reads it out of the configuration space, so it becomes part of what the guest has been told about its device, and migrating that guest to a host whose disks report something smaller leaves it appending more than the device accepts. Make it a property, as max-discard-sectors and max-write-zeroes-sectors already are, so that the value a guest is given is part of the device model and does not change under it. Nothing from BlockLimits reaches the configuration space any more. Zero is a valid value here, unlike for those two. There is no feature bit for zone append, and a maximum of zero is how the specification has a device say that it does not support the operation (virtio 1.4, 5.2.5.2). It is also what a ZBC or ZAC disk is: such a disk has no zone append command at all, and Linux emulates one in its block layer. What is reported is capped by the size of a zone. The specification asks for the largest append that can be carried out, and one larger than a zone never can be, so the default would otherwise advertise a size that the block layer refuses. The cap tells a guest nothing about the host that zone_sectors has not already told it. Signed-off-by: Niklas Cassel Reviewed-by: Stefan Hajnoczi --- hw/block/virtio-blk.c | 67 ++++++++++++++++++++++++++++++---- include/hw/virtio/virtio-blk.h | 1 + 2 files changed, 61 insertions(+), 7 deletions(-) diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 74bd08b0ec..536d71a91a 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -521,6 +521,24 @@ typedef struct ZoneCmdData { }; } ZoneCmdData; =20 +/* + * The maximum zone append size that the device reports to its driver, in = 512 + * byte sectors. + * + * An append cannot cross a zone boundary, so the configured maximum is ca= pped + * by the size of a zone: the specification asks for the largest append th= at + * can be carried out, and a larger one never can be. The zone size is alr= eady + * reported to the driver as zone_sectors, so this tells it nothing new ab= out + * the host. + */ +static uint32_t virtio_blk_max_append_sectors(VirtIOBlock *s) +{ + BlockDriverState *bs =3D blk_bs(s->blk); + + return MIN(s->conf.max_append_sectors, + bs->bl.zone_size >> BDRV_SECTOR_BITS); +} + /* * check zoned_request: error checking before issuing requests. If all che= cks * passed, return true. @@ -556,12 +574,13 @@ static bool check_zoned_request(VirtIOBlock *s, int64= _t offset, int64_t len, return false; } =20 - if (len / 512 > bs->bl.max_append_sectors) { - if (bs->bl.max_append_sectors =3D=3D 0) { - *status =3D VIRTIO_BLK_S_UNSUPP; - } else { - *status =3D VIRTIO_BLK_S_ZONE_INVALID_CMD; - } + if (!s->conf.max_append_sectors) { + *status =3D VIRTIO_BLK_S_UNSUPP; + return false; + } + + if ((len >> BDRV_SECTOR_BITS) > virtio_blk_max_append_sectors(s)) { + *status =3D VIRTIO_BLK_S_ZONE_INVALID_CMD; return false; } } @@ -1315,7 +1334,7 @@ static void virtio_blk_update_config(VirtIODevice *vd= ev, uint8_t *config) virtio_stl_p(vdev, &blkcfg.zoned.write_granularity, blkconf_zone_write_granularity(conf)); virtio_stl_p(vdev, &blkcfg.zoned.max_append_sectors, - bs->bl.max_append_sectors); + virtio_blk_max_append_sectors(s)); } else { blkcfg.zoned.model =3D VIRTIO_BLK_Z_NONE; } @@ -1852,6 +1871,34 @@ static void virtio_blk_device_realize(DeviceState *d= ev, Error **errp) } } =20 + if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_ZONED)) { + uint32_t wg =3D blkconf_zone_write_granularity(&conf->conf); + + /* + * Checked before the granularity below, so that a driver can shif= t the + * value that it reads into a byte count without overflowing. + */ + if (conf->max_append_sectors > BDRV_REQUEST_MAX_SECTORS) { + error_setg(errp, "invalid max-append-sectors property (%" PRIu= 32 + "), must not exceed %d", conf->max_append_sectors, + (int)BDRV_REQUEST_MAX_SECTORS); + return; + } + + /* + * Zero is allowed, and says that zone append is not supported, wh= ich + * is what a ZBC or ZAC disk is. Anything else has to be able to + * express a single write. + */ + if (conf->max_append_sectors && + (conf->max_append_sectors << BDRV_SECTOR_BITS) < wg) { + error_setg(errp, "invalid max-append-sectors property (%" PRIu= 32 + "), must be zero or at least the zone write granula= rity " + "(%" PRIu32 " bytes)", conf->max_append_sectors, wg= ); + return; + } + } + if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) && (!conf->max_discard_sectors || conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) { @@ -1986,6 +2033,12 @@ static const Property virtio_blk_properties[] =3D { conf.max_discard_sectors, BDRV_REQUEST_MAX_SECTORS), DEFINE_PROP_UINT32("max-write-zeroes-sectors", VirtIOBlock, conf.max_write_zeroes_sectors, BDRV_REQUEST_MAX_SEC= TORS), + /* + * Zero is valid, and says that the device does not support zone appen= d, + * as a ZBC or ZAC disk does not. + */ + DEFINE_PROP_UINT32("max-append-sectors", VirtIOBlock, + conf.max_append_sectors, BDRV_REQUEST_MAX_SECTORS), DEFINE_PROP_BOOL("x-enable-wce-if-config-wce", VirtIOBlock, conf.x_enable_wce_if_config_wce, true), }; diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h index 3d8dee7ec1..0070ca6ba9 100644 --- a/include/hw/virtio/virtio-blk.h +++ b/include/hw/virtio/virtio-blk.h @@ -47,6 +47,7 @@ struct VirtIOBlkConf bool report_discard_granularity; uint32_t max_discard_sectors; uint32_t max_write_zeroes_sectors; + uint32_t max_append_sectors; bool x_enable_wce_if_config_wce; }; =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001110; cv=none; d=zohomail.com; s=zohoarc; b=CDrR5f8iwcZkoS2o/PeeVKD+nE0qQz4UOZ/nNlqu7O8euo0MutZbTnv+h74ymdvLX55c2V+RVLZpUmhkxeSlO8NQz/bplmEcWKU7pqiLApN8CoLGPG94dQzGl7UOqj3wTi9ryZe/GYZTNGsH83dyMKJUhsEd6rrUbuZ0VxjY43k= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001110; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=aJ4D99PRE9FsrB0XYN1JFXE/oB3XRrxb2xhanlbrQFI=; b=OFTARYS33AMxNKgvDJrZ8brnviRs5xTNRPuX7BvkGWfsM3+cZyp3pzUJM4sF3UGrmCMx7iG2PwgYAL7kUd7r4H88pAK71lFST5omOtnXuuyhZ9djjcmJImkt8vdsmgcdciHyMG/MBD7c+gjGlGTpfBFGLlXoTIAoHUe1WyWUZjw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001110555113.85989778052999; Mon, 21 Sep 2026 07:31:50 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2I-0003Dh-4D; Mon, 21 Sep 2026 10:30:27 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f19-00024B-In; Mon, 21 Sep 2026 10:29:15 -0400 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f17-0000OG-Gn; Mon, 21 Sep 2026 10:29:15 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id A4C1B411D4; Mon, 21 Sep 2026 14:29:08 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ABE081F000FF; Mon, 21 Sep 2026 14:29:06 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000948; bh=aJ4D99PRE9FsrB0XYN1JFXE/oB3XRrxb2xhanlbrQFI=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=awDosqR4uHZvZ1JFDaJIAQttuiCYHSrei17UQia5IqFPbfovnl4/pelsadzmS2UcM 7fTTXYsDZbXtL6jSWqEjzHopsqdZLRlgm9nWEG07+jivEkfk2n5IHiKJU6Y7Qompmp 6fndIj2eWQ4JlZyT2vcS7THMjszHw9t3j4hV0Pv6sd54EHkRa/+Ate22fmRyvrd79d 4EXZCd1p1lQva98oJ8UhlaUxD9ZZlliBMgKELrQBBpo2zTtbhI35NW2L+8rXZO4qfA PI1ffU7Ymcjs0St/Qj/GVM3qz8NHGxrP60w9KKVfQw6WPLEh2vY/fW5PhwFk2+tgWU IQX+RLjX6kG9Q== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 12/15] block: remove BlockLimits.max_append_sectors Date: Mon, 21 Sep 2026 16:28:14 +0200 Message-ID: <20260921142819.2916043-13-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=2600:3c0a:e001:78e:0:1991:8:25; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001110952158500 Content-Type: text/plain; charset="utf-8" The field described the largest zone append that a backend accepts. It had one writer and one reader, and neither is left. file-posix filled it from the zone_append_max_bytes queue attribute, which bounds REQ_OP_ZONE_APPEND, an operation it never issues: Linux has no userspace interface for one, so raw_co_zone_append() substitutes the write pointer of the zone for the offset and the request reaches the host as a plain pwritev(). The transfer limit does not apply either, no more than it does to an ordinary write. This driver reports max_hw_transfer but never sets BlockLimits.max_transfer, which is what bdrv_aligned_pwritev() splits by, so a request of any size goes to the host kernel whole and is split there: on a null_blk device whose zone_append_max_bytes is 130560, a 16 MiB append completes and advances the write pointer by 16 MiB. That is safe for a sequential zone, as Linux issues the fragments of a split write in order, with zone write plugging since 6.10 and zone write locking before that. virtio-blk was the reader, and now takes what it reports to a guest from a property instead. Remove the field and the assignment that filled it. Keeping it would be worse than not having it: a driver that set it, believing something enforced it, would be silently ignored. Signed-off-by: Niklas Cassel Reviewed-by: Stefan Hajnoczi --- block/file-posix.c | 5 ----- include/block/block_int-common.h | 3 --- 2 files changed, 8 deletions(-) diff --git a/block/file-posix.c b/block/file-posix.c index c1ac49d23d..1a4ca9d942 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -1488,11 +1488,6 @@ static void raw_refresh_zoned_limits(BlockDriverStat= e *bs, struct stat *st, } bs->bl.nr_zones =3D ret; =20 - ret =3D get_sysfs_long_val(st, "zone_append_max_bytes"); - if (ret > 0) { - bs->bl.max_append_sectors =3D ret >> BDRV_SECTOR_BITS; - } - ret =3D get_sysfs_long_val(st, "zone_write_granularity"); if (ret >=3D 0) { bs->bl.write_granularity =3D ret; diff --git a/include/block/block_int-common.h b/include/block/block_int-com= mon.h index 7abd2b12bb..cfc7b0f427 100644 --- a/include/block/block_int-common.h +++ b/include/block/block_int-common.h @@ -913,9 +913,6 @@ typedef struct BlockLimits { /* total number of zones */ uint32_t nr_zones; =20 - /* maximum sectors of a zone append write operation */ - uint32_t max_append_sectors; - /* maximum number of open zones */ uint32_t max_open_zones; =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001035; cv=none; d=zohomail.com; s=zohoarc; b=M1TEuUSmlCVvgLpP7sG79ss8RjR/fbnK9Yux2k7rhqQUPECZ/1mBnB1s0wJiXdLqxcE3U9je8nG3v/8w3nrqnU8Zmr7AyFH5ccq+ptAy4IjFiDCarFwOOeWqGwbO8U8C0zofLVm+KtWA8uO3PFSwZTN7g16U7HYBCehFV4tTVqU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001035; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=g6WpTBSiTmJrrvQy2krSoJd7Au0mqrGfUsep873fYPI=; b=m94Wqu8cijL26u2e+XZuGJf7ZkoXJsoINsB0cliC7/Meco+YD1ZDo1v885vFwOgO4tAR0rSRU31ZPQpS6CQbFJuAz6Q3oymSV9XXs5IkFSFbqAjLkk25Vmsdnx+gJS6txWnm8gDISl1XF+H6WJXGHZNCzor/D4k0rOCGKhswR3Y= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001035689234.66585423477807; Mon, 21 Sep 2026 07:30:35 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2B-0002sy-5d; Mon, 21 Sep 2026 10:30:19 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f19-00025f-RR; Mon, 21 Sep 2026 10:29:17 -0400 Received: from sea.source.kernel.org ([172.234.252.31]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f18-0000OM-93; Mon, 21 Sep 2026 10:29:15 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 0FBBB418BC; Mon, 21 Sep 2026 14:29:11 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 170E41F000FF; Mon, 21 Sep 2026 14:29:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000950; bh=g6WpTBSiTmJrrvQy2krSoJd7Au0mqrGfUsep873fYPI=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=HUl0Wgpo+zd1TW7ZPVN97ZT5qZ/CFWrpsDvILu0cj3OQnMvsLnGOzLqxyLx/rerwe HhnP8F7V6zDLw4QNuPZ5R3YoAgZcC3yA5mbd0z8khy36U7N40jUvxvrHDLKmSxhZGY qtPewIY6psER7NUwCsbMq0ffHUcMmuiWDEkYaES++EM8ADxDKjsFmuWsbW5FOIQuuZ jOdMOzlxeDT7/MTg0Q8kTlRT7RNTgYoWrEwQJSDt7gt0dNepGOxmmD08mbWtvVgGGt HnynXvAg14ccet9SLGNK/BWY3pCCdLOxSu6ggZXkI1twLkRgiF4ep2rV4AbVTS/gYo VaEzj6kNOw0ig== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 13/15] file-posix: reject a zone append past the device capacity Date: Mon, 21 Sep 2026 16:28:15 +0200 Message-ID: <20260921142819.2916043-14-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=172.234.252.31; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001036559158500 Content-Type: text/plain; charset="utf-8" raw_co_zone_append() checks that the offset it is given is aligned to the zone size, but not that it names a zone of the device. raw_co_prw() then derives a zone index from it and reads that entry of the write pointer array, so an offset past the end of the device reads past the end of the array. bdrv_co_zone_append() does not catch it either: bdrv_check_qiov_request() bounds the request against BDRV_MAX_LENGTH, which has nothing to do with the size of this device. A guest cannot reach it, because check_zoned_request() in virtio-blk rejects an out of range offset first, but qemu-io and any other caller of blk_co_zone_append() can: $ qemu-io --image-opts -n driver=3Dhost_device,filename=3D/dev/nullb0 \ -c "zap -p 0x100000000000 0x1000" Segmentation fault On a null_blk device with 1000 zones of 256 MiB, that offset yields zone index 65536 and reads 512 KiB beyond an 8000 byte allocation. Reject an offset that lies outside the device. That also bounds the zone index that raw_co_prw() derives from it, so its write pointer lookup stays inside the array. Fixes: 4751d09adcc3 ("block: introduce zone append write for zoned devices") Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- block/file-posix.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/block/file-posix.c b/block/file-posix.c index 1a4ca9d942..e1e6a03b25 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -3587,8 +3587,15 @@ raw_co_zone_append(BlockDriverState *bs, QEMUIOVector *qiov, BdrvRequestFlags flags) { assert(flags =3D=3D 0); + int64_t capacity =3D bs->total_sectors << BDRV_SECTOR_BITS; int64_t zone_size_mask =3D bs->bl.zone_size - 1; =20 + if (*offset >=3D capacity) { + error_report("*offset %" PRId64 " is equal to or greater than the " + "device capacity %" PRId64 "", *offset, capacity); + return -ENOSPC; + } + if (*offset & zone_size_mask) { error_report("sector offset %" PRId64 " is not aligned to zone siz= e " "%" PRId64 "", *offset / 512, bs->bl.zone_size / 512); --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001185; cv=none; d=zohomail.com; s=zohoarc; b=dkf9Zh8UAbaEfuOML6MNin51pdoR1ab5pWEHRVk0Yt63RWz3XXQcQYg49ZgALpSgClBnGz1IhgOmtw2RGp7TxAmb786Yl2VLHn8DoJaUaygQkTsrnpLINOO143mXKOjec6NYWEIDXJsWtlHkoLOQwJpNrE+o6XDCQ4P+XVleRvw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001185; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=9eUY+qoiMmI8f2wHw9jfnOrmp7TtMNfsRoJm1rEUDHQ=; b=DffiVEAj6a+ot1KulcJr/BoKXXyl7O2FcdTEEDVy8yGC1GgFzsD3u6O/hcer46r974/CWaqXVJoi1mq9/TDfhCfNua9JhN+/YlGahAHqfJniq9fp1Q2sP2UPCuI/keND2ODChqk36dlevqhnEas8S0i/8XJXKuo387I/PsCcrk8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001185614344.00128295062507; Mon, 21 Sep 2026 07:33:05 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2W-0004IU-29; Mon, 21 Sep 2026 10:30:40 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f1B-00025k-Fz; Mon, 21 Sep 2026 10:29:17 -0400 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f19-0000Oc-Gi; Mon, 21 Sep 2026 10:29:17 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id A713443C24; Mon, 21 Sep 2026 14:29:13 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7E1CF1F00893; Mon, 21 Sep 2026 14:29:11 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000953; bh=9eUY+qoiMmI8f2wHw9jfnOrmp7TtMNfsRoJm1rEUDHQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Qlkq0qro4cW87Q1xh7Kc2t8MazZPrBP0SsQmjoZTTOLzMj8why1jICVcFo3zYrgAM HLwTSUanZaNSSdsN1M8YmL5xmpS4Lalx5mkr+VpkF7eHlg4mQNRyYoOo8XiEarQWAL nt1EeyvwXb0/BvMm/wtJyUWL2vjlgOIBZZg2ju2EkHj8Fo75ksv3zWzh4cnY3n3fvi oeXddvmLbIwHQtXBKsxIthI9tWPOpPVaqHKIKLgPM4WvpFwoYGDRI3NAvj+exLTv7G tgJCxbZXbMH6zj0OmXdNM6TQcS+F2l1hFWfPjBn7+4lQwF8/IaG66NBJFwHZbojfS6 zYaHWqAxa4HRQ== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Hanna Reitz , Fam Zheng Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 14/15] file-posix: reject a zone append to a full or conventional zone Date: Mon, 21 Sep 2026 16:28:16 +0200 Message-ID: <20260921142819.2916043-15-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=2600:3c0a:e001:78e:0:1991:8:25; envelope-from=cassel@kernel.org; helo=sea.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001187633158500 Content-Type: text/plain; charset="utf-8" raw_co_prw() replaces the offset of a zone append with the write pointer of the addressed zone, which assumes that the stored value names a position inside that zone. It does not in two cases. A full zone has its write pointer recorded at the end of the zone, since get_zones_wp() stores start + len for BLK_ZONE_COND_FULL. That is the first sector of the following zone, so the append is submitted there. The kernel accepts it whenever that zone is empty, because it is a legal write at its write pointer, and the completion path advances the wrong zone because it recomputes the zone index from the replaced offset. The data is written to a zone that was never addressed and success is returned: zone 2 finished, then a 4 KiB append to zone 2: After zap done, the append sector is 0x180000 <- zone 3 zone 2: wptr 0x180000, zcond:14 (full) zone 3: wptr 0x180008 <- advanced A conventional zone has no write pointer at all, and its array entry carries only the type marker in the top bit, so the offset becomes negative and the write fails with EINVAL. That is harmless but it reports nothing about the actual mistake. Reject both while the write pointer lock is held, since the state has to be read and acted on atomically. check_zoned_request() in virtio-blk refuses an append to a conventional zone, so that case needs a caller that goes to the driver directly, but nothing there examines whether a zone is full, so a guest can reach the misdirected write. Fixes: 4751d09adcc3 ("block: introduce zone append write for zoned devices") Reviewed-by: Damien Le Moal Reviewed-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- block/file-posix.c | 23 ++++++++++++++++++++++- block/io.c | 9 +++++++++ include/block/block-io.h | 6 ++++++ 3 files changed, 37 insertions(+), 1 deletion(-) diff --git a/block/file-posix.c b/block/file-posix.c index e1e6a03b25..cd3c9f0fd0 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -2555,7 +2555,28 @@ raw_co_prw(BlockDriverState *bs, int64_t *offset_ptr= , uint64_t bytes, bs->bl.zoned !=3D BLK_Z_NONE) { qemu_co_mutex_lock(&bs->wps->colock); if (type & QEMU_AIO_ZONE_APPEND) { - int index =3D bdrv_zone_index(bs, offset); + uint32_t index =3D bdrv_zone_index(bs, offset); + + /* + * The write pointer of the addressed zone becomes the offset = of + * the write, so it has to name a position inside that zone. A + * conventional zone has no write pointer, and the pointer of a + * full zone is reported at the end of the zone. Either would = send + * the data to a zone that was never addressed. + */ + if (bdrv_zone_is_conv(bs, index)) { + error_report("zone append at offset 0x%" PRIx64 " addresse= s a " + "conventional zone", offset); + qemu_co_mutex_unlock(&bs->wps->colock); + return -EINVAL; + } + if (bdrv_zone_is_full(bs, index)) { + error_report("zone append at offset 0x%" PRIx64 " addresse= s a " + "full zone", offset); + qemu_co_mutex_unlock(&bs->wps->colock); + return -ENOSPC; + } + offset =3D bs->wps->wp[index]; } } diff --git a/block/io.c b/block/io.c index d7c403bc08..a4fb56f799 100644 --- a/block/io.c +++ b/block/io.c @@ -3402,6 +3402,15 @@ bool bdrv_zone_is_conv(BlockDriverState *bs, uint32_= t index) return BDRV_ZT_IS_CONV(bs->wps->wp[index]); } =20 +bool bdrv_zone_is_full(BlockDriverState *bs, uint32_t index) +{ + uint64_t zone_end =3D MIN((uint64_t)(index + 1) * bs->bl.zone_size, + (uint64_t)bs->total_sectors << BDRV_SECTOR_BIT= S); + IO_CODE(); + + return bs->wps->wp[index] >=3D zone_end; +} + void *qemu_blockalign(BlockDriverState *bs, size_t size) { IO_CODE(); diff --git a/include/block/block-io.h b/include/block/block-io.h index e469df7061..f671476f08 100644 --- a/include/block/block-io.h +++ b/include/block/block-io.h @@ -134,6 +134,12 @@ uint32_t bdrv_zone_index(BlockDriverState *bs, uint64_= t offset); * bdrv_zone_is_full() this does not need the write pointer lock. */ bool bdrv_zone_is_conv(BlockDriverState *bs, uint32_t index); +/* + * True when the write pointer of a zone has reached the end of the writab= le + * part of that zone, so that nothing more can be written to it until it is + * reset. The write pointer lock must be held when called. + */ +bool bdrv_zone_is_full(BlockDriverState *bs, uint32_t index); =20 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs); =20 --=20 2.55.0 From nobody Sat Sep 26 20:00:19 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1790001076; cv=none; d=zohomail.com; s=zohoarc; b=Nx8e2v7qF0voQDJimtsnrKMr52BSiGHzoAcj1/wxsWop4bRnCcQYGktUdRBxW2xP0mhwQIP98z1od5zVkbWOg614tIBDValyfsmQ7DAzXThC+0soRAEUIb2ygom9ABkb8f9R/LdCUTxowgFS9X/Q3LrGWeFTKqInUM9foLXHE30= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1790001076; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=wkePXI2ZAhs57urNC3Xrzyj8N64ULkLTlQbeBh3xUWk=; b=VXmWYZZ/ujXrjgy8VSsUCRjlRU6uMTAmsbfgRPFnjHtFIHtavgm17KMizUla2P9PuXut/+6II7SBny5IQH3yO2UMCyEa1fDB6ht8ct54fnVGsdq7m1a1DCovoYVUNUJ5WbKKqyyJcEVwtXhCYEGhAHDYs49bMNaVXpqKED3CX24= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists1p.gnu.org (lists1p.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1790001076114178.43112387678661; Mon, 21 Sep 2026 07:31:16 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists1p.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1x8f2X-0004QW-VV; Mon, 21 Sep 2026 10:30:42 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f1D-00026m-Ao; Mon, 21 Sep 2026 10:29:21 -0400 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1x8f1B-0000T2-HS; Mon, 21 Sep 2026 10:29:19 -0400 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 6BF9F600C8; Mon, 21 Sep 2026 14:29:16 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1A5921F000FF; Mon, 21 Sep 2026 14:29:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790000956; bh=wkePXI2ZAhs57urNC3Xrzyj8N64ULkLTlQbeBh3xUWk=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=htW1jAUEvr6LWaEvGpkzZOyapKB+uQFs5VwOem2hqbhIdL2N8e9QXG6tp8ouBiIpF 69evputjUSfuQkQzYybwDJYLKjFsfHa8TwjI+WIJN4HxIvTHJKqvhx5M4JIPiHZhuH KKlEMUhRLqmfWJlOoaCi+EiXdNphCdzS+h+1GTvS5RupqEzmF2HlKDdbNEvPPWtsAY TFV96tWy6mWK/2BeZV5aUl4OH1cl2eXuq2uvhAi77C7ZlkINx+seyWNDSqUnqjFXwQ +uU+Qt7Trx8tKY52DB5VngweQwd/fc2TbSnqUrveohKHeywTc0vdiUIbM9zRhLd1Uu EqN2eXLAcsg/g== From: Niklas Cassel To: Stefan Hajnoczi , Kevin Wolf , Fam Zheng , Hanna Reitz Cc: Sam Li , Damien Le Moal , Niklas Cassel , qemu-block@nongnu.org, qemu-devel@nongnu.org Subject: [PATCH v6 15/15] block: do not use CoroutineIOCompletion to hold a return value Date: Mon, 21 Sep 2026 16:28:17 +0200 Message-ID: <20260921142819.2916043-16-cassel@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260921142819.2916043-1-cassel@kernel.org> References: <20260921142819.2916043-1-cassel@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists1p.gnu.org; Received-SPF: pass client-ip=2600:3c04:e001:324:0:1991:8:25; envelope-from=cassel@kernel.org; helo=tor.source.kernel.org X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1790001076619158500 Content-Type: text/plain; charset="utf-8" bdrv_co_zone_report(), bdrv_co_zone_mgmt() and bdrv_co_zone_append() each declare a CoroutineIOCompletion in order to use its ret field, and never touch the coroutine field that the rest of the structure exists for. That structure is for a request which completes through bdrv_co_io_em_complete(), where the callback has to store the result somewhere and wake the coroutine that is waiting for it. These three call into the driver directly and are already running in the coroutine that wants the result, so there is nothing to wake and nowhere else for the value to live. Use a plain int. bdrv_co_zone_append() already has one. Suggested-by: Stefan Hajnoczi Signed-off-by: Niklas Cassel --- block/io.c | 29 +++++++++++------------------ 1 file changed, 11 insertions(+), 18 deletions(-) diff --git a/block/io.c b/block/io.c index a4fb56f799..c62c3764d3 100644 --- a/block/io.c +++ b/block/io.c @@ -3303,40 +3303,36 @@ int coroutine_fn bdrv_co_zone_report(BlockDriverSta= te *bs, int64_t offset, BlockZoneDescriptor *zones) { BlockDriver *drv =3D bs->drv; - CoroutineIOCompletion co =3D { - .coroutine =3D qemu_coroutine_self(), - }; + int ret; IO_CODE(); =20 bdrv_inc_in_flight(bs); if (!drv || !drv->bdrv_co_zone_report || bs->bl.zoned =3D=3D BLK_Z_NON= E) { - co.ret =3D -ENOTSUP; + ret =3D -ENOTSUP; goto out; } - co.ret =3D drv->bdrv_co_zone_report(bs, offset, nr_zones, zones); + ret =3D drv->bdrv_co_zone_report(bs, offset, nr_zones, zones); out: bdrv_dec_in_flight(bs); - return co.ret; + return ret; } =20 int coroutine_fn bdrv_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op, int64_t offset, int64_t len) { BlockDriver *drv =3D bs->drv; - CoroutineIOCompletion co =3D { - .coroutine =3D qemu_coroutine_self(), - }; + int ret; IO_CODE(); =20 bdrv_inc_in_flight(bs); if (!drv || !drv->bdrv_co_zone_mgmt || bs->bl.zoned =3D=3D BLK_Z_NONE)= { - co.ret =3D -ENOTSUP; + ret =3D -ENOTSUP; goto out; } - co.ret =3D drv->bdrv_co_zone_mgmt(bs, op, offset, len); + ret =3D drv->bdrv_co_zone_mgmt(bs, op, offset, len); out: bdrv_dec_in_flight(bs); - return co.ret; + return ret; } =20 int coroutine_fn bdrv_co_zone_append(BlockDriverState *bs, int64_t *offset, @@ -3345,9 +3341,6 @@ int coroutine_fn bdrv_co_zone_append(BlockDriverState= *bs, int64_t *offset, { int ret; BlockDriver *drv =3D bs->drv; - CoroutineIOCompletion co =3D { - .coroutine =3D qemu_coroutine_self(), - }; IO_CODE(); =20 ret =3D bdrv_check_qiov_request(*offset, qiov->size, qiov, 0, NULL); @@ -3379,13 +3372,13 @@ int coroutine_fn bdrv_co_zone_append(BlockDriverSta= te *bs, int64_t *offset, =20 bdrv_inc_in_flight(bs); if (!drv || !drv->bdrv_co_zone_append || bs->bl.zoned =3D=3D BLK_Z_NON= E) { - co.ret =3D -ENOTSUP; + ret =3D -ENOTSUP; goto out; } - co.ret =3D drv->bdrv_co_zone_append(bs, offset, qiov, flags); + ret =3D drv->bdrv_co_zone_append(bs, offset, qiov, flags); out: bdrv_dec_in_flight(bs); - return co.ret; + return ret; } =20 uint32_t bdrv_zone_index(BlockDriverState *bs, uint64_t offset) --=20 2.55.0