epoll: confirm that timerfd wakes up even on write of 0; add nicer libc utils

Author: RalfJung

tests/pass-dep/libc/libc-epoll-no-blocking.rs

@@ -262,10 +262,8 @@ fn test_epoll_eventfd() {
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
 
-    // Write to the eventfd instance.
-    let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
-    let res = unsafe { libc_utils::write_all(fd, sized_8_data.as_ptr() as *const libc::c_void, 8) };
-    assert_eq!(res, 8);
+    // Write 1 to the eventfd instance.
+    libc_utils::write_all_from_slice(fd, &1_u64.to_ne_bytes()).unwrap();
 
     // Create an epoll instance.
     let epfd = unsafe { libc::epoll_create1(0) };
@@ -281,18 +279,15 @@ fn test_epoll_eventfd() {
     let expected_value = u64::try_from(fd).unwrap();
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 
-    // Write to the eventfd again.
-    let res = unsafe { libc_utils::write_all(fd, sized_8_data.as_ptr() as *const libc::c_void, 8) };
-    assert_eq!(res, 8);
+    // Write 0 to the eventfd.
+    libc_utils::write_all_from_slice(fd, &0_u64.to_ne_bytes()).unwrap();
 
     // This does not change the status, so we should get no event.
     // However, Linux performs a spurious wakeup.
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 
     // Read from the eventfd.
-    let mut buf = [0u8; 8];
-    let res = unsafe { libc_utils::read_all(fd, buf.as_mut_ptr().cast(), 8) };
-    assert_eq!(res, 8);
+    libc_utils::read_all_into_array::<8>(fd).unwrap();
 
     // This consumes the event, so the read status is gone. However, deactivation
     // does not trigger an event.

tests/utils/libc.rs

@@ -22,6 +22,18 @@ pub unsafe fn read_all(
     return read_so_far as libc::ssize_t;
 }
 
+#[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];
+    let res = unsafe { read_all(fd, buf.as_mut_ptr().cast(), buf.len()) };
+    if res >= 0 {
+        assert_eq!(res as usize, buf.len());
+        Ok(buf)
+    } else {
+        Err(res)
+    }
+}
+
 pub unsafe fn write_all(
     fd: libc::c_int,
     buf: *const libc::c_void,
@@ -39,3 +51,14 @@ pub unsafe fn write_all(
     }
     return written_so_far as libc::ssize_t;
 }
+
+#[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()) };
+    if res >= 0 {
+        assert_eq!(res as usize, buf.len());
+        Ok(())
+    } else {
+        Err(res)
+    }
+}