* [PATCH v4 01/11] rust: sizes: add SZ_4G constant
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 02/11] rust: mm: add `task_size` helper Ke Sun via B4 Relay
` (9 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
SZ_4G is used by Tyr when splitting the GPU VA range into
user and kernel regions. Add a LargeSizeConstants trait, implemented
for u64 since SizeConstants only covers sizes that fit in a u32.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
Reviewed-by: Daniel Almeida <daniel.almeida@collabora.com>
Reviewed-by: Gary Guo <gary@garyguo.net>
Acked-by: Miguel Ojeda <ojeda@kernel.org>
---
rust/bindings/bindings_helper.h | 1 +
rust/kernel/sizes.rs | 12 ++++++++++++
2 files changed, 13 insertions(+)
diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index 930e63290cdd4..ee99f470ae5f4 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -116,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 size_t RUST_CONST_HELPER_GENLMSG_DEFAULT_SIZE = GENLMSG_DEFAULT_SIZE;
+const unsigned long long RUST_CONST_HELPER_SZ_4G = SZ_4G;
const gfp_t RUST_CONST_HELPER_GFP_ATOMIC = GFP_ATOMIC;
const gfp_t RUST_CONST_HELPER_GFP_KERNEL = GFP_KERNEL;
const gfp_t RUST_CONST_HELPER_GFP_KERNEL_ACCOUNT = GFP_KERNEL_ACCOUNT;
diff --git a/rust/kernel/sizes.rs b/rust/kernel/sizes.rs
index 521b2b38bfe77..0acc8733d2368 100644
--- a/rust/kernel/sizes.rs
+++ b/rust/kernel/sizes.rs
@@ -132,3 +132,15 @@ impl SizeConstants for $first {
}
define_sizes!(u32, u64, usize);
+
+/// Large size constants (≥ 4 GiB).
+///
+/// Only implemented for [`u64`].
+pub trait LargeSizeConstants {
+ /// `0x1_0000_0000`.
+ const SZ_4G: Self;
+}
+
+impl LargeSizeConstants for u64 {
+ const SZ_4G: Self = bindings::SZ_4G;
+}
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 02/11] rust: mm: add `task_size` helper
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 01/11] rust: sizes: add SZ_4G constant Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 03/11] rust: sync: arc: relax `ForeignOwnable` for `Arc<T>` Ke Sun via B4 Relay
` (8 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
Expose the task's address space size. It is used by the Tyr driver
for splitting a VM's GPU address space into user and kernel regions.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
Reviewed-by: Daniel Almeida <daniel.almeida@collabora.com>
---
rust/kernel/mm.rs | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/rust/kernel/mm.rs b/rust/kernel/mm.rs
index 4764d7b68f2a7..d2dfbb7d43972 100644
--- a/rust/kernel/mm.rs
+++ b/rust/kernel/mm.rs
@@ -149,6 +149,13 @@ pub fn mmget_not_zero(&self) -> Option<ARef<MmWithUser>> {
None
}
}
+
+ /// The size of the process virtual address space.
+ #[inline]
+ pub fn task_size(&self) -> usize {
+ // SAFETY: `self.as_raw()` is a valid pointer to an `mm_struct` per the type invariants.
+ unsafe { (*self.as_raw()).__bindgen_anon_1.task_size }
+ }
}
// These methods require `mm_users` to be non-zero.
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 03/11] rust: sync: arc: relax `ForeignOwnable` for `Arc<T>`
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 01/11] rust: sizes: add SZ_4G constant Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 02/11] rust: mm: add `task_size` helper Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 04/11] drm/tyr: add per-file VM pool Ke Sun via B4 Relay
` (7 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
Drop the `'static` bound so that refcounted values borrowing from a
driver registration scope can be foreign-owned by the XArray
abstraction.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
Reviewed-by: Daniel Almeida <daniel.almeida@collabora.com>
Reviewed-by: Gary Guo <gary@garyguo.net>
---
rust/kernel/sync/arc.rs | 12 +++++++++---
1 file changed, 9 insertions(+), 3 deletions(-)
diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
index 8ae0fe6f19ec0..9b582a815f888 100644
--- a/rust/kernel/sync/arc.rs
+++ b/rust/kernel/sync/arc.rs
@@ -363,11 +363,17 @@ pub fn into_unique_or_drop(this: Self) -> Option<Pin<UniqueArc<T>>> {
// SAFETY: The pointer returned by `into_foreign` was originally allocated as an
// `KBox<ArcInner<T>>`, so that type is what determines the alignment.
-unsafe impl<T: 'static> ForeignOwnable for Arc<T> {
+unsafe impl<T> ForeignOwnable for Arc<T> {
const FOREIGN_ALIGN: usize = <KBox<ArcInner<T>> as ForeignOwnable>::FOREIGN_ALIGN;
- type Borrowed<'a> = ArcBorrow<'a, T>;
- type BorrowedMut<'a> = Self::Borrowed<'a>;
+ type Borrowed<'a>
+ = ArcBorrow<'a, T>
+ where
+ T: 'a;
+ type BorrowedMut<'a>
+ = Self::Borrowed<'a>
+ where
+ T: 'a;
fn into_foreign(self) -> *mut c_void {
ManuallyDrop::new(self).ptr.as_ptr().cast()
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 04/11] drm/tyr: add per-file VM pool
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (2 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 03/11] rust: sync: arc: relax `ForeignOwnable` for `Arc<T>` Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-21 22:59 ` Deborah Brouwer
2026-10-20 8:25 ` [PATCH v4 05/11] drm/tyr: add user and MCU VM specifications Ke Sun via B4 Relay
` (6 subsequent siblings)
10 siblings, 1 reply; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
Userspace needs multiple independent GPU address spaces per file,
addressed by ID through the VM ioctls as in panthor. Store them in an
IdPool (capped at 32 for panthor parity) plus an XArray. On a failed
insertion the caller tears the VM down through the returned error, so
an aborted creation never leaks a VM. The pool kills every VM still
stored when the file closes.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
---
drivers/gpu/drm/tyr/vm.rs | 138 +++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 137 insertions(+), 1 deletion(-)
diff --git a/drivers/gpu/drm/tyr/vm.rs b/drivers/gpu/drm/tyr/vm.rs
index c5e307b1e2416..6935e4db667b9 100644
--- a/drivers/gpu/drm/tyr/vm.rs
+++ b/drivers/gpu/drm/tyr/vm.rs
@@ -33,6 +33,7 @@
}, //
},
fmt,
+ id_pool::IdPool,
impl_flags,
io::PhysAddr,
iommu::pgtable::{
@@ -53,7 +54,11 @@
ArcBorrow,
Mutex, //
},
- uapi, //
+ uapi,
+ xarray::{
+ AllocKind,
+ XArray, //
+ }, //
};
use crate::{
@@ -948,3 +953,134 @@ fn pt_unmap(dev: &Device, pt: &IoPageTable<'_, ARM64LPAES1>, range: Range<u64>)
Ok(())
}
+
+/// Maximum number of VMs a single file may hold, matching panthor's
+/// `PANTHOR_MAX_VMS_PER_FILE`.
+const MAX_VMS_PER_FILE: usize = 32;
+
+/// Per-open-file pool of VMs.
+#[pin_data(PinnedDrop)]
+pub(crate) struct VmPool<'drm> {
+ /// Parent device, for error reporting.
+ dev: &'drm Device<Bound>,
+ #[pin]
+ ids: Mutex<IdPool>,
+ #[pin]
+ vms: XArray<Arc<Vm<'drm>>>,
+}
+
+/// Error returned when a VM cannot be added to the pool. The caller
+/// owns the teardown of the VM in [`AddError::vm`].
+pub(crate) struct AddError<'drm> {
+ pub(crate) error: Error,
+ pub(crate) vm: Arc<Vm<'drm>>,
+}
+
+impl<'drm> VmPool<'drm> {
+ /// Creates a new [`VmPool`].
+ #[expect(dead_code)]
+ pub(crate) fn new(dev: &'drm Device<Bound>) -> impl PinInit<Self> {
+ let ids = IdPool::new();
+ pin_init!(Self {
+ dev,
+ ids <- new_mutex!(ids),
+ vms <- XArray::new(AllocKind::Alloc),
+ })
+ }
+
+ /// Stores the VM and returns the allocated ID.
+ ///
+ /// On failure - ID space exhausted or a store failure - the VM is
+ /// returned in an [`AddError`] so the caller owns the teardown.
+ // TODO: allocate IDs with the XArray directly (once it grows range
+ // allocation, the equivalent of C's `XA_LIMIT`) and drop the IdPool.
+ #[expect(dead_code)]
+ pub(crate) fn add(&self, vm: Arc<Vm<'drm>>) -> Result<u32, AddError<'drm>> {
+ let id = (|| {
+ let mut ids = self.ids.lock();
+ let unused = ids.find_unused_id(1).ok_or(ENOSPC)?;
+ if unused.as_usize() > MAX_VMS_PER_FILE {
+ return Err(ENOSPC);
+ }
+ Ok(unused.acquire())
+ })();
+ let id = match id {
+ Ok(id) => id,
+ Err(error) => return Err(AddError { error, vm }),
+ };
+
+ let mut vms = self.vms.lock();
+ match vms.store(id, vm, GFP_KERNEL) {
+ Ok(prev_vm) => {
+ if let Some(prev_vm) = prev_vm {
+ // An existing VM at the freshly allocated slot means the
+ // IdPool and the XArray are out of sync: the stored VM is
+ // a pool entry, so the pool kills it and the caller's VM
+ // is handed back for the caller to kill.
+ let stored = vms.remove(id);
+ drop(vms);
+ prev_vm.kill();
+ self.ids.lock().release_id(id);
+ dev_err!(
+ self.dev,
+ "IdPool/XArray out of sync at VM pool id {id} (stored VM conflict)"
+ );
+ return Err(AddError {
+ error: EBUSY,
+ vm: stored.expect("VM was just stored"),
+ });
+ }
+ Ok(id as u32)
+ }
+ Err(err) => {
+ // Drop the XArray spinlock before acquiring the `ids` mutex.
+ drop(vms);
+ // Release the pooled id; the VM never entered the pool, so it
+ // is returned to the caller for teardown.
+ self.ids.lock().release_id(id);
+ Err(AddError { error: err.error, vm: err.value })
+ }
+ }
+ }
+
+ /// Removes and kills the VM with the given ID.
+ #[expect(dead_code)]
+ pub(crate) fn remove(&self, id: u32) -> Result<()> {
+ let mut vms = self.vms.lock();
+ let vm = match vms.remove(id as usize) {
+ Some(vm) => vm,
+ None => return Err(EINVAL),
+ };
+ // Drop the XArray spinlock before killing, since `kill()` may sleep.
+ drop(vms);
+ // Kill the VM before handing the id back to the pool, so a VM is
+ // never reusable while still alive.
+ vm.kill();
+ self.ids.lock().release_id(id as usize);
+ Ok(())
+ }
+
+ /// Gets a shared reference to the VM with the given ID.
+ #[expect(dead_code)]
+ pub(crate) fn get(&self, id: u32) -> Option<Arc<Vm<'drm>>> {
+ let vms = self.vms.lock();
+ let borrow = vms.get(id as usize)?;
+ Some(Arc::from(borrow))
+ }
+}
+
+#[pinned_drop]
+impl PinnedDrop for VmPool<'_> {
+ fn drop(self: Pin<&mut Self>) {
+ let this = self.project();
+ // Kill every VM left in the pool. The ID range is bounded by
+ // `MAX_VMS_PER_FILE`, so this loop is cheap and runs at file close.
+ for id in 1..=MAX_VMS_PER_FILE {
+ // Release the XArray lock guard before killing: `kill()` may sleep.
+ let vm = this.vms.lock().remove(id);
+ if let Some(vm) = vm {
+ vm.kill();
+ }
+ }
+ }
+}
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* Re: [PATCH v4 04/11] drm/tyr: add per-file VM pool
2026-10-20 8:25 ` [PATCH v4 04/11] drm/tyr: add per-file VM pool Ke Sun via B4 Relay
@ 2026-10-21 22:59 ` Deborah Brouwer
0 siblings, 0 replies; 13+ messages in thread
From: Deborah Brouwer @ 2026-10-21 22:59 UTC (permalink / raw)
To: Ke Sun
Cc: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki, Sami Tolvanen,
rust-for-linux, linux-mm, dri-devel, driver-core, linux-kernel,
Alvin Sun
On Tue, Oct 20, 2026 at 04:25:21PM +0800, Ke Sun wrote:
> From: Alvin Sun <alvin.sun@linux.dev>
>
> Userspace needs multiple independent GPU address spaces per file,
> addressed by ID through the VM ioctls as in panthor. Store them in an
> IdPool (capped at 32 for panthor parity) plus an XArray. On a failed
> insertion the caller tears the VM down through the returned error, so
> an aborted creation never leaks a VM. The pool kills every VM still
> stored when the file closes.
>
> Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
> ---
> drivers/gpu/drm/tyr/vm.rs | 138 +++++++++++++++++++++++++++++++++++++++++++++-
> 1 file changed, 137 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/gpu/drm/tyr/vm.rs b/drivers/gpu/drm/tyr/vm.rs
> index c5e307b1e2416..6935e4db667b9 100644
> --- a/drivers/gpu/drm/tyr/vm.rs
> +++ b/drivers/gpu/drm/tyr/vm.rs
> @@ -33,6 +33,7 @@
> }, //
> },
> fmt,
> + id_pool::IdPool,
> impl_flags,
> io::PhysAddr,
> iommu::pgtable::{
> @@ -53,7 +54,11 @@
> ArcBorrow,
> Mutex, //
> },
> - uapi, //
> + uapi,
> + xarray::{
> + AllocKind,
> + XArray, //
> + }, //
> };
>
> use crate::{
> @@ -948,3 +953,134 @@ fn pt_unmap(dev: &Device, pt: &IoPageTable<'_, ARM64LPAES1>, range: Range<u64>)
>
> Ok(())
> }
> +
> +/// Maximum number of VMs a single file may hold, matching panthor's
> +/// `PANTHOR_MAX_VMS_PER_FILE`.
> +const MAX_VMS_PER_FILE: usize = 32;
> +
> +/// Per-open-file pool of VMs.
> +#[pin_data(PinnedDrop)]
> +pub(crate) struct VmPool<'drm> {
> + /// Parent device, for error reporting.
> + dev: &'drm Device<Bound>,
> + #[pin]
> + ids: Mutex<IdPool>,
> + #[pin]
> + vms: XArray<Arc<Vm<'drm>>>,
> +}
> +
> +/// Error returned when a VM cannot be added to the pool. The caller
> +/// owns the teardown of the VM in [`AddError::vm`].
> +pub(crate) struct AddError<'drm> {
> + pub(crate) error: Error,
> + pub(crate) vm: Arc<Vm<'drm>>,
> +}
When I try to compile just this patch i get an error about
this being unused so better annotate it with #[expect(dead_code)]
like the others.
> +
> +impl<'drm> VmPool<'drm> {
> + /// Creates a new [`VmPool`].
> + #[expect(dead_code)]
> + pub(crate) fn new(dev: &'drm Device<Bound>) -> impl PinInit<Self> {
> + let ids = IdPool::new();
> + pin_init!(Self {
> + dev,
> + ids <- new_mutex!(ids),
> + vms <- XArray::new(AllocKind::Alloc),
> + })
> + }
> +
> + /// Stores the VM and returns the allocated ID.
> + ///
> + /// On failure - ID space exhausted or a store failure - the VM is
> + /// returned in an [`AddError`] so the caller owns the teardown.
> + // TODO: allocate IDs with the XArray directly (once it grows range
> + // allocation, the equivalent of C's `XA_LIMIT`) and drop the IdPool.
> + #[expect(dead_code)]
> + pub(crate) fn add(&self, vm: Arc<Vm<'drm>>) -> Result<u32, AddError<'drm>> {
> + let id = (|| {
> + let mut ids = self.ids.lock();
> + let unused = ids.find_unused_id(1).ok_or(ENOSPC)?;
> + if unused.as_usize() > MAX_VMS_PER_FILE {
> + return Err(ENOSPC);
> + }
> + Ok(unused.acquire())
> + })();
> + let id = match id {
> + Ok(id) => id,
> + Err(error) => return Err(AddError { error, vm }),
> + };
> +
> + let mut vms = self.vms.lock();
> + match vms.store(id, vm, GFP_KERNEL) {
> + Ok(prev_vm) => {
> + if let Some(prev_vm) = prev_vm {
> + // An existing VM at the freshly allocated slot means the
> + // IdPool and the XArray are out of sync: the stored VM is
> + // a pool entry, so the pool kills it and the caller's VM
> + // is handed back for the caller to kill.
> + let stored = vms.remove(id);
> + drop(vms);
> + prev_vm.kill();
> + self.ids.lock().release_id(id);
> + dev_err!(
> + self.dev,
> + "IdPool/XArray out of sync at VM pool id {id} (stored VM conflict)"
> + );
> + return Err(AddError {
> + error: EBUSY,
> + vm: stored.expect("VM was just stored"),
Since the rust for linux coding guidlines say:
panicking should be very rare and used only with a good reason.
In almost all cases, a fallible approach should be used, typically returning a Result.
I'm wondering if there is a way to avoid this expect().
For example, you could store a vm.clone() in the xarray and keep the vm
that was passed to this function so that it can be returned on error.
And on success, the vm would just drop so the overall ref count wouldn't
be incremented.
> + });
> + }
> + Ok(id as u32)
> + }
> + Err(err) => {
> + // Drop the XArray spinlock before acquiring the `ids` mutex.
> + drop(vms);
> + // Release the pooled id; the VM never entered the pool, so it
> + // is returned to the caller for teardown.
> + self.ids.lock().release_id(id);
> + Err(AddError { error: err.error, vm: err.value })
When i run rustfmt on this patch it reformats this line, can you double
check you ran rustfmt?
> + }
> + }
> + }
> +
> + /// Removes and kills the VM with the given ID.
> + #[expect(dead_code)]
> + pub(crate) fn remove(&self, id: u32) -> Result<()> {
> + let mut vms = self.vms.lock();
> + let vm = match vms.remove(id as usize) {
> + Some(vm) => vm,
> + None => return Err(EINVAL),
> + };
> + // Drop the XArray spinlock before killing, since `kill()` may sleep.
> + drop(vms);
> + // Kill the VM before handing the id back to the pool, so a VM is
> + // never reusable while still alive.
> + vm.kill();
> + self.ids.lock().release_id(id as usize);
Since i just learned about this myself, I should mention that you can
now use num::casts::FromSafeCast and then write
usize::from_safe_cast(id).
> + Ok(())
> + }
> +
> + /// Gets a shared reference to the VM with the given ID.
> + #[expect(dead_code)]
> + pub(crate) fn get(&self, id: u32) -> Option<Arc<Vm<'drm>>> {
> + let vms = self.vms.lock();
> + let borrow = vms.get(id as usize)?;
> + Some(Arc::from(borrow))
> + }
> +}
> +
> +#[pinned_drop]
> +impl PinnedDrop for VmPool<'_> {
> + fn drop(self: Pin<&mut Self>) {
> + let this = self.project();
I don't think you need to project the VmPool here because we only
need a shared ref to the pool, and the vms guard gives us the interior
mutability we need to modify the xarray anyway.
> + // Kill every VM left in the pool. The ID range is bounded by
> + // `MAX_VMS_PER_FILE`, so this loop is cheap and runs at file close.
> + for id in 1..=MAX_VMS_PER_FILE {
> + // Release the XArray lock guard before killing: `kill()` may sleep.
> + let vm = this.vms.lock().remove(id);
> + if let Some(vm) = vm {
> + vm.kill();
> + }
> + }
> + }
> +}
>
> --
> 2.43.0
>
^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH v4 05/11] drm/tyr: add user and MCU VM specifications
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (3 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 04/11] drm/tyr: add per-file VM pool Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 06/11] drm/tyr: add BO creation and lookup helpers Ke Sun via B4 Relay
` (5 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
The MCU and user VMs need different VA layouts. Give each a dedicated
constructor: new_for_fw() builds the kernel-only 4G layout, while
new_for_user() splits the address space by task_size or a user-provided
size, rejecting oversized requests rather than clamping. The resulting
user range is what VM_CREATE reports back as user_va_range.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
---
drivers/gpu/drm/tyr/fw.rs | 19 +++---
drivers/gpu/drm/tyr/vm.rs | 159 +++++++++++++++++++++++++++++++++++++++++-----
2 files changed, 153 insertions(+), 25 deletions(-)
diff --git a/drivers/gpu/drm/tyr/fw.rs b/drivers/gpu/drm/tyr/fw.rs
index aea151ff1f934..81e8103368bc2 100644
--- a/drivers/gpu/drm/tyr/fw.rs
+++ b/drivers/gpu/drm/tyr/fw.rs
@@ -51,7 +51,6 @@
KernelBoVaAlloc, //
},
gpu::GpuInfo,
-
mmu::Mmu,
regs::{
gpu_control::{
@@ -219,10 +218,10 @@ pub(crate) fn new(
mmu: ArcBorrow<'_, Mmu<'drm>>,
gpu_info: &GpuInfo,
) -> Result<Firmware<'drm>> {
- let vm = Vm::new(dev, ddev, mmu, gpu_info)?;
+ let vm = Vm::new_for_fw(dev, ddev, mmu, gpu_info)?;
vm.activate()?;
- let result = (|| {
+ let sections = (|| -> Result<KVec<Section<'drm>>> {
let (fw, parsed_sections) = Self::load(dev, ddev, gpu_info)?;
let mut sections = KVec::new();
for parsed in parsed_sections {
@@ -252,18 +251,18 @@ pub(crate) fn new(
sections.push(Section { data, mem }, GFP_KERNEL)?;
}
- Ok(Firmware {
- iomem,
- vm: vm.clone(),
- sections,
- })
+ Ok(sections)
})();
- if result.is_err() {
+ if sections.is_err() {
vm.kill();
}
- result
+ Ok(Firmware {
+ iomem,
+ vm,
+ sections: sections?,
+ })
}
pub(crate) fn boot(&self) -> Result {
diff --git a/drivers/gpu/drm/tyr/vm.rs b/drivers/gpu/drm/tyr/vm.rs
index 6935e4db667b9..adbf8edcd5c6f 100644
--- a/drivers/gpu/drm/tyr/vm.rs
+++ b/drivers/gpu/drm/tyr/vm.rs
@@ -8,6 +8,7 @@
//! mapped into hardware address space (AS) slots for GPU execution.
use core::marker::PhantomData;
+use core::num::NonZeroU64;
use core::ops::Range;
use kernel::{
@@ -44,6 +45,8 @@
new_mutex,
prelude::*,
sizes::{
+ LargeSizeConstants,
+ SizeConstants,
SZ_1G,
SZ_2M,
SZ_4K, //
@@ -159,6 +162,92 @@ fn try_from(value: u32) -> Result<Self, Self::Error> {
}
}
+/// User VA size request for a user VM.
+pub(crate) enum UserVaRequest {
+ /// Split based on `task_size()` and the GPU VA range.
+ Auto,
+ /// Caller-specified size; construction guarantees `> 0`.
+ Fixed(NonZeroU64),
+}
+
+impl UserVaRequest {
+ /// UAPI boundary normalization: `0` -> [`Auto`](Self::Auto).
+ #[expect(dead_code)]
+ pub(crate) fn from_uapi(v: u64) -> Self {
+ match NonZeroU64::new(v) {
+ Some(size) => Self::Fixed(size),
+ None => Self::Auto,
+ }
+ }
+}
+
+/// Final user/kernel VA layout for a VM.
+pub(crate) struct VmLayout {
+ /// Full GPU VA range covered by this VM.
+ pub(crate) full: Range<u64>,
+ /// User-accessible VA range. Empty for MCU VMs.
+ pub(crate) user: Range<u64>,
+}
+
+impl VmLayout {
+ /// Kernel VA range, reserved for future kernel object allocation.
+ #[expect(dead_code)]
+ pub(crate) fn kernel(&self) -> Range<u64> {
+ self.user.end..self.full.end
+ }
+
+ /// Compute a user/kernel split for a user VM from the full GPU VA range and
+ /// a user request.
+ pub(crate) fn compute(full: Range<u64>, req: UserVaRequest) -> Result<Self> {
+ // Minimum VA space reserved for kernel objects (heaps, ring buffers, ...).
+ const MIN_KERNEL_VA: u64 = u64::SZ_256M;
+
+ if full.end <= MIN_KERNEL_VA {
+ return Err(EINVAL);
+ }
+
+ let user_max = full.end - MIN_KERNEL_VA;
+
+ let user_end = match req {
+ UserVaRequest::Fixed(v) => {
+ let user_size = v.get();
+ if user_size > user_max {
+ return Err(EINVAL);
+ }
+ user_size
+ }
+ UserVaRequest::Auto => {
+ let task_size = current!().mm().map(|mm| mm.task_size());
+ let candidate = match task_size {
+ // `task_size()` returns usize; widen to u64 for the comparison.
+ Some(t) if (t as u64) < full.end => t as u64,
+ None | Some(_) => {
+ // If the range exceeds 4G, split it in two so CPU and
+ // GPU share the same addresses (SVM).
+ if full.end > u64::SZ_4G {
+ full.end / 2
+ } else {
+ user_max
+ }
+ }
+ };
+ candidate.min(user_max)
+ }
+ };
+
+ let delta = full.end - user_end;
+ // Pick a kernel VA range that's a power of two, to have a clear split.
+ let kernel_va_range = 1u64 << delta.ilog2();
+ let kernel_va_start = full.end - kernel_va_range;
+ let full_start = full.start;
+
+ Ok(Self {
+ full,
+ user: full_start..kernel_va_start,
+ })
+ }
+}
+
/// Arguments for a virtual memory map operation.
struct VmMapArgs<'drm> {
/// Access permissions and caching behavior for the mapping.
@@ -334,26 +423,64 @@ pub(crate) struct Vm<'drm> {
/// Non-core part of the GPUVM. Can be used for stuff that doesn't modify the
/// internal mapping tree, like GpuVm::obtain()
gpuvm: ARef<GpuVm<GpuVmData<'drm>>>,
- /// VA range for this VM.
- va_range: Range<u64>,
+ /// VA layout for this VM.
+ pub(crate) layout: VmLayout,
}
impl<'drm> Vm<'drm> {
- /// Creates a new GPU virtual address space.
+ /// Creates the MCU/firmware VM.
///
- /// The VM is initialized with a page table configured according to the GPU's
- /// address translation capabilities and registered with the GPUVM framework.
- pub(crate) fn new(
+ /// The MCU VM is entirely kernel-managed: it has no user-accessible range.
+ pub(crate) fn new_for_fw(
+ dev: &'drm Device<Bound>,
+ ddev: &TyrDrmDevice,
+ mmu: ArcBorrow<'_, Mmu<'drm>>,
+ gpu_info: &GpuInfo,
+ ) -> Result<Arc<Vm<'drm>>> {
+ // As in panthor: the CSF MCU is a Cortex-M7 and can only address 4G.
+ let layout = VmLayout {
+ full: 0..u64::SZ_4G,
+ user: 0..0u64,
+ };
+ Self::new_internal(dev, ddev, mmu, gpu_info, layout)
+ }
+
+ /// Creates a user VM, splitting the GPU VA range per `user_va`.
+ #[expect(dead_code)]
+ pub(crate) fn new_for_user(
dev: &'drm Device<Bound>,
ddev: &TyrDrmDevice,
mmu: ArcBorrow<'_, Mmu<'drm>>,
gpu_info: &GpuInfo,
+ user_va: UserVaRequest,
+ ) -> Result<Arc<Vm<'drm>>> {
+ let mmu_features = MMU_FEATURES::from_raw(gpu_info.mmu_features);
+ let va_bits = mmu_features.va_bits().get();
+ let range = 0..(1u64 << va_bits);
+
+ let layout = VmLayout::compute(range.clone(), user_va).inspect_err(|_| {
+ dev_dbg!(
+ dev,
+ "Failed to split GPU VA range {:#x}..{:#x} into user and kernel regions\n",
+ range.start,
+ range.end
+ );
+ })?;
+ Self::new_internal(dev, ddev, mmu, gpu_info, layout)
+ }
+
+ /// Initializes a VM with the given layout.
+ fn new_internal(
+ dev: &'drm Device<Bound>,
+ ddev: &TyrDrmDevice,
+ mmu: ArcBorrow<'_, Mmu<'drm>>,
+ gpu_info: &GpuInfo,
+ layout: VmLayout,
) -> Result<Arc<Vm<'drm>>> {
let mmu_features = MMU_FEATURES::from_raw(gpu_info.mmu_features);
let va_bits = mmu_features.va_bits().get();
let pa_bits = mmu_features.pa_bits().get();
- let range = 0..(1u64 << va_bits);
let reserve_range = 0..0u64;
// dummy_obj is used to initialize the GPUVM tree.
@@ -365,7 +492,7 @@ pub(crate) fn new(
c"Tyr::GpuVm",
ddev,
&*dummy_obj,
- range.clone(),
+ layout.full.clone(),
reserve_range,
GpuVmData::<'drm> {
_phantom: PhantomData::<&()>,
@@ -385,7 +512,7 @@ pub(crate) fn new(
mmu: mmu.into(),
gpuvm,
gpuvm_unique <- new_mutex!(gpuvm_unique),
- va_range: range,
+ layout,
}),
GFP_KERNEL,
)?;
@@ -416,10 +543,12 @@ fn deactivate(&self) -> Result {
/// Kills the VM by deactivating it and unmapping all regions.
pub(crate) fn kill(&self) {
- // TODO: Turn the VM into a state where it can't be used.
let _ = self.deactivate();
let _ = self
- .unmap_range(self.va_range.start, self.va_range.end - self.va_range.start)
+ .unmap_range(
+ self.layout.full.start,
+ self.layout.full.end - self.layout.full.start,
+ )
.inspect_err(|e| {
dev_err!(self.dev, "Failed to unmap range during deactivate: {:?}", e);
});
@@ -556,14 +685,14 @@ pub(crate) fn unmap_range(&self, va: u64, size: u64) -> Result {
let end = va.checked_add(size).ok_or(EINVAL)?;
- if va < self.va_range.start || end > self.va_range.end {
+ if va < self.layout.full.start || end > self.layout.full.end {
dev_err!(
self.dev,
"Unmap range {:#x}..{:#x} exceeds VM range {:#x}..{:#x}",
va,
end,
- self.va_range.start,
- self.va_range.end
+ self.layout.full.start,
+ self.layout.full.end
);
return Err(EINVAL);
}
@@ -573,7 +702,7 @@ pub(crate) fn unmap_range(&self, va: u64, size: u64) -> Result {
region: va..end,
};
- let full_vm = va == self.va_range.start && end == self.va_range.end;
+ let full_vm = va == self.layout.full.start && end == self.layout.full.end;
let mut resources = VmOpResources {
preallocated_gpuvas: if full_vm {
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 06/11] drm/tyr: add BO creation and lookup helpers
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (4 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 05/11] drm/tyr: add user and MCU VM specifications Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 07/11] drm/tyr: add VM-related ioctls Ke Sun via B4 Relay
` (4 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
Add helpers for the BO ioctls: new_object() creates a GEM object with
the size aligned up to PAGE_SIZE, and lookup_handle() resolves a handle
for a DRM file.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
Reviewed-by: Daniel Almeida <daniel.almeida@collabora.com>
---
drivers/gpu/drm/tyr/gem.rs | 31 ++++++++++++++++++++++++++++++-
1 file changed, 30 insertions(+), 1 deletion(-)
diff --git a/drivers/gpu/drm/tyr/gem.rs b/drivers/gpu/drm/tyr/gem.rs
index 3bf3787f5c3fd..0e0989a48678f 100644
--- a/drivers/gpu/drm/tyr/gem.rs
+++ b/drivers/gpu/drm/tyr/gem.rs
@@ -9,8 +9,10 @@
use kernel::{
drm::gem::{
self,
- shmem, //
+ shmem,
+ BaseObject, //
},
+ page::PAGE_SIZE,
prelude::*,
sync::{
aref::ARef,
@@ -23,6 +25,7 @@
TyrDrmDevice,
TyrDrmDriver, //
},
+ file::TyrDrmFile,
vm::{
Vm,
VmMapFlags, //
@@ -53,6 +56,32 @@ fn new(_dev: &TyrDrmDevice, _size: usize, args: BoCreateArgs) -> impl PinInit<Se
/// Type alias for Tyr GEM buffer objects.
pub(crate) type Bo = gem::shmem::Object<BoData>;
+/// Create a new GEM buffer object.
+#[expect(dead_code)]
+pub(crate) fn new_object(ddev: &TyrDrmDevice, size: usize, flags: u32) -> Result<ARef<Bo>> {
+ if size == 0 {
+ return Err(EINVAL);
+ }
+
+ let aligned_size = size.checked_next_multiple_of(PAGE_SIZE).ok_or(EINVAL)?;
+
+ Bo::new(
+ ddev,
+ aligned_size,
+ shmem::ObjectConfig {
+ map_wc: true,
+ parent_resv_obj: None,
+ },
+ BoCreateArgs { flags },
+ )
+}
+
+/// Look up a GEM object by handle for a DRM file.
+#[expect(dead_code)]
+pub(crate) fn lookup_handle(file: &TyrDrmFile, handle: u32) -> Result<ARef<Bo>> {
+ Bo::lookup_handle(file, handle)
+}
+
/// Creates a dummy GEM object to serve as the root of a GPUVM.
pub(crate) fn new_dummy_object(ddev: &TyrDrmDevice) -> Result<ARef<Bo>> {
let bo = Bo::new(
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 07/11] drm/tyr: add VM-related ioctls
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (5 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 06/11] drm/tyr: add BO creation and lookup helpers Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 08/11] drm/tyr: add BO-related ioctls Ke Sun via B4 Relay
` (3 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
Implement VM_CREATE, VM_DESTROY, VM_BIND and VM_GET_STATE. VM_CREATE
hands the new VM to the per-file pool and, on insertion failure, the
caller tears it down, so an aborted creation never leaks a VM.
VM_DESTROY removes the VM from the pool and kills it, even if in-flight
jobs still hold references (matching panthor: such jobs are expected
to fault). VM_BIND runs synchronously for now.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
---
drivers/gpu/drm/tyr/driver.rs | 12 +-
drivers/gpu/drm/tyr/file.rs | 320 ++++++++++++++++++++++++++++++++++++++++--
drivers/gpu/drm/tyr/gem.rs | 1 -
drivers/gpu/drm/tyr/vm.rs | 67 ++++++++-
4 files changed, 381 insertions(+), 19 deletions(-)
diff --git a/drivers/gpu/drm/tyr/driver.rs b/drivers/gpu/drm/tyr/driver.rs
index e2b6d63491b91..c0f17bc4ce2c9 100644
--- a/drivers/gpu/drm/tyr/driver.rs
+++ b/drivers/gpu/drm/tyr/driver.rs
@@ -33,7 +33,7 @@
Mutex, //
},
time,
- types::CovariantForLt, //
+ types::ForLt, //
};
use crate::{
@@ -74,6 +74,9 @@ pub(crate) struct TyrDrmRegistrationData<'drm> {
/// Firmware sections.
pub(crate) fw: Firmware<'drm>,
+ /// Memory management unit for address space slots.
+ pub(crate) mmu: Arc<Mmu<'drm>>,
+
#[pin]
clks: Mutex<Clocks>,
@@ -172,6 +175,7 @@ fn probe<'bound>(
pin_init!(TyrDrmRegistrationData {
pdev,
fw: firmware,
+ mmu,
clks <- new_mutex!(Clocks {
core: core_clk,
stacks: stacks_clk,
@@ -210,7 +214,7 @@ fn drop(self: Pin<&mut Self>) {}
impl drm::Driver for TyrDrmDriver {
type Data = ();
type RegistrationData<'drm> = TyrDrmRegistrationData<'drm>;
- type File = CovariantForLt!(TyrDrmFileData);
+ type File = ForLt!(TyrDrmFileData<'_>);
type Object = Bo;
type ParentDevice<Ctx: DeviceContext> = platform::Device<Ctx>;
@@ -219,6 +223,10 @@ impl drm::Driver for TyrDrmDriver {
kernel::declare_drm_ioctls! {
(PANTHOR_DEV_QUERY, drm_panthor_dev_query, ioctl::RENDER_ALLOW, TyrDrmFileData::dev_query),
+ (PANTHOR_VM_CREATE, drm_panthor_vm_create, ioctl::RENDER_ALLOW, TyrDrmFileData::vm_create),
+ (PANTHOR_VM_DESTROY, drm_panthor_vm_destroy, ioctl::RENDER_ALLOW, TyrDrmFileData::vm_destroy),
+ (PANTHOR_VM_BIND, drm_panthor_vm_bind, ioctl::RENDER_ALLOW, TyrDrmFileData::vm_bind),
+ (PANTHOR_VM_GET_STATE, drm_panthor_vm_get_state, ioctl::RENDER_ALLOW, TyrDrmFileData::vm_get_state),
}
}
diff --git a/drivers/gpu/drm/tyr/file.rs b/drivers/gpu/drm/tyr/file.rs
index 933a365cb016e..22a74b4abf3de 100644
--- a/drivers/gpu/drm/tyr/file.rs
+++ b/drivers/gpu/drm/tyr/file.rs
@@ -1,39 +1,64 @@
// SPDX-License-Identifier: GPL-2.0 or MIT
+use core::mem::offset_of;
+
use kernel::{
drm::{
self,
+ gem::BaseObject,
Registered, //
},
prelude::*,
- uaccess::UserSlice,
+ sizes::SizeConstants,
+ transmute::FromBytes,
+ uaccess::{
+ UserSlice,
+ UserSliceReader, //
+ },
uapi, //
};
-use crate::driver::{
- TyrDrmDevice,
- TyrDrmDriver,
- TyrDrmRegistrationData, //
+use crate::{
+ driver::{
+ TyrDrmDevice,
+ TyrDrmDriver,
+ TyrDrmRegistrationData, //
+ },
+ vm::{
+ UserVaRequest,
+ Vm,
+ VmBindOpType,
+ VmMapFlags,
+ VmPool, //
+ }, //
};
#[pin_data]
-pub(crate) struct TyrDrmFileData {}
+pub(crate) struct TyrDrmFileData<'a> {
+ reg: &'a TyrDrmRegistrationData<'a>,
+
+ #[pin]
+ vm_pool: VmPool<'a>,
+}
/// Convenience type alias for our DRM `File` type.
pub(crate) type TyrDrmFile = drm::file::File<TyrDrmDriver>;
-impl drm::file::DriverFile<'_> for TyrDrmFileData {
+impl<'a> drm::file::DriverFile<'a> for TyrDrmFileData<'a> {
type Driver = TyrDrmDriver;
fn open(
_device: &TyrDrmDevice<Registered>,
- _reg_data: &TyrDrmRegistrationData<'_>,
+ reg_data: &'a TyrDrmRegistrationData<'a>,
) -> impl PinInit<Self, Error> {
- Ok(Self {})
+ try_pin_init!(Self {
+ reg: reg_data,
+ vm_pool <- VmPool::new(reg_data.pdev.as_ref()),
+ })
}
}
-impl TyrDrmFileData {
+impl TyrDrmFileData<'_> {
pub(crate) fn dev_query(
_ddev: &TyrDrmDevice<Registered>,
reg_data: &TyrDrmRegistrationData<'_>,
@@ -65,4 +90,279 @@ pub(crate) fn dev_query(
}
}
}
+
+ pub(crate) fn vm_create(
+ ddev: &TyrDrmDevice<Registered>,
+ _reg_data: &TyrDrmRegistrationData<'_>,
+ vmcreate: &mut uapi::drm_panthor_vm_create,
+ file: &TyrDrmFile,
+ ) -> Result<u32> {
+ if vmcreate.flags != 0 {
+ dev_dbg!(
+ ddev.as_ref(),
+ "Invalid VM create flags: {:#x}\n",
+ vmcreate.flags
+ );
+ return Err(EINVAL);
+ }
+
+ let ret: Result<u32, Error> = file.inner_with(|pfile| {
+ let vm = Vm::new_for_user(
+ pfile.reg.pdev.as_ref(),
+ ddev,
+ pfile.reg.mmu.as_arc_borrow(),
+ &pfile.reg.gpu_info,
+ UserVaRequest::from_uapi(vmcreate.user_va_range),
+ )?;
+ let user_va_range = vm.layout.user.end;
+ let id = pfile.vm_pool.add(vm).map_err(|e| {
+ e.vm.kill();
+ e.error
+ })?;
+ vmcreate.user_va_range = user_va_range;
+ vmcreate.id = id;
+
+ Ok(0)
+ });
+ ret
+ }
+
+ pub(crate) fn vm_destroy(
+ ddev: &TyrDrmDevice<Registered>,
+ _reg_data: &TyrDrmRegistrationData<'_>,
+ vmdestroy: &mut uapi::drm_panthor_vm_destroy,
+ file: &TyrDrmFile,
+ ) -> Result<u32> {
+ if vmdestroy.pad != 0 {
+ dev_dbg!(
+ ddev.as_ref(),
+ "Invalid VM destroy pad: {:#x}\n",
+ vmdestroy.pad
+ );
+ return Err(EINVAL);
+ }
+
+ let ret: Result<u32, Error> = file.inner_with(|pfile| {
+ pfile.vm_pool.remove(vmdestroy.id)?;
+ Ok(0)
+ });
+ ret
+ }
+
+ pub(crate) fn vm_bind(
+ ddev: &TyrDrmDevice<Registered>,
+ _reg_data: &TyrDrmRegistrationData<'_>,
+ vmbind: &mut uapi::drm_panthor_vm_bind,
+ file: &TyrDrmFile,
+ ) -> Result<u32> {
+ let async_flag = uapi::drm_panthor_vm_bind_flags_DRM_PANTHOR_VM_BIND_ASYNC;
+
+ if vmbind.flags & !async_flag != 0 {
+ dev_dbg!(
+ ddev.as_ref(),
+ "Invalid VM_BIND flags: {:#x}\n",
+ vmbind.flags
+ );
+ return Err(EINVAL);
+ }
+
+ if vmbind.flags & async_flag != 0 {
+ dev_dbg!(ddev.as_ref(), "Async VM_BIND not supported\n");
+ return Err(EOPNOTSUPP);
+ }
+
+ let count = vmbind.ops.count as usize;
+ if count == 0 {
+ return Ok(0);
+ }
+
+ // Accept any stride that covers the trailing `syncs` array
+ // descriptor, so userspace built against older headers works.
+ static_assert!(
+ size_of::<VmBindOp>()
+ == offset_of!(uapi::drm_panthor_vm_bind_op, syncs)
+ + size_of::<uapi::drm_panthor_obj_array>()
+ );
+ let min_size = offset_of!(uapi::drm_panthor_vm_bind_op, syncs)
+ + size_of::<uapi::drm_panthor_obj_array>();
+ if min_size > vmbind.ops.stride as usize {
+ dev_dbg!(
+ ddev.as_ref(),
+ "Invalid VM_BIND op stride {} (expected at least {})\n",
+ vmbind.ops.stride,
+ size_of::<VmBindOp>()
+ );
+ return Err(EINVAL);
+ }
+ let stride = vmbind.ops.stride as usize;
+
+ let total_len = stride.checked_mul(count).ok_or_else(|| {
+ dev_dbg!(ddev.as_ref(), "VM_BIND ops length overflow\n");
+ EINVAL
+ })?;
+ let mut reader =
+ UserSlice::new(UserPtr::from_addr(vmbind.ops.array as usize), total_len).reader();
+ let mut ops = KVec::new();
+ for _ in 0..count {
+ ops.push(reader.read::<VmBindOp>()?, GFP_KERNEL)?;
+ read_padding_zero(&mut reader, stride - size_of::<VmBindOp>())?;
+ }
+
+ let ret: Result<u32, Error> = file.inner_with(|pfile| {
+ let vm = pfile.vm_pool.get(vmbind.vm_id).ok_or_else(|| {
+ dev_dbg!(ddev.as_ref(), "Invalid VM_BIND vm_id: {}\n", vmbind.vm_id);
+ EINVAL
+ })?;
+
+ for (i, op) in ops.iter().enumerate() {
+ if let Err(e) = vm_bind_exec_op(&vm, file, op) {
+ dev_dbg!(ddev.as_ref(), "VM_BIND op {} failed: {:?}\n", i, e);
+ vmbind.ops.count = i as u32;
+ return Err(e);
+ }
+ }
+
+ Ok(0)
+ });
+ ret
+ }
+
+ pub(crate) fn vm_get_state(
+ ddev: &TyrDrmDevice<Registered>,
+ _reg_data: &TyrDrmRegistrationData<'_>,
+ vmgetstate: &mut uapi::drm_panthor_vm_get_state,
+ file: &TyrDrmFile,
+ ) -> Result<u32> {
+ file.inner_with(|pfile| {
+ let vm = pfile.vm_pool.get(vmgetstate.vm_id).ok_or_else(|| {
+ dev_dbg!(
+ ddev.as_ref(),
+ "Invalid VM_GET_STATE vm_id: {}\n",
+ vmgetstate.vm_id
+ );
+ EINVAL
+ })?;
+ vmgetstate.state = if vm.is_unusable() {
+ uapi::drm_panthor_vm_state_DRM_PANTHOR_VM_STATE_UNUSABLE
+ } else {
+ uapi::drm_panthor_vm_state_DRM_PANTHOR_VM_STATE_USABLE
+ };
+ Ok(0)
+ })
+ }
+}
+
+fn vm_bind_exec_op(vm: &Vm<'_>, file: &TyrDrmFile, op: &VmBindOp) -> Result {
+ if op.size == 0 {
+ return Ok(());
+ }
+
+ if op.syncs.count != 0 {
+ dev_dbg!(vm.dev(), "VM_BIND op syncs not supported\n");
+ return Err(EINVAL);
+ }
+
+ let end = match op.va.checked_add(op.size) {
+ Some(end) => end,
+ None => {
+ dev_dbg!(vm.dev(), "VM_BIND op VA range overflow\n");
+ return Err(EINVAL);
+ }
+ };
+ if op.va < vm.layout.user.start || end > vm.layout.user.end {
+ dev_dbg!(
+ vm.dev(),
+ "VM_BIND op VA range {:#x}..{:#x} outside user range\n",
+ op.va,
+ end
+ );
+ return Err(EINVAL);
+ }
+
+ if (op.va | op.size | op.bo_offset) & (u64::SZ_4K - 1) != 0 {
+ dev_dbg!(vm.dev(), "VM_BIND op not GPU-page-aligned\n");
+ return Err(EINVAL);
+ }
+
+ match VmBindOpType::try_from(op.flags) {
+ Ok(VmBindOpType::Map) => {
+ // Once the VM is unusable only MAP ops are rejected; UNMAP
+ // stays available for cleanup (see the UAPI docs).
+ if vm.is_unusable() {
+ dev_err!(vm.dev(), "VM_BIND map op on unusable VM\n");
+ return Err(EINVAL);
+ }
+
+ let map_flags = match VmMapFlags::try_from(op.flags & !VmBindOpType::MASK) {
+ Ok(flags) => flags,
+ Err(_) => {
+ dev_dbg!(vm.dev(), "VM_BIND op invalid map flags {:#x}\n", op.flags);
+ return Err(EINVAL);
+ }
+ };
+ let bo = crate::gem::lookup_handle(file, op.bo_handle).map_err(|_| {
+ dev_dbg!(vm.dev(), "VM_BIND op invalid BO handle {}\n", op.bo_handle);
+ EINVAL
+ })?;
+ // Validate the BO window before mapping.
+ let bo_size = bo.size() as u64;
+ if op.size > bo_size || op.bo_offset > bo_size - op.size {
+ dev_dbg!(vm.dev(), "VM_BIND op BO range out of bounds\n");
+ return Err(EINVAL);
+ }
+ vm.map_bo_range(&bo, op.bo_offset, op.size, op.va, map_flags)
+ }
+ Ok(VmBindOpType::Unmap) => {
+ // Unmap must not carry map-specific flags or BO references.
+ if op.flags & !VmBindOpType::MASK != 0 || op.bo_handle != 0 || op.bo_offset != 0 {
+ dev_dbg!(
+ vm.dev(),
+ "VM_BIND UNMAP carries flags/BO refs: flags={:#x} bo_handle={} bo_offset={}\n",
+ op.flags,
+ op.bo_handle,
+ op.bo_offset
+ );
+ return Err(EINVAL);
+ }
+ vm.unmap_range(op.va, op.size)
+ }
+ Err(_) => {
+ dev_dbg!(
+ vm.dev(),
+ "VM_BIND op type {:#x} not supported\n",
+ op.flags & VmBindOpType::MASK
+ );
+ Err(EINVAL)
+ }
+ }
+}
+
+/// Reads `len` bytes of array padding, rejecting any nonzero byte with `E2BIG`.
+fn read_padding_zero(reader: &mut UserSliceReader, len: usize) -> Result {
+ let mut buf = [0u8; 64];
+ let mut remaining = len;
+ while remaining > 0 {
+ let chunk = remaining.min(buf.len());
+ reader.read_slice(&mut buf[..chunk])?;
+ if buf[..chunk].iter().any(|&b| b != 0) {
+ return Err(E2BIG);
+ }
+ remaining -= chunk;
+ }
+ Ok(())
}
+
+#[repr(transparent)]
+struct VmBindOp(uapi::drm_panthor_vm_bind_op);
+
+impl core::ops::Deref for VmBindOp {
+ type Target = uapi::drm_panthor_vm_bind_op;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+// SAFETY: `VmBindOp` contains only integers, so any bit pattern is valid;
+// the `#[repr(transparent)]` wrapper has the same layout as the UAPI struct.
+unsafe impl FromBytes for VmBindOp {}
diff --git a/drivers/gpu/drm/tyr/gem.rs b/drivers/gpu/drm/tyr/gem.rs
index 0e0989a48678f..60f6363995a5a 100644
--- a/drivers/gpu/drm/tyr/gem.rs
+++ b/drivers/gpu/drm/tyr/gem.rs
@@ -77,7 +77,6 @@ pub(crate) fn new_object(ddev: &TyrDrmDevice, size: usize, flags: u32) -> Result
}
/// Look up a GEM object by handle for a DRM file.
-#[expect(dead_code)]
pub(crate) fn lookup_handle(file: &TyrDrmFile, handle: u32) -> Result<ARef<Bo>> {
Bo::lookup_handle(file, handle)
}
diff --git a/drivers/gpu/drm/tyr/vm.rs b/drivers/gpu/drm/tyr/vm.rs
index adbf8edcd5c6f..597e35f864f64 100644
--- a/drivers/gpu/drm/tyr/vm.rs
+++ b/drivers/gpu/drm/tyr/vm.rs
@@ -53,6 +53,11 @@
},
sync::{
aref::ARef,
+ atomic::{
+ Acquire,
+ Atomic,
+ Release, //
+ },
Arc,
ArcBorrow,
Mutex, //
@@ -172,7 +177,6 @@ pub(crate) enum UserVaRequest {
impl UserVaRequest {
/// UAPI boundary normalization: `0` -> [`Auto`](Self::Auto).
- #[expect(dead_code)]
pub(crate) fn from_uapi(v: u64) -> Self {
match NonZeroU64::new(v) {
Some(size) => Self::Fixed(size),
@@ -181,6 +185,38 @@ pub(crate) fn from_uapi(v: u64) -> Self {
}
}
+/// Operation type, packed into the top nibble of
+/// `drm_panthor_vm_bind_op::flags`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum VmBindOpType {
+ /// Map a BO range into the VM.
+ Map,
+ /// Unmap a VA range.
+ Unmap,
+}
+
+impl VmBindOpType {
+ /// Bits occupied by the op type in `drm_panthor_vm_bind_op::flags`.
+ pub(crate) const MASK: u32 =
+ uapi::drm_panthor_vm_bind_op_flags_DRM_PANTHOR_VM_BIND_OP_TYPE_MASK as u32;
+}
+
+impl TryFrom<u32> for VmBindOpType {
+ type Error = Error;
+
+ fn try_from(flags: u32) -> Result<Self, Self::Error> {
+ const MAP: u32 = uapi::drm_panthor_vm_bind_op_flags_DRM_PANTHOR_VM_BIND_OP_TYPE_MAP as u32;
+ const UNMAP: u32 =
+ uapi::drm_panthor_vm_bind_op_flags_DRM_PANTHOR_VM_BIND_OP_TYPE_UNMAP as u32;
+
+ match flags & Self::MASK {
+ MAP => Ok(Self::Map),
+ UNMAP => Ok(Self::Unmap),
+ _ => Err(EINVAL),
+ }
+ }
+}
+
/// Final user/kernel VA layout for a VM.
pub(crate) struct VmLayout {
/// Full GPU VA range covered by this VM.
@@ -425,6 +461,8 @@ pub(crate) struct Vm<'drm> {
gpuvm: ARef<GpuVm<GpuVmData<'drm>>>,
/// VA layout for this VM.
pub(crate) layout: VmLayout,
+ /// Whether the VM is unusable.
+ unusable: Atomic<bool>,
}
impl<'drm> Vm<'drm> {
@@ -446,7 +484,6 @@ pub(crate) fn new_for_fw(
}
/// Creates a user VM, splitting the GPU VA range per `user_va`.
- #[expect(dead_code)]
pub(crate) fn new_for_user(
dev: &'drm Device<Bound>,
ddev: &TyrDrmDevice,
@@ -513,6 +550,7 @@ fn new_internal(
gpuvm,
gpuvm_unique <- new_mutex!(gpuvm_unique),
layout,
+ unusable: Atomic::new(false),
}),
GFP_KERNEL,
)?;
@@ -543,6 +581,7 @@ fn deactivate(&self) -> Result {
/// Kills the VM by deactivating it and unmapping all regions.
pub(crate) fn kill(&self) {
+ self.mark_unusable();
let _ = self.deactivate();
let _ = self
.unmap_range(
@@ -554,6 +593,15 @@ pub(crate) fn kill(&self) {
});
}
+ /// Marks the VM unusable.
+ fn mark_unusable(&self) {
+ self.unusable.store(true, Release);
+ }
+
+ pub(crate) fn is_unusable(&self) -> bool {
+ self.unusable.load(Acquire)
+ }
+
/// Executes a virtual memory operation.
///
/// This handles both map and unmap operations by coordinating between the
@@ -665,6 +713,17 @@ pub(crate) fn map_bo_range(
};
let result = {
let mut gpuvm_unique = self.gpuvm_unique.lock();
+ // Check under the GPUVM lock, which the kill path also takes to
+ // unmap, so this serializes against a concurrent teardown.
+ if self.is_unusable() {
+ dev_err!(
+ self.dev,
+ "Failed to map VA {:#x}..{:#x}: VM is unusable\n",
+ req.region.start,
+ req.region.end
+ );
+ return Err(EINVAL);
+ }
self.exec_op(gpuvm_unique.as_mut().get_mut(), req, &mut resources)
};
// We flush the defer cleanup list now. Things will be different in
@@ -1107,7 +1166,6 @@ pub(crate) struct AddError<'drm> {
impl<'drm> VmPool<'drm> {
/// Creates a new [`VmPool`].
- #[expect(dead_code)]
pub(crate) fn new(dev: &'drm Device<Bound>) -> impl PinInit<Self> {
let ids = IdPool::new();
pin_init!(Self {
@@ -1123,7 +1181,6 @@ pub(crate) fn new(dev: &'drm Device<Bound>) -> impl PinInit<Self> {
/// returned in an [`AddError`] so the caller owns the teardown.
// TODO: allocate IDs with the XArray directly (once it grows range
// allocation, the equivalent of C's `XA_LIMIT`) and drop the IdPool.
- #[expect(dead_code)]
pub(crate) fn add(&self, vm: Arc<Vm<'drm>>) -> Result<u32, AddError<'drm>> {
let id = (|| {
let mut ids = self.ids.lock();
@@ -1173,7 +1230,6 @@ pub(crate) fn add(&self, vm: Arc<Vm<'drm>>) -> Result<u32, AddError<'drm>> {
}
/// Removes and kills the VM with the given ID.
- #[expect(dead_code)]
pub(crate) fn remove(&self, id: u32) -> Result<()> {
let mut vms = self.vms.lock();
let vm = match vms.remove(id as usize) {
@@ -1190,7 +1246,6 @@ pub(crate) fn remove(&self, id: u32) -> Result<()> {
}
/// Gets a shared reference to the VM with the given ID.
- #[expect(dead_code)]
pub(crate) fn get(&self, id: u32) -> Option<Arc<Vm<'drm>>> {
let vms = self.vms.lock();
let borrow = vms.get(id as usize)?;
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 08/11] drm/tyr: add BO-related ioctls
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (6 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 07/11] drm/tyr: add VM-related ioctls Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 09/11] rust: device: expose the device DMA attribute Ke Sun via B4 Relay
` (2 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Alvin Sun <alvin.sun@linux.dev>
Implement BO_CREATE and BO_MMAP_OFFSET so userspace can allocate GPU
buffers and obtain a DRM mmap offset for the generic mmap path.
BO_CREATE page-aligns the requested size; BO_MMAP_OFFSET rejects
NO_MMAP objects, which must never be CPU-mapped.
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
---
drivers/gpu/drm/tyr/driver.rs | 2 ++
drivers/gpu/drm/tyr/file.rs | 73 +++++++++++++++++++++++++++++++++++++++++++
drivers/gpu/drm/tyr/gem.rs | 18 +++++++++--
3 files changed, 90 insertions(+), 3 deletions(-)
diff --git a/drivers/gpu/drm/tyr/driver.rs b/drivers/gpu/drm/tyr/driver.rs
index c0f17bc4ce2c9..f4f31b24180b4 100644
--- a/drivers/gpu/drm/tyr/driver.rs
+++ b/drivers/gpu/drm/tyr/driver.rs
@@ -227,6 +227,8 @@ impl drm::Driver for TyrDrmDriver {
(PANTHOR_VM_DESTROY, drm_panthor_vm_destroy, ioctl::RENDER_ALLOW, TyrDrmFileData::vm_destroy),
(PANTHOR_VM_BIND, drm_panthor_vm_bind, ioctl::RENDER_ALLOW, TyrDrmFileData::vm_bind),
(PANTHOR_VM_GET_STATE, drm_panthor_vm_get_state, ioctl::RENDER_ALLOW, TyrDrmFileData::vm_get_state),
+ (PANTHOR_BO_CREATE, drm_panthor_bo_create, ioctl::RENDER_ALLOW, TyrDrmFileData::bo_create),
+ (PANTHOR_BO_MMAP_OFFSET, drm_panthor_bo_mmap_offset, ioctl::RENDER_ALLOW, TyrDrmFileData::bo_mmap_offset),
}
}
diff --git a/drivers/gpu/drm/tyr/file.rs b/drivers/gpu/drm/tyr/file.rs
index 22a74b4abf3de..9ffb42f0d8851 100644
--- a/drivers/gpu/drm/tyr/file.rs
+++ b/drivers/gpu/drm/tyr/file.rs
@@ -250,6 +250,79 @@ pub(crate) fn vm_get_state(
Ok(0)
})
}
+
+ pub(crate) fn bo_create(
+ ddev: &TyrDrmDevice<Registered>,
+ _reg_data: &TyrDrmRegistrationData<'_>,
+ bocreate: &mut uapi::drm_panthor_bo_create,
+ file: &TyrDrmFile,
+ ) -> Result<u32> {
+ if bocreate.size == 0
+ || bocreate.pad != 0
+ || bocreate.flags & !uapi::drm_panthor_bo_flags_DRM_PANTHOR_BO_NO_MMAP != 0
+ {
+ dev_dbg!(
+ ddev.as_ref(),
+ "Invalid BO_CREATE params: size={}, pad={}, flags={:#x}\n",
+ bocreate.size,
+ bocreate.pad,
+ bocreate.flags
+ );
+ return Err(EINVAL);
+ }
+
+ if bocreate.exclusive_vm_id != 0 {
+ dev_dbg!(ddev.as_ref(), "BO_CREATE: exclusive_vm_id not supported\n");
+ return Err(EINVAL);
+ }
+
+ let size = usize::try_from(bocreate.size).map_err(|_| {
+ dev_dbg!(
+ ddev.as_ref(),
+ "BO_CREATE size {:#x} too large\n",
+ bocreate.size
+ );
+ EINVAL
+ })?;
+ let bo = crate::gem::new_object(ddev, size, bocreate.flags)?;
+ bocreate.handle = bo.create_handle(file)?;
+ bocreate.size = bo.size() as u64;
+
+ Ok(0)
+ }
+
+ pub(crate) fn bo_mmap_offset(
+ ddev: &TyrDrmDevice<Registered>,
+ _reg_data: &TyrDrmRegistrationData<'_>,
+ bommap: &mut uapi::drm_panthor_bo_mmap_offset,
+ file: &TyrDrmFile,
+ ) -> Result<u32> {
+ if bommap.pad != 0 {
+ dev_dbg!(
+ ddev.as_ref(),
+ "BO mmap offset pad not zero: {}\n",
+ bommap.pad
+ );
+ return Err(EINVAL);
+ }
+
+ let bo = crate::gem::lookup_handle(file, bommap.handle).inspect_err(|_| {
+ dev_dbg!(ddev.as_ref(), "Invalid BO mmap handle: {}\n", bommap.handle);
+ })?;
+ if bo.flags() & uapi::drm_panthor_bo_flags_DRM_PANTHOR_BO_NO_MMAP != 0 {
+ dev_dbg!(ddev.as_ref(), "BO mmap offset on NO_MMAP object\n");
+ return Err(EPERM);
+ }
+ bommap.offset = bo.create_mmap_offset().inspect_err(|_| {
+ dev_err!(
+ ddev.as_ref(),
+ "Failed to create mmap offset for handle {}\n",
+ bommap.handle
+ );
+ })?;
+
+ Ok(0)
+ }
}
fn vm_bind_exec_op(vm: &Vm<'_>, file: &TyrDrmFile, op: &VmBindOp) -> Result {
diff --git a/drivers/gpu/drm/tyr/gem.rs b/drivers/gpu/drm/tyr/gem.rs
index 60f6363995a5a..14f3e182b98e2 100644
--- a/drivers/gpu/drm/tyr/gem.rs
+++ b/drivers/gpu/drm/tyr/gem.rs
@@ -38,6 +38,13 @@ pub(crate) struct BoData {
flags: u32,
}
+impl BoData {
+ /// Returns the flags the BO was created with.
+ pub(crate) fn flags(&self) -> u32 {
+ self.flags
+ }
+}
+
/// Provides a way to pass arguments when creating BoData
/// as required by the gem::DriverObject trait.
pub(crate) struct BoCreateArgs {
@@ -57,7 +64,6 @@ fn new(_dev: &TyrDrmDevice, _size: usize, args: BoCreateArgs) -> impl PinInit<Se
pub(crate) type Bo = gem::shmem::Object<BoData>;
/// Create a new GEM buffer object.
-#[expect(dead_code)]
pub(crate) fn new_object(ddev: &TyrDrmDevice, size: usize, flags: u32) -> Result<ARef<Bo>> {
if size == 0 {
return Err(EINVAL);
@@ -65,7 +71,7 @@ pub(crate) fn new_object(ddev: &TyrDrmDevice, size: usize, flags: u32) -> Result
let aligned_size = size.checked_next_multiple_of(PAGE_SIZE).ok_or(EINVAL)?;
- Bo::new(
+ let bo = Bo::new(
ddev,
aligned_size,
shmem::ObjectConfig {
@@ -73,7 +79,13 @@ pub(crate) fn new_object(ddev: &TyrDrmDevice, size: usize, flags: u32) -> Result
parent_resv_obj: None,
},
BoCreateArgs { flags },
- )
+ )?;
+
+ // SAFETY: `ddev` is bound for the duration of this call.
+ let dev = unsafe { ddev.as_ref().as_ref().as_bound() };
+ bo.sg_table(dev)?;
+
+ Ok(bo)
}
/// Look up a GEM object by handle for a DRM file.
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 09/11] rust: device: expose the device DMA attribute
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (7 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 08/11] drm/tyr: add BO-related ioctls Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 10/11] drm/tyr: gem: flush write-combine BOs from probe-time coherence Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 11/11] drm/tyr: gem: map cached BOs for DRM_PANTHOR_BO_WB_MMAP Ke Sun via B4 Relay
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Sami Tolvanen <samitolvanen@google.com>
A driver may need to know whether its device is DMA-coherent, but
rust/kernel exposes no accessor for the attribute today.
Add a transparent DmaAttr wrapper around device_get_dma_attr(), so all
three attribute values (unset, non-coherent, coherent) are covered, and
an is_coherent() accessor for the boolean case.
Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
[ Replace dma_coherent() with a DmaAttr wrapper covering all three
attribute values. - Alvin ]
Co-developed-by: Alvin Sun <alvin.sun@linux.dev>
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
---
rust/kernel/device.rs | 24 ++++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs
index 2291d85b6849e..d5bbebdf620df 100644
--- a/rust/kernel/device.rs
+++ b/rust/kernel/device.rs
@@ -260,6 +260,30 @@ pub unsafe fn drvdata_borrow<T>(&self) -> Pin<&T> {
}
}
+/// The DMA attribute of a device, as reported by firmware. A transparent
+/// wrapper around the kernel's `enum dev_dma_attr`, covering all its states.
+#[repr(transparent)]
+pub struct DmaAttr(bindings::dev_dma_attr);
+
+impl DmaAttr {
+ /// This wraps `device_get_dma_attr()` and only returns `true` for the
+ /// `DEV_DMA_COHERENT` attribute; no attribute or `DEV_DMA_NON_COHERENT` is non-coherent.
+ #[inline]
+ pub fn is_coherent(&self) -> bool {
+ self.0 == bindings::dev_dma_attr_DEV_DMA_COHERENT
+ }
+}
+
+impl Device<Bound> {
+ /// Returns the DMA attribute of the device as reported by firmware.
+ #[inline]
+ pub fn dma_attr(&self) -> DmaAttr {
+ // SAFETY: By the type invariants, `self.as_raw()` is a valid pointer
+ // to a `struct device`.
+ unsafe { DmaAttr(bindings::device_get_dma_attr(self.as_raw())) }
+ }
+}
+
impl<Ctx: DeviceContext> Device<Ctx> {
/// Obtain the raw `struct device *`.
pub(crate) fn as_raw(&self) -> *mut bindings::device {
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 10/11] drm/tyr: gem: flush write-combine BOs from probe-time coherence
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (8 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 09/11] rust: device: expose the device DMA attribute Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
2026-10-20 8:25 ` [PATCH v4 11/11] drm/tyr: gem: map cached BOs for DRM_PANTHOR_BO_WB_MMAP Ke Sun via B4 Relay
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Sami Tolvanen <samitolvanen@google.com>
Tyr maps shmem-backed buffers write-combine, but the shmem layer
zero-inits new pages through a cached mapping. On a non-coherent device
those stale cache lines can land over later uncached writes, so the GPU
or userspace reads a freshly written value back as zero.
Read the device's coherence once at probe and map buffers write-back
when it's coherent, write-combine otherwise. BO_CREATE fetches the
sgtable at creation time so dma_map_sgtable() flushes the zeroed pages
before anyone accesses them uncached.
Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
[ Drop the map_wc-conditional sg_table call, now fetched
unconditionally in BO_CREATE. - Alvin ]
Co-developed-by: Alvin Sun <alvin.sun@linux.dev>
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
---
drivers/gpu/drm/tyr/driver.rs | 10 ++++++++++
drivers/gpu/drm/tyr/file.rs | 5 +++--
drivers/gpu/drm/tyr/fw.rs | 4 +++-
drivers/gpu/drm/tyr/gem.rs | 34 +++++++++++++++++++++++++---------
drivers/gpu/drm/tyr/vm.rs | 9 ++++++---
5 files changed, 47 insertions(+), 15 deletions(-)
diff --git a/drivers/gpu/drm/tyr/driver.rs b/drivers/gpu/drm/tyr/driver.rs
index f4f31b24180b4..633d1cab3cea9 100644
--- a/drivers/gpu/drm/tyr/driver.rs
+++ b/drivers/gpu/drm/tyr/driver.rs
@@ -88,6 +88,12 @@ pub(crate) struct TyrDrmRegistrationData<'drm> {
/// GPU information read from hardware during probe.
pub(crate) gpu_info: GpuInfo,
+
+ /// Whether the device is reported as DMA-coherent by firmware.
+ ///
+ /// Cached at probe via `device_get_dma_attr()`. Drives the BO
+ /// cacheability policy in `crate::gem::should_map_wc`.
+ pub(crate) coherent: bool,
}
fn issue_soft_reset(dev: &Device, iomem: &IoMem<'_>) -> Result {
@@ -152,6 +158,8 @@ fn probe<'bound>(
// other threads of execution.
unsafe { pdev.dma_set_mask_and_coherent(DmaMask::try_new(pa_bits)?)? };
+ let coherent = pdev.as_ref().dma_attr().is_coherent();
+
let unreg_dev = drm::UnregisteredDevice::<TyrDrmDriver>::new(pdev, Ok(()))?;
let mmu = Mmu::new(pdev.as_ref(), iomem.as_arc_borrow(), &gpu_info)?;
@@ -162,6 +170,7 @@ fn probe<'bound>(
&unreg_dev,
mmu.as_arc_borrow(),
&gpu_info,
+ coherent,
)?;
firmware.boot()?;
@@ -187,6 +196,7 @@ fn probe<'bound>(
}),
iomem,
gpu_info,
+ coherent,
}),
)},
_: { dev_dbg!(pdev, "Tyr initialized correctly.") },
diff --git a/drivers/gpu/drm/tyr/file.rs b/drivers/gpu/drm/tyr/file.rs
index 9ffb42f0d8851..d4d6a6742b2e1 100644
--- a/drivers/gpu/drm/tyr/file.rs
+++ b/drivers/gpu/drm/tyr/file.rs
@@ -113,6 +113,7 @@ pub(crate) fn vm_create(
pfile.reg.mmu.as_arc_borrow(),
&pfile.reg.gpu_info,
UserVaRequest::from_uapi(vmcreate.user_va_range),
+ pfile.reg.coherent,
)?;
let user_va_range = vm.layout.user.end;
let id = pfile.vm_pool.add(vm).map_err(|e| {
@@ -253,7 +254,7 @@ pub(crate) fn vm_get_state(
pub(crate) fn bo_create(
ddev: &TyrDrmDevice<Registered>,
- _reg_data: &TyrDrmRegistrationData<'_>,
+ reg_data: &TyrDrmRegistrationData<'_>,
bocreate: &mut uapi::drm_panthor_bo_create,
file: &TyrDrmFile,
) -> Result<u32> {
@@ -284,7 +285,7 @@ pub(crate) fn bo_create(
);
EINVAL
})?;
- let bo = crate::gem::new_object(ddev, size, bocreate.flags)?;
+ let bo = crate::gem::new_object(ddev, size, bocreate.flags, reg_data.coherent)?;
bocreate.handle = bo.create_handle(file)?;
bocreate.size = bo.size() as u64;
diff --git a/drivers/gpu/drm/tyr/fw.rs b/drivers/gpu/drm/tyr/fw.rs
index 81e8103368bc2..b24560ae10a4e 100644
--- a/drivers/gpu/drm/tyr/fw.rs
+++ b/drivers/gpu/drm/tyr/fw.rs
@@ -217,8 +217,9 @@ pub(crate) fn new(
ddev: &TyrDrmDevice,
mmu: ArcBorrow<'_, Mmu<'drm>>,
gpu_info: &GpuInfo,
+ coherent: bool,
) -> Result<Firmware<'drm>> {
- let vm = Vm::new_for_fw(dev, ddev, mmu, gpu_info)?;
+ let vm = Vm::new_for_fw(dev, ddev, mmu, gpu_info, coherent)?;
vm.activate()?;
let sections = (|| -> Result<KVec<Section<'drm>>> {
@@ -235,6 +236,7 @@ pub(crate) fn new(
size,
KernelBoVaAlloc::Explicit(va),
parsed.vm_map_flags,
+ coherent,
)?;
let section_start = parsed.data_range.start as usize;
diff --git a/drivers/gpu/drm/tyr/gem.rs b/drivers/gpu/drm/tyr/gem.rs
index 14f3e182b98e2..fad0720ce7123 100644
--- a/drivers/gpu/drm/tyr/gem.rs
+++ b/drivers/gpu/drm/tyr/gem.rs
@@ -63,19 +63,35 @@ fn new(_dev: &TyrDrmDevice, _size: usize, args: BoCreateArgs) -> impl PinInit<Se
/// Type alias for Tyr GEM buffer objects.
pub(crate) type Bo = gem::shmem::Object<BoData>;
+/// Returns whether a BO should be mapped write-combine given the device's
+/// DMA coherence.
+pub(crate) fn should_map_wc(coherent: bool) -> bool {
+ if coherent {
+ return false;
+ }
+
+ true
+}
+
/// Create a new GEM buffer object.
-pub(crate) fn new_object(ddev: &TyrDrmDevice, size: usize, flags: u32) -> Result<ARef<Bo>> {
+pub(crate) fn new_object(
+ ddev: &TyrDrmDevice,
+ size: usize,
+ flags: u32,
+ coherent: bool,
+) -> Result<ARef<Bo>> {
if size == 0 {
return Err(EINVAL);
}
let aligned_size = size.checked_next_multiple_of(PAGE_SIZE).ok_or(EINVAL)?;
+ let map_wc = should_map_wc(coherent);
let bo = Bo::new(
ddev,
aligned_size,
shmem::ObjectConfig {
- map_wc: true,
+ map_wc,
parent_resv_obj: None,
},
BoCreateArgs { flags },
@@ -94,18 +110,17 @@ pub(crate) fn lookup_handle(file: &TyrDrmFile, handle: u32) -> Result<ARef<Bo>>
}
/// Creates a dummy GEM object to serve as the root of a GPUVM.
-pub(crate) fn new_dummy_object(ddev: &TyrDrmDevice) -> Result<ARef<Bo>> {
- let bo = Bo::new(
+pub(crate) fn new_dummy_object(ddev: &TyrDrmDevice, coherent: bool) -> Result<ARef<Bo>> {
+ // FIXME: use a Rust resv-object abstraction once available, rather than a real BO.
+ Bo::new(
ddev,
4096,
shmem::ObjectConfig {
- map_wc: true,
+ map_wc: should_map_wc(coherent),
parent_resv_obj: None,
},
BoCreateArgs { flags: 0 },
- )?;
-
- Ok(bo)
+ )
}
/// Specifies how to choose a GPU virtual address for a [`KernelBo`].
@@ -143,6 +158,7 @@ pub(crate) fn new(
size: u64,
va_alloc: KernelBoVaAlloc,
flags: VmMapFlags,
+ coherent: bool,
) -> Result<Self> {
if size == 0 {
dev_err!(vm.dev(), "Cannot create KernelBo with size 0");
@@ -158,7 +174,7 @@ pub(crate) fn new(
ddev,
bo_size,
shmem::ObjectConfig {
- map_wc: true,
+ map_wc: should_map_wc(coherent),
parent_resv_obj: None,
},
BoCreateArgs { flags: 0 },
diff --git a/drivers/gpu/drm/tyr/vm.rs b/drivers/gpu/drm/tyr/vm.rs
index 597e35f864f64..576b2123a08ae 100644
--- a/drivers/gpu/drm/tyr/vm.rs
+++ b/drivers/gpu/drm/tyr/vm.rs
@@ -474,13 +474,14 @@ pub(crate) fn new_for_fw(
ddev: &TyrDrmDevice,
mmu: ArcBorrow<'_, Mmu<'drm>>,
gpu_info: &GpuInfo,
+ coherent: bool,
) -> Result<Arc<Vm<'drm>>> {
// As in panthor: the CSF MCU is a Cortex-M7 and can only address 4G.
let layout = VmLayout {
full: 0..u64::SZ_4G,
user: 0..0u64,
};
- Self::new_internal(dev, ddev, mmu, gpu_info, layout)
+ Self::new_internal(dev, ddev, mmu, gpu_info, layout, coherent)
}
/// Creates a user VM, splitting the GPU VA range per `user_va`.
@@ -490,6 +491,7 @@ pub(crate) fn new_for_user(
mmu: ArcBorrow<'_, Mmu<'drm>>,
gpu_info: &GpuInfo,
user_va: UserVaRequest,
+ coherent: bool,
) -> Result<Arc<Vm<'drm>>> {
let mmu_features = MMU_FEATURES::from_raw(gpu_info.mmu_features);
let va_bits = mmu_features.va_bits().get();
@@ -503,7 +505,7 @@ pub(crate) fn new_for_user(
range.end
);
})?;
- Self::new_internal(dev, ddev, mmu, gpu_info, layout)
+ Self::new_internal(dev, ddev, mmu, gpu_info, layout, coherent)
}
/// Initializes a VM with the given layout.
@@ -513,6 +515,7 @@ fn new_internal(
mmu: ArcBorrow<'_, Mmu<'drm>>,
gpu_info: &GpuInfo,
layout: VmLayout,
+ coherent: bool,
) -> Result<Arc<Vm<'drm>>> {
let mmu_features = MMU_FEATURES::from_raw(gpu_info.mmu_features);
let va_bits = mmu_features.va_bits().get();
@@ -521,7 +524,7 @@ fn new_internal(
let reserve_range = 0..0u64;
// dummy_obj is used to initialize the GPUVM tree.
- let dummy_obj = gem::new_dummy_object(ddev).inspect_err(|e| {
+ let dummy_obj = gem::new_dummy_object(ddev, coherent).inspect_err(|e| {
dev_err!(dev, "Failed to create dummy GEM object: {:?}", e);
})?;
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH v4 11/11] drm/tyr: gem: map cached BOs for DRM_PANTHOR_BO_WB_MMAP
2026-10-20 8:25 [PATCH v4 00/11] drm/tyr: add VM and BO ioctl support Ke Sun via B4 Relay
` (9 preceding siblings ...)
2026-10-20 8:25 ` [PATCH v4 10/11] drm/tyr: gem: flush write-combine BOs from probe-time coherence Ke Sun via B4 Relay
@ 2026-10-20 8:25 ` Ke Sun via B4 Relay
10 siblings, 0 replies; 13+ messages in thread
From: Ke Sun via B4 Relay @ 2026-10-20 8:25 UTC (permalink / raw)
To: Miguel Ojeda, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, Tamir Duberstein,
Alexandre Courbot, Onur Özkan, Lorenzo Stoakes,
Liam R. Howlett, Lyude Paul, David Airlie, Simona Vetter,
Greg Kroah-Hartman, Rafael J. Wysocki
Cc: Sami Tolvanen, rust-for-linux, linux-mm, dri-devel, driver-core,
Ke Sun, linux-kernel, Alvin Sun
From: Sami Tolvanen <samitolvanen@google.com>
Userspace may request a cacheable CPU mapping for a buffer it accesses
frequently. Accept DRM_PANTHOR_BO_WB_MMAP in bo_create and map the
buffer cached when the flag is set. Coherent devices already map
cached. NO_MMAP and WB_MMAP together are rejected with EINVAL.
On non-coherent platforms userspace owns the CPU cache maintenance
around GPU access to these buffers.
Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
[ Split the BO_CREATE validation and add the WB_MMAP flag checks
from the original. - Alvin ]
Co-developed-by: Alvin Sun <alvin.sun@linux.dev>
Signed-off-by: Alvin Sun <alvin.sun@linux.dev>
---
drivers/gpu/drm/tyr/file.rs | 25 +++++++++++++++++++------
drivers/gpu/drm/tyr/gem.rs | 18 +++++++++++-------
2 files changed, 30 insertions(+), 13 deletions(-)
diff --git a/drivers/gpu/drm/tyr/file.rs b/drivers/gpu/drm/tyr/file.rs
index d4d6a6742b2e1..6f4550d14bb39 100644
--- a/drivers/gpu/drm/tyr/file.rs
+++ b/drivers/gpu/drm/tyr/file.rs
@@ -258,19 +258,32 @@ pub(crate) fn bo_create(
bocreate: &mut uapi::drm_panthor_bo_create,
file: &TyrDrmFile,
) -> Result<u32> {
- if bocreate.size == 0
- || bocreate.pad != 0
- || bocreate.flags & !uapi::drm_panthor_bo_flags_DRM_PANTHOR_BO_NO_MMAP != 0
- {
+ if bocreate.size == 0 || bocreate.pad != 0 {
dev_dbg!(
ddev.as_ref(),
- "Invalid BO_CREATE params: size={}, pad={}, flags={:#x}\n",
+ "Invalid BO_CREATE params: size={}, pad={}\n",
bocreate.size,
- bocreate.pad,
+ bocreate.pad
+ );
+ return Err(EINVAL);
+ }
+
+ let no_mmap = uapi::drm_panthor_bo_flags_DRM_PANTHOR_BO_NO_MMAP;
+ let wb_mmap = uapi::drm_panthor_bo_flags_DRM_PANTHOR_BO_WB_MMAP;
+ let valid_flags = no_mmap | wb_mmap;
+
+ if bocreate.flags & !valid_flags != 0 {
+ dev_dbg!(
+ ddev.as_ref(),
+ "Invalid BO_CREATE flags: {:#x}\n",
bocreate.flags
);
return Err(EINVAL);
}
+ if bocreate.flags & no_mmap != 0 && bocreate.flags & wb_mmap != 0 {
+ dev_dbg!(ddev.as_ref(), "BO_CREATE: NO_MMAP conflicts with WB_MMAP\n");
+ return Err(EINVAL);
+ }
if bocreate.exclusive_vm_id != 0 {
dev_dbg!(ddev.as_ref(), "BO_CREATE: exclusive_vm_id not supported\n");
diff --git a/drivers/gpu/drm/tyr/gem.rs b/drivers/gpu/drm/tyr/gem.rs
index fad0720ce7123..d3791b62d5a7b 100644
--- a/drivers/gpu/drm/tyr/gem.rs
+++ b/drivers/gpu/drm/tyr/gem.rs
@@ -17,7 +17,8 @@
sync::{
aref::ARef,
Arc, //
- }, //
+ },
+ uapi, //
};
use crate::{
@@ -63,13 +64,16 @@ fn new(_dev: &TyrDrmDevice, _size: usize, args: BoCreateArgs) -> impl PinInit<Se
/// Type alias for Tyr GEM buffer objects.
pub(crate) type Bo = gem::shmem::Object<BoData>;
-/// Returns whether a BO should be mapped write-combine given the device's
-/// DMA coherence.
-pub(crate) fn should_map_wc(coherent: bool) -> bool {
+/// Returns whether a BO should be mapped write-combine.
+pub(crate) fn should_map_wc(coherent: bool, flags: u32) -> bool {
if coherent {
return false;
}
+ if flags & uapi::drm_panthor_bo_flags_DRM_PANTHOR_BO_WB_MMAP != 0 {
+ return false;
+ }
+
true
}
@@ -86,7 +90,7 @@ pub(crate) fn new_object(
let aligned_size = size.checked_next_multiple_of(PAGE_SIZE).ok_or(EINVAL)?;
- let map_wc = should_map_wc(coherent);
+ let map_wc = should_map_wc(coherent, flags);
let bo = Bo::new(
ddev,
aligned_size,
@@ -116,7 +120,7 @@ pub(crate) fn new_dummy_object(ddev: &TyrDrmDevice, coherent: bool) -> Result<AR
ddev,
4096,
shmem::ObjectConfig {
- map_wc: should_map_wc(coherent),
+ map_wc: should_map_wc(coherent, 0),
parent_resv_obj: None,
},
BoCreateArgs { flags: 0 },
@@ -174,7 +178,7 @@ pub(crate) fn new(
ddev,
bo_size,
shmem::ObjectConfig {
- map_wc: should_map_wc(coherent),
+ map_wc: should_map_wc(coherent, 0),
parent_resv_obj: None,
},
BoCreateArgs { flags: 0 },
--
2.43.0
^ permalink raw reply [flat|nested] 13+ messages in thread