Annotate sync functions

04_safe_globals/README.md

@@ -313,7 +313,7 @@ diff -uNr 03_hacky_hello_world/src/synchronization.rs 04_safe_globals/src/synchr
 +        type Data;
 +
 +        /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-+        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
++        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 +    }
 +}
 +
@@ -354,7 +354,7 @@ diff -uNr 03_hacky_hello_world/src/synchronization.rs 04_safe_globals/src/synchr
 +impl<T> interface::Mutex for NullLock<T> {
 +    type Data = T;
 +
-+    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
++    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
 +        // In a real lock, there would be code encapsulating this line that ensures that this
 +        // mutable reference will ever only be given out once at a time.
 +        let data = unsafe { &mut *self.data.get() };

04_safe_globals/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

05_drivers_gpio_uart/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

06_uart_chainloader/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

07_timestamps/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

08_hw_debug_JTAG/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

09_privilege_level/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

10_virtual_mem_part1_identity_mapping/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

11_exceptions_part1_groundwork/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

12_integrated_testing/kernel/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };

13_exceptions_part2_peripheral_IRQs/README.md

@@ -2605,7 +2605,7 @@ diff -uNr 12_integrated_testing/kernel/src/synchronization.rs 13_exceptions_part
 +++ 13_exceptions_part2_peripheral_IRQs/kernel/src/synchronization.rs
 @@ -28,6 +28,21 @@
          /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-         fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+         fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
      }
 +
 +    /// A reader-writer exclusion type.
@@ -2617,10 +2617,10 @@ diff -uNr 12_integrated_testing/kernel/src/synchronization.rs 13_exceptions_part
 +        type Data;
 +
 +        /// Grants temporary mutable access to the encapsulated data.
-+        fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
++        fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 +
 +        /// Grants temporary immutable access to the encapsulated data.
-+        fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R;
++        fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R;
 +    }
  }
 
@@ -2682,7 +2682,7 @@ diff -uNr 12_integrated_testing/kernel/src/synchronization.rs 13_exceptions_part
 +impl<T> interface::Mutex for IRQSafeNullLock<T> {
      type Data = T;
 
-     fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+     fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
 @@ -72,6 +110,50 @@
          // mutable reference will ever only be given out once at a time.
          let data = unsafe { &mut *self.data.get() };
@@ -2695,7 +2695,7 @@ diff -uNr 12_integrated_testing/kernel/src/synchronization.rs 13_exceptions_part
 +impl<T> interface::ReadWriteEx for InitStateLock<T> {
 +    type Data = T;
 +
-+    fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
++    fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
 +        assert!(
 +            state::state_manager().is_init(),
 +            "InitStateLock::write called after kernel init phase"
@@ -2710,7 +2710,7 @@ diff -uNr 12_integrated_testing/kernel/src/synchronization.rs 13_exceptions_part
          f(data)
      }
 +
-+    fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
++    fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R {
 +        let data = unsafe { &*self.data.get() };
 +
 +        f(data)

13_exceptions_part2_peripheral_IRQs/kernel/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 
     /// A reader-writer exclusion type.
@@ -38,10 +38,10 @@ pub mod interface {
         type Data;
 
         /// Grants temporary mutable access to the encapsulated data.
-        fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 
         /// Grants temporary immutable access to the encapsulated data.
-        fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R;
+        fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R;
     }
 }
 
@@ -105,7 +105,7 @@ use crate::{exception, state};
 impl<T> interface::Mutex for IRQSafeNullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };
@@ -118,7 +118,7 @@ impl<T> interface::Mutex for IRQSafeNullLock<T> {
 impl<T> interface::ReadWriteEx for InitStateLock<T> {
     type Data = T;
 
-    fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         assert!(
             state::state_manager().is_init(),
             "InitStateLock::write called after kernel init phase"
@@ -133,7 +133,7 @@ impl<T> interface::ReadWriteEx for InitStateLock<T> {
         f(data)
     }
 
-    fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
+    fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R {
         let data = unsafe { &*self.data.get() };
 
         f(data)

14_virtual_mem_part2_mmio_remap/kernel/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 
     /// A reader-writer exclusion type.
@@ -38,10 +38,10 @@ pub mod interface {
         type Data;
 
         /// Grants temporary mutable access to the encapsulated data.
-        fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 
         /// Grants temporary immutable access to the encapsulated data.
-        fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R;
+        fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R;
     }
 }
 
@@ -105,7 +105,7 @@ use crate::{exception, state};
 impl<T> interface::Mutex for IRQSafeNullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };
@@ -118,7 +118,7 @@ impl<T> interface::Mutex for IRQSafeNullLock<T> {
 impl<T> interface::ReadWriteEx for InitStateLock<T> {
     type Data = T;
 
-    fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         assert!(
             state::state_manager().is_init(),
             "InitStateLock::write called after kernel init phase"
@@ -133,7 +133,7 @@ impl<T> interface::ReadWriteEx for InitStateLock<T> {
         f(data)
     }
 
-    fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
+    fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R {
         let data = unsafe { &*self.data.get() };
 
         f(data)

15_virtual_mem_part3_precomputed_tables/kernel/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 
     /// A reader-writer exclusion type.
@@ -38,10 +38,10 @@ pub mod interface {
         type Data;
 
         /// Grants temporary mutable access to the encapsulated data.
-        fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 
         /// Grants temporary immutable access to the encapsulated data.
-        fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R;
+        fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R;
     }
 }
 
@@ -105,7 +105,7 @@ use crate::{exception, state};
 impl<T> interface::Mutex for IRQSafeNullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };
@@ -118,7 +118,7 @@ impl<T> interface::Mutex for IRQSafeNullLock<T> {
 impl<T> interface::ReadWriteEx for InitStateLock<T> {
     type Data = T;
 
-    fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         assert!(
             state::state_manager().is_init(),
             "InitStateLock::write called after kernel init phase"
@@ -133,7 +133,7 @@ impl<T> interface::ReadWriteEx for InitStateLock<T> {
         f(data)
     }
 
-    fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
+    fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R {
         let data = unsafe { &*self.data.get() };
 
         f(data)

16_virtual_mem_part4_higher_half_kernel/kernel/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 
     /// A reader-writer exclusion type.
@@ -38,10 +38,10 @@ pub mod interface {
         type Data;
 
         /// Grants temporary mutable access to the encapsulated data.
-        fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 
         /// Grants temporary immutable access to the encapsulated data.
-        fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R;
+        fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R;
     }
 }
 
@@ -105,7 +105,7 @@ use crate::{exception, state};
 impl<T> interface::Mutex for IRQSafeNullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };
@@ -118,7 +118,7 @@ impl<T> interface::Mutex for IRQSafeNullLock<T> {
 impl<T> interface::ReadWriteEx for InitStateLock<T> {
     type Data = T;
 
-    fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         assert!(
             state::state_manager().is_init(),
             "InitStateLock::write called after kernel init phase"
@@ -133,7 +133,7 @@ impl<T> interface::ReadWriteEx for InitStateLock<T> {
         f(data)
     }
 
-    fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
+    fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R {
         let data = unsafe { &*self.data.get() };
 
         f(data)

17_kernel_symbols/kernel/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 
     /// A reader-writer exclusion type.
@@ -38,10 +38,10 @@ pub mod interface {
         type Data;
 
         /// Grants temporary mutable access to the encapsulated data.
-        fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 
         /// Grants temporary immutable access to the encapsulated data.
-        fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R;
+        fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R;
     }
 }
 
@@ -105,7 +105,7 @@ use crate::{exception, state};
 impl<T> interface::Mutex for IRQSafeNullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };
@@ -118,7 +118,7 @@ impl<T> interface::Mutex for IRQSafeNullLock<T> {
 impl<T> interface::ReadWriteEx for InitStateLock<T> {
     type Data = T;
 
-    fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         assert!(
             state::state_manager().is_init(),
             "InitStateLock::write called after kernel init phase"
@@ -133,7 +133,7 @@ impl<T> interface::ReadWriteEx for InitStateLock<T> {
         f(data)
     }
 
-    fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
+    fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R {
         let data = unsafe { &*self.data.get() };
 
         f(data)

18_backtrace/kernel/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 
     /// A reader-writer exclusion type.
@@ -38,10 +38,10 @@ pub mod interface {
         type Data;
 
         /// Grants temporary mutable access to the encapsulated data.
-        fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
 
         /// Grants temporary immutable access to the encapsulated data.
-        fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R;
+        fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R;
     }
 }
 
@@ -105,7 +105,7 @@ use crate::{exception, state};
 impl<T> interface::Mutex for IRQSafeNullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };
@@ -118,7 +118,7 @@ impl<T> interface::Mutex for IRQSafeNullLock<T> {
 impl<T> interface::ReadWriteEx for InitStateLock<T> {
     type Data = T;
 
-    fn write<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn write<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         assert!(
             state::state_manager().is_init(),
             "InitStateLock::write called after kernel init phase"
@@ -133,7 +133,7 @@ impl<T> interface::ReadWriteEx for InitStateLock<T> {
         f(data)
     }
 
-    fn read<R>(&self, f: impl FnOnce(&Self::Data) -> R) -> R {
+    fn read<'a, R>(&'a self, f: impl FnOnce(&'a Self::Data) -> R) -> R {
         let data = unsafe { &*self.data.get() };
 
         f(data)

X1_JTAG_boot/src/synchronization.rs

@@ -26,7 +26,7 @@ pub mod interface {
         type Data;
 
         /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.
-        fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
+        fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
     }
 }
 
@@ -67,7 +67,7 @@ impl<T> NullLock<T> {
 impl<T> interface::Mutex for NullLock<T> {
     type Data = T;
 
-    fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
+    fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {
         // In a real lock, there would be code encapsulating this line that ensures that this
         // mutable reference will ever only be given out once at a time.
         let data = unsafe { &mut *self.data.get() };