crates/stdlib/src/faulthandler.rs (1)

122-147: Consider consolidating puts and puts_bytes to reduce duplication.

Both functions have nearly identical implementations differing only in the input type. Since &str can be converted to &[u8] via as_bytes(), you could have puts delegate to puts_bytes.

♻️ Proposed refactor

 #[cfg(any(unix, windows))]
 fn puts(fd: i32, s: &str) {
-    let _ = unsafe {
-        #[cfg(windows)]
-        {
-            libc::write(fd, s.as_ptr() as *const libc::c_void, s.len() as u32)
-        }
-        #[cfg(not(windows))]
-        {
-            libc::write(fd, s.as_ptr() as *const libc::c_void, s.len())
-        }
-    };
+    puts_bytes(fd, s.as_bytes());
 }

crates/stdlib/src/faulthandler.rs (3)

334-357: Inconsistent thread header output compared to write_thread_id.

dump_traceback_thread_frames manually writes the thread header inline (lines 342-348) instead of reusing write_thread_id. While functionally similar, this duplicates the format logic. Consider extracting a common helper or reusing write_thread_id for consistency.

♻️ Suggested refactor to reuse write_thread_id

The write_thread_id function could be modified to accept a thread_id parameter instead of always using current_thread_id(), then both call sites could use the same function.

 #[cfg(any(unix, windows))]
-fn write_thread_id(fd: i32, is_current: bool) {
+fn write_thread_id(fd: i32, thread_id: u64, is_current: bool) {
     if is_current {
         puts(fd, "Current thread ");
     } else {
         puts(fd, "Thread ");
     }
-    let thread_id = current_thread_id();
     // dump_hexadecimal already writes "0x" prefix
     dump_hexadecimal(fd, thread_id, core::mem::size_of::<usize>() * 2);
     puts(fd, " (most recent call first):\n");
 }

---

866-879: Watchdog thread marks all threads as non-current.

When the watchdog dumps tracebacks, all threads are passed is_current: false (line 872), so none are labeled "Current thread". This may be intentional since the watchdog runs in its own thread, but it differs from CPython's behavior where the thread that triggered the timeout is marked as current.

For the non-threading path (lines 876-879), write_thread_id is called with is_current: false which also seems inconsistent—in a single-threaded build, the main thread should arguably be marked as current.

♻️ Suggested fix for non-threading case

                 #[cfg(not(feature = "threading"))]
                 {
-                    write_thread_id(fd, false);
+                    write_thread_id(fd, true);
                     dump_live_frames(fd);
                 }

---

1051-1085: all_threads flag doesn't dump all threads in signal context.

The faulthandler_user_signal handler checks user.all_threads but only affects the header text (lines 1058-1063). The actual frame dumping via dump_live_frames (line 1066) only dumps the current thread regardless of this flag.

This is likely a deliberate limitation for signal safety (can't safely access other threads' data from a signal handler), but the behavior is inconsistent with what all_threads=True would suggest. Consider adding a comment documenting this limitation, or adjusting the header when all_threads is true to avoid implying all threads will be dumped.

📝 Suggested documentation improvement

     #[cfg(unix)]
     extern "C" fn faulthandler_user_signal(signum: libc::c_int) {
         let user = match user_signals::get_user_signal(signum as usize) {
             Some(u) if u.enabled => u,
             _ => return,
         };
 
-        // Write traceback header based on all_threads setting
+        // Note: In signal context, we can only safely dump the current thread.
+        // The all_threads flag only affects the header format for compatibility.
         if user.all_threads {
             write_thread_id(user.fd, true);
         } else {
             puts(user.fd, "Stack (most recent call first):\n");
         }
 
-        // Dump live frame chain (walks Frame.previous pointers)
+        // Dump current thread's live frame chain only (signal-safe limitation)
         dump_live_frames(user.fd);