use detcore_model::bundled_signal_facts;
use reverie::Errno;
use reverie::Guest;
use reverie::Pid;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::MemoryAccess;
use serde::Deserialize;
use serde::Serialize;
use tracing::debug;
use tracing::trace;
use tracing::warn;
use super::threads::KernelSigaction;
use super::threads::KernelSigset;
use super::threads::host_signal_state_reads_refused;
use super::threads::read_thread_signal_state;
use crate::Detcore;
use crate::record_or_replay::RecordOrReplay;
use crate::signal_state::Action;
use crate::signal_state::Dispositions;
use crate::signal_state::SignalShadow;
use crate::signal_state::ThreadSignals;
use crate::signal_state::sigbit;
pub(crate) const DIVERGED: &str = "SIGNAL_STATE_COPY_DIVERGED";
fn reserved() -> KernelSigset {
sigbit(reverie::PERF_EVENT_SIGNAL as i32)
}
fn forced() -> KernelSigset {
[
libc::SIGTRAP,
libc::SIGSEGV,
libc::SIGBUS,
libc::SIGILL,
libc::SIGFPE,
libc::SIGSYS,
]
.into_iter()
.fold(0, |set, signal| set | sigbit(signal))
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum Compared {
Same,
ForcedOnly,
Different,
}
fn compare(kernel: KernelSigset, copy: KernelSigset) -> Compared {
match (kernel ^ copy) & !reserved() {
0 => Compared::Same,
difference if difference & !forced() == 0 && kernel & !copy & !reserved() == 0 => {
Compared::ForcedOnly
}
_ => Compared::Different,
}
}
fn forced_changed<G, T>(guest: &mut G, at: &str)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
debug!(
"[dtid {}] signal-state copy dropped at {at}: a force-delivered signal's kernel state \
differs (SIGTRAP from a ptrace single-step, SIGSEGV from a trapped rdtsc or cpuid, \
or a fault)",
guest.thread_state().dettid
);
drop_copy(guest);
}
impl From<KernelSigaction> for Action {
fn from(action: KernelSigaction) -> Self {
Action {
handler: action.handler,
flags: action.flags,
restorer: action.restorer,
mask: action.mask,
}
}
}
fn kernel_state_is_the_guests<G, T>(guest: &G) -> bool
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let config = guest.config();
config.signal_state_copy
&& config.sequentialize_threads
&& bundled_signal_facts::kernel_signal_state_is_guests(&config.backend)
&& !host_signal_state_reads_refused()
}
fn with_copy<G, T, R>(
guest: &mut G,
change: impl FnOnce(&mut Dispositions, &mut ThreadSignals) -> R,
) -> Option<R>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let shadow = guest.thread_state_mut().signal_shadow.as_mut()?;
let actions = std::sync::Arc::clone(&shadow.dispositions);
let mut actions = actions.lock().unwrap();
match actions.as_mut() {
Some(dispositions) => Some(change(dispositions, &mut shadow.thread)),
None => {
drop(actions);
debug!(
"[dtid {}] signal-state copy dropped: a thread sharing its actions lost its copy",
guest.thread_state().dettid
);
drop_copy(guest);
None
}
}
}
pub(crate) fn give_up<G, T>(guest: &mut G, reason: &str)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if guest.thread_state().signal_shadow.is_some() {
debug!(
"[dtid {}] signal-state copy dropped: {reason}",
guest.thread_state().dettid
);
drop_copy(guest);
}
}
fn drop_copy<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
drop_thread_copy(guest.thread_state_mut());
}
fn drop_thread_copy<T>(thread: &mut crate::tool_local::ThreadState<T>) {
if let Some(shadow) = thread.signal_shadow.as_ref() {
shadow.forget_dispositions();
}
thread.signal_shadow = None;
}
pub(crate) fn at_syscall_entry<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
take_unreported(guest);
let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() else {
return;
};
shadow.thread.settle();
shadow.thread.wait_mask = None;
reconcile_returns(guest, "syscall entry");
}
#[cfg(not(test))]
static UNREPORTED: std::sync::Mutex<Vec<(i32, i32, i32)>> = std::sync::Mutex::new(Vec::new());
#[cfg(not(test))]
static ANY_UNREPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
#[cfg(test)]
thread_local! {
static UNREPORTED_NOTES: std::cell::RefCell<Vec<(i32, i32, i32)>> =
const { std::cell::RefCell::new(Vec::new()) };
}
fn with_notes<R>(f: impl FnOnce(&mut Vec<(i32, i32, i32)>) -> R) -> R {
#[cfg(not(test))]
{
let mut notes = UNREPORTED.lock().unwrap();
let result = f(&mut notes);
ANY_UNREPORTED.store(!notes.is_empty(), std::sync::atomic::Ordering::SeqCst);
result
}
#[cfg(test)]
{
UNREPORTED_NOTES.with(|notes| f(&mut notes.borrow_mut()))
}
}
fn any_notes() -> bool {
#[cfg(not(test))]
{
ANY_UNREPORTED.load(std::sync::atomic::Ordering::SeqCst)
}
#[cfg(test)]
{
UNREPORTED_NOTES.with(|notes| !notes.borrow().is_empty())
}
}
pub(crate) fn note_unreported(pid: i32, tid: i32, signal: i32) {
trace!("[tid {tid}] signal-state copy: signal {signal} was passed on unreported");
with_notes(|notes| notes.push((pid, tid, signal)));
}
fn unreported_elsewhere(tid: i32) -> bool {
if !any_notes() {
return false;
}
with_notes(|notes| {
notes.retain(|(_, t, _)| {
!super::threads::thread_is_gone(Pid::from_raw(*t), Pid::from_raw(*t))
});
notes.iter().any(|(_, t, _)| *t != tid)
})
}
pub(crate) fn unreported_pending() -> bool {
any_notes()
&& with_notes(|notes| {
notes.retain(|(_, t, _)| {
!super::threads::thread_is_gone(Pid::from_raw(*t), Pid::from_raw(*t))
});
!notes.is_empty()
})
}
fn take_unreported<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if !any_notes() {
return;
}
let (pid, tid) = (guest.pid().as_raw(), guest.tid().as_raw());
let signals: Vec<i32> = with_notes(|notes| {
let (mine, others): (Vec<_>, Vec<_>) = notes
.drain(..)
.partition(|(p, t, _)| *p == pid && *t == tid);
*notes = others;
mine.into_iter().map(|(_, _, signal)| signal).collect()
});
if let Some(signal) = signals.first() {
give_up(guest, &format!("signal {signal} was passed on unreported"));
}
}
fn reconcile_returns<G, T>(guest: &mut G, before: &str)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let open_frames = guest
.thread_state()
.signal_shadow
.as_ref()
.is_some_and(|shadow| !shadow.thread.activations.is_empty());
let verify = guest
.thread_state()
.signal_shadow
.as_ref()
.is_some_and(|shadow| shadow.thread.verify_at_entry);
if !(open_frames || verify) || !kernel_state_is_the_guests(guest) {
return;
}
let Some(kernel) = read_or_give_up(guest, before) else {
return;
};
if observes_sigreturns(guest.config()) {
let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() else {
return;
};
shadow.thread.verify_at_entry = false;
match compare(kernel.blocked, shadow.thread.blocked) {
Compared::Same => shadow.thread.observe_handler_mask(),
Compared::ForcedOnly => forced_changed(guest, before),
Compared::Different => give_up(
guest,
"the kernel's mask is not the one the copy predicts after a reported return or \
for an open handler frame",
),
}
return;
}
let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() else {
return;
};
let copy = shadow.thread.blocked;
let open = shadow.thread.activations.len();
let innermost_observed = shadow.thread.innermost_observed();
if shadow
.thread
.reconcile_returns(kernel.blocked, reserved() | forced())
{
let closed = open - shadow.thread.activations.len();
if closed > 1 {
debug!(
"[dtid {}] signal-state copy dropped at {before}: the kernel's mask matches an \
outer handler frame ({closed} frames), which is ambiguous",
guest.thread_state().dettid
);
drop_copy(guest);
} else {
if closed == 1 {
debug!(
"[dtid {}] signal-state copy: a handler frame taken as returned at {before}",
guest.thread_state().dettid
);
if !innermost_observed {
#[cfg(test)]
UNVERIFIED_ENTRIES.with(|count| count.set(count.get() + 1));
return give_up(
guest,
"a handler frame was taken as returned before any check saw its \
handler's mask",
);
}
} else if let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() {
shadow.thread.observe_handler_mask();
}
let blocked = guest
.thread_state()
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.blocked);
match blocked.map(|blocked| compare(kernel.blocked, blocked)) {
Some(Compared::ForcedOnly) => forced_changed(guest, before),
Some(Compared::Different) => give_up(
guest,
"the kernel's mask holds a force-delivered signal the copy's mask does not",
),
Some(Compared::Same) | None => {}
}
}
} else if open > 0 {
give_up(
guest,
&format!(
"at {before} the kernel's mask matches no open handler frame, which a \
handler's rewritten uc_sigmask could explain"
),
);
} else {
diverged(
guest,
before,
&format!(
"SigBlk kernel {:#018x} is neither the copy's {:#018x} nor an open handler frame's",
kernel.blocked & !reserved(),
copy & !reserved()
),
);
}
}
pub(crate) fn at_exec<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
guest.thread_state_mut().published_mask = None;
if let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() {
if !shadow.exec() {
drop_copy(guest);
return;
}
trace!(
"[dtid {}] signal-state copy: reset for execve",
guest.thread_state().dettid
);
check_against_kernel(guest, "execve");
return;
}
if guest.thread_state().signal_shadow_lost || !kernel_state_is_the_guests(guest) {
return;
}
match read_thread_signal_state(guest.pid(), guest.tid()) {
Ok(state) => {
guest.thread_state_mut().signal_shadow =
Some(SignalShadow::seeded(state.ignored, state.blocked));
trace!(
"[dtid {}] signal-state copy: seeded from the first image",
guest.thread_state().dettid
);
}
Err(errno) => debug!(
"[dtid {}] signal-state copy not seeded: the kernel state is unreadable ({errno})",
guest.thread_state().dettid
),
}
}
pub(super) fn record_rt_sigaction<G, T>(
guest: &mut G,
signum: i32,
new: Option<KernelSigaction>,
old_action: Option<AddrMut<'_, libc::sigaction>>,
result: &Result<i64, Errno>,
) where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let committed = result.is_ok() || (new.is_some() && *result == Err(Errno::EFAULT));
if !committed {
return;
}
let Some(predicted) = with_copy(guest, |dispositions, _| {
dispositions.sigaction(signum, new.map(Action::from))
}) else {
return;
};
let old = match predicted {
Ok(old) => old,
Err(errno) => {
return diverged(
guest,
"rt_sigaction",
&format!(
"the kernel accepted signal {signum}, which the copy refuses with {errno}"
),
);
}
};
let written = match (result.is_ok(), old_action) {
(true, Some(address)) => match guest
.memory()
.read_value::<_, KernelSigaction>(address.cast::<KernelSigaction>())
{
Ok(written) => Some(written),
Err(_) => {
return give_up(guest, "the old action the kernel wrote cannot be read back");
}
},
_ => None,
};
if let Some(written) = written
&& Action::from(written) != old
&& !unreported_elsewhere(guest.tid().as_raw())
{
if forced() & sigbit(signum) != 0
&& Action::from(written)
== (Action {
handler: libc::SIG_DFL as u64,
..old
})
&& old.handler != libc::SIG_DFL as u64
{
return forced_changed(guest, "rt_sigaction");
}
return diverged(
guest,
"rt_sigaction",
&format!(
"old action of signal {signum}: the kernel wrote {:?}, the copy holds {old:?}",
Action::from(written)
),
);
}
check_against_kernel(guest, "rt_sigaction");
}
#[derive(Clone, Copy, Debug)]
pub(super) enum SetInput {
None,
NotRun,
Validated(KernelSigset),
Unvalidated(Option<KernelSigset>),
}
pub(super) fn record_rt_sigprocmask<G, T>(
guest: &mut G,
how: i32,
set: SetInput,
oldset: Option<AddrMut<'_, libc::sigset_t>>,
result: &Result<i64, Errno>,
) where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let valid_how = matches!(how, libc::SIG_BLOCK | libc::SIG_UNBLOCK | libc::SIG_SETMASK);
let set = match (set, result) {
(SetInput::NotRun, _) => return,
(SetInput::None, Ok(_)) => None,
(SetInput::Validated(set), Ok(_) | Err(Errno::EFAULT)) => Some(set),
(SetInput::Unvalidated(Some(set)), Ok(_)) => Some(set),
(SetInput::Unvalidated(None), Ok(_)) => {
debug!(
"[dtid {}] signal-state copy dropped: rt_sigprocmask's set is not known after \
the call (it aliases the old mask, or could not be read)",
guest.thread_state().dettid
);
drop_copy(guest);
return;
}
(SetInput::Unvalidated(_), Err(Errno::EFAULT)) if oldset.is_none() || !valid_how => {
return;
}
(SetInput::Unvalidated(_), Err(Errno::EFAULT)) => {
debug!(
"[dtid {}] signal-state copy dropped: rt_sigprocmask's EFAULT may come from \
its set or its old mask",
guest.thread_state().dettid
);
drop_copy(guest);
return;
}
_ => return,
};
let Some(predicted) = with_copy(guest, |_, thread| thread.sigprocmask(how, set)) else {
return;
};
let old = match predicted {
Ok(old) => old,
Err(errno) => {
return diverged(
guest,
"rt_sigprocmask",
&format!("the kernel accepted how={how}, which the copy refuses with {errno}"),
);
}
};
let written = match (result.is_ok(), oldset) {
(true, Some(address)) => match guest
.memory()
.read_value::<_, KernelSigset>(address.cast::<KernelSigset>())
{
Ok(written) => Some(written),
Err(_) => return give_up(guest, "the old mask the kernel wrote cannot be read back"),
},
_ => None,
};
if let Some(written) = written {
match compare(written, old) {
Compared::Same => {}
Compared::ForcedOnly => return forced_changed(guest, "rt_sigprocmask"),
Compared::Different => {
return diverged(
guest,
"rt_sigprocmask",
&format!(
"old mask: the kernel wrote {:#x}, the copy holds {:#x}",
written & !reserved(),
old & !reserved()
),
);
}
}
}
check_against_kernel(guest, "rt_sigprocmask");
}
pub(crate) async fn check_and_record_delivery<G, T>(guest: &mut G, signal: i32)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let had_copy = guest.thread_state().signal_shadow.is_some();
take_unreported(guest);
take_wait_outcome(guest);
reconcile_returns(guest, "signal delivery");
if check_delivery(guest, signal, had_copy).await {
commit_delivery(guest, signal);
}
}
#[cfg(test)]
fn record_delivery<G, T>(guest: &mut G, signal: i32)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
take_unreported(guest);
take_wait_outcome(guest);
reconcile_returns(guest, "signal delivery");
commit_delivery(guest, signal);
}
fn commit_delivery<G, T>(guest: &mut G, signal: i32)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let Some(delivered) = with_copy(guest, |dispositions, thread| {
crate::signal_state::deliver(dispositions, thread, signal)
}) else {
return;
};
match delivered {
Ok(Some(action)) => {
trace!(
"[dtid {}] signal-state copy: recorded the delivery of signal {signal}",
guest.thread_state().dettid
);
if let Some(shadow) = guest.thread_state().signal_shadow.as_ref()
&& action.handler > 1
&& shadow.thread.activations.last() == Some(&shadow.thread.blocked)
{
debug!(
"[dtid {}] signal-state copy: the handler mask of signal {signal} equals the \
mask its frame saves, so its entry cannot be told from its return",
guest.thread_state().dettid
);
}
}
Ok(None) => {
debug!(
"[dtid {}] signal-state copy dropped: more than {} handler frames open",
guest.thread_state().dettid,
crate::signal_state::MAX_OPEN_FRAMES
);
drop_copy(guest);
}
Err(errno) => diverged(
guest,
"signal delivery",
&format!("the backend delivers signal {signal}, which the copy refuses with {errno}"),
),
}
}
#[derive(Clone, Debug, Default)]
pub(crate) struct DeliveryCounters {
owner: Option<crate::types::DetTid>,
approved: u64,
held: u64,
result_checked: u64,
mismatched: u64,
interruption_from_registers: u64,
skipped: std::collections::BTreeMap<&'static str, u64>,
unreported: std::collections::BTreeMap<&'static str, u64>,
}
impl DeliveryCounters {
fn skip(&mut self, reason: &'static str) {
*self.skipped.entry(reason).or_default() += 1;
}
pub(crate) fn count_unreported(
&mut self,
dettid: crate::types::DetTid,
reason: reverie::UnreportedSignalReason,
) {
self.owner.get_or_insert(dettid);
*self.unreported.entry(reason.name()).or_default() += 1;
}
pub(crate) fn log(&self, dettid: crate::types::DetTid) {
if self.approved + self.mismatched == 0
&& self.skipped.is_empty()
&& self.unreported.is_empty()
{
return;
}
let dettid = self.owner.unwrap_or(dettid);
trace!(
target: "detcore::signal_delivery",
"[dtid {dettid}] signal deliveries: approved={} held={} result_checked={} mismatched={} interruption_from_registers={} skipped={:?} unreported={:?}",
self.approved,
self.held,
self.result_checked,
self.mismatched,
self.interruption_from_registers,
self.skipped,
self.unreported
);
}
}
fn unavailable_reason(reason: reverie::SignalDeliveryUnavailable) -> &'static str {
use reverie::SignalDeliveryUnavailable as U;
match reason {
U::NotInSignalCallback => "not in signal callback",
U::NotTheReportedSignal { .. } => "not the reported signal",
U::NoSignalRecord => "no signal record",
U::NotADeliveryStop => "not a delivery stop",
U::FrameModeStop => "frame-mode stop",
U::TracerFiltered => "tracer filtered",
U::AlreadyApproved => "already approved",
U::AfterMismatch => "after mismatch",
U::UncheckedSignal => "unchecked signal",
U::BlockedAtResume => "blocked at resume",
U::Gone => "gone",
U::Unreadable(_) => "unreadable",
U::UnsupportedArchitecture => "unsupported architecture",
}
}
fn sees_syscall(nr: i64) -> bool {
usize::try_from(nr).is_ok_and(|nr| reverie::syscalls::Sysno::new(nr).is_some())
}
async fn delivery_interruption<G, T>(guest: &mut G) -> (reverie::Interruption, bool)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
use reverie::Interruption;
let record = guest.thread_state().delivery_interruption;
#[cfg(not(target_arch = "x86_64"))]
{
let _ = record;
(Interruption::AfterFrame, true)
}
#[cfg(target_arch = "x86_64")]
{
let regs = guest.regs().await;
let orig = regs.orig_rax as i64;
let from_registers = if orig == -1 {
Interruption::NotInSyscall
} else {
Interruption::KernelRun { syscall: orig }
};
if guest.config().passthru_opt {
return (from_registers, true);
}
match record {
Some(Interruption::AfterFrame)
if regs.rip == guest.thread_state().delivery_frame_handler =>
{
(Interruption::AfterFrame, false)
}
Some(
record @ (Interruption::Return { syscall, .. }
| Interruption::KernelRun { syscall }),
) if syscall == orig => (record, false),
Some(Interruption::NotInSyscall) if orig == -1 => (Interruption::NotInSyscall, false),
None | Some(Interruption::AfterFrame) => (from_registers, true),
_ if orig == -1 || !sees_syscall(orig) => (from_registers, true),
Some(record) => (record, false),
}
}
}
async fn check_delivery<G, T>(guest: &mut G, signal: i32, had_copy: bool) -> bool
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if !kernel_state_is_the_guests(guest) {
return true;
}
let dettid = guest.thread_state().dettid;
guest
.thread_state_mut()
.delivery_counters
.owner
.get_or_insert(dettid);
let state = guest.thread_state().signal_shadow.as_ref().map(|shadow| {
let actions = shadow.dispositions.lock().unwrap();
(
actions
.as_ref()
.map(|dispositions| dispositions.action(signal)),
shadow.thread.saved.unwrap_or(shadow.thread.blocked),
shadow.thread.blocked,
shadow.thread.clone(),
)
});
let skip = |guest: &mut G, reason| {
guest.thread_state_mut().delivery_counters.skip(reason);
true
};
let (action, frame_mask, current_mask, mut entered) = match state {
None if had_copy => return skip(guest, "copy given up at this delivery"),
None => return skip(guest, "no copy"),
Some((None, ..)) => return skip(guest, "dispositions unknown"),
Some((Some(Err(_)), ..)) => return skip(guest, "invalid signal"),
Some((Some(Ok(action)), frame, current, thread)) => (action, frame, current, thread),
};
if forced() & sigbit(signal) != 0 {
if current_mask & sigbit(signal) != 0 {
forced_changed(guest, "signal delivery");
return skip(guest, "forced while blocked");
}
let kernel_generated = guest
.signal_info()
.is_some_and(|info| i32::from_ne_bytes(info[8..12].try_into().unwrap()) > 0);
if kernel_generated && action.is_ignored() {
forced_changed(guest, "signal delivery");
return skip(guest, "forced while ignored");
}
}
if !action.is_caught() {
return skip(guest, "not caught");
}
if !entered.enter_handler(signal, &action) {
return skip(guest, "too many frames");
}
let handler_mask = entered.blocked;
let forced_frame = forced() & frame_mask & !sigbit(signal);
let forced_current = forced() & current_mask & !sigbit(signal);
let (interruption, from_registers) = delivery_interruption(guest).await;
let action = reverie::SignalAction {
handler: action.handler,
flags: action.flags,
restorer: action.restorer,
mask: action.mask,
};
let delivery = reverie::SignalDelivery {
signal,
action,
frame_mask,
current_mask,
handler_mask,
unchecked_mask: reserved() & !sigbit(signal),
unchecked_frame_mask: forced_frame,
unchecked_current_mask: forced_current,
interruption,
};
let result_checked = matches!(interruption, reverie::Interruption::Return { .. });
let held = guest.signal_report_path() == Some(reverie::SignalReportPath::Held);
let outcome = guest.deliver_signal(delivery).await;
let not_delivered = matches!(
outcome,
reverie::SignalDeliveryOutcome::Unavailable(
reverie::SignalDeliveryUnavailable::BlockedAtResume
| reverie::SignalDeliveryUnavailable::NotADeliveryStop
)
);
if !not_delivered {
let state = guest.thread_state_mut();
state.delivery_interruption = Some(reverie::Interruption::AfterFrame);
state.delivery_frame_handler = action.handler;
}
let counters = &mut guest.thread_state_mut().delivery_counters;
counters.interruption_from_registers += u64::from(from_registers);
match outcome {
reverie::SignalDeliveryOutcome::Accepted => {
counters.approved += 1;
counters.held += u64::from(held);
counters.result_checked += u64::from(result_checked);
trace!(
target: "detcore::signal_delivery",
"[dtid {}] signal-state copy: the delivery of signal {signal} is approved, \
interrupting {interruption:?}",
guest.thread_state().dettid
);
}
reverie::SignalDeliveryOutcome::Mismatch(mismatch) => {
counters.mismatched += 1;
let what = format!(
"the kernel contradicts the delivery of signal {signal} in {:?}: the copy holds \
{:#x}, the kernel {:#x}",
mismatch.field, mismatch.expected, mismatch.actual
);
if guest.config().signal_delivery_check_fatal {
let failure = format!(
"HERMIT_INTERNAL_FAILURE class=signal-delivery-check dtid={} {what}",
guest.thread_state().dettid
);
tracing::error!("{failure}");
panic!("{failure}");
}
diverged(guest, "signal delivery", &what);
}
reverie::SignalDeliveryOutcome::Unavailable(reason) => {
counters.skip(unavailable_reason(reason));
}
reverie::SignalDeliveryOutcome::Refused(_) => counters.skip("backend refuses"),
reverie::SignalDeliveryOutcome::Installed | reverie::SignalDeliveryOutcome::FrameFault => {
counters.skip("frame-building outcome");
}
}
!not_delivered
}
fn take_wait_outcome<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let Some((wait_mask, saved)) = guest
.thread_state()
.signal_shadow
.as_ref()
.map(|shadow| (shadow.thread.wait_mask, shadow.thread.saved))
else {
return;
};
if (wait_mask.is_none() && saved.is_none()) || !kernel_state_is_the_guests(guest) {
return;
}
let Some(kernel) = read_or_give_up(guest, "signal delivery") else {
return;
};
let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() else {
return;
};
let compared = !(reserved() | forced());
let same = |a: KernelSigset, b: KernelSigset| a & compared == b & compared;
if let Some(saved) = saved
&& same(kernel.blocked, saved)
{
shadow.thread.settle();
}
if let Some(wait_mask) = wait_mask
&& same(kernel.blocked, wait_mask)
&& !same(shadow.thread.blocked, wait_mask)
{
shadow.thread.interrupted_under_temporary_mask(wait_mask);
}
if compare(kernel.blocked, shadow.thread.blocked) == Compared::ForcedOnly {
forced_changed(guest, "signal delivery");
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct CopiedDispositions {
pub(crate) ignored: KernelSigset,
pub(crate) caught: KernelSigset,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
pub struct PublishedDispositions {
pub(crate) generation: u64,
#[serde(default)]
pub(crate) accepted: u64,
pub(crate) dispositions: Option<CopiedDispositions>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct PublicationAnswer {
pub(crate) held: u64,
pub(crate) taken: bool,
}
pub(crate) fn copied_dispositions<G, T>(guest: &G) -> Option<CopiedDispositions>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if any_notes() {
return None;
}
table_dispositions(guest.thread_state())
}
fn table_dispositions<T>(thread: &crate::tool_local::ThreadState<T>) -> Option<CopiedDispositions> {
let shadow = thread.signal_shadow.as_ref()?;
let actions = shadow.dispositions.lock().unwrap();
let dispositions = actions.as_ref()?;
Some(CopiedDispositions {
ignored: dispositions.ignored(),
caught: dispositions.caught(),
})
}
pub(crate) fn copied_dispositions_for<G, T>(guest: &G, signal: i32) -> Option<CopiedDispositions>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if !models(signal) {
return None;
}
copied_dispositions(guest)
}
fn models(signal: i32) -> bool {
(forced() | reserved()) & sigbit(signal) == 0
}
fn next_publication<G, T>(guest: &G) -> Option<(u64, Option<CopiedDispositions>)>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if !kernel_state_is_the_guests(guest) {
return None;
}
let mut record = guest.thread_state().published_dispositions.lock().unwrap();
let current = table_dispositions(guest.thread_state());
if current == record.dispositions {
return None;
}
record.generation += 1;
Some((record.generation, current))
}
fn settle_publication(
record: &mut PublishedDispositions,
generation: u64,
current: Option<CopiedDispositions>,
answer: Option<PublicationAnswer>,
) -> bool {
let Some(answer) = answer else {
return false;
};
if answer.taken {
if generation > record.accepted {
record.accepted = generation;
record.dispositions = current;
}
return false;
}
if answer.held > record.generation {
record.generation = answer.held;
}
true
}
pub(crate) async fn publish_dispositions<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
for _ in 0..2 {
let Some((generation, current)) = next_publication(guest) else {
return;
};
let answer =
crate::tool_global::publish_signal_dispositions(guest, generation, current).await;
trace!(
"[dtid {}] signal-state copy: published its process's dispositions {:?} (generation {}, answer: {:?})",
guest.thread_state().dettid,
current,
generation,
answer
);
let mut record = guest.thread_state().published_dispositions.lock().unwrap();
if !settle_publication(&mut record, generation, current, answer) {
return;
}
}
}
pub(crate) fn published_dispositions_decide(signal: i32) -> bool {
models(signal) && !any_notes()
}
fn mask_to_publish<T>(
thread: &crate::tool_local::ThreadState<T>,
observes_returns: bool,
) -> Option<KernelSigset> {
let masks = &thread.signal_shadow.as_ref()?.thread;
let uncertain = masks.wait_mask.is_some()
|| masks.saved.is_some()
|| masks.verify_at_entry
|| (!masks.activations.is_empty() && !(observes_returns && masks.innermost_observed()));
(!uncertain).then_some(masks.blocked)
}
pub(crate) async fn publish_mask<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if !kernel_state_is_the_guests(guest) {
return;
}
let current = mask_to_publish(guest.thread_state(), observes_sigreturns(guest.config()));
if guest.thread_state().published_mask == Some(current) {
return;
}
let taken = crate::tool_global::publish_signal_mask(guest, current).await;
trace!(
"[dtid {}] signal-state copy: published its mask {:?} (taken: {})",
guest.thread_state().dettid,
current.map(|mask| format!("{mask:#x}")),
taken
);
if taken {
guest.thread_state_mut().published_mask = Some(current);
}
}
pub(crate) async fn before_clone<G, T>(guest: &mut G, flags: u64)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let shares_actions = flags & libc::CLONE_SIGHAND as u64 != 0;
let new_process = flags & libc::CLONE_THREAD as u64 == 0;
if shares_actions
&& new_process
&& let Some(shadow) = guest.thread_state().signal_shadow.as_ref()
{
debug!(
"[dtid {}] signal-state copy: the actions become unknown, a clone shares them with a new process",
guest.thread_state().dettid
);
shadow.forget_dispositions();
}
publish_dispositions(guest).await;
}
pub(crate) fn observes_sigreturns(config: &crate::Config) -> bool {
config.signal_state_copy
&& config.sequentialize_threads
&& !config.gdbserver
&& !config.imprecise_timers
&& config.backend.reports_sigreturns
&& config.inherited_seccomp == detcore_model::config::InheritedSeccomp::Disabled
}
const RT_SIGFRAME_SIZE: u64 = 8 + 304 + 128;
const USER_ADDRESS_LIMIT_4_LEVEL: u64 = 0x7fff_ffff_f000;
pub(crate) fn record_sigreturn_report<T>(
thread: &mut crate::tool_local::ThreadState<T>,
report: reverie::SigreturnReport,
) {
let dettid = thread.dettid;
if thread.signal_shadow.is_none() {
return;
}
let frame_end = report
.stack_pointer()
.checked_sub(8)
.and_then(|frame| frame.checked_add(RT_SIGFRAME_SIZE));
let installed = match (report.frame(), frame_end) {
(reverie::SigreturnFrame::Readable { mask }, Some(end))
if end <= USER_ADDRESS_LIMIT_4_LEVEL =>
{
Some(mask)
}
(reverie::SigreturnFrame::Readable { .. }, Some(_)) => {
debug!(
"[dtid {dettid}] signal-state copy dropped: rt_sigreturn's frame reaches past \
the 4-level user address limit"
);
return drop_thread_copy(thread);
}
(reverie::SigreturnFrame::Protected, Some(_)) => {
debug!(
"[dtid {dettid}] signal-state copy dropped: rt_sigreturn's frame is mapped but \
protected from the guest"
);
return drop_thread_copy(thread);
}
_ => None,
};
let Some(shadow) = thread.signal_shadow.as_mut() else {
return;
};
shadow.thread.verify_at_entry = true;
match installed {
Some(mask) => {
shadow.thread.sigreturn(mask & !reserved());
#[cfg(test)]
REPORTED_RETURNS.with(|count| count.set(count.get() + 1));
trace!(
"[dtid {dettid}] signal-state copy: rt_sigreturn reported, installing {:#x}",
shadow.thread.blocked
);
}
None => {
trace!("[dtid {dettid}] signal-state copy: rt_sigreturn's frame faults, no mask change")
}
}
}
pub(crate) async fn record_rt_sigreturn<G, T>(guest: &mut G)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if guest.thread_state().signal_shadow.is_none() {
return;
}
let sp = guest.regs().await.rsp as usize;
let restored = Addr::<u64>::from_raw(sp.wrapping_add(super::signal::UC_SIGMASK_OFFSET))
.and_then(|address| guest.memory().read_value(address).ok());
if let Some(mask) = restored {
with_copy(guest, |_, thread| thread.sigreturn(mask & !reserved()));
}
}
fn check_against_kernel<G, T>(guest: &mut G, after: &str)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
take_unreported(guest);
if !kernel_state_is_the_guests(guest) || guest.thread_state().signal_shadow.is_none() {
return;
}
let Some(kernel) = read_or_give_up(guest, after) else {
return;
};
let Some(copy) = with_copy(guest, |dispositions, thread| {
(
thread.blocked,
dispositions.ignored(),
dispositions.caught(),
)
}) else {
return;
};
let (blocked, ignored, caught) = copy;
let shared_unsure = unreported_elsewhere(guest.tid().as_raw());
let fields = [
("SigBlk", kernel.blocked, blocked, true),
("SigIgn", kernel.ignored, ignored, !shared_unsure),
("SigCgt", kernel.caught, caught, !shared_unsure),
];
let mut forced_only = false;
let mut mismatches = Vec::new();
for (field, kernel, copy, checked) in fields {
if !checked {
continue;
}
match compare(kernel, copy) {
Compared::Same => {}
Compared::ForcedOnly => forced_only = true,
Compared::Different => mismatches.push(format!(
"{field} kernel {:#018x} copy {:#018x}",
kernel & !reserved(),
copy & !reserved()
)),
}
}
if !mismatches.is_empty() {
diverged(guest, after, &mismatches.join(", "));
} else if forced_only {
forced_changed(guest, after);
} else if shared_unsure {
trace!(
"[dtid {}] signal-state copy matches the kernel's mask at {after} (actions not \
compared: a sibling's signal was passed on unreported)",
guest.thread_state().dettid
);
} else {
if let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() {
shadow.thread.observe_handler_mask();
}
#[cfg(test)]
CHECKS_MATCHED.with(|count| count.set(count.get() + 1));
trace!(
"[dtid {}] signal-state copy matches the kernel at {after}",
guest.thread_state().dettid
);
}
}
#[cfg(test)]
thread_local! {
static CHECKS_MATCHED: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
static DIVERGENCES: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
static UNVERIFIED_ENTRIES: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
static REPORTED_RETURNS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
fn read_or_give_up<G, T>(guest: &mut G, at: &str) -> Option<super::threads::KernelSignalState>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
match read_thread_signal_state(guest.pid(), guest.tid()) {
Ok(state) => Some(state),
Err(errno) => {
debug!(
"[dtid {}] signal-state copy dropped at {at}: the kernel state is unreadable ({errno})",
guest.thread_state().dettid
);
drop_copy(guest);
None
}
}
}
pub(crate) fn note_wait_mask<G, T>(guest: &mut G, mask: KernelSigset)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if let Some(shadow) = guest.thread_state_mut().signal_shadow.as_mut() {
shadow.thread.wait_mask = Some(super::signal::kernel_installed_signal_mask(mask));
}
}
fn diverged<G, T>(guest: &mut G, after: &str, what: &str)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
#[cfg(test)]
DIVERGENCES.with(|count| count.set(count.get() + 1));
guest.thread_state_mut().signal_shadow_lost = true;
warn!(
"[dtid {}] {DIVERGED} at {after}: {what}; this thread's copy is dropped",
guest.thread_state().dettid
);
drop_copy(guest);
}
#[cfg(test)]
mod tests {
use std::cell::Cell;
use std::rc::Rc;
use reverie::GlobalRPC;
use reverie::GlobalTool;
use reverie::Pid;
use reverie::syscalls::LocalMemory;
use reverie::syscalls::SyscallInfo;
use super::*;
use crate::Config;
use crate::GlobalState;
use crate::ThreadState;
use crate::syscalls::threads::KernelSignalState;
use crate::syscalls::threads::signal_state_read_seam;
use crate::types::DetPid;
struct ShadowGuest {
config: Config,
thread: ThreadState<()>,
delivery: DeliveryScript,
}
#[derive(Default)]
struct DeliveryScript {
answer: Option<reverie::SignalDeliveryOutcome>,
signal_info: Option<[u8; reverie::SIGNAL_INFO_SIZE]>,
asked: Vec<reverie::SignalDelivery>,
report_path: Option<reverie::SignalReportPath>,
orig_rax: Option<i64>,
rip: u64,
registers_read: usize,
}
struct NoStack;
struct NoStackGuard;
impl Drop for NoStackGuard {
fn drop(&mut self) {}
}
impl reverie::Stack for NoStack {
type StackGuard = NoStackGuard;
fn size(&self) -> usize {
panic!("recording uses no scratch stack")
}
fn capacity(&self) -> usize {
panic!("recording uses no scratch stack")
}
fn push<'stack, T>(&mut self, _: T) -> Addr<'stack, T> {
panic!("recording uses no scratch stack")
}
fn reserve<'stack, T>(&mut self) -> AddrMut<'stack, T> {
panic!("recording uses no scratch stack")
}
fn commit(self) -> Result<Self::StackGuard, Errno> {
Ok(NoStackGuard)
}
}
#[reverie::tool]
impl GlobalRPC<GlobalState> for ShadowGuest {
async fn send_rpc(
&self,
message: <GlobalState as GlobalTool>::Request,
) -> <GlobalState as GlobalTool>::Response {
panic!("recording must not send an RPC: {:?}", message.2)
}
fn config(&self) -> &Config {
&self.config
}
}
#[reverie::tool]
impl Guest<Detcore> for ShadowGuest {
type Memory = LocalMemory;
type Stack = NoStack;
fn tid(&self) -> Pid {
Pid::from_raw(unsafe { libc::gettid() })
}
fn pid(&self) -> Pid {
Pid::from_raw(std::process::id() as i32)
}
fn ppid(&self) -> Option<Pid> {
None
}
fn memory(&self) -> Self::Memory {
LocalMemory::new()
}
fn thread_state_mut(&mut self) -> &mut ThreadState<()> {
&mut self.thread
}
fn thread_state(&self) -> &ThreadState<()> {
&self.thread
}
async fn regs(&mut self) -> libc::user_regs_struct {
let orig_rax = self
.delivery
.orig_rax
.expect("recording on a ptrace-like backend reads no registers");
self.delivery.registers_read += 1;
let mut regs: libc::user_regs_struct = unsafe { std::mem::zeroed() };
regs.orig_rax = orig_rax as u64;
regs.rip = self.delivery.rip;
regs
}
fn signal_report_path(&self) -> Option<reverie::SignalReportPath> {
self.delivery.report_path
}
fn signal_info(&self) -> Option<[u8; reverie::SIGNAL_INFO_SIZE]> {
self.delivery.signal_info
}
async fn deliver_signal(
&mut self,
delivery: reverie::SignalDelivery,
) -> reverie::SignalDeliveryOutcome {
self.delivery.asked.push(delivery);
self.delivery
.answer
.expect("this test does not expect a delivery check")
}
async fn stack(&mut self) -> Self::Stack {
NoStack
}
async fn daemonize(&mut self) {
panic!("recording must not daemonize")
}
async fn inject<S: SyscallInfo>(&mut self, _: S) -> Result<i64, Errno> {
panic!("recording must not inject")
}
async fn tail_inject<S: SyscallInfo>(&mut self, _: S) -> reverie::Never {
panic!("recording must not retire the guest")
}
fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), reverie::Error> {
panic!("recording must not set a timer")
}
fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), reverie::Error> {
panic!("recording must not set a timer")
}
fn read_clock(&mut self) -> Result<u64, reverie::Error> {
panic!("recording must not read a clock")
}
}
#[derive(Clone, Default)]
struct Kernel(Rc<Cell<(KernelSigset, KernelSigset, KernelSigset)>>);
impl Kernel {
fn set(&self, blocked: KernelSigset, ignored: KernelSigset, caught: KernelSigset) {
self.0.set((blocked, ignored, caught));
}
fn install(&self) -> signal_state_read_seam::Installed {
let state = self.0.clone();
signal_state_read_seam::install(move |_, _| {
let (blocked, ignored, caught) = state.get();
Some(Ok(KernelSignalState {
blocked,
ignored,
caught,
..KernelSignalState::default()
}))
})
}
}
fn seeded(kernel: &Kernel, blocked: KernelSigset) -> ShadowGuest {
seeded_on(kernel, blocked, reverie::BackendCapabilities::PTRACE)
}
fn seeded_inferring(kernel: &Kernel, blocked: KernelSigset) -> ShadowGuest {
seeded_on(kernel, blocked, reverie::BackendCapabilities::E9PATCH)
}
fn seeded_on(
kernel: &Kernel,
blocked: KernelSigset,
backend: reverie::BackendCapabilities,
) -> ShadowGuest {
let config = Config {
sequentialize_threads: true,
backend,
inherited_seccomp: detcore_model::config::InheritedSeccomp::Disabled,
..Config::default()
};
let thread = ThreadState::new(DetPid::from_raw(1), &config, ());
let mut guest = ShadowGuest {
config,
thread,
delivery: DeliveryScript::default(),
};
kernel.set(blocked, 0, 0);
at_exec(&mut guest);
assert!(
guest.thread.signal_shadow.is_some(),
"the first image is seeded"
);
guest
}
fn blocked(guest: &ShadowGuest) -> Option<KernelSigset> {
guest
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.blocked)
}
const USR1: KernelSigset = 1 << (libc::SIGUSR1 - 1);
const USR2: KernelSigset = 1 << (libc::SIGUSR2 - 1);
#[test]
fn a_matching_mask_change_is_recorded_and_checked() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
kernel.set(USR1, 0, 0);
let matched = CHECKS_MATCHED.with(std::cell::Cell::get);
let mut old: KernelSigset = 0;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(
&mut guest,
libc::SIG_BLOCK,
SetInput::Validated(USR1),
oldset,
&Ok(0),
);
assert_eq!(blocked(&guest), Some(USR1));
assert!(!guest.thread.signal_shadow_lost);
assert!(
CHECKS_MATCHED.with(std::cell::Cell::get) > matched,
"the check ran and matched"
);
}
#[test]
fn a_wait_mask_lasts_until_the_next_syscall_and_never_holds_sigkill() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let wait_mask = |guest: &ShadowGuest| {
guest
.thread
.signal_shadow
.as_ref()
.and_then(|shadow| shadow.thread.wait_mask)
};
note_wait_mask(&mut guest, USR1 | (1 << (libc::SIGKILL - 1)));
assert_eq!(wait_mask(&guest), Some(USR1));
at_syscall_entry(&mut guest);
assert_eq!(wait_mask(&guest), None, "the next call is not in the wait");
}
#[test]
fn any_signal_passed_on_unreported_gives_the_copy_up_and_its_note_is_consumed() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let (pid, tid) = (guest.pid().as_raw(), guest.tid().as_raw());
note_unreported(pid, tid, libc::SIGURG);
at_syscall_entry(&mut guest);
assert!(guest.thread.signal_shadow.is_none());
assert!(
!guest.thread.signal_shadow_lost,
"a quiet drop is seeded again at exec"
);
at_exec(&mut guest);
assert!(guest.thread.signal_shadow.is_some(), "seeded again");
guest.thread.signal_shadow = None;
note_unreported(pid, tid, libc::SIGUSR1);
at_syscall_entry(&mut guest);
assert!(!with_notes(|notes| notes.iter().any(|(_, t, _)| *t == tid)));
}
#[test]
fn a_match_with_an_outer_frame_is_ambiguous_and_gives_the_copy_up() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded_inferring(&kernel, 0);
let action = |mask| KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask,
};
kernel.set(0, 0, USR1 | USR2);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(action(0)), None, &Ok(0));
record_rt_sigaction(&mut guest, libc::SIGUSR2, Some(action(0)), None, &Ok(0));
record_delivery(&mut guest, libc::SIGUSR1);
kernel.set(USR1, 0, USR1 | USR2);
record_delivery(&mut guest, libc::SIGUSR2);
kernel.set(0, 0, USR1 | USR2);
at_syscall_entry(&mut guest);
assert!(guest.thread.signal_shadow.is_none());
}
#[test]
fn a_silent_drop_leaves_no_sharer_reporting_its_consequence() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let sharer = guest
.thread
.signal_shadow
.as_ref()
.unwrap()
.for_clone(libc::CLONE_SIGHAND as u64 | libc::CLONE_VM as u64)
.unwrap();
let before = DIVERGENCES.with(std::cell::Cell::get);
let mut old: KernelSigset = 0;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(
&mut guest,
libc::SIG_UNBLOCK,
SetInput::Unvalidated(Some(USR1)),
oldset,
&Err(Errno::EFAULT),
);
assert!(guest.thread.signal_shadow.is_none());
assert!(sharer.dispositions.lock().unwrap().is_none());
assert_eq!(
DIVERGENCES.with(std::cell::Cell::get),
before,
"nothing was reported"
);
}
#[test]
fn an_old_action_the_kernel_wrote_differently_is_a_divergence() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let mut written = KernelSigaction {
handler: 1,
flags: 0,
restorer: 0,
mask: 0,
};
let old_action = AddrMut::from_raw(&mut written as *mut KernelSigaction as usize);
let reported = DIVERGENCES.with(std::cell::Cell::get);
record_rt_sigaction(&mut guest, libc::SIGUSR1, None, old_action, &Ok(0));
assert!(guest.thread.signal_shadow.is_none());
assert!(
DIVERGENCES.with(std::cell::Cell::get) > reported,
"reported"
);
}
#[test]
fn a_mismatch_drops_the_copy_for_good_and_its_sharers_quietly() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let sharer = guest
.thread
.signal_shadow
.as_ref()
.unwrap()
.for_clone(libc::CLONE_SIGHAND as u64 | libc::CLONE_VM as u64)
.unwrap();
kernel.set(USR2, 0, 0);
let reported = DIVERGENCES.with(std::cell::Cell::get);
record_rt_sigprocmask(
&mut guest,
libc::SIG_BLOCK,
SetInput::Validated(USR1),
None,
&Ok(0),
);
assert_eq!(blocked(&guest), None, "the copy is dropped");
assert!(
DIVERGENCES.with(std::cell::Cell::get) > reported,
"the divergence was reported"
);
assert!(guest.thread.signal_shadow_lost);
assert!(
sharer.dispositions.lock().unwrap().is_none(),
"the actions it shared are unknown now"
);
at_exec(&mut guest);
assert!(
guest.thread.signal_shadow.is_none(),
"a lost copy is never reseeded"
);
}
#[test]
fn an_efault_counts_only_when_the_kernel_ran_the_call_and_the_fault_was_the_old_masks() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let mut old: KernelSigset = 0;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(
&mut guest,
libc::SIG_BLOCK,
SetInput::NotRun,
oldset,
&Err(Errno::EFAULT),
);
assert_eq!(blocked(&guest), Some(0));
kernel.set(USR1, 0, 0);
record_rt_sigprocmask(
&mut guest,
libc::SIG_BLOCK,
SetInput::Validated(USR1),
oldset,
&Err(Errno::EFAULT),
);
assert_eq!(blocked(&guest), Some(USR1));
record_rt_sigprocmask(
&mut guest,
libc::SIG_UNBLOCK,
SetInput::Unvalidated(Some(USR1)),
None,
&Err(Errno::EFAULT),
);
assert_eq!(blocked(&guest), Some(USR1));
record_rt_sigprocmask(
&mut guest,
libc::SIG_UNBLOCK,
SetInput::Unvalidated(Some(USR1)),
oldset,
&Err(Errno::EFAULT),
);
assert_eq!(blocked(&guest), None);
assert!(!guest.thread.signal_shadow_lost, "a quiet drop");
}
#[test]
fn a_delivery_inside_a_wait_follows_the_mask_the_kernel_holds() {
let kernel = Kernel::default();
let _seam = kernel.install();
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
let int = 1 << (libc::SIGINT - 1);
for kernel_ran_the_wait in [true, false] {
let mut guest = seeded(&kernel, USR1 | USR2);
kernel.set(USR1 | USR2, 0, 1 << (libc::SIGINT - 1));
record_rt_sigaction(&mut guest, libc::SIGINT, Some(action), None, &Ok(0));
let temporary: KernelSigset = USR1;
at_syscall_entry(&mut guest);
note_wait_mask(&mut guest, temporary);
kernel.set(
if kernel_ran_the_wait {
USR1
} else {
USR1 | USR2
},
0,
int,
);
record_delivery(&mut guest, libc::SIGINT);
let shadow = guest.thread.signal_shadow.as_ref().unwrap();
let expected = if kernel_ran_the_wait {
USR1
} else {
USR1 | USR2
};
assert_eq!(
shadow.thread.blocked,
expected | int,
"{kernel_ran_the_wait}"
);
assert_eq!(
shadow.thread.activations,
vec![USR1 | USR2],
"the frame saves the thread's own mask either way"
);
}
}
#[test]
fn an_unreported_return_is_recognised_at_the_next_syscall() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded_inferring(&kernel, 0);
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: USR2,
};
kernel.set(0, 0, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(action), None, &Ok(0));
record_delivery(&mut guest, libc::SIGUSR1);
assert_eq!(blocked(&guest), Some(USR1 | USR2));
kernel.set(USR1 | USR2, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), Some(USR1 | USR2));
kernel.set(0, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), Some(0));
record_delivery(&mut guest, libc::SIGUSR1);
kernel.set(USR2, 0, USR1);
let reported = DIVERGENCES.with(std::cell::Cell::get);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), None);
assert_eq!(DIVERGENCES.with(std::cell::Cell::get), reported);
}
#[test]
fn a_sigtrap_change_gives_the_copy_up_quietly() {
let kernel = Kernel::default();
let _seam = kernel.install();
let trap = 1 << (libc::SIGTRAP - 1);
let mut guest = seeded(&kernel, trap);
let reported = DIVERGENCES.with(std::cell::Cell::get);
kernel.set(0, 0, 0);
let mut old: KernelSigset = 0;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(&mut guest, libc::SIG_BLOCK, SetInput::None, oldset, &Ok(0));
assert!(
guest.thread.signal_shadow.is_none(),
"the copy is unknown now"
);
assert_eq!(
DIVERGENCES.with(std::cell::Cell::get),
reported,
"and nothing was reported"
);
}
#[test]
fn a_forced_sigsegv_reset_gives_the_copy_up_quietly() {
let kernel = Kernel::default();
let _seam = kernel.install();
let segv = 1 << (libc::SIGSEGV - 1);
let handler = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
let mut guest = seeded(&kernel, segv);
kernel.set(segv, 0, segv);
record_rt_sigaction(&mut guest, libc::SIGSEGV, Some(handler), None, &Ok(0));
assert_eq!(
copied_dispositions(&guest).map(|copied| copied.caught),
Some(segv)
);
let reported = DIVERGENCES.with(std::cell::Cell::get);
kernel.set(0, 0, 0);
let mut old: KernelSigset = 0;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(&mut guest, libc::SIG_BLOCK, SetInput::None, oldset, &Ok(0));
assert!(
guest.thread.signal_shadow.is_none(),
"the copy is unknown now"
);
assert_eq!(
DIVERGENCES.with(std::cell::Cell::get),
reported,
"and nothing was reported"
);
}
fn query_mask_written(guest: &mut ShadowGuest, kernel_blocked: KernelSigset) {
let mut old: KernelSigset = kernel_blocked;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(guest, libc::SIG_BLOCK, SetInput::None, oldset, &Ok(0));
}
fn query_mask(guest: &mut ShadowGuest) {
let mut old: KernelSigset = 0;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(guest, libc::SIG_BLOCK, SetInput::None, oldset, &Ok(0));
}
#[test]
fn a_forced_reset_of_an_ignored_sigsegv_is_quiet() {
let kernel = Kernel::default();
let _seam = kernel.install();
let segv = 1 << (libc::SIGSEGV - 1);
let ignore = KernelSigaction {
handler: libc::SIG_IGN as u64,
flags: 0x0400_0000,
restorer: 0x7000,
mask: 0,
};
let reported = DIVERGENCES.with(std::cell::Cell::get);
let mut guest = seeded(&kernel, 0);
kernel.set(0, segv, 0);
record_rt_sigaction(&mut guest, libc::SIGSEGV, Some(ignore), None, &Ok(0));
kernel.set(0, 0, 0);
query_mask(&mut guest);
assert!(guest.thread.signal_shadow.is_none(), "given up");
let mut guest = seeded(&kernel, 0);
kernel.set(0, segv, 0);
record_rt_sigaction(&mut guest, libc::SIGSEGV, Some(ignore), None, &Ok(0));
kernel.set(0, 0, 0);
let mut written = KernelSigaction {
handler: libc::SIG_DFL as u64,
..ignore
};
let old_action = AddrMut::from_raw(&mut written as *mut KernelSigaction as usize);
record_rt_sigaction(&mut guest, libc::SIGSEGV, None, old_action, &Ok(0));
assert!(guest.thread.signal_shadow.is_none(), "given up");
assert_eq!(
DIVERGENCES.with(std::cell::Cell::get),
reported,
"nothing reported"
);
}
#[test]
fn forced_signal_differences_a_reset_cannot_make_are_divergences() {
let kernel = Kernel::default();
let _seam = kernel.install();
let segv = 1 << (libc::SIGSEGV - 1);
let reported = || DIVERGENCES.with(std::cell::Cell::get);
let mut guest = seeded(&kernel, 0);
let before = reported();
kernel.set(0, segv, 0);
query_mask(&mut guest);
assert!(reported() > before, "the kernel ignores more than the copy");
let mut guest = seeded(&kernel, segv | USR1);
let before = reported();
kernel.set(0, 0, 0);
query_mask(&mut guest);
assert!(
reported() > before,
"a difference beyond the forced signals"
);
let mut guest = seeded(&kernel, 0);
let before = reported();
let mut written = KernelSigaction {
handler: 0x5000,
flags: 0x0400_0000,
restorer: 0x7000,
mask: 0,
};
let old_action = AddrMut::from_raw(&mut written as *mut KernelSigaction as usize);
record_rt_sigaction(&mut guest, libc::SIGSEGV, None, old_action, &Ok(0));
assert!(reported() > before, "a handler a reset cannot install");
let mut guest = seeded(&kernel, 0);
let handler = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
kernel.set(0, 0, segv);
record_rt_sigaction(&mut guest, libc::SIGSEGV, Some(handler), None, &Ok(0));
let before = reported();
kernel.set(0, 0, 0);
let mut written = KernelSigaction {
handler: libc::SIG_DFL as u64,
flags: 0x0400_0000,
..handler
};
let old_action = AddrMut::from_raw(&mut written as *mut KernelSigaction as usize);
record_rt_sigaction(&mut guest, libc::SIGSEGV, None, old_action, &Ok(0));
assert!(reported() > before, "flags a reset does not change");
}
#[test]
fn a_caught_signal_reset_counts_as_forced_whatever_the_mask_is_now() {
let kernel = Kernel::default();
let _seam = kernel.install();
let trap = 1 << (libc::SIGTRAP - 1);
let handler = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
let reported = || DIVERGENCES.with(std::cell::Cell::get);
let mut guest = seeded(&kernel, trap);
kernel.set(trap, 0, trap);
record_rt_sigaction(&mut guest, libc::SIGTRAP, Some(handler), None, &Ok(0));
let before = reported();
kernel.set(trap, 0, 0);
query_mask_written(&mut guest, trap);
assert!(guest.thread.signal_shadow.is_none(), "given up");
assert_eq!(reported(), before, "quietly");
let mut guest = seeded(&kernel, 0);
let before = reported();
kernel.set(0, 0, 1 << (libc::SIGSEGV - 1));
query_mask(&mut guest);
assert!(reported() > before, "the kernel catches more than the copy");
}
#[test]
fn reconciliation_follows_the_forced_rule() {
let kernel = Kernel::default();
let _seam = kernel.install();
let segv = 1 << (libc::SIGSEGV - 1);
let reported = || DIVERGENCES.with(std::cell::Cell::get);
let before = reported();
let mut guest = in_handler(&kernel, reverie::BackendCapabilities::PTRACE);
kernel.set(USR1 | USR2 | segv, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), None, "given up");
let mut guest = seeded(&kernel, segv);
let handler = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
kernel.set(segv, 0, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(handler), None, &Ok(0));
record_delivery(&mut guest, libc::SIGUSR1);
kernel.set(USR1, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), None, "given up");
let mut guest = in_handler(&kernel, reverie::BackendCapabilities::E9PATCH);
kernel.set(USR1 | USR2, 0, USR1);
at_syscall_entry(&mut guest);
kernel.set(segv, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), None, "given up");
assert_eq!(reported(), before, "none of these is a divergence");
}
#[test]
fn the_preemption_signal_is_left_out_of_old_values() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let perf = 1 << (reverie::PERF_EVENT_SIGNAL as i32 - 1);
kernel.set(perf, 0, perf);
let mut old: KernelSigset = perf;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
record_rt_sigprocmask(&mut guest, libc::SIG_BLOCK, SetInput::None, oldset, &Ok(0));
assert!(guest.thread.signal_shadow.is_some());
}
#[test]
fn a_wait_mask_from_sigfillset_matches_what_the_kernel_installs() {
let kernel = Kernel::default();
let _seam = kernel.install();
let int = 1 << (libc::SIGINT - 1);
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
let filled: KernelSigset = !(int | (1 << 31) | (1 << 32));
let installed = filled & !((1 << (libc::SIGKILL - 1)) | (1 << (libc::SIGSTOP - 1)));
for kernel_ran_the_wait in [true, false] {
let mut guest = seeded(&kernel, USR1);
kernel.set(USR1, 0, int);
record_rt_sigaction(&mut guest, libc::SIGINT, Some(action), None, &Ok(0));
at_syscall_entry(&mut guest);
note_wait_mask(&mut guest, filled);
let at_stop = if kernel_ran_the_wait { installed } else { USR1 };
kernel.set(at_stop, 0, int);
record_delivery(&mut guest, libc::SIGINT);
let shadow = guest.thread.signal_shadow.as_ref().unwrap();
assert_eq!(
shadow.thread.blocked,
at_stop | int,
"{kernel_ran_the_wait}"
);
assert_eq!(shadow.thread.activations, vec![USR1]);
}
}
#[test]
fn an_old_mask_the_kernel_wrote_differently_is_a_divergence() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let mut old: KernelSigset = USR2;
let oldset = AddrMut::from_raw(&mut old as *mut KernelSigset as usize);
let reported = DIVERGENCES.with(std::cell::Cell::get);
record_rt_sigprocmask(&mut guest, libc::SIG_BLOCK, SetInput::None, oldset, &Ok(0));
assert_eq!(blocked(&guest), None);
assert!(
DIVERGENCES.with(std::cell::Cell::get) > reported,
"reported"
);
}
#[test]
fn rt_sigaction_installs_even_when_the_old_action_cannot_be_written() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
kernel.set(0, 0, USR1);
record_rt_sigaction(
&mut guest,
libc::SIGUSR1,
Some(action),
None,
&Err(Errno::EFAULT),
);
let shadow = guest.thread.signal_shadow.as_ref().unwrap();
let caught = shadow
.dispositions
.lock()
.unwrap()
.as_ref()
.unwrap()
.caught();
assert_eq!(caught, USR1);
}
#[test]
fn a_handler_entry_no_check_saw_gives_the_copy_up_when_taken_as_returned() {
let kernel = Kernel::default();
let _seam = kernel.install();
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: USR2,
};
let mut guest = seeded_inferring(&kernel, 0);
kernel.set(0, 0, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(action), None, &Ok(0));
record_delivery(&mut guest, libc::SIGUSR1);
kernel.set(USR1 | USR2, 0, USR1);
at_syscall_entry(&mut guest);
kernel.set(0, 0, USR1);
let before = UNVERIFIED_ENTRIES.with(std::cell::Cell::get);
at_syscall_entry(&mut guest);
assert!(guest.thread.signal_shadow.is_some());
assert_eq!(UNVERIFIED_ENTRIES.with(std::cell::Cell::get), before);
let reported = DIVERGENCES.with(std::cell::Cell::get);
record_delivery(&mut guest, libc::SIGUSR1);
at_syscall_entry(&mut guest);
assert_eq!(UNVERIFIED_ENTRIES.with(std::cell::Cell::get), before + 1);
assert!(guest.thread.signal_shadow.is_none());
assert_eq!(DIVERGENCES.with(std::cell::Cell::get), reported);
}
fn in_handler(kernel: &Kernel, backend: reverie::BackendCapabilities) -> ShadowGuest {
let mut guest = seeded_on(kernel, 0, backend);
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: USR2,
};
kernel.set(0, 0, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(action), None, &Ok(0));
record_delivery(&mut guest, libc::SIGUSR1);
assert_eq!(blocked(&guest), Some(USR1 | USR2));
guest
}
fn open_frames(guest: &ShadowGuest) -> usize {
guest
.thread
.signal_shadow
.as_ref()
.map_or(0, |shadow| shadow.thread.activations.len())
}
#[test]
fn copied_dispositions_answer_only_where_the_copy_can() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let handler = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
let ignore = KernelSigaction {
handler: libc::SIG_IGN as u64,
flags: 0x0400_0000,
restorer: 0x7000,
mask: 0,
};
kernel.set(0, 0, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(handler), None, &Ok(0));
kernel.set(0, USR2, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR2, Some(ignore), None, &Ok(0));
let expected = Some(CopiedDispositions {
ignored: USR2,
caught: USR1,
});
assert_eq!(
copied_dispositions(&guest),
expected,
"what the kernel holds"
);
assert_eq!(copied_dispositions_for(&guest, libc::SIGUSR1), expected);
for signal in [
libc::SIGTRAP,
libc::SIGSEGV,
libc::SIGBUS,
libc::SIGILL,
libc::SIGFPE,
libc::SIGSYS,
] {
assert_eq!(copied_dispositions_for(&guest, signal), None, "{signal}");
}
assert_eq!(
copied_dispositions_for(&guest, reverie::PERF_EVENT_SIGNAL as i32),
None
);
note_unreported(1, i32::MAX - 1, libc::SIGUSR1);
assert_eq!(copied_dispositions(&guest), None);
with_notes(|notes| notes.clear());
assert_eq!(copied_dispositions(&guest), expected);
guest
.thread
.signal_shadow
.as_ref()
.unwrap()
.forget_dispositions();
assert_eq!(copied_dispositions(&guest), None);
guest.thread.signal_shadow = None;
assert_eq!(copied_dispositions(&guest), None);
}
fn due(guest: &ShadowGuest) -> Option<Option<CopiedDispositions>> {
next_publication(guest).map(|(_, dispositions)| dispositions)
}
#[test]
fn answers_settle_the_record_in_any_order() {
let one = Some(CopiedDispositions {
ignored: USR1,
caught: 0,
});
let two = Some(CopiedDispositions {
ignored: USR1 | USR2,
caught: 0,
});
let answer = |held, taken| Some(PublicationAnswer { held, taken });
let mut record = PublishedDispositions {
generation: 2,
accepted: 0,
dispositions: None,
};
assert!(!settle_publication(&mut record, 2, two, answer(2, true)));
assert!(
settle_publication(&mut record, 1, one, answer(2, false)),
"superseded: publish again"
);
assert_eq!((record.accepted, record.dispositions), (2, two));
let mut record = PublishedDispositions {
generation: 2,
accepted: 0,
dispositions: None,
};
assert!(!settle_publication(&mut record, 1, one, answer(1, true)));
assert_eq!((record.accepted, record.dispositions), (1, one));
assert!(!settle_publication(&mut record, 2, two, answer(2, true)));
assert_eq!((record.accepted, record.dispositions), (2, two));
let before = record;
record.generation = 3;
assert!(!settle_publication(&mut record, 3, None, None));
assert_eq!(record.dispositions, before.dispositions);
record.generation = 4;
assert!(!settle_publication(&mut record, 4, None, answer(4, true)));
assert_eq!((record.accepted, record.dispositions), (4, None));
record.generation = 5;
assert!(settle_publication(&mut record, 5, one, answer(50, false)));
assert_eq!(record.generation, 50);
assert_eq!((record.accepted, record.dispositions), (4, None));
record.generation = 51;
assert!(settle_publication(&mut record, 51, one, answer(51, false)));
assert_eq!(record.generation, 51);
assert_eq!((record.accepted, record.dispositions), (4, None));
}
#[test]
fn a_publication_is_due_whenever_the_scheduler_holds_other_dispositions() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let published = |guest: &ShadowGuest, dispositions| {
guest
.thread
.published_dispositions
.lock()
.unwrap()
.dispositions = dispositions;
};
let nothing = CopiedDispositions {
ignored: 0,
caught: 0,
};
assert_eq!(due(&guest), Some(Some(nothing)), "seeded");
published(&guest, Some(nothing));
assert_eq!(due(&guest), None, "the scheduler holds them");
let ignore = KernelSigaction {
handler: libc::SIG_IGN as u64,
flags: 0x0400_0000,
restorer: 0x7000,
mask: 0,
};
kernel.set(0, USR1, 0);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(ignore), None, &Ok(0));
let ignoring = CopiedDispositions {
ignored: USR1,
caught: 0,
};
assert_eq!(due(&guest), Some(Some(ignoring)));
published(&guest, Some(ignoring));
note_unreported(1, i32::MAX - 1, libc::SIGUSR1);
assert_eq!(due(&guest), None);
with_notes(|notes| notes.clear());
give_up(&mut guest, "a test");
assert_eq!(due(&guest), Some(None), "withdrawn");
published(&guest, None);
assert_eq!(due(&guest), None);
}
#[test]
fn the_mask_is_published_only_where_the_kernel_holds_it() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, USR1);
let publish = |guest: &ShadowGuest, observes| mask_to_publish(&guest.thread, observes);
assert_eq!(publish(&guest, true), Some(USR1));
fn masks(guest: &mut ShadowGuest) -> &mut ThreadSignals {
&mut guest.thread.signal_shadow.as_mut().unwrap().thread
}
masks(&mut guest).wait_mask = Some(0);
assert_eq!(publish(&guest, true), None, "inside a temporary-mask wait");
masks(&mut guest).wait_mask = None;
masks(&mut guest).saved = Some(USR1);
assert_eq!(
publish(&guest, true),
None,
"an interrupted wait's mask to put back"
);
masks(&mut guest).saved = None;
masks(&mut guest).verify_at_entry = true;
assert_eq!(
publish(&guest, true),
None,
"a reported mask not yet verified"
);
masks(&mut guest).verify_at_entry = false;
masks(&mut guest).activations.push(0);
masks(&mut guest).observed.push(false);
assert_eq!(
publish(&guest, true),
None,
"a handler entry no check has seen"
);
*masks(&mut guest).observed.last_mut().unwrap() = true;
assert_eq!(
publish(&guest, true),
Some(USR1),
"a checked frame whose return is reported"
);
assert_eq!(
publish(&guest, false),
None,
"a frame whose return would go unseen"
);
guest.thread.signal_shadow = None;
assert_eq!(publish(&guest, true), None, "no copy");
}
#[test]
fn nothing_is_published_where_no_copy_is_kept() {
let config = Config {
sequentialize_threads: true,
backend: reverie::BackendCapabilities::KVM,
..Config::default()
};
let thread = ThreadState::new(DetPid::from_raw(1), &config, ());
let guest = ShadowGuest {
config,
thread,
delivery: DeliveryScript::default(),
};
guest
.thread
.published_dispositions
.lock()
.unwrap()
.dispositions = Some(CopiedDispositions {
ignored: USR1,
caught: 0,
});
assert_eq!(due(&guest), None);
}
#[test]
fn published_dispositions_decide_where_the_copy_does() {
assert!(published_dispositions_decide(libc::SIGUSR1));
assert!(published_dispositions_decide(libc::SIGCHLD));
for signal in [
libc::SIGTRAP,
libc::SIGSEGV,
libc::SIGBUS,
libc::SIGILL,
libc::SIGFPE,
libc::SIGSYS,
reverie::PERF_EVENT_SIGNAL as i32,
] {
assert!(!published_dispositions_decide(signal), "{signal}");
}
note_unreported(1, i32::MAX - 1, libc::SIGUSR1);
assert!(!published_dispositions_decide(libc::SIGUSR1));
with_notes(|notes| notes.clear());
}
#[test]
fn a_clone_sharing_the_actions_with_a_new_process_makes_them_unknown() {
let kernel = Kernel::default();
let _seam = kernel.install();
let sighand = (libc::CLONE_VM | libc::CLONE_SIGHAND) as u64;
let nothing = CopiedDispositions {
ignored: 0,
caught: 0,
};
let mut guest = seeded(&kernel, 0);
guest
.thread
.published_dispositions
.lock()
.unwrap()
.dispositions = Some(nothing);
let thread = sighand | libc::CLONE_THREAD as u64;
futures::executor::block_on(before_clone(&mut guest, thread));
assert_eq!(copied_dispositions(&guest), Some(nothing), "a thread");
let mut guest = seeded(&kernel, 0);
futures::executor::block_on(before_clone(&mut guest, sighand));
assert_eq!(copied_dispositions(&guest), None);
let shadow = guest.thread.signal_shadow.as_ref().unwrap();
assert!(
shadow.for_clone(sighand).is_none(),
"the child gets no copy"
);
}
#[test]
fn a_thread_shares_its_process_record_and_one_denied_a_copy_withdraws() {
use reverie::Tool;
let kernel = Kernel::default();
let _seam = kernel.install();
let mut parent = seeded(&kernel, 0);
let nothing = CopiedDispositions {
ignored: 0,
caught: 0,
};
parent
.thread
.published_dispositions
.lock()
.unwrap()
.dispositions = Some(nothing);
let tool = <Detcore as Tool>::new(Pid::from_raw(1), &parent.config);
let child = |parent: &mut ShadowGuest, flags: u64| {
parent.thread.clone_flags = Some(crate::CloneFlags::from_bits_truncate(flags));
let thread = <Detcore as Tool>::init_thread_state(
&tool,
Pid::from_raw(2),
Some((Pid::from_raw(1), &parent.thread)),
);
parent.thread.clone_flags = None;
ShadowGuest {
config: parent.config.clone(),
thread,
delivery: DeliveryScript::default(),
}
};
let thread_flags = (libc::CLONE_VM | libc::CLONE_SIGHAND | libc::CLONE_THREAD) as u64;
let fork = child(&mut parent, libc::SIGCHLD as u64);
assert!(!std::sync::Arc::ptr_eq(
&fork.thread.published_dispositions,
&parent.thread.published_dispositions
));
assert_eq!(
due(&fork),
Some(Some(nothing)),
"a new process publishes its own"
);
let sibling = child(&mut parent, thread_flags);
assert!(std::sync::Arc::ptr_eq(
&sibling.thread.published_dispositions,
&parent.thread.published_dispositions
));
assert_eq!(due(&sibling), None, "already published");
let handler = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
kernel.set(0, 0, USR1);
record_rt_sigaction(&mut parent, libc::SIGUSR1, Some(handler), None, &Ok(0));
let caught = CopiedDispositions {
ignored: 0,
caught: USR1,
};
parent
.thread
.published_dispositions
.lock()
.unwrap()
.dispositions = Some(caught);
kernel.set(USR1, 0, USR1);
record_delivery(&mut parent, libc::SIGUSR1);
assert_eq!(open_frames(&parent), 1);
let denied = child(&mut parent, thread_flags);
assert!(denied.thread.signal_shadow.is_none());
assert_eq!(due(&denied), Some(None), "withdrawn first");
assert_eq!(due(&parent), Some(None));
}
#[test]
fn sigreturns_are_observed_only_where_the_backend_reports_them() {
let config = |backend| Config {
backend,
sequentialize_threads: true,
inherited_seccomp: detcore_model::config::InheritedSeccomp::Disabled,
..Config::default()
};
assert!(observes_sigreturns(&config(
reverie::BackendCapabilities::PTRACE
)));
for inherited in [
detcore_model::config::InheritedSeccomp::Unknown,
detcore_model::config::InheritedSeccomp::Strict,
detcore_model::config::InheritedSeccomp::Filter(Some(1)),
] {
let config = Config {
inherited_seccomp: inherited,
..config(reverie::BackendCapabilities::PTRACE)
};
assert!(!observes_sigreturns(&config), "{inherited:?}");
}
let attached = Config {
gdbserver: true,
..config(reverie::BackendCapabilities::PTRACE)
};
assert!(!observes_sigreturns(&attached));
let parallel = Config {
sequentialize_threads: false,
..config(reverie::BackendCapabilities::PTRACE)
};
assert!(!observes_sigreturns(¶llel));
let off = Config {
signal_state_copy: false,
..config(reverie::BackendCapabilities::PTRACE)
};
assert!(!observes_sigreturns(&off));
let imprecise = Config {
imprecise_timers: true,
..config(reverie::BackendCapabilities::PTRACE)
};
assert!(!observes_sigreturns(&imprecise));
for backend in [
reverie::BackendCapabilities::E9PATCH,
reverie::BackendCapabilities::KVM,
reverie::BackendCapabilities::DBT,
reverie::BackendCapabilities::SABRE,
reverie::BackendCapabilities::LITEINST_IN_GUEST,
] {
assert!(!observes_sigreturns(&config(backend)));
}
}
#[test]
fn a_reported_return_installs_the_frame_mask_the_handler_left() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = in_handler(&kernel, reverie::BackendCapabilities::PTRACE);
let (reported, matched, returns) = (
DIVERGENCES.with(std::cell::Cell::get),
CHECKS_MATCHED.with(std::cell::Cell::get),
REPORTED_RETURNS.with(std::cell::Cell::get),
);
let tid = guest.tid();
record_sigreturn_report(
&mut guest.thread,
reverie::SigreturnReport::new(
tid,
0x7fff_0000_0000,
reverie::SigreturnFrame::Readable { mask: USR2 },
),
);
assert_eq!(REPORTED_RETURNS.with(std::cell::Cell::get), returns + 1);
assert_eq!(blocked(&guest), Some(USR2));
assert_eq!(open_frames(&guest), 0);
kernel.set(USR2, 0, USR1);
at_syscall_entry(&mut guest);
check_against_kernel(&mut guest, "a test check");
assert_eq!(blocked(&guest), Some(USR2), "the copy is kept");
assert_eq!(CHECKS_MATCHED.with(std::cell::Cell::get), matched + 1);
assert_eq!(DIVERGENCES.with(std::cell::Cell::get), reported);
}
#[test]
fn a_reported_return_whose_frame_mask_cannot_be_read_changes_nothing() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = in_handler(&kernel, reverie::BackendCapabilities::PTRACE);
let tid = guest.tid();
record_sigreturn_report(
&mut guest.thread,
reverie::SigreturnReport::new(tid, 0x7fff_0000_0000, reverie::SigreturnFrame::Unmapped),
);
assert_eq!(blocked(&guest), Some(USR1 | USR2));
assert_eq!(open_frames(&guest), 1);
}
#[test]
fn the_frame_range_rule_follows_linux() {
let kernel = Kernel::default();
let _seam = kernel.install();
let readable = reverie::SigreturnFrame::Readable { mask: USR2 };
let at_limit = USER_ADDRESS_LIMIT_4_LEVEL - RT_SIGFRAME_SIZE + 8;
let cases = [
(at_limit, readable, Some(Some(USR2))),
(at_limit + 1, readable, None),
(4, readable, Some(Some(USR1 | USR2))),
(0x7fff_0000_0000, reverie::SigreturnFrame::Protected, None),
];
for (sp, frame, expected) in cases {
let mut guest = in_handler(&kernel, reverie::BackendCapabilities::PTRACE);
let tid = guest.tid();
let reported = DIVERGENCES.with(std::cell::Cell::get);
record_sigreturn_report(
&mut guest.thread,
reverie::SigreturnReport::new(tid, sp, frame),
);
assert_eq!(
blocked(&guest).map(Some),
expected,
"sp {sp:#x}, {frame:?}: None means given up"
);
assert_eq!(DIVERGENCES.with(std::cell::Cell::get), reported);
}
}
#[test]
fn a_report_the_kernel_did_not_follow_fails_closed_at_the_next_entry() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = in_handler(&kernel, reverie::BackendCapabilities::PTRACE);
let tid = guest.tid();
record_sigreturn_report(
&mut guest.thread,
reverie::SigreturnReport::new(
tid,
0x7fff_0000_0000,
reverie::SigreturnFrame::Readable { mask: USR2 },
),
);
assert_eq!(open_frames(&guest), 0);
let reported = DIVERGENCES.with(std::cell::Cell::get);
kernel.set(USR1 | USR2, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), None, "given up at the next entry, quietly");
assert_eq!(DIVERGENCES.with(std::cell::Cell::get), reported);
let mut guest = in_handler(&kernel, reverie::BackendCapabilities::PTRACE);
record_sigreturn_report(
&mut guest.thread,
reverie::SigreturnReport::new(
tid,
0x7fff_0000_0000,
reverie::SigreturnFrame::Readable { mask: USR2 },
),
);
kernel.set(USR2, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(blocked(&guest), Some(USR2));
let verify_pending = |guest: &ShadowGuest| {
guest
.thread
.signal_shadow
.as_ref()
.is_some_and(|shadow| shadow.thread.verify_at_entry)
};
assert!(!verify_pending(&guest), "checked once");
}
#[test]
fn where_returns_are_reported_none_is_inferred_and_a_mismatch_fails_closed() {
let kernel = Kernel::default();
let _seam = kernel.install();
for (backend, inferred) in [
(reverie::BackendCapabilities::PTRACE, false),
(reverie::BackendCapabilities::E9PATCH, true),
] {
let mut guest = in_handler(&kernel, backend);
kernel.set(USR1 | USR2, 0, USR1);
at_syscall_entry(&mut guest);
assert_eq!(open_frames(&guest), 1, "{backend:?}");
let reported = DIVERGENCES.with(std::cell::Cell::get);
kernel.set(0, 0, USR1);
at_syscall_entry(&mut guest);
if inferred {
assert_eq!(blocked(&guest), Some(0), "the return is inferred");
assert_eq!(open_frames(&guest), 0);
} else {
assert_eq!(blocked(&guest), None, "the copy is given up");
}
assert_eq!(
DIVERGENCES.with(std::cell::Cell::get),
reported,
"{backend:?}"
);
}
}
#[test]
fn a_caught_realtime_handler_is_followed_until_one_is_passed_on_unreported() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let (pid, tid) = (guest.pid().as_raw(), guest.tid().as_raw());
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
let reported = DIVERGENCES.with(std::cell::Cell::get);
kernel.set(0, 0, 1 << (40 - 1));
record_rt_sigaction(&mut guest, 40, Some(action), None, &Ok(0));
assert!(
guest.thread.signal_shadow.is_some(),
"installing a caught realtime handler keeps the copy"
);
note_unreported(pid, tid, 40);
at_syscall_entry(&mut guest);
assert!(guest.thread.signal_shadow.is_none());
assert_eq!(DIVERGENCES.with(std::cell::Cell::get), reported);
}
#[test]
fn a_siblings_note_makes_checks_compare_only_the_mask() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = seeded(&kernel, 0);
let sibling = guest.tid().as_raw();
guest.thread.signal_shadow.as_mut().unwrap().thread.blocked = 0;
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000 | libc::SA_RESETHAND) as u64,
restorer: 0x7000,
mask: 0,
};
kernel.set(0, 0, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(action), None, &Ok(0));
note_unreported(guest.pid().as_raw(), sibling, libc::SIGUSR1);
assert!(unreported_elsewhere(sibling + 1));
assert!(
!unreported_elsewhere(sibling),
"a thread's own note is not a sibling's"
);
}
#[test]
fn notes_of_threads_that_are_gone_are_dropped() {
note_unreported(1, i32::MAX - 1, libc::SIGUSR1);
assert!(!unreported_elsewhere(1));
assert!(!unreported_pending());
}
#[test]
fn nothing_is_seeded_without_serialized_threads() {
let kernel = Kernel::default();
let _seam = kernel.install();
let ptrace = Config {
sequentialize_threads: true,
backend: reverie::BackendCapabilities::PTRACE,
..Config::default()
};
assert!(ptrace.signal_state_copy);
for config in [
Config {
sequentialize_threads: false,
..ptrace.clone()
},
Config {
signal_state_copy: false,
..ptrace.clone()
},
] {
let thread = ThreadState::new(DetPid::from_raw(1), &config, ());
let mut guest = ShadowGuest {
config,
thread,
delivery: DeliveryScript::default(),
};
at_exec(&mut guest);
assert!(guest.thread.signal_shadow.is_none());
}
}
#[test]
fn nothing_is_seeded_where_the_kernel_state_is_not_the_guests() {
let kernel = Kernel::default();
let _seam = kernel.install();
let config = Config {
sequentialize_threads: true,
backend: reverie::BackendCapabilities::KVM,
..Config::default()
};
let thread = ThreadState::new(DetPid::from_raw(1), &config, ());
let mut guest = ShadowGuest {
config,
thread,
delivery: DeliveryScript::default(),
};
at_exec(&mut guest);
assert!(guest.thread.signal_shadow.is_none());
}
fn catching(kernel: &Kernel, answer: reverie::SignalDeliveryOutcome) -> ShadowGuest {
let int = sigbit(libc::SIGINT);
let mut guest = seeded(kernel, int);
let action = KernelSigaction {
handler: 0x4000,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: USR2,
};
kernel.set(int, 0, USR1);
record_rt_sigaction(&mut guest, libc::SIGUSR1, Some(action), None, &Ok(0));
assert!(guest.thread.signal_shadow.is_some());
guest.delivery.answer = Some(answer);
guest
}
fn fault_siginfo(signal: i32) -> [u8; reverie::SIGNAL_INFO_SIZE] {
let mut info = [0u8; reverie::SIGNAL_INFO_SIZE];
info[0..4].copy_from_slice(&signal.to_ne_bytes());
info[8..12].copy_from_slice(&1i32.to_ne_bytes());
info
}
fn check(guest: &mut ShadowGuest, signal: i32) {
futures::executor::block_on(check_and_record_delivery(guest, signal));
}
#[test]
fn a_checked_delivery_is_built_from_the_copy_and_recorded_as_unchecked() {
let kernel = Kernel::default();
let _seam = kernel.install();
let int = sigbit(libc::SIGINT);
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let mut unchecked = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let interruption = reverie::Interruption::Return {
syscall: libc::SYS_read,
result: -514,
};
guest.thread.delivery_interruption = Some(interruption);
guest.delivery.orig_rax = Some(libc::SYS_read);
check(&mut guest, libc::SIGUSR1);
record_delivery(&mut unchecked, libc::SIGUSR1);
let asked = guest.delivery.asked.clone();
assert_eq!(asked.len(), 1);
let d = asked[0];
assert_eq!(d.signal, libc::SIGUSR1);
assert_eq!(d.action.handler, 0x4000);
assert_eq!(d.action.mask, USR2);
assert_eq!((d.frame_mask, d.current_mask), (int, int));
assert_eq!(d.handler_mask, int | USR2 | USR1);
assert_eq!(d.unchecked_mask, reserved());
assert_eq!((d.unchecked_frame_mask, d.unchecked_current_mask), (0, 0));
assert_eq!(d.interruption, interruption);
assert_eq!(guest.thread.delivery_counters.approved, 1);
assert_eq!(
guest.thread.delivery_counters.held, 0,
"the backend does not say the signal was held"
);
assert_eq!(
guest
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone()),
unchecked
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone()),
);
assert_eq!(
guest.thread.delivery_interruption,
Some(reverie::Interruption::AfterFrame),
"the next delivery at this exit follows this frame"
);
}
#[test]
fn a_delivery_inside_a_temporary_mask_wait_saves_the_mask_from_before_it() {
let kernel = Kernel::default();
let _seam = kernel.install();
let int = sigbit(libc::SIGINT);
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let shadow = guest.thread.signal_shadow.as_mut().unwrap();
shadow.thread.blocked = int | USR1;
shadow.thread.interrupted_under_temporary_mask(0);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
guest.delivery.orig_rax = Some(-1);
kernel.set(0, 0, USR1);
check(&mut guest, libc::SIGUSR1);
let d = guest.delivery.asked[0];
assert_eq!((d.frame_mask, d.current_mask), (int | USR1, 0));
assert_eq!(d.handler_mask, USR2 | USR1);
}
#[test]
fn a_mismatch_is_a_divergence_that_drops_the_copy() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mismatch = reverie::SignalDeliveryMismatch {
field: reverie::SignalDeliveryField::FrameMask,
expected: 1,
actual: 2,
};
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Mismatch(mismatch));
guest.delivery.orig_rax = Some(-1);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
let before = DIVERGENCES.with(Cell::get);
check(&mut guest, libc::SIGUSR1);
assert_eq!(DIVERGENCES.with(Cell::get), before + 1);
assert!(guest.thread.signal_shadow.is_none());
assert!(guest.thread.signal_shadow_lost);
assert_eq!(guest.thread.delivery_counters.mismatched, 1);
}
#[test]
#[should_panic(expected = "HERMIT_INTERNAL_FAILURE class=signal-delivery-check")]
fn a_mismatch_ends_a_strict_run() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mismatch = reverie::SignalDeliveryMismatch {
field: reverie::SignalDeliveryField::InterruptedResult,
expected: 1,
actual: 2,
};
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Mismatch(mismatch));
guest.config.signal_delivery_check_fatal = true;
guest.delivery.orig_rax = Some(-1);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
check(&mut guest, libc::SIGUSR1);
}
#[test]
fn an_unavailable_check_is_counted_and_an_undelivered_signal_is_not_recorded() {
let kernel = Kernel::default();
let _seam = kernel.install();
let unavailable = reverie::SignalDeliveryOutcome::Unavailable;
let mut guest = catching(
&kernel,
unavailable(reverie::SignalDeliveryUnavailable::TracerFiltered),
);
let mut unchecked = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
guest.delivery.orig_rax = Some(-1);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
check(&mut guest, libc::SIGUSR1);
record_delivery(&mut unchecked, libc::SIGUSR1);
assert_eq!(
guest
.thread
.delivery_counters
.skipped
.get("tracer filtered"),
Some(&1)
);
assert_eq!(
guest
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone()),
unchecked
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone()),
);
assert_eq!(
guest.thread.delivery_interruption,
Some(reverie::Interruption::AfterFrame)
);
for (reason, name) in [
(
reverie::SignalDeliveryUnavailable::BlockedAtResume,
"blocked at resume",
),
(
reverie::SignalDeliveryUnavailable::NotADeliveryStop,
"not a delivery stop",
),
] {
let mut undelivered = catching(&kernel, unavailable(reason));
undelivered.delivery.orig_rax = Some(-1);
undelivered.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
let before = undelivered
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone());
check(&mut undelivered, libc::SIGUSR1);
assert_eq!(
undelivered.thread.delivery_counters.skipped.get(name),
Some(&1)
);
assert_eq!(
undelivered
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone()),
before,
"nothing is recorded for a signal the kernel does not deliver ({name})"
);
assert_eq!(
undelivered.thread.delivery_interruption,
Some(reverie::Interruption::NotInSyscall),
"no frame follows an undelivered signal ({name})"
);
}
}
#[test]
fn after_frame_holds_only_at_the_handlers_first_instruction() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
guest.delivery.orig_rax = Some(-1);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
check(&mut guest, libc::SIGUSR1);
assert_eq!(guest.thread.delivery_frame_handler, 0x4000);
let int = sigbit(libc::SIGINT);
kernel.set(int | USR2 | USR1, 0, USR1);
guest.delivery.rip = 0x4000;
check(&mut guest, libc::SIGUSR1);
assert_eq!(
guest.delivery.asked[1].interruption,
reverie::Interruption::AfterFrame
);
guest.delivery.rip = 0x5123;
check(&mut guest, libc::SIGUSR1);
assert_eq!(
guest.delivery.asked[2].interruption,
reverie::Interruption::NotInSyscall
);
guest.delivery.orig_rax = Some(libc::SYS_tgkill);
check(&mut guest, libc::SIGUSR1);
assert_eq!(
guest.delivery.asked[3].interruption,
reverie::Interruption::KernelRun {
syscall: libc::SYS_tgkill
}
);
assert_eq!(
guest.thread.delivery_counters.interruption_from_registers,
2
);
}
#[test]
fn a_forced_signal_the_copy_blocks_gives_the_copy_up_unchecked() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let segv = sigbit(libc::SIGSEGV);
let action = KernelSigaction {
handler: 0x4100,
flags: (libc::SA_SIGINFO | 0x0400_0000) as u64,
restorer: 0x7000,
mask: 0,
};
kernel.set(sigbit(libc::SIGINT), 0, USR1 | segv);
record_rt_sigaction(&mut guest, libc::SIGSEGV, Some(action), None, &Ok(0));
guest.thread.signal_shadow.as_mut().unwrap().thread.blocked |= segv;
let before = DIVERGENCES.with(Cell::get);
let mut raised = fault_siginfo(libc::SIGSEGV);
raised[8..12].copy_from_slice(&libc::SI_TKILL.to_ne_bytes());
guest.delivery.signal_info = Some(raised);
check(&mut guest, libc::SIGSEGV);
assert!(guest.delivery.asked.is_empty());
assert!(guest.thread.signal_shadow.is_none());
assert!(!guest.thread.signal_shadow_lost, "given up quietly");
assert_eq!(DIVERGENCES.with(Cell::get), before);
assert_eq!(
guest
.thread
.delivery_counters
.skipped
.get("forced while blocked"),
Some(&1)
);
}
#[test]
fn a_forced_signal_the_copy_ignores_gives_the_copy_up_unchecked() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let segv = sigbit(libc::SIGSEGV);
let ignore = KernelSigaction {
handler: 1,
flags: 0x0400_0000,
restorer: 0x7000,
mask: 0,
};
kernel.set(sigbit(libc::SIGINT), segv, USR1);
record_rt_sigaction(&mut guest, libc::SIGSEGV, Some(ignore), None, &Ok(0));
assert!(guest.thread.signal_shadow.is_some());
let before = DIVERGENCES.with(Cell::get);
guest.delivery.signal_info = Some(fault_siginfo(libc::SIGSEGV));
check(&mut guest, libc::SIGSEGV);
assert!(guest.delivery.asked.is_empty());
assert!(guest.thread.signal_shadow.is_none());
assert!(!guest.thread.signal_shadow_lost, "given up quietly");
assert_eq!(DIVERGENCES.with(Cell::get), before);
assert_eq!(
guest
.thread
.delivery_counters
.skipped
.get("forced while ignored"),
Some(&1)
);
let mut sent = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
kernel.set(sigbit(libc::SIGINT), segv, USR1);
record_rt_sigaction(&mut sent, libc::SIGSEGV, Some(ignore), None, &Ok(0));
let mut info = [0u8; reverie::SIGNAL_INFO_SIZE];
info[0..4].copy_from_slice(&libc::SIGSEGV.to_ne_bytes());
info[8..12].copy_from_slice(&libc::SI_USER.to_ne_bytes());
sent.delivery.signal_info = Some(info);
check(&mut sent, libc::SIGSEGV);
assert!(sent.thread.signal_shadow.is_some(), "kept");
assert_eq!(
sent.thread.delivery_counters.skipped.get("not caught"),
Some(&1)
);
}
#[test]
fn a_forced_bit_in_only_one_mask_is_exempt_in_that_mask_only() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let mut unchecked = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let trap = sigbit(libc::SIGTRAP);
for g in [&mut guest, &mut unchecked] {
let shadow = g.thread.signal_shadow.as_mut().unwrap();
shadow.thread.blocked |= trap;
shadow.thread.interrupted_under_temporary_mask(0);
g.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
g.delivery.orig_rax = Some(-1);
}
kernel.set(0, 0, USR1);
check(&mut guest, libc::SIGUSR1);
record_delivery(&mut unchecked, libc::SIGUSR1);
let d = guest.delivery.asked[0];
assert_eq!(
d.frame_mask & trap,
trap,
"the frame's mask holds the forced bit"
);
assert_eq!(d.current_mask & trap, 0, "the wait's mask does not");
assert_eq!(d.unchecked_mask, reserved());
assert_eq!(
(d.unchecked_frame_mask, d.unchecked_current_mask),
(trap, 0),
"exempt in the frame's comparison only"
);
assert_eq!(guest.thread.delivery_counters.approved, 1);
assert!(guest.thread.delivery_counters.skipped.is_empty());
assert_eq!(
guest
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone()),
unchecked
.thread
.signal_shadow
.as_ref()
.map(|shadow| shadow.thread.clone()),
);
}
#[test]
fn only_blocked_forced_signals_are_left_unchecked() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
let trap = sigbit(libc::SIGTRAP);
guest.thread.signal_shadow.as_mut().unwrap().thread.blocked |= trap;
guest.delivery.orig_rax = Some(-1);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
check(&mut guest, libc::SIGUSR1);
let d = guest.delivery.asked[0];
assert_eq!(d.unchecked_mask, reserved());
assert_eq!(
(d.unchecked_frame_mask, d.unchecked_current_mask),
(trap, trap)
);
}
#[test]
fn an_approval_at_a_held_report_is_counted_as_held() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
guest.delivery.report_path = Some(reverie::SignalReportPath::Held);
guest.delivery.orig_rax = Some(-1);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
check(&mut guest, libc::SIGUSR1);
let counters = &guest.thread.delivery_counters;
assert_eq!((counters.approved, counters.held), (1, 1));
let mut refused = catching(
&kernel,
reverie::SignalDeliveryOutcome::Unavailable(
reverie::SignalDeliveryUnavailable::TracerFiltered,
),
);
refused.delivery.report_path = Some(reverie::SignalReportPath::Held);
refused.delivery.orig_rax = Some(-1);
refused.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
check(&mut refused, libc::SIGUSR1);
let counters = &refused.thread.delivery_counters;
assert_eq!(
(counters.approved, counters.held),
(0, 0),
"only an approval counts"
);
}
#[test]
fn unreported_signals_are_counted_by_reason() {
let mut counters = DeliveryCounters::default();
let dettid = crate::types::DetTid::from_raw(7);
let count = |counters: &mut DeliveryCounters, reason| {
counters.count_unreported(dettid, reason);
};
count(
&mut counters,
reverie::UnreportedSignalReason::HeldRestorePending,
);
count(
&mut counters,
reverie::UnreportedSignalReason::HeldRestorePending,
);
count(
&mut counters,
reverie::UnreportedSignalReason::DuringSyscallSkip,
);
assert_eq!(counters.owner, Some(dettid));
assert_eq!(
counters.unreported.into_iter().collect::<Vec<_>>(),
vec![("during a syscall skip", 1), ("held, restore pending", 2)]
);
}
#[test]
fn uncaught_signals_and_threads_without_a_copy_are_not_checked() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
check(&mut guest, libc::SIGUSR2);
assert!(guest.delivery.asked.is_empty());
assert_eq!(
guest.thread.delivery_counters.skipped.get("not caught"),
Some(&1)
);
guest.thread.signal_shadow = None;
check(&mut guest, libc::SIGUSR1);
assert!(guest.delivery.asked.is_empty());
assert_eq!(
guest.thread.delivery_counters.skipped.get("no copy"),
Some(&1)
);
}
#[test]
fn a_copy_given_up_by_the_deliverys_reconciliation_is_counted_apart() {
let kernel = Kernel::default();
let _seam = kernel.install();
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
guest.delivery.orig_rax = Some(-1);
guest.thread.delivery_interruption = Some(reverie::Interruption::NotInSyscall);
check(&mut guest, libc::SIGUSR1);
assert_eq!(guest.thread.delivery_counters.approved, 1);
kernel.set(sigbit(libc::SIGINT) | sigbit(libc::SIGHUP), 0, USR1);
check(&mut guest, libc::SIGUSR1);
assert!(guest.thread.signal_shadow.is_none());
assert_eq!(guest.delivery.asked.len(), 1);
assert_eq!(
guest
.thread
.delivery_counters
.skipped
.get("copy given up at this delivery"),
Some(&1)
);
assert_eq!(guest.thread.delivery_counters.skipped.get("no copy"), None);
}
#[test]
fn the_interruption_is_the_record_where_the_registers_agree_on_the_syscall() {
let kernel = Kernel::default();
let _seam = kernel.install();
let read = reverie::Interruption::Return {
syscall: libc::SYS_read,
result: -512,
};
let cases = [
(Some(read), libc::SYS_read, false, read, false),
(
Some(read),
-1,
false,
reverie::Interruption::NotInSyscall,
true,
),
(Some(read), libc::SYS_write, false, read, false),
(
Some(read),
1000,
false,
reverie::Interruption::KernelRun { syscall: 1000 },
true,
),
(
Some(read),
-5,
false,
reverie::Interruption::KernelRun { syscall: -5 },
true,
),
(
None,
libc::SYS_read,
false,
reverie::Interruption::KernelRun {
syscall: libc::SYS_read,
},
true,
),
(None, -1, false, reverie::Interruption::NotInSyscall, true),
(
Some(read),
libc::SYS_write,
true,
reverie::Interruption::KernelRun {
syscall: libc::SYS_write,
},
true,
),
(
Some(reverie::Interruption::NotInSyscall),
libc::SYS_read,
false,
reverie::Interruption::NotInSyscall,
false,
),
(
Some(reverie::Interruption::NotInSyscall),
1000,
false,
reverie::Interruption::KernelRun { syscall: 1000 },
true,
),
(
Some(reverie::Interruption::NotInSyscall),
-1,
false,
reverie::Interruption::NotInSyscall,
false,
),
];
for (record, orig, passthru, expected, from_registers) in cases {
let mut guest = catching(&kernel, reverie::SignalDeliveryOutcome::Accepted);
guest.config.passthru_opt = passthru;
guest.thread.delivery_interruption = record;
guest.delivery.orig_rax = Some(orig);
check(&mut guest, libc::SIGUSR1);
assert_eq!(
guest.delivery.asked[0].interruption, expected,
"record {record:?}, orig_rax {orig}, passthru {passthru}"
);
assert_eq!(
guest.thread.delivery_counters.interruption_from_registers,
u64::from(from_registers),
"record {record:?}, orig_rax {orig}, passthru {passthru}"
);
}
}
}