Annotate sync functions

andre-richter · andre-richter · commit f45275591963 · 2022-05-17T23:24:33.000+02:00
diff --git a/04_safe_globals/README.md b/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() };
diff --git a/04_safe_globals/src/synchronization.rs b/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() };
diff --git a/05_drivers_gpio_uart/src/synchronization.rs b/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() };
diff --git a/06_uart_chainloader/src/synchronization.rs b/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() };
diff --git a/07_timestamps/src/synchronization.rs b/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() };
diff --git a/08_hw_debug_JTAG/src/synchronization.rs b/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() };
diff --git a/09_privilege_level/src/synchronization.rs b/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() };
diff --git a/10_virtual_mem_part1_identity_mapping/src/synchronization.rs b/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() };
diff --git a/11_exceptions_part1_groundwork/src/synchronization.rs b/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() };
diff --git a/12_integrated_testing/kernel/src/synchronization.rs b/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() };
diff --git a/13_exceptions_part2_peripheral_IRQs/README.md b/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)
diff --git a/13_exceptions_part2_peripheral_IRQs/kernel/src/synchronization.rs b/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)
diff --git a/14_virtual_mem_part2_mmio_remap/kernel/src/synchronization.rs b/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)
diff --git a/15_virtual_mem_part3_precomputed_tables/kernel/src/synchronization.rs b/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)
diff --git a/16_virtual_mem_part4_higher_half_kernel/kernel/src/synchronization.rs b/16_virtual_mem_part4_higher_half_kernel/kernel/src/synchronization.rs
diff --git a/17_kernel_symbols/kernel/src/synchronization.rs b/17_kernel_symbols/kernel/src/synchronization.rs
diff --git a/18_backtrace/kernel/src/synchronization.rs b/18_backtrace/kernel/src/synchronization.rs
diff --git a/X1_JTAG_boot/src/synchronization.rs b/X1_JTAG_boot/src/synchronization.rs

Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ diff -uNr 03_hacky_hello_world/src/synchronization.rs 04_safe_globals/src/synchr`
`313`	`313`	`+ type Data;`
`314`	`314`	`+`
`315`	`315`	`+ /// Locks the mutex and grants the closure temporary mutable access to the wrapped data.`
`316`		`-+ fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;`
	`316`	`++ fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;`
`317`	`317`	`+ }`
`318`	`318`	`+}`
`319`	`319`	`+`
`@@ -354,7 +354,7 @@ diff -uNr 03_hacky_hello_world/src/synchronization.rs 04_safe_globals/src/synchr`
`354`	`354`	`+impl<T> interface::Mutex for NullLock<T> {`
`355`	`355`	`+ type Data = T;`
`356`	`356`	`+`
`357`		`-+ fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {`
	`357`	`++ fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {`
`358`	`358`	`+ // In a real lock, there would be code encapsulating this line that ensures that this`
`359`	`359`	`+ // mutable reference will ever only be given out once at a time.`
`360`	`360`	`+ let data = unsafe { &mut *self.data.get() };`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ pub mod interface {`
`26`	`26`	`type Data;`
`27`	`27`
`28`	`28`	`/// Locks the mutex and grants the closure temporary mutable access to the wrapped data.`
`29`		`- fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R;`
	`29`	`+ fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`@@ -67,7 +67,7 @@ impl<T> NullLock<T> {`
`67`	`67`	`impl<T> interface::Mutex for NullLock<T> {`
`68`	`68`	`type Data = T;`
`69`	`69`
`70`		`- fn lock<R>(&self, f: impl FnOnce(&mut Self::Data) -> R) -> R {`
	`70`	`+ fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R {`
`71`	`71`	`// In a real lock, there would be code encapsulating this line that ensures that this`
`72`	`72`	`// mutable reference will ever only be given out once at a time.`
`73`	`73`	`let data = unsafe { &mut *self.data.get() };`