Failed test commit: some fail-dep test start to emit UB message

tiif · tiif · commit cf692d6c843e · 2024-09-14T17:20:54.000+08:00
diff --git a/src/shims/unix/fd.rs b/src/shims/unix/fd.rs
@@ -161,19 +161,19 @@ impl FileDescription for io::Stdout {
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &[u8],
-        _dest: &MPlaceTy<'tcx>,
-        _ecx: &mut MiriInterpCx<'tcx>,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         // We allow writing to stderr even with isolation enabled.
-        let result = Write::write(&mut { self }, bytes);
+        let result = Ok(Write::write(&mut { self }, bytes));
         // Stdout is buffered, flush to make sure it appears on the
         // screen.  This is the write() syscall of the interpreted
         // program, we want it to correspond to a write() syscall on
         // the host -- there is no good in adding extra buffering
         // here.
         io::stdout().flush().unwrap();
-
-        Ok(result)
+        ecx.write_byte_helper(result, dest)?;
+        Ok(Ok(0))
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {
@@ -191,12 +191,14 @@ impl FileDescription for io::Stderr {
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &[u8],
-        _dest: &MPlaceTy<'tcx>,
-        _ecx: &mut MiriInterpCx<'tcx>,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         // We allow writing to stderr even with isolation enabled.
         // No need to flush, stderr is not buffered.
-        Ok(Write::write(&mut { self }, bytes))
+        let result = Ok(Write::write(&mut { self }, bytes));
+        ecx.write_byte_helper(result, dest)?;
+        Ok(Ok(0))
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {
@@ -218,11 +220,13 @@ impl FileDescription for NullOutput {
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &[u8],
-        _dest: &MPlaceTy<'tcx>,
-        _ecx: &mut MiriInterpCx<'tcx>,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         // We just don't write anything, but report to the user that we did.
-        Ok(Ok(bytes.len()))
+        let result = Ok(Ok(bytes.len()));
+        ecx.write_byte_helper(result, dest)?;
+        Ok(Ok(0))
     }
 }
 
@@ -627,7 +631,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             return Ok(());
         };
 
-        let result = match offset {
+        let _result = match offset {
             None => fd.write(&fd, communicate, &bytes, dest, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
@@ -640,9 +644,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 fd.pwrite(communicate, &bytes, offset, dest, this)
             }
         };
-        self.write_byte_helper(result, dest)?;
         Ok(())
-        //Ok(Scalar::from_target_isize(this.try_unwrap_io_result(result)?, this))
     }
 
     /// This function write bytes to the user supplied buffer and write the total number of bytes
diff --git a/src/shims/unix/fs.rs b/src/shims/unix/fs.rs
@@ -51,11 +51,13 @@ impl FileDescription for FileHandle {
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
         bytes: &[u8],
-        _dest: &MPlaceTy<'tcx>,
-        _ecx: &mut MiriInterpCx<'tcx>,
+        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).write(bytes))
+        let result = Ok((&mut &self.file).write(bytes));
+        ecx.write_byte_helper(result, dest)?;
+        Ok(Ok(0))
     }
 
     fn pread<'tcx>(
@@ -92,8 +94,8 @@ impl FileDescription for FileHandle {
         communicate_allowed: bool,
         bytes: &[u8],
         offset: u64,
-        _dest: &MPlaceTy<'tcx>,
-        _ecx: &mut MiriInterpCx<'tcx>,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
         // Emulates pwrite using seek + write + seek to restore cursor position.
@@ -109,7 +111,9 @@ impl FileDescription for FileHandle {
                 .expect("failed to restore file position, this shouldn't be possible");
             res
         };
-        Ok(f())
+        let result = Ok(f());
+        ecx.write_byte_helper(result, dest)?;
+        Ok(Ok(0))
     }
 
     fn seek<'tcx>(
diff --git a/src/shims/unix/linux/eventfd.rs b/src/shims/unix/linux/eventfd.rs
@@ -123,12 +123,14 @@ impl FileDescription for Event {
         self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &[u8],
-        _dest: &MPlaceTy<'tcx>,
+        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::<U64_ARRAY_SIZE>() else {
-            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
+            let result = Ok(Err(Error::from(ErrorKind::InvalidInput)));
+            ecx.write_byte_helper(result, dest)?;
+            return Ok(Ok(0));
         };
         // Convert from bytes to int according to host endianness.
         let num = match ecx.tcx.sess.target.endian {
@@ -137,7 +139,9 @@ impl FileDescription for Event {
         };
         // u64::MAX as input is invalid because the maximum value of counter is u64::MAX - 1.
         if num == u64::MAX {
-            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
+            let result = Ok(Err(Error::from(ErrorKind::InvalidInput)));
+            ecx.write_byte_helper(result, dest)?;
+            return Ok(Ok(0));
         }
         // If the addition does not let the counter to exceed the maximum value, update the counter.
         // Else, block.
@@ -151,7 +155,9 @@ impl FileDescription for Event {
             }
             None | Some(u64::MAX) => {
                 if self.is_nonblock {
-                    return Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                    let result = Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                    ecx.write_byte_helper(result, dest)?;
+                    return Ok(Ok(0));
                 } else {
                     //FIXME: blocking is not supported
                     throw_unsup_format!("eventfd: blocking is unsupported");
@@ -162,7 +168,9 @@ impl FileDescription for Event {
         // types for current file description.
         ecx.check_and_update_readiness(self_ref)?;
 
-        Ok(Ok(U64_ARRAY_SIZE))
+        let result = Ok(Ok(U64_ARRAY_SIZE));
+        ecx.write_byte_helper(result, dest)?;
+        Ok(Ok(0))
     }
 }
 
diff --git a/src/shims/unix/unnamed_socket.rs b/src/shims/unix/unnamed_socket.rs
@@ -208,21 +208,25 @@ impl FileDescription for AnonSocket {
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &[u8],
-        _dest: &MPlaceTy<'tcx>,
+        dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         let write_size = bytes.len();
         // Always succeed on write size 0.
         // ("If count is zero and fd refers to a file other than a regular file, the results are not specified.")
         if write_size == 0 {
+            let result = Ok(Ok(0));
+            ecx.write_byte_helper(result, dest)?;
             return Ok(Ok(0));
         }
 
         // We are writing to our peer's readbuf.
         let Some(peer_fd) = self.peer_fd().upgrade() else {
             // If the upgrade from Weak to Rc fails, it indicates that all read ends have been
             // closed.
-            return Ok(Err(Error::from(ErrorKind::BrokenPipe)));
+            let result = Ok(Err(Error::from(ErrorKind::BrokenPipe)));
+            ecx.write_byte_helper(result, dest)?;
+            return Ok(Ok(0));
         };
 
         let Some(writebuf) = &peer_fd.downcast::<AnonSocket>().unwrap().readbuf else {
@@ -257,7 +261,9 @@ impl FileDescription for AnonSocket {
         // The kernel does this even if the fd was already readable before, so we follow suit.
         ecx.check_and_update_readiness(&peer_fd)?;
 
-        return Ok(Ok(actual_write_size));
+        let result = Ok(Ok(actual_write_size));
+        ecx.write_byte_helper(result, dest)?;
+        return Ok(Ok(0));
     }
 }
 
