信号处理：信号产生
目录
一：信号快速认识
1.1生活角度的信号
1.2技术应用角度的信号
1.2.1一个样例：
1.2.2一个系统调用
1.3信号的概念
1.3.1查看信号
1.3.2 信号处理
二：产生信号
2.1通过终端按键产生信号
2.1.1基本操作
2.1.2理解OS如何得知键盘有数据
2.1.3初步理解信号起源
2.2调用系统命令向进程发信号
2.3使用函数产生信号
2.3.1 kill
2.3.2raise
2.3.3abort
2.4由软件条件产生信号
2.4.1基本alarm验证-体会IO效率问题
2.4.2设置重复闹钟
2.4.3如何理解软件条件
2.4.4如何简单快速理解系统闹钟
2.5硬件异常产生信号
2.5.1模拟除0
2.5.2模拟野指针
2.5.3子进程退出core dump
2.5.4 Core Dump
一：信号快速认识
1.1生活角度的信号
在网上买了很多件商品，再等待不同商品快递的到来。但即便快递没有到来，你也知道快递来临 时，你该怎么处理快递。也就是你能“识别快递”
当快递员到了你楼下，你也收到快递到来的通知，但是你正在打游戏，需5min之后才能去取快递。 那么在在这5min之内，你并没有下去去取快递，但是你是知道有快递到来了。也就是取快递的行为并不是一定要立即执行，可以理解成“在合适的时候去取”。
在收到通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间，你并没有拿到快递，但是 你知道有⼀个快递已经来了。本质上是你“记住了有⼀个快递要去取”
当你时间合适，顺利拿到快递之后，就要开始处理快递了。而处理快递⼀般方式有三种：
1.执行默认动作 2.执行自定义动作（快递是礼物，送其他人） 3.忽略快递（快递拿上来之后什么也不做）
快递到来的整个过程，对你来讲是异步（突然的，意外的），你不能准确断定快递员什么时候给你打电话
基本结论：
1.你怎么能识别信号呢？识别信号是内置的，进程识别信号，是内核程序员写的内置特性。 2.信号产生之后，你知道怎么处理吗？知道。如果信号没有产生，你知道怎么处理信号吗？ 知道。所以，信号的处理方法，在信号产生之前，已经准备好了。
3.处理信号，立即处理吗？我可能正在做优先级更高的事情，不会立即处理？什么时候？合 适的时候。
3.信号到来|信号保存 |信号处理
怎么进行信号处理啊？a.默认 b.忽略 c.自定义，后续都叫做信号捕捉。
1.2技术应用角度的信号
1.2.1一个样例：
#include <iostream>
#include<unistd.h>int main()
{while(true){std::cout << "I am a process, I am waiting signal"<<std::endl;sleep(1);}return 0;
}
用户输入命令,在Shell下启动⼀个前台进程
用户按下 Ctrl+C ,这个键盘输入产生⼀个硬件中断，被OS获取，解释成信号，发送给目标前台进 程
前台进程因为收到信号，进而引起进程退出
1.2.2一个系统调用
NAMEsignal - ANSI C signal handling#include <signal.h>typedef void (*sighandler_t)(int);sighandler_t signal(int signum, sighandler_t handler);参数说明：
signum：信号编号，后⾯解释，只需要知道是数字即可
handler：函数指针，表⽰更改信号的处理动作，当收到对应的信号，就回调执⾏handler⽅法
而其实， Ctrl+C 的本质是向前台进程发送 SIGINT 即 2 号信号，我们证明⼀下，这里需要引入一 个系统调用函数
#include <iostream>
#include<unistd.h>
#include<signal.h>void Handler(int signo)
{std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl;
}int main()
{std::cout << "我是进程："<<getpid()<<std::endl;//signal只需要设置一次就够了，之后的进程都会执行这个信号，不需要放在循环signal(SIGINT,Handler);//默认执行自定义的Handlerwhile(true){std::cout << "I am a process, I am waiting siganl " << std::endl;sleep(1);}return 0;
}
此时我们会看到，当我们按下Ctrl+c之后，进程捕捉到2号信号，但是为什么这一会按下Ctrl+c之后进程没有退出呢？这篇文章后面会说明原因
要注意的是，signal函数仅仅是设置了特定信号的捕捉行为处理方式，并不是直接调用处理动作。如果后续特定信号没有产生，设置的捕捉函数永远也不会被调用！！
Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样 Shell不必等待进程结束就可以接受新的命令,启动新的进程。
Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生的信号。
前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生⼀个信号,也就是说该进程的用户空间代码执行到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步(Asynchronous)的。
1.3信号的概念
信号是进程之间事件异步通知的一种方式，属于软中断
1.3.1查看信号
9 号信号（SIGKILL）：强制终止进程
19 号信号（SIGSTOP）：暂停进程
发送这两个信号时，程序会直接终止或暂停，不会执行Handler 函数，无法捕捉信号
每个信号都有⼀个编号和⼀个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定义 #define SIGINT 2
编号34以上的是实时信号,这篇文章只讨论编号34以下的信号,不讨论实时信号。这些信号各自在什么条件下产生,默认的处理动作是什么,在signal(7)中都有详细说明: man 7 signal
1.3.2 信号处理
可选的处理动作有以下三种：
忽略此信号：SIG_IGN
#include <iostream>
#include<unistd.h>
#include<signal.h>void Handler(int signo)
{std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl;
}int main()
{std::cout << "我是进程："<<getpid()<<std::endl;signal(SIGINT,SIG_IGN);//设置忽略信号的宏while(true){std::cout << "I am a process, I am waiting siganl " << std::endl;sleep(1);}return 0;
}
执行该信号的默认处理动作：SIG_DFL
#include <iostream>
#include<unistd.h>
#include<signal.h>void Handler(int signo)
{std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl;
}int main()
{std::cout << "我是进程："<<getpid()<<std::endl;signal(SIGINT,SIG_DFL);//设置忽略信号的宏while(true){std::cout << "I am a process, I am waiting siganl " << std::endl;sleep(1);}return 0;
}
由此也可以看出：输入ctrl+c,进程退出，就是默认动作
提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为自定义捕捉(Catch)一个信号
OS收到中断信号（从硬件中断来）之后，只需要把外设数据拷贝就好了，OS只需要等待不需要轮询外设
以上是对于信号的一个大体的认识，之后对于信号的讲解，按照一下思路阐述：
二：产生信号
当前阶段：
2.1通过终端按键产生信号
2.1.1基本操作
Ctrl+C (SIGINT) 已经验证过，这里不再重复 ，见上面的1.2
Ctrl+\（SIGQUIT）可以发送终止信号并生成core dump文件，用于事后调试
Ctrl+Z（SIGTSTP）可以发送停止信号，将当前前台进程挂起到后台等。
2.1.2理解OS如何得知键盘有数据
2.1.3初步理解信号起源
信号其实是从纯软件角度，模拟硬件中断的行为
只不过硬件中断是发给CPU，而信号是发给进程
两者有相似性，但是层级不同
2.2调用系统命令向进程发信号
首先在后台执行死循环程序,然后用kill命令给它发SIGSEGV信号。
1291636是 sig 进程的pid。之所以要再次回车才显示Segmentation fault ,是因为在 1291636进程终止掉之前已经回到了Shell提示符等待用户输入下⼀条命令, Shell 不希望 Segmentation fault 信息和用户的输入交错在⼀起,所以等用户输入命令之后才显示。
指定发送某种信号的 kill 命令可以有多种写法,上面的命令还可以写成 kill -11 1291636,11 是信号 SIGSEGV 的编号。以往遇到的段错误都是由非法内存访问产生的,而这个程序本身没错,给它发SIGSEGV也能产生段错误。
2.3使用函数产生信号
2.3.1 kill
kill 命令是调用kill函数实现的。 kill 函数可以给一个指定的进程发送指定的信号。
NAMEkill - send signal to a processSYNOPSIS#include <sys/types.h>#include <signal.h>int kill(pid_t pid, int sig);RETURN VALUEOn success (at least one signal was sent), zero is returned. On error,-1 is returned, and errno is set appropriately.
实现自己的mykill：
#include <iostream>
#include<unistd.h>
#include <sys/types.h>
#include<signal.h>// ./signal -9 pid
int main(int argc, char* argv[])
{if(argc != 3){std::cout << "输入错误，请重新输入 "<<std::endl;return 1;}int killnum = std::stoi(argv[1]+1);//去掉-int pid = std::stoi(argv[2]);int n = ::kill(pid,killnum);if(n <0){std::cout << "kill 失败"<<std::endl;return 2;}return 0;
}
2.3.2raise
raise 函数可以给当前进程发送指定的信号(自己给自己发信号)。
NAMEraise - send a signal to the caller
SYNOPSIS#include <signal.h>int raise(int sig);RETURN VALUEraise() returns 0 on success, and nonzero for failure.
void Handler(int signo)
{std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl;
}int main()
{signal(2,Handler);// 先对2号信号进⾏捕捉 // 每隔1S，⾃⼰给⾃⼰发送2号信号 while(true){sleep(1);raise(2);}return 0;
}
2.3.3abort
abort 函数使当前进程接收到信号而异常终止。
AMEabort - cause abnormal process terminationSYNOPSIS#include <stdlib.h>void abort(void);RETURN VALUEThe abort() function never returns.// 就像exit函数⼀样,abort函数总是会成功的,所以没有返回值。
2.4由软件条件产生信号
SIGPIPE 是⼀种由软件条件产生的信号,在“管道”中已经介绍过了。本节主要介绍 alarm 函数和 SIGALRM 信号。
SIGPIPE：匿名管道中，如果读端关闭写端非法写入时，退出信号，13，之前文章中有验证
进程间通信：管道与共享内存-CSDN博客
AMEalarm - set an alarm clock for delivery of a signalSYNOPSIS#include <unistd.h>unsigned int alarm(unsigned int seconds);RETURN VALUEalarm() returns the number of seconds remaining until any previouslyscheduled alarm was due to be delivered, or zero if there was no previ‐ ously scheduled alarm.
调用alarm 函数可以设定⼀个闹钟,也就是告诉内核在 seconds 秒之后给当前进程发 SIGALRM 信号，该信号的默认处理动作是终止当前进程。
这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。打个比方,某⼈要睡⼀觉,设定闹 钟为30分钟之后响,20分钟后被⼈吵醒了,还想多睡⼀会儿,于是重新设定闹钟为15分钟之后响,“以前设定的闹钟时间还余下的时间”就是10分钟。如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数。
void die(int signo)
{std::cout <<"get a siganl : "<< signo << std::endl;
}
int main()
{alarm(10);sleep(4);int n = alarm(0);//取消闹钟std::cout << "n : "<<n << std::endl;signal(SIGALRM,die);return 0;
}
2.4.1基本alarm验证-体会IO效率问题
程序的作用是1秒钟之内不停地数数,1秒钟到了就被SIGALRM信号终止。必要的时候，对SIGALRM信号进行捕捉
2.4.2设置重复闹钟
NAMEpause - wait for signalSYNOPSIS#include <unistd.h>int pause(void);DESCRIPTIONpause() causes the calling process (or thread) to sleep until a signalis delivered that either terminates the process or causes the invoca‐ tion of a signal-catching function.RETURN VALUEpause() returns only when a signal was caught and the signal-catchingfunction returned. In this case, pause() returns -1, and errno is setto EINTR.
using func_t = std::function<void()>;int gcount = 0;
std::vector<func_t> gfuncs;//把信号更换为硬件中断
void Handler(int signo)
{for(auto& f : gfuncs){f();}std::cout << "gcount : "<<gcount << std::endl;
}int main()
{gfuncs.push_back([](){std::cout << "我是内核刷新操作"<<std::endl;});gfuncs.push_back([](){std::cout << "我是切换时间片操作，到了时间，会切换进程"<<std::endl;});gfuncs.push_back([](){std::cout << "我是内核管理操作，定期清理内存碎片"<<std::endl;});alarm(1);signal(SIGALRM,Handler);while(true){pause();std::cout << "我醒来了……"<<std::endl;gcount++;}return 0;
}
由此可以看出闹钟设置一次，起效一次
重复设置：
2.4.3如何理解软件条件
在操作系统中，信号的软件条件指的是由软件内部状态或特定软件操作触发的信号产生机制。这些条件包括但不限于定时器超时（如alarm函数设定的时间到达）、软件异常（如向已关闭的管道写数据 产生的SIGPIPE信号）等。当这些软件条件满足时，操作系统会向相关进程发送相应的信号，以通知进程进行相应的处理。简而言之，软件条件是因操作系统内部或外部软件操作而触发的信号产生。
2.4.4如何简单快速理解系统闹钟
系统闹钟，其实本质是OS必须自身具有定时功能，并能让用户设置这种定时功能，才可能实现闹钟这样的技术。 现代Linux是提供了定时功能的，定时器也要被管理：先描述，在组织。内核中的定时器数据结构是：
struct timer_list {struct list_head entry;unsigned long expires;void (*function)(unsigned long);unsigned long data;struct tvec_t_base_s *base;
};
我们可以看到：定时器超时时间expires和处理方法 function。
操作系统管理定时器，采用的是时间轮的做法，但是我们为了简单理解，可以把它在组织成为"堆结构"
2.5硬件异常产生信号
硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。
例如当前 进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。
2.5.1模拟除0
void handler(int sig)
{printf("catch a sig : %d\n", sig);
}
// v1
int main()
{signal(SIGFPE, handler); // 8) SIGFPEsleep(1);int a = 10;a /= 0;while (1);return 0;
}
2.5.2模拟野指针
void handler(int sig)
{printf("catch a sig : %d\n", sig);
}
// v1
int main()
{signal(SIGSEGV, handler); // 11) SIGFPEsleep(1);int* p = nullptr;*p = 10;while (1);return 0;
}
由此可以确认，我们在C/C++当中除零，内存越界等异常，在系统层面上，是被当成信号处理的。
注意： 通过上面的实验，我们可能发现： 发现⼀直有8号信号产生被我们捕获，这是为什么呢？上面我们只提到CPU运算异常后，如何处理后续的流程，实际上 OS 会检查应用程序的异常情况，其实在CPU中有⼀些控制和状态寄存器，主要用于控制处理器的操作，通常由操作系统代码使用。状态寄存器可以简单理解 为⼀个位图，对应着⼀些状态标记位、溢出标记位。OS 会检测是否存在异常状态，有异常存 在就会调用对应的异常处理方法。
除零异常后，我们并没有清理内存，关闭进程打开的文件，切换进程等操作，所以CPU中还 保留上下文数据以及寄存器内容，除零异常会⼀直存在，就有了我们看到的⼀直发出异常信 号的现象。访问非法内存其实也是如此
2.5.3子进程退出core dump
int main()
{int status = 0;waitpid(-1, &status, 0);printf("exit signal: %d, core dump: %d\n", status & 0x7F, (status >> 7) & 1);return 0;
}
2.5.4 Core Dump
SIGINT的默认处理动作是终止进程,SIGQUIT的默认处理动作是终止进程并且Core Dump,现在我们 来验证⼀下。
首先解释什么是Core Dump。当⼀个进程要异常终止时,可以选择把进程的用户空间内存数据全部保存到磁盘上,文件名通常是core,这叫做Core Dump。
进程异常终止通常是因为有Bug，比如非法内存访问导致段错误,事后可以用调试器检查core文件以 查清错误原因,这叫做 Post-mortem Debug （事后调试）。
⼀个进程允许产生多大的 core 文件取决于进程的 Resource Limit (这个信息保存在PCB 中)。默认是不允许产生core文件的,因为 core 文件中可能包含用户密码等敏感信息,不安全。
在开发调试阶段可以用ulimit 命令改变这个限制,允许产生core ⽂件。
首先用ulimit 命令改变Shell进程的Resource Limit ,如允许 core 文件最大为1024K:
ulimit -c 1024
ulimit命令改变了Shell进程的Resource Limit,test进程的PCB由Shell进程复制而来,所以也具有和 Shell进程相同的Resource Limit值,这样就可以产生Core Dump了
使用：
core-file core:事后调试，在gdb输入这个命令，直接定位到出错行号