Linux信号机制探析--信号的处理

🍑个人主页：Jupiter. 🚀 所属专栏：Linux从入门到进阶 欢迎大家点赞收藏评论😊

在这里插入图片描述

`🍑信号处理`

`信号处理常见方式概览`

可选的处理动作有以下三种:

默认处理动作。
忽略此信号。
自定义处理信号–捕捉 。提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数。

信号是在什么时候被处理的？

进程从内核态切换到用户态的时候，信号会被检测并处理。

`🍒内核如何实现信号的捕捉`

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码是在用户空间的,处理过程比较复杂,举例如下：

用户程序注册了SIGQUIT信号的处理函数sighandler。当前正在执行main函数,这时发生中断或异常切换到内核态。在中断处理完毕后要返回用户态的main函数之前 检查到有信号SIGQUIT递达。 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是两个独立的控制流程。 sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。
信号捕捉的过程可以用一个♾️简略表示，其中交点就会信号检测，如下图所示，如果拉根横线，与♾️的四个交点，也就是在信号处理过程中（信号捕捉），有四次用户态与内核态的切换，横线的上面是用户态，下面是内核态。

`🍎内核态与用户态`

我们之前所说的页表，实际上是用户级页表，是进程地址空间中的用户空间与对应物理内存的映射关系，其中，还有一个内核级页表，是进程地址空间中的内核空间与对应物理内存的映射关系，系统中第一个被加载的软件是操作系统，将操作系统加载到物理内存后，为了用户将来能够以受保护的状态的访问操作系统（内核数据），必须把操作系统 映射到进程地址空间的内核空间中，以后进程如果想要访问操作系统的数据，如一些系统调用，通过进程的地址空间中内核空间即可，所以，我们使用系统调用或则访问系统数据，其实还是在进程的地址空间内进行跳转的！

使用系统调用或则访问系统数据，是在进程的地址空间内进行跳转的，如果不加以限制，那么用户就可以随便访问内核数据了，所以就引入了用户态与内核态。当在访问内核空间的时候，会进行运行模式检测，只有在是内核态才可以访问，否则不行。

系统中存在多个进程，但是OS只有一份，所有的进程要映射内核空间，只需要共用同一个内核级页表即可，所以进程无论怎么切换，总能找到操作系统。

在这里插入图片描述

`操作系统是如何正常运行的(了解)`

是通过以非常高的频率，每隔非常短的时间，就给CPU发送中断号（假设是2），CPU不断处理中断，拿着中断号，在中断向量表（其中开机的时候，OS提供的）中找到对应的处理方法并执行。这个中断称为OS的周期时钟中断。

`🎈sigaction`

函数原型：

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

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函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非空,则通过oact传出该信号原来的处理动作。
将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。

当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止。如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_ﬂags字段包含一些选项,本章的代码都把sa_ﬂags设为0,sa_sigaction是实时信号的处理函数,本章不详细解释这两个字段。

示例代码：

void handler(int signo)
{
    std::cout << "signal : " << signo << std::endl;
    
}

int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask); 

    //在在调用信号处理函数的时候同时将3，4，5号信号屏蔽
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);
    sigaddset(&act.sa_mask, 5);

    sigaction(2, &act, &oact); //自定义捕捉2号信号
 
    while(true) sleep(1);  //循环的时候给该进程发送2号信号验证

    return 0;
}

`🌾可重入函数`

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

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

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

`🌽SIGCHLD信号`

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

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

void CleanupChild(int signo)
{
    if (signo == SIGCHLD)
    {
        pid_t rid = waitpid(-1, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait child success: " << rid << std::endl;
        }
    }
    std::cout << "wait sub process done" << std::endl;
}

int main()
{
    signal(SIGCHLD, CleanupChild);

    pid_t id = fork();
    if (id == 0)
    {
        // child
        std::cout << "child process died" << std::endl;
        exit(2);
    }
    // father
    while (true)
        sleep(1);
    
    return 0;
}

对于上面的代码，只有一个子进程，那如果一共有100个子进程呢，并且全部一起退出，意思就是100子进程都会同时向父进程发送SIGCHLD信号，可能父进程来不及处理，在子进程回收子进程的时候，也会回收部分，剩下的就没有被回收。
那么像上面的问题怎么解决呢？

解决方法：循环等待

void CleanupChild(int signo)
{
    if (signo == SIGCHLD)
    {
        while (true)
        {
            pid_t rid = waitpid(-1, nullptr, 0); // -1 : 回收任意一个子进程
            if (rid > 0)
            {
                std::cout << "wait child success: " << rid << std::endl;
            }
            else if(rid <= 0) break;
        }
    }
}

那么问题又来了，要是100子进程，只退出50个子进程呢？如果还是使用上面的代码的话，50个进程退出后，后面50个子进程根本没有退出，这时候循环里面调用waitpid就阻塞了，如果后面50个子进程再也不退的话，就会一直在信号捕捉的方法中不会返回了，就回不到主进程了，主进程就丢失了。解决方法：非阻塞等待即可。上面代码改为 waitpid(-1, nullptr, WNOAHG)即可。

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

int main()
{
    signal(SIGCHLD, SIG_IGN);

    for (int i = 0; i < 100; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            std::cout << "child process died" << std::endl;
            exit(0);
        }
    }
    while (true) sleep(1);
    
    return 0;
}