1 unstable release
0.1.0 | Jul 3, 2024 |
---|
#428 in Asynchronous
100 downloads per month
Used in 10 crates
(via swayipc-async)
18KB
174 lines
This is a maintained fork of async-pidfd
.
Process file descriptors (pidfd
) for Linux
Process file descriptors (pidfd
) provide a race-free way to manage processes
on Linux, maintaining a persistent reference to a process using a file
descriptor rather than a numeric process ID (PID) that could be reused after
the process exits.
This crate only works on Linux; if you need support for other platforms, or for older Linux kernels, see async-process.
async-pidfd
provides Rust support for pidfd, and supports managing processes
both synchronously (via the PidFd
type) and asynchronously (via the
AsyncPidFd
type).
Sync - PidFd
The PidFd
type manages processes synchronously. Use PidFd::from_pid
to
construct a PidFd
from a process ID, such as from
Child::id
in the standard library. (Note that the portable Child::id
function returns
process IDs as u32
, rather than as a libc::pid_t
, necessitating a cast.)
use std::os::unix::process::ExitStatusExt;
use std::process::{Command, ExitStatus};
use async_pidfd::PidFd;
fn main() -> std::io::Result<()> {
let child = Command::new("/bin/true").spawn()?;
let pidfd = PidFd::from_pid(child.id() as libc::pid_t)?;
let status = pidfd.wait()?.status();
assert_eq!(status.code(), Some(0));
let child = Command::new("/bin/sh").arg("-c").arg("kill -9 $$").spawn()?;
let pidfd = PidFd::from_pid(child.id() as libc::pid_t)?;
let status = pidfd.wait()?.status();
assert_eq!(status.signal(), Some(9));
Ok(())
}
PidFd::wait
returns information about an exited process via the ExitInfo
structure. ExitInfo
includes a libc::siginfo_t
indicating how the process
exited (including the exit code if it exited normally, or the signal if it was
killed by a signal), and a libc::rusage
describing the resource usage of the
process and its children. libc::siginfo_t
has complex semantics; to get a
std::process::ExitStatus
instead, you can call .status()
on an ExitInfo
.
Note that while opening the PID for an arbitrary process can potentially race
with the exit of that process, opening the PID for a child process that you
have not yet waited on is safe, as the process ID will not get reused until you
wait on the process (or block SIGCHLD
).
If you only want to use the synchronous PidFd
type, you can use async-pidfd
with default-features = false
in Cargo.toml
to remove async-related
dependencies.
Async - AsyncPidFd
The AsyncPidFd
type manages processes asynchronously, based on the
async-io
crate by Stjepan Glavina. async-io
provides an Async
wrapper that makes it easy to turn any synchronous type
based on a file descriptor into an asynchronous type; the resulting
asynchronous code uses epoll
to wait for all the file descriptors
concurrently.
AsyncPidFd
wraps an Async<PidFd>
and provides the same API as PidFd
, but
with an async
version of the wait
function.
use std::os::unix::process::ExitStatusExt;
use std::process::{Command, ExitStatus};
use async_pidfd::AsyncPidFd;
use futures_lite::future;
async fn async_spawn_and_status(cmd: &mut Command) -> std::io::Result<ExitStatus> {
let child = cmd.spawn()?;
let pidfd = AsyncPidFd::from_pid(child.id() as libc::pid_t)?;
Ok(pidfd.wait().await?.status())
}
fn main() -> std::io::Result<()> {
future::block_on(async {
let (status1, status2) = future::try_join(
async_spawn_and_status(&mut Command::new("/bin/true")),
async_spawn_and_status(&mut Command::new("/bin/false")),
)
.await?;
assert_eq!(status1.code(), Some(0));
assert_eq!(status2.code(), Some(1));
Ok(())
})
}
Dependencies
~0–9MB
~83K SLoC