fix: read and recv

Andy-Python-Programmer · Andy-Python-Programmer · commit bf0f4969f52e · 2025-04-04T19:31:54.000+11:00
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 &amp;fd or smth in
the future.

Signed-off-by: Anhad Singh &lt;andypythonappdeveloper@gmail.com&gt;
diff --git a/src/aero_kernel/src/drivers/keyboard.rs b/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);
         }
diff --git a/src/aero_kernel/src/drivers/mouse.rs b/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 {
diff --git a/src/aero_kernel/src/drivers/pty.rs b/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)?)
     }
 
diff --git a/src/aero_kernel/src/drivers/tty/ctty.rs b/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> {
diff --git a/src/aero_kernel/src/drivers/tty/vtty.rs b/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())?;
 
diff --git a/src/aero_kernel/src/fs/devfs.rs b/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;
         }
diff --git a/src/aero_kernel/src/fs/eventfd.rs b/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);
 
diff --git a/src/aero_kernel/src/fs/ext2/mod.rs b/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)
         }
diff --git a/src/aero_kernel/src/fs/file_table.rs b/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)
diff --git a/src/aero_kernel/src/fs/inode.rs b/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)
     }
 
diff --git a/src/aero_kernel/src/fs/pipe.rs b/src/aero_kernel/src/fs/pipe.rs
@@ -37,8 +37,6 @@ pub struct Pipe {
 
     /// The number of writers currently connected to the pipe.
     num_writers: AtomicUsize,
-
-    handle: Once<Arc<FileHandle>>,
 }
 
 impl Pipe {
@@ -50,8 +48,6 @@ impl Pipe {
             writers: WaitQueue::new(),
 
             num_writers: AtomicUsize::new(0),
-
-            handle: Once::new(),
         })
     }
 
@@ -66,7 +62,6 @@ impl INodeInterface for Pipe {
         // Write end of the pipe:
         if handle.flags().contains(OpenFlags::O_WRONLY) {
             self.num_writers.fetch_add(1, Ordering::SeqCst);
-            self.handle.call_once(|| handle);
         }
 
         Ok(None)
@@ -84,11 +79,8 @@ impl INodeInterface for Pipe {
         }
     }
 
-    fn read_at(&self, _offset: usize, buf: &mut [u8]) -> super::Result<usize> {
-        let flags = self.handle.get().expect("pipe: internal error").flags();
-
-        let nonblock = flags.contains(OpenFlags::O_NONBLOCK);
-        if nonblock && !self.queue.lock_irq().has_data() {
+    fn read_at(&self, flags: OpenFlags, _offset: usize, buf: &mut [u8]) -> super::Result<usize> {
+        if flags.is_nonblock() && !self.queue.lock_irq().has_data() {
             return Err(FileSystemError::WouldBlock);
         }
 
diff --git a/src/aero_kernel/src/fs/procfs.rs b/src/aero_kernel/src/fs/procfs.rs
@@ -17,6 +17,7 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
+use aero_syscall::OpenFlags;
 use alloc::borrow::ToOwned;
 use alloc::collections::BTreeMap;
 use alloc::string::ToString;
@@ -183,7 +184,7 @@ impl LockedProcINode {
 }
 
 impl INodeInterface for LockedProcINode {
-    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 this = self.0.read();
 
         let data = match &this.contents {
diff --git a/src/aero_kernel/src/fs/ramfs.rs b/src/aero_kernel/src/fs/ramfs.rs
@@ -17,7 +17,7 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use aero_syscall::MMapFlags;
+use aero_syscall::{MMapFlags, OpenFlags};
 use alloc::collections::BTreeMap;
 use alloc::string::ToString;
 use alloc::sync::{Arc, Weak};
@@ -261,7 +261,7 @@ impl INodeInterface for LockedRamINode {
         }
     }
 
-    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 this = self.0.read();
 
         match &this.contents {
@@ -294,10 +294,10 @@ impl INodeInterface for LockedRamINode {
                 let device = device.clone();
                 drop(this);
 
-                device.read_at(offset, buffer)
+                device.read_at(flags, offset, buffer)
             }
 
-            FileContents::Socket(e) => e.read_at(offset, buffer),
+            FileContents::Socket(e) => e.read_at(flags, offset, buffer),
             FileContents::None => Err(FileSystemError::NotSupported),
         }
     }
diff --git a/src/aero_kernel/src/socket/netlink.rs b/src/aero_kernel/src/socket/netlink.rs
@@ -27,7 +27,7 @@
 
 use aero_syscall::netlink::{MessageFlags, MessageType, RtAttrType};
 use aero_syscall::socket::{self, MessageHeader};
-use aero_syscall::{netlink, AF_INET, AF_NETLINK, AF_UNSPEC};
+use aero_syscall::{netlink, OpenFlags, AF_INET, AF_NETLINK, AF_UNSPEC};
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use crabnet::network::Ipv4Addr;
@@ -211,7 +211,7 @@ impl INodeInterface for NetLinkSocket {
         unimplemented!()
     }
 
-    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> {
         unimplemented!()
     }
 
@@ -221,6 +221,7 @@ impl INodeInterface for NetLinkSocket {
 
     fn recv(
         &self,
+        _fd_flags: OpenFlags,
         message_hdr: &mut MessageHeader,
         flags: socket::MessageFlags,
     ) -> fs::Result<usize> {
diff --git a/src/aero_kernel/src/socket/tcp.rs b/src/aero_kernel/src/socket/tcp.rs
diff --git a/src/aero_kernel/src/socket/udp.rs b/src/aero_kernel/src/socket/udp.rs
diff --git a/src/aero_kernel/src/socket/unix.rs b/src/aero_kernel/src/socket/unix.rs
diff --git a/src/aero_kernel/src/syscall/net.rs b/src/aero_kernel/src/syscall/net.rs
diff --git a/src/aero_kernel/src/userland/vm.rs b/src/aero_kernel/src/userland/vm.rs
diff --git a/src/aero_kernel/src/utils/mod.rs b/src/aero_kernel/src/utils/mod.rs
diff --git a/src/aero_syscall/src/lib.rs b/src/aero_syscall/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`// You should have received a copy of the GNU General Public License`
`16`	`16`	`// along with Aero. If not, see <https://www.gnu.org/licenses/>.`
`17`	`17`
	`18`	`+use aero_syscall::OpenFlags;`
`18`	`19`	`use alloc::sync::{Arc, Weak};`
`19`	`20`	`use alloc::vec::Vec;`
`20`	`21`	`use spin::RwLock;`
`@@ -228,7 +229,7 @@ impl KeyboardListener for KeyboardDevice {`
`228`	`229`	`}`
`229`	`230`
`230`	`231`	`impl INodeInterface for KeyboardDevice {`
`231`		`- fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
	`232`	`+ fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
`232`	`233`	`if self.buffer.lock_irq().is_empty() {`
`233`	`234`	`return Ok(0);`
`234`	`235`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,7 @@`
`17`	`17`
`18`	`18`	`use core::sync::atomic::{AtomicU32, Ordering};`
`19`	`19`
`20`		`-use aero_syscall as libc;`
`21`		`-use aero_syscall::{Termios, WinSize};`
	`20`	`+use aero_syscall::{self as libc, OpenFlags, Termios, WinSize};`
`22`	`21`
`23`	`22`	`use alloc::collections::BTreeMap;`
`24`	`23`	`use alloc::string::ToString;`
`@@ -128,7 +127,7 @@ impl Master {`
`128`	`127`	`}`
`129`	`128`
`130`	`129`	`impl INodeInterface for Master {`
`131`		`- fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
	`130`	`+ fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
`132`	`131`	`let mut pty_buffer = self.buffer.lock_irq();`
`133`	`132`
`134`	`133`	`if pty_buffer.is_empty() {`
`@@ -280,7 +279,7 @@ impl INodeInterface for Slave {`
`280`	`279`	`Ok(flags)`
`281`	`280`	`}`
`282`	`281`
`283`		`- fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
	`282`	`+ fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
`284`	`283`	`Ok(self.master.discipline.read(buffer)?)`
`285`	`284`	`}`
`286`	`285`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`
`18`	`18`	//! `/dev/tty`: Controlling terminal of the current process.
`19`	`19`
`20`		`-use aero_syscall::TIOCNOTTY;`
	`20`	`+use aero_syscall::{OpenFlags, TIOCNOTTY};`
`21`	`21`	`use alloc::sync::{Arc, Weak};`
`22`	`22`
`23`	`23`	`use crate::fs::devfs::Device;`
`@@ -64,8 +64,8 @@ impl INodeInterface for Ctty {`
`64`	`64`	`})`
`65`	`65`	`}`
`66`	`66`
`67`		`- fn read_at(&self, offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
`68`		`- Self::controlling_terminal()?.read_at(offset, buffer)`
	`67`	`+ fn read_at(&self, flags: OpenFlags, offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {`
	`68`	`+ Self::controlling_terminal()?.read_at(flags, offset, buffer)`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`fn write_at(&self, offset: usize, buffer: &[u8]) -> fs::Result<usize> {`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ use super::ramfs::RamFs;`
`36`	`36`	`use super::{FileSystem, FileSystemError, Result, MOUNT_MANAGER};`
`37`	`37`
`38`	`38`	`use aero_syscall::prelude::*;`
`39`		`-use aero_syscall::MMapFlags;`
	`39`	`+use aero_syscall::{MMapFlags, OpenFlags};`
`40`	`40`
`41`	`41`	`lazy_static::lazy_static! {`
`42`	`42`	`pub static ref DEV_FILESYSTEM: Arc<DevFs> = DevFs::new();`
`@@ -113,8 +113,8 @@ impl INodeInterface for DevINode {`
`113`	`113`	`self.0.inode().write_at(offset, buffer)`
`114`	`114`	`}`
`115`	`115`
`116`		`- fn read_at(&self, offset: usize, buffer: &mut [u8]) -> Result<usize> {`
`117`		`- self.0.inode().read_at(offset, buffer)`
	`116`	`+ fn read_at(&self, flags: OpenFlags, offset: usize, buffer: &mut [u8]) -> Result<usize> {`
	`117`	`+ self.0.inode().read_at(flags, offset, buffer)`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`fn mmap(&self, offset: usize, size: usize, flags: MMapFlags) -> Result<PhysFrame> {`
`@@ -178,7 +178,7 @@ impl Device for DevNull {`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`impl INodeInterface for DevNull {`
`181`		`- fn read_at(&self, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {`
	`181`	`+ fn read_at(&self, _flags: OpenFlags, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {`
`182`	`182`	`Ok(0x00)`
`183`	`183`	`}`
`184`	`184`
`@@ -214,7 +214,7 @@ impl Device for DevKmsg {`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`impl INodeInterface for DevKmsg {`
`217`		`- fn read_at(&self, offset: usize, buffer: &mut [u8]) -> Result<usize> {`
	`217`	`+ fn read_at(&self, _flags: OpenFlags, offset: usize, buffer: &mut [u8]) -> Result<usize> {`
`218`	`218`	`let buf = logger::get_log_buffer();`
`219`	`219`
`220`	`220`	`let size = core::cmp::min(buffer.len(), buf.len());`
`@@ -448,7 +448,7 @@ impl Device for DevUrandom {`
`448`	`448`	`}`
`449`	`449`
`450`	`450`	`impl INodeInterface for DevUrandom {`
`451`		`- fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> Result<usize> {`
	`451`	`+ fn read_at(&self, _flags: OpenFlags, _offset: usize, buffer: &mut [u8]) -> Result<usize> {`
`452`	`452`	`for (_, b) in buffer.iter_mut().enumerate() {`
`453`	`453`	`*b = 0;`
`454`	`454`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ pub trait INodeInterface: Send + Sync {`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	/// Read at the provided `offset` to the given `buffer`.
`140`		`- fn read_at(&self, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {`
	`140`	`+ fn read_at(&self, _flags: OpenFlags, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {`
`141`	`141`	`Err(FileSystemError::NotSupported)`
`142`	`142`	`}`
`143`	`143`
`@@ -269,7 +269,12 @@ pub trait INodeInterface: Send + Sync {`
`269`	`269`	`Err(FileSystemError::NotSupported)`
`270`	`270`	`}`
`271`	`271`
`272`		`- fn recv(&self, _message_hdr: &mut MessageHeader, _flags: MessageFlags) -> Result<usize> {`
	`272`	`+ fn recv(`
	`273`	`+ &self,`
	`274`	`+ _fd_flags: OpenFlags,`
	`275`	`+ _message_hdr: &mut MessageHeader,`
	`276`	`+ _flags: MessageFlags,`
	`277`	`+ ) -> Result<usize> {`
`273`	`278`	`Err(FileSystemError::NotSocket)`
`274`	`279`	`}`
`275`	`280`