Fail attempt: Hard to give FileDescriptor::close ecx access

Author: tiif

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,13 @@ 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<'ctx>(self,
+                       ecx: &mut MiriInterpCx<'tcx>,
+                       communicate_allowed: bool) -> InterpResult<'ctx, 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(())),
         }
     }

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

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

src/shims/unix/linux/eventfd.rs

@@ -62,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(()))

src/shims/unix/socket.rs

@@ -25,13 +25,18 @@ struct SocketPair {
     readbuf: Rc<RefCell<Buffer>>,
     peer_fd: Weak<WeakFileDescriptor>,
     is_nonblock: bool,
+    peer_closed: bool,
     epoll_events: Vec<Weak<EpollEvent>>,
 }
 
 impl SocketPair {
     fn add_peer_fd(&mut self, fd: Weak<WeakFileDescriptor>) {
         self.peer_fd = fd;
     }
+
+    fn peer_is_closed(&mut self) {
+        self.peer_closed = true;
+    }
 }
 
 #[derive(Debug)]
@@ -80,20 +85,34 @@ impl FileDescription for SocketPair {
                 ready_flags.push(epollout);
             }
         }
+
         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.
         // If the upgrade fails, there is no need to update as all read ends have been dropped.
         if let Some(writebuf) = self.writebuf.upgrade() {
             writebuf.borrow_mut().buf_has_writer = false;
         };
-        // TODO: how to notify another file description from here? We only have access to
-        // current file description.
+
+        // Notify peer fd that closed has happened.
+        if let Some(peer_fd) = self.peer_fd.upgrade() {
+            if let Some(file_description) = peer_fd.get_file_description() {
+                let mut binding = file_description.borrow_mut();
+                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()?))??;
+            }
+        }
+        // TODO: invoke check readiness from other side
         Ok(Ok(()))
     }
 
@@ -264,13 +283,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             writebuf: Rc::downgrade(&buffer1),
             readbuf: Rc::clone(&buffer2),
             peer_fd: Weak::new(),
+            peer_closed: false,
             is_nonblock: is_sock_nonblock,
             epoll_events: Vec::new(),
         };
         let socketpair_1 = SocketPair {
             writebuf: Rc::downgrade(&buffer2),
             readbuf: Rc::clone(&buffer1),
             peer_fd: Weak::new(),
+            peer_closed: false,
             is_nonblock: is_sock_nonblock,
             epoll_events: Vec::new(),
         };