Ptrace in collector child

Author: gyuheon0h

libdd-crashtracker/src/collector/api.rs

@@ -6,9 +6,7 @@ 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, register_thread_context_signal_handler,
-    },
+    collector::signal_handler_manager::register_crash_handlers,
     crash_info::Metadata,
     reset_counters,
     shared::configuration::CrashtrackerReceiverConfig,
@@ -65,10 +63,6 @@ pub fn on_fork(
 
     // panic hook is unaffected by fork.
 
-    // Reset the thread context buffer so the forked child starts clean.
-    #[cfg(target_os = "linux")]
-    crate::collector::thread_context_buffer::reset_thread_context_buffer();
-
     update_metadata(metadata)?;
     update_config(config)?;
     Receiver::update_stored_config(receiver_config)?;
@@ -95,11 +89,6 @@ pub fn init(
     Receiver::update_stored_config(receiver_config)?;
     register_crash_handlers(&config)?;
     register_panic_hook()?;
-    if config.collect_all_threads() {
-        #[cfg(target_os = "linux")]
-        crate::collector::thread_context_buffer::init_thread_context_buffer(config.max_threads());
-        register_thread_context_signal_handler()?;
-    }
     enable();
     Ok(())
 }

libdd-crashtracker/src/collector/collector_manager.rs

@@ -57,9 +57,20 @@ impl Collector {
                     tid,
                 );
             }
-            pid if pid > 0 => Ok(Self {
-                handle: ProcessHandle::new(receiver.handle.uds_fd, Some(pid)),
-            }),
+            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)),
+                })
+            },
             code => {
                 // Error
                 Err(CollectorSpawnError::ForkFailed(code))

libdd-crashtracker/src/collector/crash_handler.rs

@@ -301,19 +301,6 @@ fn handle_posix_signal_impl(
 
     let timeout_manager = TimeoutManager::new(config.timeout());
 
-    // Phase 2: collect ucontexts from all other threads before forking, so the
-    // collector child can unwind their stacks.
-    #[cfg(target_os = "linux")]
-    if config.collect_all_threads() {
-        use super::thread_context_buffer::collect_thread_contexts;
-        // Timeout for context collection: half of the overall crash timeout, capped
-        // at 200ms to avoid delaying the crash report excessively.
-        let context_timeout_ms = (config.timeout().as_millis() / 2).min(200) as u64;
-        // SAFETY: current_tid() is the TID of the crashing thread -- we skip it.
-        let crashing_tid = unsafe { libc::syscall(libc::SYS_gettid) as libc::pid_t };
-        collect_thread_contexts(crashing_tid, config.max_threads(), context_timeout_ms);
-    }
-
     let receiver = Receiver::from_crashtracker_config(config)?;
 
     let collector = Collector::spawn(

libdd-crashtracker/src/collector/emitters.rs

@@ -531,53 +531,84 @@ fn enumerate_task_tids(pid: libc::pid_t) -> Vec<libc::pid_t> {
 
 /// Emit thread blocks for all threads other than the crashing thread.
 ///
-/// Called from the collector child (after fork), so std::fs is safe to use.
+/// 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>/
-///   - If a ucontext was captured (collect_all_threads), emits the stack trace.
-///   - Otherwise emits an empty (incomplete) stack trace.
+///   - 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::thread_context_buffer::iter_collected_contexts;
-
-    // Build a map from TID to captured ucontext pointer (may be empty if buffer
-    // was not initialised or the thread did not respond in time).
-    let contexts: std::collections::HashMap<libc::pid_t, *const ucontext_t> =
-        iter_collected_contexts()
-            .map(|c| (c.tid, c.ucontext))
-            .collect();
-
-    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;
-        }
+    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);
-        let ucontext = contexts.get(&tid).copied();
-
-        emit_thread_block(
-            w,
-            tid,
-            false,
-            &name,
-            state.as_deref(),
-            config.resolve_frames(),
-            ucontext,
-        )?;
-        emitted += 1;
+            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(())

libdd-crashtracker/src/collector/mod.rs

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