Linux进程信号

信号入门

生活角度的信号

1. 你在网上买了很多件物品，在等待不同物品快递的到来，但即使快递还没有到，你也知道快递到了应该怎么处理快递，也就是你可以“识别快递”。
2. 当快递员到了你楼下，你也收到快递到来的通知，但是你正在打游戏，需要5分钟之后才能去取快递。那么在这5分钟之内，你没有下去取快递，但是你知道有快递到了，也就是取快递的行为表示一定要执行的，可以理解成“在合适的时候去取”。
3. 在收到通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间，你并没有取到快递，但是你知道有一个快递已经来了，本质上是你“记住了有一个快递要去取”。
4. 当你时间合适，顺利拿到快递之后，就要开始处理快递了。而处理快递一般方式有三种：1.执行默认动作（幸福地打开快递，使用商品）2.执行自定义动作（快递是零食，你要送给你的朋友）3.忽略（拿到快递后，丢到一边，继续开一把）。
5. 快递到来的整个过程，对你来说是异步的，你不能准确断定快递员什么时候打电话给你。

技术应用角度的信号

 我们执行下列代码：

#include <stdio.h>
#include <unistd.h>

int main()
{
	while (1){
		printf("this is a sigal!\n");
		sleep(1);
	}
	return 0;
}

 运行结果如下：

我们可以发现，这段代码是一个死循环代码，在遇到死循环的时候，最好的方法就是Ctrl+C来终止该进程。

为什么按下Ctrl+C之后，进程就会终止了呢？

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

我们可以使用signal函数对2号信号捕捉：

signal函数：

1. 第一个参数为需要捕捉的信号编号。
2. 第二个参数是处理方法，处理方法的参数为int，返回值为void。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

//对捕捉到的信号的自定义处理方法
void handle(int signo)
{
	printf("get a signal:%d\n", signo);
}

int main()
{
	signal(2, handle); //注册2号信号交给handle处理
	while (1){
		printf("hello signal!\n");
		sleep(1);
	}
	return 0;
}

运行结果如下：

可以发现，我们此时按下Ctrl+C也不能中断进程了，而是被捕捉然后自定义处理了。

需要注意的是：

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

信号的发送和记录

在Linux中有很多信号，我们可以使用 kill -l命令来查看信号列表：

其中1-31号信号是普通信号，34-64号信号是实时信号，普通信号和实时信号各自有31个，每个信号都有一个编号和一个对应宏定义名称（解释到底出什么问题了）

信号是怎么被记录下来的？ 

当一个进程接收到某个信号后，该信号是被记录在进程的进程控制块中，我们知道进程控制块本质是一个结构体变量，该结构体变量里面有一个32位的位图来记录信号是否产生。

其中比特位的位置代表信号的编号，比特位的内容代表是否收到对应信号，例如上图：第6个比特位是1，那么代表收到了6号信号 

信号是怎么产生的？

一个进程收到信号，本质上是该进程内的信号位图被修改了，也就是进程的数据被修改了，但进程的数据只有操作系统才能修改，毕竟操作系统是进程的管理者，所以，信号产生的本质就是操作系统直接修改目标进程的task_struct中的信号位图。

需要注意的是：

信号只能由操作系统发生，但是发送的方式有很多种。

信号的处理

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

我们可以用 man 7 signal 来查看各个信号的默认处理动作：

产生信号

通过终端按键产生信号

除了按下Ctrl+C可以终止进程外，还可以按下Ctrl+\进程：

Ctrl+C与Ctrl+\有什么区别？ 

在前面我们知道，Ctrl+C是向进程发送2号信号SIGINT，而Ctrl+\实际上是向进程发送3号信号SIGQUIT。我们可以查看这两个信号的默认处理动作。

可以看到，2号是Term，3号是Core，这两个都代表着终止进程，但是，Core在终止进程的时候会进行另一个动作，那就是核心转储。

核心转储是什么？

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

我们可以看到，第一行的 core file size显示文件大小为0，那么就表示核心转储是关闭的。

打开核心转储并设置核心转储大小

我们可以通过 ulimit -c size 命令来设置core文件的大小：

可以看到，此时核心转储功能就打开了，此时大小为1024，我们可以再次Ctrl+\来查看：

这次出现了提示 core dumped。

并且当前路径会生成一个core文件，以数字结尾：

可以看到，这串数字是和进程的PID相同，也就是核心转储的进程。 

需要注意的是：

ulimit命令改变了Shell进程的Resource Limit，但是proc进程的PCB是由Shell进程复制而来的，所以也具有和Shell进程相同的Resource Limit值。

核心转储有什么用？

核心转储指的是操作系统在进程收到某个信号而终止运行时，将该进程地址空间的内容以及有关进程状态的其他信息转储到一个磁盘文件中，也叫做核心转储文件，一般命名为 core.pid。

核心转储是用来调试查找程序崩溃的原因。

我们可以使用 gdb调试该程序，然后输入 core-file core.pid来加载core文件：

可以看到，该进程是收到了3号信号（Ctrl+C）而终止的。

当出错后再检查core文件来查明原因，叫做事后调试。

core dump的标志

还记得我们之前学过的 waitpid函数吗？

pid_t waitpid(pid_t pid, int *status, int options);

这里的第二个参数status是一个输出型参数，用于获取子进程的退出状态，status是一个整型变量，但不能简单的当作整型来看待：

现在，我们在打开核心转储功能，执行以下代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>

int main()
{
	if (fork() == 0){
		//child
		printf("this is child...\n");
		int *p = NULL;
		*p = 100;
		exit(0);
	}
	int status = 0;
	waitpid(-1, &status, 0);
	printf("exitcode: %d, coredump: %d, signal: %d\n",(status >> 8) & 0xff, (status >> 7) & 1, status & 0x7f);
	return 0;
}

运行结果如下：

 可以看到，此时status的第七个比特位为1，说明发生了核心转储。

9号信号

如果我们将所有信号都进行捕捉，那么进程是不是无法被杀死了？

理论上是这样的，实际上9号信号是不可以被用来执行自定义动作的，一旦接收到9号信号，就会默认处理，被终止。这也是为了防止进程无法被杀死，甚至操作系统也不行。

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

之前我们使用过kill函数：kill -信号名(信号编号) 进程PID 的形式发送

kill函数

我们的kill命令实际上是调用kill函数来进行的： 

int kill(pid_t pid, int sig);

函数说明：向pid进程发送sig信号，成功返回0，否则返回-1。

可以运行下列函数：

#include<stdio.h>    
#include<stdlib.h>    
#include<sys/types.h>    
#include<signal.h>    
    
//告知kill命令正确使用方法    
void usage(char* proc)    
{    
  printf("usage: %s pid signo\n",proc);    
}    
    
int main(int argc, char* argv[])    
{    
  if(argc != 3)//kill命令包含 程序名、pid、信号三个参数，那么argc应该会是3，否则kill出错    
  {    
    usage(argv[0]);    
    return 1;    
  }    
  pid_t pid = atoi(argv[1]);//获取pid    
  int signo = atoi(argv[2]);//获取信号    
  kill(pid, signo);//调用kill函数                                                                                       
  return 0;    
}

此时就已经模拟实现了一个kill命令：

 raise函数

raise函数可以给当前进程发送指定的信号，也就是自己给自己发送信号： 

int raise(int sig);

给当前进程发送sig信号：

#include<stdio.h>    
#include<unistd.h>    
#include<signal.h>    
    
void handle(int signo)    
{    
  printf("get a sigal: %d\n",signo);    
}    
    
int main()    
{    
  signal(2,handle);//捕捉2号信号
  while(1)    
  {    
    sleep(1);    
    raise(2);//发送2号信号 
  }    
  return 0;
}

运行结果如下：

 abort函数

abort函数可以给当前进程发送SIGABRT信号，令进程异常终止：

int abort(void);

 函数说明：abort函数是一个无参数无返回函数，只实现发送SIGABRT信号功能

#include<stdio.h>      
#include<stdlib.h>      
#include<unistd.h>      
#include<signal.h>      
      
      
void handle(int signo)      
{      
  printf("get a signal: %d\n",signo);      
}      
      
int main()      
{      
  signal(6,handle); 
  while(1)      
  {      
    sleep(1);      
    abort();      
  }      
  return 0;      
}

 运行结果如下：

需要注意的是：abort函数执行完自定义方法后，还是谁异常终止，因为abort的作用就是异常终止进程，无论如何都会终止。 

由软件条件产生信号

SIGPIPE信号

该信号是由软件条件产生的信号，当进程使用管道通信时，读端进程关闭，写端还在写入的时候，那么写端进程就会收到SIGPIPE信号而被终止：

#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<stdlib.h>

int main()
{
    int fd[2] = { 0 };
    //创建匿名管道
    if (pipe(fd) < 0)
    {
        perror("pipe");
        return 1;
    }
    pid_t id = fork();//创建子进程

    if (id == 0)//子进程代码
    {
        close(fd[0]);//关闭读端

        const char* msg = "this is child";//消息
        int count = 5;
        //循环写入
        while (count--)
        {
            write(fd[1], msg, strlen(msg));
            sleep(2);
        }
        //关闭写端                                                                               
        close(fd[1]);
        //退出
        exit(0);
    }

    //父进程
    close(fd[1]);//关闭写端
    close(fd[0]);//直接关闭读端
    int status = 0;//输出参数
    waitpid(id, &status, 0);//等待子进程
    printf("child get signal:  %d\n", status & 0x7F);//打印子进程信号
    return 0;

}

运行结果如下：

可以发现，直接打印了13号信号，也就是SIGPIPE信号。

SIGALRM信号 

该函数作用是设定一个闹钟，告诉操作系统在指定时间后发送SIGALRM信号给当前进程：

unsigned int alarm(unsigned int seconds);

 SIGALRM信号的默认处理动作是终止进程。

函数返回值说明：

1. 如果调用前已经设置了闹钟，那么返回上一个闹钟的剩余时间，本次闹钟设置会覆盖上一次的闹钟设置。
2. 调用前如果没有设置闹钟，那么返回0。

下面我们运行一段查看一秒内系统能执行多少次变量累加：

#include<stdio.h>    
#include<signal.h>    
#include<unistd.h>    
#include<stdlib.h>    
    
int count = 0;    
void handle(int signo)    
{    
  printf("get a signal: %d\n",signo);    
  printf("count: %d\n",count);    
}    
    
int main()    
{    
    
  signal(SIGALRM,handle);//捕获SIGALRM信号，交给handle处理    
  alarm(1);    
  while(1)    
  {    
    ++count;            
  }    
  return 0;    
}

 运行结果如下：

由硬件异常产生信号

为什么会产生程序崩溃

CPU当中有很多寄存器，例如我们需要对两个数进行运算，我们先将这两个数放进两个寄存器中，然后运算完再将结果写回寄存器。CPU还有叫做状态寄存器的东西，可以用来标记当前指令执行结果的各种状态，如果操作系统发现CPU内的某个状态标志位被置位，而这个置位可能是因为某个除0错误导致的，那么操作系统就会马上识别到是哪个进程导致的错误，然后将识别到的硬件错误包装成信号发给目标进程，也就是找到该进程的task_struct，然后将该位图写入8信号，然后再在合适的时间终止。

 我们举一个例子，下面是一个野指针问题：

#include<stdio.h>    
#include<stdlib.h>    
#include<sys/types.h>    
#include<sys/unistd.h>    
int main()    
{    
  printf("this is a process...\n");    
  sleep(3);    
  int *p = NULL;    
  *p = 100;    
  return 0;  
}

我们需要知道的是，当我们访问一个变量，就必须经过页表的映射，从虚拟地址转化成物理地址，才能进行相应的访问操作。

页表是一种软件映射关系，从虚拟地址到物理地址的映射，有一个叫做MMU的硬件，他是负责处理CPU内存访问请求的计算机硬件，因此映射不是CPU做的，而是MMU做的，不过MMU已经集成到了CPU中。 

当当开始映射时，我们将页表左侧的虚拟地址给MMU，然后MMU计算出物理地址，然后我们再进行访问。

既然MMU是硬件，那么就会有相应的状态信息，当我们访问不属于我们的虚拟地址时，MMU在转换时就会出错，然后将对应的错误写入到自己的状态信息中，最后被操作系统识别到，然后向对应的进程发送SIGSEGC信号。

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

阻塞信号

信号的其他相关概念

1. 实际产生信号的处理动作，叫做信号递达（Delivery）。
2. 信号从产生到递达之间的状态，叫做信号未决（Pending）。
3. 进程可以选择阻塞（Block）某个信号。
4. 被阻塞的信号产生时会保持在未决状态，直到进程接触对此信号的阻塞，才执行递达的动作。
5. 阻塞和忽略不同的是，信号被阻塞就不会递达，忽略是递达之后的处理动作。

阻塞信号在内核中的表示

下图是信号在内核中的示意图：

1. 每个信号都有两个标志位分别表示阻塞（Block）和未决（Pending），还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清楚该标志。在上图中，SIGHUP信号未阻塞也位产生过，当它递达时执行默认处理动作。
2. SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然处理动作是忽略，单单是没有接触阻塞之前，意味着还没递达，没递达就不能处理信号，不能处理就意味着不能进行忽略，但是进程仍有机会在改变处理动作之后再接触阻塞。
3. SIGQUIT信号未产生过，一旦产生SIGQUIT信号将被阻塞，它的处理动作是忽略，它的处理动作是用户自定义函数sighandler。如果在进程接触对某信号的阻塞之前，这种信号产生过多次，POSIX.1允许系统递达该信号一次或多次。Linux中：普通信号在递达前产生多次只算成一次，而实时信号递达之前产生多次可以依次放在一个队列里，我们这里只讨论普通信号。

综上所述：

1. Block位图，比特位的位置代表某一个对应的信号，比特位的内容代表信号是否被阻塞。
2. Pending位图中， 比特位的位置代表某一个对应的信号，比特位的内容代表信号是否被阻塞。
3. handler表是一个函数指针数组，数组下标代表某一个信号，数组内容表示信号递达之后的处理动作。
4. 上述三张表的每一个位置都是一一对应的。

sigset_t

从上图来看，每个信号都只有一个比特位来表示是否阻塞或者未决，要么1要么0，并不记录信号产生了多少次，因此，未决和阻塞标志可以用相同的数据类型 sigset_t来存储，sigset_t称为信号集，在Linux中的定义如下：（不同操作系统定义可能不同）

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
	unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;

typedef __sigset_t sigset_t;

sigset_t称为信号集，这个类型可以表示每个信号的“有效”与“无效”状态。

1. 在阻塞信号集中“有效”和“无效的含义是该信号是否被阻塞。
2. 在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

阻塞信号集也叫做当前进程的信号屏蔽字（Signal Mask），这里“屏蔽”可以理解为阻塞而不是屏蔽。

信号集操作函数

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 signo);

int sigaelset(sigset_t *set, int signo);

int sigismember(const sigset_t *set, int signo);

sigemptyset函数：初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号。

sigfillset函数：初始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号。

 sigaddset函数：在set所指向的信号集中添加某种有效信号。

sigdelset函数：在set所指向的信号集中删除某种有效信号。

sigismember函数：判断在set所指向的信号集中是否包含某种信号。

sigemptyset、sigfillset、sigaddset和sigdelset函数都是成功返回0，出错返回-1；

 sigismember函数包含则返回1，不包含则返回0，调用失败则返回-1。

我们可以一次性使用上述所有函数：
 

#include<stdio.h>
#include<signal.h>

int main()
{
    sigset_t s;//定义一个用户空间变量
    
    sigemptyset(&s);//初始化s，清空所有有效信号

    sigfillset(&s);//初始化s，使其包含系统支持的所有信号

    sigaddset(&s,SIGINT);//在s所指向的信号集添加SIGINT信号

    sigdelset(&s,SIGINT);//在s所指向的信号集删除SIGINT信号

    sigismember(&s,SIGINT);//判断s所指向的信号集中是否包含SIGINT信号

    return 0;
}

需要注意的是：

代码中定义的s，只是一个在用户空间的变量，后面我们用操作函数对s的操作只是在用户层面上，不会影响进程的任何行为，我们需要通过系统调用，才能将变量s的数据设置进操作系统，我们在下面会讲到。

sigprocmask

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

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

参数说明：

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

例如当前信号屏蔽字为mask，下表是how参数的可选值及其含义：

选项	含义
SIG_BLOCK	set包含了需要添加到信号屏蔽字的信号，mask=mask|set
SIG_UNBLOCK	set包含了需要从信号屏蔽字接触阻塞的信号，mask=mask|~set
SIG_SETMASK	设置信号屏蔽字为set所指向的值，mask=set

 返回值说明：调用成功返回0，出错返回-1.

需要注意的是：

如果sigprocmask解除了对当前若干个未决信号的阻塞，那么会在函数返回前至少将一个信号递达

sigpending

sigpending函数用来读取进程的未决信号集：

int sigpending(sigset_t *set);

参数说明：读取当前进程的未决信号集，通过set参数传出。

返回值说明：调用成功返回0，调用失败返回-1。

我们接下里验证一下pending信号集：

先看下列代码：

#include<stdio.h>    
#include<unistd.h>    
#include<signal.h>    
    
void printpending(sigset_t *pending)    
{    
  int i = 1;    
  for(i = 1;i<=31;++i)    
  {    
    if(sigismember(pending,i))    
    {    
      printf("1 ");    
    }    
    else{    
      printf("0 ");    
    }    
  }    
}    
    
int main()    
{    
  sigset_t set,oldset;    
  sigemptyset(&set);    
  sigemptyset(&oldset);    
    
  sigaddset(&set,2);//set指向2号信号    
  sigprocmask(SIG_SETMASK,&set,&oldset);//屏蔽2号信号    
    
  sigset_t pending;    
  sigemptyset(&pending);   
    
  while(1)    
  {    
    sigpending(&pending);//获取pending表    
    printpending(&pending);//打印pending表 
    printf("PID: %d\n",getpid());   
    sleep(1);    
  }    
  return 0;
} 

运行结果如下：

可以看到，我们此时发送2号信号之后，由于被阻塞了，所以会一直处理未决状态，pending表第二个数字从0变成了1。 

我们再尝试将信号恢复，看看会怎么变化：
 

#include<stdio.h>    
#include<unistd.h>    
#include<signal.h>    
    
void printpending(sigset_t *pending)    
{    
  int i = 1;    
  for(i = 1;i<=31;++i)    
  {    
    if(sigismember(pending,i))    
    {    
      printf("1 ");    
    }    
    else{    
      printf("0 ");    
    }    
  }    
}    

void handle(int signo)
{
    printf("handle signo: %d\n",signo);    
}
    
int main()    
{    
  signal(2,handle);
  sigset_t set,oldset;    
  sigemptyset(&set);    
  sigemptyset(&oldset);    
    
  sigaddset(&set,2);//set指向2号信号    
  sigprocmask(SIG_SETMASK,&set,&oldset);//屏蔽2号信号    
    
  sigset_t pending;    
  sigemptyset(&pending);   
    
  int count = 0;
  while(1)    
  {    
    sigpending(&pending);//获取pending表    
    printpending(&pending);//打印pending表 
    printf("PID: %d\n",getpid());   
    sleep(1);
    if(count == 20)    
    {    
      sigprocmask(SIG_SETMASK, &oldset, NULL);    
      printf("已恢复!\n");    
    }    
  }  
      
  return 0;
} 

运行结果如下： 

可以看到，再恢复了屏蔽字之后，2号信号就会立刻递达，执行自定义动作，此时pending表也变回了0。 

捕捉信号

内核空间与用户空间

我们知道，每个进程都有自己的进程地址空间，这个进程地址空间是由内核空间和用户空间组成的：

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

我们之前所了解的都是用户级页表，那么内核级页表呢？

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

虽然每个进程都能看到操作系统，但不意味着每个进程能随便对其进行访问。

进程切换的过程

1. 当当前进程的进程地址空间中找到内核空间，然后再通过内核空间找到操作系统的代码和数据。
2. 执行操作系统的代码，将当前进程的代码和数据剥离下来，并换上另一个进程的代码和数据。

必须处于用户态才能访问用户空间，同样的，必须处于内核态才能访问内核空间。

内核态与用户态

区别

1. 内核态通常是用来处理操作系统的代码，是权限很高的状态。
2. 用户态是一种用来执行普通用户的代码，受监管的普通状态。

用户态切换为内核态

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

内核态切换为用户态

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

从用户态切换到内核态的行为称作陷入内核。

内核如何实现捕捉信号

在我们执行主控制程序的时候，可能会因为某写情况而陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending检查。（此时还在内核态，权限足以查看当前进程的pending图）

在查看pending位图时，如果发现有未决信号且没有被阻塞，那么就会对信号进行处理。

处理完信号之后，就会返回用户态，从中断的地方继续执行。

如果信号是自定义处理呢？ 

此时会返回用户态执行自定义动作，然后再通过特殊的系统调用sigreturn再次陷入内核并清楚pending标志位，然后再返回用户态，继续执行代码。

 

可以理解成：

需要注意的是：

操作系统是不会信任任何用户的，因为无法保证用户的代码是合法代码，所以在内核中是不会执行用户代码的。

sigaction

sigaction函数是和前面的signal函数一样，用来捕捉信号：

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

与signal不同的是：sigaction函数可以读取和修改指定信号相关联的处理动作

调用成功返回0，失败返回-1。

参数说明：

1. signum代表指定信号的编号
2. 若act非空，则根据act修改处理动作
3. 若oldact非空，用来记录原来的处理动作 

我们可以查看act和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

1. 若为SIG_IGN，表示忽略
2. 若为SIG_DFL，表示默认
3. 若为函数指针，表示自定义，或者向内核注册了一个信号处理函数

返回值为void，参数为int，可以用同一个函数处理多种信号，是一个回调函数，不被main函数调用，而是被系统调用。

第二个成员sa_sigaction

是一个实时信号处理函数

第三个成员sa_mask 

这个成员代表需要额外屏蔽的信号。

第四个成员sa_flags 

一般设置为0即可

第五个成员sa_restorer 

这个不会使用到 

接下来我们举一个例子：

我们用sigaction捕捉2号信号，更改动作为自定义动作，自定义动作内再将信号改为原来的动作：

#include<stdio.h>                                         
#include<signal.h>    
#include<unistd.h>    
#include<string.h>    
    
struct sigaction act, oldact;    
    
void handle(int signo)    
{    
  printf("this is signal: %d\n",signo);    
  sigaction(2,&oldact,NULL);    
}    
    
int main()    
{    
  memset(&act,0,sizeof(act));    
  memset(&oldact,0,sizeof(oldact));    
    
  act.sa_handler = handle;    
  act.sa_flags = 0;    
  sigemptyset(&act.sa_mask);    
    
  sigaction(2,&act,&oldact);    
  while(1)    
  {    
    printf("this is a process...\n");    
    sleep(1);    
  }    
  return 0;    
}

运行结果如下：

可以看到，我们第一次Ctrl+C没有中断，而是第二次才中断。 

可重入函数

我们先看下列情况：

在主函数中调用insert函数，向链表插入node1，然后有个信号处理函数也掉用了insert函数插入了node2：

我们来看插入步骤：

第一步，node1指向head结点，只运行了第二步，硬件中断，切换到内核，然后进入了sighandler函数

 

第二步，此时又调用了insert函数，完成了第一行，node2指向了head

第三步， sigaction函数调用的insert函数完成了第二行，此时head指向node2

 

第四步，处理完不，返回了用户态，此时继续执行用户态调用的insert函数的第二行代码，此时head指向node1 

最后，node1和node2插入了，但是只有node1是真正插入了，因为head结点指向了node1

这种insert函数被不同的控制流调用，叫做重入。

insert函数访问全局链表，可能因为重入而造成错乱，叫做不可重入函数。

如果函数只访问自己的局部变量和参数，叫做可重入函数。

定义为不可重入的函数：

1. 调用了malloc或free
2. 调用了标志I/O库函数 

volatile

volatile是C语言的一个关键字，作用是保持内存的可见性

例如下列代码：

我们捕获2号信号，在捕获后将flag改为1，也就是捕获2号信号才能退出循环：

#include<stdio.h>    
#include<signal.h>    
    
int flag = 0;    
    
void handle(int signo)    
{    
  printf("get a signal: %d\n",signo);    
  flag = 1;    
}    
    
int main()    
{    
  signal(2,handle);    
  while(flag == 0)    
  {    
    //    
  }    
  printf("normal quit!\n");                               
  return 0;    
    
}

 运行结果如下：

好像确实是这样的，和我们前面的理解相同。

实际上，main函数和handle函数是两个独立的执行流，while循环是在main函数中，编译器编译时只会检测在main函数中对flag变量的使用。

还记得我们之前学过的寄存器吗？此时编译器检测到在main函数没有对flag变量进行修改操作，如果在编译器优化级别比较高的时候，flag就有可能会被设置到寄存器里：

那么此时main函数就会只检测寄存器里面的flag，但是handle只是修改了内存中的flag，所以此时并不会退出死循环。

此时我们必须使用volatile对flag进行修饰，告诉编译器该变量任何操作都需要在内存中进行：

#include<stdio.h>    
#include<signal.h>    
    
volatile int flag = 0;    
    
void handle(int signo)    
{    
  printf("get a signal: %d\n",signo);    
  flag = 1;    
}    
    
int main()    
{    
  signal(2,handle);    
  while(flag == 0)    
  {    
    //    
  }    
  printf("normal quit!\n");                               
  return 0;    
    
}

SIGCHLD信号

子进程在终止时会给父进程发送SIGCHLD信号，这个信号的默认处理动作是忽略，也可以自定义处理动作，这样父进程就可以专注处理自己的事情，不用一直关心子进程了，当子进程终止时通知父进程，父进程收到信号，在处理函数中调用wait和waitpid清理子进程即可。

SIGCHLD是普通信号，只记录一个pending位，如果有多个子进程同时退出，处理函数只清理了有一个，所以在处理函数内部需要用到while函数不断地清理：

#include<stdio.h>    
#include<unistd.h>    
#include<signal.h>    
#include<stdlib.h>    
#include<sys/wait.h>    
    
void handle(int signo)    
{    
  printf("het a signal: %d\n",signo);    
  int ret = 0;    
  while((ret = waitpid(-1,NULL,WNOHANG)) > 0)                                               
  {    
    printf("wait child %d success\n",ret);    
  }    
}    
    
int main()    
{    
  signal(SIGCHLD,handle);    
  if(fork() == 0)    
  {    
    printf("child is running,beging dead: %d\n",getpid());    
    sleep(3);    
    exit(1);    
  }    
    
  while(1)    
  {    
    //    
  }    
  return 0;    
}

运行结果如下：