lock_api: Allow unsafely accessing data without a guard

lock_api/src/mutex.rs

@@ -270,6 +270,22 @@ impl<R: RawMutex, T: ?Sized> Mutex<R, T> {
     pub unsafe fn raw(&self) -> &R {
         &self.raw
     }
+
+    /// Returns a raw pointer to the underlying data.
+    ///
+    /// This is useful when combined with `mem::forget` to hold a lock without
+    /// the need to maintain a `MutexGuard` object alive, for example when
+    /// dealing with FFI.
+    ///
+    /// # Safety
+    ///
+    /// The returned pointer must only be dereferenced if the current thread
+    /// logically owns a `MutexGuard` but that guard has been discarded using
+    /// `mem::forget`.
+    #[inline]
+    pub fn data_ptr(&self) -> *mut T {
+        self.data.get()
+    }
 }
 
 impl<R: RawMutexFair, T: ?Sized> Mutex<R, T> {

lock_api/src/remutex.rs

@@ -362,6 +362,22 @@ impl<R: RawMutex, G: GetThreadId, T: ?Sized> ReentrantMutex<R, G, T> {
     pub unsafe fn raw(&self) -> &R {
         &self.raw.mutex
     }
+
+    /// Returns a raw pointer to the underlying data.
+    ///
+    /// This is useful when combined with `mem::forget` to hold a lock without
+    /// the need to maintain a `ReentrantMutexGuard` object alive, for example
+    /// when dealing with FFI.
+    ///
+    /// # Safety
+    ///
+    /// The returned pointer must only be dereferenced if the current thread
+    /// logically owns a `ReentrantMutexGuard` but that guard has been discarded
+    /// using `mem::forget`.
+    #[inline]
+    pub fn data_ptr(&self) -> *mut T {
+        self.data.get()
+    }
 }
 
 impl<R: RawMutexFair, G: GetThreadId, T: ?Sized> ReentrantMutex<R, G, T> {

lock_api/src/rwlock.rs

@@ -540,6 +540,22 @@ impl<R: RawRwLock, T: ?Sized> RwLock<R, T> {
     pub unsafe fn raw(&self) -> &R {
         &self.raw
     }
+
+    /// Returns a raw pointer to the underlying data.
+    ///
+    /// This is useful when combined with `mem::forget` to hold a lock without
+    /// the need to maintain a `RwLockReadGuard` or `RwLockWriteGuard` object
+    /// alive, for example when dealing with FFI.
+    ///
+    /// # Safety
+    ///
+    /// The returned pointer must only be dereferenced if the current thread
+    /// logically owns a `RwLockReadGuard` or `RwLockWriteGuard` but that guard
+    /// has been discarded using `mem::forget`.
+    #[inline]
+    pub fn data_ptr(&self) -> *mut T {
+        self.data.get()
+    }
 }
 
 impl<R: RawRwLockFair, T: ?Sized> RwLock<R, T> {