Linux信号集

在上一篇文章中，我们已经介绍了Linux中有关进程信号的一些基础知识，现在，我们再来看一下在一个进程中，如何阻塞信号，以及如何在内核中捕捉信号。
Linux信号概念https://blog.csdn.net/aaronlanni/article/details/79794665
一、阻塞信号
1、信号与其相关概念

• 实际执行信号的处理动作称为信号递达(Delivery)
• 信号从产生到递达之间的状态,称为信号未决(Pending)。
• 进程可以选择阻塞 (Block )某个信号。
• 被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
• 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作
  2、表示方式
  
  总结：
  每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针表示处理动作。
  信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。
  在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。 SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。 SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动 作是用户⾃自定义函数。
  如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX允许系统递送该信号一次或多次。
  Linux是这样实现的:常规信号在递达之前产生多次只计⼀次,而实时信号在递达之前产生多次可以依次放在一个队列⾥。
  因此，总结上面一段话可以得出，普通信号（1~31号）允许在递达之前丢失。而实时信号（34~64号）不允许丢失。
  3、位图说明(sigset_t)—-信号集
  从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。 因此,未决和阻塞标志可以用相同的数据类型sigset_t 来存储 ,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态.阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略。
  4、有关信号集的操作函数
  sigsett 类型对于每种信号用一个 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 signum);//往信号集中增添信号 
 int sigdelset(sigset_t *set, int signum);//从信号集中删除某个信号
 int sigismember(const sigset_t *set, int signum);//检测信号是否在信号集中 
  // sigemptyset(), sigfillset(), sigaddset(), and sigdelset()这些函数均是成功返回0，失败返回-1 
  //sigismember()是一个布尔函数，如果某种信号在信号集中，则返回1，没在信号集中返回0，出错返回-1 

信号阻塞函数

  #include <signal.h> 
  int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); 
  //用来获取或者信号掩码umask（阻塞信号集） 
  //三个参数分别表示：1、表示以某种方式（阻塞还是不阻塞）
  // 2、如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。
  //如果set是非空指针,则更改进程的信号屏蔽字,参数how指示如何更改。
  //如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,
  //然后根据set和how参数更改信号屏蔽字。
  //假设当前的信号屏蔽字为mask //成功返回0，失败返回-1 

参数how的可选值如下所示：

注：如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,⾄少将其中一个信号递达。
未决信号集

#include <signal.h> 
int sigpending(sigset_t *set); //读取当前进程的未觉信号集 
//成功返回0，失败返回-1 

通过以上几个函数，我们对信号集有了大概的认识，现在，让我们来实地操作一下（信号集的使用，主要是对进程的状态进行修改，使其处于阻塞或者未决状态）

  1 #include<stdio.h>
  2 #include<signal.h>
  3 #include<unistd.h>
  4 void printsigset(sigset_t *sig)
  5 {
  6     int i;
  7     for(i=0;i<32;++i)
  8     {
  9         if(sigismember(sig,i))
 10         {
 11             printf("1");
 12         }
 13         else
 14         {
 15             printf("0");
 16         }
 17     }
 18     printf("\n");
 19 }
 20 int main()
 21 {
 22     sigset_t s,p;
 23     sigemptyset(&s);
 24     sigemptyset(&p);
 25 
 26     sigaddset(&s,SIGTSTP);
 27     sigprocmask(SIG_BLOCK,&s,NULL);
 28     while(1)
 29     {
 30         sigpending(&p);
 31         printsigset(&p);
 32         sleep(1);
 33     }
 34     return 0;
 35 }

分析如下所示：

结果如下所示：

说明：程序运行时,每秒钟把各信号的未决状态打印一遍,由于我们阻塞了SIGTSTP信号,按Ctrl-Z将会 使SIGTSTP信号处于未决状态,按Ctrl-C仍然可以终止程序,因SIGINT信号没有阻塞。
二、信号捕捉
在上一篇文章中，我们知道了信号的处理方式有三种，分别是默认、忽略、自定义（捕捉），在前正面的两种方式中，分别由操作系统给出处理方式，而在第三种方式，即信号捕捉之时，需要我们用自定义函数，从而实现我们想要的功能，需要了解这些知识，就需要我们自己对操作系统在用户态与内核态中的切换要十分熟悉，因此，现在我们先来看一下在信号捕捉之时，操作系统需要干的工作
1、操作系统内核如何实现捕捉
首先我们来看一下从用户到内核之间的切换

说明：
如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。
由于信号处理函数的代码是在用户空间的（原因：防止恶意代码侵入操作系统）,处理过程比较复杂,举例如下: 用户程序注册了SIGQUIT信号的处理函数handler。 当
前正在执行main函数,这时发生中断或异常切换到内核态。 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。 内核决定返回⽤用户态后不是恢复main函数的上下文继续执⾏行,而是执⾏shandler函 数,handler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是 两个独立的控制流程。handler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。

2、信号处理函数

#include <signal.h>
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
//signum：表示除了SIGILL与SIGSTOP的所有信号
//参数2与参数3分别表示的是结构体，大概含义就是，参数2表示当前信号的处理动作，而参数三表示之前的处理动作，参数三可以为空

结构体如下所示：

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。
• signum是指定信号的编号。
• 若act指针非空,则根据act修改该信号的处理动作。
• 若oact指针非 空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体:
• 将sahandler 赋值为常数
  SIGIGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。
• 当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止。
  如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用samask字段说明这些需要额外屏蔽的信号 ,
  当信号处理函数返回时自动恢复原来的信号屏蔽字。saflags字段包含一些选项。

 #include <unistd.h>
 int pause(void);
 //使调用进程挂起直到有信号递达

说明：
如果信号的处理动作是终止进程,则进程终止,pause函数没有机会返回;如果信号的处理动作是忽略,则进程继续处于挂起状态,pause不返回;如果信号的处理动作是捕捉,则调用了信号处理函数之后pause返回-1,errno设置为EINTR, 所以pause只有出错的返回值。错误码EINTR表示“被信号中断”。

信号处理函数实例如下所示：

  1 #include<stdio.h>
  2 #include<signal.h>
  3 #include<unistd.h>
 20 void handler(int signum)
 21 {
 22     printf("i am SIGINT of sig!!,sig=%d\n",signum);
 23 }
 24 int main()
 25 {
 26     while(1)
 27     {
 28     struct sigaction new,old;
 29     new.sa_handler=handler;
 30     sigemptyset(&new.sa_mask);
 31     new.sa_flags=0;
 32     sigaction(SIGINT,&new,NULL);
 33     }
 46     return 0;
 47 }

分析如下所示：

对于结果，如下所示：

有关pause的使用

具体结果如下所示：

到这里，有关信号处理与捕捉，大概就结束了，上面有关信号捕捉以及进程挂起的小栗子，希望可以帮助到大家！！！

三、可重入函数
1、适用场景
可重入函数主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入OS（操作系统）调度下去执行另外一段代码，而返回控制时不会出现什么错误；而不可重入的函数由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。
2、概念
可重入函数也可以这样理解，重入即表示重复进入，首先它意味着这个函数可以被中断，其次意味着它除了使用自己栈上的 变量以外不依赖于任何环境（包括static），这样的函数就是purecode（ 纯代码）可重入，可以允许有该函数的多个副本在运行，由于它们使用的是分离的栈，所以不会互相干扰。如果确实需要访问 全局变量（包括static），一定要注意实施互斥手段。可重入函数在并行运行环境中非常重要，但是一般要为访问全局变量付出一些性能代价。
3、可重入

• 不为连续的调用持有静态数据。
• 不返回指向静态数据的指针；所有数据都由函数的调用者提供。
• 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据。
• 如果必须访问全局变量，记住利用互斥信号量来保护全局变量。
• 绝不调用任何不可重入函数。
  4、不可重入
• 函数中使用了静态变量，无论是全局静态变量还是局部静态变量。
• 函数返回静态变量。
• 函数中调用了不可重入函数。
• 函数体内使用了静态的数据结构；
• 函数体内调用了malloc()或者free()函数；
• 函数体内调用了其他标准I/O函数。
• 函数是singleton中的成员函数而且使用了不使用线程独立存储的成员变量 。
• 总的来说，如果一个函数在重入条件下使用了未受保护的共享的资源，那么它是不可重入的。
  5、示意图如下所示
  
  6、说明
• main函数调用insert函数向一个链表head中插入节点s,插入操作分为两步,刚做完第一步的时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换到sighandler函数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作
  两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的inser函数中继续
  往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后
  向链表中插入两个节点,而最后只有一个节点真正插入链表中了。
• 像上例这样,insert函数被不同的控制流程调用,有可能在⼀一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入⽽造成错乱,像这样的函数称为不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant)
  函数。想一下,为 什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?（原因是，栈帧是相互独立的，局部变量等的调用需要调用栈帧，因此，在另一次调用这个函数之时，由于局部变量的另一次调用，创建新的栈帧，因此，会出现数据的混乱）

6、volatile关键字—–保证内存的可见性
（1）概念
volatile是一个类型修饰符（type specifier），被设计用来修饰被不同线程访问和修改的变量。在程序设计中，尤其是在C语言、C++、C#和Java语言中，使用volatile关键字声明的变量或对象通常拥有和优化和（或）多线程相关的特殊属性。如果没有volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器失去大量优化的机会。
（2）使用场景
　1、中断服务程序中修改的供其它程序检测的变量需要加volatile；
　2、多任务环境下各任务间共享的标志应该加volatile；
　3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能有不同意义；
　另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。

7、sigsuspend函数

#include <signal.h>
int sigsuspend(const sigset_t *mask);
//函数描述：解除对指定信号的屏蔽，挂起等待，直到有信号终止进程为止。
//返回值：只有执行了一个信号处理函数之后sigsuspend才返回,返回值
//为-1,errno设置为EINTR

说明：调用sigsuspend时,进程的信号屏蔽字由sigmask参数指定,可以通过指定sigmask来临时解除对某个信号的屏蔽,然后挂起等待,当sigsuspend返回时,进程的信号屏蔽字恢复为原来的值,如果原来对该信号是屏蔽的,从sigsuspend返回后仍然是屏蔽的。

四、SIGCHLD信号
在之前我们知道了，父进程如果不等待子进程的退出，子进程将变成僵尸状态，从而会发生内存泄漏的情况
有关僵尸进程以及进程概念，请参考
https://blog.csdn.net/aaronlanni/article/details/79774496
用wait和waitpid函数清理僵尸进程,父进程可以阻塞等待子进程结束,也可以非阻 塞地查询是否有子进程结束等待清理(也就是轮询的⽅方式)。采⽤用第一种方式,父进程阻塞了就不 能处理自己的工作了;用第二种方式,⽗父进程在处理自己的工作的同时还要记得时不时地轮询一下,程序实现复杂。
因此，为了使得程序简单且在等待子进程的同时父进程还能实现自己的任务，现在，我们将给出另一种思路：

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

  1 #include<stdio.h>
  2 #include<signal.h>
  3 #include<unistd.h>
  4 
  5 void handler(int signum)
  6 {
  7     int status=0;
  8     pid_t ret=waitpid(-1,&status,0);//-1等待任意一个子进程
  9     if(ret>0)
 10     {
 11         printf("wait child success!!!sig:%d,exitcode:%d\n",status&0X7F,(status>>8)&0XFF);
 12     }
 13     else
 14         printf("child quit\n");
 15 }
 16 
 17 
 18 int main()
 19 {
 20     signal(SIGCHLD,handler);//捕捉信号
 21     pid_t id;
 22     id=fork();
 23     if(id==0)
 24     {
 25         printf("i am child,pid:%d,ppid:%d\n",getpid(),getppid());
 26         sleep(5);
 27         exit(1);
 28     }
 29     while(1)
 30     {
 31             printf("i am father,pid:%d,ppid:%d\n",getpid(),getppid());
 32             sleep(1);
 33     }
 34     return 0;
 35 }

结果如下所示：

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

有关Linux信号集中的知识大概就这么多了，希望可以帮助到大家！！！

只有不停的奔跑，才能不停留在原地！！！