use existing global lock to protect against fork

Author: nivkner

Cargo.toml

@@ -25,7 +25,6 @@ libc = { version = "0.2", default-features = false }
 # `src/tools/rustc-std-workspace` folder
 core = { version = '1.0.0', optional = true, package = 'rustc-std-workspace-core' }
 compiler_builtins = { version = '0.1.0', optional = true }
-once_cell = { version = '1.8', default-features= false, optional = true }
 
 [dev-dependencies]
 rand = "0.3"
@@ -41,7 +40,4 @@ global = []
 # Enable very expensive debug checks in this crate
 debug = []
 
-# makes allocations safe for use during `fork(2)`
-fork-safe = ["once_cell"]
-
 rustc-dep-of-std = ['core', 'compiler_builtins/rustc-dep-of-std']

src/linux.rs

@@ -75,24 +75,23 @@ unsafe impl Allocator for System {
 
 #[cfg(feature = "global")]
 pub fn acquire_global_lock() {
-    fn _acquire_global_lock() {
-        unsafe { assert_eq!(libc::pthread_mutex_lock(&mut LOCK), 0) }
-    }
+    static mut FORK_PROTECTED: bool = false;
 
-    #[cfg(feature = "fork-safe")]
     unsafe {
-        static EXEC_ONCE: once_cell::sync::OnceCell();
-
-        EXEC_ONCE.get_or_init(|| {
+        assert_eq!(libc::pthread_mutex_lock(&mut LOCK), 0);
+        if !FORK_PROTECTED {
+            // ensures that if a process forks,
+            // it will acquire the lock before any other thread,
+            // protecting it from deadlock,
+            // when the child is created with only that thread.
             libc::pthread_atfork(
                 _acquire_global_lock,
                 release_global_lock,
                 release_global_lock,
-            )
-        });
+            );
+            FORK_PROTECTED = true;
+        }
     }
-
-    _acquire_global_lock();
 }
 
 #[cfg(feature = "global")]

src/macos.rs

@@ -63,24 +63,23 @@ unsafe impl Allocator for System {
 
 #[cfg(feature = "global")]
 pub fn acquire_global_lock() {
-    fn _acquire_global_lock() {
-        unsafe { assert_eq!(libc::pthread_mutex_lock(&mut LOCK), 0) }
-    }
+    static mut FORK_PROTECTED: bool = false;
 
-    #[cfg(feature = "fork-safe")]
     unsafe {
-        static EXEC_ONCE: once_cell::sync::OnceCell();
-
-        EXEC_ONCE.get_or_init(|| {
+        assert_eq!(libc::pthread_mutex_lock(&mut LOCK), 0);
+        if !FORK_PROTECTED {
+            // ensures that if a process forks,
+            // it will acquire the lock before any other thread,
+            // protecting it from deadlock,
+            // when the child is created with only that thread.
             libc::pthread_atfork(
                 _acquire_global_lock,
                 release_global_lock,
                 release_global_lock,
-            )
-        });
+            );
+            FORK_PROTECTED = true;
+        }
     }
-
-    _acquire_global_lock();
 }
 
 #[cfg(feature = "global")]