eventfd: force spurious wakeups, matching Linux

Author: RalfJung

src/shims/unix/linux_like/eventfd.rs

@@ -217,7 +217,10 @@ fn eventfd_write<'tcx>(
 
             // The state changed; we check and update the status of all supported event
             // types for current file description.
-            ecx.epoll_send_fd_ready_events(eventfd, /* force_edge */ false)?;
+            // Linux seems to cause spurious wakeups here, and Tokio seems to rely on that
+            // (see <https://github.com/rust-lang/miri/pull/4676#discussion_r2510528994>
+            // and also <https://www.illumos.org/issues/16700>).
+            ecx.epoll_send_fd_ready_events(eventfd, /* force_edge */ true)?;
 
             // Return how many bytes we consumed from the user-provided buffer.
             return finish.call(ecx, Ok(buf_place.layout.size.bytes_usize()));
@@ -312,7 +315,8 @@ fn eventfd_read<'tcx>(
 
         // The state changed; we check and update the status of all supported event
         // types for current file description.
-        ecx.epoll_send_fd_ready_events(eventfd, /* force_edge */ false)?;
+        // Linux seems to always emit do notifications here, even if we were already writable.
+        ecx.epoll_send_fd_ready_events(eventfd, /* force_edge */ true)?;
 
         // Tell userspace how many bytes we put into the buffer.
         return finish.call(ecx, Ok(buf_place.layout.size.bytes_usize()));

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

@@ -258,6 +258,34 @@ fn test_epoll_eventfd() {
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     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);
+
+    // 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);
+
+    // This consumes the event, so the read status is gone. However, deactivation
+    // does not trigger an event.
+    // Still, we see a spurious wakeup.
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+
+    // Write the maximum possible value.
+    let sized_8_data: [u8; 8] = (u64::MAX - 1).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);
+
+    // This reactivates reads, therefore triggering an event. Writing is no longer possible.
+    let expected_event = u32::try_from(libc::EPOLLIN).unwrap();
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
 // When read/write happened on one side of the socketpair, only the other side will be notified.