feat(kernel/posix-timer): 实现 POSIX interval timer，修复 gVisor timers_test (#1501)

- 新增 timer_create/timer_settime/timer_gettime/timer_getoverrun/timer_delete 系统调用处理，并接入 syscall table
- 实现进程级 POSIX interval timer：基于 CLOCK_MONOTONIC 的创建/删除/设置/查询、周期性重装与到期调度
- 完整实现 SIGEV_NONE/SIGEV_SIGNAL/SIGEV_THREAD_ID（限制 THREAD_ID 只能指向当前线程）与 SI_TIMER siginfo（含 si_timerid/si_overrun/si_value）
- 修复 overrun 语义与信号合并：按线程 pending 队列合并并累积 overrun，避免重复入队导致进程被信号杀死
- 修复周期性 timer 的 gettime 剩余时间计算与回调窗口返回 0 的问题（PeriodicSilent）
- 修复定时器回调中信号锁/队列访问导致的自锁死（PeriodicGroupDirectedSignal）
- clear_child_tid/robust futex 相关用户内存访问改为异常表保护，并避免在失败时继续 futex 操作

Signed-off-by: longjin <[email protected]>

Author: fslongjin

AGENTS.md

@@ -0,0 +1,44 @@
+# README for AI Agents
+
+## 项目简介
+
+DragonOS是一个面向云计算轻量化场景的，完全自主内核的，提供Linux二进制兼容性的64位操作系统，旨在为容器化工作负载提供轻量级、高性能的解决方案。
+
+## 设计思想
+
+- Linux兼容性：系统调用接口/procfs/sysfs/devfs等的行为应当符合Linux语义。参考Linux 6.6的行为进行实现。
+- 轻量：简化复杂的抽象设计，保留合理的、简洁、符合Rust开发最佳实践的的抽象，提升系统性能。
+- 安全：注重内存安全、并发安全
+
+
+## 开发准则
+
+### 项目目录结构：
+
+- 文档：在`docs/`目录下
+- 内核：在`kernel/`目录下
+- 自行编写的单元测试程序：在`user/apps/c_unitest`目录下
+- gvisor系统调用测试程序：根据用户给出的程序代码片段来读取测试代码。如果用户没有提供，就尝试寻找，如果找不到，则从 https://cnb.cool/DragonOS-Community/gvisor/-/tree/dragonos/release-20250616.0/test/syscalls/linux 下面获取（下载文件然后再尝试读取）
+
+
+### 开发最佳实践
+
+- 三思而后行！深度研究，掌握解决问题所必要的信息，然后再动手开发/修复。
+- 设计要具有合理抽象，避免过度抽象。并且要注意代码复用。
+- 实现代码的时候，多问问自己：这代码写在这里合理吗？（架构、正确性等方面）
+- 高内聚、低耦合
+- 符合Linux语义
+- 不得使用workaround的方法绕过问题。要从本质解决问题！
+
+
+**测试修复相关**
+
+- 符合Linux 6.6的语义
+- 结合测例报错、测例代码、DragonOS代码、Linux行为实现来深入分析
+
+### 开发时的一些常见命令
+
+- 格式化代码：在项目根目录下运行`make fmt`,会自动格式化，并且运行clippy检查
+- 编译内核：在项目根目录下运行`make kernel`. 当你想检查你编辑的代码有没有语法错误的时候，请执行这个命令
+
+

kernel/src/arch/x86_64/mm/fault.rs

@@ -337,8 +337,8 @@ impl X86_64MMArch {
                 if vm_flags.contains(VmFlags::VM_GROWSDOWN) {
                     if !space_guard.can_extend_stack(region.start() - address) {
                         // exceeds stack limit
-                        log::error!(
-                            "pid {} stack limit exceeded, error_code: {:?}, address: {:#x}",
+                        log::warn!(
+                            "pid {} user stack limit exceeded, error_code: {:?}, address: {:#x}",
                             ProcessManager::current_pid().data(),
                             error_code,
                             address.data(),

kernel/src/ipc/sighand.rs

@@ -7,7 +7,7 @@ use system_error::SystemError;
 
 use crate::{
     arch::ipc::signal::{SigFlags, SigSet, Signal, MAX_SIG_NUM},
-    ipc::signal_types::{SaHandlerType, SigInfo, SigPending, SigactionType, SignalFlags},
+    ipc::signal_types::{SaHandlerType, SigCode, SigInfo, SigPending, SigactionType, SignalFlags},
     libs::rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard},
     process::{
         pid::{Pid, PidType},
@@ -95,6 +95,54 @@ impl SigHand {
         g.shared_pending.queue().find(sig).0.is_some()
     }
 
+    /// 查找并判断 shared pending 队列中是否已存在指定 timerid 的 POSIX timer 信号。
+    pub fn shared_pending_posix_timer_exists(&self, sig: Signal, timerid: i32) -> bool {
+        let mut g = self.inner_mut();
+        for info in g.shared_pending.queue_mut().q.iter_mut() {
+            // bump(0) 作为“匹配探测”，不会改变值
+            if info.is_signal(sig)
+                && info.sig_code() == SigCode::Timer
+                && info.bump_posix_timer_overrun(timerid, 0)
+            {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// 若 shared pending 中已存在该 timer 的信号，则将其 si_overrun 增加 bump，并返回 true。
+    pub fn shared_pending_posix_timer_bump_overrun(
+        &self,
+        sig: Signal,
+        timerid: i32,
+        bump: i32,
+    ) -> bool {
+        let mut g = self.inner_mut();
+        for info in g.shared_pending.queue_mut().q.iter_mut() {
+            if info.is_signal(sig)
+                && info.sig_code() == SigCode::Timer
+                && info.bump_posix_timer_overrun(timerid, bump)
+            {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// 将 shared pending 中属于该 timer 的信号的 si_overrun 重置为 0（若找到则返回 true）。
+    pub fn shared_pending_posix_timer_reset_overrun(&self, sig: Signal, timerid: i32) -> bool {
+        let mut g = self.inner_mut();
+        for info in g.shared_pending.queue_mut().q.iter_mut() {
+            if info.is_signal(sig)
+                && info.sig_code() == SigCode::Timer
+                && info.reset_posix_timer_overrun(timerid)
+            {
+                return true;
+            }
+        }
+        false
+    }
+
     pub fn shared_pending_dequeue(&self, sig_mask: &SigSet) -> (Signal, Option<SigInfo>) {
         let mut g = self.inner_mut();
         g.shared_pending.dequeue_signal(sig_mask)

kernel/src/ipc/signal_types.rs

@@ -16,7 +16,7 @@ use crate::{
 
 /// siginfo中的si_code的可选值
 /// 请注意，当这个值小于0时，表示siginfo来自用户态，否则来自内核态
-#[derive(Copy, Debug, Clone)]
+#[derive(Copy, Debug, Clone, PartialEq, Eq)]
 #[repr(i32)]
 pub enum SigCode {
     /// sent by kill, sigsend, raise
@@ -394,13 +394,48 @@ pub struct PosixSiginfoSigsys {
     pub _arch: u32,
 }
 
+/// 标准 POSIX sigval_t（union）。
+///
+/// 用户态会通过 `si_int` / `si_ptr` 访问同一片内存，因此必须是 union，且大小应为 8 字节。
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-pub struct PosixSigval {
+#[derive(Copy, Clone)]
+pub union PosixSigval {
     pub sival_int: i32,
     pub sival_ptr: u64,
 }
 
+impl PosixSigval {
+    #[inline(always)]
+    pub const fn from_int(v: i32) -> Self {
+        Self { sival_int: v }
+    }
+
+    #[inline(always)]
+    pub const fn from_ptr(v: u64) -> Self {
+        Self { sival_ptr: v }
+    }
+
+    #[inline(always)]
+    pub const fn zero() -> Self {
+        Self { sival_ptr: 0 }
+    }
+}
+
+impl core::fmt::Debug for PosixSigval {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        // union：同时以 int/ptr 两种视角打印，便于调试
+        let as_int = unsafe { self.sival_int };
+        let as_ptr = unsafe { self.sival_ptr };
+        f.debug_struct("PosixSigval")
+            .field("sival_int", &as_int)
+            .field("sival_ptr", &as_ptr)
+            .finish()
+    }
+}
+
+// 编译期校验：sigval_t 在 64-bit 架构下应为 8 字节
+const _: [(); 8] = [(); core::mem::size_of::<PosixSigval>()];
+
 /// 获取当前进程的UID
 fn get_current_uid() -> u32 {
     ProcessManager::current_pcb().cred().uid.data() as u32
@@ -411,10 +446,59 @@ impl SigInfo {
         self.sig_code
     }
 
+    #[inline(always)]
+    pub fn signo_i32(&self) -> i32 {
+        self.sig_no
+    }
+
+    #[inline(always)]
+    pub fn is_signal(&self, sig: Signal) -> bool {
+        self.sig_no == sig as i32
+    }
+
     pub fn set_sig_type(&mut self, sig_type: SigType) {
         self.sig_type = sig_type;
     }
 
+    /// 若该 SigInfo 为指定 timerid 的 POSIX timer 信号，则将其 si_overrun 增加 bump，并返回 true。
+    pub fn bump_posix_timer_overrun(&mut self, timerid: i32, bump: i32) -> bool {
+        match self.sig_type {
+            SigType::PosixTimer {
+                timerid: tid,
+                overrun,
+                sigval,
+            } if tid == timerid => {
+                let new_overrun = overrun.saturating_add(bump);
+                self.sig_type = SigType::PosixTimer {
+                    timerid: tid,
+                    overrun: new_overrun,
+                    sigval,
+                };
+                true
+            }
+            _ => false,
+        }
+    }
+
+    /// 若该 SigInfo 为指定 timerid 的 POSIX timer 信号，则将其 si_overrun 重置为 0，并返回 true。
+    pub fn reset_posix_timer_overrun(&mut self, timerid: i32) -> bool {
+        match self.sig_type {
+            SigType::PosixTimer {
+                timerid: tid,
+                overrun: _,
+                sigval,
+            } if tid == timerid => {
+                self.sig_type = SigType::PosixTimer {
+                    timerid: tid,
+                    overrun: 0,
+                    sigval,
+                };
+                true
+            }
+            _ => false,
+        }
+    }
+
     /// 将内核SigInfo转换为标准PosixSigInfo
     #[inline(never)]
     pub fn convert_to_posix_siginfo(&self) -> PosixSigInfo {
@@ -438,10 +522,23 @@ impl SigInfo {
                     _timer: PosixSiginfoTimer {
                         si_tid: pid.data() as i32,
                         si_overrun: 0,
-                        si_sigval: PosixSigval {
-                            sival_int: 0,
-                            sival_ptr: 0,
-                        },
+                        si_sigval: PosixSigval::zero(),
+                    },
+                },
+            },
+            SigType::PosixTimer {
+                timerid,
+                overrun,
+                sigval,
+            } => PosixSigInfo {
+                si_signo: self.sig_no,
+                si_errno: self.errno,
+                si_code: self.sig_code as i32,
+                _sifields: PosixSiginfoFields {
+                    _timer: PosixSiginfoTimer {
+                        si_tid: timerid,
+                        si_overrun: overrun,
+                        si_sigval: sigval,
                     },
                 },
             },
@@ -475,6 +572,15 @@ impl SigInfo {
 pub enum SigType {
     Kill(RawPid),
     Alarm(RawPid),
+    /// POSIX interval timer 发送的信号（SI_TIMER）。
+    /// - `timerid`: 对应用户态 `siginfo_t::si_timerid`
+    /// - `overrun`: 对应用户态 `siginfo_t::si_overrun`
+    /// - `sigval`: 对应用户态 `siginfo_t::si_value`
+    PosixTimer {
+        timerid: i32,
+        overrun: i32,
+        sigval: PosixSigval,
+    },
     // 后续完善下列中的具体字段
     // Timer,
     // Rt,
@@ -519,6 +625,46 @@ impl SigPending {
         &mut self.queue
     }
 
+    /// 在当前线程 pending 队列中判断是否已存在指定 timerid 的 POSIX timer 信号。
+    pub fn posix_timer_exists(&mut self, sig: Signal, timerid: i32) -> bool {
+        for info in self.queue.q.iter_mut() {
+            // bump(0) 作为“匹配探测”，不会改变值
+            if info.is_signal(sig)
+                && info.sig_code() == SigCode::Timer
+                && info.bump_posix_timer_overrun(timerid, 0)
+            {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// 若当前线程 pending 队列中已存在该 timer 的信号，则将其 si_overrun 增加 bump，并返回 true。
+    pub fn posix_timer_bump_overrun(&mut self, sig: Signal, timerid: i32, bump: i32) -> bool {
+        for info in self.queue.q.iter_mut() {
+            if info.is_signal(sig)
+                && info.sig_code() == SigCode::Timer
+                && info.bump_posix_timer_overrun(timerid, bump)
+            {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// 将当前线程 pending 队列中属于该 timer 的信号的 si_overrun 重置为 0（若找到则返回 true）。
+    pub fn posix_timer_reset_overrun(&mut self, sig: Signal, timerid: i32) -> bool {
+        for info in self.queue.q.iter_mut() {
+            if info.is_signal(sig)
+                && info.sig_code() == SigCode::Timer
+                && info.reset_posix_timer_overrun(timerid)
+            {
+                return true;
+            }
+        }
+        false
+    }
+
     pub fn signal_mut(&mut self) -> &mut SigSet {
         &mut self.signal
     }

kernel/src/libs/futex/futex.rs

@@ -828,7 +828,10 @@ impl RobustListHead {
             mem::size_of::<PosixRobustListHead>(),
             true,
         )?;
-        let robust_list_head = *user_buffer_reader.read_one_from_user::<PosixRobustListHead>(0)?;
+        // 使用异常表保护读取，避免用户地址缺页/无效导致内核崩溃
+        let robust_list_head = user_buffer_reader
+            .buffer_protected(0)?
+            .read_one::<PosixRobustListHead>(0)?;
         let robust_list_head = RobustListHead {
             posix: robust_list_head,
             uaddr: head_uaddr,
@@ -881,7 +884,10 @@ impl RobustListHead {
             core::mem::size_of::<usize>(),
             true,
         )?;
-        user_writer.copy_one_to_user(&mem::size_of::<PosixRobustListHead>(), 0)?;
+        // 使用异常表保护写回
+        user_writer
+            .buffer_protected(0)?
+            .write_one::<usize>(0, &mem::size_of::<PosixRobustListHead>())?;
 
         // 获取当前线程的robust list head
         let robust_list_head_opt = *pcb.get_robust_list();
@@ -896,7 +902,10 @@ impl RobustListHead {
             mem::size_of::<usize>(),
             true,
         )?;
-        user_writer.copy_one_to_user(&head_uaddr, 0)?;
+        // 使用异常表保护写回
+        user_writer
+            .buffer_protected(0)?
+            .write_one::<usize>(0, &head_uaddr)?;
 
         return Ok(0);
     }
@@ -927,8 +936,11 @@ impl RobustListHead {
             }
         };
 
-        let posix_head = match user_buffer_reader.read_one_from_user::<PosixRobustListHead>(0) {
-            Ok(head) => *head,
+        let posix_head = match user_buffer_reader
+            .buffer_protected(0)
+            .and_then(|b| b.read_one::<PosixRobustListHead>(0))
+        {
+            Ok(head) => head,
             Err(_) => {
                 return;
             }
@@ -967,8 +979,9 @@ impl RobustListHead {
 
     /// # 安全地从用户空间读取u32值，如果地址无效则返回None
     fn safe_read_u32(addr: VirtAddr) -> Option<u32> {
-        Self::safe_read::<u32>(addr)
-            .and_then(|reader| reader.read_one_from_user::<u32>(0).ok().cloned())
+        let reader =
+            UserBufferReader::new(addr.as_ptr::<u32>(), core::mem::size_of::<u32>(), true).ok()?;
+        reader.buffer_protected(0).ok()?.read_one::<u32>(0).ok()
     }
 
     /// # 处理进程即将死亡时，进程已经持有的futex，唤醒其他等待该futex的线程