NPTL下使用vfork时，如何调用pthread_atfork注册的fork处理程序？

因为glibc未提供直接访问已注册pthread_atfork处理程序的公开接口，要在NPTL环境下让vfork触发这些处理程序，最可靠的方式是手动拦截并保存所有注册的处理函数，再在vfork前后主动调用。

方法一：封装/拦截pthread_atfork()保存处理程序 #

核心思路是拦截所有pthread_atfork调用，将注册的预处理（prepare）、父进程处理（parent）、子进程处理（child）函数存入自定义列表，之后在vfork流程中手动执行这些函数。

实现步骤 #

1. 定义结构体存储三组处理函数指针，维护全局链表保存所有注册项，用互斥锁保证线程安全。
2. 封装或hookpthread_atfork函数，每次注册时，既调用原生pthread_atfork，同时将函数存入自定义链表。
3. vfork前遍历链表执行所有预处理函数；vfork返回后，父进程执行父处理函数，子进程执行子处理函数。

代码示例（手动封装版） #

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

typedef struct AtforkHandler {
    void (*prepare)(void);
    void (*parent)(void);
    void (*child)(void);
    struct AtforkHandler *next;
} AtforkHandler;

static AtforkHandler *handler_list = NULL;
static pthread_mutex_t handler_mutex = PTHREAD_MUTEX_INITIALIZER;

// 封装pthread_atfork，同时保存处理程序
int my_pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)) {
    int ret = pthread_atfork(prepare, parent, child);
    if (ret != 0) return ret;

    pthread_mutex_lock(&handler_mutex);
    AtforkHandler *new_handler = malloc(sizeof(AtforkHandler));
    if (new_handler) {
        new_handler->prepare = prepare;
        new_handler->parent = parent;
        new_handler->child = child;
        new_handler->next = handler_list;
        handler_list = new_handler;
    }
    pthread_mutex_unlock(&handler_mutex);
    return ret;
}

// 执行所有prepare处理程序（遵循原生逆序执行逻辑）
void call_atfork_prepare(void) {
    pthread_mutex_lock(&handler_mutex);
    AtforkHandler *curr = handler_list;
    while (curr) {
        if (curr->prepare) curr->prepare();
        curr = curr->next;
    }
    pthread_mutex_unlock(&handler_mutex);
}

// 执行所有parent处理程序（遵循原生顺序执行逻辑）
void call_atfork_parent(void) {
    pthread_mutex_lock(&handler_mutex);
    // 用临时链表反转顺序，保证先注册的先执行
    AtforkHandler *reverse = NULL;
    AtforkHandler *curr = handler_list;
    while (curr) {
        AtforkHandler *next = curr->next;
        curr->next = reverse;
        reverse = curr;
        curr = next;
    }
    curr = reverse;
    while (curr) {
        if (curr->parent) curr->parent();
        curr = curr->next;
    }
    pthread_mutex_unlock(&handler_mutex);
}

// 执行所有child处理程序（遵循原生顺序执行逻辑）
void call_atfork_child(void) {
    pthread_mutex_lock(&handler_mutex);
    AtforkHandler *reverse = NULL;
    AtforkHandler *curr = handler_list;
    while (curr) {
        AtforkHandler *next = curr->next;
        curr->next = reverse;
        reverse = curr;
        curr = next;
    }
    curr = reverse;
    while (curr) {
        if (curr->child) curr->child();
        curr = curr->next;
    }
    pthread_mutex_unlock(&handler_mutex);
}

// 测试用处理程序
void prepare_func(void) {
    write(STDOUT_FILENO, "Running prepare handler\n", 23);
}

void parent_func(void) {
    write(STDOUT_FILENO, "Running parent handler\n", 22);
}

void child_func(void) {
    write(STDOUT_FILENO, "Running child handler\n", 22);
}

int main() {
    my_pthread_atfork(prepare_func, parent_func, child_func);

    call_atfork_prepare();
    pid_t pid = vfork();
    if (pid > 0) {
        call_atfork_parent();
        wait(NULL);
    } else if (pid == 0) {
        call_atfork_child();
        execl("/bin/echo", "echo", "Child exec done", NULL);
        _exit(1);
    }

    return 0;
}

进阶：用LD_PRELOAD全局拦截 #

如果需要捕获第三方库调用的pthread_atfork，可通过LD_PRELOAD注入共享库全局hook：

#define _GNU_SOURCE
#include <dlfcn.h>
#include <pthread.h>
#include <stdlib.h>

typedef struct AtforkHandler {
    void (*prepare)(void);
    void (*parent)(void);
    void (*child)(void);
    struct AtforkHandler *next;
} AtforkHandler;

static AtforkHandler *handler_list = NULL;
static pthread_mutex_t handler_mutex = PTHREAD_MUTEX_INITIALIZER;
static int (*real_pthread_atfork)(void (*)(void), void (*)(void), void (*)(void)) = NULL;

__attribute__((constructor)) void init_hook(void) {
    real_pthread_atfork = dlsym(RTLD_NEXT, "pthread_atfork");
}

int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)) {
    if (!real_pthread_atfork) return -1;
    int ret = real_pthread_atfork(prepare, parent, child);
    if (ret != 0) return ret;

    pthread_mutex_lock(&handler_mutex);
    AtforkHandler *new_handler = malloc(sizeof(AtforkHandler));
    if (new_handler) {
        new_handler->prepare = prepare;
        new_handler->parent = parent;
        new_handler->child = child;
        new_handler->next = handler_list;
        handler_list = new_handler;
    }
    pthread_mutex_unlock(&handler_mutex);
    return ret;
}

// 导出手动调用函数
void call_atfork_prepare(void) {
    // 实现同手动封装版
    pthread_mutex_lock(&handler_mutex);
    AtforkHandler *curr = handler_list;
    while (curr) {
        if (curr->prepare) curr->prepare();
        curr = curr->next;
    }
    pthread_mutex_unlock(&handler_mutex);
}

void call_atfork_parent(void) {
    // 实现同手动封装版
    pthread_mutex_lock(&handler_mutex);
    AtforkHandler *reverse = NULL;
    AtforkHandler *curr = handler_list;
    while (curr) {
        AtforkHandler *next = curr->next;
        curr->next = reverse;
        reverse = curr;
        curr = next;
    }
    curr = reverse;
    while (curr) {
        if (curr->parent) curr->parent();
        curr = curr->next;
    }
    pthread_mutex_unlock(&handler_mutex);
}

void call_atfork_child(void) {
    // 实现同手动封装版
    pthread_mutex_lock(&handler_mutex);
    AtforkHandler *reverse = NULL;
    AtforkHandler *curr = handler_list;
    while (curr) {
        AtforkHandler *next = curr->next;
        curr->next = reverse;
        reverse = curr;
        curr = next;
    }
    curr = reverse;
    while (curr) {
        if (curr->child) curr->child();
        curr = curr->next;
    }
    pthread_mutex_unlock(&handler_mutex);
}

编译共享库：

gcc -shared -fPIC -o atfork_hook.so atfork_hook.c -ldl -pthread

运行主程序时注入：

LD_PRELOAD=./atfork_hook.so ./your_program

关键注意事项 #

• vfork子进程限制：子进程共享父进程地址空间，不能调用malloc、printf等会修改内存的函数，child处理程序必须极简，执行后立即调用exec或_exit。
• 执行顺序：严格遵循原生pthread_atfork逻辑：prepare逆序执行（最后注册的先执行），parent和child顺序执行（先注册的先执行）。
• 线程安全：对处理程序链表的操作必须加互斥锁，避免多线程注册时的竞态条件。
• 内存泄漏：长期运行的程序可在退出时清理链表内存，进程退出时操作系统会自动回收内存，通常无需额外处理。

内容的提问来源于stack exchange，提问作者joepol