Merge pull request #454 from wedsonaf/guard-state

rust: allow state to be saved in lock guards.

Author: wedsonaf

rust/kernel/sync/condvar.rs

@@ -81,12 +81,12 @@ impl CondVar {
         }
 
         // SAFETY: The guard is evidence that the caller owns the lock.
-        unsafe { lock.unlock() };
+        unsafe { lock.unlock(&mut guard.context) };
 
         // SAFETY: No arguments, switches to another thread.
         unsafe { bindings::schedule() };
 
-        lock.lock_noguard();
+        guard.context = lock.lock_noguard();
 
         // SAFETY: Both `wait` and `wait_list` point to valid memory.
         unsafe { bindings::finish_wait(self.wait_list.get(), wait.as_mut_ptr()) };

rust/kernel/sync/guard.rs

@@ -12,6 +12,7 @@
 #[must_use = "the lock unlocks immediately when the guard is unused"]
 pub struct Guard<'a, L: Lock + ?Sized> {
     pub(crate) lock: &'a L,
+    pub(crate) context: L::GuardContext,
 }
 
 // SAFETY: `Guard` is sync when the data protected by the lock is also sync. This is more
@@ -44,7 +45,7 @@ impl<L: Lock + ?Sized> core::ops::DerefMut for Guard<'_, L> {
 impl<L: Lock + ?Sized> Drop for Guard<'_, L> {
     fn drop(&mut self) {
         // SAFETY: The caller owns the lock, so it is safe to unlock it.
-        unsafe { self.lock.unlock() };
+        unsafe { self.lock.unlock(&mut self.context) };
     }
 }
 
@@ -54,8 +55,8 @@ impl<'a, L: Lock + ?Sized> Guard<'a, L> {
     /// # Safety
     ///
     /// The caller must ensure that it owns the lock.
-    pub(crate) unsafe fn new(lock: &'a L) -> Self {
-        Self { lock }
+    pub(crate) unsafe fn new(lock: &'a L, context: L::GuardContext) -> Self {
+        Self { lock, context }
     }
 }
 
@@ -67,15 +68,18 @@ pub trait Lock {
     /// The type of the data protected by the lock.
     type Inner: ?Sized;
 
+    /// The type of context, if any, that needs to be stored in the guard.
+    type GuardContext;
+
     /// Acquires the lock, making the caller its owner.
-    fn lock_noguard(&self);
+    fn lock_noguard(&self) -> Self::GuardContext;
 
     /// Releases the lock, giving up ownership of the lock.
     ///
     /// # Safety
     ///
     /// It must only be called by the current owner of the lock.
-    unsafe fn unlock(&self);
+    unsafe fn unlock(&self, context: &mut Self::GuardContext);
 
     /// Returns the data protected by the lock.
     fn locked_data(&self) -> &core::cell::UnsafeCell<Self::Inner>;

rust/kernel/sync/mutex.rs

@@ -67,7 +67,7 @@ impl<T: ?Sized> Mutex<T> {
     pub fn lock(&self) -> Guard<'_, Self> {
         self.lock_noguard();
         // SAFETY: The mutex was just acquired.
-        unsafe { Guard::new(self) }
+        unsafe { Guard::new(self, ()) }
     }
 }
 
@@ -83,15 +83,16 @@ extern "C" {
 
 impl<T: ?Sized> Lock for Mutex<T> {
     type Inner = T;
+    type GuardContext = ();
 
     fn lock_noguard(&self) {
         // SAFETY: `mutex` points to valid memory.
-        unsafe {
-            rust_helper_mutex_lock(self.mutex.get());
-        }
+        unsafe { rust_helper_mutex_lock(self.mutex.get()) };
     }
 
-    unsafe fn unlock(&self) {
+    unsafe fn unlock(&self, _: &mut ()) {
+        // SAFETY: The safety requirements of the function ensure that the mutex is owned by the
+        // caller.
         unsafe { bindings::mutex_unlock(self.mutex.get()) };
     }
 

rust/kernel/sync/spinlock.rs

@@ -81,7 +81,7 @@ impl<T: ?Sized> SpinLock<T> {
     pub fn lock(&self) -> Guard<'_, Self> {
         self.lock_noguard();
         // SAFETY: The spinlock was just acquired.
-        unsafe { Guard::new(self) }
+        unsafe { Guard::new(self, ()) }
     }
 }
 
@@ -93,13 +93,16 @@ impl<T: ?Sized> NeedsLockClass for SpinLock<T> {
 
 impl<T: ?Sized> Lock for SpinLock<T> {
     type Inner = T;
+    type GuardContext = ();
 
     fn lock_noguard(&self) {
         // SAFETY: `spin_lock` points to valid memory.
         unsafe { rust_helper_spin_lock(self.spin_lock.get()) };
     }
 
-    unsafe fn unlock(&self) {
+    unsafe fn unlock(&self, _: &mut ()) {
+        // SAFETY: The safety requirements of the function ensure that the spinlock is owned by the
+        // caller.
         unsafe { rust_helper_spin_unlock(self.spin_lock.get()) };
     }