信号处理：信号产生

基本结论：

1.你怎么能识别信号呢？识别信号是内置的，进程识别信号，是内核程序员写的内置特性。 2.信号产生之后，你知道怎么处理吗？知道。如果信号没有产生，你知道怎么处理信号吗？知道。所以，信号的处理方法，在信号产生之前，已经准备好了。

3.处理信号，立即处理吗？我可能正在做优先级更高的事情，不会立即处理？什么时候？合适的时候。

3.信号到来|信号保存 |信号处理

怎么进行信号处理啊？a.默认 b.忽略 c.自定义，后续都叫做信号捕捉。

1.2技术应用角度的信号

1.2.1一个样例：

复制代码

#include <iostream>
#include<unistd.h>

int main()
{
    while(true)
    {
        std::cout << "I am a process, I am waiting signal"<<std::endl;
        sleep(1);
    }

    return 0;
}

用户输入命令,在Shell下启动⼀个前台进程

用户按下 Ctrl+C ,这个键盘输入产生⼀个硬件中断，被OS获取，解释成信号，发送给目标前台进程

前台进程因为收到信号，进而引起进程退出

1.2.2一个系统调用

复制代码

NAME
 signal - ANSI C signal handling


 #include <signal.h>
 typedef void (*sighandler_t)(int);
 sighandler_t signal(int signum, sighandler_t handler);
 
参数说明：
signum：信号编号，后⾯解释，只需要知道是数字即可
handler：函数指针，表⽰更改信号的处理动作，当收到对应的信号，就回调执⾏handler⽅法

而其实， Ctrl+C 的本质是向前台进程发送 SIGINT 即 2 号信号，我们证明⼀下，这里需要引入一个系统调用函数

cpp 复制代码

#include <iostream>
#include<unistd.h>
#include<signal.h>

void Handler(int signo)
{
    std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl; 
}

int main()
{
    std::cout << "我是进程："<<getpid()<<std::endl;
    
    //signal只需要设置一次就够了，之后的进程都会执行这个信号，不需要放在循环
    signal(SIGINT,Handler);//默认执行自定义的Handler

    while(true)
    {
        std::cout << "I am a process, I am waiting siganl " << std::endl;
        sleep(1);
    }
    return 0;
}

此时我们会看到，当我们按下Ctrl+c之后，进程捕捉到2号信号，但是为什么这一会按下Ctrl+c之后进程没有退出呢？这篇文章后面会说明原因

要注意的是，signal函数仅仅是设置了特定信号的捕捉行为处理方式，并不是直接调用处理动作。如果后续特定信号没有产生，设置的捕捉函数永远也不会被调用！！

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

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

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

1.3信号的概念

信号是进程之间事件异步通知的一种方式，属于软中断

1.3.1查看信号

9 号信号（SIGKILL）：强制终止进程
19 号信号（SIGSTOP）：暂停进程
发送这两个信号时，程序会直接终止或暂停，不会执行Handler 函数，无法捕捉信号

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

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

1.3.2 信号处理

可选的处理动作有以下三种：

忽略此信号：SIG_IGN

cpp 复制代码

#include <iostream>
#include<unistd.h>
#include<signal.h>

void Handler(int signo)
{
    std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl; 
}

int main()
{
    std::cout << "我是进程："<<getpid()<<std::endl;

    signal(SIGINT,SIG_IGN);//设置忽略信号的宏

    while(true)
    {
        std::cout << "I am a process, I am waiting siganl " << std::endl;
        sleep(1);
    }
    return 0;
}

执行该信号的默认处理动作：SIG_DFL

cpp 复制代码

#include <iostream>
#include<unistd.h>
#include<signal.h>

void Handler(int signo)
{
    std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl; 
}

int main()
{
    std::cout << "我是进程："<<getpid()<<std::endl;

    signal(SIGINT,SIG_DFL);//设置忽略信号的宏

    while(true)
    {
        std::cout << "I am a process, I am waiting siganl " << std::endl;
        sleep(1);
    }
    return 0;
}

由此也可以看出：输入ctrl+c,进程退出，就是默认动作

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

OS收到中断信号（从硬件中断来）之后，只需要把外设数据拷贝就好了，OS只需要等待不需要轮询外设

以上是对于信号的一个大体的认识，之后对于信号的讲解，按照一下思路阐述：

二：产生信号

当前阶段：

2.1通过终端按键产生信号

2.1.1基本操作

Ctrl+C (SIGINT) 已经验证过，这里不再重复，见上面的1.2

Ctrl+\（SIGQUIT）可以发送终止信号并生成core dump文件，用于事后调试

Ctrl+Z（SIGTSTP）可以发送停止信号，将当前前台进程挂起到后台等。

2.1.2理解OS如何得知键盘有数据

2.1.3初步理解信号起源

信号其实是从纯软件角度，模拟硬件中断的行为

只不过硬件中断是发给CPU，而信号是发给进程

两者有相似性，但是层级不同

2.2调用系统命令向进程发信号

首先在后台执行死循环程序,然后用kill命令给它发SIGSEGV信号。

1291636是 sig 进程的pid。之所以要再次回车才显示Segmentation fault ,是因为在 1291636进程终止掉之前已经回到了Shell提示符等待用户输入下⼀条命令, Shell 不希望 Segmentation fault 信息和用户的输入交错在⼀起,所以等用户输入命令之后才显示。

指定发送某种信号的 kill 命令可以有多种写法,上面的命令还可以写成 kill -11 1291636,11 是信号 SIGSEGV 的编号。以往遇到的段错误都是由非法内存访问产生的,而这个程序本身没错,给它发SIGSEGV也能产生段错误。

2.3使用函数产生信号

2.3.1 kill

kill 命令是调用kill函数实现的。 kill 函数可以给一个指定的进程发送指定的信号。

cpp 复制代码

NAME
 kill - send signal to a process

SYNOPSIS
 #include <sys/types.h>
 #include <signal.h>
 
 int kill(pid_t pid, int sig);
 
RETURN VALUE
 On success (at least one signal was sent), zero is returned. On error,
 -1 is returned, and errno is set appropriately.

实现自己的mykill：

cpp 复制代码

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

// ./signal -9 pid
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        std::cout << "输入错误，请重新输入 "<<std::endl;
        return 1;
    }

    int killnum = std::stoi(argv[1]+1);//去掉-
    int pid  = std::stoi(argv[2]);

    int n = ::kill(pid,killnum);
    if(n  <0)
    {
        std::cout << "kill 失败"<<std::endl;
        return 2;
    }
    
    return 0;
}

2.3.2raise

raise 函数可以给当前进程发送指定的信号(自己给自己发信号)。

bash 复制代码

NAME
 raise - send a signal to the caller
SYNOPSIS
 #include <signal.h>
 int raise(int sig);
 
RETURN VALUE
 raise() returns 0 on success, and nonzero for failure.

cpp 复制代码

void Handler(int signo)
{
    std::cout << "我是进程 : "<<getpid()<<",我获得了一个信号 : "<<signo<<std::endl; 
}


int main()
{
   signal(2,Handler);// 先对2号信号进⾏捕捉 
   
   // 每隔1S，⾃⼰给⾃⼰发送2号信号 
   while(true)
   {
        sleep(1);
        raise(2);
   }

    return 0;
}

2.3.3abort

abort 函数使当前进程接收到信号而异常终止。

cpp 复制代码

AME
 abort - cause abnormal process termination

SYNOPSIS
 #include <stdlib.h>
 void abort(void);

RETURN VALUE
 The abort() function never returns.
 // 就像exit函数⼀样,abort函数总是会成功的,所以没有返回值。

2.4由软件条件产生信号

SIGPIPE 是⼀种由软件条件产生的信号,在"管道"中已经介绍过了。本节主要介绍 alarm 函数和 SIGALRM 信号。

SIGPIPE：匿名管道中，如果读端关闭写端非法写入时，退出信号，13，之前文章中有验证

进程间通信：管道与共享内存-CSDN博客

cpp 复制代码

AME
 alarm - set an alarm clock for delivery of a signal

SYNOPSIS
 #include <unistd.h>
 unsigned int alarm(unsigned int seconds);
 
RETURN VALUE
 alarm() returns the number of seconds remaining until any previously
 scheduled alarm was due to be delivered, or zero if there was no previ‐ 
 ously scheduled alarm.

调用alarm 函数可以设定⼀个闹钟,也就是告诉内核在 seconds 秒之后给当前进程发 SIGALRM 信号，该信号的默认处理动作是终止当前进程。

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。打个比方,某⼈要睡⼀觉,设定闹钟为30分钟之后响,20分钟后被⼈吵醒了,还想多睡⼀会儿,于是重新设定闹钟为15分钟之后响,"以前设定的闹钟时间还余下的时间"就是10分钟。如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数。

cpp 复制代码

void die(int signo)
{
    std::cout <<"get a siganl : "<< signo << std::endl;
}
int main()
{
    alarm(10);

    sleep(4);
    int n = alarm(0);//取消闹钟
    std::cout << "n : "<<n << std::endl;

    signal(SIGALRM,die);

    return 0;
}

2.4.1基本alarm验证-体会IO效率问题

程序的作用是1秒钟之内不停地数数,1秒钟到了就被SIGALRM信号终止。必要的时候，对SIGALRM信号进行捕捉

2.4.2设置重复闹钟

cpp 复制代码

NAME
 pause - wait for signal

SYNOPSIS
 #include <unistd.h>
 int pause(void);

DESCRIPTION
 pause() causes the calling process (or thread) to sleep until a signal
 is delivered that either terminates the process or causes the invoca‐ 
 tion of a signal-catching function.

RETURN VALUE
 pause() returns only when a signal was caught and the signal-catching
 function returned. In this case, pause() returns -1, and errno is set
 to EINTR.

cpp 复制代码

using func_t = std::function<void()>;

int gcount = 0;
std::vector<func_t> gfuncs;

//把信号更换为硬件中断
void Handler(int signo)
{
    for(auto& f : gfuncs)
    {
        f();
    }
    std::cout << "gcount : "<<gcount << std::endl;
}

int main()
{
    gfuncs.push_back([](){std::cout << "我是内核刷新操作"<<std::endl;});
    gfuncs.push_back([](){std::cout << "我是切换时间片操作，到了时间，会切换进程"<<std::endl;});
    gfuncs.push_back([](){std::cout << "我是内核管理操作，定期清理内存碎片"<<std::endl;});

    alarm(1);
    signal(SIGALRM,Handler);

    while(true)
    {
        pause();
        std::cout << "我醒来了......"<<std::endl;
        gcount++;
    }

    return 0;
}

由此可以看出闹钟设置一次，起效一次

重复设置：

2.4.3如何理解软件条件

在操作系统中，信号的软件条件指的是由软件内部状态或特定软件操作触发的信号产生机制。这些条件包括但不限于定时器超时（如alarm函数设定的时间到达）、软件异常（如向已关闭的管道写数据产生的SIGPIPE信号）等。当这些软件条件满足时，操作系统会向相关进程发送相应的信号，以通知进程进行相应的处理。简而言之，软件条件是因操作系统内部或外部软件操作而触发的信号产生。

2.4.4如何简单快速理解系统闹钟

系统闹钟，其实本质是OS必须自身具有定时功能，并能让用户设置这种定时功能，才可能实现闹钟这样的技术。现代Linux是提供了定时功能的，定时器也要被管理：先描述，在组织。内核中的定时器数据结构是：

cpp 复制代码

struct timer_list {
 struct list_head entry;
 unsigned long expires;
 void (*function)(unsigned long);
 unsigned long data;
 struct tvec_t_base_s *base;
};

我们可以看到：定时器超时时间expires和处理方法 function。

操作系统管理定时器，采用的是时间轮的做法，但是我们为了简单理解，可以把它在组织成为"堆结构"

2.5硬件异常产生信号

硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。

例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

2.5.1模拟除0

cpp 复制代码

void handler(int sig)
{
    printf("catch a sig : %d\n", sig);
}
// v1
int main()
{
    signal(SIGFPE, handler); // 8) SIGFPE
    sleep(1);
    int a = 10;
    a /= 0;
    while (1);
    return 0;
}

2.5.2模拟野指针

cpp 复制代码

void handler(int sig)
{
    printf("catch a sig : %d\n", sig);
}
// v1
int main()
{
    signal(SIGSEGV, handler); // 11) SIGFPE
    sleep(1);
    int* p = nullptr;
    *p = 10;
    while (1);
    return 0;
}

由此可以确认，我们在C/C++当中除零，内存越界等异常，在系统层面上，是被当成信号处理的。

注意：通过上面的实验，我们可能发现：发现⼀直有8号信号产生被我们捕获，这是为什么呢？上面我们只提到CPU运算异常后，如何处理后续的流程，实际上 OS 会检查应用程序的异常情况，其实在CPU中有⼀些控制和状态寄存器，主要用于控制处理器的操作，通常由操作系统代码使用。状态寄存器可以简单理解为⼀个位图，对应着⼀些状态标记位、溢出标记位。OS 会检测是否存在异常状态，有异常存在就会调用对应的异常处理方法。

除零异常后，我们并没有清理内存，关闭进程打开的文件，切换进程等操作，所以CPU中还保留上下文数据以及寄存器内容，除零异常会⼀直存在，就有了我们看到的⼀直发出异常信号的现象。访问非法内存其实也是如此

2.5.3子进程退出core dump

cpp 复制代码

int main()
{
    int status = 0;
    waitpid(-1, &status, 0);
    printf("exit signal: %d, core dump: %d\n", status & 0x7F, (status >> 7) & 1);
    return 0;
}

2.5.4 Core Dump

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

首先解释什么是Core Dump。当⼀个进程要异常终止时,可以选择把进程的用户空间内存数据全部保存到磁盘上,文件名通常是core,这叫做Core Dump。

进程异常终止通常是因为有Bug，比如非法内存访问导致段错误,事后可以用调试器检查core文件以查清错误原因,这叫做 Post-mortem Debug （事后调试）。

⼀个进程允许产生多大的 core 文件取决于进程的 Resource Limit (这个信息保存在PCB 中)。默认是不允许产生core文件的,因为 core 文件中可能包含用户密码等敏感信息,不安全。

在开发调试阶段可以用ulimit 命令改变这个限制,允许产生core ⽂件。

首先用ulimit 命令改变Shell进程的Resource Limit ,如允许 core 文件最大为1024K:

bash 复制代码

ulimit -c 1024

ulimit命令改变了Shell进程的Resource Limit,test进程的PCB由Shell进程复制而来,所以也具有和 Shell进程相同的Resource Limit值,这样就可以产生Core Dump了

使用：

bash 复制代码

core-file core:事后调试，在gdb输入这个命令，直接定位到出错行号