修复std::fstream无法hook到close的问题

Author: yuyangzi

libgo/disable_hook/disable_hook.cpp

@@ -49,6 +49,7 @@ setsockopt_t setsockopt_f = &setsockopt;
 dup_t dup_f = &dup;
 dup2_t dup2_f = &dup2;
 dup3_t dup3_f = &dup3;
+fclose_t fclose_f = &fclose;
 
 } //extern "C"
 

libgo/linux/fd_context.cpp

@@ -137,9 +137,8 @@ bool FileDescriptorCtx::closed()
 {
     return closed_;
 }
-int FileDescriptorCtx::close(bool call_syscall)
+int FileDescriptorCtx::close_without_lock(bool call_syscall)
 {
-    std::unique_lock<mutex_t> lock(lock_);
     if (closed()) return 0;
     DebugPrint(dbg_fd_ctx, "close fd(%d) [%p] call_syscall:%d", fd_, this, (int)call_syscall);
     closed_ = true;
@@ -169,6 +168,19 @@ int FileDescriptorCtx::close(bool call_syscall)
     }
 
     return ret;
+
+}
+int FileDescriptorCtx::close(bool call_syscall)
+{
+    std::unique_lock<mutex_t> lock(lock_);
+    return close_without_lock(call_syscall);
+}
+int FileDescriptorCtx::fclose(FILE* fp)
+{
+    std::unique_lock<mutex_t> lock(lock_);
+    int ret = fclose_f(fp);
+    close_without_lock(false);
+    return ret;
 }
 void FileDescriptorCtx::set_user_nonblock(bool b)
 {
@@ -483,6 +495,24 @@ int FdManager::close(int fd, bool call_syscall)
     pptr = nullptr;
     return ret;
 }
+int FdManager::fclose(FILE* fp)
+{
+    if (!fp) return 0;
+    int fd = fileno(fp);
+    if (fd < 0) return 0;
+
+    FdPair & fpair = get_pair(fd);
+    std::unique_lock<LFLock> lock(fpair.second);
+    FdCtxPtr* & pptr = fpair.first;
+    if (!pptr) {
+        return fclose_f(fp);
+    }
+
+    int ret = (*pptr)->fclose(fp);
+    delete pptr;
+    pptr = nullptr;
+    return ret;
+}
 bool FdManager::dup(int src, int dst)
 {
     FdPair & src_fpair = get_pair(src);

libgo/linux/fd_context.h

@@ -76,6 +76,7 @@ class FileDescriptorCtx
     bool is_epoll();
     bool closed();
     int close(bool call_syscall);
+    int fclose(FILE* fp);
 
     void set_user_nonblock(bool b);
     bool user_nonblock();
@@ -118,6 +119,8 @@ class FileDescriptorCtx
 
     int GetEpollFd();
 
+    int close_without_lock(bool call_syscall);
+
     // debugger interface
 public:
     std::string GetDebugInfo();
@@ -169,6 +172,8 @@ class FdManager
 
     int close(int fd, bool call_syscall = true);
 
+    int fclose(FILE* fp);
+
 private:
     FdPair & get_pair(int fd);
 

libgo/linux/linux_glibc_hook.cpp

@@ -593,6 +593,7 @@ setsockopt_t setsockopt_f = NULL;
 dup_t dup_f = NULL;
 dup2_t dup2_f = NULL;
 dup3_t dup3_f = NULL;
+fclose_t fclose_f = NULL;
 
 int connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
 {
@@ -1110,6 +1111,12 @@ int dup3(int oldfd, int newfd, int flags)
     return ret;
 }
 
+int fclose(FILE* fp)
+{
+    if (!fclose_f) coroutine_hook_init();
+    return FdManager::getInstance().fclose(fp);
+}
+
 #if WITH_CARES
 struct hostent* co_gethostbyname2(const char *name, int af)
 {
@@ -1267,6 +1274,7 @@ extern int __dup(int);
 extern int __dup2(int, int);
 extern int __dup3(int, int, int);
 extern int __usleep(useconds_t usec);
+extern int __new_fclose(FILE *fp);
 
 // 某些版本libc.a中没有__usleep.
 __attribute__((weak))
@@ -1313,6 +1321,7 @@ void coroutine_hook_init()
     dup_f = (dup_t)dlsym(RTLD_NEXT, "dup");
     dup2_f = (dup2_t)dlsym(RTLD_NEXT, "dup2");
     dup3_f = (dup3_t)dlsym(RTLD_NEXT, "dup3");
+    fclose_f = (fclose_t)dlsym(RTLD_NEXT, "fclose");
 #else
     connect_f = &__connect;
     read_f = &__read;
@@ -1339,12 +1348,13 @@ void coroutine_hook_init()
     dup_f = &__dup;
     dup2_f = &__dup2;
     dup3_f = &__dup3;
+    fclose_f = &__new_fclose;
 #endif
 
     if (!connect_f || !read_f || !write_f || !readv_f || !writev_f || !send_f
             || !sendto_f || !sendmsg_f || !accept_f || !poll_f || !select_f
             || !sleep_f|| !usleep_f || !nanosleep_f || !close_f || !fcntl_f || !setsockopt_f
-            || !getsockopt_f || !dup_f || !dup2_f 
+            || !getsockopt_f || !dup_f || !dup2_f || !fclose_f
             // 老版本linux中没有dup3, 无需校验
             // || !dup3_f
             )

libgo/linux/linux_glibc_hook.h

@@ -84,6 +84,9 @@ extern dup2_t dup2_f;
 typedef int(*dup3_t)(int, int, int);
 extern dup3_t dup3_f;
 
+typedef int (*fclose_t)(FILE *fp);
+extern fclose_t fclose_f;
+
 // DNS by libcares
 // gethostent
 // gethostbyname

test/gtest_unit/CMakeLists.txt

@@ -28,7 +28,7 @@ add_subdirectory(${PROJECT_SOURCE_DIR}/../../third_party/gtest ${PROJECT_BINARY_
 aux_source_directory(${PROJECT_SOURCE_DIR} SRC_LIST)
 
 if (UNIX)
-    set(STATIC_LINK_ARG -Wl,--whole-archive -lpthread -Wl,--no-whole-archive -static)
+    set(STATIC_LINK_ARG -Wl,--whole-archive -lpthread -Wl,--no-whole-archive -static -static-libstdc++)
     set(LINK_ARGS libgo dl gtest_main gtest boost_coroutine boost_context boost_system boost_thread)
     if (WITH_CARES)
         set(LINK_ARGS ${LINK_ARGS} cares)

test/gtest_unit/fd_manager.cpp

@@ -0,0 +1,61 @@
+#include <iostream>
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include "coroutine.h"
+#include <poll.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/file.h>
+#include <fstream>
+#include <stdio.h>
+using namespace std;
+using namespace co;
+
+void foo()
+{
+//    int fd = open("/dev/null", O_WRONLY);
+//    write(fd, "1", 1);
+//    close(fd);
+
+    std::ofstream ofs("/dev/zero");
+    ofs << "123";
+    ofs.close();
+
+    int fds[2];
+    int res = socketpair(AF_LOCAL, SOCK_DGRAM, 0, fds);
+    EXPECT_EQ(res, 0);
+
+    pollfd pfd;
+    pfd.fd = fds[0];
+    pfd.events = POLLIN;
+    res = poll(&pfd, 1, 1000);
+    EXPECT_EQ(errno, 0);
+    EXPECT_EQ(res, 0);
+}
+
+void foo2()
+{
+    FILE * f = fopen("/dev/zero", "r");
+    fwrite("a", 1, 1, f);
+    fclose(f);
+
+    int fds[2];
+    int res = socketpair(AF_LOCAL, SOCK_DGRAM, 0, fds);
+    EXPECT_EQ(res, 0);
+
+    pollfd pfd;
+    pfd.fd = fds[0];
+    pfd.events = POLLIN;
+    res = poll(&pfd, 1, 1000);
+    EXPECT_EQ(errno, 0);
+    EXPECT_EQ(res, 0);
+}
+
+TEST(fdmanager, fdmanager)
+{
+    go foo;
+    co_sched.RunUntilNoTask();
+
+    go foo2;
+    co_sched.RunUntilNoTask();
+}