RustPython
diff --git a/‎crates/stdlib/src/faulthandler.rs‎
Lines changed: 58 additions & 77 deletions b/‎crates/stdlib/src/faulthandler.rs‎
Lines changed: 58 additions & 77 deletions
diff --git a/‎crates/vm/src/frame.rs‎
Lines changed: 10 additions & 7 deletions b/‎crates/vm/src/frame.rs‎
Lines changed: 10 additions & 7 deletions
@@ -6,7 +6,6 @@ mod decl {
     use crate::vm::{
         PyObjectRef, PyResult, VirtualMachine,
         frame::Frame,
-        frame_snapshot::SNAPSHOT_ENABLED,
         function::{ArgIntoFloat, OptionalArg},
     };
     use alloc::sync::Arc;
@@ -228,41 +227,59 @@ mod decl {
         puts(fd, " (most recent call first):\n");
     }
 
-    // dump_frame (traceback.c:1037-1087)
+    /// Dump the current thread's live frame chain to fd (signal-safe).
+    /// Walks the `Frame.previous` pointer chain starting from the
+    /// thread-local current frame pointer.
     #[cfg(any(unix, windows))]
-    fn dump_frame(fd: i32, filename: &[u8], lineno: u32, funcname: &[u8]) {
-        puts(fd, "  File \"");
-        puts_bytes(fd, filename);
-        puts(fd, "\", line ");
-        dump_decimal(fd, lineno as usize);
-        puts(fd, " in ");
-        puts_bytes(fd, funcname);
-        puts(fd, "\n");
+    fn dump_live_frames(fd: i32) {
+        const MAX_FRAME_DEPTH: usize = 100;
+
+        let mut frame_ptr = crate::vm::vm::thread::get_current_frame();
+        if frame_ptr.is_null() {
+            puts(fd, "  <no Python frame>\n");
+            return;
+        }
+        let mut depth = 0;
+        while !frame_ptr.is_null() && depth < MAX_FRAME_DEPTH {
+            let frame = unsafe { &*frame_ptr };
+            dump_frame_from_raw(fd, frame);
+            frame_ptr = frame.previous_frame();
+            depth += 1;
+        }
+        if depth >= MAX_FRAME_DEPTH && !frame_ptr.is_null() {
+            puts(fd, "  ...\n");
+        }
     }
 
-    /// Dump frame snapshots to fd (signal-safe)
+    /// Dump a single frame's info to fd (signal-safe), reading live data.
     #[cfg(any(unix, windows))]
-    fn dump_snapshot_frames(fd: i32) {
-        use crate::vm::frame_snapshot::{FRAME_SNAPSHOTS, SNAPSHOT_COUNT};
-        let count = SNAPSHOT_COUNT.load(Ordering::Acquire);
-        if count > 0 {
-            #[allow(clippy::needless_range_loop)]
-            for i in 0..count {
-                unsafe {
-                    let snap = &FRAME_SNAPSHOTS[i];
-                    if snap.filename_len > 0 {
-                        dump_frame(
-                            fd,
-                            &snap.filename[..snap.filename_len],
-                            snap.lineno,
-                            &snap.funcname[..snap.funcname_len],
-                        );
-                    }
-                }
+    fn dump_frame_from_raw(fd: i32, frame: &Frame) {
+        let filename = frame.code.source_path.as_str();
+        let funcname = frame.code.obj_name.as_str();
+        let lasti = frame.lasti();
+        let lineno = if lasti == 0 {
+            frame.code.first_line_number.map(|n| n.get()).unwrap_or(1) as u32
+        } else {
+            let idx = (lasti as usize).saturating_sub(1);
+            if idx < frame.code.locations.len() {
+                frame.code.locations[idx].0.line.get() as u32
+            } else {
+                frame.code.first_line_number.map(|n| n.get()).unwrap_or(0) as u32
             }
+        };
+
+        puts(fd, "  File \"");
+        puts(fd, filename);
+        puts(fd, "\", line ");
+        dump_decimal(fd, lineno as usize);
+        puts(fd, " in ");
+        if funcname.len() > MAX_FUNCTION_NAME_LEN {
+            puts(fd, &funcname[..MAX_FUNCTION_NAME_LEN]);
+            puts(fd, "...");
         } else {
-            puts(fd, "  <no Python frame>\n");
+            puts(fd, funcname);
         }
+        puts(fd, "\n");
     }
 
     // faulthandler_dump_traceback (signal-safe, for fatal errors)
@@ -281,16 +298,11 @@ mod decl {
             puts(fd, "Stack (most recent call first):\n");
         }
 
-        dump_snapshot_frames(fd);
+        dump_live_frames(fd);
 
         REENTRANT.store(false, Ordering::SeqCst);
     }
 
-    /// Snapshot current Python frames into signal-safe global storage.
-    fn snapshot_current_frames(vm: &VirtualMachine) {
-        crate::vm::frame_snapshot::do_update_frame_snapshots(&vm.frames.borrow());
-    }
-
     const MAX_FUNCTION_NAME_LEN: usize = 500;
 
     /// Write a frame's info to an fd using signal-safe I/O.
@@ -444,10 +456,6 @@ mod decl {
             .all_threads
             .store(args.all_threads, Ordering::Relaxed);
 
-        // Enable frame snapshot updates and immediately snapshot existing frames
-        SNAPSHOT_ENABLED.store(true, Ordering::Relaxed);
-        snapshot_current_frames(vm);
-
         // Install signal handlers
         if !faulthandler_enable_internal() {
             return Err(vm.new_runtime_error("Failed to enable faulthandler".to_owned()));
@@ -753,29 +761,11 @@ mod decl {
         FATAL_ERROR.enabled.store(false, Ordering::Relaxed);
     }
 
-    // Check if any faulthandler feature needs snapshots
-    #[cfg(unix)]
-    fn any_user_signal_enabled() -> bool {
-        for signum in 1..64 {
-            if user_signals::is_enabled(signum) {
-                return true;
-            }
-        }
-        false
-    }
-
     // faulthandler_disable_py
     #[pyfunction]
     fn disable() -> bool {
         let was_enabled = FATAL_ERROR.enabled.load(Ordering::Relaxed);
         faulthandler_disable_internal();
-        // Disable snapshots only if no user signals are registered
-        #[cfg(unix)]
-        if !any_user_signal_enabled() {
-            SNAPSHOT_ENABLED.store(false, Ordering::Relaxed);
-        }
-        #[cfg(not(unix))]
-        SNAPSHOT_ENABLED.store(false, Ordering::Relaxed);
         was_enabled
     }
 
@@ -874,7 +864,7 @@ mod decl {
                 puts_bytes(fd, header.as_bytes());
 
                 // Use thread frame slots when threading is enabled (includes all threads).
-                // Fall back to frame snapshots for non-threaded builds.
+                // Fall back to live frame walking for non-threaded builds.
                 #[cfg(feature = "threading")]
                 {
                     for (tid, slot) in &thread_frame_slots {
@@ -885,7 +875,7 @@ mod decl {
                 #[cfg(not(feature = "threading"))]
                 {
                     write_thread_id(fd, false);
-                    dump_snapshot_frames(fd);
+                    dump_live_frames(fd);
                 }
 
                 if exit {
@@ -930,10 +920,6 @@ mod decl {
 
         let header = format_timeout(timeout_us);
 
-        // Enable frame snapshot updates so watchdog can read them
-        SNAPSHOT_ENABLED.store(true, Ordering::Relaxed);
-        snapshot_current_frames(vm);
-
         // Snapshot thread frame slots so watchdog can dump tracebacks
         #[cfg(feature = "threading")]
         let thread_frame_slots: Vec<(u64, ThreadFrameSlot)> = {
@@ -1076,8 +1062,8 @@ mod decl {
             puts(user.fd, "Stack (most recent call first):\n");
         }
 
-        // Dump frame snapshots (updated by main thread on every frame push/pop)
-        dump_snapshot_frames(user.fd);
+        // Dump live frame chain (walks Frame.previous pointers)
+        dump_live_frames(user.fd);
 
         // If chain is enabled, call the previous handler
         if user.chain {
@@ -1140,10 +1126,6 @@ mod decl {
 
         let signum = args.signum as usize;
 
-        // Enable frame snapshot updates and immediately snapshot existing frames
-        SNAPSHOT_ENABLED.store(true, Ordering::Relaxed);
-        snapshot_current_frames(vm);
-
         // Get current handler to save as previous
         let previous = if !user_signals::is_enabled(signum) {
             // Install signal handler using sigaction with SA_NODEFER
@@ -1201,11 +1183,11 @@ mod decl {
     // Test functions for faulthandler testing
 
     #[pyfunction]
-    fn _read_null(vm: &VirtualMachine) {
+    fn _read_null(_vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
         {
             suppress_crash_report();
-            snapshot_current_frames(vm);
+
             unsafe {
                 let ptr: *const i32 = core::ptr::null();
                 core::ptr::read_volatile(ptr);
@@ -1221,11 +1203,10 @@ mod decl {
     }
 
     #[pyfunction]
-    fn _sigsegv(_args: SigsegvArgs, vm: &VirtualMachine) {
+    fn _sigsegv(_args: SigsegvArgs, _vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
         {
             suppress_crash_report();
-            snapshot_current_frames(vm);
 
             // Write to NULL pointer to trigger a real hardware SIGSEGV,
             // matching CPython's *((volatile int *)NULL) = 0;
@@ -1239,23 +1220,23 @@ mod decl {
     }
 
     #[pyfunction]
-    fn _sigabrt(vm: &VirtualMachine) {
+    fn _sigabrt(_vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
         {
             suppress_crash_report();
-            snapshot_current_frames(vm);
+
             unsafe {
                 libc::abort();
             }
         }
     }
 
     #[pyfunction]
-    fn _sigfpe(vm: &VirtualMachine) {
+    fn _sigfpe(_vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
         {
             suppress_crash_report();
-            snapshot_current_frames(vm);
+
             unsafe {
                 libc::raise(libc::SIGFPE);
             }
 
@@ -25,8 +25,8 @@ use crate::{
 };
 use alloc::fmt;
 use core::iter::zip;
-#[cfg(feature = "threading")]
 use core::sync::atomic;
+use core::sync::atomic::AtomicPtr;
 use indexmap::IndexMap;
 use itertools::Itertools;
 
@@ -90,6 +90,9 @@ pub struct Frame {
     /// Borrowed reference (not ref-counted) to avoid Generator↔Frame cycle.
     /// Cleared by the generator's Drop impl.
     pub generator: PyAtomicBorrow,
+    /// Previous frame in the call chain for signal-safe traceback walking.
+    /// Mirrors `_PyInterpreterFrame.previous`.
+    pub(crate) previous: AtomicPtr<Frame>,
 }
 
 impl PyPayload for Frame {
@@ -179,6 +182,7 @@ impl Frame {
             trace_opcodes: PyMutex::new(false),
             temporary_refs: PyMutex::new(vec![]),
             generator: PyAtomicBorrow::new(),
+            previous: AtomicPtr::new(core::ptr::null_mut()),
         }
     }
 
@@ -197,6 +201,11 @@ impl Frame {
         self.code.locations[self.lasti() as usize - 1].0
     }
 
+    /// Get the previous frame pointer for signal-safe traceback walking.
+    pub fn previous_frame(&self) -> *const Frame {
+        self.previous.load(atomic::Ordering::Relaxed)
+    }
+
     pub fn lasti(&self) -> u32 {
         #[cfg(feature = "threading")]
         {
@@ -398,12 +407,6 @@ impl ExecutingFrame<'_> {
         let mut arg_state = bytecode::OpArgState::default();
         loop {
             let idx = self.lasti() as usize;
-            // Update frame snapshot line number for signal handlers (faulthandler)
-            if idx < self.code.locations.len() {
-                crate::frame_snapshot::update_current_lineno(
-                    self.code.locations[idx].0.line.get() as u32
-                );
-            }
             self.update_lasti(|i| *i += 1);
             let bytecode::CodeUnit { op, arg } = instructions[idx];
             let arg = arg_state.extend(arg);