Linux下的信号详解及捕捉信号

信号的基本概念

每个信号都有一个编号和一个宏定义名称 ,这些宏定义可以在 signal.h 中找到。

使用kill -l命令查看系统中定义的信号列表： 1-31是普通信号； 34-64是实时信号

所有的信号都由操作系统来发！

对信号的三种处理方式

1、忽略此信号：大多数信号都可使用这种方式进行处理，但有两种信号却决不能被忽略。它们是：SIGKILL和SIGSTOP。这两种信号不能被忽略的，原因是：它们向超级用户提供一种使进程终止或停止的可靠方法。另外，如果忽略某些由硬件异常产生的信号（例如非法存储访问或除以0），则进程的行为是示定义的。

2、直接执行进程对于该信号的默认动作 ：对大多数信号的系统默认动作是终止该进程。

3、捕捉信号：执行自定义动作（使用signal函数），为了做到这一点要通知内核在某种信号发生时，调用一个用户函数handler。在用户函数中，可执行用户希望对这种事件进行的处理。注意，不能捕捉SIGKILL和SIGSTOP信号。

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

signal函数的作用：给某一个进程的某一个特定信号（标号为signum）注册一个相应的处理函数，即对该信号的默认处理动作进行修改，修改为handler函数所指向的方式。

1、第一个参数是信号的标号

2、第二个参数，sighandler_t是一个typedef来的，原型是void (*)(int)函数指针，int的参数会被设置成signum

举个代码例子：

#include
#include
void handler(int sig)
{
 printf("get a sig,num is %d\n",sig);
}
 
int main()
{
 signal(2,handler);
 while(1)
 {
  sleep(1);
  printf("hello\n");
 }
 return 0;
}

　　修改了2号信号（Ctrl-c）的默认处理动作为handler函数的内容，则当该程序在前台运行时，键入Ctrl-c后不会执行它的默认处理动作（终止该进程）

信号的处理过程：

进程收到一个信号后不会被立即处理，而是在恰当 时机进行处理！什么是适当的时候呢？比如说中断返回的时候，或者内核态返回用户态的时候（这个情况出现的比较多）。

信号不一定会被立即处理，操作系统不会为了处理一个信号而把当前正在运行的进程挂起（切换进程），挂起（进程切换）的话消耗太大了，如果不是紧急信号，是不会立即处理的。操作系统多选择在内核态切换回用户态的时候处理信号，这样就利用两者的切换来处理了（不用单独进行进程切换以免浪费时间）。

总归是不能避免的，因为很有可能在睡眠的进程就接收到信号，操作系统肯定不愿意切换当前正在运行的进程，于是就得把信号储存在进程唯一的PCB（task_struct）当中。

产生信号的条件

1.用户在终端按下某些键时，终端驱动程序会发送信号给前台程序。

     例如：Ctrl-c产生SIGINT信号，Ctrl-\产生SIGQUIT信号，Ctrl-z产生SIGTSTP信号

2.硬件异常产生信号。

     这类信号由硬件检测到并通知内核，然后内核向当前进程发送适当的信号。

     例如：当前进程执行除以0的指令，CPU的运算单元会产生异常，内核将这个进程解释为SIGFPE信号发送给当前进程。
               当前进程访问了非法内存地址，MMU会产生异常，内核将这个异常解释为SIGSEGV信号发送给进程。

3.一个进程调用kill(2)函数可以发送信号给另一个进程。

     可以用kill(1)命令发送信号给某个进程，kill(1)命令也是调用kill(2)函数实现的，如果不明确指定信号则发送SIGTERM信号，该信号的默认处理动作是终止进程。

信号的产生

1.通过终端按键产生信号

举个栗子：写一个死循环，前台运行这个程序，然后在终端键入Ctrl-c

　　当CPU正在执行这个进程的代码 , 终端驱动程序发送了一 个 SIGINT 信号给该进程，记录在该进程的 PCB中，则该进程的用户空间代码暂停执行 ,CPU从用户态 切换到内核态处理硬件中断。

　　从内核态回到用户态之前， 会先处理 PCB中记录的信号 ,发现有一个 SIGINT 信号待处理, 而这个信号的默认处理动作是终止进程，所以直接终止进程而不再返回它的用户空间代码执行。

 2.调用系统函数向进程发信号

/*************************************************************************
 > File Name: test.c
 > Author:Lynn-Zhang
 > Mail: [email protected]
 > Created Time: Fri 15 Jul 2016 03:03:57 PM CST
 ************************************************************************/
 
#include
int main()
{
 printf("get pid :%d circle ...\n",getpid());
 while(1);
 return 0;
}

写一个上面的程序在后台执行死循环，并获取该进程的id，然后用kill命令给它发送SIGSEGV信号，可以使进程终止。也可以使用kill -11 5796,11是信号SIGSEGV的编号。

打开终端1，运行程序：

利用终端2,给进程发送信号

 终端1 显示进程被core了：

kill命令是调用kill函数实现的。kill函数可以给一个指定的进程发送指定信号。

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

#include
int kill(pid_t pid,int signo);
int raise(int signo);

这两个函数都是成功返回0，错误返回-1.

除此之外，abort函数使当前进程接收到SIGABRT信号而异常终止。

#include
void abort(void);

就像 exit函数一样 ,abort 函数总是会成功的 ,所以没有返回值。

3.由软件条件产生信号

/*************************************************************************
 > File Name: alarm.c
 > Author:Lynn-Zhang
 > Mail: [email protected]
 > Created Time: Fri 15 Jul 2016 08:52:02 PM CST
 ************************************************************************/
 
#include
 
int main()
{
 int count=0;
 alarm(1);
 while(1)
 {
 printf("%d\n",count);
 count++;
 }
 return 0;
}

　通过实现以上代码，调用alarm函数可以设定一个闹钟,告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。

   该程序会在1秒钟之内不停地数数,并打印计数器，1秒钟到了就被SIGALRM信号终止。由于电脑配置等的不同，每台电脑一秒钟之内计数值是不同的一般是不同的。

#include 
unsigned int alarm(unsigned int seconds);

　　alarm函数的返回值是0或上次设置闹钟剩余的时间。

阻塞信号

 1.信号在内核中的表示：

信号递达delivery：实际执行信号处理信号的动作

信号未决pending：信号从产生到抵达之间的状态，信号产生了但是未处理

忽略：抵达之后的一种 动作

阻塞block：收到信号不立即处理     被阻塞的信号将保持未决状态，直到进程解除对此信号的阻塞，才执行抵达动作

信号产生和阻塞没有直接关系 抵达和解除阻塞没有直接关系！

进程收到一个信号后，不会立即处理，它会在恰当的时机被处理。

每个信号都由两个标志位分别表示阻塞和未决，以及一个函数指针表示信号的处理动作。

在上图的例子中,

　　1. SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。

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

　　3. SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。阻塞信号集也叫作信号屏蔽字。

信号产生但是不立即处理，前提条件是要把它保存在pending表中，表明信号已经产生。

2.信号集操作函数

#include 
int sigemptyset(sigset_t *set); //初始化set所指向的信号集，使所有信号的对应位清0
int sigfillset(sigset_t *set); //初始化set所指向的信号集，表示该信号集的有效信号包括系统支持的所有信号
int sigaddset(sigset_t *set, int signo); //在该信号集中添加有效信号
int sigdelset(sigset_t *set, int signo); //在该信号集中删除有效信号
int sigismember(const sigset_t *set, int signo); //用于判断一个信号集的有效信号中是否包含某种信号

参数解析：

sigset_t结构体的参数表示信号集，信号操作的时候都是以信号集合的方式进行操作，需要事先创建一个该结构体的对象，然后把想要操作的信号添加到信号集合对象当中去

signo就是信号的标号了

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

#include 
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

　　　一个进程的信号屏蔽字规定了当前阻塞而不能递送给该进程的信号集。调用函数sigprocmask可以检测或更改（或两者）进程的信号屏蔽字。如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中 一个信号递达。

参数解析：

 how，有三个宏

     SIG_BLOCK      添加到block表当中去

     SIG_UNBLOCK  从block表中删除

     SIG_SETMASK  设置block表 设置当前信号屏蔽字为set所指向的值

 set表示新设置的信号屏蔽字，oset表示当前信号屏蔽字

处理方式：

      set 非空， oset 为NULL ：按照how指示的方法更改set指向信号集的信号屏蔽字。

      set 为NULL，oset 非空：读取oset指向信号集的信号屏蔽字，通过oset参数传出。

      set 和 oset 都非空 ：现将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字。

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

#include 
int sigpending(sigset_t *set);

这是一个输出型参数，会把当前进程的pending表打印到传入的set集中。

实例验证上面几个函数：

 

一开始没有任何信号，所以pending表中全是0，我通过Ctrl+C传入2号信号，看到pending表中有2号被置位了，经过10秒取消阻塞，2号信号被处理（经过我自定义的函数）

Linux下捕捉信号

信号由三种处理方式：

     忽略

     执行该信号的默认处理动作

     捕捉信号

如果信号的处理动作是用户自定义函数，在信号递达时就调用这个自定义函数，这称为捕捉信号。

进程收到一个信号后不会被立即处理，而是在恰当时机进行处理！即内核态返回用户态之前 ！

但是由于信号处理函数的代码在用户空间，所以这增加了内核处理信号捕捉的复杂度。

内核实现信号捕捉的步骤：

      1、用户为某信号注册一个信号处理函数sighandler。

      2、当前正在执行主程序，这时候因为中断、异常或系统调用进入内核态。

      3、在处理完异常要返回用户态的主程序之前，检查到有信号未处理，并发现该信号需要按照用户自定义的函数来处理。

      4、内核决定返回用户态执行sighandler函数，而不是恢复main函数的上下文继续执行！（sighandler和main函数使用的是不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程）

      5、sighandler函数返回后，执行特殊的系统调用sigreturn从用户态回到内核态

      6、检查是否还有其它信号需要递达，如果没有 则返回用户态并恢复主程序的上下文信息继续执行。

 

signal

给某一个进程的某一个信号（标号为signum）注册一个相应的处理函数，即对该信号的默认处理动作进行修改，修改为handler函数指向的方式；

#include 
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
//即：
void (*signal(int, void(*)(int)))(int);

signal函数接受两个参数：一个整型的信号编号，以及一个指向用户定义的信号处理函数的指针。　　

此外，signal函数的返回值是一个指向调用用户定义信号处理函数的指针。

sigaction

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

#include 
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); 
};

signum是指定信号的编号。

处理方式：

     1、若act指针非空,则根据act结构体中的信号处理函数来修改该信号的处理动作。

     2、若oact指针非 空,则通过oact传出该信号原来的处理动作。

     3、现将原来的处理动作备份到oact里，然后根据act修改该信号的处理动作。

（注：后两个参数都是输入输出型参数！）

将sa_handler三种可选方式：

     1、赋值为常数SIG_IGN传给sigaction表示忽略信号；

     2、赋值为常数SIG_DFL表示执行系统默认动作；

     3、赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册一个信号处理函 数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。

（注：这是一个回调函数,不是被main函数调用,而是被系统所调用）

　　当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。

 pause

pause函数使调用进程挂起直到有信号递达！

#include 
int pause(void);

处理方式：　

     如果信号的处理动作是终止进程,则进程终止,pause函数没有机会返回;

     如果信号的处理动作是忽略,则进程继续处于挂起状态,pause不返回;

     如果信号的处理动作是捕捉,则调用了信号处理函数之后pause返回-1,errno设置为EINTR。

     所以pause只有出错的返回值(类似exec函数家族)。错误码EINTR表示“被信号中断”。

 举个栗子

     1、定义一个闹钟，约定times秒后，内核向该进程发送一个SIGALRM信号；

     2、调用pause函数将进程挂起，内核切换到别的进程运行；

     3、times秒后，内核向该进程发送SIGALRM信号，发现其处理动作是一个自定义函数，于是切回用户态执行该自定义处理函数；

     4、进入sig_alrm函数时SIGALRM信号被自动屏蔽,从sig_alrm函数返回时SIGALRM信号自动解除屏蔽。然后自动执行特殊的系统调用sigreturn再次进入内核,之后再返回用户态继续执行进程的主控制流程(main函数调用的mytest函数)。

     5、pause函数返回-1,然后调用alarm(0)取消闹钟,调用sigaction恢复SIGALRM信号以前的处理 动作。

/*************************************************************************
 > File Name: Pause.c
 > Author:Lynn-Zhang
 > Mail: [email protected]
 > Created Time: Sun 14 Aug 2016 12:27:03 PM CST
 ************************************************************************/
 
#include
#include
#include
void sig_alarm(int signum)
{
 printf("I am a custom handler!\n");
}
void mysleep(unsigned int times)
{
 //注册两个信号处理动作
 struct sigaction new,old;
 new.sa_handler=sig_alarm; //信号处理函数
 sigemptyset(&new.sa_mask);//不屏蔽任何信号屏蔽字
 new.sa_flags=0;
 
 //对SIGALRM 信号的默认处理动作修改为自定义处理动作
 sigaction(SIGALRM,&new,&old);
 alarm(times);
 pause(); //挂起等待
 alarm(1);
 sleep(2);
 alarm(0); //取消闹钟
 //恢复SIGALRM 信号到默认处理动作
 sigaction(SIGALRM,&old,NULL);
 alarm(1);
 sleep(2);
}
int main()
{
 while(1)
 {
 mysleep(2);
 printf("many seconds passed\n");
 printf("###################\n");
 }
 return 0;
}

　　　

定义一个闹钟并挂起等待，收到信号后执行自定义处理动作，在没有恢复默认处理动作前，收到SIGALRM信号都会按照其自定义处理函数来处理。恢复自定义处理动作之后收到SIGALRM信号则执行其默认处理动作即终止进程！

总结

以上就是关于Linux下信号与捕捉信号的全部内容，希望本文的内容对大家学习Linux信号能有所帮助，如果有疑问欢迎留言讨论。