syscalls::poll: init

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

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From d3bcf4e954ce27b14f5ffdb994486c984d1773ad Mon Sep 17 00:00:00 2001
+From a1c97a1acc4f67a2add919e2dbf8a7f35d1a107a Mon Sep 17 00:00:00 2001
 From: Matt Taylor <mstaveleytaylor@gmail.com>
 Date: Fri, 17 Jun 2022 15:28:34 +0100
 Subject: [PATCH] abi-bits: add domainname to utsname
@@ -10,8 +10,9 @@ Subject: [PATCH] abi-bits: add domainname to utsname
  options/glibc/generic/execinfo.cpp    |   6 +-
  options/rtdl/generic/linker.cpp       |   2 +-
  sysdeps/aero/generic/aero.cpp         |  10 ++-
- sysdeps/aero/include/aero/syscall.h   |   1 +
- 7 files changed, 104 insertions(+), 17 deletions(-)
+ sysdeps/aero/generic/filesystem.cpp   |  19 ++++-
+ sysdeps/aero/include/aero/syscall.h   |   2 +
+ 8 files changed, 122 insertions(+), 19 deletions(-)
 
 diff --git a/ABI_BREAKS.md b/ABI_BREAKS.md
 index 0cd3993b..d2a0bb7d 100644
@@ -204,15 +205,49 @@ index 43ddb906..f4fe182f 100644
  int sys_seteuid(uid_t euid) UNIMPLEMENTED("sys_seteuid")
 
  gid_t sys_getgid() {
+diff --git a/sysdeps/aero/generic/filesystem.cpp b/sysdeps/aero/generic/filesystem.cpp
+index a3e2aca2..a56438f0 100644
+--- a/sysdeps/aero/generic/filesystem.cpp
++++ b/sysdeps/aero/generic/filesystem.cpp
+@@ -158,11 +158,26 @@ int sys_tcsetattr(int fd, int optional_action, const struct termios *attr) {
+     return 0;
+ }
+ 
+-int sys_poll(struct pollfd *fds, nfds_t count, int timeout, int *num_events) {
+-    mlibc::infoLogger() << "sys_poll() is not implemented" << frg::endlog;
++int sys_ppoll(struct pollfd *fds, int nfds, const struct timespec *timeout,
++		const sigset_t *sigmask, int *num_events) {
++    auto result = syscall(SYS_POLL, fds, nfds, timeout, sigmask);
++
++    if (result < 0) {
++        return -result;
++    }
++
++    *num_events = result;
+     return 0;
+ }
+ 
++int sys_poll(struct pollfd *fds, nfds_t count, int timeout, int *num_events) {
++    struct timespec ts;
++	ts.tv_sec = timeout / 1000;
++	ts.tv_nsec = (timeout % 1000) * 1000000;
++
++    return sys_ppoll(fds, count, &ts, NULL, num_events);
++}
++
+ int sys_mkdir(const char *path, mode_t) {
+     auto result = syscall(SYS_MKDIR, path, strlen(path));
+ 
 diff --git a/sysdeps/aero/include/aero/syscall.h b/sysdeps/aero/include/aero/syscall.h
-index 12f8dc61..cf57bd3d 100644
+index 12f8dc61..fcc219a9 100644
 --- a/sysdeps/aero/include/aero/syscall.h
 +++ b/sysdeps/aero/include/aero/syscall.h
-@@ -64,6 +64,7 @@
+@@ -64,6 +64,8 @@
  #define SYS_FUTEX_WAIT 57
  #define SYS_FUTEX_WAKE 58
  #define SYS_LINK 59
 +#define SYS_BACKTRACE 60
++#define SYS_POLL 61
 
  // Invalid syscall used to trigger a log error in the kernel (as a hint)
  // so, that we can implement the syscall in the kernel.

src/aero_kernel/src/drivers/tty.rs

@@ -17,14 +17,13 @@
  * 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::{self, PollTable};
+use crate::fs::inode::{self, PollFlags, PollTable};
 use crate::rendy;
 
 use crate::fs::inode::INodeInterface;
@@ -258,12 +257,12 @@ impl INodeInterface for Tty {
         Ok(buffer.len())
     }
 
-    fn poll(&self, table: Option<&mut PollTable>) -> fs::Result<EPollEventFlags> {
+    fn poll(&self, table: Option<&mut PollTable>) -> fs::Result<PollFlags> {
         table.map(|e| e.insert(&self.block_queue));
-        let mut events = EPollEventFlags::default();
+        let mut events = PollFlags::empty();
 
         if self.stdin.lock_irq().is_complete() {
-            events.insert(EPollEventFlags::IN);
+            events.insert(PollFlags::IN);
         }
 
         Ok(events)

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, PollTable};
+use super::inode::{INodeInterface, PollFlags, PollTable};
 use super::ramfs::RamFs;
 use super::FileSystemError;
 use super::{FileSystem, Result, MOUNT_MANAGER};
@@ -129,7 +129,7 @@ impl INodeInterface for DevINode {
         self.0.inode().ioctl(command, arg)
     }
 
-    fn poll(&self, table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
+    fn poll(&self, table: Option<&mut PollTable>) -> Result<PollFlags> {
         self.0.inode().poll(table)
     }
 }

src/aero_kernel/src/fs/epoll.rs

@@ -17,7 +17,7 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
-use aero_syscall::prelude::EPollEvent;
+use aero_syscall::prelude::{EPollEvent, EPollEventFlags};
 use aero_syscall::SyscallError;
 
 use alloc::sync::Arc;
@@ -134,7 +134,7 @@ impl EPoll {
                 .ok_or(FileSystemError::NotSupported)?; // EINVAL
 
             let flags = epoll_event.events;
-            let ready = fd.inode().poll(None)?;
+            let ready: EPollEventFlags = fd.inode().poll(None)?.into();
 
             if ready.contains(flags) {
                 // The registered event is ready; increment the number of ready events
@@ -161,7 +161,7 @@ impl EPoll {
             scheduler::get_scheduler().inner.await_io()?;
 
             for fd in fds.iter() {
-                let ready = fd.inode().poll(None)?;
+                let ready: EPollEventFlags = fd.inode().poll(None)?.into();
                 let flags = table
                     .get(&fd.fd)
                     .ok_or(FileSystemError::NotSupported)?
@@ -170,6 +170,7 @@ impl EPoll {
                 if ready.contains(flags) {
                     // The event is ready; break out of the search loop and set ready
                     // events to 1.
+                    ret_events[0].events = ready & flags;
                     n = 1;
                     break 'search;
                 }

src/aero_kernel/src/fs/eventfd.rs

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

src/aero_kernel/src/fs/inode.rs

@@ -19,7 +19,7 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use aero_syscall::prelude::EPollEventFlags;
+use aero_syscall::prelude::{EPollEventFlags, PollEventFlags};
 use aero_syscall::{MMapFlags, OpenFlags};
 
 use alloc::string::String;
@@ -66,6 +66,53 @@ impl Drop for PollTable {
     }
 }
 
+bitflags::bitflags! {
+    pub struct PollFlags: usize {
+        /// The associated file is available for read operations.
+        const IN   = 1 << 1;
+        /// The associated file is available for write operations.
+        const OUT = 1 << 2;
+        /// Error condition happened on the associated file descriptor.
+        const ERR = 1 << 3;
+    }
+}
+
+impl From<PollFlags> for EPollEventFlags {
+    fn from(poll: PollFlags) -> Self {
+        let mut flags = Self::empty();
+
+        if poll.contains(PollFlags::IN) {
+            flags |= Self::IN;
+        }
+        if poll.contains(PollFlags::OUT) {
+            flags |= Self::OUT;
+        }
+        if poll.contains(PollFlags::ERR) {
+            flags |= Self::ERR;
+        }
+
+        flags
+    }
+}
+
+impl From<PollFlags> for PollEventFlags {
+    fn from(poll: PollFlags) -> Self {
+        let mut flags = Self::empty();
+
+        if poll.contains(PollFlags::IN) {
+            flags |= Self::IN;
+        }
+        if poll.contains(PollFlags::OUT) {
+            flags |= Self::OUT;
+        }
+        if poll.contains(PollFlags::ERR) {
+            flags |= Self::ERR;
+        }
+
+        flags
+    }
+}
+
 /// 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,
@@ -185,7 +232,7 @@ pub trait INodeInterface: Send + Sync {
         Err(FileSystemError::NotSocket)
     }
 
-    fn poll(&self, _table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
+    fn poll(&self, _table: Option<&mut PollTable>) -> Result<PollFlags> {
         Err(FileSystemError::NotSupported)
     }
 

src/aero_kernel/src/fs/ramfs.rs

@@ -23,7 +23,6 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use aero_syscall::prelude::EPollEventFlags;
 use aero_syscall::MMapFlags;
 use alloc::collections::BTreeMap;
 use alloc::string::{String, ToString};
@@ -38,7 +37,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, PollTable};
+use super::inode::{DirEntry, FileType, INodeInterface, PollFlags, PollTable};
 use super::inode::{FileContents, Metadata};
 use super::{FileSystem, FileSystemError, Result};
 
@@ -393,7 +392,7 @@ impl INodeInterface for LockedRamINode {
         }
     }
 
-    fn poll(&self, table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
+    fn poll(&self, table: Option<&mut PollTable>) -> Result<PollFlags> {
         let this = self.0.read();
 
         match &this.contents {

src/aero_kernel/src/socket/unix.rs

@@ -19,14 +19,13 @@
 
 use aero_syscall::SocketAddrUnix;
 
-use aero_syscall::prelude::EPollEventFlags;
 use alloc::string::String;
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 use spin::RwLock;
 
 use crate::fs;
-use crate::fs::inode::{DirEntry, FileType, INodeInterface, Metadata, PollTable};
+use crate::fs::inode::{DirEntry, FileType, INodeInterface, Metadata, PollFlags, PollTable};
 use crate::fs::{FileSystemError, Path, Result};
 use crate::utils::sync::BlockQueue;
 
@@ -65,7 +64,7 @@ impl UnixSocketBacklog {
     }
 
     pub fn len(&self) -> usize {
-        self.backlog.as_ref().map(|e| e.len()).unwrap()
+        self.backlog.as_ref().map(|e| e.len()).unwrap_or_default()
     }
 
     pub fn update_capacity(&mut self, capacity: usize) {
@@ -164,13 +163,13 @@ impl INodeInterface for UnixSocket {
         Ok(())
     }
 
-    fn poll(&self, table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
+    fn poll(&self, table: Option<&mut PollTable>) -> Result<PollFlags> {
         table.map(|e| e.insert(&self.wq));
 
-        let mut events = EPollEventFlags::default();
+        let mut events = PollFlags::empty();
 
         if self.inner.read().backlog.len() > 0 {
-            events.insert(EPollEventFlags::OUT);
+            events.insert(PollFlags::OUT);
         }
 
         Ok(events)