Linux信号机制探析--信号的处理

*🍑个人主页：Jupiter.🚀 所属专栏：Linux从入门到进阶欢迎大家点赞收藏评论😊*

目录

🍑信号处理

信号处理常见方式概览

可选的处理动作有以下三种:

1. 默认处理动作。
2. 忽略此信号。
3. 自定义处理信号–捕捉 。提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数。

信号是在什么时候被处理的？

• 进程从内核态切换到用户态的时候，信号会被检测并处理。

🍒内核如何实现信号的捕捉 

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为

捕捉信号

。由于信号处理函数的代码是在用户空间的,处理过程比较复杂,举例如下：

• 用户程序注册了SIGQUIT信号的处理函数sighandler。 当前正在执行main函数,这时发生中断或异常切换到内核态。 在中断处理完毕后要返回用户态的main函数之前``````检查到有信号SIGQUIT递达。 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是两个独立的控制流程。 sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。
• 信号捕捉的过程可以用一个♾️简略表示，其中交点就会信号检测，如下图所示，如果拉根横线，与♾️的四个交点，也就是在信号处理过程中（信号捕捉），有四次用户态与内核态的切换，横线的上面是用户态，下面是内核态。

🍎内核态与用户态

我们之前所说的页表，实际上是

用户级页表

，是进程地址空间中的用户空间与对应物理内存的映射关系，其中，还有一个

内核级页表

，是进程地址空间中的内核空间与对应物理内存的映射关系，系统中

第一个被加载的软件是操作系统

，将操作系统加载到物理内存后，为了用户将来能够以受保护的状态的访问操作系统（内核数据），必须把

操作系统

映射

到

进程地址空间的内核空间

中，以后进程如果想要访问操作系统的数据，如一些系统调用，通过进程的地址空间中内核空间即可，所以，我们

使用系统调用或则访问系统数据

，其实还是

在进程的地址空间内进行跳转的

！

使用系统调用或则访问系统数据，是在进程的地址空间内进行跳转的，如果不加以限制，那么用户就可以随便访问内核数据了，所以就引入了

用户态与内核态

。当在访问内核空间的时候，会进行运行模式检测，只有在是内核态才可以访问，否则不行。

系统中存在多个进程，但是OS只有一份，所有的进程要映射内核空间，只需要共用同一个内核级页表即可，所以进程无论怎么切换，总能找到操作系统。

操作系统是如何正常运行的(了解)

是通过以非常高的频率，每隔非常短的时间，就给CPU发送中断号（假设是2），CPU不断处理中断，拿着中断号，在中断向量表（其中开机的时候，OS提供的）中找到对应的处理方法并执行。这个中断称为OS的周期时钟中断。

🎈sigaction

函数原型：

#include<signal.h>intsigaction(int signo,conststructsigaction*act,structsigaction*oact);structsigaction{void(*sa_handler)(int);void(*sa_sigaction)(int, siginfo_t *,void*);
      sigset_t   sa_mask;int   sa_flags;void(*sa_restorer)(void);};

• sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非 空,则通过oact传出该信号原来的处理动作。
• 将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。

当某个信号的处理函数被调用时,

内核自动将当前信号加入进程的信号屏蔽字

,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。 如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用

sa_mask字段

说明这些需要

额外屏蔽的信号

,当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags字段包含一些选项,本章的代码都把sa_flags设为0,sa_sigaction是实时信号的处理函数,本章不详细解释这两个字段。

示例代码：

voidhandler(int signo){
    std::cout <<"signal : "<< signo << std::endl;}intmain(){structsigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags =0;sigemptyset(&act.sa_mask);//在在调用信号处理函数的时候同时将3，4，5号信号屏蔽sigaddset(&act.sa_mask,3);sigaddset(&act.sa_mask,4);sigaddset(&act.sa_mask,5);sigaction(2,&act,&oact);//自定义捕捉2号信号while(true)sleep(1);//循环的时候给该进程发送2号信号验证return0;}

🌾可重入函数

• main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换 到sighandler数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的 两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续 往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后 向链表中插入两个节点,而最后只有一个节点真正插入链表中了。
• 像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为 不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant) 函数。想一下,为什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?

如果一个函数

符合以下条件之一

则是

不可重入

的:

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

🌽SIGCHLD信号 

进程一章讲过用wait和waitpid函数清理僵尸进程,父进程可以阻塞等待子进程结束,也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式,父进程阻塞了就不能处理自己的工作了;采用第二种方式,父进程在处理自己的工作的同时还要记得时不时地轮询一 下,程序实现复杂。
其实,子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以

自定义SIGCHLD信号的处理函数

,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程终止时会通知父进程,父进程在信号处理函数中调用wait清理子进程即可。

请编写一个程序完成以下功能:父进程fork出子进程,子进程调用exit(2)终止,父进程自定义SIGCHLD信号的处理函数,在其中调用wait获得子进程的退出状态并打印。

voidCleanupChild(int signo){if(signo == SIGCHLD){
        pid_t rid =waitpid(-1,nullptr,0);if(rid >0){
            std::cout <<"wait child success: "<< rid << std::endl;}}
    std::cout <<"wait sub process done"<< std::endl;}intmain(){signal(SIGCHLD, CleanupChild);

    pid_t id =fork();if(id ==0){// child
        std::cout <<"child process died"<< std::endl;exit(2);}// fatherwhile(true)sleep(1);return0;}

对于上面的代码，只有一个子进程，那如果一共有100个子进程呢，并且全部一起退出，意思就是100子进程都会同时向父进程发送SIGCHLD信号，可能父进程来不及处理，在子进程回收子进程的时候，也会回收部分，剩下的就没有被回收。
那么像上面的问题怎么解决呢？

解决方法：循环等待

voidCleanupChild(int signo){if(signo == SIGCHLD){while(true){
            pid_t rid =waitpid(-1,nullptr,0);// -1 : 回收任意一个子进程if(rid >0){
                std::cout <<"wait child success: "<< rid << std::endl;}elseif(rid <=0)break;}}}

那么问题又来了，要是100子进程，只退出50个子进程呢？如果还是使用上面的代码的话，50个进程退出后，后面50个子进程根本没有退出，这时候循环里面调用waitpid就阻塞了，如果后面50个子进程再也不退的话，就会一直在信号捕捉的方法中不会返回了，就回不到主进程了，主进程就丢失了。解决方法：非阻塞等待即可。上面代码改为

 waitpid(-1, nullptr, WNOAHG)即可

。

事实上,由于UNIX 的历史原因,要想不产生僵尸进程还有另外一种办法:父进程调用

sigaction将

SIGCHLD的处理动作置为SIG_IGN

,这样fork出来的子进程在终止时会自动清理掉,不会产生僵尸进程,也不会通知父进程。

系统默认的忽略动作

和

用户用sigaction函数自定义的忽略`通常是没有区别的,但这是一个特例。此方法对于Linux可用,但不保证在其它UNIX系统上都可用。请编写程序验证这样做不会产生僵尸进程。

intmain(){signal(SIGCHLD, SIG_IGN);for(int i =0; i <100; i++){
        pid_t id =fork();if(id ==0){
            std::cout <<"child process died"<< std::endl;exit(0);}}while(true)sleep(1);return0;}