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 1/6] media: virtio: Add core driver and session management
Date: Fri, 20 Nov 2026 22:19:54 +0000 [thread overview]
Message-ID: <sashiko-outbox-226244@kernel.org> (raw)
In-Reply-To: <20261120215916.3149345-2-briandaniels@google.com>
Thank you for your contribution! Sashiko AI review found 6 potential
issues to consider:
- [High] media: virtio: UAF and NULL deref on close after
virtio_media_remove()
- [High] media: virtio: unsynchronized commandq access and stack UAF on
cb_param
- [High] media: virtio: stack cb_param left queued if virtqueue_kick()
fails
- [Medium] media: virtio: unsigned status negation in
virtio_media_kick_command()
- [Low] media: virtio: MEDIA_VIRTIO misplaced in device types Kconfig
menu
- [Low] media: virtio: malformed kernel-doc and missing include in
headers
--
commit c335528a6819af8be1759670843febeb88a66360
Author: Alexandre Courbot <gnurou@gmail.com>
media: virtio: Add core driver and session management
This commit adds the initial virtio-media driver core, build system
integration, V4L2 device registration, and session open/close lifecycle
handling over the command virtqueue.
> diff --git a/drivers/media/Kconfig b/drivers/media/Kconfig
> index 6abc9302cd84d..ce7d088e74418 100644
> --- a/drivers/media/Kconfig
> +++ b/drivers/media/Kconfig
> @@ -136,6 +136,19 @@ config MEDIA_PLATFORM_SUPPORT
>
> Say Y when you want to be able to see such devices.
>
> +config MEDIA_VIRTIO
> + tristate "Virtio-media Driver"
> + depends on VIRTIO && VIDEO_DEV && 64BIT && (X86 || CPU_LITTLE_ENDIAN)
> + select VIDEOBUF2_CORE
> + select VIDEOBUF2_MEMOPS
> + help
> + Enables the virtio-media driver.
> +
> + This driver is used to virtualize media devices such as cameras or
> + decoders from a host into a guest using the V4L2 protocol.
> +
> + If unsure, say N.
> +
> config MEDIA_TEST_SUPPORT
> bool
> prompt "Test drivers" if MEDIA_SUPPORT_FILTER
[Severity: Low]
Should MEDIA_VIRTIO be placed under the "Media drivers" menu instead of
"Media device types"? When MEDIA_SUPPORT_FILTER is enabled, VIDEO_DEV is
hidden and only defaults to y if one of the device-type filter options
(such as MEDIA_CAMERA_SUPPORT or MEDIA_PLATFORM_SUPPORT) is selected, so
MEDIA_VIRTIO cannot be seen or enabled on its own.
> diff --git a/drivers/media/virtio/virtio_media_driver.c b/drivers/media/virtio/virtio_media_driver.c
> new file mode 100644
> index 0000000000000..39c5a38d20b1b
> --- /dev/null
> +++ b/drivers/media/virtio/virtio_media_driver.c
[ ... ]
> +static void commandq_callback(struct virtqueue *queue)
> +{
> + unsigned int len;
> + struct virtio_media_cmd_callback_param *param;
> +
> +process_bufs:
> + while ((param = virtqueue_get_buf(queue, &len))) {
> + param->resp_len = len;
> + param->done = true;
> + wake_up(¶m->vv->wq);
> + }
> +
> + if (!virtqueue_enable_cb(queue)) {
> + virtqueue_disable_cb(queue);
> + goto process_bufs;
> + }
> +}
> +
> +/**
> + * virtio_media_kick_command() - send a command to the commandq.
> + * @vv: virtio-media device in use.
> + * @sgs: descriptor chain to send.
> + * @out_sgs: number of device-readable descriptors in @sgs.
> + * @in_sgs: number of device-writable descriptors in @sgs.
> + * @resp_len: output parameter. Upon success, contains the size of the response
> + * in bytes.
> + */
> +static int virtio_media_kick_command(struct virtio_media *vv,
> + struct scatterlist **sgs,
> + const size_t out_sgs, const size_t in_sgs,
> + size_t *resp_len)
> +{
> + struct virtio_media_cmd_callback_param cb_param = {
> + .vv = vv,
> + .done = false,
> + .resp_len = 0,
> + };
> + struct virtio_media_resp_header *resp_header;
> + int ret = virtqueue_add_sgs(vv->commandq, sgs, out_sgs, in_sgs,
> + &cb_param, GFP_ATOMIC);
> + if (ret) {
> + v4l2_err(&vv->v4l2_dev,
> + "failed to add sgs to command virtqueue\n");
> + return ret;
> + }
> +
> + if (!virtqueue_kick(vv->commandq)) {
> + v4l2_err(&vv->v4l2_dev, "failed to kick command virtqueue\n");
> + return -EINVAL;
> + }
> +
> + /* Wait for the response. */
> + wait_event(vv->wq, cb_param.done);
[Severity: High]
Can commandq_callback() race with virtio_media_kick_command() on both
cb_param and vv->commandq?
CPU0 CPU1 (<hardirq>)
virtio_media_kick_command()
virtqueue_add_sgs(..., &cb_param)
virtqueue_kick(vv->commandq)
commandq_callback()
param = virtqueue_get_buf(...)
param->done = true;
wait_event(vv->wq, cb_param.done)
return 0; /* cb_param stack frame popped */
wake_up(¶m->vv->wq);
<-- stack use-after-return
mutex_unlock(&vv->vlock)
/* next command on CPU0 */
mutex_lock(&vv->vlock)
virtqueue_add_sgs(vv->commandq, ...)
virtqueue_enable_cb(queue)
<-- concurrent vq access
Virtqueue operations are not internally locked, and vv->vlock only
serializes process-context callers. Once param->done is set to true, the
waiter on CPU0 can return from virtio_media_kick_command() before
commandq_callback() reads param->vv, and a subsequent command can call
virtqueue_add_sgs() or virtqueue_kick() concurrently with
virtqueue_get_buf() and virtqueue_enable_cb() in the interrupt handler.
In addition, wait_event() waits in TASK_UNINTERRUPTIBLE with no timeout
while holding vv->vlock, so an unresponsive device will hang the calling
task indefinitely and block virtio_media_remove().
[Severity: High]
What happens to the queued &cb_param token if virtqueue_kick() fails in
virtio_media_kick_command()?
At that point virtqueue_add_sgs() and virtqueue_kick_prepare() have
already published the descriptor chain and the stack-allocated &cb_param
pointer into vv->commandq. Returning -EINVAL immediately pops the stack
frame (and in virtio_media_device_close() also frees session->cmd.close)
while the buffer remains queued, so a later completion on vv->commandq
will write to the popped stack frame in commandq_callback().
> +
> + if (resp_len)
> + *resp_len = cb_param.resp_len;
> +
> + if (in_sgs > 0) {
> + /*
> + * If we expect a response, make sure we have at least a
> + * response header - anything shorter is invalid.
> + */
> + if (cb_param.resp_len < sizeof(*resp_header)) {
> + v4l2_err(&vv->v4l2_dev,
> + "received response header is too short\n");
> + return -EINVAL;
> + }
> +
> + resp_header = sg_virt(sgs[out_sgs]);
> + if (resp_header->status)
> + /* Host returns a positive error code. */\n> + return -resp_header->status;
> + }
> +
> + return 0;
> +}
[Severity: Medium]
Can negating resp_header->status return a positive int or an invalid
errno?
resp_header->status is an unsigned 32-bit __le32. If the device writes a
value with bit 31 set (for example, a negative 32-bit errno such as
0xffffffea), -resp_header->status evaluates in unsigned arithmetic and
converts to a positive int, which virtio_media_send_command() treats as
success because it only checks for ret < 0. If resp_header->status is
between MAX_ERRNO + 1 (4096) and 0x80000000, the negative return value
propagates out of virtio_media_device_open() to VFS open, where
ERR_PTR(ret) does not satisfy IS_ERR() and is treated as a valid file
pointer.
Also, protocol fields marked __le32 in resp_header, cmd_open, resp_open,
and cmd_close are accessed directly without cpu_to_le32() and
le32_to_cpu(), which will trigger Sparse endianness warnings.
[ ... ]
> +static int virtio_media_device_close(struct file *file)
> +{
> + struct video_device *video_dev = video_devdata(file);
> + struct virtio_media *vv = to_virtio_media(video_dev);
> + struct virtio_media_session *session =
> + fh_to_session(file->private_data);
> +
> + int ret = virtio_media_session_close(vv, session);
> +
> + virtio_media_session_remove(vv, session);
> + virtio_media_session_free(session);
> +
> + return ret;
> +}
[ ... ]
> +static void virtio_media_remove(struct virtio_device *virtio_dev)
> +{
> + struct virtio_media *vv = virtio_dev->priv;
> + struct list_head *p, *n;
> +
> + /* Remove the video device to stop accessing the commandq virtqueue */
> + video_unregister_device(&vv->video_dev);
> +
> + /*
> + * Acquire vlock to ensure no concurrent accesses to the commandq
> + * virtqueue
> + */
> + mutex_lock(&vv->vlock);
> +
> + /* Stop all virtqueue callbacks */
> + virtio_reset_device(virtio_dev);
> +
> + /*
> + * Only detach the unused buffers to allow internal virtqueue clean up.
> + * The actual buffers are freed in virtio_media_release()
> + */
> + while (virtqueue_detach_unused_buf(vv->commandq))
> + ;
> +
> + /* Delete the virtqueues */
> + virtio_dev->config->del_vqs(virtio_dev);
> +
> + mutex_unlock(&vv->vlock);
> +
> + 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);
> + }
> +
> + v4l2_device_put(&vv->v4l2_dev);
> +}
[Severity: High]
What happens when an open V4L2 file descriptor is closed after
virtio_media_remove() runs?
CPU0 CPU1
virtio_media_remove()
video_unregister_device()
...
virtio_dev->config->del_vqs()
list_for_each_safe(..., &vv->sessions)
virtio_media_session_remove(vv, s)
virtio_media_session_free(s)
v4l2_fh_del(&s->fh, s->file)
/* sets file->private_data = NULL */
kfree(s)
v4l2_release(file)
virtio_media_device_close(file)
session = fh_to_session(NULL)
virtio_media_session_close(vv, NULL)
cmd_close->hdr.cmd = ...
<-- NULL pointer dereference
video_unregister_device() prevents new opens, but existing open file
descriptors still invoke virtio_media_device_close() when closed. Because
virtio_media_remove() already destroyed vv->commandq, cleared
file->private_data via v4l2_fh_del(), and freed each session (while
iterating vv->sessions without holding vv->sessions_lock), closing the fd
afterward dereferences a NULL or freed session and accesses the deleted
vv->commandq virtqueue.
> diff --git a/include/uapi/linux/virtio_media.h b/include/uapi/linux/virtio_media.h
> new file mode 100644
> index 0000000000000..ad05d742165c7
> --- /dev/null
> +++ b/include/uapi/linux/virtio_media.h
> @@ -0,0 +1,118 @@
[ ... ]
> +/**
> + * struct virtio_media_config - Video device configuration space.
> + * @device_caps: flags representing the device capabilities as used in &struct
> + * v4l2_capability. It corresponds with the device_caps field in
> + * the &struct video_device
> + * @ device_type: informs the driver of the type of the video device. It
> + * corresponds to with the ``vfl_devnod_type`` field of the
> + * device.
[ ... ]
> +#endif // _UAPI__LINUX_VIRTIO_MEDIA_H
[Severity: Low]
The space in "@ device_type:" prevents kernel-doc from recognizing the
member description, and the trailing "//" comment on #endif violates C90
comment rules for exported UAPI headers. In addition,
drivers/media/virtio/session.h and drivers/media/virtio/virtio_media.h use
__dma_from_device_group_begin() and __dma_from_device_group_end() without
including <linux/dma-mapping.h>, and kernel-doc warns on those macros
inside kernel-doc annotated structs.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261120215916.3149345-1-briandaniels@google.com?part=1
next prev parent reply other threads:[~2026-11-20 22:19 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 [this message]
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
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-226244@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 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.