[linux] linux 常见信号以及使用信号时注意事项-编程知识

信号是一种进程间通信的方式，进程间通信的方式还包括共享内存，socket，管道，消息队列。信号与其它方式是有区别的，其它通信方式很灵活，可以详细定义自己的消息内容；而信号没有这么灵活，信号的种类在系统中是固定死的，我们可以使用的信号种类，只能从固定的类型中选择。

linux 中的信号有 64 种，可以通过 kill -l 命令查看。

1 信号的使用

信号作为一种进程间通信方式，最基本的有两个处理，一个是发送信号，一个是接收并处理信号。

1.1 kill 和 raise

kill 可以指定要发送的信号，以及要将这个信号发送到哪个或者哪些进程。raise 可以把信号发给进程自己。

kill 函数

int kill(pid_t pid, int sig);

raise 相当于 kill(getpid(), sig)

int raise(int sig);

使用 kill 的时候，我们一般都是向某个进程发送一个信号，第一个形参 pid 就是目标进程的进程号。但是 kill 的 pid 也可以传不大于 0 的数。

pid > 0	一个进程
pid == 0	信号发向一个进程组，发向哪个进程组呢，就是当前这个进程所在的进程组
pid < -1	信号也是发向一个进程组，进程组的组 id 是 pid 的绝对值
pid == -1	发向每一个进程，前提这个进程有权限，不会发向 1 号进程

如下代码是 kill 使用的示例，使用 signal 捕获了 SIGTERM 信号，信号处理函数是 signal_handler。父进程中的代码 kill(pid, SIGTERM) 是向子进程发送信号，kill(0, SIGTERM) 是向进程组发信号。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>void signal_handler(int sig_num) {printf("signal = %d, pid = %d\n", sig_num, getpid());
}int main() {signal(SIGTERM, signal_handler);pid_t pid = fork();if (pid == 0) {printf("子进程 id = %d, 进程组 id = %d\n", getpid(), getpgrp());// 子进程while (1) {sleep(1);}} else {printf("父进程 id = %d, 进程组 id = %d\n", getpid(), getpgrp());sleep(2);// kill(pid, SIGTERM);kill(0, SIGTERM);sleep(2);}return 0;
}

1.2 signal 和 sigaction

signal 和 sigaction 都可以用于改变信号的处理方式，指定一个信号，指定这个信号的处理函数，就可以工作了。

当进程中有线程阻塞在内核态的时候，比如 io，这个时候收到信号，默认情况下线程会被唤醒，从阻塞的系统调用中返回。如下代码，使用 sigaction 捕获 SIGTERM 信号，在主函数中有一个 while(1) 循环，循环中使用 scanf() 从标准输入读取数据，我们预期的情况是如果在控制台不输入数据，那么 scanf() 就会一直处于阻塞状态。但是默认的情况和我们预期是不一样的，当向进程发送信号 SIGTERM 时，scanf() 会被唤醒，从而返回。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>void signal_handler(int sig_num) {printf("signal = %d, pid = %d\n", sig_num, getpid());
}int main() {struct sigaction sa_sigterm;sa_sigterm.sa_flags = 0; // SA_RESTART;sa_sigterm.sa_handler = signal_handler;sigaction(SIGTERM, &sa_sigterm, NULL);printf("pid = %d\n", getpid());while (1) {printf("before scanf\n");int a = 10;scanf("%d", &a);printf("after scanf, a = \n", a);}return 0;
}

运行结果如下，当向进程发送 SIGTERM 时，信号处理函数会被调用，同时 scanf() 也会返回。

使用 sigaction 的时候，可以给 sa_flags 设置一个标志 SA_RESTART，设置这个标志之后，收到信号之后 scanf() 就不会返回。

signal 是对 sigaction 的封装，主要 signal 内部使用 sigaction 的时候就设置了 SA_RESTART 标志，所以使用 signal 的话，收到信号的时候 io 阻塞不会返回。在使用 signal 的代码里边，使用 gdb 给 sigaction 设置断点，可以看到 signal 调用了 sigaction，如下图所示。

1.3 signalfd, 一切皆文件

signalfd 是将信号通过一个 fd 来管理，体现了 linux 中一切皆文件的简洁性。

当把一个系统通过文件来管理的时候，往往都要实现自己的 struct file_operations。signalfd 也不例外，如下是实现，其中实现了最主要的两个函数，read 和 poll，通过 read 可以读取信号信息；实现了 poll 函数的话，就支持通过 select，poll，epoll 这些多路复用技术来监听。

static const struct file_operations signalfd_fops = {
#ifdef CONFIG_PROC_FS.show_fdinfo	= signalfd_show_fdinfo,
#endif.release	= signalfd_release,.poll		= signalfd_poll,.read		= signalfd_read,.llseek		= noop_llseek,.may_pollfree	= true,
};

通过 signalfd 来管理信号，要注意以下两点：

（1）使用 read 或者 select, poll, epoll 来监听信号之后，信号的处理就是同步的了；不像通过 signal() 或者 sigaction() 这样直接注册一个信号处理函数，这样是异步处理，有不可重入问题需要注意。改成同步处理之后，我们就可以使用一个单独的线程来处理信号了。

（2）使用 signalfd 来管理信号的时候需要使用 sigprocmask() 来将监听的信号设置为阻塞状态，因为我们并没有改变信号的处理方式，如果不设置为阻塞，那么信号会被默认方式处理，使用 read，select，poll，epoll 就无法获取到信号了。

sigpromask 是设置本线程的 mask，哪个线程调用，就对哪个线程生效。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <sys/signalfd.h>void *thread_function(void *arg) {sigset_t mask;int signal_fd;struct signalfd_siginfo fd_si[8];ssize_t s;sigemptyset(&mask);sigaddset(&mask, SIGTERM);sigaddset(&mask, SIGINT);signal_fd = signalfd(-1, &mask, 0);if (signal_fd == -1) {perror("signa_fd");return NULL;}printf("signal_fd = %d\n", signal_fd);// 信号阻塞，防止信号被默认的处理方式处理if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {perror("sigprocmask");}while (1) {fd_set read_fds;FD_ZERO(&read_fds);FD_SET(signal_fd, &read_fds);sleep(20);printf("before select\n");if (select(signal_fd + 1, &read_fds, NULL, NULL, NULL) == -1) {perror("select");return NULL;}printf("after select\n");s = read(signal_fd, fd_si, 2 * sizeof(struct signalfd_siginfo));if (s == sizeof(struct signalfd_siginfo)) {printf("received signal %d\n", fd_si[0].ssi_signo);} else {printf("received signal %d and %d\n", fd_si[0].ssi_signo, fd_si[1].ssi_signo);}}close(signal_fd);return NULL;
}int main() {pthread_t t1;pthread_create(&t1, NULL, thread_function, NULL);sigset_t mask;sigemptyset(&mask);sigaddset(&mask, SIGTERM);sigaddset(&mask, SIGINT);// 信号阻塞，防止信号被默认的处理方式处理if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {perror("sigprocmask");}printf("before return\n");sleep(200);return 0;
}

1.4 sigtimedwait

与使用 signalfd 类似，sigtimedwait 也可以同步处理信号，并且使用 sigtimedwait 比使用 signalfd 要简洁一些，需要调用的 api 少。

sigtimedwait 和 signalfd 有一个共同的优点，就是可以通过 signal info 获取到信号是谁发送的。这个在实际工作中非常有用，有时候进程被一个信号杀死，我们经常需要确定这个信号是谁发送的。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <errno.h>int main() {sigset_t mask;siginfo_t info;struct timespec timeout;sigemptyset(&mask);sigaddset(&mask, SIGTERM);sigaddset(&mask, SIGINT);// 信号阻塞，防止信号被默认的处理方式处理if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {perror("sigprocmask");}timeout.tv_sec = 5;timeout.tv_nsec = 0;// 在这 20s 期间，向进程分别发送一个 SIGTERM 和 SIGINT 观察怎么处理sleep(20);while (1) {printf("before signal timed wait\n");int result = sigtimedwait(&mask, &info, /*&timeout*/ NULL);printf("after signal timed wait\n");if (result == -1) {if (errno == EAGAIN) {printf("timed out waiting for signal\n");} else {perror("sigtimedwait");return -1;}} else {printf("received signal %d, sent by pid %d\n", result, info.si_pid);}}return 0;
}

1.5 信号是进程的资源

“进程是资源封装的单位”，这句话我们经常看到，信号也是属于进程的资源，所以 struct task_struct 中也有成员来维护这个进程的信号。除了信号之外，进程的资源还包括内存，打开的文件。

struct task_struct 中与信号相关的成员有如下几个：

struct task_struct {/* Signal handlers: */struct signal_struct		*signal; struct sighand_struct __rcu		*sighand; // 信号处理函数sigset_t			blocked; // 线程阻塞哪些信号sigset_t			real_blocked; // 线程当前阻塞的信号struct sigpending		pending; // 当前线程等待处理的信号
}

2 常见信号

在工作中我们经常使用一些信号，比如使用 kill -9 杀死一个进程，ctrl + C 停止一个进程其实是向进程发信号 SIGINT。另外还经常见到一个信号，比如 SIGCHLD，SIGSEGV 等。本节就记录这些常用以及常见的信号。

2.1 SIGKILL

（1）SIGKILL 是信号 9，平时常用 kill -9 杀死一个进程

（2）如果一个进程一直申请内存，导致系统资源紧张的话，系统会用 SIGKILL 将进程杀死

2.2 SIGINT

我们使用最多的 ctrl C 把进程停掉，就是向进程发 SIGINT，2 信号。

2.3 SIGCHILD

当子进程退出的时候会向父进程发送信号 SIGCHLD。

SIGCHLD 默认的操作是 ignore 的。

在开发中也不会专门使用 signal 来捕获 SIGCHLD，而是使用 wait() 来回收子进程。

如下代码可以观察到子进程退出后，父进程收到 SIGCHLD 的现象。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>void signal_handler(int sig_num) {printf("signal = %d, pid = %d\n", sig_num, getpid());
}int main() {signal(SIGCHLD, &signal_handler);printf("pid = %d\n", getpid());pid_t pid = fork();if (pid == 0) {printf("子进程 id %d\n", getpid());sleep(2);} else {printf("父进程 id %d\n", getpid());sleep(5);}return 0;
}

2.4 SIGSEGV

SIGSEGV 是段错误，一般出现在非法访问内存的时候。

如下代码 int a 是一个全局的 const 常量，常量只能在声明的时候初始化，不可以在其他地方修改，没有写权限。可以构造出段错误。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>const int a = 10;
int main() {int *pa = (int *)(void *)(&a);*pa = 100;return 0;
}

2.5 SIGABRT

发送 SIGABRT 信号的原因没有那么具体，进程收到 SIGABRT 的时候，说明发生了严重的错误。

如下代码是对一块内存重复释放了，会产生 SIGABRT 信号。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>int main() {char *p = (char *)malloc(8);p[0] = 10;free(p);free(p);return 0;
}

2.6 SIGPIPE

当我们使用 tcp 或者 unix socket 中面向连接的 socket 时，如果对端已经关闭了，这个时候我们还向对端发送数据，就会收到 SIGPIPE 信号。

2.7 SIGTERM

systemd 使用了 SIGTERM 信号将 systemd 管理的服务关掉。服务可以捕获这个信号，当收到该信号的时候，说明进程需要关闭，进程内部可以做一些退出前的状态保存工作。

2.8 SIGBUS

使用 mmap 的时候，如果使用不当，会被 SIGBUS 信号杀死。

如下代码，使用 mmap，如果 mmapfile 文件的大小是 0，这个时候通过 p[0] 写数据的话，就会收到 SIGBUS 信号。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>int main() {int fd = open("mmapfile", O_RDONLY);if (fd == -1) {perror("open");return 1;}void* map_addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);if (map_addr == MAP_FAILED) {perror("mmap");close(fd);return 1;}char *pc = (char *)map_addr;pc[0] = 10;close(fd);if (munmap(map_addr, 4096) == -1) {perror("munmap");return 1;}return 0;
}

3 信号使用注意事项

3.1 SIGKILL 和 SIGSTOP 不能被用户捕获

signal 的 man 手册中说了，这两个信号不能被用户捕获，也不能忽略。

如下代码分别设置 SIGTERM，SIGKILL, SIGSTOP 的回调函数或者将信号设置为忽略。SIGTERM 可以设置成功，SIGKILL 和 SIGSTOP 设置失败。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>void signal_handler(int sig_num) {printf("signal = %d, pid = %d\n", sig_num, getpid());
}int main() {if (signal(SIGTERM, signal_handler) == SIG_ERR) {perror("capture SIGTERM: ");}if (signal(SIGTERM, SIG_IGN) == SIG_ERR) {perror("ignore SIGTERM: ");}if (signal(SIGKILL, signal_handler) == SIG_ERR) {perror("capture SIGKILL: ");}if (signal(SIGSTOP, signal_handler) == SIG_ERR) {perror("capture SIGTERM: ");}if (signal(SIGKILL, SIG_IGN) == SIG_ERR) {perror("ignore SIGKILL: ");}if (signal(SIGSTOP, SIG_IGN) == SIG_ERR) {perror("ignore SIGSTOP: ");}return 0;
}

运行结果如下：

3.2 一个信号的处理函数在一个进程内只有一个

如果是多线程的程序，在不同的线程里使用 signal() 或者 sigaction() 注册多次信号的回调函数，那么后边注册的会覆盖前边注册的函数，最后一次调用 signal() 或者 sigaction() 传的回调函数是有效的。

当进程收到信号的时候，无论信号被哪个线程处理，都是调用最后这个函数。

如下代码所示，main 函数中首先对 SIGTERM 注册了 signal_handler1 和 signal_handler2 两个函数；然后创建了线程，在线程中又对 SIGTERM 注册了 signal_handler3；最后睡眠 1s 之后，在 main 函数中又注册了 signal_handler4。那么进程收到 SIGTERM 信号之后的处理函数是 signal_handler4。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>void signal_handler1(int sig_num) {printf("1 signal = %d, pid = %d\n", sig_num, getpid());
}void signal_handler2(int sig_num) {printf("2 signal = %d, pid = %d\n", sig_num, getpid());
}void signal_handler3(int sig_num) {printf("3 signal = %d, pid = %d\n", sig_num, getpid());
}void signal_handler4(int sig_num) {printf("4 signal = %d, pid = %d\n", sig_num, getpid());
}void *thread_function(void *arg) {signal(SIGTERM, signal_handler3);sleep(100);
}int main() {signal(SIGTERM, signal_handler1);signal(SIGTERM, signal_handler2);pthread_t t1;pthread_create(&t1, NULL, thread_function, NULL);sleep(1);signal(SIGTERM, signal_handler4);sleep(100);return 0;
}

3.3 fork 之后，子进程与父进程共用一个 signal handler

如下代码，父进程中创建子进程之前使用 signal() 指定信号 SIGTERM 的处理函数是 signal_handler。然后创建一个子进程，在父进程中分别向子进程和父进程中发送信号 SIGTERM，可以看到子进程中的 SIGTERM 处理函数也是 signal_handler。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>void signal_handler(int sig_num) {printf("signal = %d, pid = %d\n", sig_num, getpid());
}int main() {signal(SIGTERM, signal_handler);pid_t pid = fork();if (pid == 0) {printf("子进程 id = %d, 进程组 id = %d\n", getpid(), getpgrp());while (1) {sleep(1);}} else {printf("父进程 id = %d, 进程组 id = %d\n", getpid(), getpgrp());sleep(2);kill(pid, SIGTERM);raise(SIGTERM);sleep(2);}return 0;
}

运行结果如下：

3.3 信号会被并行处理

对于一个多线程的进程来说，如果同一个信号，前一个信号还没有处理完毕，这个时候又来了一个信号，那么两个信号会并发处理吗？

会。

如下代码，有两个线程，一个主线程，一个使用 pthread_create() 创建的线程。信号 SIGTERM 的处理函数是 signal_handler。为了构造信号没有处理完毕的场景，在信号处理函数 signal_handler 中是一个死循环，一旦收到了信号，这个函数不返回。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <sys/syscall.h>void signal_handler(int sig_num) {printf("signal = %d, pid = %d, tid = %d\n", sig_num, getpid(), syscall(SYS_gettid));while (1);
}void *thread_function(void *arg) {while (1) {sleep(1);}
}int main() {signal(SIGTERM, signal_handler);pthread_t t1;pthread_create(&t1, NULL, thread_function, NULL);while (1) {sleep(1);}return 0;
}

进程运行之后，连续两次向进程发送信号，可以看到如下的打印，两次处理信号的线程，一次是 10707，一次是 10708。由此可以看出来，同一个信号并不是串行处理的，可以并行处理。

从下边的打印信息也可以看出来，信号处理函数是在线程上下文执行的，并且这个线程是我们自己创建的线程。

3.4 不可重入问题

3.4.1 什么是不可重入问题

信号相对于用户态的线程，类似于中断相对于内核态的线程。

在内核态做开发时，如果数据会被线程和中断同时访问，在线程中我们需要使用关中断自旋锁，在中断处理函数中需要使用自旋锁。这样在线程访问数据的时候，中断是关闭的，所以这个时候中断也上不来，不会打断线程的执行。如果线程中只是加自旋锁，而不关中断，这样会导致问题：因为没有关中断，在线程访问数据的时候，中断是可以打断线程的，这个时候中断要获取锁获取不到(因为自旋锁被线程拿着)，中断一直无法返回，中断无法返回就会导致线程也得不到执行，这样就造成了中断和线程之间的死锁。

内核线程：

spin_lock_irq(); // 关中断自旋锁
// do something
spin_unloc_irq();

中断处理函数：

spin_lock();
// do something
spin_unlock();

什么是信号的重入问题呢？

如下代码，有一个全局变量 g_a，这个变量会在两处修改，一个是线程 t1 中，一个是 SIGINT 的信号处理函数 signal_handler 中。如果只是在多个线程中处理，不在信号中处理，这就是我们常见的多线程并发问题，多线程并发问题可以在访问变量的地方加锁来解决。但是如果这个变量在线程中处理，也在信号中处理，就不能使用自旋锁来解决了。从上边的分析也能看出来，信号回调函数的调用是在线程上下文，并且这个调用的时机是不确定的，那就很有可能出现线程正在拿着自旋锁，这个时候线程被打断，而这个时候信号处理函数中也想拿到自旋锁，但是自旋锁被线程拿着，所以信号处理函数也拿不到自旋锁，就产生了死锁。这就是信号的重入问题，使用自旋锁无法解决。我们经常使用的 malloc()，free()，printf() 这些标准库函数都是不可重入的，也就是不能在信号处理函数中调用这些函数。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <pthread.h>int g_a = 0;void signal_handler(int signum) {printf("received signal: %d\n", signum);// pthrtead_spin_lock()g_a++;// pthread_spin_unlock()
}void *thread_function(void *arg) {while (1) {// pthread_spin_lock()g_a++;// pthread_spin_unlock()sleep(1);}
}int main() {signal(SIGINT, signal_handler);pthread_t t1;pthread_create(&t1, NULL, thread_function, NULL);while (1) {sleep(1);}return 0;
}

3.4.2 怎么避免不可重入问题

（1）直接调用系统调用，而不是标准库函数

以 printf() 为例，printf() 是向标准输出打印信息，标准输出的 fd 是 1，我们可以不使用 printf()，而是使用 write 系统调用直接向文件 1 写内容。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>int main() {printf("hello\n");char *str = "hello world\n";write(1, str, strlen(str));return 0;
}

运行结果如下：