Remove support for macos

Author: tiif

src/shims/unix/linux/eventfd.rs

@@ -49,9 +49,9 @@ 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 bytes.first_chunk::<8>().is_none() {
+        let Some(bytes) = bytes.first_chunk_mut::<8>() else {
             return Ok(Err(Error::from(ErrorKind::InvalidInput)));
-        }
+        };
         if self.counter == 0 {
             if self.is_nonblock {
                 return Ok(Err(Error::from(ErrorKind::WouldBlock)));
@@ -63,12 +63,10 @@ impl FileDescription for Event {
             // Prevent false alarm in data race detection when doing synchronisation via eventfd.
             ecx.acquire_clock(&self.clock);
             // Return the counter in the host endianness using the buffer provided by caller.
-            let counter_byte: [u8; 8] = match ecx.tcx.sess.target.endian {
+            *bytes = match ecx.tcx.sess.target.endian {
                 Endian::Little => self.counter.to_le_bytes(),
                 Endian::Big => self.counter.to_be_bytes(),
             };
-            // 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));
         }
@@ -93,11 +91,8 @@ 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.
-        let bytes = match bytes.first_chunk::<8>() {
-            Some(bytes) => bytes,
-            None => {
-                return Ok(Err(Error::from(ErrorKind::InvalidInput)));
-            }
+        let Some(bytes) = bytes.first_chunk::<8>() else {
+            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
         };
         // Convert from target endianness to host endianness.
         let num = match ecx.tcx.sess.target.endian {
@@ -108,21 +103,21 @@ impl FileDescription for Event {
         if num == u64::MAX {
             return Ok(Err(Error::from(ErrorKind::InvalidInput)));
         }
-        let max_addition = MAX_COUNTER.checked_sub(self.counter).unwrap();
-        if num > max_addition {
-            // If addition cause the counter value to exceed the maximum, block
-            // or throw error based on the existence of non-blocking flag.
-            if self.is_nonblock {
-                return Ok(Err(Error::from(ErrorKind::WouldBlock)));
-            } else {
-                //FIXME: blocking is not supported
-                throw_unsup_format!("eventfd: blocking is unsupported");
+        match self.counter.checked_add(num) {
+            Some(new_count @ 0..=MAX_COUNTER) => {
+                // Prevent false alarm in data race detection when doing synchronisation via eventfd.
+                self.clock.join(&ecx.release_clock().unwrap());
+                self.counter = new_count;
             }
-        } else {
-            // Prevent false alarm in data race detection when doing synchronisation via eventfd.
-            self.clock.join(&ecx.release_clock().unwrap());
-            self.counter = self.counter.checked_add(num).unwrap();
-        }
+            None | Some(u64::MAX) => {
+                if self.is_nonblock {
+                    return Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                } else {
+                    //FIXME: blocking is not supported
+                    throw_unsup_format!("eventfd: blocking is unsupported");
+                }
+            }
+        };
         Ok(Ok(8))
     }
 }
@@ -148,6 +143,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn eventfd(&mut self, val: &OpTy<'tcx>, flags: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
+        // eventfd is Linux specific.
+        this.assert_target_os("linux", "eventfd");
+
         let val = this.read_scalar(val)?.to_u32()?;
         let mut flags = this.read_scalar(flags)?.to_i32()?;
 
@@ -160,7 +158,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
 
         let mut is_nonblock = false;
-        //Unload the flag that we support.
+        // Unload the flag that we support.
         if flags & efd_cloexec == efd_cloexec {
             flags &= !efd_cloexec;
         }

tests/fail-dep/libc/libc_eventfd_read_block.rs

@@ -0,0 +1,12 @@
+//@ignore-target-windows: No eventfd on Windows
+//@ignore-target-apple: No eventfd in macos
+fn main() {
+    // eventfd read will block when non-block flag is clear and counter = 0.
+    // This will pass when blocking is implemented.
+    let flags = libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+    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() //~ERROR: blocking is unsupported
+    };
+}

tests/fail-dep/libc/libc_eventfd_read_block.stderr

@@ -0,0 +1,14 @@
+error: unsupported operation: eventfd: blocking is unsupported
+  --> $DIR/libc_eventfd_read_block.rs:LL:CC
+   |
+LL |         libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ eventfd: blocking is unsupported
+   |
+   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+   = note: BACKTRACE:
+   = note: inside `main` at $DIR/libc_eventfd_read_block.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+

tests/fail-dep/libc/libc_eventfd_write_block.rs

@@ -0,0 +1,33 @@
+//@ignore-target-windows: No eventfd on Windows
+//@ignore-target-apple: No eventfd in macos
+fn main() {
+    // eventfd write will block when we try to add until it exceed u64-1.
+    // This will pass when blocking is implemented.
+    let flags = libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+    let mut sized_8_data: [u8; 8];
+    if cfg!(target_endian = "big") {
+        // Adjust the data based on the endianness of host system.
+        sized_8_data = [255, 255, 255, 255, 255, 255, 255, 254];
+    } else {
+        sized_8_data = [254, 255, 255, 255, 255, 255, 255, 255];
+    }
+    // Write u64 - 1.
+    let _res: i64 = unsafe {
+        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    // Write u64 - 1.
+    let _res: i64 = unsafe {
+        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap() //~ERROR: blocking is unsupported
+    };
+    if cfg!(target_endian = "big") {
+        // Adjust the data based on the endianess of host system.
+        sized_8_data = [0, 0, 0, 0, 0, 0, 0, 1];
+    } else {
+        sized_8_data = [1, 0, 0, 0, 0, 0, 0, 0];
+    }
+    // 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()
+    };
+}

tests/fail-dep/libc/libc_eventfd_write_block.stderr

@@ -0,0 +1,14 @@
+error: unsupported operation: eventfd: blocking is unsupported
+  --> $DIR/libc_eventfd_write_block.rs:LL:CC
+   |
+LL |         libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ eventfd: blocking is unsupported
+   |
+   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+   = note: BACKTRACE:
+   = note: inside `main` at $DIR/libc_eventfd_write_block.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+

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

@@ -1,4 +1,7 @@
 //@ignore-target-windows: No eventfd in windows
+//@ignore-target-apple: No eventfd in macos
+// test_race depends on a deterministic schedule.
+//@compile-flags: -Zmiri-preemption-rate=0
 
 use std::thread;
 
@@ -24,7 +27,7 @@ fn test_read_write() {
     assert_eq!(res, 8);
 
     // Read 1 from the counter.
-    let mut buf: [u8; 8] = [1; 8];
+    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()
     };
@@ -39,6 +42,14 @@ fn test_read_write() {
     }
     assert_eq!(counter, 1);
 
+    // Read when counter == 0 should fail.
+    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, -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()
@@ -77,6 +88,13 @@ fn test_read_write() {
         libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
     };
     assert_eq!(res, 8);
+
+    // Write u64::MAX should fail.
+    let u64_max_bytes: [u8; 8] = [255; 8];
+    let res: i64 = unsafe {
+        libc::write(fd, u64_max_bytes.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    assert_eq!(res, -1);
 }
 
 fn test_race() {
@@ -92,7 +110,7 @@ fn test_race() {
         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.
+            // Read will store the bytes based on the endianness of the host system.
             counter = u64::from_be_bytes(buf);
         } else {
             counter = u64::from_le_bytes(buf);
@@ -105,7 +123,7 @@ fn test_race() {
     unsafe { VAL = 1 };
     let data: [u8; 8];
     if cfg!(target_endian = "big") {
-        // Adjust the data based on the endianess of host system.
+        // Adjust the data based on the endianness of host system.
         data = [0, 0, 0, 0, 0, 0, 0, 1];
     } else {
         data = [1, 0, 0, 0, 0, 0, 0, 0];