Ptrace in receiver (need libunwind bindings)

Author: gyuheon0h

libdd-crashtracker/src/collector/api.rs

@@ -4,13 +4,10 @@
 
 use super::{crash_handler::enable, receiver_manager::Receiver};
 use crate::{
-    clear_spans, clear_traces,
-    collector::crash_handler::register_panic_hook,
-    collector::signal_handler_manager::register_crash_handlers,
-    crash_info::Metadata,
-    reset_counters,
-    shared::configuration::CrashtrackerReceiverConfig,
-    update_config, update_metadata, CrashtrackerConfiguration,
+    clear_spans, clear_traces, collector::crash_handler::register_panic_hook,
+    collector::signal_handler_manager::register_crash_handlers, crash_info::Metadata,
+    reset_counters, shared::configuration::CrashtrackerReceiverConfig, update_config,
+    update_metadata, CrashtrackerConfiguration,
 };
 
 pub static DEFAULT_SYMBOLS: [libc::c_int; 4] =

libdd-crashtracker/src/collector/collector_manager.rs

@@ -57,20 +57,9 @@ impl Collector {
                     tid,
                 );
             }
-            child_pid if child_pid > 0 => {
-                // Parent process; enable ptrace permission for child if multi-thread collection is enabled
-                #[cfg(target_os = "linux")]
-                if config.collect_all_threads() {
-                    // Allow the collector child to ptrace this process for thread context collection
-                    // SAFETY: prctl is async-signal-safe and we're just setting ptrace permissions
-                    unsafe {
-                        libc::prctl(libc::PR_SET_PTRACER, child_pid as libc::c_ulong, 0, 0, 0);
-                    }
-                }
-                Ok(Self {
-                    handle: ProcessHandle::new(receiver.handle.uds_fd, Some(child_pid)),
-                })
-            },
+            child_pid if child_pid > 0 => Ok(Self {
+                handle: ProcessHandle::new(receiver.handle.uds_fd, Some(child_pid)),
+            }),
             code => {
                 // Error
                 Err(CollectorSpawnError::ForkFailed(code))

libdd-crashtracker/src/collector/crash_handler.rs

@@ -303,6 +303,18 @@ fn handle_posix_signal_impl(
 
     let receiver = Receiver::from_crashtracker_config(config)?;
 
+    // Enable ptrace permissions for receiver if multi-thread collection is enabled
+    #[cfg(target_os = "linux")]
+    if config.collect_all_threads() {
+        if let Some(receiver_pid) = receiver.handle.pid {
+            // Allow the receiver to ptrace this process for thread context collection
+            // SAFETY: prctl is async-signal-safe and we're just setting ptrace permissions
+            unsafe {
+                libc::prctl(libc::PR_SET_PTRACER, receiver_pid as libc::c_ulong, 0, 0, 0);
+            }
+        }
+    }
+
     let collector = Collector::spawn(
         &receiver,
         config,

libdd-crashtracker/src/collector/emitters.rs

@@ -127,12 +127,6 @@ pub(crate) fn emit_crashreport(
         }
     }
 
-    // Emit other threads (Phase 1: name/state; Phase 2: also stack if context available).
-    #[cfg(target_os = "linux")]
-    if config.collect_all_threads() {
-        let _ = emit_all_threads(pipe, config, ppid, crashing_tid);
-    }
-
     writeln!(pipe, "{DD_CRASHTRACK_DONE}")?;
     pipe.flush()?;
     Ok(())
@@ -486,134 +480,6 @@ fn emit_thread_block(
     Ok(())
 }
 
-/// Read a thread's name from /proc/<pid>/task/<tid>/comm.
-#[cfg(target_os = "linux")]
-fn read_thread_name(pid: libc::pid_t, tid: libc::pid_t) -> Option<String> {
-    let path = format!("/proc/{pid}/task/{tid}/comm");
-    std::fs::read_to_string(path)
-        .ok()
-        .map(|s| s.trim_end_matches('\n').to_string())
-}
-
-/// Read a thread's scheduler state letter from /proc/<pid>/task/<tid>/status.
-/// Returns the single-letter state ("S", "R", "D") or None on failure.
-#[cfg(target_os = "linux")]
-fn read_thread_state(pid: libc::pid_t, tid: libc::pid_t) -> Option<String> {
-    let path = format!("/proc/{pid}/task/{tid}/status");
-    let file = std::fs::File::open(path).ok()?;
-    let reader = std::io::BufReader::new(file);
-    for line in reader.lines() {
-        let line = line.ok()?;
-        if let Some(rest) = line.strip_prefix("State:") {
-            return Some(rest.trim().to_string());
-        }
-    }
-    None
-}
-
-/// Enumerate all live thread IDs under /proc/<pid>/task/ using std::fs (safe to
-/// call from the collector child, where there are no async-signal-safety constraints).
-#[cfg(target_os = "linux")]
-fn enumerate_task_tids(pid: libc::pid_t) -> Vec<libc::pid_t> {
-    let path = format!("/proc/{pid}/task");
-    let Ok(entries) = std::fs::read_dir(&path) else {
-        return vec![];
-    };
-    entries
-        .filter_map(|e| e.ok())
-        .filter_map(|e| {
-            e.file_name()
-                .to_str()
-                .and_then(|s| s.parse::<libc::pid_t>().ok())
-        })
-        .collect()
-}
-
-/// Emit thread blocks for all threads other than the crashing thread.
-///
-/// Called from the collector child (after fork), so std::fs and ptrace are safe to use.
-/// Uses a streaming approach to avoid allocating vectors or hashmaps.
-/// For each thread:
-///   - Uses ptrace to capture thread context (registers + stack)
-///   - Reads name and state from /proc/<ppid>/task/<tid>/
-///   - Immediately emits the thread block without intermediate storage
-#[cfg(target_os = "linux")]
-fn emit_all_threads(
-    w: &mut impl Write,
-    config: &CrashtrackerConfiguration,
-    ppid: libc::pid_t,
-    crashing_tid: libc::pid_t,
-) -> Result<(), EmitterError> {
-    use crate::collector::ptrace_collector::stream_thread_contexts;
-    use std::time::Duration;
-
-    // Calculate timeout for ptrace operations
-    let context_timeout = Duration::from_millis((config.timeout().as_millis() / 2).min(200) as u64);
-
-    let result = stream_thread_contexts(
-        ppid,
-        crashing_tid,
-        config.max_threads(),
-        context_timeout,
-        |tid, captured_context| {
-            // Read thread metadata from /proc
-            let name = read_thread_name(ppid, tid).unwrap_or_else(|| tid.to_string());
-            let state = read_thread_state(ppid, tid);
-
-            // Get ucontext pointer if we captured context for this thread
-            let ucontext = captured_context.map(|ctx| &ctx.ucontext as *const _);
-
-            // Immediately emit the thread block
-            match emit_thread_block(
-                w,
-                tid,
-                false,
-                &name,
-                state.as_deref(),
-                config.resolve_frames(),
-                ucontext,
-            ) {
-                Ok(()) => true,  // Continue with next thread
-                Err(_) => false, // Stop iteration on write error
-            }
-        },
-    );
-
-    // Handle the case where ptrace setup fails entirely
-    if result.is_err() {
-        // Fall back to thread enumeration without context capture
-        // This provides basic thread information even when ptrace fails
-        let tids = enumerate_task_tids(ppid);
-        let max = config.max_threads();
-        let mut emitted = 0;
-
-        for tid in tids {
-            if tid == crashing_tid {
-                continue;
-            }
-            if emitted >= max {
-                break;
-            }
-
-            let name = read_thread_name(ppid, tid).unwrap_or_else(|| tid.to_string());
-            let state = read_thread_state(ppid, tid);
-
-            emit_thread_block(
-                w,
-                tid,
-                false,
-                &name,
-                state.as_deref(),
-                config.resolve_frames(),
-                None, // No context available
-            )?;
-            emitted += 1;
-        }
-    }
-
-    Ok(())
-}
-
 fn emit_config(w: &mut impl Write, config_str: &str) -> Result<(), EmitterError> {
     writeln!(w, "{DD_CRASHTRACK_BEGIN_CONFIG}")?;
     writeln!(w, "{config_str}")?;

libdd-crashtracker/src/collector/mod.rs

@@ -13,8 +13,6 @@ mod receiver_manager;
 mod saguard;
 mod signal_handler_manager;
 mod spans;
-#[cfg(target_os = "linux")]
-pub(crate) mod ptrace_collector;
 
 pub use additional_tags::{
     clear_additional_tags, consume_and_emit_additional_tags, insert_additional_tag,

libdd-crashtracker/src/receiver/mod.rs

@@ -7,6 +7,8 @@ pub use entry_points::{
     async_receiver_entry_point_unix_listener, async_receiver_entry_point_unix_socket,
     get_receiver_unix_socket, receiver_entry_point_stdin, receiver_entry_point_unix_socket,
 };
+#[cfg(target_os = "linux")]
+mod ptrace_collector;
 mod receive_report;
 
 #[cfg(feature = "benchmarking")]

…racker/src/collector/ptrace_collector.rs …tracker/src/receiver/ptrace_collector.rslibdd-crashtracker/src/collector/ptrace_collector.rs renamed to libdd-crashtracker/src/receiver/ptrace_collector.rs libdd-crashtracker/src/collector/ptrace_collector.rs renamed to libdd-crashtracker/src/receiver/ptrace_collector.rs

@@ -32,8 +32,12 @@ use std::time::{Duration, Instant};
 /// Maximum number of threads to collect contexts for
 const MAX_TRACKED_THREADS: usize = 128;
 
-
-/// A captured thread context containing register state
+/// A captured thread context containing basic register state
+///
+/// TODO: Add remote libunwind stack walking using:
+/// - unw_init_remote() with _UPT_accessors for ptrace-based remote unwinding
+/// - _UPT_create(), _UPT_destroy() for managing ptrace state
+/// - This will enable full stack traces for all threads
 pub struct CapturedThreadContext {
     /// The captured register context as a ucontext_t
     pub ucontext: ucontext_t,
@@ -60,7 +64,11 @@ impl std::fmt::Display for PtraceError {
                 write!(f, "Failed to attach to thread {}: errno {}", tid, errno)
             }
             PtraceError::RegisterReadFailed(tid, errno) => {
-                write!(f, "Failed to read registers from thread {}: errno {}", tid, errno)
+                write!(
+                    f,
+                    "Failed to read registers from thread {}: errno {}",
+                    tid, errno
+                )
             }
             PtraceError::DetachFailed(tid, errno) => {
                 write!(f, "Failed to detach from thread {}: errno {}", tid, errno)
@@ -77,8 +85,7 @@ impl std::error::Error for PtraceError {}
 /// Returns a vector of thread IDs.
 pub fn enumerate_threads(pid: libc::pid_t) -> Result<Vec<libc::pid_t>, PtraceError> {
     let task_dir = format!("/proc/{}/task", pid);
-    let entries = std::fs::read_dir(&task_dir)
-        .map_err(PtraceError::EnumerationFailed)?;
+    let entries = std::fs::read_dir(&task_dir).map_err(PtraceError::EnumerationFailed)?;
 
     let mut tids = Vec::new();
     for entry in entries {
@@ -215,13 +222,15 @@ pub fn read_thread_registers(tid: libc::pid_t) -> Result<ucontext_t, PtraceError
     Ok(uctx)
 }
 
-
 /// Capture register context for a single thread
-pub fn capture_thread_context(_pid: libc::pid_t, tid: libc::pid_t) -> Result<CapturedThreadContext, PtraceError> {
+pub fn capture_thread_context(
+    _pid: libc::pid_t,
+    tid: libc::pid_t,
+) -> Result<CapturedThreadContext, PtraceError> {
     // Attach to the thread
     attach_thread(tid)?;
 
-    // Read registers
+    // Read basic registers
     let ucontext = match read_thread_registers(tid) {
         Ok(uctx) => uctx,
         Err(e) => {
@@ -231,7 +240,7 @@ pub fn capture_thread_context(_pid: libc::pid_t, tid: libc::pid_t) -> Result<Cap
     };
 
     // Detach from the thread
-    // detach_thread(tid)?;
+    detach_thread(tid)?;
 
     Ok(CapturedThreadContext { ucontext })
 }
@@ -249,7 +258,8 @@ pub fn stream_thread_contexts<F>(
     mut callback: F,
 ) -> Result<(), PtraceError>
 where
-    F: FnMut(libc::pid_t, Option<&CapturedThreadContext>) -> bool, // returns false to stop iteration
+    F: FnMut(libc::pid_t, Option<&CapturedThreadContext>) -> bool, /* returns false to stop
+                                                                    * iteration */
 {
     let start_time = Instant::now();
 
@@ -293,4 +303,3 @@ where
 
     Ok(())
 }
-