refactor: move IN_FACADE re-entrancy guard from mod.rs to write.rs

The IN_FACADE thread-local and its accessors (in_facade/set_in_facade)
are specific to the write hook's re-entrancy prevention. Moved from the
generic impl_facade! macro in mod.rs to write.rs where they belong.

The generic impl_facade! no longer has IN_FACADE logic — it keeps the
state-transition-before-logging reorder for the preemption fix, while
write.rs handles its own re-entrancy guard privately.

Agent-Logs-Url: https://github.com/acl-dev/open-coroutine/sessions/481d5b61-d175-4f75-ade3-a6f0b5511a71

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

Author: Copilot

core/src/syscall/unix/mod.rs

@@ -2,25 +2,6 @@ use dashmap::DashMap;
 use once_cell::sync::Lazy;
 use std::ffi::c_int;
 
-//防止重入：info!()/error!()内部会调用write()，如果write被hook了，
-//会导致无限递归或嵌套状态转换。当检测到重入时，直接调用内部系统调用跳过facade逻辑。
-// Re-entrancy guard: info!()/error!() internally call write(). If write is hooked,
-// this causes infinite recursion or nested state transitions that corrupt coroutine state.
-// When re-entrancy is detected, bypass the facade and call the inner syscall directly.
-thread_local! {
-    static IN_FACADE: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
-}
-
-#[inline]
-pub fn in_facade() -> bool {
-    IN_FACADE.get()
-}
-
-#[inline]
-pub fn set_in_facade(val: bool) {
-    IN_FACADE.set(val);
-}
-
 macro_rules! impl_syscall {
     (
         $facade_struct_name:ident, $iocp_struct_name: ident, $nio_struct_name: ident, $raw_struct_name: ident,
@@ -116,9 +97,6 @@ macro_rules! impl_facade {
                 fn_ptr: Option<&extern "C" fn($($arg_type),*) -> $result>,
                 $($arg: $arg_type),*
             ) -> $result {
-                if $crate::syscall::in_facade() {
-                    return self.inner.$syscall(fn_ptr, $($arg, )*);
-                }
                 let syscall = $crate::common::constants::SyscallName::$syscall;
                 //先转换状态再记录日志：co.syscall(Executing)会通过on_state_changed
                 //移除MonitorListener的NOTIFY_NODE，使monitor不再发送SIGURG。
@@ -129,7 +107,6 @@ macro_rules! impl_facade {
                 // 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);
                 if let Some(co) = $crate::scheduler::SchedulableCoroutine::current() {
                     let new_state = $crate::common::constants::SyscallState::Executing;
                     if co.syscall((), syscall, new_state).is_err() {
@@ -139,16 +116,13 @@ 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);
                 if let Some(co) = $crate::scheduler::SchedulableCoroutine::current() {
                     if co.running().is_err() {
                         $crate::error!("{} change to running state failed !", co.name());
                     }
                 }
                 $crate::info!("exit syscall {} {:?} {}", syscall, r, std::io::Error::last_os_error());
-                $crate::syscall::set_in_facade(false);
                 r
             }
         }

core/src/syscall/unix/write.rs

@@ -1,6 +1,25 @@
 use libc::{size_t, ssize_t};
 use std::ffi::{c_int, c_void};
 
+//防止重入：info!()/error!()内部会调用write()，如果write被hook了，
+//会导致无限递归或嵌套状态转换。当检测到重入时，直接调用内部系统调用跳过facade逻辑。
+// Re-entrancy guard: info!()/error!() internally call write(). If write is hooked,
+// this causes infinite recursion or nested state transitions that corrupt coroutine state.
+// When re-entrancy is detected, bypass the facade and call the inner syscall directly.
+thread_local! {
+    static IN_FACADE: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+}
+
+#[inline]
+fn in_facade() -> bool {
+    IN_FACADE.get()
+}
+
+#[inline]
+fn set_in_facade(val: bool) {
+    IN_FACADE.set(val);
+}
+
 trait WriteSyscall {
     extern "C" fn write(
         &self,
@@ -43,12 +62,12 @@ impl<I: WriteSyscall> WriteSyscall for WriteSyscallFacade<I> {
         // when already inside a facade (re-entrancy guard)
         if fd == libc::STDOUT_FILENO
             || fd == libc::STDERR_FILENO
-            || crate::syscall::in_facade()
+            || in_facade()
         {
             return self.inner.write(fn_ptr, fd, buf, len);
         }
         let syscall = crate::common::constants::SyscallName::write;
-        crate::syscall::set_in_facade(true);
+        set_in_facade(true);
         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,16 +77,16 @@ impl<I: WriteSyscall> WriteSyscall for WriteSyscallFacade<I> {
             }
         }
         crate::info!("enter syscall {}", syscall);
-        crate::syscall::set_in_facade(false);
+        set_in_facade(false);
         let r = self.inner.write(fn_ptr, fd, buf, len);
-        crate::syscall::set_in_facade(true);
+        set_in_facade(true);
         if let Some(co) = crate::scheduler::SchedulableCoroutine::current() {
             if co.running().is_err() {
                 crate::error!("{} change to running state failed !", co.name());
             }
         }
         crate::info!("exit syscall {} {:?} {}", syscall, r, std::io::Error::last_os_error());
-        crate::syscall::set_in_facade(false);
+        set_in_facade(false);
         r
     }
 }