use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::net::Ipv4Addr;
use std::net::Ipv6Addr;
use std::os::unix::fs::FileTypeExt;
use std::os::unix::fs::MetadataExt;
use std::path::Path;
use std::path::PathBuf;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use detcore_model::bundled_signal_facts;
use nix::fcntl::AtFlags;
use nix::fcntl::OFlag;
use rand::RngExt as _;
use reverie::Error;
use reverie::Guest;
use reverie::Stack;
use reverie::syscalls;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::AddrSlice;
use reverie::syscalls::AddrSliceMut;
use reverie::syscalls::Errno;
use reverie::syscalls::FcntlCmd::*;
use reverie::syscalls::MapFlags;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::PathPtr;
use reverie::syscalls::ProtFlags;
use reverie::syscalls::ReadAddr;
use reverie::syscalls::SockFlag;
use reverie::syscalls::StatPtr;
use reverie::syscalls::StatxMask;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallInfo;
use reverie::syscalls::Sysno;
use reverie::syscalls::Timespec;
use reverie::syscalls::Whence;
use reverie::syscalls::family::StatFamily;
use tracing::error;
use tracing::info;
use tracing::trace;
use tracing::warn;
use super::deterministic_stdio_inode_for_resource;
use crate::config::SchedHeuristic;
use crate::dirents::*;
use crate::fd::*;
use crate::fifo_peer::FifoPeer;
use crate::procfs::MountInfoSnapshot;
use crate::procfs::ProcfsFile;
use crate::procfs::ProcfsSnapshotContext;
use crate::procfs::is_absent_cpu_entry;
use crate::procfs::levels;
use crate::procfs_inode;
use crate::procfs_inode::DirectoryInodes;
use crate::procfs_inode::ProcfsDirectory;
use crate::procfs_inode::ProcfsName;
use crate::record_or_replay::RecordOrReplay;
use crate::resources::Device;
use crate::resources::HOST_TIMED_INTERNAL_PIPE_IO_FYI;
use crate::resources::Permission;
use crate::resources::ResourceID;
use crate::resources::Resources;
use crate::scheduler::HostTimedSignalScope;
use crate::scheduler::runqueue::LAST_PRIORITY;
use crate::scheduler::terminal_signals;
use crate::stat::*;
use crate::syscalls::threads::kernel_sigset_bit;
use crate::tool_global::*;
use crate::tool_local::CapturedDetFdInstallError;
use crate::tool_local::Detcore;
use crate::tool_local::finish_partial_record_or_replay_write;
use crate::types::*;
pub(crate) mod procfs_levels;
pub(crate) mod procfs_numbers;
pub(crate) mod rendered_procfs;
fn oflag_from_sock_bits(s_bits: i32) -> OFlag {
OFlag::from_bits_truncate(s_bits & (libc::SOCK_CLOEXEC | libc::SOCK_NONBLOCK))
}
const UNIX_AUTOBIND_NAME_LEN: usize = 6;
const TIMER_SLACK_PARSE_BYTES: usize = 66;
#[derive(Clone, Copy)]
struct TimerSlackIovec {
base: usize,
len: usize,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct TimerSlackBinding {
target: i32,
device: u64,
inode: u64,
}
fn classify_timer_slack_binding(
binding: TimerSlackBinding,
observed_identity: Option<(u64, u64)>,
current_tid: i32,
) -> Result<(), Errno> {
if observed_identity != Some((binding.device, binding.inode)) {
return Err(Errno::ESRCH);
}
if current_tid != binding.target {
return Err(Errno::EPERM);
}
Ok(())
}
fn parse_timer_slack_write(bytes: &[u8]) -> Result<u64, Errno> {
let bytes = &bytes[..bytes.len().min(TIMER_SLACK_PARSE_BYTES)];
let end = bytes
.iter()
.position(|byte| *byte == 0)
.unwrap_or(bytes.len());
let mut value = &bytes[..end];
if value.first() == Some(&b'+') {
value = &value[1..];
}
if value.last() == Some(&b'\n') {
value = &value[..value.len() - 1];
}
if value.is_empty() || !value.iter().all(u8::is_ascii_digit) {
return Err(Errno::EINVAL);
}
value.iter().try_fold(0_u64, |parsed, digit| {
parsed
.checked_mul(10)
.and_then(|parsed| parsed.checked_add(u64::from(digit - b'0')))
.ok_or(Errno::ERANGE)
})
}
fn vectored_offset(low: u64, high: u64) -> i64 {
if std::mem::size_of::<usize>() == 8 {
low as i64
} else {
((high << 32) | (low & u32::MAX as u64)) as i64
}
}
struct RandomVectoredRead {
address: usize,
count: usize,
offset: Option<u64>,
flags: i32,
}
fn validate_random_vector_read(offset: Option<u64>, total: usize, flags: i32) -> Result<(), Errno> {
if total == 0 {
return Ok(());
}
if let Some(offset) = offset
&& offset
.checked_add(total as u64)
.is_none_or(|end| end > i64::MAX as u64)
{
return Err(Errno::EINVAL);
}
const RWF_NOSIGNAL: i32 = 0x100;
const KNOWN: i32 = libc::RWF_HIPRI
| libc::RWF_DSYNC
| libc::RWF_SYNC
| libc::RWF_NOWAIT
| libc::RWF_APPEND
| libc::RWF_NOAPPEND
| libc::RWF_ATOMIC
| libc::RWF_DONTCACHE
| RWF_NOSIGNAL;
if flags & !KNOWN != 0 {
return Err(Errno::EOPNOTSUPP);
}
if flags & libc::RWF_APPEND != 0 && flags & libc::RWF_NOAPPEND != 0 {
return Err(Errno::EINVAL);
}
if flags & (libc::RWF_ATOMIC | libc::RWF_DONTCACHE) != 0 {
return Err(Errno::EOPNOTSUPP);
}
Ok(())
}
fn read_iovecs<M: MemoryAccess>(
memory: &M,
address: Option<Addr<libc::iovec>>,
count: usize,
) -> Result<Vec<TimerSlackIovec>, Errno> {
if count > libc::UIO_MAXIOV as usize {
return Err(Errno::EINVAL);
}
if count == 0 {
return Ok(Vec::new());
}
let address = address.ok_or(Errno::EFAULT)?;
let mut iovecs = vec![
libc::iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
};
count
];
memory.read_values(address, &mut iovecs)?;
let total = iovecs.iter().try_fold(0_usize, |total, iovec| {
total.checked_add(iovec.iov_len).ok_or(Errno::EINVAL)
})?;
if total > isize::MAX as usize {
return Err(Errno::EINVAL);
}
Ok(iovecs
.into_iter()
.map(|iovec| TimerSlackIovec {
base: iovec.iov_base as usize,
len: iovec.iov_len,
})
.collect())
}
fn copy_timer_slack_output<M: MemoryAccess>(
memory: &mut M,
destination: Option<AddrMut<'_, u8>>,
bytes: &[u8],
) -> Result<usize, Errno> {
if bytes.is_empty() {
return Ok(0);
}
let copied = memory.write(destination.ok_or(Errno::EFAULT)?, bytes)?;
if copied == 0 {
Err(Errno::EFAULT)
} else {
Ok(copied)
}
}
fn copy_procfs_output<M: MemoryAccess>(
memory: &mut M,
destination: Option<AddrMut<'_, u8>>,
bytes: &[u8],
) -> Result<usize, Error> {
if bytes.is_empty() {
return Ok(0);
}
let destination = destination.ok_or(Errno::EFAULT)?;
let mut copied = 0;
while copied < bytes.len() {
let Some(address) = destination
.as_raw()
.checked_add(copied)
.and_then(AddrMut::<u8>::from_raw)
else {
break;
};
match memory.write_with_user_access(address, &bytes[copied..]) {
Ok(0) | Err(Errno::EFAULT) => break,
Ok(n) => copied += n,
Err(errno) => {
return Err(Error::Tool(anyhow::anyhow!(
"procfs read publication failed after {copied} bytes: {errno}"
)));
}
}
}
if copied == 0 {
Err(Errno::EFAULT.into())
} else {
Ok(copied)
}
}
fn can_read(status: i32) -> bool {
status & libc::O_PATH == 0 && matches!(status & libc::O_ACCMODE, libc::O_RDONLY | libc::O_RDWR)
}
fn copy_procfs_read<M: MemoryAccess>(
memory: &mut M,
destination: Option<AddrMut<'_, u8>>,
bytes: &[u8],
faults_on_a_short_copy: bool,
) -> Result<usize, Error> {
let copied = copy_procfs_output(memory, destination, bytes)?;
if faults_on_a_short_copy && copied < bytes.len() {
return Err(Errno::EFAULT.into());
}
Ok(copied)
}
fn validate_procfs_vector_flags(flags: i32, read_iter: bool) -> Result<(), Errno> {
if !read_iter {
return if flags & !libc::RWF_HIPRI != 0 {
Err(Errno::EOPNOTSUPP)
} else {
Ok(())
};
}
const RWF_NOSIGNAL: i32 = 0x100;
const KNOWN: i32 = libc::RWF_HIPRI
| libc::RWF_DSYNC
| libc::RWF_SYNC
| libc::RWF_NOWAIT
| libc::RWF_APPEND
| libc::RWF_NOAPPEND
| libc::RWF_ATOMIC
| libc::RWF_DONTCACHE
| RWF_NOSIGNAL;
if flags & !KNOWN != 0 {
return Err(Errno::EOPNOTSUPP);
}
if flags & libc::RWF_APPEND != 0 && flags & libc::RWF_NOAPPEND != 0 {
return Err(Errno::EINVAL);
}
if flags & (libc::RWF_NOWAIT | libc::RWF_ATOMIC | libc::RWF_DONTCACHE) != 0 {
return Err(Errno::EOPNOTSUPP);
}
Ok(())
}
fn validate_procfs_destination(
limit: impl FnOnce() -> Result<crate::iovecs::UserAddressLimit, Error>,
destination: Option<AddrMut<'_, u8>>,
len: usize,
) -> Result<(), Error> {
if isize::try_from(len).is_err() {
return Err(Errno::EFAULT.into());
}
limit()?.validate(&[
crate::iovecs::ImportedIovec {
base: destination.map_or(0, |address| address.as_raw()),
len,
},
crate::iovecs::ImportedIovec { base: 0, len: 0 },
])
}
fn save_procfs_scratch<M: MemoryAccess>(
memory: &mut M,
scratch: AddrMut<'_, u8>,
original: &mut [u8],
) -> bool {
read_guest_exact(memory, scratch, original).is_ok()
&& memory
.write_with_user_access(scratch, original)
.is_ok_and(|written| written == original.len())
}
pub(crate) fn read_guest_exact<M: MemoryAccess>(
memory: &M,
addr: AddrMut<'_, u8>,
buf: &mut [u8],
) -> Result<(), Errno> {
let len = buf.len();
let remote = unsafe { AddrSlice::from_raw_parts(addr.into(), len) };
let remote = [unsafe { remote.as_ioslice() }];
let mut local = [std::io::IoSliceMut::new(buf)];
match memory.read_vectored(&remote, &mut local) {
Ok(copied) if copied == len => Ok(()),
Ok(_) => Err(Errno::EFAULT),
Err(errno) => Err(errno),
}
}
pub(crate) const DETERMINISTIC_PIPE_CAPACITY_BYTES: i32 = 8 * 1024;
pub(crate) fn pipe_capacity_request_exceeds_ceiling(requested: i32) -> bool {
requested > DETERMINISTIC_PIPE_CAPACITY_BYTES
}
pub(crate) fn reported_pipe_capacity(host: i64) -> i64 {
host.min(i64::from(DETERMINISTIC_PIPE_CAPACITY_BYTES))
}
fn async_io_signals() -> u64 {
kernel_sigset_bit(libc::SIGIO) | kernel_sigset_bit(libc::SIGURG)
}
fn fcntl_host_timed_signals(cmd: syscalls::FcntlCmd<'_>) -> u64 {
match cmd {
F_SETFL(flags) if flags & libc::O_ASYNC != 0 => async_io_signals(),
F_SETOWN | F_SETOWN_EX(_) | F_SETLEASE(_) | F_NOTIFY(_) => async_io_signals(),
F_SETSIG(signal) => async_io_signals() | kernel_sigset_bit(signal),
_ => 0,
}
}
fn ioctl_host_timed_signals(request: syscalls::ioctl::Request<'_>) -> u64 {
match request {
syscalls::ioctl::Request::FIOASYNC(_)
| syscalls::ioctl::Request::FIOSETOWN(_)
| syscalls::ioctl::Request::SIOCSPGRP(_) => async_io_signals(),
syscalls::ioctl::Request::TIOCSCTTY(_) | syscalls::ioctl::Request::TIOCSPGRP(_) => {
terminal_signals()
}
syscalls::ioctl::Request::TIOCGPTPEER(flags)
if open_can_acquire_controlling_terminal(OFlag::from_bits_truncate(flags)) =>
{
terminal_signals()
}
_ => 0,
}
}
fn open_can_acquire_controlling_terminal(flags: OFlag) -> bool {
!flags.intersects(OFlag::O_NOCTTY | OFlag::O_PATH)
}
fn terminal_can_become_controlling(rdev: libc::dev_t, tty_drivers: Option<&str>) -> bool {
let (major, minor) = (libc::major(rdev), libc::minor(rdev));
if matches!((major, minor), (5, 1) | (5, 2) | (4, 0)) {
return false;
}
let Some(table) = tty_drivers else {
return true;
};
let mut unparsed = false;
for line in table.lines().filter(|line| !line.trim().is_empty()) {
let fields: Vec<&str> = line.split_whitespace().collect();
let range = match fields[..] {
[.., line_major, minors, kind] => {
line_major.parse::<u32>().ok().and_then(|line_major| {
let (first, last) = minors.split_once('-').unwrap_or((minors, minors));
Some((
line_major,
first.parse::<u32>().ok()?,
last.parse::<u32>().ok()?,
kind,
))
})
}
_ => None,
};
match range {
Some((line_major, first, last, kind))
if line_major == major && (first..=last).contains(&minor) =>
{
return kind != "pty:master";
}
Some(_) => {}
None => unparsed = true,
}
}
unparsed
}
fn may_have_acquired_controlling_terminal(
pid: i32,
session: i32,
rdev: libc::dev_t,
tty_drivers: Option<&str>,
) -> bool {
session == pid && terminal_can_become_controlling(rdev, tty_drivers)
}
fn opened_controlling_terminal(pid: i32, fd: RawFd, host_stat: Option<&libc::stat>) -> bool {
let rdev = match host_stat {
Some(stat) if stat.st_mode & libc::S_IFMT == libc::S_IFCHR => stat.st_rdev,
Some(_) => return false,
None => match std::fs::metadata(format!("/proc/{pid}/fd/{fd}")) {
Ok(metadata) if metadata.file_type().is_char_device() => metadata.rdev(),
Ok(_) => return false,
Err(_) => return true,
},
};
let session = match procfs::process::Process::new(pid).and_then(|process| process.stat()) {
Ok(stat) => stat.session,
Err(_) => return true,
};
let tty_drivers = std::fs::read_to_string("/proc/tty/drivers").ok();
may_have_acquired_controlling_terminal(pid, session, rdev, tty_drivers.as_deref())
}
#[derive(Debug, PartialEq, Eq)]
struct PipeCapacityFailure {
created_fds: [i32; 2],
error: Errno,
}
impl PipeCapacityFailure {
fn close_syscalls(&self) -> [syscalls::Close; 2] {
self.created_fds
.map(|fd| syscalls::Close::new().with_fd(fd))
}
}
fn pipe_capacity_failure(
created_fds: [i32; 2],
capacity_result: Result<i64, Errno>,
) -> Option<PipeCapacityFailure> {
let error = match capacity_result {
Ok(applied) if applied == i64::from(DETERMINISTIC_PIPE_CAPACITY_BYTES) => return None,
Ok(_) => Errno::EIO,
Err(error) => error,
};
Some(PipeCapacityFailure { created_fds, error })
}
fn should_tag_host_timed_internal_pipe_io(
internal_pipe_turns_are_host_timed: bool,
fd_type: FdType,
physically_nonblocking: bool,
logically_nonblocking: bool,
) -> bool {
internal_pipe_turns_are_host_timed
&& fd_type == FdType::Pipe
&& physically_nonblocking
&& !logically_nonblocking
}
fn random_device_lseek_result(status_flags: i32, whence: Whence) -> Result<i64, Errno> {
if status_flags & OFlag::O_PATH.bits() != 0 {
return Err(Errno::EBADF);
}
match whence {
Whence::SEEK_SET
| Whence::SEEK_CUR
| Whence::SEEK_END
| Whence::SEEK_DATA
| Whence::SEEK_HOLE => Ok(0),
_ => Err(Errno::EINVAL),
}
}
fn require_random_device_read_access(status_flags: i32) -> Result<(), Errno> {
if status_flags & libc::O_PATH != 0
|| !matches!(
status_flags & libc::O_ACCMODE,
libc::O_RDONLY | libc::O_RDWR
)
{
Err(Errno::EBADF)
} else {
Ok(())
}
}
fn is_inherited_container_output(resource: Option<ResourceID>) -> bool {
matches!(
resource,
Some(ResourceID::Device(
Device::ContainerStdout | Device::ContainerStderr
))
)
}
fn unix_autobind_addrlen() -> i32 {
(std::mem::offset_of!(libc::sockaddr_un, sun_path) + UNIX_AUTOBIND_NAME_LEN) as i32
}
fn unix_autobind_address(port: u16) -> libc::sockaddr_un {
let mut address: libc::sockaddr_un = unsafe { std::mem::zeroed() };
address.sun_family = libc::AF_UNIX as libc::sa_family_t;
for (destination, source) in address.sun_path[1..UNIX_AUTOBIND_NAME_LEN]
.iter_mut()
.zip(format!("{port:05x}").bytes())
{
*destination = source as libc::c_char;
}
address
}
fn canonicalize_tcp_info(info: &mut [u8]) {
for (offset, byte) in info.iter_mut().enumerate() {
if !matches!(offset, 0 | 1 | 5 | 6) {
*byte = 0;
}
}
}
const DETERMINISTIC_NETNS_COOKIE: u64 = 1;
const DETERMINISTIC_NETLINK_PORT_ID_BASE: u32 = 0x4000_0000;
fn reopens_scheduler_managed_pipe(
backend: &reverie::BackendCapabilities,
pid: i32,
fd: RawFd,
managed_pipe_fds: &[RawFd],
) -> bool {
if !crate::procfs_inode::tool_can_name_guest_descriptors(backend) {
return false;
}
let link = |fd: RawFd| std::fs::read_link(format!("/proc/{pid}/fd/{fd}")).ok();
let Some(opened) = link(fd) else {
return false;
};
if !opened
.to_str()
.is_some_and(|name| name.starts_with("pipe:["))
{
return false;
}
managed_pipe_fds
.iter()
.any(|&held| held != fd && link(held).as_ref() == Some(&opened))
}
fn resolved_open_path(
backend: &reverie::BackendCapabilities,
pid: i32,
fd: RawFd,
) -> Option<PathBuf> {
if !crate::procfs_inode::tool_can_name_guest_descriptors(backend) {
return None;
}
let link = std::fs::read_link(format!("/proc/{pid}/fd/{fd}")).ok()?;
link.is_absolute().then_some(link)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum PidfdSignalScope {
Process,
Thread,
ProcessGroup,
}
const PIDFD_SIGNAL_THREAD: u32 = 1 << 0;
const PIDFD_SIGNAL_THREAD_GROUP: u32 = 1 << 1;
const PIDFD_SIGNAL_PROCESS_GROUP: u32 = 1 << 2;
pub(crate) fn pidfd_signal_scope(flags: u32) -> Result<PidfdSignalScope, Errno> {
match flags {
0 | PIDFD_SIGNAL_THREAD_GROUP => Ok(PidfdSignalScope::Process),
PIDFD_SIGNAL_THREAD => Ok(PidfdSignalScope::Thread),
PIDFD_SIGNAL_PROCESS_GROUP => Ok(PidfdSignalScope::ProcessGroup),
_ => Err(Errno::EINVAL),
}
}
const PIDFD_SELF_THREAD: RawFd = -10000;
const PIDFD_SELF_THREAD_GROUP: RawFd = -10001;
fn pidfd_self_target<T, G: Guest<Detcore<T>>>(
guest: &mut G,
pidfd: RawFd,
) -> Option<(DetPid, PidfdSignalScope)>
where
T: RecordOrReplay,
{
let state = guest.thread_state();
match pidfd {
PIDFD_SELF_THREAD => Some((
DetPid::from_raw(state.dettid.as_raw()),
PidfdSignalScope::Thread,
)),
PIDFD_SELF_THREAD_GROUP => Some((state.detpid?, PidfdSignalScope::Process)),
_ => None,
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum ProcessDirectoryDescriptor {
Process(DetPid),
NotAProcess,
Unknown(&'static str),
}
#[derive(Clone, Debug, Default)]
pub(crate) struct DescriptorFacts {
pub(crate) link: PathBuf,
pub(crate) on_procfs: bool,
pub(crate) is_dir: bool,
pub(crate) dev: u64,
pub(crate) parent: Option<(u64, u64)>,
pub(crate) guest_proc_dev: Option<u64>,
}
const PROC_ROOT_INO: u64 = 1;
pub(crate) fn classify_process_directory(
facts: Option<&DescriptorFacts>,
) -> ProcessDirectoryDescriptor {
use ProcessDirectoryDescriptor as D;
let Some(facts) = facts else {
return D::Unknown("Hermit cannot read what the descriptor names");
};
let link = facts.link.to_string_lossy();
if link == "anon_inode:[pidfd]" || link.starts_with("pidfd:") {
return D::Unknown("it is a pidfd that Detcore did not open with pidfd_open");
}
if !facts.on_procfs {
return D::NotAProcess;
}
if !facts.is_dir {
return D::NotAProcess;
}
let name = facts
.link
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_default();
let name = match name.strip_suffix(" (deleted)") {
Some(name) if facts.parent.is_none() => {
if facts.link.parent() != Some(Path::new("/proc")) {
return if facts.link.starts_with("/proc/") {
D::NotAProcess
} else {
D::Unknown("it names a reaped task outside the guest's /proc")
};
}
name.to_owned()
}
_ if facts.parent != Some((facts.dev, PROC_ROOT_INO)) => return D::NotAProcess,
_ => name,
};
let Ok(pid) = name.parse::<i32>() else {
return D::NotAProcess;
};
if pid <= 0 || name.starts_with(['+', '0']) {
return D::NotAProcess;
}
if facts.guest_proc_dev != Some(facts.dev) {
return D::Unknown("it is a procfs that is not the guest's /proc");
}
D::Process(DetPid::from_raw(pid))
}
fn process_directory_descriptor(tid: i32, fd: RawFd) -> ProcessDirectoryDescriptor {
let facts = (|| {
let (link, on_procfs) = descriptor_identity(tid, fd)?;
let target = std::fs::metadata(format!("/proc/{tid}/fd/{fd}")).ok()?;
let parent = std::fs::metadata(format!("/proc/{tid}/fd/{fd}/.."))
.ok()
.map(|parent| (parent.dev(), parent.ino()));
let guest_proc_dev = std::fs::metadata(format!("/proc/{tid}/root/proc"))
.ok()
.filter(|proc| proc.ino() == PROC_ROOT_INO)
.map(|proc| proc.dev());
Some(DescriptorFacts {
link,
on_procfs,
is_dir: target.is_dir(),
dev: target.dev(),
parent: if target.is_dir() { parent } else { None },
guest_proc_dev,
})
})();
classify_process_directory(facts.as_ref())
}
fn default_huge_page_size() -> u64 {
static SIZE: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
*SIZE.get_or_init(|| {
std::fs::read_to_string("/proc/meminfo")
.ok()
.and_then(|meminfo| {
let line = meminfo
.lines()
.find(|line| line.starts_with("Hugepagesize:"))?;
let kib: u64 = line.split_whitespace().nth(1)?.parse().ok()?;
kib.checked_mul(1024)
})
.unwrap_or(2 << 20)
})
}
fn descriptor_identity(tid: i32, fd: RawFd) -> Option<(PathBuf, bool)> {
let path = format!("/proc/{tid}/fd/{fd}");
let link = std::fs::read_link(&path).ok()?;
let path = std::ffi::CString::new(path).ok()?;
let mut buf = std::mem::MaybeUninit::<libc::statfs>::uninit();
if unsafe { libc::statfs(path.as_ptr(), buf.as_mut_ptr()) } != 0 {
return None;
}
let on_procfs = unsafe { buf.assume_init() }.f_type == libc::PROC_SUPER_MAGIC;
Some((link, on_procfs))
}
fn resolved_at_fdcwd_path(pid: i32, path: &Path) -> Option<PathBuf> {
debug_assert!(!path.is_absolute());
let root = std::fs::read_link(format!("/proc/{pid}/root")).ok()?;
let cwd = std::fs::read_link(format!("/proc/{pid}/cwd")).ok()?;
let guest_cwd = cwd.strip_prefix(root).ok()?;
Some(Path::new("/").join(guest_cwd).join(path))
}
fn retires_on_removal(stat: &libc::stat) -> bool {
stat.st_mode & libc::S_IFMT == libc::S_IFDIR || stat.st_nlink == 1
}
fn rebound_path(observed: Option<PathBuf>) -> String {
match observed {
Some(path) if path.is_absolute() => path.to_string_lossy().into_owned(),
_ => String::from("/"),
}
}
pub(crate) fn may_change_untraced_code(
number: Sysno,
args: &syscalls::SyscallArgs,
(start, end): (u64, u64),
default_huge_page: u64,
) -> bool {
let [arg0, arg1, arg2, arg3, arg4] =
[args.arg0, args.arg1, args.arg2, args.arg3, args.arg4].map(|arg| arg as u64);
let overlaps = |addr: u64, len: u64| addr < end && addr.saturating_add(len.max(1)) > start;
let overlaps_huge = |addr: u64, len: u64, page: u64| {
let page = page.max(1);
let first = addr - addr % page;
let last = addr
.saturating_add(len.max(1))
.div_ceil(page)
.saturating_mul(page);
overlaps(first, last.saturating_sub(first).max(1))
};
let huge_page = |flags: u64| match (flags >> libc::MAP_HUGE_SHIFT) & libc::MAP_HUGE_MASK as u64
{
0 => default_huge_page,
shift => 1u64.checked_shl(shift as u32).unwrap_or(u64::MAX),
};
match number {
Sysno::mmap if arg3 & libc::MAP_FIXED as u64 == 0 => false,
Sysno::mmap if arg3 & libc::MAP_HUGETLB as u64 != 0 => {
overlaps_huge(arg0, arg1, huge_page(arg3))
}
Sysno::mmap => overlaps(arg0, arg1),
Sysno::mprotect | Sysno::pkey_mprotect | Sysno::madvise | Sysno::munmap => {
overlaps(arg0, arg1)
}
Sysno::mremap => {
overlaps(arg0, arg1) || (arg3 & libc::MREMAP_FIXED as u64 != 0 && overlaps(arg4, arg2))
}
Sysno::shmat => arg1 != 0 && arg2 & libc::SHM_REMAP as u64 != 0 && overlaps(arg1, u64::MAX),
_ => false,
}
}
pub(crate) fn may_write_process_memory(flags: OFlag, descriptor: Option<(&Path, bool)>) -> bool {
let writes = !flags.contains(OFlag::O_PATH) && flags & OFlag::O_ACCMODE != OFlag::O_RDONLY;
writes
&& descriptor.is_none_or(|(link, on_procfs)| {
on_procfs && link.file_name() == Some(std::ffi::OsStr::new("mem"))
})
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum LockCall {
Fcntl,
Flock,
PidfdGetfd,
Recvmsg,
}
impl LockCall {
fn name(self) -> &'static str {
match self {
Self::Fcntl => "fcntl",
Self::Flock => "flock",
Self::PidfdGetfd => "pidfd_getfd",
Self::Recvmsg => "recvmsg",
}
}
fn changes_locks(self) -> bool {
matches!(self, Self::Fcntl | Self::Flock)
}
}
fn fdinfo_inode(fdinfo: &[u8]) -> Option<String> {
String::from_utf8_lossy(fdinfo)
.lines()
.find_map(|line| line.strip_prefix("ino:"))
.map(|inode| inode.trim().to_string())
.filter(|inode| !inode.is_empty() && inode.bytes().all(|byte| byte.is_ascii_digit()))
}
const FDINFO_PAGE: usize = 4096;
const FDINFO_PATH: usize = 0;
const FDINFO_HOW: usize = 64;
const FDINFO_HOW_SIZE: usize = 24;
const FDINFO_STAT: usize = 128;
const FDINFO_READ: usize = 512;
const _: () = assert!(FDINFO_HOW + FDINFO_HOW_SIZE <= FDINFO_STAT);
const _: () = assert!(FDINFO_STAT + std::mem::size_of::<libc::stat>() <= FDINFO_READ);
const _: () = assert!(FDINFO_STAT + std::mem::size_of::<libc::statfs>() <= FDINFO_READ);
const FDINFO_RESOLVE: u64 = libc::RESOLVE_NO_XDEV | libc::RESOLVE_BENEATH;
pub(crate) enum FdinfoRead {
Contents(Vec<u8>),
Unknown(String),
Untrackable(String),
}
impl FdinfoRead {
fn inode(&self) -> Option<String> {
match self {
Self::Contents(contents) => fdinfo_inode(contents),
Self::Unknown(_) | Self::Untrackable(_) => None,
}
}
}
enum FdinfoFailure {
Failed(&'static str, Errno),
NotProcfs(&'static str),
}
fn fdinfo_failure_hides(errno: Errno) -> bool {
matches!(
errno,
Errno::ENOENT | Errno::ENOTDIR | Errno::ELOOP | Errno::EXDEV | Errno::EINVAL
)
}
fn fdinfo_refusal(call: &str, fd: RawFd, step: &str, errno: Errno) -> String {
format!(
"after {call} on fd {fd}, Detcore could not {step} that descriptor's fdinfo \
({errno}), so it does not know which locks the description holds"
)
}
#[cfg(test)]
mod fdinfo_refusal_tests {
use super::*;
#[test]
fn a_failed_fdinfo_read_is_a_named_refusal_not_an_empty_one() {
let reason = fdinfo_refusal("recvmsg", 7, "open", Errno::EMFILE);
assert!(reason.contains("after recvmsg on fd 7"), "{reason}");
assert!(
reason.contains("could not open that descriptor's fdinfo"),
"{reason}"
);
assert!(reason.contains("EMFILE"), "{reason}");
assert!(fdinfo_refusal("flock", 7, "read", Errno::EIO).contains("could not read that"));
}
#[test]
fn only_a_guest_or_backend_decided_failure_hides_the_description() {
for errno in [
Errno::ENOENT,
Errno::ENOTDIR,
Errno::ELOOP,
Errno::EXDEV,
Errno::EINVAL,
] {
assert!(fdinfo_failure_hides(errno), "{errno}");
}
for errno in [
Errno::EACCES,
Errno::EPERM,
Errno::EMFILE,
Errno::ENFILE,
Errno::ENOMEM,
Errno::EINTR,
Errno::EIO,
Errno::EAGAIN,
Errno::ENOSYS,
Errno::EBADF,
] {
assert!(!fdinfo_failure_hides(errno), "{errno}");
}
}
#[test]
fn an_fdinfo_names_its_inode_as_proc_locks_prints_it() {
let fdinfo = b"pos:\t0\nflags:\t0100002\nmnt_id:\t31\nino:\t1234\n\
lock:\t1: OFDLCK ADVISORY READ -1 00:18:1234 0 0\n";
assert_eq!(fdinfo_inode(fdinfo).as_deref(), Some("1234"));
assert_eq!(fdinfo_inode(b"pos:\t0\n"), None);
assert_eq!(fdinfo_inode(b"ino:\tx\n"), None);
}
}
fn restore_lookup_buffer<M: MemoryAccess>(memory: &mut M, buffer: StatPtr, saved: &[u8]) {
if memory.write_exact(buffer.0.cast(), saved).is_err() {
info!("Could not restore the guest bytes under a pre-call lookup buffer.");
}
}
fn path_overlaps_buffer<M: MemoryAccess>(
memory: &M,
path: Option<syscalls::PathPtr<'_>>,
buffer: StatPtr,
) -> bool {
path_overlaps_bytes(
memory,
path,
buffer.0.as_raw(),
std::mem::size_of::<libc::stat>(),
)
}
fn path_overlaps_bytes<M: MemoryAccess>(
memory: &M,
path: Option<syscalls::PathPtr<'_>>,
start: usize,
len: usize,
) -> bool {
use reverie::syscalls::FromToRaw;
let end = start.saturating_add(len);
path.is_some_and(|ptr| match ptr.read(memory) {
Ok(read) => {
let addr = Some(ptr).into_raw();
let read: PathBuf = read;
addr < end && start < addr.saturating_add(read.as_os_str().len() + 1)
}
Err(_) => true,
})
}
fn utimensat_input_overlaps<M: MemoryAccess>(
memory: &M,
call: &syscalls::Utimensat,
guest_times: bool,
buffer: StatPtr,
) -> bool {
let start = buffer.0.as_raw();
let end = start + std::mem::size_of::<libc::stat>();
let overlaps = |addr: usize, len: usize| addr < end && start < addr.saturating_add(len);
let path = path_overlaps_buffer(memory, call.path(), buffer);
let times = guest_times
&& call
.times()
.is_some_and(|times| overlaps(times.as_raw(), std::mem::size_of::<[Timespec; 2]>()));
path || times
}
fn names_no_path<M: MemoryAccess>(memory: &M, path: Option<PathPtr>, flags: AtFlags) -> bool {
flags.contains(AtFlags::AT_EMPTY_PATH)
&& match path {
None => true,
Some(path) => path
.read(memory)
.is_ok_and(|path| path.as_os_str().is_empty()),
}
}
fn stdio_inode_override<T: RecordOrReplay, G: Guest<Detcore<T>>>(
guest: &G,
fd: i32,
) -> Option<DetInode> {
guest
.thread_state()
.with_detfd(fd, |detfd| {
deterministic_stdio_inode_for_resource(fd, detfd.resource())
})
.ok()
.flatten()
}
#[derive(Clone, Copy)]
enum StatTarget<'a> {
Descriptor(RawFd),
Cwd,
Path {
dirfd: i32,
path: Option<PathPtr<'a>>,
follow: bool,
},
Overwritten,
}
impl<'a> StatTarget<'a> {
fn at<M: MemoryAccess>(
memory: &M,
dirfd: i32,
path: Option<PathPtr<'a>>,
flags: AtFlags,
) -> Self {
if names_no_path(memory, path, flags) {
if dirfd == libc::AT_FDCWD {
return StatTarget::Cwd;
}
if dirfd >= 0 {
return StatTarget::Descriptor(dirfd);
}
}
StatTarget::Path {
dirfd,
path,
follow: !flags.contains(AtFlags::AT_SYMLINK_NOFOLLOW),
}
}
fn unless_overwritten<M: MemoryAccess>(self, memory: &M, result: usize, len: usize) -> Self {
match self {
StatTarget::Path { path, .. } if path_overlaps_bytes(memory, path, result, len) => {
StatTarget::Overwritten
}
target => target,
}
}
fn descriptor(&self) -> Option<RawFd> {
match self {
StatTarget::Descriptor(fd) => Some(*fd),
StatTarget::Cwd | StatTarget::Path { .. } | StatTarget::Overwritten => None,
}
}
}
fn rendered_entry(
procfs: &ProcfsEntry,
stat: &DetStat,
cfg: &crate::config::Config,
files: crate::procfs::RenderedFiles,
) -> Option<&'static Path> {
if cfg.recordreplay_modes {
return None;
}
let found = match procfs {
ProcfsEntry::At(within) => rendered_procfs::rendered_path_within(within, files),
ProcfsEntry::NotProcfs | ProcfsEntry::Unknown => {
rendered_procfs::rendered_path_of_raw(stat, files)
}
ProcfsEntry::Unnamed => None,
};
found.filter(|path| !crate::procfs::rendered_path_is_per_process(path))
}
const STATX_MNT_ID_UNIQUE: u32 = 0x4000;
const MNT_UNIQUE_ID_OFFSET: u64 = 1 << 31;
fn statx_requested_mask(call: syscalls::Statx) -> u32 {
syscalls::SyscallArgs::from(call).arg3 as u32
}
fn statx_asking_classic_mount_id(call: syscalls::Statx) -> syscalls::Statx {
let mut args = syscalls::SyscallArgs::from(call);
let mask = args.arg3 as u32;
if mask & STATX_MNT_ID_UNIQUE != 0 {
args.arg3 = ((mask & !STATX_MNT_ID_UNIQUE) | libc::STATX_MNT_ID) as usize;
}
syscalls::Statx::from(args)
}
fn statx_arguments_valid(flags: i32, mask: u32, names_no_path: bool) -> bool {
let known = libc::AT_SYMLINK_NOFOLLOW
| libc::AT_EMPTY_PATH
| libc::AT_NO_AUTOMOUNT
| libc::AT_STATX_SYNC_TYPE;
mask & 0x8000_0000 == 0
&& (names_no_path || flags & !known == 0)
&& flags & libc::AT_STATX_SYNC_TYPE != libc::AT_STATX_SYNC_TYPE
}
fn names_descriptor_link(path: &Path) -> bool {
let parts = path
.components()
.filter_map(|component| match component {
std::path::Component::Normal(part) => {
Some(std::os::unix::ffi::OsStrExt::as_bytes(part))
}
_ => None,
})
.collect::<Vec<_>>();
let number = |part: &[u8]| !part.is_empty() && part.iter().all(u8::is_ascii_digit);
match parts.as_slice() {
[b"dev", b"fd", fd] | [b"proc", _, b"fd", fd] | [b"proc", _, b"task", _, b"fd", fd] => {
number(fd)
}
_ => false,
}
}
#[derive(Debug, Clone, Copy)]
struct DescriptorLinkOpener {
own: Option<(i32, i32)>,
holds_process_table: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct LinkSource {
fd: RawFd,
path: Option<PathBuf>,
open_file: OpenFileId,
reached: Option<(PathBuf, Option<crate::procfs::TaskIncarnation>)>,
}
impl LinkSource {
fn path_if_unchanged(&self, fd: RawFd, current: Option<OpenFileId>) -> Option<PathBuf> {
(fd == self.fd && current == Some(self.open_file))
.then(|| self.path.clone())
.flatten()
}
fn reached_if_unchanged(
&self,
fd: RawFd,
current: Option<OpenFileId>,
) -> Option<(PathBuf, Option<crate::procfs::TaskIncarnation>)> {
(fd == self.fd && current == Some(self.open_file))
.then(|| self.reached.clone())
.flatten()
}
}
fn procfs_selector_reached(recorded: &Path, own: Option<(i32, i32)>) -> Option<PathBuf> {
let (pid, tid) = own?;
let below = recorded.strip_prefix("/proc").ok()?;
let names = below
.components()
.map(|component| match component {
std::path::Component::Normal(name) => name.to_str(),
_ => None,
})
.collect::<Option<Vec<_>>>()?;
let number = |name: &str| {
(!name.starts_with('0') && !name.is_empty() && name.bytes().all(|b| b.is_ascii_digit()))
.then(|| name.parse::<i32>().ok())
.flatten()
};
Some(PathBuf::from(match names.as_slice() {
["self"] => format!("/proc/{pid}"),
["self", "task"] => format!("/proc/{pid}/task"),
["self", "task", thread] => format!("/proc/{pid}/task/{}", number(thread)?),
["thread-self"] => format!("/proc/{pid}/task/{tid}"),
[process] => format!("/proc/{}", number(process)?),
[process, "task"] => format!("/proc/{}/task", number(process)?),
[process, "task", thread] => {
format!("/proc/{}/task/{}", number(process)?, number(thread)?)
}
_ => return None,
}))
}
fn procfs_reached_task(reached: &Path) -> Option<crate::procfs::BoundTask> {
let names = reached
.strip_prefix("/proc")
.ok()?
.components()
.map(|component| component.as_os_str().to_str())
.collect::<Option<Vec<_>>>()?;
let number = |name: &str| name.parse::<i32>().ok().filter(|number| *number > 0);
let process = number(names.first()?)?;
let thread = match names.as_slice() {
[_, "task", thread, ..] => Some(number(thread)?),
_ => None,
};
Some(crate::procfs::BoundTask { process, thread })
}
fn names_a_selector_link(spelling: &Path) -> bool {
spelling.parent() == Some(Path::new("/proc"))
&& spelling
.file_name()
.is_some_and(|name| name == "self" || name == "thread-self")
}
fn opens_the_link_itself(observed: &Path, flags: OFlag) -> bool {
let bytes = std::os::unix::ffi::OsStrExt::as_bytes(observed.as_os_str());
flags.contains(OFlag::O_NOFOLLOW) && !(bytes.ends_with(b"/") || bytes.ends_with(b"/."))
}
fn path_to_record_for_open(
observed: &Path,
flags: OFlag,
opener: DescriptorLinkOpener,
recorded: impl FnOnce(RawFd) -> Option<PathBuf>,
identity: Option<PathBuf>,
) -> PathBuf {
use crate::syscalls::namespace::DescriptorTable;
if opens_the_link_itself(observed, flags) {
return observed.to_path_buf();
}
let Some(link) = crate::syscalls::namespace::own_descriptor_link(observed, opener.own) else {
return observed.to_path_buf();
};
if !(link.table == DescriptorTable::Thread || opener.holds_process_table) {
return observed.to_path_buf();
}
match recorded(link.fd) {
Some(path) => {
(!crate::syscalls::namespace::names_through_caller_selector(&path)).then_some(path)
}
None => identity,
}
.unwrap_or_else(|| observed.to_path_buf())
}
fn procfs_directory_task_positions(link: &str) -> Option<(Vec<String>, Vec<usize>)> {
if link.ends_with(" (deleted)") {
return None;
}
let below = link.strip_prefix("/proc")?;
if !(below.is_empty() || below.starts_with('/')) {
return None;
}
let names = below
.split('/')
.filter(|name| !name.is_empty())
.map(str::to_owned)
.collect::<Vec<_>>();
if names.iter().any(|name| name == "." || name == "..") {
return None;
}
let number = |name: &str| {
!name.is_empty() && !name.starts_with('0') && name.bytes().all(|byte| byte.is_ascii_digit())
};
let mut positions = Vec::new();
if let Some(first) = names.first()
&& first.bytes().all(|byte| byte.is_ascii_digit())
{
if !number(first) {
return None;
}
positions.push(0);
if names.get(1).map(String::as_str) == Some("task")
&& let Some(thread) = names.get(2)
{
if !number(thread) {
return None;
}
positions.push(2);
}
}
Some((names, positions))
}
fn procfs_directory_link(link: &Path) -> bool {
use std::os::unix::ffi::OsStrExt;
let bytes = link.as_os_str().as_bytes();
link.starts_with("/proc")
&& !bytes.ends_with(b" (deleted)")
&& link.components().all(|component| match component {
std::path::Component::RootDir => true,
std::path::Component::Normal(name) => !name.as_bytes().iter().all(u8::is_ascii_digit),
_ => false,
})
&& crate::procfs::ids::named_ids(link).is_empty()
&& !crate::syscalls::namespace::names_through_caller_selector(link)
}
fn stat_family_arguments_valid<M: MemoryAccess>(memory: &M, call: &StatFamily) -> bool {
match call {
StatFamily::Fstatat(call) => {
let known = libc::AT_SYMLINK_NOFOLLOW
| libc::AT_NO_AUTOMOUNT
| libc::AT_EMPTY_PATH
| libc::AT_STATX_SYNC_TYPE;
names_no_path(memory, call.path(), call.flags()) || call.flags().bits() & !known == 0
}
_ => true,
}
}
fn stat_family_target<'a, M: MemoryAccess>(memory: &M, call: &'a StatFamily) -> StatTarget<'a> {
match call {
StatFamily::Fstat(call) => StatTarget::Descriptor(call.fd()),
StatFamily::Fstatat(call) => {
StatTarget::at(memory, call.dirfd(), call.path(), call.flags())
}
#[cfg(not(target_arch = "aarch64"))]
StatFamily::Stat(call) => StatTarget::Path {
dirfd: libc::AT_FDCWD,
path: call.path(),
follow: true,
},
#[cfg(not(target_arch = "aarch64"))]
StatFamily::Lstat(call) => StatTarget::Path {
dirfd: libc::AT_FDCWD,
path: call.path(),
follow: false,
},
}
}
const OBJECT_DESCRIPTOR_ATTEMPTS: usize = 8;
#[derive(Debug, Clone, PartialEq, Eq)]
enum ProcfsEntry {
NotProcfs,
At(PathBuf),
Unnamed,
Unknown,
}
impl ProcfsEntry {
fn is_procfs(&self) -> bool {
matches!(self, ProcfsEntry::At(_) | ProcfsEntry::Unnamed)
}
fn name(&self, device: u64) -> Option<ProcfsName> {
match self {
ProcfsEntry::At(within) => Some(ProcfsName::new(device, within)),
ProcfsEntry::NotProcfs | ProcfsEntry::Unnamed | ProcfsEntry::Unknown => None,
}
}
}
impl<T: RecordOrReplay> Detcore<T> {
async fn observe_timer_slack_identity<G: Guest<Self>>(
&self,
guest: &mut G,
target: i32,
) -> Result<Option<(u64, u64)>, Error> {
let Some(target) = Self::kernel_procfs_number(guest, target).await else {
return Ok(None);
};
let path = format!("/proc/{target}/timerslack_ns");
let path_bytes = path.as_bytes();
let mut path_buffer = [0_u8; 64];
assert!(path_bytes.len() < path_buffer.len());
path_buffer[..path_bytes.len()].copy_from_slice(path_bytes);
let mut stack = guest.stack().await;
let path_address = stack.push(path_buffer).cast::<libc::c_char>();
let statptr = StatPtr(stack.reserve());
let stack_guard = stack.commit()?;
let call = syscalls::Fstatat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(PathPtr::from_ptr(
path_address.as_raw() as *const libc::c_char
))
.with_stat(Some(statptr))
.with_flags(AtFlags::empty());
let mut identity = match guest.inject_with_retry(call).await {
Ok(_) => {
let stat = statptr.read(&guest.memory())?;
Some((stat.st_dev, stat.st_ino))
}
Err(Errno::ENOENT) | Err(Errno::ESRCH) => None,
Err(error) => return Err(error.into()),
};
drop(stack_guard);
if identity.is_none()
&& guest.config().recordreplay_modes
&& let Ok(metadata) = std::fs::metadata(path)
{
identity = Some((metadata.dev(), metadata.ino()));
}
Ok(identity)
}
async fn require_current_timer_slack_target<G: Guest<Self>>(
&self,
guest: &mut G,
binding: TimerSlackBinding,
) -> Result<(), Error> {
let observed_identity = self
.observe_timer_slack_identity(guest, binding.target)
.await?;
let current = guest.inject(syscalls::Gettid::new()).await? as i32;
classify_timer_slack_binding(binding, observed_identity, current).map_err(Into::into)
}
fn timer_slack_binding<G: Guest<Self>>(
&self,
guest: &G,
fd: RawFd,
) -> Result<Option<TimerSlackBinding>, Errno> {
guest.thread_state().with_detfd(fd, |detfd| {
detfd
.procfs_timer_slack_binding()
.map(|(target, device, inode)| TimerSlackBinding {
target,
device,
inode,
})
})
}
fn require_timer_slack_access<G: Guest<Self>>(
&self,
guest: &G,
fd: RawFd,
write: bool,
) -> Result<(), Errno> {
guest.thread_state().with_detfd(fd, |detfd| {
let flags = detfd.status_flags();
let mode = flags & libc::O_ACCMODE;
let denied = flags & libc::O_PATH != 0
|| if write {
mode == libc::O_RDONLY
} else {
mode == libc::O_WRONLY
};
(!denied).then_some(()).ok_or(Errno::EBADF)
})?
}
fn read_timer_slack_input<G: Guest<Self>>(
&self,
guest: &G,
buffer: Option<Addr<u8>>,
count: usize,
) -> Result<u64, Errno> {
let mut bytes = vec![0_u8; count.min(TIMER_SLACK_PARSE_BYTES)];
if !bytes.is_empty() {
guest
.memory()
.read_exact(buffer.ok_or(Errno::EFAULT)?, &mut bytes)?;
}
parse_timer_slack_write(&bytes)
}
async fn read_timer_slack<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
buffer: Option<AddrMut<'_, u8>>,
maximum: usize,
) -> Result<i64, Error> {
self.require_timer_slack_access(guest, fd, false)?;
if maximum == 0 {
return Ok(0);
}
let binding = self
.timer_slack_binding(guest, fd)?
.expect("timer-slack read lost its procfs classification");
self.require_current_timer_slack_target(guest, binding)
.await?;
let value = guest.thread_state().timer_slack_ns;
let preview = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.preview_procfs_timer_slack(value, maximum))?
.expect("timer-slack procfs state disappeared");
let copied = copy_timer_slack_output(&mut guest.memory(), buffer, &preview.bytes)?;
if copied != 0 {
guest.thread_state().with_detfd(fd, |detfd| {
detfd.commit_procfs_timer_slack_read(&preview, copied);
})?;
}
Ok(copied as i64)
}
async fn pread_timer_slack<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
buffer: Option<AddrMut<'_, u8>>,
maximum: usize,
offset: i64,
) -> Result<i64, Error> {
if offset < 0 {
return Err(Errno::EINVAL.into());
}
self.require_timer_slack_access(guest, fd, false)?;
if maximum == 0 {
return Ok(0);
}
let binding = self
.timer_slack_binding(guest, fd)?
.expect("timer-slack pread lost its procfs classification");
self.require_current_timer_slack_target(guest, binding)
.await?;
let value = guest.thread_state().timer_slack_ns;
let bytes = guest
.thread_state()
.with_detfd(fd, |detfd| {
detfd.take_procfs_timer_slack_at(value, offset as usize, maximum)
})?
.expect("timer-slack procfs state disappeared");
Ok(copy_timer_slack_output(&mut guest.memory(), buffer, &bytes)? as i64)
}
async fn readv_rendered_procfs<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
address: usize,
count: usize,
offset: Option<i64>,
flags: i32,
) -> Result<i64, Error> {
let status = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.status_flags())?;
if !can_read(status) {
return Err(Errno::EBADF.into());
}
let iovecs = crate::iovecs::import_read_iovecs(&guest.memory(), address, count, || {
crate::iovecs::UserAddressLimit::from_query(guest.user_address_limit())
})?;
let maximum = iovecs.iter().map(|iovec| iovec.len).sum::<usize>();
if maximum == 0 {
return Ok(0);
}
if let Some(offset) = offset
&& offset.checked_add(maximum as i64).is_none()
{
return Err(Errno::EINVAL.into());
}
let read_iter = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_has_read_iter())?;
validate_procfs_vector_flags(flags, read_iter)?;
if guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_needs_snapshot())?
{
self.initialize_procfs_snapshot(guest, syscalls::Read::new().with_fd(fd))
.await?;
} else if let Some(offset) = offset
&& guest.thread_state().with_detfd(fd, |detfd| {
detfd
.procfs_position()
.is_some_and(|(position, _)| position as i64 != offset)
})?
{
self.require_rendered_task(guest, fd).await?;
}
let start = match offset {
Some(offset) => offset as usize,
None => {
self.adopt_rendered_procfs_position(guest, fd).await?;
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_position())?
.map_or(0, |(offset, _)| offset)
}
};
let (bytes, faults_on_a_short_copy) = guest.thread_state().with_detfd(fd, |detfd| {
(
detfd.take_procfs_at(start, maximum).unwrap_or_default(),
detfd.procfs_faults_on_a_short_copy(),
)
})?;
let mut copied = 0;
for iovec in iovecs {
if copied == bytes.len() {
break;
}
if iovec.len == 0 {
continue;
}
let end = (copied + iovec.len).min(bytes.len());
let written = match copy_procfs_output(
&mut guest.memory(),
AddrMut::from_raw(iovec.base),
&bytes[copied..end],
) {
Ok(written) => written,
Err(Error::Errno(Errno::EFAULT)) => 0,
Err(error) => return Err(error),
};
copied += written;
if copied < end {
break;
}
}
if copied < bytes.len() && (faults_on_a_short_copy || copied == 0) {
return Err(Errno::EFAULT.into());
}
if offset.is_none() {
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.commit_procfs_read(start, copied))?;
self.sync_rendered_procfs_position(guest, fd).await?;
}
Ok(copied as i64)
}
async fn readv_timer_slack<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
iovecs: Vec<TimerSlackIovec>,
offset: Option<i64>,
flags: i32,
) -> Result<i64, Error> {
self.require_timer_slack_access(guest, fd, false)?;
let maximum = iovecs.iter().map(|iovec| iovec.len).sum::<usize>();
if maximum == 0 {
return Ok(0);
}
if flags & !libc::RWF_HIPRI != 0 {
return Err(Errno::EOPNOTSUPP.into());
}
let binding = self
.timer_slack_binding(guest, fd)?
.expect("timer-slack readv lost its procfs classification");
self.require_current_timer_slack_target(guest, binding)
.await?;
let value = guest.thread_state().timer_slack_ns;
let mut positioned_offset = offset.map(|offset| offset as usize);
let mut total = 0_usize;
for iovec in iovecs {
if iovec.len == 0 {
continue;
}
let sequential_preview = if positioned_offset.is_none() {
guest.thread_state().with_detfd(fd, |detfd| {
detfd.preview_procfs_timer_slack(value, iovec.len)
})?
} else {
None
};
let bytes = match (&sequential_preview, positioned_offset) {
(Some(preview), None) => preview.bytes.clone(),
(None, Some(offset)) => guest
.thread_state()
.with_detfd(fd, |detfd| {
detfd.take_procfs_timer_slack_at(value, offset, iovec.len)
})?
.expect("timer-slack procfs state disappeared"),
_ => unreachable!("timer-slack read mode changed while reading"),
};
if bytes.is_empty() {
break;
}
let copied = match copy_timer_slack_output(
&mut guest.memory(),
AddrMut::from_raw(iovec.base),
&bytes,
) {
Ok(copied) => copied,
Err(_) if total > 0 => return Ok(total as i64),
Err(error) => return Err(error.into()),
};
if let Some(preview) = &sequential_preview {
guest.thread_state().with_detfd(fd, |detfd| {
detfd.commit_procfs_timer_slack_read(preview, copied);
})?;
}
total += copied;
if let Some(offset) = positioned_offset.as_mut() {
*offset += copied;
}
if copied != bytes.len() {
return Ok(total as i64);
}
if bytes.len() != iovec.len {
break;
}
}
Ok(total as i64)
}
async fn write_timer_slack<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
buffer: Option<Addr<'_, u8>>,
count: usize,
) -> Result<i64, Error> {
self.require_timer_slack_access(guest, fd, true)?;
let requested = self.read_timer_slack_input(guest, buffer, count)?;
let binding = self
.timer_slack_binding(guest, fd)?
.expect("timer-slack write lost its procfs classification");
self.require_current_timer_slack_target(guest, binding)
.await?;
let state = guest.thread_state_mut();
state.timer_slack_ns = if requested == 0 {
state.default_timer_slack_ns
} else {
requested
};
i64::try_from(count).map_err(|_| Errno::EINVAL.into())
}
async fn writev_timer_slack<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
iovecs: Vec<TimerSlackIovec>,
flags: i32,
) -> Result<i64, Error> {
self.require_timer_slack_access(guest, fd, true)?;
if iovecs.iter().all(|iovec| iovec.len == 0) {
return Ok(0);
}
if flags & !libc::RWF_HIPRI != 0 {
return Err(Errno::EOPNOTSUPP.into());
}
let mut total = 0_i64;
for iovec in iovecs {
if iovec.len == 0 {
continue;
}
let buffer = Addr::from_raw(iovec.base).ok_or(Errno::EFAULT);
let requested = match buffer
.and_then(|buffer| self.read_timer_slack_input(guest, Some(buffer), iovec.len))
{
Ok(requested) => requested,
Err(_error) if total > 0 => return Ok(total),
Err(error) => return Err(error.into()),
};
let binding = self
.timer_slack_binding(guest, fd)?
.expect("timer-slack writev lost its procfs classification");
if let Err(error) = self
.require_current_timer_slack_target(guest, binding)
.await
{
return if total > 0 { Ok(total) } else { Err(error) };
}
let state = guest.thread_state_mut();
state.timer_slack_ns = if requested == 0 {
state.default_timer_slack_ns
} else {
requested
};
total = total
.checked_add(i64::try_from(iovec.len).map_err(|_| Errno::EINVAL)?)
.ok_or(Errno::EINVAL)?;
}
Ok(total)
}
async fn inject_physical_nonblocking<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<(), Errno> {
let flags = guest
.inject(syscalls::Fcntl::new().with_fd(fd).with_cmd(F_GETFL))
.await?;
guest
.inject(
syscalls::Fcntl::new()
.with_fd(fd)
.with_cmd(F_SETFL(flags as i32 | OFlag::O_NONBLOCK.bits())),
)
.await?;
Ok(())
}
async fn open_fifo_once_a_guest_holds_its_peer<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Openat,
fifo: (u64, u64),
path: &std::ffi::OsStr,
) -> Result<i64, Error> {
let reading = call.flags().bits() & libc::O_ACCMODE == libc::O_RDONLY;
let peer = if reading {
FifoPeer::Writer
} else {
FifoPeer::Reader
};
let nonblocking = call.with_flags(call.flags() | OFlag::O_NONBLOCK);
let opens_before = crate::fifo_peer::guest_opens(fifo);
let guest_peer_ready = || {
crate::fifo_peer::guest_holds_peer_of(fifo, peer)
|| crate::fifo_peer::pending_opens(fifo).of(peer) > 0
|| crate::fifo_peer::guest_opens(fifo).of(peer) > opens_before.of(peer)
};
let pending = match guest.inject_with_retry(nonblocking).await {
Ok(fd) if !reading => return Ok(self.make_blocking(guest, fd as RawFd).await?),
Ok(fd) if guest_peer_ready() => {
crate::fifo_peer::stand_in_for_waiting_writers(fifo, path);
return Ok(self.make_blocking(guest, fd as RawFd).await?);
}
Ok(fd) => {
let pending = crate::fifo_peer::PendingOpen::begin(fifo, path, call.flags().bits());
guest
.inject_with_retry(syscalls::Close::new().with_fd(fd as RawFd))
.await?;
pending
}
Err(Errno::ENXIO) if !reading => {
crate::fifo_peer::PendingOpen::begin(fifo, path, call.flags().bits())
}
Err(errno) => return Err(errno.into()),
};
info!("[detcore] the FIFO open polls for a guest peer");
let in_effect = self.cfg.pipe_wake_latency_in_effect().is_some();
let channel = crate::pipe_wake::ChannelId::Fifo(if in_effect {
crate::fifo_peer::fifo_channel(fifo)
} else {
0
});
let (readies, waits_for) = if reading {
(
crate::pipe_wake::Wants::PeerReader,
crate::pipe_wake::Wants::PeerWriter,
)
} else {
(
crate::pipe_wake::Wants::PeerWriter,
crate::pipe_wake::Wants::PeerReader,
)
};
self.note_pipe_readied(guest, channel, readies).await;
let mut resources = Resources::new(guest.thread_state().dettid);
resources.insert(ResourceID::InternalIOPolling, Permission::W);
resources.fyi(call.name());
resources.polls_guest_state_only = true;
resources.waits_until_nothing_else_can_run = true;
if in_effect {
resources.polls_channel = Some(Box::new((channel, waits_for)));
}
resources.set_signal_interrupt_errno(Errno::ERESTARTSYS);
resources.signal_state_task = crate::syscalls::helpers::guest_signal_state_task(guest);
loop {
let status = resource_request(guest, resources.clone()).await;
resources.poll_attempt += 1;
if guest_peer_ready() {
break;
}
match status {
ResumeStatus::Signaled(_) => return Err(Errno::ERESTARTSYS.into()),
ResumeStatus::NothingElseCanRun => {
info!(
"[detcore] nothing else can run; the FIFO open waits in the kernel, as without the poll"
);
let waited_on = pending.guest_path();
return self
.open_fifo_waited_on(
guest,
call,
fifo,
waited_on.as_deref(),
call.flags(),
false,
)
.await;
}
_ => {}
}
}
let waited_on = pending.guest_path();
let open = async |guest: &mut G| {
self.open_fifo_waited_on(
guest,
call,
fifo,
waited_on.as_deref(),
nonblocking.flags(),
true,
)
.await
};
let mut opened = open(guest).await;
if matches!(opened, Err(Error::Errno(Errno::ENXIO))) {
let _stand_in = pending.open_in_tracer(libc::O_RDONLY);
opened = open(guest).await;
}
if reading && opened.is_ok() {
pending.stand_in_for_waiting_writers();
}
drop(pending);
Ok(self.make_blocking(guest, opened? as RawFd).await?)
}
async fn open_fifo_waited_on<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Openat,
fifo: (u64, u64),
waited_on: Option<&str>,
flags: OFlag,
retry: bool,
) -> Result<i64, Error> {
let is_the_fifo = |stat: &libc::stat| (stat.st_dev, stat.st_ino) == fifo;
let unreachable = match waited_on {
Some(waited_on) => {
match Self::open_waited_on_fifo(guest, fifo, waited_on, flags, retry).await {
Err(errno) if !matches!(errno, Errno::ENXIO | Errno::ERESTARTSYS) => {
Some(errno)
}
Ok(fd)
if !self
.inject_fstat(guest, fd as RawFd)
.await
.is_ok_and(|stat| is_the_fifo(&stat)) =>
{
info!(
"[detcore] the tracer's descriptor path reached another file in the guest's root"
);
guest
.inject_with_retry(syscalls::Close::new().with_fd(fd as RawFd))
.await?;
Some(Errno::ENOENT)
}
opened => return Ok(opened?),
}
}
None => None,
};
if let Some(errno) = unreachable {
info!(
"[detcore] the guest cannot reach the tracer's descriptor for the FIFO ({}); it opens the FIFO by its name",
errno
);
}
let path = call.path().ok_or(Errno::EFAULT)?;
let lookup = if flags.contains(OFlag::O_NOFOLLOW) {
AtFlags::AT_SYMLINK_NOFOLLOW
} else {
AtFlags::empty()
};
if Self::inject_statat(guest, call.dirfd(), path, [Some(path), None], lookup)
.await
.is_ok_and(|stat| is_the_fifo(&stat))
{
let open = call.with_flags(flags - (OFlag::O_CREAT | OFlag::O_EXCL));
let fd = if retry {
guest.inject_with_retry(open).await?
} else {
guest.inject(open).await?
};
if self
.inject_fstat(guest, fd as RawFd)
.await
.is_ok_and(|stat| is_the_fifo(&stat))
{
return Ok(fd);
}
guest
.inject_with_retry(syscalls::Close::new().with_fd(fd as RawFd))
.await?;
}
error!(
"[detcore] a blocking open of a FIFO a guest made waited for its peer, and cannot complete \
on that FIFO: the guest cannot reach the tracer's descriptor for it, and its name no \
longer reaches it (a guest without CAP_SYS_PTRACE, or without the tracer's /proc, whose \
FIFO was renamed or unlinked during the wait); refused \
(https://github.com/rrnewton/hermit/pull/4329)"
);
self.refuse_unserviceable_operation(
guest,
Sysno::openat,
unreachable.unwrap_or(Errno::ENOENT),
)
.await
}
async fn open_waited_on_fifo<G: Guest<Self>>(
guest: &mut G,
fifo: (u64, u64),
waited_on: &str,
flags: OFlag,
retry: bool,
) -> Result<i64, Errno> {
let mut path_buffer = [0_u8; crate::fifo_peer::STAGED_PAGE_LENGTH];
let bytes = waited_on.as_bytes();
if bytes.len() >= path_buffer.len() {
return Err(Errno::ENAMETOOLONG);
}
path_buffer[..bytes.len()].copy_from_slice(bytes);
let address =
crate::fifo_peer::free_staging_address(guest.tid().as_raw()).ok_or(Errno::ENOMEM)?;
let page = AddrMut::<u8>::from_raw(address).ok_or(Errno::ENOMEM)?;
let staged =
crate::fifo_peer::StagedPage::new(guest.thread_state().mm_id, address, path_buffer);
match guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(Some(page.cast::<libc::c_void>().into()))
.with_len(path_buffer.len())
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(
MapFlags::MAP_PRIVATE
| MapFlags::MAP_ANONYMOUS
| MapFlags::MAP_FIXED_NOREPLACE,
)
.with_fd(-1)
.with_offset(0),
))
.await
{
Ok(mapped) if mapped as usize == address => {
crate::race_probe::delay(crate::race_probe::FIFO_STAGING_MAPPED).await;
}
Err(errno) => {
staged.unmapped();
return Err(errno);
}
Ok(mapped) => {
staged.unmapped();
if let Some(elsewhere) = Addr::<libc::c_void>::from_raw(mapped as usize) {
let _ = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(elsewhere))
.with_len(path_buffer.len()),
))
.await;
}
return Err(Errno::ENOMEM);
}
}
let path = PathPtr::from_ptr(page.as_raw() as *const libc::c_char)
.expect("a mapped page is not null");
let opened = match guest.memory().write_exact(page, &path_buffer) {
Ok(()) => match Self::inject_statat(
guest,
libc::AT_FDCWD,
path,
[Some(path), None],
AtFlags::empty(),
)
.await
{
Ok(stat) if (stat.st_dev, stat.st_ino) == fifo => {
let open = syscalls::Openat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(Some(path))
.with_flags(flags - (OFlag::O_CREAT | OFlag::O_EXCL | OFlag::O_NOFOLLOW))
.with_mode(None);
if retry {
guest.inject_with_retry(open).await
} else {
guest.inject(open).await
}
}
Ok(_) => {
info!(
"[detcore] the tracer's descriptor path names another file in the guest's root"
);
Err(Errno::ESTALE)
}
Err(errno) => Err(errno),
},
Err(error) => Err(error),
};
match guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(page.cast::<libc::c_void>().into()))
.with_len(path_buffer.len()),
))
.await
{
Ok(_) => staged.unmapped(),
Err(errno) => info!(
"[detcore] the transient FIFO path page is left to the next task: {}",
errno
),
}
opened
}
pub(crate) async fn unmap_orphaned_staging_pages<G: Guest<Self>>(guest: &mut G) {
for page in crate::fifo_peer::take_orphaned_pages(guest.thread_state().mm_id) {
let mut contents = [0_u8; crate::fifo_peer::STAGED_PAGE_LENGTH];
let Some(address) = Addr::<u8>::from_raw(page.address()) else {
page.unmapped();
continue;
};
let readable = guest.memory().read_exact(address, &mut contents).is_ok();
if !readable
|| (contents != *page.contents()
&& !(contents == [0; crate::fifo_peer::STAGED_PAGE_LENGTH]
&& crate::fifo_peer::is_lone_staging_mapping(
guest.tid().as_raw(),
page.address(),
)))
{
info!("[detcore] a FIFO open's path page that a killed task left is gone");
page.unmapped();
continue;
}
info!("[detcore] unmapping a FIFO open's path page that a killed task left");
crate::race_probe::delay(crate::race_probe::FIFO_STAGING_RECLAIM).await;
let unmapped = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Addr::<libc::c_void>::from_raw(page.address()))
.with_len(contents.len()),
))
.await;
match unmapped {
Ok(_) => page.unmapped(),
Err(Errno::EINVAL) => {
warn!(
"[detcore] could not unmap the transient FIFO path page: {}",
Errno::EINVAL
);
page.unmapped();
}
Err(errno) => info!(
"[detcore] the transient FIFO path page is left to the next task: {}",
errno
),
}
}
}
async fn make_blocking<G: Guest<Self>>(&self, guest: &mut G, fd: RawFd) -> Result<i64, Errno> {
let flags = guest
.inject_with_retry(syscalls::Fcntl::new().with_fd(fd).with_cmd(F_GETFL))
.await?;
guest
.inject_with_retry(
syscalls::Fcntl::new()
.with_fd(fd)
.with_cmd(F_SETFL(flags as i32 & !OFlag::O_NONBLOCK.bits())),
)
.await?;
Ok(fd as i64)
}
async fn shrink_fifo_capacity<G: Guest<Self>>(&self, guest: &mut G, fd: RawFd) {
let Ok(capacity) = guest
.inject(syscalls::Fcntl::new().with_fd(fd).with_cmd(F_GETPIPE_SZ))
.await
else {
return;
};
if capacity > i64::from(DETERMINISTIC_PIPE_CAPACITY_BYTES)
&& let Err(errno) = guest
.inject(
syscalls::Fcntl::new()
.with_fd(fd)
.with_cmd(F_SETPIPE_SZ(DETERMINISTIC_PIPE_CAPACITY_BYTES)),
)
.await
{
info!(
"[detcore] FIFO fd {} keeps its {}-byte capacity: shrinking it failed with {}",
fd, capacity, errno
);
}
}
async fn fifo_polls_if_a_guest_holds_its_peer<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
peer: FifoPeer,
) {
let Ok((awaiting, logically_nonblocking)) = guest.thread_state().with_detfd(fd, |detfd| {
(detfd.fifo_awaiting_guest_peer(), detfd.is_nonblocking())
}) else {
return;
};
if !awaiting || logically_nonblocking {
return;
}
let tid = guest.tid().as_raw();
let joins = match crate::fifo_peer::kernel_nonblocking(tid, fd) {
Some(true) => true,
Some(false) => {
crate::fifo_peer::guest_holds_peer(tid, fd, peer) && {
self.shrink_fifo_capacity(guest, fd).await;
self.inject_physical_nonblocking(guest, fd).await.is_ok()
}
}
None => false,
};
if joins {
info!(
"[detcore] fd {} is a FIFO with a guest at its other end; polling it as a pipe",
fd
);
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.fifo_joins_internal_polling());
}
}
pub(crate) async fn inject_fstat<G: Guest<Self>>(
&self,
guest: &mut G,
raw_fd: RawFd,
) -> Result<libc::stat, Errno> {
info!(
"Injecting additional fstat to retrieve file metadata on fd {}.",
raw_fd
);
let fstat = move |statptr: StatPtr<'_>| {
Syscall::Fstat(
syscalls::Fstat::new()
.with_fd(raw_fd)
.with_stat(Some(statptr)),
)
};
let copied = match Self::inject_stat_on_stack(guest, fstat).await {
Err(Errno::EFAULT) => {
info!(
"Guest stack scratch cannot hold the fstat buffer for fd {}; \
using a transient page instead.",
raw_fd
);
Self::inject_stat_in_transient_page(guest, fstat).await?
}
result => result?,
};
trace!("extra fstat returned inode {}", copied.st_ino);
Ok(copied)
}
async fn inject_lstatat<G: Guest<Self>>(
guest: &mut G,
dirfd: RawFd,
path: syscalls::PathPtr<'_>,
inputs: [Option<syscalls::PathPtr<'_>>; 2],
) -> Result<libc::stat, Errno> {
Self::inject_statat(guest, dirfd, path, inputs, AtFlags::AT_SYMLINK_NOFOLLOW).await
}
pub(crate) async fn inject_statat<G: Guest<Self>>(
guest: &mut G,
dirfd: RawFd,
path: syscalls::PathPtr<'_>,
inputs: [Option<syscalls::PathPtr<'_>>; 2],
flags: AtFlags,
) -> Result<libc::stat, Errno> {
let probe = Syscall::Newfstatat(
syscalls::Newfstatat::new()
.with_dirfd(dirfd)
.with_path(Some(path))
.with_flags(flags),
);
let Some(translated) = Self::procfs_translated_call(guest, &probe).await? else {
return Self::inject_statat_as_spelled(guest, dirfd, path, inputs, flags).await;
};
let respelled = PathPtr::from_ptr(translated.page.as_raw() as *const libc::c_char);
let looked_up = match respelled {
Some(respelled) => {
Self::inject_statat_as_spelled(
guest,
dirfd,
respelled,
[Some(respelled), None],
flags,
)
.await
}
None => Err(Errno::ENOMEM),
};
Self::finish_translated_call(guest, translated).await;
looked_up
}
async fn inject_statat_as_spelled<G: Guest<Self>>(
guest: &mut G,
dirfd: RawFd,
path: syscalls::PathPtr<'_>,
inputs: [Option<syscalls::PathPtr<'_>>; 2],
flags: AtFlags,
) -> Result<libc::stat, Errno> {
let lstatat = move |statptr: StatPtr<'_>| {
Syscall::Newfstatat(
syscalls::Newfstatat::new()
.with_dirfd(dirfd)
.with_path(Some(path))
.with_stat(Some(statptr))
.with_flags(flags),
)
};
let scratch = 128 + std::mem::size_of::<libc::stat>();
if usize::try_from(guest.regs().await.rsp).map_or(true, |rsp| rsp <= scratch) {
return Self::inject_stat_in_transient_page(guest, lstatat).await;
}
let mut stack = guest.stack().await;
let statptr: StatPtr = StatPtr(stack.reserve());
let mut saved = [0u8; std::mem::size_of::<libc::stat>()];
let staged_on_stack = !inputs
.iter()
.any(|input| path_overlaps_buffer(&guest.memory(), *input, statptr))
&& guest
.memory()
.read_exact(statptr.0.cast(), &mut saved)
.is_ok();
if !staged_on_stack {
drop(stack);
return Self::inject_stat_in_transient_page(guest, lstatat).await;
}
let guard = match stack.commit() {
Ok(guard) => guard,
Err(_) => {
restore_lookup_buffer(&mut guest.memory(), statptr, &saved);
return Self::inject_stat_in_transient_page(guest, lstatat).await;
}
};
restore_lookup_buffer(&mut guest.memory(), statptr, &saved);
let looked_up = Self::inject_stat_into(guest, lstatat(statptr), statptr).await;
restore_lookup_buffer(&mut guest.memory(), statptr, &saved);
drop(guard);
looked_up
}
async fn inject_stat_on_stack<G: Guest<Self>>(
guest: &mut G,
stat_call: impl Fn(StatPtr<'_>) -> Syscall,
) -> Result<libc::stat, Errno> {
let mut stack = guest.stack().await;
let statptr: StatPtr = StatPtr(stack.reserve());
let _stack_guard = stack.commit()?;
let copied = Self::inject_stat_into(guest, stat_call(statptr), statptr).await?;
guest
.memory()
.write_exact(statptr.0.cast(), &[0; std::mem::size_of::<libc::stat>()])?;
Ok(copied)
}
async fn inject_stat_in_transient_page<G: Guest<Self>>(
guest: &mut G,
stat_call: impl Fn(StatPtr<'_>) -> Syscall,
) -> Result<libc::stat, Errno> {
let len = std::mem::size_of::<libc::stat>();
let mapped = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(len)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await?;
let page = usize::try_from(mapped)
.ok()
.and_then(AddrMut::<libc::stat>::from_raw)
.unwrap_or_else(|| panic!("transient fstat page mmap returned {mapped}"));
let copied = Self::inject_stat_into(guest, stat_call(StatPtr(page)), StatPtr(page)).await;
if let Err(errno) = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(page.cast::<libc::c_void>().into()))
.with_len(len),
))
.await
{
warn!(
"[detcore] could not unmap the transient stat page: {}",
errno
);
}
copied
}
async fn inject_stat_into<G: Guest<Self>>(
guest: &mut G,
stat_call: Syscall,
statptr: StatPtr<'_>,
) -> Result<libc::stat, Errno> {
guest.inject_with_retry(stat_call).await?;
statptr.read(&guest.memory())
}
pub(crate) async fn add_fd<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
flags: OFlag,
ty: FdType,
) -> Result<(), Errno> {
self.add_fd_with_stat(guest, fd, flags, ty).await.map(drop)
}
pub(crate) async fn track_held_fd<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
flags: OFlag,
ty: FdType,
) -> Result<(), Errno> {
let host_stat = if guest.config().virtualize_metadata {
Some(self.inject_fstat(guest, fd).await?)
} else {
None
};
guest
.thread_state()
.add_fd(fd, flags, ty, host_stat.map(Into::into))
}
async fn add_fd_with_stat<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
flags: OFlag,
ty: FdType,
) -> Result<Option<libc::stat>, Errno> {
let host_stat = if guest.config().virtualize_metadata {
match self.inject_fstat(guest, fd).await {
Ok(stat) => Some(stat),
Err(errno) => {
if let Err(close_errno) = guest.inject(syscalls::Close::new().with_fd(fd)).await
{
warn!(
"[detcore] could not close fd {} after failing to record its \
metadata ({}): {}",
fd, errno, close_errno
);
}
return Err(errno);
}
}
} else {
None
};
guest
.thread_state()
.add_fd(fd, flags, ty, host_stat.map(Into::into))?;
Ok(host_stat)
}
pub(crate) async fn release_port_for_open_file<G: Guest<Self>>(
&self,
guest: &mut G,
open_file_id: OpenFileId,
) -> Option<u16> {
let response = send_and_update_time(guest, GlobalRequest::ReleasePort(open_file_id)).await;
match response.1 {
GlobalResponse::ReleasePort(port) => port,
other => panic!("unexpected release-port response: {other:?}"),
}
}
pub(crate) async fn restore_port_for_open_file<G: Guest<Self>>(
&self,
guest: &mut G,
open_file_id: OpenFileId,
port: u16,
) {
let response =
send_and_update_time(guest, GlobalRequest::AddUsedPort(port, open_file_id)).await;
match response.1 {
GlobalResponse::AddUsedPort => {}
other => panic!("unexpected restore-port response: {other:?}"),
}
}
pub(crate) async fn procfs_spelling_at<G: Guest<Self>>(
&self,
guest: &mut G,
dirfd: i32,
path: &Path,
) -> Result<PathBuf, Error> {
if !path.is_absolute() && !path.as_os_str().is_empty() && dirfd != libc::AT_FDCWD {
let (reached, link_itself) = guest
.thread_state()
.with_detfd(dirfd, |detfd| {
(detfd.procfs_reached(), detfd.procfs_link_itself())
})
.unwrap_or((None, false));
if link_itself {
return Err(Errno::ENOTDIR.into());
}
if let Some((reached, incarnation)) = reached {
if let Some(incarnation) = incarnation
&& let Some(task) = procfs_reached_task(&reached)
{
let answer = crate::tool_global::procfs_task(guest, task).await;
if !answer.still_names(incarnation) {
return Err(Errno::ESRCH.into());
}
}
return Ok(reached.join(path));
}
if let Some(directory) = self.unrecorded_procfs_directory(guest, dirfd).await {
return Ok(directory.join(path));
}
}
Self::observed_path(guest, dirfd, path)
}
pub(crate) async fn unrecorded_procfs_directory<G: Guest<Self>>(
&self,
guest: &mut G,
dirfd: i32,
) -> Option<PathBuf> {
if dirfd < 0 || !self.renders_procfs(guest) {
return None;
}
let recorded = guest
.thread_state()
.with_detfd(dirfd, |detfd| detfd.path())
.unwrap_or(None);
if recorded.is_some() {
return None;
}
const LINK_CAPACITY: usize = 40;
const TARGET_CAPACITY: usize = 256;
let mut stack = guest.stack().await;
let link = stack.push(rendered_procfs::c_string::<LINK_CAPACITY>(
format!("/proc/thread-self/fd/{dirfd}").as_bytes(),
));
let target = stack.reserve::<[u8; TARGET_CAPACITY]>();
let stack_guard = stack.commit().ok()?;
let length = guest
.inject(
syscalls::Readlinkat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(PathPtr::from_ptr(link.as_raw() as *const libc::c_char))
.with_buf(Some(target.cast::<libc::c_char>()))
.with_buf_len(TARGET_CAPACITY),
)
.await;
let bytes = match length.map(|length| length as usize) {
Ok(length) if length < TARGET_CAPACITY => {
let mut bytes = vec![0; length];
guest
.memory()
.read_exact(target.cast::<u8>(), &mut bytes)
.ok()
.map(|()| bytes)
}
_ => None,
};
drop(stack_guard);
let text = String::from_utf8(bytes?).ok()?;
let (mut names, positions) = procfs_directory_task_positions(&text)?;
if Self::translates_procfs_numbers(guest) && !positions.is_empty() {
let kernel = positions
.iter()
.map(|position| names[*position].parse::<i32>().ok())
.collect::<Option<Vec<_>>>()?;
let translated = crate::tool_global::procfs_ids(guest, false, kernel).await;
for (position, number) in positions.iter().zip(translated) {
names[*position] = number?.to_string();
}
}
let mut directory = PathBuf::from("/proc");
directory.extend(names);
Some(directory)
}
fn observed_path<G: Guest<Self>>(guest: &G, dirfd: i32, path: &Path) -> Result<PathBuf, Error> {
Ok(if path.is_absolute() {
path.to_path_buf()
} else if dirfd == libc::AT_FDCWD {
resolved_at_fdcwd_path(guest.pid().as_raw(), path).unwrap_or_else(|| path.to_path_buf())
} else {
guest
.thread_state()
.with_detfd(dirfd, |detfd| detfd.path())
.unwrap_or(None)
.map_or_else(|| path.to_path_buf(), |directory| directory.join(path))
})
}
pub(crate) async fn record_host_namespace_change<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) {
let at = libc::AT_FDCWD;
let changed: Vec<(i32, Option<syscalls::PathPtr>)> = match call {
#[cfg(not(target_arch = "aarch64"))]
Syscall::Rename(c) => vec![(at, c.oldpath()), (at, c.newpath())],
Syscall::Renameat(c) => vec![(c.olddirfd(), c.oldpath()), (c.newdirfd(), c.newpath())],
Syscall::Renameat2(c) => {
vec![(c.olddirfd(), c.oldpath()), (c.newdirfd(), c.newpath())]
}
#[cfg(not(target_arch = "aarch64"))]
Syscall::Link(c) => vec![(at, c.newpath())],
Syscall::Linkat(c) => vec![(c.newdirfd(), c.newpath())],
#[cfg(not(target_arch = "aarch64"))]
Syscall::Unlink(c) => vec![(at, c.path())],
Syscall::Unlinkat(c) => vec![(c.dirfd(), c.path())],
#[cfg(not(target_arch = "aarch64"))]
Syscall::Symlink(c) => vec![(at, c.linkpath())],
Syscall::Symlinkat(c) => vec![(c.newdirfd(), c.linkpath())],
#[cfg(not(target_arch = "aarch64"))]
Syscall::Mknod(c) => vec![(at, c.path())],
Syscall::Mknodat(c) => vec![(c.dirfd(), c.path())],
#[cfg(not(target_arch = "aarch64"))]
Syscall::Mkdir(c) => vec![(at, c.path())],
Syscall::Mkdirat(c) => vec![(c.dirfd(), c.path())],
#[cfg(not(target_arch = "aarch64"))]
Syscall::Rmdir(c) => vec![(at, c.path())],
#[cfg(not(target_arch = "aarch64"))]
Syscall::Creat(c) => vec![(at, c.path())],
_ => return,
};
for (dirfd, path) in changed {
let observed = match path.map(|path| path.read(&guest.memory())) {
Some(Ok(path)) => {
let path: PathBuf = path;
Self::observed_path(guest, dirfd, &path).ok()
}
_ => None,
};
crate::tool_global::record_host_mutation(guest, rebound_path(observed)).await;
}
}
pub(crate) async fn last_names_removed_by<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) -> Vec<RawInode> {
if !guest.config().virtualize_metadata || !guest.config().sequentialize_threads {
return Vec::new();
}
let at = libc::AT_FDCWD;
let (removed, source) = match call {
#[cfg(not(target_arch = "aarch64"))]
Syscall::Unlink(c) => ((at, c.path()), None),
Syscall::Unlinkat(c) => ((c.dirfd(), c.path()), None),
#[cfg(not(target_arch = "aarch64"))]
Syscall::Rmdir(c) => ((at, c.path()), None),
#[cfg(not(target_arch = "aarch64"))]
Syscall::Rename(c) => ((at, c.newpath()), Some((at, c.oldpath()))),
Syscall::Renameat(c) => (
(c.newdirfd(), c.newpath()),
Some((c.olddirfd(), c.oldpath())),
),
Syscall::Renameat2(c) if c.flags() & libc::RENAME_EXCHANGE == 0 => (
(c.newdirfd(), c.newpath()),
Some((c.olddirfd(), c.oldpath())),
),
_ => return Vec::new(),
};
let inputs = [removed.1, source.and_then(|source| source.1)];
let Some(path) = removed.1 else {
return Vec::new();
};
let Ok(stat) = Self::inject_lstatat(guest, removed.0, path, inputs).await else {
return Vec::new();
};
let inode = RawInode::new(stat.st_dev, stat.st_ino);
if let Some((dirfd, Some(path))) = source
&& Self::inject_lstatat(guest, dirfd, path, inputs)
.await
.is_ok_and(|source| RawInode::new(source.st_dev, source.st_ino) == inode)
{
return Vec::new();
}
if retires_on_removal(&stat) {
vec![inode]
} else {
Vec::new()
}
}
pub(crate) async fn guest_made_fifos_removed_by<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) -> Vec<(u64, u64)> {
if !crate::fifo_peer::any_guest_made()
|| !crate::fifo_peer::guest_descriptors_are_visible(
&self.cfg.backend,
guest.thread_state().physical_tid,
)
{
return Vec::new();
}
let at = libc::AT_FDCWD;
let (removed, source) = match call {
#[cfg(not(target_arch = "aarch64"))]
Syscall::Unlink(c) => ((at, c.path()), None),
Syscall::Unlinkat(c) => ((c.dirfd(), c.path()), None),
#[cfg(not(target_arch = "aarch64"))]
Syscall::Rename(c) => ((at, c.newpath()), Some((at, c.oldpath()))),
Syscall::Renameat(c) => (
(c.newdirfd(), c.newpath()),
Some((c.olddirfd(), c.oldpath())),
),
Syscall::Renameat2(c) if c.flags() & libc::RENAME_EXCHANGE == 0 => (
(c.newdirfd(), c.newpath()),
Some((c.olddirfd(), c.oldpath())),
),
_ => return Vec::new(),
};
let inputs = [removed.1, source.and_then(|source| source.1)];
let Some(path) = removed.1 else {
return Vec::new();
};
let Ok(stat) = Self::inject_lstatat(guest, removed.0, path, inputs).await else {
return Vec::new();
};
let fifo = (stat.st_dev, stat.st_ino);
if stat.st_mode & libc::S_IFMT != libc::S_IFIFO
|| !crate::fifo_peer::is_guest_made(fifo)
|| !retires_on_removal(&stat)
{
return Vec::new();
}
if let Some((dirfd, Some(path))) = source
&& Self::inject_lstatat(guest, dirfd, path, inputs)
.await
.is_ok_and(|source| (source.st_dev, source.st_ino) == fifo)
{
return Vec::new();
}
vec![fifo]
}
pub(crate) async fn note_guest_made_fifo<G: Guest<Self>>(&self, guest: &mut G, call: &Syscall) {
if !self.cfg.use_nonblocking_sockets()
|| self.cfg.recordreplay_modes
|| !crate::fifo_peer::guest_descriptors_are_visible(
&self.cfg.backend,
guest.thread_state().physical_tid,
)
{
return;
}
let (dirfd, path, mode) = match call {
#[cfg(not(target_arch = "aarch64"))]
Syscall::Mknod(c) => (libc::AT_FDCWD, c.path(), c.mode().bits()),
Syscall::Mknodat(c) => (c.dirfd(), c.path(), c.mode().bits()),
_ => return,
};
if mode & libc::S_IFMT != libc::S_IFIFO {
return;
}
let Some(path) = path else {
return;
};
if let Ok(stat) = Self::inject_lstatat(guest, dirfd, path, [Some(path), None]).await
&& stat.st_mode & libc::S_IFMT == libc::S_IFIFO
{
crate::fifo_peer::note_guest_made((stat.st_dev, stat.st_ino));
}
}
pub(crate) async fn retire_removed_inodes<G: Guest<Self>>(
&self,
guest: &mut G,
inodes: Vec<RawInode>,
) {
for inode in inodes {
retire_inode(guest, inode).await;
}
}
pub(crate) async fn record_untraced_code_change<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) {
let Some(range) = guest.config().untraced_code_range else {
return;
};
let (number, args) = call.into_parts();
if may_change_untraced_code(number, &args, range, default_huge_page_size()) {
crate::tool_global::record_host_mutation(guest, String::from("/")).await;
}
}
async fn open_launched_exe<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Openat,
exe: Option<&crate::exec_record::ExecRecord>,
) -> Result<i64, Error> {
const CAPACITY: usize = libc::PATH_MAX as usize;
let probe = syscalls::Openat::new()
.with_dirfd(call.dirfd())
.with_path(call.path())
.with_flags(OFlag::O_PATH | OFlag::O_CLOEXEC);
let probed = guest.inject(probe).await?;
let _ = guest
.inject(syscalls::Close::new().with_fd(probed as RawFd))
.await;
let present = exe.filter(|exe| {
self.guest_root(guest)
.is_some_and(|root| exe.is_present(&root))
});
let Some(exe) = present else {
return self.refuse_launched_exe(guest, Sysno::openat, exe).await;
};
let bytes = std::os::unix::ffi::OsStrExt::as_bytes(exe.exe.as_os_str());
let mut stack = guest.stack().await;
if bytes.len() >= CAPACITY || stack.capacity() < CAPACITY {
drop(stack);
let reason = format!(
"unsupported: opening the /proc/<pid>/exe link of {:?}, whose path does not \
fit the guest stack, where the kernel's link names the launcher",
exe.exe
);
return self
.refuse_launched_exe_because(guest, Sysno::openat, reason)
.await;
}
let mut buffer = [0_u8; CAPACITY];
buffer[..bytes.len()].copy_from_slice(bytes);
let address = stack.push(buffer).cast::<libc::c_char>();
let stack_guard = stack.commit()?;
let call = call.with_path(PathPtr::from_ptr(address.as_raw() as *const libc::c_char));
let result = self.record_or_replay(guest, Syscall::Openat(call)).await;
drop(stack_guard);
Ok(result?)
}
fn opened_the_launcher(&self, fd: RawFd) -> bool {
use std::os::unix::fs::MetadataExt;
let Some(launcher) = self.declared_launcher() else {
return false;
};
if !self.cfg.backend.tool_shares_guest_descriptor_table {
return false;
}
let mut opened: libc::stat = unsafe { std::mem::zeroed() };
let result = unsafe {
crate::util::raw_syscall(
libc::SYS_fstat,
[fd as u64, (&raw mut opened) as u64, 0, 0, 0, 0],
)
};
result == 0
&& std::fs::metadata(launcher)
.is_ok_and(|meta| (meta.dev(), meta.ino()) == (opened.st_dev, opened.st_ino))
}
pub async fn handle_openat<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Openat,
) -> Result<i64, Error> {
let path = call.path().ok_or(Errno::EFAULT)?;
let path: PathBuf = path.read(&guest.memory())?;
let observed_path = Self::observed_path(guest, call.dirfd(), &path)?;
let procfs_spelling = self.procfs_spelling_at(guest, call.dirfd(), &path).await?;
crate::race_probe::delay(crate::race_probe::PROCFS_SPELLING_RESOLVED).await;
if guest.config().record_host_inputs && call.flags().contains(OFlag::O_CREAT) {
crate::tool_global::record_host_mutation(
guest,
rebound_path(Some(observed_path.clone())),
)
.await;
}
let resource = ResourceID::Path(path.clone());
let request = guest.thread_state().mk_request(resource, Permission::R);
resource_request(guest, request).await;
let rendered = match if path.as_os_str().is_empty() {
Ok(None)
} else {
self.rendered_procfs_at(guest, &procfs_spelling).await
} {
Ok(rendered) => rendered,
Err(error) => {
resource_release_all(guest).await;
return Err(
rendered_procfs::open_flags_refused(call.flags()).map_or(error, Into::into)
);
}
};
if let Some(target) = rendered.filter(|target| {
!(target.via_link && call.flags().contains(OFlag::O_PATH | OFlag::O_NOFOLLOW))
}) {
let result = self.open_rendered_procfs(guest, call.flags(), target).await;
resource_release_all(guest).await;
return result;
}
let launched_exe = if call.flags().bits() & libc::O_ACCMODE == libc::O_RDONLY
&& !call
.flags()
.intersects(OFlag::O_NOFOLLOW | OFlag::O_TRUNC | OFlag::O_CREAT)
{
self.launched_exe(guest, (call.dirfd(), &path), true).await
} else {
None
};
if guest.thread_state().sigalrm_handled
&& !call.flags().intersects(OFlag::O_DIRECTORY | OFlag::O_PATH)
&& let Some(path) = call.path()
&& crate::sigalrm_phase1::open_refused(
Self::inject_statat(
guest,
call.dirfd(),
path,
[Some(path), None],
AtFlags::empty(),
)
.await,
call.flags().contains(OFlag::O_NONBLOCK),
)
{
return Err(Errno::EOPNOTSUPP.into());
}
let link_source = crate::syscalls::namespace::own_descriptor_link(
&observed_path,
self.procfs_caller_ids(guest),
)
.and_then(|link| {
guest
.thread_state()
.with_detfd(link.fd, |detfd| LinkSource {
fd: link.fd,
path: detfd.path(),
open_file: detfd.open_file_id(),
reached: detfd.procfs_reached(),
})
.ok()
});
let fifo = (self.cfg.use_nonblocking_sockets()
&& !self.cfg.recordreplay_modes
&& !call.flags().intersects(OFlag::O_NONBLOCK | OFlag::O_PATH)
&& call.flags().bits() & libc::O_ACCMODE != libc::O_RDWR)
.then(|| {
crate::fifo_peer::fifo_at(
&self.cfg.backend,
guest.thread_state().physical_tid,
guest.tid().as_raw(),
call.dirfd(),
&path,
)
})
.flatten()
.filter(|(fifo, _)| crate::fifo_peer::is_guest_made(*fifo));
let maps_before = if guest.runtime_private_memory_regions().is_some() {
if let Some((pid, tid)) = self.procfs_caller_ids(guest)
&& let Some(task) = crate::procfs::maps_task_at(&procfs_spelling, pid, tid)
{
Some((task, crate::tool_global::procfs_task(guest, task).await))
} else {
None
}
} else {
None
};
let res: Result<i64, Error> = match fifo {
Some((fifo, fifo_path)) => {
self.open_fifo_once_a_guest_holds_its_peer(guest, call, fifo, &fifo_path)
.await
}
None => match launched_exe {
Some(exe) => self.open_launched_exe(guest, call, exe.as_deref()).await,
None => self
.record_or_replay(guest, Syscall::Openat(call))
.await
.map_err(Error::from),
},
};
match res {
Ok(fd) => {
let fd = fd as RawFd;
if crate::syscalls::namespace::exe_link_candidate(&path)
&& self.opened_the_launcher(fd)
{
let _ = guest.inject(syscalls::Close::new().with_fd(fd)).await;
resource_release_all(guest).await;
return self.refuse_launched_exe(guest, Sysno::openat, None).await;
}
if names_descriptor_link(&observed_path)
&& !call.flags().contains(OFlag::O_PATH | OFlag::O_NOFOLLOW)
&& (rendered_procfs::placeholders_exist()
|| guest.config().backend.tool_shares_guest_descriptor_table)
{
let behind = self.rendered_procfs_behind(guest, fd).await;
if !matches!(behind, Ok(None)) {
let _ = guest.inject(syscalls::Close::new().with_fd(fd)).await;
}
let result = match behind {
Ok(None) => None,
Ok(Some(path)) => {
let target = rendered_procfs::RenderedTarget {
procfs: ProcfsFile::from_rendered_path(path)
.expect("a rendered path is a procfs file"),
via_link: true,
};
Some(self.open_rendered_procfs(guest, call.flags(), target).await)
}
Err(error) => Some(Err(error)),
};
if let Some(result) = result {
resource_release_all(guest).await;
return result;
}
}
let pid = guest.pid().as_raw();
let backend = self.cfg.backend;
self.network_check_open(guest, &observed_path, || {
resolved_open_path(&backend, pid, fd)
})
.await;
let fd_type = path.to_str().map_or(FdType::Regular, |fname| {
if fname == "/dev/random" || fname == "/dev/urandom" {
FdType::Rng
} else {
FdType::Regular
}
});
let fd_type = if fd_type == FdType::Regular
&& self.cfg.use_nonblocking_sockets()
&& !self.cfg.recordreplay_modes
&& !call.flags().contains(OFlag::O_PATH)
&& reopens_scheduler_managed_pipe(
&self.cfg.backend,
guest.pid().as_raw(),
fd,
&guest.thread_state().scheduler_managed_pipe_fds(),
)
&& (call.flags().contains(OFlag::O_NONBLOCK)
|| self.inject_physical_nonblocking(guest, fd).await.is_ok())
{
FdType::Pipe
} else {
fd_type
};
let host_stat = self
.add_fd_with_stat(guest, fd, call.flags(), fd_type)
.await?;
let identity = match &host_stat {
Some(stat) => Some(*stat),
None if self.renders_procfs(guest)
&& (guest.thread_state().holds_a_rendered_procfs_file()
|| rendered_procfs::placeholders_exist()) =>
{
self.inject_fstat(guest, fd).await.ok()
}
None => None,
};
let reached = match &identity {
Some(stat) if self.renders_procfs(guest) => {
self.recognize_placeholder(
guest,
&DetStat::from(*stat),
StatTarget::Descriptor(fd),
)
.await
}
_ => None,
};
if let Some(path) = reached {
guest.thread_state().remove_fd(fd);
let _ = guest.inject(syscalls::Close::new().with_fd(fd)).await;
let target = rendered_procfs::RenderedTarget {
procfs: ProcfsFile::from_rendered_path(path)
.expect("a rendered path is a procfs file"),
via_link: false,
};
let result = self.open_rendered_procfs(guest, call.flags(), target).await;
resource_release_all(guest).await;
return result;
}
if self
.opened_procfs_name_outside_level(
guest,
fd,
identity.as_ref().map(|stat| (stat.st_dev, stat.st_ino)),
)
.await
{
guest.thread_state().remove_fd(fd);
let _ = guest.inject(syscalls::Close::new().with_fd(fd)).await;
resource_release_all(guest).await;
return Err(Errno::ENOENT.into());
}
if fd_type == FdType::Regular
&& self.cfg.use_nonblocking_sockets()
&& !self.cfg.recordreplay_modes
&& !call.flags().contains(OFlag::O_PATH)
&& let Some(fifo) = crate::fifo_peer::fifo_of(
&self.cfg.backend,
guest.thread_state().physical_tid,
guest.tid().as_raw(),
fd,
)
{
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.mark_fifo_awaiting_guest_peer())?;
crate::fifo_peer::note_guest_open(fifo, call.flags().bits());
if self.cfg.pipe_wake_latency_in_effect().is_some() {
let accmode = call.flags().bits() & libc::O_ACCMODE;
let end = crate::pipe_wake::ChannelEnd {
channel: crate::pipe_wake::ChannelId::Fifo(
crate::fifo_peer::fifo_channel(fifo),
),
reads: accmode != libc::O_WRONLY,
writes: accmode != libc::O_RDONLY,
};
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_channel(end))?;
for (applies, readies) in [
(end.reads, crate::pipe_wake::Wants::PeerReader),
(end.writes, crate::pipe_wake::Wants::PeerWriter),
] {
if applies {
self.note_pipe_readied(guest, end.channel, readies).await;
}
}
}
}
if let (true, Some(stat)) = (guest.config().record_host_inputs, &host_stat) {
crate::tool_global::record_host_input(
guest,
observed_path.to_string_lossy().into_owned(),
detcore_model::host_input::HostFileIdentity::from_stat(stat),
)
.await;
}
if let Some(stat) = &host_stat
&& (stat.st_nlink > 0 || call.flags().contains(OFlag::O_TMPFILE))
{
let procfs =
Self::procfs_entry(guest, &DetStat::from(stat), StatTarget::Descriptor(fd))
.await;
forget_retired_inode(
guest,
RawInode::new(stat.st_dev, stat.st_ino),
procfs.name(stat.st_dev),
)
.await;
}
if guest.config().record_host_inputs
&& guest.config().untraced_code_range.is_some()
&& may_write_process_memory(
call.flags(),
descriptor_identity(guest.tid().as_raw(), fd)
.as_ref()
.map(|(link, on_procfs)| (link.as_path(), *on_procfs)),
)
{
crate::tool_global::record_host_mutation(guest, String::from("/")).await;
}
if bundled_signal_facts::host_timed_signal_sources_are_physical(
&guest.config().backend,
) && !self.cfg.recordreplay_modes
&& open_can_acquire_controlling_terminal(call.flags())
&& opened_controlling_terminal(guest.pid().as_raw(), fd, host_stat.as_ref())
{
record_host_timed_signals(
guest,
HostTimedSignalScope::Container,
terminal_signals(),
)
.await;
}
if fd_type == FdType::Pipe {
self.maybe_set_nonblocking_fd(guest, fd);
}
let mut procfs =
ProcfsFile::from_path(&observed_path).filter(ProcfsFile::kernel_served);
if procfs.is_none() || self.cfg.recordreplay_modes {
let resolved = if self.cfg.recordreplay_modes {
self.recorded_open_path(guest, fd).await?
} else {
resolved_open_path(&self.cfg.backend, guest.pid().as_raw(), fd)
};
if self.cfg.recordreplay_modes
&& resolved.as_deref().is_some_and(|resolved| {
levels::procfs_name(resolved)
.is_some_and(|name| name.absent_at(self.cfg.proc_level))
})
&& self.recorded_descriptor_is_on_procfs(guest, fd).await
{
guest.thread_state().remove_fd(fd);
let _ = self
.record_or_replay(guest, syscalls::Close::new().with_fd(fd))
.await;
resource_release_all(guest).await;
return Err(Errno::ENOENT.into());
}
if procfs.is_none() {
procfs = resolved
.filter(|resolved| resolved != &observed_path)
.and_then(|resolved| ProcfsFile::from_path(&resolved))
.filter(ProcfsFile::kernel_served);
}
}
if procfs.is_none()
&& guest.config().sequentialize_threads
&& let Some(stat) = host_stat
&& let ProcfsEntry::At(within) =
Self::procfs_entry(guest, &DetStat::from(stat), StatTarget::Descriptor(fd))
.await
{
procfs = ProcfsFile::from_path(
&Path::new("/proc").join(within.strip_prefix("/").unwrap_or(&within)),
)
.filter(ProcfsFile::may_be_named_by_provenance);
}
if guest.runtime_private_memory_regions().is_some()
&& procfs.as_ref().is_some_and(ProcfsFile::is_maps)
&& let Some(stat) = host_stat
{
match self
.maps_descriptor_entry(guest, &DetStat::from(stat), fd)
.await
{
ProcfsEntry::At(within) => {
let actual = Path::new("/proc")
.join(within.strip_prefix("/").unwrap_or(&within));
if let Some(task) = self.maps_guest_target(guest, &actual).await
&& let Some((before_task, before)) = maps_before.as_ref()
&& *before_task == task
{
let after = crate::tool_global::procfs_task(guest, task).await;
if let Some(target) =
crate::procfs::MapsTarget::from_open(task, before, &after)
&& guest.runtime_private_memory_is_current(&target.private)
{
procfs.as_mut().unwrap().bind_maps_target(target);
}
}
}
ProcfsEntry::NotProcfs => procfs = None,
ProcfsEntry::Unnamed | ProcfsEntry::Unknown => {}
}
}
if let Some(file) = procfs.as_ref()
&& file.mount_table_rendering().is_some()
{
let kernel = self.mount_view_is_kernel(guest, file).await;
procfs
.as_mut()
.expect("a classified procfs file disappeared")
.pin_mount_view(kernel);
}
if procfs
.as_ref()
.is_some_and(ProcfsFile::needs_bound_thread_identity)
{
let tgid = guest.inject(syscalls::Getpid::new()).await? as i32;
let tid = guest.inject(syscalls::Gettid::new()).await? as i32;
let ppid = guest.inject(syscalls::Getppid::new()).await? as i32;
procfs
.as_mut()
.expect("thread identity request lost its procfs file")
.bind_thread_identity(tgid, tid, ppid);
}
if procfs
.as_ref()
.and_then(ProcfsFile::timer_slack_target)
.is_some()
{
let target = procfs
.as_ref()
.and_then(ProcfsFile::timer_slack_target)
.expect("timer-slack target disappeared");
let stat = match guest.thread_state().with_detfd(fd, |detfd| detfd.stat())? {
Some(stat) => libc::stat::from(&stat),
None => self.inject_fstat(guest, fd).await?,
};
let identity = if stat.st_mode & libc::S_IFMT == libc::S_IFREG {
(stat.st_dev, stat.st_ino)
} else {
self.observe_timer_slack_identity(guest, target)
.await?
.unwrap_or((stat.st_dev, stat.st_ino))
};
procfs
.as_mut()
.expect("timer-slack classification disappeared")
.bind_timer_slack_identity(identity.0, identity.1);
}
let provenance = guest
.thread_state()
.sigalrm_handled
.then(|| crate::sigalrm_phase1::kernel_provenance(guest.pid().as_raw(), fd));
let opener = {
let detpid = self.own_detpid(guest);
let state = guest.thread_state();
DescriptorLinkOpener {
own: self.procfs_caller_ids(guest),
holds_process_table: state.dettid == detpid || state.holds_process_files(),
}
};
let unrecorded_link_identity = if self.renders_procfs(guest)
&& guest.config().sequentialize_threads
&& !opens_the_link_itself(&observed_path, call.flags())
&& host_stat.is_none_or(|stat| stat.st_mode & libc::S_IFMT == libc::S_IFDIR)
&& link_source
.as_ref()
.is_none_or(|source| source.path.is_none())
&& crate::syscalls::namespace::own_descriptor_link(&observed_path, opener.own)
.is_some_and(|link| {
link.table == crate::syscalls::namespace::DescriptorTable::Thread
|| opener.holds_process_table
}) {
Self::procfs_directory_named_for(guest, fd).await
} else {
None
};
let recorded_path = {
let state = guest.thread_state();
if state.changed_root.load(Ordering::SeqCst) {
observed_path.clone()
} else {
path_to_record_for_open(
&observed_path,
call.flags(),
opener,
|target| {
link_source.as_ref().and_then(|source| {
source.path_if_unchanged(
target,
state.with_detfd(target, |detfd| detfd.open_file_id()).ok(),
)
})
},
unrecorded_link_identity,
)
}
};
let link_itself = self.renders_procfs(guest)
&& opens_the_link_itself(&procfs_spelling, call.flags())
&& names_a_selector_link(&procfs_spelling);
let reached = if self.renders_procfs(guest) {
let linked = {
let state = guest.thread_state();
crate::syscalls::namespace::own_descriptor_link(&observed_path, opener.own)
.filter(|link| {
!opens_the_link_itself(&observed_path, call.flags())
&& (link.table
== crate::syscalls::namespace::DescriptorTable::Thread
|| opener.holds_process_table)
})
.and_then(|link| {
link_source.as_ref().and_then(|source| {
source.reached_if_unchanged(
link.fd,
state
.with_detfd(link.fd, |detfd| detfd.open_file_id())
.ok(),
)
})
})
};
match linked {
Some(reached) => Some(reached),
None if link_itself => None,
None => match procfs_selector_reached(&procfs_spelling, opener.own) {
Some(selected) => {
let incarnation = match procfs_reached_task(&selected) {
Some(task) => {
let answer =
crate::tool_global::procfs_task(guest, task).await;
answer.exists.then(|| answer.incarnation())
}
None => None,
};
Some((selected, incarnation))
}
None if procfs_spelling != observed_path => {
let inherited = (!path.is_absolute()
&& call.dirfd() != libc::AT_FDCWD)
.then(|| {
guest
.thread_state()
.with_detfd(call.dirfd(), |detfd| {
detfd.procfs_reached()
})
.ok()
.flatten()
})
.flatten()
.and_then(|(_, incarnation)| incarnation);
Some((procfs_spelling.clone(), inherited))
}
None => None,
},
}
} else {
None
};
let (reached, link_itself) = if (reached.is_some() || link_itself)
&& !path.is_absolute()
&& !guest.config().sequentialize_threads
{
let held = Self::descriptor_kernel_link(guest, fd).await;
let below_proc = |name: &Path| {
use std::os::unix::ffi::OsStrExt;
name.starts_with("/proc")
&& !name.as_os_str().as_bytes().ends_with(b" (deleted)")
};
let reached = reached.filter(|_| held.as_deref().is_some_and(below_proc));
let link_itself = link_itself
&& held.as_deref().is_some_and(|name| {
name == Path::new("/proc/self")
|| name == Path::new("/proc/thread-self")
});
(reached, link_itself)
} else {
(reached, link_itself)
};
guest.thread_state().with_detfd(fd, |detfd| {
detfd.set_path(&recorded_path);
if let Some((reached, incarnation)) = reached.clone() {
detfd.set_procfs_reached(reached, incarnation);
}
if link_itself {
detfd.set_procfs_link_itself();
}
if let Some(procfs) = procfs.clone() {
detfd.set_procfs(procfs);
}
if let Some(provenance) = provenance {
detfd.set_sigalrm_phase1_provenance(provenance);
}
})?;
resource_release_all(guest).await;
Ok(fd as i64)
}
Err(e) => {
let e = if matches!(e, Error::Errno(Errno::EACCES | Errno::EPERM))
&& self
.refused_open_reaches_procfs_name_outside_level(guest, &call)
.await
{
Errno::ENOENT.into()
} else {
e
};
resource_release_all(guest).await;
Err(e)
}
}
}
pub async fn handle_close<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Close,
) -> Result<i64, Error> {
let fd = call.fd();
if let Ok(waited) = u32::try_from(fd)
&& let Some(refusal) = self
.refuse_close_of_waited_listener(guest, Sysno::close, waited..=waited)
.await
{
return refusal;
}
let channel_end = self.pipe_channel_end(guest, fd);
let lock_tracked = self.lock_tracked_descriptions(guest, fd..=fd);
let res = self.record_or_replay(guest, call).await;
let fd_was_released = !matches!(res, Err(Errno::EBADF) | Err(Errno::ERESTARTSYS));
if fd_was_released {
if let Some(open_file_id) = guest.thread_state_mut().remove_fd(fd) {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.report_lock_references(guest, lock_tracked).await;
if let Ok(fd) = u32::try_from(fd) {
crate::tool_global::descriptors_replaced(guest, fd, fd).await;
}
trace!("Closed {}", fd);
self.note_channel_end_closed(guest, channel_end).await;
}
res.map_err(Error::from)
}
pub async fn handle_close_range<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
) -> Result<i64, Error> {
let Syscall::Other(_, args) = call else {
unreachable!("close_range unexpectedly gained a typed variant")
};
let first = args.arg0 as u32;
let last = args.arg1 as u32;
let flags = args.arg2 as u32;
if flags != 0 {
return Err(Errno::ENOSYS.into());
}
if first <= last
&& let Some(refusal) = self
.refuse_close_of_waited_listener(guest, Sysno::close_range, first..=last)
.await
{
return refusal;
}
let channel_ends = self.pipe_channel_ends_in(guest, first, last);
let lock_tracked = match (i32::try_from(first), i32::try_from(last)) {
(Ok(first), Ok(last)) => self.lock_tracked_descriptions(guest, first..=last),
(Ok(first), Err(_)) => self.lock_tracked_descriptions(guest, first..=RawFd::MAX),
_ => Vec::new(),
};
let result = self.record_or_replay(guest, call).await;
if result.is_ok() {
let released = guest.thread_state_mut().remove_fd_range(first, last);
for open_file_id in released {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.report_lock_references(guest, lock_tracked).await;
crate::tool_global::descriptors_replaced(guest, first, last).await;
for end in channel_ends {
self.note_channel_end_closed(guest, Some(end)).await;
}
}
result.map_err(Error::from)
}
pub async fn handle_flock<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Flock,
) -> Result<i64, Error> {
let fd = call.fd();
let result = self.flock_through_the_kernel(guest, call).await;
self.refresh_description_locks(guest, fd, LockCall::Flock)
.await?;
result
}
async fn flock_through_the_kernel<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Flock,
) -> Result<i64, Error> {
const LOCK_NB: i32 = libc::LOCK_NB;
const MODE_MASK: i32 = libc::LOCK_SH | libc::LOCK_EX | libc::LOCK_UN;
let (fd, operation) = (call.fd(), call.operation());
let requested = operation & MODE_MASK;
let caller_wants_nonblocking = operation & LOCK_NB != 0;
let releasing = requested == libc::LOCK_UN;
let valid_operation = operation & !(MODE_MASK | LOCK_NB) == 0
&& matches!(requested, libc::LOCK_SH | libc::LOCK_EX | libc::LOCK_UN);
let dettid = guest.thread_state().dettid;
if !valid_operation {
return self
.record_or_replay(guest, call)
.await
.map_err(Error::from);
}
let known_held = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.known_flock_mode())
.unwrap_or(None);
if !caller_wants_nonblocking && !releasing && known_held.is_none() {
guest
.inject_with_retry(Syscall::Fcntl(
syscalls::Fcntl::new().with_fd(fd).with_cmd(F_GETFD),
))
.await?;
report_flock_refusal(&format!(
"[dtid {dettid}] blocking flock(fd={fd}, operation={operation:#x}) refused: \
this open file description existed before Detcore observed its lock state, \
so a nonblocking probe could destroy a lock that cannot be restored. \
{FLOCK_REFUSAL_ADVICE}"
));
return self
.refuse_unserviceable_operation(guest, Sysno::flock, Errno::ENOLCK)
.await;
}
let held = known_held.flatten();
let probe_operation = if releasing {
operation
} else {
operation | LOCK_NB
};
let result = self
.record_or_replay(guest, call.with_operation(probe_operation))
.await;
let refusal = if result.is_err() {
guest.take_unsupported_refusal()
} else {
None
};
if let Some(refusal) = refusal {
let message = format!(
"[dtid {dettid}] flock(fd={fd}, operation={operation:#x}) refused by the backend: {}. \
No lock was taken or released.",
refusal.diagnostic
);
report_flock_refusal(&message);
if !self.cfg.panic_on_unsupported_syscalls {
crate::tool_global::report_unsupported_syscall(guest, Sysno::flock).await;
}
return self
.refuse_unserviceable_operation_because(
guest,
Sysno::flock,
Errno::ENOLCK,
refusal.diagnostic,
)
.await;
}
match result {
Ok(value) => {
let granted = if releasing { None } else { Some(requested) };
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_flock_mode(granted));
trace!(
"flock(fd={}, operation={:#x}) served, open file now holds {:?}",
fd, operation, granted
);
Ok(value)
}
Err(Errno::EWOULDBLOCK) if caller_wants_nonblocking => {
if held.is_some_and(|held| held != requested) {
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_flock_mode(None));
}
trace!("flock(fd={}, operation={:#x}) would block", fd, operation);
Err(Errno::EWOULDBLOCK.into())
}
Err(Errno::EWOULDBLOCK) => {
if let Some(previous) = held.filter(|previous| *previous != requested) {
let restore = call.with_operation(previous | LOCK_NB);
match self.record_or_replay(guest, restore).await {
Ok(_) => {
warn!(
"[dtid {dettid}] contended blocking flock(fd={fd}, \
operation={operation:#x}) refused; restored this open file's \
prior {previous:#x} lock, which Linux's non-atomic conversion \
had dropped. The guest holds exactly what it held before the \
call."
);
}
Err(err) => {
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_flock_mode(None));
error!(
"[dtid {dettid}] contended blocking flock(fd={fd}, \
operation={operation:#x}) refused, AND this open file's prior \
{previous:#x} lock could not be restored ({err}). Linux's \
non-atomic conversion dropped it and something outside this \
container took it in the interval. The guest has lost a lock \
it held; treat any mutual exclusion it was protecting as \
broken."
);
}
}
}
report_flock_refusal(&format!(
"[dtid {dettid}] blocking flock(fd={fd}, operation={operation:#x}) is \
contended, and Detcore cannot yet park a thread on a file lock \
deterministically. Refusing rather than granting a lock another guest \
holds. {FLOCK_REFUSAL_ADVICE}"
));
self.refuse_unserviceable_operation(guest, Sysno::flock, Errno::ENOLCK)
.await
}
Err(err) => {
trace!(
"flock(fd={}, operation={:#x}) refused: {}",
fd, operation, err
);
Err(err.into())
}
}
}
async fn snapshot_procfs<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
) -> Result<Vec<u8>, Error> {
match guest
.inject_with_retry(Syscall::Lseek(
syscalls::Lseek::new()
.with_fd(call.fd())
.with_offset(0)
.with_whence(Whence::SEEK_SET),
))
.await
{
Ok(_) => {}
Err(Errno::ESPIPE) => {}
Err(err) => return Err(err.into()),
}
let (lists_address_space, lists_locks) =
guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.procfs_lists_address_space(),
detfd.procfs_lists_locks(),
)
})?;
if lists_address_space {
self.capture_procfs_on_stack(guest, call, lists_locks).await
} else {
self.capture_procfs_in_mapping(guest, call, lists_locks)
.await
}
}
async fn capture_procfs_in_mapping<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
lists_locks: bool,
) -> Result<Vec<u8>, Error> {
const CAPTURE_CHUNK_BYTES: usize = 64 * 1024;
let mapped = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(CAPTURE_CHUNK_BYTES)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await?;
let mapping = usize::try_from(mapped)
.ok()
.and_then(AddrMut::<u8>::from_raw)
.ok_or(Errno::EFAULT)?;
let result = self
.drain_procfs(guest, call, mapping, CAPTURE_CHUNK_BYTES, lists_locks)
.await;
guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(Addr::from(mapping).cast()))
.with_len(CAPTURE_CHUNK_BYTES),
))
.await?;
result
}
async fn capture_procfs_on_stack<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
lists_locks: bool,
) -> Result<Vec<u8>, Error> {
const CAPTURE_CHUNK_BYTES: usize = 512;
let mut original = [0_u8; CAPTURE_CHUNK_BYTES];
{
let mut stack = guest.stack().await;
let scratch = stack.reserve::<[u8; CAPTURE_CHUNK_BYTES]>().cast::<u8>();
if save_procfs_scratch(&mut guest.memory(), scratch, &mut original)
&& let Ok(guard) = stack.commit()
{
let result = self
.drain_procfs(guest, call, scratch, CAPTURE_CHUNK_BYTES, lists_locks)
.await;
guest.memory().write_exact(scratch, &original)?;
drop(guard);
return result;
}
}
let buffer = call.buf().ok_or(Errno::EFAULT)?;
for chunk in [call.len().min(CAPTURE_CHUNK_BYTES), 1] {
let original = &mut original[..chunk];
if save_procfs_scratch(&mut guest.memory(), buffer, original) {
let result = self
.drain_procfs(guest, call, buffer, chunk, lists_locks)
.await;
guest.memory().write_exact(buffer, original)?;
return result;
}
}
Err(Errno::EFAULT.into())
}
async fn drain_procfs<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
scratch: AddrMut<'_, u8>,
chunk: usize,
lists_locks: bool,
) -> Result<Vec<u8>, Error> {
const MAX_SNAPSHOT_BYTES: usize = 16 * 1024 * 1024;
let capture = call.with_buf(Some(scratch)).with_len(chunk);
let mut contents = Vec::new();
let mut reads = Vec::new();
loop {
let bytes_read = self.record_or_replay(guest, capture).await? as usize;
if bytes_read == 0 {
break;
}
if contents.len() + bytes_read > MAX_SNAPSHOT_BYTES {
return Err(Errno::EFBIG.into());
}
let start = contents.len();
contents.resize(start + bytes_read, 0);
read_guest_exact(&guest.memory(), scratch, &mut contents[start..])?;
reads.push(bytes_read);
}
if lists_locks {
let kept = crate::procfs::locks::locks_capture_kept_bytes(&reads, chunk);
if kept < contents.len() {
tracing::debug!(
"[detcore] /proc/locks capture: dropped {} bytes that reads after the end \
of the kernel's list returned (reads {:?})",
contents.len() - kept,
reads
);
contents.truncate(kept);
}
}
Ok(contents)
}
async fn procfs_directory_named_for<G: Guest<Self>>(
guest: &mut G,
fd: RawFd,
) -> Option<PathBuf> {
let named = Self::descriptor_kernel_link(guest, fd).await?;
procfs_directory_link(&named).then_some(named)
}
async fn descriptor_kernel_link<G: Guest<Self>>(guest: &mut G, fd: RawFd) -> Option<PathBuf> {
const LINK_CAPACITY: usize = 40;
const TARGET_CAPACITY: usize = 256;
let mut stack = guest.stack().await;
let link = stack.push(rendered_procfs::c_string::<LINK_CAPACITY>(
format!("/proc/thread-self/fd/{fd}").as_bytes(),
));
let target = stack.reserve::<[u8; TARGET_CAPACITY]>();
let stack_guard = stack.commit().ok()?;
let length = guest
.inject(
syscalls::Readlinkat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(PathPtr::from_ptr(link.as_raw() as *const libc::c_char))
.with_buf(Some(target.cast::<libc::c_char>()))
.with_buf_len(TARGET_CAPACITY),
)
.await;
let bytes = match length.map(|length| length as usize) {
Ok(length) if length < TARGET_CAPACITY => {
let mut bytes = vec![0; length];
guest
.memory()
.read_exact(target.cast::<u8>(), &mut bytes)
.ok()
.map(|()| bytes)
}
_ => None,
};
drop(stack_guard);
Some(PathBuf::from(
<std::ffi::OsString as std::os::unix::ffi::OsStringExt>::from_vec(bytes?),
))
}
async fn recorded_open_path<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<Option<PathBuf>, Error> {
const LINK_CAPACITY: usize = 32;
const TARGET_CAPACITY: usize = 256;
let link_name = rendered_procfs::c_string::<LINK_CAPACITY>(
format!("/proc/thread-self/fd/{fd}").as_bytes(),
);
let mut stack = guest.stack().await;
let link = stack.push(link_name);
let target = stack.reserve::<[u8; TARGET_CAPACITY]>();
let bytes = match stack.commit() {
Ok(stack_guard) => {
let bytes = self
.recorded_readlink(guest, link.as_raw(), target.as_raw(), TARGET_CAPACITY)
.await;
drop(stack_guard);
bytes
}
Err(_) => {
info!(
"Guest stack scratch cannot hold the link of fd {}; using a transient page \
instead.",
fd
);
let len = LINK_CAPACITY + TARGET_CAPACITY;
let mapped = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(len)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await;
let Some(page) = mapped
.ok()
.and_then(|mapped| usize::try_from(mapped).ok())
.and_then(AddrMut::<u8>::from_raw)
else {
return Ok(None);
};
let bytes = if guest.memory().write_exact(page, &link_name).is_ok() {
self.recorded_readlink(
guest,
page.as_raw(),
page.as_raw() + LINK_CAPACITY,
TARGET_CAPACITY,
)
.await
} else {
None
};
if let Err(errno) = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(page.cast::<libc::c_void>().into()))
.with_len(len),
))
.await
{
warn!(
"[detcore] could not unmap the transient link page: {}",
errno
);
}
bytes
}
};
Ok(bytes.and_then(|bytes| {
let path = PathBuf::from(
<std::ffi::OsString as std::os::unix::ffi::OsStringExt>::from_vec(bytes),
);
path.is_absolute().then_some(path)
}))
}
async fn recorded_readlink<G: Guest<Self>>(
&self,
guest: &mut G,
link: usize,
target: usize,
capacity: usize,
) -> Option<Vec<u8>> {
let target = AddrMut::<u8>::from_raw(target)?;
let length = self
.record_or_replay(
guest,
syscalls::Readlink::new()
.with_path(PathPtr::from_ptr(link as *const libc::c_char))
.with_buf(Some(target.cast::<libc::c_char>()))
.with_bufsize(capacity),
)
.await
.ok()?;
let length = usize::try_from(length)
.ok()
.filter(|length| *length < capacity)?;
let mut bytes = vec![0; length];
guest.memory().read_exact(target, &mut bytes).ok()?;
Some(bytes)
}
async fn initialize_procfs_snapshot<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
) -> Result<(), Error> {
let maps_target = if guest.runtime_private_memory_regions().is_some()
&& guest
.thread_state()
.with_detfd(call.fd(), |fd| fd.procfs_is_maps())?
{
if !guest.config().sequentialize_threads {
return Err(Error::Tool(anyhow::anyhow!(
"runtime-private maps view unavailable: capture is not sequentialized"
)));
}
let target = guest
.thread_state()
.with_detfd(call.fd(), |fd| fd.procfs_maps_target())?
.ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"runtime-private maps view unavailable: opened target image is unbound"
))
})?;
if !guest.runtime_private_memory_is_current(&target.private) {
return Err(Error::Tool(anyhow::anyhow!(
"runtime-private maps view unavailable: target ownership retired"
)));
}
Some(target)
} else {
None
};
let template = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_rendering_template())?;
let mount_table = self.mount_table_snapshot(guest, call.fd())?;
let raw_contents = match template {
Some(_)
if !can_read(
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.status_flags())?,
) =>
{
return Err(Errno::EBADF.into());
}
Some(template) => {
let position = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_position())?
.map_or(0, |(offset, _)| offset);
if position == 0 {
self.require_rendered_task(guest, call.fd()).await?;
}
mount_table.unwrap_or_else(|| template.to_vec())
}
None if let Some(table) = mount_table => {
if !can_read(
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.status_flags())?,
) {
return Err(Errno::EBADF.into());
}
table
}
None => self.snapshot_procfs(guest, call).await?,
};
let raw_contents = if let Some(target) = maps_target {
if !guest.runtime_private_memory_is_current(&target.private) {
return Err(Error::Tool(anyhow::anyhow!(
"runtime-private maps view unavailable: target ownership changed during capture"
)));
}
crate::procfs::private_maps::project(&raw_contents, &target.private.regions).map_err(
|reason| {
Error::Tool(anyhow::anyhow!(
"runtime-private maps view unavailable: {reason}"
))
},
)?
} else {
raw_contents
};
let contents = if guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_needs_mountinfo_identities())?
{
crate::procfs::exclude_ephemeral_host_seed_mounts(&raw_contents)
} else {
raw_contents
};
let held = guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.procfs_kernel_numbers_held(&contents)
})?;
let path = if guest.config().backend.tool_shares_guest_descriptor_table {
std::fs::read_link(format!("/proc/thread-self/fd/{}", call.fd())).ok()
} else {
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.path())?
};
let init = path.is_some_and(|path| crate::procfs::ids::names_init(&path));
let held = if init { Vec::new() } else { held };
if let Some(numbers) = Self::guest_procfs_numbers(guest, &held).await {
guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.set_procfs_guest_numbers(numbers.clone())
})?;
}
let virtual_uptime_seconds = self.calculate_procfs_uptime(guest).await?;
let virtual_uptime_seconds = match guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd
.procfs_rendered_at_first_read()
.then(|| detfd.procfs_rendered_path())
.flatten()
})? {
Some(path) => {
self.first_read_uptime(guest, call.fd(), path, virtual_uptime_seconds)
.await
}
None => virtual_uptime_seconds,
};
let needs_boot_time = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_needs_boot_time())?;
let virtual_boot_time_seconds = needs_boot_time
.then(|| self.calculate_procfs_boot_time())
.transpose()?;
let virtual_realtime_seconds = i64::try_from(thread_observe_time(guest).await.as_secs())
.map_err(|_| Errno::EOVERFLOW)?;
let virtual_pid = guest.inject(syscalls::Getpid::new()).await? as i32;
let virtual_ppid = guest.inject(syscalls::Getppid::new()).await? as i32;
let virtual_pty_count = guest.thread_state().count_open_files_at_paths(&[
std::path::Path::new("/dev/ptmx"),
std::path::Path::new("/dev/pts/ptmx"),
]);
let target_fd = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_target_fd())?;
if let Some(target_fd) = target_fd {
self.adopt_rendered_procfs_position(guest, target_fd)
.await?;
}
let rendered_target = match target_fd {
Some(target_fd) => guest
.thread_state()
.with_detfd(target_fd, |detfd| {
detfd.procfs_rendered_path().map(|path| {
(
path,
detfd.procfs_position().map_or(0, |(offset, _)| offset),
)
})
})
.ok()
.flatten(),
None => None,
};
let contents = match rendered_target {
Some((_, offset)) => format!(
"pos:\t{offset}\nflags:\t0\nmnt_id:\t{}\nino:\t0\n",
rendered_procfs::guest_procfs_mount_id()?
)
.into_bytes(),
None => contents,
};
let fdinfo_identity = if let Some(target_fd) = target_fd {
let (cached_stat, logical_flags, open_file_id, fd_type, inode_override) =
guest.thread_state().with_detfd(target_fd, |detfd| {
(
detfd.stat(),
detfd.status_flags(),
detfd.open_file_id(),
detfd.ty(),
deterministic_stdio_inode_for_resource(target_fd, detfd.resource()),
)
})?;
let stat = match cached_stat {
Some(stat) => stat,
None => DetStat::from(self.inject_fstat(guest, target_fd).await?),
};
let virtual_inode = match inode_override {
Some(inode) => inode,
None if let Some((path, _)) = rendered_target => {
DetInode::mint(procfs_inode::rendered_inode(path))
}
None => {
let procfs =
Self::procfs_entry(guest, &stat, StatTarget::Descriptor(target_fd)).await;
let files = self.rendered_files(guest);
if let Some(path) = rendered_entry(&procfs, &stat, guest.config(), files) {
DetInode::mint(procfs_inode::rendered_inode(path))
} else {
determinize_inode_observing_mtime(
guest,
stat.raw_inode(),
procfs.name(stat.dev),
ObservedMtime::Unobserved,
InodeSighting::Descriptor,
)
.await
.0
}
}
};
let raw_mount_id =
detcore_model::procfs::parse_fdinfo_mount_id(&contents).ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"kernel returned malformed /proc/*/fdinfo without one numeric mnt_id"
))
})?;
let has_configured_mount_ids = guest.config().mountinfo_mount_ids_captured;
let virtual_mount_id = if raw_mount_id == 0 {
0
} else if !has_configured_mount_ids {
let mountinfo_path = format!("/proc/{}/mountinfo", guest.pid().as_raw());
let mountinfo_contents = std::fs::read(&mountinfo_path).map_err(|error| {
Error::Tool(anyhow::anyhow!(
"failed to read {mountinfo_path} while validating fdinfo mnt_id: {error}"
))
})?;
let mountinfo_contents =
crate::procfs::exclude_ephemeral_host_seed_mounts(&mountinfo_contents);
let mountinfo_rows =
crate::procfs::parse_mountinfo(&mountinfo_contents).ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"kernel returned malformed {mountinfo_path} while validating fdinfo mnt_id"
))
})?;
let snapshot = MountInfoSnapshot::new(
mountinfo_rows,
&[],
false,
BTreeMap::new(),
BTreeMap::new(),
)
.ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"{mountinfo_path} failed strict identity validation for fdinfo"
))
})?;
determinize_mount_id(guest, raw_mount_id, Some(snapshot.raw_mount_id_order()))
.await
.ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"mountinfo mount-ID order changed after the identity snapshot while resolving fdinfo mnt_id {raw_mount_id} for {fd_type:?} from {mountinfo_path}"
))
})?
} else {
let raw_mount_id = self.shown_mount_id(guest, raw_mount_id);
determinize_mount_id(guest, raw_mount_id, None)
.await
.ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"recorded mount identity provenance was invalid while resolving fdinfo mnt_id {raw_mount_id} for {fd_type:?}"
))
})?
};
Some((
virtual_inode.as_raw(),
logical_flags,
open_file_id.deterministic_socket_cookie(),
virtual_mount_id,
))
} else {
None
};
let (is_cpuinfo, placeholder) = guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.procfs_is_cpuinfo(),
detfd.procfs_rendered_path().is_some(),
)
})?;
let virtual_cpuinfo = (is_cpuinfo && (placeholder || self.rendered_files(guest).cpuinfo))
.then(|| self.virtual_cpuid().cpuinfo());
let needs_random_uuid = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_needs_random_uuid())?;
let random_uuid =
needs_random_uuid.then(|| guest.thread_state_mut().thread_prng().random::<[u8; 16]>());
let needs_mapping_identities = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_needs_mapping_identities())?;
let mut mapping_identities: BTreeMap<(u64, u64), (u64, u64)> = BTreeMap::new();
if needs_mapping_identities {
let mut stdio_by_raw_inode: BTreeMap<RawInode, DetInode> = BTreeMap::new();
for fd in libc::STDIN_FILENO..=libc::STDERR_FILENO {
let cached = guest
.thread_state()
.with_detfd(fd, |detfd| {
let inode = deterministic_stdio_inode_for_resource(fd, detfd.resource())?;
detfd.stat().map(|stat| (stat.raw_inode(), inode))
})
.ok()
.flatten();
if let Some((raw, det)) = cached {
stdio_by_raw_inode.entry(raw).or_insert(det);
}
}
let raw_pairs: Vec<(u64, u64)> = String::from_utf8_lossy(&contents)
.lines()
.filter_map(crate::procfs::mapping_header_identity)
.collect();
let pooled = determinize_mapping_inodes(
guest,
raw_pairs
.iter()
.map(|&(raw_dev, raw_inode)| RawInode::new(raw_dev, raw_inode))
.collect(),
)
.await;
for (&(raw_dev, raw_inode), pooled) in raw_pairs.iter().zip(pooled) {
if mapping_identities.contains_key(&(raw_dev, raw_inode)) {
continue;
}
let det_inode = stdio_by_raw_inode
.get(&RawInode::new(raw_dev, raw_inode))
.copied()
.unwrap_or(pooled);
let det_dev = determinize_device(guest, raw_dev).await;
mapping_identities.insert((raw_dev, raw_inode), (det_dev, det_inode.as_raw()));
}
}
let mountinfo = if guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_needs_mountinfo_identities())?
{
let mut rows = crate::procfs::parse_mountinfo(&contents).ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"kernel returned malformed /proc/*/mountinfo"
))
})?;
let mut device_rewrites = BTreeMap::new();
for &(mountinfo_device, metadata_device) in &guest.config().mountinfo_device_rewrites {
if device_rewrites
.insert(mountinfo_device, metadata_device)
.is_some()
{
return Err(Error::Tool(anyhow::anyhow!(
"duplicate proven mountinfo device rewrite for raw device {mountinfo_device}"
)));
}
}
for row in &mut rows {
if let Some(metadata_device) = device_rewrites.get(&row.raw_device) {
row.raw_device = *metadata_device;
}
}
let mut raw_devices = Vec::new();
let mut seen_devices = BTreeSet::new();
for row in &rows {
if seen_devices.insert(row.raw_device) {
raw_devices.push(row.raw_device);
}
}
let mut devices = BTreeMap::new();
let virtualize_metadata = guest.config().virtualize_metadata;
if virtualize_metadata {
for raw in raw_devices {
devices.insert(raw, determinize_device(guest, raw).await);
}
}
let mut root_rewrites = BTreeMap::new();
for rewrite in &guest.config().mountinfo_root_rewrites {
if root_rewrites
.insert(rewrite.raw_mount_id, rewrite.clone())
.is_some()
{
return Err(Error::Tool(anyhow::anyhow!(
"duplicate proven mountinfo root rewrite for mount ID {}",
rewrite.raw_mount_id
)));
}
}
let mut snapshot = MountInfoSnapshot::new(
rows,
if guest.config().mountinfo_mount_ids_captured {
&guest.config().mountinfo_mount_ids
} else {
&[]
},
virtualize_metadata,
devices,
root_rewrites,
)
.ok_or_else(|| {
Error::Tool(anyhow::anyhow!(
"mountinfo snapshot failed strict identity validation"
))
})?;
let observation_order = snapshot.raw_mount_id_observation_order();
let Some(virtual_ids) = resolve_mountinfo_identities(
guest,
snapshot.raw_mount_id_order(),
observation_order.clone(),
)
.await
else {
return Err(Error::Tool(anyhow::anyhow!(
"mountinfo mount-ID order changed after the run-global identity snapshot"
)));
};
if !snapshot.use_run_mount_ids(&observation_order, &virtual_ids) {
return Err(Error::Tool(anyhow::anyhow!(
"run-global mount identities do not cover this mountinfo snapshot"
)));
}
Some(snapshot)
} else {
None
};
let lock_rows_kept = if guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_lists_locks())?
{
match crate::procfs::locks::lock_rows(&contents) {
Some(rows) => match crate::tool_global::guest_lock_rows(guest, rows).await {
Ok(kept) => Some(kept),
Err(reason) => {
let reason = format!(
"/proc/locks: {reason}; that description's rows cannot be told \
from another process's"
);
self.refuse_lock_bookkeeping(guest, reason).await
}
},
None => None,
}
} else {
None
};
let machine = crate::machine::MachineDescription::of(guest.config());
let mask_thread = guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.procfs_status_mask_thread(&contents)
})?;
let published_sigblk = match mask_thread {
Some(thread) if crate::scheduler::discarded_at_send::records(guest.config()) => {
crate::tool_global::published_guest_sigmask(guest, DetTid::from_raw(thread)).await
}
_ => None,
};
guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.initialize_procfs(
contents.clone(),
ProcfsSnapshotContext {
mapping_identities: mapping_identities.clone(),
mountinfo: mountinfo.clone(),
virtual_uptime_seconds,
virtual_boot_time_seconds,
virtual_realtime_seconds,
virtual_pid,
virtual_ppid,
virtual_pty_count,
fdinfo_identity,
random_uuid,
virtual_cpuinfo: virtual_cpuinfo.clone(),
machine: machine.clone(),
published_sigblk,
lock_rows_kept: lock_rows_kept.clone(),
},
);
})?;
Ok(())
}
fn mount_table_snapshot<G: Guest<Self>>(
&self,
guest: &G,
fd: RawFd,
) -> Result<Option<Vec<u8>>, Errno> {
let Some(table) = guest.config().container_mount_table.as_ref() else {
return Ok(None);
};
let (rendering, rendered, pinned) = guest.thread_state().with_detfd(fd, |detfd| {
(
detfd.procfs_mount_table_rendering(),
detfd.procfs_rendered_path().is_some(),
detfd.procfs_pinned_mount_view(),
)
})?;
let Some(rendering) = rendering else {
return Ok(None);
};
let kernel_view = !rendered
&& pinned.unwrap_or_else(|| {
guest
.thread_state()
.changed_root
.load(std::sync::atomic::Ordering::SeqCst)
});
if kernel_view {
return Ok(None);
}
Ok(Some(match rendering {
crate::procfs::MountTableRendering::Mountinfo => table.mountinfo(),
crate::procfs::MountTableRendering::Mounts => {
table.mounts(&guest.config().mountinfo_root_rewrites)
}
}))
}
async fn mount_view_is_kernel<G: Guest<Self>>(&self, guest: &mut G, file: &ProcfsFile) -> bool {
let Some((pid, tid)) = self.procfs_caller_ids(guest) else {
return true;
};
let mut bound = file.clone();
bound.bind_task(pid, tid);
match bound.bound_task() {
Some(task) => {
crate::tool_global::root_changed(
guest,
detcore_model::pid::DetPid::from_raw(task.thread.unwrap_or(task.process)),
)
.await
}
None => true,
}
}
pub(crate) fn shown_mount_id<G: Guest<Self>>(&self, guest: &G, raw_mount_id: u64) -> u64 {
match guest.config().container_mount_table.as_ref() {
Some(table)
if !guest
.thread_state()
.changed_root
.load(std::sync::atomic::Ordering::SeqCst) =>
{
table.shown_mount_id(raw_mount_id)
}
_ => raw_mount_id,
}
}
async fn write_rendered_statx<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Statx,
stat: DetStat,
) -> Result<i64, Error> {
let statptr = call.statx().ok_or(Errno::EFAULT)?;
let mut statx: libc::statx = stat.into();
let raw_mount_id = rendered_procfs::guest_procfs_mount_id().ok();
let unique = statx_requested_mask(call) & STATX_MNT_ID_UNIQUE != 0;
self.fill_statx_mount_id(guest, &mut statx, raw_mount_id, unique)
.await;
guest.memory().write_value(statptr.0, &statx)?;
Ok(0)
}
async fn fill_statx_mount_id<G: Guest<Self>>(
&self,
guest: &mut G,
statx: &mut libc::statx,
raw_mount_id: Option<u64>,
unique: bool,
) {
let guest_mount_id = match raw_mount_id {
Some(raw_mount_id) if guest.config().mountinfo_mount_ids_captured => {
let raw_mount_id = self.shown_mount_id(guest, raw_mount_id);
determinize_mount_id(guest, raw_mount_id, None).await
}
_ => None,
};
let reported = match guest_mount_id {
Some(id) if unique => id
.checked_add(MNT_UNIQUE_ID_OFFSET)
.map(|id| (id, STATX_MNT_ID_UNIQUE)),
Some(id) => Some((id, libc::STATX_MNT_ID)),
None => None,
};
statx.stx_mask &= !(libc::STATX_MNT_ID | STATX_MNT_ID_UNIQUE);
match reported {
Some((id, bit)) => {
statx.stx_mnt_id = id;
statx.stx_mask |= bit;
}
None => statx.stx_mnt_id = 0,
}
}
pub async fn handle_read<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
return self
.read_timer_slack(guest, call.fd(), call.buf(), call.len())
.await;
}
if call.len() == 0 {
if let Ok(Some(status_flags)) = guest.thread_state().with_detfd(call.fd(), |detfd| {
(detfd.ty() == FdType::Rng).then(|| detfd.status_flags())
}) {
require_random_device_read_access(status_flags)?;
let limit =
crate::iovecs::UserAddressLimit::from_query(guest.user_address_limit())?;
limit.validate(&[crate::iovecs::ImportedIovec {
base: call.buf().map_or(0, |address| address.as_raw()),
len: 0,
}])?;
return Ok(0);
}
return self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
}
let (needs_procfs_snapshot, serves_procfs_snapshot, cannot_read) =
guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.procfs_needs_snapshot(),
detfd.procfs_serves_snapshot(),
!can_read(detfd.status_flags()),
)
})?;
if serves_procfs_snapshot && cannot_read {
return Err(Errno::EBADF.into());
}
if serves_procfs_snapshot {
validate_procfs_destination(
|| crate::iovecs::UserAddressLimit::from_query(guest.user_address_limit()),
call.buf(),
call.len(),
)?;
}
if needs_procfs_snapshot {
self.initialize_procfs_snapshot(guest, call).await?;
}
self.adopt_rendered_procfs_position(guest, call.fd())
.await?;
let procfs_preview = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.preview_procfs(call.len()))?;
if let Some((offset, bytes)) = procfs_preview {
let faults_on_a_short_copy = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_faults_on_a_short_copy())?;
let copied = copy_procfs_read(
&mut guest.memory(),
call.buf(),
&bytes,
faults_on_a_short_copy,
)?;
guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.commit_procfs_read(offset, copied);
})?;
self.sync_rendered_procfs_position(guest, call.fd()).await?;
return Ok(copied as i64);
}
self.fifo_polls_if_a_guest_holds_its_peer(guest, call.fd(), FifoPeer::Writer)
.await;
let (fd_type, physically_nonblocking, logically_nonblocking, resource, descriptor) =
guest.thread_state_mut().with_detfd(call.fd(), |detfd| {
(
detfd.ty(),
detfd.physically_nonblocking(),
detfd.is_nonblocking(),
detfd.resource(),
detfd.clone(),
)
})?;
if let Some(resource) = resource {
let mut request = guest.thread_state().mk_request(resource, Permission::R);
if should_tag_host_timed_internal_pipe_io(
guest.config().backend.internal_pipe_turns_are_host_timed,
fd_type,
physically_nonblocking,
logically_nonblocking,
) {
request.fyi(HOST_TIMED_INTERNAL_PIPE_IO_FYI);
}
resource_request(guest, request).await;
}
let res = match fd_type {
FdType::Rng => {
trace!("Read call RNG fd {}, simulating...", call.fd());
let status_flags = descriptor.status_flags();
descriptor
.with_random_device_stream(|offset| {
require_random_device_read_access(status_flags)?;
let remote_buf = call.buf().ok_or(Errno::EFAULT)?;
self.fill_random_device_bytes(guest, remote_buf, call.len(), offset)
})
.map(|n| n as i64)
}
FdType::Regular | FdType::Pipe if descriptor.inherited_external_read().is_some() => {
self.record_or_replay_blocking(guest, call.into()).await
}
FdType::Regular => {
if guest.config().deterministic_io {
self.deterministic_read(guest, call).await
} else {
Ok(self.record_or_replay(guest, call).await?)
}
}
FdType::Signalfd
if call.len() >= 2 * crate::syscalls::signal::SIGNALFD_RECORD
&& self.signalfd_reads_per_record(guest, call.fd()).await =>
{
self.read_signalfd_per_record(guest, call).await
}
FdType::Signalfd => self.read_signalfd(guest, call, true).await,
FdType::Timerfd => {
trace!("Possibly blocking read call on timerfd {}", call.fd());
crate::syscalls::timerfd::publish_expired(guest).await;
let result = self.execute_nonblockable_fd_syscall(guest, call).await;
crate::syscalls::timerfd::finish_read(guest, call.fd(), call.buf(), result)
}
FdType::Eventfd | FdType::Inotify => {
trace!(
"Possibly blocking read call on notification fd {}, type {:?}",
call.fd(),
fd_type
);
self.execute_nonblockable_fd_syscall(guest, call).await
}
FdType::Memfd | FdType::Pidfd | FdType::Userfaultfd | FdType::Epoll => {
trace!("Read call on unusual fd {}, type {:?}", call.fd(), fd_type);
Ok(self.record_or_replay(guest, call).await?)
}
FdType::Socket | FdType::Pipe => {
trace!(
"Possibly blocking read call on {:?} fd {}",
fd_type,
call.fd()
);
self.execute_nonblockable_fd_syscall(guest, call).await
}
};
if fd_type == FdType::Signalfd {
crate::tool_global::reconcile_alarm(guest).await;
}
resource_release_all(guest).await;
res
}
async fn read_signalfd<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
may_read_again: bool,
) -> Result<i64, Error> {
loop {
trace!("Possibly blocking read call on signalfd {}", call.fd());
let extents = [(call.buf().map_or(0, |buf| buf.as_raw()), call.len())];
let before =
crate::syscalls::signal::capture_signalfd_buffer(guest, &extents, call.len());
let result = self.execute_nonblockable_fd_syscall(guest, call).await;
match (result, call.buf()) {
(Ok(read), Some(buf))
if read > 0 && self.cfg.backend.reports_child_exit_publication =>
{
let Some(kept) = self
.reconcile_signalfd_records(guest, buf, read as usize, &before)
.await
else {
break self
.refuse_unrestorable_signalfd_record(guest, Sysno::read)
.await;
};
if self
.settle_faulted_signalfd_record(
guest,
call.fd(),
&extents,
Some(read as usize),
)
.await
{
break self
.refuse_faulted_signalfd_discard(guest, Sysno::read)
.await;
}
if kept > 0 {
break Ok(kept as i64);
}
if !may_read_again {
break Ok(0);
}
}
(Err(Error::Errno(Errno::EFAULT)), _) => {
if self
.settle_faulted_signalfd_record(guest, call.fd(), &extents, None)
.await
{
break self
.refuse_faulted_signalfd_discard(guest, Sysno::read)
.await;
}
break Err(Errno::EFAULT.into());
}
(result, _) => break result,
}
}
}
async fn signalfd_reads_per_record<G: Guest<Self>>(&self, guest: &mut G, fd: i32) -> bool {
use crate::scheduler::discarded_at_send::DiscardedSignalAnswer;
use crate::scheduler::discarded_at_send::DiscardedSignalControl;
if !crate::scheduler::discarded_at_send::records(guest.config()) {
return false;
}
let Some(mask) = crate::syscalls::signal::signalfd_mask(guest.pid().as_raw(), fd) else {
return false;
};
matches!(
crate::tool_global::discarded_signal(guest, DiscardedSignalControl::Queued).await,
DiscardedSignalAnswer::Bits { thread, process } if (thread | process) & mask != 0
)
}
async fn read_signalfd_per_record<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Read,
) -> Result<i64, Error> {
const RECORD: usize = crate::syscalls::signal::SIGNALFD_RECORD;
let Some(buf) = call.buf() else {
return self.read_signalfd(guest, call, true).await;
};
let mask = crate::syscalls::signal::signalfd_mask(guest.pid().as_raw(), call.fd());
let mut done = 0usize;
while done + RECORD <= call.len() {
if done > 0 {
let pending =
crate::syscalls::threads::read_kernel_signal_state(guest.pid(), guest.tid())
.map(|state| state.thread_pending | state.shared_pending)
.unwrap_or(0);
if mask.is_none_or(|mask| pending & mask == 0) {
break;
}
}
let at = AddrMut::<u8>::from_raw(buf.as_raw() + done);
let record = syscalls::Read::new()
.with_fd(call.fd())
.with_buf(at)
.with_len(RECORD);
match self.read_signalfd(guest, record, done == 0).await {
Ok(read) if read > 0 => done += read as usize,
Ok(read) if done == 0 => return Ok(read),
Ok(_) => {}
Err(error) if done == 0 => return Err(error),
Err(_) => break,
}
}
Ok(done as i64)
}
pub async fn handle_pread64<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Pread64,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
return self
.pread_timer_slack(guest, call.fd(), call.buf(), call.len(), call.offset())
.await;
}
if call.len() == 0 {
return self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
}
let offset = usize::try_from(call.offset()).map_err(|_| Errno::EINVAL)?;
let (needs_procfs_snapshot, serves_procfs_snapshot, cannot_read) =
guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.procfs_needs_snapshot(),
detfd.procfs_serves_snapshot(),
!can_read(detfd.status_flags()),
)
})?;
if serves_procfs_snapshot && cannot_read {
return Err(Errno::EBADF.into());
}
if serves_procfs_snapshot {
validate_procfs_destination(
|| crate::iovecs::UserAddressLimit::from_query(guest.user_address_limit()),
call.buf(),
call.len(),
)?;
}
if needs_procfs_snapshot {
let read = syscalls::Read::new()
.with_fd(call.fd())
.with_buf(call.buf())
.with_len(call.len());
self.initialize_procfs_snapshot(guest, read).await?;
} else if serves_procfs_snapshot
&& guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd
.procfs_position()
.is_some_and(|(position, _)| position != offset)
})?
{
self.require_rendered_task(guest, call.fd()).await?;
}
let procfs_bytes = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.take_procfs_at(offset, call.len()))?;
if let Some(bytes) = procfs_bytes {
let faults_on_a_short_copy = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_faults_on_a_short_copy())?;
let copied = copy_procfs_read(
&mut guest.memory(),
call.buf(),
&bytes,
faults_on_a_short_copy,
)?;
return Ok(copied as i64);
}
let (fd_type, resource) = guest
.thread_state_mut()
.with_detfd(call.fd(), |detfd| (detfd.ty(), detfd.resource()))?;
if let Some(resource) = resource {
let request = guest.thread_state().mk_request(resource, Permission::R);
resource_request(guest, request).await;
}
let res = match fd_type {
FdType::Rng => (|| -> Result<i64, Error> {
trace!("Pread64 call RNG fd {}, simulating...", call.fd());
let remote_buf = call.buf().ok_or(Errno::EFAULT)?;
let n =
self.fill_random_device_bytes(guest, remote_buf, call.len(), offset as u64)?;
Ok(n as i64)
})(),
FdType::Regular if guest.config().deterministic_io => {
self.deterministic_pread64(guest, call).await
}
_ => match self.record_or_replay(guest, call).await {
Ok(value) => Ok(value),
Err(error) => Err(error.into()),
},
};
resource_release_all(guest).await;
res
}
async fn is_seekable_directory<G: Guest<Self>>(
guest: &mut G,
fd: RawFd,
cached: Option<DetStat>,
) -> bool {
let Some(stat) = cached.filter(|stat| stat.mode & libc::S_IFMT == libc::S_IFDIR) else {
return false;
};
if procfs_inode::is_backend_procfs_device(&guest.config().backend, stat.dev, stat.blksize)
|| procfs_inode::unprovable_procfs_signature(
&guest.config().backend,
guest.thread_state().physical_tid,
stat.dev,
stat.blksize,
)
{
return false;
}
!Self::procfs_entry(guest, &stat, StatTarget::Descriptor(fd))
.await
.is_procfs()
}
pub async fn handle_lseek<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Lseek,
) -> Result<i64, Error> {
let timer_slack_binding = self.timer_slack_binding(guest, call.fd())?;
let directory_lock = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.directory_lock())?;
let _seeking = directory_lock.lock().await;
self.adopt_rendered_procfs_position(guest, call.fd())
.await?;
let (fd_type, status_flags, procfs_position, resource, directory_stream, host_order) =
guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.ty(),
detfd.status_flags(),
detfd.procfs_position(),
detfd.resource(),
detfd.has_directory_stream(),
detfd.directory_in_host_order(),
)
})?;
if fd_type == FdType::Rng {
return random_device_lseek_result(status_flags, call.whence()).map_err(Into::into);
}
if is_inherited_container_output(resource) {
return Err(Errno::ESPIPE.into());
}
if timer_slack_binding.is_some() && status_flags & libc::O_PATH != 0 {
return Err(Errno::EBADF.into());
}
if directory_stream {
let current = guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.with_directory_stream(|stream| stream.position())
})??;
let requested = i128::from(call.offset());
let position = match call.whence() {
Whence::SEEK_SET => requested,
Whence::SEEK_CUR => i128::from(current) + requested,
_ => return Err(Errno::EINVAL.into()),
};
let result = i64::try_from(position)
.ok()
.filter(|position| *position >= 0)
.ok_or(Errno::EINVAL)?;
let target = guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.with_directory_stream(|stream| {
stream.seek(result as u64);
stream.kernel_target()
})
})??;
self.move_directory_kernel_position(guest, call.fd() as RawFd, target)
.await;
return Ok(result);
}
let Some((current, snapshot_len)) = procfs_position else {
if guest.config().virtualize_metadata
&& status_flags & libc::O_PATH == 0
&& matches!(
call.whence(),
Whence::SEEK_END | Whence::SEEK_DATA | Whence::SEEK_HOLE
)
{
let cached = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.stat())?;
if Self::is_seekable_directory(guest, call.fd(), cached).await {
return Err(Errno::EINVAL.into());
}
}
let position = self.record_or_replay(guest, call).await?;
if host_order && position == 0 {
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.use_directory_stream())?;
}
return Ok(position);
};
if let Some(binding) = timer_slack_binding {
let requested = i128::from(call.offset());
let new_offset = match call.whence() {
Whence::SEEK_SET => requested,
Whence::SEEK_CUR => current as i128 + requested,
_ => return Err(Errno::EINVAL.into()),
};
let new_offset = usize::try_from(new_offset).map_err(|_| Errno::EINVAL)?;
let result = i64::try_from(new_offset).map_err(|_| Errno::EOVERFLOW)?;
if new_offset != 0 && new_offset != current {
self.require_current_timer_slack_target(guest, binding)
.await?;
}
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.set_procfs_offset(new_offset))?;
return Ok(result);
}
let files = self.rendered_files(guest);
let rendered = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_renderable_path(files))?;
if let Some(rendered) = rendered {
if status_flags & libc::O_PATH != 0 {
return Err(Errno::EBADF.into());
}
let seq_file = crate::procfs::rendered_path_is_seq_file(rendered);
let requested = i128::from(call.offset());
let new_offset = match call.whence() {
Whence::SEEK_SET => requested,
Whence::SEEK_CUR => current as i128 + requested,
_ if seq_file => return Err(Errno::EINVAL.into()),
Whence::SEEK_END => requested,
Whence::SEEK_DATA | Whence::SEEK_HOLE if requested >= 0 => {
return Err(Errno::ENXIO.into());
}
Whence::SEEK_DATA | Whence::SEEK_HOLE => requested,
_ => return Err(Errno::EINVAL.into()),
};
let new_offset = usize::try_from(new_offset).map_err(|_| Errno::EINVAL)?;
let result = i64::try_from(new_offset).map_err(|_| Errno::EOVERFLOW)?;
if new_offset != 0 && new_offset != current {
self.require_rendered_task(guest, call.fd()).await?;
}
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.seek_procfs(new_offset))?;
self.sync_rendered_procfs_position(guest, call.fd()).await?;
return Ok(result);
}
let Some(snapshot_len) = snapshot_len else {
let offset = guest.inject(Syscall::from(call)).await?;
let offset = usize::try_from(offset).map_err(|_| Errno::EINVAL)?;
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.set_procfs_offset(offset))?;
return Ok(offset as i64);
};
let seq_file = guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.procfs_seeks_only_from_start_or_position()
})?;
let requested = i128::from(call.offset());
let new_offset = match call.whence() {
Whence::SEEK_SET => requested,
Whence::SEEK_CUR => current as i128 + requested,
_ if seq_file => return Err(Errno::EINVAL.into()),
Whence::SEEK_END => snapshot_len as i128 + requested,
Whence::SEEK_DATA => {
if requested < 0 || requested >= snapshot_len as i128 {
return Err(Errno::ENXIO.into());
}
requested
}
Whence::SEEK_HOLE => {
if requested < 0 || requested >= snapshot_len as i128 {
return Err(Errno::ENXIO.into());
}
snapshot_len as i128
}
_ => return Err(Errno::EINVAL.into()),
};
let new_offset = usize::try_from(new_offset).map_err(|_| Errno::EINVAL)?;
let result = i64::try_from(new_offset).map_err(|_| Errno::EOVERFLOW)?;
guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.set_procfs_offset(new_offset))?;
self.sync_rendered_procfs_position(guest, call.fd()).await?;
Ok(result)
}
async fn deterministic_read<G: Guest<Self>>(
&self,
guest: &mut G,
mut call: syscalls::Read,
) -> Result<i64, Error> {
let mut total_read_bytes = 0;
let mut remaining_buf = call.len();
trace!(
"[detcore/det_io]: Requested read buffer size: {:?}",
remaining_buf
);
loop {
match guest.inject_with_retry(call).await {
Ok(res) => {
remaining_buf -= res as usize;
total_read_bytes += res;
trace!(
"[detcore/det_io]: Remaining read buffer size: {:?}",
remaining_buf
);
if res == 0 || remaining_buf == 0 {
break Ok(total_read_bytes);
}
let old_ptr = call.buf().unwrap().as_raw();
call = call
.with_len(remaining_buf)
.with_buf(AddrMut::<u8>::from_raw(old_ptr + res as usize));
}
Err(error) if total_read_bytes > 0 => {
trace!("[detcore/det_io]: returning {total_read_bytes} bytes before {error}");
break Ok(total_read_bytes);
}
Err(error) => break Err(error.into()),
}
}
}
async fn deterministic_pread64<G: Guest<Self>>(
&self,
guest: &mut G,
mut call: syscalls::Pread64,
) -> Result<i64, Error> {
let mut total_read_bytes = 0;
let mut remaining_buf = call.len();
trace!(
"[detcore/det_io]: Requested pread64 buffer size: {:?}",
remaining_buf
);
loop {
match guest.inject_with_retry(call).await {
Ok(res) => {
remaining_buf -= res as usize;
total_read_bytes += res;
trace!(
"[detcore/det_io]: Remaining pread64 buffer size: {:?}",
remaining_buf
);
if res == 0 || remaining_buf == 0 {
break Ok(total_read_bytes);
}
let old_ptr = call
.buf()
.expect("successful pread64 requires a valid guest buffer")
.as_raw();
let offset = call.offset().checked_add(res).ok_or(Errno::EOVERFLOW)?;
call = call
.with_len(remaining_buf)
.with_buf(AddrMut::<u8>::from_raw(old_ptr + res as usize))
.with_offset(offset);
}
Err(error) => break Err(error.into()),
}
}
}
pub async fn handle_sendfile<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Sendfile,
) -> Result<i64, Error> {
let in_type = guest
.thread_state()
.with_detfd(call.in_fd(), |detfd| detfd.ty())?;
let (out_type, out_resource, out_inode) =
guest.thread_state().with_detfd(call.out_fd(), |detfd| {
(
detfd.ty(),
detfd.resource(),
detfd.stat().map(|stat| stat.raw_inode()),
)
})?;
let in_is_procfs = guest
.thread_state()
.with_detfd(call.in_fd(), |detfd| detfd.procfs_position().is_some())?;
if in_is_procfs {
return Err(Errno::ENOSYS.into());
}
if !matches!(in_type, FdType::Regular | FdType::Memfd)
|| !matches!(out_type, FdType::Regular | FdType::Memfd)
{
return Err(Errno::ENOSYS.into());
}
let dettid = guest.thread_state().dettid;
let mut resources = Resources::new(dettid);
let out_resource = match out_resource {
Some(resource) => Some(resource),
None => match out_inode {
Some(raw_ino) => Some(ResourceID::FileContents(
determinize_inode(guest, raw_ino).await.0,
)),
None => None,
},
};
if let Some(resource) = out_resource {
resources.insert(resource, Permission::W);
}
resources.fyi("sendfile");
resource_request(guest, resources).await;
let result = self
.record_or_replay(guest, call)
.await
.map_err(Error::from);
if guest.config().virtualize_metadata && matches!(&result, Ok(copied) if *copied > 0) {
let inode = out_inode.expect("virtualized metadata requires stat data for sendfile");
touch_file(guest, inode).await;
}
resource_release_all(guest).await;
result
}
pub async fn handle_write<G: Guest<Self>>(
&self,
guest: &mut G,
mut call: syscalls::Write,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
return self
.write_timer_slack(guest, call.fd(), call.buf(), call.len())
.await;
}
if call.len() > 0 {
self.fifo_polls_if_a_guest_holds_its_peer(guest, call.fd(), FifoPeer::Reader)
.await;
}
let (
fd_type,
physically_nonblocking,
logically_nonblocking,
open_file_id,
resource,
raw_ino,
) = guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.ty(),
detfd.physically_nonblocking(),
detfd.is_nonblocking(),
detfd.open_file_id(),
detfd.resource(),
detfd.stat().map(|x| x.raw_inode()),
)
})?;
if guest.config().virtualize_metadata {
let r =
raw_ino.expect("Expect that when virtualize_metadata, DetFd's stat is populated!");
touch_file(guest, r).await;
}
if let Some(resource) = resource {
let container_output = crate::sigalrm_phase1::is_container_output(&resource);
let mut request = guest.thread_state().mk_request(resource, Permission::W);
if should_tag_host_timed_internal_pipe_io(
guest.config().backend.internal_pipe_turns_are_host_timed,
fd_type,
physically_nonblocking,
logically_nonblocking,
) {
request.fyi(HOST_TIMED_INTERNAL_PIPE_IO_FYI);
}
resource_request(guest, request).await;
if guest.thread_state().sigalrm_handled && container_output {
sigalrm_refuses(guest, SigalrmControl::UnadmittedStdioIo).await;
}
}
let res = if physically_nonblocking && fd_type == FdType::Pipe && !logically_nonblocking {
self.execute_blocking_pipe_write(guest, call, open_file_id)
.await
} else if physically_nonblocking
&& matches!(fd_type, FdType::Socket | FdType::Pipe | FdType::Eventfd)
{
self.execute_nonblockable_fd_syscall(guest, call).await
} else if guest.config().deterministic_io {
let mut total_written_bytes = 0;
let mut remaining_buf = call.len();
trace!(
"[detcore/det_io]: Requested write buffer size: {:?}",
remaining_buf
);
loop {
match self
.record_or_replay_preserving_tool_errors(guest, call)
.await
{
Ok(res) => {
remaining_buf -= res as usize;
total_written_bytes += res;
trace!(
"[detcore/det_io]: Remaining write buffer size: {:?}",
remaining_buf
);
if res == 0 || remaining_buf == 0 {
break Ok(total_written_bytes);
}
let old_ptr = call.buf().unwrap().as_raw();
call = call
.with_len(remaining_buf)
.with_buf(Addr::<u8>::from_raw(old_ptr + res as usize));
}
Err(error) => {
break finish_partial_record_or_replay_write(total_written_bytes, error);
}
}
}
} else {
self.record_or_replay_preserving_tool_errors(guest, call)
.await
};
resource_release_all(guest).await;
res
}
pub async fn handle_pwrite64<G: Guest<Self>>(
&self,
guest: &mut G,
mut call: syscalls::Pwrite64,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
return Err(if call.offset() < 0 {
Errno::EINVAL.into()
} else {
Errno::ESPIPE.into()
});
}
let (resource, raw_ino) = guest.thread_state().with_detfd(call.fd(), |detfd| {
(detfd.resource(), detfd.stat().map(|stat| stat.raw_inode()))
})?;
let resource = match resource {
Some(resource) => Some(resource),
None => match raw_ino {
Some(raw_ino) => Some(ResourceID::FileContents(
determinize_inode(guest, raw_ino).await.0,
)),
None => None,
},
};
if let Some(resource) = resource {
let request = guest.thread_state().mk_request(resource, Permission::W);
resource_request(guest, request).await;
}
let result = if guest.config().deterministic_io {
let mut total_written = 0_i64;
let mut remaining = call.len();
loop {
match self
.record_or_replay_preserving_tool_errors(guest, call)
.await
{
Ok(written) => {
let Ok(written) = usize::try_from(written) else {
break Err(Errno::EIO.into());
};
let Ok(written_i64) = i64::try_from(written) else {
break Err(Errno::EIO.into());
};
if written > remaining {
break Err(Errno::EIO.into());
}
remaining -= written;
let Some(next_total) = total_written.checked_add(written_i64) else {
break Err(Errno::EIO.into());
};
total_written = next_total;
if written == 0 || remaining == 0 {
break Ok(total_written);
}
let Some(old_buf) = call.buf() else {
break Err(Errno::EFAULT.into());
};
let Some(next_buf) = old_buf.as_raw().checked_add(written) else {
break Err(Errno::EFAULT.into());
};
let Some(next_offset) = call.offset().checked_add(written_i64) else {
break Err(Errno::EFBIG.into());
};
let Some(next_buf) = Addr::<u8>::from_raw(next_buf) else {
break Err(Errno::EFAULT.into());
};
call = call
.with_buf(Some(next_buf))
.with_len(remaining)
.with_offset(next_offset);
}
Err(error) => {
break finish_partial_record_or_replay_write(total_written, error);
}
}
}
} else {
self.record_or_replay_preserving_tool_errors(guest, call)
.await
};
if guest.config().virtualize_metadata && matches!(&result, Ok(written) if *written > 0) {
let inode = raw_ino.expect("virtualized metadata requires stat data for tracked fds");
touch_file(guest, inode).await;
}
resource_release_all(guest).await;
result
}
pub async fn handle_writev<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Writev,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
self.require_timer_slack_access(guest, call.fd(), true)?;
let iovecs = read_iovecs(&guest.memory(), call.iov(), call.len())?;
return self.writev_timer_slack(guest, call.fd(), iovecs, 0).await;
}
self.fifo_polls_if_a_guest_holds_its_peer(guest, call.fd(), FifoPeer::Reader)
.await;
let (
fd_type,
physically_nonblocking,
logically_nonblocking,
open_file_id,
resource,
raw_ino,
) = guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.ty(),
detfd.physically_nonblocking(),
detfd.is_nonblocking(),
detfd.open_file_id(),
detfd.resource(),
detfd.stat().map(|x| x.raw_inode()),
)
})?;
if let Some(resource) = resource {
let mut request = guest.thread_state().mk_request(resource, Permission::W);
if should_tag_host_timed_internal_pipe_io(
guest.config().backend.internal_pipe_turns_are_host_timed,
fd_type,
physically_nonblocking,
logically_nonblocking,
) {
request.fyi(HOST_TIMED_INTERNAL_PIPE_IO_FYI);
}
resource_request(guest, request).await;
}
let result = if physically_nonblocking && fd_type == FdType::Pipe && !logically_nonblocking
{
self.execute_blocking_pipe_writev(guest, call, open_file_id)
.await
} else if physically_nonblocking
&& matches!(fd_type, FdType::Socket | FdType::Pipe | FdType::Eventfd)
{
self.execute_nonblockable_fd_syscall(guest, call).await
} else {
self.record_or_replay_preserving_tool_errors(guest, call)
.await
};
if guest.config().virtualize_metadata && matches!(&result, Ok(written) if *written > 0) {
let inode =
raw_ino.expect("virtualized metadata requires stat data for every tracked fd");
touch_file(guest, inode).await;
}
resource_release_all(guest).await;
result
}
async fn vectored_signalfd_read<G: Guest<Self>, C>(
&self,
guest: &mut G,
sysno: Sysno,
call: C,
address: usize,
count: usize,
observed: &mut Option<Vec<crate::io_buffers::BufferExtent>>,
) -> Result<i64, Error>
where
C: Into<Syscall> + Copy,
{
const IOVEC: usize = std::mem::size_of::<libc::iovec>();
let fd = match call.into() {
Syscall::Readv(call) => call.fd(),
Syscall::Preadv2(call) => call.fd(),
_ => -1,
};
let count = crate::io_buffers::linux_iovec_count(count as u64);
if count > libc::UIO_MAXIOV as usize {
return self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
}
let mut raw = vec![0u8; count * IOVEC];
if count > 0 {
let read = AddrMut::<u8>::from_raw(address)
.is_some_and(|at| guest.memory().read_exact(at, &mut raw).is_ok())
|| {
use std::os::unix::fs::FileExt;
std::fs::File::open(format!("/proc/{}/mem", guest.tid().as_raw()))
.and_then(|mem| mem.read_exact_at(&mut raw, address as u64))
.is_ok()
};
if !read {
let maps = std::fs::read_to_string(format!("/proc/{}/maps", guest.tid().as_raw()));
if let Ok(maps) = &maps
&& !signalfd_range_is_mapped(maps, address, raw.len())
{
return self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
}
tracing::error!(
"[detcore, dtid {}] {} of a signalfd with its iovec array at {:#x} is not \
supported: the memory is mapped, but Hermit cannot read it to reconcile \
the SIGCHLD records (https://github.com/rrnewton/hermit/issues/3994)",
guest.thread_state().dettid,
sysno,
address,
);
return self
.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await;
}
}
let extents: Vec<(usize, usize)> = raw
.chunks(IOVEC)
.map(|iovec| {
let word = |at: usize| {
usize::from_ne_bytes(iovec[at..at + 8].try_into().expect("eight bytes"))
};
(word(0), word(8))
})
.collect();
let total: usize = extents.iter().map(|(_, len)| *len).sum();
if total >= 2 * crate::syscalls::signal::SIGNALFD_RECORD
&& self.signalfd_reads_per_record(guest, fd).await
{
tracing::error!(
"[detcore, dtid {}] {} of a signalfd while a signal it covers has a POSIX timer's entry queued behind another is not supported: Linux returns them one by one in its dequeue order, which Detcore produces only for read (https://github.com/rrnewton/hermit/issues/4262)",
guest.thread_state().dettid,
sysno,
);
return self
.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await;
}
loop {
let before =
crate::syscalls::signal::capture_signalfd_buffer(guest, &extents, usize::MAX);
let result = self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
match result {
Ok(read) if read > 0 => {
let Some(kept) = self
.reconcile_signalfd_extents(guest, &extents, read as usize, &before)
.await
else {
break self.refuse_unrestorable_signalfd_record(guest, sysno).await;
};
if self
.settle_faulted_signalfd_record(guest, fd, &extents, Some(read as usize))
.await
{
break self.refuse_faulted_signalfd_discard(guest, sysno).await;
}
if kept > 0 {
*observed = Some(
crate::syscalls::signal::signalfd_extent_pieces(&extents, kept)
.into_iter()
.map(|(addr, len)| crate::io_buffers::BufferExtent {
addr: addr as u64,
len: len as u64,
})
.collect(),
);
break Ok(kept as i64);
}
if let Some(at) = AddrMut::<u8>::from_raw(address)
&& guest.memory().write_exact(at, &raw).is_err()
{
break Err(Errno::EFAULT.into());
}
}
Err(Error::Errno(Errno::EFAULT)) => {
if self
.settle_faulted_signalfd_record(guest, fd, &extents, None)
.await
{
break self.refuse_faulted_signalfd_discard(guest, sysno).await;
}
break Err(Errno::EFAULT.into());
}
result => break result,
}
}
}
async fn settle_faulted_signalfd_record<G: Guest<Self>>(
&self,
guest: &mut G,
fd: i32,
extents: &[(usize, usize)],
read: Option<usize>,
) -> bool {
if !self.cfg.backend.reports_child_exit_publication || !guest.config().sequentialize_threads
{
return false;
}
match read {
None => {
let user_end = user_address_end();
if extents.iter().any(|(address, len)| {
address.checked_add(*len).is_none_or(|end| end > user_end)
}) {
return false;
}
}
Some(read) => {
let Some(next) = signalfd_next_record(extents, read) else {
return false;
};
let Ok(maps) =
std::fs::read_to_string(format!("/proc/{}/maps", guest.tid().as_raw()))
else {
return false;
};
if next
.iter()
.all(|(address, len)| signalfd_range_is_writable(&maps, *address, *len))
{
return false;
}
}
}
let mask = signalfd_sigmask(guest.pid().as_raw(), fd);
let lost_a_discarded_copy = {
use crate::scheduler::discarded_at_send::DiscardedSignalAnswer;
use crate::scheduler::discarded_at_send::DiscardedSignalControl;
use crate::scheduler::discarded_at_send::STANDARD_SIGNALS;
matches!(
crate::tool_global::discarded_signal(guest, DiscardedSignalControl::Bits).await,
DiscardedSignalAnswer::Bits { thread, process }
if (thread | process) & mask.unwrap_or(!0) & STANDARD_SIGNALS != 0
)
};
let sigchld = crate::syscalls::threads::kernel_sigset_bit(libc::SIGCHLD);
if mask.is_some_and(|mask| mask & sigchld == 0) {
return lost_a_discarded_copy;
}
let Ok(state) =
crate::syscalls::threads::read_thread_wait_signal_state(guest.pid(), guest.tid())
else {
return lost_a_discarded_copy;
};
let shared_pending = if read.is_none() && mask == Some(sigchld) {
false
} else {
state.shared_pending & sigchld != 0
};
crate::tool_global::child_exit_sigchld(
guest,
crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::WaitFaulted {
private_pending: state.thread_pending & sigchld != 0,
shared_pending,
},
)
.await;
lost_a_discarded_copy
}
async fn refuse_faulted_signalfd_discard<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
) -> Result<i64, Error> {
tracing::error!(
"[detcore, dtid {}] {} of a signalfd faulted copying out a record that may hold a \
signal Linux discarded when it was sent, which Linux would never have dequeued; \
Hermit cannot tell which copy was lost \
(https://github.com/rrnewton/hermit/issues/4293)",
guest.thread_state().dettid,
sysno,
);
self.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await
}
async fn refuse_unrestorable_signalfd_record<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
) -> Result<i64, Error> {
tracing::error!(
"[detcore, dtid {}] {} of a signalfd read a record Hermit drops, beyond the bytes \
captured before the read, so it cannot leave the caller's buffer as Linux would \
(https://github.com/rrnewton/hermit/issues/4293)",
guest.thread_state().dettid,
sysno,
);
self.refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
.await
}
pub async fn handle_readv<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Readv,
) -> Result<i64, Error> {
self.handle_readv_with_output(guest, call, &mut None).await
}
fn read_random_vectors<G: Guest<Self>>(
&self,
guest: &mut G,
detfd: &DetFd,
request: RandomVectoredRead,
rng_output: &mut Option<Vec<crate::io_buffers::BufferExtent>>,
) -> Result<i64, Error> {
require_random_device_read_access(detfd.status_flags())?;
let iovecs = crate::iovecs::import_read_iovecs(
&guest.memory(),
request.address,
request.count,
|| crate::iovecs::UserAddressLimit::from_query(guest.user_address_limit()),
)?;
let total = iovecs.iter().map(|iov| iov.len).sum();
validate_random_vector_read(request.offset, total, request.flags)?;
let written = if let Some(offset) = request.offset {
self.fill_random_device_iovecs(guest, &iovecs, offset)?
} else {
detfd.with_random_device_stream(|offset| {
self.fill_random_device_iovecs(guest, &iovecs, offset)
})?
};
if written > 0 && self.cfg.detlog_io_buffers && crate::detlog_observed!() {
*rng_output = Some(crate::io_buffers::rng_readv_extents(&iovecs, written)?);
}
Ok(written as i64)
}
pub(crate) async fn handle_readv_with_output<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Readv,
rng_output: &mut Option<Vec<crate::io_buffers::BufferExtent>>,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
self.require_timer_slack_access(guest, call.fd(), false)?;
let iovecs = read_iovecs(&guest.memory(), call.iov(), call.len())?;
return self
.readv_timer_slack(guest, call.fd(), iovecs, None, 0)
.await;
}
let files = self.rendered_files(guest);
if guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.procfs_renderable_path(files).is_some()
})? {
let address = call.iov().map_or(0, |address| address.as_raw());
return self
.readv_rendered_procfs(guest, call.fd(), address, call.len(), None, 0)
.await;
}
let is_procfs = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_position().is_some())?;
if is_procfs {
return Err(Errno::ENOSYS.into());
}
self.fifo_polls_if_a_guest_holds_its_peer(guest, call.fd(), FifoPeer::Writer)
.await;
let (fd_type, physically_nonblocking, logically_nonblocking, resource, detfd) =
guest.thread_state().with_detfd(call.fd(), |detfd| {
(
detfd.ty(),
detfd.physically_nonblocking(),
detfd.is_nonblocking(),
detfd.resource(),
detfd.clone(),
)
})?;
if let Some(resource) = resource {
let mut request = guest.thread_state().mk_request(resource, Permission::R);
if should_tag_host_timed_internal_pipe_io(
guest.config().backend.internal_pipe_turns_are_host_timed,
fd_type,
physically_nonblocking,
logically_nonblocking,
) {
request.fyi(HOST_TIMED_INTERNAL_PIPE_IO_FYI);
}
resource_request(guest, request).await;
}
let res = if fd_type == FdType::Rng {
self.read_random_vectors(
guest,
&detfd,
RandomVectoredRead {
address: call.iov().map_or(0, |addr| addr.as_raw()),
count: call.len(),
offset: None,
flags: 0,
},
rng_output,
)
} else if detfd.inherited_external_read().is_some() {
self.record_or_replay_blocking(guest, call.into()).await
} else if fd_type == FdType::Timerfd && crate::syscalls::timerfd::enabled(guest) {
crate::syscalls::timerfd::publish_expired(guest).await;
let result = self.execute_nonblockable_fd_syscall(guest, call).await;
crate::syscalls::timerfd::finish_readv(guest, call.fd(), call.iov(), call.len(), result)
} else if physically_nonblocking
&& matches!(fd_type, FdType::Socket | FdType::Pipe | FdType::Eventfd)
{
self.execute_nonblockable_fd_syscall(guest, call).await
} else if fd_type == FdType::Signalfd && self.cfg.backend.reports_child_exit_publication {
self.vectored_signalfd_read(
guest,
Sysno::readv,
call,
call.iov().map_or(0, |iov| iov.as_raw()),
call.len(),
rng_output,
)
.await
} else {
self.record_or_replay_preserving_tool_errors(guest, call)
.await
};
if fd_type == FdType::Signalfd {
crate::tool_global::reconcile_alarm(guest).await;
}
resource_release_all(guest).await;
res
}
pub async fn handle_preadv<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Preadv,
) -> Result<i64, Error> {
self.handle_preadv_with_output(guest, call, &mut None).await
}
pub(crate) async fn handle_preadv_with_output<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Preadv,
rng_output: &mut Option<Vec<crate::io_buffers::BufferExtent>>,
) -> Result<i64, Error> {
let offset = vectored_offset(call.pos_l(), call.pos_h());
if offset < 0 {
return Err(Errno::EINVAL.into());
}
if self.timer_slack_binding(guest, call.fd())?.is_some() {
self.require_timer_slack_access(guest, call.fd(), false)?;
let iovecs = read_iovecs(&guest.memory(), call.iov(), call.iov_len())?;
return self
.readv_timer_slack(guest, call.fd(), iovecs, Some(offset), 0)
.await;
}
let files = self.rendered_files(guest);
if guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.procfs_renderable_path(files).is_some()
})? {
let address = call.iov().map_or(0, |address| address.as_raw());
return self
.readv_rendered_procfs(guest, call.fd(), address, call.iov_len(), Some(offset), 0)
.await;
}
let is_procfs = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_position().is_some())?;
if is_procfs {
return Err(Errno::ENOSYS.into());
}
let detfd = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.clone())?;
if let Some(resource) = detfd.resource() {
let request = guest.thread_state().mk_request(resource, Permission::R);
resource_request(guest, request).await;
}
let res = if detfd.ty() == FdType::Rng {
self.read_random_vectors(
guest,
&detfd,
RandomVectoredRead {
address: call.iov().map_or(0, |addr| addr.as_raw()),
count: call.iov_len(),
offset: Some(offset as u64),
flags: 0,
},
rng_output,
)
} else {
self.record_or_replay_preserving_tool_errors(guest, call)
.await
};
resource_release_all(guest).await;
res
}
pub async fn handle_preadv2<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Preadv2,
) -> Result<i64, Error> {
self.handle_preadv2_with_output(guest, call, &mut None)
.await
}
pub(crate) async fn handle_preadv2_with_output<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Preadv2,
rng_output: &mut Option<Vec<crate::io_buffers::BufferExtent>>,
) -> Result<i64, Error> {
let offset = vectored_offset(call.pos_l(), call.pos_h());
if offset < -1 {
return Err(Errno::EINVAL.into());
}
if self.timer_slack_binding(guest, call.fd())?.is_some() {
self.require_timer_slack_access(guest, call.fd(), false)?;
let count = usize::try_from(call.iov_len()).map_err(|_| Errno::EINVAL)?;
let iovecs = read_iovecs(&guest.memory(), call.iov(), count)?;
return if offset == -1 {
self.readv_timer_slack(guest, call.fd(), iovecs, None, call.flags())
.await
} else {
self.readv_timer_slack(guest, call.fd(), iovecs, Some(offset), call.flags())
.await
};
}
let files = self.rendered_files(guest);
if guest.thread_state().with_detfd(call.fd(), |detfd| {
detfd.procfs_renderable_path(files).is_some()
})? {
let address = call.iov().map_or(0, |address| address.as_raw());
let offset = (offset != -1).then_some(offset);
return self
.readv_rendered_procfs(
guest,
call.fd(),
address,
call.iov_len() as usize,
offset,
call.flags(),
)
.await;
}
let is_procfs = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_position().is_some())?;
if is_procfs {
return Err(Errno::ENOSYS.into());
}
let detfd = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.clone())?;
if let Some(resource) = detfd.resource() {
let request = guest.thread_state().mk_request(resource, Permission::R);
resource_request(guest, request).await;
}
let res = if detfd.ty() == FdType::Rng {
self.read_random_vectors(
guest,
&detfd,
RandomVectoredRead {
address: call.iov().map_or(0, |addr| addr.as_raw()),
count: call.iov_len() as usize,
offset: (offset != -1).then_some(offset as u64),
flags: call.flags(),
},
rng_output,
)
} else if detfd.ty() == FdType::Signalfd
&& offset == -1
&& self.cfg.backend.reports_child_exit_publication
{
self.vectored_signalfd_read(
guest,
Sysno::preadv2,
call,
call.iov().map_or(0, |iov| iov.as_raw()),
usize::try_from(call.iov_len()).unwrap_or(0),
rng_output,
)
.await
} else {
self.record_or_replay_preserving_tool_errors(guest, call)
.await
};
if detfd.ty() == FdType::Signalfd {
crate::tool_global::reconcile_alarm(guest).await;
}
resource_release_all(guest).await;
res
}
pub async fn handle_pwritev<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Pwritev,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
let offset = vectored_offset(call.pos_l(), call.pos_h());
return if offset < 0 {
Err(Errno::EINVAL.into())
} else {
Err(Errno::ESPIPE.into())
};
}
let (resource, raw_ino) = guest.thread_state().with_detfd(call.fd(), |detfd| {
(detfd.resource(), detfd.stat().map(|stat| stat.raw_inode()))
})?;
let resource = match resource {
Some(resource) => Some(resource),
None => match raw_ino {
Some(raw_ino) => Some(ResourceID::FileContents(
determinize_inode(guest, raw_ino).await.0,
)),
None => None,
},
};
if let Some(resource) = resource {
let request = guest.thread_state().mk_request(resource, Permission::W);
resource_request(guest, request).await;
}
let result = self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
if guest.config().virtualize_metadata && matches!(&result, Ok(written) if *written > 0) {
let inode = raw_ino.expect("virtualized metadata requires stat data for tracked fds");
touch_file(guest, inode).await;
}
resource_release_all(guest).await;
result
}
pub async fn handle_pwritev2<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Pwritev2,
) -> Result<i64, Error> {
if self.timer_slack_binding(guest, call.fd())?.is_some() {
let offset = vectored_offset(call.pos_l(), call.pos_h());
if offset < -1 {
return Err(Errno::EINVAL.into());
}
if offset >= 0 {
return Err(Errno::ESPIPE.into());
}
self.require_timer_slack_access(guest, call.fd(), true)?;
let count = usize::try_from(call.iov_len()).map_err(|_| Errno::EINVAL)?;
let iovecs = read_iovecs(&guest.memory(), call.iov(), count)?;
return self
.writev_timer_slack(guest, call.fd(), iovecs, call.flags())
.await;
}
let (resource, raw_ino) = guest.thread_state().with_detfd(call.fd(), |detfd| {
(detfd.resource(), detfd.stat().map(|stat| stat.raw_inode()))
})?;
let resource = match resource {
Some(resource) => Some(resource),
None => match raw_ino {
Some(raw_ino) => Some(ResourceID::FileContents(
determinize_inode(guest, raw_ino).await.0,
)),
None => None,
},
};
if let Some(resource) = resource {
let request = guest.thread_state().mk_request(resource, Permission::W);
resource_request(guest, request).await;
}
let result = self
.record_or_replay_preserving_tool_errors(guest, call)
.await;
if guest.config().virtualize_metadata && matches!(&result, Ok(written) if *written > 0) {
let inode = raw_ino.expect("virtualized metadata requires stat data for tracked fds");
touch_file(guest, inode).await;
}
resource_release_all(guest).await;
result
}
pub async fn handle_mmap<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Mmap,
) -> Result<i64, Error> {
enum SharedBacking {
Anonymous,
File {
object: SharedMemoryObjectId,
offset: u64,
},
}
let backing = if call.flags().contains(MapFlags::MAP_SHARED) {
if call.fd() == -1 {
Some(SharedBacking::Anonymous)
} else {
let offset = u64::try_from(call.offset()).map_err(|_| Errno::EINVAL)?;
guest
.thread_state()
.with_detfd(call.fd(), |fd| {
let object = fd.stat().map_or_else(
|| SharedMemoryObjectId::OpenFile {
id: fd.open_file_id(),
},
|stat| SharedMemoryObjectId::File {
device: stat.dev,
inode: stat.inode,
},
);
SharedBacking::File { object, offset }
})
.ok()
}
} else {
None
};
let len = call.len();
let result = self.record_or_replay(guest, call).await?;
let start = usize::try_from(result).expect("a successful mmap must return an address");
guest.thread_state().unmap_memory(start, len);
match backing {
Some(SharedBacking::Anonymous) => {
guest.thread_state().map_shared_anonymous(start, len);
}
Some(SharedBacking::File { object, offset }) => {
guest
.thread_state()
.map_shared_object(start, len, object, offset);
}
None => {}
}
Ok(result)
}
pub async fn handle_munmap<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Munmap,
) -> Result<i64, Error> {
let start = call.addr().map(Addr::as_raw).unwrap_or(0);
let len = call.len();
let result = self.record_or_replay(guest, call).await?;
guest.thread_state().unmap_memory(start, len);
Ok(result)
}
pub async fn handle_mremap<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Mremap,
) -> Result<i64, Error> {
let old_start = call.addr().map(AddrMut::as_raw).unwrap_or(0);
let old_len = call.old_len();
let new_len = call.new_len();
let keep_source = call.flags() & 4 != 0;
let result = self.record_or_replay(guest, call).await?;
let new_start =
usize::try_from(result).expect("a successful mremap must return an address");
guest
.thread_state()
.remap_memory(old_start, old_len, new_start, new_len, keep_source);
Ok(result)
}
async fn procfs_entry<G: Guest<Self>>(
guest: &mut G,
stat: &DetStat,
target: StatTarget<'_>,
) -> ProcfsEntry {
procfs_inode::preserving_errno(Self::name_procfs_entry(guest, stat, target)).await
}
async fn maps_descriptor_entry<G: Guest<Self>>(
&self,
guest: &G,
stat: &DetStat,
fd: RawFd,
) -> ProcfsEntry {
procfs_inode::preserving_errno(async {
if guest.config().recordreplay_modes || !guest.config().sequentialize_threads {
return ProcfsEntry::Unknown;
}
let Some(task) = self.guest_task_directory(guest) else {
return ProcfsEntry::Unknown;
};
match procfs_inode::descriptor_procfs_path(&task, fd, stat.dev, stat.inode) {
Ok(Some(within)) => ProcfsEntry::At(within),
Ok(None) => ProcfsEntry::NotProcfs,
Err(_) => ProcfsEntry::Unknown,
}
})
.await
}
async fn maps_guest_target<G: Guest<Self>>(
&self,
guest: &mut G,
actual: &Path,
) -> Option<crate::procfs::BoundTask> {
let numbers = if Self::translates_procfs_numbers(guest) {
let ids = crate::procfs::ids::named_ids(actual);
Some(Self::guest_procfs_numbers(guest, &ids).await?)
} else {
None
};
let (pid, tid) = self.procfs_caller_ids(guest)?;
Self::maps_target_with_numbers(actual, numbers.as_ref(), pid, tid)
}
fn maps_target_with_numbers(
actual: &Path,
numbers: Option<&BTreeMap<i32, i32>>,
pid: i32,
tid: i32,
) -> Option<crate::procfs::BoundTask> {
let translated;
let actual = if let Some(numbers) = numbers {
if crate::procfs::ids::named_ids(actual)
.iter()
.any(|id| !numbers.contains_key(id))
{
return None;
}
translated = crate::procfs::ids::translate(actual, |id| numbers.get(&id).copied());
translated.as_deref().unwrap_or(actual)
} else {
actual
};
crate::procfs::maps_task_at(actual, pid, tid)
}
async fn name_procfs_entry<G: Guest<Self>>(
guest: &mut G,
stat: &DetStat,
target: StatTarget<'_>,
) -> ProcfsEntry {
if guest.config().recordreplay_modes
|| !procfs_inode::guest_tids_name_host_tasks(
&guest.config().backend,
guest.thread_state().physical_tid,
)
|| !procfs_inode::may_be_procfs(stat.dev, stat.blksize)
{
return ProcfsEntry::NotProcfs;
}
if !guest.config().sequentialize_threads {
Self::record_procfs_loss(
guest,
"the guest's threads are not sequentialized, so Detcore does not name procfs files"
.into(),
)
.await;
return ProcfsEntry::Unknown;
}
let tid = guest.tid().as_raw();
let mounts = match procfs_inode::procfs_mounts(tid, stat.dev, false) {
Ok(Some(mounts)) => mounts,
Ok(None) => {
let on_procfs = Self::with_object_link(guest, target, |link| {
procfs_inode::is_on_procfs(link, stat.dev, stat.inode)
})
.await;
return match on_procfs {
Ok(false) => ProcfsEntry::NotProcfs,
Ok(true) => {
Self::record_procfs_loss(
guest,
"a procfs file outside the guest's procfs mounts".into(),
)
.await;
ProcfsEntry::Unnamed
}
Err(reason) => {
Self::record_procfs_loss(guest, reason).await;
ProcfsEntry::Unknown
}
};
}
Err(error) => {
Self::record_procfs_loss(
guest,
format!(
"cannot read the guest's mount table: {}",
crate::util::describe_io_error(&error)
),
)
.await;
return ProcfsEntry::Unknown;
}
};
let (canonical, mount_id) = match Self::procfs_canonical_path(guest, stat, target).await {
Ok(found) => found,
Err(reason) => {
Self::record_procfs_loss(guest, reason).await;
return ProcfsEntry::Unnamed;
}
};
let reread = || procfs_inode::procfs_mounts(tid, stat.dev, true);
match procfs_inode::path_within(
&mounts,
mount_id,
&canonical,
reread,
procfs_inode::mount_root,
) {
Ok(within) => ProcfsEntry::At(within),
Err(reason) => {
Self::record_procfs_loss(guest, reason).await;
ProcfsEntry::Unnamed
}
}
}
async fn procfs_canonical_path<G: Guest<Self>>(
guest: &mut G,
stat: &DetStat,
target: StatTarget<'_>,
) -> Result<(PathBuf, u64), String> {
Self::with_object_link(guest, target, |link| {
procfs_inode::inspect_link(link, stat.dev, stat.inode)
})
.await
}
async fn with_object_link<G: Guest<Self>, R>(
guest: &mut G,
target: StatTarget<'_>,
inspect: impl FnOnce(&Path) -> Result<R, String>,
) -> Result<R, String> {
let tid = guest.tid().as_raw();
match target {
StatTarget::Descriptor(fd) => inspect(Path::new(&format!("/proc/{tid}/fd/{fd}"))),
StatTarget::Cwd => inspect(Path::new(&format!("/proc/{tid}/cwd"))),
StatTarget::Overwritten => Err("the call's result overwrote the guest's path".into()),
StatTarget::Path {
dirfd,
path,
follow,
} => {
let mut flags = OFlag::O_PATH | OFlag::O_CLOEXEC;
if !follow {
flags |= OFlag::O_NOFOLLOW;
}
let open = syscalls::Openat::new()
.with_dirfd(dirfd)
.with_path(path)
.with_flags(flags);
let fd = Self::open_object_descriptor(guest, open).await?;
let found = inspect(Path::new(&format!("/proc/{tid}/fd/{fd}")));
Self::close_object_descriptor(guest, fd).await?;
found
}
}
}
async fn open_object_descriptor<G: Guest<Self>>(
guest: &mut G,
open: syscalls::Openat,
) -> Result<RawFd, String> {
let mut last = Errno::EINTR.to_string();
for _ in 0..OBJECT_DESCRIPTOR_ATTEMPTS {
match procfs_inode::read_open(guest.inject(open).await) {
procfs_inode::Injected::Ran(fd) => return Ok(fd),
procfs_inode::Injected::NotRun(reported) => last = reported,
procfs_inode::Injected::Failed(reason) => return Err(reason),
}
}
Err(format!(
"cannot open the guest's path again: {last} in each of {OBJECT_DESCRIPTOR_ATTEMPTS} attempts"
))
}
async fn close_object_descriptor<G: Guest<Self>>(
guest: &mut G,
fd: RawFd,
) -> Result<(), String> {
let close = syscalls::Close::new().with_fd(fd);
for _ in 0..OBJECT_DESCRIPTOR_ATTEMPTS {
match procfs_inode::read_close(guest.inject(close).await) {
procfs_inode::Injected::Ran(()) => return Ok(()),
procfs_inode::Injected::NotRun(_) => {}
procfs_inode::Injected::Failed(reason) => return Err(reason),
}
}
Err(format!(
"close of the guest's O_PATH descriptor did not run in {OBJECT_DESCRIPTOR_ATTEMPTS} attempts"
))
}
async fn record_procfs_loss<G: Guest<Self>>(guest: &mut G, reason: String) {
static RECORDED: AtomicBool = AtomicBool::new(false);
if !RECORDED.swap(true, Ordering::Relaxed) {
report_determinism_loss(guest, format!("procfs inode numbers: {reason}")).await;
}
}
async fn determinize_stat<G, S>(
&self,
guest: &mut G,
stat: S,
inode_override: Option<DetInode>,
procfs: ProcfsEntry,
) -> Result<DetStat, Error>
where
G: Guest<Self>,
S: Into<DetStat>,
{
let cfg = guest.config().clone();
let mut stat: DetStat = stat.into();
if inode_override.is_none()
&& !cfg.recordreplay_modes
&& let Some(path) = rendered_procfs::placeholder_identity(stat.dev, stat.inode)
{
return self.rendered_metadata(guest, path).await;
}
let (d_ino, global_mtime) = match inode_override {
Some(inode) => {
let nanos = cfg
.epoch
.timestamp_nanos_opt()
.expect("epoch cannot be represented in nanoseconds")
as u64;
(inode, LogicalTime::from_nanos(nanos))
}
None => {
let observed = if stat.mask.contains(StatxMask::STATX_MTIME) {
ObservedMtime::from_host_mtime(stat.mtime.tv_sec, stat.mtime.tv_nsec)
} else {
ObservedMtime::Unobserved
};
let sighting = if stat.mask.contains(StatxMask::STATX_NLINK) && stat.nlink > 0 {
InodeSighting::Name
} else {
InodeSighting::Descriptor
};
if procfs.is_procfs()
&& stat.inode == procfs_inode::PROC_ROOT_INO
&& stat.mode & libc::S_IFMT == libc::S_IFDIR
&& stat.mask.contains(StatxMask::STATX_NLINK)
{
stat.nlink = 1;
}
match rendered_entry(&procfs, &stat, &cfg, self.rendered_files(guest)) {
Some(path) => {
let nanos = cfg
.epoch
.timestamp_nanos_opt()
.expect("epoch cannot be represented in nanoseconds")
as u64;
(
DetInode::mint(procfs_inode::rendered_inode(path)),
LogicalTime::from_nanos(nanos),
)
}
None => {
determinize_inode_observing_mtime(
guest,
stat.raw_inode(),
procfs.name(stat.dev),
observed,
sighting,
)
.await
}
}
}
};
stat.inode = d_ino.as_raw();
let host_device = stat.dev;
stat.dev = determinize_device(guest, stat.dev).await;
if stat.mode & libc::S_IFMT == libc::S_IFDIR
&& stat.mask.contains(StatxMask::STATX_SIZE)
&& !procfs.is_procfs()
&& !procfs_inode::is_backend_procfs_device(
&guest.config().backend,
host_device,
stat.blksize,
)
&& !procfs_inode::unprovable_procfs_signature(
&guest.config().backend,
guest.thread_state().physical_tid,
host_device,
stat.blksize,
)
{
stat.size = 4096;
if stat.mask.contains(StatxMask::STATX_BLOCKS) {
stat.blocks = 8;
}
}
let epoch_tp = Timespec {
tv_sec: cfg.epoch.timestamp(),
tv_nsec: cfg.epoch.timestamp_subsec_nanos() as i64,
};
let mtime: Timespec = global_mtime.into();
stat.atime = epoch_tp;
stat.ctime = epoch_tp;
stat.btime = epoch_tp;
stat.mtime = mtime;
Ok(stat)
}
pub async fn handle_stat_family<G: Guest<Self>>(
&self,
guest: &mut G,
call: StatFamily,
) -> Result<i64, Error> {
if guest.config().virtualize_metadata {
let target = stat_family_target(&guest.memory(), &call);
if !stat_family_arguments_valid(&guest.memory(), &call) {
if !matches!(self.rendered_procfs_stat(guest, target).await, Ok(None)) {
return Err(Errno::EINVAL.into());
}
} else if let Some(stat) = self.rendered_procfs_stat(guest, target).await? {
let statptr = call.stat().ok_or(Errno::EFAULT)?;
guest.memory().write_value(statptr.0, &stat.into())?;
return Ok(0);
}
let target = match call.stat() {
Some(result) => target.unless_overwritten(
&guest.memory(),
result.0.as_raw(),
std::mem::size_of::<libc::stat>(),
),
None => target,
};
Self::inject_translated(guest, Syscall::from(call)).await?;
let statptr = call.stat().ok_or(Errno::EFAULT)?;
let inode_override = target
.descriptor()
.and_then(|fd| stdio_inode_override(guest, fd));
let mut memory = guest.memory();
let stat: libc::stat = memory.read_value(statptr.0)?;
if inode_override.is_none() {
let _ = self
.recognize_placeholder(guest, &DetStat::from(&stat), target)
.await;
}
let procfs = match inode_override {
Some(_) => ProcfsEntry::NotProcfs,
None => Self::procfs_entry(guest, &DetStat::from(&stat), target).await,
};
let stat = self
.determinize_stat(guest, stat, inode_override, procfs)
.await?;
memory.write_value(statptr.0, &stat.into())?;
Ok(0)
} else {
let target = stat_family_target(&guest.memory(), &call);
if !stat_family_arguments_valid(&guest.memory(), &call) {
if !matches!(self.rendered_procfs_stat(guest, target).await, Ok(None)) {
return Err(Errno::EINVAL.into());
}
} else if let Some(stat) = self.rendered_procfs_stat(guest, target).await? {
let statptr = call.stat().ok_or(Errno::EFAULT)?;
guest.memory().write_value(statptr.0, &stat.into())?;
return Ok(0);
}
Ok(self.record_or_replay(guest, call).await?)
}
}
pub async fn handle_statx<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Statx,
) -> Result<i64, Error> {
let renderable = statx_arguments_valid(
call.flags().bits(),
call.mask().bits(),
names_no_path(&guest.memory(), call.path(), call.flags()),
);
if guest.config().virtualize_metadata {
let target = StatTarget::at(&guest.memory(), call.dirfd(), call.path(), call.flags());
if !renderable {
if !matches!(self.rendered_procfs_stat(guest, target).await, Ok(None)) {
return Err(Errno::EINVAL.into());
}
} else if let Some(stat) = self.rendered_procfs_stat(guest, target).await? {
return self.write_rendered_statx(guest, call, stat).await;
}
let target = match call.statx() {
Some(result) => target.unless_overwritten(
&guest.memory(),
result.0.as_raw(),
std::mem::size_of::<libc::statx>(),
),
None => target,
};
let unique = statx_requested_mask(call) & STATX_MNT_ID_UNIQUE != 0;
Self::inject_translated(guest, Syscall::from(statx_asking_classic_mount_id(call)))
.await?;
let statptr = call.statx().ok_or(Errno::EFAULT)?;
let inode_override = target
.descriptor()
.and_then(|fd| stdio_inode_override(guest, fd));
let mut memory = guest.memory();
let stat: libc::statx = memory.read_value(statptr.0)?;
let placeholder = match inode_override {
None => {
self.recognize_placeholder(guest, &DetStat::from(stat), target)
.await
}
Some(_) => None,
};
let procfs = match inode_override {
Some(_) => ProcfsEntry::NotProcfs,
None => Self::procfs_entry(guest, &DetStat::from(stat), target).await,
};
let raw_mount_id = match placeholder {
Some(_) => rendered_procfs::guest_procfs_mount_id().ok(),
None => (stat.stx_mask & libc::STATX_MNT_ID != 0).then_some(stat.stx_mnt_id),
};
let stat = self
.determinize_stat(guest, stat, inode_override, procfs)
.await?;
let mut statx: libc::statx = stat.into();
self.fill_statx_mount_id(guest, &mut statx, raw_mount_id, unique)
.await;
memory.write_value(statptr.0, &statx)?;
Ok(0)
} else {
let target = StatTarget::at(&guest.memory(), call.dirfd(), call.path(), call.flags());
if !renderable {
if !matches!(self.rendered_procfs_stat(guest, target).await, Ok(None)) {
return Err(Errno::EINVAL.into());
}
} else if let Some(stat) = self.rendered_procfs_stat(guest, target).await? {
return self.write_rendered_statx(guest, call, stat).await;
}
Ok(self.record_or_replay(guest, call).await?)
}
}
fn keeps_physically_nonblocking(
&self,
fd_type: FdType,
socketpair_endpoint: bool,
physically_nonblocking: bool,
inherited_external_read: bool,
) -> bool {
self.cfg.use_nonblocking_sockets()
&& !inherited_external_read
&& match fd_type {
FdType::Pipe => !self.cfg.recordreplay_modes || physically_nonblocking,
FdType::Socket if socketpair_endpoint => {
!self.cfg.recordreplay_modes || physically_nonblocking
}
FdType::Socket | FdType::Eventfd => !self.cfg.recordreplay_modes,
_ => false,
}
}
pub async fn handle_fcntl<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Fcntl,
) -> Result<i64, Error> {
let fd = call.fd();
let (call, _owner_copy) = self.screen_fcntl_owner(guest, call).await?;
let signals = fcntl_host_timed_signals(call.cmd());
if signals & kernel_sigset_bit(libc::SIGALRM) != 0 {
refuse_sigalrm(guest, SigalrmControl::ArmProducer).await?;
}
if matches!(call.cmd(), F_SETLEASE(lease) if lease != libc::F_UNLCK) {
refuse_sigalrm(guest, SigalrmControl::ArmProducer).await?;
}
if signals != 0
&& bundled_signal_facts::host_timed_signal_sources_are_physical(&guest.config().backend)
{
record_host_timed_signals(guest, HostTimedSignalScope::Container, signals).await;
}
let o_cloexec = match call.cmd() {
F_DUPFD_CLOEXEC(_) => OFlag::O_CLOEXEC,
_ => OFlag::empty(),
};
match call.cmd() {
F_GETFL => {
let physical_flags = self.record_or_replay(guest, call).await?;
let (logical_nonblocking, rendered_nofollow) =
guest.thread_state().with_detfd(fd, |detfd| {
(
detfd.is_nonblocking(),
detfd.procfs_rendered_path().is_some()
&& detfd.status_flags() & libc::O_NOFOLLOW != 0,
)
})?;
let physical_flags = if rendered_nofollow {
physical_flags | i64::from(libc::O_NOFOLLOW)
} else {
physical_flags
};
let nonblocking = i64::from(OFlag::O_NONBLOCK.bits());
if logical_nonblocking {
Ok(physical_flags | nonblocking)
} else {
Ok(physical_flags & !nonblocking)
}
}
F_SETFL(flags) => {
let (fd_type, socketpair_endpoint, physically_nonblocking, inherited_external_read) =
guest.thread_state().with_detfd(fd, |detfd| {
(
detfd.ty(),
detfd.is_socketpair_endpoint(),
detfd.physically_nonblocking(),
detfd.inherited_external_read().is_some(),
)
})?;
let force_nonblocking = self.keeps_physically_nonblocking(
fd_type,
socketpair_endpoint,
physically_nonblocking,
inherited_external_read,
);
let physical_flags = if force_nonblocking {
flags | OFlag::O_NONBLOCK.bits()
} else {
flags
};
let result = self
.record_or_replay(guest, call.with_cmd(F_SETFL(physical_flags)))
.await?;
guest.thread_state().with_detfd(fd, |detfd| {
detfd.set_status_flags(flags);
if force_nonblocking {
detfd.set_physically_nonblocking();
}
})?;
Ok(result)
}
F_DUPFD(_) | F_DUPFD_CLOEXEC(_) => {
let newfd = self.record_or_replay(guest, call).await? as RawFd;
let lock_tracked = self.lock_tracked_descriptions(guest, newfd..=newfd);
let replaced = guest.thread_state_mut().dup_fd(fd, newfd, o_cloexec)?;
if let Some(open_file_id) = replaced {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.report_lock_references(guest, lock_tracked).await;
Ok(newfd as i64)
}
F_SETFD(flags) => {
let result = self.record_or_replay(guest, call).await?;
guest.thread_state().with_detfd(fd, |detfd| {
detfd.set_cloexec(flags & libc::FD_CLOEXEC != 0);
})?;
Ok(result)
}
F_GETPIPE_SZ => Ok(reported_pipe_capacity(
self.record_or_replay(guest, call).await?,
)),
F_SETPIPE_SZ(requested) if pipe_capacity_request_exceeds_ceiling(requested) => {
trace!(
"[detcore] refusing F_SETPIPE_SZ({}) above the deterministic pipe ceiling {}",
requested, DETERMINISTIC_PIPE_CAPACITY_BYTES
);
Err(Errno::EPERM.into())
}
F_OFD_SETLK(_) | F_OFD_SETLKW(_) => {
let result = self.record_or_replay(guest, call).await?;
self.refresh_description_locks(guest, fd, LockCall::Fcntl)
.await?;
Ok(result)
}
_ => {
trace!(
"[detcore-finishme]: fcntl unhandled cases: {:?}",
call.cmd()
);
Ok(self.record_or_replay(guest, call).await?)
}
}
}
pub(crate) async fn refresh_description_locks<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
call: LockCall,
) -> Result<(), Error> {
let model = guest.thread_state().with_detfd(fd, |detfd| {
detfd.set_lock_tracked();
if call == LockCall::Recvmsg {
detfd.set_received_for_locks();
}
if call == LockCall::Fcntl {
detfd.set_may_hold_ofd_lock();
}
(detfd.open_file_id(), detfd.is_received_for_locks())
});
let Ok((open_file, received)) = model else {
if call.changes_locks() {
let fdinfo = self.read_own_fdinfo(guest, fd, call.name()).await?;
Self::note_alias(guest, &fdinfo).await;
}
return Ok(());
};
let fdinfo = self.read_own_fdinfo(guest, fd, call.name()).await?;
if received && call.changes_locks() {
Self::note_alias(guest, &fdinfo).await;
}
let held = matches!(&fdinfo, FdinfoRead::Contents(_));
let locks = match fdinfo {
FdinfoRead::Contents(contents) => {
Ok(crate::procfs::locks::held_locks_in_fdinfo(&contents))
}
FdinfoRead::Unknown(reason) => Err(reason),
FdinfoRead::Untrackable(reason) => {
info!("[detcore] /proc/locks: {reason}; its locks are not shown");
Ok(Vec::new())
}
};
if !held
|| locks
.as_ref()
.is_ok_and(|locks| locks.iter().any(|lock| lock.class == "OFDLCK"))
{
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_may_hold_ofd_lock());
}
let slots = guest.thread_state().slots_naming(open_file);
crate::tool_global::note_description_locks(guest, open_file, locks, slots).await;
Ok(())
}
async fn note_alias<G: Guest<Self>>(guest: &mut G, fdinfo: &FdinfoRead) {
match fdinfo {
FdinfoRead::Unknown(reason) => {
crate::tool_global::note_lock_ledger_refused(guest, reason.clone()).await;
}
FdinfoRead::Contents(_) | FdinfoRead::Untrackable(_) => {
crate::tool_global::note_aliased_inode(guest, fdinfo.inode()).await;
}
}
}
fn lock_tracked_descriptions<G: Guest<Self>>(
&self,
guest: &G,
fds: std::ops::RangeInclusive<RawFd>,
) -> Vec<OpenFileId> {
let thread = guest.thread_state();
let candidates = if fds.start() == fds.end() {
vec![*fds.start()]
} else {
thread
.open_fds()
.into_iter()
.filter(|fd| fds.contains(fd))
.collect()
};
let mut tracked = candidates
.into_iter()
.filter_map(|fd| {
thread
.with_detfd(fd, |detfd| {
detfd.is_lock_tracked().then(|| detfd.open_file_id())
})
.ok()
.flatten()
})
.collect::<Vec<_>>();
tracked.sort();
tracked.dedup();
tracked
}
async fn report_lock_references<G: Guest<Self>>(
&self,
guest: &mut G,
descriptions: Vec<OpenFileId>,
) {
for open_file in descriptions {
let remaining = guest.thread_state().slots_naming(open_file);
crate::tool_global::note_table_released(guest, open_file, remaining).await;
}
}
async fn read_own_fdinfo<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
call: &str,
) -> Result<FdinfoRead, Error> {
let mapped = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(FDINFO_PAGE)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await;
let Some(page) = mapped
.ok()
.and_then(|mapped| usize::try_from(mapped).ok())
.filter(|page| *page != 0)
else {
return Ok(FdinfoRead::Unknown(format!(
"after {call} on fd {fd}, Detcore could not map the page it reads that \
descriptor's fdinfo through ({mapped:?}), so it does not know which locks \
the description holds"
)));
};
let result = self.read_staged_fdinfo(guest, page, fd).await;
if let Err(errno) = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Addr::from_raw(page))
.with_len(FDINFO_PAGE),
))
.await
{
warn!(
"[detcore] could not unmap the transient fdinfo page: {}",
errno
);
}
Ok(match result? {
Ok(contents) => FdinfoRead::Contents(contents),
Err(FdinfoFailure::Failed(step, errno)) if !fdinfo_failure_hides(errno) => {
FdinfoRead::Unknown(fdinfo_refusal(call, fd, step, errno))
}
Err(FdinfoFailure::Failed(step, errno)) => FdinfoRead::Untrackable(format!(
"after {call} on fd {fd}, the guest's /proc did not give a procfs fdinfo \
({step}: {errno})"
)),
Err(FdinfoFailure::NotProcfs(why)) => FdinfoRead::Untrackable(format!(
"after {call} on fd {fd}, the guest's /proc did not give a procfs fdinfo \
({why})"
)),
})
}
async fn refuse_lock_bookkeeping<G: Guest<Self>>(&self, guest: &mut G, reason: String) -> ! {
error!("[detcore] {reason}");
crate::tool_global::report_policy_refusal(guest, reason).await;
crate::tool_global::unrecoverable_shutdown(guest, detcore_model::HERMIT_POLICY_REFUSAL_EXIT)
.await
}
async fn read_staged_fdinfo<G: Guest<Self>>(
&self,
guest: &mut G,
page: usize,
fd: RawFd,
) -> Result<Result<Vec<u8>, FdinfoFailure>, Error> {
let path_ptr =
PathPtr::from_ptr((page + FDINFO_PATH) as *const libc::c_char).ok_or(Errno::EFAULT)?;
self.write_fdinfo_path(guest, page, "/proc")?;
let anchor = syscalls::Openat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(Some(path_ptr))
.with_flags(OFlag::O_PATH | OFlag::O_DIRECTORY | OFlag::O_CLOEXEC)
.with_mode(None);
let anchor = match self.record_or_replay(guest, Syscall::Openat(anchor)).await {
Ok(anchor) => anchor as RawFd,
Err(errno) => return Ok(Err(FdinfoFailure::Failed("open", errno))),
};
let result = self.read_beneath_anchor(guest, page, anchor, fd).await;
if let Err(errno) = self
.record_or_replay(guest, syscalls::Close::new().with_fd(anchor))
.await
{
trace!("[detcore] closing the fdinfo anchor failed: {errno}");
}
result
}
async fn read_beneath_anchor<G: Guest<Self>>(
&self,
guest: &mut G,
page: usize,
anchor: RawFd,
fd: RawFd,
) -> Result<Result<Vec<u8>, FdinfoFailure>, Error> {
let anchor_device = match self.recorded_procfs_device(guest, page, anchor).await? {
Ok(device) => device,
Err(failure) => return Ok(Err(failure)),
};
self.write_fdinfo_path(guest, page, &format!("thread-self/fdinfo/{fd}"))?;
let how = (libc::O_RDONLY | libc::O_CLOEXEC) as u64;
let mut open_how = [0u8; FDINFO_HOW_SIZE];
open_how[..8].copy_from_slice(&how.to_ne_bytes());
open_how[16..].copy_from_slice(&FDINFO_RESOLVE.to_ne_bytes());
let how_ptr = AddrMut::<u8>::from_raw(page + FDINFO_HOW).ok_or(Errno::EFAULT)?;
guest.memory().write_exact(how_ptr, &open_how)?;
let opened = match self
.record_or_replay(
guest,
Syscall::from_raw(
Sysno::openat2,
procfs_levels::raw_args([
anchor as usize,
page + FDINFO_PATH,
page + FDINFO_HOW,
FDINFO_HOW_SIZE,
0,
0,
]),
),
)
.await
{
Ok(opened) => opened as RawFd,
Err(Errno::EXDEV) => {
return Ok(Err(FdinfoFailure::NotProcfs(
"the entry is outside /proc or across a mount",
)));
}
Err(errno) => return Ok(Err(FdinfoFailure::Failed("open", errno))),
};
let result = self
.read_opened_entry(guest, page, opened, anchor_device)
.await;
if let Err(errno) = self
.record_or_replay(guest, syscalls::Close::new().with_fd(opened))
.await
{
trace!("[detcore] closing fdinfo failed: {errno}");
}
result
}
async fn read_opened_entry<G: Guest<Self>>(
&self,
guest: &mut G,
page: usize,
opened: RawFd,
anchor_device: u64,
) -> Result<Result<Vec<u8>, FdinfoFailure>, Error> {
match self.recorded_procfs_device(guest, page, opened).await? {
Ok(device) if device == anchor_device => {}
Ok(_) => {
return Ok(Err(FdinfoFailure::NotProcfs(
"the entry is not on /proc's device",
)));
}
Err(failure) => return Ok(Err(failure)),
}
let scratch = AddrMut::<u8>::from_raw(page + FDINFO_READ).ok_or(Errno::EFAULT)?;
match self
.drain_procfs(
guest,
syscalls::Read::new().with_fd(opened),
scratch,
FDINFO_PAGE - FDINFO_READ,
false,
)
.await
{
Ok(contents) => Ok(Ok(contents)),
Err(Error::Errno(errno)) => Ok(Err(FdinfoFailure::Failed("read", errno))),
Err(error) => Err(error),
}
}
async fn recorded_procfs_device<G: Guest<Self>>(
&self,
guest: &mut G,
page: usize,
fd: RawFd,
) -> Result<Result<u64, FdinfoFailure>, Error> {
let stat = page + FDINFO_STAT;
if let Err(errno) = self
.record_or_replay(
guest,
Syscall::from_raw(
Sysno::fstatfs,
procfs_levels::raw_args([fd as usize, stat, 0, 0, 0, 0]),
),
)
.await
{
return Ok(Err(FdinfoFailure::Failed("fstatfs", errno)));
}
if self.read_fdinfo_word(guest, stat)? != libc::PROC_SUPER_MAGIC as u64 {
return Ok(Err(FdinfoFailure::NotProcfs("not procfs")));
}
if let Err(errno) = self
.record_or_replay(
guest,
Syscall::from_raw(
Sysno::fstat,
procfs_levels::raw_args([fd as usize, stat, 0, 0, 0, 0]),
),
)
.await
{
return Ok(Err(FdinfoFailure::Failed("fstat", errno)));
}
Ok(Ok(self.read_fdinfo_word(guest, stat)?))
}
fn write_fdinfo_path<G: Guest<Self>>(
&self,
guest: &mut G,
page: usize,
path: &str,
) -> Result<(), Error> {
assert!(
path.len() < FDINFO_HOW - FDINFO_PATH,
"fdinfo path {path:?} outgrew its room"
);
let start = AddrMut::<u8>::from_raw(page + FDINFO_PATH).ok_or(Errno::EFAULT)?;
let mut bytes = path.as_bytes().to_vec();
bytes.push(0);
guest.memory().write_exact(start, &bytes)?;
Ok(())
}
fn read_fdinfo_word<G: Guest<Self>>(
&self,
guest: &mut G,
address: usize,
) -> Result<u64, Error> {
let mut word = [0u8; 8];
let start = Addr::<u8>::from_raw(address).ok_or(Errno::EFAULT)?;
guest.memory().read_exact(start, &mut word)?;
Ok(u64::from_ne_bytes(word))
}
async fn refuse_hermit_owner<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
command: &str,
owner: libc::c_int,
) -> Result<(), Error> {
if owner <= 0 || !crate::tool_global::names_hermit_task(guest, None, owner).await {
return Ok(());
}
tracing::info!(
"[detcore, dtid {}] {command} on fd {fd} names task {owner}, one of Hermit's own, \
as the owner of its signals: refused with EPERM \
(https://github.com/rrnewton/hermit/issues/4083)",
guest.thread_state().dettid,
);
Err(Errno::EPERM.into())
}
async fn screen_fcntl_owner<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Fcntl,
) -> Result<(syscalls::Fcntl, Option<<G::Stack as Stack>::StackGuard>), Error> {
const F_OWNER_TID: libc::c_int = 0;
const F_OWNER_PID: libc::c_int = 1;
match call.cmd() {
F_SETOWN => {
let (_, args) = call.into_parts();
self.refuse_hermit_owner(guest, call.fd(), "F_SETOWN", args.arg2 as libc::c_int)
.await?;
Ok((call, None))
}
F_SETOWN_EX(owner) => {
let owner: Addr<[libc::c_int; 2]> = owner.ok_or(Errno::EFAULT)?.cast();
let copy = guest.memory().read_value(owner)?;
if matches!(copy[0], F_OWNER_TID | F_OWNER_PID) {
self.refuse_hermit_owner(guest, call.fd(), "F_SETOWN_EX", copy[1])
.await?;
}
let mut stack = guest.stack().await;
let copied: Addr<[libc::c_int; 2]> = stack.push(copy);
let guard = stack.commit()?;
Ok((call.with_cmd(F_SETOWN_EX(Some(copied.cast()))), Some(guard)))
}
_ => Ok((call, None)),
}
}
async fn screen_ioctl_owner<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Ioctl,
) -> Result<(syscalls::Ioctl, Option<<G::Stack as Stack>::StackGuard>), Error> {
let (command, owner) = match call.request() {
syscalls::ioctl::Request::FIOSETOWN(owner) => ("FIOSETOWN", owner),
syscalls::ioctl::Request::SIOCSPGRP(owner) => ("SIOCSPGRP", owner),
_ => return Ok((call, None)),
};
let copy: libc::c_int = guest.memory().read_value(owner.ok_or(Errno::EFAULT)?)?;
self.refuse_hermit_owner(guest, call.fd(), command, copy)
.await?;
let mut stack = guest.stack().await;
let copied = stack.push(copy);
let guard = stack.commit()?;
let request = match call.request() {
syscalls::ioctl::Request::FIOSETOWN(_) => {
syscalls::ioctl::Request::FIOSETOWN(Some(copied))
}
_ => syscalls::ioctl::Request::SIOCSPGRP(Some(copied)),
};
Ok((call.with_request(request), Some(guard)))
}
pub async fn handle_ioctl<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Ioctl,
) -> Result<i64, Error> {
let fd = call.fd();
if Syscall::Ioctl(call).into_parts().1.arg1 as u64
== crate::syscalls::timerfd::TFD_IOC_SET_TICKS
&& crate::syscalls::timerfd::enabled(guest)
&& crate::syscalls::timerfd::is_timerfd(guest, fd)
{
crate::syscalls::timerfd::refuse(format_args!(
"ioctl(TFD_IOC_SET_TICKS) on timerfd {fd} would set the host's tick count"
));
}
let (call, _owner_copy) = self.screen_ioctl_owner(guest, call).await?;
let signals = ioctl_host_timed_signals(call.request());
if signals != 0
&& bundled_signal_facts::host_timed_signal_sources_are_physical(&guest.config().backend)
{
record_host_timed_signals(guest, HostTimedSignalScope::Container, signals).await;
}
let (cloexec, nonblocking) = match call.request() {
syscalls::ioctl::Request::SIOCETHTOOL(_) => return Err(Errno::ENODEV.into()),
syscalls::ioctl::Request::FIOCLEX => (Some(true), None),
syscalls::ioctl::Request::FIONCLEX => (Some(false), None),
syscalls::ioctl::Request::FIONBIO(value) => {
let enabled = guest.memory().read_value(value.ok_or(Errno::EFAULT)?)? != 0;
(None, Some(enabled))
}
_ => (None, None),
};
if let Some(enabled) = nonblocking {
let (fd_type, socketpair_endpoint, physically_nonblocking, inherited_external_read) =
guest.thread_state().with_detfd(fd, |detfd| {
(
detfd.ty(),
detfd.is_socketpair_endpoint(),
detfd.physically_nonblocking(),
detfd.inherited_external_read().is_some(),
)
})?;
if self.keeps_physically_nonblocking(
fd_type,
socketpair_endpoint,
physically_nonblocking,
inherited_external_read,
) && physically_nonblocking
{
guest.thread_state().with_detfd(fd, |detfd| {
detfd.set_logical_nonblocking(enabled);
})?;
return Ok(0);
}
}
let result = self.record_or_replay(guest, call).await?;
if cloexec.is_some() || nonblocking.is_some() {
guest.thread_state().with_detfd(fd, |detfd| {
if let Some(enabled) = cloexec {
detfd.set_cloexec(enabled);
}
if let Some(enabled) = nonblocking {
detfd.set_nonblocking(enabled);
}
})?;
}
Ok(result)
}
pub async fn handle_statfs<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Statfs,
) -> Result<i64, Error> {
if let Some(pointer) = call.path() {
let path: PathBuf = pointer.read(&guest.memory())?;
let observed = Self::observed_path(guest, libc::AT_FDCWD, &path)?;
if self.rendered_procfs_at(guest, &observed).await?.is_some()
|| self
.placeholder_reached(guest, libc::AT_FDCWD, Some(pointer), true)
.await
.is_some()
{
self.write_procfs_statfs(guest, call.buf())?;
return Ok(0);
}
}
let ret = self.record_or_replay(guest, call).await?;
self.canonicalize_statfs_buf(guest, call.buf())?;
Ok(ret)
}
pub async fn handle_fstatfs<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Fstatfs,
) -> Result<i64, Error> {
let rendered = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.procfs_rendered_path().is_some())
.unwrap_or(false);
if rendered {
self.write_procfs_statfs(guest, call.buf())?;
return Ok(0);
}
let ret = self.record_or_replay(guest, call).await?;
self.canonicalize_statfs_buf(guest, call.buf())?;
Ok(ret)
}
pub async fn handle_ownership_change_noop<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
) -> Result<i64, Error> {
if !matches!(
call,
Syscall::Chown(_) | Syscall::Fchown(_) | Syscall::Fchownat(_) | Syscall::Lchown(_)
) {
warn!(
"ownership-change no-op reached with an unexpected syscall {:?}; \
refusing unvalidated success",
call.number()
);
return Err(Error::Errno(Errno::ENOSYS));
}
if let Syscall::Fchownat(c) = &call {
let allowed = AtFlags::AT_EMPTY_PATH | AtFlags::AT_SYMLINK_NOFOLLOW;
if c.flags().bits() & !allowed.bits() != 0 {
return Err(Error::Errno(Errno::EINVAL));
}
}
if let Syscall::Fchown(c) = &call {
let flags = self
.record_or_replay(
guest,
syscalls::Fcntl::new().with_fd(c.fd()).with_cmd(F_GETFL),
)
.await?;
if flags & i64::from(OFlag::O_PATH.bits()) != 0 {
return Err(Error::Errno(Errno::EBADF));
}
} else {
let mut stack = guest.stack().await;
let statptr: StatPtr = StatPtr(stack.reserve());
stack.commit()?;
let validate = match &call {
Syscall::Chown(c) => Syscall::Newfstatat(
syscalls::Newfstatat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(c.path())
.with_stat(Some(statptr))
.with_flags(AtFlags::empty()),
),
Syscall::Lchown(c) => Syscall::Newfstatat(
syscalls::Newfstatat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(c.path())
.with_stat(Some(statptr))
.with_flags(AtFlags::AT_SYMLINK_NOFOLLOW),
),
Syscall::Fchownat(c) => Syscall::Newfstatat(
syscalls::Newfstatat::new()
.with_dirfd(c.dirfd())
.with_path(c.path())
.with_stat(Some(statptr))
.with_flags(c.flags()),
),
_ => return Err(Error::Errno(Errno::ENOSYS)),
};
let result = self.record_or_replay(guest, validate).await;
guest
.memory()
.write_exact(statptr.0.cast(), &[0; std::mem::size_of::<libc::stat>()])?;
result?;
}
const KEEP_ID: libc::uid_t = libc::uid_t::MAX;
let consequence = match &call {
Syscall::Fchown(c) => Syscall::Fchown(
syscalls::Fchown::new()
.with_fd(c.fd())
.with_owner(KEEP_ID)
.with_group(KEEP_ID),
),
Syscall::Chown(c) => Syscall::Chown(
syscalls::Chown::new()
.with_path(c.path())
.with_owner(KEEP_ID)
.with_group(KEEP_ID),
),
Syscall::Lchown(c) => Syscall::Lchown(
syscalls::Lchown::new()
.with_path(c.path())
.with_owner(KEEP_ID)
.with_group(KEEP_ID),
),
Syscall::Fchownat(c) => Syscall::Fchownat(
syscalls::Fchownat::new()
.with_dirfd(c.dirfd())
.with_path(c.path())
.with_owner(KEEP_ID)
.with_group(KEEP_ID)
.with_flags(c.flags()),
),
_ => return Err(Error::Errno(Errno::ENOSYS)),
};
self.record_or_replay(guest, consequence).await?;
Ok(0)
}
fn canonicalize_statfs_buf<G: Guest<Self>>(
&self,
guest: &mut G,
buf: Option<AddrMut<libc::statfs>>,
) -> Result<(), Error> {
const FREE_BLOCKS_CAP: libc::fsblkcnt_t = 1_000_000;
const FREE_INODES_CAP: libc::fsfilcnt_t = 500_000;
if let Some(buf) = buf {
let mut sf = guest.memory().read_value(buf)?;
let free_blocks = FREE_BLOCKS_CAP.min(sf.f_blocks);
sf.f_bfree = free_blocks;
sf.f_bavail = free_blocks;
sf.f_ffree = if sf.f_files == 0 {
0
} else {
FREE_INODES_CAP.min(sf.f_files)
};
sf.f_fsid = unsafe { std::mem::zeroed() };
guest.memory().write_value(buf, &sf)?;
}
Ok(())
}
pub async fn handle_dup<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Dup,
) -> Result<i64, Errno> {
let old_fd = call.oldfd();
let new_fd = self.record_or_replay(guest, call).await? as RawFd;
let lock_tracked = self.lock_tracked_descriptions(guest, new_fd..=new_fd);
let replaced = guest
.thread_state_mut()
.dup_fd(old_fd, new_fd, OFlag::empty())?;
if let Some(open_file_id) = replaced {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.report_lock_references(guest, lock_tracked).await;
Ok(new_fd as i64)
}
pub async fn handle_dup2<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Dup2,
) -> Result<i64, Error> {
let old_fd = call.oldfd();
let new_fd = call.newfd();
if let Some(refusal) = self
.refuse_dup_over_waited_listener(guest, Sysno::dup2, old_fd, new_fd)
.await
{
return refusal;
}
let closed_end = (old_fd != new_fd)
.then(|| self.pipe_channel_end(guest, new_fd))
.flatten();
let res = self.record_or_replay(guest, call).await?;
if old_fd != new_fd
&& let Ok(new_fd) = u32::try_from(new_fd)
{
crate::tool_global::descriptors_replaced(guest, new_fd, new_fd).await;
}
let lock_tracked = if old_fd == new_fd {
Vec::new()
} else {
self.lock_tracked_descriptions(guest, new_fd..=new_fd)
};
let replaced = self
.dup_fd_after_replacement(guest, old_fd, new_fd, OFlag::empty(), lock_tracked.clone())
.await?;
if let Some(open_file_id) = replaced {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.report_lock_references(guest, lock_tracked).await;
self.note_channel_end_closed(guest, closed_end).await;
Ok(res)
}
async fn dup_fd_after_replacement<G: Guest<Self>>(
&self,
guest: &mut G,
old_fd: RawFd,
new_fd: RawFd,
flags: OFlag,
lock_tracked: Vec<OpenFileId>,
) -> Result<Option<OpenFileId>, Error> {
match guest.thread_state_mut().dup_fd(old_fd, new_fd, flags) {
Ok(replaced) => Ok(replaced),
Err(errno) => {
if old_fd != new_fd {
let displaced = guest.thread_state().remove_fd(new_fd);
if let Some(open_file_id) = displaced {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.report_lock_references(guest, lock_tracked).await;
}
Err(errno.into())
}
}
}
async fn refuse_dup_over_waited_listener<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
old_fd: RawFd,
new_fd: RawFd,
) -> Option<Result<i64, Error>> {
if old_fd == new_fd {
return None;
}
let new_fd = u32::try_from(new_fd).ok()?;
self.refuse_close_of_waited_listener(guest, sysno, new_fd..=new_fd)
.await
}
pub async fn handle_dup3<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Dup3,
) -> Result<i64, Error> {
let old_fd = call.oldfd();
let new_fd = call.newfd();
let flags = call.flags();
if let Some(refusal) = self
.refuse_dup_over_waited_listener(guest, Sysno::dup3, old_fd, new_fd)
.await
{
return refusal;
}
let closed_end = (old_fd != new_fd)
.then(|| self.pipe_channel_end(guest, new_fd))
.flatten();
let res = self.record_or_replay(guest, call).await?;
if let Ok(new_fd) = u32::try_from(new_fd) {
crate::tool_global::descriptors_replaced(guest, new_fd, new_fd).await;
}
let lock_tracked = self.lock_tracked_descriptions(guest, new_fd..=new_fd);
let replaced = self
.dup_fd_after_replacement(guest, old_fd, new_fd, flags, lock_tracked.clone())
.await?;
if let Some(open_file_id) = replaced {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.report_lock_references(guest, lock_tracked).await;
self.note_channel_end_closed(guest, closed_end).await;
Ok(res)
}
pub async fn handle_pipe2<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Pipe2,
) -> Result<i64, Error> {
let internally_nonblocking = self.cfg.use_nonblocking_sockets();
let injected = if internally_nonblocking {
call.with_flags(call.flags() | OFlag::O_NONBLOCK)
} else {
call
};
let res = self.record_or_replay(guest, injected).await?;
let memory = guest.memory();
if let Some(pipefd) = call.pipefd() {
let fds: [i32; 2] = memory.read_value(pipefd)?;
if internally_nonblocking {
let capacity_result = guest
.inject(
syscalls::Fcntl::new()
.with_fd(fds[0])
.with_cmd(F_SETPIPE_SZ(DETERMINISTIC_PIPE_CAPACITY_BYTES)),
)
.await;
if let Some(failure) = pipe_capacity_failure(fds, capacity_result) {
for close in failure.close_syscalls() {
let _ = guest.inject(close).await;
}
error!(
"[detcore] cannot pin scheduler-managed pipe to {} bytes (fds {:?}): {}. \
Determinism is unavailable for this run.",
DETERMINISTIC_PIPE_CAPACITY_BYTES, failure.created_fds, failure.error,
);
unrecoverable_shutdown(guest, detcore_model::HERMIT_POLICY_REFUSAL_EXIT).await;
}
}
self.add_fd(guest, fds[0], call.flags(), FdType::Pipe)
.await?;
self.add_fd(guest, fds[1], call.flags(), FdType::Pipe)
.await?;
if internally_nonblocking {
self.maybe_set_nonblocking_fd(guest, fds[0]);
self.maybe_set_nonblocking_fd(guest, fds[1]);
}
if self.cfg.pipe_wake_latency_in_effect().is_some() {
let read_end = guest
.thread_state()
.with_detfd(fds[0], |detfd| detfd.open_file_id())?;
let channel = crate::pipe_wake::ChannelId::Pipe(read_end);
for (fd, reads) in [(fds[0], true), (fds[1], false)] {
let end = crate::pipe_wake::ChannelEnd {
channel,
reads,
writes: !reads,
};
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_channel(end))?;
}
}
}
Ok(res)
}
pub async fn handle_utime<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Utime,
) -> Result<i64, Errno> {
let times = match call.times() {
None => {
let now: Timespec = thread_observe_time(guest).await.into();
[now, now]
}
Some(times) => {
let utimbuf = guest.memory().read_value(times)?;
[
Timespec {
tv_sec: utimbuf.actime,
tv_nsec: 0,
},
Timespec {
tv_sec: utimbuf.modtime,
tv_nsec: 0,
},
]
}
};
let utimensat = syscalls::Utimensat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(call.path());
self.set_file_times(guest, utimensat, Some(times)).await
}
pub async fn handle_utimes<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Utimes,
) -> Result<i64, Errno> {
let utimensat = syscalls::Utimensat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(call.filename());
match call.times() {
None => {
let now: Timespec = thread_observe_time(guest).await.into();
self.set_file_times(guest, utimensat, Some([now, now]))
.await
}
Some(times) => {
let mut memory = guest.memory();
let tvs = memory.read_value(times)?;
let tp: Addr<[Timespec; 2]> = times.cast();
let tp = unsafe { tp.into_mut() };
memory.write_value(tp, &[tvs[0].into(), tvs[1].into()])?;
self.set_file_times(guest, utimensat.with_times(Some(tp.into())), None)
.await
}
}
}
pub async fn handle_utimensat<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Utimensat,
) -> Result<i64, Errno> {
self.set_file_times(guest, call, None).await
}
async fn set_file_times<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Utimensat,
staged: Option<[Timespec; 2]>,
) -> Result<i64, Errno> {
if !guest.config().virtualize_metadata {
return self.utimensat_without_lookup(guest, call, staged).await;
}
if !guest.config().sequentialize_threads {
return self.utimensat_without_lookup(guest, call, staged).await;
}
let scratch = 128
+ staged.map_or(0, |_| std::mem::size_of::<[Timespec; 2]>())
+ std::mem::size_of::<libc::stat>();
if usize::try_from(guest.regs().await.rsp).map_or(true, |rsp| rsp <= scratch) {
info!(
"Guest stack pointer cannot hold the utimensat target lookup; \
leaving the virtual mtime unchanged."
);
return self.utimensat_without_lookup(guest, call, staged).await;
}
let mut stack = guest.stack().await;
let staged_call = match staged {
Some(times) => call.with_times(Some(stack.push(times))),
None => call,
};
let statptr: StatPtr = StatPtr(stack.reserve());
if utimensat_input_overlaps(&guest.memory(), &call, staged.is_none(), statptr) {
info!(
"utimensat inputs overlap the target lookup buffer; \
leaving the virtual mtime unchanged."
);
drop(stack);
return self.utimensat_without_lookup(guest, call, staged).await;
}
let mut saved = [0u8; std::mem::size_of::<libc::stat>()];
if guest
.memory()
.read_exact(statptr.0.cast(), &mut saved)
.is_err()
{
info!(
"Guest stack scratch cannot hold the utimensat target lookup; \
leaving the virtual mtime unchanged."
);
drop(stack);
return self.utimensat_without_lookup(guest, call, staged).await;
}
let _guard = match stack.commit() {
Ok(guard) => guard,
Err(_) => {
info!(
"Guest stack scratch cannot hold the utimensat target lookup; \
leaving the virtual mtime unchanged."
);
restore_lookup_buffer(&mut guest.memory(), statptr, &saved);
return self.utimensat_without_lookup(guest, call, staged).await;
}
};
restore_lookup_buffer(&mut guest.memory(), statptr, &saved);
let call = staged_call;
let mtime = match (staged, call.times()) {
(Some([_, mtime]), _) => Some(mtime),
(None, None) => Some(Timespec {
tv_sec: 0,
tv_nsec: libc::UTIME_NOW,
}),
(None, Some(times)) => guest
.memory()
.read_value(times)
.ok()
.map(|[_, mtime]| mtime),
}
.filter(|mtime| mtime.tv_nsec != libc::UTIME_OMIT);
let before = match mtime {
Some(_) => self.utimensat_target(guest, &call, statptr).await,
None => None,
};
restore_lookup_buffer(&mut guest.memory(), statptr, &saved);
let res = self.record_or_replay(guest, call).await?;
let (Some(mtime), Some(before)) = (mtime, before) else {
return Ok(res);
};
let after = self.utimensat_target(guest, &call, statptr).await;
restore_lookup_buffer(&mut guest.memory(), statptr, &saved);
let Some(after) = after else {
return Ok(res);
};
if (after.st_dev, after.st_ino) != (before.st_dev, before.st_ino) {
return Ok(res);
}
if mtime.tv_nsec == libc::UTIME_NOW {
touch_file(guest, RawInode::new(after.st_dev, after.st_ino)).await;
return Ok(res);
}
const NANOS_PER_SEC: i128 = 1_000_000_000;
let requested = i128::from(mtime.tv_sec) * NANOS_PER_SEC + i128::from(mtime.tv_nsec);
let stored = i128::from(after.st_mtime) * NANOS_PER_SEC + i128::from(after.st_mtime_nsec);
if (0..NANOS_PER_SEC).contains(&(requested - stored)) {
let nanos = u64::try_from(stored.max(0)).unwrap_or(u64::MAX);
set_file_mtime(
guest,
RawInode::new(after.st_dev, after.st_ino),
LogicalTime::from_nanos(nanos),
)
.await;
}
Ok(res)
}
async fn utimensat_without_lookup<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Utimensat,
staged: Option<[Timespec; 2]>,
) -> Result<i64, Errno> {
let Some(times) = staged else {
return self.record_or_replay(guest, call).await;
};
let mut stack = guest.stack().await;
let call = call.with_times(Some(stack.push(times)));
let _guard = stack.commit()?;
self.record_or_replay(guest, call).await
}
async fn utimensat_target<G: Guest<Self>>(
&self,
guest: &mut G,
call: &syscalls::Utimensat,
statptr: StatPtr<'_>,
) -> Option<libc::stat> {
let lookup = match call.path() {
None => Syscall::Fstat(
syscalls::Fstat::new()
.with_fd(call.dirfd())
.with_stat(Some(statptr)),
),
Some(path) => {
let allowed = libc::AT_SYMLINK_NOFOLLOW | libc::AT_EMPTY_PATH;
Syscall::Newfstatat(
syscalls::Newfstatat::new()
.with_dirfd(call.dirfd())
.with_path(Some(path))
.with_stat(Some(statptr))
.with_flags(AtFlags::from_bits_truncate(call.flags() & allowed)),
)
}
};
self.record_or_replay(guest, lookup).await.ok()?;
statptr.read(&guest.memory()).ok()
}
pub async fn handle_socket<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Socket,
) -> Result<i64, Error> {
if !self.cfg.sequentialize_threads || self.cfg.recordreplay_modes {
let fd = self.record_or_replay(guest, call).await? as RawFd;
self.add_fd(
guest,
fd,
OFlag::from_bits_truncate(call.r#type()),
FdType::Socket,
)
.await?;
self.mark_sock_diag_fd(guest, fd, &call);
const SOCK_TYPE_MASK: i32 = 0xf;
if self.accept_in_turn_enabled() && call.r#type() & SOCK_TYPE_MASK == libc::SOCK_STREAM
{
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_accept_in_turn_eligible())?;
}
Ok(fd as i64)
} else {
let call2 = if self.cfg.use_nonblocking_sockets() {
call.with_type(call.r#type() | libc::SOCK_NONBLOCK)
} else {
call
};
let fd = self.record_or_replay(guest, call2).await? as RawFd; self.add_fd(
guest,
fd,
OFlag::from_bits_truncate(
call.r#type() & (libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC),
),
FdType::Socket,
)
.await?;
self.maybe_set_nonblocking_fd(guest, fd);
self.mark_sock_diag_fd(guest, fd, &call);
Ok(fd as i64)
}
}
pub(crate) fn accept_in_turn_enabled(&self) -> bool {
self.cfg.recordreplay_modes
&& self.cfg.use_nonblocking_sockets()
&& !self.cfg.backend.tool_shares_guest_descriptor_table
}
fn mark_sock_diag_fd<G: Guest<Self>>(&self, guest: &mut G, fd: RawFd, call: &syscalls::Socket) {
if call.family() != libc::AF_NETLINK {
return;
}
if call.protocol() == libc::NETLINK_SOCK_DIAG {
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_sock_diag());
}
if call.protocol() == libc::NETLINK_ROUTE {
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_netlink_route());
}
}
pub async fn handle_socketpair<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Socketpair,
) -> Result<i64, Error> {
let call2 = if self.cfg.sequentialize_threads && !self.cfg.debug_externalize_sockets {
call.with_type(call.r#type() | libc::SOCK_NONBLOCK)
} else {
call
};
let res = self.record_or_replay(guest, call2).await?;
if let Some(usockvec) = call.usockvec() {
let memory = guest.memory();
let fds: [i32; 2] = memory.read_value(usockvec)?;
self.add_fd(
guest,
fds[0],
OFlag::from_bits_truncate(
call.r#type() & (libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC),
),
FdType::Socket,
)
.await?;
self.add_fd(
guest,
fds[1],
OFlag::from_bits_truncate(
call.r#type() & (libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC),
),
FdType::Socket,
)
.await?;
if self.cfg.use_nonblocking_sockets() {
for fd in fds {
let _ = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_socketpair_endpoint());
}
}
self.maybe_set_nonblocking_fd(guest, fds[0]);
self.maybe_set_nonblocking_fd(guest, fds[1]);
}
Ok(res)
}
pub async fn handle_setsockopt<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Setsockopt,
) -> Result<i64, Error> {
const SO_RCVTIMEO_NEW: i32 = 66;
let receive_timeout = (self.accept_in_turn_enabled()
&& call.level() == libc::SOL_SOCKET
&& matches!(call.optname(), libc::SO_RCVTIMEO | SO_RCVTIMEO_NEW))
.then(|| {
call.optval()
.and_then(|value| {
guest
.memory()
.read_value::<_, libc::timeval>(value.cast())
.ok()
})
.map_or(ReceiveTimeout::Unknown, ReceiveTimeout::set_by)
});
let result = self.record_or_replay(guest, call).await?;
if let Some(timeout) = receive_timeout {
let _ = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.set_receive_timeout(timeout));
}
Ok(result)
}
pub async fn handle_listen<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Listen,
) -> Result<i64, Error> {
Ok(self.record_or_replay(guest, call).await?)
}
pub async fn handle_getsockname<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Getsockname,
) -> Result<i64, Error> {
Ok(self.record_or_replay(guest, call).await?)
}
pub async fn handle_getpeername<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Getpeername,
) -> Result<i64, Error> {
Ok(self.record_or_replay(guest, call).await?)
}
pub async fn handle_getsockopt<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Getsockopt,
) -> Result<i64, Error> {
let requested_length =
if call.level() == libc::SOL_SOCKET && call.optname() == libc::SO_NETNS_COOKIE {
let fd_type = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.ty())?;
if fd_type == FdType::Socket {
call.optlen()
.map(|length| guest.memory().read_value(length))
.transpose()?
} else {
None
}
} else {
None
};
let deterministic_cookie =
if call.level() == libc::SOL_SOCKET && call.optname() == libc::SO_COOKIE {
let requested_length = call
.optlen()
.map(|length| guest.memory().read_value(length))
.transpose()?;
let open_file_id = guest
.thread_state()
.with_detfd(call.fd(), |detfd| detfd.open_file_id())?;
Some((open_file_id.deterministic_socket_cookie(), requested_length))
} else {
None
};
let result = self.record_or_replay(guest, call).await?;
if result == 0
&& call.level() == libc::SOL_SOCKET
&& call.optname() == libc::SO_INCOMING_CPU
&& let (Some(optval), Some(optlen)) = (call.optval(), call.optlen())
{
let returned_len: libc::socklen_t = guest.memory().read_value(optlen)?;
let zero_cpu = 0_i32.to_ne_bytes();
let returned_len = (returned_len as usize).min(zero_cpu.len());
guest
.memory()
.write_exact(optval.cast::<u8>(), &zero_cpu[..returned_len])?;
}
if result == 0
&& call.level() == libc::IPPROTO_TCP
&& call.optname() == libc::TCP_INFO
&& let (Some(optval), Some(optlen)) = (call.optval(), call.optlen())
{
let returned_len: libc::socklen_t = guest.memory().read_value(optlen)?;
let mut info = vec![0; returned_len as usize];
let optval = optval.cast::<u8>();
guest.memory().read_exact(optval, info.as_mut_slice())?;
canonicalize_tcp_info(&mut info);
guest.memory().write_exact(optval, info.as_slice())?;
}
if let Some(requested_length) = requested_length
&& let Some(value) = call.optval()
{
let bytes = DETERMINISTIC_NETNS_COOKIE.to_ne_bytes();
let write_length = (requested_length as usize).min(bytes.len());
guest
.memory()
.write_exact(value.cast(), &bytes[..write_length])?;
}
if let Some((cookie, Some(requested_length))) = deterministic_cookie
&& let Some(value) = call.optval()
{
let bytes = cookie.to_ne_bytes();
let write_length = (requested_length as usize).min(bytes.len());
guest
.memory()
.write_exact(value.cast(), &bytes[..write_length])?;
}
Ok(result)
}
pub async fn handle_shutdown<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Shutdown,
) -> Result<i64, Error> {
Ok(self.record_or_replay(guest, call).await?)
}
pub async fn handle_bind<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Bind,
) -> Result<i64, Error> {
if guest.config().sched_heuristic == SchedHeuristic::ConnectBind {
trace!("Scheduling heuristic: reprioritizing bind");
let resource = ResourceID::PriorityChangePoint(
LAST_PRIORITY,
guest.thread_state().thread_logical_time.as_nanos(),
guest.thread_state().committed_clock_value,
Vec::new(),
);
let req = guest.thread_state().mk_request(resource, Permission::W);
resource_request(guest, req).await;
}
let addr = call.umyaddr().ok_or(Errno::EFAULT)?;
let sock_fd = call.fd();
let open_file_id = guest
.thread_state()
.with_detfd(sock_fd, |detfd| detfd.open_file_id())?;
let sockaddr_family = guest.memory().read_value(addr.cast::<u16>())?;
if sockaddr_family == libc::AF_UNIX as u16
&& call.addrlen() == std::mem::offset_of!(libc::sockaddr_un, sun_path) as i32
{
let resp = send_and_update_time(guest, GlobalRequest::RequestPort(open_file_id)).await;
let port = match resp.1 {
GlobalResponse::RequestPort(port) => port,
GlobalResponse::PortFull => {
return Err(reverie::Error::from(nix::errno::Errno::EADDRINUSE));
}
_ => unreachable!(),
};
let mut stack = guest.stack().await;
let autobind_addr: AddrMut<libc::sockaddr_un> = stack.reserve();
let _stack_guard = stack.commit()?;
guest
.memory()
.write_value(autobind_addr, &unix_autobind_address(port))?;
let deterministic_bind = call
.with_umyaddr(Some(autobind_addr.cast()))
.with_addrlen(unix_autobind_addrlen());
return Ok(self.record_or_replay(guest, deterministic_bind).await?);
} else if sockaddr_family == libc::AF_NETLINK as u16
&& call.addrlen() >= std::mem::size_of::<libc::sockaddr_nl>() as i32
{
let mut sockaddr_nl: libc::sockaddr_nl = guest
.memory()
.read_value(addr.cast::<libc::sockaddr_nl>())?;
if sockaddr_nl.nl_pid == 0 {
let resp =
send_and_update_time(guest, GlobalRequest::RequestPort(open_file_id)).await;
match resp.1 {
GlobalResponse::RequestPort(port) => {
sockaddr_nl.nl_pid = DETERMINISTIC_NETLINK_PORT_ID_BASE | u32::from(port);
let mut stack = guest.stack().await;
let deterministic_addr: AddrMut<libc::sockaddr_nl> = stack.reserve();
let _stack_guard = stack.commit()?;
guest
.memory()
.write_value(deterministic_addr, &sockaddr_nl)?;
let deterministic_bind = call.with_umyaddr(Some(deterministic_addr.cast()));
return Ok(self.record_or_replay(guest, deterministic_bind).await?);
}
GlobalResponse::PortFull => {
return Err(reverie::Error::from(nix::errno::Errno::EADDRINUSE));
}
_ => unreachable!(),
}
}
} else if sockaddr_family == libc::AF_INET as u16 {
let mut sockaddr_in: libc::sockaddr_in = guest
.memory()
.read_value(addr.cast::<libc::sockaddr_in>())?;
let port = sockaddr_in.sin_port.to_be();
let ipaddr = Ipv4Addr::from(sockaddr_in.sin_addr.s_addr);
if port != 0 {
if guest.config().warn_non_zero_binds {
warn!(
"Analyze Networking: Non-zero port detected: {:?}:{:?}",
ipaddr, port
);
}
let resp =
send_and_update_time(guest, GlobalRequest::AddUsedPort(port, open_file_id))
.await;
match resp.1 {
GlobalResponse::AddUsedPort => {
trace!("Added to used port {}", port);
}
_ => unreachable!(),
}
} else {
let resp =
send_and_update_time(guest, GlobalRequest::RequestPort(open_file_id)).await;
match resp.1 {
GlobalResponse::RequestPort(port_assigned) => {
sockaddr_in.sin_port = port_assigned.to_be();
guest
.memory()
.write_value(addr.cast::<libc::sockaddr_in>(), &sockaddr_in)?;
}
GlobalResponse::PortFull => {
return Err(reverie::Error::from(nix::errno::Errno::EADDRINUSE));
}
_ => unreachable!(),
}
}
} else if sockaddr_family == libc::AF_INET6 as u16 {
let mut sockfaddr_in: libc::sockaddr_in6 = guest
.memory()
.read_value(addr.cast::<libc::sockaddr_in6>())?;
let port = sockfaddr_in.sin6_port.to_be();
let ipaddr = Ipv6Addr::from(sockfaddr_in.sin6_addr.s6_addr);
if port != 0 {
if guest.config().warn_non_zero_binds {
warn!(
"Analyze Networking: Non-zero port detected: {:?}:{:?}",
ipaddr, port
);
}
let resp =
send_and_update_time(guest, GlobalRequest::AddUsedPort(port, open_file_id))
.await;
match resp.1 {
GlobalResponse::AddUsedPort => {
trace!("Added to used port {}", port);
}
_ => unreachable!(),
}
} else {
let resp =
send_and_update_time(guest, GlobalRequest::RequestPort(open_file_id)).await;
match resp.1 {
GlobalResponse::RequestPort(port_assigned) => {
sockfaddr_in.sin6_port = port_assigned.to_be();
guest
.memory()
.write_value(addr.cast::<libc::sockaddr_in6>(), &sockfaddr_in)?;
trace!("Port assigned {}", port_assigned)
}
GlobalResponse::PortFull => {
return Err(reverie::Error::from(nix::errno::Errno::EADDRINUSE));
}
_ => unreachable!(),
}
}
}
let res = self.record_or_replay(guest, call).await?;
Ok(res)
}
pub async fn handle_eventfd2<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Eventfd2,
) -> Result<i64, Error> {
let internally_nonblocking =
self.cfg.use_nonblocking_sockets() && !self.cfg.recordreplay_modes;
let injected = if internally_nonblocking {
call.with_flags(call.flags() | syscalls::EfdFlags::EFD_NONBLOCK)
} else {
call
};
let fd = self.record_or_replay(guest, injected).await? as RawFd;
self.add_fd(
guest,
fd,
OFlag::from_bits_truncate(
call.flags().bits() & (libc::EFD_CLOEXEC | libc::EFD_NONBLOCK),
),
FdType::Eventfd,
)
.await?;
if internally_nonblocking {
self.maybe_set_nonblocking_fd(guest, fd);
}
Ok(fd as i64)
}
pub async fn handle_signalfd4<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Signalfd4,
) -> Result<i64, Error> {
let mask = match call.mask().and_then(|mask| Addr::from_raw(mask.as_raw())) {
Some(mask) => {
match crate::syscalls::signal::restart_if_first_probe_not_run(
crate::syscalls::signal::read_kernel_sigset(guest, mask).await,
) {
Err(Error::Errno(Errno::ERESTARTNOINTR)) => {
return Err(Errno::ERESTARTNOINTR.into());
}
read => read.ok(),
}
}
None => None,
};
if let Some(mask) = mask {
let pending = crate::syscalls::helpers::pending_real_time_among(guest, mask).await;
crate::syscalls::helpers::act_on_pending_real_time(guest, pending, mask, 0).await;
}
let signalfd = self.record_or_replay(guest, call).await? as RawFd;
if let Some(mask) = mask
&& mask != 0
&& let Some(detpid) = guest.thread_state().detpid
{
crate::tool_global::register_signalfd(guest, detpid, mask).await;
}
self.add_fd(
guest,
signalfd,
OFlag::from_bits_truncate(
call.flags().bits() & (libc::SFD_CLOEXEC | libc::SFD_NONBLOCK),
),
FdType::Signalfd,
)
.await?;
Ok(signalfd as i64)
}
pub async fn handle_timerfd_create<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::TimerfdCreate,
) -> Result<i64, Error> {
crate::syscalls::timerfd::refuse_unshared_model(guest);
let internally_nonblocking = crate::syscalls::timerfd::enabled(guest);
let injected = if internally_nonblocking {
call.with_flags(call.flags() | syscalls::TimerFlags::TFD_NONBLOCK)
} else {
call
};
let fd = self.record_or_replay(guest, injected).await? as RawFd;
self.add_fd(
guest,
fd,
OFlag::from_bits_truncate(
call.flags().bits() & (libc::TFD_CLOEXEC | libc::TFD_NONBLOCK),
),
FdType::Timerfd,
)
.await?;
if internally_nonblocking {
self.maybe_set_nonblocking_fd(guest, fd);
}
Ok(fd as i64)
}
async fn notification_fd_control<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
) -> Result<i64, Error> {
let dettid = guest.thread_state().dettid;
resource_request(guest, Resources::new(dettid)).await;
Ok(self.record_or_replay(guest, call).await?)
}
pub async fn handle_timerfd_settime<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::TimerfdSettime,
) -> Result<i64, Error> {
let dettid = guest.thread_state().dettid;
resource_request(guest, Resources::new(dettid)).await;
if let Some(result) = crate::syscalls::timerfd::settime(guest, call).await? {
return Ok(result);
}
Ok(self.record_or_replay(guest, call).await?)
}
pub async fn handle_timerfd_gettime<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::TimerfdGettime,
) -> Result<i64, Error> {
let dettid = guest.thread_state().dettid;
resource_request(guest, Resources::new(dettid)).await;
if let Some(result) = crate::syscalls::timerfd::gettime(guest, call).await? {
return Ok(result);
}
Ok(self.record_or_replay(guest, call).await?)
}
pub async fn handle_inotify_init1<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::InotifyInit1,
) -> Result<i64, Error> {
let fd = self.record_or_replay(guest, call).await? as RawFd;
self.add_fd(
guest,
fd,
OFlag::from_bits_truncate(call.flags().bits() & (libc::IN_CLOEXEC | libc::IN_NONBLOCK)),
FdType::Inotify,
)
.await?;
Ok(fd as i64)
}
pub async fn handle_inotify_add_watch<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::InotifyAddWatch,
) -> Result<i64, Error> {
self.notification_fd_control(guest, call.into()).await
}
pub async fn handle_inotify_rm_watch<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::InotifyRmWatch,
) -> Result<i64, Error> {
self.notification_fd_control(guest, call.into()).await
}
pub async fn handle_memfd_create<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::MemfdCreate,
) -> Result<i64, Error> {
let fd = self.record_or_replay(guest, call).await? as RawFd;
self.add_fd(
guest,
fd,
OFlag::from_bits_truncate((call.flags() & libc::MFD_CLOEXEC) as i32),
FdType::Memfd,
)
.await?;
Ok(fd as i64)
}
pub async fn handle_pidfd_open<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::PidfdOpen,
) -> Result<i64, Error> {
let allowed_flags = libc::O_NONBLOCK as u32;
if call.flags() & !allowed_flags != 0 {
return Err(Errno::EINVAL.into());
}
let pid = call.pid() as i32;
if pid > 0 && guest.thread_state().nested_pid_namespace {
let target = match crate::tool_global::guest_pid(guest, pid).await {
crate::scheduler::pid_namespaces::GuestPidAnswer::Task { task, .. } => Some(task),
crate::scheduler::pid_namespaces::GuestPidAnswer::NoSuchPid => None,
crate::scheduler::pid_namespaces::GuestPidAnswer::Untranslatable(reason) => {
tracing::error!(
"[detcore, dtid {}] pidfd_open of pid {} from a nested PID namespace is not supported: {} (https://github.com/rrnewton/hermit/issues/4155)",
guest.thread_state().dettid,
pid,
reason,
);
return self
.refuse_unserviceable_operation(guest, Sysno::pidfd_open, Errno::ENOSYS)
.await;
}
};
let fd = self.record_or_replay(guest, call).await? as RawFd;
let flags = OFlag::O_CLOEXEC | OFlag::from_bits_truncate(call.flags() as libc::c_int);
self.add_fd(guest, fd, flags, FdType::Pidfd).await?;
if let Some(target) = target {
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_pidfd_target(target))?;
}
return Ok(fd as i64);
}
if pid > 0 && crate::tool_global::names_hermit_task(guest, Some(pid), pid).await {
tracing::info!(
"[detcore, dtid {}] pidfd_open of {}, Hermit's own process: refused with EPERM \
(https://github.com/rrnewton/hermit/issues/4066)",
guest.thread_state().dettid,
pid,
);
return Err(Errno::EPERM.into());
}
let fd = self.record_or_replay(guest, call).await? as RawFd;
let flags = OFlag::O_CLOEXEC | OFlag::from_bits_truncate(call.flags() as libc::c_int);
self.add_fd(guest, fd, flags, FdType::Pidfd).await?;
let target = DetPid::from_raw(call.pid() as i32);
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_pidfd_target(target))?;
Ok(fd as i64)
}
pub async fn handle_pidfd_send_signal<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
pidfd: RawFd,
signal: i32,
flags: u32,
) -> Result<i64, Error> {
let mut scope = pidfd_signal_scope(flags)?;
let info = AddrMut::<libc::siginfo_t>::from_raw(call.into_parts().1.arg2);
if let Some(refused) = self
.refuse_forged_own_sigchld(guest, Sysno::pidfd_send_signal, signal, info)
.await
{
return refused;
}
let named = if let Some((target, default)) = pidfd_self_target(guest, pidfd) {
if flags == 0 {
scope = default;
}
Some(target)
} else {
let kind = guest
.thread_state()
.with_detfd(pidfd, |detfd| match detfd.ty() {
FdType::Pidfd => Some(Some(detfd.pidfd_target())),
FdType::Regular if detfd.status_flags() & libc::O_PATH == 0 => Some(None),
_ => None,
})?;
let Some(kind) = kind else {
return Err(Errno::EBADF.into());
};
match kind {
Some(target) => target,
None => {
let descriptor = if self.cfg.recordreplay_modes {
ProcessDirectoryDescriptor::Unknown(
"record and replay do not read what a descriptor names",
)
} else if !bundled_signal_facts::host_task_reads_enabled(
&guest.config().backend,
) {
ProcessDirectoryDescriptor::Unknown(
"this backend's guest thread ids are not host thread ids",
)
} else {
process_directory_descriptor(guest.tid().as_raw(), pidfd)
};
match descriptor {
ProcessDirectoryDescriptor::Process(task)
if crate::tool_global::names_hermit_task(
guest,
None,
task.as_raw(),
)
.await =>
{
tracing::info!(
"[detcore, dtid {}] pidfd_send_signal through /proc/{}, one of \
Hermit's own threads: refused with EPERM",
guest.thread_state().dettid,
task,
);
return Err(Errno::EPERM.into());
}
ProcessDirectoryDescriptor::Process(task) => Some(task),
ProcessDirectoryDescriptor::NotAProcess => return Err(Errno::EBADF.into()),
ProcessDirectoryDescriptor::Unknown(reason) => {
tracing::error!(
"[detcore, dtid {}] pidfd_send_signal through descriptor {} is not \
supported: {} (https://github.com/rrnewton/hermit/issues/4108)",
guest.thread_state().dettid,
pidfd,
reason,
);
return self
.refuse_unserviceable_operation(
guest,
Sysno::pidfd_send_signal,
Errno::ENOSYS,
)
.await;
}
}
}
}
};
if scope == PidfdSignalScope::ProcessGroup {
tracing::error!(
"[detcore, dtid {}] signal {} by pidfd_send_signal with PIDFD_SIGNAL_PROCESS_GROUP \
is not supported: Detcore does not model process-group membership, and the \
guest's process group is inherited from Hermit's \
(https://github.com/rrnewton/hermit/issues/4108)",
guest.thread_state().dettid,
signal,
);
return self
.refuse_unserviceable_operation(guest, Sysno::pidfd_send_signal, Errno::ENOSYS)
.await;
}
let process = match named {
Some(named) => Some(signal_target_process(guest, named).await.unwrap_or(named)),
None => None,
};
if guest.thread_state().nested_pid_namespace
&& let Some(process) = process
&& let Ok(Some(local)) = crate::tool_global::local_pid(guest, process).await
&& let crate::scheduler::pid_namespaces::GuestPidAnswer::Task {
own_init_caught, ..
} = crate::tool_global::guest_pid(guest, local).await
&& Self::own_namespace_init_drops(own_init_caught, signal)
{
return Ok(self.record_or_replay(guest, call).await?);
}
if guest.config().sequentialize_threads
&& let Some(process) = process
{
let (targets, zombie) = resolve_kill_targets_and_exit(guest, process).await;
if targets.is_empty() && zombie == Some(false) {
return self.gone_pidfd_signal_answer(guest, call, signal).await;
}
}
let thread_scope = scope == PidfdSignalScope::Thread;
let receiver_id = if thread_scope { named } else { process };
self.record_orphaned_group_signals(guest, signal).await;
if signal == libc::SIGALRM {
let control = match receiver_id {
Some(target) => SigalrmControl::SendTo(DetTid::from_raw(target.as_raw())),
None => SigalrmControl::SendToUnnamed,
};
refuse_sigalrm(guest, control).await?;
}
let exited_leader = signal == libc::SIGKILL
&& guest.config().sequentialize_threads
&& thread_scope
&& match named {
Some(thread) => {
crate::syscalls::signal::sigkill_names_an_exited_leader(
guest,
DetTid::from_raw(thread.as_raw()),
)
.await
}
None => false,
};
if signal == libc::SIGKILL
&& guest.config().sequentialize_threads
&& !exited_leader
&& let (Some(process), Some(receiver)) = (process, receiver_id)
{
if self
.reserve_controlled_self_sigkill_exit(
guest,
signal,
Some(process),
thread_scope.then(|| DetTid::from_raw(receiver.as_raw())),
)
.await
{
return Ok(self.record_or_replay(guest, call).await?);
}
if let Some(reservation) =
reserve_sigkill(guest, DetTid::from_raw(receiver.as_raw())).await
{
return self.send_reserved_sigkill(guest, reservation, call).await;
}
}
if thread_scope {
let value = match (named, process) {
(Some(thread), Some(process)) => {
self.send_guest_signal(
guest,
call,
DetTid::from_raw(thread.as_raw()),
signal,
Some(process),
true,
DetTid::from_raw(thread.as_raw()),
)
.await?
}
_ => self.record_or_replay(guest, call).await?,
};
if exited_leader {
return Ok(value);
}
if let (Some(thread), Some(process)) = (named, process) {
let thread = DetTid::from_raw(thread.as_raw());
if signal == libc::SIGKILL {
crate::tool_global::notify_signal_pending(
guest,
thread,
SigWrapper(libc::SIGKILL),
Some(process),
crate::tool_global::SignalScope::Thread,
)
.await;
} else {
self.notify_cross_task_signal(
guest,
thread,
signal,
Some(process),
crate::tool_global::SignalScope::Thread,
)
.await;
}
}
return Ok(value);
}
let mut receiver = None;
if signal != 0
&& signal != libc::SIGKILL
&& guest.config().sequentialize_threads
&& let Some(target) = process
{
match resolve_kill_targets(guest, target).await.as_slice() {
[] => {}
[thread] => receiver = Some((*thread, target)),
_ => {
self.process_signal_target(
guest,
reverie::syscalls::Sysno::pidfd_send_signal,
target,
signal,
)
.await?;
}
}
}
let value = match receiver {
Some((thread, process)) => {
self.send_guest_signal(
guest,
call,
thread,
signal,
Some(process),
false,
DetTid::from_raw(process.as_raw()),
)
.await?
}
None => self.record_or_replay(guest, call).await?,
};
if let Some((thread, process)) = receiver {
self.notify_cross_task_signal(
guest,
thread,
signal,
Some(process),
crate::tool_global::SignalScope::Process,
)
.await;
}
if signal == libc::SIGKILL {
match process {
Some(target) => {
crate::tool_global::notify_signal_pending(
guest,
DetTid::from_raw(target.as_raw()),
SigWrapper(libc::SIGKILL),
Some(target),
crate::tool_global::SignalScope::Process,
)
.await
}
None => crate::tool_global::notify_unresolved_sigkill(guest, None).await,
}
}
Ok(value)
}
async fn gone_pidfd_signal_answer<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
signal: i32,
) -> Result<i64, Error> {
let info = match call {
Syscall::Other(_, args) => args.arg2,
_ => 0,
};
let Some(info) = AddrMut::<libc::siginfo_t>::from_raw(info) else {
return Err(Errno::ESRCH.into());
};
let signo = guest.memory().read_value(info.cast::<libc::c_int>()).ok();
let checked = guest
.inject(
syscalls::RtSigqueueinfo::new()
.with_tgid(super::signal::NO_SUCH_PID)
.with_sig(signo.unwrap_or(signal))
.with_siginfo(Some(info)),
)
.await;
let answer = match checked {
Err(errno @ (Errno::EPERM | Errno::ESRCH)) => errno,
Err(errno) => return Err(errno.into()),
Ok(_) => Errno::ESRCH,
};
let Some(signo) = signo else {
tracing::error!(
"[detcore, dtid {}] pidfd_send_signal to a gone process with a siginfo_t at \
{:#x} is not supported: Hermit cannot read its si_signo \
(https://github.com/rrnewton/hermit/issues/4108)",
guest.thread_state().dettid,
info.as_raw(),
);
return self
.refuse_unserviceable_operation(guest, Sysno::pidfd_send_signal, Errno::ENOSYS)
.await;
};
if signo != signal {
return Err(Errno::EINVAL.into());
}
Err(answer.into())
}
pub async fn handle_pidfd_getfd<G: Guest<Self>>(
&self,
guest: &mut G,
call: Syscall,
pidfd: RawFd,
targetfd: RawFd,
flags: u32,
) -> Result<i64, Error> {
if flags != 0 {
return match self.record_or_replay(guest, call).await {
Err(error) => Err(error.into()),
Ok(fd) => {
let fd = fd as RawFd;
let close_result = guest.inject(syscalls::Close::new().with_fd(fd)).await;
Err(Error::Tool(anyhow::anyhow!(
"pidfd_getfd unexpectedly accepted reserved flags and returned fd {fd}; cleanup close result: {close_result:?}"
)))
}
};
}
if !guest.config().sequentialize_threads {
return self
.refuse_unserviceable_operation(guest, Sysno::pidfd_getfd, Errno::EOPNOTSUPP)
.await;
}
let (current_tgid, current_tid) = match guest.thread_state().detpid {
Some(detpid) if guest.thread_state().nested_pid_namespace => {
(detpid, guest.thread_state().dettid)
}
_ => (
DetPid::from_raw(guest.inject(syscalls::Getpid::new()).await? as i32),
DetTid::from_raw(guest.inject(syscalls::Gettid::new()).await? as i32),
),
};
let source = guest.thread_state().capture_pidfd_getfd_source(
pidfd,
targetfd,
current_tgid,
current_tid,
)?;
let fd = match self.record_or_replay(guest, call).await {
Ok(fd) => fd as RawFd,
Err(error) => {
if let Some(open_file_id) = guest.thread_state().abandon_captured_fd(source) {
self.release_port_for_open_file(guest, open_file_id).await;
}
return Err(error.into());
}
};
let replaced = match guest.thread_state_mut().install_captured_fd(
source,
fd,
OFlag::O_CLOEXEC,
) {
Ok(replaced) => replaced,
Err(error @ CapturedDetFdInstallError { .. }) => {
let expected_files_id = error.expected_files_id;
let actual_files_id = error.actual_files_id;
let cleanup = error.into_cleanup();
let close_result = guest
.inject(syscalls::Close::new().with_fd(cleanup.close_fd))
.await;
if let Some(open_file_id) = cleanup.release_open_file {
self.release_port_for_open_file(guest, open_file_id).await;
}
if let Err(close_error) = close_result {
return Err(Error::Tool(anyhow::anyhow!(
"pidfd_getfd returned fd {fd}, but its captured source table changed from {expected_files_id:?} to {actual_files_id:?}; cleanup close failed with {close_error}"
)));
}
warn!(
"pidfd_getfd returned fd {fd}, but its captured source table changed from {expected_files_id:?} to {actual_files_id:?}; closed the result and refusing with EOPNOTSUPP"
);
return Err(Errno::EOPNOTSUPP.into());
}
};
if let Some(open_file_id) = replaced {
self.release_port_for_open_file(guest, open_file_id).await;
}
self.refresh_description_locks(guest, fd, LockCall::PidfdGetfd)
.await?;
Ok(fd as i64)
}
pub async fn handle_userfaultfd<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Userfaultfd,
) -> Result<i64, Error> {
let fd = self.record_or_replay(guest, call).await? as RawFd;
self.add_fd(
guest,
fd,
OFlag::from_bits_truncate(call.flags()),
FdType::Userfaultfd,
)
.await?;
Ok(fd as i64)
}
pub async fn handle_accept4<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Accept4,
) -> Result<i64, Error> {
let physically_nonblocking =
self.cfg.use_nonblocking_sockets() && !self.cfg.recordreplay_modes;
let call2 = if physically_nonblocking {
call.with_flags(call.flags() | SockFlag::SOCK_NONBLOCK)
} else {
call
};
let in_turn = self.accept_in_turn_enabled()
&& guest
.thread_state()
.with_detfd(call.sockfd(), |detfd| detfd.is_accept_in_turn_listener())
.unwrap_or(false);
let fd = if in_turn {
self.accept_in_turn(guest, call2).await? as RawFd
} else {
self.execute_nonblockable_fd_syscall(guest, call2).await? as RawFd
};
self.add_fd(
guest,
fd,
oflag_from_sock_bits(call.flags().bits()),
FdType::Socket,
)
.await?;
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_accepted_connection())?;
if physically_nonblocking {
self.maybe_set_nonblocking_fd(guest, fd);
}
Ok(fd as i64)
}
pub async fn handle_getdents<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Getdents,
) -> Result<i64, Error> {
let virtualize = guest.config().virtualize_metadata;
if !virtualize
&& (call.dirent().is_none()
|| !self.is_caller_descriptor_table(guest, call.fd() as i32))
{
return Ok(self.record_or_replay(guest, call).await?);
}
let buf = call.dirent().ok_or(Errno::EFAULT)?.cast::<u8>();
let call = GetdentsCall {
call: Syscall::from(call),
empty: Syscall::from(call.with_count(0)),
fd: call.fd() as i32,
buf,
capacity: call.count() as usize,
format: DirentFormat::Legacy,
};
if virtualize {
self.serve_directory_stream(guest, call).await
} else {
self.project_one_buffer(guest, call).await
}
}
pub async fn handle_getdents64<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Getdents64,
) -> Result<i64, Error> {
let virtualize = guest.config().virtualize_metadata;
if !virtualize
&& (call.dirent().is_none()
|| !self.is_caller_descriptor_table(guest, call.fd() as i32))
{
return Ok(self.record_or_replay(guest, call).await?);
}
let buf = call.dirent().ok_or(Errno::EFAULT)?.cast::<u8>();
let call = GetdentsCall {
call: Syscall::from(call),
empty: Syscall::from(call.with_count(0)),
fd: call.fd() as i32,
buf,
capacity: call.count() as usize,
format: DirentFormat::Dirent64,
};
if virtualize {
self.serve_directory_stream(guest, call).await
} else {
self.project_one_buffer(guest, call).await
}
}
async fn serve_directory_stream<G: Guest<Self>>(
&self,
guest: &mut G,
call: GetdentsCall<'_>,
) -> Result<i64, Error> {
let negative = i32::try_from(call.capacity).is_err();
let lock = match guest
.thread_state()
.with_detfd(call.fd, |detfd| detfd.directory_lock())
{
Ok(lock) => lock,
Err(Errno::EBADF) if negative => {
return self.serve_negative_count(guest, call, None).await;
}
Err(Errno::EBADF) => return self.project_one_buffer(guest, call).await,
Err(errno) => return Err(errno.into()),
};
let _serving = lock.lock().await;
let (host_order, needs_snapshot, position) =
guest.thread_state().with_detfd(call.fd, |detfd| {
(
detfd.directory_in_host_order(),
detfd.directory_needs_snapshot(),
detfd.with_directory_stream(|stream| stream.position()).ok(),
)
})?;
if negative {
let stream = if host_order {
None
} else {
position.map(|position| (position, needs_snapshot))
};
return self.serve_negative_count(guest, call, stream).await;
}
if host_order {
return self.project_one_buffer(guest, call).await;
}
if !needs_snapshot {
return self.serve_next_batch(guest, call).await;
}
let mark = directory_snapshot_mark(guest).await;
if let Some((entries, inodes, order)) = self.modeled_directory_snapshot(guest, call).await?
{
let mut entries = Some(entries);
guest.thread_state().with_detfd(call.fd, |detfd| {
detfd.install_directory_snapshot(
entries.take().unwrap_or_default(),
mark,
inodes.clone(),
order,
)
})?;
return self.serve_next_batch(guest, call).await;
}
let inodes = self.directory_inodes(guest, call.fd).await?;
match self.snapshot_directory_privately(guest, call).await {
Ok(Some(entries)) => {
let mut entries = Some(entries);
guest.thread_state().with_detfd(call.fd, |detfd| {
detfd.install_directory_snapshot(
entries.take().unwrap_or_default(),
mark,
inodes.clone(),
DirectoryOrder::NameBytes,
)
})?;
self.serve_next_batch(guest, call).await
}
Ok(None) => {
guest
.thread_state()
.with_detfd(call.fd, |detfd| detfd.use_host_directory_order())?;
self.project_one_buffer(guest, call).await
}
Err(error) => Err(error),
}
}
async fn serve_negative_count<G: Guest<Self>>(
&self,
guest: &mut G,
call: GetdentsCall<'_>,
stream: Option<(u64, bool)>,
) -> Result<i64, Error> {
if let Some((_, true)) = stream {
self.move_directory_kernel_position(guest, call.fd, 0).await;
}
let kernel = self.record_or_replay(guest, call.empty).await;
match kernel {
Ok(_) | Err(Errno::EINVAL) => {}
Err(errno) => return Err(errno.into()),
}
match stream {
None | Some((0, true)) => return Ok(kernel.map(|_| 0)?),
Some((_, true)) => {
let mark = directory_snapshot_mark(guest).await;
let modeled = self.modeled_directory_snapshot(guest, call).await?;
let (snapshot, inodes, order) = match modeled {
Some((entries, inodes, order)) => (Ok(Some(entries)), inodes, order),
None => {
let inodes = self.directory_inodes(guest, call.fd).await?;
(
self.snapshot_directory_privately(guest, call).await,
inodes,
DirectoryOrder::NameBytes,
)
}
};
match snapshot {
Ok(Some(entries)) => {
let mut entries = Some(entries);
let target = guest.thread_state().with_detfd(call.fd, |detfd| {
detfd.install_directory_snapshot(
entries.take().unwrap_or_default(),
mark,
inodes.clone(),
order,
);
detfd.with_directory_stream(|stream| stream.kernel_target())
})??;
self.move_directory_kernel_position(guest, call.fd, target)
.await;
}
Ok(None) => return Ok(kernel.map(|_| 0)?),
Err(error) => return Err(error),
}
}
Some((_, false)) => {}
}
let batch = guest.thread_state().with_detfd(call.fd, |detfd| {
detfd.with_directory_stream(|stream| stream.next_batch(call.format, 0))
})??;
batch?;
Ok(0)
}
async fn serve_next_batch<G: Guest<Self>>(
&self,
guest: &mut G,
call: GetdentsCall<'_>,
) -> Result<i64, Error> {
let (start, batch, mark, inodes) =
guest.thread_state().with_detfd(call.fd, |detfd| {
detfd.with_directory_stream(|stream| {
(
stream.position(),
stream.next_batch(call.format, call.capacity),
stream.snapshot_mark(),
stream.snapshot_inodes(),
)
})
})??;
let (passed, copied) = match batch {
Ok(batch) => {
let inodes = match inodes {
Some(inodes) => inodes,
None => self.directory_inodes(guest, call.fd).await?,
};
let mut records = Vec::new();
let mut names = Vec::with_capacity(batch.len());
for (index, entry) in batch.iter().enumerate() {
let (host, path) = inodes.entry_inode(&entry.name, entry.ino);
let files = self.rendered_files(guest);
let d_ino = match self
.rendered_listed_inode(guest, &inodes, &entry.name, entry.ino, files)
.await?
{
Some(inode) => DetInode::mint(inode),
None => determinize_listed_inode(guest, host, path, mark).await.0,
};
let d_off = i64::try_from(start + index as u64 + 1).unwrap_or(i64::MAX);
call.format
.encode(entry, d_ino.as_raw(), d_off, &mut records);
names.push(entry.name.len());
}
copy_records(
&mut guest.memory(),
call.buf,
call.format,
&records,
&names,
start,
)
}
Err(errno) => (0, Err(errno)),
};
let target = guest.thread_state().with_detfd(call.fd, |detfd| {
detfd.with_directory_stream(|stream| {
stream.advance(passed);
stream.kernel_target()
})
});
if let Ok(Ok(target)) = target {
self.move_directory_kernel_position(guest, call.fd, target)
.await;
}
Ok(copied.map(|len| len as i64)?)
}
async fn modeled_directory_snapshot<G: Guest<Self>>(
&self,
guest: &mut G,
call: GetdentsCall<'_>,
) -> Result<Option<(Vec<DirEntry>, DirectoryInodes, DirectoryOrder)>, Error> {
let fd = call.fd;
use std::os::unix::ffi::OsStrExt;
use crate::procfs::listing;
use crate::procfs::listing::ModeledDirectory;
let state = guest.thread_state();
if self.cfg.recordreplay_modes
|| state.nested_pid_namespace
|| state.changed_root.load(Ordering::SeqCst)
{
return Ok(None);
}
let Ok((spelled, status_flags)) =
state.with_detfd(fd, |detfd| (detfd.path(), detfd.status_flags()))
else {
return Ok(None);
};
if status_flags & libc::O_PATH != 0 {
return Ok(None);
}
let kernel_named = || {
std::fs::read_link(format!("/proc/thread-self/fd/{fd}"))
.is_ok_and(|kernel| listing::classify(&kernel, 0, 0).is_some())
};
if spelled
.as_deref()
.and_then(|spelled| listing::classify(spelled, 0, 0))
.is_none()
&& !(Self::translates_procfs_numbers(guest)
&& guest.config().backend.tool_shares_guest_descriptor_table
&& kernel_named())
{
return Ok(None);
}
let state = guest.thread_state();
let tid = state.dettid.as_raw();
let names_tasks =
procfs_inode::guest_tids_name_host_tasks(&self.cfg.backend, state.physical_tid);
let pid = self.own_detpid(guest).as_raw();
let cached = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.stat())
.ok()
.flatten();
let stat = match cached {
Some(stat) => stat,
None => DetStat::from(self.inject_fstat(guest, fd).await?),
};
if stat.mode & libc::S_IFMT != libc::S_IFDIR {
return Ok(None);
}
let backend_procfs =
procfs_inode::is_backend_procfs_device(&self.cfg.backend, stat.dev, stat.blksize);
let translates = Self::translates_procfs_numbers(guest)
&& rendered_procfs::proc_device() == Some(stat.dev);
let path = if names_tasks && rendered_procfs::proc_device() == Some(stat.dev) {
match Self::procfs_entry(guest, &stat, StatTarget::Descriptor(fd)).await {
ProcfsEntry::At(within) => {
Path::new("/proc").join(within.strip_prefix("/").unwrap_or(&within))
}
ProcfsEntry::NotProcfs | ProcfsEntry::Unnamed | ProcfsEntry::Unknown => {
return Ok(None);
}
}
} else if translates {
match Self::guest_procfs_spelling(guest, fd).await {
Some(path) => path,
None => return Ok(None),
}
} else if backend_procfs && let Some(spelled) = spelled {
spelled
} else {
return Ok(None);
};
let Some(directory) = listing::classify(&path, pid, tid) else {
return Ok(None);
};
if backend_procfs && !matches!(directory, ModeledDirectory::System(_)) {
return Ok(None);
}
let process = match directory {
ModeledDirectory::System(_) => None,
ModeledDirectory::Process(process)
| ModeledDirectory::Thread(process, _)
| ModeledDirectory::Tasks(process) => Some(DetPid::from_raw(process)),
};
let facts = crate::tool_global::procfs_listing(guest, process).await;
let listed = match directory {
ModeledDirectory::System(_) => true,
ModeledDirectory::Process(process) => {
process == 1 || facts.processes.contains(&process)
}
ModeledDirectory::Thread(_, thread) => facts.threads.contains(&thread),
ModeledDirectory::Tasks(_) => !facts.threads.is_empty(),
};
if !listed {
return Ok(None);
}
let Some(names) = listing::entries(&directory, self.cfg.proc_level, &facts) else {
return Ok(None);
};
let host = if backend_procfs {
let known = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.has_directory_stream())?;
let position = syscalls::Lseek::new()
.with_fd(fd)
.with_offset(0)
.with_whence(Whence::SEEK_CUR);
if !known && self.record_or_replay(guest, position).await != Ok(0) {
return Ok(None);
}
Vec::new()
} else {
let Some(host) = self.snapshot_directory_privately(guest, call).await? else {
return Ok(None);
};
host
};
let host_numbers = if translates {
let held = host
.iter()
.filter(|entry| {
crate::procfs::ids::names_an_id(&path, std::ffi::OsStr::from_bytes(&entry.name))
})
.filter_map(|entry| std::str::from_utf8(&entry.name).ok()?.parse::<i32>().ok())
.collect::<Vec<_>>();
Self::guest_procfs_numbers(guest, &held)
.await
.unwrap_or_default()
} else {
BTreeMap::new()
};
let host_cookies: std::collections::HashMap<Vec<u8>, i64> = host
.iter()
.filter_map(|entry| {
if !translates
|| !crate::procfs::ids::names_an_id(
&path,
std::ffi::OsStr::from_bytes(&entry.name),
)
{
return Some((entry.name.clone(), entry.off));
}
let kernel = std::str::from_utf8(&entry.name).ok()?.parse::<i32>().ok()?;
let guest = host_numbers.get(&kernel)?;
Some((guest.to_string().into_bytes(), entry.off))
})
.collect();
let host_cookie = |name: &[u8]| host_cookies.get(name).copied().unwrap_or(0);
let session_files = self.rendered_files(guest);
let host_end = host.last().map_or(0, |entry| entry.off);
let (lookup_dir, spellings): (RawFd, Vec<PathBuf>) = if backend_procfs || translates {
let spellings = names
.iter()
.map(|(name, _)| path.join(std::ffi::OsStr::from_bytes(name)))
.collect();
(libc::AT_FDCWD, spellings)
} else {
let spellings = names
.iter()
.map(|(name, _)| PathBuf::from(std::ffi::OsStr::from_bytes(name)))
.collect();
(fd, spellings)
};
let looked_up = self.looked_up_inodes(guest, lookup_dir, &spellings).await?;
let within = listing::within(&directory);
let entries = names
.into_iter()
.zip(looked_up)
.filter_map(|((name, ty), looked_up)| {
let entry = match name.as_slice() {
b"." => within.clone(),
b".." => within.parent().unwrap_or(&within).to_path_buf(),
name => within.join(std::ffi::OsStr::from_bytes(name)),
};
let rendered = crate::procfs::ProcfsFile::from_path(
&Path::new("/proc").join(entry.strip_prefix("/").unwrap_or(&entry)),
)
.is_some_and(|file| file.rendered_path(session_files).is_some());
let ino = match looked_up {
Ok(ino) => ino,
Err(Errno::ENOENT)
if name != b"." && name != b".." && !rendered && !backend_procfs =>
{
return None;
}
Err(_) => procfs_inode::path_inode(stat.dev, &entry).ino,
};
Some(DirEntry {
ino,
off: host_cookie(&name),
ty,
name,
})
})
.collect::<Vec<_>>();
let mut entries = entries;
entries.sort_by_key(|entry| entry.off);
if let Some(last) = entries.last_mut() {
last.off = last.off.max(host_end);
}
let inodes = DirectoryInodes::new(stat.dev, Some(ProcfsDirectory::new(within)));
let order = match &directory {
ModeledDirectory::System(names) if names.is_empty() => DirectoryOrder::ProcfsIds,
ModeledDirectory::Tasks(_) => DirectoryOrder::ProcfsIds,
_ => DirectoryOrder::NameBytes,
};
Ok(Some((entries, inodes, order)))
}
async fn looked_up_inodes<G: Guest<Self>>(
&self,
guest: &mut G,
dir: RawFd,
paths: &[PathBuf],
) -> Result<Vec<Result<u64, Errno>>, Error> {
use std::os::unix::ffi::OsStrExt;
let mapped = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(DIRECTORY_PAGE)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await;
let Some(page) = mapped
.ok()
.and_then(|addr| usize::try_from(addr).ok())
.and_then(AddrMut::<u8>::from_raw)
else {
return Ok(vec![Err(Errno::ENOMEM); paths.len()]);
};
let mut inodes = Vec::with_capacity(paths.len());
for path in paths {
let mut bytes = path.as_os_str().as_bytes().to_vec();
bytes.push(0);
let staged =
bytes.len() <= DIRECTORY_PAGE && guest.memory().write_exact(page, &bytes).is_ok();
let staged_path = PathPtr::from_ptr(page.as_raw() as *const libc::c_char);
let inode = match (staged, staged_path) {
(true, Some(staged_path)) => Self::inject_statat(
guest,
dir,
staged_path,
[Some(staged_path), None],
AtFlags::AT_SYMLINK_NOFOLLOW,
)
.await
.map(|stat| stat.st_ino),
_ => Err(Errno::ENAMETOOLONG),
};
inodes.push(inode);
}
guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(Addr::from(page).cast()))
.with_len(DIRECTORY_PAGE),
))
.await?;
Ok(inodes)
}
async fn directory_inodes<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<DirectoryInodes, Errno> {
let cached = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.stat())
.ok()
.flatten();
let stat = match cached {
Some(stat) => stat,
None => DetStat::from(self.inject_fstat(guest, fd).await?),
};
let procfs = match Self::procfs_entry(guest, &stat, StatTarget::Descriptor(fd)).await {
ProcfsEntry::At(within) => Some(ProcfsDirectory::new(within)),
ProcfsEntry::NotProcfs | ProcfsEntry::Unnamed | ProcfsEntry::Unknown => None,
};
Ok(DirectoryInodes::new(stat.dev, procfs))
}
async fn move_directory_kernel_position<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
target: i64,
) {
let seek = syscalls::Lseek::new()
.with_fd(fd)
.with_offset(target)
.with_whence(Whence::SEEK_SET);
let _ = self.record_or_replay(guest, seek).await;
}
fn drop_absent_entries<G: Guest<Self>>(
&self,
guest: &G,
fd: RawFd,
entries: &mut Vec<DirEntry>,
) {
if self.cfg.recordreplay_modes {
return;
}
let link = format!("{}/fd/{fd}", self.caller_proc_directory(guest));
let tool_sees_caller =
crate::procfs_inode::tool_can_name_guest_descriptors(&self.cfg.backend);
let directory_metadata = tool_sees_caller
.then(|| std::fs::metadata(&link).ok())
.flatten();
let on_procfs = match (&directory_metadata, rendered_procfs::proc_device()) {
(Some(metadata), Some(device)) => metadata.dev() == device,
_ => false,
};
if self.is_caller_descriptor_table(guest, fd) {
entries.retain(|entry| {
!runtime_owned_descriptor_entry(&entry.name, |fd| guest.is_runtime_owned_fd(fd))
});
}
let directory = std::fs::read_link(&link)
.ok()
.or_else(|| {
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.path())
.ok()
.flatten()
})
.filter(|path| path.is_absolute());
let directory = match (directory, self.guest_root_in_view(guest)) {
(Some(directory), Some(Some(root))) if !directory.starts_with("/proc") => directory
.strip_prefix(&root)
.ok()
.map(|below| Path::new("/").join(below))
.or(Some(directory)),
(directory, _) => directory,
};
if let Some(directory) = directory {
let level = self.cfg.proc_level;
entries.retain(|entry| {
!is_absent_cpu_entry(&directory, &entry.name)
&& !(on_procfs && levels::absent_entry(&directory, &entry.name, level))
});
}
}
fn is_caller_descriptor_table<G: Guest<Self>>(&self, guest: &G, fd: RawFd) -> bool {
if self.cfg.recordreplay_modes
|| !crate::procfs_inode::tool_can_name_guest_descriptors(&self.cfg.backend)
{
return false;
}
let link = format!("{}/fd/{fd}", self.caller_proc_directory(guest));
let directory_metadata = std::fs::metadata(link).ok();
let on_procfs = match (&directory_metadata, rendered_procfs::proc_device()) {
(Some(metadata), Some(device)) => metadata.dev() == device,
_ => false,
};
let state = guest.thread_state();
let holds_process_table =
state.dettid == self.own_detpid(guest) || state.holds_process_files();
let process = if self.cfg.backend.tool_shares_guest_descriptor_table {
String::from("/proc/self")
} else {
format!("/proc/{}", guest.pid().as_raw())
};
on_procfs
&& directory_metadata.as_ref().is_some_and(|metadata| {
is_caller_descriptor_directory(
metadata,
&self.caller_proc_directory(guest),
holds_process_table.then_some(process.as_str()),
)
})
}
async fn project_one_buffer<G: Guest<Self>>(
&self,
guest: &mut G,
call: GetdentsCall<'_>,
) -> Result<i64, Error> {
let virtualize = guest.config().virtualize_metadata;
let mut written = 0;
let mut dropped = false;
let (len, mut entries) = loop {
let len = match self.record_or_replay(guest, call.call).await {
Ok(len) => len as usize,
Err(error) => {
if written > 0 {
guest.memory().write_exact(call.buf, &vec![0; written])?;
}
return Err(error.into());
}
};
if len == 0 {
if written > 0 {
guest.memory().write_exact(call.buf, &vec![0; written])?;
}
return Ok(0);
}
written = written.max(len);
let mut entries = match read_records(&guest.memory(), call.buf, len, call.format) {
Ok(entries) => entries,
Err(error) => {
guest.memory().write_exact(call.buf, &vec![0; written])?;
return Err(error.into());
}
};
if virtualize {
self.drop_absent_entries(guest, call.fd, &mut entries);
} else {
let original = entries.len();
entries.retain(|entry| {
!runtime_owned_descriptor_entry(&entry.name, |fd| guest.is_runtime_owned_fd(fd))
});
if entries.len() == original && !dropped {
return Ok(len as i64);
}
dropped = true;
}
if !entries.is_empty() {
break (len, entries);
}
};
let inodes = if virtualize {
sort_dir_entries(&mut entries);
Some(self.directory_inodes(guest, call.fd).await?)
} else {
None
};
let mut records = Vec::with_capacity(len);
for entry in &entries {
let Some(inodes) = &inodes else {
call.format
.encode(entry, entry.ino, entry.off, &mut records);
continue;
};
let (host, path) = inodes.entry_inode(&entry.name, entry.ino);
let files = self.rendered_files(guest);
let d_ino = match self
.rendered_listed_inode(guest, inodes, &entry.name, entry.ino, files)
.await?
{
Some(inode) => DetInode::mint(inode),
None => determinize_named_inode(guest, host, path).await.0,
};
call.format
.encode(entry, d_ino.as_raw(), entry.off, &mut records);
}
let returned = records.len();
records.resize(returned.max(written), 0);
if guest.memory().write_exact(call.buf, &records).is_err() {
let written = entries.last().map_or(0, |last| {
returned - call.format.record_len(last.name.len())
+ call.format.written_len(last.name.len())
});
guest.memory().write_exact(call.buf, &records[..written])?;
}
Ok(returned as i64)
}
async fn snapshot_directory_privately<G: Guest<Self>>(
&self,
guest: &mut G,
call: GetdentsCall<'_>,
) -> Result<Option<Vec<DirEntry>>, Error> {
let mut mapping = None;
for len in [DIRECTORY_DRAIN_COUNT as usize, DIRECTORY_PAGE] {
let mapped = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(len)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await;
if let Some(scratch) = mapped
.ok()
.and_then(|addr| usize::try_from(addr).ok())
.and_then(AddrMut::<u8>::from_raw)
{
mapping = Some((scratch, len));
break;
}
}
let Some((scratch, len)) = mapping else {
return Err(Errno::ENOMEM.into());
};
let snapshot = self
.snapshot_directory(guest, call.into_scratch(scratch, len as u32))
.await;
let unmapped = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(Addr::from(scratch).cast()))
.with_len(len),
))
.await;
unmapped?;
let mut snapshot = snapshot?;
if let Some(entries) = &mut snapshot {
self.drop_absent_entries(guest, call.fd, entries);
}
Ok(snapshot)
}
async fn snapshot_directory<G: Guest<Self>>(
&self,
guest: &mut G,
call: GetdentsCall<'_>,
) -> Result<Option<Vec<DirEntry>>, Error> {
let known_directory = guest
.thread_state()
.with_detfd(call.fd, |detfd| detfd.has_directory_stream())?;
let lseek = |offset, whence| {
syscalls::Lseek::new()
.with_fd(call.fd)
.with_offset(offset)
.with_whence(whence)
};
if known_directory {
self.record_or_replay(guest, lseek(0, Whence::SEEK_SET))
.await?;
} else if self
.record_or_replay(guest, lseek(0, Whence::SEEK_CUR))
.await
!= Ok(0)
{
return Ok(None);
}
let mut entries = Vec::new();
let mut read_any = false;
let error: Error = loop {
let len = match self.record_or_replay(guest, call.call).await {
Ok(0) => return Ok(Some(entries)),
Ok(len) => len as usize,
Err(error) => break error.into(),
};
read_any = true;
match read_records(&guest.memory(), call.buf, len, call.format) {
Ok(parsed) => entries.extend(parsed),
Err(error) => break error.into(),
}
};
if !read_any {
return Err(error);
}
self.record_or_replay(guest, lseek(0, Whence::SEEK_SET))
.await?;
Ok(None)
}
}
const DIRECTORY_DRAIN_COUNT: u32 = 64 * 1024;
const DIRECTORY_PAGE: usize = 4096;
const PAGES_PER_COPY: usize = 1024;
fn guest_pages(addr: usize, len: usize) -> Vec<(usize, usize)> {
let mut pieces = Vec::with_capacity(len / DIRECTORY_PAGE + 2);
let mut at = 0;
while at < len {
let piece = (DIRECTORY_PAGE - (addr + at) % DIRECTORY_PAGE).min(len - at);
pieces.push((at, piece));
at += piece;
}
pieces
}
fn read_records(
memory: &impl MemoryAccess,
buf: AddrMut<u8>,
len: usize,
format: DirentFormat,
) -> Result<Vec<DirEntry>, Errno> {
let mut bytes = vec![0; len];
let readable = match memory.read_exact(buf, &mut bytes) {
Ok(()) => len,
Err(_) => read_guest_prefix(memory, buf, &mut bytes)?,
};
format.parse_written(&mut bytes, readable)
}
pub(crate) fn read_guest_prefix(
memory: &impl MemoryAccess,
buf: AddrMut<u8>,
bytes: &mut [u8],
) -> Result<usize, Errno> {
let mut done = 0;
for pages in guest_pages(buf.as_raw(), bytes.len()).chunks(PAGES_PER_COPY) {
let from = pages[0].0;
let len: usize = pages.iter().map(|&(_, len)| len).sum();
let remote: Vec<AddrSlice<u8>> = pages
.iter()
.map(|&(at, len)| unsafe { AddrSlice::from_raw_parts(buf.add(at).into(), len) })
.collect();
let remote: Vec<std::io::IoSlice> = remote
.iter()
.map(|piece| unsafe { piece.as_ioslice() })
.collect();
let mut local = [std::io::IoSliceMut::new(&mut bytes[from..from + len])];
let copied = match memory.read_vectored(&remote, &mut local) {
Err(Errno::EFAULT) => 0,
copied => copied?,
};
done += copied;
if copied < len {
break;
}
}
Ok(done)
}
fn write_guest_pieces(
memory: &mut impl MemoryAccess,
buf: AddrMut<u8>,
pieces: &[(usize, &[u8])],
) -> Result<usize, Errno> {
let mut done = 0;
for pieces in pieces.chunks(PAGES_PER_COPY) {
let len: usize = pieces.iter().map(|(_, bytes)| bytes.len()).sum();
let mut remote: Vec<AddrSliceMut<u8>> = pieces
.iter()
.map(|&(at, bytes)| unsafe { AddrSliceMut::from_raw_parts(buf.add(at), bytes.len()) })
.collect();
let mut remote: Vec<std::io::IoSliceMut> = remote
.iter_mut()
.map(|piece| unsafe { piece.as_ioslice_mut() })
.collect();
let local: Vec<std::io::IoSlice> = pieces
.iter()
.map(|&(_, bytes)| std::io::IoSlice::new(bytes))
.collect();
let copied = match memory.write_vectored(&local, &mut remote) {
Err(Errno::EFAULT) => 0,
copied => copied?,
};
done += copied;
if copied < len {
break;
}
}
Ok(done)
}
struct DirentStore {
at: usize,
from: std::ops::Range<usize>,
single: bool,
}
fn dirent_stores(
format: DirentFormat,
names: &[usize],
placeholder: usize,
) -> (Vec<DirentStore>, Vec<usize>) {
let field = |at: usize, len: usize| DirentStore {
at,
from: at..at + len,
single: true,
};
let mut stores = Vec::with_capacity(names.len() * 6 + 1);
let mut filled = Vec::with_capacity(names.len());
let mut previous = None;
let mut at = 0;
for &name_len in names {
let reclen = format.record_len(name_len);
let name = at + format.name_offset();
stores.push(match previous {
Some(previous) => field(previous + 8, 8),
None => DirentStore {
at: at + 8,
from: placeholder..placeholder + 8,
single: true,
},
});
stores.push(field(at, 8));
stores.push(field(at + 16, 2));
stores.push(field(at + format.type_offset(reclen), 1));
stores.push(field(name + name_len, 1));
stores.push(DirentStore {
at: name,
from: name..name + name_len,
single: false,
});
filled.push(stores.len());
previous = Some(at);
at += reclen;
}
if let Some(previous) = previous {
stores.push(field(previous + 8, 8));
}
(stores, filled)
}
fn copy_records(
memory: &mut impl MemoryAccess,
buf: AddrMut<u8>,
format: DirentFormat,
records: &[u8],
names: &[usize],
start: u64,
) -> (usize, Result<usize, Errno>) {
if names.is_empty() {
return (0, Ok(0));
}
let mut source = records.to_vec();
let placeholder = source.len();
source.extend_from_slice(&i64::try_from(start).unwrap_or(i64::MAX).to_ne_bytes());
let (stores, filled) = dirent_stores(format, names, placeholder);
let mut pieces: Vec<(usize, &[u8])> = Vec::with_capacity(stores.len());
let mut owner = Vec::with_capacity(stores.len());
let mut crossing = Vec::new();
for (index, store) in stores.iter().enumerate() {
let mut split = guest_pages(buf.as_raw() + store.at, store.from.len());
if store.single && split.len() > 1 {
let readable: Result<Vec<bool>, Errno> = split
.iter()
.map(|&(at, len)| {
let mut bytes = vec![0; len];
let addr = unsafe { buf.add(store.at + at) };
Ok(read_guest_prefix(memory, addr, &mut bytes)? == len)
})
.collect();
let mut readable = match readable {
Ok(readable) => readable,
Err(errno) => return (0, Err(errno)),
};
if readable[1] || !readable[0] {
split.reverse();
readable.reverse();
}
crossing.push((pieces.len(), readable[0]));
}
for (at, len) in split {
let from = store.from.start + at;
pieces.push((store.at + at, &source[from..from + len]));
owner.push(index);
}
}
let mut next = 0;
let mut saved: Option<(usize, Vec<u8>)> = None;
let mut failed = None;
for &(stop, readable) in crossing.iter().chain([(pieces.len(), false)].iter()) {
let segment = &pieces[next..stop];
let written = match write_guest_pieces(memory, buf, segment) {
Ok(written) => written,
Err(errno) => return (0, Err(errno)),
};
let mut end = 0;
if let Some(at) = segment.iter().position(|(_, bytes)| {
end += bytes.len();
end > written
}) {
failed = Some(next + at);
break;
}
if stop == pieces.len() {
break;
}
let (at, bytes) = pieces[stop];
let addr = unsafe { buf.add(at) };
let mut before = vec![0; bytes.len()];
let read = if readable {
match read_guest_prefix(memory, addr, &mut before) {
Ok(read) => read == before.len(),
Err(errno) => return (0, Err(errno)),
}
} else {
memory.read_exact(addr, &mut before).is_ok()
};
saved = read.then_some((stop, before));
next = stop;
}
let Some(failed) = failed else {
return (names.len(), Ok(records.len()));
};
let store = owner[failed];
if failed > 0
&& owner[failed - 1] == store
&& let Some((first, before)) = &saved
&& *first == failed - 1
&& let Err(errno) =
write_guest_pieces(memory, buf, &[(pieces[*first].0, before.as_slice())])
{
return (0, Err(errno));
}
let entry = filled.partition_point(|&end| end <= store);
let first = entry.checked_sub(1).map_or(0, |before| filled[before]);
let result = if entry == 0 || store == first {
Err(Errno::EFAULT)
} else {
Ok(names[..entry]
.iter()
.map(|&name_len| format.record_len(name_len))
.sum())
};
(entry, result)
}
#[derive(Clone, Copy)]
struct GetdentsCall<'a> {
call: Syscall,
empty: Syscall,
fd: RawFd,
buf: AddrMut<'a, u8>,
capacity: usize,
format: DirentFormat,
}
impl<'a> GetdentsCall<'a> {
fn into_scratch<'b>(self, buf: AddrMut<'b, u8>, count: u32) -> GetdentsCall<'b> {
let call = match self.call {
Syscall::Getdents(call) => {
Syscall::from(call.with_dirent(Some(buf.cast())).with_count(count))
}
Syscall::Getdents64(call) => {
Syscall::from(call.with_dirent(Some(buf.cast())).with_count(count))
}
other => other,
};
GetdentsCall {
call,
empty: self.empty,
fd: self.fd,
buf,
capacity: count as usize,
format: self.format,
}
}
}
fn signalfd_range_is_mapped(maps: &str, address: usize, len: usize) -> bool {
signalfd_range_is_covered(maps, address, len, false)
}
fn signalfd_range_is_writable(maps: &str, address: usize, len: usize) -> bool {
signalfd_range_is_covered(maps, address, len, true)
}
fn signalfd_next_record(extents: &[(usize, usize)], read: usize) -> Option<Vec<(usize, usize)>> {
const RECORD: usize = std::mem::size_of::<libc::signalfd_siginfo>();
let capacity = extents
.iter()
.try_fold(0usize, |total, (_, len)| total.checked_add(*len))?;
if capacity / RECORD <= read / RECORD {
return None;
}
let mut skip = read - read % RECORD;
let mut left = RECORD;
let mut pieces = Vec::new();
for (address, len) in extents {
if left == 0 {
break;
}
if skip >= *len {
skip -= len;
continue;
}
let take = (len - skip).min(left);
pieces.push((address + skip, take));
left -= take;
skip = 0;
}
Some(pieces)
}
fn user_address_end() -> usize {
static END: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
*END.get_or_init(|| {
const HINT: usize = 1 << 48;
let at = unsafe {
libc::mmap(
HINT as *mut libc::c_void,
4096,
libc::PROT_NONE,
libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
-1,
0,
)
};
if at == libc::MAP_FAILED {
return (1 << 47) - 4096;
}
unsafe { libc::munmap(at, 4096) };
if at as usize >= 1 << 47 {
(1 << 56) - 4096
} else {
(1 << 47) - 4096
}
})
}
fn is_caller_descriptor_directory(
observed: &std::fs::Metadata,
caller: &str,
process: Option<&str>,
) -> bool {
[Some(caller), process].into_iter().flatten().any(|owner| {
["fd", "fdinfo"].into_iter().any(|kind| {
std::fs::metadata(format!("{owner}/{kind}")).is_ok_and(|expected| {
observed.dev() == expected.dev() && observed.ino() == expected.ino()
})
})
})
}
fn runtime_owned_descriptor_entry(name: &[u8], owns: impl FnOnce(RawFd) -> bool) -> bool {
!name.is_empty()
&& name.iter().all(u8::is_ascii_digit)
&& std::str::from_utf8(name)
.ok()
.and_then(|name| name.parse::<RawFd>().ok())
.is_some_and(owns)
}
fn signalfd_sigmask(pid: i32, fd: i32) -> Option<u64> {
let info = std::fs::read_to_string(format!("/proc/{pid}/fdinfo/{fd}")).ok()?;
let mask = info
.lines()
.find_map(|line| line.strip_prefix("sigmask:"))?;
u64::from_str_radix(mask.trim(), 16).ok()
}
fn signalfd_range_is_covered(maps: &str, address: usize, len: usize, writable: bool) -> bool {
let mut ranges: Vec<(usize, usize)> = maps
.lines()
.filter_map(|line| {
let mut fields = line.split_whitespace();
let (start, end) = fields.next()?.split_once('-')?;
if writable && !fields.next()?.contains('w') {
return None;
}
Some((
usize::from_str_radix(start, 16).ok()?,
usize::from_str_radix(end, 16).ok()?,
))
})
.collect();
ranges.sort();
let Some(end) = address.checked_add(len) else {
return false;
};
let mut next = address;
for (start, stop) in ranges {
if start <= next && next < stop {
next = stop;
if next >= end {
return true;
}
}
}
false
}
#[cfg(test)]
mod guest_proc_visibility_tests {
use std::os::fd::AsRawFd;
use reverie::BackendCapabilities;
use super::reopens_scheduler_managed_pipe;
use super::resolved_open_path;
#[tokio::test]
async fn host_proc_links_are_read_except_under_kvm() {
let pid = std::process::id() as i32;
let (reader, _writer) = nix::unistd::pipe().unwrap();
let alias = nix::unistd::dup(&reader).unwrap();
let file = std::fs::File::open("/proc/self/exe").unwrap();
let (pipe_fd, alias_fd) = (reader.as_raw_fd(), alias.as_raw_fd());
let file_fd = file.as_raw_fd();
for backend in [
BackendCapabilities::PTRACE,
BackendCapabilities::LITEINST_IN_GUEST,
BackendCapabilities::DBT,
BackendCapabilities::SABRE,
] {
assert!(
reopens_scheduler_managed_pipe(&backend, pid, alias_fd, &[pipe_fd]),
"{backend:?}"
);
assert!(
resolved_open_path(&backend, pid, file_fd).is_some(),
"{backend:?}"
);
}
let kvm = BackendCapabilities::KVM;
assert!(!reopens_scheduler_managed_pipe(
&kvm,
pid,
alias_fd,
&[pipe_fd]
));
assert_eq!(resolved_open_path(&kvm, pid, file_fd), None);
for name in [
b"1023".as_slice(),
b"1025",
b"4096",
b".",
b"..",
b"+1024",
b"2147483648",
] {
assert!(!super::runtime_owned_descriptor_entry(name, |fd| fd == 1024));
}
assert!(super::runtime_owned_descriptor_entry(b"1024", |fd| fd == 1024));
assert!(!super::runtime_owned_descriptor_entry(b"1024", |_| false));
for kind in ["fd", "fdinfo"] {
let thread = std::fs::metadata(format!("/proc/thread-self/{kind}")).unwrap();
let process = std::fs::metadata(format!("/proc/self/{kind}")).unwrap();
assert!(super::is_caller_descriptor_directory(
&thread,
"/proc/thread-self",
None
));
assert!(!super::is_caller_descriptor_directory(
&process,
"/proc/thread-self",
None
));
assert!(super::is_caller_descriptor_directory(
&process,
"/proc/thread-self",
Some("/proc/self")
));
}
let ordinary = tempfile::tempdir().unwrap();
let metadata = std::fs::metadata(ordinary.path()).unwrap();
assert!(!super::is_caller_descriptor_directory(
&metadata,
"/proc/thread-self",
Some("/proc/self")
));
super::inject_fstat_scratch::raw_directory_projection().await;
}
}
#[cfg(test)]
mod signalfd_geometry_tests {
use super::signalfd_next_record;
use super::signalfd_range_is_mapped;
use super::signalfd_range_is_writable;
#[test]
fn an_iovec_array_is_mapped_only_when_mappings_cover_every_byte() {
let maps =
"1000-2000 r--p 0 0:0 0\n2000-3000 ---p 0 0:0 0 [vvar]\n5000-6000 rw-p 0 0:0 0\n";
assert!(signalfd_range_is_mapped(maps, 0x1ff0, 32));
assert!(
!signalfd_range_is_mapped(maps, 0x2ff0, 32),
"runs into a hole"
);
assert!(!signalfd_range_is_mapped(maps, 0x4000, 16));
assert!(!signalfd_range_is_mapped(maps, usize::MAX - 4, 16));
assert!(!signalfd_range_is_mapped("", 0x1000, 16));
}
#[test]
fn the_record_after_a_read_is_where_the_buffers_have_room_for_it() {
assert_eq!(
signalfd_next_record(&[(0x1000, 256)], 128),
Some(vec![(0x1080, 128)])
);
assert_eq!(signalfd_next_record(&[(0x1000, 255)], 128), None);
assert_eq!(signalfd_next_record(&[(0x1000, 128)], 128), None);
assert_eq!(
signalfd_next_record(&[(0x1000, 100), (0x3000, 60), (0x5000, 300)], 128),
Some(vec![(0x3000 + 28, 32), (0x5000, 96)])
);
assert_eq!(
signalfd_next_record(&[(0x1000, usize::MAX), (0x2000, 2)], 0),
None
);
let maps = "1000-2000 rw-p 0 0:0 0\n2000-3000 ---p 0 0:0 0\n";
assert!(signalfd_range_is_writable(maps, 0x1f80, 128));
assert!(!signalfd_range_is_writable(maps, 0x1fc0, 128));
assert!(signalfd_range_is_mapped(maps, 0x1fc0, 128));
}
}
#[cfg(test)]
mod procfs_wiring_guard {
fn production_source() -> &'static str {
const WHOLE: &str = include_str!("files.rs");
const GUARD: &str = "#[cfg(test)]\nmod procfs_wiring_guard {";
match WHOLE.find(GUARD) {
Some(cut) => &WHOLE[..cut],
None => WHOLE,
}
}
fn handler_body(name: &str) -> &'static str {
let start = production_source()
.find(&format!("fn {}<G: Guest<Self>>", name))
.unwrap_or_else(|| {
panic!(
"procfs wiring guard: handler `{name}` not found in files.rs.\n\
TWO VERY DIFFERENT CAUSES, and the guard cannot tell them apart:\n\
(a) the handler was RENAMED or its signature changed -- the \
mechanism is fine, update the name in this guard; or\n\
(b) the handler was DELETED -- the procfs snapshot wiring is gone.\n\
Check which before editing. This guard binds to source text on \
purpose: the handlers are async `Tool` methods taking a live Guest, \
so nothing cheaper can observe the call. It is deliberately loud \
when it cannot see the code, because silently passing is the \
failure it exists to prevent."
)
});
let rest = &production_source()[start..];
let end = rest
.find(
"
}
",
)
.map(|e| e + 6)
.unwrap_or(rest.len());
&rest[..end]
}
#[test]
fn pread64_initializes_the_procfs_snapshot() {
let body = handler_body("handle_pread64");
assert!(
body.contains("procfs_needs_snapshot") && body.contains("initialize_procfs_snapshot"),
"MISSING MECHANISM: the pread64 handler no longer initialises the procfs \
snapshot. Positioned reads will fall through to LIVE KERNEL BYTES instead of \
the sanitized ProcfsFile snapshot, reintroducing the positioned-read \
nondeterminism that hermit-cli/tests/procfs_positioned_determinism.rs exists \
to catch. Restore the `procfs_needs_snapshot` -> `initialize_procfs_snapshot` \
call in handle_pread64."
);
}
#[test]
fn read_initializes_the_procfs_snapshot() {
let body = handler_body("handle_read");
assert!(
body.contains("procfs_needs_snapshot") && body.contains("initialize_procfs_snapshot"),
"MISSING MECHANISM: the sequential read handler no longer initialises the \
procfs snapshot. Reads of /proc will observe live kernel bytes. Restore the \
`procfs_needs_snapshot` -> `initialize_procfs_snapshot` call in handle_read."
);
}
#[test]
fn both_read_paths_share_one_snapshot_initializer() {
let n = production_source()
.matches("async fn initialize_procfs_snapshot")
.count();
assert_eq!(
n, 1,
"MISSING MECHANISM: expected exactly ONE `initialize_procfs_snapshot` \
definition so every read path shares it; found {n}. Two initialisers is how \
read/pread64 drifted apart in the first place."
);
for handler in ["handle_read", "handle_pread64"] {
assert!(
handler_body(handler).contains("self.initialize_procfs_snapshot("),
"MISSING MECHANISM: `{handler}` does not call the shared \
initialize_procfs_snapshot."
);
}
}
#[test]
fn snapshot_initializer_excludes_host_seed_mounts_at_both_captures() {
let body = handler_body("initialize_procfs_snapshot");
let calls = body.matches("exclude_ephemeral_host_seed_mounts(").count();
assert_eq!(
calls, 2,
"MISSING MECHANISM: initialize_procfs_snapshot must call \
exclude_ephemeral_host_seed_mounts exactly twice (the guest mountinfo \
capture and the fdinfo mnt_id capture); found {calls}. Without it, \
unrelated host squashfuse seed mounts make /proc/<pid>/mountinfo and \
fdinfo mount IDs depend on host timing."
);
let guest_capture = body
.find("exclude_ephemeral_host_seed_mounts(&raw_contents)")
.expect(
"MISSING MECHANISM: the guest read's procfs capture (`raw_contents`) is \
no longer filtered for host seed mounts",
);
let gate = body[..guest_capture]
.rfind("let contents = if")
.map(|start| &body[start..guest_capture])
.unwrap_or_default();
assert!(
gate.contains("procfs_needs_mountinfo_identities()"),
"MISSING MECHANISM: the guest capture's seed filter must apply exactly to \
the files that carry mountinfo identities (`let contents = if ... \
procfs_needs_mountinfo_identities()`); found {gate:?}"
);
let fdinfo_capture = body
.find("exclude_ephemeral_host_seed_mounts(&mountinfo_contents)")
.expect(
"MISSING MECHANISM: the fdinfo mnt_id capture (`mountinfo_contents`) is \
no longer filtered for host seed mounts",
);
let parse = body
.find("parse_mountinfo(&mountinfo_contents)")
.expect("the fdinfo mnt_id capture no longer parses mountinfo_contents");
assert!(
fdinfo_capture < parse,
"MISSING MECHANISM: the fdinfo mnt_id capture parses mountinfo before \
dropping host seed rows"
);
}
#[test]
fn the_guard_can_actually_see_the_handlers() {
for handler in ["handle_read", "handle_pread64"] {
let body = handler_body(handler);
assert!(
body.len() > 200 && body.contains("call.fd()"),
"guard extractor did not find a real body for `{handler}` \
(len {}), so the wiring assertions would be vacuous",
body.len()
);
}
}
}
#[cfg(test)]
mod test {
use nix::fcntl::OFlag;
use reverie::syscalls::FromToRaw;
use reverie::syscalls::LocalMemory;
use reverie::syscalls::Whence;
use super::DETERMINISTIC_PIPE_CAPACITY_BYTES;
use super::fcntl_host_timed_signals;
use super::ioctl_host_timed_signals;
use super::may_have_acquired_controlling_terminal;
use super::open_can_acquire_controlling_terminal;
use super::opened_controlling_terminal;
use super::pipe_capacity_request_exceeds_ceiling;
use super::terminal_can_become_controlling;
use crate::test_pages::PAGE;
use crate::test_pages::Pages;
#[test]
fn a_proc_selector_leads_to_the_openers_task() {
use std::path::Path;
use super::procfs_selector_reached;
let own = Some((3, 5));
for (spelling, reached) in [
("/proc/self", Some("/proc/3")),
("/proc/self/", Some("/proc/3")),
("/proc/self/task", Some("/proc/3/task")),
("/proc/self/task/5", Some("/proc/3/task/5")),
("/proc/thread-self", Some("/proc/3/task/5")),
("/proc/self/fd/7", None),
("/proc/self/task/05", None),
("/proc/thread-self/fd/7", None),
("/proc/self/cwd", None),
("/proc/3", Some("/proc/3")),
("/proc/7/", Some("/proc/7")),
("/proc/7/task", Some("/proc/7/task")),
("/proc/7/task/9", Some("/proc/7/task/9")),
("/proc/07", None),
("/proc/7/task/09", None),
("/proc/7/fd", None),
("/proc/7/task/9/fd/1", None),
("/proc/sys", None),
("/proc", None),
("/proc/selfish", None),
("/dev/fd", None),
("self", None),
] {
assert_eq!(
procfs_selector_reached(Path::new(spelling), own).as_deref(),
reached.map(Path::new),
"{spelling}"
);
}
assert_eq!(procfs_selector_reached(Path::new("/proc/self"), None), None);
assert_eq!(procfs_selector_reached(Path::new("/proc/3"), None), None);
for (spelling, link) in [
("/proc/self", true),
("/proc/thread-self", true),
("/proc/self/", true),
("/proc/self/task", false),
("/proc/3", false),
("/proc/selfish", false),
] {
assert_eq!(
super::names_a_selector_link(Path::new(spelling)),
link,
"{spelling}"
);
}
let task = |process, thread| crate::procfs::BoundTask { process, thread };
for (reached, expected) in [
("/proc/3", Some(task(3, None))),
("/proc/3/task", Some(task(3, None))),
("/proc/3/task/5", Some(task(3, Some(5)))),
("/proc/3/task/5/ns", Some(task(3, Some(5)))),
("/proc/3/ns", Some(task(3, None))),
("/proc", None),
("/proc/sys", None),
("/proc/0", None),
] {
assert_eq!(
super::procfs_reached_task(Path::new(reached)),
expected,
"{reached}"
);
}
}
#[test]
fn an_open_through_a_descriptor_link_records_the_targets_path() {
use std::path::Path;
use std::path::PathBuf;
use super::DescriptorLinkOpener;
use super::path_to_record_for_open;
let leader = DescriptorLinkOpener {
own: Some((3, 3)),
holds_process_table: true,
};
let read = OFlag::O_RDONLY | OFlag::O_DIRECTORY;
let table = |fd: i32| match fd {
4 => Some(PathBuf::from("/proc")),
6 => Some(PathBuf::from("relative/dir")),
8 => Some(PathBuf::from("/proc/self")),
9 => Some(PathBuf::from("/proc/thread-self")),
10 => Some(PathBuf::from("/dev/fd")),
11 => Some(PathBuf::from("/proc/12")),
_ => None,
};
for spelling in [
"/proc/self/fd/4",
"/dev/fd/4",
"/proc/thread-self/fd/4",
"/proc/3/fd/4",
"/proc/3/task/3/fd/4",
] {
let recorded = path_to_record_for_open(Path::new(spelling), read, leader, table, None);
assert_eq!(recorded, Path::new("/proc"), "{spelling}");
assert_eq!(recorded.join("stat"), Path::new("/proc/stat"));
assert_eq!(
recorded.join("sys/kernel/random/uuid"),
Path::new("/proc/sys/kernel/random/uuid")
);
}
let first =
path_to_record_for_open(Path::new("/proc/self/fd/4"), read, leader, table, None);
let second = path_to_record_for_open(
Path::new("/dev/fd/9"),
read,
leader,
|fd| (fd == 9).then(|| first.clone()),
None,
);
assert_eq!(second, Path::new("/proc"));
let nofollow = OFlag::O_PATH | OFlag::O_NOFOLLOW;
assert_eq!(
path_to_record_for_open(Path::new("/proc/self/fd/4"), nofollow, leader, table, None),
Path::new("/proc/self/fd/4")
);
for spelling in ["/proc/self/fd/4/", "/proc/self/fd/4/.", "/dev/fd/4/"] {
assert_eq!(
path_to_record_for_open(Path::new(spelling), nofollow, leader, table, None),
Path::new("/proc"),
"{spelling}"
);
}
let split = DescriptorLinkOpener {
own: Some((3, 5)),
holds_process_table: false,
};
for spelling in ["/proc/self/fd/4", "/dev/fd/4", "/proc/3/fd/4"] {
assert_eq!(
path_to_record_for_open(
Path::new(spelling),
read,
split,
|_| { panic!("{spelling} names the leader's table, not the caller's") },
None
),
Path::new(spelling)
);
}
for spelling in ["/proc/thread-self/fd/4", "/proc/3/task/5/fd/4"] {
assert_eq!(
path_to_record_for_open(Path::new(spelling), read, split, table, None),
Path::new("/proc"),
"{spelling}"
);
}
for spelling in [
"/proc/self/fd/5",
"/proc/self/fd/6",
"/proc/self/fd/8",
"/proc/self/fd/9",
"/dev/fd/10",
"/proc/7/fd/4",
] {
assert_eq!(
path_to_record_for_open(Path::new(spelling), read, leader, table, None),
Path::new(spelling)
);
}
assert_eq!(
path_to_record_for_open(Path::new("/dev/fd/11"), read, leader, table, None),
Path::new("/proc/12")
);
for spelling in ["/proc/stat", "/proc/self/fd/4/stat", "/tmp/x"] {
assert_eq!(
path_to_record_for_open(
Path::new(spelling),
read,
leader,
|_| { panic!("{spelling} names no descriptor") },
None
),
Path::new(spelling)
);
}
use super::LinkSource;
let creator = crate::types::DetTid::from_raw(3);
let fifo = LinkSource {
fd: 5,
path: Some(PathBuf::from("/tmp/dir/fifo")),
open_file: crate::types::OpenFileId::new(creator, 7),
reached: None,
};
let replaced = Some(crate::types::OpenFileId::new(creator, 8));
let unchanged = Some(fifo.open_file);
let spelling = Path::new("/proc/self/fd/5");
assert_eq!(
path_to_record_for_open(
spelling,
read,
leader,
|fd| fifo.path_if_unchanged(fd, unchanged),
None
),
Path::new("/tmp/dir/fifo")
);
assert_eq!(
path_to_record_for_open(
spelling,
read,
leader,
|fd| fifo.path_if_unchanged(fd, replaced),
None
),
spelling
);
assert_eq!(
path_to_record_for_open(
spelling,
read,
leader,
|fd| fifo.path_if_unchanged(fd, None),
None
),
spelling
);
assert_eq!(fifo.path_if_unchanged(4, unchanged), None);
}
#[test]
fn an_open_through_an_unrecorded_descriptors_link_records_its_identity() {
use std::path::Path;
use std::path::PathBuf;
use super::DescriptorLinkOpener;
use super::path_to_record_for_open;
let leader = DescriptorLinkOpener {
own: Some((3, 3)),
holds_process_table: true,
};
let read = OFlag::O_RDONLY | OFlag::O_DIRECTORY;
let proc = || Some(PathBuf::from("/proc"));
for spelling in [
"/proc/self/fd/10",
"/dev/fd/10",
"/proc/thread-self/fd/10",
"/proc/3/fd/10",
"/proc/3/task/3/fd/10",
] {
let recorded =
path_to_record_for_open(Path::new(spelling), read, leader, |_| None, proc());
assert_eq!(recorded, Path::new("/proc"), "{spelling}");
assert_eq!(recorded.join("stat"), Path::new("/proc/stat"));
assert_eq!(
path_to_record_for_open(Path::new(spelling), read, leader, |_| None, None),
Path::new(spelling)
);
}
assert_eq!(
path_to_record_for_open(
Path::new("/proc/self/fd/4"),
read,
leader,
|fd| (fd == 4).then(|| PathBuf::from("/proc/12")),
proc(),
),
Path::new("/proc/12")
);
let nofollow = OFlag::O_PATH | OFlag::O_NOFOLLOW;
assert_eq!(
path_to_record_for_open(
Path::new("/proc/self/fd/10"),
nofollow,
leader,
|_| None,
proc()
),
Path::new("/proc/self/fd/10")
);
for spelling in ["/proc/self/fd/10/stat", "/tmp/x"] {
assert_eq!(
path_to_record_for_open(Path::new(spelling), read, leader, |_| None, proc()),
Path::new(spelling)
);
}
assert_eq!(
path_to_record_for_open(
Path::new("/proc/self/fd/8"),
read,
leader,
|_| Some(PathBuf::from("/proc/self")),
proc(),
),
Path::new("/proc/self/fd/8")
);
let split = DescriptorLinkOpener {
own: Some((3, 5)),
holds_process_table: false,
};
for spelling in ["/proc/self/fd/10", "/dev/fd/10", "/proc/3/fd/10"] {
assert_eq!(
path_to_record_for_open(Path::new(spelling), read, split, |_| None, proc()),
Path::new(spelling)
);
}
for spelling in ["/proc/thread-self/fd/10", "/proc/3/task/5/fd/10"] {
assert_eq!(
path_to_record_for_open(Path::new(spelling), read, split, |_| None, proc()),
Path::new("/proc"),
"{spelling}"
);
}
use super::procfs_directory_link;
for accepted in ["/proc", "/proc/sys", "/proc/sys/kernel", "/proc/sys/net"] {
assert!(procfs_directory_link(Path::new(accepted)), "{accepted}");
}
for refused in [
"/tmp/dir",
"/procfs",
"/proc (deleted)",
"/proc/sys (deleted)",
"/proc/12",
"/proc/12/task/12",
"/proc/self",
"/proc/thread-self",
"/proc/net",
"/proc/sys/../12",
"proc",
"anon_inode:[eventfd]",
"/memfd:x (deleted)",
] {
assert!(!procfs_directory_link(Path::new(refused)), "{refused}");
}
}
#[test]
fn a_received_procfs_directory_names_its_task_positions() {
use super::procfs_directory_task_positions;
let parsed = |link: &str| procfs_directory_task_positions(link);
let owned = |names: &[&str]| names.iter().map(|name| (*name).to_owned()).collect();
assert_eq!(parsed("/proc"), Some((Vec::new(), Vec::new())));
assert_eq!(
parsed("/proc/sys/kernel"),
Some((owned(&["sys", "kernel"]), Vec::new()))
);
assert_eq!(parsed("/proc/12"), Some((owned(&["12"]), vec![0])));
assert_eq!(parsed("/proc/12/ns"), Some((owned(&["12", "ns"]), vec![0])));
assert_eq!(parsed("/proc/12/fd"), Some((owned(&["12", "fd"]), vec![0])));
assert_eq!(
parsed("/proc/12/task/14"),
Some((owned(&["12", "task", "14"]), vec![0, 2]))
);
assert_eq!(
parsed("/proc/12/task/14/ns"),
Some((owned(&["12", "task", "14", "ns"]), vec![0, 2]))
);
assert_eq!(
parsed("/proc/irq/5"),
Some((owned(&["irq", "5"]), Vec::new()))
);
for refused in [
"/proc/012",
"/proc/12/task/014",
"/procfs",
"/tmp/12",
"proc/12",
"/proc/12 (deleted)",
"socket:[1]",
"/proc/12/../13",
] {
assert_eq!(parsed(refused), None, "{refused}");
}
}
#[test]
fn inherited_input_status_flags_remain_kernel_owned() {
for recordreplay_modes in [false, true] {
let tool = crate::Detcore {
detpid: crate::types::DetPid::from_raw(3),
cfg: crate::Config {
sequentialize_threads: true,
recordreplay_modes,
..Default::default()
},
record_or_replay: crate::record_or_replay::NoopTool,
};
for physically_nonblocking in [false, true] {
assert!(!tool.keeps_physically_nonblocking(
crate::fd::FdType::Pipe,
false,
physically_nonblocking,
true
));
assert_eq!(
tool.keeps_physically_nonblocking(
crate::fd::FdType::Pipe,
false,
physically_nonblocking,
false
),
!recordreplay_modes || physically_nonblocking
);
assert_eq!(
tool.keeps_physically_nonblocking(
crate::fd::FdType::Socket,
true,
physically_nonblocking,
false
),
!recordreplay_modes || physically_nonblocking
);
}
}
}
#[test]
fn async_io_arming_calls_name_their_host_timed_signals() {
use reverie::syscalls::FcntlCmd;
use reverie::syscalls::ioctl::Request;
let bit = |signal: i32| 1_u64 << (signal - 1);
let async_io = bit(libc::SIGIO) | bit(libc::SIGURG);
for (cmd, expected) in [
(
FcntlCmd::F_SETFL(libc::O_ASYNC | libc::O_NONBLOCK),
async_io,
),
(FcntlCmd::F_SETFL(libc::O_NONBLOCK), 0),
(FcntlCmd::F_SETOWN, async_io),
(FcntlCmd::F_SETOWN_EX(None), async_io),
(FcntlCmd::F_SETLEASE(libc::F_RDLCK), async_io),
(FcntlCmd::F_NOTIFY(0x2), async_io),
(
FcntlCmd::F_SETSIG(libc::SIGUSR1),
async_io | bit(libc::SIGUSR1),
),
(FcntlCmd::F_SETSIG(0), async_io),
(FcntlCmd::F_GETFL, 0),
(FcntlCmd::F_SETFD(libc::FD_CLOEXEC), 0),
] {
assert_eq!(fcntl_host_timed_signals(cmd), expected, "{cmd:?}");
}
for (request, expected) in [
(Request::FIOASYNC(None), async_io),
(Request::FIOSETOWN(None), async_io),
(Request::SIOCSPGRP(None), async_io),
(Request::FIOCLEX, 0),
] {
assert_eq!(ioctl_host_timed_signals(request), expected, "{request:?}");
}
}
#[test]
fn terminal_control_calls_name_the_terminal_signals() {
use reverie::syscalls::ioctl::Request;
let bit = |signal: i32| 1_u64 << (signal - 1);
let terminal = [
libc::SIGHUP,
libc::SIGCONT,
libc::SIGINT,
libc::SIGQUIT,
libc::SIGTSTP,
libc::SIGWINCH,
libc::SIGTTIN,
libc::SIGTTOU,
]
.into_iter()
.fold(0, |set, signal| set | bit(signal));
for (request, expected) in [
(Request::TIOCSCTTY(0), terminal),
(Request::TIOCSCTTY(1), terminal),
(Request::TIOCSPGRP(None), terminal),
(Request::TIOCGPTPEER(libc::O_RDWR), terminal),
(
Request::TIOCGPTPEER(libc::O_RDWR | libc::O_CLOEXEC),
terminal,
),
(Request::TIOCGPTPEER(libc::O_RDWR | libc::O_NOCTTY), 0),
(Request::TIOCGPGRP(None), 0),
(Request::TIOCNOTTY, 0),
(Request::TIOCSWINSZ(None), 0),
] {
assert_eq!(ioctl_host_timed_signals(request), expected, "{request:?}");
}
}
#[test]
fn an_open_acquires_a_controlling_terminal_only_as_a_session_leader() {
assert!(open_can_acquire_controlling_terminal(OFlag::O_RDWR));
assert!(!open_can_acquire_controlling_terminal(
OFlag::O_RDWR | OFlag::O_NOCTTY
));
assert!(!open_can_acquire_controlling_terminal(OFlag::O_PATH));
let table = Some(
"/dev/tty /dev/tty 5 0 system:/dev/tty\n\
/dev/console /dev/console 5 1 system:console\n\
/dev/ptmx /dev/ptmx 5 2 system\n\
/dev/vc/0 /dev/vc/0 4 0 system:vtmaster\n\
serial_8250 /dev/ttyS 4 64-95 serial\n\
acm serial /dev/ttyACM 166 0-255 serial\n\
pty_slave /dev/pts 136 0-1048575 pty:slave\n\
pty_master /dev/ptm 128 0-1048575 pty:master\n\
unknown /dev/tty 4 1-63 console\n",
);
let pts3 = libc::makedev(136, 3);
let pts300 = libc::makedev(136, 300);
assert!(may_have_acquired_controlling_terminal(42, 42, pts3, table));
assert!(may_have_acquired_controlling_terminal(
42, 42, pts300, table
));
assert!(!may_have_acquired_controlling_terminal(43, 42, pts3, table));
for (major, minor) in [(4, 64), (4, 95), (166, 7), (4, 1), (4, 63), (5, 0)] {
let rdev = libc::makedev(major, minor);
assert!(
terminal_can_become_controlling(rdev, table),
"{major}:{minor}"
);
}
for (major, minor) in [(5, 1), (5, 2), (4, 0), (128, 3), (4, 96), (188, 0), (1, 3)] {
let rdev = libc::makedev(major, minor);
assert!(
!terminal_can_become_controlling(rdev, table),
"{major}:{minor}"
);
}
let null = libc::makedev(1, 3);
assert!(terminal_can_become_controlling(pts3, None));
assert!(terminal_can_become_controlling(null, None));
assert!(!terminal_can_become_controlling(libc::makedev(5, 1), None));
let garbled = Some("pty_slave /dev/pts 136 0-1048575 pty:slave\nnot a driver line\n");
assert!(terminal_can_become_controlling(null, garbled));
assert!(terminal_can_become_controlling(pts3, garbled));
let master = Some("pty_master /dev/ptm 128 0-1048575 pty:master\nnot a driver line\n");
assert!(!terminal_can_become_controlling(
libc::makedev(128, 3),
master
));
}
#[test]
fn a_hangup_after_the_open_does_not_hide_the_acquired_terminal() {
use std::time::Duration;
use std::time::Instant;
struct Child(libc::pid_t);
impl Drop for Child {
fn drop(&mut self) {
unsafe {
libc::kill(self.0, libc::SIGKILL);
libc::waitpid(self.0, std::ptr::null_mut(), 0);
}
}
}
let flags = libc::O_RDWR | libc::O_NOCTTY | libc::O_CLOEXEC;
let master = unsafe { libc::posix_openpt(flags) };
assert!(
master >= 0,
"posix_openpt: {}",
std::io::Error::last_os_error()
);
assert_eq!(unsafe { libc::grantpt(master) }, 0);
assert_eq!(unsafe { libc::unlockpt(master) }, 0);
let mut slave_path = [0 as libc::c_char; 64];
let path_len = slave_path.len();
assert_eq!(
unsafe { libc::ptsname_r(master, slave_path.as_mut_ptr(), path_len) },
0
);
let (mut ready, mut release) = ([0; 2], [0; 2]);
assert_eq!(
unsafe { libc::pipe2(ready.as_mut_ptr(), libc::O_CLOEXEC) },
0
);
assert_eq!(
unsafe { libc::pipe2(release.as_mut_ptr(), libc::O_CLOEXEC) },
0
);
let pid = unsafe { libc::fork() };
assert!(pid >= 0, "fork: {}", std::io::Error::last_os_error());
if pid == 0 {
unsafe {
libc::alarm(60);
libc::signal(libc::SIGHUP, libc::SIG_IGN);
libc::close(master);
libc::close(ready[0]);
libc::close(release[1]);
if libc::setsid() < 0 {
libc::_exit(2);
}
let slave = libc::open(slave_path.as_ptr(), libc::O_RDWR);
if slave < 0 {
libc::_exit(3);
}
let bytes = slave.to_ne_bytes();
if libc::write(ready[1], bytes.as_ptr().cast(), bytes.len()) != 4 {
libc::_exit(4);
}
let mut byte = [0_u8; 1];
libc::read(release[0], byte.as_mut_ptr().cast(), 1);
libc::_exit(0);
}
}
let child = Child(pid);
unsafe {
libc::close(ready[1]);
libc::close(release[0]);
}
let mut bytes = [0_u8; 4];
let got = unsafe { libc::read(ready[0], bytes.as_mut_ptr().cast(), bytes.len()) };
assert_eq!(got, 4, "the child did not open the slave");
let slave = i32::from_ne_bytes(bytes);
let link = std::ffi::CString::new(format!("/proc/{pid}/fd/{slave}")).unwrap();
let mut host_stat: libc::stat = unsafe { std::mem::zeroed() };
assert_eq!(unsafe { libc::stat(link.as_ptr(), &mut host_stat) }, 0);
let terminal = (
libc::major(host_stat.st_rdev) as i32,
libc::minor(host_stat.st_rdev) as i32,
);
let process = procfs::process::Process::new(pid).unwrap();
let before = process.stat().unwrap();
assert_eq!(
(before.session, before.tty_nr()),
(pid, terminal),
"the child's open did not acquire the terminal"
);
assert!(opened_controlling_terminal(pid, slave, Some(&host_stat)));
assert_eq!(unsafe { libc::close(master) }, 0);
let deadline = Instant::now() + Duration::from_secs(10);
while process.stat().unwrap().tty_nr() != (0, 0) {
assert!(
Instant::now() < deadline,
"the hangup did not clear the controlling terminal"
);
std::thread::sleep(Duration::from_millis(10));
}
assert_eq!(process.stat().unwrap().session, pid);
assert!(
opened_controlling_terminal(pid, slave, Some(&host_stat)),
"a hangup after the descriptor's stat hid the acquisition"
);
assert!(
opened_controlling_terminal(pid, slave, None),
"a hangup before the descriptor's stat hid the acquisition"
);
drop(child);
}
#[test]
fn the_pipe_ceiling_admits_exactly_the_pinned_capacity() {
assert!(!pipe_capacity_request_exceeds_ceiling(
DETERMINISTIC_PIPE_CAPACITY_BYTES
));
assert!(!pipe_capacity_request_exceeds_ceiling(
DETERMINISTIC_PIPE_CAPACITY_BYTES - 1
));
assert!(pipe_capacity_request_exceeds_ceiling(
DETERMINISTIC_PIPE_CAPACITY_BYTES + 1
));
}
#[test]
fn a_host_pipe_capacity_reads_no_larger_than_the_ceiling() {
let ceiling = i64::from(DETERMINISTIC_PIPE_CAPACITY_BYTES);
assert_eq!(super::reported_pipe_capacity(65536), ceiling);
assert_eq!(super::reported_pipe_capacity(1 << 20), ceiling);
assert_eq!(super::reported_pipe_capacity(ceiling), ceiling);
assert_eq!(super::reported_pipe_capacity(4096), 4096);
}
#[test]
fn shrinking_is_never_refused_by_the_ceiling() {
for requested in [1, 4096, DETERMINISTIC_PIPE_CAPACITY_BYTES / 2] {
assert!(
!pipe_capacity_request_exceeds_ceiling(requested),
"shrink to {requested} must remain permitted"
);
}
}
#[test]
fn host_ceilings_are_refused_identically_on_any_host() {
for host_ceiling in [65536, 1048576] {
assert!(
pipe_capacity_request_exceeds_ceiling(host_ceiling),
"{host_ceiling} must be refused regardless of the host sysctl"
);
}
}
use super::Errno;
use super::TimerSlackBinding;
use super::UNIX_AUTOBIND_NAME_LEN;
use super::canonicalize_tcp_info;
use super::classify_timer_slack_binding;
use super::is_inherited_container_output;
use super::parse_timer_slack_write;
use super::pipe_capacity_failure;
use super::random_device_lseek_result;
use super::should_tag_host_timed_internal_pipe_io;
use super::unix_autobind_address;
use super::unix_autobind_addrlen;
use super::vectored_offset;
use crate::fd::FdType;
use crate::resources::Device;
use crate::resources::ResourceID;
#[test]
fn linux_flags_assumptions() {
assert_eq!(libc::SOCK_NONBLOCK, OFlag::O_NONBLOCK.bits());
assert_eq!(libc::SOCK_CLOEXEC, OFlag::O_CLOEXEC.bits());
}
#[test]
fn pipe_capacity_failure_classifies_the_errno() {
let created = [17, 18];
assert_eq!(
pipe_capacity_failure(created, Ok(i64::from(DETERMINISTIC_PIPE_CAPACITY_BYTES))),
None
);
let mismatch = pipe_capacity_failure(
created,
Ok(i64::from(DETERMINISTIC_PIPE_CAPACITY_BYTES) * 2),
)
.expect("a capacity Linux rounded away from the pin must not read as success");
assert_eq!(mismatch.created_fds, created);
assert_eq!(mismatch.error, Errno::EIO);
let denied = pipe_capacity_failure(created, Err(Errno::EPERM))
.expect("a kernel refusal must not read as success");
assert_eq!(denied.created_fds, created);
assert_eq!(denied.error, Errno::EPERM);
assert_eq!(denied.created_fds, created);
}
#[test]
fn pipe_capacity_failure_closes_both_created_descriptors() {
let mut created = [-1; 2];
assert_eq!(
unsafe { libc::pipe2(created.as_mut_ptr(), libc::O_CLOEXEC) },
0
);
let pin_result = unsafe { libc::fcntl(created[0], libc::F_SETPIPE_SZ, -1) };
assert_eq!(pin_result, -1);
let pin_error = Errno::last();
assert_eq!(pin_error, Errno::EINVAL);
let failure = pipe_capacity_failure(created, Err(pin_error))
.expect("the forced capacity-pin failure must enter the cleanup path");
for close in failure.close_syscalls() {
assert_eq!(unsafe { libc::close(close.fd()) }, 0);
}
for fd in created {
assert_eq!(unsafe { libc::fcntl(fd, libc::F_GETFD) }, -1);
assert_eq!(Errno::last(), Errno::EBADF);
}
}
#[test]
fn sabre_pipe_marker_requires_nonblockize_retry_semantics() {
assert!(should_tag_host_timed_internal_pipe_io(
true,
FdType::Pipe,
true,
false
));
assert!(!should_tag_host_timed_internal_pipe_io(
true,
FdType::Pipe,
true,
true
));
assert!(!should_tag_host_timed_internal_pipe_io(
true,
FdType::Pipe,
false,
false
));
assert!(!should_tag_host_timed_internal_pipe_io(
false,
FdType::Pipe,
true,
false
));
assert!(!should_tag_host_timed_internal_pipe_io(
true,
FdType::Regular,
true,
false
));
}
#[test]
fn random_device_lseek_matches_linux_noop_llseek() {
for whence in [
Whence::SEEK_SET,
Whence::SEEK_CUR,
Whence::SEEK_END,
Whence::SEEK_DATA,
Whence::SEEK_HOLE,
] {
for status_flags in [
OFlag::empty().bits(),
OFlag::O_WRONLY.bits(),
OFlag::O_RDWR.bits(),
] {
assert_eq!(random_device_lseek_result(status_flags, whence), Ok(0));
}
assert_eq!(
random_device_lseek_result(OFlag::O_PATH.bits(), whence),
Err(Errno::EBADF)
);
}
assert_eq!(
random_device_lseek_result(OFlag::empty().bits(), Whence::from_raw(99)),
Err(Errno::EINVAL)
);
assert_eq!(
random_device_lseek_result(OFlag::O_PATH.bits(), Whence::from_raw(99)),
Err(Errno::EBADF)
);
}
#[test]
fn timer_slack_write_parser_matches_decimal_procfs_contract() {
assert_eq!(parse_timer_slack_write(b"0"), Ok(0));
assert_eq!(parse_timer_slack_write(b"+123\n"), Ok(123));
assert_eq!(parse_timer_slack_write(b"456\0ignored"), Ok(456));
assert_eq!(
parse_timer_slack_write(u64::MAX.to_string().as_bytes()),
Ok(u64::MAX)
);
for invalid in [b"".as_slice(), b"+", b"-1", b" 1", b"1 ", b"1\n2", b"0x10"] {
assert_eq!(parse_timer_slack_write(invalid), Err(Errno::EINVAL));
}
assert_eq!(
parse_timer_slack_write(b"18446744073709551616"),
Err(Errno::ERANGE)
);
}
#[test]
fn timer_slack_vectored_offset_preserves_minus_one_sentinel() {
assert_eq!(vectored_offset(u64::MAX, u64::MAX), -1);
assert_eq!(vectored_offset(0, 0), 0);
assert_eq!(vectored_offset(7, 0), 7);
}
#[test]
fn timer_slack_binding_rejects_exit_reuse_and_other_tasks() {
let binding = TimerSlackBinding {
target: 202,
device: 11,
inode: 22,
};
assert_eq!(
classify_timer_slack_binding(binding, Some((11, 22)), 202),
Ok(())
);
assert_eq!(
classify_timer_slack_binding(binding, Some((11, 22)), 303),
Err(Errno::EPERM)
);
assert_eq!(
classify_timer_slack_binding(binding, None, 202),
Err(Errno::ESRCH)
);
assert_eq!(
classify_timer_slack_binding(binding, Some((11, 23)), 202),
Err(Errno::ESRCH),
"a recycled numeric TID must not revive an old proc inode"
);
}
#[test]
fn only_inherited_container_output_is_nonseekable() {
assert!(is_inherited_container_output(Some(ResourceID::Device(
Device::ContainerStdout
))));
assert!(is_inherited_container_output(Some(ResourceID::Device(
Device::ContainerStderr
))));
assert!(!is_inherited_container_output(Some(ResourceID::Device(
Device::ContainerStdin
))));
assert!(!is_inherited_container_output(None));
}
#[test]
fn unix_autobind_address_matches_linux_shape() {
let address = unix_autobind_address(0x2af);
assert_eq!(address.sun_family, libc::AF_UNIX as libc::sa_family_t);
assert_eq!(address.sun_path[0], 0);
let name = address.sun_path[1..UNIX_AUTOBIND_NAME_LEN]
.iter()
.map(|byte| *byte as u8)
.collect::<Vec<_>>();
assert_eq!(name, b"002af");
assert_eq!(
unix_autobind_addrlen() as usize,
std::mem::offset_of!(libc::sockaddr_un, sun_path) + UNIX_AUTOBIND_NAME_LEN
);
}
#[test]
fn tcp_info_retains_only_logical_connection_header() {
let mut info = [0xff; 16];
canonicalize_tcp_info(&mut info);
for (offset, byte) in info.into_iter().enumerate() {
let expected = if matches!(offset, 0 | 1 | 5 | 6) {
0xff
} else {
0
};
assert_eq!(byte, expected, "unexpected byte at offset {offset}");
}
for len in 0..8 {
canonicalize_tcp_info(&mut [0xff; 8][..len]);
}
}
fn directory_records(format: super::DirentFormat, names: &[&[u8]]) -> (Vec<u8>, Vec<usize>) {
let mut records = Vec::new();
for (index, name) in names.iter().enumerate() {
let entry = super::DirEntry {
name: name.to_vec(),
ino: 0x1111_1111_1111_1111,
off: 0,
ty: 4,
};
format.encode(&entry, entry.ino, index as i64 + 1, &mut records);
}
(records, names.iter().map(|name| name.len()).collect())
}
fn as_linux_writes(format: super::DirentFormat, records: &[u8], names: &[usize]) -> Vec<u8> {
let mut bytes = records.to_vec();
let mut at = 0;
for &name_len in names {
let reclen = format.record_len(name_len);
let padding = at + format.name_offset() + name_len + 1;
let end = match format {
super::DirentFormat::Dirent64 => at + reclen,
super::DirentFormat::Legacy => at + reclen - 1,
};
bytes[padding..end].fill(Pages::FILL);
at += reclen;
}
bytes
}
const FORMATS: [super::DirentFormat; 2] =
[super::DirentFormat::Dirent64, super::DirentFormat::Legacy];
const TEN: [&[u8]; 10] = [b"a", b"b", b"c", b"d", b"e", b"f", b"g", b"h", b"i", b"j"];
#[test]
fn a_first_record_that_cannot_be_written_leaves_the_next_page_untouched() {
for protection in [libc::PROT_NONE, libc::PROT_READ] {
for format in FORMATS {
let pages = Pages::new(&[protection, libc::PROT_READ | libc::PROT_WRITE]);
let (records, names) = directory_records(format, &TEN);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 16),
format,
&records,
&names,
0,
);
assert_eq!(copied, (0, Err(Errno::EFAULT)), "{format:?} {protection}");
assert!(
pages.contents().iter().all(|&byte| byte == Pages::FILL),
"{format:?} after a page with protection {protection}: bytes changed"
);
}
}
}
struct FailingMemory(Errno);
impl reverie::syscalls::MemoryAccess for FailingMemory {
fn read_vectored(
&self,
_: &[std::io::IoSlice],
_: &mut [std::io::IoSliceMut],
) -> Result<usize, Errno> {
Err(self.0)
}
fn write_vectored(
&mut self,
_: &[std::io::IoSlice],
_: &mut [std::io::IoSliceMut],
) -> Result<usize, Errno> {
Err(self.0)
}
}
#[test]
fn a_copy_error_other_than_a_fault_is_returned() {
let buf = |offset| reverie::syscalls::AddrMut::<u8>::from_raw(16 * PAGE + offset).unwrap();
for errno in [Errno::ESRCH, Errno::EIO] {
let mut bytes = [0; 32];
assert_eq!(
super::read_guest_prefix(&FailingMemory(errno), buf(0), &mut bytes),
Err(errno)
);
for format in FORMATS {
let (records, names) = directory_records(format, &TEN);
for offset in [0, PAGE - 4] {
let copied = super::copy_records(
&mut FailingMemory(errno),
buf(offset),
format,
&records,
&names,
0,
);
assert_eq!(copied, (0, Err(errno)), "{format:?} at {offset}");
}
let read =
super::read_records(&FailingMemory(errno), buf(0), records.len(), format);
assert_eq!(read.err(), Some(errno), "{format:?}");
}
}
}
#[test]
fn a_fault_of_the_whole_copy_copies_nothing() {
let buf = reverie::syscalls::AddrMut::<u8>::from_raw(16 * PAGE).unwrap();
let mut bytes = [0; 32];
assert_eq!(
super::read_guest_prefix(&FailingMemory(Errno::EFAULT), buf, &mut bytes),
Ok(0)
);
assert_eq!(
super::write_guest_pieces(&mut FailingMemory(Errno::EFAULT), buf, &[(0, &bytes)]),
Ok(0)
);
}
#[test]
fn a_first_record_leaves_its_position_in_its_d_off() {
for format in FORMATS {
let pages = Pages::new(&[libc::PROT_READ, libc::PROT_READ | libc::PROT_WRITE]);
let (records, names) = directory_records(format, &TEN);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 8),
format,
&records,
&names,
7,
);
assert_eq!(copied, (0, Err(Errno::EFAULT)), "{format:?}");
let contents = pages.contents();
assert_eq!(&contents[PAGE..PAGE + 8], &7i64.to_ne_bytes(), "{format:?}");
assert!(
contents[..PAGE]
.iter()
.chain(&contents[PAGE + 8..])
.all(|&byte| byte == Pages::FILL),
"{format:?}: bytes other than the first d_off changed"
);
}
}
#[test]
fn a_store_crossing_out_of_an_unwritable_page_writes_nothing() {
for format in FORMATS {
let pages = Pages::new(&[libc::PROT_READ, libc::PROT_READ | libc::PROT_WRITE]);
let (records, names) = directory_records(format, &TEN);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 12),
format,
&records,
&names,
0,
);
assert_eq!(copied, (0, Err(Errno::EFAULT)), "{format:?}");
assert!(
pages.contents().iter().all(|&byte| byte == Pages::FILL),
"{format:?}: bytes changed"
);
}
}
#[test]
fn a_store_crossing_pages_is_put_back_from_the_page_that_can_be_read() {
let (none, read, write) = (libc::PROT_NONE, libc::PROT_READ, libc::PROT_WRITE);
let both = read | write;
for protections in [
[read, write],
[write, read],
[write, none],
[both, none],
[both, read],
[none, both],
] {
for format in FORMATS {
let pages = Pages::new(&protections);
let (records, names) = directory_records(format, &TEN);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 12),
format,
&records,
&names,
0,
);
assert_eq!(
copied,
(0, Err(Errno::EFAULT)),
"{protections:?} {format:?}"
);
assert!(
pages.contents().iter().all(|&byte| byte == Pages::FILL),
"{protections:?} {format:?}: bytes changed"
);
}
}
}
#[test]
fn a_record_crossing_into_an_inaccessible_page_leaves_nothing_before_it() {
for format in FORMATS {
let pages = Pages::new(&[libc::PROT_READ | libc::PROT_WRITE, libc::PROT_NONE]);
let (records, names) = directory_records(format, &TEN);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 100),
format,
&records,
&names,
0,
);
assert_eq!(copied, (4, Ok(96)), "{format:?}");
let contents = pages.contents();
assert_eq!(
&contents[PAGE - 100..PAGE - 4],
&as_linux_writes(format, &records[..96], &names[..4])[..],
"{format:?}"
);
assert!(
contents[..PAGE - 100]
.iter()
.chain(&contents[PAGE - 4..])
.all(|&byte| byte == Pages::FILL),
"{format:?}: bytes outside the records copied changed"
);
}
}
#[test]
fn a_torn_procfs_read_is_partial_for_a_seq_file_and_a_fault_for_a_sysctl() {
let pages = Pages::new(&[libc::PROT_READ | libc::PROT_WRITE, libc::PROT_NONE]);
let edge = || Some(pages.address(PAGE - 2));
let read = |bytes: &[u8], sysctl| {
super::copy_procfs_read(&mut LocalMemory::new(), edge(), bytes, sysctl)
.map_err(|error| error.into_errno().unwrap())
};
assert_eq!(read(b"Linux version\n", false), Ok(2));
assert_eq!(
read(b"65530\n", true),
Err(reverie::syscalls::Errno::EFAULT)
);
assert_eq!(read(b"0\n", true), Ok(2));
assert_eq!(read(b"", true), Ok(0));
}
#[test]
fn only_a_descriptor_opened_for_reading_reads_procfs() {
assert!(super::can_read(libc::O_RDONLY));
assert!(super::can_read(libc::O_RDWR | libc::O_CLOEXEC));
assert!(!super::can_read(libc::O_WRONLY));
assert!(!super::can_read(libc::O_ACCMODE));
assert!(!super::can_read(libc::O_PATH));
}
#[test]
fn procfs_vector_flags_are_refused_in_linux_order() {
use reverie::syscalls::Errno;
const NOSIGNAL: i32 = 0x100;
const UNKNOWN: i32 = 0x200;
for accepted in [
0,
libc::RWF_HIPRI,
libc::RWF_DSYNC,
libc::RWF_SYNC,
libc::RWF_APPEND,
libc::RWF_NOAPPEND,
NOSIGNAL,
] {
assert_eq!(super::validate_procfs_vector_flags(accepted, true), Ok(()));
}
for (flags, errno) in [
(libc::RWF_NOWAIT, Errno::EOPNOTSUPP),
(libc::RWF_ATOMIC, Errno::EOPNOTSUPP),
(libc::RWF_DONTCACHE, Errno::EOPNOTSUPP),
(UNKNOWN, Errno::EOPNOTSUPP),
(libc::RWF_APPEND | libc::RWF_NOAPPEND, Errno::EINVAL),
(libc::RWF_NOWAIT | UNKNOWN, Errno::EOPNOTSUPP),
(
libc::RWF_APPEND | libc::RWF_NOAPPEND | UNKNOWN,
Errno::EOPNOTSUPP,
),
(
libc::RWF_ATOMIC | libc::RWF_APPEND | libc::RWF_NOAPPEND,
Errno::EINVAL,
),
(
libc::RWF_NOWAIT | libc::RWF_APPEND | libc::RWF_NOAPPEND,
Errno::EINVAL,
),
] {
assert_eq!(
super::validate_procfs_vector_flags(flags, true),
Err(errno),
"{flags:#x}"
);
}
assert_eq!(
super::validate_procfs_vector_flags(libc::RWF_HIPRI, false),
Ok(())
);
for flags in [
libc::RWF_DSYNC,
libc::RWF_APPEND,
NOSIGNAL,
libc::RWF_APPEND | libc::RWF_NOAPPEND,
] {
assert_eq!(
super::validate_procfs_vector_flags(flags, false),
Err(Errno::EOPNOTSUPP),
"{flags:#x}"
);
}
}
#[test]
fn a_first_record_is_written_from_its_d_off() {
for format in FORMATS {
let pages = Pages::new(&[libc::PROT_WRITE, libc::PROT_NONE]);
let (records, names) = directory_records(format, &TEN);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 4),
format,
&records,
&names,
0,
);
assert_eq!(copied, (0, Err(Errno::EFAULT)), "{format:?}");
assert!(
pages.contents().iter().all(|&byte| byte == Pages::FILL),
"{format:?}: bytes before the inaccessible page changed"
);
}
}
#[test]
fn a_record_not_copied_is_left_as_linux_leaves_it() {
let names: Vec<[u8; 1]> = (0..200u8).map(|i| [b'a' + i % 26]).collect();
let names: Vec<&[u8]> = names.iter().map(|name| &name[..]).collect();
for format in FORMATS {
let rw = libc::PROT_READ | libc::PROT_WRITE;
let pages = Pages::new(&[rw, rw, libc::PROT_NONE]);
let start = PAGE - 40;
let (records, lens) = directory_records(format, &names);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(start),
format,
&records,
&lens,
0,
);
assert_eq!(copied, (172, Ok(172 * 24)), "{format:?}");
let contents = pages.contents();
let mut expected = as_linux_writes(format, &records[..4128], &lens[..172]);
expected.extend_from_slice(&records[4128..4136]);
assert_eq!(&contents[start..start + 4136], &expected[..], "{format:?}");
assert!(
contents[..start]
.iter()
.chain(&contents[start + 4136..])
.all(|&byte| byte == Pages::FILL),
"{format:?}: bytes outside what Linux writes changed"
);
}
}
#[test]
fn a_name_is_stored_after_the_bytes_that_follow_it() {
for format in FORMATS {
let pages = Pages::new(&[libc::PROT_READ | libc::PROT_WRITE, libc::PROT_NONE]);
let (records, names) = directory_records(format, &[b"a", b"abcdefghijklmnopqrst"]);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 50),
format,
&records,
&names,
0,
);
assert_eq!(copied, (1, Ok(24)), "{format:?}");
let contents = &pages.contents()[PAGE - 50..PAGE];
let mut expected = as_linux_writes(format, &records[..24], &names[..1]);
expected.extend_from_slice(&records[24..32]);
expected.extend_from_slice(&[Pages::FILL; 8]);
expected.extend_from_slice(&records[40..42]);
match format {
super::DirentFormat::Dirent64 => expected.push(records[42]),
super::DirentFormat::Legacy => expected.push(Pages::FILL),
}
expected.resize(50, Pages::FILL);
assert_eq!(contents, &expected[..], "{format:?}");
}
}
#[test]
fn records_that_fit_are_copied_whole() {
for format in FORMATS {
let rw = libc::PROT_READ | libc::PROT_WRITE;
let pages = Pages::new(&[rw, rw]);
let (records, names) = directory_records(format, &TEN);
let copied = super::copy_records(
&mut LocalMemory::new(),
pages.address(PAGE - 50),
format,
&records,
&names,
0,
);
assert_eq!(copied, (10, Ok(240)), "{format:?}");
let contents = pages.contents();
assert_eq!(
&contents[PAGE - 50..PAGE - 50 + records.len()],
&as_linux_writes(format, &records, &names)[..],
"{format:?}"
);
assert!(
contents[..PAGE - 50]
.iter()
.chain(&contents[PAGE - 50 + records.len()..])
.all(|&byte| byte == Pages::FILL),
"{format:?}: bytes outside the records changed"
);
}
}
}
#[cfg(test)]
mod inject_fstat_scratch {
use std::os::fd::IntoRawFd;
use std::os::fd::RawFd;
use std::os::unix::fs::MetadataExt;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use reverie::GlobalRPC;
use reverie::GlobalTool;
use reverie::Pid;
use reverie::Tool;
use reverie::syscalls::LocalMemory;
use reverie::syscalls::ProtFlags;
use super::*;
use crate::Config;
use crate::GlobalState;
use crate::ThreadState;
use crate::types::DetPid;
const ARENA_WORDS: usize = 32;
struct ScriptedStack {
writable: bool,
arena: usize,
capacity: usize,
guard_live: Arc<AtomicBool>,
partial: bool,
protect_on_failure: Option<usize>,
}
struct ScriptedStackGuard {
guard_live: Arc<AtomicBool>,
}
impl Drop for ScriptedStackGuard {
fn drop(&mut self) {
self.guard_live.store(false, Ordering::SeqCst);
}
}
impl reverie::Stack for ScriptedStack {
type StackGuard = ScriptedStackGuard;
fn size(&self) -> usize {
panic!("inject_fstat must not query the scratch size")
}
fn capacity(&self) -> usize {
panic!("inject_fstat must not query the scratch capacity")
}
fn push<'stack, T>(&mut self, _: T) -> Addr<'stack, T> {
panic!("inject_fstat reserves its buffer rather than pushing one")
}
fn reserve<'stack, T>(&mut self) -> AddrMut<'stack, T> {
assert!(std::mem::size_of::<T>() <= self.capacity);
AddrMut::from_raw(self.arena).unwrap()
}
fn commit(self) -> Result<Self::StackGuard, Errno> {
if !self.writable {
if self.partial {
unsafe { (self.arena as *mut u64).write(0) };
}
if let Some(page) = self.protect_on_failure {
assert_eq!(
unsafe { libc::mprotect(page as *mut _, 4096, libc::PROT_READ) },
0
);
}
return Err(Errno::EFAULT);
}
self.guard_live.store(true, Ordering::SeqCst);
Ok(ScriptedStackGuard {
guard_live: self.guard_live,
})
}
}
struct ScriptedGuest {
config: Config,
thread: ThreadState<()>,
stack_writable: bool,
mmap_fails: bool,
arena: Box<[u64; ARENA_WORDS]>,
guard_live: Arc<AtomicBool>,
injected: Vec<Sysno>,
fstat_guard_live: Vec<bool>,
fstat_buffers: Vec<usize>,
mapped: Vec<(usize, usize)>,
unmapped: Vec<(usize, usize)>,
closed: Vec<RawFd>,
runtime_fd: Option<RawFd>,
directory_batches: std::collections::VecDeque<Result<Vec<u8>, Errno>>,
open_errors: std::collections::VecDeque<Errno>,
opened_paths: Vec<Vec<u8>>,
opened_fds: Vec<RawFd>,
close_errors: std::collections::VecDeque<Errno>,
close_attempts: Vec<RawFd>,
capget_effective: u64,
scratch_page: Option<usize>,
commit_partial: bool,
protect_page_on_commit_failure: bool,
protect_page_on: Option<Sysno>,
private_memory: Option<reverie::RuntimePrivateMemorySnapshot>,
private_retired: bool,
private_validations: std::sync::atomic::AtomicUsize,
maps_reads: std::collections::VecDeque<Vec<u8>>,
}
impl ScriptedGuest {
fn new(stack_writable: bool, mmap_fails: bool) -> (Detcore, Self) {
let config = Config {
virtualize_metadata: true,
..Config::default()
};
let pid = DetPid::from_raw(1);
let mut thread = ThreadState::new(pid, &config, ());
thread.detpid = Some(pid);
let tool = <Detcore as Tool>::new(Pid::from_raw(1), &config);
let guest = Self {
config,
thread,
stack_writable,
mmap_fails,
arena: Box::new([u64::MAX; ARENA_WORDS]),
guard_live: Arc::new(AtomicBool::new(false)),
injected: Vec::new(),
fstat_guard_live: Vec::new(),
fstat_buffers: Vec::new(),
mapped: Vec::new(),
unmapped: Vec::new(),
closed: Vec::new(),
runtime_fd: None,
directory_batches: Default::default(),
open_errors: Default::default(),
opened_paths: Vec::new(),
opened_fds: Vec::new(),
close_errors: Default::default(),
close_attempts: Vec::new(),
capget_effective: (1 << 41) - 1,
scratch_page: None,
commit_partial: false,
protect_page_on_commit_failure: false,
protect_page_on: None,
private_memory: None,
private_retired: false,
private_validations: std::sync::atomic::AtomicUsize::new(0),
maps_reads: Default::default(),
};
(tool, guest)
}
fn with_scratch_page(stack_writable: bool) -> (Detcore, Self) {
let (tool, mut guest) = Self::new(stack_writable, false);
guest.config.panic_on_unsupported_syscalls = false;
let page = unsafe {
libc::mmap(
std::ptr::null_mut(),
4096,
libc::PROT_READ | libc::PROT_WRITE,
libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
-1,
0,
)
};
assert_ne!(page, libc::MAP_FAILED);
unsafe { std::ptr::write_bytes(page as *mut u8, 0xa5, 4096) };
guest.scratch_page = Some(page as usize);
(tool, guest)
}
fn take_scratch_page(&mut self) -> Vec<u8> {
let page = self.scratch_page.take().unwrap();
let bytes = unsafe { std::slice::from_raw_parts(page as *const u8, 4096) }.to_vec();
assert_eq!(unsafe { libc::munmap(page as *mut _, 4096) }, 0);
bytes
}
}
#[reverie::tool]
impl GlobalRPC<GlobalState> for ScriptedGuest {
async fn send_rpc(
&self,
message: <GlobalState as GlobalTool>::Request,
) -> <GlobalState as GlobalTool>::Response {
panic!("fd registration must not send an RPC: {:?}", message.2)
}
fn config(&self) -> &Config {
&self.config
}
}
#[reverie::tool]
impl Guest<Detcore> for ScriptedGuest {
type Memory = LocalMemory;
type Stack = ScriptedStack;
fn tid(&self) -> Pid {
Pid::from_raw(1)
}
fn pid(&self) -> Pid {
Pid::from_raw(1)
}
fn ppid(&self) -> Option<Pid> {
None
}
fn is_runtime_owned_fd(&self, fd: RawFd) -> bool {
self.runtime_fd == Some(fd)
}
fn runtime_private_memory_regions(&self) -> Option<reverie::RuntimePrivateMemory> {
self.private_memory.clone().map(|facts| {
if self.private_retired {
reverie::RuntimePrivateMemory::Unavailable
} else {
reverie::RuntimePrivateMemory::Ready(facts)
}
})
}
fn runtime_private_memory_is_current(
&self,
snapshot: &reverie::RuntimePrivateMemorySnapshot,
) -> bool {
self.private_validations.fetch_add(1, Ordering::SeqCst);
!self.private_retired && self.private_memory.as_ref() == Some(snapshot)
}
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!("fd registration must not read registers")
}
async fn stack(&mut self) -> Self::Stack {
ScriptedStack {
writable: self.stack_writable,
arena: self
.scratch_page
.unwrap_or(self.arena.as_mut_ptr() as usize),
capacity: if self.scratch_page.is_some() {
4096
} else {
ARENA_WORDS * std::mem::size_of::<u64>()
},
guard_live: self.guard_live.clone(),
partial: self.commit_partial,
protect_on_failure: self
.scratch_page
.filter(|_| self.protect_page_on_commit_failure),
}
}
async fn daemonize(&mut self) {
panic!("fd registration must not daemonize")
}
async fn inject<S: SyscallInfo>(&mut self, syscall: S) -> Result<i64, Errno> {
let (number, args) = syscall.into_parts();
self.injected.push(number);
if let Some(page) = self
.scratch_page
.filter(|_| self.protect_page_on == Some(number))
{
assert_eq!(
unsafe { libc::mprotect(page as *mut _, 4096, libc::PROT_READ) },
0
);
}
if matches!(number, Sysno::getdents | Sysno::getdents64) {
let bytes = self
.directory_batches
.pop_front()
.expect("scripted getdents")?;
assert!(bytes.len() <= args.arg2);
if !bytes.is_empty() {
let buffer = AddrMut::from_raw(args.arg1).unwrap();
self.memory().write_exact(buffer, &bytes)?;
}
return Ok(bytes.len() as i64);
}
let raw = match Syscall::from_raw(number, args) {
Syscall::Lseek(call) if self.private_memory.is_some() => {
assert_eq!(call.offset(), 0);
assert_eq!(call.whence(), Whence::SEEK_SET);
0
}
Syscall::Read(call) if self.private_memory.is_some() => {
let bytes = self.maps_reads.pop_front().expect("scripted maps drain");
assert!(bytes.len() <= call.len());
self.memory().write_exact(call.buf().unwrap(), &bytes)?;
if bytes.is_empty() {
self.private_retired = true;
}
bytes.len() as i64
}
Syscall::Mmap(call) => {
assert!(call.addr().is_none(), "the kernel must choose the address");
assert_eq!(call.prot(), ProtFlags::PROT_READ | ProtFlags::PROT_WRITE);
assert_eq!(
call.flags(),
MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS
);
if self.mmap_fails {
return Err(Errno::ENOMEM);
}
let address = unsafe {
libc::mmap(
std::ptr::null_mut(),
call.len(),
libc::PROT_READ | libc::PROT_WRITE,
libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
-1,
0,
)
};
if address == libc::MAP_FAILED {
-1
} else {
self.mapped.push((address as usize, call.len()));
address as i64
}
}
Syscall::Fstat(call) => {
let buffer = call.stat().expect("fstat without a buffer").0.as_raw();
self.fstat_buffers.push(buffer);
self.fstat_guard_live
.push(self.guard_live.load(Ordering::SeqCst));
i64::from(unsafe { libc::fstat(call.fd(), buffer as *mut libc::stat) })
}
Syscall::Munmap(call) => {
let address = call.addr().expect("munmap without an address").as_raw();
let raw = i64::from(unsafe { libc::munmap(address as *mut _, call.len()) });
if raw == 0 {
self.unmapped.push((address, call.len()));
}
raw
}
Syscall::Close(call) => {
self.close_attempts.push(call.fd());
if let Some(errno) = self.close_errors.pop_front() {
return Err(errno);
}
self.closed.push(call.fd());
i64::from(unsafe { libc::close(call.fd()) })
}
Syscall::Openat(call) => {
let path = call.path().expect("openat without a path");
let path = path.read(&self.memory()).unwrap();
self.opened_paths
.push(path.as_os_str().as_encoded_bytes().to_vec());
if let Some(errno) = self.open_errors.pop_front() {
return Err(errno);
}
let (fd, _) = open_file();
self.opened_fds.push(fd);
i64::from(fd)
}
Syscall::Capget(call) => {
let data = call.data().expect("capget without data").as_raw();
let effective = self.capget_effective;
let words: [u32; 6] = [
effective as u32,
u32::MAX,
0,
(effective >> 32) as u32,
0x1ff,
0,
];
let bytes: Vec<u8> = words.iter().flat_map(|word| word.to_ne_bytes()).collect();
self.memory()
.write_exact(AddrMut::<u8>::from_raw(data).unwrap(), &bytes)?;
0
}
other => panic!("unexpected injected syscall {other:?}"),
};
Errno::result(raw)
}
async fn tail_inject<S: SyscallInfo>(&mut self, _: S) -> reverie::Never {
panic!("fd registration must not retire the guest")
}
fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("fd registration must not set a timer")
}
fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("fd registration must not set a timer")
}
fn read_clock(&mut self) -> Result<u64, Error> {
panic!("fd registration must not read a clock")
}
}
pub(super) async fn raw_directory_projection() {
use std::os::fd::AsRawFd;
let directory = std::fs::File::open("/proc/self/fd").unwrap();
for format in [DirentFormat::Legacy, DirentFormat::Dirent64] {
let entries = [
DirEntry {
ino: 91,
off: 29,
name: b"40960".to_vec(),
ty: 8,
},
DirEntry {
ino: 92,
off: 17,
name: b"1024".to_vec(),
ty: 10,
},
DirEntry {
ino: 93,
off: 31,
name: b"1023".to_vec(),
ty: 8,
},
];
let encode = |rows: &[DirEntry]| {
let mut bytes = Vec::new();
for entry in rows {
format.encode(entry, entry.ino, entry.off, &mut bytes);
}
bytes
};
let mut unmodified = encode(&entries[..1]);
for at in format.name_offset() + entries[0].name.len() + 1..unmodified.len() {
if at != format.type_offset(unmodified.len()) {
unmodified[at] = 0x7c;
}
}
for (batches, expected, calls) in [
(
vec![Ok(encode(&entries))],
Ok(encode(&[entries[0].clone(), entries[2].clone()])),
1,
),
(
vec![Ok(encode(&entries[1..2])), Ok(encode(&entries[..1]))],
Ok(encode(&entries[..1])),
2,
),
(
vec![Ok(encode(&entries[1..2])), Ok(Vec::new())],
Ok(Vec::new()),
2,
),
(
vec![Ok(encode(&entries[1..2])), Err(Errno::EIO)],
Err(Errno::EIO),
2,
),
(vec![Ok(unmodified.clone())], Ok(unmodified.clone()), 1),
] {
let (_, mut guest) = ScriptedGuest::new(true, false);
guest.config.virtualize_metadata = false;
guest.config.backend = reverie::BackendCapabilities::DBT;
guest.runtime_fd = Some(1024);
let written = batches
.iter()
.filter_map(|batch| batch.as_ref().ok().map(Vec::len))
.max()
.unwrap();
let untouched = expected.as_ref().is_ok_and(|bytes| bytes == &unmodified);
guest.directory_batches = batches.into();
let tool = <Detcore as Tool>::new(Pid::from_raw(1), &guest.config);
let mut bytes = vec![0xa5; 512];
let buffer: AddrMut<u8> = AddrMut::from_raw(bytes.as_mut_ptr() as usize).unwrap();
let result = match format {
DirentFormat::Legacy => {
tool.handle_getdents(
&mut guest,
syscalls::Getdents::new()
.with_fd(directory.as_raw_fd() as u32)
.with_dirent(Some(buffer.cast()))
.with_count(bytes.len() as u32),
)
.await
}
DirentFormat::Dirent64 => {
tool.handle_getdents64(
&mut guest,
syscalls::Getdents64::new()
.with_fd(directory.as_raw_fd() as u32)
.with_dirent(Some(buffer.cast()))
.with_count(bytes.len() as u32),
)
.await
}
};
assert_eq!(guest.injected.len(), calls, "{format:?}");
assert!(bytes[written..].iter().all(|byte| *byte == 0xa5));
match expected {
Ok(expected) => {
assert_eq!(result.unwrap(), expected.len() as i64, "{format:?}");
assert_eq!(&bytes[..expected.len()], expected, "{format:?}");
if !untouched {
assert!(bytes[expected.len()..written].iter().all(|byte| *byte == 0));
}
}
Err(expected) => {
assert!(
matches!(result, Err(Error::Errno(actual)) if actual == expected),
"{format:?}: {result:?}"
);
assert!(bytes[..format.record_len(4)].iter().all(|byte| *byte == 0));
}
}
}
}
}
#[test]
fn private_maps_targets_require_complete_identity_or_translated_numbers() {
use crate::procfs::BoundTask;
let actual = Path::new("/proc/21/task/23/maps");
for (numbers, expected) in [
(
BTreeMap::from([(21, 21), (23, 23)]),
Some(BoundTask {
process: 21,
thread: Some(23),
}),
),
(
BTreeMap::from([(21, 3), (23, 5)]),
Some(BoundTask {
process: 3,
thread: Some(5),
}),
),
(BTreeMap::from([(21, 3)]), None),
] {
assert_eq!(
Detcore::<crate::record_or_replay::NoopTool>::maps_target_with_numbers(
actual,
Some(&numbers),
1,
1,
),
expected
);
}
}
#[tokio::test]
async fn private_maps_authenticates_the_opened_descriptor_in_its_task_view() {
use std::os::fd::AsRawFd;
let (_, mut guest) = ScriptedGuest::new(true, false);
guest.config.backend = reverie::BackendCapabilities::DBT;
guest.config.sequentialize_threads = true;
guest.thread.physical_tid = Some(123456);
let tool = <Detcore as Tool>::new(Pid::from_raw(1), &guest.config);
assert!(!procfs_inode::guest_tids_name_host_tasks(
&guest.config.backend,
guest.thread.physical_tid,
));
let file = std::fs::File::open("/proc/thread-self/maps").unwrap();
let fd = file.as_raw_fd();
let mut stat: libc::stat = unsafe { std::mem::zeroed() };
assert_eq!(unsafe { libc::fstat(fd, &mut stat) }, 0);
let stat = DetStat::from(stat);
let authenticated = tool.maps_descriptor_entry(&guest, &stat, fd).await;
assert!(
matches!(&authenticated, ProcfsEntry::At(path) if path.ends_with("maps")),
"{authenticated:?}"
);
let ordinary = tempfile::tempfile().unwrap();
let mut ordinary_stat: libc::stat = unsafe { std::mem::zeroed() };
assert_eq!(
unsafe { libc::fstat(ordinary.as_raw_fd(), &mut ordinary_stat) },
0
);
assert!(matches!(
tool.maps_descriptor_entry(&guest, &DetStat::from(ordinary_stat), ordinary.as_raw_fd())
.await,
ProcfsEntry::NotProcfs
));
assert!(matches!(
tool.maps_descriptor_entry(&guest, &stat, ordinary.as_raw_fd())
.await,
ProcfsEntry::Unknown
));
guest.thread.changed_root.store(true, Ordering::SeqCst);
assert!(matches!(
tool.maps_descriptor_entry(&guest, &stat, fd).await,
ProcfsEntry::Unknown
));
}
#[tokio::test]
async fn private_maps_retired_during_drain_never_publish_a_snapshot() {
let (_, mut guest) = ScriptedGuest::with_scratch_page(true);
guest.config.sequentialize_threads = true;
let tool = <Detcore as Tool>::new(Pid::from_raw(1), &guest.config);
let target = crate::procfs::MapsTarget {
task: crate::procfs::BoundTask {
process: 2,
thread: None,
},
incarnation: crate::procfs::TaskIncarnation {
process: 1,
thread: None,
},
mm: detcore_model::futex::MmId::initial(DetTid::from_raw(2)),
private: reverie::RuntimePrivateMemorySnapshot {
owner: [1, 2, 3, 4],
version: 1,
regions: vec![reverie::RuntimePrivateMemoryRegion {
start: 0x1000,
end: 0x2000,
}],
},
};
guest.private_memory = Some(target.private.clone());
guest.maps_reads = [b"1000-2000 rw-p 00000000 00:00 0 \n".to_vec(), Vec::new()].into();
let fd = 9;
guest
.thread
.add_fd(fd, OFlag::O_RDONLY, FdType::Regular, None)
.unwrap();
let mut file = ProcfsFile::from_path(Path::new("/proc/2/maps")).unwrap();
file.bind_maps_target(target.clone());
guest
.thread
.with_detfd(fd, |detfd| detfd.set_procfs(file.clone()))
.unwrap();
let mut output = [0xa5_u8; 512];
let call = syscalls::Read::new()
.with_fd(fd)
.with_buf(AddrMut::from_raw(output.as_mut_ptr() as usize))
.with_len(output.len());
let error = tool
.initialize_procfs_snapshot(&mut guest, call)
.await
.unwrap_err();
assert!(
matches!(error, Error::Tool(ref error) if error.to_string() ==
"runtime-private maps view unavailable: target ownership changed during capture"),
"{error:?}"
);
assert_eq!(guest.private_validations.load(Ordering::SeqCst), 2);
assert!(guest.maps_reads.is_empty());
assert_eq!(guest.injected, [Sysno::lseek, Sysno::read, Sysno::read]);
assert_eq!(output, [0xa5; 512]);
guest
.thread
.with_detfd(fd, |detfd| {
assert!(detfd.procfs_needs_snapshot());
assert_eq!(detfd.procfs_position(), Some((0, None)));
assert_eq!(detfd.preview_procfs(512), None);
assert_eq!(detfd.procfs_maps_target(), Some(target.clone()));
})
.unwrap();
assert_eq!(guest.take_scratch_page(), vec![0xa5; 4096]);
}
fn open_file() -> (RawFd, u64) {
let file = tempfile::tempfile().unwrap();
let inode = file.metadata().unwrap().ino();
(file.into_raw_fd(), inode)
}
fn close_unless_detcore_did(guest: &ScriptedGuest, fd: RawFd) {
if !guest.closed.contains(&fd) {
assert_eq!(unsafe { libc::close(fd) }, 0);
}
}
fn recorded_inode(guest: &ScriptedGuest, fd: RawFd) -> Option<u64> {
guest
.thread
.with_detfd(fd, |detfd| detfd.stat().map(|stat| stat.inode))
.unwrap()
}
fn policy_errno(error: Error) -> Errno {
error.into_errno().unwrap()
}
const TARGET: crate::procfs::BoundTask = crate::procfs::BoundTask {
process: 3,
thread: None,
};
#[tokio::test]
async fn the_auxv_access_check_follows_the_kernel_beneaths_answers() {
let paths = |guest: &ScriptedGuest| guest.opened_paths.clone();
let target = b"/proc/3/auxv".to_vec();
let serves = b"/proc/thread-self/stat".to_vec();
let all = (1_u64 << 41) - 1;
let without_ptrace = all & !(1 << 19);
for (errors, effective, answer, probes, capget) in [
(vec![], all, Ok(()), vec![target.clone()], false),
(
vec![Errno::EACCES],
all,
Err(Errno::EACCES),
vec![target.clone(), serves.clone()],
false,
),
(
vec![Errno::EACCES, Errno::EACCES],
all,
Ok(()),
vec![target.clone(), serves.clone()],
true,
),
(
vec![Errno::EACCES, Errno::EACCES],
without_ptrace,
Err(Errno::EACCES),
vec![target.clone(), serves.clone()],
true,
),
(
vec![Errno::EMFILE, Errno::EMFILE],
without_ptrace,
Err(Errno::EMFILE),
vec![target.clone(), serves.clone()],
false,
),
(
vec![Errno::ERESTARTSYS],
without_ptrace,
Ok(()),
vec![target.clone(), target.clone()],
false,
),
] {
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(true);
guest.open_errors.extend(errors.clone());
guest.capget_effective = effective;
let result = Detcore::ptrace_read_allowed(&mut guest, TARGET).await;
assert_eq!(result.unwrap(), answer, "{errors:?}");
assert_eq!(paths(&guest), probes, "{errors:?}");
assert_eq!(
guest.injected.contains(&Sysno::capget),
capget,
"{errors:?}"
);
assert_eq!(guest.closed, guest.opened_fds, "every probe is closed");
assert!(
guest.take_scratch_page().iter().all(|byte| *byte == 0xa5),
"{errors:?}: the scratch is left modified"
);
}
}
#[tokio::test]
async fn guest_stack_scratch_failures_go_to_the_failure_policy() {
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(false);
guest.commit_partial = true;
let result = Detcore::ptrace_read_allowed(&mut guest, TARGET).await;
assert_eq!(policy_errno(result.unwrap_err()), Errno::EOPNOTSUPP);
assert!(guest.injected.is_empty());
assert!(guest.take_scratch_page().iter().all(|byte| *byte == 0xa5));
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(false);
guest.commit_partial = true;
guest.protect_page_on_commit_failure = true;
let result = Detcore::ptrace_read_allowed(&mut guest, TARGET).await;
assert_eq!(policy_errno(result.unwrap_err()), Errno::EOPNOTSUPP);
assert!(guest.injected.is_empty());
guest.take_scratch_page();
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(false);
guest.commit_partial = true;
guest.protect_page_on_commit_failure = true;
let result =
Detcore::inject_capget(&mut guest, rendered_procfs::CapabilitySet::Effective).await;
assert_eq!(policy_errno(result.unwrap_err()), Errno::EOPNOTSUPP);
guest.take_scratch_page();
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(true);
guest.protect_page_on = Some(Sysno::openat);
let result = Detcore::ptrace_read_allowed(&mut guest, TARGET).await;
assert_eq!(policy_errno(result.unwrap_err()), Errno::EOPNOTSUPP);
assert_eq!(guest.closed, guest.opened_fds);
guest.take_scratch_page();
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(true);
guest.protect_page_on = Some(Sysno::capget);
let result =
Detcore::inject_capget(&mut guest, rendered_procfs::CapabilitySet::Effective).await;
assert_eq!(policy_errno(result.unwrap_err()), Errno::EOPNOTSUPP);
guest.take_scratch_page();
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(true);
let result =
Detcore::inject_capget(&mut guest, rendered_procfs::CapabilitySet::Effective).await;
assert_eq!(result.unwrap(), Some((1 << 41) - 1));
assert!(guest.take_scratch_page().iter().all(|byte| *byte == 0xa5));
}
#[tokio::test]
async fn the_auxv_access_probe_closes_its_descriptor_as_linux_close_allows() {
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(true);
guest.close_errors.push_back(Errno::ERESTARTSYS);
let result = Detcore::ptrace_read_allowed(&mut guest, TARGET).await;
assert_eq!(result.unwrap(), Ok(()));
let [fd] = guest.opened_fds[..] else { panic!() };
assert_eq!(
guest.close_attempts,
[fd, fd],
"a close that did not run is retried"
);
assert_eq!(guest.closed, [fd]);
guest.take_scratch_page();
for (errno, failed) in [(Errno::EINTR, false), (Errno::EBADF, true)] {
let (_tool, mut guest) = ScriptedGuest::with_scratch_page(true);
guest.close_errors.push_back(errno);
let result = Detcore::ptrace_read_allowed(&mut guest, TARGET).await;
let [fd] = guest.opened_fds[..] else { panic!() };
assert_eq!(guest.close_attempts, [fd], "{errno} is not retried");
match result {
Ok(answer) => {
assert!(!failed, "{errno}");
assert_eq!(answer, Ok(()));
}
Err(error) => {
assert!(failed, "{errno}");
assert_eq!(policy_errno(error), Errno::EOPNOTSUPP);
}
}
assert_eq!(unsafe { libc::close(fd) }, 0);
assert!(guest.take_scratch_page().iter().all(|byte| *byte == 0xa5));
}
}
#[tokio::test]
async fn writable_stack_scratch_is_used_while_its_guard_is_live() {
let (fd, inode) = open_file();
let (tool, mut guest) = ScriptedGuest::new(true, false);
let result = tool
.add_fd(&mut guest, fd, OFlag::O_RDONLY, FdType::Regular)
.await;
close_unless_detcore_did(&guest, fd);
assert_eq!(result, Ok(()));
assert_eq!(guest.injected, [Sysno::fstat]);
assert_eq!(
guest.fstat_guard_live,
[true],
"the stack guard must outlive the injected fstat: backends whose \
scratch is an arena free it when the guard drops"
);
assert_eq!(
guest.fstat_buffers,
[guest.arena.as_ptr() as usize],
"fstat must write into the stack scratch"
);
let used_words = std::mem::size_of::<libc::stat>().div_ceil(8);
assert!(
guest.arena[..used_words].iter().all(|word| *word == 0),
"the stat must not be left in the guest's stack scratch"
);
assert_eq!(recorded_inode(&guest, fd), Some(inode));
}
#[tokio::test]
async fn faulting_stack_scratch_falls_back_to_a_transient_page() {
let (fd, inode) = open_file();
let (tool, mut guest) = ScriptedGuest::new(false, false);
let result = tool
.add_fd(&mut guest, fd, OFlag::O_RDONLY, FdType::Regular)
.await;
close_unless_detcore_did(&guest, fd);
assert_eq!(
result,
Ok(()),
"a stack that cannot hold the fstat buffer must not fail the open"
);
assert_eq!(guest.injected, [Sysno::mmap, Sysno::fstat, Sysno::munmap]);
let [(page, len)] = guest.mapped[..] else {
panic!(
"expected exactly one transient page, got {:?}",
guest.mapped
);
};
assert_eq!(
guest.fstat_buffers,
[page],
"fstat must write into the transient page"
);
assert_eq!(
guest.unmapped,
[(page, len)],
"the transient page must be unmapped, whole"
);
assert_eq!(recorded_inode(&guest, fd), Some(inode));
}
#[tokio::test]
async fn descriptor_is_closed_when_no_scratch_can_be_found() {
let (fd, _) = open_file();
let (tool, mut guest) = ScriptedGuest::new(false, true);
let result = tool
.add_fd(&mut guest, fd, OFlag::O_RDONLY, FdType::Regular)
.await;
close_unless_detcore_did(&guest, fd);
assert_eq!(result, Err(Errno::ENOMEM));
assert_eq!(guest.injected, [Sysno::mmap, Sysno::close]);
assert_eq!(
guest.closed,
[fd],
"the descriptor must not stay open behind the error"
);
assert_eq!(
guest.thread.with_detfd(fd, |_| ()),
Err(Errno::EBADF),
"a descriptor that failed registration must not be modeled"
);
}
}
#[cfg(test)]
mod rebound_path_tests {
use std::path::PathBuf;
use super::rebound_path;
#[test]
fn an_operand_that_cannot_be_established_is_reported_as_the_root() {
assert_eq!(rebound_path(Some(PathBuf::from("/data/F"))), "/data/F");
assert_eq!(rebound_path(None), "/");
assert_eq!(rebound_path(Some(PathBuf::from("F"))), "/");
}
}
#[cfg(test)]
mod untraced_code_tests {
use std::path::Path;
use std::path::PathBuf;
use nix::fcntl::OFlag;
use reverie::syscalls::Errno;
use reverie::syscalls::SyscallArgs;
use reverie::syscalls::Sysno;
use super::DescriptorFacts;
use super::DetPid;
use super::PROC_ROOT_INO;
use super::PidfdSignalScope;
use super::ProcessDirectoryDescriptor;
use super::classify_process_directory;
use super::descriptor_identity;
use super::may_change_untraced_code;
use super::may_write_process_memory;
use super::pidfd_signal_scope;
const PAGE: (u64, u64) = (0x7100_0000, 0x7100_1000);
fn args(arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64) -> SyscallArgs {
SyscallArgs::new(
arg0 as usize,
arg1 as usize,
arg2 as usize,
arg3 as usize,
arg4 as usize,
0,
)
}
#[test]
fn a_descriptor_is_read_through_the_thread_that_opened_it() {
use std::os::fd::AsRawFd;
let directory = tempfile::tempdir().unwrap();
let ordinary = directory.path().join("out");
let named_mem = directory.path().join("mem");
std::thread::spawn(move || {
assert_eq!(unsafe { libc::unshare(libc::CLONE_FILES) }, 0);
let tid = unsafe { libc::gettid() };
let leader = std::process::id() as i32;
let files = [
(std::fs::File::create(&ordinary).unwrap(), false),
(std::fs::File::create(&named_mem).unwrap(), false),
(
std::fs::OpenOptions::new()
.read(true)
.write(true)
.open("/proc/thread-self/mem")
.unwrap(),
true,
),
];
for (number, (file, is_process_memory)) in (900..).zip(files) {
assert_eq!(unsafe { libc::dup2(file.as_raw_fd(), number) }, number);
drop(file);
let identity = descriptor_identity(tid, number);
assert!(identity.is_some(), "{number}");
assert_eq!(descriptor_identity(leader, number), None, "{number}");
assert_eq!(
may_write_process_memory(
OFlag::O_WRONLY,
identity
.as_ref()
.map(|(link, procfs)| (link.as_path(), *procfs)),
),
is_process_memory,
"{identity:?}"
);
assert_eq!(unsafe { libc::close(number) }, 0);
}
})
.join()
.unwrap();
}
#[test]
fn a_call_counts_exactly_when_it_may_change_the_range() {
let fixed = libc::MAP_FIXED as u64 | libc::MAP_PRIVATE as u64;
let huge = fixed | libc::MAP_HUGETLB as u64;
let huge_1gb = (30 << libc::MAP_HUGE_SHIFT) as u64;
let remap_fixed = (libc::MREMAP_MAYMOVE | libc::MREMAP_FIXED) as u64;
let remap = libc::SHM_REMAP as u64;
let cases = [
(
"mmap fixed over it",
Sysno::mmap,
args(0x7100_0000, 0x1000, 7, fixed, 0),
true,
),
(
"mmap fixed reaching it",
Sysno::mmap,
args(0x70ff_f000, 0x1001, 7, fixed, 0),
true,
),
(
"mmap fixed below it",
Sysno::mmap,
args(0x70ff_f000, 0x1000, 7, fixed, 0),
false,
),
(
"mmap fixed above it",
Sysno::mmap,
args(0x7100_1000, 0x1000, 7, fixed, 0),
false,
),
(
"mmap hinted at it",
Sysno::mmap,
args(0x7100_0000, 0x1000, 7, 0x22, 0),
false,
),
(
"mmap fixed default huge page holding it",
Sysno::mmap,
args(0x7110_0000, 1, 7, huge, 0),
true,
),
(
"mmap fixed small page there",
Sysno::mmap,
args(0x7110_0000, 1, 7, fixed, 0),
false,
),
(
"mmap fixed default huge page below it",
Sysno::mmap,
args(0x70ff_f000, 1, 7, huge, 0),
false,
),
(
"mmap fixed 1 GiB page holding it",
Sysno::mmap,
args(0x4000_0000, 1, 7, huge | huge_1gb, 0),
true,
),
(
"mmap fixed 1 GiB page elsewhere",
Sysno::mmap,
args(0x8000_0000, 1, 7, huge | huge_1gb, 0),
false,
),
(
"mprotect of it",
Sysno::mprotect,
args(0x7100_0000, 0x1000, 7, 0, 0),
true,
),
(
"mprotect covering it",
Sysno::mprotect,
args(0x7000_0000, 0x200_0000, 7, 0, 0),
true,
),
(
"mprotect of a zero length",
Sysno::mprotect,
args(0x7100_0000, 0, 7, 0, 0),
true,
),
(
"pkey_mprotect of it",
Sysno::pkey_mprotect,
args(0x7100_0000, 1, 7, 0, 0),
true,
),
(
"madvise of it",
Sysno::madvise,
args(0x7100_0000, 0x1000, 4, 0, 0),
true,
),
(
"munmap of it",
Sysno::munmap,
args(0x7100_0000, 0x1000, 0, 0, 0),
true,
),
(
"munmap past it",
Sysno::munmap,
args(0x7100_1000, 0x1000, 0, 0, 0),
false,
),
(
"mremap from it",
Sysno::mremap,
args(0x7100_0000, 0x1000, 0x2000, 1, 0),
true,
),
(
"mremap fixed onto it",
Sysno::mremap,
args(0x6000_0000, 0x1000, 0x1000, remap_fixed, 0x7100_0000),
true,
),
(
"mremap fixed of a small page into its gigabyte",
Sysno::mremap,
args(0x6000_0000, 0x1000, 0x1000, remap_fixed, 0x4000_0000),
false,
),
(
"mremap moving elsewhere",
Sysno::mremap,
args(0x6000_0000, 0x1000, 0x2000, 1, 0x7100_0000),
false,
),
(
"shmat remapping at it",
Sysno::shmat,
args(3, 0x7100_0000, remap, 0, 0),
true,
),
(
"shmat remapping below it",
Sysno::shmat,
args(3, 0x6000_0000, remap, 0, 0),
true,
),
(
"shmat without remap",
Sysno::shmat,
args(3, 0x7100_0000, 0, 0, 0),
false,
),
(
"shmat anywhere",
Sysno::shmat,
args(3, 0, remap, 0, 0),
false,
),
("brk", Sysno::brk, args(0x7100_0000, 0, 0, 0, 0), false),
(
"lseek to that offset",
Sysno::lseek,
args(3, 0x7100_0000, 0, 0, 0),
false,
),
(
"an address near the end",
Sysno::munmap,
args(u64::MAX - 0xfff, 0x1000, 0, 0, 0),
false,
),
];
for (label, number, args, expected) in cases {
assert_eq!(
may_change_untraced_code(number, &args, PAGE, 2 << 20),
expected,
"{label}"
);
}
}
#[test]
fn pidfd_signal_flags_select_one_scope() {
assert_eq!(pidfd_signal_scope(0), Ok(PidfdSignalScope::Process));
assert_eq!(pidfd_signal_scope(1), Ok(PidfdSignalScope::Thread));
assert_eq!(pidfd_signal_scope(2), Ok(PidfdSignalScope::Process));
assert_eq!(pidfd_signal_scope(4), Ok(PidfdSignalScope::ProcessGroup));
for flags in [3, 5, 6, 7, 8, 9, 1 << 31, u32::MAX] {
assert_eq!(pidfd_signal_scope(flags), Err(Errno::EINVAL), "{flags:#x}");
}
}
#[test]
fn a_proc_process_directory_names_its_process() {
use ProcessDirectoryDescriptor as D;
let procfs = |link: &str, parent: Option<(u64, u64)>| DescriptorFacts {
link: PathBuf::from(link),
on_procfs: true,
is_dir: parent.is_some(),
dev: 22,
parent,
guest_proc_dev: Some(22),
};
let reaped = |link: &str| DescriptorFacts {
is_dir: true,
..procfs(link, None)
};
let root = Some((22, PROC_ROOT_INO));
let cases = [
(
"process",
procfs("/proc/3", root),
D::Process(DetPid::from_raw(3)),
),
(
"reaped process",
reaped("/proc/7 (deleted)"),
D::Process(DetPid::from_raw(7)),
),
(
"reaped task directory",
reaped("/proc/7/task/8 (deleted)"),
D::NotAProcess,
),
(
"reaped elsewhere",
reaped("/mnt/p/7 (deleted)"),
D::Unknown("it names a reaped task outside the guest's /proc"),
),
(
"procfs mounted elsewhere",
procfs("/mnt/p/3", root),
D::Process(DetPid::from_raw(3)),
),
(
"task directory",
procfs("/proc/3/task/3", Some((22, 4000))),
D::NotAProcess,
),
(
"procfs file",
procfs("/proc/3/status", None),
D::NotAProcess,
),
(
"named root entry",
procfs("/proc/sys", root),
D::NotAProcess,
),
("pid zero", procfs("/proc/0", root), D::NotAProcess),
("leading zero", procfs("/proc/03", root), D::NotAProcess),
("signed", procfs("/proc/+3", root), D::NotAProcess),
(
"another procfs root",
procfs("/proc/3", Some((23, PROC_ROOT_INO))),
D::NotAProcess,
),
(
"not the guest's procfs",
DescriptorFacts {
guest_proc_dev: Some(99),
..procfs("/proc/3", root)
},
D::Unknown("it is a procfs that is not the guest's /proc"),
),
(
"ordinary directory",
DescriptorFacts {
on_procfs: false,
..procfs("/tmp/3", root)
},
D::NotAProcess,
),
(
"pidfd",
DescriptorFacts {
on_procfs: false,
..procfs("anon_inode:[pidfd]", None)
},
D::Unknown("it is a pidfd that Detcore did not open with pidfd_open"),
),
(
"pidfs pidfd",
DescriptorFacts {
on_procfs: false,
..procfs("pidfd:[1234]", None)
},
D::Unknown("it is a pidfd that Detcore did not open with pidfd_open"),
),
];
for (label, facts, expected) in cases {
assert_eq!(
classify_process_directory(Some(&facts)),
expected,
"{label}"
);
}
assert_eq!(
classify_process_directory(None),
D::Unknown("Hermit cannot read what the descriptor names")
);
}
#[test]
fn an_open_counts_when_it_may_write_process_memory() {
let proc_mem = Some((Path::new("/proc/12/mem"), true));
let cases = [
("process mem read-write", OFlag::O_RDWR, proc_mem, true),
(
"task mem write-only",
OFlag::O_WRONLY,
Some((Path::new("/proc/12/task/13/mem"), true)),
true,
),
("an unreadable descriptor", OFlag::O_WRONLY, None, true),
("process mem read-only", OFlag::O_RDONLY, proc_mem, false),
(
"process mem as a path",
OFlag::O_PATH | OFlag::O_RDWR,
proc_mem,
false,
),
(
"an ordinary file named mem",
OFlag::O_WRONLY | OFlag::O_CREAT,
Some((Path::new("/tmp/mem"), false)),
false,
),
(
"a name that leads to a pipe",
OFlag::O_WRONLY,
Some((Path::new("pipe:[4026]"), false)),
false,
),
(
"another procfs file",
OFlag::O_WRONLY,
Some((Path::new("/proc/12/attr/current"), true)),
false,
),
(
"an unreadable read-only descriptor",
OFlag::O_RDONLY,
None,
false,
),
];
for (label, flags, descriptor, expected) in cases {
assert_eq!(
may_write_process_memory(flags, descriptor),
expected,
"{label}"
);
}
}
}
const FLOCK_REFUSAL_ADVICE: &str = "LOCK_NB is the supported form where the backend \
supports flock at all; ENOLCK is returned instead only under \
--allow-unsupported-syscalls.";
fn report_flock_refusal(message: &str) {
error!("{message}");
let _ = std::io::Write::write_fmt(
&mut crate::util::RetryingStderr,
format_args!("hermit: {message}\n"),
);
}