进程信号初识

信号入门

1.生活角度的信号

• 你在网上买了很多件商品，再等待不同商品快递的到来。但即便快递没有到来，你也知道快递来临时，
  你该怎么处理快递。也就是你能“识别快递”
• 当快递员到了你楼下，你也收到快递到来的通知，但是你正在打游戏，需5min之后才能去取快递。那么在在这5min之内，你并没有下去去取快递，但是你是知道有快递到来了。也就是取快递的行为并不是一定要立即执行，可以理解成“在合适的时候去取”。
• 在收到通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间，你并没有拿到快递，但是你知道有一个快递已经来了。本质上是你“记住了有一个快递要去取”
• 当你时间合适，顺利拿到快递之后，就要开始处理快递了。而处理快递一般方式有三种：1. 执行默认动作（幸福的打开快递，使用商品）2. 执行自定义动作（快递是零食，你要送给你你的女朋友）3. 忽略快 递（快递拿上来之后，扔掉床头，继续开一把游戏）
• 快递到来的整个过程，对你来讲是异步的，你不能准确断定快递员什么时候给你打电话

2. 技术应用角度的信号

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

   [hb@localhost code_test]$ cat sig.c
   #include 
   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
   [hb@localhost code_test]$
   

   • 请将生活例子和 Ctrl-C 信号处理过程相结合，解释一下信号处理过程
   • 进程就是你，操作系统就是快递员，信号就是快递

3.注意

1. Ctrl-C 产生的信号只能发给前台进程。一条命令后面加个&可以将该命令放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
2. Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生
   的信号。
3. 前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生一个信号,也就是说该进程的用户空间代码执行
   到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步(Asynchronous)的

4. 信号概念

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

5.用kill -l命令可以察看系统定义的信号列表

• 每个信号都有一个编号和一个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定 义 #define
SIGINT 2
• 编号34以上的是实时信号,我们只讨论编号34以下的信号,不讨论实时信号。这些信号各自在什么条件下
  产生,默认的处理动作是什么,在signal(7)中都有详细说明: man 7 signal

6. 信号处理常见方式概览

(sigaction函数稍后详细介绍),可选的处理动作有以下三种:

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

产生信号

1.通过终端按键产生信号

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

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: $ ulimit -c1024

2. 调用系统函数向进程发信号

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

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

• 指定发送某种信号的kill命令可以有多种写法,上面的命令还可以写成 kill -SIGSEGV 16697 或 kill -11

  16697 , 11是信号SIGSEGV的编号。以往遇到的段错误都是由非法内存访问产生的,而这个程序本身没错,
  给它发SIGSEGV也能产生段错误

先介绍一个函数signal：

void (*signal(int sig, void (*func(int)))(int);

参数1：我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。这些信号其实就是系统定义的宏。

参数2：我们处理的方式（是系统默认还是忽略还是捕获）。

所以该函数是可以让信号被我们捕获的

下面的代码就是将2号信号捕获，然后我们进程相应的打印

void handle(int signo)
{
  printf("get a signal:%d\n", signo);
}

int main()
{
  signal(2, handle); 
  while (1)
  {
    ;
  }
  return 0;
}

可以看到当进程进入死循环时，我们想按ctrl + c让它停下来，但是被捕获了，所以无法实现原来的功能。说明ctrl+c对应的信号是2号信号

想要退出可以按ctrl + \

kill命令是调用kill函数实现的。kill函数可以给一个指定的进程发送指定的信号。raise函数可以给当前进程发送指定
的信号(自己给自己发信号)。

#include 
int kill(pid_t pid, int signo);
int raise(int signo);
这两个函数都是成功返回0,错误返回-1。

kill的使用，用命令行传参的形式，例如，./test 345 9，用9号信号杀掉345进程

[ysj@VM-4-11-centos shm_10-6]$ sleep 1000 &
[1] 22497
[ysj@VM-4-11-centos shm_10-6]$ ./test 22497 9

#include
#include
#include

int main(int argc, char*argv[])
{

  if (argc == 3)
  {
    kill(atoi(argv[1]), atoi(argv[2]));
  }

  return 0;
}

raise示例

#include
#include
#include

void handle(int signo)
{
  printf("get a signal:%d\n", signo);
}

int main(int argc, char*argv[])
{
  while (1)
  {
    signal(6, handle); 
    raise(6);
  }

  return 0;
}

代码会死循环地捕捉6号信号：

如果我们捕捉9号信号会怎么样？

可以看到，进程还是被杀掉了，也就是9号信号捕捉失败了，说明9号信号是不能被捕捉的。

否则假设遇到一个病毒：将所有的信号都捕捉，就没有办法杀死进程了。

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

#include 
void abort(void);
//默认是发送6信号——SIGABRT

就像exit函数一样,abort函数总是会成功的,所以没有返回值

abort示例：

#include
#include
#include

void handle(int signo)
{
  printf("get a signal:%d\n", signo);
}

int main(int argc, char*argv[])
{
  signal(6, handle); 
  abort();

  return 0;
}

结果：

可以看到最后进程还是被杀掉了，与我们之前看到的一直ctrl+c被捕捉的情况不同。

3. 由软件条件产生信号

SIGPIPE是一种由软件条件产生的信号,在“管道”中已经介绍过了。这里主要介绍alarm函数 和SIGALRM信号

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

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

例 alarm

#include
#include
#include
#include

int main(int argc, char*argv[])
{
  int count = 10;
  alarm(5);

  for (; count > 0; count--)
  {
    sleep(1);
    printf("time remain:%d\n", count);
  }

  return 0;
}

这个程序的作用是5秒钟之内不停地数数，5秒钟到了就被SIGALRM信号终止。

如果在for循环里加一句: if (count == 7) alarm(0);，之前设置的 alarm(5)的闹钟就会取消，进程就不会被杀掉。

int main(int argc, char*argv[])
{
  int count = 10;
  alarm(5);

  for (; count > 0; count--)
  {
    sleep(1);
    printf("time remain:%d\n", count);
    
    if (count == 7)
    {
      alarm(0);
      printf("alarm canceled!\n");
    }
  }

  return 0;
}

中间有卡顿是因为网络不好，导致效果出现了一点差错，但在倒数到7s的时候，alarm被取消了，进程也就能够完整地执行了

4.硬件异常产生信号

硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

示例：我们将SIGFPE信号捕获

#include
#include
#include
#include

void handle(int signo)
{
  printf("get a signal:%d\n", signo);
}

int main()
{
  signal(8, handle);
  int i = 1/0;

  return 0;
}

一直发送信号，一直接收信号：

发生错误后，我们修改了信号处理方法(捕获了信号)，为什么还会一直发送信号呢？

在软件层面上，我们处理了，可是硬件上的错误没有处理，所以OS一直在发送信号

信号捕捉初识

#include 
#include 
void handler(int sig)
{
	printf("catch a sig : %d\n", sig);
}
int main()
{
    signal(2, handler); //前文提到过，信号是可以被自定义捕捉的，siganl函数就是来进行信号捕捉的，提前了解一下
    while(1);
    return 0;
}


[ysj@localhost code_test]$ ./sig
^Ccatch a sig : 2
^Ccatch a sig : 2
^Ccatch a sig : 2
^Ccatch a sig : 2
^\Quit (core dumped)
[hb@localhost code_test]$

模拟一下野指针异常

//默认行为
[hb@localhost code_test]$ cat sig.c
#include 
#include 
void handler(int sig)
{
	printf("catch a sig : %d\n", sig);
}
int main()
{
    //signal(SIGSEGV, handler);
    sleep(1);
    int *p = NULL;
    *p = 100;
    
    while(1);//死循环
    
    return 0;
}


[ysj@localhost code_test]$ ./sig
Segmentation fault (core dumped)
    
[ysj@localhost code_test]$
//捕捉行为
[ysj@localhost code_test]$ cat sig.c
    
#include 
#include 
void handler(int sig)
{
	printf("catch a sig : %d\n", sig);
}

int main()
{
    signal(SIGSEGV, handler);
    sleep(1);
    int *p = NULL;
    *p = 100;
    
    while(1);
    
    return 0;
}

[ysj@localhost code_test]$ ./sig
[ysj@localhost code_test]$ ./sig
catch a sig : 11
catch a sig : 11
catch a sig : 11 

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

总结思考一下

• 上面所说的所有信号产生，最终都要有OS来进行执行，为什么？OS是进程的管理者
• 信号的处理是否是立即处理的？不是，是在合适的时候
• 信号如果不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？
• 一个进程在没有收到信号的时候，能否能知道，自己应该对合法信号作何处理呢？
• 如何理解OS向进程发送信号？能否描述一下完整的发送处理过程？