当前位置：首页 > article >正文

信号保存和信号处理

article 2024/11/15 7:17:26

信号保存中重要的概念

内核中信号的保存

对sigset_t操作的函数

对block，pendding，handler三张表的操作

sigpromask

编辑

sigpending

是否有sighandler函数呢？

案例

信号处理

操作系统是如何运行的？

硬件中断

时钟中断

软中断

死循环

缺⻚中断？内存碎⽚处理？除零野指针错误？

理解用户态和内核态

信号的自定义捕捉

sigaction

验证阻塞信号

处理完解除对信号的阻塞

验证在处理前将pending表清零

验证sa_mask的作用

可重入函数

案例

volatile

SIGCHLD信号

waitpid补充

验证子进程退出会给父进程发送SIGCHLD信号

基于信号对子进程回收

问题1：

解决方法循环回收

问题2：

信号保存中重要的概念

信号捕捉的三种方式：1.默认 SIG_DFL default

2.忽略 SIG_ING ingore

3.自定义

信号递达：实际执行信号的处理动作

信号未决：信号从产生到递达的状态

信号阻塞：进程可以阻塞某个信号 -->阻塞/屏蔽特定信号，信号产生了，一定把信号pendding(保存），并且信号永远不递达，除非解除阻塞。

os信号的保存都与以上的三个概念有关

阻塞 vs 忽略

阻塞发生在为信号递达之前

忽略发生在信号递达

内核中信号的保存

内核数据结构示意图

pending:信号未决

block: 信号阻塞

handler:信号递达

进程维护了以上的结构，所以进程是可以识别信号的。

以后对进程信号的操作都是为绕着这三张表展开的。

内核中的相应的数据结构

sigset_t 是信号集，也是信号屏蔽字（signal mask）（有block，pending）

类似umask

对sigset_t操作的函数

对block，pendding，handler三张表的操作

sigpromask

读取/修改进程屏蔽字 block表

set:进程中的block表修改基于set

oldset:修改前block表的模样

how：以何种方式修改mask（block表）

1. SIG_BLOCK: mask = mask | set 新增

2.SIG_UNBLOCK : mask = mask & ~set 去除指定信号

3.SIG_SETMASK: mask = set 覆盖

sigpending

通过该函数可以知道pending表的情况

但为什么不设置一个输入型参数，修改pending表呢？

因为信号的产生都是在修改pending表

是否有sighandler函数呢？

答案：没有

那么如何修改handler表呢？

signal就一直在修改啊

是否有恍然大悟的感觉啊。

案例

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>
#include <wait.h>
#include <vector>
void PrintBlock(const sigset_t &block)
{
    std::cout<<"block"<<"["<<getpid()<<"]: ";
    for (int i = 31; i > 0; i--)
    {

        if (sigismember(&block, i))
        {
            std::cout << 1;
        }
        else
        {
            std::cout << 0;
        }
    }
    std::cout << std::endl;
}

void handler(int signo)
{
    std::cout <<"signo:"<<signo<<" 信号递达"<<std::endl;
    exit(0);
}
int main()
{
    signal(2,handler);
    sigset_t block, oldblock;

    sigemptyset(&block);
    // 将二号新号加入
    sigaddset(&block, 2);
    //阻塞二号信号
    int ret = sigprocmask(SIG_SETMASK, &block, &oldblock);
    if (ret < 0)
    {
        perror("sigpromask");
        exit(1);
    }
    int cnt = 0;
    while (true)
    {
        PrintBlock(block);
        sleep(3);
        if(cnt==5)
        {
            PrintBlock(oldblock);
            //取消对二号信号的阻塞
            sigprocmask(SIG_SETMASK, &oldblock, nullptr);
            
        }
        cnt++;
    }
    return 0;
}

执行结果

一开始block表中二号信号被阻塞，即使收到了二号信号也不能处理，当修改block表二号没被阻塞时，在执行二号信号相应的处理方法。

信号处理

信号没被处理，被保存起来---->合适的时候

那么什么是合适的时候？

进程从用户态切换会用户态时，检测额pending && block，决定是否用handler表处理信号。

os的运行状态：

1.用户态 ---> 执行用户写的代码

2.内核态 -->执行内核代码

信号自定义捕捉的流程

操作系统是如何运行的？

硬件中断

硬件中断的处理流程

中断向量表在os启动时就填充好了。

时钟中断

进程是由操作系统调度的，那么操作系统谁有谁调度的呢？

有个设备时钟源定期向cpu发送中断，cpu处理中断，执行中断处理历程，而查表查到的终端服务是进程调度。

这样操作系统不就能自主调度了吗

时钟源是外设，将中断传给cpu效率有点低，现在的时钟源都是继承在cpu中。

主频就是控制CPU工作的时钟信号的频率

主频越快，相应单位时间内操作系统执行的中断服务越多，进程调度越频繁，os的性能越高。

进程调度不一定切换进程

软中断

是否能不通过外设来产生中断呢？

可以，比如os支持系统调用，cpu设计了汇编指令（int 0x80 或 syscall）,让cpu在内部触发中断逻辑，

这样就可已在软件中触发中断-->再根据中断号，查系统调用表，执行相应的系统调用

系统调用号的本质就是数组下标

死循环

无论是软中断还是硬件中断

os需要什么方法直接，向中断向量表中添加就可以了：os的本质就是一个死循环

void main(void) /* 这⾥确实是void，并没错。 */
{ /* 在startup 程序(head.s)中就是这样假设的。 */
...
/*
* 注意!! 对于任何其它的任务，'pause()'将意味着我们必须等待收到⼀个信号才会返
* 回就绪运⾏态，但任务0（task0）是唯⼀的意外情况（参⻅'schedule()'），因为任
* 务0 在任何空闲时间⾥都会被激活（当没有其它任务在运⾏时），
* 因此对于任务0'pause()'仅意味着我们返回来查看是否有其它任务可以运⾏，如果没
* 有的话我们就回到这⾥，⼀直循环执⾏'pause()'。
*/
for (;;)
pause();
} // end main

---------------------------------------------------------------------------------------------------------------------------------

用户怎么把中断号给os？寄存器（如eax）

os怎么把返回值返回给用户？也是寄存器

用户和内核之间传递信息用的是寄存器。

系统调用-->是通过软中断完成的

中断号-->系统调用号写入寄存器eax-->软中断-->查表--->执行相应的方法-->将返回值写入寄存器返回给用户

既然执行系统调用需要触发软中断，那我们使用系统调用函数值没有用 int 0x80 或 syscall？

因为linux提供的系统调用接口，不是C语言函数，而是系统调用号 + 约定的传递参数，用于内核和用户间传递信息的系统调用号和返回值的寄存器 + syscall 或 int 0x80

也就是说GNU glibc 把真正的系统调用封装--->C语言封装版的系统调用

OS是躺在中断处理历程上的代码块。

缺⻚中断？内存碎⽚处理？除零野指针错误？

这些错误都是通过软中断来处理的。

软中断有： 1.陷阱（int 0x80 或 syscall）

2.异常

CPU内部的软中断，⽐如int 0x80或者syscall，我们叫做陷阱

•

CPU内部的软中断，⽐如除零/野指针等，我们叫做异常。（所以，能理解“缺⻚异常”

为什么这么叫了吗？）

理解用户态和内核态

内核页表：整个系统只有一张

用户页表：每个进程都有一张

对于任何进程，不管如何调度，任何进程都只能找到一个os

为什么只有一张内核页表？

因为用户最关心的是系统调用。

用户关心系统调用的地址吗？

不关心，只需要知道系统调用号就可以了。

系统调用是在进程的地址空间中发起的，但其执行是在内核地址空间中完成的。

1.调用任何函数（库中）都是在我们自己进程中的地址空间中进行的

操作系统无论怎么切换进程，进程都只能找到一个操作系统

2.os调用方法的执行是在内核地址空间中执行的

不管是通过哪个进程的地址空间进入内核，都是通过软中断进行操作的。

⽤⼾态就是执⾏⽤⼾[0,3]GB时所处的状态

•

内核态就是执⾏内核[3,4]GB时所处的状态

如何区分内核态还是用户态？

cpu中有cs段寄存器

用户如何进入内核态？

1.时钟/外设中断

2.异常 cpu--->软中断

3.陷阱系统调用(int 0x80,syscall)

信号的自定义捕捉

1.前三步很好理解，那么为什么要转为用户态来调用处理方法，直接在内核态来处理不好吗？

内核和用户的权限不同，有安全风险；并且用户来处理，如果出了错误用户担责任。

2.信号处理完只能从内核返回，因为处理函数的调用与main()函数之间不存在调用关心(栈区）

3.如何继续执行原来的程序？

cpu中有pc寄存器（pc指针），指向下一条要执行的命令，只需要恢复pc指针的值就可以了。

sigaction

作用检查并修改handler表

sigaction结构

sa_handler :函数指针

sa_mask：自定义屏蔽的信号

信号处理期间，如果处理方法有系统调用，那么就陷入内核态

os不允许信号处理方法嵌套--->实现该方法的方式是将block表相应的信号置为1(阻塞该信号),但信号处理完会自动解除阻塞

什么时候pending表清0？

在调用信号处理之前，因为如果是处理完之后清零，那么就无法区分pending中的1是处理进程时收到的1，还是处理完时的1

验证阻塞信号

void PrintBlock()
{
    sigset_t block;
    sigprocmask(SIG_SETMASK,nullptr,&block);
    for(int i = 31;i>0;i--)
    {
        if(sigismember(&block,i))
            std::cout<<1;
        else
            std::cout<<0;
    }
    std::cout<<std::endl;
}
void handler(int signo)
{
    std::cout<<"signo: "<<signo<<std::endl;
    while(true)
    {
        PrintBlock();
        sleep(3);
    }
}

int main()
{
    //signal(2,handler);
    struct sigaction act,oldact;
    act.sa_handler = handler;
    sigaction(2,&act,&oldact);
    //std::cout<<"执行"<<std::endl;
    PrintBlock();
    while(true)
    {
        pause();
    }
}

处理完解除对信号的阻塞

void PrintBlock()
{
    sigset_t block;
    sigprocmask(SIG_SETMASK,nullptr,&block);
    for(int i = 31;i>0;i--)
    {
        if(sigismember(&block,i))
            std::cout<<1;
        else
            std::cout<<0;
    }
    std::cout<<std::endl;
}
void handler(int signo)
{
    std::cout<<"signo: "<<signo<<std::endl;
    // while(true)
    // {
    //     PrintBlock();
    //     sleep(3);
    // }
    PrintBlock();
    sleep(3);
}

int main()
{
    //signal(2,handler);
    struct sigaction act,oldact;
    act.sa_handler = handler;
    sigaction(2,&act,&oldact);
    //std::cout<<"执行"<<std::endl;
    PrintBlock();
    while(true)
    {
        pause();
        PrintBlock();
    }
}

验证在处理前将pending表清零

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>
#include <wait.h>
#include <vector>
void PrintBlock()
{
    sigset_t block;
    sigprocmask(SIG_SETMASK, nullptr, &block);
    std::cout<<"block: ";
    for (int i = 31; i > 0; i--)
    {
        if (sigismember(&block, i))
            std::cout << 1;
        else
            std::cout << 0;
    }
    std::cout << std::endl;
}
void PrintPending()
{
    sigset_t pending;
    sigpending(&pending);
    sigprocmask(SIG_SETMASK, nullptr, &pending);
    std::cout<<"pending: ";
    for (int i = 31; i > 0; i--)
    {
        if (sigismember(&pending, i))
            std::cout << 1;
        else
            std::cout << 0;
    }
    std::cout << std::endl;
}
void handler(int signo)
{
    std::cout << "signo: " << signo << std::endl;
    // while(true)
    // {
    //     PrintBlock();
    //     sleep(3);
    // }
    PrintBlock();
    PrintPending();
    sleep(3);
}

int main()
{
    // signal(2,handler);
    struct sigaction act, oldact;
    act.sa_handler = handler;
    sigaction(2, &act, &oldact);
    // std::cout<<"执行"<<std::endl;
    PrintBlock();
    PrintPending();
    while (true)
    {

        pause();
        PrintBlock();
        PrintPending();
    }
}

验证sa_mask的作用

void handler(int signo)
{
    std::cout << "signo: " << signo << std::endl;
    // while(true)
    // {
    //     PrintBlock();
    //     sleep(3);
    // }
    PrintBlock();
    //PrintPending();
    while(true)
    {

    }
    //sleep(3);
}

int main()
{
    // signal(2,handler);
    struct sigaction act, oldact;
    act.sa_handler = handler;
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask,2);
    sigaddset(&mask,3);//把三号信号屏蔽
    act.sa_mask = mask;//设置屏蔽信号
    sigaction(2, &act, &oldact);
    // std::cout<<"执行"<<std::endl;
    PrintBlock();
    //PrintPending();
    while (true)
    {

        pause();
        //PrintBlock();
        //PrintPending();
    }
}

屏蔽了2号和3号信号

可重入函数

一个函数被两个以上的执行流同时进入--->重入(重复进入)

重入，不出问题--->可重入函数

重入，出问题---> 不可重入函数--->涉及对全局资源的处理

大部分库中的函数都是不可重入函数

重入和不可重入没有好坏之分，只是特性。

案例

因为中断，将node2插入链表，head指向node2，但返回main函数继续执行时，head又指向了node1导致找不到node2,也就造成了内存泄漏。main和信号的处理是两个执行流，进入的都是inset函数。

volatile

volatile是易变关键字

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
int flag = 1;
void handler(int signo)
{
    printf("signo:%d\n",signo);
    printf("flag -> 0\n");
    flag = 0;

}
int main()
{
    signal(2,handler);
    while(flag);
    
    printf("quit normal!\n");
    return 0;
}

没开启编译器优化，会实时更新进程地址空间中flag的值

当把编译器的优化等级开高一些，为什么不退出了呢？

开了优化后，即使进程内存地址空间中的flag改变了，但cpu中的flag不会根据进程地址空间中的flag更新寄存器中的flag，所以一直死循环没有退出。

volatile flag = 1;//加上volatile关键字

即使优化编译器优化等级开高了，也实时通过进程地址空间中值修改寄存器中的值。

SIGCHLD信号

当子进程退回后----（给父进程发送）--->SIGCHLD信号

waitpid补充

pid为-1时，可以等待任何子进程。

验证子进程退出会给父进程发送SIGCHLD信号

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
void handler(int signo)
{
    std::cout << "signo: " << signo << std::endl;
    pid_t ret = waitpid(-1, nullptr, 0);//pid==-1,表示等待任何子进程
    if (ret > 0)
    {
        std::cout<<"子进程: "<<ret<<"退出"<<std::endl;
    }
    else if (ret < 0)
    {
        std::cout << "wait error" << std::endl;
    }
    sleep(3);
}
int main()
{
    signal(SIGCHLD, handler);
    pid_t pid = fork();
    if (pid == 0)
    {
        std::cout << "我是子进程: ";
        std::cout << getpid() << std::endl;
        exit(0);
    }
    std::cout << "我是父进程: " << getpid() << std::endl;
    while (true);
    return 0;
}

基于信号对子进程回收

问题1：

如果有n个子进程同时给父进程发送SIGCHLD信号，这是只能记录和处理一个信号；

如果pending记录了一个信号，其他的信号再发过来也不会被记录。

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
void handler(int signo)
{
    std::cout << "signo: " << signo << std::endl;
    pid_t ret = waitpid(-1,nullptr,0);
    if(ret>0)
    {
            std::cout << "子进程: " << ret << "退出" << std::endl;
    }
    else if(ret<0)
    {
        std::cout<<"wait error"<<std::endl;
    }
}
int main()
{
    signal(SIGCHLD, handler);
    pid_t pid = fork();
    for (int i = 0; i < 5; i++)
    {
        pid_t pid = fork();
        if (pid == 0)
        {
            std::cout << "我是子进程: ";
            std::cout << getpid() << std::endl;
            exit(0);
        }
    }
    while(true);
    return 0;
}

创建了10个子进程只有7个子进程退出，剩余的子进程发出的信号没有被处理，这些子进程变为了僵尸

解决方法循环回收

void handler(int signo)
{
    while (true)
    {
        pid_t ret = waitpid(-1, nullptr, 0);
        if (ret > 0)
        {
            std::cout << "子进程: " << ret << "退出" << std::endl;
            // std::cout << "wait success" << std::endl;
        }
        else if (ret < 0)
        {
            std::cout << "暂时回收完毕" << std::endl;
            break;
        }
    }
}

运行结果：子进程全都被回收

没有僵尸子进程

问题2：

基于问题1，如果10个子进程中，有几个进程迟迟不退出那么，就会阻塞在信号处理那里等待子进程的退出

解决方法

options中有个WNOHANG，如果没有子进程结束则立即返回0

这样处理方法就有阻塞变为了非阻塞，如果有子进程退出则又会在进入循环回收，一次往复，避免了子进程出现僵尸。

pid_t ret = waitpid(-1, nullptr, WNOHANG);

查看全文

http://www.kler.cn/a/394083.html

UDP协议和TCP协议之间有什么具体区别？

Vue 3 介绍及应用

vue3+element-plus==＞ el-form输入响应式失效踩坑!!!!!!!!!!

【Linux】TCP原理

5G时代的关键元件：射频微波MLCCs市场前景广阔

linux 下查看程序启动的目录

修改yolo格式的labels类别、删除yolo格式的labels类别

redis7.x源码分析:(1) sds动态字符串

【回溯法】——组合总数

【AI技术】GPT-SoVits训练日志

蓝桥杯——杨辉三角

【PGCCC】Postgresql 物理流复制

设计模式之工厂模式，但是宝可梦

【Node.js]

TCON 相关知识

Git - 命令杂谈 - merge、rebase和cherry-pick

git修改当前分支名称并推送到远程仓库

【新手友好】用Pyspark和GraphX解析复杂网络数据

【数据分享】中国食品工业年鉴(1984-2023) PDF

确保HTML邮件兼容所有PC和移动设备的样式

Vue Canvas实现区域拉框选择

Jmeter中的配置原件（五）

微服务电商平台课程四: 搭建本地前端服务

WPF学习之路，控件的只读、是否可以、是否可见属性控制

〔 MySQL 〕数据类型

基于HTTP编写ping操作

信号保存中重要的概念

内核中信号的保存

对sigset_t操作的函数

对block，pendding，handler三张表的操作

sigpromask

sigpending

是否有sighandler函数呢？

案例

信号处理

操作系统是如何运行的？

硬件中断

时钟中断

软中断

死循环

缺⻚中断？内存碎⽚处理？除零野指针错误？

理解用户态和内核态

信号的自定义捕捉

sigaction

验证阻塞信号

处理完解除对信号的阻塞

验证在处理前将pending表清零

验证sa_mask的作用

可重入函数

案例

volatile

SIGCHLD信号

waitpid补充

验证子进程退出会给父进程发送SIGCHLD信号

基于信号对子进程回收

问题1：

解决方法循环回收

问题2：

相关文章：