rt_sigprocmask syscall implementation

kernel/process/process.rs

@@ -15,13 +15,13 @@ use crate::{
         elf::{Elf, ProgramHeader},
         init_stack::{estimate_user_init_stack_size, init_user_stack, Auxv},
         process_group::{PgId, ProcessGroup},
-        signal::{SigAction, Signal, SignalDelivery, SIGCHLD, SIGKILL},
+        signal::{SigAction, Signal, SignalDelivery, SignalMask, SIGCHLD, SIGKILL},
         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,32 @@ impl Process {
         self.signals.lock().is_pending()
     }
 
+    /// Sets signal mask.
+    pub fn set_signal_mask(
+        &self,
+        how: SignalMask,
+        set: Option<UserVAddr>,
+        oldset: Option<UserVAddr>,
+        _length: usize,
+    ) -> Result<()> {
+        let mut sigset = self.sigset.lock();
+
+        if let Some(old) = oldset {
+            old.write_bytes(sigset.as_slice())?;
+        }
+
+        if let Some(new) = set {
+            let new_set = new.read::<[u8; 128]>()?;
+            match how {
+                SignalMask::Block => sigset.assign_or(new_set),
+                SignalMask::Unblock => sigset.assign_and_not(new_set),
+                SignalMask::Set => sigset.assign(new_set),
+            }
+        }
+
+        Ok(())
+    }
+
     /// Tries to delivering a pending signal to the current process.
     ///
     /// If there's a pending signal, it may modify `frame` (e.g. user return
@@ -359,17 +390,20 @@ impl Process {
         // TODO: sigmask
         let current = current_process();
         if let Some((signal, sigaction)) = current.signals.lock().pop_pending() {
-            match sigaction {
-                SigAction::Ignore => {}
-                SigAction::Terminate => {
-                    trace!("terminating {:?} by {:?}", current.pid, signal,);
-                    Process::exit(1 /* FIXME: */);
-                }
-                SigAction::Handler { handler } => {
-                    trace!("delivering {:?} to {:?}", signal, current.pid,);
-                    current.signaled_frame.store(Some(*frame));
-                    unsafe {
-                        current.arch.setup_signal_stack(frame, signal, handler)?;
+            let sigset = current.sigset.lock();
+            if !sigset.get(signal as usize).unwrap_or(true) {
+                match sigaction {
+                    SigAction::Ignore => {}
+                    SigAction::Terminate => {
+                        trace!("terminating {:?} by {:?}", current.pid, signal,);
+                        Process::exit(1 /* FIXME: */);
+                    }
+                    SigAction::Handler { handler } => {
+                        trace!("delivering {:?} to {:?}", signal, current.pid,);
+                        current.signaled_frame.store(Some(*frame));
+                        unsafe {
+                            current.arch.setup_signal_stack(frame, signal, handler)?;
+                        }
                     }
                 }
             }
@@ -433,6 +467,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 +482,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,10 @@ impl SignalDelivery {
         self.pending |= 1 << (signal);
     }
 }
+
+pub type SigSet = BitMap<128 /* 1024 / 8 */>;
+pub enum SignalMask {
+    Block,
+    Unblock,
+    Set,
+}

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,29 @@
+use crate::prelude::*;
+use crate::process::current_process;
+
+use crate::process::signal::SignalMask;
+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> {
+        let how = match how {
+            0 => SignalMask::Block,
+            1 => SignalMask::Unblock,
+            2 => SignalMask::Set,
+            _ => return Err(Errno::EINVAL.into()),
+        };
+
+        if let Err(_) = current_process().set_signal_mask(how, set, oldset, length) {
+            return Err(Errno::EFAULT.into());
+        }
+
+        Ok(0)
+    }
+}

libs/kerla_utils/bitmap.rs

@@ -1,5 +1,6 @@
 use core::slice::memchr::memchr;
 
+#[derive(Clone)]
 pub struct BitMap<const SZ: usize>([u8; SZ]);
 
 impl<const SZ: usize> BitMap<SZ> {
@@ -12,7 +13,6 @@ impl<const SZ: usize> BitMap<SZ> {
         BitMap(array)
     }
 
-    #[cfg(test)]
     pub fn as_slice(&self) -> &[u8] {
         &self.0
     }
@@ -51,6 +51,24 @@ impl<const SZ: usize> BitMap<SZ> {
 
         None
     }
+
+    pub fn assign(&mut self, rhs: [u8; SZ]) {
+        self.0 = rhs;
+    }
+
+    /// This method will panic if SZ != rhs.len()
+    pub fn assign_or(&mut self, rhs: [u8; SZ]) {
+        for (i, byte) in self.0.iter_mut().enumerate() {
+            *byte |= rhs[i];
+        }
+    }
+
+    /// This method will panic if SZ != rhs.len()
+    pub fn assign_and_not(&mut self, rhs: [u8; SZ]) {
+        for (i, byte) in self.0.iter_mut().enumerate() {
+            *byte &= !rhs[i];
+        }
+    }
 }
 
 #[cfg(all(test, not(feature = "no_std")))]
@@ -71,4 +89,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_and_not([0b0110_0100, 0b1010_0110]);
+        assert_eq!(bitmap.as_slice(), &[0b0000_0010, 0b0000_0001]);
+    }
 }