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

@@ -8,3 +8,55 @@ fn test_pidfd_open() {
     pidfd_open(getpid(), PidfdOpenFlags::empty())
         .expect("should be able to get pidfd");
 }
+
+#[cfg(feature = "signal")]
+mod send_signal {
+    use nix::{
+        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 = pidfd_open(getpid(), PidfdOpenFlags::empty())
+                .unwrap_or_else(|_| std::process::exit(1));
+
+            // Code beyond this call should be unreachable.
+            pidfd_send_signal(
+                &pidfd,
+                Signal::SIGKILL,
+                None,
+                PidfdSendSignalFlags::empty(),
+            )
+            .unwrap_or_else(|_| 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(),
+            }
+        };
+
+        assert!(matches!(
+            waitpid(child, None),
+            Ok(WaitStatus::Signaled(
+                x,
+                Signal::SIGKILL,
+                _
+            )) if x == child
+        ));
+    }
+}