Linux操作系统中的信号剖析，

1、前言

        信号是一种信息载体，在现实中，信号就是表示消息的物理量，比如说红绿灯，古时候狼烟等等，就拿红绿灯来说，为什人和车辆都是看到绿灯才会通行，红灯亮了就要停下来，因为这是现实生活中制定的规则，那么在操作系统中，也有一种叫做信号的东西，那操作系统中的信号又是怎么一回事，在这篇文章里，咱们一起讨论一下吧！注：本篇文章中的观点有任何的错误都请在文章下面评论指出来，谢谢！

2、信号概念

        当我们在linux中敲写代码，执行出一些错误，比如说死循环之类的错误的时候，我们都会使用ctrl + c 来结束当前进程，那么我们有没有想过，这个ctrl + c的底层到底是个什么东西。其实就是linux中的信号，

使用ctrl + c来终止当前进程：

#include <iostream>
#include <unistd.h>

int main() {
    while (1) {
        std::cout << "此进程死循环中 ，pid：" << getpid() << std::endl;
        sleep(1);
    }
    return 0;
}

1.ctrl + c 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
2. Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像ctrl + c 这样这种控制键产生的信号，

2.1 概念：

        信号是进程之间事件异步通知的一种方式，属于软中断。

        在Linux系统中，可以使用一下命令来查看系统中的信号：

kill -l

        每个信号都有一个编号和一个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定义   #define SIGINT 2

        编号34以上的信号都是实时信号，就平常而言的话，不常用，所以我们不做讨论。如果有需要了解的话，可以在linux中使用man命令查看：

man 7 signal

2.2 信号的处理方式

信号的处理方式有以下三种：

        （1）忽略此信号

        （1）执行该信号的默认处理动作

        （3）执行用户提供的自定义信号处理函数，具体怎么执行我们后面详细说。这种方式叫做信号捕捉，

        要说清楚一个信号，那就要从信号是如何产生，如何捕捉，在操作系统中如何体现来看，下来我们就详细说说

3、信号的产生

3.1 通过终端信号产生信号

        这种产生信号的方式其实就是我们用来开篇的例子，其中ctrl + c 就是我们的2号信号，也就是SIGINT这个信号，对应的还有我们的 ctrl + \ ,就是我们能看到的3 号信号了，就是SIGQUIT，这两个信号都是终止进程，那他俩有什么不同吗，

        我们可以看到他们的动作是不一样的，其中 SIGINT 的 action 是 Term，只是单纯的终止进程，当然只是从我们的用户层面看，其中不同的是信号 SIGQUIT 的 action 是 Core ，他干了点什么呢。

        这里我们就要理解一个概念，那就是底层CPU在执行队列中的进程的时候，并不是一个进程执行完，再去执行下一个进程，因为CPU的速度是很快的，我们平时使用电脑的时候，感觉可以同时运行好多程序，其实对于CPU来说，他并没有同时处理多个进程的能力，他只是对这些进程进行轮询处理，进程1执行一段，进程2执行一段，因为他的速度很快，所以在上层我们就感觉CPU在同时执行好多进程一样，

        那这和我们说的 Core 有什么关系呢。因为CPU在切换处理进程的时候，他肯定是保存了一些信息在某个角落里，不然他下次处理没处理完的进程的时候，怎么知道上次我执行到那里了，被保存的这个东西就是进程的用户地址空间内存的数据。相应的，如果cpu在处理进程的时候，遇到了信号，或者是异常，他可以将这些数据进行保存。那么问题又来了，在进程还没结束的时候，只是该进程的抢到的时间片到了，进程并未结束，那也就是说它可以将该进程的信息存储到PCB中，那程序遇到异常或者执行了信号，程序是会结束的，那他在PCB中的资源也就被释放了，那么它会将这些资源保存到哪里呢，这个时候就需要Core Dump。

        所谓的Core Dump也很简单理解起来，就是将用户空间内存以文件的方式保存到磁盘。事后可以用调试器检查core文件以查清错误原因,这叫做Post-mortem Debug（事后调试）。但是在系统中，默认是不会产生这个core文件的，因为这个举动会暴露用户密码关键信息，不安全，在开发阶段我们可以使用命令改变这个限制：

查看core选项：

ulimit -a #查看所有的选项

设置Core的值（指定这个文件的最大内存，这里我们设置吧1024k）：

ulimit -c 1024

 然后就可以使用gdb对代码调试了

        最后注意一点，要调试的话，摇摆难以debug版本下的，

3.2 调用系统函数向进程发信号

首先在后台执行死循环程序,然后用kill命令给它发SIGSEGV信号。

         指定发送某种信号的kill命令可以有多种写法,上面的命令还可以写成 kill -11 3338251，其中11代表的是信号  SIGSEGV，其中3338251是进程的pid，

        kill命令是调用kill函数实现的。kill函数可以给一个指定的进程发送指定的信号。raise函数可以给当前进程发送指定的信号(自己给自己发信号)。

#include <signal.h>

//对指定的进程发送signo信号
int kill(pid_t pid, int signo); 

//对自己发送信号signo
int raise(int signo);
//这两个函数都是成功返回0,错误返回-1。

模拟实现kill指令：

#include <iostream>
#include <string>
#include <sys/types.h>
#include <signal.h>
using namespace std;

int main(int argc,char* args[]) {
    if (argc != 3) {
        cout << "./mykill signo pid" << endl;
        exit(1);
    }
    kill(stoi(args[2]), stoi(args[1]));
    return 0;
}

 abort函数

#include <stdlib.h> 
void abort(void);
//就像exit函数一样,abort函数总是会成功的,所以没有返回值。

3.3. 由软件条件产生信号

alarm函数 和SIGALRM信号。

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
//调用alarm函数可以设定一个闹钟,
//也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 
//该信号的默认处理动 作是终止当前进程。

#include <iostream>
#include <unistd.h>

int main() {
    alarm(1);
    int count = 1;
    while (count++){
        std::cout << count << std::endl;
    }
    return 0;
}

设置一个一秒的闹铃，对count不断++；

运行结果如下：

3.4 硬件异常产生信号

        硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释 为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

4、信号捕捉和信号屏蔽

4.1 阻塞信号

4.1.1. 信号其他相关常见概念

实际执行信号的处理动作称为信号递达(Delivery)

信号从产生到递达之间的状态,称为信号未决(Pending)。

进程可以选择阻塞 (Block )某个信号。

被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.

        注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。

4.1.2. 在内核中的表示

        信号在内核中的表示示意图

         每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。

        SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。

        如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。

4.1.3. sigset_t

        从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。后面将详细介绍信号集的各种操作。  阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略。

4.1.4. 信号集操作函数

        sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态,至于这个类型内部如何存储这些bit则依赖于系统实现,从使用者的角度是不必关心的,使用者只能调用以下函数来操作sigset_ t变量,而不应该对它的内部数据做任何解释,比如用printf直接打印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);
int sigismember(const sigset_t *set, int signo);

函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含任何有效信号。

函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示  该信号集的有效信号包括系统支持的所有信号。

        注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

这四个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含某种  信号,若包含则返回1,不包含则返回0,出错返回-1。

4.1.5 sigprocmask函数

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 
//返回值:若成功则为0,若出错则为-1

        如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则 更改进程的信号屏蔽字,参数how指示如何更改。如果oset和set都是非空指针,则先将原来的信号 屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值。

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

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

using namespace std;

int main() {

    sigset_t set, oset;
    sigemptyset(&set);
    sigemptyset(&oset);

    //使用sigprocmask函数阻塞2号信号和40号信号
    sigaddset(&set, 2);
    sigaddset(&set, 40);

    //SIG_BLOCK表示添加对set中的信号的屏蔽 ，相当于mask = mask | set，
    //SIG_UNBLOCK表示解除对set中的信号进行的屏蔽 mask = mask &~ set
    //SIG_SETMASK表示直接使用set中的信号屏蔽 mask = set
    sigprocmask(SIG_BLOCK, &set, &oset);

    while (1) {
        cout << "进程正在运行！" << getpid() << endl;
        sleep(1);
    }
    return 0;
}

4.1.6 sigpending函数

#include <signal.h>
int sigpending(sigset_t *set);

读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。    下面用刚学的几个函数做个实验。程序如下:

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

using namespace std;

void printpending(sigset_t* s){
    int i = 31;
    for (; i > 0; --i) {
        cout << sigismember(s, i);
    }
    cout << endl;
}

int main() {

    sigset_t set, pending;
    //清空初始化
    sigemptyset(&set);
    //将ctrl + c 2号信号添加入阻塞信号集
    sigaddset(&set, SIGINT);
    //设置信号集
    sigprocmask(SIG_BLOCK, &set, nullptr);

    while (1) {
        sigpending(&pending);
        printpending(&pending);
        sleep(1);
    }


    return 0;
}

 4.2 捕捉信号

4.2.1 内核如何实现信号的捕捉

        如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码是在用户空间的,处理过程比较复杂,举例如下: 用户程序注册了SIGQUIT信号的处理函数sighandler。  当前正在执行main函数,这时发生中断或异常切换到内核态。  在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。  内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函  数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是  两个独立的控制流程。 sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。  如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。

4.2.2 signal函数

sighandler_t signal(int signum, sighandler_t handler);

#include <iostream>
#include <signal.h>

using namespace std;

void handler(int signum) {
    cout << "捕获信号：" << signum << endl;
}

int main() {

    signal(SIGINT, handler);//给信号SIGINT也就是2号信号绑定自定义处理函数
    //也就实现对信号的捕捉
    while (1) {;}
    return 0;
}

4.2.3. sigaction

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

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

using namespace std;

void sigcd(int signum){
    cout << "捕获了信号：" << signum << endl;
}

int main() {

    cout << "进程：" << getpid() << endl;

    struct sigaction act, oact;
    act.sa_handler = sigcd;

    sigaction(2, &act, &oact);

    while (1) {;}

    return 0;
}

5、结语

本篇文章中观点若有错误，请私信指出！谢谢