Linux下的系统编程——信号(十一)

前言:

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

目录

一、信号的概念:

1.信号的机制:

2.信号相关的事件:

(1)产生信号:

(2)未决:

(3)递达:

(4)信号处理方式:

(5)阻塞信号集(信号屏蔽字):

(6)未决信号集:

3.信号的编号:

[4.信号 4 要素](#4.信号 4 要素)

二、信号的产生:

1.终端按键产生信号

2.硬件异常产生信号

[3.kill 函数/命令产生信号](#3.kill 函数/命令产生信号)

4.alarm:

5.setitimer:

三、信号集操作函数:

1.信号集设定

[2.sigprocmask 函数](#2.sigprocmask 函数)

[3.sigpending 函数](#3.sigpending 函数)

四、信号捕捉:

[1.signal 函数](#1.signal 函数)

[***2.sigaction 函数:](#***2.sigaction 函数:)

3.信号捕捉特性:

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

五、SIGCHLD

1.SIGCHID的产生条件

[2.借助信号完成 子进程回收](#2.借助信号完成 子进程回收)

六、中断系统调用


一、信号的概念:

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

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 文件。

  1. SIGABRT: 调用 abort 函数时产生该信号。默认动作为终止进程并产生 core 文件。

7)SIGBUS:非法访问内存地址,包括内存对齐出错,默认动作为终止进程并产生 core 文件。

  1. SIGFPE:在发生致命的运算错误时发出。不仅包括浮点运算错误,还包括溢出及除数为 0 等所有的算法错误。 默认动作为终止进程并产生 core 文件。

9)SIGKILL无条件终止进程本信号不能被忽略,处理和阻塞。默认动作为终止进程。它向系统管理员提供了 可以杀死任何进程的方法。

10)SIGUSE1用户定义 的信号 。即程序员可以在程序中定义并使用该信号。默认动作为终止进程。

  1. SIGSEGV:指示进程进行了无效内存访问。默认动作为终止进程并产生 core 文件。

  2. S IGUSR2:另外一个用户自定义信号 ,程序员可以在程序中定义并使用该信号**。默认动作为终止进程。**

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

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

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

  1. SIGSTKFLT:Linux 早期版本出现的信号,现仍保留向后兼容。默认动作为终止进程。

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

  1. SIGCONT:如果进程已停止,则使其继续运行。默认动作为继续/忽略。

  2. SIGSTOP停止进程的执行。信号不能被忽略,处理和阻塞。默认动作为暂停进程。

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

  4. SIGTTIN:后台进程读终端控制台。默认动作为暂停进程。

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

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

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

  8. SIGXFSZ:超过文件的最大长度设置。默认动作为终止进程。

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

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

  11. SIGWINCH:窗口变化大小时发出。默认动作为忽略该信号。

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

  13. SIGPWR:关机。默认动作为终止进程。

  14. 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

cpp 复制代码
#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

cpp 复制代码
#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:定时秒数

cpp 复制代码
 类型: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

cpp 复制代码
#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。已达到屏蔽指定信号的目的。

cpp 复制代码
#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信号捕捉:

cpp 复制代码
#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 结构体

cpp 复制代码
 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,表使用默认属性。

cpp 复制代码
#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. 捕捉函数执行期间,被屏蔽信号多次发送,解除屏蔽后只处理一次

cpp 复制代码
#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.借助信号完成 子进程回收

cpp 复制代码
#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;
}

解决方法:

cpp 复制代码
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...

  1. 其他系统调用:getpid、getppid、fork...

结合 pause,回顾慢速系统调用:

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

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

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

③ 中断后返回-1, 设置 errno 为 EINTR(表"被信号中断")

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

相关推荐
gywl1 小时前
openEuler VM虚拟机操作(期末考试)
linux·服务器·网络·windows·http·centos
日记跟新中2 小时前
Ubuntu20.04 修改root密码
linux·运维·服务器
码农君莫笑2 小时前
信管通低代码信息管理系统应用平台
linux·数据库·windows·低代码·c#·.net·visual studio
明 庭2 小时前
Ubuntu下通过Docker部署NGINX服务器
服务器·ubuntu·docker
BUG 4042 小时前
Linux——Shell
linux·运维·服务器
猿小蔡-Cool2 小时前
ubuntu20.04安装imwheel实现鼠标滚轮调速
ubuntu
过过过呀Glik3 小时前
在 Ubuntu 上安装 MySQL 的详细指南
mysql·ubuntu
大霞上仙3 小时前
Linux 多命令执行
linux·运维·服务器
晨欣3 小时前
Kibana:LINUX_X86_64 和 DEB_X86_64两种可选下载方式的区别
linux·运维·服务器
AI青年志3 小时前
【服务器】linux服务器管理员查看用户使用内存情况
linux·运维·服务器