Linux进程 ----- 信号处理

前言

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

一、信号的处理时机

1.1 处理时面临的情况

普通情况

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

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

特殊情况

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

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

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

1.2 “合适”的时机

信号的产生是异步的

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

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

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

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

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

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

二、用户态与内核态

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

2.1 概念理论

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

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

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

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

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

用户态 切换为 内核态：

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

内核态 切换为 用户态：

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

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

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

2.2 再现进程地址空间

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

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

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

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

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

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

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

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

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

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

这个跑到是如何实现的呢？

在 CPU 中，存在一个 CR3 寄存器，这个 寄存器 的作用就是用来表征当前处于 用户态 还是 内核态

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

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

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

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

2.3 信号处理过程

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

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

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

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

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

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

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

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

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

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

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

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

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

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

三、信号的捕捉

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：当信号在执行用户自定义动作时，可以将部分信号进行屏蔽，直到用户自定义动作执行完成

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