5.1信号一2015/7/28
1.信号的种类
$ kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX 一般只关心前32个
信号产生的方式
终端特殊按键
ctl+c SIGINT //终止进程
ctl+z SIGTSTP //暂停进程并切换到后台
ctl+\ SIGQUIT //退出(核心已转储)
终端接收到特殊按键后，终端发给内核，内核再给当前进程的PCB发送相应信号
硬件异常
除0操作 //SIGFPE 8 (核心已转储)
访问非法内存 //SIGSEGV 11 (段错误)
/*访问MMU没有分配访问权限(例如3G~4G)，但用户去访问就会产生非法访问*/
进程接收到信号后会有三类行为：默认行为，忽略行为，捕捉行为
忽略行为：无视信号
捕捉行为：要先设置一个信号处理函数(do_sig)，当前进程收到该信号时，触发这个信号处理函数，执行该函数里面的内容(自行设计)
默认行为:包含5种动作，term(把当前进程终止掉)，core(终止进程，并产生一个core文件，ulimit -c 1024设置core文件大小)，stop(让当前进程暂停)，continue(继续执行先前停止的进程),ignore(忽略)
Term Default action is to terminate the process.
Ign Default action is to ignore the signal.
Core Default action is to terminate the process and dump core (see core(5)).
Stop Default action is to stop the process.
Cont Default action is to continue the process if it is currently stopped.
当没有对信号进行特殊处理之前，32种信号里面的行为都是默认行为里面的默认动作
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 tty
SIGTTIN 21,21,26 Stop tty input for background process
SIGTTOU 22,22,27 Stop tty output for background process
函数产生信号
kill给特定进程或进程组发送信号
既是命令又是函数
int kill(pid_t, int sig)
pid > 0 sig发送给ID为pid的进程
pid == 0 sig发送给与发送进程同组的所有进程
pid < 0 sig发送给组ID为|-pid|的进程，并且发送进程具有向其发送信号的权限
pid == -1 sig发送给发送进程有权限向他们发送信号的系统上的所有进程(慎用！)
sig为0时，用于检测，特定为pid进程是否存在，如不存在，返回-1
kill(geipid,sig)给自己发信号
例子：
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int signum;
pid_t pid_id;
if(argc < 3) {
printf("./mykill signum pid_id\n");
exit(-1);
}
signum = atoi(argv[1]); //receive sig_id
pid_id = atoi(argv[2]); //receive pid_id
if(kill(pid_id, signum) < 0) { //error is set appropriately
perror("kill");
exit(-1);
}
return 0;
}raise/abort给自己发信号
int raise(int sig)
给自己进程发送设置的信号
void abort(void)
给自己发送SIGABRT，默认行为core，自己把自己干掉，(核心已转储)
某种软件条件满足时产生信号
1.管道：读端关闭，写端写管道，那么该进程会收到SIGPIPE信号，默认动作core
2.alarm定时器，每个进程有且只有一个定时器,当时间到时，当前进程会收到SIGALRM信号，默认行为trem
3.子进程结束时，父进程会收到SIGCHLD这个信号。默认动作为忽略这个信号
unsigned int alarm(unsigned int seconds)
例
#include <stdio.h>
#include <unistd.h>
int main(void)
{
int count = 0;
alarm(1); //timing 1s，send SIGALARM，core
while(1) {
printf("count = %d", count++); //how many times a second print
}
return 0;
}进程处理信号行为
SIG_IGN 默认
term
core
gcc -g file.c
ulimit -c 1024
gdb a.out core
进程死之前的内存情况，死后验尸
ign
stop
cont
SIG_DFL 忽略
a signal handling function 捕捉
PCB信号集
未决信号集，阻塞信号集，信号处理动作都在PCB中
未决态：信号产生了，还没有被进程响应，那么此信号处在未决态
递达态：信号产生了，并且被当前进程响应了，那么此信号称之为递达
信号集处理函数
sigset_t为信号集，可sizeof(sigset_t)查看大小
int sigemptyset(sigset_t *set) //set传出参数，清空set
int sigfillset(sigset *set) //把set全部置1
int sigaddset(sigset_t *set, int signo) //把信号集里的第signo这一位置1，添加一个信号
int sigdelset(sigset_t *set, int signo) //把信号集里的第signo这一位置0，删除一个信号
int sigismember(const sigset_t *set, int signo) //测试，在set这个信号集里面signo这个信号位是否为1，存在返回1，不存在返回0
调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)
#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
return：成功返回0，出错返回-1how参数的含义
SIG_BLOCK set包括了我们希望添加到当前信号屏蔽字的信号，相当于mask=mask|set
SIG_UNBLOCK set包含了我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask=mask&`set(set先取反，在进行位与操作)
SIG_SETMASK 设置当前信号屏蔽字为set所指向的值，相当于mask=set
sigpending读取当前进程的未决信号集,通过set传出
#include <signal.h>
int sigpending(sigset_t *set);
return：successful 0, error -1.
例子：
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void printsigset(sigset_t *p)
{
int i = 0;
for(i=0; i<32; i++) /* print 0~31 signal status */
if(sigismember(p, i) == 1) /* test p signal status */
putchar('1');
else
putchar('0');
puts(""); /* wrap */
}
int main(void)
{
int i = 0;
sigset_t set, p;
sigemptyset(&set); /* empty set */
sigaddset(&set, SIGINT); /* add SIGINT to set */
sigprocmask(SIG_SETMASK, &set, NULL); /* replace block */
while(1) {
sigpending(&p); /* get pending */
printsigset(&p); /* print peding */
sleep(1);
}
retrun 0;
}信号捕捉设定
#include <signal.h>
int sigaction(int signum, const struct sigaction sigaction *act, struct sigaction *oldact);
struct sigaction 定义：
struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *)
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};
(*sa_handler)(int);有三种情况：SIG_DFL(默认)，SIG_IGN(忽略)，a pointer to a signal handling function
sa_mask;掩码，当运行signal handling function的时候还想阻塞哪些信号，临时的，只作用于signal handling function
例子：
#include <stdio.h>
#include <signal.h>
void do_sig(int num) /* signal handling function, num is signal number*/
{
printf("I am in signal handling %d\n", num);
}
int main(void){
int i = 0;
struct sigaction set;
set.sa_handler = do_sig; /* set function address */
sigemptyset(&set.sa_mask); /* empty mask */
set.sa_flags = 0;
sigaction(SIGINT, &set, NULL); /* handling SIGINT signal 2 */
while(1) {
printf("i = %d\n", i++);
sleep(1);
}
return 0;
}do_sig是内核调用的，但是用户身份执行的
0.产生信号，打断当前进程，切换到内核空间，当前进程的处理器现场会保存到内核的栈空间里面去
1.内核接收到信号，去调do_sig函数，在代码段执行。
2.当do_sig执行完毕，返回内核去。
3.内核进行进程调度，把处理器现场重新加载到寄存器中，继续执行刚才被信号打断的进程。
C标准库信号处理函数
typedef void(*sighandler_t)(int)
sighandler_t signal(int signum, sigbandler_t handler)
int system(const char *command)
集合了fork，exec，wait一体
例子：
#include <stdio.h>
#include <signal.h>
void do_sig(int n)
{
printf("here I am SIGINT handler\n");
}
int main(void)
{
signal(SIGINT, do_sig);
while(1) {
printf("*******************\n");
sleep(1);
}
return 0;
}
------------------------------------------------
#include <stdlib.h>
int main(void)
{
system("ls -l");
return 0;
}不可重入函数
含全局变量和静态变量是不可重入函数的一个要素
可重入函数可以通过man 7 signal查看
在信号捕捉函数里面应使用可重入函数
时序竞态
int pause(void)
使调用进程挂起，知道有信号递达，如果递达信号是忽略，则继续挂起
int singsuspend(const sigset_t *mask)
1.以通过指定mask来临时解除对某个信号的屏蔽
2.然后等待挂起
3.当被信号唤醒sigsuspend返回时，进程的信号屏蔽字恢复为原来的值
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
void do_sig(int num)
{
/* nothing to do */
}
unsigned int mysleep(unsigned int nsecs)
{
struct sigaction newact, oldact;
unsigned int unslept;
newact.sa_flags = 0;
newact.sa_handler = do_sig;
sigemptyset(&newact.sa_mask);
sigaction(SIGALRM, &newact, &oldact); /* set newmask, get oldmask to oldact */
alarm(nsecs); /* set SIGALRM */
pause();
unslept = alarm(0); /* if alarm clock is no finished, it will return the remanining number of seconds when alarm is again */
sigaction(SIGALRM, &oldact, NULL); /* set oldmask to block*/
return unslept;
}
int main(void)
{
while(1) {
mysleep(2);
printf("Two second passed\n");
}
}上述代码，当进程执行完alarm(nsecs)定时器之后，kernel又去调用其他进程，该进程处理器现场保存，但是定时器依旧在计时，当计时器订完之后，kernel在来执行该进程，恢复处理器现场，会立即出发sigaction里的do_sig函数，这个函数执行完之后，会再去执行pause(),那此进程这时候会被永久挂起。因为没有信号来触发pause了。
解决方式
unsigned int mysleep(unsigned int nsecs)
{
struct sigaction newact, oldact;
sigset_t newmask, oldmask, suspmask;
unsigned int unslept;
/* set our handler, save previous information */
newact.sa_flags = 0;
newact.sa_handler = do_sig;
sigemptyset(&newact.sa_mask);
sigaction(SIGALRM, &newact, &oldact);
/* block SIGALRM and save current signal mask*/
sigemptyset(&newmask);
sigaddset(&newmask, SIGALRM);
sigprocmask(SIG_BLOCK, &newmask, &oldmask);
alarm(nsecs);
suspmask = oldmask;
sigdelset(&suspmask, SIGALRM); /* mask sure SIGALRM isn't blocked*/
sigsuspend(&suspmask); /* wait for any signal to be caught*/
/* some signal has been caught, SIGALRM is now blocked*/
unslept = alarm(0);
sigaction(SIGALRM, &oldact, NULL); /* reset previous action */
sigprocmask(SIG_SETMASK, &oldmask, NULL);
return unslept;
}说明，在设置好捕捉函数之后，在定义一个新的信号屏蔽字，把这个屏蔽字先用sigemptyset清空，然后在用sigaddset把SIGALRM信号加上，再通过 sigprocmask(SET_BLOOK,&newmask,&oldmask) 把原来的信号屏蔽字表替换掉，原来的保存到oldmask中，此时SIGALRM这个信号是屏蔽的，这时候去调用alarm(),下面接着把oldmask表里面的内容复制到suspmask中，把其中的SIGALRM删除，确认SIGALRM这个信号在suspmask里面是非阻塞的，然后执行sigsuspand(&suspmask),这个函数是先把当前进程的信号屏蔽字表临时替换成suspmask这个，然后挂起等待，等alarm定的时间到了，给进程发送SIGALRM信号，此时的进程的信号屏蔽字表是不对它屏蔽的，所以触发sigsuspmask这个函数，进程继续往下执行，信号屏蔽字重新变回到newmask，之后重新设置一个alarm通过返回值查看之前的闹钟是否执行完全，然后通过sigacton和siaprocmask把之前的捕捉动作和信号屏蔽字重新改回去。