Linux——信号

什么是信号

Linux下的信号

信号的记录

信号处理的常见方式

产生信号

使用组合键产生信号（包含core dump）

使用系统调用向进程发送信号

由软件条件产生信号

由硬件异常产生信号

阻塞信号

内核表示

sigset_t

信号集操作函数

sigpending

sigprocmask

示例

捕捉信号

内核状态与用户状态

内核信号捕捉

sigaction

可重入函数

volatile关键字

SIGCHLD

什么是信号

在我们生活中就有很多的信号，比如道路上经常会看到的红绿灯，红灯停，绿灯行，那我们为什么会知道呢，那是因为我们记住了什么是信号，记住了看到这个信号后应该做什么。

Linux下的信号

Linux下的信号本质上是一种通知机制，用户或者操作系统通过发送信号，通知进程某件事已经发生了，之后就可以处理它了。

进程要处理信号，必须具有识别信号的能力，有时我们虽然接受到了这个信号，但是我可能不会立马处理这个信号，无法处理，那也要先被临时记住，然后在合适的时候处理。

对于信号的产生，它和进程运行是异步的。

以前我们运行代码的时候，程序是个死循环，我们想要关闭它就是用过Ctrl + c，它是一个热键，实际上它就是向进程发送2号信号，当然要先识别组合键，这种键盘的工作方式是通过中断方式进行的。

使用kill -l命令就可以查看Linux中的信号列表，信号编号是1~64，在这之中没有32、33，1~31我们叫做普通信号，34~64我们叫做实时信号。

输入man 7 signal就可以查看信号的信息。

信号的记录

既然是操作系统发送的信号，那么要不要管理起来呢，那是肯定的，我们要判断一个信号是否产生，进程必须具有保存信号的相关数据结构，很明显就是使用位图结构，并保存在进程的PCB中，这部分属于内核数据结构，所以只有操作系统有权利向目标进程写入。

例如：Ctrl + c，操作系统首先要识别组合键，再找到进程列表的前台进程，然后写入对应的信号到进程内部的位图结构中。

信号处理的常见方式

执行信号的默认处理动作（进程自带的）。
忽略该信号。
自定义动作（捕捉信号）。

产生信号

使用组合键产生信号（包含core dump）

通过方法捕捉信号，修改进程对特定信号的处理动作，并不会直接调用对应的处理动作。如果没有产生这个signum，函数指针指向的方法就不会被调用。

参数：

signum表示要捕捉的信号。
参数类型为函数指针，传入一个函数指针，这个函数要处理这个捕捉到的信号。
#include <iostream>
#include <unistd.h>
#include <signal.h>

using namespace std;

void catchSignal(int signum)
{
    cout << "捕捉到了一个信号，正在处理：" << signum << ", pid: " << getpid() << endl;
}

int main()
{
    signal(SIGINT, catchSignal);

    while (true)
    {
        cout << "进程运行中... pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}
信号的默认处理动作更改了，并没有终止进程，而是执行了特定的处理动作。

键盘上还有一个组合键就是Ctrl + \，它是向进程发送3号信号，也会终止掉进程。

        可以看到两个信号对应的动作不一样，Term就是terminate表示终止，Core在终止进程的时候会进行一个动作：核心转储。

在进程控制的章节提到了status，那里有一张图。

        进程等待返回的输出型参数status，被信号杀掉会在0~6这7为重存储终止信号，这一位7的位置就存放的是core dump标志。

        在云服务器中，核心转储是默认被关掉的，我们可以通过使用ulimit -a命令查看当前资源限制的设定。

        这里表示core文件的大小为0，表示核心转储是被关闭的，使用ulimit -c 大小来设置core文件的大小，这个操作也仅限于本次会话。

        设置完了，核心转储该怎么用呢，就比如信号中有一个8号信号SIGFPE浮点数异常，它的操作也是Core。

        随便写一个除0错误，这时在报错信息后就有了（core dumped），并且目录下也会多一个文件core.pid。

当运行中代码出错了，我们要知道出错原因是什么。这时我们就会用到核心转储，核心转储指的是操作系统在进程收到某些信号而终止运行时，将该进程地址空间的内容以及有关进程状态的其他信息转而存储到一个磁盘文件当中，这个磁盘文件也叫做核心转储文件。而核心转储的目的就是为了在调试。

我们重新编译一下，在g++选项中加入-g，使用gdb调试，输入core-file core.pid就可以得到这些信息。

所以core_dump标志表示的就是是否发生核心转储。
int main()
{
    pid_t id = fork();
    if (id == 0)
    {
        sleep(10);
        int a = 10;
        a /= 0;
        exit(1);
    }
    int status = 0;
    waitpid(id, &status, 0);
    cout << "父进程: " << getpid() << ", 子进程: " << id
         << ", exit sig: " << (status & 0x7F) << ", is core: " << ((status >> 7) & 1) << endl;

    return 0;
}
这里core dump标志就被设置成1，代表需要核心转储，并在磁盘中建立了文件。

当我们在这个除0错误之前向他发送其他信号，那么core dump就不会被设置

当我们把这个功能关掉也就不会发生核心转储了。

因为在我们平常使用的环境中是默认关闭core dump的，原因就是如果出错发生了核心转储，那么就要在磁盘上创建一个文件，如果一直出错，久而久之就会有大量的core dump文件，此时操作系统都有可能会挂掉，为了节约成本所以要关闭它。

使用系统调用向进程发送信号

作用：让操作系统向指定进程发送指定信号。

参数：进程pid和信号。

返回值：成功返回0，失败返回-1。
static void Usage(string proc)
{
    cout << "Usage:\r\n\t" << proc << " signumber pid" << endl;
}

// ./mykill 2 pid
int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
    }
    int signumber = atoi(argv[1]);
    int procid = atoi(argv[2]);

    kill(procid, signumber);

    return 0;
}
这就我们自己写的一个程序可以向指定进程发送信号。

作用：让操作系统向自己发送指定信号。

参数：信号。

返回值：成功返回0，非0表示失败。

作用：让操作系统给自己发送6号SIGABRT信号，就是自己终止自己。

由软件条件产生信号

SIGPIPE

上一篇进程间通信中就提到了，如果把读端关闭，写端一直写，管道已经没有人读了，这个写入就没有意义，操作系统会自动终止对应的写端进程，就是向写端进程发送13号SIGPIPE信号。这是一种由软件发现运行条件不满足的时候发送的一种信号，管道也是软件。

SIGALRM

参数：设置几秒后让操作系统向我发送SIGALRM信号

返回值：

若调用alarm函数前，进程已经设置了闹钟，则返回上一个闹钟时间的剩余时间，并且本次闹钟的设置会覆盖上一次闹钟的设置。
如果调用alarm函数前，进程没有设置闹钟，则返回值为0。
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <functional>
#include <vector>

#include <sys/wait.h>
#include <sys/types.h>

using namespace std;

typedef function<void()> func;
vector<func> callbacks;

uint64_t count = 0;

void showCount()
{
    cout << "count: " << count << endl;
}

void catchSig(int signum)
{
    cout << "捕捉到了一个信号，正在处理：" << signum << ", pid: " << getpid() << endl;

    for (auto& f : callbacks)
    {
        f();
    }
    alarm(1);
}

int main()
{
    // 要捕捉的信号
    signal(SIGALRM, catchSig);

    // 设置闹钟
    alarm(1);

    // 添加函数
    callbacks.push_back(showCount);

    while(true) count++;

    return 0;
}
一个简单的累加器，通过这个代码我们也可以做到某一段时间后我们可以执行相应的操作。

由硬件异常产生信号

除0错误
void catchSig(int signum)
{
    sleep(1);
    cout << "捕捉到了一个信号，正在处理：" << signum << ", pid: " << getpid() << endl;
}

int main()
{   
    signal(SIGFPE, catchSig);
    int a = 10;
    a /= 0;

    while (true) sleep(1);

    return 0;
}
通过上面的代码运行结果就会发现问题，代码中有除0错误，也捕捉到了信号，但是为什么会一直循环的打印呢？

在我们的电脑中，是谁一直在帮我们计算，那就是CPU，CPU就是个硬件，我们也知道在CPU中有很多寄存器，其中就有一个状态寄存器，在这之中就有一个溢出标记位，操作系统在计算完毕之后就会检测，如果溢出标记位为1就代表发生了溢出问题，他就会找到当前正在运行的进程，向它发送信号，这个进程就会在合适的时候进行处理。

所以这种除0文件其实是一个硬件问题，一旦出现硬件异常，默认是终止进程，或者使用try/catch，实际也是做不了什么。

那么为什么会出现死循环？因为一旦触发了异常是要终止的，但是如果捕捉了这个信号就要自定义处理方式，处理了但没有终止进程，那寄存器中的异常信息没有处理，虽然有异常，进程切换的时候也会保存进程的上下文数据，当恢复的时候操作系统就会发现这个异常，然后不断的发送8号信号。解决这个问题那就捕捉到信号的时候直接终止进程就好了。

野指针或越界问题

无论是哪一个错误，他们都会通过地址找到目标位置，然而我们语言层面的地址都是虚拟地址，虚拟地址和物理地址映射的时候是通过页表+MMU（Memory Manager Unit 内存管理单元，这是一个硬件）。

MMU是一种处理CPU的内存访问请求的硬件，所以映射工作是由它做的，

当需要进行虚拟地址到物理地址的映射时，先将虚拟地址给MMU，它会计算出对应的物理地址，然后我们再访问这个物理地址。

而MMU既然是硬件，那么它当然也要记录相应的状态信息，当出现野指针或者越界访问非法地址时，MMU进行虚拟地址到物理地址的转换时就会报错，然后将错误信息写入，这时硬件上面的信息也会立马被操作系统识别到，然后找到当前进程，向该进程发送SIGSEGV信号。

阻塞信号

关于信号的其他相关概念：

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

内核表示

这个pending表就是上述的位图结构，0代表没有收到该比特位的信号，1表示收到了；handler表就是函数指针数组，一旦pending表中收到了这个信号，那么就拿着信号的编号去handler表中找对应的函数处理方法，signal函数需要的参数一个是信号编号，另一个就是函数，signal就是通过这个信号的编号，找到handler表中对应的位置，再填入函数地址，这就是信号的自定义捕捉。

系统也提供了默认处理的宏，SIG_DEF和SIG_IGN。

还有一个block位图，和pending位图的结构一模一样，这个位图中表示的是信号是否被阻塞。

所以一个信号的处理流程应该是这样的：

操作系统向目标进程发送信号，其实就是修改pending位图。
进程合适的时候处理信号，找到pending位图中收到的信号。
再看block位图中该信号是否被阻塞。
最后再调用处理方法。

sigset_t

一般而言，语言会给我们提供头文件或者定义的结构体，操作系统也会提供这些，因为操作系统不希望我们直接访问这些数据结构，所以会给我们提供接口来访问他们。

sigset_t就是操作系统提供的位图结构，但是不允许用户直接进行位操作，它会给我们提供对应的方法来完成对应的功能。

sigset_t称为信号集，pending位图就叫做信号集，block信号集叫做信号屏蔽字，这个类型可以表示每个信号的“有效”或“无效”状态。

在信号屏蔽字中“有效”和“无效”的含义是该信号是否被阻塞。
在信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

信号集操作函数

#include <signal.h>

int sigemptyset(sigset_t *set); // 初始化set信号集，所有比特位清零

int sigfillset(sigset_t *set); // 初始化set信号集，所有比特位置1

int sigaddset(sigset_t *set, int signum); // 在set信号集中添加某种有效信号

int sigdelset(sigset_t *set, int signum); // 在set信号集中删除某种有效信号

// 上面的函数成功返回0，失败返回-1

int sigismember(const sigset_t *set, int signum); // 判断set信号集中是否包含某种信号，若包含则返回1，不包含则返回0，调用失败返回-1

sigpending

int sigpending(sigset_t *set); 
作用：获取当前进程的pending信号集

返回值：成功返回0，失败返回-1。

sigprocmask

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
作用：可以读取或更改进程内核中的信号屏蔽字（默认进程不会对任何信号block）

参数：

how：
SIG_BLOCK：添加set到当前信号屏蔽字的信号，相当于mask = mask | set
SIG_UNBLOCK：从当前信号屏蔽字中解除阻塞set中的信号，相当于mask = mask | ~set
SIG_SETMASK：设置当前信号屏蔽字为set，相当于mask=set
set：信号屏蔽字
oldset：输出型参数，拿到更改前的set信号屏蔽字

示例

这样就可以捕捉所有的信号了，是不是也就没有任何信号可以杀掉这个进程呢？
#include <iostream>
#include <signal.h>
#include <unistd.h>

using namespace std;

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

int main()
{ 
    for (int i = 1; i <= 31; i++) signal(i, catchSig);

    while (true) sleep(1);

    return 0;
}
我们发现9号信号没有被捕捉，直接杀掉了进程，所以9号信号是不能被捕捉的，操作系统为了解决所有信号都被捕捉，没有信号能让进程退出的问题。

static void showPending(sigset_t &pending)
{
    for (int sig = 1; sig <= 31; sig++)
    {
        if (sigismember(&pending, sig)) cout << " 1";
        else cout << " 0";
    }
    cout << endl;
}

int main()
{
    // 1.定义信号集
    sigset_t bset, obset; // 信号屏蔽字,阻塞信号集
    sigset_t pending; // 信号集

    // 2.初始化信号集
    sigemptyset(&bset);
    sigemptyset(&obset);
    sigemptyset(&pending);

    // 3.添加进行屏蔽的信号
    sigaddset(&bset, 2); // SIGINT

    // 4.设置到内核中
    int n = sigprocmask(SIG_BLOCK, &bset, &obset);
    assert(n != -1);
    (void)n;
    cout << "阻塞2号信号成功, pid: " << getpid() << endl;  

    // 5.重复打印pending信号集
    while (true)
    {
        // 5.1 获取进程的pending信号集
        sigpending(&pending);

        // 5.2 显示pending信号集中没有被递达的信号
        showPending(pending);
        sleep(1);
    }
    return 0;
}

这样就屏蔽了2号信号，如果我们想要过一段时间解除阻塞2号，就可以修改一下。

// ...
    // 5.重复打印pending信号集
    int count = 0;
    while (true)
    {
        // 5.1 获取进程的pending信号集
        sigpending(&pending);

        // 5.2 显示pending信号集中没有被递达的信号
        showPending(pending);
        sleep(1);
        count++;
        if (count == 10)
            sigprocmask(SIG_SETMASK, &obset, nullptr); // 使用修改之前的信号集
    }
// ...

当我们解除阻塞之后，2号信号确实被递达了，直接执行了默认处理动作——终止进程。

如果不想让进程终止，也可以使用signal函数捕捉信号。