Linux信号-信号集&信号屏蔽字&捕捉信号【转】

转自：https://blog.csdn.net/Lycorisradiata__/article/details/80096203

一. 阻塞信号

1. 信号的常见其他概念
    实际执行信号的处理动作（3种）称为信号递达；
    信号从产生到递达之间的状态，叫做信号未决；
    进程可以选择阻塞某个信号；
    被阻塞的信号产生时，将保持在未决状态，直至进程取消对该信号的阻塞，才执行递达的动作；
注意：阻塞和忽略是不同的。只要信号阻塞就不会被递达；而忽略是信号在递达之后的一种处理方式。
2. 在内核中的表示
    信号在内核中的表示示意图：

每个信号都有两个标志位分别表示阻塞（block）和未决（pending），还有一个函数指针（handler）表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直至信号递达才清除该标志。操作系统向进程发送信号就是将pending位图中的该信号对应状态位由0变为1。
    如上图，SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作；SIGINT信号产生过，但是正在被阻塞，所以暂时递达不了。虽然它的处理动作是忽略，但是未解除阻塞时不能忽略该信号，因为经常仍有机会改变处理动作后再解除阻塞；SIGQUIT信号未产生过，但是它是阻塞的，所以一旦该信号产生它就被阻塞无法递达，它的处理动作也是用户自定义函数。
    在Linux下，如果进程解除某信号的阻塞之前，该信号产生了很多次，它的处理方法是：若是常规信号，在递达之前多次产生只计一次；若是实时信号，在递达之前产生多次则可以放在一个队列里。本文只讨论常规信号，下面提到的信号都是常规信号。

3. 信号集
        
        从上图我们可以知道，每个信号只有一个bit的未决标志，非0即1，不记录该信号产生了多少次。同样的，阻塞标志也是这样表示的。所以阻塞和未决标志我们可以采用相同的数据类型sigset_t来存储，sigget_t称为信号集。
        这个类型可以表示每个信号的“有效”、“无效”状态。在未决信号集中，“有效”、“无效”表示该信号是否处于未决状态；在阻塞信号集中，“有效”、“无效”表示该信号是否被阻塞。阻塞信号集也叫做当前进程的信号屏蔽字。

4. 信号集操作函数
        sigget_t类型对每一种信号用一个bit表示“有效”或者“无效”状态，至于这个类型内部是怎样储存这些bit则依赖系统实现，从使用者的角度是不用关心的。使用者只用调用以下函数来对sigget_t变量进行操作，而不用对它的内部数据进行任何解释。

其中，前四个函数都是成功返回0，出错返回-1；最后一个sigismember函数包含返回1，不包含返回0，出错返回-1。
注意：在使用sigget_t类型的变量之前，一定要调用sigemptyset函数或者sigfillset函数做初始化，使信号集处于确定的状态。

5. sigprocmask
调用sigprocmask函数可以读取或更改进程的信号屏蔽字（阻塞信号集）。
（1）函数原型：

（2）参数：
        how：有三个可取值（如下图，假设当前信号屏蔽字为mask）

set：指向一个信号集的指针
    oldset：用于备份原来的信号屏蔽字，不想备份时可设置为NULL

1）若set为非空指针，则根据参数how更改进程的信号屏蔽字；
2）若oldset是非空指针，则读取进程当前的信号屏蔽字通过oldset参数传出；
3）若set、oldset都非空，则将原先的信号屏蔽字备份到oldset中，然后根据set和how参数更改信号屏蔽字

（3）返回值：成功返回0，出错返回-1

说明：若调用sigprocmask解除了若干个未决信号的阻塞，则在sigprocmask返回前，至少将其中一个信号递达。

6. sigpending

（1）函数原型：

（2）函数功能：读取当前进程的未决信号集，通过set参数传出
（3）参数：输出型参数，传出数据
（4）返回值：成功返回0，出错返回-1

7.利用以上所介绍函数编写代码使用：
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void printsigset(sigset_t* set)//打印pending表
{
int i = 0;
for(i=1; i<=32; ++i)
{
if(sigismember(set,i))//当前信号在信号集中
putchar('1');
else//当前信号不在信号集中
putchar('0');
}
puts("");//printf("\n");
}

int main()
{
sigset_t s,p;
sigemptyset(&s);//初始化信号集
sigaddset(&s,2);//将2号信号设置为有效信号
sigprocmask(SIG_BLOCK, &s, NULL);//屏蔽2号信号
int i = 10;
while(i--)
{
sigpending(&p);//获取当前进程的未决信号集
printsigset(&p);//打印未决信号集
if(i==7)
{
raise(2);//向本进程发送2号信号
}
if(i == 5)
{
sigprocmask(SIG_UNBLOCK, &s, NULL);//解除对2号信号的屏蔽
printf("recober block bitmap\n");
}
sleep(1);
}
return 0;
}
运行结果为：

可以看到，开始运行时未决信号集中没有有效信号。过3秒后我们向进程发送了一个2号信号，此时未决信号集对应的第二个bit变为1，说明进程有2号信号。到第5秒时，我们解除了对2号信号的屏蔽，此时第三秒产生的2号信号被递达，它的默认处理动作是终止进程，所以此时进程直接终止。

二. 捕捉信号

1. 内核如何实现对信号的捕捉
        在前面的介绍中我们可以知道，当信号的处理动作是自定义函数的时候，在信号递达时就调用这个函数，这称为捕捉信号。内核对信号的捕捉详细过程见下图（进行了四次用户态与内核态的切换）：

说明：信号处理函数与main函数使用不同的堆栈空间，它们之间不存在调用与被调用的关系，是两个独立的控制流程。

2. signal函数
（1）函数原型

（2）函数功能：修改signum信号的处理动作为handler指向的函数
（3）参数：
        signum：表示要捕捉的信号序号
        handler：是一个回调函数，若信号signum产生并且没有被阻塞时，当该信号被递达时，就去执行该回调函数，该回调函数有一个整型参数，表示对哪个信号进行处理。
（4）代码实现：
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int num)//捕捉信号
{
printf("signo is %d\n",num);
return;
}

int main()
{
signal(2,handler);//捕捉2号信号
signal(3,handler);//捕捉3号信号

while(1)
{
printf("this is youngmay\n");
sleep(1);
}
return 0;
}
运行结果：

可以看到，我们由键盘向进程发送的2号和3号信号都被捕捉，而发送的20号信号并未被捕捉，而是执行了它的默认处理动作，让进程暂停了。

3. sigaction函数

（1）函数原型

（2）函数功能：读取和修改与指定信号相关联的处理动作。如果正在执行该信号的处理动作时，又发来了该信号，系统会自动屏蔽该信号，直到执行结束才解除屏蔽

（3）参数：
        signum：指定信号的编号
        act：若非空，则根据它修改该信号的处理动作
        oldact：若非空，则通过它传出该信号原来的处理动作
说明：act、oldact指针指向sigaction结构体，sigaction结构体如下：
struct sigaction {
void (*sa_handler)(int);//信号的处理动作
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;//当正在执行信号处理动作时，希望屏蔽的信号。当处理结束后，自动解除屏蔽
int sa_flags;//一般为0
void (*sa_restorer)(void);
};
（4）返回值：成功返回0，出错返回-1

（5）说明
        将sahandler赋值为常数SIGIGN传给sigsction表示忽略信号；赋值为常数SIG_DFL表示执行系统默认处理动作；赋值为一个函数指针表示用户自定义函数捕捉信号，或者说向内核注册了一个信号处理函数。
（6）代码实现：
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int num)
{
printf("signo is %d\n",num);
return;
}

int main()
{
struct sigaction act,oact;
act.sa_handler = handler;//将信号处理动作设置为信号捕捉
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask,3);//屏蔽3号信号
sigaction(2,&act,&oact);//自定义2号信号的处理动作
sigaction(3,&act,&oact);//自定义3号信号的处理动作
int i = 10;
while(i--)
{
printf("this is youngmay\n");
if(i == 5)
{
sigaction(2,&oact,NULL);//恢复2号信号的默认处理动作
oact.sa_handler = SIG_IGN;//将3号信号的处理动作设为忽略
sigaction(3,&oact,NULL);
}
sleep(1);
}
return 0;
}

运行结果：

可以看到，前五秒内，我们可进程发送2号和3号信号都执行了自定义函数，打印出一句话；在五秒之后，因为3号信号的处理动作设置为了忽略，而2号信号的处理动作设为默认处理动作，所以我们再向进程发送3号信号时无任何反应，而发送2号信号执行了2号信号的默认处理动作直接终止了进程。

4. pause函数
（1）函数原型：

（2）函数功能：使进程挂起等待直到有信号递达。
（3）返回值：只有出错的返回值，返回-1
    若信号的处理动作是终止进程，则进程终止，pause函数没有机会返回；若信号的处理动作是忽略，则进程继续处于挂起等待状态，pause不返回；若信号的处理动作是捕捉，则调用了信号处理函数之后，pause返回-1，errno设置为EINTR（该错误码表示“被信号中断”）。
（4）利用pause函数实现sleep
        我们想实现sleep几秒，我们可以先让进程挂起等待，在几秒之后，向进程发送信号使得它递达，从而让pause出错返回-1（这里信号的处理动作必须设置为捕捉信号，否则pause函数不会返回），从而达到sleep的功能。其中，在几秒之后向进程发送信号使得pause函数出错返回，我们需要用到之前的alarm函数，设置一个闹钟，在几秒之后，让它向进程发送SIGALRM信号。所以，实现我们的mysleep函数，具体步骤如下：
   
     1）将SIGALRM信号的处理动作设置为自定义动作；
     2）调用alarm函数设置闹钟；
     3）调用pause函数等待；
     4）alarm（0）取消闹钟（在（3）中pause可能被其他信号唤醒，所以要取消闹钟返回闹钟剩余的秒数）；
     5）恢复SIGALRM信号的原有处理动作；
     6）返回剩余的秒数；
实现代码如下：
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void handler(int num)
{
;
}

unsigned int mysleep(unsigned int t)
{
struct sigaction act,oact;//act为要设置闹钟信号的相关信息，oact保存闹钟信号>的原有相关信息
act.sa_handler = handler;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);//处理闹钟信号时，不屏蔽其他信号
sigaction(SIGALRM,&act,&oact);//捕捉闹钟信号

alarm(t);//t秒之后向进程发送闹钟信号
pause();//使进程挂起等待
int ret = alarm(0);//取消闹钟,返回闹钟剩余秒数
sigaction(SIGALRM,&oact,NULL);//恢复闹钟的默认处理动作
return ret;//返回闹钟剩下的时间
}

int main()
{
while(1)
{
printf("hi,i am youngmay\n");
mysleep(1);
}
return 0;
}
运行结果为：

程序跑起来之后，每隔一秒，都会打印出一句话。说明我们自己实习的mysleep函数实现了sleep函数的功能。
我们可以验证一下mysleep函数的返回值是否为闹钟剩下的秒数，修改代码如下：
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int num)
{
printf("signo is %d\n",num);
return;
}

unsigned int mysleep(unsigned int t)
{
struct sigaction act,oact;//act为要设置闹钟信号的相关信息，oact保存闹钟信号>的原有相关信息
act.sa_handler = handler;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);//处理闹钟信号时，不屏蔽其他信号
sigaction(SIGALRM,&act,&oact);//捕捉闹钟信号

alarm(t);//t秒之后向进程发送闹钟信号
pause();//使进程挂起等待
int ret = alarm(0);//取消闹钟,返回闹钟剩余秒数
sigaction(SIGALRM,&oact,NULL);//恢复闹钟的默认处理动作
return ret;//返回闹钟剩下的时间
}

int main()
{
signal(2,handler);//将2号信号的处理动作改为自定义函数
printf("hello\n");
unsigned int ret = mysleep(20);
printf("return ret is %d\n",ret);
return 0;
}
运行结果如下：

在程序运行起来过两秒，我们由键盘给进程发送ctrl+c命令，即向进程发送2号信号，可以看到mysleep函数的返回值为18即闹钟剩余的时间。
说明：
（1）在mysleep程序中注册SIGALRM的自定义处理函数，是为了使pause出错返回，使进程从挂起状态醒来。因为如果不注册该函数，SIGALRM信号的默认处理动作是终止进程，所以在几秒后，进程会直接终止而不是醒来继续执行后面的语句。而在处理函数中什么都没做，是因为sleep函数在让进程挂起等待时也什么都没做。

（2）mysleep中再返回前恢复SIGALRM信号的原有处理动作，是因为在mysleep结束后，进程结束前，如果再次发送SIGALRM信号本意是想终止进程，但因为SIGALRM信号是自定义处理动作，导致进程不终止，这样达不到我们的预期。我们也可以将恢复SIGALRM信号的默认处理动作认为是：你借了别人的东西用，在用完之后，你要将东西给人家还回去，不能影响其他人的使用。

（3）mysleep函数的返回值与sleep函数的返回值作用一致。
---------------------
作者：_满舒克的喵
来源：CSDN
原文：https://blog.csdn.net/Lycorisradiata__/article/details/80096203
版权声明：本文为博主原创文章，转载请附上博文链接！