Use i32 for exit statuses too. (#1384)

* Use `i32` for exit statuses too.

Following up on #1378, make process exit statuses be `i32` too, for
compatibility with `exit`, `exit_group`, and related things.

* Add a comment about why some features are disabled on NetBSD.

Author: sunfishcode

CHANGES.md

@@ -35,11 +35,12 @@ the functions in the [`rustix::thread::futex`] module instead.
 
 [`terminating_signal`] and other functions in [`rustix::process::WaitStatus`] changed
 from returning `u32` to returning `i32`, for better compatibility with the new
-[`Signal`] type.
+[`Signal`] type and [`exit`].
 
 [`terminating_signal`]: https://docs.rs/rustix/1.0.0/rustix/process/struct.WaitStatus.html#method.terminating_signal
 [`rustix::process::WaitStatus`]: https://docs.rs/rustix/1.0.0/rustix/process/struct.WaitStatus.html
 [`Signal`]: https://docs.rs/rustix/1.0.0/rustix/process/struct.Signal.html
+[`exit`]: std::process::exit
 
 The `SLAVE` flag in [`rustix::mount::MountPropagationFlags`] is renamed to
 [`DOWNSTREAM`].

src/backend/linux_raw/process/syscalls.rs

@@ -298,7 +298,7 @@ pub(crate) fn _waitpid(
     waitopts: WaitOptions,
 ) -> io::Result<Option<(Pid, WaitStatus)>> {
     unsafe {
-        let mut status = MaybeUninit::<u32>::uninit();
+        let mut status = MaybeUninit::<i32>::uninit();
         let pid = ret_c_int(syscall!(
             __NR_wait4,
             c_int(pid as _),

src/backend/linux_raw/process/wait.rs

@@ -7,37 +7,37 @@ pub(crate) use linux_raw_sys::general::{
 };
 
 #[inline]
-pub(crate) fn WIFSTOPPED(status: u32) -> bool {
+pub(crate) fn WIFSTOPPED(status: i32) -> bool {
     (status & 0xff) == 0x7f
 }
 
 #[inline]
-pub(crate) fn WSTOPSIG(status: u32) -> u32 {
+pub(crate) fn WSTOPSIG(status: i32) -> i32 {
     (status >> 8) & 0xff
 }
 
 #[inline]
-pub(crate) fn WIFCONTINUED(status: u32) -> bool {
+pub(crate) fn WIFCONTINUED(status: i32) -> bool {
     status == 0xffff
 }
 
 #[inline]
-pub(crate) fn WIFSIGNALED(status: u32) -> bool {
+pub(crate) fn WIFSIGNALED(status: i32) -> bool {
     ((status & 0x7f) + 1) as i8 >= 2
 }
 
 #[inline]
-pub(crate) fn WTERMSIG(status: u32) -> u32 {
+pub(crate) fn WTERMSIG(status: i32) -> i32 {
     status & 0x7f
 }
 
 #[inline]
-pub(crate) fn WIFEXITED(status: u32) -> bool {
+pub(crate) fn WIFEXITED(status: i32) -> bool {
     (status & 0x7f) == 0
 }
 
 #[inline]
-pub(crate) fn WEXITSTATUS(status: u32) -> u32 {
+pub(crate) fn WEXITSTATUS(status: i32) -> i32 {
     (status >> 8) & 0xff
 }
 
@@ -107,15 +107,17 @@ mod tests {
             4095,
             4096,
             4097,
-            u32::MAX,
+            i32::MAX,
+            i32::MIN,
+            u32::MAX as i32,
         ] {
-            assert_eq!(WIFSTOPPED(status), libc::WIFSTOPPED(status as i32));
-            assert_eq!(WSTOPSIG(status), libc::WSTOPSIG(status as i32) as u32);
-            assert_eq!(WIFCONTINUED(status), libc::WIFCONTINUED(status as i32));
-            assert_eq!(WIFSIGNALED(status), libc::WIFSIGNALED(status as i32));
-            assert_eq!(WTERMSIG(status), libc::WTERMSIG(status as i32) as u32);
-            assert_eq!(WIFEXITED(status), libc::WIFEXITED(status as i32));
-            assert_eq!(WEXITSTATUS(status), libc::WEXITSTATUS(status as i32) as u32);
+            assert_eq!(WIFSTOPPED(status), libc::WIFSTOPPED(status));
+            assert_eq!(WSTOPSIG(status), libc::WSTOPSIG(status));
+            assert_eq!(WIFCONTINUED(status), libc::WIFCONTINUED(status));
+            assert_eq!(WIFSIGNALED(status), libc::WIFSIGNALED(status));
+            assert_eq!(WTERMSIG(status), libc::WTERMSIG(status));
+            assert_eq!(WIFEXITED(status), libc::WIFEXITED(status));
+            assert_eq!(WEXITSTATUS(status), libc::WEXITSTATUS(status));
         }
     }
 }

src/process/wait.rs

@@ -9,6 +9,7 @@
 use crate::process::Pid;
 use crate::{backend, io};
 use bitflags::bitflags;
+use core::fmt;
 
 #[cfg(target_os = "linux")]
 use crate::fd::BorrowedFd;
@@ -73,51 +74,51 @@ bitflags! {
 /// The status of a child process after calling [`wait`]/[`waitpid`].
 #[derive(Debug, Clone, Copy)]
 #[repr(transparent)]
-pub struct WaitStatus(u32);
+pub struct WaitStatus(i32);
 
 impl WaitStatus {
     /// Creates a `WaitStatus` out of an integer.
     #[inline]
-    pub(crate) fn new(status: u32) -> Self {
+    pub(crate) fn new(status: i32) -> Self {
         Self(status)
     }
 
     /// Converts a `WaitStatus` into its raw representation as an integer.
     #[inline]
-    pub const fn as_raw(self) -> u32 {
+    pub const fn as_raw(self) -> i32 {
         self.0
     }
 
     /// Returns whether the process is currently stopped.
     #[inline]
     pub fn stopped(self) -> bool {
-        backend::process::wait::WIFSTOPPED(self.0 as _)
+        backend::process::wait::WIFSTOPPED(self.0)
     }
 
     /// Returns whether the process has exited normally.
     #[inline]
     pub fn exited(self) -> bool {
-        backend::process::wait::WIFEXITED(self.0 as _)
+        backend::process::wait::WIFEXITED(self.0)
     }
 
     /// Returns whether the process was terminated by a signal.
     #[inline]
     pub fn signaled(self) -> bool {
-        backend::process::wait::WIFSIGNALED(self.0 as _)
+        backend::process::wait::WIFSIGNALED(self.0)
     }
 
     /// Returns whether the process has continued from a job control stop.
     #[inline]
     pub fn continued(self) -> bool {
-        backend::process::wait::WIFCONTINUED(self.0 as _)
+        backend::process::wait::WIFCONTINUED(self.0)
     }
 
     /// Returns the number of the signal that stopped the process, if the
     /// process was stopped by a signal.
     #[inline]
     pub fn stopping_signal(self) -> Option<i32> {
         if self.stopped() {
-            Some(backend::process::wait::WSTOPSIG(self.0 as _) as _)
+            Some(backend::process::wait::WSTOPSIG(self.0))
         } else {
             None
         }
@@ -126,9 +127,9 @@ impl WaitStatus {
     /// Returns the exit status number returned by the process, if it exited
     /// normally.
     #[inline]
-    pub fn exit_status(self) -> Option<u32> {
+    pub fn exit_status(self) -> Option<i32> {
         if self.exited() {
-            Some(backend::process::wait::WEXITSTATUS(self.0 as _) as _)
+            Some(backend::process::wait::WEXITSTATUS(self.0))
         } else {
             None
         }
@@ -139,7 +140,7 @@ impl WaitStatus {
     #[inline]
     pub fn terminating_signal(self) -> Option<i32> {
         if self.signaled() {
-            Some(backend::process::wait::WTERMSIG(self.0 as _) as _)
+            Some(backend::process::wait::WTERMSIG(self.0))
         } else {
             None
         }
@@ -217,7 +218,7 @@ impl WaitIdStatus {
     #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
     pub fn stopping_signal(&self) -> Option<i32> {
         if self.stopped() {
-            Some(self.si_status() as _)
+            Some(self.si_status())
         } else {
             None
         }
@@ -229,7 +230,7 @@ impl WaitIdStatus {
     #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
     pub fn trapping_signal(&self) -> Option<i32> {
         if self.trapped() {
-            Some(self.si_status() as _)
+            Some(self.si_status())
         } else {
             None
         }
@@ -239,9 +240,9 @@ impl WaitIdStatus {
     /// normally.
     #[inline]
     #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
-    pub fn exit_status(&self) -> Option<u32> {
+    pub fn exit_status(&self) -> Option<i32> {
         if self.exited() {
-            Some(self.si_status() as _)
+            Some(self.si_status())
         } else {
             None
         }
@@ -253,7 +254,7 @@ impl WaitIdStatus {
     #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
     pub fn terminating_signal(&self) -> Option<i32> {
         if self.killed() || self.dumped() {
-            Some(self.si_status() as _)
+            Some(self.si_status())
         } else {
             None
         }
@@ -295,6 +296,10 @@ impl WaitIdStatus {
         self.0.si_code
     }
 
+    // This is disabled on NetBSD because the libc crate's `si_status()`
+    // implementation doesn't appear to match what's in NetBSD's headers and we
+    // don't get a meaningful value returned.
+    // TODO: Report this upstream.
     #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
     #[allow(unsafe_code)]
     fn si_status(&self) -> crate::ffi::c_int {
@@ -306,6 +311,41 @@ impl WaitIdStatus {
     }
 }
 
+#[cfg(not(any(
+    target_os = "horizon",
+    target_os = "openbsd",
+    target_os = "redox",
+    target_os = "wasi"
+)))]
+impl fmt::Debug for WaitIdStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut s = f.debug_struct("WaitIdStatus");
+        s.field("stopped", &self.stopped());
+        s.field("exited", &self.exited());
+        s.field("killed", &self.killed());
+        s.field("trapped", &self.trapped());
+        s.field("dumped", &self.dumped());
+        s.field("continued", &self.continued());
+        #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
+        if let Some(stopping_signal) = self.stopping_signal() {
+            s.field("stopping_signal", &stopping_signal);
+        }
+        #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
+        if let Some(trapping_signal) = self.trapping_signal() {
+            s.field("trapping_signal", &trapping_signal);
+        }
+        #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
+        if let Some(exit_status) = self.exit_status() {
+            s.field("exit_status", &exit_status);
+        }
+        #[cfg(not(any(target_os = "emscripten", target_os = "fuchsia", target_os = "netbsd")))]
+        if let Some(terminating_signal) = self.terminating_signal() {
+            s.field("terminating_signal", &terminating_signal);
+        }
+        s.finish()
+    }
+}
+
 /// The identifier to wait on in a call to [`waitid`].
 #[cfg(not(any(target_os = "openbsd", target_os = "redox", target_os = "wasi")))]
 #[derive(Debug, Clone)]

tests/process/pidfd.rs

@@ -12,7 +12,7 @@ use std::process::Command;
 #[serial]
 fn test_pidfd_waitid() {
     // Create a new process.
-    let child = Command::new("yes")
+    let mut child = Command::new("yes")
         .stdout(std::process::Stdio::null())
         .stderr(std::process::Stdio::null())
         .spawn()
@@ -25,6 +25,7 @@ fn test_pidfd_waitid() {
         Err(io::Errno::NOSYS) => {
             // The kernel does not support pidfds.
             unsafe { kill(child.id() as _, SIGINT) };
+            child.wait().unwrap();
             return;
         }
         Err(e) => panic!("failed to open pidfd: {}", e),
@@ -104,7 +105,7 @@ fn test_pidfd_waitid() {
 #[serial]
 fn test_pidfd_send_signal() {
     // Create a new process.
-    let child = Command::new("yes")
+    let mut child = Command::new("yes")
         .stdout(std::process::Stdio::null())
         .stderr(std::process::Stdio::null())
         .spawn()
@@ -117,6 +118,7 @@ fn test_pidfd_send_signal() {
         Err(io::Errno::NOSYS) => {
             // The kernel does not support pidfds.
             process::kill_process(process::Pid::from_child(&child), process::Signal::INT).unwrap();
+            child.wait().unwrap();
             return;
         }
         Err(e) => panic!("failed to open pidfd: {}", e),
@@ -195,7 +197,7 @@ fn test_pidfd_send_signal() {
 #[serial]
 fn test_pidfd_poll() {
     // Create a new process.
-    let child = Command::new("sleep")
+    let mut child = Command::new("sleep")
         .arg("1")
         .stdout(std::process::Stdio::null())
         .stderr(std::process::Stdio::null())
@@ -209,6 +211,7 @@ fn test_pidfd_poll() {
         Err(io::Errno::NOSYS) | Err(io::Errno::INVAL) => {
             // The kernel does not support non-blocking pidfds.
             process::kill_process(process::Pid::from_child(&child), process::Signal::INT).unwrap();
+            child.wait().unwrap();
             return;
         }
         Err(e) => panic!("failed to open pidfd: {}", e),

tests/process/wait.rs

@@ -161,7 +161,7 @@ fn test_waitid() {
     assert!(status.continued());
 
     let status = process::waitid(
-        process::WaitId::All,
+        process::WaitId::Pid(pid),
         process::WaitIdOptions::EXITED | process::WaitIdOptions::NOHANG,
     )
     .expect("failed to wait");