Fix inspecting frames from other threads

msimacek · msimacek · commit 6b1fdfd16ba6 · 2025-11-21T15:05:49.000+01:00
diff --git a/graalpython/com.oracle.graal.python.test/src/tests/test_frame_tests.py b/graalpython/com.oracle.graal.python.test/src/tests/test_frame_tests.py
@@ -246,3 +246,35 @@ def test_clearing_globals():
     junk = globals().clear()
     assert "foo" not in globals().keys()
     assert "junk" in globals().keys()
+
+
+def test_frame_from_another_thread():
+    import sys, threading
+    event1 = threading.Event()
+    event2 = threading.Event()
+    event3 = threading.Event()
+    event4 = threading.Event()
+    frame = None
+    def target():
+        # Mind the line numbers
+        nonlocal frame
+        frame = sys._getframe()
+        a = 1
+        event1.set()
+        event2.wait(timeout=60)
+        b = 2
+        event3.set()
+        event4.wait(timeout=60)
+    thread = threading.Thread(target=target)
+    thread.start()
+    event1.wait(timeout=60)
+    firstlineno = target.__code__.co_firstlineno
+    assert 5 <= frame.f_lineno - firstlineno <= 6
+    assert frame.f_locals['a'] == 1
+    assert 'b' not in frame.f_locals
+    event2.set()
+    event3.wait(timeout=60)
+    assert 8 <= frame.f_lineno - firstlineno <= 9
+    assert frame.f_locals['b'] == 2
+    event4.set()
+    thread.join(timeout=60)
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/frame/PFrame.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/frame/PFrame.java
@@ -77,6 +77,7 @@ public final class PFrame extends PythonBuiltinObject {
     private Object localsDict;
     private PythonObject globals;
     private final Reference virtualFrameInfo;
+    private final Thread thread;
     /**
      * For the manual bytecode interpreter the location can be the {@link PBytecodeRootNode} itself,
      * but for the Bytecode DSL interpreter, the location must be an AST node connected to the
@@ -107,7 +108,7 @@ public final class PFrame extends PythonBuiltinObject {
 
     /**
      * The last {@link CallerFlags} that were used the last time the frame was synced or passed down
-     * to a callee. See {@link #isStale(VirtualFrame, int)} for more details.
+     * to a callee. See {@link #needsRefresh(VirtualFrame, int)} for more details.
      */
     private int lastCallerFlags;
 
@@ -208,6 +209,7 @@ public PFrame(PythonLanguage lang, Reference virtualFrameInfo, Node location, bo
         // Mark everything as current for now. MaterializeFrameNode will set lastCallerFlags to a
         // narrower value if needed
         this.lastCallerFlags = CallerFlags.ALL_FRAME_FLAGS;
+        this.thread = Thread.currentThread();
     }
 
     public PFrame(PythonLanguage lang, @SuppressWarnings("unused") Object threadState, PCode code, PythonObject globals, Object localsDict) {
@@ -223,6 +225,7 @@ public PFrame(PythonLanguage lang, @SuppressWarnings("unused") Object threadStat
         this.localsDict = localsDict;
         // This is a synthetic frame, there will be no sync, mark everything as current
         this.lastCallerFlags = CallerFlags.ALL_FRAME_FLAGS;
+        this.thread = null;
     }
 
     /**
@@ -252,18 +255,27 @@ public void setLocals(MaterializedFrame locals) {
      * @param callerFlags Specifies which fields should be checked for needing sync. It should be
      *            flags from {@link CallerFlags}.
      */
-    public boolean isStale(VirtualFrame frame, int callerFlags) {
-        if (hasCustomLocals) {
-            // Custom locals don't need locals sync
-            callerFlags &= ~CallerFlags.NEEDS_LOCALS;
-        }
-        if (CallerFlags.needsLocals(callerFlags) && locals == null) {
+    public boolean needsRefresh(VirtualFrame frame, int callerFlags) {
+        if (outdatedCallerFlags(callerFlags)) {
             return true;
         }
         if (CallerFlags.needsLocals(callerFlags) || CallerFlags.needsLasti(callerFlags)) {
             if (frame != null && PArguments.getCurrentFrameInfo(frame) == getRef()) {
                 return true;
             }
+            // Frames from other threads need to go through slow path
+            return thread != null && thread != Thread.currentThread();
+        }
+        return false;
+    }
+
+    public boolean outdatedCallerFlags(int callerFlags) {
+        if (hasCustomLocals) {
+            // Custom locals don't need locals sync
+            callerFlags &= ~CallerFlags.NEEDS_LOCALS;
+        }
+        if (CallerFlags.needsLocals(callerFlags) && locals == null) {
+            return true;
         }
         return (callerFlags & lastCallerFlags) != callerFlags;
     }
@@ -291,6 +303,10 @@ public PFrame.Reference getRef() {
         return virtualFrameInfo;
     }
 
+    public Thread getThread() {
+        return thread;
+    }
+
     public PFrame.Reference getBackref() {
         return backref;
     }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/GetFrameLocalsNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/GetFrameLocalsNode.java
@@ -102,10 +102,10 @@ static Object doLoop(VirtualFrame frame, Node inliningTarget, PFrame pyFrame, bo
                     @Cached InlinedBranchProfile create,
                     @Cached(inline = false) CopyLocalsToDict copyLocalsToDict,
                     @Cached ReadFrameNode readFrameNode) {
-        if (!freshFrame && pyFrame.isStale(frame, CallerFlags.NEEDS_LOCALS)) {
+        if (!freshFrame && pyFrame.needsRefresh(frame, CallerFlags.NEEDS_LOCALS)) {
             pyFrame = readFrameNode.refreshFrame(frame, pyFrame.getRef(), CallerFlags.NEEDS_LOCALS);
         }
-        assert !pyFrame.isStale(null, CallerFlags.NEEDS_LOCALS);
+        assert !pyFrame.outdatedCallerFlags(CallerFlags.NEEDS_LOCALS);
         MaterializedFrame locals = pyFrame.getLocals();
         // It doesn't have custom locals, so it has to be a builtin dict or null
         PDict localsDict = (PDict) pyFrame.getLocalsDict();
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/ReadFrameNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/ReadFrameNode.java
@@ -40,24 +40,37 @@
  */
 package com.oracle.graal.python.nodes.frame;
 
+import static com.oracle.graal.python.util.PythonUtils.tsLiteral;
+
 import java.util.Objects;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
+import com.oracle.graal.python.PythonLanguage;
+import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.objects.frame.PFrame;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
 import com.oracle.graal.python.builtins.objects.generator.PGenerator;
+import com.oracle.graal.python.nodes.PRaiseNode;
 import com.oracle.graal.python.nodes.PRootNode;
 import com.oracle.graal.python.nodes.bytecode.PBytecodeGeneratorRootNode;
 import com.oracle.graal.python.nodes.bytecode.PBytecodeRootNode;
 import com.oracle.graal.python.nodes.bytecode_dsl.PBytecodeDSLRootNode;
 import com.oracle.graal.python.runtime.CallerFlags;
+import com.oracle.graal.python.runtime.GilNode;
 import com.oracle.graal.python.runtime.IndirectCallData;
 import com.oracle.graal.python.runtime.IndirectCallData.BoundaryCallData;
 import com.oracle.graal.python.runtime.PythonContext;
 import com.oracle.graal.python.runtime.PythonOptions;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.RootCallTarget;
+import com.oracle.truffle.api.ThreadLocalAction;
 import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.TruffleSafepoint;
 import com.oracle.truffle.api.bytecode.ContinuationRootNode;
 import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached;
@@ -144,7 +157,7 @@ public final PFrame refreshFrame(VirtualFrame frame, PFrame.Reference reference,
     }
 
     public final PFrame ensureFresh(VirtualFrame frame, PFrame pFrame, int callerFlags) {
-        if (pFrame.isStale(frame, callerFlags)) {
+        if (pFrame.needsRefresh(frame, callerFlags)) {
             return refreshFrame(frame, pFrame.getRef(), callerFlags);
         }
         return pFrame;
@@ -166,9 +179,11 @@ PFrame read(VirtualFrame frame, PFrame.Reference startFrameInfo, FrameInstance.F
                     @Cached MaterializeFrameNode materializeFrameNode,
                     @Cached InlinedBranchProfile stackWalkProfile1,
                     @Cached InlinedBranchProfile stackWalkProfile2) {
+        PFrame.Reference executingFrameInfo = frame != null ? PArguments.getCurrentFrameInfo(frame) : null;
         if (startFrameInfo == null) {
             PythonContext context = PythonContext.get(this);
             startFrameInfo = context.peekTopFrameInfo(context.getLanguage(this));
+            executingFrameInfo = startFrameInfo;
         }
         int i = 0;
         PFrame.Reference curFrameInfo = startFrameInfo;
@@ -182,10 +197,10 @@ PFrame read(VirtualFrame frame, PFrame.Reference startFrameInfo, FrameInstance.F
                 if (i == level) {
                     // We found the right reference
                     // Maybe it's for the frame we're in?
-                    if (frame != null && PArguments.getCurrentFrameInfo(frame) == curFrameInfo) {
+                    if (curFrameInfo == executingFrameInfo) {
                         return materializeFrameNode.execute(this, false, CallerFlags.needsLocals(callerFlags), frame);
                     }
-                    if (curFrameInfo.getPyFrame() != null && !curFrameInfo.getPyFrame().isStale(null, callerFlags)) {
+                    if (curFrameInfo.getPyFrame() != null && !curFrameInfo.getPyFrame().needsRefresh(null, callerFlags)) {
                         return curFrameInfo.getPyFrame();
                     }
                     // We don't have the frame for the reference, fall back to the stack walk
@@ -215,7 +230,7 @@ PFrame read(VirtualFrame frame, PFrame.Reference startFrameInfo, FrameInstance.F
          * It is necessary to continue from where we stopped with the backref walk because the
          * original starting frame might not be on stack anymore
          */
-        return readFromStackWalk(curFrameInfo, frameAccess, selector, level - i, callerFlags, materializeFrameNode);
+        return readSlowPath(curFrameInfo, frameAccess, selector, level - i, callerFlags, materializeFrameNode);
     }
 
     private static PFrame.Reference getBackref(PFrame.Reference reference) {
@@ -226,9 +241,49 @@ private static PFrame.Reference getBackref(PFrame.Reference reference) {
     }
 
     @TruffleBoundary
-    private PFrame readFromStackWalk(PFrame.Reference startFrameInfo, FrameInstance.FrameAccess frameAccess, FrameSelector selector, int level, int callerFlags,
+    @SuppressWarnings("try")
+    private PFrame readSlowPath(PFrame.Reference startFrameInfo, FrameInstance.FrameAccess frameAccess, FrameSelector selector, int level, int callerFlags,
                     MaterializeFrameNode materializeFrameNode) {
+        if (level == 0 && startFrameInfo != null && startFrameInfo.getPyFrame() != null && !selector.skip(startFrameInfo.getRootNode()) && startFrameInfo.getPyFrame().getThread() != null &&
+                        startFrameInfo.getPyFrame().getThread() != Thread.currentThread()) {
+            // We have the frame we're looking for, but it's on another thread
+            Thread thread = startFrameInfo.getPyFrame().getThread();
+            if (thread.isAlive()) {
+                try (var gil = GilNode.uncachedRelease()) {
+                    // Schedule a safepoint action on that thread
+                    Future<Void> future = PythonContext.get(null).getEnv().submitThreadLocal(new Thread[]{thread}, new ThreadLocalAction(true, false) {
+                        @Override
+                        protected void perform(Access access) {
+                            Node location = access.getLocation();
+                            if (location instanceof PBytecodeDSLRootNode) {
+                                // See AsyncPythonAction#execute for explanation
+                                location = PythonLanguage.get(null).unavailableSafepointLocation;
+                            }
+                            StackWalkResult result = ReadFrameNode.getFrame(location, startFrameInfo, frameAccess, selector, 0, callerFlags);
+                            processStackWalkResult(materializeFrameNode, callerFlags, result);
+                        }
+                    });
+                    TruffleSafepoint.setBlockedThreadInterruptible(this, voidFuture -> {
+                        try {
+                            voidFuture.get(10, TimeUnit.SECONDS);
+                        } catch (TimeoutException e) {
+                            throw PRaiseNode.raiseStatic(this, PythonBuiltinClassType.RuntimeError, tsLiteral("Failed to interrupt thread " + Thread.currentThread() + " within 10 seconds"));
+                        } catch (CancellationException e) {
+                            // Ignore
+                        } catch (ExecutionException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }, future);
+                }
+            }
+            assert !startFrameInfo.getPyFrame().outdatedCallerFlags(callerFlags);
+            return startFrameInfo.getPyFrame();
+        }
         StackWalkResult callerFrameResult = getFrame(this, startFrameInfo, frameAccess, selector, level, callerFlags);
+        return processStackWalkResult(materializeFrameNode, callerFlags, callerFrameResult);
+    }
+
+    private static PFrame processStackWalkResult(MaterializeFrameNode materializeFrameNode, int callerFlags, StackWalkResult callerFrameResult) {
         if (callerFrameResult != null) {
             Node location = callerFrameResult.callNode;
             if (!(callerFrameResult.rootNode instanceof PBytecodeDSLRootNode) && location == null) {
