Remove parameter byte from FileDescription::read/pread

Author: tiif

src/shims/unix/fd.rs

@@ -30,9 +30,8 @@ pub trait FileDescription: std::fmt::Debug + Any {
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _bytes: &mut [u8],
-        _len: usize,
         _ptr: Pointer,
+        _len: u64,
         _dest: &MPlaceTy<'tcx>,
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx> {
@@ -56,9 +55,9 @@ pub trait FileDescription: std::fmt::Debug + Any {
     fn pread<'tcx>(
         &self,
         _communicate_allowed: bool,
-        _bytes: &mut [u8],
         _offset: u64,
         _ptr: Pointer,
+        _len: u64,
         _dest: &MPlaceTy<'tcx>,
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx> {
@@ -132,18 +131,18 @@ impl FileDescription for io::Stdin {
         &self,
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        bytes: &mut [u8],
-        _len: usize,
         ptr: Pointer,
+        len: u64,
         dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx> {
+        let mut bytes = vec![0; usize::try_from(len).unwrap()];
         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")?;
         }
-        let result = Read::read(&mut { self }, bytes);
-        ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
+        let result = Read::read(&mut { self }, &mut bytes);
+        ecx.read_byte_helper(ptr, bytes, result, dest)?;
         Ok(())
     }
 
@@ -585,18 +584,16 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // because it was a target's `usize`. Also we are sure that its smaller than
         // `usize::MAX` because it is bounded by the host's `isize`.
 
-        let len = usize::try_from(count).unwrap();
-        let mut bytes = vec![0; len];
         match offset {
-            None => fd.read(&fd, communicate, &mut bytes, len, buf, dest, this)?,
+            None => fd.read(&fd, communicate, buf, count, 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_int(-1, dest)?;
                     return Ok(());
                 };
-                fd.pread(communicate, &mut bytes, offset, buf, dest, this)?
+                fd.pread(communicate, offset, buf, count, dest, this)?
             }
         };
         Ok(())
@@ -682,7 +679,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
     }
 
-
     /// This function either writes to the user supplied buffer and to dest place, or return error.
     // TODO: this is only used for eventfd
     fn read_byte_helper_ev(

src/shims/unix/fs.rs

@@ -34,14 +34,14 @@ impl FileDescription for FileHandle {
         &self,
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        bytes: &mut [u8],
-        _len: usize,
         ptr: Pointer,
+        len: u64,
         dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        let result = (&mut &self.file).read(bytes);
+        let mut bytes = vec![0; usize::try_from(len).unwrap()];
+        let result = (&mut &self.file).read(&mut bytes);
         ecx.read_byte_helper(ptr, bytes.to_vec(), result, dest)?;
         Ok(())
     }
@@ -63,21 +63,22 @@ impl FileDescription for FileHandle {
     fn pread<'tcx>(
         &self,
         communicate_allowed: bool,
-        bytes: &mut [u8],
         offset: u64,
         ptr: Pointer,
+        len: u64,
         dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
+        let mut bytes = vec![0; usize::try_from(len).unwrap()];
         // Emulates pread using seek + read + seek to restore cursor position.
         // Correctness of this emulation relies on sequential nature of Miri execution.
         // The closure is used to emulate `try` block, since we "bubble" `io::Error` using `?`.
         let file = &mut &self.file;
         let mut f = || {
             let cursor_pos = file.stream_position()?;
             file.seek(SeekFrom::Start(offset))?;
-            let res = file.read(bytes);
+            let res = file.read(&mut bytes);
             // Attempt to restore cursor position even if the read has failed
             file.seek(SeekFrom::Start(cursor_pos))
                 .expect("failed to restore file position, this shouldn't be possible");

src/shims/unix/linux/eventfd.rs

@@ -62,16 +62,15 @@ impl FileDescription for Event {
         &self,
         self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _bytes: &mut [u8],
-        len: usize,
         ptr: Pointer,
+        len: u64,
         dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx> {
         // eventfd read at the size of u64.
         let buf_place = ecx.ptr_to_mplace(ptr, ecx.machine.layouts.u64);
         // Check the size of slice, and return error only if the size of the slice < 8.
-        if len < U64_ARRAY_SIZE {
+        if len < U64_ARRAY_SIZE.try_into().unwrap() {
             let result = Err(Error::from(ErrorKind::InvalidInput));
             ecx.read_byte_helper_ev(&buf_place, None, result, dest)?;
             return Ok(());

src/shims/unix/unnamed_socket.rs

@@ -126,13 +126,13 @@ impl FileDescription for AnonSocket {
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &mut [u8],
-        _len: usize,
         ptr: Pointer,
+        len: u64,
         dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx> {
-        let request_byte_size = bytes.len();
+        let request_byte_size = len;
+        let mut bytes = vec![0; usize::try_from(len).unwrap()];
 
         // Always succeed on read size 0.
         if request_byte_size == 0 {
@@ -179,7 +179,7 @@ impl FileDescription for AnonSocket {
 
         // Do full read / partial read based on the space available.
         // Conveniently, `read` exists on `VecDeque` and has exactly the desired behavior.
-        let actual_read_size = readbuf.buf.read(bytes).unwrap();
+        let actual_read_size = readbuf.buf.read(&mut bytes).unwrap();
 
         // Need to drop before others can access the readbuf again.
         drop(readbuf);