kill: allow using real-time signals

Right now it is not possible to send real-time signals using kill
because the underlying nix::sys::signal code does not support real-time
signals. Workaround this by using libc directly.

With this, the "EXIT" workaround can be dropped, because we no longer
need to convert to nix::sys::signal::Signal.

Author: enr0n

src/uu/kill/src/kill.rs

@@ -6,16 +6,16 @@
 // spell-checker:ignore (ToDO) signalname pids killpg
 
 use clap::{Arg, ArgAction, Command};
-use nix::sys::signal::{self, Signal};
-use nix::unistd::Pid;
+use nix::errno::Errno;
+use nix::libc;
 use std::io::Error;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::translate;
 
 use uucore::signals::{
     signal_by_name_or_value, signal_list_name_by_value, signal_list_value_by_name_or_number,
-    signal_name_by_value, signal_number_upper_bound,
+    signal_number_upper_bound,
 };
 use uucore::{format_usage, show};
 
@@ -68,18 +68,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 15_usize //SIGTERM
             };
 
-            let sig_name = signal_name_by_value(sig);
-            // Signal does not support converting from EXIT
-            // Instead, nix::signal::kill expects Option::None to properly handle EXIT
-            let sig: Option<Signal> = if sig_name.is_some_and(|name| name == "EXIT") {
-                None
-            } else {
-                let sig = (sig as i32)
-                    .try_into()
-                    .map_err(|e| Error::from_raw_os_error(e as i32))?;
-                Some(sig)
-            };
-
             let pids = parse_pids(&pids_or_signals)?;
             if pids.is_empty() {
                 Err(USimpleError::new(1, translate!("kill-error-no-process-id")))
@@ -250,9 +238,14 @@ fn parse_pids(pids: &[String]) -> UResult<Vec<i32>> {
         .collect()
 }
 
-fn kill(sig: Option<Signal>, pids: &[i32]) {
+fn kill(sig: usize, pids: &[i32]) {
     for &pid in pids {
-        if let Err(e) = signal::kill(Pid::from_raw(pid), sig) {
+        let result = unsafe {
+            let res = libc::kill(pid, sig as libc::c_int);
+            Errno::result(res)
+        };
+
+        if let Err(e) = result {
             show!(
                 Error::from_raw_os_error(e as i32)
                     .map_err_context(|| { translate!("kill-error-sending-signal", "pid" => pid) })

tests/by-util/test_kill.rs

@@ -6,6 +6,8 @@
 use regex::Regex;
 use std::os::unix::process::ExitStatusExt;
 use std::process::{Child, Command};
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use uucore::signals::realtime_signal_bounds;
 use uutests::new_ucmd;
 
 // A child process the tests will try to kill.
@@ -493,3 +495,33 @@ fn test_kill_signal_only_no_pid() {
         .fails()
         .stderr_contains("no process ID specified");
 }
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[test]
+fn test_kill_with_rtmin_offset() {
+    let (rtmin, _) = realtime_signal_bounds().unwrap();
+    let sig: i32 = (rtmin as i32) + 7;
+
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("SIGRTMIN+7")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(sig));
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[test]
+fn test_kill_with_rtmax_offset() {
+    let (_, rtmax) = realtime_signal_bounds().unwrap();
+    let sig: i32 = (rtmax as i32) - 7;
+
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("SIGRTMAX-7")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(sig));
+}