Move error helper to helper.rs

Author: tiif

src/helpers.rs

@@ -1,9 +1,9 @@
-use std::cmp;
 use std::collections::BTreeSet;
 use std::iter;
 use std::num::NonZero;
 use std::sync::Mutex;
 use std::time::Duration;
+use std::{cmp, io};
 
 use rand::RngCore;
 
@@ -846,6 +846,17 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         self.set_last_error(self.io_error_to_errnum(err)?)
     }
 
+    /// Sets the last OS error using a `std::io::ErrorKind` and writes -1 to dest place.
+    fn set_io_error_and_return_neg_one(
+        &mut self,
+        err: io::Error,
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
+        self.set_last_error(self.io_error_to_errnum(err)?)?;
+        self.write_int(-1, dest)?;
+        Ok(())
+    }
+
     /// Helper function that consumes an `std::io::Result<T>` and returns an
     /// `InterpResult<'tcx,T>::Ok` instead. In case the result is an error, this function returns
     /// `Ok(-1)` and sets the last OS error accordingly.

src/shims/unix/fd.rs

@@ -154,7 +154,7 @@ impl FileDescription for io::Stdin {
         match result {
             Ok(rw_bytes) =>
                 ecx.return_read_write_success(Some(ptr), Some(&bytes), true, rw_bytes, dest),
-            Err(e) => ecx.return_read_write_error(e, dest),
+            Err(e) => ecx.set_io_error_and_return_neg_one(e, dest),
         }
     }
 
@@ -188,7 +188,7 @@ impl FileDescription for io::Stdout {
         io::stdout().flush().unwrap();
         match result {
             Ok(rw_bytes) => ecx.return_read_write_success(None, None, false, rw_bytes, dest),
-            Err(e) => ecx.return_read_write_error(e, dest),
+            Err(e) => ecx.set_io_error_and_return_neg_one(e, dest),
         }
     }
 
@@ -217,7 +217,7 @@ impl FileDescription for io::Stderr {
         let result = Write::write(&mut { self }, bytes);
         match result {
             Ok(rw_bytes) => ecx.return_read_write_success(None, None, false, rw_bytes, dest),
-            Err(e) => ecx.return_read_write_error(e, dest),
+            Err(e) => ecx.set_io_error_and_return_neg_one(e, dest),
         }
     }
 
@@ -690,18 +690,4 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         this.write_int(u64::try_from(actual_rw_size).unwrap(), dest)?;
         Ok(())
     }
-
-    /// Helper to implement `FileDescription::read/write`.
-    /// This is only used when there is a read/write error.
-    ///`-1` is written to `dest` and the last libc error is set appropriately.
-    fn return_read_write_error(
-        &mut self,
-        err: io::Error,
-        dest: &MPlaceTy<'tcx>,
-    ) -> InterpResult<'tcx> {
-        let this = self.eval_context_mut();
-        this.set_last_error(this.io_error_to_errnum(err)?)?;
-        this.write_int(-1, dest)?;
-        Ok(())
-    }
 }

src/shims/unix/fs.rs

@@ -45,7 +45,7 @@ impl FileDescription for FileHandle {
         match result {
             Ok(rw_bytes) =>
                 ecx.return_read_write_success(Some(ptr), Some(&bytes), true, rw_bytes, dest),
-            Err(e) => ecx.return_read_write_error(e, dest),
+            Err(e) => ecx.set_io_error_and_return_neg_one(e, dest),
         }
     }
 
@@ -63,7 +63,7 @@ impl FileDescription for FileHandle {
         let result = (&mut &self.file).write(bytes);
         match result {
             Ok(rw_bytes) => ecx.return_read_write_success(None, None, false, rw_bytes, dest),
-            Err(e) => ecx.return_read_write_error(e, dest),
+            Err(e) => ecx.set_io_error_and_return_neg_one(e, dest),
         }
     }
 
@@ -95,7 +95,7 @@ impl FileDescription for FileHandle {
         match result {
             Ok(rw_bytes) =>
                 ecx.return_read_write_success(Some(ptr), Some(&bytes), true, rw_bytes, dest),
-            Err(e) => ecx.return_read_write_error(e, dest),
+            Err(e) => ecx.set_io_error_and_return_neg_one(e, dest),
         }
     }
 
@@ -126,7 +126,7 @@ impl FileDescription for FileHandle {
         let result = f();
         match result {
             Ok(rw_bytes) => ecx.return_read_write_success(None, None, false, rw_bytes, dest),
-            Err(e) => ecx.return_read_write_error(e, dest),
+            Err(e) => ecx.set_io_error_and_return_neg_one(e, dest),
         }
     }
 

src/shims/unix/linux/eventfd.rs

@@ -127,7 +127,7 @@ impl FileDescription for Event {
         let ty = ecx.machine.layouts.u64;
         // Check the size of slice, and return error only if the size of the slice < 8.
         if len < ty.layout.size.bytes_usize() {
-            return ecx.return_read_write_error(Error::from(ErrorKind::InvalidInput), dest);
+            return ecx.set_io_error_and_return_neg_one(Error::from(ErrorKind::InvalidInput), dest);
         }
 
         // Read the user supplied value from the pointer.
@@ -136,7 +136,7 @@ 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 ecx.return_read_write_error(Error::from(ErrorKind::InvalidInput), dest);
+            return ecx.set_io_error_and_return_neg_one(Error::from(ErrorKind::InvalidInput), dest);
         }
         // If the addition does not let the counter to exceed the maximum value, update the counter.
         // Else, block.
@@ -150,7 +150,8 @@ impl FileDescription for Event {
             }
             None | Some(u64::MAX) =>
                 if self.is_nonblock {
-                    return ecx.return_read_write_error(Error::from(ErrorKind::WouldBlock), dest);
+                    return ecx
+                        .set_io_error_and_return_neg_one(Error::from(ErrorKind::WouldBlock), dest);
                 } else {
                     throw_unsup_format!("eventfd: blocking is unsupported");
                 },

src/shims/unix/unnamed_socket.rs

@@ -158,7 +158,8 @@ 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 ecx.return_read_write_error(Error::from(ErrorKind::WouldBlock), dest);
+                    return ecx
+                        .set_io_error_and_return_neg_one(Error::from(ErrorKind::WouldBlock), dest);
                 } else {
                     // Blocking socketpair with writer and empty buffer.
                     // FIXME: blocking is currently not supported
@@ -212,7 +213,7 @@ impl FileDescription for AnonSocket {
         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 ecx.return_read_write_error(Error::from(ErrorKind::BrokenPipe), dest);
+            return ecx.set_io_error_and_return_neg_one(Error::from(ErrorKind::BrokenPipe), dest);
         };
 
         let Some(writebuf) = &peer_fd.downcast::<AnonSocket>().unwrap().readbuf else {
@@ -226,7 +227,8 @@ impl FileDescription for AnonSocket {
         if available_space == 0 {
             if self.is_nonblock {
                 // Non-blocking socketpair with a full buffer.
-                return ecx.return_read_write_error(Error::from(ErrorKind::WouldBlock), dest);
+                return ecx
+                    .set_io_error_and_return_neg_one(Error::from(ErrorKind::WouldBlock), dest);
             } else {
                 // Blocking socketpair with a full buffer.
                 throw_unsup_format!("socketpair write: blocking isn't supported yet");