[C语言] 安全的信号处理：Self-Pipe技巧

Wed, Jul 23 2025 23:09:50 KST

在使用C/C++为Linux/Unix环境开发服务器或守护进程时，有一个不可避免的难题，那就是“信号(signal)”。无论是通过 Ctrl + C (SIGINT) 终止程序，还是使用 kill 命令指示特定操作，信号都是从进程外部异步发生的强大事件。

问题在于，尽管信号功能强大，但安全地处理它却异常棘手。您是否曾在信号处理器中使用 printf 或 malloc，然后程序因无法解释的原因卡死或崩溃？这是因为忽略了 async-signal-safe（异步信号安全）这一重要概念。

本文将探讨信号处理器为何危险，并利用经典的“Self-Pipe Trick”（自管道技巧）来解决此问题，用C语言实现一个稳定且可复用的信号处理模块。

症结所在：异步信号安全 (Async-Signal-Safety)

信号处理器函数可以随时中断程序的正常流程并执行。想象一下，如果 main 函数在调用 malloc 并成功获取堆内存锁（lock）的那一刻，一个信号恰好抵达，会发生什么？

main 函数在 malloc 内部获取了堆内存的锁。
信号发生，操作系统中断 main 的执行，并调用已注册的信号处理器。
如果信号处理器为了记录日志而调用 printf 或 malloc，这些函数也会尝试在内部再次获取堆内存的锁。
然而，锁已经被 main 函数持有，因此信号处理器将陷入无限等待。这种情况被称为 死锁 (deadlock)。

正因为无法预知处理器何时介入，所以在处理器内部，我们必须只使用那些可重入（re-entrant）且即使执行被中断也依然安全的函数，即保证为 async-signal-safe 的函数。只有极少数的系统调用符合此标准，如 write、read、close、_exit 等。而我们常用的大多数标准库函数，如 printf、malloc、free、fopen 等，都是不安全的。

解决方案：Self-Pipe Trick

那么，需要复杂处理的信号该如何应对？答案是：“在信号处理器中只做最少的工作，将实际处理逻辑转移到安全的’主程序上下文’中。” Self-Pipe Trick 是实现这一思想最经典的方法。

其工作原理如下：

创建管道：程序启动时，创建一个可以向自身写入数据的管道（pipe）。管道由一对文件描述符（fd）组成：一个用于读取（fd[0]），一个用于写入（fd[1]）。
注册最小化的处理器：实际的信号处理器只负责将信号编号 write 到管道的写入端fd（fd[1]）。因为 write 是 async-signal-safe 函数，所以此操作是安全的。
在事件循环中监视：主程序利用 poll、select、epoll 等I/O多路复用函数来监视管道的读取端fd（fd[0]）。当信号发生，处理器向管道写入数据时，poll 会通知主程序该fd已“准备好读取”。
安全地处理：主循环从管道中 read 出信号编号，并调用预定义的相应回调函数来处理信号。整个过程都在安全的’主程序上下文’中执行，而非在信号处理器上下文中。

最终，这种方法将信号的异步事件转换为了文件描述符的I/O同步事件，使其能与网络套接字等其他事件源一同被统一处理。

可复用的C代码实现

现在，我们来看看基于此概念设计的可复用信号处理模块。

1. 头文件：`signal_handler.h`

首先，我们定义对外暴露的API。用户仅通过此头文件就应能理解库的功能。

#ifndef SIGNAL_HANDLER_H
#define SIGNAL_HANDLER_H

#include <signal.h>

// 用户自定义信号处理器函数指针类型
typedef void (*SignalHandler)(int signo);

// 初始化信号处理机制
int signal_init(void);

// 释放信号处理机制的资源
void signal_fini(void);

//为特定信号(signo)设置处理行为(handler)
int signal_set_action(int signo, SignalHandler handler);

// 返回用于接收信号事件的管道的读取端fd
int signal_get_fd(void);

// 从管道读取信号并调用已注册的处理器
int signal_dispatch(void);

#endif // SIGNAL_HANDLER_H

2. 实现文件：`signal_handler.c`

这里是 Self-Pipe Trick 核心逻辑的实现部分。

#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include "signal_handler.h"

static SignalHandler signal_handlers[NSIG];
static int pipe_fds[2] = {-1, -1};

// [核心] 该主处理器只负责将信号编号写入管道
static void master_signal_handler(int signo, siginfo_t *info, void *context) {
    (void)info;
    (void)context;
    // 只使用 async-signal-safe 函数 write()
    ssize_t written;
    do {
        written = write(pipe_fds[1], &signo, sizeof(signo));
    } while (written == -1 && errno == EINTR);
}

int signal_init(void) {
    if (pipe2(pipe_fds, O_CLOEXEC | O_NONBLOCK) == -1) {
        perror("pipe2");
        return -1;
    }
    for (int i = 0; i < NSIG; ++i) {
        signal_handlers[i] = NULL;
    }
    return 0;
}

void signal_fini(void) {
    if (pipe_fds[0] != -1) close(pipe_fds[0]);
    if (pipe_fds[1] != -1) close(pipe_fds[1]);
}

int signal_set_action(int signo, SignalHandler handler) {
    if (signo < 1 || signo >= NSIG) return -1;

    signal_handlers[signo] = handler;
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sigemptyset(&sa.sa_mask);

    if (handler == SIG_DFL || handler == SIG_IGN) {
        sa.sa_handler = handler;
        sa.sa_flags = 0;
    } else {
        sa.sa_sigaction = master_signal_handler;
        sa.sa_flags = SA_SIGINFO | SA_RESTART;
    }

    if (sigaction(signo, &sa, NULL) == -1) {
        perror("sigaction");
        return -1;
    }
    return 0;
}

int signal_get_fd(void) {
    return pipe_fds[0];
}

int signal_dispatch(void) {
    int signo;
    ssize_t bytes_read;
    int dispatched_count = 0;

    while ((bytes_read = read(pipe_fds[0], &signo, sizeof(signo))) > 0) {
        if (bytes_read == sizeof(signo)) {
            SignalHandler handler = signal_handlers[signo];
            if (handler && handler != SIG_DFL && handler != SIG_IGN) {
                handler(signo);
                dispatched_count++;
            }
        }
    }
    return dispatched_count;
}

3. 使用示例：`main.c`

现在，我们使用创建的模块来编写主应用程序。可以看到，程序使用 poll 来等待信号事件。

#include <stdio.h>
#include <unistd.h>
#include <poll.h>
#include <stdlib.h>
#include "signal_handler.h"

volatile sig_atomic_t running = 1;

// 针对 SIGINT (Ctrl+C) 的自定义处理器
void handle_sigint(int signo) {
    printf("\nCaught signal %d (SIGINT). Shutting down...\n", signo);
    running = 0;
}

// 针对 SIGTERM 的自定义处理器
void handle_sigterm(int signo) {
    printf("\nCaught signal %d (SIGTERM). Shutting down gracefully...\n", signo);
    running = 0;
}

int main(void) {
    printf("Starting... PID: %d\n", getpid());

    if (signal_init() != 0) {
        return EXIT_FAILURE;
    }

    signal_set_action(SIGINT, handle_sigint);
    signal_set_action(SIGTERM, handle_sigterm);
    signal_set_action(SIGPIPE, SIG_IGN); // 忽略 SIGPIPE

    struct pollfd pfd;
    pfd.fd = signal_get_fd();
    pfd.events = POLLIN;

    while (running) {
        printf("Waiting for a signal or other events...\n");
        int ret = poll(&pfd, 1, -1); // 无限期等待

        if (ret > 0 && (pfd.revents & POLLIN)) {
            printf("Signal event detected. Dispatching...\n");
            signal_dispatch();
        }
    }

    printf("Cleaning up and exiting.\n");
    signal_fini();
    return EXIT_SUCCESS;
}

结语

Self-Pipe Trick 是一个非常强大且经过验证的信号安全处理方法。通过该技术，我们可以获得以下好处：

安全性：从根本上防止因调用非 async-signal-safe 函数而导致的死锁和竞争条件。
集成性：将信号事件视作文件I/O事件，从而能干净地集成到复杂的应用程序事件循环中。
简洁性：极大地简化了信号处理器的职责，提高了代码的可预测性。

当然，在最新的Linux内核中，也提供了一个更简洁的替代方案 signalfd()，它在内核级别实现了此技术。然而，理解 Self-Pipe Trick 的原理，对于在所有POSIX系统上设计健壮的软件来说，仍然是极其重要的基石。

希望通过安全地处理信号，能让您的下一个项目更加稳固。