【Linux学习】进程信号

最新推荐文章于 2023-10-25 23:38:43 发布

求知.

最新推荐文章于 2023-10-25 23:38:43 发布

阅读量679

点赞数 2

分类专栏： Linux学习文章标签： linux 学习

本文链接：https://blog.csdn.net/qq_61635026/article/details/127947767

版权

Linux学习专栏收录该内容

18 篇文章 7 订阅

订阅专栏

前言

本文是博主对学习完Linux系统中的进程信号部分的知识点总结，在阅读完该文章之后，我们会对进程信号有更深层次的理解。学习完本文后我们可以掌握以下内容：Linux信号的基本概念、掌握信号产生的一般方式、理解信号递达和阻塞的概念和原理、掌握信号捕捉的一般方式、重新了解可重入函数的概念、了解竞态条件的情景和处理方式、了解SIGCHLD信号，重新编写信号处理函数的一般处理机制。

一、信号初识

1. 信号的概念

对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号为 Linux 提供了一种处理异步事件的方法。在Linux当中，每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。信号定义在signal.h头文件中，信号名都定义为正整数。具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用。

2. Linux中的普通信号

如上文所示，一共有62个信号，实际上缺少了32和33号信号。编号34以上的是实时信号，本文只讨论编号34以下的信号，不讨论实时信号。这些信号各自在什么条件下产生，默认的处理动作是什么，在signal(7)中都有详细说明: man 7 signal。

以下是对Linux系统中31个普通信号的说明：

信号	说明
SIGHUP	当用户退出shell 时，由该shell 启动的所有进程将收到这个信号，默认动作为终止进程。
SIGINT	当用户按下了<Ctrl+C>组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动作为终止进程。
SIGQUIT	当用户按下<ctrl+>组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信号。默认动作为终止进程。
SIGILL	CPU 检测到某进程执行了非法指令。默认动作为终止进程并产生core 文件
SIGTRAP	该信号由断点指令或其他 trap 指令产生。默认动作为终止里程并产生 core 文件。
SIGABRT	调用abort 函数时产生该信号。默认动作为终止进程并产生 core 文件。
SIGBUS	非法访问内存地址，包括内存对齐出错，默认动作为终止进程并产生 core 文件。
SIGFPE	在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为 0 等所有的算法错误。默认动作为终止进程并产生 core 文件。
SIGKILL	无条件终止进程。本信号不能被忽略，处理和阻塞。默认动作为终止进程。它向系统管理员提供了可以杀死任何进程的方法。
SIGUSE1	用户定义的信号。即程序员可以在程序中定义并使用该信号。默认动作为终止进程。
SIGSEGV	指示进程进行了无效内存访问。默认动作为终止进程并产生 core 文件。
SIGUSR2	另外一个用户自定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程。
SIGPIPE	Broken pipe 向一个没有读端的管道写数据。默认动作为终止进程。
SIGALRM	定时器超时，超时的时间由系统调用alarm 设置。默认动作为终止进程。
SIGTERM	程序结束信号，与 SIGKILL 不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出。执行 shell 命令Kill 时，缺省产生这个信号。默认动作为终止进程。
SIGSTKFLT	Linux 早期版本出现的信号，现仍保留向后兼容。默认动作为终止进程。
SIGCHLD	子进程状态发生变化时，父进程会收到这个信号。默认动作为忽略这个信号。
SIGCONT	如果进程已停止，则使其继续运行。默认动作为继续/忽略。
SIGSTOP	停止进程的执行。信号不能被忽略，处理和阻塞。默认动作为暂停进程。
SIGTSTP	停止终端交互进程的运行。按下<ctrl+z>组合键时发出这个信号。默认动作为暂停进程。
SIGTTIN	后台进程读终端控制台。默认动作为暂停进程。
SIGTTOU	该信号类似于 SIGTTIN，在后台进程要向终端输出数据时发生。默认动作为暂停进程。
SIGURG	套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达，默认动作为忽略该信号。
SIGXCPU	进程执行时间超过了分配给该进程的CPU 时间，系统产生该信号并发送给该进程。默认动作为终止进程。
SIGXFSZ	超过文件的最大长度设置。默认动作为终止进程。
SIGVTALRM	虚拟时钟超时时产生该信号。类似于 SIGALRM，但是该信号只计算该进程占用 CPU 的使用时间。默认动作为终止进程。
SGIPROF	类似于SIGVTALRM，它不公包括该进程占用 CPU 时间还包括执行系统调用时间。默认动作为终止进程。
SIGWINCH	窗口变化大小时发出。默认动作为忽略该信号。
SIGIO	此信号向进程指示发出了一个异步IO 事件。默认动作为忽略。
SIGPWR	关机。默认动作为终止进程。
SIGSYS	无效的系统调用。默认动作为终止进程并产生 core 文件。

3. 信号的处理

信号的处理方式有三种，分别是：忽略、捕捉和默认动作。

忽略信号

大多数信号都可以采用这个方式进行处理，但有两种信号不能被忽略（即SIGKILL和SIGSTOP）。因为它们向内核和超级用户提供了进程终止和停止的可靠方法。如果忽略了，那么这个要处理的进程就变成了没人能管理的进程，显然是内核设计者不希望看到的场景。

捕捉信号

捕捉信号，就是需要告诉内核用户希望如何处理某一种信号，其实就是写一个信号处理的函数，然后将这个函数告诉内核。当该信号产生时，内核来调用用户自定义的函数，以此来达到处理信号的目的。

系统默认

对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。

二、信号产生

1. 终端按键产生信号

对于下面的死循环程序，我们可以通过键盘的ctrl+c进行终止：

#include <stdio.h>
#include <unistd.h>

int main()
{
	while (1){
		printf("hello signal!\n");
		sleep(1);
	}
	return 0;
}

当我们运行程序，在通过键盘ctrl+c就终止了该进程。

但实际上除了按ctrl+c之外，按ctrl+\也可以终止该进程。

二者都是通过按键终止进程，又有什么区别呢？
通过man 7 signal 我们可以发现按ctrl+c实际上是向进程发送2号信号SIGINT，而按ctrl+\实际上是向进程发送3号信号SIGQUIT。查看这两个信号的默认处理动作，可以看到这两个信号的Action是不一样的，2号信号是Term，而3号信号是Core。

Term和Core都代表着终止进程，但是Core在终止进程的时候会进行一个动作，那就是核心转储。

核心转储的概念：

核心转储（core dump），在汉语中有时戏称为吐核，是操作系统在进程收到某些信号而终止运行时，将此时进程地址空间的内容以及有关进程状态的其他信息写出的一个磁盘文件。

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

我们可以发现第一行是core文件的大小，它的默认大小被设定为0，因此就相当于关闭了核心转储的功能。我们可以通过ulimit -c size命令来设置core文件的大小。

此时我们再次运行程序，并用ctrl+\终止。就会发现终止进程后会显示core dumped。
并且会在当前路径下生成一个core文件，该文件以一串数字为后缀，而这一串数字实际上就是发生这一次核心转储的进程的PID。

核心转储的功能：

当我们的代码出错了，我们最关心的是我们的代码是什么原因出错的。如果我们的代码运行结束了，那么我们可以通过退出码来判断代码出错的原因，而如果一个代码是在运行过程中出错的，那么我们也要有办法判断代码是什么原因出错的。

当我们的程序在运行过程中崩溃了，我们一般会通过调试来进行逐步查找程序崩溃的原因。而在某些特殊情况下，我们会用到核心转储，核心转储指的是操作系统在进程收到某些信号而终止运行时，将该进程地址空间的内容以及有关进程状态的其他信息转而存储到一个磁盘文件当中，这个磁盘文件也叫做核心转储文件，一般命名为core.pid。

而核心转储的目的就是为了在调试时，方便问题的定位。我们用下面这段代码进行演示：

#include <cstdio>
#include <unistd.h>

int main()
{
    printf("Hello Linux...\n");

    sleep(3);
    int a = 1/0;

    return 0;
}

该代码当中出现了除0错误，该程序运行3秒后便会崩溃。

使用gdb对当前可执行程序进行调试，然后直接使用core-file core文件命令加载core文件，即可判断出该程序在终止时收到了8号信号，并且定位到了产生该错误的具体代码。

说明：

事后用调试器检查core文件以查清错误原因，这种调试方式叫做事后调试。

core dump 标志：

此时我们回忆前面所学习的【进程控制】中的获取子进程的退出码部分。

进程等待函数waitpid函数的第二个参数：

pid_t waitpid(pid_t pid, int *status, int options);

waitpid函数的第二个参数status是一个输出型参数，用于获取子进程的退出状态。status是一个整型变量，但status不能简单的当作整型来看待，status的不同比特位所代表的信息不同，具体细节如下（只关注status低16位比特位）：

若进程是正常终止的，那么status的次低8位就表示进程的退出状态，即退出码。若进程是被信号所杀，那么status的低7位表示终止信号，而第8位比特位是core dump标志，即进程终止时是否进行了核心转储。

打开Linux的核心转储功能，通过以下的程序查看core dump 的标志位信息。代码中父进程使用fork函数创建了一个子进程，子进程所执行的代码当中存在野指针问题，当子进程执行到*p = 1000时，必然会被操作系统所终止并在终止时进行核心转储。此时父进程使用waitpid函数便可获取到子进程退出时的状态，根据status的第7个比特位便可得知子进程在被终止时是否进行了核心转储。

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>

using namespace std;

int main()
{
    pid_t id = fork();

    if (id == 0)
    {
        //子进程
        int *p = nullptr;
        *p = 1000;

        exit(1);
    }

    //父进程
    int status = 0;
    waitpid(id, &status, 0);

    printf("exit code %d, sigo: %d, core dump flag: %d\n", (status >> 8) & 0xFF, (status >> 7) & 0x7F, (status >> 7) & 0x1);

    return 0;
}

可以看到，所获取的status的第7个比特位为1，即可说明子进程在被终止时进行了核心转储。

因此，core dump标志实际上就是用于表示程序崩溃的时候是否进行了核心转储。

2. 系统调用发送信号

2.1 kill函数

当我们继续运行死循环程序，可以使用kill -信号进程ID的方式向进程发送信号。

实际上kill命令是通过调用kill函数实现的，kill函数可以给指定的进程发送指定的信号，kill函数的函数原型如下：

#include <signal.h>
int kill(pid_t pid, int sig);

kill函数用于向进程ID为pid的进程发送sig信号，如果发送成功返回0，失败则返回-1。

此时我们可以之间模拟实现一个kill命令：

#include <iostream>
#include <string>
#include <unistd.h>
#include <signal.h>
using namespace std;

static void Usage(const string& proc)
{
    cerr << "Usage:\n\t" << proc << " signo pid" << endl;
}

int main(int argc, char *argv[])
{
    if(argc !=3)
    {
        Usage(argv[0]);
        exit(1);
    }

    if(kill(static_cast<pid_t>(atoi(argv[2])), atoi(argv[1])) == 1)
    {
        cerr << " kill: " << strerror(errno) << endl;
    }

    return 0;

}

【注意】
此时要想执行mykill程序时不带路径，就需要我们提前导入环境变量：

2.2 raise函数

raise函数原型：

#include <signal.h>
int raise(int sig);

raise函数用于给当前进程发送信号，发送成功返回0，发送失败则返回非0。例如，下列代码当中用raise函数每隔一秒向自己发送一个2号信号。

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

using namespace std;

int cnt = 0;

void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << " cnt: " << cnt << endl;
}

int main()
{
    signal(2, handler);

    while(true)
    {
        sleep(1);
        cnt++;
        raise(2);
    }
    return 0;
}

运行结果就是该进程每隔一秒收到一个2号信号。

2.3 abort函数

abort函数的函数原型如下：

#include <stdlib.h>
void abort(void);

abort函数使当前进程接收到信号而异常终止。就像exit函数一样,abort函数总是会成功的,所以没有返回值。
例如使用下面的程序，运行5秒后调用abort终止程序。

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

using namespace std;

int cnt = 0;

void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << " cnt: " << cnt << endl;
}


int main()
{
    signal(2, handler);

    while (true)
    {
        sleep(1);
        cnt++;

        if (cnt == 5)
            abort();
    }
    return 0;
}

【注意】
abort函数的作用是异常终止进程，exit函数的作用是正常终止进程，而abort本质是通过向当前进程发送SIGABRT信号而终止进程的，因此使用exit函数终止进程可能会失败，但使用abort函数终止进程总是成功的。

3. 由软件条件产生信号

3.1 SIGPIPE信号

SIGPIPE信号是一种由软件条件产生的信号，当进程在使用管道通信时，如果读端进程将读端关闭后，另一个进程还在不断向管道写入数据，那么此次写端进程就会收到SIGPIPE信号而终止程序。

例如使用下面的一段代码来模拟以上这种情况，创建管道进行父子进程间通信，其中父进程是读端，子进程是写端，但父进程关闭了自己的读端，那么此时子进程在向管道写入数据时就会收到SIGPIPE信号，进而被终止。

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    int fd[2] = {0};

    if (pipe(fd) < 0)
    {
        cerr << "pipe error" << endl;
        exit(1);
    }

    pid_t id = fork();
    if (id == 0)
    {
        //子进程 --- 写端
        close(fd[0]);

        const char *msg = "父进程你好，我是子进程...";

        int count = 5;
        while (count)
        {
            write(fd[1], msg, strlen(msg));
            sleep(1);
            count--;
        }

        close(fd[1]);
        exit(0);
    }

    //父进程 --- 读端
    close(fd[1]);

    close(fd[0]); //父进程关闭自己的写端，导致子进程写入会被操作系统终止

    int status = 0;
    waitpid(id, &status, 0);

    cout << "子进程收到信号：" << (status & 0x7F) << endl;
    return 0;
}

结果子进程收到13号信号，即SIGPIPE信号。

3.2 alarm函数

调用alarm函数可以设定一个闹钟，也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号，该函数的原型如下：

#include <unistd.h>
unsigned alarm(unsigned seconds);

alarm函数的作用就是让操作系统在seconds秒之后给当前进程发送SIGALRM信号，, 该信号的默认处理动作是终止当前进程。

返回值：

若调用alarm函数之前，进程已经设置了闹钟，则返回上一个闹钟剩余的时间，并且本次闹钟会覆盖上次闹钟的设置。
若调用alarm函数之前，没有设置闹钟，则返回0。

以下是一个小例子，统计一个我们的进程1S cnt++ 多少次。

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

using namespace std;

int cnt = 0;

int main()
{
    alarm(1); //设置1s

    while (true)
    {
        cnt++;
        printf("cnt = %d\n", cnt);
    }
    return 0;
}

执行结果如下：

我们发现最终打印的结果是1秒cnt++了98721次，但是真的是只++了这么多次吗？肯定不止，因为这里的打印属于IO操作，相比于CPU的速度简直是天差地别。所以让我们改写一下程序：

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

using namespace std;

int cnt = 0;

void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << " cnt = "<< cnt << endl;
}

int main()
{
    signal(SIGALRM, handler);

    alarm(1); //设置1s

    while (true)
    {
        cnt++;
        //printf("cnt = %d\n", cnt);
    }
    return 0;
}

结果如下：

这才是cnt++执行1s的次数，其中该进程收到的14号信号就是SIGALRM信号。由此也证明了计算机的CPU速度与外设进行IO时的速度相比是非常快的。

4. 由硬件异常产生信号

程序崩溃的本质：
当我们的程序中存在除0、越界或者野指针时引起程序崩溃，其本质就是因为进程收到了来自操作系统的异常信号。那么操作系统为什么知道这些异常的呢？
原因是CPU当中有许多的寄存器，当对两个数进行算术运算时，操作系统先将这两个操作数分别放到两个寄存器当中，然后进行运算并把结果写回寄存器当中。此外，CPU当中还有一组寄存器叫做状态寄存器，它可以用来标记当前指令执行结果的各种状态信息，如有无进位、有无溢出等等。而操作系统是软硬件资源的管理者，在程序运行过程中，若操作系统发现CPU内的某个状态标志位被置位，而这次置位就是因为出现了某种除0错误而导致的，那么此时操作系统就会马上识别到当前是哪个进程导致的该错误，并将所识别到的硬件错误包装成信号发送给目标进程。

用以下代码模拟野指针异常：

#include <iostream>
#include <signal.h>
using namespace std;

int cnt = 0;

void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << endl;
}



int main()
{
    signal(SIGSEGV, handler);

    sleep(1);

    int *p = nullptr;
    *p = 1000;
    while (true);

    return 0;
}

结果该进程收到了11号信号，也就是SIGSEGV信号。

首先我们必须知道的是，当我们要访问一个变量时，一定要先经过页表的映射，将虚拟地址转换成物理地址，然后才能进行相应的访问操作。其中页表属于一种软件映射关系，而实际上在从虚拟地址到物理地址映射的时候还有一个硬件叫做MMU，它是一种负责处理CPU的内存访问请求的计算机硬件，因此映射工作不是由CPU做的，而是由MMU做的，但现在MMU已经集成到CPU当中了。

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

而MMU既然是硬件单元，那么它当然也有相应的状态信息，当我们要访问不属于我们的虚拟地址时，MMU在进行虚拟地址到物理地址的转换时就会出现错误，然后将对应的错误写入到自己的状态信息当中，这时硬件上面的信息也会立马被操作系统识别到，进而将对应进程发送SIGSEGV信号。

三、信号阻塞

1. 信号阻塞即其他相关概念

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

2. 信号在内核中的表示

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

在block位图中，比特位的位置代表某一个信号，其内容表示该信号是否被阻塞。
在pending位图中，比特位的位置代表某一个信号，其内容表示是否收到该信号。
handler表本质上是一个函数指针数组，数组的下标代表一个信号，数组的内容表示该信号递达时的处理动作，包括默认、忽略和自定义。
block、pending和handler这三张表是一一对应的。

【说明】

每个信号都有两个标志位，分别表示阻塞（Block）和未决（Pending），还有一个函数指针表示对信号的处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。如上图所示。
SIGINT信号以及产生，但是正处于阻塞状态，所以暂时不能被递达。虽然它的处理动作是忽略，但是没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除该阻塞。
SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。
【注意】
如果在进程解除对某信号的阻塞之前，这种信号产生过多次：POSIX.1允许系统递送该信号一次或多次。但是Linux是这样实现的:常规信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里。

3. sigset_t

从信号在内核中的示意图来看，每个信号只有一个比特位的未决标志，非0即1，不记录该信号产生了多少次，阻塞标志也是这样表示的。

因此，未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t的定义如下：

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
	unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;

typedef __sigset_t sigset_t;

sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态:

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

其中阻塞信号集也叫做当前进程的信号屏蔽字（Signal Mask），这里的“屏蔽”应该理解为阻塞而不是忽略。

4. 信号集操作函数

sigset_t类型对于每种信号用一个比特位表示“有效”或“无效”状态，至于这个类型内部如何存储这些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所指向的信号集，使其中所有信号的对应比特位清零，表示该信号集不包含任何有效信号。
函数sigfillset初始化set所指向的信号集，使其中所有信号的对应比特位置位，表示该信号集的有效信号包括系统支持的所有信号。
注意，在使用sigset_ t类型的变量之前,一定要调用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。
初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。
前面四个函数都是调用成功返回0，出错返回-1。sigismember是一个布尔函数，用于判断一个信号集的有效信号中是否包含某种信号，若包含则返回1，不包含则返回0，出错返回-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参数的可选值及其含义：

可选值	含义
SIG_BLOCK	set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask = mask 按位或 set
SIG_UNBLOCK	set包含了我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask = mask &~ set
SIG_SETMASK	设置当前信号屏蔽字为set所指向的值，相当于mask = set

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

6. sigpending

sigpending函数的作用是读取当前进程的未决信号集，通过set参数传出。
【函数原型】

int sigpending(sigset_t *set);

【返回值】调用成功返回0，否则返回-1。

下面用刚学的几个函数做个实验。程序如下:

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

using namespace std;

void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号: " << signo << endl;
    // exit(1);
}

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

int main()
{
    cout << "pid = " << getpid() << endl;

    // 3. 屏蔽2号信号
    sigset_t bsig, obsig;
    sigemptyset(&bsig);
    sigemptyset(&obsig);

    // 3.1 添加2号信号到信号屏蔽字中
    sigaddset(&bsig, 2);

    // 2. signal
    signal(sig, handler);

    // 3.2 设置用户集的信号屏蔽字到内核中，让当前进程屏蔽掉2号信号
    sigprocmask(SIG_SETMASK, &bsig, &obsig);

    // 1. 不断获取当前进程的pending信号集
    sigset_t pendings;
    int cnt = 0;
    while (true)
    {
        // 1.1 清空信号集
        sigemptyset(&pendings);
        // 1.2 获取当前进程的pending信号集
        if (sigpending(&pendings) == 0)
        {
            // 1.3 打印当前pending信号集的内容
            showPendings(&pendings);
        }

        sleep(1);
        cnt++;
        if (cnt == 20)
        {
            cout << "解除对所有信号的block..." << endl;
            sigset_t sigs;
            sigemptyset(&sigs);
            sigaddset(&sigs, 2);
            sigprocmask(SIG_UNBLOCK, &sigs, nullptr);
        }
    }
    return 0;
}

该程序的功能是先用上述的函数将2号信号进行屏蔽（阻塞），使用kill命令或组合按键向进程发送2号信号。此时2号信号会一直被阻塞，并一直处于pending（未决）状态。使用sigpending函数获取当前进程的pending信号集进行验证。20秒后，解除对2号信号的屏蔽。

执行结果如下：

第一次发送2号信号，我们可以发现signal函数没有收到2号信号，而pending表中存在2号信号，0秒后，解除对2号信号的屏蔽，signal函数就接收到了2号信号。

这里我们可以发现，在解除2号信号之后，2号信号的自定义动作的打印是在打印全为0的pending表之前执行的。这是因为如果调用sigprocmask解除对当前若干个未决信号的阻塞，则在sigprocmask函数返回前，至少将其中一个信号递达。

四、信号捕捉

在认识信号捕捉之前，首先得认识内核和用户之间的连续和区别。

1. 内核态和用户态

用户态和内核态是操作系统的两种运行状态。

内核态：处于内核态的 CPU 可以访问任意的数据，包括外围设备，比如网卡、硬盘等，处于内核态的 CPU 可以从一个程序切换到另外一个程序，并且占用 CPU 不会发生抢占情况，一般处于特权级 0 的状态我们称之为内核态。
用户态：处于用户态的 CPU 只能受限的访问内存，并且不允许访问外围设备，用户态下的 CPU 不允许独占，也就是说 CPU 能够被其他程序获取。

进程收到信号之后，并不是立即处理信号，而是在从内核态切换回用户态的时候，进行对信号的检查与处理。

操作系统在内核态与用户态之间切换的情况：

从用户态切换为内核态通常有如下几种情况：

进行系统调用时
当前进程的时间片结束，导致进程切换
产生异常、中断、陷阱等

从内核态切换为用户态有如下几种情况：

系统调用返回时
进程切换完毕
异常、中断、陷阱等处理完毕

此外，由用户态切换为内核态我们称之为陷入内核。每当我们需要陷入内核的时，本质上是因为我们需要执行操作系统的代码，比如系统调用函数是由操作系统实现的，我们要进行系统调用就必须先由用户态切换为内核态。

2. 内核空间和用户空间

我们都知道每一个进程都有属于自己的进程地址空间，该空间其实是有内核空间和用户空间组成的。其中用户实现的代码和数据位于用户空间，通过用户级页表与物理内存之间建立映射关系；而内核空间是只操作系统的代码和数据，通过内核级页表与物理内存之间建立映射关系。

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。因此，在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，由所有进程所共同拥有。只是唯一区别在于该进程是否有权利去访问内核空间。

3. 内核实现信号捕捉

信号捕捉示意图：

当执行主控制流程的时候，可能因为某些情况而陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending的检查。在查看pending位图时，如果发现有未决信号，并且该信号没有被阻塞，那么此时就需要该信号进行处理。如果待处理信号的处理动作是默认或者忽略，则执行该信号的处理动作后清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，从主控制流程中上次被中断的地方继续向下执行即可。
但如果待处理信号是自定义捕捉的，即该信号的处理动作是由用户提供的，那么处理该信号时就需要先返回用户态执行对应的自定义处理动作，执行完后再通过特殊的系统调用sigreturn再次陷入内核并清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，继续执行主控制流程的代码。

4. sigaction函数

捕捉信号除了用前面用过的signal函数之外，我们还可以使用sigaction函数对信号进行捕捉。
【函数原型】

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

sigaction函数可以读取和修改与指定信号相关联的处理动作，该函数调用成功返回0，出错返回-1。

【参数说明】

signum代表指定信号的编号。
若act指针非空，则根据act修改该信号的处理动作。
若oldact指针非空，则通过oldact传出该信号原来的处理动作。
参数act和oldact都是结构体指针变量，该结构体的定义如下：

struct sigaction
  {
    /* Signal handler.  */
#ifdef __USE_POSIX199309
    union
      {
	/* Used if SA_SIGINFO is not set.  */
	__sighandler_t sa_handler;
	/* Used if SA_SIGINFO is set.  */
	void (*sa_sigaction) (int, siginfo_t *, void *);
      }
    __sigaction_handler;
# define sa_handler	__sigaction_handler.sa_handler
# define sa_sigaction	__sigaction_handler.sa_sigaction
#else
    __sighandler_t sa_handler;
#endif

    /* Additional set of signals to be blocked.  */
    __sigset_t sa_mask;

    /* Special flags.  */
    int sa_flags;

    /* Restore handler.  */
    void (*sa_restorer) (void);
  };

结构体的第一个成员sa_handler：

将sa_handler赋值为常数SIG_IGN传给sigaction函数，表示忽略信号。
将sa_handler赋值为常数SIG_DFL传给sigaction函数，表示执行系统默认动作。
将sa_handler赋值为一个函数指针，表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数。

注意：所注册的信号处理函数的返回值为void，参数为int，通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。显然这是一个回调函数，不是被main函数调用，而是被系统所调用。

结构体的第二个成员sa_sigaction：

sa_sigaction是实时信号的处理函数。

结构体的第三个成员sa_mask：

如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时，自动恢复原来的信号屏蔽字。

例如，下面我们用sigaction函数对2号信号进行了捕捉，将2号信号的处理动作改为了自定义的打印动作，并在执行一次自定义动作后将2号信号的处理动作恢复为原来默认的处理动作。

struct sigaction act, oact;
void handler(int signo)
{
    printf("get a signal:%d\n", signo);
    sigaction(2, &oact, NULL);
}
int main()
{
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));

    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);

    sigaction(2, &act, &oact);
    while (1)
    {
        cout << "main running" << endl;
        sleep(1);
    }
    return 0;
}

由运行结果可以发现，第一次向进程发送2号信号，执行的是自定义动作，然后再次发送2号信号，则执行默认动作。

五、可重入函数

要理解可重入函数，可以通过链表的插入过程来进行理解。

如图，main函数调用insert向链表中插入一个节点node1，但是代表执行的1的位置时，该进程收到了一个信号，该信号的处理动作是再向链表插入一个节点node2，处理完该信号后又返回4的位置继续执行插入node1的动作。现在则发生了下面的情况：

我们可以发现最终node1和node2指向了同一个节点，但是只有node1真正的插入了链表，而node2却丢失了，造成内存泄漏。

在该例中，main函数和sighandler函数使用不同的堆栈空间，它们之间不存在调用与被调用的关系，是两个独立的控制流程，因此insert函数被不同的控制流调用，造成了第一次调用还没有返回时就再次调用了该函数，这种现象称之为可重入现象。

然而insert函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数我们称之为不可重入函数，反之，如果一个函数只访问自己的局部变量或参数，则称之为可重入（Reentrant）函数。

如果一个函数符合以下条件之一则是不可重入的:

调用了malloc或free，因为malloc也是用全局链表来管理堆的。
调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。

六、重识 volatile 关键字

volatile是C语言的一个关键字，该关键字的作用是保持内存的可见性。告知编译器，被该关键字修饰的变量，不允许被优化，对该变量
的任何操作，都必须在真实的内存中进行操作。
例如，下面的代码实现了对2号信号的捕捉，当收到2号信号时，将全局变量flag由0变为1，观察程序是否能正常退出。

首先不使用volatile关键字修饰flags:


#include <stdio.h>
#include <signal.h>

// 保持内存的可见性
int flags = 0;

void handler(int signo)
{
    flags = 1;
    printf("更改flags: 0->1\n");
}

int main()
{
    signal(2, handler);

    while (!flags);
    printf("进程是正常退出的!\n");

    return 0;
}

执行结果：

该程序的运行过程好像都在我们的意料之中，但实际并非如此。代码中的main函数和handler函数是两个独立的执行流，而while循环是在main函数当中的，在编译器编译时只能检测到在main函数中对flag变量的使用。
此时编译器检测到在main函数中并没有对flag变量做修改操作，在编译器优化级别较高的时候，就有可能将flag设置进寄存器里面。

此时main函数在检测flag时只检测寄存器里面的值，而handler执行流只是将内存中flag的值置为1了，那么此时就算进程收到2号信号也不会跳出死循环。

在编译代码时携带-03选项使得编译器的优化级别最高，此时再运行该代码。

此时再向进程发生2号信号，该进程也不会终止。

若在flag变量前面加上volatile修饰，则进程就可以进程退出了。

七、SIGCHLD信号

在前面进程的学习过程中，我们知道了wait和waitpid函数清理僵尸进程，父进程可以阻塞等待子进程结束，也可以非阻塞地查询是否有子进
程结束等待清理(也就是轮询的方式)。但是采用第一种方式，父进程阻塞了就不能处理自己的工作了；采用第二种方式，父进程在处理自己的工作的同时还要记得时不时地轮询一下，程序实现复杂。

其实，子进程在终止时会给父进程发SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理函数，这样父进程只需专心处理自己的工作，不必关心子进程了，子进程在终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可。

例如编写一个程序完成以下功能：

父进程调用fork函数创建出子进程，子进程调用exit(2)终止，父进程自定义SIGCHLD信号的处理函数，在其中调用wait函数获得子进程的退出状态并打印。


#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>

void handler(int sig)
{
    pid_t id;
    while ((id = waitpid(-1, NULL, WNOHANG)) > 0)
    {
        printf("wait child success: %d\n", id);
    }
    printf("child is quit! %d\n", getpid());
}
int main()
{
    signal(SIGCHLD, handler);
    pid_t cid;
    if ((cid = fork()) == 0)
    { // child
        printf("child : %d\n", getpid());
        sleep(3);
        exit(1);
    }
    while (1)
    {
        printf("father proc is doing some thing!\n");
        sleep(1);
    }
    return 0;
}

事实上，由于UNIX 的历史原因，要想不产生僵尸进程还有另外一种办法:父进程调用signal将SIGCHLD的处理动作置为SIG_IGN，这样fork出来的子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程。系统默认的忽略动作和用户用signal函数自定义的忽略通常是没有区别的。但这是一个特例，此方法对于Linux可用，但不保证在其它UNIX系统上都可用。

测试代码如下：

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <signal.h>
#include <cassert>

using namespace std;

void FreeChld(int signo)
{
    assert(signo == SIGCHLD);
    while (true)
    {
        // waitpid 什么时候调用失败呢？如果你已经没有子进程了
        // -1: 等待任意一个子进程
        pid_t id = waitpid(-1, nullptr, WNOHANG); // bug?？
        if (id > 0)
        {
            cout << "父进程等待成功, chld pid: " << id << endl;
        }
        else if(id == 0)
        {
            //还有子进程，但是现在没有退出
            cout << "还有子进程，但是现在没有退出, 父进程要去忙自己的事情了" << endl;
            break;
        }
        else
        {
            cout << "父进程等待所有子进程结束" << endl;
            break;
        }
    }
}

int main()
{
    // signal(SIGCHLD, FreeChld);
    // 子进程退出的时候，默认的信号处理就是忽略吗？
    // 调用signal/sigaction SIG_IGN, 意义在哪里呢？
    // SIG_IGN手动设置，让子进程退出，不要给父进程发送信号了，并且自动释放
    signal(SIGCHLD, SIG_IGN);
    for (int i = 0; i < 3; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            //子进程
            int cnt = 3;

            // if (i < 7)
            //     cnt = 5;
            // else
            //     cnt = 20;
            while (cnt)
            {
                cout << "我是子进程, pid: " << getpid() << " 当前的cnt: " << cnt-- << endl;
                sleep(1);
            }
            cout << "子进程退出，进入僵尸状态" << endl;
            exit(0);
        }
        // sleep(1);
    }

    while (true)
    {
        cout << "我是父进程，我正在运行: " << getpid() << endl;
        sleep(1);
    }
    // //父进程,都是要自己主动等待
    // if(waitpid(id, nullptr, 0) > 0)
    // {
    //     cout << "父进程等待子进程成功" << endl;
    // }
    return 0;
}

运行结果如下：

这样，父进程调用signal将SIGCHLD的处理动作置为SIG_IGN，fork出来的子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程，父进程也可以做自己的工作并且不用管子进程，提高了程序的运行效率。

求知.

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Linux学习】进程信号

本文是博主对学习完Linux系统中的进程信号部分的知识点总结，在阅读完该文章之后，我们会对进程信号有更深层次的理解。学习完本文后我们可以掌握以下内容：Linux信号的基本概念、掌握信号产生的一般方式、理解信号递达和阻塞的概念和原理、掌握信号捕捉的一般方式、重新了解可重入函数的概念、了解竞态条件的情景和处理方式、了解SIGCHLD信号，重新编写信号处理函数的一般处理机制。
复制链接

扫一扫