move use of std::thread from ffi crate to main

Author: Person-93

pyo3-ffi/src/pystate.rs

@@ -79,68 +79,19 @@ pub enum PyGILState_STATE {
     PyGILState_UNLOCKED,
 }
 
-#[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
-struct HangThread;
-
-#[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
-impl Drop for HangThread {
-    fn drop(&mut self) {
-        loop {
-            core::thread::park(); // Block forever.
-        }
-    }
-}
-
-// The PyGILState_Ensure function will call pthread_exit during interpreter shutdown,
-// which causes undefined behavior. Redirect to the "safe" version that hangs instead,
-// as Python 3.14 does.
-//
-// See https://github.com/rust-lang/rust/issues/135929
-
 // C-unwind only supported (and necessary) since 1.71. Python 3.14+ does not do
 // pthread_exit from PyGILState_Ensure (https://github.com/python/cpython/issues/87135).
-mod raw {
-    #[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
-    extern_libpython! { "C-unwind" {
-        #[cfg_attr(PyPy, link_name = "PyPyGILState_Ensure")]
-        pub fn PyGILState_Ensure() -> super::PyGILState_STATE;
-    }}
-
-    #[cfg(any(Py_3_14, target_arch = "wasm32"))]
-    extern_libpython! {
-        #[cfg_attr(PyPy, link_name = "PyPyGILState_Ensure")]
-        pub fn PyGILState_Ensure() -> super::PyGILState_STATE;
-    }
-}
-
 #[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
-pub unsafe extern "C" fn PyGILState_Ensure() -> PyGILState_STATE {
-    let guard = HangThread;
-    // If `PyGILState_Ensure` calls `pthread_exit`, which it does on Python < 3.14
-    // when the interpreter is shutting down, this will cause a forced unwind.
-    // doing a forced unwind through a function with a Rust destructor is unspecified
-    // behavior.
-    //
-    // However, currently it runs the destructor, which will cause the thread to
-    // hang as it should.
-    //
-    // And if we don't catch the unwinding here, then one of our callers probably has a destructor,
-    // so it's unspecified behavior anyway, and on many configurations causes the process to abort.
-    //
-    // The alternative is for pyo3 to contain custom C or C++ code that catches the `pthread_exit`,
-    // but that's also annoying from a portability point of view.
-    //
-    // On Windows, `PyGILState_Ensure` calls `_endthreadex` instead, which AFAICT can't be caught
-    // and therefore will cause unsafety if there are pinned objects on the stack. AFAICT there's
-    // nothing we can do it other than waiting for Python 3.14 or not using Windows. At least,
-    // if there is nothing pinned on the stack, it won't cause the process to crash.
-    let ret: PyGILState_STATE = raw::PyGILState_Ensure();
-    core::mem::forget(guard);
-    ret
-}
+extern_libpython! { "C-unwind" {
+    #[cfg_attr(PyPy, link_name = "PyPyGILState_Ensure")]
+    pub fn PyGILState_Ensure() -> super::PyGILState_STATE;
+}}
 
 #[cfg(any(Py_3_14, target_arch = "wasm32"))]
-pub use self::raw::PyGILState_Ensure;
+extern_libpython! {
+    #[cfg_attr(PyPy, link_name = "PyPyGILState_Ensure")]
+    pub fn PyGILState_Ensure() -> super::PyGILState_STATE;
+}
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyGILState_Release")]

src/internal/state.rs

@@ -141,8 +141,50 @@ impl AttachGuard {
     /// Attach to the interpreter, without a fast-path to check if the thread is already attached.
     #[cold]
     unsafe fn do_attach_unchecked() -> Self {
+        // The PyGILState_Ensure function will call pthread_exit during interpreter shutdown,
+        // which causes undefined behavior. Hang the thread instead, as Python 3.14 does.
+        //
+        // See https://github.com/rust-lang/rust/issues/135929
+
+        #[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+        struct HangThread;
+
+        #[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+        impl Drop for HangThread {
+            fn drop(&mut self) {
+                loop {
+                    std::thread::park(); // Block forever.
+                }
+            }
+        }
+
+        // If `PyGILState_Ensure` calls `pthread_exit`, which it does on Python < 3.14
+        // when the interpreter is shutting down, this will cause a forced unwind.
+        // doing a forced unwind through a function with a Rust destructor is unspecified
+        // behavior.
+        //
+        // However, currently it runs the destructor, which will cause the thread to
+        // hang as it should.
+        //
+        // And if we don't catch the unwinding here, then one of our callers probably has a destructor,
+        // so it's unspecified behavior anyway, and on many configurations causes the process to abort.
+        //
+        // The alternative is for pyo3 to contain custom C or C++ code that catches the `pthread_exit`,
+        // but that's also annoying from a portability point of view.
+        //
+        // On Windows, `PyGILState_Ensure` calls `_endthreadex` instead, which AFAICT can't be caught
+        // and therefore will cause unsafety if there are pinned objects on the stack. AFAICT there's
+        // nothing we can do it other than waiting for Python 3.14 or not using Windows. At least,
+        // if there is nothing pinned on the stack, it won't cause the process to crash.
+        #[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+        let guard = HangThread;
+
         // SAFETY: interpreter is sufficiently initialized to attach a thread.
         let gstate = unsafe { ffi::PyGILState_Ensure() };
+
+        #[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+        core::mem::forget(guard);
+
         increment_attach_count();
         // SAFETY: just attached to the interpreter
         drop_deferred_references(unsafe { Python::assume_attached() });