rt_sigprocmask syscall implementation

kernel/process/process.rs

@@ -19,9 +19,9 @@ use crate::{
         switch, UserVAddr, JOIN_WAIT_QUEUE, SCHEDULER,
     },
     random::read_secure_random,
+    result::Errno,
     INITIAL_ROOT_FS,
 };
-
 use alloc::collections::BTreeMap;
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
@@ -36,7 +36,9 @@ use kerla_runtime::{
     page_allocator::{alloc_pages, AllocPageFlags},
     spinlock::{SpinLock, SpinLockGuard},
 };
-use kerla_utils::alignment::align_up;
+use kerla_utils::{alignment::align_up, bitmap::BitMap};
+
+use super::signal::SigSet;
 
 type ProcessTable = BTreeMap<PId, Arc<Process>>;
 
@@ -104,6 +106,7 @@ pub struct Process {
     root_fs: Arc<SpinLock<RootFs>>,
     signals: SpinLock<SignalDelivery>,
     signaled_frame: AtomicCell<Option<PtRegs>>,
+    sigset: SpinLock<SigSet>,
 }
 
 impl Process {
@@ -126,6 +129,7 @@ impl Process {
             opened_files: SpinLock::new(OpenedFileTable::new()),
             signals: SpinLock::new(SignalDelivery::new()),
             signaled_frame: AtomicCell::new(None),
+            sigset: SpinLock::new(BitMap::zeroed()),
         });
 
         process_group.lock().add(Arc::downgrade(&proc));
@@ -187,6 +191,7 @@ impl Process {
             root_fs,
             signals: SpinLock::new(SignalDelivery::new()),
             signaled_frame: AtomicCell::new(None),
+            sigset: SpinLock::new(BitMap::zeroed()),
         });
 
         process_group.lock().add(Arc::downgrade(&process));
@@ -351,6 +356,38 @@ impl Process {
         self.signals.lock().is_pending()
     }
 
+    /// Sets signal mask
+    pub fn rt_sigprocmask(
+        &self,
+        how: usize,
+        set: Option<UserVAddr>,
+        oldset: Option<UserVAddr>,
+        _length: usize,
+    ) -> Result<isize> {
+        let mut sigset = self.sigset.lock();
+
+        if let Some(old) = oldset {
+            if let Err(_) = old.write_bytes(sigset.as_slice()) {
+                return Err(Error::new(Errno::EFAULT));
+            }
+        }
+
+        if let Some(new) = set {
+            if let Ok(new_set) = new.read::<[u8; 128]>() {
+                match how {
+                    0 => sigset.assign_or(new_set),
+                    1 => sigset.assign_material_nonimplication(new_set),
+                    2 => sigset.assign(new_set),
+                    _ => return Err(Error::new(Errno::EINVAL)),
+                }
+            } else {
+                return Err(Error::new(Errno::EFAULT));
+            }
+        }
+
+        Ok(0)
+    }
+
     /// Tries to delivering a pending signal to the current process.
     ///
     /// If there's a pending signal, it may modify `frame` (e.g. user return
@@ -433,6 +470,7 @@ impl Process {
         let vm = parent.vm().as_ref().unwrap().lock().fork()?;
         let opened_files = parent.opened_files().lock().fork();
         let process_group = parent.process_group();
+        let sig_set = parent.sigset.lock();
 
         let child = Arc::new(Process {
             process_group: AtomicRefCell::new(Arc::downgrade(&process_group)),
@@ -447,6 +485,7 @@ impl Process {
             arch,
             signals: SpinLock::new(SignalDelivery::new()),
             signaled_frame: AtomicCell::new(None),
+            sigset: SpinLock::new(sig_set.clone()),
         });
 
         process_group.lock().add(Arc::downgrade(&child));

kernel/process/signal.rs

@@ -1,5 +1,6 @@
 use crate::{ctypes::c_int, prelude::*};
 use kerla_runtime::address::UserVAddr;
+use kerla_utils::bitmap::BitMap;
 
 pub type Signal = c_int;
 #[allow(unused)]
@@ -153,3 +154,5 @@ impl SignalDelivery {
         self.pending |= 1 << (signal);
     }
 }
+
+pub type SigSet = BitMap<128 /* 1024 / 8 */>;

kernel/syscalls/mod.rs

@@ -57,6 +57,7 @@ pub(self) mod readlink;
 pub(self) mod reboot;
 pub(self) mod recvfrom;
 pub(self) mod rt_sigaction;
+pub(self) mod rt_sigprocmask;
 pub(self) mod rt_sigreturn;
 pub(self) mod select;
 pub(self) mod sendto;
@@ -112,6 +113,7 @@ const SYS_POLL: usize = 7;
 const SYS_MMAP: usize = 9;
 const SYS_BRK: usize = 12;
 const SYS_RT_SIGACTION: usize = 13;
+const SYS_RT_SIGPROCMASK: usize = 14;
 const SYS_RT_SIGRETURN: usize = 15;
 const SYS_IOCTL: usize = 16;
 const SYS_WRITEV: usize = 20;
@@ -368,6 +370,9 @@ impl<'a> SyscallHandler<'a> {
             SYS_SYSLOG => self.sys_syslog(a1 as c_int, UserVAddr::new(a2), a3 as c_int),
             SYS_REBOOT => self.sys_reboot(a1 as c_int, a2 as c_int, a3),
             SYS_GETTID => self.sys_gettid(),
+            SYS_RT_SIGPROCMASK => {
+                self.sys_rt_sigprocmask(a1, UserVAddr::new(a2), UserVAddr::new(a3), a4)
+            }
             _ => {
                 debug_warn!(
                     "unimplemented system call: {} (n={})",

kernel/syscalls/rt_sigprocmask.rs

@@ -0,0 +1,17 @@
+use crate::prelude::*;
+use crate::process::current_process;
+
+use crate::syscalls::SyscallHandler;
+use kerla_runtime::address::UserVAddr;
+
+impl SyscallHandler<'_> {
+    pub fn sys_rt_sigprocmask(
+        &mut self,
+        how: usize,
+        set: Option<UserVAddr>,
+        oldset: Option<UserVAddr>,
+        length: usize,
+    ) -> Result<isize> {
+        current_process().rt_sigprocmask(how, set, oldset, length)
+    }
+}

libs/kerla_utils/bitmap.rs

@@ -12,7 +12,6 @@ impl<const SZ: usize> BitMap<SZ> {
         BitMap(array)
     }
 
-    #[cfg(test)]
     pub fn as_slice(&self) -> &[u8] {
         &self.0
     }
@@ -51,6 +50,30 @@ impl<const SZ: usize> BitMap<SZ> {
 
         None
     }
+
+    pub fn assign(&mut self, rhs: [u8; SZ]) {
+        self.0 = rhs;
+    }
+
+    pub fn assign_or(&mut self, rhs: [u8; SZ]) {
+        let mut iter = rhs.into_iter();
+        for byte in &mut self.0 {
+            *byte |= iter.next().unwrap_or(0);
+        }
+    }
+
+    pub fn assign_material_nonimplication(&mut self, rhs: [u8; SZ]) {
+        let mut iter = rhs.into_iter();
+        for byte in &mut self.0 {
+            *byte &= !iter.next().unwrap_or(0);
+        }
+    }
+}
+
+impl<const SZ: usize> Clone for BitMap<SZ> {
+    fn clone(&self) -> Self {
+        BitMap(self.0)
+    }
 }
 
 #[cfg(all(test, not(feature = "no_std")))]
@@ -71,4 +94,18 @@ mod tests {
         assert_eq!(bitmap.as_slice(), &[0b1111_1111, 0b1111_1001]);
         assert_eq!(bitmap.first_zero(), Some(9));
     }
+
+    #[test]
+    fn or() {
+        let mut bitmap = BitMap::from_array([0b0100_0010, 0b1000_0001]);
+        bitmap.assign_or([0b0010_0100, 0b1010_0110]);
+        assert_eq!(bitmap.as_slice(), &[0b0110_0110, 0b1010_0111]);
+    }
+
+    #[test]
+    fn material_nonimplication() {
+        let mut bitmap = BitMap::from_array([0b0100_0010, 0b1000_0001]);
+        bitmap.assign_material_nonimplication([0b0110_0100, 0b1010_0110]);
+        assert_eq!(bitmap.as_slice(), &[0b0000_0010, 0b0000_0001]);
+    }
 }