Linux：信号【阻塞和捕捉信号】-CSDN博客

本文链接：https://blog.csdn.net/2301_82256131/article/details/147808747

Linux：信号【阻塞和捕捉信号】

（一）阻塞信号
（二）捕捉信号

（一）阻塞信号

1.信号其他相关的概念

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

信号传递过程：信号产生 -> 信号未决 -> 信号递达
在这里插入图片描述

2.在内核中表示

在这里插入图片描述

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

block和pending都是用位图表示，而handler是一个函数指针数组

在block位图中，比特位的位置代表某一个信号，比特位的内容代表该信号是否被阻塞。
在pending位图中，比特位的位置代表某一个信号，比特位的内容代表是否收到该信号。
handler表本质上是一个函数指针数组，数组的下标代表某一个信号，数组的内容代表该信号递达时的处理动作，处理动作包括默认、忽略以及自定义
block、pending和handler这三张表的每一个位置是一一对应的。

3.sigset_t

从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。

因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略。

#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_NWORDS 大小为 32，所以这是一个可以包含 32 个无符号长整型的数组，而每个无符号长整型大小为 4 字节，即 32 比特，至多可以使用 1024 个比特位

4.信号集操作函数

sigset_t类型对于每种信号用一个bit表示“有效”或“无效”，至于这个类型内部如何存储这些bit则依赖于系统的实现，从使用者的角度是不必关心的，使用者只能调用以下函数来操作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是一个布尔函数,用于判断一个信号集的有效信号中是否包含
某种信号,若包含则返回1,不包含则返回0,出错返回-1。

5.sigprocmask（设置阻塞）

sigprocmask函数可以用于读取或更改进程的信号屏蔽字（阻塞信号集），该函数的函数原型如下：

 #include <signal.h>
 int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

函数说明：

参数how：
参数set：
就是一个信号集，主要从此信号集中获取屏蔽信号信息
参数oldset：
一个信号集，保存进程中原来的 block 表

返回值：

sigprocmask函数调用成功返回0，出错返回-1。
如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask函数返回前，至少将其中一个信号递达。

6.sigpending（得到未决状态）

sigpending函数可以用于读取进程的未决信号集，该函数的函数原型如下：
在这里插入图片描述
sigpending函数读取当前进程的未决信号集，并通过set参数传出。该函数调用成功返回0，出错返回-1。

（二）捕捉信号

1、内核空间与用户空间

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

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

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。因此，在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，所有进程看到的都是一样的内容。
在这里插入图片描述
内核级页表只有一个并且是全部进程共享。而用户级页表有多个，每个进程都有一个独立的用户级页表。

2、内核态与用户态

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

为什么要区分用户态与内核态？

内核空间中存储的可是操作系统的代码和数据，权限非常高，绝不允许随便一个进程对其造成影响
区域的合理划分也是为了更好的进行管理

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

用户态切换到内核态：
- 需要进行系统调用时。
- 当前进程的时间片到了，导致进程切换。
- 产生异常、中断、陷阱等。
内核态切换到用户态：
- 系统调用返回时。
- 进程切换完毕。
- 异常、中断、陷阱等处理完毕。

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

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码是在用户空间的,处理过程比较复杂。
举例如下:

用户程序注册了SIGQUIT信号的处理函数sighandler。
当前正在执行main函数,这时发生中断或异常切换到内核态。
在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。
内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是两个独立的控制流程。
sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。

当识别到信号的处理动作是自定义时，能直接在内核态执行用户空间的代码吗？
理论上是可以实现的，但是是绝对不允许的。
很好理解，倘若可以在内核态执行用户空间的代码，那么会不会有非法操作？假如在内核态有一个非法操作是将其数据库都删掉了，那么这可恢复不了了，因为内核态的权限是足够大的。虽然在用户态时没有足够的权限做到清空数据库，但是如果是在内核态时执行了这种非法代码，那么数据库就真的被清空了，因为内核态是有足够权限清空数据库的。
也就是说，不能让操作系统直接去执行用户的代码，因为操作系统无法保证用户的代码是合法代码，即操作系统不信任任何用户。

3.捕捉信号

signal函数

signal 函数可以用来修改信号的执行动作，也叫注册自定义执行动作。
在这里插入图片描述
函数理解：

参数 1：
待操作信号的编号，为 int，单纯地传递信号名也是可以的，因为信号名其实就是信号编号的宏定义
参数 2：待注册的新方法。
参数2 是一个函数指针，意味着需要传递一个参数为 int，返回值为空的函数对象
我们需要手动创造一个函数对象，就像下面这样：

void handler(int signo)
{
    cout << "当前 " << signo << " 号信号正在尝试执行相应的动作" << endl;
}

sigaction函数

捕捉信号除了用上面的signal函数之外，我们还可以使用sigaction函数对信号进行捕捉，sigaction函数的函数原型如下：

#include <signal.h>

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

struct sigaction 
{
	void     (*sa_handler)(int);	//自定义动作
	void     (*sa_sigaction)(int, siginfo_t *, void *);	//实时信号相关，不用管
	sigset_t   sa_mask;	//待屏蔽的信号集
	int        sa_flags;	//一些选项，一般设为 0
	void     (*sa_restorer)(void);	//实时信号相关，不用管
};

函数说明：

参数1：待操作的信号
参数2：sigaction 结构体，具体成员如上所示
参数3：保存修改前进程的 sigaction 结构体信息
返回值：成功返回 0，失败返回 -1 并将错误码设置

再了解sigaction结构体中的 sa_mask 字段。
sa_mask：当信号在执行用户自定义动作时，可以将部分信号进行屏蔽，直到用户自定义动作执行完成。
也就是说，我们可以提前设置一批待阻塞的屏蔽信号集，当执行 signum 中的用户自定义动作时，这些屏蔽信号集中的信号将会被屏蔽（避免干扰用户自定义动作的执行），直到用户自定义动作执行完成。

使用示范：

#include<iostream>
#include <string.h>
#include <unistd.h>
#include <signal.h>
using namespace std;
struct sigaction act, oldact;
void handler(int signo)
{
    cout << "get a signo#" << signo << endl;
    sigaction(2, &oldact, NULL);
}
int main()
{
    memset(&act, 0, sizeof(act));
	memset(&oldact, 0, sizeof(oldact));
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(2, &act, &oldact);
    while(1)
    {
        cout << "I am a process..." << endl;
        sleep(1);
    }
    return 0;
}

3.可重入函数

可以被重复进入的函数称为可重入函数
在这里插入图片描述
main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换到sighandler函
数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后向链表中插入两个节点,而最后只有一个节点真正插入链表中了。

像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant) 函数。

如果一个函数符合以下条件之一则是不可重入的

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

4.volatile关键字

volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作

我们看到下面代码：

#include<iostream>
#include<unistd.h>
#include<signal.h>
using namespace std;
int flag = 0;
void handler(int signo)
{
    cout << "get a signal is#" << signo << endl;
    flag = 1;
}
int main()
{
    signal(2, handler);
    cout << "process beginning" << endl;
    while(!flag)
    {
        // 什么也不做
    }
    cout << "process exit..." << endl;
    return 0;
}

我们将2号信号进行捕捉，当进程收到2号信号后会将全局变量flag由0置1。也就是说，在进程收到2号信号之前，该进程会一直处于死循环状态，直到收到2号信号时将flag置1才能够正常退出。

上面的观点不一定是正确的！！
当我们修改编译器的优先级时，将优化级别设为更高是一样的结果，如果设为 O0 则会符合预期般的运行，说明我们当前的编译器默认的优化级别是 O0。编译器就会对上述代码做出优化！

代码中的main函数和handler函数是两个独立的执行流，而while循环是在main函数当中的，在编译器编译时只能检测到在main函数中对flag变量的使用。此时编译器检测到在main函数中并没有对flag变量做修改操作，在编译器优化级别较高的时候，就有可能将flag的值设置进寄存器里面。此时main函数在检测flag时只检测寄存器里面的值，而handler执行流只是将内存中flag的值置为1了，那么此时就算进程收到2号信号也不会跳出死循环，因为编译器直接从寄存器上拿到值了。

在这里插入图片描述

5.SIGCHLD信号

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

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

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.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 << "sucess" << endl;
	}
}
int main()
{
	signal(SIGCHLD, handler);
    pid_t id = fork();
	if (id == 0)
    {
		//child
        cout << "child is running, begin dead#" << getpid() << endl;
		sleep(3);
		exit(1);
	}
	//father
	while (1);
	return 0;
}

SIGCHLD属于普通信号，记录该信号的pending位只有一个，如果在同一时刻有多个子进程同时退出，那么在handler函数当中实际上只清理了一个子进程，因此在使用waitpid函数清理子进程时需要使用while不断进行清理。

信号处理期间的附加规则
在信号处理函数执行期间，内核会自动将该信号加入信号屏蔽字（临时阻塞）。此时：
- 若该信号再次触发，会被标记为未决状态（ $s i g p e n d in g$ 位置1），但需等待当前处理函数结束后才会递送。
- 对于非实时信号（如SIGINT），多次触发仅保留一次未决记录；**实时信号（如SIGRTMIN+1）**则支持排队，每次触发均独立记录。

关键流程图释

信号触发 → 检查是否被阻塞 → 是 → 加入sigpending表（置1）
                       ↓ 否  
                       立即递送处理

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

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
using namespace std;
int main()
{
	signal(SIGCHLD, SIG_IGN);
    pid_t id = fork();
	if (id == 0)
    {
		//child
        cout << "child is running, child dead:" << getpid() << endl;
		sleep(3);
		exit(1);
	}
	//father
	while (1);
	return 0;
}