fix: reorder impl_facade! to transition state before logging, revert do_schedule redirect

Root cause fix: co.syscall(Executing) is now called BEFORE info!("enter syscall")
in both impl_facade! and WriteSyscallFacade. This triggers on_state_changed which
removes MonitorListener's NOTIFY_NODE before slow logging, preventing SIGURG from
firing while the coroutine is still in Running state.

Reverted the do_schedule Syscall(Executing) → ready queue redirect in scheduler.rs
since it's no longer needed — the MonitorListener design correctly prevents signals
to Syscall-state coroutines when the NOTIFY_NODE is removed before logging.

Agent-Logs-Url: https://github.com/acl-dev/open-coroutine/sessions/79faeb2b-0a58-4973-8277-f50a34bcb60b

Co-authored-by: loongs-zhang <38336731+loongs-zhang@users.noreply.github.com>

Author: Copilot

core/src/scheduler.rs

@@ -311,17 +311,12 @@ impl<'s> Scheduler<'s> {
                     _ = RUNNING_COROUTINES.remove(&co_id);
                 })? {
                     CoroutineState::Syscall((), _, state) => {
-                        if let SyscallState::Executing = state {
-                            //协程在系统调用执行期间被信号抢占，放回就绪队列以恢复执行
-                            self.ready.push(coroutine);
-                        } else {
-                            //挂起协程到系统调用表
-                            //如果已包含，说明当前系统调用还有上层父系统调用，因此直接忽略插入结果
-                            _ = self.syscall.insert(co_id, coroutine);
-                            if let SyscallState::Suspend(timestamp) = state {
-                                self.syscall_suspend
-                                    .push(SyscallSuspendItem { timestamp, co_id });
-                            }
+                        //挂起协程到系统调用表
+                        //如果已包含，说明当前系统调用还有上层父系统调用，因此直接忽略插入结果
+                        _ = self.syscall.insert(co_id, coroutine);
+                        if let SyscallState::Suspend(timestamp) = state {
+                            self.syscall_suspend
+                                .push(SyscallSuspendItem { timestamp, co_id });
                         }
                     }
                     CoroutineState::Suspend((), timestamp) => {

core/src/syscall/unix/mod.rs

@@ -120,15 +120,16 @@ macro_rules! impl_facade {
                     return self.inner.$syscall(fn_ptr, $($arg, )*);
                 }
                 let syscall = $crate::common::constants::SyscallName::$syscall;
-                //在日志和状态变更期间设置防重入标志，因为info!()/error!()内部会
-                //调用write()，co.syscall()/co.running()内部会调用change_state()
-                //再调用info!()，这些都可能触发hooked write导致无限递归
-                // Set re-entrancy guard during logging and state changes because:
-                // - info!()/error!() internally call write()
-                // - co.syscall()/co.running() call change_state() which calls info!()
-                // Both can trigger hooked write causing infinite recursion.
+                //先转换状态再记录日志：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.
                 $crate::syscall::set_in_facade(true);
-                $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() {
@@ -137,6 +138,7 @@ macro_rules! impl_facade {
                         );
                     }
                 }
+                $crate::info!("enter syscall {}", syscall);
                 $crate::syscall::set_in_facade(false);
                 let r = self.inner.$syscall(fn_ptr, $($arg, )*);
                 $crate::syscall::set_in_facade(true);

core/src/syscall/unix/write.rs

@@ -49,7 +49,6 @@ impl<I: WriteSyscall> WriteSyscall for WriteSyscallFacade<I> {
         }
         let syscall = crate::common::constants::SyscallName::write;
         crate::syscall::set_in_facade(true);
-        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() {
@@ -58,6 +57,7 @@ impl<I: WriteSyscall> WriteSyscall for WriteSyscallFacade<I> {
                 );
             }
         }
+        crate::info!("enter syscall {}", syscall);
         crate::syscall::set_in_facade(false);
         let r = self.inner.write(fn_ptr, fd, buf, len);
         crate::syscall::set_in_facade(true);