use std::io;
use std::os::fd::AsFd;
use std::os::unix::process::{CommandExt as _, ExitStatusExt as _};
use std::process::{ChildStderr, ChildStdin, ChildStdout, Command, ExitStatus};
use std::time::{Duration, Instant};
use rustix::event::{PollFd, PollFlags, Timespec, poll};
use rustix::io::Errno;
use rustix::process::{
Pid, Signal as Raw, WaitId, WaitIdOptions, WaitIdStatus, getpgid, kill_process,
kill_process_group, test_kill_process_group, waitid,
};
#[cfg(feature = "forward")]
use crate::forward::{listed, unlisted};
use crate::{REAP_GRACE, Scope, Signal, Status};
#[cfg(test)]
mod tests;
pub(crate) use std::os::fd::AsFd as Pipe;
const STOPPED_CHECK: Duration = Duration::from_millis(10);
const EMPTY_CHECK: Duration = Duration::from_millis(1);
pub(crate) const GRACEFUL: bool = true;
#[derive(Debug)]
pub(crate) struct Child {
process: std::process::Child,
pid: Pid,
scope: Scope,
}
impl Child {
pub(crate) fn spawn(mut command: Command, scope: Scope) -> io::Result<Self> {
let child = if scope == Scope::Group {
command.process_group(0);
listed(|| command.spawn())?
} else {
command.spawn()?
};
let pid = Pid::from_child(&child);
Ok(Self {
process: child,
pid,
scope,
})
}
pub(crate) fn others_alive(&self) -> bool {
self.scope == Scope::Group && others_in_group(self.pid)
}
pub(crate) fn id(&self) -> u32 {
self.process.id()
}
pub(crate) fn take_stdin(&mut self) -> Option<ChildStdin> {
self.process.stdin.take()
}
pub(crate) fn take_stdout(&mut self) -> Option<ChildStdout> {
self.process.stdout.take()
}
pub(crate) fn take_stderr(&mut self) -> Option<ChildStderr> {
self.process.stderr.take()
}
pub(crate) fn signal(&self, signal: Signal) -> io::Result<()> {
let raw = raw(signal);
let result = if self.scope == Scope::Child {
sent(kill_process(self.pid, raw))
.and_then(|()| resume(raw, |cont| kill_process(self.pid, cont)))
} else {
signal_group(self.pid, raw)
};
match result {
Err(_) if self.has_exited().unwrap_or(false) => Ok(()),
result => result,
}
}
pub(crate) fn is_gone(error: &io::Error) -> bool {
error.raw_os_error() == Some(Errno::CHILD.raw_os_error())
}
pub(crate) fn has_exited(&self) -> io::Result<bool> {
has_exited(self.pid)
}
pub(crate) const fn waiter(&self) -> Waiter {
Waiter(self.pid)
}
pub(crate) fn reap(&mut self) -> io::Result<ExitStatus> {
self.waiter().wait()?;
if self.scope == Scope::Child {
return self.process.wait();
}
let pid = self.pid;
let give_up = Instant::now().checked_add(REAP_GRACE);
until_empty(
give_up,
|| {
let _ = kill_process_group(pid, Raw::KILL);
},
|| missed_by_kill(pid),
);
let process = &mut self.process;
let status = unlisted(pid, || process.wait())?;
until_empty(
give_up,
|| {},
|| test_kill_process_group(pid) != Err(Errno::SRCH),
);
Ok(status)
}
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct Waiter(Pid);
impl Waiter {
pub(crate) fn wait(self) -> io::Result<()> {
loop {
match waitid(
WaitId::Pid(self.0),
WaitIdOptions::EXITED | WaitIdOptions::NOWAIT,
) {
Ok(Some(status)) if ended(&status) => return Ok(()),
Ok(_) => {
if !consume(self.0)? {
std::thread::sleep(STOPPED_CHECK);
}
}
Err(Errno::INTR) => {}
Err(error) => return Err(error.into()),
}
}
}
}
#[cfg(any(target_os = "linux", target_os = "android"))]
fn others_in_group(leader: Pid) -> bool {
let Ok(processes) = std::fs::read_dir("/proc") else {
return false;
};
processes.flatten().any(|process| {
std::fs::read(process.path().join("stat")).is_ok_and(|stat| {
live_in_group(
&String::from_utf8_lossy(&stat),
leader.as_raw_nonzero().get(),
)
})
})
}
#[cfg(target_os = "macos")]
fn others_in_group(leader: Pid) -> bool {
test_kill_process_group(leader).is_ok()
}
#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "macos")))]
const fn others_in_group(_leader: Pid) -> bool {
false
}
#[cfg(target_os = "macos")]
fn missed_by_kill(leader: Pid) -> bool {
others_in_group(leader)
}
#[cfg(not(target_os = "macos"))]
const fn missed_by_kill(_leader: Pid) -> bool {
false
}
fn until_empty(give_up: Option<Instant>, mut step: impl FnMut(), mut left: impl FnMut() -> bool) {
loop {
step();
if !left() || give_up.is_some_and(|give_up| Instant::now() >= give_up) {
return;
}
std::thread::sleep(EMPTY_CHECK);
}
}
#[cfg(any(target_os = "linux", target_os = "android", test))]
fn live_in_group(stat: &str, group: i32) -> bool {
let Some((_, fields)) = stat.rsplit_once(')') else {
return false;
};
let mut fields = fields.split_ascii_whitespace();
let state = fields.next();
let in_group = fields.nth(1).and_then(|value| value.parse().ok()) == Some(group);
in_group && !matches!(state, Some("Z" | "X" | "x"))
}
fn consume(pid: Pid) -> io::Result<bool> {
let options = WaitIdOptions::STOPPED | WaitIdOptions::CONTINUED | WaitIdOptions::NOHANG;
loop {
match waitid(WaitId::Pid(pid), options) {
Ok(found) => return Ok(found.is_some()),
Err(Errno::INTR) => {}
Err(error) => return Err(error.into()),
}
}
}
pub(crate) fn signal_group(pid: Pid, raw: Raw) -> io::Result<()> {
let group = sent(kill_process_group(pid, raw))
.and_then(|()| resume(raw, |cont| kill_process_group(pid, cont)));
if getpgid(Some(pid)).ok() == Some(pid) {
return group;
}
let moved =
sent(kill_process(pid, raw)).and_then(|()| resume(raw, |cont| kill_process(pid, cont)));
group.and(moved)
}
fn resume(raw: Raw, send: impl FnOnce(Raw) -> rustix::io::Result<()>) -> io::Result<()> {
if raw == Raw::KILL {
return Ok(());
}
sent(send(Raw::CONT))
}
fn ended(status: &WaitIdStatus) -> bool {
status.exited() || status.killed() || status.dumped()
}
pub(crate) fn has_exited(pid: Pid) -> io::Result<bool> {
let options = WaitIdOptions::EXITED | WaitIdOptions::NOHANG | WaitIdOptions::NOWAIT;
loop {
match waitid(WaitId::Pid(pid), options) {
Ok(status) => return Ok(status.is_some_and(|status| ended(&status))),
Err(Errno::INTR) => {}
Err(error) => return Err(error.into()),
}
}
}
#[cfg(not(feature = "forward"))]
fn listed(
spawn: impl FnOnce() -> io::Result<std::process::Child>,
) -> io::Result<std::process::Child> {
spawn()
}
#[cfg(not(feature = "forward"))]
fn unlisted<T>(_pid: Pid, reap: impl FnOnce() -> T) -> T {
reap()
}
const fn raw(signal: Signal) -> Raw {
match signal {
Signal::Interrupt => Raw::INT,
Signal::Terminate => Raw::TERM,
Signal::Hangup => Raw::HUP,
Signal::Kill => Raw::KILL,
}
}
fn sent(result: rustix::io::Result<()>) -> io::Result<()> {
match result {
Ok(()) | Err(Errno::SRCH) => Ok(()),
Err(error) => Err(error.into()),
}
}
pub(crate) fn status_of(status: ExitStatus) -> Status {
match status.code() {
Some(code) => Status::Code(code),
None => Status::Signal(status.signal().unwrap_or(0)),
}
}
pub(crate) fn ready(pipe: impl AsFd, write: bool, timeout: Duration) -> io::Result<bool> {
let flags = if write { PollFlags::OUT } else { PollFlags::IN };
let timeout = Timespec::try_from(timeout).map_err(io::Error::other)?;
let mut fds = [PollFd::new(&pipe, flags)];
match poll(&mut fds, Some(&timeout)) {
Ok(ready) => Ok(ready > 0),
Err(Errno::INTR) => Ok(false),
Err(error) => Err(error.into()),
}
}
pub(crate) fn unblock(pipe: impl AsFd) -> io::Result<()> {
rustix::io::ioctl_fionbio(pipe, true).map_err(io::Error::from)
}