sigprocmask: handle if set is none

* handle the case if `set` is None!

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

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From dc0eb6086c635232cf3fee338dbbaa8915938e4e Mon Sep 17 00:00:00 2001
+From 4642a80de4f0c967d553e020347cf042d367c381 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,9 +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/generic/signals.cpp    |  8 +++++--
  sysdeps/aero/include/aero/syscall.h |  6 +++++
- 4 files changed, 52 insertions(+), 9 deletions(-)
+ 4 files changed, 46 insertions(+), 9 deletions(-)
 
 diff --git a/.gitignore b/.gitignore
 index dbb35e8b..384b3395 100644
@@ -91,22 +91,16 @@ index 6a13f19c..69833ae5 100644
  }
 
 diff --git a/sysdeps/aero/generic/signals.cpp b/sysdeps/aero/generic/signals.cpp
-index 3527370c..67f23202 100644
+index 3527370c..a6f69fff 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,
+@@ -42,8 +42,12 @@ 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);
++    auto result = syscall(SYS_SIGPROCMASK, how, set, retrieve);
 +
 +    if (result < 0) {
 +        return -result;

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

@@ -79,7 +79,7 @@ pub fn interrupt_check_signals(stack: &mut InterruptStack) {
             let old_mask = signals.blocked_mask();
 
             let signal_frame = SignalFrame::from_interrupt(stack, old_mask);
-            signals.set_mask(SigProcMask::Block, 1u64 << signal, None);
+            signals.set_mask(SigProcMask::Block, Some(1u64 << signal), None);
 
             // We cannot straight away update the stack pointer from the stack
             // helper, since it will created a reference to a packed field which
@@ -124,7 +124,7 @@ pub fn syscall_check_signals(syscall_result: isize, stack: &mut InterruptStack)
 
             let signal_frame =
                 SignalFrame::from_syscall(restart_syscall, syscall_result as _, stack, old_mask);
-            signals.set_mask(SigProcMask::Block, 1u64 << signal, None);
+            signals.set_mask(SigProcMask::Block, Some(1u64 << signal), None);
 
             // We cannot straight away update the stack pointer from the stack
             // helper, since it will created a reference to a packed field which
@@ -160,7 +160,7 @@ pub fn sigreturn(stack: &mut InterruptStack) -> usize {
 
     current_task.signals().set_mask(
         aero_syscall::signal::SigProcMask::Set,
-        signal_frame.sigmask,
+        Some(signal_frame.sigmask),
         None,
     );
 

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

@@ -103,7 +103,7 @@ impl VirtAddr {
     ///    .read_mut::<SomeStruct>();
     ///    .ok_or(AeroSyscallError::EFAULT)?;
     /// ```
-    pub fn read_mut<'struc, T>(&self) -> Option<&'struc mut T> {
+    pub fn read_mut<'struc, T: Sized>(&self) -> Option<&'struc mut T> {
         if self.validate_read::<T>() {
             Some(unsafe { &mut *(self.as_mut_ptr() as *mut T) })
         } else {
@@ -113,8 +113,7 @@ impl VirtAddr {
 
     /// 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()
+        (*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
@@ -127,7 +126,7 @@ impl VirtAddr {
     ///    .ok_or(AeroSyscallError::EFAULT)?;
     /// ```
     pub fn copied_read<T: Copy + Sized>(&self) -> Option<T> {
-        self.read_mut().map(|t| *t)
+        self.read_mut::<T>().map(|t| *t)
     }
 
     /// Aligns the virtual address downwards to the given alignment.

src/aero_kernel/src/syscall/process.rs

@@ -243,9 +243,15 @@ 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 set = if set > 0 {
+        Some(
+            VirtAddr::new(set as _)
+                .copied_read::<u64>()
+                .ok_or(AeroSyscallError::EFAULT)?,
+        )
+    } else {
+        None
+    };
 
     let old_set = if old_set > 0 {
         Some(

src/aero_kernel/src/userland/signals.rs

@@ -390,24 +390,35 @@ impl Signals {
         );
     }
 
-    pub fn set_mask(&self, how: SigProcMask, set: u64, old_set: Option<&mut u64>) {
+    /// Used to update or read the signal mask of a task.
+    ///
+    /// ## Notes
+    /// * If `old_set` is not `None`, the previous value of the signal mask is
+    /// stored in oldset.
+    ///
+    /// * NOTE: If `set` is `None`, then the signal mask is unchanged (i.e., `how` is
+    /// ignored), but the current value of the signal mask is returned in `old_set`
+    /// (if it is not `None`).
+    pub fn set_mask(&self, how: SigProcMask, set: Option<u64>, old_set: Option<&mut u64>) {
         if let Some(old) = old_set {
             *old = self.blocked_mask.load(Ordering::SeqCst);
         }
 
-        let set = set & !IMMUTABLE_MASK;
+        if let Some(set) = set {
+            let set = set & !IMMUTABLE_MASK;
 
-        match how {
-            SigProcMask::Block => {
-                self.blocked_mask.fetch_or(set, Ordering::SeqCst);
-            }
+            match how {
+                SigProcMask::Block => {
+                    self.blocked_mask.fetch_or(set, Ordering::SeqCst);
+                }
 
-            SigProcMask::Unblock => {
-                self.blocked_mask.fetch_and(!set, Ordering::SeqCst);
-            }
+                SigProcMask::Unblock => {
+                    self.blocked_mask.fetch_and(!set, Ordering::SeqCst);
+                }
 
-            SigProcMask::Set => {
-                self.blocked_mask.store(set, Ordering::SeqCst);
+                SigProcMask::Set => {
+                    self.blocked_mask.store(set, Ordering::SeqCst);
+                }
             }
         }
     }