Fix lock trait bound.

src/lock/api.rs

@@ -3,7 +3,12 @@ use core::mem::ManuallyDrop;
 use core::ops::{Deref, DerefMut};
 
 /// Raw lock interface.
-pub trait RawLock: Default + Send + Sync {
+///
+/// # Safety
+///
+/// Implementations of this trait must ensure that the lock is actually
+/// exclusive: a lock can't be acquired while the lock is already locked.
+pub unsafe trait RawLock: Default + Send + Sync {
     /// Raw lock's token type.
     type Token;
 
@@ -19,7 +24,13 @@ pub trait RawLock: Default + Send + Sync {
 }
 
 /// Raw lock interface for the try_lock API.
-pub trait RawTryLock: RawLock {
+///
+/// # Safety
+///
+/// Implementations of this trait must ensure that the lock is actually
+/// exclusive: a lock can't be acquired while the lock is already locked.
+/// Also, `try_lock()`, when successful, should return a token that can be used for `RawLock::unlock`.
+pub unsafe trait RawTryLock: RawLock {
     /// Tries to acquire the raw lock.
     fn try_lock(&self) -> Result<Self::Token, ()>;
 }
@@ -114,13 +125,6 @@ pub struct LockGuard<'s, L: RawLock, T> {
 unsafe impl<L: RawLock, T: Sync> Send for LockGuard<'_, L, T> {}
 unsafe impl<L: RawLock, T: Sync> Sync for LockGuard<'_, L, T> {}
 
-impl<L: RawLock, T> LockGuard<'_, L, T> {
-    /// Returns the address of the referenced lock.
-    pub fn raw(&mut self) -> usize {
-        self.lock as *const _ as usize
-    }
-}
-
 impl<L: RawLock, T> Drop for LockGuard<'_, L, T> {
     fn drop(&mut self) {
         // SAFETY: `self.token` is not used anymore in this function, and as we are `drop`ing

src/lock/clhlock.rs

@@ -18,26 +18,26 @@ pub struct ClhLock {
 }
 
 impl Node {
-    const fn new(locked: bool) -> Self {
-        Self {
+    fn new(locked: bool) -> *mut CachePadded<Self> {
+        Box::into_raw(Box::new(CachePadded::new(Self {
             locked: AtomicBool::new(locked),
-        }
+        })))
     }
 }
 
 impl Default for ClhLock {
     fn default() -> Self {
-        let node = AtomicPtr::new(Box::into_raw(Box::new(CachePadded::new(Node::new(false)))));
+        let node = AtomicPtr::new(Node::new(false));
 
         Self { tail: node }
     }
 }
 
-impl RawLock for ClhLock {
+unsafe impl RawLock for ClhLock {
     type Token = Token;
 
     fn lock(&self) -> Self::Token {
-        let node = Box::into_raw(Box::new(CachePadded::new(Node::new(true))));
+        let node = Node::new(true);
         let prev = self.tail.swap(node, AcqRel);
         let backoff = Backoff::new();
 

src/lock/mcslock.rs

@@ -20,11 +20,11 @@ pub struct McsLock {
 }
 
 impl Node {
-    const fn new() -> Self {
-        Self {
+    fn new() -> *mut CachePadded<Self> {
+        Box::into_raw(Box::new(CachePadded::new(Self {
             locked: AtomicBool::new(true),
             next: AtomicPtr::new(ptr::null_mut()),
-        }
+        })))
     }
 }
 
@@ -36,11 +36,11 @@ impl Default for McsLock {
     }
 }
 
-impl RawLock for McsLock {
+unsafe impl RawLock for McsLock {
     type Token = Token;
 
     fn lock(&self) -> Self::Token {
-        let node = Box::into_raw(Box::new(CachePadded::new(Node::new())));
+        let node = Node::new();
         let prev = self.tail.swap(node, AcqRel);
 
         if prev.is_null() {

src/lock/mcsparkinglock.rs

@@ -22,12 +22,12 @@ pub struct McsParkingLock {
 }
 
 impl Node {
-    fn new() -> Self {
-        Self {
+    fn new() -> *mut CachePadded<Self> {
+        Box::into_raw(Box::new(CachePadded::new(Self {
             thread: thread::current(),
             locked: AtomicBool::new(true),
             next: AtomicPtr::new(ptr::null_mut()),
-        }
+        })))
     }
 }
 
@@ -39,11 +39,11 @@ impl Default for McsParkingLock {
     }
 }
 
-impl RawLock for McsParkingLock {
+unsafe impl RawLock for McsParkingLock {
     type Token = Token;
 
     fn lock(&self) -> Self::Token {
-        let node = Box::into_raw(Box::new(CachePadded::new(Node::new())));
+        let node = Node::new();
         let prev = self.tail.swap(node, AcqRel);
 
         if prev.is_null() {

src/lock/spinlock.rs

@@ -18,7 +18,7 @@ impl Default for SpinLock {
     }
 }
 
-impl RawLock for SpinLock {
+unsafe impl RawLock for SpinLock {
     type Token = ();
 
     fn lock(&self) {
@@ -38,7 +38,7 @@ impl RawLock for SpinLock {
     }
 }
 
-impl RawTryLock for SpinLock {
+unsafe impl RawTryLock for SpinLock {
     fn try_lock(&self) -> Result<(), ()> {
         self.inner
             .compare_exchange(false, true, Acquire, Relaxed)

src/lock/ticketlock.rs

@@ -20,7 +20,7 @@ impl Default for TicketLock {
     }
 }
 
-impl RawLock for TicketLock {
+unsafe impl RawLock for TicketLock {
     type Token = usize;
 
     fn lock(&self) -> usize {