fix: read and recv

Handles were stored on open(). Obvious that this is wrong as with other
fd pointing to the same file would be different. This was totally wrong.
Pass open flags for now as thats what we need. May pass &fd or smth in
the future.

Signed-off-by: Anhad Singh <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

src/aero_kernel/src/drivers/keyboard.rs

@@ -15,6 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Aero. If not, see <https://www.gnu.org/licenses/>.
 
+use aero_syscall::OpenFlags;
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 use spin::RwLock;
@@ -228,7 +229,7 @@ impl KeyboardListener for KeyboardDevice {
 }
 
 impl INodeInterface for KeyboardDevice {
-    fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
         if self.buffer.lock_irq().is_empty() {
             return Ok(0);
         }

src/aero_kernel/src/drivers/mouse.rs

@@ -15,6 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Aero. If not, see <https://www.gnu.org/licenses/>.
 
+use aero_syscall::OpenFlags;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 
@@ -137,7 +138,7 @@ impl Device for Mouse {
 }
 
 impl INodeInterface for Mouse {
-    fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
         let size = core::mem::size_of::<Packet>();
 
         if buffer.len() < size {

src/aero_kernel/src/drivers/pty.rs

@@ -17,8 +17,7 @@
 
 use core::sync::atomic::{AtomicU32, Ordering};
 
-use aero_syscall as libc;
-use aero_syscall::{Termios, WinSize};
+use aero_syscall::{self as libc, OpenFlags, Termios, WinSize};
 
 use alloc::collections::BTreeMap;
 use alloc::string::ToString;
@@ -128,7 +127,7 @@ impl Master {
 }
 
 impl INodeInterface for Master {
-    fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
         let mut pty_buffer = self.buffer.lock_irq();
 
         if pty_buffer.is_empty() {
@@ -280,7 +279,7 @@ impl INodeInterface for Slave {
         Ok(flags)
     }
 
-    fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
         Ok(self.master.discipline.read(buffer)?)
     }
 

src/aero_kernel/src/drivers/tty/ctty.rs

@@ -17,7 +17,7 @@
 
 //! `/dev/tty`: Controlling terminal of the current process.
 
-use aero_syscall::TIOCNOTTY;
+use aero_syscall::{OpenFlags, TIOCNOTTY};
 use alloc::sync::{Arc, Weak};
 
 use crate::fs::devfs::Device;
@@ -64,8 +64,8 @@ impl INodeInterface for Ctty {
         })
     }
 
-    fn read_at(&self, offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
-        Self::controlling_terminal()?.read_at(offset, buffer)
+    fn read_at(&self, flags: OpenFlags, offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
+        Self::controlling_terminal()?.read_at(flags, offset, buffer)
     }
 
     fn write_at(&self, offset: usize, buffer: &[u8]) -> fs::Result<usize> {

src/aero_kernel/src/drivers/tty/vtty.rs

@@ -19,6 +19,7 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
+use aero_syscall::OpenFlags;
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 
@@ -246,7 +247,7 @@ impl INodeInterface for Tty {
         self.connected.fetch_sub(1, Ordering::SeqCst);
     }
 
-    fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
         self.block_queue
             .block_on(&self.stdin, |future| future.is_complete())?;
 

src/aero_kernel/src/fs/devfs.rs

@@ -36,7 +36,7 @@ use super::ramfs::RamFs;
 use super::{FileSystem, FileSystemError, Result, MOUNT_MANAGER};
 
 use aero_syscall::prelude::*;
-use aero_syscall::MMapFlags;
+use aero_syscall::{MMapFlags, OpenFlags};
 
 lazy_static::lazy_static! {
     pub static ref DEV_FILESYSTEM: Arc<DevFs> = DevFs::new();
@@ -113,8 +113,8 @@ impl INodeInterface for DevINode {
         self.0.inode().write_at(offset, buffer)
     }
 
-    fn read_at(&self, offset: usize, buffer: &mut [u8]) -> Result<usize> {
-        self.0.inode().read_at(offset, buffer)
+    fn read_at(&self, flags: OpenFlags, offset: usize, buffer: &mut [u8]) -> Result<usize> {
+        self.0.inode().read_at(flags, offset, buffer)
     }
 
     fn mmap(&self, offset: usize, size: usize, flags: MMapFlags) -> Result<PhysFrame> {
@@ -178,7 +178,7 @@ impl Device for DevNull {
 }
 
 impl INodeInterface for DevNull {
-    fn read_at(&self, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {
         Ok(0x00)
     }
 
@@ -214,7 +214,7 @@ impl Device for DevKmsg {
 }
 
 impl INodeInterface for DevKmsg {
-    fn read_at(&self, offset: usize, buffer: &mut [u8]) -> Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, offset: usize, buffer: &mut [u8]) -> Result<usize> {
         let buf = logger::get_log_buffer();
 
         let size = core::cmp::min(buffer.len(), buf.len());
@@ -448,7 +448,7 @@ impl Device for DevUrandom {
 }
 
 impl INodeInterface for DevUrandom {
-    fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> Result<usize> {
         for (_, b) in buffer.iter_mut().enumerate() {
             *b = 0;
         }

src/aero_kernel/src/fs/eventfd.rs

@@ -54,7 +54,12 @@ impl INodeInterface for EventFd {
         Ok(None)
     }
 
-    fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> super::Result<usize> {
+    fn read_at(
+        &self,
+        _flags: OpenFlags,
+        _offset: usize,
+        buffer: &mut [u8],
+    ) -> super::Result<usize> {
         let size = core::mem::size_of::<u64>();
         assert!(buffer.len() >= size);
 

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

@@ -21,7 +21,7 @@ mod group_desc;
 use core::mem::MaybeUninit;
 
 use aero_syscall::socket::{MessageFlags, MessageHeader};
-use aero_syscall::{MMapFlags, SyscallError};
+use aero_syscall::{MMapFlags, OpenFlags, SyscallError};
 use alloc::boxed::Box;
 use alloc::string::ToString;
 use alloc::sync::{Arc, Weak};
@@ -364,7 +364,7 @@ impl CachedAccess for INode {
     }
 
     fn read_direct(&self, offset: usize, dest: PhysFrame) -> Option<usize> {
-        INodeInterface::read_at(self, offset, dest.as_slice_mut()).ok()
+        INodeInterface::read_at(self, OpenFlags::empty(), offset, dest.as_slice_mut()).ok()
     }
 
     fn write_direct(&self, offset: usize, src: PhysFrame) -> Option<usize> {
@@ -440,9 +440,14 @@ impl INodeInterface for INode {
         Ok(self.make_dirent(parent, entry.name(), entry).unwrap())
     }
 
-    fn read_at(&self, offset: usize, usr_buffer: &mut [u8]) -> super::Result<usize> {
+    fn read_at(
+        &self,
+        flags: OpenFlags,
+        offset: usize,
+        usr_buffer: &mut [u8],
+    ) -> super::Result<usize> {
         if let Some(proxy) = self.proxy.as_ref() {
-            return proxy.read_at(offset, usr_buffer);
+            return proxy.read_at(flags, offset, usr_buffer);
         }
 
         if !self.metadata()?.is_file() {
@@ -596,7 +601,7 @@ impl INodeInterface for INode {
         private_cp.as_slice_mut().fill(0);
 
         let buffer = &mut private_cp.as_slice_mut()[..size];
-        self.read_at(offset, buffer)?;
+        self.read_at(OpenFlags::empty(), offset, buffer)?;
 
         Ok(private_cp)
     }
@@ -644,9 +649,14 @@ impl INodeInterface for INode {
         }
     }
 
-    fn recv(&self, message_hdr: &mut MessageHeader, flags: MessageFlags) -> super::Result<usize> {
+    fn recv(
+        &self,
+        fd_flags: OpenFlags,
+        message_hdr: &mut MessageHeader,
+        flags: MessageFlags,
+    ) -> super::Result<usize> {
         if let Some(proxy) = self.proxy.as_ref() {
-            proxy.recv(message_hdr, flags)
+            proxy.recv(fd_flags, message_hdr, flags)
         } else {
             Err(FileSystemError::NotSupported)
         }

src/aero_kernel/src/fs/file_table.rs

@@ -81,7 +81,7 @@ impl FileHandle {
 
     pub fn read(&self, buffer: &mut [u8]) -> super::Result<usize> {
         let offset = self.offset.load(Ordering::SeqCst);
-        let new_offset = self.inode.inode().read_at(offset, buffer)?;
+        let new_offset = self.inode.inode().read_at(self.flags(), offset, buffer)?;
 
         self.offset.fetch_add(new_offset, Ordering::SeqCst);
         Ok(new_offset)

src/aero_kernel/src/fs/inode.rs

@@ -137,7 +137,7 @@ pub trait INodeInterface: Send + Sync {
     }
 
     /// Read at the provided `offset` to the given `buffer`.
-    fn read_at(&self, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {
+    fn read_at(&self, _flags: OpenFlags, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {
         Err(FileSystemError::NotSupported)
     }
 
@@ -269,7 +269,12 @@ pub trait INodeInterface: Send + Sync {
         Err(FileSystemError::NotSupported)
     }
 
-    fn recv(&self, _message_hdr: &mut MessageHeader, _flags: MessageFlags) -> Result<usize> {
+    fn recv(
+        &self,
+        _fd_flags: OpenFlags,
+        _message_hdr: &mut MessageHeader,
+        _flags: MessageFlags,
+    ) -> Result<usize> {
         Err(FileSystemError::NotSocket)
     }