信号
系统中的信号
使用kill -l命令产看当前系统中可使用的信号:
每个进程都可以收到上面这些信号,这些信号都是由内核负责返送,内核负责处理。
特别强调,9号和19号信号不允许忽略和捕捉和阻塞,只能执行默认动作
信号的产生和处理
产生信号:
1.按键产生:
Ctrl + c → 2) SIGINT(终止/中断) “INT” ----Interrupt
Ctrl + z → 20) SIGTSTP(暂停/停止) “T” ----Terminal 终端。
Ctrl + \ → 3) SIGQUIT(退出)
2.系统调用产生,如:kill、raise、abort
3.软件条件产生,如:定时器alarm
4.硬件异常产生:
除0操作 → 8) SIGFPE (浮点数例外) “F” -----float 浮点数。
非法访问内存 → 11) SIGSEGV (段错误)
总线错误 → 7) SIGBUS
未决:产生和递达之间的状态,主要由于阻塞(屏蔽)导致该状态
信号处理方式:
- 执行默认动作
Term:终止进程
Ign:忽略信号(默认即对该种信号忽略操作)
Core:终止进程,生成Core文件。(检验进程死亡原因,用于gdb调试)
Stop:停止(暂停)进程
Cont:继续运行进程
- 忽略(丢弃)
- 捕捉(调用用户处理函数)
阻塞信号集(信号屏蔽字):将某些信号加入集合,对他们设置屏蔽,当屏蔽X信号后,再收到该信号,该信号的处理将推后。
未决信号集:
- 信号产生,未决信号集中描述该信号的位立刻翻转为1,表示信号处于未决状态,当信号被处理对应位翻转为0,这一时刻往往非常短暂。
- 信号产生后由于某些原因(主要时阻塞)不能抵达,这类信号的集合称之为未决信号集,在解除屏蔽前,信号一直处于未决状态,也就是1。
kill函数
kill命令产生信号:kill -SIGKILL pid
kill函数:给指定进程发送指定信号
int kill(pid_t pid, int sig); 成功返回0,失败返回-1,sig不推荐直接使用数字,应该使用宏名,因为不同操作系统信号编号可能不同,但是名称是一样的。
pid > 0:发送信号给指定进程
pid = 0:发送信号给与调用kill函数进程属于同一进程组的所有进程
pid < 0:取|pid|发给对应进程组
pid = -1:发送给进程有权限发送的系统中所有进程。
进程组:每个进程都属于一个进程组,进程组是一个或多个进程集合,他们相互关联,共同完成一个实体任务,每个进程组都有一个进程组长,默认进程组ID与进程组长ID相同。
权限保护:super用户(root)可以发送信号给任意用户,普通用户是不能向系统用户发送信号的,kill -9 root用户的pid 是不可以的,同样,普通用户也不能向其他普通用户发送信号,终止其进程,只能向自己创建的进程发送信号。普通用户基本规则是:发送者实际或有效用户ID == 接收者实际或有效用户ID。
练习:循环创建5个子进程,父进程终止第三个子进程。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#define N 5
int main(void)
{
int i;
pid_t pid, q;
for (i = 0; i < N; i++) {
pid = fork();
if (pid == 0)
break;
if (i == 2)
q = pid;
}
if (i < 5) {
while(1) {
printf("I'm child %d, getpid = %u\n", i, getpid());
sleep(1);
}
} else {
sleep(1);
kill(q, SIGKILL);
while (1);
}
return 0;
}
raise和abort函数
raise函数:给当前进程发送指定信号(自己给自己发)
raise(signo) == kill(getpid(), signo);
int raise(int sig); 成功返回0,失败非0值
abort函数:给自己发送异常终止信号6)SIGABRT信号,终止并产生core文件
void abort(void); 该函数没有返回值
alarm和setitimer函数
alarm函数
设置定时器(闹钟),在指定seconds后,内核会给当前进程发送14)SIGALRM信号。进程收到该信号,默认动作终止。
每个进程都有且只有唯一一个定时器
unsigned int alarm(unsigned int seconds); 返回0或者剩余的秒数,无失败
常用:取消定时器alarm(0),返回旧闹钟余下秒数。
练习:编写程序,测试你使用的计算机1秒钟能数多少个数。
#include <stdio.h>
#include <unistd.h>
int main(void)
{
int i;
alarm(1);
for(i = 0; ; i++)
printf("%d\n", i);
return 0;
}
setitmer函数
设置定时器(闹钟),可替代alarm函数,精确到微秒,还可以实现周期定时。
int setitimer(int which, const struct itimerval *new_value, struct itimer *old_value);
成功返回0,失败返回-1,设置errno;
参数which:指定定时方式
- 自然定时:ITIMER_REAL →14)SIGLARM 计算自然时间
- 虚拟空间计时(用户空间):ITIMER_VIRTUAL→26)SIGVTALRM 只计算进程占用cpu的时间
- 运行时计时(用户+内核):ITIMER_PROF→27)SIGPROF 计算占用cpu及执行系统调用的时间
练习:使用seitimer函数实现alarm函数,重复计算机1秒数多少个数
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
/*
* struct itimerval {
struct timeval{
it_value.tv_sec;
it_value.tv_usec;
} it_interval;
struct timeval {
it_value.tv_sec;
it_value.tv_usec;
} it_value;
} it, oldit;
*/
unsigned int my_alarm(unsigned int sec)
{
struct itimerval it, oldit;
int ret;
it.it_value.tv_sec = sec;
it.it_value.tv_usec = 0;
it.it_interval.tv_sec = 0;
it.it_interval.tv_usec = 0;
ret = setitimer(ITIMER_REAL, &it, &oldit);
if (ret == -1) {
perror("setitimer");
exit(1);
}
return oldit.it_value.tv_sec;
}
int main(void)
{
int i;
my_alarm(1); //alarm(sec);
for(i = 0; ; i++)
printf("%d\n", i);
return 0;
}
信号集操作函数
内核通过读取未决信号集来判断信号是否应被处理,信号屏蔽字mask可以影响未决信号集,而我们可以在应用程序中自定义set来改变mask,来达到屏蔽指定信号的目的。
sigset_t set; //typedef unsigned long sigset_t
int sigemptyset(sigset_t *set); 将某个信号集清0
int sigfillset(sigset_t *set); 将某个信号集置1
int sigaddset(sigset_t *set, int signum); 将某个信号加入信号集
int sigdellset(sigset_t *set, int signum); 将某个信号清出信号集
int sigismemeber(const sigset_t *set, int signum); 判断某个信号是否在信号集中
上面这几个信号集操作函数都是成功返回0,失败返回-1
sigset_t类型的本质是位图,但不应该直接使用位操作,而应该使用上述函数,保证跨系统操作有效。
sigprocmask函数
用来屏蔽信号,解除屏蔽也使用该函数,其本质是读取或修改进程的信号屏蔽字(PCB中),严格注意,屏蔽信号只是将信号处理延后执行(延至解除屏蔽),而忽略表示将信号丢处理。
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);成功返回0,失败返回-1
参数:
set:传入参数,是一个位图,set中哪个位置为1,就表示当前进程屏蔽哪个信号。
oldset:传出参数,保存旧的信号屏蔽集。
how参数取值,假设当前的信号屏蔽字为mask
1.SIG_BLOCK:当how设置为此值,set表示需要屏蔽的信号,相当于mask=mask|set
2.SIG_UNBLOCK:当how设置为此值,set表示需要解除屏蔽的信号,相当于mask=mask& ~set
3.SIG_SETMASK:当how设置为此值,set表示用于替代原始屏蔽集的新屏蔽集,相当于mask=set
sigpending函数
读取当前进程的未决信号集
int sigpending(sigset_t *set);
set表示传出参数,成功返回0,失败返回-1,设置errno
练习:编写程序,把所有常规信号的未决状态打印至屏幕。
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void printset(sigset_t *ped)
{
int i;
for(i = 1; i < 32; i++){
if((sigismember(ped, i) == 1)){
putchar('1');
} else {
putchar('0');
}
}
printf("\n");
}
int main(void)
{
sigset_t ped;
while(1){
sigpending(&ped); //获取未决信号集
printset(&ped);
sleep(1);
}
return 0;
}
信号捕捉
singal函数
注册一个信号捕捉函数:
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
该函数由ANSI定义,由于历史原因在不同版本的Unix和不同版本的Linux中可能有不同的行为,因此应该尽量避免使用它,取而代之使用sigaction函数。
void (*signal(int signum, void(*sighandler_t)(int)))(int);
#include <signal.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
typedef void (*sighandler_t) (int);
void catchsigint(int signo)
{
printf("-----------------catch\n");
}
int main(void)
{
sighandler_t handler;
handler = signal(SIGINT, catchsigint);
if (handler == SIG_ERR) {
perror("signal error");
exit(1);
}
while (1);
return 0;
}
sigaction函数
修改信号处理动作(通常在Linux中用来注册一个信号的捕捉函数)
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
成功返回0失败返回-1,设置errno
参数:
act:传入参数,新的处理方式
oldset:传出参数,旧的处理方式
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_restorer:该元素是过时的,不应该使用,POSIX.1标准将不指定该元素,已弃用
sa_sigaction:当sa_flags被指定为SA_SIGINFO标志时,使用该信号处理程序,很少使用。
重点掌握:
sa_handler:指定信号捕捉后的处理函数名(即注册函数),也可赋值为SIG_IGN表示忽略,或者SIG_DFL表示执行默认动作。
sa_mask:调用信号处理函数时,所要屏蔽的信号集合(信号屏蔽字),仅在处理函数被调用期间屏蔽生效,是临时设置。
sa_flags:通常设置为0,表示使用默认属性。
信号捕捉特性
1.进程正常运行时,默认PCB中有一个信号屏蔽字,假设为mask,它决定了进程自动屏蔽哪些信号,当注册了某个信号捕捉函数,捕捉到该信号以后,要调用捕捉函数,而捕捉函数有可能执行很长时间,在这期间所屏蔽的信号不由mask来指定,而是用sa_mask来指定,当调用完信号捕捉函数后,再恢复为mask。如果在捕捉函数执行期间,收到的信号没有被屏蔽,则立即跳出该捕捉函数去处理没有被屏蔽的信号。
2.XXX信号捕捉函数执行期间,XXX信号自动被屏蔽。
3.阻塞的常规信号不支持排队,产生多次只记录一次,后32个实时信号支持排队。
练习:为某个信号设置捕捉函数
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
/*自定义的信号捕捉函数*/
void sig_int(int signo)
{
printf("catch signal SIGINT\n");//单次打印
sleep(10);
printf("----slept 10 s\n");
}
int main(void)
{
struct sigaction act;
act.sa_handler = sig_int;
act.sa_flags = 0;
sigemptyset(&act.sa_mask); //不屏蔽任何信号
sigaddset(&act.sa_mask, SIGQUIT);
sigaction(SIGINT, &act, NULL);
printf("------------main slept 10\n");
sleep(10);
while(1);//该循环只是为了保证有足够的时间来测试函数特性
return 0;
}
练习:验证在信号处理函数执行期间,该信号多次递送,那么只在处理函数执行结束之后,处理一次
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
/*自定义的信号捕捉函数*/
void sig_int(int signo)
{
printf("catch signal SIGINT\n");//单次打印
sleep(10);
printf("----slept 10 s\n");
}
int main(void)
{
struct sigaction act;
act.sa_handler = sig_int;
act.sa_flags = 0;
sigemptyset(&act.sa_mask); //不屏蔽任何信号
sigaddset(&act.sa_mask, SIGQUIT);
sigaction(SIGINT, &act, NULL);
printf("------------main slept 10\n");
sleep(10);
while(1);//该循环只是为了保证有足够的时间来测试函数特性
return 0;
}
练习:验证sa_mask在捕捉函数执行期间的屏蔽作用
/*当执行SIGINT信号处理函数期间
*多次收到SIGQUIT信号都将被屏蔽(阻塞)
*SIGINT信号处理函数处理完,立刻解除对
*SIGQUIT信号的屏蔽,由于没有捕捉该信号,
*将立刻执行该信号的默认动作,程序退出
*/
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
void sig_int(int signo)
{
printf("catch signal SIGINT\n");
sleep(10); //模拟信号处理函数执行很长时间
printf("end of handler\n");
}
int main(void)
{
struct sigaction act;
act.sa_handler = sig_int;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask, SIGQUIT);
/*将SIGQUIT加入信号屏蔽集,这就导致,在调用信号处理函数期间
*不仅不响应SIGINT信号本身,还不响应SIGQUIT*/
act.sa_flags = 0;
sigaction(SIGINT, &act, NULL); //注册信号SIGINT捕捉函数
while(1);
return 0;
}
内核实现信号捕捉过程
竞态条件(时序竞态)
pause函数
调用该函数可以造成进程主动挂起,等待信号唤醒,调用该系统调用的进程将处于阻塞状态(主动放弃cpu)直到有信号递达将其唤醒。
int pause(void);
返回值:
1.如果信号的默认处理动作是终止进程,则进程终止,pause函数没有机会返回。
2.如果信号的默认处理动作是忽略,则进程继续处于挂起状态,pause函数不返回。
3.如果信号的处理动作是捕捉,则调用完信号处理函数之后,pause返回-1,errno设置未EINTR,表示“被信号中断”。
4.pause收到的信号不能被屏蔽,如果被屏蔽,那么pause就不能被唤醒。
练习:使用pause和alarm来实现sleep函数。
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
void sig_alrm(int signo)
{
/* nothing to do */
}
unsigned int mysleep(unsigned int nsecs)
{
struct sigaction newact, oldact;
unsigned int unslept;
newact.sa_handler = sig_alrm;
sigemptyset(&newact.sa_mask);
newact.sa_flags = 0;
sigaction(SIGALRM, &newact, &oldact);
alarm(nsecs);
pause();
//取消闹铃,将SIGALRM信号处理还原
unslept = alarm(0);
sigaction(SIGALRM, &oldact, NULL);
return unslept;
}
int main(void)
{
while(1){
mysleep(2);
printf("Two seconds passed\n");
}
return 0;
}
注意alarm(0)的用法:
例如:睡觉,alarm(10)闹铃
正常:10秒后闹钟将我唤醒,这时额外设置alarm(0)取消闹铃,不会出错。
异常:5秒后,被其他事物吵醒,alarm(0)取消闹铃防止打扰。
时序竞态问题(sigsuspend函数)
回看pause和alarm实现的mysleep函数,设想如下时序:
1.注册SIGALRM信号处理函数
2.调用ararm(2)设定闹钟
3.函数调用刚结束,开始倒计时2秒,当前进程失去cpu,内核调度优先级高的进程(有多个)取代当前进程,当前进程无法获得cpu,进入就绪态等待cpu。
4.经过2秒后,闹钟超时,内核向当前进程发送SIGALRM信号(自然定时法,与进程状态无关),高优先级进程尚未执行完,当前进程仍处于就绪状态,信号无法处理(未决)。
5.优先级高的进程执行完,当前进程获得cpu资源,内核调度回当前进程执行,SIGALRM信号递达,信号设置捕捉,执行处理函数sig_alrm.
6.信号处理函数执行结束,返回当前进程主控流程,pause()被调用挂起等待(欲等待alarm函数发送的SIGALRM信号将自己唤醒)。
7.SIGALRM信号已经处理完毕,pause不会等到。
想要解决上面的时序问题,可以通过设置屏蔽SIGALRM的方法来控制程序执行逻辑,但无论如何设置,程序都有可能在解除信号屏蔽与挂起等待信号这两个操作间隙失去cpu资源,除非将这两个步骤合并成一个原子操作。sigsuspend函数具备这个功能,在对时序要求严格的场合下都应该使用sigsuspend替换pause。
int sigsuspend(const sigset_t *mask); 挂起等待信号。
sigsuspend函数调用期间,进程信号屏蔽字由其参数mask指定。
可将某个信号(如SIGALRM)从临时信号屏蔽字mask中删除,这样在调用sigsuspend时将解除对该信号的屏蔽,然后挂起等待,当sigsuspend返回时,进程的信号屏蔽字恢复为原来的值,如果原来对该信号是屏蔽态,sigsuspend函数返回后仍然屏蔽该信号。
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
void sig_alrm(int signo)
{
/* nothing to do */
}
unsigned int mysleep(unsigned int nsecs)
{
struct sigaction newact, oldact;
sigset_t newmask, oldmask, suspmask;
unsigned int unslept;
//1.为SIGALRM设置捕捉函数,一个空函数
newact.sa_handler = sig_alrm;
sigemptyset(&newact.sa_mask);
newact.sa_flags = 0;
sigaction(SIGALRM, &newact, &oldact);
//2.设置阻塞信号集,阻塞SIGALRM信号
sigemptyset(&newmask);
sigaddset(&newmask, SIGALRM);
sigprocmask(SIG_BLOCK, &newmask, &oldmask); //信号屏蔽字 mask
//3.定时n秒,到时后可以产生SIGALRM信号
alarm(nsecs);
/*4.构造一个调用sigsuspend临时有效的阻塞信号集,
* 在临时阻塞信号集里解除SIGALRM的阻塞*/
suspmask = oldmask;
sigdelset(&suspmask, SIGALRM);
/*5.sigsuspend调用期间,采用临时阻塞信号集suspmask替换原有阻塞信号集
* 这个信号集中不包含SIGALRM信号,同时挂起等待,
* 当sigsuspend被信号唤醒返回时,恢复原有的阻塞信号集*/
sigsuspend(&suspmask);
unslept = alarm(0);
//6.恢复SIGALRM原有的处理动作,呼应前面注释1
sigaction(SIGALRM, &oldact, NULL);
//7.解除对SIGALRM的阻塞,呼应前面注释2
sigprocmask(SIG_SETMASK, &oldmask, NULL);
return(unslept);
}
int main(void)
{
while(1){
mysleep(2);
printf("Two seconds passed\n");
}
return 0;
}
总结:
竞态条件,跟系统负载有很密切的关系,体现出信号的不可靠性,系统负载越严重,信号不可靠性越强。
不可靠由其实现原理所致,信号是通过软件方法实现(跟内核调度高度依赖,延时性强),每次系统调用结束或中断处理结束后,需要通过扫描PCB中的未决信号集来判断是否应该处理某个信号,当系统负载过重时,会出现时序混乱。
这种意外情况只能在编写程序过程中,提早预见,主动规避,而无法通过gdb程序调试等其他手段弥补,且由于该错误不具规律性,后期捕捉和重现十分困难。
全局变量异步I/O
分析如下父子进程交替数数程序,重点分析程序中3个sleep函数的作用,如果取消掉用户处理函数中的两个sleep函数会发生什么问题:
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
int n = 0, flag = 0;
void sys_err(char *str)
{
perror(str);
exit(1);
}
void do_sig_child(int num)
{
printf("I am child %d\t%d\n", getpid(), n);
n += 2;
flag = 1;
sleep(1);
}
void do_sig_parent(int num)
{
printf("I am parent %d\t%d\n", getpid(), n);
n += 2;
flag = 1;
sleep(1);
}
int main(void)
{
pid_t pid;
struct sigaction act;
if ((pid = fork()) < 0)
sys_err("fork");
else if (pid > 0) {
n = 1;
sleep(1);
act.sa_handler = do_sig_parent;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGUSR2, &act, NULL); //注册自己的信号捕捉函数 父使用SIGUSR2信号
do_sig_parent(0);
while(1) {
/* wait for signal */;
if (flag == 1) { //父进程数数完成
kill(pid, SIGUSR1);
flag = 0; //标志已经给子进程发送完信号
}
}
} else if (pid == 0){
n = 2;
act.sa_handler = do_sig_child;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGUSR1, &act, NULL);
while(1) {
/* wait for signal */;
if (flag == 1) {
kill(getppid(), SIGUSR2);
flag = 0;
}
}
}
return 0;
}
SIGUSR1和SIGUSR2信号。用户自定义信号,程序员可以在程序中定义并使用该信号。默认动作为终止进程。
上述函数的正常执行结果本应该是:父进程数1、3、5、7、······;子进程数2、4、6、8、·······,且它们之间交替数数。
父进程中的第一个sleep函数确保在父进程向子进程发送信号前,子进程已经完成了对信号的注册(因为子进程有可能失去CPU时间太长而未完成对信号的注册),否则会导致子进程收到信号被终结。
在父进程中的全局变量flag在用户处理函数中和主控程序(while循环中)都会被修改(子进程也一样),但是正确的执行顺序必须是:父进程完成数数→用户处理函数置flag为1→父进程发信号→主控程序置flag为0。flag为1确保向进程发送信号,flag为0确保信号只是发送一次,不重复发送。但是,如果其中某一个进程(父进程或子进程)在while循环中刚发送完信号就失去了CPU,还未对flag进行修改,此时另一个进程处理完信号后,再次向该进程发送信号,此时该进程接收到信号不会接着执行flag=0的操作了,会马上去处理信号,信号处理完后,才会回到主控程序执行flag=0的操作,此时显然顺序发生了颠倒,导致最终flag错误置为0。因此,该进程处理完信号后再也不会发送信号了,另一个进程也再也不会收到信号,从而更不会再发信号。两个进程都在while循环中重复判断条件,但是条件永远不满足。因此,用户捕捉函数中的两个sleep函数的作用就是确保,一个进程在向两一个进程发送信号前,另一个进程主控程序中的flag=0的操作已经执行了,确保变量值修改的正确性。
如何解决该问题呢?可以使用后续章节讲到的“锁”机制。当操作全局变量的时候,通过加锁、解锁来解决该问题(互斥访问,进程同步)。
现阶段,我们在编程期间如若使用全局变量,应在主观上注意全局变量的异步IO可能造成的问题。
上述问题虽然可以通过sleep函数来解决,但是sleep函数会导致数数效率太低,可以取消全局变量flag,让发送信号的操作在用户处理函数中完成即可。
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
int n = 0;
pid_t pid;
void sys_err(char *str)
{
perror(str);
exit(1);
}
void do_sig_child(int num)
{
printf("I am child %d\t%d\n", getpid(), n);
n += 2;
kill(getppid( ) , SIGUSR2);
}
void do_sig_parent(int num)
{
printf("I am parent %d\t%d\n", getpid(), n);
n += 2;
kill(pid , SIGUSR1);
}
int main(void)
{
struct sigaction act;
if ((pid = fork()) < 0)
sys_err("fork");
else if (pid > 0) {
n = 1;
sleep(1);
act.sa_handler = do_sig_parent;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGUSR2, &act, NULL);
do_sig_parent(0);
while(1) {
;
}
} else if (pid == 0){
n = 2;
act.sa_handler = do_sig_child;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGUSR1, &act, NULL);
while(1) {
;
}
}
return 0;
}
可/不可重入函数
一个函数在被调用执行期间(尚未调用结束),由于某种时序又被重复调用,称之为重入。根据数实现的方法可分为可重入函数和不可重入函数两种。
显然,insert函数是不可重入函数,会导致意外结果出现,究其原因,是该函数内部实现使用了全局变量。
注意:
1.定义可重入函数,函数内不能含有全局变量及static变量,不能使用malloc和free。
2.信号捕捉函数应设计为可重入函数。
3.信号处理程序可以调用的可重入函数可参阅man 7 signal。
4.没有包含在上述列表中的函数大多是不可重入的,因为:
a)使用了静态数据结构
b)调用了malloc或free
c)是标准I/O函数
SIGCHLD信号
产生条件:
1.子进程终止时
2.子进程收到SIGSTOP信号停止时
3.子进程处在停止态,接收到SIGCONT后唤醒时
可以借助SIGCHLD信号回收子进程
子进程结束时,其父进程会收到SIGCHLD信号,该信号的默认处理动作是忽略,可以捕捉该信号,在捕捉函数中完成子进程状态的回收。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
void sys_err(char *str)
{
perror(str);
exit(1);
}
void do_sig_child(int signo)
{
int status;
pid_t pid;
// if ((pid = waitpid(0, &status, WNOHANG)) > 0) {
while ((pid = waitpid(0, &status, WNOHANG)) > 0) {
if (WIFEXITED(status))
printf("------------child %d exit %d\n", pid, WEXITSTATUS(status));
else if (WIFSIGNALED(status))
printf("child %d cancel signal %d\n", pid, WTERMSIG(status));
}
}
int main(void)
{
pid_t pid;
int i;
//阻塞SIGCHLD
for (i = 0; i < 10; i++) {
if ((pid = fork()) == 0)
break;
else if (pid < 0)
sys_err("fork");
}
if (pid == 0) { //10个子进程
int n = 1;
while (n--) {
printf("child ID %d\n", getpid());
sleep(1);
}
return i+1;
} else if (pid > 0) {
//SIGCHLD阻塞
struct sigaction act;
act.sa_handler = do_sig_child;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGCHLD, &act, NULL);
//解除对SIGCHLD的阻塞
while (1) {
printf("Parent ID %d\n", getpid());
sleep(1);
}
}
return 0;
}
如果每创建一个子进程后不使用sleep可以吗?可不可以将信号捕捉函数的while替换为if,为什么?
if((pid = waitpid(0, &status, WNOHANG)) > 0){…}
最好使用sleep,防止父进程还没有捕获SIGCHILD信号,子进程就结束了。
不能将while替换为if,会导致有些子进程没有回收,因为信号不支持排队,当一个子进程的SIGCHLD信号被捕获,进入捕捉函数之后,如果同时有其他三个子进程发送SIGCHLD,依据信号捕捉特性,这三个子进程的信号只捕捉一个,从而导致其他两个子进程没有被捕捉。
信号传参
sigqueue函数对应kill函数,可在指定进程发送信号的同时携带参数
int sigqueue(pid_t pid, int sig, const union sigval value);//成功返回0,失败返回-1,设置errno
union sigval
{
int sival int;
void *sival_ptr;
}
向指定进程发送指定信号的同时,携带数据,如果传地址需要注意,不同进程之间虚拟地址控件各自独立,将当前进程地址传递给另一个进程没有实际意义。
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);
};
当注册信号捕捉函数,希望获得更多信号相关信息,不应使用sa_handler而应该使用sa_sigaction,但此时sa_flags必须指定为SA_SIGINFO,siginfo_t是一个成员十分丰富的结构体类型,可以携带各种与信号相关的数据。
中断系统调用
系统调用可以分为两类:慢速系统调用和其他系统调用
1.慢速系统调用:可能会使进程永远阻塞的一类,如果在阻塞期间收到一个信号,该系统调用就被中断,不再继续执行(早期),也可以设定系统调用是否重启,如:read,write,pause,wait…
2.其他系统调用:getpid,getppid,fork…
结合pause,回顾慢速系统调用:
慢速系统调用被中断的相关行为,实际上就是pause的行为:如,read
1.想中断pause,信号不能被屏蔽
2.信号的处理方式必须是捕捉(默认和忽略都不可以)
3.中断后返回-1,设置errno为EINTR(表示被信号中断)
可修改sa_flags参数来设置被信号中断后系统调用是否重启,SA_INTERRURT不重启,sa_flags还有很多可选参数,适用于不同情况,如:捕捉到信号后,在执行捕捉函数期间,不希望自动阻塞该信号,可将sa_flags设置为SA_NODEFER,除非sa_mask中包含该信号。