sys_sigprocmask: initial implementation

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

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From c7e816f64f5dc357cfd6399413ac38098de6234a Mon Sep 17 00:00:00 2001
+From dc0eb6086c635232cf3fee338dbbaa8915938e4e Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <[email protected]>
 Date: Thu, 10 Feb 2022 19:12:25 +1100
 Subject: [PATCH] yes
@@ -7,8 +7,9 @@ Signed-off-by: Andy-Python-Programmer <[email protected]>
 ---
  .gitignore                          |  7 ++++++
  sysdeps/aero/generic/filesystem.cpp | 34 +++++++++++++++++++++++------
+ sysdeps/aero/generic/signals.cpp    | 14 ++++++++++--
  sysdeps/aero/include/aero/syscall.h |  6 +++++
- 3 files changed, 40 insertions(+), 7 deletions(-)
+ 4 files changed, 52 insertions(+), 9 deletions(-)
 
 diff --git a/.gitignore b/.gitignore
 index dbb35e8b..384b3395 100644
@@ -89,6 +90,32 @@ index 6a13f19c..69833ae5 100644
      return 0;
  }
 
+diff --git a/sysdeps/aero/generic/signals.cpp b/sysdeps/aero/generic/signals.cpp
+index 3527370c..67f23202 100644
+--- a/sysdeps/aero/generic/signals.cpp
++++ b/sysdeps/aero/generic/signals.cpp
+@@ -42,8 +42,18 @@ int sys_sigaction(int how, const struct sigaction *__restrict action,
+ 
+ int sys_sigprocmask(int how, const sigset_t *__restrict set,
+                     sigset_t *__restrict retrieve) {
+-    mlibc::infoLogger() << "sys_sigprocmask() is not implemented"
+-                        << frg::endlog;
++	auto old_set = 0;
++
++    if (retrieve) {
++        old_set = reinterpret_cast<sc_word_t>(retrieve);
++    }
++
++    auto result = syscall(SYS_SIGPROCMASK, how, set, old_set);
++
++    if (result < 0) {
++        return -result;
++    }
++
+     return 0;
+ }
+ } // namespace mlibc
+\ No newline at end of file
 diff --git a/sysdeps/aero/include/aero/syscall.h b/sysdeps/aero/include/aero/syscall.h
 index 07b1b51b..f6d7836d 100644
 --- a/sysdeps/aero/include/aero/syscall.h

src/aero_kernel/src/arch/x86_64/signals.rs

@@ -92,7 +92,6 @@ pub fn interrupt_check_signals(stack: &mut InterruptStack) {
     }
 }
 
-/// Helper function to check for any pending signals from a sycall.
 pub fn syscall_check_signals(_syscall_result: isize, _stack: &mut InterruptStack) {
     if let Some((_signal, entry)) = userland::signals::check_for_signals() {
         if let aero_syscall::signal::SignalHandler::Handle(_) = entry.handler() {

src/aero_kernel/src/mem/paging/addr.rs

@@ -94,37 +94,40 @@ impl VirtAddr {
         self.as_ptr::<T>() as *mut T
     }
 
-    /// If the virtual address is a valid userland address, the [`Some`] varient is returned
-    /// contaning the address, else the [`None`] variant is returned.
+    /// Validate reads `sizeof(T)` bytes from the virtual address and returns a mutable
+    /// reference to the value (`&mut T`).
     ///
     /// ## Example
     /// ```no_run
-    /// let address: VirtAddr = VirtAddr::new(stat)
-    ///     .validate_user()
-    ///     .ok_or(AeroSyscallError::EFAULT)?;
+    /// let address: &mut SomeStruct = VirtAddr::new(0xcafebabe)
+    ///    .read_mut::<SomeStruct>();
+    ///    .ok_or(AeroSyscallError::EFAULT)?;
     /// ```
-    pub fn validate_user(self) -> Option<Self> {
-        if self <= crate::arch::task::userland_last_address() {
-            Some(self)
+    pub fn read_mut<'struc, T>(&self) -> Option<&'struc mut T> {
+        if self.validate_read::<T>() {
+            Some(unsafe { &mut *(self.as_mut_ptr() as *mut T) })
         } else {
             None
         }
     }
 
-    /// Reads `sizeof(T)` bytes from the virtual address and returns a mutable reference
-    /// to the value (`&mut T`).
+    /// Returns if the address is valid to read `sizeof(T)` bytes at the address.
+    fn validate_read<T: Sized>(&self) -> bool {
+        *self < crate::arch::task::userland_last_address()
+            && (*self + core::mem::size_of::<T>()) <= crate::arch::task::userland_last_address()
+    }
+
+    /// Validate reads `sizeof(T)` bytes from the virtual address and returns a copy
+    /// of the value (`T`).
     ///
     /// ## Example
     /// ```no_run
-    /// let address: SomeStruct = VirtAddr::new(0xcafebabe)
-    ///     .read_mut::<SomeStruct>();
+    /// let value: u64 = VirtAddr::new(0xcafebabe)
+    ///    .copied_read::<u64>()
+    ///    .ok_or(AeroSyscallError::EFAULT)?;
     /// ```
-    ///
-    /// ## Safety
-    /// * The virtual address must be valid.
-    /// * It must be safe to read `sizeof(T)` bytes from the virtual address.
-    pub unsafe fn read_mut<'struc, T>(&self) -> &'struc mut T {
-        &mut *(self.as_mut_ptr() as *mut T)
+    pub fn copied_read<T: Copy + Sized>(&self) -> Option<T> {
+        self.read_mut().map(|t| *t)
     }
 
     /// Aligns the virtual address downwards to the given alignment.

src/aero_kernel/src/syscall/fs.rs

@@ -370,12 +370,9 @@ pub fn fcntl(fd: usize, command: usize, arg: usize) -> Result<usize, AeroSyscall
 fn validate_stat_struct<'struc>(
     stat_struct: usize,
 ) -> Result<&'struc mut aero_syscall::Stat, AeroSyscallError> {
-    let stat_struct = VirtAddr::new(stat_struct as _)
-        .validate_user()
-        .ok_or(AeroSyscallError::EFAULT)?;
-
-    // SAFETY: The user provided address is validated above.
-    Ok(unsafe { stat_struct.read_mut::<aero_syscall::Stat>() })
+    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> {

src/aero_kernel/src/syscall/mod.rs

@@ -166,6 +166,7 @@ pub fn generic_do_syscall(
         SYS_SETHOSTNAME => process::sethostname(b, c),
         SYS_INFO => process::info(b),
         SYS_SIGACTION => process::sigaction(b, c, d, e),
+        SYS_SIGPROCMASK => process::sigprocmask(b, c, d),
         SYS_CLONE => process::clone(b, c),
 
         SYS_READ => fs::read(b, c, d),

src/aero_kernel/src/syscall/process.rs

@@ -17,7 +17,7 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
-use aero_syscall::signal::SigAction;
+use aero_syscall::signal::{SigAction, SigProcMask};
 use aero_syscall::{AeroSyscallError, MMapFlags, MMapProt};
 use alloc::string::String;
 use spin::{Mutex, Once};
@@ -242,6 +242,31 @@ pub fn sethostname(ptr: usize, length: usize) -> Result<usize, AeroSyscallError>
     }
 }
 
+pub fn sigprocmask(how: usize, set: usize, old_set: usize) -> Result<usize, AeroSyscallError> {
+    let set = VirtAddr::new(set as _)
+        .copied_read::<u64>()
+        .ok_or(AeroSyscallError::EFAULT)?;
+
+    let old_set = if old_set > 0 {
+        Some(
+            VirtAddr::new(old_set as _)
+                .read_mut::<u64>()
+                .ok_or(AeroSyscallError::EFAULT)?,
+        )
+    } else {
+        None
+    };
+
+    let how = SigProcMask::from(how as u64);
+
+    scheduler::get_scheduler()
+        .current_task()
+        .signals()
+        .set_mask(how, set, old_set);
+
+    Ok(0)
+}
+
 pub fn sigaction(
     sig: usize,
     sigact: usize,