use std::fmt;
use std::fs;
use std::io;
use std::os::unix::ffi::OsStrExt;
use std::path::Path;
use std::sync::atomic::AtomicU64;
use std::sync::atomic::Ordering;
use reverie::Errno;
use reverie::syscalls::Displayable;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::ReadAddr;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallArgs;
use reverie::syscalls::SyscallInfo;
use reverie::syscalls::Sysno;
use serde::Deserialize;
use serde::Serialize;
use crate::event::Event;
#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
pub(crate) struct EventStreamId(Vec<u64>);
impl EventStreamId {
pub(crate) fn root() -> Self {
Self(Vec::new())
}
pub(crate) fn child(&self, ordinal: u64) -> Self {
let mut path = self.0.clone();
path.push(ordinal);
Self(path)
}
fn file_name(&self) -> String {
let mut identity = b"hermit-event-stream-v1\0".to_vec();
for ordinal in &self.0 {
identity.extend_from_slice(&ordinal.to_be_bytes());
}
format!("stream-{}", detcore::Digest::new(&identity))
}
}
impl fmt::Display for EventStreamId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", detcore::ROOT_DETPID.as_raw())?;
for ordinal in &self.0 {
write!(f, ".{ordinal}")?;
}
Ok(())
}
}
#[derive(Default)]
pub(crate) struct ChildEventStreamIds(AtomicU64);
impl ChildEventStreamIds {
pub(crate) fn next(&self, parent: &EventStreamId) -> EventStreamId {
let ordinal = self
.0
.try_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
value.checked_add(1)
})
.unwrap_or_else(|_| panic!("record/replay child stream ordinal overflow"));
parent.child(ordinal)
}
}
#[derive(Serialize, Deserialize)]
struct EventStreamHeader {
stream_id: EventStreamId,
}
fn decode_stream_header(
reader: &mut io::BufReader<fs::File>,
expected: &EventStreamId,
) -> io::Result<()> {
let header: EventStreamHeader =
bincode::serde::decode_from_std_read(reader, bincode::config::legacy()).map_err(
|error| {
io::Error::new(
io::ErrorKind::InvalidData,
format!("invalid event-stream identity header: {error}"),
)
},
)?;
if header.stream_id != *expected {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!(
"event-stream identity mismatch: expected {expected}, found {}",
header.stream_id
),
));
}
Ok(())
}
fn encode_stream_header(
writer: &mut io::BufWriter<fs::File>,
stream_id: &EventStreamId,
) -> io::Result<()> {
bincode::serde::encode_into_std_write(
EventStreamHeader {
stream_id: stream_id.clone(),
},
writer,
bincode::config::legacy(),
)
.map(|_| ())
.map_err(|error| {
io::Error::new(
io::ErrorKind::InvalidData,
format!("failed to encode event-stream identity header: {error}"),
)
})
}
impl Serialize for ChildEventStreamIds {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_u64(self.0.load(Ordering::Relaxed))
}
}
impl<'de> Deserialize<'de> for ChildEventStreamIds {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
Ok(Self(AtomicU64::new(u64::deserialize(deserializer)?)))
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DebugEvent {
syscall: (Sysno, SyscallArgs),
pretty: String,
exec_request: Option<DebugExecRequest>,
}
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
struct DebugExecRequest {
dirfd: libc::c_int,
path: Result<Vec<u8>, Errno>,
flags: libc::c_int,
}
impl DebugEvent {
pub fn new<M: MemoryAccess>(syscall: Syscall, memory: &M) -> Self {
let exec_request = match syscall {
Syscall::Execve(call) => {
let call: reverie::syscalls::Execveat = call.into();
Some(DebugExecRequest {
dirfd: call.dirfd(),
path: call
.path()
.ok_or(Errno::EFAULT)
.and_then(|path| path.read(memory))
.map(|path| path.as_os_str().as_bytes().to_vec()),
flags: call.flags(),
})
}
Syscall::Execveat(call) => Some(DebugExecRequest {
dirfd: call.dirfd(),
path: call
.path()
.ok_or(Errno::EFAULT)
.and_then(|path| path.read(memory))
.map(|path| path.as_os_str().as_bytes().to_vec()),
flags: call.flags(),
}),
_ => None,
};
Self {
syscall: syscall.into_parts(),
pretty: format!("{}", syscall.display(memory)),
exec_request,
}
}
pub fn syscall(&self) -> Syscall {
Syscall::from_raw(self.syscall.0, self.syscall.1)
}
pub(crate) fn exec_request_matches(&self, other: &Self) -> bool {
self.exec_request == other.exec_request
}
#[cfg(test)]
pub(crate) fn for_test(sysno: Sysno, pretty: &str) -> Self {
Self {
syscall: (sysno, SyscallArgs::new(0, 0, 0, 0, 0, 0)),
pretty: pretty.to_owned(),
exec_request: None,
}
}
}
impl fmt::Display for DebugEvent {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(&self.pretty)
}
}
fn kernel_arg_count(sysno: Sysno) -> Option<u8> {
use reverie::syscalls::Sysno::*;
Some(match sysno {
close | chdir | fchdir | dup | time | unlink | rmdir => 1,
access | getcwd | set_robust_list | stat | fstat | lstat | dup2 | clock_gettime
| clock_getres | gettimeofday | settimeofday | mkdir | statfs | fstatfs | ftruncate
| kill | listen | rt_sigpending | rename | link | symlink | chmod => 2,
mprotect | read | readv | write | writev | lseek | getdents | getdents64 | dup3 | ioctl
| socket | fcntl | connect | sendmsg | poll | getpeername | getsockname | getrandom
| readlink | unlinkat | open | execve | close_range | tgkill | faccessat | chown
| lchown | mknod => 3,
pread64 | pwrite64 | newfstatat | fadvise64 | openat | faccessat2 => 4,
statx | pwritev | preadv | ppoll | setsockopt | getsockopt | execveat | prctl => 5,
recvfrom | sendto | pwritev2 | preadv2 | mmap => 6,
_ => return None,
})
}
pub(crate) fn normalize_unused_args(syscall: Syscall) -> Syscall {
let (sysno, args) = syscall.into_parts();
let Some(used) = kernel_arg_count(sysno) else {
return syscall;
};
let mut raw = [
args.arg0, args.arg1, args.arg2, args.arg3, args.arg4, args.arg5,
];
for reg in raw.iter_mut().skip(usize::from(used)) {
*reg = 0;
}
Syscall::from_raw(
sysno,
SyscallArgs::new(raw[0], raw[1], raw[2], raw[3], raw[4], raw[5]),
)
}
#[derive(Serialize, Deserialize)]
pub struct EventReader {
#[serde(skip, default = "default_reader")]
reader: io::BufReader<fs::File>,
#[serde(skip, default = "default_reader")]
debug_events: io::BufReader<fs::File>,
pub count: u64,
}
fn default_reader() -> io::BufReader<fs::File> {
unimplemented!("Serialization is not yet implemented")
}
impl EventReader {
pub fn open(path: &Path, stream_id: &EventStreamId) -> io::Result<Self> {
let file_name = stream_id.file_name();
let mut reader = io::BufReader::new(fs::File::open(path.join("thread").join(&file_name))?);
let mut debug_events = io::BufReader::new(fs::File::open(
path.join("thread").join(format!("{file_name}.debug")),
)?);
decode_stream_header(&mut reader, stream_id)?;
decode_stream_header(&mut debug_events, stream_id)?;
Ok(Self {
reader,
debug_events,
count: 0,
})
}
pub fn next_event(&mut self) -> Result<Event, bincode::error::DecodeError> {
bincode::serde::decode_from_std_read(&mut self.reader, bincode::config::legacy())
}
pub fn next_debug_event(&mut self) -> Result<DebugEvent, bincode::error::DecodeError> {
let debug_event = bincode::serde::decode_from_std_read(
&mut self.debug_events,
bincode::config::legacy(),
)?;
self.count += 1;
Ok(debug_event)
}
}
impl Default for EventReader {
fn default() -> Self {
panic!("Thread state should be explicitly initialized in init_thread_state")
}
}
#[derive(Serialize, Deserialize)]
pub struct EventWriter {
#[serde(skip, default = "default_writer")]
writer: io::BufWriter<fs::File>,
#[serde(skip, default = "default_writer")]
debug_events: io::BufWriter<fs::File>,
}
fn default_writer() -> io::BufWriter<fs::File> {
unimplemented!("Serialization is not yet implemented")
}
impl EventWriter {
pub fn create(path: &Path, stream_id: &EventStreamId) -> io::Result<Self> {
let path = path.join("thread");
fs::create_dir_all(&path)?;
let file_name = stream_id.file_name();
let create = |path| {
fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(path)
};
let mut writer = io::BufWriter::new(create(path.join(&file_name))?);
let mut debug_events = io::BufWriter::new(create(path.join(format!("{file_name}.debug")))?);
encode_stream_header(&mut writer, stream_id)?;
encode_stream_header(&mut debug_events, stream_id)?;
Ok(Self {
writer,
debug_events,
})
}
pub fn push_event(&mut self, event: Event) -> Result<(), bincode::error::EncodeError> {
bincode::serde::encode_into_std_write(&event, &mut self.writer, bincode::config::legacy())
.map(|_| ())
}
pub fn push_debug_event(
&mut self,
event: DebugEvent,
) -> Result<(), bincode::error::EncodeError> {
bincode::serde::encode_into_std_write(
&event,
&mut self.debug_events,
bincode::config::legacy(),
)
.map(|_| ())
}
}
impl Default for EventWriter {
fn default() -> Self {
panic!("Thread state should be explicitly initialized in init_thread_state")
}
}
#[cfg(test)]
mod tests {
use std::fs;
use std::io;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallArgs;
use reverie::syscalls::Sysno;
use super::ChildEventStreamIds;
use super::EventStreamId;
use super::kernel_arg_count;
use super::normalize_unused_args;
fn raw(sysno: Sysno, args: SyscallArgs) -> Syscall {
Syscall::from_raw(sysno, args)
}
#[test]
fn unused_args_do_not_cause_desync() {
let clean = raw(Sysno::statfs, SyscallArgs::new(0x1000, 0x2000, 0, 0, 0, 0));
let garbage = raw(
Sysno::statfs,
SyscallArgs::new(0x1000, 0x2000, 0xdead, 0xbeef, 0, 0xcafe),
);
assert_ne!(clean, garbage, "raw comparison should differ (the bug)");
assert_eq!(
normalize_unused_args(clean),
normalize_unused_args(garbage),
"normalized statfs must ignore unused argument registers"
);
}
#[test]
fn close_range_ignores_unused_args() {
let clean = raw(
Sysno::close_range,
SyscallArgs::new(3, 9, libc::CLOSE_RANGE_CLOEXEC as usize, 0, 0, 0),
);
let garbage = raw(
Sysno::close_range,
SyscallArgs::new(
3,
9,
libc::CLOSE_RANGE_CLOEXEC as usize,
0xdead,
0xbeef,
0xcafe,
),
);
assert_eq!(normalize_unused_args(clean), normalize_unused_args(garbage));
}
#[test]
fn meaningful_args_are_not_masked() {
let a = raw(Sysno::fcntl, SyscallArgs::new(3, 4, 0x800, 0, 0, 0));
let b = raw(Sysno::fcntl, SyscallArgs::new(3, 4, 0x0, 0, 0, 0));
assert_ne!(
normalize_unused_args(a),
normalize_unused_args(b),
"fcntl's third argument is meaningful and must not be zeroed"
);
}
#[test]
fn delegated_syscalls_have_kernel_arities() {
assert_eq!(kernel_arg_count(Sysno::kill), Some(2));
assert_eq!(kernel_arg_count(Sysno::ftruncate), Some(2));
assert_eq!(kernel_arg_count(Sysno::listen), Some(2));
assert_eq!(kernel_arg_count(Sysno::rt_sigpending), Some(2));
assert_eq!(kernel_arg_count(Sysno::tgkill), Some(3));
assert_eq!(kernel_arg_count(Sysno::prctl), Some(5));
}
#[test]
fn path_query_and_mutation_syscalls_have_kernel_arities() {
assert_eq!(kernel_arg_count(Sysno::faccessat), Some(3));
assert_eq!(kernel_arg_count(Sysno::faccessat2), Some(4));
assert_eq!(kernel_arg_count(Sysno::chdir), Some(1));
assert_eq!(kernel_arg_count(Sysno::getcwd), Some(2));
assert_eq!(kernel_arg_count(Sysno::set_robust_list), Some(2));
assert_eq!(kernel_arg_count(Sysno::rmdir), Some(1));
assert_eq!(kernel_arg_count(Sysno::rename), Some(2));
assert_eq!(kernel_arg_count(Sysno::link), Some(2));
assert_eq!(kernel_arg_count(Sysno::symlink), Some(2));
assert_eq!(kernel_arg_count(Sysno::chmod), Some(2));
assert_eq!(kernel_arg_count(Sysno::chown), Some(3));
assert_eq!(kernel_arg_count(Sysno::lchown), Some(3));
assert_eq!(kernel_arg_count(Sysno::mknod), Some(3));
}
#[test]
fn unknown_syscall_compares_all_registers() {
let a = raw(Sysno::getpid, SyscallArgs::new(0, 0, 0xaa, 0, 0, 0));
let b = raw(Sysno::getpid, SyscallArgs::new(0, 0, 0xbb, 0, 0, 0));
assert_ne!(normalize_unused_args(a), normalize_unused_args(b));
}
#[test]
fn pedigree_stream_ids_are_stable_and_collision_free() {
let root = EventStreamId::root();
let recording = ChildEventStreamIds::default();
let replay = ChildEventStreamIds::default();
let first = recording.next(&root);
let second = recording.next(&root);
assert_eq!(first.to_string(), "3.0");
assert_eq!(second.to_string(), "3.1");
assert_ne!(first, second);
assert_eq!(first, replay.next(&root));
assert_eq!(second, replay.next(&root));
let serialized = serde_json::to_vec(&recording).expect("serialize child ordinal");
let restored: ChildEventStreamIds =
serde_json::from_slice(&serialized).expect("restore child ordinal");
assert_eq!(restored.next(&root).to_string(), "3.2");
let grandchildren = ChildEventStreamIds::default();
assert_eq!(grandchildren.next(&first).to_string(), "3.0.0");
}
#[test]
fn deeply_nested_stream_names_remain_bounded() {
let mut stream_id = EventStreamId::root();
for ordinal in 0..125 {
stream_id = stream_id.child(ordinal);
}
assert_eq!(stream_id.file_name().len(), "stream-".len() + 64);
assert!(stream_id.file_name().len() <= 255);
}
#[test]
fn duplicate_stream_identity_refuses_instead_of_overwriting() {
let data = tempfile::tempdir().expect("create recording directory");
let stream_id = EventStreamId::root().child(0);
let first = super::EventWriter::create(data.path(), &stream_id).expect("create stream");
let error = super::EventWriter::create(data.path(), &stream_id)
.err()
.expect("duplicate stream must refuse");
assert_eq!(error.kind(), std::io::ErrorKind::AlreadyExists);
drop(first);
}
#[test]
fn mismatched_stream_header_refuses_instead_of_aliasing() {
let data = tempfile::tempdir().expect("create recording directory");
let expected = EventStreamId::root().child(0);
let different = EventStreamId::root().child(1);
let writer = super::EventWriter::create(data.path(), &expected).expect("create stream");
drop(writer);
let file_name = expected.file_name();
let mut file = io::BufWriter::new(
fs::OpenOptions::new()
.write(true)
.truncate(true)
.open(data.path().join("thread").join(file_name))
.expect("open stream for corruption"),
);
super::encode_stream_header(&mut file, &different).expect("write mismatched header");
drop(file);
let error = super::EventReader::open(data.path(), &expected)
.err()
.expect("mismatched stream identity must refuse");
assert_eq!(error.kind(), io::ErrorKind::InvalidData);
assert!(error.to_string().contains("identity mismatch"));
}
}