Use read_byte_pointer in every FileDescription::read

Author: tiif

src/shims/unix/fd.rs

@@ -128,15 +128,18 @@ impl FileDescription for io::Stdin {
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
         bytes: &mut [u8],
-        _ptr: Pointer,
-        _dest: &MPlaceTy<'tcx>,
-        _ecx: &mut MiriInterpCx<'tcx>,
+        ptr: Pointer,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         if !communicate_allowed {
             // We want isolation mode to be deterministic, so we have to disallow all reads, even stdin.
             helpers::isolation_abort_error("`read` from stdin")?;
         }
-        Ok(Read::read(&mut { self }, bytes))
+        let result = Ok(Read::read(&mut { self }, bytes));
+        ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+        // TODO: remove the usize later
+        Ok(Ok(0))
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {
@@ -572,19 +575,21 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // `usize::MAX` because it is bounded by the host's `isize`.
 
         let mut bytes = vec![0; usize::try_from(count).unwrap()];
-        let result = match offset {
-            None => fd.read(&fd, communicate, &mut bytes, buf, dest, this),
+        // TODO: fix this later, handle this properly
+        let _res = match offset {
+            None => fd.read(&fd, communicate, &mut bytes, buf, dest, this)?,
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
                     this.set_last_error(einval)?;
                     this.write_scalar(Scalar::from_target_isize(-1, this), dest)?;
                     return Ok(());
                 };
-                fd.pread(communicate, &mut bytes, offset, this)
+                let result = fd.pread(communicate, &mut bytes, offset, this);
+                self.read_byte_helper(buf, bytes, result, dest)?;
+                return Ok(());
             }
         };
-        self.read_byte_helper(buf, bytes, result, dest)?;
         Ok(())
     }
 

src/shims/unix/fs.rs

@@ -35,12 +35,15 @@ impl FileDescription for FileHandle {
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
         bytes: &mut [u8],
-        _ptr: Pointer,
-        _dest: &MPlaceTy<'tcx>,
-        _ecx: &mut MiriInterpCx<'tcx>,
+        ptr: Pointer,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        Ok((&mut &self.file).read(bytes))
+        let result = Ok((&mut &self.file).read(bytes));
+        ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+        // TODO: remove the usize later
+        Ok(Ok(0))
     }
 
     fn write<'tcx>(

src/shims/unix/linux/eventfd.rs

@@ -63,19 +63,25 @@ impl FileDescription for Event {
         self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &mut [u8],
-        _ptr: Pointer,
-        _dest: &MPlaceTy<'tcx>,
+        ptr: Pointer,
+        dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         // Check the size of slice, and return error only if the size of the slice < 8.
         let Some(bytes) = bytes.first_chunk_mut::<U64_ARRAY_SIZE>() else {
-            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
+            let result = Ok(Err(Error::from(ErrorKind::InvalidInput)));
+            ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+            // TODO: remove the usize later
+            return Ok(Ok(0));
         };
         // Block when counter == 0.
         let counter = self.counter.get();
         if counter == 0 {
             if self.is_nonblock {
-                return Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                let result = Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+                // TODO: remove the usize later
+                return Ok(Ok(0));
             } else {
                 //FIXME: blocking is not supported
                 throw_unsup_format!("eventfd: blocking is unsupported");
@@ -93,7 +99,10 @@ impl FileDescription for Event {
             // types for current file description.
             ecx.check_and_update_readiness(self_ref)?;
 
-            return Ok(Ok(U64_ARRAY_SIZE));
+            let result = Ok(Ok(U64_ARRAY_SIZE));
+            ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+            // TODO: remove the usize later
+            return Ok(Ok(0));
         }
     }
 

src/shims/unix/unnamed_socket.rs

@@ -127,14 +127,17 @@ impl FileDescription for AnonSocket {
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &mut [u8],
-        _ptr: Pointer,
-        _dest: &MPlaceTy<'tcx>,
+        ptr: Pointer,
+        dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         let request_byte_size = bytes.len();
 
         // Always succeed on read size 0.
         if request_byte_size == 0 {
+            let result = Ok(Ok(0));
+            ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+            // TODO: remove the usize later
             return Ok(Ok(0));
         }
 
@@ -148,6 +151,9 @@ impl FileDescription for AnonSocket {
             if self.peer_fd().upgrade().is_none() {
                 // Socketpair with no peer and empty buffer.
                 // 0 bytes successfully read indicates end-of-file.
+                let result = Ok(Ok(0));
+                ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+                // TODO: remove the usize later
                 return Ok(Ok(0));
             } else {
                 if self.is_nonblock {
@@ -156,7 +162,10 @@ impl FileDescription for AnonSocket {
                     // EAGAIN or EWOULDBLOCK can be returned for socket,
                     // POSIX.1-2001 allows either error to be returned for this case.
                     // Since there is no ErrorKind for EAGAIN, WouldBlock is used.
-                    return Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                    let result = Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                    ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+                    // TODO: remove the usize later
+                    return Ok(Ok(0));
                 } else {
                     // Blocking socketpair with writer and empty buffer.
                     // FIXME: blocking is currently not supported
@@ -188,7 +197,10 @@ impl FileDescription for AnonSocket {
             ecx.check_and_update_readiness(&peer_fd)?;
         }
 
-        return Ok(Ok(actual_read_size));
+        let result = Ok(Ok(actual_read_size));
+        ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+        // TODO: remove the usize later
+        return Ok(Ok(0));
     }
 
     fn write<'tcx>(