linux中信号的产生 阻塞与捕捉

一，信号的基本概念

在讲信号之前，先举个例子：

    日常生活中，当我们走到马路上时，看到的绿灯是一种信号，它能提示我们在什么时候安全的过马路。正是由于这些信号的存在，才使得我们的生活方便而有序。

通俗的讲：
    信号就是当你看到它是知道它是什么，并且知道看到信号之后应该做什么，至于你遵不遵守就是你自己的事了。

信号的产生和默认处理方法：

    同日常生活中的信号一样，计算机在收到信号之后，并不一定会立即处理它，它会将收到的信号记录在其相应进程的PCB中的信号部分，等待合适的时间再去处理它。换句话说，一个进程是否收到信号，需要查看其进程PCB中的信号信息，给进程发信号实则是向进程PCB中写入信号信息。同时，我们的操作系统对每个信号都有对应的默认处理动作。

用kill -l命令查看linux中所有的信号：

注意：
  总共是62个信号 没有32 33号信号
  1-31：普通信号
  34-64：实时信号

    每个信号都有一个宏名称和一个信号编号，这些宏定义可以在signal.h中找到，这些信号各自在什么条件下产生,默认的处理动作是什么，可以用 man 7 signal 命令查看linux下信号的产生条件和处理动作。

各种信号的产生条件和默认处理动作：
    http://blog.csdn.net/u012814689/article/details/55105257

普通信号的存储方式：
     使用位图存储，每一个bit位存储一个相应信号，31个信号只需4个字节（仅一个整形的大小）即可存储，bit位的位置表示信号的编号，bit位的值则用来表示是否收到该信号（0—-未收到该信号，1—-收到该信号）。
信号量的本质就是修改PCB中管理信号变量中的某个bit位。

产生信号的方式主要包括:

1. 用户在终端按下某些键时,终端驱动程序会发送信号给前台进程
   Ctrl-C产生SIGINT信号（2号信号，终止前台进程）,
   Ctrl-\产生SIGQUIT信号（3号信号，捕捉信号）,
   Ctrl-Z产生SIGTSTP信号(20号信号，可使前台进程停止)。

    SIGINT（ctrl C）的默认处理动作是终止进程,SIGQUIT(ctrl )的默认处理动作是终止进程并且Core Dump,那么什么是Core Dump呢？

Core Dump：核心转储。
    当一个进程要异常终止时,可以选择把进程的用户空间内存数据全部保存到磁盘上,文件名通常是core,这叫做Core Dump。
    进程异常终止通常是因为有Bug,比如非法内存访问导致段错误,事后可以用调试器检查core文件以查清错误原因,这叫做Post-mortem Debug（事后调试）。一个进程允许产生多大的core文件取决于进程的Resource Limit(这个信息保存 在PCB中)。默认是不允许产生core文件的,因为core文件中可能包含用户密码等敏感信息,不安全。在开发调试阶段可以用ulimit命令改变这个限制,允许产生core文件。

核心转储：
<1>用ulimit命令改变Shell进程的Resource Limit,设置core文件大小为1024K:
    ulimit -c 1024

<2>然后写一个死循环程序:

test.c

#include<stdio.h>int main(){    printf("pid id :%d\n",getpid());    while(1);    return 0;}

运行结果：

2.硬件异常产生信号,  这些条件由硬件检测到并通知内核,然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释 为SIGFPE信号发送给进程。再⽐如当前进程访问了非法内存地址,,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

3.调用系统函数给进程发信号。
 可以用kill(1)命令发送信号给某个进程,kill(1)命令也是调用kill(2)函数实现的,如果不明确指定信号则发送SIGTERM信号,该信号的默认处理动作是终止进程。 当内核检测到某种软件条件发生时也可以通过信号通知进程,例如闹钟超时产生SIGALRM信号,向读端已关闭的管道写数据时产生SIGPIPE信号。 如果不想按默认动作处理信号,用户程序可以调用sigaction(2)函数告诉内核如何处理某种信号。可以调用raise函数给当前进程发送指定的信号，等等的系统函数。

raise函数可以给当前进程发送指定的信号(自己给自己发信号)。

#include<stdio.h>#include<signal.h>#include<stdlib.h>#include<unistd.h>void myhandler(){   printf("this is a raise test:pid is %d\n",getpid());}int main() {     signal(2,myhandler);     while(1)     {        raise(2);//给自己发2号信号        sleep(1);     }     return 0;}

运行结果：
每隔一秒打印一次这句话

4.由软件条件产生信号

由软件条件产生的信号：SIGPIPE，SIGALRM 等。

alarm函数:可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。

//函数原型#include<unistd.h>unsigned int alarm（unsigned int seconds)

返回值：
成功：如果调用此alarm（）前，进程已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。
出错：-1

alarm函数实例:

alarm.c

#include<stdio.h>#include<signal.h>#include<stdlib.h>int count=0;void myhandler(){    printf("count is %d\n",count);    exit(1);}int main(){    signal(SIGALRM,myhandler);    alarm(1);    while(1)    {        count++;    }    return 0;}~                                                                           ~                  

运行结果：
这个程序的作用是1秒钟之内不停地运行count++,1秒钟到了就被SIGALRM信号终止，得到加了之后的count。

可选的处理信号的方法：

1. 忽略该信号。
2. 执行该信号的默认处理动作。（与信号的种类有关，大多数信号会直接终止该进程）。
3. 提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为捕捉(Catch)一个信号。用信号处理函数为该信号指定自定义动作。即：修改信号的默认动作。

siganl函数的声明：

       #include <signal.h>       typedef void (*sighandler_t)(int);       sighandler_t signal(int signum, sighandler_t handler);

参数：
    signum:信号编号
    handler:描述了与信号关联的动作，它可以取以下三种值：
（1）SIG_IGN 　　
这个符号表示忽略该信号。
（2）SIG_DFL 　　
这个符号表示恢复对信号的系统默认处理。不写此处理函数默认也是执行系统默认操作。
（3）sighandler_t类型的函数指针
　　
上面提到了sighandler_t类型声明：

typedef void (*sighandler_t)(int);sighandler_t signal(int signum, sighandler_t handler);

    此函数必须在signal()被调用前申明，handler中为这个函数的名字。当接收到一个类型为sig的信号时，就执行handler 所指定的函数。（int）signum是传递给它的唯一参数。执行了signal()调用后，进程只要接收到类型为sig的信号，不管其正在执行程序的哪一部分，就立即执行func()函数。当func()函数执行结束后，控制权返回进程被中断的那一点继续执行。

返回值：
    signal函数的返回值是一个函数指针， 成功时返回调用前已经安装的信号处理函数的指针.，失败返回错误码对应的错误提示。

举例：
捕捉2号信号SIGINT：

#include<unistd.h>#include<stdio.h>#include<signal.h>void myhandler(int signo){    printf("got SIGINT\n");}int main(){   signal(2,myhandler);//捕捉2号信号SIGINT：Ctrl C   while(1)   {       sleep(1);   }   return 0;}

运行结果：

背景知识：
    前台进程：基本不用和用户交互，优先级稍微低一些（运行前台进程： ./test.c）
    后台进程：需要和用户进行交互，需要较高的相应速度，优先级别高(运行后台进程： ./test.c &)

    在./signal 后面加& 表示进程在后台运行 ，而ctrl+C ctrl+\都只能终止前台进程，后台程序如何终止呢？此时，我们需要用到kill命令：

改进：signal.c

#include<stdio.h>#include<signal.h>typedef void (*sighandler_t)(int);//函数指针sighandler_t old_handler = NULL;void myhandler(int signo){      printf("got SIGINT\n");//第一次按ctrlC捕捉2号信号SIGINT      signal(2, old_handler);//恢复默认的处理，再按ctrl C的话，就会终止程序}int main(){   signal(2,myhandler);//捕捉2号信号SIGINT：Ctrl C   while(1)   {       sleep(1);   }   return 0;}

运行结果：

二. 信号的阻塞：

*

1.概念：

**

信号递达（Delivery）：实际执行信号处理的动作。
信号未决（Pending）：信号从产生到递达之间的状态。
信号阻塞（Block）：被阻塞的信号产生时将保持在未决状态,直到 进程解除对此信号的阻塞,才 执行递达的动作。

    注意：信号阻塞和信号忽略是不同的。只要信号被阻塞就不会递达,除非解除阻塞，而忽略是在递达之后 可选的一种处理动作。

2.信号在内核中的表示—-每个进程都会维护这3张表：

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

3张表的存储：
    pending表：用4个字节的位图表示，位图的位置表示信号编号，内容表示是否pending。
    block表：用4个字节的位图表示，位图的位置表示信号编号，内容表示是否block。
    handler表:是一个句柄函数指针，数组即可表示，下标表示信号编号，内容表示信号处理的动作，为NULL表示没有处理该信号。

分析上图中的信号：
1〉SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。
2〉SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。
3〉 SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。

3.如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?

    常规信号在递达之前产生多次只计一次（用位图表示，非0即1）,而实时信号在递达之前产生多次可以依次放在一个队列里。

    常规信号中，未决和阻塞标志可以用相同的数据类型 sigset_t 来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。 阻塞信号集也叫做当前进程的 信号屏蔽字 (Signal Mask),这里的 “屏蔽”应该理解为阻塞而不是忽略。

4，信号集操作函数

    信号集类型：sigsize_t。sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态,至于这个类型内部如何存储，从使用者的角度是不必关心的。这些bit位依赖于系统实现,使用者只能调用以下函数来操作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);

    函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有效信号。函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示该信号集的有效信号包括系统支持的所有信号。注意,在使用sigset_t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以 在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。这四个函数都是成功返回0,出错返回-1。 sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含某种信号,若包含则返回1,不包含则返回0,出错返回-1。

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

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

返回值：若成功则为0,若出错则为-1。

参数：
oset:如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则更改进程的信号屏蔽字,参数how指示如何更改。

set:如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字。
how参数的可选值为：

6，sigpending 读取当前进程的未决信号集,通过set参数传出。

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

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

  #include<stdio.h>  #include<signal.h>  #include<unistd.h>  #include<sys/types.h>  void showpending(sigset_t* pending)//打印当前进程的pending表  {      int i = 1;      for(; i < 32; ++i)      {          if(sigismember(pending,i))//判断pending信号集的有效信号中是否包含信号i,若包含则返回1,不包含则返回0,出错返回-1              printf("1 ");          else              printf("0 "); }      printf("\n");  }  void handler(int sig)  {      printf("pid is %d,get a signo:%d\n",getpid(),sig);      return;  }  int main()  {      sigset_t sigset,osigset;//定义两个信号集      sigemptyset(&sigset);//信号集siget初始化，将所有bit位清零      sigemptyset(&sigset);//信号集osigset初始化，将所有bit位清零      sigaddset(&sigset,2);//给信号集sigset添加2号信号      sigprocmask(SIG_SETMASK,&sigset,&osigset);//先将原来的信号屏蔽字备份到osigset里,然后将\      sigset的值设置为当前信号屏蔽字      signal(2,handler);//捕捉2号信号      int count = 0;      sigset_t pending;//定义信号集pending      while(1)      {          sigpending(&pending);//读取当前进程的未决信号集，通过pengding传出          showpending(&pending);//打印当前进程的pending表          sleep(1);          if(count++ > 3)          {                sigprocmask(SIG_SETMASK,&osigset,NULL);//读取进程的当前信号屏蔽字,然后将osigset的值设置为当前信号屏蔽字                count = 0;          }      }      return 0;  }

三. 捕捉信号

1. 什么是捕捉信号？

捕捉信号：信号处理方式三种方式中的一种，意思是既不忽略该信号，又不执行信号默认的动作，而是让信号执行自定义动作。捕捉信号要使用signal函数，为了做到这一点要通知内核在某种信号发生时，调用一个用户函数handler。在用户函数中，可执行用户希望对这种事件进行的处理。注意，不能捕捉SIGKILL和SIGSTOP信号。

2. 内核如何实现信号的捕捉

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

图示：

内核捕捉信号举例：

1>用户程序注册了SIGQUIT信号的处理函数sighandler。
2> 当前正在执行main函数,这时发生中断或异常切换到内核态。
3> 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。
4> 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是两个独立的控制流程。
5> sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。
6> 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。

3，捕捉信号用到的函数

1）SIGALRM 信号：

时钟定时信号, 计算的是实际的时间或时钟时间， alarm函数使用该信号。

2）alarm函数：

函数原型：

#include <unistd.h>unsigned int alarm(unsigned int seconds);

alarm也称为闹钟函数。它可以在进程中设置一个定时器，当定时器指定的时间到时，它向进程发送SIGALRM信号。如果忽略或者不捕获此信号，则其默认动作是终止调用该alarm函数的进程。
返回值是0或者是以前设定的闹钟时间还余下 的秒数。如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数。

3）pause函数：

函数原型：

#include <unistd.h> int pause(void); 

pause函数使调用进程挂起直到有信号递达。pause只有出错的返回值。errno设置为EINTR表示“被信号中断”。
如果信号的处理动作是终止进程，则进程终止， pause函数没有机会返回；
如果信号的处理动作是忽略，则进程继续处于挂起状态， pause不返回；
如果信号的处理动作是捕捉，则调用了信号处理函数之后pause返回- 1；

4）sigaction函数:

sigaction函数可以读取和修改与指定信号相关联的处理动作。

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

sigaction函数：成功返回0，失败返回-1
signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非空,则通过oact传出该信号原来的处理动作。

sigaction的结构体：

sa_handler：赋值为常数SIG_IGN传给sigaction表示忽略信号；赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号。 向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。
sa_mask：进程的信号屏蔽字。如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。
sa_flags：sa_flags字段包含一些选项,本文代码把sa_flags设为0。
sa_sigaction是实时信号的处理函数。

四，捕捉信号举例—-模拟sleep

（一）普通版本的mysleep

#include<stdio.h>#include<signal.h>#include<unistd.h>void myhandler(){    printf("get a sig:");}int mysleep(int timeout){    struct sigaction act,oldact;    act.sa_handler=myhandler;    sigemptyset(&act.sa_mask);//初始化信号集    act.sa_flags=0;    sigaction(SIGALRM,&act,&oldact);//注册信号处理动作    alarm(timeout);//设置闹钟    pause();// 将自己挂起 直到有信号递达    int ret=alarm(0);//取消闹钟    sigaction(SIGALRM,&oldact,NULL);////恢复对SIGALRM信号的处理动作    return ret;}int main(){       while(1)       {            mysleep(2);            printf("use mysleep!\n");       }       return 0; }

上述程序存在的问题：

    上面的程序运行过程中遇到一个问题，虽然程序按照流程运行完成，但是并没有结束，直到人为的按ctrl C才结束运行，那么为什么会这样呢？
    因为程序的时序，优先级等问题导致程序没有按预期运行，有可能在设置闹钟之后由于某种原因程序被切出去了，等时钟到了固定时间后程序仍没切回来，此时会将信号递达，等程序切回来时pause有可能再也等不到信号来临导致程序一直被挂起。

    根本原因就是系统运行代码时并不会按照我们的思路走，虽然alarm(timeout)紧接着的下一行就是pause(),但是无法保证pause()一定会在调用alarm(timeout)之后的timeout秒之内被调用。由于异步事件在任何时候都有可能发生,如果写程序时考虑不周密,就可能由于时序问题而导致错误,这叫做 竞态条件

（二）避免竞态条件的mysleep

程序改善：用sigsuspend代替pause,sigsuspend函数既包含了pause的挂起等待功能,同时又解决了竞态条件问题。

#include <signal.h>    int sigsuspend(const sigset_t *sigmask);

在对时序要求严格的场合下都应该调用sigsuspend而不是pause。
如果在调用my_sleep函数时SIGALRM信号没有屏蔽：
1）调用sigprocmask(SIG_BLOCK,&newmask, &oldmask)时，屏蔽SIGALRM。
2）调用sigsuspend(&suspmask)时，解除对SIGALRM的屏蔽，然后挂起等待。
3）SIGALRM递达后suspend返回，自动恢复原来的屏蔽字，也就是再次屏蔽SIGALRM。
4）调用sigprocmask(SIG_SETMASK, &oldmask, NULL)时，再次解除对SIGALRM的屏蔽。

  #include<stdio.h>   #include<signal.h>   void myhandler(int sig)   {       //printf("get a sig:%d\n",sig);   }   unsigned int mysleep1(unsigned int seconds) {    struct sigaction newact,oldact;    sigset_t newmask,oldmask,suspmask;    unsigned int unslept;    newact.sa_handler=sig_alrm;    sigemptyset(&newact.sa_mask);    newact.sa_flags=0;    sigaction(SIGALRM,&newact,&oldact);//读取和修改与SIGALRM信号相关联的处理动作    sigemptyset(&newmask);    sigaddset(&newmask,SIGALRM);    sigprocmask(SIG_BLOCK,&newmask,&oldmask);    alarm(seconds);    suspmask=oldmask;    sigdelset(&suspmask,SIGALRM);    sigsuspend(&suspmask);//将当前进程的信号屏蔽字设为oldmask,在进程接受到信号之前，进程会挂起，当捕捉一个信号，首先执行信号处理程序，然后从sigsuspend返回，最后将信号屏蔽字恢复为调用sigsuspend之前的值    unslept=alarm(0);//取消闹钟     sigaction(SIGALRM,&oldact,NULL);    return unslept;  }   int main()   {      while(1)      {          mysleep(2);          printf("use mysleep!\n");      }      return 0;   }

sigsuspend与pause区别：

sigsuspend函数是pause函数的增强版。当sigsuspend函数的参数信号集为空信号集时，sigsuspend函数是和pause函数是一样的，可以接受任何信号的中断。 但，sigsuspend函数可以屏蔽信号，接受指定的信号中断。（信号中断的是sigsuspend和pause函数，不是程序代码。）