use std::os::unix::fs::FileExt;
use reverie::Errno;
use reverie::Guest;
use reverie::syscalls::AddrMut;
use reverie::syscalls::Madvise;
use reverie::syscalls::MapFlags;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::Mmap;
use reverie::syscalls::Mprotect;
use reverie::syscalls::ProtFlags;
use super::Replayer;
use crate::event::MadviseRefill;
const PAGE_SIZE: usize = 4096;
impl Replayer {
pub(super) async fn handle_mmap<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Mmap,
) -> Result<i64, Errno> {
let flags = syscall.flags();
if flags.contains(MapFlags::MAP_ANONYMOUS) {
return guest.inject_with_retry(syscall).await;
}
let event = next_event!(guest, Mmap)?;
let addr = unsafe { AddrMut::<u8>::from_raw_unchecked(event.addr) };
let len = syscall.len();
let prot = syscall.prot();
let ptr = guest
.inject_with_retry(
syscall
.with_addr(Some(addr.cast::<libc::c_void>().into()))
.with_prot(prot | ProtFlags::PROT_WRITE)
.with_flags(flags | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
)
.await?;
assert_eq!(
ptr as usize, event.addr,
"Failed to inject mmap at desired address"
);
guest.memory().write_exact(addr.cast(), &event.buf).unwrap();
if !prot.contains(ProtFlags::PROT_WRITE) {
guest
.inject_with_retry(
Mprotect::new()
.with_addr(Some(addr.cast()))
.with_len(len)
.with_protection(prot),
)
.await?;
}
Ok(ptr)
}
pub(super) async fn handle_madvise<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Madvise,
) -> Result<i64, Errno> {
let event = next_event!(guest, Madvise)?;
let len = syscall.len();
assert!(
event.live_len <= len,
"Recorded madvise prefix {} exceeds the guest length {}",
event.live_len,
len
);
if event.live_len == len {
let result = guest.inject_with_retry(syscall).await;
assert_eq!(
result,
event.result,
"Replayed madvise({:?}, {}, {}) diverged from the recording; replay \
cannot reproduce this outcome",
syscall.addr(),
len,
syscall.advice()
);
} else if event.live_len > 0 {
let result = guest
.inject_with_retry(syscall.with_len(event.live_len))
.await;
assert!(
matches!(result, Ok(0) | Err(Errno::ENOMEM) | Err(Errno::EINVAL)),
"Replayed madvise prefix ({:?}, {}, {}) returned {:?}; replay cannot \
reproduce the recorded {:?}",
syscall.addr(),
event.live_len,
syscall.advice(),
result,
event.result
);
}
if !event.refills.is_empty() {
let mem_path = format!("/proc/{}/mem", guest.tid().as_raw());
let mem = std::fs::File::open(&mem_path)
.unwrap_or_else(|error| panic!("Cannot replay madvise: {mem_path}: {error}"));
for refill in &event.refills {
let mut current = vec![0u8; refill.bytes.len()];
let readable = read_prefix(&mem, refill.addr, &mut current);
for (offset, run) in differing_pages(¤t[..readable], &refill.bytes) {
self.write_refill(guest, refill, offset, run).await;
}
}
}
event.result
}
}
impl Replayer {
async fn write_refill<G: Guest<Self>>(
&self,
guest: &mut G,
refill: &MadviseRefill,
offset: usize,
len: usize,
) {
let start = refill.addr + offset;
let prot = ProtFlags::from_bits_truncate(refill.prot);
if !prot.contains(ProtFlags::PROT_WRITE) {
guest
.inject_with_retry(protection(start, len, prot | ProtFlags::PROT_WRITE))
.await
.unwrap_or_else(|err| {
panic!("Cannot unprotect madvise refill at {start:#x}: {err}")
});
}
let addr = unsafe { AddrMut::<u8>::from_raw_unchecked(start) };
guest
.memory()
.write_exact(addr, &refill.bytes[offset..offset + len])
.unwrap();
if !prot.contains(ProtFlags::PROT_WRITE) {
guest
.inject_with_retry(protection(start, len, prot))
.await
.unwrap_or_else(|err| {
panic!("Cannot reprotect madvise refill at {start:#x}: {err}")
});
}
}
}
fn protection(start: usize, len: usize, protection: ProtFlags) -> Mprotect {
let addr = unsafe { AddrMut::<libc::c_void>::from_raw_unchecked(start) };
Mprotect::new()
.with_addr(Some(addr))
.with_len(len)
.with_protection(protection)
}
fn read_prefix(mem: &std::fs::File, addr: usize, buf: &mut [u8]) -> usize {
let mut done = 0;
while done < buf.len() {
match mem.read_at(&mut buf[done..], (addr + done) as u64) {
Ok(n) if n > 0 => done += n,
_ => break,
}
}
done
}
fn differing_pages(current: &[u8], recorded: &[u8]) -> Vec<(usize, usize)> {
let mut runs: Vec<(usize, usize)> = Vec::new();
for offset in (0..recorded.len()).step_by(PAGE_SIZE) {
let end = (offset + PAGE_SIZE).min(recorded.len());
if current.get(offset..end) == Some(&recorded[offset..end]) {
continue;
}
match runs.last_mut() {
Some((start, len)) if *start + *len == offset => *len = end - *start,
_ => runs.push((offset, end - offset)),
}
}
runs
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn differing_pages_merges_adjacent_changed_pages() {
let recorded = vec![1u8; 4 * PAGE_SIZE];
let mut current = recorded.clone();
current[PAGE_SIZE + 7] = 0;
current[2 * PAGE_SIZE] = 0;
assert_eq!(
differing_pages(¤t, &recorded),
vec![(PAGE_SIZE, 2 * PAGE_SIZE)]
);
assert!(differing_pages(&recorded, &recorded).is_empty());
}
#[test]
fn differing_pages_treats_unread_bytes_as_changed() {
let recorded = vec![1u8; 3 * PAGE_SIZE + 10];
let current = recorded[..PAGE_SIZE].to_vec();
assert_eq!(
differing_pages(¤t, &recorded),
vec![(PAGE_SIZE, 2 * PAGE_SIZE + 10)]
);
}
}