信号是进程之间做异步事件通知的方式,属于软中断:通知先到,处理可以晚一点。这个"晚一点"决定了整套机制的形状——信号产生时只在进程控制块里置一个标志位,等进程从内核态返回用户态、并且当前没被阻塞时,才真正处理。

能识别信号、知道每种信号默认怎么办,是内核写死的行为,不需要程序事先声明。需要程序决定的只有一件事:这个信号到来时,是走默认动作、忽略,还是执行我自己的函数。

一张按 ABI 排的信号表

编号名称默认动作触发场景
1SIGHUP终止控制终端挂断
2SIGINT终止Ctrl+C
3SIGQUIT终止 + core终端按 Ctrl+\
6SIGABRT终止 + coreabort()
8SIGFPE终止 + core除零等算术异常
9SIGKILL终止只能由 kill 发送
11SIGSEGV终止 + core非法内存访问
13SIGPIPE终止写已关闭读端的管道
14SIGALRM终止alarm() 到期
15SIGTERM终止kill 的默认信号
17SIGCHLD忽略子进程停止或终止
18SIGCONT继续让停止的进程继续
19SIGSTOP停止不可捕获、不可阻塞
20SIGTSTP停止Ctrl+Z

SIGKILL 和 SIGSTOP 是唯二不给商量的:既不能捕捉,也不能阻塞,忽略也无效。SIGTERM 是可以捕捉的"礼貌请求退出",SIGKILL 是内核直接收尸,所以发信号应该先 SIGTERM,等不到再 SIGKILL。

signal.h 里的宏与编号:前两段是 ISO C 与 POSIX 历史信号,第三段是较新的 POSIX 信号;对照看 SIGINT=2、SIGKILL=9、SIGALRM=14,以及下半段里 SIGSTOP、SIGTSTP、SIGCHLD 的编号——这几个正是各平台不一致的地方

编号是 ABI 常量,不该背。课件引用的一份 signal.h 列出 SIGSTOP 17、SIGTSTP 18、SIGCHLD 20,同一份课件里 Ctrl+Z 的实验又打印出"获得了一个信号: 20"——两处对不上。原因是那份列表用的是 POSIX 的通用编号,而 x86-64 Linux 上 SIGCHLD 是 17、SIGCONT 18、SIGSTOP 19、SIGTSTP 20。判断依据是本机的 kill -l,不要照抄表格里的数字。符号 34 以上是实时信号,32、33 被线程库内部占用。

五种产生方式

终端按键。按下 Ctrl+C,键盘产生硬件中断,CPU 进入内核,键盘驱动把字节送到 tty 层;tty 层识别出 0x03 是中断字符,向前台进程组发 SIGINT。Ctrl+\ 对应 SIGQUIT(终止并 dump core),Ctrl+Z 对应 SIGTSTP(挂起)。这几个信号只发给前台进程组,& 放到后台的程序收不到 Ctrl+C。

系统命令。kill -SIGSEGV 213784 给一个死循环程序发 11 号信号,它就以段错误的身份退出。多按一次回车才看到 Segmentation fault,是因为 Shell 要把这条消息和用户的输入分开打印。kill -11 与 kill -SIGSEGV 等价。

系统调用。三个函数对应三种对象:

#include <sys/types.h>
#include <signal.h>
 
int kill(pid_t pid, int sig);    /* 给任意进程发,成功返回 0 */
int raise(int sig);              /* 给自己发,成功返回 0 */
void abort(void);                /* 给自己发 SIGABRT,永不返回 */

kill 的 pid 取负值时按进程组发送,取 0 时发给同组所有进程。abort() 的行为值得记一笔:它发的是固定的 6 号信号,即使你捕捉了 SIGABRT,abort 也会在调用处理函数之后恢复默认动作并重新发送,所以进程仍然会退出——这是 abort 的语义,不是 bug。

软件条件。alarm 定一个一次性的闹钟:

unsigned int alarm(unsigned int seconds);

到点给当前进程发 SIGALRM,默认动作是终止。返回值是上一个闹钟的剩余秒数,没有旧闹钟则返回 0;alarm(0) 取消闹钟,返回值同样是剩余时间。闹钟只响一次,要周期性触发就在处理函数里重新调用 alarm。另一个软件条件是 SIGPIPE:往一个读端全关的管道写数据,内核给写进程发 13 号信号。

硬件异常。除零时 CPU 的运算单元报异常,内核把它解释成 SIGFPE;访问非法地址时 MMU 报异常,解释成 SIGSEGV。这两类信号有个共同现象:如果只是捕捉而不处理根因,信号会一直重复。因为异常发生时执行上下文没被清理,出错的那条指令还在,返回去再执行一次又出错。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
 
static void handler(int sig)
{
    printf("catch a sig: %d\n", sig);
}
 
int main(void)
{
    signal(SIGFPE, handler);
    sleep(1);
    int a = 10;
    a /= 0;
    while (1)
        ;
    return 0;
}

这段程序会不停打印 catch a sig: 8。GCC 会对 a /= 0 给出 division by zero 警告,但通常仍生成除法指令,跑到那一行就触发 SIGFPE;如果哪一级优化把它提前算掉了,把除数换成一个运行时读入的变量即可。真实工程里没人这么写,它只说明信号与异常的关系。

保存信号:三张表和一个位图

内核给每个进程维护三样东西:一张 block 表、一张 pending 表、一张 handler 表,每张表对每个信号占一位或一个槽。

"task_struct" 引出三列:block 表里 SIGHUP=0、SIGINT=1、SIGQUIT=1;pending 表里 SIGHUP=0、SIGINT=1、SIGQUIT=0;handler 表里依次是 SIG_DFL、SIG_IGN 和指向用户函数 sighandler 的指针

看这张图可以读出三件事:

  • SIGHUP 没阻塞也没产生,一旦递达就走默认动作;
  • SIGINT 产生过并处于未决,但被阻塞,所以暂时不递达。它的处理动作是忽略,可在解除阻塞之前这个"忽略"还不算数——进程仍有机会改主意;
  • SIGQUIT 没产生过,一旦产生就会被阻塞,它的动作是用户自定义函数。

三个术语要分清:信号实际执行处理动作叫递达(delivery);从产生到递达之间的状态叫未决(pending);进程主动拒绝它递达叫阻塞(block)。阻塞和忽略不是一回事:阻塞发生在递达前,忽略发生在递达时。

常规信号在递达之前产生多次只记一次,因为 pending 表只有一位,不计数。实时信号排队,本章不涉及。

block 表和 pending 表在用户侧对应同一个类型 sigset_t——信号集。它的内部布局依赖实现,不能拿来直接打印,只能用函数操作:

#include <signal.h>
 
int sigemptyset(sigset_t *set);              /* 全部清零 */
int sigfillset(sigset_t *set);               /* 全部置位 */
int sigaddset(sigset_t *set, int signo);     /* 加一个 */
int sigdelset(sigset_t *set, int signo);     /* 删一个 */
int sigismember(const sigset_t *set, int signo);

前四个成功返回 0、失败返回 -1;sigismember 是布尔判断,包含返回 1,不包含返回 0,出错返回 -1。使用 sigset_t 变量之前必须先 sigemptyset 或 sigfillset,否则里面是栈上的随机值。

读改阻塞表用 sigprocmask:

int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
how动作
SIG_BLOCK把 set 里的信号并入当前屏蔽字
SIG_UNBLOCK从当前屏蔽字里去掉 set 里的信号
SIG_SETMASK直接把屏蔽字设为 set

oset 非空时,函数先把旧屏蔽字写进 oset 再改。如果解除阻塞时正好有未决信号,sigprocmask 返回之前至少会递达其中一个。

读未决表用 sigpending:

int sigpending(sigset_t *set);

下面这段程序把两张表都用了一遍:先屏蔽 SIGINT,每轮打印 pending 的 31 位,15 轮之后解除屏蔽。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
 
static void print_pending(const sigset_t *p)
{
    int i;
    printf("pending: ");
    for (i = 31; i >= 1; i--)
        printf("%d", sigismember(p, i));
    printf("\n");
}
 
static void handler(int sig)
{
    sigset_t p;
    printf("%d 号信号被递达\n", sig);
    sigpending(&p);
    print_pending(&p);
}
 
int main(void)
{
    sigset_t block_set, old_set, p;
    int cnt = 15;
 
    signal(SIGINT, handler);
 
    sigemptyset(&block_set);
    sigemptyset(&old_set);
    sigaddset(&block_set, SIGINT);
    sigprocmask(SIG_BLOCK, &block_set, &old_set);
 
    while (cnt-- > 0) {
        sigpending(&p);
        print_pending(&p);
        if (cnt == 0) {
            printf("解除对 2 号信号的屏蔽\n");
            sigprocmask(SIG_SETMASK, &old_set, NULL);
        }
        sleep(1);
    }
    return 0;
}

按一次 Ctrl+C,屏幕上那一行里右数第二位从 0 变成 1(循环从 31 打到 1,SIGINT 编号 2 因此落在倒数第二格),之后一直保持,直到解除屏蔽,处理函数才被调用,pending 位同时清零。中途按 Ctrl+\ 仍然能终止程序,因为 SIGQUIT 没被屏蔽。

捕捉信号:进内核,绕出来,再回去

信号处理函数在用户空间,但信号是内核递达的,这一趟往返比较绕:

上半是用户态:main 执行到某条指令,或因中断异常系统调用进入内核;下半是内核态:处理完准备回用户态之前先 do_signal,自定义动作则不回到 main,而是回用户态执行 sighandler;sighandler 返回时执行 sigreturn 再进内核,最后从被中断的地方继续

关键在第四步和第五步:sighandler 和 main 之间没有调用关系,它靠 sigreturn 这个特殊系统调用回到内核,再由内核恢复 main 被中断时的上下文。

课件在这里写"sighandler 和 main 函数使用不同的堆栈空间",这句不准确。同一个线程里的信号处理函数默认就跑在被中断的那条用户栈上,sighandler 的栈帧压在 main 的栈帧上方,只不过它不是 main 调用的,返回路径也不走 ret。真正"换栈"要显式申请:sigaltstack 建立备用栈,再在 sigaction 里加 SA_ONSTACK。这个选项存在的意义,恰好说明默认行为不换栈——栈溢出导致的 SIGSEGV 如果还在同一根栈上处理,处理函数自己也会踩到栈顶。

sigaction 是比 signal 更完整的注册方式:

#include <signal.h>
 
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);
struct sigaction {
    void     (*sa_handler)(int);    /* 也可以是 SIG_IGN / SIG_DFL */
    sigset_t   sa_mask;             /* 处理期间额外屏蔽的信号 */
    int        sa_flags;
    void     (*sa_restorer)(void);
    void     (*sa_sigaction)(int, siginfo_t *, void *);  /* SA_SIGINFO 时用 */
};

sa_handler 有三种赋值:SIG_IGN 忽略,SIG_DFL 走默认动作,一个函数指针则自定义。SIG_IGN 和 SIG_DFL 在头文件里就是 ((__sighandler_t)1) 和 ((__sighandler_t)0),把 0 和 1 强转成函数指针。

有一个自动行为:处理函数被调用时,内核把当前这个信号加进屏蔽字,返回时恢复。所以处理 SIGINT 期间再来一个 SIGINT,它不会嵌套进同一个处理函数,而是等这次处理结束。想额外屏蔽别的信号,写进 sa_mask。

可重入:处理函数打断了什么

main 里正在往链表插节点,刚做完第一步就被信号打断,处理函数也去插节点,回来之后 main 接着做第二步——这就是重入。

五个阶段:main 的 insert 把 node1 接到 head 之后还没改 head;sighandler 的 insert 把 node2 接到 head;返回后 main 才把 head 改成 node1,结果 node1 覆盖了 head,node2 从链上掉了下来

一个函数被不同控制流程调用、第一次还没返回就可能再次进入,这就是重入;重入之后会错乱,说明它访问了共享的全局状态,这样的函数叫不可重入。只访问自己的局部变量和参数的函数天生可重入,因为每次调用都有自己的栈帧。

下面这些函数不可重入,不适合在处理函数里调用:

  • malloc / free:堆由全局链表管理,重入会破坏链表;
  • 标准 I/O 函数:printf 系列内部用全局缓冲和锁,多线程版本靠锁保护,信号处理函数里拿锁可能死锁;
  • 其他读写全局或静态数据的函数。

处理函数里能安全使用的只有 write、_exit、sigaction 等一份精简清单(POSIX 里叫 async-signal-safe 函数)。要打印调试信息,用 write(STDERR_FILENO, "msg\n", 4),别用 printf。

还有一个编译器层面的坑。while (!flag) 在 -O2 下会把 flag 读进寄存器,循环体里不再重新读内存,于是处理函数把 flag 改成 1 也不起作用:

#include <signal.h>
 
volatile int flag = 0;
 
static void handler(int sig)
{
    (void)sig;
    flag = 1;
}
 
int main(void)
{
    signal(SIGINT, handler);
    while (!flag)
        ;
    return 0;
}

加 volatile 之后,每次循环都从内存取值,程序能正常退出。volatile 保证的是"不被优化掉、每次都真实访存",它不提供原子性,也不能替代锁。汇编层面看 while (!flag),-O2 会把它变成一个没有内存读的空循环。

SIGCHLD 与 core dump

子进程终止时,内核给父进程发 SIGCHLD,默认动作是忽略。父进程因此不必阻塞在 wait,也不必轮询,只要注册一个处理函数,在里面清理完就行。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>
 
static void handler(int sig)
{
    pid_t id;
    (void)sig;
    while ((id = waitpid(-1, NULL, WNOHANG)) > 0)
        printf("wait child success: %d\n", id);
}
 
int main(void)
{
    pid_t cid;
 
    signal(SIGCHLD, handler);
    if ((cid = fork()) == 0) {
        printf("child: %d\n", getpid());
        sleep(3);
        exit(1);
    }
 
    while (1) {
        printf("father is working\n");
        sleep(1);
    }
    return 0;
}

waitpid 第一个参数传 -1、并带上 WNOHANG 循环,是为了处理"一次回调对应多个子进程退出"的情况。常规信号不计数,三个子进程同时退出只会留下一个 SIGCHLD,只调一次 waitpid 会漏掉两个僵尸。

还有一种绕开僵尸的办法:把 SIGCHLD 的处理动作用 sigaction 设成 SIG_IGN。这样 fork 出来的子进程终止时由系统自动回收,不产生僵尸也不通知父进程。默认的忽略和显式 SIG_IGN 通常没区别,这里是唯一的特例,而且只在 Linux 上成立。

core dump 是另一条线索。进程异常终止时可以把用户空间内存全部写到磁盘,文件名通常是 core,用于事后调试(post-mortem debug)。默认不允许产生,因为里面可能有密码之类的敏感数据,资源上限由 ulimit -c 控制:

ulimit -c 0        # 默认,不产生 core
ulimit -c 1024     # 允许最大 1024 KB

ulimit 改的是 Shell 进程的资源上限,它 fork 出来的子进程继承这个值。

想从父进程看出子进程是被哪个信号杀的、有没有 dump,靠 waitpid 的 status:

#include <stdio.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>
 
int main(void)
{
    pid_t pid = fork();
    int status = 0;
 
    if (pid == 0) {
        sleep(1);
        int a = 10;
        a /= 0;
        _exit(0);
    }
 
    waitpid(-1, &status, 0);
    printf("exit signal: %d, core dump: %d\n", status & 0x7F, (status >> 7) & 1);
    return 0;
}

低 7 位是终止进程的信号编号,第 8 位((status >> 7) & 1)是 core dump 标志。标准做法是用宏:

if (WIFEXITED(status))
    printf("正常退出,退出码 %d\n", WEXITSTATUS(status));
else if (WIFSIGNALED(status))
    printf("被信号 %d 终止,core dump: %d\n",
           WTERMSIG(status), WCOREDUMP(status));

WIFEXITED 和 WIFSIGNALED 是互斥的,别用裸位运算代替——宏的写法跨平台稳得多。

信号背后那套中断机制

信号是软中断,中断是它的原型。两者层级不同:硬件中断发给 CPU,信号发给进程。

  • 硬件中断由外部设备触发。中断向量表是操作系统的一部分,启动时就装进内存;有了它,操作系统不必轮询外设,设备有事件就自己跳过来。
  • 时钟中断是最特殊的一个,它由硬件周期性地自动触发。有了它,操作系统才不需要别人推着走:每次时钟中断进来,do_timer 更新计时、递减时间片,到点就调 schedule 换进程。主频越高,同样时间里中断越多,调度粒度越细。
  • 软中断由指令触发。系统调用用 int 0x80 或 syscall 主动陷入内核,这类叫陷阱(trap);除零、野指针这类由执行错误引发,叫异常(exception)。缺页(page fault)也是异常的一种,处理例程负责补页、补映射。

用户态和内核态的区分靠 CPU 内的特权级别,x86 上有 ring 0 到 ring 3 四级,Linux 只用了 ring 0 和 ring 3。32 位系统里虚拟地址空间被切成两半:低 3 GB 归用户进程,高 1 GB 归内核,所有进程共享同一份内核地址空间。切到内核态时 CPU 还要换栈,栈段和栈顶从 TSS 里取。

这些机制解释了为什么信号总是"在合适的时候"才被处理:处理函数要等进程从内核返回用户态那一刻才有机会执行,而进入内核的时机,就是中断、异常和系统调用。信号没有自己的执行线程,它只是搭在这套机制上的一段插队逻辑。