epoll_ctl: add add event

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

Author: Andy-Python-Programmer

base-files/server.exe

@@ -1,4 +1,4 @@
-From c11445241f6016b07ed89c0be2617488cfb79265 Mon Sep 17 00:00:00 2001
+From 1f388ec59a355c18a21aa23226159d90fcb35912 Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
 Date: Thu, 10 Feb 2022 19:12:25 +1100
 Subject: [PATCH] yes
@@ -8,10 +8,10 @@ Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
  .gitignore                          |  3 ++
  options/rtdl/generic/linker.cpp     |  2 +-
  sysdeps/aero/generic/aero.cpp       | 12 ++++-
- sysdeps/aero/generic/filesystem.cpp | 68 +++++++++++++++++++++++++----
- sysdeps/aero/generic/signals.cpp    |  8 +++-
+ sysdeps/aero/generic/filesystem.cpp | 79 ++++++++++++++++++++++++++---
+ sysdeps/aero/generic/signals.cpp    |  8 ++-
  sysdeps/aero/include/aero/syscall.h | 12 +++++
- 6 files changed, 92 insertions(+), 13 deletions(-)
+ 6 files changed, 103 insertions(+), 13 deletions(-)
 
 diff --git a/.gitignore b/.gitignore
 index dbb35e8b..20c8d4c3 100644
@@ -68,7 +68,7 @@ index 7de909f5..4281beb9 100644
  #endif
  } // namespace mlibc
 diff --git a/sysdeps/aero/generic/filesystem.cpp b/sysdeps/aero/generic/filesystem.cpp
-index 6a13f19c..8679b28a 100644
+index 6a13f19c..d34dfce3 100644
 --- a/sysdeps/aero/generic/filesystem.cpp
 +++ b/sysdeps/aero/generic/filesystem.cpp
 @@ -1,3 +1,4 @@
@@ -150,11 +150,12 @@ index 6a13f19c..8679b28a 100644
      return 0;
  }
 
-@@ -267,4 +297,26 @@ int sys_pipe(int *fds, int flags) {
+@@ -267,4 +297,37 @@ int sys_pipe(int *fds, int flags) {
 
      return 0;
  }
 +
++// epoll API syscalls:
 +int sys_epoll_create(int flags, int *fd) { 
 +    auto result = syscall(SYS_EPOLL_CREATE, flags);
 +
@@ -166,6 +167,16 @@ index 6a13f19c..8679b28a 100644
 +    return 0;
 +}
 +
++int sys_epoll_ctl(int epfd, int mode, int fd, struct epoll_event *ev) {
++    auto result = syscall(SYS_EPOLL_CTL, epfd, mode, fd, ev);
++
++    if (result < 0) {
++        return -result;
++    }
++
++    return 0;
++}
++
 +int sys_eventfd_create(unsigned int initval, int flags, int *fd) {
 +    auto result = syscall(SYS_EVENT_FD, initval, flags);
 +

patches/mlibc/mlibc.patch

@@ -17,16 +17,42 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
+use aero_syscall::{prelude::EPollEvent, AeroSyscallError};
 use alloc::sync::Arc;
+use hashbrown::HashMap;
+
+use crate::utils::sync::Mutex;
 
 use super::inode::INodeInterface;
 
-pub struct EPoll {}
+pub struct EPoll {
+    events: Mutex<HashMap<usize, EPollEvent>>,
+}
 
 impl EPoll {
     pub fn new() -> Arc<Self> {
-        Arc::new(Self {})
+        Arc::new(Self {
+            events: Mutex::new(HashMap::new()),
+        })
+    }
+
+    /// Adds an event to the epoll instance.
+    ///
+    /// ## Errors
+    /// * `EEXIST`: The event already exists at `fd`.
+    pub fn add_event(&self, fd: usize, event: EPollEvent) -> Result<(), AeroSyscallError> {
+        let mut events = self.events.lock_irq();
+
+        if events.get(&fd).is_some() {
+            return Err(AeroSyscallError::EEXIST);
+        }
+
+        events.insert(fd, event);
+        Ok(())
     }
 }
 
+unsafe impl Send for EPoll {}
+unsafe impl Sync for EPoll {}
+
 impl INodeInterface for EPoll {}

src/aero_kernel/src/fs/epoll.rs

@@ -23,12 +23,13 @@ use aero_syscall::{AeroSyscallError, OpenFlags, Stat};
 use crate::fs::epoll::EPoll;
 use crate::fs::eventfd::EventFd;
 use crate::fs::file_table::DuplicateHint;
-use crate::fs::inode::DirEntry;
+use crate::fs::inode::{DirEntry, INodeInterface};
 use crate::fs::pipe::Pipe;
 use crate::fs::{self, lookup_path, LookupMode};
 use crate::userland::scheduler;
 
 use crate::fs::Path;
+use crate::utils::downcast;
 
 #[aero_proc::syscall]
 pub fn write(fd: usize, buffer: &[u8]) -> Result<usize, AeroSyscallError> {
@@ -275,6 +276,8 @@ pub fn pipe(fds: &mut [usize; 2], flags: usize) -> Result<usize, AeroSyscallErro
 
 #[aero_proc::syscall]
 pub fn unlink(fd: usize, path: &Path, flags: usize) -> Result<usize, AeroSyscallError> {
+    log::debug!("{path:?}");
+
     // TODO: Make use of the open flags.
     let _flags = OpenFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)?;
     let name = path.container();
@@ -404,6 +407,35 @@ pub fn epoll_create(flags: usize) -> Result<usize, AeroSyscallError> {
         .open_file(entry, OpenFlags::O_RDWR)?)
 }
 
+/// Used to add, modify, or remove entries in the interest list of the
+/// epoll instance referred to by the file descriptor. It requests that
+/// the operation be performed for the target file descriptor.
+#[aero_proc::syscall]
+pub fn epoll_ctl(
+    epfd: usize,
+    mode: usize,
+    fd: usize,
+    event: &mut EPollEvent,
+) -> Result<usize, AeroSyscallError> {
+    let current_task = scheduler::get_scheduler().current_task();
+    let epfd = current_task
+        .file_table
+        .get_handle(epfd)
+        .ok_or(AeroSyscallError::EBADFD)?;
+
+    match mode {
+        EPOLL_CTL_ADD => {
+            let epoll = downcast::<dyn INodeInterface, EPoll>(&epfd.inode())
+                .ok_or(AeroSyscallError::EINVAL)?;
+
+            epoll.add_event(fd, event.clone())?;
+            Ok(0)
+        }
+
+        _ => unreachable!("epoll_ctl: unknown mode {mode}"),
+    }
+}
+
 #[aero_proc::syscall]
 pub fn event_fd(_initval: usize, flags: usize) -> Result<usize, AeroSyscallError> {
     let flags = EventFdFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)?;

src/aero_kernel/src/syscall/fs.rs

@@ -206,6 +206,7 @@ pub fn generic_do_syscall(
 
         // epoll calls:
         SYS_EPOLL_CREATE => fs::epoll_create(b),
+        SYS_EPOLL_CTL => fs::epoll_ctl(b, c, d, e),
 
         SYS_SOCKET => net::socket(b, c, d),
         SYS_BIND => net::bind(b, c, d),

src/aero_kernel/src/syscall/mod.rs

@@ -105,6 +105,27 @@ bitflags::bitflags! {
     }
 }
 
+pub const EPOLL_CTL_ADD: usize = 1;
+pub const EPOLL_CTL_DEL: usize = 2;
+pub const EPOLL_CTL_MOD: usize = 3;
+
+// structures and uninons for the epoll API:
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union EPollData {
+    pub ptr: *mut u8,
+    pub fd: i32,
+    pub u32: u32,
+    pub u64: u64,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct EPollEvent {
+    pub events: u32,
+    pub data: EPollData,
+}
+
 // constants for event fd:
 bitflags::bitflags! {
     // mlibc/options/linux/include/sys/eventfd.h

src/aero_syscall/src/consts.rs

@@ -203,7 +203,17 @@ fn repl(history: &mut Vec<String>) -> Result<(), AeroSyscallError> {
 
                     let argv = argv.as_slice();
 
-                    match sys_exec(cmd, argv, &["TERM=linux"]) {
+                    match sys_exec(
+                        cmd,
+                        argv,
+                        &[
+                            "TERM=linux",
+                            // The `XDG_RUNTIME_DIR` enviornment variable tells the tells any program you
+                            // run where to find a user-specific directory in which it can store small
+                            // temporary files.
+                            "XDG_RUNTIME_DIR=temp",
+                        ],
+                    ) {
                         Ok(_) => core::unreachable!(),
                         Err(AeroSyscallError::EISDIR) => error!("{}: is a directory", cmd),
                         Err(AeroSyscallError::ENOENT) => error!("{}: command not found", cmd),