Commit bf3d331b authored by Alice Ryhl's avatar Alice Ryhl Committed by Andrew Morton
Browse files

mm: rust: add vm_insert_page 

The vm_insert_page method is only usable on vmas with the VM_MIXEDMAP
flag, so we introduce a new type to keep track of such vmas.

The approach used in this patch assumes that we will not need to encode
many flag combinations in the type.  I don't think we need to encode more
than VM_MIXEDMAP and VM_PFNMAP as things are now.  However, if that
becomes necessary, using generic parameters in a single type would scale
better as the number of flags increases.

Link: https://lkml.kernel.org/r/20250408-vma-v16-3-d8b446e885d9@google.com


Signed-off-by: default avatarAlice Ryhl <aliceryhl@google.com>
Acked-by: default avatarLorenzo Stoakes <lorenzo.stoakes@oracle.com>
Acked-by: default avatarLiam R. Howlett <Liam.Howlett@Oracle.com>
Reviewed-by: default avatarAndreas Hindborg <a.hindborg@kernel.org>
Reviewed-by: default avatarGary Guo <gary@garyguo.net>
Cc: Alex Gaynor <alex.gaynor@gmail.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Balbir Singh <balbirs@nvidia.com>
Cc: Benno Lossin <benno.lossin@proton.me>
Cc: Björn Roy Baron <bjorn3_gh@protonmail.com>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jann Horn <jannh@google.com>
Cc: John Hubbard <jhubbard@nvidia.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Cc: Miguel Ojeda <ojeda@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Trevor Gross <tmgross@umich.edu>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 040f404b

rust/kernel/mm/virt.rs

+78 −1
Original line number Diff line number Diff line
@@ -14,7 +14,15 @@ 
//! ensures that you can't, for example, accidentally call a function that requires holding the

//! write lock when you only hold the read lock.



use crate::{bindings, mm::MmWithUser, types::Opaque};

use crate::{

    bindings,

    error::{to_result, Result},

    mm::MmWithUser,

    page::Page,

    types::Opaque,

};



use core::ops::Deref;



/// A wrapper for the kernel's `struct vm_area_struct` with read access.

///
@@ -119,6 +127,75 @@ pub fn zap_page_range_single(&self, address: usize, size: usize) { 
            bindings::zap_page_range_single(self.as_ptr(), address, size, core::ptr::null_mut())

        };

    }



    /// If the [`VM_MIXEDMAP`] flag is set, returns a [`VmaMixedMap`] to this VMA, otherwise

    /// returns `None`.

    ///

    /// This can be used to access methods that require [`VM_MIXEDMAP`] to be set.

    ///

    /// [`VM_MIXEDMAP`]: flags::MIXEDMAP

    #[inline]

    pub fn as_mixedmap_vma(&self) -> Option<&VmaMixedMap> {

        if self.flags() & flags::MIXEDMAP != 0 {

            // SAFETY: We just checked that `VM_MIXEDMAP` is set. All other requirements are

            // satisfied by the type invariants of `VmaRef`.

            Some(unsafe { VmaMixedMap::from_raw(self.as_ptr()) })

        } else {

            None

        }

    }

}



/// A wrapper for the kernel's `struct vm_area_struct` with read access and [`VM_MIXEDMAP`] set.

///

/// It represents an area of virtual memory.

///

/// This struct is identical to [`VmaRef`] except that it must only be used when the

/// [`VM_MIXEDMAP`] flag is set on the vma.

///

/// # Invariants

///

/// The caller must hold the mmap read lock or the vma read lock. The `VM_MIXEDMAP` flag must be

/// set.

///

/// [`VM_MIXEDMAP`]: flags::MIXEDMAP

#[repr(transparent)]

pub struct VmaMixedMap {

    vma: VmaRef,

}



// Make all `VmaRef` methods available on `VmaMixedMap`.

impl Deref for VmaMixedMap {

    type Target = VmaRef;



    #[inline]

    fn deref(&self) -> &VmaRef {

        &self.vma

    }

}



impl VmaMixedMap {

    /// Access a virtual memory area given a raw pointer.

    ///

    /// # Safety

    ///

    /// Callers must ensure that `vma` is valid for the duration of 'a, and that the mmap read lock

    /// (or stronger) is held for at least the duration of 'a. The `VM_MIXEDMAP` flag must be set.

    #[inline]

    pub unsafe fn from_raw<'a>(vma: *const bindings::vm_area_struct) -> &'a Self {

        // SAFETY: The caller ensures that the invariants are satisfied for the duration of 'a.

        unsafe { &*vma.cast() }

    }



    /// Maps a single page at the given address within the virtual memory area.

    ///

    /// This operation does not take ownership of the page.

    #[inline]

    pub fn vm_insert_page(&self, address: usize, page: &Page) -> Result {

        // SAFETY: By the type invariant of `Self` caller has read access and has verified that

        // `VM_MIXEDMAP` is set. By invariant on `Page` the page has order 0.

        to_result(unsafe { bindings::vm_insert_page(self.as_ptr(), address, page.as_ptr()) })

    }

}



/// The integer type used for vma flags.