remove some unnecessary state, small refactor

Author: nia-e

src/shims/trace.rs

@@ -258,11 +258,6 @@ fn sv_loop(listener: ChildListener, t_event: ipc::IpcSender<MemEvents>) -> ! {
  // Memory allocated on the MiriMachine
  let mut ch_pages = vec![];
 
- // Random bits of syscall-related state
- let mut enter = true;
- let mut flush_mapped = None;
- let mut munmap_args = None;
-
  // Straight up magic numbers we need
  let malloc_addr = libc::malloc as usize;
  let malloc_bytes = unsafe { (malloc_addr as *mut i64).read_volatile() }; // i'm sorry
@@ -275,7 +270,6 @@ fn sv_loop(listener: ChildListener, t_event: ipc::IpcSender<MemEvents>) -> ! {
  let mut retcode = 0;
 
  #[allow(clippy::cast_possible_wrap)]
- #[allow(clippy::arithmetic_side_effects)]
  'listen: for evt in listener {
  match evt {
  ExecEvent::Status(wait_status) =>
@@ -316,71 +310,25 @@ fn sv_loop(listener: ChildListener, t_event: ipc::IpcSender<MemEvents>) -> ! {
  wait::WaitStatus::PtraceSyscall(pid) => {
  let regs = ptrace::getregs(pid).unwrap();
  let syscall_nr = regs.syscall_nr();
- if enter {
- if syscall_nr as i64 == libc::SYS_mmap {
+ match syscall_nr as i64 {
+ n if n == libc::SYS_mmap => {
+ // No need for a discrete fn here, it's very tiny
  let len = regs.arg2();
- flush_mapped = Some(len);
- } else if syscall_nr as i64 == libc::SYS_munmap {
- // The unmap call might hit multiple mappings we've saved,
- // or overlap with them partially (or both)
- let um_start = regs.arg1();
- let um_len = regs.arg2();
- let um_end = um_start + um_len;
- let mut idxes = vec![];
- for (idx, &(mp_start, len)) in mappings.iter().enumerate() {
- let mp_end = mp_start + len;
- let cond = (mp_start..mp_end).contains(&um_start)
- || (mp_start..mp_end).contains(&um_end)
- || (um_start..um_end).contains(&mp_start);
-
- if cond {
- idxes.push(idx);
- }
- }
- if !idxes.is_empty() {
- // We iterate thru this later while removing elements so if
- // it's not reversed we will mess up the mappings badly!
- idxes.reverse();
- munmap_args = Some((idxes, um_start, um_len));
- }
- } // TODO: handle brk/sbrk
- } else {
- if syscall_nr as i64 == libc::SYS_mmap {
+ ptrace::syscall(pid, None).unwrap();
+ let _ = wait::waitpid(pid, None).unwrap();
+ let regs = ptrace::getregs(pid).unwrap();
  if regs.retval() as isize > 0 {
- if let Some(len) = flush_mapped.take() {
- let addr = regs.retval();
- mappings.push((addr, len as _));
- } else {
- eprintln!(
- "Process returned from mmap syscall without entering it? Attempting to continue..."
- );
- }
+ let addr = regs.retval();
+ mappings.push((addr, len as _));
  }
- } else if syscall_nr as i64 == libc::SYS_munmap {
- if let Some((idxes, um_start, um_len)) = munmap_args.take() {
- if regs.retval() as isize > 0 {
- // Unmap succeeded, so take out the mapping(s) from our list
- // but it may be only partial so we may readd some sections
- for idx in idxes {
- let um_end = um_start + um_len;
- let (mp_start, mp_len) = mappings.remove(idx);
- let mp_end = mp_len + mp_len;
-
- if mp_start < um_start {
- let preserved_len_head = um_start - mp_start;
- mappings.push((mp_start, preserved_len_head));
- }
- if mp_end > um_end {
- let preserved_len_tail = mp_end - um_end;
- mappings.push((um_end, preserved_len_tail));
- }
- }
- }
- }
- }
+ },
+ n if n == libc::SYS_munmap => {
+ handle_munmap(pid, regs, &mut mappings);
+ },
+ // TODO: handle brk/sbrk
+ _ => (),
  }
 
- enter = !enter;
  ptrace::syscall(pid, None).unwrap();
  }
  _ => (),
@@ -428,6 +376,53 @@ fn sv_loop(listener: ChildListener, t_event: ipc::IpcSender<MemEvents>) -> ! {
  std::process::exit(retcode);
 }
 
+#[allow(clippy::arithmetic_side_effects)]
+#[allow(clippy::cast_possible_wrap)]
+fn handle_munmap(pid: unistd::Pid, regs: libc::user_regs_struct, mappings: &mut Vec<(usize, usize)>) {
+ // The unmap call might hit multiple mappings we've saved,
+ // or overlap with them partially (or both)
+ let um_start = regs.arg1();
+ let um_len = regs.arg2();
+ let um_end = um_start + um_len;
+ let mut idxes = vec![];
+ for (idx, &(mp_start, len)) in mappings.iter().enumerate() {
+ let mp_end = mp_start + len;
+ let cond = (mp_start..mp_end).contains(&um_start)
+ || (mp_start..mp_end).contains(&um_end)
+ || (um_start..um_end).contains(&mp_start);
+
+ if cond {
+ idxes.push(idx);
+ }
+ }
+ // We iterate thru this while removing elements so if
+ // it's not reversed we will mess up the mappings badly!
+ idxes.reverse();
+
+ ptrace::syscall(pid, None).unwrap();
+ let _ = wait::waitpid(pid, None).unwrap();
+ let regs = ptrace::getregs(pid).unwrap();
+
+ if regs.retval() as isize > 0 {
+ // Unmap succeeded, so take out the mapping(s) from our list
+ // but it may be only partial so we may readd some sections
+ for idx in idxes {
+ let um_end = um_start + um_len;
+ let (mp_start, mp_len) = mappings.remove(idx);
+ let mp_end = mp_len + mp_len;
+
+ if mp_start < um_start {
+ let preserved_len_head = um_start - mp_start;
+ mappings.push((mp_start, preserved_len_head));
+ }
+ if mp_end > um_end {
+ let preserved_len_tail = mp_end - um_end;
+ mappings.push((um_end, preserved_len_tail));
+ }
+ }
+ }
+}
+
 #[allow(clippy::cast_possible_wrap)]
 #[allow(clippy::arithmetic_side_effects)]
 fn handle_segfault(
@@ -604,6 +599,8 @@ fn intercept_retptr(
  ptr
 }
 
+
+
 // We only get dropped into these functions via offsetting the instr pointer
 // manually, so we *must not ever* unwind from it
 pub unsafe extern "C" fn mempr_off() {