Skip to contentSkip to conversation

media: add virtio-media driver

PATCH New Brian Daniels 2 participants 13 messages Nov 21

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

v12 cover media: add virtio-media driver

From: Alexandre Courbot <[email protected]>

Add the first version of the virtio-media driver.

This driver acts roughly as a V4L2 relay between user-space and the virtio virtual device on the host, so it is relatively simple, yet unconventional. It doesn't use VB2 or other frameworks typically used in a V4L2 driver, and most of its complexity resides in correctly and efficiently building the virtio descriptor chain to pass to the host, avoiding copies whenever possible. This is done by scatterlist_builder.[ch].

This version supports MMAP buffers. DMABUF support is still pending.
---
Guest Setup

Tests were ran on a Debian 12 guest running with crosvm. The guest image was created with:

$ virt-builder debian-12 --root-password password:""

Build crosvm and launch the guest starting at the "Crosvm" section on this page: https://github.com/chromeos/virtio-media/blob/main/TRY_IT_OUT.md#crosvm

NOTE: Before running v4l2-compliance in the guest, you need to install v4l-utils and ffmpeg:

$ apt update && apt install v4l-utils ffmpeg

---
Compliance Testing

This was tested using v4l2-compliance. Since virtio-media serves as a proxy to host devices for the guest VMs, we expect the guest compliance test to essentially match the host compliance test for the same device.

NOTE: A single failure is fixed when v4l2-compliance is ran on the guest by patching the v4l2r crate used by crosvm. The patch I used hasn't been merged but is available here: https://github.com/Gnurou/v4l2r/pull/66.

All tests used a Logitech USB Webcam C925e.

As tested on the host:

$ v4l2-compliance -d0 -s

v4l2-compliance 1.33.0-5523, 64 bits, 64-bit time_t v4l2-compliance SHA: 7e25bb929095 2026-10-29 15:02:40

Compliance test for uvcvideo device /dev/video0:

Driver Info:

	Driver name      : uvcvideo
	Card type        : Logitech Webcam C925e
	Bus info         : usb-0000:04:00.1-3
	Driver version   : 7.1.6
	Capabilities     : 0x84a00001

Video Capture
Metadata Capture
Streaming
Extended Pix Format
Device Capabilities
Device Caps : 0x04200001
Video Capture
Streaming
Extended Pix Format
Media Driver Info:

	Driver name      : uvcvideo
	Model            : Logitech Webcam C925e
	Serial           : 686F371F
	Bus info         : usb-0000:04:00.1-3
	Media version    : 7.1.6
	Hardware revision: 0x00000016 (22)
	Driver version   : 7.1.6
Interface Info:
	ID               : 0x03000002
	Type             : V4L Video
Entity Info:
	ID               : 0x00000001 (1)
	Name             : Logitech Webcam C925e
	Function         : V4L2 I/O
	Flags            : default
	Pad 0x01000007   : 0: Sink
	  Link 0x0200001f: from remote pad 0x100000a of entity 'Processing 3' (Video Pixel Formatter): Data, Enabled, Immutable

Required ioctls:
test MC information (see 'Media Driver Info' above): OK test VIDIOC_QUERYCAP: OK
test invalid ioctls: OK

Allow for multiple opens:
test second /dev/video0 open: OK
test VIDIOC_QUERYCAP: OK
test VIDIOC_G/S_PRIORITY: OK
test for unlimited opens: OK

Debug ioctls:
test VIDIOC_DBG_G/S_REGISTER: OK (Not Supported) test VIDIOC_LOG_STATUS: OK (Not Supported)

Input ioctls:
test VIDIOC_G/S_TUNER/ENUM_FREQ_BANDS: OK (Not Supported) test VIDIOC_G/S_FREQUENCY: OK (Not Supported) test VIDIOC_S_HW_FREQ_SEEK: OK (Not Supported) test VIDIOC_ENUMAUDIO: OK (Not Supported)
test VIDIOC_G/S/ENUMINPUT: OK
test VIDIOC_G/S_AUDIO: OK (Not Supported)
Inputs: 1 Audio Inputs: 0 Tuners: 0

Output ioctls:
test VIDIOC_G/S_MODULATOR: OK (Not Supported) test VIDIOC_G/S_FREQUENCY: OK (Not Supported) test VIDIOC_ENUMAUDOUT: OK (Not Supported) test VIDIOC_G/S/ENUMOUTPUT: OK (Not Supported) test VIDIOC_G/S_AUDOUT: OK (Not Supported)
Outputs: 0 Audio Outputs: 0 Modulators: 0

Input/Output configuration ioctls:
test VIDIOC_ENUM/G/S/QUERY_STD: OK (Not Supported) test VIDIOC_ENUM/G/S/QUERY_DV_TIMINGS: OK (Not Supported) test VIDIOC_DV_TIMINGS_CAP: OK (Not Supported) test VIDIOC_G/S_EDID: OK (Not Supported)

Control ioctls (Input 0):
test VIDIOC_QUERY_EXT_CTRL/QUERYMENU: OK test VIDIOC_QUERYCTRL: OK
test VIDIOC_G/S_CTRL: OK
test VIDIOC_G/S/TRY_EXT_CTRLS: OK test VIDIOC_(UN)SUBSCRIBE_EVENT/DQEVENT: OK test VIDIOC_G/S_JPEGCOMP: OK (Not Supported) Standard Controls: 19 Private Controls: 0

Format ioctls (Input 0):
test VIDIOC_ENUM_FMT/FRAMESIZES/FRAMEINTERVALS: OK test VIDIOC_G/S_PARM: OK
test VIDIOC_G_FBUF: OK (Not Supported) test VIDIOC_G_FMT: OK
test VIDIOC_TRY_FMT: OK
test VIDIOC_S_FMT: OK
test VIDIOC_G_SLICED_VBI_CAP: OK (Not Supported) test Cropping: OK (Not Supported)
test Composing: OK (Not Supported)
test Scaling: OK (Not Supported)

Codec ioctls (Input 0):
test VIDIOC_(TRY_)ENCODER_CMD: OK (Not Supported) test VIDIOC_G_ENC_INDEX: OK (Not Supported) test VIDIOC_(TRY_)DECODER_CMD: OK (Not Supported)

Buffer ioctls (Input 0):
test VIDIOC_REQBUFS/CREATE_BUFS/QUERYBUF: OK test CREATE_BUFS maximum buffers: OK test VIDIOC_REMOVE_BUFS: OK
test VIDIOC_EXPBUF: OK
test Requests: OK (Not Supported) test blocking wait: OK

Test input 0:

Streaming ioctls:
test read/write: OK (Not Supported)

Video Capture: Frame #000
Video Capture: Frame #001
Video Capture: Frame #002
Video Capture: Frame #003
Video Capture: Frame #004
Video Capture: Frame #005
Video Capture: Frame #006
Video Capture: Frame #007
Video Capture: Frame #008
Video Capture: Frame #009
Video Capture: Frame #010
Video Capture: Frame #011
Video Capture: Frame #012
Video Capture: Frame #013
Video Capture: Frame #014
Video Capture: Frame #015
Video Capture: Frame #016
Video Capture: Frame #017
Video Capture: Frame #018
Video Capture: Frame #019
Video Capture: Frame #020
Video Capture: Frame #021
Video Capture: Frame #022
Video Capture: Frame #023
Video Capture: Frame #024
Video Capture: Frame #025
Video Capture: Frame #026
Video Capture: Frame #027
Video Capture: Frame #028
Video Capture: Frame #029
Video Capture: Frame #030
Video Capture: Frame #031
Video Capture: Frame #032
Video Capture: Frame #033
Video Capture: Frame #034
Video Capture: Frame #035
Video Capture: Frame #036
Video Capture: Frame #037
Video Capture: Frame #038
Video Capture: Frame #039
Video Capture: Frame #040
Video Capture: Frame #041
Video Capture: Frame #042
Video Capture: Frame #043
Video Capture: Frame #044
Video Capture: Frame #045
Video Capture: Frame #046
Video Capture: Frame #047
Video Capture: Frame #048
Video Capture: Frame #049
Video Capture: Frame #050
Video Capture: Frame #051
Video Capture: Frame #052
Video Capture: Frame #053
Video Capture: Frame #054
Video Capture: Frame #055
Video Capture: Frame #056
Video Capture: Frame #057
Video Capture: Frame #058
Video Capture: Frame #059

test MMAP (no poll, REQBUFS): OK

Video Capture: Frame #000 (select)
Video Capture: Frame #001 (select)
Video Capture: Frame #002 (select)
Video Capture: Frame #003 (select)
Video Capture: Frame #004 (select)
Video Capture: Frame #005 (select)
Video Capture: Frame #006 (select)
Video Capture: Frame #007 (select)
Video Capture: Frame #008 (select)
Video Capture: Frame #009 (select)
Video Capture: Frame #010 (select)
Video Capture: Frame #011 (select)
Video Capture: Frame #012 (select)
Video Capture: Frame #013 (select)
Video Capture: Frame #014 (select)
Video Capture: Frame #015 (select)
Video Capture: Frame #016 (select)
Video Capture: Frame #017 (select)
Video Capture: Frame #018 (select)
Video Capture: Frame #019 (select)
Video Capture: Frame #020 (select)
Video Capture: Frame #021 (select)
Video Capture: Frame #022 (select)
Video Capture: Frame #023 (select)
Video Capture: Frame #024 (select)
Video Capture: Frame #025 (select)
Video Capture: Frame #026 (select)
Video Capture: Frame #027 (select)
Video Capture: Frame #028 (select)
Video Capture: Frame #029 (select)
Video Capture: Frame #030 (select)
Video Capture: Frame #031 (select)
Video Capture: Frame #032 (select)
Video Capture: Frame #033 (select)
Video Capture: Frame #034 (select)
Video Capture: Frame #035 (select)
Video Capture: Frame #036 (select)
Video Capture: Frame #037 (select)
Video Capture: Frame #038 (select)
Video Capture: Frame #039 (select)
Video Capture: Frame #040 (select)
Video Capture: Frame #041 (select)
Video Capture: Frame #042 (select)
Video Capture: Frame #043 (select)
Video Capture: Frame #044 (select)
Video Capture: Frame #045 (select)
Video Capture: Frame #046 (select)
Video Capture: Frame #047 (select)
Video Capture: Frame #048 (select)
Video Capture: Frame #049 (select)
Video Capture: Frame #050 (select)
Video Capture: Frame #051 (select)
Video Capture: Frame #052 (select)
Video Capture: Frame #053 (select)
Video Capture: Frame #054 (select)
Video Capture: Frame #055 (select)
Video Capture: Frame #056 (select)
Video Capture: Frame #057 (select)
Video Capture: Frame #058 (select)
Video Capture: Frame #059 (select)

test MMAP (select, REQBUFS): OK

Video Capture: Frame #000 (epoll)
Video Capture: Frame #001 (epoll)
Video Capture: Frame #002 (epoll)
Video Capture: Frame #003 (epoll)
Video Capture: Frame #004 (epoll)
Video Capture: Frame #005 (epoll)
Video Capture: Frame #006 (epoll)
Video Capture: Frame #007 (epoll)
Video Capture: Frame #008 (epoll)
Video Capture: Frame #009 (epoll)
Video Capture: Frame #010 (epoll)
Video Capture: Frame #011 (epoll)
Video Capture: Frame #012 (epoll)
Video Capture: Frame #013 (epoll)
Video Capture: Frame #014 (epoll)
Video Capture: Frame #015 (epoll)
Video Capture: Frame #016 (epoll)
Video Capture: Frame #017 (epoll)
Video Capture: Frame #018 (epoll)
Video Capture: Frame #019 (epoll)
Video Capture: Frame #020 (epoll)
Video Capture: Frame #021 (epoll)
Video Capture: Frame #022 (epoll)
Video Capture: Frame #023 (epoll)
Video Capture: Frame #024 (epoll)
Video Capture: Frame #025 (epoll)
Video Capture: Frame #026 (epoll)
Video Capture: Frame #027 (epoll)
Video Capture: Frame #028 (epoll)
Video Capture: Frame #029 (epoll)
Video Capture: Frame #030 (epoll)
Video Capture: Frame #031 (epoll)
Video Capture: Frame #032 (epoll)
Video Capture: Frame #033 (epoll)
Video Capture: Frame #034 (epoll)
Video Capture: Frame #035 (epoll)
Video Capture: Frame #036 (epoll)
Video Capture: Frame #037 (epoll)
Video Capture: Frame #038 (epoll)
Video Capture: Frame #039 (epoll)
Video Capture: Frame #040 (epoll)
Video Capture: Frame #041 (epoll)
Video Capture: Frame #042 (epoll)
Video Capture: Frame #043 (epoll)
Video Capture: Frame #044 (epoll)
Video Capture: Frame #045 (epoll)
Video Capture: Frame #046 (epoll)
Video Capture: Frame #047 (epoll)
Video Capture: Frame #048 (epoll)
Video Capture: Frame #049 (epoll)
Video Capture: Frame #050 (epoll)
Video Capture: Frame #051 (epoll)
Video Capture: Frame #052 (epoll)
Video Capture: Frame #053 (epoll)
Video Capture: Frame #054 (epoll)
Video Capture: Frame #055 (epoll)
Video Capture: Frame #056 (epoll)
Video Capture: Frame #057 (epoll)
Video Capture: Frame #058 (epoll)
Video Capture: Frame #059 (epoll)

test MMAP (epoll, REQBUFS): OK

Video Capture: Frame #000
Video Capture: Frame #001
Video Capture: Frame #002
Video Capture: Frame #003
Video Capture: Frame #004
Video Capture: Frame #005
Video Capture: Frame #006
Video Capture: Frame #007
Video Capture: Frame #008
Video Capture: Frame #009
Video Capture: Frame #010
Video Capture: Frame #011
Video Capture: Frame #012
Video Capture: Frame #013
Video Capture: Frame #014
Video Capture: Frame #015
Video Capture: Frame #016
Video Capture: Frame #017
Video Capture: Frame #018
Video Capture: Frame #019
Video Capture: Frame #020
Video Capture: Frame #021
Video Capture: Frame #022
Video Capture: Frame #023
Video Capture: Frame #024
Video Capture: Frame #025
Video Capture: Frame #026
Video Capture: Frame #027
Video Capture: Frame #028
Video Capture: Frame #029
Video Capture: Frame #030
Video Capture: Frame #031
Video Capture: Frame #032
Video Capture: Frame #033
Video Capture: Frame #034
Video Capture: Frame #035
Video Capture: Frame #036
Video Capture: Frame #037
Video Capture: Frame #038
Video Capture: Frame #039
Video Capture: Frame #040
Video Capture: Frame #041
Video Capture: Frame #042
Video Capture: Frame #043
Video Capture: Frame #044
Video Capture: Frame #045
Video Capture: Frame #046
Video Capture: Frame #047
Video Capture: Frame #048
Video Capture: Frame #049
Video Capture: Frame #050
Video Capture: Frame #051
Video Capture: Frame #052
Video Capture: Frame #053
Video Capture: Frame #054
Video Capture: Frame #055
Video Capture: Frame #056
Video Capture: Frame #057
Video Capture: Frame #058
Video Capture: Frame #059

test MMAP (no poll, CREATE_BUFS): OK

Video Capture: Frame #000 (select)
Video Capture: Frame #001 (select)
Video Capture: Frame #002 (select)
Video Capture: Frame #003 (select)
Video Capture: Frame #004 (select)
Video Capture: Frame #005 (select)
Video Capture: Frame #006 (select)
Video Capture: Frame #007 (select)
Video Capture: Frame #008 (select)
Video Capture: Frame #009 (select)
Video Capture: Frame #010 (select)
Video Capture: Frame #011 (select)
Video Capture: Frame #012 (select)
Video Capture: Frame #013 (select)
Video Capture: Frame #014 (select)
Video Capture: Frame #015 (select)
Video Capture: Frame #016 (select)
Video Capture: Frame #017 (select)
Video Capture: Frame #018 (select)
Video Capture: Frame #019 (select)
Video Capture: Frame #020 (select)
Video Capture: Frame #021 (select)
Video Capture: Frame #022 (select)
Video Capture: Frame #023 (select)
Video Capture: Frame #024 (select)
Video Capture: Frame #025 (select)
Video Capture: Frame #026 (select)
Video Capture: Frame #027 (select)
Video Capture: Frame #028 (select)
Video Capture: Frame #029 (select)
Video Capture: Frame #030 (select)
Video Capture: Frame #031 (select)
Video Capture: Frame #032 (select)
Video Capture: Frame #033 (select)
Video Capture: Frame #034 (select)
Video Capture: Frame #035 (select)
Video Capture: Frame #036 (select)
Video Capture: Frame #037 (select)
Video Capture: Frame #038 (select)
Video Capture: Frame #039 (select)
Video Capture: Frame #040 (select)
Video Capture: Frame #041 (select)
Video Capture: Frame #042 (select)
Video Capture: Frame #043 (select)
Video Capture: Frame #044 (select)
Video Capture: Frame #045 (select)
Video Capture: Frame #046 (select)
Video Capture: Frame #047 (select)
Video Capture: Frame #048 (select)
Video Capture: Frame #049 (select)
Video Capture: Frame #050 (select)
Video Capture: Frame #051 (select)
Video Capture: Frame #052 (select)
Video Capture: Frame #053 (select)
Video Capture: Frame #054 (select)
Video Capture: Frame #055 (select)
Video Capture: Frame #056 (select)
Video Capture: Frame #057 (select)
Video Capture: Frame #058 (select)
Video Capture: Frame #059 (select)

test MMAP (select, CREATE_BUFS): OK

Video Capture: Frame #000 (epoll)
Video Capture: Frame #001 (epoll)
Video Capture: Frame #002 (epoll)
Video Capture: Frame #003 (epoll)
Video Capture: Frame #004 (epoll)
Video Capture: Frame #005 (epoll)
Video Capture: Frame #006 (epoll)
Video Capture: Frame #007 (epoll)
Video Capture: Frame #008 (epoll)
Video Capture: Frame #009 (epoll)
Video Capture: Frame #010 (epoll)
Video Capture: Frame #011 (epoll)
Video Capture: Frame #012 (epoll)
Video Capture: Frame #013 (epoll)
Video Capture: Frame #014 (epoll)
Video Capture: Frame #015 (epoll)
Video Capture: Frame #016 (epoll)
Video Capture: Frame #017 (epoll)
Video Capture: Frame #018 (epoll)
Video Capture: Frame #019 (epoll)
Video Capture: Frame #020 (epoll)
Video Capture: Frame #021 (epoll)
Video Capture: Frame #022 (epoll)
Video Capture: Frame #023 (epoll)
Video Capture: Frame #024 (epoll)
Video Capture: Frame #025 (epoll)
Video Capture: Frame #026 (epoll)
Video Capture: Frame #027 (epoll)
Video Capture: Frame #028 (epoll)
Video Capture: Frame #029 (epoll)
Video Capture: Frame #030 (epoll)
Video Capture: Frame #031 (epoll)
Video Capture: Frame #032 (epoll)
Video Capture: Frame #033 (epoll)
Video Capture: Frame #034 (epoll)
Video Capture: Frame #035 (epoll)
Video Capture: Frame #036 (epoll)
Video Capture: Frame #037 (epoll)
Video Capture: Frame #038 (epoll)
Video Capture: Frame #039 (epoll)
Video Capture: Frame #040 (epoll)
Video Capture: Frame #041 (epoll)
Video Capture: Frame #042 (epoll)
Video Capture: Frame #043 (epoll)
Video Capture: Frame #044 (epoll)
Video Capture: Frame #045 (epoll)
Video Capture: Frame #046 (epoll)
Video Capture: Frame #047 (epoll)
Video Capture: Frame #048 (epoll)
Video Capture: Frame #049 (epoll)
Video Capture: Frame #050 (epoll)
Video Capture: Frame #051 (epoll)
Video Capture: Frame #052 (epoll)
Video Capture: Frame #053 (epoll)
Video Capture: Frame #054 (epoll)
Video Capture: Frame #055 (epoll)
Video Capture: Frame #056 (epoll)
Video Capture: Frame #057 (epoll)
Video Capture: Frame #058 (epoll)
Video Capture: Frame #059 (epoll)

test MMAP (epoll, CREATE_BUFS): OK

Video Capture: Frame #000
Video Capture: Frame #001
Video Capture: Frame #002
Video Capture: Frame #003
Video Capture: Frame #004
Video Capture: Frame #005
Video Capture: Frame #006
Video Capture: Frame #007
Video Capture: Frame #008
Video Capture: Frame #009
Video Capture: Frame #010
Video Capture: Frame #011
Video Capture: Frame #012
Video Capture: Frame #013
Video Capture: Frame #014
Video Capture: Frame #015
Video Capture: Frame #016
Video Capture: Frame #017
Video Capture: Frame #018
Video Capture: Frame #019
Video Capture: Frame #020
Video Capture: Frame #021
Video Capture: Frame #022
Video Capture: Frame #023
Video Capture: Frame #024
Video Capture: Frame #025
Video Capture: Frame #026
Video Capture: Frame #027
Video Capture: Frame #028
Video Capture: Frame #029
Video Capture: Frame #030
Video Capture: Frame #031
Video Capture: Frame #032
Video Capture: Frame #033
Video Capture: Frame #034
Video Capture: Frame #035
Video Capture: Frame #036
Video Capture: Frame #037
Video Capture: Frame #038
Video Capture: Frame #039
Video Capture: Frame #040
Video Capture: Frame #041
Video Capture: Frame #042
Video Capture: Frame #043
Video Capture: Frame #044
Video Capture: Frame #045
Video Capture: Frame #046
Video Capture: Frame #047
Video Capture: Frame #048
Video Capture: Frame #049
Video Capture: Frame #050
Video Capture: Frame #051
Video Capture: Frame #052
Video Capture: Frame #053
Video Capture: Frame #054
Video Capture: Frame #055
Video Capture: Frame #056
Video Capture: Frame #057
Video Capture: Frame #058
Video Capture: Frame #059

test USERPTR (no poll): OK

Video Capture: Frame #000 (select)
Video Capture: Frame #001 (select)
Video Capture: Frame #002 (select)
Video Capture: Frame #003 (select)
Video Capture: Frame #004 (select)
Video Capture: Frame #005 (select)
Video Capture: Frame #006 (select)
Video Capture: Frame #007 (select)
Video Capture: Frame #008 (select)
Video Capture: Frame #009 (select)
Video Capture: Frame #010 (select)
Video Capture: Frame #011 (select)
Video Capture: Frame #012 (select)
Video Capture: Frame #013 (select)
Video Capture: Frame #014 (select)
Video Capture: Frame #015 (select)
Video Capture: Frame #016 (select)
Video Capture: Frame #017 (select)
Video Capture: Frame #018 (select)
Video Capture: Frame #019 (select)
Video Capture: Frame #020 (select)
Video Capture: Frame #021 (select)
Video Capture: Frame #022 (select)
Video Capture: Frame #023 (select)
Video Capture: Frame #024 (select)
Video Capture: Frame #025 (select)
Video Capture: Frame #026 (select)
Video Capture: Frame #027 (select)
Video Capture: Frame #028 (select)
Video Capture: Frame #029 (select)
Video Capture: Frame #030 (select)
Video Capture: Frame #031 (select)
Video Capture: Frame #032 (select)
Video Capture: Frame #033 (select)
Video Capture: Frame #034 (select)
Video Capture: Frame #035 (select)
Video Capture: Frame #036 (select)
Video Capture: Frame #037 (select)
Video Capture: Frame #038 (select)
Video Capture: Frame #039 (select)
Video Capture: Frame #040 (select)
Video Capture: Frame #041 (select)
Video Capture: Frame #042 (select)
Video Capture: Frame #043 (select)
Video Capture: Frame #044 (select)
Video Capture: Frame #045 (select)
Video Capture: Frame #046 (select)
Video Capture: Frame #047 (select)
Video Capture: Frame #048 (select)
Video Capture: Frame #049 (select)
Video Capture: Frame #050 (select)
Video Capture: Frame #051 (select)
Video Capture: Frame #052 (select)
Video Capture: Frame #053 (select)
Video Capture: Frame #054 (select)
Video Capture: Frame #055 (select)
Video Capture: Frame #056 (select)
Video Capture: Frame #057 (select)
Video Capture: Frame #058 (select)
Video Capture: Frame #059 (select)

test USERPTR (select): OK
warn: v4l2-test-buffers.cpp(2220): Cannot test DMABUF, specify --expbuf-device
test DMABUF (no poll): OK (Not Supported)
test DMABUF (select): OK (Not Supported)

Total for uvcvideo device /dev/video0: 60, Succeeded: 60, Failed: 0, Warnings: 1

As tested on the guest:

$ v4l2-compliance -d0 -s --is-uvc

v4l2-compliance 1.33.0-5523, 64 bits, 64-bit time_t v4l2-compliance SHA: b3a7e9f866ed 2026-10-29 15:25:03

Compliance test for virtio-media device /dev/video0:

Driver Info:

	Driver name      : virtio-media
	Card type        : Logitech Webcam C925e
	Bus info         : platform:virtio-media
	Driver version   : 7.3.0
	Capabilities     : 0x84200001

Video Capture
Streaming
Extended Pix Format
Device Capabilities
Device Caps : 0x04200001
Video Capture
Streaming
Extended Pix Format

Required ioctls:
test VIDIOC_QUERYCAP: OK
test invalid ioctls: OK

Allow for multiple opens:
test second /dev/video0 open: OK
test VIDIOC_QUERYCAP: OK
test VIDIOC_G/S_PRIORITY: OK
test for unlimited opens: OK

Debug ioctls:
test VIDIOC_DBG_G/S_REGISTER: OK (Not Supported) test VIDIOC_LOG_STATUS: OK (Not Supported)

Input ioctls:
test VIDIOC_G/S_TUNER/ENUM_FREQ_BANDS: OK (Not Supported) test VIDIOC_G/S_FREQUENCY: OK (Not Supported) test VIDIOC_S_HW_FREQ_SEEK: OK
test VIDIOC_ENUMAUDIO: OK (Not Supported)
test VIDIOC_G/S/ENUMINPUT: OK
test VIDIOC_G/S_AUDIO: OK (Not Supported)
Inputs: 1 Audio Inputs: 0 Tuners: 0

Output ioctls:
test VIDIOC_G/S_MODULATOR: OK (Not Supported) test VIDIOC_G/S_FREQUENCY: OK (Not Supported) test VIDIOC_ENUMAUDOUT: OK (Not Supported) test VIDIOC_G/S/ENUMOUTPUT: OK (Not Supported) test VIDIOC_G/S_AUDOUT: OK (Not Supported)
Outputs: 0 Audio Outputs: 0 Modulators: 0

Input/Output configuration ioctls:
test VIDIOC_ENUM/G/S/QUERY_STD: OK (Not Supported) test VIDIOC_ENUM/G/S/QUERY_DV_TIMINGS: OK (Not Supported) test VIDIOC_DV_TIMINGS_CAP: OK (Not Supported) test VIDIOC_G/S_EDID: OK (Not Supported)

Control ioctls (Input 0):
test VIDIOC_QUERY_EXT_CTRL/QUERYMENU: OK test VIDIOC_QUERYCTRL: OK
test VIDIOC_G/S_CTRL: OK
test VIDIOC_G/S/TRY_EXT_CTRLS: OK test VIDIOC_(UN)SUBSCRIBE_EVENT/DQEVENT: OK test VIDIOC_G/S_JPEGCOMP: OK (Not Supported) Standard Controls: 19 Private Controls: 0

Format ioctls (Input 0):
test VIDIOC_ENUM_FMT/FRAMESIZES/FRAMEINTERVALS: OK test VIDIOC_G/S_PARM: OK
test VIDIOC_G_FBUF: OK (Not Supported) test VIDIOC_G_FMT: OK
test VIDIOC_TRY_FMT: OK
test VIDIOC_S_FMT: OK
test VIDIOC_G_SLICED_VBI_CAP: OK (Not Supported) test Cropping: OK (Not Supported)
test Composing: OK (Not Supported)
test Scaling: OK (Not Supported)

Codec ioctls (Input 0):
test VIDIOC_(TRY_)ENCODER_CMD: OK (Not Supported) test VIDIOC_G_ENC_INDEX: OK (Not Supported) test VIDIOC_(TRY_)DECODER_CMD: OK (Not Supported)

Buffer ioctls (Input 0):
test VIDIOC_REQBUFS/CREATE_BUFS/QUERYBUF: OK test CREATE_BUFS maximum buffers: OK test VIDIOC_REMOVE_BUFS: OK
test VIDIOC_EXPBUF: OK (Not Supported) test Requests: OK (Not Supported) test blocking wait: OK

Test input 0:

Streaming ioctls:
test read/write: OK (Not Supported)

Video Capture: Frame #000
Video Capture: Frame #001
Video Capture: Frame #002
Video Capture: Frame #003
Video Capture: Frame #004
Video Capture: Frame #005
Video Capture: Frame #006
Video Capture: Frame #007
Video Capture: Frame #008
Video Capture: Frame #009
Video Capture: Frame #010
Video Capture: Frame #011
Video Capture: Frame #012
Video Capture: Frame #013
Video Capture: Frame #014
Video Capture: Frame #015
Video Capture: Frame #016
Video Capture: Frame #017
Video Capture: Frame #018
Video Capture: Frame #019
Video Capture: Frame #020
Video Capture: Frame #021
Video Capture: Frame #022
Video Capture: Frame #023
Video Capture: Frame #024
Video Capture: Frame #025
Video Capture: Frame #026
Video Capture: Frame #027
Video Capture: Frame #028
Video Capture: Frame #029
Video Capture: Frame #030
Video Capture: Frame #031
Video Capture: Frame #032
Video Capture: Frame #033
Video Capture: Frame #034
Video Capture: Frame #035
Video Capture: Frame #036
Video Capture: Frame #037
Video Capture: Frame #038
Video Capture: Frame #039
Video Capture: Frame #040
Video Capture: Frame #041
Video Capture: Frame #042
Video Capture: Frame #043
Video Capture: Frame #044
Video Capture: Frame #045
Video Capture: Frame #046
Video Capture: Frame #047
Video Capture: Frame #048
Video Capture: Frame #049
Video Capture: Frame #050
Video Capture: Frame #051
Video Capture: Frame #052
Video Capture: Frame #053
Video Capture: Frame #054
Video Capture: Frame #055
Video Capture: Frame #056
Video Capture: Frame #057
Video Capture: Frame #058
Video Capture: Frame #059

test MMAP (no poll, REQBUFS): OK

Video Capture: Frame #000 (select)
Video Capture: Frame #001 (select)
Video Capture: Frame #002 (select)
Video Capture: Frame #003 (select)
Video Capture: Frame #004 (select)
Video Capture: Frame #005 (select)
Video Capture: Frame #006 (select)
Video Capture: Frame #007 (select)
Video Capture: Frame #008 (select)
Video Capture: Frame #009 (select)
Video Capture: Frame #010 (select)
Video Capture: Frame #011 (select)
Video Capture: Frame #012 (select)
Video Capture: Frame #013 (select)
Video Capture: Frame #014 (select)
Video Capture: Frame #015 (select)
Video Capture: Frame #016 (select)
Video Capture: Frame #017 (select)
Video Capture: Frame #018 (select)
Video Capture: Frame #019 (select)
Video Capture: Frame #020 (select)
Video Capture: Frame #021 (select)
Video Capture: Frame #022 (select)
Video Capture: Frame #023 (select)
Video Capture: Frame #024 (select)
Video Capture: Frame #025 (select)
Video Capture: Frame #026 (select)
Video Capture: Frame #027 (select)
Video Capture: Frame #028 (select)
Video Capture: Frame #029 (select)
Video Capture: Frame #030 (select)
Video Capture: Frame #031 (select)
Video Capture: Frame #032 (select)
Video Capture: Frame #033 (select)
Video Capture: Frame #034 (select)
Video Capture: Frame #035 (select)
Video Capture: Frame #036 (select)
Video Capture: Frame #037 (select)
Video Capture: Frame #038 (select)
Video Capture: Frame #039 (select)
Video Capture: Frame #040 (select)
Video Capture: Frame #041 (select)
Video Capture: Frame #042 (select)
Video Capture: Frame #043 (select)
Video Capture: Frame #044 (select)
Video Capture: Frame #045 (select)
Video Capture: Frame #046 (select)
Video Capture: Frame #047 (select)
Video Capture: Frame #048 (select)
Video Capture: Frame #049 (select)
Video Capture: Frame #050 (select)
Video Capture: Frame #051 (select)
Video Capture: Frame #052 (select)
Video Capture: Frame #053 (select)
Video Capture: Frame #054 (select)
Video Capture: Frame #055 (select)
Video Capture: Frame #056 (select)
Video Capture: Frame #057 (select)
Video Capture: Frame #058 (select)
Video Capture: Frame #059 (select)

test MMAP (select, REQBUFS): OK

Video Capture: Frame #000 (epoll)
Video Capture: Frame #001 (epoll)
Video Capture: Frame #002 (epoll)
Video Capture: Frame #003 (epoll)
Video Capture: Frame #004 (epoll)
Video Capture: Frame #005 (epoll)
Video Capture: Frame #006 (epoll)
Video Capture: Frame #007 (epoll)
Video Capture: Frame #008 (epoll)
Video Capture: Frame #009 (epoll)
Video Capture: Frame #010 (epoll)
Video Capture: Frame #011 (epoll)
Video Capture: Frame #012 (epoll)
Video Capture: Frame #013 (epoll)
Video Capture: Frame #014 (epoll)
Video Capture: Frame #015 (epoll)
Video Capture: Frame #016 (epoll)
Video Capture: Frame #017 (epoll)
Video Capture: Frame #018 (epoll)
Video Capture: Frame #019 (epoll)
Video Capture: Frame #020 (epoll)
Video Capture: Frame #021 (epoll)
Video Capture: Frame #022 (epoll)
Video Capture: Frame #023 (epoll)
Video Capture: Frame #024 (epoll)
Video Capture: Frame #025 (epoll)
Video Capture: Frame #026 (epoll)
Video Capture: Frame #027 (epoll)
Video Capture: Frame #028 (epoll)
Video Capture: Frame #029 (epoll)
Video Capture: Frame #030 (epoll)
Video Capture: Frame #031 (epoll)
Video Capture: Frame #032 (epoll)
Video Capture: Frame #033 (epoll)
Video Capture: Frame #034 (epoll)
Video Capture: Frame #035 (epoll)
Video Capture: Frame #036 (epoll)
Video Capture: Frame #037 (epoll)
Video Capture: Frame #038 (epoll)
Video Capture: Frame #039 (epoll)
Video Capture: Frame #040 (epoll)
Video Capture: Frame #041 (epoll)
Video Capture: Frame #042 (epoll)
Video Capture: Frame #043 (epoll)
Video Capture: Frame #044 (epoll)
Video Capture: Frame #045 (epoll)
Video Capture: Frame #046 (epoll)
Video Capture: Frame #047 (epoll)
Video Capture: Frame #048 (epoll)
Video Capture: Frame #049 (epoll)
Video Capture: Frame #050 (epoll)
Video Capture: Frame #051 (epoll)
Video Capture: Frame #052 (epoll)
Video Capture: Frame #053 (epoll)
Video Capture: Frame #054 (epoll)
Video Capture: Frame #055 (epoll)
Video Capture: Frame #056 (epoll)
Video Capture: Frame #057 (epoll)
Video Capture: Frame #058 (epoll)
Video Capture: Frame #059 (epoll)

test MMAP (epoll, REQBUFS): OK

Video Capture: Frame #000
Video Capture: Frame #001
Video Capture: Frame #002
Video Capture: Frame #003
Video Capture: Frame #004
Video Capture: Frame #005
Video Capture: Frame #006
Video Capture: Frame #007
Video Capture: Frame #008
Video Capture: Frame #009
Video Capture: Frame #010
Video Capture: Frame #011
Video Capture: Frame #012
Video Capture: Frame #013
Video Capture: Frame #014
Video Capture: Frame #015
Video Capture: Frame #016
Video Capture: Frame #017
Video Capture: Frame #018
Video Capture: Frame #019
Video Capture: Frame #020
Video Capture: Frame #021
Video Capture: Frame #022
Video Capture: Frame #023
Video Capture: Frame #024
Video Capture: Frame #025
Video Capture: Frame #026
Video Capture: Frame #027
Video Capture: Frame #028
Video Capture: Frame #029
Video Capture: Frame #030
Video Capture: Frame #031
Video Capture: Frame #032
Video Capture: Frame #033
Video Capture: Frame #034
Video Capture: Frame #035
Video Capture: Frame #036
Video Capture: Frame #037
Video Capture: Frame #038
Video Capture: Frame #039
Video Capture: Frame #040
Video Capture: Frame #041
Video Capture: Frame #042
Video Capture: Frame #043
Video Capture: Frame #044
Video Capture: Frame #045
Video Capture: Frame #046
Video Capture: Frame #047
Video Capture: Frame #048
Video Capture: Frame #049
Video Capture: Frame #050
Video Capture: Frame #051
Video Capture: Frame #052
Video Capture: Frame #053
Video Capture: Frame #054
Video Capture: Frame #055
Video Capture: Frame #056
Video Capture: Frame #057
Video Capture: Frame #058
Video Capture: Frame #059

test MMAP (no poll, CREATE_BUFS): OK

Video Capture: Frame #000 (select)
Video Capture: Frame #001 (select)
Video Capture: Frame #002 (select)
Video Capture: Frame #003 (select)
Video Capture: Frame #004 (select)
Video Capture: Frame #005 (select)
Video Capture: Frame #006 (select)
Video Capture: Frame #007 (select)
Video Capture: Frame #008 (select)
Video Capture: Frame #009 (select)
Video Capture: Frame #010 (select)
Video Capture: Frame #011 (select)
Video Capture: Frame #012 (select)
Video Capture: Frame #013 (select)
Video Capture: Frame #014 (select)
Video Capture: Frame #015 (select)
Video Capture: Frame #016 (select)
Video Capture: Frame #017 (select)
Video Capture: Frame #018 (select)
Video Capture: Frame #019 (select)
Video Capture: Frame #020 (select)
Video Capture: Frame #021 (select)
Video Capture: Frame #022 (select)
Video Capture: Frame #023 (select)
Video Capture: Frame #024 (select)
Video Capture: Frame #025 (select)
Video Capture: Frame #026 (select)
Video Capture: Frame #027 (select)
Video Capture: Frame #028 (select)
Video Capture: Frame #029 (select)
Video Capture: Frame #030 (select)
Video Capture: Frame #031 (select)
Video Capture: Frame #032 (select)
Video Capture: Frame #033 (select)
Video Capture: Frame #034 (select)
Video Capture: Frame #035 (select)
Video Capture: Frame #036 (select)
Video Capture: Frame #037 (select)
Video Capture: Frame #038 (select)
Video Capture: Frame #039 (select)
Video Capture: Frame #040 (select)
Video Capture: Frame #041 (select)
Video Capture: Frame #042 (select)
Video Capture: Frame #043 (select)
Video Capture: Frame #044 (select)
Video Capture: Frame #045 (select)
Video Capture: Frame #046 (select)
Video Capture: Frame #047 (select)
Video Capture: Frame #048 (select)
Video Capture: Frame #049 (select)
Video Capture: Frame #050 (select)
Video Capture: Frame #051 (select)
Video Capture: Frame #052 (select)
Video Capture: Frame #053 (select)
Video Capture: Frame #054 (select)
Video Capture: Frame #055 (select)
Video Capture: Frame #056 (select)
Video Capture: Frame #057 (select)
Video Capture: Frame #058 (select)
Video Capture: Frame #059 (select)

test MMAP (select, CREATE_BUFS): OK

Video Capture: Frame #000 (epoll)
Video Capture: Frame #001 (epoll)
Video Capture: Frame #002 (epoll)
Video Capture: Frame #003 (epoll)
Video Capture: Frame #004 (epoll)
Video Capture: Frame #005 (epoll)
Video Capture: Frame #006 (epoll)
Video Capture: Frame #007 (epoll)
Video Capture: Frame #008 (epoll)
Video Capture: Frame #009 (epoll)
Video Capture: Frame #010 (epoll)
Video Capture: Frame #011 (epoll)
Video Capture: Frame #012 (epoll)
Video Capture: Frame #013 (epoll)
Video Capture: Frame #014 (epoll)
Video Capture: Frame #015 (epoll)
Video Capture: Frame #016 (epoll)
Video Capture: Frame #017 (epoll)
Video Capture: Frame #018 (epoll)
Video Capture: Frame #019 (epoll)
Video Capture: Frame #020 (epoll)
Video Capture: Frame #021 (epoll)
Video Capture: Frame #022 (epoll)
Video Capture: Frame #023 (epoll)
Video Capture: Frame #024 (epoll)
Video Capture: Frame #025 (epoll)
Video Capture: Frame #026 (epoll)
Video Capture: Frame #027 (epoll)
Video Capture: Frame #028 (epoll)
Video Capture: Frame #029 (epoll)
Video Capture: Frame #030 (epoll)
Video Capture: Frame #031 (epoll)
Video Capture: Frame #032 (epoll)
Video Capture: Frame #033 (epoll)
Video Capture: Frame #034 (epoll)
Video Capture: Frame #035 (epoll)
Video Capture: Frame #036 (epoll)
Video Capture: Frame #037 (epoll)
Video Capture: Frame #038 (epoll)
Video Capture: Frame #039 (epoll)
Video Capture: Frame #040 (epoll)
Video Capture: Frame #041 (epoll)
Video Capture: Frame #042 (epoll)
Video Capture: Frame #043 (epoll)
Video Capture: Frame #044 (epoll)
Video Capture: Frame #045 (epoll)
Video Capture: Frame #046 (epoll)
Video Capture: Frame #047 (epoll)
Video Capture: Frame #048 (epoll)
Video Capture: Frame #049 (epoll)
Video Capture: Frame #050 (epoll)
Video Capture: Frame #051 (epoll)
Video Capture: Frame #052 (epoll)
Video Capture: Frame #053 (epoll)
Video Capture: Frame #054 (epoll)
Video Capture: Frame #055 (epoll)
Video Capture: Frame #056 (epoll)
Video Capture: Frame #057 (epoll)
Video Capture: Frame #058 (epoll)
Video Capture: Frame #059 (epoll)

test MMAP (epoll, CREATE_BUFS): OK test USERPTR (no poll): OK (Not Supported) test USERPTR (select): OK (Not Supported) test DMABUF (no poll): OK (Not Supported) test DMABUF (select): OK (Not Supported)

Total for virtio-media device /dev/video0: 59, Succeeded: 59, Failed: 0, Warnings: 0

---
Changes in v12:
- Add new dirty field to vb2_destroy_framevec() calls

Changes in v11:
- Initialize controls' size value to zero
(https://lore.kernel.org/all/[email protected])
- Framevec updated to work for multiple controls
- virtio_device_ready() is now called after early error paths
- Make g_input and g_output ioctls use _IOR version of cmd instead of _IOWR
- Fix behavior where poll does not report the CAPTURE queue readable after the LAST buffer
- Ensure event mutex is locked during probe
- Mmap returns EIO if the session error state is set
- Changed g_input and g_output ioctls to be _IOR instead of _IOWR to
match the v4l2 specification and virtio-media virtual device implementation

Changes in v10:
- Rebased on top of v7.3-rc1
- Add missing padding in ``struct virtio_media_cmd_mmap``
- Add ``virtio_media_config`` to uapi header and use proper ``cread`` during init
- Remove redundant assignment of ``vfl_type``
- Fix tear down order of the video device and resources in ``virtio_media_remove()``
- Call ``virtio_device_ready()`` before starting device
- Move from ``devm`` to manual memory management to prevent potential use after free
- Detach unused buffers from the virtqueues during device remove
- Remove wait timeout during kick command
- Fix use after free in case of transport-level error
- Add additional validity check for scatterlist data buffer
- Ensure PFNs are not truncated
- Use dynamic ``shadow_buffer_size`` in ``scatterlist_builder`` instead of the ``VIRTIO_SHADOW_BUF_SIZE`` constant to guard against future modifications
- Fix case where exact fit into a shadow buffer was wrongly rejected
- Fail early if ``virtio_get_shm_region()`` fails
- Move guest allocation before host call in ``reqbufs`` and ``createbufs``
- Clean up host-side mmap if ``io_remap_pfn_range()`` fails
- Ensure command failure returns in ``ext_controls`` ioctls
- Replace array ``vmalloc`` allocations with ``vcalloc`` for overflow protection
- Add check in ``dqbuf`` ioctl if no buffer is in the queue in case multiple threads call ``VIDIOC_DQBUF``
- Change ``copy_from_user()``/``copy_to_user()`` failure return value from ``EINVAL`` to ``EFAULT``
- Ensure reserved fields are initialized to zero
- Ensure ``device_type`` from config area is valid
- Set ``done`` flag after ``resp_len`` to address a race in the condition check fast path
- Do not leave host session open if guest allocations fail
- Rename ``errno`` to ``error`` in ``virtio_media`` UAPI to prevent compilation errors in userspaces apps that include ``errno.h``
- Keep user pages pinned during ``ext_ctrls`` request

Changes in v9:
- Removed note from cover letter about the dependency on the VIRTIO_ID_MEDIA patch since this was merged.

Changes in v8:
- Fix usage of integer types in uapi
- Add uapi header test exemption due to depenency on currently exempt videodev2.h

Changes in v7:
- Removed USERPTR feature
- Updated Kconfig dependency to include little endian and 64bit platforms (not only ARM and x86)
- Fixed incorrect constant in vfl_dir detection
- Clarified that error codes returned by the host are positive integers

Changes in v6:
- Added missing "WITH Linux-syscall-note" for SPDX-License-Identifier in ``include/uapi/linux/virtio_media.h``
- Rebased on top of v7.2-rc1

Changes in v5:
- Add DMA buffer alignment and padding for commands, responses, and the event buffer
- Corrected styling of kernel-doc comments
- Removed the configurable ``driver_name`` module parameter
- Moved the protocol to ``include/uapi/linux/virtio_media.h``
- Link to v4: https://lore.kernel.org/all/[email protected]/

Changes in v4:
- Rebased on top of v7.1-rc1
- Replace usages of filep->private_data with file_to_v4l2_fh()
throughout the driver
- Link to v3: https://lore.kernel.org/r/[email protected]

Changes in v3:
- Rebased on top of v6.15-rc1 and removes obsolete control callbacks.
- Link to v2: https://lore.kernel.org/r/[email protected]

Changes in v2:
- Fixed kernel test robot and media CI warnings (ignored a few false positives).
- Changed in-driver email address to personal one since my Google one
will soon become invalid.
- Link to v1: https://lore.kernel.org/r/[email protected]

Brian Daniels (5):
media: virtio: Add core driver and session management
media: virtio: Add V4L2 ioctl forwarding infrastructure
media: virtio: Add extended controls support
media: virtio: Add buffer streaming, event handling, and poll
media: virtio: Add MMAP buffer mapping support

Nick Rogers (1):
media: virtio: clear the size of legacy controls built on the stack

 MAINTAINERS                                |    8 +
 drivers/media/Kconfig                      |   13 +
 drivers/media/Makefile                     |    2 +
 drivers/media/virtio/Makefile              |    7 +
 drivers/media/virtio/scatterlist_builder.c |  596 +++++++++
 drivers/media/virtio/scatterlist_builder.h |  125 ++
 drivers/media/virtio/session.h             |  135 ++
 drivers/media/virtio/virtio_media.h        |   95 ++
 drivers/media/virtio/virtio_media_driver.c | 1071 +++++++++++++++
 drivers/media/virtio/virtio_media_ioctls.c | 1411 ++++++++++++++++++++
 include/uapi/linux/virtio_media.h          |  309 +++++
 usr/include/Makefile                       |    1 +
 12 files changed, 3773 insertions(+)
 create mode 100644 drivers/media/virtio/Makefile
 create mode 100644 drivers/media/virtio/scatterlist_builder.c
 create mode 100644 drivers/media/virtio/scatterlist_builder.h
 create mode 100644 drivers/media/virtio/session.h
 create mode 100644 drivers/media/virtio/virtio_media.h
 create mode 100644 drivers/media/virtio/virtio_media_driver.c
 create mode 100644 drivers/media/virtio/virtio_media_ioctls.c
 create mode 100644 include/uapi/linux/virtio_media.h

base-commit: ccf78740d63813c452c035b57d17a650492562fa

Signature · 1 line
2.56.1.750.gf70dc682cf-goog
#1 lore raw

PATCH v12 1/6 media: virtio: Add core driver and session management

From: Alexandre Courbot <[email protected]>

Add the initial virtio-media driver core, build system integration, MAINTAINERS entry, and V4L2 session lifecycle management.

The driver binds to VIRTIO_ID_MEDIA devices, reads device capabilities and device node type from the virtio configuration space, sets up the command virtqueue for synchronous host requests, and registers the V4L2 and video devices. Opening and closing the video device creates and destroys a host-backed session via VIRTIO_MEDIA_CMD_OPEN and VIRTIO_MEDIA_CMD_CLOSE.

Protocol structures in the UAPI header include explicit __reserved fields solely to guarantee 64-bit alignment rather than for future protocol expansion. Because the UAPI header includes linux/videodev2.h, which is currently excluded from standalone UAPI header compilation checks (CONFIG_UAPI_HEADER_TEST=y), add linux/virtio_media.h to the same exception list in usr/include/Makefile.

---
 MAINTAINERS                                |   8 +
 drivers/media/Kconfig                      |  13 +
 drivers/media/Makefile                     |   2 +
 drivers/media/virtio/Makefile              |   7 +
 drivers/media/virtio/session.h             |  58 +++
 drivers/media/virtio/virtio_media.h        |  70 +++
 drivers/media/virtio/virtio_media_driver.c | 504 +++++++++++++++++++++
 include/uapi/linux/virtio_media.h          | 118 +++++
 usr/include/Makefile                       |   1 +
 9 files changed, 781 insertions(+)
 create mode 100644 drivers/media/virtio/Makefile
 create mode 100644 drivers/media/virtio/session.h
 create mode 100644 drivers/media/virtio/virtio_media.h
 create mode 100644 drivers/media/virtio/virtio_media_driver.c
 create mode 100644 include/uapi/linux/virtio_media.h
MAINTAINERS +8 -0
index f72ce07a4..ba8373452 100644
@@ -29630,6 +29630,7 @@ F:	Documentation/devicetree/bindings/virtio/
 F:	Documentation/driver-api/virtio/
 F:	drivers/block/virtio_blk.c
 F:	drivers/crypto/virtio/
+F:	drivers/media/virtio/
 F:	drivers/vdpa/
 F:	drivers/virtio/
 F:	include/linux/vdpa.h
@@ -29742,6 +29743,13 @@ S:	Maintained
 F:	drivers/iommu/virtio-iommu.c
 F:	include/uapi/linux/virtio_iommu.h
 
+VIRTIO MEDIA DRIVER
+M:	Brian Daniels <[email protected]>
+L:	[email protected]
+S:	Maintained
+F:	drivers/media/virtio/
+F:	include/uapi/linux/virtio_media.h
+
 VIRTIO MEM DRIVER
 M:	David Hildenbrand <[email protected]>
 L:	[email protected]
drivers/media/Kconfig +13 -0
index 6abc9302c..ce7d088e7 100644
@@ -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
drivers/media/Makefile +2 -0
index 20fac24e4..357e786cc 100644
@@ -23,6 +23,8 @@ obj-$(CONFIG_DVB_CORE) += dvb-core/
 # There are both core and drivers at RC subtree - merge before drivers
 obj-y += rc/
 
+obj-$(CONFIG_MEDIA_VIRTIO) += virtio/
+
 obj-$(CONFIG_CEC_CORE) += cec/
 
 #
drivers/media/virtio/Makefile new file +7 -0
new file mode 100644
index 000000000..09d9834da
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Makefile for the virtio-media device driver.
+
+virtio-media-objs := virtio_media_driver.o
+
+obj-$(CONFIG_MEDIA_VIRTIO) += virtio-media.o
drivers/media/virtio/session.h new file +58 -0

58 lines not on this page · raw message

drivers/media/virtio/virtio_media.h new file +70 -0

70 lines not on this page · raw message

drivers/media/virtio/virtio_media_driver.c new file +504 -0

504 lines not on this page · raw message

include/uapi/linux/virtio_media.h new file +118 -0

118 lines not on this page · raw message

usr/include/Makefile +1 -0
index ee69dd9d9..df106b5d9 100644
@@ -37,6 +37,7 @@ no-header-test += linux/usb/audio.h
 no-header-test += linux/v4l2-mediabus.h
 no-header-test += linux/v4l2-subdev.h
 no-header-test += linux/videodev2.h
+no-header-test += linux/virtio_media.h
 no-header-test += linux/vm_sockets.h
 no-header-test += sound/asequencer.h
 no-header-test += sound/asoc.h
Signature · 1 line
2.56.1.750.gf70dc682cf-goog
#2 lore raw

Re: [PATCH v12 1/6] media: virtio: Add core driver and session management

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…

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 cb_param wakeup race
- [Medium] media: virtio: stack cb_param left queued if virtqueue_kick() fails
- [Medium] media: virtio: unsigned status negation and missing le32 conversions
- [Low] media: Kconfig: MEDIA_VIRTIO depends on hidden VIDEO_DEV in filter menu
- [Low] media: virtio: kernel-doc warnings and C++ comment in UAPI header
--

commit 737186f1522940e8113c5acf117d0e10e560174d
Author: Alexandre Courbot <[email protected]>

media: virtio: Add core driver and session management

This commit adds the initial virtio-media driver core, build system integration, MAINTAINERS entry, and V4L2 session lifecycle management.

Quoted 14 lines
drivers/media/Kconfig +6 -0
index 6abc9302cd84d..ce7d088e74418 100644
@@ -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

drivers/media/Kconfig config MEDIA_PLATFORM_SUPPORT · line 154

Quoted 10 lines
drivers/media/Kconfig +7 -0
+	  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]
Can MEDIA_VIRTIO be selected when MEDIA_SUPPORT_FILTER=y unless another media device category is also enabled?

When MEDIA_SUPPORT_FILTER=y, VIDEO_DEV has no prompt and is only enabled by its default expression (MEDIA_CAMERA_SUPPORT || MEDIA_ANALOG_TV_SUPPORT || MEDIA_RADIO_SUPPORT || MEDIA_SDR_SUPPORT || MEDIA_PLATFORM_SUPPORT || MEDIA_TEST_SUPPORT). Because MEDIA_VIRTIO is placed inside the "Media device types" filter menu with a dependency on VIDEO_DEV rather than under "Media drivers" (or included in VIDEO_DEV's default rule), it stays hidden unless an unrelated device category is enabled.

Quoted 5 lines
drivers/media/virtio/virtio_media_driver.c new file +0 -0
new file mode 100644
index 0000000000000..39c5a38d20b1b

[ ... ]

Quoted 43 lines
drivers/media/virtio/virtio_media_driver.c new file +43 -0
+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(&param->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");

drivers/media/virtio/virtio_media_driver.c line 207

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c new file +10 -0
+		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 the stack-allocated cb_param and vv->commandq?

CPU0 (commandq_callback) CPU1 (virtio_media_kick_command)
param = virtqueue_get_buf(...)
param->resp_len = len;

param->done = true;
                                  wait_event(vv->wq, cb_param.done)
                                    /* sees cb_param.done == true */
                                  return 0; /* pops cb_param */

wake_up(&param->vv->wq);
<-- stack use-after-return on param->vv

                                  /* next command under vv->vlock */
                                  virtqueue_add_sgs(vv->commandq, ...)

virtqueue_enable_cb(queue) virtqueue_kick(vv->commandq)
<-- concurrent unsynchronized virtqueue access

wait_event() checks cb_param.done before taking vv->wq.lock, so CPU1 can observe param->done == true and return from virtio_media_kick_command() before CPU0 reads param->vv in wake_up(&param->vv->wq). Once CPU1 wakes, it or the next caller acquiring vv->vlock can also call virtqueue_add_sgs() and virtqueue_kick() while commandq_callback() is still calling virtqueue_get_buf(), virtqueue_enable_cb(), and virtqueue_disable_cb() on vv->commandq without a spinlock, violating virtio_ring's caller serialization requirement.

[Severity: Medium]
If virtqueue_kick() fails after virtqueue_add_sgs() succeeds, does returning -EINVAL leave the stack address &cb_param and the caller's command buffer queued in vv->commandq?

virtio_media_device_close() ignores the error from virtio_media_session_close() and frees session while session->cmd.close is still in the vring, and any later completion in commandq_callback() will write through the dangling &cb_param stack pointer. Also, once virtqueue_kick() succeeds, wait_event(vv->wq, cb_param.done) sleeps uninterruptibly under vv->vlock with no timeout or removal wake condition, which will hang the caller and block virtio_media_remove() if the host stops responding.

Quoted 13 lines
drivers/media/virtio/virtio_media_driver.c new file +13 -0
+
+	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;

drivers/media/virtio/virtio_media_driver.c line 230

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c new file +10 -0
+		}
+
+		resp_header = sg_virt(sgs[out_sgs]);
+		if (resp_header->status)
+			/* Host returns a positive error code. */
+			return -resp_header->status;
+	}
+
+	return 0;
+}

[Severity: Medium]
Can negating the unsigned __le32 resp_header->status produce a positive return value that virtio_media_send_command() treats as success?

Because resp_header->status is an unsigned 32-bit __le32, -resp_header->status is computed in unsigned arithmetic before converting to int. If a buggy host writes a value with bit 31 set (such as a negative errno like -EINVAL = 0xffffffea), virtio_media_kick_command() returns a positive int, which bypasses the "if (ret < 0)" check in virtio_media_send_command() and causes virtio_media_device_open() to proceed with an invalid resp_open->session_id. Status values between MAX_ERRNO + 1 and 0x80000000 also yield negative values below -MAX_ERRNO that VFS open() does not recognize as errors in IS_ERR().

In addition, resp_header->status, cmd_open->hdr.cmd, resp_open->session_id, cmd_close->hdr.cmd, and cmd_close->session_id are all __le32 protocol fields accessed without le32_to_cpu() / cpu_to_le32(), which triggers Sparse -Wbitwise warnings.

[ ... ]

Quoted 29 lines
drivers/media/virtio/virtio_media_driver.c new file +29 -0
+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);
+

drivers/media/virtio/virtio_media_driver.c line 480

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c new file +10 -0
+	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 a userspace process closes an open /dev/videoX file descriptor during or after virtio_media_remove()?

video_unregister_device() prevents new opens, but existing open file descriptors stay open until userspace closes them, at which point v4l2_release() still invokes virtio_media_device_close(). Meanwhile, virtio_media_remove() destroys vv->commandq via del_vqs() and frees every active session in vv->sessions (without holding vv->sessions_lock across the list walk), and virtio_media_session_free() -> v4l2_fh_del() sets file->private_data = NULL. When the open file descriptor is later closed, virtio_media_device_close() computes session = fh_to_session(file->private_data) (which is NULL, or a freed pointer if virtio_media_device_close() raced with virtio_media_remove()), dereferences session in virtio_media_session_close(), queues a command onto the already deleted vv->commandq, and frees the session a second time.

Quoted 6 lines
include/uapi/linux/virtio_media.h new file +0 -0
new file mode 100644
index 0000000000000..ad05d742165c7
@@ -0,0 +1,118 @@

[ ... ]

Quoted 18 lines
include/uapi/linux/virtio_media.h new file +18 -0
+/**
+ * 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.
+ * @card: name of the device, a NUL-terminated UTF-8 string. It corresponds
+ *        with the card field of the struct v4l2_capability. If all the
+ *        characters of the field are used, it does not need to be
+ *        NUL-terminated.
+ */
+struct virtio_media_config {
+	__le32 device_caps;
+	__le32 device_type;
+	__u8 card[32];
+};

[ ... ]

Quoted 1 line

+#endif // _UAPI__LINUX_VIRTIO_MEDIA_H

[Severity: Low]
In include/uapi/linux/virtio_media.h, the space in "@ device_type:" keeps scripts/kernel-doc from recognizing the member description, and the "//" comment on the #endif line violates the C90 requirement (-std=c90) for exported UAPI headers. In drivers/media/virtio/session.h and drivers/media/virtio/virtio_media.h, scripts/kernel-doc also warns on __dma_from_device_group_begin() and __dma_from_device_group_end() inside the kernel-doc documented structs virtio_media_session and virtio_media.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#3 lore raw

PATCH v12 2/6 media: virtio: Add V4L2 ioctl forwarding infrastructure

In reply to Brian Daniels

From: Alexandre Courbot <[email protected]>

Introduce the scatterlist builder and synchronous V4L2 ioctl forwarding via VIRTIO_MEDIA_CMD_IOCTL.

The scatterlist builder constructs virtio descriptor chains for ioctl commands and responses, mapping 1:1 kernel memory and vmalloc buffers directly into scatterlists when possible while falling back to a per-session shadow buffer otherwise.

Use this infrastructure to implement VIDIOC_QUERYCAP from the virtio configuration space along with fixed-size read, write, and read-write V4L2 ioctls covering format negotiation, frame sizes and intervals, control and menu queries, inputs and outputs, audio, selection, video standards, tuners, and DV timings.

---
 drivers/media/virtio/Makefile              |   2 +-
 drivers/media/virtio/scatterlist_builder.c | 222 ++++++++
 drivers/media/virtio/scatterlist_builder.h |  90 +++
 drivers/media/virtio/session.h             |  28 +-
 drivers/media/virtio/virtio_media.h        |   9 +
 drivers/media/virtio/virtio_media_driver.c |  24 +-
 drivers/media/virtio/virtio_media_ioctls.c | 606 +++++++++++++++++++++
 include/uapi/linux/virtio_media.h          |  43 ++
 8 files changed, 1020 insertions(+), 4 deletions(-)
 create mode 100644 drivers/media/virtio/scatterlist_builder.c
 create mode 100644 drivers/media/virtio/scatterlist_builder.h
 create mode 100644 drivers/media/virtio/virtio_media_ioctls.c
drivers/media/virtio/Makefile +1 -1
index 09d9834da..f1bc8a3ce 100644
@@ -2,6 +2,6 @@
 #
 # Makefile for the virtio-media device driver.
 
-virtio-media-objs := virtio_media_driver.o
+virtio-media-objs := scatterlist_builder.o virtio_media_ioctls.o virtio_media_driver.o
 
 obj-$(CONFIG_MEDIA_VIRTIO) += virtio-media.o
drivers/media/virtio/scatterlist_builder.c new file +222 -0

222 lines not on this page · raw message

drivers/media/virtio/scatterlist_builder.h new file +90 -0

90 lines not on this page · raw message

drivers/media/virtio/session.h +26 -2
index 4ade7fb9c..6fe7ff5ae 100644
@@ -9,17 +9,32 @@
 #ifndef __VIRTIO_MEDIA_SESSION_H
 #define __VIRTIO_MEDIA_SESSION_H
 
+#include <linux/scatterlist.h>
 #include <media/v4l2-fh.h>
 
 #include "uapi/linux/virtio_media.h"
 
+/*
+ * Size of the per-session virtio shadow and event buffers. 16K should be
+ * enough to contain everything we need.
+ */
+#define VIRTIO_SHADOW_BUF_SIZE 0x4000
+
 /**
  * struct virtio_media_session - A session on a virtio_media device.
  * @fh: file handler for the session.
  * @file: file pointer associated with the session's file handler.
  * @id: session ID used to communicate with the device.
- * @cmd: union of session-level commands. A session can have one command
- *       currently running.
+ * @cmd: union of session commands ``close`` and ``ioctl``. A session can have
+ *       one command currently running. The rest of the commands are handled by
+ *       &struct virtio_media.
+ * @resp: union of responses to session commands. A session can wait on one
+ *        command only. The rest of the responses are handled by
+ *        &struct virtio_media.
+ * @shadow_buf: shadow buffer where data to be added to the descriptor chain can
+ *              be staged before being sent to the device.
+ * @command_sgs: SG table gathering descriptors for a given command and its
+ *               response.
  * @list: link into the list of sessions for the device.
  */
 struct virtio_media_session {
@@ -30,9 +45,18 @@ struct virtio_media_session {
 	__dma_from_device_group_begin();
 	union {
 		struct virtio_media_cmd_close close;
+		struct virtio_media_cmd_ioctl ioctl;
 	} cmd;
+
+	union {
+		struct virtio_media_resp_ioctl ioctl;
+	} resp;
 	__dma_from_device_group_end();
 
+	void *shadow_buf;
+
+	struct sg_table command_sgs;
+
 	struct list_head list;
 };
 
drivers/media/virtio/virtio_media.h +9 -0
index 68299377a..a120c1014 100644
@@ -14,6 +14,8 @@
 
 #include "uapi/linux/virtio_media.h"
 
+#define DESC_CHAIN_MAX_LEN SG_MAX_SINGLE_ALLOC
+
 #define VIRTIO_MEDIA_DEFAULT_DRIVER_NAME "virtio-media"
 
 /**
@@ -66,5 +68,12 @@ to_virtio_media(struct video_device *video_dev)
 int virtio_media_send_command(struct virtio_media *vv, struct scatterlist **sgs,
 			      const size_t out_sgs, const size_t in_sgs,
 			      size_t minimum_resp_len, size_t *resp_len);
+
+/* virtio_media_ioctls.c */
+
+long virtio_media_device_ioctl(struct file *file, unsigned int cmd,
+			       unsigned long arg);
+extern const struct v4l2_ioctl_ops virtio_media_ioctl_ops;
+
 #endif // __VIRTIO_MEDIA_H
 
drivers/media/virtio/virtio_media_driver.c +23 -1
index 39c5a38d2..0fe20cf50 100644
@@ -37,10 +37,20 @@ static struct virtio_media_session *
 virtio_media_session_alloc(struct virtio_media *vv, struct file *file)
 {
 	struct virtio_media_session *session;
+	int ret;
 
 	session = kzalloc_obj(*session, GFP_KERNEL);
 	if (!session)
-		return ERR_PTR(-ENOMEM);
+		goto err_session;
+
+	session->shadow_buf = kzalloc(VIRTIO_SHADOW_BUF_SIZE, GFP_KERNEL);
+	if (!session->shadow_buf)
+		goto err_shadow_buf;
+
+	ret = sg_alloc_table(&session->command_sgs, DESC_CHAIN_MAX_LEN,
+			     GFP_KERNEL);
+	if (ret)
+		goto err_payload_sgs;
 
 	// The caller is expected to set the ID once the host assigns a value.
 	session->id = 0;
@@ -50,6 +60,13 @@ virtio_media_session_alloc(struct virtio_media *vv, struct file *file)
 	virtio_media_session_fh_add(session, file);
 
 	return session;
+
+err_payload_sgs:
+	kfree(session->shadow_buf);
+err_shadow_buf:
+	kfree(session);
+err_session:
+	return ERR_PTR(-ENOMEM);
 }
 
 /**
@@ -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);
 }
 
@@ -342,6 +362,7 @@ static const struct v4l2_file_operations virtio_media_fops = {
 	.owner = THIS_MODULE,
 	.open = virtio_media_device_open,
 	.release = virtio_media_device_close,
+	.unlocked_ioctl = virtio_media_device_ioctl,
 };
 
 static void virtio_media_release(struct v4l2_device *v4l2_dev)
@@ -394,6 +415,7 @@ static int virtio_media_probe(struct virtio_device *virtio_dev)
 
 	vd = &vv->video_dev;
 	vd->v4l2_dev = &vv->v4l2_dev;
+	vd->ioctl_ops = &virtio_media_ioctl_ops;
 	vd->fops = &virtio_media_fops;
 	vd->release = video_device_release_empty;
 	strscpy(vd->name, "virtio-media", sizeof(vd->name));
drivers/media/virtio/virtio_media_ioctls.c new file +606 -0

606 lines not on this page · raw message

include/uapi/linux/virtio_media.h +43 -0

47 lines not on this page · raw message

Signature · 1 line
2.56.1.750.gf70dc682cf-goog
#4 lore raw

Re: [PATCH v12 2/6] media: virtio: Add V4L2 ioctl forwarding infrastructure

Thank you for your contribution! Sashiko AI review found 5 potential issues to consider: - [High] media: virtio: stack buffers mapped for DMA in scatterlist_builder_add_data() - [High] media…

Thank you for your contribution! Sashiko AI review found 5 potential issues to consider:
- [High] media: virtio: stack buffers mapped for DMA in scatterlist_builder_add_data()
- [High] media: virtio: V4L2 core and remove race bypass in virtio_media_device_ioctl()
- [Medium] media: virtio: const discard in scatterlist_builder_retrieve_data() on ppc64le
- [Medium] media: virtio: missing NUL-termination of card in virtio_media_querycap()
- [Medium] media: virtio: uninitialized stack payload in virtio_media_g_input()
--

commit 2bb3f66c322d534b371d016a0dfc9daa0878344f
Author: Alexandre Courbot <[email protected]>

media: virtio: Add V4L2 ioctl forwarding infrastructure

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

Quoted 6 lines
drivers/media/virtio/scatterlist_builder.c new file +0 -0
new file mode 100644
index 0000000000000..ae8ffee82fa6e
@@ -0,0 +1,222 @@

[ ... ]

Quoted 16 lines
drivers/media/virtio/scatterlist_builder.c new file +16 -0
+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.

drivers/media/virtio/scatterlist_builder.c line 81

Quoted 10 lines
drivers/media/virtio/scatterlist_builder.c new file +10 -0
+		 */
+		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 into scatterlists for DMA instead of bouncing them through the shadow buffer?

Most ioctl payloads passed here live on the kernel stack: video_usercopy() uses a 128-byte stack buffer (sbuf) for small ioctls, and handlers such as virtio_media_g_input(), virtio_media_s_std(), and virtio_media_device_ioctl() pass addresses of local stack variables. Because neither branch checks !object_is_on_stack(data), stack buffers match virt_addr_valid() when CONFIG_VMAP_STACK=n and is_vmalloc_addr() when CONFIG_VMAP_STACK=y. Mapping stack memory into virtio scatterlists violates kernel DMA rules (triggering CONFIG_DMA_API_DEBUG warnings when the virtqueue uses the DMA API) and risks corrupting adjacent stack frames sharing a cache line on non-coherent DMA platforms while the caller sleeps in wait_event().

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

[ ... ]

drivers/media/virtio/scatterlist_builder.c line 173

Quoted 13 lines
drivers/media/virtio/scatterlist_builder.c new file +13 -0
+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;

[Severity: Medium]
Does assigning pfn_to_kaddr() to void *kaddr fail to build on 64-bit little-endian PowerPC with CONFIG_WERROR=y? On PowerPC, pfn_to_kaddr() returns const void *, so this assignment triggers -Wdiscarded-qualifiers. Using sg_virt(sg) avoids the qualifier mismatch.

Quoted 6 lines
drivers/media/virtio/virtio_media_ioctls.c new file +0 -0
new file mode 100644
index 0000000000000..e92032bce7dbe
@@ -0,0 +1,606 @@

[ ... ]

Quoted 6 lines
drivers/media/virtio/virtio_media_ioctls.c new file +6 -0
+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);
+

drivers/media/virtio/virtio_media_ioctls.c line 328

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c new file +10 -0
+	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() return a non-NUL-terminated cap->card string to userspace?

In include/uapi/linux/virtio_media.h, struct virtio_media_config documents that its 32-byte card field does not need to be NUL-terminated when all characters are used, whereas V4L2 requires v4l2_capability.card to always be NUL-terminated. Ensuring cap->card[sizeof(cap->card) - 1] = '\0' (and using offsetof(struct virtio_media_config, card) instead of the hardcoded
8) would prevent unterminated strings from reaching userspace.

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c new file +10 -0
+
+/*
+ * 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;
+

drivers/media/virtio/virtio_media_ioctls.c line 348

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c new file +10 -0
+	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]
Can virtio_media_g_input() and virtio_media_g_output() copy uninitialized kernel stack memory into the DMA shadow buffer or back to userspace?

Both functions leave their local u32 variable uninitialized before calling virtio_media_send_r_ioctl() -> scatterlist_builder_add_data(). When the shadow buffer path is used, scatterlist_builder_add_data() unconditionally runs memcpy(shadow_buffer, data, len) even for _IOR response buffers, copying the uninitialized stack value into session->shadow_buf, and if the host does not overwrite the buffer (or returns a status with bit 31 set, which virtio_media_kick_command() negates as unsigned __le32 into a positive value that virtio_media_send_command() treats as success), that uninitialized value is returned to userspace.

[ ... ]

Quoted 53 lines
drivers/media/virtio/virtio_media_ioctls.c new file +53 -0
+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;

drivers/media/virtio/virtio_media_ioctls.c line 606

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c new file +10 -0
+		break;
+	default:
+		ret = video_ioctl2(file, cmd, arg);
+		break;
+	}
+
+	mutex_unlock(&vv->vlock);
+
+	return ret;
+}

[Severity: High]
Can intercepting VIDIOC_S_STD, VIDIOC_ENUMSTD, and VIDIOC_QUERYSTD before video_ioctl2() cause a use-after-free or NULL pointer dereference when racing with virtio_media_remove()?

CPU0 CPU1
v4l2_ioctl()
video_is_registered(vdev) -> true
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()
      virtio_media_send_r_ioctl()     <-- NULL fh->vdev / UAF on session
                                          and deleted commandq

Unlike __video_do_ioctl(), which re-checks video_is_registered() after taking the lock, these manual cases proceed directly into the handlers after virtio_media_remove() has deleted vv->commandq and freed the sessions.

Bypassing video_ioctl2() here also skips 32-bit compat translation for VIDIOC_ENUMSTD32 (so 32-bit compat callers fall through to default and fail because video_dev->tvnorms is 0), skips is_valid_ioctl() and v4l2_prio_check() on VIDIOC_S_STD, and does not zero the output fields of struct v4l2_standard after index on VIDIOC_ENUMSTD.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
#5 lore raw

PATCH v12 3/6 media: virtio: Add extended controls support

In reply to Brian Daniels

From: Alexandre Courbot <[email protected]>

Add support for VIDIOC_G_EXT_CTRLS, VIDIOC_S_EXT_CTRLS, and VIDIOC_TRY_EXT_CTRLS.

Extended controls carry an auxiliary array of struct v4l2_ext_control entries and may reference userspace payload buffers. Pin userspace control payloads using vb2_create_framevec() for the duration of the virtio command and pass their physical memory segments to the host as an array of struct virtio_media_sg_entry descriptors in the session shadow buffer.

---
 drivers/media/virtio/scatterlist_builder.c | 302 +++++++++++++++++++++
 drivers/media/virtio/scatterlist_builder.h |  27 ++
 drivers/media/virtio/virtio_media_ioctls.c | 164 +++++++++++
 include/uapi/linux/virtio_media.h          |  13 +
 4 files changed, 506 insertions(+)
drivers/media/virtio/scatterlist_builder.c +302 -0
index ae8ffee82..631c7b13c 100644
@@ -220,3 +220,305 @@ int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder,
 	return scatterlist_builder_add_data(builder, resp_ioctl,
 					    sizeof(*resp_ioctl));
 }
+
+/**
+ * __scatterlist_builder_add_userptr() - Add user pages to @builder.
+ * @builder: builder to use.
+ * @userptr: pointer to userspace memory that we want to add.
+ * @length: length of the data to add.
+ * @sg_list: output parameter. Upon success, points to the area of the shadow
+ *           buffer containing the array of SG entries to be added to the
+ *           descriptor chain.
+ * @nents: output parameter. Upon success, contains the number of entries
+ *         pointed to by @sg_list.
+ *
+ * Data referenced by userspace pointers can be potentially large and very
+ * scattered, which could overwhelm the descriptor chain if added as-is. For
+ * these, we instead build an array of &struct virtio_media_sg_entry in the
+ * shadow buffer and reference it using a single descriptor.
+ *
+ * This function is a helper to perform that. Callers should then add the
+ * descriptor to the chain properly.
+ *
+ * Returns %-EFAULT if @userptr is not a valid user address, which is a case the
+ * driver should consider as "normal" operation. All other failures signal a
+ * problem with the driver.
+ */
+static int
+__scatterlist_builder_add_userptr(struct scatterlist_builder *builder,
+				  unsigned long userptr, unsigned long length,
+				  struct virtio_media_sg_entry **sg_list,
+				  int *nents)
+{
+	struct sg_table sg_table = {};
+	struct frame_vector *framevec;
+	struct scatterlist *sg_iter;
+	struct page **pages;
+	const unsigned int offset = userptr & ~PAGE_MASK;
+	unsigned int pages_count;
+	size_t entries_size;
+	size_t initial_cur_framevec = builder->cur_framevec;
+	int i;
+	int ret;
+
+	if (builder->cur_framevec >= builder->num_framevecs) {
+		pr_err("Ran out of framevecs (%zu/%zu)", builder->cur_framevec,
+		       builder->num_framevecs);
+		ret = -ENOMEM;
+	}
+
+	framevec = vb2_create_framevec(userptr, length, true);
+	if (IS_ERR(framevec)) {
+		if (PTR_ERR(framevec) != -EFAULT) {
+			pr_warn("error %ld creating frame vector for userptr 0x%lx, length 0x%lx\n",
+				PTR_ERR(framevec), userptr, length);
+		} else {
+			/* -EINVAL is expected in case of invalid userptr. */
+			framevec = ERR_PTR(-EINVAL);
+		}
+		return PTR_ERR(framevec);
+	}
+
+	pages = frame_vector_pages(framevec);
+	if (IS_ERR(pages)) {
+		pr_warn("error getting vector pages\n");
+		ret = PTR_ERR(pages);
+		goto free_framevec;
+	}
+	pages_count = frame_vector_count(framevec);
+	ret = sg_alloc_table_from_pages(&sg_table, pages, pages_count, offset,
+					length, 0);
+	if (ret) {
+		pr_warn("error creating sg table\n");
+		goto free_framevec;
+	}
+
+	/* Allocate our actual SG in the shadow buffer. */
+	*nents = sg_nents(sg_table.sgl);
+	entries_size = sizeof(**sg_list) * *nents;
+	if (builder->shadow_buffer_pos + entries_size >
+	    builder->shadow_buffer_size) {
+		ret = -ENOMEM;
+		goto free_sg;
+	}
+
+	*sg_list = builder->shadow_buffer + builder->shadow_buffer_pos;
+	builder->shadow_buffer_pos += entries_size;
+
+	for_each_sgtable_sg(&sg_table, sg_iter, i) {
+		struct virtio_media_sg_entry *sg_entry = &(*sg_list)[i];
+
+		sg_entry->start = sg_phys(sg_iter);
+		sg_entry->len = sg_iter->length;
+		sg_entry->__reserved = 0;
+	}
+
+	builder->framevecs[builder->cur_framevec++] = framevec;
+
+free_sg:
+	sg_free_table(&sg_table);
+free_framevec:
+	// Only destroy the framevec if we didn't save it
+	if (builder->cur_framevec == initial_cur_framevec && framevec)
+		vb2_destroy_framevec(framevec, false);
+	return ret;
+}
+
+/**
+ * scatterlist_builder_add_userptr() - Add a user-memory buffer using an array
+ *                                     of &struct virtio_media_sg_entry.
+ * @builder: builder to use.
+ * @userptr: pointer to userspace memory that we want to add.
+ * @length: length of the data to add.
+ *
+ * Upon success, an array of &struct virtio_media_sg_entry referencing
+ * @userptr has been built into the shadow buffer, and that array added to the
+ * descriptor chain.
+ */
+static int scatterlist_builder_add_userptr(struct scatterlist_builder *builder,
+					   unsigned long userptr,
+					   unsigned long length)
+{
+	int ret;
+	int nents;
+	struct virtio_media_sg_entry *sg_list;
+
+	ret = __scatterlist_builder_add_userptr(builder, userptr, length,
+						&sg_list, &nents);
+	if (ret)
+		return ret;
+
+	ret = scatterlist_builder_add_data(builder, sg_list,
+					   sizeof(*sg_list) * nents);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+/**
+ * scatterlist_builder_add_ext_ctrls() - Add a &struct v4l2_ext_controls and its
+ *                                       controls to @builder.
+ * @builder: builder to use.
+ * @ctrls: &struct v4l2_ext_controls to add.
+ *
+ * Add @ctrls and its array of &struct v4l2_ext_control to the descriptor
+ * chain.
+ */
+int scatterlist_builder_add_ext_ctrls(struct scatterlist_builder *builder,
+				      struct v4l2_ext_controls *ctrls)
+{
+	int ret;
+
+	/* v4l2_ext_controls */
+	ret = scatterlist_builder_add_data(builder, ctrls, sizeof(*ctrls));
+	if (ret)
+		return ret;
+
+	if (ctrls->count > 0) {
+		/* array of v4l2_controls */
+		ret = scatterlist_builder_add_data(builder, ctrls->controls,
+						   sizeof(ctrls->controls[0]) *
+							   ctrls->count);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+/**
+ * scatterlist_builder_allocate_framevecs() - Allocate the pointers to store
+ *                                            framevecs during a request.
+ * @builder: builder to use.
+ * @ctrls: &struct v4l2_ext_controls from which we determine how many framevecs
+ *         are needed
+ *
+ * The framevecs are used to pin the user pages during the request. Once the
+ * request is completed, the allocated framevecs and pointers should be freed
+ * with scatterlist_builder_free_framevecs().
+ */
+int
+scatterlist_builder_allocate_framevecs(struct scatterlist_builder *builder,
+				       struct v4l2_ext_controls *ctrls)
+{
+	int i;
+
+	builder->cur_framevec = 0;
+
+	/* Count the pointers to user memory in individual controls */
+	for (i = 0; i < ctrls->count; i++) {
+		struct v4l2_ext_control *ctrl = &ctrls->controls[i];
+
+		if (ctrl->size > 0)
+			builder->num_framevecs += 1;
+	}
+
+	if (builder->num_framevecs > 0) {
+		builder->framevecs = kzalloc_objs(struct frame_vector*,
+						  builder->num_framevecs);
+		if (!builder->framevecs) {
+			builder->num_framevecs = 0;
+			return -ENOMEM;
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * scatterlist_builder_free_framevecs() - Free the framevecs used during a
+ *                                        request.
+ * @builder: builder to use.
+ *
+ * Frees the framevecs allocated in scatterlist_builder_allocate_framevecs().
+ */
+void
+scatterlist_builder_free_framevecs(struct scatterlist_builder *builder)
+{
+	if (builder->cur_framevec && builder->framevecs) {
+		struct frame_vector *vec;
+
+		while (builder->cur_framevec--) {
+			vec = builder->framevecs[builder->cur_framevec];
+			vb2_destroy_framevec(vec, true);
+		}
+
+		kfree(builder->framevecs);
+	}
+
+	builder->framevecs = NULL;
+	builder->num_framevecs = 0;
+	builder->cur_framevec = 0;
+}
+
+/**
+ * scatterlist_builder_add_ext_ctrls_userptrs() - Add the userspace payloads of
+ *                                                a &struct v4l2_ext_controls
+ *                                                to the descriptor chain.
+ * @builder: builder to use.
+ * @ctrls: &struct v4l2_ext_controls from which we want to add the
+ *         userspace payload.
+ *
+ * Add the userspace payloads of @ctrls to the descriptor chain. This is split
+ * out of scatterlist_builder_add_ext_ctrls() because we only want to add
+ * these to the device-readable part of the descriptor chain.
+ */
+int
+scatterlist_builder_add_ext_ctrls_userptrs(struct scatterlist_builder *builder,
+					   struct v4l2_ext_controls *ctrls)
+{
+	int i;
+	int ret;
+
+	for (i = 0; i < ctrls->count; i++) {
+		struct v4l2_ext_control *ctrl = &ctrls->controls[i];
+
+		if (ctrl->size > 0) {
+			unsigned long uptr = (unsigned long)ctrl->ptr;
+
+			ret = scatterlist_builder_add_userptr(builder, uptr,
+							      ctrl->size);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * scatterlist_builder_retrieve_ext_ctrls() - Retrieve controls written by the
+ *                                            device on the shadow buffer,
+ *                                            if needed.
+ * @builder: builder to use.
+ * @sg_index: index of the first SG entry of the controls in the builder's
+ *            descriptor chain.
+ * @ctrls: &struct v4l2_ext_controls to copy shadow buffer data into.
+ *
+ * If the shadow buffer is pointed to by @sg_index, copy its content back into
+ * @ctrls.
+ */
+int scatterlist_builder_retrieve_ext_ctrls(struct scatterlist_builder *builder,
+					   size_t sg_index,
+					   struct v4l2_ext_controls *ctrls)
+{
+	struct v4l2_ext_control *controls_backup = ctrls->controls;
+	int ret;
+
+	ret = scatterlist_builder_retrieve_data(builder, sg_index++, ctrls);
+
+	if (ret)
+		return ret;
+
+	ctrls->controls = controls_backup;
+
+	if (ctrls->count > 0 && ctrls->controls) {
+		ret = scatterlist_builder_retrieve_data(builder, sg_index++,
+							ctrls->controls);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
drivers/media/virtio/scatterlist_builder.h +27 -0
index 044ea409a..bced1e030 100644
@@ -25,6 +25,11 @@
  * @sgs: descriptor chain to eventually pass to virtio functions.
  * @num_sgs: total number of entries in @sgs.
  * @cur_sg: next entry in @sgs to be used.
+ * @framevecs: Array of *struct frame_vector that is allocated to keep user
+ *             pages pinned until after a response is received. It is allocated
+ *             in scatterlist_builder_add_ext_ctrls_userptrs() and freed in
+ *             scatterlist_builder_retrieve_ext_ctrls().
+ * @cur_framevec: next entry in @framevecs to be used.
  *
  * Virtio passes data from the driver to the device (through e.g.
  * virtqueue_add_sgs()) via a scatterlist that the device interprets as a
@@ -69,6 +74,10 @@ struct scatterlist_builder {
 	struct scatterlist **sgs;
 	size_t num_sgs;
 	size_t cur_sg;
+
+	struct frame_vector **framevecs;
+	size_t num_framevecs;
+	size_t cur_framevec;
 };
 
 int scatterlist_builder_add_descriptor(struct scatterlist_builder *builder,
@@ -87,4 +96,22 @@ int scatterlist_builder_add_ioctl_cmd(struct scatterlist_builder *builder,
 int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder,
 				       struct virtio_media_session *session);
 
+int scatterlist_builder_add_ext_ctrls(struct scatterlist_builder *builder,
+				      struct v4l2_ext_controls *ctrls);
+
+int
+scatterlist_builder_allocate_framevecs(struct scatterlist_builder *builder,
+				       struct v4l2_ext_controls *ctrls);
+
+void
+scatterlist_builder_free_framevecs(struct scatterlist_builder *builder);
+
+int
+scatterlist_builder_add_ext_ctrls_userptrs(struct scatterlist_builder *builder,
+					   struct v4l2_ext_controls *ctrls);
+
+int scatterlist_builder_retrieve_ext_ctrls(struct scatterlist_builder *builder,
+					   size_t sg_index,
+					   struct v4l2_ext_controls *ctrls);
+
 #endif // __VIRTIO_MEDIA_SCATTERLIST_BUILDER_H
drivers/media/virtio/virtio_media_ioctls.c +164 -0

200 lines not on this page · raw message

include/uapi/linux/virtio_media.h +13 -0
index c1e68d47c..f117b97fc 100644
@@ -158,4 +158,17 @@ struct virtio_media_resp_ioctl {
 	struct virtio_media_resp_header hdr;
 };
 
+/**
+ * struct virtio_media_sg_entry - Description of part of a scattered guest
+ *                                memory.
+ * @start: start guest address of the memory segment.
+ * @len: length of this memory segment.
+ * @__reserved: must be set to zero by the driver.
+ */
+struct virtio_media_sg_entry {
+	__le64 start;
+	__le32 len;
+	__le32 __reserved;
+};
+
 #endif // _UAPI__LINUX_VIRTIO_MEDIA_H
Signature · 1 line
2.56.1.750.gf70dc682cf-goog
#6 lore raw

Re: [PATCH v12 3/6] media: virtio: Add extended controls support

Thank you for your contribution! Sashiko AI review found 10 potential issues to consider: - [High] media: virtio: two-argument calls to vb2_destroy_framevec() break build - [High] media: virtio…

Thank you for your contribution! Sashiko AI review found 10 potential issues to consider:
- [High] media: virtio: two-argument calls to vb2_destroy_framevec() break build
- [High] media: virtio: framevecs array leak in scatterlist_builder_free_framevecs()
- [High] media: virtio: framevec and pinned page leaks on ext_ctrls error paths
- [High] media: virtio: stack buffers mapped for DMA in scatterlist_builder_add_data()
- [Medium] media: virtio: gfp_mask = 0 passed to sg_alloc_table_from_pages()
- [Medium] media: virtio: ctrls->count checked before shadow copy and not restored
- [Medium] media: virtio: sgs index passed as desc_index in ext_ctrls response
- [Medium] media: virtio: wrong errno in __scatterlist_builder_add_userptr()
- [Low] media: virtio: missing @num_framevecs kernel-doc in scatterlist_builder
- [Low] media: virtio: missing endian conversions for virtio_media_sg_entry
--

commit 27e06a79a3e678981f79713cac25fd1f43109084
Author: Alexandre Courbot <[email protected]>

media: virtio: Add extended controls support

This commit adds support for the VIDIOC_G_EXT_CTRLS, VIDIOC_S_EXT_CTRLS, and VIDIOC_TRY_EXT_CTRLS ioctls by pinning userspace control payloads with frame vectors and passing their physical segments to the host via the session shadow buffer.

Quoted 56 lines
drivers/media/virtio/scatterlist_builder.c +48 -0
index ae8ffee82fa6e..631c7b13c438c 100644
@@ -220,3 +220,305 @@ int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder,
 	return scatterlist_builder_add_data(builder, resp_ioctl,
 					    sizeof(*resp_ioctl));
 }
+
+/**
+ * __scatterlist_builder_add_userptr() - Add user pages to @builder.
+ * @builder: builder to use.
+ * @userptr: pointer to userspace memory that we want to add.
+ * @length: length of the data to add.
+ * @sg_list: output parameter. Upon success, points to the area of the shadow
+ *           buffer containing the array of SG entries to be added to the
+ *           descriptor chain.
+ * @nents: output parameter. Upon success, contains the number of entries
+ *         pointed to by @sg_list.
+ *
+ * Data referenced by userspace pointers can be potentially large and very
+ * scattered, which could overwhelm the descriptor chain if added as-is. For
+ * these, we instead build an array of &struct virtio_media_sg_entry in the
+ * shadow buffer and reference it using a single descriptor.
+ *
+ * This function is a helper to perform that. Callers should then add the
+ * descriptor to the chain properly.
+ *
+ * Returns %-EFAULT if @userptr is not a valid user address, which is a case the
+ * driver should consider as "normal" operation. All other failures signal a
+ * problem with the driver.
+ */
+static int
+__scatterlist_builder_add_userptr(struct scatterlist_builder *builder,
+				  unsigned long userptr, unsigned long length,
+				  struct virtio_media_sg_entry **sg_list,
+				  int *nents)
+{
+	struct sg_table sg_table = {};
+	struct frame_vector *framevec;
+	struct scatterlist *sg_iter;
+	struct page **pages;
+	const unsigned int offset = userptr & ~PAGE_MASK;
+	unsigned int pages_count;
+	size_t entries_size;
+	size_t initial_cur_framevec = builder->cur_framevec;
+	int i;
+	int ret;
+
+	if (builder->cur_framevec >= builder->num_framevecs) {
+		pr_err("Ran out of framevecs (%zu/%zu)", builder->cur_framevec,
+		       builder->num_framevecs);
+		ret = -ENOMEM;
+	}
+
+	framevec = vb2_create_framevec(userptr, length, true);

drivers/media/virtio/scatterlist_builder.c int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder, · line 280

Quoted 10 lines
drivers/media/virtio/scatterlist_builder.c +10 -0
+	if (IS_ERR(framevec)) {
+		if (PTR_ERR(framevec) != -EFAULT) {
+			pr_warn("error %ld creating frame vector for userptr 0x%lx, length 0x%lx\n",
+				PTR_ERR(framevec), userptr, length);
+		} else {
+			/* -EINVAL is expected in case of invalid userptr. */
+			framevec = ERR_PTR(-EINVAL);
+		}
+		return PTR_ERR(framevec);
+	}

[Severity: Medium]
Should this preserve -EFAULT instead of converting it to -EINVAL?

For extended controls with userspace payload pointers ( unlike V4L2_MEMORY_USERPTR buffer queueing), the V4L2 UAPI and the kernel-doc above both specify -EFAULT when a control's userspace address is invalid.

drivers/media/virtio/scatterlist_builder.c int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder, · line 290

Quoted 10 lines
drivers/media/virtio/scatterlist_builder.c +10 -0
+
+	pages = frame_vector_pages(framevec);
+	if (IS_ERR(pages)) {
+		pr_warn("error getting vector pages\n");
+		ret = PTR_ERR(pages);
+		goto free_framevec;
+	}
+	pages_count = frame_vector_count(framevec);
+	ret = sg_alloc_table_from_pages(&sg_table, pages, pages_count, offset,
+					length, 0);

[Severity: Medium]
Should the gfp_mask argument to sg_alloc_table_from_pages() be GFP_KERNEL instead of 0? Passing 0 clears all reclaim flags, so scatterlist allocation in sleepable ioctl context cannot reclaim memory under pressure.

Quoted 14 lines
drivers/media/virtio/scatterlist_builder.c +14 -0
+	if (ret) {
+		pr_warn("error creating sg table\n");
+		goto free_framevec;
+	}
+
+	/* Allocate our actual SG in the shadow buffer. */
+	*nents = sg_nents(sg_table.sgl);
+	entries_size = sizeof(**sg_list) * *nents;
+	if (builder->shadow_buffer_pos + entries_size >
+	    builder->shadow_buffer_size) {
+		ret = -ENOMEM;
+		goto free_sg;
+	}
+

drivers/media/virtio/scatterlist_builder.c int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder, · line 314

Quoted 10 lines
drivers/media/virtio/scatterlist_builder.c +10 -0
+	*sg_list = builder->shadow_buffer + builder->shadow_buffer_pos;
+	builder->shadow_buffer_pos += entries_size;
+
+	for_each_sgtable_sg(&sg_table, sg_iter, i) {
+		struct virtio_media_sg_entry *sg_entry = &(*sg_list)[i];
+
+		sg_entry->start = sg_phys(sg_iter);
+		sg_entry->len = sg_iter->length;
+		sg_entry->__reserved = 0;
+	}

[Severity: Low]
struct virtio_media_sg_entry declares start as __le64 and len as __le32. Should these assignments use cpu_to_le64() and cpu_to_le32() to avoid Sparse endianness warnings?

drivers/media/virtio/scatterlist_builder.c int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder, · line 325

Quoted 11 lines
drivers/media/virtio/scatterlist_builder.c +11 -0
+
+	builder->framevecs[builder->cur_framevec++] = framevec;
+
+free_sg:
+	sg_free_table(&sg_table);
+free_framevec:
+	// Only destroy the framevec if we didn't save it
+	if (builder->cur_framevec == initial_cur_framevec && framevec)
+		vb2_destroy_framevec(framevec, false);
+	return ret;
+}

[Severity: High]
Does calling vb2_destroy_framevec() with two arguments break the build?

In include/media/videobuf2-memops.h, vb2_destroy_framevec() takes only a single struct frame_vector * argument:

  void vb2_destroy_framevec(struct frame_vector *vec);

Because vb2_destroy_framevec() does not mark pages dirty, scatterlist_builder_free_framevecs() also leaves device-modified user pages clean when unpinning them unless it iterates over frame_vector_pages(vec) and calls set_page_dirty_lock() before destroying the frame vector.

[ ... ]

Quoted 11 lines
drivers/media/virtio/scatterlist_builder.c +11 -0
+int scatterlist_builder_add_ext_ctrls(struct scatterlist_builder *builder,
+				      struct v4l2_ext_controls *ctrls)
+{
+	int ret;
+
+	/* v4l2_ext_controls */
+	ret = scatterlist_builder_add_data(builder, ctrls, sizeof(*ctrls));
+	if (ret)
+		return ret;
+
+	if (ctrls->count > 0) {

drivers/media/virtio/scatterlist_builder.c int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder, · line 388

Quoted 10 lines
drivers/media/virtio/scatterlist_builder.c +10 -0
+		/* array of v4l2_controls */
+		ret = scatterlist_builder_add_data(builder, ctrls->controls,
+						   sizeof(ctrls->controls[0]) *
+							   ctrls->count);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}

[Severity: High]
Does passing ctrls to scatterlist_builder_add_data() map kernel stack memory directly for DMA?

video_usercopy() places struct v4l2_ext_controls in its stack buffer sbuf (and v4l_g_ctrl() / v4l_s_ctrl() allocate both struct v4l2_ext_controls and struct v4l2_ext_control on the stack). When always_use_shadow_buffer is false, scatterlist_builder_add_data() checks virt_addr_valid() or is_vmalloc_addr() without checking !object_is_on_stack(data), mapping stack pages directly into the request and device-writable response scatterlists instead of copying through the shadow buffer.

[ ... ]

Quoted 8 lines
drivers/media/virtio/scatterlist_builder.c +8 -0
+void
+scatterlist_builder_free_framevecs(struct scatterlist_builder *builder)
+{
+	if (builder->cur_framevec && builder->framevecs) {
+		struct frame_vector *vec;
+
+		while (builder->cur_framevec--) {
+			vec = builder->framevecs[builder->cur_framevec];

drivers/media/virtio/scatterlist_builder.c int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder, · line 453

Quoted 10 lines
drivers/media/virtio/scatterlist_builder.c +10 -0
+			vb2_destroy_framevec(vec, true);
+		}
+
+		kfree(builder->framevecs);
+	}
+
+	builder->framevecs = NULL;
+	builder->num_framevecs = 0;
+	builder->cur_framevec = 0;
+}

[Severity: High]
Does scatterlist_builder_free_framevecs() leak builder->framevecs when builder->cur_framevec is 0?

scatterlist_builder_allocate_framevecs() allocates builder->framevecs whenever any control has ctrl->size > 0. If an error occurs before the first framevec is pinned (for example, vb2_create_framevec() fails on the first control's userptr), builder->cur_framevec is still 0, so kfree(builder->framevecs) is skipped before builder->framevecs is set to NULL.

drivers/media/virtio/scatterlist_builder.h line 32

Quoted 13 lines
drivers/media/virtio/scatterlist_builder.h +5 -0
index 044ea409acdb1..bced1e0301402 100644
@@ -25,6 +25,11 @@
  * @sgs: descriptor chain to eventually pass to virtio functions.
  * @num_sgs: total number of entries in @sgs.
  * @cur_sg: next entry in @sgs to be used.
+ * @framevecs: Array of *struct frame_vector that is allocated to keep user
+ *             pages pinned until after a response is received. It is allocated
+ *             in scatterlist_builder_add_ext_ctrls_userptrs() and freed in
+ *             scatterlist_builder_retrieve_ext_ctrls().
+ * @cur_framevec: next entry in @framevecs to be used.

[Severity: Low]
This kernel-doc comment is missing an entry for @num_framevecs (which triggers a W=1 kernel-doc warning), and @framevecs is allocated in scatterlist_builder_allocate_framevecs() and freed in scatterlist_builder_free_framevecs().

Quoted 74 lines
drivers/media/virtio/virtio_media_ioctls.c +66 -0
index e92032bce7dbe..d0ea743e793bd 100644
@@ -215,6 +221,130 @@ static int virtio_media_send_wr_ioctl(struct v4l2_fh *fh, u32 ioctl,
 	return 0;
 }
 
+/**
+ * virtio_media_send_ext_controls_ioctl() - Send an ioctl taking extended
+ * controls as parameters to the device.
+ * @fh: file handler of the session doing the ioctl.
+ * @ioctl: ``VIDIOC_*`` ioctl code.
+ * @ctrls: &struct v4l2_ext_controls to be sent as the ioctl payload.
+ *
+ * Queues an ioctl that sends a &struct v4l2_ext_controls to the host and
+ * receives an updated version.
+ *
+ * &struct v4l2_ext_controls has a pointer to an array of
+ * &struct v4l2_ext_control, and also potentially pointers to user-space memory
+ * that we need to map properly, hence the dedicated function.
+ */
+static int virtio_media_send_ext_controls_ioctl(struct v4l2_fh *fh, u32 ioctl,
+						struct v4l2_ext_controls *ctrls)
+{
+	struct video_device *video_dev = fh->vdev;
+	struct virtio_media *vv = to_virtio_media(video_dev);
+	struct virtio_media_session *session = fh_to_session(fh);
+	size_t num_cmd_sgs;
+	size_t end_ctrls_sg;
+	struct v4l2_ext_control *controls_backup = ctrls->controls;
+	const u32 num_ctrls = ctrls->count;
+	struct scatterlist *sgs[64];
+	struct scatterlist_builder builder = {
+		.descs = session->command_sgs.sgl,
+		.num_descs = DESC_CHAIN_MAX_LEN,
+		.cur_desc = 0,
+		.shadow_buffer = session->shadow_buf,
+		.shadow_buffer_size = VIRTIO_SHADOW_BUF_SIZE,
+		.shadow_buffer_pos = 0,
+		.sgs = sgs,
+		.num_sgs = ARRAY_SIZE(sgs),
+		.cur_sg = 0,
+		.framevecs = NULL,
+		.cur_framevec = 0,
+	};
+	size_t resp_len = 0;
+	int i;
+
+	int ret = scatterlist_builder_allocate_framevecs(&builder, ctrls);
+
+	if (ret)
+		return ret;
+
+	/* Command descriptor */
+	ret = scatterlist_builder_add_ioctl_cmd(&builder, session, ioctl);
+
+	if (ret)
+		goto free_framevecs;
+
+	/* v4l2_controls */
+	ret = scatterlist_builder_add_ext_ctrls(&builder, ctrls);
+	if (ret)
+		goto free_framevecs;
+
+	end_ctrls_sg = builder.cur_sg;
+
+	ret = scatterlist_builder_add_ext_ctrls_userptrs(&builder, ctrls);
+	if (ret)
+		goto free_framevecs;
+
+	num_cmd_sgs = builder.cur_sg;
+
+	/* Response descriptor */

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_send_wr_ioctl(struct v4l2_fh *fh, u32 ioctl, · line 299

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+	ret = scatterlist_builder_add_ioctl_resp(&builder, session);
+	if (ret)
+		goto free_framevecs;
+
+	/* Response payload (same as input but without userptrs) */
+	for (i = 1; i < end_ctrls_sg; i++) {
+		ret = scatterlist_builder_add_descriptor(&builder, i);
+		if (ret < 0)
+			goto free_framevecs;
+	}

[Severity: Medium]
Can passing the builder.sgs[] index i as desc_index to scatterlist_builder_add_descriptor() point the response chain at the wrong descriptors?

When a vmalloc-backed payload (such as a large ctrls->controls array allocated via kvmalloc() in video_usercopy()) spans non-contiguous pages, scatterlist_builder_add_data() advances builder->cur_desc for each page segment while adding only one entry to builder->sgs[]. Because end_ctrls_sg is taken from builder.cur_sg, indexing builder->descs[i] does not match builder->sgs[i] once any earlier entry uses more than one descriptor.

Quoted 29 lines
drivers/media/virtio/virtio_media_ioctls.c +29 -0
+
+	ret = virtio_media_send_command(vv, builder.sgs, num_cmd_sgs,
+					builder.cur_sg - num_cmd_sgs,
+					sizeof(struct virtio_media_resp_ioctl) +
+					sizeof(*ctrls),
+					&resp_len);
+
+	/* Just in case the host touched these. */
+	ctrls->controls = controls_backup;
+	if (ctrls->count != num_ctrls) {
+		v4l2_err(&vv->v4l2_dev,
+			 "device returned a number of controls different than the one submitted\n");
+	}
+	if (ctrls->count > num_ctrls)
+		return -ENOSPC;
+	if (ret < 0) {
+		/*
+		 * Even if we have received an error, we may need to read our
+		 * payloadback.
+		 */
+		if (resp_len >= sizeof(struct virtio_media_resp_ioctl) +
+		    sizeof(*ctrls)) {
+			/*
+			 * Deliberately ignore the error here as we want to
+			 * return the previous one.
+			 */
+			scatterlist_builder_retrieve_ext_ctrls(&builder,
+							       num_cmd_sgs + 1,
+							       ctrls);

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_send_wr_ioctl(struct v4l2_fh *fh, u32 ioctl, · line 338

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+		}
+
+		goto free_framevecs;
+	}
+
+	resp_len -= sizeof(struct virtio_media_resp_ioctl);
+
+	/* Make sure that the reply's length covers our v4l2_ext_controls */
+	if (resp_len < sizeof(*ctrls))
+		return -EINVAL;

[Severity: High]
Do the early returns on ctrls->count > num_ctrls and
resp_len < sizeof(*ctrls) leak builder.framevecs and leave userspace pages permanently pinned?

Both paths return directly instead of jumping to free_framevecs. In addition, in __scatterlist_builder_add_userptr(), the bounds check if (builder->cur_framevec >= builder->num_framevecs) sets ret = -ENOMEM without returning, falling through to pin the pages and write past the end of builder->framevecs.

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_send_wr_ioctl(struct v4l2_fh *fh, u32 ioctl, · line 341

Quoted 3 lines
drivers/media/virtio/virtio_media_ioctls.c +3 -0
+
+	ret = scatterlist_builder_retrieve_ext_ctrls(&builder, num_cmd_sgs + 1,
+						     ctrls);

[Severity: Medium]
Isn't ctrls->count validated before scatterlist_builder_retrieve_ext_ctrls() copies the shadow buffer back into *ctrls, and left un-restored if the host increases it?

When ctrls goes through the shadow buffer, ctrls->count still holds the pre-command value during the check above and is only overwritten by the device response here (and on the error path above). Furthermore, if the device sets ctrls->count > num_ctrls and it is not clamped back to num_ctrls, V4L2 core post-processing (which runs even on error because VIDIOC_G/S/TRY_EXT_CTRLS have INFO_FL_ALWAYS_COPY) will read past the end of the num_ctrls-sized ctrls->controls buffer in v4l2_compat_put_array_args() and v4l_print_ext_controls().

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
#7 lore raw

PATCH v12 4/6 media: virtio: Add buffer streaming, event handling, and poll

In reply to Brian Daniels

From: Alexandre Courbot <[email protected]>

Add V4L2 buffer queue state tracking, streaming ioctls, asynchronous event virtqueue processing, V4L2 event subscription, and poll support.

Set up the event virtqueue to receive VIRTIO_MEDIA_EVT_DQBUF, VIRTIO_MEDIA_EVT_EVENT, and VIRTIO_MEDIA_EVT_ERROR notifications from the host, dispatching dequeued buffers, V4L2 events, and unrecoverable session errors to their respective sessions.

Implement buffer and streaming ioctls (VIDIOC_REQBUFS, VIDIOC_CREATE_BUFS, VIDIOC_QUERYBUF, VIDIOC_PREPARE_BUF, VIDIOC_QBUF, VIDIOC_DQBUF, VIDIOC_STREAMON, VIDIOC_STREAMOFF, and VIDIOC_DECODER_CMD) as well as VIDIOC_SUBSCRIBE_EVENT, VIDIOC_UNSUBSCRIBE_EVENT, and the poll file operation.

---
 drivers/media/virtio/scatterlist_builder.c |  72 +++
 drivers/media/virtio/scatterlist_builder.h |   8 +
 drivers/media/virtio/session.h             |  51 ++
 drivers/media/virtio/virtio_media.h        |  11 +
 drivers/media/virtio/virtio_media_driver.c | 396 ++++++++++++-
 drivers/media/virtio/virtio_media_ioctls.c | 618 ++++++++++++++++++++-
 include/uapi/linux/virtio_media.h          |  68 +++
 7 files changed, 1218 insertions(+), 6 deletions(-)
drivers/media/virtio/scatterlist_builder.c +72 -0
index 631c7b13c..f01df04cd 100644
@@ -356,6 +356,78 @@ static int scatterlist_builder_add_userptr(struct scatterlist_builder *builder,
 	return 0;
 }
 
+/**
+ * scatterlist_builder_add_buffer() - Add a &struct v4l2_buffer and its planes
+ *                                    to the descriptor chain.
+ * @builder: builder to use.
+ * @b: &struct v4l2_buffer to add.
+ */
+int scatterlist_builder_add_buffer(struct scatterlist_builder *builder,
+				   struct v4l2_buffer *b)
+{
+	int ret;
+
+	/* v4l2_buffer */
+	ret = scatterlist_builder_add_data(builder, b, sizeof(*b));
+	if (ret)
+		return ret;
+
+	if (V4L2_TYPE_IS_MULTIPLANAR(b->type) && b->length > 0) {
+		/* Array of v4l2_planes */
+		ret = scatterlist_builder_add_data(builder, b->m.planes,
+						   sizeof(struct v4l2_plane) *
+							   b->length);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+/**
+ * scatterlist_builder_retrieve_buffer() - Retrieve a &struct v4l2_buffer
+ *                                         written by the device on the shadow
+ *                                         buffer, if needed.
+ * @builder: builder to use.
+ * @sg_index: index of the first SG entry of the buffer in the builder's
+ *            descriptor chain.
+ * @b: &struct v4l2_buffer to copy shadow buffer data into.
+ * @orig_planes: the original ``planes`` pointer, to be restored if the buffer
+ *               is multi-planar.
+ *
+ * If the &struct v4l2_buffer pointed to by @sg_index was copied into the
+ * shadow buffer, then its updated content is copied back into @b.
+ * Otherwise nothing is done as the device has written into @b directly.
+ *
+ * @orig_planes is used to restore the original ``planes`` pointer in case it
+ * gets modified by the host. The specification stipulates that the host should
+ * not modify it, but we enforce this for additional safety.
+ */
+int scatterlist_builder_retrieve_buffer(struct scatterlist_builder *builder,
+					size_t sg_index, struct v4l2_buffer *b,
+					struct v4l2_plane *orig_planes)
+{
+	int ret;
+
+	ret = scatterlist_builder_retrieve_data(builder, sg_index++, b);
+	if (ret)
+		return ret;
+
+	if (V4L2_TYPE_IS_MULTIPLANAR(b->type)) {
+		b->m.planes = orig_planes;
+
+		if (orig_planes) {
+			ret = scatterlist_builder_retrieve_data(builder,
+								sg_index++,
+								b->m.planes);
+			if (ret)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
 /**
  * scatterlist_builder_add_ext_ctrls() - Add a &struct v4l2_ext_controls and its
  *                                       controls to @builder.
drivers/media/virtio/scatterlist_builder.h +8 -0
index bced1e030..f63daca33 100644
@@ -96,6 +96,14 @@ int scatterlist_builder_add_ioctl_cmd(struct scatterlist_builder *builder,
 int scatterlist_builder_add_ioctl_resp(struct scatterlist_builder *builder,
 				       struct virtio_media_session *session);
 
+int scatterlist_builder_add_buffer(struct scatterlist_builder *builder,
+				   struct v4l2_buffer *buffer);
+
+int scatterlist_builder_retrieve_buffer(struct scatterlist_builder *builder,
+					size_t sg_index,
+					struct v4l2_buffer *buffer,
+					struct v4l2_plane *orig_planes);
+
 int scatterlist_builder_add_ext_ctrls(struct scatterlist_builder *builder,
 				      struct v4l2_ext_controls *ctrls);
 
drivers/media/virtio/session.h +51 -0

86 lines not on this page · raw message

drivers/media/virtio/virtio_media.h +11 -0
index a120c1014..8b21c1941 100644
@@ -24,8 +24,12 @@
  * @video_dev: video_device for the media device.
  * @virtio_dev: virtio device for the media device.
  * @commandq: virtio command queue.
+ * @eventq: virtio event queue.
+ * @eventq_work: work to run when events are received on @eventq.
+ * @event_buffer: buffer for event descriptors.
  * @sessions: list of active sessions on the device.
  * @sessions_lock: protects @sessions and &struct virtio_media_session.list.
+ * @events_lock: prevents concurrent processing of events.
  * @cmd: union of device-level commands. Session commands are handled by
  *       &struct virtio_media_session.
  * @resp: union of responses to device-level commands. Session responses are
@@ -39,10 +43,16 @@ struct virtio_media {
 
 	struct virtio_device *virtio_dev;
 	struct virtqueue *commandq;
+	struct virtqueue *eventq;
+	struct work_struct eventq_work;
+
+	void *event_buffer;
 
 	struct list_head sessions;
 	struct mutex sessions_lock; /* protects sessions list */
 
+	struct mutex events_lock; /* prevents concurrent event processing */
+
 	__dma_from_device_group_begin();
 	union {
 		struct virtio_media_cmd_open open;
@@ -68,6 +78,7 @@ to_virtio_media(struct video_device *video_dev)
 int virtio_media_send_command(struct virtio_media *vv, struct scatterlist **sgs,
 			      const size_t out_sgs, const size_t in_sgs,
 			      size_t minimum_resp_len, size_t *resp_len);
+void virtio_media_process_events(struct virtio_media *vv);
 
 /* virtio_media_ioctls.c */
 
drivers/media/virtio/virtio_media_driver.c +391 -5

532 lines not on this page · raw message

drivers/media/virtio/virtio_media_ioctls.c +617 -1

674 lines not on this page · raw message

include/uapi/linux/virtio_media.h +68 -0

72 lines not on this page · raw message

Signature · 1 line
2.56.1.750.gf70dc682cf-goog
#8 lore raw

Re: [PATCH v12 4/6] media: virtio: Add buffer streaming, event handling, and poll

Thank you for your contribution! Sashiko AI review found 19 potential issues to consider: - [High] media: virtio: use-after-free races in virtio_media_process_events() - [High] media: virtio…

Thank you for your contribution! Sashiko AI review found 19 potential issues to consider:
- [High] media: virtio: use-after-free races in virtio_media_process_events()
- [High] media: virtio: deadlock between vlock and events_lock in event handling
- [High] media: virtio: use-after-free of pending_dqbufs in create_bufs and reqbufs
- [High] media: virtio: missing queues_lock and state check on queue and dqbuf state
- [High] media: virtio: cancel_work_sync() before virtio_reset_device() on teardown
- [High] media: virtio: OOB access and leak in reqbufs and create_bufs
- [High] media: virtio: hang on streamoff and O_NONBLOCK bugs in virtio_media_dqbuf()
- [High] media: virtio: device-wide vlock deadlock on blocking VIDIOC_DQEVENT
- [High] media: virtio: missing multiplanar planes validation in buffer ioctls
- [High] media: virtio: wrong response SG index in virtio_media_send_buffer_ioctl()
- [High] media: virtio: stack memory mapped for DMA in scatterlist_builder_add_data()
- [High] media: virtio: broken poll state checks in virtio_media_device_poll()
- [High] media: virtio: infinite wait in virtio_media_dqbuf() on streamoff
- [Medium] media: virtio: premature video_register_device() and incomplete probe unwind
- [Medium] media: virtio: missing mplane and cap handling in virtio_media_create_bufs()
- [Medium] media: virtio: MMAP buffer offsets overwritten on VIDIOC_DQBUF
- [Low] media: virtio: missing kernel-doc for error_lock in virtio_media_session
- [Low] media: virtio: uninitialized resp_len in virtio_media_send_buffer_ioctl()
- [Low] media: virtio: missing virtqueue_disable_cb() and unbatched kicks on eventq
--

commit e79e0e915b239b29517f1a3fac8fe93a0a091be8
Author: Alexandre Courbot <[email protected]>

media: virtio: Add buffer streaming, event handling, and poll

This commit adds V4L2 buffer and streaming ioctls, asynchronous event virtqueue handling, V4L2 event subscription, and poll support to the virtio-media driver.

Quoted 11 lines
drivers/media/virtio/scatterlist_builder.c +3 -0
index 631c7b13c438c..f01df04cdbad9 100644
@@ -356,6 +356,78 @@ static int scatterlist_builder_add_userptr(struct scatterlist_builder *builder,
 	return 0;
 }
 
+/**
+ * scatterlist_builder_add_buffer() - Add a &struct v4l2_buffer and its planes
+ *                                    to the descriptor chain.

drivers/media/virtio/scatterlist_builder.c static int scatterlist_builder_add_userptr(struct scatterlist_builder *builder, · line 371

Quoted 10 lines
drivers/media/virtio/scatterlist_builder.c +10 -0
+ * @builder: builder to use.
+ * @b: &struct v4l2_buffer to add.
+ */
+int scatterlist_builder_add_buffer(struct scatterlist_builder *builder,
+				   struct v4l2_buffer *b)
+{
+	int ret;
+
+	/* v4l2_buffer */
+	ret = scatterlist_builder_add_data(builder, b, sizeof(*b));

[Severity: High]
Does passing b to scatterlist_builder_add_data() DMA-map kernel stack memory?

video_usercopy() allocates ioctl payloads up to 128 bytes in char sbuf[128] on the kernel stack, which includes struct v4l2_buffer (88 bytes), struct v4l2_requestbuffers, struct v4l2_event_subscription, and struct v4l2_decoder_cmd, while virtio_media_streamon() and virtio_media_streamoff() pass &i from their own stack frames. Because scatterlist_builder_add_data() checks virt_addr_valid() and is_vmalloc_addr() without checking !object_is_on_stack(data), both non-VMAP_STACK and CONFIG_VMAP_STACK=y kernels map stack pages directly into virtqueue scatterlists instead of copying through builder->shadow_buffer, violating the DMA API rules and risking stack corruption on non-coherent architectures.

Quoted 19 lines
drivers/media/virtio/scatterlist_builder.c +14 -0
+	if (ret)
+		return ret;
+
+	if (V4L2_TYPE_IS_MULTIPLANAR(b->type) && b->length > 0) {
+		/* Array of v4l2_planes */
+		ret = scatterlist_builder_add_data(builder, b->m.planes,
+						   sizeof(struct v4l2_plane) *
+							   b->length);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
 
drivers/media/virtio/session.h +0 -0
index 6fe7ff5ae02c5..16bb86bf480de 100644

[ ... ]

Quoted 12 lines
drivers/media/virtio/session.h +5 -0
@@ -35,12 +73,19 @@
  *              be staged before being sent to the device.
  * @command_sgs: SG table gathering descriptors for a given command and its
  *               response.
+ * @queues: state of all the queues for this session.
+ * @queues_lock: protects all members for the queues for this session.
+ * @dqbuf_wait: waitqueue for dequeued buffers, if ``VIDIOC_DQBUF`` needs to
+ *              block or when polling.
+ * @error: true if the session has encountered an unrecoverable session error.
  * @list: link into the list of sessions for the device.
  */
 struct virtio_media_session {

[ ... ]

drivers/media/virtio/session.h struct virtio_media_session { · line 112

Quoted 8 lines
drivers/media/virtio/session.h +6 -0
+	struct virtio_media_queue_state queues[VIRTIO_MEDIA_LAST_QUEUE + 1];
+	struct mutex queues_lock; /* protects queues array and states */
+	wait_queue_head_t dqbuf_wait;
+	bool error;
+	struct mutex error_lock; /* protects error */
+
 	struct list_head list;
 };

[Severity: Low]
The kernel-doc comment for struct virtio_media_session is missing an @error_lock entry, which will trigger a kernel-doc warning under W=1.

Quoted 4 lines
drivers/media/virtio/virtio_media_driver.c +0 -0
index 0fe20cf508212..7483577256bd0 100644

[ ... ]

Quoted 28 lines
drivers/media/virtio/virtio_media_driver.c +24 -0
@@ -152,6 +174,31 @@ static int virtio_media_session_close(struct virtio_media *vv,
 	return 0;
 }
 
+/**
+ * virtio_media_find_session() - Look up a session with a given ID.
+ * @vv: virtio-media device to lookup the session from.
+ * @id: ID of the session to lookup.
+ */
+static struct virtio_media_session *
+virtio_media_find_session(struct virtio_media *vv, u32 id)
+{
+	struct list_head *p;
+	struct virtio_media_session *session = NULL;
+
+	mutex_lock(&vv->sessions_lock);
+	list_for_each(p, &vv->sessions) {
+		struct virtio_media_session *s =
+			list_entry(p, struct virtio_media_session, list);
+		if (s->id == id) {
+			session = s;
+			break;
+		}
+	}
+	mutex_unlock(&vv->sessions_lock);
+
+	return session;
+}

[ ... ]

Quoted 95 lines
drivers/media/virtio/virtio_media_driver.c +91 -0
@@ -290,6 +337,234 @@ int virtio_media_send_command(struct virtio_media *vv, struct scatterlist **sgs,
 	return 0;
 }
 
+/**
+ * virtio_media_send_event_buffer() - Sends an event buffer to the host so it
+ * can return it with an event.
+ * @vv: virtio-media device in use.
+ * @event_buffer: pointer to the event buffer to send to the device.
+ */
+static int virtio_media_send_event_buffer(struct virtio_media *vv,
+					  void *event_buffer)
+{
+	struct scatterlist *sgs[1], vresp;
+	int ret;
+
+	sg_init_one(&vresp, event_buffer, VIRTIO_MEDIA_EVENT_MAX_SIZE);
+	sgs[0] = &vresp;
+
+	ret = virtqueue_add_sgs(vv->eventq, sgs, 0, 1, event_buffer,
+				GFP_ATOMIC);
+	if (ret) {
+		v4l2_err(&vv->v4l2_dev,
+			 "failed to add sgs to event virtqueue\n");
+		return ret;
+	}
+
+	if (!virtqueue_kick(vv->eventq)) {
+		v4l2_err(&vv->v4l2_dev, "failed to kick event virtqueue\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+/**
+ * eventq_callback() - Callback for the event queue.
+ * @queue: event virtqueue.
+ *
+ * This just schedules for event work to be run.
+ */
+static void eventq_callback(struct virtqueue *queue)
+{
+	struct virtio_media *vv = queue->vdev->priv;
+
+	schedule_work(&vv->eventq_work);
+}
+
+/**
+ * virtio_media_process_dqbuf_event() - Process a dequeued event for a session.
+ * @vv: virtio-media device in use.
+ * @session: session the event is addressed to.
+ * @dqbuf_evt: the dequeued event to process.
+ *
+ * Invalid events are ignored with an error log.
+ */
+static void
+virtio_media_process_dqbuf_event(struct virtio_media *vv,
+				 struct virtio_media_session *session,
+				 struct virtio_media_event_dqbuf *dqbuf_evt)
+{
+	struct virtio_media_buffer *dqbuf;
+	const enum v4l2_buf_type queue_type = dqbuf_evt->buffer.type;
+	struct virtio_media_queue_state *queue;
+	typeof(dqbuf->buffer.m) buffer_m;
+	typeof(dqbuf->buffer.m.planes[0].m) plane_m;
+	int i;
+
+	if (queue_type >= ARRAY_SIZE(session->queues)) {
+		v4l2_err(&vv->v4l2_dev,
+			 "unmanaged queue %d passed to dqbuf event",
+			 dqbuf_evt->buffer.type);
+		return;
+	}
+	queue = &session->queues[queue_type];
+
+	if (dqbuf_evt->buffer.index >= queue->allocated_bufs) {
+		v4l2_err(&vv->v4l2_dev,
+			 "invalid buffer ID %d for queue %d in dqbuf event",
+			 dqbuf_evt->buffer.index, dqbuf_evt->buffer.type);
+		return;
+	}
+
+	dqbuf = &queue->buffers[dqbuf_evt->buffer.index];
+
+	/*
+	 * Preserve the 'm' union that was passed to us during QBUF so userspace
+	 * gets back the information it submitted.
+	 */
+	buffer_m = dqbuf->buffer.m;
+	memcpy(&dqbuf->buffer, &dqbuf_evt->buffer, sizeof(dqbuf->buffer));
+	dqbuf->buffer.m = buffer_m;
+	if (V4L2_TYPE_IS_MULTIPLANAR(dqbuf->buffer.type)) {
+		if (dqbuf->buffer.length > VIDEO_MAX_PLANES) {
+			v4l2_err(&vv->v4l2_dev,

drivers/media/virtio/virtio_media_driver.c int virtio_media_send_command(struct virtio_media *vv, struct scatterlist **sgs, · line 440

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +10 -0
+				 "invalid number of planes received from host for a multiplanar buffer\n");
+			return;
+		}
+		for (i = 0; i < dqbuf->buffer.length; i++) {
+			plane_m = dqbuf->planes[i].m;
+			memcpy(&dqbuf->planes[i], &dqbuf_evt->planes[i],
+			       sizeof(struct v4l2_plane));
+			dqbuf->planes[i].m = plane_m;
+		}
+	}

[Severity: Medium]
Does preserving dqbuf->buffer.m and dqbuf->planes[i].m across QBUF and DQBUF clobber the MMAP offsets returned by the host?

For V4L2_MEMORY_MMAP buffers, m.offset and planes[i].m.mem_offset are output fields returned by the driver, and userspace typically leaves them zeroed when calling VIDIOC_PREPARE_BUF or VIDIOC_QBUF. Restoring the pre-QBUF m union here overwrites the host's MMAP offsets on VIDIOC_DQBUF.

drivers/media/virtio/virtio_media_driver.c int virtio_media_send_command(struct virtio_media *vv, struct scatterlist **sgs, · line 448

Quoted 8 lines
drivers/media/virtio/virtio_media_driver.c +8 -0
+
+	/* Set the DONE flag as the buffer is waiting to be dequeued. */
+	dqbuf->buffer.flags |= V4L2_BUF_FLAG_DONE;
+
+	mutex_lock(&session->queues_lock);
+	list_add_tail(&dqbuf->list, &queue->pending_dqbufs);
+	queue->queued_bufs -= 1;
+	mutex_unlock(&session->queues_lock);

[Severity: High]
Can virtio_media_process_dqbuf_event() race with queue state changes and corrupt queue->buffers, queue->pending_dqbufs, or queue->queued_bufs?

CPU0 (kworker) CPU1 (ioctl)
virtio_media_process_dqbuf_event()
if (idx >= queue->allocated_bufs)

  dqbuf = &queue->buffers[idx];
                                      virtio_media_reqbufs()
                                        vfree(queue->buffers);
  memcpy(&dqbuf->buffer, ...);
    <-- use-after-free

queue->allocated_bufs and queue->buffers are accessed here before acquiring session->queues_lock, while virtio_media_reqbufs(), virtio_media_create_bufs(), virtio_media_qbuf(), virtio_media_querybuf(), virtio_media_prepare_buf(), virtio_media_dqbuf(), virtio_media_streamon(), and virtio_media_decoder_cmd() read and mutate queue fields and queue->queued_bufs under vv->vlock without holding session->queues_lock.

In addition, list_add_tail() and queue->queued_bufs -= 1 run without checking under session->queues_lock that the buffer still has V4L2_BUF_FLAG_QUEUED set (for example, if an in-flight DQBUF event arrives just after VIDIOC_STREAMOFF called virtio_media_clear_queue(), or if a duplicate event arrives), which corrupts queue->pending_dqbufs and underflows queue->queued_bufs to SIZE_MAX.

Quoted 49 lines
drivers/media/virtio/virtio_media_driver.c +49 -0
+
+	wake_up(&session->dqbuf_wait);
+}
+
+/**
+ * virtio_media_process_events() - Process all pending events on a device.
+ * @vv: device whose pending events we want to process.
+ *
+ * Retrieves all pending events on @vv's event queue and dispatches them to
+ * their corresponding session.
+ *
+ * Invalid events are ignored with an error log.
+ */
+void virtio_media_process_events(struct virtio_media *vv)
+{
+	struct virtio_media_event_error *error_evt;
+	struct virtio_media_event_dqbuf *dqbuf_evt;
+	struct virtio_media_event_event *event_evt;
+	struct virtio_media_session *session;
+	struct virtio_media_event_header *evt;
+	unsigned int len;
+
+	mutex_lock(&vv->events_lock);
+
+process_bufs:
+	while ((evt = virtqueue_get_buf(vv->eventq, &len))) {
+		/* Make sure we received enough data */
+		if (len < sizeof(*evt)) {
+			v4l2_err(&vv->v4l2_dev,
+				 "event is too short: got %u, expected at least %zu\n",
+				 len, sizeof(*evt));
+			goto end_of_event;
+		}
+
+		session = virtio_media_find_session(vv, evt->session_id);
+		if (!session) {
+			v4l2_err(&vv->v4l2_dev, "cannot find session %d\n",
+				 evt->session_id);
+			goto end_of_event;
+		}
+
+		switch (evt->event) {
+		case VIRTIO_MEDIA_EVT_ERROR:
+			if (len < sizeof(*error_evt)) {
+				v4l2_err(&vv->v4l2_dev,
+					 "error event is too short: got %u, expected %zu\n",
+					 len, sizeof(*error_evt));
+				break;
+			}

drivers/media/virtio/virtio_media_driver.c int virtio_media_send_command(struct virtio_media *vv, struct scatterlist **sgs, · line 507

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +10 -0
+			error_evt = (struct virtio_media_event_error *)evt;
+			v4l2_err(&vv->v4l2_dev,
+				 "received error %d for session %d",
+				 error_evt->error, error_evt->hdr.session_id);
+
+			mutex_lock(&session->error_lock);
+			session->error = true;
+			mutex_unlock(&session->error_lock);
+
+			virtio_media_session_close(vv, session);

[Severity: High]
Does calling virtio_media_session_close() while holding vv->events_lock cause an ABBA deadlock (and a recursive lock deadlock) with vv->vlock?

CPU0 CPU1
---- ----
mutex_lock(&vv->vlock)

                                  mutex_lock(&vv->events_lock)
mutex_lock(&vv->events_lock)
                                  mutex_lock(&vv->vlock)

*** DEADLOCK ***

CPU0: virtio_media_device_ioctl() -> ... -> virtio_media_subscribe_event()

        -> virtio_media_process_events()
CPU1: virtio_media_event_work() -> virtio_media_process_events()
        -> virtio_media_session_close()

Furthermore, if a VIRTIO_MEDIA_EVT_ERROR event is processed during the direct call to virtio_media_process_events() from virtio_media_subscribe_event(), the current thread already holds vv->vlock from virtio_media_device_ioctl() and immediately self-deadlocks when virtio_media_session_close() tries to take vv->vlock again.

Quoted 5 lines
drivers/media/virtio/virtio_media_driver.c +5 -0
+
+			/* Wake up any waiting dqbuf requests */
+			wake_up(&session->dqbuf_wait);
+
+			break;

[ ... ]

drivers/media/virtio/virtio_media_driver.c int virtio_media_send_command(struct virtio_media *vv, struct scatterlist **sgs, · line 558

Quoted 11 lines
drivers/media/virtio/virtio_media_driver.c +11 -0
+end_of_event:
+		virtio_media_send_event_buffer(vv, evt);
+	}
+
+	if (!virtqueue_enable_cb(vv->eventq)) {
+		virtqueue_disable_cb(vv->eventq);
+		goto process_bufs;
+	}
+
+	mutex_unlock(&vv->events_lock);
+}

[Severity: Low]
Neither eventq_callback() nor the entry to virtio_media_process_events() calls virtqueue_disable_cb(vv->eventq) before the initial loop, so the first pass drains vv->eventq with callbacks still enabled in the shared ring (incurring a memory barrier per buffer and allowing redundant interrupts while work is already running). Also, virtio_media_send_event_buffer() calls virtqueue_kick() on every buffer instead of batching the kick after the loops in virtio_media_process_events() and virtio_media_probe().

[ ... ]

Quoted 8 lines
drivers/media/virtio/virtio_media_driver.c +3 -1
@@ -350,7 +625,16 @@ static int virtio_media_device_close(struct file *file)
 	struct virtio_media_session *session =
 		fh_to_session(file->private_data);
 
-	int ret = virtio_media_session_close(vv, session);
+	mutex_lock(&session->error_lock);
+	bool session_error = session->error;
+

drivers/media/virtio/virtio_media_driver.c static int virtio_media_device_close(struct file *file) · line 640

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +7 -0
+	mutex_unlock(&session->error_lock);
+
+	int ret = 0;
+
+	/* If session is in an error state, then it has already been closed */
+	if (!session_error)
+		ret = virtio_media_session_close(vv, session);
 
 	virtio_media_session_remove(vv, session);
 	virtio_media_session_free(session);

[Severity: High]
Can virtio_media_device_close() free session while virtio_media_process_events() is still using it?

CPU0 (kworker) CPU1 (close)
virtio_media_process_events()
session = virtio_media_find_session()
virtio_media_device_close()
virtio_media_session_close() virtio_media_session_remove() virtio_media_session_free(session)
virtio_media_process_dqbuf_event()

    queue = &session->queues[...];
      <-- use-after-free

virtio_media_find_session() drops vv->sessions_lock before returning the raw session pointer, and virtio_media_device_close() does not synchronize with vv->events_lock before freeing session.

Even on VIRTIO_MEDIA_EVT_ERROR, virtio_media_process_events() sets session->error = true and drops session->error_lock before calling virtio_media_session_close() and wake_up(&session->dqbuf_wait). A concurrent virtio_media_device_close() seeing session_error == true skips virtio_media_session_close() and immediately frees session while virtio_media_process_events() is still closing and waking it; conversely, if virtio_media_device_close() checks session->error just before VIRTIO_MEDIA_EVT_ERROR sets it, both paths call virtio_media_session_close(). And because virtio_media_device_ioctl() checks session->error only before acquiring vv->vlock, an ioctl blocked on vv->vlock while VIRTIO_MEDIA_EVT_ERROR closes the session will proceed and send a command for a closed host session.

Quoted 42 lines
drivers/media/virtio/virtio_media_driver.c +38 -0
 	return ret;
 }
 
+/**
+ * virtio_media_device_poll() - Poll logic for a virtio-media device.
+ * @file: file of the session to poll.
+ * @wait: poll table to wait on.
+ */
+static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait)
+{
+	struct virtio_media_session *session =
+		fh_to_session(file->private_data);
+	enum v4l2_buf_type capture_type =
+		session->uses_mplane ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
+				       V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	enum v4l2_buf_type output_type =
+		session->uses_mplane ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
+				       V4L2_BUF_TYPE_VIDEO_OUTPUT;
+	struct virtio_media_queue_state *capture_queue =
+		&session->queues[capture_type];
+	struct virtio_media_queue_state *output_queue =
+		&session->queues[output_type];
+	__poll_t req_events = poll_requested_events(wait);
+	__poll_t rc = 0;
+
+	poll_wait(file, &session->dqbuf_wait, wait);
+	poll_wait(file, &session->fh.wait, wait);
+
+	mutex_lock(&session->error_lock);
+	if (session->error)
+		rc |= EPOLLERR;
+	mutex_unlock(&session->error_lock);
+
+	mutex_lock(&session->queues_lock);
+	if (req_events & (EPOLLIN | EPOLLRDNORM)) {
+		if (!capture_queue->streaming ||
+		    (capture_queue->queued_bufs == 0 &&
+		     list_empty(&capture_queue->pending_dqbufs)))
+			rc |= EPOLLERR;
+		else if (!list_empty(&capture_queue->pending_dqbufs) ||
+			 capture_queue->is_capture_last)

drivers/media/virtio/virtio_media_driver.c static int virtio_media_device_close(struct file *file) · line 692

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +10 -0
+			rc |= EPOLLIN | EPOLLRDNORM;
+	}
+	if (req_events & (EPOLLOUT | EPOLLWRNORM)) {
+		if (!output_queue->streaming)
+			rc |= EPOLLERR;
+		else if (output_queue->queued_bufs <
+			 output_queue->allocated_bufs)
+			rc |= EPOLLOUT | EPOLLWRNORM;
+	}
+	mutex_unlock(&session->queues_lock);

[Severity: High]
Does virtio_media_device_poll() return premature EPOLLERR and EPOLLOUT events?

First, when the last capture buffer (with V4L2_BUF_FLAG_LAST) has been dequeued, capture_queue->is_capture_last is true, queued_bufs is 0, and pending_dqbufs is empty; because the first if condition does not check !capture_queue->is_capture_last, it takes the EPOLLERR branch instead of reaching the else-if branch that returns EPOLLIN | EPOLLRDNORM for the subsequent -EPIPE dequeue.

Second, for EPOLLOUT | EPOLLWRNORM, checking output_queue->queued_bufs < output_queue->allocated_bufs signals writability whenever any allocated output buffer is not currently queued on the host (for example right after VIDIOC_REQBUFS/STREAMON or after a buffer was already dequeued), even when output_queue->pending_dqbufs is empty and VIDIOC_DQBUF would return -EAGAIN.

Third, when userspace polls with both EPOLLIN and EPOLLOUT while only one queue is streaming (such as during M2M header parsing or resolution change), the non-streaming queue unconditionally sets EPOLLERR.

[ ... ]

Quoted 45 lines
drivers/media/virtio/virtio_media_driver.c +24 -0
@@ -449,13 +809,34 @@ static int virtio_media_probe(struct virtio_device *virtio_dev)
 	if (ret)
 		goto err_del_vqs;
 
+	mutex_lock(&vv->events_lock);
+
+	for (i = 0; i < VIRTIO_MEDIA_NUM_EVENT_BUFS; i++) {
+		void *ebuf = vv->event_buffer +
+			     virtio_media_event_aligned_size * i;
+
+		ret = virtio_media_send_event_buffer(vv, ebuf);
+		if (ret)
+			break;
+	}
+
+	mutex_unlock(&vv->events_lock);
+
+	if (ret)
+		goto err_video_unregister_device;
+
 	return 0;
 
+err_video_unregister_device:
+	video_unregister_device(&vv->video_dev);
 err_del_vqs:
+	cancel_work_sync(&vv->eventq_work);
 	virtio_reset_device(virtio_dev);
 	virtio_dev->config->del_vqs(virtio_dev);
 err_v4l2_device_unregister:
 	v4l2_device_unregister(&vv->v4l2_dev);
+err_free_event_buffer:
+	kfree(vv->event_buffer);
 err_free_virtio_media:
 	kfree(vv);
 	return ret;
@@ -469,6 +850,9 @@ static void virtio_media_remove(struct virtio_device *virtio_dev)
 	/* Remove the video device to stop accessing the commandq virtqueue */
 	video_unregister_device(&vv->video_dev);
 
+	/* Stop event handling work queue from accessing eventq virtqueue */
+	cancel_work_sync(&vv->eventq_work);
+
 	/*
 	 * Acquire vlock to ensure no concurrent accesses to the commandq
 	 * virtqueue

drivers/media/virtio/virtio_media_driver.c

Quoted 5 lines
drivers/media/virtio/virtio_media_driver.c +0 -0
 	 */
 	mutex_lock(&vv->vlock);
 
 	/* Stop all virtqueue callbacks */
 	virtio_reset_device(virtio_dev);

[Severity: High]
Can eventq_callback() re-schedule vv->eventq_work after cancel_work_sync() because virtio_reset_device() has not run yet?

CPU0 CPU1 (<hardirq>)
virtio_media_remove()
cancel_work_sync(&vv->eventq_work)

                                  eventq_callback()
                                    schedule_work(&vv->eventq_work)
  virtio_reset_device(virtio_dev)
  del_vqs(virtio_dev)
  v4l2_device_put(&vv->v4l2_dev)
    kfree(vv)
                                  virtio_media_event_work()
                                    virtio_media_process_events(vv)
                                      <-- use-after-free

The same ordering issue exists in the err_del_vqs error path of virtio_media_probe(). virtio_reset_device() needs to stop virtqueue callbacks before cancel_work_sync(&vv->eventq_work) drains the work item.

[Severity: Medium]
Also in virtio_media_probe(), shouldn't the event buffers be queued on vv->eventq before video_register_device() exposes the device node to userspace?

If virtio_media_send_event_buffer() fails partway through the loop after video_register_device() has already succeeded, err_del_vqs calls virtio_dev->config->del_vqs() without detaching the already-queued eventq buffers via virtqueue_detach_unused_buf(vv->eventq), and if userspace has already opened the video device, jumping to err_free_event_buffer and err_free_virtio_media directly frees vv->event_buffer and vv instead of waiting for virtio_media_release() via v4l2_device_put().

Quoted 4 lines
drivers/media/virtio/virtio_media_ioctls.c +0 -0
index d0ea743e793bd..aa56efe9a08c2 100644

[ ... ]

Quoted 17 lines
drivers/media/virtio/virtio_media_ioctls.c +13 -0
@@ -221,6 +223,101 @@ static int virtio_media_send_wr_ioctl(struct v4l2_fh *fh, u32 ioctl,
 	return 0;
 }
 
+/**
+ * virtio_media_send_buffer_ioctl() - Send an ioctl taking a buffer as
+ * parameter to the device.
+ * @fh: file handler of the session doing the ioctl.
+ * @ioctl: ``VIDIOC_*`` ioctl code.
+ * @b: &struct v4l2_buffer to be sent as the ioctl payload.
+ *
+ * Buffers can require an additional descriptor to send their planes array, and
+ * can have pointers to userspace memory hence this dedicated function.
+ */
+static int virtio_media_send_buffer_ioctl(struct v4l2_fh *fh, u32 ioctl,
+					  struct v4l2_buffer *b)
+{

[ ... ]

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_send_wr_ioctl(struct v4l2_fh *fh, u32 ioctl, · line 262

Quoted 1 line
drivers/media/virtio/virtio_media_ioctls.c +1 -0
+	size_t resp_len;

[Severity: Low]
Is resp_len left uninitialized before being passed to virtio_media_send_command()? virtio_media_send_command() reads *resp_len on entry (size_t local_resp_len = resp_len ? *resp_len : 0;), which reads an uninitialized stack value.

Quoted 23 lines
drivers/media/virtio/virtio_media_ioctls.c +23 -0
+	int ret;
+	int i;
+
+	if (b->type > VIRTIO_MEDIA_LAST_QUEUE)
+		return -EINVAL;
+
+	if (V4L2_TYPE_IS_MULTIPLANAR(b->type))
+		orig_planes = b->m.planes;
+
+	/* Command descriptor */
+	ret = scatterlist_builder_add_ioctl_cmd(&builder, session, ioctl);
+	if (ret)
+		return ret;
+
+	/* Command payload (struct v4l2_buffer) */
+	ret = scatterlist_builder_add_buffer(&builder, b);
+	if (ret < 0)
+		return ret;
+
+	end_buf_sg = builder.cur_sg;
+	num_cmd_sgs = builder.cur_sg;
+
+	/* Response descriptor */

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_send_wr_ioctl(struct v4l2_fh *fh, u32 ioctl, · line 295

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+	ret = scatterlist_builder_add_ioctl_resp(&builder, session);
+	if (ret)
+		return ret;
+
+	/* Response payload (same as input, but no userptr mapping) */
+	for (i = 1; i < end_buf_sg; i++) {
+		ret = scatterlist_builder_add_descriptor(&builder, i);
+		if (ret < 0)
+			return ret;
+	}

[Severity: High]
Does passing i (an index up to builder.cur_sg) as desc_index to scatterlist_builder_add_descriptor() attach the wrong descriptors when a vmalloc buffer spans non-contiguous pages?

In scatterlist_builder_add_data(), a vmalloc buffer crossing a boundary between two non-contiguous pages consumes two entries in builder.descs[] (say descs[1] and descs[2]) while adding only one entry to builder.sgs[] (sgs[1] = &descs[1]), so builder.cur_desc and builder.cur_sg diverge. For a multiplanar buffer whose planes array is then placed at descs[3] (with end_buf_sg = builder.cur_sg = 3), this loop adds &descs[1] and &descs[2] as the writable response descriptors, mapping the second page of b twice and omitting descs[3] (b->m.planes).

[ ... ]

Quoted 1 line
drivers/media/virtio/virtio_media_ioctls.c +0 -0
@@ -488,6 +620,431 @@ static int virtio_media_try_ext_ctrls(struct file *file, void *fh,

[ ... ]

Quoted 29 lines
drivers/media/virtio/virtio_media_ioctls.c +29 -0
+static int virtio_media_reqbufs(struct file *file, void *fh,
+				struct v4l2_requestbuffers *b)
+{
+	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
+	struct virtio_media_session *session = fh_to_session(vfh);
+	struct virtio_media_buffer *buffers = NULL;
+	struct virtio_media_queue_state *queue;
+	int ret;
+
+	if (b->type > VIRTIO_MEDIA_LAST_QUEUE)
+		return -EINVAL;
+
+	if (b->memory == V4L2_MEMORY_USERPTR)
+		return -EINVAL;
+
+	if (b->count > 0) {
+		buffers =
+			vcalloc(b->count, sizeof(struct virtio_media_buffer));
+		if (!buffers)
+			return -ENOMEM;
+	}
+
+	ret = virtio_media_send_wr_ioctl(vfh, VIDIOC_REQBUFS, b, sizeof(*b),
+					 sizeof(*b));
+	if (ret) {
+		vfree(buffers);
+		return ret;
+	}
+

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_try_ext_ctrls(struct file *file, void *fh, · line 766

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+	queue = &session->queues[b->type];
+
+	/* REQBUFS(0) is an implicit STREAMOFF. */
+	if (b->count == 0)
+		virtio_media_clear_queue(session, queue);
+
+	vfree(queue->buffers);
+	queue->buffers = buffers;
+
+	queue->allocated_bufs = b->count;

[Severity: High]
Can queue->allocated_bufs exceed the size of the vcalloc()-allocated queue->buffers array when the host increases b->count?

V4L2 drivers commonly clamp b->count up to a queue's minimum buffer requirement in VIDIOC_REQBUFS. Because buffers is allocated using the caller's initial b->count before virtio_media_send_wr_ioctl(), but queue->allocated_bufs is set to the host-returned b->count, any buffer index between the requested count and the returned count will index queue->buffers out of bounds.

The same issue occurs in virtio_media_create_bufs() below if the host returns b->index + b->count larger than the pre-allocated queue->allocated_bufs + initial b->count, or if b->count was > 0 on entry and the host returns b->count == 0, where virtio_media_create_bufs() returns early without calling vfree(buffers) and leaks the allocation.

[ ... ]

Quoted 44 lines
drivers/media/virtio/virtio_media_ioctls.c +44 -0
+static int virtio_media_create_bufs(struct file *file, void *fh,
+				    struct v4l2_create_buffers *b)
+{
+	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
+	struct virtio_media_session *session = fh_to_session(vfh);
+	struct virtio_media_queue_state *queue;
+	struct virtio_media_buffer *buffers = NULL;
+	u32 type = b->format.type;
+	int ret;
+
+	if (type > VIRTIO_MEDIA_LAST_QUEUE)
+		return -EINVAL;
+
+	queue = &session->queues[type];
+
+	if (b->count > 0) {
+		/*
+		 * This allocates a new buffer large enough for the existing
+		 * buffers (``queue->allocated_bufs``) as well as the newly
+		 * requested buffers (``b->count``). The host may allocate
+		 * fewer buffers than requested, as indicated by the final
+		 * value of ``b->count``. In this case, we do not re-allocate
+		 * to avoid the case where this new allocation fails and the
+		 * host buffers need to be freed. Instead we simply use the
+		 * larger buffer.
+		 */
+		buffers = vcalloc(queue->allocated_bufs + b->count,
+				  sizeof(*queue->buffers));
+		if (!buffers)
+			return -ENOMEM;
+	}
+
+	ret = virtio_media_send_wr_ioctl(vfh, VIDIOC_CREATE_BUFS, b, sizeof(*b),
+					 sizeof(*b));
+	if (ret) {
+		if (buffers)
+			vfree(buffers);
+
+		return ret;
+	}
+
+	/* If count is zero, we were just checking for format. */
+	if (b->count == 0)
+		return 0;

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_try_ext_ctrls(struct file *file, void *fh, · line 866

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+
+	memcpy(buffers, queue->buffers,
+	       sizeof(*queue->buffers) * queue->allocated_bufs);
+	vfree(queue->buffers);
+	queue->buffers = buffers;
+
+	queue->allocated_bufs = b->index + b->count;
+
+	return 0;
+}

[Severity: High]
Does copying queue->buffers with memcpy() and freeing the old array leave dangling list_head pointers in queue->pending_dqbufs?

Each struct virtio_media_buffer embeds a struct list_head list node that is linked into queue->pending_dqbufs when a buffer is awaiting dequeue. Reallocating queue->buffers via memcpy() and vfree(queue->buffers) without fixing up linked list nodes (or clearing queue->pending_dqbufs when virtio_media_reqbufs() is called with b->count > 0) leaves queue->pending_dqbufs pointing into freed vmalloc memory, causing a use-after-free on the next VIDIOC_DQBUF or VIDIOC_STREAMOFF.

[Severity: Medium]
Unlike virtio_media_reqbufs(), virtio_media_create_bufs() also does not reject b->memory == V4L2_MEMORY_USERPTR, does not clear V4L2_BUF_CAP_SUPPORTS_USERPTR and V4L2_BUF_CAP_SUPPORTS_DMABUF from b->capabilities, and does not set session->uses_mplane = true when V4L2_TYPE_IS_MULTIPLANAR(type) is true (which causes virtio_media_device_poll() to poll the inactive single-planar queues and return EPOLLERR when buffers were allocated with VIDIOC_CREATE_BUFS).

[ ... ]

Quoted 45 lines
drivers/media/virtio/virtio_media_ioctls.c +45 -0
+static int virtio_media_dqbuf(struct file *file, void *fh,
+			      struct v4l2_buffer *b)
+{
+	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_to_v4l2_fh(file));
+	struct virtio_media_buffer *dqbuf;
+	struct virtio_media_queue_state *queue;
+	struct list_head *buffer_queue;
+	struct v4l2_plane *planes_backup = NULL;
+	const bool is_multiplanar = V4L2_TYPE_IS_MULTIPLANAR(b->type);
+	int ret;
+	bool error;
+
+	if (b->type > VIRTIO_MEDIA_LAST_QUEUE)
+		return -EINVAL;
+
+	queue = &session->queues[b->type];
+
+	/*
+	 * If a buffer with the LAST flag has been returned, subsequent
+	 * calls to DQBUF must return -EPIPE until the queue is cleared.
+	 */
+	if (queue->is_capture_last)
+		return -EPIPE;
+
+	buffer_queue = &queue->pending_dqbufs;
+
+	if (session->nonblocking_dequeue) {
+		if (list_empty(buffer_queue))
+			return -EAGAIN;
+	} else if (queue->allocated_bufs == 0) {
+		return -EINVAL;
+	} else if (!queue->streaming) {
+		return -EINVAL;
+	}
+
+	/*
+	 * vv->lock has been acquired by virtio_media_device_ioctl. Release it
+	 * while we wait so that other ioctls for this session can be processed
+	 * and potentially trigger dqbuf_wait.
+	 */
+	mutex_unlock(&vv->vlock);
+

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_try_ext_ctrls(struct file *file, void *fh, · line 1001

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+	/*
+	 * It's not possible to acquire ``session->error_lock`` during the
+	 * check, however this shouldn't cause issues because:
+	 *     - The lock is acquired when actually checking the value
+	 *     - The ``session->error`` flag is never reset once set
+	 */
+	ret = wait_event_interruptible(session->dqbuf_wait,
+				       !list_empty(buffer_queue) ||
+				       session->error);
+	mutex_lock(&vv->vlock);

[Severity: High]
Will a thread blocked in wait_event_interruptible() here hang forever if another thread calls VIDIOC_STREAMOFF or VIDIOC_REQBUFS(0)?

virtio_media_clear_queue() clears queue->pending_dqbufs and sets queue->streaming = false, but never calls wake_up(&session->dqbuf_wait), and !queue->streaming is not part of the wait condition here.

In addition:
- While vv->vlock is dropped across wait_event_interruptible(), virtio_media_remove() can acquire and release vv->vlock and then free all sessions in vv->sessions while virtio_media_dqbuf() is still sleeping on session->dqbuf_wait, causing a use-after-free when virtio_media_dqbuf() wakes.
- Caching session->nonblocking_dequeue at open() time ignores O_NONBLOCK changes made later via fcntl(F_SETFL).
- Putting queue->allocated_bufs == 0 and !queue->streaming in else-if branches after if (session->nonblocking_dequeue) makes non-blocking calls on unallocated or stopped queues return -EAGAIN instead of -EINVAL, and when buffer_queue is non-empty on a non-blocking call, execution still drops vv->vlock and enters wait_event_interruptible().

Quoted 29 lines
drivers/media/virtio/virtio_media_ioctls.c +29 -0
+	if (ret)
+		return -EINTR;
+
+	mutex_lock(&session->error_lock);
+	error = session->error;
+	mutex_unlock(&session->error_lock);
+
+	if (error)
+		return -EIO;
+
+	mutex_lock(&session->queues_lock);
+	dqbuf = list_first_entry_or_null(buffer_queue,
+					 struct virtio_media_buffer, list);
+
+	if (dqbuf)
+		list_del(&dqbuf->list);
+
+	mutex_unlock(&session->queues_lock);
+
+	if (!dqbuf) {
+		v4l2_err(&vv->v4l2_dev, "No buffer found when dqbuf event triggered\n");
+		return -EIO;
+	}
+
+	/* Clear the DONE flag as the buffer is now being dequeued. */
+	dqbuf->buffer.flags &= ~V4L2_BUF_FLAG_DONE;
+
+	if (is_multiplanar) {
+		size_t nb_planes = min_t(u32, b->length, VIDEO_MAX_PLANES);

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_try_ext_ctrls(struct file *file, void *fh, · line 1040

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+
+		memcpy(b->m.planes, dqbuf->planes,
+		       nb_planes * sizeof(struct v4l2_plane));
+		planes_backup = b->m.planes;
+	}
+
+	memcpy(b, &dqbuf->buffer, sizeof(*b));
+
+	if (is_multiplanar)
+		b->m.planes = planes_backup;

[Severity: High]
Can a multiplanar buffer ioctl with a small or zero b->length cause an out-of-bounds kernel heap read or dereference an untranslated user pointer?

In drivers/media/v4l2-core/v4l2-ioctl.c, check_array_args() and video_usercopy() only allocate a kernel array_buf for b->m.planes when b->length > 0, and size it to b->length elements:

drivers/media/v4l2-core/v4l2-ioctl.c:check_array_args() {
    ...
	if (V4L2_TYPE_IS_MULTIPLANAR(buf->type) && buf->length > 0) {
		if (buf->length > VIDEO_MAX_PLANES) {
			ret = -EINVAL;
			break;
		}
		*user_ptr = (void __user *)buf->m.planes;
		*kernel_ptr = (void **)&buf->m.planes;
		ret = sizeof(struct v4l2_plane) * buf->length;
	}
    ...
}

If a 32-bit compat caller passes 0 < b->length < dqbuf->buffer.length to VIDIOC_DQBUF (or if the host returns an increased b->length in virtio_media_send_buffer_ioctl()), overwriting *b sets b->length to the larger plane count while b->m.planes still points to the smaller array_buf, causing v4l2_compat_put_array_args() (and v4l_print_buffer()) to read past the end of array_buf and copy out-of-bounds kernel heap memory to userspace.

If b->length == 0 and b->m.planes != NULL, video_usercopy() leaves b->m.planes as the raw userspace pointer: virtio_media_dqbuf() consumes the buffer and sets b->length = dqbuf->buffer.length > 0 with an untranslated user pointer in b->m.planes, while virtio_media_send_buffer_ioctl() passes a non-NULL orig_planes to scatterlist_builder_retrieve_buffer() even though scatterlist_builder_add_buffer() skipped adding a planes SG descriptor.

[ ... ]

Quoted 20 lines
drivers/media/virtio/virtio_media_ioctls.c +6 -1
@@ -701,6 +1304,9 @@ const struct v4l2_ioctl_ops virtio_media_ioctl_ops = {
 	.vidioc_g_edid = NULL,
 	.vidioc_s_edid = NULL,
 
+	.vidioc_subscribe_event = virtio_media_subscribe_event,
+	.vidioc_unsubscribe_event = virtio_media_unsubscribe_event,
+
 	/* For other private ioctls */
 	.vidioc_default = NULL,
 };
@@ -714,9 +1320,19 @@ long virtio_media_device_ioctl(struct file *file, unsigned int cmd,
 	struct v4l2_standard standard;
 	v4l2_std_id std_id = 0;
 	int ret;
+	bool error;
 
-	if (test_bit(V4L2_FL_USES_V4L2_FH, &video_dev->flags))
+	if (test_bit(V4L2_FL_USES_V4L2_FH, &video_dev->flags)) {
 		vfh = file_to_v4l2_fh(file);
+		struct virtio_media_session *session = fh_to_session(vfh);

drivers/media/virtio/virtio_media_ioctls.c long virtio_media_device_ioctl(struct file *file, unsigned int cmd, · line 1337

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +8 -0
+
+		mutex_lock(&session->error_lock);
+		error = session->error;
+		mutex_unlock(&session->error_lock);
+
+		if (error)
+			return -EIO;
+	}
 
 	mutex_lock(&vv->vlock);

[Severity: High]
Does enabling event subscription here cause a blocking VIDIOC_DQEVENT call to sleep with vv->vlock held?

In drivers/media/v4l2-core/v4l2-event.c, v4l2_event_dequeue() only unlocks fh->vdev->lock while waiting on fh->wait. Because vv->video_dev.lock is NULL and virtio_media_device_ioctl() acquires vv->vlock manually before calling video_ioctl2(), a blocking VIDIOC_DQEVENT call when no event is queued will sleep holding vv->vlock and block all other ioctls, opens, and closes across the entire virtio-media device.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
#9 lore raw

PATCH v12 5/6 media: virtio: Add MMAP buffer mapping support

In reply to Brian Daniels

From: Alexandre Courbot <[email protected]>

Support mapping V4L2_MEMORY_MMAP buffers into guest userspace through virtio shared memory region 0.

Query the shared memory region during device probe and implement the mmap file operation and VMA close callback using VIRTIO_MEDIA_CMD_MMAP and VIRTIO_MEDIA_CMD_MUNMAP, remapping the host-provided shared memory offset into userspace via io_remap_pfn_range().

---
 drivers/media/virtio/session.h             |  14 +-
 drivers/media/virtio/virtio_media.h        |  13 +-
 drivers/media/virtio/virtio_media_driver.c | 159 +++++++++++++++++++++
 include/uapi/linux/virtio_media.h          |  67 +++++++++
 4 files changed, 243 insertions(+), 10 deletions(-)
drivers/media/virtio/session.h +8 -6
index 16bb86bf4..c074ffc2c 100644
@@ -63,12 +63,12 @@ struct virtio_media_queue_state {
  * @nonblocking_dequeue: whether dequeue should block or not (nonblocking if
  *                       file opened with O_NONBLOCK).
  * @uses_mplane: whether the queues for this session use the MPLANE API or not.
- * @cmd: union of session commands ``close`` and ``ioctl``. A session can have
- *       one command currently running. The rest of the commands are handled by
- *       &struct virtio_media.
- * @resp: union of responses to session commands. A session can wait on one
- *        command only. The rest of the responses are handled by
- *        &struct virtio_media.
+ * @cmd: union of session commands ``close``, ``ioctl``, and ``mmap``. A
+ *       session can have one command currently running. The rest of the
+ *       commands are handled by &struct virtio_media.
+ * @resp: union of responses to session commands ``close``, ``ioctl``, and
+ *        ``mmap``. A session can wait on one command only. The rest of the
+ *        responses are handled by &struct virtio_media.
  * @shadow_buf: shadow buffer where data to be added to the descriptor chain can
  *              be staged before being sent to the device.
  * @command_sgs: SG table gathering descriptors for a given command and its
@@ -91,10 +91,12 @@ struct virtio_media_session {
 	union {
 		struct virtio_media_cmd_close close;
 		struct virtio_media_cmd_ioctl ioctl;
+		struct virtio_media_cmd_mmap mmap;
 	} cmd;
 
 	union {
 		struct virtio_media_resp_ioctl ioctl;
+		struct virtio_media_resp_mmap mmap;
 	} resp;
 	__dma_from_device_group_end();
 
drivers/media/virtio/virtio_media.h +9 -4
index 8b21c1941..7acb2b842 100644
@@ -26,14 +26,15 @@
  * @commandq: virtio command queue.
  * @eventq: virtio event queue.
  * @eventq_work: work to run when events are received on @eventq.
+ * @mmap_region: region into which MMAP buffers are mapped by the host.
  * @event_buffer: buffer for event descriptors.
  * @sessions: list of active sessions on the device.
  * @sessions_lock: protects @sessions and &struct virtio_media_session.list.
  * @events_lock: prevents concurrent processing of events.
- * @cmd: union of device-level commands. Session commands are handled by
- *       &struct virtio_media_session.
- * @resp: union of responses to device-level commands. Session responses are
- *        handled by &struct virtio_media_session.
+ * @cmd: union of the device commands ``open`` and ``munmap``. The other
+ *       commands are handled by &struct virtio_media_session
+ * @resp: union of responses to device commands ``open`` and ``munmap``. The
+ *        other responses are handled by &struct virtio_media_session
  * @vlock: serializes access to the command queue.
  * @wq: waitqueue for host responses on the command queue.
  */
@@ -46,6 +47,8 @@ struct virtio_media {
 	struct virtqueue *eventq;
 	struct work_struct eventq_work;
 
+	struct virtio_shm_region mmap_region;
+
 	void *event_buffer;
 
 	struct list_head sessions;
@@ -56,10 +59,12 @@ struct virtio_media {
 	__dma_from_device_group_begin();
 	union {
 		struct virtio_media_cmd_open open;
+		struct virtio_media_cmd_munmap munmap;
 	} cmd;
 
 	union {
 		struct virtio_media_resp_open open;
+		struct virtio_media_resp_munmap munmap;
 	} resp;
 	__dma_from_device_group_end();
 
drivers/media/virtio/virtio_media_driver.c +159 -0

195 lines not on this page · raw message

include/uapi/linux/virtio_media.h +67 -0

73 lines not on this page · raw message

Signature · 1 line
2.56.1.750.gf70dc682cf-goog
#10 lore raw

Re: [PATCH v12 5/6] media: virtio: Add MMAP buffer mapping support

Thank you for your contribution! Sashiko AI review found 8 potential issues to consider: - [High] media: virtio: missing vm_ops.open and pgoff bug in virtio_media_vma_close() - [High] media: virtio…

Thank you for your contribution! Sashiko AI review found 8 potential issues to consider:
- [High] media: virtio: missing vm_ops.open and pgoff bug in virtio_media_vma_close()
- [High] media: virtio: use-after-free of commandq in virtio_media_vma_close()
- [High] media: virtio: ABBA deadlock between mm->mmap_lock and vv->vlock in mmap/close/ioctl
- [High] media: virtio: use-after-free in virtio_media_vma_close() after remove
- [Medium] media: virtio: missing mmap_region bounds check in virtio_media_device_mmap()
- [Medium] media: virtio: offset truncation and VM_MAYWRITE in virtio_media_device_mmap()
- [Medium] media: virtio: missing VM_MAYWRITE clear on read-only mmap in virtio_media_device_mmap()
- [Medium] media: virtio: TOCTOU race on session->error in virtio_media_device_mmap()
--

commit 14004eedd96a0d60c179b127c333d6afc58f6ae1
Author: Alexandre Courbot <[email protected]>

media: virtio: Add MMAP buffer mapping support

This commit adds V4L2_MEMORY_MMAP buffer mapping support to the virtio-media driver by querying shared memory region 0 at probe time and implementing the mmap file operation and VMA close callback with VIRTIO_MEDIA_CMD_MMAP and VIRTIO_MEDIA_CMD_MUNMAP.

Quoted 4 lines
drivers/media/virtio/virtio_media_driver.c +0 -0
index 7483577256bd0..eb6b31d7e370c 100644

[ ... ]

Quoted 15 lines
drivers/media/virtio/virtio_media_driver.c +11 -0
@@ -697,12 +705,155 @@ static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait)
 	return rc;
 }
 
+static void virtio_media_vma_close_locked(struct vm_area_struct *vma)
+{
+	struct virtio_media *vv = vma->vm_private_data;
+	struct virtio_media_cmd_munmap *cmd_munmap = &vv->cmd.munmap;
+	struct virtio_media_resp_munmap *resp_munmap = &vv->resp.munmap;
+	struct scatterlist cmd_sg = {}, resp_sg = {};
+	struct scatterlist *sgs[2] = { &cmd_sg, &resp_sg };
+	int ret;
+
+	sg_set_buf(&cmd_sg, cmd_munmap, sizeof(*cmd_munmap));
+	sg_mark_end(&cmd_sg);

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 728

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +10 -0
+
+	sg_set_buf(&resp_sg, resp_munmap, sizeof(*resp_munmap));
+	sg_mark_end(&resp_sg);
+
+	cmd_munmap->hdr.cmd = VIRTIO_MEDIA_CMD_MUNMAP;
+	cmd_munmap->hdr.__reserved = 0;
+	cmd_munmap->driver_addr =
+		(vma->vm_pgoff << PAGE_SHIFT) - vv->mmap_region.addr;
+	ret = virtio_media_send_command(vv, sgs, 1, 1, sizeof(*resp_munmap),
+					NULL);

[Severity: High]
Can virtio_media_vma_close_locked() dereference a freed vv->commandq if the virtio device was removed while a buffer remained mapped in userspace?

An active VMA pins vma->vm_file, which keeps struct virtio_media allocated until all mappings are unmapped. If virtio_media_remove() runs first, it calls virtio_dev->config->del_vqs(virtio_dev), freeing vv->commandq. Unlike the v4l2 file operation wrappers that check video_is_registered(), vma->vm_ops->close is invoked directly by the MM subsystem on munmap() or process exit and sends VIRTIO_MEDIA_CMD_MUNMAP on the freed virtqueue.

Quoted 11 lines
drivers/media/virtio/virtio_media_driver.c +11 -0
+	if (ret < 0) {
+		v4l2_err(&vv->v4l2_dev, "host failed to unmap buffer: %d\n",
+			 ret);
+	}
+}
+
+/**
+ * virtio_media_vma_close() - Close a MMAP buffer mapping.
+ * @vma: VMA of the mapping to close.
+ *
+ * Inform the host that a previously created MMAP mapping is no longer needed

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 749

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +10 -0
+ * and can be removed.
+ + */
+static void virtio_media_vma_close(struct vm_area_struct *vma)
+{
+	struct virtio_media *vv = vma->vm_private_data;
+
+	mutex_lock(&vv->vlock);
+	virtio_media_vma_close_locked(vma);
+	mutex_unlock(&vv->vlock);
+}

[Severity: High]
When a mapped VMA pins vma->vm_file across virtio_media_remove(), does unmapping the VMA cause a use-after-free in virtio_media_vma_close() followed by a use-after-free and double free of the session in virtio_media_device_close()?

virtio_media_remove() deletes the virtqueues and frees every session in vv->sessions while vma->vm_file is still open. When the process later unmaps the VMA or exits, remove_vma() calls virtio_media_vma_close() (which uses the freed vv->commandq) and then drops vma->vm_file, triggering v4l2_release() -> virtio_media_device_close(), which accesses and frees the already-freed struct virtio_media_session a second time.

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 753

Quoted 4 lines
drivers/media/virtio/virtio_media_driver.c +4 -0
+
+static const struct vm_operations_struct virtio_media_vm_ops = {
+	.close = virtio_media_vma_close,
+};

[Severity: High]
What happens when a mapped VMA is duplicated by fork() or split by a partial munmap(), mprotect(), or mremap()?

Because virtio_media_vm_ops has no .open callback and vma->vm_private_data Does not track a reference-counted mapping object, closing the first VMA in a forked child or half of a split VMA sends VIRTIO_MEDIA_CMD_MUNMAP while the remaining VMA still maps those guest physical pages, and closing the remaining VMA sends an extra unmap command.

In addition, __split_vma() advances vma->vm_pgoff on the upper half of a split VMA, so virtio_media_vma_close_locked() computes cmd_munmap->driver_addr from the shifted vma->vm_pgoff instead of the buffer's base driver_addr and fails to unmap the buffer on the host.

Quoted 19 lines
drivers/media/virtio/virtio_media_driver.c +19 -0
+
+/**
+ * virtio_media_device_mmap() - Perform a mmap request from userspace.
+ * @file: opened file of the session to map for.
+ * @vma: VM area struct describing the desired mapping.
+ *
+ * This requests the host to map a MMAP buffer for us, so we can then make that
+ * mapping visible into user-space address space.
+ */
+static int virtio_media_device_mmap(struct file *file,
+				    struct vm_area_struct *vma)
+{
+	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);
+	struct virtio_media_cmd_mmap *cmd_mmap = &session->cmd.mmap;
+	struct virtio_media_resp_mmap *resp_mmap = &session->resp.mmap;
+	struct scatterlist cmd_sg = {}, resp_sg = {};

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 782

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +10 -0
+	struct scatterlist *sgs[2] = { &cmd_sg, &resp_sg };
+	int ret;
+
+	mutex_lock(&session->error_lock);
+	bool session_error = session->error;
+
+	mutex_unlock(&session->error_lock);
+
+	if (session_error)
+		return -EIO;

[Severity: Medium]
Can session->error become true after session->error_lock is dropped here and before mutex_lock(&vv->vlock) is acquired below?

CPU0 CPU1 (eventq_work)
virtio_media_device_mmap()
lock(&session->error_lock)
session_error = session->error
unlock(&session->error_lock)

                                  virtio_media_process_events()
                                    lock(&session->error_lock)
                                    session->error = true
                                    unlock(&session->error_lock)
                                    virtio_media_session_close()
                                      lock(&vv->vlock)
                                      /* closes session->id on host */
                                      unlock(&vv->vlock)
  lock(&vv->vlock)
  /* sends VIRTIO_MEDIA_CMD_MMAP
     for closed session->id */

Checking session->error after acquiring vv->vlock (or holding vv->vlock across the check) would avoid sending VIRTIO_MEDIA_CMD_MMAP for a closed session.

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 788

Quoted 6 lines
drivers/media/virtio/virtio_media_driver.c +6 -0
+	if (!(vma->vm_flags & VM_SHARED))
+		return -EINVAL;
+	if (!(vma->vm_flags & (VM_READ | VM_WRITE)))
+		return -EINVAL;
+
+	mutex_lock(&vv->vlock);

[Severity: High]
Does acquiring vv->vlock inside virtio_media_device_mmap() and virtio_media_vma_close() create an ABBA deadlock with current->mm->mmap_lock?

CPU0 CPU1
---- ----
lock(&mm->mmap_lock)

                                  lock(&vv->vlock)
lock(&vv->vlock)
                                  lock(&mm->mmap_lock)

*** DEADLOCK ***

CPU0: mmap_region() -> virtio_media_device_mmap() (or munmap() ->
virtio_media_vma_close())
CPU1: virtio_media_device_ioctl() -> video_ioctl2() -> copy_from_user() (or

      __scatterlist_builder_add_userptr() -> vb2_create_framevec())

The MM core calls f_op->mmap and vm_ops->close with mm->mmap_lock held in write mode, whereas virtio_media_device_ioctl() holds vv->vlock across user copies and userptr page pinning that fault or take mm->mmap_lock.

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 794

Quoted 6 lines
drivers/media/virtio/virtio_media_driver.c +6 -0
+
+	cmd_mmap->hdr.cmd = VIRTIO_MEDIA_CMD_MMAP;
+	cmd_mmap->hdr.__reserved = 0;
+	cmd_mmap->session_id = session->id;
+	cmd_mmap->flags =
+		(vma->vm_flags & VM_WRITE) ? VIRTIO_MEDIA_MMAP_FLAG_RW_MASK : 0;

[Severity: Medium]
When a file opened O_RDWR is mapped with PROT_READ and MAP_SHARED, does leaving VM_MAYWRITE set on the VMA allow userspace to bypass the read-only host mapping via mprotect()?

Because VM_WRITE is clear, VIRTIO_MEDIA_MMAP_FLAG_RW_MASK is not sent to the host, but VM_MAYWRITE remains set in vma->vm_flags, allowing a later mprotect(..., PROT_READ | PROT_WRITE) to make the guest page tables writable without host write permission. Should this clear VM_MAYWRITE with vm_flags_clear(vma, VM_MAYWRITE) when !(vma->vm_flags & VM_WRITE)?

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 795

Quoted 1 line
drivers/media/virtio/virtio_media_driver.c +1 -0
+	cmd_mmap->offset = vma->vm_pgoff << PAGE_SHIFT;

[Severity: Medium]
Can a 64-bit file offset >= 4 GiB silently truncate when assigned to the 32-bit cmd_mmap->offset field?

On 64-bit kernels vma->vm_pgoff is an unsigned long, so shifting it into __le32 cmd_mmap->offset without checking vma->vm_pgoff > (U32_MAX >> PAGE_SHIFT) discards the upper bits and aliases a valid 32-bit plane mem_offset instead of returning -EINVAL. Also, when mapping read-only (!(vma->vm_flags & VM_WRITE)), VM_MAYWRITE is left set on the VMA, allowing mprotect(PROT_WRITE) to upgrade guest PTE permissions afterward.

Quoted 30 lines
drivers/media/virtio/virtio_media_driver.c +30 -0
+	cmd_mmap->__reserved = 0;
+
+	sg_set_buf(&cmd_sg, cmd_mmap, sizeof(*cmd_mmap));
+	sg_mark_end(&cmd_sg);
+
+	sg_set_buf(&resp_sg, resp_mmap, sizeof(*resp_mmap));
+	sg_mark_end(&resp_sg);
+
+	/*
+	 * The host performs reference counting and is smart enough to return
+	 * the same guest physical address if this is called several times on
+	 * the same
+	 * buffer.
+	 */
+	ret = virtio_media_send_command(vv, sgs, 1, 1, sizeof(*resp_mmap),
+					NULL);
+	if (ret < 0)
+		goto end;
+
+	vma->vm_private_data = vv;
+	/*
+	 * Keep the guest address at which the buffer is mapped since we will
+	 * use that to unmap.
+	 */
+	vma->vm_pgoff = (resp_mmap->driver_addr + vv->mmap_region.addr) >>
+			PAGE_SHIFT;
+
+	/*
+	 * We cannot let the mapping be larger than the buffer.
+	 */

drivers/media/virtio/virtio_media_driver.c static __poll_t virtio_media_device_poll(struct file *file, poll_table *wait) · line 835

Quoted 10 lines
drivers/media/virtio/virtio_media_driver.c +10 -0
+	if (vma->vm_end - vma->vm_start > PAGE_ALIGN(resp_mmap->len)) {
+		dev_dbg(&video_dev->dev,
+			"invalid MMAP, as it would overflow buffer length\n");
+		ret = -EINVAL;
+		goto cleanup;
+	}
+
+	ret = io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
+				 vma->vm_end - vma->vm_start,
+				 vma->vm_page_prot);

[Severity: Medium]
Should virtio_media_device_mmap() validate that resp_mmap->driver_addr is page-aligned and that the mapped range fits within vv->mmap_region.len before calling io_remap_pfn_range()?

vv->mmap_region.len is never checked, so an out-of-bounds or overflowing resp_mmap->driver_addr or resp_mmap->len from the host would cause io_remap_pfn_range() to remap guest physical memory outside the virtio shared memory region into userspace, and an unaligned driver_addr would lose its sub-page offset when shifted into vma->vm_pgoff.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
#11 lore raw

PATCH v12 6/6 media: virtio: clear the size of legacy controls built on the stack

In reply to Brian Daniels

From: Nick Rogers <[email protected]>

A driver without a control handler receives VIDIOC_G_CTRL and VIDIOC_S_CTRL from the V4L2 core as a single extended control that the core builds on its own stack, with the control's size left uninitialized. virtio_media_send_ext_controls_ioctl() takes a nonzero size as a payload to copy from userspace, so these ioctls fail with -EINVAL whenever the stack is dirty. GStreamer's V4L2 encoders set their profile with VIDIOC_S_CTRL and cannot negotiate, and v4l2-ctl cannot read the MIN_BUFFERS controls.

Legacy controls carry a 32-bit value and never a payload, and an array that comes from userspace is copied into an allocation, never onto the stack. Clear the size of each control when the array is on the stack.

The core is being fixed to zero the structure [1]; this keeps the driver working on kernels without that fix.

[1] https://lore.kernel.org/all/[email protected]/

---
 drivers/media/virtio/virtio_media_ioctls.c | 25 ++++++++++++++++++++++
 1 file changed, 25 insertions(+)
drivers/media/virtio/virtio_media_ioctls.c +25 -0
index aa56efe9a..ad240073a 100644
@@ -6,6 +6,7 @@
  * Copyright (c) 2024-2026 Google LLC.
  */
 
+#include <linux/sched/task_stack.h>
 #include <linux/mutex.h>
 #include <linux/videodev2.h>
 #include <linux/virtio_config.h>
@@ -593,11 +594,31 @@ static int virtio_media_querycap(struct file *file, void *fh,
  * Extended control ioctls are handled mostly identically.
  */
 
+/*
+ * VIDIOC_G_CTRL and VIDIOC_S_CTRL reach a driver without a control handler
+ * as one extended control the V4L2 core builds on its own stack, with its
+ * size left uninitialized. They carry a 32-bit value and never a payload,
+ * so a size there is stack garbage, which would be sent as a user pointer
+ * to copy and fail the ioctl. An array from userspace is never on the
+ * stack: the core copies it into an allocation.
+ */
+static void virtio_media_legacy_ctrl(struct v4l2_ext_controls *ctrls)
+{
+	u32 i;
+
+	if (!ctrls->count || !object_is_on_stack(ctrls->controls))
+		return;
+	for (i = 0; i < ctrls->count; i++)
+		ctrls->controls[i].size = 0;
+}
+
 static int virtio_media_g_ext_ctrls(struct file *file, void *fh,
 				    struct v4l2_ext_controls *ctrls)
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
+	virtio_media_legacy_ctrl(ctrls);
+
 	return virtio_media_send_ext_controls_ioctl(vfh, VIDIOC_G_EXT_CTRLS,
 						    ctrls);
 }
@@ -607,6 +628,8 @@ static int virtio_media_s_ext_ctrls(struct file *file, void *fh,
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
+	virtio_media_legacy_ctrl(ctrls);
+
 	return virtio_media_send_ext_controls_ioctl(vfh, VIDIOC_S_EXT_CTRLS,
 						    ctrls);
 }
@@ -616,6 +639,8 @@ static int virtio_media_try_ext_ctrls(struct file *file, void *fh,
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
+	virtio_media_legacy_ctrl(ctrls);
+
 	return virtio_media_send_ext_controls_ioctl(vfh, VIDIOC_TRY_EXT_CTRLS,
 						    ctrls);
 }
Signature · 1 line
2.56.1.750.gf70dc682cf-goog
#12 lore raw

Re: [PATCH v12 6/6] media: virtio: clear the size of legacy controls built on the stack

Thank you for your contribution! Sashiko AI review found 3 potential issues to consider: - [High] media: virtio: framevecs array leak in scatterlist_builder_free_framevecs() - [Medium] media…

Thank you for your contribution! Sashiko AI review found 3 potential issues to consider:
- [High] media: virtio: framevecs array leak in scatterlist_builder_free_framevecs()
- [Medium] media: virtio: incomplete stack control init in virtio_media_legacy_ctrl()
- [Medium] media: virtio: framevec and pinned page leaks in virtio_media_send_ext_controls_ioctl()
--

commit 623bf5e3612ed0e69ea0cdb41218ea9e8d7b62ef
Author: Nick Rogers <[email protected]>

media: virtio: clear the size of legacy controls built on the stack

This commit adds a helper that checks if the extended control array is on the kernel stack and zeroes each control's size field before forwarding extended control ioctls to the VirtIO host.

Quoted 4 lines
drivers/media/virtio/virtio_media_ioctls.c +0 -0
index aa56efe9a08c2..ad240073aec9f 100644

[ ... ]

Quoted 11 lines
drivers/media/virtio/virtio_media_ioctls.c +7 -0
@@ -593,11 +594,31 @@ static int virtio_media_querycap(struct file *file, void *fh,
  * Extended control ioctls are handled mostly identically.
  */
 
+/*
+ * VIDIOC_G_CTRL and VIDIOC_S_CTRL reach a driver without a control handler
+ * as one extended control the V4L2 core builds on its own stack, with its
+ * size left uninitialized. They carry a 32-bit value and never a payload,
+ * so a size there is stack garbage, which would be sent as a user pointer
+ * to copy and fail the ioctl. An array from userspace is never on the
+ * stack: the core copies it into an allocation.

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_querycap(struct file *file, void *fh, · line 613

Quoted 10 lines
drivers/media/virtio/virtio_media_ioctls.c +10 -0
+ */
+static void virtio_media_legacy_ctrl(struct v4l2_ext_controls *ctrls)
+{
+	u32 i;
+
+	if (!ctrls->count || !object_is_on_stack(ctrls->controls))
+		return;
+	for (i = 0; i < ctrls->count; i++)
+		ctrls->controls[i].size = 0;
+}

[Severity: Medium]
Does clearing only ctrls->controls[i].size still leave uninitialized kernel stack fields that get sent across the virtqueue to the host?

When v4l_g_ctrl() and v4l_s_ctrl() build struct v4l2_ext_controls and struct v4l2_ext_control on the stack without zero-initializing them, ctrls->error_idx, ctrls->request_fd, struct alignment padding, and the upper 32 bits of the 8-byte value64 union in ctrl remain uninitialized. scatterlist_builder_add_ext_ctrls() transmits the entire sizeof(*ctrls) and sizeof(ctrls->controls[0]) * ctrls->count buffers to the host, leaking guest kernel stack bytes and passing stack garbage in request_fd, error_idx, and the upper 32 bits of value64.

Also, detecting legacy controls in the driver with object_is_on_stack() (including in virtio_media_try_ext_ctrls(), which VIDIOC_G_CTRL and VIDIOC_S_CTRL never call) works around v4l_g_ctrl() and v4l_s_ctrl() in drivers/media/v4l2-core/v4l2-ioctl.c rather than zero-initializing the stack structures there.

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_querycap(struct file *file, void *fh, · line 624

Quoted 11 lines
drivers/media/virtio/virtio_media_ioctls.c +3 -0
+
 static int virtio_media_g_ext_ctrls(struct file *file, void *fh,
 				    struct v4l2_ext_controls *ctrls)
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
+	virtio_media_legacy_ctrl(ctrls);
+
 	return virtio_media_send_ext_controls_ioctl(vfh, VIDIOC_G_EXT_CTRLS,
 						    ctrls);
 }

[Severity: Medium]
In virtio_media_send_ext_controls_ioctl() (introduced earlier in this series in commit "media: virtio: Add extended controls support"), do the two post-command validation checks leak builder.framevecs and leave user pages permanently pinned?

drivers/media/virtio/virtio_media_ioctls.c:virtio_media_send_ext_controls_ioctl() {
    ...
	if (ctrls->count > num_ctrls)
		return -ENOSPC;
	if (ret < 0) {
    ...
		goto free_framevecs;
	}

	resp_len -= sizeof(struct virtio_media_resp_ioctl);

	/* Make sure that the reply's length covers our v4l2_ext_controls */
	if (resp_len < sizeof(*ctrls))
		return -EINVAL;
    ...
free_framevecs:
	scatterlist_builder_free_framevecs(&builder);
	return ret;
}

When a request includes controls with ctrl->size > 0, returning -ENOSPC or -EINVAL directly after virtio_media_send_command() skips free_framevecs, leaking builder.framevecs and never calling vb2_destroy_framevec() on the pinned user buffers.

drivers/media/virtio/virtio_media_ioctls.c static int virtio_media_querycap(struct file *file, void *fh, · line 624

Quoted 11 lines

static int virtio_media_s_ext_ctrls(struct file *file, void *fh,

drivers/media/virtio/virtio_media_ioctls.c +2 -0
 				    struct v4l2_ext_controls *ctrls)
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
+	virtio_media_legacy_ctrl(ctrls);
+
 	return virtio_media_send_ext_controls_ioctl(vfh, VIDIOC_S_EXT_CTRLS,
 						    ctrls);
 }

[Severity: High]
Also in the free_framevecs path of virtio_media_send_ext_controls_ioctl() (from commit "media: virtio: Add extended controls support"), does scatterlist_builder_free_framevecs() leak builder->framevecs when an error occurs before the first framevec is created?

drivers/media/virtio/scatterlist_builder.c:scatterlist_builder_free_framevecs() {
	if (builder->cur_framevec && builder->framevecs) {
		struct frame_vector *vec;

		while (builder->cur_framevec--) {
			vec = builder->framevecs[builder->cur_framevec];
			vb2_destroy_framevec(vec, true);
		}

		kfree(builder->framevecs);
	}

	builder->framevecs = NULL;
    ...
}

scatterlist_builder_allocate_framevecs() allocates builder->framevecs whenever any control has ctrl->size > 0, while builder->cur_framevec is still 0. If an unprivileged user passes an invalid ctrl->ptr on the first payload control, vb2_create_framevec() fails with cur_framevec == 0 and scatterlist_builder_free_framevecs() skips kfree(builder->framevecs) before clearing the pointer.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=6