【hello Linux】进程信号
目录
1. 进程信号的引出及整体概况
2. 信号的产生
1. 键盘产生
2. 进程异常
3. 系统调用
4. 软件条件
3. 信号的保存
1. 信号相关的常见概念
2. sigset_t
3. 信号集操作函数
4. sigprocmask：对block位图的操作
5. sigpending：对pending位图的操作
6. 捕捉信号
4. 信号的处理
Linux
1. 进程信号的引出及整体概况
在生活中关于信号的场景有很多。比如：早上响起的闹钟、过马路时的红绿灯、烽火台的烽火、跑步时的信号枪......这些信号都是在生活中的，是给人看的；
虽然这些场景还未到来时，但我们立马便能想到我们接下来应该做什么，其本质也就是：对于信号的处理动作，远远早于信号的产生，这是我们在长期以来积累的经验，又或者是通过学习知道的；
在计算机中也存在着信号，这个信号是OS给进程发送的，目的是为了让进程在合适的时候执行对应的动作。进程也是在没有收到信号时就能够识别信号并知道如何处理它，这是曾经编写OS的工程师在写进程源代码的时候就设置好的；
总结一下：进程具有识别信号并处理信号的能力，这是远远早于信号的产生的。
在生活中，我们收到某种”信号“的时候，并不一定是立即处理的：因为信号随时可能产生，我们在此时可能有更重要的事要做。也就是说：信号的产生和信号的处理是异步的。进程收到某种信号的时候，并不是立即处理的，而是在进程收到信号之后，先将信号保存起来，以供在合适的时候再进行处理。信号本质上也是数据，信号在发送之后，由OS将信号数据写往进程的task_struct中。信号产生的方式不止一种，无论信号时如何产生的，本质在底层都是通过OS发送的！
接下来将从（信号的产生——>信号的保存——>信号的处理）三个方面书写本篇的博客；
请大家耐心看下去，定会收获不少；
开始正文了！！！
2. 信号的产生
1. 键盘产生
我们写了一个每隔1秒钟往显示器输出 ”hello linux!" 的死循环代码；
程序运行起来后，往键盘中输入 ctrl c 发现程序终止，猜想是该进程收到什么信号的原因；
信号捕捉函数：
#include
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
我们可以在程序中，通过使用如上函数对信号进行捕捉；
其本质是修改进程对信号的默认处理动作；
signum：捕捉到的信号；
handler：对于信号的自定义处理方法；
对于信号捕捉函数，只有到收到信号时，才会执行 handler 方法；
#include
#include
#include
//自定义处理方法
void handler(int signo)
{
printf("get a signal: signal no:%d\n",signo);
}
int main()
{
//信号捕捉函数
int i;
for(i=1;i<31;i++)
{
signal(i,handler);
}
while(1)
{
printf("hello linux! pid:%d\n",getpid());
sleep(1);
}
return 0;
}
我们使用如上代码对 1~31 号信号 进行捕捉，发现从键盘输入 ctrl c 后确实产生了信号，并且是2号信号，同时我们也发现 9 号信号是不可被捕捉的；
查看系统定义的信号列表
kill -l
这些信号其实都是利用宏定义出来的，我们既可以使用信号前面的数字，又可以使用信号宏；
编号 34 以上的是实时信号，在此只讨论编号 34 一下的信号；
这些信号各自在什么条件下产生，默认处理动作是什么，我们都可以使用如下命令进行查看：
man 7 signal在此只截出文件中的一小部分；
注意：这些信号的默认处理动作都是终止进程，且只能用来终止前台进程；
使用 kill 命令发送信号：
kill [-信号名] [进程ID]
2. 进程异常
我们写了一个算术异常的代码，经过运行，发现程序崩溃，猜测是否是因为收到信号的原因；
#include
#include
#include
#include
void handler(int signo)
{
printf("get a signal! signal no:%d pid:%d\n",signo,getpid() );
sleep(1);
}
int main()
{
//信号捕捉
int i;
for(i=1;i<31;i++)
{
signal(i,handler);
}
//算术异常
int a=10;
a/=0;
return 0;
}
上述代码对信号捕捉，发现确实是因为收到 8 号信号的原因；
这是因为CPU对上述代码中的异常算术进行了计算，导致CPU出现一些标志位的错误，OS作为硬件资源的管理者，要对硬件的 “健康” 负责，因此向该进程发送信号，达到终止进程的目的；
core dump：
在学习父进程 waitpid 等子进程时，有这样一张图；
我们学习了进程退出时的退出码（(status>>8)&0xff），进程退出时的信号（status&0x7f）；
一直没有说 core dump 标志位是干什么的；
core dump：在程序异常终止时，如果有必要OS会将 core dump 标志位设为1，并将进程在内存中的数据转储到磁盘中，方便我们后期调试；
Linux云服务器，core dump 技术默认是关闭的，可以使用 ulimit -a 查看；
设置 core dump 大小：ulimit -c 10240
设置 core dump 前后对比：
并且我们发现多了 core 文件，这个文件是二进制的，是OS把内存数据直接转载到磁盘中的，是可供我们调试的；
注意：我们要调试程序肯定是在 gdb 下调试的，那编译时便要在后面带 -g 选项；
我们来验证一下如果 core dump 了，那么 core dump 标志位会被置为1；
程序异常时：
#include
#include
#include
#include
int main()
{
if(fork()==0)
{
printf("I am a child...\n");
int a=10;
a/=0;
}
int status=0;
waitpid(-1,&status,0);
printf("exit code:%d, exit signo:%d, core dump flag:%d\n",(status>>8)&0xff,status&0x7f,(status>>7)&0x1);
return 0;
}
运行后发现 core dump 标志位果然被置为1了；
程序正常时：
#include
#include
#include
#include
int main()
{
if(fork()==0)
{
printf("I am a child...\n");
int a=10;
a/=1;
}
int status=0;
waitpid(-1,&status,0);
printf("exit code:%d, exit signo:%d, core dump flag:%d\n",(status>>8)&0xff,status&0x7f,(status>>7)&0x1);
return 0;
}
core dump 标志位为0；
注意：并不是所有的 singnal 都会产生 core dump（在此不进行验证了）；
core 文件的使用：
3. 系统调用
kill：可以给指定的进程发送指定的信号；
#include
#include
int kill(pid_t pid, int sig);
//成功返回0，出错返回-1
raise：给当前进程发送指定信号（自己给自己发）；
#include
int raise(int sig);
//成功返回0，出错返回-1 abort：使当前进程接收到信号而异常终止；
#include
void abort(void);
//abort函数总会成功，所以没有返回值 三个函数的使用：
注意：如下代码并不能直接运行 ，只是示例下三个函数的使用方法；
#include
#include
#include
static void Usage(const char * proc)
{
printf("Usage:\n\t %s signo who\n",proc);
}
int mainint(int argc,char *argv[])
{
//使用手册
if(argc!=3)
{
Usage(argv[0]);
return 1;
}
int signo = atoi(argv[1]);
int who = atoi(argv[2]);
//kill
kill(who,signo);
//raise
raise(signo);
//abort
abort();
printf("signo:%d, who:%d\n",signo,who);
return 0;
} 4. 软件条件
软件条件：通过某种软件(OS)，来触发信号的发送，系统层面设置定时器，或者某种操作而导致条件不就绪等这样的场景下，触发的信号发送；
在进程间通信时：当读端不光不读，而且还关闭了读fd，写端一直在写，最终写进程会受到sigpipe(13)，就是一种典型的软件条件触发的信号发送；
今天主要介绍 alarm 函数和 SLGALRM 信号；
设置闹钟：
#include
unsigned int alarm(unsigned int seconds);
功能：设置一个闹钟，也就是告诉内核在 seconds 秒之后给当前进程发 SIGALRM 信号，该信号的默认处理动作是终止当前进程；
参数：设置的秒数；
返回值：为0，或者是以前设定的闹钟时间还余下的秒数；
代码练习：
如下代码：设置了一个3秒的闹钟，对返回值进行输出 ，并且捕捉信号；
#include
#include
#include
void handler(int signo)
{
printf("get a signal! signo:%d\n",signo);
}
int main()
{
//设置闹钟-3s
int ret = alarm(3);
//对信号进行自定义捕捉
int i;
for(i=1;i<31;i++)
{
signal(i,handler);
}
while(1)
{
printf("hello linux! ret:%d\n",ret);
sleep(1);
}
return 0;
}
运行代码之后发现：alarm函数的返回值为0， 在3秒后收到了一个 14 号信号；
查看发现：14号信号就是SIGALRM；
取消闹钟：
alarm(0);
//返回值为上个闹钟剩余的秒数代码：1s之后我们取消闹钟，并对返回值进行输出打印；
#include
#include
#include
int main()
{
//设置闹钟
int ret = alarm(10);
while(1)
{
sleep(1);
//取消闹钟
int res = alarm(0);
printf("返回值 ret:%d , 剩余值 res:%d\n", ret, res);
}
return 0;
}
接下来我们统计一下 1s CPU的运算次数；
#include
#include
#include
int count=0;
void handler(int signo)
{
printf("count:%d\n",count);
}
int main()
{
//设置一个1s的闹钟
alarm(1);
//对闹钟后的信号进行捕捉
signal(14,handler);
while(1)
{
count++;
}
return 0;
}
我们将代码修改一下，边计算count的值，边进行输出：
#include
#include
#include
int count=0;
int main()
{
//设置一个1s的闹钟
alarm(1);
//对闹钟后的信号进行捕捉
while(1)
{
count++;
printf("count:%d\n",count);
}
return 0;
} 
我们发现这样统计的CPU在1s内的运算次数，比上个代码慢4个0不止，根本原因就是该程序涉及到外设的输出，其大大影响了CPU的速度；
3. 信号的保存
产生的信号，并不一定是立即处理的，OS发送给进程的信号，进程可以先保存在task_struct中；
我们在此讨论的是1~31号信号，task_struct 是用一个 uint32_t sigs 的位图结构对信号进行保存；
比如：
00000000 00000000 00000000 00000000
比特位的位置：代表的就是哪一个信号；
比特位的内容：代表是否收到了信号；
信号在内核中的表示示意图：
对于信号的保存，并以是一张位图完成的，而是三张位图的共同的结果；
block表（信号屏蔽字）：代表该信号是否被堵塞；
pending表：代表是否收到了该信号；
handler表：该表其实是一个函数指针数组，保存着对于信号处理方法函数的地址；
对于一个信号，只有block为0(未堵塞) pending为1(收到信号) 才会处理handler的方法，也就是对信号的处理；
对于信号的处理有三种方法：
1. 默认 SIG_DFL：其实是一个宏定义，表示((sighandler_t)0)；
2. 忽略 SIG_IGN：其实是一个宏定义，表示((sighandler_t)1)；
3. 自定义函数（signal自定义捕捉）；
在此便对信号的发送有了深一步的理解：
产生信号后，OS给进程发送信号，其本质就是OS向指定进程的task_struct中pending位图写入比特位1，即完成信号的写入；
1. 信号相关的常见概念
- 实际执行信号的处理动作称为信号递达(Delivery)
- 信号从产生到递达之间的状态,称为信号未决(Pending)。
- 进程可以选择阻塞 (Block )某个信号。
- 被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
- 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。
2. sigset_t
3. 信号集操作函数
#include
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset (sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember（const sigset_t *set, int signo); - 函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含任何有效信号。
- 函数sigfifillset初始化set所指向的信号集,使其中所有信号的对应bit置1,表示该信号集的有效信号包括系统支持的所有信号。
- 注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfifillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。
4. sigprocmask：对block位图的操作
调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)
#include
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
//返回值:若成功则为0,若出错则为-1
//set：输入型，返回老的信号屏蔽字——block位图，如果不想要的话设为NULL
//oset：输出型，修改block 
5. sigpending：对pending位图的操作
#include
int sigpending(sigset_t *set);
//读取当前进程的未决信号集,通过set参数传出。
//调用成功则返回0,出错则返回-1。
//不对pending位图做修改，只是单纯的获取进程的pending位图，只能OS来修改 下面用刚学的几个函数做个实验：
代码1：
其功能是将2号和9号信号进行屏蔽；
#include
#include
#include
int main()
{
sigset_t iset, oset;
//清空老的和新的信号
sigemptyset(&iset);
sigemptyset(&oset);
//将2号信号添加
sigaddset(&iset,2);
//将9号信号添加
sigaddset(&iset,9);
//1.设置当前进程的屏蔽字
//2.获取当前进程老的屏蔽字
sigprocmask(SIG_SETMASK, &iset, &oset);
while(1)
{
printf("I am a process! pid:%d\n",getpid());
sleep(1);
}
return 0;
}
我们向该进程发送2号信号发现没有反应，发送9号信号发现进程终止；
这也说明了9号信号不仅不可被自定义捕捉，也不可被屏蔽；
代码2：
将2号信号进行堵塞，并输出堵塞之前和堵塞之后的pending位图；
#include
#include
#include
void show_pending(sigset_t *set)
{
printf("pid:%d curr process pending:",getpid());
int i;
for(i=1;i<=31;i++)
{
if(sigismember(set,i))
{
printf("1");
}
else
{
printf("0");
}
}
printf("\n");
}
int main()
{
sigset_t iset, oset;
//清空老的和新的信号
sigemptyset(&iset);
sigemptyset(&oset);
//将2号信号添加
sigaddset(&iset,2);
//1.设置当前进程的屏蔽字
//2.获取当前进程老的屏蔽字
sigprocmask(SIG_SETMASK, &iset, &oset);
sigset_t pending;
while(1)
{
//清空pending
sigemptyset(&pending);
//pending输出型参数
sigpending(&pending);
show_pending(&pending);
sleep(1);
}
return 0;
}
2号信号被堵塞，所以pending中的2号信号位置一直为1；
代码3：
#include
#include
#include
void handler(int signo)
{
printf("%d号信号被传递了，已经处理完成！\n",signo);
}
void show_pending(sigset_t *set)
{
printf("pid:%d curr process pending:",getpid());
int i;
for(i=1;i<=31;i++)
{
if(sigismember(set,i))
{
printf("1");
}
else
{
printf("0");
}
}
printf("\n");
}
int main()
{
sigset_t iset, oset;
//清空老的和新的信号
sigemptyset(&iset);
sigemptyset(&oset);
//将2号信号添加
sigaddset(&iset,2);
//1.设置当前进程的屏蔽字
//2.获取当前进程老的屏蔽字
sigprocmask(SIG_SETMASK, &iset, &oset);
sigset_t pending;
int count=0;
while(1)
{
//清空pending
sigemptyset(&pending);
//pending输出型参数
sigpending(&pending);
show_pending(&pending);
sleep(1);
count++;
if(count==10)
{
sigprocmask(SIG_SETMASK, &oset, NULL);
//2号信号的默认动作是终止进程，看不到现象
printf("恢复2号信号，可以被传递了！\n");
}
//对2号信号进行捕捉
signal(2,handler);
}
return 0;
}
6. 捕捉信号
signal函数可以完成信号的自定义捕捉，sigaction函数也可以
#include
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact); 
sigaction：是一个结构体，在此我们使用它的 (*sa_handler)(int) 和 sa_mask ；
- signo：指定信号的编号；
- act：输入型参数，若act指针非空,则根据act修改该信号的处理动作；
- oact：输出型参数，若oact指针非 空,则通过oact传出该信号原来的处理动作，不想要的话置为NULL；
(*sa_handler)(int) 的使用：
代码： 完成对2号信号的自定义捕捉；
#include
#include
#include
#include
void handler(int signo)
{
printf("get a signal! signo: %d\n",signo);
}
int main()
{
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_handler = handler;
//本质是修改当前进程的handler函数指针数组特定内容
sigaction(2, &act, NULL);
while(1)
{
printf("I am a process! pid:%d\n",getpid());
sleep(1);
}
return 0;
}
//忽略处理
act.sa_handler = SIG_IGN;
//默认处理
act.sa_handler = SIG_DEL;
#include
#include
#include
#include
#include
void handler(int signo)
{
printf("get a signal! signo:%d\n",signo);
}
int main()
{
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_handler = handler;
sigemptyset(&act.sa_mask);
//将3号信号捎带屏蔽
sigaddset(&act.sa_mask, 3);
sigaction(2, &act, NULL);
while(1)
{
printf("I am a process! signo:%d\n",getpid());
sleep(1);
}
return 0;
}
4. 信号的处理
我们之前总说信号的产生和信号的处理并不是同步的，而是在信号产生后在合适的时机进行信号的处理；
这个合适的时机：进程从内核态切换回用户态的时候，进行信号检测与信号的处理；
先来科普一些知识：
OS也是软件，在开机的时候，便是将OS的代码和数据加载到内存中。每个进程有自己的一张页表，OS也有：系统级页表，这张页表是供所有进程共享的。进程的程序地址有3GB给用户使用，还有1GB是给OS使用的。当进程切换至内核态时，便能访问那1GB空间，每个进程都是如此，进程之间无论如何切换，我们能保证我们一定能够找到同一个OS，因为我们每个进程都有3~4的地址空间，使用同一张内核页表。
CPU中有CR3寄存器，当CR3寄存器为0时：代表OS，当CR3为1时：代表用户；
用户态使用的是用户级页表，只能访问用户数据和代码；
内核态使用的是内核级页表，只能访问内核级数据和代码；
所谓的系统调用：就是进程的身份转化成为内核，然后根据内核页表找到系统函数，执行函数；
在大部分情况下，实际上我们OS都是可以在进程的上下文中直接运行的，但为了保护OS的安全，只允许OS执行内核代码；
上述皆是较为感性的认识；
下面的是较为理性的认识：
信号的处理过程：
用一张图更好的记忆下：
坚持打卡！