Enum CloneMode 

pub enum CloneMode {
    Fork,
    Thread,
}

How WorkloadHandle::spawn creates worker tasks.

Fork is the default — the existing fork(2) path with separate address space, separate thread group, and waitpid reaping. Thread switches to std::thread::spawn for workers that share the test runner’s tgid.

WorkType × CloneMode compatibility

Most WorkType variants compose with both clone modes. The only exception is surfaced at spawn time by WorkloadHandle::spawn:

WorkType	Fork	Thread
All variants (default)	OK	OK
WorkType::ForkExit	OK	reject

ForkExit + Thread is rejected because the worker body calls libc::fork() from inside a thread of the multi-threaded harness: the fork duplicates only the calling thread, so any lock another thread holds at fork time stays locked forever in the child. The child only _exits here — and fork() omits CLONE_THREAD, so the child is its own singleton tgid; its _exit invokes exit_group(2), but that tgid has no sibling threads to tear down, so it ends only the child — but the fork/exit lifecycle is faithfully exercised only when each worker is its own process. Use CloneMode::Fork for WorkType::ForkExit.

Other Thread-mode interactions worth knowing:

• WorkType::NiceSweep: setpriority(PRIO_PROCESS, 0, …) targets the calling task only (kernel/sys.c::sys_setpriority case PRIO_PROCESS: if (who == 0) p = current), so each sibling thread independently sweeps its own nice. Allowed.
• WorkType::AffinityChurn: sched_setaffinity(0, …) addresses the calling thread by kernel rule (kernel/sched/syscalls.c::sched_setaffinity). Allowed; no cross-thread interference.
• WorkType::PolicyChurn: sched_setscheduler(0, …) is also per-task. Allowed.
• WorkType::AsymmetricWaker with an RT class: legal but the harness still runs as its original (likely SCHED_NORMAL) policy; only the worker thread is RT.

Variants

Fork

Plain fork(2): separate address space, separate thread group (p->tgid = p->pid), reaped via waitpid. The default — preserves existing WorkloadHandle::spawn behavior.

Thread

Same thread group as the spawning process. Implementation uses std::thread::spawn; the Rust thread runtime owns all clone-flag selection internally. Reaped via std::thread::JoinHandle. Workers share tgid, signal-handler table, and address space with the parent — observers like task_struct->group_leader, tgid, real_parent all match the parent’s.

Trait Implementations

impl Clone for CloneMode

fn clone(&self) -> CloneMode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CloneMode

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

Formats the value using the given formatter.

impl Default for CloneMode

fn default() -> CloneMode

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CloneMode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CloneMode

fn eq(&self, other: &CloneMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CloneMode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for CloneMode

impl Eq for CloneMode

impl StructuralPartialEq for CloneMode