add some shared helpers for epoll tests

Author: RalfJung

src/tools/miri/tests/pass-dep/libc/libc-epoll-no-blocking.rs

@@ -4,6 +4,7 @@ use std::convert::TryInto;
 
 #[path = "../../utils/libc.rs"]
 mod libc_utils;
+use libc_utils::epoll::*;
 use libc_utils::*;
 
 fn main() {
@@ -57,48 +58,36 @@ fn test_epoll_socketpair() {
     // Create a socketpair instance.
     let mut fds = [-1, -1];
     errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
-    let fds = [fds[1], fds[0]];
 
     // Write to fd[0]
-    let data = "abcde".as_bytes().as_ptr();
-    let res = unsafe { libc_utils::write_all(fds[0], data as *const libc::c_void, 5) };
-    assert_eq!(res, 5);
+    write_all_from_slice(fds[0], "abcde".as_bytes()).unwrap();
 
     // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET|EPOLLRDHUP
-    let mut ev = libc::epoll_event {
-        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET | libc::EPOLLRDHUP) as _,
-        u64: u64::try_from(fds[1]).unwrap(),
-    };
-    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_eq!(res, 0);
+    epoll_ctl_add(epfd, fds[1], EPOLLIN | EPOLLOUT | EPOLLET | EPOLLRDHUP).unwrap();
 
     // Check result from epoll_wait.
-    let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
-    let expected_value = u64::try_from(fds[1]).unwrap();
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    check_epoll_wait_noblock::<8>(epfd, &[Ev { data: fds[1], events: EPOLLIN | EPOLLOUT }]);
 
     // Check that this is indeed using "ET" (edge-trigger) semantics: a second epoll should return nothing.
-    check_epoll_wait::<8>(epfd, &[]);
+    check_epoll_wait_noblock::<8>(epfd, &[]);
 
     // Write some more to fd[0].
-    let data = "abcde".as_bytes().as_ptr();
-    let res = unsafe { libc_utils::write_all(fds[0], data as *const libc::c_void, 5) };
-    assert_eq!(res, 5);
+    write_all_from_slice(fds[0], "abcde".as_bytes()).unwrap();
 
     // This did not change the readiness of fd[1], so we should get no event.
     // However, Linux seems to always deliver spurious events to the peer on each write,
     // so we match that.
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    check_epoll_wait_noblock::<8>(epfd, &[Ev { data: fds[1], events: EPOLLIN | EPOLLOUT }]);
 
     // Close the peer socketpair.
     errno_check(unsafe { libc::close(fds[0]) });
 
-    // Check result from epoll_wait.
-    // We expect to get a read, write, HUP notification from the close since closing an FD always unblocks reads and writes on its peer.
-    let expected_event =
-        u32::try_from(libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLHUP | libc::EPOLLRDHUP).unwrap();
-    let expected_value = u64::try_from(fds[1]).unwrap();
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    // Check result from epoll_wait. We expect to get a read, write, HUP notification from the close
+    // since closing an FD always unblocks reads and writes on its peer.
+    check_epoll_wait_noblock::<8>(
+        epfd,
+        &[Ev { data: fds[1], events: EPOLLIN | EPOLLOUT | EPOLLHUP | EPOLLRDHUP }],
+    );
 }
 
 // This test first registers a file description with a flag that does not lead to notification,
@@ -113,49 +102,33 @@ fn test_epoll_ctl_mod() {
     errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Register fd[1] with EPOLLIN|EPOLLET, and data of "0".
-    let mut ev = libc::epoll_event { events: (libc::EPOLLIN | libc::EPOLLET) as _, u64: 0 };
-    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_eq!(res, 0);
+    epoll_ctl(epfd, EPOLL_CTL_ADD, fds[1], Ev { events: EPOLLIN | EPOLLET, data: 0 }).unwrap();
 
     // Check result from epoll_wait. No notification would be returned.
-    check_epoll_wait::<8>(epfd, &[]);
+    check_epoll_wait_noblock::<8>(epfd, &[]);
 
     // Use EPOLL_CTL_MOD to change to EPOLLOUT flag and data.
-    let mut ev = libc::epoll_event { events: (libc::EPOLLOUT | libc::EPOLLET) as _, u64: 1 };
-    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_MOD, fds[1], &mut ev) };
-    assert_eq!(res, 0);
+    epoll_ctl(epfd, EPOLL_CTL_MOD, fds[1], Ev { events: EPOLLOUT | EPOLLET, data: 1 }).unwrap();
 
     // Check result from epoll_wait. EPOLLOUT notification and new data is expected.
-    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
-    let expected_value = 1;
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    check_epoll_wait_noblock::<8>(epfd, &[Ev { events: EPOLLOUT, data: 1 }]);
 
     // Write to fds[1] and read from fds[0] to make the notification ready again
     // (relying on there always being an event when the buffer gets emptied).
-    let data = "abc".as_bytes();
-    let res = unsafe { libc_utils::write_all(fds[1], data.as_ptr().cast(), data.len()) };
-    assert_eq!(res, 3);
-    let mut buf = [0u8; 3];
-    let res = unsafe { libc_utils::read_all(fds[0], buf.as_mut_ptr().cast(), buf.len()) };
-    assert_eq!(res, 3);
+    write_all_from_slice(fds[1], "abc".as_bytes()).unwrap();
+    read_all_into_array::<3>(fds[0]).unwrap();
 
     // Now that the event is already ready, change the "data" value.
-    let mut ev = libc::epoll_event { events: (libc::EPOLLOUT | libc::EPOLLET) as _, u64: 2 };
-    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_MOD, fds[1], &mut ev) };
-    assert_eq!(res, 0);
+    epoll_ctl(epfd, EPOLL_CTL_MOD, fds[1], Ev { events: EPOLLOUT | EPOLLET, data: 2 }).unwrap();
 
     // Receive event, with latest data value.
-    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
-    let expected_value = 2;
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    check_epoll_wait_noblock::<8>(epfd, &[Ev { events: EPOLLOUT, data: 2 }]);
 
     // Do another update that changes nothing.
-    let mut ev = libc::epoll_event { events: (libc::EPOLLOUT | libc::EPOLLET) as _, u64: 2 };
-    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_MOD, fds[1], &mut ev) };
-    assert_eq!(res, 0);
+    epoll_ctl(epfd, EPOLL_CTL_MOD, fds[1], Ev { events: EPOLLOUT | EPOLLET, data: 2 }).unwrap();
 
     // This re-triggers the event, even if it's the same flags as before.
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    check_epoll_wait_noblock::<8>(epfd, &[Ev { events: EPOLLOUT, data: 2 }]);
 }
 
 fn test_epoll_ctl_del() {

src/tools/miri/tests/utils/libc.rs

@@ -40,6 +40,7 @@ pub unsafe fn read_all(
     return read_so_far as libc::ssize_t;
 }
 
+/// Read exactly `N` bytes from `fd`. Error if that many bytes could not be read.
 #[track_caller]
 pub fn read_all_into_array<const N: usize>(fd: libc::c_int) -> Result<[u8; N], libc::ssize_t> {
     let mut buf = [0; N];
@@ -70,6 +71,7 @@ pub unsafe fn write_all(
     return written_so_far as libc::ssize_t;
 }
 
+/// Write the entire `buf` to `fd`. Error if not all bytes could be written.
 #[track_caller]
 pub fn write_all_from_slice(fd: libc::c_int, buf: &[u8]) -> Result<(), libc::ssize_t> {
     let res = unsafe { write_all(fd, buf.as_ptr().cast(), buf.len()) };
@@ -80,3 +82,54 @@ pub fn write_all_from_slice(fd: libc::c_int, buf: &[u8]) -> Result<(), libc::ssi
         Err(res)
     }
 }
+
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "illumos"))]
+#[allow(unused_imports)]
+pub mod epoll {
+    use libc::c_int;
+    pub use libc::{EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD};
+    // Re-export some constants we need a lot for this.
+    pub use libc::{EPOLLET, EPOLLHUP, EPOLLIN, EPOLLOUT, EPOLLRDHUP};
+
+    use super::*;
+
+    /// The libc epoll_event type doesn't fit to the EPOLLIN etc constants, so we have our
+    /// own type. We also make the data field an int since we typically want to store FDs there.
+    #[derive(PartialEq, Debug)]
+    pub struct Ev {
+        pub events: c_int,
+        pub data: c_int,
+    }
+
+    #[track_caller]
+    pub fn epoll_ctl(epfd: c_int, op: c_int, fd: c_int, event: Ev) -> io::Result<()> {
+        let mut event = libc::epoll_event {
+            events: event.events.cast_unsigned(),
+            u64: event.data.try_into().unwrap(),
+        };
+        errno_result(unsafe { libc::epoll_ctl(epfd, op, fd, &raw mut event) })
+            .map(|r| assert_eq!(r, 0))
+    }
+
+    /// Helper for the common case of adding an FD to an epoll with the FD itself being
+    /// the `data`.
+    #[track_caller]
+    pub fn epoll_ctl_add(epfd: c_int, fd: c_int, events: c_int) -> io::Result<()> {
+        epoll_ctl(epfd, EPOLL_CTL_ADD, fd, Ev { events, data: fd })
+    }
+
+    #[track_caller]
+    pub fn check_epoll_wait_noblock<const N: usize>(epfd: i32, expected: &[Ev]) {
+        let mut array: [libc::epoll_event; N] = [libc::epoll_event { events: 0, u64: 0 }; N];
+        let num = errno_result(unsafe {
+            libc::epoll_wait(epfd, array.as_mut_ptr(), N.try_into().unwrap(), 0)
+        })
+        .unwrap();
+        let got = &mut array[..num.try_into().unwrap()];
+        let got = got
+            .iter()
+            .map(|e| Ev { events: e.events.cast_signed(), data: e.u64.try_into().unwrap() })
+            .collect::<Vec<_>>();
+        assert_eq!(got, expected, "got wrong notifications");
+    }
+}