INodeInterface::recv: dont take non-block

Do not take `non_block` as a parameter for `recv` since you can check if
the file handle has NON_BLOCK flag set inside the inode.

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

src/aero_kernel/src/fs/ext2/mod.rs

@@ -549,17 +549,17 @@ impl INodeInterface for INode {
         return Err(FileSystemError::NotSupported);
     }
 
-    fn send(&self, message_header: &mut MessageHeader) -> super::Result<usize> {
+    fn send(&self, message_hdr: &mut MessageHeader) -> super::Result<usize> {
         if let Some(proxy) = self.proxy.as_ref() {
-            return proxy.send(message_header);
+            return proxy.send(message_hdr);
         }
 
         return Err(FileSystemError::NotSupported);
     }
 
-    fn recv(&self, message_header: &mut MessageHeader, non_block: bool) -> super::Result<usize> {
+    fn recv(&self, message_hdr: &mut MessageHeader) -> super::Result<usize> {
         if let Some(proxy) = self.proxy.as_ref() {
-            return proxy.recv(message_header, non_block);
+            return proxy.recv(message_hdr);
         }
 
         return Err(FileSystemError::NotSupported);

src/aero_kernel/src/fs/inode.rs

@@ -248,7 +248,7 @@ pub trait INodeInterface: Send + Sync {
         Err(FileSystemError::NotSupported)
     }
 
-    fn recv(&self, _message_header: &mut MessageHeader, _non_block: bool) -> Result<usize> {
+    fn recv(&self, _message_hdr: &mut MessageHeader) -> Result<usize> {
         Err(FileSystemError::NotSocket)
     }
 

src/aero_kernel/src/socket/unix.rs

@@ -388,15 +388,15 @@ impl INodeInterface for UnixSocket {
         Ok(sock)
     }
 
-    fn recv(&self, header: &mut MessageHeader, non_block: bool) -> fs::Result<usize> {
+    fn recv(&self, header: &mut MessageHeader) -> fs::Result<usize> {
         let inner = self.inner.lock_irq();
 
         let peer = match &inner.state {
             UnixSocketState::Connected(peer) => peer,
             _ => return Err(FileSystemError::NotConnected),
         };
 
-        if self.buffer.lock_irq().is_empty() && non_block {
+        if self.buffer.lock_irq().is_empty() && self.is_non_block() {
             return Err(FileSystemError::WouldBlock);
         }
 

src/aero_kernel/src/syscall/net.rs

@@ -97,8 +97,7 @@ pub fn sock_recv(
         .get_handle(sockfd)
         .ok_or(SyscallError::EINVAL)?;
 
-    let non_block = socket.flags.read().contains(OpenFlags::O_NONBLOCK);
-    Ok(socket.inode().recv(header, non_block)?)
+    Ok(socket.inode().recv(header)?)
 }
 
 /// Marks the socket as a passive socket (i.e. as a socket that will be used to accept incoming