6.1 前言
本章简单描述信号。信号是Linux系统中，内核和进程通信的一种方式。如果内核希望打断进程的顺序执行，那么内核会在进程的PCB中记录信号。而当这个进程被分配到CPU，进入执行状态时，首先会检查是否有信号，如果有信号，那么进程会先尝试执行信号处理函数。
内核需要打断进程运行的时机：
-
进程无法继续了
int* p = NULL;
*p = 100;
// 此时代码无法再继续运行，内核会发送SIGSEGV信号给进程，这是我们常见的段错误
int a = 0;
int b = 1/a;
// 除0操作，发送SIGFPE给进程
-
按下ctrl+c
ctrl+c其实是bash向前台进程组发送SIGINT
int main()
{
fork(); // 四个进程
while(1)
{
}
运行该程序后，再按Ctrl+c，结果是四个进程全部退出
int main()
{
fork();
fork(); // 四个进程
while(1)
{
}
有了signal的处理之后，ctrl+c发送的SIGINT不会导致进程退出。
6.2 信号类型
通过kill -l命令可以看到系统定义的信号类型，信号值小于32的是传统的信号，称之为非实时信号，而大于32的称之为实时信号。这里只讨论非实时信号。
6.3 信号的处理
可以通过signal函数，注册信号处理函数。如果没有注册信号处理函数，那么按照默认方式处理。
也可以通过signal设置忽略信号。
| 信号 | 默认处理动作 | 发出信号的原因 |
|---|---|---|
| SIGHUP | A | 进程session leader退出时，同session的其他进程会收到这个信号 |
| SIGINT | A | Ctrl+C |
| SIGQUIT | C | Ctrl+D |
| SIGILL | C | 非法指令 |
| SIGABRT | C | 调用abort函数产生的信号 |
| SIGFPE | C | 浮点异常 |
| SIGKILL | AEF | Kill信号 |
| SIGSEGV | C | 无效的内存引用 |
| SIGPIPE | A | 管道破裂: 写一个没有读端口的管道 |
| SIGALRM | A | 由alarm(2)发出的信号 |
| SIGTERM | A | 终止信号 |
| SIGUSR1 | A | 用户自定义信号1 |
| SIGUSR2 | A | 用户自定义信号2 |
| SIGCHLD | B | 子进程状态变化会给父进程发送SIGCHLD信号 |
| SIGCONT | 进程继续（曾被停止的进程） | |
| SIGSTOP | DEF | 暂停进程 |
| SIGTSTP | D | 控制终端（tty）上按下停止键 |
| SIGTTIN | D | 后台进程企图从控制终端读 |
| SIGTTOU | D | 后台进程企图从控制终端写 |
A 缺省的动作是终止进程
B 缺省的动作是忽略此信号
C 缺省的动作是终止进程并进行内核映像转储（dump core）
D 缺省的动作是停止进程
E 信号不能被捕获
F 信号不能被忽略
因为SIGKILL不能被捕获，那么以下代码是不正常
signal(SIGKILL, handle) //xxxx
#include <stdio.h> #include <signal.h> #include <stdlib.h> void signal_handle(int a) { if(a == SIGINT) printf("signal_handle\n"); else if(a == SIGABRT) printf("abrt\n"); else if(a == SIGALRM) printf("alarm\n"); else if(a == SIGCHLD) printf("child\n"); else if(a == SIGUSR1) printf("usr1 signal\n"); } int main() { // SIGINT 2 signal(SIGINT, signal_handle); signal(SIGABRT, signal_handle); signal(SIGALRM, signal_handle); signal(SIGCHLD, signal_handle); signal(SIGUSR1, signal_handle); pid_t pid = fork(); if(pid == 0) return 0; // 给自己发送一个abrt信号 //abort(); alarm(1); while(1) { sleep(1); } }
6.4 不可靠信号
信号值小于32的都是不可靠信号，假如进程收到一个信号来不及处理，这时候又收到一个同样的信号，那么这两个信号会合并成一个信号，这个原因是因为进程保存该信号的值只有1位。
6.5 中断系统调用（中断阻塞）
假如一个进程调用了某系统调用导致该进行处于挂起状态，而此时该进程接收到一个信号，那么该系统调用被唤醒。通常该系统调用会返回-1，错误码是EINTR。
也有些系统调用，可以设置打断后重启，这样就不会被信号打断，具体参考man 7 signal
如果使用signal函数注册信号处理函数，默认被中断的系统调用是自动重启的。
// 阻塞
int ret = read(0, buf, sizeof(buf));
printf("read data\n");
#include <signal.h> #include <stdio.h> #include <errno.h> void handle(int v){ printf("ctrl+c\n"); } int main() { signal(SIGINT, handle); char buf; int ret = read(0, buf, sizeof(buf)); // read被中断打断了 printf("ret = %d, errno=%d, EINTR=%d\n", ret, errno, EINTR); // EINTR }
6.6 可重入问题
信号会导致可重入问题，比如一个全局链表。
std::vector<int> v;
void handler(int sig)
{
v.push_back(0);
}
int main()
{
signal(SIGINT, handler);
signal(SIGUSR1, handler);
while(1)
{
// 先屏蔽所有信号
v.push_back(0);
// 再去掉屏蔽
}
}
以上代码在一定情况下会崩溃，在main函数中不停调用push_back，如果在push_back执行一半时，被中断打断，然后去执行中断处理函数时，那么该中断处理函数的push_back会崩溃。
有些系统调用本身带有局部静态变量，因此那些函数不能在信号处理函数中调用，比如strtok，readdir等，对应的可重入的函数是strtok_r，readdir_r。
6.7 发送信号
可以通过kill函数发送信号。
调用kill
发送信号
进程1
内核
进程2
kill也可以进程组发送信号
#include <sys/types.h> #include <signal.h> int main() { kill(27054, SIGUSR1); }
补充：掩盖信号
//掩盖不可靠信号 #include <signal.h> #include <stdio.h> #include <stdlib.h> // 掩盖SIGINT // 掩盖一个可靠信号 void handle(int v) { printf("sigint \n"); } int main() { signal(SIGINT, handle); sigset_t set; // 将set集合设置为空 sigemptyset(&set); // 将SIGINT信号加入集合 sigaddset(&set, SIGINT); // 把这个集合代表的信号，加入信号掩码 sigprocmask(SIG_BLOCK, &set, NULL); // 从此，该进程收到SIGINT，不会被处理 sleep(5); printf("remove SIGINT from mask\n"); // 去掉SIGINT的掩码 sigprocmask(SIG_UNBLOCK, &set, NULL); while(1) { sleep(1); } }
#include <signal.h> #include <stdio.h> #include <stdlib.h> // 掩盖34 // 掩盖一个可靠信号 void handle(int v) { printf("hahahaha \n"); } int main() { signal(34, handle); sigset_t set; // 将set集合设置为空 sigemptyset(&set); // 将34信号加入集合 sigaddset(&set, 34); // 把这个集合代表的信号，加入信号掩码 sigprocmask(SIG_BLOCK, &set, NULL); // 从此，该进程收到34，不会被处理 kill(getpid(), 34); kill(getpid(), 34); kill(getpid(), 34); kill(getpid(), 34); kill(getpid(), 34); sleep(5); printf("remove 34 from mask\n"); // 去掉34的掩码 sigprocmask(SIG_UNBLOCK, &set, NULL); while(1) { sleep(1); } }
6.8 忽略信号
signal(SIGPIPE, SIG_IGN);
#include <signal.h> void handle(int v) { } int main() { // 表示忽略SIGINT // 忽略信号和掩盖信号是有区别： // // 未决的信号：已经发出但是没有被处理的信号叫未决的信号 signal(SIGINT, SIG_IGN); // 从这里开始就不忽略 signal(SIGINT, handle); // 设置一个处理函数 signal(SIGINT, SIG_DFL); // 恢复成默认处理 while(1) { sleep(1); } }
以上例子，忽略SIGPIPE信号，那么进程收到SIGPIPE后，不会有任何反应。
6.9 屏蔽信号
屏蔽和忽略不同，忽略意味着在忽略期间，接收的信号就被忽略了。而屏蔽的意思，是暂时屏蔽，屏蔽期间收到的信号依旧在，如果某一时刻该信号不再忽略时，该信号的处理程序会被调用。
设置屏蔽集合，使用sigprocmask
6.10 SIGCHLD
SIGCHLD信号产生于子进程退出和状态变化，父进程通常在该信号的处理函数中，调用wait来回收子进程的PCB，这样可以避免阻塞。
#include <signal.h> void chld_handle(int v) { // 有子进程退出了 // wait(NULL); // while(1) // 使用while(1)是避免有多个子进程同时退出，由于SIGCHLD是不可靠信号，函数只会调用一次 { int ret = waitpid(-1, NULL, WNOHANG); // 每次回收都应该用非阻塞方式去回收 if(ret == -1) // 没有僵尸进程了，之前僵尸进程已经被回收了 break; } } int main() { // 等待子进程的结束，问题是：ddddd // 它阻塞主进程的执行，影响效率 // wait(NULL); // signal(SIGCHLD, chld_handle); pid_t pid = fork(); if(pid == 0) return 0; while(1) { sleep(1); } }
6.11 sigaction和sigqueue
sigaction和signal一样用来注册信号处理函数，siqqueue和kill一样，用来发送信号，但是sigaction比signal功能强大，signal比较简单。
强大：
-
可以传递参数
-
可以获得发送信号的进程信息
-
可以设置SA_RESTART
#include <signal.h> #include <stdio.h> #include <errno.h> //void handle(int v){} // // 新的信号处理函数 void handle(int v, siginfo_t* info, void* p) { printf("ctrl+c\n"); } int main() { // 默认的signal已经有SA_RESTART这个flag了 //signal(SIGINT, handle); struct sigaction sig; sig.sa_handler = NULL; sig.sa_sigaction = handle; sigemptyset(&sig.sa_mask); // sig.sa_flags = 0; sig.sa_flags = SA_RESTART; // 让阻塞的系统调用，被这个信号打断之后，要重启 sig.sa_restorer = NULL; // 在Linux下没用，直接填NULL就可以了 sigaction(SIGINT, &sig, NULL); char buf; int ret = read(0, buf, sizeof(buf)); // read被中断打断了 printf("ret = %d, errno=%d, EINTR=%d\n", ret, errno, EINTR); // EINTR }
#include <stdio.h> #include <stdlib.h> #include <signal.h> char buf[1024]; void handle_data() { printf("user input is %s\n", buf); } void handle_chld1(int v) { while(1) { int ret = waitpid(-1, NULL, WNOHANG); if(ret < 0) break; } } void handle_chld(int v, siginfo_t* info, void* p) { handle_chld1(v); } int main() { // signal(SIGCHLD, handle_chld); struct sigaction act; act.sa_handler = NULL; act.sa_sigaction = handle_chld; sigemptyset(&act.sa_mask); act.sa_flags = 0; act.sa_restorer = NULL; sigaction(SIGCHLD, &act, NULL); while(1) { // char* ret = fgets(buf, sizeof(buf), stdin); // if(ret == NULL) break; int ret = read(0, buf, sizeof(buf)); if(ret < 0) { // 说明read出错，不是真正的出错，而是被中断打扰了 // 那此时，应该重新调用read函数，去获取信息 if(errno == EINTR) { continue; } // 如果是其他错误原因，就break break; } pid_t pid = fork(); if(pid == 0) { handle_data(); // 创建一个子进程去处理数据 exit(0); } } }
#include <signal.h> #include <stdio.h> void handle(int v, siginfo_t* info, void* p) { printf("recv SIGINT, arg=%d\n", info->si_value.sival_int); } int main() { struct sigaction act; act.sa_handler = NULL; act.sa_sigaction = handle; sigemptyset(&act.sa_mask); act.sa_flags = SA_SIGINFO|SA_RESTART; act.sa_restorer = NULL; // 注册信号处理函数 sigaction(SIGINT, &act, NULL); union sigval v; v.sival_int = 99; // 相当于kill，但是它可以传递一个参数 sigqueue(getpid(), SIGINT, v); getchar(); }
#include <signal.h> #include <stdio.h> int main() { char* p = malloc(100); union sigval v; // v.sival_int = 98; v.sival_ptr = p; // 相当于kill，但是它可以传递一个参数 sigqueue(28360, SIGINT, v); getchar(); }
6.12 函数命令
signal：注册信号处理函数
kill：发送信号
sigprocmask：设置信号掩码
sigemptyset：清空信号集
sigfillset：设满信号集
sigaddset：往信号集增加一个信号
sigdelset：从信号集删除一个信号
sigismember：判断信号否则在信号集
sigaction：注册更加强大的处理函数
sigqueue：发送信号
abort
alarm
pause