refactor: use impl_hook! for write and implement special facade in write.rs

Move the stdout/stderr bypass logic from a custom hook in hook/src/syscall/unix.rs
to a specialized facade in core/src/syscall/unix/write.rs per maintainer feedback.

- hook/src/syscall/unix.rs: Use standard impl_hook!(WRITE, write(...)) macro
- core/src/syscall/unix/write.rs: Replace generic impl_facade! with a custom
  WriteSyscallFacade that bypasses state transitions and logging for:
  - stdout(fd=1)/stderr(fd=2) writes (triggered by logging framework)
  - writes during in_facade() re-entrancy (prevents recursive facade entry)

Agent-Logs-Url: https://github.com/acl-dev/open-coroutine/sessions/6a64e463-d9fb-4d2f-9e86-284f579ee741

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

Author: Copilot

core/src/syscall/unix/write.rs

@@ -15,9 +15,62 @@ impl_syscall!(WriteSyscallFacade, IoUringWriteSyscall, NioWriteSyscall, RawWrite
     write(fd: c_int, buf: *const c_void, len: size_t) -> ssize_t
 );
 
-impl_facade!(WriteSyscallFacade, WriteSyscall,
-    write(fd: c_int, buf: *const c_void, len: size_t) -> ssize_t
-);
+//write的facade需要特殊处理：stdout/stderr的write由日志框架(tracing)触发，
+//必须跳过状态转换和日志记录直接调用内层，否则facade内部的info!()会再次
+//触发write导致stdout RefCell重复借用（无限递归）。
+// The write facade needs special handling: writes to stdout/stderr are
+// triggered by the logging framework (tracing). They must skip state
+// transitions and logging, going directly to the inner layer. Otherwise
+// the facade's info!() would re-trigger write, causing stdout's RefCell
+// to be double-borrowed (infinite recursion).
+#[repr(C)]
+#[derive(Debug, Default)]
+struct WriteSyscallFacade<I: WriteSyscall> {
+    inner: I,
+}
+
+impl<I: WriteSyscall> WriteSyscall for WriteSyscallFacade<I> {
+    extern "C" fn write(
+        &self,
+        fn_ptr: Option<&extern "C" fn(c_int, *const c_void, size_t) -> ssize_t>,
+        fd: c_int,
+        buf: *const c_void,
+        len: size_t,
+    ) -> ssize_t {
+        // stdout(1)/stderr(2)由日志框架触发，或已在facade内部（防重入），
+        // 直接调用内层跳过状态转换和日志记录
+        // Bypass state transitions for stdout/stderr (logging fds) and
+        // when already inside a facade (re-entrancy guard)
+        if fd == libc::STDOUT_FILENO
+            || fd == libc::STDERR_FILENO
+            || crate::syscall::in_facade()
+        {
+            return self.inner.write(fn_ptr, fd, buf, len);
+        }
+        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() {
+                crate::error!("{} change to syscall {} {} failed !",
+                    co.name(), syscall, new_state
+                );
+            }
+        }
+        crate::syscall::set_in_facade(false);
+        let r = self.inner.write(fn_ptr, fd, buf, len);
+        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
+    }
+}
 
 impl_io_uring_write!(IoUringWriteSyscall, WriteSyscall,
     write(fd: c_int, buf: *const c_void, len: size_t) -> ssize_t

hook/src/syscall/unix.rs

@@ -82,41 +82,8 @@ impl_hook!(RENAMEAT2, renameat2(olddirfd: c_int, oldpath: *const c_char, newdirf
 // NOTE: unhook poll due to mio's poller
 // impl_hook!(POLL, poll(fds: *mut pollfd, nfds: nfds_t, timeout: c_int) -> c_int);
 
-// NOTE: unhook write/pthread_mutex_lock/pthread_mutex_unlock due to stack overflow or bug
+// NOTE: unhook pthread_mutex_lock/pthread_mutex_unlock due to bug
 // impl_hook!(PTHREAD_MUTEX_LOCK, pthread_mutex_lock(lock: *mut pthread_mutex_t) -> c_int);
 // impl_hook!(PTHREAD_MUTEX_UNLOCK, pthread_mutex_unlock(lock: *mut pthread_mutex_t) -> c_int);
 
-//write需要特殊的hook实现：stdout/stderr的write由日志框架触发，
-//必须绕过facade直接调用原始write，否则facade内部的info!()会再次
-//触发write导致stdout RefCell重复借用。其他fd正常走facade。
-// write needs a custom hook: writes to stdout/stderr are triggered by
-// the logging framework. They must bypass the facade and call raw write
-// directly; otherwise the facade's info!() would re-trigger write,
-// causing stdout's RefCell to be double-borrowed. Other fds go through
-// the facade normally.
-#[no_mangle]
-pub extern "C" fn write(fd: c_int, buf: *const c_void, count: size_t) -> ssize_t {
-    static WRITE: once_cell::sync::Lazy<extern "C" fn(c_int, *const c_void, size_t) -> ssize_t> =
-        once_cell::sync::Lazy::new(|| unsafe {
-            let symbol = std::ffi::CString::new("write")
-                .unwrap_or_else(|_| panic!("can not transfer \"write\" to CString"));
-            let ptr = libc::dlsym(libc::RTLD_NEXT, symbol.as_ptr());
-            assert!(!ptr.is_null(), "syscall \"write\" not found !");
-            std::mem::transmute(ptr)
-        });
-    let fn_ptr = once_cell::sync::Lazy::force(&WRITE);
-    // stdout(1)/stderr(2)的write由日志框架触发，必须绕过facade
-    // Bypass facade for stdout/stderr — these are logging fds
-    if fd == libc::STDOUT_FILENO || fd == libc::STDERR_FILENO
-        || open_coroutine_core::syscall::in_facade()
-    {
-        return (fn_ptr)(fd, buf, count);
-    }
-    if crate::hook()
-        || open_coroutine_core::scheduler::SchedulableCoroutine::current().is_some()
-        || cfg!(feature = "ci")
-    {
-        return open_coroutine_core::syscall::write(Some(fn_ptr), fd, buf, count);
-    }
-    (fn_ptr)(fd, buf, count)
-}
+impl_hook!(WRITE, write(fd: c_int, buf: *const c_void, count: size_t) -> ssize_t);