diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 000000000..949a0b2e8 --- /dev/null +++ b/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`. 当你想检查你编辑的代码有没有语法错误的时候，请执行这个命令 + + diff --git a/kernel/src/arch/x86_64/mm/fault.rs b/kernel/src/arch/x86_64/mm/fault.rs index e2c1f27ed..985251eb4 100644 --- a/kernel/src/arch/x86_64/mm/fault.rs +++ b/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(), diff --git a/kernel/src/ipc/sighand.rs b/kernel/src/ipc/sighand.rs index b3644748f..ee38d7f1a 100644 --- a/kernel/src/ipc/sighand.rs +++ b/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) { let mut g = self.inner_mut(); g.shared_pending.dequeue_signal(sig_mask) diff --git a/kernel/src/ipc/signal_types.rs b/kernel/src/ipc/signal_types.rs index 98cccfcbe..4c829a215 100644 --- a/kernel/src/ipc/signal_types.rs +++ b/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::()]; + /// 获取当前进程的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 } diff --git a/kernel/src/libs/futex/futex.rs b/kernel/src/libs/futex/futex.rs index 6e816e334..1469b17e3 100644 --- a/kernel/src/libs/futex/futex.rs +++ b/kernel/src/libs/futex/futex.rs @@ -828,7 +828,10 @@ impl RobustListHead { mem::size_of::(), true, )?; - let robust_list_head = *user_buffer_reader.read_one_from_user::(0)?; + // 使用异常表保护读取，避免用户地址缺页/无效导致内核崩溃 + let robust_list_head = user_buffer_reader + .buffer_protected(0)? + .read_one::(0)?; let robust_list_head = RobustListHead { posix: robust_list_head, uaddr: head_uaddr, @@ -881,7 +884,10 @@ impl RobustListHead { core::mem::size_of::(), true, )?; - user_writer.copy_one_to_user(&mem::size_of::(), 0)?; + // 使用异常表保护写回 + user_writer + .buffer_protected(0)? + .write_one::(0, &mem::size_of::())?; // 获取当前线程的robust list head let robust_list_head_opt = *pcb.get_robust_list(); @@ -896,7 +902,10 @@ impl RobustListHead { mem::size_of::(), true, )?; - user_writer.copy_one_to_user(&head_uaddr, 0)?; + // 使用异常表保护写回 + user_writer + .buffer_protected(0)? + .write_one::(0, &head_uaddr)?; return Ok(0); } @@ -927,8 +936,11 @@ impl RobustListHead { } }; - let posix_head = match user_buffer_reader.read_one_from_user::(0) { - Ok(head) => *head, + let posix_head = match user_buffer_reader + .buffer_protected(0) + .and_then(|b| b.read_one::(0)) + { + Ok(head) => head, Err(_) => { return; } @@ -967,8 +979,9 @@ impl RobustListHead { /// # 安全地从用户空间读取u32值，如果地址无效则返回None fn safe_read_u32(addr: VirtAddr) -> Option { - Self::safe_read::(addr) - .and_then(|reader| reader.read_one_from_user::(0).ok().cloned()) + let reader = + UserBufferReader::new(addr.as_ptr::(), core::mem::size_of::(), true).ok()?; + reader.buffer_protected(0).ok()?.read_one::(0).ok() } /// # 处理进程即将死亡时，进程已经持有的futex，唤醒其他等待该futex的线程 diff --git a/kernel/src/process/mod.rs b/kernel/src/process/mod.rs index dd6eae69d..881c27e22 100644 --- a/kernel/src/process/mod.rs +++ b/kernel/src/process/mod.rs @@ -85,6 +85,7 @@ pub mod idle; pub mod kthread; pub mod namespace; pub mod pid; +pub mod posix_timer; pub mod preempt; pub mod process_group; pub mod resource; @@ -479,11 +480,20 @@ impl ProcessManager { if let Some(addr) = thread.clear_child_tid { // 按 Linux 语义：先清零 userland 的 *clear_child_tid，再 futex_wake(addr) - unsafe { - clear_user_protected(addr, core::mem::size_of::()) - .expect("clear tid failed") + let cleared_ok = unsafe { + match clear_user_protected(addr, core::mem::size_of::()) { + Ok(_) => true, + Err(e) => { + // clear_child_tid 指针可能无效或已拆映射：不能因此 panic。 + warn!("clear tid failed: {e:?}"); + false + } + } }; - if Arc::strong_count(&pcb.basic().user_vm().expect("User VM Not found")) > 1 { + // 若无法清零 *clear_child_tid，则也不要 futex_wake（避免进一步的非法用户态访问） + if cleared_ok + && Arc::strong_count(&pcb.basic().user_vm().expect("User VM Not found")) > 1 + { // Linux 使用 FUTEX_SHARED 标志来唤醒 clear_child_tid // 这允许跨进程/线程的同步（例如 pthread_join） let _ = @@ -905,6 +915,8 @@ pub struct ProcessControlBlock { ///闹钟定时器 alarm_timer: SpinLock>, itimers: SpinLock, + /// POSIX interval timers（timer_create/timer_settime/...） + posix_timers: SpinLock, /// CPU时间片 cpu_time: Arc, @@ -1040,6 +1052,7 @@ impl ProcessControlBlock { fs: RwLock::new(Arc::new(FsStruct::new())), alarm_timer: SpinLock::new(None), itimers: SpinLock::new(ProcessItimers::default()), + posix_timers: SpinLock::new(posix_timer::ProcessPosixTimers::default()), cpu_time: Arc::new(ProcessCpuTime::default()), robust_list: RwLock::new(None), cred: SpinLock::new(cred), @@ -1603,6 +1616,10 @@ impl ProcessControlBlock { return self.itimers.lock_irqsave(); } + pub fn posix_timers_irqsave(&self) -> SpinLockGuard<'_, posix_timer::ProcessPosixTimers> { + return self.posix_timers.lock_irqsave(); + } + #[inline(always)] pub fn cputime(&self) -> Arc { return self.cpu_time.clone(); diff --git a/kernel/src/process/posix_timer.rs b/kernel/src/process/posix_timer.rs new file mode 100644 index 000000000..b11ba1b0a --- /dev/null +++ b/kernel/src/process/posix_timer.rs @@ -0,0 +1,406 @@ +//! POSIX interval timers (timer_create/timer_settime/...) for a process. +//! +//! This is a minimal-but-correct implementation for gVisor `timers.cc` tests: +//! - CLOCK_MONOTONIC based timers +//! - SIGEV_NONE / SIGEV_SIGNAL / SIGEV_THREAD_ID (thread id must be current thread) +//! - coalescing: at most one pending signal per (signo,timerid); overruns accumulate + +use alloc::{ + boxed::Box, + sync::{Arc, Weak}, +}; +use hashbrown::HashMap; +use system_error::SystemError; + +use crate::{ + arch::ipc::signal::Signal, + ipc::signal_types::{PosixSigval, SigCode, SigInfo, SigType}, + process::{ProcessControlBlock, ProcessFlags, ProcessManager, RawPid}, + time::{ + jiffies::NSEC_PER_JIFFY, + syscall::PosixClockID, + timer::{clock, Jiffies, Timer, TimerFunction}, + PosixTimeSpec, + }, +}; + +use core::{mem::size_of, time::Duration}; + +/// 用户态 itimerspec +#[repr(C)] +#[derive(Default, Debug, Copy, Clone)] +pub struct PosixItimerspec { + pub it_interval: PosixTimeSpec, + pub it_value: PosixTimeSpec, +} + +/// 用户态 sigevent（Linux x86_64 下大小为 64B；这里保守定义为 64B） +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct PosixSigevent { + pub sigev_value: u64, + pub sigev_signo: i32, + pub sigev_notify: i32, + pub sigev_notify_thread_id: i32, + pub _pad: [u8; 44], +} + +const _: [(); 64] = [(); size_of::()]; + +/// sigev_notify 常量（Linux） +pub const SIGEV_SIGNAL: i32 = 0; +pub const SIGEV_NONE: i32 = 1; +pub const SIGEV_THREAD_ID: i32 = 4; + +#[derive(Debug, Copy, Clone)] +pub enum PosixTimerNotify { + None, + Signal { + signo: Signal, + sigval: PosixSigval, + target_tid: RawPid, + }, +} + +#[derive(Debug)] +pub struct PosixIntervalTimer { + pub id: i32, + pub clockid: PosixClockID, + pub notify: PosixTimerNotify, + pub interval: PosixTimeSpec, + pub timer: Option>, + pub expire_jiffies: Option, + pub pending_overrun_acc: i32, + pub last_overrun: i32, +} + +impl PosixIntervalTimer { + fn is_armed(&self) -> bool { + self.timer.is_some() && self.expire_jiffies.is_some() + } +} + +#[derive(Debug, Default)] +pub struct ProcessPosixTimers { + next_id: i32, + timers: HashMap, +} + +impl ProcessPosixTimers { + pub fn get_timer(&self, timerid: i32) -> Result<&PosixIntervalTimer, SystemError> { + self.timers.get(&timerid).ok_or(SystemError::EINVAL) + } + + pub fn get_timer_mut(&mut self, timerid: i32) -> Result<&mut PosixIntervalTimer, SystemError> { + self.timers.get_mut(&timerid).ok_or(SystemError::EINVAL) + } + + fn alloc_id(&mut self) -> i32 { + // Linux timer_t 在用户态通常是 int；这里用递增 id，跳过 0。 + let mut id = self.next_id; + if id <= 0 { + id = 1; + } + loop { + if !self.timers.contains_key(&id) { + self.next_id = id.saturating_add(1); + return id; + } + id = id.saturating_add(1); + } + } + + pub fn create( + &mut self, + pcb: &Arc, + clockid: PosixClockID, + sev: Option, + ) -> Result { + // gVisor tests only use CLOCK_MONOTONIC. + if clockid != PosixClockID::Monotonic { + return Err(SystemError::EINVAL); + } + + let sev = sev.unwrap_or(PosixSigevent { + sigev_value: 0, + sigev_signo: Signal::SIGALRM as i32, + sigev_notify: SIGEV_SIGNAL, + sigev_notify_thread_id: pcb.raw_pid().data() as i32, + _pad: [0u8; 44], + }); + + let notify = match sev.sigev_notify { + SIGEV_NONE => PosixTimerNotify::None, + SIGEV_SIGNAL => { + let signo = Signal::from(sev.sigev_signo as usize); + if !signo.is_valid() { + return Err(SystemError::EINVAL); + } + PosixTimerNotify::Signal { + signo, + sigval: PosixSigval::from_ptr(sev.sigev_value), + target_tid: pcb.raw_pid(), + } + } + SIGEV_THREAD_ID => { + // 当前内核暂无完善的线程模型：只允许指定当前线程（tid）。 + let tid = RawPid::new(sev.sigev_notify_thread_id as usize); + if tid != ProcessManager::current_pcb().raw_pid() { + return Err(SystemError::EINVAL); + } + let signo = Signal::from(sev.sigev_signo as usize); + if !signo.is_valid() { + return Err(SystemError::EINVAL); + } + PosixTimerNotify::Signal { + signo, + sigval: PosixSigval::from_ptr(sev.sigev_value), + target_tid: tid, + } + } + _ => return Err(SystemError::EINVAL), + }; + + let id = self.alloc_id(); + self.timers.insert( + id, + PosixIntervalTimer { + id, + clockid, + notify, + interval: PosixTimeSpec::default(), + timer: None, + expire_jiffies: None, + pending_overrun_acc: 0, + last_overrun: 0, + }, + ); + Ok(id) + } + + pub fn delete( + &mut self, + pcb: &Arc, + timerid: i32, + ) -> Result<(), SystemError> { + let t = self.timers.remove(&timerid).ok_or(SystemError::EINVAL)?; + if let Some(timer) = t.timer { + timer.cancel(); + } + // 删除/停用会将已排队的 SI_TIMER 的 overrun 重置为 0（与 tests 注释一致） + if let PosixTimerNotify::Signal { signo, .. } = t.notify { + pcb.sig_info_mut() + .sig_pending_mut() + .posix_timer_reset_overrun(signo, timerid); + } + Ok(()) + } + + pub fn gettime(&self, timerid: i32) -> Result { + let t = self.get_timer(timerid)?; + let mut out = PosixItimerspec { + it_interval: t.interval, + ..Default::default() + }; + if let Some(exp) = t.expire_jiffies { + let now = clock(); + if exp > now { + let remaining_j = exp - now; + let remaining_ns: u64 = remaining_j.saturating_mul(NSEC_PER_JIFFY as u64); + out.it_value = PosixTimeSpec { + tv_sec: (remaining_ns / 1_000_000_000) as i64, + tv_nsec: (remaining_ns % 1_000_000_000) as i64, + } + } + } + Ok(out) + } + + pub fn getoverrun(&self, timerid: i32) -> Result { + let t = self.get_timer(timerid)?; + Ok(t.last_overrun) + } + + pub fn settime( + &mut self, + pcb: &Arc, + timerid: i32, + new_value: PosixItimerspec, + ) -> Result { + let old = self.gettime(timerid)?; + let t = self.get_timer_mut(timerid)?; + + // 取消旧 timer + if let Some(old_timer) = t.timer.take() { + old_timer.cancel(); + } + t.expire_jiffies = None; + + // timer_settime 会重置 overrun（包含已排队信号的 overrun） + t.pending_overrun_acc = 0; + t.last_overrun = 0; + if let PosixTimerNotify::Signal { signo, .. } = t.notify { + pcb.sig_info_mut() + .sig_pending_mut() + .posix_timer_reset_overrun(signo, timerid); + } + + // 更新 interval + validate_timespec(&new_value.it_interval)?; + validate_timespec(&new_value.it_value)?; + t.interval = new_value.it_interval; + + // it_value 为 0 => disarm + if new_value.it_value.is_empty() { + return Ok(old); + } + + let delay = timespec_to_duration(&new_value.it_value)?; + let expire_jiffies = clock() + >::from(delay).data(); + + let helper = PosixTimerHelper::new(Arc::downgrade(pcb), timerid); + let new_timer = Timer::new(helper, expire_jiffies); + new_timer.activate(); + + t.expire_jiffies = Some(expire_jiffies); + t.timer = Some(new_timer); + Ok(old) + } +} + +#[derive(Debug)] +struct PosixTimerHelper { + pcb: Weak, + timerid: i32, +} + +impl PosixTimerHelper { + fn new(pcb: Weak, timerid: i32) -> Box { + Box::new(Self { pcb, timerid }) + } +} + +impl TimerFunction for PosixTimerHelper { + fn run(&mut self) -> Result<(), SystemError> { + let pcb = match self.pcb.upgrade() { + Some(p) => p, + None => return Ok(()), + }; + + // 在 softirq/timer 上下文执行：核心逻辑放在持锁区域内，避免并发打架。 + let mut timers = pcb.posix_timers_irqsave(); + let t = match timers.timers.get_mut(&self.timerid) { + Some(t) => t, + None => return Ok(()), + }; + + // 已经被 disarm/delete + if !t.is_armed() { + return Ok(()); + } + + // 周期性定时器：先重建下一次，避免 gettime() 在回调窗口看到 0（PeriodicSilent 期望仍在运行） + let is_periodic = !t.interval.is_empty(); + if is_periodic { + let interval = timespec_to_duration(&t.interval)?; + let expire_jiffies = clock() + >::from(interval).data(); + let helper = PosixTimerHelper::new(Arc::downgrade(&pcb), self.timerid); + let next_timer = Timer::new(helper, expire_jiffies); + next_timer.activate(); + t.expire_jiffies = Some(expire_jiffies); + t.timer = Some(next_timer); + } else { + // one-shot：本次触发后应停止 + t.timer = None; + t.expire_jiffies = None; + } + + match t.notify { + PosixTimerNotify::None => { + // 无信号 + } + PosixTimerNotify::Signal { + signo, + sigval, + target_tid, + } => { + // 注意：DragonOS 当前 signal 发送路径对非 RT 信号的“去重检查”是看 shared_pending， + // 但实际入队在 per-thread pending，因此这里必须基于当前线程 pending 来做合并/overrun。 + let mut siginfo_guard = pcb.sig_info_mut(); + // 计算“是否未阻塞且 handler=SIG_IGN”，必须使用已持有的 siginfo_guard， + // 否则在持有写锁时再次调用 pcb.sig_info_irqsave() 会造成自锁死（PeriodicGroupDirectedSignal 复现）。 + let ignored_and_unblocked = { + let mut blocked = *siginfo_guard.sig_blocked(); + if pcb.flags().contains(ProcessFlags::RESTORE_SIG_MASK) { + blocked.insert(*siginfo_guard.saved_sigmask()); + } + let is_blocked = blocked.contains(signo.into_sigset()); + if is_blocked { + false + } else { + pcb.sighand() + .handler(signo) + .map(|x| x.is_ignore()) + .unwrap_or(false) + } + }; + let pending = siginfo_guard.sig_pending_mut(); + + // 1) 若已有该 timer 的信号：在队列项上累加 overrun + if pending.posix_timer_exists(signo, self.timerid) { + let bump = 1i32.saturating_add(t.pending_overrun_acc); + t.pending_overrun_acc = 0; + pending.posix_timer_bump_overrun(signo, self.timerid, bump); + } else { + // 2) 若 signo 已有其他来源的 pending（如 tgkill 提前排队）：本次无法入队，记为 overrun + if pending.queue().find(signo).0.is_some() { + t.pending_overrun_acc = t.pending_overrun_acc.saturating_add(1); + } else if ignored_and_unblocked { + // 3) 未阻塞且 handler=SIG_IGN：Linux 语义下会丢弃；tests 期望这也计入 overrun + t.pending_overrun_acc = t.pending_overrun_acc.saturating_add(1); + } else { + // 4) 可以入队：构造 SI_TIMER siginfo（确保只入队一次） + let overrun = t.pending_overrun_acc; + t.pending_overrun_acc = 0; + t.last_overrun = overrun; + + drop(siginfo_guard); // 避免在 send_signal 路径中再次取 sig_info 锁导致死锁 + + let mut info = SigInfo::new( + signo, + 0, + SigCode::Timer, + SigType::PosixTimer { + timerid: self.timerid, + overrun, + sigval, + }, + ); + + // 当前实现：target_tid 必须属于当前进程；否则在 create 时已拒绝 + let target = ProcessManager::find_task_by_vpid(target_tid) + .unwrap_or_else(|| pcb.clone()); + let _ = signo.send_signal_info_to_pcb(Some(&mut info), target); + } + } + } + } + + Ok(()) + } +} + +fn validate_timespec(ts: &PosixTimeSpec) -> Result<(), SystemError> { + if ts.tv_sec < 0 || ts.tv_nsec < 0 || ts.tv_nsec >= 1_000_000_000 { + return Err(SystemError::EINVAL); + } + Ok(()) +} + +fn timespec_to_duration(ts: &PosixTimeSpec) -> Result { + validate_timespec(ts)?; + Ok(Duration::new(ts.tv_sec as u64, ts.tv_nsec as u32)) +} + +// 注意：不要在持有 pcb.sig_info_mut() 写锁时调用任何会再次获取 sig_info_* 锁的函数， +// 否则会造成自锁死。相关判断请在持锁区内使用已拿到的 guard 直接计算。 diff --git a/kernel/src/time/syscall/mod.rs b/kernel/src/time/syscall/mod.rs index b66ad0f9f..ca0b2b48d 100644 --- a/kernel/src/time/syscall/mod.rs +++ b/kernel/src/time/syscall/mod.rs @@ -12,6 +12,11 @@ mod sys_getitimer; mod sys_gettimeofday; mod sys_nanosleep; mod sys_setitimer; +mod sys_timer_create; +mod sys_timer_delete; +mod sys_timer_getoverrun; +mod sys_timer_gettime; +mod sys_timer_settime; pub type PosixTimeT = c_longlong; pub type PosixSusecondsT = c_int; diff --git a/kernel/src/time/syscall/sys_timer_create.rs b/kernel/src/time/syscall/sys_timer_create.rs new file mode 100644 index 000000000..e191562d1 --- /dev/null +++ b/kernel/src/time/syscall/sys_timer_create.rs @@ -0,0 +1,71 @@ +use crate::{ + arch::{interrupt::TrapFrame, syscall::nr::SYS_TIMER_CREATE}, + process::posix_timer::PosixSigevent, + process::ProcessManager, + syscall::{ + table::{FormattedSyscallParam, Syscall}, + user_access::{UserBufferReader, UserBufferWriter}, + }, + time::syscall::PosixClockID, +}; +use alloc::vec::Vec; +use core::mem::size_of; +use syscall_table_macros::declare_syscall; +use system_error::SystemError; + +pub struct SysTimerCreateHandle; + +impl SysTimerCreateHandle { + fn clockid(args: &[usize]) -> Result { + PosixClockID::try_from(args[0] as i32) + } + fn sevp(args: &[usize]) -> *const PosixSigevent { + args[1] as *const PosixSigevent + } + fn timeridp(args: &[usize]) -> *mut i32 { + args[2] as *mut i32 + } +} + +impl Syscall for SysTimerCreateHandle { + fn num_args(&self) -> usize { + 3 + } + + fn handle(&self, args: &[usize], _frame: &mut TrapFrame) -> Result { + let clockid = Self::clockid(args)?; + let sevp = Self::sevp(args); + let timeridp = Self::timeridp(args); + + if timeridp.is_null() { + return Err(SystemError::EINVAL); + } + + let pcb = ProcessManager::current_pcb(); + + let sev = if sevp.is_null() { + None + } else { + let reader = UserBufferReader::new(sevp, size_of::(), true)?; + // 用异常表保护版本读取 + Some(reader.buffer_protected(0)?.read_one::(0)?) + }; + + let id = pcb.posix_timers_irqsave().create(&pcb, clockid, sev)?; + + let mut writer = UserBufferWriter::new(timeridp, size_of::(), true)?; + // 用异常表保护版本写回 + writer.buffer_protected(0)?.write_one::(0, &id)?; + Ok(0) + } + + fn entry_format(&self, args: &[usize]) -> Vec { + vec![ + FormattedSyscallParam::new("clockid", format!("{}", args[0])), + FormattedSyscallParam::new("sevp", format!("{:#x}", args[1])), + FormattedSyscallParam::new("timerid", format!("{:#x}", args[2])), + ] + } +} + +declare_syscall!(SYS_TIMER_CREATE, SysTimerCreateHandle); diff --git a/kernel/src/time/syscall/sys_timer_delete.rs b/kernel/src/time/syscall/sys_timer_delete.rs new file mode 100644 index 000000000..19198fdb6 --- /dev/null +++ b/kernel/src/time/syscall/sys_timer_delete.rs @@ -0,0 +1,38 @@ +use crate::{ + arch::{interrupt::TrapFrame, syscall::nr::SYS_TIMER_DELETE}, + process::ProcessManager, + syscall::table::{FormattedSyscallParam, Syscall}, +}; +use alloc::vec::Vec; +use syscall_table_macros::declare_syscall; +use system_error::SystemError; + +pub struct SysTimerDeleteHandle; + +impl SysTimerDeleteHandle { + fn timerid(args: &[usize]) -> i32 { + args[0] as i32 + } +} + +impl Syscall for SysTimerDeleteHandle { + fn num_args(&self) -> usize { + 1 + } + + fn handle(&self, args: &[usize], _frame: &mut TrapFrame) -> Result { + let timerid = Self::timerid(args); + let pcb = ProcessManager::current_pcb(); + pcb.posix_timers_irqsave().delete(&pcb, timerid)?; + Ok(0) + } + + fn entry_format(&self, args: &[usize]) -> Vec { + vec![FormattedSyscallParam::new( + "timerid", + format!("{}", args[0]), + )] + } +} + +declare_syscall!(SYS_TIMER_DELETE, SysTimerDeleteHandle); diff --git a/kernel/src/time/syscall/sys_timer_getoverrun.rs b/kernel/src/time/syscall/sys_timer_getoverrun.rs new file mode 100644 index 000000000..6f8db20f1 --- /dev/null +++ b/kernel/src/time/syscall/sys_timer_getoverrun.rs @@ -0,0 +1,38 @@ +use crate::{ + arch::{interrupt::TrapFrame, syscall::nr::SYS_TIMER_GETOVERRUN}, + process::ProcessManager, + syscall::table::{FormattedSyscallParam, Syscall}, +}; +use alloc::vec::Vec; +use syscall_table_macros::declare_syscall; +use system_error::SystemError; + +pub struct SysTimerGetoverrunHandle; + +impl SysTimerGetoverrunHandle { + fn timerid(args: &[usize]) -> i32 { + args[0] as i32 + } +} + +impl Syscall for SysTimerGetoverrunHandle { + fn num_args(&self) -> usize { + 1 + } + + fn handle(&self, args: &[usize], _frame: &mut TrapFrame) -> Result { + let timerid = Self::timerid(args); + let pcb = ProcessManager::current_pcb(); + let v = pcb.posix_timers_irqsave().getoverrun(timerid)?; + Ok(v as isize as usize) + } + + fn entry_format(&self, args: &[usize]) -> Vec { + vec![FormattedSyscallParam::new( + "timerid", + format!("{}", args[0]), + )] + } +} + +declare_syscall!(SYS_TIMER_GETOVERRUN, SysTimerGetoverrunHandle); diff --git a/kernel/src/time/syscall/sys_timer_gettime.rs b/kernel/src/time/syscall/sys_timer_gettime.rs new file mode 100644 index 000000000..3ad51fe26 --- /dev/null +++ b/kernel/src/time/syscall/sys_timer_gettime.rs @@ -0,0 +1,55 @@ +use crate::{ + arch::{interrupt::TrapFrame, syscall::nr::SYS_TIMER_GETTIME}, + process::posix_timer::PosixItimerspec, + process::ProcessManager, + syscall::{ + table::{FormattedSyscallParam, Syscall}, + user_access::UserBufferWriter, + }, +}; +use alloc::vec::Vec; +use core::mem::size_of; +use syscall_table_macros::declare_syscall; +use system_error::SystemError; + +pub struct SysTimerGettimeHandle; + +impl SysTimerGettimeHandle { + fn timerid(args: &[usize]) -> i32 { + args[0] as i32 + } + fn curr_value(args: &[usize]) -> *mut PosixItimerspec { + args[1] as *mut PosixItimerspec + } +} + +impl Syscall for SysTimerGettimeHandle { + fn num_args(&self) -> usize { + 2 + } + + fn handle(&self, args: &[usize], _frame: &mut TrapFrame) -> Result { + let timerid = Self::timerid(args); + let curr_value_ptr = Self::curr_value(args); + if curr_value_ptr.is_null() { + return Err(SystemError::EINVAL); + } + let pcb = ProcessManager::current_pcb(); + let val = pcb.posix_timers_irqsave().gettime(timerid)?; + let mut writer = UserBufferWriter::new(curr_value_ptr, size_of::(), true)?; + // 用异常表保护版本写回，避免用户地址缺页/无效导致内核崩溃 + writer + .buffer_protected(0)? + .write_one::(0, &val)?; + Ok(0) + } + + fn entry_format(&self, args: &[usize]) -> Vec { + vec![ + FormattedSyscallParam::new("timerid", format!("{}", args[0])), + FormattedSyscallParam::new("curr_value", format!("{:#x}", args[1])), + ] + } +} + +declare_syscall!(SYS_TIMER_GETTIME, SysTimerGettimeHandle); diff --git a/kernel/src/time/syscall/sys_timer_settime.rs b/kernel/src/time/syscall/sys_timer_settime.rs new file mode 100644 index 000000000..8cab271e1 --- /dev/null +++ b/kernel/src/time/syscall/sys_timer_settime.rs @@ -0,0 +1,82 @@ +use crate::{ + arch::{interrupt::TrapFrame, syscall::nr::SYS_TIMER_SETTIME}, + process::posix_timer::PosixItimerspec, + process::ProcessManager, + syscall::{ + table::{FormattedSyscallParam, Syscall}, + user_access::{UserBufferReader, UserBufferWriter}, + }, +}; +use alloc::vec::Vec; +use core::mem::size_of; +use syscall_table_macros::declare_syscall; +use system_error::SystemError; + +pub struct SysTimerSettimeHandle; + +impl SysTimerSettimeHandle { + fn timerid(args: &[usize]) -> i32 { + args[0] as i32 + } + fn flags(args: &[usize]) -> i32 { + args[1] as i32 + } + fn new_value(args: &[usize]) -> *const PosixItimerspec { + args[2] as *const PosixItimerspec + } + fn old_value(args: &[usize]) -> *mut PosixItimerspec { + args[3] as *mut PosixItimerspec + } +} + +impl Syscall for SysTimerSettimeHandle { + fn num_args(&self) -> usize { + 4 + } + + fn handle(&self, args: &[usize], _frame: &mut TrapFrame) -> Result { + let timerid = Self::timerid(args); + let flags = Self::flags(args); + let new_value_ptr = Self::new_value(args); + let old_value_ptr = Self::old_value(args); + + // 暂不支持 TIMER_ABSTIME 等 flag + if flags != 0 { + return Err(SystemError::EINVAL); + } + if new_value_ptr.is_null() { + return Err(SystemError::EINVAL); + } + + let reader = UserBufferReader::new(new_value_ptr, size_of::(), true)?; + // 用异常表保护版本读取，避免用户地址缺页/无效导致内核崩溃 + let new_value = reader.buffer_protected(0)?.read_one::(0)?; + + let pcb = ProcessManager::current_pcb(); + let old = pcb + .posix_timers_irqsave() + .settime(&pcb, timerid, new_value)?; + + if !old_value_ptr.is_null() { + let mut writer = + UserBufferWriter::new(old_value_ptr, size_of::(), true)?; + // 用异常表保护版本写回 + writer + .buffer_protected(0)? + .write_one::(0, &old)?; + } + + Ok(0) + } + + fn entry_format(&self, args: &[usize]) -> Vec { + vec![ + FormattedSyscallParam::new("timerid", format!("{}", args[0])), + FormattedSyscallParam::new("flags", format!("{:#x}", args[1])), + FormattedSyscallParam::new("new_value", format!("{:#x}", args[2])), + FormattedSyscallParam::new("old_value", format!("{:#x}", args[3])), + ] + } +} + +declare_syscall!(SYS_TIMER_SETTIME, SysTimerSettimeHandle); diff --git a/user/apps/tests/syscall/gvisor/blocklists/timers_test b/user/apps/tests/syscall/gvisor/blocklists/timers_test new file mode 100644 index 000000000..5a340ce8f --- /dev/null +++ b/user/apps/tests/syscall/gvisor/blocklists/timers_test @@ -0,0 +1,4 @@ +TimerTest.ProcessKilledOnCPUSoftLimit +TimerTest.ProcessPingedRepeatedlyAfterCPUSoftLimit +TimerTest.ProcessKilledOnCPUHardLimit +TimerTest.RlimitCpuInheritedAcrossFork \ No newline at end of file diff --git a/user/apps/tests/syscall/gvisor/whitelist.txt b/user/apps/tests/syscall/gvisor/whitelist.txt index 42c16ce8c..d24504579 100644 --- a/user/apps/tests/syscall/gvisor/whitelist.txt +++ b/user/apps/tests/syscall/gvisor/whitelist.txt @@ -84,3 +84,4 @@ fifo_test unshare_test pty_root_test time_test +timers_test