refactor(ctl): use rustix::process for kill and process-alive checks

Co-authored-by: Leonardo Di Giovanna <leonardodigiovanna1@gmail.com>
Signed-off-by: Leonardo Grasso <me@leonardograsso.com>

Author: 2 people

Cargo.lock

@@ -14,6 +14,9 @@ serde_json = "1"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
+# `process` enables `kill_process` / `test_kill_process` (safe wrappers
+# around `kill(pid, sig)` and `kill(pid, 0)`).
+rustix = { version = "1", features = ["process"] }
 
 [target.'cfg(windows)'.dependencies]
 uds_windows = "1.2"

tools/premptictl/Cargo.toml

@@ -333,12 +333,15 @@ fn spawn_signal_watcher(
 #[cfg(unix)]
 #[cfg_attr(not(target_os = "windows"), allow(dead_code))]
 pub(crate) fn process_alive(pid: u32) -> bool {
-    let rc = unsafe { libc::kill(pid as i32, 0) };
-    if rc == 0 {
-        return true;
+    let Some(pid) = rustix::process::Pid::from_raw(pid as i32) else {
+        return false;
+    };
+    match rustix::process::test_kill_process(pid) {
+        Ok(()) => true,
+        // ESRCH = no such process. Anything else (e.g. EPERM: process exists
+        // but we can't signal it) still counts as "alive".
+        Err(e) => e != rustix::io::Errno::SRCH,
     }
-    let err = std::io::Error::last_os_error();
-    err.raw_os_error() != Some(libc::ESRCH)
 }
 
 #[cfg(windows)]

tools/premptictl/src/daemon/mod.rs

@@ -24,17 +24,17 @@ pub fn graceful_stop(child: &mut Child, timeout: Duration) -> io::Result<ExitSta
 
 #[cfg(unix)]
 fn request_graceful_stop(child: &mut Child) -> io::Result<()> {
-    let pid = child.id() as i32;
-    let rc = unsafe { libc::kill(pid, libc::SIGTERM) };
-    if rc != 0 {
-        let err = io::Error::last_os_error();
+    let Some(pid) = rustix::process::Pid::from_raw(child.id() as i32) else {
+        // PID 0 / invalid: a spawned Child should never have this; treat as
+        // "already gone" for safety.
+        return Ok(());
+    };
+    match rustix::process::kill_process(pid, rustix::process::Signal::TERM) {
+        Ok(()) => Ok(()),
         // ESRCH means the process is already gone; that's fine.
-        if err.raw_os_error() == Some(libc::ESRCH) {
-            return Ok(());
-        }
-        return Err(err);
+        Err(e) if e == rustix::io::Errno::SRCH => Ok(()),
+        Err(e) => Err(e.into()),
     }
-    Ok(())
 }
 
 #[cfg(windows)]