Add SIGPIPE debugging logs and remove stderr checks from tests

Author: ChrisDryden

src/uu/dd/src/dd.rs

@@ -1116,6 +1116,10 @@ fn flush_caches_full_length(i: &Input, o: &Output) -> io::Result<()> {
 /// If there is a problem reading from the input or writing to
 /// this output.
 fn dd_copy(mut i: Input, o: Output) -> io::Result<()> {
+    eprintln!("[DD-DEBUG] dd_copy() starting");
+    #[cfg(unix)]
+    uucore::signals::debug_sigpipe_disposition("dd_copy start");
+
     // The read and write statistics.
     //
     // These objects are counters, initialized to zero. After each
@@ -1188,13 +1192,17 @@ fn dd_copy(mut i: Input, o: Output) -> io::Result<()> {
     // The signal handler spawns an own thread that waits for signals.
     // When the signal is received, it calls a handler function.
     // We inject a handler function that manually triggers the alarm.
+    eprintln!("[DD-DEBUG] About to create SignalHandler");
     #[cfg(target_os = "linux")]
     let signal_handler = progress::SignalHandler::install_signal_handler(alarm.manual_trigger_fn());
     #[cfg(target_os = "linux")]
     if let Err(e) = &signal_handler {
+        eprintln!("[DD-DEBUG] SignalHandler creation failed: {e}");
         if Some(StatusLevel::None) != i.settings.status {
             eprintln!("{}\n\t{e}", translate!("dd-warning-signal-handler"));
         }
+    } else {
+        eprintln!("[DD-DEBUG] SignalHandler created successfully");
     }
 
     // Index in the input file where we are reading bytes and in
@@ -1286,6 +1294,10 @@ fn dd_copy(mut i: Input, o: Output) -> io::Result<()> {
         }
     }
 
+    eprintln!("[DD-DEBUG] Main loop complete, about to call finalize()");
+    #[cfg(unix)]
+    uucore::signals::debug_sigpipe_disposition("dd_copy before finalize");
+
     finalize(o, rstat, wstat, start, &prog_tx, output_thread, truncate)
 }
 
@@ -1299,27 +1311,41 @@ fn finalize<T>(
     output_thread: thread::JoinHandle<T>,
     truncate: bool,
 ) -> io::Result<()> {
+    eprintln!("[DD-DEBUG] finalize() starting");
+
     // Flush the output in case a partial write has been buffered but
     // not yet written.
+    eprintln!("[DD-DEBUG] finalize() - flushing output");
     let wstat_update = output.flush()?;
 
     // Sync the output, if configured to do so.
+    eprintln!("[DD-DEBUG] finalize() - syncing output");
     output.sync()?;
 
     // Truncate the file to the final cursor location.
     if truncate {
+        eprintln!("[DD-DEBUG] finalize() - truncating");
         output.truncate();
     }
 
     // Print the final read/write statistics.
+    eprintln!("[DD-DEBUG] finalize() - sending final stats to progress thread");
     let wstat = wstat + wstat_update;
     let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), ProgUpdateType::Final);
     prog_tx.send(prog_update).unwrap_or(());
+
     // Wait for the output thread to finish
+    eprintln!("[DD-DEBUG] finalize() - joining output thread");
     output_thread
         .join()
         .expect("Failed to join with the output thread.");
 
+    eprintln!(
+        "[DD-DEBUG] finalize() - complete, about to return (SignalHandler will be dropped after this)"
+    );
+    #[cfg(unix)]
+    uucore::signals::debug_sigpipe_disposition("finalize before return");
+
     Ok(())
 }
 

src/uu/dd/src/progress.rs

@@ -463,15 +463,26 @@ impl SignalHandler {
         use signal_hook::consts::signal::*;
         use signal_hook::iterator::Signals;
 
+        eprintln!("[DD-DEBUG] SignalHandler::install_signal_handler() - creating signal_hook pipe");
+        uucore::signals::debug_sigpipe_disposition("SignalHandler::install before Signals::new");
+
         let mut signals = Signals::new([SIGUSR1])?;
         let handle = signals.handle();
+
+        eprintln!(
+            "[DD-DEBUG] SignalHandler::install_signal_handler() - signal_hook pipe created successfully"
+        );
+        uucore::signals::debug_sigpipe_disposition("SignalHandler::install after Signals::new");
+
         let thread = std::thread::spawn(move || {
+            eprintln!("[DD-DEBUG] SignalHandler signal thread started");
             for signal in &mut signals {
                 match signal {
                     SIGUSR1 => (*f)(),
                     _ => unreachable!(),
                 }
             }
+            eprintln!("[DD-DEBUG] SignalHandler signal thread exiting");
         });
 
         Ok(Self {
@@ -484,10 +495,19 @@ impl SignalHandler {
 #[cfg(target_os = "linux")]
 impl Drop for SignalHandler {
     fn drop(&mut self) {
+        eprintln!("[DD-DEBUG] SignalHandler::drop() - about to close handle");
+        uucore::signals::debug_sigpipe_disposition("SignalHandler::drop before handle.close");
+
         self.handle.close();
+
+        eprintln!("[DD-DEBUG] SignalHandler::drop() - handle closed, joining thread");
+        uucore::signals::debug_sigpipe_disposition("SignalHandler::drop after handle.close");
+
         if let Some(thread) = std::mem::take(&mut self.thread) {
             thread.join().unwrap();
         }
+
+        eprintln!("[DD-DEBUG] SignalHandler::drop() - complete");
     }
 }
 

src/uucore/src/lib/features/signals.rs

@@ -413,16 +413,20 @@ pub fn signal_name_by_value(signal_value: usize) -> Option<&'static str> {
 /// Restores SIGPIPE to default behavior (process terminates on broken pipe).
 #[cfg(unix)]
 pub fn enable_pipe_errors() -> Result<(), Errno> {
+    eprintln!("[SIGPIPE-DEBUG] enable_pipe_errors() called - setting SIGPIPE to SIG_DFL");
     // We pass the error as is, the return value would just be Ok(SigDfl), so we can safely ignore it.
     // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
-    unsafe { signal(SIGPIPE, SigDfl) }.map(|_| ())
+    let result = unsafe { signal(SIGPIPE, SigDfl) }.map(|_| ());
+    eprintln!("[SIGPIPE-DEBUG] enable_pipe_errors() result: {:?}", result);
+    result
 }
 
 /// Ignores SIGPIPE signal (broken pipe errors are returned instead of terminating).
 /// Use this to override the default SIGPIPE handling when you need to handle
 /// broken pipe errors gracefully (e.g., tee with --output-error).
 #[cfg(unix)]
 pub fn disable_pipe_errors() -> Result<(), Errno> {
+    eprintln!("[SIGPIPE-DEBUG] disable_pipe_errors() called - setting SIGPIPE to SIG_IGN");
     // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
     unsafe { signal(SIGPIPE, SigIgn) }.map(|_| ())
 }
@@ -545,14 +549,51 @@ pub const fn stderr_was_closed() -> bool {
 /// Returns whether SIGPIPE was ignored at process startup.
 #[cfg(unix)]
 pub fn sigpipe_was_ignored() -> bool {
-    SIGPIPE_WAS_IGNORED.load(Ordering::Acquire)
+    let was_ignored = SIGPIPE_WAS_IGNORED.load(Ordering::Acquire);
+    eprintln!(
+        "[SIGPIPE-DEBUG] sigpipe_was_ignored() returning: {}",
+        was_ignored
+    );
+    was_ignored
 }
 
 #[cfg(not(unix))]
 pub const fn sigpipe_was_ignored() -> bool {
     false
 }
 
+/// Debug function: query and log current SIGPIPE disposition
+#[cfg(unix)]
+pub fn debug_sigpipe_disposition(context: &str) {
+    use nix::libc;
+    use std::mem::MaybeUninit;
+    use std::ptr;
+
+    let mut current = MaybeUninit::<libc::sigaction>::uninit();
+    if unsafe { libc::sigaction(libc::SIGPIPE, ptr::null(), current.as_mut_ptr()) } == 0 {
+        let action = unsafe { current.assume_init() };
+        let disposition = if action.sa_sigaction == libc::SIG_IGN {
+            "SIG_IGN (ignored)"
+        } else if action.sa_sigaction == libc::SIG_DFL {
+            "SIG_DFL (default - will terminate on SIGPIPE)"
+        } else {
+            "custom handler"
+        };
+        eprintln!(
+            "[SIGPIPE-DEBUG] {} - current SIGPIPE disposition: {}",
+            context, disposition
+        );
+    } else {
+        eprintln!(
+            "[SIGPIPE-DEBUG] {} - failed to query SIGPIPE disposition",
+            context
+        );
+    }
+}
+
+#[cfg(not(unix))]
+pub fn debug_sigpipe_disposition(_context: &str) {}
+
 #[cfg(target_os = "linux")]
 pub fn ensure_stdout_not_broken() -> std::io::Result<bool> {
     use nix::{