[PATCH 4/6] rust: media: videobuf2: add a videobuf2 abstraction

Daniel Almeida
2023-04-06T21:58:41Z

Add a videobuf2 abstraction. Notably, only vb2_v4l2_buffer is supported
as the subsystem-specific struct.

Signed-off-by: Daniel Almeida <daniel.almeida@collabora.com>
---
rust/bindings/bindings_helper.h | 3 +
rust/kernel/media/mod.rs | 1 +
rust/kernel/media/videobuf2/core.rs | 552 ++++++++++++++++++++++++++++
rust/kernel/media/videobuf2/mod.rs | 5 +
4 files changed, 561 insertions(+)
create mode 100644 rust/kernel/media/videobuf2/core.rs
create mode 100644 rust/kernel/media/videobuf2/mod.rs

diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index 3b3d6fcf110f..3153894f426b 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -36,6 +36,9 @@
#include <linux/uaccess.h>
#include <linux/uio.h>
#include <linux/videodev2.h>
+#include <media/videobuf2-core.h>
+#include <media/videobuf2-v4l2.h>
+#include <media/videobuf2-dma-sg.h>

/* `bindgen` gets confused at certain things. */
const gfp_t BINDINGS_GFP_KERNEL = GFP_KERNEL;
diff --git a/rust/kernel/media/mod.rs b/rust/kernel/media/mod.rs
index 342e66382719..95b11544af8d 100644
--- a/rust/kernel/media/mod.rs
+++ b/rust/kernel/media/mod.rs
@@ -3,3 +3,4 @@
//! Media subsystem

pub mod v4l2;
+pub mod videobuf2;
diff --git a/rust/kernel/media/videobuf2/core.rs b/rust/kernel/media/videobuf2/core.rs
new file mode 100644
index 000000000000..40ab06475a8e
--- /dev/null
+++ b/rust/kernel/media/videobuf2/core.rs
@@ -0,0 +1,552 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Video Buffer 2 Core Framework
+//!
+//! C header: [`include/media/videobuf2-core.h`](../../../../include/media/videobuf2-core.h)
+
+use core::cell::UnsafeCell;
+use core::marker::PhantomData;
+use core::ops::Deref;
+
+use alloc::slice;
+
+use crate::device::RawDevice;
+use crate::error::from_kernel_result;
+use crate::media::v4l2::{enums, mmap};
+use crate::prelude::*;
+use crate::sync::ffi_mutex::FfiMutex;
+use crate::sync::Arc;
+use crate::ForeignOwnable;
+
+/// The queue operations to be implemented by drivers.
+#[vtable]
+pub trait QueueOperations {
+ /// The subsystem-specific data, usually bindings::vb2_v4l2_buffer.
+ type SubsystemSpecificData = bindings::vb2_v4l2_buffer;
+ /// The driver specific data.
+ type DriverSpecificData;
+ /// The private data held in the queue.
+ type PrivateData: ForeignOwnable
+ + Deref<Target = PrivateData<Self::SubsystemSpecificData, Self::DriverSpecificData>>;
+
+ // Note: alloc_devs is TODO
+
+ /// Called as part of the queue_setup() queue operation.
+ fn queue_setup(
+ queue: &QueueRef,
+ private_data: &mut Self::PrivateData,
+ num_buffers: &mut u32,
+ num_planes: &mut u32,
+ sizes: &mut [u32],
+ ) -> Result;
+
+ /// Called as part of the wait_prepare() queue operation.
+ fn wait_prepare(_queue: &QueueRef, _private_data: &mut Self::PrivateData) {}
+
+ /// Called as part of the wait_finish() queue operation.
+ fn wait_finish(_queue: &QueueRef, _private_data: &mut Self::PrivateData) {}
+
+ /// Optional. Called as part of the buf_out_validate() queue operation.
+ fn buf_out_validate(_buffer: &Buffer, _private_data: &mut Self::PrivateData) -> Result {
+ Ok(())
+ }
+
+ /// Called as part of the buf_init() queue operation.
+ fn buf_init(_buffer: &Buffer, _private_data: &mut Self::PrivateData) -> Result;
+ /// Called as part of the buf_prepare() queue operation.
+ fn buf_prepare(_buffer: &Buffer, _private_data: &mut Self::PrivateData) -> Result;
+ /// Called as part of the buf_finish() queue operation.
+ fn buf_finish(_buffer: &Buffer, _private_data: &mut Self::PrivateData) {}
+ /// Called as part of the buf_cleanup() queue operation.
+ fn buf_cleanup(_buffer: &Buffer, _private_data: &mut Self::PrivateData);
+
+ /// Called as part of the prepare_streaming() queue operation.
+ fn prepare_streaming(_queue: &QueueRef, _private_data: &mut Self::PrivateData) -> Result {
+ Ok(())
+ }
+ /// Called as part of the start_streaming() queue operation.
+ fn start_streaming(
+ _queue: &QueueRef,
+ _private_data: &mut Self::PrivateData,
+ _count: u32,
+ ) -> Result;
+
+ /// Called as part of the unprepare_streaming() queue operation.
+ fn unprepare_streaming(_queue: &QueueRef, _private_data: &mut Self::PrivateData) {}
+ /// Called as part of the stop_streaming() queue operation.
+ fn stop_streaming(_queue: &QueueRef, _private_data: &mut Self::PrivateData);
+ /// Called as part of the buf_queue() queue operation.
+ fn buf_queue(_buffer: &Buffer, _private_data: &mut Self::PrivateData);
+ /// Called as part of the buf_request_complete() queue operation.
+ fn buf_request_complete(_buffer: &Buffer, _private_data: &mut Self::PrivateData) {}
+}
+
+type AsPrivateData<T> = <T as QueueOperations>::PrivateData;
+
+struct Vb2OperationsVtable<T: QueueOperations>(PhantomData<T>);
+
+impl<T: QueueOperations> Vb2OperationsVtable<T> {
+ unsafe extern "C" fn queue_setup_callback(
+ q: *mut bindings::vb2_queue,
+ num_buffers: *mut core::ffi::c_uint,
+ num_planes: *mut core::ffi::c_uint,
+ sizes: *mut core::ffi::c_uint,
+ _alloc_devs: *mut *mut bindings::device,
+ ) -> core::ffi::c_int {
+ from_kernel_result! {
+ // SAFETY: `q` is a pointer returned by the kernel and outlives the
+ // QueueRef as QueueRef is dropped by the end of this function
+ let queue = unsafe { QueueRef::from_ptr(q) };
+
+ // SAFETY: into_foreign() was called in Queue::new() and this
+ // function is called because we set the ops during Queue::new().
+ // Furthermore, from_pointer() is only called when Queue is dropped,
+ // at which point we cannot be called anymore because we will have
+ // called vb2_queue_release. There are no other concurrent uses of
+ // the pointer until the guard is dropped.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*q).drv_priv) };
+
+ // SAFETY: sizes is known to be of size bindings::VB2_MAX_PLANES as
+ // per videobuf2-core.c::vb2_core_reqbufs()
+ let sizes = unsafe { slice::from_raw_parts_mut(sizes as _, bindings::VB2_MAX_PLANES as usize) };
+
+ // SAFETY: these are both safe, since they're initialized in
+ // videobuf2-core.c::vb2_core_reqbufs() and they are not read from any
+ // other pointer while the reference exists, since they live in the
+ // stack of vb2_core_reqbufs().
+ let num_buffers = unsafe { num_buffers.as_mut().ok_or(EINVAL) }?;
+ let num_planes = unsafe { num_planes.as_mut().ok_or(EINVAL) }?;
+
+ T::queue_setup(&queue, &mut private_data, num_buffers, num_planes, sizes)?;
+ Ok(0)
+ }
+ }
+
+ unsafe extern "C" fn wait_prepare_callback(q: *mut bindings::vb2_queue) {
+ // SAFETY: QueueRef has a shorter lifetime if compared to the lifetime
+ // of q. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let queue = unsafe { QueueRef::from_ptr(q) };
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*q).drv_priv) };
+ T::wait_prepare(&queue, &mut private_data);
+ }
+
+ unsafe extern "C" fn wait_finish_callback(q: *mut bindings::vb2_queue) {
+ // Same safety comment from wait_prepare_callback applies.
+ let queue = unsafe { QueueRef::from_ptr(q) };
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*q).drv_priv) };
+ T::wait_finish(&queue, &mut private_data);
+ }
+
+ unsafe extern "C" fn buf_out_validate_callback(
+ vb: *mut bindings::vb2_buffer,
+ ) -> core::ffi::c_int {
+ from_kernel_result! {
+ // SAFETY: Buffer has a shorter lifetime if compared to the lifetime
+ // of vb. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let buf = unsafe { Buffer::from_ptr(vb) };
+ let queue_ptr = buf.queue_ptr();
+
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*queue_ptr).drv_priv) };
+
+ T::buf_out_validate(&buf, &mut private_data)?;
+ Ok(0)
+ }
+ }
+
+ unsafe extern "C" fn buf_init_callback(vb: *mut bindings::vb2_buffer) -> core::ffi::c_int {
+ from_kernel_result! {
+ // SAFETY: Buffer has a shorter lifetime if compared to the lifetime
+ // of vb. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let buf = unsafe { Buffer::from_ptr(vb) };
+ let queue_ptr = buf.queue_ptr();
+
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*queue_ptr).drv_priv) };
+
+ T::buf_init(&buf, &mut private_data)?;
+ Ok(0)
+ }
+ }
+
+ unsafe extern "C" fn buf_prepare_callback(vb: *mut bindings::vb2_buffer) -> core::ffi::c_int {
+ from_kernel_result! {
+ // SAFETY: Buffer has a shorter lifetime if compared to the lifetime
+ // of vb. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let buf = unsafe { Buffer::from_ptr(vb) };
+ let queue_ptr = buf.queue_ptr();
+
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*queue_ptr).drv_priv) };
+
+ T::buf_prepare(&buf, &mut private_data)?;
+ Ok(0)
+ }
+ }
+
+ unsafe extern "C" fn buf_finish_callback(vb: *mut bindings::vb2_buffer) {
+ // SAFETY: Buffer has a shorter lifetime if compared to the lifetime
+ // of vb. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let buf = unsafe { Buffer::from_ptr(vb) };
+ let queue_ptr = buf.queue_ptr();
+
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*queue_ptr).drv_priv) };
+
+ T::buf_finish(&buf, &mut private_data);
+ }
+
+ unsafe extern "C" fn buf_cleanup_callback(vb: *mut bindings::vb2_buffer) {
+ // SAFETY: Buffer has a shorter lifetime if compared to the lifetime
+ // of vb. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let buf = unsafe { Buffer::from_ptr(vb) };
+ let queue_ptr = buf.queue_ptr();
+
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*queue_ptr).drv_priv) };
+
+ T::buf_cleanup(&buf, &mut private_data);
+ }
+
+ unsafe extern "C" fn prepare_streaming_callback(
+ q: *mut bindings::vb2_queue,
+ ) -> core::ffi::c_int {
+ from_kernel_result! {
+ // SAFETY: QueueRef has a shorter lifetime if compared to the lifetime
+ // of q. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let queue = unsafe { QueueRef::from_ptr(q) };
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*q).drv_priv) };
+ T::prepare_streaming(&queue, &mut private_data)?;
+ Ok(0)
+ }
+ }
+
+ unsafe extern "C" fn start_streaming_callback(
+ q: *mut bindings::vb2_queue,
+ count: core::ffi::c_uint,
+ ) -> core::ffi::c_int {
+ from_kernel_result! {
+ // Same safety comments from queue_setup() apply.
+ let queue = unsafe { QueueRef::from_ptr(q) };
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*q).drv_priv) };
+ T::start_streaming(&queue, &mut private_data, count)?;
+ Ok(0)
+ }
+ }
+
+ unsafe extern "C" fn stop_streaming_callback(q: *mut bindings::vb2_queue) {
+ // Same safety comments from queue_setup() apply.
+ let queue = unsafe { QueueRef::from_ptr(q) };
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*q).drv_priv) };
+ T::stop_streaming(&queue, &mut private_data);
+ }
+
+ unsafe extern "C" fn unprepare_streaming_callback(q: *mut bindings::vb2_queue) {
+ // SAFETY: QueueRef has a shorter lifetime if compared to the lifetime
+ // of q. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let queue = unsafe { QueueRef::from_ptr(q) };
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*q).drv_priv) };
+ T::unprepare_streaming(&queue, &mut private_data);
+ }
+
+ unsafe extern "C" fn buf_queue_callback(vb: *mut bindings::vb2_buffer) {
+ // SAFETY: Buffer has a shorter lifetime if compared to the lifetime
+ // of vb. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let buf = unsafe { Buffer::from_ptr(vb) };
+ let queue_ptr = buf.queue_ptr();
+
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*queue_ptr).drv_priv) };
+
+ T::buf_queue(&buf, &mut private_data);
+ }
+
+ unsafe extern "C" fn buf_request_complete_callback(vb: *mut bindings::vb2_buffer) {
+ // SAFETY: Buffer has a shorter lifetime if compared to the lifetime
+ // of vb. The pointer is passed in by the kernel and thus it is assumed
+ // valid.
+ let buf = unsafe { Buffer::from_ptr(vb) };
+ let queue_ptr = buf.queue_ptr();
+
+ // Same safety comments from queue_setup_callback apply.
+ let mut private_data = unsafe { T::PrivateData::borrow_mut((*queue_ptr).drv_priv) };
+
+ T::buf_request_complete(&buf, &mut private_data);
+ }
+
+ const VTABLE: bindings::vb2_ops = bindings::vb2_ops {
+ queue_setup: Some(Self::queue_setup_callback),
+ wait_prepare: if T::HAS_WAIT_PREPARE {
+ Some(Self::wait_prepare_callback)
+ } else {
+ None
+ },
+ wait_finish: if T::HAS_WAIT_FINISH {
+ Some(Self::wait_finish_callback)
+ } else {
+ None
+ },
+ buf_out_validate: if T::HAS_BUF_OUT_VALIDATE {
+ Some(Self::buf_out_validate_callback)
+ } else {
+ None
+ },
+ buf_init: Some(Self::buf_init_callback),
+ buf_prepare: Some(Self::buf_prepare_callback),
+ buf_finish: if T::HAS_BUF_FINISH {
+ Some(Self::buf_finish_callback)
+ } else {
+ None
+ },
+ buf_cleanup: Some(Self::buf_cleanup_callback),
+ start_streaming: Some(Self::start_streaming_callback),
+ stop_streaming: Some(Self::stop_streaming_callback),
+ buf_queue: Some(Self::buf_queue_callback),
+ buf_request_complete: if T::HAS_BUF_REQUEST_COMPLETE {
+ Some(Self::buf_request_complete_callback)
+ } else {
+ None
+ },
+ prepare_streaming: if T::HAS_PREPARE_STREAMING {
+ Some(Self::prepare_streaming_callback)
+ } else {
+ None
+ },
+ unprepare_streaming: if T::HAS_UNPREPARE_STREAMING {
+ Some(Self::unprepare_streaming_callback)
+ } else {
+ None
+ },
+ };
+
+ fn build() -> &'static bindings::vb2_ops {
+ &Self::VTABLE
+ }
+}
+
+/// The IO modes as defined by `struct vb2_io_mode::VB2_*`.
+#[allow(missing_docs)]
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+pub enum IoModes {
+ Mmap = bindings::vb2_io_modes_VB2_MMAP as isize,
+ UserPtr = bindings::vb2_io_modes_VB2_USERPTR as isize,
+ Read = bindings::vb2_io_modes_VB2_READ as isize,
+ Write = bindings::vb2_io_modes_VB2_WRITE as isize,
+ DmaBuf = bindings::vb2_io_modes_VB2_DMABUF as isize,
+}
+
+/// Controls the value assigned to the `mem_ops` member.
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+pub enum MemOps {
+ /// Sets `bindings::vb2_dma_sg_memops`.
+ DmaSg,
+}
+
+/// Represents the driver-specific buffer structure. This must contain the
+/// subsystem-specific structure as its first member. For now, only `struct
+/// vb2_v4l2_buffer` is supported as the subsystem-specific structure.
+#[repr(C)]
+pub struct PrivateData<T, U> {
+ subsystem_specific: T,
+ driver_specific: U,
+}
+
+impl<T, U> PrivateData<T, U> {
+ /// Returns the size of the driver-specific struct.
+ pub fn driver_data_size(&self) -> usize {
+ core::mem::size_of_val(&self.driver_specific)
+ }
+
+ /// Returns the subsystem-specific struct.
+ pub fn subsystem_specific(&self) -> &T {
+ &self.subsystem_specific
+ }
+
+ /// Returns the driver-specific struct.
+ pub fn driver_specific_mut(&mut self) -> &mut U {
+ &mut self.driver_specific
+ }
+}
+
+impl PrivateData<bindings::vb2_v4l2_buffer, U> {
+ /// Creates a new instance.
+ pub fn new(data: U) -> Self {
+ Self {
+ subsystem_specific: Default::default(),
+ driver_specific: data,
+ }
+ }
+}
+
+/// A struct containing the parameters for queue creation.
+#[allow(missing_docs)]
+pub struct QueueCreateInfo<'a, T: QueueOperations, U: RawDevice> {
+ pub buf_type: enums::BufType,
+ pub io_modes: &'a [IoModes],
+ pub dev: Arc,
+ pub timestamp_flags: &'a [mmap::BufferFlag],
+ pub lock: Option<Pin<Box<FfiMutex>>>,
+ pub min_buffers_needed: usize,
+ pub gfp_flags: u32,
+ pub mem_ops: MemOps,
+ pub requires_requests: bool,
+ pub supports_requests: bool,
+ pub private_data: Option<T::PrivateData>,
+}
+
+/// An owned wrapper over `struct vb2_queue`.
+pub struct Queue<T: QueueOperations> {
+ inner: UnsafeCell<bindings::vb2_queue>,
+ has_private_data: bool,
+ _lock: Option<Pin<Box<FfiMutex>>>,
+ _p1: PhantomData<T>,
+}
+
+impl<T: QueueOperations> Queue<T> {
+ /// Creates a new queue.
+ pub fn new<U: RawDevice>(create_info: QueueCreateInfo<'_, T, U>) -> Result<Self> {
+ let QueueCreateInfo {
+ buf_type,
+ io_modes,
+ dev,
+ timestamp_flags,
+ mut lock,
+ min_buffers_needed,
+ gfp_flags,
+ mem_ops,
+ requires_requests,
+ supports_requests,
+ private_data,
+ } = create_info;
+
+ let mut io_modes_val = 0;
+ for io_mode in io_modes {
+ io_modes_val |= *io_mode as u32;
+ }
+
+ let mut timestamp_flags_val = 0;
+ for timestamp_flag in timestamp_flags {
+ timestamp_flags_val |= *timestamp_flag as u32;
+ }
+
+ let (buf_struct_size, drv_priv, has_private_data) = if let Some(private_data) = private_data
+ {
+ (
+ private_data.driver_data_size(),
+ private_data.into_foreign() as *mut _,
+ true,
+ )
+ } else {
+ (0, core::ptr::null_mut(), false)
+ };
+
+ let mut inner = bindings::vb2_queue {
+ type_: buf_type as _,
+ io_modes: io_modes_val,
+ dev: dev.raw_device(),
+ ..Default::default()
+ };
+
+ if let Some(ref mut lock) = lock {
+ let raw_lock = unsafe { lock.as_mut().raw() };
+ inner.lock = raw_lock;
+ }
+
+ inner.drv_priv = drv_priv;
+ inner.buf_struct_size = buf_struct_size as u32;
+ inner.timestamp_flags = timestamp_flags_val;
+ inner.gfp_flags = gfp_flags;
+ inner.min_buffers_needed = min_buffers_needed as u32;
+
+ inner.set_requires_requests(requires_requests as u32);
+ inner.set_supports_requests(supports_requests as u32);
+
+ inner.ops = Vb2OperationsVtable::<T>::build();
+
+ inner.mem_ops = match mem_ops {
+ // SAFETY: this will be called by the C code.
+ MemOps::DmaSg => unsafe { &bindings::vb2_dma_sg_memops as _ },
+ };
+
+ // SAFETY: just a FFI call and we have just initialized `inner`.
+ unsafe {
+ bindings::vb2_queue_init(&mut inner as _);
+ }
+
+ let inner = UnsafeCell::new(inner);
+
+ Ok(Self {
+ inner,
+ has_private_data,
+ _p1: PhantomData,
+ _lock: lock,
+ })
+ }
+}
+
+impl<T: QueueOperations> Drop for Queue<T> {
+ fn drop(&mut self) {
+ if self.has_private_data {
+ // SAFETY: into_pointer() was previously called during new() and
+ // `self.has_private_data` was set accordingly.
+ unsafe {
+ AsPrivateData::<T>::from_foreign(self.inner.get_mut().drv_priv);
+ }
+ }
+
+ // SAFETY: just a FFI call and we have initialized `inner` during new().
+ unsafe {
+ bindings::vb2_queue_release(self.inner.get());
+ }
+ }
+}
+
+// SAFETY: This is a wrapper over the `struct vb2_queue` C type, which can be
+// used from any thread.
+unsafe impl<T: QueueOperations> Send for Queue<T> {}
+
+/// A wrapper over a pointer to `struct vb2_queue`.
+pub struct QueueRef {
+ _ptr: *mut bindings::vb2_queue,
+}
+
+impl QueueRef {
+ /// # Safety
+ /// The caller must ensure that `ptr` is valid and remains valid for the lifetime of the
+ /// returned [`QueueRef`] instance.
+ unsafe fn from_ptr(ptr: *mut bindings::vb2_queue) -> Self {
+ Self { _ptr: ptr }
+ }
+}
+
+/// A wrapper over a pointer to `struct vb2_buffer`.
+pub struct Buffer {
+ ptr: *mut bindings::vb2_buffer,
+}
+
+impl Buffer {
+ /// # Safety
+ /// The caller must ensure that `ptr` is valid and remains valid for the lifetime of the
+ /// returned [`Buffer`] instance.
+ pub(crate) unsafe fn from_ptr(ptr: *mut bindings::vb2_buffer) -> Self {
+ Self { ptr }
+ }
+
+ pub(crate) fn queue_ptr(&self) -> *mut bindings::vb2_queue {
+ // SAFETY: self.ptr should be valid according to the safety requirements in `from_raw()`.
+ unsafe { (*self.ptr).vb2_queue }
+ }
+}
diff --git a/rust/kernel/media/videobuf2/mod.rs b/rust/kernel/media/videobuf2/mod.rs
new file mode 100644
index 000000000000..6b0be2c7a14d
--- /dev/null
+++ b/rust/kernel/media/videobuf2/mod.rs
@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Videobuf2 Framework
+
+pub mod core;
--
2.40.0