init

Author: ShrigmaDev

Diff for: library/std/src/sync/poison/rwlock.rs

@@ -1,3 +1,5 @@
+use std::sync::PoisonError;
+
 use crate::cell::UnsafeCell;
 use crate::fmt;
 use crate::marker::PhantomData;
@@ -918,6 +920,19 @@ impl<'a, T: ?Sized> RwLockReadGuard<'a, T> {
             None => Err(orig),
         }
     }
+
+    pub fn try_upgrade<T>(orig: Self) -> Result<RwLockWriteGuard<'a, T>, RwLockReadGuard<'a, T>> {
+        read_lock = orig.inner_lock;
+
+        // don't call the destructor
+        forget(read_lock);
+
+        // SAFETY: We have ownership of the read guard, so it must be in read mode already
+        match unsafe { read_lock.try_upgrade() } {
+            true => RwLockWriteGuard::new(read_lock).unwrap_or_else(PoisonError::into_inner),
+            false => RwLockReadGuard::new(read_lock).unwrap_or_else(PoisonError::into_inner),
+        }
+    }
 }
 
 impl<'a, T: ?Sized> MappedRwLockReadGuard<'a, T> {

Diff for: library/std/src/sys/sync/rwlock/futex.rs

@@ -1,3 +1,5 @@
+use std::sync::atomic::Ordering::{Acquire, Relaxed};
+
 use crate::sync::atomic::Ordering::{Acquire, Relaxed, Release};
 use crate::sys::futex::{Futex, Primitive, futex_wait, futex_wake, futex_wake_all};
 
@@ -33,6 +35,11 @@ fn is_write_locked(state: Primitive) -> bool {
     state & MASK == WRITE_LOCKED
 }
 
+#[inline]
+fn is_read_locked(state: Primitive) -> bool {
+    state & MASK == READ_LOCKED
+}
+
 #[inline]
 fn has_readers_waiting(state: Primitive) -> bool {
     state & READERS_WAITING != 0
@@ -205,6 +212,19 @@ impl RwLock {
         }
     }
 
+    /// # Safety
+    ///
+    /// The 'RwLock' must be read-locked in order to call this. Calling this function in a loop
+    /// in at least 2 threads will deadlock.
+    #[inline]
+    pub unsafe fn try_upgrade(&self) -> bool {
+        debug_assert!(
+            is_read_locked(self.state),
+            "RwLock must be read locked to call `try_upgrade`"
+        );
+        self.state.compare_exchange(READ_LOCKED, WRITE_LOCKED, Acquire, Relaxed).is_ok()
+    }
+
     #[cold]
     fn write_contended(&self) {
         let mut state = self.spin_write();