Struct Fork 

pub struct Fork { /* private fields */ }

A Spawner-like structure that executes a closure instead of another process. Specifically, it forks the current caller, runs the closure within the child, then serializes and returns the result to the parent via a pipe.

Your return type, if one exists, must implement Serialize + Deserialize from serde, as the closure is run under a separate process (the child). This means that “returning” the result requires serializing the result and sending it back to the parent. This operates identically to how standard Input/Output/Error is captured in Spawn.

Implementations

impl Fork

pub fn new() -> Self

Construct a new fork instance.

pub fn mode(self, mode: Mode) -> Self

See Spawner::mode

pub fn seccomp(self, seccomp: Filter) -> Self

See Spawner::seccomp

pub fn cap(self, cap: Capability) -> Self

See Spawner::cap

pub fn caps(self, caps: impl IntoIterator<Item = Capability>) -> Self

See Spawner::caps

pub fn new_privileges(self, allow: bool) -> Self

See Spawner::new_privileges

pub fn mode_i(&mut self, mode: Mode)

See Spawner::mode_i

pub fn seccomp_i(&self, seccomp: Filter)

See Spawner::seccomp_i

pub fn cap_i(&mut self, cap: Capability)

See Spawner::cap_i

pub fn caps_i(&mut self, caps: impl IntoIterator<Item = Capability>)

See Spawner::caps_i

pub fn new_privileges_i(self, allow: bool)

See Spawner::new_privileges_i

pub unsafe fn fork<F, R>(self, op: F) -> Result<R, Error>

where F: FnOnce() -> R + UnwindSafe, R: Serialize + DeserializeOwned,

Run a closure within a fork.

Example

let result = unsafe { spawn::Fork::new().fork(|| 1) }.unwrap();
assert!(result == 1);

Safety

This function does not call execve. The closure runs within the fork, which has several considerations:

1. The code should not make allocations. Though the default memory allocator on Linux often works in such an environment, it should not be relied upon.
2. If you had a signal handler installed, this tries and drops all of them. Other such primitives may fail at any point, and should not be relied upon.

---

If your closure returns a value, it must implement Serialize, as the closure is running under a separate process, and must be transmitted to the parent through a pipe.

pub unsafe fn fork_fd<F, R>(self, op: F) -> Result<OwnedFd, Error>

where F: FnOnce() -> R + UnwindSafe, R: Into<OwnedFd>,

This is a specialized version of fork() that uses the SCM-Rights of a Unix Socket to transmit a FD to the parent. This could be used to open a file under one operating mode, and send the FD to the parent under another operating mode.

Safety

See fork()

Trait Implementations

impl Default for Fork

fn default() -> Fork

Returns the “default value” for a type.