Add builtin implementation for std targets.

Cargo.toml

@@ -14,6 +14,11 @@ categories = [
 
 [features]
 
+# Enable a critical-section implementation for platforms supporting `std`, based on `std::sync::Mutex`.
+# If you enable this, the `critical-section` crate itself provides the implementation,
+# you don't have to get another crate to to do it.
+std = ["restore-state-bool"]
+
 # Set the RestoreState size.
 # The crate supplying the critical section implementation can set ONE of them.
 # Other crates MUST NOT set any of these.

src/lib.rs

@@ -1,7 +1,9 @@
-#![no_std]
+#![cfg_attr(not(feature = "std"), no_std)]
 #![doc = include_str!("../README.md")]
 
 mod mutex;
+#[cfg(feature = "std")]
+mod std;
 
 use core::marker::PhantomData;
 

src/std.rs

@@ -0,0 +1,49 @@
+use std::cell::Cell;
+use std::mem::MaybeUninit;
+use std::sync::{Mutex, MutexGuard};
+
+static GLOBAL_MUTEX: Mutex<()> = Mutex::new(());
+
+// This is initialized if a thread has acquired the CS, uninitialized otherwise.
+static mut GLOBAL_GUARD: MaybeUninit<MutexGuard<'static, ()>> = MaybeUninit::uninit();
+
+std::thread_local!(static IS_LOCKED: Cell<bool> = Cell::new(false));
+
+struct StdCriticalSection;
+crate::set_impl!(StdCriticalSection);
+
+unsafe impl crate::Impl for StdCriticalSection {
+    unsafe fn acquire() -> bool {
+        // Allow reentrancy by checking thread local state
+        IS_LOCKED.with(|l| {
+            if l.get() {
+                // CS already acquired in the current thread.
+                return true;
+            }
+
+            // Note: it is fine to set this flag *before* acquiring the mutex because it's thread local.
+            // No other thread can see its value, there's no potential for races.
+            // This way, we hold the mutex for slightly less time.
+            l.set(true);
+
+            // Not acquired in the current thread, acquire it.
+            let guard = GLOBAL_MUTEX.lock().unwrap();
+            GLOBAL_GUARD.write(guard);
+            false
+        })
+    }
+
+    unsafe fn release(nested_cs: bool) {
+        if !nested_cs {
+            // SAFETY: As per the acquire/release safety contract, release can only be called
+            // if the critical section is acquired in the current thread,
+            // in which case we know the GLOBAL_GUARD is initialized.
+            GLOBAL_GUARD.assume_init_drop();
+
+            // Note: it is fine to clear this flag *after* releasing the mutex because it's thread local.
+            // No other thread can see its value, there's no potential for races.
+            // This way, we hold the mutex for slightly less time.
+            IS_LOCKED.with(|l| l.set(false));
+        }
+    }
+}