Add basic tests

Author: tiif

src/shims/unix/linux/eventfd.rs

@@ -48,14 +48,10 @@ impl FileDescription for Event {
         bytes: &mut [u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
-        // Use bytes[0..8] so it won't fail when bytes's size > 8.
-        let mut buffer = match bytes[0..8].try_into() {
-            Ok(bytes) => bytes,
-            Err(_) => {
-                // Size of bytes is less than 8.
-                return Ok(Err(Error::from(ErrorKind::InvalidInput)));
-            }
-        };
+        // Check the size of slice, and return error only if the size of the slice < 8.
+        if <[u8; 8]>::try_from(&bytes[0..8]).is_err() {
+            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
+        }
         if self.counter == 0 {
             if self.is_nonblock {
                 return Ok(Err(Error::from(ErrorKind::WouldBlock)));
@@ -65,13 +61,12 @@ impl FileDescription for Event {
             }
         } else {
             // Return the counter in the host endianness using the buffer provided by caller.
-            //TODO: check if why mutable bytes is not used? is this not the same buffer?
-            buffer = match ecx.tcx.sess.target.endian {
+            let counter_byte: [u8; 8] = match ecx.tcx.sess.target.endian {
                 Endian::Little => self.counter.to_le_bytes(),
                 Endian::Big => self.counter.to_be_bytes(),
             };
+            bytes.copy_from_slice(&counter_byte);
             self.counter = 0;
-            // It is always 8 bytes being read.
             return Ok(Ok(8));
         }
     }
@@ -94,7 +89,7 @@ impl FileDescription for Event {
         bytes: &[u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
-        let mut bytes = match bytes[0..8].try_into() {
+        let bytes = match bytes[0..8].try_into() {
             Ok(bytes) => bytes,
             Err(_) => {
                 // Size of bytes is less than 8.
@@ -121,7 +116,7 @@ impl FileDescription for Event {
                 throw_unsup_format!("eventfd: blocking is unsupported");
             }
         } else {
-            self.counter.checked_add(num).unwrap();
+            self.counter = self.counter.checked_add(num).unwrap();
         }
         Ok(Ok(8))
     }

tests/pass-dep/libc/libc-eventfd.rs

@@ -0,0 +1,37 @@
+//@ignore-target-windows: No eventfd in windows
+
+fn main() {
+    test_read_write();
+}
+
+fn test_read_write() {
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+    let data: [u8; 8];
+    if cfg!(target_endian = "big") {
+        // Adjust the data based on the endianess of host system.
+        data = [0, 0, 0, 0, 0, 0, 0, 1];
+    } else {
+        data = [1, 0, 0, 0, 0, 0, 0, 0];
+    }
+    // Write 1 to the counter
+    let res: i64 =
+        unsafe { libc::write(fd, data.as_ptr() as *const libc::c_void, 8).try_into().unwrap() };
+    assert_eq!(res, 8);
+
+    // Read 1 from the counter
+    let mut buf: [u8; 8] = [1; 8];
+    let res: i32 = unsafe {
+        libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    // read returns number of bytes has been read, which is always 8
+    assert_eq!(res, 8);
+    let counter: u64;
+    if cfg!(target_endian = "big") {
+        // Read will store the bytes based on the endianess of the host system.
+        counter = u64::from_be_bytes(buf);
+    } else {
+        counter = u64::from_le_bytes(buf);
+    }
+    assert_eq!(counter, 1);
+}