Linux virtualization list
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Brian Daniels" <briandaniels@google.com>
Cc: virtualization@lists.linux.dev, media-ci@linuxtv.org,
	"Michael S. Tsirkin" <mst@redhat.com>,
	"Eugenio Perez" <eperezma@redhat.com>
Subject: Re: [PATCH v11 2/6] media: virtio: Add V4L2 ioctl forwarding infrastructure
Date: Fri, 20 Nov 2026 22:25:37 +0000	[thread overview]
Message-ID: <sashiko-outbox-226261@kernel.org> (raw)
In-Reply-To: <20261120215916.3149345-3-briandaniels@google.com>

Thank you for your contribution! Sashiko AI review found 7 potential
issues to consider:
- [High] media: virtio: DMA mapping of kernel stack in
  scatterlist_builder_add_data()
- [High] media: virtio: pfn_to_kaddr() build and KASAN bug in
  retrieve_data()
- [High] media: virtio: session use-after-free on unbind in
  virtio_media_remove()
- [High] media: virtio: V4L2 core and compat bypass in
  virtio_media_device_ioctl()
- [Medium] media: virtio: unaligned shadow_buffer_pos in
  scatterlist_builder_add_data()
- [Medium] media: virtio: missing NUL-termination of cap->card in
  virtio_media_querycap()
- [Medium] media: virtio: uninitialized stack variables in
  virtio_media_g_input/output()
--

commit 2de20993548662c5f3f30aa219959343b41cbc39
Author: Alexandre Courbot <gnurou@gmail.com>

media: virtio: Add V4L2 ioctl forwarding infrastructure

This commit introduces a scatterlist builder and synchronous V4L2 ioctl
forwarding via VIRTIO_MEDIA_CMD_IOCTL, implementing VIDIOC_QUERYCAP and
fixed-size V4L2 ioctls.

> diff --git a/drivers/media/virtio/scatterlist_builder.c b/drivers/media/virtio/scatterlist_builder.c
> new file mode 100644
> index 0000000000000..ae8ffee82fa6e
> --- /dev/null
> +++ b/drivers/media/virtio/scatterlist_builder.c
[ ... ]
> +int scatterlist_builder_add_data(struct scatterlist_builder *builder,
> +				 void *data, size_t len)
> +{
> +	const size_t cur_desc = builder->cur_desc;
> +
> +	if (len == 0)
> +		return 0;
> +
> +	if (builder->cur_desc >= builder->num_descs)
> +		return -ENOSPC;
> +
> +	if (!always_use_shadow_buffer && virt_addr_valid(data) &&
> +	    virt_addr_valid(data + len)) {
> +		/*
> +		 * If "data" is in the 1:1 physical memory mapping then we can
> +		 * use a single SG entry and avoid copying.
> +		 */
> +		struct page *page = virt_to_page(data);
> +		size_t offset = (((size_t)data) & ~PAGE_MASK);
> +		struct scatterlist *next_desc =
> +			&builder->descs[builder->cur_desc];
> +
> +		memset(next_desc, 0, sizeof(*next_desc));
> +		sg_set_page(next_desc, page, len, offset);
> +		builder->cur_desc++;
> +	} else if (!always_use_shadow_buffer && is_vmalloc_addr(data)) {

[Severity: High]
Does scatterlist_builder_add_data() map kernel stack buffers directly for
DMA instead of falling back to builder->shadow_buffer?

Both video_usercopy() (for ioctl arguments up to 128 bytes) and handlers
such as virtio_media_g_input() and virtio_media_device_ioctl() pass
stack-allocated buffers here.  When CONFIG_VMAP_STACK=y, stack addresses
satisfy is_vmalloc_addr(data); when CONFIG_VMAP_STACK=n, they satisfy
virt_addr_valid(data).  Without checking !object_is_on_stack(data), stack
pages are placed directly into the virtqueue scatterlist, violating the DMA
API contract when DMA mapping is used (triggering CONFIG_DMA_API_DEBUG
check_for_stack() warnings and risking stack corruption on non-coherent
platforms).

Also, virt_addr_valid(data + len) checks one byte past the end of the
buffer rather than data + len - 1.

[ ... ]

> +	} else {
> +		/*
> +		 * As a last resort, copy into the shadow buffer and reference
> +		 * it with a single SG entry. Calling
> +		 * scatterlist_builder_retrieve_data() will be necessary to copy
> +		 * the data written by the device back into @data.
> +		 */
> +		void *shadow_buffer =
> +			builder->shadow_buffer + builder->shadow_buffer_pos;
> +		struct page *page = virt_to_page(shadow_buffer);
> +		unsigned long offset =
> +			(((unsigned long)shadow_buffer) & ~PAGE_MASK);
> +		struct scatterlist *next_desc =
> +			&builder->descs[builder->cur_desc];
> +
> +		if (len >
> +		    builder->shadow_buffer_size - builder->shadow_buffer_pos)
> +			return -ENOSPC;
> +
> +		memcpy(shadow_buffer, data, len);
> +		memset(next_desc, 0, sizeof(*next_desc));
> +		sg_set_page(next_desc, page, len, offset);
> +		builder->cur_desc++;
> +		builder->shadow_buffer_pos += len;
> +	}

[Severity: Medium]
Can advancing builder->shadow_buffer_pos by an unaligned len pack separate
DMA_TO_DEVICE and DMA_FROM_DEVICE descriptors into the same DMA cacheline?

When multiple descriptors use the shadow buffer (for example, cmd_ioctl at
12 bytes followed by resp_ioctl at 8 bytes and the response payload),
packing them at unaligned offsets shares a single cacheline across
bidirectional DMA mappings and leaves subsequent shadow buffer entries
misaligned.  In addition, this path unconditionally runs
memcpy(shadow_buffer, data, len) even when staging device-writable (_IOR)
response buffers.

[ ... ]

> +int scatterlist_builder_retrieve_data(struct scatterlist_builder *builder,
> +				      size_t sg_index, void *data)
> +{
> +	void *shadow_buf = builder->shadow_buffer;
> +	struct scatterlist *sg;
> +	void *kaddr;
> +
> +	/* We can only retrieve from the range of sgs currently set. */
> +	if (sg_index >= builder->cur_sg)
> +		return -ERANGE;
> +
> +	sg = builder->sgs[sg_index];
> +	kaddr = pfn_to_kaddr(page_to_pfn(sg_page(sg))) + sg->offset;
> +
> +	if (kaddr >= shadow_buf &&
> +	    kaddr < shadow_buf + builder->shadow_buffer_size) {
> +		if (kaddr + sg->length >
> +		    shadow_buf + builder->shadow_buffer_size)
> +			return -EINVAL;
> +
> +		memcpy(data, kaddr, sg->length);
> +	}
> +
> +	return 0;
> +}

[Severity: High]
Should this use sg_virt(sg) instead of
pfn_to_kaddr(page_to_pfn(sg_page(sg))) + sg->offset?

On powerpc, pfn_to_kaddr() returns const void *, failing compilation with
-Werror=discarded-qualifiers when assigned to void *kaddr, and on alpha and
x86_64 UML pfn_to_kaddr() is not defined.  On arm64 with tag-based KASAN
(CONFIG_KASAN_SW_TAGS or CONFIG_KASAN_HW_TAGS), pfn_to_kaddr() returns an
untagged linear address (top byte 0xff) while shadow_buf from kzalloc()
carries a KASAN tag, so the shadow_buf range check evaluates to false and
silently skips copying the device response back into data.

> diff --git a/drivers/media/virtio/virtio_media_driver.c b/drivers/media/virtio/virtio_media_driver.c
> index 39c5a38d20b1b..0fe20cf508212 100644
> --- a/drivers/media/virtio/virtio_media_driver.c
> +++ b/drivers/media/virtio/virtio_media_driver.c
[ ... ]
> @@ -77,6 +94,9 @@ static void virtio_media_session_free(struct virtio_media_session *session)
>  	virtio_media_session_fh_del(session);
>  	v4l2_fh_exit(&session->fh);
>  
> +	sg_free_table(&session->command_sgs);
> +
> +	kfree(session->shadow_buf);
>  	kfree(session);
>  }

[Severity: High]
Can session->command_sgs, session->shadow_buf, and session be used after
free and double freed if the device is removed while a file descriptor is
open?

virtio_media_remove() frees all sessions in vv->sessions via
virtio_media_session_free() while open struct file instances still reference
session->fh:

drivers/media/virtio/virtio_media_driver.c:virtio_media_remove() {
    ...
	list_for_each_safe(p, n, &vv->sessions) {
		struct virtio_media_session *s =
			list_entry(p, struct virtio_media_session, list);

		virtio_media_session_remove(vv, s);
		virtio_media_session_free(s);
	}
    ...
}

When userspace later closes the file descriptor, v4l2_release() invokes
virtio_media_device_close(), which accesses the freed session and calls
virtio_media_session_free(session) a second time:

CPU0                              CPU1
virtio_media_remove()
  video_unregister_device(...)
  ...
  virtio_media_session_free(s)
    sg_free_table(&s->command_sgs)
    kfree(s->shadow_buf)
    kfree(s)
                                  v4l2_release()
                                    virtio_media_device_close()
                                      virtio_media_session_close(vv, s)
                                        <-- use-after-free
                                      virtio_media_session_free(s)
                                        <-- double free

> diff --git a/drivers/media/virtio/virtio_media_ioctls.c b/drivers/media/virtio/virtio_media_ioctls.c
> new file mode 100644
> index 0000000000000..e92032bce7dbe
> --- /dev/null
> +++ b/drivers/media/virtio/virtio_media_ioctls.c
[ ... ]
> +static int virtio_media_querycap(struct file *file, void *fh,
> +				 struct v4l2_capability *cap)
> +{
> +	struct video_device *video_dev = video_devdata(file);
> +	struct virtio_media *vv = to_virtio_media(video_dev);
> +
> +	strscpy(cap->bus_info, "platform:virtio-media");
> +	strscpy(cap->driver, VIRTIO_MEDIA_DEFAULT_DRIVER_NAME);
> +
> +	virtio_cread_bytes(vv->virtio_dev, 8, cap->card, sizeof(cap->card));
> +
> +	cap->capabilities = video_dev->device_caps | V4L2_CAP_DEVICE_CAPS;
> +	cap->device_caps = video_dev->device_caps;
> +
> +	return 0;
> +}

[Severity: Medium]
Can virtio_media_querycap() leave cap->card without a NUL terminator?

In include/uapi/linux/virtio_media.h, struct virtio_media_config documents
that card does not need to be NUL-terminated when all 32 bytes are used,
whereas V4L2 requires struct v4l2_capability.card to be a NUL-terminated
string.

> +/*
> + * s/g_input/output work with an unsigned int - recast this to a u32 so the
> + * size is unambiguous.
> + */
> +
> +static int virtio_media_g_input(struct file *file, void *fh, unsigned int *i)
> +{
> +	u32 input;
> +
> +	int ret = virtio_media_send_r_ioctl(file_to_v4l2_fh(file),
> +					 VIDIOC_G_INPUT, &input,
> +					 sizeof(input));
> +	if (ret)
> +		return ret;
> +
> +	*i = input;
> +
> +	return 0;
> +}

[Severity: Medium]
Does virtio_media_g_input() (and virtio_media_g_output() below) pass
uninitialized stack memory to scatterlist_builder_add_data()?

Because input and output are not initialized before calling
virtio_media_send_r_ioctl(), the shadow buffer fallback in
scatterlist_builder_add_data() reads 4 bytes of uninitialized stack memory
via memcpy(shadow_buffer, data, len), and an incomplete host write leaves
uninitialized stack bytes in *i or *o.

[ ... ]

> +long virtio_media_device_ioctl(struct file *file, unsigned int cmd,
> +			       unsigned long arg)
> +{
> +	struct video_device *video_dev = video_devdata(file);
> +	struct virtio_media *vv = to_virtio_media(video_dev);
> +	struct v4l2_fh *vfh = NULL;
> +	struct v4l2_standard standard;
> +	v4l2_std_id std_id = 0;
> +	int ret;
> +
> +	if (test_bit(V4L2_FL_USES_V4L2_FH, &video_dev->flags))
> +		vfh = file_to_v4l2_fh(file);
> +
> +	mutex_lock(&vv->vlock);
> +
> +	/*
> +	 * We need to handle a few ioctls manually because their results
> +	 * rely on vfd->tvnorms, which is normally updated by the driver
> +	 * as S_INPUT is called. Since we want to just pass these ioctls
> +	 * through, we have to hijack them from here.
> +	 */
> +	switch (cmd) {
> +	case VIDIOC_S_STD:
> +		ret = copy_from_user(&std_id, (void __user *)arg,
> +				     sizeof(std_id));
> +		if (ret) {
> +			ret = -EFAULT;
> +			break;
> +		}
> +		ret = virtio_media_s_std(file, vfh, std_id);
> +		break;
> +	case VIDIOC_ENUMSTD:
> +		ret = copy_from_user(&standard, (void __user *)arg,
> +				     sizeof(standard));
> +		if (ret) {
> +			ret = -EFAULT;
> +			break;
> +		}
> +		ret = virtio_media_enumstd(file, vfh, &standard);
> +		if (ret)
> +			break;
> +		ret = copy_to_user((void __user *)arg, &standard,
> +				   sizeof(standard));
> +		if (ret)
> +			ret = -EFAULT;
> +		break;
> +	case VIDIOC_QUERYSTD:
> +		ret = virtio_media_querystd(file, vfh, &std_id);
> +		if (ret)
> +			break;
> +		ret = copy_to_user((void __user *)arg, &std_id, sizeof(std_id));
> +		if (ret)
> +			ret = -EFAULT;
> +		break;
> +	default:
> +		ret = video_ioctl2(file, cmd, arg);
> +		break;
> +	}
> +
> +	mutex_unlock(&vv->vlock);
> +
> +	return ret;
> +}

[Severity: High]
Does intercepting VIDIOC_S_STD, VIDIOC_ENUMSTD, and VIDIOC_QUERYSTD before
video_ioctl2() bypass V4L2 registration, priority, and 32-bit compat
handling?

Unlike __video_do_ioctl(), these three branches do not check
video_is_registered(video_dev) after acquiring vv->vlock.  If
virtio_media_device_ioctl() blocks on mutex_lock(&vv->vlock) while
virtio_media_remove() unregisters the device, deletes vv->commandq, and
frees all sessions, these branches proceed to dereference the freed session
and deleted virtqueue:

CPU0                              CPU1
v4l2_ioctl()
  video_is_registered(vdev)
  virtio_media_device_ioctl()
                                  virtio_media_remove()
                                    video_unregister_device(...)
                                    mutex_lock(&vv->vlock)
                                    ...
                                    virtio_dev->config->del_vqs(...)
                                    mutex_unlock(&vv->vlock)
                                    virtio_media_session_free(s)
    mutex_lock(&vv->vlock)
    virtio_media_querystd()
      ...                         <-- use-after-free of s and commandq

In addition, 32-bit compat userspace on x86_64 issues VIDIOC_ENUMSTD32,
which misses the VIDIOC_ENUMSTD case and falls through to video_ioctl2() ->
v4l_enumstd(), failing with -EINVAL because video_dev->tvnorms is 0.
Bypassing video_ioctl2() also skips is_valid_ioctl(), v4l2_prio_check() on
VIDIOC_S_STD, and INFO_FL_CLEAR zeroing of struct v4l2_standard fields
beyond index on VIDIOC_ENUMSTD.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261120215916.3149345-1-briandaniels@google.com?part=2

  reply	other threads:[~2026-11-20 22:25 UTC|newest]

Thread overview: 13+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20 21:59 [PATCH v11 0/6] media: add virtio-media driver Brian Daniels
2026-11-20 21:59 ` [PATCH v11 1/6] media: virtio: Add core driver and session management Brian Daniels
2026-11-20 22:19   ` sashiko-bot
2026-11-20 21:59 ` [PATCH v11 2/6] media: virtio: Add V4L2 ioctl forwarding infrastructure Brian Daniels
2026-11-20 22:25   ` sashiko-bot [this message]
2026-11-20 21:59 ` [PATCH v11 3/6] media: virtio: Add extended controls support Brian Daniels
2026-11-20 22:23   ` sashiko-bot
2026-11-20 21:59 ` [PATCH v11 4/6] media: virtio: Add buffer streaming, event handling, and poll Brian Daniels
2026-11-20 22:21   ` sashiko-bot
2026-11-20 21:59 ` [PATCH v11 5/6] media: virtio: Add MMAP buffer mapping support Brian Daniels
2026-11-20 22:16   ` sashiko-bot
2026-11-20 21:59 ` [PATCH v11 6/6] media: virtio: clear the size of legacy controls built on the stack Brian Daniels
2026-11-20 22:25   ` sashiko-bot

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-226261@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=briandaniels@google.com \
    --cc=eperezma@redhat.com \
    --cc=media-ci@linuxtv.org \
    --cc=mst@redhat.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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox