rust/kernel/drm/gpuvm/va.rs

Source file repositories/reference/linux-study-clean/rust/kernel/drm/gpuvm/va.rs

File Facts

System
Linux kernel
Corpus path
rust/kernel/drm/gpuvm/va.rs
Extension
.rs
Size
5360 bytes
Lines
169
Domain
Rust Kernel Layer
Bucket
Rust API Membrane
Inferred role
Rust Kernel Layer: implementation source
Status
source implementation candidate

Why This File Exists

Rust-side wrappers and abstractions around kernel C APIs, ownership contracts, allocation, synchronization, and module integration.

Dependency Surface

Detected Declarations

Annotated Snippet

// SPDX-License-Identifier: GPL-2.0 OR MIT

use super::*;

/// Represents that a range of a GEM object is mapped in this [`GpuVm`] instance.
///
/// Does not assume that GEM lock is held.
///
/// # Invariants
///
/// * This is a valid `drm_gpuva` object that is resident in a [`GpuVm<T>`] instance.
/// * It is associated with a [`GpuVmBo<T>`]. Or in other words, it's not an
///   `gpuvm->kernel_alloc_node` and `DRM_GPUVA_SPARSE` is not set.
/// * The associated [`GpuVmBo<T>`] is part of the GEM list.
#[repr(C)]
#[pin_data]
pub struct GpuVa<T: DriverGpuVm> {
    #[pin]
    inner: Opaque<bindings::drm_gpuva>,
    #[pin]
    data: T::VaData,
}

impl<T: DriverGpuVm> PartialEq for GpuVa<T> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        core::ptr::eq(self.as_raw(), other.as_raw())
    }
}
impl<T: DriverGpuVm> Eq for GpuVa<T> {}

impl<T: DriverGpuVm> GpuVa<T> {
    /// Access this [`GpuVa`] from a raw pointer.
    ///
    /// # Safety
    ///
    /// * For the duration of `'a`, the pointer must reference a valid `drm_gpuva` associated with
    ///   a [`GpuVm<T>`].
    /// * It must be associated with a [`GpuVmBo<T>`].
    /// * The associated [`GpuVmBo<T>`] is part of the GEM list.
    #[inline]
    pub unsafe fn from_raw<'a>(ptr: *mut bindings::drm_gpuva) -> &'a Self {
        // CAST: `drm_gpuva` is first field and `repr(C)`.
        // SAFETY: The safety requirements match the invariants of `GpuVa`.
        unsafe { &*ptr.cast() }
    }

    /// Returns a raw pointer to underlying C value.
    #[inline]
    pub fn as_raw(&self) -> *mut bindings::drm_gpuva {
        self.inner.get()
    }

    /// Returns the address of this mapping in the GPU virtual address space.
    #[inline]
    pub fn addr(&self) -> u64 {
        // SAFETY: The `va.addr` field of `drm_gpuva` is immutable.
        unsafe { (*self.as_raw()).va.addr }
    }

    /// Returns the length of this mapping.
    #[inline]
    pub fn length(&self) -> u64 {
        // SAFETY: The `va.range` field of `drm_gpuva` is immutable.
        unsafe { (*self.as_raw()).va.range }
    }

    /// Returns `addr..addr+length`.
    #[inline]
    pub fn range(&self) -> Range<u64> {
        let addr = self.addr();
        addr..addr + self.length()
    }

    /// Returns the offset within the GEM object.
    #[inline]
    pub fn gem_offset(&self) -> u64 {
        // SAFETY: The `gem.offset` field of `drm_gpuva` is immutable.
        unsafe { (*self.as_raw()).gem.offset }
    }

    /// Returns the GEM object.
    #[inline]
    pub fn obj(&self) -> &T::Object {
        // SAFETY: The `gem.obj` field of `drm_gpuva` is immutable. We know that it's not null
        // because this VA is associated with a `GpuVmBo<T>`.
        unsafe { <T::Object as IntoGEMObject>::from_raw((*self.as_raw()).gem.obj) }
    }

    /// Returns the underlying [`GpuVmBo`] object that backs this [`GpuVa`].

Annotation

Implementation Notes