Struct PidFd

pub struct PidFd { /* private fields */ }

PidFd for async and efficient method of reaping children process and race-free signal sending.

Example

use libc::fork;
use async_linux_spec_fd::*;

#[tokio::main(flavor = "current_thread")]
async fn f() {
    let pid = unsafe { fork() };
    assert!(pid >= 0);
    if pid != 0 { // parent
        let pidfd = PidFd::open(pid).unwrap();
        let exitinfo = pidfd.waitpid().await.unwrap();

        match exitinfo.get_code() {
            ExitCode::Killed(_) => panic!("Children killed by signal!"),
            ExitCode::Exited(code) => assert_eq!(code, 0),
        }
    }
}

f();

Implementations

impl PidFd

pub fn open(pid: pid_t) -> Result<Self>

Creating PidFd from the pid of children

Make sure that:

• the disposition of SIGCHLD has not been explicitly set to SIG_IGN;
• the SA_NOCLDWAIT flag was not specified while establishing a handler for SIGCHLD or while setting the disposition of that signal to SIG_DFL;
• the zombie process was not reaped elsewhere in the program (e.g., either by an asynchronously executed signal handler or by wait(2) or similar in another thread).

If any of these conditions does not hold, then the child process (along with a PID file descriptor that refers to it) should instead be created using clone with the CLONE_PIDFD flag and uses the from_raw function to create PidFd.

Creating PidFd from arbitary pid

Make sure to verify that the process pointed to by this pid is the one you want.

pub const unsafe fn from_raw(fd: RawFd) -> Self

Safety

Make sure fd is actually created via clone with the CLONE_PIDFD flag or by using pidfd_open.

pub fn send_signal( &self, signal: Signal, info: Option<&siginfo_t>, ) -> Result<()>

• self - The calling process must either be in the same PID namespace as the process referred to by self, or be in an ancestor of that namespace.
• info - If equals to Some(buffer), then buffer should be populated as described in rt_sigqueueinfo. Or, it is equivalent to specifing to a buffer whose fields are implicily filled in as follows:
  • si_signo is set to the signal;
  • si_errno is set to 0;
  • si_code is set to SI_USER;
  • si_pid is set to the caller’s PID;
  • si_uid is set to the caller’s real user ID.

pub async fn wait_for_terminate(&self) -> Result<()>

Asynchronously wait for the process to terminate.

pub async fn waitpid(&self) -> Result<ExitInfo>

Asynchronously wait for the child process to terminate and reap it using waitid.