From: Simon Song <xinmengs@nvidia.com>
To: <dakr@kernel.org>, <acourbot@nvidia.com>, <kvm@vger.kernel.org>,
<rust-for-linux@vger.kernel.org>, <nova-gpu@lists.linux.dev>,
<linux-pci@vger.kernel.org>
Cc: Zhi Wang <zhiw@nvidia.com>, <alex@shazbot.org>, <jgg@nvidia.com>,
<yishaih@nvidia.com>, <skolothumtho@nvidia.com>,
<kevin.tian@intel.com>, <airlied@gmail.com>, <simona@ffwll.ch>,
<ojeda@kernel.org>, <alex.gaynor@gmail.com>,
<boqun.feng@gmail.com>, <gary@garyguo.net>,
<bjorn3_gh@protonmail.com>, <lossin@kernel.org>,
<a.hindborg@kernel.org>, <aliceryhl@google.com>,
<tmgross@umich.edu>, <jhubbard@nvidia.com>,
<ecourtney@nvidia.com>, <cjia@nvidia.com>, <smitra@nvidia.com>,
<kjaju@nvidia.com>, <alkumar@nvidia.com>, <ankita@nvidia.com>,
<aniketa@nvidia.com>, <kwankhede@nvidia.com>,
<targupta@nvidia.com>, <linux-kernel@vger.kernel.org>,
<zhiwang@kernel.org>, <boqun@kernel.org>,
<daniel.almeida@collabora.com>, <tamird@kernel.org>,
<work@onurozkan.dev>, <jgg@ziepe.ca>, <bhelgaas@google.com>,
<kwilczynski@kernel.org>, <dri-devel@lists.freedesktop.org>,
<peter@colberg.org>, <xinmengs@nvidia.com>
Subject: [PATCH v3 6/9] rust: vfio: add common VFIO device handling
Date: Thu, 19 Nov 2026 13:50:41 -0800 [thread overview]
Message-ID: <20261119215046.2892839-7-xinmengs@nvidia.com> (raw)
In-Reply-To: <20261119215046.2892839-1-xinmengs@nvidia.com>
From: Zhi Wang <zhiw@nvidia.com>
A VFIO PCI device contains a VFIO device. Expose that relationship in
Rust so common device handling is independent of PCI resources.
Add vfio::DeviceBase, a C VFIO device structure followed by pointers to
callback data, and vfio::Device, its alias for struct vfio_device. The
data is registration data and data kept from the first successful open
until the last close, which can borrow the former. Share reference
counting and callback-data lifetime handling in vfio.
The helpers are unused until the next patch adds the PCI abstraction.
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
rust/bindings/bindings_helper.h | 2 +
rust/kernel/lib.rs | 2 +
rust/kernel/vfio.rs | 430 ++++++++++++++++++++++++++++++++
3 files changed, 434 insertions(+)
create mode 100644 rust/kernel/vfio.rs
diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index 3791af0aadc7..a5781bc1ea85 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -93,6 +93,7 @@
#include <linux/task_work.h>
#include <linux/tracepoint.h>
#include <linux/usb.h>
+#include <linux/vfio.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/xarray.h>
@@ -115,6 +116,7 @@
const size_t RUST_CONST_HELPER_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;
const size_t RUST_CONST_HELPER_ARCH_KMALLOC_MINALIGN = ARCH_KMALLOC_MINALIGN;
const size_t RUST_CONST_HELPER_PAGE_SIZE = PAGE_SIZE;
+const unsigned int RUST_CONST_HELPER_VFIO_DEVICE_RESET = VFIO_DEVICE_RESET;
const size_t RUST_CONST_HELPER_GENLMSG_DEFAULT_SIZE = GENLMSG_DEFAULT_SIZE;
const gfp_t RUST_CONST_HELPER_GFP_ATOMIC = GFP_ATOMIC;
const gfp_t RUST_CONST_HELPER_GFP_KERNEL = GFP_KERNEL;
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 1ab41129d557..10a8e7de0d9c 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -147,6 +147,8 @@
pub mod uaccess;
#[cfg(CONFIG_USB = "y")]
pub mod usb;
+#[cfg(CONFIG_VFIO)]
+pub mod vfio;
pub mod workqueue;
pub mod xarray;
diff --git a/rust/kernel/vfio.rs b/rust/kernel/vfio.rs
new file mode 100644
index 000000000000..bc50647a2437
--- /dev/null
+++ b/rust/kernel/vfio.rs
@@ -0,0 +1,430 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Virtual Function I/O (VFIO) devices and callback data.
+//!
+//! [`DeviceBase`] combines a C VFIO device structure with the data its callbacks use.
+//! [`Device`] is an alias of it for `struct vfio_device`.
+//!
+//! C header: [`include/linux/vfio.h`](srctree/include/linux/vfio.h)
+
+use crate::{
+ bindings,
+ prelude::*,
+ sync::aref::AlwaysRefCounted,
+ types::{
+ NotThreadSafe,
+ Opaque, //
+ },
+ uaccess::{
+ UserPtr,
+ UserSlice, //
+ }, //
+};
+use core::{
+ cell::UnsafeCell,
+ marker::PhantomData,
+ ptr::NonNull, //
+};
+
+/// Reset the VFIO device.
+pub const DEVICE_RESET: u32 = bindings::VFIO_DEVICE_RESET;
+
+/// The context in which a VFIO device reference is valid.
+///
+/// Callback views can only be borrowed from the corresponding VFIO trampoline.
+/// They cannot be refcounted or shared across threads.
+pub trait DeviceContext: private::Sealed {}
+
+/// A callback context in which VFIO keeps the device open.
+///
+/// Registration data and open data are available throughout such a callback.
+pub trait IoContext: DeviceContext {}
+
+/// An ordinary device reference, without callback-specific operations.
+pub struct Normal;
+
+/// The device is undergoing its exclusive first-open callback.
+pub struct Open;
+
+/// The device is borrowed for a VFIO ioctl callback on the current thread.
+pub struct Ioctl;
+
+/// The device is borrowed for a VFIO read callback on the current thread.
+pub struct Read;
+
+/// The device is borrowed for a VFIO write callback on the current thread.
+pub struct Write;
+
+/// The device is borrowed for a VFIO mmap callback on the current thread.
+pub struct Mmap;
+
+/// The device is borrowed for a VFIO region-info callback on the current thread.
+pub struct GetRegionInfo;
+
+mod private {
+ pub trait Sealed {}
+
+ impl Sealed for super::Normal {}
+ impl Sealed for super::Open {}
+ impl Sealed for super::Write {}
+ impl Sealed for super::Mmap {}
+ impl Sealed for super::Ioctl {}
+ impl Sealed for super::Read {}
+ impl Sealed for super::GetRegionInfo {}
+}
+
+impl DeviceContext for Normal {}
+impl DeviceContext for Open {}
+impl DeviceContext for Write {}
+impl DeviceContext for Mmap {}
+impl DeviceContext for Ioctl {}
+impl DeviceContext for Read {}
+impl DeviceContext for GetRegionInfo {}
+
+impl IoContext for Write {}
+impl IoContext for Mmap {}
+impl IoContext for Ioctl {}
+impl IoContext for Read {}
+impl IoContext for GetRegionInfo {}
+
+/// The data the driver of a [`Device`] shares with its callbacks.
+///
+/// Bus-specific devices take the data types from their own trait.
+pub trait Operations: Sized + Send + Sync + 'static {
+ /// Data owned by the registration and passed to VFIO callbacks.
+ ///
+ /// It can borrow resources of the driver's binding for `'a`. Per-device state lives here.
+ type RegistrationData<'a>: Send + Sync + 'a;
+
+ /// Data shared by callbacks from the first successful open until the last close.
+ ///
+ /// It can borrow the registration data, of lifetime `'data`, for `'a`.
+ type OpenData<'a, 'data: 'a>: Send + Sync + 'a;
+}
+
+/// Maps a C device structure to its embedded VFIO device.
+///
+/// # Safety
+///
+/// Implementations must return the address of the `vfio_device` at the beginning of `Self`,
+/// preserving the input pointer's provenance.
+pub unsafe trait RawDevice {
+ /// Returns the `vfio_device` embedded in `raw`.
+ ///
+ /// # Safety
+ ///
+ /// `raw` must point to an initialized, live `Self`.
+ unsafe fn raw_vfio_device(raw: *mut Self) -> *mut bindings::vfio_device;
+}
+
+// SAFETY: A `vfio_device` is its own VFIO device.
+unsafe impl RawDevice for bindings::vfio_device {
+ unsafe fn raw_vfio_device(raw: *mut Self) -> *mut bindings::vfio_device {
+ raw
+ }
+}
+
+/// Callback data stored after the C device structure.
+///
+/// `R` is the type of the registration data and `O` the type of the open data, both written
+/// with the placeholder lifetime `'static`, because the device has no lifetime to name.
+///
+/// # Invariants
+///
+/// `reg_data` is `None` until a registration publishes its data, and is not changed again. The
+/// data is pinned and remains valid while the device is registered. After unregistration or a
+/// failed registration attempt, the pointer may dangle; its pointee must never again be
+/// accessed through this device.
+/// `open_data` is null outside a successful first open, otherwise it owns a pinned allocation
+/// until the last close. The bus-specific layer drains callbacks before either is released.
+struct CallbackData<R, O> {
+ reg_data: UnsafeCell<Option<NonNull<R>>>,
+ open_data: UnsafeCell<*mut O>,
+}
+
+/// A C VFIO device structure `Raw`, followed by the callback data of the driver `T`.
+///
+/// `raw` is the first field, so the `vfio_device` at the beginning of `Raw` is also at the
+/// beginning of `Self`, as `vfio_alloc_device()` requires.
+///
+/// `R` and `O` are the types of the registration data and the open data of `T`, written with
+/// the placeholder lifetime `'static`. Use the alias [`Device`], which takes both from the
+/// operations trait of `T`.
+///
+/// # Invariants
+///
+/// - `R` and `O` are the registration data and open data types of `T` with all lifetimes
+/// replaced by `'static`. The data stored is only valid as described for `CallbackData`.
+/// - `raw` is initialized and remains alive while borrowed. The reference count of its embedded
+/// `vfio_device` owns the allocation.
+/// - The device is registered with VFIO only after its registration data has been published.
+/// - Callback contexts are borrowed only for the corresponding callback and thread; only
+/// [`Normal`] references can be reference-counted.
+#[repr(C)]
+pub struct DeviceBase<Raw, R, O, T, Ctx: DeviceContext = Normal> {
+ raw: Opaque<Raw>,
+ data: CallbackData<R, O>,
+ _context: PhantomData<(T, Ctx, NotThreadSafe)>,
+}
+
+/// A VFIO device, wrapping `struct vfio_device`.
+pub type Device<T, Ctx = Normal> = DeviceBase<
+ bindings::vfio_device,
+ <T as Operations>::RegistrationData<'static>,
+ <T as Operations>::OpenData<'static, 'static>,
+ T,
+ Ctx,
+>;
+
+#[expect(dead_code)]
+impl<Raw: RawDevice, R, O, T, Ctx: DeviceContext> DeviceBase<Raw, R, O, T, Ctx> {
+ /// Initializes the Rust fields of a newly allocated device.
+ ///
+ /// # Safety
+ ///
+ /// `this` must point to an allocation with the size and alignment of `Self`, whose `raw`
+ /// has been initialized. Nothing else may access the allocation during this call.
+ unsafe fn init(this: *mut Self) {
+ // SAFETY: The caller provides exclusive access to a suitable allocation.
+ unsafe {
+ (&raw mut (*this).data).write(CallbackData {
+ reg_data: UnsafeCell::new(None),
+ open_data: UnsafeCell::new(core::ptr::null_mut()),
+ });
+ (&raw mut (*this)._context).write(PhantomData);
+ }
+ }
+
+ /// Recovers `&Self` from the `vfio_device` VFIO passes to a callback.
+ ///
+ /// # Safety
+ ///
+ /// `vdev` must point to the `vfio_device` at the beginning of a `Self` that remains alive
+ /// for `'a`. The caller must provide the guarantees of `Ctx` throughout the borrow.
+ unsafe fn from_raw_vfio<'a>(vdev: *mut bindings::vfio_device) -> &'a Self {
+ // SAFETY: `Raw` begins with its `vfio_device` and is the first field of `Self`. The
+ // caller guarantees validity and the context.
+ unsafe { &*vdev.cast() }
+ }
+
+ fn as_raw(&self) -> *mut Raw {
+ self.raw.get()
+ }
+
+ fn as_raw_vfio(&self) -> *mut bindings::vfio_device {
+ // SAFETY: By the type invariants, `raw` is initialized and alive.
+ unsafe { Raw::raw_vfio_device(self.as_raw()) }
+ }
+}
+
+#[expect(dead_code)]
+impl<Raw: RawDevice, R, O, T> DeviceBase<Raw, R, O, T> {
+ /// Publishes the registration data passed to callbacks.
+ ///
+ /// Returns [`EBUSY`] if registration data has been published before, so that a device can
+ /// be registered at most once.
+ ///
+ /// # Safety
+ ///
+ /// The caller must serialize calls for this device. `data` must point to pinned data that
+ /// remains valid until the device has been unregistered or, if registration fails, is not
+ /// accessed through this device.
+ unsafe fn publish_registration_data(&self, data: NonNull<R>) -> Result {
+ // SAFETY: The caller serializes publication, and callbacks only read the slot.
+ if unsafe { (*self.data.reg_data.get()).is_some() } {
+ return Err(EBUSY);
+ }
+ // SAFETY: The slot is unpublished, so the device has not been registered and no
+ // callback can read the slot.
+ // INVARIANT: The slot is written once; the caller keeps `data` valid.
+ unsafe { *self.data.reg_data.get() = Some(data) };
+ Ok(())
+ }
+
+ /// Destroys the open data.
+ ///
+ /// # Safety
+ ///
+ /// Call once after a successful [`DeviceBase::open`], with all I/O callbacks drained and
+ /// the next first open excluded. Registration data and the resources the open data borrows
+ /// must remain alive.
+ unsafe fn close(&self) {
+ // SAFETY: The last close exclusively takes the allocation published by `open()`.
+ let raw =
+ unsafe { core::mem::replace(&mut *self.data.open_data.get(), core::ptr::null_mut()) };
+ // SAFETY: The allocation came from `KBox::into_raw()` and is destroyed without moving
+ // it. Lifetimes do not affect its layout.
+ unsafe { drop(KBox::from_raw(raw)) };
+ }
+}
+
+#[expect(dead_code)]
+impl<Raw: RawDevice, R, O, T> DeviceBase<Raw, R, O, T, Open> {
+ /// Creates the open data from the registration data.
+ ///
+ /// The [`Open`] context guarantees an exclusive first open of a registered device, whose
+ /// registration data remains valid until the last close.
+ ///
+ /// # Safety
+ ///
+ /// - No open data may exist.
+ /// - `OD` must be `O`, except for lifetimes.
+ /// - `R` names the registration data with the placeholder lifetime `'static`, and the
+ /// caller chooses the lifetimes of `OD`; this function cannot tie either to the time the
+ /// data is valid. `init` must therefore use the registration data parametrically, as a
+ /// function generic over its lifetimes does: nothing borrowed from it may escape, other
+ /// than into the returned open data.
+ /// - `init` must not capture references that are only valid for the callback and store
+ /// them in the open data, which outlives the callback.
+ /// - The open data must be destroyed with [`DeviceBase::close`] at the last close.
+ unsafe fn open<'a, OD, I>(&'a self, init: impl FnOnce(&'a R) -> I) -> Result
+ where
+ I: PinInit<OD, Error>,
+ {
+ // SAFETY: By the type invariants, an `Open` reference only exists for a registered
+ // device, which has published registration data that nothing changes anymore. The
+ // data remains valid until the last close.
+ let reg_data = unsafe { (*self.data.reg_data.get()).unwrap_unchecked().as_ref() };
+
+ // Allocate before calling the driver so allocation failure cannot follow open.
+ let data = KBox::<OD>::new_uninit(GFP_KERNEL)?;
+ let data = data.write_pin_init(init(reg_data))?;
+
+ // SAFETY: Only the owning pointer moves; `close()` drops the allocation in place.
+ let raw = KBox::into_raw(unsafe { Pin::into_inner_unchecked(data) });
+ // SAFETY: The first open is exclusive, and no I/O callback runs before it returns.
+ // The caller guarantees that `OD` and `O` only differ in lifetimes, which do not
+ // affect the layout.
+ // INVARIANT: The allocation is pinned and owned by the slot until `close()`.
+ unsafe { *self.data.open_data.get() = raw.cast::<O>() };
+ Ok(())
+ }
+}
+
+#[expect(dead_code)]
+impl<Raw: RawDevice, R, O, T, Ctx: IoContext> DeviceBase<Raw, R, O, T, Ctx> {
+ /// Returns the registration data and the open data, for an I/O callback.
+ ///
+ /// # Safety
+ ///
+ /// `R` and `O` name the data with the placeholder lifetime `'static`, which is not the time
+ /// the data is valid. The caller must use both parametrically, as a function generic over
+ /// their lifetimes does: nothing borrowed from them may outlive the callback, and nothing
+ /// borrowed for the callback may be stored in them.
+ unsafe fn callback_data(&self) -> (&R, Pin<&O>) {
+ // SAFETY: By the type invariants, an `IoContext` reference only exists during an I/O
+ // callback on an open, registered device. VFIO excludes the last close and
+ // unregistration for its duration, so by the type invariants of `CallbackData` both
+ // slots hold valid data that nothing changes, and the open data is pinned.
+ unsafe {
+ let reg_data = (*self.data.reg_data.get()).unwrap_unchecked();
+ let open_data = *self.data.open_data.get();
+ (reg_data.as_ref(), Pin::new_unchecked(&*open_data))
+ }
+ }
+}
+
+// SAFETY: VFIO uses the embedded class device's refcount to own the full allocation.
+unsafe impl<Raw: RawDevice, R, O, T> AlwaysRefCounted for DeviceBase<Raw, R, O, T> {
+ fn inc_ref(&self) {
+ // SAFETY: A shared reference keeps the initialized VFIO device alive.
+ unsafe { bindings::get_device(&raw mut (*self.as_raw_vfio()).device) };
+ }
+
+ unsafe fn dec_ref(obj: NonNull<Self>) {
+ // SAFETY: The caller owns a reference, so `obj` points to a live device.
+ let raw = Opaque::cast_into(unsafe { &raw const (*obj.as_ptr()).raw });
+ // SAFETY: `raw` is initialized and alive, as above.
+ let vdev = unsafe { Raw::raw_vfio_device(raw) };
+ // SAFETY: The caller owns the VFIO reference being released.
+ unsafe { bindings::put_device(&raw mut (*vdev).device) };
+ }
+}
+
+// SAFETY: VFIO serializes open/close transitions, and callback data is `Send + Sync`.
+unsafe impl<Raw: RawDevice, R: Send + Sync, O: Send + Sync, T> Send for DeviceBase<Raw, R, O, T> {}
+
+// SAFETY: Shared access only changes the embedded class device's reference count. I/O callbacks
+// share `Sync` data; VFIO excludes them from mutations of `open_data` during first open and
+// last close, and registration data follows the registration lifetime. Mutable C state is
+// managed by the VFIO core.
+unsafe impl<Raw: RawDevice, R: Send + Sync, O: Send + Sync, T> Sync for DeviceBase<Raw, R, O, T> {}
+
+/// Capability buffer supplied by VFIO for a region-info callback.
+pub struct InfoCap<'a> {
+ #[expect(dead_code)]
+ raw: &'a mut bindings::vfio_info_cap,
+}
+
+/// Opaque wrapper around a `char __user *` buffer from a VFIO read or write callback.
+///
+/// Provides bounds-checked copying of kernel data into the user-space buffer.
+///
+/// This type cannot be constructed by driver code — it is only created by the
+/// callback trampoline.
+pub struct UserBuf {
+ ptr: UserPtr,
+ count: usize,
+}
+
+impl UserBuf {
+ /// Returns the buffer length in bytes.
+ pub fn len(&self) -> usize {
+ self.count
+ }
+
+ /// Returns `true` when the buffer is empty.
+ pub fn is_empty(&self) -> bool {
+ self.count == 0
+ }
+
+ /// Limit this callback's transfer to at most `count` bytes.
+ pub fn truncate(&mut self, count: usize) {
+ self.count = self.count.min(count);
+ }
+
+ /// Overwrite the part of `data` that overlaps a completed region read.
+ ///
+ /// `read_offset` is the starting region offset and `read_len` is the number of
+ /// bytes returned by the read. `data_offset` locates `data` within the same region.
+ pub fn write_overlapping(
+ &self,
+ read_offset: u64,
+ read_len: usize,
+ data_offset: u64,
+ data: &[u8],
+ ) -> Result {
+ if read_len > self.len() {
+ return Err(EINVAL);
+ }
+ let read_end = read_offset.checked_add(read_len as u64).ok_or(EOVERFLOW)?;
+ let data_end = data_offset
+ .checked_add(data.len() as u64)
+ .ok_or(EOVERFLOW)?;
+ let start = read_offset.max(data_offset);
+ let end = read_end.min(data_end);
+ if start >= end {
+ return Ok(());
+ }
+
+ // These differences are bounded by `read_len` and `data.len()`.
+ let buf_offset = (start - read_offset) as usize;
+ let data_start = (start - data_offset) as usize;
+ let data_end = (end - data_offset) as usize;
+ self.write_at(buf_offset, &data[data_start..data_end])
+ }
+
+ /// Copy `data` to the user buffer at byte offset `offset`.
+ ///
+ /// Returns [`EFAULT`] if the copy fails, [`EINVAL`] if the write would
+ /// exceed the buffer bounds.
+ fn write_at(&self, offset: usize, data: &[u8]) -> Result {
+ let end = offset.checked_add(data.len()).ok_or(EOVERFLOW)?;
+ if end > self.count {
+ return Err(EINVAL);
+ }
+ let dest = self.ptr.wrapping_byte_add(offset);
+ let mut writer = UserSlice::new(dest, data.len()).writer();
+ writer.write_slice(data)
+ }
+}
--
2.43.7
next prev parent reply other threads:[~2026-11-19 21:51 UTC|newest]
Thread overview: 10+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 21:50 [PATCH v3 0/9] Rust VFIO PCI support and NVIDIA vGPU driver Simon Song
2026-11-19 21:50 ` [PATCH v3 1/9] rust: pci: add VFIO override device IDs Simon Song
2026-11-19 21:50 ` [PATCH v3 2/9] rust: pci: expose the VF index within its PF Simon Song
2026-11-19 21:50 ` [PATCH v3 3/9] rust: pci: allow drivers to manage DMA ownership Simon Song
2026-11-19 21:50 ` [PATCH v3 4/9] rust: pci: add reset callbacks Simon Song
2026-11-19 21:50 ` [PATCH v3 5/9] rust: pci: add an error_detected callback Simon Song
2026-11-19 21:50 ` Simon Song [this message]
2026-11-19 21:50 ` [PATCH v3 7/9] rust: vfio: add PCI variant driver abstractions Simon Song
2026-11-19 21:50 ` [PATCH v3 8/9] gpu: nova-core: publish typed SR-IOV PF APIs Simon Song
2026-11-19 21:50 ` [PATCH v3 9/9] vfio/nova-vgpu: add the Rust VFIO variant driver Simon Song
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261119215046.2892839-7-xinmengs@nvidia.com \
--to=xinmengs@nvidia.com \
--cc=a.hindborg@kernel.org \
--cc=acourbot@nvidia.com \
--cc=airlied@gmail.com \
--cc=alex.gaynor@gmail.com \
--cc=alex@shazbot.org \
--cc=aliceryhl@google.com \
--cc=alkumar@nvidia.com \
--cc=aniketa@nvidia.com \
--cc=ankita@nvidia.com \
--cc=bhelgaas@google.com \
--cc=bjorn3_gh@protonmail.com \
--cc=boqun.feng@gmail.com \
--cc=boqun@kernel.org \
--cc=cjia@nvidia.com \
--cc=dakr@kernel.org \
--cc=daniel.almeida@collabora.com \
--cc=dri-devel@lists.freedesktop.org \
--cc=ecourtney@nvidia.com \
--cc=gary@garyguo.net \
--cc=jgg@nvidia.com \
--cc=jgg@ziepe.ca \
--cc=jhubbard@nvidia.com \
--cc=kevin.tian@intel.com \
--cc=kjaju@nvidia.com \
--cc=kvm@vger.kernel.org \
--cc=kwankhede@nvidia.com \
--cc=kwilczynski@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-pci@vger.kernel.org \
--cc=lossin@kernel.org \
--cc=nova-gpu@lists.linux.dev \
--cc=ojeda@kernel.org \
--cc=peter@colberg.org \
--cc=rust-for-linux@vger.kernel.org \
--cc=simona@ffwll.ch \
--cc=skolothumtho@nvidia.com \
--cc=smitra@nvidia.com \
--cc=tamird@kernel.org \
--cc=targupta@nvidia.com \
--cc=tmgross@umich.edu \
--cc=work@onurozkan.dev \
--cc=yishaih@nvidia.com \
--cc=zhiw@nvidia.com \
--cc=zhiwang@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®