use std::ffi::OsStr;
use std::os::fd::RawFd;
use std::os::unix::ffi::OsStrExt;
use std::path::Path;
use nix::fcntl::OFlag;
use reverie::Error;
use reverie::Guest;
use reverie::Stack;
use reverie::syscalls;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::AtFlags;
use reverie::syscalls::Errno;
use reverie::syscalls::MapFlags;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::PathPtr;
use reverie::syscalls::ProtFlags;
use reverie::syscalls::ReadAddr;
use reverie::syscalls::StatxMask;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallInfo;
use reverie::syscalls::Sysno;
use reverie::syscalls::Timespec;
use tracing::error;
use tracing::info;
use tracing::warn;
use super::StatTarget;
use crate::fd::FdType;
use crate::procfs::FixedProcfsFile;
use crate::procfs::ProcfsFile;
use crate::procfs::RenderedFiles;
use crate::procfs::placeholder_link_path;
use crate::procfs::placeholder_name;
use crate::procfs_inode;
use crate::record_or_replay::RecordOrReplay;
use crate::stat::DetStat;
use crate::stat::StatxAttributes;
use crate::syscalls::namespace::proc_fd_target;
use crate::syscalls::namespace::proc_fd_target_with_leading_zeros;
use crate::tool_local::Detcore;
use crate::util::raw_result;
use crate::util::raw_syscall;
const XATTR_SIZE_MAX: usize = 65536;
const XATTR_NAME_MAX: usize = 255;
pub(crate) fn rendered_path_within(within: &Path, files: RenderedFiles) -> Option<&'static Path> {
let relative = within.strip_prefix("/").unwrap_or(within);
ProcfsFile::from_path(&Path::new("/proc").join(relative))?.rendered_path(files)
}
pub(crate) const PLACEHOLDER_SEALS: libc::c_int =
libc::F_SEAL_SEAL | libc::F_SEAL_SHRINK | libc::F_SEAL_GROW | libc::F_SEAL_WRITE;
const PLACEHOLDER_NAME_CAPACITY: usize = 250;
const CARRIED_UPTIME_NSEC_BITS: u32 = 29;
fn carried_uptime_mtime(uptime_seconds: u64) -> Timespec {
Timespec {
tv_sec: -1 - (uptime_seconds >> CARRIED_UPTIME_NSEC_BITS) as i64,
tv_nsec: (uptime_seconds & ((1 << CARRIED_UPTIME_NSEC_BITS) - 1)) as i64,
}
}
fn descriptor_stable_across_injections(sequentialized: bool, guest_code_between: bool) -> bool {
sequentialized && !guest_code_between
}
fn may_carry_uptime(stable: bool, identity: Option<&Path>, path: &Path) -> bool {
stable && identity == Some(path)
}
fn carried_uptime(seconds: i64, nanoseconds: i64) -> Option<u64> {
if seconds >= 0 || !(0..1 << CARRIED_UPTIME_NSEC_BITS).contains(&nanoseconds) {
return None;
}
let high = (-1 - seconds) as u64;
(high < 1 << (64 - CARRIED_UPTIME_NSEC_BITS))
.then_some((high << CARRIED_UPTIME_NSEC_BITS) | nanoseconds as u64)
}
static PLACEHOLDERS: std::sync::Mutex<std::collections::BTreeMap<(u64, u64), &'static Path>> =
std::sync::Mutex::new(std::collections::BTreeMap::new());
pub(crate) fn register_placeholder(dev: u64, ino: u64, path: &'static Path) {
PLACEHOLDERS
.lock()
.expect("placeholder registry poisoned")
.insert((dev, ino), path);
}
static PLACEHOLDER_OPENS: std::sync::Mutex<
std::collections::BTreeMap<(u64, u64), PlaceholderOpen>,
> = std::sync::Mutex::new(std::collections::BTreeMap::new());
type PlaceholderOpen = (crate::fd::OpenFileHandle, Vec<u8>);
pub(crate) fn register_placeholder_open(
identity: (u64, u64),
handle: crate::fd::OpenFileHandle,
snapshot: Vec<u8>,
) {
PLACEHOLDER_OPENS
.lock()
.expect("placeholder open registry poisoned")
.insert(identity, (handle, snapshot));
}
fn placeholder_open(identity: (u64, u64)) -> Option<PlaceholderOpen> {
PLACEHOLDER_OPENS
.lock()
.expect("placeholder open registry poisoned")
.get(&identity)
.cloned()
}
pub(crate) fn placeholders_exist() -> bool {
!PLACEHOLDERS
.lock()
.expect("placeholder registry poisoned")
.is_empty()
}
pub(crate) fn placeholder_identity(dev: u64, ino: u64) -> Option<&'static Path> {
PLACEHOLDERS
.lock()
.expect("placeholder registry poisoned")
.get(&(dev, ino))
.copied()
}
const DYNAMIC_PATHS: [&std::ffi::CStr; 4] = [
c"/proc/sys/kernel/random/uuid",
c"/proc/sys/kernel/pty/nr",
c"/proc/uptime",
c"/proc/stat",
];
pub(crate) fn rendered_paths(
files: RenderedFiles,
) -> impl Iterator<Item = &'static std::ffi::CStr> {
DYNAMIC_PATHS
.into_iter()
.chain(files.cpuinfo.then_some(c"/proc/cpuinfo"))
.chain(
FixedProcfsFile::ALL
.into_iter()
.map(FixedProcfsFile::c_path),
)
}
fn rendered_name(path: &std::ffi::CStr) -> &[u8] {
let bytes = path.to_bytes();
bytes.rsplit(|byte| *byte == b'/').next().unwrap_or(bytes)
}
pub(crate) fn rendered_path_of_raw(stat: &DetStat, files: RenderedFiles) -> Option<&'static Path> {
let has = |field| stat.mask.contains(field);
if (has(StatxMask::STATX_TYPE) && stat.mode & libc::S_IFMT != libc::S_IFREG)
|| (has(StatxMask::STATX_NLINK) && stat.nlink != 1)
|| (has(StatxMask::STATX_MODE) && !matches!(stat.mode & 0o7777, 0o444 | 0o644))
{
return None;
}
let identity = (stat.dev, stat.inode);
if NOT_RENDERED
.lock()
.expect("raw identity cache poisoned")
.contains(&identity)
{
return None;
}
let found = rendered_path_among(stat.dev, stat.inode, rendered_paths(RenderedFiles::ALL));
if found.is_none() && proc_device() == Some(stat.dev) {
NOT_RENDERED
.lock()
.expect("raw identity cache poisoned")
.insert(identity);
}
found
.and_then(ProcfsFile::from_path)
.and_then(|file| file.rendered_path(files))
}
static NOT_RENDERED: std::sync::Mutex<std::collections::BTreeSet<(u64, u64)>> =
std::sync::Mutex::new(std::collections::BTreeSet::new());
pub(super) fn proc_device() -> Option<u64> {
static PROC_DEVICE: std::sync::OnceLock<Option<u64>> = std::sync::OnceLock::new();
*PROC_DEVICE.get_or_init(|| GuestProcfs::stat(c"/proc").ok().map(|stat| stat.st_dev))
}
fn rendered_path_among(
dev: u64,
ino: u64,
mut paths: impl Iterator<Item = &'static std::ffi::CStr>,
) -> Option<&'static Path> {
if proc_device() != Some(dev) {
return None;
}
paths.find_map(|path| {
let stat = GuestProcfs::stat(path).ok()?;
(stat.st_dev == dev && stat.st_ino == ino)
.then(|| Path::new(OsStr::from_bytes(path.to_bytes())))
.and_then(|path| ProcfsFile::from_path(path)?.rendered_path(RenderedFiles::ALL))
})
}
struct GuestProcfs;
impl GuestProcfs {
fn stat(path: &std::ffi::CStr) -> Result<libc::stat, Errno> {
let mut stat = std::mem::MaybeUninit::<libc::stat>::zeroed();
let result = unsafe {
raw_syscall(
libc::SYS_newfstatat,
[
libc::AT_FDCWD as u64,
path.as_ptr() as u64,
stat.as_mut_ptr() as u64,
0,
0,
0,
],
)
};
raw_errno(result)?;
Ok(unsafe { stat.assume_init() })
}
fn sysctl_owner() -> Result<(u32, u32), Errno> {
static OWNER: std::sync::OnceLock<(u32, u32)> = std::sync::OnceLock::new();
if let Some(owner) = OWNER.get() {
return Ok(*owner);
}
let stat = Self::stat(c"/proc/sys/kernel")?;
Ok(*OWNER.get_or_init(|| (stat.st_uid, stat.st_gid)))
}
fn statfs() -> Result<(libc::statfs, u64), Errno> {
const WORDS: usize = 15;
const _: () = assert!(std::mem::size_of::<libc::statfs>() == WORDS * 8);
static WORDS_READ: std::sync::OnceLock<[u64; WORDS]> = std::sync::OnceLock::new();
let words = match WORDS_READ.get() {
Some(words) => *words,
None => {
let mut words = [0_u64; WORDS];
let result = unsafe {
raw_syscall(
libc::SYS_statfs,
[
c"/proc".as_ptr() as u64,
words.as_mut_ptr() as u64,
0,
0,
0,
0,
],
)
};
raw_errno(result)?;
*WORDS_READ.get_or_init(|| words)
}
};
let flags = words[10];
let statfs = unsafe { std::mem::transmute::<[u64; WORDS], libc::statfs>(words) };
Ok((statfs, flags))
}
fn mount_id() -> Result<u64, Error> {
static MOUNT_ID: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
if let Some(mount_id) = MOUNT_ID.get() {
return Ok(*mount_id);
}
let mut statx = std::mem::MaybeUninit::<libc::statx>::zeroed();
let result = unsafe {
raw_syscall(
libc::SYS_statx,
[
libc::AT_FDCWD as u64,
c"/proc".as_ptr() as u64,
0,
u64::from(libc::STATX_MNT_ID),
statx.as_mut_ptr() as u64,
0,
],
)
};
raw_errno(result)?;
let statx = unsafe { statx.assume_init() };
if statx.stx_mask & libc::STATX_MNT_ID == 0 {
return Err(Errno::EOPNOTSUPP.into());
}
Ok(*MOUNT_ID.get_or_init(|| statx.stx_mnt_id))
}
fn maps_id(gid: bool, id: u32) -> bool {
static UID_MAP: std::sync::OnceLock<Vec<u8>> = std::sync::OnceLock::new();
static GID_MAP: std::sync::OnceLock<Vec<u8>> = std::sync::OnceLock::new();
if id == u32::MAX {
return false;
}
let (cell, path) = if gid {
(&GID_MAP, c"/proc/self/gid_map")
} else {
(&UID_MAP, c"/proc/self/uid_map")
};
let map = match cell.get() {
Some(map) => map,
None => match Self::read_small(path) {
Some(map) => cell.get_or_init(|| map),
None => return false,
},
};
String::from_utf8_lossy(map).lines().any(|line| {
let fields: Vec<u64> = line
.split_whitespace()
.filter_map(|field| field.parse().ok())
.collect();
matches!(fields.as_slice(), [inside, _, count]
if (*inside..inside.saturating_add(*count)).contains(&u64::from(id)))
})
}
fn read_small(path: &std::ffi::CStr) -> Option<Vec<u8>> {
let fd = unsafe {
raw_syscall(
libc::SYS_openat,
[
libc::AT_FDCWD as u64,
path.as_ptr() as u64,
(libc::O_RDONLY | libc::O_CLOEXEC) as u64,
0,
0,
0,
],
)
};
let fd = raw_errno(fd).ok()?;
let mut buffer = vec![0_u8; 4096];
let length = unsafe {
raw_syscall(
libc::SYS_read,
[fd, buffer.as_mut_ptr() as u64, buffer.len() as u64, 0, 0, 0],
)
};
unsafe { raw_syscall(libc::SYS_close, [fd, 0, 0, 0, 0, 0]) };
buffer.truncate(raw_errno(length).ok()? as usize);
Some(buffer)
}
fn remember() {
let _ = Self::sysctl_owner();
let _ = Self::statfs();
let _ = Self::mount_id();
let _ = Self::maps_id(false, 0);
let _ = Self::maps_id(true, 0);
}
}
fn raw_errno(result: i64) -> Result<u64, Errno> {
raw_result(result)
.map_err(|error| Errno::new(error.raw_os_error().expect("a raw result is an errno")))
}
pub(super) fn guest_procfs_mount_id() -> Result<u64, Error> {
GuestProcfs::mount_id()
}
fn rendered_stat(path: &Path, epoch: Timespec, owner: (u32, u32)) -> DetStat {
let permissions = path
.to_str()
.and_then(FixedProcfsFile::from_path)
.map_or(0o444, FixedProcfsFile::permissions);
let permissions = if rendered_path_is_owner_only(path) {
0o400
} else {
permissions
};
DetStat {
mask: StatxMask::STATX_BASIC_STATS | StatxMask::STATX_MNT_ID,
mode: libc::S_IFREG | permissions,
uid: owner.0,
gid: owner.1,
attributes: StatxAttributes::empty(),
attributes_mask: StatxAttributes::STATX_ATTR_AUTOMOUNT
| StatxAttributes::STATX_ATTR_MOUNT_ROOT
| StatxAttributes::STATX_ATTR_DAX,
dev: procfs_inode::VIRTUAL_PROC_DEVICE,
rdev: 0,
inode: procfs_inode::rendered_inode(path),
nlink: 1,
size: 0,
blksize: procfs_inode::PROC_BLOCK_SIZE,
blocks: 0,
atime: epoch,
btime: epoch,
ctime: epoch,
mtime: epoch,
}
}
pub(super) fn rendered_path_is_owner_only(path: &Path) -> bool {
crate::procfs::per_process_name(path).is_some_and(|name| name.filename == "auxv")
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum AuxvAccess {
Answer(Result<(), Errno>),
CallerCapability,
}
pub(super) fn auxv_access_answer(
target: Result<(), Errno>,
serves: Result<(), Errno>,
) -> AuxvAccess {
match (target, serves) {
(Ok(()), _) => AuxvAccess::Answer(Ok(())),
(Err(refused), Ok(())) => AuxvAccess::Answer(Err(refused)),
(Err(_), Err(Errno::EACCES)) => AuxvAccess::CallerCapability,
(Err(_), Err(errno)) => AuxvAccess::Answer(Err(errno)),
}
}
fn rendered_owner(path: &Path) -> Result<(u32, u32), Errno> {
if crate::procfs::rendered_path_is_per_process(path) {
Ok((0, 0))
} else {
GuestProcfs::sysctl_owner()
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) struct FileAccess {
owner: bool,
readable: bool,
dac_override: bool,
sys_admin: bool,
}
impl FileAccess {
pub(super) const GLOBAL_ROOT: Self = Self {
owner: false,
readable: true,
dac_override: false,
sys_admin: false,
};
fn owned_with(capabilities: u64) -> Self {
Self {
owner: true,
readable: true,
dac_override: capabilities & (1 << CAP_DAC_OVERRIDE) != 0,
sys_admin: capabilities & (1 << CAP_SYS_ADMIN) != 0,
}
}
fn may_write(&self) -> bool {
self.dac_override
}
}
const CAP_DAC_OVERRIDE: u32 = 1;
const CAP_SYS_ADMIN: u32 = 21;
const CAP_SYS_PTRACE: u32 = 19;
const LINUX_CAPABILITY_VERSION_3: u32 = 0x2008_0522;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum CapabilitySet {
Effective,
Permitted,
}
pub(super) fn epoch_time(epoch: chrono::DateTime<chrono::Utc>) -> Timespec {
Timespec {
tv_sec: epoch.timestamp(),
tv_nsec: i64::from(epoch.timestamp_subsec_nanos()),
}
}
fn names_a_directory(path: &Path) -> bool {
let bytes = path.as_os_str().as_bytes();
bytes.ends_with(b"/") || bytes.ends_with(b"/.")
}
fn rendered_open_flags(flags: OFlag, access: FileAccess) -> Result<OFlag, Errno> {
if let Some(errno) = open_flags_refused(flags) {
return Err(errno);
}
if flags.contains(OFlag::O_PATH) {
if flags.contains(OFlag::O_DIRECTORY) {
return Err(Errno::ENOTDIR);
}
return Ok(OFlag::O_PATH | (flags & OFlag::O_CLOEXEC));
}
if flags.contains(OFlag::O_TMPFILE) {
return Err(Errno::ENOTDIR);
}
if flags.contains(OFlag::O_CREAT | OFlag::O_EXCL) {
return Err(Errno::EEXIST);
}
if flags.contains(OFlag::O_DIRECTORY) {
return Err(Errno::ENOTDIR);
}
let accmode = flags & OFlag::O_ACCMODE;
let reads =
accmode == OFlag::O_RDONLY || accmode == OFlag::O_RDWR || accmode == OFlag::O_ACCMODE;
let writes = accmode != OFlag::O_RDONLY || flags.contains(OFlag::O_TRUNC);
if (writes && !access.may_write()) || (reads && !access.readable) {
return Err(Errno::EACCES);
}
if flags.contains(OFlag::O_NOATIME) && !access.owner {
return Err(Errno::EPERM);
}
if flags.contains(OFlag::O_DIRECT) {
return Err(Errno::EINVAL);
}
let kept = OFlag::O_APPEND
| OFlag::O_ASYNC
| OFlag::O_CLOEXEC
| OFlag::O_DSYNC
| OFlag::O_LARGEFILE
| OFlag::O_NOATIME
| OFlag::O_NONBLOCK
| OFlag::O_SYNC;
let mode = flags & OFlag::O_ACCMODE;
Ok(mode | (flags & kept))
}
pub(super) fn open_flags_refused(flags: OFlag) -> Option<Errno> {
if flags.contains(OFlag::O_PATH) {
return None;
}
let tmpfile = OFlag::O_TMPFILE & !OFlag::O_DIRECTORY;
if flags.intersects(tmpfile)
&& (flags & (OFlag::O_TMPFILE | OFlag::O_CREAT) != OFlag::O_TMPFILE
|| flags & OFlag::O_ACCMODE == OFlag::O_RDONLY)
{
return Some(Errno::EINVAL);
}
flags
.contains(OFlag::O_CREAT | OFlag::O_DIRECTORY)
.then_some(Errno::EINVAL)
}
fn rendered_mmap_address_checks(
addr: usize,
len: usize,
offset: libc::off_t,
flags: MapFlags,
) -> Result<usize, Errno> {
if flags.contains(MapFlags::MAP_HUGETLB) || len == 0 || offset & 4095 != 0 {
return Err(Errno::EINVAL);
}
const TASK_SIZE: usize = 0x7fff_ffff_f000;
let Some(len) = len.checked_add(4095).map(|length| length & !4095) else {
return Err(Errno::ENOMEM);
};
if len > TASK_SIZE {
return Err(Errno::ENOMEM);
}
if flags.intersects(MapFlags::MAP_FIXED | MapFlags::MAP_FIXED_NOREPLACE) {
if addr > TASK_SIZE - len {
return Err(Errno::ENOMEM);
}
if addr & 4095 != 0 {
return Err(Errno::EINVAL);
}
let mmap_min_addr = crate::machine::MachineDescription::default()
.limits
.mmap_min_addr;
if (addr as u64) < mmap_min_addr {
return Err(Errno::EPERM);
}
}
Ok(len)
}
fn rendered_mmap_file_checks(
len: usize,
offset: libc::off_t,
prot: ProtFlags,
flags: MapFlags,
noexec: bool,
seq_file: bool,
(readable, writable): (bool, bool),
) -> Errno {
const MAX_LFS_FILESIZE: u64 = i64::MAX as u64;
if offset as u64 / 4096 > (MAX_LFS_FILESIZE - len as u64) >> 12 {
return Errno::EOVERFLOW;
}
let map_type = flags.bits() & libc::MAP_TYPE;
if map_type != libc::MAP_SHARED
&& map_type != libc::MAP_PRIVATE
&& map_type != libc::MAP_SHARED_VALIDATE
{
return Errno::EINVAL;
}
if map_type == libc::MAP_SHARED_VALIDATE && flags.bits() & !LEGACY_MAP_MASK != 0 {
return Errno::EOPNOTSUPP;
}
if map_type != libc::MAP_PRIVATE && prot.contains(ProtFlags::PROT_WRITE) && !writable {
return Errno::EACCES;
}
if !readable {
return Errno::EACCES;
}
if noexec && prot.contains(ProtFlags::PROT_EXEC) {
return Errno::EPERM;
}
if !seq_file {
return Errno::ENODEV;
}
if flags.contains(MapFlags::MAP_GROWSDOWN) {
return Errno::EINVAL;
}
Errno::EIO
}
const LEGACY_MAP_MASK: libc::c_int = libc::MAP_SHARED
| libc::MAP_PRIVATE
| libc::MAP_FIXED
| libc::MAP_ANONYMOUS
| libc::MAP_DENYWRITE
| libc::MAP_EXECUTABLE
| 0x400_0000 | libc::MAP_GROWSDOWN
| libc::MAP_LOCKED
| libc::MAP_NORESERVE
| libc::MAP_POPULATE
| libc::MAP_NONBLOCK
| libc::MAP_STACK
| libc::MAP_HUGETLB
| libc::MAP_32BIT
| 0x80 | (21 << 26) | (30 << 26);
#[cfg(test)]
fn rendered_mmap_answer(
addr: usize,
len: usize,
offset: libc::off_t,
prot: ProtFlags,
flags: MapFlags,
noexec: bool,
seq_file: bool,
) -> Result<i64, Errno> {
let len = rendered_mmap_address_checks(addr, len, offset, flags)?;
Err(rendered_mmap_file_checks(
len,
offset,
prot,
flags,
noexec,
seq_file,
(true, false),
))
}
fn rendered_seq_file_pwrite_answer(sysno: Sysno, position: i64) -> Option<Result<i64, Errno>> {
if sysno == Sysno::pwritev2 && position == -1 {
return None;
}
Some(Err(if position < 0 {
Errno::EINVAL
} else {
Errno::ESPIPE
}))
}
fn xattr_change_answer(
name: &[u8],
size: Option<usize>,
value: Option<&[u8]>,
access: FileAccess,
) -> Result<i64, Errno> {
if name.is_empty() || name.len() > 255 {
return Err(Errno::ERANGE);
}
if size.is_some_and(|size| size > XATTR_SIZE_MAX) {
return Err(Errno::E2BIG);
}
if size.is_some_and(|size| size > 0) && value.is_none() {
return Err(Errno::EFAULT);
}
let setting = size.is_some();
if name.starts_with(b"trusted.") {
Err(Errno::EPERM)
} else if name == b"system.posix_acl_access" || name == b"system.posix_acl_default" {
if setting && posix_acl_parser_refuses(value.unwrap_or_default()) {
Err(Errno::EINVAL)
} else {
Err(Errno::EOPNOTSUPP)
}
} else if name == b"security.capability" && setting {
Err(Errno::EINVAL)
} else if name.starts_with(b"security.") {
Err(if access.sys_admin {
Errno::EOPNOTSUPP
} else {
Errno::EPERM
})
} else if name.starts_with(b"system.") {
Err(Errno::EOPNOTSUPP)
} else {
Err(if access.may_write() {
Errno::EOPNOTSUPP
} else {
Errno::EACCES
})
}
}
fn posix_acl_parser_refuses(value: &[u8]) -> bool {
if value.is_empty() {
return false;
}
let Some((header, entries)) = value.split_first_chunk::<4>() else {
return true;
};
if u32::from_le_bytes(*header) != 2 {
return false;
}
if entries.len() % 8 != 0 {
return true;
}
entries.as_chunks::<8>().0.iter().any(|entry| {
let tag = u16::from_le_bytes([entry[0], entry[1]]);
let id = u32::from_le_bytes([entry[4], entry[5], entry[6], entry[7]]);
match tag {
0x01 | 0x04 | 0x10 | 0x20 => false,
0x02 => !GuestProcfs::maps_id(false, id),
0x08 => !GuestProcfs::maps_id(true, id),
_ => true,
}
})
}
fn xattr_get_answer(name: &[u8], readable: bool) -> Result<i64, Errno> {
if name.is_empty() || name.len() > 255 {
Err(Errno::ERANGE)
} else if name.starts_with(b"trusted.") {
Err(Errno::ENODATA)
} else if !readable && !name.starts_with(b"security.") && !name.starts_with(b"system.") {
Err(Errno::EACCES)
} else {
Err(Errno::EOPNOTSUPP)
}
}
pub(super) fn c_string<const N: usize>(text: &[u8]) -> [u8; N] {
assert!(text.len() < N, "{} bytes do not fit in {N}", text.len());
let mut buffer = [0; N];
buffer[..text.len()].copy_from_slice(text);
buffer
}
fn write_link<M: MemoryAccess>(
memory: &mut M,
link: &Path,
buffer: Option<AddrMut<'_, libc::c_char>>,
buffer_len: usize,
) -> Result<i64, Error> {
let link = link.as_os_str().as_bytes();
let copied = link.len().min(buffer_len);
let buffer = buffer.ok_or(Errno::EFAULT)?;
memory.write_exact(buffer.cast::<u8>(), &link[..copied])?;
Ok(copied as i64)
}
pub(super) struct RenderedTarget {
pub(super) procfs: ProcfsFile,
pub(super) via_link: bool,
}
impl<T: RecordOrReplay> Detcore<T> {
pub(super) fn renders_procfs<G: Guest<Self>>(&self, guest: &G) -> bool {
!self.cfg.recordreplay_modes
&& !guest
.thread_state()
.changed_root
.load(std::sync::atomic::Ordering::SeqCst)
}
pub(super) async fn rendered_task_state<G: Guest<Self>>(
&self,
guest: &mut G,
path: &Path,
) -> Option<(crate::procfs::listing::ProcfsTaskAnswer, bool)> {
let name = crate::procfs::per_process_name(path)?;
let answer = crate::tool_global::procfs_task(guest, name.task).await;
let current = name
.incarnation
.is_some_and(|bound| answer.still_names(bound));
Some((answer, current))
}
pub(crate) async fn require_rendered_task<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<(), Errno> {
let Some(path) = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_rendered_path())
.ok()
.flatten()
else {
return Ok(());
};
if !ProcfsFile::from_rendered_path(path).is_some_and(|file| file.shows_at_read()) {
return Ok(());
}
match self.rendered_task_state(guest, path).await {
Some((_, false)) => Err(Errno::ESRCH),
_ => Ok(()),
}
}
pub(super) async fn rendered_file_owner<G: Guest<Self>>(
&self,
guest: &mut G,
path: &Path,
) -> Result<(u32, u32), Errno> {
match self.rendered_task_state(guest, path).await {
Some((answer, true)) if !answer.without_mm => Ok((0, 0)),
Some(_) => GuestProcfs::sysctl_owner(),
None => rendered_owner(path),
}
}
pub(super) async fn rendered_metadata<G: Guest<Self>>(
&self,
guest: &mut G,
path: &Path,
) -> Result<DetStat, Error> {
let owner = self.rendered_file_owner(guest, path).await?;
let epoch = epoch_time(guest.config().epoch);
let mut stat = rendered_stat(path, epoch, owner);
if crate::procfs::per_process_name(path).is_some() {
let state = crate::tool_global::rendered_file_state(
guest,
stat.inode,
crate::procfs::listing::RenderedFileChange::Read,
)
.await;
if let Some((tv_sec, tv_nsec)) = state.mtime {
stat.mtime = Timespec { tv_sec, tv_nsec };
}
}
Ok(stat)
}
pub(super) async fn rendered_procfs_at<G: Guest<Self>>(
&self,
guest: &mut G,
path: &Path,
) -> Result<Option<RenderedTarget>, Error> {
if !self.renders_procfs(guest)
|| path
.components()
.any(|component| component == std::path::Component::ParentDir)
{
return Ok(None);
}
if let Some(mut procfs) = ProcfsFile::from_path(path) {
if procfs.per_process_name().is_some() {
let Some((pid, tid)) = self.procfs_caller_ids(guest) else {
return Ok(None);
};
procfs.bind_task(pid, tid);
let Some(task) = procfs.bound_task() else {
return Err(Errno::ENOENT.into());
};
let answer = crate::tool_global::procfs_task(guest, task).await;
if !answer.exists {
return Err(Errno::ENOENT.into());
}
let without_mm = answer.without_mm;
self.bind_task_identity(guest, &mut procfs, answer).await?;
if Self::auxv_kept_by_kernel(guest, &procfs, without_mm).await {
return Ok(None);
}
if procfs.mount_table_rendering().is_some()
&& crate::tool_global::root_changed(
guest,
detcore_model::pid::DetPid::from_raw(task.thread.unwrap_or(task.process)),
)
.await
{
return Ok(None);
}
}
if procfs.rendered_path(self.rendered_files(guest)).is_none() {
return Ok(None);
}
if names_a_directory(path) {
return Err(Errno::ENOTDIR.into());
}
let via_link = crate::procfs::is_proc_mounts_link(path);
return Ok(Some(RenderedTarget { procfs, via_link }));
}
if let Some((subject, fd)) = proc_fd_target_with_leading_zeros(path) {
let own = match subject {
Some(subject) => self.guest_visible_own_pid(guest).await? == i64::from(subject),
None => true,
};
let rendered = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_rendered_path().is_some())
.unwrap_or(false);
if own && rendered {
return Err(Errno::ENOENT.into());
}
return Ok(None);
}
let Some((subject, fd)) = proc_fd_target(path) else {
return Ok(None);
};
if let Some(subject) = subject
&& self.guest_visible_own_pid(guest).await? != i64::from(subject)
{
return Ok(None);
}
let target = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_rendered_path())
.ok()
.flatten()
.and_then(ProcfsFile::from_rendered_path)
.map(|procfs| RenderedTarget {
procfs: procfs.into_rendered(),
via_link: true,
});
if target.is_some() && names_a_directory(path) {
return Err(Errno::ENOTDIR.into());
}
Ok(target)
}
pub(super) async fn rendered_procfs_behind<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<Option<&'static Path>, Error> {
if !self.renders_procfs(guest) {
return Ok(None);
}
if let Ok(stat) = self.inject_fstat(guest, fd).await
&& let Some(path) = placeholder_identity(stat.st_dev, stat.st_ino)
{
return Ok(Some(path));
}
if !self.cfg.backend.tool_shares_guest_descriptor_table {
return Ok(None);
}
let named = self.placeholder_named(guest, fd).await?;
if named.is_none() {
return Ok(None);
}
let seals = guest
.inject(
syscalls::Fcntl::new()
.with_fd(fd)
.with_cmd(syscalls::FcntlCmd::F_GET_SEALS),
)
.await;
let wanted = i64::from(PLACEHOLDER_SEALS);
Ok(named.filter(|_| match seals {
Ok(seals) => seals & wanted == wanted,
Err(errno) => errno == Errno::EBADF,
}))
}
async fn placeholder_named<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<Option<&'static Path>, Error> {
const TARGET_CAPACITY: usize = crate::procfs::PLACEHOLDER_LINK_CAPACITY;
let mut stack = guest.stack().await;
let link = stack.push(c_string::<32>(
format!("/proc/thread-self/fd/{fd}").as_bytes(),
));
let target = stack.reserve::<[u8; TARGET_CAPACITY]>();
let stack_guard = stack.commit()?;
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 path = match length {
Ok(length) => {
let mut bytes = vec![0; (length as usize).min(TARGET_CAPACITY)];
guest.memory().read_exact(target.cast::<u8>(), &mut bytes)?;
placeholder_link_path(&bytes, self.rendered_files(guest))
}
Err(_) => None,
};
drop(stack_guard);
Ok(path)
}
pub(super) async fn placeholder_reached<G: Guest<Self>>(
&self,
guest: &mut G,
dirfd: RawFd,
path: Option<PathPtr<'_>>,
follow: bool,
) -> Option<&'static Path> {
let pointer = path?;
let in_guest = self.cfg.backend.tool_shares_guest_descriptor_table;
if (!placeholders_exist() && !in_guest) || !self.renders_procfs(guest) {
return None;
}
if !in_guest && !guest.thread_state().holds_a_rendered_procfs_file() {
let text: std::path::PathBuf = pointer.read(&guest.memory()).ok()?;
let names_a_link = super::names_descriptor_link(&text)
|| text.starts_with("/dev/std")
|| text.starts_with("/dev/fd/");
if !names_a_link {
return None;
}
}
let path = pointer;
let flags = if follow {
AtFlags::empty()
} else {
AtFlags::AT_SYMLINK_NOFOLLOW
};
let stat = Self::inject_statat(guest, dirfd, path, [Some(path), None], flags)
.await
.ok()?;
let target = StatTarget::Path {
dirfd,
path: Some(path),
follow,
};
self.recognize_placeholder(guest, &DetStat::from(stat), target)
.await
}
pub(super) async fn recognize_placeholder<G: Guest<Self>>(
&self,
guest: &mut G,
stat: &DetStat,
target: StatTarget<'_>,
) -> Option<&'static Path> {
if let Some(path) = placeholder_identity(stat.dev, stat.inode) {
return Some(path);
}
let has = |field| stat.mask.contains(field);
let may_be_placeholder = (!has(StatxMask::STATX_TYPE)
|| stat.mode & libc::S_IFMT == libc::S_IFREG)
&& (!has(StatxMask::STATX_NLINK) || stat.nlink == 0)
&& (!has(StatxMask::STATX_SIZE) || stat.size == 0);
if !self.cfg.backend.tool_shares_guest_descriptor_table
|| self.cfg.recordreplay_modes
|| !may_be_placeholder
{
return None;
}
let (fd, opened) = match target {
StatTarget::Descriptor(fd) => (fd, false),
StatTarget::Path {
dirfd,
path: Some(path),
follow,
} => {
let flags = OFlag::O_PATH
| OFlag::O_CLOEXEC
| if follow {
OFlag::empty()
} else {
OFlag::O_NOFOLLOW
};
let fd = guest
.inject(
syscalls::Openat::new()
.with_dirfd(dirfd)
.with_path(Some(path))
.with_flags(flags),
)
.await
.ok()?;
(fd as RawFd, true)
}
_ => return None,
};
let path = self.rendered_procfs_behind(guest, fd).await.ok().flatten();
if opened {
let _ = guest.inject(syscalls::Close::new().with_fd(fd)).await;
}
if let Some(path) = path {
register_placeholder(stat.dev, stat.inode, path);
}
path
}
async fn placeholder_descriptor<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Option<&'static Path> {
let in_guest = self.cfg.backend.tool_shares_guest_descriptor_table;
if !in_guest
&& (!placeholders_exist() || !guest.thread_state().holds_a_rendered_procfs_file())
{
return None;
}
let stat = self.inject_fstat(guest, fd).await.ok()?;
self.recognize_placeholder(guest, &DetStat::from(stat), StatTarget::Descriptor(fd))
.await
}
pub(super) async fn rendered_file_access<G: Guest<Self>>(
&self,
guest: &mut G,
path: &Path,
needed: bool,
set: CapabilitySet,
) -> Result<FileAccess, Error> {
if !crate::procfs::rendered_path_is_per_process(path) {
return Ok(FileAccess::GLOBAL_ROOT);
}
match self.rendered_task_state(guest, path).await {
Some((answer, true)) if !answer.without_mm => {}
_ => {
return Ok(FileAccess {
readable: !rendered_path_is_owner_only(path),
..FileAccess::GLOBAL_ROOT
});
}
}
let capabilities = if needed {
Self::inject_capget(guest, set).await?.unwrap_or(0)
} else {
0
};
Ok(FileAccess::owned_with(capabilities))
}
pub(super) async fn inject_capget<G: Guest<Self>>(
guest: &mut G,
set: CapabilitySet,
) -> Result<Option<u64>, Error> {
let (scratch, original, stack_guard) = match Self::borrow_scratch::<G, 32>(guest).await {
Ok(Some(borrowed)) => borrowed,
Ok(None) => return Ok(None),
Err(reason) => {
return Err(
Self::scratch_failure(guest, reverie::syscalls::Sysno::capget, reason).await,
);
}
};
let caller = &mut *guest;
let words = async move {
let guest = caller;
let header = scratch;
let data = AddrMut::<u8>::from_raw(scratch.as_raw() + 8)?;
let mut bytes = [0_u8; 32];
bytes[..4].copy_from_slice(&LINUX_CAPABILITY_VERSION_3.to_ne_bytes());
guest.memory().write_exact(header, &bytes).ok()?;
guest
.inject(
syscalls::Capget::new()
.with_header(AddrMut::from_raw(header.as_raw()))
.with_data(AddrMut::from_raw(data.as_raw())),
)
.await
.ok()?;
let mut read = [0_u8; 24];
guest.memory().read_exact(data, &mut read).ok()?;
Some(read)
}
.await;
let restored = guest.memory().write_exact(scratch, &original);
drop(stack_guard);
if let Err(errno) = restored {
let reason = format!(
"the guest stack scratch under an injected capget could not be restored: {errno}"
);
return Err(
Self::scratch_failure(guest, reverie::syscalls::Sysno::capget, reason).await,
);
}
let Some(words) = words else {
return Ok(None);
};
let word =
|index: usize| u32::from_ne_bytes(words[index * 4..index * 4 + 4].try_into().unwrap());
let index = match set {
CapabilitySet::Effective => 0,
CapabilitySet::Permitted => 1,
};
Ok(Some(
u64::from(word(index)) | (u64::from(word(index + 3)) << 32),
))
}
pub(super) async fn borrow_scratch<G: Guest<Self>, const N: usize>(
guest: &mut G,
) -> Result<
Option<(
AddrMut<'static, u8>,
[u8; N],
<G::Stack as Stack>::StackGuard,
)>,
String,
> {
let mut stack = guest.stack().await;
let scratch = stack.reserve::<[u8; N]>().cast::<u8>();
let mut original = [0_u8; N];
if !super::save_procfs_scratch(&mut guest.memory(), scratch, &mut original) {
return Ok(None);
}
match stack.commit() {
Ok(guard) => Ok(Some((scratch, original, guard))),
Err(_) => match guest.memory().write_exact(scratch, &original) {
Ok(()) => Ok(None),
Err(errno) => Err(format!(
"a failed stack commit's partial write to the guest stack scratch could not \
be put back: {errno}"
)),
},
}
}
async fn scratch_failure<G: Guest<Self>>(
guest: &mut G,
sysno: reverie::syscalls::Sysno,
reason: String,
) -> Error {
error!("Detcore refuses {sysno}: {reason}");
let panic_on_unsupported = guest.config().panic_on_unsupported_syscalls;
match crate::syscalls::helpers::refuse_unserviceable_operation_with(
guest,
panic_on_unsupported,
sysno,
Errno::EOPNOTSUPP,
Some(&reason),
)
.await
{
Ok(_) => Errno::EOPNOTSUPP.into(),
Err(error) => error,
}
}
pub(super) async fn open_rendered_procfs<G: Guest<Self>>(
&self,
guest: &mut G,
flags: OFlag,
target: RenderedTarget,
) -> Result<i64, Error> {
if let Some(errno) = open_flags_refused(flags) {
return Err(errno.into());
}
if target.via_link
&& flags.contains(OFlag::O_CREAT | OFlag::O_EXCL)
&& !flags.contains(OFlag::O_PATH)
{
return Err(Errno::EEXIST.into());
}
if target.via_link && flags.contains(OFlag::O_NOFOLLOW) {
return Err(Errno::ELOOP.into());
}
let procfs = target.procfs.into_rendered();
let path = procfs
.opened_path()
.expect("a file opened as rendered has a path");
let writes = flags & OFlag::O_ACCMODE != OFlag::O_RDONLY || flags.contains(OFlag::O_TRUNC);
let access = self
.rendered_file_access(guest, path, writes, CapabilitySet::Effective)
.await?;
let reopen = rendered_open_flags(flags, access)?;
if procfs.mount_table_rendering().is_some()
&& !flags.contains(OFlag::O_PATH)
&& let Some((answer, current)) = self.rendered_task_state(guest, path).await
&& (!current || answer.without_mm)
{
return Err(Errno::EINVAL.into());
}
let auxv = if procfs.is_process_auxv() && !flags.contains(OFlag::O_PATH) {
Some(Box::pin(self.open_process_auxv(guest, &procfs)).await?)
} else {
None
};
GuestProcfs::remember();
let metadata = self.rendered_metadata(guest, path).await?;
let snapshot = match auxv {
Some(bytes) => Some(bytes),
None if procfs.is_process_auxv() => None,
None => {
(!procfs.snapshot_at_first_read()).then(|| self.render_snapshot(guest, &procfs))
}
};
let carried: Vec<u8> = match &snapshot {
Some(snapshot) if !procfs.snapshot_is_rerendered() && !procfs.is_process_auxv() => {
snapshot.clone()
}
_ => Vec::new(),
};
let (fd, identity) = self
.inject_placeholder(guest, path, &carried, reopen)
.await?;
let registered = match &snapshot {
Some(snapshot) if procfs.is_process_auxv() => snapshot.clone(),
_ => carried,
};
guest.thread_state().add_fd(
fd,
reopen | (flags & OFlag::O_NOFOLLOW),
FdType::Regular,
Some(metadata),
)?;
let procfs = match snapshot {
Some(snapshot) => procfs.with_rendered_snapshot(snapshot),
None => procfs,
};
let handle = guest.thread_state().with_detfd(fd, |detfd| {
detfd.set_path(path);
detfd.set_procfs(procfs.clone());
detfd.open_file_handle()
})?;
register_placeholder_open(identity, handle, registered);
Ok(fd as i64)
}
async fn open_process_auxv<G: Guest<Self>>(
&self,
guest: &mut G,
procfs: &ProcfsFile,
) -> Result<Vec<u8>, Error> {
let task = procfs.bound_task().ok_or(Errno::ENOENT)?;
let target = detcore_model::pid::DetPid::from_raw(task.process);
let entry = crate::tool_global::process_auxv(guest, target)
.await
.ok_or(Errno::ESRCH)?;
if self.own_detpid(guest) != entry.process {
Self::ptrace_read_allowed(guest, task).await??;
}
Ok(entry.bytes)
}
pub(crate) async fn ptrace_read_allowed<G: Guest<Self>>(
guest: &mut G,
task: crate::procfs::BoundTask,
) -> Result<Result<(), Errno>, Error> {
let named = task.thread.unwrap_or(task.process);
let target = match Self::kernel_procfs_number(guest, named).await {
Some(kernel) => Self::probe(guest, format!("/proc/{kernel}/auxv").as_bytes()).await?,
None => Err(Errno::ESRCH),
};
if target.is_ok() {
return Ok(Ok(()));
}
let serves = Self::probe(guest, b"/proc/thread-self/stat").await?;
match auxv_access_answer(target, serves) {
AuxvAccess::Answer(answer) => Ok(answer),
AuxvAccess::CallerCapability => {
match Self::inject_capget(guest, CapabilitySet::Effective).await? {
Some(effective) if effective & (1 << CAP_SYS_PTRACE) != 0 => Ok(Ok(())),
Some(_) => Ok(Err(Errno::EACCES)),
None => Err(Self::scratch_failure(
guest,
reverie::syscalls::Sysno::openat,
"the caller's capabilities, which decide another process's \
/proc/<pid>/auxv where the kernel beneath serves no /proc, could \
not be read"
.to_string(),
)
.await),
}
}
}
}
async fn probe<G: Guest<Self>>(guest: &mut G, path: &[u8]) -> Result<Result<(), Errno>, Error> {
match Self::kernel_procfs_open_answer(guest, path).await {
Ok(answer) => Ok(answer),
Err(reason) => {
Err(Self::scratch_failure(guest, reverie::syscalls::Sysno::openat, reason).await)
}
}
}
pub(super) async fn kernel_procfs_open_answer<G: Guest<Self>>(
guest: &mut G,
path: &[u8],
) -> Result<Result<(), Errno>, String> {
const PATH_CAPACITY: usize = 32;
let (scratch, original, stack_guard) =
match Self::borrow_scratch::<G, PATH_CAPACITY>(guest).await? {
Some(borrowed) => borrowed,
None => {
return Err(format!(
"no guest stack scratch can hold the path of the access probe of {}",
String::from_utf8_lossy(path)
));
}
};
let probe = &mut *guest;
let answer: Result<Result<(), Errno>, String> = async move {
let guest = probe;
let bytes = c_string::<PATH_CAPACITY>(path);
if let Err(errno) = guest.memory().write_exact(scratch, &bytes) {
return Err(format!(
"the path of the access probe of {} could not be written to the guest \
stack scratch: {errno}",
String::from_utf8_lossy(path)
));
}
let opened = loop {
match guest
.inject(
syscalls::Openat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(PathPtr::from_ptr(scratch.as_raw() as *const libc::c_char))
.with_flags(OFlag::O_RDONLY | OFlag::O_CLOEXEC),
)
.await
{
Err(Errno::ERESTARTSYS) => continue,
opened => break opened,
}
};
let fd = match opened {
Ok(fd) => fd as RawFd,
Err(errno) => return Ok(Err(errno)),
};
loop {
match guest.inject(syscalls::Close::new().with_fd(fd)).await {
Ok(_) | Err(Errno::EINTR) => return Ok(Ok(())),
Err(Errno::ERESTARTSYS) => continue,
Err(errno) => {
return Err(format!(
"the descriptor {fd} of the access probe of {} could not be closed: \
{errno}",
String::from_utf8_lossy(path)
));
}
}
}
}
.await;
let restored = guest.memory().write_exact(scratch, &original);
drop(stack_guard);
if let Err(errno) = restored {
return Err(format!(
"the guest stack scratch under the access probe of {} could not be restored: \
{errno}",
String::from_utf8_lossy(path)
));
}
answer
}
fn render_snapshot<G: Guest<Self>>(&self, guest: &mut G, procfs: &ProcfsFile) -> Vec<u8> {
use rand::RngExt as _;
let mut file = procfs.clone();
let random_uuid = file
.needs_random_uuid()
.then(|| guest.thread_state_mut().thread_prng().random::<[u8; 16]>());
let virtual_pty_count = guest
.thread_state()
.count_open_files_at_paths(&[Path::new("/dev/ptmx"), Path::new("/dev/pts/ptmx")]);
let virtual_cpuinfo = file.is_cpuinfo().then(|| self.virtual_cpuid().cpuinfo());
let template = file.rendering_template().to_vec();
file.initialize(
template,
crate::procfs::ProcfsSnapshotContext {
random_uuid,
virtual_pty_count,
virtual_cpuinfo,
machine: crate::machine::MachineDescription::of(guest.config()),
..Default::default()
},
);
file.rendered_snapshot()
.expect("a rendered file has its snapshot once initialized")
.to_vec()
}
pub(super) async fn first_read_uptime<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
path: &'static Path,
uptime_seconds: u64,
) -> u64 {
let stable = descriptor_stable_across_injections(
guest.config().sequentialize_threads,
guest.config().backend.runs_guest_code_between_injections,
);
if !stable {
return uptime_seconds;
}
let Ok(stat) = self.inject_fstat(guest, fd).await else {
return uptime_seconds;
};
if !may_carry_uptime(stable, placeholder_identity(stat.st_dev, stat.st_ino), path) {
return uptime_seconds;
}
if let Some(carried) = carried_uptime(stat.st_mtime, stat.st_mtime_nsec) {
return carried;
}
let times = [
Timespec {
tv_sec: 0,
tv_nsec: libc::UTIME_OMIT,
},
carried_uptime_mtime(uptime_seconds),
];
if let Err(errno) = Self::inject_futimens(guest, fd, times).await {
warn!(
"The first read of {} on fd {fd} could not carry its uptime on the \
placeholder ({errno}); a process without Detcore's state of the open \
file takes its own snapshot.",
path.display()
);
}
uptime_seconds
}
async fn inject_futimens<G: Guest<Self>>(
guest: &mut G,
fd: RawFd,
times: [Timespec; 2],
) -> Result<(), Errno> {
let call = |times| {
syscalls::Utimensat::new()
.with_dirfd(fd)
.with_path(None)
.with_times(Some(times))
.with_flags(0)
};
let mut stack = guest.stack().await;
let staged = stack.push(times);
if let Ok(stack_guard) = stack.commit() {
let result = guest.inject(call(staged)).await;
drop(stack_guard);
if result != Err(Errno::EFAULT) {
return result.map(drop);
}
}
let len = std::mem::size_of::<[Timespec; 2]>();
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).map_err(|_| Errno::EFAULT)?;
let staged = Addr::<[Timespec; 2]>::from_raw(page).ok_or(Errno::EFAULT)?;
let written = AddrMut::<[Timespec; 2]>::from_raw(page)
.ok_or(Errno::EFAULT)
.and_then(|address| guest.memory().write_value(address, ×));
let result = match written {
Ok(()) => guest.inject(call(staged)).await.map(drop),
Err(errno) => Err(errno),
};
let _ = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(staged.cast()))
.with_len(len),
))
.await;
result
}
async fn inject_placeholder<G: Guest<Self>>(
&self,
guest: &mut G,
path: &'static Path,
snapshot: &[u8],
flags: OFlag,
) -> Result<(RawFd, (u64, u64)), Error> {
let name = placeholder_name(path, snapshot);
let mut stack = guest.stack().await;
let name = stack.push(c_string::<PLACEHOLDER_NAME_CAPACITY>(name.as_bytes()));
let link = stack.reserve::<[u8; 32]>();
let stack_guard = stack.commit()?;
let name = name.as_raw();
let create = move |flags| {
syscalls::MemfdCreate::new()
.with_name(PathPtr::from_ptr(name as *const libc::c_char))
.with_flags(flags)
};
let sealable = libc::MFD_CLOEXEC | libc::MFD_ALLOW_SEALING;
let memfd = match guest.inject(create(sealable | libc::MFD_NOEXEC_SEAL)).await {
Err(Errno::EINVAL) => guest.inject(create(sealable)).await?,
created => created?,
} as RawFd;
let _ = guest
.inject(
syscalls::Fcntl::new()
.with_fd(memfd)
.with_cmd(syscalls::FcntlCmd::F_ADD_SEALS(PLACEHOLDER_SEALS)),
)
.await;
guest.memory().write_exact(
link.cast::<u8>(),
&c_string::<32>(format!("/proc/thread-self/fd/{memfd}").as_bytes()),
)?;
let reopened = guest
.inject(
syscalls::Openat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(PathPtr::from_ptr(link.as_raw() as *const libc::c_char))
.with_flags(flags | OFlag::O_CLOEXEC),
)
.await;
let moved = match reopened {
Ok(reopened) => {
let moved = guest
.inject(
syscalls::Dup3::new()
.with_oldfd(reopened as i32)
.with_newfd(memfd)
.with_flags(flags & OFlag::O_CLOEXEC),
)
.await;
let _ = guest
.inject(syscalls::Close::new().with_fd(reopened as i32))
.await;
moved
}
Err(errno) => Err(errno),
};
drop(stack_guard);
if let Err(errno) = moved {
let _ = guest.inject(syscalls::Close::new().with_fd(memfd)).await;
return Err(errno.into());
}
let identity = match self.inject_fstat(guest, memfd).await {
Ok(stat) => stat,
Err(errno) => {
let _ = guest.inject(syscalls::Close::new().with_fd(memfd)).await;
return Err(errno.into());
}
};
register_placeholder(identity.st_dev, identity.st_ino, path);
Ok((memfd, (identity.st_dev, identity.st_ino)))
}
pub(super) async fn rendered_listed_inode<G: Guest<Self>>(
&self,
guest: &mut G,
inodes: &procfs_inode::DirectoryInodes,
name: &[u8],
host_ino: u64,
files: RenderedFiles,
) -> Result<Option<u64>, Error> {
if self.cfg.recordreplay_modes {
return Ok(None);
}
if let Some(path) = inodes.entry_procfs_path(name)
&& let Some(mut file) = ProcfsFile::from_path(&path)
&& file.per_process_name().is_some()
{
if !self.renders_procfs(guest) {
return Ok(None);
}
let Some(task) = file.bound_task() else {
return Ok(None);
};
let answer = crate::tool_global::procfs_task(guest, task).await;
if !answer.exists {
return Ok(None);
}
let without_mm = answer.without_mm;
self.bind_task_identity(guest, &mut file, answer).await?;
if Self::auxv_kept_by_kernel(guest, &file, without_mm).await {
return Ok(None);
}
return Ok(file.rendered_path(files).map(procfs_inode::rendered_inode));
}
Ok(inodes.rendered_entry_inode(name, files).or_else(|| {
let named = rendered_paths(files).filter(|path| rendered_name(path) == name);
rendered_path_among(inodes.device(), host_ino, named).map(procfs_inode::rendered_inode)
}))
}
async fn auxv_kept_by_kernel<G: Guest<Self>>(
guest: &mut G,
file: &ProcfsFile,
without_mm: bool,
) -> bool {
let Some(task) = file
.bound_task()
.filter(|_| file.is_process_auxv() && !without_mm)
else {
return false;
};
crate::tool_global::process_auxv(guest, detcore_model::pid::DetPid::from_raw(task.process))
.await
.is_none()
}
pub(super) async fn bind_task_identity<G: Guest<Self>>(
&self,
guest: &mut G,
file: &mut ProcfsFile,
answer: crate::procfs::listing::ProcfsTaskAnswer,
) -> Result<(), Error> {
let incarnation = answer.incarnation();
if procfs_inode::incarnation_fits(incarnation) {
file.set_task_incarnation(incarnation);
return Ok(());
}
let task = file.bound_task();
let reason = format!(
"the per-process /proc file of task {task:?} would belong to its numbers' \
incarnation {incarnation:?}, beyond the {} task generations an inode number \
of such a file tells apart (procfs_inode::MAX_INCARNATION)",
procfs_inode::MAX_INCARNATION
);
let sysno = reverie::syscalls::Sysno::new(guest.regs().await.orig_rax as usize)
.unwrap_or(reverie::syscalls::Sysno::openat);
error!("Detcore refuses {sysno}: {reason}");
crate::syscalls::helpers::refuse_unserviceable_operation_with(
guest,
self.cfg.panic_on_unsupported_syscalls,
sysno,
Errno::EOVERFLOW,
Some(&reason),
)
.await
.map(|_| ())
}
pub(super) async fn adopt_rendered_procfs_position<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<(), Error> {
if !self.cfg.backend.tool_shares_guest_descriptor_table {
return Ok(());
}
let kept = guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_keeps_kernel_position())
.unwrap_or(false);
if !kept {
return Ok(());
}
if let Ok(offset) = guest
.inject(
syscalls::Lseek::new()
.with_fd(fd)
.with_offset(0)
.with_whence(syscalls::Whence::SEEK_CUR),
)
.await
{
guest
.thread_state()
.with_detfd(fd, |detfd| detfd.set_procfs_offset(offset as usize))?;
}
Ok(())
}
pub(super) async fn sync_rendered_procfs_position<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> Result<(), Error> {
let (offset, placeholder) = guest.thread_state().with_detfd(fd, |detfd| {
let offset = detfd
.procfs_keeps_kernel_position()
.then(|| detfd.procfs_position().map(|(offset, _)| offset))
.flatten();
(offset, detfd.procfs_rendered_path().is_some())
})?;
if let Some(offset) = offset {
let moved = guest
.inject(
syscalls::Lseek::new()
.with_fd(fd)
.with_offset(offset as libc::off_t)
.with_whence(syscalls::Whence::SEEK_SET),
)
.await;
if placeholder {
moved?;
}
}
Ok(())
}
pub(super) async fn rendered_procfs_stat<G: Guest<Self>>(
&self,
guest: &mut G,
target: StatTarget<'_>,
) -> Result<Option<DetStat>, Error> {
let path = match target {
StatTarget::Descriptor(fd) => {
match guest
.thread_state()
.with_detfd(fd, |detfd| detfd.procfs_rendered_path())
.ok()
.flatten()
{
Some(path) => Some(path),
None if !guest.config().virtualize_metadata => {
self.placeholder_descriptor(guest, fd).await
}
None => None,
}
}
StatTarget::Path {
dirfd,
path: Some(pointer),
follow,
} => {
let path = pointer.read(&guest.memory())?;
if path.as_os_str().is_empty() {
return Ok(None);
}
let observed = self.procfs_spelling_at(guest, dirfd, &path).await?;
match self.rendered_procfs_at(guest, &observed).await? {
Some(target) if follow || !target.via_link => {
target.procfs.rendered_path(self.rendered_files(guest))
}
Some(_) => None,
None if !guest.config().virtualize_metadata => {
self.placeholder_reached(guest, dirfd, Some(pointer), follow)
.await
}
None => None,
}
}
StatTarget::Path { path: None, .. } | StatTarget::Cwd | StatTarget::Overwritten => None,
};
let Some(path) = path else {
return Ok(None);
};
Ok(Some(self.rendered_metadata(guest, path).await?))
}
pub(super) fn write_procfs_statfs<G: Guest<Self>>(
&self,
guest: &mut G,
buffer: Option<AddrMut<'_, libc::statfs>>,
) -> Result<(), Error> {
let (statfs, _) = GuestProcfs::statfs()?;
let buffer = buffer.ok_or(Errno::EFAULT)?;
guest.memory().write_value(buffer, &statfs)?;
self.canonicalize_statfs_buf(guest, Some(buffer))
}
pub(crate) async fn readlink_rendered_procfs<G: Guest<Self>>(
&self,
guest: &mut G,
path: &Path,
buffer: Option<AddrMut<'_, libc::c_char>>,
buffer_len: usize,
) -> Result<Option<i64>, Error> {
let Some(target) = self.rendered_procfs_at(guest, path).await? else {
return Ok(None);
};
let size = crate::syscalls::namespace::readlink_size(buffer_len)?;
if !target.via_link {
return Err(Errno::EINVAL.into());
}
let Some(link) = target.procfs.opened_path() else {
return Ok(None);
};
write_link(&mut guest.memory(), link, buffer, size).map(Some)
}
pub(crate) async fn rewrite_placeholder_link<G: Guest<Self>>(
&self,
guest: &mut G,
link: (RawFd, Option<PathPtr<'_>>),
buffer: Option<AddrMut<'_, libc::c_char>>,
buffer_len: usize,
result: i64,
saved: Option<&[u8]>,
) -> Result<i64, Error> {
let (Some(address), Ok(length)) = (buffer, usize::try_from(result)) else {
return Ok(result);
};
if self.cfg.recordreplay_modes
|| length == 0
|| (!placeholders_exist() && !self.cfg.backend.tool_shares_guest_descriptor_table)
{
return Ok(result);
}
let mut bytes = vec![0; length.min(buffer_len)];
guest
.memory()
.read_exact(address.cast::<u8>(), &mut bytes)?;
match placeholder_link_path(&bytes, self.rendered_files(guest)) {
Some(path) if self.placeholder_link_confirmed(guest, link).await => {
let written = write_link(&mut guest.memory(), path, buffer, buffer_len)?;
crate::syscalls::namespace::restore_link_tail(
guest,
address,
written as usize,
bytes.len(),
saved,
)?;
Ok(written)
}
_ => Ok(result),
}
}
fn clone_ioctl_answer<G: Guest<Self>>(guest: &mut G, source: RawFd) -> Result<i64, Errno> {
let on_procfs = guest
.thread_state()
.with_detfd(source, |detfd| {
detfd.procfs_rendered_path().is_some()
|| detfd.path().is_some_and(|path| path.starts_with("/proc"))
})
.map_err(|_| Errno::EBADF)?;
Err(if on_procfs {
Errno::EBADF
} else {
Errno::EXDEV
})
}
pub(crate) async fn placeholder_link_confirmed<G: Guest<Self>>(
&self,
guest: &mut G,
link: (RawFd, Option<PathPtr<'_>>),
) -> bool {
if self.cfg.backend.tool_shares_guest_descriptor_table {
return true;
}
let (dirfd, Some(path)) = link else {
return false;
};
match Self::inject_statat(guest, dirfd, path, [Some(path), None], AtFlags::empty()).await {
Ok(stat) => placeholder_identity(stat.st_dev, stat.st_ino).is_some(),
Err(_) => false,
}
}
pub(crate) async fn answer_rendered_procfs_mapping<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) -> Option<Result<i64, Error>> {
let Syscall::Mmap(c) = call else {
return None;
};
if c.flags().contains(MapFlags::MAP_ANONYMOUS) {
return None;
}
let (path, status_flags) = guest
.thread_state()
.with_detfd(c.fd(), |detfd| {
(detfd.status_flags() & libc::O_PATH == 0)
.then(|| detfd.procfs_rendered_path())
.flatten()
.map(|path| (path, detfd.status_flags()))
})
.ok()
.flatten()?;
let seq_file = crate::procfs::rendered_path_is_seq_file(path)
&& !crate::procfs::rendered_path_is_per_process(path);
let access_mode = status_flags & libc::O_ACCMODE;
let mode = (
access_mode == libc::O_RDONLY || access_mode == libc::O_RDWR,
access_mode == libc::O_WRONLY || access_mode == libc::O_RDWR,
);
let noexec = match GuestProcfs::statfs() {
Ok((_, flags)) => flags & libc::ST_NOEXEC != 0,
Err(errno) => return Some(Err(errno.into())),
};
let addr = c.addr().map_or(0, |addr| addr.as_raw());
let flags = c.flags();
let len = match rendered_mmap_address_checks(addr, c.len(), c.offset(), flags) {
Ok(len) => len,
Err(errno) => return Some(Err(errno.into())),
};
let sequentialized = guest.config().sequentialize_threads;
if sequentialized && flags.contains(MapFlags::MAP_FIXED_NOREPLACE) {
let probe = guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(c.addr())
.with_len(len)
.with_prot(ProtFlags::PROT_NONE)
.with_flags(
MapFlags::MAP_PRIVATE
| MapFlags::MAP_ANONYMOUS
| MapFlags::MAP_FIXED_NOREPLACE,
)
.with_fd(-1)
.with_offset(0),
))
.await;
match probe {
Err(errno @ (Errno::EEXIST | Errno::EPERM)) => return Some(Err(errno.into())),
Err(_) => {}
Ok(placed) => {
let placed_addr = Addr::<libc::c_void>::from_raw(placed as usize);
if let Err(errno) = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new().with_addr(placed_addr).with_len(len),
))
.await
{
return Some(Err(errno.into()));
}
if placed as usize != addr {
return Some(Err(Errno::EEXIST.into()));
}
}
}
}
let errno =
rendered_mmap_file_checks(len, c.offset(), c.prot(), flags, noexec, seq_file, mode);
let unmaps = sequentialized
&& errno == Errno::EIO
&& flags.contains(MapFlags::MAP_FIXED)
&& !flags.contains(MapFlags::MAP_FIXED_NOREPLACE);
if unmaps
&& let Err(unmapped) = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new().with_addr(c.addr()).with_len(len),
))
.await
{
return Some(Err(unmapped.into()));
}
if unmaps {
guest.thread_state().unmap_memory(addr, len);
}
Some(Err(errno.into()))
}
async fn answer_rendered_procfs_write<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
args: &reverie::syscalls::SyscallArgs,
) -> Option<Result<i64, Errno>> {
let fd = match sysno {
Sysno::write | Sysno::writev | Sysno::ftruncate | Sysno::fallocate => args.arg0,
Sysno::pwritev2 if args.arg3 as i64 == -1 => args.arg0,
Sysno::sendfile => args.arg0,
Sysno::splice => args.arg2,
_ => return None,
} as RawFd;
let status = guest
.thread_state()
.with_detfd(fd, |detfd| {
(detfd.procfs_rendered_path().is_some() && detfd.status_flags() & libc::O_PATH == 0)
.then(|| detfd.status_flags())
})
.ok()
.flatten();
let writable = match status.map(|status| status & libc::O_ACCMODE) {
None | Some(libc::O_RDONLY) => return None,
Some(mode) => mode == libc::O_WRONLY || mode == libc::O_RDWR,
};
if matches!(sysno, Sysno::sendfile | Sysno::splice) {
let kernel = guest
.inject(
syscalls::Fcntl::new()
.with_fd(fd)
.with_cmd(syscalls::FcntlCmd::F_GETFL),
)
.await
.ok()
.map(|status| status as i32);
let appends = kernel
.or(status)
.is_some_and(|status| status & libc::O_APPEND != 0);
return Some(
self.answer_rendered_procfs_transfer(guest, sysno, args, writable, appends)
.await,
);
}
if !writable {
return Some(match sysno {
Sysno::ftruncate => Err(Errno::EINVAL),
_ => Err(Errno::EBADF),
});
}
Some(match sysno {
Sysno::ftruncate if (args.arg1 as i64) < 0 => Err(Errno::EINVAL),
Sysno::ftruncate => Ok(0),
Sysno::fallocate if (args.arg2 as i64) < 0 || (args.arg3 as i64) <= 0 => {
Err(Errno::EINVAL)
}
Sysno::fallocate => Err(Errno::EOPNOTSUPP),
_ => Err(Errno::EINVAL),
})
}
async fn answer_rendered_procfs_transfer<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
args: &reverie::syscalls::SyscallArgs,
writable: bool,
appends: bool,
) -> Result<i64, Errno> {
const SPLICE_F_ALL: usize = 0xf;
fn offset_at<M: MemoryAccess>(memory: &M, address: usize) -> Result<i64, Errno> {
let address = reverie::syscalls::Addr::<i64>::from_raw(address).ok_or(Errno::EFAULT)?;
memory.read_value(address).map_err(|_| Errno::EFAULT)
}
let (source, length) = match sysno {
Sysno::sendfile => (args.arg1 as RawFd, args.arg3),
_ => (args.arg0 as RawFd, args.arg4),
};
if sysno == Sysno::splice {
if length == 0 {
return Ok(0);
}
if args.arg5 & !SPLICE_F_ALL != 0 {
return Err(Errno::EINVAL);
}
}
let offset = if sysno == Sysno::sendfile && args.arg2 != 0 {
Some(offset_at(&guest.memory(), args.arg2)?)
} else {
None
};
let source_status = guest
.inject(
syscalls::Fcntl::new()
.with_fd(source)
.with_cmd(syscalls::FcntlCmd::F_GETFL),
)
.await
.map_err(|_| Errno::EBADF)? as i32;
if source_status & libc::O_PATH != 0 {
return Err(Errno::EBADF);
}
let source_reads = matches!(
source_status & libc::O_ACCMODE,
libc::O_RDONLY | libc::O_RDWR
);
let source_type =
|stat: Result<libc::stat, Errno>| stat.map_or(0, |stat| stat.st_mode & libc::S_IFMT);
if sysno == Sysno::sendfile {
if !source_reads {
return Err(Errno::EBADF);
}
if let Some(offset) = offset {
let kind = source_type(self.inject_fstat(guest, source).await);
if matches!(kind, libc::S_IFIFO | libc::S_IFSOCK) {
return Err(Errno::ESPIPE);
}
if offset < 0 {
return Err(Errno::EINVAL);
}
}
if !writable {
return Err(Errno::EBADF);
}
if appends {
return Err(Errno::EINVAL);
}
return if length == 0 {
Ok(0)
} else {
Err(Errno::EINVAL)
};
}
let (off_in, off_out) = (args.arg1, args.arg3);
if off_in != 0 && source_type(self.inject_fstat(guest, source).await) == libc::S_IFIFO {
return Err(Errno::ESPIPE);
}
if off_in != 0 {
offset_at(&guest.memory(), off_in)?;
}
if off_out != 0 {
offset_at(&guest.memory(), off_out)?;
}
if !source_reads || !writable {
return Err(Errno::EBADF);
}
Err(Errno::EINVAL)
}
pub(crate) async fn record_process_auxv<G: Guest<Self>>(&self, guest: &mut G) {
use crate::tool_global::AuxvFromKernel;
let found = match guest.initial_stack_pointer() {
Some(stack) => {
let memory = guest.memory();
crate::procfs::initial_stack_auxv(stack, |at| {
let address =
reverie::syscalls::Addr::<u64>::from_raw(usize::try_from(at).ok()?)?;
memory.read_value(address).ok()
})
.ok_or(AuxvFromKernel::Implausible)
}
None => Err(AuxvFromKernel::NoInitialStackPointer),
};
let bytes = match found {
Ok(bytes) => bytes,
Err(why) => {
if crate::tool_global::auxv_from_kernel(guest, why).await {
match why {
AuxvFromKernel::NoInitialStackPointer => warn!(
"auxv: backend gives no initial stack pointer; guest auxv is the \
kernel beneath's"
),
AuxvFromKernel::Implausible => warn!(
"auxv: the initial stack did not hold a plausible auxiliary vector; \
guest auxv is the kernel beneath's"
),
}
}
return;
}
};
crate::tool_global::record_process_auxv(guest, bytes).await;
}
pub(crate) async fn adopt_received_placeholders<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) -> Result<(), Error> {
if !placeholders_exist() || !self.renders_procfs(guest) {
return Ok(());
}
let (sysno, args) = call.into_parts();
for fd in descriptor_arguments(&guest.memory(), sysno, &args) {
if fd < 0 || guest.thread_state().with_detfd(fd, |_| ()).is_ok() {
continue;
}
info!(
"Descriptor {fd}, which Detcore has no record of, is checked for a rendered \
procfs placeholder."
);
let Ok(stat) = self.inject_fstat(guest, fd).await else {
continue;
};
let may_be_placeholder = stat.st_mode & libc::S_IFMT == libc::S_IFREG
&& stat.st_nlink == 0
&& stat.st_size == 0;
if !may_be_placeholder {
continue;
}
let identity = (stat.st_dev, stat.st_ino);
let Some(path) = placeholder_identity(identity.0, identity.1) else {
continue;
};
if !guest.config().sequentialize_threads {
let reason = format!(
"descriptor {fd}, a rendered procfs file Detcore has no record of \
(received over SCM_RIGHTS), cannot be adopted without sequentialized \
threads (--no-sequentialize-threads)"
);
error!("Detcore refuses {sysno}: {reason}");
return crate::syscalls::helpers::refuse_unserviceable_operation_with(
guest,
self.cfg.panic_on_unsupported_syscalls,
sysno,
Errno::EOPNOTSUPP,
Some(&reason),
)
.await
.map(|_| ());
}
self.adopt_received_placeholder(guest, fd, path, identity)
.await?;
}
Ok(())
}
async fn adopt_received_placeholder<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
path: &'static Path,
identity: (u64, u64),
) -> Result<(), Error> {
let descriptor_flags = guest
.inject(
syscalls::Fcntl::new()
.with_fd(fd)
.with_cmd(syscalls::FcntlCmd::F_GETFD),
)
.await?;
let cloexec = descriptor_flags & i64::from(libc::FD_CLOEXEC) != 0;
let registered = placeholder_open(identity);
if let Some(alias) = registered
.as_ref()
.and_then(|(description, _)| description.descriptor(fd, cloexec))
{
guest.thread_state().install_alias(alias);
return Ok(());
}
let status = guest
.inject(
syscalls::Fcntl::new()
.with_fd(fd)
.with_cmd(syscalls::FcntlCmd::F_GETFL),
)
.await? as i32;
let offset = guest
.inject(
syscalls::Lseek::new()
.with_fd(fd)
.with_offset(0)
.with_whence(syscalls::Whence::SEEK_CUR),
)
.await
.map_or(0, |offset| offset as usize);
let snapshot = registered.map(|(_, snapshot)| snapshot).unwrap_or_default();
let metadata = self.rendered_metadata(guest, path).await?;
let mut flags = OFlag::from_bits_truncate(status);
flags.set(OFlag::O_CLOEXEC, cloexec);
guest
.thread_state()
.add_fd(fd, flags, FdType::Regular, Some(metadata))?;
let procfs = ProcfsFile::from_rendered_path(path)
.expect("a placeholder's path is a rendered procfs file")
.into_rendered();
let procfs = if snapshot.is_empty() {
procfs
} else {
procfs.with_rendered_snapshot(snapshot.clone())
};
let handle = guest.thread_state().with_detfd(fd, |detfd| {
detfd.set_path(path);
detfd.set_procfs(procfs.clone());
detfd.set_procfs_offset(offset);
detfd.open_file_handle()
})?;
register_placeholder_open(identity, handle, snapshot);
Ok(())
}
pub(crate) async fn answer_rendered_procfs_operation<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) -> Option<Result<i64, Error>> {
let (sysno, args) = call.into_parts();
if let Some(answer) = self.answer_rendered_procfs_write(guest, sysno, &args).await {
return Some(answer.map_err(Error::from));
}
let fd = match sysno {
Sysno::pwrite64
| Sysno::pwritev
| Sysno::pwritev2
| Sysno::fsync
| Sysno::fdatasync
| Sysno::fchmod
| Sysno::fgetxattr
| Sysno::flistxattr
| Sysno::fsetxattr
| Sysno::fremovexattr
| Sysno::ioctl
| Sysno::fcntl => args.arg0 as i32,
_ => return None,
};
let (path, status_flags) = guest
.thread_state()
.with_detfd(fd, |detfd| {
detfd
.procfs_rendered_path()
.map(|path| (path, detfd.status_flags()))
})
.ok()
.flatten()?;
if status_flags & libc::O_PATH != 0 {
return None;
}
let seq_file = crate::procfs::rendered_path_is_seq_file(path);
let writable = matches!(
status_flags & libc::O_ACCMODE,
libc::O_WRONLY | libc::O_RDWR
);
let per_process = crate::procfs::rendered_path_is_per_process(path);
let command = args.arg1 as libc::c_int;
let needs_access = matches!(sysno, Sysno::fsetxattr | Sysno::fremovexattr)
|| (sysno == Sysno::fcntl
&& (matches!(command, libc::F_SETLEASE | 1036)
|| (command == libc::F_SETFL
&& args.arg2 as libc::c_int & libc::O_NOATIME != 0)));
let access = if needs_access {
match self
.rendered_file_access(
guest,
path,
matches!(sysno, Sysno::fsetxattr | Sysno::fremovexattr),
CapabilitySet::Effective,
)
.await
{
Ok(access) => access,
Err(error) => return Some(Err(error)),
}
} else {
FileAccess::GLOBAL_ROOT
};
let answer = match call {
Syscall::Pwrite64(_) | Syscall::Pwritev(_) | Syscall::Pwritev2(_)
if !seq_file && per_process =>
{
let position = args.arg3 as i64;
if sysno == Sysno::pwritev2 && position == -1 {
Err(Errno::EBADF)
} else if position < 0 || writable {
Err(Errno::EINVAL)
} else {
Err(Errno::EBADF)
}
}
Syscall::Pwrite64(_) | Syscall::Pwritev(_) | Syscall::Pwritev2(_) if !seq_file => {
return None;
}
Syscall::Pwrite64(_) | Syscall::Pwritev(_) | Syscall::Pwritev2(_) => {
return rendered_seq_file_pwrite_answer(sysno, args.arg3 as i64)
.map(|answer| answer.map_err(Error::from));
}
Syscall::Fsync(_) | Syscall::Fdatasync(_) => Err(Errno::EINVAL),
Syscall::Fchmod(_) => Err(Errno::EPERM),
Syscall::Fgetxattr(c) => match c.name().map(|name| name.read(&guest.memory())) {
Some(Ok(name)) => xattr_get_answer(name.as_bytes(), true),
Some(Err(errno)) => Err(errno),
None => Err(Errno::EFAULT),
},
Syscall::Flistxattr(_) => Ok(0),
Syscall::Fsetxattr(c)
if c.flags() & !(libc::XATTR_CREATE | libc::XATTR_REPLACE) != 0 =>
{
Err(Errno::EINVAL)
}
Syscall::Fsetxattr(c) => match c.name().map(|name| name.read(&guest.memory())) {
Some(Ok(name)) => xattr_change_answer(
name.as_bytes(),
Some(c.size()),
read_value(&guest.memory(), args.arg2 as u64, c.size()).as_deref(),
access,
),
Some(Err(errno)) => Err(errno),
None => Err(Errno::EFAULT),
},
Syscall::Fremovexattr(c) => match c.name().map(|name| name.read(&guest.memory())) {
Some(Ok(name)) => xattr_change_answer(name.as_bytes(), None, None, access),
Some(Err(errno)) => Err(errno),
None => Err(Errno::EFAULT),
},
Syscall::Ioctl(_) => match args.arg1 as u32 as usize {
1 | 0xc004_5877 | 0xc004_5878 => Err(Errno::EPERM),
0xc020_660b => Err(Errno::EOPNOTSUPP),
0x4004_9409 => Self::clone_ioctl_answer(guest, args.arg2 as i32),
0x4020_940d => {
match reverie::syscalls::Addr::<[u64; 4]>::from_raw(args.arg2)
.map(|address| guest.memory().read_value(address))
{
Some(Ok(range)) => Self::clone_ioctl_answer(guest, range[0] as i32),
_ => Err(Errno::EFAULT),
}
}
0x5450..=0x5452 | 0x5421 => return None,
0x541b if self.cfg.backend.tool_shares_guest_descriptor_table => return None,
0x541b => match AddrMut::<libc::c_int>::from_raw(args.arg2) {
Some(address) => {
let position = guest
.thread_state()
.with_detfd(args.arg0 as RawFd, |detfd| {
detfd.procfs_position().map_or(0, |(offset, _)| offset)
})
.unwrap_or(0);
let unread = 0_i64.wrapping_sub(position as i64) as libc::c_int;
guest.memory().write_value(address, &unread).map(|()| 0)
}
None => Err(Errno::EFAULT),
},
0x5460 => match AddrMut::<libc::loff_t>::from_raw(args.arg2) {
Some(address) => guest.memory().write_value(address, &0).map(|()| 0),
None => Err(Errno::EFAULT),
},
2 => match AddrMut::<libc::c_int>::from_raw(args.arg2) {
Some(address) => guest
.memory()
.write_value(address, &(procfs_inode::PROC_BLOCK_SIZE as libc::c_int))
.map(|()| 0),
None => Err(Errno::EFAULT),
},
_ => Err(Errno::ENOTTY),
},
Syscall::Fcntl(_) => match args.arg1 as libc::c_int {
libc::F_ADD_SEALS if !writable => Err(Errno::EPERM),
libc::F_ADD_SEALS | libc::F_GET_SEALS => Err(Errno::EINVAL),
libc::F_SETLEASE if access.owner => Err(Errno::EINVAL),
libc::F_SETLEASE => Err(Errno::EACCES),
1036 if access.owner => {
match Addr::<u64>::from_raw(args.arg2)
.map(|hint| guest.memory().read_value(hint))
{
Some(Ok(hint)) if hint <= 5 => {
crate::tool_global::rendered_file_state(
guest,
procfs_inode::rendered_inode(path),
crate::procfs::listing::RenderedFileChange::WriteHint(hint),
)
.await;
Ok(0)
}
Some(Ok(_)) => Err(Errno::EINVAL),
_ => Err(Errno::EFAULT),
}
}
1036 => Err(Errno::EPERM),
1035 if per_process => {
let state = crate::tool_global::rendered_file_state(
guest,
procfs_inode::rendered_inode(path),
crate::procfs::listing::RenderedFileChange::Read,
)
.await;
match AddrMut::<u64>::from_raw(args.arg2) {
Some(address) => guest
.memory()
.write_value(address, &state.write_hint)
.map(|()| 0),
None => Err(Errno::EFAULT),
}
}
libc::F_GETLEASE => Ok(i64::from(libc::F_UNLCK)),
libc::F_SETFL
if args.arg2 as libc::c_int & libc::O_NOATIME != 0 && !access.owner =>
{
Err(Errno::EPERM)
}
libc::F_SETFL if args.arg2 as libc::c_int & libc::O_DIRECT != 0 => {
Err(Errno::EINVAL)
}
_ => return None,
},
_ => return None,
};
Some(answer.map_err(Into::into))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum PathRequest {
Access {
mode: u64,
flags: u64,
},
GetXattr,
ListXattr,
ChangeXattr {
size: Option<usize>,
value: u64,
flags: u64,
},
Chmod {
flags: u64,
},
Truncate {
length: i64,
},
Times {
explicit: Option<bool>,
},
Chdir,
Invalid,
Fault,
}
fn path_request_answer(
request: PathRequest,
name: Option<&[u8]>,
value: Option<&[u8]>,
access: FileAccess,
) -> Result<i64, Errno> {
match request {
PathRequest::Access { mode, flags } => {
if access_arguments_invalid(mode, flags) {
Err(Errno::EINVAL)
} else if mode & libc::X_OK as u64 != 0
|| (mode & libc::W_OK as u64 != 0 && !access.may_write())
|| (mode & libc::R_OK as u64 != 0 && !access.readable)
{
Err(Errno::EACCES)
} else {
Ok(0)
}
}
PathRequest::GetXattr => xattr_get_answer(name.ok_or(Errno::EFAULT)?, access.readable),
PathRequest::ListXattr => Ok(0),
PathRequest::ChangeXattr { size, flags, .. } => {
if flags & !(libc::XATTR_CREATE | libc::XATTR_REPLACE) as u64 != 0 {
return Err(Errno::EINVAL);
}
xattr_change_answer(name.ok_or(Errno::EFAULT)?, size, value, access)
}
PathRequest::Chmod { flags } => {
if flags & !(libc::AT_SYMLINK_NOFOLLOW | libc::AT_EMPTY_PATH) as u64 != 0 {
Err(Errno::EINVAL)
} else {
Err(Errno::EPERM)
}
}
PathRequest::Truncate { length } if length < 0 => Err(Errno::EINVAL),
PathRequest::Truncate { .. } if access.may_write() => Ok(0),
PathRequest::Truncate { .. } => Err(Errno::EACCES),
PathRequest::Times { explicit: None } if access.owner || access.may_write() => Ok(0),
PathRequest::Times { explicit: None } => Err(Errno::EACCES),
PathRequest::Times {
explicit: Some(false),
} => Ok(0),
PathRequest::Times {
explicit: Some(true),
} if access.owner => Ok(0),
PathRequest::Times {
explicit: Some(true),
} => Err(Errno::EPERM),
PathRequest::Chdir => Err(Errno::ENOTDIR),
PathRequest::Invalid => Err(Errno::EINVAL),
PathRequest::Fault => Err(Errno::EFAULT),
}
}
fn utimens_request(times: Option<[libc::timespec; 2]>) -> Option<bool> {
let times = times?;
if times.iter().all(|time| time.tv_nsec == libc::UTIME_OMIT) {
Some(false)
} else if times.iter().all(|time| time.tv_nsec == libc::UTIME_NOW) {
None
} else {
Some(true)
}
}
fn access_arguments_invalid(mode: u64, flags: u64) -> bool {
flags & !(libc::AT_EACCESS | libc::AT_SYMLINK_NOFOLLOW | libc::AT_EMPTY_PATH) as u64 != 0
|| mode & !7 != 0
}
impl<T: RecordOrReplay> Detcore<T> {
pub(crate) async fn answer_rendered_procfs_path_call<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) -> Result<Option<i64>, Error> {
if self.cfg.recordreplay_modes {
return Ok(None);
}
let (sysno, args) = call.into_parts();
let [a0, a1, a2, a3, a4] =
[args.arg0, args.arg1, args.arg2, args.arg3, args.arg4].map(|arg| arg as u64);
let at = libc::AT_FDCWD as u64;
let mut decided_before_descriptor = false;
let (dirfd, path, flags, request, name) = match sysno {
Sysno::access => (
at,
a0,
0,
PathRequest::Access {
mode: u64::from(a1 as u32),
flags: 0,
},
0,
),
Sysno::faccessat => (
a0,
a1,
0,
PathRequest::Access {
mode: u64::from(a2 as u32),
flags: 0,
},
0,
),
Sysno::faccessat2 => (
a0,
a1,
u64::from(a3 as u32),
PathRequest::Access {
mode: u64::from(a2 as u32),
flags: u64::from(a3 as u32),
},
0,
),
Sysno::getxattr => (at, a0, 0, PathRequest::GetXattr, a1),
Sysno::lgetxattr => (at, a0, nofollow(), PathRequest::GetXattr, a1),
Sysno::listxattr => (at, a0, 0, PathRequest::ListXattr, 0),
Sysno::llistxattr => (at, a0, nofollow(), PathRequest::ListXattr, 0),
Sysno::setxattr | Sysno::lsetxattr => (
at,
a0,
if sysno == Sysno::lsetxattr {
nofollow()
} else {
0
},
PathRequest::ChangeXattr {
size: Some(a3 as usize),
value: a2,
flags: u64::from(a4 as u32),
},
a1,
),
Sysno::removexattr | Sysno::lremovexattr => (
at,
a0,
if sysno == Sysno::lremovexattr {
nofollow()
} else {
0
},
PathRequest::ChangeXattr {
size: None,
value: 0,
flags: 0,
},
a1,
),
Sysno::chmod => (at, a0, 0, PathRequest::Chmod { flags: 0 }, 0),
Sysno::fchmodat => (a0, a1, 0, PathRequest::Chmod { flags: 0 }, 0),
Sysno::fchmodat2 => (a0, a1, a3, PathRequest::Chmod { flags: a3 }, 0),
Sysno::truncate => (at, a0, 0, PathRequest::Truncate { length: a1 as i64 }, 0),
Sysno::utimensat => {
let Ok(times) = read_pair::<libc::timespec, _>(&guest.memory(), a2) else {
return Ok(None);
};
let omitted = times
.is_some_and(|times| times.iter().all(|time| time.tv_nsec == libc::UTIME_OMIT));
let flags_valid = a3 & !((libc::AT_SYMLINK_NOFOLLOW | libc::AT_EMPTY_PATH) as u64)
== 0
&& (a1 != 0 || a3 == 0 || a0 as i32 == libc::AT_FDCWD);
if self.renders_procfs(guest) {
if omitted {
return Ok(Some(0));
}
if !flags_valid {
return Err(Errno::EINVAL.into());
}
if a1 == 0 && a0 as i32 == libc::AT_FDCWD {
return Err(Errno::EFAULT.into());
}
}
decided_before_descriptor = omitted || !flags_valid;
let valid = omitted
|| (flags_valid
&& times.is_none_or(|times| times.iter().all(valid_utime_nsec)));
(
a0,
a1,
a3,
if valid {
PathRequest::Times {
explicit: utimens_request(times),
}
} else {
PathRequest::Invalid
},
0,
)
}
Sysno::utime => (
at,
a0,
0,
legacy_times_request(&guest.memory(), a1, false),
0,
),
Sysno::utimes => (
at,
a0,
0,
legacy_times_request(&guest.memory(), a1, true),
0,
),
Sysno::chdir => (at, a0, 0, PathRequest::Chdir, 0),
_ => return Ok(None),
};
if let PathRequest::Access { mode, flags } = request
&& access_arguments_invalid(mode, flags)
{
return Ok(None);
}
if let PathRequest::ChangeXattr { flags, .. } = request
&& flags & !(libc::XATTR_CREATE | libc::XATTR_REPLACE) as u64 != 0
&& self.renders_procfs(guest)
{
return Err(Errno::EINVAL.into());
}
let dirfd = dirfd as i32;
let empty_path_allowed = flags & libc::AT_EMPTY_PATH as u64 != 0;
let path_text = match PathPtr::from_ptr(path as *const libc::c_char) {
Some(path) => match path.read(&guest.memory()) {
Ok(path) => Some(path),
Err(_) => return Ok(None),
},
None => None,
};
let by_descriptor = match &path_text {
None => sysno == Sysno::utimensat,
Some(path) => path.as_os_str().is_empty() && empty_path_allowed,
};
let session_files = self.rendered_files(guest);
let xattr_arguments = if self.renders_procfs(guest)
&& (by_descriptor
|| path_text
.as_deref()
.is_some_and(|text| could_name_rendered(text, session_files)))
{
checked_xattr_arguments(&guest.memory(), request, name)?
} else {
None
};
let rendered = if by_descriptor {
let known = guest
.thread_state()
.with_detfd(dirfd, |detfd| {
detfd
.procfs_rendered_path()
.map(|path| (path, detfd.status_flags() & libc::O_PATH != 0))
})
.ok()
.flatten();
let rendered = match known {
Some(known) => Some(known),
None if self.renders_procfs(guest) => {
match self.placeholder_descriptor(guest, dirfd).await {
Some(path) => {
let status = guest
.inject(
syscalls::Fcntl::new()
.with_fd(dirfd)
.with_cmd(syscalls::FcntlCmd::F_GETFL),
)
.await
.unwrap_or(0);
Some((path, status & i64::from(libc::O_PATH) != 0))
}
None => None,
}
}
None => None,
};
if let Some((_, true)) = rendered
&& path_text.is_none()
&& !decided_before_descriptor
{
return Err(Errno::EBADF.into());
}
rendered.map(|(path, _)| path)
} else {
let Some(text) = path_text else {
return Ok(None);
};
if text.as_os_str().is_empty() || !self.renders_procfs(guest) {
return Ok(None);
}
let files = self.rendered_files(guest);
let lexical = if could_name_rendered(&text, files) {
let observed = self.procfs_spelling_at(guest, dirfd, &text).await?;
match self.rendered_procfs_at(guest, &observed).await? {
Some(target) if target.via_link && flags & nofollow() != 0 => return Ok(None),
Some(target) => target.procfs.rendered_path(files),
None => None,
}
} else {
None
};
match lexical {
Some(rendered) => Some(rendered),
None => {
self.placeholder_reached(
guest,
dirfd,
PathPtr::from_ptr(path as *const libc::c_char),
flags & nofollow() == 0,
)
.await
}
}
};
if rendered.is_none() {
return Ok(None);
}
let xattr_arguments = match xattr_arguments {
Some(arguments) => Some(arguments),
None => checked_xattr_arguments(&guest.memory(), request, name)?,
};
let (name, value) = match xattr_arguments {
Some((name, value)) => (Some(name), value),
None => (None, None),
};
let rendered = rendered.expect("checked above");
let needs_capabilities = match request {
PathRequest::Access { mode, .. } => mode & libc::W_OK as u64 != 0,
PathRequest::Truncate { .. } | PathRequest::ChangeXattr { .. } => true,
_ => false,
};
let set = match request {
PathRequest::Access { flags, .. } if flags & libc::AT_EACCESS as u64 == 0 => {
CapabilitySet::Permitted
}
_ => CapabilitySet::Effective,
};
let access = self
.rendered_file_access(guest, rendered, needs_capabilities, set)
.await?;
let answer = path_request_answer(request, name.as_deref(), value.as_deref(), access);
if answer == Ok(0)
&& matches!(request, PathRequest::Times { .. })
&& access.owner
&& crate::procfs::per_process_name(rendered).is_some()
&& let Some((seconds, nanoseconds)) =
self.requested_mtime(guest, sysno, [a0, a1, a2]).await
{
crate::tool_global::rendered_file_state(
guest,
procfs_inode::rendered_inode(rendered),
crate::procfs::listing::RenderedFileChange::Mtime(seconds, nanoseconds),
)
.await;
}
answer.map(Some).map_err(Into::into)
}
async fn requested_mtime<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
[_, a1, a2]: [u64; 3],
) -> Option<(i64, i64)> {
let times = if sysno == Sysno::utimensat { a2 } else { a1 };
let explicit = if times == 0 {
None
} else if sysno == Sysno::utimensat {
let [_, mtime] = read_pair::<libc::timespec, _>(&guest.memory(), times)
.ok()
.flatten()?;
match mtime.tv_nsec {
libc::UTIME_OMIT => return None,
libc::UTIME_NOW => None,
_ => Some((mtime.tv_sec, mtime.tv_nsec)),
}
} else if sysno == Sysno::utime {
let [_, modtime] = read_pair::<libc::time_t, _>(&guest.memory(), times)
.ok()
.flatten()?;
Some((modtime, 0))
} else {
let [_, mtime] = read_pair::<libc::timeval, _>(&guest.memory(), times)
.ok()
.flatten()?;
Some((mtime.tv_sec, mtime.tv_usec * 1000))
};
match explicit {
Some(time) => Some(time),
None => {
let now: Timespec = crate::tool_global::thread_observe_time(guest).await.into();
Some((now.tv_sec, now.tv_nsec))
}
}
}
}
fn descriptor_arguments<M: MemoryAccess>(
memory: &M,
sysno: Sysno,
args: &reverie::syscalls::SyscallArgs,
) -> Vec<RawFd> {
let names_itself = |path: usize| -> bool {
match PathPtr::from_ptr(path as *const libc::c_char) {
None => true,
Some(pointer) => pointer
.read(memory)
.is_ok_and(|path: std::path::PathBuf| path.as_os_str().is_empty()),
}
};
let fd = |raw: usize| raw as i32 as RawFd;
match sysno {
Sysno::read
| Sysno::readv
| Sysno::pread64
| Sysno::preadv
| Sysno::preadv2
| Sysno::write
| Sysno::writev
| Sysno::pwrite64
| Sysno::pwritev
| Sysno::pwritev2
| Sysno::lseek
| Sysno::fstat
| Sysno::fstatfs
| Sysno::fcntl
| Sysno::ioctl
| Sysno::ftruncate
| Sysno::fallocate
| Sysno::fsync
| Sysno::fdatasync
| Sysno::fadvise64
| Sysno::readahead
| Sysno::sync_file_range
| Sysno::fchmod
| Sysno::fchown
| Sysno::fgetxattr
| Sysno::fsetxattr
| Sysno::flistxattr
| Sysno::fremovexattr
| Sysno::flock
| Sysno::dup
| Sysno::dup2
| Sysno::dup3
| Sysno::getdents
| Sysno::getdents64
| Sysno::fchdir => vec![fd(args.arg0)],
Sysno::mmap => vec![fd(args.arg4)],
Sysno::sendfile | Sysno::tee => vec![fd(args.arg0), fd(args.arg1)],
Sysno::splice | Sysno::copy_file_range => vec![fd(args.arg0), fd(args.arg2)],
Sysno::epoll_ctl => vec![fd(args.arg2)],
Sysno::newfstatat
| Sysno::statx
| Sysno::utimensat
| Sysno::faccessat2
| Sysno::fchownat
| Sysno::fchmodat
| Sysno::readlinkat
if names_itself(args.arg1) =>
{
vec![fd(args.arg0)]
}
_ => Vec::new(),
}
}
type XattrArguments = (Vec<u8>, Option<Vec<u8>>);
fn checked_xattr_arguments<M: MemoryAccess>(
memory: &M,
request: PathRequest,
name: u64,
) -> Result<Option<XattrArguments>, Errno> {
if !matches!(
request,
PathRequest::GetXattr | PathRequest::ChangeXattr { .. }
) {
return Ok(None);
}
let name = read_xattr_name(memory, name)?;
if name.is_empty() || name.len() > XATTR_NAME_MAX {
return Err(Errno::ERANGE);
}
let value = match request {
PathRequest::ChangeXattr {
size: Some(size),
value,
..
} => {
if size > XATTR_SIZE_MAX {
return Err(Errno::E2BIG);
}
let read = read_value(memory, value, size);
if size > 0 && read.is_none() {
return Err(Errno::EFAULT);
}
read
}
_ => None,
};
Ok(Some((name, value)))
}
fn read_xattr_name<M: MemoryAccess>(memory: &M, address: u64) -> Result<Vec<u8>, Errno> {
const PAGE: u64 = 4096;
let mut name = Vec::new();
let limit = XATTR_NAME_MAX + 1;
while name.len() < limit {
let start = address
.checked_add(name.len() as u64)
.ok_or(Errno::EFAULT)?;
let page_left = (PAGE - start % PAGE) as usize;
let mut chunk = vec![0u8; page_left.min(limit - name.len())];
let chunk_address =
reverie::syscalls::Addr::<u8>::from_raw(start as usize).ok_or(Errno::EFAULT)?;
memory
.read_exact_with_user_access(chunk_address, &mut chunk)
.map_err(|_| Errno::EFAULT)?;
match chunk.iter().position(|byte| *byte == 0) {
Some(end) => {
name.extend_from_slice(&chunk[..end]);
return Ok(name);
}
None => name.extend_from_slice(&chunk),
}
}
Ok(name)
}
const fn nofollow() -> u64 {
libc::AT_SYMLINK_NOFOLLOW as u64
}
fn could_name_rendered(path: &Path, files: RenderedFiles) -> bool {
let Some(std::path::Component::Normal(last)) = path.components().next_back() else {
return false;
};
let last = last.as_bytes();
rendered_paths(files).any(|rendered| rendered_name(rendered) == last)
|| ProcfsFile::PER_PROCESS_NAMES
.iter()
.any(|name| name.as_bytes() == last)
|| (!last.is_empty() && last.iter().all(u8::is_ascii_digit))
}
fn read_value<M: MemoryAccess>(memory: &M, address: u64, size: usize) -> Option<Vec<u8>> {
let size = size.min(XATTR_SIZE_MAX);
if size == 0 {
return Some(Vec::new());
}
let address = reverie::syscalls::Addr::<u8>::from_raw(address as usize)?;
let mut value = vec![0; size];
memory
.read_exact_with_user_access(address, &mut value)
.ok()?;
Some(value)
}
fn legacy_times_request<M: MemoryAccess>(memory: &M, times: u64, timevals: bool) -> PathRequest {
if times == 0 {
return PathRequest::Times { explicit: None };
}
if !timevals {
return match read_pair::<libc::time_t, M>(memory, times) {
Err(_) => PathRequest::Fault,
Ok(_) => PathRequest::Times {
explicit: Some(true),
},
};
}
match read_pair::<libc::timeval, M>(memory, times) {
Err(_) => PathRequest::Fault,
Ok(Some(values))
if values
.iter()
.any(|value| !(0..1_000_000).contains(&value.tv_usec)) =>
{
PathRequest::Invalid
}
Ok(_) => PathRequest::Times {
explicit: Some(true),
},
}
}
fn valid_utime_nsec(time: &libc::timespec) -> bool {
(0..1_000_000_000).contains(&time.tv_nsec)
|| time.tv_nsec == libc::UTIME_NOW
|| time.tv_nsec == libc::UTIME_OMIT
}
fn read_pair<U: Copy, M: MemoryAccess>(memory: &M, address: u64) -> Result<Option<[U; 2]>, Error> {
match reverie::syscalls::Addr::<[U; 2]>::from_raw(address as usize) {
Some(address) => Ok(Some(memory.read_value(address)?)),
None => Ok(None),
}
}
#[cfg(test)]
mod tests {
use super::*;
struct RefusalGuest<'a> {
config: &'a crate::config::Config,
thread: crate::ThreadState<()>,
}
struct RefusalStack;
struct RefusalStackGuard;
impl Drop for RefusalStackGuard {
fn drop(&mut self) {}
}
impl reverie::Stack for RefusalStack {
type StackGuard = RefusalStackGuard;
fn size(&self) -> usize {
panic!("binding a task identity uses no guest stack")
}
fn capacity(&self) -> usize {
panic!("binding a task identity uses no guest stack")
}
fn push<'stack, T>(&mut self, _: T) -> reverie::syscalls::Addr<'stack, T> {
panic!("binding a task identity uses no guest stack")
}
fn reserve<'stack, T>(&mut self) -> reverie::syscalls::AddrMut<'stack, T> {
panic!("binding a task identity uses no guest stack")
}
fn commit(self) -> Result<Self::StackGuard, Errno> {
panic!("binding a task identity uses no guest stack")
}
}
#[reverie::tool]
impl reverie::GlobalRPC<crate::tool_global::GlobalState> for RefusalGuest<'_> {
async fn send_rpc(
&self,
_: <crate::tool_global::GlobalState as reverie::GlobalTool>::Request,
) -> <crate::tool_global::GlobalState as reverie::GlobalTool>::Response {
panic!("a refusal without the shutdown policy sends no request")
}
fn config(&self) -> &crate::config::Config {
self.config
}
}
#[reverie::tool]
impl Guest<Detcore> for RefusalGuest<'_> {
type Memory = reverie::syscalls::LocalMemory;
type Stack = RefusalStack;
fn tid(&self) -> reverie::Tid {
reverie::Tid::from_raw(3)
}
fn pid(&self) -> reverie::Tid {
reverie::Tid::from_raw(3)
}
fn ppid(&self) -> Option<reverie::Tid> {
None
}
fn memory(&self) -> Self::Memory {
panic!("binding a task identity reads no guest memory")
}
fn thread_state(&self) -> &crate::ThreadState<()> {
&self.thread
}
fn thread_state_mut(&mut self) -> &mut crate::ThreadState<()> {
&mut self.thread
}
async fn regs(&mut self) -> libc::user_regs_struct {
let mut regs: libc::user_regs_struct = unsafe { std::mem::zeroed() };
regs.orig_rax = libc::SYS_openat as u64;
regs
}
async fn stack(&mut self) -> Self::Stack {
RefusalStack
}
async fn daemonize(&mut self) {
panic!("binding a task identity does not daemonize")
}
async fn inject<S: reverie::syscalls::SyscallInfo>(&mut self, _: S) -> Result<i64, Errno> {
panic!("binding a task identity injects nothing")
}
async fn tail_inject<S: reverie::syscalls::SyscallInfo>(&mut self, _: S) -> reverie::Never {
panic!("binding a task identity does not retire the guest")
}
fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("binding a task identity sets no timer")
}
fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
panic!("binding a task identity sets no timer")
}
fn read_clock(&mut self) -> Result<u64, Error> {
panic!("binding a task identity reads no clock")
}
}
#[tokio::test]
async fn the_256th_task_generation_is_refused_by_name() {
use reverie::Tool as _;
let answer = |process| crate::procfs::listing::ProcfsTaskAnswer {
exists: true,
without_mm: false,
process_incarnation: process,
thread_incarnation: None,
mm: None,
runtime_private_memory: None,
};
for (fail_closed, incarnation, expected) in [
(true, procfs_inode::MAX_INCARNATION, "bound"),
(false, procfs_inode::MAX_INCARNATION + 1, "EOVERFLOW"),
(true, procfs_inode::MAX_INCARNATION + 1, "stop"),
] {
let config = crate::config::Config {
panic_on_unsupported_syscalls: fail_closed,
exit_on_unsupported_syscall: true,
shutdown_on_unsupported_syscall: false,
..crate::config::Config::default()
};
let tool = Detcore::new(reverie::Tid::from_raw(3), &config);
let mut guest = RefusalGuest {
config: &config,
thread: crate::ThreadState::new(crate::types::DetTid::from_raw(3), &config, ()),
};
let mut file = ProcfsFile::from_path(Path::new("/proc/stat")).unwrap();
let result = tool
.bind_task_identity(&mut guest, &mut file, answer(incarnation))
.await;
let bound = file.task_incarnation();
match (expected, result) {
("bound", Ok(())) => assert_eq!(bound, Some(answer(incarnation).incarnation())),
("EOVERFLOW", Err(Error::Errno(Errno::EOVERFLOW))) => assert_eq!(bound, None),
("stop", Err(Error::Tool(error))) => assert_eq!(
error
.downcast_ref::<crate::UnsupportedSyscallError>()
.expect("the policy's named refusal")
.0,
Sysno::openat
),
(expected, result) => panic!("{incarnation}: expected {expected}, got {result:?}"),
}
if expected != "bound" {
assert_eq!(bound, None, "a refused generation is bound to no file");
}
}
}
#[test]
fn a_rendered_snapshot_survives_exec() {
let open = || {
ProcfsFile::from_path(Path::new("/proc/sys/kernel/random/uuid"))
.unwrap()
.into_rendered()
};
let mut before = open();
assert_eq!(before.rendered_snapshot(), None);
let template = before.rendering_template().to_vec();
before.initialize(
template,
crate::procfs::ProcfsSnapshotContext {
random_uuid: Some([0x5a; 16]),
..Default::default()
},
);
let snapshot = before.rendered_snapshot().unwrap().to_vec();
assert_eq!(snapshot.len(), 37);
let head = before.take(10).unwrap();
let mut after = open().with_rendered_snapshot(snapshot.clone());
after.set_offset(10);
assert!(!after.needs_snapshot());
let mut joined = head;
joined.extend(after.take(64).unwrap());
assert_eq!(joined, snapshot);
}
#[test]
fn rendered_stat_is_a_read_only_regular_procfs_file() {
let epoch = Timespec {
tv_sec: 1_767_225_600,
tv_nsec: 0,
};
let path = Path::new("/proc/sys/kernel/random/uuid");
let stat = rendered_stat(path, epoch, (65534, 65534));
assert_eq!(stat.mode, libc::S_IFREG | 0o444);
assert_eq!((stat.nlink, stat.size, stat.blocks), (1, 0, 0));
assert_eq!(stat.blksize, 1024);
assert_eq!((stat.uid, stat.gid), (65534, 65534));
assert_eq!(stat.dev, procfs_inode::VIRTUAL_PROC_DEVICE);
assert_eq!(stat.inode, procfs_inode::rendered_inode(path));
assert_eq!((stat.atime, stat.mtime, stat.ctime), (epoch, epoch, epoch));
assert_ne!(
rendered_stat(Path::new("/proc/sys/kernel/pty/nr"), epoch, (0, 0)).inode,
stat.inode
);
}
#[test]
fn rendered_files_have_distinct_inodes_and_linux_modes() {
let epoch = Timespec {
tv_sec: 0,
tv_nsec: 0,
};
let paths: Vec<&Path> = rendered_paths(RenderedFiles::ALL)
.map(|path| Path::new(path.to_str().unwrap()))
.collect();
assert!(paths.contains(&Path::new("/proc/cpuinfo")));
let inodes: std::collections::BTreeSet<u64> = paths
.iter()
.map(|path| procfs_inode::rendered_inode(path))
.collect();
assert_eq!(inodes.len(), paths.len());
for path in &paths {
assert_eq!(
ProcfsFile::from_path(path).and_then(|file| file.rendered_path(RenderedFiles::ALL)),
Some(*path)
);
assert!(could_name_rendered(path, RenderedFiles::ALL), "{path:?}");
}
let without = RenderedFiles::WITHOUT_CPUINFO;
assert_eq!(rendered_paths(without).count() + 1, paths.len());
assert!(rendered_paths(without).all(|path| path != c"/proc/cpuinfo"));
assert!(!could_name_rendered(Path::new("/proc/cpuinfo"), without));
assert_eq!(rendered_path_within(Path::new("/cpuinfo"), without), None);
assert_eq!(
rendered_path_within(Path::new("/cpuinfo"), RenderedFiles::ALL),
Some(Path::new("/proc/cpuinfo"))
);
let mode = |path: &str| rendered_stat(Path::new(path), epoch, (0, 0)).mode;
assert_eq!(mode("/proc/version"), libc::S_IFREG | 0o444);
assert_eq!(mode("/proc/sys/kernel/osrelease"), libc::S_IFREG | 0o444);
assert_eq!(mode("/proc/sys/kernel/overflowgid"), libc::S_IFREG | 0o644);
assert_eq!(mode("/proc/sys/vm/max_map_count"), libc::S_IFREG | 0o644);
}
#[test]
fn raw_identity_finds_rendered_files_and_nothing_else() {
let host = |path: &str| {
let path = std::ffi::CString::new(path).unwrap();
DetStat::from(GuestProcfs::stat(&path).expect("stat the host's procfs"))
};
assert_eq!(
rendered_path_of_raw(&host("/proc/version"), RenderedFiles::ALL),
Some(Path::new("/proc/version"))
);
assert_eq!(
rendered_path_of_raw(&host("/proc/sys/kernel/osrelease"), RenderedFiles::ALL),
Some(Path::new("/proc/sys/kernel/osrelease"))
);
let status = host("/proc/self/status");
assert_eq!(rendered_path_of_raw(&status, RenderedFiles::ALL), None);
assert!(
NOT_RENDERED
.lock()
.unwrap()
.contains(&(status.dev, status.inode))
);
assert_eq!(rendered_path_of_raw(&status, RenderedFiles::ALL), None);
let cpuinfo = host("/proc/cpuinfo");
for _ in 0..2 {
assert_eq!(
rendered_path_of_raw(&cpuinfo, RenderedFiles::WITHOUT_CPUINFO),
None
);
assert_eq!(
rendered_path_of_raw(&cpuinfo, RenderedFiles::ALL),
Some(Path::new("/proc/cpuinfo"))
);
}
assert_eq!(
rendered_path_of_raw(&host("/proc/sys/kernel"), RenderedFiles::ALL),
None
);
}
#[test]
fn pty_nr_ends_after_a_partial_read() {
let mut file = ProcfsFile::from_path(Path::new("/proc/sys/kernel/pty/nr"))
.unwrap()
.into_rendered();
let template = file.rendering_template().to_vec();
file.initialize(
template,
crate::procfs::ProcfsSnapshotContext {
virtual_pty_count: 12,
..Default::default()
},
);
assert_eq!(file.take(1), Some(b"1".to_vec()));
assert_eq!(file.take(64), Some(Vec::new()));
assert_eq!(file.take_at(0, 64), Some(b"12\n".to_vec()));
}
#[test]
fn placeholder_links_name_only_rendered_files() {
assert_eq!(
placeholder_link_path(
b"/memfd:hermit-procfs:/proc/sys/kernel/random/uuid@30 (deleted)",
RenderedFiles::ALL
),
Some(Path::new("/proc/sys/kernel/random/uuid"))
);
assert_eq!(
crate::procfs::placeholder_link(
b"/memfd:hermit-procfs:/proc/sys/kernel/pty/nr@330a (deleted)",
RenderedFiles::ALL
),
Some((Path::new("/proc/sys/kernel/pty/nr"), b"3\n".to_vec()))
);
let name = placeholder_name(Path::new("/proc/sys/kernel/pty/nr"), b"12\n");
assert_eq!(
crate::procfs::placeholder_link(
format!("/memfd:{name} (deleted)").as_bytes(),
RenderedFiles::ALL
),
Some((Path::new("/proc/sys/kernel/pty/nr"), b"12\n".to_vec()))
);
assert_eq!(
crate::procfs::placeholder_link(
b"/memfd:hermit-procfs:/proc/uptime@ (deleted)",
RenderedFiles::ALL
),
Some((Path::new("/proc/uptime"), Vec::new()))
);
assert_eq!(
crate::procfs::placeholder_link(
b"/memfd:hermit-procfs:/proc/stat@ (deleted)",
RenderedFiles::ALL
),
Some((Path::new("/proc/stat"), Vec::new()))
);
assert_eq!(
crate::procfs::placeholder_link(
b"/memfd:hermit-procfs:/proc/cpuinfo@ (deleted)",
RenderedFiles::ALL
),
Some((Path::new("/proc/cpuinfo"), Vec::new()))
);
for link in [
b"/memfd:hermit-procfs:/proc/diskstats@30 (deleted)".as_slice(),
b"/memfd:hermit-procfs:/proc/sys/kernel/random/uuid (deleted)",
b"/memfd:hermit-procfs:/proc/sys/kernel/random/uuid@3 (deleted)",
b"/memfd:hermit-procfs:/proc/sys/kernel/random/uuid@zz (deleted)",
b"/memfd:hermit-procfs:/proc/sys/kernel/random/uuid@30",
b"/memfd: (deleted)",
b"/proc/sys/kernel/random/uuid",
] {
assert_eq!(
placeholder_link_path(link, RenderedFiles::ALL),
None,
"{link:?}"
);
}
assert_eq!(
rendered_path_within(Path::new("/sys/kernel/random/uuid"), RenderedFiles::ALL),
Some(Path::new("/proc/sys/kernel/random/uuid"))
);
assert_eq!(
rendered_path_within(Path::new("/uptime"), RenderedFiles::ALL),
Some(Path::new("/proc/uptime"))
);
assert_eq!(
rendered_path_within(Path::new("/stat"), RenderedFiles::ALL),
Some(Path::new("/proc/stat"))
);
assert_eq!(
rendered_path_within(Path::new("/diskstats"), RenderedFiles::ALL),
None
);
assert_eq!(
rendered_path_within(Path::new("/self/stat"), RenderedFiles::ALL),
None
);
}
#[test]
fn a_placeholder_carries_the_uptime_of_the_first_read() {
for uptime in [
0,
1,
120,
(1 << 29) - 1,
1 << 29,
1 << 63,
u64::MAX - 1,
u64::MAX,
] {
let mtime = carried_uptime_mtime(uptime);
assert!(mtime.tv_sec < 0, "{uptime}");
assert!((0..1_000_000_000).contains(&mtime.tv_nsec), "{uptime}");
assert_eq!(carried_uptime(mtime.tv_sec, mtime.tv_nsec), Some(uptime));
}
assert_eq!(carried_uptime(0, 0), None);
assert_eq!(carried_uptime(1_767_225_600, 123), None);
assert_eq!(carried_uptime(-1, 1 << 29), None);
assert_eq!(carried_uptime(-1, -1), None);
assert_eq!(carried_uptime(i64::MIN, 0), None);
assert!(descriptor_stable_across_injections(true, false));
assert!(!descriptor_stable_across_injections(false, false));
assert!(!descriptor_stable_across_injections(true, true));
assert!(!descriptor_stable_across_injections(false, true));
let stat = Path::new("/proc/stat");
assert!(may_carry_uptime(true, Some(stat), stat));
assert!(!may_carry_uptime(false, Some(stat), stat));
assert!(!may_carry_uptime(true, None, stat));
assert!(!may_carry_uptime(
true,
Some(Path::new("/proc/uptime")),
stat
));
assert_eq!(
carried_uptime(-(1 << 35), 7),
Some((((1 << 35) - 1) << 29) | 7)
);
}
#[test]
fn open_flags_follow_linux_for_a_read_only_sysctl_file() {
let ok = |flags| rendered_open_flags(flags, FileAccess::GLOBAL_ROOT).unwrap();
let err = |flags| rendered_open_flags(flags, FileAccess::GLOBAL_ROOT).unwrap_err();
assert_eq!(ok(OFlag::O_RDONLY), OFlag::O_RDONLY);
assert_eq!(
ok(OFlag::O_RDONLY | OFlag::O_APPEND | OFlag::O_NONBLOCK | OFlag::O_CLOEXEC),
OFlag::O_APPEND | OFlag::O_NONBLOCK | OFlag::O_CLOEXEC
);
assert_eq!(
ok(OFlag::O_PATH | OFlag::O_WRONLY | OFlag::O_CLOEXEC),
OFlag::O_PATH | OFlag::O_CLOEXEC
);
assert_eq!(ok(OFlag::O_RDONLY | OFlag::O_CREAT), OFlag::O_RDONLY);
assert_eq!(err(OFlag::O_WRONLY), Errno::EACCES);
assert_eq!(err(OFlag::O_RDWR), Errno::EACCES);
assert_eq!(err(OFlag::O_RDONLY | OFlag::O_TRUNC), Errno::EACCES);
assert_eq!(err(OFlag::O_RDONLY | OFlag::O_DIRECTORY), Errno::ENOTDIR);
assert_eq!(err(OFlag::O_PATH | OFlag::O_DIRECTORY), Errno::ENOTDIR);
assert_eq!(err(OFlag::O_CREAT | OFlag::O_EXCL), Errno::EEXIST);
assert_eq!(err(OFlag::O_CREAT | OFlag::O_DIRECTORY), Errno::EINVAL);
assert_eq!(
err(OFlag::O_CREAT | OFlag::O_EXCL | OFlag::O_DIRECTORY),
Errno::EINVAL
);
assert_eq!(err(OFlag::O_TMPFILE | OFlag::O_RDONLY), Errno::EINVAL);
assert_eq!(err(OFlag::O_TMPFILE | OFlag::O_RDWR), Errno::ENOTDIR);
assert_eq!(
err(OFlag::O_CREAT | OFlag::O_TMPFILE | OFlag::O_RDWR),
Errno::EINVAL
);
assert_eq!(err(OFlag::O_PATH | OFlag::O_TMPFILE), Errno::ENOTDIR);
assert_eq!(err(OFlag::O_RDONLY | OFlag::O_NOATIME), Errno::EPERM);
assert_eq!(err(OFlag::O_RDONLY | OFlag::O_DIRECT), Errno::EINVAL);
}
#[test]
fn mapping_follows_do_mmap_order() {
let private = MapFlags::MAP_PRIVATE;
let shared = MapFlags::MAP_SHARED;
let read = ProtFlags::PROT_READ;
let write = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE;
let exec = ProtFlags::PROT_READ | ProtFlags::PROT_EXEC;
let answer = |len, offset, prot, flags| {
rendered_mmap_answer(0, len, offset, prot, flags, true, false)
};
assert_eq!(answer(0, 0, read, private), Err(Errno::EINVAL));
assert_eq!(answer(4096, 1, read, private), Err(Errno::EINVAL));
assert_eq!(answer(4096, 0, write, shared), Err(Errno::EACCES));
assert_eq!(answer(4096, 0, exec, private), Err(Errno::EPERM));
assert_eq!(answer(4096, 0, write, private), Err(Errno::ENODEV));
assert_eq!(answer(4096, 0, read, shared), Err(Errno::ENODEV));
assert_eq!(
rendered_mmap_answer(0, 4096, 0, exec, private, false, false),
Err(Errno::ENODEV)
);
assert_eq!(answer(4096, -4096, read, private), Err(Errno::EOVERFLOW));
assert_eq!(
answer(4096, 0x7fff_ffff_ffff_f000, read, private),
Err(Errno::EOVERFLOW)
);
assert_eq!(
answer(4096, 0x7fff_ffff_ffff_e000, read, private),
Err(Errno::ENODEV)
);
let fixed = MapFlags::MAP_PRIVATE | MapFlags::MAP_FIXED;
assert_eq!(
rendered_mmap_answer(0x7fff_ffff_f000, 4096, 0, read, fixed, false, false),
Err(Errno::ENOMEM)
);
assert_eq!(
rendered_mmap_answer(0x7fff_ffff_e000, 4096, 0, read, fixed, false, false),
Err(Errno::ENODEV)
);
assert_eq!(
rendered_mmap_answer(0x1001, 4096, 0, read, fixed, false, false),
Err(Errno::EINVAL)
);
assert_eq!(
rendered_mmap_answer(0x1000, 4096, 0, read, fixed, false, false),
Err(Errno::EPERM)
);
}
#[test]
fn a_seq_file_refuses_mappings_and_positioned_writes_as_linux() {
let read = ProtFlags::PROT_READ;
let write = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE;
let private = MapFlags::MAP_PRIVATE;
let shared = MapFlags::MAP_SHARED;
let seq = |prot, flags| rendered_mmap_answer(0, 4096, 0, prot, flags, false, true);
assert_eq!(seq(read, private), Err(Errno::EIO));
assert_eq!(seq(read, shared), Err(Errno::EIO));
assert_eq!(seq(write, shared), Err(Errno::EACCES));
assert_eq!(
seq(read, private | MapFlags::MAP_GROWSDOWN),
Err(Errno::EINVAL)
);
assert_eq!(
rendered_mmap_answer(
0,
4096,
0,
read,
private | MapFlags::MAP_GROWSDOWN,
false,
false
),
Err(Errno::ENODEV)
);
let validate = MapFlags::from_bits_retain(libc::MAP_SHARED_VALIDATE);
for seq_file in [false, true] {
for flag in [MapFlags::MAP_FIXED_NOREPLACE, MapFlags::MAP_SYNC] {
assert_eq!(
rendered_mmap_answer(
0x7000_0000_0000,
4096,
0,
read,
validate | flag,
false,
seq_file
),
Err(Errno::EOPNOTSUPP)
);
}
assert_eq!(
rendered_mmap_answer(0, 4096, 0, read, validate, false, seq_file),
Err(if seq_file { Errno::EIO } else { Errno::ENODEV })
);
assert_eq!(
rendered_mmap_answer(
0,
4096,
0,
read,
validate | MapFlags::from_bits_retain(i32::MIN),
false,
seq_file
),
Err(Errno::EOPNOTSUPP)
);
assert_eq!(
rendered_mmap_answer(
0,
4096,
0,
read,
validate | MapFlags::from_bits_retain(30 << 26),
false,
seq_file
),
Err(if seq_file { Errno::EIO } else { Errno::ENODEV })
);
}
assert_eq!(
rendered_mmap_answer(0, 0, 0, read, private, false, true),
Err(Errno::EINVAL)
);
assert_eq!(
rendered_mmap_answer(0, 4096, 0, read, private, false, false),
Err(Errno::ENODEV)
);
assert!(crate::procfs::rendered_path_is_seq_file(Path::new(
"/proc/uptime"
)));
assert!(crate::procfs::rendered_path_is_seq_file(Path::new(
"/proc/meminfo"
)));
assert!(!crate::procfs::rendered_path_is_seq_file(Path::new(
"/proc/sys/kernel/osrelease"
)));
for sysno in [Sysno::pwrite64, Sysno::pwritev, Sysno::pwritev2] {
assert_eq!(
rendered_seq_file_pwrite_answer(sysno, 0),
Some(Err(Errno::ESPIPE))
);
assert_eq!(
rendered_seq_file_pwrite_answer(sysno, -2),
Some(Err(Errno::EINVAL))
);
}
assert_eq!(
rendered_seq_file_pwrite_answer(Sysno::pwrite64, -1),
Some(Err(Errno::EINVAL))
);
assert_eq!(rendered_seq_file_pwrite_answer(Sysno::pwritev2, -1), None);
}
#[test]
fn extended_attribute_changes_follow_linux() {
let one = Some(&b"1"[..]);
let change = |name: &[u8], size, value| {
xattr_change_answer(name, size, value, FileAccess::GLOBAL_ROOT)
};
assert_eq!(change(b"user.x", Some(1), one), Err(Errno::EACCES));
assert_eq!(change(b"user.x", Some(1), None), Err(Errno::EFAULT));
assert_eq!(change(b"foo.x", Some(1), one), Err(Errno::EACCES));
assert_eq!(change(b"trusted.x", None, None), Err(Errno::EPERM));
assert_eq!(change(b"security.x", None, None), Err(Errno::EPERM));
assert_eq!(change(b"security.x", Some(1), one), Err(Errno::EPERM));
assert_eq!(
change(b"security.capability", Some(1), one),
Err(Errno::EINVAL)
);
assert_eq!(change(b"system.x", Some(1), one), Err(Errno::EOPNOTSUPP));
assert_eq!(change(b"", None, None), Err(Errno::ERANGE));
assert_eq!(
change(b"user.x", Some(XATTR_SIZE_MAX + 1), one),
Err(Errno::E2BIG)
);
let bad = [2, 0, 0, 0, 0x40, 0, 7, 0, 0, 0, 0, 0];
let good = [
2, 0, 0, 0, 1, 0, 6, 0, 255, 255, 255, 255, 4, 0, 4, 0, 255, 255, 255, 255, 0x20, 0, 4,
0, 255, 255, 255, 255,
];
let acl = b"system.posix_acl_access";
assert_eq!(change(acl, Some(12), Some(&bad)), Err(Errno::EINVAL));
assert_eq!(change(acl, Some(28), Some(&good)), Err(Errno::EOPNOTSUPP));
assert_eq!(
change(acl, Some(4), Some(&good[..4])),
Err(Errno::EOPNOTSUPP)
);
assert_eq!(change(acl, None, None), Err(Errno::EOPNOTSUPP));
assert_eq!(change(acl, Some(0), Some(&[])), Err(Errno::EOPNOTSUPP));
assert_eq!(
change(acl, Some(12), Some(&good[..12])),
Err(Errno::EOPNOTSUPP)
);
assert_eq!(change(acl, Some(6), Some(&good[..6])), Err(Errno::EINVAL));
assert_eq!(change(acl, Some(2), Some(&good[..2])), Err(Errno::EINVAL));
let mut bad_version = good;
bad_version[0] = 7;
assert_eq!(
change(acl, Some(28), Some(&bad_version)),
Err(Errno::EOPNOTSUPP)
);
let mut bad_permissions = good;
bad_permissions[6] = 0x40;
assert_eq!(
change(acl, Some(28), Some(&bad_permissions)),
Err(Errno::EOPNOTSUPP)
);
let named = [
2, 0, 0, 0, 1, 0, 6, 0, 255, 255, 255, 255, 2, 0, 4, 0, 255, 255, 255, 255, 4, 0, 4, 0,
255, 255, 255, 255, 0x10, 0, 4, 0, 255, 255, 255, 255, 0x20, 0, 4, 0, 255, 255, 255,
255,
];
assert!(posix_acl_parser_refuses(&named), "user ID -1");
assert_eq!(xattr_get_answer(b"", true), Err(Errno::ERANGE));
assert_eq!(xattr_get_answer(b"trusted.x", true), Err(Errno::ENODATA));
assert_eq!(xattr_get_answer(b"user.x", true), Err(Errno::EOPNOTSUPP));
assert_eq!(xattr_get_answer(b"", false), Err(Errno::ERANGE));
assert_eq!(xattr_get_answer(b"trusted.x", false), Err(Errno::ENODATA));
assert_eq!(xattr_get_answer(b"user.x", false), Err(Errno::EACCES));
assert_eq!(
xattr_get_answer(b"security.x", false),
Err(Errno::EOPNOTSUPP)
);
assert_eq!(xattr_get_answer(b"system.x", false), Err(Errno::EOPNOTSUPP));
}
#[test]
fn path_calls_follow_linux_for_a_read_only_sysctl_file() {
let access = |mode: i32, flags: i32| {
path_request_answer(
PathRequest::Access {
mode: mode as u64,
flags: flags as u64,
},
None,
None,
FileAccess::GLOBAL_ROOT,
)
};
assert_eq!(access(libc::F_OK, 0), Ok(0));
assert_eq!(access(libc::R_OK, libc::AT_EACCESS), Ok(0));
assert_eq!(access(libc::W_OK, 0), Err(Errno::EACCES));
assert_eq!(access(libc::X_OK, 0), Err(Errno::EACCES));
assert_eq!(access(8, 0), Err(Errno::EINVAL));
assert_eq!(access(libc::R_OK, 0x10000), Err(Errno::EINVAL));
assert_eq!(
path_request_answer(
PathRequest::GetXattr,
Some(b"user.x"),
None,
FileAccess::GLOBAL_ROOT
),
Err(Errno::EOPNOTSUPP)
);
assert_eq!(
path_request_answer(PathRequest::ListXattr, None, None, FileAccess::GLOBAL_ROOT),
Ok(0)
);
let change = |name: &[u8], flags: i32| {
path_request_answer(
PathRequest::ChangeXattr {
size: Some(1),
value: 0,
flags: flags as u64,
},
Some(name),
Some(&b"1"[..]),
FileAccess::GLOBAL_ROOT,
)
};
assert_eq!(change(b"user.x", 0), Err(Errno::EACCES));
assert_eq!(change(b"user.x", 4), Err(Errno::EINVAL));
assert_eq!(
path_request_answer(
PathRequest::Chmod { flags: 0 },
None,
None,
FileAccess::GLOBAL_ROOT
),
Err(Errno::EPERM)
);
assert_eq!(
path_request_answer(
PathRequest::Truncate { length: 100 },
None,
None,
FileAccess::GLOBAL_ROOT
),
Err(Errno::EACCES)
);
assert_eq!(
path_request_answer(
PathRequest::Truncate { length: -1 },
None,
None,
FileAccess::GLOBAL_ROOT
),
Err(Errno::EINVAL)
);
assert_eq!(
path_request_answer(PathRequest::Chdir, None, None, FileAccess::GLOBAL_ROOT),
Err(Errno::ENOTDIR)
);
}
#[test]
fn times_ask_for_write_permission_or_the_owner() {
let at = |nsec: [i64; 2]| {
Some([
libc::timespec {
tv_sec: 1,
tv_nsec: nsec[0],
},
libc::timespec {
tv_sec: 1,
tv_nsec: nsec[1],
},
])
};
assert_eq!(utimens_request(None), None);
assert_eq!(utimens_request(at([libc::UTIME_NOW; 2])), None);
assert_eq!(utimens_request(at([libc::UTIME_OMIT; 2])), Some(false));
assert_eq!(
utimens_request(at([libc::UTIME_NOW, libc::UTIME_OMIT])),
Some(true)
);
assert_eq!(utimens_request(at([0, libc::UTIME_OMIT])), Some(true));
let times = |explicit| {
path_request_answer(
PathRequest::Times { explicit },
None,
None,
FileAccess::GLOBAL_ROOT,
)
};
assert_eq!(times(None), Err(Errno::EACCES));
assert_eq!(times(Some(false)), Ok(0));
assert_eq!(times(Some(true)), Err(Errno::EPERM));
}
#[test]
fn a_trailing_slash_asks_for_a_directory() {
assert!(names_a_directory(Path::new(
"/proc/sys/kernel/random/uuid/"
)));
assert!(names_a_directory(Path::new(
"/proc/sys/kernel/random/uuid/."
)));
assert!(!names_a_directory(Path::new(
"/proc/sys/kernel/random/uuid"
)));
}
const ALL_CAPABILITIES: u64 = (1 << 41) - 1;
#[test]
fn open_flags_follow_linux_for_a_process_file_its_owner_opens() {
let with = FileAccess::owned_with(ALL_CAPABILITIES);
let without = FileAccess::owned_with(0);
assert_eq!(
rendered_open_flags(OFlag::O_WRONLY, with),
Ok(OFlag::O_WRONLY)
);
assert_eq!(
rendered_open_flags(OFlag::O_RDWR | OFlag::O_APPEND, with),
Ok(OFlag::O_RDWR | OFlag::O_APPEND)
);
assert_eq!(
rendered_open_flags(OFlag::O_RDONLY | OFlag::O_TRUNC, with),
Ok(OFlag::O_RDONLY)
);
assert_eq!(
rendered_open_flags(OFlag::O_RDONLY | OFlag::O_NOATIME, without),
Ok(OFlag::O_RDONLY | OFlag::O_NOATIME)
);
for flags in [
OFlag::O_WRONLY,
OFlag::O_RDWR,
OFlag::O_RDONLY | OFlag::O_TRUNC,
] {
assert_eq!(rendered_open_flags(flags, without), Err(Errno::EACCES));
}
assert_eq!(
rendered_open_flags(OFlag::O_RDONLY | OFlag::O_DIRECT, with),
Err(Errno::EINVAL)
);
assert_eq!(
rendered_open_flags(OFlag::O_CREAT | OFlag::O_EXCL, with),
Err(Errno::EEXIST)
);
assert_eq!(
rendered_open_flags(OFlag::O_WRONLY, FileAccess::GLOBAL_ROOT),
Err(Errno::EACCES)
);
assert_eq!(
rendered_open_flags(OFlag::O_NOATIME, FileAccess::GLOBAL_ROOT),
Err(Errno::EPERM)
);
}
#[test]
fn path_calls_follow_linux_for_a_process_file_its_owner_names() {
for (capabilities, writes, xattr, security) in [
(
ALL_CAPABILITIES,
Ok(0),
Errno::EOPNOTSUPP,
Errno::EOPNOTSUPP,
),
(0, Err(Errno::EACCES), Errno::EACCES, Errno::EPERM),
] {
let access = FileAccess::owned_with(capabilities);
let answer = |request| path_request_answer(request, None, None, access);
let probe = |mode: i32| {
answer(PathRequest::Access {
mode: mode as u64,
flags: 0,
})
};
assert_eq!(probe(libc::R_OK), Ok(0));
assert_eq!(probe(libc::W_OK), writes);
assert_eq!(probe(libc::X_OK), Err(Errno::EACCES));
assert_eq!(answer(PathRequest::Truncate { length: 0 }), writes);
assert_eq!(
answer(PathRequest::Truncate { length: -1 }),
Err(Errno::EINVAL)
);
assert_eq!(answer(PathRequest::Chmod { flags: 0 }), Err(Errno::EPERM));
for explicit in [None, Some(false), Some(true)] {
assert_eq!(answer(PathRequest::Times { explicit }), Ok(0));
}
let change = |name: &[u8]| {
path_request_answer(
PathRequest::ChangeXattr {
size: Some(1),
value: 0,
flags: 0,
},
Some(name),
Some(&b"1"[..]),
access,
)
};
assert_eq!(change(b"user.x"), Err(xattr));
assert_eq!(change(b"security.x"), Err(security));
assert_eq!(change(b"trusted.x"), Err(Errno::EPERM));
assert_eq!(
xattr_change_answer(b"user.x", None, None, access),
Err(xattr)
);
}
}
#[test]
fn a_process_file_maps_as_a_file_without_mmap() {
let read = ProtFlags::PROT_READ;
let write = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE;
let check = |prot, flags, seq_file, mode| {
rendered_mmap_file_checks(4096, 0, prot, flags, false, seq_file, mode)
};
let private = MapFlags::MAP_PRIVATE;
let shared = MapFlags::MAP_SHARED;
assert_eq!(check(read, private, false, (true, false)), Errno::ENODEV);
assert_eq!(check(write, shared, false, (true, true)), Errno::ENODEV);
assert_eq!(check(write, shared, false, (true, false)), Errno::EACCES);
assert_eq!(check(read, private, false, (false, true)), Errno::EACCES);
assert_eq!(check(read, shared, false, (false, true)), Errno::EACCES);
assert_eq!(
check(read, private | MapFlags::MAP_GROWSDOWN, false, (true, true)),
Errno::ENODEV
);
assert_eq!(check(read, private, true, (true, false)), Errno::EIO);
}
#[test]
fn a_process_file_exists_for_exactly_the_tasks_the_table_lists() {
use crate::procfs::BoundTask;
use crate::procfs::listing::ListingFacts;
let facts = ListingFacts {
processes: vec![1, 3, 7],
threads: vec![3, 5],
};
let task = |process, thread| BoundTask { process, thread };
assert!(crate::procfs::listing::task_exists(
task(3, None),
Some(3),
&facts
));
assert!(crate::procfs::listing::task_exists(
task(3, Some(5)),
Some(3),
&facts
));
assert!(!crate::procfs::listing::task_exists(
task(3, Some(6)),
Some(3),
&facts
));
assert!(crate::procfs::listing::task_exists(
task(5, None),
Some(3),
&facts
));
assert!(crate::procfs::listing::task_exists(
task(5, Some(3)),
Some(3),
&facts
));
assert!(!crate::procfs::listing::task_exists(
task(9, None),
Some(9),
&facts
));
assert!(!crate::procfs::listing::task_exists(
task(11, None),
None,
&facts
));
let without_init = ListingFacts {
processes: vec![3],
threads: Vec::new(),
};
assert!(crate::procfs::listing::task_exists(
task(1, None),
None,
&without_init
));
assert!(crate::procfs::listing::task_exists(
task(1, Some(1)),
None,
&without_init
));
assert!(!crate::procfs::listing::task_exists(
task(1, Some(2)),
None,
&without_init
));
}
#[test]
fn a_process_auxv_is_readable_by_its_owner_only() {
let mut file = crate::procfs::ProcfsFile::from_path(Path::new("/proc/self/auxv")).unwrap();
file.bind_task(3, 3);
let path = file.into_rendered().opened_path().unwrap();
assert!(rendered_path_is_owner_only(path));
let mut cgroup =
crate::procfs::ProcfsFile::from_path(Path::new("/proc/self/cgroup")).unwrap();
cgroup.bind_task(3, 3);
assert!(!rendered_path_is_owner_only(
cgroup.into_rendered().opened_path().unwrap()
));
assert!(!rendered_path_is_owner_only(Path::new("/proc/stat")));
let epoch = Timespec {
tv_sec: 0,
tv_nsec: 0,
};
assert_eq!(
rendered_stat(path, epoch, (0, 0)).mode,
libc::S_IFREG | 0o400
);
let owner = FileAccess::owned_with(ALL_CAPABILITIES);
assert_eq!(
rendered_open_flags(OFlag::O_RDONLY, owner),
Ok(OFlag::O_RDONLY)
);
assert_eq!(rendered_open_flags(OFlag::O_RDWR, owner), Ok(OFlag::O_RDWR));
let zombie = FileAccess {
readable: false,
..FileAccess::GLOBAL_ROOT
};
for flags in [
OFlag::O_RDONLY,
OFlag::O_WRONLY,
OFlag::O_RDWR,
OFlag::O_ACCMODE,
] {
assert_eq!(rendered_open_flags(flags, zombie), Err(Errno::EACCES));
}
assert_eq!(
rendered_open_flags(OFlag::O_PATH, zombie),
Ok(OFlag::O_PATH)
);
let probe = |mode: i32| {
path_request_answer(
PathRequest::Access {
mode: mode as u64,
flags: 0,
},
None,
None,
zombie,
)
};
assert_eq!(probe(libc::F_OK), Ok(0));
assert_eq!(probe(libc::R_OK), Err(Errno::EACCES));
let get =
|name: &[u8]| path_request_answer(PathRequest::GetXattr, Some(name), None, zombie);
assert_eq!(get(b"user.x"), Err(Errno::EACCES));
assert_eq!(get(b"security.x"), Err(Errno::EOPNOTSUPP));
assert_eq!(get(b"trusted.x"), Err(Errno::ENODATA));
}
#[test]
fn another_process_opens_auxv_as_the_kernel_beneath_answers() {
use AuxvAccess::Answer;
use AuxvAccess::CallerCapability;
for serves in [Ok(()), Err(Errno::EACCES), Err(Errno::EMFILE)] {
assert_eq!(auxv_access_answer(Ok(()), serves), Answer(Ok(())));
}
for refused in [Errno::EACCES, Errno::EPERM, Errno::ESRCH, Errno::EMFILE] {
assert_eq!(
auxv_access_answer(Err(refused), Ok(())),
Answer(Err(refused))
);
}
assert_eq!(
auxv_access_answer(Err(Errno::EACCES), Err(Errno::EACCES)),
CallerCapability
);
for operational in [Errno::EMFILE, Errno::ENFILE, Errno::ENOMEM] {
assert_eq!(
auxv_access_answer(Err(operational), Err(operational)),
Answer(Err(operational))
);
assert_eq!(
auxv_access_answer(Err(Errno::EACCES), Err(operational)),
Answer(Err(operational))
);
}
}
#[test]
fn a_process_file_is_owned_by_the_guest_and_named_by_path_calls() {
assert_eq!(rendered_owner(Path::new("/proc/3/cgroup")), Ok((0, 0)));
assert_eq!(
rendered_owner(Path::new("/proc/3/task/5/cgroup")),
Ok((0, 0))
);
let stat = rendered_stat(
Path::new("/proc/3/cgroup"),
Timespec {
tv_sec: 0,
tv_nsec: 0,
},
(0, 0),
);
assert_eq!(stat.mode, libc::S_IFREG | 0o444);
assert_eq!(
stat.inode,
procfs_inode::rendered_inode(Path::new("/proc/3/cgroup"))
);
assert_ne!(
stat.inode,
procfs_inode::rendered_inode(Path::new("/proc/3/task/3/cgroup"))
);
assert!(could_name_rendered(
Path::new("/proc/self/cgroup"),
RenderedFiles::WITHOUT_CPUINFO
));
assert!(could_name_rendered(
Path::new("cgroup"),
RenderedFiles::WITHOUT_CPUINFO
));
}
}