gh-158364: Don't report other interpreters' threads in sys._current_frames()

sys._current_frames() materialized a PyFrameObject for every thread of
every interpreter.  A frame object created for a thread of another
interpreter belongs to that interpreter: it is stored in its
_PyInterpreterFrame.frame_obj and deallocated when that interpreter pops
the frame, while the calling interpreter holds the reference from the
returned dict and drops it at some arbitrary later time.  Since PEP 684
gives each interpreter its own obmalloc arenas, the block ends up being
freed by a different interpreter than the one that allocated it, which
corrupts the heap and typically aborts the process inside free().

sys._current_exceptions() has the same problem: it hands out references
to exception objects owned by other interpreters.

Both functions now only report the threads of the calling interpreter.
This matches PyUnstable_DumpTracebackThreads() (used by faulthandler),
which already only dumps the threads of one interpreter.  As a
consequence, only the current interpreter's world needs to be stopped.

Author: Himesh-rupchandani

Doc/library/sys.rst

@@ -271,6 +271,13 @@ always available. Unless explicitly noted otherwise, all variables are read-only
 
    .. audit-event:: sys._current_frames "" sys._current_frames
 
+   .. versionchanged:: 3.16
+      Only the threads of the current interpreter are included.  Previously
+      the threads of other interpreters were reported as well, but the frame
+      objects created for them belonged to those interpreters, which could
+      corrupt the heap (each interpreter has its own memory arenas) and crash
+      the process.
+
 .. function:: _current_exceptions()
 
    Return a dictionary mapping each thread's identifier to the topmost exception
@@ -288,6 +295,10 @@ always available. Unless explicitly noted otherwise, all variables are read-only
       Each value in the dictionary is now a single exception instance, rather
       than a 3-tuple as returned from ``sys.exc_info()``.
 
+   .. versionchanged:: 3.16
+      Only the threads of the current interpreter are included, as for
+      :func:`_current_frames`.
+
 .. function:: breakpointhook()
 
    This hook function is called by built-in :func:`breakpoint`.  By default,

Lib/test/test_sys.py

@@ -563,6 +563,108 @@ def g456():
             leave_g.set()
             t.join()
 
+    @support.cpython_only
+    @requires_subinterpreters
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_current_frames_other_interpreters(self):
+        # gh-158364: sys._current_frames() must not report the threads of
+        # other interpreters.  A frame object materialized for such a thread
+        # belongs to that interpreter, and since each interpreter has its own
+        # memory arenas, it would be deallocated by a different interpreter
+        # than the one that allocated it, corrupting the heap.
+        import threading
+
+        # Park a thread of *this* interpreter at a known place.
+        entered_g = threading.Event()
+        leave_g = threading.Event()
+
+        def park():
+            entered_g.set()
+            leave_g.wait(support.SHORT_TIMEOUT)
+
+        t = threading.Thread(target=park)
+        t.start()
+        entered_g.wait(support.SHORT_TIMEOUT)
+        try:
+            interp = interpreters.create()
+            try:
+                interp.exec(textwrap.dedent(f'''
+                    import sys
+                    import threading
+
+                    frames = sys._current_frames()
+
+                    # This interpreter reports its own threads...
+                    assert threading.get_ident() in frames, frames
+                    frame = frames[threading.get_ident()]
+                    assert frame.f_globals is globals(), frame.f_globals
+                    # ...and not the threads of the main interpreter.
+                    assert {t.ident} not in frames, frames
+                    '''))
+            finally:
+                interp.close()
+        finally:
+            # Reap the spawned thread.
+            leave_g.set()
+            t.join()
+
+    @support.cpython_only
+    @requires_subinterpreters
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_current_frames_subinterpreter_thread(self):
+        # gh-158364: the same, but sampling here while another interpreter
+        # runs in a different thread.  The frames are kept alive until after
+        # the other interpreter is destroyed, so that *this* interpreter is
+        # the one that deallocates them.
+        import threading
+
+        # One queue per direction, so that neither side can consume its own
+        # message.
+        ids = interpreters.create_queue()
+        release = interpreters.create_queue()
+        interp = interpreters.create()
+        script = textwrap.dedent(f'''
+            import threading
+            from concurrent.interpreters import Queue
+
+            ids = Queue({ids.id})
+            release = Queue({release.id})
+
+            def work():
+                ids.put(threading.get_ident())
+                release.get()
+
+            t = threading.Thread(target=work)
+            t.start()
+            t.join()
+            ''')
+        t = threading.Thread(target=interp.exec, args=(script,), daemon=True)
+        t.start()
+        frames = None
+        try:
+            # The other interpreter's thread is now parked in release.get(),
+            # running a frame that this interpreter must leave alone.
+            other_id = ids.get(timeout=support.SHORT_TIMEOUT)
+            frames = sys._current_frames()
+            self.assertNotIn(other_id, frames)
+
+            # Let the other interpreter unwind and go away.
+            release.put('go')
+            t.join(support.SHORT_TIMEOUT)
+            self.assertFalse(t.is_alive())
+        finally:
+            release.put('go')
+            t.join(support.SHORT_TIMEOUT)
+            try:
+                interp.close()
+            except interpreters.InterpreterError:
+                pass
+            # The other interpreter's memory is gone by now; dropping the
+            # frames here must still be safe.
+            frames = None
+
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_current_exceptions(self):
@@ -629,6 +731,46 @@ def g456():
             leave_g.set()
             t.join()
 
+    @support.cpython_only
+    @requires_subinterpreters
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_current_exceptions_other_interpreters(self):
+        # gh-158364: like test_current_frames_other_interpreters(), but for
+        # sys._current_exceptions(): the returned dict would hold a reference
+        # to an exception owned by another interpreter.
+        import threading
+
+        entered_g = threading.Event()
+        leave_g = threading.Event()
+
+        def hold():
+            try:
+                raise ValueError('held in another thread')
+            except ValueError:
+                entered_g.set()
+                leave_g.wait(support.SHORT_TIMEOUT)
+
+        t = threading.Thread(target=hold)
+        t.start()
+        entered_g.wait(support.SHORT_TIMEOUT)
+        try:
+            interp = interpreters.create()
+            try:
+                interp.exec(textwrap.dedent(f'''
+                    import sys
+
+                    excs = sys._current_exceptions()
+
+                    assert {t.ident} not in excs, excs
+                    '''))
+            finally:
+                interp.close()
+        finally:
+            # Reap the spawned thread.
+            leave_g.set()
+            t.join()
+
     def test_attributes(self):
         self.assertIsInstance(sys.api_version, int)
         self.assertIsInstance(sys.argv, list)

Misc/NEWS.d/next/Core_and_Builtins/2026-09-28-18-58-27.gh-issue-158364.jBqmTs.rst

@@ -0,0 +1,8 @@
+Fix heap corruption (typically an abort or crash in the C library's
+``free()``) when :func:`sys._current_frames` or
+:func:`sys._current_exceptions` is called while another interpreter is
+running.  Both functions no longer report the threads of other
+interpreters: a frame object materialized for such a thread belongs to
+that interpreter, and since each interpreter has its own memory arenas it
+was being deallocated by a different interpreter than the one that
+allocated it.

Python/pystate.c

@@ -2792,6 +2792,9 @@ _PyThread_CurrentFrames(void)
 {
     _PyRuntimeState *runtime = &_PyRuntime;
     PyThreadState *tstate = current_fast_get();
+
+    _Py_EnsureTstateNotNULL(tstate);
+
     if (_PySys_Audit(tstate, "sys._current_frames", NULL) < 0) {
         return NULL;
     }
@@ -2801,36 +2804,45 @@ _PyThread_CurrentFrames(void)
         return NULL;
     }
 
-    /* for i in all interpreters:
-     *     for t in all of i's thread states:
-     *          if t's frame isn't NULL, map t's id to its frame
+    /* for t in all of the current interpreter's thread states:
+     *     if t's frame isn't NULL, map t's id to its frame
      * Because these lists can mutate even when the GIL is held, we
      * need to grab head_mutex for the duration.
+     *
+     * Threads of other interpreters are not included (gh-158364).  A frame
+     * object materialized for such a thread belongs to that interpreter: it
+     * is stored in its _PyInterpreterFrame.frame_obj and deallocated when
+     * that interpreter pops the frame, while the caller drops the reference
+     * held by the returned dict at some arbitrary later time.  Since PEP 684
+     * gives each interpreter its own obmalloc arenas, the block can be freed
+     * by a different interpreter than the one that allocated it, corrupting
+     * the heap.  Handing out such a frame is unsafe for other reasons too: it
+     * holds references to the other interpreter's objects, and that
+     * interpreter may be finalized while the caller still holds the frame.
+     * Code running in each interpreter sees its own threads.
      */
-    _PyEval_StopTheWorldAll(runtime);
+    PyInterpreterState *interp = tstate->interp;
+    _PyEval_StopTheWorld(interp);
     HEAD_LOCK(runtime);
-    PyInterpreterState *i;
-    for (i = runtime->interpreters.head; i != NULL; i = i->next) {
-        _Py_FOR_EACH_TSTATE_UNLOCKED(i, t) {
-            _PyInterpreterFrame *frame = t->current_frame;
-            frame = _PyFrame_GetFirstComplete(frame);
-            if (frame == NULL) {
-                continue;
-            }
-            PyObject *id = PyLong_FromUnsignedLong(t->thread_id);
-            if (id == NULL) {
-                goto fail;
-            }
-            PyObject *frameobj = (PyObject *)_PyFrame_GetFrameObject(frame);
-            if (frameobj == NULL) {
-                Py_DECREF(id);
-                goto fail;
-            }
-            int stat = PyDict_SetItem(result, id, frameobj);
+    _Py_FOR_EACH_TSTATE_UNLOCKED(interp, t) {
+        _PyInterpreterFrame *frame = t->current_frame;
+        frame = _PyFrame_GetFirstComplete(frame);
+        if (frame == NULL) {
+            continue;
+        }
+        PyObject *id = PyLong_FromUnsignedLong(t->thread_id);
+        if (id == NULL) {
+            goto fail;
+        }
+        PyObject *frameobj = (PyObject *)_PyFrame_GetFrameObject(frame);
+        if (frameobj == NULL) {
             Py_DECREF(id);
-            if (stat < 0) {
-                goto fail;
-            }
+            goto fail;
+        }
+        int stat = PyDict_SetItem(result, id, frameobj);
+        Py_DECREF(id);
+        if (stat < 0) {
+            goto fail;
         }
     }
     goto done;
@@ -2840,7 +2852,7 @@ _PyThread_CurrentFrames(void)
 
 done:
     HEAD_UNLOCK(runtime);
-    _PyEval_StartTheWorldAll(runtime);
+    _PyEval_StartTheWorld(interp);
     return result;
 }
 
@@ -2866,35 +2878,37 @@ _PyThread_CurrentExceptions(void)
         return NULL;
     }
 
-    /* for i in all interpreters:
-     *     for t in all of i's thread states:
-     *          if t's frame isn't NULL, map t's id to its frame
+    /* for t in all of the current interpreter's thread states:
+     *     if t's frame isn't NULL, map t's id to its exception
      * Because these lists can mutate even when the GIL is held, we
      * need to grab head_mutex for the duration.
+     *
+     * Threads of other interpreters are not included, for the same reason as
+     * in _PyThread_CurrentFrames(): the returned dict would hold a reference
+     * to an exception owned by another interpreter, which can then be
+     * deallocated by whichever interpreter drops it last (gh-158364).
      */
-    _PyEval_StopTheWorldAll(runtime);
+    PyInterpreterState *interp = tstate->interp;
+    _PyEval_StopTheWorld(interp);
     HEAD_LOCK(runtime);
-    PyInterpreterState *i;
-    for (i = runtime->interpreters.head; i != NULL; i = i->next) {
-        _Py_FOR_EACH_TSTATE_UNLOCKED(i, t) {
-            _PyErr_StackItem *err_info = _PyErr_GetTopmostException(t);
-            if (err_info == NULL) {
-                continue;
-            }
-            PyObject *id = PyLong_FromUnsignedLong(t->thread_id);
-            if (id == NULL) {
-                goto fail;
-            }
-            PyObject *exc = err_info->exc_value;
-            assert(exc == NULL ||
-                   exc == Py_None ||
-                   PyExceptionInstance_Check(exc));
-
-            int stat = PyDict_SetItem(result, id, exc == NULL ? Py_None : exc);
-            Py_DECREF(id);
-            if (stat < 0) {
-                goto fail;
-            }
+    _Py_FOR_EACH_TSTATE_UNLOCKED(interp, t) {
+        _PyErr_StackItem *err_info = _PyErr_GetTopmostException(t);
+        if (err_info == NULL) {
+            continue;
+        }
+        PyObject *id = PyLong_FromUnsignedLong(t->thread_id);
+        if (id == NULL) {
+            goto fail;
+        }
+        PyObject *exc = err_info->exc_value;
+        assert(exc == NULL ||
+               exc == Py_None ||
+               PyExceptionInstance_Check(exc));
+
+        int stat = PyDict_SetItem(result, id, exc == NULL ? Py_None : exc);
+        Py_DECREF(id);
+        if (stat < 0) {
+            goto fail;
         }
     }
     goto done;
@@ -2904,7 +2918,7 @@ _PyThread_CurrentExceptions(void)
 
 done:
     HEAD_UNLOCK(runtime);
-    _PyEval_StartTheWorldAll(runtime);
+    _PyEval_StartTheWorld(interp);
     return result;
 }