实验七 信号

项目	内容
这个作业属于哪个课程	[2020春季Linux系统与应用]
这个作业的要求在哪里	实验七作业要求
学号-姓名	17041503-李美霞
作业学习目标	1.了解信号的概念 2.掌握信号处理的方法

---

1. 编写一个简单的程序并运行，然后向该进程发送不同的信号以观察该进程对接收到信号的反应。

   //hellosignal.c
   #include <stdio.h> 
   #include <unistd.h> 
   int main() 
   { 
   	printf("hello signal! I'm %d\n", getpid()); 
   	while(1) 
   	{ 
   		write(STDOUT_FILENO, ".", 1); 
   		sleep(10); 
   	}
   return 0;
   }
   

   在终端编译并运行该程序：

   

   1) 我们可以在当前终端通过按键组合向该进程发送信号 CTRL+C 、 CTRL+Z 、 CTRL+\ ，大家可以试着 在每一次运行该程序的时候分别通过按键发送不同的信号来观察进程的反应。这里三个按键组合说明要 发送三个信号，所以我们要运行该程序三次，然后每次使用不同的按键组合来观察。

   按下 CTRL+C :

   

   按下 CTRL+Z :

   

   按下 CTRL+\ :

   

   2) 另外再开启一个终端，在终端通过输入 kill 命令来给进程发送信号，进程的 pid 在程序运行的第一 行输出，每次运行程序的时候 pid 是不同的，这个是大家要注意的。

   我们可以在终端通过输入 kill -l 来查看当前系统当中的信号列表:

   

   我们重新运行程序:

   

   在当前终端我们可以看到程序输出自己的 pid 是19073,这是我们可以另开一个终端,通过 kill 命令向该 进程发送信号:

   

   这里我们发送了信号值为9的信号给了进程19073.再切换到运行程序的终端来观察进程接收到信号后的反应:

   

   对于 kill 命令我们可以查看手册: man kill

   

   3) 我们编写一个简单的程序，该程序调用 kill() 函数向某个进程发送信号

   //mykill.c
   #include <stdio.h>
   #include <stdlib.h>
   #include <sys/types.h>
   #include <signal.h>
   int main(int argc,char *argv[]){
   	if(argc < 2)
   	{
   		printf("%s arg error.",argv[0]);
   		exit(1);
   	}
   	kill(atoi(argv[1]),SIGKILL);
   	return 0;
   }
   

   我们继续运行之前的程序等待有信号到来：

   

   在新开一个终端完成上面程序的输入并编译，运行的时候把19124作为参数

   

   再返回之前运行 hellosignal 的终端观察进程接收到信号的反应：

   

   我们可以查看手册看看 kill() 函数： man 2 kill

   

2. 使用signal()函数来捕捉信号。

   通常进程在接收到某种信号后，会根据不同的信号执行默认的操作：
   (1)忽略信号
   (2)终止（杀死）进程
   (3)产生核心转储文件，同时 终止进程
   (4)停止进程
   (5)恢复之前被暂停的进程继续运行
   这里可以通过signal()来改变进程对某个信号的处置方式。signal()是目前为止见过最复杂的函数。
   我们通过查看手册： man 2 signal
   

   

   //catchsignal.c
   #include <stdio.h>
   #include <unistd.h>
   #include <signal.h>
   #include <stdlib.h>
   #include <string.h>
   #include <errno.h>
   void sighandler(int sig) {
   	switch(sig) {
   		case SIGUSR1://10
   			printf("hello SIGUSR1\n");break;
   		case SIGUSR2://12
   			printf("hello SIGUSR2\n");break;
   		case SIGINT://2 CTRL+C
   			printf("休想干掉我！\n");break;
   		case SIGTSTP://20 CTRL+Z
   			printf("不要停止我！\n");break;
   		case SIGQUIT://3 CTRL+\
   			printf("就是不退出！\n");break;
   		case SIGSEGV://11
   			printf("呃！程序出 bug 了！\n");break;
   		default:
   			printf("hello, who are you %d?\n", sig);
   	}
   	sleep(2); // 删除这一行，再给程序发信号，看看 main 函数打点的情况。
   }
   int main() {
   	printf("I'm %d\n", getpid());
   	if (SIG_ERR == signal(SIGUSR1, sighandler)) {
   		perror("signal SIGUSR1");
   	}
   	if (SIG_ERR == signal(SIGUSR2, sighandler)) {
   		perror("signal SIGUSR2");
   	}
   	if (SIG_ERR == signal(SIGINT, sighandler)) {
   		perror("signal SIGINT");
   	}
   	if (SIG_ERR == signal(SIGTSTP, sighandler)) {
   		perror("signal SIGTSTP");
   	}
   	if (SIG_ERR == signal(SIGQUIT, sighandler)) {
   		perror("signal SIGQUTI");
   	}
   	if (SIG_ERR == signal(SIGSEGV, sighandler)) {
   		perror("signal SIGSEGV");
   	}
   	while(1) {
   		write(STDOUT_FILENO, ".", 1);
   		sleep(10);
   	}
   	return 0;
   }
   

   我们输入完上述代码，编译并运行，然后再给该进程发送信号，观察进程对接收到信号的反应：

   

   我们在另外一个终端输入 kill 命令来向该进程发送信号：

   

3. 通过举例说明alarm()函数和setitimer()函数的使用。

   我们先分别查看两个函数的手册：
   man 2 alarm :

   

   man 2 setitimer :

   

   这里我们通过命令 man 7 signal 可以查看当前系统信号的清单：

   

   从上面可以看到 alarm() 函数在计时结束后会发生 SIGALRM 信号给当前进程，进程对 SIGALRM 信号的 缺省动作是结束进程。
   下面一个非常简单的例子：

   //例:
   //alarm_test.c
   #include<stdio.h>
   #include<stdlib.h>
   #include<unistd.h>
    
   int main(){
   	alarm(1);
   	while(1)
   	{
   		printf("process will finish!\n");
   	}
   	return 0;
   }
   

   

   虽然程序中有无限循环，不断输出字符串 process will finish! ,由于调用了 alarm(1) 函数， alarm 函数会在1秒后给该进程发送 SIGALRM 信号，然后进程结束。

   

   接下来继续看一个程序设定了两次定时炸弹，第一次设定 5 秒后爆炸，设定后过了 2 秒，再设定了一个 3 秒后爆炸的定时炸弹。

   //myalarm.c
   #include<stdio.h>
   #include <unistd.h>
   #include <signal.h>
   void handler(int sig) {
   	if (sig == SIGALRM) printf("Bomb!!!!!!!!\n");
   }
   int main() {
   	if(SIG_ERR == signal(SIGALRM, handler)) {
   		perror("signal SIGALRM");
   	}
   	unsigned int remain = 0;
       remain = alarm(5); // 设定 5 秒后爆炸
       printf("the previous alarm remain %d seconds\n", remain);
       sleep(3); // 等待 3 秒
   	remain = alarm(3); // 设定 3 秒后爆炸，同时会取消前面那个定时炸弹
   	printf("the previous alarm remain %d seconds\n", remain);
       while(1) {
   		write(STDOUT_FILENO, ".", 1);
       	pause();
   	}
   }
   

   

   这里计时时间到了并不会结束进程，因为我们编写了信号捕捉函数，产生 SIGALRM 信号后会输出字符 串 Bomb!! , 我们可以键盘按键组合结束进程，这里我用了 CTRL+C 。
   接下来我们用 setitimer() 函数实现 alarm() 函数

   //mysetitimer.c
   #include<stdio.h>
   #include<stdlib.h>
   #include<sys/time.h>
   #include<error.h>
   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(){
   	my_alarm( 1) ;
   	while(1)
   	{
   		printf( "process will finish! \n");
   	}
   	return 0;
   }
   

   

   程序在运行1秒钟后被 SIGALRM 信号结束。

   

   试分析一下 alarm() 函数和 setitimer() 函数的区别?
   
   alarm()函数，当定时时间到了，就会产生SIGALRM信号结束进程。
   setitimer()函数从开始计时到时间结束，会产生SIGALRM信号，
   若it_interval的值为0，则不会重新启动该定时器，调用 setitimer()失败，返回-1，结束进程。
   

4. 举例说明信号集操作函数的使用。

   我们可以通过命令 man 3 sigsetops 来查看手册：

   

   从手册中可以看到，这些函数都是对 sigset_t 这个数据结构进行操作的。

   我们可以编写一个打印 sigset_t 的函数

   void printsigset(const sigset_t *set)
    {
   int i;
   for (i = 1; i <= 64; i++) {
   if (i==33)
   putchar(' ');
   if (sigismember(set, i) == 1)
   putchar('1');
   else
   putchar('0');
   }
   puts("");
   }
   

   然后通常该函数查看，信号集操作函数对信号集操作后的结果：

   //mysigset.c
   #include <stdio.h>
   #include <unistd.h>
   #include <signal.h>
   void printsigset(const sigset_t *set)
   {
   	int i;
   	for (i = 1; i <= 64; i++) {
   		if (i==33)
   			putchar(' ');
   		if (sigismember(set, i) == 1)
   			putchar('1');
   		else
   			putchar('0');
   	}
   	puts("");
   }
   int main() {
   	sigset_t st;
   	printf("1. create set\n");
   	printsigset(&st);
    
   	printf("\n2. vertify sigset_t is a 64-bit integer\n");
   	unsigned int test[2] = {0xf0f0f0f0, 0xf0f0f0f0};
   	printsigset((sigset_t*)test); // 这种方法不被推荐，仅供测试用。
   	
   	// fill set
   	printf("\n3. fill set\n");
   	sigfillset(&st);
   	printsigset(&st);
   	
   	// empty set 
   	printf("\n4. empty set\n");
   	sigemptyset(&st);
   	printsigset(&st); 
   	
   	// add sig
   	printf("\n5. add SIGHUP(1), SIGINT(2), SIGKILL(9), SIGSYS(31), SIGRTMIN(34) and SIGRTMAX(64) to set\n");
   	sigaddset(&st, SIGHUP);
   	sigaddset(&st, SIGINT);
   	sigaddset(&st, SIGKILL);
   	sigaddset(&st, SIGSYS);
   	sigaddset(&st, SIGRTMIN);
   	sigaddset(&st, SIGRTMAX);
   	printsigset(&st);
    
   	// delete sig
   	printf("\n6. delete SIGKILL from set\n");
   	sigdelset(&st, SIGKILL);
   	printsigset(&st);
    
   	// is member
   	printf("\n");
   	if (sigismember(&st, SIGKILL)) {
   	printf("SIGKILL is member\n");
   	}
   	if (sigismember(&st, SIGINT)) {
   	printf("SIGINT is member\n");
   	}
   	return 0;
   }
   
   

   

5. 举例说明对阻塞信号与未决信号的理解。

   在一个进程中，保存了两个信号集（在PCB中），分别是阻塞信号集，还有一个未决信号集。当你使用sigprocmask的时候，就会修改阻塞信号集。
   
   当你的进程一收到信号且该信号被阻塞，它首先进入到未决信号集中（就是一个 sigset_t ），
   
   当未决信号集中的信号被信号处理函数（你自己定义的或者系统默认的）处理，就会从未决信号集中删除。
   
   如果一个信号加入阻塞信号集，该信号的信号处理函数就不会被调用。
   
   通过 man sigprocmask 来查看手册：
   

   

   对于未决信号集我们不能直接操作，可以使用 sigpending 函数获取未决信号集。
   man sigpending

   

   下面结合例子来理解，程序的功能是先把 SIGINT 、 SIGTSTP 加入到了进程阻塞信号集中去。接下 来，每隔一秒打印一次未决信号集，第 10 次的时候，又把 SIGINT 信号从阻塞信号集中删除。

   //sigblock.c
   #include <stdio.h>
   #include <unistd.h>
   #include <signal.h>
   #include <stdlib.h>
   void printsigset(const sigset_t *set)
   {
   	int i;
   	for (i = 1; i <= 64; i++) {
   		if (i==33)
   			putchar(' ');
   		if (sigismember(set, i) == 1)
   			putchar('1');
   		else
   			putchar('0');
   	}
   	puts("");
   }
   
   void handler(int sig) {
   	if (sig == SIGINT)
   		printf("hello SIGINT\n");
   	if (sig == SIGQUIT)
   		printf("hello SIGQUIT\n");
    }
    
   int main() {
   	printf("I'm %d\n", getpid());
   	
   	sigset_t st, oldst;
   	sigemptyset(&st);
   	sigaddset(&st, SIGINT);
   	sigaddset(&st, SIGTSTP);
   	sigprocmask(SIG_BLOCK, &st, &oldst);
   	printf("new set:");
   	printsigset(&st);
   	printf("old set:");
   	printsigset(&oldst);
    
   	if (SIG_ERR == signal(SIGINT, handler)) {
   		perror("signal SIGINT");
   		return 1;
   	}
   	
   	if (SIG_ERR == signal(SIGQUIT, handler)) {
   		perror("signal SIGQUIT");
   		return 1;
   	}
   	
   	puts("");
   	
   	int n = 0;
   
   	while(1) {
   		sigpending(&st);
   		printsigset(&st);
   		puts("");
   		sleep(1);
   		
   		if (n == 10) {
   			sigset_t tmp;
   			sigemptyset(&tmp);
   			sigaddset(&tmp, SIGINT);
   			sigprocmask(SIG_UNBLOCK, &tmp, NULL);
   		}  
   		
   		++n;
   	}
   	return 0;
   }
   

   

   

6. 举例说明sigaction()函数的使用。

   不同于 signal 函数， sigaction 函数是符合 POSIX 标准的，而 signal 只是 ANSI C 定义的函数。
   除了上面的区别外， sigaction 提供了更多的功能。
   比如它可以处理带参数的信号，在信号处理的时候，可以屏蔽其它信号等等。
   我们通过 man 2 sigaction 来查看手册：
   

   

   下面给出一个程序来说明 sigaction() 函数的使用，程序注册了信号 SIGINT 和 SIGTSTP . 需要注意 的一点是 sa_mask 被设置为 SIGINT ，它表示当执行信号处理函数的时候，阻塞信 SIGINT 信号。我 在 handler 函数加入了一打印未决信号的功能，以验证执行到 handler 的时候发送 SIGINT 是被阻 塞住的。

   //sigaction.c
   #include <stdio.h>
   #include <unistd.h>
   #include <signal.h>
   void printsigset(const sigset_t *set)
   {
   	int i;
   	for (i = 1; i <= 64; i++) {
   		if (i==33)
   			putchar(' ');
   		if (sigismember(set, i) == 1)
   			putchar('1');
   		else
   			putchar('0');
   	}
   	puts("");
   }
    
   void handler(int sig) {
   	if (sig == SIGTSTP)
   		printf("hello SIGTSTP\n");
   	if (sig == SIGINT)
   		printf("hello SIGINT\n");
   	sleep(5);
   	sigset_t st;
   	sigpending(&st);
   	printsigset(&st);
   }
   
   int main() {
   	printf("I'm %d\n", getpid());
   	struct sigaction act, oldact; 
   	act.sa_handler = handler; // 设置普通信号处理函数
    
   	// 向 sa_mask 中添加 SIGINT
   	sigemptyset(&act.sa_mask);
   	sigaddset(&act.sa_mask, SIGINT);
   	act.sa_flags = 0; // 先置 0
    
   	sigaction(SIGTSTP, &act, &oldact);
   	sigaction(SIGINT, &act, &oldact);
    
   	while(1) {
   		write(STDOUT_FILENO, ".", 1);
   		pause();
   	}
   	return 0;
   }
   
   

   1. 当程序运行的时候， Ctrl+C 进入 handler ，然后立即 Ctrl+Z 发现 handler 还未执行完就被 SIGTSTP 打断.
   2. 当程序运行的时候， Ctrl+Z 进入 handler ，然后立即 Ctrl+C 发现并不会被 SIGINT 打断，这是因 为该 handler 注册的时候被设置了 SA_MASK = SIGINT 。最后 handler 结束的时候打印了未决信号 集，发现里头有 SIGINT 。所以 handler 结束后，又去继续对 SIGINT 进行处理。