kernel: Implement a syscall proc macro

This patch introduces a procedural macro that takes care of validating
input buffers and paths automagically for us :^) There is still a bit
of clean up/bug fixing to do, but for the most part it does what it's
supposed to be doing.

Author: 48cf

src/Cargo.lock

@@ -44,8 +44,11 @@ features = ["no_std"]
 version = "1.4.0"
 features = ["spin_no_std"]
 
+[dependencies.aero_proc]
+path = "../aero_proc"
+
 [dependencies.aero_syscall]
-path = "../aero_syscall/"
+path = "../aero_syscall"
 
 [dependencies.cpio_reader]
 git = "https://github.com/czapek1337/cpio_reader"

src/aero_kernel/Cargo.toml

@@ -18,18 +18,17 @@
  */
 
 use aero_syscall::prelude::FdFlags;
-use aero_syscall::{AeroSyscallError, OpenFlags};
+use aero_syscall::{AeroSyscallError, OpenFlags, Stat};
 
 use crate::fs::inode::DirEntry;
 use crate::fs::pipe::Pipe;
 use crate::fs::{self, lookup_path, LookupMode};
-use crate::mem::paging::VirtAddr;
 use crate::userland::scheduler;
 
 use crate::fs::Path;
-use crate::utils::{validate_slice, validate_slice_mut, validate_str};
 
-pub fn write(fd: usize, buffer: usize, size: usize) -> Result<usize, AeroSyscallError> {
+#[aero_proc::syscall]
+pub fn write(fd: usize, buffer: &[u8]) -> Result<usize, AeroSyscallError> {
     let handle = scheduler::get_scheduler()
         .current_task()
         .file_table
@@ -40,14 +39,14 @@ pub fn write(fd: usize, buffer: usize, size: usize) -> Result<usize, AeroSyscall
         .flags
         .intersects(OpenFlags::O_WRONLY | OpenFlags::O_RDWR)
     {
-        let buffer = validate_slice(buffer as *const u8, size).ok_or(AeroSyscallError::EINVAL)?;
         Ok(handle.write(buffer)?)
     } else {
         Err(AeroSyscallError::EACCES)
     }
 }
 
-pub fn read(fd: usize, buffer: usize, size: usize) -> Result<usize, AeroSyscallError> {
+#[aero_proc::syscall]
+pub fn read(fd: usize, buffer: &mut [u8]) -> Result<usize, AeroSyscallError> {
     let handle = scheduler::get_scheduler()
         .current_task()
         .file_table
@@ -58,23 +57,20 @@ pub fn read(fd: usize, buffer: usize, size: usize) -> Result<usize, AeroSyscallE
         .flags
         .intersects(OpenFlags::O_RDONLY | OpenFlags::O_RDWR)
     {
-        let buffer = validate_slice_mut(buffer as *mut u8, size).ok_or(AeroSyscallError::EINVAL)?;
         Ok(handle.read(buffer)?)
     } else {
         Err(AeroSyscallError::EACCES)
     }
 }
 
-pub fn open(_fd: usize, path: usize, len: usize, mode: usize) -> Result<usize, AeroSyscallError> {
+#[aero_proc::syscall]
+pub fn open(_fd: usize, path: &Path, mode: usize) -> Result<usize, AeroSyscallError> {
     let mut flags = OpenFlags::from_bits(mode).ok_or(AeroSyscallError::EINVAL)?;
 
     if !flags.intersects(OpenFlags::O_RDONLY | OpenFlags::O_RDWR | OpenFlags::O_WRONLY) {
         flags.insert(OpenFlags::O_RDONLY);
     }
 
-    let path = validate_str(path as *const u8, len).ok_or(AeroSyscallError::EINVAL)?;
-    let path = Path::new(path);
-
     let mut lookup_mode = LookupMode::None;
 
     if flags.contains(OpenFlags::O_CREAT) {
@@ -97,31 +93,34 @@ pub fn open(_fd: usize, path: usize, len: usize, mode: usize) -> Result<usize, A
         .open_file(inode, flags)?)
 }
 
+#[aero_proc::syscall]
 pub fn dup(fd: usize, flags: usize) -> Result<usize, AeroSyscallError> {
     let task = scheduler::get_scheduler().current_task();
     let flags = OpenFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)? & OpenFlags::O_CLOEXEC;
 
     task.file_table.duplicate(fd, flags)
 }
 
+#[aero_proc::syscall]
 pub fn dup2(fd: usize, new_fd: usize, flags: usize) -> Result<usize, AeroSyscallError> {
     let task = scheduler::get_scheduler().current_task();
     let flags = OpenFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)? & OpenFlags::O_CLOEXEC;
 
     task.file_table.duplicate_at(fd, new_fd, flags)
 }
 
-pub fn getdents(fd: usize, buffer: usize, size: usize) -> Result<usize, AeroSyscallError> {
+#[aero_proc::syscall]
+pub fn getdents(fd: usize, buffer: &mut [u8]) -> Result<usize, AeroSyscallError> {
     let handle = scheduler::get_scheduler()
         .current_task()
         .file_table
         .get_handle(fd)
         .ok_or(AeroSyscallError::EBADFD)?;
 
-    let buffer = validate_slice_mut(buffer as *mut u8, size).ok_or(AeroSyscallError::EINVAL)?;
     Ok(handle.get_dents(buffer)?)
 }
 
+#[aero_proc::syscall]
 pub fn close(fd: usize) -> Result<usize, AeroSyscallError> {
     let res = scheduler::get_scheduler()
         .current_task()
@@ -136,9 +135,9 @@ pub fn close(fd: usize) -> Result<usize, AeroSyscallError> {
     }
 }
 
-pub fn chdir(path: usize, size: usize) -> Result<usize, AeroSyscallError> {
-    let buffer = validate_str(path as *mut u8, size).ok_or(AeroSyscallError::EINVAL)?;
-    let inode = fs::lookup_path(Path::new(buffer))?;
+#[aero_proc::syscall]
+pub fn chdir(path: &str) -> Result<usize, AeroSyscallError> {
+    let inode = fs::lookup_path(Path::new(path))?;
 
     if !inode.inode().metadata()?.is_directory() {
         // A component of path is not a directory.
@@ -149,10 +148,8 @@ pub fn chdir(path: usize, size: usize) -> Result<usize, AeroSyscallError> {
     Ok(0x00)
 }
 
-pub fn mkdirat(dfd: usize, path: usize, size: usize) -> Result<usize, AeroSyscallError> {
-    let path_str = validate_str(path as *mut u8, size).ok_or(AeroSyscallError::EINVAL)?;
-    let path = Path::new(path_str);
-
+#[aero_proc::syscall]
+pub fn mkdirat(dfd: usize, path: &Path) -> Result<usize, AeroSyscallError> {
     // NOTE: If the pathname given in pathname is relative, then it is interpreted
     // relative to the directory referred to by the file descriptor (rather than relative
     // to the current working directory of the calling task, as is done by mkdir() for a
@@ -183,7 +180,7 @@ pub fn mkdirat(dfd: usize, path: usize, size: usize) -> Result<usize, AeroSyscal
         return Err(AeroSyscallError::ENOTDIR);
     }
 
-    if ["", ".", ".."].contains(&path_str) {
+    if ["", ".", ".."].contains(&path.as_str()) {
         // Cannot create a directory with a name of "", ".", or "..".
         return Err(AeroSyscallError::EEXIST);
     }
@@ -192,14 +189,9 @@ pub fn mkdirat(dfd: usize, path: usize, size: usize) -> Result<usize, AeroSyscal
     Ok(0x00)
 }
 
-#[inline]
-pub fn mkdir(path: usize, size: usize) -> Result<usize, AeroSyscallError> {
-    mkdirat(aero_syscall::AT_FDCWD as _, path, size)
-}
-
-pub fn rmdir(path: usize, size: usize) -> Result<usize, AeroSyscallError> {
-    let path_str = validate_str(path as *mut u8, size).ok_or(AeroSyscallError::EINVAL)?;
-    let path = Path::new(path_str);
+#[aero_proc::syscall]
+pub fn rmdir(path: &str) -> Result<usize, AeroSyscallError> {
+    let path = Path::new(path);
 
     let (_, child) = path.parent_and_basename();
     let inode = fs::lookup_path(path)?;
@@ -215,20 +207,15 @@ pub fn rmdir(path: usize, size: usize) -> Result<usize, AeroSyscallError> {
     Ok(0x00)
 }
 
-pub fn getcwd(buffer: usize, size: usize) -> Result<usize, AeroSyscallError> {
-    // Invalid value of the size argument is zero and buffer is not a
-    // null pointer.
-    if size == 0x00 && buffer != 0x00 {
-        return Err(AeroSyscallError::EINVAL);
-    }
-
-    let buffer = validate_slice_mut(buffer as *mut u8, size).ok_or(AeroSyscallError::EINVAL)?;
+#[aero_proc::syscall]
+pub fn getcwd(buffer: &mut [u8]) -> Result<usize, AeroSyscallError> {
     let cwd = scheduler::get_scheduler().current_task().get_cwd();
 
     buffer[..cwd.len()].copy_from_slice(cwd.as_bytes());
     Ok(cwd.len())
 }
 
+#[aero_proc::syscall]
 pub fn ioctl(fd: usize, command: usize, argument: usize) -> Result<usize, AeroSyscallError> {
     let handle = scheduler::get_scheduler()
         .current_task()
@@ -239,6 +226,7 @@ pub fn ioctl(fd: usize, command: usize, argument: usize) -> Result<usize, AeroSy
     Ok(handle.inode().ioctl(command, argument)?)
 }
 
+#[aero_proc::syscall]
 pub fn seek(fd: usize, offset: usize, whence: usize) -> Result<usize, AeroSyscallError> {
     let handle = scheduler::get_scheduler()
         .current_task()
@@ -249,10 +237,11 @@ pub fn seek(fd: usize, offset: usize, whence: usize) -> Result<usize, AeroSyscal
     Ok(handle.seek(offset as isize, aero_syscall::SeekWhence::from(whence))?)
 }
 
-pub fn pipe(fds: usize, flags: usize) -> Result<usize, AeroSyscallError> {
-    let flags = OpenFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)?;
-    let fds = validate_slice_mut(fds as *mut usize, 2).ok_or(AeroSyscallError::EINVAL)?;
+#[aero_proc::syscall]
+pub fn pipe(fds: &mut [usize], flags: usize) -> Result<usize, AeroSyscallError> {
+    assert!(fds.len() == 2);
 
+    let flags = OpenFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)?;
     let pipe = Pipe::new();
 
     let entry = DirEntry::from_inode(pipe);
@@ -282,15 +271,8 @@ pub fn pipe(fds: usize, flags: usize) -> Result<usize, AeroSyscallError> {
     Ok(0x00)
 }
 
-pub fn unlink(
-    fd: usize,
-    path: usize,
-    path_size: usize,
-    flags: usize,
-) -> Result<usize, AeroSyscallError> {
-    let path_str = validate_str(path as *mut u8, path_size).ok_or(AeroSyscallError::EINVAL)?;
-    let path = Path::new(path_str);
-
+#[aero_proc::syscall]
+pub fn unlink(fd: usize, path: &Path, flags: usize) -> Result<usize, AeroSyscallError> {
     // TODO: Make use of the open flags.
     let _flags = OpenFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)?;
     let name = path.container();
@@ -313,16 +295,13 @@ pub fn unlink(
     Ok(0x00)
 }
 
+#[aero_proc::syscall]
 pub fn access(
     fd: usize,
-    path: usize,
-    path_size: usize,
+    path: &Path,
     _mode: usize,
     _flags: usize,
 ) -> Result<usize, AeroSyscallError> {
-    let path_str = validate_str(path as *mut u8, path_size).ok_or(AeroSyscallError::EINVAL)?;
-    let path = Path::new(path_str);
-
     if fd as isize == aero_syscall::AT_FDCWD {
         lookup_path(path)?;
         Ok(0x00)
@@ -332,6 +311,7 @@ pub fn access(
     }
 }
 
+#[aero_proc::syscall]
 pub fn fcntl(fd: usize, command: usize, arg: usize) -> Result<usize, AeroSyscallError> {
     let handle = scheduler::get_scheduler()
         .current_task()
@@ -364,50 +344,31 @@ pub fn fcntl(fd: usize, command: usize, arg: usize) -> Result<usize, AeroSyscall
     }
 }
 
-/// Validates the [`aero_syscall::Stat`] struct provided by the user and returns a mutable
-/// reference to it. [`AeroSyscallError::EFAULT`] is returned if the provided pointer is outside
-/// of the user's address space.
-fn validate_stat_struct<'struc>(
-    stat_struct: usize,
-) -> Result<&'struc mut aero_syscall::Stat, AeroSyscallError> {
-    VirtAddr::new(stat_struct as _)
-        .read_mut::<aero_syscall::Stat>()
-        .ok_or(AeroSyscallError::EFAULT)
-}
-
-pub fn fstat(fd: usize, stat_struct: usize) -> Result<usize, AeroSyscallError> {
-    let stat_struct = validate_stat_struct(stat_struct)?;
-    let handle = scheduler::get_scheduler()
+#[aero_proc::syscall]
+pub fn fstat(fd: usize, stat: &mut Stat) -> Result<usize, AeroSyscallError> {
+    let file = scheduler::get_scheduler()
         .current_task()
         .file_table
         .get_handle(fd)
         .ok_or(AeroSyscallError::EBADFD)?;
 
-    *stat_struct = handle.inode().stat()?;
+    *stat = file.inode().stat()?;
+
     Ok(0)
 }
 
-pub fn stat(path: usize, path_size: usize, stat_struct: usize) -> Result<usize, AeroSyscallError> {
-    let stat_struct = validate_stat_struct(stat_struct)?;
-
-    let path = validate_str(path as *mut u8, path_size).ok_or(AeroSyscallError::EINVAL)?;
-    let path = Path::new(path);
-
+#[aero_proc::syscall]
+pub fn stat(path: &Path, stat: &mut Stat) -> Result<usize, AeroSyscallError> {
     let file = fs::lookup_path(path)?;
-    *stat_struct = file.inode().stat()?;
+
+    *stat = file.inode().stat()?;
 
     Ok(0)
 }
 
-pub fn read_link(
-    path: usize,
-    path_size: usize,
-    _buffer: usize,
-    _buffer_size: usize,
-) -> Result<usize, AeroSyscallError> {
-    let path = validate_str(path as *mut u8, path_size).ok_or(AeroSyscallError::EINVAL)?;
-    let path = Path::new(path);
-
+#[aero_proc::syscall]
+pub fn read_link(path: &Path, _buffer: &mut [u8]) -> Result<usize, AeroSyscallError> {
     log::warn!("read_link: is a stub! (path={path:?})");
+
     Err(AeroSyscallError::EINVAL)
 }