Fix lints and nits

Author: Arshia001

lib/virtual-fs/src/pipe.rs

@@ -130,18 +130,16 @@ impl PipeRx {
         }
     }
 
-    pub fn set_interest_handler(&mut self, interest_handler: Box<dyn InterestHandler>) {
+    pub fn set_interest_handler(&self, interest_handler: Box<dyn InterestHandler>) {
         let Some(ref rx) = self.rx else {
             return;
         };
         let mut rx = rx.lock().unwrap();
         rx.interest_handler.replace(interest_handler);
     }
 
-    pub fn remove_interest_handler(&mut self) -> Option<Box<dyn InterestHandler>> {
-        let Some(ref rx) = self.rx else {
-            return None;
-        };
+    pub fn remove_interest_handler(&self) -> Option<Box<dyn InterestHandler>> {
+        let rx = self.rx.as_ref()?;
         let mut rx = rx.lock().unwrap();
         rx.interest_handler.take()
     }
@@ -200,11 +198,11 @@ impl Pipe {
         self.recv.close();
     }
 
-    pub fn set_interest_handler(&mut self, interest_handler: Box<dyn InterestHandler>) {
+    pub fn set_interest_handler(&self, interest_handler: Box<dyn InterestHandler>) {
         self.recv.set_interest_handler(interest_handler);
     }
 
-    pub fn remove_interest_handler(&mut self) -> Option<Box<dyn InterestHandler>> {
+    pub fn remove_interest_handler(&self) -> Option<Box<dyn InterestHandler>> {
         self.recv.remove_interest_handler()
     }
 }
@@ -235,7 +233,7 @@ impl PipeTx {
         }
     }
 
-    fn push_readable_interest_to_rx_end(&self) {
+    fn mark_other_end_readable(&self) {
         if let Some(rx_end) = self.rx_end.upgrade() {
             let mut guard = rx_end.lock().unwrap();
             if let Some(interest_handler) = guard.interest_handler.as_mut() {
@@ -332,7 +330,7 @@ impl std::io::Write for PipeTx {
 
         tx.send(buf.to_vec())
             .map_err(|_| Into::<std::io::Error>::into(std::io::ErrorKind::BrokenPipe))?;
-        self.push_readable_interest_to_rx_end();
+        self.mark_other_end_readable();
         Ok(buf.len())
     }
 
@@ -419,7 +417,7 @@ impl AsyncWrite for PipeTx {
 
         match tx.send(buf.to_vec()) {
             Ok(()) => {
-                self.push_readable_interest_to_rx_end();
+                self.mark_other_end_readable();
                 Poll::Ready(Ok(buf.len()))
             }
             Err(_) => Poll::Ready(Err(Into::<std::io::Error>::into(

lib/wasix/src/fs/fd.rs

@@ -124,11 +124,11 @@ impl Drop for EpollJoinGuard {
                 inner.remove_interest_handler();
             }
             InodeValFilePollGuardMode::DuplexPipe { pipe } => {
-                let mut inner = pipe.write().unwrap();
+                let inner = pipe.write().unwrap();
                 inner.remove_interest_handler();
             }
             InodeValFilePollGuardMode::PipeRx { rx } => {
-                let mut inner = rx.write().unwrap();
+                let inner = rx.write().unwrap();
                 inner.remove_interest_handler();
             }
             InodeValFilePollGuardMode::PipeTx { .. } => {

lib/wasix/src/net/socket.rs

@@ -235,6 +235,9 @@ impl InodeSocket {
 
     // When a sendto or connect call comes in for a UDP "pre-socket", it must be bound to
     // an ephemeral port automatically.
+    // Apparently, clippy fails to recognize the write-locked guard being passed into
+    // the other function, hence the `allow` attribute.
+    #[allow(clippy::await_holding_lock, clippy::readonly_write_lock)]
     pub async fn auto_bind_udp(
         &self,
         tasks: &dyn VirtualTaskManager,
@@ -245,15 +248,15 @@ impl InodeSocket {
             .ok()
             .flatten()
             .unwrap_or(Duration::from_secs(30));
-        let mut inner = self.inner.protected.write().unwrap();
+        let inner = self.inner.protected.write().unwrap();
         match &inner.kind {
             InodeSocketKind::PreSocket { props, .. } if props.ty == Socktype::Dgram => {
                 let addr = match props.family {
                     Addressfamily::Inet4 => SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0),
                     Addressfamily::Inet6 => SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 0),
                     _ => return Err(Errno::Notsup),
                 };
-                Self::bind_internal(tasks, net, addr, timeout, &mut inner).await
+                Self::bind_internal(tasks, net, addr, timeout, inner).await
             }
             _ => Ok(None),
         }
@@ -270,16 +273,18 @@ impl InodeSocket {
             .ok()
             .flatten()
             .unwrap_or(Duration::from_secs(30));
-        let mut inner = self.inner.protected.write().unwrap();
-        Self::bind_internal(tasks, net, set_addr, timeout, &mut inner).await
+        let inner = self.inner.protected.write().unwrap();
+        Self::bind_internal(tasks, net, set_addr, timeout, inner).await
     }
 
+    // The lock is dropped before awaiting, but clippy doesn't realize it
+    #[allow(clippy::await_holding_lock)]
     async fn bind_internal(
         tasks: &dyn VirtualTaskManager,
         net: &dyn VirtualNetworking,
         set_addr: SocketAddr,
         timeout: Duration,
-        inner: &mut RwLockWriteGuard<'_, InodeSocketProtected>,
+        mut inner: RwLockWriteGuard<'_, InodeSocketProtected>,
     ) -> Result<Option<InodeSocket>, Errno> {
         let socket = {
             match &mut inner.kind {
@@ -373,6 +378,8 @@ impl InodeSocket {
             }
         };
 
+        drop(inner);
+
         tokio::select! {
             socket = socket => {
                 let socket = socket.map_err(net_error_into_wasi_err)?;

lib/wasix/src/syscalls/wasix/epoll_ctl.rs

@@ -6,10 +6,7 @@ use wasmer_wasix_types::wasi::{
     EpollCtl, EpollEvent, EpollEventCtl, EpollType, SubscriptionClock, SubscriptionUnion, Userdata,
 };
 
-use std::{
-    os::fd,
-    task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-};
+use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
 
 use futures::Future;