fix(stat): use USR1 for termination

Author: Alonely0

src/uu/timeout/src/timeout.rs

@@ -20,7 +20,10 @@ use uucore::process::{ChildExt, CommandExt, SelfPipe, WaitOrTimeoutRet};
 use uucore::translate;
 
 #[cfg(unix)]
-use uucore::signals::{enable_pipe_errors, is_ignored};
+use ::{
+    nix::sys::signal::{SigSet, SigmaskHow, pthread_sigmask},
+    uucore::signals::{enable_pipe_errors, is_ignored},
+};
 
 use uucore::{
     format_usage, show_error,
@@ -233,7 +236,7 @@ fn wait_or_kill_process(
     self_pipe: &mut SelfPipe,
 ) -> std::io::Result<i32> {
     // ignore `SIGTERM` here
-    self_pipe.unset_other()?;
+    self_pipe.unset_other(Signal::SIGTERM)?;
 
     match process.wait_or_timeout(duration, self_pipe) {
         Ok(WaitOrTimeoutRet::InTime(status)) => {
@@ -250,7 +253,8 @@ fn wait_or_kill_process(
             process.wait()?;
             Ok(ExitStatus::SignalSent(signal).into())
         }
-        Ok(WaitOrTimeoutRet::CustomSignaled) | Err(_) => Ok(ExitStatus::TimeoutFailed.into()),
+        Ok(WaitOrTimeoutRet::CustomSignaled(n)) => Ok(ExitStatus::SignalSent(n as _).into()),
+        Err(_) => Ok(ExitStatus::TimeoutFailed.into()),
     }
 }
 
@@ -334,7 +338,10 @@ fn timeout(
         .stderr(Stdio::inherit());
     #[cfg(unix)]
     block_ignored_signals()?;
-    let mut self_pipe = command.set_up_timeout(Some(Signal::SIGTERM))?;
+    let mut set = SigSet::empty();
+    set.add(Signal::SIGTERM);
+    set.add(Signal::SIGUSR1);
+    let mut self_pipe = command.set_up_timeout(set)?;
     let process = &mut command.spawn().map_err(|err| {
         let status_code = match err.kind() {
             ErrorKind::NotFound => ExitStatus::CommandNotFound.into(),
@@ -356,11 +363,15 @@ fn timeout(
             .code()
             .unwrap_or_else(|| preserve_signal_info(status.signal().unwrap()))
             .into()),
-        Ok(WaitOrTimeoutRet::CustomSignaled) => {
+        Ok(WaitOrTimeoutRet::CustomSignaled(n)) => {
             report_if_verbose(signal, &cmd[0], verbose);
             send_signal(process, signal, foreground);
             process.wait()?;
-            Err(ExitStatus::Terminated.into())
+            if n == Signal::SIGTERM as i32 {
+                Err(ExitStatus::Terminated.into())
+            } else {
+                Err(ExitStatus::SignalSent(n as _).into())
+            }
         }
         Ok(WaitOrTimeoutRet::TimedOut) => {
             report_if_verbose(signal, &cmd[0], verbose);

src/uucore/src/lib/features/process.rs

@@ -16,7 +16,7 @@ use crate::pipes::pipe;
 use ::{
     nix::sys::select::FdSet,
     nix::sys::select::select,
-    nix::sys::signal::{self, signal},
+    nix::sys::signal::{SaFlags, SigAction, SigHandler, SigSet, sigaction},
     nix::sys::time::TimeVal,
     std::fs::File,
     std::io::{Read, Write},
@@ -126,19 +126,19 @@ pub trait ChildExt {
 }
 
 #[cfg(feature = "pipes")]
-pub struct SelfPipe(File, Option<Signal>, PhantomData<*mut ()>);
+pub struct SelfPipe(File, SigSet, PhantomData<*mut ()>);
 
 #[cfg(feature = "pipes")]
 pub trait CommandExt {
-    fn set_up_timeout(&mut self, other: Option<Signal>) -> io::Result<SelfPipe>;
+    fn set_up_timeout(&mut self, others: SigSet) -> io::Result<SelfPipe>;
 }
 
 /// Concise enum of [`ChildExt::wait_or_timeout`] possible returns.
 #[derive(Debug)]
 #[cfg(feature = "pipes")]
 pub enum WaitOrTimeoutRet {
     InTime(ExitStatus),
-    CustomSignaled,
+    CustomSignaled(i32),
     TimedOut,
 }
 
@@ -197,24 +197,24 @@ impl ChildExt for Child {
                     // if empty, we'd stall on the read. However, this may
                     // happen spuriously, so we try to select again.
                     if fd_set.contains(self_pipe.0.as_fd()) {
-                        let mut buf = [0];
+                        let mut buf = [0; std::mem::size_of::<Signal>()];
                         self_pipe.0.read_exact(&mut buf)?;
-                        return match buf[0] {
+                        let sig = i32::from_ne_bytes(buf);
+                        return match sig {
                             // SIGCHLD
-                            1 => match self.try_wait()? {
+                            libc::SIGCHLD => match self.try_wait()? {
                                 Some(e) => Ok(WaitOrTimeoutRet::InTime(e)),
                                 None => Ok(WaitOrTimeoutRet::InTime(ExitStatus::default())),
                             },
                             // Received SIGALRM externally, for compat with
                             // GNU timeout we act as if it had timed out.
-                            2 => Ok(WaitOrTimeoutRet::TimedOut),
+                            libc::SIGALRM => Ok(WaitOrTimeoutRet::TimedOut),
                             // Custom signals on zero timeout still succeed.
-                            3 if timeout.is_zero() => {
+                            _ if timeout.is_zero() => {
                                 Ok(WaitOrTimeoutRet::InTime(ExitStatus::default()))
                             }
                             // We received a custom signal and fail.
-                            3 => Ok(WaitOrTimeoutRet::CustomSignaled),
-                            _ => unreachable!(),
+                            x => Ok(WaitOrTimeoutRet::CustomSignaled(x)),
                         };
                     }
                 }
@@ -250,7 +250,7 @@ fn duration_to_timeval_elapsed(time: Duration, start: Instant) -> Option<TimeVal
 
 #[cfg(feature = "pipes")]
 impl CommandExt for Command {
-    fn set_up_timeout(&mut self, other: Option<Signal>) -> io::Result<SelfPipe> {
+    fn set_up_timeout(&mut self, others: SigSet) -> io::Result<SelfPipe> {
         static SELF_PIPE_W: Mutex<Option<File>> = Mutex::new(None);
         let (r, w) = pipe()?;
         *SELF_PIPE_W.lock().unwrap() = Some(w);
@@ -259,31 +259,33 @@ impl CommandExt for Command {
             let Ok(&mut Some(ref mut writer)) = lock.as_deref_mut() else {
                 return;
             };
-            if signal == Signal::SIGCHLD as c_int {
-                let _ = writer.write(&[1]);
-            } else if signal == Signal::SIGALRM as c_int {
-                let _ = writer.write(&[2]);
-            } else {
-                let _ = writer.write(&[3]);
-            }
+            let _ = writer.write(&signal.to_ne_bytes());
         }
+        let action = SigAction::new(
+            SigHandler::Handler(sig_handler),
+            SaFlags::SA_NOCLDSTOP,
+            SigSet::all(),
+        );
         unsafe {
-            signal(Signal::SIGCHLD, signal::SigHandler::Handler(sig_handler))?;
-            signal(Signal::SIGALRM, signal::SigHandler::Handler(sig_handler))?;
-            if let Some(other) = other {
-                signal(other, signal::SigHandler::Handler(sig_handler))?;
+            sigaction(Signal::SIGCHLD, &action)?;
+            sigaction(Signal::SIGALRM, &action)?;
+            for signal in &others {
+                sigaction(signal, &action)?;
             }
         };
-        Ok(SelfPipe(r, other, PhantomData))
+        Ok(SelfPipe(r, others, PhantomData))
     }
 }
 
 #[cfg(feature = "pipes")]
 impl SelfPipe {
-    pub fn unset_other(&self) -> io::Result<()> {
-        if let Some(other) = self.1 {
+    pub fn unset_other(&self, signal: Signal) -> io::Result<()> {
+        if self.1.contains(signal) {
             unsafe {
-                signal(other, signal::SigHandler::SigDfl)?;
+                sigaction(
+                    signal,
+                    &SigAction::new(SigHandler::SigDfl, SaFlags::empty(), SigSet::empty()),
+                )?;
             }
         }
         Ok(())
@@ -293,8 +295,11 @@ impl SelfPipe {
 #[cfg(feature = "pipes")]
 impl Drop for SelfPipe {
     fn drop(&mut self) {
-        let _ = unsafe { signal(Signal::SIGCHLD, signal::SigHandler::SigDfl) };
-        let _ = self.unset_other();
+        let action = SigAction::new(SigHandler::SigDfl, SaFlags::empty(), SigSet::empty());
+        let _ = unsafe { sigaction(Signal::SIGCHLD, &action) };
+        for signal in &self.1 {
+            let _ = unsafe { sigaction(signal, &action) };
+        }
     }
 }