信号是进程之间做异步事件通知的方式,属于软中断:通知先到,处理可以晚一点。这个"晚一点"决定了整套机制的形状——信号产生时只在进程控制块里置一个标志位,等进程从内核态返回用户态、并且当前没被阻塞时,才真正处理。
能识别信号、知道每种信号默认怎么办,是内核写死的行为,不需要程序事先声明。需要程序决定的只有一件事:这个信号到来时,是走默认动作、忽略,还是执行我自己的函数。
一张按 ABI 排的信号表
| 编号 | 名称 | 默认动作 | 触发场景 |
|---|---|---|---|
| 1 | SIGHUP | 终止 | 控制终端挂断 |
| 2 | SIGINT | 终止 | Ctrl+C |
| 3 | SIGQUIT | 终止 + core | 终端按 Ctrl+\ |
| 6 | SIGABRT | 终止 + core | abort() |
| 8 | SIGFPE | 终止 + core | 除零等算术异常 |
| 9 | SIGKILL | 终止 | 只能由 kill 发送 |
| 11 | SIGSEGV | 终止 + core | 非法内存访问 |
| 13 | SIGPIPE | 终止 | 写已关闭读端的管道 |
| 14 | SIGALRM | 终止 | alarm() 到期 |
| 15 | SIGTERM | 终止 | kill 的默认信号 |
| 17 | SIGCHLD | 忽略 | 子进程停止或终止 |
| 18 | SIGCONT | 继续 | 让停止的进程继续 |
| 19 | SIGSTOP | 停止 | 不可捕获、不可阻塞 |
| 20 | SIGTSTP | 停止 | Ctrl+Z |
SIGKILL 和 SIGSTOP 是唯二不给商量的:既不能捕捉,也不能阻塞,忽略也无效。SIGTERM 是可以捕捉的"礼貌请求退出",SIGKILL 是内核直接收尸,所以发信号应该先 SIGTERM,等不到再 SIGKILL。

编号是 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 表,每张表对每个信号占一位或一个槽。

看这张图可以读出三件事:
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 没被屏蔽。
捕捉信号:进内核,绕出来,再回去
信号处理函数在用户空间,但信号是内核递达的,这一趟往返比较绕:

关键在第四步和第五步: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 接着做第二步——这就是重入。

一个函数被不同控制流程调用、第一次还没返回就可能再次进入,这就是重入;重入之后会错乱,说明它访问了共享的全局状态,这样的函数叫不可重入。只访问自己的局部变量和参数的函数天生可重入,因为每次调用都有自己的栈帧。
下面这些函数不可重入,不适合在处理函数里调用:
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 KBulimit 改的是 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 里取。
这些机制解释了为什么信号总是"在合适的时候"才被处理:处理函数要等进程从内核返回用户态那一刻才有机会执行,而进入内核的时机,就是中断、异常和系统调用。信号没有自己的执行线程,它只是搭在这套机制上的一段插队逻辑。
还没有评论 — 第一条由你来留。