use std::collections::HashMap;
use std::collections::hash_map::Entry;
use std::fmt;
use std::path::PathBuf;
use reverie::Errno;
use reverie::syscalls::Syscall;
use serde::Deserialize;
use serde::Serialize;
use crate::types::ChildWaitSpec;
use crate::types::DetInode;
use crate::types::DetPid;
use crate::types::DetTid;
use crate::types::LogicalTime;
use crate::types::MmId;
use crate::types::RcbTimeMultiplier;
use crate::types::SigWrapper;
pub(crate) const HOST_TIMED_INTERNAL_PIPE_IO_FYI: &str = "sabre-internal-pipe-io";
pub(crate) const LOOPBACK_POLL_YIELD_FYI: &str = "sabre-loopback-poll-zero-timeout";
pub(crate) const PAUSE_FYI: &str = "pause";
pub(crate) const NANOSLEEP_FYI: &str = "nanosleep";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) enum SigalrmSleepDisposition {
Default,
Ignored,
Handled,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) struct InGuestSleepSigalrm {
pub disposition: SigalrmSleepDisposition,
pub blocked: bool,
}
impl InGuestSleepSigalrm {
pub(crate) fn ends_process(self) -> bool {
self.disposition == SigalrmSleepDisposition::Default && !self.blocked
}
}
#[derive(PartialEq, Debug, Eq, Clone, Copy, Serialize, Deserialize, Hash)]
pub struct ChaosEpochTransition {
pub logical_time: LogicalTime,
pub epoch: u64,
pub factor: RcbTimeMultiplier,
}
#[derive(
PartialEq,
Debug,
Eq,
Clone,
Copy,
Serialize,
Deserialize,
Hash,
PartialOrd,
Ord
)]
pub struct ExternalOpId {
pub tid: DetTid,
pub sequence: u64,
}
impl ExternalOpId {
pub const fn new(tid: DetTid, sequence: u64) -> Self {
Self { tid, sequence }
}
}
#[derive(PartialEq, Debug, Eq, Clone, Serialize, Deserialize, Hash)]
pub enum ResourceID {
FileContents(DetInode),
FileMetadata(DetInode),
DirectoryContents(DetInode),
MemAddrSpace(DetPid),
Path(PathBuf),
PathsTransitive(PathBuf),
Device(Device),
Exit {
group: bool,
process: DetPid,
mm: MmId,
},
ParentContinue { parent: DetTid, child: DetTid },
SleepUntil(LogicalTime),
InternalIOPolling,
TraceReplay,
FutexWait,
BlockingExternalIO(ExternalOpId),
BlockingVfork(ExternalOpId),
VforkFailed(ExternalOpId),
BlockedExternalContinue(ExternalOpId),
PriorityChangePoint(u64, LogicalTime, u64, Vec<ChaosEpochTransition>),
WaitChild {
parent: DetPid,
spec: ChildWaitSpec,
},
WaitPhysicalChild(DetPid),
InboundSignal(SigWrapper),
WaitidSignals(Vec<SigWrapper>),
SchedYield,
HappensBeforeCheckpoint(u64),
HappensBeforeSyscallCheckpoint {
count: u64,
anchors: Vec<String>,
},
HappensBeforePosthookInterrupted {
count: u64,
anchors: Vec<String>,
code: String,
},
BlockingRtSigsuspend(ExternalOpId),
InGuestFatalAlarm,
}
#[allow(clippy::enum_variant_names)]
#[derive(PartialEq, Debug, Eq, Clone, Serialize, Deserialize, Hash)]
pub enum Device {
ContainerStdin,
ContainerStdout,
ContainerStderr,
}
#[derive(PartialEq, Eq, Clone, Serialize, Deserialize)]
pub struct Resources {
pub tid: DetTid,
pub resources: HashMap<ResourceID, Permission>,
pub poll_attempt: u32,
pub fyi: String,
#[serde(default)]
pub(crate) signal_interrupt_errno: Option<i32>,
#[serde(default)]
pub(crate) backend_runtime_bootstrap: bool,
#[serde(default)]
pub(crate) blocked_signal_mask: Option<u64>,
#[serde(default)]
pub(crate) blocked_signal_mask_unknown: bool,
#[serde(default)]
pub(crate) replay_served_from_log: bool,
#[serde(default)]
pub(crate) reads_signalfd: bool,
#[serde(default)]
pub(crate) read_fd: Option<(detcore_model::fd::FilesId, i32)>,
#[serde(default)]
pub(crate) polls_guest_state_only: bool,
#[serde(default)]
pub(crate) waits_until_nothing_else_can_run: bool,
#[serde(default)]
pub(crate) previous_attempt_made_progress: bool,
#[serde(default)]
pub(crate) upgraded_from_attempt: u32,
#[serde(default)]
pub(crate) polls_channel: Option<Box<(crate::pipe_wake::ChannelId, crate::pipe_wake::Wants)>>,
#[serde(default)]
pub(crate) poll_deadline: Option<LogicalTime>,
#[serde(default)]
pub(crate) in_guest_sleep_sigalrm: Option<InGuestSleepSigalrm>,
#[serde(default)]
pub(crate) signal_state_task: Option<(i32, i32)>,
#[serde(default)]
pub(crate) decides_signal_interruption_itself: bool,
#[serde(default)]
pub(crate) continues_sigreturn: bool,
#[serde(default)]
pub(crate) private_sigchld_decides: bool,
}
impl fmt::Debug for Resources {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut debug = f.debug_struct("Resources");
debug
.field("tid", &self.tid)
.field("resources", &self.resources)
.field("poll_attempt", &self.poll_attempt)
.field("fyi", &self.fyi);
if let Some(errno) = self.signal_interrupt_errno {
debug.field("signal_interrupt_errno", &errno);
}
if self.backend_runtime_bootstrap {
debug.field("backend_runtime_bootstrap", &true);
}
if let Some(mask) = self.blocked_signal_mask {
debug.field("blocked_signal_mask", &mask);
}
if self.blocked_signal_mask_unknown {
debug.field("blocked_signal_mask_unknown", &true);
}
if self.replay_served_from_log {
debug.field("replay_served_from_log", &true);
}
if self.polls_guest_state_only {
debug.field("polls_guest_state_only", &true);
}
if self.waits_until_nothing_else_can_run {
debug.field("waits_until_nothing_else_can_run", &true);
}
if self.previous_attempt_made_progress {
debug.field("previous_attempt_made_progress", &true);
}
if self.upgraded_from_attempt != 0 {
debug.field("upgraded_from_attempt", &self.upgraded_from_attempt);
}
if let Some(channel) = &self.polls_channel {
debug.field("polls_channel", channel);
}
if let Some(deadline) = self.poll_deadline {
debug.field("poll_deadline", &deadline);
}
if let Some(snapshot) = self.in_guest_sleep_sigalrm {
debug.field("in_guest_sleep_sigalrm", &snapshot);
}
if let Some(task) = self.signal_state_task {
debug.field("signal_state_task", &task);
}
if self.decides_signal_interruption_itself {
debug.field("decides_signal_interruption_itself", &true);
}
if self.continues_sigreturn {
debug.field("continues_sigreturn", &true);
}
if self.private_sigchld_decides {
debug.field("private_sigchld_decides", &true);
}
debug.finish()
}
}
impl Resources {
pub(crate) fn upgraded_to_runnable(&self) -> Resources {
let mut runnable = self.clone();
runnable.upgraded_from_attempt = runnable.upgraded_from_attempt.max(runnable.poll_attempt);
runnable.poll_attempt = 0;
runnable
}
pub fn new(tid: DetTid) -> Resources {
Resources {
tid,
resources: HashMap::new(),
poll_attempt: 0,
fyi: String::new(),
signal_interrupt_errno: None,
backend_runtime_bootstrap: false,
blocked_signal_mask: None,
blocked_signal_mask_unknown: false,
replay_served_from_log: false,
reads_signalfd: false,
read_fd: None,
polls_guest_state_only: false,
waits_until_nothing_else_can_run: false,
previous_attempt_made_progress: false,
upgraded_from_attempt: 0,
polls_channel: None,
poll_deadline: None,
in_guest_sleep_sigalrm: None,
signal_state_task: None,
decides_signal_interruption_itself: false,
continues_sigreturn: false,
private_sigchld_decides: false,
}
}
pub fn union(&mut self, other: &Resources) {
assert_eq!(self.tid, other.tid);
self.in_guest_sleep_sigalrm = None;
for (id, perm2) in other.resources.iter() {
match self.resources.entry(id.clone()) {
Entry::Occupied(mut e) => {
let perm1 = e.get_mut();
*perm1 = perm1.union(perm2)
}
Entry::Vacant(e) => {
e.insert(perm2.clone());
}
}
}
match (self.signal_interrupt_errno, other.signal_interrupt_errno) {
(None, interrupt) => self.signal_interrupt_errno = interrupt,
(Some(left), Some(right)) => assert_eq!(left, right),
(Some(_), None) => {}
}
self.backend_runtime_bootstrap |= other.backend_runtime_bootstrap;
match (self.blocked_signal_mask, other.blocked_signal_mask) {
(None, mask) => self.blocked_signal_mask = mask,
(Some(left), Some(right)) => assert_eq!(left, right),
(Some(_), None) => {}
}
self.blocked_signal_mask_unknown |= other.blocked_signal_mask_unknown;
if self.signal_state_task.is_none() {
self.signal_state_task = other.signal_state_task;
}
self.decides_signal_interruption_itself |= other.decides_signal_interruption_itself;
self.continues_sigreturn &= other.continues_sigreturn;
self.private_sigchld_decides |= other.private_sigchld_decides;
self.replay_served_from_log |= other.replay_served_from_log;
self.polls_guest_state_only |= other.polls_guest_state_only;
self.waits_until_nothing_else_can_run |= other.waits_until_nothing_else_can_run;
self.previous_attempt_made_progress |= other.previous_attempt_made_progress;
self.upgraded_from_attempt = self.upgraded_from_attempt.max(other.upgraded_from_attempt);
self.poll_deadline = match (self.poll_deadline, other.poll_deadline) {
(Some(left), Some(right)) => Some(left.min(right)),
(left, right) => left.or(right),
};
}
pub(crate) fn queued_deadline(&self) -> Option<LogicalTime> {
let sleep = self.resources.keys().find_map(|resource| match resource {
ResourceID::SleepUntil(deadline) if !deadline.is_indefinite() => Some(*deadline),
_ => None,
});
match (sleep, self.poll_deadline) {
(Some(a), Some(b)) => Some(a.min(b)),
(a, b) => a.or(b),
}
}
pub(crate) fn in_guest_sigalrm_sleep(&self) -> Option<(InGuestSleepSigalrm, LogicalTime)> {
if self.resources.len() != 1
|| self.poll_attempt != 0
|| self.signal_interrupt_errno.is_some()
|| self.blocked_signal_mask.is_some()
|| self.replay_served_from_log
|| self.backend_runtime_bootstrap
|| self.poll_deadline.is_some()
{
return None;
}
let (ResourceID::SleepUntil(deadline), Permission::W) = self.resources.iter().next()?
else {
return None;
};
if !(self.fyi == PAUSE_FYI && deadline.is_indefinite() || self.fyi == NANOSLEEP_FYI) {
return None;
}
Some((self.in_guest_sleep_sigalrm?, *deadline))
}
pub fn set_signal_interrupt_errno(&mut self, errno: Errno) {
self.signal_interrupt_errno = Some(errno.into_raw());
}
pub fn signal_interrupt_errno(&self) -> Option<i32> {
self.signal_interrupt_errno
}
pub fn insert(&mut self, new: ResourceID, perm: Permission) {
let old = self.resources.insert(new, perm);
assert_eq!(old, None);
}
pub fn fyi(&mut self, s: &str) {
if !self.fyi.is_empty() {
self.fyi.push_str(", ");
}
self.fyi.push_str(s);
}
pub fn as_exit_syscall(&self) -> Option<Syscall> {
let exit = self.resources.keys().find_map(|resource| match resource {
ResourceID::Exit { group, process, mm } => Some((*group, *process, *mm)),
_ => None,
});
if exit.is_some() && self.resources.len() > 1 {
panic!(
"is_polling_turn: not expecting an InternalIOPolling mixed in with other resource requests: {:?}",
self
);
}
if exit.is_some_and(|(group, _, _)| group) {
Some(Syscall::ExitGroup(Default::default())) } else if exit.is_some() {
Some(Syscall::Exit(Default::default())) } else {
None
}
}
pub fn exit_identity(&self) -> Option<(bool, DetPid, MmId)> {
self.resources.keys().find_map(|resource| match resource {
ResourceID::Exit { group, process, mm } => Some((*group, *process, *mm)),
_ => None,
})
}
}
#[derive(PartialEq, Debug, Eq, Clone, Serialize, Deserialize, Hash)]
pub enum Permission {
R,
W,
RW,
}
impl Permission {
pub fn union(&self, other: &Permission) -> Permission {
use Permission::*;
match (self, other) {
(R, R) => R,
(R, W) => RW,
(W, R) => RW,
(W, W) => W,
(RW, _) => RW,
(_, RW) => RW,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn control_tokens_do_not_alias_unrelated_operations() {
let tid1 = DetTid::from_raw(1);
let tid2 = DetTid::from_raw(2);
assert_ne!(
ResourceID::BlockingExternalIO(ExternalOpId::new(tid1, 7)),
ResourceID::BlockingExternalIO(ExternalOpId::new(tid2, 7))
);
assert_ne!(
ResourceID::BlockingExternalIO(ExternalOpId::new(tid1, 7)),
ResourceID::BlockingRtSigsuspend(ExternalOpId::new(tid1, 7))
);
assert_ne!(
ResourceID::ParentContinue {
parent: tid1,
child: tid2,
},
ResourceID::ParentContinue {
parent: tid2,
child: tid1,
}
);
}
fn owner_sleep(deadline: LogicalTime, fyi: &str) -> Resources {
let mut request = Resources::new(DetTid::from_raw(1));
request.insert(ResourceID::SleepUntil(deadline), Permission::W);
request.fyi(fyi);
request.in_guest_sleep_sigalrm = Some(InGuestSleepSigalrm {
disposition: SigalrmSleepDisposition::Default,
blocked: false,
});
request
}
#[test]
fn in_guest_sleep_snapshot_requires_exact_singleton_wait_shape() {
let deadline = LogicalTime::from_nanos(10);
for (deadline, fyi) in [
(LogicalTime::INDEFINITE, PAUSE_FYI),
(deadline, NANOSLEEP_FYI),
] {
let request = owner_sleep(deadline, fyi);
assert_eq!(
request.in_guest_sigalrm_sleep(),
Some((request.in_guest_sleep_sigalrm.unwrap(), deadline))
);
}
for case in 0..11 {
let mut request = owner_sleep(deadline, NANOSLEEP_FYI);
match case {
0 => request.in_guest_sleep_sigalrm = None,
1 => request.fyi = PAUSE_FYI.to_owned(),
2 => request.fyi("unrelated"),
3 => request.insert(ResourceID::TraceReplay, Permission::W),
4 => {
request
.resources
.insert(ResourceID::SleepUntil(deadline), Permission::R);
}
5 => request.poll_attempt = 1,
6 => request.signal_interrupt_errno = Some(libc::EINTR),
7 => request.blocked_signal_mask = Some(0),
8 => request.backend_runtime_bootstrap = true,
9 => request.poll_deadline = Some(deadline),
10 => request.replay_served_from_log = true,
_ => unreachable!(),
}
assert_eq!(request.in_guest_sigalrm_sleep(), None, "case {case}");
}
}
#[test]
fn merging_resources_cannot_spread_sleep_snapshot_authority() {
let deadline = LogicalTime::from_nanos(10);
for merge_sleep_first in [false, true] {
let mut sleep = owner_sleep(deadline, NANOSLEEP_FYI);
let mut unrelated = Resources::new(sleep.tid);
unrelated.insert(ResourceID::TraceReplay, Permission::W);
let merged = if merge_sleep_first {
sleep.union(&unrelated);
sleep
} else {
unrelated.union(&sleep);
unrelated
};
assert_eq!(merged.in_guest_sleep_sigalrm, None);
assert_eq!(merged.in_guest_sigalrm_sleep(), None);
}
let mut sleep = owner_sleep(deadline, NANOSLEEP_FYI);
sleep.union(&sleep.clone());
assert_eq!(
sleep.in_guest_sleep_sigalrm, None,
"even identical merged operations surrender their original wait identity"
);
}
}