ptrace stuff

Author: nia-e

Cargo.lock

@@ -40,6 +40,11 @@ libc = "0.2"
 libffi = "4.0.0"
 libloading = "0.8"
 nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"] }
+ipc-channel = "0.19.0"
+serde = { version = "1.0.219", features = ["derive"] }
+
+[target.'cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))'.dependencies]
+iced-x86 = "1.21.0"
 
 [target.'cfg(target_family = "windows")'.dependencies]
 windows-sys = { version = "0.59", features = [

Cargo.toml

@@ -465,13 +465,26 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
  /// This overapproximates the modifications which external code might make to memory:
  /// We set all reachable allocations as initialized, mark all reachable provenances as exposed
  /// and overwrite them with `Provenance::WILDCARD`.
- fn prepare_exposed_for_native_call(&mut self) -> InterpResult<'tcx> {
+ fn prepare_exposed_for_native_call(&mut self, _paranoid: bool) -> InterpResult<'tcx> {
  let this = self.eval_context_mut();
  // We need to make a deep copy of this list, but it's fine; it also serves as scratch space
  // for the search within `prepare_for_native_call`.
  let exposed: Vec<AllocId> =
  this.machine.alloc_addresses.get_mut().exposed.iter().copied().collect();
- this.prepare_for_native_call(exposed)
+ this.prepare_for_native_call(exposed /*, paranoid*/)
+ }
+
+ /// Makes use of information obtained about memory accesses during FFI to determine which
+ /// provenances should be exposed. Note that if `prepare_exposed_for_native_call` was not
+ /// called before the FFI (with `paranoid` set to false) then some of the writes may be
+ /// lost!
+ #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+ fn apply_events(&mut self, _events: crate::shims::trace::MemEvents) -> InterpResult<'tcx> {
+ let this = self.eval_context_mut();
+ let _exposed: Vec<AllocId> =
+ this.machine.alloc_addresses.get_mut().exposed.iter().copied().collect();
+ interp_ok(())
+ //this.apply_accesses(exposed, events.reads, events.writes)
  }
 }
 

src/alloc_addresses/mod.rs

@@ -53,7 +53,6 @@ impl MachineAlloc {
  }
 
  /// Returns a vector of page addresses managed by the allocator.
- #[expect(dead_code)]
  pub fn pages() -> Vec<u64> {
  let alloc = ALLOCATOR.lock().unwrap();
  alloc.pages.clone().into_iter().map(|p| p.addr().to_u64()).collect()
@@ -225,7 +224,6 @@ impl MachineAlloc {
  ///
  /// SAFETY: Accessing memory after this point will result in a segfault
  /// unless it is first unprotected.
- #[expect(dead_code)]
  pub unsafe fn prepare_ffi() -> Result<(), nix::errno::Errno> {
  let mut alloc = ALLOCATOR.lock().unwrap();
  unsafe {
@@ -238,7 +236,6 @@ impl MachineAlloc {
  /// Deprotects all owned memory by setting it to RW. Erroring here is very
  /// likely unrecoverable, so it may panic if applying those permissions
  /// fails.
- #[expect(dead_code)]
  pub fn unprep_ffi() {
  let mut alloc = ALLOCATOR.lock().unwrap();
  let default_flags = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE;

src/discrete_alloc.rs

@@ -19,6 +19,8 @@ pub mod os_str;
 pub mod panic;
 pub mod time;
 pub mod tls;
+#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+pub mod trace;
 
 pub use self::files::FdTable;
 pub use self::unix::{DirTable, EpollInterestTable};