Commit fbd7a5a0 authored by Lyude Paul's avatar Lyude Paul Committed by Boqun Feng
Browse files

rust: sync: Add lock::Backend::assert_is_held() 



Since we've exposed Lock::from_raw() and Guard::new() publically, we
want to be able to make sure that we assert that a lock is actually held
when constructing a Guard for it to handle instances of unsafe
Guard::new() calls outside of our lock module.

Hence add a new method assert_is_held() to Backend, which uses lockdep
to check whether or not a lock has been acquired. When lockdep is
disabled, this has no overhead.

[Boqun: Resolve the conflicts with exposing Guard::new(), reword the
 commit log a bit and format "unsafe { <statement>; }" into "unsafe {
 <statement> }" for the consistency. ]

Signed-off-by: default avatarLyude Paul <lyude@redhat.com>
Signed-off-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Link: https://lore.kernel.org/r/20241125204139.656801-1-lyude@redhat.com
parent eb5ccb03

rust/helpers/mutex.c

+5 −0
Original line number Diff line number Diff line
@@ -12,3 +12,8 @@ void rust_helper___mutex_init(struct mutex *mutex, const char *name, 
{

	__mutex_init(mutex, name, key);

}



void rust_helper_mutex_assert_is_held(struct mutex *mutex)

{

	lockdep_assert_held(mutex);

}

rust/helpers/spinlock.c

+5 −0
Original line number Diff line number Diff line
@@ -30,3 +30,8 @@ int rust_helper_spin_trylock(spinlock_t *lock) 
{

	return spin_trylock(lock);

}



void rust_helper_spin_assert_is_held(spinlock_t *lock)

{

	lockdep_assert_held(lock);

}

rust/kernel/sync/lock.rs

+10 −0
Original line number Diff line number Diff line
@@ -90,6 +90,13 @@ unsafe fn relock(ptr: *mut Self::State, guard_state: &mut Self::GuardState) { 
        // SAFETY: The safety requirements ensure that the lock is initialised.

        *guard_state = unsafe { Self::lock(ptr) };

    }



    /// Asserts that the lock is held using lockdep.

    ///

    /// # Safety

    ///

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

    unsafe fn assert_is_held(ptr: *mut Self::State);

}



/// A mutual exclusion primitive.
@@ -235,6 +242,9 @@ impl<'a, T: ?Sized, B: Backend> Guard<'a, T, B> { 
    ///

    /// The caller must ensure that it owns the lock.

    pub unsafe fn new(lock: &'a Lock<T, B>, state: B::GuardState) -> Self {

        // SAFETY: The caller can only hold the lock if `Backend::init` has already been called.

        unsafe { B::assert_is_held(lock.state.get()) };



        Self {

            lock,

            state,

rust/kernel/sync/lock/mutex.rs

+5 −0
Original line number Diff line number Diff line
@@ -134,4 +134,9 @@ unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState> { 
            None

        }

    }



    unsafe fn assert_is_held(ptr: *mut Self::State) {

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

        unsafe { bindings::mutex_assert_is_held(ptr) }

    }

}

rust/kernel/sync/lock/spinlock.rs

+5 −0
Original line number Diff line number Diff line
@@ -133,4 +133,9 @@ unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState> { 
            None

        }

    }



    unsafe fn assert_is_held(ptr: *mut Self::State) {

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

        unsafe { bindings::spin_assert_is_held(ptr) }

    }

}