Pass Pointer to read function

Author: tiif

src/shims/unix/fd.rs

@@ -31,6 +31,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         _bytes: &mut [u8],
+        _ptr: Pointer,
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         throw_unsup_format!("cannot read from {}", self.name());
@@ -126,6 +127,7 @@ impl FileDescription for io::Stdin {
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
         bytes: &mut [u8],
+        _ptr: Pointer,
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         if !communicate_allowed {
@@ -563,9 +565,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // We want to read at most `count` bytes. We are sure that `count` is not negative
         // 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`.
+
+        // TODO: shouldn't pass vec, just pass pointer and write it.
         let mut bytes = vec![0; usize::try_from(count).unwrap()];
         let result = match offset {
-            None => fd.read(&fd, communicate, &mut bytes, this),
+            None => fd.read(&fd, communicate, &mut bytes, buf, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
@@ -578,10 +582,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // `File::read` never returns a value larger than `count`, so this cannot fail.
         match result?.map(|c| i64::try_from(c).unwrap()) {
+            // TODO: get the byte out the result, then write the ptr.
+            // try to pass this the write_ptr inside write
+            // Pass the pointer inside the write function.
             Ok(read_bytes) => {
                 // If reading to `bytes` did not fail, we write those bytes to the buffer.
                 // Crucially, if fewer than `bytes.len()` bytes were read, only write
                 // that much into the output buffer!
+
+                // TODO: write to pointer here.
                 this.write_bytes_ptr(
                     buf,
                     bytes[..usize::try_from(read_bytes).unwrap()].iter().copied(),

src/shims/unix/fs.rs

@@ -35,6 +35,7 @@ impl FileDescription for FileHandle {
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
         bytes: &mut [u8],
+        _ptr: Pointer,
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");

src/shims/unix/linux/eventfd.rs

@@ -63,6 +63,7 @@ impl FileDescription for Event {
         self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &mut [u8],
+        _ptr: Pointer,
         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.

src/shims/unix/unnamed_socket.rs

@@ -127,6 +127,7 @@ impl FileDescription for AnonSocket {
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
         bytes: &mut [u8],
+        _ptr: Pointer,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         let request_byte_size = bytes.len();