"Fix" fork() so it "works" on Python 3.13, and "works" better on older Python versions (#1047)

Behavior change: threads created by eventlet.green.threading.Thread and threading.Thead will be visible across both modules if monkey patching was used. Previously each module would only list threads created in that module.

Bug fix: after fork(), greenlet threads are correctly listed in threading.enumerate() if monkey patching was used. You should not use fork()-without-execve().

Co-authored-by: Itamar Turner-Trauring <[email protected]>

Author: itamarst

doc/source/fork.rst

@@ -0,0 +1,30 @@
+fork() without execve()
+=======================
+
+``fork()`` is a way to make a clone of a process.
+Most subprocesses replace the child process with a new executable, wiping out all memory from the parent process.
+A ``fork()ed`` subprocess can choose not to do this, and preserve data from the parent process.
+(Technically this is ``fork()`` without ``execve()``.)
+
+This is a terrible idea, as it can cause deadlocks, memory corruption, and crashes.
+
+For backwards compatibility, Eventlet *tries* to work in this case, but this is very much not guaranteed and your program may suffer from deadlocks, memory corruption, and crashes.
+This is even more so when using the ``asyncio`` hub, as that requires even more questionable interventions to "work".
+
+This is not a problem with Eventlet.
+It's a fundamental problem with ``fork()`` applicable to pretty much every Python program.
+
+Below are some common reasons you might be using ``fork()`` without knowing it, and what you can do about it.
+
+``multiprocessing``
+------------------
+
+On Linux, on Python 3.13 earlier, the standard library ``multiprocessing`` library uses ``fork()`` by default.
+To fix this, switch to the ``"spawn"`` method (the default in Python 3.14 and later) as `documented here <https://docs.python.org/3.13/library/multiprocessing.html#contexts-and-start-methods>`.
+
+
+``oslo.service``
+----------------
+
+There are alternative ways of running services that do not use ``fork()``.
+See the documentation.

doc/source/index.rst

@@ -93,6 +93,7 @@ Concepts & References
    zeromq
    hubs
    environment
+   fork
    modules
 
 Want to contribute?

eventlet/__init__.py

@@ -76,4 +76,13 @@
         ('call_after_global', 'greenthread.call_after_global', greenthread.call_after_global),
     ))
 
-os
+
+if hasattr(os, "register_at_fork"):
+    def _warn_on_fork():
+        import warnings
+        warnings.warn(
+            "Using fork() is a bad idea, and there is no guarantee eventlet will work." +
+            " See https://eventlet.readthedocs.io/en/latest/fork.html for more details.",
+            DeprecationWarning
+        )
+    os.register_at_fork(before=_warn_on_fork)

eventlet/green/threading.py

@@ -4,10 +4,11 @@
 from eventlet.green import time
 from eventlet.support import greenlets as greenlet
 
-__patched__ = ['Lock', '_after_fork', '_allocate_lock', '_get_main_thread_ident',
+__patched__ = ['Lock', '_allocate_lock', '_get_main_thread_ident',
                '_make_thread_handle', '_shutdown', '_sleep',
                '_start_joinable_thread', '_start_new_thread', '_ThreadHandle',
-               'currentThread', 'current_thread', 'local', 'stack_size']
+               'currentThread', 'current_thread', 'local', 'stack_size',
+               "_active", "_limbo"]
 
 __patched__ += ['get_ident', '_set_sentinel']
 

eventlet/hubs/asyncio.py

@@ -44,6 +44,19 @@ def __init__(self):
         asyncio.set_event_loop(self.loop)
         self.sleep_event = asyncio.Event()
 
+        import asyncio.events
+        if hasattr(asyncio.events, "on_fork"):
+            # Allow post-fork() child to continue using the same event loop.
+            # This is a terrible idea.
+            asyncio.events.on_fork.__code__ = (lambda: None).__code__
+        else:
+            # On Python 3.9-3.11, there's a thread local we need to reset.
+            # Also a terrible idea.
+            def re_register_loop(loop=self.loop):
+                asyncio.events._set_running_loop(loop)
+
+            os.register_at_fork(after_in_child=re_register_loop)
+
     def add_timer(self, timer):
         """
         Register a ``Timer``.

eventlet/patcher.py

@@ -432,27 +432,21 @@ def monkey_patch(**on):
                 if hasattr(orig_mod, attr_name):
                     delattr(orig_mod, attr_name)
 
-            # https://github.com/eventlet/eventlet/issues/592
             if name == "threading" and register_at_fork:
-
-                def fix_threading_active(
-                    _global_dict=_threading.current_thread.__globals__,
-                    # alias orig_mod as patched to reflect its new state
-                    # https://github.com/eventlet/eventlet/pull/661#discussion_r509877481
-                    _patched=orig_mod,
-                ):
-                    _prefork_active = [None]
-
-                    def before_fork():
-                        _prefork_active[0] = _global_dict["_active"]
-                        _global_dict["_active"] = _patched._active
-
-                    def after_fork():
-                        _global_dict["_active"] = _prefork_active[0]
-
-                    register_at_fork(before=before_fork, after_in_parent=after_fork)
-
-                fix_threading_active()
+                # The whole post-fork processing in stdlib threading.py,
+                # implemented in threading._after_fork(), is based on the
+                # assumption that threads don't survive fork(). However, green
+                # threads do survive fork, and that's what threading.py is
+                # tracking when using eventlet, so there's no need to do any
+                # post-fork cleanup in this case.
+                #
+                # So, we wipe out _after_fork()'s code so it does nothing. We
+                # can't just override it because it has already been registered
+                # with os.register_after_fork().
+                def noop():
+                    pass
+                orig_mod._after_fork.__code__ = noop.__code__
+                inject("threading", {})._after_fork.__code__ = noop.__code__
     finally:
         imp.release_lock()
 

tests/isolated/fork_in_main_thread.py

@@ -0,0 +1,47 @@
+import eventlet
+
+eventlet.monkey_patch()
+
+import os
+import time
+import threading
+
+results = set()
+parent = True
+
+
+def check_current():
+    if threading.current_thread() not in threading.enumerate():
+        raise SystemExit(17)
+
+
+def background():
+    time.sleep(1)
+    check_current()
+    results.add("background")
+
+
+def forker():
+    pid = os.fork()
+    check_current()
+    if pid != 0:
+        # We're in the parent. Wait for child to die.
+        wait_pid, status = os.wait()
+        exit_code = os.waitstatus_to_exitcode(status)
+        assert wait_pid == pid
+        assert exit_code == 0, exit_code
+    else:
+        global parent
+        parent = False
+    results.add("forker")
+
+
+t = threading.Thread(target=background)
+t.start()
+forker()
+t.join()
+
+check_current()
+assert results == {"background", "forker"}, results
+if parent:
+    print("pass")

tests/isolated/fork_in_thread.py

@@ -0,0 +1,49 @@
+import eventlet
+
+eventlet.monkey_patch()
+
+import os
+import time
+import threading
+
+results = []
+parent = True
+
+
+def check_current():
+    if threading.current_thread() not in threading.enumerate():
+        raise SystemExit(17)
+
+
+def background():
+    time.sleep(1)
+    check_current()
+    results.append(True)
+
+
+def forker():
+    pid = os.fork()
+    check_current()
+    if pid != 0:
+        # We're in the parent. Wait for child to die.
+        wait_pid, status = os.wait()
+        exit_code = os.waitstatus_to_exitcode(status)
+        assert wait_pid == pid
+        assert exit_code == 0, exit_code
+    else:
+        global parent
+        parent = False
+    results.append(True)
+
+
+t = threading.Thread(target=background)
+t.start()
+t2 = threading.Thread(target=forker)
+t2.start()
+t2.join()
+t.join()
+
+check_current()
+assert results == [True, True]
+if parent:
+    print("pass")

tests/isolated/patcher_fork_after_monkey_patch.py

@@ -17,8 +17,12 @@ def check(n, mod, tag):
     _threading = eventlet.patcher.original('threading')
     import eventlet.green.threading
 
+    global threads_keep_running
+    threads_keep_running = True
+
     def target():
-        eventlet.sleep(0.1)
+        while threads_keep_running:
+            eventlet.sleep(0.001)
 
     threads = [
         threading.Thread(target=target, name='patched'),
@@ -31,23 +35,31 @@ def target():
     for t in threads:
         t.start()
 
-    check(2, threading, 'pre-fork patched')
+    check(5, threading, 'pre-fork patched')
     check(3, _threading, 'pre-fork original')
-    check(4, eventlet.green.threading, 'pre-fork green')
+    check(5, eventlet.green.threading, 'pre-fork green')
 
-    if os.fork() == 0:
-        # Inside the child, we should only have a main thread,
-        # but old pythons make it difficult to ensure
-        check(1, threading, 'child post-fork patched')
+    pid = os.fork()
+    if pid == 0:
+        # Inside the child, we should only have a main _OS_ thread,
+        # but green threads should survive.
+        check(5, threading, 'child post-fork patched')
         check(1, _threading, 'child post-fork original')
-        check(1, eventlet.green.threading, 'child post-fork green')
+        check(5, eventlet.green.threading, 'child post-fork green')
+        threads_keep_running = False
         sys.exit()
     else:
-        os.wait()
+        wait_pid, status = os.wait()
+        exit_code = os.waitstatus_to_exitcode(status)
+        assert wait_pid == pid
+        assert exit_code == 0, exit_code
 
-    check(2, threading, 'post-fork patched')
+    # We're in the parent now; all threads should survive:
+    check(5, threading, 'post-fork patched')
     check(3, _threading, 'post-fork original')
-    check(4, eventlet.green.threading, 'post-fork green')
+    check(5, eventlet.green.threading, 'post-fork green')
+
+    threads_keep_running = False
 
     for t in threads:
         t.join()

tests/patcher_test.py

@@ -514,14 +514,33 @@ def test_threadpoolexecutor():
     tests.run_isolated('patcher_threadpoolexecutor.py')
 
 
+FORK_REASON = "fork() doesn't work well on macOS, and definitely doesn't work on Windows"
+
+
 @pytest.mark.skipif(
     not sys.platform.startswith("linux"),
-    reason="fork() doesn't work well on macOS, and definitely doesn't work on Windows"
+    reason=FORK_REASON
 )
 def test_fork_after_monkey_patch():
     tests.run_isolated('patcher_fork_after_monkey_patch.py')
 
 
+@pytest.mark.skipif(
+    not sys.platform.startswith("linux"),
+    reason=FORK_REASON
+)
+def test_fork_after_monkey_patch_threading():
+    tests.run_isolated('fork_in_main_thread.py')
+
+
+@pytest.mark.skipif(
+    not sys.platform.startswith("linux"),
+    reason=FORK_REASON
+)
+def test_fork_in_thread_after_monkey_patch_threading():
+    tests.run_isolated('fork_in_thread.py')
+
+
 def test_builtin():
     tests.run_isolated('patcher_builtin.py')