gh-155725: Capture tracemalloc tracebacks without a thread state attached

Store traceback frame filenames as interned NUL terminated UTF-8 strings
instead of Python str objects, so that capturing a traceback no longer
uses or modifies Python objects. Threads without an attached thread state
now capture their Python traceback by walking the frames of the thread
state most recently bound to the thread; only threads which never had a
thread state record the traceback as "<unknown>".

Author: kumaraditya303

Doc/c-api/memory.rst

@@ -781,15 +781,14 @@ tracemalloc C API
    If memory block is already tracked, update the existing trace.
 
    The function can be called from any thread, with or without an
-   :term:`attached thread state`.  If the calling thread has no attached
-   thread state, the traceback of the allocation is recorded as
-   ``<unknown>``.
+   :term:`attached thread state`.  The traceback is captured using the
+   Python thread state associated with the calling thread, even if it is
+   not attached.  If the thread has no Python thread state, the traceback
+   is recorded as ``<unknown>``.
 
    .. versionchanged:: next
-      The function no longer acquires the :term:`GIL`.  When called from a
-      thread without an :term:`attached thread state`, the traceback is now
-      recorded as ``<unknown>`` instead of the Python traceback of the
-      calling thread.
+      The function no longer acquires the :term:`GIL` nor creates a
+      temporary thread state.
 
 .. c:function:: int PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr)
 

Include/internal/pycore_tracemalloc.h

@@ -44,9 +44,10 @@ struct
 __attribute__((packed))
 #endif
 tracemalloc_frame {
-    /* filename cannot be NULL: "<unknown>" is used if the Python frame
-       filename is NULL */
-    PyObject *filename;
+    /* Interned NUL terminated UTF-8 (surrogatepass) string.
+       Cannot be NULL: "<unknown>" is used if the Python frame filename
+       cannot be captured. */
+    const char *filename;
     unsigned int lineno;
 };
 
@@ -85,7 +86,7 @@ struct _tracemalloc_runtime_state {
        Protected by TABLES_LOCK(). */
     size_t peak_traced_memory;
     /* Hash table used as a set to intern filenames:
-       PyObject* => PyObject*.
+       char* (NUL terminated UTF-8 string) => NULL.
        Protected by the TABLES_LOCK(). */
     _Py_hashtable_t *filenames;
     /* Buffer to store a new traceback in traceback_new().

Lib/test/test_tracemalloc.py

@@ -1047,22 +1047,17 @@ def check_track(self, release_gil):
         size = tracemalloc.get_traced_memory()[0]
 
         frames = self.track(release_gil, nframe)
-        if release_gil:
-            # PyTraceMalloc_Track() never acquires the GIL: without an
-            # attached thread state, the traceback is recorded as <unknown>
-            expected = tracemalloc.Traceback([("<unknown>", 0)])
-        else:
-            expected = tracemalloc.Traceback(frames)
-        self.assertEqual(self.get_traceback(), expected)
+        self.assertEqual(self.get_traceback(),
+                         tracemalloc.Traceback(frames))
 
         self.assertEqual(self.get_traced_memory(), self.size)
 
     def test_track(self):
         self.check_track(False)
 
     def test_track_without_gil(self):
-        # check that calling PyTraceMalloc_Track() with the thread state
-        # detached (GIL released) records the trace with an unknown traceback
+        # check that calling PyTraceMalloc_Track() without the GIL
+        # (detached thread state) still captures the Python traceback
         self.check_track(True)
 
     def test_track_already_tracked(self):

Misc/NEWS.d/next/Core_and_Builtins/2026-08-26-10-00-00.gh-issue-155725.tRcMal.rst

@@ -1,6 +1,6 @@
 :mod:`tracemalloc` no longer acquires the :term:`GIL` nor creates a
-temporary thread state when tracing memory allocations. Memory allocations
-and :c:func:`PyTraceMalloc_Track` calls made by threads without an
-:term:`attached thread state` now record the traceback as ``<unknown>``
-instead of temporarily attaching a thread state to capture the Python
-traceback of the calling thread.
+temporary thread state to trace memory allocations: traceback frames now
+store plain UTF-8 strings instead of Python str objects, and tracebacks are
+captured using the Python thread state already associated with the calling
+thread, even if it is not attached. Threads without a Python thread state
+record the traceback as ``<unknown>``.