Fail attempt 2: If update_readiness is only implement under SocketPair and Eventfd, epoll_ctl can't find a way to invoke it~

Author: tiif

src/shims/unix/fd.rs

@@ -51,7 +51,6 @@ 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());
@@ -198,13 +197,11 @@ impl FileDescriptor {
         RefMut::map(self.0.borrow_mut(), |fd| fd.as_mut())
     }
 
-    pub fn close<'ctx>(self,
-                       ecx: &mut MiriInterpCx<'tcx>,
-                       communicate_allowed: bool) -> InterpResult<'ctx, io::Result<()>> {
+    pub fn close<'ctx>(self, 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(ecx, communicate_allowed),
+            Some(fd) => RefCell::into_inner(fd).close(communicate_allowed),
             None => Ok(Ok(())),
         }
     }
@@ -412,33 +409,6 @@ 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();
 

src/shims/unix/fs.rs

@@ -60,7 +60,6 @@ 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,7 +88,6 @@ impl FileDescription for Epoll {
 
     fn close<'tcx>(
         self: Box<Self>,
-        _ecx: &mut MiriInterpCx<'tcx>,
         _communicate_allowed: bool,
     ) -> InterpResult<'tcx, io::Result<()>> {
         Ok(Ok(()))
@@ -215,8 +214,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             interest_list.insert(epoll_key, event);
 
             target_file_description.check_readiness(this).map(|events| {
-                this.update_readiness(events, target_file_description.return_epoll_events()?)
-            })??;
+                target_file_description.update_readiness(
+                    events,
+                    target_file_description.return_epoll_events().unwrap(),
+                )
+            })?;
 
             Ok(Scalar::from_i32(0))
         } else if op == epoll_ctl_del {

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;
+use crate::shims::unix::linux::epoll::{EpollEvent, EpollReturn};
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
@@ -35,6 +35,30 @@ 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"
@@ -62,7 +86,6 @@ impl FileDescription for Event {
     }
     fn close<'tcx>(
         self: Box<Self>,
-        _ecx: &mut MiriInterpCx<'tcx>,
         _communicate_allowed: bool,
     ) -> InterpResult<'tcx, io::Result<()>> {
         Ok(Ok(()))
@@ -98,7 +121,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| ecx.update_readiness(events, self.return_epoll_events()?))??;
+                .map(|events| self.update_readiness(events, self.return_epoll_events().unwrap()))?;
             return Ok(Ok(U64_ARRAY_SIZE));
         }
     }
@@ -144,8 +167,9 @@ 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| ecx.update_readiness(events, self.return_epoll_events()?))??;
+                self.check_readiness(ecx).map(|events| {
+                    self.update_readiness(events, self.return_epoll_events().unwrap())
+                })?;
             }
             None | Some(u64::MAX) => {
                 if self.is_nonblock {

src/shims/unix/socket.rs

@@ -5,6 +5,7 @@ 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, *};
 
@@ -37,6 +38,28 @@ 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)]
@@ -91,7 +114,6 @@ impl FileDescription for SocketPair {
 
     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.
@@ -107,9 +129,9 @@ 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
@@ -160,7 +182,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| ecx.update_readiness(events, self.return_epoll_events()?))??;
+            .map(|events| self.update_readiness(events, self.return_epoll_events().unwrap()))?;
         return Ok(Ok(actual_read_size));
     }
 
@@ -203,7 +225,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| ecx.update_readiness(events, self.return_epoll_events()?))??;
+            .map(|events| self.update_readiness(events, self.return_epoll_events().unwrap()))?;
         return Ok(Ok(actual_write_size));
     }
 }