【Linux】第三十八站：信号处理

一、信号处理

我们知道，信号保存以后，会在合适的时候进行处理这个信号。

那么信号是如何被处理的？什么时候进行处理呢？

当我们的进程从内核态返回到用户态的时候，进行信号的检测和处理！

内核态：就是允许访问操作系统的代码和数据

用户态：只能访问用户自己的代码和数据

当我们使用系统调用的时候，操作系统是会自动做“身份”切换的，用户身份变为内核身份，或者反着来

我们的CPU它可以响应外部的中断，也可以内部直接产生中断

下面这条汇编指令，它可以直接从用户态陷入内核态。即就可以访问操作系统的代码了

int 80

二、再谈进程地址空间

如下图所示，我们都是比较熟悉的

我们会发现，进程地址空间中，有一个3G的用户空间，和1G的内核空间。

我们前面所谈的所有东西，都是这3GB的用户空间中的内容

上面的这1GB内核空间，它映射的是操作系统的代码和数据

而这内核空间会通过内核级页表映射操物理内存的底部！（当然也有的会通过直接映射到物理内存，这里我们不讨论它）

那么用户级页表有几份？

有几个进程，就有几份用户级页表，进程具有独立性

内核级页表有几份？

内核级页表只有一份，即每个进程看到的3_{4GB的东西是一样的！在整个系统中，进程再怎么切换，3}4GB的空间的内容是不变的！！！

---

所以站在进程的视角：调用系统中的方法，就是在我们自己的地址空间中进行执行的

站在操作系统的视角：任何一个时刻，都会有进程执行（即便一个进程都没有，操作系统也有自己对应的进程在运行。只需要它自己的内核空间即可）。我们想要执行操作系统的代码，就可以随时执行！

---

操作系统的本质：

基于时钟中断的一个死循环！

---

我们可能会疑惑，我们自己的代码是让操作系统去运行的。是谁让操作系统去运行的呢？

其实在计算机硬件中，有一个时钟芯片，每隔很短的时间（纳秒级别），向计算机发送时钟中断。

如下图所示，时钟会不断的发送时钟中断，然后CPU中的寄存器接收到信号以后，去中断向量表中寻找对应的方法，去执行。比如里面就会进行检查时间片到了没有，如果到了，就把这个进程剥夺下去，换下一个进程。从而完成进程的调度。然后上面的不断的进行死循环。

也就是被动的由时钟去驱动操作系统。

操作系统的最后会卡在这样一个死循环里面，然后就靠着时钟中断来进行驱动

for(;;) pause();

---

我们知道，用户只能访问自己的代码和数据；无法直接访问操作系统的代码和数据。因为操作系统不相信任何人。

我们知道，在CPU当中，有一个CR3寄存器，指向这个页表

在CPU当中还有一个ecs寄存器。它最低的两个比特位中。有两种权限位。

一个是0，一个是3。如果是0表示内核态，如果是3表示用户态

如果我们想要访问内核的代码，我们必须把这个3设置为0

这就叫做进入内核态。就允许去访问操作系统的代码和数据了。

所以我们到底处于用户态还是内核态，就是由CPU来决定的

那么CPU就必须提供一个方法，让我们可以去改变这个工作级别。也就是下面的这个方法，陷入内核。

int 80； //陷入内核

---

所以前面的这张图中

是基于用户捕捉代码的

第一步第二步比较好理解

在第三步中，这个do_signal()函数会先遍历这个pending表，如果pending表中有1，那么在看一下block表，如果为1，不管这个信号，继续遍历pending表，直到遇到pending表有1，block表中为0以后。先将pending表对应的位置从1置为0，在看handler表，如果是SIG_DFL，那么则在内核中执行默认的动作。如果是SIG_IGN，那么就相当于忽略，直接返回代码。如果是自定义的handler,那么要先变为用户态（因为操作系统不想去执行我们的代码，不想让在内核中执行，害怕我们的代码中有非法的操作），然后执行第四步。

注意，先将pending表的位置置为0，才去执行的handler

在第四步中，我们的信号处理完成以后，它会自动系统调用sigretum系统调用接口返回内核。这里它在执行第四步之前会先将sigreturn进行入栈帧，然后在去入这个函数的栈帧。当这个函数的栈帧结束后，自然就会调用这个系统调用了

在第五步中，在去使用sys_sigreturn()函数去返回用户态。返回到我们原来的代码

我们可以用下面这张图去理解上面的过程

三、内核如何实现信号的捕捉

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

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

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

其实在操作系统中，所有的系统调用都是一张函数指针表，调用的时候也就是将对应的编号写入到寄存器中，就可以通过函数指针表去进行调用了

四、sigaction

#include 
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

这个函数和signal是很相似的。都是捕捉信号的

第一个参数是信号编号

第二个参数和第三个参数中，函数名和结构体名字是一样的，这样是可以的。不过不推荐

第二个参数是输入型参数，负责把数据结构设置为它

第三个参数是输出型参数，负责把设置之前老的结构给返回

返回值中，0是成功，-1是失败

如下所示，是这个结构体的内容

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

在这个结构体中，我们只关心这两个字段。其他的字段与实时信号有关

第一个参数就是信号捕捉的处理方法。

如下样例所示可以简单的先用起来这个函数

#include 
#include 
#include 
#include 
using namespace std;

void handler(int signo)
{   
    cout << "I catch a signal: " << signo << endl;
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));

    act.sa_handler = handler;
    sigaction(2, &act, &oact);

    while(true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }
    return 0;
}

运行结果为

pending位图，什么时候从1 -> 0？

我们可以用这段代码来进行测试

#include 
#include 
#include 
#include 
using namespace std;

void PrintPending()
{
    sigset_t set;
    sigpending(&set);
    for(int signo = 31; signo >= 1; signo--)
    {
        cout << sigismember(&set, signo);
    }
    cout << endl << endl;
}

void handler(int signo)
{   
    PrintPending();
    cout << "I catch a signal: " << signo << endl;
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));

    act.sa_handler = handler;
    sigaction(2, &act, &oact);

    while(true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }
    return 0;
}

运行结果为

所以pending位图，执行捕捉方法之前，先清0，在调用

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

我们可以用如下代码来进行验证

#include 
#include 
#include 
#include 
using namespace std;

void PrintPending()
{
    sigset_t set;
    sigpending(&set);
    for(int signo = 31; signo >= 1; signo--)
    {
        cout << sigismember(&set, signo);
    }
    cout << endl << endl;
}

void handler(int signo)
{   
    cout << "I catch a signal: " << signo << endl;
    while(true)
    {
        PrintPending();
        sleep(1);
    }

}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));

    act.sa_handler = handler;
    sigaction(2, &act, &oact);

    while(true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }
    return 0;
}

运行结果如下所示：

当我们在捕捉处理的过程中，再次发送信号，发现pending为1，也就意味着没有被执行，即被被阻塞了。那么只能是block表被置为1了

即操作系统不允许对某个信号重复捕捉，最多只能捕捉一层

信号被处理的时候，对应的信号也会被添加到block表中，防止信号捕捉被嵌套调用

sigaction中的sa_mask字段代表什么呢？

这个字段是一个sigset_t 类型的字段。它代表着屏蔽的信号。也就是会将block表给设置

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

我们用如下代码来进行演示

#include 
#include 
#include 
#include 
using namespace std;

void PrintPending()
{
    sigset_t set;
    sigpending(&set);
    for(int signo = 31; signo >= 1; signo--)
    {
        cout << sigismember(&set, signo);
    }
    cout << endl;
}

void handler(int signo)
{   
    cout << "I catch a signal: " << signo << endl;
    while(true)
    {
        PrintPending();
        sleep(1);
    }

}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 1);
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);

    act.sa_handler = handler;
    sigaction(2, &act, &oact);

    while(true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }
    return 0;
}

运行结果为