sys_epoll_pwait: initial implementation

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

.gitignore

@@ -22,5 +22,3 @@ base-files/doom1.wad
 # Wayland test client and server executables: (todo: remove these)
 base-files/client
 base-files/server
-
-userland/.cargo/config.toml

src/aero_kernel/src/drivers/tty.rs

@@ -17,13 +17,14 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
+use aero_syscall::prelude::EPollEventFlags;
 use alloc::string::String;
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 
 use crate::fs;
 use crate::fs::devfs;
-use crate::fs::inode;
+use crate::fs::inode::{self, PollTable};
 use crate::rendy;
 
 use crate::fs::inode::INodeInterface;
@@ -257,6 +258,17 @@ impl INodeInterface for Tty {
         Ok(buffer.len())
     }
 
+    fn poll(&self, table: Option<&mut PollTable>) -> fs::Result<EPollEventFlags> {
+        table.map(|e| e.insert(&self.block_queue));
+        let mut events = EPollEventFlags::default();
+
+        if self.stdin.lock_irq().is_complete() {
+            events.insert(EPollEventFlags::IN);
+        }
+
+        Ok(events)
+    }
+
     fn ioctl(&self, command: usize, arg: usize) -> fs::Result<usize> {
         match command {
             aero_syscall::TIOCGWINSZ => {

src/aero_kernel/src/fs/devfs.rs

@@ -35,7 +35,7 @@ use crate::mem::paging::*;
 use crate::rendy::RendyInfo;
 
 use super::cache::{DirCacheItem, INodeCacheItem};
-use super::inode::INodeInterface;
+use super::inode::{INodeInterface, PollTable};
 use super::ramfs::RamFs;
 use super::FileSystemError;
 use super::{FileSystem, Result, MOUNT_MANAGER};
@@ -128,6 +128,10 @@ impl INodeInterface for DevINode {
     fn ioctl(&self, command: usize, arg: usize) -> Result<usize> {
         self.0.inode().ioctl(command, arg)
     }
+
+    fn poll(&self, table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
+        self.0.inode().poll(table)
+    }
 }
 
 /// Implementation of dev filesystem. (See the module-level documentation for more

src/aero_kernel/src/fs/epoll.rs

@@ -17,13 +17,17 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
-use aero_syscall::{prelude::EPollEvent, AeroSyscallError};
+use aero_syscall::prelude::EPollEvent;
+use aero_syscall::AeroSyscallError;
+
 use alloc::sync::Arc;
 use hashbrown::HashMap;
 
+use crate::userland::scheduler;
 use crate::utils::sync::Mutex;
 
-use super::inode::INodeInterface;
+use super::inode::{INodeInterface, PollTable};
+use super::FileSystemError;
 
 pub struct EPoll {
     events: Mutex<HashMap<usize, EPollEvent>>,
@@ -50,6 +54,99 @@ impl EPoll {
         events.insert(fd, event);
         Ok(())
     }
+
+    /// Retrieves ready events, and delivers them to the caller-supplied event buffer.
+    ///
+    /// ## Arguments
+    ///
+    /// * `events`: Used to return information from the ready list about file descriptors in the
+    /// interest list that have some events available.
+    ///
+    /// * `max_events`: Maximum number of events.
+    ///
+    /// * `timeout`: specifies the minimum number of milliseconds that epoll wait will block. Specifying
+    /// a timeout of `-1` will block indefinitely. While specifing a timeout of `0` will return immediately
+    /// even if there are available no events.
+    ///
+    /// ## Return
+    /// Returns the number of ready events if the call was successful.
+    ///
+    /// ## Blocking
+    /// Blocks the current task until either:
+    ///
+    /// * A file descriptor delivers an event.
+    /// * The call is interrupted by a signal handler.
+    /// * The timeout expires.
+    pub fn wait(
+        &self,
+        ret_events: &mut [&mut EPollEvent],
+        max_events: usize,
+        _timeout: usize,
+    ) -> Result<usize, FileSystemError> {
+        let current_task = scheduler::get_scheduler().current_task();
+        let file_table = &current_task.file_table;
+
+        let mut table = self.events.lock();
+        let mut n = 0;
+
+        let mut fds = alloc::vec![];
+        let mut poll_table = PollTable::default();
+
+        // Iterate over all the registered events and check if they are ready.
+        for (fd, epoll_event) in table.iter_mut() {
+            if n == max_events {
+                break;
+            }
+
+            let fd = file_table
+                .get_handle(*fd)
+                .ok_or(FileSystemError::NotSupported)?; // EINVAL
+
+            let flags = epoll_event.events;
+            let ready = fd.inode().poll(None)?;
+
+            if ready.contains(flags) {
+                // The registered event is ready; increment the number of ready events
+                // and set event flags mask for this event in the caller-supplied event
+                // buffer.
+                ret_events[n].events = ready & flags;
+                n += 1;
+                continue;
+            }
+
+            // Not ready; add the event to the poll table.
+            fd.inode().poll(Some(&mut poll_table))?;
+            fds.push(fd);
+        }
+
+        // If all events are ready, we can return now.
+        if n > 0 {
+            debug_assert!(fds.len() == 0);
+            return Ok(n);
+        }
+
+        'search: loop {
+            // Wait till one of the file descriptor deliever an event.
+            scheduler::get_scheduler().inner.await_io()?;
+
+            for fd in fds.iter() {
+                let ready = fd.inode().poll(None)?;
+                let flags = table
+                    .get(&fd.fd)
+                    .ok_or(FileSystemError::NotSupported)?
+                    .events;
+
+                if ready.contains(flags) {
+                    // The event is ready; break out of the search loop and set ready
+                    // events to 1.
+                    n = 1;
+                    break 'search;
+                }
+            }
+        }
+
+        Ok(n)
+    }
 }
 
 unsafe impl Send for EPoll {}

src/aero_kernel/src/fs/eventfd.rs

@@ -17,24 +17,57 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
+use aero_syscall::prelude::EPollEventFlags;
 use alloc::sync::Arc;
 
-use super::inode::INodeInterface;
+use super::inode::{INodeInterface, PollTable};
+use crate::utils::sync::{BlockQueue, Mutex};
 
-pub struct EventFd {}
+pub struct EventFd {
+    wq: BlockQueue,
+    count: Mutex<usize>,
+}
 
 impl EventFd {
     pub fn new() -> Arc<Self> {
-        Arc::new(Self {})
+        Arc::new(Self {
+            wq: BlockQueue::new(),
+            count: Mutex::new(0),
+        })
     }
 }
 
 impl INodeInterface for EventFd {
     fn read_at(&self, _offset: usize, _buffer: &mut [u8]) -> super::Result<usize> {
+        self.wq.notify_complete();
+
         unimplemented!()
     }
 
     fn write_at(&self, _offset: usize, _buffer: &[u8]) -> super::Result<usize> {
+        self.wq.notify_complete();
+
         unimplemented!()
     }
+
+    fn poll(&self, table: Option<&mut PollTable>) -> super::Result<EPollEventFlags> {
+        let count = self.count.lock();
+        let mut events = EPollEventFlags::default();
+
+        table.map(|e| e.insert(&self.wq)); // listen for changes
+
+        if *count > 0 {
+            events.insert(EPollEventFlags::IN);
+        }
+
+        if *count == usize::MAX {
+            events.insert(EPollEventFlags::ERR);
+        }
+
+        if *count < (usize::MAX - 1) {
+            events.insert(EPollEventFlags::OUT); // possible to write a value of at least "1" without blocking.
+        }
+
+        Ok(events)
+    }
 }

src/aero_kernel/src/fs/file_table.rs

@@ -122,10 +122,10 @@ impl FileHandle {
         self.inode.inode()
     }
 
-    pub fn duplicate(&self, flags: OpenFlags) -> super::Result<Arc<FileHandle>> {
+    pub fn duplicate(&self, dupfd: usize, flags: OpenFlags) -> super::Result<Arc<FileHandle>> {
         let flags = self.flags | flags;
         let new = Arc::new(Self {
-            fd: self.fd,
+            fd: dupfd,
             inode: self.inode.clone(),
             offset: self.offset.clone(),
             flags,
@@ -241,15 +241,15 @@ impl FileTable {
             // avaliable file descriptor.
             for (i, file) in array.iter_mut().enumerate() {
                 if file.is_none() {
-                    *file = Some(handle.duplicate(flags)?);
+                    *file = Some(handle.duplicate(i, flags)?);
                     return Ok(i);
                 }
             }
 
-            // We ran out of file descriptors. Grow the table and add the
-            // file descriptor.
-            files.push(Some(handle.duplicate(flags)?));
-            Ok(files.len() - 1)
+            // We ran out of file descriptors. Grow the FD table and insert the FD.
+            let fd = files.len();
+            files.push(Some(handle.duplicate(fd, flags)?));
+            Ok(fd)
         };
 
         match hint {
@@ -258,12 +258,12 @@ impl FileTable {
 
                 // Ensure the file descriptor is available.
                 if files[new_fd].is_none() {
-                    files[new_fd] = Some(handle.duplicate(flags)?);
+                    files[new_fd] = Some(handle.duplicate(new_fd, flags)?);
                     Ok(0x00)
                 } else {
                     // If the file descriptor is not available, then we close the
                     // old one and set its handle to the new duplicate handle.
-                    let handle = handle.duplicate(flags)?;
+                    let handle = handle.duplicate(new_fd, flags)?;
                     let old = files[new_fd].take().unwrap();
 
                     old.inode.inode().close(old.flags);

src/aero_kernel/src/fs/inode.rs

@@ -19,17 +19,21 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
+use aero_syscall::prelude::EPollEventFlags;
 use aero_syscall::{MMapFlags, OpenFlags};
 
 use alloc::string::String;
 use alloc::sync::Arc;
 use alloc::sync::Weak;
 
 use alloc::vec::Vec;
+use intrusive_collections::UnsafeRef;
 use spin::Once;
 
 use crate::mem::paging::PhysFrame;
 use crate::socket::SocketAddr;
+use crate::userland::scheduler;
+use crate::utils::sync::BlockQueue;
 use crate::utils::sync::Mutex;
 use crate::utils::Downcastable;
 
@@ -42,13 +46,31 @@ use super::{FileSystem, FileSystemError, Result};
 
 static DIR_CACHE_MARKER: AtomicUsize = AtomicUsize::new(0x00);
 
+#[derive(Default)]
+pub struct PollTable {
+    pub queues: Vec<UnsafeRef<BlockQueue>>,
+}
+
+impl PollTable {
+    pub fn insert(&mut self, queue: &BlockQueue) {
+        queue.insert(scheduler::get_scheduler().current_task());
+        unsafe { self.queues.push(UnsafeRef::from_raw(queue as *const _)) }
+    }
+}
+
+impl Drop for PollTable {
+    fn drop(&mut self) {
+        let ctask = scheduler::get_scheduler().current_task();
+        for queue in self.queues.iter() {
+            queue.remove(ctask.clone());
+        }
+    }
+}
+
 /// An inode describes a file. An inode structure holds metadata of the
 /// inode which includes its type, size, the number of links referring to it,
 /// and the list of blocks holding the file's content. For example device files,
 /// files on the disk, etc...
-///
-/// This trait requires the implementor to implement [Send], [Sync] and [Downcastable] on
-/// the inode structure.
 pub trait INodeInterface: Send + Sync + Downcastable {
     /// Returns the inode metadata of `this` inode.
     fn metadata(&self) -> Result<Metadata> {
@@ -162,6 +184,10 @@ pub trait INodeInterface: Send + Sync + Downcastable {
     fn as_unix_socket(&self) -> Result<Arc<dyn INodeInterface>> {
         Err(FileSystemError::NotSocket)
     }
+
+    fn poll(&self, _table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
+        Err(FileSystemError::NotSupported)
+    }
 }
 
 /// Structure representing the curcial, characteristics of an inode. The metadata

src/aero_kernel/src/fs/ramfs.rs

@@ -23,6 +23,7 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
+use aero_syscall::prelude::EPollEventFlags;
 use aero_syscall::MMapFlags;
 use alloc::collections::BTreeMap;
 use alloc::string::String;
@@ -38,7 +39,7 @@ use crate::utils::sync::Mutex;
 use super::cache::{self, CacheWeak};
 use super::cache::{CachedINode, DirCacheItem, INodeCacheItem, INodeCacheWeakItem};
 use super::devfs::DevINode;
-use super::inode::{DirEntry, FileType, INodeInterface};
+use super::inode::{DirEntry, FileType, INodeInterface, PollTable};
 use super::inode::{FileContents, Metadata};
 use super::{FileSystem, FileSystemError, Result};
 
@@ -391,6 +392,21 @@ impl INodeInterface for LockedRamINode {
         }
     }
 
+    fn poll(&self, table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
+        let this = self.0.read();
+
+        match &this.contents {
+            FileContents::Device(device) => {
+                let device = device.clone();
+                drop(this);
+
+                device.poll(table)
+            }
+
+            _ => Err(FileSystemError::NotSupported),
+        }
+    }
+
     #[inline]
     fn weak_filesystem(&self) -> Option<Weak<dyn FileSystem>> {
         Some(self.0.read().filesystem.clone())