【Linux系统编程】27.sigprocmask、sigpending、signel、sigaction

最新推荐文章于 2024-07-04 17:16:54 发布
最新推荐文章于 2024-07-04 17:16:54 发布
阅读量593 收藏 13
点赞数 20
分类专栏： Linux系统编程 文章标签： linux 嵌入式硬件 ubuntu c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CETET/article/details/138256574
版权
本文详细介绍了Linux系统中的信号处理函数sigprocmask、sigpending以及如何使用它们来屏蔽、查看信号和实现信号捕捉。通过示例代码展示了如何操作信号集，以及信号捕捉的特性，包括信号延迟执行和子进程回收等。
摘要由CSDN通过智能技术生成

目录

sigprocmask

参数how

参数set

参数oldset

返回值

sigpending

参数set

测试代码1

测试结果

signel

测试代码2

测试结果

sigaction

参数act

参数oldact

返回值

测试代码3

测试结果

信号捕捉特性

测试代码4

测试结果

测试代码5

测试结果

内核实现信号捕捉过程

测试代码6

测试结果

测试代码7

测试结果

慢速系统调用

sigprocmask

用来屏蔽信号、解除屏蔽也使用该函数。其本质，在PCB中读取或修改进程的信号屏蔽字。

注意：屏蔽信号只是将信号处理延后执行（延至解除屏蔽），而忽略表示将信号丢处理。

man 2 sigprocmask

参数how

  • SIG_BLOCK：设置阻塞

  • SIG_UNBLOCK：取消阻塞

  • SIG_SETMASK：用自定义的set替换mask

参数set

自定义set

参数oldset

保存旧的信号屏蔽集。

返回值

成功：0

失败：-1，设置errno

sigpending

查看未决信号集。

man 2 sigpending

参数set

传出的未决信号。

测试代码1

屏蔽CTRL+C、CTRL+\、7）、9）信号。

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <signal.h>

int main(int argc, char *argv[])
{
    sigset_t XinHaoJi;      //信号集
    sigset_t Old_XinHaoJi;  //旧的信号集
    sigset_t WeiJue_XinHao; //未决信号
    int flag, i;
    sigemptyset(&XinHaoJi);        //清空信号集
    sigaddset(&XinHaoJi, SIGINT);  //屏蔽Ctrl+C信号
    sigaddset(&XinHaoJi, SIGQUIT); //屏蔽Ctrl+\信号
    sigaddset(&XinHaoJi, SIGBUS);  //屏蔽7）信号
    sigaddset(&XinHaoJi, SIGKILL); //屏蔽9）信号

    flag = sigprocmask(SIG_BLOCK, &XinHaoJi, &Old_XinHaoJi); //设置阻塞屏蔽信号
    if (flag == -1)
    {
        perror("设置阻塞屏蔽信号错误");
        exit(1);
    }

    while (1)
    {
        flag = sigpending(&WeiJue_XinHao); //获取未决信号
        if (flag == -1)
        {
            perror("获取未决信号错误");
            exit(1);
        }
        printf("未决信号集：");
        for (i = 1; i < 32; i++)
        {
            printf("%d", sigismember(&WeiJue_XinHao, i)); //判断一个信号是否在集合中
        }
        printf("\n");
        sleep(2);
    }
    
    return 0;
}

测试结果

只有9）信号不能被屏蔽，能够杀死进程。

signel

注册一个信号捕捉函数。

man 2 signel

测试代码2

捕捉CTRL+C信号，捕捉后输出内容。

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

void ChuLi_HanShu()
{
    static int i = 1;
    printf("成功捕捉到%d次。\n", i++);
}

int main(int argc, char *argv[])
{
    signal(SIGINT, ChuLi_HanShu); //注册信号捕捉函数，捕捉Ctrl+C信号
    printf("开始捕捉Ctrl+C信号！\n");
    while (1)
        ;
    return 0;
}

测试结果

sigaction

注册一个信号捕捉函数。

man 2 sigaction

参数act

传入参数，新的处理方式。

参数oldact

传出参数，旧的处理方式。

返回值

成功：0

失败：-1

测试代码3

用sigaction捕捉Ctrl+C、Ctrl+\信号，捕捉后输出内容。

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

void ChuLi_HanShu(int XinHao)
{
    static int i = 1;
    printf("成功捕捉到%d次，捕捉到的信号是%d。\n", i++, XinHao);
}

int main(int argc, char *argv[])
{
    int flag;
    struct sigaction New_ChuLi_FangShi;                               //新的处理方式
    struct sigaction Old_ChuLi_FangShi;                               //旧的处理方式
    New_ChuLi_FangShi.sa_handler = ChuLi_HanShu;                      //设置处理函数
    sigemptyset(&New_ChuLi_FangShi.sa_mask);                          //清空信号集
    New_ChuLi_FangShi.sa_flags = 0;                                   //默认值处理
    flag = sigaction(SIGINT, &New_ChuLi_FangShi, &Old_ChuLi_FangShi); //注册信号捕捉函数
    if (flag == -1)
    {
        perror("注册捕捉信号函数失败");
    }
    flag = sigaction(SIGQUIT, &New_ChuLi_FangShi, &Old_ChuLi_FangShi); //注册信号捕捉函数
    if (flag == -1)
    {
        perror("注册捕捉信号函数失败");
    }
    printf("开始捕捉Ctrl+C、Ctrl+\\信号！\n");
    while (1)
        ;
    return 0;
}

测试结果

信号捕捉特性

  1. 捕捉函数执行期间，信号屏蔽字由mask变成sa_mask，捕捉函数执行结束。再由sa_mask恢复回mask。

  2. 捕捉函数执行期间，本信号自动被屏蔽，sa_flags=0。

  3. 捕捉函数执行期间，被屏蔽信号多次发送，解除屏蔽后只处理一次。

测试代码4

按照Ctrl+\、Ctrl+C、Ctrl+\、Ctrl+C的顺序发送信号，查看执行结果。

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

void ChuLi_HanShu(int XinHao)
{
    static int i = 1;
    if (XinHao == SIGINT)
    {
        printf("\n成功捕捉到%d次，捕捉到的信号是%d，Ctrl+C开始睡10s。\n", i++, XinHao);
        sleep(10);
        printf("\nCtrl+C睡醒了。\n");
    }
    else if (XinHao == SIGQUIT)
    {
        printf("\n成功捕捉到%d次，捕捉到的信号是%d，Ctrl+\\开始睡10s。\n", i++, XinHao);
        sleep(10);
        printf("\nCtrl+\\睡醒了。\n");
    }
}

int main(int argc, char *argv[])
{
    int flag;
    struct sigaction New_ChuLi_FangShi;                               //新的处理方式
    struct sigaction Old_ChuLi_FangShi;                               //旧的处理方式
    New_ChuLi_FangShi.sa_handler = ChuLi_HanShu;                      //设置处理函数
    sigemptyset(&New_ChuLi_FangShi.sa_mask);                          //清空信号集
    New_ChuLi_FangShi.sa_flags = 0;                                   //默认值处理
    flag = sigaction(SIGINT, &New_ChuLi_FangShi, &Old_ChuLi_FangShi); //注册信号捕捉函数
    if (flag == -1)
    {
        perror("注册捕捉信号函数失败");
    }
    flag = sigaction(SIGQUIT, &New_ChuLi_FangShi, &Old_ChuLi_FangShi); //注册信号捕捉函数
    if (flag == -1)
    {
        perror("注册捕捉信号函数失败");
    }
    printf("开始捕捉Ctrl+C、Ctrl+\\信号！\n");
    while (1)
        ;
    return 0;
}

测试结果

推测：

第1次捕捉到3）信号，未决信号3）置1，处理函数开始执行，未决信号3）清零。

第2次捕捉到2）信号，未决信号2）置1，中断第1次的处理函数，第2次处理函数开始执行，未决信号2）清零。

3）信号、2）信号按顺序到达，未决信号3）置1，未决信号2）置1。

第2次处理函数执行结束，检测未决信号2），发现还是1，继续执行信号2）第3次的处理函数，未决信号2）清零。

第3次的处理函数执行完成后，继续执行第1次的处理函数。

第1次处理函数执行完成后，检测未决信号3），发现还是1，继续执行信号3）第4次的处理函数。

总结：每执行完对应的信号处理函数，都再次检测未决信号，如果仍有未决信号，则继续执行处理函数；如果没有未决信号，则继续执行中断后的处理函数。

测试代码5

捕捉到1个信号后，在执行中，再捕捉到下一个信号，下一个信号延迟执行。

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

void ChuLi_HanShu(int XinHao)
{
    static int i = 1;
    if (XinHao == SIGINT)
    {
        printf("\n成功捕捉到%d次，捕捉到的信号是%d，Ctrl+C开始睡10s。\n", i++, XinHao);
        sleep(10);
        printf("\nCtrl+C睡醒了。\n");
    }
}

int main(int argc, char *argv[])
{
    int flag;
    struct sigaction New_ChuLi_FangShi;                               //新的处理方式
    struct sigaction Old_ChuLi_FangShi;                               //旧的处理方式
    New_ChuLi_FangShi.sa_handler = ChuLi_HanShu;                      //设置处理函数
    sigemptyset(&New_ChuLi_FangShi.sa_mask);                          //清空信号集
    sigaddset(&New_ChuLi_FangShi.sa_mask, SIGQUIT);                   //延迟执行的信号
    New_ChuLi_FangShi.sa_flags = 0;                                   //默认值处理
    flag = sigaction(SIGINT, &New_ChuLi_FangShi, &Old_ChuLi_FangShi); //注册信号捕捉函数
    if (flag == -1)
    {
        perror("注册捕捉信号函数失败");
    }
    printf("开始捕捉Ctrl+C、Ctrl+\\信号！\n");
    while (1)
        ;
    return 0;
}

测试结果

内核实现信号捕捉过程

 

测试代码6

借助信号捕捉回收子进程，全部回收后，父进程再继续执行。

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

void ChuLi_HanShu(int XinHao)
{
    int flag;
    pid_t JinCheng_ID;                                  //进程ID
    while ((JinCheng_ID = waitpid(-1, &flag, 0)) != -1) //循环回收子进程，防止僵尸进程出现
    {
        if (WIFEXITED(flag))
        {
            printf("这是处理函数，回收的子进程ID是%d。\n", JinCheng_ID);
        }
    }
}

int main(int argc, char *argv[])
{
    pid_t JinCheng_ID; //进程ID
    int flag, i;
    struct sigaction New_ChuLi_FangShi; //新的处理方式

    //创建子进程
    for (i = 0; i < 5; i++)
    {
        JinCheng_ID = fork();
        if (JinCheng_ID == 0)
        {
            break;
        }
    }

    if (i == 5) //父进程
    {
        New_ChuLi_FangShi.sa_handler = ChuLi_HanShu;         //设置处理函数
        sigemptyset(&New_ChuLi_FangShi.sa_mask);             //清空信号集
        New_ChuLi_FangShi.sa_flags = 0;                      //默认值处理
        flag = sigaction(SIGCHLD, &New_ChuLi_FangShi, NULL); //注册信号捕捉函数
        if (flag == -1)
        {
            perror("注册捕捉信号函数失败");
        }
        printf("这是父进程，进程ID是%d。\n", getpid());
        while (1)
        {
            printf("你好，世界！\n");
            sleep(1);
        }
    }
    else //子进程
    {
        sleep(i);
        printf("这是子进程，进程ID是%d，已死亡。\n", getpid());
        return i + 1;
    }
    return 0;
}

测试结果

测试代码7

借助信号捕捉回收子进程，死一个回收一个，同时执行。

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

void ChuLi_HanShu(int XinHao)
{
    int flag;
    pid_t JinCheng_ID; //进程ID
    JinCheng_ID = waitpid(-1, &flag, 0);
    if (WIFEXITED(flag))
    {
        printf("这是处理函数，回收的子进程ID是%d。\n", JinCheng_ID);
    }
}

int main(int argc, char *argv[])
{
    pid_t JinCheng_ID; //进程ID
    int flag, i;
    struct sigaction New_ChuLi_FangShi; //新的处理方式

    //创建子进程
    for (i = 0; i < 5; i++)
    {
        JinCheng_ID = fork();
        if (JinCheng_ID == 0)
        {
            break;
        }
    }

    if (i == 5) //父进程
    {
        New_ChuLi_FangShi.sa_handler = ChuLi_HanShu;         //设置处理函数
        sigemptyset(&New_ChuLi_FangShi.sa_mask);             //清空信号集
        New_ChuLi_FangShi.sa_flags = 0;                      //默认值处理
        flag = sigaction(SIGCHLD, &New_ChuLi_FangShi, NULL); //注册信号捕捉函数
        if (flag == -1)
        {
            perror("注册捕捉信号函数失败");
        }
        printf("这是父进程，进程ID是%d。\n", getpid());
        while (1)
        {
            printf("你好，世界！\n");
            sleep(1);
        }
    }
    else //子进程
    {
        sleep(i);
        printf("这是子进程，进程ID是%d，已死亡。\n", getpid());
        return i + 1;
    }
    return 0;
}

测试结果

慢速系统调用

       可能会使进程永远阻塞的一类，如，read、write、pause、wait。在早期，如果在阻塞期间收到一个信号，该系统调用就被中断，不再继续执行，也可以设定系统调用是否重启。

可修改sa_flags参数来设置被信号中断后系统调用是否重启：

  1. SA_INTERRURT：不重启。

  2. SA_RESTART：重启。

        捕捉到信号后，在执行捕捉函数期间，不希望自动阻塞该信号，可将sa_flags设置为SA_NODEFER，除非sa_mask中包含该信号。

因心，三人水
关注
专栏目录
《Linux系统调用：sigprocmask,sigpending》
yexiangCSDN的专栏
12-30 363
一、介绍 信号阻塞集也称信号屏蔽集、信号掩码。每个进程都有一个阻塞集，创建子进程时子进程将继承父进程的阻塞集。 信号阻塞集用来描述哪些信号递送到该进程的时候被阻塞(在信号发生时记住它，直到进程准备好时再将信号通知进程)。 所谓阻塞并不是禁止传送信号, 而是暂缓信号的传送。若将被阻塞的信号从信号阻塞集中删除，且对应的信号在被阻塞时发生了，进程将会收到相应的信号。 我们可以通过 sigproc...
Linux信号处理函数sigprocmask()使用方法讲解
weixin_42048463的博客
07-05 1692
我们看一下sigprocmask()函数的使用方法. 下面我们再写一个简单的例子来熟悉sigprocmask()函数及其配套使用函数. SIG_UNBLOCK参数的使用: #include <signal.h> #include <stdio.h> #include <stdlib.h> int main() { in...
LINUX C中sigprocmask()函数用法
热门推荐
ShaoLiang_Ge的博客
02-27 1万+
1、有时候不希望在接到信号时就立即停止当前执行，去处理信号，同时也不希望忽略该信号，而是延时一段时间去调用信号处理函数。这种情况是通过阻塞信号实现的。 2、信号阻塞和忽略信号的区别。 阻塞的概念和忽略信号是不同的。操作系统在信号被进程解除阻塞之前不会讲信号传递出去，被阻塞的信号也不会影响进程的行为，信号只是暂时被阻止传递。当进程忽略一个信号时，信号会被传递出去但进程会将信号丢弃。
嵌入式Linux系统编程 — 6.6 信号掩码
最新发布
几度春风里的博客
07-04 647
信号掩码（Signal Mask）是操作系统中用于控制进程接收信号的一种机制。每个进程都有一个或多个信号掩码，它们定义了哪些信号在特定时间被阻塞（即暂时忽略），哪些信号可以被进程接收。当应用程序调用 signal()或 sigaction()函数为某一个信号设置处理方式时，进程会自动将该信号添加到信号掩码中， 这样保证了在处理一个给定的信号时，如果此信号再次发生，那么它将会被阻塞；
Linux系统调用之sigprocmask、sigpending函数（设置内核阻塞信号集，查看内核未决信号集）
weixin_49503250的博客
05-07 892
这篇文章介绍了标准C库中的sigprocmask、sigpending这两个函数。标准C库内容简介，标准C库函数常用函数与函数文章索引（不断更新）Linux系统调用函数文章索引。
关于linux操作系统_信号_sigprocmask函数
mw_nice的博客
04-17 341
sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作）。 他是POSIX的信号接口，而signal()是标准C的信号接口(如果程序必须在非POSIX系统上运行，那么就应该使用这个接口) 给信号signum设置新的信号处理函数act， 同时保留该信号原有的信号处理函数oldact intsigaction(intsigno,conststructs...
（转）Linux sigprocmask
caoli98033的专栏
03-24 899
功能描述：设定对信号屏蔽集内的信号的处理方式(阻塞或不阻塞)。 用法： #include int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); 参数： how：用于指定信号修改的方式，可能选择有三种 SIG_BLOCK //加入信号到进程屏蔽。 SIG_UNBLOCK //从进程屏蔽里将信号删除。 S
Linux内核同步编程技术.doc
03-29
Linux内核同步编程技术是操作系统领域的一个重要主题，它涉及到多进程或线程之间的协调与通信，确保在并发环境中正确地访问共享资源。本实验主要探讨了四种不同的进程间通信（IPC）机制：信号、管道、命名管道（FIFO...
Linux编程之信号.pdf
09-07
《Linux编程之信号》这本书深入探讨了Linux操作系统中的信号机制，这是进程间通信的一种基本方式。信号用于指示系统中发生的特定事件，如硬件故障、程序异常、子进程终止或者用户从终端发送的中断请求等。在Linux...
Linux系统编程13.信号
qq_42027408的博客
03-10 97
信号共性： 简单、不能携带大量信息、满足条件才发送。 信号的特质： 信号是软件层面上的 “中断” 。一旦信号产生，无论程序执行到什么位置，必须立即停止运行，处理信号，处理结束，再继续执行后续指令。 所有信号的产生和处理全部都是由【内核】完成的。 信号相关概念： 产生信号： 1.按键产生 2.系统调用产生 3.硬件异常产生 4.命令产生 概念： 未决：产生与抵达之间状态。 抵达：产生并且送达到进程。...
linux系统编程（中文版）
10-15
### Linux系统编程（中文版） #### 一、概述与核心概念 **本书介绍：** 《Linux系统编程（中文版）》是一本深入讲解Linux环境下系统编程技术的专业书籍。该书不仅提供了理论上的深入剖析，还结合了大量的实际案例...
Linux系统应用编程 --- 信号处理函数（sigprocmask、sigpending函数）
M2嵌入式
04-06 948
信号集处理函数 int sigemptyset(sigset_t *set); 清空信号集，将信号集全部置0 int sigfillset(sigset_t *set); 将信号集全部置1 int sigaddset(sigset_t *set, int signo) ...
linux sigprocmask函数理解
weixin_34399060的博客
02-24 190
2019独角兽企业重金招聘Python工程师标准>>> ...
Linux学习笔记18——sigprocmask 信号屏蔽字
孤独的根号3的博客
03-30 668
1，信号集 我们可以将多个信号编成一个集合，对集合内的信号进行同样的操作（比如忽略一个信号集内的所有信号）。信号集的数据类型为sigset_t。还有一些与之相关的函数用于初始化信号集、向信号集中添加、删除信号，以及判断某个信号是否在信号集内。 原型如下： #include<signal.h> int sigemptyset(sigset_t *set); //将set指向的信号...
LinuxC：信号处理 alarm() 信号集操作函数 sigprocmask() sigpending() sigsuspend() SIGCHILD信号 实现sleep()
qq_33373173的博客
08-25 241
kill -l：Linux查看当前系统有哪些信号 man 7 signal：Linux查看信号手册 ulimit -a：Linux命令可查看core文件大小（core file size） ulimit -c 1024：Linux命令设置core文件大小为1024 ulimit -c unlimited: 大小设置为无限制 Tern：终止当前进程 Core：Tern并且Core Dump(产生core文件) Ign：忽略信号 Stop：停止（暂停）当前进程 Cont：继续执行之前Stop的进程 S...
【LinuxC语言】信号集与sigprocmask
m0_62599305的博客
05-05 1034
在Linux C编程中，信号是一种重要的进程间通信机制，用于通知进程发生了特定的事件。然而，程序在执行过程中可能会收到各种各样的信号，有些信号可能会在不合适的时候打断程序的正常执行，造成不可预料的后果。为了控制信号的接收和处理，Linux提供了信号集和sigprocmask()函数。信号集是一种数据结构，用于管理信号的集合，而sigprocmask()函数则允许程序员临时修改进程的信号屏蔽字，以控制信号的接收和处理。本文介绍了Linux C编程中的信号集与sigprocmask()函数。
【探索Linux】P.17（进程信号 —— 信号保存 | 阻塞信号 | sigprocmask() | sigpending() ）
Yawesh的博客
11-28 2557
这篇文章主要介绍了与信号相关的常见概念，以及涉及到信号阻塞和信号集操作的函数。首先，文章解释了信号递达、信号未决、阻塞信号和忽略信号这些常见概念。然后，通过示意图展示了信号在内核中的表示方式。接着，介绍了sigset_t数据类型，它用于表示信号集。文章还列举了一些信号集操作函数，用于对信号集进行操作。接下来，文章详细介绍了sigprocmask()函数，该函数用于设置和修改进程的信号屏蔽字，从而实现信号的阻塞。最后，文章提及了sigpending()函数，该函数用于获取当前进程挂起的信号集。
【Linux】进程信号篇Ⅱ：信号的阻塞及保存（sigset_t, sigprocmask, sigpending）、信号的处理、信号的捕捉（sigaction）
m0_67470729的博客
08-18 239
如题
sigpending(&sig_set);
05-24
`sigpending` 函数用于获取当前已经被阻塞且等待处理的信号集合。它的函数原型如下： ```c int sigpending(sigset_t *set); ``` 其中，`set` 参数是一个指向 `sigset_t` 类型的指针，用于存储获取到的信号集合。 函数执行成功时返回 0，否则返回 -1。 在调用 `sigpending` 函数后，通过检查 `set` 指向的信号集合，可以知道当前有哪些信号被阻塞且等待处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

因心，三人水

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值