use reverie::Error;
use reverie::Guest;
use reverie::syscalls;
use reverie::syscalls::AddrMut;
use reverie::syscalls::Errno;
use reverie::syscalls::MemoryAccess;
use crate::Detcore;
use crate::RecordOrReplay;
const PAGE_SIZE: usize = 4096;
const MADV_GUARD_INSTALL: i32 = 102;
const MADV_GUARD_REMOVE: i32 = 103;
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
enum MadviseAction {
ForwardHint,
ForwardSemantic,
Ignore,
Reject(Errno),
Unknown,
}
const fn madvise_action(advice: i32) -> MadviseAction {
match advice {
libc::MADV_NORMAL | libc::MADV_RANDOM | libc::MADV_SEQUENTIAL | libc::MADV_WILLNEED => {
MadviseAction::ForwardHint
}
libc::MADV_DONTNEED
| libc::MADV_DONTFORK
| libc::MADV_DOFORK
| libc::MADV_DONTDUMP
| libc::MADV_DODUMP
| libc::MADV_WIPEONFORK
| libc::MADV_KEEPONFORK
| libc::MADV_DONTNEED_LOCKED
| MADV_GUARD_INSTALL
| MADV_GUARD_REMOVE => MadviseAction::ForwardSemantic,
libc::MADV_FREE
| libc::MADV_MERGEABLE
| libc::MADV_UNMERGEABLE
| libc::MADV_HUGEPAGE
| libc::MADV_NOHUGEPAGE
| libc::MADV_COLD
| libc::MADV_PAGEOUT => MadviseAction::Ignore,
libc::MADV_REMOVE => MadviseAction::Reject(Errno::EINVAL),
libc::MADV_POPULATE_READ | libc::MADV_POPULATE_WRITE | libc::MADV_COLLAPSE => {
MadviseAction::Reject(Errno::EINVAL)
}
libc::MADV_HWPOISON | libc::MADV_SOFT_OFFLINE => MadviseAction::Reject(Errno::EPERM),
_ => MadviseAction::Unknown,
}
}
fn validate_common_args(call: syscalls::Madvise) -> Result<(), Error> {
let start = call.addr().map(AddrMut::as_raw).unwrap_or(0);
if !start.is_multiple_of(PAGE_SIZE) {
return Err(Errno::EINVAL.into());
}
if call.len() == 0 {
return Ok(());
}
let end = start.checked_add(call.len()).ok_or(Errno::EINVAL)?;
end.checked_add(PAGE_SIZE - 1).ok_or(Errno::EINVAL)?;
Ok(())
}
impl<T: RecordOrReplay> Detcore<T> {
pub async fn handle_madvise<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Madvise,
) -> Result<i64, Error> {
let advice = call.advice();
let action = madvise_action(advice);
validate_common_args(call)?;
if call.len() == 0 {
return match action {
MadviseAction::Unknown => Err(Errno::EINVAL.into()),
_ => Ok(0),
};
}
if self.cfg.recordreplay_modes && action == MadviseAction::ForwardHint {
crate::detlog!(
"[dtid {}] madvise hint {} accepted as record/replay no-op",
guest.thread_state().dettid,
advice,
);
return Ok(0);
}
match action {
MadviseAction::ForwardHint if self.cfg.backend.supports_madvise => {
Ok(self.record_or_replay(guest, call).await?)
}
MadviseAction::ForwardHint => {
crate::detlog!(
"[dtid {}] madvise hint {} accepted as backend no-op",
guest.thread_state().dettid,
advice,
);
Ok(0)
}
MadviseAction::ForwardSemantic
if self.cfg.backend.supports_madvise
|| (advice == libc::MADV_DONTNEED
&& self.cfg.backend.supports_madv_dontneed) =>
{
Ok(self.record_or_replay(guest, call).await?)
}
MadviseAction::ForwardSemantic => {
crate::detlog!(
"[dtid {}] madvise advice {} is unsupported by this backend",
guest.thread_state().dettid,
advice,
);
Err(Errno::ENOSYS.into())
}
MadviseAction::Ignore => {
crate::detlog!(
"[dtid {}] madvise advice {} accepted as deterministic no-op",
guest.thread_state().dettid,
advice,
);
Ok(0)
}
MadviseAction::Reject(errno) => {
crate::detlog!(
"[dtid {}] madvise advice {} rejected with {}",
guest.thread_state().dettid,
advice,
errno,
);
Err(errno.into())
}
MadviseAction::Unknown => {
crate::detlog!(
"[dtid {}] unknown madvise advice {} rejected with EINVAL",
guest.thread_state().dettid,
advice,
);
Err(Errno::EINVAL.into())
}
}
}
pub async fn handle_mincore<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Mincore,
) -> Result<i64, Error> {
let start = call.addr().map(AddrMut::as_raw).unwrap_or(0);
if !start.is_multiple_of(PAGE_SIZE) {
return Err(Errno::EINVAL.into());
}
let len = call.len();
if len == 0 {
return Ok(0);
}
start.checked_add(len).ok_or(Errno::EINVAL)?;
let page_count = len.div_ceil(PAGE_SIZE);
let vec = call.vec().ok_or(Errno::EFAULT)?;
guest.inject(syscalls::Syscall::from(call)).await?;
let residency = vec![1u8; page_count];
guest.memory().write_exact(vec, &residency)?;
Ok(0)
}
}
const BRK_PAGE: u64 = 4096;
fn brk_page_align(address: u64) -> Option<u64> {
Some(address.checked_add(BRK_PAGE - 1)? & !(BRK_PAGE - 1))
}
const STACK_GUARD_GAP: u64 = 256 * BRK_PAGE;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Vma {
start: u64,
end: u64,
start_gap: u64,
}
fn smaps_vmas(smaps: &[u8]) -> SmapsVmas<'_> {
SmapsVmas { rest: smaps }
}
#[derive(Clone)]
struct SmapsVmas<'a> {
rest: &'a [u8],
}
impl<'a> SmapsVmas<'a> {
fn peek(&self) -> Option<&'a [u8]> {
(!self.rest.is_empty()).then(|| {
self.rest
.split(|&byte| byte == b'\n')
.next()
.unwrap_or_default()
})
}
fn advance(&mut self) {
self.rest = match self.rest.iter().position(|&byte| byte == b'\n') {
Some(newline) => &self.rest[newline + 1..],
None => &[],
};
}
}
fn smaps_range(line: &[u8]) -> Option<(u64, u64)> {
let range = line.split(|&byte| byte == b' ').next()?;
let (start, end) = std::str::from_utf8(range).ok()?.split_once('-')?;
Some((
u64::from_str_radix(start, 16).ok()?,
u64::from_str_radix(end, 16).ok()?,
))
}
impl Iterator for SmapsVmas<'_> {
type Item = Vma;
fn next(&mut self) -> Option<Vma> {
let (start, end) = loop {
let line = self.peek()?;
self.advance();
if let Some(range) = smaps_range(line) {
break range;
}
};
let mut vma = Vma {
start,
end,
start_gap: 0,
};
while let Some(line) = self.peek() {
if smaps_range(line).is_some() {
break;
}
self.advance();
if let Some(flags) = line.strip_prefix(b"VmFlags:") {
let mut flags = flags.split(|byte| byte.is_ascii_whitespace());
vma.start_gap = if flags.clone().any(|flag| flag == b"gd") {
STACK_GUARD_GAP
} else if flags.any(|flag| flag == b"ss") {
BRK_PAGE
} else {
0
};
}
}
Some(vma)
}
}
fn brk_may_grow(mut vmas: impl Iterator<Item = Vma>, old_end: u64, new_end: u64) -> bool {
let Some(limit) = new_end.checked_add(BRK_PAGE) else {
return false;
};
let search_end = limit.saturating_add(STACK_GUARD_GAP);
let Some(next) = vmas.find(|vma| vma.end > old_end && vma.start < search_end) else {
return true;
};
let gap_start = next.start.saturating_sub(next.start_gap);
limit <= gap_start
}
fn brk_may_shrink(mut vmas: impl Iterator<Item = Vma>, new_end: u64, old_end: u64) -> bool {
vmas.any(|vma| vma.end > new_end && vma.start < old_end)
}
struct BrkDiagnostic<'a> {
dettid: i32,
model: &'a crate::memory::BrkModel,
requested: u64,
}
struct BrkDiagnosticHex<'a>(&'a [u8]);
impl std::fmt::Display for BrkDiagnosticHex<'_> {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for byte in self.0 {
write!(formatter, "{byte:02x}")?;
}
Ok(())
}
}
impl BrkDiagnostic<'_> {
fn rejected(
&self,
branch: &'static str,
limit: Option<u64>,
smaps: Option<&[u8]>,
kernel_result: &dyn std::fmt::Debug,
) {
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
static CAPTURED: AtomicBool = AtomicBool::new(false);
const MAX_BYTES: usize = 256 * 1024;
if self.requested == 0
|| self.requested == self.model.current
|| !tracing::enabled!(target: "detcore::brk_diagnostic", tracing::Level::DEBUG)
|| CAPTURED.swap(true, Ordering::Relaxed)
{
return;
}
let complete = smaps.is_some_and(|bytes| bytes.len() <= MAX_BYTES);
tracing::debug!(
target: "detcore::brk_diagnostic",
dettid = self.dettid,
requested = self.requested,
start = self.model.start,
current = self.model.current,
data_span = self.model.data_span,
launcher_break = self.model.launcher_break,
?limit,
branch,
?kernel_result,
smaps_len = ?smaps.map(<[u8]>::len),
complete,
"BRK_DENIAL_V1 begin",
);
if complete {
for (index, chunk) in smaps.unwrap().chunks(1024).enumerate() {
tracing::debug!(
target: "detcore::brk_diagnostic",
dettid = self.dettid,
index,
bytes = %BrkDiagnosticHex(chunk),
"BRK_DENIAL_V1 chunk",
);
}
}
tracing::debug!(
target: "detcore::brk_diagnostic",
dettid = self.dettid,
complete,
"BRK_DENIAL_V1 end",
);
}
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
serde::Serialize,
serde::Deserialize
)]
pub enum BrkMappingCheck {
Grow { old_end: u64, new_end: u64 },
Shrink { new_end: u64, old_end: u64 },
}
impl BrkMappingCheck {
pub(crate) fn allows(self, smaps: &[u8]) -> bool {
match self {
Self::Grow { old_end, new_end } => brk_may_grow(smaps_vmas(smaps), old_end, new_end),
Self::Shrink { new_end, old_end } => {
brk_may_shrink(smaps_vmas(smaps), new_end, old_end)
}
}
}
}
impl<T: RecordOrReplay> Detcore<T> {
pub(crate) async fn handle_brk<G: Guest<Self>>(
&self,
guest: &mut G,
call: syscalls::Syscall,
) -> Result<i64, Error> {
let (model, unmodeled) = {
let metadata = guest
.thread_state()
.memory_metadata
.lock()
.expect("memory metadata mutex poisoned");
(metadata.brk_model, metadata.brk_unmodeled.clone())
};
let Some(model) = model else {
let reason = format!(
"unsupported: brk where the kernel's program break is the launcher's and Detcore has no model of the guest's: {}",
unmodeled
.as_deref()
.unwrap_or("the image was never modeled"),
);
return self
.refuse_launched_exe_because(guest, syscalls::Sysno::brk, reason)
.await;
};
let requested = syscalls::SyscallInfo::into_parts(call).1.arg0 as u64;
let granted = match self.granted_brk(guest, &model, requested).await {
Ok(granted) => granted,
Err(reason) => {
return self
.refuse_launched_exe_because(guest, syscalls::Sysno::brk, reason.to_owned())
.await;
}
};
guest
.thread_state()
.memory_metadata
.lock()
.expect("memory metadata mutex poisoned")
.brk_model = Some(crate::memory::BrkModel {
current: granted,
..model
});
Ok(granted as i64)
}
async fn granted_brk<G: Guest<Self>>(
&self,
guest: &mut G,
model: &crate::memory::BrkModel,
requested: u64,
) -> Result<u64, &'static str> {
let current = model.current;
let diagnostic = BrkDiagnostic {
dettid: guest.thread_state().dettid.as_raw(),
model,
requested,
};
if requested < model.start {
if requested >= model.launcher_break {
diagnostic.rejected("below_start_launcher", None, None, &"not_injected");
return Err(
"unsupported: brk from the launcher's break, which the guest's libc read before Detcore modeled the guest's",
);
}
diagnostic.rejected("below_start", None, None, &"not_injected");
return Ok(current);
}
let limit = guest
.thread_state()
.resource_limits
.lock()
.unwrap()
.get(libc::RLIMIT_DATA)
.map_or(libc::RLIM64_INFINITY, |limit| limit.current);
let used = (requested - model.start).saturating_add(model.data_span);
if limit != libc::RLIM64_INFINITY && used > limit {
diagnostic.rejected("rlimit_data", Some(limit), None, &"not_injected");
return Ok(current);
}
let (Some(new_end), Some(old_end)) = (brk_page_align(requested), brk_page_align(current))
else {
diagnostic.rejected("page_overflow", Some(limit), None, &"not_injected");
return Ok(current);
};
if new_end == old_end {
return Ok(requested);
}
let smaps = self
.guest_task_directory(guest)
.and_then(|directory| crate::util::raw_read_listing(&directory.join("smaps")).ok());
let check = if requested <= current {
BrkMappingCheck::Shrink { new_end, old_end }
} else {
BrkMappingCheck::Grow { old_end, new_end }
};
let allowed = match smaps.as_deref() {
Some(smaps) => Some(check.allows(smaps)),
None if guest
.thread_state()
.changed_root
.load(std::sync::atomic::Ordering::SeqCst) =>
{
crate::tool_global::check_brk_mappings(guest, check)
}
None => None,
}
.ok_or_else(|| {
diagnostic.rejected("smaps_unavailable", Some(limit), None, &"not_injected");
"unsupported: brk where Detcore cannot read the guest's mappings"
})?;
if !allowed {
diagnostic.rejected(
if requested <= current {
"shrink_predicate"
} else {
"grow_predicate"
},
Some(limit),
smaps.as_deref(),
&"not_injected",
);
return Ok(current);
}
if requested <= current {
let unmapped = guest
.inject_with_retry(syscalls::Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(syscalls::Addr::from_raw(new_end as usize))
.with_len((old_end - new_end) as usize),
))
.await;
if unmapped.is_err() {
diagnostic.rejected("munmap_error", Some(limit), smaps.as_deref(), &unmapped);
}
return Ok(if unmapped.is_ok() { requested } else { current });
}
let length = new_end - old_end;
let mapped = guest
.inject_with_retry(syscalls::Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(syscalls::Addr::from_raw(old_end as usize))
.with_len(length as usize)
.with_prot(syscalls::ProtFlags::PROT_READ | syscalls::ProtFlags::PROT_WRITE)
.with_flags(
syscalls::MapFlags::MAP_PRIVATE
| syscalls::MapFlags::MAP_ANONYMOUS
| syscalls::MapFlags::MAP_FIXED_NOREPLACE,
)
.with_fd(-1)
.with_offset(0),
))
.await;
match &mapped {
Ok(address) if *address as u64 == old_end => Ok(requested),
Ok(address) => {
let removed = guest
.inject_with_retry(syscalls::Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(syscalls::Addr::from_raw(*address as usize))
.with_len(length as usize),
))
.await;
diagnostic.rejected(
"mmap_wrong_address",
Some(limit),
smaps.as_deref(),
&(&mapped, &removed),
);
if removed.is_ok() {
Ok(current)
} else {
Err(
"unsupported: brk growth the kernel mapped elsewhere and Detcore could not remove",
)
}
}
Err(_) => {
diagnostic.rejected("mmap_error", Some(limit), smaps.as_deref(), &mapped);
Ok(current)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_shared_brk_check_uses_the_existing_mapping_policy() {
let smaps = b"00500000-00501000 rw-p 00000000 00:00 0\nVmFlags: rd wr\n";
let grow = |new_end| BrkMappingCheck::Grow {
old_end: 0x400000,
new_end,
};
assert!(grow(0x4ff000).allows(smaps));
assert!(!grow(0x500000).allows(smaps));
assert!(!grow(u64::MAX - BRK_PAGE + 1).allows(smaps));
assert!(
BrkMappingCheck::Shrink {
new_end: 0x500000,
old_end: 0x501000,
}
.allows(smaps)
);
assert!(
!BrkMappingCheck::Shrink {
new_end: 0x400000,
old_end: 0x500000,
}
.allows(smaps)
);
assert!(grow(0x500000).allows(b""));
assert!(
!BrkMappingCheck::Shrink {
new_end: 0x500000,
old_end: 0x501000,
}
.allows(b"")
);
}
#[test]
fn a_break_grows_and_shrinks_only_where_linuxs_brk_would() {
let smaps = "\
00400000-00401000 r-xp 00000000 00:20 1234 /image
Size: 4 kB
VmFlags: rd ex mr mw me
00406000-00407000 r--p 00000000 00:00 0
VmFlags: rd mr mw me
7ffffff00000-7ffffffff000 rw-p 00000000 00:00 0 [stack]
VmFlags: rd wr mr mw me gd ac
";
let vmas: Vec<Vma> = smaps_vmas(smaps.as_bytes()).collect();
assert_eq!(vmas.len(), 3);
let mut named =
b"00500000-00501000 r--p 00000000 00:20 42 /n\xffme\nVmFlags: rd\n".to_vec();
named.extend_from_slice(smaps.as_bytes());
let named: Vec<Vma> = smaps_vmas(&named).collect();
assert_eq!(named.len(), 4);
assert_eq!(named[1..], vmas[..]);
assert_eq!(
vmas[2],
Vma {
start: 0x7ffffff00000,
end: 0x7ffffffff000,
start_gap: STACK_GUARD_GAP
}
);
assert!(brk_may_grow(vmas.iter().copied(), 0x401000, 0x405000));
assert!(!brk_may_grow(vmas.iter().copied(), 0x401000, 0x406000));
let below_stack = 0x7ffffff00000 - STACK_GUARD_GAP;
assert!(brk_may_grow(
vmas.iter().copied(),
0x500000,
below_stack - BRK_PAGE
));
assert!(!brk_may_grow(vmas.iter().copied(), 0x500000, below_stack));
let shadow: Vec<Vma> =
smaps_vmas(b"00410000-00411000 rw-p 00000000 00:00 0\nVmFlags: rd wr mr mw me ss\n")
.collect();
assert_eq!(shadow[0].start_gap, BRK_PAGE);
assert!(brk_may_grow(shadow.iter().copied(), 0x401000, 0x40e000));
assert!(!brk_may_grow(shadow.iter().copied(), 0x401000, 0x40f000));
assert!(brk_may_shrink(vmas.iter().copied(), 0x405000, 0x407000));
assert!(!brk_may_shrink(vmas.iter().copied(), 0x402000, 0x406000));
}
#[test]
fn madvise_known_linux_advice_has_an_explicit_policy() {
for advice in [
libc::MADV_NORMAL,
libc::MADV_RANDOM,
libc::MADV_SEQUENTIAL,
libc::MADV_WILLNEED,
] {
assert_eq!(madvise_action(advice), MadviseAction::ForwardHint);
}
for advice in [
libc::MADV_DONTNEED,
libc::MADV_DONTFORK,
libc::MADV_DOFORK,
libc::MADV_DONTDUMP,
libc::MADV_DODUMP,
libc::MADV_WIPEONFORK,
libc::MADV_KEEPONFORK,
libc::MADV_DONTNEED_LOCKED,
MADV_GUARD_INSTALL,
MADV_GUARD_REMOVE,
] {
assert_eq!(madvise_action(advice), MadviseAction::ForwardSemantic);
}
for advice in [
libc::MADV_FREE,
libc::MADV_MERGEABLE,
libc::MADV_UNMERGEABLE,
libc::MADV_HUGEPAGE,
libc::MADV_NOHUGEPAGE,
libc::MADV_COLD,
libc::MADV_PAGEOUT,
] {
assert_eq!(madvise_action(advice), MadviseAction::Ignore);
}
for advice in [
libc::MADV_REMOVE,
libc::MADV_POPULATE_READ,
libc::MADV_POPULATE_WRITE,
libc::MADV_COLLAPSE,
] {
assert_eq!(madvise_action(advice), MadviseAction::Reject(Errno::EINVAL));
}
for advice in [libc::MADV_HWPOISON, libc::MADV_SOFT_OFFLINE] {
assert_eq!(madvise_action(advice), MadviseAction::Reject(Errno::EPERM));
}
assert_eq!(madvise_action(i32::MAX), MadviseAction::Unknown);
}
#[test]
fn common_argument_validation_is_host_independent() {
let aligned = unsafe { AddrMut::<libc::c_void>::from_raw_unchecked(0x1000) };
assert!(
validate_common_args(
syscalls::Madvise::new()
.with_addr(Some(aligned))
.with_len(0)
.with_advice(libc::MADV_FREE),
)
.is_ok()
);
let unaligned = unsafe { AddrMut::<libc::c_void>::from_raw_unchecked(0x1001) };
assert!(
validate_common_args(
syscalls::Madvise::new()
.with_addr(Some(unaligned))
.with_len(0)
.with_advice(libc::MADV_FREE),
)
.is_err()
);
let near_end =
unsafe { AddrMut::<libc::c_void>::from_raw_unchecked(usize::MAX & !(PAGE_SIZE - 1)) };
assert!(
validate_common_args(
syscalls::Madvise::new()
.with_addr(Some(near_end))
.with_len(PAGE_SIZE)
.with_advice(libc::MADV_FREE),
)
.is_err()
);
}
}