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
next prev 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