std: fix deadlock in Parker

Author: joboet

library/std/src/sys/itron/wait_flag.rs

@@ -42,13 +42,18 @@ impl WaitFlag {
     }
 
     /// Wait for the wait flag to be raised or the timeout to occur.
-    pub fn wait_timeout(&self, dur: Duration) {
+    ///
+    /// Returns whether the flag was raised (`true`) or the operation timed out (`false`).
+    pub fn wait_timeout(&self, dur: Duration) -> bool {
         let mut token = MaybeUninit::uninit();
-        let er = with_tmos(dur, |tmout| unsafe {
+        let res = with_tmos(dur, |tmout| unsafe {
             abi::twai_flg(self.flag, RAISED, abi::TWF_ORW, token.as_mut_ptr(), tmout)
         });
-        if er != abi::E_OK && er != abi::E_TMOUT {
-            fail(er, &"twai_flg");
+
+        match res {
+            abi::E_OK => true,
+            abi::E_TMOUT => false,
+            error => fail(error, &"twai_flg"),
         }
     }
 

library/std/src/sys_common/thread_parker/wait_flag.rs

@@ -2,7 +2,7 @@
 //!
 //! Some operating systems provide low-level parking primitives like wait counts,
 //! event flags or semaphores which are not susceptible to race conditions (meaning
-//! the wakeup can occure before the wait operation). To implement the `std` thread
+//! the wakeup can occur before the wait operation). To implement the `std` thread
 //! parker on top of these primitives, we only have to ensure that parking is fast
 //! when the thread token is available, the atomic ordering guarantees are maintained
 //! and spurious wakeups are minimized.
@@ -73,10 +73,10 @@ impl Parker {
             _ => panic!("inconsistent park state"),
         }
 
-        self.wait_flag.wait_timeout(dur);
+        let wakeup = self.wait_flag.wait_timeout(dur);
         let state = self.state.swap(EMPTY, SeqCst);
-        if state == NOTIFIED {
-            // The token was made available after the timeout occurred, but before
+        if state == NOTIFIED && !wakeup {
+            // The token was made available after the wait timed out, but before
             // we reset the state, so we need to reset the wait flag to avoid
             // spurious wakeups. This wait has no timeout, but we know it will
             // return quickly, as the unparking thread will definitely raise the