use std::collections::BTreeMap;
use std::collections::BTreeSet;
use detcore_model::bundled_signal_facts;
use serde::Deserialize;
use serde::Serialize;
use super::Scheduler;
use super::signal_lists::KernelSiginfo;
use super::signal_lists::SignalLists;
use super::signal_lists::siginfo_code;
use crate::resources::ResourceID;
use crate::scheduler::kernel_signal_bit;
use crate::syscalls::KernelSignalState;
use crate::syscalls::ignored_at_generation;
use crate::syscalls::read_kernel_signal_state;
use crate::types::DetPid;
use crate::types::DetTid;
pub(crate) fn records(cfg: &crate::config::Config) -> bool {
bundled_signal_facts::models_signal_targets(cfg)
}
pub(crate) const STANDARD_SIGNALS: u64 = (1 << 31) - 1;
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
PartialOrd,
Ord,
Serialize,
Deserialize
)]
pub enum QueueId {
Thread(DetTid),
Process(DetPid),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct TimerProducer {
pub process: DetPid,
pub timer: i32,
pub arm_gen: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum SignalProducer {
ItimerReal,
Posix(TimerProducer),
}
pub(crate) fn itimer_real_siginfo() -> [u8; reverie::SIGNAL_INFO_SIZE] {
let mut info = [0; reverie::SIGNAL_INFO_SIZE];
info[..4].copy_from_slice(&libc::SIGALRM.to_ne_bytes());
info[8..12].copy_from_slice(&libc::SI_KERNEL.to_ne_bytes());
info
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum SendFate {
Classify(Option<SignalProducer>),
Kept,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct PreSend {
pub(crate) present: bool,
pub(crate) generation: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum Consumption {
KeptResume { blocked: bool },
Dropped,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum AlarmOrigin {
ItimerReal,
Other,
Unknown,
}
#[derive(Debug, Default)]
pub(crate) struct DiscardedAtSend {
bits: BTreeMap<QueueId, u64>,
alarm_first: BTreeMap<QueueId, AlarmOrigin>,
alarm_unreported: BTreeSet<DetPid>,
kept: BTreeMap<QueueId, u64>,
clear_generation: BTreeMap<(QueueId, i32), u64>,
parked: BTreeMap<(DetPid, i32), ParkedExpiry>,
pub(crate) lists: SignalLists,
timer_history: BTreeSet<(DetPid, i32)>,
discarded_si_timer: BTreeSet<(QueueId, i32)>,
park_seq: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct SendRecord {
pub siginfo: KernelSiginfo,
pub listed: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ParkedExpiry {
queue: QueueId,
signal: i32,
arm_gen: u64,
seq: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum UnignoreAction {
Send(QueueId, super::signal_lists::TimerEntry),
Wake(QueueId),
}
impl DiscardedAtSend {
pub(crate) fn discarded(&self, queue: QueueId) -> u64 {
self.bits.get(&queue).copied().unwrap_or(0) & STANDARD_SIGNALS
}
pub(crate) fn is_discarded(&self, queue: QueueId, signal: i32) -> bool {
self.discarded(queue) & kernel_signal_bit(signal) != 0
}
pub(crate) fn pre_send(&self, queue: QueueId, signal: i32, present: bool) -> PreSend {
PreSend {
present,
generation: self.generation(queue, signal),
}
}
pub(crate) fn note_send(
&mut self,
queue: QueueId,
signal: i32,
discarded: bool,
pre: PreSend,
producer: Option<TimerProducer>,
) {
self.note_send_with_alarm_origin(
queue,
signal,
discarded,
pre,
producer,
AlarmOrigin::Other,
);
}
pub(crate) fn note_itimer_real_send(&mut self, queue: QueueId, discarded: bool, pre: PreSend) {
self.note_send_with_alarm_origin(
queue,
libc::SIGALRM,
discarded,
pre,
None,
AlarmOrigin::ItimerReal,
);
}
pub(crate) fn alarm_origin(&self, queue: QueueId) -> AlarmOrigin {
self.alarm_first
.get(&queue)
.copied()
.unwrap_or(AlarmOrigin::Unknown)
}
pub(crate) fn has_recorded_copy(&self, queue: QueueId, signal: i32) -> bool {
let bit = kernel_signal_bit(signal) & STANDARD_SIGNALS;
self.kept.get(&queue).is_some_and(|kept| kept & bit != 0)
|| self.is_discarded(queue, signal)
}
pub(crate) fn claim_itimer_real(&mut self, source: QueueId) -> bool {
if self.alarm_origin(source) != AlarmOrigin::ItimerReal {
return false;
}
self.retire_copy(source, libc::SIGALRM);
true
}
fn note_send_with_alarm_origin(
&mut self,
queue: QueueId,
signal: i32,
discarded: bool,
pre: PreSend,
producer: Option<TimerProducer>,
origin: AlarmOrigin,
) {
let bit = kernel_signal_bit(signal) & STANDARD_SIGNALS;
if bit == 0 {
return;
}
if !discarded {
if signal == libc::SIGALRM {
let same_generation = self.generation(queue, signal) == pre.generation;
let preserves_first =
pre.present && same_generation && !self.is_discarded(queue, signal);
if !preserves_first {
self.alarm_first.insert(queue, origin);
}
}
self.clear_bit(queue, signal);
*self.kept.entry(queue).or_default() |= bit;
return;
}
let emptied = !pre.present || self.generation(queue, signal) != pre.generation;
if emptied {
*self.bits.entry(queue).or_default() |= bit;
if signal == libc::SIGALRM {
self.alarm_first.remove(&queue);
}
}
if let Some(producer) = producer {
self.park(
producer.process,
producer.timer,
queue,
signal,
producer.arm_gen,
);
}
}
#[expect(
clippy::too_many_arguments,
reason = "note_send's facts, plus the receiving process and the record"
)]
pub(crate) fn note_send_listed(
&mut self,
process: DetPid,
queue: QueueId,
signal: i32,
discarded: bool,
pre: PreSend,
producer: Option<TimerProducer>,
record: SendRecord,
) {
if kernel_signal_bit(signal) & STANDARD_SIGNALS == 0 {
return;
}
let standing = self
.is_discarded(queue, signal)
.then(|| self.discarded_si_timer.contains(&(queue, signal)));
self.note_send(queue, signal, discarded, pre, producer);
if discarded {
if standing.is_none() && self.is_discarded(queue, signal) {
self.note_discarded_si_timer(queue, signal, siginfo_code(&record.siginfo));
}
return;
}
if record.listed {
let timer_pair = self.has_timer_history(process, signal);
self.lists
.append_plain(queue, signal, record.siginfo, standing, timer_pair);
debug_assert!(self.lists.invariants_hold());
}
}
pub(crate) fn note_discarded_si_timer(&mut self, queue: QueueId, signal: i32, code: i32) {
if code == super::signal_lists::SI_TIMER {
self.discarded_si_timer.insert((queue, signal));
} else {
self.discarded_si_timer.remove(&(queue, signal));
}
}
pub(crate) fn discarded_is_si_timer(&self, queue: QueueId, signal: i32) -> bool {
self.is_discarded(queue, signal) && self.discarded_si_timer.contains(&(queue, signal))
}
pub(crate) fn note_timer_history(&mut self, process: DetPid, signal: i32) {
self.timer_history.insert((process, signal));
}
pub(crate) fn has_timer_history(&self, process: DetPid, signal: i32) -> bool {
self.timer_history.contains(&(process, signal))
}
pub(crate) fn consume(
&mut self,
thread: DetTid,
process: DetPid,
signal: i32,
how: Consumption,
thread_holds: bool,
process_holds: bool,
) {
if how == (Consumption::KeptResume { blocked: true }) {
return;
}
if !thread_holds {
self.retire_copy(QueueId::Thread(thread), signal);
}
if !process_holds {
self.retire_copy(QueueId::Process(process), signal);
}
}
pub(crate) fn take(&mut self, source: QueueId, signal: i32) -> bool {
let discarded = self.is_discarded(source, signal);
self.retire_copy(source, signal);
discarded
}
pub(crate) fn take_from(&mut self, thread: DetTid, process: DetPid, signal: i32) -> bool {
let (private, shared) = (QueueId::Thread(thread), QueueId::Process(process));
let bit = kernel_signal_bit(signal);
let source = if self.kept.get(&private).is_some_and(|kept| kept & bit != 0)
|| self.is_discarded(private, signal)
|| !self.is_discarded(shared, signal)
{
private
} else {
shared
};
if signal == libc::SIGALRM
&& source == private
&& !self.kept.get(&private).is_some_and(|kept| kept & bit != 0)
&& !self.is_discarded(private, signal)
{
self.alarm_first.remove(&shared);
}
self.take(source, signal)
}
pub(crate) fn take_faulted(
&mut self,
thread: DetTid,
process: DetPid,
set: u64,
thread_pending: u64,
shared_pending: u64,
) -> bool {
let (private, shared) = (QueueId::Thread(thread), QueueId::Process(process));
let alarm = kernel_signal_bit(libc::SIGALRM);
if set & alarm != 0 {
for (queue, pending) in [(private, thread_pending), (shared, shared_pending)] {
if pending & alarm == 0 && self.alarm_first.contains_key(&queue) {
self.retire_copy(queue, libc::SIGALRM);
}
}
}
let emptied = |queue, pending: u64| self.discarded(queue) & set & !pending;
let candidates = [
(private, emptied(private, thread_pending)),
(shared, emptied(shared, shared_pending)),
];
let Some((queue, bits)) = candidates
.into_iter()
.filter(|(_, bits)| *bits != 0)
.min_by_key(|(_, bits)| bits.trailing_zeros())
else {
return false;
};
let signal = bits.trailing_zeros() as i32 + 1;
self.take(queue, signal)
}
pub(crate) fn flush(&mut self, queues: impl IntoIterator<Item = QueueId>, signal: i32) {
for queue in queues {
self.retire_copy(queue, signal);
}
}
pub(crate) fn unignore(
&mut self,
process: DetPid,
signal: i32,
current: impl Fn(&TimerProducer) -> bool,
) -> Vec<(QueueId, TimerProducer)> {
let mut resend: Vec<(QueueId, TimerProducer)> = Vec::new();
for producer in self.parked_timers(process, signal) {
let Some(parked) = self.parked.remove(&(process, producer.timer)) else {
continue;
};
if !current(&producer) {
continue;
}
if self.is_discarded(parked.queue, signal) {
self.clear_bit(parked.queue, signal);
*self.kept.entry(parked.queue).or_default() |= kernel_signal_bit(signal);
if signal == libc::SIGALRM {
self.alarm_first.insert(parked.queue, AlarmOrigin::Other);
}
} else if !resend.iter().any(|(queue, _)| *queue == parked.queue) {
resend.push((parked.queue, producer));
}
}
resend
}
fn park(&mut self, process: DetPid, timer: i32, queue: QueueId, signal: i32, arm_gen: u64) {
let seq = match self.parked.get(&(process, timer)) {
Some(parked) => parked.seq,
None => {
self.park_seq += 1;
self.park_seq
}
};
self.parked.insert(
(process, timer),
ParkedExpiry {
queue,
signal,
arm_gen,
seq,
},
);
}
pub(crate) fn flush_lists(
&mut self,
queues: &[QueueId],
signal: i32,
live: impl Fn(DetPid, i32) -> bool,
) {
for &queue in queues {
for entry in self.lists.take_all(queue, signal) {
if let super::signal_lists::Entry::Timer(timer) = entry
&& timer.periodic_at_send
&& live(timer.process, timer.timer)
{
self.park(timer.process, timer.timer, queue, signal, timer.gen_at_send);
}
}
}
self.flush(queues.iter().copied(), signal);
}
pub(crate) fn unignore_lists(
&mut self,
process: DetPid,
signal: i32,
live: impl Fn(DetPid, i32) -> bool,
) -> Vec<UnignoreAction> {
use super::signal_lists::TimerAppend;
let mut parks: Vec<(i32, ParkedExpiry)> = self
.parked
.iter()
.filter(|((owner, _), parked)| *owner == process && parked.signal == signal)
.map(|(&(_, timer), parked)| (timer, *parked))
.collect();
for (timer, _) in &parks {
self.parked.remove(&(process, *timer));
}
parks.retain(|(timer, _)| live(process, *timer));
parks.sort_by_key(|(_, parked)| std::cmp::Reverse(parked.seq));
let mut actions = Vec::new();
for (timer, parked) in parks {
let entry = super::signal_lists::TimerEntry {
process,
timer,
gen_at_send: parked.arm_gen,
periodic_at_send: true,
};
let standing = self
.is_discarded(parked.queue, signal)
.then(|| self.discarded_si_timer.contains(&(parked.queue, signal)));
match self
.lists
.append_timer(parked.queue, signal, entry, standing)
{
TimerAppend::SendFront => actions.push(UnignoreAction::Send(parked.queue, entry)),
TimerAppend::ProxyFront => {
self.clear_bit(parked.queue, signal);
*self.kept.entry(parked.queue).or_default() |= kernel_signal_bit(signal);
actions.push(UnignoreAction::Wake(parked.queue));
}
TimerAppend::Behind | TimerAppend::AlreadyPending => {}
}
}
actions
}
pub(crate) fn parked_processes(&self) -> Vec<DetPid> {
self.parked.keys().map(|(process, _)| *process).collect()
}
pub(crate) fn forget_park(&mut self, process: DetPid, timer: i32) {
self.parked.remove(&(process, timer));
}
pub(crate) fn forget_parks_of(&mut self, process: DetPid) {
self.parked.retain(|&(owner, _), _| owner != process);
}
pub(crate) fn parked_timers(&self, process: DetPid, signal: i32) -> Vec<TimerProducer> {
self.parked
.iter()
.filter(|((owner, _), parked)| *owner == process && parked.signal == signal)
.map(|(&(_, timer), parked)| TimerProducer {
process,
timer,
arm_gen: parked.arm_gen,
})
.collect()
}
pub(crate) fn rekey_thread(&mut self, from: DetTid, to: DetTid) {
if from == to {
return;
}
let (old, new) = (QueueId::Thread(from), QueueId::Thread(to));
self.retire(new);
if let Some(origin) = self.alarm_first.remove(&old) {
self.alarm_first.insert(new, origin);
}
if let Some(bits) = self.bits.remove(&old) {
self.bits.insert(new, bits);
}
if let Some(kept) = self.kept.remove(&old) {
self.kept.insert(new, kept);
}
let generations: Vec<_> = self
.clear_generation
.range((old, i32::MIN)..=(old, i32::MAX))
.map(|(&(_, signal), &generation)| (signal, generation))
.collect();
for (signal, generation) in generations {
self.clear_generation.remove(&(old, signal));
self.clear_generation.insert((new, signal), generation);
}
for parked in self.parked.values_mut() {
if parked.queue == old {
parked.queue = new;
}
}
let si_timer: Vec<i32> = self
.discarded_si_timer
.iter()
.filter(|(queue, _)| *queue == old)
.map(|(_, signal)| *signal)
.collect();
for signal in si_timer {
self.discarded_si_timer.remove(&(old, signal));
self.discarded_si_timer.insert((new, signal));
}
self.lists.rekey_thread(old, new);
}
pub(crate) fn retire(&mut self, queue: QueueId) -> Vec<super::signal_lists::Entry> {
let entries = self.lists.retire(queue);
self.discarded_si_timer.retain(|&(owner, _)| owner != queue);
if let QueueId::Process(process) = queue {
self.timer_history.retain(|&(owner, _)| owner != process);
self.alarm_unreported.remove(&process);
}
self.alarm_first.remove(&queue);
self.bits.remove(&queue);
self.kept.remove(&queue);
self.clear_generation
.retain(|&(entry, _), _| entry != queue);
self.parked.retain(|&(owner, _), parked| {
parked.queue != queue && QueueId::Process(owner) != queue
});
entries
}
fn generation(&self, queue: QueueId, signal: i32) -> u64 {
self.clear_generation
.get(&(queue, signal))
.copied()
.unwrap_or(0)
}
fn retire_copy(&mut self, queue: QueueId, signal: i32) {
if signal == libc::SIGALRM {
self.alarm_first.remove(&queue);
}
self.clear_bit(queue, signal);
if let Some(kept) = self.kept.get_mut(&queue) {
*kept &= !kernel_signal_bit(signal);
}
*self.clear_generation.entry((queue, signal)).or_default() += 1;
}
fn clear_bit(&mut self, queue: QueueId, signal: i32) {
if let Some(bits) = self.bits.get_mut(&queue) {
*bits &= !kernel_signal_bit(signal);
}
self.discarded_si_timer.remove(&(queue, signal));
self.prune(queue);
}
fn prune(&mut self, queue: QueueId) {
if self.bits.get(&queue) == Some(&0) {
self.bits.remove(&queue);
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum DiscardedSignalControl {
PreSend {
named: DetTid,
queue: QueueId,
signal: i32,
},
Sent(DiscardToken, Option<KernelSiginfo>),
Consumed {
signal: i32,
how: Consumption,
thread_holds: bool,
process_holds: bool,
},
Take {
signal: i32,
at: crate::types::LogicalTime,
after: Option<(u64, u64)>,
},
TakeFaulted {
set: u64,
thread_pending: u64,
shared_pending: u64,
at: crate::types::LogicalTime,
},
Flushed { signal: i32 },
Unignored { signal: i32 },
Bits,
ClaimItimerReal,
UnreportedAlarm,
Dequeue {
signal: i32,
at: crate::types::LogicalTime,
},
DeliveryInfo {
signal: i32,
at: crate::types::LogicalTime,
},
Unreported { signal: i32 },
Handler {
signal: i32,
caught: bool,
mask: u64,
nodefer: bool,
},
TimerCreated { signal: i32 },
Queued,
TimerReadout {
timer: i32,
now: crate::types::LogicalTime,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum DiscardedSignalAnswer {
Recorded,
Token(DiscardToken),
Discarded(bool),
Bits {
thread: u64,
process: u64,
},
ItimerReal(bool),
Delivery(super::posix_timer_coalesce::DeliveryAnswer),
TimerReadout {
remaining: Option<crate::types::LogicalTime>,
overrun: i32,
},
Taken(super::posix_timer_coalesce::TakeOutcome),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct DiscardToken {
pub queue: QueueId,
pub signal: i32,
pub discarded: bool,
pub present: bool,
pub generation: u64,
}
impl Scheduler {
pub(crate) fn discarded_when_sent_to(
&self,
named: DetTid,
signal: i32,
sender: Option<DetTid>,
) -> bool {
let bit = kernel_signal_bit(signal) & STANDARD_SIGNALS;
if !self.models_signal_targets || bit == 0 {
return false;
}
let Some(mask) = self.discard_mask(named, signal) else {
return false;
};
if mask & bit != 0 {
return false;
}
let Some((ignored, caught)) = self.named_dispositions(named, signal) else {
return false;
};
if ignored_at_generation(ignored, caught) & bit != 0 {
return true;
}
let process = self.thread_tree.process_of(named).unwrap_or(named);
if !self.thread_tree.is_pid_namespace_init(process) || caught & bit != 0 {
return false;
}
if signal == libc::SIGKILL || signal == libc::SIGSTOP {
return sender.is_some_and(|sender| {
self.thread_tree.pid_namespaces.namespace_of(sender) == Some(process)
});
}
true
}
pub(crate) fn discard_mask(&self, named: DetTid, signal: i32) -> Option<u64> {
if let Some(saved) = self.saved_guest_sigmasks.get(&named) {
return Some(*saved);
}
if let Some(watch) = self
.parked_futex_waiter(named)
.and_then(|waiter| waiter.signal_watch)
{
return Some(!watch.unblocked);
}
if let Some(recorded) = self.blocked.out_of_scheduler_masks.get(&named) {
return *recorded;
}
if let Some(kept) = self.blocked.continuation_masks.get(&named) {
return *kept;
}
if let Some(mask) = self.filed_sigsuspend_mask(named) {
return Some(mask);
}
if !self.next_turns.contains_key(&named) {
return None;
}
self.blocked_mask_for(named, signal)
}
fn filed_sigsuspend_mask(&self, dettid: DetTid) -> Option<u64> {
let Some(Some(Ok(request))) = self.next_turns.get(&dettid).map(|nt| nt.req.try_read())
else {
return None;
};
request
.resources
.keys()
.any(|rid| matches!(rid, ResourceID::BlockingRtSigsuspend(_)))
.then_some(request.blocked_signal_mask)
.flatten()
}
fn named_dispositions(&self, named: DetTid, signal: i32) -> Option<(u64, u64)> {
if !self.next_turns.contains_key(&named) {
return None;
}
if let Some(published) = self.published_dispositions_for(named, signal) {
tracing::trace!(
"[dtid {}] a send of signal {} reads its process's published dispositions",
named,
signal
);
return Some((published.ignored, published.caught));
}
let state = self.named_signal_state(named)?;
Some((state.ignored, state.caught))
}
fn named_signal_state(&self, named: DetTid) -> Option<KernelSignalState> {
if !self.next_turns.contains_key(&named) {
return None;
}
#[cfg(test)]
if let Some(state) = self.test_kernel_signal_states.get(&named) {
return Some(*state);
}
let process = self.thread_tree.process_of(named).unwrap_or(named);
read_kernel_signal_state(
reverie::Pid::from_raw(process.as_raw()),
reverie::Pid::from_raw(named.as_raw()),
)
.ok()
}
fn queue_holds(&self, queue: QueueId, signal: i32) -> bool {
let bit = kernel_signal_bit(signal);
let state = match queue {
QueueId::Thread(thread) => self.named_signal_state(thread).map(|s| s.thread_pending),
QueueId::Process(process) => self
.process_signal_targets(process)
.into_iter()
.find_map(|thread| self.named_signal_state(thread))
.map(|s| s.shared_pending),
};
state.is_none_or(|pending| pending & bit != 0)
}
pub(crate) fn discard_pre_send(
&self,
named: DetTid,
queue: QueueId,
signal: i32,
sender: Option<DetTid>,
) -> DiscardToken {
let discarded = self.discarded_when_sent_to(named, signal, sender);
let pre = self
.discarded_at_send
.pre_send(queue, signal, self.queue_holds(queue, signal));
DiscardToken {
queue,
signal,
discarded,
present: pre.present,
generation: pre.generation,
}
}
pub(crate) fn discard_kept_token(&self, queue: QueueId, signal: i32) -> DiscardToken {
let pre = self
.discarded_at_send
.pre_send(queue, signal, self.queue_holds(queue, signal));
DiscardToken {
queue,
signal,
discarded: false,
present: pre.present,
generation: pre.generation,
}
}
pub(crate) fn discard_note_send(
&mut self,
token: DiscardToken,
producer: Option<TimerProducer>,
record: Option<KernelSiginfo>,
) {
let pre = PreSend {
present: token.present,
generation: token.generation,
};
match record {
Some(siginfo) => {
if !token.discarded {
self.pop_in_flight_front(token.queue, token.signal, token.present);
}
let process = match token.queue {
QueueId::Thread(thread) => {
self.thread_tree.process_of(thread).unwrap_or(thread)
}
QueueId::Process(process) => process,
};
let listed = !token.discarded && self.signal_observable(process, token.signal);
self.discarded_at_send.note_send_listed(
process,
token.queue,
token.signal,
token.discarded,
pre,
producer,
SendRecord { siginfo, listed },
);
}
None => self.discarded_at_send.note_send(
token.queue,
token.signal,
token.discarded,
pre,
producer,
),
}
self.discard_job_control_flush(token.queue, token.signal);
}
pub(crate) fn discard_note_fate(
&mut self,
token: DiscardToken,
fate: SendFate,
record: Option<KernelSiginfo>,
) {
match fate {
SendFate::Classify(Some(SignalProducer::ItimerReal)) => {
self.discard_note_itimer_real(token)
}
SendFate::Classify(Some(SignalProducer::Posix(timer))) => {
self.discard_note_send(token, Some(timer), record)
}
SendFate::Classify(None) | SendFate::Kept => {
self.discard_note_send(token, None, record)
}
}
}
pub(crate) fn discard_note_itimer_real(&mut self, token: DiscardToken) {
debug_assert_eq!(token.signal, libc::SIGALRM);
self.discarded_at_send.note_itimer_real_send(
token.queue,
token.discarded,
PreSend {
present: token.present,
generation: token.generation,
},
);
}
fn claim_reported_itimer_real(&mut self, thread: DetTid, process: DetPid) -> bool {
if !self.alarm_observable_now(process)
|| self.discarded_at_send.alarm_unreported.contains(&process)
{
return false;
}
let private = QueueId::Thread(thread);
let shared = QueueId::Process(process);
let source = if self
.discarded_at_send
.has_recorded_copy(private, libc::SIGALRM)
{
private
} else if self
.discarded_at_send
.has_recorded_copy(shared, libc::SIGALRM)
{
shared
} else {
return false;
};
self.discarded_at_send.claim_itimer_real(source)
}
fn discard_job_control_flush(&mut self, queue: QueueId, signal: i32) {
const STOPS: [i32; 4] = [libc::SIGSTOP, libc::SIGTSTP, libc::SIGTTIN, libc::SIGTTOU];
let flushed: &[i32] = if STOPS.contains(&signal) {
&[libc::SIGCONT]
} else if signal == libc::SIGCONT {
&STOPS
} else {
return;
};
let process = match queue {
QueueId::Thread(thread) => self.thread_tree.process_of(thread).unwrap_or(thread),
QueueId::Process(process) => process,
};
let mut queues = self.process_queues(process);
if !queues.contains(&queue) {
queues.push(queue);
}
for &signal in flushed {
self.discarded_at_send.flush(queues.iter().copied(), signal);
}
}
pub(crate) fn process_queues(&self, process: DetPid) -> Vec<QueueId> {
let mut queues = vec![QueueId::Process(process)];
queues.extend(
self.process_signal_targets(process)
.into_iter()
.map(QueueId::Thread),
);
queues
}
pub(crate) fn discarded_signal_control(
&mut self,
dtid: DetTid,
control: DiscardedSignalControl,
) -> DiscardedSignalAnswer {
self.signal_control_caller = Some(dtid);
let answer = self.answer_discarded_signal_control(dtid, control);
self.signal_control_caller = None;
answer
}
fn answer_discarded_signal_control(
&mut self,
dtid: DetTid,
control: DiscardedSignalControl,
) -> DiscardedSignalAnswer {
let process = self.thread_tree.process_of(dtid).unwrap_or(dtid);
match control {
DiscardedSignalControl::ClaimItimerReal => {
DiscardedSignalAnswer::ItimerReal(self.claim_reported_itimer_real(dtid, process))
}
DiscardedSignalControl::UnreportedAlarm => {
self.discarded_at_send.alarm_unreported.insert(process);
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::PreSend {
named,
queue,
signal,
} => {
let queue = match queue {
QueueId::Process(task) => {
QueueId::Process(self.thread_tree.process_of(task).unwrap_or(task))
}
thread => thread,
};
DiscardedSignalAnswer::Token(self.discard_pre_send(
named,
queue,
signal,
Some(dtid),
))
}
DiscardedSignalControl::Sent(token, siginfo) => {
let siginfo = siginfo.unwrap_or_else(|| {
super::signal_lists::ordinary_siginfo(token.signal, 0, process.as_raw(), 0)
});
self.discard_note_send(token, None, Some(siginfo));
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::Consumed {
signal,
how,
thread_holds,
process_holds,
} => {
let pending = self.finish_timer_signal_dequeue(
dtid,
signal,
how,
thread_holds,
process_holds,
);
if how != (Consumption::KeptResume { blocked: true }) {
self.note_replayed_copy_taken(dtid, signal, thread_holds, process_holds);
}
self.discarded_at_send.consume(
dtid,
process,
signal,
how,
thread_holds,
process_holds,
);
if let Some(pending) = pending {
self.pop_and_promote(pending, dtid);
}
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::Take { signal, at, after } => {
DiscardedSignalAnswer::Taken(self.timer_signal_take(dtid, signal, at, after))
}
DiscardedSignalControl::TakeFaulted {
set,
thread_pending,
shared_pending,
at,
} => DiscardedSignalAnswer::Discarded(self.timer_signal_take_faulted(
dtid,
set,
thread_pending,
shared_pending,
at,
)),
DiscardedSignalControl::Flushed { signal } => {
let queues = self.process_queues(process);
if self.signal_observable(process, signal) {
let live: std::collections::BTreeSet<i32> = self
.posix_timer_values
.keys()
.filter(|(owner, _)| *owner == process)
.map(|(_, timer)| *timer)
.collect();
self.discarded_at_send
.flush_lists(&queues, signal, |_, timer| live.contains(&timer));
} else {
self.discarded_at_send.flush(queues, signal);
}
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::Unignored { signal }
if self.signal_observable(process, signal) =>
{
let live: std::collections::BTreeSet<i32> = self
.posix_timer_values
.keys()
.filter(|(owner, _)| *owner == process)
.map(|(_, timer)| *timer)
.collect();
let actions = self
.discarded_at_send
.unignore_lists(process, signal, |_, timer| live.contains(&timer));
for action in actions {
match action {
UnignoreAction::Send(queue, entry) => {
let info = self.timer_signal_info(signal, &entry, 0);
let producer = TimerProducer {
process,
timer: entry.timer,
arm_gen: entry.gen_at_send,
};
self.send_unignored_expiry(
dtid,
process,
queue,
signal,
producer,
Some(info),
);
}
UnignoreAction::Wake(queue) => {
if let Ok(sig) = nix::sys::signal::Signal::try_from(signal) {
self.wake_for_entry(queue, sig, dtid);
}
}
}
}
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::Unignored { signal } => {
let current: Vec<_> = self
.discarded_at_send
.parked_timers(process, signal)
.into_iter()
.filter(|producer| self.posix_timer_expiry_current(producer))
.collect();
let resend = self
.discarded_at_send
.unignore(process, signal, |producer| current.contains(producer));
for (queue, producer) in resend {
let entry = super::signal_lists::TimerEntry {
process,
timer: producer.timer,
gen_at_send: producer.arm_gen,
periodic_at_send: true,
};
let info = self
.models_signal_targets
.then(|| self.timer_signal_info(signal, &entry, 0));
self.send_unignored_expiry(dtid, process, queue, signal, producer, info);
}
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::Bits => {
let (thread, process) = self.discarded_bits(dtid);
DiscardedSignalAnswer::Bits { thread, process }
}
DiscardedSignalControl::Dequeue { signal, at } => {
DiscardedSignalAnswer::Delivery(self.timer_signal_dequeue(dtid, signal, Some(at)))
}
DiscardedSignalControl::DeliveryInfo { signal, at } => {
match self.timer_delivery_info(dtid, signal, at) {
Some(info) => DiscardedSignalAnswer::Delivery(
super::posix_timer_coalesce::DeliveryAnswer::Rewrite(info),
),
None => DiscardedSignalAnswer::Delivery(
super::posix_timer_coalesce::DeliveryAnswer::AsIs,
),
}
}
DiscardedSignalControl::Unreported { signal } => {
DiscardedSignalAnswer::Delivery(self.timer_signal_dequeue(dtid, signal, None))
}
DiscardedSignalControl::Handler {
signal,
caught,
mask,
nodefer,
} => {
if caught {
self.handler_masks
.insert((process, signal), (mask, nodefer));
} else {
self.handler_masks.remove(&(process, signal));
}
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::TimerCreated { signal } => {
if (1..32).contains(&signal) {
self.discarded_at_send.note_timer_history(process, signal);
}
DiscardedSignalAnswer::Recorded
}
DiscardedSignalControl::Queued => {
let listed = |queue: QueueId| {
(1..32)
.filter(|&signal| {
let entries = self.discarded_at_send.lists.entries(queue, signal);
entries.len() > 1
|| entries.iter().any(|entry| {
matches!(entry, super::signal_lists::Entry::Timer(timer)
if !self.timer_entry_valid(timer))
})
})
.fold(0, |bits, signal| bits | kernel_signal_bit(signal))
};
DiscardedSignalAnswer::Bits {
thread: listed(QueueId::Thread(dtid)),
process: listed(QueueId::Process(process)),
}
}
DiscardedSignalControl::TimerReadout { timer, now } => {
DiscardedSignalAnswer::TimerReadout {
remaining: self.posix_timer_remaining(process, timer, now),
overrun: self.posix_timer_overrun(process, timer),
}
}
}
}
fn send_unignored_expiry(
&mut self,
caller: DetTid,
process: DetPid,
queue: QueueId,
signal: i32,
producer: TimerProducer,
info: Option<[u8; 128]>,
) {
let Ok(sig) = nix::sys::signal::Signal::try_from(signal) else {
return;
};
let target = match queue {
QueueId::Thread(thread) => Some(thread),
QueueId::Process(_) => self
.select_signal_target(process, Some(caller))
.map(|preferred| self.timer_signal_target(process, preferred, sig)),
};
let Some(target) = target else {
return;
};
let token = self.discard_kept_token(queue, signal);
let every_thread_blocks = matches!(queue, QueueId::Process(_))
&& self.models_signal_targets
&& self.kernel_signal_target(process, target, signal).is_none();
let rc = match (queue, info.as_ref()) {
(QueueId::Thread(thread), None) => unsafe {
libc::syscall(libc::SYS_tgkill, process.as_raw(), thread.as_raw(), signal)
},
(QueueId::Thread(thread), Some(info)) => unsafe {
libc::syscall(
libc::SYS_rt_tgsigqueueinfo,
process.as_raw(),
thread.as_raw(),
signal,
info.as_ptr(),
)
},
(QueueId::Process(_), None) => unsafe {
libc::kill(target.as_raw(), signal) as libc::c_long
},
(QueueId::Process(_), Some(info)) => unsafe {
libc::syscall(
libc::SYS_rt_sigqueueinfo,
target.as_raw(),
signal,
info.as_ptr(),
)
},
};
if rc < 0 {
tracing::info!(
"[dtid {}] the parked expiry of signal {} was not queued again: the thread exited",
target,
sig
);
return;
}
tracing::info!(
"[dtid {}] signal {} stopped being ignored: a parked timer expiry is queued again",
target,
sig
);
self.discard_note_send(token, None, None);
let bit = kernel_signal_bit(signal);
match queue {
QueueId::Thread(thread) => {
let id = super::timed_waiters::SignalTimerId::Posix(process, producer.timer);
if self.thread_timer_copy_is_observable(thread, bit)
&& !super::is_job_control_signal(signal)
{
self.thread_timer_copies.insert((thread, signal), id);
} else {
self.thread_timer_copies.remove(&(thread, signal));
}
}
QueueId::Process(_) => {
if every_thread_blocks {
self.note_signal_left_in_shared_queue(process, signal);
}
if !self.note_group_send(target, sig, false) {
return;
}
}
}
super::TIMER_COPIES_RECORDED.store(true, std::sync::atomic::Ordering::SeqCst);
if target != caller {
self.wake_signaled_guest_as(target, sig, false);
}
}
pub(crate) fn posix_timer_producer(
&self,
id: super::timed_waiters::SignalTimerId,
) -> Option<TimerProducer> {
let super::timed_waiters::SignalTimerId::Posix(process, timer) = id else {
return None;
};
self.blocked.timed_waiters.signal_timer_period(id)?;
Some(TimerProducer {
process,
timer,
arm_gen: self.posix_timer_arm_generation(process, timer),
})
}
pub(crate) fn posix_timer_expiry_current(&self, producer: &TimerProducer) -> bool {
let id = super::timed_waiters::SignalTimerId::Posix(producer.process, producer.timer);
self.blocked.timed_waiters.signal_timer_period(id).is_some()
&& self.posix_timer_arm_generation(producer.process, producer.timer) == producer.arm_gen
}
pub(crate) fn discarded_bits(&self, thread: DetTid) -> (u64, u64) {
let process = self.thread_tree.process_of(thread).unwrap_or(thread);
let undeliverable = |queue: QueueId| {
(1..32)
.filter(|&signal| {
self.discarded_at_send.lists.is_listed(queue, signal)
&& !self.list_deliverable(queue, signal)
})
.fold(0, |bits, signal| bits | kernel_signal_bit(signal))
};
let (private, shared) = (QueueId::Thread(thread), QueueId::Process(process));
(
self.discarded_at_send.discarded(private) | undeliverable(private),
self.discarded_at_send.discarded(shared) | undeliverable(shared),
)
}
}
#[cfg(test)]
mod tests {
use super::*;
const T: DetTid = DetTid::from_raw(10);
const U: DetTid = DetTid::from_raw(11);
const P: DetPid = DetPid::from_raw(10);
const USR1: i32 = libc::SIGUSR1;
const USR2: i32 = libc::SIGUSR2;
fn thread() -> QueueId {
QueueId::Thread(T)
}
fn send(record: &mut DiscardedAtSend, queue: QueueId, discarded: bool, present: bool) {
let pre = record.pre_send(queue, USR1, present);
record.note_send(queue, USR1, discarded, pre, None);
}
#[test]
fn a_discarded_send_to_an_empty_queue_sets_and_a_kept_send_clears() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
assert!(record.is_discarded(thread(), USR1));
assert!(!record.is_discarded(QueueId::Process(P), USR1));
send(&mut record, thread(), false, true);
assert!(!record.is_discarded(thread(), USR1));
}
#[test]
fn a_discarded_send_coalescing_into_a_kept_copy_leaves_it_kept() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, true);
assert!(!record.is_discarded(thread(), USR1));
}
#[test]
fn a_same_signal_clear_between_read_and_update_sets_the_bit() {
let mut record = DiscardedAtSend::default();
let pre = record.pre_send(thread(), USR1, true);
record.consume(T, P, USR1, Consumption::Dropped, false, false);
record.note_send(thread(), USR1, true, pre, None);
assert!(record.is_discarded(thread(), USR1));
}
#[test]
fn an_unrelated_signal_clear_between_read_and_update_leaves_the_bit() {
let mut record = DiscardedAtSend::default();
let pre = record.pre_send(thread(), USR1, true);
record.consume(T, P, USR2, Consumption::Dropped, false, false);
record.note_send(thread(), USR1, true, pre, None);
assert!(!record.is_discarded(thread(), USR1));
}
#[test]
fn a_blocked_kept_resume_keeps_the_bit() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
record.consume(
T,
P,
USR1,
Consumption::KeptResume { blocked: true },
false,
false,
);
assert!(record.is_discarded(thread(), USR1));
}
#[test]
fn an_unblocked_kept_resume_clears_only_the_emptied_queue() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
send(&mut record, QueueId::Process(P), true, false);
record.consume(
T,
P,
USR1,
Consumption::KeptResume { blocked: false },
false,
true,
);
assert!(!record.is_discarded(thread(), USR1));
assert!(record.is_discarded(QueueId::Process(P), USR1));
}
#[test]
fn a_blocked_drop_clears_the_bit() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
send(&mut record, QueueId::Process(P), true, false);
record.consume(T, P, USR1, Consumption::Dropped, false, true);
assert!(!record.is_discarded(thread(), USR1));
assert!(record.is_discarded(QueueId::Process(P), USR1));
}
#[test]
fn a_take_answers_the_captured_bit_then_retires_it() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
send(&mut record, QueueId::Process(P), true, false);
assert!(record.take(thread(), USR1));
assert!(!record.is_discarded(thread(), USR1));
assert!(record.is_discarded(QueueId::Process(P), USR1));
assert!(!record.take(thread(), USR1));
}
#[test]
fn a_take_finds_its_queue_from_the_record_alone() {
let shared = QueueId::Process(P);
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
send(&mut record, shared, false, false);
assert!(record.take_from(T, P, USR1));
assert!(!record.take_from(T, P, USR1));
let mut record = DiscardedAtSend::default();
send(&mut record, shared, true, false);
send(&mut record, thread(), false, false);
assert!(!record.take_from(T, P, USR1));
assert!(record.is_discarded(shared, USR1));
assert!(record.take_from(T, P, USR1));
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
assert!(record.take_from(T, P, USR1));
assert!(!record.take_from(T, P, USR1));
}
#[test]
fn a_faulted_take_of_a_discarded_copy_is_found_by_its_emptied_queue() {
let usr1 = kernel_signal_bit(USR1);
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
assert!(!record.take_faulted(T, P, usr1, usr1, 0));
assert!(record.is_discarded(thread(), USR1));
assert!(record.take_faulted(T, P, usr1, 0, 0));
assert!(!record.is_discarded(thread(), USR1));
assert!(!record.take_faulted(T, P, usr1, 0, 0));
}
#[test]
fn a_flush_clears_every_named_queue() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
send(&mut record, QueueId::Thread(U), true, false);
send(&mut record, QueueId::Process(P), true, false);
record.flush([thread(), QueueId::Process(P)], USR1);
assert!(!record.is_discarded(thread(), USR1));
assert!(record.is_discarded(QueueId::Thread(U), USR1));
assert!(!record.is_discarded(QueueId::Process(P), USR1));
}
#[test]
fn exec_moves_the_private_queue_to_the_leader_id() {
let mut record = DiscardedAtSend::default();
send(&mut record, QueueId::Thread(U), true, false);
send(&mut record, thread(), false, false);
let leader_bits = record.discarded(thread());
assert_eq!(leader_bits, 0);
record.rekey_thread(U, T);
assert!(record.is_discarded(thread(), USR1));
assert_eq!(record.discarded(QueueId::Thread(U)), 0);
let pre = record.pre_send(thread(), USR1, true);
record.note_send(thread(), USR1, true, pre, None);
assert!(record.is_discarded(thread(), USR1));
}
#[test]
fn retirement_forgets_the_queue() {
let mut record = DiscardedAtSend::default();
send(&mut record, thread(), true, false);
record.retire(thread());
assert_eq!(record.discarded(thread()), 0);
}
#[test]
fn real_time_signals_are_not_tracked() {
let mut record = DiscardedAtSend::default();
let pre = record.pre_send(thread(), 34, false);
record.note_send(thread(), 34, true, pre, None);
assert_eq!(record.discarded(thread()), 0);
}
fn timer(arm_gen: u64) -> TimerProducer {
TimerProducer {
process: P,
timer: 0,
arm_gen,
}
}
fn timer_send(record: &mut DiscardedAtSend, arm_gen: u64, present: bool) {
let queue = QueueId::Process(P);
let pre = record.pre_send(queue, USR1, present);
record.note_send(queue, USR1, true, pre, Some(timer(arm_gen)));
}
#[test]
fn unignore_clears_a_pending_expiry_of_an_unchanged_live_timer() {
let mut record = DiscardedAtSend::default();
timer_send(&mut record, 1, false);
let resend = record.unignore(P, USR1, |p| p.arm_gen == 1);
assert!(resend.is_empty());
assert!(!record.is_discarded(QueueId::Process(P), USR1));
}
#[test]
fn unignore_resends_a_current_expiry_whose_copy_was_taken() {
let mut record = DiscardedAtSend::default();
timer_send(&mut record, 1, false);
record.consume(T, P, USR1, Consumption::Dropped, false, false);
assert_eq!(
record.unignore(P, USR1, |p| p.arm_gen == 1),
vec![(QueueId::Process(P), timer(1))]
);
assert!(record.unignore(P, USR1, |_| true).is_empty());
}
#[test]
fn unignore_keeps_an_expiry_of_a_rearmed_disarmed_or_deleted_timer() {
let mut record = DiscardedAtSend::default();
timer_send(&mut record, 1, false);
assert!(record.unignore(P, USR1, |p| p.arm_gen == 2).is_empty());
assert!(record.is_discarded(QueueId::Process(P), USR1));
}
#[test]
fn a_new_ignored_expiry_after_a_rearm_refreshes_the_generation() {
let mut record = DiscardedAtSend::default();
timer_send(&mut record, 1, false);
timer_send(&mut record, 2, true);
assert!(record.is_discarded(QueueId::Process(P), USR1));
assert!(record.unignore(P, USR1, |p| p.arm_gen == 2).is_empty());
assert!(!record.is_discarded(QueueId::Process(P), USR1));
}
#[test]
fn unignore_leaves_a_bit_no_timer_set() {
let mut record = DiscardedAtSend::default();
send(&mut record, QueueId::Process(P), true, false);
assert!(record.unignore(P, USR1, |_| true).is_empty());
assert!(record.is_discarded(QueueId::Process(P), USR1));
}
fn siginfo(code: i32) -> KernelSiginfo {
let mut info = [0u8; super::super::signal_lists::KERNEL_SIGINFO_SIZE];
info[0..4].copy_from_slice(&USR1.to_ne_bytes());
info[8..12].copy_from_slice(&code.to_ne_bytes());
KernelSiginfo(info)
}
fn listed_send(
record: &mut DiscardedAtSend,
queue: QueueId,
discarded: bool,
code: i32,
listed: bool,
) {
let present = record.is_discarded(queue, USR1) || record.lists.is_listed(queue, USR1);
let pre = record.pre_send(queue, USR1, present);
let record_ = SendRecord {
siginfo: siginfo(code),
listed,
};
record.note_send_listed(P, queue, USR1, discarded, pre, None, record_);
}
const SI_QUEUE: i32 = -1;
const SI_TIMER: i32 = super::super::signal_lists::SI_TIMER;
#[test]
fn a_kept_send_of_a_listed_pair_becomes_the_front_of_an_empty_list() {
let mut record = DiscardedAtSend::default();
listed_send(&mut record, thread(), false, 0, true);
assert_eq!(record.lists.entries(thread(), USR1).len(), 1);
listed_send(&mut record, thread(), false, SI_QUEUE, true);
assert_eq!(record.lists.entries(thread(), USR1).len(), 1);
assert!(record.lists.invariants_hold());
}
#[test]
fn an_unlisted_pair_keeps_no_list() {
let mut record = DiscardedAtSend::default();
listed_send(&mut record, thread(), false, 0, false);
assert!(!record.lists.is_listed(thread(), USR1));
}
#[test]
fn a_kept_send_on_a_discarded_si_timer_copy_is_a_proxy_only_in_a_timer_pair() {
use super::super::signal_lists::FrontClass;
for (history, class) in [(false, FrontClass::Own), (true, FrontClass::Proxy)] {
let mut record = DiscardedAtSend::default();
if history {
record.note_timer_history(P, USR1);
}
listed_send(&mut record, thread(), true, SI_TIMER, true);
assert!(record.discarded_is_si_timer(thread(), USR1));
listed_send(&mut record, thread(), false, SI_QUEUE, true);
let (_, front_class, physical_si_timer) = record.lists.front(thread(), USR1).unwrap();
assert_eq!(front_class, class);
assert!(physical_si_timer);
assert!(!record.is_discarded(thread(), USR1));
assert!(!record.discarded_is_si_timer(thread(), USR1));
}
}
#[test]
fn a_discarded_send_coalescing_into_a_pending_copy_records_no_si_code() {
let mut record = DiscardedAtSend::default();
listed_send(&mut record, thread(), true, 0, true);
listed_send(&mut record, thread(), true, SI_TIMER, true);
assert!(record.is_discarded(thread(), USR1));
assert!(!record.discarded_is_si_timer(thread(), USR1));
}
#[test]
fn the_timer_history_survives_rekey_and_goes_with_the_process() {
let mut record = DiscardedAtSend::default();
record.note_timer_history(P, USR1);
listed_send(&mut record, QueueId::Thread(U), false, 0, true);
record.rekey_thread(U, T);
assert!(record.lists.is_listed(thread(), USR1));
assert!(!record.lists.is_listed(QueueId::Thread(U), USR1));
assert!(record.has_timer_history(P, USR1));
record.retire(thread());
assert!(!record.lists.is_listed(thread(), USR1));
assert!(record.has_timer_history(P, USR1));
record.retire(QueueId::Process(P));
assert!(!record.has_timer_history(P, USR1));
}
}
#[cfg(test)]
mod alarm_origin_tests {
use super::*;
const T: DetTid = DetTid::from_raw(10);
const U: DetTid = DetTid::from_raw(11);
const P: DetPid = DetPid::from_raw(10);
const ALRM: i32 = libc::SIGALRM;
const TIMER: AlarmOrigin = AlarmOrigin::ItimerReal;
const OTHER: AlarmOrigin = AlarmOrigin::Other;
const UNKNOWN: AlarmOrigin = AlarmOrigin::Unknown;
fn send(
r: &mut DiscardedAtSend,
q: QueueId,
origin: AlarmOrigin,
discarded: bool,
present: bool,
) {
let pre = r.pre_send(q, ALRM, present);
match origin {
AlarmOrigin::ItimerReal => r.note_itimer_real_send(q, discarded, pre),
AlarmOrigin::Other => r.note_send(q, ALRM, discarded, pre, None),
AlarmOrigin::Unknown => panic!("Unknown is not an authenticated send tag"),
}
}
#[test]
fn every_two_send_order_preserves_the_first_kept_origin() {
for q in [QueueId::Thread(T), QueueId::Process(P)] {
for first in [TIMER, OTHER] {
for second in [TIMER, OTHER] {
let mut r = DiscardedAtSend::default();
send(&mut r, q, first, false, false);
send(&mut r, q, second, false, true);
assert_eq!(r.alarm_origin(q), first);
assert!(!r.is_discarded(q, ALRM));
}
}
}
}
#[test]
fn a_discarded_later_send_does_not_replace_either_kept_origin() {
for first in [TIMER, OTHER] {
for later in [TIMER, OTHER] {
let q = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, q, first, false, false);
send(&mut r, q, later, true, true);
assert_eq!(r.alarm_origin(q), first);
assert!(!r.is_discarded(q, ALRM));
}
}
}
#[test]
fn either_kept_origin_replaces_a_known_discarded_artifact() {
for first in [TIMER, OTHER] {
for kept in [TIMER, OTHER] {
let q = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, q, first, true, false);
assert_eq!(r.alarm_origin(q), UNKNOWN);
assert!(r.is_discarded(q, ALRM));
send(&mut r, q, kept, false, true);
assert_eq!(r.alarm_origin(q), kept);
assert!(!r.is_discarded(q, ALRM));
}
}
}
#[test]
fn an_unknown_physical_first_copy_stays_unknown_for_every_later_send() {
for later in [TIMER, OTHER] {
for discarded in [false, true] {
let q = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, q, later, discarded, true);
assert_eq!(r.alarm_origin(q), UNKNOWN);
assert!(!r.is_discarded(q, ALRM));
send(&mut r, q, TIMER, false, true);
assert_eq!(r.alarm_origin(q), UNKNOWN);
}
}
}
#[test]
fn explicit_claim_retires_before_a_prehook_can_publish_the_next_copy() {
let q = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, q, TIMER, false, false);
let before = r.pre_send(q, ALRM, true).generation;
assert!(r.claim_itimer_real(q));
assert_eq!(r.alarm_origin(q), UNKNOWN);
assert_eq!(r.pre_send(q, ALRM, false).generation, before + 1);
send(&mut r, q, OTHER, false, false);
let generation = r.pre_send(q, ALRM, true).generation;
assert!(!r.claim_itimer_real(q));
assert_eq!(r.alarm_origin(q), OTHER);
assert!(r.has_recorded_copy(q, ALRM));
assert_eq!(r.pre_send(q, ALRM, true).generation, generation);
r.take(q, ALRM);
assert!(!r.claim_itimer_real(q));
}
#[test]
fn explicit_private_first_claim_preserves_the_shared_timer() {
let private = QueueId::Thread(T);
let shared = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, private, OTHER, false, false);
send(&mut r, shared, TIMER, false, false);
let generation = r.pre_send(private, ALRM, true).generation;
assert!(!r.claim_itimer_real(private));
assert_eq!(r.alarm_origin(private), OTHER);
assert_eq!(r.pre_send(private, ALRM, true).generation, generation);
r.take(private, ALRM);
assert_eq!(r.alarm_origin(shared), TIMER);
assert!(r.claim_itimer_real(shared));
}
#[test]
fn a_generic_ambiguous_take_cannot_leave_positive_shared_provenance() {
let shared = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, shared, TIMER, false, false);
assert!(!r.take_from(T, P, ALRM));
assert_eq!(r.alarm_origin(shared), UNKNOWN);
}
#[test]
fn an_explicit_take_clears_only_its_selected_origin() {
let private = QueueId::Thread(T);
let shared = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, private, OTHER, false, false);
send(&mut r, shared, TIMER, false, false);
assert!(!r.take(private, ALRM));
assert_eq!(r.alarm_origin(private), UNKNOWN);
assert_eq!(r.alarm_origin(shared), TIMER);
assert!(!r.take(shared, ALRM));
assert_eq!(r.alarm_origin(shared), UNKNOWN);
}
#[test]
fn faulted_takes_clear_emptied_alarm_origins_but_keep_pending_ones() {
let private = QueueId::Thread(T);
let shared = QueueId::Process(P);
let alarm = kernel_signal_bit(ALRM);
let mut r = DiscardedAtSend::default();
send(&mut r, private, OTHER, false, false);
send(&mut r, shared, TIMER, false, false);
assert!(!r.take_faulted(T, P, alarm, 0, alarm));
assert_eq!(r.alarm_origin(private), UNKNOWN);
assert_eq!(r.alarm_origin(shared), TIMER);
assert!(!r.take_faulted(T, P, alarm, 0, 0));
assert_eq!(r.alarm_origin(shared), UNKNOWN);
}
#[test]
fn blocked_resume_keeps_origins_and_an_emptied_consumption_clears_them() {
let private = QueueId::Thread(T);
let shared = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, private, OTHER, false, false);
send(&mut r, shared, TIMER, false, false);
r.consume(
T,
P,
ALRM,
Consumption::KeptResume { blocked: true },
false,
false,
);
assert_eq!(r.alarm_origin(private), OTHER);
assert_eq!(r.alarm_origin(shared), TIMER);
r.consume(T, P, ALRM, Consumption::Dropped, false, true);
assert_eq!(r.alarm_origin(private), UNKNOWN);
assert_eq!(r.alarm_origin(shared), TIMER);
r.consume(
T,
P,
ALRM,
Consumption::KeptResume { blocked: false },
false,
false,
);
assert_eq!(r.alarm_origin(shared), UNKNOWN);
}
#[test]
fn flush_retire_and_rekey_follow_existing_queue_lifetimes() {
let private = QueueId::Thread(T);
let moved = QueueId::Thread(U);
let shared = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, private, OTHER, false, false);
send(&mut r, moved, TIMER, false, false);
send(&mut r, shared, TIMER, false, false);
r.rekey_thread(U, T);
assert_eq!(r.alarm_origin(private), TIMER);
assert_eq!(r.alarm_origin(moved), UNKNOWN);
assert_eq!(r.alarm_origin(shared), TIMER);
r.rekey_thread(T, T);
assert_eq!(r.alarm_origin(private), TIMER);
r.flush([private], ALRM);
assert_eq!(r.alarm_origin(private), UNKNOWN);
assert_eq!(r.alarm_origin(shared), TIMER);
r.retire(shared);
assert_eq!(r.alarm_origin(shared), UNKNOWN);
}
#[test]
fn unrelated_signals_do_not_clear_or_forge_alarm_origin() {
let q = QueueId::Thread(T);
let mut r = DiscardedAtSend::default();
send(&mut r, q, TIMER, false, false);
let pre = r.pre_send(q, libc::SIGUSR1, false);
r.note_send(q, libc::SIGUSR1, false, pre, None);
r.take(q, libc::SIGUSR1);
r.flush([q], 34);
assert_eq!(r.alarm_origin(q), TIMER);
}
#[test]
fn a_known_empty_queue_or_generation_change_allows_a_new_first_origin() {
let q = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, q, TIMER, false, false);
send(&mut r, q, OTHER, false, false);
assert_eq!(r.alarm_origin(q), OTHER);
let pre = r.pre_send(q, ALRM, true);
r.take(q, ALRM);
r.note_itimer_real_send(q, false, pre);
assert_eq!(r.alarm_origin(q), TIMER);
}
#[test]
fn false_claims_preserve_discarded_unknown_and_other_signal_records() {
let q = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
send(&mut r, q, OTHER, true, false);
let generation = r.pre_send(q, ALRM, true).generation;
assert!(!r.claim_itimer_real(q));
assert!(r.is_discarded(q, ALRM));
assert!(r.has_recorded_copy(q, ALRM));
assert_eq!(r.pre_send(q, ALRM, true).generation, generation);
r.take(q, ALRM);
send(&mut r, q, TIMER, false, true); assert_eq!(r.alarm_origin(q), UNKNOWN);
assert!(!r.claim_itimer_real(q));
assert!(r.has_recorded_copy(q, ALRM));
assert!(!r.has_recorded_copy(q, 34));
assert!(!r.has_recorded_copy(QueueId::Thread(T), ALRM));
}
#[test]
fn a_posix_timer_unignored_as_sigalrm_is_other_not_itimer_real() {
let q = QueueId::Process(P);
let mut r = DiscardedAtSend::default();
let producer = TimerProducer {
process: P,
timer: 7,
arm_gen: 2,
};
let pre = r.pre_send(q, ALRM, false);
r.note_send(q, ALRM, true, pre, Some(producer));
assert_eq!(r.alarm_origin(q), UNKNOWN);
assert!(r.unignore(P, ALRM, |p| *p == producer).is_empty());
assert_eq!(r.alarm_origin(q), OTHER);
send(&mut r, q, TIMER, false, true);
assert_eq!(r.alarm_origin(q), OTHER);
}
}
#[cfg(test)]
mod reported_alarm_tests {
use super::*;
#[test]
fn canonical_itimer_info_zeros_every_non_header_byte() {
let info = itimer_real_siginfo();
assert_eq!(
i32::from_ne_bytes(info[..4].try_into().unwrap()),
libc::SIGALRM
);
assert_eq!(
i32::from_ne_bytes(info[8..12].try_into().unwrap()),
libc::SI_KERNEL
);
assert!(info[4..8].iter().chain(&info[12..]).all(|byte| *byte == 0));
}
#[test]
fn unreported_origin_loss_survives_thread_exec_rekey_until_process_retirement() {
let process = DetPid::from_raw(100);
let thread = DetTid::from_raw(101);
let leader = DetTid::from_raw(100);
let mut record = DiscardedAtSend::default();
record.alarm_unreported.insert(process);
record.rekey_thread(thread, leader);
assert!(record.alarm_unreported.contains(&process));
record.retire(QueueId::Thread(leader));
assert!(record.alarm_unreported.contains(&process));
record.retire(QueueId::Process(process));
assert!(!record.alarm_unreported.contains(&process));
}
}