use std::os::fd::AsRawFd;
use std::os::fd::FromRawFd;
use std::os::fd::OwnedFd;
use std::os::unix::fs::FileExt;
use std::os::unix::fs::MetadataExt;
use std::sync::OnceLock;
use reverie::Errno;
use reverie::Guest;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::Madvise;
use reverie::syscalls::MapFlags;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::Mmap;
use super::Recorder;
use crate::event::MadviseEvent;
use crate::event::MadviseRefill;
use crate::event::MmapEvent;
use crate::event::SyscallEvent;
const PAGE_SIZE: usize = 4096;
const MADV_GUARD_REMOVE: i32 = 103;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Mapping {
start: usize,
end: usize,
prot: i32,
private: bool,
file_backed: bool,
anonymous_shmem: bool,
}
type Device = (u32, u32);
fn shmem_device() -> Option<Device> {
static DEVICE: OnceLock<Option<Device>> = OnceLock::new();
*DEVICE.get_or_init(|| {
let fd = unsafe { libc::memfd_create(c"hermit-shmem-device".as_ptr(), libc::MFD_CLOEXEC) };
if fd < 0 {
return None;
}
let fd = unsafe { OwnedFd::from_raw_fd(fd) };
let dev = std::fs::metadata(format!("/proc/self/fd/{}", fd.as_raw_fd()))
.ok()?
.dev();
Some((libc::major(dev), libc::minor(dev)))
})
}
fn parse_device(field: &str) -> Option<Device> {
let (major, minor) = field.split_once(':')?;
Some((
u32::from_str_radix(major, 16).ok()?,
u32::from_str_radix(minor, 16).ok()?,
))
}
fn parse_maps(text: &str, shmem_device: Option<Device>) -> Vec<Mapping> {
text.lines()
.filter_map(|line| {
let mut fields = line.split_ascii_whitespace();
let (start, end) = fields.next()?.split_once('-')?;
let perms = fields.next()?.as_bytes();
let _offset = fields.next()?;
let device = parse_device(fields.next()?);
let inode = fields.next()?;
let path = fields.collect::<Vec<_>>().join(" ");
if perms.len() < 4 {
return None;
}
let mut prot = libc::PROT_NONE;
for (flag, bit) in [
(b'r', libc::PROT_READ),
(b'w', libc::PROT_WRITE),
(b'x', libc::PROT_EXEC),
] {
if perms[..3].contains(&flag) {
prot |= bit;
}
}
Some(Mapping {
start: usize::from_str_radix(start, 16).ok()?,
end: usize::from_str_radix(end, 16).ok()?,
prot,
private: perms[3] == b'p',
file_backed: inode != "0",
anonymous_shmem: shmem_device.is_some()
&& device == shmem_device
&& (path == "/dev/zero (deleted)" || path.starts_with("/SYSV")),
})
})
.collect()
}
fn read_mappings(path: &str) -> Vec<Mapping> {
let maps = std::fs::read(path)
.unwrap_or_else(|error| panic!("Cannot record madvise: {path}: {error}"));
parse_maps(&String::from_utf8_lossy(&maps), shmem_device())
}
fn refill_ranges(mappings: &[Mapping], start: usize, end: usize) -> Vec<(usize, usize, i32)> {
mappings
.iter()
.filter(|mapping| mapping.file_backed && !mapping.anonymous_shmem)
.filter_map(|mapping| {
let lo = mapping.start.max(start);
let hi = mapping.end.min(end);
(lo < hi).then_some((lo, hi, mapping.prot))
})
.collect()
}
fn wipeonfork_live_len(mappings: &[Mapping], start: usize, end: usize) -> Option<usize> {
mappings
.iter()
.find(|mapping| {
mapping.file_backed && mapping.private && mapping.start < end && start < mapping.end
})
.map(|mapping| mapping.start.max(start) - start)
}
fn read_readable_runs(mem: &std::fs::File, start: usize, end: usize) -> Vec<(usize, Vec<u8>)> {
let mut runs: Vec<(usize, Vec<u8>)> = Vec::new();
let mut pos = start;
let mut run_open = false;
while pos < end {
let mut buf = vec![0u8; end - pos];
match mem.read_at(&mut buf, pos as u64) {
Ok(n) if n > 0 => {
buf.truncate(n);
if run_open {
runs.last_mut().unwrap().1.extend_from_slice(&buf);
} else {
runs.push((pos, buf));
run_open = true;
}
pos += n;
}
_ => {
run_open = false;
pos = (pos & !(PAGE_SIZE - 1)) + PAGE_SIZE;
}
}
}
runs
}
impl Recorder {
pub(super) async fn handle_mmap<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Mmap,
) -> Result<i64, Errno> {
if syscall.flags().contains(MapFlags::MAP_ANONYMOUS) {
return guest.inject(syscall).await;
}
let len = syscall.len();
let result = guest.inject(syscall).await;
self.record_event(
guest,
match result {
Ok(addr) => {
let addr = Addr::from_raw(addr as usize).ok_or(Errno::EINVAL)?;
let mut buf = vec![0u8; len];
let physical_length = guest.memory().read(addr, &mut buf)?;
buf.truncate(physical_length);
Ok(SyscallEvent::Mmap(MmapEvent {
addr: addr.as_raw(),
buf,
}))
}
Err(errno) => Err(errno),
},
);
result
}
pub(super) async fn handle_madvise<G: Guest<Self>>(
&self,
guest: &mut G,
syscall: Madvise,
) -> Result<i64, Errno> {
let advice = syscall.advice();
let start = syscall.addr().map(AddrMut::as_raw).unwrap_or(0);
let len = syscall.len();
let end = start.saturating_add(len).next_multiple_of(PAGE_SIZE);
let drops_pages = matches!(
advice,
libc::MADV_DONTNEED | libc::MADV_DONTNEED_LOCKED | MADV_GUARD_REMOVE
);
let maps_path = format!("/proc/{}/maps", guest.tid().as_raw());
let wipeonfork_prefix = if advice == libc::MADV_WIPEONFORK {
let mappings = read_mappings(&maps_path);
wipeonfork_live_len(&mappings, start, end)
} else {
None
};
let result = guest.inject(syscall).await;
let live_len = match (wipeonfork_prefix, result) {
(Some(prefix), Err(Errno::EINVAL)) => prefix,
_ => len,
};
let mut refills = Vec::new();
if drops_pages {
let mappings = read_mappings(&maps_path);
let ranges = refill_ranges(&mappings, start, end);
if !ranges.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 record madvise: {mem_path}: {error}"));
for (lo, hi, prot) in ranges {
for (addr, bytes) in read_readable_runs(&mem, lo, hi) {
refills.push(MadviseRefill { addr, bytes, prot });
}
}
}
}
self.record_event(
guest,
Ok(SyscallEvent::Madvise(MadviseEvent {
result,
live_len,
refills,
})),
);
result
}
}
#[cfg(test)]
mod tests {
use super::*;
const MAPS: &str = "\
00400000-00401000 r-xp 00000000 08:01 1234 /usr/bin/guest
7f0000000000-7f0000002000 rw-p 00000000 00:00 0
7f0000002000-7f0000003000 rw-p 00001000 08:01 1234 /usr/bin/guest
7f0000003000-7f0000004000 ---s 00000000 00:01 77 /dev/zero (deleted)
7f0000004000-7f0000005000 rw-s 00000000 00:01 88 /memfd:shared state (deleted)
7f0000005000-7f0000006000 rw-s 00000000 00:01 2 /SYSV00000000 (deleted)
7f0000006000-7f0000007000 rw-s 00000000 08:01 99 /SYSV00000000 (deleted)
7f0000007000-7f0000008000 rw-s 00000000 00:05 98 /dev/zero (deleted)
7ffffffde000-7ffffffff000 rw-p 00000000 00:00 0 [stack]
";
const SHMEM: Option<Device> = Some((0, 1));
#[test]
fn parses_maps_lines() {
let mappings = parse_maps(MAPS, SHMEM);
assert_eq!(mappings.len(), 9);
assert_eq!(
mappings[0],
Mapping {
start: 0x400000,
end: 0x401000,
prot: libc::PROT_READ | libc::PROT_EXEC,
private: true,
file_backed: true,
anonymous_shmem: false,
}
);
assert!(!mappings[1].file_backed);
assert_eq!(mappings[3].prot, libc::PROT_NONE);
assert!(!mappings[3].private);
assert!(mappings[3].file_backed);
assert!(mappings[3].anonymous_shmem);
assert!(!mappings[4].anonymous_shmem);
assert!(mappings[5].anonymous_shmem);
}
#[test]
fn refill_ranges_clip_to_the_advised_range() {
let mappings = parse_maps(MAPS, SHMEM);
assert_eq!(
refill_ranges(&mappings, 0x7f0000001000, 0x7f0000004000),
vec![(
0x7f0000002000,
0x7f0000003000,
libc::PROT_READ | libc::PROT_WRITE
)]
);
assert!(refill_ranges(&mappings, 0x7f0000000000, 0x7f0000002000).is_empty());
}
#[test]
fn refill_ranges_cover_shared_files_but_not_shared_anonymous_memory() {
let rw = libc::PROT_READ | libc::PROT_WRITE;
let mappings = parse_maps(MAPS, SHMEM);
assert_eq!(
refill_ranges(&mappings, 0x7f0000003000, 0x7f0000008000),
vec![
(0x7f0000004000, 0x7f0000005000, rw),
(0x7f0000006000, 0x7f0000007000, rw),
(0x7f0000007000, 0x7f0000008000, rw),
]
);
let mappings = parse_maps(MAPS, None);
assert!(mappings.iter().all(|mapping| !mapping.anonymous_shmem));
assert_eq!(
refill_ranges(&mappings, 0x7f0000003000, 0x7f0000008000).len(),
5
);
}
#[test]
fn this_hosts_shared_anonymous_memory_is_on_the_shmem_device() {
let addr = unsafe {
libc::mmap(
std::ptr::null_mut(),
PAGE_SIZE,
libc::PROT_READ | libc::PROT_WRITE,
libc::MAP_SHARED | libc::MAP_ANONYMOUS,
-1,
0,
)
};
assert_ne!(addr, libc::MAP_FAILED);
let mappings = read_mappings("/proc/self/maps");
let mapping = mappings
.iter()
.find(|mapping| mapping.start == addr as usize)
.expect("the new mapping is listed");
assert!(mapping.file_backed && mapping.anonymous_shmem);
assert!(refill_ranges(&mappings, mapping.start, mapping.end).is_empty());
assert_eq!(unsafe { libc::munmap(addr, PAGE_SIZE) }, 0);
}
#[test]
fn wipeonfork_prefix_stops_at_the_first_private_file_mapping() {
let mappings = parse_maps(MAPS, SHMEM);
assert_eq!(
wipeonfork_live_len(&mappings, 0x7f0000000000, 0x7f0000004000),
Some(0x2000)
);
assert_eq!(
wipeonfork_live_len(&mappings, 0x7f0000002000, 0x7f0000003000),
Some(0)
);
assert_eq!(
wipeonfork_live_len(&mappings, 0x7f0000003000, 0x7f0000004000),
None
);
}
}