fix: prevent SIGURG preemption live-lock by hooking write, guarding monitor signal dispatch, and adding sigurg_handler safety net

core/src/monitor.rs

@@ -78,24 +78,6 @@ impl Monitor {
                 set.remove(Signal::SIGURG);
                 set.thread_set_mask()
                     .expect("Failed to remove SIGURG signal mask!");
-                //不抢占处于Syscall状态的协程。
-                //MonitorListener的设计理念是不对Syscall状态的协程发送信号。
-                //但由于NOTIFY_NODE移除和monitor线程遍历之间存在竞态条件，
-                //SIGURG可能在协程刚进入Syscall状态时到达。
-                //如果此时抢占，协程会被放入syscall_map但无人唤醒（因为没有io_uring/epoll注册），
-                //导致死锁。
-                // Skip preemption for coroutines in Syscall state.
-                // MonitorListener's design is to NOT send signals to Syscall-state
-                // coroutines. However, a race between NOTIFY_NODE removal and the
-                // monitor's queue iteration can cause SIGURG to arrive just after
-                // the coroutine entered Syscall state. If preempted here, the
-                // coroutine lands in the syscall map with no io_uring/epoll/timer
-                // registration to wake it, causing a deadlock.
-                if let Some(co) = SchedulableCoroutine::current() {
-                    if matches!(co.state(), CoroutineState::Syscall((), _, _)) {
-                        return;
-                    }
-                }
                 if let Some(suspender) = SchedulableSuspender::current() {
                     suspender.suspend();
                 }
@@ -177,14 +159,25 @@ impl Monitor {
         let monitor = Self::get_instance();
         Self::init_current(monitor);
         let notify_queue = unsafe { &*monitor.notify_queue.get() };
+        //先收集超时节点快照，再逐个检查是否仍在队列中
+        //（在收集和检查之间，on_state_changed可能已将节点移除——协程进入了Syscall状态）
+        let mut expired = Vec::new();
         while MonitorState::Running == monitor.state.get() || !notify_queue.is_empty() {
             //只遍历，不删除，如果抢占调度失败，会在1ms后不断重试，相当于主动检测
-            for node in notify_queue {
-                if now() < node.timestamp {
-                    continue;
-                }
+            expired.clear();
+            let current = now();
+            expired.extend(
+                notify_queue
+                    .iter()
+                    .filter(|n| current >= n.timestamp)
+                    .copied(),
+            );
+            for node in &expired {
                 //实际上只对陷入重度计算的协程发送信号抢占
                 //对于陷入执行系统调用的协程不发送信号(如果发送信号，会打断系统调用，进而降低总体性能)
+                if !notify_queue.contains(node) {
+                    continue;
+                }
                 cfg_if::cfg_if! {
                     if #[cfg(unix)] {
                         if pthread_kill(node.pthread, Signal::SIGURG).is_err() {

core/src/syscall/unix/mod.rs

@@ -98,7 +98,15 @@ macro_rules! impl_facade {
                 $($arg: $arg_type),*
             ) -> $result {
                 let syscall = $crate::common::constants::SyscallName::$syscall;
-                $crate::info!("enter syscall {}", syscall);
+                //先转换状态再记录日志：co.syscall(Executing)会通过on_state_changed
+                //移除MonitorListener的NOTIFY_NODE，使monitor不再发送SIGURG。
+                //如果先调用info!()再转换状态，在QEMU等慢平台上info!()可能耗时>10ms，
+                //导致SIGURG在协程还处于Running状态时被发送，造成抢占活锁。
+                // Transition state BEFORE logging: co.syscall(Executing) triggers
+                // on_state_changed which removes MonitorListener's NOTIFY_NODE,
+                // preventing the monitor from sending SIGURG. If info!() is called
+                // first while still in Running state, it can take >10ms on slow
+                // platforms (QEMU), causing SIGURG to fire and preemption live-lock.
                 if let Some(co) = $crate::scheduler::SchedulableCoroutine::current() {
                     let new_state = $crate::common::constants::SyscallState::Executing;
                     if co.syscall((), syscall, new_state).is_err() {
@@ -107,6 +115,7 @@ macro_rules! impl_facade {
                         );
                     }
                 }
+                $crate::info!("enter syscall {}", syscall);
                 let r = self.inner.$syscall(fn_ptr, $($arg, )*);
                 if let Some(co) = $crate::scheduler::SchedulableCoroutine::current() {
                     if co.running().is_err() {

core/src/syscall/unix/write.rs

@@ -42,7 +42,6 @@ impl<I: WriteSyscall> WriteSyscall for WriteSyscallFacade<I> {
             return RawWriteSyscall::default().write(fn_ptr, fd, buf, len);
         }
         let syscall = crate::common::constants::SyscallName::write;
-        crate::info!("enter syscall {}", syscall);
         if let Some(co) = crate::scheduler::SchedulableCoroutine::current() {
             let new_state = crate::common::constants::SyscallState::Executing;
             if co.syscall((), syscall, new_state).is_err() {
@@ -51,6 +50,7 @@ impl<I: WriteSyscall> WriteSyscall for WriteSyscallFacade<I> {
                 );
             }
         }
+        crate::info!("enter syscall {}", syscall);
         let r = self.inner.write(fn_ptr, fd, buf, len);
         if let Some(co) = crate::scheduler::SchedulableCoroutine::current() {
             if co.running().is_err() {

core/src/syscall/windows/mod.rs

@@ -76,7 +76,15 @@ macro_rules! impl_facade {
                 $($arg: $arg_type),*
             ) -> $result {
                 let syscall = $crate::common::constants::SyscallName::$syscall;
-                $crate::info!("enter syscall {}", syscall);
+                //先转换状态再记录日志：co.syscall(Executing)会通过on_state_changed
+                //移除MonitorListener的NOTIFY_NODE，使monitor不再发送SIGURG。
+                //如果先调用info!()再转换状态，在QEMU等慢平台上info!()可能耗时>10ms，
+                //导致SIGURG在协程还处于Running状态时被发送，造成抢占活锁。
+                // Transition state BEFORE logging: co.syscall(Executing) triggers
+                // on_state_changed which removes MonitorListener's NOTIFY_NODE,
+                // preventing the monitor from sending SIGURG. If info!() is called
+                // first while still in Running state, it can take >10ms on slow
+                // platforms (QEMU), causing SIGURG to fire and preemption live-lock.
                 if let Some(co) = $crate::scheduler::SchedulableCoroutine::current() {
                     let new_state = $crate::common::constants::SyscallState::Executing;
                     if co.syscall((), syscall, new_state).is_err() {
@@ -85,6 +93,7 @@ macro_rules! impl_facade {
                         );
                     }
                 }
+                $crate::info!("enter syscall {}", syscall);
                 let r = self.inner.$syscall(fn_ptr, $($arg, )*);
                 // Save errno immediately—logging and coroutine bookkeeping
                 // call Win32 APIs (e.g. CreateFileW) that clobber GetLastError().