Struct Process 

pub struct Process { /* private fields */ }

A handle to a process this VFS did not spawn.

Holding one is what makes the operations below refer to a single process rather than to whatever currently owns a PID. How strong that guarantee is varies:

• Linux (pidfd) and Windows (a process handle pins the PID against reuse) are race-free for the whole life of the handle.
• FreeBSD and macOS validate identity at open and cannot maintain it: kill(2) takes a PID, and Capsicum mints process descriptors only through pdfork, so there is no handle to hold for a process this one did not fork. Process::signal and Process::terminate are racy there.

Implementations

impl Process

pub fn pid(&self) -> u32

Returns the process ID.

The only attribute projected directly: it is fixed for the life of the handle, where everything else has to be re-read to be true.

pub async fn info(&self) -> Result<ProcessInfo>

Takes a fresh snapshot of the process.

pub async fn signal(&self, signal: Signal) -> Result<()>

Sends a signal to the process.

Fails with ErrorKind::Unsupported on a Windows target. The method exists there regardless, because the target may be remote: whether signals exist is a property of the target, not of the host this code was compiled for.

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

Asks the process to terminate.

SIGTERM on Unix, TerminateProcess on Windows. Unconditional, with no grace period and no escalation, unlike Child::terminate: the graceful half of that path relies on children being spawned into a process group of their own, which is not something that can be arranged after the fact. Compose terminate, wait, a timeout, and kill for grace with escalation.

Note the asymmetry this leaves on Windows, where TerminateProcess is not a request the target can decline or clean up after.

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

Kills the process.

SIGKILL on Unix, TerminateProcess on Windows — the strongest stop the target offers, and one the process cannot catch or clean up after.

On a Windows target this is terminate under another name, since TerminateProcess is already unconditional and there is nothing harder to escalate to. The pair exists because on Unix the distinction is real, and a portable caller should be able to ask for either without branching on the target.

pub async fn wait(&self) -> Result<ProcessExit>

Waits for the process to exit.

pub async fn close(self) -> Result<()>

Closes the handle.

Not required: a dropped Process closes itself, and a remote one is released when the session’s object table is torn down. This exists so a caller can observe a close failure instead of discarding it.

Trait Implementations

impl Debug for Process

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.