Use Drop instead of destroy() for locks.

m-ou-se · m-ou-se · commit ac5aa1ded529 · 2022-06-03T16:45:47.000+02:00
diff --git a/library/std/src/sys/hermit/condvar.rs b/library/std/src/sys/hermit/condvar.rs
@@ -70,9 +70,13 @@ impl Condvar {
         mutex.lock();
         res == 0
     }
+}
 
-    pub unsafe fn destroy(&self) {
-        let _ = abi::sem_destroy(self.sem1);
-        let _ = abi::sem_destroy(self.sem2);
+impl Drop for Condvar {
+    fn drop(&mut self) {
+        unsafe {
+            let _ = abi::sem_destroy(self.sem1);
+            let _ = abi::sem_destroy(self.sem2);
+        }
     }
 }
diff --git a/library/std/src/sys/hermit/mutex.rs b/library/std/src/sys/hermit/mutex.rs
@@ -215,7 +215,4 @@ impl Mutex {
         }
         guard.locked
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {}
 }
diff --git a/library/std/src/sys/hermit/rwlock.rs b/library/std/src/sys/hermit/rwlock.rs
@@ -84,12 +84,6 @@ impl RwLock {
         // FIXME: should only wake up one of these some of the time
         self.cond.notify_all();
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {
-        self.lock.destroy();
-        self.cond.destroy();
-    }
 }
 
 impl State {
diff --git a/library/std/src/sys/itron/condvar.rs b/library/std/src/sys/itron/condvar.rs
@@ -117,8 +117,6 @@ impl Condvar {
         unsafe { mutex.lock() };
         success
     }
-
-    pub unsafe fn destroy(&self) {}
 }
 
 mod waiter_queue {
diff --git a/library/std/src/sys/itron/mutex.rs b/library/std/src/sys/itron/mutex.rs
@@ -64,8 +64,10 @@ impl Mutex {
             }
         }
     }
+}
 
-    pub unsafe fn destroy(&self) {
+impl Drop for Mutex {
+    fn drop(&mut self) {
         if let Some(mtx) = self.mtx.get().map(|x| x.0) {
             expect_success_aborting(unsafe { abi::del_mtx(mtx) }, &"del_mtx");
         }
diff --git a/library/std/src/sys/sgx/condvar.rs b/library/std/src/sys/sgx/condvar.rs
@@ -38,7 +38,4 @@ impl Condvar {
         unsafe { mutex.lock() };
         success
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {}
 }
diff --git a/library/std/src/sys/sgx/mutex.rs b/library/std/src/sys/sgx/mutex.rs
@@ -52,7 +52,4 @@ impl Mutex {
             true
         }
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {}
 }
diff --git a/library/std/src/sys/sgx/rwlock.rs b/library/std/src/sys/sgx/rwlock.rs
@@ -168,9 +168,6 @@ impl RwLock {
             unsafe { self.__read_unlock(rguard, wguard) };
         }
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {}
 }
 
 // The following functions are needed by libunwind. These symbols are named
diff --git a/library/std/src/sys/solid/rwlock.rs b/library/std/src/sys/solid/rwlock.rs
@@ -82,9 +82,11 @@ impl RwLock {
         let rwl = self.raw();
         expect_success_aborting(unsafe { abi::rwl_unl_rwl(rwl) }, &"rwl_unl_rwl");
     }
+}
 
+impl Drop for RwLock {
     #[inline]
-    pub unsafe fn destroy(&self) {
+    fn drop(&mut self) {
         if let Some(rwl) = self.rwl.get().map(|x| x.0) {
             expect_success_aborting(unsafe { abi::rwl_del_rwl(rwl) }, &"rwl_del_rwl");
         }
diff --git a/library/std/src/sys/unix/locks/futex.rs b/library/std/src/sys/unix/locks/futex.rs
@@ -24,9 +24,6 @@ impl Mutex {
     #[inline]
     pub unsafe fn init(&mut self) {}
 
-    #[inline]
-    pub unsafe fn destroy(&self) {}
-
     #[inline]
     pub unsafe fn try_lock(&self) -> bool {
         self.futex.compare_exchange(0, 1, Acquire, Relaxed).is_ok()
@@ -121,9 +118,6 @@ impl Condvar {
     #[inline]
     pub unsafe fn init(&mut self) {}
 
-    #[inline]
-    pub unsafe fn destroy(&self) {}
-
     // All the memory orderings here are `Relaxed`,
     // because synchronization is done by unlocking and locking the mutex.
 
diff --git a/library/std/src/sys/unix/locks/futex_rwlock.rs b/library/std/src/sys/unix/locks/futex_rwlock.rs
@@ -63,9 +63,6 @@ impl RwLock {
         Self { state: AtomicU32::new(0), writer_notify: AtomicU32::new(0) }
     }
 
-    #[inline]
-    pub unsafe fn destroy(&self) {}
-
     #[inline]
     pub unsafe fn try_read(&self) -> bool {
         self.state
diff --git a/library/std/src/sys/unix/locks/pthread_condvar.rs b/library/std/src/sys/unix/locks/pthread_condvar.rs
@@ -179,14 +179,14 @@ impl Condvar {
 
     #[inline]
     #[cfg(not(target_os = "dragonfly"))]
-    pub unsafe fn destroy(&self) {
+    unsafe fn destroy(&mut self) {
         let r = libc::pthread_cond_destroy(self.inner.get());
         debug_assert_eq!(r, 0);
     }
 
     #[inline]
     #[cfg(target_os = "dragonfly")]
-    pub unsafe fn destroy(&self) {
+    unsafe fn destroy(&mut self) {
         let r = libc::pthread_cond_destroy(self.inner.get());
         // On DragonFly pthread_cond_destroy() returns EINVAL if called on
         // a condvar that was just initialized with
@@ -195,3 +195,10 @@ impl Condvar {
         debug_assert!(r == 0 || r == libc::EINVAL);
     }
 }
+
+impl Drop for Condvar {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { self.destroy() };
+    }
+}
diff --git a/library/std/src/sys/unix/locks/pthread_mutex.rs b/library/std/src/sys/unix/locks/pthread_mutex.rs
@@ -73,13 +73,13 @@ impl Mutex {
     }
     #[inline]
     #[cfg(not(target_os = "dragonfly"))]
-    pub unsafe fn destroy(&self) {
+    unsafe fn destroy(&mut self) {
         let r = libc::pthread_mutex_destroy(self.inner.get());
         debug_assert_eq!(r, 0);
     }
     #[inline]
     #[cfg(target_os = "dragonfly")]
-    pub unsafe fn destroy(&self) {
+    unsafe fn destroy(&mut self) {
         let r = libc::pthread_mutex_destroy(self.inner.get());
         // On DragonFly pthread_mutex_destroy() returns EINVAL if called on a
         // mutex that was just initialized with libc::PTHREAD_MUTEX_INITIALIZER.
@@ -89,6 +89,13 @@ impl Mutex {
     }
 }
 
+impl Drop for Mutex {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { self.destroy() };
+    }
+}
+
 pub(super) struct PthreadMutexAttr<'a>(pub &'a mut MaybeUninit<libc::pthread_mutexattr_t>);
 
 impl Drop for PthreadMutexAttr<'_> {
diff --git a/library/std/src/sys/unix/locks/pthread_rwlock.rs b/library/std/src/sys/unix/locks/pthread_rwlock.rs
@@ -128,7 +128,7 @@ impl RwLock {
         self.raw_unlock();
     }
     #[inline]
-    pub unsafe fn destroy(&self) {
+    unsafe fn destroy(&mut self) {
         let r = libc::pthread_rwlock_destroy(self.inner.get());
         // On DragonFly pthread_rwlock_destroy() returns EINVAL if called on a
         // rwlock that was just initialized with
@@ -141,3 +141,10 @@ impl RwLock {
         }
     }
 }
+
+impl Drop for RwLock {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { self.destroy() };
+    }
+}
diff --git a/library/std/src/sys/unsupported/locks/condvar.rs b/library/std/src/sys/unsupported/locks/condvar.rs
@@ -26,7 +26,4 @@ impl Condvar {
     pub unsafe fn wait_timeout(&self, _mutex: &Mutex, _dur: Duration) -> bool {
         panic!("condvar wait not supported");
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {}
 }
diff --git a/library/std/src/sys/unsupported/locks/mutex.rs b/library/std/src/sys/unsupported/locks/mutex.rs
@@ -32,7 +32,4 @@ impl Mutex {
     pub unsafe fn try_lock(&self) -> bool {
         self.locked.replace(true) == false
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {}
 }
diff --git a/library/std/src/sys/unsupported/locks/rwlock.rs b/library/std/src/sys/unsupported/locks/rwlock.rs
@@ -62,7 +62,4 @@ impl RwLock {
     pub unsafe fn write_unlock(&self) {
         assert_eq!(self.mode.replace(0), -1);
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {}
 }
diff --git a/library/std/src/sys/windows/locks/condvar.rs b/library/std/src/sys/windows/locks/condvar.rs
@@ -51,8 +51,4 @@ impl Condvar {
     pub unsafe fn notify_all(&self) {
         c::WakeAllConditionVariable(self.inner.get())
     }
-
-    pub unsafe fn destroy(&self) {
-        // ...
-    }
 }
diff --git a/library/std/src/sys/windows/locks/mutex.rs b/library/std/src/sys/windows/locks/mutex.rs
@@ -53,9 +53,4 @@ impl Mutex {
     pub unsafe fn unlock(&self) {
         c::ReleaseSRWLockExclusive(raw(self));
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {
-        // SRWLock does not need to be destroyed.
-    }
 }
diff --git a/library/std/src/sys/windows/locks/rwlock.rs b/library/std/src/sys/windows/locks/rwlock.rs
@@ -38,9 +38,4 @@ impl RwLock {
     pub unsafe fn write_unlock(&self) {
         c::ReleaseSRWLockExclusive(self.inner.get())
     }
-
-    #[inline]
-    pub unsafe fn destroy(&self) {
-        // ...
-    }
 }
diff --git a/library/std/src/sys_common/condvar.rs b/library/std/src/sys_common/condvar.rs
@@ -55,9 +55,3 @@ impl Condvar {
         self.inner.wait_timeout(mutex.raw(), dur)
     }
 }
-
-impl Drop for Condvar {
-    fn drop(&mut self) {
-        unsafe { self.inner.destroy() };
-    }
-}
diff --git a/library/std/src/sys_common/mutex.rs b/library/std/src/sys_common/mutex.rs
@@ -92,9 +92,3 @@ impl MovableMutex {
         self.0.unlock()
     }
 }
-
-impl Drop for MovableMutex {
-    fn drop(&mut self) {
-        unsafe { self.0.destroy() };
-    }
-}
diff --git a/library/std/src/sys_common/remutex.rs b/library/std/src/sys_common/remutex.rs
@@ -168,13 +168,6 @@ impl<T> ReentrantMutex<T> {
     }
 }
 
-impl<T> Drop for ReentrantMutex<T> {
-    fn drop(&mut self) {
-        // Safety: We're the unique owner of this mutex and not going to use it afterwards.
-        unsafe { self.mutex.destroy() }
-    }
-}
-
 impl<T> Deref for ReentrantMutexGuard<'_, T> {
     type Target = T;
 
diff --git a/library/std/src/sys_common/rwlock.rs b/library/std/src/sys_common/rwlock.rs
@@ -126,9 +126,3 @@ impl MovableRwLock {
         self.0.write_unlock()
     }
 }
-
-impl Drop for MovableRwLock {
-    fn drop(&mut self) {
-        unsafe { self.0.destroy() };
-    }
-}

Original file line number	Diff line number	Diff line change
`@@ -70,9 +70,13 @@ impl Condvar {`
`70`	`70`	`mutex.lock();`
`71`	`71`	`res == 0`
`72`	`72`	`}`
	`73`	`+}`
`73`	`74`
`74`		`- pub unsafe fn destroy(&self) {`
`75`		`- let _ = abi::sem_destroy(self.sem1);`
`76`		`- let _ = abi::sem_destroy(self.sem2);`
	`75`	`+impl Drop for Condvar {`
	`76`	`+ fn drop(&mut self) {`
	`77`	`+ unsafe {`
	`78`	`+ let _ = abi::sem_destroy(self.sem1);`
	`79`	`+ let _ = abi::sem_destroy(self.sem2);`
	`80`	`+ }`
`77`	`81`	`}`
`78`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -215,7 +215,4 @@ impl Mutex {`
`215`	`215`	`}`
`216`	`216`	`guard.locked`
`217`	`217`	`}`
`218`		`-`
`219`		`- #[inline]`
`220`		`- pub unsafe fn destroy(&self) {}`
`221`	`218`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,12 +84,6 @@ impl RwLock {`
`84`	`84`	`// FIXME: should only wake up one of these some of the time`
`85`	`85`	`self.cond.notify_all();`
`86`	`86`	`}`
`87`		`-`
`88`		`- #[inline]`
`89`		`- pub unsafe fn destroy(&self) {`
`90`		`- self.lock.destroy();`
`91`		`- self.cond.destroy();`
`92`		`- }`
`93`	`87`	`}`
`94`	`88`
`95`	`89`	`impl State {`
Original file line number	Diff line number	Diff line change
`@@ -117,8 +117,6 @@ impl Condvar {`
`117`	`117`	`unsafe { mutex.lock() };`
`118`	`118`	`success`
`119`	`119`	`}`
`120`		`-`
`121`		`- pub unsafe fn destroy(&self) {}`
`122`	`120`	`}`
`123`	`121`
`124`	`122`	`mod waiter_queue {`
Original file line number	Diff line number	Diff line change
`@@ -64,8 +64,10 @@ impl Mutex {`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`}`
	`67`	`+}`
`67`	`68`
`68`		`- pub unsafe fn destroy(&self) {`
	`69`	`+impl Drop for Mutex {`
	`70`	`+ fn drop(&mut self) {`
`69`	`71`	`if let Some(mtx) = self.mtx.get().map(\|x\| x.0) {`
`70`	`72`	`expect_success_aborting(unsafe { abi::del_mtx(mtx) }, &"del_mtx");`
`71`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,4 @@ impl Condvar {`
`38`	`38`	`unsafe { mutex.lock() };`
`39`	`39`	`success`
`40`	`40`	`}`
`41`		`-`
`42`		`- #[inline]`
`43`		`- pub unsafe fn destroy(&self) {}`
`44`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,4 @@ impl Mutex {`
`52`	`52`	`true`
`53`	`53`	`}`
`54`	`54`	`}`
`55`		`-`
`56`		`- #[inline]`
`57`		`- pub unsafe fn destroy(&self) {}`
`58`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -168,9 +168,6 @@ impl RwLock {`
`168`	`168`	`unsafe { self.__read_unlock(rguard, wguard) };`
`169`	`169`	`}`
`170`	`170`	`}`
`171`		`-`
`172`		`- #[inline]`
`173`		`- pub unsafe fn destroy(&self) {}`
`174`	`171`	`}`
`175`	`172`
`176`	`173`	`// The following functions are needed by libunwind. These symbols are named`
Original file line number	Diff line number	Diff line change
`@@ -82,9 +82,11 @@ impl RwLock {`
`82`	`82`	`let rwl = self.raw();`
`83`	`83`	`expect_success_aborting(unsafe { abi::rwl_unl_rwl(rwl) }, &"rwl_unl_rwl");`
`84`	`84`	`}`
	`85`	`+}`
`85`	`86`
	`87`	`+impl Drop for RwLock {`
`86`	`88`	`#[inline]`
`87`		`- pub unsafe fn destroy(&self) {`
	`89`	`+ fn drop(&mut self) {`
`88`	`90`	`if let Some(rwl) = self.rwl.get().map(\|x\| x.0) {`
`89`	`91`	`expect_success_aborting(unsafe { abi::rwl_del_rwl(rwl) }, &"rwl_del_rwl");`
`90`	`92`	`}`