Linux进程信号【信号处理】

北海

发布于 2023-07-01 10:35:21

2470

发布于 2023-07-01 10:35:21

文章被收录于专栏：用户10155340的专栏

🌇前言

从信号产生到信号保存，中间经历了很多，当操作系统准备对信号进行处理时，还需要判断时机是否 “合适”，在绝大多数情况下，只有在 “合适” 的时机才能处理信号，即调用信号的执行动作。关于信号何时处理、该如何处理，本文中将会一一揭晓

捕捉动作并进行处理

🏙️正文

1、信号的处理时机

直奔主题，谈谈信号的 处理时机

1.1、处理情况

普通情况

所谓的普通情况就是指 信号没有被阻塞，直接产生，记录未决信息后，再进行处理

在这种情况下，信号是不会被立即递达的，也就无法立即处理，需要等待合适的时机

特殊情况

当信号被阻塞后，信号产生时，记录未决信息，此时信号被阻塞了，也不会进行处理

当阻塞解除后，信号会被立即递达，此时信号会被立即处理

特殊情况 很好理解，就好比往气球里吹气，当气球炸了，空气会被立即释放，因为空气是被气球阻塞的，当气球炸了之后（阻塞解除），空气立马往外跑，这不就是 立即递达、立即处理 吗？

普通情况 就有点难搞了，它需要等待 “合适” 的时机，才能被递达，继而被处理

1.2、“合适” 的时机

信号的产生是异步的

也就是说，信号可能随时产生，当信号产生时，进程可能在处理更重要的事，此时贸然处理信号显然不够明智

比如进程正在执行一个重要的 IO，突然一个终止信号发出，IO 立即终止，对进程、磁盘都不好

因此信号在产生后，需要等进程将 更重要 的事忙完后（合适的时机），才进行处理

合适的时机：进程从 内核态 返回 用户态 时，会在操作系统的指导下，对信号进行检测及处理

至于处理动作，分为：默认动作、忽略、用户自定义

搞清楚 “合适” 的时机 后，接下来需要学习 用户态 和 内核态 相关知识

2、用户态与内核态

对于 用户态、内核态 的理解及引出的 进程地址空间 和 信号处理过程 相关知识是本文的重难点

2.1、概念

先来看看什么是 用户态和内核态

用户态：执行用户所写的代码时，就属于用户态

内核态：执行操作系统的代码时，就属于内核态

自己写的代码被执行很好理解，操作系统的代码是什么？

操作系统也是由大量代码构成的
在对进程进行调度、执行系统调用、异常、中断、陷阱等，都需要借助操作系统之手
此时执行的就是操作系统的代码

也就是说，用户态 与 内核态 是两种不同的状态，必然存在相互转换的情况

用户态 切换为 内核态：

当进程时间片到了之后，进行进程切换动作
调用系统调用接口，比如 open、close、read、write 等
产生异常、中断、陷阱等

内核态 切换为 用户态：

进程切换完毕后，运行相应的进程
系统调用结束后
异常、中断、陷阱等处理完毕

信号的处理时机就是 内核态 切换为 用户态，也就是 当把更重要的事做完后，进程才会在操作系统的指导下，对信号进行检测、处理

下面来结合 进程地址空间 深入理解 操作系统的代码 及 状态切换 的相关内容（拓展知识）

2.2、重谈进程地址空间

首先简单回顾下 进程地址空间 的相关知识：

进程地址空间是虚拟的，依靠页表+MMU机制与真实的地址空间建立映射关系
每个进程都有自己的进程地址空间，不同进程地址空间中地址可能冲突，但实际上地址是独立的
进程地址空间可以让进程以统一的视角看待自己的代码和数据

关于 进程地址空间 的相关知识详见《Linux进程学习【进程地址】》

不难发现，在 进程地址空间 中，存在 1 GB 的 内核空间，每个进程都有，而这 1 GB 的空间中存储的就是 操作系统 相关代码和数据，并且这块区域采用 内核级页表 与 真实地址空间 进行映射

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

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

所谓的执行操作系统的代码及系统调用，就是在使用这 1 GB 的内核空间

进程间具有独立性，比如存在用户空间中的代码和数据是不同的，难道多个进程需要存储多份操作系统的代码和数据吗？

当然不用，内核空间比较特殊，所有进程最终映射的都是同一块区域，也就是说，进程只是将操作系统代码和数据映射入自己的进程地址空间而已
而内核级页表不同于用户级页表，专注于对操作系统代码和数据进行映射，是很特殊的

当我们执行诸如 open 这类的 系统调用 时，会跑到 内核空间 中调用对应的函数

而 跑到内核空间 就是 用户态 切换为 内核态 了（用户空间切换至内核空间）

这个跑到是如何实现的呢？在 CPU 中，存在一个 CR3 寄存器，这个 寄存器 的作用就是用来表征当前处于 用户态 还是 内核态

当寄存器中的值为 3 时：表示正在执行用户的代码，也就是处于用户态
当寄存器中的值为 0 时：表示正在执行操作系统的代码，也就是处于内核态

通过一个 寄存器，表征当前所处的状态，修改其中的值，就可以表示不同的状态，这是很聪明的做法

重谈 进程地址空间 后，得到以下结论

所有进程的用户空间 [0, 3] GB 是不一样的，并且每个进程都要有自己的用户级页表进行不同的映射
所有进程的内核空间 [3, 4] GB 是一样的，每个进程都可以看到同一张内核级页表，从而进行统一的映射，看到同一个操作系统
操作系统运行的本质其实就是在该进程的内核空间内运行的（最终映射的都是同一块区域）
系统调用的本质其实就是在调用库中对应的方法后，通过内核空间中的地址进行跳转调用

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

操作系统的本质 - 操作系统也是软件啊，并且是一个死循环式等待指令的软件 - 存在一个硬件：操作系统时钟硬件，每隔一段时间向操作系统发送时钟中断
进程被调度，就意味着它的时间片到了，操作系统会通过时钟中断，检测到是哪一个进程的时间片到了，然后通过系统调用函数 schedule() 保存进程的上下文数据，然后选择合适的进程去运行

2.3、信号的处理过程

当在 内核态 完成某种任务后，需要切回 用户态，此时就可以对信号进行检测并处理了

情况1：信号被阻塞，信号产生/未产生

信号都被阻塞了，也就不需要处理信号，此时不用管，直接切回用户态就行了

下面的情况都是基于 信号未被阻塞 且 信号已产生 的前提

情况2：当前信号的执行动作为默认

大多数信号的默认执行动作都是终止进程，此时只需要把对应的进程干掉，然后切回用户态就行了

情况3：当前信号的执行动作为忽略

当信号执行动作为忽略时，不做出任何动作，直接返回用户态

情况4：当前信号的执行动作为用户自定义

这种情况就比较麻烦了，用户自定义的动作位于用户态中，也就是说，需要先切回用户态，把动作完成了，重新坠入内核态，最后才能带着进程的上下文相关数据，返回用户态

在 内核态 中，也可以直接执行自定义动作，为什么还要切回 用户态 执行自定义动作？

因为在内核态可以访问操作系统的代码和数据，自定义动作可能干出危害操作系统的事
在用户态中可以减少影响，并且可以做到溯源

为什么不在执行完 自定义动作 直接后返回进程？

因为自定义动作和待返回的进程属于不同的堆栈，是无法返回的
并且进程的上下文数据还在内核态中，所以需要先坠入内核态，才能正确返回用户态

注意： 用户自定义的动作，需要先切换至用户态中执行，执行结束后，还需要坠入内核态

通过一张图快速记录信号的处理过程

图片来源：Linux进程信号

3、信号的捕捉

接下来谈谈信号是如何被捕捉的

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

如果信号的执行动作为 用户自定义动作，当信号递达时调用 用户自定义动作，这一动作称为 信号捕捉

用户自定义动作是位于用户空间中的

当 内核态 中任务完成，准备返回 用户态 时，检测到信号递达，并且此时为 用户自定义动作，需要先切入 用户态 ，完成 用户自定义动作 的执行；因为 用户自定义动作 和 待返回的函数 属于不同的堆栈空间，它们之间也不存在 调用与被调用 的关系，是两个 独立的执行流，需要先坠入 内核态 （通过 sigreturn() 坠入），再返回 用户态 （通过 sys_sigreturn() 返回）

上述过程可以总结为下图：

3.2、sigaction

sigaction 也可以 用户自定义动作，比 signal 功能更丰富

#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);	//实时信号相关，不用管
};

返回值：成功返回 0，失败返回 -1 并将错误码设置

参数1：待操作的信号

参数2：sigaction 结构体，具体成员如上所示

参数3：保存修改前进程的 sigaction 结构体信息

这个函数的主要看点是 sigaction 结构体

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);	//实时信号相关，不用管
};

其中部分字段不需要管，因为那些是与 实时信号 相关的，我们这里不讨论

重点可以看看 sa_mask 字段

sa_mask：当信号在执行用户自定义动作时，可以将部分信号进行屏蔽，直到用户自定义动作执行完成

也就是说，我们可以提前设置一批 待阻塞 的 屏蔽信号集，当执行 signum 中的 用户自定义动作 时，这些 屏蔽信号集 中的信号将会被屏蔽（避免干扰 用户自定义动作 的执行），直到 用户自定义动作 执行完成

可以简单用一下 sigaction 函数

#include <iostream>
#include <cassert>
#include <cstring>
#include <signal.h>
#include <unistd.h>

using namespace std;

static void DisplayPending(const sigset_t pending)
{
    // 打印 pending 表
    cout << "当前进程的 pending 表为: ";
    int i = 1;
    while (i < 32)
    {
        if (sigismember(&pending, i))
            cout << "1";
        else
            cout << "0";

        i++;
    }
    cout << endl;
}

static void handler(int signo)
{
    cout << signo << " 号信号确实递达了" << endl;
    // 最终不退出进程

    int n = 10;
    while (n--)
    {
        // 获取进程的 未决信号集
        sigset_t pending;
        sigemptyset(&pending);

        int ret = sigpending(&pending);
        assert(ret == 0);
        (void)ret; // 欺骗编译器，避免 release 模式中出错

        DisplayPending(pending);
        sleep(1);
    }
}

int main()
{
    cout << "当前进程: " << getpid() << endl;
    
    //使用 sigaction 函数
    struct sigaction act, oldact;

    //初始化结构体
    memset(&act, 0, sizeof(act));
    memset(&oldact, 0, sizeof(oldact));

    //初始化 自定义动作
    act.sa_handler = handler;

    //初始化 屏蔽信号集
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);
    sigaddset(&act.sa_mask, 5);

    //给 2号 信号注册自定义动作
    sigaction(2, &act, &oldact);

    // 死循环
    while (true);

    return 0;
}