Linux进程信号

目录

一、认识信号

1.1 生活角度的信号

1.2 技术角度的信号

1.3 信号的发送与记录

1.4 常见信号处理方式

二、产生信号

2.1 通过终端按键产生信号(核心转储)

2.2 通过系统函数向进程发送信号

2.2.1 kill()函数

2.2.2 raise()函数

2.2.3 abort()函数

2.3 因软件条件产生信号

2.3.1 SIGPIPE信号

2.3.2 SIGALRM信号

2.4 因硬件异常产生信号

三、阻塞信号

3.1 相关概念认识

3.2 内核层理解

3.3 sigset_t

3.4 信号集操作函数

3.5 sigprocmask && sigpending

3.5.1 sigprocmask

3.5.2 sigpending

3.6 实验测试

四、捕捉信号

4.1 内核空间与用户空间

4.2 内核态与用户态

4.3 内核实现信号捕捉

4.4 sigcation

五、SIGCHLD信号

六、可重入函数

---

一、认识信号

1.1 生活角度的信号

• 在网上买了很多件商品，在等待不同商品快递的到来。但即使快递并没有到来，你也知道快递到了后应该如何处理快递，即你能"识别快递"
• 当快递到达目的地，你收到了快递到来的通知，但不一定要马上下楼取快递，也就是说取快递的行为并不是一定要立即执行，可以理解成在"在合适的时候去取"
• 在你收到快递到达的通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间内你并没有拿到快递，但是你知道快递已经到了，即你"记住了有一个快递要去取"
• 当时间合适，顺利拿到快递后，就要开始处理快递了，而处理快递的方式有三种：1、执行默认动作（打开快递，使用商品）2、执行自定义动作（快递是帮别人买的，你要将快递交给他）3、忽略（拿到快递后，放在一边继续做自己的事）
• 快递到来的整个过程，对你来讲是异步的，因为你不能确定你的快递何时到达

1.2 技术角度的信号

#include <iostream>
#include <unistd.h>
int main()
{
	while (1) {
		std::cout << "hello signal!" << std::endl;
		sleep(1);
	}
	return 0;
}

为什么输入Ctrl + c之后本该死循环的进程会被终止呢？

实际上当用户按Ctrl+C时，这个键盘输入会产生一个硬中断，被操作系统获取并解释成信号（Ctrl+C被解释成2号信号），然后操作系统将2号信号发送给目标前台进程，当前台进程收到2号信号后就会退出。

可以使用signal()函数对2号信号进行捕捉，证明按Ctrl+C时进程确实收到了2号信号

typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

#include <iostream>
#include <signal.h>
#include <unistd.h>
void handler(int signum) {
    std::cout << "get a signal : " << signum << std::endl;
}
int main()
{
    signal(2, handler);
    while (1) {
		std::cout << "hello signal!" << std::endl;
		sleep(1);
	}
    return 0;
}

注意：

• Ctrl+C产生的信号只能发送给前台进程。在一个命令后面加个&就可以将其放到后台运行，此时Shell就不必等待进程结束就可直接接收新的命令
• Shell可以同时运行一个前台进程和任意多个后台进程，只有前台进程才能接到类似于Ctrl + c这种控制键产生的信号
• 前台进程在运行过程中，随时都可能因按下Ctrl+C而产生一个信号。所以该进程的用户空间代码执行到任何地方都可能收到2号信号而终止，所以信号相对于进程的控制流程来说是异步的
• 信号是进程之间事件异步通知的一种方式，属于软中断

1.3 信号的发送与记录

可以使用 kill -l 命令查看Linux中的信号列表

其中1~31号信号是普通信号，34~64号信号是实时信号，各有31个。

每个信号都有一个编号和一个宏定义名称：/usr/include/bits/signum.h

进程是如何记录信号的呢？

当一个进程接收到某种信号后，该信号被记录在该进程的进程控制块当中。通过一个32位的位图记录信号是否产生

其中bit位的位置代表信号的编号，而bit位的内容就代表是否收到对应信号，比如第6个bit位是1就表明收到了6号信号

信号是如何发送给进程的呢？

一个进程收到信号，本质就是该进程内的信号位图被修改了，即该进程的数据被修改了，而只有操作系统才有资格修改进程的数据，因为操作系统是进程的管理者。也就是说，信号的发送本质上就是操作系统直接去修改目标进程的task_struct中的信号位图。

1.4 常见信号处理方式

1. 执行该信号的默认处理动作
2. 提供一个信号处理函数，要求内核在处理该信号时切换到用户态执行这个处理函数，这种方式称为捕捉（Catch）一个信号
3. 忽略该信号

可以使用 man 7 signal 查看各个信号的默认处理动作

二、产生信号

2.1 通过终端按键产生信号(核心转储)

通过上面了解到Ctrl + c可以终止前台进程，而Ctrl + \也可以。那么两者有什么区别吗？

Ctrl + c是向进程发送2号信号SIGINT，而Ctrl  +\是向进程发送3号信号SIGQUIT。这两个信号的默认处理动作Action是不一样的，2号信号是Term，而3号信号是Core。

Term和Core都代表着终止进程，但是Core在终止进程时会进行一个动作（核心转储）

什么是核心转储？

在云服务器中，核心转储是默认关闭的，可以使用 ulimit -a 查看当前资源限制的设定

core file size为0就说明此时核心转储是关闭的，可以使用 ulimit -c size设置core文件大小

注意： ulimit命令改变的是bash进程的Resource Limit，但test进程的PCB是由bash进程复制而来，所以也具有和bash进程相同的Resource Limit值

设置完core文件大小后相当于打开了核心转储，此时使用Ctrl + \终止进程会显示 core dumped

并且当前路径下出现了一个新文件，该文件以一串数字为后缀，那一串数字其实是发生本次核心转储的进程的PID

认识coredump文件

• coredump文件又被称为核心转储文件
• 进程运行时，突然崩溃的那一瞬间，进程在内存中的一个快照。会把进程此刻内存、寄存器状态、运行堆栈等信息转储保存在一个文件中

核心转储功能的作用

当程序在运行过程中崩溃了，一般会通过调试来进行逐步查找程序崩溃的原因。而在某些特殊情况下，会用到核心转储，核心转储指的是操作系统在进程收到某些信号而终止运行时，将该进程地址空间的内容以及有关进程状态的其他信息转而存储到一个磁盘文件中，这个磁盘文件也叫做核心转储文件，一般命名为core.pid。而核心转储的目的就是为了在调试时，方便问题的定位

#include <iostream>
#include <unistd.h>
int main()
{
    std::cout << "I am running!!!" << std::endl;
    sleep(3);
    int err = 10 / 0;//除0错误
    return 0;
}

上述程序发生除0错误，休眠3秒后就会崩溃

使用gdb对可执行程序进行调试，然后使用 core-file core文件 命令加载core文件，即可判断出该程序在终止时收到了8号信号，并且定位到了产生该错误的具体代码

或者直接gdb 调试文件 core文件进行调试

core dump标志

wait()和waitpid()都有一个参数int* status，这是一个输出型参数，用于获取子进程的退出状态的。

status是一个整型变量，但应将status变量看作是一个存储信息的位图，status的不同bit位所代表的信息不同，具体细节如下（只讲解status低16个bit位）：

若进程是正常终止的，那么status的次低8位就表示进程的退出状态，即退出码。若进程是被信号所杀，那么status的低7位表示终止信号，而第8位比特位是core dump标志（用于表示进程终止时是否进行了核心转储）

打开Linux的核心转储功能。代码中父进程创建一个子进程，子进程所执行的代码中存在野指针问题，当子进程执行到*p = 100时，会被操作系统所终止并进行核心转储。此时父进程使用waitpid函数获取到子进程退出时的状态，根据status的第7个bit位就可得知子进程在被终止时是否进行了核心转储

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
using namespace std;
int main()
{
	if (fork() == 0) {//child
		std::cout << "I am running..." << std::endl;
		int *p = nullptr;
		*p = 100;//野指针
		exit(0);
	}
	//father
	int status = 0;
	waitpid(-1, &status, 0);
    std::cout << "exit_code:" << WEXITSTATUS(status) << std::endl;
    std::cout << "core_dump:" << WCOREDUMP(status) << std::endl;
    std::cout << "trem_signal:" << WTERMSIG(status) << std::endl;
	
	return 0;
}

说明发生了核心转储

2.2 通过系统函数向进程发送信号

2.2.1 kill()函数

可以使用kill命令向进程发送信号，也可以使用系统函数向进程发送信号，譬如kill()函数

int kill(pid_t pid, int sig);//向进程ID为pid的进程发送sig号信号
//若信号发送成功则返回0，否则返回-1并设置errno

可以使用kill()函数模拟实现一个kill命令

#include <iostream>
#include <cstdlib>
#include <vector>
#include <sys/types.h>
#include <signal.h>

void Usage(const char* str) {
    std::cout << "Usage : " << str << "pid signo" << std::endl;   
}
int main(int argc, char* argv[]) 
{
    if(argc < 3) {
        Usage(argv[0]);
    }

    int signum = atoi(argv[1]);

    std::vector<pid_t> v;
    for(int i = 2; i < argc; ++i) {
        v.push_back(atoi(argv[i]));
    }

    for(auto &e : v) {
        kill(e, signum);
    }
    return 0;
}

为了可执行程序在执行时不用带上路径，将当前路径临时导入环境变量PATH当中 

2.2.2 raise()函数

raise()函数可以给当前进程发送指定信号，即自己给自己发送信号

int raise(int sig);//若信号发送成功则返回0，否则返回一个非零值

2.2.3 abort()函数

abort()函数可以给当前进程发送SIGABRT信号，使得当前进程异常终止

void abort(void);

#include <iostream>
#include <cstdlib>
#include <signal.h>
#include <unistd.h>
using namespace std;

void handler(int signum) {
    cout << "get a signal : " << signum << endl;
}
int main()
{
    signal(SIGABRT,handler);

    while(true) {
        sleep(1);
        abort();
    }
    return 0;
}

虽然对SIGABRT信号进行了捕捉，并且收到SIGABRT信号后执行了自定义方法，但进程依然异常终止

2.3 因软件条件产生信号

2.3.1 SIGPIPE信号

SIGPIPE信号是一种由软件条件产生的信号。当进程在使用管道通信时，读端进程将读端关闭，而写端进程还在一直向管道写入数据，那么写端进程就会收到SIGPIPE信号进而终止

#include <iostream>
#include <unistd.h>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main()
{
    //使用pipe创建匿名管道
	int fd[2] = { 0 };
	if (pipe(fd) < 0) {
		perror("pipe");
		exit(1);
	}

	pid_t id = fork();
	if (id == 0) { //child
		close(fd[0]);
		const char* msg = "hello father, I am child...";
        for(int i = 0;i < 10; ++i) {
            write(fd[1], msg, strlen(msg));
			sleep(1);
        }
		close(fd[1]);
		exit(0);
	}
    else if(id > 0) { //father
        close(fd[1]);
	    close(fd[0]);
	    int status = 0;
	    waitpid(id, &status, 0);
	    cout << "child get signal:" << WTERMSIG(status) << endl; //打印子进程收到的信号
    }
    else {
        perror("fork error");
        exit(1);
    }
	
	return 0;
}

2.3.2 SIGALRM信号

调用alarm()函数可以设定闹钟，让操作系统在seconds秒之后给当前进程发送SIGALRM信号，SIGALRM信号的默认处理动作是终止进程

unsigned int alarm(unsigned int seconds);

返回值：

• 若调用alarm函数前，已设置过闹钟，则返回上一个闹钟时间的剩余时间，并且本次闹钟的设置会覆盖上一次闹钟的设置
• 若调用alarm函数前，进程没有设置闹钟，则返回值为0

//测试云服务器一秒时间内可以将一个变量累加到多大(存在大量IO)
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int main()
{
	int count = 0;
	alarm(1);
	while (1) {
		count++;
		printf("count: %d\n", count);
	}
	return 0;
}

CPU都是每秒上亿级的运算，但这个结果相差甚远。

为什么呢？是因为与外设之间大量的IO和云服务本身要通过网络传输数据。

//减少IO后的代码
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

int count = 0;
void handler(int signum) {
    printf("get a signal: %d\n", signum);
    printf("count: %d\n", count);
    exit(0);
}
int main()
{
    signal(SIGALRM, handler);
	alarm(1);
	while (1) {
		count++;
	}
	return 0;
}

减少与外设的IO后，count由七万多提升至了五亿多

2.4 因硬件异常产生信号

当程序当中出现类似于除0、野指针、越界之类的错误时，进程在运行过程中会收到操作系统发来的信号从而终止，那操作系统是如何识别到一个进程触发了某种问题的呢？

CPU当中有一组寄存器被称为状态寄存器，它可用来标记当前指令执行结果的各种状态信息，如有无进位、有无溢出等。而操作系统是软硬件资源的管理者，在程序运行过程中，若操作系统发现CPU内的某个状态标志位被置位，而这次置位就是因为某种除0错误而导致的，那么此时操作系统就会马上识别到当前是哪个进程导致的该错误（发生这种运行时错误的一定是此时CPU调度的进程），并将所识别到的硬件错误包装成信号发送给目标进程。本质就是操作系统去找到这个进程的task_struct，并向该进程的位图中写入8信号，写入8号信号后这个进程就会在合适的时候被终止。

具体案例：野指针问题

#include <stdio.h>
int main() 
{
    printf("I am running!!!\n");
    int* ptr = NULL;
    *ptr = 100;
    return 0;
}

当要访问一个变量时，首先要先经过页表的映射，将虚拟地址转换成物理地址，然后才能进行相应的访问操作。

页表属于一种软件映射关系，而实际上在从虚拟地址到物理地址映射的时候还涉及到一个硬件MMU，它是一种负责处理CPU的内存访问请求的计算机硬件，映射工作就是由MMU完成的，现在MMU基本上都已经集成到CPU当中了。

MMU既然是硬件单元，那么它当然也有相应的状态信息。当访问错误的虚拟地址时，MMU在进行虚拟地址到物理地址的转换时就会出现错误，其会将对应的错误写入到自己的状态信息当中，此时硬件上的信息会立马被操作系统识别，进而向对应进程发送SIGSEGV信号

总结：

C/C++程序会崩溃，是因为程序当中出现的各种错误最终一定会在硬件层面上有所表现，进而会被操作系统识别到，然后操作系统就会发送相应的信号将当前的进程终止

三、阻塞信号

3.1 相关概念认识

• 实际执行信号的处理动作，称为信号递达（Delivery）
• 信号从产生到递达之间的状态，称为信号未决（pending）
• 进程可以选择阻塞（Block）某个信号，被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作
• 阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后的一种处理动作

3.2 内核层理解

• 在block位图中，bit位的位置代表某一个信号，biit位的内容代表该信号是否被阻塞
• 在pending位图中，bit位的位置代表某一个信号，bit位的内容代表是否收到该信号
• handler表本质上是一个函数指针数组，数组的下标代表某一个信号，数组的内容代表该信号递达时的处理动作，处理动作包括默认、忽略以及自定义
• block、pending和handler这三张表的每一个位置是一一对应的
• 每个信号都有两个标志位分别表示阻塞和未决，还有一个函数指针指向处理方法。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作（未产生则不会递达）
• SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然其处理动作是忽略，但在没有递达前不能忽略这个信号，因为进程仍有机会在改变处理动作之后再解除阻塞
• SIGQUIT信号未产生过，但一旦产生SIGQUIT信号，该信号将被阻塞，它的处理动作是用户自定义函数sighandler
• 若在进程解除对某信号的阻塞之前，这种信号产生过多次，POSIX.1允许系统递达该信号一次或多次。Linux是这样实现的：普通信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里（这里只讨论普通信号）

3.3 sigset_t

sigset_t被称为信号集，这个类型可以表示每个信号的"有效"或"无效"状态

• 在阻塞信号集中"有效"和"无效"的含义是该信号是否被阻塞。
• 在未决信号集中"有效"和"无效"的含义是该信号是否处于未决状态

阻塞信号集也被称为当前进程的信号屏蔽字，"屏蔽"应该理解为阻塞而不是忽略

3.4 信号集操作函数

sigset_t类型对于每种信号用一个bit位表示"有效"或"无效"，至于这个类型内部如何存储这些bit则依赖于系统的实现，从使用者的角度是不必关心的，使用者只能调用以下函数来操作sigset_t变量，而不应该对它的内部数据做任何解释，比如用printf()直接打印sigset_t变量是没有意义的。

#include <signal.h>

int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signum);
int sigdelset(sigset_t *set, int signum);
int sigismember(const sigset_t *set, int signum);  

• sigemptyset函数：初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号
• sigfillset函数：初始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号
• sigaddset函数：在set所指向的信号集中添加某种有效信号
• sigdelset函数：在set所指向的信号集中删除某种有效信号
• sigemptyset、sigfillset、sigaddset和sigdelset函数都是成功返回0，出错返回-1
• sigismember函数：判断在set所指向的信号集中是否包含某种信号，若包含则返回1，不包含则返回0，调用失败返回-1

注意： 

1. 在使用sigset_t类型的变量前，一定要调用sigemptyset()或sigfillset()初始化，使信号处于确定的状态
2. 代码中定义的sigset_t类型的变量s存在栈区，使用上面的函数只会对变量s造成影响，并不会影响进程的任何行为。还需通过sigprocmask()函数，才能将变量s的数据设置进操作系统

3.5 sigprocmask && sigpending

3.5.1 sigprocmask

sigprocmask()函数可用于读取或更改进程的信号屏蔽字（阻塞信号集）

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

• 若oset是非空指针，则读取进程当前的信号屏蔽字通过oset参数传出
• 若set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改
• 若oset和set都是非空指针，则先将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字

how选项：

返回值：sigprocmask函数调用成功返回0，出错返回-1

3.5.2 sigpending

sigpending()函数用于读取进程的未决信号集

int sigpending(sigset_t *set);

sigpending()函数读取当前进程的未决信号集，通过set参数传出。该函数调用成功返回0，出错返回-1

3.6 实验测试

步骤：

1. 先用上述的函数将2号信号进行屏蔽（阻塞）。
2. 使用kill命令或组合按键向进程发送2号信号。
3. 此时2号信号会一直被阻塞，并一直处于pending（未决）状态。
4. 使用sigpending函数获取当前进程的pending信号集进行验证

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void PrintPending(sigset_t *pending)
{
	for (int i = 1; i <= 31; i++) {
		if (sigismember(pending, i)) cout << "1 ";
		else cout << "0 ";
	}
	cout << endl;
}
int main()
{
	sigset_t set, oset;
    sigset_t pending;
    //清空信号集
	sigemptyset(&set);
	sigemptyset(&oset);
    sigemptyset(&pending);

	sigaddset(&set, 2);//添加2号信号
	sigprocmask(SIG_SETMASK, &set, &oset);//将数据设置进内核，阻塞2号信号

	while (1) {
		sigpending(&pending); //获取pending
		PrintPending(&pending); //打印pending位图
		sleep(1);
	}
	return 0;
}

程序刚刚运行时，因为没有收到任何信号，所以此时该进程的pending表一直是全0。当使用kill命令向进程发送2号信号后，由于2号信号是阻塞的，所以2号信号一直处于未决状态，所以pending表中的第二个数字一直是1

为了看到2号信号递达后pending表的变化，可以设置一段时间后解除2号信号的阻塞状态，但解除2号信号的阻塞后2号信号就会立即被递达。2号信号的默认处理动作是终止进程，所以为了看到2号信号递达后的pending表，可以将2号信号进行捕捉，让2号信号递达时执行自定义动作

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void handler(int signum) {
	cout << "handler signo: " << signum << endl;
}
void PrintPending(sigset_t *pending)
{
	for (int i = 1; i <= 31; i++) {
		if (sigismember(pending, i)) cout << "1 ";
		else cout << "0 ";
	}
	cout << endl;
}
int main()
{
	signal(2, handler);

	sigset_t set, oset;
    sigset_t pending;
    //清空信号集
	sigemptyset(&set);
	sigemptyset(&oset);
    sigemptyset(&pending);

	sigaddset(&set, 2);//添加2号信号
	sigprocmask(SIG_SETMASK, &set, &oset);//将数据设置进内核，阻塞2号信号

	int count = 0;
	while (1) {
		sigpending(&pending); //获取pending
		PrintPending(&pending); //打印pending位图
		sleep(1);
		++count;

		if(count == 20) { //恢复曾经的信号屏蔽字
			sigprocmask(SIG_SETMASK, &oset, NULL);
			cout << "恢复信号屏蔽字" << endl;
		}
	}
	return 0;
}

进程收到2号信号后，该信号在一段时间内处于未决状态，当解除2号信号的屏蔽后，2号信号就会立即递达，执行我们所给的自定义动作，而此时的pending表也变回了全0 

四、捕捉信号

4.1 内核空间与用户空间

每个进程都有自己的进程地址空间，该进程地址空间由内核空间和用户空间组成：

• 用户所写的代码和数据位于用户空间，通过用户级页表与物理内存之间建立映射关系
• 内核空间存储的实际上是操作系统代码和数据，通过内核级页表与物理内存之间建立映射关系

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，所有进程看到的都是一样的内容

虽然每个进程都能够看到操作系统，但并不意味着每个进程都能够随时对其进行访问.当访问用户空间时必须处于用户态，当访问内核空间时必须处于内核态

4.2 内核态与用户态

• 内核态通常用来执行操作系统的代码，是一种权限非常高的状态
• 用户态是一种用来执行普通用户代码的状态，是一种受监管的普通状态

进程收到信号之后，并不是立即处理信号，而是在合适的时候进行处理。"合适的时候"就是指，从内核态切换回用户态的时候

从用户态切换为内核态：

1. 需要进行系统调用时
2. 当前进程的时间片到了，导致进程切换
3. 产生异常、中断、陷阱等

从内核态切换为用户态：

1. 系统调用返回时
2. 进程切换完毕
3. 异常、中断、陷阱等处理完毕

由用户态切换为内核态被称之为陷入内核。每当需要陷入内核时，本质上是因为需要执行操作系统的代码。比如系统调用函数是由操作系统实现的，要进行系统调用就必须先由用户态切换为内核态

4.3 内核实现信号捕捉

当我们在执行主控制流程的时候，可能因为某些情况而陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending的检查。（此时仍处于内核态，有权力查看当前进程的pending位图）

在查看pending位图时，若发现未决信号，且该信号没有被阻塞，那么此时就需要该信号进行处理。若待处理信号的处理动作是默认或者忽略，则执行该信号的处理动作后清除对应的pending标志位，若没有新的信号要递达，就直接返回用户态，从主控制流程中上次被中断的地方继续向下执行即可

但若待处理信号是自定义捕捉的（用户提供处理方法），那么处理该信号时就需要先返回用户态执行对应的自定义处理动作，执行完后再通过特殊的系统调用sigreturn再次陷入内核并清除对应的pending标志位。若没有新的信号要递达，就直接返回用户态，继续执行主控制流程的代码

注意：sighandler和main函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程。sighandler是内核线程调用的(内核线程服务于多个进程)

简化上图:

该图形与直线有几个交点就代表在这期间有几次状态切换，而箭头的方向就代表着此次状态切换的方向，图形中间的圆点就代表着检查pending表。

当识别到信号的处理动作是自定义时，能直接在内核态执行用户空间的代码吗？

看似可以，因为内核态是一种权限非常高的状态，但是绝对不能这样设计。

若允许在内核态直接执行用户空间的代码，那么恶意用户就可以在代码中设计一些非法操作，比如清空数据库等，虽然在用户态时没有足够的权限清空数据库，但是在内核态时是有足够权限清空数据库的。即不能让操作系统直接去执行用户的代码，因为操作系统无法保证用户的代码是合法代码，即操作系统不信任用户

4.4 sigcation

捕捉信号除了使用signal()函数外，还可以使用sigaction()函数

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

sigaction()函数可以读取和修改与指定信号相关联的处理动作，该函数调用成功返回0，出错返回-1

• signum代表指定信号的编号
• 若act指针非空，则根据act修改该信号的处理动作
• 若oldact指针非空，则通过oldact传出该信号原来的处理动作

struct sigaction {
	void(*sa_handler)(int);
	void(*sa_sigaction)(int, siginfo_t *, void *);
	sigset_t   sa_mask;
	int        sa_flags;
	void(*sa_restorer)(void);
};

sa_handler

• 将sa_handler赋值为SIG_IGN传给sigaction函数，表示忽略信号
• 将sa_handler赋值为SIG_DFL传给sigaction函数，表示执行系统默认动作
• 将sa_handler赋值为一个函数指针，表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数

注意： 所注册的信号处理函数的返回值为void，参数为int。通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。这是一个回调函数，但不是被main函数调用，而是被操作系统所调用

sa_sigaction

sa_sigaction是实时信号的处理函数

sa_mask

当某个信号的处理函数被调用，内核自动将当前信号加入进程的信号屏蔽字，当信号处理函数返回时自动恢复原来的信号屏蔽字，这样就保证了在处理某个信号时，若这种信号再次产生，那么它会被阻塞到当前处理结束为止。

若在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时，会自动恢复成原来的信号屏蔽字。

sa_flags

sa_flags字段包含一些选项，这里直接将sa_flags设置为0即可

sa_restorer

暂时不使用该参数

五、SIGCHLD信号

为了避免出现僵尸进程，父进程需要使用wait或waitpid函数等待子进程结束，父进程可以阻塞等待子进程结束，也可以非阻塞地轮询是否有子进程结束等待清理。采用第一种方式，父进程阻塞时就不能处理自己的工作了；采用第二种方式，父进程在处理自己的工作的同时还要记得时不时地轮询一下，且程序实现复杂。

其实，子进程在终止时操作系统会给父进程发生SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理动作，这样父进程就只需专心处理自己的工作，不必关心子进程了，子进程终止时会通知父进程，父进程在信号处理函数中调用wait或waitpid函数清理子进程即可。

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
using namespace std;

void handler(int signo)
{
	cout << "get a signal:" << signo << endl;
	int ret = 0;
	while ((ret = waitpid(-1, NULL, WNOHANG)) > 0) {
		cout << "wait child " << ret << " success" << endl;
	}
    exit(0);
}
int main()
{
	signal(SIGCHLD, handler);
	if (fork() == 0) {//child
		cout << "child is running, PID: " << getpid() << endl;
		exit(1);
	}
	//father
	while (1);

	return 0;
}

• SIGCHLD属于普通信号，记录该信号的pending位只有一个，在同一时刻可能有多个子进程同时退出，那么使用waitpid()函数清理子进程时需要使用while不断进行清理
• 使用waitpid()函数时，需要设置WNOHANG选项，即非阻塞式等待。否则当所有子进程都已经清理完毕时，由于while循环，会再次调用waitpid函数，此时就会阻塞住

要想不产生僵尸进程还有另外一种办法：父进程调用signal或sigaction函数将SIGCHLD信号的处理动作设置为SIG_IGN，这样子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程。系统默认的忽略动作和用户用signal或sigaction函数自定义的忽略通常是没有区别的，但这是一个特列。此方法对于Linux可用，但不保证在其他UNIX系统上都可用

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
using namespace std;

int main()
{
	signal(SIGCHLD, SIG_IGN);
	if (fork() == 0) { //child
		cout << "child is running, PID: " << getpid() << endl;
		sleep(3);
		exit(1);
	}
	//father
	while (1);

	return 0;
}

六、可重入函数

若主函数中调用insert()函数向链表中插入结点node1，且某信号处理函数中也调用了insert函数向链表中插入结点node2，貌似并没有什么问题

1、首先，main函数中调用了insert函数，想将结点node1插入链表，但插入操作分为两步，刚做完第一步的时候，因为硬件中断使进程切换到内核，再次回到用户态之前检查到有信号待处理，于是切换到sighandler函数

2、而sighandler函数中也调用了insert函数，将结点node2插入到了链表中。当结点node2插入的两步操作都做完之后从sighandler返回内核态

3、再次回到用户态就从main函数调用的insert函数中继续往下执行，即继续进行结点node1的插入操作

最终结果是，main函数和sighandler函数先后向链表中插入了两个结点，但最后只有node1结点真正插入到了链表中，而node2结点就找不到了，造成了内存泄漏

如上例，insert函数被不同的控制流调用（main函数和sighandler函数使用不同的堆栈空间，它们之间不存在调用与被调用的关系，是两个独立的控制流程），有可能在第一次调用还没返回时就再次进入该函数，这种现象被称之为重入

insert函数访问一个全局链表，有可能因为重入而造成错乱，这样的函数被称之为不可重入函数；反之，若一个函数只访问自己的局部变量或参数，则称之为可重入函数

一个函数符合以下条件之一就一定是不可重入的：

1. 调用了malloc或free，因为malloc也是用全局链表来管理堆的
2. 调用了标准I/O库函数，因为标准I/O库的很多实现都以不可重入的方式使用全局数据结构