前言：对信号产生的思考

上一篇博客所说的信号产生，最终都要有OS来进行执行，为什么？OS是进程的管理者！
信号的处理是否是立即处理的？在合适的时候 -》那什么是合适的时候？
信号如图不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？
一个进程没有接收到信号的时候，能否知道，自己应该对合法信号做处理呢？他又是如何知道的呢？
如何理解OS向进程发送信号？能否描述一下完整的发送过程？

以上的问题将在本篇博客得到解释！

1 阻塞信号

1.1 相关概念

实际执行信号的处理动作称为信号递达(Delivery)
信号从产生到递达之间的状态,称为信号未决(Pending)。
进程可以选择阻塞 (Block )某个信号。
被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。

1.2 内核中的表示

【结构分析】

每个进程都有两个标志位，分别是阻塞（block）和未决（pending），还有一个函数指针指向信号处理的函数。block和pending是一种位图结构，handler是一个函数指针数组
当函数产生后，内核在进程控制块中把pending被设为1，只有等函数递达（执行函数开始），pending才变回0。
SIGHUP信号未产生过。
SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。
SIGQUIT信号还未产生，但是已经提前被阻塞，产生后会立刻进入阻塞状态。
如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。本章不讨论实时信号。

sigset_t类型

从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

1.3 信号集操作函数

用户层调用函数

sigset_t每一位都代表一个信号的“有效”或“无效”状态，至于sigset_t内部是如何存储这些数据的我们不需要关心，是由操作系统去维护的。所以我们想要操作sigset_t变量要通过下面的这些函数，而不应该对内部数据有任何操作，因为这是没有意义的。

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset (sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);

sigemptyset和sigfillset为初始化函数，初始化set所指向的信号集。sigempty将所有bit位清零，sigfillset将所有bit位置1。
在使用sigset_t类型的变量前，必须要对它进行初始化，使信号集处在确定状态。
在对sigset_t类型的变量初始化后，可以用sigaddset或sigdelste对信号集进行有效信号的增加和删除。
这四个函数都是成功返回1，失败返回0。

int sigismember（const sigset_t *set, int signo);

sigismember是一个bool函数，用来判断某个信号集中是否包含某个有效信号，包含返回1，不包含返回0。

系统调用

我们上面定义的sigset_t类型变量是在栈中的，本质上是在用户层，没有进操作系统。我们对它的操作仅仅是改变这个变量的值，并不会影响进程的任何行为。我们想借助sigset_t类型变量影响系统和进程需要调用下面的接口。

sigprocmask函数

#include <signal.h>
原型：int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

功能：来读取或更改进程的阻塞信号集。
返回值: 若成功则为0,若出错则为-1

参数说明：如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则更改进程的信号屏蔽字,参数how指示如何更改。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值。

如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中一个信号递达。

sigpending函数

#include <signal.h>
原型：int sigpending(sigset_t *set);
读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。

下面我们写一个进程来完成以下操作：

将信号2阻塞
发送信号2
十秒后解除信号2阻塞
每隔一秒打印一次未决信号集

#include <iostream>

using namespace std;

#include <cassert>

#include <unistd.h>
#include <signal.h>

void PrintPending()
{
    sigset_t pd;
    int ret = sigpending(&pd);
    assert(ret == 0);
    (void)ret;

    for (int signo = 1; signo <= 31; ++signo)
    {
        if (sigismember(&pd, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

void sighandler(int signo)
{
    cout << "捕捉到：" << signo << endl;
}

int main()
{
    // 捕捉信号2
    signal(2, sighandler);

    // 1. 将信号2阻塞
    sigset_t set, oset;
    // 初始化
    sigemptyset(&set);
    sigemptyset(&oset);
    sigaddset(&set, 2); // 设置2信号bit位为1
    // 设置到进程中
    sigprocmask(SIG_SETMASK, &set, &oset);
    cout << "设置信号2的阻塞" << endl;
    int cnt = 0;

    while (true)
    {
        // 获取pending的信号集
        PrintPending();
        sleep(1);
        if (cnt++ == 10)
        {
            sigprocmask(SIG_SETMASK, &oset, &set);
            cout << "解除信号2的阻塞" << endl;
        }
    }

    return 0;
}

程序运行时,每秒钟把各信号的未决状态打印一遍,由于我们阻塞了SIGINT信号,按Ctrl-C将会使SIGINT信号处于未决状态,按Ctrl-\仍然可以终止程序,因为SIGQUIT信号没有阻塞。

2 捕捉信号（处理信号）

信号处理的时间有两种：

立即处理
等待到合适的时间在进行处理

是什么时候是立即处理呢？如果一个信号之前是被block的，当它解除阻塞之后就会被立即处理，对应的信号就会被立即送达！

为什么要等到合适的时间才处理呢？答：因为信号的产生是异步的，可能信号产生的时候进程正在坐着重要的事情；

那是什么时候是合适的时间呢？答：当进程从内核态切回用户态的时候，进程会在OS指导下，进行信号的检查和处理 --》疑问什么是内核态？什么是用户态？

2.1 用户态和内核态

【用户态和内核态概念】

用户态：执行用户自己的代码，系统所处的状态叫做用户态。用户态是一种受监管的普通状态。

内核态：有时候我们写的代码中，调用了系统接口，本质上就是调用了内核级的代码，这时候就需要内核态权限。内核态通常用来执行os代码，是一种权限非常高的状态。

【用户态与内核态切换场景】

用户态->内核态：系统调用，时间片到了导致进程切换，异常，中断，陷阱，这些情况会切换到内核态。

内核态->用户态：系统调用，进程切换，异常，中断，陷阱处理完毕后，会切换回用户态。

【剖析切换的过程】

在用户态时，访问用户的代码和数据，切换到内核态后，比如调用系统接口后，往往会执行操作系统内核中的代码。那么进程是怎么找到操作系统的呢？首先要明确一个概念，操作系统也是一款软件，既然是软件运行的时候就会被加载到内存中。每个进程都有一张地址空间表，这张表下半部分为用户区，通过用户页表映射找到内存中用户的代码和数据。上方为内核空间，保存了内核的虚拟地址，可以通过内核页表映射找到内存中操作系统内核的代码和数据。

进程无论如何切换，都能看到操作系统，但不一定能访问，只有处在内核态时才能够访问。那么处于内核态还是用户态的标志是什么呢？我们知道代码是加载到cpu中进行运算的，在cpu中有一个cr3寄存器，里面记录了是否此时的状态是用户态3还是内核态0。同时cpu中还有寄存器记录着用户页表和内核页表的值，当在某种状态下访问越界，cpu可以检索到。

2.2 捕捉并处理信号过程分析

信号递达时处理的动作为用户自己定义的函数,这称为捕捉信号。

通过前文的学习我们知道，进程在收到信号后不一定是立刻处理的，而是等到适合的时候。那么什么是适合的时候呢？答案：系统从用户态切到内核态后。

假设用户程序注册了信号2的处理函数sighandler。下面我来阐述捕获进程信号的过程：

当前正在运行main函数为用户态，此时发生了系统调用，时间片到了导致进程切换，异常，中断，陷阱，切换到内核态。
当中断处理完毕后在返回用户态的main函数前要检查是否有信号未决，假设收到了信号2，则先进入信号2的处理函数sighandler，由于sighandler是用户程序定义的，所以要切换到用户态。
等sighandler函数执行完毕后，自动执行特殊的系统调用sigreturn再次进入内核态。
如果没有新的信号要递达，这次返回用户态进入main函数中继续执行上下文。

思考一个问题：在内核态是否能调用用户的代码和数据呢？

理论上以内核的权限是可以的，但实际上并不能这么做，因为操作系统不信任任何人，它担心用户会越权执行一些非法操作。

2.3 系统调用函数

sigaction

#include <signal.h>
原型：int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

功能：sigaction函数可以读取和修改与指定信号相关联的处理动作。

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

参数：signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非空,则通过oact传出该信号原来的处理动作。

act和oact指向sigaction结构体:

sa_handler：将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。

sa_mask：当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止。如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。

sa_flags：字段包含一些选项,本章的代码都把sa_flags设为0

sa_sigaction：是实时信号的处理函数,本章不详细解释这两个字段,有兴趣的同学可以在了解一下。

【测试代码】


void PrintPending()
{
    sigset_t pd;
    int ret = sigpending(&pd);
    assert(ret == 0);
    (void)ret;

    for (int signo = 1; signo <= 31; ++signo)
    {
        if (sigismember(&pd, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

void sighandler(int signo)
{
    cout << "捕捉到：" << signo << endl;
    int cnt = 5;
    while (cnt--)
    {
        PrintPending();
        sleep(1);
    }
}

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

    act.sa_handler = sighandler;
    sigaddset(&act.sa_mask, 3);
    sigaction(2, &act, &oact);
    while (true)
    {
        PrintPending();
        sleep(1);
    }

    return 0;
}