intro crate signal and signal-impl; add getpid()

Author: scPointer

Cargo.lock

@@ -17,6 +17,8 @@ members = [
     "kernel-vm",
     "utils",
     "easy-fs",
+    "signal",
+    "signal-impl",
 ]
 default-members = ["xtask"]
 

Cargo.toml

@@ -20,6 +20,8 @@ kernel-vm = { path = "../kernel-vm" }
 syscall = { path = "../syscall", features = ["kernel"] }
 task-manage = { path = "../task-manage" }
 easy-fs = { path = "../easy-fs" }
+signal = { path = "../signal" }
+signal-impl = { path = "../signal-impl" }
 
 [build-dependencies]
 linker = { path = "../linker" }

ch7/Cargo.toml

@@ -521,6 +521,11 @@ mod impls {
                 }
             }
         }
+
+        fn getpid(&self, _caller: Caller) -> isize {
+            let current = unsafe { PROCESSOR.current().unwrap() };
+            current.pid.get_val() as _
+        }
     }
 
     impl Scheduling for SyscallContext {

ch7/src/main.rs

@@ -95,6 +95,12 @@ impl LocalContext {
         self.sepc
     }
 
+    /// 修改上下文的 pc。
+    #[inline]
+    pub fn pc_mut(&mut self) -> &mut usize {
+        &mut self.sepc
+    }
+
     /// 将 pc 移至下一条指令。
     ///
     /// # Notice

kernel-context/src/lib.rs

@@ -0,0 +1,9 @@
+[package]
+name = "signal-impl"
+version = "0.1.0"
+edition = "2021"
+authors = ["scPointer <[email protected]>"]
+
+[dependencies]
+kernel-context = { path = "../kernel-context" }
+signal = { path = "../signal" }

signal-impl/Cargo.toml

@@ -0,0 +1,26 @@
+use super::{SignalNo, SignalResult};
+
+/// 没有处理函数时的默认行为。
+/// 参见 `https://venam.nixers.net/blog/unix/2016/10/21/unix-signals.html`
+pub enum DefaultAction {
+    Terminate(i32), // 结束进程。其实更标准的实现应该细分为 terminate / terminate(core dump) / stop
+    Ignore,    // 忽略信号
+}
+
+impl From<SignalNo> for DefaultAction {
+    fn from(signal_no: SignalNo) -> Self {
+        match signal_no {
+            SignalNo::SIGCHLD | SignalNo::SIGURG => Self::Ignore,
+            _ => Self::Terminate(-(signal_no as i32)),
+        }
+    }
+}
+
+impl Into<SignalResult> for DefaultAction {
+    fn into(self) -> SignalResult {
+        match self {
+            Self::Terminate(exit_code) => SignalResult::ProcessKilled(exit_code),
+            Self::Ignore => SignalResult::Ignored,
+        }
+    }
+}

signal-impl/src/default_action.rs

@@ -0,0 +1,181 @@
+//! 一种信号模块的实现
+
+#![no_std]
+
+extern crate alloc;
+use alloc::boxed::Box;
+use signal::{Signal, SignalResult, SignalAction, SignalNo, MAX_SIG};
+use kernel_context::LocalContext;
+
+mod default_action;
+use default_action::DefaultAction;
+mod signal_set;
+use signal_set::SignalSet;
+
+/// 正在处理的信号
+pub enum HandlingSignal {
+    Frozen, // 是内核信号，需要暂停当前进程
+    UserSignal(LocalContext), // 是用户信号，需要保存之前的用户栈
+}
+
+/// 管理一个进程中的信号
+pub struct SignalImpl {
+    /// 已收到的信号
+    pub received: SignalSet,
+    /// 屏蔽的信号掩码
+    pub mask: SignalSet,
+    /// 在信号处理函数中，保存之前的用户栈
+    pub handling: Option<HandlingSignal>,
+    /// 当前任务的信号处理函数集
+    pub actions: [Option<SignalAction>; MAX_SIG + 1],  
+}
+
+impl SignalImpl {
+    pub fn new() -> Self {
+        Self {
+            received: SignalSet::empty(),
+            mask: SignalSet::empty(),
+            handling: None,
+            actions: [None; MAX_SIG + 1],
+        }
+    }
+}
+
+impl SignalImpl {
+    /// 获取一个没有被 mask 屏蔽的信号，并从已收到的信号集合中删除它。如果没有这样的信号，则返回空
+    fn fetch_signal(&mut self) -> Option<SignalNo> {
+        // 在已收到的信号中，寻找一个没有被 mask 屏蔽的信号
+        self.received.find_first_one(self.mask).map(|num| {
+            self.received.remove_bit(num);
+            num.into()
+        })
+    }
+    
+    /// 检查是否收到一个信号，如果是，则接收并删除它
+    fn fetch_and_remove(&mut self, signal_no: SignalNo) -> bool {
+        if self.received.contain_bit(signal_no as usize)
+            && !self.mask.contain_bit(signal_no as usize) {
+            self.received.remove_bit(signal_no as usize);
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl Signal for SignalImpl {
+    fn from_fork(&mut self) -> Box<dyn Signal> {
+        Box::new(Self {
+            received: SignalSet::empty(),
+            mask: self.mask,
+            handling: None,
+            actions: {
+                let mut actions = [None; MAX_SIG + 1];
+                actions.copy_from_slice(&self.actions);
+                actions
+            },
+            
+        })
+    }
+    
+    fn clear(&mut self) {
+        for action in &mut self.actions {
+            action.take();
+        }
+    }
+
+    /// 添加一个信号
+    fn add_signal(&mut self, signal: SignalNo) {
+        self.received.add_bit(signal as usize)
+    }
+
+    /// 是否当前正在处理信号
+    fn is_handling_signal(&self) -> bool {
+        self.handling.is_some()
+    }
+    
+    /// 设置一个信号处理函数。`sys_sigaction` 会使用
+    fn set_action(&mut self, signum: SignalNo, action: &SignalAction) -> bool {
+        if signum == SignalNo::SIGKILL || signum == SignalNo::SIGSTOP {
+            false
+        } else {
+            self.actions[signum as usize] = Some(*action);
+            true
+        }
+    }
+
+    /// 获取一个信号处理函数的值。`sys_sigaction` 会使用
+    fn get_action_ref(&self, signum: SignalNo) -> Option<SignalAction> {
+        if signum == SignalNo::SIGKILL || signum == SignalNo::SIGSTOP {
+            None
+        } else {
+            Some(self.actions[signum as usize].unwrap_or(SignalAction::default()))
+        }
+    }
+
+    /// 设置信号掩码，并获取旧的信号掩码，`sys_procmask` 会使用
+    fn update_mask(&mut self, mask: usize) -> usize {
+        self.mask.set_new(mask.into())
+    }
+
+    fn handle_signals(&mut self, current_context: &mut LocalContext) -> SignalResult {
+        if self.is_handling_signal() {
+            match self.handling.as_ref().unwrap() {
+                // 如果当前正在暂停状态
+                HandlingSignal::Frozen => {
+                    // 则检查是否收到 SIGCONT，如果收到则当前任务需要从暂停状态中恢复
+                    if self.fetch_and_remove(SignalNo::SIGCONT) {
+                        self.handling.take();
+                        SignalResult::Handled
+                    } else { // 否则，继续暂停
+                        SignalResult::ProcessSuspended
+                    }
+                }, // 其他情况下，需要等待当前信号处理结束
+                _ => SignalResult::IsHandlingSignal,
+            }
+        } else if let Some(signal) = self.fetch_signal() {
+            match signal {
+                // SIGKILL 信号不能被捕获或忽略
+                SignalNo::SIGKILL => SignalResult::ProcessKilled(-(signal as i32)),
+                SignalNo::SIGSTOP => {
+                    self.handling = Some(HandlingSignal::Frozen);
+                    SignalResult::ProcessSuspended
+                },
+                _ => {
+                    if let Some(action) = self.actions[signal as usize] {
+                        // 如果用户给定了处理方式，则按照 SignalAction 中的描述处理
+                        // 保存原来用户程序的上下文信息
+                        self.handling = Some(HandlingSignal::UserSignal(current_context.clone()));
+                        // 修改返回后的 pc 值为 handler，修改 a0 为信号编号
+                        //println!("handle pre {:x}, after {:x}", current_context.pc(), action.handler);
+                        *current_context.pc_mut() = action.handler;
+                        *current_context.a_mut(0) = signal as usize;
+                        SignalResult::Handled
+                    } else {
+                        // 否则，使用自定义的 DefaultAction 类来处理
+                        // 然后再转换成 SignalResult
+                        DefaultAction::from(signal).into()
+                    }
+                },
+            }
+        } else {
+            SignalResult::NoSignal
+        }
+    }
+
+    fn sig_return(&mut self, current_context: &mut LocalContext) -> bool {
+        let handling_signal = self.handling.take();
+        match handling_signal {
+            Some(HandlingSignal::UserSignal(old_ctx)) => {
+                //println!("return to {:x} a0 {}", old_ctx.pc(), old_ctx.a(0));
+                *current_context = old_ctx;
+                true
+            },
+            // 如果当前在处理内核信号，或者没有在处理信号，也就谈不上“返回”了
+            _ => {
+                self.handling = handling_signal;
+                false
+            },
+        }
+    }
+}

signal-impl/src/lib.rs

@@ -0,0 +1,70 @@
+//! 字符数组。可取并集和差集，也可对给定的 mask 取首位
+//!
+
+#[derive(Clone, Copy, Debug)]
+/// bit数组
+pub struct SignalSet(pub usize);
+
+impl SignalSet {
+    /// 新建一个空的数组
+    pub fn empty() -> Self {
+        Self(0)
+    }
+    /// 新建一个数组，长为 usize = 8Byte
+    pub fn new(v: usize) -> Self {
+        Self(v)
+    }
+    /// 直接暴力写入 SignalSet
+    pub fn reset(&mut self, v: usize) {
+        self.0 = v;
+    }
+    /// 清空 SignalSet
+    pub fn clear(&mut self) {
+        self.0 = 0;
+    }
+    /// 是否包含第 k 个 bit
+    pub fn contain_bit(&self, kth: usize) -> bool {
+        ((self.0 >> kth) & 1) > 0
+    }
+    /// 新增一个 bit
+    pub fn add_bit(&mut self, kth: usize) {
+        self.0 |= 1 << kth;
+    }
+    /// 删除一个 bit
+    pub fn remove_bit(&mut self, kth: usize) {
+        self.0 &= !(1 << kth);
+    }
+    /// 取交集
+    pub fn get_union(&mut self, set: SignalSet) {
+        self.0 |= set.0;
+    }
+    /// 取差集，即去掉 set 中的内容
+    pub fn get_difference(&mut self, set: SignalSet) {
+        self.0 &= !(set.0);
+    }
+    /// 直接设置为新值
+    pub fn set_new(&mut self, set: SignalSet) -> usize {
+        let old = self.0;
+        self.0 = set.0;
+        old
+    }
+    /// 获取后缀0个数，可以用来寻找最小的1
+    pub fn get_trailing_zeros(&self) -> u32 {
+        self.0.trailing_zeros()
+    }
+    /// 寻找不在mask中的最小的 1 的位置，如果有，返回其位置，如没有则返回 None。
+    pub fn find_first_one(&self, mask: SignalSet) -> Option<usize> {
+        let ans = (self.0 & !mask.0).trailing_zeros() as usize;
+        if ans == 64 {
+            None
+        } else {
+            Some(ans)
+        }
+    }
+}
+
+impl From<usize> for SignalSet {
+    fn from(v: usize) -> Self {
+        Self(v)
+    }
+}

signal-impl/src/signal_set.rs

@@ -0,0 +1,9 @@
+[package]
+name = "signal"
+version = "0.1.0"
+edition = "2021"
+authors = ["scPointer <[email protected]>"]
+
+[dependencies]
+kernel-context = { path = "../kernel-context" }
+numeric-enum-macro = "0.2.0"