处理 Linux 信号：进程控制与异常管理的核心

个人主页：chian-ocean

文章专栏-Linux

前言：

在 Linux 操作系统中，信号是用于进程间通信的一种机制，能够向进程发送通知，指示某些事件的发生。信号通常由操作系统内核、硬件中断或其他进程发送。接收和处理信号是 Linux 系统中进程控制和资源管理的一个重要组成部分。

信号的保存

信号递送（Delivery）

• 信号的处理动作称为信号递送（Delivery）。
  • 这意味着在 Linux 系统中，当信号发生时，它会被传递到目标进程并执行相应的操作。递送是信号处理的第一步，是信号机制中至关重要的一部分。

2. 信号未决（Pending）

• 信号从产生到递送之间的状态，称为信号未决（Pending）。

  • 当信号发送到一个进程，但该进程因某些原因（如信号被屏蔽或进程正在执行其他操作）暂时无法处理信号时，这个信号就会处于未决状态，等待后续处理。

• Linux内核是通过一个一个位图编标记信号，进而储存信号

• block 位图（通常是一个 sigset_t 类型的数据结构）用于记录当前进程被阻塞的信号。每一位代表一个特定的信号，当该位被设置为1时，表示该信号处于被阻塞状态；如果该位是0，则表示该信号未被阻塞，可以递送给进程。
• pending 位图（Pending Bitmap）用于记录进程中待处理的信号。位图是一个位数组，其中每个比特代表一个信号的状态（是否待处理）。
• headler代表的是该信号所需要用的方法。

sigset_t

定义：

sigset_t 是一个适用于信号管理的基本数据类型，通常在头文件 <signal.h> 中定义。它的具体实现依赖于系统，但通常是一个位图或位集合，每一位表示一个信号的状态（是否被屏蔽、是否待处理等）。

sigset_t 的用途

• 信号屏蔽：用于设置进程的信号掩码（signal mask），即哪些信号被屏蔽，不允许递送。例如，通过 sigprocmask 函数修改信号掩码。
• 信号检查：通过 sigpending() 函数检查进程是否有待处理的信号。
• 信号操作：例如，sigaddset() 和 sigdelset() 等函数可以用来向信号集添加或移除特定信号

常用函数与 sigset_t 的操作

在 Linux 系统中，sigset_t 是一个数据类型，用于表示信号集，通常用于管理信号的掩码。它用于存储一个进程中多个信号的集合，可以用来表示进程阻塞的信号、待处理的信号等。

sigset_t 类型定义

sigset_t 是一个适用于信号管理的基本数据类型，通常在头文件 <signal.h> 中定义。它的具体实现依赖于系统，但通常是一个位图或位集合，每一位表示一个信号的状态（是否被屏蔽、是否待处理等）。

sigset_t 的用途

sigset_t 主要用于以下几个方面：

• 信号屏蔽：用于设置进程的信号掩码（signal mask），即哪些信号被屏蔽，不允许递送。例如，通过 sigprocmask 函数修改信号掩码。
• 信号检查：通过 sigpending() 函数检查进程是否有待处理的信号。
• 信号操作：例如，sigaddset() 和 sigdelset() 等函数可以用来向信号集添加或移除特定信号。

sigset_t 的操作

以下是一些与 sigset_t 相关的常见操作函数：

• sigemptyset(sigset_t ,*set)： 初始化一个空的信号集（即不包含任何信号）。

  sigset_t set;
  sigemptyset(&set); // 将 set 设为空信号集
  

• sigfillset(sigset_t ,*set)： 初始化一个包含所有信号的信号集。

  sigset_t set;
  sigfillset(&set); // 将 set 设为包含所有信号的信号集
  

• sigaddset(sigset_t ,*set, int signo)： 将指定的信号添加到信号集。

  sigset_t set;
  sigemptyset(&set);
  sigaddset(&set, SIGINT); // 将 SIGINT 添加到 set 中
  

• sigdelset(sigset_t ,*set, int signo)： 从信号集移除指定的信号。

  sigdelset(&set, SIGINT); // 从 set 中删除 SIGINT
  

• sigismember(const sigset_t ,*set, int signo)： 检查指定的信号是否在信号集中。

  if (sigismember(&set, SIGINT)) {
      // 如果 SIGINT 在 set 集合中
  }
  

控制sigset_t常见函数

sigprocmask(int how, const sigset_t ,*set, sigset_t ,*oldset)： 修改进程的信号掩码（即屏蔽哪些信号）。

• sigismember(const sigset_t ,*set, int signo)： 检查指定的信号是否在信号集中。

  if (sigismember(&set, SIGINT)) {
      // 如果 SIGINT 在 set 集合中
  }
  

  • how:

    参数控制信号掩码的设置方式：

    • SIG_BLOCK：把 set中的信号添加到 blocked中(blocked= blocked | set)。
    • SIG_UNBLOCK：从 blocked中删除 set中的信号(blocked= blocked & set)。
    • SIG_SETMASK：block= set

  sigset_t set, oldset;
  sigemptyset(&set);
  sigaddset(&set, SIGINT);
  sigprocmask(SIG_BLOCK, &set, &oldset); // 阻塞 SIGINT
  

• sigpending(sigset_t g*set)： 获取当前进程的未决信号集，返回一个信号集，表示所有尚未被处理的信号。

  sigset_t set;
  sigpending(&set); // 获取当前进程的待处理信号
  

屏蔽字的实例

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

// 函数：用于打印信号集中的信号状态
void pendingprint(sigset_t &pending)
{
    // 遍历信号集中的每个信号，从31到1（Linux支持的信号范围通常是1到31）
    for(int i = 31; i >= 1; i--)
    {
        // 检查信号集pending中是否包含第i个信号
        if (sigismember(&pending, i))
        {
            std::cout << "1";  // 如果信号存在，打印"1"
        }
        else
        {
            std::cout << "0";  // 如果信号不存在，打印"0"
        }
    }
    std::cout << "\n";  // 换行打印结果
}

int main()
{
    // 定义信号集，用于保存信号掩码、旧掩码和待处理信号集
    sigset_t mask, old_mask;
    sigset_t pending;

    // 初始化信号集mask为空信号集
    sigemptyset(&mask);

    // 将SIGINT信号（Ctrl+C触发的中断信号）添加到信号集mask中
    sigaddset(&mask, SIGINT);

    // 将SIGINT信号添加到当前进程的信号掩码中，即阻塞SIGINT信号
    // 并保存原来的信号掩码到old_mask中
    sigprocmask(SIG_BLOCK, &mask, &old_mask);
    
    int cnt = 0;
    while(true)
    {
        // 获取当前进程的待处理信号集，并保存在pending中
        sigpending(&pending);

        // 调用pendingprint函数，打印待处理信号集中的信号
        pendingprint(pending);

        // 每次睡眠1秒钟
        sleep(1);

        // 计数器，每次增加1
        if(++cnt == 5)
        {
            // 在第20次循环时，解除阻塞SIGINT信号
            std::cout << "SIGINT UNLOCK" << std::endl;

            // 恢复之前的信号掩码，即解除对SIGINT信号的阻塞
            sigprocmask(SIG_SETMASK, &old_mask, NULL);
        }
    }
    std::cout << "QUIT..." << std::endl;

    return 0;
}

• 代码中我会每秒打印penging中的数据
• 第三秒中的时候，像进程发送2好信号，penging中会显示为处理的信号，在bolck中该信号被阻塞，也就是被屏蔽。
• 代码执行第五秒中的时候，进程阻塞信号解除，由于penging中有未处理的信号，就会执行2好号信号。

信号的捕捉

信号捕捉的时机

1. 进程是否正在执行系统调用。
2. 进程是否在空闲状态（如调用 sleep()）。
3. 信号是否被发送。
4. 信号是否被阻塞或保留直到适当时机。
5. 信号是否导致进程退出或崩溃时处理。

信号执行的流程

• 用户模式：进程在用户模式下执行，直到某个信号因中断、异常或系统调用被触发。
• 内核模式：当信号被触发时，操作系统切换到内核模式，进行信号的处理。内核会完成信号的处理并准备将进程返回到用户模式之前的状态。
• 信号处理：在信号处理过程中，内核会调用信号处理函数（如 do_signal()）。如果信号需要对用户指定的特定处理，系统会在信号处理时调用相应的函数。
• 处理返回：信号处理函数执行完毕后，操作系统会通过 sigreturn 系统调用返回到用户模式。
• 恢复执行：操作系统恢复用户模式下的程序执行，从中断的地方继续执行。

用户态和内核态的切换

用户态到内核态：

• 触发方式：通过系统调用（如read(), write()）或硬件中断（如键盘中断）。
• 过程：
  • 当用户程序调用系统调用时，会执行一个软中断（例如x86的int 0x80指令）。
  • 内核会保存当前用户程序的上下文（如程序计数器、堆栈指针等），并设置内核模式。
  • 进入内核代码执行，执行完后，准备返回用户态。

内核态到用户态：

• 触发方式：内核任务完成后，需要返回用户程序继续执行。
• 过程：
  • 内核将处理结果返回用户进程，并恢复用户进程的上下文。
  • 恢复用户态的堆栈指针、程序计数器等寄存器，并将程序从内核模式切换回用户模式。
  • 继续执行用户进程。

sigaction

• sigaction是处理粒度更加强大的一个系统调用。

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

参数：

• signum：指定信号的编号（例如，SIGINT、SIGTERM 等）。
• act：指向 struct sigaction 结构体的指针，用于指定新的信号处理程序及其设置。
• oldact：指向 struct sigaction 结构体的指针，用于保存之前的信号处理程序（可选）。如果不关心旧的处理程序，可以传递 NULL。

返回值：

• 成功时，返回 0。
• 失败时，返回 -1 并设置 errno。

struct sigaction {
    void (*sa_handler)(int);   // 信号处理函数
    void (*sa_sigaction)(int, siginfo_t *, void *);  // 备用信号处理函数
    sigset_t sa_mask;           // 用于指定在信号处理期间要阻塞的信号
    int sa_flags;               // 信号处理行为的标志
    void (*sa_restorer)(void);  // 不常用，保留字段
};

代码示例：

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

// 信号处理函数，当捕获到信号时执行
void headler(int signo)
{
    // 输出捕获到的信号类型
    std::cout << "catch signal --- signo :" << signo << std::endl;
    sleep(4);
    // 退出程序，返回 1 作为退出状态
    exit(1);
}

int main()
{   
    // 定义 sigaction 结构体，用于设置新的信号处理行为 (sa) 和保存旧的信号处理行为 (osa)
    struct sigaction sa, osa;
    
    // 使用 memset 将结构体清零，确保结构体中的字段没有未初始化的值
    memset(&sa, 0, sizeof(sa));
    memset(&osa, 0, sizeof(osa));

    // 清空信号集，准备设置信号屏蔽
    sigemptyset(&sa.sa_mask);
    // 将 SIGINT 信号添加到屏蔽信号集中，意思是处理 SIGINT 时，其他信号会被阻塞
    sigaddset(&sa.sa_mask, SIGINT);

    // 设置自定义的信号处理函数，当 SIGINT 信号触发时，调用 headler 函数
    sa.sa_handler = headler;

    // 注册信号处理函数，绑定 SIGINT 信号与信号处理函数 headler，同时保存原来的信号处理方式
    sigaction(SIGINT, &sa, &osa);

    // 进入一个无限循环，模拟进程运行
    while (true)
    {
        // 输出当前进程的 pid，表示进程正在运行
        std::cout << "Process Running ...: pid: " << getpid() << std::endl;
        // 每 1 秒输出一次，模拟进程持续运行
        sleep(1);
    }

    return 0;
}

信号处理函数 headler：

• 该函数定义了如何处理接收到的 SIGINT 信号。当捕获到 SIGINT 信号时，会输出信号编号，然后模拟处理过程（休眠 4秒），最后退出程序并返回状态码 1。

信号处理结构体 sigaction：

• sigaction 是用来定义和控制信号处理方式的结构体。通过它可以设置信号的处理函数、信号掩码等信息。
• 通过 memset 清空结构体，确保没有未初始化的字段。
• 使用 sigemptyset 和 sigaddset 配置信号屏蔽集，指定在处理 SIGINT 时，阻塞其他信号（在本例中，仅阻塞 SIGINT 自身）。

sigaction 调用：

• sigaction(SIGINT, &sa, &osa) 设置 SIGINT 信号的处理程序为 headler，并保存原来的信号处理方式（虽然在这里我们没有使用 osa 来恢复原处理方式）。

进程运行：

• 进入无限循环 while(true)，打印当前进程的 pid（进程 ID），模拟一个长时间运行的进程。
• 每秒输出一次进程信息，并通过 sleep(1) 使程序每秒钟暂停一次。

信号捕获时期的相关问题

• 信号递归：信号处理期间默认屏蔽当前信号，避免递归调用。

void headler(int signo)
{
    int cnt  = 20;
    while(cnt --)
    {
        std::cout << "catch signal --- signo :" << signo <<std:: endl;
        sleep(1);
    }
    exit(1);
}

1. 在这里面headler方法进行循环,并且休眠一秒，在此期间持续像进发送2号信号。

2. 同时可以及逆行进行多信号屏蔽。

sigaddset(&sa.sa_mask,1);
sigaddset(&sa.sa_mask,3);
sigaddset(&sa.sa_mask,4);

• 信号丢失：如果信号未及时处理，可能丢失，尤其是长时间阻塞时。
• 系统调用中断：信号可能中断系统调用，导致 EINTR 错误。
• 信号屏蔽问题：如果未正确设置信号掩码，可能导致信号被过多屏蔽或错误处理。

信号pending表的处理时机

• 信号在调用处理方法之前会被制空

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

// 声明一个全局的 sigset_t 变量，用于保存挂起的信号
sigset_t pending;

// 打印挂起信号的状态（1表示挂起，0表示没有挂起）
void PrintPending()
{
    sigset_t set;
    sigpending(&set);  // 获取当前挂起的信号集合

    // 遍历信号编号，打印每个信号的状态
    for (int signo = 31; signo >= 1; signo--)
    {
        if (sigismember(&set, signo))  // 检查该信号是否在挂起集合中
            std::cout << "1";  // 如果挂起，打印 1
        else
            std::cout << "0";  // 如果没有挂起，打印 0
    }
    std::cout << "\n";  // 输出换行
}

// 信号处理程序
void headler(int signo)
{
    int cnt = 5;  // 设置循环次数为 5
    while (cnt--)  // 每次处理信号时，循环 5 次
    {
        PrintPending();  // 打印当前挂起的信号状态
        sleep(1);  // 休眠 1 秒，模拟信号处理的过程
        std::cout << "catch signal --- signo :" << signo << std::endl;  // 输出捕获到的信号编号
    }
    exit(1);  // 信号处理完毕后退出程序
}

int main()
{
    signal(SIGINT, headler);  // 设置 SIGINT 信号的处理函数为 headler

    sigset_t mask, old_mask;
        
    sigemptyset(&mask);  // 初始化信号集 mask，清空所有信号
    sigaddset(&mask, SIGINT);  // 将 SIGINT 信号加入到 mask 中，表示屏蔽 SIGINT 信号

    sigprocmask(SIG_BLOCK, &mask, &old_mask);  // 阻塞 SIGINT 信号，并保存原信号掩码到 old_mask
    
    int cnt = 1;
    while (true)
    {
        sigpending(&pending);  // 获取当前挂起的信号
        PrintPending();  // 打印挂起信号的状态
        sleep(1);  // 程序每秒输出一次状态
        cnt++;  // 计数器加 1
        std::cout << "Process Running ...: pid: " << getpid() << std::endl;  // 输出当前进程的 PID
        
        if (cnt % 5 == 0)  // 每经过 5 次循环
        {
            PrintPending();  // 再次打印挂起信号的状态
            sleep(1);  // 休眠 1 秒
            std::cout << "SIGINT UNLOCK" << std::endl;  // 输出解锁 SIGINT 信号的提示
            sigprocmask(SIG_SETMASK, &old_mask, NULL);  // 恢复原来的信号掩码，解除对 SIGINT 的阻塞
        }
    }

    std::cout << "QUIT..." << std::endl;  // 输出退出提示

    return 0;
}

• 程序启动后，会阻塞 SIGINT 信号。
• 每秒钟，程序打印当前进程的 PID 和挂起的信号状态。
• 每经过 5 次循环，解除对 SIGINT 信号的阻塞，允许信号被捕获并处理。
• 捕获到 SIGINT 信号后，headler 会打印挂起信号状态，处理信号并退出。