Add pidfd_getfd syscall. (#681)

Author: moshevds

src/backend/libc/process/syscalls.rs

@@ -15,7 +15,7 @@ use crate::backend::conv::{syscall_ret, syscall_ret_u32};
 #[cfg(not(target_os = "wasi"))]
 use crate::fd::BorrowedFd;
 #[cfg(target_os = "linux")]
-use crate::fd::{AsRawFd, OwnedFd};
+use crate::fd::{AsRawFd, OwnedFd, RawFd};
 #[cfg(feature = "fs")]
 use crate::ffi::CStr;
 #[cfg(feature = "fs")]
@@ -33,7 +33,10 @@ use crate::process::{Resource, Rlimit};
 use crate::process::{WaitId, WaitidOptions, WaitidStatus};
 use core::mem::MaybeUninit;
 #[cfg(target_os = "linux")]
-use {crate::backend::conv::syscall_ret_owned_fd, crate::process::PidfdFlags};
+use {
+    super::super::conv::syscall_ret_owned_fd, crate::process::PidfdFlags,
+    crate::process::PidfdGetfdFlags,
+};
 
 #[cfg(feature = "fs")]
 #[cfg(not(target_os = "wasi"))]
@@ -517,6 +520,22 @@ pub(crate) fn pidfd_open(pid: Pid, flags: PidfdFlags) -> io::Result<OwnedFd> {
     }
 }
 
+#[cfg(target_os = "linux")]
+pub(crate) fn pidfd_getfd(
+    pidfd: BorrowedFd<'_>,
+    targetfd: RawFd,
+    flags: PidfdGetfdFlags,
+) -> io::Result<OwnedFd> {
+    unsafe {
+        syscall_ret_owned_fd(c::syscall(
+            c::SYS_pidfd_getfd,
+            pidfd,
+            targetfd,
+            flags.bits(),
+        ))
+    }
+}
+
 #[cfg(not(target_os = "wasi"))]
 pub(crate) fn getgroups(buf: &mut [Gid]) -> io::Result<usize> {
     let len = buf.len().try_into().map_err(|_| io::Errno::NOMEM)?;

src/backend/linux_raw/process/syscalls.rs

@@ -11,18 +11,18 @@ use crate::backend::c;
 #[cfg(feature = "fs")]
 use crate::backend::conv::slice_mut;
 use crate::backend::conv::{
-    by_mut, by_ref, c_int, c_uint, negative_pid, pass_usize, ret, ret_c_int, ret_c_int_infallible,
-    ret_c_uint, ret_infallible, ret_owned_fd, ret_usize, size_of, slice_just_addr,
-    slice_just_addr_mut, zero,
+    by_mut, by_ref, c_int, c_uint, negative_pid, pass_usize, raw_fd, ret, ret_c_int,
+    ret_c_int_infallible, ret_c_uint, ret_infallible, ret_owned_fd, ret_usize, size_of,
+    slice_just_addr, slice_just_addr_mut, zero,
 };
-use crate::fd::{AsRawFd, BorrowedFd, OwnedFd};
+use crate::fd::{AsRawFd, BorrowedFd, OwnedFd, RawFd};
 #[cfg(feature = "fs")]
 use crate::ffi::CStr;
 use crate::io;
 use crate::pid::{RawNonZeroPid, RawPid};
 use crate::process::{
-    Cpuid, Gid, MembarrierCommand, MembarrierQuery, Pid, PidfdFlags, Resource, Rlimit, Uid, WaitId,
-    WaitOptions, WaitStatus, WaitidOptions, WaitidStatus,
+    Cpuid, Gid, MembarrierCommand, MembarrierQuery, Pid, PidfdFlags, PidfdGetfdFlags, Resource,
+    Rlimit, Uid, WaitId, WaitOptions, WaitStatus, WaitidOptions, WaitidStatus,
 };
 use crate::signal::Signal;
 use crate::utils::as_mut_ptr;
@@ -600,6 +600,22 @@ pub(crate) fn test_kill_current_process_group() -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_kill, pass_usize(0), pass_usize(0))) }
 }
 
+#[inline]
+pub(crate) fn pidfd_getfd(
+    pidfd: BorrowedFd<'_>,
+    targetfd: RawFd,
+    flags: PidfdGetfdFlags,
+) -> io::Result<OwnedFd> {
+    unsafe {
+        ret_owned_fd(syscall_readonly!(
+            __NR_pidfd_getfd,
+            pidfd,
+            raw_fd(targetfd),
+            c_int(flags.bits() as _)
+        ))
+    }
+}
+
 #[inline]
 pub(crate) fn pidfd_open(pid: Pid, flags: PidfdFlags) -> io::Result<OwnedFd> {
     unsafe { ret_owned_fd(syscall_readonly!(__NR_pidfd_open, pid, flags)) }

src/process/mod.rs

@@ -14,6 +14,8 @@ mod kill;
 mod membarrier;
 #[cfg(target_os = "linux")]
 mod pidfd;
+#[cfg(target_os = "linux")]
+mod pidfd_getfd;
 #[cfg(linux_kernel)]
 mod prctl;
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] // WASI doesn't have [gs]etpriority.
@@ -44,6 +46,8 @@ pub use kill::*;
 pub use membarrier::*;
 #[cfg(target_os = "linux")]
 pub use pidfd::*;
+#[cfg(target_os = "linux")]
+pub use pidfd_getfd::*;
 #[cfg(linux_kernel)]
 pub use prctl::*;
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]

src/process/pidfd_getfd.rs

@@ -0,0 +1,46 @@
+#![allow(unsafe_code)]
+use crate::fd::OwnedFd;
+use crate::{backend, io};
+use backend::fd::{AsFd, RawFd};
+
+/// Raw file descriptor in another process.
+///
+/// A distinct type alias is used here to inform the user that normal file descriptors from the
+/// calling process should not be used. The provided file descriptor is used by the kernel as the
+/// index into the file descriptor table of an entirely different process.
+pub type ForeignRawFd = RawFd;
+
+bitflags::bitflags! {
+    /// All flags are reserved for future use.
+    pub struct PidfdGetfdFlags: backend::c::c_uint {}
+}
+
+/// `syscall(SYS_pidfd_getfd, pidfd, flags)`—Obtain a duplicate of another
+/// process's file descriptor.
+///
+/// # References
+///  - [Linux]
+///
+/// # Warning
+///
+/// This function is generally safe for the calling process, but it can impact the target process
+/// in unexpected ways. If you want to ensure that Rust I/O safety assumptions continue to hold in
+/// the target process, then the target process must have communicated the file description number
+/// to the calling process from a value of a type that implements AsRawFd, and the target process
+/// must not drop that value until after the calling process has returned from `pidfd_getfd`.
+///
+/// When `pidfd_getfd` is used to debug the target, or the target is not a Rust aplication, or
+/// `pidfd_getfd` is used in any other way, then extra care should be taken to avoid unexpected
+/// behaviour or crashes.
+///
+/// For further details, see the references above.
+///
+/// [Linux]: https://man7.org/linux/man-pages/man2/pidfd_getfd.2.html
+#[inline]
+pub fn pidfd_getfd<Fd: AsFd>(
+    pidfd: Fd,
+    targetfd: ForeignRawFd,
+    flags: PidfdGetfdFlags,
+) -> io::Result<OwnedFd> {
+    backend::process::syscalls::pidfd_getfd(pidfd.as_fd(), targetfd, flags)
+}