use std::time::Duration;
use std::time::Instant;
use reverie::Error;
use reverie::Guest;
use reverie::Stack;
use reverie::syscalls;
use reverie::syscalls::AddrMut;
use reverie::syscalls::Errno;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallInfo;
use reverie::syscalls::Sysno;
use crate::detlog;
use crate::fd::FdType;
use crate::fd::VirtualTimerfd;
use crate::record_or_replay::RecordOrReplay;
use crate::syscalls::helpers::poll_deadline_for;
use crate::tool_global::thread_observe_time;
use crate::tool_local::Detcore;
use crate::types::LogicalTime;
use crate::types::RawFd;
const READABLE_VALVE: Duration = Duration::from_secs(30);
const FAULT_ENV: &str = "HERMIT_TEST_TIMERFD_FAULT";
#[derive(Clone, Copy, PartialEq, Eq)]
enum Fault {
NeverReadable,
SignalBeforeArm,
}
pub(crate) const TFD_IOC_SET_TICKS: u64 = 0x4008_5400;
pub(crate) fn detcore_runs_outside_the_guest(backend: &reverie::BackendCapabilities) -> bool {
!backend.tool_shares_guest_descriptor_table && !backend.process_exits_complete_asynchronously
}
pub(crate) fn models_are_shared(backend: &reverie::BackendCapabilities) -> bool {
detcore_runs_outside_the_guest(backend) || backend.promotes_open_files_before_native_lifecycle
}
pub(crate) fn enabled<T, G>(guest: &G) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let config = guest.config();
config.virtualize_time
&& config.sequentialize_threads
&& !config.recordreplay_modes
&& models_are_shared(&config.backend)
}
pub(crate) fn refuse_unshared_model<T, G>(guest: &G)
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let config = guest.config();
if config.virtualize_time
&& config.sequentialize_threads
&& !config.recordreplay_modes
&& !models_are_shared(&config.backend)
{
refuse(format_args!(
"timerfd_create on a backend whose runtime does not keep one model of an open \
file description across fork and exec (it does not promote them before a \
native fork or exec), so the timer would follow the host clock"
));
}
}
pub(crate) fn refuse(what: std::fmt::Arguments<'_>) -> ! {
crate::scheduler::exit_on_scheduler_refusal(&format_args!(
"hermit: refusing the run: {what}; a timerfd on Detcore's virtual clock cannot be served here (https://github.com/rrnewton/hermit/issues/1923)"
))
}
pub(crate) fn is_timerfd<T, G>(guest: &G, fd: RawFd) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.ty() == FdType::Timerfd)
.unwrap_or(false)
}
pub(crate) fn has_virtual_timerfds<T, G>(guest: &G) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
enabled(guest) && !guest.thread_state().virtual_timerfds().is_empty()
}
pub(crate) fn refuse_host_wait<T, G>(guest: &G, call: &str)
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if has_virtual_timerfds(guest) {
refuse(format_args!(
"{call} would wait in the host on descriptors that may include a timerfd that only Detcore's probes make readable"
));
}
}
const MAX_SCANNED_DESCRIPTORS: usize = 1 << 16;
fn call_may_name_timerfd<T, G>(guest: &G, call: Syscall) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let names = |fds: &mut dyn Iterator<Item = RawFd>| {
for fd in fds {
let ty = guest.thread_state().with_detfd(fd, |detfd| detfd.ty());
if matches!(ty, Ok(FdType::Timerfd) | Ok(FdType::Epoll)) {
return true;
}
}
false
};
let pollfds = |address: Option<usize>, nfds: u64| -> bool {
let count = nfds as u32 as usize;
if count == 0 {
return false;
}
let Some(address) = address.and_then(syscalls::Addr::<u8>::from_raw) else {
return true;
};
if count > MAX_SCANNED_DESCRIPTORS {
return true;
}
let mut bytes = vec![0u8; count * std::mem::size_of::<libc::pollfd>()];
if guest.memory().read_exact(address, &mut bytes).is_err() {
return true;
}
names(
&mut bytes
.as_chunks::<{ std::mem::size_of::<libc::pollfd>() }>()
.0
.iter()
.map(|entry| RawFd::from_ne_bytes(entry[..4].try_into().unwrap())),
)
};
let fd_sets = |nfds: i32, sets: [Option<usize>; 3]| -> bool {
let Ok(count) = usize::try_from(nfds) else {
return false;
};
if count > MAX_SCANNED_DESCRIPTORS {
return true;
}
let len = count.div_ceil(64) * 8;
sets.into_iter().flatten().any(|set| {
let Some(address) = syscalls::Addr::<u8>::from_raw(set) else {
return false;
};
let mut bits = vec![0u8; len];
if guest.memory().read_exact(address, &mut bits).is_err() {
return true;
}
names(
&mut (0..count)
.filter(|fd| bits[fd / 8] & (1 << (fd % 8)) != 0)
.map(|fd| fd as RawFd),
)
})
};
match call {
Syscall::Poll(poll) => pollfds(poll.fds().map(|fds| fds.as_raw()), poll.nfds()),
Syscall::Ppoll(ppoll) => pollfds(ppoll.fds().map(|fds| fds.as_raw()), ppoll.nfds()),
Syscall::Select(select) => fd_sets(
select.nfds(),
[select.readfds(), select.writefds(), select.exceptfds()]
.map(|set| set.map(|set| set.as_raw())),
),
Syscall::Pselect6(pselect6) => fd_sets(
pselect6.nfds(),
[
pselect6.readfds(),
pselect6.writefds(),
pselect6.exceptfds(),
]
.map(|set| set.map(|set| set.as_raw())),
),
Syscall::Read(read) => is_timerfd(guest, read.fd()),
Syscall::Readv(readv) => is_timerfd(guest, readv.fd()),
_ => true,
}
}
pub(crate) fn refuse_host_wait_for<T, G>(guest: &G, call: Syscall)
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if has_virtual_timerfds(guest)
&& observes_timerfds(guest, call)
&& call_may_name_timerfd(guest, call)
{
refuse(format_args!(
"{} would wait in the host on descriptors that may include a timerfd that only Detcore's probes make readable",
call.number().name()
));
}
}
pub(crate) fn observes_timerfds<T, G>(guest: &G, call: Syscall) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
match call {
Syscall::Poll(_)
| Syscall::Ppoll(_)
| Syscall::Select(_)
| Syscall::Pselect6(_)
| Syscall::EpollWait(_)
| Syscall::EpollPwait(_) => true,
Syscall::Other(Sysno::epoll_pwait2, _) => true,
Syscall::Read(read) => is_timerfd(guest, read.fd()),
Syscall::Readv(readv) => is_timerfd(guest, readv.fd()),
_ => false,
}
}
fn valid(ts: &libc::timespec) -> bool {
ts.tv_sec >= 0 && (0..1_000_000_000).contains(&ts.tv_nsec)
}
fn timespec_ns(ts: &libc::timespec) -> u64 {
(ts.tv_sec as u64)
.saturating_mul(1_000_000_000)
.saturating_add(ts.tv_nsec as u64)
}
fn itimerspec(remaining_ns: u64, interval_ns: u64) -> libc::itimerspec {
let ts = |ns: u64| libc::timespec {
tv_sec: (ns / 1_000_000_000) as libc::time_t,
tv_nsec: (ns % 1_000_000_000) as libc::c_long,
};
libc::itimerspec {
it_interval: ts(interval_ns),
it_value: ts(remaining_ns),
}
}
async fn timerfd_now<T, G>(guest: &mut G) -> LogicalTime
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let raw = thread_observe_time(guest).await;
guest.thread_state().peek_guest_clock(raw)
}
pub(crate) async fn publish_expired<T, G>(guest: &mut G) -> Option<LogicalTime>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
publish_expired_in(guest, None).await
}
#[derive(Clone, Copy)]
pub(crate) struct Scratch {
setting: AddrMut<'static, libc::itimerspec>,
pollfd: AddrMut<'static, libc::pollfd>,
}
pub(crate) fn holds_armed_virtual_timerfd<T, G>(guest: &G) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
enabled(guest)
&& guest
.thread_state()
.virtual_timerfds()
.iter()
.any(|(_, detfd)| detfd.virtual_timerfd().and_then(|t| t.deadline).is_some())
}
pub(crate) fn reserve_scratch<S: Stack>(stack: &mut S) -> Scratch {
Scratch {
setting: stack.reserve(),
pollfd: stack.reserve(),
}
}
pub(crate) fn may_publish<T, G>(guest: &G, call: Syscall) -> bool
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
enabled(guest)
&& observes_timerfds(guest, call)
&& guest
.thread_state()
.virtual_timerfds()
.iter()
.any(|(_, detfd)| detfd.virtual_timerfd().and_then(|t| t.deadline).is_some())
}
pub(crate) async fn publish_expired_in<T, G>(
guest: &mut G,
scratch: Option<Scratch>,
) -> Option<LogicalTime>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if !holds_armed_virtual_timerfd(guest) {
return None;
}
let timerfds = guest.thread_state().virtual_timerfds();
let now = timerfd_now(guest).await;
let mut next: Option<LogicalTime> = None;
for (fd, detfd) in timerfds {
let Some(mut timer) = detfd.virtual_timerfd() else {
continue;
};
let added = timer.expire_through(now);
if added > 0 {
make_readable(guest, fd, scratch).await;
detfd.set_virtual_timerfd(Some(timer));
detlog!(
"[dtid {}] timerfd {} expired {} time(s) at virtual time {}, {} unread",
guest.thread_state().dettid,
fd,
added,
now,
timer.unread,
);
}
if let Some(deadline) = timer.deadline {
next = Some(next.map_or(deadline, |earliest| earliest.min(deadline)));
}
}
next
}
pub(crate) fn poll_deadline_with<T, G>(
guest: &G,
timeout: Option<LogicalTime>,
next_timerfd: Option<LogicalTime>,
) -> Option<LogicalTime>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let deadline = match (timeout, next_timerfd) {
(Some(a), Some(b)) => Some(a.min(b)),
(a, b) => a.or(b),
};
poll_deadline_for(guest, deadline)
}
pub(crate) async fn publish_before_probe<T, G>(
guest: &mut G,
call: Syscall,
timeout: Option<LogicalTime>,
) -> Option<LogicalTime>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if !observes_timerfds(guest, call) {
return poll_deadline_for(guest, timeout);
}
let next = publish_expired(guest).await;
poll_deadline_with(guest, timeout, next)
}
fn take_fault() -> Option<Fault> {
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
static FIRED: AtomicBool = AtomicBool::new(false);
let fault = match std::env::var(FAULT_ENV).as_deref() {
Ok("never-readable") => Fault::NeverReadable,
Ok("signal-before-arm") => Fault::SignalBeforeArm,
_ => return None,
};
(!FIRED.swap(true, Ordering::SeqCst)).then_some(fault)
}
async fn inject_bounded<T, G, S>(
guest: &mut G,
call: S,
start: Instant,
valve: Duration,
what: &'static str,
fd: RawFd,
) -> i64
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
S: SyscallInfo + Copy,
{
loop {
match guest.inject(call).await {
Ok(value) => return value,
Err(Errno::ERESTARTSYS | Errno::EINTR) if start.elapsed() < valve => {}
Err(errno) => refuse(format_args!("{what} {fd} failed with {errno}")),
}
}
}
async fn make_readable<T, G>(guest: &mut G, fd: RawFd, scratch: Option<Scratch>)
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let (setting, pollfd, _guard) = match scratch {
Some(scratch) => (scratch.setting, scratch.pollfd, None),
None => {
let mut stack = guest.stack().await;
let scratch = reserve_scratch(&mut stack);
let Ok(guard) = stack.commit() else {
refuse(format_args!(
"no scratch memory to make expired timerfd {fd} readable"
));
};
(scratch.setting, scratch.pollfd, Some(guard))
}
};
let fault = take_fault();
let never_readable = fault == Some(Fault::NeverReadable);
let valve = if never_readable {
Duration::from_secs(1)
} else {
READABLE_VALVE
};
let start = Instant::now();
if !never_readable {
if let Err(error) = guest.memory().write_value(setting, &itimerspec(1, 0)) {
refuse(format_args!(
"could not stage the setting that makes expired timerfd {fd} readable: {error}"
));
}
let arm = syscalls::TimerfdSettime::new()
.with_fd(fd)
.with_flags(libc::TFD_TIMER_ABSTIME)
.with_new_value(Some(setting.into()))
.with_old_value(None);
if fault == Some(Fault::SignalBeforeArm)
&& !guest.config().backend.provides_process_signal_control
{
unsafe {
libc::syscall(
libc::SYS_tgkill,
guest.pid().as_raw(),
guest.tid().as_raw(),
libc::SIGCONT,
);
}
if let Err(Errno::ERESTARTSYS | Errno::EINTR) = guest.inject(arm).await {
tracing::warn!(
"[detcore, dtid {}] timerfd fault hook: a host signal interrupted arming timerfd {}; retrying",
guest.thread_state().dettid,
fd,
);
}
}
inject_bounded(
guest,
arm,
start,
valve,
"arming, to make its expiration readable, the host timerfd",
fd,
)
.await;
}
loop {
if let Err(error) = guest.memory().write_value(
pollfd,
&libc::pollfd {
fd,
events: libc::POLLIN,
revents: 0,
},
) {
refuse(format_args!(
"could not stage the readiness probe of timerfd {fd}: {error}"
));
}
let probe = syscalls::Poll::new()
.with_fds(Some(pollfd.cast()))
.with_nfds(1)
.with_timeout(1);
let ready = inject_bounded(
guest,
probe,
start,
valve,
"probing for its expiration the host timerfd",
fd,
)
.await;
if ready > 0 {
match guest.memory().read_value(pollfd) {
Ok(pollfd) if pollfd.revents & libc::POLLIN != 0 => return,
Ok(_) => {}
Err(error) => refuse(format_args!(
"could not read the readiness probe of timerfd {fd}: {error}"
)),
}
}
if start.elapsed() >= valve {
refuse(format_args!(
"the host timerfd {fd} did not become readable within {valve:?} of being armed to expire at once"
));
}
}
}
pub(crate) async fn settime<T, G>(
guest: &mut G,
call: syscalls::TimerfdSettime,
) -> Result<Option<i64>, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let fd = call.fd();
if !enabled(guest) || !is_timerfd(guest, fd) {
return Ok(None);
}
let new_ptr = call.new_value().ok_or(Errno::EFAULT)?;
let new: libc::itimerspec = guest.memory().read_value(new_ptr)?;
if !valid(&new.it_value) || !valid(&new.it_interval) {
return Err(Errno::EINVAL.into());
}
{
let mut stack = guest.stack().await;
let disarm: AddrMut<libc::itimerspec> = stack.reserve();
let _guard = stack.commit()?;
guest.memory().write_value(disarm, &itimerspec(0, 0))?;
guest
.inject_with_retry(
call.with_flags(call.flags() & !libc::TFD_TIMER_CANCEL_ON_SET)
.with_new_value(Some(disarm.into()))
.with_old_value(None),
)
.await?;
}
let now = timerfd_now(guest).await;
let detfd = guest.thread_state().with_detfd(fd, |detfd| detfd.clone())?;
let mut old = detfd.virtual_timerfd().unwrap_or_default();
old.expire_through(now);
let (old_remaining_ns, old_interval_ns) = old.remaining(now);
let value_ns = timespec_ns(&new.it_value);
let interval_ns = timespec_ns(&new.it_interval);
let deadline = if value_ns == 0 {
None
} else if call.flags() & libc::TFD_TIMER_ABSTIME != 0 {
Some(LogicalTime::from_nanos(value_ns))
} else {
Some(LogicalTime::from_nanos(
now.as_nanos().saturating_add(value_ns),
))
};
detfd.set_virtual_timerfd(Some(VirtualTimerfd::set(deadline, interval_ns)));
detlog!(
"[dtid {}] timerfd_settime(fd={}, flags={:#x}, interval_ns={}, value_ns={}) armed against virtual clock",
guest.thread_state().dettid,
fd,
call.flags(),
interval_ns,
value_ns,
);
if let Some(old_ptr) = call.old_value() {
guest
.memory()
.write_value(old_ptr, &itimerspec(old_remaining_ns, old_interval_ns))?;
}
Ok(Some(0))
}
pub(crate) async fn gettime<T, G>(
guest: &mut G,
call: syscalls::TimerfdGettime,
) -> Result<Option<i64>, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let fd = call.fd();
if !enabled(guest) || !is_timerfd(guest, fd) {
return Ok(None);
}
let detfd = guest.thread_state().with_detfd(fd, |detfd| detfd.clone())?;
if detfd.virtual_timerfd().is_none() {
return Ok(None);
}
let value_ptr = call.value().ok_or(Errno::EFAULT)?;
publish_expired(guest).await;
let now = timerfd_now(guest).await;
let timer = detfd.virtual_timerfd().unwrap_or_default();
let (remaining_ns, interval_ns) = timer.remaining(now);
guest
.memory()
.write_value(value_ptr, &itimerspec(remaining_ns, interval_ns))?;
Ok(Some(0))
}
fn take_unread<T, G>(guest: &mut G, fd: RawFd) -> Option<u64>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
let detfd = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.clone())
.ok()?;
let mut timer = detfd.virtual_timerfd()?;
if timer.unread == 0 {
return None;
}
let unread = timer.unread;
timer.unread = 0;
detfd.set_virtual_timerfd(Some(timer));
Some(unread)
}
pub(crate) fn finish_read<T, G>(
guest: &mut G,
fd: RawFd,
buf: Option<AddrMut<u8>>,
result: Result<i64, Error>,
) -> Result<i64, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if !enabled(guest) || !matches!(result, Ok(8)) {
return result;
}
let Some(buf) = buf else {
return result;
};
if let Some(unread) = take_unread(guest, fd) {
guest.memory().write_value(buf.cast::<u64>(), &unread)?;
}
result
}
pub(crate) fn finish_readv<T, G>(
guest: &mut G,
fd: RawFd,
iov: Option<syscalls::Addr<libc::iovec>>,
iovcnt: usize,
result: Result<i64, Error>,
) -> Result<i64, Error>
where
T: RecordOrReplay,
G: Guest<Detcore<T>>,
{
if !enabled(guest) || !matches!(result, Ok(8)) {
return result;
}
let Some(iov) = iov else {
return result;
};
let Some(unread) = take_unread(guest, fd) else {
return result;
};
let bytes = unread.to_ne_bytes();
let mut written = 0;
for index in 0..iovcnt {
if written == bytes.len() {
break;
}
let Some(slot) = syscalls::Addr::<libc::iovec>::from_raw(
iov.as_raw() + index * std::mem::size_of::<libc::iovec>(),
) else {
break;
};
let entry: libc::iovec = guest.memory().read_value(slot)?;
let take = entry.iov_len.min(bytes.len() - written);
if take == 0 {
continue;
}
let Some(base) = AddrMut::<u8>::from_raw(entry.iov_base as usize) else {
break;
};
guest
.memory()
.write_exact(base, &bytes[written..written + take])?;
written += take;
}
result
}
#[cfg(test)]
mod tests {
use reverie::BackendCapabilities;
use super::detcore_runs_outside_the_guest;
use super::models_are_shared;
#[test]
fn timerfd_models_are_shared_per_backend() {
for (name, backend, outside, shared) in [
("ptrace", BackendCapabilities::PTRACE, true, true),
("e9patch", BackendCapabilities::E9PATCH, true, true),
("kvm", BackendCapabilities::KVM, true, true),
("sabre", BackendCapabilities::SABRE, false, false),
("dbt", BackendCapabilities::DBT, false, true),
(
"liteinst in-guest",
BackendCapabilities::LITEINST_IN_GUEST,
false,
true,
),
] {
assert_eq!(detcore_runs_outside_the_guest(&backend), outside, "{name}");
assert_eq!(models_are_shared(&backend), shared, "{name}");
}
}
}