use super::Scheduler;
use super::kernel_signal_bit;
use crate::resources::NANOSLEEP_FYI;
use crate::resources::PAUSE_FYI;
use crate::resources::Permission;
use crate::resources::ResourceID;
use crate::resources::Resources;
use crate::syscalls::KernelSignalState;
use crate::syscalls::read_thread_signal_state;
use crate::syscalls::thread_is_gone;
use crate::types::DetTid;
use crate::types::LogicalTime;
use crate::types::SigWrapper;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum SignalSleep {
Pause,
Nanosleep { deadline: LogicalTime },
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum SleeperStateUnreadable {
Gone,
Unreadable(reverie::Errno),
}
impl Scheduler {
pub(super) fn signal_sleep(&self, dettid: DetTid) -> Option<SignalSleep> {
if !self.models_signal_targets {
return None;
}
let resources = self.next_turns.get(&dettid)?.req.try_read()?.ok()?;
if resources.resources.len() != 1 {
return None;
}
let Some((ResourceID::SleepUntil(deadline), _)) = resources.resources.iter().next() else {
return None;
};
match resources.fyi.as_str() {
PAUSE_FYI if deadline.is_indefinite() => Some(SignalSleep::Pause),
NANOSLEEP_FYI => Some(SignalSleep::Nanosleep {
deadline: *deadline,
}),
_ => None,
}
}
pub(super) fn private_sigchld(&self, dettid: DetTid) -> u64 {
if self.child_exit_sigchld.private_sent.contains(&dettid)
&& !self.discarded_at_send.is_discarded(
super::discarded_at_send::QueueId::Thread(dettid),
libc::SIGCHLD,
)
{
kernel_signal_bit(libc::SIGCHLD) & !self.host_timed_signals(dettid)
} else {
0
}
}
pub(super) fn admits_sleep_signal(&self, dettid: DetTid, signal: SigWrapper) -> bool {
let bit = kernel_signal_bit(signal.raw());
if signal.raw() == libc::SIGKILL
|| self.signal_sleep(dettid).is_none()
|| self.futex_wait_held_signals(dettid) & !self.private_sigchld(dettid) & bit != 0
{
return false;
}
match self.read_sleeper_signal_state(dettid) {
Ok(state) => state.discarded_at_generation() & bit == 0,
Err(_) => true,
}
}
pub(super) fn sleep_interrupting_signals(
&self,
dettid: DetTid,
sleep: SignalSleep,
) -> Result<u64, SleeperStateUnreadable> {
let state = self.read_sleeper_signal_state(dettid)?;
let interrupting = (state.pending & !self.futex_wait_held_signals(dettid)
| self.private_sigchld(dettid))
& state.interrupting(state.blocked);
Ok(match sleep {
SignalSleep::Pause => interrupting,
SignalSleep::Nanosleep { .. } => {
interrupting
& !(state.default_job_control_stops() | kernel_signal_bit(libc::SIGSTOP))
}
})
}
pub(super) fn read_sleeper_signal_state(
&self,
dettid: DetTid,
) -> Result<KernelSignalState, SleeperStateUnreadable> {
#[cfg(test)]
if let Some(state) = self.test_kernel_signal_states.get(&dettid) {
return Ok(*state);
}
#[cfg(test)]
if let Some(failure) = self.test_sleeper_read_failures.get(&dettid) {
return Err(*failure);
}
let process = reverie::Pid::from_raw(self.sigchld_process(dettid).as_raw());
let thread = reverie::Pid::from_raw(dettid.as_raw());
read_thread_signal_state(process, thread).map_err(|errno| {
if thread_is_gone(process, thread) {
SleeperStateUnreadable::Gone
} else {
SleeperStateUnreadable::Unreadable(errno)
}
})
}
pub(super) fn drain_sleep_signals(
&mut self,
dettid: DetTid,
sleep: SignalSleep,
mut signals: Vec<SigWrapper>,
) {
if let SignalSleep::Nanosleep { deadline } = sleep
&& deadline <= self.committed_time
{
return;
}
let interrupting = match self.sleep_interrupting_signals(dettid, sleep) {
Ok(interrupting) => interrupting,
Err(SleeperStateUnreadable::Gone) => {
tracing::debug!(
"[dtid {}] is gone; its {:?} is left to its retirement.",
dettid,
sleep
);
return;
}
Err(SleeperStateUnreadable::Unreadable(errno)) => {
self.terminal_deadlock.get_or_insert_with(|| {
format!(
"HERMIT_DEADLOCK: cannot read the signal state of dettid {} ({}) to decide whether cross-task signals {:?} end its {:?}",
dettid, errno, signals, sleep
)
});
return;
}
};
signals.retain(|signal| interrupting & kernel_signal_bit(signal.raw()) != 0);
signals.sort_by_key(SigWrapper::raw);
signals.dedup();
if signals.is_empty() {
tracing::debug!(
"[dtid {}] no drained signal interrupts its {:?}; leaving it parked.",
dettid,
sleep
);
return;
}
tracing::info!(
"[dtid {}] cross-task signals {:?} end its {:?}.",
dettid,
signals,
sleep
);
if self.run_queue.contains_tid(dettid) {
let removed = self.run_queue.remove_tid(dettid);
debug_assert!(
removed,
"run_queue.contains_tid disagreed with remove_tid for {dettid}"
);
}
let mut resources = Resources::new(dettid);
resources.insert(ResourceID::WaitidSignals(signals), Permission::W);
self.force_unblock_thread_at(dettid, resources, true);
}
}