Linux--进程信号

如何理解闹钟是由软件条件产生信号？

        --"闹钟"其实就是用软件实现的

任意一个进程都可以通过alarm系统调用在内核中设置闹钟，操作系统中可能会存在很多闹钟，此时，操作系统就需要管理这些闹钟。管理闹钟就是需要先描述，再组织。

总结

上面所说的所有信号产生，最终都要有OS来进行执行，为什么？

        OS是进程的管理者 ，只有OS有权力向目标进程写入信号

信号的处理是否是立即处理的？

        不是，在合适的时候

信号如果不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？

        是需要被保存下来的，被记录在PCB中

一个进程在没有收到信号的时候，能否能知道，自己应该对合法信号作何处理呢？

        能知道，当未收到信号时，对信号如何做处理已经被默认程序员写入在代码中的

如何理解OS向进程发送信号？能否描述一下完整的发送处理过程？

        操作系统发送信号，本质是在进程（结构体）的位图（signal）进行修改，将对应位图的信号编号进行置1处理，置1表示操作系统向进程发送信号，如果是0表示未发送信号。

核心转储

关于产生信号的退出问题，大部分信号的执行结构都是终止，但是有两种终止方式：Term，Core。那么他们有什么区别呢？

为了便于操作和理解，这里我们采用11号信号进行测试和观察，观察Core是如终止进程的。代码就是简单数组越界问题。

    while (true)    {        int a[10];        a[10000] = 106;    }

[hongxin@VM-8-2-centos 2023-4-4]$ ./mysignal 
Segmentation fault

结果只出现一个错误描述，感觉上与Term正常结束是几乎一样的，因为我们没有看见其他现象，但事实就是如此吗？

        首先我这里是使用的云服务器，在云服务器上，默认如果进程是core退出，暂时看不到明显的现象，如果想看到可以输入：ulimit -a 进行观察

通过观察发现，core file size设置为 0,则代表了云服务器默认关闭了core file选项。如果我们想打开此选项：ulimit -c 1024；我们再输入ulimit -a查看：

core file size          (blocks, -c) 1024

当我们打开云服务器的core file选项后，再运行当前代码。我们发现不仅多了core dumped，而且还多生成了一个core文件。

[hongxin@VM-8-2-centos 2023-4-4]$ ./mysignal 
Segmentation fault (core dumped)

[hongxin@VM-8-2-centos 2023-4-4]$ ll
total 304
-rw------- 1 hongxin hongxin 557056 Apr  5 10:36 core.598
-rw-rw-r-- 1 hongxin hongxin    167 Apr  4 00:29 makefile
-rwxrwxr-x 1 hongxin hongxin  47864 Apr  5 10:20 mysignal
-rw-rw-r-- 1 hongxin hongxin   2734 Apr  5 10:19 mysignal.cc
-rwxrwxr-x 1 hongxin hongxin   9176 Apr  5 10:20 mytest
-rw-rw-r-- 1 hongxin hongxin    259 Apr  4 00:00 mytest.cc

core dumped--核心转储 ；core.598->这个598--引起core问题进程的pid；core.589一般是以core+引起core问题进程pid命名文件，该文件存在磁盘中。

为什么需要有核心转储呢？

        目的是为了支持调试，如何支持呢？直接在gdb的上下文中core-file core.xxx

作为对面，还是用上述代码，不报段错误，直接死循环用kill -2 pid终止进程(Term)。然后观察终止后会不会产生core文件，发生核心转储。

 SIGINT        2       Term    Interrupt from keyboard

结论：

        以core退出的可以被核心转储，Term退出是没有被核心转储即为正常退出。核心转储其目的是为了更便于调试。 

最后关系信号产生，最后一个问题：

        如果将全部信号捕捉，然后自定义处理后，是不是该进程一直被执行，就不能被终止。

为了探究这个问题，下面进行代码测试，实验见证真理。

然后我们发现即使其他进程都被自定义处理后，但是kill -9 还是能将进程终止的。9号信号是管理员信号，在操作系统内是静止对9号信号做捕捉的。

信号的保存--阻塞信号

信号其他相关常见概念

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

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

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

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

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

对于抵达，未决，阻塞这三个名词是非常有必要了解其意思。相信大家很好理解抵达和未决。对于阻塞是不易理解的。

        例：整个这个信号的过程，我们可以用生活中的例子理解，上课时老师发出信号，说：大家把书上例题1，7，13勾画上，有时间去把做了。这个时候由于老师需要继续上课，我们有更要的事情需要处理，就在书上记录（勾画）上题，但是一直没有做。这段时间老师发出的信号就叫做未决。

当回家后我们觉得这个老师讲的知识点很难，我们不想做，该信号阻塞（记录但不做）。但是过一段时间你认为老师很严格，不做后果很严重，就选择把例题做了，该信号抵达。

还有一种情况，老师上课说：把这个例题算出来（信号的产生），大家不需要记录，直接就做。在这个过程不需要保存信号，发出信号直接执行（抵达）。

注意，阻塞和未决是不一样的，阻塞是需要保存这个信号，未决是在发出信号，不管你保不保存信号都是未决状态。

注意，阻塞和忽略也是不同。比如当老师布置了例题（发出信号），我们认为做不做都不影响时，我们直接不记录这些例题（忽略）。在未保存信号下，我们执行的策略是（忽略）。在发出信号到未做这段时间处于未决状态，阻塞是在未决状态之间的。忽略是在未决之后，更是在抵达（如何执行老师的信号）之后。所以说忽略是在递达之后可选的一种处理动作。

在内核中的表示     

信号在内核中的表示示意图

        ●每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针(handler)表示处理动作。

        ●在代码运行过程中，在用户层调用signal函数，对信号进行捕捉，若有信号被捕捉到，操作系统向进程发送信号，进程中pending位图置1，如果操作系统判断该信号可以立即执行，则不需要保存信号，例如  SIGINT 信号--正常处理（Term ）。

        ●如果是SIGQUIT信号需要保存处理--（ Core）,一旦产生SIGQUIT信号将被阻塞,当它的处理动作是用户自定义函数sighandler。此时需要接触对该信号的阻塞，然后用内核态转入到用户态，对用户态的handler进行执行。

        ●如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。

地址空间第二讲

关于上述介绍，我们发现程序员写的代码是在用户态那一层，PCB则是在内核态一层。什么时候需要访问内核态呢？内核资源是通过什么访问的呢？

在这个进程中，有两块空间，其中一块是让用户使用的，另外的一块是让操作系统使用的。

        例：这好比在学校，作为学生我们只能在自己的班级上课，而不能去其他班级。作为校长就可以随便去哪个班级。我们则是用户，校长就好比操作系统。

用户为了访问内核或者硬件资源都必须通过系统调用。但系统调用往往都比较耗时，因为系统调用会进行大量操作，所以我们应该尽量避免频繁的调用系统操作。

这里介绍了进程中有用户态和内核态，也知道了如果用户态如果想访问操作系统本身的资源或者硬件资源时，需要通过系统调用访问，而且系统调用比较耗时。

系统调用是用户用相关系统调用接口实现访问内核资源，这个调用过程是CPU完成的，所以我们还是不理解，操作系统是如何跟进程联系起来的呢？

我们知道在CPU中有大量的寄存器

        1.可见寄存器，如exa，exd等通用寄存器。

        2.不可见寄存器，如状态寄存器，CR3等寄存器。

凡是这些寄存器与当前进程相关，进程就会存储寄存器的上下文数据--(保存了程序运行时寄存器的当中的内容：如一个进程在运行过程中被切换出去，上下文信息就保存了寄存器的信息，直到这个进程重新拥有cpu资源)。

在CPU中的诸多寄存器中，有指定寄存器保存task_struct的起始地址实现直接跳转到进程中，也有指定寄存器保存页表起始地址，还有CR3表示当前进程的运行级别的指定寄存器。上下文数据也有专门的寄存器保存。

知道了他们之间的联系，那么他们又是如何执行的呢？比如我是一个进程，怎么就跑到操作系统中去执行方法呢？

如上图，则是进程是如何调用到系统资源的原理图。

        ●每个进程的数据都被保存到相应的寄存器中，当在用户空间执行程序时，相关上下文的寄存器运行。当系统识别到用户通过系统调用访问内核数据时，在CPU中这个系统调用接口，在起始的位置就会帮你调整进程的运行级别，系统调用接口会通过Int 80-陷入内核（在设计系统接口时就已经编写好的），Int80就会用到CR3寄存器。改变运行级别：将级别0变成1。

        ●而且每个进程都有3-4G的内核空间，都会共享内核级页表，无论进程如何切换都不会改变3-4的内核数据资源。所以在CPU中的指定寄存器中改变运行级别后，直接在mm_struct直接实现跳转获取相关的内核数据。

sigset_t

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

sigset_t实质就是结构体封装的一个数组，在c++中bitset也讲过--位图。

# define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))

typedef struct

  {

    unsigned long int __val[_SIGSET_NWORDS];

  } __sigset_t;

#endif

信号集操作函数 

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

#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清零,表示该信号集不包含 任何有效信号。

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

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

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

sigprocmask 

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

#include

int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

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

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则更改进程的信号屏蔽字,参数how指示如何更改。如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值。 

如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中一个信号递达。

sigpending

#include

int sigpending(sigset_t *set);

读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。

 面用刚学的几个函数做个实验。程序如下:

#include #include #include #include //#define BLOCK_SIGNAL 2#define MAX_SIGNUM 31static std::vector sigarr = {2};static void show_pending(const sigset_t &pending){    for(size_t signal=MAX_SIGNUM; signal > 0; --signal)    {        if(sigismember(&pending,signal))        {            std::cout<< "1";        }        else        {            std::cout<< "0";        }       }    std::cout<

#include #include #include using namespace std;void Count(int cnt){    while (cnt--)    {        cout<< cnt<<" ";        fflush(stdout);        sleep(1);    }    cout<

#include #include int quit =0;void handler(int signo){    printf("%d 信号已经被捕捉!\n",signal);    printf("quit -> %d\n",quit);     quit=1;    printf("-> %d\n",quit);}int main(){    signal(2,handler);    while(!quit);    printf("注意，我是正常退出！\n");    return 0;}

#include #include #include #include int quit = 0;void handler(int signo){    printf("pid : %d,%d信号,正在被捕捉\n",getpid(),getppid());}void Count(int cnt){    while (cnt)    {        printf("cnt: %2d\r", cnt);        fflush(stdout);        cnt--;        sleep(1);    }    printf("\n");}int main(){    // 显示的设置对SIGCHLD进行忽略    signal(SIGCHLD, handler);    //signal(SIGCHLD, SIG_DFL);    printf("我是父进程, %d, ppid: %d\n", getpid(), getppid());    pid_t id = fork();    if (id == 0)    {        printf("我是子进程, %d, ppid: %d，我要退出啦\n", getpid(), getppid());        Count(5);        exit(1);    }    while (1)        sleep(1);    return 0;}

void handler(int signo){    //1.有很多子进程，在同一个时刻退出        //--在同一时刻退出也必须依次退出，必须while退完    //2.有很多子进程，在同一时刻只有一步部分退出        //--尽管只有一部分退出，对于系统而言，它是不知道到底有多少个进程需要退出，那么只有退完之后才知道        //--在waitpid中默认的是阻塞是等待，如果没有退出完，就会发生僵尸        //--所以我们将等待改成非阻塞，    while (1)    {        //如果指定了WNOHANG，并且存在一个或多个由pid指定的子（ren），但尚未更改状态，则返回0。出现错误时，返回-1。        pid_t ret = waitpid(-1,NULL,WNOHANG);        if (ret == 0)        {            //ret==0 则就是 waitpid调用成功 && 子进程没退出            //子进程没有退出，我的waitpid没有等待失败，仅仅是监测到了子进程没退出.那么继续等待退出即可            break;        }        else if(ret > 0)        {            //waitpid调用成功 && 子进程退出成功            printf("wait child success %d\n ",ret);        }        printf("child is quit! %d\n",getpid());            }        printf("pid : %d,%d信号,正在被捕捉\n",getpid(),getppid());}