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};