[系统运维]Linux进程信号

一.信号入门

信号相关的理论基础 :
(1). 信号还没有产生的时候，对于我们来讲，我们是知道信号产生以后，应该怎么做的。
例如 : 我们晚上定了一个闹钟，虽然闹钟并没有响，但我们知道闹钟响了以后，我们要起床
虽然我们没有看到红绿灯，但我们知道红灯停，绿灯行
(2). 我们能够识别这些信号，是因为有人曾经给过我们这样的"教育"过程，让我们将信号特征，如何识别，及其处理过程记住了
例如 : 小时候，老师和父母教育我们红绿灯的特征，如何识别，以及遇到红绿灯该怎么做(红灯停，绿灯行)
(3). 信号产生的时候，和人的正常生活之间是一种异步关系
例如 : 我们在上课的时候，电话铃声响了(信号产生)，但我们不会立即处理信号，还会继续上课
(4). 当信号产生的时候，我们并不一定立即去处理信号，因为我们可能在做优先级更高的事情，所以我们会在合适的时候去处理信号，此时信号已经产生但没有处理，所以我们一定要用某种方式记下来信号已经产生，在我们做完优先级更高的事情后，再去处理这个信号
(5). 当我们处理信号时，有三种方式，分别为 默认行为，自定义行为，忽略信号

推广到进程当中 :
(1). 进程虽然现在没有收到信号，但是进程知道收到信号以后，该怎么做(说明进程内部一定能够识别信号->程序员设计进程的时候，已经内置了处理方案->信号属于进程内部特有的特征)
(2). 当信号到来的时候，进程可能正在处理更重要的事情，信号可能不会被立即处理，等合适的时候在进行处理(在这段时间窗口中，信号必须暂时被进程保存起来)
(3). 进程处理信号时有三种方式 : 默认行为，自定义行为，忽略

(4). 查看所有信号可以用 kill -l 命令查看，一共62个信号，1~31号信号为普通信号，34 ~ 62号信号为实时信号

kill -l 

(5). 信号本质是一个宏，定义在 /usr/include/bits/signum.h 中，我们使用 vim 打开后就可以看到其定义

vim /usr/include/bits/signum.h

信号是如何发送的以及如何记录的?

信号的记录是在进程的 task_struct 中的，使用位图(unsigned int signal)来记录信号是否产生，比特位的位置代表信号编号，比特位的内容代表是否收到信号(1代表收到信号，0代表没有收到信号)

进程收到信号，本质是进程内信号位图被修改了，有资格修改进程内信号位图的只有操作系统

信号发送只有操作系统有资格，但信号发送的方式有多种

Ctrl + C 常用来中断进程，本质是一种键盘组合键，操作系统识别到 Ctrl + C 组合键以后，会将 Ctrl + C 解释成2号信号

signal函数介绍

#include <signal.h>
typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);
signum : 信号编号
handler : 函数指针，指向的函数参数为信号编号，函数内部重新定义了对信号的处理方法

test.c 内容

#include<stdio.h>
#include<unistd.h>
#include<signal.h>
void handler(int signum)
{
        printf("got a signal : %d\n",signum);
}
int main()
{
        signal(2,handler);
        while(1)
        {
                printf("hello world\n");
                sleep(1);
        }
}

在这段代码里我们对进程收到2号信号的处理方式做了自定义处理，进程收到2号信号时，不再中断进程，而是打印出一句话 : got a signal : 信号编号

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

// 把进程放到后台去运行
./test &

我们在使用 Ctrl + C 的时候，进程不会在打印出上面的那句话，因为进程不会收到 Ctrl + C 的信号，而使用 kill -2(SIGINT) pid ，就会打印出上面的那句话

Linux中只允许有一个前台进程，bash是默认的前台进程，当我们的 test 进程成为前台进程后，我们输入ls pwd 等命令时不会再起作用，而 test 进程成为后台进程后，输入ls pwd 等命令时照常

信号是什么?
信号本质是操作系统通知某个进程某种事件发生了的一种机制，这种机制也属于通信的范畴，不过这种方式不是传递数据，而是传递事件

为什么要有信号?
为了能让进程处理突发的状况
在进程正常运行期间，可能需要处理正常执行流之外的事件，可能会有很多突发的事件，所以需要用信号来通知进程某种突发事件已经产生了

二. 产生信号

(1). 通过键盘按键产生信号

常见的键盘按键 :
Ctrl + C ： 2号信号
Ctrl + \ : 3号信号
Ctrl + Z : 20号信号

查看信号的相关信息

man 7 signal

signal函数介绍

#include <signal.h>
typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);
signum : 信号编号
handler : 函数指针，指向的函数参数为信号编号，函数内部重新定义了对信号的处理方法

写代码来验证键盘组合键的各种信号

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<signal.h>
void handler(int signum)
{
        printf("got a signal : %d\n",signum);
        signal(signum,handler);
}
int main()
{
        for(int signum = 1;signum < 32;signum++)
        {
                signal(signum,handler);
        }
        while(1)
        {
                sleep(1);
        }
}

注意 : 9号信号不能被自定义处理，否则如果像我们这样把所有普通信号都自定义处理的话，就不能杀掉进程了，从运行结果也可以看出，向进程发送9号信号，进程就被杀掉了，没有执行自定义的处理方式（19号信号(SIGSTOP)也不能被自定义处理）

(2). 硬件异常产生信号

这里先介绍一下核心转储 (Core dump):

核心转储 : 代码运行完，出错的原因可以通过退出码来判断，代码正在运行时出错了(此时进程退出码无意义了)，我们也需要知道是什么原因导致出错了，通常我们会采用调试的方法， 但我们还有另外一种方法即核心转储，核心转储会把进程在内存中的核心数据转储到磁盘上，存储在磁盘上的文件(核心转储文件)命名core.pid，目的是为了调试，定位问题

默认核心转储是关闭的，我们可以使用 ulimit -c 打开核心转储

ulimit -c 1024

没有打开核心转储之前，向进程发送3号信号，会出现^\Quit，打开核心转储后，我们再向进程发送3号信号，会出现 ^\Quit (core dumped)，ls 会发现当前目录下会出现 core.发生核心转储的进程pid 文件

注意 :

一个进程在终止的时候，有多种终止的方式(Term退出时不做任何核心转储,Core会做核心转储)，不是所有的进程退出都有 core dumped ，必须是触发了某种类别的错误导致的 core dumped

使用核心转储进行调试的例子

Makefile

test:test.c
        gcc -o $@ $^ -g // 带上-g,为了后面能用gdb调试
.PHONY:clean
clean:
        rm -f test

test.c

#include<stdio.h>
#include<unistd.h>
#include<signal.h>
int main()
{
        while(1)
        {
                printf("hello world\n");
                sleep(5);
                int a = 1 / 0;
        }
        return 0;
}

运行 test 之后，会爆 Floating point exception 的错误(8号信号SIGFPE)，同时在当前目录下出现核心转储文件，然后我们打开gdb开始调试，输入 core-file 转储文件名 ，就可以知道进程在哪里出错了

test.c

#include<stdio.h>
#include<unistd.h>
#include<signal.h>
int main()
{
        while(1)
        {
                printf("hello world\n");
                sleep(5);
                int* p = NULL;
                *p = 100;
        }
        return 0;
}

运行 test 之后，会爆 Segmentation fault 的错误(11号信号SIGSEGV)，同时在当前目录下出现核心转储文件，然后我们打开gdb开始调试，输入 core-file 转储文件名 ，就可以知道进程在哪里出错了

注意 :

(1). 为什么以上进程会崩溃? 是因为进程收到了信号
(2). 为什么会收到信号?
首先明确一点，信号都是由OS发送的
(1). CPU内部有一组状态寄存器，描述的是特定计算的计算状态，当除0时，OS发现状态标志位发生了变化，所以OS识别到硬件错误，将硬件错误解释为信号发送给目标进程(即修改task_struct的信号位图)
(2). 当出现野指针或越界时，MMU硬件单元状态信息被OS识别，发送信号给对应的进程

这些错误一定会在硬件层面上有所表现，进而被OS识别到，将相应的信号发送给对应的进程，所以进程会崩溃

(3). 在之前进程等待时，我们讲过 status 中保存了子进程退出的信息，低7位是进程收到的信号，第8位表示进程是否进行核心转储(1代表开启核心转储，0代表未开启核心转储)，次低8位是进程的退出码

test.c内容

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
      if(fork() == 0)
       {
               printf("hello world\n");
               sleep(3);
               //exit(0);
               //int a = 1 / 0;
               //int* p = NULL;
               //*p = 100;
       }
       int status = 0;
       waitpid(-1,&status,0);
       printf("exit code : %d,code dump : %d,signal : %d\n",
               (status>>8)& 0xff,(status>>7)&1,status&0x7f);
}                                  

(3).通过系统函数发送信号

kill系统调用介绍

#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);
功能 : 向特定进程发送指定信号
pid : 进程的pid
sig : 信号编号
返回值 : 成功返回0，失败返回-1

Makefile

.PHONY:all
all:myproc mykill

myproc:test.c
        gcc -o $@ $^ -g -std=c99

mykill:mykill.c
        gcc -o $@ $^ -g -std=c99
.PHONY:clean
clean:
        rm -f myproc mykill

test.c

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
int main()
{
        while(1)
        {
                printf("I am a process : %d\n",getpid());
                sleep(1);
        }
        return 0;
}

mykill.c

#include<stdio.h>
#include<sys/types.h>
#include<signal.h>
#include<stdlib.h>
void Usage(const char* msg)
{
        printf("Usage %s pid signum\n",msg);
}
int main(int argc,char* argv[])
{
        if(argc != 3)
        {
                Usage(argv[0]);
                return 1;
        }
		
        int pid = atoi(argv[1]);
        int signum = atoi(argv[2]);

        kill(pid,signum);
        return 0;
}

kill命令实际上就是调用kill函数实现的，只不过kill命令是系统命令，不需要加 ./

raise函数

#include <signal.h>

int raise(int sig);
功能 : 给自己发送指定信号
返回值 : 成功返回0，失败返回-1

test.c

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
void handler(int signum)
{
        printf("got a signum : %d\n",signum);
        signal(2,handler);
}
int main()
{
        signal(2,handler);
        while(1)
        {
                printf("I am a process : %d\n",getpid());
                sleep(1);
                raise(2);
        }
        return 0;
}

abort函数

#include <stdlib.h>
void abort(void);
功能 : 向自己发送6号信号(SIGABRT)，使当前进程接收到信号而异常终止
就像exit函数一样,abort函数总是会成功的,所以没有返回值。

test.c 内容

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
void handler(int signum)
{
        printf("got a signum : %d\n",signum);
        signal(6,handler);
}
int main()
{
        signal(6,handler);
        while(1)
        {
                printf("I am a process : %d\n",getpid());
                sleep(1);
                abort();
        }
        return 0;
}

(4). 由软件条件产生信号

SIGPIPE是一种由软件条件产生的信号,在“管道”中已经介绍过了(读端关闭，写端会收到SIGPIPE信号)，这里再介绍下alarm函数和SIGALARM信号(14号信号)

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

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
int main()
{
		// 1秒后发送14号信号(SIGALARM)使进程终止
        alarm(1);
        int count = 0;
        while(1)
        {
                printf("count : %d\n",count++);
        }
        return 0;
}

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
int count = 0;
void handler(int signum)
{
        printf("count : %d\n",count);
        exit(0);
}
int main()
{
		// 1秒后发送14号信号(SIGALARM)使进程终止
        alarm(1);
        signal(SIGALRM,handler);
        while(1)
        {
                count++;
        }
        return 0;
}

从上面两段代码的运行结果可以看出系统I/O所需时间较长

三.阻塞信号

(1). 阻塞/递达/未决概念 :

(1). 实际执行信号的处理动作称为信号递达(Delivery)
(2). 信号从产生到递达之间的状态,称为信号未决(Pending)。
(3). 进程可以选择阻塞 (Block )某个信号，被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
(4). 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。

(2). 信号在内核中的表示

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

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

(3). SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。 如果在进程解除对某信号的阻塞之前这种信号产生过多次，Linux是这样实现的:常规信号在递达之前产生多次只计一次。

信号发送处理的大体流程
操作系统发送信号，首先修改进程的 pending 位图，等待合适的时机递达，在递达之前会先检查 block 位图，检查信号是否被阻塞，若没有被阻塞，开始递达，否则不可以直接递达，直到信号被解除阻塞

(3). sigset_t

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

(4). 信号集操作函数

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

#include <signal.h>
// 函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零
// 表示该信号集不包含任何有效信号
int sigemptyset(sigset_t *set);
// 函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置1
// 表示该信号集的有效信号包括系统支持的所有信号。
int sigfillset(sigset_t *set);
// 向set所指向的信号集中添加信号
int sigaddset (sigset_t *set, int signo);
// 在set所指向的信号集中删除信号
int sigdelset(sigset_t *set, int signo);
// 判断信号是否在set所指向的信号集中
int sigismember（const sigset_t *set, int signo);
前4个函数成功返回0，失败返回-1，sigismember信号在信号集中返回1，不在返回0

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 
功能 : 读取或更改进程的信号屏蔽字(阻塞信号集)

how : 指示如何更改信号屏蔽字
SIG_BLOCK : set中包含了我们希望添加到当前信号屏蔽字的信号，相当于mask = mask|set
SIG_UNBLOCK : set中包含了我们希望从当前信号屏蔽字中解除屏蔽的信号，相当于mask = mask&~set
SIG_SETMASK : 设置当前信号屏蔽字为set所指向的值，相当于 mask = set

set : 如果set是非空指针,则更改进程的信号屏蔽字
oset : 如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出
如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字

返回值:若成功则为0,若出错则为-1

#include <signal.h>

int sigpending(sigset_t *set);
功能 : 读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。

下面来写代码来熟悉一下这些函数的使用
(1). 先将2号信号屏蔽
(2). 使用 kill 命令发送2号信号，可见2号信号不会被递达
(3). 使用 sigpending 获取当前进程的 pending 信号集
(4). 最终看到的现象就是信号集由全0到发送信号后第二位变1

#include<stdio.h>
#include<signal.h>
void printPending(sigset_t* pending)
{
        int i = 1;
        for(;i <= 31;i++)
        {
                if(sigismember(pending,i))
                {
                        printf("1 ");
                }
                else
                {
                        printf("0 ");
                }
        }
        printf("\n");
}
int main()
{
        sigset_t set,oset;

        sigemptyset(&set);
        sigemptyset(&oset);

        sigaddset(&set,2);

        sigprocmask(SIG_BLOCK,&set,&oset);
		
		sigset_t pending;
        while(1)
        {
                sigemptyset(&pending);
                sigpending(&pending);
                printPending(&pending);
                sleep(1);
        }
}

(1). 自定义2号信号处理方式
(2). 将2号信号添加到阻塞信号集，向进程发送2号信号，不会被递达
(3). 10秒之后，通过oset取消2号信号的阻塞，2号信号被递达

#include<stdio.h>
#include<signal.h>
void printPending(sigset_t* pending)
{
        int i = 1;
        for(;i <= 31;i++)
        {
                if(sigismember(pending,i))
                {
                        printf("1 ");
                }
                else
                {
                        printf("0 ");
                }
        }
        printf("\n");
}
void handler(int signum)
{
	printf("got a sign : %d\n",signum);
}
int main()
{
		signal(2,handler);
        sigset_t set,oset;

        sigemptyset(&set);
        sigemptyset(&oset);

        sigaddset(&set,2);

        sigprocmask(SIG_BLOCK,&set,&oset);
		
		sigset_t pending;
		int count = 0;
        while(1)
        {
                sigemptyset(&pending);
                sigpending(&pending);
                printPending(&pending);
                sleep(1);
                count++;
                if(count == 10)
                {
                	sigprocmask(SIG_SETMASK,&oset,NULL);
                }
        }
}

(5). 处理信号

上文说过处理信号是在合适的时候，而合适的时候其实是在由内核态->用户态的时候

在进程概念中，我们讲了进程地址空间的概念，其中0~3G为用户空间，3 ~ 4G为内核空间，在用户空间，通过用户级页表映射到不同的物理内存，使进程看到的代码和数据是完全不同的，在内核空间，通过内核页表映射到相同的物理内存(使进程看到相同的操作系统代码和数据)

(内核级页表维护的是操作系统的代码和数据和进程之间的关系(内核空间和物理内存的映射))

在内存中，有着操作系统的代码和数据，进程切换的时候，一定是由操作系统帮其切换的，那怎么做到让一个进程正在运行时去执行操作系统的代码，把该进程从CPU上剥离下来，放上其他的进程运行?

进程无论如何切换，都能看到操作系统，但并不一定都能访问，进程在切换的时候(该进程的时间片到了)，我们需要通过该进程找到操作系统的代码和数据，完成进程切换，要想找到操作系统，需要从用户态切换到内核态，通过内核页表找到操作系统的代码和数据，从而完成进程切换

内核态 : 通常用来执行OS代码，是一种权限非常高的状态
用户态 : 通常用来执行普通用户代码的状态，是一种受到监管的普通状态

用户态切换到内核态的几种情况
(1). 系统调用
(2). 时间片到了导致进程切换
(3). 某些异常，中断，陷阱导致陷入内核

内核态返回到用户态的几种情况
(1). 系统调用返回
(2). 进程切换完毕
(3). 异常，中断，陷阱处理完毕

像C语言中使用的 fopen，fclose，fread，fwrite，printf 等这些I/O类接口，底层都使用了系统调用接口，把数据通过操作系统写到硬件上，或者从硬件上获取数据，虽然我们平常写的代码看似并没有进入内核，但其实会经常进入内核的

信号处理过程
(1). 在用户态执行主控制流程的某条指令时因为中断，异常或系统调用进入内核态
(2). 内核在处理完中断，异常，系统调用等后，再返回用户态前会对信号进行处理
(3). 检查 panding 位图，如果 block 位图被阻塞，则信号不会被递达，返回用户态主控制流程中
如果 block 位图没有被阻塞，检查 handler 数组，如果处理信号的行为是默认行为(一般为中断/暂停，中断直接在内核态删除掉该进程即可，暂停将进程的R状态改为T状态，将其放在某种队列里)，处理完信号，修改pending位图，返回用户态主控制流程中，如果是忽略行为，修改pending位图，返回用户态主控制流程中
(4). 如果处理行为是自定义行为，会先从内核态切换到用户态去执行自定义的函数，执行完自定义函数执行特殊的系统调用 sigreturn 再次进入内核，再通过 sys_sigreturn()系统调用返回用户态主控制流程中

注意 : 为什么处理自定义行为时，要先从内核态切换到用户态去执行呢？直接在内核态访问执行用户态的函数不可以吗?
理论上是可以的，因为内核态的权限更高(拥有系统的最高权限)，但是绝对不能这样设计! 如果用户态的函数里设计了一些非法操作，越权操作，以内核态去执行这些操作时是毫无约束的，OS是不信任任何用户的

当一个进程收到信号时，并不是立即处理信号的原因是进程正在做某些优先级更高的事情，这件优先级更高的事情有可能是用户所对应的一段代码，执行用户代码时，无法进入内核，所以信号也就没办法立即处理了，当把这件事情处理完之后，在合适的时候(系统调用，中断，异常)进入内核，返回用户态前处理信号

sigaction

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);
struct sigaction
{
    void     (*sa_handler)(int);
    void     (*sa_sigaction)(int, siginfo_t*, void*);
    sigset_t   sa_mask;
    int        sa_flags;
    void     (*sa_restorer)(void);
};
功能 : 自定义信号处理方式
sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1。signo
是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非空,则通过oact传
出该信号原来的处理动作。act和oact指向sigaction结构体

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

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

利用 sigaction 自定义处理信号

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<string.h>
void handler(int signum)
{
        printf("got a sign : %d\n",signum);
}
int main()
{
        struct sigaction act,oact;
        memset(&act,0,sizeof act);
        memset(&oact,0,sizeof oact);

        act.sa_handler = handler;
        act.sa_flags = 0;
        sigemptyset(&act.sa_mask);

        sigaction(2,&act,&oact);
        while(1)
        {
                printf("I am a process\n");
                sleep(1);
        }
}

自定义2号信号处理方式，再通过oact恢复2号信号处理方式

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<string.h>
struct sigaction act,oact;
void handler(int signum)
{
        printf("got a sign : %d\n",signum);
        sigaction(2,&oact,NULL);
}
int main()
{
        memset(&act,0,sizeof act);
        memset(&oact,0,sizeof oact);

        act.sa_handler = handler;
        act.sa_flags = 0;
        sigemptyset(&act.sa_mask);

        sigaction(2,&act,&oact);
        while(1)
        {
                printf("I am a process\n");
                sleep(1);
        }
}

四. 可重入函数/不可重入函数

可重入的概念 : 若一个程序或子程序可以“在任意时刻被中断，然后操作系统调度执行另外一段代码，这段代码又调用了该子程序不会出错”，则称其为可重入（reentrant或re-entrant）的，否则称其为非可重入的

main程序中调用了insert函数(功能是头插节点)，在执行 p->next = head 的时候发生中断，进入内核，处理完之后返回用户态之前检查到有信号需要处理，且信号的处理方式为自定义处理方式，于是由内核态切换到用户态去执行自定义处理函数sighandler，sighandler中也调用了insert函数，调用完成后头插了node2节点，返回内核态，再由内核态返回到main函数中，执行 head = p，但这样会导致 node2 节点丢失，造成内存泄露，因此insert函数是不可重入函数

如果一个函数符合以下条件之一则是不可重入的:
(1). 调用了malloc或free,因为malloc也是用全局链表来管理堆的。
(2). 调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构

五. volatile

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<string.h>
int flag = 0;
void handler(int signum)
{
        printf("got a signum : %d\n",signum);
        flag = 1;
}
int main()
{
        signal(2,handler);
        while(!flag);
        printf("proc normal quit!\n");
        return 0;
}

该命令可以将flag优化成寄存器变量
gcc -o myproc test.c -O3

编译器在编译时只能检测到main函数中flag的使用，编译器只能识别到main函数中并没有修改flag，编译器就有可能将flag优化成寄存器变量，这样main函数在执行的时候只会检测寄存器中的flag，当进行信号处理后，将内存中的flag由0置1，但是寄存器中的值仍然为0，程序有可能陷入死循环

这也说明了信号捕捉和main函数是两个执行流，信号捕捉中将flag由0置1，main函数中看不到

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<string.h>
volatile int flag = 0;
void handler(int signum)
{
        printf("got a signum : %d\n",signum);
        flag = 1;
}
int main()
{
        signal(2,handler);
        while(!flag);
        printf("proc normal quit!\n");
        return 0;
}

加上 volatile 关键字后就可正常退出，原因是被 volatile 修饰的变量在开辟空间的时候/编译器编译时，不能被优化到寄存器中，对该变量的任何操作，都必须在真实的内存中进行操作，保证了内存的可见性

六. SIGCHLD信号

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

验证子进程退出时会给父进程发送SIGCHLD信号(17号信号)

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<string.h>
void handler(int signum)
{
        printf("got a %d signo\n",signum);
        int ret = 0;
        // 使用while是因为有可能有多个子进程退出等待父进程处理，不使用阻塞式等待是因为有可能
        // 存在没有退出的子进程导致死循环
        while((ret = waitpid(-1,NULL,WNOHANG)) > 0)
        {
                printf("wait child success : %d\n",ret);
        }
}
int main()
{
        signal(17,handler);
        if(fork() == 0)
        {
                printf("I am a child : %d\n",getpid());
                sleep(3);
                exit(0);
        }
        while(1);
}

while :; do ps axj | head -1 && ps axj | grep myproc | grep -v grep;echo"###############################";sleep 1;done;

grep -ER 'SIG_IGN|SIG_DFL' /usr/include

七. 守护进程

test.c 内容

#include<stdio.h>
int main()
{
	while(1);
	return 0;
}

前台进程

./test

后台进程

./test &

查看后台进程

jobs

将后台作业放到前台

fg 作业号

将前台进程放到后台

Ctrl + z
bg 作业号

守护进程是脱离于终端并且在后台运行的进程，脱离终端是为了避免在执行的过程中的信息在终端上显示，并且进程也不会被任何终端所产生的终端信息所打断。

进程组 ：
1.每个进程属于一个进程组
2.每个进程组都有一个进程组号，该号等于该进程组组长的PID号
3.一个进程只能为它自己或子进程设置进程组ID号

会话(session)：会话是一个或多个进程组的集合
setsid()函数可以建立一个会话，如果，调用setsid的进程不是一个进程组的组长，此函数创建一个新的会话
(1). 此进程变成该会话的首进程
(2)此进程变成一个新进程组的组长进程。
(3)此进程没有控制终端，如果在调用setsid前，该进程有控制终端，那么与该终端的联系被解除。 如果该进程是一个进程组的组长，此函数返回错误。
(4)为了保证这一点，我们先调用fork()然后exit()，此时只有子进程在运行.
(5). 那么为什么要调用setsid函数呢？主要是因为前面创建子进程的时候，虽然父进程退出了，但是子进程拷贝了父进程的会话、进程组、控制终端等等，所以需要使用setsid来摆脱控制。

ps -o pid,ppid,pgrp,session,tpgid,comm（只能查看在当前会话启动的任务）
功能 : 查看进程的属性信息
session : 会话
pgrp : 进程组id

test.c 内容

#include<stdio.h>
#include<unistd.h>
int main()
{
        fork();
        while(1);
        return 0;
}

会话首进程能够帮助我们打开终端设备，通过终端设备让我们进行输入输出(例如bash进程)，我们可以通过如下命令查看与会话进程相关联的终端设备

ps axj | head -n1 && ps axj | grep bash
PPID    PID   PGID    SID TTY(终端设备)       TPGID STAT   UID   TIME COMMAND
2156   2163   2163   2163 pts/0      5608 Ss    1000   0:00 bash
ls -al /dev/pts/0

两个进程在不同的终端下属于各自bash所对应的会话，每一次使用xshell登录，本质都是先创建一个bash进程，整体称之为一个会话，所有的命令行启动的任务都是在对应的会话内运行的

守护进程本质上也是一种孤儿进程，因为调用setsid函数不能是进程组的组长，所以需要fork出子进程，使父进程退出，调用setsid后，子进程就成为了新的会话首进程，而会话首进程具有打开终端的权限，但守护进程不需要再和终端打交道了，所以我们需要再fork出孙子进程，使子进程退出，这样孙子进程就不是会话首进程了

#include <unistd.h>

int chdir(const char *path);
功能 : 改变当前路径
通过查看 ls /proc/pid -al 里面的cwd(当前路径) 的变化可知

但我们发现守护进程的文件描述符指向了 /dev/pts/0，而 /dev/pts/0 就是当前终端，而守护进程是独立于终端的，所以还需要重定向到 /dev/null

/dev/null 是一个字符文件/设备，所有的数据向/dev/null文件里写入相当于直接丢弃，从/dev/null文件里读取是没有意义的，所以/dev/null通常用来屏蔽或丢弃输入输出信息

根据进程名称杀掉所有进程
killall 进程名

#include <unistd.h>

int daemon(int nochdir, int noclose);
功能 : 创建一个守护进程
nochdir : nochdir为0，会更改当前路径为"/"
noclose : noclose为0，会重定向标准输入，标准输出，标准错误到/dev/null
返回值 : 成功返回0，失败返回-1

模拟守护进程

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
void mydaemon(int nochdir,int noclose)
{
        umask(0);
        if(fork() > 0)
        {
                exit(0);
        }
        signal(SIGCHLD,SIG_IGN);
        setsid();

        if(fork() > 0)
        {
                exit(0);
        }

        if(nochdir == 0)
        {
                chdir("/");
        }

        if(noclose == 0)
        {
                close(0);
                int fd = open("/dev/null",O_RDWR);
                dup2(fd,1);
                dup2(fd,2);
  		}
}
int main()
{
        mydaemon(0,0);
        while(1)
        {
				周而复始的做周期性任务
        }
}