use std::num::NonZeroUsize;
use std::time::Duration;
use async_trait::async_trait;
use reverie::Errno;
use reverie::Error;
use reverie::Guest;
use reverie::MaskChangeRefused;
use reverie::Stack;
use reverie::syscalls;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::Displayable;
use reverie::syscalls::MapFlags;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::ProtFlags;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallInfo;
use reverie::syscalls::Sysno;
use reverie::syscalls::Timespec;
use reverie::syscalls::WaitPidFlag;
use crate::fd::FdType;
use crate::record_or_replay::RecordOrReplay;
use crate::resources::ExternalOpId;
use crate::resources::Permission;
use crate::resources::ResourceID;
use crate::resources::Resources;
use crate::syscalls::threads::BlockedWaitSignalError;
use crate::syscalls::threads::KERNEL_SIGSET_SIZE;
use crate::syscalls::threads::KernelSigaction;
use crate::syscalls::threads::KernelSignalState;
use crate::syscalls::threads::KernelSigset;
use crate::syscalls::threads::SignalQueue;
use crate::syscalls::threads::WaitSignalDisposition;
use crate::syscalls::threads::block_signals_for_disposition;
use crate::syscalls::threads::blocked_signal_mask;
use crate::syscalls::threads::kernel_sigset_bit;
use crate::syscalls::threads::read_thread_wait_signal_state;
use crate::syscalls::threads::read_wait_signal_state;
use crate::syscalls::threads::restore_signals_after_disposition;
use crate::syscalls::threads::wait_signal_disposition;
use crate::tool_global::ResumeStatus;
use crate::tool_global::host_timed_signals;
use crate::tool_global::resource_request;
use crate::tool_global::thread_observe_time;
use crate::tool_global::trace_schedevent;
use crate::tool_local::Detcore;
use crate::tool_local::finish_partial_record_or_replay_write;
use crate::types::DetTid;
use crate::types::LogicalTime;
use crate::types::OpenFileId;
use crate::types::SchedEvent;
use crate::types::SyscallPhase;
impl<T: RecordOrReplay> Detcore<T> {
pub(crate) async fn refuse_unserviceable_operation<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: reverie::syscalls::Sysno,
fallback: Errno,
) -> Result<i64, Error> {
refuse_unserviceable_operation_with(
guest,
self.cfg.panic_on_unsupported_syscalls,
sysno,
fallback,
None,
)
.await
}
pub(crate) async fn refuse_unserviceable_operation_because<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: reverie::syscalls::Sysno,
fallback: Errno,
reason: &str,
) -> Result<i64, Error> {
refuse_unserviceable_operation_with(
guest,
self.cfg.panic_on_unsupported_syscalls,
sysno,
fallback,
Some(reason),
)
.await
}
pub async fn record_or_replay_blocking<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
) -> Result<i64, Error> {
self.record_or_replay_blocking_with_mask(guest, call, None)
.await
}
pub async fn record_or_replay_blocking_with_mask<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
blocked_signal_mask: Option<u64>,
) -> Result<i64, Error> {
let dettid = guest.thread_state().dettid;
let op_id = ExternalOpId::new(dettid, guest.thread_state().stats.syscall_count);
self.record_or_replay_blocking_resource(
guest,
call,
ResourceID::BlockingExternalIO(op_id),
blocked_signal_mask,
false,
)
.await
}
pub async fn record_or_replay_blocking_with_unknown_mask<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
) -> Result<i64, Error> {
self.record_or_replay_blocking_with_unknown_mask_then(guest, call, |_| {})
.await
}
pub async fn record_or_replay_blocking_with_unknown_mask_then<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
after_grant: impl FnOnce(&mut G),
) -> Result<i64, Error> {
let dettid = guest.thread_state().dettid;
let op_id = ExternalOpId::new(dettid, guest.thread_state().stats.syscall_count);
self.record_or_replay_blocking_resource_then(
guest,
call,
ResourceID::BlockingExternalIO(op_id),
None,
true,
after_grant,
)
.await
}
pub async fn record_or_replay_rt_sigsuspend<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::RtSigsuspend,
temporary_mask: u64,
) -> Result<i64, Error> {
let dettid = guest.thread_state().dettid;
let op_id = ExternalOpId::new(dettid, guest.thread_state().stats.syscall_count);
let result = self
.record_or_replay_blocking_resource(
guest,
call.into(),
ResourceID::BlockingRtSigsuspend(op_id),
Some(temporary_mask),
false,
)
.await;
match result {
Err(Error::Errno(Errno::ERESTARTSYS)) => Err(Errno::ERESTARTNOHAND.into()),
other => other,
}
}
async fn record_or_replay_blocking_resource<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
blocking_resource: ResourceID,
blocked_signal_mask: Option<u64>,
blocked_signal_mask_unknown: bool,
) -> Result<i64, Error> {
self.record_or_replay_blocking_resource_then(
guest,
call,
blocking_resource,
blocked_signal_mask,
blocked_signal_mask_unknown,
|_| {},
)
.await
}
async fn record_or_replay_blocking_resource_then<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
blocking_resource: ResourceID,
blocked_signal_mask: Option<u64>,
blocked_signal_mask_unknown: bool,
after_grant: impl FnOnce(&mut G),
) -> Result<i64, Error> {
crate::syscalls::timerfd::refuse_host_wait_for(guest, call);
let dettid = guest.thread_state().dettid;
let op_id = match &blocking_resource {
ResourceID::BlockingExternalIO(op_id) | ResourceID::BlockingRtSigsuspend(op_id) => {
*op_id
}
_ => unreachable!("blocking syscall helper requires a blocking resource"),
};
let replay_served_from_log = self.cfg.replaying
&& (replay_serves_blocking_call_from_log(call)
|| replay_serves_socket_call_from_log(guest, call));
debug_assert!(
!self.cfg.sequentialize_threads || !syscall_targets_internal_fd(guest, call),
"record_or_replay_blocking (BlockingExternalIO) reached for an internal fd \
(pipe or socketpair endpoint) on syscall {}; internal fds must use the \
InternalIOPolling path",
call.name()
);
{
let mut rsrcs = Resources::new(dettid);
rsrcs.reads_signalfd = matches!(blocking_resource, ResourceID::BlockingExternalIO(_))
&& call_reads_signalfd(guest, call);
if matches!(blocking_resource, ResourceID::BlockingExternalIO(_)) {
rsrcs.read_fd =
read_family_fd(call).map(|fd| (guest.thread_state().files_id(), fd));
}
rsrcs.insert(blocking_resource, Permission::RW);
rsrcs.fyi(call.name());
rsrcs.blocked_signal_mask = blocked_signal_mask;
rsrcs.blocked_signal_mask_unknown = blocked_signal_mask_unknown;
rsrcs.replay_served_from_log = replay_served_from_log;
resource_request(guest, rsrcs).await;
}
after_grant(guest);
crate::race_probe::delay(crate::race_probe::BG_PRE_CALL).await;
tracing::trace!(
"Guest proceeding to execute potentially blocking call {}...",
call.name()
);
let res = self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
crate::race_probe::delay(crate::race_probe::BG_POST_CALL).await;
{
let mut rsrcs = Resources::new(dettid);
rsrcs.insert(ResourceID::BlockedExternalContinue(op_id), Permission::RW);
rsrcs.fyi(call.name());
match continuation_mask(call, &res) {
ContinuationMask::Temporary => {
rsrcs.blocked_signal_mask = blocked_signal_mask;
rsrcs.blocked_signal_mask_unknown = blocked_signal_mask_unknown;
}
ContinuationMask::Unknown => rsrcs.blocked_signal_mask_unknown = true,
ContinuationMask::Restored => {}
}
resource_request(guest, rsrcs).await;
}
res
}
pub async fn execute_nonblockable_fd_syscall<
G: Guest<Self>,
C: SyscallInfo + NonblockableSyscall + Into<Syscall>,
>(
&self,
guest: &mut G,
call: C,
) -> Result<i64, Error> {
let wrapped: Syscall = call.into();
let action = match ioaction_based_on_fd_status(guest, call) {
Ok(action) => action,
Err(errno) => {
tracing::trace!(
"NonblockableSyscall: fd classification failed with {}; executing kernel-authoritatively: {}",
errno,
call.name()
);
return self.record_or_replay_blocking(guest, wrapped).await;
}
};
let internal_fd = syscall_targets_internal_fd(guest, wrapped);
if !self.cfg.sequentialize_threads
|| (self.cfg.recordreplay_modes && !internal_fd)
|| action == IOAction::Blocking
{
tracing::trace!(
"NonblockableSyscall: executing in blocking mode after all: {}",
call.name()
);
Ok(self.record_or_replay_blocking(guest, wrapped).await?)
} else if action == IOAction::NonblockizeRetry {
tracing::trace!(
"NonblockableSyscall: converting to nonblocking syscall (internal polling): {}",
call.name()
);
let mut rsrc = Resources::new(guest.thread_state().dettid);
rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
rsrc.fyi(call.name());
rsrc.polls_guest_state_only = internal_fd;
rsrc.private_sigchld_decides = reads_a_pipe(guest, wrapped);
rsrc.polls_channel = crate::pipe_wake::poll_of(&wrapped).and_then(|(fd, wants)| {
self.pipe_channel_end(guest, fd)
.map(|end| Box::new((end.channel, wants)))
});
let subtool = (self.cfg.recordreplay_modes && internal_fd).then_some(self);
Ok(retry_nonblocking_syscall(guest, call, rsrc, subtool).await?)
} else {
assert!(action == IOAction::PassThru);
tracing::trace!(
"NonblockableSyscall: just passing it through: {}",
call.name()
);
self.record_or_replay_preserving_tool_errors(guest, wrapped)
.await
}
}
pub async fn execute_blocking_pipe_writev<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Writev,
expected_open_file: OpenFileId,
) -> Result<i64, Error> {
const MAX_IOVECS: usize = 1024;
const MAX_RW_COUNT: usize = 0x7fff_f000;
const PIPE_BUF: usize = 4096;
const STACK_IOVECS: usize = 32;
let Some(iov_addr) = call.iov() else {
return self.execute_nonblockable_fd_syscall(guest, call).await;
};
if call.len() == 0 || call.len() > MAX_IOVECS {
return self.execute_nonblockable_fd_syscall(guest, call).await;
}
let iovecs: Vec<(usize, usize)> = {
let mut raw_iovecs = vec![
libc::iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
};
call.len()
];
guest.memory().read_values(iov_addr, &mut raw_iovecs)?;
raw_iovecs
.into_iter()
.map(|iovec| (iovec.iov_base as usize, iovec.iov_len))
.collect()
};
let requested = iovecs.iter().try_fold(0usize, |total, (_, length)| {
total.checked_add(*length).ok_or(Errno::EINVAL)
})?;
if requested > isize::MAX as usize {
return Err(Errno::EINVAL.into());
}
let target = requested.min(MAX_RW_COUNT);
if target == 0 {
return self.execute_nonblockable_fd_syscall(guest, call).await;
}
let atomic_pipe_write = target <= PIPE_BUF;
tracing::trace!(
"NonblockableSyscall: converting to nonblocking syscall (internal polling): writev"
);
let mut resources = pipe_writev_resources(guest.thread_state().dettid, call);
resources.polls_channel = self
.pipe_channel_end(guest, call.fd())
.map(|end| Box::new((end.channel, crate::pipe_wake::Wants::Space)));
let subtool = self.cfg.recordreplay_modes.then_some(self);
let mut current = Syscall::Writev(call);
let mut written_total = 0usize;
let blocked_mask = blocked_signal_mask();
let mut stack = guest.stack().await;
let atomic_scratch_iov = if atomic_pipe_write && iovecs.len() <= STACK_IOVECS {
let mut raw_iovecs = [libc::iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
}; STACK_IOVECS];
for (raw, (base, length)) in raw_iovecs.iter_mut().zip(&iovecs) {
raw.iov_base = *base as *mut libc::c_void;
raw.iov_len = *length;
}
let scratch_iov: Addr<libc::iovec> = stack.push(raw_iovecs).cast();
Some(scratch_iov.as_raw())
} else {
None
};
let blocked_mask_addr = stack.push(blocked_mask);
let old_mask_addr = stack.reserve::<KernelSigset>();
let turn_mask_cell = stack.reserve::<KernelSigset>();
let action_addr = stack.reserve::<KernelSigaction>();
let _mask_guard = stack.commit()?;
let checks_at_turn = decides_interruption_at_turn(guest, guest_signal_state_task(guest));
let mut first_turn = if checks_at_turn {
let turn = read_turn_signals(guest, None, 0, NamedRealTime::ByDisposition).await?;
Some((ResumeStatus::Normal, turn))
} else {
None
};
let mut turn_wait = checks_at_turn
.then(|| KernelSignalWait::new(guest, 0, false, call.signal_interrupt_errno()));
let mut turn_mask: Option<KernelSigset> = None;
let guest_signal_mask = if checks_at_turn {
0
} else {
block_signals_for_disposition(guest, blocked_mask_addr, old_mask_addr).await?
};
let result: Result<i64, Error> = loop {
let written_before = written_total;
let (status, turn) = match first_turn.take() {
Some((status, turn)) => (status, Some(turn)),
None => {
if let Some(wait) = turn_wait.as_mut()
&& turn_mask.is_none()
{
match install_turn_mask(guest, wait, turn_mask_cell).await {
Ok(mask) => turn_mask = Some(mask),
Err(Error::Errno(errno)) => {
break if written_total > 0 {
Ok(written_total as i64)
} else {
Err(errno.into())
};
}
Err(error) => break Err(error),
}
}
let status = resource_request(guest, resources.clone()).await;
let turn = if checks_at_turn {
match read_turn_signals(
guest,
turn_mask,
committed_signals(&status),
NamedRealTime::ByDisposition,
)
.await
{
Ok(turn) => Some(turn),
Err(error) => break Err(error),
}
} else {
None
};
(status, turn)
}
};
if turn.is_none() {
let disposition = match wait_signal_disposition(
guest,
status.clone(),
&guest_signal_mask,
action_addr,
true,
)
.await
{
Ok(disposition) => disposition,
Err(error) => break Err(error),
};
if matches!(status, ResumeStatus::Signaled(_))
&& let Some(result) =
interrupted_write_result(&call, written_total, disposition)
{
break result;
}
}
if resources.poll_attempt > 0
&& !guest
.thread_state()
.with_detfd(call.fd(), |detfd| {
detfd.open_file_id() == expected_open_file
})
.unwrap_or(false)
{
break if written_total > 0 {
Ok(written_total as i64)
} else {
self.refuse_unserviceable_operation(guest, Sysno::writev, Errno::EOPNOTSUPP)
.await
};
}
let own_first_attempt = turn_wait.is_some() && turn_mask.is_none();
let result = if atomic_pipe_write && !own_first_attempt {
self.execute_atomic_pipe_writev_attempt(guest, call, &iovecs, atomic_scratch_iov)
.await
} else {
match subtool {
Some(detcore) => {
detcore
.record_or_replay_preserving_tool_errors(guest, current)
.await
}
None => guest.inject_with_retry(current).await.map_err(Error::from),
}
};
match result {
Ok(written) if written > 0 => {
let written = match usize::try_from(written) {
Ok(written) => written,
Err(_) => break Err(Errno::EIO.into()),
};
written_total = match written_total.checked_add(written) {
Some(written_total) => written_total,
None => break Err(Errno::EIO.into()),
};
if written_total >= target {
break Ok(written_total as i64);
}
if atomic_pipe_write {
break Ok(written_total as i64);
}
if turn.is_some_and(|turn| turn.ends(true)) {
break Ok(written_total as i64);
}
current = match remaining_writev_segment(
call.fd(),
&iovecs,
written_total,
target - written_total,
) {
Ok(Some(write)) => Syscall::Write(write),
Ok(None) => break Ok(written_total as i64),
Err(_) => break Ok(written_total as i64),
};
}
Ok(0) => break Ok(written_total as i64),
Err(Error::Errno(Errno::EAGAIN))
if turn.is_some_and(|turn| turn.ends(written_total > 0)) =>
{
break if written_total > 0 {
Ok(written_total as i64)
} else {
Err(call.signal_interrupt_errno().into())
};
}
Err(Error::Errno(Errno::EAGAIN)) => {
if !atomic_pipe_write && matches!(current, Syscall::Writev(_)) {
current = match remaining_writev_segment(call.fd(), &iovecs, 0, target) {
Ok(Some(write)) => Syscall::Write(write),
Ok(None) => break Ok(0),
Err(error) => break Err(error.into()),
};
}
}
Err(error) => {
break finish_partial_record_or_replay_write(written_total as i64, error);
}
Ok(_) => break Err(Errno::EIO.into()),
}
resources.previous_attempt_made_progress = written_total > written_before;
if resources.previous_attempt_made_progress {
self.note_fd_readied(guest, call.fd(), crate::pipe_wake::Wants::Data)
.await;
}
resources.poll_attempt += 1;
tracing::trace!(
"Retry #{} for {}blocking pipe writev after EAGAIN: {}",
resources.poll_attempt,
if atomic_pipe_write { "atomic " } else { "" },
call.display(&guest.memory())
);
record_retry_event(guest, call).await;
};
match turn_wait {
Some(mut wait) => {
let restored = wait.restore(guest, Some(turn_mask_cell)).await;
if turn_mask.is_some() {
crate::tool_global::set_saved_guest_sigmask(guest, None).await;
}
match result_after_restore(restored, result) {
Ok(result) => refuse_held_signal_loss(guest, Sysno::writev, result).await,
Err(error) => Err(error),
}
}
None => {
restore_signals_after_disposition(guest, old_mask_addr).await?;
result
}
}
}
pub async fn execute_blocking_pipe_write<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Write,
expected_open_file: OpenFileId,
) -> Result<i64, Error> {
const MAX_RW_COUNT: usize = 0x7fff_f000;
let target = call.len().min(MAX_RW_COUNT);
if target == 0 {
return self.execute_nonblockable_fd_syscall(guest, call).await;
}
tracing::trace!(
"NonblockableSyscall: converting to nonblocking syscall (internal polling): write"
);
let mut resources = Resources::new(guest.thread_state().dettid);
resources.insert(ResourceID::InternalIOPolling, Permission::W);
resources.fyi(call.name());
resources.set_signal_interrupt_errno(call.signal_interrupt_errno());
resources.signal_state_task = guest_signal_state_task(guest);
resources.private_sigchld_decides = true;
resources.polls_guest_state_only = true;
resources.polls_channel = self
.pipe_channel_end(guest, call.fd())
.map(|end| Box::new((end.channel, crate::pipe_wake::Wants::Space)));
let disposition_scratch = if resources.signal_state_task.is_none() {
resources.decides_signal_interruption_itself = true;
let mut stack = guest.stack().await;
let mask_addr = stack.reserve::<KernelSigset>();
let action_addr = stack.reserve::<KernelSigaction>();
let guard = stack.commit()?;
Some((mask_addr, action_addr, guard))
} else {
None
};
let subtool = self.cfg.recordreplay_modes.then_some(self);
let mut current = call;
let mut written_total = 0usize;
let checks_at_turn = decides_interruption_at_turn(guest, resources.signal_state_task);
let mut turn_wait = checks_at_turn
.then(|| KernelSignalWait::new(guest, 0, false, call.signal_interrupt_errno()));
let mut published = PublishedWaitMask::default();
let result: Result<i64, Error> = loop {
let written_before = written_total;
let status = if resources.poll_attempt > 0 {
Some(resource_request(guest, resources.clone()).await)
} else {
None
};
let turn = if checks_at_turn {
let committed = status.as_ref().map_or(0, committed_signals);
match turn_signals_with_block(
guest,
&mut turn_wait,
resources.poll_attempt > 0,
committed,
resources.private_sigchld_decides,
&mut published,
)
.await
{
Ok(turn) => Some(turn),
Err(error) => break Err(error),
}
} else {
None
};
let signaled = if turn.is_some() {
false
} else {
match (&status, &disposition_scratch) {
(Some(ResumeStatus::Signaled(_)), None) => true,
(
Some(status @ ResumeStatus::Signaled(_)),
Some((mask_addr, action_addr, _)),
) => {
match own_disposition_interrupts(
guest,
status.clone(),
*mask_addr,
*action_addr,
)
.await
{
Ok(interrupts) => interrupts,
Err(error) => break Err(error),
}
}
_ => false,
}
};
if resources.poll_attempt > 0
&& !guest
.thread_state()
.with_detfd(call.fd(), |detfd| {
detfd.open_file_id() == expected_open_file
})
.unwrap_or(false)
{
break if written_total > 0 {
Ok(written_total as i64)
} else {
self.refuse_unserviceable_operation(guest, Sysno::write, Errno::EOPNOTSUPP)
.await
};
}
let result = match subtool {
Some(detcore) => {
detcore
.record_or_replay_preserving_tool_errors(guest, current)
.await
}
None => guest.inject_with_retry(current).await.map_err(Error::from),
};
match result {
Ok(written) if written > 0 => {
let Ok(written) = usize::try_from(written) else {
break Err(Errno::EIO.into());
};
let Some(remaining) = target.checked_sub(written_total) else {
break Err(Errno::EIO.into());
};
if written > remaining {
break Err(Errno::EIO.into());
}
let Some(total) = written_total.checked_add(written) else {
break Err(Errno::EIO.into());
};
written_total = total;
if written_total == target || turn.map_or(signaled, |turn| turn.ends(true)) {
break Ok(written_total as i64);
}
let Some(buffer) = call.buf() else {
break Err(Errno::EFAULT.into());
};
let Some(next_buffer) = buffer
.as_raw()
.checked_add(written_total)
.and_then(Addr::<u8>::from_raw)
else {
break finish_partial_record_or_replay_write(
written_total as i64,
Errno::EFAULT.into(),
);
};
current = call
.with_buf(Some(next_buffer))
.with_len(target - written_total);
}
Ok(0) => break Ok(written_total as i64),
Err(Error::Errno(Errno::EAGAIN))
if turn.map_or(signaled, |turn| turn.ends(written_total > 0)) =>
{
break if written_total > 0 {
Ok(written_total as i64)
} else {
Err(call.signal_interrupt_errno().into())
};
}
Err(Error::Errno(Errno::EAGAIN)) => {}
Err(error) => {
break finish_partial_record_or_replay_write(written_total as i64, error);
}
Ok(_) => break Err(Errno::EIO.into()),
}
resources.previous_attempt_made_progress = written_total > written_before;
if resources.previous_attempt_made_progress {
self.note_fd_readied(guest, call.fd(), crate::pipe_wake::Wants::Data)
.await;
}
resources.poll_attempt += 1;
tracing::trace!(
"Retry #{} for blocking pipe write: {}",
resources.poll_attempt,
call.display(&guest.memory())
);
record_retry_event(guest, call).await;
};
match turn_wait {
Some(mut wait) if wait.effective_mask().is_some() => {
let restored = wait.restore(guest, None).await;
publish_wait_mask(guest, None, &mut published).await;
match result_after_restore(restored, result) {
Ok(result) => refuse_held_signal_loss(guest, Sysno::write, result).await,
Err(error) => Err(error),
}
}
_ => result,
}
}
async fn execute_atomic_pipe_writev_attempt<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Writev,
iovecs: &[(usize, usize)],
stack_iov: Option<usize>,
) -> Result<i64, Error> {
if let Some(stack_iov) = stack_iov {
let scratch_call = call.with_iov(Addr::from_raw(stack_iov));
return if self.cfg.recordreplay_modes {
self.record_or_replay_preserving_tool_errors(guest, scratch_call)
.await
} else {
guest
.inject_with_retry(scratch_call)
.await
.map_err(Error::from)
};
}
let mapping_len = iovecs
.len()
.checked_mul(std::mem::size_of::<libc::iovec>())
.expect("validated iovec count cannot overflow scratch length");
let mapped = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(mapping_len)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await
.unwrap_or_else(|error| panic!("failed to map atomic writev scratch: {error}"));
let mapped = usize::try_from(mapped)
.unwrap_or_else(|_| panic!("atomic writev scratch mmap returned {mapped}"));
let scratch_iov = Addr::<libc::iovec>::from_raw(mapped)
.unwrap_or_else(|| panic!("atomic writev scratch mmap returned a null address"));
let mapping_addr: Addr<libc::c_void> = scratch_iov.cast();
let write_result = {
let raw_iovecs: Vec<libc::iovec> = iovecs
.iter()
.map(|(base, length)| libc::iovec {
iov_base: *base as *mut libc::c_void,
iov_len: *length,
})
.collect();
guest
.memory()
.write_values(unsafe { scratch_iov.into_mut() }, &raw_iovecs)
};
if let Err(write_error) = write_result {
guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(mapping_addr))
.with_len(mapping_len),
))
.await
.unwrap_or_else(|cleanup_error| {
panic!(
"failed to populate atomic writev scratch ({write_error}); cleanup failed ({cleanup_error})"
)
});
panic!("failed to populate atomic writev scratch: {write_error}");
}
let scratch_call = call.with_iov(Some(scratch_iov));
let result = if self.cfg.recordreplay_modes {
self.record_or_replay_preserving_tool_errors(guest, scratch_call)
.await
} else {
guest
.inject_with_retry(scratch_call)
.await
.map_err(Error::from)
};
guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(mapping_addr))
.with_len(mapping_len),
))
.await
.unwrap_or_else(|error| panic!("failed to unmap atomic writev scratch: {error}"));
result
}
pub fn maybe_set_nonblocking_fd<G: Guest<Self>>(&self, guest: &G, fd: i32) {
if self.cfg.sequentialize_threads && !self.cfg.debug_externalize_sockets {
guest
.thread_state()
.with_detfd(fd, |detfd| {
detfd.set_physically_nonblocking();
})
.unwrap();
}
}
}
fn remaining_writev_segment(
fd: i32,
iovecs: &[(usize, usize)],
mut consumed: usize,
remaining_limit: usize,
) -> Result<Option<syscalls::Write>, Errno> {
for (base, length) in iovecs {
if consumed >= *length {
consumed -= *length;
continue;
}
let base = base.checked_add(consumed).ok_or(Errno::EFAULT)?;
let buffer = Addr::<u8>::from_raw(base).ok_or(Errno::EFAULT)?;
return Ok(Some(
syscalls::Write::new()
.with_fd(fd)
.with_buf(Some(buffer))
.with_len((*length - consumed).min(remaining_limit)),
));
}
Ok(None)
}
#[derive(PartialEq, Eq, Debug)]
pub enum IOAction {
Blocking,
NonblockizeRetry,
PassThru,
}
pub fn ioaction_based_on_fd_status<
G: Guest<Detcore<T>>,
T: RecordOrReplay,
C: SyscallInfo + Into<Syscall>,
>(
guest: &mut G,
call: C,
) -> Result<IOAction, Errno> {
let wrapped: Syscall = call.into();
let fd = get_fd(wrapped).unwrap_or_else(|| panic!("Failed to get fd for {}", call.name()));
let (phys, virt) = guest.thread_state().with_detfd(fd, |detfd| {
(detfd.physically_nonblocking(), detfd.is_nonblocking())
})?;
tracing::trace!(
"Checking FD {} for nonblocking: physical {} / virtual {}",
fd,
phys,
virt
);
if virt && !phys {
panic!(
"Invariant violation, fd {}: we cannot simulate nonblocking behavior when set to blocking mode in the kernel.",
fd
);
} else if !virt && !phys {
Ok(IOAction::Blocking)
} else if virt && phys {
Ok(IOAction::PassThru)
} else {
Ok(IOAction::NonblockizeRetry)
}
}
pub fn syscall_targets_internal_fd<G: Guest<Detcore<T>>, T: RecordOrReplay>(
guest: &mut G,
call: Syscall,
) -> bool {
if matches!(call, Syscall::EpollWait(_) | Syscall::EpollPwait(_)) {
return false;
}
match get_fd(call) {
Some(fd) => guest
.thread_state()
.with_detfd(fd, |detfd| {
if matches!(call, Syscall::Read(_) | Syscall::Readv(_))
&& detfd.inherited_external_read().is_some()
{
return false;
}
matches!(detfd.ty(), FdType::Pipe) || detfd.is_socketpair_endpoint()
})
.unwrap_or(false),
None => false,
}
}
fn reads_a_pipe<G: Guest<Detcore<T>>, T: RecordOrReplay>(guest: &mut G, call: Syscall) -> bool {
matches!(call, Syscall::Read(_) | Syscall::Readv(_))
&& get_fd(call).is_some_and(|fd| {
guest
.thread_state()
.with_detfd(fd, |detfd| matches!(detfd.ty(), FdType::Pipe))
.unwrap_or(false)
})
}
fn call_reads_signalfd<G: Guest<Detcore<T>>, T: RecordOrReplay>(
guest: &mut G,
call: Syscall,
) -> bool {
let fd = match call {
Syscall::Read(c) => c.fd(),
Syscall::Readv(c) => c.fd(),
Syscall::Preadv2(c) => c.fd(),
_ => return false,
};
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.ty() == crate::fd::FdType::Signalfd)
.unwrap_or(false)
}
fn read_family_fd(call: Syscall) -> Option<i32> {
match call {
Syscall::Read(c) => Some(c.fd()),
Syscall::Readv(c) => Some(c.fd()),
Syscall::Preadv2(c) => Some(c.fd()),
_ => None,
}
}
fn replay_serves_socket_call_from_log<G: Guest<Detcore<T>>, T: RecordOrReplay>(
guest: &mut G,
call: Syscall,
) -> bool {
let fd = match call {
Syscall::Accept(_)
| Syscall::Accept4(_)
| Syscall::Connect(_)
| Syscall::Sendto(_)
| Syscall::Sendmsg(_)
| Syscall::Recvfrom(_)
| Syscall::Recvmsg(_) => return true,
Syscall::Read(s) => s.fd(),
Syscall::Readv(s) => s.fd(),
Syscall::Write(s) => s.fd(),
Syscall::Writev(s) => s.fd(),
_ => return false,
};
is_log_served_socket(guest, fd)
}
fn replay_serves_blocking_call_from_log(call: Syscall) -> bool {
matches!(
call,
Syscall::Poll(_) | Syscall::Ppoll(_) | Syscall::Select(_) | Syscall::Pselect6(_)
)
}
fn is_log_served_socket<G: Guest<Detcore<T>>, T: RecordOrReplay>(guest: &mut G, fd: i32) -> bool {
guest
.thread_state()
.with_detfd(fd, |detfd| {
matches!(detfd.ty(), FdType::Socket) && !detfd.is_socketpair_endpoint()
})
.unwrap_or(false)
}
pub(crate) fn is_accepted_connection<G: Guest<Detcore<T>>, T: RecordOrReplay>(
guest: &mut G,
fd: i32,
) -> bool {
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.is_accepted_connection())
.unwrap_or(false)
}
pub(crate) fn get_fd(s: Syscall) -> Option<i32> {
match s {
Syscall::Recvfrom(s) => Some(s.fd()),
Syscall::Recvmsg(s) => Some(s.sockfd()),
Syscall::Recvmmsg(s) => Some(s.fd()),
Syscall::Sendto(s) => Some(s.fd()),
Syscall::Sendmsg(s) => Some(s.fd()),
Syscall::Sendmmsg(s) => Some(s.sockfd()),
Syscall::Accept(s) => Some(s.sockfd()),
Syscall::Accept4(s) => Some(s.sockfd()),
Syscall::Connect(s) => Some(s.fd()),
Syscall::Bind(s) => Some(s.fd()),
Syscall::Listen(s) => Some(s.fd()),
Syscall::Getsockname(s) => Some(s.fd()),
Syscall::Getpeername(s) => Some(s.fd()),
Syscall::Setsockopt(s) => Some(s.fd()),
Syscall::Getsockopt(s) => Some(s.fd()),
Syscall::Read(s) => Some(s.fd()),
Syscall::Write(s) => Some(s.fd()),
Syscall::Close(s) => Some(s.fd()),
Syscall::Fstat(s) => Some(s.fd()),
Syscall::Lseek(s) => Some(s.fd()),
Syscall::Mmap(s) => Some(s.fd()),
Syscall::Ioctl(s) => Some(s.fd()),
Syscall::Pread64(s) => Some(s.fd()),
Syscall::Pwrite64(s) => Some(s.fd()),
Syscall::Readv(s) => Some(s.fd()),
Syscall::Writev(s) => Some(s.fd()),
Syscall::Shutdown(s) => Some(s.fd()),
Syscall::Fcntl(s) => Some(s.fd()),
Syscall::Flock(s) => Some(s.fd()),
Syscall::Fsync(s) => Some(s.fd()),
Syscall::Fdatasync(s) => Some(s.fd()),
Syscall::Ftruncate(s) => Some(s.fd()),
Syscall::Fchdir(s) => Some(s.fd()),
Syscall::Fchmod(s) => Some(s.fd()),
Syscall::Fchown(s) => Some(s.fd()),
Syscall::Fstatfs(s) => Some(s.fd()),
Syscall::Readahead(s) => Some(s.fd()),
Syscall::Fsetxattr(s) => Some(s.fd()),
Syscall::Fgetxattr(s) => Some(s.fd()),
Syscall::Flistxattr(s) => Some(s.fd()),
Syscall::Fremovexattr(s) => Some(s.fd()),
Syscall::Fadvise64(s) => Some(s.fd()),
Syscall::InotifyAddWatch(s) => Some(s.fd()),
Syscall::InotifyRmWatch(s) => Some(s.fd()),
Syscall::SyncFileRange(s) => Some(s.fd()),
Syscall::Vmsplice(s) => Some(s.fd()),
Syscall::Utimensat(s) => Some(s.dirfd()),
Syscall::Signalfd(s) => Some(s.fd()),
Syscall::Fallocate(s) => Some(s.fd()),
Syscall::TimerfdSettime(s) => Some(s.fd()),
Syscall::TimerfdGettime(s) => Some(s.fd()),
Syscall::Signalfd4(s) => Some(s.fd()),
Syscall::Preadv(s) => Some(s.fd()),
Syscall::Pwritev(s) => Some(s.fd()),
Syscall::Syncfs(s) => Some(s.fd()),
Syscall::Setns(s) => Some(s.fd()),
Syscall::FinitModule(s) => Some(s.fd()),
Syscall::Preadv2(s) => Some(s.fd()),
Syscall::Pwritev2(s) => Some(s.fd()),
Syscall::Openat(s) => Some(s.dirfd()),
Syscall::Mkdirat(s) => Some(s.dirfd()),
Syscall::Mknodat(s) => Some(s.dirfd()),
Syscall::Fchownat(s) => Some(s.dirfd()),
Syscall::Futimesat(s) => Some(s.dirfd()),
Syscall::Newfstatat(s) => Some(s.dirfd()),
Syscall::Unlinkat(s) => Some(s.dirfd()),
Syscall::Readlinkat(s) => Some(s.dirfd()),
Syscall::Fchmodat(s) => Some(s.dirfd()),
Syscall::Faccessat(s) => Some(s.dirfd()),
Syscall::NameToHandleAt(s) => Some(s.dirfd()),
Syscall::Execveat(s) => Some(s.dirfd()),
Syscall::Statx(s) => Some(s.dirfd()),
Syscall::Symlinkat(s) => Some(s.newdirfd()),
Syscall::PerfEventOpen(s) => Some(s.group_fd()),
Syscall::OpenByHandleAt(s) => Some(s.mount_fd()),
Syscall::EpollCtl(s) => Some(s.epfd()),
Syscall::EpollWait(s) => Some(s.epfd()),
Syscall::EpollPwait(s) => Some(s.epfd()),
Syscall::Dup2(_) => None,
Syscall::Sendfile(_) => None,
Syscall::Renameat(_) => None,
Syscall::Linkat(_) => None,
Syscall::FanotifyMark(_) => None,
Syscall::Renameat2(_) => None,
Syscall::Dup3(_) => None,
Syscall::KexecLoad(_) => None,
Syscall::Poll(_) => None,
Syscall::Ppoll(_) => None,
_ => None,
}
}
#[allow(clippy::double_must_use)]
#[async_trait]
pub trait NonblockableSyscall: SyscallInfo {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>);
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Ok(0)
}
fn signal_interrupt_errno(&self) -> Errno {
Errno::ERESTARTSYS
}
fn kernel_restart_errno(&self) -> Errno {
self.signal_interrupt_errno()
}
fn restart_keeps_deadline(&self) -> bool {
false
}
fn signals_consumed_by_wait<M: MemoryAccess>(&self, _memory: &M) -> KernelSigset {
0
}
fn normalize_nonblocking_result(
&self,
res: Result<i64, Errno>,
_retried: bool,
) -> Result<i64, Errno> {
res
}
}
pub trait TimeoutableSyscall: SyscallInfo {
fn timeout_return_val(&self) -> Result<i64, Errno>;
}
fn interrupted_write_result<C: NonblockableSyscall>(
call: &C,
written_total: usize,
disposition: Option<WaitSignalDisposition>,
) -> Option<Result<i64, Error>> {
match disposition {
None => None,
Some(_) if written_total > 0 => Some(Ok(written_total as i64)),
Some(_) => Some(Err(call.signal_interrupt_errno().into())),
}
}
fn pipe_writev_resources(dettid: DetTid, call: reverie::syscalls::Writev) -> Resources {
let mut resources = Resources::new(dettid);
resources.insert(ResourceID::InternalIOPolling, Permission::W);
resources.fyi(call.name());
resources.set_signal_interrupt_errno(call.signal_interrupt_errno());
resources.decides_signal_interruption_itself = true;
resources.polls_guest_state_only = true;
resources
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Poll {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
_guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
(self.with_timeout(0), None)
}
fn signal_interrupt_errno(&self) -> Errno {
Errno::EINTR
}
fn kernel_restart_errno(&self) -> Errno {
if self.restart_keeps_deadline() {
Errno::ERESTART_RESTARTBLOCK
} else {
Errno::ERESTARTNOHAND
}
}
fn restart_keeps_deadline(&self) -> bool {
self.timeout() > 0
}
}
impl TimeoutableSyscall for reverie::syscalls::Poll {
fn timeout_return_val(&self) -> Result<i64, Errno> {
Ok(0)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Ppoll {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
let (tp, guard) = zero_timespec(guest).await;
let tp = unsafe { tp.into_mut() };
(self.with_timeout(Some(tp)), Some(guard))
}
fn signal_interrupt_errno(&self) -> Errno {
Errno::EINTR
}
fn kernel_restart_errno(&self) -> Errno {
Errno::ERESTARTNOHAND
}
}
impl TimeoutableSyscall for reverie::syscalls::Ppoll {
fn timeout_return_val(&self) -> Result<i64, Errno> {
Ok(0)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::EpollWait {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
_guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
(self.with_timeout(0), None)
}
fn signal_interrupt_errno(&self) -> Errno {
Errno::EINTR
}
}
impl TimeoutableSyscall for reverie::syscalls::EpollWait {
fn timeout_return_val(&self) -> Result<i64, Errno> {
Ok(0)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::EpollPwait {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
_guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
(self.with_timeout(0), None)
}
fn signal_interrupt_errno(&self) -> Errno {
Errno::EINTR
}
}
impl TimeoutableSyscall for reverie::syscalls::EpollPwait {
fn timeout_return_val(&self) -> Result<i64, Errno> {
Ok(0)
}
}
pub(crate) async fn take_outcome<T, G>(
guest: &mut G,
signal: i32,
after: Option<(u64, u64)>,
) -> crate::scheduler::posix_timer_coalesce::TakeOutcome
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
use crate::scheduler::discarded_at_send::DiscardedSignalAnswer;
use crate::scheduler::discarded_at_send::DiscardedSignalControl;
use crate::scheduler::posix_timer_coalesce::TakeOutcome;
let at = guest.thread_state().thread_logical_time.as_nanos();
match crate::tool_global::discarded_signal(
guest,
DiscardedSignalControl::Take { signal, at, after },
)
.await
{
DiscardedSignalAnswer::Taken(outcome) => outcome,
_ => TakeOutcome {
skip: false,
rewrite: None,
},
}
}
async fn zero_timespec<'stack, T: RecordOrReplay, G: Guest<Detcore<T>>>(
guest: &mut G,
) -> (Addr<'stack, Timespec>, <G::Stack as Stack>::StackGuard) {
let mut stack = guest.stack().await;
let tp_val = Timespec {
tv_sec: 0,
tv_nsec: 0,
};
let tp = stack.push(tp_val);
let guard = stack.commit().expect("stack.commit to succeed");
(tp, guard)
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Wait4 {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
_guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
let call2 = self.with_options(self.options() | WaitPidFlag::WNOHANG);
(call2, None)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Ok(0)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Futex {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
let (tp, guard) = zero_timespec(guest).await;
(self.with_timeout(Some(tp)), Some(guard))
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::ETIMEDOUT)
}
fn kernel_restart_errno(&self) -> Errno {
if self.restart_keeps_deadline() {
Errno::ERESTART_RESTARTBLOCK
} else if self.timeout().is_some() {
Errno::ERESTARTNOHAND
} else {
Errno::ERESTARTSYS
}
}
fn restart_keeps_deadline(&self) -> bool {
matches!(
self.futex_op() & libc::FUTEX_CMD_MASK,
libc::FUTEX_WAIT | libc::FUTEX_WAIT_BITSET
) && self.timeout().is_some()
}
}
impl TimeoutableSyscall for reverie::syscalls::Futex {
fn timeout_return_val(&self) -> Result<i64, Errno> {
Err(Errno::ETIMEDOUT)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::RtSigtimedwait {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
let (tp, guard) = zero_timespec(guest).await;
(self.with_timeout(Some(tp)), Some(guard))
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN)
}
fn signal_interrupt_errno(&self) -> Errno {
Errno::EINTR
}
fn signals_consumed_by_wait<M: MemoryAccess>(&self, memory: &M) -> KernelSigset {
self.set()
.and_then(|set| memory.read_value(set.cast::<KernelSigset>()).ok())
.unwrap_or(0)
}
}
impl TimeoutableSyscall for reverie::syscalls::RtSigtimedwait {
fn timeout_return_val(&self) -> Result<i64, Errno> {
Err(Errno::EAGAIN)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Read {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Write {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Readv {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Writev {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
fn network_comm_syscall<T: RecordOrReplay, G: Guest<Detcore<T>>, C: SyscallInfo + Into<Syscall>>(
call: C,
guest: &mut G,
) -> (C, Option<<G::Stack as Stack>::StackGuard>) {
let fd = get_fd(call.into()).unwrap_or_else(|| {
panic!(
"network_comm_syscall called on invalid syscall / unknown fd: {}",
call.name()
);
});
guest
.thread_state()
.with_detfd(fd, |detfd| {
assert!(
detfd.physically_nonblocking(),
"expecting sockets/pipes to be physically nonblocking"
);
})
.unwrap();
(call, None)
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Accept4 {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
impl TimeoutableSyscall for reverie::syscalls::Accept4 {
fn timeout_return_val(&self) -> Result<i64, Errno> {
Ok(0)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Recvfrom {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Recvmsg {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Recvmmsg {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Sendto {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Sendmmsg {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Sendmsg {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN) || res == Err(Errno::EWOULDBLOCK)
}
}
#[async_trait]
impl NonblockableSyscall for reverie::syscalls::Connect {
async fn into_nonblocking<T: RecordOrReplay, G: Guest<Detcore<T>>>(
self,
guest: &mut G,
) -> (Self, Option<<G::Stack as Stack>::StackGuard>) {
network_comm_syscall(self, guest)
}
fn syscall_would_have_blocked(&self, res: Result<i64, Errno>) -> bool {
res == Err(Errno::EAGAIN)
|| res == Err(Errno::EWOULDBLOCK)
|| res == Err(Errno::EINPROGRESS)
|| res == Err(Errno::EALREADY)
}
fn normalize_nonblocking_result(
&self,
res: Result<i64, Errno>,
retried: bool,
) -> Result<i64, Errno> {
match (retried, res) {
(true, Err(Errno::EISCONN)) => Ok(0),
(_, res) => res,
}
}
}
pub async fn retry_nonblocking_syscall<T, G, C>(
guest: &mut G,
call: C,
rsrc: Resources,
subtool: Option<&Detcore<T>>,
) -> Result<i64, Error>
where
C: NonblockableSyscall + Into<Syscall>,
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
retry_nonblocking_syscall_helper(guest, call, rsrc, None, subtool).await
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct RestartBlock {
pub(crate) rip: u64,
pub(crate) deadline: Option<LogicalTime>,
pub(crate) call: RestartCall,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RestartCall {
Poll(syscalls::Poll),
Futex(syscalls::Futex),
Nanosleep(reverie::syscalls::family::NanosleepFamily),
}
impl RestartBlock {
pub(crate) fn resumed_at(self, rip: u64) -> Option<Self> {
(self.rip == rip).then_some(self)
}
}
pub(crate) async fn keep_restart_block<T, G>(
guest: &mut G,
result: &Result<i64, Error>,
call: RestartCall,
deadline: Option<LogicalTime>,
) where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if matches!(result, Err(Error::Errno(errno)) if *errno == Errno::ERESTART_RESTARTBLOCK) {
let rip = guest.regs().await.rip;
let block = RestartBlock {
rip,
deadline,
call,
};
tracing::trace!(
"[tid {}] the wait keeps {:?} for its restart",
guest.tid(),
block
);
guest.thread_state_mut().restart_block = Some(block);
}
}
fn held_signal_restart_errno(restart_errno: Errno, signal: i32) -> Errno {
if restart_errno == Errno::ERESTART_RESTARTBLOCK && signal != libc::SIGSTOP {
Errno::ERESTARTNOHAND
} else {
restart_errno
}
}
pub(crate) fn poll_deadline_for<T, G>(
guest: &G,
deadline: Option<LogicalTime>,
) -> Option<LogicalTime>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if guest.config().recordreplay_modes {
None
} else {
deadline
}
}
pub async fn retry_nonblocking_syscall_with_timeout<T, G, C>(
guest: &mut G,
call: C,
rsrc: Resources,
maybe_timeout: Option<LogicalTime>,
) -> Result<i64, Error>
where
C: NonblockableSyscall + TimeoutableSyscall + Into<Syscall>,
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let maybe_tup = maybe_timeout.map(|t| (t, call.timeout_return_val()));
if guest
.config()
.backend
.supports_blocked_wait_signal_interruption
{
return retry_blocking_wait_with_kernel_signal_state(guest, call, rsrc, maybe_tup).await;
}
retry_nonblocking_syscall_helper(guest, call, rsrc, maybe_tup, None).await
}
pub(crate) fn guest_signal_state_task<T, G>(guest: &G) -> Option<(i32, i32)>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
crate::procfs_inode::guest_tids_name_host_tasks(&guest.config().backend, None)
.then(|| (guest.pid().as_raw(), guest.tid().as_raw()))
}
async fn own_disposition_interrupts<T, G>(
guest: &mut G,
status: ResumeStatus,
mask_addr: AddrMut<'_, KernelSigset>,
action_addr: AddrMut<'_, KernelSigaction>,
) -> Result<bool, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let query = syscalls::RtSigprocmask::new()
.with_how(libc::SIG_BLOCK)
.with_set(None)
.with_oldset(Some(mask_addr.cast()))
.with_sigsetsize(KERNEL_SIGSET_SIZE);
guest.inject_with_retry(query).await?;
let mask: KernelSigset = guest.memory().read_value(mask_addr)?;
Ok(
wait_signal_disposition(guest, status, &mask, action_addr, true)
.await?
.is_some(),
)
}
async fn retry_nonblocking_syscall_helper<T, G, C>(
guest: &mut G,
call0: C,
rsrc: Resources,
maybe_timeout: Option<(LogicalTime, Result<i64, Errno>)>,
subtool: Option<&Detcore<T>>,
) -> Result<i64, Error>
where
C: NonblockableSyscall + Into<Syscall>,
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let consumed = call0.signals_consumed_by_wait(&guest.memory());
let (mut call, mut maybe_stackguard) = call0.into_nonblocking(guest).await;
let mut rsrc = rsrc.clone();
rsrc.poll_deadline = poll_deadline_for(guest, maybe_timeout.map(|(deadline, _)| deadline));
if rsrc.signal_interrupt_errno().is_none()
&& rsrc.resources.len() == 1
&& rsrc.resources.contains_key(&ResourceID::InternalIOPolling)
&& call.signal_interrupt_errno() == Errno::ERESTARTSYS
{
rsrc.set_signal_interrupt_errno(Errno::ERESTARTSYS);
rsrc.signal_state_task = guest_signal_state_task(guest);
}
let checks_at_turn = rsrc.signal_interrupt_errno() == Some(Errno::ERESTARTSYS.into_raw())
&& decides_interruption_at_turn(guest, rsrc.signal_state_task);
let mut turn_wait = checks_at_turn
.then(|| KernelSignalWait::new(guest, 0, false, call.signal_interrupt_errno()));
let mut published = PublishedWaitMask::default();
let result: Result<i64, Error> = loop {
let resumed = match call.into() {
Syscall::Read(read) if maybe_timeout.is_none() && maybe_stackguard.is_none() => {
crate::tool_global::polled_read_request(guest, read, rsrc.clone()).await
}
_ => resource_request(guest, rsrc.clone()).await,
};
let turn = if checks_at_turn && !matches!(resumed, ResumeStatus::Signaled(None)) {
match turn_signals_with_block(
guest,
&mut turn_wait,
true,
committed_signals(&resumed),
rsrc.private_sigchld_decides,
&mut published,
)
.await
{
Ok(turn) => Some(turn),
Err(error) => break Err(error),
}
} else {
None
};
let reconvert =
maybe_stackguard.is_some() && crate::syscalls::timerfd::may_publish(guest, call.into());
if reconvert {
maybe_stackguard = None;
}
rsrc.poll_deadline = crate::syscalls::timerfd::publish_before_probe(
guest,
call.into(),
maybe_timeout.map(|(deadline, _)| deadline),
)
.await;
if reconvert {
(call, maybe_stackguard) = call0.into_nonblocking(guest).await;
}
let signaled = match turn {
Some(turn) => turn.ends(false),
None => matches!(resumed, ResumeStatus::Signaled(_)),
};
let pending = pending_real_time_among(guest, consumed).await;
act_on_pending_real_time(guest, pending, consumed, 0).await;
let res = match subtool {
Some(detcore) => {
detcore
.record_or_replay_preserving_tool_errors(guest, call)
.await
}
None => guest.inject_with_retry(call).await.map_err(Error::from),
};
let syscall_result = match res {
Ok(value) => Ok(value),
Err(Error::Errno(error)) => Err(error),
Err(error) => break Err(error),
};
if signaled && call.syscall_would_have_blocked(syscall_result) {
let errno = call.signal_interrupt_errno();
tracing::trace!(
"retry_nonblocking_syscall: interrupted by signal while {} would block: {:?}",
call.display(&guest.memory()),
errno
);
break Err(errno.into());
}
if call.syscall_would_have_blocked(syscall_result) {
rsrc.poll_attempt += 1;
if let Some((timeout, timeout_result)) = maybe_timeout {
let new_time = thread_observe_time(guest).await;
if new_time >= timeout {
tracing::trace!(
"Timing out syscall after #{} retries: {}",
rsrc.poll_attempt - 1,
call.display(&guest.memory())
);
break timeout_result.map_err(|e| e.into());
} else {
tracing::trace!(
"Retry #{} for syscall due to result {:?}, {} from timeout: {}",
rsrc.poll_attempt,
syscall_result,
timeout - new_time,
call.display(&guest.memory())
);
record_retry_event(guest, call).await;
}
} else {
tracing::trace!(
"Retry #{} for syscall due to result {:?}: {}",
rsrc.poll_attempt,
syscall_result,
call.display(&guest.memory())
);
record_retry_event(guest, call).await;
}
} else {
let res = call
.normalize_nonblocking_result(syscall_result, rsrc.poll_attempt > 0)
.map_err(|e| e.into());
tracing::trace!(
"retry_nonblocking_syscall: syscall completed after {} retries: {} = {:?}",
rsrc.poll_attempt,
call.display(&guest.memory()),
res
);
break res;
}
};
match turn_wait {
Some(mut wait) if wait.effective_mask().is_some() => {
let restored = wait.restore(guest, None).await;
publish_wait_mask(guest, None, &mut published).await;
match result_after_restore(restored, result) {
Ok(result) => refuse_held_signal_loss(guest, call0.number(), result).await,
Err(error) => Err(error),
}
}
_ => result,
}
}
fn committed_signals(resumed: &ResumeStatus) -> KernelSigset {
match resumed {
ResumeStatus::Signaled(Some(signals)) => signals.iter().fold(0, |set, signal| {
set | kernel_sigset_bit(signal.0 as libc::c_int)
}),
_ => 0,
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct TurnSignals {
named: KernelSigset,
pending: KernelSigset,
}
impl TurnSignals {
fn ends(&self, progress: bool) -> bool {
self.pending != 0 || (progress && self.named != 0)
}
}
async fn read_turn_signals<T, G>(
guest: &mut G,
mask: Option<KernelSigset>,
committed: KernelSigset,
real_time: NamedRealTime,
) -> Result<TurnSignals, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
Ok(
read_turn_signals_and_state(guest, mask, committed, real_time)
.await?
.0,
)
}
async fn read_turn_signals_and_state<T, G>(
guest: &mut G,
mask: Option<KernelSigset>,
committed: KernelSigset,
real_time: NamedRealTime,
) -> Result<(TurnSignals, KernelSignalState), Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let state = read_wait_signal_state(guest.pid(), guest.tid())?;
let mask = mask.unwrap_or(state.blocked);
let host_timed = host_timed_signals(guest).await;
Ok((
turn_signals_from_state(guest, &state, mask, host_timed, committed, real_time, 0).await,
state,
))
}
async fn turn_signals_from_state<T, G>(
guest: &mut G,
state: &KernelSignalState,
mask: KernelSigset,
host_timed: KernelSigset,
committed: KernelSigset,
real_time: NamedRealTime,
private: KernelSigset,
) -> TurnSignals
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let before =
turn_signals_before_discard(state, mask, host_timed, committed, real_time, private);
let pending =
crate::syscalls::threads::without_discarded(guest, state, before.pending, committed).await;
TurnSignals { pending, ..before }
}
async fn turn_signals_with_block<T, G>(
guest: &mut G,
wait: &mut Option<KernelSignalWait>,
may_block: bool,
committed: KernelSigset,
private_decides: bool,
published: &mut PublishedWaitMask,
) -> Result<TurnSignals, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let mask = wait.as_ref().and_then(KernelSignalWait::effective_mask);
let state = read_wait_signal_state(guest.pid(), guest.tid())?;
let (host_timed, recorded) = crate::tool_global::host_timed_and_private_sigchld(guest).await;
let mut private = 0;
if let Some(wait) = wait.as_mut() {
if may_block
&& wait.needs_block()
&& pending_could_stop_injection(&state)
&& wait.block_in_place(guest, host_timed).await?
{
publish_wait_mask(guest, wait.effective_mask(), published).await;
}
if private_decides
&& wait.saved_mask.is_some()
&& state.thread_pending & kernel_sigset_bit(libc::SIGCHLD) != 0
{
private = recorded;
}
}
let mask = mask.unwrap_or(state.blocked);
Ok(turn_signals_from_state(
guest,
&state,
mask,
host_timed,
committed,
NamedRealTime::Woken,
private,
)
.await)
}
fn pending_could_stop_injection(state: &KernelSignalState) -> bool {
state.pending & !state.blocked & blocked_signal_mask() != 0
}
fn turn_signals_before_discard(
state: &KernelSignalState,
mask: KernelSigset,
host_timed: KernelSigset,
committed: KernelSigset,
real_time: NamedRealTime,
private: KernelSigset,
) -> TurnSignals {
use crate::scheduler::discarded_at_send::STANDARD_SIGNALS;
let held =
crate::syscalls::threads::futex_wait_held_after_wake(host_timed, committed) & !private;
let pending = state.pending_interrupting(mask, false) & !held;
let counted = match real_time {
NamedRealTime::Woken => !0,
NamedRealTime::ByDisposition => {
STANDARD_SIGNALS | (state.interrupting(mask) & !STANDARD_SIGNALS)
}
};
let named = committed & !mask & counted;
TurnSignals { named, pending }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum NamedRealTime {
Woken,
ByDisposition,
}
fn decides_interruption_at_turn<T, G>(guest: &G, task: Option<(i32, i32)>) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
task.is_some() && crate::scheduler::discarded_at_send::records(guest.config())
}
async fn install_turn_mask<T, G>(
guest: &mut G,
wait: &mut KernelSignalWait,
cell: AddrMut<'_, KernelSigset>,
) -> Result<KernelSigset, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let state = read_wait_signal_state(guest.pid(), guest.tid())?;
let kept = crate::syscalls::threads::without_discarded(guest, &state, state.pending, 0).await;
wait.hold_until_return(host_timed_signals(guest).await | (state.pending & !kept));
wait.block(guest, Some(cell)).await?;
let Some(mask) = wait.effective_mask() else {
return Err(Errno::EFAULT.into());
};
crate::tool_global::set_saved_guest_sigmask(guest, Some(mask)).await;
Ok(mask)
}
#[derive(Debug, Default)]
pub(crate) struct PublishedWaitMask(Option<KernelSigset>);
pub(crate) async fn publish_wait_mask<T, G>(
guest: &mut G,
mask: Option<KernelSigset>,
published: &mut PublishedWaitMask,
) where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if mask == published.0
|| !detcore_model::bundled_signal_facts::models_signal_targets(guest.config())
{
return;
}
crate::tool_global::set_saved_guest_sigmask(guest, mask).await;
published.0 = mask;
}
async fn retry_blocking_wait_with_kernel_signal_state<T, G, C>(
guest: &mut G,
call0: C,
rsrc: Resources,
maybe_timeout: Option<(LogicalTime, Result<i64, Errno>)>,
) -> Result<i64, Error>
where
C: NonblockableSyscall + Into<Syscall>,
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
retry_blocking_wait_under_mask(guest, call0, rsrc, maybe_timeout, None)
.await
.0
}
pub(crate) async fn retry_blocking_wait_under_mask<T, G, C>(
guest: &mut G,
call0: C,
rsrc: Resources,
maybe_timeout: Option<(LogicalTime, Result<i64, Errno>)>,
wait_mask: Option<KernelSigset>,
) -> (Result<i64, Error>, bool)
where
C: NonblockableSyscall + Into<Syscall>,
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let mut signals = KernelSignalWait::new(
guest,
call0.signals_consumed_by_wait(&guest.memory()),
call0.restart_keeps_deadline(),
call0.kernel_restart_errno(),
)
.with_deadline(maybe_timeout.is_some())
.with_wait_mask(wait_mask);
let mut deliver_under_wait_mask = false;
let mut published = PublishedWaitMask::default();
publish_wait_mask(guest, signals.effective_mask(), &mut published).await;
let mut rsrc = rsrc.clone();
rsrc.poll_deadline = poll_deadline_for(guest, maybe_timeout.map(|(deadline, _)| deadline));
let (mut call, mut guard) = call0.into_nonblocking(guest).await;
let mut first_turn = true;
let mut interrupt_after_probe;
let result = loop {
interrupt_after_probe = false;
let resumed = resource_request(guest, rsrc.clone()).await;
let (host_timed, recorded) =
crate::tool_global::host_timed_and_private_sigchld(guest).await;
signals.hold_until_return(host_timed);
let committed = committed_signals(&resumed) & kernel_sigset_bit(libc::SIGCHLD);
let private = match signals
.admit_under_block(guest, committed, recorded, host_timed, &mut published)
.await
{
Ok(private) => private,
Err(error) => break Err(error),
};
signals.admit(committed, private);
let reconvert =
guard.is_some() && crate::syscalls::timerfd::may_publish(guest, call.into());
if reconvert {
guard = None;
}
rsrc.poll_deadline = crate::syscalls::timerfd::publish_before_probe(
guest,
call.into(),
maybe_timeout.map(|(deadline, _)| deadline),
)
.await;
if reconvert {
(call, guard) = call0.into_nonblocking(guest).await;
}
let pending = pending_real_time_among(guest, REAL_TIME_SIGNALS).await;
if pending != 0 {
match signals.observable_now() {
Ok(observable) => act_on_pending_real_time(guest, pending, observable, 0).await,
Err(error) => break Err(error),
}
}
let first = std::mem::take(&mut first_turn);
let injected = if first {
signals.inject_first_probe(guest, call).await
} else {
let state = match signals.interrupted_with_state() {
Ok((false, state)) => state,
Ok((true, state)) if signals.interrupts_only_by_committed(&state) => {
interrupt_after_probe = true;
deliver_under_wait_mask = signals.interrupts_only_under_wait_mask(&state);
state
}
Ok((true, state)) => {
deliver_under_wait_mask = signals.interrupts_only_under_wait_mask(&state);
let errno = call0.kernel_restart_errno();
tracing::trace!(
"retry_nonblocking_syscall: pending signals interrupt {}: {:?}",
call.display(&guest.memory()),
errno
);
break Err(errno.into());
}
Err(error) => break Err(error),
};
signals.inject_absorbing_after(guest, call, state).await
};
let syscall_result = match injected {
Ok(result) => result,
Err(error) => {
tracing::trace!(
"retry_nonblocking_syscall: a signal stop ends the wait in {}: {:?}",
call.display(&guest.memory()),
error
);
break Err(error);
}
};
if !call.syscall_would_have_blocked(syscall_result) {
let res = call
.normalize_nonblocking_result(syscall_result, rsrc.poll_attempt > 0)
.map_err(|e| e.into());
tracing::trace!(
"retry_nonblocking_syscall: syscall completed after {} retries: {} = {:?}",
rsrc.poll_attempt,
call.display(&guest.memory()),
res
);
break res;
}
if interrupt_after_probe {
let errno = call0.kernel_restart_errno();
tracing::trace!(
"retry_nonblocking_syscall: a committed signal interrupts {}: {:?}",
call.display(&guest.memory()),
errno
);
break Err(errno.into());
}
if first {
match signals.interrupted_with_state() {
Ok((false, _)) => {}
Ok((true, state)) => {
deliver_under_wait_mask = signals.interrupts_only_under_wait_mask(&state);
let errno = call0.kernel_restart_errno();
tracing::trace!(
"retry_nonblocking_syscall: pending signals interrupt {}: {:?}",
call.display(&guest.memory()),
errno
);
break Err(errno.into());
}
Err(error) => break Err(error),
}
}
if signals.needs_block() {
guard = None;
if let Err(error) = signals.block(guest, None).await {
break Err(error);
}
publish_wait_mask(guest, signals.effective_mask(), &mut published).await;
(call, guard) = call0.into_nonblocking(guest).await;
}
rsrc.poll_attempt += 1;
if let Some((timeout, timeout_result)) = maybe_timeout {
let new_time = thread_observe_time(guest).await;
if new_time >= timeout {
tracing::trace!(
"Timing out syscall after #{} retries: {}",
rsrc.poll_attempt - 1,
call.display(&guest.memory())
);
break timeout_result.map_err(|e| e.into());
}
tracing::trace!(
"Retry #{} for syscall due to result {:?}, {} from timeout: {}",
rsrc.poll_attempt,
syscall_result,
timeout - new_time,
call.display(&guest.memory())
);
} else {
tracing::trace!(
"Retry #{} for syscall due to result {:?}: {}",
rsrc.poll_attempt,
syscall_result,
call.display(&guest.memory())
);
}
record_retry_event(guest, call).await;
};
drop(guard);
let restored = signals.restore(guest, None).await;
publish_wait_mask(guest, None, &mut published).await;
let result = match result_after_restore(restored, result) {
Ok(result) => result,
Err(error) => return (Err(error), false),
};
let deliver = deliver_under_wait_mask && !signals.holds_signal() && result.is_err();
(
refuse_held_signal_loss(guest, call0.number(), result).await,
deliver,
)
}
pub(crate) async fn refuse_unserviceable_operation_with<T, G>(
guest: &mut G,
panic_on_unsupported_syscalls: bool,
sysno: Sysno,
fallback: Errno,
reason: Option<&str>,
) -> Result<i64, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if !panic_on_unsupported_syscalls {
return Err(fallback.into());
}
if guest.config().shutdown_on_unsupported_syscall {
let reason = match reason {
Some(reason) => format!("{sysno}: {reason}"),
None => format!(
"{sysno} cannot be serviced on this backend (with \
--allow-unsupported-syscalls the guest would see {fallback})"
),
};
crate::tool_global::report_policy_refusal(guest, reason).await;
crate::tool_global::unrecoverable_shutdown(
guest,
detcore_model::HERMIT_POLICY_REFUSAL_EXIT,
)
.await;
}
if guest.config().exit_on_unsupported_syscall {
return Err(Error::Tool(anyhow::Error::new(
crate::UnsupportedSyscallError(sysno),
)));
}
panic!("unserviceable operation on syscall: {sysno:?}");
}
pub(crate) async fn refuse_held_signal_loss<T, G>(
guest: &mut G,
sysno: Sysno,
result: Result<i64, Error>,
) -> Result<i64, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
use std::io::Write as _;
let refusal = match &result {
Err(Error::Tool(error)) => match error.downcast_ref::<HeldSignalRefusal>() {
Some(refusal) => HeldSignalRefusal {
wait: Some(sysno),
..*refusal
},
None => return result,
},
_ => return result,
};
let panic_on_unsupported_syscalls = guest.config().panic_on_unsupported_syscalls;
tracing::error!("[tid {}] {}", guest.tid(), refusal);
if panic_on_unsupported_syscalls {
let _ = writeln!(crate::util::RetryingStderr, "{refusal}");
}
refuse_unserviceable_operation_with(
guest,
panic_on_unsupported_syscalls,
sysno,
Errno::ERESTARTNOINTR,
None,
)
.await
}
pub(crate) const REAL_TIME_SIGNALS: KernelSigset = !0 << 31;
pub(crate) fn unblocked_by(
state: &KernelSignalState,
mask: KernelSigset,
) -> (KernelSigset, KernelSigset) {
unblocked_by_ignored(state.ignored, mask)
}
pub(crate) fn unblocked_by_ignored(
ignored: KernelSigset,
mask: KernelSigset,
) -> (KernelSigset, KernelSigset) {
let unblocked = !mask;
(unblocked & !ignored, unblocked & ignored)
}
pub(crate) async fn pending_real_time_among<T, G>(guest: &mut G, candidates: KernelSigset) -> u64
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let candidates = candidates & REAL_TIME_SIGNALS;
if candidates == 0 || !crate::scheduler::real_time_expiration_kept_pending() {
return 0;
}
let Some(detpid) = guest.thread_state().detpid else {
return 0;
};
crate::tool_global::pending_real_time_expirations(guest, detpid).await & candidates
}
pub(crate) async fn act_on_pending_real_time<T, G>(
guest: &mut G,
pending: KernelSigset,
observable: KernelSigset,
discarded: KernelSigset,
) where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let observed = pending & observable;
if observed != 0 {
crate::scheduler::refuse_real_time_expiration(observed.trailing_zeros() as i32 + 1);
}
if pending & discarded != 0
&& let Some(detpid) = guest.thread_state().detpid
{
crate::tool_global::discard_pending_real_time_expirations(
guest,
detpid,
pending & discarded,
)
.await;
}
}
pub(crate) async fn observe_under_mask<T, G>(guest: &mut G, mask: KernelSigset) -> Result<(), Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let pending = pending_real_time_among(guest, !mask).await;
if pending != 0 {
let ignored = match crate::syscalls::signal_shadow::copied_dispositions(guest) {
Some(copied) => copied.ignored,
None => read_thread_wait_signal_state(guest.pid(), guest.tid())?.ignored,
};
let (observable, discarded) = unblocked_by_ignored(ignored, mask);
act_on_pending_real_time(guest, pending, observable, discarded).await;
}
Ok(())
}
pub(crate) struct KernelSignalWait {
pid: reverie::Pid,
tid: reverie::Pid,
consumed: KernelSigset,
defers_default_stops: bool,
restart_errno: Errno,
held_until_return: KernelSigset,
deadline: bool,
saved_mask: Option<KernelSigset>,
unblockable: bool,
blocked_in_place: bool,
held: Option<HeldSignal>,
held_unidentified: bool,
host_timed: KernelSigset,
committed: KernelSigset,
private: KernelSigset,
wait_mask: Option<KernelSigset>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct HeldSignal {
signal: i32,
queue: SignalQueue,
kind: HeldKind,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
enum HeldKind {
Harmless,
Precious,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum HeldSignalLoss {
Replaced,
UnidentifiedStop,
StopBound,
Consumed,
Restoration,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct HeldSignalRefusal {
pub(crate) wait: Option<Sysno>,
pub(crate) held: Option<i32>,
pub(crate) replacing: Option<i32>,
pub(crate) loss: HeldSignalLoss,
}
fn signal_label(signal: Option<i32>) -> String {
match signal {
Some(signal) => match nix::sys::signal::Signal::try_from(signal) {
Ok(named) => named.as_str().to_string(),
Err(_) => format!("signal {signal}"),
},
None => "a signal that could not be identified".to_string(),
}
}
impl std::fmt::Display for HeldSignalRefusal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let wait = self
.wait
.map_or_else(|| "a blocking".to_string(), |sysno| sysno.to_string());
let held = match self.held {
Some(_) => format!("the held signal {}", signal_label(self.held)),
None => "a held signal that could not be identified".to_string(),
};
let replacing = signal_label(self.replacing);
match self.loss {
HeldSignalLoss::Replaced => write!(
f,
"unsupported: the {wait} wait cannot keep {held}: the pending {replacing} \
would stop the next injection and replace it"
)?,
HeldSignalLoss::UnidentifiedStop => write!(
f,
"unsupported: the {wait} wait cannot keep {held}: a signal stop that /proc \
cannot identify replaced it"
)?,
HeldSignalLoss::StopBound => write!(
f,
"unsupported: the {wait} wait cannot keep {held}: the wait absorbed the \
maximum number of signal stops"
)?,
HeldSignalLoss::Consumed => {
write!(
f,
"unsupported: the {wait} wait cannot return {replacing}, which it consumes: \
the signal stopped an injection, so the backend would deliver it instead"
)?;
if self.held.is_some() {
write!(f, ", in place of {held}")?;
}
}
HeldSignalLoss::Restoration => write!(
f,
"unsupported: the {wait} wait cannot keep {held}: {replacing} stopped the \
injection that puts the guest's signal mask back and replaced it"
)?,
}
write!(
f,
" (scope reduction of https://github.com/rrnewton/hermit/pull/3361; rerun with \
--allow-unsupported-syscalls to restart the call instead)"
)
}
}
impl std::error::Error for HeldSignalRefusal {}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum StopVerdict {
Absorb(HeldKind),
End(Errno),
}
const KERNEL_SIGRTMIN: i32 = 32;
impl KernelSignalWait {
pub(crate) fn new<T, G>(
guest: &G,
consumed: KernelSigset,
defers_default_stops: bool,
restart_errno: Errno,
) -> Self
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
Self {
pid: guest.pid(),
tid: guest.tid(),
consumed,
defers_default_stops,
restart_errno,
held_until_return: kernel_sigset_bit(libc::SIGCHLD),
deadline: false,
saved_mask: None,
unblockable: false,
blocked_in_place: false,
held: None,
held_unidentified: false,
host_timed: 0,
committed: 0,
private: 0,
wait_mask: None,
}
}
pub(crate) fn with_deadline(self, deadline: bool) -> Self {
Self { deadline, ..self }
}
pub(crate) fn for_select<T, G>(guest: &G) -> Self
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
Self {
held_until_return: 0,
..Self::new(guest, 0, false, Errno::ERESTARTNOHAND)
}
}
pub(crate) fn with_wait_mask(self, mask: Option<KernelSigset>) -> Self {
Self {
wait_mask: mask,
..self
}
}
pub(crate) fn effective_mask(&self) -> Option<KernelSigset> {
self.wait_mask.or(self.saved_mask)
}
pub(crate) fn holds_signal(&self) -> bool {
self.held.is_some() || self.held_unidentified
}
pub(crate) fn interrupts_only_under_wait_mask(&self, state: &KernelSignalState) -> bool {
let own_mask = self.saved_mask.unwrap_or(state.blocked);
let held_until_return = self.held_until_return & !self.committed;
let could_interrupt = self.could_interrupt(state);
let interrupting = (state.pending & !held_until_return
| state.thread_pending & self.private)
& could_interrupt;
self.wait_mask.is_some() && interrupting & own_mask != 0
}
pub(crate) fn hold_until_return(&mut self, signals: KernelSigset) {
self.held_until_return |= signals;
self.host_timed |= signals;
}
pub(crate) fn admit(&mut self, committed: KernelSigset, private: KernelSigset) {
self.committed = committed & !self.host_timed;
self.private = private & !self.host_timed;
}
pub(crate) async fn admit_under_block<T, G>(
&mut self,
guest: &mut G,
committed: KernelSigset,
recorded: KernelSigset,
host_timed: KernelSigset,
published: &mut PublishedWaitMask,
) -> Result<KernelSigset, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if (committed | recorded) & !host_timed == 0 {
return Ok(0);
}
if self.needs_block() {
if self.block_in_place(guest, host_timed).await? {
publish_wait_mask(guest, self.effective_mask(), published).await;
} else {
self.unblockable = false;
}
}
if recorded == 0 || self.saved_mask.is_none() {
return Ok(0);
}
let state = read_wait_signal_state(self.pid, self.tid)?;
Ok(recorded & state.thread_pending)
}
pub(crate) fn interrupts_only_by_committed(&self, state: &KernelSignalState) -> bool {
let held = self.held.map_or(0, |held| kernel_sigset_bit(held.signal));
let interrupting = (state.pending | held) & self.could_interrupt(state);
(self.committed | self.private) != 0 && interrupting & !self.held_until_return == 0
}
pub(crate) fn needs_block(&self) -> bool {
self.saved_mask.is_none() && !self.unblockable
}
pub(crate) fn observable_now(&self) -> Result<KernelSigset, Error> {
let state = read_wait_signal_state(self.pid, self.tid)?;
Ok(self.consumed | self.could_interrupt(&state))
}
fn could_interrupt(&self, state: &KernelSignalState) -> KernelSigset {
let guest_mask = self.wait_mask.or(self.saved_mask).unwrap_or(state.blocked);
state.interrupting_wait(guest_mask, self.defers_default_stops) & !self.consumed
}
#[cfg(test)]
pub(crate) fn interrupted(&self) -> Result<bool, Error> {
Ok(self.interrupted_with_state()?.0)
}
pub(crate) fn interrupted_with_state(&self) -> Result<(bool, KernelSignalState), Error> {
let state = read_wait_signal_state(self.pid, self.tid)?;
let could_interrupt = self.could_interrupt(&state);
let held = self.held.map_or(0, |held| kernel_sigset_bit(held.signal));
let held_until_return = self.held_until_return & !self.committed;
let interrupting = ((state.pending | held) & !held_until_return
| state.thread_pending & self.private)
& could_interrupt;
if interrupting != 0 {
tracing::trace!(
"[tid {}] pending signals {:#x} interrupt a blocking wait",
self.tid,
interrupting
);
}
Ok((interrupting != 0, state))
}
pub(crate) async fn inject_absorbing<T, G, S>(
&mut self,
guest: &mut G,
call: S,
) -> Result<Result<i64, Errno>, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
S: SyscallInfo,
{
self.inject_absorbing_from(guest, call, None, false).await
}
pub(crate) async fn inject_first_probe<T, G, S>(
&mut self,
guest: &mut G,
call: S,
) -> Result<Result<i64, Errno>, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
S: SyscallInfo,
{
self.inject_absorbing_from(guest, call, None, true).await
}
pub(crate) async fn inject_absorbing_after<T, G, S>(
&mut self,
guest: &mut G,
call: S,
state: KernelSignalState,
) -> Result<Result<i64, Errno>, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
S: SyscallInfo,
{
let first = self.saved_mask.is_some().then_some(state);
self.inject_absorbing_from(guest, call, first, false).await
}
async fn inject_absorbing_from<T, G, S>(
&mut self,
guest: &mut G,
call: S,
mut first: Option<KernelSignalState>,
first_probe: bool,
) -> Result<Result<i64, Errno>, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
S: SyscallInfo,
{
const MAX_ABSORBED_STOPS: usize = 64;
let mut absorbed = 0;
loop {
let before = match first.take() {
Some(state) => state,
None => read_wait_signal_state(self.pid, self.tid)?,
};
let ends_wait = self.could_interrupt(&before) & !self.held_until_return;
if !first_probe && before.pending & ends_wait != 0 {
return Err(self.restart_errno.into());
}
let next = before.next_dequeued(before.blocked);
if let Some((signal, queue)) = next
&& self.would_replace_precious(signal, queue)
{
if let Some(held) = self.held
&& self.held_ends_wait(&before, held.signal)
{
tracing::trace!(
"[tid {}] signal {} would replace the held signal {}, which ends the wait",
self.tid,
signal,
held.signal
);
return Err(held_signal_restart_errno(self.restart_errno, held.signal).into());
}
tracing::trace!(
"[tid {}] signal {} would replace the held signal {:?}; the wait is refused",
self.tid,
signal,
self.held
);
return Err(self.refusal(Some(signal), HeldSignalLoss::Replaced));
}
let result = guest.inject(call).await;
let Err(errno) = result else {
return Ok(result);
};
if !probe_was_interrupted_by_signal(errno) {
return Ok(result);
}
let after = read_wait_signal_state(self.pid, self.tid)?;
if self.wait_mask.is_some()
&& errno == Errno::ERESTARTNOHAND
&& after.blocked != before.blocked
{
return Ok(result);
}
let identified =
next.filter(|&(signal, queue)| stop_took_only(&before, &after, signal, queue));
let Some((signal, queue)) = identified else {
if self.holds_precious() {
tracing::trace!(
"[tid {}] a signal stop that cannot be identified replaced the held signal {:?}; the wait is refused",
self.tid,
self.held
);
return Err(self.refusal(None, HeldSignalLoss::UnidentifiedStop));
}
if !self.deadline && absorbed >= MAX_ABSORBED_STOPS {
self.held = None;
self.held_unidentified = true;
return Err(self.refusal(None, HeldSignalLoss::StopBound));
}
absorbed += 1;
tracing::trace!(
"[tid {}] a signal stop that cannot be identified is held; the injection runs again",
self.tid
);
self.held = None;
self.held_unidentified = true;
continue;
};
let bit = kernel_sigset_bit(signal);
let verdict = match self.stop_verdict(&before, signal) {
StopVerdict::End(_)
if first_probe
&& self.consumed & bit == 0
&& self.could_interrupt(&before) & bit != 0 =>
{
StopVerdict::Absorb(HeldKind::Precious)
}
verdict => verdict,
};
match verdict {
StopVerdict::Absorb(kind) => {
let kind = self.held.map_or(kind, |held| held.kind.max(kind));
let unidentified = self.held_unidentified;
self.held = Some(HeldSignal {
signal,
queue,
kind,
});
self.held_unidentified = false;
if !self.deadline && absorbed >= MAX_ABSORBED_STOPS {
if kind == HeldKind::Precious || unidentified {
return Err(self.refusal(None, HeldSignalLoss::StopBound));
}
return Err(Errno::ERESTARTNOINTR.into());
}
absorbed += 1;
tracing::trace!(
"[tid {}] signal {} stopped an injection and is held ({:?})",
self.tid,
signal,
kind
);
}
StopVerdict::End(_)
if !self.deadline
&& self.consumed & bit != 0
&& (self.held_until_return & bit != 0 || self.holds_precious()) =>
{
tracing::trace!(
"[tid {}] consumed signal {} stopped an injection; the wait is refused",
self.tid,
signal
);
return Err(self.refusal(Some(signal), HeldSignalLoss::Consumed));
}
StopVerdict::End(errno) => {
return Err(held_signal_restart_errno(errno, signal).into());
}
}
}
}
fn stop_verdict(&self, before: &KernelSignalState, signal: i32) -> StopVerdict {
let bit = kernel_sigset_bit(signal);
let interrupts = if self.consumed & bit != 0 {
if !self.deadline {
return StopVerdict::End(Errno::ERESTARTNOINTR);
}
let guest_mask = self.wait_mask.or(self.saved_mask).unwrap_or(before.blocked);
before.interrupting_wait(guest_mask, self.defers_default_stops) & bit != 0
} else {
self.could_interrupt(before) & bit != 0
};
if interrupts {
return if self.held_until_return & bit != 0 {
StopVerdict::Absorb(HeldKind::Precious)
} else {
StopVerdict::End(self.restart_errno)
};
}
if signal == libc::SIGCHLD
|| (self.defers_default_stops && before.default_job_control_stops() & bit != 0)
{
return StopVerdict::Absorb(HeldKind::Precious);
}
let default_ignored = [libc::SIGCONT, libc::SIGURG, libc::SIGWINCH]
.into_iter()
.fold(0, |set, signal| set | kernel_sigset_bit(signal));
if (before.ignored | (default_ignored & !before.caught)) & bit != 0 {
return StopVerdict::Absorb(HeldKind::Harmless);
}
if self.deadline || self.wait_mask.is_some_and(|mask| mask & bit != 0) {
StopVerdict::Absorb(HeldKind::Precious)
} else {
StopVerdict::End(Errno::ERESTARTNOINTR)
}
}
fn would_replace_precious(&self, signal: i32, queue: SignalQueue) -> bool {
self.held_unidentified
|| self.held.is_some_and(|held| {
held.kind == HeldKind::Precious
&& !(signal == held.signal && queue == held.queue && signal < KERNEL_SIGRTMIN)
})
}
fn holds_precious(&self) -> bool {
self.held_unidentified
|| self
.held
.is_some_and(|held| held.kind == HeldKind::Precious)
}
fn refusal(&self, replacing: Option<i32>, loss: HeldSignalLoss) -> Error {
Error::Tool(anyhow::Error::new(HeldSignalRefusal {
wait: None,
held: self.held.map(|held| held.signal),
replacing,
loss,
}))
}
fn held_ends_wait(&self, before: &KernelSignalState, signal: i32) -> bool {
self.could_interrupt(before) & !self.held_until_return & kernel_sigset_bit(signal) != 0
}
pub(crate) async fn block<'a, T, G>(
&mut self,
guest: &mut G,
scratch: Option<AddrMut<'a, KernelSigset>>,
) -> Result<(), Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let guest_mask = read_wait_signal_state(self.pid, self.tid)?.blocked;
let mask = blocked_signal_mask() | guest_mask;
let result = match scratch {
Some(cell) => match guest.memory().write_value(cell, &mask) {
Ok(()) => {
self.inject_absorbing(guest, set_signal_mask_call(cell.into()))
.await
}
Err(errno) => Ok(Err(errno)),
},
None => {
let mut stack = guest.stack().await;
let cell = stack.push(mask);
match stack.commit() {
Ok(_guard) => {
self.inject_absorbing(guest, set_signal_mask_call(cell))
.await
}
Err(_) => Ok(Err(Errno::EFAULT)),
}
}
};
match result {
Ok(Ok(_)) => {
self.saved_mask = Some(guest_mask);
Ok(())
}
Ok(Err(errno)) => {
tracing::debug!(
"[tid {}] cannot block signals for a wait ({}); its probes run under the \
guest's mask",
self.tid,
errno
);
self.unblockable = true;
Ok(())
}
Err(error) => {
self.saved_mask = Some(guest_mask);
Err(error)
}
}
}
pub(crate) async fn block_in_place<T, G>(
&mut self,
guest: &mut G,
host_timed: KernelSigset,
) -> Result<bool, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
self.hold_until_return(host_timed);
let guest_mask = read_wait_signal_state(self.pid, self.tid)?.blocked;
match guest
.set_blocked_signals(blocked_signal_mask() | guest_mask)
.await
{
Ok(old) => {
self.saved_mask = Some(old);
self.blocked_in_place = true;
Ok(true)
}
Err(MaskChangeRefused::Failed {
errno,
mask_unknown: true,
}) => Err(self.mask_not_restored(1, Some(errno))),
Err(refused) => {
tracing::debug!(
"[tid {}] cannot block signals in place for a wait ({}); its attempts run \
under the guest's mask",
self.tid,
refused
);
self.unblockable = true;
Ok(false)
}
}
}
fn mask_not_restored(&self, attempts: usize, last_error: Option<Errno>) -> Error {
Error::Tool(anyhow::Error::new(
BlockedWaitSignalError::MaskNotRestored {
pid: self.pid,
tid: self.tid,
attempts,
last_error,
},
))
}
pub(crate) async fn restore<'a, T, G>(
&mut self,
guest: &mut G,
scratch: Option<AddrMut<'a, KernelSigset>>,
) -> Result<(), Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let Some(guest_mask) = self.saved_mask else {
return Ok(());
};
if std::mem::take(&mut self.blocked_in_place) {
match guest.set_blocked_signals(guest_mask).await {
Ok(_) | Err(MaskChangeRefused::Gone) => {
self.saved_mask = None;
return Ok(());
}
Err(MaskChangeRefused::Failed {
errno,
mask_unknown: true,
}) => {
self.saved_mask = None;
return Err(self.mask_not_restored(1, Some(errno)));
}
Err(refused) => {
tracing::debug!(
"[tid {}] cannot restore the mask in place ({}); injecting it",
self.tid,
refused
);
}
}
}
let restored = self.restore_mask(guest, guest_mask, scratch).await;
self.saved_mask = None;
restored
}
async fn restore_mask<'a, T, G>(
&mut self,
guest: &mut G,
guest_mask: KernelSigset,
scratch: Option<AddrMut<'a, KernelSigset>>,
) -> Result<(), Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
const ATTEMPTS: usize = 16;
let mut attempts = 0;
let mut last_error = None;
let mut stopped = None;
let mut loss = None;
while attempts < ATTEMPTS {
let state = read_wait_signal_state(self.pid, self.tid)?;
if let Some(before) = stopped.take() {
let replaced = self.absorb_restoration_stop(&before, &state);
loss = loss.or(replaced);
}
if state.blocked == guest_mask {
return loss.map_or(Ok(()), Err);
}
attempts += 1;
match inject_signal_mask(guest, guest_mask, scratch).await {
Ok(()) => return loss.map_or(Ok(()), Err),
Err(errno) if probe_was_interrupted_by_signal(errno) => {
last_error = Some(errno);
stopped = Some(state);
}
Err(errno) => {
last_error = Some(errno);
break;
}
}
}
let state = read_wait_signal_state(self.pid, self.tid)?;
if let Some(before) = stopped.take() {
let replaced = self.absorb_restoration_stop(&before, &state);
loss = loss.or(replaced);
}
if state.blocked == guest_mask {
return loss.map_or(Ok(()), Err);
}
Err(Error::Tool(anyhow::Error::new(
BlockedWaitSignalError::MaskNotRestored {
pid: self.pid,
tid: self.tid,
attempts,
last_error,
},
)))
}
fn absorb_restoration_stop(
&mut self,
before: &KernelSignalState,
after: &KernelSignalState,
) -> Option<Error> {
let identified = before
.next_dequeued(before.blocked)
.filter(|&(signal, queue)| stop_took_only(before, after, signal, queue));
let Some((signal, queue)) = identified else {
let loss = self
.holds_precious()
.then(|| self.refusal(None, HeldSignalLoss::Restoration));
tracing::trace!(
"[tid {}] a signal stop that cannot be identified stopped the mask restoration; it replaced the held signal {:?}",
self.tid,
self.held
);
self.held = None;
self.held_unidentified = true;
return loss;
};
let loss = self
.would_replace_precious(signal, queue)
.then(|| self.refusal(Some(signal), HeldSignalLoss::Restoration));
let kind = match self.stop_verdict(before, signal) {
StopVerdict::Absorb(kind) => kind,
StopVerdict::End(_) => HeldKind::Precious,
};
let kind = self.held.map_or(kind, |held| held.kind.max(kind));
tracing::trace!(
"[tid {}] signal {} stopped the mask restoration and is held ({:?}) in place of {:?}",
self.tid,
signal,
kind,
self.held
);
self.held = Some(HeldSignal {
signal,
queue,
kind,
});
self.held_unidentified = false;
loss
}
}
pub(crate) fn result_after_restore(
restored: Result<(), Error>,
result: Result<i64, Error>,
) -> Result<Result<i64, Error>, Error> {
let is_refusal =
|error: &Error| matches!(error, Error::Tool(error) if error.is::<HeldSignalRefusal>());
match restored {
Ok(()) => Ok(result),
Err(refusal) if is_refusal(&refusal) => match &result {
Err(error) if is_refusal(error) => Ok(result),
_ => Ok(Err(refusal)),
},
Err(error) => Err(error),
}
}
async fn inject_signal_mask<'a, T, G>(
guest: &mut G,
mask: KernelSigset,
scratch: Option<AddrMut<'a, KernelSigset>>,
) -> Result<(), Errno>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
match scratch {
Some(cell) => {
guest.memory().write_value(cell, &mask)?;
guest
.inject(set_signal_mask_call(cell.into()))
.await
.map(drop)
}
None => {
let mut stack = guest.stack().await;
let cell = stack.push(mask);
let _guard = stack.commit().map_err(|_| Errno::EFAULT)?;
guest.inject(set_signal_mask_call(cell)).await.map(drop)
}
}
}
fn set_signal_mask_call(cell: Addr<'_, KernelSigset>) -> syscalls::RtSigprocmask {
syscalls::RtSigprocmask::new()
.with_how(libc::SIG_SETMASK)
.with_set(Some(cell.cast()))
.with_oldset(None)
.with_sigsetsize(KERNEL_SIGSET_SIZE)
}
fn stop_took_only(
before: &KernelSignalState,
after: &KernelSignalState,
signal: i32,
queue: SignalQueue,
) -> bool {
let bit = kernel_sigset_bit(signal);
let other = match queue {
SignalQueue::Thread => SignalQueue::Shared,
SignalQueue::Shared => SignalQueue::Thread,
};
before.blocked == after.blocked
&& before.ignored == after.ignored
&& before.caught == after.caught
&& after.queued(queue) & bit == 0
&& before.queued(queue) & !bit & !after.queued(queue) == 0
&& before.queued(other) & !after.queued(other) == 0
}
pub(crate) fn probe_was_interrupted_by_signal(errno: Errno) -> bool {
matches!(
errno,
Errno::EINTR
| Errno::ERESTARTSYS
| Errno::ERESTARTNOINTR
| Errno::ERESTARTNOHAND
| Errno::ERESTART_RESTARTBLOCK
)
}
pub(crate) async fn record_retry_event<G, C, T>(guest: &mut G, call: C)
where
C: SyscallInfo,
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let dettid = guest.thread_state().dettid;
let cfg = &guest.config();
if cfg.sequentialize_threads && cfg.should_trace_schedevent() {
trace_schedevent(
guest,
with_guest_time(
guest,
SchedEvent::syscall(dettid, call.number(), SyscallPhase::Polling),
),
true,
)
.await;
}
}
pub fn with_guest_time<G, T>(guest: &G, event: SchedEvent) -> SchedEvent
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
let dettime = &guest.thread_state().thread_logical_time;
event.with_dettime(dettime)
}
pub async fn with_guest_rip<G, T>(guest: &mut G, mut event: SchedEvent) -> SchedEvent
where
G: Guest<Detcore<T>>,
T: RecordOrReplay,
{
assert!(event.end_rip.is_none());
let regs = guest.regs().await;
let end_rip = NonZeroUsize::new(regs.rip.try_into().unwrap()).unwrap();
event.end_rip = Some(end_rip);
event
}
pub async fn millis_duration_to_absolute_timeout<G: Guest<Detcore<T>>, T: RecordOrReplay>(
guest: &mut G,
timeout_millis: i32,
) -> Option<LogicalTime> {
match positive_millis_as_nanos(timeout_millis) {
Some(timeout_nanos) => nanos_duration_to_absolute_timeout(guest, timeout_nanos).await,
None => None,
}
}
fn positive_millis_as_nanos(timeout_millis: i32) -> Option<u128> {
(timeout_millis > 0).then(|| (timeout_millis as u128) * 1_000_000)
}
pub async fn nanos_duration_to_absolute_timeout<G: Guest<Detcore<T>>, T: RecordOrReplay>(
guest: &mut G,
timeout_nanos: u128,
) -> Option<LogicalTime> {
if timeout_nanos > 0 {
let ns_delta = Duration::from_nanos(timeout_nanos as u64);
let base_time = thread_observe_time(guest).await;
let target_time = base_time + ns_delta;
Some(target_time)
} else {
None
}
}
pub fn poll_nfds(nfds: libc::nfds_t) -> u32 {
nfds as u32
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn millis_to_nanos_conversion() {
assert_eq!(positive_millis_as_nanos(-1), None);
assert_eq!(positive_millis_as_nanos(i32::MIN), None);
assert_eq!(positive_millis_as_nanos(0), None);
assert_eq!(positive_millis_as_nanos(1), Some(1_000_000));
assert_eq!(positive_millis_as_nanos(1_000), Some(1_000_000_000));
assert_eq!(
positive_millis_as_nanos(i32::MAX),
Some(i32::MAX as u128 * 1_000_000)
);
for millis in [1, 2, 7, 250, 1_000, 86_400_000] {
assert_eq!(
positive_millis_as_nanos(millis),
Some(millis as u128 * 1_000_000),
"1 ms must convert to 1_000_000 ns, not 1_000"
);
}
}
#[test]
fn connect_nonblocking_results() {
let call = reverie::syscalls::Connect::new();
assert!(call.syscall_would_have_blocked(Err(Errno::EINPROGRESS)));
assert!(call.syscall_would_have_blocked(Err(Errno::EALREADY)));
assert_eq!(
call.normalize_nonblocking_result(Err(Errno::EISCONN), true),
Ok(0)
);
assert_eq!(
call.normalize_nonblocking_result(Err(Errno::EISCONN), false),
Err(Errno::EISCONN)
);
}
#[test]
fn signal_interruption_errno_matches_linux_restart_policy() {
assert_eq!(
reverie::syscalls::Poll::new().signal_interrupt_errno(),
Errno::EINTR
);
assert_eq!(
reverie::syscalls::Ppoll::new().signal_interrupt_errno(),
Errno::EINTR
);
assert_eq!(
reverie::syscalls::EpollWait::new().signal_interrupt_errno(),
Errno::EINTR
);
let sigtimedwait = reverie::syscalls::RtSigtimedwait::new();
assert_eq!(sigtimedwait.signal_interrupt_errno(), Errno::EINTR);
assert!(sigtimedwait.syscall_would_have_blocked(Err(Errno::EAGAIN)));
assert_eq!(sigtimedwait.timeout_return_val(), Err(Errno::EAGAIN));
assert_eq!(
reverie::syscalls::Read::new().signal_interrupt_errno(),
Errno::ERESTARTSYS
);
assert_eq!(
reverie::syscalls::Writev::new().signal_interrupt_errno(),
Errno::ERESTARTSYS
);
assert_eq!(
reverie::syscalls::Futex::new().signal_interrupt_errno(),
Errno::ERESTARTSYS
);
}
#[test]
fn kernel_restart_errno_matches_linux_restart_policy() {
assert_eq!(
reverie::syscalls::Poll::new()
.with_timeout(300)
.kernel_restart_errno(),
Errno::ERESTART_RESTARTBLOCK
);
assert_eq!(
reverie::syscalls::Poll::new().kernel_restart_errno(),
Errno::ERESTARTNOHAND
);
assert_eq!(
reverie::syscalls::Poll::new()
.with_timeout(-1)
.kernel_restart_errno(),
Errno::ERESTARTNOHAND
);
assert_eq!(
reverie::syscalls::Ppoll::new().kernel_restart_errno(),
Errno::ERESTARTNOHAND
);
assert_eq!(
reverie::syscalls::EpollWait::new().kernel_restart_errno(),
Errno::EINTR
);
assert_eq!(
reverie::syscalls::RtSigtimedwait::new().kernel_restart_errno(),
Errno::EINTR
);
assert_eq!(
reverie::syscalls::Futex::new().kernel_restart_errno(),
Errno::ERESTARTSYS
);
let timeout = reverie::syscalls::Addr::from_raw(0x1000).unwrap();
assert_eq!(
reverie::syscalls::Futex::new()
.with_timeout(Some(timeout))
.kernel_restart_errno(),
Errno::ERESTART_RESTARTBLOCK
);
let bitset = reverie::syscalls::Futex::new()
.with_futex_op(libc::FUTEX_WAIT_BITSET | libc::FUTEX_PRIVATE_FLAG)
.with_val3(-1);
assert_eq!(bitset.kernel_restart_errno(), Errno::ERESTARTSYS);
assert!(!bitset.restart_keeps_deadline());
assert_eq!(
bitset.with_timeout(Some(timeout)).kernel_restart_errno(),
Errno::ERESTART_RESTARTBLOCK
);
assert!(bitset.with_timeout(Some(timeout)).restart_keeps_deadline());
}
#[test]
fn a_held_signal_is_reported_unless_it_is_sigstop() {
for signal in [libc::SIGUSR1, libc::SIGTERM, libc::SIGTSTP, libc::SIGCHLD] {
assert_eq!(
held_signal_restart_errno(Errno::ERESTART_RESTARTBLOCK, signal),
Errno::ERESTARTNOHAND,
"signal {signal}"
);
}
assert_eq!(
held_signal_restart_errno(Errno::ERESTART_RESTARTBLOCK, libc::SIGSTOP),
Errno::ERESTART_RESTARTBLOCK
);
for errno in [
Errno::ERESTARTNOHAND,
Errno::ERESTARTSYS,
Errno::ERESTARTNOINTR,
Errno::EINTR,
] {
for signal in [libc::SIGUSR1, libc::SIGSTOP] {
assert_eq!(held_signal_restart_errno(errno, signal), errno);
}
}
}
#[test]
fn a_restart_block_resumes_only_at_the_interrupted_call() {
let timeout = reverie::syscalls::Addr::from_raw(0x1000).unwrap();
let block = RestartBlock {
rip: 0x4000_1234,
deadline: Some(LogicalTime::from_nanos(300_000_000)),
call: RestartCall::Futex(reverie::syscalls::Futex::new().with_timeout(Some(timeout))),
};
assert_eq!(block.resumed_at(0x4000_1234), Some(block));
assert_eq!(block.resumed_at(0x4000_1236), None);
assert_eq!(block.resumed_at(0x4000_1232), None);
}
#[test]
fn writev_signal_result_uses_disposition_and_progress() {
let call = reverie::syscalls::Writev::new();
for disposition in [
WaitSignalDisposition::Interrupt,
WaitSignalDisposition::Restart,
] {
assert!(matches!(
interrupted_write_result(&call, 0, Some(disposition)),
Some(Err(Error::Errno(Errno::ERESTARTSYS)))
));
assert!(matches!(
interrupted_write_result(&call, 17, Some(disposition)),
Some(Ok(17))
));
}
assert!(interrupted_write_result(&call, 0, None).is_none());
assert!(interrupted_write_result(&call, 17, None).is_none());
}
#[test]
fn pipe_writev_requests_signal_disposition() {
let dettid = DetTid::from_raw(42);
let call = reverie::syscalls::Writev::new();
let request = pipe_writev_resources(dettid, call);
assert_eq!(
request.signal_interrupt_errno(),
Some(Errno::ERESTARTSYS.into_raw())
);
assert!(request.decides_signal_interruption_itself);
assert_eq!(request.resources.len(), 1);
}
}
#[cfg(test)]
mod kernel_signal_wait_failures {
use std::collections::VecDeque;
use std::sync::Arc;
use std::sync::Mutex;
use reverie::GlobalRPC;
use reverie::GlobalTool;
use reverie::Pid;
use reverie::syscalls::LocalMemory;
use super::*;
use crate::Config;
use crate::GlobalState;
use crate::ThreadState;
use crate::syscalls::threads::KernelSignalState;
use crate::syscalls::threads::kernel_sigset_bit;
use crate::syscalls::threads::signal_state_read_seam;
use crate::types::DetPid;
#[derive(Clone, Copy, Debug)]
enum MaskOutcome {
Apply,
StoppedBefore,
Fail(Errno),
StoppedBy(i32),
}
#[derive(Default)]
struct FakeKernel {
blocked: KernelSigset,
pending: KernelSigset,
shared: KernelSigset,
caught: KernelSigset,
ignored: KernelSigset,
stops_for_pending: bool,
taken: Vec<i32>,
read_failures: VecDeque<Errno>,
outcomes: VecDeque<MaskOutcome>,
requested: Vec<KernelSigset>,
repost_after_take: usize,
pending_repost: KernelSigset,
held_slot: Option<i32>,
lost: Vec<i32>,
setter: VecDeque<Option<MaskChangeRefused>>,
set_calls: Vec<KernelSigset>,
private_record: Option<(KernelSigset, KernelSigset)>,
}
impl FakeKernel {
fn hold(&mut self, signal: i32) {
if let Some(previous) = self.held_slot.replace(signal)
&& !(previous == signal && signal < KERNEL_SIGRTMIN)
{
self.lost.push(previous);
}
}
}
type Kernel = Arc<Mutex<FakeKernel>>;
const ARENA_WORDS: usize = 2;
struct WaitStack {
commit_fails: bool,
arena: usize,
}
struct WaitStackGuard;
impl Drop for WaitStackGuard {
fn drop(&mut self) {}
}
impl reverie::Stack for WaitStack {
type StackGuard = WaitStackGuard;
fn size(&self) -> usize {
panic!("a blocked wait must not query the scratch size")
}
fn capacity(&self) -> usize {
panic!("a blocked wait must not query the scratch capacity")
}
fn push<'stack, T>(&mut self, value: T) -> Addr<'stack, T> {
assert!(std::mem::size_of::<T>() <= ARENA_WORDS * std::mem::size_of::<u64>());
unsafe { std::ptr::write(self.arena as *mut T, value) };
Addr::from_raw(self.arena).unwrap()
}
fn reserve<'stack, T>(&mut self) -> AddrMut<'stack, T> {
panic!("a blocked wait pushes its mask rather than reserving room")
}
fn commit(self) -> Result<Self::StackGuard, Errno> {
if self.commit_fails {
Err(Errno::EFAULT)
} else {
Ok(WaitStackGuard)
}
}
}
struct WaitGuest {
config: Config,
thread: ThreadState<()>,
pid: Pid,
tid: Pid,
commit_fails: bool,
arena: Box<[u64; ARENA_WORDS]>,
kernel: Kernel,
}
impl WaitGuest {
fn new(tid: Pid, mask: KernelSigset) -> (Self, Kernel) {
let config = Config::default();
let thread = ThreadState::new(DetPid::from_raw(1), &config, ());
let kernel = Arc::new(Mutex::new(FakeKernel {
blocked: mask,
..FakeKernel::default()
}));
let guest = Self {
config,
thread,
pid: Pid::from_raw(std::process::id() as i32),
tid,
commit_fails: false,
arena: Box::new([u64::MAX; ARENA_WORDS]),
kernel: kernel.clone(),
};
(guest, kernel)
}
fn live(mask: KernelSigset) -> (Self, Kernel) {
Self::new(Pid::from_raw(unsafe { libc::gettid() }), mask)
}
}
#[test]
fn inherited_input_exempts_only_authenticated_reads_from_the_internal_guard() {
use std::os::fd::AsRawFd;
let (mut guest, _) = WaitGuest::live(guest_mask());
let slot = tempfile::tempfile().unwrap();
let fd = slot.as_raw_fd();
let input = reverie::InheritedInput::pipe(fd).unwrap();
let identity = input.identity().clone();
let (reader, _writer) = input.into_reader_and_writer();
assert_eq!(unsafe { libc::dup2(reader.as_raw_fd(), fd) }, fd);
guest
.thread
.add_fd(fd, nix::fcntl::OFlag::O_RDONLY, FdType::Pipe, None)
.unwrap();
let calls = [
Syscall::from(syscalls::Read::new().with_fd(fd)),
Syscall::from(syscalls::Readv::new().with_fd(fd)),
Syscall::from(syscalls::Write::new().with_fd(fd)),
Syscall::from(syscalls::Writev::new().with_fd(fd)),
];
for call in calls {
assert!(syscall_targets_internal_fd(&mut guest, call));
}
guest
.thread
.file_metadata
.lock()
.unwrap()
.apply_exec_fd_state(
guest.thread.dettid,
crate::tool_local::ExecFdState {
initial_input: Some(identity),
..Default::default()
},
true,
)
.unwrap();
for (index, call) in calls.into_iter().enumerate() {
assert_eq!(syscall_targets_internal_fd(&mut guest, call), index >= 2);
}
assert!(
!guest
.thread
.with_detfd(fd, |d| d.physically_nonblocking())
.unwrap()
);
assert_eq!(
unsafe { libc::fcntl(fd, libc::F_GETFL) } & libc::O_NONBLOCK,
0
);
let (internal, _writer) = nix::unistd::pipe().unwrap();
guest
.thread
.add_fd(
internal.as_raw_fd(),
nix::fcntl::OFlag::O_RDONLY,
FdType::Pipe,
None,
)
.unwrap();
assert!(syscall_targets_internal_fd(
&mut guest,
syscalls::Read::new().with_fd(internal.as_raw_fd()).into()
));
let (socket, _peer) = std::os::unix::net::UnixStream::pair().unwrap();
guest
.thread
.add_fd(
socket.as_raw_fd(),
nix::fcntl::OFlag::O_RDWR,
FdType::Socket,
None,
)
.unwrap();
guest
.thread
.with_detfd(socket.as_raw_fd(), |d| d.set_socketpair_endpoint())
.unwrap();
assert!(syscall_targets_internal_fd(
&mut guest,
syscalls::Readv::new().with_fd(socket.as_raw_fd()).into()
));
}
fn scripted_proc(kernel: &Kernel) -> signal_state_read_seam::Installed {
let kernel = kernel.clone();
signal_state_read_seam::install(move |_, _| {
let mut kernel = kernel.lock().unwrap();
let read = match kernel.read_failures.pop_front() {
Some(errno) => Err(errno),
None => Ok(KernelSignalState {
pending: kernel.pending,
thread_pending: kernel.pending & !kernel.shared,
shared_pending: kernel.pending & kernel.shared,
blocked: kernel.blocked,
caught: kernel.caught,
ignored: kernel.ignored,
}),
};
kernel.pending |= std::mem::take(&mut kernel.pending_repost);
Some(read)
})
}
#[reverie::tool]
impl GlobalRPC<GlobalState> for WaitGuest {
async fn send_rpc(
&self,
message: <GlobalState as GlobalTool>::Request,
) -> <GlobalState as GlobalTool>::Response {
match (&message.2, self.kernel.lock().unwrap().private_record) {
(
crate::tool_global::GlobalRequest::HostTimedAndPrivateSigchld(_),
Some((host_timed, private)),
) => (
None,
crate::tool_global::GlobalResponse::HostTimedAndPrivateSigchld(
host_timed, private,
),
),
_ => panic!("these waits must not send an RPC: {:?}", message.2),
}
}
fn config(&self) -> &Config {
&self.config
}
}
#[reverie::tool]
impl Guest<Detcore> for WaitGuest {
type Memory = LocalMemory;
type Stack = WaitStack;
fn tid(&self) -> Pid {
self.tid
}
fn pid(&self) -> Pid {
self.pid
}
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 {
panic!("a blocked wait must not read registers")
}
async fn stack(&mut self) -> Self::Stack {
WaitStack {
commit_fails: self.commit_fails,
arena: self.arena.as_mut_ptr() as usize,
}
}
async fn daemonize(&mut self) {
panic!("a blocked wait must not daemonize")
}
async fn inject<S: SyscallInfo>(&mut self, syscall: S) -> Result<i64, Errno> {
let (number, args) = syscall.into_parts();
let Syscall::RtSigprocmask(call) = Syscall::from_raw(number, args) else {
panic!("a blocked wait injected {number}, not rt_sigprocmask")
};
assert_eq!(call.how(), libc::SIG_SETMASK);
assert!(call.oldset().is_none());
let set = call.set().expect("rt_sigprocmask without a mask");
let mask: KernelSigset = LocalMemory::new().read_value(set.cast::<KernelSigset>())?;
let mut kernel = self.kernel.lock().unwrap();
kernel.requested.push(mask);
let deliverable = kernel.pending & !kernel.blocked;
if kernel.stops_for_pending && deliverable != 0 {
let signal = deliverable.trailing_zeros() as i32 + 1;
kernel.pending &= !kernel_sigset_bit(signal);
kernel.taken.push(signal);
kernel.hold(signal);
if kernel.repost_after_take > 0 {
kernel.repost_after_take -= 1;
kernel.pending_repost |= kernel_sigset_bit(signal);
}
return Err(Errno::ERESTARTSYS);
}
match kernel.outcomes.pop_front().unwrap_or(MaskOutcome::Apply) {
MaskOutcome::Apply => {
kernel.blocked = mask;
Ok(0)
}
MaskOutcome::StoppedBefore => Err(Errno::ERESTARTNOINTR),
MaskOutcome::StoppedBy(signal) => {
kernel.hold(signal);
Err(Errno::ERESTARTNOINTR)
}
MaskOutcome::Fail(errno) => Err(errno),
}
}
async fn set_blocked_signals(&mut self, mask: u64) -> Result<u64, MaskChangeRefused> {
let mut kernel = self.kernel.lock().unwrap();
kernel.set_calls.push(mask);
match kernel.setter.pop_front() {
Some(None) => Ok(std::mem::replace(&mut kernel.blocked, mask)),
Some(Some(refused)) => Err(refused),
None => Err(MaskChangeRefused::Unsupported),
}
}
async fn tail_inject<S: SyscallInfo>(&mut self, _: S) -> reverie::Never {
panic!("a blocked wait must not retire the guest")
}
fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("a blocked wait must not set a timer")
}
fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("a blocked wait must not set a timer")
}
fn read_clock(&mut self) -> Result<u64, Error> {
panic!("a blocked wait must not read a clock")
}
}
fn guest_mask() -> KernelSigset {
kernel_sigset_bit(libc::SIGUSR2)
}
fn diagnostic<V: std::fmt::Debug>(result: Result<V, Error>) -> BlockedWaitSignalError {
match result {
Err(Error::Tool(error)) => *error
.downcast_ref::<BlockedWaitSignalError>()
.unwrap_or_else(|| panic!("not a blocked-wait diagnostic: {error:#}")),
other => panic!("expected the run to end with a diagnostic, got {other:?}"),
}
}
fn refusal<V: std::fmt::Debug>(result: Result<V, Error>) -> HeldSignalRefusal {
match result {
Err(Error::Tool(error)) => *error
.downcast_ref::<HeldSignalRefusal>()
.unwrap_or_else(|| panic!("not a held-signal refusal: {error:#}")),
other => panic!("expected the wait to end with a held-signal refusal, got {other:?}"),
}
}
async fn blocked_wait(guest: &mut WaitGuest, kernel: &Kernel) -> KernelSignalWait {
let mut wait = KernelSignalWait::new(guest, 0, false, Errno::ERESTARTSYS);
wait.block(guest, None).await.unwrap();
assert!(!wait.needs_block());
assert_eq!(kernel.lock().unwrap().blocked, blocked_signal_mask());
wait
}
#[tokio::test]
async fn restore_repeats_the_mask_change_until_the_kernel_reports_it() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
let mut wait = blocked_wait(&mut guest, &kernel).await;
kernel
.lock()
.unwrap()
.outcomes
.extend([MaskOutcome::StoppedBefore; 5]);
let result = wait.restore(&mut guest, None).await;
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: None,
replacing: None,
loss: HeldSignalLoss::Restoration,
}
);
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.blocked, guest_mask());
assert_eq!(
kernel.requested.len(),
1 + 6,
"block, then five stopped attempts and one that ran"
);
assert!(
kernel.requested[1..]
.iter()
.all(|&mask| mask == guest_mask())
);
}
#[tokio::test]
async fn a_mask_that_signals_keep_stopping_ends_the_run_instead_of_resuming_the_guest() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
let mut wait = blocked_wait(&mut guest, &kernel).await;
kernel
.lock()
.unwrap()
.outcomes
.extend([MaskOutcome::StoppedBefore; 64]);
let error = diagnostic(wait.restore(&mut guest, None).await);
assert_eq!(
error,
BlockedWaitSignalError::MaskNotRestored {
pid: guest.pid,
tid: guest.tid,
attempts: 16,
last_error: Some(Errno::ERESTARTNOINTR),
}
);
let message = error.to_string();
assert!(
message.starts_with("cannot restore the signal mask of guest thread")
&& message.contains("(16 attempts, last error ")
&& message.contains("ERESTARTNOINTR")
&& message.ends_with("); it would resume with every signal blocked"),
"{message}"
);
assert_eq!(kernel.lock().unwrap().requested.len(), 1 + 16);
}
#[tokio::test]
async fn a_mask_change_that_cannot_run_ends_the_run_instead_of_resuming_the_guest() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
let mut wait = blocked_wait(&mut guest, &kernel).await;
kernel
.lock()
.unwrap()
.outcomes
.push_back(MaskOutcome::Fail(Errno::EFAULT));
let error = diagnostic(wait.restore(&mut guest, None).await);
assert_eq!(
error,
BlockedWaitSignalError::MaskNotRestored {
pid: guest.pid,
tid: guest.tid,
attempts: 1,
last_error: Some(Errno::EFAULT),
}
);
}
#[tokio::test]
async fn an_in_place_block_and_its_restore_make_no_injection() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
guest.commit_fails = true;
kernel.lock().unwrap().setter.extend([None, None]);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert!(wait.block_in_place(&mut guest, 0).await.unwrap());
assert_eq!(wait.effective_mask(), Some(guest_mask()));
assert_eq!(
kernel.lock().unwrap().blocked,
blocked_signal_mask() | guest_mask()
);
wait.restore(&mut guest, None).await.unwrap();
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.blocked, guest_mask());
assert_eq!(
kernel.set_calls,
vec![blocked_signal_mask() | guest_mask(), guest_mask()]
);
assert!(
kernel.requested.is_empty(),
"no rt_sigprocmask was injected"
);
assert_eq!(wait.effective_mask(), None);
}
#[tokio::test]
async fn an_in_place_block_holds_the_host_timed_signals() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
kernel.lock().unwrap().setter.push_back(None);
let host_timed = kernel_sigset_bit(libc::SIGIO) | kernel_sigset_bit(libc::SIGHUP);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert!(wait.block_in_place(&mut guest, host_timed).await.unwrap());
assert_eq!(wait.held_until_return & host_timed, host_timed);
assert_eq!(wait.host_timed & host_timed, host_timed);
}
#[tokio::test]
async fn a_refused_in_place_block_leaves_the_guest_mask() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
kernel
.lock()
.unwrap()
.setter
.push_back(Some(MaskChangeRefused::RestorePending {
saved: guest_mask(),
effective: 0,
}));
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert!(!wait.block_in_place(&mut guest, 0).await.unwrap());
assert!(!wait.needs_block());
assert_eq!(wait.effective_mask(), None);
wait.restore(&mut guest, None).await.unwrap();
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.blocked, guest_mask());
assert_eq!(kernel.set_calls.len(), 1);
assert!(kernel.requested.is_empty());
}
#[tokio::test]
async fn a_refused_in_place_restore_falls_back_to_an_injection() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
kernel
.lock()
.unwrap()
.setter
.extend([None, Some(MaskChangeRefused::Unsupported)]);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert!(wait.block_in_place(&mut guest, 0).await.unwrap());
wait.restore(&mut guest, None).await.unwrap();
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.blocked, guest_mask());
assert_eq!(kernel.requested, vec![guest_mask()], "one injected restore");
}
#[tokio::test]
async fn an_unknown_mask_after_an_in_place_change_ends_the_run() {
let unknown = Some(MaskChangeRefused::Failed {
errno: Errno::EIO,
mask_unknown: true,
});
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
let not_restored = BlockedWaitSignalError::MaskNotRestored {
pid: guest.pid,
tid: guest.tid,
attempts: 1,
last_error: Some(Errno::EIO),
};
kernel.lock().unwrap().setter.push_back(unknown);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert_eq!(
diagnostic(wait.block_in_place(&mut guest, 0).await),
not_restored
);
kernel.lock().unwrap().setter.extend([None, unknown]);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert!(wait.block_in_place(&mut guest, 0).await.unwrap());
assert_eq!(
diagnostic(wait.restore(&mut guest, None).await),
not_restored
);
assert!(kernel.lock().unwrap().requested.is_empty());
}
#[tokio::test]
async fn a_gone_thread_needs_no_restore() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
kernel
.lock()
.unwrap()
.setter
.extend([None, Some(MaskChangeRefused::Gone)]);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert!(wait.block_in_place(&mut guest, 0).await.unwrap());
wait.restore(&mut guest, None).await.unwrap();
assert!(kernel.lock().unwrap().requested.is_empty());
}
#[tokio::test]
async fn an_unreadable_signal_state_of_a_live_thread_ends_the_run() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
let _proc = scripted_proc(&kernel);
let (pid, tid) = (guest.pid, guest.tid);
let expected = |errno| BlockedWaitSignalError::StateUnreadable { pid, tid, errno };
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
kernel.lock().unwrap().read_failures.push_back(Errno::EIO);
assert_eq!(diagnostic(wait.interrupted()), expected(Errno::EIO));
kernel.lock().unwrap().read_failures.push_back(Errno::ESRCH);
assert_eq!(
diagnostic(wait.block(&mut guest, None).await),
expected(Errno::ESRCH)
);
assert!(kernel.lock().unwrap().requested.is_empty());
wait.block(&mut guest, None).await.unwrap();
kernel.lock().unwrap().read_failures.push_back(Errno::ESRCH);
assert_eq!(
diagnostic(wait.restore(&mut guest, None).await),
expected(Errno::ESRCH)
);
let error = expected(Errno::EIO).to_string();
assert!(
error.starts_with("cannot read the signal state of guest thread"),
"{error}"
);
}
#[tokio::test]
async fn a_thread_that_no_longer_exists_ends_its_wait_with_erestartnointr() {
let exited = std::thread::spawn(|| unsafe { libc::gettid() })
.join()
.unwrap();
let task = format!("/proc/self/task/{exited}");
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
while std::path::Path::new(&task).exists() {
assert!(
std::time::Instant::now() < deadline,
"thread {exited} is still in /proc 10 s after it was joined"
);
std::thread::sleep(std::time::Duration::from_millis(1));
}
let (guest, _kernel) = WaitGuest::new(Pid::from_raw(exited), guest_mask());
let wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
assert!(matches!(
wait.interrupted(),
Err(Error::Errno(Errno::ERESTARTNOINTR))
));
assert!(matches!(
read_wait_signal_state(guest.pid, guest.tid),
Err(Error::Errno(Errno::ERESTARTNOINTR))
));
}
#[tokio::test]
async fn a_stack_with_no_scratch_room_leaves_the_wait_under_the_guest_mask() {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
guest.commit_fails = true;
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
wait.block(&mut guest, None).await.unwrap();
assert!(!wait.needs_block(), "block must not be tried again");
assert_eq!(kernel.lock().unwrap().blocked, guest_mask());
assert!(kernel.lock().unwrap().requested.is_empty());
{
let mut kernel = kernel.lock().unwrap();
kernel.caught = kernel_sigset_bit(libc::SIGUSR1) | kernel_sigset_bit(libc::SIGUSR2);
kernel.pending = kernel_sigset_bit(libc::SIGUSR2);
}
assert!(!wait.interrupted().unwrap(), "SIGUSR2 is blocked");
kernel.lock().unwrap().pending = kernel_sigset_bit(libc::SIGUSR1);
assert!(wait.interrupted().unwrap(), "SIGUSR1 is not blocked");
wait.restore(&mut guest, None).await.unwrap();
assert!(
kernel.lock().unwrap().requested.is_empty(),
"nothing to put back"
);
assert_eq!(kernel.lock().unwrap().blocked, guest_mask());
}
fn stopping_guest(pending: KernelSigset, ignored: KernelSigset) -> (WaitGuest, Kernel) {
let (guest, kernel) = WaitGuest::live(guest_mask());
{
let mut kernel = kernel.lock().unwrap();
kernel.stops_for_pending = true;
kernel.pending = pending;
kernel.ignored = ignored;
}
(guest, kernel)
}
async fn inject_mask_absorbing(
wait: &mut KernelSignalWait,
guest: &mut WaitGuest,
mask: KernelSigset,
) -> Result<Result<i64, Errno>, Error> {
let mut stack = guest.stack().await;
let cell = stack.push(mask);
let _guard = stack.commit().unwrap();
wait.inject_absorbing(guest, set_signal_mask_call(cell))
.await
}
#[tokio::test]
async fn an_ignored_signal_that_stops_the_mask_change_does_not_end_the_wait() {
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let (mut guest, kernel) = stopping_guest(usr1, usr1);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
wait.block(&mut guest, None).await.unwrap();
assert!(!wait.needs_block());
let all_blocked = blocked_signal_mask() | guest_mask();
{
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.taken, vec![libc::SIGUSR1]);
assert_eq!(kernel.requested, vec![all_blocked, all_blocked]);
assert_eq!(kernel.blocked, all_blocked);
}
assert_eq!(
wait.held,
Some(HeldSignal {
signal: libc::SIGUSR1,
queue: SignalQueue::Thread,
kind: HeldKind::Harmless,
})
);
assert!(
!wait.interrupted().unwrap(),
"an ignored signal does not end the wait"
);
wait.restore(&mut guest, None).await.unwrap();
assert_eq!(kernel.lock().unwrap().blocked, guest_mask());
}
#[tokio::test]
async fn a_default_ignored_signal_that_stops_an_injection_is_held() {
let (mut guest, kernel) = stopping_guest(kernel_sigset_bit(libc::SIGWINCH), 0);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(matches!(result, Ok(Ok(0))), "{result:?}");
assert_eq!(kernel.lock().unwrap().taken, vec![libc::SIGWINCH]);
assert_eq!(kernel.lock().unwrap().requested.len(), 2);
assert_eq!(wait.held.map(|held| held.kind), Some(HeldKind::Harmless));
assert!(!wait.interrupted().unwrap());
}
#[tokio::test]
async fn a_pending_caught_signal_ends_the_wait_before_the_injection() {
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let (mut guest, kernel) = stopping_guest(usr1, 0);
kernel.lock().unwrap().caught = usr1;
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTSYS))),
"{result:?}"
);
let kernel = kernel.lock().unwrap();
assert!(kernel.requested.is_empty(), "nothing is injected");
assert_eq!(kernel.pending, usr1);
assert_eq!(wait.held, None);
}
#[tokio::test]
async fn a_held_sigchld_is_never_replaced_by_another_stop() {
let (mut guest, kernel) = stopping_guest(
kernel_sigset_bit(libc::SIGCHLD) | kernel_sigset_bit(libc::SIGWINCH),
0,
);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: Some(libc::SIGWINCH),
loss: HeldSignalLoss::Replaced,
}
);
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.taken, vec![libc::SIGCHLD]);
assert_eq!(
kernel.requested.len(),
1,
"the second injection is not made"
);
assert_eq!(kernel.pending, kernel_sigset_bit(libc::SIGWINCH));
assert_eq!(wait.held.map(|held| held.kind), Some(HeldKind::Precious));
}
async fn wait_holding_sigchld(guest: &mut WaitGuest, kernel: &Kernel) -> KernelSignalWait {
let mut wait = KernelSignalWait::new(&*guest, 0, false, Errno::ERESTARTSYS);
wait.block(guest, None).await.unwrap();
assert_eq!(
wait.held.map(|held| (held.signal, held.kind)),
Some((libc::SIGCHLD, HeldKind::Precious))
);
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.blocked, blocked_signal_mask() | guest_mask());
assert_eq!(kernel.held_slot, Some(libc::SIGCHLD));
wait
}
#[tokio::test]
async fn a_stop_of_the_mask_restoration_that_replaces_a_held_sigchld_is_refused() {
let (mut guest, kernel) = stopping_guest(kernel_sigset_bit(libc::SIGCHLD), 0);
let _proc = scripted_proc(&kernel);
let mut wait = wait_holding_sigchld(&mut guest, &kernel).await;
kernel
.lock()
.unwrap()
.outcomes
.push_back(MaskOutcome::StoppedBy(libc::SIGSTOP));
let result = wait.restore(&mut guest, None).await;
{
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.blocked, guest_mask(), "the guest's mask is back");
assert_eq!(
kernel.requested[2..],
[guest_mask(), guest_mask()],
"one stopped restoration attempt and one that ran"
);
assert_eq!(kernel.held_slot, Some(libc::SIGSTOP));
assert_eq!(kernel.lost, vec![libc::SIGCHLD]);
}
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: None,
loss: HeldSignalLoss::Restoration,
}
);
}
#[tokio::test]
async fn an_identified_stop_of_the_mask_restoration_that_replaces_a_held_sigchld_is_refused() {
const RESERVED: i32 = 32;
assert_eq!(blocked_signal_mask() & kernel_sigset_bit(RESERVED), 0);
let (mut guest, kernel) = stopping_guest(kernel_sigset_bit(libc::SIGCHLD), 0);
let _proc = scripted_proc(&kernel);
let mut wait = wait_holding_sigchld(&mut guest, &kernel).await;
kernel.lock().unwrap().pending = kernel_sigset_bit(RESERVED);
let result = wait.restore(&mut guest, None).await;
{
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.blocked, guest_mask(), "the guest's mask is back");
assert_eq!(kernel.taken, vec![libc::SIGCHLD, RESERVED]);
assert_eq!(kernel.held_slot, Some(RESERVED));
assert_eq!(kernel.lost, vec![libc::SIGCHLD]);
}
let refused = refusal(result);
assert_eq!(
refused,
HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: Some(RESERVED),
loss: HeldSignalLoss::Restoration,
}
);
let message = refused.to_string();
assert!(
message.starts_with(
"unsupported: the a blocking wait cannot keep the held signal SIGCHLD: signal 32 \
stopped the injection that puts the guest's signal mask back and replaced it"
),
"{message}"
);
}
#[test]
fn a_restoration_refusal_replaces_the_result_unless_the_wait_refused_first() {
let tool = |refusal: HeldSignalRefusal| Error::Tool(anyhow::Error::new(refusal));
let restoration = HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: None,
loss: HeldSignalLoss::Restoration,
};
let replaced = HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: Some(libc::SIGUSR1),
loss: HeldSignalLoss::Replaced,
};
let not_restored = BlockedWaitSignalError::MaskNotRestored {
pid: Pid::from_raw(1),
tid: Pid::from_raw(1),
attempts: 16,
last_error: Some(Errno::ERESTARTNOINTR),
};
assert_eq!(result_after_restore(Ok(()), Ok(3)).unwrap().unwrap(), 3);
assert_eq!(
refusal(result_after_restore(Err(tool(restoration)), Ok(3)).unwrap()),
restoration
);
assert_eq!(
refusal(
result_after_restore(Err(tool(restoration)), Err(Errno::ERESTARTSYS.into()))
.unwrap()
),
restoration
);
assert_eq!(
refusal(result_after_restore(Err(tool(restoration)), Err(tool(replaced))).unwrap()),
replaced
);
assert_eq!(
diagnostic(result_after_restore(
Err(Error::Tool(anyhow::Error::new(not_restored))),
Ok(3)
)),
not_restored
);
}
fn unidentified_stops_guest(stops: usize) -> (WaitGuest, Kernel) {
let (guest, kernel) = WaitGuest::live(guest_mask());
kernel.lock().unwrap().outcomes =
std::iter::repeat_n(MaskOutcome::StoppedBefore, stops).collect();
(guest, kernel)
}
#[tokio::test]
async fn a_stop_that_cannot_be_identified_keeps_a_timed_wait_and_its_deadline() {
for deadline in [true, false] {
let (mut guest, kernel) = unidentified_stops_guest(1);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, true, Errno::ERESTARTNOHAND)
.with_deadline(deadline);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(
matches!(result, Ok(Ok(0))),
"deadline={deadline}: {result:?}"
);
assert_eq!(
kernel.lock().unwrap().requested.len(),
2,
"deadline={deadline}"
);
assert_eq!(wait.held, None, "deadline={deadline}");
}
}
#[tokio::test]
async fn only_a_wait_without_a_deadline_ends_after_the_absorbed_stop_bound() {
let stops = 100;
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let (mut guest, kernel) = stopping_guest(usr1, usr1);
kernel.lock().unwrap().repost_after_take = stops - 1;
let _proc = scripted_proc(&kernel);
let mut wait =
KernelSignalWait::new(&guest, 0, true, Errno::ERESTARTNOHAND).with_deadline(true);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(matches!(result, Ok(Ok(0))), "{result:?}");
assert_eq!(kernel.lock().unwrap().requested.len(), stops + 1);
assert_eq!(wait.held.map(|held| held.kind), Some(HeldKind::Harmless));
let (mut guest, kernel) = stopping_guest(usr1, usr1);
kernel.lock().unwrap().repost_after_take = stops - 1;
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, true, Errno::ERESTARTNOHAND);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTNOINTR))),
"{result:?}"
);
assert_eq!(kernel.lock().unwrap().requested.len(), 65);
}
#[tokio::test]
async fn a_wait_that_reaches_the_stop_bound_holding_a_sigchld_is_refused() {
let (mut guest, kernel) = stopping_guest(kernel_sigset_bit(libc::SIGCHLD), 0);
kernel.lock().unwrap().repost_after_take = 100;
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: None,
loss: HeldSignalLoss::StopBound,
}
);
assert_eq!(kernel.lock().unwrap().requested.len(), 65);
}
#[tokio::test]
async fn an_unidentified_stop_at_the_stop_bound_is_refused() {
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
for deadline in [false, true] {
let (mut guest, kernel) = stopping_guest(usr1, usr1);
{
let mut kernel = kernel.lock().unwrap();
kernel.repost_after_take = 63;
kernel.outcomes = VecDeque::from([MaskOutcome::StoppedBefore]);
}
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, true, Errno::ERESTARTNOHAND)
.with_deadline(deadline);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
if deadline {
assert!(matches!(result, Ok(Ok(0))), "{result:?}");
assert_eq!(kernel.lock().unwrap().requested.len(), 66);
assert!(wait.held_unidentified);
} else {
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: None,
replacing: None,
loss: HeldSignalLoss::StopBound,
}
);
assert_eq!(kernel.lock().unwrap().requested.len(), 65);
}
assert_eq!(
kernel.lock().unwrap().taken.len(),
64,
"deadline={deadline}"
);
}
}
#[tokio::test]
async fn an_unidentified_stop_over_a_held_sigchld_is_refused() {
for deadline in [true, false] {
let (mut guest, kernel) = stopping_guest(kernel_sigset_bit(libc::SIGCHLD), 0);
kernel.lock().unwrap().outcomes = VecDeque::from([MaskOutcome::StoppedBefore]);
let _proc = scripted_proc(&kernel);
let mut wait =
KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS).with_deadline(deadline);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: None,
loss: HeldSignalLoss::UnidentifiedStop,
},
"deadline={deadline}"
);
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.requested.len(), 2, "deadline={deadline}");
assert_eq!(kernel.taken, vec![libc::SIGCHLD], "deadline={deadline}");
}
}
#[tokio::test]
async fn a_second_unidentified_stop_is_refused() {
for deadline in [true, false] {
let (mut guest, kernel) = unidentified_stops_guest(2);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, true, Errno::ERESTARTNOHAND)
.with_deadline(deadline);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: None,
replacing: None,
loss: HeldSignalLoss::UnidentifiedStop,
},
"deadline={deadline}"
);
assert_eq!(
kernel.lock().unwrap().requested.len(),
2,
"deadline={deadline}"
);
}
}
#[tokio::test]
async fn a_sigchld_after_an_unidentified_stop_is_refused_before_it_replaces_it() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
for deadline in [true, false] {
let (mut guest, kernel) = stopping_guest(0, 0);
{
let mut kernel = kernel.lock().unwrap();
kernel.pending_repost = chld;
kernel.repost_after_take = 1;
}
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, true, Errno::ERESTARTNOHAND)
.with_deadline(deadline);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
let refused = refusal(result);
assert_eq!(
refused,
HeldSignalRefusal {
wait: None,
held: None,
replacing: Some(libc::SIGCHLD),
loss: HeldSignalLoss::Replaced,
},
"deadline={deadline}"
);
let message = HeldSignalRefusal {
wait: Some(Sysno::futex),
..refused
}
.to_string();
assert!(
message.starts_with(
"unsupported: the futex wait cannot keep a held signal that could not be \
identified: the pending SIGCHLD would stop the next injection and replace it"
),
"deadline={deadline}: {message}"
);
assert!(wait.held_unidentified, "deadline={deadline}");
let kernel = kernel.lock().unwrap();
assert_eq!(
kernel.requested.len(),
1,
"deadline={deadline}: the second injection is not made"
);
assert_eq!(kernel.taken, vec![libc::SIGCHLD], "deadline={deadline}");
assert_eq!(kernel.held_slot, Some(libc::SIGCHLD), "deadline={deadline}");
assert!(kernel.lost.is_empty(), "deadline={deadline}");
assert_eq!(kernel.pending, chld, "deadline={deadline}");
}
}
#[tokio::test]
async fn a_timed_wait_refuses_to_let_another_stop_replace_a_held_sigchld() {
let (mut guest, kernel) = stopping_guest(
kernel_sigset_bit(libc::SIGCHLD) | kernel_sigset_bit(libc::SIGWINCH),
0,
);
let _proc = scripted_proc(&kernel);
let mut wait =
KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND).with_deadline(true);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: Some(libc::SIGWINCH),
loss: HeldSignalLoss::Replaced,
}
);
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.taken, vec![libc::SIGCHLD]);
assert_eq!(
kernel.requested.len(),
1,
"the second injection is not made"
);
assert_eq!(kernel.pending, kernel_sigset_bit(libc::SIGWINCH));
}
#[tokio::test]
async fn a_timed_wait_ends_for_a_held_signal_that_would_end_it() {
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let (mut guest, kernel) = stopping_guest(usr1 | kernel_sigset_bit(libc::SIGWINCH), 0);
let _proc = scripted_proc(&kernel);
let mut wait =
KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND).with_deadline(true);
wait.held = Some(HeldSignal {
signal: libc::SIGUSR1,
queue: SignalQueue::Thread,
kind: HeldKind::Precious,
});
kernel.lock().unwrap().pending = kernel_sigset_bit(libc::SIGWINCH);
kernel.lock().unwrap().caught = usr1;
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTNOHAND))),
"{result:?}"
);
assert!(
kernel.lock().unwrap().requested.is_empty(),
"nothing is injected"
);
}
#[tokio::test]
async fn a_wait_without_a_deadline_ends_for_a_held_signal_that_would_end_it() {
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let (mut guest, kernel) = stopping_guest(kernel_sigset_bit(libc::SIGWINCH), 0);
kernel.lock().unwrap().caught = usr1;
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
wait.held = Some(HeldSignal {
signal: libc::SIGUSR1,
queue: SignalQueue::Thread,
kind: HeldKind::Precious,
});
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTSYS))),
"{result:?}"
);
assert!(
kernel.lock().unwrap().requested.is_empty(),
"nothing is injected"
);
}
#[tokio::test]
async fn a_consumed_sigchld_that_stops_an_injection_is_refused() {
let usr1 = kernel_sigset_bit(libc::SIGUSR1);
let (mut guest, kernel) = stopping_guest(usr1, 0);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, usr1, false, Errno::ERESTARTSYS);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTNOINTR))),
"{result:?}"
);
assert_eq!(kernel.lock().unwrap().taken, vec![libc::SIGUSR1]);
drop(_proc);
let chld = kernel_sigset_bit(libc::SIGCHLD);
let (mut guest, kernel) = stopping_guest(chld, 0);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, chld, false, Errno::ERESTARTSYS);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert_eq!(
refusal(result),
HeldSignalRefusal {
wait: None,
held: None,
replacing: Some(libc::SIGCHLD),
loss: HeldSignalLoss::Consumed,
}
);
assert_eq!(kernel.lock().unwrap().taken, vec![libc::SIGCHLD]);
}
#[tokio::test]
async fn a_stop_by_the_preemption_signal_still_restarts_a_wait_without_a_deadline() {
let signal = reverie::PERF_EVENT_SIGNAL as i32;
let (mut guest, kernel) = stopping_guest(kernel_sigset_bit(signal), 0);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS);
let result = inject_mask_absorbing(&mut wait, &mut guest, guest_mask()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTNOINTR))),
"{result:?}"
);
assert_eq!(kernel.lock().unwrap().taken, vec![signal]);
}
#[tokio::test]
async fn a_held_signal_refusal_follows_the_unsupported_operation_policy() {
let refused = || {
Err::<i64, Error>(Error::Tool(anyhow::Error::new(HeldSignalRefusal {
wait: None,
held: Some(libc::SIGCHLD),
replacing: Some(libc::SIGWINCH),
loss: HeldSignalLoss::Replaced,
})))
};
let (mut guest, _kernel) = WaitGuest::live(guest_mask());
guest.config.panic_on_unsupported_syscalls = false;
let result = refuse_held_signal_loss(&mut guest, Sysno::poll, refused()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTNOINTR))),
"{result:?}"
);
let result = refuse_held_signal_loss(&mut guest, Sysno::poll, Ok(3)).await;
assert!(matches!(result, Ok(3)), "{result:?}");
let result =
refuse_held_signal_loss(&mut guest, Sysno::poll, Err(Errno::ERESTARTSYS.into())).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTSYS))),
"{result:?}"
);
guest.config.panic_on_unsupported_syscalls = true;
guest.config.exit_on_unsupported_syscall = true;
guest.config.shutdown_on_unsupported_syscall = false;
let result = refuse_held_signal_loss(&mut guest, Sysno::poll, refused()).await;
match result {
Err(Error::Tool(error)) => assert!(
matches!(
error.downcast_ref::<crate::UnsupportedSyscallError>(),
Some(crate::UnsupportedSyscallError(Sysno::poll))
),
"{error:#}"
),
other => panic!("expected the typed refusal, got {other:?}"),
}
let message = HeldSignalRefusal {
wait: Some(Sysno::poll),
held: Some(libc::SIGCHLD),
replacing: Some(libc::SIGWINCH),
loss: HeldSignalLoss::Replaced,
}
.to_string();
for part in [
"poll",
"SIGCHLD",
"SIGWINCH",
"https://github.com/rrnewton/hermit/pull/3361",
] {
assert!(message.contains(part), "{part} missing from: {message}");
}
}
fn caught_sigchld_guest(gated_backend: bool) -> (WaitGuest, Kernel) {
let (mut guest, kernel) = WaitGuest::live(guest_mask());
guest.config.sequentialize_threads = gated_backend;
guest
.config
.backend
.supports_blocked_wait_signal_interruption = gated_backend;
{
let mut kernel = kernel.lock().unwrap();
kernel.pending = kernel_sigset_bit(libc::SIGCHLD);
kernel.caught = kernel_sigset_bit(libc::SIGCHLD);
}
(guest, kernel)
}
#[tokio::test]
async fn a_pending_caught_sigchld_ends_a_select_wait_but_no_gated_wait() {
for gated_backend in [false, true] {
let (guest, kernel) = caught_sigchld_guest(gated_backend);
let _proc = scripted_proc(&kernel);
let gated = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
assert!(
!gated.interrupted().unwrap(),
"a pending caught SIGCHLD does not end a gated wait \
(gated_backend={gated_backend})"
);
let select = KernelSignalWait::for_select(&guest);
assert!(
select.interrupted().unwrap(),
"the pending caught SIGCHLD ends a select wait (gated_backend={gated_backend})"
);
assert_eq!(
kernel.lock().unwrap().pending,
kernel_sigset_bit(libc::SIGCHLD),
"the signal stays queued for the guest's handler"
);
}
}
#[tokio::test]
async fn a_committed_sigchld_ends_a_gated_wait_unless_a_host_timed_source_can_post_it() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
let (guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
assert!(
!wait.interrupted().unwrap(),
"an uncommitted SIGCHLD is held"
);
wait.admit(chld, 0);
assert!(
wait.interrupted().unwrap(),
"a committed SIGCHLD ends the wait"
);
wait.admit(0, 0);
assert!(
!wait.interrupted().unwrap(),
"the next turn's resume names nothing, so the SIGCHLD is held again"
);
let mut host_timed = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
host_timed.hold_until_return(chld);
host_timed.admit(chld, 0);
assert!(
!host_timed.interrupted().unwrap(),
"a SIGCHLD a host-timed source can post stays held although committed"
);
}
#[tokio::test]
async fn an_admitted_private_sigchld_ends_a_gated_wait_from_the_threads_own_queue_only() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
let (guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
wait.admit(0, chld);
assert!(
wait.interrupted().unwrap(),
"the thread's own copy ends the wait"
);
assert!(
wait.interrupts_only_by_committed(
&read_wait_signal_state(guest.pid(), guest.tid()).unwrap()
),
"only the admitted copy ends it, so the turn's probe runs first"
);
kernel.lock().unwrap().shared = chld;
assert!(
!wait.interrupted().unwrap(),
"a SIGCHLD pending only on the shared queue is held"
);
kernel.lock().unwrap().shared = 0;
wait.admit(0, 0);
assert!(!wait.interrupted().unwrap(), "the next turn holds it again");
let mut host_timed = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
host_timed.hold_until_return(chld);
host_timed.admit(0, chld);
assert!(
!host_timed.interrupted().unwrap(),
"a SIGCHLD a host-timed source can post stays held"
);
}
#[tokio::test]
async fn an_admitted_private_sigchld_that_only_the_wait_mask_lets_in_is_delivered_under_it() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
let (guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
kernel.lock().unwrap().blocked |= chld;
let mut wait =
KernelSignalWait::new(&guest, 0, false, Errno::EINTR).with_wait_mask(Some(0));
let state = read_wait_signal_state(guest.pid(), guest.tid()).unwrap();
assert!(
!wait.interrupts_only_under_wait_mask(&state),
"held while not admitted"
);
wait.admit(0, chld);
assert!(wait.interrupts_only_under_wait_mask(&state));
}
#[tokio::test]
async fn a_recorded_private_sigchld_is_kept_only_under_a_block_in_place() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
let mut published = PublishedWaitMask(Some(guest_mask()));
let (mut guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
kernel.lock().unwrap().setter.push_back(None);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
assert_eq!(
wait.admit_under_block(&mut guest, 0, chld, 0, &mut published)
.await
.unwrap(),
chld,
"blocked in place, and the thread's own queue holds it"
);
assert!(wait.blocked_in_place);
wait.restore(&mut guest, None).await.unwrap();
drop(_proc);
let (mut guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
assert_eq!(
wait.admit_under_block(&mut guest, 0, 0, 0, &mut published)
.await
.unwrap(),
0
);
assert!(
kernel.lock().unwrap().set_calls.is_empty(),
"nothing admitted, no request"
);
assert_eq!(
wait.admit_under_block(&mut guest, 0, chld, chld, &mut published)
.await
.unwrap(),
0,
"a SIGCHLD a host-timed source can post is not admitted"
);
assert!(kernel.lock().unwrap().set_calls.is_empty());
drop(_proc);
let (mut guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
kernel.lock().unwrap().shared = chld;
kernel.lock().unwrap().setter.push_back(None);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
assert_eq!(
wait.admit_under_block(&mut guest, 0, chld, 0, &mut published)
.await
.unwrap(),
0,
"only on the shared queue: not the recorded copy"
);
wait.restore(&mut guest, None).await.unwrap();
drop(_proc);
let (mut guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
assert_eq!(
wait.admit_under_block(&mut guest, 0, chld, 0, &mut published)
.await
.unwrap(),
0,
"the setter refuses (no answer queued)"
);
assert!(
wait.needs_block(),
"the injected block after the first probe stays"
);
drop(_proc);
let (mut guest, kernel) = caught_sigchld_guest(true);
let _proc = scripted_proc(&kernel);
let mut wait = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
wait.unblockable = true;
assert_eq!(
wait.admit_under_block(&mut guest, 0, chld, 0, &mut published)
.await
.unwrap(),
0,
"an earlier injected block failed: no block, no private copy"
);
assert!(kernel.lock().unwrap().set_calls.is_empty());
}
#[tokio::test]
async fn a_pipe_turn_counts_a_recorded_private_sigchld_only_under_a_block_in_place() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
let turn = |may_block: bool, gate: bool, shared: bool| async move {
let (mut guest, kernel) = WaitGuest::new(Pid::from_raw(1), guest_mask());
{
let mut kernel = kernel.lock().unwrap();
kernel.pending = chld;
kernel.caught = chld;
kernel.shared = if shared { chld } else { 0 };
kernel.setter.push_back(None);
kernel.private_record = Some((0, chld));
}
let _proc = scripted_proc(&kernel);
let mut wait = Some(KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTSYS));
let mut published = PublishedWaitMask(Some(guest_mask()));
let pending =
turn_signals_with_block(&mut guest, &mut wait, may_block, 0, gate, &mut published)
.await
.unwrap()
.pending;
if let Some(wait) = wait.as_mut() {
wait.restore(&mut guest, None).await.unwrap();
}
let blocked_in_place = !kernel.lock().unwrap().set_calls.is_empty();
(pending & chld, blocked_in_place)
};
assert_eq!(
turn(true, true, false).await,
(chld, true),
"blocked in place: admitted"
);
assert_eq!(
turn(false, true, false).await,
(0, false),
"the writer's first attempt blocks nothing: held"
);
assert_eq!(turn(true, false, false).await, (0, true), "no gate: held");
assert_eq!(
turn(true, true, true).await,
(0, true),
"the shared queue alone: held"
);
}
#[test]
fn a_pipe_turn_counts_an_admitted_private_sigchld() {
let chld = kernel_sigset_bit(libc::SIGCHLD);
let state = KernelSignalState {
pending: chld,
thread_pending: chld,
caught: chld,
..KernelSignalState::default()
};
assert_eq!(
turn_signals_before_discard(&state, 0, 0, 0, NamedRealTime::Woken, 0).pending,
0,
"held"
);
assert_eq!(
turn_signals_before_discard(&state, 0, 0, 0, NamedRealTime::Woken, chld).pending,
chld,
"admitted"
);
}
#[tokio::test]
async fn a_pending_caught_sigchld_ends_a_select_wait_before_the_injection() {
let (mut guest, kernel) = caught_sigchld_guest(true);
kernel.lock().unwrap().stops_for_pending = true;
let _proc = scripted_proc(&kernel);
let mut select = KernelSignalWait::for_select(&guest);
let result = inject_mask_absorbing(&mut select, &mut guest, guest_mask()).await;
assert!(
matches!(result, Err(Error::Errno(Errno::ERESTARTNOHAND))),
"{result:?}"
);
{
let kernel = kernel.lock().unwrap();
assert!(kernel.requested.is_empty(), "nothing is injected");
assert_eq!(kernel.pending, kernel_sigset_bit(libc::SIGCHLD));
}
assert_eq!(select.held, None);
let mut gated = KernelSignalWait::new(&guest, 0, false, Errno::ERESTARTNOHAND);
let result = inject_mask_absorbing(&mut gated, &mut guest, guest_mask()).await;
assert!(matches!(result, Ok(Ok(0))), "{result:?}");
{
let kernel = kernel.lock().unwrap();
assert_eq!(kernel.taken, vec![libc::SIGCHLD]);
assert_eq!(kernel.requested.len(), 2, "stopped once, then ran");
}
assert_eq!(gated.held.map(|held| held.kind), Some(HeldKind::Precious));
}
#[test]
fn next_dequeued_follows_the_kernel_order() {
let bit = kernel_sigset_bit;
let state = KernelSignalState {
thread_pending: bit(libc::SIGUSR2) | bit(libc::SIGSEGV),
shared_pending: bit(libc::SIGHUP),
..KernelSignalState::default()
};
assert_eq!(
state.next_dequeued(0),
Some((libc::SIGSEGV, SignalQueue::Thread))
);
assert_eq!(
state.next_dequeued(bit(libc::SIGSEGV)),
Some((libc::SIGUSR2, SignalQueue::Thread))
);
assert_eq!(
state.next_dequeued(bit(libc::SIGSEGV) | bit(libc::SIGUSR2)),
Some((libc::SIGHUP, SignalQueue::Shared))
);
assert_eq!(state.next_dequeued(!0), None);
}
#[test]
fn a_stop_is_identified_only_by_exactly_its_signal() {
let bit = kernel_sigset_bit;
let before = KernelSignalState {
thread_pending: bit(libc::SIGUSR1) | bit(libc::SIGWINCH),
shared_pending: bit(libc::SIGHUP),
..KernelSignalState::default()
};
let took = |after: KernelSignalState, signal, queue| {
stop_took_only(&before, &after, signal, queue)
};
let after = KernelSignalState {
thread_pending: bit(libc::SIGWINCH) | bit(libc::SIGUSR2),
..before
};
assert!(took(after, libc::SIGUSR1, SignalQueue::Thread));
assert!(
!took(after, libc::SIGWINCH, SignalQueue::Thread),
"SIGWINCH is still queued"
);
let two_left = KernelSignalState {
thread_pending: 0,
..before
};
assert!(!took(two_left, libc::SIGUSR1, SignalQueue::Thread));
let shared_left = KernelSignalState {
thread_pending: bit(libc::SIGWINCH),
shared_pending: 0,
..before
};
assert!(!took(shared_left, libc::SIGUSR1, SignalQueue::Thread));
let mask_changed = KernelSignalState {
blocked: bit(libc::SIGUSR2),
..after
};
assert!(!took(mask_changed, libc::SIGUSR1, SignalQueue::Thread));
let disposition_changed = KernelSignalState {
ignored: bit(libc::SIGWINCH),
..after
};
assert!(!took(
disposition_changed,
libc::SIGUSR1,
SignalQueue::Thread
));
}
#[test]
fn a_signal_the_temporary_mask_blocks_is_held_not_ended() {
let bit = kernel_sigset_bit;
let (guest, _kernel) = WaitGuest::live(guest_mask());
let before = KernelSignalState {
pending: bit(libc::SIGALRM),
thread_pending: bit(libc::SIGALRM),
blocked: guest_mask(),
caught: bit(libc::SIGALRM) | bit(libc::SIGUSR2),
..KernelSignalState::default()
};
let plain = KernelSignalWait::for_select(&guest);
assert_eq!(
plain.stop_verdict(&before, libc::SIGALRM),
StopVerdict::End(Errno::ERESTARTNOHAND)
);
let masked = KernelSignalWait::for_select(&guest).with_wait_mask(Some(bit(libc::SIGALRM)));
assert_eq!(
masked.stop_verdict(&before, libc::SIGALRM),
StopVerdict::Absorb(HeldKind::Precious)
);
let unblocking = KernelSignalWait::for_select(&guest).with_wait_mask(Some(0));
assert_eq!(
unblocking.stop_verdict(&before, libc::SIGUSR2),
StopVerdict::End(Errno::ERESTARTNOHAND)
);
}
}
#[cfg(test)]
mod turn_signal_tests {
use super::*;
fn bit(signal: libc::c_int) -> KernelSigset {
kernel_sigset_bit(signal)
}
fn state(
pending: KernelSigset,
caught: KernelSigset,
blocked: KernelSigset,
) -> KernelSignalState {
KernelSignalState {
pending,
thread_pending: pending,
caught,
blocked,
..Default::default()
}
}
#[test]
fn a_named_wake_ends_a_call_only_after_progress() {
let named = TurnSignals {
named: bit(libc::SIGUSR1),
pending: 0,
};
assert!(!named.ends(false));
assert!(named.ends(true));
let pending = TurnSignals {
named: 0,
pending: bit(libc::SIGUSR1),
};
assert!(pending.ends(false));
assert!(pending.ends(true));
assert!(!TurnSignals::default().ends(true));
}
#[test]
fn the_hold_leaves_out_an_uncommitted_sigchld_and_every_host_timed_signal() {
let chld = bit(libc::SIGCHLD);
let hup = bit(libc::SIGHUP);
let s = state(chld | hup, chld | hup, 0);
assert_eq!(
turn_signals_before_discard(&s, 0, hup, 0, NamedRealTime::Woken, 0).pending,
0
);
assert_eq!(
turn_signals_before_discard(&s, 0, hup, chld, NamedRealTime::Woken, 0).pending,
chld
);
assert_eq!(
turn_signals_before_discard(&s, 0, hup, chld | hup, NamedRealTime::Woken, 0).pending,
chld
);
}
#[test]
fn a_named_signal_counts_only_unblocked_and_a_real_time_one_by_its_call() {
use NamedRealTime::ByDisposition;
use NamedRealTime::Woken;
let usr1 = bit(libc::SIGUSR1);
let rt = bit(libc::SIGRTMIN());
let s = state(0, usr1, usr1);
for real_time in [Woken, ByDisposition] {
assert_eq!(
turn_signals_before_discard(&s, usr1, 0, usr1, real_time, 0).named,
0
);
assert_eq!(
turn_signals_before_discard(&s, 0, 0, usr1, real_time, 0).named,
usr1
);
}
let ignored_rt = KernelSignalState {
ignored: rt,
..state(0, 0, 0)
};
assert_eq!(
turn_signals_before_discard(&ignored_rt, 0, 0, rt, ByDisposition, 0).named,
0
);
assert_eq!(
turn_signals_before_discard(&ignored_rt, 0, 0, rt, Woken, 0).named,
rt
);
assert_eq!(
turn_signals_before_discard(&ignored_rt, rt, 0, rt, Woken, 0).named,
0
);
let caught_rt = state(0, rt, 0);
assert_eq!(
turn_signals_before_discard(&caught_rt, 0, 0, rt, ByDisposition, 0).named,
rt
);
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ContinuationMask {
Temporary,
Unknown,
Restored,
}
pub(crate) fn continuation_mask(call: Syscall, result: &Result<i64, Error>) -> ContinuationMask {
let ended_by = |errno: Errno| matches!(result, Err(Error::Errno(error)) if *error == errno);
let kept = match call {
Syscall::RtSigsuspend(_) => return ContinuationMask::Unknown,
Syscall::Pselect6(_) | Syscall::Ppoll(_) => {
ended_by(Errno::ERESTARTNOHAND) || ended_by(Errno::EINTR)
}
Syscall::EpollPwait(_) | Syscall::Other(Sysno::epoll_pwait2, _) => ended_by(Errno::EINTR),
_ => false,
};
if kept {
ContinuationMask::Temporary
} else {
ContinuationMask::Restored
}
}
#[cfg(test)]
mod temporary_mask_tests {
use super::*;
#[test]
fn the_continuation_mask_follows_what_the_kernel_did() {
let restart = Err(Error::Errno(Errno::ERESTARTNOHAND));
let eintr = Err(Error::Errno(Errno::EINTR));
let pselect = Syscall::Pselect6(syscalls::Pselect6::new());
let ppoll = Syscall::Ppoll(syscalls::Ppoll::new());
let epoll = Syscall::EpollPwait(syscalls::EpollPwait::new());
let epoll2 = Syscall::Other(
Sysno::epoll_pwait2,
reverie::syscalls::SyscallArgs::new(0, 0, 0, 0, 0, 0),
);
let before_entry = Err(Error::Errno(Errno::ERESTARTSYS));
let sigsuspend = Syscall::RtSigsuspend(syscalls::RtSigsuspend::new());
let read = Syscall::Read(syscalls::Read::new());
let ebadf = Err(Error::Errno(Errno::EBADF));
use ContinuationMask::*;
for call in [pselect, ppoll] {
assert_eq!(continuation_mask(call, &restart), Temporary, "{call:?}");
assert_eq!(continuation_mask(call, &eintr), Temporary, "{call:?}");
assert_eq!(continuation_mask(call, &before_entry), Restored, "{call:?}");
assert_eq!(continuation_mask(call, &ebadf), Restored, "{call:?}");
assert_eq!(continuation_mask(call, &Ok(1)), Restored, "{call:?}");
}
for result in [&restart, &eintr, &before_entry, &Ok(0)] {
assert_eq!(continuation_mask(sigsuspend, result), Unknown, "{result:?}");
}
for call in [epoll, epoll2] {
assert_eq!(continuation_mask(call, &eintr), Temporary, "{call:?}");
assert_eq!(continuation_mask(call, &restart), Restored, "{call:?}");
assert_eq!(continuation_mask(call, &before_entry), Restored, "{call:?}");
assert_eq!(continuation_mask(call, &Ok(0)), Restored, "{call:?}");
}
assert_eq!(continuation_mask(read, &restart), Restored);
}
}