文章目录
- 一、信号处理
- 二、再谈进程地址空间
- 三、内核如何实现信号的捕捉
- 四、sigaction
一、信号处理
我们知道，信号保存以后，会在合适的时候进行处理这个信号。
那么信号是如何被处理的？什么时候进行处理呢？
当我们的进程从内核态返回到用户态的时候，进行信号的检测和处理！
内核态：就是允许访问操作系统的代码和数据
用户态：只能访问用户自己的代码和数据
当我们使用系统调用的时候，操作系统是会自动做“身份”切换的，用户身份变为内核身份，或者反着来
我们的CPU它可以响应外部的中断，也可以内部直接产生中断
下面这条汇编指令，它可以直接从用户态陷入内核态。即就可以访问操作系统的代码了
int 80
二、再谈进程地址空间
如下图所示，我们都是比较熟悉的
我们会发现，进程地址空间中，有一个3G的用户空间，和1G的内核空间。
我们前面所谈的所有东西，都是这3GB的用户空间中的内容
上面的这1GB内核空间，它映射的是操作系统的代码和数据
而这内核空间会通过内核级页表映射操物理内存的底部！（当然也有的会通过直接映射到物理内存，这里我们不讨论它）
那么用户级页表有几份？
有几个进程，就有几份用户级页表，进程具有独立性
内核级页表有几份？
内核级页表只有一份，即每个进程看到的34GB的东西是一样的！在整个系统中，进程再怎么切换，34GB的空间的内容是不变的！！！
所以站在进程的视角：调用系统中的方法，就是在我们自己的地址空间中进行执行的
站在操作系统的视角：任何一个时刻，都会有进程执行（即便一个进程都没有，操作系统也有自己对应的进程在运行。只需要它自己的内核空间即可）。我们想要执行操作系统的代码，就可以随时执行！
操作系统的本质：
基于时钟中断的一个死循环！
我们可能会疑惑，我们自己的代码是让操作系统去运行的。是谁让操作系统去运行的呢？
其实在计算机硬件中，有一个时钟芯片，每隔很短的时间（纳秒级别），向计算机发送时钟中断。
如下图所示，时钟会不断的发送时钟中断，然后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 <signal.h>
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 <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstring>
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 <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstring>
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 <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstring>
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 <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstring>
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;
}
运行结果为
