use reverie::Errno;
use reverie::RdtscResult;
use reverie::syscalls::AddrMut;
use reverie::syscalls::PollFd;
use reverie::syscalls::StatBuf;
use reverie::syscalls::StatxBuf;
use reverie::syscalls::Syscall;
use reverie::syscalls::Timespec;
use reverie::syscalls::Timeval;
use reverie::syscalls::Timezone;
use reverie::syscalls::ioctl;
use serde::Deserialize;
use serde::Serialize;
const SIOCETHTOOL: usize = 0x8946;
pub(crate) fn deterministic_ioctl_error(request: &ioctl::Request<'_>) -> Option<Errno> {
match request {
ioctl::Request::SIOCETHTOOL(_) | ioctl::Request::Other(SIOCETHTOOL, _) => {
Some(Errno::ENODEV)
}
_ => None,
}
}
pub(crate) fn xattr_query_output(syscall: &Syscall) -> Option<(Option<AddrMut<'_, u8>>, usize)> {
match syscall {
Syscall::Getxattr(call) => Some((call.value().map(|a| a.cast()), call.size())),
Syscall::Lgetxattr(call) => Some((call.value().map(|a| a.cast()), call.size())),
Syscall::Fgetxattr(call) => Some((call.value().map(|a| a.cast()), call.size())),
Syscall::Listxattr(call) => Some((call.list().map(|a| a.cast()), call.size())),
Syscall::Llistxattr(call) => Some((call.list().map(|a| a.cast()), call.size())),
Syscall::Flistxattr(call) => Some((call.list().map(|a| a.cast()), call.size())),
_ => None,
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Event {
pub event: Result<SyscallEvent, Errno>,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum SyscallEvent {
Bytes(Vec<u8>),
Readv(Vec<u8>),
Write(i64),
Mmap(MmapEvent),
Recvmsg(RecvmsgEvent),
Return(i64),
Stat(StatEvent),
Statfs(Vec<u8>),
Statx(StatxBuf),
Rdtsc(RdtscResult),
Ioctl(ioctl::Output),
Timespec(TimespecEvent),
Timeofday((Timeval, Timezone)),
Poll(PollEvent),
SockOpt(SockOptEvent),
EpollWait(EpollWaitEvent),
Open(OpenEvent),
Mkdir(MkdirEvent),
WriteV2(WriteEvent),
ReadV2(ReadEvent),
ReadvV2(ReadEvent),
FtruncateV2(FtruncateEvent),
FileClone(FileCloneEvent),
Exec(ExecEvent),
Ppoll(PpollEvent),
Select(SelectEvent),
Madvise(MadviseEvent),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ReadEvent {
pub bytes: Vec<u8>,
pub consumed_sigpipe_count: u64,
pub replay_fd_kind: ReplayFdKind,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WriteEvent {
pub result: Result<i64, Errno>,
pub output_fd: Option<i32>,
pub output_offset: Option<i64>,
pub advances_output_offset: bool,
pub generated_sigpipe: bool,
pub replay_fd_kind: ReplayFdKind,
pub replay_file_offset: Option<i64>,
pub replay_file_advances_offset: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FtruncateEvent {
pub result: Result<i64, Errno>,
pub output_fd: Option<i32>,
pub length: libc::off_t,
pub replay_regular_file: bool,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum ReplayFdKind {
None,
Eventfd,
RegularFile,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct OpenEvent {
pub result: Result<i64, Errno>,
pub materialize: OpenMaterialization,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum OpenMaterialization {
None,
RegularFile,
Directory,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MkdirEvent {
pub result: Result<i64, Errno>,
pub existing_directory: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ExecEvent {
pub(crate) request: ExecRequest,
pub(crate) executable: ExecImage,
pub(crate) target: ExecTarget,
pub(crate) dependencies: Vec<ExecDependency>,
}
#[derive(Debug, Deserialize, Eq, PartialEq, Serialize)]
pub(crate) struct ExecRequest {
pub(crate) dirfd: libc::c_int,
pub(crate) path: Vec<u8>,
pub(crate) flags: libc::c_int,
}
#[derive(Debug, Serialize, Deserialize)]
pub(crate) struct ExecImage {
pub(crate) digest: detcore::Digest,
pub(crate) mode: u32,
}
#[derive(Debug, Serialize, Deserialize)]
pub(crate) struct ExecDescriptor {
pub(crate) target_fd: libc::c_int,
pub(crate) status_flags: libc::c_int,
pub(crate) offset: Option<libc::off_t>,
pub(crate) aliases: Vec<ExecDescriptorAlias>,
}
#[derive(Debug, Serialize, Deserialize)]
pub(crate) struct ExecDescriptorAlias {
pub(crate) fd: libc::c_int,
pub(crate) descriptor_flags: libc::c_int,
}
#[derive(Debug, Serialize, Deserialize)]
pub(crate) enum ExecTarget {
Materialize(ExecMaterialization),
VerifyLive,
RestoreDescriptor(ExecDescriptor),
}
#[derive(Debug, Serialize, Deserialize)]
pub(crate) struct ExecMaterialization {
pub(crate) base: ExecMaterializationBase,
pub(crate) path: Vec<u8>,
pub(crate) symlinks: Vec<crate::record_replay_path::ResolvedSymlink>,
}
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
pub(crate) enum ExecMaterializationBase {
Root,
Cwd,
DirectoryFd(libc::c_int),
}
#[derive(Debug, Serialize, Deserialize)]
pub(crate) struct ExecDependency {
pub(crate) base: ExecMaterializationBase,
pub(crate) path: Vec<u8>,
pub(crate) image: ExecImage,
pub(crate) symlinks: Vec<crate::record_replay_path::ResolvedSymlink>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FileCloneEvent {
pub length: u64,
pub destination_offset: u64,
pub replacement_length: u64,
pub truncate_destination: bool,
pub image: FileCloneImage,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum FileCloneImage {
Extents(Vec<FileExtent>),
Sidecar(String),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FileExtent {
pub offset: u64,
pub bytes: Vec<u8>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MmapEvent {
pub addr: usize,
pub buf: Vec<u8>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MadviseEvent {
pub result: Result<i64, Errno>,
pub live_len: usize,
pub refills: Vec<MadviseRefill>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MadviseRefill {
pub addr: usize,
pub bytes: Vec<u8>,
pub prot: i32,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RecvmsgEvent {
pub result: i64,
pub iovs: Vec<Vec<u8>>,
pub name: Vec<u8>,
pub name_len: libc::socklen_t,
pub control: Vec<u8>,
pub control_len: usize,
pub flags: libc::c_int,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct StatEvent {
#[serde(with = "StatBuf")]
pub statbuf: libc::stat,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TimespecEvent {
pub timespec: Timespec,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct PollEvent {
pub result: Result<i64, Errno>,
pub fds_pointer_present: bool,
pub fds: Option<Vec<PollFd>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct PpollEvent {
pub result: Result<i64, Errno>,
pub fds_pointer_present: bool,
pub fds: Option<Vec<PollFd>>,
pub timeout_pointer_present: bool,
pub timeout: Option<Timespec>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SelectEvent {
pub result: Result<i64, Errno>,
pub fd_sets: [Option<Vec<u8>>; 3],
pub timeout: Option<Vec<u8>>,
}
pub fn fd_set_bytes(nfds: i32) -> usize {
const LONG_BYTES: usize = std::mem::size_of::<libc::c_long>();
usize::try_from(nfds).map_or(0, |nfds| nfds.div_ceil(8 * LONG_BYTES) * LONG_BYTES)
}
#[derive(Serialize, Deserialize, Debug)]
pub struct EpollWaitEvent {
pub events: Vec<u8>,
pub updated: usize,
pub replay_kernel_side_effect: bool,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SockOptEvent {
pub value: Vec<u8>,
pub length: libc::socklen_t,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn siocethtool_has_a_deterministic_error() {
let request = ioctl::Request::SIOCETHTOOL(None);
assert_eq!(deterministic_ioctl_error(&request), Some(Errno::ENODEV));
let legacy_request = ioctl::Request::Other(SIOCETHTOOL, 0x1234);
assert_eq!(
deterministic_ioctl_error(&legacy_request),
Some(Errno::ENODEV)
);
}
#[test]
fn neighboring_unknown_ioctl_is_not_rejected() {
let request = ioctl::Request::Other(SIOCETHTOOL - 1, 0x1234);
assert_eq!(deterministic_ioctl_error(&request), None);
}
#[test]
fn mkdir_event_schema_preserves_directory_classification() {
let events = vec![
Event {
event: Ok(SyscallEvent::Mkdir(MkdirEvent {
result: Err(Errno::EEXIST),
existing_directory: true,
})),
},
Event {
event: Ok(SyscallEvent::Mkdir(MkdirEvent {
result: Err(Errno::ENOENT),
existing_directory: false,
})),
},
];
let encoded = bincode::serde::encode_to_vec(&events, bincode::config::legacy()).unwrap();
let (decoded, consumed): (Vec<Event>, usize) =
bincode::serde::decode_from_slice(&encoded, bincode::config::legacy()).unwrap();
assert_eq!(consumed, encoded.len());
let [first, second] = decoded.as_slice() else {
panic!("unexpected mkdir event count")
};
assert!(matches!(
&first.event,
Ok(SyscallEvent::Mkdir(MkdirEvent {
result: Err(Errno::EEXIST),
existing_directory: true,
}))
));
assert!(matches!(
&second.event,
Ok(SyscallEvent::Mkdir(MkdirEvent {
result: Err(Errno::ENOENT),
existing_directory: false,
}))
));
}
#[test]
fn exec_event_schema_preserves_non_utf8_paths_and_topology() {
let event = Event {
event: Ok(SyscallEvent::Exec(ExecEvent {
request: ExecRequest {
dirfd: libc::AT_FDCWD,
path: b"relative/\xff-program".to_vec(),
flags: 0,
},
executable: ExecImage {
digest: detcore::Digest::new(b"program"),
mode: 0o751,
},
target: ExecTarget::Materialize(ExecMaterialization {
base: ExecMaterializationBase::Cwd,
path: b"relative/\xff-program".to_vec(),
symlinks: vec![crate::record_replay_path::ResolvedSymlink {
lookup_index: 1,
target: b"target-\xfe".to_vec(),
}],
}),
dependencies: Vec::new(),
})),
};
let encoded = bincode::serde::encode_to_vec(&event, bincode::config::legacy()).unwrap();
let (decoded, consumed): (Event, usize) =
bincode::serde::decode_from_slice(&encoded, bincode::config::legacy()).unwrap();
assert_eq!(consumed, encoded.len());
let Ok(SyscallEvent::Exec(decoded)) = decoded.event else {
panic!("unexpected exec event")
};
assert_eq!(decoded.request.path, b"relative/\xff-program");
let ExecTarget::Materialize(materialization) = decoded.target else {
panic!("unexpected exec target policy")
};
assert_eq!(materialization.path, b"relative/\xff-program");
assert_eq!(materialization.symlinks[0].target, b"target-\xfe");
}
}