1 // SPDX-License-Identifier: GPL-2.0
3 //! Generic kernel lock and guard.
5 //! It contains a generic Rust lock and guard that allow for different backends (e.g., mutexes,
22 /// The "backend" of a lock.
24 /// It is the actual implementation of the lock, without the need to repeat patterns used in all
29 /// - Implementers must ensure that only one thread/CPU may access the protected data once the lock
30 ///   is owned, that is, between calls to [`lock`] and [`unlock`].
31 /// - Implementers must also ensure that [`relock`] uses the same locking method as the original
32 ///   lock operation.
34 /// [`lock`]: Backend::lock
38     /// The state required by the lock.
39     type State;  typedef
41     /// The state required to be kept between [`lock`] and [`unlock`].
43     /// [`lock`]: Backend::lock
47     /// Initialises the lock.
54         ptr: *mut Self::State,  in init()  argument
59     /// Acquires the lock, making the caller its owner.
65     unsafe fn lock(ptr: *mut Self::State) -> Self::GuardState;  in lock()  method
67     /// Tries to acquire the lock.
72     unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState>;  in try_lock()
74     /// Releases the lock, giving up its ownership.
78     /// It must only be called by the current owner of the lock.
79     unsafe fn unlock(ptr: *mut Self::State, guard_state: &Self::GuardState);  in unlock()  argument
81     /// Reacquires the lock, making the caller its owner.
85     /// Callers must ensure that `guard_state` comes from a previous call to [`Backend::lock`] (or
87     unsafe fn relock(ptr: *mut Self::State, guard_state: &mut Self::GuardState) {  in relock()  argument
88         // SAFETY: The safety requirements ensure that the lock is initialised.  in relock()
89         *guard_state = unsafe { Self::lock(ptr) };  in relock()
92     /// Asserts that the lock is held using lockdep.
97     unsafe fn assert_is_held(ptr: *mut Self::State);  in assert_is_held()  argument
102 /// Exposes one of the kernel locking primitives. Which one is exposed depends on the lock
106 pub struct Lock<T: ?Sized, B: Backend> {  struct
107     /// The kernel lock object.
109     state: Opaque<B::State>,  field
111     /// Some locks are known to be self-referential (e.g., mutexes), while others are architecture
113     /// some architecture uses self-references now or in the future.
117     /// The data protected by the lock.
121 // SAFETY: `Lock` can be transferred across thread boundaries iff the data it protects can.  argument
122 unsafe impl<T: ?Sized + Send, B: Backend> Send for Lock<T, B> {}  implementation
124 // SAFETY: `Lock` serialises the interior mutability it provides, so it is `Sync` as long as the
126 unsafe impl<T: ?Sized + Send, B: Backend> Sync for Lock<T, B> {}  implementation
128 impl<T, B: Backend> Lock<T, B> {  implementation
129     /// Constructs a new lock initialiser.
130     pub fn new(t: T, name: &'static CStr, key: Pin<&'static LockClassKey>) -> impl PinInit<Self> {  in new()
136             state <- Opaque::ffi_init(|slot| unsafe {  in new()
143 impl<B: Backend> Lock<(), B> {  impl
144     /// Constructs a [`Lock`] from a raw pointer.
146     /// This can be useful for interacting with a lock which was initialised outside of Rust.
150     /// The caller promises that `ptr` points to a valid initialised instance of [`State`] during
153     /// [`State`]: Backend::State
154     pub unsafe fn from_raw<'a>(ptr: *mut B::State) -> &'a Self {  in from_raw()
156         // - By the safety contract `ptr` must point to a valid initialised instance of `B::State`  in from_raw()
157         // - Since the lock data type is `()` which is a ZST, `state` is the only non-ZST member of  in from_raw()
159         // - Combined with `#[repr(C)]`, this guarantees `Self` has an equivalent data layout to  in from_raw()
160         //   `B::State`.  in from_raw()
165 impl<T: ?Sized, B: Backend> Lock<T, B> {  impl
166     /// Acquires the lock and gives the caller access to the data protected by it.
167     pub fn lock(&self) -> Guard<'_, T, B> {  in lock()  method
170         let state = unsafe { B::lock(self.state.get()) };  in lock()  localVariable
171         // SAFETY: The lock was just acquired.  in lock()
172         unsafe { Guard::new(self, state) }  in lock()
175     /// Tries to acquire the lock.
177     /// Returns a guard that can be used to access the data protected by the lock if successful.
178     pub fn try_lock(&self) -> Option<Guard<'_, T, B>> {  in try_lock()
181         unsafe { B::try_lock(self.state.get()).map(|state| Guard::new(self, state)) }  in try_lock()
185 /// A lock guard.
189 /// protected by the lock.
190 #[must_use = "the lock unlocks immediately when the guard is unused"]
192     pub(crate) lock: &'a Lock<T, B>,  field
193     pub(crate) state: B::GuardState,  field
197 // SAFETY: `Guard` is sync when the data protected by the lock is also sync.
201     /// Returns the lock that this guard originates from.
206     /// lock is held.
209     /// # use kernel::{new_spinlock, sync::lock::{Backend, Guard, Lock}};
212     /// fn assert_held<T, B: Backend>(guard: &Guard<'_, T, B>, lock: &Lock<T, B>) {
213     ///     // Address-equal means the same lock.
214     ///     assert!(core::ptr::eq(guard.lock_ref(), lock));
217     /// // Creates a new lock on the stack.
222     /// let g = l.lock();
227     pub fn lock_ref(&self) -> &'a Lock<T, B> {  in lock_ref()
228         self.lock  in lock_ref()
231     pub(crate) fn do_unlocked<U>(&mut self, cb: impl FnOnce() -> U) -> U {  in do_unlocked()
232         // SAFETY: The caller owns the lock, so it is safe to unlock it.  in do_unlocked()
233         unsafe { B::unlock(self.lock.state.get(), &self.state) };  in do_unlocked()
236                 // SAFETY: The lock was just unlocked above and is being relocked now.  in do_unlocked()
237                 unsafe { B::relock(self.lock.state.get(), &mut self.state) });  in do_unlocked()
246     fn deref(&self) -> &Self::Target {  in deref()
247         // SAFETY: The caller owns the lock, so it is safe to deref the protected data.  in deref()
248         unsafe { &*self.lock.data.get() }  in deref()
253     fn deref_mut(&mut self) -> &mut Self::Target {  in deref_mut()
254         // SAFETY: The caller owns the lock, so it is safe to deref the protected data.  in deref_mut()
255         unsafe { &mut *self.lock.data.get() }  in deref_mut()
261         // SAFETY: The caller owns the lock, so it is safe to unlock it.  in drop()
262         unsafe { B::unlock(self.lock.state.get(), &self.state) };  in drop()
267     /// Constructs a new immutable lock guard.
271     /// The caller must ensure that it owns the lock.
272     pub unsafe fn new(lock: &'a Lock<T, B>, state: B::GuardState) -> Self {  in new()
273         // SAFETY: The caller can only hold the lock if `Backend::init` has already been called.  in new()
274         unsafe { B::assert_is_held(lock.state.get()) };  in new()
277             lock,  in new()
278             state,  in new()