Fix event fetching logic and add test

Author: tiif

src/shims/unix/linux/epoll.rs

@@ -411,24 +411,30 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let mut num_of_events: i32 = 0;
         let mut array_iter = this.project_array_fields(&event)?;
 
-        while let Some(des) = array_iter.next(this)? {
+        while let Some(des) = array_iter.next(this)?
+            && !ready_list.is_empty()
+        {
+            let mut entry_written = false;
             // Fetch an event from the ready list.
-            if let Some((epoll_key, epoll_return)) = ready_list.pop_first() {
-                // If the file description is fully close, the entry for corresponding FdID in the
-                // global epoll event interest table would be empty.
-                if this.machine.epoll_interests.get_epoll_interest(epoll_key.0).is_some() {
-                    // Return notification to the caller if the file description is not fully closed.
-                    this.write_int_fields_named(
-                        &[
-                            ("events", epoll_return.events.into()),
-                            ("u64", epoll_return.data.into()),
-                        ],
-                        &des.1,
-                    )?;
-                    num_of_events = num_of_events.checked_add(1).unwrap();
+            while !entry_written {
+                if let Some((epoll_key, epoll_return)) = ready_list.pop_first() {
+                    // If the file description is fully close, the entry for corresponding FdID in the
+                    // global epoll event interest table would be empty.
+                    if this.machine.epoll_interests.get_epoll_interest(epoll_key.0).is_some() {
+                        // Return notification to the caller if the file description is not fully closed.
+                        this.write_int_fields_named(
+                            &[
+                                ("events", epoll_return.events.into()),
+                                ("u64", epoll_return.data.into()),
+                            ],
+                            &des.1,
+                        )?;
+                        num_of_events = num_of_events.checked_add(1).unwrap();
+                        entry_written = true;
+                    }
+                } else {
+                    break;
                 }
-            } else {
-                break;
             }
         }
         Ok(Scalar::from_i32(num_of_events))

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

@@ -19,6 +19,7 @@ fn main() {
     test_pointer();
     test_two_same_fd_in_same_epoll_instance();
     test_epoll_lost_events();
+    test_ready_list_fetching_logic();
 }
 
 // Using `as` cast since `EPOLLET` wraps around
@@ -535,3 +536,34 @@ fn test_epoll_lost_events() {
     let expected_value1 = fds[1] as u64;
     assert!(check_epoll_wait::<1>(epfd, &[(expected_event1, expected_value1)]));
 }
+
+// This is testing if closing an fd that is already in ready_list will cause an empty entry in
+// returned notification.
+// Related discussion in https://github.com/rust-lang/miri/pull/3818#discussion_r1720679440.
+fn test_ready_list_fetching_logic() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create two eventfd instances.
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd0 = unsafe { libc::eventfd(0, flags) };
+    let fd1 = unsafe { libc::eventfd(0, flags) };
+
+    // Register both fd to the same epoll instance. At this point, both of them is in ready list.
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fd0 as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd0, &mut ev) };
+    assert_ne!(res, -1);
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fd1 as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd1, &mut ev) };
+    assert_ne!(res, -1);
+
+    // Close fd0. So the first entry in the ready list will be empty.
+    let res = unsafe { libc::close(fd0) };
+    assert_eq!(res, 0);
+
+    // Notification for fd1 should be returned.
+    let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value1 = fd1 as u64;
+    assert!(check_epoll_wait::<1>(epfd, &[(expected_event1, expected_value1)]));
+}