use std::time::Duration;
use detcore_model::bundled_signal_facts;
use detcore_model::schedule::SigWrapper;
use nix::sys::signal::Signal;
use reverie::Errno;
use reverie::Error;
use reverie::Guest;
use reverie::Stack;
use reverie::syscalls;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::Sysno;
use reverie::syscalls::Timespec;
use tracing::info;
use crate::Detcore;
use crate::fd::FdType;
use crate::record_or_replay::RecordOrReplay;
use crate::resources::InGuestSleepSigalrm;
use crate::resources::Permission;
use crate::resources::ResourceID;
use crate::resources::Resources;
use crate::resources::SigalrmSleepDisposition;
use crate::scheduler::HostTimedSignalScope;
use crate::scheduler::OwnProcessSignalInputs;
use crate::scheduler::SiblingSignalState;
use crate::scheduler::discarded_at_send::DiscardToken;
use crate::scheduler::discarded_at_send::DiscardedSignalAnswer;
use crate::scheduler::discarded_at_send::DiscardedSignalControl;
use crate::scheduler::discarded_at_send::QueueId;
use crate::scheduler::pid_namespaces::GuestPidAnswer;
use crate::scheduler::signal_lists::KernelSiginfo;
use crate::syscalls::helpers::REAL_TIME_SIGNALS;
use crate::syscalls::helpers::act_on_pending_real_time;
use crate::syscalls::helpers::observe_under_mask;
use crate::syscalls::helpers::pending_real_time_among;
use crate::syscalls::helpers::retry_nonblocking_syscall_with_timeout;
use crate::syscalls::helpers::unblocked_by;
use crate::syscalls::threads::KERNEL_SIGSET_SIZE;
use crate::syscalls::threads::KernelSigaction;
use crate::syscalls::threads::KernelSigset;
use crate::syscalls::threads::kernel_sigset_bit;
use crate::syscalls::threads::read_thread_wait_signal_state;
use crate::tool_global::ResumeStatus;
use crate::tool_global::SigalrmControl;
use crate::tool_global::alarm_remaining;
use crate::tool_global::commit_sigkill;
use crate::tool_global::host_timed_signals;
use crate::tool_global::names_a_retired_exited_leader;
use crate::tool_global::notify_signal_pending;
use crate::tool_global::own_process_signal_inputs;
use crate::tool_global::record_host_timed_signals;
use crate::tool_global::refuse_sigalrm;
use crate::tool_global::register_alarm;
use crate::tool_global::registered_process_of;
use crate::tool_global::reserve_sigkill;
use crate::tool_global::reserve_sigkill_group;
use crate::tool_global::resolve_kill_targets_and_exit;
use crate::tool_global::resource_request;
use crate::tool_global::set_sigchld_disposition;
use crate::tool_global::set_sigtimedwait_set;
use crate::tool_global::sigalrm_refuses;
use crate::tool_global::signal_target_process;
use crate::tool_global::thread_observe_time;
use crate::types::DetPid;
use crate::types::DetTid;
use crate::types::LogicalTime;
const APPROPRIATED_SIGNALS: [(i32, &str); 2] = [
(
libc::SIGTRAP,
"ptrace consumes every SIGTRAP (syscall/seccomp stops, breakpoints)",
),
(
libc::SIGSTKFLT,
"reverie uses it as PERF_EVENT_SIGNAL, the PMU preemption timer",
),
];
fn appropriated_reason(signum: i32, handler: u64) -> Option<&'static str> {
if handler <= 1 {
return None;
}
APPROPRIATED_SIGNALS
.iter()
.find(|(s, _)| *s == signum)
.map(|(_, why)| *why)
}
fn warn_appropriated_signal(signum: i32, handler: u64) {
if let Some(why) = appropriated_reason(signum, handler) {
tracing::warn!(
"HERMIT_APPROPRIATED_SIGNAL signum={signum} effect=handler-installed-but-never-invoked reason={why}"
);
}
}
fn validate_kernel_sigset_size(sigsetsize: usize) -> Result<(), Errno> {
if sigsetsize == KERNEL_SIGSET_SIZE {
Ok(())
} else {
Err(Errno::EINVAL)
}
}
pub(crate) fn kernel_installed_signal_mask(mask: KernelSigset) -> KernelSigset {
let unblockable = (1_u64 << (libc::SIGKILL - 1)) | (1_u64 << (libc::SIGSTOP - 1));
mask & !unblockable
}
fn without_perf_event_signal(mask: KernelSigset) -> KernelSigset {
let bit = (reverie::PERF_EVENT_SIGNAL as u32) - 1;
mask & !(1_u64 << bit)
}
pub(crate) fn restart_if_first_probe_not_run<V>(result: Result<V, Error>) -> Result<V, Error> {
match result {
Err(Error::Errno(Errno::ERESTARTSYS)) => Err(Errno::ERESTARTNOINTR.into()),
other => other,
}
}
pub(super) const STACK_RED_ZONE: usize = 128;
const SCRATCH_CELLS_SIZE: usize = 2 * std::mem::size_of::<u64>();
pub(super) async fn read_kernel_sigset<G, T>(
guest: &mut G,
address: Addr<'_, libc::sigset_t>,
) -> Result<KernelSigset, Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let validation = syscalls::RtSigprocmask::new()
.with_how(-1)
.with_set(Some(address))
.with_oldset(None)
.with_sigsetsize(KERNEL_SIGSET_SIZE);
match guest.inject(validation).await {
Err(Errno::EINVAL) => {}
Err(errno) => return Err(errno.into()),
Ok(_) => {
return Err(Errno::EIO.into());
}
}
Ok(guest.memory().read_value(address.cast())?)
}
pub(crate) async fn sigkill_names_an_exited_leader<G, T>(guest: &mut G, tid: DetTid) -> bool
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
names_a_retired_exited_leader(guest, tid).await
}
async fn virtual_sigalrm_state<G, T>(guest: &mut G) -> Result<(bool, bool), Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let state = read_sigalrm_sleep_state(guest).await?;
Ok((
state.disposition == SigalrmSleepDisposition::Handled,
state.blocked,
))
}
async fn read_sigalrm_sleep_state<G, T>(guest: &mut G) -> Result<InGuestSleepSigalrm, Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let mut stack = guest.stack().await;
let action = stack.reserve::<KernelSigaction>();
let mask = stack.reserve::<KernelSigset>();
let _stack_guard = stack.commit()?;
guest
.inject(
syscalls::RtSigaction::new()
.with_signum(libc::SIGALRM)
.with_action(None)
.with_old_action(Some(action.cast()))
.with_sigsetsize(KERNEL_SIGSET_SIZE),
)
.await?;
guest
.inject(
syscalls::RtSigprocmask::new()
.with_how(libc::SIG_BLOCK)
.with_set(None)
.with_oldset(Some(mask.cast()))
.with_sigsetsize(KERNEL_SIGSET_SIZE),
)
.await?;
let action: KernelSigaction = guest.memory().read_value(action)?;
let mask: KernelSigset = guest.memory().read_value(mask)?;
let disposition = if action.handler == libc::SIG_DFL as u64 {
SigalrmSleepDisposition::Default
} else if action.handler == libc::SIG_IGN as u64 {
SigalrmSleepDisposition::Ignored
} else {
SigalrmSleepDisposition::Handled
};
Ok(InGuestSleepSigalrm {
disposition,
blocked: mask & kernel_sigset_bit(libc::SIGALRM) != 0,
})
}
pub(crate) async fn take_pending_signal<G, T>(guest: &mut G, signo: i32) -> Result<i64, Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let mut stack = guest.stack().await;
let set = stack.push(kernel_sigset_bit(signo));
let timeout = stack.push(Timespec {
tv_sec: 0,
tv_nsec: 0,
});
let stack_guard = stack.commit()?;
let set = unsafe { set.cast::<libc::sigset_t>().into_mut() };
let taken = guest
.inject(
syscalls::RtSigtimedwait::new()
.with_set(Some(set))
.with_info(None)
.with_timeout(Some(timeout))
.with_sigsetsize(KERNEL_SIGSET_SIZE),
)
.await;
drop(stack_guard);
Ok(taken?)
}
pub(crate) async fn claim_pending_sigchld<G, T>(guest: &mut G) -> Result<bool, Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
match guest.inject(syscalls::Getpid::new()).await {
Ok(_) => Ok(false),
Err(errno) if is_restart_errno(errno) => Ok(true),
Err(errno) => Err(errno.into()),
}
}
const CLAIM_FAULT_ENV: &str = "HERMIT_TEST_SIGCHLD_CLAIM_FAULT";
static CLAIM_FAULT_FIRED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ClaimFault {
Usr1BeforeClaim,
Usr1AfterClaim,
DropClaimed,
}
pub(crate) fn take_claim_fault(fault: ClaimFault) -> bool {
let asked = match std::env::var(CLAIM_FAULT_ENV).as_deref() {
Ok("usr1-before-claim") => ClaimFault::Usr1BeforeClaim,
Ok("usr1-after-claim") => ClaimFault::Usr1AfterClaim,
Ok("drop-claimed") => ClaimFault::DropClaimed,
_ => return false,
};
asked == fault && !CLAIM_FAULT_FIRED.swap(true, std::sync::atomic::Ordering::SeqCst)
}
fn send_claim_fault_signal<G, T>(guest: &G, fault: ClaimFault)
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if take_claim_fault(fault) {
let sent = unsafe {
libc::syscall(
libc::SYS_tgkill,
guest.pid().as_raw(),
guest.tid().as_raw(),
libc::SIGUSR1,
)
};
if sent == 0 {
tracing::warn!("claim fault hook: sent SIGUSR1 {:?}", fault);
} else {
tracing::error!(
"claim fault hook: could not send SIGUSR1 {:?}: {}",
fault,
std::io::Error::last_os_error()
);
}
}
}
fn is_restart_errno(errno: Errno) -> bool {
matches!(
errno,
Errno::ERESTARTSYS
| Errno::ERESTARTNOINTR
| Errno::ERESTARTNOHAND
| Errno::ERESTART_RESTARTBLOCK
)
}
pub(crate) async fn virtual_sigalrm_blocked<G, T>(guest: &mut G) -> Result<bool, Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let mut stack = guest.stack().await;
let mask = stack.reserve::<KernelSigset>();
let _stack_guard = stack.commit()?;
guest
.inject(
syscalls::RtSigprocmask::new()
.with_how(libc::SIG_BLOCK)
.with_set(None)
.with_oldset(Some(mask.cast()))
.with_sigsetsize(KERNEL_SIGSET_SIZE),
)
.await?;
let mask: KernelSigset = guest.memory().read_value(mask)?;
Ok(mask & kernel_sigset_bit(libc::SIGALRM) != 0)
}
async fn read_kernel_sigaction<G, T>(
guest: &mut G,
address: Addr<'_, libc::sigaction>,
) -> Result<KernelSigaction, Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let validation = syscalls::RtSigaction::new()
.with_signum(libc::SIGKILL)
.with_action(Some(address))
.with_old_action(None)
.with_sigsetsize(KERNEL_SIGSET_SIZE);
match guest.inject(validation).await {
Err(Errno::EINVAL) => {}
Err(errno) => return Err(errno.into()),
Ok(_) => return Err(Errno::EIO.into()),
}
Ok(guest.memory().read_value(address.cast())?)
}
fn timeval_to_logical_time(value: libc::timeval) -> Result<LogicalTime, Errno> {
let seconds = u64::try_from(value.tv_sec).map_err(|_| Errno::EINVAL)?;
let micros = u64::try_from(value.tv_usec).map_err(|_| Errno::EINVAL)?;
if micros >= 1_000_000 {
return Err(Errno::EINVAL);
}
let nanos = seconds
.checked_mul(1_000_000_000)
.and_then(|nanos| nanos.checked_add(micros * 1_000))
.ok_or(Errno::EINVAL)?;
Ok(LogicalTime::from_nanos(nanos))
}
fn logical_time_to_timeval(value: LogicalTime) -> libc::timeval {
libc::timeval {
tv_sec: value.as_secs() as libc::time_t,
tv_usec: value.subsec_micros() as libc::suseconds_t,
}
}
fn logical_time_to_alarm_seconds(value: LogicalTime) -> i64 {
value.as_nanos().div_ceil(1_000_000_000) as i64
}
fn linux_alarm_seconds(value: LogicalTime) -> i64 {
let ns = value.as_nanos();
let (secs, rem) = (ns / 1_000_000_000, ns % 1_000_000_000);
let round_up = (secs == 0 && rem != 0) || rem >= 500_000_000;
(secs + u64::from(round_up)) as i64
}
pub(crate) const NO_SUCH_PID: libc::pid_t = libc::pid_t::MAX;
fn sent_siginfo<T, G: Guest<Detcore<T>>>(
guest: &mut G,
call: &syscalls::Syscall,
signal: i32,
) -> Option<KernelSiginfo>
where
T: RecordOrReplay,
{
if !crate::scheduler::discarded_at_send::records(guest.config()) {
return None;
}
let code = match call {
syscalls::Syscall::RtSigqueueinfo(call) => {
return read_siginfo(guest, call.siginfo()?)
.map(|bytes| KernelSiginfo::from_user(&bytes));
}
syscalls::Syscall::RtTgsigqueueinfo(call) => {
return read_siginfo(guest, call.siginfo()?)
.map(|bytes| KernelSiginfo::from_user(&bytes));
}
syscalls::Syscall::Other(sysno, args) if *sysno == Sysno::pidfd_send_signal => {
match AddrMut::<libc::siginfo_t>::from_raw(args.arg2) {
Some(info) => {
return read_siginfo(guest, info).map(|bytes| KernelSiginfo::from_user(&bytes));
}
None => libc::SI_USER,
}
}
syscalls::Syscall::Kill(_) => libc::SI_USER,
syscalls::Syscall::Tgkill(_) | syscalls::Syscall::Tkill(_) => libc::SI_TKILL,
_ => return None,
};
let pid = guest.thread_state().detpid?.as_raw();
let uid = crate::syscalls::real_uid(guest.tid().as_raw())?;
Some(crate::scheduler::signal_lists::ordinary_siginfo(
signal, code, pid, uid,
))
}
fn read_siginfo<T, G: Guest<Detcore<T>>>(
guest: &mut G,
info: AddrMut<libc::siginfo_t>,
) -> Option<[u8; 128]>
where
T: RecordOrReplay,
{
if let Ok(bytes) = guest.memory().read_value(info.cast::<[u8; 128]>()) {
return Some(bytes);
}
use std::os::unix::fs::FileExt;
let mem = std::fs::File::open(format!("/proc/{}/mem", guest.tid().as_raw())).ok()?;
let mut bytes = [0u8; 128];
mem.read_exact_at(&mut bytes, info.as_raw() as u64).ok()?;
Some(bytes)
}
fn read_mapped_prefix<T, G: Guest<Detcore<T>>>(guest: &mut G, address: usize, len: usize) -> Vec<u8>
where
T: RecordOrReplay,
{
const PAGE: usize = 4096;
let mut bytes = Vec::with_capacity(len);
let mut mem = None;
while bytes.len() < len {
let at = address + bytes.len();
let take = (PAGE - at % PAGE).min(len - bytes.len());
let mut piece = vec![0u8; take];
let Some(remote) = AddrMut::<u8>::from_raw(at) else {
break;
};
if guest.memory().read_exact(remote, &mut piece).is_err() {
use std::os::unix::fs::FileExt;
if mem.is_none() {
mem = std::fs::File::open(format!("/proc/{}/mem", guest.tid().as_raw())).ok();
}
let Some(file) = mem.as_ref() else {
break;
};
if file.read_exact_at(&mut piece, at as u64).is_err() {
break;
}
}
bytes.extend_from_slice(&piece);
}
bytes
}
const SIGNALFD_CAPTURED: usize = 2 * 64 * SIGNALFD_RECORD;
pub(crate) fn capture_signalfd_buffer<T, G: Guest<Detcore<T>>>(
guest: &mut G,
extents: &[(usize, usize)],
limit: usize,
) -> Vec<u8>
where
T: RecordOrReplay,
{
let total: usize = extents.iter().map(|(_, len)| *len).sum();
let len = total.min(limit).min(SIGNALFD_CAPTURED);
let mut bytes = Vec::with_capacity(len);
for (address, length) in signalfd_extent_pieces(extents, len) {
let piece = read_mapped_prefix(guest, address, length);
let short = piece.len() < length;
bytes.extend_from_slice(&piece);
if short {
break;
}
}
bytes
}
fn restore_changed_bytes<T, G: Guest<Detcore<T>>>(
guest: &mut G,
info: AddrMut<libc::siginfo_t>,
before: &[u8],
) where
T: RecordOrReplay,
{
let now = read_mapped_prefix(guest, info.as_raw(), before.len());
let before = &before[..now.len()];
let mut at = 0;
while at < before.len() {
if now[at] == before[at] {
at += 1;
continue;
}
let start = at;
while at < before.len() && now[at] != before[at] {
at += 1;
}
if let Some(address) = AddrMut::<u8>::from_raw(info.as_raw() + start) {
let _ = guest.memory().write_exact(address, &before[start..at]);
}
}
}
fn deterministic_kill_target(
targets: &[DetTid],
zombie: Option<bool>,
sig: libc::c_int,
) -> Result<Option<DetTid>, Errno> {
match targets {
[] if zombie == Some(true) => Ok(None),
[] => Err(Errno::ESRCH),
[target] => Ok(Some(*target)),
[target, ..] if sig == 0 => Ok(Some(*target)),
_ => Err(Errno::ENOSYS),
}
}
fn can_forward_process_group_signal(
pid: libc::pid_t,
sig: libc::c_int,
backend_requires_pid_translation: bool,
) -> bool {
pid < -1 && sig == libc::SIGKILL && !backend_requires_pid_translation
}
fn self_sigkill_targets_current_task(
signal: libc::c_int,
target_process: Option<DetPid>,
target_thread: Option<DetTid>,
current_process: DetPid,
current_thread: DetTid,
) -> bool {
signal == libc::SIGKILL
&& (target_process.is_some() || target_thread.is_some())
&& target_process.is_none_or(|target| target == current_process)
&& target_thread.is_none_or(|target| target == current_thread)
}
impl<T: RecordOrReplay> Detcore<T> {
pub(crate) async fn in_guest_sleep_sigalrm_snapshot<G: Guest<Self>>(
&self,
guest: &mut G,
) -> Option<InGuestSleepSigalrm> {
if !self.cfg.backend.virtualizes_guest_sigalrm {
return None;
}
match read_sigalrm_sleep_state(guest).await {
Ok(state) => Some(state),
Err(error) => {
self.stop_after_in_guest_sleep_signal_loss(
guest,
format!("could not query its SIGALRM action/mask before sleeping: {error}"),
)
.await
}
}
}
pub(crate) async fn stage_in_guest_fatal_alarm<G: Guest<Self>>(&self, guest: &mut G) {
if !self.cfg.backend.virtualizes_guest_sigalrm {
self.stop_after_in_guest_sleep_signal_loss(
guest,
"received an in-guest fatal alarm on another backend".into(),
)
.await;
}
match read_sigalrm_sleep_state(guest).await {
Ok(InGuestSleepSigalrm {
disposition: SigalrmSleepDisposition::Default,
blocked: false,
}) => {}
other => {
self.stop_after_in_guest_sleep_signal_loss(
guest,
format!("its default/unblocked SIGALRM sleep snapshot changed: {other:?}"),
)
.await;
}
}
let call = syscalls::Tgkill::new()
.with_tgid(guest.pid().as_raw())
.with_tid(guest.tid().as_raw())
.with_sig(libc::SIGALRM);
if guest.inject(call).await != Ok(0) {
self.stop_after_in_guest_sleep_signal_loss(
guest,
"could not stage its default-fatal SIGALRM after a sleep wake".into(),
)
.await;
}
}
async fn stop_after_in_guest_sleep_signal_loss<G: Guest<Self>>(
&self,
guest: &mut G,
reason: String,
) -> ! {
let reason = format!(
"thread {} cannot complete its in-guest SIGALRM sleep delivery: {reason}",
guest.thread_state().dettid,
);
crate::tool_global::report_determinism_loss(guest, reason).await;
crate::guest_log::flush_unsent();
match guest
.tail_inject(
syscalls::ExitGroup::new().with_status(detcore_model::HERMIT_POLICY_REFUSAL_EXIT),
)
.await {}
}
pub async fn handle_alarm<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Alarm,
) -> Result<i64, Error> {
if guest.config().sequentialize_threads {
let remaining = register_alarm(
guest,
LogicalTime::from_secs(call.seconds() as u64),
LogicalTime::ZERO,
Signal::SIGALRM,
)
.await;
Ok(if self.cfg.recordreplay_modes {
logical_time_to_alarm_seconds(remaining.0)
} else {
linux_alarm_seconds(remaining.0)
})
} else {
info!(
"[dtid {}] Running without scheduler, so letting alarm call through...",
guest.thread_state().dettid
);
Ok(guest.inject(call).await?)
}
}
pub async fn handle_setitimer<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Setitimer,
) -> Result<i64, Error> {
if !guest.config().sequentialize_threads {
info!(
"[dtid {}] Running without scheduler, so letting setitimer call through...",
guest.thread_state().dettid
);
return Ok(guest.inject(call).await?);
}
if call.which() != libc::ITIMER_REAL {
return Err(Error::Errno(Errno::ENOSYS));
}
let value = call.value().ok_or(Errno::EFAULT)?;
let timer: libc::itimerval = guest.memory().read_value(value)?;
let interval = timeval_to_logical_time(timer.it_interval)?;
let duration = timeval_to_logical_time(timer.it_value)?;
if duration.as_nanos() != 0 && interval.as_nanos() != 0 {
refuse_sigalrm(guest, SigalrmControl::ArmRecurringTimer).await?;
}
let (remaining, old_interval) =
register_alarm(guest, duration, interval, Signal::SIGALRM).await;
if let Some(old_value) = call.ovalue() {
let old_timer = libc::itimerval {
it_interval: logical_time_to_timeval(old_interval),
it_value: logical_time_to_timeval(remaining),
};
guest.memory().write_value(old_value, &old_timer)?;
}
Ok(0)
}
pub async fn handle_getitimer<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Getitimer,
) -> Result<i64, Error> {
if !guest.config().sequentialize_threads {
info!(
"[dtid {}] Running without scheduler, so letting getitimer call through...",
guest.thread_state().dettid
);
return Ok(guest.inject(call).await?);
}
let snapshot = match call.which() {
libc::ITIMER_REAL => alarm_remaining(guest).await,
libc::ITIMER_VIRTUAL | libc::ITIMER_PROF => {
crate::scheduler::real_timer::ItimerSnapshot::default()
}
_ => return Err(Errno::EINVAL.into()),
};
let value = call.value().ok_or(Errno::EFAULT)?;
let timer = libc::itimerval {
it_interval: logical_time_to_timeval(snapshot.interval),
it_value: logical_time_to_timeval(snapshot.remaining),
};
guest.memory().write_value(value, &timer)?;
Ok(0)
}
pub async fn handle_pause<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Pause,
) -> Result<i64, Error> {
if guest.config().sequentialize_threads {
loop {
if sleep_signal(guest, SleepCheck::BeforePark, true).await? == SleepSignal::Pending
{
return Err(Errno::ERESTARTNOHAND.into());
}
let mut req = Self::sleep_request_abs(guest, LogicalTime::INDEFINITE).await;
req.fyi(crate::resources::PAUSE_FYI);
req.in_guest_sleep_sigalrm = self.in_guest_sleep_sigalrm_snapshot(guest).await;
match crate::tool_global::parked_wait_request(
guest,
req,
crate::scheduler::parked::ParkedWaitPolicy::PauseNoHandlerRestart,
)
.await
{
ResumeStatus::InGuestFatalAlarm => {
self.stage_in_guest_fatal_alarm(guest).await;
return Err(Errno::EINTR.into());
}
ResumeStatus::Normal | ResumeStatus::NothingElseCanRun => {
panic!(
"Internal violation: pause should never return from the scheduler except by interruption!"
)
}
ResumeStatus::Signaled(signals) => {
match sleep_signal(guest, SleepCheck::AfterWake(signals), true).await? {
SleepSignal::Pending | SleepSignal::Claimed => {
return Err(Errno::ERESTARTNOHAND.into());
}
SleepSignal::Held => return Err(Errno::EINTR.into()),
SleepSignal::None => {
info!(
"[dtid {}] pause woken for a signal no longer pending for it; waiting again",
guest.thread_state().dettid
);
}
}
}
}
}
} else {
info!(
"[dtid {}] Running without scheduler, so letting pause call through...",
guest.thread_state().dettid
);
Ok(guest.inject(call).await?)
}
}
pub async fn handle_rt_sigsuspend<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigsuspend,
) -> Result<i64, Error> {
validate_kernel_sigset_size(call.sigsetsize())?;
let Some(mask_addr) = call.mask() else {
return Err(Errno::EFAULT.into());
};
let temporary_mask =
restart_if_first_probe_not_run(read_kernel_sigset(guest, mask_addr).await)?;
super::signal_shadow::note_wait_mask(guest, temporary_mask);
observe_under_mask(guest, temporary_mask).await?;
let caller_mask = mask_addr.as_raw()..mask_addr.as_raw() + KERNEL_SIGSET_SIZE;
let below_red_zone = (guest.regs().await.rsp as usize).wrapping_sub(STACK_RED_ZONE);
let cells = (below_red_zone - SCRATCH_CELLS_SIZE)..below_red_zone;
let cells_start = if cells.start < caller_mask.end && caller_mask.start < cells.end {
(caller_mask.start - SCRATCH_CELLS_SIZE) & !(std::mem::align_of::<u64>() - 1)
} else {
cells.start
};
let pending_addr = Addr::<u64>::from_raw(cells_start).ok_or(Errno::EFAULT)?;
let mask_copy = AddrMut::<u64>::from_raw(cells_start + std::mem::size_of::<u64>())
.ok_or(Errno::EFAULT)?;
guest.memory().write_value(mask_copy, &temporary_mask)?;
let pending_out = AddrMut::<libc::sigset_t>::from_raw(pending_addr.as_raw())
.expect("stack address must be non-null");
let pending_call = syscalls::RtSigpending::new()
.with_set(Some(pending_out))
.with_sigsetsize(KERNEL_SIGSET_SIZE);
guest.inject_with_retry(pending_call).await?;
let pending: u64 = guest.memory().read_value(pending_addr)?;
let call = call.with_mask(Some(Addr::from_raw(mask_copy.as_raw()).expect("non-null")));
if rt_sigsuspend_never_sleeps(&self.cfg.backend) {
let result = self.record_or_replay(guest, call).await;
if result == Err(Errno::ENOSYS) && self.cfg.sequentialize_threads {
if self.cfg.max_timeslice.is_some() {
guest
.thread_state_mut()
.reset_timeslice_for_explicit_yield();
}
let request = Self::sched_yield_request(guest);
resource_request(guest, request).await;
}
return Ok(result?);
}
let installed_mask = kernel_installed_signal_mask(temporary_mask);
if pending & !temporary_mask != 0 {
self.record_or_replay_blocking_with_mask(guest, call.into(), Some(installed_mask))
.await
} else {
self.record_or_replay_rt_sigsuspend(guest, call, installed_mask)
.await
}
}
pub async fn handle_rt_sigaction<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigaction,
) -> Result<i64, Error> {
validate_kernel_sigset_size(call.sigsetsize())?;
let kernel_action = match call.action() {
Some(action) => Some(restart_if_first_probe_not_run(
read_kernel_sigaction(guest, action).await,
)?),
None => None,
};
if let Some(action) = kernel_action
&& call.signum() != reverie::PERF_EVENT_SIGNAL as i32
{
warn_appropriated_signal(call.signum(), action.handler);
}
if call.signum() == reverie::PERF_EVENT_SIGNAL as i32 {
if kernel_action.is_some_and(|action| action.handler != libc::SIG_DFL as u64) {
crate::tool_global::announce_signal_handler_not_installed(guest, call.signum())
.await;
}
if call.old_action().is_some() {
return Ok(guest
.inject(call.with_signum(libc::SIGKILL).with_action(None))
.await?);
}
return Ok(0);
}
let phase1 = self.cfg.backend.virtualizes_guest_sigalrm
&& call.signum() == libc::SIGALRM
&& kernel_action.is_some();
let was_handled = guest.thread_state().sigalrm_handled;
let to_handler = kernel_action.is_some_and(|action| {
action.handler != libc::SIG_DFL as u64 && action.handler != libc::SIG_IGN as u64
});
if phase1 {
if to_handler {
self.refuse_sigalrm_handler(guest).await?;
} else if was_handled
&& kernel_action.is_some_and(|action| action.handler == libc::SIG_DFL as u64)
{
refuse_sigalrm(guest, SigalrmControl::HandlerToDefault).await?;
}
}
let unignores = crate::scheduler::discarded_at_send::records(guest.config())
&& (1..32).contains(&call.signum())
&& kernel_action.is_some_and(|action| {
action.handler != libc::SIG_IGN as u64
&& !(action.handler == libc::SIG_DFL as u64
&& [libc::SIGCONT, libc::SIGCHLD, libc::SIGWINCH, libc::SIGURG]
.contains(&call.signum()))
})
&& match crate::syscalls::signal_shadow::copied_dispositions_for(guest, call.signum()) {
Some(copied) => copied.ignored & kernel_sigset_bit(call.signum()) != 0,
None => {
crate::syscalls::threads::read_kernel_signal_state(guest.pid(), guest.tid())
.is_ok_and(|state| state.ignored & kernel_sigset_bit(call.signum()) != 0)
}
};
let result = if let Some(kernel_action) = kernel_action {
let mut kernel_action = kernel_action;
kernel_action.mask = without_perf_event_signal(kernel_action.mask);
let mut stack = guest.stack().await;
let sanitized_action = stack.push(kernel_action);
let _stack_guard = stack.commit()?;
guest
.inject(call.with_action(Some(sanitized_action.cast())))
.await
} else {
guest.inject(call).await
};
super::signal_shadow::record_rt_sigaction(
guest,
call.signum(),
kernel_action.map(|action| KernelSigaction {
mask: without_perf_event_signal(action.mask),
..action
}),
call.old_action(),
&result,
);
if phase1 && (was_handled || (to_handler && result != Err(Errno::EPERM))) {
self.publish_virtual_sigalrm(guest).await?;
}
if call.signum() == libc::SIGCHLD
&& guest.config().sequentialize_threads
&& let Some(action) = kernel_action
&& matches!(result, Ok(_) | Err(Errno::EFAULT))
{
let dettid = guest.thread_state().dettid;
if let Some(process) = registered_process_of(guest, dettid).await {
set_sigchld_disposition(
guest,
process,
action.handler == libc::SIG_IGN as u64,
action.flags & libc::SA_NOCLDWAIT as u64 != 0,
)
.await;
}
}
if call.signum() == libc::SIGCHLD
&& guest.config().sequentialize_threads
&& matches!(result, Ok(_) | Err(Errno::EFAULT))
&& kernel_action.is_some_and(|action| {
action.handler == libc::SIG_IGN as u64 || action.handler == libc::SIG_DFL as u64
})
{
crate::tool_global::child_exit_sigchld(
guest,
crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::Flushed,
)
.await;
}
if result.is_ok()
&& kernel_action.is_some_and(|action| action.handler == libc::SIG_IGN as u64)
&& (1..=64).contains(&call.signum())
{
let bit = kernel_sigset_bit(call.signum());
let pending = pending_real_time_among(guest, bit).await;
act_on_pending_real_time(guest, pending, 0, bit).await;
}
let ignored = |handler: u64| {
handler == libc::SIG_IGN as u64
|| (handler == libc::SIG_DFL as u64
&& [libc::SIGCONT, libc::SIGCHLD, libc::SIGWINCH, libc::SIGURG]
.contains(&call.signum()))
};
if (result.is_ok() || matches!(result, Err(Errno::EFAULT)))
&& kernel_action.is_some_and(|action| ignored(action.handler))
&& (1..32).contains(&call.signum())
&& crate::scheduler::timer_copies_recorded()
{
crate::tool_global::forget_thread_timer_copies(guest, call.signum()).await;
}
if crate::scheduler::discarded_at_send::records(guest.config())
&& (result.is_ok() || matches!(result, Err(Errno::EFAULT)))
&& (1..32).contains(&call.signum())
&& let Some(action) = kernel_action
{
crate::tool_global::discarded_signal(
guest,
DiscardedSignalControl::Handler {
signal: call.signum(),
caught: action.handler != libc::SIG_IGN as u64
&& action.handler != libc::SIG_DFL as u64,
mask: action.mask,
nodefer: action.flags & libc::SA_NODEFER as u64 != 0,
},
)
.await;
}
if crate::scheduler::discarded_at_send::records(guest.config())
&& (result.is_ok() || matches!(result, Err(Errno::EFAULT)))
&& (1..32).contains(&call.signum())
{
let signal = call.signum();
if kernel_action.is_some_and(|action| ignored(action.handler)) {
crate::tool_global::discarded_signal(
guest,
DiscardedSignalControl::Flushed { signal },
)
.await;
} else if unignores {
crate::tool_global::discarded_signal(
guest,
DiscardedSignalControl::Unignored { signal },
)
.await;
}
}
Ok(result?)
}
async fn refuse_sigalrm_handler<G: Guest<Self>>(&self, guest: &mut G) -> Result<(), Error> {
if !guest.config().sequentialize_threads {
return Err(Errno::EPERM.into());
}
let holds_signalfd = guest
.thread_state()
.file_metadata
.lock()
.expect("file metadata mutex poisoned")
.file_handles
.values()
.any(|fd| fd.ty() == FdType::Signalfd)
|| crate::sigalrm_phase1::process_holds_signalfd(guest.pid().as_raw());
if holds_signalfd {
return Err(Errno::EPERM.into());
}
Ok(refuse_sigalrm(guest, SigalrmControl::InstallHandler).await?)
}
async fn publish_virtual_sigalrm<G: Guest<Self>>(&self, guest: &mut G) -> Result<(), Error> {
let (handled, blocked) = virtual_sigalrm_state(guest).await?;
sigalrm_refuses(guest, SigalrmControl::Publish { handled, blocked }).await;
guest.thread_state_mut().sigalrm_handled = handled;
guest.thread_state_mut().sigalrm_blocked_published = blocked;
Ok(())
}
async fn publish_virtual_sigalrm_blocked<G: Guest<Self>>(
&self,
guest: &mut G,
) -> Result<(), Error> {
let blocked = virtual_sigalrm_blocked(guest).await?;
sigalrm_refuses(guest, SigalrmControl::PublishBlocked(blocked)).await;
guest.thread_state_mut().sigalrm_blocked_published = blocked;
Ok(())
}
pub async fn handle_rt_sigprocmask<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigprocmask,
) -> Result<i64, Error> {
validate_kernel_sigset_size(call.sigsetsize())?;
let (result, validated_set) = self.rt_sigprocmask_inner(guest, call).await;
let set_not_read = matches!(validated_set, ValidatedSet::NotRun);
if guest.thread_state().signal_shadow.is_some() {
use super::signal_shadow::SetInput;
let errno_result = match &result {
Ok(value) => Some(Ok(*value)),
Err(Error::Errno(errno)) => Some(Err(*errno)),
Err(_) => {
super::signal_shadow::give_up(
guest,
"rt_sigprocmask failed without an errno, so its effect is unknown",
);
None
}
};
let set = match (call.set(), validated_set) {
(None, _) => SetInput::None,
(Some(_), ValidatedSet::Validated(set)) => {
SetInput::Validated(without_perf_event_signal(set))
}
(Some(_), ValidatedSet::NotRun) => SetInput::NotRun,
(Some(set), ValidatedSet::NotValidated) => SetInput::Unvalidated(
(result.is_ok()
&& !call.oldset().is_some_and(|old| {
old.as_raw().abs_diff(set.as_raw()) < KERNEL_SIGSET_SIZE
}))
.then(|| {
guest
.memory()
.read_value::<_, KernelSigset>(set.cast::<KernelSigset>())
.ok()
})
.flatten()
.map(without_perf_event_signal),
),
};
if let Some(errno_result) = errno_result {
super::signal_shadow::record_rt_sigprocmask(
guest,
call.how(),
set,
call.oldset(),
&errno_result,
);
}
}
if set_not_read && matches!(result, Err(Error::Errno(Errno::ERESTARTNOINTR))) {
return result;
}
if call.how() != libc::SIG_BLOCK && call.set().is_some() {
let pending = pending_real_time_among(guest, REAL_TIME_SIGNALS).await;
if pending != 0 {
let (observable, discarded) =
match read_thread_wait_signal_state(guest.pid(), guest.tid()) {
Ok(state) => unblocked_by(&state, state.blocked),
Err(_) => (REAL_TIME_SIGNALS, 0),
};
act_on_pending_real_time(guest, pending, observable, discarded).await;
}
}
if self.cfg.backend.virtualizes_guest_sigalrm && guest.thread_state().sigalrm_handled {
self.publish_virtual_sigalrm_blocked(guest).await?;
}
result
}
async fn rt_sigprocmask_inner<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigprocmask,
) -> (Result<i64, Error>, ValidatedSet) {
if call.how() != libc::SIG_BLOCK && call.how() != libc::SIG_SETMASK {
let result = guest.inject_with_retry(call).await;
(result.map_err(Into::into), ValidatedSet::NotValidated)
} else if let Some(set) = call.set() {
let set_mask =
match restart_if_first_probe_not_run(read_kernel_sigset(guest, set).await) {
Ok(set_mask) => set_mask,
Err(error) => return (Err(error), ValidatedSet::NotRun),
};
let mut stack = guest.stack().await;
let new_set = stack.push(without_perf_event_signal(set_mask));
let _stack_guard = match stack.commit() {
Ok(guard) => guard,
Err(error) => return (Err(error.into()), ValidatedSet::NotRun),
};
let modified_call = syscalls::RtSigprocmask::new()
.with_how(call.how())
.with_set(Some(new_set.cast()))
.with_oldset(call.oldset())
.with_sigsetsize(call.sigsetsize());
let result = guest.inject_with_retry(modified_call).await;
(
result.map_err(Into::into),
ValidatedSet::Validated(set_mask),
)
} else {
let result = guest.inject_with_retry(call).await;
(result.map_err(Into::into), ValidatedSet::NotValidated)
}
}
pub async fn handle_rt_sigtimedwait<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigtimedwait,
) -> Result<i64, Error> {
validate_kernel_sigset_size(call.sigsetsize())?;
let dettid = guest.thread_state().dettid;
let maybe_timeout = if let Some(timeout) = call.timeout() {
let ts: Timespec = guest.memory().read_value(timeout)?;
let ns_delta =
Duration::from_secs(ts.tv_sec as u64) + Duration::from_nanos(ts.tv_nsec as u64);
let base_time = thread_observe_time(guest).await;
let target_time = base_time + ns_delta;
Some(target_time)
} else {
None
};
let mut rsrc = Resources::new(dettid);
rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
rsrc.fyi("rt_sigtimedwait");
let waited = match call.set() {
Some(set) => {
match restart_if_first_probe_not_run(read_kernel_sigset(guest, set.into()).await) {
Err(Error::Errno(Errno::ERESTARTNOINTR)) => {
return Err(Errno::ERESTARTNOINTR.into());
}
read => read.ok(),
}
}
None => None,
};
if waited.is_some() {
set_sigtimedwait_set(guest, waited).await;
}
let records = crate::scheduler::discarded_at_send::records(guest.config());
let before = match call.info() {
Some(info) if self.cfg.backend.reports_child_exit_publication || records => {
Some(read_mapped_prefix(guest, info.as_raw(), 128))
}
_ => None,
};
let result = loop {
let result =
retry_nonblocking_syscall_with_timeout(guest, call, rsrc.clone(), maybe_timeout)
.await;
let stands = self
.synchronous_sigchld_stands(guest, call, waited, &result)
.await;
let outcome = if records {
self.take_outcome_of(guest, waited, &result).await
} else {
crate::scheduler::posix_timer_coalesce::TakeOutcome {
skip: false,
rewrite: None,
}
};
if stands && !outcome.skip {
if let (Ok(_), Some(info), Some(rewrite)) = (&result, call.info(), outcome.rewrite)
&& guest
.memory()
.write_value(info.cast::<[u8; 128]>(), &rewrite.to_user())
.is_err()
{
tracing::warn!(
"[dtid {}] rt_sigtimedwait's siginfo keeps the physical record",
guest.thread_state().dettid
);
}
break result;
}
if let (Some(info), Some(bytes)) = (call.info(), before.as_ref()) {
restore_changed_bytes(guest, info, bytes);
}
};
if waited.is_some() {
set_sigtimedwait_set(guest, None).await;
}
if waited.is_some_and(|set| {
set & crate::syscalls::threads::kernel_sigset_bit(libc::SIGALRM) != 0
}) {
crate::tool_global::reconcile_alarm(guest).await;
}
result
}
async fn take_outcome_of<G: Guest<Self>>(
&self,
guest: &mut G,
waited: Option<u64>,
result: &Result<i64, Error>,
) -> crate::scheduler::posix_timer_coalesce::TakeOutcome {
use crate::scheduler::posix_timer_coalesce::TakeOutcome;
let skip = |skip| TakeOutcome {
skip,
rewrite: None,
};
match result {
Ok(signal) if (1..32).contains(&(*signal as i32)) => {
let after =
crate::syscalls::threads::read_kernel_signal_state(guest.pid(), guest.tid())
.ok()
.map(|state| (state.thread_pending, state.shared_pending));
crate::syscalls::helpers::take_outcome(guest, *signal as i32, after).await
}
Err(Error::Errno(Errno::EFAULT)) => {
let Some(set) = waited else {
return skip(false);
};
let Ok(state) =
crate::syscalls::threads::read_kernel_signal_state(guest.pid(), guest.tid())
else {
return skip(false);
};
let at = guest.thread_state().thread_logical_time.as_nanos();
skip(matches!(
crate::tool_global::discarded_signal(
guest,
DiscardedSignalControl::TakeFaulted {
set,
thread_pending: state.thread_pending,
shared_pending: state.shared_pending,
at,
},
)
.await,
DiscardedSignalAnswer::Discarded(true)
))
}
_ => skip(false),
}
}
pub(crate) async fn reconcile_signalfd_records<G: Guest<Self>>(
&self,
guest: &mut G,
buf: AddrMut<'_, u8>,
len: usize,
before: &[u8],
) -> Option<usize> {
self.reconcile_signalfd_extents(guest, &[(buf.as_raw(), len)], len, before)
.await
}
pub(crate) async fn reconcile_signalfd_extents<G: Guest<Self>>(
&self,
guest: &mut G,
extents: &[(usize, usize)],
read: usize,
before: &[u8],
) -> Option<usize> {
let len = read - read % SIGNALFD_RECORD;
let pieces = signalfd_extent_pieces(extents, len);
let mut bytes = Vec::with_capacity(len);
for (address, length) in &pieces {
let mut piece = vec![0u8; *length];
let Some(address_mut) = AddrMut::<u8>::from_raw(*address) else {
return Some(len);
};
if guest.memory().read_exact(address_mut, &mut piece).is_err() {
use std::os::unix::fs::FileExt;
let read = std::fs::File::open(format!("/proc/{}/mem", guest.tid().as_raw()))
.and_then(|mem| mem.read_exact_at(&mut piece, *address as u64));
if read.is_err() {
return Some(len);
}
}
bytes.extend_from_slice(&piece);
}
let controls = signalfd_record_controls(&bytes, std::process::id());
let mut answers = Vec::with_capacity(controls.len());
for control in controls {
answers.push(match control {
Some(control) => Some(crate::tool_global::child_exit_sigchld(guest, control).await),
None => None,
});
}
if crate::scheduler::discarded_at_send::records(guest.config()) {
for (record, answer) in bytes.chunks_mut(SIGNALFD_RECORD).zip(answers.iter_mut()) {
let signal = signalfd_field(record, 0) as i32;
if !(1..32).contains(&signal) {
continue;
}
let outcome = crate::syscalls::helpers::take_outcome(guest, signal, None).await;
if outcome.skip {
*answer = Some(
crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer::Claimed(true),
);
} else if let Some(rewrite) = outcome.rewrite {
record.copy_from_slice(&crate::scheduler::signal_lists::signalfd_record(
&rewrite,
));
}
}
}
let rewritten = match apply_signalfd_answers(&bytes, &answers, before) {
Ok(Some(rewritten)) => rewritten,
Ok(None) => return Some(len),
Err(()) => return None,
};
let mut offset = 0;
for (address, length) in &pieces {
let written = AddrMut::<u8>::from_raw(*address).map(|address| {
guest
.memory()
.write_exact(address, &rewritten.bytes[offset..offset + length])
});
if !matches!(written, Some(Ok(()))) {
tracing::warn!(
"[dtid {}] the signalfd records at {:#x} keep the kernel's siginfo",
guest.thread_state().dettid,
address,
);
return Some(len);
}
offset += length;
}
Some(rewritten.kept)
}
async fn synchronous_sigchld_stands<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigtimedwait,
waited: Option<u64>,
result: &Result<i64, Error>,
) -> bool {
if !self.cfg.backend.reports_child_exit_publication {
return true;
}
if matches!(result, Err(Error::Errno(Errno::EFAULT)))
&& guest.config().sequentialize_threads
&& let Some(set) = waited
{
let sigchld = kernel_sigset_bit(libc::SIGCHLD);
if set & sigchld != 0
&& let Ok(state) = crate::syscalls::threads::read_thread_wait_signal_state(
guest.pid(),
guest.tid(),
)
{
let shared_pending = if set & !sigchld == 0 {
false
} else {
state.shared_pending & sigchld != 0
};
crate::tool_global::child_exit_sigchld(
guest,
crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::WaitFaulted {
private_pending: state.thread_pending & sigchld != 0,
shared_pending,
},
)
.await;
}
return true;
}
if !matches!(result, Ok(signal) if *signal == libc::SIGCHLD as i64) {
return true;
}
let Some(info) = call.info() else {
crate::tool_global::child_exit_sigchld(
guest,
crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::Dequeue {
copy: crate::scheduler::child_exit_sigchld::DequeuedCopy::Unknown,
admits: false,
},
)
.await;
return true;
};
let Some(bytes) = read_siginfo(guest, info) else {
return true;
};
Self::synchronous_sigchld_copy_stands(guest, info, &bytes).await
}
async fn synchronous_sigchld_copy_stands<G: Guest<Self>>(
guest: &mut G,
info: AddrMut<'_, libc::siginfo_t>,
bytes: &[u8; 128],
) -> bool {
use crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer;
use crate::scheduler::child_exit_sigchld::OwnCopy;
let Some(control) =
crate::scheduler::child_exit_sigchld::control_for(bytes, std::process::id(), false)
else {
return true;
};
match crate::tool_global::child_exit_sigchld(guest, control).await {
ChildExitSigchldAnswer::Claimed(dropped) => !dropped,
ChildExitSigchldAnswer::OwnCopy(OwnCopy::Duplicate) => false,
ChildExitSigchldAnswer::OwnCopy(OwnCopy::Deliver(own))
| ChildExitSigchldAnswer::ClaimedFor(own) => {
if let Err(error) = guest
.memory()
.write_value(info.cast::<[u8; 128]>(), &own.to_bytes())
{
tracing::warn!(
"[dtid {}] the SIGCHLD for child {} keeps its siginfo: {}",
guest.thread_state().dettid,
own.pid,
error
);
}
true
}
_ => true,
}
}
pub(crate) async fn reserve_controlled_self_sigkill_exit<G: Guest<Self>>(
&self,
guest: &mut G,
signal: libc::c_int,
target_process: Option<DetPid>,
target_thread: Option<DetTid>,
) -> bool {
if guest.signal_control_mode() != reverie::BackendSignalControlMode::ToolControlled {
return false;
}
let (current_thread, mm) = {
let state = guest.thread_state();
(state.dettid, state.mm_id)
};
if !self_sigkill_targets_current_task(
signal,
target_process,
target_thread,
self.detpid,
current_thread,
) {
return false;
}
let request = guest.thread_state().mk_request(
ResourceID::Exit {
group: true,
process: self.detpid,
mm,
},
Permission::RW,
);
resource_request(guest, request).await;
true
}
pub(crate) async fn report_backend_signal_refusal<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
result: Result<i64, Error>,
) -> Result<i64, Error> {
if !matches!(result, Err(Error::Errno(Errno::ENOSYS))) {
return result;
}
let Some(refusal) = guest
.take_unsupported_refusal()
.filter(|refusal| refusal.operation == reverie::UnsupportedOperation::Signal)
else {
return result;
};
let message = format!(
"[dtid {}] {sysno} refused by the backend: {}. No signal was sent.",
guest.thread_state().dettid,
refusal.diagnostic
);
tracing::error!("{message}");
let _ = std::io::Write::write_fmt(
&mut crate::util::RetryingStderr,
format_args!("hermit: {message}\n"),
);
if !self.cfg.panic_on_unsupported_syscalls {
crate::tool_global::report_unsupported_syscall(guest, sysno).await;
}
self.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await
}
pub async fn handle_kill<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Kill,
) -> Result<i64, Error> {
self.record_orphaned_group_signals(guest, call.sig()).await;
let nested = guest.thread_state().nested_pid_namespace;
if !guest.config().sequentialize_threads {
if call.sig() != 0 && call.pid() <= 0 && call.pid() != libc::pid_t::MIN {
return self
.refuse_group_signal(guest, call.pid(), call.sig())
.await;
}
if !nested
&& self
.drop_signal_to_hermit(guest, Sysno::kill, None, call.pid(), call.sig())
.await
{
return Ok(0);
}
return Ok(self.record_or_replay(guest, call).await?);
}
if nested && call.pid() <= 0 && call.pid() != libc::pid_t::MIN && call.sig() != 0 {
return self
.refuse_group_signal(guest, call.pid(), call.sig())
.await;
}
let (named, own_init_caught) = if call.pid() > 0 {
match self.name_guest_pid(guest, Sysno::kill, call.pid()).await {
NamedGuestPid::Task {
task,
own_init_caught,
} => (task.as_raw(), own_init_caught),
NamedGuestPid::Answer(answer) => return answer,
}
} else {
(call.pid(), None)
};
if Self::own_namespace_init_drops(own_init_caught, call.sig()) {
let task = DetTid::from_raw(named);
return self
.send_to_own_init(guest, call, task, QueueId::Process(task), call.sig())
.await;
}
if call.sig() == 0 && call.pid() > 0 {
let (targets, zombie) =
resolve_kill_targets_and_exit(guest, DetPid::from_raw(named)).await;
if targets.is_empty() {
match zombie {
Some(true) => return Ok(0),
Some(false) => return Err(Errno::ESRCH.into()),
None => {}
}
}
}
if call.sig() == 0 || call.pid() == libc::pid_t::MIN {
return Ok(self.record_or_replay(guest, call).await?);
}
let tgid = named;
if call.sig() == libc::SIGALRM && tgid > 0 {
refuse_sigalrm(guest, SigalrmControl::SendTo(DetTid::from_raw(tgid))).await?;
}
if self
.drop_signal_to_hermit(guest, Sysno::kill, None, tgid, call.sig())
.await
{
return Ok(0);
}
if can_forward_process_group_signal(
tgid,
call.sig(),
guest
.config()
.backend
.requires_thread_directed_process_signals,
) {
let group = tgid.checked_neg().map(DetPid::from_raw);
if group.is_some() {
crate::tool_global::notify_unresolved_sigkill(guest, group).await;
}
if guest.config().sequentialize_threads
&& let Some(group) = group
&& let Some(reservation) = reserve_sigkill_group(guest, group).await
{
return self.send_reserved_sigkill(guest, reservation, call).await;
}
return Ok(self.record_or_replay(guest, call).await?);
}
if tgid <= 0 {
return self.refuse_group_signal(guest, tgid, call.sig()).await;
}
let process = signal_target_process(guest, DetPid::from_raw(tgid))
.await
.map_or(tgid, |process| process.as_raw());
if self
.reserve_controlled_self_sigkill_exit(
guest,
call.sig(),
Some(DetPid::from_raw(process)),
None,
)
.await
{
return Ok(self.record_or_replay(guest, call).await?);
}
if call.sig() == libc::SIGKILL
&& let Some(reservation) = reserve_sigkill(guest, DetTid::from_raw(tgid)).await
{
return self.send_reserved_sigkill(guest, reservation, call).await;
}
match self
.own_process_signal(guest, Sysno::kill, tgid, process, call.sig())
.await?
{
OwnProcessSend::Admitted => {
return self
.forward_own_process_signal(guest, call.sig(), call, DetTid::from_raw(tgid))
.await;
}
OwnProcessSend::Refused(answer) => return answer,
OwnProcessSend::NotOwn => {}
}
let Some(tid) = self
.process_signal_target(guest, Sysno::kill, DetPid::from_raw(process), call.sig())
.await?
else {
if !(1..=libc::SIGRTMAX()).contains(&call.sig()) {
return Err(Errno::EINVAL.into());
}
return Ok(0);
};
let value = if !guest
.config()
.backend
.requires_thread_directed_process_signals
{
self.send_guest_signal(
guest,
call,
tid,
call.sig(),
Some(DetPid::from_raw(process)),
false,
DetTid::from_raw(tgid),
)
.await?
} else if process == self.detpid.as_raw()
&& tid == guest.thread_state().dettid
&& (1..=libc::SIGRTMAX()).contains(&call.sig())
{
let uid = guest.inject_with_retry(syscalls::Getuid::new()).await? as u32;
let mut info = [0_u8; 128];
info[0..4].copy_from_slice(&call.sig().to_ne_bytes());
info[8..12].copy_from_slice(&libc::SI_USER.to_ne_bytes());
info[16..20].copy_from_slice(&self.detpid.as_raw().to_ne_bytes());
info[20..24].copy_from_slice(&uid.to_ne_bytes());
let mut stack = guest.stack().await;
let info = stack.push(info);
let _stack_guard = stack.commit()?;
let targeted = syscalls::RtTgsigqueueinfo::new()
.with_tgid(process)
.with_tid(tid.as_raw())
.with_sig(call.sig())
.with_siginfo(Some(unsafe { info.cast().into_mut() }));
self.send_guest_signal(
guest,
targeted,
tid,
call.sig(),
Some(DetPid::from_raw(process)),
false,
DetTid::from_raw(tgid),
)
.await?
} else {
let targeted = syscalls::Tgkill::new()
.with_tgid(process)
.with_tid(tid.as_raw())
.with_sig(call.sig());
self.send_guest_signal(
guest,
targeted,
tid,
call.sig(),
Some(DetPid::from_raw(process)),
false,
DetTid::from_raw(tgid),
)
.await?
};
self.notify_cross_task_signal(
guest,
tid,
call.sig(),
Some(DetPid::from_raw(process)),
crate::tool_global::SignalScope::Process,
)
.await;
Ok(value)
}
async fn refuse_group_signal<G: Guest<Self>>(
&self,
guest: &mut G,
pid: libc::pid_t,
sig: libc::c_int,
) -> Result<i64, Error> {
let target = match pid {
0 => "its own process group".to_owned(),
-1 => "every process it may signal".to_owned(),
pid => format!("process group {}", pid.unsigned_abs()),
};
let reason = if guest.config().sequentialize_threads {
"Detcore does not model process-group membership or each process's receiving \
thread (https://github.com/rrnewton/hermit/issues/4046)"
} else {
"with threads not sequentialized (--no-sequentialize-threads, --strace-only) it \
would go to the host kernel as is, and the guest's process group is inherited from \
Hermit's, so it can reach Hermit and the processes that started it \
(https://github.com/rrnewton/hermit/issues/4057)"
};
tracing::error!(
"[detcore, dtid {}] signal {} to {} by kill is not supported: {}",
guest.thread_state().dettid,
sig,
target,
reason,
);
self.refuse_unserviceable_operation(guest, Sysno::kill, Errno::ENOSYS)
.await
}
async fn own_process_signal<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
pid: libc::pid_t,
process: libc::pid_t,
sig: libc::c_int,
) -> Result<OwnProcessSend, Error> {
if !bundled_signal_facts::kernel_signal_state_is_guests(&guest.config().backend) {
return Ok(OwnProcessSend::NotOwn);
}
let sender = guest.thread_state().dettid;
if process != self.detpid.as_raw() {
return Ok(OwnProcessSend::NotOwn);
}
let names_sender = pid == sender.as_raw();
let inputs = own_process_signal_inputs(guest).await;
if inputs
.siblings
.iter()
.all(|(_, state)| *state == SiblingSignalState::ExitGranted)
{
return Ok(OwnProcessSend::NotOwn);
}
let state = read_thread_wait_signal_state(guest.pid(), guest.tid())?;
let send = OwnProcessSignal {
sig,
names_sender,
blocked: state.blocked,
thread_pending: state.thread_pending,
ignored: state.ignored,
caught: state.caught,
inputs,
record_replay: self.cfg.recordreplay_modes,
schedule_replay: self.cfg.replay_schedule_from.is_some(),
stacktrace_signal: self.cfg.stacktrace_signal.is_some(),
posthook_anchor: !guest.thread_state().stats.hb_pending_posthook.is_empty(),
signalfd: guest.thread_state().holds_a_signalfd(),
};
tracing::debug!(
"[detcore, dtid {}] signal {} to its own process: {:?}",
sender,
sig,
send
);
let Some(refusal) = own_process_signal_refusal(&send) else {
return Ok(OwnProcessSend::Admitted);
};
tracing::error!(
"[detcore, dtid {}] process-directed signal {} to process {} by {} is not supported: \
{} (https://github.com/rrnewton/hermit/issues/4034)",
sender,
sig,
self.detpid,
sysno,
refusal,
);
Ok(OwnProcessSend::Refused(
self.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await,
))
}
async fn forward_own_process_signal<G: Guest<Self>, C>(
&self,
guest: &mut G,
sig: libc::c_int,
call: C,
named: DetTid,
) -> Result<i64, Error>
where
C: Into<syscalls::Syscall>,
syscalls::Syscall: From<C>,
{
let token = self
.discard_pre_send(guest, named, QueueId::Process(self.detpid), sig)
.await;
let call: syscalls::Syscall = call.into();
let siginfo = sent_siginfo(guest, &call, sig);
guest.thread_state_mut().own_signal_turn_hold = Some(sig);
let result = self.record_or_replay(guest, call).await;
if result.is_err() {
guest.thread_state_mut().own_signal_turn_hold = None;
} else {
self.discard_sent(guest, token, siginfo).await;
}
Ok(result?)
}
async fn send_to_own_init<G: Guest<Self>, C>(
&self,
guest: &mut G,
call: C,
named: DetTid,
queue: QueueId,
sig: libc::c_int,
) -> Result<i64, Error>
where
C: Into<syscalls::Syscall>,
syscalls::Syscall: From<C>,
{
let token = self.discard_pre_send(guest, named, queue, sig).await;
let call: syscalls::Syscall = call.into();
let siginfo = sent_siginfo(guest, &call, sig);
let result = self.record_or_replay(guest, call).await;
if result.is_ok() {
self.discard_sent(guest, token, siginfo).await;
}
Ok(result?)
}
pub(crate) async fn discard_pre_send<G: Guest<Self>>(
&self,
guest: &mut G,
named: DetTid,
queue: QueueId,
raw_signal: i32,
) -> Option<DiscardToken> {
if !crate::scheduler::discarded_at_send::records(guest.config())
|| !(1..32).contains(&raw_signal)
{
return None;
}
match crate::tool_global::discarded_signal(
guest,
DiscardedSignalControl::PreSend {
named,
queue,
signal: raw_signal,
},
)
.await
{
DiscardedSignalAnswer::Token(token) => Some(token),
_ => None,
}
}
pub(crate) async fn discard_sent<G: Guest<Self>>(
&self,
guest: &mut G,
token: Option<DiscardToken>,
siginfo: Option<KernelSiginfo>,
) {
if let Some(token) = token {
crate::tool_global::discarded_signal(
guest,
DiscardedSignalControl::Sent(token, siginfo),
)
.await;
}
}
fn rt_sigqueueinfo_precheck<G: Guest<Self>>(
&self,
guest: &mut G,
call: &syscalls::RtSigqueueinfo,
) -> RtSigqueueinfoPrecheck {
const SIZE: usize = std::mem::size_of::<libc::siginfo_t>();
const KERNEL_SIGINFO: usize = 48;
let address = call.siginfo().map_or(0, |address| address.as_raw());
let Ok(smaps) = std::fs::read_to_string(format!("/proc/{}/smaps", guest.tid().as_raw()))
else {
return RtSigqueueinfoPrecheck::Unreadable;
};
let mappings = parse_smaps(&smaps);
match first_user_unreadable(&mappings, address, KERNEL_SIGINFO) {
None => {}
Some(Unreadable::NoPermission)
| Some(Unreadable::Hole {
below_growsdown: false,
}) => {
return RtSigqueueinfoPrecheck::Efault;
}
Some(Unreadable::Hole {
below_growsdown: true,
}) => {
return RtSigqueueinfoPrecheck::Unreadable;
}
}
if first_user_unreadable(&mappings, address, SIZE).is_some() {
return RtSigqueueinfoPrecheck::Unreadable;
}
let read = call.siginfo().and_then(|info| {
guest.memory().read_value(info).ok().or_else(|| {
use std::os::unix::fs::FileExt;
let mut bytes = [0u8; SIZE];
std::fs::File::open(format!("/proc/{}/mem", guest.tid().as_raw()))
.and_then(|mem| mem.read_exact_at(&mut bytes, address as u64))
.ok()?;
Some(unsafe { std::ptr::read_unaligned(bytes.as_ptr().cast::<libc::siginfo_t>()) })
})
});
let Some(info) = read else {
return RtSigqueueinfoPrecheck::Unreadable;
};
let code = info.si_code;
if (code >= 0 || code == libc::SI_TKILL)
&& guest.thread_state().dettid.as_raw() != call.tgid()
{
RtSigqueueinfoPrecheck::KernelFails
} else {
RtSigqueueinfoPrecheck::Proceeds
}
}
pub(crate) async fn record_orphaned_group_signals<G: Guest<Self>>(
&self,
guest: &mut G,
sig: libc::c_int,
) {
if sig == libc::SIGSTKFLT {
crate::tool_global::record_guest_marker_signal(guest).await;
}
let signals = orphaned_group_signals(sig);
if signals != 0
&& bundled_signal_facts::host_timed_signal_sources_are_physical(&guest.config().backend)
{
record_host_timed_signals(guest, HostTimedSignalScope::Container, signals).await;
}
}
async fn name_guest_pid<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
pid: libc::pid_t,
) -> NamedGuestPid {
if !guest.thread_state().nested_pid_namespace {
return NamedGuestPid::Task {
task: DetTid::from_raw(pid),
own_init_caught: None,
};
}
let refusal = if guest
.config()
.backend
.requires_thread_directed_process_signals
{
"this backend sends process signals with Detcore's container-namespace ids".to_owned()
} else {
match crate::tool_global::guest_pid(guest, pid).await {
GuestPidAnswer::Task {
task,
own_init_caught,
} => {
return NamedGuestPid::Task {
task,
own_init_caught,
};
}
GuestPidAnswer::NoSuchPid => {
return NamedGuestPid::Answer(Err(Errno::ESRCH.into()));
}
GuestPidAnswer::Untranslatable(reason) => reason,
}
};
tracing::error!(
"[detcore, dtid {}] {} naming pid {} from a nested PID namespace is not supported: {} (https://github.com/rrnewton/hermit/issues/4155)",
guest.thread_state().dettid,
sysno,
pid,
refusal,
);
NamedGuestPid::Answer(
self.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await,
)
}
pub(crate) fn own_namespace_init_drops(own_init_caught: Option<u64>, sig: libc::c_int) -> bool {
own_init_caught.is_some_and(|caught| {
(1..=libc::SIGRTMAX()).contains(&sig)
&& (sig == libc::SIGKILL
|| sig == libc::SIGSTOP
|| caught & kernel_sigset_bit(sig) == 0)
})
}
async fn drop_signal_to_hermit<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
tgid: Option<libc::pid_t>,
target: libc::pid_t,
sig: libc::c_int,
) -> bool {
if !(1..=libc::SIGRTMAX()).contains(&sig) || target <= 0 {
return false;
}
if !crate::tool_global::names_hermit_task(guest, tgid, target).await {
return false;
}
tracing::info!(
"[detcore, dtid {}] {} of signal {} to task {}, one of Hermit's own: dropped and \
answered 0, as Linux drops a signal from inside a PID namespace to its init \
(https://github.com/rrnewton/hermit/issues/4066)",
guest.thread_state().dettid,
sysno,
sig,
target,
);
true
}
pub(crate) async fn process_signal_target<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
tgid: DetPid,
sig: libc::c_int,
) -> Result<Option<DetTid>, Error> {
let (targets, zombie) = resolve_kill_targets_and_exit(guest, tgid).await;
if sig == libc::SIGKILL
&& targets.len() > 1
&& guest
.config()
.backend
.requires_thread_directed_process_signals
{
return Ok(targets.first().copied());
}
match deterministic_kill_target(&targets, zombie, sig) {
Err(Errno::ENOSYS) => {
tracing::error!(
"[detcore, dtid {}] process-directed signal {} to process {} by {} is not supported: \
the process has {} live threads, and Detcore does not choose the receiving \
thread as Linux's complete_signal does \
(https://github.com/rrnewton/hermit/issues/4034)",
guest.thread_state().dettid,
sig,
tgid,
sysno,
targets.len(),
);
self.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await
.and(Err(Errno::ENOSYS.into()))
}
target => Ok(target?),
}
}
pub async fn handle_tgkill<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Tgkill,
) -> Result<i64, Error> {
self.record_orphaned_group_signals(guest, call.sig()).await;
let nested = guest.thread_state().nested_pid_namespace;
let (tgid, tid) = if nested && call.tgid() > 0 && call.tid() > 0 {
let (tid, own_init_caught) =
match self.name_guest_pid(guest, Sysno::tgkill, call.tid()).await {
NamedGuestPid::Task {
task,
own_init_caught,
} => (task, own_init_caught),
NamedGuestPid::Answer(answer) => return answer,
};
let tgid = match self.name_guest_pid(guest, Sysno::tgkill, call.tgid()).await {
NamedGuestPid::Task { task, .. } => task,
NamedGuestPid::Answer(answer) => return answer,
};
if Self::own_namespace_init_drops(own_init_caught, call.sig()) {
return self
.send_to_own_init(guest, call, tid, QueueId::Thread(tid), call.sig())
.await;
}
(tgid.as_raw(), tid.as_raw())
} else {
(call.tgid(), call.tid())
};
if call.sig() == libc::SIGALRM {
refuse_sigalrm(guest, SigalrmControl::SendTo(DetTid::from_raw(tid))).await?;
}
if !nested
&& self
.drop_signal_to_hermit(guest, Sysno::tgkill, Some(tgid), tid, call.sig())
.await
{
return Ok(0);
}
let _reserved = self
.reserve_controlled_self_sigkill_exit(
guest,
call.sig(),
Some(DetPid::from_raw(tgid)),
Some(DetTid::from_raw(tid)),
)
.await;
let mut exited_leader = false;
if call.sig() == libc::SIGKILL
&& guest.config().sequentialize_threads
&& tgid > 0
&& tid > 0
&& registered_process_of(guest, DetTid::from_raw(tid)).await
== Some(DetPid::from_raw(tgid))
{
exited_leader = sigkill_names_an_exited_leader(guest, DetTid::from_raw(tid)).await;
if !exited_leader
&& let Some(reservation) = reserve_sigkill(guest, DetTid::from_raw(tid)).await
{
return self.send_reserved_sigkill(guest, reservation, call).await;
}
}
let value = self
.send_guest_signal(
guest,
call,
DetTid::from_raw(call.tid()),
call.sig(),
None,
true,
DetTid::from_raw(tid),
)
.await?;
if exited_leader {
return Ok(value);
}
self.notify_cross_task_signal(
guest,
DetTid::from_raw(tid),
call.sig(),
None,
crate::tool_global::SignalScope::Thread,
)
.await;
Ok(value)
}
pub async fn handle_tkill<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Tkill,
) -> Result<i64, Error> {
self.record_orphaned_group_signals(guest, call.sig()).await;
let nested = guest.thread_state().nested_pid_namespace;
let tid = if nested && call.tid() > 0 {
match self.name_guest_pid(guest, Sysno::tkill, call.tid()).await {
NamedGuestPid::Task {
task,
own_init_caught,
} => {
if Self::own_namespace_init_drops(own_init_caught, call.sig()) {
return self
.send_to_own_init(guest, call, task, QueueId::Thread(task), call.sig())
.await;
}
task.as_raw()
}
NamedGuestPid::Answer(answer) => return answer,
}
} else {
call.tid()
};
if call.sig() == libc::SIGALRM {
refuse_sigalrm(guest, SigalrmControl::SendTo(DetTid::from_raw(tid))).await?;
}
if !nested
&& self
.drop_signal_to_hermit(guest, Sysno::tkill, None, tid, call.sig())
.await
{
return Ok(0);
}
let _reserved = self
.reserve_controlled_self_sigkill_exit(
guest,
call.sig(),
None,
Some(DetTid::from_raw(tid)),
)
.await;
let mut exited_leader = false;
if call.sig() == libc::SIGKILL && guest.config().sequentialize_threads && tid > 0 {
exited_leader = sigkill_names_an_exited_leader(guest, DetTid::from_raw(tid)).await;
if !exited_leader
&& let Some(reservation) = reserve_sigkill(guest, DetTid::from_raw(tid)).await
{
return self.send_reserved_sigkill(guest, reservation, call).await;
}
}
let value = self
.send_guest_signal(
guest,
call,
DetTid::from_raw(call.tid()),
call.sig(),
None,
true,
DetTid::from_raw(tid),
)
.await?;
if exited_leader {
return Ok(value);
}
self.notify_cross_task_signal(
guest,
DetTid::from_raw(tid),
call.sig(),
None,
crate::tool_global::SignalScope::Thread,
)
.await;
Ok(value)
}
pub(crate) async fn send_reserved_sigkill<G: Guest<Self>>(
&self,
guest: &mut G,
reservation: crate::scheduler::sigkill_retirement::SigkillReservation,
call: impl Into<syscalls::Syscall> + Copy,
) -> Result<i64, Error> {
if !reservation.includes_sender {
let result = self.record_or_replay(guest, call).await;
commit_sigkill(guest, reservation.token, result.is_ok()).await;
return Ok(result?);
}
if self.cfg.backend.reports_kernel_child_exit_signals {
let uid = crate::syscalls::real_uid(guest.tid().as_raw())
.unwrap_or_else(|| unsafe { libc::getuid() });
crate::tool_global::child_exit_sigchld(
guest,
crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::ExitStatus {
code: libc::CLD_KILLED,
status: libc::SIGKILL,
uid,
},
)
.await;
}
let request = guest.thread_state().mk_request(
ResourceID::Exit {
group: true,
process: guest.thread_state().detpid.expect("detpid unset"),
mm: guest.thread_state().mm_id,
},
Permission::RW,
);
resource_request(guest, request).await;
commit_sigkill(guest, reservation.token, true).await;
Ok(self.record_or_replay(guest, call).await?)
}
#[expect(
clippy::too_many_arguments,
reason = "each argument is one fact about the send the kernel call cannot tell"
)]
pub(crate) async fn send_guest_signal<G, S>(
&self,
guest: &mut G,
syscall: S,
target: DetTid,
raw_signal: i32,
target_process: Option<DetPid>,
thread_directed: bool,
named: DetTid,
) -> Result<i64, Error>
where
G: Guest<Self>,
S: Into<reverie::syscalls::Syscall>,
{
use crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer;
use crate::scheduler::child_exit_sigchld::ChildExitSigchldControl;
let mut undo = None;
if raw_signal == libc::SIGCHLD && guest.config().sequentialize_threads {
if thread_directed
|| target_process.is_none()
|| guest
.config()
.backend
.requires_thread_directed_process_signals
{
let answer = crate::tool_global::child_exit_sigchld(
guest,
ChildExitSigchldControl::PrivateSent { target },
)
.await;
if answer == ChildExitSigchldAnswer::Placed(true) {
undo = Some(ChildExitSigchldControl::SendFailed {
private: Some(target),
shared: None,
});
}
} else if let Some(process) = target_process {
crate::tool_global::child_exit_sigchld(
guest,
ChildExitSigchldControl::SharedSent { target: process },
)
.await;
undo = Some(ChildExitSigchldControl::SendFailed {
private: None,
shared: Some(process),
});
}
}
let queue = match target_process {
Some(process)
if !thread_directed
&& !guest
.config()
.backend
.requires_thread_directed_process_signals =>
{
QueueId::Process(process)
}
_ => QueueId::Thread(target),
};
let token = self.discard_pre_send(guest, named, queue, raw_signal).await;
let syscall: syscalls::Syscall = syscall.into();
let siginfo = sent_siginfo(guest, &syscall, raw_signal);
let result = self.record_or_replay(guest, syscall).await;
if result.is_err()
&& let Some(undo) = undo
{
crate::tool_global::child_exit_sigchld(guest, undo).await;
}
if result.is_ok() {
self.discard_sent(guest, token, siginfo).await;
}
Ok(result?)
}
pub(crate) async fn notify_cross_task_signal<G: Guest<Self>>(
&self,
guest: &mut G,
target: DetTid,
raw_signal: i32,
target_process: Option<DetPid>,
scope: crate::tool_global::SignalScope,
) {
if should_notify_cross_task_signal(guest.thread_state().dettid, target, raw_signal) {
notify_signal_pending(guest, target, SigWrapper(raw_signal), target_process, scope)
.await;
}
}
pub(crate) async fn refuse_forged_own_sigchld<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
signal: i32,
info: Option<AddrMut<'_, libc::siginfo_t>>,
) -> Option<Result<i64, Error>> {
if signal != libc::SIGCHLD {
return None;
}
let bytes = read_siginfo(guest, info?)?;
let (code, _) = crate::scheduler::child_exit_sigchld::siginfo_code_and_pid(&bytes);
let value = i32::from_ne_bytes(bytes[24..28].try_into().expect("four bytes"));
if code != libc::SI_QUEUE || value != crate::scheduler::child_exit_sigchld::OWN_SIGCHLD_MARK
{
return None;
}
tracing::error!(
"[detcore, dtid {}] {} sends a SIGCHLD carrying the scheduler's own-copy mark {:#x}, which a nested PID namespace's receiver could not tell from the scheduler's (https://github.com/rrnewton/hermit/issues/4155)",
guest.thread_state().dettid,
sysno,
crate::scheduler::child_exit_sigchld::OWN_SIGCHLD_MARK,
);
Some(
self.refuse_unserviceable_operation(guest, sysno, Errno::EPERM)
.await,
)
}
pub async fn handle_rt_tgsigqueueinfo<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtTgsigqueueinfo,
) -> Result<i64, Error> {
if let Some(refused) = self
.refuse_forged_own_sigchld(guest, Sysno::rt_tgsigqueueinfo, call.sig(), call.siginfo())
.await
{
return refused;
}
self.record_orphaned_group_signals(guest, call.sig()).await;
let nested = guest.thread_state().nested_pid_namespace;
let tid = if nested && call.tgid() > 0 && call.tid() > 0 {
match self
.name_guest_pid(guest, Sysno::rt_tgsigqueueinfo, call.tid())
.await
{
NamedGuestPid::Task {
task,
own_init_caught,
} => {
if Self::own_namespace_init_drops(own_init_caught, call.sig()) {
return self
.send_to_own_init(guest, call, task, QueueId::Thread(task), call.sig())
.await;
}
task.as_raw()
}
NamedGuestPid::Answer(Err(Error::Errno(Errno::ESRCH))) => {
return Ok(self.record_or_replay(guest, call).await?);
}
NamedGuestPid::Answer(answer) => return answer,
}
} else {
call.tid()
};
if call.sig() == libc::SIGALRM {
refuse_sigalrm(guest, SigalrmControl::SendTo(DetTid::from_raw(tid))).await?;
}
if !nested
&& self
.drop_signal_to_hermit(
guest,
Sysno::rt_tgsigqueueinfo,
Some(call.tgid()),
tid,
call.sig(),
)
.await
{
return Ok(0);
}
let exited_leader = call.sig() == libc::SIGKILL
&& guest.config().sequentialize_threads
&& tid > 0
&& sigkill_names_an_exited_leader(guest, DetTid::from_raw(tid)).await;
if call.sig() == libc::SIGKILL
&& !nested
&& !exited_leader
&& guest.config().sequentialize_threads
&& call.tgid() > 0
&& tid > 0
&& guest
.thread_state()
.detpid
.is_none_or(|own| own.as_raw() != call.tgid())
&& registered_process_of(guest, DetTid::from_raw(tid)).await
== Some(DetPid::from_raw(call.tgid()))
&& let Some(reservation) = reserve_sigkill(guest, DetTid::from_raw(tid)).await
{
if reservation.includes_sender {
commit_sigkill(guest, reservation.token, false).await;
} else {
return self.send_reserved_sigkill(guest, reservation, call).await;
}
}
let value = self
.send_guest_signal(
guest,
call,
DetTid::from_raw(call.tid()),
call.sig(),
None,
true,
DetTid::from_raw(tid),
)
.await?;
if exited_leader {
return Ok(value);
}
self.notify_cross_task_signal(
guest,
DetTid::from_raw(tid),
call.sig(),
None,
crate::tool_global::SignalScope::Thread,
)
.await;
Ok(value)
}
pub async fn handle_rt_sigqueueinfo<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigqueueinfo,
) -> Result<i64, Error> {
if let Some(refused) = self
.refuse_forged_own_sigchld(guest, Sysno::rt_sigqueueinfo, call.sig(), call.siginfo())
.await
{
return refused;
}
self.record_orphaned_group_signals(guest, call.sig()).await;
let nested = guest.thread_state().nested_pid_namespace;
if !guest.config().sequentialize_threads {
if !nested
&& self
.drop_signal_to_hermit(
guest,
Sysno::rt_sigqueueinfo,
None,
call.tgid(),
call.sig(),
)
.await
{
return Ok(0);
}
return Ok(self.record_or_replay(guest, call).await?);
}
let tgid = if nested && call.tgid() > 0 {
match self
.name_guest_pid(guest, Sysno::rt_sigqueueinfo, call.tgid())
.await
{
NamedGuestPid::Task {
task,
own_init_caught,
} => {
if Self::own_namespace_init_drops(own_init_caught, call.sig()) {
return self
.send_to_own_init(guest, call, task, QueueId::Process(task), call.sig())
.await;
}
task.as_raw()
}
NamedGuestPid::Answer(Err(Error::Errno(Errno::ESRCH))) => {
return Ok(self.record_or_replay(guest, call).await?);
}
NamedGuestPid::Answer(answer) => return answer,
}
} else {
call.tgid()
};
if tgid <= 0 {
return Ok(self.record_or_replay(guest, call).await?);
}
if call.sig() == 0 {
let (targets, zombie) =
resolve_kill_targets_and_exit(guest, DetPid::from_raw(tgid)).await;
if targets.is_empty() && zombie == Some(false) {
return Ok(self
.record_or_replay(guest, call.with_tgid(NO_SUCH_PID))
.await?);
}
return Ok(self.record_or_replay(guest, call).await?);
}
if call.sig() == libc::SIGALRM {
refuse_sigalrm(guest, SigalrmControl::SendTo(DetTid::from_raw(tgid))).await?;
}
if self
.drop_signal_to_hermit(guest, Sysno::rt_sigqueueinfo, None, tgid, call.sig())
.await
{
return Ok(0);
}
if bundled_signal_facts::host_task_reads_enabled(&guest.config().backend) {
match self.rt_sigqueueinfo_precheck(guest, &call) {
RtSigqueueinfoPrecheck::KernelFails => {
return Ok(self.record_or_replay(guest, call).await?);
}
RtSigqueueinfoPrecheck::Efault => return Err(Errno::EFAULT.into()),
RtSigqueueinfoPrecheck::Unreadable => {
tracing::error!(
"[detcore, dtid {}] rt_sigqueueinfo with a siginfo_t at {:#x} is not \
supported: Hermit cannot read all 128 bytes of it to decide the call \
(https://github.com/rrnewton/hermit/issues/4034)",
guest.thread_state().dettid,
call.siginfo().map_or(0, |info| info.as_raw()),
);
return self
.refuse_unserviceable_operation(
guest,
Sysno::rt_sigqueueinfo,
Errno::ENOSYS,
)
.await;
}
RtSigqueueinfoPrecheck::Proceeds => {}
}
}
let process = signal_target_process(guest, DetPid::from_raw(tgid))
.await
.map_or(tgid, |process| process.as_raw());
match self
.own_process_signal(guest, Sysno::rt_sigqueueinfo, tgid, process, call.sig())
.await?
{
OwnProcessSend::Admitted => {
return self
.forward_own_process_signal(guest, call.sig(), call, DetTid::from_raw(tgid))
.await;
}
OwnProcessSend::Refused(answer) => return answer,
OwnProcessSend::NotOwn => {}
}
let target = match self
.process_signal_target(
guest,
Sysno::rt_sigqueueinfo,
DetPid::from_raw(process),
call.sig(),
)
.await
{
Err(Error::Errno(Errno::ESRCH)) => {
return Ok(self
.record_or_replay(guest, call.with_tgid(NO_SUCH_PID))
.await?);
}
target => target?,
};
let Some(tid) = target else {
if guest
.config()
.backend
.requires_thread_directed_process_signals
{
return Err(Errno::ESRCH.into());
}
return Ok(self.record_or_replay(guest, call).await?);
};
let value = if !guest
.config()
.backend
.requires_thread_directed_process_signals
{
self.send_guest_signal(
guest,
call,
tid,
call.sig(),
Some(DetPid::from_raw(process)),
false,
DetTid::from_raw(tgid),
)
.await?
} else {
let targeted = syscalls::RtTgsigqueueinfo::new()
.with_tgid(process)
.with_tid(tid.as_raw())
.with_sig(call.sig())
.with_siginfo(call.siginfo());
self.send_guest_signal(
guest,
targeted,
tid,
call.sig(),
Some(DetPid::from_raw(process)),
false,
DetTid::from_raw(tgid),
)
.await?
};
self.notify_cross_task_signal(
guest,
tid,
call.sig(),
Some(DetPid::from_raw(process)),
crate::tool_global::SignalScope::Process,
)
.await;
Ok(value)
}
pub async fn handle_rt_sigpending<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigpending,
) -> Result<i64, Error> {
let pending = pending_real_time_among(guest, REAL_TIME_SIGNALS).await;
act_on_pending_real_time(guest, pending, REAL_TIME_SIGNALS, 0).await;
Ok(self.record_or_replay(guest, call).await?)
}
pub(crate) async fn record_handler_restore_mask<G: Guest<Self>>(
&self,
guest: &mut G,
signal: SigWrapper,
) {
if !bundled_signal_facts::models_signal_targets(&self.cfg)
|| guest.thread_state().handler_restore_rt_reported == REAL_TIME_SIGNALS
{
return;
}
let caught =
match crate::syscalls::signal_shadow::copied_dispositions_for(guest, signal.raw()) {
Some(copied) => Ok(copied.caught),
None => read_thread_wait_signal_state(guest.pid(), guest.tid())
.map(|state| state.caught),
};
if let Ok(caught) = caught
&& caught & kernel_sigset_bit(signal.raw()) == 0
{
return;
}
let Some(detpid) = guest.thread_state().detpid else {
return;
};
crate::tool_global::record_handler_restore_mask(guest, detpid, REAL_TIME_SIGNALS).await;
guest.thread_state_mut().handler_restore_rt_reported = REAL_TIME_SIGNALS;
}
pub(crate) async fn observe_sigreturn_mask<G: Guest<Self>>(&self, guest: &mut G) {
let pending = pending_real_time_among(guest, REAL_TIME_SIGNALS).await;
if pending == 0 {
return;
}
let sp = guest.regs().await.rsp as usize;
let restored = Addr::<u64>::from_raw(sp.wrapping_add(UC_SIGMASK_OFFSET))
.and_then(|addr| guest.memory().read_value(addr).ok());
let (observable, discarded) = match (
restored,
read_thread_wait_signal_state(guest.pid(), guest.tid()),
) {
(Some(mask), Ok(state)) => unblocked_by(&state, mask),
(None, _) => (0, 0),
(Some(_), Err(_)) => (REAL_TIME_SIGNALS, 0),
};
act_on_pending_real_time(guest, pending, observable, discarded).await;
}
}
enum ValidatedSet {
Validated(KernelSigset),
NotRun,
NotValidated,
}
pub(super) const UC_SIGMASK_OFFSET: usize = 8 + 8 + 24 + 256;
fn should_notify_cross_task_signal(sender: DetTid, target: DetTid, raw_signal: i32) -> bool {
raw_signal != 0 && target != sender
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum SleepCheck {
BeforePark,
AfterWake(Option<Vec<SigWrapper>>),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum SleepSignal {
Pending,
Held,
None,
Claimed,
}
pub(crate) async fn sleep_signal<G, T>(
guest: &mut G,
check: SleepCheck,
stops_end_it: bool,
) -> Result<SleepSignal, Error>
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
if !guest
.config()
.backend
.supports_blocked_wait_signal_interruption
{
return Ok(match check {
SleepCheck::BeforePark => SleepSignal::None,
SleepCheck::AfterWake(_) => SleepSignal::Held,
});
}
let host_timed = host_timed_signals(guest).await;
let held = kernel_sigset_bit(libc::SIGCHLD) | host_timed;
let before_park = check == SleepCheck::BeforePark;
let (deciding, held_woken, unknown_held_wake) = match check {
SleepCheck::BeforePark => (!held, 0, false),
SleepCheck::AfterWake(None) => (0, 0, true),
SleepCheck::AfterWake(Some(woken)) => {
let woken = woken
.iter()
.fold(0, |set, signal| set | kernel_sigset_bit(signal.raw()));
(woken & !held, woken & held, false)
}
};
if deciding != 0 || held_woken != 0 {
let state = read_thread_wait_signal_state(guest.pid(), guest.tid())?;
let mut ending = state.pending_interrupting(state.blocked, false) & deciding;
if !stops_end_it && before_park {
ending &= !(state.default_job_control_stops() | kernel_sigset_bit(libc::SIGSTOP));
}
let committed = if before_park { 0 } else { deciding };
let ending =
crate::syscalls::threads::without_discarded(guest, &state, ending, committed).await;
if ending != 0 {
return Ok(SleepSignal::Pending);
}
let sigchld = kernel_sigset_bit(libc::SIGCHLD) & !host_timed;
let committed = if asks_committed_sigchld(held_woken, &state, sigchld)
&& matches!(
crate::tool_global::child_exit_sigchld(
guest,
crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::PlacedPending,
)
.await,
crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer::Placed(true)
) {
if state.pending & sigchld == 0 {
tracing::error!(
"[dtid {}] a committed SIGCHLD is pending by the schedule but not in /proc",
guest.thread_state().dettid
);
debug_assert!(false, "a committed SIGCHLD is not pending in /proc");
}
sigchld
} else {
0
};
if let Some(verdict) = committed_sigchld_verdict(&state, held_woken, committed) {
return Ok(verdict);
}
if committed == 0
&& held_woken & sigchld != 0
&& woken_sigchld_pending(&state, sigchld)
&& matches!(
crate::tool_global::child_exit_sigchld(
guest,
crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::WindowUnusable,
)
.await,
crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer::Placed(true)
)
&& state.next_dequeued(state.blocked).map(|(signal, _)| signal) == Some(libc::SIGCHLD)
&& {
send_claim_fault_signal(guest, ClaimFault::Usr1BeforeClaim);
let claimed = claim_pending_sigchld(guest).await?;
if claimed {
send_claim_fault_signal(guest, ClaimFault::Usr1AfterClaim);
}
claimed
}
{
guest.thread_state_mut().claimed_sigchld = true;
return Ok(SleepSignal::Claimed);
}
let held_woken = held_woken & !sigchld;
if held_wake_ends_sleep(&state, held_woken) {
return Ok(SleepSignal::Held);
}
return Ok(SleepSignal::None);
}
Ok(if unknown_held_wake {
SleepSignal::Held
} else {
SleepSignal::None
})
}
pub(crate) fn rt_sigsuspend_never_sleeps(backend: &reverie::BackendCapabilities) -> bool {
backend.provides_process_signal_control
}
pub(crate) fn claim_still_pending<E>(
claimed: bool,
read_state: impl FnOnce() -> Result<crate::syscalls::threads::KernelSignalState, E>,
) -> bool {
claimed && read_state().is_ok_and(|state| state.pending & kernel_sigset_bit(libc::SIGCHLD) != 0)
}
fn woken_sigchld_pending(
state: &crate::syscalls::threads::KernelSignalState,
sigchld: KernelSigset,
) -> bool {
state.pending & state.interrupting(state.blocked) & sigchld != 0
}
fn asks_committed_sigchld(
held_woken: KernelSigset,
state: &crate::syscalls::threads::KernelSignalState,
sigchld: KernelSigset,
) -> bool {
(held_woken | state.thread_pending) & sigchld != 0
}
fn committed_sigchld_verdict(
state: &crate::syscalls::threads::KernelSignalState,
held_woken: KernelSigset,
committed: KernelSigset,
) -> Option<SleepSignal> {
let verdict = if held_woken & committed != 0 {
SleepSignal::Held
} else {
SleepSignal::Pending
};
(state.interrupting(state.blocked) & committed != 0).then_some(verdict)
}
pub(crate) const SIGNALFD_RECORD: usize = 128;
pub(crate) fn signalfd_mask(pid: i32, fd: i32) -> Option<u64> {
let info = std::fs::read_to_string(format!("/proc/{pid}/fdinfo/{fd}")).ok()?;
info.lines()
.find_map(|line| line.strip_prefix("sigmask:"))
.and_then(|mask| u64::from_str_radix(mask.trim(), 16).ok())
}
fn signalfd_field(record: &[u8], at: usize) -> u32 {
u32::from_ne_bytes(record[at..at + 4].try_into().expect("four bytes"))
}
fn signalfd_record_controls(
bytes: &[u8],
tracer: u32,
) -> Vec<Option<crate::scheduler::child_exit_sigchld::ChildExitSigchldControl>> {
use crate::scheduler::child_exit_sigchld::ChildExitSigchldControl;
use crate::scheduler::child_exit_sigchld::DequeuedCopy;
bytes
.chunks(SIGNALFD_RECORD)
.map(|record| {
if signalfd_field(record, 0) != libc::SIGCHLD as u32 {
return None;
}
let code = signalfd_field(record, 8) as i32;
let pid = signalfd_field(record, 12);
let value = signalfd_field(record, 44) as i32;
let copy = if crate::scheduler::child_exit_sigchld::is_child_exit_code(code) {
DequeuedCopy::Kernel {
child: DetPid::from_raw(pid as i32),
}
} else if crate::scheduler::child_exit_sigchld::is_own_sigchld_mark(
code, pid as i32, value, tracer,
) {
DequeuedCopy::Scheduler
} else if code == libc::SI_TKILL {
DequeuedCopy::Thread
} else {
DequeuedCopy::Other
};
Some(ChildExitSigchldControl::Dequeue {
copy,
admits: false,
})
})
.collect()
}
pub(crate) fn signalfd_extent_pieces(
extents: &[(usize, usize)],
len: usize,
) -> Vec<(usize, usize)> {
let mut left = len;
let mut pieces = Vec::new();
for (address, length) in extents {
if left == 0 {
break;
}
let take = (*length).min(left);
if take > 0 {
pieces.push((*address, take));
left -= take;
}
}
pieces
}
#[derive(Debug, PartialEq, Eq)]
struct RewrittenSignalfdRecords {
bytes: Vec<u8>,
kept: usize,
}
fn apply_signalfd_answers(
bytes: &[u8],
answers: &[Option<crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer>],
before: &[u8],
) -> Result<Option<RewrittenSignalfdRecords>, ()> {
use crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer;
use crate::scheduler::child_exit_sigchld::OwnCopy;
let mut kept = Vec::with_capacity(bytes.len());
let mut changed = false;
for (record, answer) in bytes.chunks(SIGNALFD_RECORD).zip(answers) {
let mut record = record.to_vec();
match answer {
Some(ChildExitSigchldAnswer::Claimed(true))
| Some(ChildExitSigchldAnswer::OwnCopy(OwnCopy::Duplicate)) => {
changed = true;
continue;
}
Some(ChildExitSigchldAnswer::OwnCopy(OwnCopy::Deliver(own)))
| Some(ChildExitSigchldAnswer::ClaimedFor(own)) => {
let signo = signalfd_field(&record, 0);
record.fill(0);
record[0..4].copy_from_slice(&signo.to_ne_bytes());
record[8..12].copy_from_slice(&own.code.to_ne_bytes());
record[12..16].copy_from_slice(&(own.pid as u32).to_ne_bytes());
record[16..20].copy_from_slice(&own.uid.to_ne_bytes());
record[40..44].copy_from_slice(&own.status.to_ne_bytes());
changed = true;
}
_ => {}
}
kept.extend_from_slice(&record);
}
if !changed {
return Ok(None);
}
let kept_len = kept.len();
let len = bytes.len() - bytes.len() % SIGNALFD_RECORD;
if before.len() < len {
return Err(());
}
kept.extend_from_slice(&before[kept_len..len]);
Ok(Some(RewrittenSignalfdRecords {
bytes: kept,
kept: kept_len,
}))
}
#[cfg(test)]
mod signalfd_record_tests {
use super::*;
use crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer;
use crate::scheduler::child_exit_sigchld::ChildExitSigchldControl;
use crate::scheduler::child_exit_sigchld::ChildExitSiginfo;
use crate::scheduler::child_exit_sigchld::OwnCopy;
const TRACER: u32 = 4242;
fn apply_without_capture(
bytes: &[u8],
answers: &[Option<ChildExitSigchldAnswer>],
) -> Option<RewrittenSignalfdRecords> {
apply_signalfd_answers(bytes, answers, &vec![0; bytes.len()]).unwrap()
}
#[test]
fn a_dropped_record_past_the_capture_is_refused() {
let mut bytes = vec![0u8; 2 * SIGNALFD_RECORD];
bytes[0..4].copy_from_slice(&10u32.to_ne_bytes());
bytes[SIGNALFD_RECORD..SIGNALFD_RECORD + 4].copy_from_slice(&12u32.to_ne_bytes());
let before = vec![0xa5u8; SIGNALFD_RECORD];
assert_eq!(
apply_signalfd_answers(
&bytes,
&[Some(ChildExitSigchldAnswer::Claimed(true)), None],
&before,
),
Err(())
);
assert_eq!(apply_signalfd_answers(&bytes, &[None, None], &[]), Ok(None));
}
#[test]
fn a_dropped_record_leaves_the_captured_bytes() {
let record = |signo: u32| {
let mut bytes = vec![0u8; SIGNALFD_RECORD];
bytes[0..4].copy_from_slice(&signo.to_ne_bytes());
bytes
};
let bytes = [record(10), record(12)].concat();
let before = vec![0xa5u8; 2 * SIGNALFD_RECORD];
let rewritten = apply_signalfd_answers(
&bytes,
&[Some(ChildExitSigchldAnswer::Claimed(true)), None],
&before,
)
.unwrap()
.unwrap();
assert_eq!(rewritten.kept, SIGNALFD_RECORD);
assert_eq!(&rewritten.bytes[..SIGNALFD_RECORD], &record(12)[..]);
assert!(
rewritten.bytes[SIGNALFD_RECORD..]
.iter()
.all(|byte| *byte == 0xa5)
);
}
fn record(signo: i32, code: i32, pid: u32, status: i32) -> Vec<u8> {
let mut record = vec![0u8; SIGNALFD_RECORD];
record[0..4].copy_from_slice(&(signo as u32).to_ne_bytes());
record[8..12].copy_from_slice(&code.to_ne_bytes());
record[12..16].copy_from_slice(&pid.to_ne_bytes());
record[40..44].copy_from_slice(&status.to_ne_bytes());
record[56..72].fill(7);
record
}
#[test]
fn a_nested_receivers_marked_record_asks_for_the_own_copy() {
use crate::scheduler::child_exit_sigchld::DequeuedCopy;
let marked = |value: i32| {
let mut record = record(libc::SIGCHLD, libc::SI_QUEUE, 0, 0);
record[44..48].copy_from_slice(&value.to_ne_bytes());
record
};
let bytes = [
marked(crate::scheduler::child_exit_sigchld::OWN_SIGCHLD_MARK),
marked(7),
record(libc::SIGCHLD, libc::SI_USER, 0, 0),
]
.concat();
let dequeue = |copy| {
Some(ChildExitSigchldControl::Dequeue {
copy,
admits: false,
})
};
assert_eq!(
signalfd_record_controls(&bytes, TRACER),
vec![
dequeue(DequeuedCopy::Scheduler),
dequeue(DequeuedCopy::Other),
dequeue(DequeuedCopy::Other),
]
);
}
#[test]
fn each_record_asks_the_ledger_only_about_a_child_exit_copy() {
use crate::scheduler::child_exit_sigchld::DequeuedCopy;
let bytes = [
record(libc::SIGCHLD, libc::CLD_KILLED, 31, libc::SIGKILL),
record(libc::SIGCHLD, libc::SI_USER, TRACER, 0),
record(libc::SIGCHLD, libc::SI_USER, 77, 0),
record(libc::SIGCHLD, libc::SI_TKILL, 77, 0),
record(libc::SIGUSR1, libc::SI_USER, TRACER, 0),
]
.concat();
let dequeue = |copy| {
Some(ChildExitSigchldControl::Dequeue {
copy,
admits: false,
})
};
assert_eq!(
signalfd_record_controls(&bytes, TRACER),
vec![
dequeue(DequeuedCopy::Kernel {
child: DetPid::from_raw(31)
}),
dequeue(DequeuedCopy::Scheduler),
dequeue(DequeuedCopy::Other),
dequeue(DequeuedCopy::Thread),
None,
]
);
}
#[test]
fn dropped_records_leave_and_standing_ones_take_the_ledgers_siginfo() {
let own = |pid| ChildExitSiginfo {
code: libc::CLD_KILLED,
pid,
uid: 0,
status: libc::SIGKILL,
};
let first = record(libc::SIGCHLD, libc::CLD_KILLED, 31, libc::SIGKILL);
let second = record(libc::SIGCHLD, libc::SI_USER, TRACER, 0);
let third = record(libc::SIGCHLD, libc::CLD_KILLED, 33, libc::SIGKILL);
let bytes = [first, second, third].concat();
let rewritten = apply_without_capture(
&bytes,
&[
Some(ChildExitSigchldAnswer::Claimed(true)),
Some(ChildExitSigchldAnswer::OwnCopy(OwnCopy::Deliver(own(32)))),
Some(ChildExitSigchldAnswer::ClaimedFor(own(30))),
],
)
.expect("records changed");
assert_eq!(rewritten.kept, 2 * SIGNALFD_RECORD);
assert_eq!(rewritten.bytes.len(), 3 * SIGNALFD_RECORD);
let expect = |pid: u32| {
let mut wanted = record(libc::SIGCHLD, libc::CLD_KILLED, pid, libc::SIGKILL);
wanted[56..72].fill(0);
wanted
};
assert_eq!(&rewritten.bytes[..SIGNALFD_RECORD], &expect(32)[..]);
assert_eq!(
&rewritten.bytes[SIGNALFD_RECORD..2 * SIGNALFD_RECORD],
&expect(30)[..]
);
assert!(
rewritten.bytes[2 * SIGNALFD_RECORD..]
.iter()
.all(|byte| *byte == 0)
);
}
#[test]
fn a_rewritten_own_copy_keeps_none_of_its_marked_record() {
let mut marked = record(libc::SIGCHLD, libc::SI_QUEUE, 0, 0);
marked[44..48]
.copy_from_slice(&crate::scheduler::child_exit_sigchld::OWN_SIGCHLD_MARK.to_ne_bytes());
marked[48..56].fill(9);
marked[20..40].fill(5);
marked[72..].fill(6);
let rewritten = apply_without_capture(
&marked,
&[Some(ChildExitSigchldAnswer::OwnCopy(OwnCopy::Deliver(
ChildExitSiginfo {
code: libc::CLD_KILLED,
pid: 3,
uid: 0,
status: libc::SIGKILL,
},
)))],
)
.expect("records changed");
let mut wanted = vec![0u8; SIGNALFD_RECORD];
wanted[0..4].copy_from_slice(&(libc::SIGCHLD as u32).to_ne_bytes());
wanted[8..12].copy_from_slice(&libc::CLD_KILLED.to_ne_bytes());
wanted[12..16].copy_from_slice(&3u32.to_ne_bytes());
wanted[40..44].copy_from_slice(&libc::SIGKILL.to_ne_bytes());
assert_eq!(rewritten.bytes, wanted);
assert!(rewritten.bytes[44..56].iter().all(|byte| *byte == 0));
}
#[test]
fn a_vectored_reads_records_are_found_across_its_buffers() {
let extents = [(0x1000, 100), (0x2000, 0), (0x3000, 200), (0x4000, 128)];
assert_eq!(
signalfd_extent_pieces(&extents, 256),
vec![(0x1000, 100), (0x3000, 156)]
);
assert_eq!(
signalfd_extent_pieces(&extents, 428),
vec![(0x1000, 100), (0x3000, 200), (0x4000, 128)]
);
assert_eq!(signalfd_extent_pieces(&extents, 0), vec![]);
}
#[test]
fn a_fully_dropped_read_leaves_no_record_and_an_untouched_read_is_not_rewritten() {
let bytes = [
record(libc::SIGCHLD, libc::CLD_KILLED, 31, libc::SIGKILL),
record(libc::SIGCHLD, libc::SI_USER, TRACER, 0),
]
.concat();
let rewritten = apply_without_capture(
&bytes,
&[
Some(ChildExitSigchldAnswer::Claimed(true)),
Some(ChildExitSigchldAnswer::OwnCopy(OwnCopy::Duplicate)),
],
)
.expect("records changed");
assert_eq!(rewritten.kept, 0);
assert!(rewritten.bytes.iter().all(|byte| *byte == 0));
assert_eq!(
apply_without_capture(
&bytes,
&[
Some(ChildExitSigchldAnswer::Claimed(false)),
Some(ChildExitSigchldAnswer::OwnCopy(OwnCopy::Unowned)),
],
),
None
);
}
}
const OWN_PROCESS_SIGNALS: [libc::c_int; 7] = [
libc::SIGHUP,
libc::SIGINT,
libc::SIGQUIT,
libc::SIGUSR1,
libc::SIGUSR2,
libc::SIGPIPE,
libc::SIGTERM,
];
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum OwnProcessSignalRefusal {
SignalNotAdmitted,
DefaultDisposition,
RecordReplay,
ScheduleReplay,
GuestMarkerSignal,
StacktraceSignal,
SenderBlocks,
OutOfSchedule(DetTid),
UnknownMask(DetTid),
NotSoleReceiver(DetTid),
PrivatePending(u64),
HostTimedSource(u64),
ForeignExitSignal(u64),
UndeliveredSchedulerSignal(u64),
PosthookAnchor,
Signalfd,
ExecInFlight,
}
impl std::fmt::Display for OwnProcessSignalRefusal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::SignalNotAdmitted => write!(
f,
"only SIGHUP, SIGINT, SIGQUIT, SIGUSR1, SIGUSR2, SIGPIPE and SIGTERM are delivered \
deterministically to the sender"
),
Self::DefaultDisposition => write!(
f,
"the signal has its default disposition, which ends the process"
),
Self::RecordReplay => write!(f, "the run records or replays"),
Self::ScheduleReplay => write!(
f,
"the run replays a recorded schedule (--replay-schedule-from), whose trace turn \
after the send can hand the turn to another thread"
),
Self::GuestMarkerSignal => write!(
f,
"a guest sent SIGSTKFLT, which Reverie also uses as its timer marker, so a pending \
copy cannot be told from Reverie's"
),
Self::StacktraceSignal => write!(f, "--stacktrace-signal is configured"),
Self::SenderBlocks => write!(f, "the sending thread blocks the signal"),
Self::OutOfSchedule(tid) => write!(
f,
"thread {tid} runs or sleeps outside the schedule, at moments host timing sets"
),
Self::UnknownMask(tid) => write!(f, "thread {tid}'s signal mask is unknown"),
Self::NotSoleReceiver(tid) => write!(
f,
"thread {tid} does not block the signal, so Linux could give it to either thread"
),
Self::PrivatePending(set) => write!(
f,
"the sending thread has signals pending ({set:#x}) that it would take first"
),
Self::HostTimedSource(set) => write!(
f,
"a source that sends signals {set:#x} at moments host timing sets is armed"
),
Self::ForeignExitSignal(set) => write!(
f,
"a child with exit signal {set:#x} is unreaped, and the kernel sends that signal at \
a moment host timing sets"
),
Self::UndeliveredSchedulerSignal(set) => write!(
f,
"the scheduler sent signals {set:#x} that no thread has taken yet"
),
Self::PosthookAnchor => {
write!(f, "a happens-before anchor is set on the call's completion")
}
Self::Signalfd => write!(f, "the process holds a signalfd"),
Self::ExecInFlight => write!(f, "an exec is in flight in the process"),
}
}
}
#[derive(Clone, Debug, Default)]
pub(crate) struct OwnProcessSignal {
pub(crate) sig: libc::c_int,
pub(crate) names_sender: bool,
pub(crate) blocked: u64,
pub(crate) thread_pending: u64,
pub(crate) ignored: u64,
pub(crate) caught: u64,
pub(crate) inputs: OwnProcessSignalInputs,
pub(crate) record_replay: bool,
pub(crate) schedule_replay: bool,
pub(crate) stacktrace_signal: bool,
pub(crate) posthook_anchor: bool,
pub(crate) signalfd: bool,
}
pub(crate) fn own_process_signal_refusal(
send: &OwnProcessSignal,
) -> Option<OwnProcessSignalRefusal> {
use OwnProcessSignalRefusal as R;
let bit = kernel_sigset_bit(send.sig);
if !OWN_PROCESS_SIGNALS.contains(&send.sig) {
return Some(R::SignalNotAdmitted);
}
if (send.ignored | send.caught) & bit == 0 {
return Some(R::DefaultDisposition);
}
if send.record_replay {
return Some(R::RecordReplay);
}
if send.schedule_replay {
return Some(R::ScheduleReplay);
}
if send.stacktrace_signal {
return Some(R::StacktraceSignal);
}
if send.blocked & bit != 0 {
return Some(R::SenderBlocks);
}
for (tid, state) in &send.inputs.siblings {
if *state == SiblingSignalState::OutOfSchedule {
return Some(R::OutOfSchedule(*tid));
}
}
for (tid, state) in &send.inputs.siblings {
if *state == SiblingSignalState::InSchedule(None) {
return Some(R::UnknownMask(*tid));
}
}
if !send.names_sender {
for (tid, state) in &send.inputs.siblings {
if matches!(state, SiblingSignalState::InSchedule(Some(mask)) if mask & bit == 0) {
return Some(R::NotSoleReceiver(*tid));
}
}
}
let unblocked = !send.blocked;
let private = without_perf_event_signal(send.thread_pending) & unblocked;
if private != 0 {
return Some(R::PrivatePending(private));
}
let host_timed = send.inputs.host_timed & unblocked;
if host_timed != 0 {
return Some(R::HostTimedSource(host_timed));
}
let foreign = send.inputs.foreign_exit_signals & unblocked;
if foreign != 0 {
return Some(R::ForeignExitSignal(foreign));
}
let at_or_below = bit | (bit - 1);
let undelivered = send.inputs.undelivered_scheduler_signals & unblocked & at_or_below;
if undelivered != 0 {
return Some(R::UndeliveredSchedulerSignal(undelivered));
}
if send.posthook_anchor {
return Some(R::PosthookAnchor);
}
if send.signalfd {
return Some(R::Signalfd);
}
if send.inputs.exec_in_flight {
return Some(R::ExecInFlight);
}
if send.inputs.guest_marker_signal {
return Some(R::GuestMarkerSignal);
}
None
}
enum NamedGuestPid {
Task {
task: DetTid,
own_init_caught: Option<u64>,
},
Answer(Result<i64, Error>),
}
enum OwnProcessSend {
NotOwn,
Admitted,
Refused(Result<i64, Error>),
}
enum RtSigqueueinfoPrecheck {
KernelFails,
Efault,
Proceeds,
Unreadable,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Mapping {
start: usize,
end: usize,
user_readable: bool,
growsdown: bool,
}
fn parse_smaps(smaps: &str) -> Vec<Mapping> {
let mut mappings: Vec<Mapping> = Vec::new();
for line in smaps.lines() {
if let Some(flags) = line.strip_prefix("VmFlags:") {
if let Some(last) = mappings.last_mut() {
last.growsdown = flags.split_whitespace().any(|flag| flag == "gd");
}
continue;
}
let mut fields = line.split_whitespace();
let Some((start, end)) = fields.next().and_then(|range| range.split_once('-')) else {
continue;
};
let (Ok(start), Ok(end), Some(perms)) = (
usize::from_str_radix(start, 16),
usize::from_str_radix(end, 16),
fields.next(),
) else {
continue;
};
if perms.len() < 4 {
continue;
}
mappings.push(Mapping {
start,
end,
user_readable: perms.chars().take(3).any(|perm| perm != '-'),
growsdown: false,
});
}
mappings.sort_by_key(|mapping| mapping.start);
mappings
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Unreadable {
NoPermission,
Hole { below_growsdown: bool },
}
fn first_user_unreadable(mappings: &[Mapping], address: usize, len: usize) -> Option<Unreadable> {
let Some(end) = address.checked_add(len) else {
return Some(Unreadable::Hole {
below_growsdown: false,
});
};
let mut next = address;
while next < end {
match mappings.iter().find(|mapping| mapping.end > next) {
Some(mapping) if mapping.start <= next => {
if !mapping.user_readable {
return Some(Unreadable::NoPermission);
}
next = mapping.end;
}
above => {
return Some(Unreadable::Hole {
below_growsdown: above.is_some_and(|mapping| mapping.growsdown),
});
}
}
}
None
}
fn orphaned_group_signals(sig: libc::c_int) -> u64 {
match sig {
libc::SIGSTOP | libc::SIGTSTP | libc::SIGTTIN | libc::SIGTTOU => {
kernel_sigset_bit(libc::SIGHUP) | kernel_sigset_bit(libc::SIGCONT)
}
_ => 0,
}
}
fn held_wake_ends_sleep(
state: &crate::syscalls::threads::KernelSignalState,
held_woken: KernelSigset,
) -> bool {
state.interrupting(state.blocked) & held_woken != 0
}
#[cfg(test)]
mod tests {
#[test]
fn a_first_probe_not_run_restarts_the_call() {
let restart = |result: Result<u64, Error>| restart_if_first_probe_not_run(result);
assert!(matches!(
restart(Err(Errno::ERESTARTSYS.into())),
Err(Error::Errno(Errno::ERESTARTNOINTR))
));
for errno in [
Errno::EFAULT,
Errno::EINVAL,
Errno::EINTR,
Errno::ERESTARTNOHAND,
] {
assert!(
matches!(restart(Err(errno.into())), Err(Error::Errno(e)) if e == errno),
"{errno} passes through"
);
}
assert!(matches!(restart(Ok(7)), Ok(7)));
}
use super::*;
fn timeval(seconds: libc::time_t, micros: libc::suseconds_t) -> libc::timeval {
libc::timeval {
tv_sec: seconds,
tv_usec: micros,
}
}
#[test]
fn rt_sigsuspend_never_sleeps_per_backend() {
use reverie::BackendCapabilities;
for (name, backend, never_sleeps) in [
("ptrace", BackendCapabilities::PTRACE, false),
("e9patch", BackendCapabilities::E9PATCH, false),
("kvm", BackendCapabilities::KVM, true),
("sabre", BackendCapabilities::SABRE, false),
("dbt", BackendCapabilities::DBT, false),
(
"liteinst in-guest",
BackendCapabilities::LITEINST_IN_GUEST,
false,
),
] {
assert_eq!(rt_sigsuspend_never_sleeps(&backend), never_sleeps, "{name}");
}
}
#[test]
fn only_a_default_stop_signal_arms_the_orphaned_group_signals() {
let hup_cont = kernel_sigset_bit(libc::SIGHUP) | kernel_sigset_bit(libc::SIGCONT);
for sig in 0..=65 {
let stops = matches!(
sig,
libc::SIGSTOP | libc::SIGTSTP | libc::SIGTTIN | libc::SIGTTOU
);
assert_eq!(
orphaned_group_signals(sig),
if stops { hup_cont } else { 0 },
"signal {sig}"
);
}
}
#[test]
fn a_held_wake_ends_a_sleep_only_when_unblocked_and_caught_or_fatal() {
use crate::syscalls::threads::KernelSignalState;
let chld = kernel_sigset_bit(libc::SIGCHLD);
let alrm = kernel_sigset_bit(libc::SIGALRM);
let state = |caught: KernelSigset, blocked: KernelSigset| KernelSignalState {
caught,
blocked,
..Default::default()
};
assert!(held_wake_ends_sleep(&state(chld, 0), chld));
assert!(!held_wake_ends_sleep(&state(chld, chld), chld));
assert!(!held_wake_ends_sleep(&state(0, 0), chld));
assert!(held_wake_ends_sleep(&state(0, 0), alrm));
assert!(!held_wake_ends_sleep(&state(0, alrm), alrm));
assert!(
!held_wake_ends_sleep(&state(chld, 0), 0),
"taken by a sibling"
);
}
#[test]
fn a_woken_sleep_counts_a_pending_sigchld_in_an_unusable_window() {
use crate::syscalls::threads::KernelSignalState;
let chld = kernel_sigset_bit(libc::SIGCHLD);
let state =
|caught: KernelSigset, blocked: KernelSigset, shared: KernelSigset| KernelSignalState {
caught,
blocked,
pending: shared,
shared_pending: shared,
..Default::default()
};
assert!(woken_sigchld_pending(&state(chld, 0, chld), chld));
assert!(
!woken_sigchld_pending(&state(chld, 0, 0), chld),
"another thread took it"
);
assert!(
!woken_sigchld_pending(&state(chld, chld, chld), chld),
"blocked"
);
assert!(
!woken_sigchld_pending(&state(0, 0, chld), chld),
"default, ignored"
);
assert!(
!woken_sigchld_pending(&state(chld, 0, chld), 0),
"host-timed SIGCHLD keeps it held"
);
let private = KernelSignalState {
caught: chld,
pending: chld,
thread_pending: chld,
..Default::default()
};
assert!(woken_sigchld_pending(&private, chld));
}
#[test]
fn a_claimed_sigchld_stays_claimed_while_pending() {
use crate::syscalls::threads::KernelSignalState;
let chld = kernel_sigset_bit(libc::SIGCHLD);
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let state = |blocked: KernelSigset, thread_pending: KernelSigset, shared: KernelSigset| {
Ok::<_, Errno>(KernelSignalState {
caught: chld | usr1,
blocked,
pending: thread_pending | shared,
thread_pending,
shared_pending: shared,
..Default::default()
})
};
assert!(claim_still_pending(true, || state(0, 0, chld)));
assert!(claim_still_pending(true, || state(0, chld, 0)));
assert!(
claim_still_pending(true, || state(chld | usr1, 0, chld)),
"inside the held SIGUSR1's handler, whose mask holds SIGCHLD"
);
assert!(
!claim_still_pending(true, || state(0, 0, usr1)),
"taken elsewhere"
);
assert!(
!claim_still_pending(true, || Err::<KernelSignalState, _>(Errno::ESRCH)),
"unreadable"
);
assert!(
!claim_still_pending(false, || -> Result<KernelSignalState, Errno> {
panic!("an unclaimed thread reads no state")
}),
"unclaimed"
);
}
#[test]
fn a_private_sigchld_sent_before_the_sleep_is_filed_ends_it_before_it_parks() {
use crate::syscalls::threads::KernelSignalState;
let chld = kernel_sigset_bit(libc::SIGCHLD);
let state = |blocked: KernelSigset, thread_pending: KernelSigset| KernelSignalState {
caught: chld,
blocked,
pending: thread_pending,
thread_pending,
..Default::default()
};
assert!(asks_committed_sigchld(0, &state(0, chld), chld));
assert!(!asks_committed_sigchld(0, &state(0, 0), chld));
assert!(
!asks_committed_sigchld(0, &state(0, chld), 0),
"a host-timed SIGCHLD source keeps it held"
);
assert_eq!(
committed_sigchld_verdict(&state(0, chld), 0, chld),
Some(SleepSignal::Pending)
);
assert_eq!(committed_sigchld_verdict(&state(chld, chld), 0, chld), None);
assert_eq!(committed_sigchld_verdict(&state(0, chld), 0, 0), None);
assert!(asks_committed_sigchld(chld, &state(0, 0), chld));
assert_eq!(
committed_sigchld_verdict(&state(0, chld), chld, chld),
Some(SleepSignal::Held)
);
}
#[test]
fn raw_kernel_signal_masks_are_exactly_one_u64() {
assert_eq!(KERNEL_SIGSET_SIZE, 8);
assert_eq!(std::mem::size_of::<KernelSigset>(), 8);
assert!(std::mem::size_of::<libc::sigset_t>() > KERNEL_SIGSET_SIZE);
}
#[test]
fn the_installed_mask_cannot_block_kill_or_stop() {
let kill = 1_u64 << (libc::SIGKILL - 1);
let stop = 1_u64 << (libc::SIGSTOP - 1);
assert_eq!(kernel_installed_signal_mask(u64::MAX), !(kill | stop));
assert_eq!(kernel_installed_signal_mask(kill | stop), 0);
let alrm_and_rt64 = (1_u64 << (libc::SIGALRM - 1)) | (1_u64 << 63);
assert_eq!(kernel_installed_signal_mask(alrm_and_rt64), alrm_and_rt64);
}
#[test]
fn raw_signal_size_validation_rejects_before_pointer_processing() {
assert_eq!(validate_kernel_sigset_size(7), Err(Errno::EINVAL));
assert_eq!(validate_kernel_sigset_size(8), Ok(()));
assert_eq!(validate_kernel_sigset_size(16), Err(Errno::EINVAL));
}
#[test]
fn reserved_signal_is_removed_from_the_kernel_sized_mask_only() {
let reserved = 1_u64 << (reverie::PERF_EVENT_SIGNAL as u32 - 1);
let usr1 = 1_u64 << (libc::SIGUSR1 as u32 - 1);
assert_eq!(without_perf_event_signal(reserved | usr1), usr1);
assert_eq!(without_perf_event_signal(usr1), usr1);
}
#[test]
fn timeval_conversion_preserves_subsecond_precision() {
let logical_time =
timeval_to_logical_time(timeval(2, 345_678)).expect("valid timeval should convert");
assert_eq!(
logical_time,
LogicalTime::from_nanos(2_345_678_000),
"timeval conversion should preserve microsecond precision"
);
let round_trip = logical_time_to_timeval(logical_time);
assert_eq!(round_trip.tv_sec, 2, "round trip should preserve seconds");
assert_eq!(
round_trip.tv_usec, 345_678,
"round trip should preserve microseconds"
);
}
#[test]
fn timeval_conversion_rejects_invalid_values() {
for invalid in [
timeval(-1, 0),
timeval(0, -1),
timeval(0, 1_000_000),
timeval(libc::time_t::MAX, 0),
] {
assert_eq!(
timeval_to_logical_time(invalid),
Err(Errno::EINVAL),
"invalid timeval should return EINVAL"
);
}
}
#[test]
fn alarm_seconds_round_as_linux_does() {
assert_eq!(linux_alarm_seconds(LogicalTime::ZERO), 0);
assert_eq!(linux_alarm_seconds(LogicalTime::from_nanos(1)), 1);
assert_eq!(linux_alarm_seconds(LogicalTime::from_nanos(1_000)), 1);
assert_eq!(
linux_alarm_seconds(LogicalTime::from_nanos(1_000_000_000)),
1
);
assert_eq!(
linux_alarm_seconds(LogicalTime::from_nanos(1_499_999_999)),
1
);
assert_eq!(
linux_alarm_seconds(LogicalTime::from_nanos(1_500_000_000)),
2
);
assert_eq!(
linux_alarm_seconds(LogicalTime::from_nanos(2_000_000_001)),
2
);
}
#[test]
fn alarm_remaining_seconds_round_up() {
assert_eq!(logical_time_to_alarm_seconds(LogicalTime::ZERO), 0);
assert_eq!(logical_time_to_alarm_seconds(LogicalTime::from_nanos(1)), 1);
assert_eq!(
logical_time_to_alarm_seconds(LogicalTime::from_nanos(999_999_999)),
1
);
assert_eq!(
logical_time_to_alarm_seconds(LogicalTime::from_nanos(1_000_000_000)),
1
);
assert_eq!(
logical_time_to_alarm_seconds(LogicalTime::from_nanos(1_000_000_001)),
2
);
}
#[test]
fn kill_targets_only_unambiguous_process_delivery() {
let first = DetTid::from_raw(42);
let second = DetTid::from_raw(43);
assert_eq!(
deterministic_kill_target(&[], None, libc::SIGUSR1),
Err(Errno::ESRCH)
);
assert_eq!(
deterministic_kill_target(&[], Some(true), libc::SIGUSR1),
Ok(None)
);
assert_eq!(
deterministic_kill_target(&[], Some(false), libc::SIGUSR1),
Err(Errno::ESRCH)
);
assert_eq!(
deterministic_kill_target(&[first], None, libc::SIGUSR1),
Ok(Some(first))
);
assert_eq!(
deterministic_kill_target(&[first, second], None, libc::SIGUSR1),
Err(Errno::ENOSYS)
);
assert_eq!(
deterministic_kill_target(&[first, second], None, 0),
Ok(Some(first))
);
let process = DetPid::from_raw(41);
assert!(self_sigkill_targets_current_task(
libc::SIGKILL,
Some(process),
None,
process,
first,
));
assert!(self_sigkill_targets_current_task(
libc::SIGKILL,
None,
Some(first),
process,
first,
));
assert!(self_sigkill_targets_current_task(
libc::SIGKILL,
Some(process),
Some(first),
process,
first,
));
for (signal, target_process, target_thread) in [
(libc::SIGTERM, Some(process), Some(first)),
(libc::SIGKILL, Some(DetPid::from_raw(40)), Some(first)),
(libc::SIGKILL, Some(process), Some(second)),
(libc::SIGKILL, None, None),
] {
assert!(!self_sigkill_targets_current_task(
signal,
target_process,
target_thread,
process,
first,
));
}
}
#[test]
fn process_group_forwarding_is_limited_to_unmaskable_sigkill() {
assert!(can_forward_process_group_signal(-42, libc::SIGKILL, false));
assert!(!can_forward_process_group_signal(-42, libc::SIGTERM, false));
assert!(!can_forward_process_group_signal(0, libc::SIGKILL, false));
assert!(!can_forward_process_group_signal(-1, libc::SIGKILL, false));
assert!(!can_forward_process_group_signal(-42, libc::SIGKILL, true));
}
#[test]
fn signal_zero_never_notifies_a_target() {
let sender = DetTid::from_raw(42);
let target = DetTid::from_raw(43);
assert!(!should_notify_cross_task_signal(sender, target, 0));
assert!(should_notify_cross_task_signal(
sender,
target,
libc::SIGUSR1
));
assert!(!should_notify_cross_task_signal(
sender,
sender,
libc::SIGUSR1
));
}
}
#[cfg(test)]
mod appropriated_signal_tests {
use super::*;
#[test]
fn the_appropriated_set_is_exactly_sigtrap_and_sigstkflt() {
let signums: Vec<i32> = APPROPRIATED_SIGNALS.iter().map(|(s, _)| *s).collect();
assert_eq!(signums, vec![libc::SIGTRAP, libc::SIGSTKFLT]);
assert_eq!(libc::SIGSTKFLT, reverie::PERF_EVENT_SIGNAL as i32);
}
#[test]
fn only_a_real_handler_is_reported() {
for signum in [libc::SIGTRAP, libc::SIGSTKFLT] {
assert!(!reports(signum, 0), "SIG_DFL must not warn");
assert!(!reports(signum, 1), "SIG_IGN must not warn");
assert!(reports(signum, 0x4000_1234), "a real handler must warn");
}
}
#[test]
fn an_unappropriated_signal_is_never_reported() {
for signum in [libc::SIGUSR1, libc::SIGTERM, libc::SIGINT, 10, 30] {
assert!(
!reports(signum, 0x4000_1234),
"signal {signum} is not appropriated"
);
}
}
fn reports(signum: i32, handler: u64) -> bool {
appropriated_reason(signum, handler).is_some()
}
}
#[cfg(test)]
mod rt_sigsuspend_tests {
use reverie::GlobalRPC;
use reverie::GlobalTool;
use reverie::Pid;
use reverie::Tool;
use reverie::syscalls::LocalMemory;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallInfo;
use super::*;
use crate::Config;
use crate::GlobalState;
use crate::ThreadState;
use crate::syscalls::threads::kernel_sigset_bit;
const ARENA_WORDS: usize = 64;
const STACK_WORD: usize = 48;
const COPY_WORD: usize = STACK_WORD - STACK_RED_ZONE / 8 - 1;
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!("rt_sigsuspend takes no scratch stack")
}
fn capacity(&self) -> usize {
panic!("rt_sigsuspend takes no scratch stack")
}
fn push<'stack, T>(&mut self, _: T) -> Addr<'stack, T> {
panic!("rt_sigsuspend takes no scratch stack")
}
fn reserve<'stack, T>(&mut self) -> AddrMut<'stack, T> {
panic!("rt_sigsuspend takes no scratch stack")
}
fn commit(self) -> Result<Self::StackGuard, Errno> {
panic!("rt_sigsuspend takes no scratch stack")
}
}
struct SuspendGuest {
config: Config,
thread: ThreadState<()>,
arena: Box<[u64; ARENA_WORDS]>,
caller_mask: usize,
rewritten: Option<KernelSigset>,
suspended_under: Vec<KernelSigset>,
}
#[reverie::tool]
impl GlobalRPC<GlobalState> for SuspendGuest {
async fn send_rpc(
&self,
message: <GlobalState as GlobalTool>::Request,
) -> <GlobalState as GlobalTool>::Response {
panic!(
"an unsequentialized rt_sigsuspend sends no RPC: {:?}",
message.2
)
}
fn config(&self) -> &Config {
&self.config
}
}
#[reverie::tool]
impl Guest<Detcore> for SuspendGuest {
type Memory = LocalMemory;
type Stack = NoStack;
fn tid(&self) -> Pid {
Pid::from_raw(1)
}
fn pid(&self) -> Pid {
Pid::from_raw(1)
}
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 mut regs: libc::user_regs_struct = unsafe { std::mem::zeroed() };
regs.rsp = (self.arena.as_ptr() as usize + STACK_WORD * 8) as u64;
regs
}
async fn stack(&mut self) -> Self::Stack {
NoStack
}
async fn daemonize(&mut self) {
panic!("rt_sigsuspend must not daemonize")
}
async fn inject<S: SyscallInfo>(&mut self, syscall: S) -> Result<i64, Errno> {
let (number, args) = syscall.into_parts();
match Syscall::from_raw(number, args) {
Syscall::RtSigprocmask(call) if call.how() == -1 => Err(Errno::EINVAL),
Syscall::RtSigpending(call) => {
let set = call.set().expect("rt_sigpending without a set");
LocalMemory::new().write_value(set.cast::<KernelSigset>(), &0)?;
if let Some(rewritten) = self.rewritten {
unsafe {
std::ptr::write(self.caller_mask as *mut KernelSigset, rewritten)
};
}
Ok(0)
}
Syscall::RtSigsuspend(call) => {
let mask = call.mask().expect("rt_sigsuspend without a mask");
self.suspended_under
.push(LocalMemory::new().read_value(mask.cast::<KernelSigset>())?);
Err(Errno::EINTR)
}
other => panic!("rt_sigsuspend injected {other:?}"),
}
}
async fn tail_inject<S: SyscallInfo>(&mut self, _: S) -> reverie::Never {
panic!("rt_sigsuspend must not retire the guest")
}
fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("rt_sigsuspend must not set a timer")
}
fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("rt_sigsuspend must not set a timer")
}
fn read_clock(&mut self) -> Result<u64, Error> {
panic!("rt_sigsuspend must not read a clock")
}
}
#[tokio::test(flavor = "current_thread")]
async fn rt_sigsuspend_sleeps_under_the_mask_detcore_read() {
let config = Config::default();
assert!(!config.sequentialize_threads);
let tool = <Detcore as Tool>::new(Pid::from_raw(1), &config);
let unblocks_sigchld: KernelSigset = kernel_sigset_bit(libc::SIGUSR2);
let blocks_sigchld = unblocks_sigchld | kernel_sigset_bit(libc::SIGCHLD);
let mut caller_mask: Box<KernelSigset> = Box::new(unblocks_sigchld);
let caller_address = &mut *caller_mask as *mut KernelSigset as usize;
let mut guest = SuspendGuest {
thread: ThreadState::new(DetPid::from_raw(1), &config, ()),
config: config.clone(),
arena: Box::new([u64::MAX; ARENA_WORDS]),
caller_mask: caller_address,
rewritten: Some(blocks_sigchld),
suspended_under: Vec::new(),
};
let call = syscalls::RtSigsuspend::new()
.with_mask(Addr::from_raw(caller_address))
.with_sigsetsize(KERNEL_SIGSET_SIZE);
let result = tool.handle_rt_sigsuspend(&mut guest, call).await;
assert!(
matches!(result, Err(Error::Errno(Errno::EINTR))),
"{result:?}"
);
assert_eq!(*caller_mask, blocks_sigchld, "the buffer was rewritten");
assert_eq!(guest.suspended_under, [unblocks_sigchld]);
}
#[tokio::test(flavor = "current_thread")]
async fn rt_sigsuspend_scratch_never_lands_on_the_callers_mask() {
let config = Config::default();
let tool = <Detcore as Tool>::new(Pid::from_raw(1), &config);
let original: KernelSigset = kernel_sigset_bit(libc::SIGUSR2);
let rewritten = original | kernel_sigset_bit(libc::SIGCHLD);
for (slot, peer_rewrite) in [(COPY_WORD, Some(rewritten)), (COPY_WORD - 1, None)] {
let mut arena = Box::new([u64::MAX; ARENA_WORDS]);
arena[slot] = original;
let caller_address = &mut arena[slot] as *mut u64 as usize;
let mut guest = SuspendGuest {
thread: ThreadState::new(DetPid::from_raw(1), &config, ()),
config: config.clone(),
arena,
caller_mask: caller_address,
rewritten: peer_rewrite,
suspended_under: Vec::new(),
};
let call = syscalls::RtSigsuspend::new()
.with_mask(Addr::from_raw(caller_address))
.with_sigsetsize(KERNEL_SIGSET_SIZE);
let result = tool.handle_rt_sigsuspend(&mut guest, call).await;
assert!(
matches!(result, Err(Error::Errno(Errno::EINTR))),
"slot {slot}: {result:?}"
);
assert_eq!(guest.suspended_under, [original], "slot {slot}");
assert_eq!(
guest.arena[slot],
peer_rewrite.unwrap_or(original),
"slot {slot}: the caller's buffer holds only what the guest wrote"
);
}
}
}
#[cfg(test)]
mod before_park_tests {
use reverie::GlobalRPC;
use reverie::GlobalTool;
use reverie::Pid;
use reverie::syscalls::SyscallInfo;
use super::*;
use crate::Config;
use crate::GlobalState;
use crate::ThreadState;
use crate::scheduler::child_exit_sigchld::ChildExitSigchldControl;
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!("the before-park check takes no stack")
}
fn capacity(&self) -> usize {
panic!("the before-park check takes no stack")
}
fn push<'stack, T>(&mut self, _: T) -> Addr<'stack, T> {
panic!("the before-park check takes no stack")
}
fn reserve<'stack, T>(&mut self) -> AddrMut<'stack, T> {
panic!("the before-park check takes no stack")
}
fn commit(self) -> Result<Self::StackGuard, Errno> {
panic!("the before-park check takes no stack")
}
}
struct SleeperGuest<'a> {
state: &'a GlobalState,
config: Config,
thread: ThreadState<()>,
pid: Pid,
}
#[reverie::tool]
impl GlobalRPC<GlobalState> for SleeperGuest<'_> {
async fn send_rpc(
&self,
request: <GlobalState as GlobalTool>::Request,
) -> <GlobalState as GlobalTool>::Response {
self.state.receive_rpc(self.pid, request).await
}
fn config(&self) -> &Config {
&self.config
}
}
#[reverie::tool]
impl Guest<Detcore> for SleeperGuest<'_> {
type Memory = reverie::syscalls::LocalMemory;
type Stack = NoStack;
fn tid(&self) -> Pid {
self.pid
}
fn pid(&self) -> Pid {
self.pid
}
fn ppid(&self) -> Option<Pid> {
None
}
fn memory(&self) -> Self::Memory {
panic!("the before-park check reads no guest memory")
}
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 {
panic!("the before-park check reads no registers")
}
async fn stack(&mut self) -> Self::Stack {
panic!("the before-park check takes no stack")
}
async fn daemonize(&mut self) {
panic!("the before-park check must not daemonize")
}
async fn inject<S: SyscallInfo>(&mut self, _: S) -> Result<i64, Errno> {
panic!("the before-park check injects no syscall")
}
async fn tail_inject<S: SyscallInfo>(&mut self, _: S) -> reverie::Never {
panic!("the before-park check must not retire the guest")
}
fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("the before-park check sets no timer")
}
fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("the before-park check sets no timer")
}
fn read_clock(&mut self) -> Result<u64, Error> {
panic!("the before-park check reads no clock")
}
}
extern "C" fn caught(_: libc::c_int) {}
fn wait_for(
child: libc::pid_t,
options: libc::c_int,
) -> Result<(libc::pid_t, libc::c_int), i32> {
let mut status = 0;
loop {
let waited = unsafe { libc::waitpid(child, &mut status, options) };
if waited != -1 {
return Ok((waited, status));
}
match std::io::Error::last_os_error().raw_os_error() {
Some(libc::EINTR) => continue,
errno => return Err(errno.unwrap_or(0)),
}
}
}
struct ChildOwner {
pid: libc::pid_t,
reaped: bool,
}
impl ChildOwner {
fn wait_stopped(&mut self) -> Result<(), Result<(libc::pid_t, libc::c_int), i32>> {
let waited = wait_for(self.pid, libc::WUNTRACED);
match waited {
Ok((pid, status))
if pid == self.pid
&& (libc::WIFEXITED(status) || libc::WIFSIGNALED(status)) =>
{
self.reaped = true;
}
Err(libc::ECHILD) => self.reaped = true,
_ => {}
}
match waited {
Ok((pid, status)) if pid == self.pid && libc::WIFSTOPPED(status) => Ok(()),
other => Err(other),
}
}
fn disarmed_after_reap(&mut self) -> bool {
std::mem::replace(&mut self.reaped, true)
}
fn kill_and_reap(&mut self) -> Result<(libc::pid_t, libc::c_int), i32> {
unsafe { libc::kill(self.pid, libc::SIGKILL) };
let reaped = wait_for(self.pid, 0);
self.reaped = true;
reaped
}
fn finish(mut self) {
let reaped = self.kill_and_reap();
assert!(
matches!(reaped, Ok((pid, status)) if pid == self.pid
&& libc::WIFSIGNALED(status)
&& libc::WTERMSIG(status) == libc::SIGKILL),
"the child was not reaped: {reaped:?}"
);
}
}
impl Drop for ChildOwner {
fn drop(&mut self) {
if !self.reaped {
let _ = self.kill_and_reap();
}
}
}
fn forked_child(exits: bool) -> ChildOwner {
let child = unsafe { libc::fork() };
if child == 0 {
unsafe {
if exits {
libc::_exit(7);
}
let mut action: libc::sigaction = std::mem::zeroed();
action.sa_sigaction = caught as extern "C" fn(libc::c_int) as usize;
libc::sigaction(libc::SIGCHLD, &action, std::ptr::null_mut());
let mut set: libc::sigset_t = std::mem::zeroed();
libc::sigemptyset(&mut set);
libc::sigaddset(&mut set, libc::SIGCHLD);
libc::pthread_sigmask(libc::SIG_UNBLOCK, &set, std::ptr::null_mut());
libc::raise(libc::SIGSTOP);
libc::_exit(0);
}
}
assert!(child > 0, "fork failed");
ChildOwner {
pid: child,
reaped: false,
}
}
fn stopped_child_with_a_private_sigchld() -> ChildOwner {
let mut owner = forked_child(false);
let child = owner.pid;
if let Err(waited) = owner.wait_stopped() {
panic!("the child did not stop: {waited:?}");
}
let sent = unsafe { libc::syscall(libc::SYS_tgkill, child, child, libc::SIGCHLD) };
assert_eq!(sent, 0, "tgkill failed");
owner
}
#[tokio::test(flavor = "current_thread")]
async fn a_private_sigchld_committed_before_the_sleep_is_filed_ends_it_through_the_ledger() {
let mut exited = forked_child(true);
let wait = exited.wait_stopped();
let exit_reaped = matches!(wait, Err(Ok((pid, status))) if pid == exited.pid
&& libc::WIFEXITED(status)
&& libc::WEXITSTATUS(status) == 7);
let disarmed = exit_reaped && exited.disarmed_after_reap();
assert!(exit_reaped, "{wait:?}");
assert!(disarmed, "a reaped child disarms its owner");
drop(exited);
let mut gone = forked_child(true);
let reaped_elsewhere = wait_for(gone.pid, 0);
gone.reaped = matches!(reaped_elsewhere, Ok((pid, _)) if pid == gone.pid)
|| reaped_elsewhere == Err(libc::ECHILD);
assert!(
matches!(reaped_elsewhere, Ok((pid, _)) if pid == gone.pid),
"{reaped_elsewhere:?}"
);
gone.reaped = false;
let wait = gone.wait_stopped();
let disarmed = gone.disarmed_after_reap();
assert_eq!(wait, Err(Err(libc::ECHILD)));
assert!(disarmed, "an ECHILD disarms its owner");
drop(gone);
let owner = stopped_child_with_a_private_sigchld();
let child = owner.pid;
let state_of_child = crate::syscalls::threads::read_thread_wait_signal_state(
Pid::from_raw(child),
Pid::from_raw(child),
)
.expect("the child's signal state");
let chld = kernel_sigset_bit(libc::SIGCHLD);
assert_eq!(
state_of_child.thread_pending & chld,
chld,
"pending, private"
);
assert_eq!(state_of_child.blocked & chld, 0, "unblocked");
assert_eq!(state_of_child.caught & chld, chld, "caught");
let mut verdicts = Vec::new();
for committed in [true, false] {
let config = Config {
sequentialize_threads: true,
..Config::default()
}
.with_backend(|backend| {
backend.supports_blocked_wait_signal_interruption = true;
backend.delivers_preemption_timer_events = false;
backend.runs_guest_code_between_injections = false;
});
let state = GlobalState::for_tests(&config);
let mut guest = SleeperGuest {
state: &state,
thread: ThreadState::new(DetPid::from_raw(child), &config, ()),
config,
pid: Pid::from_raw(child),
};
if committed {
let target = guest.thread_state().dettid;
crate::tool_global::child_exit_sigchld(
&mut guest,
ChildExitSigchldControl::PrivateSent { target },
)
.await;
}
verdicts.push(sleep_signal(&mut guest, SleepCheck::BeforePark, false).await);
}
owner.finish();
assert!(
matches!(verdicts[0], Ok(SleepSignal::Pending)),
"committed: {:?}",
verdicts[0]
);
assert!(
matches!(verdicts[1], Ok(SleepSignal::None)),
"not committed: {:?}",
verdicts[1]
);
}
#[tokio::test(flavor = "current_thread")]
async fn a_private_sigchld_committed_before_a_futex_wait_parks_ends_it_through_the_ledger() {
let owner = stopped_child_with_a_private_sigchld();
let child = owner.pid;
let state = crate::syscalls::threads::read_thread_wait_signal_state(
Pid::from_raw(child),
Pid::from_raw(child),
)
.expect("the child's signal state");
let chld = kernel_sigset_bit(libc::SIGCHLD);
let interrupting = state.pending_interrupting(state.blocked, false);
let mut pending = Vec::new();
for (committed, host_timed) in [(true, 0), (false, 0), (true, chld)] {
let config = Config {
sequentialize_threads: true,
..Config::default()
}
.with_backend(|backend| {
backend.supports_blocked_wait_signal_interruption = true;
backend.delivers_preemption_timer_events = false;
backend.runs_guest_code_between_injections = false;
});
let global = GlobalState::for_tests(&config);
let mut guest = SleeperGuest {
state: &global,
thread: ThreadState::new(DetPid::from_raw(child), &config, ()),
config,
pid: Pid::from_raw(child),
};
if committed {
let target = guest.thread_state().dettid;
crate::tool_global::child_exit_sigchld(
&mut guest,
ChildExitSigchldControl::PrivateSent { target },
)
.await;
}
let held = crate::syscalls::threads::futex_wait_held_after_wake(host_timed, 0);
pending.push(
crate::syscalls::threads::futex_wait_pending_signals(
&mut guest,
&state,
interrupting,
held,
host_timed,
0,
)
.await,
);
}
owner.finish();
assert_eq!(interrupting & chld, chld, "pending, unblocked and caught");
assert_eq!(
pending,
vec![chld, 0, 0],
"recorded, unrecorded, host-timed"
);
}
#[tokio::test(flavor = "current_thread")]
async fn a_futex_waits_check_after_a_wake_needs_the_private_copy_and_its_record() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
let state = |thread: KernelSigset, shared: KernelSigset| {
crate::syscalls::threads::KernelSignalState {
pending: thread | shared,
thread_pending: thread,
shared_pending: shared,
caught: chld,
..Default::default()
}
};
let mut answers = Vec::new();
for (name, kernel, recorded, flushed) in [
("private, recorded", state(chld, 0), true, false),
("flushed, shared only", state(0, chld), true, true),
("recorded, shared only", state(0, chld), true, false),
] {
let config = Config {
sequentialize_threads: true,
..Config::default()
}
.with_backend(|backend| {
backend.supports_blocked_wait_signal_interruption = true;
backend.delivers_preemption_timer_events = false;
backend.runs_guest_code_between_injections = false;
});
let global = GlobalState::for_tests(&config);
let mut guest = SleeperGuest {
state: &global,
thread: ThreadState::new(DetPid::from_raw(4242), &config, ()),
config,
pid: Pid::from_raw(4242),
};
let target = guest.thread_state().dettid;
if recorded {
crate::tool_global::child_exit_sigchld(
&mut guest,
ChildExitSigchldControl::PrivateSent { target },
)
.await;
}
if flushed {
crate::tool_global::child_exit_sigchld(
&mut guest,
ChildExitSigchldControl::Flushed,
)
.await;
}
let held = crate::syscalls::threads::futex_wait_held_after_wake(0, 0);
let interrupting = kernel.pending_interrupting(kernel.blocked, false);
let pending = crate::syscalls::threads::futex_wait_pending_signals(
&mut guest,
&kernel,
interrupting,
held,
0,
0,
)
.await;
answers.push((name, pending));
}
assert_eq!(
answers,
vec![
("private, recorded", chld),
("flushed, shared only", 0),
("recorded, shared only", 0),
]
);
}
#[tokio::test(flavor = "current_thread")]
async fn a_shared_sigchld_after_a_flush_does_not_end_a_drain_woken_futex_wait() {
let mut owner = forked_child(false);
let child = owner.pid;
if let Err(waited) = owner.wait_stopped() {
panic!("the child did not stop: {waited:?}");
}
assert_eq!(
unsafe { libc::kill(child, libc::SIGCHLD) },
0,
"kill failed"
);
let state = crate::syscalls::threads::read_thread_wait_signal_state(
Pid::from_raw(child),
Pid::from_raw(child),
)
.expect("the child's signal state");
let chld = kernel_sigset_bit(libc::SIGCHLD);
let mut pending = Vec::new();
for committed_wake in [0, chld] {
let config = Config {
sequentialize_threads: true,
..Config::default()
}
.with_backend(|backend| {
backend.supports_blocked_wait_signal_interruption = true;
backend.delivers_preemption_timer_events = false;
backend.runs_guest_code_between_injections = false;
});
let global = GlobalState::for_tests(&config);
let mut guest = SleeperGuest {
state: &global,
thread: ThreadState::new(DetPid::from_raw(child), &config, ()),
config,
pid: Pid::from_raw(child),
};
let target = guest.thread_state().dettid;
crate::tool_global::child_exit_sigchld(
&mut guest,
ChildExitSigchldControl::PrivateSent { target },
)
.await;
crate::tool_global::child_exit_sigchld(&mut guest, ChildExitSigchldControl::Flushed)
.await;
let held = crate::syscalls::threads::futex_wait_held_after_wake(0, committed_wake);
pending.push(
crate::syscalls::threads::futex_wait_pending_signals(
&mut guest,
&state,
state.pending_interrupting(state.blocked, false),
held,
0,
committed_wake,
)
.await,
);
}
owner.finish();
assert_eq!(
(state.thread_pending & chld, state.shared_pending & chld),
(0, chld),
"SIGCHLD pending in the shared queue only"
);
assert_eq!(pending, vec![0, chld], "stripped, then committed as before");
}
}
#[cfg(test)]
mod own_process_signal_tests {
use super::*;
const SENDER_SIBLING: i32 = 11;
fn admitted_s1() -> OwnProcessSignal {
OwnProcessSignal {
sig: libc::SIGUSR1,
names_sender: true,
caught: kernel_sigset_bit(libc::SIGUSR1),
inputs: OwnProcessSignalInputs {
siblings: vec![(
DetTid::from_raw(SENDER_SIBLING),
SiblingSignalState::InSchedule(Some(0)),
)],
..Default::default()
},
..Default::default()
}
}
fn refusal(edit: impl FnOnce(&mut OwnProcessSignal)) -> Option<OwnProcessSignalRefusal> {
let mut send = admitted_s1();
edit(&mut send);
own_process_signal_refusal(&send)
}
#[test]
fn the_first_user_unreadable_byte_is_classified_by_its_mapping() {
let smaps = "1000-2000 r--p 0 0:0 0\nVmFlags: rd mr\n\
2000-3000 -w-p 0 0:0 0\nVmFlags: wr mw\n\
3000-4000 ---p 0 0:0 0\nVmFlags: mr\n\
6000-7000 --xp 0 0:0 0 [vvar]\nVmFlags: ex\n\
9000-a000 rw-p 0 0:0 0 [stack]\nVmFlags: rd wr gd\n";
let mappings = parse_smaps(smaps);
assert_eq!(mappings.len(), 5);
assert!(mappings[4].growsdown && !mappings[0].growsdown);
assert_eq!(
first_user_unreadable(&mappings, 0x1fc0, 128),
None,
"crosses from read-only into write-only"
);
assert_eq!(
first_user_unreadable(&mappings, 0x6000, 128),
None,
"execute-only"
);
assert_eq!(
first_user_unreadable(&mappings, 0x2fc0, 128),
Some(Unreadable::NoPermission),
"runs into PROT_NONE"
);
assert_eq!(
first_user_unreadable(&mappings, 0x4000, 48),
Some(Unreadable::Hole {
below_growsdown: false
}),
"a hole below a fixed mapping"
);
assert_eq!(
first_user_unreadable(&mappings, 0x8000, 48),
Some(Unreadable::Hole {
below_growsdown: true
}),
"a hole below the stack"
);
assert_eq!(
first_user_unreadable(&mappings, 0xb000, 48),
Some(Unreadable::Hole {
below_growsdown: false
}),
"above every mapping"
);
assert_eq!(
first_user_unreadable(&mappings, 0, 48),
Some(Unreadable::Hole {
below_growsdown: false
})
);
assert_eq!(
first_user_unreadable(&mappings, usize::MAX - 10, 48),
Some(Unreadable::Hole {
below_growsdown: false
})
);
}
#[test]
fn the_sender_named_by_its_call_is_admitted_whatever_its_siblings_masks() {
assert_eq!(refusal(|_| {}), None);
}
#[test]
fn another_sender_is_admitted_only_when_every_live_sibling_blocks() {
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let leader = DetTid::from_raw(SENDER_SIBLING);
assert_eq!(
refusal(|send| send.names_sender = false),
Some(OwnProcessSignalRefusal::NotSoleReceiver(leader))
);
assert_eq!(
refusal(|send| {
send.names_sender = false;
send.inputs.siblings = vec![(leader, SiblingSignalState::InSchedule(Some(usr1)))];
}),
None
);
assert_eq!(
refusal(|send| {
send.names_sender = false;
send.inputs.siblings = vec![(leader, SiblingSignalState::ExitGranted)];
}),
None
);
}
#[test]
fn only_the_seven_signals_below_sigchld_are_admitted() {
for sig in 1..=64 {
let admitted = OWN_PROCESS_SIGNALS.contains(&sig);
let got = refusal(|send| {
send.sig = sig;
send.caught = kernel_sigset_bit(sig);
});
if admitted {
assert!(sig < libc::SIGCHLD, "signal {sig}");
assert_eq!(got, None, "signal {sig}");
} else {
assert_eq!(
got,
Some(OwnProcessSignalRefusal::SignalNotAdmitted),
"signal {sig}"
);
}
}
for sig in [
libc::SIGCHLD,
libc::SIGCONT,
libc::SIGTSTP,
libc::SIGRTMIN(),
libc::SIGSEGV,
libc::SIGTRAP,
libc::SIGSTKFLT,
libc::SIGKILL,
libc::SIGALRM,
] {
assert!(!OWN_PROCESS_SIGNALS.contains(&sig), "signal {sig}");
}
}
#[test]
fn a_default_disposition_is_refused_and_sig_ign_is_admitted() {
assert_eq!(
refusal(|send| send.caught = 0),
Some(OwnProcessSignalRefusal::DefaultDisposition)
);
assert_eq!(
refusal(|send| {
send.caught = 0;
send.ignored = kernel_sigset_bit(libc::SIGUSR1);
}),
None
);
}
#[test]
fn each_mode_and_sender_state_refuses_by_name() {
use OwnProcessSignalRefusal as R;
let sibling = DetTid::from_raw(SENDER_SIBLING);
assert_eq!(
refusal(|send| send.record_replay = true),
Some(R::RecordReplay)
);
assert_eq!(
refusal(|send| send.schedule_replay = true),
Some(R::ScheduleReplay)
);
assert_eq!(
refusal(|send| send.inputs.guest_marker_signal = true),
Some(R::GuestMarkerSignal)
);
assert_eq!(
refusal(|send| send.stacktrace_signal = true),
Some(R::StacktraceSignal)
);
assert_eq!(
refusal(|send| send.blocked = kernel_sigset_bit(libc::SIGUSR1)),
Some(R::SenderBlocks)
);
assert_eq!(
refusal(|send| send.inputs.siblings[0].1 = SiblingSignalState::OutOfSchedule),
Some(R::OutOfSchedule(sibling))
);
assert_eq!(
refusal(|send| send.inputs.siblings[0].1 = SiblingSignalState::InSchedule(None)),
Some(R::UnknownMask(sibling))
);
assert_eq!(
refusal(|send| send.posthook_anchor = true),
Some(R::PosthookAnchor)
);
assert_eq!(refusal(|send| send.signalfd = true), Some(R::Signalfd));
assert_eq!(
refusal(|send| send.inputs.exec_in_flight = true),
Some(R::ExecInFlight)
);
}
#[test]
fn a_private_pending_signal_refuses_unless_blocked_or_the_timer_marker() {
let hup = kernel_sigset_bit(libc::SIGHUP);
let marker = kernel_sigset_bit(reverie::PERF_EVENT_SIGNAL as i32);
assert_eq!(
refusal(|send| send.thread_pending = hup),
Some(OwnProcessSignalRefusal::PrivatePending(hup))
);
assert_eq!(
refusal(|send| {
send.thread_pending = hup;
send.blocked = hup;
}),
None
);
assert_eq!(refusal(|send| send.thread_pending = marker), None);
}
#[test]
fn armed_sources_refuse_unless_the_sender_blocks_them() {
let io = kernel_sigset_bit(libc::SIGIO);
let usr2 = kernel_sigset_bit(libc::SIGUSR2);
assert_eq!(
refusal(|send| send.inputs.host_timed = io),
Some(OwnProcessSignalRefusal::HostTimedSource(io))
);
assert_eq!(
refusal(|send| {
send.inputs.host_timed = io;
send.blocked = io;
}),
None
);
assert_eq!(
refusal(|send| send.inputs.foreign_exit_signals = usr2),
Some(OwnProcessSignalRefusal::ForeignExitSignal(usr2))
);
assert_eq!(
refusal(|send| {
send.inputs.foreign_exit_signals = usr2;
send.blocked = usr2;
}),
None
);
}
#[test]
fn an_undelivered_scheduler_signal_refuses_only_at_or_below_the_sent_one() {
let term = libc::SIGTERM;
for (pending, refuses) in [
(libc::SIGHUP, true),
(libc::SIGALRM, true),
(libc::SIGTERM, true),
(libc::SIGSTKFLT, false),
(libc::SIGRTMIN(), false),
] {
let bit = kernel_sigset_bit(pending);
let got = refusal(|send| {
send.sig = term;
send.caught = kernel_sigset_bit(term);
send.inputs.undelivered_scheduler_signals = bit;
});
assert_eq!(
got,
refuses.then_some(OwnProcessSignalRefusal::UndeliveredSchedulerSignal(bit)),
"pending {pending}"
);
}
}
}