rust: allow state to be saved in lock guards.

No functional changes are expected.

This is in preparation for adding spinlocks that disable interrupts when
locking and restore interrupt state when unlocking. We need to save the
interrupt state to be stored.

Signed-off-by: Wedson Almeida Filho <[email protected]>

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()) };
     }