当前位置:首页 » 《随便一记》 » 正文

Linux进程信号_DR5200的博客

5 人参与  2022年05月28日 10:52  分类 : 《随便一记》  评论

点击全文阅读


文章目录

  • 一.信号入门
  • 二. 产生信号
    • (1). 通过键盘按键产生信号
    • (2). 硬件异常产生信号
    • (3).通过系统函数发送信号
    • (4). 由软件条件产生信号
  • 三.阻塞信号
    • (1). 阻塞/递达/未决概念 :
    • (2). 信号在内核中的表示
    • (3). sigset_t
    • (4). 信号集操作函数
    • (5). 处理信号
  • 四. 可重入函数/不可重入函数
  • 五. volatile
  • 六. SIGCHLD信号
  • 七. 守护进程

一.信号入门

信号相关的理论基础 :
(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)
        {
				周而复始的做周期性任务
        }
}

点击全文阅读


本文链接:http://m.zhangshiyu.com/post/40912.html

信号  进程  函数  
<< 上一篇 下一篇 >>

  • 评论(0)
  • 赞助本站

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

关于我们 | 我要投稿 | 免责申明

Copyright © 2020-2022 ZhangShiYu.com Rights Reserved.豫ICP备2022013469号-1