【Linux】：进程信号（再谈信号保存和信号捕捉）

IsLand1314

发布于 2024-11-26 04:50:38

25400

代码可运行

文章被收录于专栏：学习之路学习之路

运行总次数：0

代码可运行

1. sigaction

#include <signal.h>

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


// 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);
};

/*
① sa_handler: 指向信号处理函数的指针。当信号到达时，会调用该函数来处理信号。信号处理函数的原型为 void handler(int signum)，其中 signum 是信号的编号。
② sa_sigaction: 当使用了更复杂的信号处理需求时，可以设置这个字段，它允许获取更多的信号信息，包括信号的额外数据（通过 siginfo_t 结构体）和信号发生时的上下文信息。
③ sa_mask: 这个字段用于指定一个信号集，表示在信号处理程序执行期间应该被阻塞的信号。即，在信号处理期间，可以通过 sa_mask 阻止其他信号的处理。
④ sa_flags: 这个字段用于指定如何处理信号的选项。常见的标志包括：
    a. SA_RESTART: 如果信号处理程序返回后，系统调用应当自动重新启动（默认情况下，系统调用会因为信号的到来而被中断）。
    b. SA_SIGINFO: 如果设置了该标志，则会调用 sa_sigaction 函数，而不是 sa_handler，同时可以通过 siginfo_t 获取更多信息。
    c. SA_NOCLDSTOP: 不报告子进程的停止信号。
    d. SA_NODEFER: 在信号处理期间不会阻塞该信号。
*/

功能：sigaction 的数可以读取和修改与指定信号相关联的处理动作。

参数：

signum：这是信号的编号，指定了要操作的信号。例如，SIGINT (Ctrl+C 中断)、SIGTERM (终止信号)等
act：指向一个 struct sigaction 结构体的指针，定义了信号处理的行为。它包含信号处理的详细信息，如信号处理程序、信号屏蔽集等
oldact： 指向一个 struct sigaction 结构体的指针，用于存储之前信号的处理方式。如果不需要保存原先的信号处理方式，可以将其设置为 NULL

返回值：调用成功则返回0，出错则返回-1

sigaction 本质就是修改信号的handler表
sigaction 跟前面的signal本质作用是一样的，都是对特定信号进行捕捉

调用成功则返回0，出错则返回-1

sigaction 本质就是修改信号的handler表
sigaction 跟前面的signal本质作用是一样的，都是对特定信号进行捕捉

sa_nandler 赋值问题？

将 sa_nandler 赋值为常数 SIG_IGN 传给 sigaction 表示忽略信号
赋值为常数 SIG_DFL 表示执行系统默认动作
赋值为一个函教指针表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数，
1. 该函教返回值为 void，可以带一个 int 参数，通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。
2. 显然，这也是个回调函数，不是被 main函数调用，而是被系统所用.

🌈 当某个信号的处理函数被调用时，内核自动将当前信号加入进程的信号屏蔽字，当信号处理函数返回时自动恢复原来的信号屏蔽字，这样就保证了在处理某个信号时，如果这种信号再次产生，那么它会被阻塞到当前处理结束为止

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

sa_flags字段包含一些选项，这里都把sa_fags设为0，sa_sigaction 是实时信号的处理函数

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

void handler(int signo)
{
    std::cout << "get a sig: " << signo << std::endl;
    exit(1);
}

int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    ::sigaction(2, &act, &oact);
    while(true)
    {
        pause();
    }
}

运行结果如下：

看了上面代码，我们来想一个问题。处理信号期间，有没有可能进行陷入内核呢？ -- > 有可能，如下演示：

OS 不允许信号处理方法进行嵌套 -- 某个信号正在被处理 -- OS 会自动把对应信号的 block 位设置为 1 ，信号处理完成会自动解除

因此我们写一个函数，把 blocklist 位图打印出来看看

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

// PrintBlockList
void PrintBlock()
{
    sigset_t set, oset;
    sigemptyset(&set);
    sigemptyset(&oset);
    
    sigprocmask(SIG_BLOCK, &set, &oset);
    std::cout << "block: ";
    for(int signo = 31; signo > 0; signo--)
    {
        if(sigismember(&oset, signo)){
            std::cout << 1;
        }
        else std::cout << 0;
    }
    std::cout << std::endl;
}


void handler(int signo)
{
    static int cnt = 0;
    cnt++;
    while(true)
    {
        std::cout << "get a sig: " << signo <<", cnt: " << cnt << std::endl;
        PrintBlock();
        sleep(1);
    }
    exit(1);
}

int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    ::sigaction(2, &act, &oact);
    while(true)
    {
        PrintBlock();
        pause();
    }
}

如果想自定义屏蔽信号列表的 list，就可以加到 sa_mask 里面，如下：

再来看一个代码

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

void PrintPending()
{
    sigset_t pending;
    ::sigpending(&pending);

    std::cout << "Pending: ";
    for(int signo = 31; signo > 0; signo--)
    {
        if(sigismember(&pending, signo)) std::cout << 1;
        else std::cout << 0;
    }
    std::cout << std::endl;
}


void handler(int signo){
    static int cnt = 0;
    cnt++;
    while(true){
        std::cout << "get a sig: " << signo <<", cnt: " << cnt << std::endl;
        PrintPending();
        sleep(1);
    }
    exit(1);
}

int main(){
    struct sigaction act, oact;
    act.sa_handler = handler;

    // 自定义进行信号屏蔽
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);
    sigaddset(&act.sa_mask, 5);
    sigaddset(&act.sa_mask, 6);

    ::sigaction(2, &act, &oact);
    while(true){
        PrintPending();
        pause();
    }
}

运行结果如下：

结论：2 号信号默认在 handler 之前， pending 位图由 0 变 1

sigaction 和 signal 的区别

sigaction 提供了更丰富的功能，比如更精细的控制信号屏蔽和信号处理标志。
signal 函数相对简单，但不支持某些高级功能（如信号屏蔽、信号恢复等），并且在一些系统中可能会受到实现差异的影响。
因此，sigaction 是一种更现代、更稳定的信号处理方法，建议在新代码中使用它。

2. 可重入函数

验证：链表的插入是不可重入的

main函数调用insert 函数向一个链表head中插入节点node1，插入操作分为两步：
- 刚做完第一步的时候，因为硬件中断使进程切换到内核，再次回用户态之前检查到有信号待处理，于是切换到 sighandler 函数
- sighandler 函数 也调用insert函数向同一个链表head中插入节点node2，插入操作的两步都做完之后从sighandler返回内核态，再次回到用户态就从main函数调用的insert函数中继续往下执行，先前做第一步之后被打断，现在继续做完第二步。
- 结果是：main函数和 sighandler先后向链表中插入两个节点，而最后只有一个节点真正插入链表中了
像上例这样，insert函数被不同的控制流程调用，有可能在第一次调用还没返回时就再次进入该函数，这称为重入
insert 函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数称为 不可重入函数
反之，如果一个函数只访问自己的局部变量或参数，则称为 可重入(Reentrant)函数。想一下,为什么两个不同的控制流程调用同一个函数，访问它的同一个局部变量或参数就不会造成错乱?

函数的重入指的是一个函数在不同执行流中同时进入运行，其中不可重入指的是一旦重入就有可能会出问题，而可重入就是不管怎么重入都不会有特殊影响

函数不可重入指的是函数中可以在不同的执行流中调用函数会出现数据二义问题
函数可重入指的是函数中可以在不同的执行流中调用函数而不会出现数据二义问题

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

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

理解如下：

函数是否可重入的关键在于函数内部是否对全局数据进行了不受保护的非原子操作，其中原子操作指的是一次完成，中间不会被打断的操作，表示操作过程是安全的

因此如果一个函数中如果对全局数据进行了原子操作，但是因为原子操作本身是不可被打断的，因此是可重入的

3. volatile 关键字

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

int flag = 0;

void change(int signo){
    (void) signo;

    flag = 1;
    printf("change flag 0->1, getpid: %d\n", getpid());
}

int main(){
    printf("I am main process, pid is: %d\n", getpid());
    signal(2, change);

    while(!flag); // 主执行流 -- flag 未做任何修改
    printf("我是正常退出的\n");
}

正常情况下的输出：

进行编译优化：

编译优化的设置：g++ -o @ ^ -Ox ( x = 0 1 2 3 对优化等级的选择）

在优化条件下， flag变量只在读取，可能被直接优化到CPU内的寄存器中
while(!flag); // flag 0, !flag 真逻辑运算

那么有个问题，改 1 优化后为什么就无法退出循环了？

因为优化，导致我们的内存不可见了！

这时添加 volatile 关键字（易变关键字）：

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

此时输出就不一样了

4. SIGCHLD 信号

之前在这篇博客【Linux】进程详解：进程的创建&终止&等待&替换_手动创建进程里面讲过用wait 和 waitpid 函数清理僵尸进程，父进程可以阻塞等待子进程结束，也可以非阻塞地查询是否有子进程结束等待清理 (也就是轮询的方式)

采用第一种方式：父进程阻塞了就不能处理自己的工作了;
采用第二种方式：父进程在处理自己的工作的同时还要时不时地轮询一下，程序实现过于复杂

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

请编写一个程序完成以下功能：父进程 fork 出子进程，子进程调用 exit(2) 终止，父进程自定义 SIGCHLD 信号的处理函数,在其中调用 wait 获得子进程的退出状态并打印。

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

void handler(int signo)
{
    std::cout << "get a sig: " << signo  << " I am :  " << getpid() << std::endl;
    pid_t rid = ::waitpid(-1, nullptr, 0);

    if(rid > 0)
    {
        std::cout << "子进程退出了, 回收成功, child id: " << rid << std::endl;
    }
}


// 1. 验证子进程退出，给父进程发送 SIGCHLD
int main()
{
    signal(SIGCHLD, handler);
    if(fork() == 0){
        sleep(5);
        std::cout << "子进程退出" << std::endl;
        // 子进程
        exit(0);
    }

    while(true){
        sleep(1);
    }
    return 0;
}

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

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

// 1. 验证子进程退出，给父进程发送 SIGCHLD
// 2. 我们可不可以基于信号进行子进程回收呢？
int main()
{

    // Linux 下，将 SIGCHLD 的处理动作置为 SIG_IGN ，这样fork 出来的子进程在终止时候会自动清理掉
    ::signal(SIGCHLD, SIG_IGN);

    for(int i = 0; i < 10; i++)
    {
        if(fork() == 0){
            sleep(5);
            std::cout << "子进程退出" << std::endl;
            // 子进程
            exit(0);
        }
    }

    while(true){
        sleep(1);
    }
    return 0;
}