Struct PhysicalExitWatch 

pub struct PhysicalExitWatch { /* private fields */ }

A watcher over a set of pidfds. See the module documentation.

Implementations

impl PhysicalExitWatch

pub fn on_runtime( handle: Handle, on_exit: impl Fn(i32) + Send + Sync + 'static, ) -> Result<Self>

Watches on handle’s runtime and creates no thread. on_exit is called on that runtime, once per watched process, with the id given to PhysicalExitWatch::watch. Wait for the reports with PhysicalExitWatch::drain_async: on a current-thread runtime the blocking PhysicalExitWatch::drain would stop the very tasks it waits for.

pub fn new(on_exit: impl Fn(i32) + Send + 'static) -> Result<Self>

Starts the watcher thread. on_exit is called on that thread, once per watched process, with the id given to PhysicalExitWatch::watch.

pub fn watch(&self, pidfd: OwnedFd, raw_pid: i32) -> Result<Watched>

Watches one process. pidfd must refer to it; raw_pid is the id the callback reports. A process that has already exited is reported at once.

Registrations are keyed by birth identity where the kernel provides one: a second registration for the same process (for example its admission and its parent’s creation report, in either order) joins the first and is reported once, and one for a process already seen to exit is not reported again. So a second registration cannot add a watch for a process already watched or already reported, even when its pid has been reused. (The report itself still carries only raw_pid; carrying the identity through to the completion is later work.)

pub fn failure(&self) -> Option<Error>

The watcher’s terminal failure, if it has stopped observing exits.

pub fn fail_and_kill_all(&self) -> Result<()>

Sends SIGKILL to every watched process that has not exited yet, and to every process watched from now on. Used when a run has failed, so that no guest outlives it, including one admitted after the failure; the exits that follow are reported as usual. SIGKILL also ends a stopped process. Every process is attempted; the first error other than ESRCH (the process already exited, so its report is on the way) is returned.

pub fn drain(&self, timeout: Duration) -> Result<(), DrainError>

Waits until every watched process has exited and its callback has returned, or until timeout expires. Blocks the calling thread, so a runtime-mode watcher is drained with PhysicalExitWatch::drain_async.

pub async fn drain_async(&self, timeout: Duration) -> Result<(), DrainError>

PhysicalExitWatch::drain without blocking the thread, so the watcher’s own tasks keep running when it shares a runtime with the caller.

Trait Implementations

impl Drop for PhysicalExitWatch

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.