【Linux】信号：信号保存和处理

🔥个人主页：Quitecoder

🔥专栏：linux笔记仓

01.阻塞信号

• 实际执行信号的处理动作称为信号递达：每个信号都有一个默认行为，例如终止进程、忽略信号或生成 Core Dump，进程可以为信号注册自定义处理函数
• 信号从产生到递达之间的状态,称为信号未决(Pending)
• 进程可以选择阻塞 (Block )某个信号：被阻塞的信号产生时将一直保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作
• 忽略信号：信号递达后，进程选择不采取任何行动
• 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

如果一个信号阻塞了，和它有没有未决没有关系

signal(2,handler);
signal(2,SIG_IGN);
signal(2,SIG_DFL);

三种处理方式：自定义捕捉，忽略信号，默认行为

pending位图表（32位），比特位的位置：代表信号编号，比特位的内容：代表信号是否收到
handler信号处理表：一个数组，其中每个条目对应一个信号编号，并记录该信号的处理方式
block位图表：与pending类型一样，比特位位置代表信号编号，内容代表信号是否阻塞

每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作

SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

sighandler_t就是函数指针类型，handler表就是一个函数指针数组

每一个信号的编号，相当于该数组的下标

signal(2,handler)就是找到2号信号函数指针数组的索引，传入我们自己写的handler函数的地址

信号集

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

---

1. sigset_t 的定义
   sigset_t 是一个不透明的数据类型，通常定义为一个位掩码。具体实现可能因操作系统而异，但它的本质是一个整数或结构体，用于存储信号的状态。

在 Linux 中，sigset_t 通常定义如下：

typedef struct {unsigned long sig[NSIG / (8 * sizeof(unsigned long))];
} sigset_t;

其中，NSIG 是系统中信号的总数。

---

sigset_t 主要用于以下系统调用：
• 阻塞信号：sigprocmask() 使用 sigset_t 来设置或修改进程的信号掩码。
• 检查挂起信号：sigpending() 使用 sigset_t 来获取当前挂起的信号集。
• 设置信号处理函数：sigaction() 使用 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);
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

---

sigprocmask

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

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

how取值

sigpending

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

获取当前进程的未决信号集,通过set参数传出，pending表的内容是由内核根据信号的发送和阻塞状态自动管理的，因此不需要提供直接修改挂起信号表的系统调用，这里set为输出型参数

sigpending() 会将内核中保存的挂起信号数据复制到用户提供的 sigset_t 变量中

---

示例
以下是一个使用 sigset_t 的示例，展示了如何阻塞和解除阻塞信号：

#include <unistd.h>
#include <iostream>
#include <signal.h>using namespace std;// 信号处理函数
void handler(int signum) {cout << "Caught SIGINT (signal number: " << signum << ")" << endl;
}int main() {// 注册信号处理函数signal(SIGINT, handler);// 保存旧的信号掩码sigset_t oldset;// 阻塞 SIGINT 信号sigset_t mask;sigemptyset(&mask);sigaddset(&mask, SIGINT);if (sigprocmask(SIG_BLOCK, &mask, &oldset) == -1) {perror("sigprocmask");return 1;}cout << "SIGINT is blocked. Press Ctrl+C within 5 seconds to send SIGINT." << endl;sleep(5);// 检查挂起的信号sigset_t pending;if (sigpending(&pending) == -1) {perror("sigpending");return 1;}if (sigismember(&pending, SIGINT)) {cout << "SIGINT is pending." << endl;} else {cout << "SIGINT is not pending." << endl;}// 恢复旧的信号掩码if (sigprocmask(SIG_SETMASK, &oldset, NULL) == -1) {perror("sigprocmask");return 1;}cout << "SIGINT is unblocked. Pending signal will be handled." << endl;return 0;
}

这里来处理二号信号

oldset 是一个 sigset_t 类型的指针，用于保存当前的信号掩码，如果需要恢复之前的信号掩码，可以将 oldset 传递给 sigprocmask()

pending位图对应的信号清零是在递达之前清零的

02.捕捉信号

信号可能不会立即被处理，在合适的时候进行处理：进程从内核态返回到用户态的时候进行处理

操作系统不能直接转过去执行用户提供的handler方法，必须使用用户身份来执行handler

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

内核态是 CPU 的一种运行模式，在这种模式下：
• 代码可以执行所有特权指令（如直接操作硬件、修改内存管理单元等）。
• 可以访问整个系统的内存空间（包括用户空间和内核空间）。
• 操作系统内核运行在内核态，负责管理硬件资源、进程调度、内存管理等核心功能。

特性	内核态	用户态
权限	最高权限，可以执行所有指令	受限权限，只能执行非特权指令
内存访问	可以访问整个系统的内存空间	只能访问用户空间的内存
硬件访问	可以直接操作硬件	不能直接操作硬件，必须通过系统调用
运行代码	操作系统内核代码	用户程序代码
安全性	不受限制，可能影响系统稳定性	受限制，不会直接破坏系统

用户程序通常运行在用户态，当需要执行特权操作时，必须通过 系统调用（System Call） 切换到内核态。

为了确保系统的安全性和稳定性，操作系统通过以下方式隔离内核态和用户态：
• 特权级别：CPU 提供了不同的特权级别（如 x86 架构的 Ring 0 和 Ring 3），内核态运行在最高特权级别（Ring 0），用户态运行在最低特权级别（Ring 3）。
• 内存保护：通过内存管理单元（MMU）隔离用户空间和内核空间，防止用户程序访问内核内存。
• 系统调用接口：用户程序必须通过系统调用接口访问内核功能，不能直接执行特权指令。

0-3GB是给用户用的，有用户级页表，3-4有内核级页表，核心工作时将内核地址空间和操作系统之间进行映射的

意味着操作系统本身就在我们的地址空间中

进程中，用户级页表有很多份，但是内核级页表只有一份，我们通过访问3-4的地址空间可以找到OS所有代码和数据

我们访问操作系统，其实还是在我们的地址空间中进行的，和我们访问库函数没区别

用户访问3-4地址空间，只能通过系统调用

键盘输入数据会向cpu发送硬件中断，内存加载时会加载函数指针数组，有的会被预先加载，比如有读磁盘的，读网卡的，每一种设备有自己的中断号，终端号就是该数组的数组下标。开机的时候，操作系统先把这张表加载到内存

cpu执行的代码就是OS的代码，把数据从外设读到内存，键盘有数据会通过硬件中断告诉cpu，cpu得到中断号来执行操作系统方法

我们学习的信号就是模拟中断实现的

操作系统本质就是一个死循环+时钟中断 不断调度系统的任务的

sigaction

前面我们用signal进行捕捉

#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结构体

struct sigaction {void (*sa_handler)(int);         // 信号处理函数void (*sa_sigaction)(int, siginfo_t *, void *); // 高级信号处理函数sigset_t sa_mask;                // 阻塞的信号集int sa_flags;                    // 标志位void (*sa_restorer)(void);       // 未使用
};

sigaction() 的使用步骤
（1）定义信号处理函数
编写一个函数来处理信号，例如：

void handler(int signum) {printf("Caught signal %d\n", signum);
}

（2）设置 struct sigaction
初始化 struct sigaction 结构体，指定信号处理函数和其他行为：

struct sigaction sa;
sa.sa_handler = handler;         // 指定信号处理函数
sigemptyset(&sa.sa_mask);        // 清空阻塞信号集
sa.sa_flags = 0;                 // 无特殊标志

（3）调用 sigaction()
调用 sigaction() 设置信号处理行为：

if (sigaction(SIGINT, &sa, NULL) == -1) {perror("sigaction");return 1;
}

#include <stdio.h>
#include <signal.h>
#include <unistd.h>// 信号处理函数
void handler(int signum) {printf("Caught signal %d\n", signum);
}int main() {// 设置信号处理行为struct sigaction sa;sa.sa_handler = handler;         // 指定信号处理函数sigemptyset(&sa.sa_mask);        // 清空阻塞信号集sa.sa_flags = 0;                 // 无特殊标志if (sigaction(SIGINT, &sa, NULL) == -1) {perror("sigaction");return 1;}printf("Press Ctrl+C to send SIGINT.\n");while (1) {sleep(1);}return 0;
}

如果当前正在对2号信号进行处理。默认2号信号会被自动屏蔽，对2号信号处理完成的时候，会自动解除对二号信号的屏蔽

可重入函数

可重入函数是指在执行过程中可以被中断，并且在中断后再次调用时仍能正确执行的函数

main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的 时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换 到sighandler函数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的 两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续 往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后 向链表中插入两个节点,而最后只有一个节点真正插入链表中了。

像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant) 函数。想一下,为什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?

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

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

volatile

#include <stdio.h>
#include <signal.h>
int flag = 0;
void handler(int sig)
{printf("chage flag 0 to 1\n");flag = 1;
}
int main()
{signal(2, handler);while(!flag);printf("process quit normal\n");return 0;
}

标准情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ， while 条件不满足,退出循环，进程退出

^Cchage flag 0 to 1
^Cchage flag 0 to 1
^Cchage flag 0 to 1

优化情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ，但是 while 条件依旧满足,进程继续运行！但是很明显flag肯定已经被修改了，但是为何循环依旧执行？很明显， while 循环检查的flag，并不是内存中最新的flag，这就存在了数据二异性的问题。 while 检测的flag其实已经因为优化，被放在了CPU寄存器当中。如何解决呢？很明显需要 volatile

volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作

SIGCHLD

进程一章讲过用wait和waitpid函数清理僵尸进程,父进程可以阻塞等待子进程结束,也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式,父进程阻塞了就不 能处理自己的工作了;采用第二种方式,父进程在处理自己的工作的同时还要记得时不时地轮询一 下,程序实现复杂。其实,子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自定义SIGCHLD信号的处理函数,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程 终止时会通知父进程,父进程在信号处理函数中调用wait清理子进程即可

#include <stdio.h>
#include <stdlib.h>
#include <signal.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){ // childprintf("child : %d\n", getpid());sleep(3);exit(1);}while (1){printf("father proc is doing some thing!\n");sleep(1);}return 0;
}