Linux 信号机制：从内核投递到用户态捕获的完整链路解析

一、异步中断下的程序失控——信号为何是系统编程中最易踩坑的机制

信号（Signal）是 Unix/Linux 系统中最古老的进程间通信机制之一，也是唯一一种异步通知手段。当内核向进程发送 SIGSEGV 时，进程可能在执行任何一条指令的中途被打断；当用户按下 Ctrl+C 触发 SIGINT 时，进程可能正持有互斥锁、正处在堆内存分配的中间状态、或者正修改全局数据结构。

这种"随时可能被打断"的特性，使信号处理成为系统编程中最容易产生竞态条件和隐蔽 Bug 的区域。一个典型的生产事故场景：信号处理函数中调用了 malloc()，而信号恰好发生在主线程的 malloc() 执行过程中——此时堆的自旋锁已被持有，信号处理函数再次请求堆锁，死锁发生。

理解信号从内核投递到用户态捕获的完整链路，是写出信号安全代码的前提。这不是一个可以靠"记住几条规则"就绕过去的知识点，它涉及内核中断处理、进程上下文切换、用户态栈帧构造等多个底层机制。

二、信号的生命周期——从内核发送到用户态返回的全链路追踪

一个信号从产生到处理完毕，需要经历"发送-挂起-投递-返回"四个阶段。每个阶段都涉及内核态与用户态的切换，以及进程上下文的保存与恢复。

sequenceDiagram
    participant K as 内核
    participant P as 目标进程

    Note over K,P: 阶段一：信号发送
    K->>K: 产生信号（硬件异常/kill系统调用/内核事件）
    K->>K: 查找目标进程的 task_struct
    K->>K: 设置 pending 信号位图（sigset_t）
    K->>K: 唤醒可中断睡眠的进程

    Note over K,P: 阶段二：信号挂起
    K->>K: 进程被调度运行前检查 pending 信号
    K->>K: 逐个检查未屏蔽的信号（从低编号到高编号）
    K->>K: 确定下一个要投递的信号编号

    Note over K,P: 阶段三：信号投递
    K->>K: 保存当前用户态寄存器到 pt_regs
    K->>K: 在用户态栈上构造 sigreturn 帧
    K->>K: 修改 pt_regs 使返回地址指向信号处理函数
    K->>P: 返回用户态，执行信号处理函数

    Note over K,P: 阶段四：信号返回
    P->>K: 执行 sigreturn 系统调用
    K->>K: 从 sigreturn 帧恢复原始 pt_regs
    K->>P: 返回用户态，从被中断的指令继续执行

信号发送阶段：信号的来源有三类——硬件异常（除零、缺页）由 CPU 触发，内核将其转换为对应信号；kill()/tgkill() 系统调用允许进程主动发送信号；内核事件（如子进程退出 SIGCHLD、管道读端关闭 SIGPIPE）由内核自动产生。内核在目标进程的 task_struct->pending 或 shared_pending 中设置对应的位图位，并将进程加入运行队列。

信号挂起阶段：信号并非发送后立即处理。内核在每次从内核态返回用户态之前（系统调用返回、中断返回），检查进程的 pending 信号集。如果存在未屏蔽的信号，按编号从小到大选择一个进行投递。这意味着低编号信号（如 SIGHUP=1）总是先于高编号信号（如 SIGTERM=15）被处理。

信号投递阶段：这是整个链路中最复杂的环节。内核需要在用户态栈上构造一个特殊的栈帧（sigreturn frame），包含被中断时的寄存器状态、信号信息和返回地址。然后修改进程的 pt_regs，将指令指针（RIP）设为信号处理函数的入口地址，将栈指针（RSP）指向新构造的栈帧。这样当内核返回用户态时，进程就会"自动"跳转到信号处理函数执行。

信号返回阶段：信号处理函数执行完毕后，通过 sigreturn() 系统调用返回内核。内核从栈帧中恢复被中断时的寄存器状态，进程从被信号打断的指令处继续执行，就像什么都没发生过一样。

三、信号安全编程实践——可重入函数与屏蔽时序的正确用法

以下代码展示了生产环境中信号处理的正确模式，包括可重入约束、信号屏蔽时序和自管道技巧：

/*
 * Linux 信号安全编程实践
 * 演示：可重入约束、信号屏蔽时序、自管道技巧
 * 适用于需要处理异步信号的生产级服务程序
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <pthread.h>

/* ========= 第一部分：信号安全的基本原则 ========= */

/*
 * 全局标志位：使用 volatile sig_atomic_t 保证原子访问
 * sig_atomic_t 保证在信号处理函数中的读写是原子的
 * volatile 防止编译器将其缓存到寄存器中
 */
static volatile sig_atomic_t g_shutdown_requested = 0;
static volatile sig_atomic_t g_reload_requested = 0;

/*
 * 信号处理函数：只做两件事——设置标志位、写管道
 * 绝对禁止在信号处理函数中调用非异步信号安全的函数
 * 非安全函数包括：printf, malloc, free, pthread_mutex_lock, syslog 等
 */
static void handle_sigterm(int signo)
{
    g_shutdown_requested = 1;
}

static void handle_sighup(int signo)
{
    g_reload_requested = 1;
}


/* ========= 第二部分：自管道技巧（Self-Pipe Trick） ========= */

/*
 * 自管道技巧解决的核心问题：
 * 信号处理函数无法安全地唤醒 epoll/select 等事件循环
 * 通过写管道的方式，将信号事件转化为 I/O 事件
 * 主事件循环通过 poll 监听管道读端，实现信号与 I/O 的统一处理
 */

static int g_pipe_fds[2] = {-1, -1};

/*
 * 信号处理函数：向管道写入信号编号
 * write() 是异步信号安全的，且对已打开的管道描述符写少量数据是原子的
 */
static void handle_signal_via_pipe(int signo)
{
    /*
     * 写入信号编号到管道
     * 只写 1 字节，保证管道缓冲区不会溢出
     * 即使主循环来不及读取，管道缓冲区（默认 64KB）足够容纳大量信号
     */
    const uint8_t sig_byte = (uint8_t)signo;
    ssize_t ret = write(g_pipe_fds[1], &sig_byte, 1);
    if (ret != 1) {
        /* 写入失败时无法安全报告错误（不能调用 fprintf）
         * 只能忽略——这是信号安全编程的硬性约束 */
        ;  /* 静默失败 */
    }
}

/*
 * 初始化自管道
 * 设置非阻塞模式，防止写端阻塞信号处理函数
 */
int self_pipe_init(void)
{
    /* 创建管道 */
    if (pipe(g_pipe_fds) < 0) {
        fprintf(stderr, "[ERROR] 创建管道失败: %s\n", strerror(errno));
        return -1;
    }

    /* 设置读端为非阻塞 */
    int flags = fcntl(g_pipe_fds[0], F_GETFL);
    if (flags < 0 || fcntl(g_pipe_fds[0], F_SETFL, flags | O_NONBLOCK) < 0) {
        fprintf(stderr, "[ERROR] 设置管道读端非阻塞失败: %s\n",
                strerror(errno));
        close(g_pipe_fds[0]);
        close(g_pipe_fds[1]);
        g_pipe_fds[0] = g_pipe_fds[1] = -1;
        return -1;
    }

    /* 设置写端为非阻塞——防止信号处理函数在管道满时阻塞 */
    flags = fcntl(g_pipe_fds[1], F_GETFL);
    if (flags < 0 || fcntl(g_pipe_fds[1], F_SETFL, flags | O_NONBLOCK) < 0) {
        fprintf(stderr, "[ERROR] 设置管道写端非阻塞失败: %s\n",
                strerror(errno));
        close(g_pipe_fds[0]);
        close(g_pipe_fds[1]);
        g_pipe_fds[0] = g_pipe_fds[1] = -1;
        return -1;
    }

    return 0;
}

void self_pipe_cleanup(void)
{
    if (g_pipe_fds[0] >= 0) close(g_pipe_fds[0]);
    if (g_pipe_fds[1] >= 0) close(g_pipe_fds[1]);
    g_pipe_fds[0] = g_pipe_fds[1] = -1;
}


/* ========= 第三部分：信号屏蔽的时序控制 ========= */

/*
 * 信号屏蔽的核心场景：
 * 主线程需要原子地修改某个全局数据结构，此时不能被信号处理函数打断
 * 必须在修改前屏蔽信号，修改后解除屏蔽
 * 关键：屏蔽操作必须使用 sigprocmask，而非 signal(SIG_IGN)
 */

/*
 * 安全地修改共享状态
 * 在修改期间屏蔽 SIGTERM 和 SIGHUP，防止信号处理函数并发访问
 */
void update_shared_state_safely(void (*update_fn)(void *), void *arg)
{
    sigset_t block_mask, old_mask;

    /* 构造屏蔽集：屏蔽 SIGTERM 和 SIGHUP */
    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGTERM);
    sigaddset(&block_mask, SIGHUP);

    /* 原子地设置信号屏蔽字，保存旧的屏蔽字 */
    if (sigprocmask(SIG_BLOCK, &block_mask, &old_mask) < 0) {
        fprintf(stderr, "[ERROR] sigprocmask BLOCK 失败: %s\n",
                strerror(errno));
        return;
    }

    /* ---- 临界区开始：此时 SIGTERM/SIGHUP 被挂起，不会投递 ---- */
    update_fn(arg);
    /* ---- 临界区结束 ---- */

    /* 恢复原来的信号屏蔽字
     * 注意：使用 SIG_SETMASK 而非 SIG_UNBLOCK
     * 因为原来的屏蔽字可能已经屏蔽了其他信号，直接 UNBLOCK 会丢失 */
    if (sigprocmask(SIG_SETMASK, &old_mask, NULL) < 0) {
        fprintf(stderr, "[ERROR] sigprocmask SETMASK 失败: %s\n",
                strerror(errno));
        /* 此处无法安全恢复，但程序仍可继续运行 */
    }
}


/* ========= 第四部分：完整的信号处理框架 ========= */

/*
 * 注册信号处理函数的推荐方式
 * 使用 sigaction 而非 signal，原因：
 * 1. signal 的行为在不同 Unix 实现中不一致
 * 2. sigaction 可以精确控制信号处理的各种标志
 * 3. sigaction 在处理函数执行期间自动屏蔽同类型信号
 */
int register_signal_handler(int signo, void (*handler)(int))
{
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));

    sa.sa_handler = handler;

    /*
     * SA_RESTART：被信号中断的系统调用自动重启
     * 适用于：read/write/accept 等慢速系统调用
     * 不适用于：select/poll/epoll_wait（这些总是因信号而提前返回）
     */
    sa.sa_flags = SA_RESTART;

    /*
     * 在信号处理函数执行期间，自动屏蔽同类型信号
     * 防止信号处理函数被自身递归调用
     */
    sigemptyset(&sa.sa_mask);

    if (sigaction(signo, &sa, NULL) < 0) {
        fprintf(stderr, "[ERROR] 注册信号 %d 处理函数失败: %s\n",
                signo, strerror(errno));
        return -1;
    }

    return 0;
}

/*
 * 示例：主事件循环
 * 结合自管道技巧和标志位，实现信号与 I/O 的统一处理
 */
void event_loop(void)
{
    fd_set read_fds;
    uint8_t sig_buf[32];

    printf("[INFO] 事件循环启动，等待信号或 I/O 事件...\n");

    while (!g_shutdown_requested) {
        FD_ZERO(&read_fds);
        FD_SET(g_pipe_fds[0], &read_fds);

        /* 使用 select 监听管道读端
         * 不使用 SA_RESTART，让 select 在信号后返回 EINTR
         * 这样可以在每次信号后检查标志位 */
        int ret = select(g_pipe_fds[0] + 1, &read_fds, NULL, NULL, NULL);

        if (ret < 0) {
            if (errno == EINTR) {
                /* 被信号中断，检查标志位后继续循环 */
                if (g_shutdown_requested) break;
                if (g_reload_requested) {
                    printf("[INFO] 收到重载请求，执行配置热更新\n");
                    g_reload_requested = 0;
                }
                continue;
            }
            fprintf(stderr, "[ERROR] select 失败: %s\n", strerror(errno));
            break;
        }

        /* 从管道读取信号编号 */
        if (FD_ISSET(g_pipe_fds[0], &read_fds)) {
            ssize_t n = read(g_pipe_fds[0], sig_buf, sizeof(sig_buf));
            if (n > 0) {
                for (ssize_t i = 0; i < n; i++) {
                    printf("[INFO] 通过管道收到信号: %d\n", sig_buf[i]);
                    if (sig_buf[i] == SIGTERM || sig_buf[i] == SIGINT) {
                        g_shutdown_requested = 1;
                        break;
                    }
                    if (sig_buf[i] == SIGHUP) {
                        g_reload_requested = 1;
                    }
                }
            }
            /* 非阻塞读取，EAGAIN 是正常情况 */
        }

        if (g_reload_requested) {
            printf("[INFO] 执行配置热更新\n");
            g_reload_requested = 0;
        }
    }

    printf("[INFO] 收到终止信号，优雅退出\n");
}

int main(void)
{
    /* 初始化自管道 */
    if (self_pipe_init() < 0) {
        return EXIT_FAILURE;
    }

    /* 注册信号处理函数 */
    register_signal_handler(SIGTERM, handle_signal_via_pipe);
    register_signal_handler(SIGINT,  handle_signal_via_pipe);
    register_signal_handler(SIGHUP,  handle_signal_via_pipe);

    /* 进入主事件循环 */
    event_loop();

    /* 清理资源 */
    self_pipe_cleanup();
    return EXIT_SUCCESS;
}

四、信号的不可靠性与架构边界——何时该放弃信号转用其他机制

信号机制存在若干根本性的设计局限，在架构决策时必须纳入考量。

标准信号的不可靠性：标准信号（Standard Signals，编号 1-31）使用位图实现，同一信号在未被处理前再次发送，只会被记录一次。这意味着如果进程来不及处理 SIGCHLD，连续三个子进程退出只产生一次通知，导致僵尸进程残留。实时信号（SIGRTMIN-SIGRTMAX）通过队列解决了这个问题，但队列容量有限（默认 8192），溢出后仍会丢失。

信号处理函数的执行上下文约束：信号处理函数运行在被中断线程的用户态栈上，与主逻辑共享同一地址空间。这意味着任何非原子的全局状态访问都是竞态条件。POSIX 定义的异步信号安全函数仅有约 140 个，排除所有标准 I/O、内存分配和线程同步函数。这一约束严重限制了信号处理的实际能力。

多线程环境下的信号投递语义：在多线程程序中，信号的处理分为两类：针对进程的信号（如 SIGINT）会被投递到任意一个未屏蔽该信号的线程；针对线程的信号（如 pthread_kill 发送的信号）只投递到指定线程。这种不确定性使得多线程程序的信号处理更加复杂，需要仔细设计每个线程的信号屏蔽字。

替代方案的选择：对于进程间通知，eventfd 比 pipe 更轻量（无需序列化/反序列化）；对于内核到用户态的事件通知，signalfd 将信号转化为文件描述符的可读事件，完全消除了信号处理函数的需求；对于高频事件通知，epoll 边沿触发模式配合 eventfd 是更可靠的选择。信号机制应当被限制在"低频、异步、最后手段"的定位上，而非作为常规的通信手段。

五、总结

Linux 信号机制是操作系统异步通知的基础设施，其从内核投递到用户态捕获的完整链路涉及 pending 位图检查、sigreturn 栈帧构造和 pt_regs 修改等底层机制。信号处理函数的执行环境极为受限，只能调用异步信号安全函数，只能访问 volatile sig_atomic_t 类型的全局变量。

落地路线建议：

1. 信号注册统一使用 sigaction：替代 signal()，精确控制 SA_RESTART、SA_SIGINFO 等标志，避免跨平台行为不一致。

2. 信号处理函数只做两件事：设置 volatile sig_atomic_t 标志位，或通过自管道/eventfd 将信号转化为 I/O 事件。绝不调用非安全函数。

3. 多线程程序集中信号管理：主线程统一处理信号，工作线程屏蔽所有异步信号。通过 pthread_sigmask 在线程创建前设置屏蔽字。

4. 优先使用 signalfd + epoll：在新项目中，用 signalfd 将信号转化为文件描述符事件，纳入 epoll 事件循环统一处理，彻底消除信号处理函数的编写需求。

5. 实时信号用于可靠通知：当标准信号的"合并"语义不可接受时（如子进程退出通知），使用实时信号并检查队列是否溢出。