【Linux】进程信号之信号的处理

一、信号的处理时机

在前面我们讲过信号产生和保存以后，我们知道进程对于产生的信号不是立即去处理的，而是在"合适"的时候去处理信号，这是因为信号的产生的异步的，当前进程可能正在做更重要的事情!。

那么信号可以被立即处理吗？答案的可以的，但是要满足这个条件：

在Linux中如果一个信号之前被阻塞过，当他解除阻塞时，对应的信号会被立即递达！

那么对于进程来说什么是"合适"的时候呢？

答案是：当进程从内核态切换回用户态的时候，进程会在操作系统的指导下，进行信号的检测与处理!

二、内核态与用户态

简单来说内核态与用户态的区别就是：

用户态：进程只能执行用户所写的代码。

内核态：进程只能执行操作系统的代码。

我们知道操作系统也是一款软件，而且是一款专注于搞管理的软件，在对进程进行调度、执行系统调用、异常、中断、陷阱等，都需要借助操作系统，执行操作系统的代码，此时进程便处于内核态。

进程又是如何被调度的呢？

1. 操作系统的本质：

• 操作系统也是软件，并且是一个死循环式等待指令的软件。
• 计算机内部存在一个硬件：时钟模块，每隔一段时间向操作系统发送时钟中断

2. 进程被调度，就意味着它的时间片到了，操作系统会通过时钟中断，检测到是哪一个进程的时间片到了，然后通过系统调用函数 schedule()保存进程的上下文数据，然后选择合适的进程去运行，这就完成了一次进程调度。

1、内核态与用户态的转化

• 用户态向内核态的转化的时机：

1. 当进程时间片到了之后，需要进行进程调度时。
2. 调用系统调用接口，比如 open、read 时
3. 产生异常、中断、陷阱时

• 内核态向用户态的转化的时机：

4. 进程调度完成以后。
5. 系统调用调用完毕时。
6. 异常、中断、陷阱处理完毕时。

2、重谈进程地址空间

关于进程地址空间的初级知识可以看这里《进程地址空间》

在以前我们只讨论了[0, 3]G的用户空间，并没有对[3, 4]G的内核空间进行讨论，现在我们对[3, 4]G的内核空间进行讨论。

我们在谈论用户空间时提到，用户空间的地址要经过页表映射到物理地址，这个用户空间的页表其实其真实名称是用户级页表，对于内核空间来说也有一张页表，也负责将内核空间的地址映射到物理地址中，这个页表的名称是内核级页表。这两张页表是相互独立的！

内核空间里面存放的是操作系统代码和数据， 所以执行操作系统的代码及系统调用，其实就是在使用这 1 GB 的内核空间

1. 对于所有的进程[0, 3]GB是不同的，每一个进程都要有自己的用户级页表用来映射自己的代码和数据。
2. 所有的进程[3，4]GB是一样的，每一个进程都可以看到同一张内核级页表，所有进程都可以通过统一的窗口，看到同一个操作系统!
3. 无论进程如何切换，[3,4]GB不变，看到的都是OS的内容，与进程切换无关，也就是说进程切换其实切换的是[0, 3]G的用户空间里面的内容和用户级页表!
4. 操作系统运行的本质: 其实是在进程的地址空间内运行的!
5. 由于内核空间中存放的是操作系统的代码和数据，所以调用系统调用的本质: 其实就如同调用动态库中的函数，在自己的地址空间中进行函数跳转并返回即可!

由于操作系统的代码和数据是不能够被轻易访问的，所以在正文代码中如果要执行操作系统的代码和数据，需要先进行状态转化，由用户态转化为内核态，才能成功执行，那么这个状态转换是怎么实现的呢？

对于状态转化，操作系统采用的是软硬件结合的方式。

• 硬件方面：
  在CPU中，存在一个 CR3 寄存器，这个寄存器的作用就是用来表是当前处于进程所处的状态。
  
  当CR3寄存器中的值为 3 时：表示处于用户态，可以执行用户的代码。
  当CR3寄存器中的值为 0 时：表示处于内核态，可以执行操作系统的代码。

• 软件方面
  Linux并没有给我们提供相应的接口让我们可以更改CR3寄存器里面的值，因为操作系统没有办法保证每一个用户使用OS的代码和数据时都要先更改CR3寄存器的值，所以OS提供的所有的系统调用，内部在正执行调用逻辑的时候，会去修改执行级别! 这样就保证了用户使用系统调用的时候用户所处的状态是内核态。

三、信号的处理

1、一般信号的处理流程

当CPU正在执行某条代码时，可能因为中断、异常或系统调用进入内核态，然后在内核态完成相应的任务，任务完成以后并不是直接返回用户态，而是调用系统调用do_signal()去处理可以递达信号。

处理信号时会从1号到31号逐个检查block表和pending表，当block和pending表符合处理条件时才进行信号递达。

当信号递达时就需要调用handler表里面对应位置的的函数进行执行：

2、捕捉信号的处理流程

对于被捕捉的信号，与普通信号有所不同，在调用自定义处理方法时，由handler表里面的方法是用户的代码，所以还要进行一次状态转换，转换为用户态，然后执行自定义动作，当自定义动作执行完毕时OS会自动调用一次系统调用sigreturn()使用户态重新陷入内核变成内核态，然后在内核态再调用sys _sigreturn()进行返回并恢复为用户态。

下面我们通过一张图快速记忆捕捉信号的处理过程：

ps: 在执行hadler表中的方法之前，操作系统会先将pengding表对应位置的1给清零。

3、信号捕捉函数sigaction

该函数是一个系统调用，功能与signal()函数类似但是功能会更加强大，sigaction函数可以读取和修改指定信号相关联的处理动作。

• 参数：

1. 第一个参数是要捕捉的信号，第二个与第三个都是一个结构体参数，但是第二个参数是输入型参数，第三个是输出形参数。
2. 若act指针非空,则根据act修改该信号的处理动作。若oact指针非空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体。

• 返回值：
   调用成功则返回0,出错则返回-1
  

结构体的定义如下：

1. 第一个字段是函数指针，这个函数就是我们捕捉完信号以后要执行的处理动作。
2. 第二个与第五个字段是实时信号的处理函数,这里我们不做详细解释，可以直接设置为0。
3. 第三个字段是一个信号屏蔽集，这个字段设置完毕以后我们可以在处理捕捉信号时对信号屏蔽集里面的信号进行屏蔽。
4. 第四个字段包含了一些选项，一般默认设置为0。

关于信号处理时的一些机制:

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

下面我们来使用该函数验证一下信号处理时：内核会自动将当前信号加入进程的信号屏蔽字。

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>
// 打印pending表
void PrintPending(sigset_t set)
{
    std::cout << "当前的pending表：";
    for (int i = 1; i <= 31; i++)
    {
        if (sigismember(&set, i))
        {
            std::cout << '1';
        }
        else
        {
            std::cout << '0';
        }
    }
    std::cout << std::endl;
}
// 自定义处理动作
void handler(int signum)
{
    std::cout << "捕捉到了" << signum << "信号，执行了自定义动作" << std::endl;
    int cnt = 0;
    sigset_t set;
    sigemptyset(&set);
    while (cnt < 5)
    {
        cnt++;
        sigpending(&set);
        PrintPending(set);
        sleep(1);
    }
}
int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(act));
    act.sa_handler = handler;
    sigaction(2, &act, &oact);
    while (true)
    {
        sleep(1);
    }
}

这段代码中我们对2号信号进行了捕捉，自定义处理动作就是在自定义函数中停留5秒，每秒都打印一下当前状态的pending表。

我们可以运行程序，然后给该进程发送2号信号触发自定义处理动作，然后再在5秒之内再次发送2号信号观察pending表是否为1,如果为1就代表当前信号收到了阻塞，如果没有变成1代表没有受到阻塞。

可以看到结果符合我们的理论。

接下来我们尝试利用sigaction将3, 4号信号也加入信号屏蔽集中。

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>
// 打印pending表
void PrintPending(sigset_t set)
{
    std::cout << "当前的pending表：";
    for (int i = 1; i <= 31; i++)
    {
        if (sigismember(&set, i))
        {
            std::cout << '1';
        }
        else
        {
            std::cout << '0';
        }
    }
    std::cout << std::endl;
}
// 自定义处理动作
void handler(int signum)
{
    std::cout << "捕捉到了" << signum << "信号，执行了自定义动作" << std::endl;
    int cnt = 0;
    sigset_t set;
    sigemptyset(&set);
    while (cnt < 15)
    {
        cnt++;
        sigpending(&set);
        PrintPending(set);
        sleep(1);
    }
}
int main()
{
    struct sigaction act, oact;
    sigset_t set, oset;
    // 进行初始化
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(act));
    sigemptyset(&set);
    sigemptyset(&oset);
    // 将3， 4也加入信号屏蔽集中
    sigaddset(&set, 3);
    sigaddset(&set, 4);
    act.sa_handler = handler;
    // 设置信号屏蔽字
    act.sa_mask = set;
    sigaction(2, &act, &oact);
    std::cout << "进程的pid是：" << getpid() << std::endl;
    while (true)
    {
        sleep(1);
    }
}

如果我们还想将其他信号进行屏蔽，我们可以继续修改sigaction结构体里面sa_mask字段。