Make epollrdhup works by giving close MiriInterpCx<'tcx> access

tiif · tiif · commit c518ad4b0395 · 2024-07-08T16:07:32.000+08:00
diff --git a/src/shims/unix/fd.rs b/src/shims/unix/fd.rs
@@ -51,6 +51,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
 
     fn close<'tcx>(
         self: Box<Self>,
+        _ecx: &mut MiriInterpCx<'tcx>,
         _communicate_allowed: bool,
     ) -> InterpResult<'tcx, io::Result<()>> {
         throw_unsup_format!("cannot close {}", self.name());
@@ -197,11 +198,15 @@ impl FileDescriptor {
         RefMut::map(self.0.borrow_mut(), |fd| fd.as_mut())
     }
 
-    pub fn close<'ctx>(self, communicate_allowed: bool) -> InterpResult<'ctx, io::Result<()>> {
+    pub fn close<'tcx>(
+        self,
+        ecx: &mut MiriInterpCx<'tcx>,
+        communicate_allowed: bool,
+    ) -> InterpResult<'tcx, io::Result<()>> {
         // Destroy this `Rc` using `into_inner` so we can call `close` instead of
         // implicitly running the destructor of the file description.
         match Rc::into_inner(self.0) {
-            Some(fd) => RefCell::into_inner(fd).close(communicate_allowed),
+            Some(fd) => RefCell::into_inner(fd).close(ecx, communicate_allowed),
             None => Ok(Ok(())),
         }
     }
@@ -389,7 +394,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let fd = this.read_scalar(fd_op)?.to_i32()?;
 
         Ok(Scalar::from_i32(if let Some(file_descriptor) = this.machine.fds.remove(fd) {
-            let result = file_descriptor.close(this.machine.communicate())?;
+            let result = file_descriptor.close(this, this.machine.communicate())?;
             // return `0` if close is successful
             let result = result.map(|()| 0i32);
             this.try_unwrap_io_result(result)?
@@ -409,6 +414,33 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         Ok((-1).into())
     }
 
+    /// Functions to update the ready list of an epoll_event.
+    fn update_readiness(
+        &self,
+        ready_flags: Vec<u32>,
+        epoll_events: &Vec<Weak<EpollEvent>>,
+    ) -> InterpResult<'tcx> {
+        for event in epoll_events {
+            // If the current epoll_event contains the flag that is signaled as ready, we add/update
+            // the epoll_return entry in the ready list.
+            if let Some(epoll_event) = event.upgrade() {
+                if let Some(flags) = epoll_event.contains_flag(&ready_flags) {
+                    let weak_file_descriptor = epoll_event.weak_file_descriptor.clone();
+                    let epoll_key = (weak_file_descriptor, epoll_event.file_descriptor);
+                    // Retrieve the epoll return if it is already in the return list.
+                    let ready_list = &mut epoll_event.ready_list.borrow_mut();
+                    // Add a new epoll entry if it doesn't exist, or update the event mask if it exists.
+                    let epoll_return = EpollReturn::new(flags, epoll_event.data);
+                    let epoll_entry = ready_list.entry(epoll_key).or_insert(epoll_return);
+                    // The update here is bitwise or, so it will still be correct if we try to add
+                    // a flag that already exists.
+                    epoll_entry.update_events(flags);
+                }
+            }
+        }
+        Ok(())
+    }
+
     fn read(&mut self, fd: i32, buf: Pointer, count: u64) -> InterpResult<'tcx, i64> {
         let this = self.eval_context_mut();
 
diff --git a/src/shims/unix/fs.rs b/src/shims/unix/fs.rs
@@ -60,6 +60,7 @@ impl FileDescription for FileHandle {
 
     fn close<'tcx>(
         self: Box<Self>,
+        _ecx: &mut MiriInterpCx<'tcx>,
         communicate_allowed: bool,
     ) -> InterpResult<'tcx, io::Result<()>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
diff --git a/src/shims/unix/linux/epoll.rs b/src/shims/unix/linux/epoll.rs
@@ -88,6 +88,7 @@ impl FileDescription for Epoll {
 
     fn close<'tcx>(
         self: Box<Self>,
+        _ecx: &mut MiriInterpCx<'tcx>,
         _communicate_allowed: bool,
     ) -> InterpResult<'tcx, io::Result<()>> {
         Ok(Ok(()))
@@ -214,11 +215,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             interest_list.insert(epoll_key, event);
 
             target_file_description.check_readiness(this).map(|events| {
-                target_file_description.update_readiness(
-                    events,
-                    target_file_description.return_epoll_events().unwrap(),
-                )
-            })?;
+                this.update_readiness(events, target_file_description.return_epoll_events()?)
+            })??;
 
             Ok(Scalar::from_i32(0))
         } else if op == epoll_ctl_del {
diff --git a/src/shims/unix/linux/eventfd.rs b/src/shims/unix/linux/eventfd.rs
@@ -6,7 +6,7 @@ use std::rc::Weak;
 
 use rustc_target::abi::Endian;
 
-use crate::shims::unix::linux::epoll::{EpollEvent, EpollReturn};
+use crate::shims::unix::linux::epoll::EpollEvent;
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
@@ -35,30 +35,6 @@ struct Event {
     epoll_events: Vec<Weak<EpollEvent>>,
 }
 
-impl Event {
-    /// Functions to update the ready list of an epoll_event.
-    fn update_readiness(&self, ready_flags: Vec<u32>, epoll_events: &Vec<Weak<EpollEvent>>) {
-        for event in epoll_events {
-            // If the current epoll_event contains the flag that is signaled as ready, we add/update
-            // the epoll_return entry in the ready list.
-            if let Some(epoll_event) = event.upgrade() {
-                if let Some(flags) = epoll_event.contains_flag(&ready_flags) {
-                    let weak_file_descriptor = epoll_event.weak_file_descriptor.clone();
-                    let epoll_key = (weak_file_descriptor, epoll_event.file_descriptor);
-                    // Retrieve the epoll return if it is already in the return list.
-                    let ready_list = &mut epoll_event.ready_list.borrow_mut();
-                    // Add a new epoll entry if it doesn't exist, or update the event mask if it exists.
-                    let epoll_return = EpollReturn::new(flags, epoll_event.data);
-                    let epoll_entry = ready_list.entry(epoll_key).or_insert(epoll_return);
-                    // The update here is bitwise or, so it will still be correct if we try to add
-                    // a flag that already exists.
-                    epoll_entry.update_events(flags);
-                }
-            }
-        }
-    }
-}
-
 impl FileDescription for Event {
     fn name(&self) -> &'static str {
         "event"
@@ -86,6 +62,7 @@ impl FileDescription for Event {
     }
     fn close<'tcx>(
         self: Box<Self>,
+        _ecx: &mut MiriInterpCx<'tcx>,
         _communicate_allowed: bool,
     ) -> InterpResult<'tcx, io::Result<()>> {
         Ok(Ok(()))
@@ -121,7 +98,7 @@ impl FileDescription for Event {
             self.counter = 0;
             // When any of the event is happened, we check and update the status of all supported flags.
             self.check_readiness(ecx)
-                .map(|events| self.update_readiness(events, self.return_epoll_events().unwrap()))?;
+                .map(|events| ecx.update_readiness(events, self.return_epoll_events()?))??;
             return Ok(Ok(U64_ARRAY_SIZE));
         }
     }
@@ -167,9 +144,8 @@ impl FileDescription for Event {
                 }
                 self.counter = new_count;
                 // When any of the event is happened, we check and update the status of all supported flags.
-                self.check_readiness(ecx).map(|events| {
-                    self.update_readiness(events, self.return_epoll_events().unwrap())
-                })?;
+                self.check_readiness(ecx)
+                    .map(|events| ecx.update_readiness(events, self.return_epoll_events()?))??;
             }
             None | Some(u64::MAX) => {
                 if self.is_nonblock {
diff --git a/src/shims/unix/socket.rs b/src/shims/unix/socket.rs
@@ -5,7 +5,6 @@ use std::io::{Error, ErrorKind, Read};
 use std::rc::{Rc, Weak};
 
 use crate::shims::unix::fd::WeakFileDescriptor;
-use crate::shims::unix::linux::epoll::EpollReturn;
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
@@ -38,28 +37,6 @@ impl SocketPair {
     fn peer_is_closed(&mut self) {
         self.peer_closed = true;
     }
-
-    /// Functions to update the ready list of an epoll_event.
-    fn update_readiness(&self, ready_flags: Vec<u32>, epoll_events: &Vec<Weak<EpollEvent>>) {
-        for event in epoll_events {
-            // If the current epoll_event contains the flag that is signaled as ready, we add/update
-            // the epoll_return entry in the ready list.
-            if let Some(epoll_event) = event.upgrade() {
-                if let Some(flags) = epoll_event.contains_flag(&ready_flags) {
-                    let weak_file_descriptor = epoll_event.weak_file_descriptor.clone();
-                    let epoll_key = (weak_file_descriptor, epoll_event.file_descriptor);
-                    // Retrieve the epoll return if it is already in the return list.
-                    let ready_list = &mut epoll_event.ready_list.borrow_mut();
-                    // Add a new epoll entry if it doesn't exist, or update the event mask if it exists.
-                    let epoll_return = EpollReturn::new(flags, epoll_event.data);
-                    let epoll_entry = ready_list.entry(epoll_key).or_insert(epoll_return);
-                    // The update here is bitwise or, so it will still be correct if we try to add
-                    // a flag that already exists.
-                    epoll_entry.update_events(flags);
-                }
-            }
-        }
-    }
 }
 
 #[derive(Debug)]
@@ -109,11 +86,17 @@ impl FileDescription for SocketPair {
             }
         }
 
+        // Check if the peer_fd closed
+        if self.peer_closed {
+            ready_flags.push(epollrdhup);
+        }
+
         Ok(ready_flags)
     }
 
     fn close<'tcx>(
         self: Box<Self>,
+        ecx: &mut MiriInterpCx<'tcx>,
         _communicate_allowed: bool,
     ) -> InterpResult<'tcx, io::Result<()>> {
         // This is used to signal socketfd of other side that there is no writer to its readbuf.
@@ -129,12 +112,11 @@ impl FileDescription for SocketPair {
                 let peer_socketpair = binding.downcast_mut::<SocketPair>().unwrap();
                 peer_socketpair.peer_is_closed();
                 // When any of the event is happened, we check and update the status of all supported flags.
-                //peer_socketpair
-                //    .check_readiness(ecx)
-                //    .map(|events| ecx.update_readiness(events, self.return_epoll_events()?))??;
+                peer_socketpair
+                    .check_readiness(ecx)
+                    .map(|events| ecx.update_readiness(events, self.return_epoll_events()?))??;
             }
         }
-        // TODO: invoke check readiness from other side
         Ok(Ok(()))
     }
 
@@ -182,7 +164,7 @@ impl FileDescription for SocketPair {
         let actual_read_size = readbuf.buf.read(bytes).unwrap();
         // When any of the event is happened, we check and update the status of all supported flags.
         self.check_readiness(ecx)
-            .map(|events| self.update_readiness(events, self.return_epoll_events().unwrap()))?;
+            .map(|events| ecx.update_readiness(events, self.return_epoll_events()?))??;
         return Ok(Ok(actual_read_size));
     }
 
@@ -225,7 +207,7 @@ impl FileDescription for SocketPair {
         writebuf.buf.extend(&bytes[..actual_write_size]);
         // When any of the event is happened, we check and update the status of all supported flags.
         self.check_readiness(ecx)
-            .map(|events| self.update_readiness(events, self.return_epoll_events().unwrap()))?;
+            .map(|events| ecx.update_readiness(events, self.return_epoll_events()?))??;
         return Ok(Ok(actual_write_size));
     }
 }
