use std::collections::BTreeSet;
use std::ffi::OsString;
use std::fmt;
use std::num::NonZeroU64;
use std::path::PathBuf;
use std::str::FromStr;
use std::time::SystemTime;
use chrono::DateTime;
use chrono::Utc;
use clap::Parser;
use reverie::BackendCapabilities;
use serde::Deserialize;
use serde::Serialize;
use crate::happens_before::HappensBeforeProgram;
use crate::network_trace::NetworkTraceConfig;
use crate::pid::DetTid;
use crate::schedule::SigWrapper;
use crate::time::NANOS_PER_RCB;
use crate::time::NANOS_PER_SCHED;
use crate::time::RcbTimeMultiplier;
const fn default_backend_capabilities() -> BackendCapabilities {
DEFAULT_BACKEND_CAPABILITIES
}
pub const DEFAULT_BACKEND_CAPABILITIES: BackendCapabilities = {
let mut backend = BackendCapabilities::PTRACE;
backend.supports_blocked_wait_signal_interruption = false;
backend.delivers_preemption_timer_events = false;
backend.runs_guest_code_between_injections = false;
backend.reports_sigreturns = false;
backend
};
#[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq)]
pub struct MountInfoRootRewrite {
pub raw_mount_id: u64,
pub deterministic_root: Vec<u8>,
#[serde(default)]
pub raw_root_prefix: Option<Vec<u8>>,
#[serde(default)]
pub deterministic_root_prefix: Option<Vec<u8>>,
#[serde(default)]
pub raw_mountpoint_prefix: Option<Vec<u8>>,
#[serde(default)]
pub deterministic_mountpoint_prefix: Option<Vec<u8>>,
}
#[derive(
Clone,
Copy,
Debug,
Default,
PartialEq,
Eq,
Hash,
Serialize,
Deserialize
)]
pub enum InheritedSeccomp {
#[default]
Unknown,
Disabled,
Strict,
Filter(Option<u32>),
}
impl InheritedSeccomp {
pub fn measure() -> Self {
std::fs::read_to_string("/proc/thread-self/status")
.map_or(Self::Unknown, |status| Self::parse(&status))
}
pub fn parse(status: &str) -> Self {
let field = |name: &str| {
status
.lines()
.find_map(|line| line.strip_prefix(name)?.strip_prefix(':'))
.map(str::trim)
};
match field("Seccomp") {
Some("0") => Self::Disabled,
Some("1") => Self::Strict,
Some("2") => Self::Filter(field("Seccomp_filters").and_then(|n| n.parse().ok())),
_ => Self::Unknown,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LaunchImage {
pub exe: Option<PathBuf>,
pub launcher: Option<PathBuf>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct MountNamespaceIdentity {
pub id: Option<u64>,
pub device: u64,
pub inode: u64,
}
#[derive(Debug, Serialize, Deserialize, Clone, Parser)]
pub struct Config {
#[clap(long = "no-virtualize-time", action = clap::ArgAction::SetFalse)]
pub virtualize_time: bool,
#[clap(long = "no-virtualize-cpuid", action = clap::ArgAction::SetFalse)]
pub virtualize_cpuid: bool,
#[clap(long, value_enum, default_value_t, long_help = crate::cpu_profile::CPU_PROFILE_LONG_HELP)]
#[serde(default)]
pub cpu_profile: crate::cpu_profile::CpuProfile,
#[clap(skip)]
#[serde(default)]
pub cpu_profile_host: Option<crate::cpu_profile::HostXstate>,
#[serde(default = "default_backend_capabilities")]
#[clap(skip = DEFAULT_BACKEND_CAPABILITIES)]
pub backend: BackendCapabilities,
#[serde(default)]
#[clap(skip)]
pub guest_may_inherit_a_terminal: bool,
#[serde(default)]
#[clap(skip)]
pub in_guest_detlog_forward_policy: Option<String>,
#[serde(default)]
#[clap(skip)]
pub in_guest_site_patching_off: bool,
#[serde(default)]
#[clap(skip)]
pub launch_image: Option<LaunchImage>,
#[serde(default)]
#[clap(skip)]
pub inherited_seccomp: InheritedSeccomp,
#[clap(
long,
env = "HERMIT_EPOCH",
value_name = "YYYY-MM-DDThh:mm:ssZ",
default_value = DEFAULT_EPOCH_STR,
hide_default_value = true
)]
pub epoch: DateTime<Utc>,
#[clap(
long = "seed",
env = "HERMIT_PRNG",
default_value = "0",
value_name = "uint64"
)]
pub seed: u64,
#[clap(long, value_name = "uint64")]
pub rng_seed: Option<u64>,
#[clap(long, value_name = "uint64")]
pub fuzz_seed: Option<u64>,
#[clap(long, value_name = "float")]
pub clock_multiplier: Option<f64>,
#[clap(long = "no-virtualize-metadata", action = clap::ArgAction::SetFalse)]
pub virtualize_metadata: bool,
#[serde(default)]
#[clap(skip)]
pub mountinfo_root_rewrites: Vec<MountInfoRootRewrite>,
#[serde(default)]
#[clap(skip)]
pub mountinfo_device_rewrites: Vec<(u64, u64)>,
#[serde(default)]
#[clap(skip)]
pub mountinfo_mount_ids: Vec<u64>,
#[serde(default)]
#[clap(skip)]
pub mountinfo_mount_ids_captured: bool,
#[serde(default)]
#[clap(skip)]
pub mountinfo_mount_namespace: Option<MountNamespaceIdentity>,
#[serde(default)]
#[clap(skip)]
pub mount_id_assignment_order: Vec<u64>,
#[serde(default)]
#[clap(skip)]
pub container_mount_table: Option<crate::container_mounts::ContainerMountTable>,
#[clap(long)]
pub sequentialize_threads: bool,
#[serde(default)]
#[clap(long, default_value = "child", value_name = "child|parent|random")]
pub runs_post_fork: RunsPostFork,
#[serde(default)]
#[clap(long)]
pub passthru_opt: bool,
#[clap(long)]
pub imprecise_timers: bool,
#[serde(default = "signal_state_copy_default")]
#[clap(long = "no-signal-state-copy", action = clap::ArgAction::SetFalse)]
pub signal_state_copy: bool,
#[serde(default)]
#[clap(skip)]
pub signal_delivery_check_fatal: bool,
#[clap(long)]
pub chaos: bool,
#[clap(long)]
pub fuzz_futexes: bool,
#[clap(long)]
pub chaos_target_races: bool,
#[clap(long)]
pub chaos_per_thread_slowdown: bool,
#[clap(long, default_value = "10.0", value_name = "double")]
pub chaos_slowdown_max_factor: f64,
#[clap(long, default_value = "0", value_name = "nanos")]
pub chaos_epoch_length_ns: u64,
#[clap(long)]
pub record_preemptions: bool,
#[clap(long, value_name = "filepath")]
pub record_preemptions_to: Option<PathBuf>,
#[clap(long, value_name = "filepath", conflicts_with = "replay_schedule_from")]
pub replay_preemptions_from: Option<PathBuf>,
#[clap(
long,
value_name = "filepath",
conflicts_with = "replay_preemptions_from"
)]
pub replay_schedule_from: Option<PathBuf>,
#[clap(long)]
pub replay_exhausted_panic: bool,
#[clap(long)]
pub die_on_desync: bool,
#[clap(long,
short = 's',
value_name = "index[,path]",
value_parser = parse_index_with_path)]
pub stacktrace_event: Vec<(u64, Option<PathBuf>)>,
#[clap(long, value_name = "signame")]
pub stacktrace_signal: Option<SigWrapper>,
#[clap(long)]
pub preemption_stacktrace: bool,
#[clap(long, value_name = "filepath")]
pub preemption_stacktrace_log_file: Option<PathBuf>,
#[clap(long)]
pub deterministic_io: bool,
#[clap(long)]
pub panic_on_unsupported_syscalls: bool,
#[serde(default)]
#[clap(skip)]
pub exit_on_unsupported_syscall: bool,
#[serde(default)]
#[clap(skip)]
pub shutdown_on_unsupported_syscall: bool,
#[serde(default)]
#[clap(skip)]
pub unsupported_syscall_report_fd: Option<i32>,
#[serde(default)]
#[clap(
long = "panic-on-rbc-overshoot",
visible_alias = "panic-on-rcb-overshoot"
)]
pub panic_on_rcb_overshoot: bool,
#[clap(skip)]
pub has_uts_namespace: bool,
#[clap(skip)]
pub replay_data: Option<PathBuf>,
#[clap(long)]
pub kill_daemons: bool,
#[clap(long)]
pub gdbserver: bool,
#[clap(
long,
value_name = "uint16",
help = "Port gdbserver listening on",
default_value = "1234"
)]
pub gdbserver_port: u16,
#[serde(alias = "preemption_timeout")]
#[clap(
long,
visible_alias = "preemption-timeout",
value_name = "uint64|'disabled'",
default_value = "200000000",
value_parser = parse_timeslice)]
pub max_timeslice: MaybeTimeslice,
#[serde(default)]
#[clap(long, value_name = "virtual-nanoseconds")]
pub target_timeslice: Option<NonZeroU64>,
#[serde(default)]
#[clap(long, requires = "target_timeslice")]
pub target_timeslice_syscalls_only: bool,
#[serde(default)]
#[clap(long)]
pub futex_wake_yields: bool,
#[serde(default)]
#[clap(long, value_name = "nanos")]
pub pipe_wake_latency: Option<u64>,
#[serde(default)]
#[clap(long, value_name = "virtual-nanoseconds")]
pub scheduler_turn_cost: Option<NonZeroU64>,
#[clap(long)]
pub sigint_instakill: bool,
#[clap(long)]
pub warn_non_zero_binds: bool,
#[clap(long, default_value = "none", value_name = "str")]
pub sched_heuristic: SchedHeuristic,
#[clap(long, env = "HERMIT_SCHED_SEED", value_name = "uint64")]
pub sched_seed: Option<u64>,
#[serde(default)]
#[clap(skip)]
pub network_trace: NetworkTraceConfig,
#[clap(long, default_value = "0.0", value_name = "double")]
pub sched_sticky_random_param: f64,
#[clap(skip = false)]
pub recordreplay_modes: bool,
#[serde(default)]
#[clap(skip = false)]
pub replaying: bool,
#[clap(long, value_name = "turn_N")]
pub stop_after_turn: Option<u64>,
#[clap(long, value_name = "iter_N")]
pub stop_after_iter: Option<u64>,
#[clap(long)]
pub debug_externalize_sockets: bool,
#[clap(
long,
value_name = "precise|polling|external",
default_value = "precise"
)]
pub debug_futex_mode: BlockingMode,
#[clap(long)]
pub no_rcb_time: bool,
#[clap(long)]
pub detlog_heap: bool,
#[clap(long)]
pub detlog_stack: bool,
#[clap(long)]
pub detlog_regs: bool,
#[clap(long = "no-detlog-io-buffers", action = clap::ArgAction::SetFalse)]
pub detlog_io_buffers: bool,
#[clap(long, default_value = "1", value_name = "uint64")]
pub detlog_regs_cadence: u64,
#[clap(long, default_value = "120", value_name = "uint64")]
pub sysinfo_uptime_offset: u64,
#[clap(long, default_value = "1GB", value_parser = try_parse_memory, value_name = "bytesize")]
pub memory: u64,
#[serde(default)]
#[clap(
long = "proc",
default_value = "minimal",
value_name = "minimal|standard"
)]
pub proc_level: ProcLevel,
#[clap(long, value_name = "tid:rcbs", value_parser = try_parse_numbers_with_colon)]
pub interrupt_at: Vec<(DetTid, u64)>,
#[serde(skip)]
#[clap(skip)]
pub happens_before: Option<HappensBeforeProgram>,
#[serde(default)]
#[clap(skip)]
pub record_host_inputs: bool,
#[serde(skip)]
#[clap(skip)]
pub host_input_log: Option<PathBuf>,
#[serde(skip)]
#[clap(skip)]
pub untraced_code_range: Option<(u64, u64)>,
#[serde(skip)]
#[clap(skip)]
pub fatal_core_capture: Option<FatalCoreCapture>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FatalCoreCapture {
pub dir: PathBuf,
pub file_prefix: String,
pub max_core_bytes: u64,
pub max_total_bytes: u64,
pub time_limit: std::time::Duration,
}
fn try_parse_numbers_with_colon(from_str: &str) -> anyhow::Result<(DetTid, u64)> {
if let Some((thread_id_str, time_str)) = from_str.split_once(':') {
Ok((
thread_id_str
.parse::<DetTid>()
.map_err(anyhow::Error::msg)?,
time_str.parse::<u64>().map_err(anyhow::Error::msg)?,
))
} else {
anyhow::bail!(
"unable to parse <thread_id>:<logical_time> from '{}'",
from_str
)
}
}
fn try_parse_memory(from_str: &str) -> anyhow::Result<u64> {
<bytesize::ByteSize as FromStr>::from_str(from_str)
.map(|res| res.as_u64())
.map_err(anyhow::Error::msg)
}
impl Config {
pub fn with_backend(mut self, change: impl FnOnce(&mut BackendCapabilities)) -> Self {
change(&mut self.backend);
self
}
pub fn has_default_epoch(&self) -> bool {
self.epoch == DEFAULT_EPOCH_STR.parse::<DateTime<Utc>>().unwrap()
}
pub fn capture_epoch_from_host_time(&mut self, now: SystemTime) {
self.epoch = epoch_from_host_time(now);
}
pub fn minimum_max_timeslice_nanos(&self) -> u64 {
let slowdown = if self.chaos && self.chaos_per_thread_slowdown {
self.chaos_slowdown_max_factor
} else {
1.0
};
let multiplier = self.clock_multiplier.unwrap_or(1.0) * slowdown;
((NANOS_PER_RCB * multiplier).ceil() as u64).max(NANOS_PER_RCB as u64)
}
pub fn validate_invariants(&self) {
assert!(self.sched_sticky_random_param >= 0.0);
assert!(self.sched_sticky_random_param <= 1.0);
assert!(
self.chaos_slowdown_max_factor.is_finite()
&& self.chaos_slowdown_max_factor >= 1.0
&& self.chaos_slowdown_max_factor <= RcbTimeMultiplier::MAX,
"chaos_slowdown_max_factor must be finite and in [1.0, {}], got {}",
RcbTimeMultiplier::MAX,
self.chaos_slowdown_max_factor
);
if let Some(multiplier) = self.clock_multiplier {
assert!(
multiplier.is_finite() && multiplier > 0.0,
"clock_multiplier must be finite and positive"
);
}
let minimum_max_timeslice = self.minimum_max_timeslice_nanos();
assert!(
self.max_timeslice
.is_none_or(|timeslice| u64::from(timeslice) >= minimum_max_timeslice),
"max_timeslice must be at least one RCB ({} virtual nanoseconds)",
minimum_max_timeslice
);
}
pub fn validate(&mut self) {
self.validate_invariants();
if self.record_preemptions_to.is_some() {
self.record_preemptions = true;
}
if self.replay_schedule_from.is_some() && self.replay_preemptions_from.is_some() {
panic!("Cannot set both --replay-preemptions-from and --replay-schedule-from!!");
}
if self.chaos {
self.sequentialize_threads = true;
}
if self.replay_preemptions_from.is_some() && self.imprecise_timers {
eprintln!(
"WARNING: Setting --imprecise timers with --replay-preemptions-from is probably not what you want. They won't replay precisely."
);
}
if self.stop_after_turn.is_some() && !self.sequentialize_threads {
eprintln!(
"WARNING: --stop-after-turn will have no effect if --no-sequentialize-threads is enabled"
);
self.stop_after_turn = None;
}
if self.stop_after_iter.is_some() && !self.sequentialize_threads {
eprintln!(
"WARNING: --stop-after-iter will have no effect if --no-sequentialize-threads is enabled"
);
self.stop_after_iter = None;
}
if self.debug_externalize_sockets && !self.sequentialize_threads {
eprintln!(
"WARNING: --debug-externalize-sockets will have no effect if --no-sequentialize-threads is enabled"
);
self.debug_externalize_sockets = false;
}
if !self.stacktrace_event.is_empty()
&& !self.record_preemptions
&& self.replay_schedule_from.is_none()
{
eprintln!(
"WARNING: -s/--stacktrace-event has no effect if not recording/replaying events!"
);
}
if self.preemption_stacktrace_log_file.is_some() {
self.preemption_stacktrace = true;
}
}
pub fn use_preemption_timer(&self) -> bool {
self.max_timeslice.is_some() && self.backend.delivers_preemption_timer_events
}
pub fn use_rcb_time(&self) -> bool {
self.max_timeslice.is_some() && !self.no_rcb_time
}
pub fn yields_after_futex_wake(&self, woken: u64) -> bool {
self.futex_wake_yields && woken > 0
}
pub fn scheduler_turn_charge(&self) -> Result<u64, String> {
let multiplier = self.clock_multiplier.unwrap_or(1.0);
let Some(cost) = self.scheduler_turn_cost else {
return Ok((NANOS_PER_SCHED * multiplier) as u64);
};
let cost = u64::from(cost);
if cost > MAX_SCHEDULER_TURN_COST {
return Err(format!(
"--scheduler-turn-cost must be at most {MAX_SCHEDULER_TURN_COST} virtual \
nanoseconds (received {cost})"
));
}
let charge = cost as f64 * multiplier;
if !(1.0..=MAX_SCHEDULER_TURN_COST as f64).contains(&charge) {
return Err(format!(
"--scheduler-turn-cost {cost} at --clock-multiplier {multiplier} charges {charge} \
virtual nanoseconds per scheduler turn; the charge must be at least 1, so that \
timed waits keep advancing, and at most {MAX_SCHEDULER_TURN_COST}"
));
}
Ok(charge as u64)
}
pub fn pipe_wake_latency_in_effect(&self) -> Option<u64> {
self.pipe_wake_latency.filter(|_| {
self.use_nonblocking_sockets()
&& !self.recordreplay_modes
&& self.sched_heuristic.is_priority_ordered()
})
}
pub fn use_nonblocking_sockets(&self) -> bool {
self.sequentialize_threads && !self.debug_externalize_sockets
}
pub fn should_trace_schedevent(&self) -> bool {
self.record_preemptions || self.replay_schedule_from.is_some()
}
pub fn interrupts_for_thread(&self, thread_id: DetTid) -> BTreeSet<u64> {
self.interrupt_at
.iter()
.filter_map(|(tid, time)| {
if tid.eq(&thread_id) {
Some(*time)
} else {
None
}
})
.collect::<BTreeSet<u64>>()
}
}
impl fmt::Display for Config {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if !self.virtualize_time {
write!(f, " --no-virtualize-time")?;
}
if !self.virtualize_cpuid {
write!(f, " --no-virtualize-cpuid")?;
}
if !self.cpu_profile.is_default() {
write!(f, " --cpu-profile={}", self.cpu_profile)?;
}
if !self.virtualize_metadata {
write!(f, " --no-virtualize-metadata")?;
}
if self.passthru_opt {
write!(f, " --passthru-opt")?;
}
match self.runs_post_fork {
RunsPostFork::Child => {}
RunsPostFork::Parent => write!(f, " --runs-post-fork=parent")?,
RunsPostFork::Random => write!(f, " --runs-post-fork=random")?,
}
if !self.has_default_epoch() {
write!(f, " --epoch={}", self.epoch.to_rfc3339())?;
}
if self.seed != 0 {
write!(f, " --seed={}", self.seed)?;
}
if let Some(rng_seed) = self.rng_seed {
write!(f, " --rng-seed={}", rng_seed)?;
}
if let Some(fuzz_seed) = self.fuzz_seed {
write!(f, " --fuzz-seed={}", fuzz_seed)?;
}
if self.fuzz_futexes {
write!(f, " --fuzz-futexes")?;
}
if self.chaos_target_races {
write!(f, " --chaos-target-races")?;
}
if self.chaos_per_thread_slowdown {
write!(f, " --chaos-per-thread-slowdown")?;
write!(
f,
" --chaos-slowdown-max-factor={}",
self.chaos_slowdown_max_factor
)?;
if self.chaos_epoch_length_ns > 0 {
write!(f, " --chaos-epoch-length-ns={}", self.chaos_epoch_length_ns)?;
}
}
if let Some(m) = self.clock_multiplier {
write!(f, " --clock-multiplier={}", m)?;
}
if self.imprecise_timers {
write!(f, " --imprecise-timers")?;
}
if !self.signal_state_copy {
write!(f, " --no-signal-state-copy")?;
}
if self.chaos {
write!(f, " --chaos")?;
}
if self.record_preemptions {
write!(f, " --record-preemptions")?;
}
if let Some(p) = &self.record_preemptions_to {
let s = p.to_str().expect("valid unicode path");
write!(f, " --record-preemptions-to={}", shell_words::quote(s))?;
}
if let Some(p) = &self.replay_preemptions_from {
let s = p.to_str().expect("valid unicode path");
write!(f, " --replay-preemptions-from={}", shell_words::quote(s))?;
}
if let Some(p) = &self.replay_schedule_from {
let s = p.to_str().expect("valid unicode path");
write!(f, " --replay-schedule-from={}", shell_words::quote(s))?;
}
if self.replay_exhausted_panic {
write!(f, " --replay-exhausted-panic")?;
}
if self.die_on_desync {
write!(f, " --die-on-desync")?;
}
for (index, path) in &self.stacktrace_event {
write!(f, " --stacktrace-event={}", index)?;
if let Some(p) = path {
let s = p.to_str().expect("valid unicode path");
write!(f, ",{}", shell_words::quote(s))?;
}
}
if self.preemption_stacktrace {
write!(f, " --preemption-stacktrace")?;
}
if self.panic_on_unsupported_syscalls {
write!(f, " --panic-on-unsupported-syscalls")?;
}
if self.panic_on_rcb_overshoot {
write!(f, " --panic-on-rbc-overshoot")?;
}
if self.kill_daemons {
write!(f, " --kill-daemons")?;
}
if self.gdbserver {
write!(f, " --gdbserver")?;
}
if self.gdbserver_port != 1234u16 {
write!(f, " --gdbserver-port={}", self.gdbserver_port)?;
}
match &self.max_timeslice {
Some(x) => {
if *x != NonZeroU64::new(200_000_000).unwrap() {
write!(f, " --max-timeslice={}", x)?;
}
}
None => {
write!(f, " --max-timeslice=disabled")?;
}
}
if let Some(target_timeslice) = self.target_timeslice {
write!(f, " --target-timeslice={}", target_timeslice)?;
}
if self.target_timeslice_syscalls_only {
write!(f, " --target-timeslice-syscalls-only")?;
}
if self.futex_wake_yields {
write!(f, " --futex-wake-yields")?;
}
if let Some(latency) = self.pipe_wake_latency {
write!(f, " --pipe-wake-latency={}", latency)?;
}
if let Some(cost) = self.scheduler_turn_cost {
write!(f, " --scheduler-turn-cost={}", cost)?;
}
if self.sigint_instakill {
write!(f, " --sigint-instakill")?;
}
if self.warn_non_zero_binds {
write!(f, " --warn-non-zero-binds")?;
}
match &self.sched_heuristic {
SchedHeuristic::None => {}
SchedHeuristic::ConnectBind => {
write!(f, " --sched-heuristic=connectbind")?;
}
SchedHeuristic::Random => {
write!(f, " --sched-heuristic=random")?;
}
SchedHeuristic::StickyRandom => {
write!(f, " --sched-heuristic=stickyrandom")?;
}
}
if let Some(s) = self.sched_seed {
write!(f, " --sched-seed={}", s)?;
}
if self.sched_sticky_random_param != 0.0 {
write!(
f,
" --sched-sticky-random-param={}",
self.sched_sticky_random_param
)?;
}
if let Some(t) = self.stop_after_turn {
write!(f, " --stop-after-turn={}", t)?;
}
if let Some(i) = self.stop_after_iter {
write!(f, " --stop-after-iter={}", i)?;
}
if self.debug_externalize_sockets {
write!(f, " --debug-externalize-sockets")?;
}
match &self.debug_futex_mode {
BlockingMode::External => {
write!(f, " --debug-futex-mode=external")?;
}
BlockingMode::Polling => {
write!(f, " --debug-futex-mode=polling")?;
}
BlockingMode::Precise => { }
}
if self.no_rcb_time {
write!(f, " --no-rcb-time")?;
}
if self.detlog_heap {
write!(f, " --detlog-heap")?;
}
if self.detlog_stack {
write!(f, " --detlog-stack")?;
}
if self.detlog_regs {
write!(f, " --detlog-regs")?;
}
if self.detlog_regs_cadence != 1 {
write!(f, " --detlog-regs-cadence={}", self.detlog_regs_cadence)?;
}
if !self.detlog_io_buffers {
write!(f, " --no-detlog-io-buffers")?;
}
if self.sysinfo_uptime_offset != 120 {
write!(f, " --sysinfo-uptime-offset={}", self.sysinfo_uptime_offset)?;
}
if self.memory != 1_000_000_000 {
write!(f, " --memory={}", self.memory)?;
}
match self.proc_level {
ProcLevel::Minimal => {}
ProcLevel::Standard => write!(f, " --proc=standard")?,
}
for (tid, rcb) in &self.interrupt_at {
write!(f, " --interrupt-at={}:{}", tid, rcb)?;
}
Ok(())
}
}
#[derive(
Debug,
Default,
Clone,
Copy,
Serialize,
Deserialize,
Parser,
PartialEq,
Eq,
PartialOrd,
Ord
)]
pub enum ProcLevel {
#[default]
Minimal,
Standard,
}
impl FromStr for ProcLevel {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"minimal" => Ok(Self::Minimal),
"standard" => Ok(Self::Standard),
_ => Err(format!(
"Expected minimal|standard, could not parse: {:?}",
s
)),
}
}
}
#[derive(
Debug,
Default,
Clone,
Copy,
Serialize,
Deserialize,
Parser,
PartialEq,
Eq
)]
pub enum RunsPostFork {
#[default]
Child,
Parent,
Random,
}
impl FromStr for RunsPostFork {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"child" => Ok(Self::Child),
"parent" => Ok(Self::Parent),
"random" => Ok(Self::Random),
_ => Err(format!(
"Expected Child|Parent|Random, could not parse: {:?}",
s
)),
}
}
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, Parser, PartialEq, Eq)]
pub enum BlockingMode {
External,
Polling,
Precise,
}
impl FromStr for BlockingMode {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"polling" => Ok(BlockingMode::Polling),
"precise" => Ok(BlockingMode::Precise),
"external" => Ok(BlockingMode::External),
_ => Err(format!(
"Expected Polling|Precise|External, could not parse: {:?}",
s
)),
}
}
}
#[derive(
Debug,
Default,
Clone,
Copy,
Serialize,
Deserialize,
Parser,
PartialEq,
Eq
)]
pub enum SchedHeuristic {
#[default]
None,
ConnectBind,
Random,
StickyRandom,
}
impl SchedHeuristic {
pub fn is_priority_ordered(self) -> bool {
matches!(self, SchedHeuristic::None | SchedHeuristic::ConnectBind)
}
}
impl FromStr for SchedHeuristic {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"none" | "roundrobin" => Ok(SchedHeuristic::None),
"connectbind" => Ok(SchedHeuristic::ConnectBind),
"random" => Ok(SchedHeuristic::Random),
"stickyrandom" => Ok(SchedHeuristic::StickyRandom),
_ => Err(format!(
"Expected None|ConnectBind|Random|StickyRandom, could not parse: {:?}",
s
)),
}
}
}
pub type MaybeTimeslice = Option<NonZeroU64>;
#[deprecated(note = "use MaybeTimeslice")]
pub type MaybePreemptionTimeout = MaybeTimeslice;
fn parse_timeslice(src: &str) -> Result<MaybeTimeslice, ParseTimesliceError> {
if let Ok(n) = src.parse::<u64>() {
if n != 0 && n < NANOS_PER_RCB as u64 {
Err(ParseTimesliceError::new(
"PMU-backed timeslices must be at least one RCB (10 virtual nanoseconds)",
))
} else {
Ok(NonZeroU64::new(n))
}
} else {
match src {
"disabled" => Ok(None),
_ => Err(ParseTimesliceError::new(
"Unable to parse timeslice, expected disabled or a non-negative integer",
)),
}
}
}
fn parse_index_with_path(src: &str) -> Result<(u64, Option<PathBuf>), String> {
let convert = |e| format!("Failed to parse int index before comma: {e}");
if let Some((index_str, path)) = src.split_once(',') {
let ix = index_str.parse::<u64>().map_err(convert)?;
let pathbuf = PathBuf::from_str(path).map_err(|_| "the impossible happened")?;
Ok((ix, Some(pathbuf)))
} else {
let ix = src.parse::<u64>().map_err(convert)?;
Ok((ix, None))
}
}
#[derive(Debug)]
struct ParseTimesliceError {
details: String,
}
impl fmt::Display for ParseTimesliceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.details)
}
}
impl ParseTimesliceError {
fn new(msg: &str) -> ParseTimesliceError {
ParseTimesliceError {
details: msg.to_string(),
}
}
}
impl std::error::Error for ParseTimesliceError {
fn description(&self) -> &str {
&self.details
}
}
pub static DEFAULT_EPOCH_STR: &str = "2026-01-01T00:00:00Z";
pub use crate::canonical_test_epoch::CANONICAL_TEST_EPOCH;
pub use crate::canonical_test_epoch::CANONICAL_TEST_EPOCH_ARG;
pub fn epoch_from_host_time(now: SystemTime) -> DateTime<Utc> {
DateTime::<Utc>::from(now)
}
impl Config {
pub fn from_env() -> Self {
let args: [OsString; 2] = [
OsString::from("CMD"), OsString::from(format!("--epoch={}", DEFAULT_EPOCH_STR)),
];
Config::parse_from(args.iter())
}
pub fn rng_seed(&self) -> u64 {
self.rng_seed.unwrap_or(self.seed)
}
pub fn fuzz_seed(&self) -> u64 {
self.fuzz_seed.unwrap_or(self.seed)
}
pub fn sched_seed(&self) -> u64 {
self.sched_seed.unwrap_or(self.seed)
}
}
pub const MAX_SCHEDULER_TURN_COST: u64 = 1_000_000_000;
pub const CONFIG_FINGERPRINT_ENV: &str = "REVERIE_SABRE_HERMIT_CONFIG_FINGERPRINT";
pub const LITEINST_CONFIG_FINGERPRINT_ENV: &str = "HERMIT_LITEINST_CONFIG_FINGERPRINT";
const CONFIG_DEFINITION_SOURCES: &[&[u8]] = &[
include_bytes!("config.rs"),
include_bytes!("fd.rs"),
include_bytes!("happens_before.rs"),
include_bytes!("network_trace.rs"),
include_bytes!("pid.rs"),
include_bytes!("schedule.rs"),
include_bytes!("time.rs"),
];
fn config_wire_default() -> Config {
let mut config = Config::parse_from([
"config-wire-fingerprint",
&format!("--epoch={DEFAULT_EPOCH_STR}"),
"--seed=0",
"--sched-seed=0",
]);
config.sched_seed = None;
config.backend = BackendCapabilities::KVM;
config
}
pub fn config_wire_fingerprint() -> String {
let config = config_wire_default();
let wire = bincode::serde::encode_to_vec(&config, bincode::config::legacy())
.expect("canonical Config wire default must encode with Reverie's bincode configuration");
let named_shape = serde_json::to_string(&config)
.expect("canonical Config wire default must encode as JSON for field-name checking");
fingerprint_of_config_material(&wire, &named_shape, CONFIG_DEFINITION_SOURCES)
}
pub fn config_fingerprint_mismatch(expected: &std::ffi::OsStr) -> Option<String> {
let ours = config_wire_fingerprint();
(expected.to_str() != Some(ours.as_str())).then(|| {
format!(
"its configuration and clock RPC fingerprint is {ours}, Hermit's is {}",
expected.to_string_lossy()
)
})
}
fn fingerprint_of_config_material(
wire: &[u8],
named_shape: &str,
definition_sources: &[&[u8]],
) -> String {
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
let mut update = |domain: u8, bytes: &[u8]| {
for byte in std::iter::once(&domain)
.chain((bytes.len() as u64).to_le_bytes().iter())
.chain(bytes.iter())
{
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(0x1000_0000_01b3);
}
};
update(0, wire);
update(1, named_shape.as_bytes());
for source in definition_sources {
update(2, source);
}
format!("{hash:016x}")
}
fn signal_state_copy_default() -> bool {
true
}
impl Default for Config {
fn default() -> Self {
let v: Vec<String> = vec![];
Config::parse_from(v.iter())
}
}
pub fn to_legacy_backend_json(config: &Config) -> serde_json::Result<String> {
let mut json = Vec::with_capacity(4096);
let mut serializer = serde_json::Serializer::new(&mut json);
config.serialize(legacy_backend_json::ConfigSerializer {
inner: &mut serializer,
config,
})?;
String::from_utf8(json).map_err(serde::ser::Error::custom)
}
fn legacy_backend_keys(config: &Config) -> [(&'static str, bool); 15] {
let backend = &config.backend;
[
("cpuid_virtualized_by_backend", false),
("backend_supports_madvise", backend.supports_madvise),
(
"discover_live_file_metadata",
backend.tool_shares_guest_descriptor_table,
),
(
"detect_host_clock_futex_timeouts",
backend.guest_clock_reads_bypass_backend,
),
(
"syscall_clobbers_virtualized_by_backend",
backend.virtualizes_syscall_clobbers,
),
(
"cancel_killed_thread_rpcs",
backend.needs_killed_thread_rpc_cancellation,
),
(
"backend_reports_physical_process_exits",
backend.reports_physical_process_exits,
),
(
"backend_tracks_process_children",
backend.tracks_process_children,
),
(
"backend_runs_exit_robust_list",
backend.runs_exit_robust_list,
),
(
"backend_requires_thread_directed_process_signals",
backend.requires_thread_directed_process_signals,
),
("backend_is_kvm", backend.provides_process_signal_control),
(
"kvm_shared_dequeue_timers",
backend.provides_process_signal_control && config.sequentialize_threads,
),
(
"backend_supports_parked_write_signal_interruption",
backend.supports_parked_write_signal_interruption,
),
("backend_virtualizes_capability_prctls", false),
(
"backend_defers_vfork_child_registration",
backend.defers_vfork_child_registration,
),
]
}
pub fn from_legacy_backend_json(json: &str) -> serde_json::Result<Config> {
let mut deserializer = serde_json::Deserializer::from_str(json);
let (mut config, legacy) = serde::Deserializer::deserialize_struct(
&mut deserializer,
"Config",
&[],
legacy_backend_json::LegacyConfigVisitor,
)?;
deserializer.end()?;
if legacy.cpuid_virtualized_by_backend {
return Err(<serde_json::Error as serde::de::Error>::custom(
"cpuid_virtualized_by_backend is true, but no backend installs a CPUID \
policy of its own; the key must be false or absent",
));
}
if legacy.backend_virtualizes_capability_prctls {
return Err(<serde_json::Error as serde::de::Error>::custom(
"backend_virtualizes_capability_prctls is true, but no backend answers the \
capability prctls itself; the key must be false or absent",
));
}
let controlled = legacy.backend_is_kvm && config.sequentialize_threads;
if legacy.kvm_shared_dequeue_timers != controlled {
return Err(<serde_json::Error as serde::de::Error>::custom(
format_args!(
"kvm_shared_dequeue_timers is {} but backend_is_kvm && \
sequentialize_threads is {controlled}; the key is no longer an \
independent setting and must equal that conjunction",
legacy.kvm_shared_dequeue_timers,
),
));
}
config.backend = legacy.capabilities();
Ok(config)
}
pub fn encode_backend_config_json(
legacy_json: String,
backend: BackendCapabilities,
) -> serde_json::Result<String> {
if from_legacy_backend_json(&legacy_json)?.backend == backend {
return Ok(legacy_json);
}
serde_json::to_string(&VersionedBackendConfig {
dbt_config_version: 1,
config: serde_json::from_str(&legacy_json)?,
backend,
})
}
pub fn decode_backend_config_json(json: &str) -> serde_json::Result<Config> {
if let Ok(config) = from_legacy_backend_json(json) {
return Ok(config);
}
let envelope: VersionedBackendConfig<'_> = serde_json::from_str(json)?;
if envelope.dbt_config_version != 1 {
return Err(<serde_json::Error as serde::de::Error>::custom(
format_args!(
"unsupported DBT configuration version {}",
envelope.dbt_config_version
),
));
}
let mut config = from_legacy_backend_json(envelope.config.get())?;
config.backend = envelope.backend;
Ok(config)
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct VersionedBackendConfig<'a> {
dbt_config_version: u32,
#[serde(borrow)]
config: &'a serde_json::value::RawValue,
backend: BackendCapabilities,
}
const LEGACY_BACKEND_KEY_NAMES: [&str; 15] = [
"cpuid_virtualized_by_backend",
"backend_supports_madvise",
"discover_live_file_metadata",
"detect_host_clock_futex_timeouts",
"syscall_clobbers_virtualized_by_backend",
"cancel_killed_thread_rpcs",
"backend_reports_physical_process_exits",
"backend_tracks_process_children",
"backend_runs_exit_robust_list",
"backend_requires_thread_directed_process_signals",
"backend_is_kvm",
"kvm_shared_dequeue_timers",
"backend_supports_parked_write_signal_interruption",
"backend_virtualizes_capability_prctls",
"backend_defers_vfork_child_registration",
];
const fn legacy_backend_key_default_true() -> bool {
true
}
#[derive(Deserialize)]
struct LegacyBackendKeys {
#[serde(default)]
cpuid_virtualized_by_backend: bool,
#[serde(default = "legacy_backend_key_default_true")]
backend_supports_madvise: bool,
#[serde(default)]
discover_live_file_metadata: bool,
#[serde(default)]
detect_host_clock_futex_timeouts: bool,
#[serde(default)]
syscall_clobbers_virtualized_by_backend: bool,
#[serde(default)]
cancel_killed_thread_rpcs: bool,
#[serde(default)]
backend_reports_physical_process_exits: bool,
#[serde(default = "legacy_backend_key_default_true")]
backend_tracks_process_children: bool,
#[serde(default = "legacy_backend_key_default_true")]
backend_runs_exit_robust_list: bool,
#[serde(default)]
backend_requires_thread_directed_process_signals: bool,
#[serde(default)]
backend_is_kvm: bool,
#[serde(default)]
kvm_shared_dequeue_timers: bool,
#[serde(default = "legacy_backend_key_default_true")]
backend_supports_parked_write_signal_interruption: bool,
#[serde(default)]
backend_virtualizes_capability_prctls: bool,
#[serde(default)]
backend_defers_vfork_child_registration: bool,
}
impl LegacyBackendKeys {
fn capabilities(&self) -> BackendCapabilities {
let mut backend = BackendCapabilities::PTRACE;
backend.tool_shares_guest_descriptor_table = self.discover_live_file_metadata;
backend.rediscovers_descriptors_after_exec = self.discover_live_file_metadata;
backend.internal_pipe_turns_are_host_timed = self.discover_live_file_metadata;
backend.loopback_pollers_yield_to_peers = self.discover_live_file_metadata;
backend.guest_clock_reads_bypass_backend = self.detect_host_clock_futex_timeouts;
backend.virtualizes_syscall_clobbers = self.syscall_clobbers_virtualized_by_backend;
backend.needs_killed_thread_rpc_cancellation = self.cancel_killed_thread_rpcs;
backend.reports_child_exit_publication = !self.cancel_killed_thread_rpcs;
backend.reports_kernel_child_exit_signals = backend.reports_child_exit_publication;
backend.reports_physical_process_exits = self.backend_reports_physical_process_exits;
backend.signal_interrupts_external_syscalls = self.backend_reports_physical_process_exits;
backend.tracks_process_children = self.backend_tracks_process_children;
backend.runs_exit_robust_list = self.backend_runs_exit_robust_list;
backend.requires_thread_directed_process_signals =
self.backend_requires_thread_directed_process_signals;
backend.supports_parked_write_signal_interruption =
self.backend_supports_parked_write_signal_interruption;
backend.defers_vfork_child_registration = self.backend_defers_vfork_child_registration;
backend.supports_madvise = self.backend_supports_madvise;
backend.supports_madv_dontneed = self.backend_supports_madvise || self.backend_is_kvm;
backend.provides_process_signal_control = self.backend_is_kvm;
backend.emulates_child_waits = self.backend_is_kvm;
backend.promotes_open_files_before_native_lifecycle =
self.backend_requires_thread_directed_process_signals;
backend.supports_blocked_wait_signal_interruption = false;
backend.reports_sigreturns = false;
backend.delivers_preemption_timer_events = false;
backend.runs_guest_code_between_injections = false;
backend
}
}
mod legacy_backend_json {
use std::fmt;
use serde::Deserialize;
use serde::Serialize;
use serde::de;
use serde::de::DeserializeSeed;
use serde::de::IgnoredAny;
use serde::de::MapAccess;
use serde::de::SeqAccess;
use serde::de::Visitor;
use serde::de::value::BoolDeserializer;
use serde::de::value::MapAccessDeserializer;
use serde::de::value::MapDeserializer;
use serde::de::value::SeqAccessDeserializer;
use serde::de::value::StringDeserializer;
use serde::ser::Error as _;
use serde::ser::Impossible;
use serde::ser::SerializeStruct;
use serde::ser::Serializer;
use super::BackendCapabilities;
use super::Config;
use super::LEGACY_BACKEND_KEY_NAMES;
use super::LegacyBackendKeys;
use super::legacy_backend_keys;
const FIELDS_WITHOUT_A_LEGACY_KEY: [&str; 18] = [
"backend",
"record_host_inputs",
"guest_may_inherit_a_terminal",
"in_guest_detlog_forward_policy",
"in_guest_site_patching_off",
"launch_image",
"target_timeslice_syscalls_only",
"futex_wake_yields",
"pipe_wake_latency",
"replaying",
"scheduler_turn_cost",
"inherited_seccomp",
"cpu_profile",
"cpu_profile_host",
"signal_state_copy",
"container_mount_table",
"mountinfo_mount_namespace",
"signal_delivery_check_fatal",
];
pub(super) struct LegacyConfigVisitor;
impl<'de> Visitor<'de> for LegacyConfigVisitor {
type Value = (Config, LegacyBackendKeys);
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("struct Config")
}
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
let mut legacy = Vec::new();
let config = Config::deserialize(MapAccessDeserializer::new(LegacyKeys {
inner: map,
legacy: &mut legacy,
}))?;
Ok((config, legacy_backend_keys_from(legacy)?))
}
fn visit_seq<A: SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> {
let fields = config_field_order().map_err(<A::Error as de::Error>::custom)?;
let mut legacy = Vec::new();
let config = Config::deserialize(SeqAccessDeserializer::new(LegacyPositions {
inner: seq,
fields: fields.iter(),
legacy: &mut legacy,
}))?;
Ok((config, legacy_backend_keys_from(legacy)?))
}
}
fn legacy_backend_keys_from<E: de::Error>(
legacy: Vec<(&'static str, bool)>,
) -> Result<LegacyBackendKeys, E> {
LegacyBackendKeys::deserialize(MapDeserializer::<_, E>::new(legacy.into_iter()))
}
struct LegacyKeys<'l, A> {
inner: A,
legacy: &'l mut Vec<(&'static str, bool)>,
}
impl<'de, A: MapAccess<'de>> MapAccess<'de> for LegacyKeys<'_, A> {
type Error = A::Error;
fn next_key_seed<K: DeserializeSeed<'de>>(
&mut self,
seed: K,
) -> Result<Option<K::Value>, A::Error> {
while let Some(key) = self.inner.next_key::<String>()? {
if let Some(name) = LEGACY_BACKEND_KEY_NAMES
.into_iter()
.find(|name| *name == key)
{
let value = self.inner.next_value::<bool>()?;
self.legacy.push((name, value));
} else if FIELDS_WITHOUT_A_LEGACY_KEY.contains(&key.as_str()) {
self.inner.next_value::<IgnoredAny>()?;
} else {
return seed.deserialize(StringDeserializer::new(key)).map(Some);
}
}
Ok(None)
}
fn next_value_seed<V: DeserializeSeed<'de>>(
&mut self,
seed: V,
) -> Result<V::Value, A::Error> {
self.inner.next_value_seed(seed)
}
}
struct LegacyPositions<'f, 'l, A> {
inner: A,
fields: std::slice::Iter<'f, String>,
legacy: &'l mut Vec<(&'static str, bool)>,
}
impl<'de, A: SeqAccess<'de>> SeqAccess<'de> for LegacyPositions<'_, '_, A> {
type Error = A::Error;
fn next_element_seed<T: DeserializeSeed<'de>>(
&mut self,
seed: T,
) -> Result<Option<T::Value>, A::Error> {
match self.fields.next().map(String::as_str) {
Some("backend") => {
for name in LEGACY_BACKEND_KEY_NAMES {
match self.inner.next_element::<bool>()? {
Some(value) => self.legacy.push((name, value)),
None => break,
}
}
let placeholder = serde_json::to_value(BackendCapabilities::PTRACE)
.map_err(<A::Error as de::Error>::custom)?;
seed.deserialize(placeholder)
.map(Some)
.map_err(<A::Error as de::Error>::custom)
}
Some(
"record_host_inputs"
| "guest_may_inherit_a_terminal"
| "in_guest_site_patching_off"
| "target_timeslice_syscalls_only"
| "futex_wake_yields"
| "replaying"
| "signal_delivery_check_fatal",
) => seed.deserialize(BoolDeserializer::new(false)).map(Some),
Some("signal_state_copy") => {
seed.deserialize(BoolDeserializer::new(true)).map(Some)
}
Some(
"in_guest_detlog_forward_policy"
| "launch_image"
| "scheduler_turn_cost"
| "pipe_wake_latency"
| "container_mount_table"
| "mountinfo_mount_namespace",
) => seed
.deserialize(serde_json::Value::Null)
.map(Some)
.map_err(<A::Error as de::Error>::custom),
Some("cpu_profile") => {
let v2 = serde_json::to_value(crate::cpu_profile::CpuProfile::X86_64V2)
.map_err(<A::Error as de::Error>::custom)?;
seed.deserialize(v2)
.map(Some)
.map_err(<A::Error as de::Error>::custom)
}
Some("cpu_profile_host") => seed
.deserialize(serde_json::Value::Null)
.map(Some)
.map_err(<A::Error as de::Error>::custom),
Some("inherited_seccomp") => {
let unknown = serde_json::to_value(super::InheritedSeccomp::Unknown)
.map_err(<A::Error as de::Error>::custom)?;
seed.deserialize(unknown)
.map(Some)
.map_err(<A::Error as de::Error>::custom)
}
_ => self.inner.next_element_seed(seed),
}
}
}
fn config_field_order() -> serde_json::Result<Vec<String>> {
let config = environment_free_config().map_err(<serde_json::Error as de::Error>::custom)?;
let json = serde_json::to_string(&config)?;
Ok(serde_json::from_str::<KeyOrder>(&json)?.0)
}
fn environment_free_config() -> Result<Config, clap::Error> {
use clap::CommandFactory;
use clap::FromArgMatches;
let matches = Config::command()
.mut_args(|arg| arg.env(None::<&'static str>))
.try_get_matches_from(["config-field-order"])?;
Config::from_arg_matches(&matches)
}
pub(super) struct KeyOrder(pub(super) Vec<String>);
impl<'de> Deserialize<'de> for KeyOrder {
fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct KeyOrderVisitor;
impl<'de> Visitor<'de> for KeyOrderVisitor {
type Value = KeyOrder;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a JSON object")
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<KeyOrder, A::Error> {
let mut keys = Vec::new();
while let Some(key) = map.next_key::<String>()? {
map.next_value::<IgnoredAny>()?;
keys.push(key);
}
Ok(KeyOrder(keys))
}
}
deserializer.deserialize_map(KeyOrderVisitor)
}
}
pub(super) struct ConfigSerializer<'c, S> {
pub(super) inner: S,
pub(super) config: &'c Config,
}
pub(super) struct ConfigFields<'c, S> {
inner: S,
config: &'c Config,
wrote_backend_keys: bool,
}
fn not_a_config<E: serde::ser::Error>() -> E {
E::custom("the legacy backend JSON encoding applies only to a Detcore Config")
}
impl<'c, S: Serializer> Serializer for ConfigSerializer<'c, S> {
type Ok = S::Ok;
type Error = S::Error;
type SerializeSeq = Impossible<S::Ok, S::Error>;
type SerializeTuple = Impossible<S::Ok, S::Error>;
type SerializeTupleStruct = Impossible<S::Ok, S::Error>;
type SerializeTupleVariant = Impossible<S::Ok, S::Error>;
type SerializeMap = Impossible<S::Ok, S::Error>;
type SerializeStruct = ConfigFields<'c, S::SerializeStruct>;
type SerializeStructVariant = Impossible<S::Ok, S::Error>;
fn is_human_readable(&self) -> bool {
self.inner.is_human_readable()
}
fn serialize_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, S::Error> {
let len = len + legacy_backend_keys(self.config).len() - 2;
Ok(ConfigFields {
inner: self.inner.serialize_struct(name, len)?,
config: self.config,
wrote_backend_keys: false,
})
}
fn serialize_bool(self, _: bool) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_i8(self, _: i8) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_i16(self, _: i16) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_i32(self, _: i32) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_i64(self, _: i64) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_u8(self, _: u8) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_u16(self, _: u16) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_u32(self, _: u32) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_u64(self, _: u64) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_f32(self, _: f32) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_f64(self, _: f64) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_char(self, _: char) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_str(self, _: &str) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_bytes(self, _: &[u8]) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_none(self) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_some<T: ?Sized + Serialize>(self, _: &T) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_unit(self) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_unit_struct(self, _: &'static str) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_unit_variant(
self,
_: &'static str,
_: u32,
_: &'static str,
) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
_: &'static str,
_: &T,
) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
_: &'static str,
_: u32,
_: &'static str,
_: &T,
) -> Result<S::Ok, S::Error> {
Err(not_a_config())
}
fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, S::Error> {
Err(not_a_config())
}
fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, S::Error> {
Err(not_a_config())
}
fn serialize_tuple_struct(
self,
_: &'static str,
_: usize,
) -> Result<Self::SerializeTupleStruct, S::Error> {
Err(not_a_config())
}
fn serialize_tuple_variant(
self,
_: &'static str,
_: u32,
_: &'static str,
_: usize,
) -> Result<Self::SerializeTupleVariant, S::Error> {
Err(not_a_config())
}
fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, S::Error> {
Err(not_a_config())
}
fn serialize_struct_variant(
self,
_: &'static str,
_: u32,
_: &'static str,
_: usize,
) -> Result<Self::SerializeStructVariant, S::Error> {
Err(not_a_config())
}
}
impl<S: SerializeStruct> SerializeStruct for ConfigFields<'_, S> {
type Ok = S::Ok;
type Error = S::Error;
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), S::Error> {
match key {
"backend" => {
for (legacy_key, legacy_value) in legacy_backend_keys(self.config) {
self.inner.serialize_field(legacy_key, &legacy_value)?;
}
self.wrote_backend_keys = true;
Ok(())
}
"record_host_inputs"
| "guest_may_inherit_a_terminal"
| "in_guest_detlog_forward_policy"
| "in_guest_site_patching_off"
| "launch_image"
| "target_timeslice_syscalls_only"
| "futex_wake_yields"
| "pipe_wake_latency"
| "replaying"
| "scheduler_turn_cost"
| "inherited_seccomp"
| "cpu_profile"
| "cpu_profile_host"
| "signal_state_copy"
| "container_mount_table"
| "mountinfo_mount_namespace"
| "signal_delivery_check_fatal" => Ok(()),
_ => self.inner.serialize_field(key, value),
}
}
fn skip_field(&mut self, key: &'static str) -> Result<(), S::Error> {
self.inner.skip_field(key)
}
fn end(self) -> Result<S::Ok, S::Error> {
if !self.wrote_backend_keys {
return Err(S::Error::custom(
"Config serialized no `backend` field to replace with the legacy backend keys",
));
}
self.inner.end()
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_epoch_is_2026() {
assert_eq!(DEFAULT_EPOCH_STR, "2026-01-01T00:00:00Z");
let epoch = DEFAULT_EPOCH_STR.parse::<DateTime<Utc>>().unwrap();
assert_eq!(epoch.timestamp(), 1_767_225_600);
}
#[test]
fn resolved_epoch_is_serialized_as_an_exact_config_input() {
let epoch = "2000-12-31T23:59:59.123456789Z"
.parse::<DateTime<Utc>>()
.unwrap();
let config = Config {
epoch,
..Config::default()
};
let encoded = serde_json::to_value(&config).unwrap();
assert_eq!(
encoded["epoch"],
serde_json::json!("2000-12-31T23:59:59.123456789Z")
);
let decoded: Config = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded.epoch, epoch);
}
#[test]
fn default_backend_capabilities_match_instrumented_backends() {
let config = Config::default();
assert_eq!(config.backend, DEFAULT_BACKEND_CAPABILITIES);
assert!(!config.backend.reports_physical_process_exits);
assert!(config.backend.tracks_process_children);
assert!(config.backend.runs_exit_robust_list);
assert!(!config.backend.requires_thread_directed_process_signals);
assert!(config.backend.supports_parked_write_signal_interruption);
assert!(!config.backend.defers_vfork_child_registration);
assert!(!config.sequentialize_threads);
assert!(
legacy_backend_keys(&config).contains(&("kvm_shared_dequeue_timers", false)),
"the default configuration must not write a controlled-run legacy key"
);
assert!(!config.backend.supports_blocked_wait_signal_interruption);
assert!(!config.backend.delivers_preemption_timer_events);
assert!(!config.backend.runs_guest_code_between_injections);
assert!(!config.guest_may_inherit_a_terminal);
assert!(config.in_guest_detlog_forward_policy.is_none());
assert!(!config.in_guest_site_patching_off);
assert!(config.launch_image.is_none());
}
#[test]
fn a_config_without_backend_capabilities_deserializes_as_ptrace() {
let mut encoded = serde_json::to_value(Config::default()).unwrap();
let fields = encoded.as_object_mut().unwrap();
assert!(fields.remove("backend").is_some());
assert!(!fields.contains_key("shared_dequeue_timers"));
let decoded: Config = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded.backend, DEFAULT_BACKEND_CAPABILITIES);
}
#[test]
fn a_saved_shared_dequeue_timers_field_is_ignored() {
let baseline = serde_json::to_string(&Config::default()).unwrap();
for extra in [
r#""shared_dequeue_timers":false"#,
r#""shared_dequeue_timers":true"#,
r#""shared_dequeue_timers":"yes""#,
r#""shared_dequeue_timers":true,"shared_dequeue_timers":false"#,
] {
let edited = baseline.replacen('{', &format!("{{{extra},"), 1);
let decoded: Config = serde_json::from_str(&edited).unwrap();
assert_eq!(
serde_json::to_string(&decoded).unwrap(),
baseline,
"{edited}"
);
}
}
fn ptrace_without_exit_transitions() -> BackendCapabilities {
let mut backend = BackendCapabilities::PTRACE;
backend.runs_exit_robust_list = false;
backend.supports_parked_write_signal_interruption = false;
backend
}
fn legacy_expressible(mut backend: BackendCapabilities) -> BackendCapabilities {
backend.process_exits_complete_asynchronously = false;
backend.virtualizes_guest_sigalrm = false;
backend.supports_blocked_wait_signal_interruption = false;
backend.delivers_preemption_timer_events = false;
backend.runs_guest_code_between_injections = false;
backend.reports_sigreturns = false;
backend.reports_kernel_child_exit_signals = backend.reports_child_exit_publication;
backend.rediscovers_descriptors_after_exec = backend.tool_shares_guest_descriptor_table;
backend.promotes_open_files_before_native_lifecycle =
backend.requires_thread_directed_process_signals;
backend.internal_pipe_turns_are_host_timed = backend.tool_shares_guest_descriptor_table;
backend.loopback_pollers_yield_to_peers = backend.tool_shares_guest_descriptor_table;
backend
}
#[test]
fn legacy_backend_json_round_trips_every_backend_capabilities_constant() {
for (name, backend) in [
("PTRACE", BackendCapabilities::PTRACE),
("E9PATCH", BackendCapabilities::E9PATCH),
(
"ptrace without exit transitions",
ptrace_without_exit_transitions(),
),
("LITEINST_IN_GUEST", BackendCapabilities::LITEINST_IN_GUEST),
("SABRE", BackendCapabilities::SABRE),
("DBT", BackendCapabilities::DBT),
("KVM", BackendCapabilities::KVM),
] {
for sequentialize_threads in [false, true] {
let sent = Config {
backend,
sequentialize_threads,
..Config::default()
};
let json = to_legacy_backend_json(&sent).unwrap();
let received = from_legacy_backend_json(&json).unwrap();
assert_eq!(received.backend, legacy_expressible(backend), "{name}");
assert_eq!(
received.sequentialize_threads, sequentialize_threads,
"{name}"
);
assert_controlled_key(&json, &backend, sequentialize_threads, name);
let expressible = Config {
backend: legacy_expressible(backend),
..sent.clone()
};
assert_eq!(
serde_json::to_string(&received).unwrap(),
serde_json::to_string(&expressible).unwrap(),
"{name}"
);
assert_eq!(to_legacy_backend_json(&received).unwrap(), json, "{name}");
assert_controlled_key_is_checked(&json, &sent, name);
}
}
}
#[test]
fn backend_config_json_preserves_every_backend_and_representable_bytes() {
for (name, backend, needs_envelope) in [
("PTRACE", BackendCapabilities::PTRACE, true),
("E9PATCH", BackendCapabilities::E9PATCH, true),
(
"LITEINST_IN_GUEST",
BackendCapabilities::LITEINST_IN_GUEST,
true,
),
("SABRE", BackendCapabilities::SABRE, true),
("DBT", BackendCapabilities::DBT, true),
("KVM", BackendCapabilities::KVM, false),
] {
for sequentialize_threads in [false, true] {
let sent = Config {
backend,
sequentialize_threads,
..Config::default()
};
let legacy = to_legacy_backend_json(&sent).unwrap();
let encoded = encode_backend_config_json(legacy.clone(), backend).unwrap();
assert_eq!(encoded != legacy, needs_envelope, "{name}");
assert_eq!(
from_legacy_backend_json(&encoded).is_err(),
needs_envelope,
"{name}: an envelope must not be accepted as a legacy config"
);
let received = decode_backend_config_json(&encoded).unwrap();
assert_eq!(received.backend, backend, "{name}");
assert_eq!(
serde_json::to_string(&received).unwrap(),
serde_json::to_string(&sent).unwrap(),
"{name}"
);
}
}
}
#[test]
fn backend_config_json_round_trips_each_independent_capability() {
let baseline = serde_json::to_value(BackendCapabilities::DBT).unwrap();
for (name, value) in baseline.as_object().unwrap() {
let mut edited = baseline.clone();
edited[name] = serde_json::Value::Bool(!value.as_bool().unwrap());
let backend = serde_json::from_value(edited).unwrap();
let sent = Config {
backend,
..Config::default()
};
let legacy = to_legacy_backend_json(&sent).unwrap();
let encoded = encode_backend_config_json(legacy, backend).unwrap();
let received = decode_backend_config_json(&encoded).unwrap();
assert_eq!(received.backend, backend, "{name}");
}
}
#[test]
fn backend_config_json_requires_each_typed_capability_once() {
let sent = Config {
backend: BackendCapabilities::LITEINST_IN_GUEST,
..Config::default()
};
let encoded =
encode_backend_config_json(to_legacy_backend_json(&sent).unwrap(), sent.backend)
.unwrap();
let envelope: serde_json::Value = serde_json::from_str(&encoded).unwrap();
for (name, value) in envelope["backend"].as_object().unwrap() {
let mut missing = envelope.clone();
missing["backend"].as_object_mut().unwrap().remove(name);
assert!(
decode_backend_config_json(&missing.to_string()).is_err(),
"missing {name}"
);
let backend = serde_json::to_string(&sent.backend).unwrap();
let duplicate = backend.replacen('{', &format!("{{\"{name}\":{value},"), 1);
let duplicate = encoded.replace(&backend, &duplicate);
assert_ne!(duplicate, encoded);
assert!(
decode_backend_config_json(&duplicate).is_err(),
"duplicate {name}"
);
}
}
#[test]
fn backend_config_json_keeps_legacy_object_and_array_semantics() {
let legacy = to_legacy_backend_json(&Config::default()).unwrap();
let unknown_duplicates = legacy.replacen(
'{',
r#"{"unrecognized":1,"unrecognized":null,"backend":null,"backend":true,"dbt_config_version":null,"dbt_config_version":2,"#,
1,
);
let known_duplicate = legacy.replacen('{', r#"{"seed":1,"#, 1);
let mistyped = legacy.replacen("\"backend_is_kvm\":false", "\"backend_is_kvm\":null", 1);
assert_ne!(mistyped, legacy);
for json in [
legacy.clone(),
positional(&legacy),
unknown_duplicates,
known_duplicate,
mistyped,
format!("{legacy} trailing"),
"[]".to_owned(),
] {
let old = from_legacy_backend_json(&json);
let new = decode_backend_config_json(&json);
match (old, new) {
(Ok(old), Ok(new)) => assert_eq!(
serde_json::to_string(&old).unwrap(),
serde_json::to_string(&new).unwrap()
),
(Err(_), Err(_)) => {}
_ => panic!("legacy parse outcome changed for {json}"),
}
}
}
fn assert_controlled_key_is_checked(json: &str, sent: &Config, name: &str) {
let controlled = sent.backend.provides_process_signal_control && sent.sequentialize_threads;
let written = format!("\"kvm_shared_dequeue_timers\":{controlled}");
assert_eq!(json.matches(&written).count(), 1, "{name}");
for value in [None, Some(false), Some(true)] {
let edited = match value {
None => json.replacen(&format!(",{written}"), "", 1),
Some(value) => json.replacen(
&written,
&format!("\"kvm_shared_dequeue_timers\":{value}"),
1,
),
};
assert_eq!(
edited.contains("kvm_shared_dequeue_timers"),
value.is_some(),
"{name} {value:?}"
);
let case = format!(
"{name} sequentialize_threads={} key={value:?}",
sent.sequentialize_threads
);
match from_legacy_backend_json(&edited) {
Ok(received) => {
assert_eq!(value.unwrap_or(false), controlled, "{case} was accepted");
let expressible = Config {
backend: legacy_expressible(sent.backend),
..sent.clone()
};
assert_eq!(
serde_json::to_string(&received).unwrap(),
serde_json::to_string(&expressible).unwrap(),
"{case}"
);
}
Err(error) => {
assert_ne!(value.unwrap_or(false), controlled, "{case}: {error}");
assert!(
error.to_string().contains("kvm_shared_dequeue_timers"),
"{case}: {error}"
);
}
}
}
}
#[test]
fn a_controlled_key_that_contradicts_the_capabilities_fails_the_parse() {
let kvm = Config {
backend: BackendCapabilities::KVM,
sequentialize_threads: true,
..Config::default()
};
let kvm_json = to_legacy_backend_json(&kvm).unwrap();
assert!(from_legacy_backend_json(&kvm_json).is_ok());
let dbt = Config {
backend: BackendCapabilities::DBT,
sequentialize_threads: true,
..Config::default()
};
let dbt_json = to_legacy_backend_json(&dbt).unwrap();
assert!(from_legacy_backend_json(&dbt_json).is_ok());
for edited in [
kvm_json.replacen(
r#""kvm_shared_dequeue_timers":true"#,
r#""kvm_shared_dequeue_timers":false"#,
1,
),
kvm_json.replacen(r#","kvm_shared_dequeue_timers":true"#, "", 1),
dbt_json.replacen(
r#""kvm_shared_dequeue_timers":false"#,
r#""kvm_shared_dequeue_timers":true"#,
1,
),
to_legacy_backend_json(&Config {
sequentialize_threads: false,
..kvm.clone()
})
.unwrap()
.replacen(
r#""kvm_shared_dequeue_timers":false"#,
r#""kvm_shared_dequeue_timers":true"#,
1,
),
] {
assert_ne!(edited, kvm_json);
assert_ne!(edited, dbt_json);
let error = from_legacy_backend_json(&edited).unwrap_err();
assert!(
error.to_string().contains("kvm_shared_dequeue_timers"),
"{error}"
);
}
}
#[test]
fn legacy_backend_keys_decode_as_the_fields_they_were() {
let ptrace_json = to_legacy_backend_json(&Config::default()).unwrap();
let ptrace: serde_json::Map<String, serde_json::Value> =
serde_json::from_str(&ptrace_json).unwrap();
let keys = legacy_backend_keys(&Config::default());
let mut absent = ptrace.clone();
for (key, _) in keys {
assert!(absent.remove(key).is_some(), "{key}");
}
let decoded = from_legacy_backend_json(&serde_json::to_string(&absent).unwrap()).unwrap();
let legacy_ptrace = legacy_expressible(BackendCapabilities::PTRACE);
assert_eq!(decoded.backend, legacy_ptrace);
let unflipped =
serde_json::to_string(&from_legacy_backend_json(&ptrace_json).unwrap()).unwrap();
assert_eq!(serde_json::to_string(&decoded).unwrap(), unflipped);
for (key, ptrace_value) in keys {
let mut expected = legacy_ptrace;
match key {
"cpuid_virtualized_by_backend" => {
let mut flipped = ptrace.clone();
flipped.insert(key.to_owned(), serde_json::Value::Bool(!ptrace_value));
let error = from_legacy_backend_json(&serde_json::to_string(&flipped).unwrap())
.unwrap_err();
assert!(error.to_string().contains(key), "{error}");
continue;
}
"backend_supports_madvise" => {
expected.supports_madvise = false;
expected.supports_madv_dontneed = false;
}
"discover_live_file_metadata" => {
expected.tool_shares_guest_descriptor_table = true;
expected.rediscovers_descriptors_after_exec = true;
expected.internal_pipe_turns_are_host_timed = true;
expected.loopback_pollers_yield_to_peers = true;
}
"detect_host_clock_futex_timeouts" => {
expected.guest_clock_reads_bypass_backend = true
}
"syscall_clobbers_virtualized_by_backend" => {
expected.virtualizes_syscall_clobbers = true
}
"cancel_killed_thread_rpcs" => {
expected.needs_killed_thread_rpc_cancellation = true;
expected.reports_child_exit_publication = false;
expected.reports_kernel_child_exit_signals = false;
}
"backend_reports_physical_process_exits" => {
expected.reports_physical_process_exits = true;
expected.signal_interrupts_external_syscalls = true;
}
"backend_tracks_process_children" => expected.tracks_process_children = false,
"backend_runs_exit_robust_list" => expected.runs_exit_robust_list = false,
"backend_requires_thread_directed_process_signals" => {
expected.requires_thread_directed_process_signals = true;
expected.promotes_open_files_before_native_lifecycle = true;
}
"backend_is_kvm" => {
expected.provides_process_signal_control = true;
expected.emulates_child_waits = true;
}
"kvm_shared_dequeue_timers" => {
let mut flipped = ptrace.clone();
flipped.insert(key.to_owned(), serde_json::Value::Bool(!ptrace_value));
assert!(
from_legacy_backend_json(&serde_json::to_string(&flipped).unwrap())
.is_err(),
"{key}"
);
continue;
}
"backend_supports_parked_write_signal_interruption" => {
expected.supports_parked_write_signal_interruption = false
}
"backend_virtualizes_capability_prctls" => {
let mut flipped = ptrace.clone();
flipped.insert(key.to_owned(), serde_json::Value::Bool(!ptrace_value));
let error = from_legacy_backend_json(&serde_json::to_string(&flipped).unwrap())
.unwrap_err();
assert!(error.to_string().contains(key), "{error}");
continue;
}
"backend_defers_vfork_child_registration" => {
expected.defers_vfork_child_registration = true
}
other => panic!("no expectation for legacy key {other}"),
}
let mut flipped = ptrace.clone();
flipped.insert(key.to_owned(), serde_json::Value::Bool(!ptrace_value));
let decoded =
from_legacy_backend_json(&serde_json::to_string(&flipped).unwrap()).unwrap();
assert_eq!(decoded.backend, expected, "{key}");
assert_ne!(serde_json::to_string(&decoded).unwrap(), unflipped, "{key}");
}
}
fn assert_controlled_key(
json: &str,
backend: &BackendCapabilities,
sequentialize_threads: bool,
name: &str,
) {
let object: serde_json::Map<String, serde_json::Value> =
serde_json::from_str(json).unwrap();
assert_eq!(
object["kvm_shared_dequeue_timers"],
serde_json::Value::Bool(
backend.provides_process_signal_control && sequentialize_threads
),
"{name} sequentialize_threads={sequentialize_threads}"
);
}
#[test]
fn a_legacy_backend_key_of_the_wrong_type_fails_the_parse() {
let json = to_legacy_backend_json(&Config::default()).unwrap();
assert!(from_legacy_backend_json(&json).is_ok());
for (key, value) in legacy_backend_keys(&Config::default()) {
let field = format!("\"{key}\":{value}");
assert_eq!(json.matches(&field).count(), 1, "{field}");
let mistyped = json.replacen(&field, &format!("\"{key}\":0"), 1);
assert!(from_legacy_backend_json(&mistyped).is_err(), "{mistyped}");
let repeated = json.replacen(&field, &format!("{field},{field}"), 1);
assert!(from_legacy_backend_json(&repeated).is_err(), "{repeated}");
}
}
fn ordered_entries(json: &str) -> Vec<(String, serde_json::Value)> {
struct Entries(Vec<(String, serde_json::Value)>);
impl<'de> Deserialize<'de> for Entries {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct EntriesVisitor;
impl<'de> serde::de::Visitor<'de> for EntriesVisitor {
type Value = Entries;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a JSON object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
mut map: A,
) -> Result<Entries, A::Error> {
let mut entries = Vec::new();
while let Some(entry) = map.next_entry()? {
entries.push(entry);
}
Ok(Entries(entries))
}
}
deserializer.deserialize_map(EntriesVisitor)
}
}
serde_json::from_str::<Entries>(json).unwrap().0
}
fn positional(json: &str) -> String {
let values: Vec<serde_json::Value> = ordered_entries(json)
.into_iter()
.map(|(_, value)| value)
.collect();
serde_json::to_string(&values).unwrap()
}
#[test]
fn legacy_positions_are_the_encoded_key_order() {
let names = legacy_backend_keys(&Config::default()).map(|(name, _)| name);
assert_eq!(names, LEGACY_BACKEND_KEY_NAMES);
let fields = serde_json::from_str::<legacy_backend_json::KeyOrder>(
&serde_json::to_string(&Config::default()).unwrap(),
)
.unwrap()
.0;
let mut expected = Vec::new();
for field in &fields {
match field.as_str() {
"backend" => expected.extend(names.map(str::to_owned)),
"record_host_inputs"
| "guest_may_inherit_a_terminal"
| "in_guest_detlog_forward_policy"
| "in_guest_site_patching_off"
| "launch_image"
| "target_timeslice_syscalls_only"
| "futex_wake_yields"
| "pipe_wake_latency"
| "replaying"
| "scheduler_turn_cost"
| "inherited_seccomp"
| "cpu_profile"
| "cpu_profile_host"
| "signal_state_copy"
| "container_mount_table"
| "mountinfo_mount_namespace"
| "signal_delivery_check_fatal" => {}
other => expected.push(other.to_owned()),
}
}
let encoded = to_legacy_backend_json(&Config::default()).unwrap();
let keys: Vec<String> = ordered_entries(&encoded)
.into_iter()
.map(|(key, _)| key)
.collect();
assert_eq!(keys, expected);
assert!(!fields.iter().any(|field| field == "shared_dequeue_timers"));
assert_eq!(fields.len(), keys.len() + 3);
}
#[test]
fn record_host_inputs_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
record_host_inputs: true,
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("record_host_inputs"), "{json}");
assert!(!from_legacy_backend_json(&json).unwrap().record_host_inputs);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert!(!from_legacy_backend_json(&array).unwrap().record_host_inputs);
}
#[test]
fn process_exits_complete_asynchronously_never_enters_the_legacy_form() {
let on = Config {
backend: BackendCapabilities::LITEINST_IN_GUEST,
..Config::default()
};
assert!(on.backend.process_exits_complete_asynchronously);
assert!(on.backend.virtualizes_guest_sigalrm);
let off = Config {
backend: legacy_expressible(on.backend),
..on.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(
!json.contains("process_exits_complete_asynchronously"),
"{json}"
);
assert!(!json.contains("virtualizes_guest_sigalrm"), "{json}");
let decoded = from_legacy_backend_json(&json).unwrap();
assert!(!decoded.backend.process_exits_complete_asynchronously);
assert!(!decoded.backend.virtualizes_guest_sigalrm);
let array = positional(&json);
assert!(
!from_legacy_backend_json(&array)
.unwrap()
.backend
.process_exits_complete_asynchronously
);
}
#[test]
fn post_freeze_capabilities_never_enter_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let mut on = off.clone();
on.backend.supports_blocked_wait_signal_interruption = true;
on.backend.delivers_preemption_timer_events = true;
on.backend.runs_guest_code_between_injections = true;
on.backend.reports_sigreturns = true;
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
for key in [
"supports_blocked_wait_signal_interruption",
"delivers_preemption_timer_events",
"runs_guest_code_between_injections",
"reports_sigreturns",
] {
assert!(!json.contains(key), "{json}");
}
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
for decoded in [&json, &array] {
let backend = from_legacy_backend_json(decoded).unwrap().backend;
assert!(!backend.supports_blocked_wait_signal_interruption);
assert!(!backend.delivers_preemption_timer_events);
assert!(!backend.runs_guest_code_between_injections);
assert!(!backend.reports_sigreturns);
assert_eq!(backend, legacy_expressible(BackendCapabilities::DBT));
}
}
#[test]
fn in_guest_detlog_forward_policy_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
in_guest_detlog_forward_policy: Some("1".to_owned()),
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("in_guest_detlog_forward_policy"), "{json}");
assert!(
from_legacy_backend_json(&json)
.unwrap()
.in_guest_detlog_forward_policy
.is_none()
);
}
#[test]
fn launch_image_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
launch_image: Some(LaunchImage {
exe: Some(PathBuf::from("/usr/bin/true")),
launcher: Some(PathBuf::from("/usr/bin/env")),
}),
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("launch_image"), "{json}");
assert!(
from_legacy_backend_json(&json)
.unwrap()
.launch_image
.is_none()
);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert!(
from_legacy_backend_json(&array)
.unwrap()
.launch_image
.is_none()
);
}
#[test]
fn in_guest_site_patching_off_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
in_guest_site_patching_off: true,
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("in_guest_site_patching_off"), "{json}");
assert!(
!from_legacy_backend_json(&json)
.unwrap()
.in_guest_site_patching_off
);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert!(
!from_legacy_backend_json(&array)
.unwrap()
.in_guest_site_patching_off
);
}
#[test]
fn guest_may_inherit_a_terminal_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
guest_may_inherit_a_terminal: true,
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("guest_may_inherit_a_terminal"), "{json}");
assert!(
!from_legacy_backend_json(&json)
.unwrap()
.guest_may_inherit_a_terminal
);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert!(
!from_legacy_backend_json(&array)
.unwrap()
.guest_may_inherit_a_terminal
);
}
#[test]
fn the_cpu_profile_never_enters_the_legacy_form() {
let v2 = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let v3 = Config {
cpu_profile: crate::cpu_profile::CpuProfile::X86_64V3,
..v2.clone()
};
let json = to_legacy_backend_json(&v3).unwrap();
assert_eq!(json, to_legacy_backend_json(&v2).unwrap());
assert!(!json.contains("cpu_profile"), "{json}");
assert_eq!(
from_legacy_backend_json(&json).unwrap().cpu_profile,
crate::cpu_profile::CpuProfile::X86_64V2
);
let wire = bincode::serde::encode_to_vec(&v3, bincode::config::legacy()).unwrap();
let (decoded, _): (Config, usize) =
bincode::serde::decode_from_slice(&wire, bincode::config::legacy()).unwrap();
assert_eq!(
decoded.cpu_profile,
crate::cpu_profile::CpuProfile::X86_64V3
);
}
#[test]
fn inherited_seccomp_never_enters_the_legacy_form() {
use crate::config::InheritedSeccomp;
let unknown = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
assert_eq!(unknown.inherited_seccomp, InheritedSeccomp::Unknown);
let measured = Config {
inherited_seccomp: InheritedSeccomp::Filter(Some(2)),
..unknown.clone()
};
let json = to_legacy_backend_json(&measured).unwrap();
assert_eq!(json, to_legacy_backend_json(&unknown).unwrap());
assert!(!json.contains("inherited_seccomp"), "{json}");
assert_eq!(
from_legacy_backend_json(&json).unwrap().inherited_seccomp,
InheritedSeccomp::Unknown
);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert_eq!(
from_legacy_backend_json(&array).unwrap().inherited_seccomp,
InheritedSeccomp::Unknown
);
}
#[test]
fn inherited_seccomp_round_trips_through_reverie_bincode() {
use crate::config::InheritedSeccomp;
for inherited_seccomp in [
InheritedSeccomp::Unknown,
InheritedSeccomp::Disabled,
InheritedSeccomp::Strict,
InheritedSeccomp::Filter(None),
InheritedSeccomp::Filter(Some(3)),
] {
let config = Config {
inherited_seccomp,
..Config::default()
};
let wire = bincode::serde::encode_to_vec(&config, bincode::config::legacy()).unwrap();
let (decoded, read): (Config, usize) =
bincode::serde::decode_from_slice(&wire, bincode::config::legacy()).unwrap();
assert_eq!(read, wire.len());
assert_eq!(decoded.inherited_seccomp, inherited_seccomp);
assert_eq!(
bincode::serde::encode_to_vec(&decoded, bincode::config::legacy()).unwrap(),
wire
);
}
}
#[test]
fn inherited_seccomp_is_read_from_a_status_file() {
use crate::config::InheritedSeccomp;
let status = |lines: &str| {
InheritedSeccomp::parse(&format!(
"Name:\tguest\nNoNewPrivs:\t1\n{lines}Speculation_Store_Bypass:\tthread vulnerable\n"
))
};
assert_eq!(
status("Seccomp:\t0\nSeccomp_filters:\t0\n"),
InheritedSeccomp::Disabled
);
assert_eq!(
status("Seccomp:\t1\nSeccomp_filters:\t0\n"),
InheritedSeccomp::Strict
);
assert_eq!(
status("Seccomp:\t2\nSeccomp_filters:\t3\n"),
InheritedSeccomp::Filter(Some(3))
);
assert_eq!(status("Seccomp:\t2\n"), InheritedSeccomp::Filter(None));
assert_eq!(status(""), InheritedSeccomp::Unknown);
assert_eq!(status("Seccomp:\t7\n"), InheritedSeccomp::Unknown);
assert_ne!(InheritedSeccomp::measure(), InheritedSeccomp::Unknown);
}
#[test]
fn target_timeslice_syscalls_only_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
target_timeslice: NonZeroU64::new(1_000_000),
..Config::default()
};
let on = Config {
target_timeslice_syscalls_only: true,
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("target_timeslice_syscalls_only"), "{json}");
assert!(
!from_legacy_backend_json(&json)
.unwrap()
.target_timeslice_syscalls_only
);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert!(
!from_legacy_backend_json(&array)
.unwrap()
.target_timeslice_syscalls_only
);
}
#[test]
fn a_futex_wake_yields_only_when_it_woke_a_waiter() {
let config = Config {
futex_wake_yields: true,
..Config::default()
};
assert!(config.yields_after_futex_wake(1));
assert!(config.yields_after_futex_wake(3));
assert!(!config.yields_after_futex_wake(0));
assert!(!Config::default().futex_wake_yields);
assert!(!Config::default().yields_after_futex_wake(1));
}
#[test]
fn a_futex_wake_yields_under_replay_too() {
let config = Config {
futex_wake_yields: true,
..Config::default()
};
let preemption_replay = Config {
replay_preemptions_from: Some(PathBuf::from("/nonexistent/preemptions.json")),
..config.clone()
};
assert!(preemption_replay.yields_after_futex_wake(1));
assert!(!preemption_replay.yields_after_futex_wake(0));
let schedule_replay = Config {
replay_schedule_from: Some(PathBuf::from("/nonexistent/schedule.json")),
..config
};
assert!(schedule_replay.yields_after_futex_wake(1));
}
#[test]
fn scheduler_turn_charge_refuses_a_scaled_charge_below_one_nanosecond() {
let default = Config::default();
assert_eq!(default.scheduler_turn_charge(), Ok(500_000));
let scaled = Config {
clock_multiplier: Some(0.1),
..Config::default()
};
assert_eq!(scaled.scheduler_turn_charge(), Ok(50_000));
let cost = |cost: u64, multiplier: f64| Config {
scheduler_turn_cost: NonZeroU64::new(cost),
clock_multiplier: Some(multiplier),
..Config::default()
};
assert_eq!(cost(10_000, 0.1).scheduler_turn_charge(), Ok(1_000));
assert_eq!(cost(10, 0.1).scheduler_turn_charge(), Ok(1));
assert!(cost(9, 0.1).scheduler_turn_charge().is_err());
assert!(cost(1, 0.1).scheduler_turn_charge().is_err());
assert_eq!(
cost(MAX_SCHEDULER_TURN_COST, 1.0).scheduler_turn_charge(),
Ok(MAX_SCHEDULER_TURN_COST)
);
assert!(
cost(MAX_SCHEDULER_TURN_COST + 1, 1.0)
.scheduler_turn_charge()
.is_err()
);
assert!(cost(u64::MAX, 1.0).scheduler_turn_charge().is_err());
assert!(
cost(MAX_SCHEDULER_TURN_COST, 1e12)
.scheduler_turn_charge()
.is_err()
);
assert!(
cost(MAX_SCHEDULER_TURN_COST, 9e9)
.scheduler_turn_charge()
.is_err()
);
assert!(cost(1_000_000, 1_001.0).scheduler_turn_charge().is_err());
assert_eq!(
cost(1_000_000, 1_000.0).scheduler_turn_charge(),
Ok(MAX_SCHEDULER_TURN_COST)
);
let message = cost(MAX_SCHEDULER_TURN_COST, 9e9)
.scheduler_turn_charge()
.unwrap_err();
assert!(message.contains("at least 1"), "{message}");
assert!(message.contains("at most 1000000000"), "{message}");
}
#[test]
fn futex_wake_yields_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
futex_wake_yields: true,
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("futex_wake_yields"), "{json}");
assert!(!from_legacy_backend_json(&json).unwrap().futex_wake_yields);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert!(!from_legacy_backend_json(&array).unwrap().futex_wake_yields);
}
#[test]
fn scheduler_turn_cost_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
scheduler_turn_cost: NonZeroU64::new(10_000),
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("scheduler_turn_cost"), "{json}");
assert_eq!(
from_legacy_backend_json(&json).unwrap().scheduler_turn_cost,
None
);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert_eq!(
from_legacy_backend_json(&array)
.unwrap()
.scheduler_turn_cost,
None
);
}
#[test]
fn replaying_never_enters_the_legacy_form() {
let off = Config {
backend: BackendCapabilities::DBT,
..Config::default()
};
let on = Config {
replaying: true,
..off.clone()
};
let json = to_legacy_backend_json(&on).unwrap();
assert_eq!(json, to_legacy_backend_json(&off).unwrap());
assert!(!json.contains("replaying"), "{json}");
assert!(!from_legacy_backend_json(&json).unwrap().replaying);
let values: Vec<serde_json::Value> = ordered_entries(&json)
.into_iter()
.map(|(_, value)| value)
.collect();
let array = serde_json::to_string(&values).unwrap();
assert!(!from_legacy_backend_json(&array).unwrap().replaying);
}
#[test]
fn replaying_round_trips_through_reverie_bincode() {
for replaying in [false, true] {
let config = Config {
replaying,
..Config::default()
};
let wire = bincode::serde::encode_to_vec(&config, bincode::config::legacy()).unwrap();
let (decoded, read): (Config, usize) =
bincode::serde::decode_from_slice(&wire, bincode::config::legacy()).unwrap();
assert_eq!(read, wire.len());
assert_eq!(decoded.replaying, replaying);
assert_eq!(
bincode::serde::encode_to_vec(&decoded, bincode::config::legacy()).unwrap(),
wire
);
}
}
#[test]
fn a_legacy_positional_array_reads_as_the_object_it_lists() {
for (name, backend) in [
("PTRACE", BackendCapabilities::PTRACE),
("E9PATCH", BackendCapabilities::E9PATCH),
(
"ptrace without exit transitions",
ptrace_without_exit_transitions(),
),
("LITEINST_IN_GUEST", BackendCapabilities::LITEINST_IN_GUEST),
("SABRE", BackendCapabilities::SABRE),
("DBT", BackendCapabilities::DBT),
("KVM", BackendCapabilities::KVM),
] {
for sequentialize_threads in [false, true] {
let sent = Config {
backend,
sequentialize_threads,
seed: 7,
chaos: true,
..Config::default()
};
let json = to_legacy_backend_json(&sent).unwrap();
assert_controlled_key(&json, &backend, sequentialize_threads, name);
let array = positional(&json);
assert!(array.starts_with('['), "{array}");
let received = from_legacy_backend_json(&array).unwrap();
assert_eq!(received.backend, legacy_expressible(backend), "{name}");
assert_eq!(
received.sequentialize_threads, sequentialize_threads,
"{name}"
);
assert_eq!(received.seed, 7, "{name}");
assert!(received.chaos, "{name}");
assert_eq!(to_legacy_backend_json(&received).unwrap(), json, "{name}");
}
}
}
#[test]
fn a_malformed_legacy_positional_array_fails_the_parse() {
let json = to_legacy_backend_json(&Config {
backend: BackendCapabilities::DBT,
..Config::default()
})
.unwrap();
let entries = ordered_entries(&json);
let values: Vec<serde_json::Value> =
entries.iter().map(|(_, value)| value.clone()).collect();
let parse = |values: &[serde_json::Value]| {
from_legacy_backend_json(&serde_json::to_string(values).unwrap())
};
assert!(parse(&values).is_ok());
let mut longer = values.clone();
longer.push(serde_json::Value::Bool(false));
assert!(parse(&longer).is_err());
assert_eq!(entries.last().unwrap().0, "interrupt_at");
for len in 0..values.len() {
assert!(parse(&values[..len]).is_err(), "{len} elements");
}
for (position, (key, _)) in entries.iter().enumerate() {
if LEGACY_BACKEND_KEY_NAMES.contains(&key.as_str()) || key == "seed" {
let mut mistyped = values.clone();
mistyped[position] = serde_json::json!("0");
assert!(parse(&mistyped).is_err(), "{key}");
}
}
}
const LEGACY_INPUT_IN_CHILD: &str = "DETCORE_MODEL_TEST_LEGACY_INPUT";
const LEGACY_EXPECTED_IN_CHILD: &str = "DETCORE_MODEL_TEST_LEGACY_EXPECTED";
const LEGACY_DECODED_IN_CHILD: &str = "legacy configuration decoded under the ambient settings";
#[test]
fn a_legacy_configuration_decodes_whatever_the_ambient_hermit_settings() {
use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;
if let Some(input) = std::env::var_os(LEGACY_INPUT_IN_CHILD) {
let expected = std::env::var(LEGACY_EXPECTED_IN_CHILD).unwrap();
let received = from_legacy_backend_json(input.to_str().unwrap()).unwrap();
assert_eq!(
received.backend,
legacy_expressible(BackendCapabilities::DBT)
);
assert_eq!(received.seed, 7);
assert_eq!(received.sched_seed, Some(11));
assert_eq!(to_legacy_backend_json(&received).unwrap(), expected);
println!("{LEGACY_DECODED_IN_CHILD}");
return;
}
const VARIABLES: [&str; 3] = ["HERMIT_EPOCH", "HERMIT_PRNG", "HERMIT_SCHED_SEED"];
let text = OsStr::new("not-a-value");
let bytes = OsStr::from_bytes(b"\xff");
let mut settings: Vec<Vec<(&str, &OsStr)>> = vec![Vec::new()];
for variable in VARIABLES {
settings.push(vec![(variable, text)]);
settings.push(vec![(variable, bytes)]);
}
settings.push(VARIABLES.map(|variable| (variable, text)).to_vec());
settings.push(VARIABLES.map(|variable| (variable, bytes)).to_vec());
let object = to_legacy_backend_json(&Config {
backend: BackendCapabilities::DBT,
seed: 7,
sched_seed: Some(11),
..Config::default()
})
.unwrap();
let array = positional(&object);
assert!(array.starts_with('['), "{array}");
let test = format!(
"{}::a_legacy_configuration_decodes_whatever_the_ambient_hermit_settings",
module_path!().split_once("::").unwrap().1
);
for input in [&object, &array] {
for setting in &settings {
let mut child = std::process::Command::new(std::env::current_exe().unwrap());
child
.args(["--exact", &test, "--nocapture"])
.env(LEGACY_INPUT_IN_CHILD, input)
.env(LEGACY_EXPECTED_IN_CHILD, &object);
for variable in VARIABLES {
child.env_remove(variable);
}
for (variable, value) in setting {
child.env(variable, value);
}
let output = child.output().unwrap();
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
output.status.success()
&& stdout.contains(LEGACY_DECODED_IN_CHILD)
&& stdout.contains("test result: ok. 1 passed; 0 failed;"),
"decoding {} under {setting:?} did not succeed exactly once: {}\n{stdout}\n{stderr}",
if input.starts_with('[') {
"the array"
} else {
"the object"
},
output.status,
);
}
}
}
#[test]
fn keys_the_legacy_form_did_not_name_are_ignored() {
let sent = Config {
backend: legacy_expressible(BackendCapabilities::DBT),
seed: 7,
..Config::default()
};
let json = to_legacy_backend_json(&sent).unwrap();
let kvm = serde_json::to_string(&BackendCapabilities::KVM).unwrap();
for extra in [
r#""backend":null"#.to_owned(),
r#""shared_dequeue_timers":null"#.to_owned(),
r#""backend":null,"shared_dequeue_timers":null"#.to_owned(),
format!(r#""backend":{kvm},"shared_dequeue_timers":true"#),
r#""backend":7,"backend":{"supports_madvise":false}"#.to_owned(),
r#""shared_dequeue_timers":"yes","shared_dequeue_timers":true"#.to_owned(),
r#""no_such_field":[1,{"x":null}]"#.to_owned(),
] {
for edited in [
json.replacen('{', &format!("{{{extra},"), 1),
format!("{},{extra}}}", &json[..json.len() - 1]),
] {
let received = from_legacy_backend_json(&edited).unwrap();
assert_eq!(received.backend, sent.backend, "{edited}");
assert_eq!(
serde_json::to_string(&received).unwrap(),
serde_json::to_string(&sent).unwrap(),
"{edited}"
);
assert_eq!(to_legacy_backend_json(&received).unwrap(), json, "{edited}");
}
}
let repeated = format!("{},\"seed\":7}}", &json[..json.len() - 1]);
assert!(from_legacy_backend_json(&repeated).is_err());
}
#[test]
fn network_perturbation_seed_never_falls_back_to_scheduler_seeds() {
let mut config = Config {
seed: 41,
sched_seed: Some(42),
..Config::default()
};
assert_eq!(config.network_trace.network_perturb_seed, None);
config.network_trace = NetworkTraceConfig {
mode: crate::network_trace::NetworkTraceMode::Replay,
path: Some("network.trace".into()),
network_perturb_seed: Some(43),
};
assert_eq!(config.seed, 41);
assert_eq!(config.sched_seed(), 42);
assert_eq!(config.network_trace.network_perturb_seed, Some(43));
}
#[test]
fn missing_mountinfo_provenance_deserializes_as_empty() {
let mut value = serde_json::to_value(Config::default()).unwrap();
value
.as_object_mut()
.unwrap()
.remove("mountinfo_root_rewrites");
value
.as_object_mut()
.unwrap()
.remove("mountinfo_device_rewrites");
value.as_object_mut().unwrap().remove("mountinfo_mount_ids");
value
.as_object_mut()
.unwrap()
.remove("mountinfo_mount_ids_captured");
value
.as_object_mut()
.unwrap()
.remove("mount_id_assignment_order");
value
.as_object_mut()
.unwrap()
.remove("container_mount_table");
value
.as_object_mut()
.unwrap()
.remove("mountinfo_mount_namespace");
let restored: Config = serde_json::from_value(value).unwrap();
assert!(restored.mountinfo_root_rewrites.is_empty());
assert!(restored.mountinfo_device_rewrites.is_empty());
assert!(restored.mountinfo_mount_ids.is_empty());
assert!(!restored.mountinfo_mount_ids_captured);
assert!(restored.mount_id_assignment_order.is_empty());
assert!(restored.container_mount_table.is_none());
assert!(restored.mountinfo_mount_namespace.is_none());
}
#[test]
fn runs_post_fork_parses_all_modes_and_defaults_to_child() {
assert_eq!(Config::default().runs_post_fork, RunsPostFork::Child);
assert_eq!(
Config::parse_from(["detcore", "--runs-post-fork=parent"]).runs_post_fork,
RunsPostFork::Parent
);
assert_eq!(
Config::parse_from(["detcore", "--runs-post-fork=random"]).runs_post_fork,
RunsPostFork::Random
);
assert!(Config::try_parse_from(["detcore", "--runs-post-fork=invalid"]).is_err());
}
#[test]
fn proc_level_parses_both_levels_defaults_to_minimal_and_round_trips() {
assert_eq!(Config::default().proc_level, ProcLevel::Minimal);
assert!(!Config::default().to_string().contains("--proc"));
let standard = Config::parse_from(["detcore", "--proc=standard"]);
assert_eq!(standard.proc_level, ProcLevel::Standard);
assert!(standard.to_string().contains(" --proc=standard"));
assert_eq!(
Config::parse_from(["detcore", "--proc=minimal"]).proc_level,
ProcLevel::Minimal
);
assert!(Config::try_parse_from(["detcore", "--proc=host"]).is_err());
assert!(ProcLevel::Minimal < ProcLevel::Standard);
}
#[test]
fn panic_on_rcb_overshoot_is_opt_in_and_round_trips() {
assert!(!Config::default().panic_on_rcb_overshoot);
let config = Config::parse_from(["detcore", "--panic-on-rbc-overshoot"]);
assert!(config.panic_on_rcb_overshoot);
assert!(config.to_string().contains(" --panic-on-rbc-overshoot"));
let alias = Config::parse_from(["detcore", "--panic-on-rcb-overshoot"]);
assert!(alias.panic_on_rcb_overshoot);
}
#[test]
fn config_display_preserves_nondefault_post_fork_modes() {
let mut config = Config {
runs_post_fork: RunsPostFork::Parent,
..Config::default()
};
assert!(config.to_string().contains(" --runs-post-fork=parent"));
config.runs_post_fork = RunsPostFork::Random;
assert!(config.to_string().contains(" --runs-post-fork=random"));
}
#[test]
fn a_fatal_delivery_check_is_off_by_default_and_never_enters_the_legacy_form() {
assert!(!Config::default().signal_delivery_check_fatal);
let fatal = Config {
signal_delivery_check_fatal: true,
..Config::default()
};
let json = serde_json::to_string(&fatal).unwrap();
let reparsed: Config = serde_json::from_str(&json).unwrap();
assert!(reparsed.signal_delivery_check_fatal);
let mut old = serde_json::to_value(Config::default()).unwrap();
old.as_object_mut()
.unwrap()
.remove("signal_delivery_check_fatal");
let old: Config = serde_json::from_value(old).unwrap();
assert!(!old.signal_delivery_check_fatal);
let legacy = to_legacy_backend_json(&fatal).unwrap();
assert!(!legacy.contains("signal_delivery_check_fatal"), "{legacy}");
assert!(
!from_legacy_backend_json(&legacy)
.unwrap()
.signal_delivery_check_fatal
);
}
#[test]
fn the_signal_state_copy_is_on_by_default_and_its_off_switch_round_trips() {
let dflt = Config::default();
assert!(dflt.signal_state_copy);
assert!(!dflt.to_string().contains("signal-state-copy"));
let mut json = serde_json::to_value(&dflt).unwrap();
json.as_object_mut().unwrap().remove("signal_state_copy");
let old: Config = serde_json::from_value(json).unwrap();
assert!(old.signal_state_copy);
let off = Config::parse_from(["detcore", "--no-signal-state-copy"]);
assert!(!off.signal_state_copy);
let rendered = off.to_string();
assert!(rendered.contains(" --no-signal-state-copy"), "{rendered}");
let reparsed = Config::parse_from(
std::iter::once("detcore".to_string())
.chain(rendered.split_whitespace().map(String::from)),
);
assert!(!reparsed.signal_state_copy);
}
#[test]
fn chaos_per_thread_slowdown_is_opt_in_and_round_trips() {
let dflt = Config::default();
assert!(!dflt.chaos_per_thread_slowdown);
assert_eq!(dflt.chaos_slowdown_max_factor, 10.0);
assert!(!dflt.to_string().contains("--chaos-per-thread-slowdown"));
let config = Config::parse_from([
"detcore",
"--chaos",
"--chaos-per-thread-slowdown",
"--chaos-slowdown-max-factor=4.5",
]);
assert!(config.chaos_per_thread_slowdown);
assert_eq!(config.chaos_slowdown_max_factor, 4.5);
let rendered = config.to_string();
assert!(rendered.contains(" --chaos-per-thread-slowdown"));
assert!(rendered.contains(" --chaos-slowdown-max-factor=4.5"));
let reparsed = Config::parse_from(
std::iter::once("detcore".to_string())
.chain(rendered.split_whitespace().map(String::from)),
);
assert!(reparsed.chaos_per_thread_slowdown);
assert_eq!(reparsed.chaos_slowdown_max_factor, 4.5);
}
#[test]
fn chaos_epoch_length_is_opt_in_and_round_trips() {
let dflt = Config::default();
assert_eq!(dflt.chaos_epoch_length_ns, 0);
assert!(!dflt.to_string().contains("--chaos-epoch-length-ns"));
let config = Config::parse_from([
"detcore",
"--chaos",
"--chaos-per-thread-slowdown",
"--chaos-epoch-length-ns=100000",
]);
assert_eq!(config.chaos_epoch_length_ns, 100000);
let rendered = config.to_string();
assert!(rendered.contains(" --chaos-epoch-length-ns=100000"));
let reparsed = Config::parse_from(
std::iter::once("detcore".to_string())
.chain(rendered.split_whitespace().map(String::from)),
);
assert_eq!(reparsed.chaos_epoch_length_ns, 100000);
let no_slowdown = Config::parse_from(["detcore", "--chaos", "--chaos-epoch-length-ns=100"]);
assert_eq!(no_slowdown.chaos_epoch_length_ns, 100);
assert!(!no_slowdown.to_string().contains("--chaos-epoch-length-ns"));
}
#[test]
#[should_panic(expected = "chaos_slowdown_max_factor must be finite and in")]
fn validate_rejects_chaos_slowdown_max_factor_below_one() {
let mut config = Config {
chaos_slowdown_max_factor: 0.5,
..Default::default()
};
config.validate();
}
#[test]
#[should_panic(expected = "max_timeslice must be at least one RCB")]
fn validate_rejects_max_timeslice_below_one_rcb() {
let mut config = Config {
max_timeslice: NonZeroU64::new(NANOS_PER_RCB as u64 - 1),
..Default::default()
};
config.validate();
}
#[test]
fn validate_accepts_one_rcb_max_timeslice() {
let mut config = Config {
max_timeslice: NonZeroU64::new(NANOS_PER_RCB as u64),
..Default::default()
};
config.validate();
}
#[test]
#[should_panic(expected = "clock_multiplier must be finite and positive")]
fn validate_rejects_invalid_clock_multiplier() {
let mut config = Config {
clock_multiplier: Some(0.0),
..Default::default()
};
config.validate();
}
#[test]
#[should_panic(expected = "max_timeslice must be at least one RCB")]
fn validate_scales_one_rcb_minimum_with_clock_multiplier() {
let mut config = Config {
max_timeslice: NonZeroU64::new(10),
clock_multiplier: Some(2.0),
..Default::default()
};
config.validate();
}
#[test]
fn config_fingerprint_sees_the_width_of_every_backend_capability() {
let config = config_wire_default();
let fields = serde_json::to_value(config.backend).unwrap();
let fields = fields.as_object().unwrap();
assert!(
fields.values().all(serde_json::Value::is_boolean),
"{fields:?}"
);
let encode = |config: &Config| {
bincode::serde::encode_to_vec(config, bincode::config::legacy()).unwrap()
};
assert_eq!(
bincode::serde::encode_to_vec(config.backend, bincode::config::legacy())
.unwrap()
.len(),
fields.len()
);
let flipped = config
.clone()
.with_backend(|backend| backend.supports_madvise = !backend.supports_madvise);
assert_eq!(encode(&flipped).len(), encode(&config).len());
assert_ne!(encode(&flipped), encode(&config));
}
#[test]
fn config_fingerprint_includes_clock_rpc_definitions() {
let config = config_wire_default();
let wire = bincode::serde::encode_to_vec(&config, bincode::config::legacy()).unwrap();
let named_shape = serde_json::to_string(&config).unwrap();
let current = config_wire_fingerprint();
let clock_source = include_bytes!("time.rs").as_slice();
let without_clock: Vec<_> = CONFIG_DEFINITION_SOURCES
.iter()
.copied()
.filter(|source| *source != clock_source)
.collect();
assert_ne!(
fingerprint_of_config_material(&wire, &named_shape, &without_clock),
current,
"the published fingerprint must reject source inputs that omit the RPC clock"
);
let changed_clock =
include_str!("time.rs").replacen(" inherited_nanos: LogicalDuration,", "", 1);
assert_ne!(changed_clock.as_bytes(), clock_source);
let changed_sources: Vec<_> = CONFIG_DEFINITION_SOURCES
.iter()
.map(|source| {
if *source == clock_source {
changed_clock.as_bytes()
} else {
*source
}
})
.collect();
assert_ne!(
fingerprint_of_config_material(&wire, &named_shape, &changed_sources),
current,
"a clock-only serialized field change must invalidate the fingerprint"
);
}
#[test]
fn config_fingerprint_includes_the_inode_rpc_identity() {
let config = config_wire_default();
let wire = bincode::serde::encode_to_vec(&config, bincode::config::legacy()).unwrap();
let named_shape = serde_json::to_string(&config).unwrap();
let current = config_wire_fingerprint();
let inode_source = include_bytes!("fd.rs").as_slice();
assert!(CONFIG_DEFINITION_SOURCES.contains(&inode_source));
let without_device = include_str!("fd.rs").replacen(" pub dev: u64,\n", "", 1);
assert_ne!(without_device.as_bytes(), inode_source);
let changed_sources: Vec<_> = CONFIG_DEFINITION_SOURCES
.iter()
.map(|source| {
if *source == inode_source {
without_device.as_bytes()
} else {
*source
}
})
.collect();
assert_ne!(
fingerprint_of_config_material(&wire, &named_shape, &changed_sources),
current,
"an inode-identity layout change must invalidate the fingerprint"
);
}
#[test]
fn a_config_fingerprint_mismatch_names_both_fingerprints() {
let ours = config_wire_fingerprint();
assert_eq!(
config_fingerprint_mismatch(std::ffi::OsStr::new(&ours)),
None
);
let other = config_fingerprint_mismatch(std::ffi::OsStr::new("0123456789abcdef"))
.expect("another fingerprint is a mismatch");
assert!(other.contains(&ours), "{other}");
assert!(other.contains("0123456789abcdef"), "{other}");
use std::os::unix::ffi::OsStrExt;
assert!(config_fingerprint_mismatch(std::ffi::OsStr::from_bytes(b"\xff")).is_some());
}
#[test]
fn config_fingerprint_is_stable_and_shape_sensitive() {
assert_eq!(config_wire_fingerprint(), config_wire_fingerprint());
assert_eq!(config_wire_fingerprint().len(), 16);
let config = config_wire_default();
let base = serde_json::to_string(&config).unwrap();
let wire = bincode::serde::encode_to_vec(&config, bincode::config::legacy()).unwrap();
assert_eq!(
fingerprint_of_config_material(&wire, &base, CONFIG_DEFINITION_SOURCES),
config_wire_fingerprint()
);
let with_extra_field = format!("{},\"a_new_flag\":false}}", &base[..base.len() - 1]);
assert_ne!(
fingerprint_of_config_material(&wire, &with_extra_field, CONFIG_DEFINITION_SOURCES),
config_wire_fingerprint()
);
let removed = base.replacen("\"virtualize_time\":true,", "", 1);
assert_ne!(
fingerprint_of_config_material(&wire, &removed, CONFIG_DEFINITION_SOURCES),
config_wire_fingerprint()
);
let renamed = base.replacen("\"virtualize_time\"", "\"virtualise_time\"", 1);
assert_ne!(
fingerprint_of_config_material(&wire, &renamed, CONFIG_DEFINITION_SOURCES),
config_wire_fingerprint()
);
#[derive(Serialize)]
struct U32Field {
field: u32,
}
#[derive(Serialize)]
struct U64Field {
field: u64,
}
let u32_value = U32Field { field: 0 };
let u64_value = U64Field { field: 0 };
let u32_json = serde_json::to_string(&u32_value).unwrap();
let u64_json = serde_json::to_string(&u64_value).unwrap();
assert_eq!(
u32_json, u64_json,
"the planted JSON collision must be real"
);
let u32_wire =
bincode::serde::encode_to_vec(&u32_value, bincode::config::legacy()).unwrap();
let u64_wire =
bincode::serde::encode_to_vec(&u64_value, bincode::config::legacy()).unwrap();
assert_ne!(u32_wire, u64_wire, "the planted wire retype must be real");
assert_ne!(
fingerprint_of_config_material(&u32_wire, &u32_json, &[b"struct S { field: u32 }"]),
fingerprint_of_config_material(&u64_wire, &u64_json, &[b"struct S { field: u64 }"]),
"a wire-incompatible integer retype must change the fingerprint"
);
#[derive(Serialize)]
struct OptionalU32 {
field: Option<u32>,
}
#[derive(Serialize)]
struct OptionalU64 {
field: Option<u64>,
}
let optional_u32 = OptionalU32 { field: None };
let optional_u64 = OptionalU64 { field: None };
let optional_u32_json = serde_json::to_string(&optional_u32).unwrap();
let optional_u64_json = serde_json::to_string(&optional_u64).unwrap();
assert_eq!(optional_u32_json, optional_u64_json);
let optional_u32_wire =
bincode::serde::encode_to_vec(&optional_u32, bincode::config::legacy()).unwrap();
let optional_u64_wire =
bincode::serde::encode_to_vec(&optional_u64, bincode::config::legacy()).unwrap();
assert_eq!(
optional_u32_wire, optional_u64_wire,
"the planted default must be invisible in both value encodings"
);
assert_ne!(
fingerprint_of_config_material(
&optional_u32_wire,
&optional_u32_json,
&[b"struct S { field: Option<u32> }"]
),
fingerprint_of_config_material(
&optional_u64_wire,
&optional_u64_json,
&[b"struct S { field: Option<u64> }"]
),
"a hidden wire-incompatible inner-type change must alter the fingerprint"
);
}
#[test]
fn config_fingerprint_uses_environment_free_wire_defaults() {
let environment_derived = Config {
epoch: "2042-03-04T05:06:07.890123456Z".parse().unwrap(),
seed: 41,
sched_seed: Some(42),
..Config::default()
};
let canonical = config_wire_default();
assert_ne!(
serde_json::to_string(&environment_derived).unwrap(),
serde_json::to_string(&canonical).unwrap()
);
assert_eq!(
canonical.epoch,
DEFAULT_EPOCH_STR.parse::<DateTime<Utc>>().unwrap()
);
assert_eq!(canonical.seed, 0);
assert_eq!(canonical.sched_seed, None);
}
#[test]
#[should_panic(expected = "max_timeslice must be at least one RCB")]
fn validate_scales_one_rcb_minimum_with_chaos_slowdown() {
let mut config = Config {
chaos: true,
chaos_per_thread_slowdown: true,
chaos_slowdown_max_factor: 4.0,
max_timeslice: NonZeroU64::new(39),
..Default::default()
};
config.validate();
}
#[test]
#[should_panic(expected = "chaos_slowdown_max_factor must be finite and in")]
fn validate_rejects_unrepresentable_chaos_slowdown_factor() {
let mut config = Config {
chaos_slowdown_max_factor: RcbTimeMultiplier::MAX * 2.0,
..Default::default()
};
config.validate();
}
}