Linux——进程信号

本节重点：

1. 掌握Linux信号的基本概念

2. 掌握信号产生的一般方式

3. 理解信号递达和阻塞的概念，原理。

4. 掌握信号捕捉的一般方式。

5. 重新了解可重入函数的概念。

6. 了解竞态条件的情景和处理方式

7. 了解SIGCHLD信号， 重新编写信号处理函数的一般处理机制

一，信号入门理解

1，生活角度的信号

你在网上买了很多件商品，再等待不同商品快递的到来。但即便快递没有到来，你也知道快递来临时， 你该怎么处理快递。也就是你能“识别快递”

当快递员到了你楼下，你也收到快递到来的通知，但是你正在打游戏，需5min之后才能去取快递。那 么在在这5min之内，你并没有下去去取快递，但是你是知道有快递到来了。也就是取快递的行为并不 是一定要立即执行，可以理解成“在合适的时候去取”。

在收到通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间，你并没有拿到快递，但是你知 道有一个快递已经来了。本质上是你“记住了有一个快递要去取”

当你时间合适，顺利拿到快递之后，就要开始处理快递了。而处理快递一般方式有三种：

1. 执行默认动 作（幸福的打开快递，使用商品）

2. 执行自定义动作（快递是零食，你要送给你你的女朋友）

3. 忽略快 递（快递拿上来之后，扔掉床头，继续开一把游戏）

快递到来的整个过程，对你来讲是异步的，你不能准确断定快递员什么时候给你打电话

2，专业角度的信号

. 用户输入命令,在Shell下启动一个前台进程。  用户按下Ctrl-C ,这个键盘输入产生一个硬件中断，被OS获取，解释成信号，发送给目标前台进程 . 前台进程因为收到信号，进而引起进程退出

int main()
{
 while(1){
 printf("I am a process, I am waiting signal!\n");
 sleep(1);
 }
}
[hb@localhost code_test]$ ./sig
I am a process, I am waiting signal!
I am a process, I am waiting signal!
I am a process, I am waiting signal!
^C
}

从这个例子中，我们可以这样理解：

进程就是你，操作系统就是快递员，信号就是快递。

3，注意：

1. Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样Shell不必等待进程 结束就可以接受新的命令,启动新的进程。

2. Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生 的信号。

3. 前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生一个信号,也就是说该进程的用户空间代码执行 到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步 (Asynchronous)的。

4，kill -l 命令

每个信号都有一个编号和一个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定 义 #define SIGINT 2

编号34以上的是实时信号,本章只讨论编号34以下的信号,不讨论实时信号。这些信号各自在什么条件下 产生,默认的处理动作是什么,在signal(7)中都有详细说明: man 7 signal

5，信号常见处理方式

1. 忽略此信号。

2. 执行该信号的默认处理动作。

3. 提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为捕捉 (Catch)一个信号。

6，信号被读取的过程

1，首先从键盘输入数据后，会对cpu对应的针脚产生中断，从而告诉cpu自己产生数据了

2，cpu接到信号后进行处理，将数据发送给进程

3，最后进程在一个函数指针数组中查找对应信号的处理方法，最后以这种方法执行出去。

二，产生信号

1，如何判断是否收到信号了

通过位图！！！

每个进程都有一张自己的函数指针数组，指针的下标和信号的编号强相关。

所以os向目标进程发信号的本质是写信号，就是修改该进程pcb中的位图。

无论信号有多少种产生方式，只能由os向目标进程发送信号：

因为os是进程的直接管理者。

2，信号的自定义捕捉

但是9号信号不可被修改！

3，通过终端按键产生信号

SIGINT的默认处理动作是终止进程,SIGQUIT的默认处理动作是终止进程并且Core Dump,现在我们来验证一 下。

4，kill命令

这里通过对数组argv的读取来获得信号，其中在下标为0位置放的是进程，1位置放的是进程码，2位置放的是对应信号。

举个例子：

5，raise命令

raise(signo)  相当于  kill(getpid(),signo)。

6，abort函数

abort函数：void abort(void)
功能：给自己发送异常终止信号6：SIGABRT信号，并终止产生core文件
返回值：无

7，异常

问题引入：计算机为什么能判断出除0错误？

解释：

计算机可能会将a变量放进eax寄存器当中，然后除数放入ebx寄存器中，将运算结果放入ecx，但是中间过程中会经过status寄存器判断溢出，除零时status就会报错，从而阻止结果放入ecx中，这就是硬件上对于异常的处理。

然后系统将错误会直接kill，会将信号发至进程，将标志位从0改为1，最后干掉引发问题的进程，解释为信号的发送。

以下代码可以解释除0错误：

一旦除0，系统会向进程发送8号信号，但是为什么会一直发送，不终止呢？

解释：

收到异常后会调度8号信号的处理方式，但是我们重写了8号信号的处理方式，让进程不在退出，这样异常一直存在，一直进行调度，再发送信号，一直循环，就不再执行接下来的进程，所以会出现循环调度。

问题引入：空指针错误是如何发现的？

解释：

如果虚拟内存转化为物理内存中出现错误，mmu通过页表从虚拟转物理时就会识别出问题，被os捕捉到，这个就是被成为段错误，也就是野指针问题。（11号信号）

所以综上我们出异常的目的是为了让进程正常退出，不是为了修正。

产生信号的方式有很多，但是发送信号只能由os发送！！！

8，软件条件

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动
作是终止当前进程。

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。

打个比方,某人要小睡一觉,设定闹钟为30分钟之后 响,20分钟后被人吵醒了,还想多睡一会儿,于是重新设定闹钟为15分钟之后响,“以前设定的闹钟时间还余下的时间”就 是10分钟。

如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数

闹钟的本质就是建立一个小堆，对比设置的闹钟，将超时的pop出去，转换成信号的产生，产生闹钟信号。

查看闹钟一秒让cnt加多少次：

软件产生信号终止的例子：

如果在写入管道中后，写的方法被关闭，此时就会产生信号让os发送信号关闭管道。

闹钟返回值是闹钟剩余时间。

综上：闹钟就是一种软件产生信号的方式。

1，所有用户的行为，都是以进程的形式在os中表现的

2，操作系统只要把进程调度好，就能完成所有的用户任务

3，cmos，周期性高频率的向cpu发送时钟中断。

操作系统是基于硬件中断的，不断刷新cpu内调用中断向量表

9，coredump：

1、什么是coredump：

我们经常听到大家说到程序core掉了，需要定位解决，这里说的大部分是指对应程序由于各种异常或者bug导致在运行过程中异常退出或者中止，并且在满足一定条件下会产生一个叫做core的文件。
    通常情况下，core文件会包含了程序运行时的内存，寄存器状态，堆栈指针，内存管理信息还有各种函数调用堆栈信息等，我们可以理解为是程序工作当前状态存储生成的一个文件，许多的程序出错的时候都会产生一个core文件，通过工具分析这个文件，我们可以定位到程序异常退出的时候对应的堆栈调用等信息，找出问题所在并进行及时解决。
   

2、开启或关闭core文件的生成：

（1）查看core文件是否打开：

ulimit -c  # 如果为 0 表示coredump开关处于关闭状态

（2）打开core文件生成： 

ulimit -c 1024         # 1024个blocks,一般1block=512bytes
ulimit -c unlimited    # 取消大小限制

（3）检查core文件的选项是否打开：

ulimit -a  # 显示当前所有limit信息

命令参数      描述                                          例子
-H    设置硬资源限制，一旦设置不能增加。                      ulimit – Hs 64；限制硬资源，线程栈大小为 64K。
-S    设置软资源限制，设置后可以增加，但是不能超过硬资源设置。  ulimit – Sn 32；限制软资源，32 个文件描述符。
-a    显示当前所有的 limit 信息                             ulimit – a；显示当前所有的 limit 信息
-c    最大的 core 文件的大小， 以 blocks 为单位              ulimit – c unlimited； 对生成的 core 文件的大小不进行限制
-d    进程最大的数据段的大小，以 Kbytes 为单位                ulimit -d unlimited；对进程的数据段大小不进行限制
-f    进程可以创建文件的最大值，以 blocks 为单位              ulimit – f 2048；限制进程可以创建的最大文件大小为 2048 blocks
-l    最大可加锁内存大小，以 Kbytes 为单位                   ulimit – l 32；限制最大可加锁内存大小为 32 Kbytes
-m    最大内存大小，以 Kbytes 为单位                         ulimit – m unlimited；对最大内存不进行限制
-n    可以打开最大文件描述符的数量                           ulimit – n 128；限制最大可以使用 128 个文件描述符
-p    管道缓冲区的大小，以 Kbytes 为单位                     ulimit – p 512；限制管道缓冲区的大小为 512 Kbytes
-s    线程栈大小，以 Kbytes 为单位                          ulimit – s 512；限制线程栈的大小为 512 Kbytes
-t    最大的 CPU 占用时间，以秒为单位                        ulimit – t unlimited；对最大的 CPU 占用时间不进行限制
-u    用户最大可用的进程数                                  ulimit – u 64；限制用户最多可以使用 64 个进程
-v    进程最大可用的虚拟内存，以 Kbytes 为单位               ulimit – v 200000；限制最大可用的虚拟内存为 200000 Kbytes

以上是命令总览

（4） 永久配置core：

   以上配置只对当前会话起作用，下次重新登陆后，还是得重新配置。要想配置永久生效，得在/etc/profile或者/etc/security/limits.conf文件中进行配置。

3、造成程序core的原因（参考）：

（1）内存访问越界：

（2）多线程程序使用了线程不安全的函数：

（3）多线程读写的数据未加锁保护：

（4）非法指针：

（5）堆栈溢出：

具体的学习请参考大佬博客：
详解coredump-CSDN博客

三，阻塞信号

1. 信号其他相关常见概念

实际执行信号的处理动作称为信号递达(Delivery)

信号从产生到递达之间的状态,称为信号未决(Pending)。

在信号位图中，从信号产生到信号被处理中间的过程，就叫做信号未决

进程可以选择阻塞 (Block )某个信号。

未决后，暂时不抵达，直到解除对信号的阻塞中间的状态。

被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.

注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。

1，每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针表示处理动作。信号 产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例子 中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作

2，SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前 不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞

3，SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。 如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次 或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可 以依次放在一个队列里。本章不讨论实时信号。

2. 在内核中的表示

1，sigset_t

从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。 因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号 的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有 效”和“无效”的含义是该信号是否处于未决状态。下一节将详细介绍信号集的各种操作。 阻塞信号集也叫做当 前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略。

2，位图的实现

下标存储利用除法，再精细找位置则用%。

3. 信号集操作函数

sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态,至于这个类型内部如何存储这些bit则依赖于系统 实现,从使用者的角度是不必关心的,使用者只能调用以下函数来操作sigset_ t变量,而不应该对它的内部数据做 任何解释,比如用printf直接打印sigset_t变量是没有意义的

#include <signal.h>
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);

1，函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有 效信号。

2，函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系 统支持的所有信号。

3，注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的 状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号

这四个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含 某种 信号,若包含则返回1,不包含则返回0,出错返回-1。

4，sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
返回值:若成功则为0,若出错则为-1 

第一个参数how：

表面函数执行的方法。
第二个参数set：

表面执行新增一个或者多个信号进行屏蔽。

第三个参数oset：

老表中的位图参数返回，

举个例子：

让我们对2号信号处理方式做一点改变，让它不再退出

这样设置后按^c进程便不会再退出。

5，sigpending

#include <signal.h>
sigpending
读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。 下面用刚学的几个函数做个实验。程
序如下:

程序运行时,每秒钟把各信号的未决状态打印一遍,由于我们阻塞了SIGINT信号,按Ctrl-C将会 使SIGINT信号处于未决 状态,按Ctrl-\仍然可以终止程序,因为SIGQUIT信号没有阻塞。

其中：

int sigemptyset(sigset_t *mask)                  清空信号集
 
int sigfillset(sigset_t *mask, int signum)       在信号集中设置所有信号  
 
int sigdelset(sigset_t *mask, int signum)        从信号集中删除signum信号
 
int sigaddset(sigset_t *mask, int signum)        在信号集中添加signum信号
 

int sigisnumber(sigset_t *mask, int signum)      测试信号signum是否在信号集中

但是有个问题，pending表中位图的修改是在处理信号前还是处理信号后呢？
验证：

结果：

事实就是pending表的位图已经在信号处理前就修改了。

3，信号的处理——捕捉信号

信号在合适的时候被处理---什么时候？

答：进程从内核返回到用户态的时候，进行信号的检测和信号的处理。

1，内核态和用户态：

用户态是一种受控的状态，能够访问的资源是有限的

内核态是一种操作系统的工作状态，能够访问大部分的系统资源

系统级接口只有一个，所哟一os中内核页表一份足矣，所以多个进程访问的内核页表是同一份

无论进程如何调度，cpu都可以直接找到os！！

我们的进程所有代码的执行，都可以在自己的地址空间内通过跳转的方式，进行调用和返回。

在cpu中：

有一个叫做cs的寄存器，它有两个比特位表征当前寄存器工作状态。

其中：

1表示内核，对应的是01

3表示用户，对应的是10

CR3:

还有寄存器比如cr1，cr3，他们是用来保存当前页表信息的。

它保存的是物理地址！！！，它必须要支持我们快速的找到用户级对应的页表。

CR1:

保存发生缺页中断的地址，在虚拟转化为物理地址前。

综上所述：从用户态到内核态的的转化是由cs寄存器比特位从“01”到“10”转变的，而且这一过程是由操作系统完成的

信号的处理就是从用户态变成内核态，再从内核态返回用户态时处理的。

2，在访问信号的方法时是在内核态还是用户态？n

不能是内核态！因为信号的处理方式是可以被用户自定义的，万一发生越界可能会对内核造成问题

所以以用户态的方式访问是最安全的。

3，信号的捕捉——sigol_return函数

在执行完信号的执行方法后，要从用户态态再次返回内核态处理下一条信号，所以我们必须要有返回的函数，叫做sys_sigreturn().

整个过程可以描述为：

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码 是在用户空间的,处理过程比较复杂,举例如下: 用户程序注册了SIGQUIT信号的处理函数sighandler。 当前正在执行 main函数,这时发生中断或异常切换到内核态。 在中断处理完毕后要返回用户态的main函数之前检查到有信号 SIGQUIT递达。 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函 数,sighandler 和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是 两个独立的控制流程。 sighandler函数返 回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复 main函数的上下文继续执行了。

4，sigaction

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

1，sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回-1。signo 是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非 空,则通过oact传 出该信号原来的处理动作。act和oact指向sigaction结构体:

2，将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动 作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函 数,该函数返回 值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信 号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。

注意：

当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来 的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。 如果 在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需 要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags字段包含一些选项,本章的代码都 把sa_flags设为0,sa_sigaction是实时信号的处理函数

验证：sigaction函数对信号的捕捉是可以同时捕捉多个吗》
代码验证：

结论：

是可以同时捕捉的

四，信号的补充

1,可重入函数

问题分析：
1，main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的 时候,因 为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换 到sighandler函 数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的 两步都做完之后从 sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续 往下执行,先前做第一步 之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后 向链表中插入两个节点,而最后只 有一个节点真正插入链表中了。

2，像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称 为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为 不可重入函数,反之, 如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant) 函数。想一下,为什么两个不同的 控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?

不可重入的函数具有以下特点：

调用了malloc或free,因为malloc也是用全局链表来管理堆的。

调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。

2，volatile

引入：
我们先用以下代码做个测试：

允许完后，这是正常情况下的结果：

这次我们把优化级别调高：

结果代码就不退出了：

分析：

正常情况下变量是储存在内存当中，但是代码的执行是由cpu来的，cpu中寄存器会将内存中变量不断刷新拿走在while里进行判断，继而将信号传输给针脚。一旦内存中变量值改为1，cpu寄存器拿取时就会向针脚发送中断信号，从而终止循环。

那么优化时：

cpu中的寄存器只会读取一次内存里变量的值，后序cpu只会将最开始读取的变量一直放在while里进行比对，变量变成了只读状态，尽管后序变量值被修改了，所以这样就导致一直在while循环里无法跳出来。

就好比说内存和cpu之间产生了一层屏障。

而volatile的作用就是保证读取稳定性，始终保持cpu和内存的可见状态

3，SIGCHLD信号

其实,子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自 定义SIGCHLD信号 的处理函数,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程 终止时会通知父进程,父进程在信号处理 函数中调用wait清理子进程即可。

请编写一个程序完成以下功能:父进程fork出子进程,子进程调用exit(2)终止,父进程自定 义SIGCHLD信号的处理函数, 在其中调用wait获得子进程的退出状态并打印。

事实上,由于UNIX 的历史原因,要想不产生僵尸进程还有另外一种办法:父进程调 用sigaction将SIGCHLD的处理动作 置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不 会产生僵尸进程,也不会通知父进程。

系统默认的忽 略动作和用户用sigaction函数自定义的忽略 通常是没有区别的,但这是一个特例。此方法对于Linux可用,但不保证 在其它UNIX系统上都可 用。请编写程序验证这样做不会产生僵尸进程。

当然也可以被替代，写一个手动不进行等待的方式，让进程自动被回收：

本篇到此结束！！！