Question

我有一个小的测试代码atfork_demo.c：

#include <stdio.h>
#include <pthread.h>

void hello_from_fork_prepare() {
    printf("Hello from atfork prepare.\n");
    fflush(stdout);
}

void register_hello_from_fork_prepare() {
    pthread_atfork(&hello_from_fork_prepare, 0, 0);
}

现在，我用两种不同的方式编译它：

gcc -shared -fPIC atfork_demo.c -o atfork_demo1.so
gcc -shared -fPIC atfork_demo.c -o atfork_demo2.so -lpthread

我的演示主atfork_demo_main.c就是这样：

#include <dlfcn.h>
#include <stdio.h>
#include <unistd.h>

int main(int argc, const char** argv) {
    if(argc <= 1) {
        printf("usage: ... lib.so\n");
        return 1;
    }
    void* plib = dlopen("libpthread.so.0", RTLD_NOW|RTLD_GLOBAL);
    if(!plib) {
        printf("cannot load pthread, error %s\n", dlerror());
        return 1;
    }
    void* lib = dlopen(argv[1], RTLD_LAZY);
    if(!lib) {
        printf("cannot load %s, error %s\n", argv[1], dlerror());
        return 1;
    }
    void (*reg)();
    reg = dlsym(lib, "register_hello_from_fork_prepare");
    if(!reg) {
        printf("did not found func, error %s\n", dlerror());
        return 1;
    }
    reg();
    fork();
}

我编译的是这样的：

gcc atfork_demo_main.c -o atfork_demo_main.exec -ldl

现在，我还有另一个小型演示atfork_patch.c，我要覆盖pthread_atfork：

#include <stdio.h>
int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)) {
  printf("Ignoring pthread_atfork call!\n");
  fflush(stdout);
  return 0;
}

我编译的是这样的：

gcc -shared -O2 -fPIC patch_atfork.c -o patch_atfork.so

然后我设置LD_PRELOAD=./atfork_patch.so，然后执行以下两个调用：

./atfork_demo_main.exec ./atfork_demo1.so
./atfork_demo_main.exec ./atfork_demo2.so

在第一种情况下，LD_PRELOAD - 覆盖pthread_atfork工作，而在第二种情况下，它没有。我得到了输出：

Ignoring pthread_atfork call!
Hello from atfork prepare.

所以，现在回答问题：

为什么在第二种情况下不起作用？
如何在第二种情况下使其工作，即也覆盖它？在我的实际用例中，atfork_demo是一些我无法改变的库。我也无法更改atfork_demo_main但我可以加载任何其他代码。如果我可以在atfork_patch中进行一些更改，我更愿意这样做。

如果您还使用LD_DEBUG=all，还会获得更多调试输出。对于第二种情况，可能有点有趣：

   841:     symbol=__register_atfork;  lookup in file=./atfork_demo_main.exec [0]
   841:     symbol=__register_atfork;  lookup in file=./atfork_patch_extended.so [0]
   841:     symbol=__register_atfork;  lookup in file=/lib/x86_64-linux-gnu/libdl.so.2 [0]
   841:     symbol=__register_atfork;  lookup in file=/lib/x86_64-linux-gnu/libc.so.6 [0]
   841:     binding file ./atfork_demo2.so [0] to /lib/x86_64-linux-gnu/libc.so.6 [0]: normal symbol `__register_atfork' [GLIBC_2.3.2]

因此，它会搜索符号__register_atfork。我已将其添加到atfork_patch_extended.so，但它找不到它并使用libc代替它。如何找到并使用我的__register_atfork？

作为旁注，我的主要目标是在调用fork()时忽略atfork处理程序，但这不是问题，而是here。对此的一个解决方案似乎有效，就是通过以下方式覆盖fork()：

pid_t fork(void) {
  return syscall(SYS_clone, SIGCHLD, 0);
}

Answer 1

在回答这个问题之前，我会强调 这对于任何生产应用来说都是一个非常糟糕的想法 。

如果您正在使用第三方库来实施此类限制，那么请考虑另一种解决方案，例如尽早分支以维护“帮助”流程，并在您和它...然后，当您需要致电exec()时，您可以代表您请求它完成工作（fork()，exec()）。

修补或以其他方式支持系统调用（如pthread_atfork()）的服务只是在寻找麻烦（错过事件，内存泄漏，崩溃等等）。

正如@Sergio指出的那样，pthread_atfork()实际上内置于atfork_demo2.so，所以你无法做任何事情来覆盖它......但是检查pthread_atfork()的反汇编/来源给出了关于如何实现你的要求，你得到了一个不错的暗示：

0000000000000830 <__pthread_atfork>:
 830:   48 8d 05 f9 07 20 00    lea    0x2007f9(%rip),%rax        # 201030 <__dso_handle>
 837:   48 85 c0                test   %rax,%rax
 83a:   74 0c                   je     848 <__pthread_atfork+0x18>
 83c:   48 8b 08                mov    (%rax),%rcx
 83f:   e9 6c fe ff ff          jmpq   6b0 <__register_atfork@plt>
 844:   0f 1f 40 00             nopl   0x0(%rax)
 848:   31 c9                   xor    %ecx,%ecx
 84a:   e9 61 fe ff ff          jmpq   6b0 <__register_atfork@plt>

或来源（来自here）：

int
pthread_atfork (void (*prepare) (void),
        void (*parent) (void),
        void (*child) (void))
{
  return __register_atfork (prepare, parent, child, &__dso_handle == NULL ? NULL : __dso_handle);
}

正如您所看到的，pthread_atfork()除了致电__register_atfork()之外什么也没做什么......所以请改为补充！

atfork_patch.c的内容现在变为:(使用__register_atfork()的原型，来自here / here）

#include <stdio.h>

int __register_atfork (void (*prepare) (void), void (*parent) (void),
                       void (*child) (void), void *dso_handle) {
  printf("Ignoring pthread_atfork call!\n");
  fflush(stdout);
  return 0;
}

这适用于两个演示：

$ LD_PRELOAD=./atfork_patch.so ./atfork_demo_main.exec ./atfork_demo1.so
Ignoring pthread_atfork call!
$ LD_PRELOAD=./atfork_patch.so ./atfork_demo_main.exec ./atfork_demo2.so
Ignoring pthread_atfork call!

Answer 2

它不适用于第二种情况，因为没有什么可以覆盖。您的第二个库与pthread库静态链接：

$ readelf --symbols atfork_demo1.so | grep pthread_atfork
     7: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND pthread_atfork
    54: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND pthread_atfork
$ readelf --symbols atfork_demo2.so | grep pthread_atfork
    41: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS pthread_atfork.c
    47: 0000000000000830    31 FUNC    LOCAL  DEFAULT   12 __pthread_atfork
    49: 0000000000000830    31 FUNC    LOCAL  DEFAULT   12 pthread_atfork

因此，每次都会使用本地pthread_atfork，无论LD_PRELOAD还是其他任何已加载的库。

如何克服这个问题？看起来像所描述的配置是不可能的，因为您无论如何都需要修改atfork_demo库或主要可执行文件。

LD_PRELOAD和链接

2 个答案: