All of lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Annie Kim" <pulpannie@gmail.com>
Cc: virtualization@lists.linux.dev,
	"Michael S. Tsirkin" <mst@redhat.com>,
	"Eugenio Perez" <eperezma@redhat.com>
Subject: Re: [PATCH] virtio_blk: validate zone append sector from device
Date: Fri, 20 Nov 2026 06:47:44 +0000	[thread overview]
Message-ID: <sashiko-outbox-224582@kernel.org> (raw)
In-Reply-To: <20261120063039.4155597-1-pulpannie@gmail.com>

Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Medium] virtio_blk: double virtblk_update_zone_append_sector() call
  in virtblk_poll()
It also noticed 1 related pre-existing issue this patch does not
introduce:
- [Critical] virtio-blk: null pointer dereference in virtblk_poll() [1]
--

commit 9e4aa32cc96237b908b67c8c0ca12ebb3020f3a1
Author: Hyokyung Kim <pulpannie@gmail.com>

virtio_blk: validate zone append sector from device

This commit validates the device-reported starting sector on
REQ_OP_ZONE_APPEND completions in both the normal and polled completion
paths before updating req->__sector, failing out-of-range completions with
BLK_STS_IOERR.

> diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
> index 2b462005cdb68..8f88570b4f0e5 100644
> --- a/drivers/block/virtio_blk.c
> +++ b/drivers/block/virtio_blk.c
> @@ -331,15 +331,45 @@ static inline u8 virtblk_vbr_status(struct virtblk_req *vbr)
>  	return *((u8 *)&vbr->in_hdr + vbr->in_hdr_len - 1);
>  }
>  
> -static inline void virtblk_update_zone_append_sector(struct request *req,
> -						     struct virtblk_req *vbr)
> +#ifdef CONFIG_BLK_DEV_ZONED
> +static inline blk_status_t
> +virtblk_update_zone_append_sector(struct request *req,
> +				  struct virtblk_req *vbr,
> +				  blk_status_t status)
>  {
>  	struct virtio_blk *vblk = req->mq_hctx->queue->queuedata;
> +	sector_t req_start, sector, zone_end;
> +	unsigned int nr_sectors;
> +
> +	if (req_op(req) != REQ_OP_ZONE_APPEND || status != BLK_STS_OK)
> +		return status;
> +
> +	req_start = blk_rq_pos(req);
> +	sector = virtio64_to_cpu(vblk->vdev, vbr->in_hdr.zone_append.sector);
> +	nr_sectors = blk_rq_sectors(req);
> +	zone_end = req_start + disk_zone_capacity(vblk->disk, req_start);
> +
> +	if (zone_end < req_start || sector < req_start || sector >= zone_end ||
> +	    nr_sectors > zone_end - sector) {
> +		dev_err_ratelimited(&vblk->vdev->dev,
> +				    "zone append sector %llu + %u outside valid range [%llu, %llu)\n",
> +				    (u64)sector, nr_sectors,
> +				    (u64)req_start, (u64)zone_end);
> +		return BLK_STS_IOERR;
> +	}
>  
> -	if (req_op(req) == REQ_OP_ZONE_APPEND)
> -		req->__sector = virtio64_to_cpu(vblk->vdev,
> -						vbr->in_hdr.zone_append.sector);
> +	req->__sector = sector;
> +	return status;
>  }
> +#else
> +static inline blk_status_t
> +virtblk_update_zone_append_sector(struct request *req,
> +				  struct virtblk_req *vbr,
> +				  blk_status_t status)
> +{
> +	return status;
> +}
> +#endif
>  
>  static inline void virtblk_request_done(struct request *req)
>  {
> @@ -349,7 +379,7 @@ static inline void virtblk_request_done(struct request *req)
>  	virtblk_unmap_data(req, vbr);
>  	virtblk_cleanup_cmd(req);
>  
> -	virtblk_update_zone_append_sector(req, vbr);
> +	status = virtblk_update_zone_append_sector(req, vbr, status);
>  
>  	blk_mq_end_request(req, status);
>  }

[ ... ]

> @@ -1260,11 +1289,14 @@ static int virtblk_poll(struct blk_mq_hw_ctx *hctx, struct io_comp_batch *iob)
>  
>  	while ((vbr = virtqueue_get_buf(vq->vq, &len)) != NULL) {
>  		struct request *req = blk_mq_rq_from_pdu(vbr);
> -		u8 status = virtblk_vbr_status(vbr);
> +		blk_status_t status;
> +
> +		status = virtblk_result(virtblk_vbr_status(vbr));
> +		status = virtblk_update_zone_append_sector(req, vbr, status);
>  
>  		found++;
>  		if (!blk_mq_complete_request_remote(req) &&
> -		    !blk_mq_add_to_batch(req, iob, status != VIRTIO_BLK_S_OK,
> +		    !blk_mq_add_to_batch(req, iob, status != BLK_STS_OK,
>  					 virtblk_complete_batch))
>  			virtblk_request_done(req);
>  	}

[Severity: Medium]
Does calling virtblk_update_zone_append_sector() in virtblk_poll() before
falling back to virtblk_request_done() run the validation and update a
second time after req->__sector has already been overwritten?

When a polled REQ_OP_ZONE_APPEND request is not batched (for example when
an I/O scheduler is attached so RQF_SCHED_TAGS is set, when req->end_io is
set, or when validation itself returns BLK_STS_IOERR), virtblk_poll()
calls virtblk_request_done(), which recomputes status from vbr and calls
virtblk_update_zone_append_sector() again with req_start = blk_rq_pos(req)
now equal to the updated mid-zone sector rather than the zone start:

include/linux/blkdev.h:disk_zone_capacity() {
	sector_t zone_sectors = disk->queue->limits.chunk_sectors;

	if (sector + zone_sectors >= get_capacity(disk))
		return disk->last_zone_capacity;
	return disk->zone_capacity;
}

For a valid append in the second-to-last zone landing past the start of
that zone on a disk with a smaller last zone, sector + zone_sectors >=
get_capacity(disk) is true on the second call, so disk_zone_capacity()
returns last_zone_capacity and falsely fails the request with
BLK_STS_IOERR when nr_sectors > last_zone_capacity.  Even when all zones
have equal capacity, the second call shifts zone_end to sector +
zone_capacity and re-reads vbr->in_hdr from device memory, and any invalid
polled append logs dev_err_ratelimited() twice.

[Severity: Critical]
This problem wasn't introduced by this patch, but can virtblk_poll() hit a
NULL pointer dereference [1] on vq->lock if polled I/O runs after
init_vq() fails during device resume?

When virtio_find_vqs() fails in init_vq() (for instance if the hypervisor
reduces the ring size on resume), init_vq() frees vblk->vqs and sets it to
NULL while leaving the request queue quiesced but not frozen.  Because
blk_mq_poll() does not check whether the queue is quiesced, a userspace
polled read (such as preadv2() with RWF_HIPRI) calls virtblk_poll(), where
get_virtio_blk_vq() indexes the NULL vblk->vqs pointer and
spin_lock_irqsave(&vq->lock, flags) dereferences it.

[1] https://sashiko.dev/#/bug/linux-c7b06d8d-b2d5-4a94-acf6-9b1cf7480add

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261120063039.4155597-1-pulpannie@gmail.com?part=1

  reply	other threads:[~2026-11-20  6:47 UTC|newest]

Thread overview: 3+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20  6:30 [PATCH] virtio_blk: validate zone append sector from device Annie Kim
2026-11-20  6:47 ` sashiko-bot [this message]
2026-11-20 13:29 ` Damien Le Moal

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=sashiko-outbox-224582@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=eperezma@redhat.com \
    --cc=mst@redhat.com \
    --cc=pulpannie@gmail.com \
    --cc=sashiko-reviews@lists.linux.dev \
    --cc=virtualization@lists.linux.dev \
    /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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.