Commit f4c2c90b authored by Filipe Xavier's avatar Filipe Xavier Committed by Miguel Ojeda
Browse files

rust: lock: add trylock method support for lock backend 

Add a non-blocking trylock method to lock backend interface, mutex and
spinlock implementations. It includes a C helper for spin_trylock.

Rust Binder will use this method together with the new shrinker
abstractions to avoid deadlocks in the memory shrinker.

Link: https://lore.kernel.org/all/20240912-shrinker-v1-1-18b7f1253553@google.com


Signed-off-by: default avatarFilipe Xavier <felipe_life@live.com>
Reviewed-by: default avatarFiona Behrens <me@kloenk.dev>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Link: https://lore.kernel.org/r/BL0PR02MB4914579914884B5D7473B3D6E96A2@BL0PR02MB4914.namprd02.prod.outlook.com


[ Slightly reworded. - Miguel ]
Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent 3566362d

rust/helpers/spinlock.c

+5 −0
Original line number Diff line number Diff line
@@ -22,3 +22,8 @@ void rust_helper_spin_unlock(spinlock_t *lock) 
{

	spin_unlock(lock);

}



int rust_helper_spin_trylock(spinlock_t *lock)

{

	return spin_trylock(lock);

}

rust/kernel/sync/lock.rs

+16 −0
Original line number Diff line number Diff line
@@ -58,6 +58,13 @@ unsafe fn init( 
    #[must_use]

    unsafe fn lock(ptr: *mut Self::State) -> Self::GuardState;



    /// Tries to acquire the lock.

    ///

    /// # Safety

    ///

    /// Callers must ensure that [`Backend::init`] has been previously called.

    unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState>;



    /// Releases the lock, giving up its ownership.

    ///

    /// # Safety
@@ -128,6 +135,15 @@ pub fn lock(&self) -> Guard<'_, T, B> { 
        // SAFETY: The lock was just acquired.

        unsafe { Guard::new(self, state) }

    }



    /// Tries to acquire the lock.

    ///

    /// Returns a guard that can be used to access the data protected by the lock if successful.

    pub fn try_lock(&self) -> Option<Guard<'_, T, B>> {

        // SAFETY: The constructor of the type calls `init`, so the existence of the object proves

        // that `init` was called.

        unsafe { B::try_lock(self.state.get()).map(|state| Guard::new(self, state)) }

    }

}



/// A lock guard.

rust/kernel/sync/lock/mutex.rs

+11 −0
Original line number Diff line number Diff line
@@ -115,4 +115,15 @@ unsafe fn unlock(ptr: *mut Self::State, _guard_state: &Self::GuardState) { 
        // caller is the owner of the mutex.

        unsafe { bindings::mutex_unlock(ptr) };

    }



    unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState> {

        // SAFETY: The `ptr` pointer is guaranteed to be valid and initialized before use.

        let result = unsafe { bindings::mutex_trylock(ptr) };



        if result != 0 {

            Some(())

        } else {

            None

        }

    }

}

rust/kernel/sync/lock/spinlock.rs

+11 −0
Original line number Diff line number Diff line
@@ -114,4 +114,15 @@ unsafe fn unlock(ptr: *mut Self::State, _guard_state: &Self::GuardState) { 
        // caller is the owner of the spinlock.

        unsafe { bindings::spin_unlock(ptr) }

    }



    unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState> {

        // SAFETY: The `ptr` pointer is guaranteed to be valid and initialized before use.

        let result = unsafe { bindings::spin_trylock(ptr) };



        if result != 0 {

            Some(())

        } else {

            None

        }

    }

}