【Linux】信号保存&信号处理

前言:对信号产生的思考

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

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


1 阻塞信号

1.1 相关概念

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

1.2 内核中的表示

【Linux】信号保存&信号处理_第1张图片

 【结构分析

  • 每个进程都有两个标志位,分别是阻塞(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
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
原型:int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

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

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

【Linux】信号保存&信号处理_第2张图片

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

sigpending函数

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

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

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

using namespace std;

#include 

#include 
#include 

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;
}

【Linux】信号保存&信号处理_第3张图片

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

2 捕捉信号(处理信号)

信号处理的时间有两种:

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

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

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

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

2.1 用户态和内核态

【用户态和内核态概念】

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

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

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

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

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


【剖析切换的过程】

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

【Linux】信号保存&信号处理_第4张图片

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

【Linux】信号保存&信号处理_第5张图片

【Linux】信号保存&信号处理_第6张图片 

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

【Linux】信号保存&信号处理_第7张图片

 

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

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

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

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


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

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

【Linux】信号保存&信号处理_第8张图片

【Linux】信号保存&信号处理_第9张图片 

 2.3 系统调用函数

 sigaction

#include
原型:int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

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

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

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

act和oact指向sigaction结构体

【Linux】信号保存&信号处理_第10张图片

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;
}

你可能感兴趣的:(Linux,服务器,运维)