From: Alvin Sun <[email protected]> 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. A failed insertion kills the VM before returning the error, and the pool kills every VM still stored when the file closes.
Signed-off-by: Alvin Sun <[email protected]> --- drivers/gpu/drm/tyr/vm.rs | 106 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 105 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/tyr/vm.rs b/drivers/gpu/drm/tyr/vm.rs index c5e307b1e2416..a2857820570cf 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,102 @@ 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> { + #[pin] + ids: Mutex<IdPool>, + #[pin] + vms: XArray<Arc<Vm<'drm>>>, +} + +impl<'drm> VmPool<'drm> { + /// Creates a new [`VmPool`]. + #[expect(dead_code)] + pub(crate) fn new() -> impl PinInit<Self> { + let ids = IdPool::new(); + pin_init!(Self { + ids <- new_mutex!(ids), + vms <- XArray::new(AllocKind::Alloc), + }) + } + + /// Stores the VM and returns the allocated ID. + /// + /// On failure - ID space exhausted or store failure - the VM is killed + /// here and only the error is returned. + // 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> { + 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); + } + unused.acquire() + }; + + let mut vms = self.vms.lock(); + match vms.store(id, vm, GFP_KERNEL) { + Ok(prev_vm) => { + drop(prev_vm); + Ok(id as u32) + } + Err(err) => { + // Drop the XArray spinlock before acquiring the `ids` mutex. + drop(vms); + // Kill the VM and release the pooled id before returning. + err.value.kill(); + self.ids.lock().release_id(id); + Err(err.error) + } + } + } + + /// Removes the VM with the given ID. + /// + /// The caller is responsible for killing the returned VM. + #[expect(dead_code)] + pub(crate) fn remove(&self, id: u32) -> Result<Arc<Vm<'drm>>> { + let mut vms = self.vms.lock(); + match vms.remove(id as usize) { + Some(vm) => { + drop(vms); + self.ids.lock().release_id(id as usize); + Ok(vm) + } + None => Err(EINVAL), + } + } + + /// 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
