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

mm: rust: add lock_vma_under_rcu 

Currently, the binder driver always uses the mmap lock to make changes to
its vma.  Because the mmap lock is global to the process, this can involve
significant contention.  However, the kernel has a feature called per-vma
locks, which can significantly reduce contention.  For example, you can
take a vma lock in parallel with an mmap write lock.  This is important
because contention on the mmap lock has been a long-term recurring
challenge for the Binder driver.

This patch introduces support for using `lock_vma_under_rcu` from Rust. 
The Rust Binder driver will be able to use this to reduce contention on
the mmap lock.

Link: https://lkml.kernel.org/r/20250408-vma-v16-4-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 avatarJann Horn <jannh@google.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: 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 bf3d331b

rust/helpers/mm.c

+5 −0
Original line number Diff line number Diff line
@@ -43,3 +43,8 @@ struct vm_area_struct *rust_helper_vma_lookup(struct mm_struct *mm, 
{

	return vma_lookup(mm, addr);

}



void rust_helper_vma_end_read(struct vm_area_struct *vma)

{

	vma_end_read(vma);

}

rust/kernel/mm.rs

+60 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
use core::{ops::Deref, ptr::NonNull};



pub mod virt;

use virt::VmaRef;



/// A wrapper for the kernel's `struct mm_struct`.

///
@@ -161,6 +162,36 @@ pub unsafe fn from_raw<'a>(ptr: *const bindings::mm_struct) -> &'a MmWithUser { 
        unsafe { &*ptr.cast() }

    }



    /// Attempt to access a vma using the vma read lock.

    ///

    /// This is an optimistic trylock operation, so it may fail if there is contention. In that

    /// case, you should fall back to taking the mmap read lock.

    ///

    /// When per-vma locks are disabled, this always returns `None`.

    #[inline]

    pub fn lock_vma_under_rcu(&self, vma_addr: usize) -> Option<VmaReadGuard<'_>> {

        #[cfg(CONFIG_PER_VMA_LOCK)]

        {

            // SAFETY: Calling `bindings::lock_vma_under_rcu` is always okay given an mm where

            // `mm_users` is non-zero.

            let vma = unsafe { bindings::lock_vma_under_rcu(self.as_raw(), vma_addr) };

            if !vma.is_null() {

                return Some(VmaReadGuard {

                    // SAFETY: If `lock_vma_under_rcu` returns a non-null ptr, then it points at a

                    // valid vma. The vma is stable for as long as the vma read lock is held.

                    vma: unsafe { VmaRef::from_raw(vma) },

                    _nts: NotThreadSafe,

                });

            }

        }



        // Silence warnings about unused variables.

        #[cfg(not(CONFIG_PER_VMA_LOCK))]

        let _ = vma_addr;



        None

    }



    /// Lock the mmap read lock.

    #[inline]

    pub fn mmap_read_lock(&self) -> MmapReadGuard<'_> {
@@ -231,3 +262,32 @@ fn drop(&mut self) { 
        unsafe { bindings::mmap_read_unlock(self.mm.as_raw()) };

    }

}



/// A guard for the vma read lock.

///

/// # Invariants

///

/// This `VmaReadGuard` guard owns the vma read lock.

pub struct VmaReadGuard<'a> {

    vma: &'a VmaRef,

    // `vma_end_read` must be called on the same thread as where the lock was taken

    _nts: NotThreadSafe,

}



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

impl Deref for VmaReadGuard<'_> {

    type Target = VmaRef;



    #[inline]

    fn deref(&self) -> &VmaRef {

        self.vma

    }

}



impl Drop for VmaReadGuard<'_> {

    #[inline]

    fn drop(&mut self) {

        // SAFETY: We hold the read lock by the type invariants.

        unsafe { bindings::vma_end_read(self.vma.as_ptr()) };

    }

}