use std::collections::BTreeMap;
use std::collections::BTreeSet;
use tracing::info;
use super::Scheduler;
use crate::types::DetPid;
use crate::types::DetTid;
use crate::types::FutexID;
use crate::types::MmId;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct SigkillVictim {
pub(crate) tid: DetTid,
pub(crate) process: DetPid,
pub(crate) mm: MmId,
}
#[derive(Debug)]
struct Reservation {
victims: Vec<SigkillVictim>,
uid: u32,
includes_sender: bool,
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
serde::Serialize,
serde::Deserialize
)]
pub struct SigkillReservation {
pub token: u64,
pub includes_sender: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum SigkillRefusal {
Backend,
NoTarget,
UnknownAddressSpace(DetTid),
AlreadyReserved(DetTid),
BackgroundOperation(DetTid),
NamespaceInit(DetPid),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SigkillFenceRefusal {
pub unaccounted: Vec<DetTid>,
pub unpublished: Vec<DetPid>,
pub waited: std::time::Duration,
}
impl std::fmt::Display for SigkillFenceRefusal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"hermit refused to continue the run: a SIGKILL's victims waited {:?} for \
backend events that never arrived: unaccounted threads {:?}, unpublished \
exits {:?}",
self.waited,
self.unaccounted
.iter()
.map(|t| t.as_raw())
.collect::<Vec<_>>(),
self.unpublished
.iter()
.map(|p| p.as_raw())
.collect::<Vec<_>>(),
)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnfencedSigkill {
pub process: DetPid,
pub reason: String,
}
impl std::fmt::Display for UnfencedSigkill {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"hermit refused to continue the run: the sender of a SIGKILL to process {} \
cannot be held until it is gone: {}",
self.process.as_raw(),
self.reason
)
}
}
pub(crate) fn retires_sigkill_at_the_kill_turn(backend: &reverie::BackendCapabilities) -> bool {
!(backend.needs_killed_thread_rpc_cancellation
|| backend.requires_thread_directed_process_signals
|| backend.process_exits_complete_asynchronously
|| backend.reports_physical_process_exits)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum SigkillReceipt {
Ordinary,
Held,
Committed,
}
#[derive(Debug, Default)]
pub(crate) struct SigkillRetirement {
next_token: u64,
reservations: BTreeMap<u64, Reservation>,
reserved: BTreeMap<DetTid, u64>,
held_receipts: BTreeSet<DetTid>,
unaccounted: BTreeSet<DetTid>,
retained_wakes: BTreeMap<(DetTid, u64), Vec<(DetTid, FutexID)>>,
wake_batches: BTreeMap<DetTid, u64>,
accounted: BTreeSet<DetTid>,
unpublished: BTreeSet<DetPid>,
dying: BTreeSet<DetPid>,
}
impl Scheduler {
pub(crate) fn reserve_sigkill(
&mut self,
sender: DetTid,
target: DetPid,
uid: u32,
) -> Result<SigkillReservation, SigkillRefusal> {
self.reserve_sigkill_processes(sender, &[target], uid)
}
pub(crate) fn reserve_sigkill_group(
&mut self,
sender: DetTid,
pgid: DetPid,
uid: u32,
) -> Result<SigkillReservation, SigkillRefusal> {
let mut members: Vec<DetPid> = self
.thread_tree
.thread_group_leaders
.iter()
.copied()
.filter(|process| self.thread_tree.process_group(*process) == Some(pgid))
.filter(|process| {
self.thread_tree
.my_thread_group(process)
.into_iter()
.any(|tid| self.next_turns.contains_key(&tid))
})
.collect();
members.sort();
self.reserve_sigkill_processes(sender, &members, uid)
}
fn reserve_sigkill_processes(
&mut self,
sender: DetTid,
targets: &[DetPid],
uid: u32,
) -> Result<SigkillReservation, SigkillRefusal> {
if !retires_sigkill_at_the_kill_turn(&self.backend) {
return Err(SigkillRefusal::Backend);
}
if targets.is_empty() {
return Err(SigkillRefusal::NoTarget);
}
let mut victims = Vec::new();
let mut includes_sender = false;
for target in targets {
if !self.thread_tree.thread_group_leaders.contains(target) {
return Err(SigkillRefusal::NoTarget);
}
if self.thread_tree.is_pid_namespace_init(*target) {
crate::detlog::write_loss_notice(&format!(
"a SIGKILL victim, process {target}, is a PID namespace's init, which Linux may protect from it, so the send keeps its host-timed retirement (https://github.com/rrnewton/hermit/issues/3994)"
));
return Err(SigkillRefusal::NamespaceInit(*target));
}
if self.thread_tree.granted_exits.contains(target) {
continue;
}
let own = self.registered_process(sender) == Some(*target);
includes_sender |= own;
let mut threads: Vec<DetTid> = self
.thread_tree
.my_thread_group(target)
.into_iter()
.filter(|tid| self.next_turns.contains_key(tid))
.collect();
if threads.is_empty() {
return Err(SigkillRefusal::NoTarget);
}
threads.retain(|tid| *tid != sender);
threads.sort();
for tid in threads {
if self.sigkill.reserved.contains_key(&tid) {
return Err(SigkillRefusal::AlreadyReserved(tid));
}
let in_unreturned_vfork = self.vfork_barriers.contains_key(&tid)
&& !self.released_vfork_barriers.contains(&tid);
if self.recordreplay_modes
&& self.blocked.external_io_blockers.contains_key(&tid)
&& !in_unreturned_vfork
{
crate::detlog::record_replay_refusal(&format!(
"a SIGKILL victim, thread {tid}, had a background operation in flight during record or replay, so its death is retired at its host-timed deregistration (https://github.com/rrnewton/hermit/issues/3994)"
));
return Err(SigkillRefusal::BackgroundOperation(tid));
}
let Some(mm) = self.thread_mm(tid) else {
crate::detlog::write_loss_notice(&format!(
"a SIGKILL victim, thread {tid}, has no recorded address-space identity, so its death is retired at its host-timed deregistration (https://github.com/rrnewton/hermit/issues/3994)"
));
return Err(SigkillRefusal::UnknownAddressSpace(tid));
};
victims.push(SigkillVictim {
tid,
process: *target,
mm,
});
}
}
let token = self.sigkill.next_token;
self.sigkill.next_token += 1;
for victim in &victims {
self.sigkill.reserved.insert(victim.tid, token);
}
self.sigkill.reservations.insert(
token,
Reservation {
victims,
uid,
includes_sender,
},
);
Ok(SigkillReservation {
token,
includes_sender,
})
}
pub(crate) fn route_sigkill_receipt(&mut self, tid: DetTid) -> SigkillReceipt {
if self.sigkill.reserved.contains_key(&tid) {
self.sigkill.held_receipts.insert(tid);
self.sigkill.accounted.insert(tid);
SigkillReceipt::Held
} else if self.sigkill.unaccounted.remove(&tid) {
self.sigkill.accounted.insert(tid);
SigkillReceipt::Committed
} else {
SigkillReceipt::Ordinary
}
}
pub(crate) fn sigkill_receipt_already_counted(&self, tid: DetTid) -> bool {
self.sigkill.accounted.contains(&tid)
}
pub(crate) fn forget_sigkill_receipt(&mut self, tid: DetTid) {
self.sigkill.accounted.remove(&tid);
}
pub(crate) fn commit_sigkill(&mut self, token: u64, sent: bool) -> Vec<SigkillVictim> {
let Some(reservation) = self.sigkill.reservations.remove(&token) else {
return Vec::new();
};
for victim in &reservation.victims {
self.sigkill.reserved.remove(&victim.tid);
}
if !sent {
let victims: BTreeSet<DetTid> = reservation.victims.iter().map(|v| v.tid).collect();
self.run_retained_wakes_of(|tid| victims.contains(&tid));
for victim in &reservation.victims {
if self.sigkill.held_receipts.remove(&victim.tid) {
self.logically_kill_thread(&victim.tid, &victim.process, victim.mm);
}
}
return Vec::new();
}
let published: BTreeSet<DetPid> = reservation
.victims
.iter()
.map(|victim| victim.process)
.filter(|process| self.child_exit_publications_completed.contains(process))
.collect();
let already_notified: BTreeSet<DetPid> = reservation
.victims
.iter()
.map(|victim| victim.process)
.filter(|process| self.thread_tree.granted_exits.contains(process))
.collect();
for victim in &reservation.victims {
self.sigkill.dying.insert(victim.process);
self.thread_tree.granted_exits.insert(victim.process);
self.record_committed_sigkill(victim.tid, Some(victim.process));
}
for victim in &reservation.victims {
info!(
"[scheduler] retiring dettid {} of SIGKILLed process {} at the kill turn",
victim.tid, victim.process
);
if !self.sigkill.held_receipts.remove(&victim.tid) {
self.sigkill.unaccounted.insert(victim.tid);
}
self.logically_kill_thread(&victim.tid, &victim.process, victim.mm);
}
self.sigkill.dying.clear();
let mut processes: Vec<DetPid> = reservation
.victims
.iter()
.map(|victim| victim.process)
.collect();
processes.dedup();
self.child_exit_publications_completed
.extend(published.iter().copied());
let cohort = (processes.len() > 1).then_some(token);
for process in processes {
if !already_notified.contains(&process) {
self.own_killed_child_notification(process, reservation.uid, cohort);
}
}
for process in &published {
self.child_exit_publications_completed.remove(process);
}
reservation.victims
}
fn own_killed_child_notification(&mut self, process: DetPid, uid: u32, cohort: Option<u64>) {
let Some(parent) = self.thread_tree.parent_process(&process) else {
return;
};
if !self.should_synthesize_child_exit_signal(parent) {
return;
}
if matches!(
self.thread_tree.notification_signal(process),
Some(signal) if signal != libc::SIGCHLD
) {
return;
}
let notification = if self.backend.reports_child_exit_publication {
self.classify_child_exit_notification(process, parent)
} else {
super::ChildExitNotification::Undecided
};
match notification {
super::ChildExitNotification::None | super::ChildExitNotification::Discard => {
if !self.child_exit_publications_completed.remove(&process) {
self.child_exit_publications_pending.insert(process);
self.sigkill.unpublished.insert(process);
}
}
super::ChildExitNotification::Deliver | super::ChildExitNotification::Undecided => {
if self.backend.reports_child_exit_publication
&& !self.child_exit_publications_completed.remove(&process)
{
self.child_exit_publications_pending.insert(process);
self.sigkill.unpublished.insert(process);
}
self.child_exit_sigchld.exit_status.insert(
process,
super::child_exit_sigchld::ChildExitSiginfo {
code: libc::CLD_KILLED,
pid: process.as_raw(),
uid,
status: libc::SIGKILL,
},
);
let deadline = self.committed_time + super::LogicalTime::from_nanos(1);
let parent_thread = if self.models_signal_targets {
self.thread_tree
.process_wait
.get(&process)
.map_or(parent, |metadata| metadata.wait_owner)
} else {
parent
};
if self.backend.reports_kernel_child_exit_signals
&& self.child_exit_sigchld.own(parent, process)
&& let Some(cohort) = cohort
{
self.child_exit_sigchld.join_cohort(process, cohort);
}
self.blocked.timed_waiters.insert_child_exit(
deadline,
process,
parent,
parent_thread,
);
}
}
}
pub(crate) fn sigkill_fence_holds(&self) -> bool {
!self.sigkill.unaccounted.is_empty()
|| self
.sigkill
.unpublished
.iter()
.any(|process| self.child_exit_publications_pending.contains(process))
}
pub(crate) fn note_sigkill_publication(&mut self, process: DetPid) {
self.sigkill.unpublished.remove(&process);
}
pub(crate) fn sigkill_reservation_includes_sender(&self, token: u64) -> bool {
self.sigkill
.reservations
.get(&token)
.is_some_and(|reservation| reservation.includes_sender)
}
pub(crate) fn sigkill_settled(&self, victims: &[SigkillVictim]) -> bool {
victims.iter().all(|victim| {
!self.sigkill.unaccounted.contains(&victim.tid)
&& !self
.child_exit_publications_pending
.contains(&victim.process)
})
}
pub(crate) fn refuse_unsettled_sigkill(&mut self, waited: std::time::Duration) {
if self.sigkill_fence_refusal.is_none() {
let refusal = SigkillFenceRefusal {
unaccounted: self.sigkill.unaccounted.iter().copied().collect(),
unpublished: self
.sigkill
.unpublished
.iter()
.copied()
.filter(|process| self.child_exit_publications_pending.contains(process))
.collect(),
waited,
};
tracing::error!("[sigkill] {}", refusal);
self.sigkill_fence_refusal = Some(refusal);
}
}
pub(crate) fn is_dying_sigkill_victim(&self, process: DetPid) -> bool {
self.sigkill.dying.contains(&process)
}
pub(crate) fn is_unaccounted_sigkill_victim(&self, tid: DetTid) -> bool {
self.sigkill.unaccounted.contains(&tid)
}
pub(crate) fn retain_sigkill_victim_wakes(
&mut self,
from: DetTid,
wakes: &[(DetTid, FutexID)],
) -> bool {
if wakes.is_empty()
|| !(self.sigkill.reserved.contains_key(&from)
|| self.sigkill.unaccounted.contains(&from))
{
return false;
}
let position = self.sigkill.wake_batches.entry(from).or_default();
self.sigkill
.retained_wakes
.insert((from, *position), wakes.to_vec());
*position += 1;
true
}
fn run_retained_wakes_of(&mut self, select: impl Fn(DetTid) -> bool) {
let keys: Vec<(DetTid, u64)> = self
.sigkill
.retained_wakes
.keys()
.filter(|(victim, _)| select(*victim))
.copied()
.collect();
for key in keys {
let wakes = self.sigkill.retained_wakes.remove(&key).unwrap();
let counts = self.wake_futex_waiters_after_exit(&wakes);
for ((owner, futex), count) in wakes.into_iter().zip(counts) {
info!(
"[detcore, dtid {}] robust-list owner death woke {} waiter(s) on futex {:?} after physical exit",
owner, count, futex,
);
}
}
let retained = &self.sigkill.retained_wakes;
self.sigkill
.wake_batches
.retain(|victim, _| retained.keys().any(|(tid, _)| tid == victim));
}
pub(crate) fn run_retained_sigkill_wakes(&mut self) {
if !self.sigkill_fence_holds() && !self.sigkill.retained_wakes.is_empty() {
self.run_retained_wakes_of(|_| true);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::Config;
fn family() -> Scheduler {
let mut scheduler = Scheduler::new(&Config::default());
let [root, sender, target, worker] = [1, 2, 3, 4].map(DetPid::from_raw);
scheduler.thread_tree.add_child(root, root, true);
scheduler.thread_tree.add_child(root, sender, true);
scheduler.thread_tree.add_child(root, target, true);
scheduler.thread_tree.add_child(target, worker, false);
for tid in [root, sender, target, worker] {
super::super::test::register_known_thread_for(&mut scheduler, tid);
scheduler.record_thread_mm(tid, MmId::initial(tid));
}
scheduler
}
fn live(scheduler: &Scheduler, tid: i32) -> bool {
scheduler.next_turns.contains_key(&DetTid::from_raw(tid))
}
#[test]
fn a_committed_sigkill_retires_the_whole_target_and_fences_until_accounted() {
let mut scheduler = family();
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0)
.unwrap()
.token;
assert!(live(&scheduler, 3) && live(&scheduler, 4));
let victims = scheduler.commit_sigkill(token, true);
assert_eq!(
victims.iter().map(|v| v.tid.as_raw()).collect::<Vec<_>>(),
[3, 4]
);
assert!(!live(&scheduler, 3) && !live(&scheduler, 4));
assert!(
scheduler
.logically_exited_processes
.contains(&DetPid::from_raw(3))
);
assert!(scheduler.sigkill_fence_holds());
assert_eq!(
scheduler.route_sigkill_receipt(DetTid::from_raw(4)),
SigkillReceipt::Committed
);
assert!(scheduler.sigkill_fence_holds());
assert_eq!(
scheduler.route_sigkill_receipt(DetTid::from_raw(3)),
SigkillReceipt::Committed
);
assert!(
scheduler.sigkill_fence_holds(),
"the victim's exit is not yet published to its parent"
);
scheduler.complete_child_exit_publication(DetPid::from_raw(3));
assert!(!scheduler.sigkill_fence_holds());
assert_eq!(
scheduler.route_sigkill_receipt(DetTid::from_raw(3)),
SigkillReceipt::Ordinary
);
}
#[test]
fn the_fence_waits_for_no_publication_but_the_victims() {
let mut scheduler = family();
let bystander = DetPid::from_raw(2);
scheduler.child_exit_publications_pending.insert(bystander);
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0)
.unwrap()
.token;
scheduler.commit_sigkill(token, true);
for tid in [3, 4] {
scheduler.route_sigkill_receipt(DetTid::from_raw(tid));
}
assert!(scheduler.sigkill_fence_holds());
scheduler.complete_child_exit_publication(DetPid::from_raw(3));
assert!(!scheduler.sigkill_fence_holds());
assert!(
scheduler
.child_exit_publications_pending
.contains(&bystander)
);
}
#[test]
fn a_new_thread_on_a_victims_tid_is_accounted_afresh() {
let mut scheduler = family();
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0)
.unwrap()
.token;
scheduler.commit_sigkill(token, true);
let tid = DetTid::from_raw(4);
scheduler.route_sigkill_receipt(tid);
assert!(scheduler.sigkill_receipt_already_counted(tid));
scheduler.forget_committed_exit(tid);
assert!(
!scheduler.sigkill_receipt_already_counted(tid),
"the new thread inherits the old one's counted receipt"
);
}
#[test]
fn an_early_receipt_is_held_until_the_commit() {
let mut scheduler = family();
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0)
.unwrap()
.token;
assert_eq!(
scheduler.route_sigkill_receipt(DetTid::from_raw(4)),
SigkillReceipt::Held
);
assert!(live(&scheduler, 4), "a held receipt retires nothing");
scheduler.commit_sigkill(token, true);
assert!(!live(&scheduler, 4));
scheduler.route_sigkill_receipt(DetTid::from_raw(3));
scheduler.complete_child_exit_publication(DetPid::from_raw(3));
assert!(
!scheduler.sigkill_fence_holds(),
"the held receipt was counted"
);
}
#[test]
fn a_failed_send_unwinds_the_reservation() {
let mut scheduler = family();
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0)
.unwrap()
.token;
scheduler.route_sigkill_receipt(DetTid::from_raw(4));
assert!(scheduler.commit_sigkill(token, false).is_empty());
assert!(live(&scheduler, 3), "no kill happened");
assert!(
!live(&scheduler, 4),
"the held receipt took the ordinary path"
);
assert!(!scheduler.sigkill_fence_holds());
assert_eq!(
scheduler.route_sigkill_receipt(DetTid::from_raw(3)),
SigkillReceipt::Ordinary
);
}
#[test]
fn sends_the_protocol_cannot_cover_are_refused() {
let mut scheduler = family();
let [sender, target] = [2, 3].map(DetPid::from_raw);
let own = scheduler.reserve_sigkill(sender, sender, 0).unwrap();
assert!(own.includes_sender);
scheduler.commit_sigkill(own.token, false);
assert_eq!(
scheduler.reserve_sigkill(sender, DetPid::from_raw(99), 0),
Err(SigkillRefusal::NoTarget)
);
scheduler.thread_mms.remove(&DetTid::from_raw(4));
assert_eq!(
scheduler.reserve_sigkill(sender, target, 0),
Err(SigkillRefusal::UnknownAddressSpace(DetTid::from_raw(4)))
);
scheduler.record_thread_mm(DetTid::from_raw(4), MmId::initial(DetTid::from_raw(4)));
let _reserved = scheduler.reserve_sigkill(sender, target, 0).unwrap();
assert_eq!(
scheduler.reserve_sigkill(DetPid::from_raw(1), target, 0),
Err(SigkillRefusal::AlreadyReserved(DetTid::from_raw(3)))
);
}
#[test]
fn a_process_group_sigkill_retires_every_member() {
let mut scheduler = family();
let [root, sender, target] = [1, 2, 3].map(DetPid::from_raw);
let group = DetPid::from_raw(77);
assert!(scheduler.thread_tree.set_process_group(target, group));
assert!(scheduler.thread_tree.set_process_group(root, group));
let reserved = scheduler.reserve_sigkill_group(sender, group, 0).unwrap();
assert!(!reserved.includes_sender);
let victims = scheduler.commit_sigkill(reserved.token, true);
assert_eq!(
victims.iter().map(|v| v.tid.as_raw()).collect::<Vec<_>>(),
[1, 3, 4]
);
assert!(!live(&scheduler, 1) && !live(&scheduler, 3) && !live(&scheduler, 4));
assert!(live(&scheduler, 2));
let mut scheduler = family();
assert!(scheduler.thread_tree.set_process_group(sender, group));
assert!(scheduler.thread_tree.set_process_group(target, group));
let reserved = scheduler.reserve_sigkill_group(sender, group, 0).unwrap();
assert!(reserved.includes_sender);
let victims = scheduler.commit_sigkill(reserved.token, true);
assert_eq!(
victims.iter().map(|v| v.tid.as_raw()).collect::<Vec<_>>(),
[3, 4]
);
assert!(live(&scheduler, 2));
}
#[test]
fn a_pid_namespace_init_is_not_reserved() {
let mut scheduler = family();
let [sender, target] = [2, 3].map(DetPid::from_raw);
scheduler.thread_tree.mark_pid_namespace_init(target);
assert_eq!(
scheduler.reserve_sigkill(sender, target, 0),
Err(SigkillRefusal::NamespaceInit(target))
);
assert!(live(&scheduler, 3));
}
#[test]
fn backends_with_their_own_death_reports_are_refused() {
let config = Config::default().with_backend(|backend| {
backend.requires_thread_directed_process_signals = true;
});
let mut scheduler = Scheduler::new(&config);
let [root, target] = [1, 3].map(DetPid::from_raw);
scheduler.thread_tree.add_child(root, root, true);
scheduler.thread_tree.add_child(root, target, true);
assert_eq!(
scheduler.reserve_sigkill(root, target, 0),
Err(SigkillRefusal::Backend)
);
}
#[test]
fn victims_owner_death_wakes_do_not_depend_on_receipt_order() {
let mm = MmId::initial(DetTid::from_raw(3));
let futexes = [0x404100, 0x404200].map(|addr| FutexID::private(mm, addr));
let run = |fuzz: bool, reverse: bool| {
let mut scheduler = family();
scheduler.fuzz_futexes = fuzz;
for (futex, waiters) in futexes.iter().zip([[11, 12, 13], [14, 15, 16]]) {
for raw in waiters {
let tid = DetTid::from_raw(raw);
super::super::test::register_known_thread_for(&mut scheduler, tid);
scheduler.sleep_futex_waiter(&tid, *futex, None, u32::MAX, None);
}
}
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0)
.unwrap()
.token;
scheduler.commit_sigkill(token, true);
let mut receipts = [
(DetTid::from_raw(3), futexes[0]),
(DetTid::from_raw(4), futexes[1]),
];
if reverse {
receipts.reverse();
}
for (victim, futex) in receipts {
if !scheduler.retain_sigkill_victim_wakes(victim, &[(victim, futex)]) {
scheduler.wake_futex_waiters_after_exit(&[(victim, futex)]);
}
let _ = scheduler.step2_drain_prefix();
assert_eq!(
scheduler.route_sigkill_receipt(victim),
SigkillReceipt::Committed
);
let _ = scheduler.step2_drain_prefix();
}
assert!(scheduler.sigkill_fence_holds(), "the exit is unpublished");
scheduler.complete_child_exit_publication(DetPid::from_raw(3));
let _ = scheduler.step2_drain_prefix();
let still_waiting: Vec<Vec<DetTid>> = futexes
.iter()
.map(|futex| {
scheduler
.blocked
.futex_waiters
.get(futex)
.map(|waiters| waiters.iter().map(|w| w.dettid).collect())
.unwrap_or_default()
})
.collect();
let queue: Vec<DetTid> = scheduler.run_queue.tids().copied().collect();
let next_draw: u64 = rand::RngExt::random(&mut scheduler.fuzz_prng);
(still_waiting, queue, next_draw)
};
for fuzz in [false, true] {
let forward = run(fuzz, false);
assert_eq!(forward.0.iter().map(Vec::len).collect::<Vec<_>>(), [2, 2]);
assert_eq!(forward, run(fuzz, true), "fuzz={fuzz}");
}
}
#[test]
fn record_mode_refuses_a_background_victim_except_an_unreturned_vfork() {
let victim = DetTid::from_raw(3);
for (case, refused) in [
("background read", true),
("vfork not returned", false),
("vfork released", true),
] {
let mut scheduler = family();
scheduler.recordreplay_modes = true;
scheduler
.blocked
.external_io_blockers
.insert(victim, crate::resources::ExternalOpId::new(victim, 1));
match case {
"vfork not returned" => {
scheduler.vfork_barriers.insert(victim, None);
}
"vfork released" => {
scheduler
.vfork_barriers
.insert(victim, Some(DetTid::from_raw(9)));
scheduler.released_vfork_barriers.insert(victim);
}
_ => {}
}
let reserved = scheduler.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0);
assert_eq!(
matches!(reserved, Err(SigkillRefusal::BackgroundOperation(tid)) if tid == victim),
refused,
"{case}: {reserved:?}"
);
}
}
#[test]
fn a_killed_child_with_a_non_sigchld_exit_signal_gets_no_synthetic_sigchld() {
for exit_signal in [libc::SIGUSR1, 0] {
let mut scheduler = Scheduler::new(&Config::default());
let [root, sender, child] = [1, 2, 3].map(DetPid::from_raw);
scheduler.thread_tree.add_child(root, root, true);
scheduler.thread_tree.add_child(root, sender, true);
scheduler.thread_tree.add_child_with_wait_metadata(
root,
child,
true,
false,
exit_signal,
);
for tid in [root, sender, child] {
super::super::test::register_known_thread_for(&mut scheduler, tid);
scheduler.record_thread_mm(tid, MmId::initial(tid));
}
let token = scheduler.reserve_sigkill(sender, child, 0).unwrap().token;
scheduler.commit_sigkill(token, true);
let timer_armed = scheduler.blocked.timed_waiters.iter().any(|(_, event)| {
matches!(
event,
super::super::TimedEvent::SignalEvt(
super::super::timed_waiters::SignalTimerId::ChildExit { child: exited, .. },
..
) if exited == child
)
});
assert!(!timer_armed, "exit signal {exit_signal}");
assert!(
scheduler.child_exit_publications_pending.is_empty(),
"exit signal {exit_signal}"
);
}
}
#[test]
fn a_committed_sigkill_dooms_its_victims_for_the_deadlock_check() {
let mut scheduler = family();
let target = DetPid::from_raw(3);
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), target, 0)
.unwrap()
.token;
assert_eq!(scheduler.sigkill_recorded(target), (false, false));
scheduler.commit_sigkill(token, true);
assert_eq!(scheduler.sigkill_recorded(target), (true, false));
}
#[test]
fn a_sigkill_fence_past_its_valve_refuses_the_run() {
let mut scheduler = family();
let token = scheduler
.reserve_sigkill(DetTid::from_raw(2), DetPid::from_raw(3), 0)
.unwrap()
.token;
scheduler.commit_sigkill(token, true);
assert!(scheduler.step2_drain_prefix().is_err());
assert!(scheduler.sigkill_fence_refusal.is_none());
scheduler.sigkill_fence_wait_since = std::time::Instant::now()
.checked_sub(Scheduler::SIGKILL_FENCE_VALVE + std::time::Duration::from_secs(1));
assert!(scheduler.step2_drain_prefix().is_err());
let refusal = scheduler
.sigkill_fence_refusal
.take()
.expect("the fence must refuse past its valve");
assert_eq!(
refusal.unaccounted,
[DetTid::from_raw(3), DetTid::from_raw(4)]
);
assert!(refusal.waited >= Scheduler::SIGKILL_FENCE_VALVE);
assert!(
refusal
.to_string()
.starts_with("hermit refused to continue the run")
);
}
}