use std::os::fd::AsRawFd;
use std::os::unix::ffi::OsStringExt;
use std::os::unix::fs::FileExt;
use std::os::unix::fs::FileTypeExt;
use std::os::unix::fs::OpenOptionsExt;
use reverie::Errno;
use reverie::Guest;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::Ftruncate;
use reverie::syscalls::Getcwd;
use reverie::syscalls::Getdents;
use reverie::syscalls::Getdents64;
use reverie::syscalls::Ioctl;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::Pread64;
use reverie::syscalls::Read;
use reverie::syscalls::ReadAddr;
use reverie::syscalls::Readlink;
use reverie::syscalls::Statx;
use reverie::syscalls::Syscall;
use reverie::syscalls::family::StatFamily;
use reverie::syscalls::family::WriteFamily;
use reverie::syscalls::ioctl;
use super::Recorder;
use crate::event::FileCloneEvent;
use crate::event::FileCloneImage;
use crate::event::FileExtent;
use crate::event::FtruncateEvent;
use crate::event::ReadEvent;
use crate::event::ReplayFdKind;
use crate::event::StatEvent;
use crate::event::SyscallEvent;
use crate::event::WriteEvent;
use crate::event::deterministic_ioctl_error;
use crate::event::xattr_query_output;
use crate::vectored_offset;
fn read_iovec_output<M: MemoryAccess>(
memory: &M,
iov_addr: Option<usize>,
iovcnt: usize,
length: usize,
) -> Result<Vec<u8>, Errno> {
let mut buf = vec![0u8; length];
if length == 0 {
return Ok(buf);
}
let addr = iov_addr
.and_then(Addr::<libc::iovec>::from_raw)
.ok_or(Errno::EFAULT)?;
let mut iovecs = vec![
libc::iovec {
iov_base: std::ptr::null_mut(),
iov_len: 0,
};
iovcnt
];
memory.read_values(addr, &mut iovecs)?;
let mut filled = 0;
for iovec in iovecs {
if filled == length {
break;
}
let take = (length - filled).min(iovec.iov_len);
if take == 0 {
continue;
}
let src = Addr::<u8>::from_raw(iovec.iov_base as usize).ok_or(Errno::EFAULT)?;
memory.read_exact(src, &mut buf[filled..filled + take])?;
filled += take;
}
Ok(buf)
}
fn consumed_sigpipe_count(pid: libc::pid_t, fd: libc::c_int, bytes: &[u8]) -> u64 {
let path = format!("/proc/{pid}/fd/{fd}");
if !std::fs::read_link(path)
.is_ok_and(|target| target == std::path::Path::new("anon_inode:[signalfd]"))
{
return 0;
}
let (records, _) = bytes.as_chunks::<{ std::mem::size_of::<libc::signalfd_siginfo>() }>();
records
.iter()
.filter(|info| {
u32::from_ne_bytes(info[..std::mem::size_of::<u32>()].try_into().unwrap())
== libc::SIGPIPE as u32
})
.count()
.try_into()
.expect("SIGPIPE signalfd record count overflow")
}
fn write_advances_output_offset(syscall: WriteFamily) -> bool {
match syscall {
WriteFamily::Write(_) | WriteFamily::Writev(_) => true,
WriteFamily::Pwritev2(call) => vectored_offset(call.pos_l(), call.pos_h()) == -1,
WriteFamily::Pwrite64(_) | WriteFamily::Pwritev(_) => false,
}
}
fn uses_append_offset(status_flags: libc::c_int, write_flags: libc::c_int) -> bool {
write_flags & libc::RWF_APPEND != 0
|| (status_flags & libc::O_APPEND != 0 && write_flags & libc::RWF_NOAPPEND == 0)
}
#[cfg(test)]
fn shares_open_file_description(left: libc::c_int, right: libc::c_int) -> bool {
match crate::fd::same_open_file_description(left, right) {
Ok(shared) => shared,
Err(error) => {
tracing::debug!(
%error,
left,
right,
"could not compare captured open-file descriptions"
);
false
}
}
}
fn output_file_offset(
pid: libc::pid_t,
syscall: WriteFamily,
metadata: &std::fs::Metadata,
count: i64,
) -> Option<i64> {
if !metadata.file_type().is_file() {
return None;
}
let fdinfo = std::fs::read_to_string(format!("/proc/{pid}/fdinfo/{}", syscall.fd())).ok()?;
let position = fdinfo
.lines()
.find_map(|line| line.strip_prefix("pos:\t"))
.and_then(|value| value.parse::<i64>().ok())?;
let status_flags = fdinfo
.lines()
.find_map(|line| line.strip_prefix("flags:\t"))
.and_then(|value| i32::from_str_radix(value, 8).ok())
.unwrap_or_default();
let write_flags = match syscall {
WriteFamily::Pwritev2(call) => call.flags(),
_ => 0,
};
if uses_append_offset(status_flags, write_flags) {
return i64::try_from(metadata.len()).ok()?.checked_sub(count);
}
match syscall {
WriteFamily::Pwrite64(call) => Some(call.offset()),
WriteFamily::Pwritev(call) => Some(vectored_offset(call.pos_l(), call.pos_h())),
WriteFamily::Pwritev2(call) => {
let offset = vectored_offset(call.pos_l(), call.pos_h());
(offset != -1)
.then_some(offset)
.or_else(|| position.checked_sub(count))
}
WriteFamily::Write(_) | WriteFamily::Writev(_) => position.checked_sub(count),
}
}
const MAX_CLONE_SNAPSHOT_BYTES: u64 = 64 * 1024 * 1024;
const MAX_CLONE_SIDECAR_BYTES: u64 = 1024 * 1024 * 1024;
const CLONE_COPY_CHUNK_BYTES: usize = 1024 * 1024;
fn read_dense_clone_snapshot(
file: &std::fs::File,
source_offset: u64,
length: u64,
) -> std::io::Result<FileCloneImage> {
if length > MAX_CLONE_SNAPSHOT_BYTES {
return Err(std::io::Error::new(
std::io::ErrorKind::FileTooLarge,
format!("clone snapshot is {length} bytes; limit is {MAX_CLONE_SNAPSHOT_BYTES}"),
));
}
let mut bytes = vec![0; length as usize];
file.read_exact_at(&mut bytes, source_offset)?;
Ok(FileCloneImage::Extents(
(!bytes.is_empty())
.then_some(FileExtent { offset: 0, bytes })
.into_iter()
.collect(),
))
}
fn clone_snapshot(
file: &std::fs::File,
source_offset: u64,
length: u64,
) -> std::io::Result<FileCloneImage> {
let mut extents = Vec::new();
let mut total = 0u64;
let mut cursor = source_offset;
let end = source_offset.checked_add(length).ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"clone source range overflow",
)
})?;
while cursor < end {
let data = unsafe {
libc::lseek(
file.as_raw_fd(),
cursor.try_into().unwrap(),
libc::SEEK_DATA,
)
};
if data == -1 {
let error = std::io::Error::last_os_error();
if error.raw_os_error() == Some(libc::ENXIO) {
break;
}
if error.raw_os_error() == Some(libc::EINVAL) {
return read_dense_clone_snapshot(file, source_offset, length);
}
return Err(error);
}
let hole = unsafe { libc::lseek(file.as_raw_fd(), data, libc::SEEK_HOLE) };
if hole == -1 {
let error = std::io::Error::last_os_error();
if error.raw_os_error() != Some(libc::ENXIO) {
return Err(error);
}
}
let data = data as u64;
let hole = if hole == -1 {
end
} else {
(hole as u64).min(end)
};
if data >= end {
break;
}
let extent_length = hole.saturating_sub(data);
total = total.checked_add(extent_length).ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::FileTooLarge,
"clone snapshot size overflow",
)
})?;
if total > MAX_CLONE_SNAPSHOT_BYTES {
return Err(std::io::Error::new(
std::io::ErrorKind::FileTooLarge,
format!(
"clone data extents total {total} bytes; limit is {MAX_CLONE_SNAPSHOT_BYTES}"
),
));
}
let mut bytes = vec![0; extent_length as usize];
file.read_exact_at(&mut bytes, data)?;
extents.push(FileExtent {
offset: data - source_offset,
bytes,
});
cursor = hole;
}
Ok(FileCloneImage::Extents(extents))
}
fn spool_clone_snapshot(
source: &std::fs::File,
source_offset: u64,
length: u64,
data: &std::path::Path,
) -> std::io::Result<FileCloneImage> {
let directory = data.join("clone");
std::fs::create_dir_all(&directory)?;
let sidecar = tempfile::Builder::new()
.prefix("image-")
.tempfile_in(&directory)?;
sidecar.as_file().set_len(length)?;
let mut total = 0u64;
let mut cursor = source_offset;
let end = source_offset.checked_add(length).ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"clone source range overflow",
)
})?;
let mut buffer = vec![0; CLONE_COPY_CHUNK_BYTES];
while cursor < end {
let data_offset = unsafe {
libc::lseek(
source.as_raw_fd(),
cursor.try_into().unwrap(),
libc::SEEK_DATA,
)
};
let (data_offset, hole) = if data_offset == -1 {
let error = std::io::Error::last_os_error();
match error.raw_os_error() {
Some(libc::ENXIO) => break,
Some(libc::EINVAL) => (source_offset, end),
_ => return Err(error),
}
} else {
let hole = unsafe { libc::lseek(source.as_raw_fd(), data_offset, libc::SEEK_HOLE) };
if hole == -1 {
let error = std::io::Error::last_os_error();
if error.raw_os_error() != Some(libc::ENXIO) {
return Err(error);
}
}
(
data_offset as u64,
if hole == -1 {
end
} else {
(hole as u64).min(end)
},
)
};
let extent_length = hole.saturating_sub(data_offset);
if data_offset >= end {
break;
}
total = total.checked_add(extent_length).ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::FileTooLarge,
"clone sidecar size overflow",
)
})?;
if total > MAX_CLONE_SIDECAR_BYTES {
return Err(std::io::Error::new(
std::io::ErrorKind::FileTooLarge,
format!(
"clone sidecar data exceeds {MAX_CLONE_SIDECAR_BYTES} byte recording quota"
),
));
}
let mut offset = data_offset;
while offset < hole {
let count = usize::try_from((hole - offset).min(buffer.len() as u64)).unwrap();
source.read_exact_at(&mut buffer[..count], offset)?;
sidecar
.as_file()
.write_all_at(&buffer[..count], offset - source_offset)?;
offset += count as u64;
}
cursor = hole;
}
sidecar.as_file().sync_data()?;
let (_, path) = sidecar.keep().map_err(|error| error.error)?;
let relative = path.strip_prefix(data).map_err(|error| {
std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!("clone sidecar escaped recording directory: {error}"),
)
})?;
Ok(FileCloneImage::Sidecar(
relative.to_string_lossy().into_owned(),
))
}
fn capture_clone_snapshot(
source: &std::fs::File,
source_offset: u64,
length: u64,
data: &std::path::Path,
) -> std::io::Result<FileCloneImage> {
let inline_error = match clone_snapshot(source, source_offset, length) {
Ok(snapshot) => return Ok(snapshot),
Err(error) => error,
};
tracing::warn!(
error = %inline_error,
"inline clone snapshot unavailable; spooling sparse replay sidecar"
);
spool_clone_snapshot(source, source_offset, length, data)
}
fn private_clone_snapshot(
pid: reverie::Pid,
destination_fd: libc::c_int,
source: &std::fs::File,
source_offset: u64,
length: u64,
) -> std::io::Result<std::fs::File> {
let destination = std::fs::read_link(format!("/proc/{}/fd/{destination_fd}", pid.as_raw()))?;
let relative = destination.strip_prefix("/").map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!("clone destination is not an absolute path: {destination:?}"),
)
})?;
let parent = relative.parent().ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!("clone destination has no parent: {destination:?}"),
)
})?;
let parent = std::path::PathBuf::from(format!("/proc/{}/root", pid.as_raw())).join(parent);
let private = std::fs::OpenOptions::new()
.read(true)
.write(true)
.custom_flags(libc::O_TMPFILE | libc::O_CLOEXEC)
.mode(0o600)
.open(&parent)?;
if length == 0 {
return Ok(private);
}
let range = libc::file_clone_range {
src_fd: source.as_raw_fd() as i64,
src_offset: source_offset,
src_length: length,
dest_offset: 0,
};
let result = unsafe {
libc::ioctl(
private.as_raw_fd(),
libc::FICLONERANGE,
std::ptr::addr_of!(range),
)
};
if result == -1 {
return Err(std::io::Error::last_os_error());
}
Ok(private)
}
impl Recorder {
pub(super) async fn handle_readv_family<G: Guest<Self>>(
&self,
guest: &mut G,
iov_addr: Option<usize>,
iovcnt: usize,
fd: libc::c_int,
syscall: Syscall,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|length| {
let bytes = read_iovec_output(&guest.memory(), iov_addr, iovcnt, length as usize)?;
Ok(SyscallEvent::ReadvV2(ReadEvent {
consumed_sigpipe_count: consumed_sigpipe_count(
guest.pid().as_raw(),
fd,
&bytes,
),
replay_fd_kind: self.fd_replay_kind(guest.pid(), fd),
bytes,
}))
}),
);
result
}
pub(super) async fn handle_read<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Read,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|length| {
let mut buf = vec![0; length as usize];
if !buf.is_empty() {
let addr = syscall.buf().ok_or(Errno::EFAULT)?;
guest.memory().read_exact(addr, &mut buf)?;
}
Ok(SyscallEvent::ReadV2(ReadEvent {
consumed_sigpipe_count: consumed_sigpipe_count(
guest.pid().as_raw(),
syscall.fd(),
&buf,
),
bytes: buf,
replay_fd_kind: self.fd_replay_kind(guest.pid(), syscall.fd()),
}))
}),
);
result
}
pub(super) async fn handle_pread64<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Pread64,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|length| {
let mut buf = vec![0; length as usize];
if !buf.is_empty() {
let addr = syscall.buf().ok_or(Errno::EFAULT)?;
guest.memory().read_exact(addr, &mut buf)?;
}
Ok(SyscallEvent::Bytes(buf))
}),
);
result
}
pub(super) async fn handle_write_family<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: WriteFamily,
) -> Result<i64, Errno> {
let result = guest.inject(Syscall::from(syscall)).await;
let metadata = std::fs::metadata(format!(
"/proc/{}/fd/{}",
guest.pid().as_raw(),
syscall.fd()
))
.ok();
let (output_fd, shares_output_ofd) = metadata.as_ref().map_or((None, false), |metadata| {
let stdout_matches = self
.stdout
.is_some_and(|identity| identity.matches(metadata));
let stderr_matches = self
.stderr
.is_some_and(|identity| identity.matches(metadata));
let candidate = (metadata.file_type().is_file() && (stdout_matches || stderr_matches))
.then(|| crate::fd::duplicate_guest_fd(guest.pid(), syscall.fd()).ok())
.flatten();
let stdout_shares = stdout_matches
&& candidate.as_ref().is_some_and(|candidate| {
self.output_ofd_matches(libc::STDOUT_FILENO, candidate)
});
let stderr_shares = stderr_matches
&& candidate.as_ref().is_some_and(|candidate| {
self.output_ofd_matches(libc::STDERR_FILENO, candidate)
});
if stdout_shares {
(Some(libc::STDOUT_FILENO), true)
} else if stderr_shares {
(Some(libc::STDERR_FILENO), true)
} else if stdout_matches {
(Some(libc::STDOUT_FILENO), false)
} else if stderr_matches {
(Some(libc::STDERR_FILENO), false)
} else {
(None, false)
}
});
let file_offset = match (result, metadata.as_ref()) {
(Ok(count), Some(metadata)) => {
output_file_offset(guest.pid().as_raw(), syscall, metadata, count)
}
_ => None,
};
let output_offset = output_fd.and(file_offset);
let advances_output_offset =
output_offset.is_some() && shares_output_ofd && write_advances_output_offset(syscall);
let generated_sigpipe = result == Err(Errno::EPIPE)
&& metadata.is_some_and(|metadata| {
metadata.file_type().is_fifo() || metadata.file_type().is_socket()
});
let replay_fd_kind = if result.is_ok() && output_fd.is_none() {
self.fd_replay_kind(guest.pid(), syscall.fd())
} else {
ReplayFdKind::None
};
let replay_file_offset = (replay_fd_kind == ReplayFdKind::RegularFile)
.then_some(file_offset)
.flatten();
let replay_file_advances_offset =
replay_file_offset.is_some() && write_advances_output_offset(syscall);
self.record_event(
guest,
Ok(SyscallEvent::WriteV2(WriteEvent {
result,
output_fd,
output_offset,
generated_sigpipe,
advances_output_offset,
replay_fd_kind,
replay_file_offset,
replay_file_advances_offset,
})),
);
result
}
pub(super) async fn handle_ftruncate<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Ftruncate,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
let metadata = std::fs::metadata(format!(
"/proc/{}/fd/{}",
guest.pid().as_raw(),
syscall.fd()
))
.ok();
let output_fd = if result.is_ok() {
metadata.as_ref().and_then(|metadata| {
if self
.stdout
.is_some_and(|identity| identity.matches(metadata))
{
Some(libc::STDOUT_FILENO)
} else if self
.stderr
.is_some_and(|identity| identity.matches(metadata))
{
Some(libc::STDERR_FILENO)
} else {
None
}
})
} else {
None
};
self.record_event(
guest,
Ok(SyscallEvent::FtruncateV2(FtruncateEvent {
result,
output_fd,
length: syscall.length(),
replay_regular_file: result.is_ok()
&& metadata.is_some_and(|metadata| metadata.file_type().is_file()),
})),
);
result
}
pub(super) async fn handle_stat_family<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: StatFamily,
) -> Result<i64, Errno> {
let result = guest.inject(Syscall::from(syscall)).await;
self.record_event(
guest,
result.and_then(|ret| {
debug_assert_eq!(ret, 0);
let statbuf = syscall.stat().ok_or(Errno::EFAULT)?.read(&guest.memory())?;
Ok(SyscallEvent::Stat(StatEvent { statbuf }))
}),
);
result
}
pub(super) async fn handle_statfs<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Syscall,
buf: Option<AddrMut<'_, libc::statfs>>,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|ret| {
debug_assert_eq!(ret, 0);
let mut bytes = vec![0; std::mem::size_of::<libc::statfs>()];
guest
.memory()
.read_exact(buf.ok_or(Errno::EFAULT)?.cast(), &mut bytes)?;
Ok(SyscallEvent::Statfs(bytes))
}),
);
result
}
pub(super) async fn handle_statx<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Statx,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|ret| {
debug_assert_eq!(ret, 0);
let statbuf = syscall
.statx()
.ok_or(Errno::EFAULT)?
.read(&guest.memory())?;
Ok(SyscallEvent::Statx(statbuf.into()))
}),
);
result
}
pub(super) async fn handle_ioctl<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Ioctl,
) -> Result<i64, Errno> {
let request = syscall.request();
if let Some(error) = deterministic_ioctl_error(&request) {
self.record_event(guest, Err(error));
return Err(error);
}
let ret = guest.inject(syscall).await.inspect_err(|&err| {
self.record_event(guest, Err(err));
})?;
if matches!(
request,
ioctl::Request::FICLONE(_) | ioctl::Request::FICLONERANGE(_)
) {
let (source_fd, source_offset, requested_length, destination_offset, truncate) =
match request {
ioctl::Request::FICLONE(fd) => (fd, 0, None, 0, true),
ioctl::Request::FICLONERANGE(Some(address)) => {
let range: libc::file_clone_range = guest
.memory()
.read_value(address)
.expect("successful FICLONERANGE has a readable argument");
(
range.src_fd as libc::c_int,
range.src_offset,
(range.src_length != 0).then_some(range.src_length),
range.dest_offset,
false,
)
}
ioctl::Request::FICLONERANGE(None) => {
unreachable!("successful FICLONERANGE has a non-null argument")
}
_ => unreachable!(),
};
let source = std::fs::File::from(
crate::fd::duplicate_guest_fd(guest.pid(), source_fd)
.expect("failed to duplicate clone source descriptor"),
);
let source_length = source
.metadata()
.expect("failed to stat clone source descriptor")
.len();
let replacement_length = requested_length.unwrap_or_else(|| {
source_length
.checked_sub(source_offset)
.expect("successful clone source offset exceeds file length")
});
let private = private_clone_snapshot(
guest.pid(),
syscall.fd(),
&source,
source_offset,
replacement_length,
)
.unwrap_or_else(|error| panic!("failed to make private clone snapshot: {error}"));
let image = capture_clone_snapshot(&private, 0, replacement_length, &self.data)
.unwrap_or_else(|error| panic!("failed to snapshot private clone: {error}"));
let destination_path = format!("/proc/{}/fd/{}", guest.pid().as_raw(), syscall.fd());
let length = std::fs::metadata(&destination_path)
.unwrap_or_else(|error| {
panic!("failed to stat cloned destination {destination_path}: {error}")
})
.len();
self.record_event(
guest,
Ok(SyscallEvent::FileClone(FileCloneEvent {
length,
destination_offset,
replacement_length,
truncate_destination: truncate,
image,
})),
);
} else if matches!(
request,
ioctl::Request::FIOCLEX | ioctl::Request::FIONCLEX | ioctl::Request::FIONBIO(_)
) {
self.record_event(guest, Ok(SyscallEvent::Return(ret)));
} else if let Some(output) = request.read_output(&guest.memory()).transpose() {
self.record_event(guest, output.map(SyscallEvent::Ioctl));
} else {
self.record_event(guest, Ok(SyscallEvent::Return(ret)));
}
Ok(ret)
}
pub(super) async fn handle_readlink<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Readlink,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|length| {
let mut buf = vec![0; length as usize];
let addr = syscall.buf().ok_or(Errno::EFAULT)?.cast::<u8>();
guest.memory().read_exact(addr, &mut buf)?;
Ok(SyscallEvent::Bytes(buf))
}),
);
result
}
pub(super) async fn handle_xattr_query<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Syscall,
) -> Result<i64, Errno> {
let (buf, size) = xattr_query_output(&syscall)
.unwrap_or_else(|| unreachable!("xattr query recording called for {syscall:?}"));
let result = guest.inject(syscall).await;
if size == 0 {
self.record_event(guest, result.map(SyscallEvent::Return));
} else {
self.record_event(
guest,
result.and_then(|length| {
let mut bytes = vec![0; length as usize];
if !bytes.is_empty() {
guest
.memory()
.read_exact(buf.ok_or(Errno::EFAULT)?, &mut bytes)?;
}
Ok(SyscallEvent::Bytes(bytes))
}),
);
}
result
}
pub(super) async fn handle_getcwd<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Getcwd,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|length| {
let mut buf = vec![0; length as usize];
let addr = syscall.buf().ok_or(Errno::EFAULT)?.cast::<u8>();
guest.memory().read_exact(addr, &mut buf)?;
Ok(SyscallEvent::Bytes(buf))
}),
);
result
}
pub(super) async fn handle_working_directory_change<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Syscall,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.map(|_| {
let cwd = crate::record_replay_path::process_cwd_path(guest.tid()).unwrap_or_else(
|error| panic!("could not record the directory {syscall:?} entered: {error}"),
);
SyscallEvent::Bytes(cwd.into_os_string().into_vec())
}),
);
result
}
pub(super) async fn handle_getdents<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Getdents,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|length| {
let mut buf = vec![0; length as usize];
let addr = syscall.dirent().ok_or(Errno::EFAULT)?.cast::<u8>();
guest.memory().read_exact(addr, &mut buf)?;
Ok(SyscallEvent::Bytes(buf))
}),
);
result
}
pub(super) async fn handle_getdents64<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Getdents64,
) -> Result<i64, Errno> {
let result = guest.inject(syscall).await;
self.record_event(
guest,
result.and_then(|length| {
let mut buf = vec![0; length as usize];
let addr = syscall.dirent().ok_or(Errno::EFAULT)?.cast::<u8>();
guest.memory().read_exact(addr, &mut buf)?;
Ok(SyscallEvent::Bytes(buf))
}),
);
result
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn vectored_offsets_combine_both_abi_halves() {
if std::mem::size_of::<usize>() == 8 {
assert_eq!(vectored_offset(0x1_0000_0002, 0), 0x1_0000_0002);
assert_eq!(vectored_offset(u64::MAX, 0), -1);
} else {
assert_eq!(vectored_offset(2, 1), 0x1_0000_0002);
assert_eq!(vectored_offset(u32::MAX as u64, u32::MAX as u64), -1);
}
}
#[test]
fn rwf_noappend_overrides_descriptor_append_mode() {
assert!(uses_append_offset(libc::O_APPEND, 0));
assert!(uses_append_offset(0, libc::RWF_APPEND));
assert!(!uses_append_offset(libc::O_APPEND, libc::RWF_NOAPPEND));
}
#[test]
fn kcmp_distinguishes_dup_from_reopened_file() {
use std::os::fd::AsRawFd as _;
use std::os::fd::FromRawFd as _;
let file = tempfile::NamedTempFile::new().unwrap();
let original = file.as_file().as_raw_fd();
let duplicate =
unsafe { libc::fcntl(original, libc::F_DUPFD_CLOEXEC, libc::STDERR_FILENO + 1) };
assert_ne!(duplicate, -1);
let duplicate = unsafe { std::os::fd::OwnedFd::from_raw_fd(duplicate) };
let reopened = std::fs::OpenOptions::new()
.read(true)
.write(true)
.open(file.path())
.unwrap();
assert!(shares_open_file_description(
original,
duplicate.as_raw_fd()
));
assert!(!shares_open_file_description(
original,
reopened.as_raw_fd()
));
}
}