add pidfd_send_signal(2)

Author: CobaltCause

changelog/2748.added.md

@@ -1 +1 @@
-Added `pidfd_open(2)`
+Added `pidfd_open(2)` and `pidfd_send_signal(2)`

src/sys/pidfd.rs

@@ -2,12 +2,14 @@
 
 use std::{
     hint::unreachable_unchecked,
-    os::fd::{FromRawFd as _, OwnedFd, RawFd},
+    os::fd::{AsFd, AsRawFd, FromRawFd as _, OwnedFd, RawFd},
+    ptr,
 };
 
 use bitflags::bitflags;
+use libc::siginfo_t;
 
-use crate::{errno::Errno, unistd::Pid};
+use crate::{errno::Errno, sys::signal::Signal, unistd::Pid};
 
 bitflags! {
     /// Flags for [`pidfd_open`].
@@ -58,3 +60,73 @@ pub fn pidfd_open(pid: Pid, flags: PidfdOpenFlags) -> Result<OwnedFd, Errno> {
         }
     }
 }
+
+feature! {
+#![feature = "signal"]
+
+bitflags! {
+    /// Flags for [`pidfd_send_signal`].
+    #[derive(Copy, Clone)]
+    pub struct PidfdSendSignalFlags: libc::c_uint {
+        /// See [`pidfd_send_signal(2)`] for details.
+        ///
+        /// [`pidfd_send_signal(2)`]: https://man7.org/linux/man-pages/man2/pidfd_send_signal.2.html
+        const PIDFD_SIGNAL_THREAD = libc::PIDFD_SIGNAL_THREAD;
+
+        /// See [`pidfd_send_signal(2)`] for details.
+        ///
+        /// [`pidfd_send_signal(2)`]: https://man7.org/linux/man-pages/man2/pidfd_send_signal.2.html
+        const PIDFD_SIGNAL_THREAD_GROUP = libc::PIDFD_SIGNAL_THREAD_GROUP;
+
+        /// See [`pidfd_send_signal(2)`] for details.
+        ///
+        /// [`pidfd_send_signal(2)`]: https://man7.org/linux/man-pages/man2/pidfd_send_signal.2.html
+        const PIDFD_SIGNAL_PROCESS_GROUP = libc::PIDFD_SIGNAL_PROCESS_GROUP;
+    }
+}
+
+/// Send a signal to a process by its PIDFD.
+///
+/// See [`pidfd_send_signal(2)`] for details.
+///
+/// [`pidfd_send_signal(2)`]: https://man7.org/linux/man-pages/man2/pidfd_send_signal.2.html
+///
+/// # Safety
+///
+/// This function is [async-signal-safe], although it may modify `errno`.
+///
+/// [async-signal-safe]: https://man7.org/linux/man-pages/man7/signal-safety.7.html
+pub fn pidfd_send_signal<T>(
+    pidfd: T,
+    signal: Signal,
+    signal_info: Option<siginfo_t>,
+    flags: PidfdSendSignalFlags,
+) -> Result<(), Errno>
+where
+    T: AsFd,
+{
+    let signal_info = match signal_info {
+        Some(x) => &x,
+        None => ptr::null(),
+    };
+
+    // SAFETY:
+    //
+    // * Arguments passed to the syscall have the correct types.
+    // * The kernel should not return any value other than `0` and `-1`.
+    unsafe {
+        match libc::syscall(
+            libc::SYS_pidfd_send_signal,
+            pidfd.as_fd().as_raw_fd(),
+            signal as libc::c_int,
+            signal_info,
+            flags.bits(),
+        ) {
+            0 => Ok(()),
+            -1 => Err(Errno::last()),
+            _ => unreachable_unchecked(),
+        }
+    }
+}
+
+}

test/sys/test_pidfd.rs

@@ -1,10 +1,74 @@
 use nix::{
+    errno::Errno,
     sys::pidfd::{pidfd_open, PidfdOpenFlags},
     unistd::getpid,
 };
 
 #[test]
 fn test_pidfd_open() {
-    pidfd_open(getpid(), PidfdOpenFlags::empty())
-        .expect("should be able to get pidfd");
+    match pidfd_open(getpid(), PidfdOpenFlags::empty()) {
+        Ok(_) => (),
+        Err(Errno::ENOSYS) => (),
+        Err(e) => panic!("{e}"),
+    }
+}
+
+#[cfg(feature = "signal")]
+mod send_signal {
+    use nix::{
+        errno::Errno,
+        sys::{
+            pidfd::{
+                pidfd_open, pidfd_send_signal, PidfdOpenFlags,
+                PidfdSendSignalFlags,
+            },
+            signal::Signal,
+            wait::{waitpid, WaitStatus},
+        },
+        unistd::{fork, getpid, ForkResult},
+    };
+
+    #[test]
+    fn test_pidfd_send_signal() {
+        // NOTE: This function MUST be async-signal-safe.
+        fn child_process() -> ! {
+            let pidfd = match pidfd_open(getpid(), PidfdOpenFlags::empty()) {
+                Ok(x) => x,
+                Err(Errno::ENOSYS) => std::process::exit(2),
+                Err(_) => std::process::exit(1),
+            };
+
+            // Code beyond this call should be unreachable.
+            match pidfd_send_signal(
+                &pidfd,
+                Signal::SIGKILL,
+                None,
+                PidfdSendSignalFlags::empty(),
+            ) {
+                Ok(()) => (),
+                Err(Errno::ENOSYS) => std::process::exit(2),
+                Err(_) => std::process::exit(1),
+            }
+
+            std::process::exit(1)
+        }
+
+        // SAFETY: `child_process` is async-signal-safe.
+        let child = unsafe {
+            match fork().expect("should be able to fork") {
+                ForkResult::Parent { child } => child,
+                ForkResult::Child => child_process(),
+            }
+        };
+
+        match waitpid(child, None) {
+            // Kernel has PIDFD syscalls and they worked.
+            Ok(WaitStatus::Signaled(x, Signal::SIGKILL, _)) if x == child => (),
+
+            // Kernel does not have PIDFD syscalls.
+            Ok(WaitStatus::Exited(x, 2)) if x == child => (),
+
+            _ => panic!("unexpected waitpid result"),
+        }
+    }
 }