Linux信号的保存和处理

南桥

发布于 2024-07-26 12:50:37

270

发布于 2024-07-26 12:50:37

文章被收录于专栏：南桥谈编程

信号的保存

信号其他常见概念

实际执行信号的处理动作称为信号递达(Delivery)：

默认
忽略
自定义捕捉

信号从产生到递达之间的状态,称为信号未决(Pending)。阻塞一个信号，那么对应的信号一旦产生一到不递达，一直未决，直到主动解除阻塞。如果一个宿舍处于阻塞状态，和它有没有未决有没有关系？没有关系，
被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

信号在内存中的表示

信号在内核中的表示示意图：

每一个信号都有着三张表：block、pending、handler。 两张位图+一张函数指针数组=进程识别信号

pending是一个未决信号集，是一个有着32位比特位的位图，比特位的位置代表信号编号，比特位的内容代表信号是否收到

在signal函数中：

sighandler_t signal(int signum, sighandler_t handler);

sighandler_t handler[32]本质上是一个函数指针数组，向函数传入某一个编号，就是数组的可以采用信号编号索引信号处理方法。

block也是一张位图，有32个比特位，比特位的位置代表信号的编号，比特位的内容代表的是信号是否阻塞。

每个信号都有两个标志位分别表示阻塞和未决(pending),还有一个函数指针表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。

SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。

SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。

sigset_t类型

未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

#ifndef ____sigset_t_defined
#define ____sigset_t_defined

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
  unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;

#endif

信号集操作函数

sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态,至于这个类型内部如何存储这些bit则依赖于系统实现,从使用者的角度是不必关心的,使用者只能调用以下函数来操作sigset_ t变量,而不应该对它的内部数据做任何解释,比如用printf直接打印sigset_t变量是没有意义的。

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset (sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember（const sigset_t *set, int signo);

sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

how参数的可选值：

set：指向一个 sigset_t 类型的指针，这是一个信号集合，用于指定要添加、移除或替换的信号。

oldset：如果不是 NULL，则 oldset 指向的位置用来存储之前的信号屏蔽字，即在调用 sigprocmask 之前当前进程的信号屏蔽字的状态。

sigpending

作用是检查pending信号集，获取当前进程的pending的位图。

#include <signal.h>
int sigpending(sigset_t *set);

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

案例测试

场景：将2号信号屏蔽，再给当前进程发送2号信号，但是2号信号已经被屏蔽，发完之后不断获取当前进程的pending表，就可以看到2号信号被屏蔽的效果。

void PrintfPending(sigset_t &pending)
{
    std::cout<<"curr process["<<getpid()<<"] pending:";
    for(int signo=31;signo>=1;signo--)
    {
        if(sigismember(&pending,signo))
        {
            std::cout<<1;
        }
        else 
        {
            std::cout<<0;
        }
    }
    std::cout<<std::endl;
}

int main()
{
    //1.屏蔽2号信号
    sigset_t block_set,old_set;
    sigemptyset(&block_set);
    sigemptyset(&old_set);
    sigaddset(&block_set,SIGINT);
    //1.1设置进入进程的Block表中
    sigprocmask(SIG_BLOCK,&block_set,&old_set);
    //至此完成对2号信号屏蔽

    while(1)
    {
        //2.获取当前信号的pending信号集
        sigset_t pending;
        sigpending(&pending);
        
        //3.打印pending信号集
        PrintfPending(pending);
        sleep(1);
    }

    return 0;
}

可以发现，当我向当前进程发送2号信号时，pending发生了变化，可以观察到2号信号被屏蔽了。

如果解除对2号信号的屏蔽，那么2号信号就可以递达，此时的代码和运行结果如下：

void PrintfPending(sigset_t &pending)
{
    std::cout<<"curr process["<<getpid()<<"] pending:";
    for(int signo=31;signo>=1;signo--)
    {
        if(sigismember(&pending,signo))
        {
            std::cout<<1;
        }
        else 
        {
            std::cout<<0;
        }
    }
    std::cout<<std::endl;
}

int main()
{
    //1.屏蔽2号信号
    sigset_t block_set,old_set;
    sigemptyset(&block_set);
    sigemptyset(&old_set);
    sigaddset(&block_set,SIGINT);
    //1.1设置进入进程的Block表中
    sigprocmask(SIG_BLOCK,&block_set,&old_set);
    //至此完成对2号信号屏蔽

    int cnt=10;
    while(1)
    {
        //2.获取当前信号的pending信号集
        sigset_t pending;
        sigpending(&pending);
        
        //3.打印pending信号集
        PrintfPending(pending);
        cnt--;
        //4.解除屏蔽
        if(cnt==0)
        {
            std::cout<<"解除2号信号的屏蔽"<<std::endl;
            sigprocmask(SIG_SETMASK,&old_set,&block_set);

        }
        
        sleep(1);

    }

    return 0;
}

运行结果：

运行10秒之后，2号信号恢复屏蔽，但是pending并没有再去打印，是因为2号信号执行默认动作，终止程序。可以通过自定义捕捉2号信号来观察恢复屏蔽的现象。

注意：

解除屏蔽一般会立即处理当前被解除的信号
在递达之前，pending位图对应的信号被清0

信号的处理

处理信号就是递达信号，在上面我们处理信号使用的是signal函数：

signal(2,handler);  //自定义
signal(2,SIG_IGN);  //忽略
signal(2,SIG_DFL);  //默认

信号可能不会被立即处理而是在合适的时候（进程从内核态返回到用户态的时候）处理。

信号的捕捉过程

第三步是进行检查的操作，如果此时的pending对应为1，block对应为0，再去看handler对应为SIG_DFL，执行默认的动作，执行完后直接将pending置为0即可。但是当handler是用户自定义的操作时，就需要再回到用户定义的操作，然后再回到内核。

如果操作系统发现是用户自定义捕捉，操作系统能不能直接去执行用户的handler方法？从技术角度是可以的，但是不能让操作系统直接执行hanlder的方法，因为这是用户提供的，如果直接执行用户，那么用户就绕过了权限制度。

内核态VS用户态

再谈地址空间

以32为地址空间为例，整个地址地址空间中，0G ~ 3G是给用户使用的，3G ~ 4G是给操作系统的。

电脑在刚开机时，操作系统是第一个加载到内存中的软件，在内核空间对应的有一个内核级页表，指向物理内存中的操作系统，也就是说操作系统本身就在进程的地址空间中。

不同进程有自己的用户级页表和虚拟地址，但是只有一个内核级页表。总的来说，有多个用户级页表，但是只有一份内核级页表。无论进程如何切换，总能找到操作系统。

用户访问操作系统，本质上还是在用户的地址空间中进行的，和访问库函数没有区别。操作系统不相信任何用户，用户在访问3G ~ 4G的地址空间时会受到一定的约束。

键盘输入数据的过程

先看硬件： CPU不会和键盘等外设打交道，键盘通过芯片会向CPU发送一个硬件中断（是硬件结构），键盘有自己的中断号，键盘会给CPU的针脚发送高电平，此时CPU就会读取中断号，将中断号放在寄存器中，中断号就会变成寄存器中的数据，完后就可以用软件来操作。

再谈软件：计算机中第一款软件是操作系统，操作系统需要在内存中先初始化一个函数指针数组，里面会有很多操作系统的方法，例如读磁盘、读网卡等，其中每一个设备有自己的中断号，中断号对应数组下标，这些都是操作系统提前完成的。 CPU将寄存器里的值在函数指针数组中索引，CPU会执行读取键盘方法，读取到内存的指定区。另外这个函数指针数组在硬件层面上叫做中断向量表。

如何理解操作系统如何正常运行

操作系统的本质是一个死循环+时钟中断，不断调度系统调用。

如何执行系统调用？操作系统会提供一个系统调用表，它是一个函数指针数组，我们只要找到特定数组下标）系统调用号）的方法，就能执行系统调用。在CPU内部会存在两个寄存器，当用户在进行系统调用时，会将系统调用号放在寄存器中，内部会执行一个中断，操作系统内部会形成一个中断号。

内核和用户

在Linux操作系统中，用户态（User Mode）和内核态（Kernel Mode）是两种不同的执行级别，它们定义了程序（包括操作系统内核和用户程序）的权限和访问资源的能力。下面是对这两种模式的详细解释：

用户态（User Mode）：用户态是较低权限的执行级别，通常用于运行用户应用程序。在用户态下，程序只能访问有限的资源，并且不能直接访问硬件设备。用户态程序需要通过系统调用（System Call）请求操作系统内核提供服务，如文件操作、网络通信等。用户态程序受到操作系统的保护，不能执行可能会损害系统的指令，例如直接访问内存地址或修改控制寄存器。
内核态（Kernel Mode）：内核态是较高权限的执行级别，通常由操作系统内核在执行系统级任务时使用。在内核态下，程序可以访问所有硬件资源和执行所有指令，包括那些在用户态下被限制的指令。内核态程序可以执行如内存管理、进程调度、设备驱动等核心功能。内核态程序可以直接与硬件交互，但同时也更容易受到错误或恶意代码的影响，因此内核态的代码需要非常谨慎地编写和测试。
状态转换：用户程序通常在用户态下运行，当需要操作系统提供的服务时，它会通过系统调用请求内核态的服务。系统调用会触发一个上下文切换，将程序从用户态切换到内核态，执行所需的服务后，再切换回用户态。如果用户程序试图执行非法操作，操作系统可能会将其终止并返回错误信息。

也就是说内核态是操作系统的状态，用户态是用户对于的状态

实现信号捕捉

之前介绍过signal函数，现在不再介绍

sigaction

#include <signal.h>

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

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传出该信号原来的处理动作。act和oact指向sigaction结构体。

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

实例：当前如果正在对2号信号进行处理，默认2号信号会被自动屏蔽，对2号信号处理完成的时候，会自动解除对2号信号的屏蔽。

void Print(sigset_t &pending)
{
    for(int sig = 31; sig > 0; sig--)
    {
        if(sigismember(&pending, sig))
        {
            std::cout << 1;
        }
        else
        {
            std::cout << 0;
        }
    }
    std::cout << std::endl;
}

void handler(int signum)
{
    std::cout << "get a sig: " << signum << std::endl;
    while(true)
    {
        sigset_t pending;
        sigpending(&pending);

        Print(pending);

        sleep(1);
        // sleep(30);
        // break;
    }
    // exit(1);
}

int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    sigemptyset(&act.sa_mask); // 如果你还想处理2号(OS对2号自动屏蔽)，同时对其他信号也进行屏蔽
    sigaddset(&act.sa_mask, 3);
    act.sa_flags = 0;

    for(int i = 0; i <= 31; i++)  // 对所有信号进行屏蔽是不被系统允许的！！
        sigaction(i, &act, &oact);

    while(true)
    {
        std::cout << "I am a process, pid: " << getpid() << std::endl;
        sleep(1);
    }
    return 0;
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-07-26，如有侵权请联系 cloudcommunity@tencent.com 删除

linux