syscalls: implement sys_link and epoll_ctl_del

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

Author: Andy-Python-Programmer

aero.py

@@ -397,6 +397,8 @@ def generate_docs(args):
 
 
 def prepare_iso(args, kernel_bin, user_bins):
+    log_info("preparing ISO")
+
     if not os.path.exists(BUILD_DIR):
         os.makedirs(BUILD_DIR)
 

patches/mlibc/mlibc.patch

@@ -1,13 +1,14 @@
-From b4160476f4d1f02e0ea4550b66c9f9b478ab55fa Mon Sep 17 00:00:00 2001
+From 10e4288b75bcaa72e84cabe7af331cb95cbb1c86 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
 
 ---
- ABI_BREAKS.md                      | 1 +
- abis/linux/utsname.h               | 1 +
- options/glibc/generic/execinfo.cpp | 6 ++++--
- 3 files changed, 6 insertions(+), 2 deletions(-)
+ ABI_BREAKS.md                         |   1 +
+ abis/linux/utsname.h                  |   1 +
+ options/ansi/generic/stdlib-stubs.cpp | 100 ++++++++++++++++++++++----
+ options/glibc/generic/execinfo.cpp    |   6 +-
+ 4 files changed, 94 insertions(+), 14 deletions(-)
 
 diff --git a/ABI_BREAKS.md b/ABI_BREAKS.md
 index 0cd3993b..d2a0bb7d 100644
@@ -30,6 +31,117 @@ index 2cd22265..9875a46e 100644
  };
 
  #endif // _ABIBITS_UTSNAME_T_H
+diff --git a/options/ansi/generic/stdlib-stubs.cpp b/options/ansi/generic/stdlib-stubs.cpp
+index 375d4d72..2b4934d9 100644
+--- a/options/ansi/generic/stdlib-stubs.cpp
++++ b/options/ansi/generic/stdlib-stubs.cpp
+@@ -374,18 +374,94 @@ int mblen(const char *mbs, size_t mb_limit) {
+ 	return nseq.it - mbs;
+ }
+ 
+-int mbtowc(wchar_t *__restrict wc, const char *__restrict mbs, size_t max_size) {
+-	mlibc::infoLogger() << "mlibc: Broken mbtowc() called" << frg::endlog;
+-	__ensure(max_size);
+-
+-	if(wc && mbs){
+-		if(*mbs){
+-			*wc = *mbs;
+-		} else {
+-			return 0; // When mbs is a null byte, return 0
+-		}
+-	}
+-	return 1;
++// Upper 6 state bits are a negative integer offset to bound-check next byte
++//    equivalent to: ( (b-0x80) | (b+offset) ) & ~0x3f
++#define OOB(c, b) (((((b) >> 3) - 0x10) | (((b) >> 3) + ((int32_t)(c) >> 26))) & ~7)
++
++// Interval [a,b). Either a must be 80 or b must be c0, lower 3 bits clear.
++#define R(a, b) ((uint32_t)((a == 0x80 ? 0x40u - b : 0u - a) << 23))
++#define FAILSTATE R(0x80, 0x80)
++
++#define SA 0xc2u
++#define SB 0xf4u
++
++// Arbitrary encoding for representing code units instead of characters.
++#define CODEUNIT(c) (0xdfff & (signed char)(c))
++#define IS_CODEUNIT(c) ((unsigned)(c)-0xdf80 < 0x80)
++
++#define C(x) ( x<2 ? -1 : ( R(0x80,0xc0) | x ) )
++#define D(x) C((x+16))
++#define E(x) ( ( x==0 ? R(0xa0,0xc0) : \
++                 x==0xd ? R(0x80,0xa0) : \
++                 R(0x80,0xc0) ) \
++             | ( R(0x80,0xc0) >> 6 ) \
++             | x )
++#define F(x) ( ( x>=5 ? 0 : \
++                 x==0 ? R(0x90,0xc0) : \
++                 x==4 ? R(0x80,0xa0) : \
++                 R(0x80,0xc0) ) \
++             | ( R(0x80,0xc0) >> 6 ) \
++             | ( R(0x80,0xc0) >> 12 ) \
++             | x )
++
++const uint32_t bittab[] = {
++	C(0x2),C(0x3),C(0x4),C(0x5),C(0x6),C(0x7),
++	C(0x8),C(0x9),C(0xa),C(0xb),C(0xc),C(0xd),C(0xe),C(0xf),
++	D(0x0),D(0x1),D(0x2),D(0x3),D(0x4),D(0x5),D(0x6),D(0x7),
++	D(0x8),D(0x9),D(0xa),D(0xb),D(0xc),D(0xd),D(0xe),D(0xf),
++	E(0x0),E(0x1),E(0x2),E(0x3),E(0x4),E(0x5),E(0x6),E(0x7),
++	E(0x8),E(0x9),E(0xa),E(0xb),E(0xc),E(0xd),E(0xe),E(0xf),
++	F(0x0),F(0x1),F(0x2),F(0x3),F(0x4)
++};
++
++// Converts a multibyte sequence to a wide character.
++//
++// Credits - MUSL
++int mbtowc(wchar_t *__restrict wc, const char *__restrict src, size_t n) {
++	unsigned c;
++	const unsigned char *s = static_cast<const unsigned char *>((const void *)src);
++	wchar_t dummy;
++
++  	if (!s) return 0;
++  	if (!n) goto ilseq;
++  	if (!wc) wc = &dummy;
++
++  	if (*s < 0x80) return !!(*wc = *s);
++	if (MB_CUR_MAX == 1) return (*wc = CODEUNIT(*s)), 1;
++  	if (*s - SA > SB - SA) goto ilseq;
++  	
++	c = bittab[*s++ - SA];
++
++  	// Avoid excessive checks against n: If shifting the state n-1
++	// times does not clear the high bit, then the value of n is
++	// insufficient to read a character.
++  	if (n < 4 && ((c << (6 * n - 6)) & (1U << 31))) goto ilseq;
++  	if (OOB(c, *s)) goto ilseq;
++  	
++	c = c << 6 | (*s++ - 0x80);
++  	
++	if (!(c & (1U << 31))) {
++    	*wc = c;
++    	return 2;
++  	}
++
++  	if (*s - 0x80u >= 0x40) goto ilseq;
++  	
++	c = c << 6 | (*s++ - 0x80);
++  	
++	if (!(c & (1U << 31))) {
++    	*wc = c;
++    	return 3;
++  	}
++
++  	if (*s - 0x80u >= 0x40) goto ilseq;
++	
++	*wc = c << 6 | (*s++ - 0x80);
++	return 4;
++
++ilseq:
++	errno = EILSEQ;
++	return -1;
+ }
+ 
+ int wctomb(char *, wchar_t) {
 diff --git a/options/glibc/generic/execinfo.cpp b/options/glibc/generic/execinfo.cpp
 index 3474615e..c0081e30 100644
 --- a/options/glibc/generic/execinfo.cpp

src/aero_kernel/src/fs/epoll.rs

@@ -40,7 +40,7 @@ impl EPoll {
         })
     }
 
-    /// Adds an event to the epoll instance.
+    /// Adds an event to the interest list.
     ///
     /// ## Errors
     /// * `EEXIST`: The event already exists at `fd`.
@@ -55,7 +55,22 @@ impl EPoll {
         Ok(())
     }
 
-    /// Change the settings associated with file derscriptor in the interest list to the
+    /// Removes an event from the interest list.
+    ///
+    /// ## Errors
+    /// * `ENOENT`: The event does not exist at `fd`.
+    pub fn remove_event(&self, fd: usize) -> Result<(), SyscallError> {
+        let mut events = self.events.lock_irq();
+
+        if events.get(&fd).is_none() {
+            return Err(SyscallError::ENOENT);
+        }
+
+        events.remove(&fd);
+        Ok(())
+    }
+
+    /// Change the settings associated with file descriptor in the interest list to the
     /// new settings specified in event.
     ///
     /// ## Errors

src/aero_kernel/src/fs/inode.rs

@@ -188,6 +188,10 @@ pub trait INodeInterface: Send + Sync {
     fn poll(&self, _table: Option<&mut PollTable>) -> Result<EPollEventFlags> {
         Err(FileSystemError::NotSupported)
     }
+
+    fn link(&self, _name: &str, _src: INodeCacheItem) -> Result<()> {
+        Err(FileSystemError::NotSupported)
+    }
 }
 
 /// Structure representing the curcial, characteristics of an inode. The metadata

src/aero_kernel/src/fs/mod.rs

@@ -129,6 +129,7 @@ pub enum FileSystemError {
     Busy,
     NotDirectory,
     IsPipe,
+    IsDir,
     Interrupted,
     TooSmall,
     InvalidPath,
@@ -150,6 +151,7 @@ impl From<FileSystemError> for SyscallError {
             FileSystemError::InvalidPath => Self::EINVAL,
             FileSystemError::NotSocket => Self::ENOTSOCK,
             FileSystemError::ConnectionRefused => Self::ECONNREFUSED,
+            FileSystemError::IsDir => Self::EISDIR,
         }
     }
 }
@@ -219,7 +221,7 @@ pub fn lookup_path_with(
     mode: LookupMode,
 ) -> Result<DirCacheItem> {
     // Iterate and resolve each component. For example `a`, `b`, and `c` in `a/b/c`.
-    for component in path.components() {
+    for (i, component) in path.components().enumerate() {
         match component {
             // Handle some special cases that might occur in a relative path.
             "." => continue,
@@ -250,7 +252,14 @@ pub fn lookup_path_with(
                             if err == FileSystemError::EntryNotFound
                                 && mode == LookupMode::Create =>
                         {
-                            cwd = cwd.inode().touch(cwd.clone(), component)?;
+                            if i == path.components().count() - 1 {
+                                cwd = cwd.inode().touch(cwd.clone(), component)?;
+                            } else {
+                                // todo: fix this shit
+                                cwd.inode().mkdir(component)?;
+                                cwd =
+                                    lookup_path_with(cwd, Path::new(component), LookupMode::None)?;
+                            }
                         }
 
                         Err(err) => return Err(err),

src/aero_kernel/src/fs/ramfs.rs

@@ -26,7 +26,7 @@ use core::sync::atomic::{AtomicUsize, Ordering};
 use aero_syscall::prelude::EPollEventFlags;
 use aero_syscall::MMapFlags;
 use alloc::collections::BTreeMap;
-use alloc::string::String;
+use alloc::string::{String, ToString};
 use alloc::sync::{Arc, Weak};
 
 use alloc::vec::Vec;
@@ -412,6 +412,34 @@ impl INodeInterface for LockedRamINode {
     fn weak_filesystem(&self) -> Option<Weak<dyn FileSystem>> {
         Some(self.0.read().filesystem.clone())
     }
+
+    fn link(&self, name: &str, src: INodeCacheItem) -> Result<()> {
+        // ensure: The dest inode (self) is a directory.
+        if self.metadata()?.file_type() != FileType::Directory {
+            return Err(FileSystemError::NotDirectory);
+        }
+
+        // ensure: The src inode is not a directory.
+        if src.metadata()?.file_type() == FileType::Directory {
+            return Err(FileSystemError::IsDir);
+        }
+
+        // ensure: The dest directory does not already contain a
+        // file with the same name.
+        {
+            let this = self.0.read();
+
+            if this.children.iter().find(|(e, _)| e == &name).is_some() {
+                return Err(FileSystemError::EntryExists);
+            }
+        }
+
+        let mut this = self.0.write();
+
+        // Create the link!
+        this.children.insert(name.to_string(), src.clone());
+        Ok(())
+    }
 }
 
 /// Implementation of in-memory filesystem. (See the module-level documentation for more

src/aero_kernel/src/syscall/fs.rs

@@ -436,6 +436,11 @@ pub fn epoll_ctl(
             Ok(0)
         }
 
+        EPOLL_CTL_DEL => {
+            epoll.remove_event(fd)?;
+            Ok(0)
+        }
+
         EPOLL_CTL_MOD => {
             epoll.update_event(fd, event.clone())?;
             Ok(0)
@@ -494,8 +499,25 @@ pub fn event_fd(_initval: usize, flags: usize) -> Result<usize, SyscallError> {
         .open_file(entry, OpenFlags::O_RDWR)?)
 }
 
+/// Creates a new link (also known as a hard link) to an existing
+/// file.
 #[syscall]
 pub fn link(src_path: &Path, dest_path: &Path) -> Result<usize, SyscallError> {
-    log::warn!("sys_link: is a stub! (src_path={src_path:?}, dest_path={dest_path:?})");
+    let src = fs::lookup_path(src_path)?.inode();
+    let (dest_dir, dest_name) = dest_path.parent_and_basename();
+
+    let dest_dir = fs::lookup_path(dest_dir)?.inode();
+
+    // Cannot create a hardlink to a file on a different filesystem.
+    //
+    // SAFTEY: The pointers to the file system are valid since we know that there are
+    // strong references to it.
+    //
+    // TODO: Should this be moved to the inode impl?
+    if dest_dir.weak_filesystem().unwrap().as_ptr() != src.weak_filesystem().unwrap().as_ptr() {
+        return Err(SyscallError::EINVAL);
+    }
+
+    dest_dir.link(dest_name, src)?;
     Ok(0)
 }