Handle FUTEX_OWNER_DIED properly

Author: ruihe774

library/std/src/sync/mutex.rs

@@ -313,10 +313,11 @@ impl<T: ?Sized> Mutex<T> {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
-        unsafe {
-            self.inner.lock();
-            MutexGuard::new(self)
+        if self.inner.lock() == sys::MutexState::Poisoned {
+            self.poison.set();
         }
+
+        unsafe { MutexGuard::new(self) }
     }
 
     /// Attempts to acquire this lock.

library/std/src/sync/poison.rs

@@ -75,6 +75,12 @@ impl Flag {
         #[cfg(panic = "unwind")]
         self.failed.store(false, Ordering::Relaxed)
     }
+
+    #[inline]
+    pub fn set(&self) {
+        #[cfg(panic = "unwind")]
+        self.failed.store(true, Ordering::Relaxed)
+    }
 }
 
 #[derive(Clone)]

library/std/src/sync/reentrant_lock.rs

@@ -289,7 +289,7 @@ impl<T: ?Sized> ReentrantLock<T> {
             if self.owner.contains(this_thread) {
                 self.increment_lock_count().expect("lock count overflow in reentrant mutex");
             } else {
-                self.mutex.lock();
+                let _ = self.mutex.lock();
                 self.owner.set(Some(this_thread));
                 debug_assert_eq!(*self.lock_count.get(), 0);
                 *self.lock_count.get() = 1;

library/std/src/sys/pal/unix/pi_futex.rs

@@ -1,15 +1,9 @@
 #![cfg(any(target_os = "linux", target_os = "android"))]
 
+use crate::io;
+use crate::ptr::null;
 use crate::sync::atomic::AtomicU32;
 use crate::sys::cvt;
-use crate::sys::os::errno;
-use crate::{io, ptr};
-
-pub enum FutexLockError {
-    TryAgain,
-    DeadLock,
-    Other(io::Error),
-}
 
 pub const fn unlocked() -> u32 {
     0
@@ -23,25 +17,26 @@ pub fn is_contended(futex_val: u32) -> bool {
     (futex_val & libc::FUTEX_WAITERS) != 0
 }
 
-pub fn futex_lock(futex: &AtomicU32) -> Result<(), FutexLockError> {
-    if (unsafe {
-        libc::syscall(
-            libc::SYS_futex,
-            futex as *const AtomicU32,
-            libc::FUTEX_LOCK_PI | libc::FUTEX_PRIVATE_FLAG,
-            0,
-            ptr::null::<u32>(),
-            // remaining args are unused
-        )
-    } == -1)
-    {
-        Err(match errno() {
-            libc::EAGAIN | libc::EINTR => FutexLockError::TryAgain,
-            libc::EDEADLK => FutexLockError::DeadLock,
-            errno => FutexLockError::Other(io::Error::from_raw_os_error(errno)),
-        })
-    } else {
-        Ok(())
+pub fn is_owned_died(futex_val: u32) -> bool {
+    (futex_val & libc::FUTEX_OWNER_DIED) != 0
+}
+
+pub fn futex_lock(futex: &AtomicU32) -> io::Result<()> {
+    loop {
+        match cvt(unsafe {
+            libc::syscall(
+                libc::SYS_futex,
+                futex as *const AtomicU32,
+                libc::FUTEX_LOCK_PI | libc::FUTEX_PRIVATE_FLAG,
+                0,
+                null::<u32>(),
+                // remaining args are unused
+            )
+        }) {
+            Ok(_) => return Ok(()),
+            Err(e) if e.raw_os_error() == Some(libc::EINTR) => continue,
+            Err(e) => return Err(e),
+        }
     }
 }
 

library/std/src/sys/sync/condvar/futex.rs

@@ -50,7 +50,7 @@ impl Condvar {
         let r = futex_wait(&self.futex, futex_value, timeout);
 
         // Lock the mutex again.
-        mutex.lock();
+        let _ = mutex.lock();
 
         r
     }

library/std/src/sys/sync/mod.rs

@@ -6,7 +6,7 @@ mod rwlock;
 mod thread_parking;
 
 pub use condvar::Condvar;
-pub use mutex::Mutex;
+pub use mutex::{Mutex, MutexState};
 pub use once::{Once, OnceState};
 #[allow(unused)] // Only used on some platforms.
 use once_box::OnceBox;

library/std/src/sys/sync/mutex/fuchsia.rs

@@ -37,6 +37,7 @@
 //!
 //! [mutex in Fuchsia's libsync]: https://cs.opensource.google/fuchsia/fuchsia/+/main:zircon/system/ulib/sync/mutex.c
 
+use super::MutexState;
 use crate::sync::atomic::AtomicU32;
 use crate::sync::atomic::Ordering::{Acquire, Relaxed, Release};
 use crate::sys::futex::zircon::{
@@ -88,7 +89,7 @@ impl Mutex {
     }
 
     #[inline]
-    pub fn lock(&self) {
+    pub fn lock(&self) -> MutexState {
         let thread_self = unsafe { zx_thread_self() };
         if let Err(state) =
             self.futex.compare_exchange(UNLOCKED, to_state(thread_self), Acquire, Relaxed)
@@ -97,6 +98,7 @@ impl Mutex {
                 self.lock_contested(state, thread_self);
             }
         }
+        MutexState::Normal
     }
 
     /// # Safety

library/std/src/sys/sync/mutex/futex.rs

@@ -1,3 +1,4 @@
+use super::MutexState;
 use crate::sync::atomic::Ordering::{Acquire, Relaxed, Release};
 use crate::sys::futex::{self, futex_wait, futex_wake};
 
@@ -24,10 +25,11 @@ impl Mutex {
     }
 
     #[inline]
-    pub fn lock(&self) {
+    pub fn lock(&self) -> MutexState {
         if self.futex.compare_exchange(UNLOCKED, LOCKED, Acquire, Relaxed).is_err() {
             self.lock_contended();
         }
+        MutexState::Normal
     }
 
     #[cold]

library/std/src/sys/sync/mutex/itron.rs

@@ -2,6 +2,7 @@
 //! `TA_INHERIT` are available.
 #![forbid(unsafe_op_in_unsafe_fn)]
 
+use super::MutexState;
 use crate::sys::pal::itron::abi;
 use crate::sys::pal::itron::error::{ItronError, expect_success, expect_success_aborting, fail};
 use crate::sys::pal::itron::spin::SpinIdOnceCell;
@@ -37,9 +38,10 @@ impl Mutex {
         }
     }
 
-    pub fn lock(&self) {
+    pub fn lock(&self) -> MutexState {
         let mtx = self.raw();
         expect_success(unsafe { abi::loc_mtx(mtx) }, &"loc_mtx");
+        MutexState::Normal
     }
 
     pub unsafe fn unlock(&self) {

library/std/src/sys/sync/mutex/mod.rs

@@ -1,3 +1,9 @@
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum MutexState {
+    Normal,
+    Poisoned,
+}
+
 cfg_if::cfg_if! {
     if #[cfg(any(
         target_os = "linux",