参考博客：http://blog.csdn.net/alex_my/article/details/39494129
1. 信号概念
何为信号？
信号是一种软中断，可以由以下情形触发：
-1: 用户按下某些终断键，例如ctrl + C ，这可以停止一个失去控制的程序。(ctrl + D并不是发送信号，而是抛出一个
EOF 结束符，使程序退出。)
-2: 硬件异常，例如除数为0，无效的内存引用
-3：kill(2), kill(1) （接收信号的进程必须与发送信号进程的所有者相同，或者发送信号进程的uid为root）
-4: 当软件条件达成，且有进程需要得到此通知
注：信号是异步事件的经典实例。
当信号发生时，可以告诉内核进行以下处理：
-1：忽略信号(SIG_IGN): 有两个信号不能被忽略，SIGKILL(9), SIGSTOP(19), 不能被忽略的原因是这两个信号为内核和超级用户提供了一条可靠的方法去杀死和暂停进程。当忽略一些来自硬件的异常信号，产生的结果是未定义的，不如引用了无效的内存，除数为0。
-2：抓取信号: 在抓取信号之前，首先要定义抓取信号之后要如何处理，SIGKILL和SIGSTOP信号不能被捕捉。
-3：默认处理信号(SIG_DEF): 每一个信号都有一个默认的处理，大部分处理方式都是终止进程。如果想看各个的处理方式，可以在终端上输入man 7 signal，以下列出备查。红色标注为常用信号。
Signal Value Action Comment
------------------------------------------------------------------------------------------------------------------------------------------------
SIGHUP 1 Term Hangup detected on controlling terminal
or death of controlling process
SIGINT 2 Term Interrupt from keyboard
SIGQUIT 3 Core Quit from keyboard
SIGILL 4 Core Illegal Instruction
SIGABRT 6 Core Abort signal from abort(3)
SIGFPE 8 Core Floating point exception
SIGKILL 9 Term Kill signal
SIGSEGV 11 Core Invalid memory reference
SIGPIPE 13 Term Broken pipe: write to pipe with no
readers
SIGALRM 14 Term Timer signal from alarm(2)
SIGTERM 15 Term Termination signal
SIGUSR1 30,10,16 Term User-defined signal 1
SIGUSR2 31,12,17 Term User-defined signal 2
SIGCHLD 20,17,18 Ign Child stopped or terminated
SIGCONT 19,18,25 Cont Continue if stopped
SIGSTOP 17,19,23 Stop Stop process
SIGTSTP 18,20,24 Stop Stop typed at terminal
SIGTTIN 21,21,26 Stop Terminal input for background process
SIGTTOU 22,22,27 Stop Terminal output for background process
Next the signals not in the POSIX.1-1990 standard but described in SUSv2 and POSIX.1-2001.
SIGBUS 10,7,10 Core Bus error (bad memory access)
SIGPOLL Term Pollable event (Sys V).
Synonym for SIGIO
SIGPROF 27,27,29 Term Profiling timer expired
SIGSYS 12,31,12 Core Bad argument to routine (SVr4)
SIGTRAP 5 Core Trace/breakpoint trap
SIGURG 16,23,21 Ign Urgent condition on socket (4.2BSD)
SIGVTALRM 26,26,28 Term Virtual alarm clock (4.2BSD)
SIGXCPU 24,24,30 Core CPU time limit exceeded (4.2BSD)
SIGXFSZ 25,25,31 Core File size limit exceeded (4.2BSD)
Up to and including Linux 2.2, the default behavior for SIGSYS, SIGXCPU, SIGXFSZ, and (on architec-
tures other than SPARC and MIPS) SIGBUS was to terminate the process (without a core dump). (On some
other Unix systems the default action for SIGXCPU and SIGXFSZ is to terminate the process without a
core dump.) Linux 2.4 conforms to the POSIX.1-2001 requirements for these signals, terminating the
process with a core dump.
Next various other signals.
SIGIOT 6 Core IOT trap. A synonym for SIGABRT
SIGEMT 7,-,7 Term
SIGSTKFLT -,16,- Term Stack fault on coprocessor (unused)
SIGIO 23,29,22 Term I/O now possible (4.2BSD)
SIGCLD -,-,18 Ign A synonym for SIGCHLD
SIGPWR 29,30,19 Term Power failure (System V)
SIGINFO 29,-,- A synonym for SIGPWR
SIGLOST -,-,- Term File lock lost (unused)
SIGWINCH 28,28,20 Ign Window resize signal (4.3BSD, Sun)
SIGUNUSED -,31,- Core Synonymous with SIGSYS
2. signal 函数
#include <signal.h>
void (*signal(int signo, void (*func)(int)))(int);
若出错，返回SIG_ERR
这个signal函数接受两个参数
参数1: 信号名，如SIGCHLD
参数2: 接受信号处理函数指针，函数原型void func(int)，也可以是常量SIG_IGN或SIG_DEF
另外，还有三个定义：
#define SIG_ERR (void(*)())-1 // 返回错误值
#define SIG_DFL (void(*)())0 //恢复为参数1所指信号的处理方法为默认方法
#define SIG_IGN (void(*)())1 // 忽略参数1所指信号
可以作为参数2或者signal的返回值
程序用例：
<span style="font-size:14px;">#include "apue.h"
static void sig_func(int signo)
{
printf("\nsigno: %d\n", signo);
exit(EXIT_SUCCESS);
}
int main(int argc, char** argv)
{
if(signal(SIGINT, sig_func) == SIG_ERR)
{
printf("signal failed. errno[%d]\t %s\n", errno, strerror(errno));
exit(EXIT_FAILURE);
}
pause();
exit(EXIT_SUCCESS);
}</span>输出：
在键盘上按下ctrl + c，产生中断信号。
^C
signo: 2
注意点：
-1：当执行一个程序时，所有信号的状态都是系统默认或者忽略，且信号响应后执行默认动作，直到在程序中做出改变。如同上一程序用例当中，按下ctrl + c后，默认是终止进程，当在程序中做出改变之后，变成执行函数sig_func了。
-2：当使用fork后，子进程继承父进程的信号处理方式。
-3：当fork后又使用exec后，新的程序中的信号又恢复了默认，因为替换旧的数据空间，堆栈等，使得原来处理函数对于新的程序来说，已经失效
-4：对于一个正在执行任务的进程，如果异步捕获了一个信号，并且进入相应的信号处理函数，当它处理完这个函数并想要回到进程中时，可能会使进程“忘记”刚才做到哪里了，这就引入了可重入函数的概念。书中列出了异步信号安全的函数。
一个具体的例子：
假如主线程用malloc申请一个动态空间，并向其中写数据，这是异步获得一个SIG，并跳进SIG处理函数，这个处理函数可能也会向此动态空间写入数据，从而导致破坏了malloc的数据结构。
因此，要避免在信号处理程序中调用非可重入函数。
-5：不可靠的信号是指不具备阻塞信号能力的信号（早起Unix版本中存在的问题）
3.信号集：signal sets
#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);
return 0 on success and -1 on error
int sigismember(const sigset_t* set, int signum);
return 1 if is signum is a member of set, return 0 if not, -1 on error
以上函数可以从字面意思理解：
sigemptyset: （初始化）将set信号集清空
sigfillset : （初始化）将所有的信号填充到set中
sigaddset : 添加指定信号signum到set中
sigdelset : 从set中移除指定信号signum
sigismember: 特使signum是否是set中的成员
4. sigprocmask
#include <signal.h>
int pthread_sigmask(int how, const sigset_t* restrict set, sigset_t* restrict oset);
int sigprocmask(int how, const sigset_t* restrict set, sigset_t* restrict oset);
sigprocmask: 用于设定信号屏蔽集内信号的处理方式
参数how可选值如下：
SIG_BLOCK : set中包含了我们所希望添加的阻塞信号
SIG_UNBLOCK: set中包含了我们所希望解除阻塞的信号
SIG_SETMASK: set中为所设置屏蔽的信号
程序用例：
<span style="font-size:14px;">#include "apue.h"
int main(int argc, char** argv)
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
if(sigismember(&set, SIGINT) == 1)
printf("SIGINT is a member now\n");
else
printf("SIGINT is not a member or error occur\n");
sigdelset(&set, SIGINT);
if(sigismember(&set, SIGINT) == 0)
printf("SIGINT is not a member now\n");
else
printf("SIGINT is still a member or error occur\n");
sigaddset(&set, SIGINT);
sigprocmask(SIG_SETMASK, &set, NULL);
getchar();
// try ctrl + c
return 0;
}</span>
编译运行之后，可以ctrl + c，可以发现无效。
如果将sigprocmask(SIG_SETMASK, &set, NULL)注释，则可以了。
5. sigpending
#include <signal.h>
int sigpending(sigset_t* set);
return 0 if success and -1 on error.
sigpending: 通过set返回已经通知进程，但被阻塞而挂起的信号（未决信号）。比如阻塞了SIGINT信号一段时间，而在这段时间中产生了这个信号，通知进程，这个信号称之为pending信号。如果产生多个SIGINT信号，在Linux实现中，也只会处理一次。可以通过程序用例观察到。
程序用例：
<span style="font-size:14px;">#include "apue.h"
static void sigfunc(int signo)
{
printf("signo: %d\n", signo);
}
int main(int argc, char** argv)
{
sigset_t set, oset, pset;
if(signal(SIGINT, sigfunc) == SIG_ERR)
{
printf("signal failed, error[%d]: %s\n", errno, strerror(errno));
exit(EXIT_FAILURE);
}
sigemptyset(&set);
sigaddset(&set, SIGINT);
if(sigprocmask(SIG_BLOCK, &set, &oset) == -1)
{
printf("sigprocmask failed, error[%d]: %s\n", errno, strerror(errno));
exit(EXIT_FAILURE);
}
//此时，阻塞掉信号集内的信号
// 在此期ctrl + c，可以多次输入，看会处理几次
sleep(5);
//处理未决信号，把未决信号SIGINT放入pset信号集
if(sigpending(&pset) == -1)
{
printf("sigpending failed, error[%d]: %s\n", errno, strerror(errno));
exit(EXIT_FAILURE);
}
if(sigismember(&pset, SIGINT) == 1)
printf("SIGINT is pending\n");
else
printf("SIGINT is not pending\n");
// 不再屏蔽，也可以用SIG_UNBLOCK
if(sigprocmask(SIG_SETMASK, &oset, NULL) == -1)
{
printf("sigprocmask failed2, error[%d]: %s \n", errno, strerror(errno));
exit(EXIT_FAILURE);
}
printf("sleep again\n");
// ctrl + c， 可以多次输入，看会处理几次
sleep(5);
exit(EXIT_SUCCESS);
}</span>输出：
第一次sleep时，可以多次输入ctrl + c，5秒结束之后，会显示"SIGINT is pending"，且函数sigfunc仅会被调用一次，说明多次输入，在当前的Linux实现中只会被调用一次。
第二次sleep期间，由于SIGINT不再被阻塞，因此输入ctrl + c后，会立即响应。
6. sigaction
#include <signal.h>
int sigaction(int sig, const struct sigaction* restrict act, struct sigaction* restrict oact);
sigaction: 指定或者修改与指定信号相关联的处理动作。可用sigaction实现signal
struct sigaction:{
void (*sa_handler )(int); /*addr of signal handler,
or SIG_IGN or SIG_DFL.*/
sigset_t sa_mask /*additional signals to block */
int sa_flags /* Special flags to affect behavior of signal. */
void(*sa_sigaction )(int, siginfo_t *, void *) Pointer to a signal-catching function.
sa_handler: 信号处理函数，参数为int，如同signal函数的参数意愿。
sa_sigaction: 信号处理函数，参数有3个。
至于选择sa_handler指向的函数还是sa_sigaction指向的函数，需要依靠sa_flags判断。
sa_flags: 指定信号处理行为，以下值可以使用或组合
SA_NOCLDSTOP: 父进程在子进程暂停或者继续运行时不会收到SIGCHLD信号
SA_ONSTACK : 如果设置此标志，且使用了sigaltstack设置了备用信号堆栈，则信号会传递给该堆栈中的进程，否则，在当前的进程中
SA_RESETHAND: 信号处理之后，重新设置为默认的处理方式
SA_RESTART : 被信号打断的系统调用自动重新发起
SA_SIGINFO : 使用sa_sigaction做为处理函数，而不是sa_handler
SA_NOCLDWAIT: 父进程在子进程中退出不会收到SIGCHLD信号，且子进程不会变成僵尸进程
SA_NODEFER : 使sa_mask设置的屏蔽无效
sa_mask: 在信号处理函数执行过程中，屏蔽哪些信号。注意的是，这个屏蔽仅在信号处理函数执行过程中有效，而不是整个进程。
程序用例：
#include "apue.h"
static void sigfunc(int signo)
{
printf("signo: %d\n", signo);
sleep(10);
printf("sleep over\n");
}
static void sigfunc_int(int signo)
{
printf("SIGINT occur\n");
}
int main(int argc, char** argv)
{
struct sigaction act;
act.sa_flags = SA_NODEFER;
sigemptyset(&act.sa_mask);
act.sa_handler = sigfunc_int;
sigaction(SIGINT, &act, NULL);
act.sa_handler = sigfunc;
sigaddset(&act.sa_mask, SIGINT);
/*阻塞SIGINT信号，在输出时，如果我们先用ctrl+c产生SIGINT信号，
则立即处理该信号退出程序，但是如果程序先捕获到的是SIGQUIT信号，
则sigaddset处理会将SIGINT阻塞，先执行sigfunc()函数，sleep10秒后，
执行sigfunc_int函数，完成后退出。
*/
if(sigaction(SIGQUIT, &act, NULL) == -1)
{
printf("sigaction failed");
exit(EXIT_FAILURE);
}
sleep(20);
printf("\n");
return 0;
}
2108
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
