OpenVZ / Virtuozzo kernel development (devel@openvz.org)
 help / color / mirror / Atom feed
From: Alexander Ivanov <alexander.ivanov@virtuozzo.com>
To: andrey.zhadchenko@virtuozzo.com
Cc: devel@openvz.org
Subject: [Devel] [PATCH hci-8.1 v2 2/2] drivers/vhost/blk: support VIRTIO_BLK_F_WRITE_ZEROES
Date: Fri, 13 Nov 2026 09:27:44 +0100	[thread overview]
Message-ID: <20261113082744.2334476-3-alexander.ivanov@virtuozzo.com> (raw)
In-Reply-To: <20261113082744.2334476-1-alexander.ivanov@virtuozzo.com>

Handle VIRTIO_BLK_T_WRITE_ZEROES for parity with virtio-blk. The range
is zeroed with __blkdev_issue_zeroout(), which uses WRITE ZEROES of the
backend or falls back to writing zero pages. The UNMAP flag maps to
the absence of BLKDEV_ZERO_NOUNMAP. The range is issued in chunks of
at most 16 WRITE ZEROES bios and 1 GiB, or 4 MiB ones when zero pages
are written, since each chunk is built in the vhost worker.

The VMM must advertise blk_size equal to the backend logical block
size, max_write_zeroes_sectors aligned to it and at most 8388607, and
max_write_zeroes_seg = 1.

The guest gets VIRTIO_BLK_S_UNSUPP when VIRTIO_BLK_F_WRITE_ZEROES was
not negotiated, for a payload other than exactly one segment or an
unknown flag, and VIRTIO_BLK_S_IOERR for a read-only backend and for a
range that is unaligned, beyond the capacity or above 8388607 sectors.

https://virtuozzo.atlassian.net/browse/VSTOR-141684
Feature: vhost-blk: in-kernel accelerator for virtio-blk guests
Signed-off-by: Alexander Ivanov <alexander.ivanov@virtuozzo.com>
---
 drivers/vhost/blk.c | 178 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 176 insertions(+), 2 deletions(-)

diff --git a/drivers/vhost/blk.c b/drivers/vhost/blk.c
index eea8cca59cac..e27320651469 100644
--- a/drivers/vhost/blk.c
+++ b/drivers/vhost/blk.c
@@ -29,7 +29,8 @@ enum {
 			     (1ULL << VIRTIO_RING_F_INDIRECT_DESC) |
 			     (1ULL << VIRTIO_RING_F_EVENT_IDX) |
 			     (1ULL << VIRTIO_BLK_F_MQ) |
-			     (1ULL << VIRTIO_BLK_F_FLUSH),
+			     (1ULL << VIRTIO_BLK_F_FLUSH) |
+			     (1ULL << VIRTIO_BLK_F_WRITE_ZEROES),
 };
 
 /*
@@ -75,6 +76,10 @@ struct vhost_blk_req {
 	struct iovec status[VHOST_MAX_METADATA_IOV];
 
 	sector_t sector;
+	sector_t nr_sects;
+	sector_t chunk_sects;
+	struct block_device *bdev;
+	unsigned int zeroout_flags;
 	int bi_opf;
 	u16 head;
 	size_t len;
@@ -271,6 +276,63 @@ static int vhost_blk_move_bb_to_req(struct vhost_blk_req *req)
 	return 0;
 }
 
+/*
+ * The range is zeroed in the vhost worker with vq->mutex held, so it is
+ * split into chunks of a few bios each, much smaller ones when zero pages
+ * are written. The chunk sizes are multiples of any logical block size.
+ */
+#define VHOST_BLK_MAX_WRITE_ZEROES_BIOS		16
+#define VHOST_BLK_MAX_WRITE_ZEROES_SECTORS	(SZ_1G >> SECTOR_SHIFT)
+#define VHOST_BLK_MAX_ZERO_PAGES_SECTORS	(SZ_4M >> SECTOR_SHIFT)
+
+/*
+ * A request holds vhost_blk_flush() until its last chunk completes, so the
+ * whole range is bounded too. No Linux guest sends more, a bio cannot carry
+ * it.
+ */
+#define VHOST_BLK_MAX_WRITE_ZEROES_REQ_SECTORS	(UINT_MAX >> SECTOR_SHIFT)
+
+static int vhost_blk_bio_make_zeroes(struct vhost_blk_req *req,
+				     struct block_device *bdev)
+{
+	sector_t bs_mask = (bdev_logical_block_size(bdev) >> SECTOR_SHIFT) - 1;
+	sector_t max_sects = (sector_t)bdev_write_zeroes_sectors(bdev) *
+			     VHOST_BLK_MAX_WRITE_ZEROES_BIOS & ~bs_mask;
+	struct bio *bio = NULL;
+	int ret = -EOPNOTSUPP;
+
+	req->chunk_sects = min3(req->nr_sects, max_sects,
+				(sector_t)VHOST_BLK_MAX_WRITE_ZEROES_SECTORS);
+	/* The limit may appear after it was read, and no bio is built then */
+	if (req->chunk_sects)
+		ret = __blkdev_issue_zeroout(bdev, req->sector,
+					     req->chunk_sects, GFP_KERNEL, &bio,
+					     req->zeroout_flags |
+					     BLKDEV_ZERO_NOFALLBACK);
+	if (ret == -EOPNOTSUPP) {
+		req->chunk_sects = min_t(sector_t, req->nr_sects,
+					 VHOST_BLK_MAX_ZERO_PAGES_SECTORS);
+		ret = __blkdev_issue_zeroout(bdev, req->sector,
+					     req->chunk_sects, GFP_KERNEL, &bio,
+					     req->zeroout_flags);
+	}
+	if (ret)
+		return ret;
+
+	bio->bi_private = req;
+	bio->bi_end_io  = vhost_blk_req_done;
+	req->bio = req->inline_bio;
+	req->bio[0] = bio;
+
+	/* Zero pages are plain writes, a failure of them is not retried */
+	if (bio_op(bio) != REQ_OP_WRITE_ZEROES)
+		req->bi_opf = REQ_OP_WRITE;
+
+	atomic_set(&req->bio_nr, 1);
+
+	return 0;
+}
+
 static int vhost_blk_bio_make(struct vhost_blk_req *req,
 			      struct block_device *bdev)
 {
@@ -284,6 +346,9 @@ static int vhost_blk_bio_make(struct vhost_blk_req *req,
 	if (unlikely(req->bi_opf & REQ_PREFLUSH))
 		return vhost_blk_bio_make_simple(req, bdev);
 
+	if (req->bi_opf == REQ_OP_WRITE_ZEROES)
+		return vhost_blk_bio_make_zeroes(req, bdev);
+
 	/*
 	 * Requests with unaligned io vectors are not supported by underlined
 	 * block device, let's use an aligned intermediary "bounce buffer" to
@@ -451,6 +516,50 @@ static bool vhost_blk_backend_ro(struct file *f)
 	       bdev_read_only(I_BDEV(f->f_mapping->host));
 }
 
+static int vhost_blk_parse_write_zeroes(struct vhost_blk_req *req, u8 *status)
+{
+	struct file *f = vhost_vq_get_backend(&req->blk_vq->vq);
+	struct block_device *bdev = I_BDEV(f->f_mapping->host);
+	sector_t bs_mask = (bdev_logical_block_size(bdev) >> SECTOR_SHIFT) - 1;
+	struct virtio_blk_discard_write_zeroes seg;
+	struct iov_iter iter;
+	u32 flags;
+
+	if (!vhost_has_feature(&req->blk_vq->vq, VIRTIO_BLK_F_WRITE_ZEROES) ||
+	    req->len != sizeof(seg)) {
+		*status = VIRTIO_BLK_S_UNSUPP;
+		return 0;
+	}
+
+	iov_iter_init(&iter, ITER_SOURCE, req->iov, req->iov_nr, req->len);
+	if (copy_from_iter(&seg, sizeof(seg), &iter) != sizeof(seg))
+		return -EFAULT;
+
+	flags = le32_to_cpu(seg.flags);
+	if (flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) {
+		*status = VIRTIO_BLK_S_UNSUPP;
+		return 0;
+	}
+
+	req->sector = le64_to_cpu(seg.sector);
+	req->nr_sects = le32_to_cpu(seg.num_sectors);
+	req->bdev = bdev;
+	req->zeroout_flags = flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP ?
+			     0 : BLKDEV_ZERO_NOUNMAP;
+
+	if (vhost_blk_backend_ro(f) ||
+	    (req->sector | req->nr_sects) & bs_mask ||
+	    req->nr_sects > VHOST_BLK_MAX_WRITE_ZEROES_REQ_SECTORS ||
+	    req->sector > bdev_nr_sectors(bdev) ||
+	    req->nr_sects > bdev_nr_sectors(bdev) - req->sector) {
+		*status = VIRTIO_BLK_S_IOERR;
+		return 0;
+	}
+
+	*status = VIRTIO_BLK_S_OK;
+	return 0;
+}
+
 static int vhost_blk_req_handle(struct vhost_virtqueue *vq,
 				struct virtio_blk_outhdr *hdr,
 				u16 head, u16 out, u16 in)
@@ -475,6 +584,7 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq,
 	req->head	= head;
 	req->blk	= blk;
 	req->sector	= vhost64_to_cpu(vq, hdr->sector);
+	req->nr_sects	= 0;
 	req->iov	= blk_vq->iov;
 	req->bio_err	= 0;
 	in_len		= iov_length(vq->iov + out, in);
@@ -490,7 +600,7 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq,
 	req->status[0].iov_base = st->iov_base + st->iov_len;
 	req->status[0].iov_len = sizeof(status);
 
-	if (type == VIRTIO_BLK_T_OUT) {
+	if (type == VIRTIO_BLK_T_OUT || type == VIRTIO_BLK_T_WRITE_ZEROES) {
 		data_iov = vq->iov;
 		data_nr = out;
 	} else {
@@ -538,6 +648,22 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq,
 		req->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
 		ret = vhost_blk_req_submit(req);
 		break;
+	case VIRTIO_BLK_T_WRITE_ZEROES:
+		ret = vhost_blk_parse_write_zeroes(req, &status);
+		if (ret)
+			break;
+		if (status == VIRTIO_BLK_S_OK && req->nr_sects) {
+			req->bi_opf = REQ_OP_WRITE_ZEROES;
+			ret = vhost_blk_req_submit(req);
+			if (ret != -EPERM)
+				break;
+			status = VIRTIO_BLK_S_IOERR;
+		}
+		ret = vhost_blk_set_status(req, status);
+		if (ret)
+			break;
+		vhost_add_used_and_signal(&blk->dev, vq, head, sizeof(status));
+		break;
 	case VIRTIO_BLK_T_GET_ID:
 		len = min_t(size_t,
 			    strnlen(blk->serial, VIRTIO_BLK_ID_BYTES) + 1,
@@ -561,6 +687,51 @@ static int vhost_blk_req_handle(struct vhost_virtqueue *vq,
 	return ret;
 }
 
+/*
+ * Some devices clear their WRITE ZEROES limit only after a failed request,
+ * as blkdev_issue_write_zeroes() expects. Retry such a request with zero
+ * pages instead of failing it.
+ */
+static bool vhost_blk_retry_zeroes(struct vhost_blk_req *req)
+{
+	if (!req->bio_err || req->bi_opf != REQ_OP_WRITE_ZEROES)
+		return false;
+
+	if (bdev_write_zeroes_sectors(req->bdev))
+		return false;
+
+	/* The limit may come back before the bio is built, retry only once */
+	req->bi_opf = REQ_OP_WRITE;
+	if (vhost_blk_bio_make_zeroes(req, req->bdev))
+		return false;
+
+	req->bio_err = 0;
+	vhost_blk_bio_send(req);
+	return true;
+}
+
+/* Issue the next chunk of a write-zeroes range, if any is left */
+static bool vhost_blk_next_zeroes(struct vhost_blk_req *req)
+{
+	int ret;
+
+	if (req->bio_err || req->nr_sects <= req->chunk_sects)
+		return false;
+
+	req->sector += req->chunk_sects;
+	req->nr_sects -= req->chunk_sects;
+
+	req->bi_opf = REQ_OP_WRITE_ZEROES;
+	ret = vhost_blk_bio_make_zeroes(req, req->bdev);
+	if (ret) {
+		req->bio_err = ret;
+		return false;
+	}
+
+	vhost_blk_bio_send(req);
+	return true;
+}
+
 static void vhost_blk_handle_guest_kick(struct vhost_work *work)
 {
 	struct virtio_blk_outhdr hdr;
@@ -661,6 +832,9 @@ static void vhost_blk_handle_host_kick(struct vhost_work *work)
 		if (!blk)
 			blk = req->blk;
 
+		if (vhost_blk_retry_zeroes(req) || vhost_blk_next_zeroes(req))
+			continue;
+
 		if (!req->bio_err && req->bb && req->bi_opf == REQ_OP_READ) {
 			if (vhost_blk_move_bb_to_req(req))
 				req->bio_err = EINVAL;
-- 
2.53.0

_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel

  parent reply	other threads:[~2026-11-13  8:30 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-13  8:27 [Devel] [PATCH hci-8.1 v2 0/2] " Alexander Ivanov
2026-11-13  8:27 ` [Devel] [PATCH hci-8.1 v2 1/2] drivers/vhost/blk: fix a flush hang on requests completed after worker kill Alexander Ivanov
2026-11-13  8:34   ` no-reply
2026-11-13 19:55   ` Konstantin Khorenko
2026-11-13  8:27 ` Alexander Ivanov [this message]
2026-11-13  8:37   ` [Devel] [PATCH hci-8.1 v2 2/2] drivers/vhost/blk: support VIRTIO_BLK_F_WRITE_ZEROES no-reply
2026-11-13 19:55   ` Konstantin Khorenko
2026-11-13 19:55 ` [Devel] [PATCH hci-8.1 v2 0/2] " Konstantin Khorenko

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261113082744.2334476-3-alexander.ivanov@virtuozzo.com \
    --to=alexander.ivanov@virtuozzo.com \
    --cc=andrey.zhadchenko@virtuozzo.com \
    --cc=devel@openvz.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox