012信号_定时器设定_信号集设定_信号捕捉

信号；alarm、setitimer定时器；信号集设定 set、sigprocmask；信号捕捉 signal、sigaction

1.信号

概念：信号是信息的载体。

共性：

1. 简单
2. 不能携带大量的信息
3. 满足某个特定条件才发送

1.1 信号的机制

A给B发送信号，B收到信号之前执行自己的代码，收到信号后，不管执行到程序的什么位置，都要暂停运行，去处理信号，处理完毕再继续执行，与硬件中断类似。但信号是软件层面上实现的中断，早期常被称为“软中断”

信号的特质： 由于信号是通过软件方法实现，其实现手段导致信号有很强的延时性。但对于用户来说，这个延迟时间非常短，不易察觉。

每个进程收到的所有信号，都是由内核负责发送的，内核处理

2. 与信号相关的事件和状态

2.1 信号的产生

1. 按键产生， 如 ctrl+c ctrl+z ctrl+\
2. 系统调用产生， 如 kill、raise、abort
3. 软件条件产生，如 定时器 alarm
4. 硬件异常产生，如，非法访问内存（段错误）、除0、内存对齐出错（总线错误）
5. 命令产生，如 kill 命令

2.2 递达 和 未决 的概念:

递达：递送并且到达进程
未决：产生和递达之间的状态。主要由于阻塞（屏蔽）导致该状态

2.3 信号的处理方式：

1. 执行默认动作（每个信号都有默认的执行动作）
2. 忽略（丢弃）
3. 捕捉（调用户处理函数）

2.4 阻塞信号集 和 未决信号集

Linux 内核的进程控制块PCB是一个结构体， task_struct 除了包含进程id，状态，工作目录，用户id，组id、文件描述符表，还包含了信号相关的信息，主要指阻塞信号集和未决信号集。

阻塞信号集（信号屏蔽字）： 将某些信号加入集合，对他们设置屏蔽，当屏蔽 x 信号之后，再收到该信号，该信号的处理将推后（解除屏蔽后）

未决信号集：

1. 信号的产生，未决信号集中描述该信号的位立刻翻转为1.表信号处于未决状态。当信号被处理对应位翻转回为0。这一时刻往往非常的短暂。
2. 信号产生后由于某些原因（主要是阻塞）不能递达。这类信号的集合称之为未决信号集。再屏蔽解除前，信号一直处于未决状态。

2.5 Linux 常规信号预览

kill -l		// 查看信号列表

1~31 常规信号（每个信号都有对应的默认事件和处理动作）
34~64 实时信号（没有默认事件）

信号四要素（man 7 signal）

1. 编号
2. 名称
3. 事件
4. 默认处理动作

Linux 常规信号预览:
1 SIGHUP：当用户退出shell时，由该shell启动的所有进程将收到这个信号，默认动作为终止进程
2 SIGINT:当用户按下<Ctrl+C>组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动作为终止进程
3 SIGQUIT:当用户按下<Ctrl+>组合键时产生该信号，用户终端向正在运行中的由终端启动的程序发出信号，默认动作为终止进程
4 SIGILL:CPU检测到某进程执行了非法指令。默认动作为终止进程并产生core文件
5 SIGTRAP:该信号由断点指令或其他trap指令产生。默认动作为终止进程并产生core文件
6 SIGABRT:调用abort函数时产生该信号。默认动作为终止进程并产生core文件
7 SIGBUS:非法访问内存地址，包括内存对齐错误，默认动作为终止进程并产生core文件
8 SIGFPE:在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为0等所有的算法错误。默认动作为终止进程并产生core文件
9 SIGKILL：无条件终止进程。本信号不能被忽略，处理和阻塞。默认动作为终止进程。它向系统管理员提供了可以杀死任何进程的方法
10 SIGUSE1:用户定义 的信号。即程序员可以在程序中定义并使用该信号。默认动作为终止进程
11 SIGSEGV:指示进程进行了无效内存访问。默认动作为终止进程并产生core文件
12 SIGUSE2:用户定义 的信号。即程序员可以在程序中定义并使用该信号。默认动作为终止进程
13 SIGPIPE：Broken pipe向一个没有读端的管道写数据。默认动作为终止进程
14 SIGALRM:定时器超时，超时的时间 由系统调用alarm设置。默认动作为终止进程
15 SIGTERM:程序结束信号，与SIGKILL不同的是，该信号可以被阻塞和终止。通常用来表示程序正常退出。执行shell命令kill时，缺省产生这个信号。默认动作为终止进程
16 SIGSTKFLT:Linux早期版本出现的信号，现仍保留向后兼容。默认动作为终止进程
17 SIGCHLD:子进程状态发生变化时，父进程会受到这个信号。默认动作是忽略这个信号
18 SIGCONT:如果进程已停止，则使其继续运行。默认动作为继续/忽略
19 SIGSTOP:停止进程的执行。信号不能被忽略，处理和阻塞。默认动作为暂停进程
20 SIGSTP:停止终端交互进程的运行。按下<Ctrl+z>组合键时发出这个信号。默认动作为暂停进程
21 SIGTTIN:后台进程读终端控制台。默认动作为暂停进程。
22 SIGTTOU:该信号类似于SIGTTIN，在后台进程要向终端输出数据时发生。默认动作为暂停进程
23 SIGURG:套接字上有紧急数据时，向当前正在运行的进程发出信号，报告有紧急数据到达。如网络带外数据到达，默认动作忽略该信号。
24 SIGXCPU:进程执行时间超过了分配给该进程的CPU时间 ，系统产生该信号并发送给该进程。默认动作为终止进程。
25 SIGXFSZ:超过文件的最大长度设置。默认动作为终止进程
26 SIGVTALRM:虚拟时钟超时时产生该信号。类似于SIGALRM,但是该信号只计算该进程占用CPU的使用时间。默认动作为终止进程
27 SIGPROF:类似于SIGVTALRM，它不仅包括该进程占用CPU时间还包括执行系统调用时间。默认动作为终止进程
28 SIGWINCH:窗口大小发生变化时发出。默认动作为忽略该信号
29 SIGIO:此信号向进程指示发生了一个异步IO事件。默认动作为忽略
30 SIGPWR:关机。默认动作是终止进程
31 SIGSYS:无效的系统调用。默认动作为终止进程并产生core文件
34 SIGRTMIN ~ 64 SIGRTMAX:LINUX的实时信号，它们没有固定的含义（可以由用户自定义）。所有的实时信号的默认动作都为终止进程

默认动作：
1.终止进程
2.忽略信号
3.终止进程，生成core文件
4.停止（暂停）进程
5.继续运行进程

终端按键产生的信号:
<Ctrl+c> 2 SIGINT(终止/中断)
<Ctrl+z> 20 SIGSTP(暂停/停止)
<Ctrl+> 3 SIGQUIT(退出)

硬件异常产生信号:
除0操作 8 SIGFPE(浮点数例外)
非法访问内存 11 SIGSEGV(段错误)
总线错误 7 SIGBUS

2.6 kill 函数/命令产生信号

bash 命令：

kill -信号 pid

kill 函数：

man 2 kill   // send signal to a process
#include<sys/types.h>
#include<signal.h>

int kill(pid_t pid, int sig);

返回值:
成功：0
失败：-1，设置errno

sig 不推荐直接使用数字，应使用宏名（因为不同操作系统信号编号可能不同）!!!

pid>0:发送信号给指定的进程
pid=0:发送信号给与调用kill函数进程属于同一进程组的所有进程
pid<-1:取|pid|发送给对应的进程组（负号代表的是进程组id）
pid=-1:发送给进程有权限发送的系统中所有进程

进程组： 每个进程都属于一个进程组，进程组是一个或多个进程集合，他们相互关联，共同完成一个实体任务，每个进程组都有一个进程组长，默认进程组ID与进程组长ID相同。

权限保护： super用户（root）可以发送信号给任意用户，普通用户是不能向系统用户发送信号的。只能向自己创建的进程发送信号

2.6.1 demo 子进程给父进程发送-9信号

1. fork创建父子进程
2. 父子进程各自打印pid
3. 子进程给父进程发送-9信号杀死进程

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<signal.h>


void sys_error(const char * str)
{
	perror(str);
	exit(1);
}

int main(int argc, char * argv [])
{
	pid_t pid;

	pid = fork();
	if (pid >0 )
	{
		printf("parent process, pid = %d\n", getpid());
		while(1);
	}
	else if(pid == 0)
	{
		printf("child pid = %d, ppid = %d\n",getpid(), getppid());
		sleep(2);
		kill(getppid(),SIGKILL);
	}
	return 0;
}

2.6.2 其他几个发信号的函数

#include<signal.h>

int raise(int sig);		// 给自己发信号

#include<stdlib.h>

void abort(void);

3. 软件条件产生信号（alarm 和 setitimer 定时器）

3.1 alarm 函数（使用自然计时法）

• 设置定时器（闹钟)。在指定 seconds 后，内核会给当前进程发送 14 SIGALRM 信号。进程收到该信号，默认动作终止。
• 每个进程都有且只有唯一个定时器

函数声明及头文件包含

man alarm
#include<unistd.h>

unsigned int alarm(unsigned int seconds);

返回值：
0或剩余的秒数，无失败

定时
与进程状态无关（自然定时法）！就绪、运行、挂起（阻塞、停止）、终止、僵尸…无论进程处于何种状态，alarm都计时

常用：
alarm(0):取消定时器，返回旧闹钟余下的秒数

3.1.1 demo 测试计算机1秒内能数多少个数

#include<unistd.h>
#include<stdio.h>

int main(void)
{
	int i;
	alarm(1);


	for (i = 0; ; i++)
	{
		printf("%d\n",i);
	}
}

使用 time 命令查看程序执行的时间

time ./alarm.out

实际执行时间 = 系统时间 + 用户时间 + 等待时间（大部分时间在等待设备）

3.2 setitimer 函数

设定定时器（闹钟）。可代替 alarm 函数。精度微妙us，可以实现周期定时

man setitimer

#include<sys/time.h>

int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);

返回值：
成功： 0
失败：-1，设置errno

参数：

which：指定定时方式
1. 自然定时：ITIMER_REAL — 14 SIGLARM 计算自然时间
2. 虚拟空间计时（用户空间）：ITIMER_VIRTUAL — 26 SIGVTALRM 只计算进程占用CPU时间
3. 运行时计时（用户 + 内核）：ITIMER_PROF — 27 SIGPROF 计算占用CPU及执行系统调用的时间

new_value:传入参数，设定初始化计时器时间
old_value:传出参数，上次定时剩余时间
new_value 和 old_value 都是 itimerval 结构体(嵌套结构体)

struct itimerval {
               struct timeval it_interval; /* Interval for periodic timer */
               struct timeval it_value;    /* Time until next expiration */
           };

struct timeval {
               time_t      tv_sec;         /* seconds */
               suseconds_t tv_usec;        /* microseconds */
           };
/* 结构体初始化 */
struct itimerval new_t;
new_t.it_interval.tv_sec = 1;
new_t.it_interval.tv_usec = 0;
new_t.it_value.tv_sec = 0;
new_t.it_value.tv_usec = 0;

it_interval:用来设定两次定时任务之间间隔的时间(用来实现周期定时)
it_value：定时时长（第一次定时的时间）
/* 两个参数都设置为0，即清0操作 */

3.2.1 demo 首次计时2s，周期定时5s，打印 hello world

/* setitimer_cycle.c */
#include<stdio.h>
#include<sys/time.h>
#include<signal.h>

void myfunc(int signo)
{
	printf("hello world\n");
}

int main(void)
{
	struct itimerval newit, oldit;

	signal(SIGALRM, myfunc);  // 捕捉SIGALRM信号的捕捉处理函数

	newit.it_value.tv_sec = 2;		// 第一次定时2s
	newit.it_value.tv_usec = 0;
	newit.it_interval.tv_sec =5;		// 除去第一次定时，周期定时5s
	newit.it_interval.tv_usec = 0;

	if(setitimer(ITIMER_REAL, &newit, &oldit) == -1)
	{
		perror("setimer error\n");
		return -1;
	}
	while(1);

	return 0;
}

4. 信号集设定 set 、sigprocmask

通过 set 函数去设置 PCB 中的阻塞信号集

4.1 set 、sigprocmask 、sigpending 函数

4.1.1 set 函数声明及头文件包含

set 创建相应的位图，并对相应信号位进行操作

man emptyset

#include<signal.h>

sigset_t set;    							//自定义信号集
int sigemptyset(sigset_t *set);				// 清空信号集，成功0，失败-1
int sigfillset(sigset_t *set);				// 全部置1，成功0，失败-1
int sigaddset(sigset_t *set, int signum);		// 将一个 信号添加到集合中，成功0，失败-1
int sigdelset(sigset_t *set, int signum);		// 将一个信号从集合中移除，成功0，失败-1
int sigismember(const sigset_t *set, int signum);	// 判断一个信号是否在集合中 在1 不在0

4.1.2 sigprocmask 函数声明及头文件包含

用来屏蔽信号、解除信号。其本质：读取或修改进程的信号屏蔽字（PCB中）
sigprocmask 函数将设置的 set 位，与进程阻塞信号集进行操作

#include<signal.h>

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

how 参数
SIG_BLOCK: set表示需要屏蔽的信号，相当于 mask = mask|set
SIG_UNBLOCK: set表示需要解除屏蔽的信号，相当于 mask = mask &~ set
SIG_SETMASK: set表示用于替代原始屏蔽及新屏蔽集。相当于 mask=set
若嗲用 SIG_SETMASK解除了对当前若干个信号的阻塞，则在SIG_SETMASK返回前，至少将其中一个信号送达

4.1.3 sigpending 函数声明及头文件包含

读取当前进程的未决信号集

int sigpending(sigset_t *set);		//set传出参数 ，当前进程的未决信号集

返回值：
成功：0
失败：-1，设置errno

4.2 demo 信号屏蔽，查看当前信号未决集

将 SIGINT 信号进行屏蔽，然后 <Ctrl+C>发送中断信号，因为屏蔽，所以信号未决集置1

/* sigsfunc.c */
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<signal.h>

void sys_error(const char * str)
{
	perror(str);
	exit(1);
}

void print_set(sigset_t* set)
{
	int i,ret;
	
	for(i=1; i<32; i++)
	{
		ret = sigismember(set, i);
		if(ret == 1)
			putchar('1');
		else if(ret == 0)
			putchar('0');
	}
	printf("\n");
}

int main(int argc, char * argv [ ])
{
	sigset_t set, oldset, pendset;
	int ret;

	sigemptyset(&set);
	sigaddset(&set, SIGINT);

	ret = sigprocmask(SIG_BLOCK, &set, &oldset);
	if (ret == -1)
		sys_error("sigprocmask error\n");

	while(1)
	{
		ret = sigpending(&pendset);
		if (ret == -1)
			sys_error("sigpending error\n");

		print_set(&pendset);
		sleep(1);
	}
	return 0;
	
}

注：9号和19号屏蔽字可以设置为1，但是不管用！！！！

5.信号捕捉 (signal、sigaction)

5.1 signal 函数声明及头文件包含

注册一个信号捕捉函数

man 2 signal

#include<signal.h>

typedef void(*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

5.2 demo 注册 SIGINT 的信号捕捉函数

/* signal.c */
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<signal.h>

void sys_error(const char * str)
{
	perror(str);
	exit(1);
}

void sig_catch(int signo)
{
	printf("catch you!! %d\n", signo);
	return;
}

int main(int argc, char * argv [ ])
{
	signal(SIGINT, sig_catch);

	while(1);

	return 0;
}

5.3 sigaction 函数

修改信号处理动作（通常在Linux用来注册一个信号的捕捉函数）

man 2 sigaction

#include<signal.h>

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;					// sa_mask屏蔽字，只在sig_catch工作时有效
	int		sa_flags;					// 默认处理动作
	void		(*sa_restorer)(void);
};

返回值:
成功0
失败 -1，设置 errno

参数：
act:传入参数，新的处理方式
oldact：传出参数，旧的处理方式

结构体参数介绍
sa_handler:指定信号捕捉后的处理函数名（即注册函数）。也可赋值为 SIG_IGN 表忽略，或 SIG_DFL 表执行默认动作
sa_mask:调用信号处理函数时，所要屏蔽的信号集合（信号屏蔽字）。注意：仅在处理函数被调用期间屏蔽生效，是临时性设置
sa_flag:通常设置为0，表使用默认属性

5.4 demo sigaction 屏蔽捕捉信号 SIGINT 和 SIGQUIT

/* sigaction.c */
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<signal.h>

void sys_error(const char * str)
{
	perror(str);
	exit(1);
}

void sig_catch(int signo)
{
	if(signo == SIGINT)
		printf("catch you!! %d\n", signo);
	else if(signo == SIGQUIT)
		printf("------catch you!! %d\n",signo);
	return;
}

int main(int argc, char * argv [ ])
{
	struct sigaction act, oldact;
	act.sa_handler = sig_catch;
	sigemptyset(&(act.sa_mask));
	act.sa_flags = 0;
	
	int ret = sigaction(SIGINT, &act, &oldact);
	if(ret == -1)
		sys_error("sigaction error\n");
	ret = sigaction(SIGQUIT, &act, &oldact);
	if(ret == -1)
		sys_error("sigaction error\n");
	while(1);

	return 0;
}

5.5 信号捕捉特性

1. 进程正常运行时，默认PCB中有一个信号屏蔽字，它决定了进程自动屏蔽哪些信号。当注册了某个信号捕捉函数，捕捉到该信号以后，要调用该函数。而该函数有可能执行很长时间，在这期间所屏蔽的信号不由默认信号屏蔽字来指定，而是用sa_mask来指定。调用完信号处理函数后，在恢复默认信号屏蔽字
2. XXX信号捕捉函数执行期间，XXX信号自动被屏蔽
3. 阻塞的常规信号不支持排队，产生多次只记录一次（后32个实时信号支持排队）

5.5.1 demo 在捕捉信号SIG_INT期间屏蔽 SIG_QUIT 信号

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<signal.h>

void sys_error(const char * str)
{
	perror(str);
	exit(1);
}

void sig_catch(int signo)
{
	if(signo == SIGINT)
	{
		printf("catch you!! %d\n", signo);
		sleep(10);
	}
	return;
}

int main(int argc, char * argv [ ])
{
	struct sigaction act, oldact;
	act.sa_handler = sig_catch;
	sigemptyset(&(act.sa_mask));
	sigaddset(&(act.sa_mask), SIGQUIT);
	act.sa_flags = 0;
	
	int ret = sigaction(SIGINT, &act, &oldact);
	if(ret == -1)
		sys_error("sigaction error\n");

	while(1);

	return 0;
}

阻塞的常规信号不支持排队，产生多次只记录一次（后32个实时信号支持排队）!!!

5.6 内核实现信号捕捉的过程

6. SIGCHLD 信号

6.1 SIGCHLD 信号产生的条件

1. 子进程终止时
2. 子进程接受到SIGSTOP信号停止时
3. 子进程处在停止态，接收到SIGCONT后唤醒时

6.2 demo 借助SIGCHLD信号回收子进程

解决execl跳转时，不好对子进程回收问题

error demo:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<signal.h>
#include<sys/wait.h>

void sys_error(const char * str)
{
	perror(str);
	exit(1);
}

void catch_child(int signo)
{
	pid_t wpid;
	wpid = wait(NULL);
	if(wpid == -1)
		sys_error("wait error\n");
	printf("catch child is %d\n", wpid);

	return ;
}

int main(int argc, char * argv [ ])
{
	pid_t pid;

	int i;
	for(i = 0; i < 5; i++)
	{
		if((pid = fork()) == 0)
			break;
	}

	if(i ==5)
	{
		struct sigaction act;
		act.sa_handler = catch_child;
		sigemptyset(&(act.sa_mask));
		sigaddset(&(act.sa_mask), SIGCHLD);
		act.sa_flags = 0;

		sigaction(SIGCHLD,&act, NULL);

		printf("I'm parent, pid is %d\n",getpid());

		while(2); 		// 为了让父进程不提前结束
	}
	else
		printf("I'm child pid is %d\n",getpid());

	return 0;
}

信号不排队！！！！！解决办法1：第一次收到消息时就循环回收

success demo:

/* catch_child.c */
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<signal.h>
#include<sys/wait.h>

void sys_error(const char * str)
{
	perror(str);
	exit(1);
}

void catch_child(int signo)     //子进程终止，发送SIG_CHLD信号时，该函数会被内核回调
{
	int status;

	while (waitpid(-1, &status, 0) != -1)
	{
		if(WIFEXITED(status))
			printf("-------------catch child is %d, ret = %d\n",getpid(), WEXITSTATUS(status));
	}

	return ;
}

int main(int argc, char * argv [ ])
{
	pid_t pid;
	/* 阻塞 */
	sigset_t set;
	sigemptyset(&set);
	sigaddset(&set,SIGCHLD);

	sigprocmask(SIG_BLOCK, &set, NULL);
	

	int i;
	for(i = 0; i < 5; i++)
	{
		if((pid = fork()) == 0)
			break;
	}

	if(i ==5)
	{
		struct sigaction act;
		act.sa_handler = catch_child;
		sigemptyset(&(act.sa_mask));
		sigaddset(&(act.sa_mask), SIGCHLD);
		act.sa_flags = 0;

		sigaction(SIGCHLD,&act, NULL);

		sigprocmask(SIG_UNBLOCK, &set, NULL);

		printf("I'm parent, pid is %d\n",getpid());

		while(2); 		// 为了让父进程不提前结束
	}
	else
	{
		printf("I'm child pid is %d\n",getpid());
		return i;
	}

	return 0;
}

7. 中断系统调用

系统调用可分为两类：慢速系统调用和其他系统调用。

1. 慢速系统调用：可能会使进程永远阻塞的一类。如果在阻塞期间收到一个信号，该系统调用就会被中断，不在继续执行（早期），也可以设定系统调用是否重启。如 read、write、pause、wait…
2. 其他系统调用： getpid、getppid、fork…

---

慢速系统调用被中断的相关行为，实际上就是pause的行为，

1. 想中断pause，信号不能被屏蔽
2. 信号的处理方式必须是捕捉（默认、忽略都不可以）
3. 中断后返回-1，设置errno为EINTR(表”被信号中断“)

可修改 sa_flags 参数来设置被信号中断后系统调用是否重启。 SA_INTERRURT 不重启 ；SA_RESTART 重启

注：sa_flags还有很多可选参数，适用于不同情况。如捕捉到信号后，在执行捕捉函数期间，不希望自动阻塞该信号，可将sa_flags设置为 SA_NODEFER，除非 sa_mask 中包含该信号