文章目录
- 4 信号的捕捉处理
- 4.1 内核如何实现信号的捕捉
- 4.2 sigaction
- 4.2.1 使用这个函数对2号信号进行捕捉
- 4.2.2 pending位图什么时候由1变0
- 4.2.3 不允许信号重复发送
- 5. 其他
- 5.1 可重入函数
- 5.2 volatile
- 5.3 SIGCHLD信号
- 5.4 信号生命周期
4 信号的捕捉处理
4.1 内核如何实现信号的捕捉
当我们的进程从内核态返回到用户态的时候，进行信号的检测和处理
内核态：允许进程访问OS的代码和数据
用户态：只能访问进程自己的代码和数据
如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。举例如下: 用户程序写了SIGQUIT信号的处理函数sighandler。 当前正在执行main函数,这时**发生中断或异常（也可能是系统调用）**切换到内核态。 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函 数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是 两个独立的控制流程。 sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。
4.2 sigaction
#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);
struct sigaction {
void (*sa_handler)(int); // 自定义信号处理函数
sigset_t sa_mask; // 设置block表
// ...
};
- sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非 空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体
- 将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。
4.2.1 使用这个函数对2号信号进行捕捉
void MyHandler(int sigNo)
{
cout << "Catch a signal, signal number:" << sigNo << endl;
}
int main()
{
// 变量定义和初始化
struct sigaction act, oact;
memset(&act, 0, sizeof(act));
memset(&oact, 0, sizeof(act));
// 指定一个自定义函数
act.sa_handler = MyHandler;
// 调用sigaction函数
sigaction(2, &act, &oact);
while(true) {
cout << "Process running!" << endl;
sleep(1);
}
return 0;
}
4.2.2 pending位图什么时候由1变0
添加如下的代码
void PrintPending()
{
sigset_t pending;
sigpending(&pending);
cout << "Pending: ";
for(size_t i = 31;i>=1;--i) {
if(sigismember(&pending, i)) cout << "1";
else cout << "0";
}
cout << endl;
}
void MyHandler(int sigNo)
{
PrintPending();
cout << "Catch a signal, signal number:" << sigNo << endl;
}
可见，在执行信号捕捉方法之前，先清0，再调用
4.2.3 不允许信号重复发送
当某个信号的处理函数被调用时, 内核自动将当前信号加入进程的信号屏蔽字 ,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止。
验证1，一个信号被捕捉处理过程中，该信号会被屏蔽。
// 修改MyHandler()方法
void MyHandler(int sigNo)
{
cout << "Catch a signal, signal number:" << sigNo << endl;
while(true) {
PrintPending();
sleep(1);
}
}
如果**在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,**则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。
验证2，希望在捕捉处理信号过程中，同时屏蔽一些其他的信号
void MyHandler(int sigNo)
{
cout << "Catch a signal, signal number:" << sigNo << endl;
while(true) {
PrintPending();
sleep(1);
}
}
int main()
{
// 变量定义和初始化
struct sigaction act, oact;
memset(&act, 0, sizeof(act));
memset(&oact, 0, sizeof(act));
// 指定一个自定义函数
act.sa_handler = MyHandler;
// 在屏蔽2号信号的同时屏蔽1,3,4信号
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask, 1);
sigaddset(&act.sa_mask, 3);
sigaddset(&act.sa_mask, 4);
// 调用sigaction函数
sigaction(2, &act, &oact);
while(true) {
cout << "Process running! pid: " << getpid() << endl;
sleep(1);
}
return 0;
}
5. 其他
5.1 可重入函数
main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换到sighandler函数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后向链表中插入两个节点,而最后只有一个节点真正插入链表中了
像上面这样,insert函数被不同的执行流调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant) 函数。
如果一个函数符合以下条件之一则是不可重入的:
- 调用了malloc或free,因为malloc也是用全局链表来管理堆的。
- 调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。
5.2 volatile
看下面的代码
int flag = 0;
void myHandler(int sigNo)
{
cout << "Catch a signal, signal number:" << sigNo << endl;
flag = 1;
}
int main()
{
signal(2, myHandler);
while(!flag);
cout << "Process normal quit" << endl;
return 0;
}
问题：在优化条件下，flag变量可能直接优化到cpu内的寄存器中。而myHandler执行流修改的是内存的值
修改makefile
outSignal : mySignal.cc
g++ -o $@ $^ -O1
.PHONY : clean
clean:
rm -rf outSignal
此时，进程就退不出来了。volatile的作用就是为了防止CPU进行过度的优化
在flag变量前加上volatile后，即便g++ 设置了-O3的最高级别的优化，进程也能正常退出
5.3 SIGCHLD信号
验证：子进程在终止时会给父进程发SIGCHLD信号
void MyHandler(int sigNo)
{
cout << "Process " << getpid() << " catch a signal, signal number:" << sigNo << endl;
}
int main()
{
signal(SIGCHLD, MyHandler);
pid_t n = fork();
if(n == 0) {
// child
int cnt = 3;
while(cnt--) {
cout << "I am child process, pid: " << getpid() << " ppid: " << getppid() << endl;
sleep(1);
}
cout << "Child quit!" << endl;
exit(0);
}
// father
while(true) {
cout << "I am father process, pid: " << getpid() << endl;
sleep(1);
}
return 0;
}
代码：基于信号捕捉等待子进程
// 仅修改MyHandler()
void MyHandler(int sigNo)
{
sleep(3); // 方便观察，让子进程僵尸一会
pid_t rid = waitpid(-1, nullptr, 0);
cout << "Process " << getpid() << " catch a signal, signal number:"
<< sigNo << " child quit pid: "<< rid << endl;
}
问题：如果有多个子进程同时退出呢？这多个子进程都会向父进程发送SIGCHLD信号，当父进程处理该信号时，会阻塞屏蔽掉该信号，这会导致其它子进程发送的信号不被处理。
此时就需要修改MyHandler()的写法
void MyHandler(int sigNo)
{
sleep(3); // 方便观察，让子进程僵尸一会
pid_t rid = 0;
while(rid = waitpid(-1, nullptr, WNOHANG) > 0) { // 设置WNOHANG的目的是当没有进程处于僵尸状态时，rid会返回0，此时就不会进循环
cout << "Process " << getpid() << " catch a signal, signal number:"
<< sigNo << " child quit pid: "<< rid << endl;
}
}
int main()
{
signal(SIGCHLD, MyHandler);
for(int i = 0; i < 10; ++i) {
pid_t n = fork();
if(n == 0) {
// child
int cnt = 3;
while(cnt--) {
cout << "I am child process, pid: " << getpid() << " ppid: " << getppid() << endl;
sleep(1);
}
cout << "Child quit!" << endl;
exit(0);
}
}
// father
while(true) {
cout << "I am father process, pid: " << getpid() << endl;
sleep(1);
}
return 0;
}
子进程在终止时会给父进程发SIGCHLD信号**,该信号的默认处理动作是忽略,**父进程可以自 定义SIGCHLD信号的处理函数,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程终止时会通知父进程,父进程在信号处理函数中调用wait清理子进程即可。
事实上,由于UNIX 的历史原因,要想不产生僵尸进程还有另外一种办法:父进程调用将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不 会产生僵尸进程,也不会通知父进程。但这是一个特例。此方法对于Linux可用,但不保证在其它UNIX系统上都可用。
int main()
{
signal(SIGCHLD, SIG_IGN);
for(int i = 0; i < 10; ++i) {
pid_t n = fork();
if(n == 0) {
// child
int cnt = 3;
while(cnt--) {
cout << "I am child process, pid: " << getpid() << " ppid: " << getppid() << endl;
sleep(3);
}
cout << "Child quit!" << endl;
exit(0);
}
}
// father
while(true) {
cout << "I am father process, pid: " << getpid() << endl;
sleep(1);
}
return 0;
}
5.4 信号生命周期
