Linux下的系统编程——信号（十一）

前言：

信号在我们的生活中随处可见，如：古代战争中摔杯为号；现代战争中的信号弹；体育比赛中使用的信号枪...... 他们都有共性，信号是信息的载体，Linux/UNIX 环境下，古老、经典的通信方式，现下依然是主要的通信手段。 Unix 早期版本就提供了信号机制，但不可靠，信号可能丢失。Berkeley 和 AT&T 都对信号模型做了更改，增加了可靠信号机制。但彼此不兼容。POSIX.1 对可靠信号例程进行了标准化。

一、信号的概念：

1.信号的机制：

一、信号的概念：

信号在我们的生活中随处可见，如：古代战争中摔杯为号；现代战争中的信号弹；体育比赛中使用的信号枪...... 他们都有共性：

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

信号是信息的载体，Linux/UNIX 环境下，古老、经典的通信方式，现下依然是主要的通信手段。

Unix 早期版本就提供了信号机制，但不可靠，信号可能丢失。Berkeley 和 AT&T 都对信号模型做了更改，增加了可靠信号机制。但彼此不兼容。POSIX.1 对可靠信号例程进行了标准化。

1.信号的机制：

信号的特质：

信号是软件层面上的“中断”。一旦信号产生，无论程序执行到什么位置，必须立即停止运行，处理信号，处理结束，再继续执行后续指令。

所有信号的产生及处理全部都是由【内核】完成的

2.信号相关的事件：

（1）产生信号：

1）. 按键产生，如：Ctrl+c、Ctrl+z、Ctrl+\

2）. 系统调用产生，如：kill、raise、abort

3）. 软件条件产生，如：定时器 alarm

4）. 硬件异常产生，如：非法访问内存(段错误)、除 0(浮点数例外)、内存对齐出错(总线错误)

5）. 命令产生，如：kill 命令

（2）未决：

产生与递达之间状态。主要由于阻塞（屏蔽）导致该状态

（3）递达：

产生并且送达到进程。直接被内核处理掉。

（4）信号处理方式：

执行默认处理动作、忽略、捕捉（自定义）

（5）阻塞信号集（信号屏蔽字）：

本质：位图。用来记录信号的屏蔽状态。一旦被屏蔽的信号，在解除屏蔽前，一直处于未决态。

（6）未决信号集：

本质：位图。用来记录信号的处理状态。该信号集中的信号，表示已经产生，但尚未被处理。

3.信号的编号:

可以使用 kill –l 命令查看当前系统可使用的信号有哪些。

4.信号 4 要素

与变量三要素类似的，每个信号也有其必备 4 要素，信号使用之前，应先确定其4要素，而后再用！！！分别是：

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

默认动作：

Term：终止进程 Ign：忽略信号 (默认即时对该种信号忽略操作)

Core：终止进程，生成 Core 文件。(查验进程死亡原因，用于 gdb 调试)

Stop：停止（暂停）进程 Cont：继续运行进程

可通过 man 7 signal 查看帮助文档获取。也可查看:

/usr/src/linux-headers-3.16.0-30/arch/s390/include/uapi/asm/signal.h

这里特别强调：9) SIGKILL 和 19) SIGSTOP 信号，不允许忽略和捕捉，只能执行默认动作。甚至不能将其设置为阻塞。

另外需清楚，只有每个信号所对应的事件发生了，该信号才会被递送(但不一定递达)，不应乱发信号！！

1) SIGHUP: 当用户退出 shell 时，由该 shell 启动的所有进程将收到这个信号，默认动作为终止进程

2) SIGINT：当用户按下了组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动作为终止进程。

3) SIGQUIT：当用户按下组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信号。默认动作为终止进程。

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) S IGUSR2：另外一个用户自定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程。

13) SIGPIPE：Broken pipe 向一个没有读端的管道写数据。默认动作为终止进程

14) SIGALRM: 定时器超时，超时的时间由系统调用 alarm 设置。默认动作为终止进程。

15) SIGTERM：程序结束信号，与 SIGKILL 不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出。执行 shell 命令 Kill 时，缺省产生这个信号。默认动作为终止进程。

16) SIGSTKFLT：Linux 早期版本出现的信号，现仍保留向后兼容。默认动作为终止进程。

17) SIGCHLD：子进程状态发生变化时，父进程会收到这个信号。默认动作为忽略这个信号。

18) SIGCONT：如果进程已停止，则使其继续运行。默认动作为继续/忽略。

19) SIGSTOP：停止进程的执行。信号不能被忽略，处理和阻塞。默认动作为暂停进程。

20) SIGTSTP：停止终端交互进程的运行。按下组合键时发出这个信号。默认动作为暂停进程。

21) SIGTTIN：后台进程读终端控制台。默认动作为暂停进程。

22) SIGTTOU: 该信号类似于 SIGTTIN，在后台进程要向终端输出数据时发生。默认动作为暂停进程。

23) SIGURG：套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达，默认动作为忽略该信号。

24) SIGXCPU：进程执行时间超过了分配给该进程的 CPU 时间，系统产生该信号并发送给该进程。默认动作为终止进程。

25) SIGXFSZ：超过文件的最大长度设置。默认动作为终止进程。

26) SIGVTALRM：虚拟时钟超时时产生该信号。类似于 SIGALRM，但是该信号只计算该进程占用 CPU 的使用时间。默认动作为终止进程。

27) SGIPROF：类似于 SIGVTALRM，它不公包括该进程占用 CPU 时间还包括执行系统调用时间。默认动作为终止进程。

28) SIGWINCH：窗口变化大小时发出。默认动作为忽略该信号。

29) SIGIO：此信号向进程指示发出了一个异步 IO 事件。默认动作为忽略。

30) SIGPWR：关机。默认动作为终止进程。

31) SIGSYS：无效的系统调用。默认动作为终止进程并产生 core 文件。

二、信号的产生：

1.终端按键产生信号

Ctrl + c → 2) SIGINT（终止/中断） "INT" ----Interrupt

Ctrl + z → 20) SIGTSTP（暂停/停止） "T" ----Terminal 终端。

Ctrl + \ → 3) SIGQUIT（退出）

2.硬件异常产生信号

除 0 操作 → 8) SIGFPE (浮点数例外) "F" -----float 浮点数。

非法访问内存 → 11) SIGSEGV (段错误)

总线错误 → 7) SIGBUS

#include <stdio.h>

int main()
{
	int a = 10;

	int b = a / 0;    //除0操作

	return 0;
}

3.kill 函数/命令产生信号

int kill（pid_t pid, int signum）

参数：
pid: > 0:发送信号给指定进程

= 0：发送信号给跟调用kill函数的那个进程处于同一进程组的进程。

< -1: 取绝对值，发送信号给该绝对值所对应的进程组的所有组员。

= -1：发送信号给，有权限发送的所有进程。

signum：待发送的信号

返回值：
成功： 0

失败： -1 errno

4.alarm：

alarm 函数：使用自然计时法。

每个进程都有且只有唯一个定时器

定时发送SIGALRM给当前进程。

unsigned int alarm(unsigned int seconds);

seconds：定时秒数

返回值：上次定时剩余时间。

无错误现象，调用一定会成功。

alarm（0）：取消闹钟，返回旧闹钟余下秒数。

time 命令：查看程序执行时间。

实际时间 = 用户时间 + 内核时间 + 等待时间。 --》 优化瓶颈 IO

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

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

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

	return 0;
}

重定向到out，忽视等待时间

5.setitimer:

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

参数：
which：

ITIMER_REAL： 采用自然计时。 ——> SIGALRM

ITIMER_VIRTUAL: 采用用户空间计时 ——> SIGVTALRM

ITIMER_PROF: 采用内核+用户空间计时 ——> SIGPROF

new_value：定时秒数

 类型：struct itimerval {

          struct timeval {
               	time_t      tv_sec;         /* seconds */
               	suseconds_t tv_usec;        /* microseconds */

          }it_interval;    ---> 周期定时秒数

          struct timeval {
               	time_t          tv_sec;         
               	suseconds_t     tv_usec;        

          }it_value;       ---> 第一次定时秒数  
    };

       old_value：传出参数，上次定时剩余时间。

       e.g.
           struct itimerval new_t;
           struct itimerval old_t;

new_t.it_interval.tv_sec = 0;
new_t.it_interval.tv_usec = 0;

new_t.it_value.tv_sec = 1;
new_t.it_value.tv_usec = 0;

int ret = s etitimer(&new_t, &old_t); 定时1秒

返回值：
成功： 0

失败： -1 errno

#include <stdio.h>
#include <sys/time.h>
#include <signal.h>

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

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

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

	it.it_value.tv_sec = 2;
	it.it_value.tv_usec = 0;

	it.it_interval.tv_sec = 5;
	it.it_interval.tv_usec = 0;

	if(setitimer(ITIMER_REAL, &it, &oldit) == -1){
		perror("setitimer error");
		return -1;
	}

	while(1);

	return 0;
}

三、信号集操作函数：

1.信号集设定

sigset_t set; 自定义信号集

int sigemptyset(sigset_t *set); 将某个信号集清 0 成功：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；出错：-1

2.sigprocmask 函数

用来屏蔽信号、解除屏蔽也使用该函数。其本质，读取或修改进程的信号屏蔽字(PCB 中)

严格注意，屏蔽信号：只是将信号处理延后执行(延至解除屏蔽)；而忽略表示将信号丢处理。

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

成功：0；失败：-1，设置 errno

参数： 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 若，调用 sigprocmask 解除了对当前若干个信号的阻塞，则在 sigprocmask 返回前，至少将其中一个信号递达。

3.sigpending 函数

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

int sigpending(sigset_t *set);

set 传出的未决信号集。

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

练习：编写程序。把所有常规信号的未决状态打印至屏幕。

内核通过读取未决信号集来判断信号是否应被处理。信号屏蔽字 mask 可以影响未决信号集。而我们可以在应用程序中自定义 set 来改变 mask。已达到屏蔽指定信号的目的。

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

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

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

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

	int ret = 0;

	sigemptyset(&set);
	sigaddset(&set,SIGINT);    //设置Ctrl^C的阻塞
	sigaddset(&set,SIGQUIT);   //设置Ctrl^\的阻塞
    sigaddset(&set,SIGKILL);   //设置总线的阻塞
	sigaddset(&set,SIGBUS);    //设置总线的阻塞

	ret = sigprocmask(SIG_BLOCK,&set,&oldset);
	if(ret == -1)
		sys_err("sigprocmask error");
	
	while(1){
		ret = sigpending(&pedset);
		if(ret == -1)
			sys_err("sigpending error");

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

*四、信号捕捉：

1.signal 函数

注册一个信号捕捉函数：

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);

能看出这个函数代表什么意思吗？注意多在复杂结构中使用 typedef

signal信号捕捉：

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

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

void sig_cath(int signo)
{
	printf("cath you!!! %d\n",signo);
	return ;
}
int main(int argc,char *argv[])
{

	signal(SIGINT,sig_cath); //创建Ctrl^C信号捕捉


	while(1);

	return 0;
}

***2.sigaction 函数：

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

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

成功：0；失败：-1，设置 errno

参数：

act：传入参数，新的处理方式。

oldact：传出参数，旧的处理方式。【signal.c】

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，表使用默认属性。


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

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

void sig_catch(int signo)                   // 回调函数
{
    if (signo == SIGINT) {
        printf("************catch you!! %d\n", signo);
        sleep(1);
    }
    
    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));        //    清空sa_mask屏蔽字, 只在sig_catch工作时有效
    act.sa_flags = 0;                   //    默认值
    
    int ret = sigaction(SIGINT, &act, &oldact);     //注册信号捕捉函数
    if (ret == -1)
        sys_err("sigaction error");
    ret = sigaction(SIGQUIT, &act, &oldact);     //注册信号捕捉函数

    while (1);

	return 0;
}

3.信号捕捉特性:

1. 捕捉函数执行期间，信号屏蔽字由 mask --> sa_mask , 捕捉函数执行结束。恢复回mask

2. 捕捉函数执行期间，本信号自动被屏蔽(sa_flgs = 0).

3. 捕捉函数执行期间，被屏蔽信号多次发送，解除屏蔽后只处理一次！

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

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

void sig_catch(int signo)                   // 回调函数
{
    if (signo == SIGINT) {
        printf("************catch you!! %d*********\n", signo);
        sleep(10);
    }
   /* 
    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));        //  清空sa_mask屏蔽字, 只在sig_catch工作时有效
    act.sa_flags = 0;                   //  默认值
    
    int ret = sigaction(SIGINT, &act, &oldact);     //注册信号捕捉函数
    if (ret == -1)
        sys_err("sigaction error");
    //ret = sigaction(SIGQUIT, &act, &oldact);     //注册信号捕捉函数

    while (1);

	return 0;
}

4.内核实现信号捕捉过程：

五、SIGCHLD

1.SIGCHID的产生条件

子进程终止时

子进程接收到SIGSTOP信号停止时

子进程处于停止状态，接受到 SIGCONT 后唤醒时

2.借助信号完成子进程回收

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

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

void catch_child(int signo)
{
    pid_t wpid;
    int status;

    //while((wpid = wait(NULL)) != -1) {
    while((wpid = waitpid(-1, &status, 0)) != -1) {         // 循环回收,防止僵尸进程出现.
        if (WIFEXITED(status))
            printf("---------------catch child id %d, ret=%d\n", wpid, WEXITSTATUS(status));
    }

    return ;
}

int main(int argc, char *argv[])
{
    pid_t pid;
//阻塞
    int i; 
    for (i = 0; i < 15; i++)
        if ((pid = fork()) == 0)                // 创建多个子进程
            break;

    if (15 == i) {
        struct sigaction act;

        act.sa_handler = catch_child;           // 设置回调函数
        sigemptyset(&act.sa_mask);              // 设置捕捉函数执行期间屏蔽字
        act.sa_flags = 0;                       // 设置默认属性, 本信号自动屏蔽

        sigaction(SIGCHLD, &act, NULL);         // 注册信号捕捉函数
//解除阻塞

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

        while (1);

    } else {
        printf("I'm child pid = %d\n", getpid());
        return i;
    }

    return 0;
}

解决方法：

void catch_child(int signo)
{
	pid_t wpid;
	while((wpid = wait(NULL)) != -1){    //循环回收，防止僵尸进程出现
		printf("**********catch child id **********%d\n",wpid);
	}
	return ;
}

六、中断系统调用

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

1. 慢速系统调用：可能会使进程永远阻塞的一类。如果在阻塞期间收到一个信号，该系统调用就被

中断,不再继续执行(早期)；也可以设定系统调用是否重启。如，read、write、pause、wait...

2. 其他系统调用：getpid、getppid、fork...

结合 pause，回顾慢速系统调用：

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

① 想中断 pause，信号不能被屏蔽。

② 信号的处理方式必须是捕捉 (默认、忽略都不可以)

③ 中断后返回-1，设置 errno 为 EINTR(表“被信号中断”)

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