Add more pass test and race test

Author: tiif

src/shims/unix/linux/eventfd.rs

@@ -49,7 +49,7 @@ impl FileDescription for Event {
         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.
-        if <[u8; 8]>::try_from(&bytes[0..8]).is_err() {
+        if bytes.first_chunk::<8>().is_none() {
             return Ok(Err(Error::from(ErrorKind::InvalidInput)));
         }
         if self.counter == 0 {
@@ -65,7 +65,8 @@ impl FileDescription for Event {
                 Endian::Little => self.counter.to_le_bytes(),
                 Endian::Big => self.counter.to_be_bytes(),
             };
-            bytes.copy_from_slice(&counter_byte);
+            // Use bytes[0..8] to prevent panic when size of bytes > 8.
+            bytes[0..8].copy_from_slice(&counter_byte);
             self.counter = 0;
             return Ok(Ok(8));
         }
@@ -89,17 +90,17 @@ impl FileDescription for Event {
         bytes: &[u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
-        let bytes = match bytes[0..8].try_into() {
-            Ok(bytes) => bytes,
-            Err(_) => {
-                // Size of bytes is less than 8.
+        // Check the size of slice, and return error only if the size of the slice < 8.
+        let bytes = match bytes.first_chunk::<8>() {
+            Some(bytes) => bytes,
+            None => {
                 return Ok(Err(Error::from(ErrorKind::InvalidInput)));
             }
         };
         // Convert from target endianness to host endianness.
         let num = match ecx.tcx.sess.target.endian {
-            Endian::Little => u64::from_le_bytes(bytes),
-            Endian::Big => u64::from_be_bytes(bytes),
+            Endian::Little => u64::from_le_bytes(*bytes),
+            Endian::Big => u64::from_be_bytes(*bytes),
         };
         // u64::MAX as input is invalid because the maximum value of counter is u64::MAX - 1.
         if num == u64::MAX {

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

@@ -1,30 +1,34 @@
 //@ignore-target-windows: No eventfd in windows
 
+use std::thread;
+
 fn main() {
-    test_read_write();
+    //test_read_write();
+    test_race();
 }
 
 fn test_read_write() {
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
-    let data: [u8; 8];
+    let sized_8_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];
+        sized_8_data = [0, 0, 0, 0, 0, 0, 0, 1];
     } else {
-        data = [1, 0, 0, 0, 0, 0, 0, 0];
+        sized_8_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() };
+    // Write 1 to the counter.
+    let res: i64 = unsafe {
+        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
     assert_eq!(res, 8);
 
-    // Read 1 from the counter
+    // 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
+    // Read returns number of bytes has been read, which is always 8.
     assert_eq!(res, 8);
     let counter: u64;
     if cfg!(target_endian = "big") {
@@ -34,4 +38,82 @@ fn test_read_write() {
         counter = u64::from_le_bytes(buf);
     }
     assert_eq!(counter, 1);
+
+    // Write with buffer size > 8 bytes.
+    let res: i64 = unsafe {
+        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    assert_eq!(res, 8);
+
+    // Read with supplied buffer that < 8 bytes.
+    let mut buf: [u8; 7] = [1; 7];
+    let res: i32 = unsafe {
+        libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, -1);
+
+    // Write with supplied buffer that < 8 bytes
+    let res: i64 = unsafe {
+        libc::write(fd, sized_8_data[0..7].as_ptr() as *const libc::c_void, 7).try_into().unwrap()
+    };
+    assert_eq!(res, -1);
+
+    // Write with supplied buffer that > 8 bytes
+    let sized_9_data: [u8; 9];
+    if cfg!(target_endian = "big") {
+        // Adjust the data based on the endianess of host system.
+        sized_9_data = [0, 0, 0, 0, 0, 0, 0, 0, 1];
+    } else {
+        sized_9_data = [1, 0, 0, 0, 0, 0, 0, 0, 0];
+    }
+    let res: i64 = unsafe {
+        libc::write(fd, sized_9_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    assert_eq!(res, 8);
+
+    // Read with supplied buffer > 8 bytes.
+    let mut buf: [u8; 9] = [1; 9];
+    let res: i32 = unsafe {
+        libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 8);
+}
+
+fn test_race() {
+    static mut VAL: u8 = 0;
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+    let thread1 = thread::spawn(move || {
+        let mut buf: [u8; 8] = [0; 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);
+        // Read from the static mutable variable
+        unsafe { assert_eq!(VAL, 1) };
+    });
+    // Write to the static mutable variable
+    unsafe { VAL = 1 };
+    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];
+    }
+    let res: i64 =
+        unsafe { libc::write(fd, data.as_ptr() as *const libc::c_void, 8).try_into().unwrap() };
+    // write return number of bytes written, which is always 8
+    assert_eq!(res, 8);
+    thread::yield_now();
+    thread1.join().unwrap();
 }