From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.openvz.org (mail.openvz.org [69.168.225.77]) by lore.virtuozzo.com (Postfix) with ESMTPS id C1714803F6 for ; Fri, 13 Nov 2026 08:30:14 +0000 (UTC) Received: from mail.openvz.org (localhost [127.0.0.1]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6AD8RwC3015961; Fri, 13 Nov 2026 11:27:59 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AD8RwC3015961 Authentication-Results: mail.openvz.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=virtuozzo.com header.i=@virtuozzo.com header.b="HcMXIOlc" Received: from mail-wm1-f69.google.com (mail-wm1-f69.google.com [209.85.128.69]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6AD8RmB9015939 (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128 verify=FAIL) for ; Fri, 13 Nov 2026 11:27:48 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AD8RmB9015939 Received: by mail-wm1-f69.google.com with SMTP id 5b1f17b1804b1-4a0284121c6so3646655e9.3 for ; Fri, 13 Nov 2026 00:27:48 -0800 (PST) X-Forwarded-Encrypted: i=2; AL+hErHOEICg0wWPTTYDa6Mb+yEXLFLmmwHsPcNrNsIF4tGqfwMbFLV7JOgyBxYEr+RMGwd8rrYovg==@openvz.org X-Gm-Message-State: APuU4Z/loPOD65/Pkfesvtv4l3gf4fEi0VV/fIWycd7T6/QQXl+1rjDo bxxSLja2VswDo0pUIpp7ABP9FFBHZwlldEqiTm2hfd3RsWBkPY81eVyZAw3O6U3y/UwFbAvkRdN Ni3c6ScKMepEk1TH/rn5NewaS7bJIfwjkpF2nbc0Bx91kVfTMtnAIwg== X-Gm-Gg: AYBFou1tYuRM8mxWsyrRUW9hXBkklYt/9wACMHe2AvxmFeLRe15J2R6YMhpMn8nrEU7 WvgVlh4nKjYBPDR5jg7rOQ2xe+ZJIDN61awHXMoCJvjdTNM/TzhEKn85u1If70bs40vDH/rAnbf axlkqbzzWZFjo3OvHEz/SVJ4QbJdJq+S/VSqgrFatq+bPcZnC+l6ZEVUDv5N1/aa0cOstrck4KG Dfp//vuqIJfPmLMsJL+8uHOWPO2UrPZWEipEU24v1tIQEPIu+KhpdeXVePFnApRbyftUjImHZ6M vdWoPkQGc/IHoiAA7O/QTtjmRoha8ZbTkAFqUk3QPPjmSV7Z96IzHIvYknN9L7mYe00YZvG9+8/ kqZ+3ZTyYIcQ94Z7S8ooFkZ1UX9b8 X-Received: by 2002:a05:600c:1d16:b0:4a2:84c:52f3 with SMTP id 5b1f17b1804b1-4bb55a4502amr36486105e9.6.1794558468206; Fri, 13 Nov 2026 00:27:48 -0800 (PST) X-Received: by 2002:a05:600c:1d16:b0:4a2:84c:52f3 with SMTP id 5b1f17b1804b1-4bb55a4502amr36485665e9.6.1794558467724; Fri, 13 Nov 2026 00:27:47 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1794558467; cv=none; d=google.com; s=arc-20260327; b=BWjuTv9Hw7Sh50jXocaBIEWSi4kOOBIzTww4xRfW28ieQXoU8xe/bxYBGV0kfGIEE4 LdECybQtJnxTy/z2pphEYh0giH2aMiE8gyy7IYzvKsFpLQ3W+Hp9s70xDoRgloKBdyhc AF/7zIaSVM4Tz5p2n48WyyiFYC1ARj+VBTcaVHRQpsUuKGJROXBSBVk9IBOCgn/745AF pRkind426rKL3XrP51qW3i4o59B3B3eRqFa+khkV3ApmSaG/BVOi5Q2s/DlMH+ElefD2 YwkpDrVazWYaPQuoVQZbFKQrRgZCiF3DjHfJDhEwEhPYO0VhNfwkDQslHwCUT0kird3L cddg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20260327; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=FT5yGKOFngV8hcEZCJ+y05dwa00GOC8IMaz5cnz2qDc=; fh=CMILZ+goaghq6B4UpCDhf0EQp6kYD0LAlmOkUiVCOvs=; b=Skns2cBZ27dnOd3Xeh7TjgDeV4IrhIpOnfwIUDb4iO+NJtAz1pQQxdBK+97iIQ4Pjj ie4Zc+HKyCGq5tGl4jwg0sVNVvF6mE17EBm5KGGMh0+0rib8VVLDGmtVr4PDHAP48FrJ gRVya4163FJe7Ck7/HrDEOyHwDvHTnErKfQ0deSnQwEshMZK6X8Es4q53z8qzh4BTXEZ EJmDyHQLWwP0P3Xs+Ed6iXOORpaSZ+wh7Cl2wiPjpBYTXSIZ6XDPJl1v0Pjczzx/MWc0 nt35saUeKOrl0+scSJvBqkpPYY3NYgpvo0YclBrQKFuoqxY+Z0aZfC6TlMJPt/GlGIZ3 mEUQ==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=HcMXIOlc; spf=pass (google.com: domain of alexander.ivanov@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=alexander.ivanov@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com Received: from relay.virtuozzo.com (relay.virtuozzo.com. [130.117.225.111]) by mx.google.com with ESMTPS id ffacd0b85a97d-49c89627737si3511768f8f.18.2026.11.13.00.27.47 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Nov 2026 00:27:47 -0800 (PST) Received-SPF: pass (google.com: domain of alexander.ivanov@virtuozzo.com designates 130.117.225.111 as permitted sender) client-ip=130.117.225.111; Authentication-Results: mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=HcMXIOlc; spf=pass (google.com: domain of alexander.ivanov@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=alexander.ivanov@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=virtuozzo.com; s=relay; h=MIME-Version:Message-ID:Date:Subject:From: Content-Type; bh=FT5yGKOFngV8hcEZCJ+y05dwa00GOC8IMaz5cnz2qDc=; b=HcMXIOlcjsrw jxlJTQLdCaSDTb5AtY8hJxYEcN8LD7uMqzAMd4lze6VMLQwoJVh18Spbk8YcaXgrDqRS3WShABkrz SI8xdMcDVEZ+8D4rLVKDhUFXk7oD9gvtGoP7yoMwljxGSEvSWh3ie+YFAwT6acPt1+ob9F6dNrIhr 3gHFsqVdkgkP8lNkj5Dq/5+1PP0JZsma0ngl6SOTKmUw/bo0f33zmFgBTl6z02gLhE/JEJRVDbkQ6 qImqv8xZ6/a1nsH16dX3JtcI6BlvmxQ8UDSSOzRVCbFyyoZvG4WdcS8XW310IFN+3gaZ2B4D32M6M D9gZYd3WffFGdUG2wHm78Q==; Received: from ch-vpn.virtuozzo.com ([130.117.225.6] helo=sky) by relay.virtuozzo.com with esmtps (TLS1.3) tls TLS_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1xRmZF-003ta7-10; Fri, 13 Nov 2026 09:27:44 +0100 From: Alexander Ivanov To: andrey.zhadchenko@virtuozzo.com Date: Fri, 13 Nov 2026 09:27:44 +0100 Message-ID: <20261113082744.2334476-3-alexander.ivanov@virtuozzo.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20261113082744.2334476-1-alexander.ivanov@virtuozzo.com> References: <20261113082744.2334476-1-alexander.ivanov@virtuozzo.com> MIME-Version: 1.0 X-OZ-Fwd: true Cc: devel@openvz.org Subject: [Devel] [PATCH hci-8.1 v2 2/2] drivers/vhost/blk: support VIRTIO_BLK_F_WRITE_ZEROES X-BeenThere: devel@openvz.org X-Mailman-Version: 2.1.12 Precedence: list List-Id: OpenVZ development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: devel-bounces@openvz.org Errors-To: devel-bounces@openvz.org 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 --- 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