Previous change before applying suggestion

Author: tiif

src/concurrency/thread.rs

@@ -172,6 +172,8 @@ pub enum BlockReason {
     Futex { addr: u64 },
     /// Blocked on an InitOnce.
     InitOnce(InitOnceId),
+    /// Blocked on epoll
+    Epoll,
 }
 
 /// The state of a thread.

src/machine.rs

@@ -958,11 +958,11 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
 
     #[inline(always)]
     fn find_mir_or_eval_fn(
-        ecx: &mut MiriInterpCx<'tcx>,
+        ecx: &'tcx mut MiriInterpCx<'tcx>,
         instance: ty::Instance<'tcx>,
         abi: Abi,
-        args: &[FnArg<'tcx, Provenance>],
-        dest: &MPlaceTy<'tcx>,
+        args: &'tcx [FnArg<'tcx, Provenance>],
+        dest: &'tcx MPlaceTy<'tcx>,
         ret: Option<mir::BasicBlock>,
         unwind: mir::UnwindAction,
     ) -> InterpResult<'tcx, Option<(&'tcx mir::Body<'tcx>, ty::Instance<'tcx>)>> {
@@ -985,11 +985,11 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
 
     #[inline(always)]
     fn call_extra_fn(
-        ecx: &mut MiriInterpCx<'tcx>,
+        ecx: &'tcx mut MiriInterpCx<'tcx>,
         fn_val: DynSym,
         abi: Abi,
-        args: &[FnArg<'tcx, Provenance>],
-        dest: &MPlaceTy<'tcx>,
+        args: &'tcx [FnArg<'tcx, Provenance>],
+        dest: &'tcx MPlaceTy<'tcx>,
         ret: Option<mir::BasicBlock>,
         unwind: mir::UnwindAction,
     ) -> InterpResult<'tcx> {

src/shims/foreign_items.rs

@@ -41,7 +41,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         link_name: Symbol,
         abi: Abi,
         args: &[OpTy<'tcx>],
-        dest: &MPlaceTy<'tcx>,
+        dest: &'tcx MPlaceTy<'tcx>,
         ret: Option<mir::BasicBlock>,
         unwind: mir::UnwindAction,
     ) -> InterpResult<'tcx, Option<(&'tcx mir::Body<'tcx>, ty::Instance<'tcx>)>> {
@@ -109,7 +109,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         sym: DynSym,
         abi: Abi,
         args: &[OpTy<'tcx>],
-        dest: &MPlaceTy<'tcx>,
+        dest: &'tcx MPlaceTy<'tcx>,
         ret: Option<mir::BasicBlock>,
         unwind: mir::UnwindAction,
     ) -> InterpResult<'tcx> {
@@ -221,7 +221,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         link_name: Symbol,
         abi: Abi,
         args: &[OpTy<'tcx>],
-        dest: &MPlaceTy<'tcx>,
+        dest: &'tcx MPlaceTy<'tcx>,
     ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
 

src/shims/unix/foreign_items.rs

@@ -46,7 +46,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         link_name: Symbol,
         abi: Abi,
         args: &[OpTy<'tcx>],
-        dest: &MPlaceTy<'tcx>,
+        dest: &'tcx MPlaceTy<'tcx>,
     ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
 

src/shims/unix/linux/epoll.rs

@@ -2,6 +2,7 @@ use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::io;
 use std::rc::{Rc, Weak};
+use std::time::Duration;
 
 use crate::shims::unix::fd::FdId;
 use crate::shims::unix::*;
@@ -378,62 +379,74 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         events_op: &OpTy<'tcx>,
         maxevents: &OpTy<'tcx>,
         timeout: &OpTy<'tcx>,
-    ) -> InterpResult<'tcx, Scalar> {
+        place: &'tcx MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        let epfd = this.read_scalar(epfd)?.to_i32()?;
+        let epfd_value = this.read_scalar(epfd)?.to_i32()?;
         let maxevents = this.read_scalar(maxevents)?.to_i32()?;
         let event = this.deref_pointer_as(
             events_op,
             this.libc_array_ty_layout("epoll_event", maxevents.try_into().unwrap()),
         )?;
-        let timeout = this.read_scalar(timeout)?.to_i32()?;
+        let timeout = this.read_scalar(timeout)?.to_u32()?;
 
-        if epfd <= 0 {
+        if epfd_value <= 0 {
             let einval = this.eval_libc("EINVAL");
             this.set_last_error(einval)?;
-            return Ok(Scalar::from_i32(-1));
-        }
-        // FIXME: Implement blocking support
-        if timeout != 0 {
-            throw_unsup_format!("epoll_wait: timeout value can only be 0");
+            this.write_scalar(Scalar::from_i32(-1), place)?;
+            return Ok(());
         }
-
-        let Some(epfd) = this.machine.fds.get_ref(epfd) else {
-            return Ok(Scalar::from_i32(this.fd_not_found()?));
+        let Some(epfd) = this.machine.fds.get_ref(epfd_value) else {
+            let result_value = this.fd_not_found()?;
+            this.write_scalar(Scalar::from_i32(result_value), place)?;
+            return Ok(());
         };
         let mut binding = epfd.borrow_mut();
         let epoll_file_description = &mut binding
             .downcast_mut::<Epoll>()
             .ok_or_else(|| err_unsup_format!("non-epoll FD passed to `epoll_wait`"))?;
 
         let binding = epoll_file_description.get_ready_list();
-        let mut ready_list = binding.borrow_mut();
-        let mut num_of_events: i32 = 0;
-        let mut array_iter = this.project_array_fields(&event)?;
+        let ready_list = binding.borrow_mut();
 
-        while 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.
-                if let Some(des) = array_iter.next(this)? {
-                    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();
-                } else {
-                    break;
-                }
+        if ready_list.is_empty() {
+            if timeout == 0 {
+                // Non-blocking with no notification returned.
+                this.write_scalar(Scalar::from_i32(0), place)?;
+                return Ok(());
+            } else {
+                // Blocking
+                let duration = Duration::from_secs(timeout.into());
+                this.block_thread(
+                    BlockReason::Epoll,
+                    Some((TimeoutClock::Monotonic, TimeoutAnchor::Relative, duration)),
+                    callback!(
+                        @capture<'tcx> {
+                        epfd_value: i32,
+                        place: &'tcx MPlaceTy<'tcx>,
+                        event: MPlaceTy<'tcx>,
+                        }
+                        @unblock = |this| {
+                                    this.blocking_epoll_callback(epfd_value, place, &event);
+                                    Ok(())
+                                }
+                        @timeout = |this| {
+                        this.write_scalar(Scalar::from_i32(0), place)?;
+                                    Ok(())
+                                }
+                    ),
+                );
             }
+        } else {
+            // Non-blocking with notification returned.
+            this.blocking_epoll_callback(epfd_value, place, &event);
+            return Ok(());
         }
-        Ok(Scalar::from_i32(num_of_events))
-    }
 
+        Ok(())
+    }
+    
     /// For a specific unique file descriptor id, get its ready events and update
     /// the corresponding ready list. This function is called whenever a file description
     /// is registered with epoll, or when read, write, or close operations are performed,

src/shims/unix/linux/foreign_items.rs

@@ -21,7 +21,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         link_name: Symbol,
         abi: Abi,
         args: &[OpTy<'tcx>],
-        dest: &MPlaceTy<'tcx>,
+        dest: &'tcx MPlaceTy<'tcx>,
     ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
 
@@ -62,8 +62,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             "epoll_wait" => {
                 let [epfd, events, maxevents, timeout] =
                     this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
-                let result = this.epoll_wait(epfd, events, maxevents, timeout)?;
-                this.write_scalar(result, dest)?;
+                this.epoll_wait(epfd, events, maxevents, timeout, dest)?;
             }
             "eventfd" => {
                 let [val, flag] =