Attempt to use this.block_thread in epoll_wait

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

@@ -956,11 +956,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>)>> {
@@ -983,11 +983,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> {
@@ -210,7 +210,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,30 +379,25 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         events_op: &OpTy<'tcx>,
         maxevents: &OpTy<'tcx>,
         timeout: &OpTy<'tcx>,
-        place: &MPlaceTy<'tcx>,
+        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)?;
             this.write_scalar(Scalar::from_i32(-1), place)?;
             return Ok(());
         }
-        // FIXME: Implement blocking support
-        if timeout != 0 {
-            throw_unsup_format!("epoll_wait: timeout value can only be 0");
-        }
-
-        let Some(epfd) = this.machine.fds.get_ref(epfd) else {
+        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(());
@@ -412,30 +408,42 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             .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(());
         }
-        this.write_scalar(Scalar::from_i32(num_of_events), place)?;
+
         Ok(())
     }
     /// For a specific unique file descriptor id, get its ready events and update
@@ -477,4 +485,51 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
         Ok(())
     }
+
+    /// Callback function after epoll_wait unblocks
+    fn blocking_epoll_callback(
+        &mut self,
+        epfd: i32,
+        place: &MPlaceTy<'tcx>,
+        event: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        let Some(epfd) = this.machine.fds.get_ref(epfd) 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)?;
+
+        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;
+                }
+            }
+        }
+        this.write_scalar(Scalar::from_i32(num_of_events), place)?;
+        Ok(())
+    }
 }

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();