linux进程信号_linux abort

信号入门

注册过的信号来了之后，我们是知道要怎么做的。
比如说：红绿灯，我们知道红灯停绿灯行。

信号算通信，进程通信的是数据。信号是想告诉你哪些时间发生了

技术应用角度的信号

问题1

运行一个前台进程。

运行之后，我们发现，按什么命令它都不理你。

原因：一个会话中，只允许有一个前台进程，现在的前台进程是myfile，bash跑到后台去运行了，因此没办法接收命令

---

问题2

我们把这个进程放到后台。 （运行后面加一个&即可）

结果：命令行有效了。

原因：前台进程还是bash，因此它接收的了命令行。

---

问题3

问题又来了：如何用通信的角度解释这些命令很混乱的在显示屏出现了？

答：bash和这个后台进程都往显示器打，本质上是看到了同一块资源。因此此时显示器是临界资源，而临界资源是不受保护的，因此就乱了。

问题4

我们平时用的ctrl + C是什么信号，为什么可以终止前台进程？
先说结论：是2号信号

下面验证一下：

信号捕捉

系统调用signal

第一个参数是信号编号，第二个参数是接收到信号后要干的事情，是一个函数指针。（回调函数）

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

//接收到信号之后要干的事情
void handler(int signo)
{
  printf("catch a signal : %d\n", signo);
}

int main()
{
  signal(2, handler);//设置2号信号
  while(1)
  {
    printf("i am running\n");
    sleep(1);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行后发现：ctrl + c就是二号信号

换另一个终端，发送kill -2信号结果也是这样，证明了ctrl + c就是二号信号

信号种类

用kill -l命令查看

总共有62个信号（没有32，33信号）。
前31个信号是普通信号，后31个信号是实时信号。

信号处理常见方式

• 忽略此信号
• 执行该信号的默认处理动作
• 提供一个信号处理函数，要求内核在处理该信号时切换到处理函数的方式，这种方式称为捕捉一个信号。（9号信号不能被捕捉， SIGSTOP也不能被捕捉）

core dump

core dump解释

当程序运行的过程中异常终止或崩溃，操作系统会将程序当时的内存状态记录下来，保存在一个文件中，这种行为就叫做Core Dump（中文有的翻译成“核心转储”)。

core dump作用

core dump 对于编程人员诊断和调试程序是非常有帮助的，因为对于有些程序错误是很难重现的，例如指针异常，而 core dump 文件可以再现程序出错时的情景。这种调试方法叫做事后调试。（先运行完再看错误信息）

core dump使用

core dump默认是关闭的，要自己打开。
输入命令 ulimit -a可以看到core file size大小是0，证明没有打开

使用命令ulimit -c unlimited可以让core file文件大小无限制。

写一段段错误的代码：

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

int main(int argc, char* argv[])
{
	 int i = 0;
	 int arr[100];
	 for(; i <= 200; i++)
	 {
	   arr[i] = i;
	 }
 	printf("run here?\n");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

生成可执行文件并运行：
发生了core dump行为

在磁盘中也出现了core文件，后面接的那个数字是刚刚进程的pid

进入gdb之后
输入命令core-file core.xxxxx
通过查看core-file来看出现了什么错误

信号生命周期

注：信号的产生等待处理，都不是和main函数同一条执行流的。
如图：

信号产生时

通过键盘产生

系统调用函数

kill

参数：给哪一个进程（pid）发什么信号（sig）

---

用系统调用接口kill做一个自己的kill

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

int main(int argc, char* argv[])
{
   kill(atoi(argv[1]),atoi(argv[2]));//由于命令行是字符串，因此要转为整型
}

1
2
3
4
5
6
7
8
9
10

效果：

raise

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

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

int main(int argc, char* argv[])
{
  raise(9);
}
1
2
3
4
5
6
7
8
9

刚运行起来就被kill了。

abort

abort是给自己发送6号信号，SIGABRT。
运行之后直接把自己aborted。即使你捕捉了abort信号，它在捕捉后仍然会结束进程

软件条件产生信号

SIGPIPE是一种由软件条件产生的信号，在管道中产生的条件是：当写端还在写时，读端关闭了，进程就会被信号SIGPIPE杀掉。

alarm

用处：过多少秒就发生SIGALRM信号，终止进程

硬件异常产生信号

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

SIGSEGV

写了一个段错误代码，并对11号信号SIGSEGV信号进行捕捉。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
void handler(int signo)
{
  printf("catch a signal : %d\n", signo);
  exit(0);
}

int main(int argc, char* argv[])
{
  signal(11, handler);
  int *p = NULL;
  *p = 100;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

问题：系统是怎么知道知道发生了段错误的？

答：指针指向的地址是虚拟地址，当解引用要拿到物理地址的时候，需要通过页表和MMU来转化成物理地址。可是页表和MMU上没有这个虚拟到物理的映射关系，MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

SIGFPE

浮点数运算错误。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
void handler(int signo)
{
  printf("catch a signal : %d\n", signo);
  exit(0);
}

int main(int argc, char* argv[])
{
  signal(8, handler);
  int a = 1 / 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

过程：cpu在计算1 / 0的时候，发现错误，会产生异常，os捕捉到这个异常并发送SIGFPE信号终止进程

总结

1. 所有的信号都必须经过操作系统的手发出。为什么所有的信号都必须经过操作系统的手，因为只有操作系统才可以管理进程，让他继续或者停止。
2. 信号的发送：os把pcb当中的信号位图中的某一个bit位由0变1即可。
3. 信号不是立刻被处理的，而是在合适的时候。一个程序报错了它有可能可以继续往下运行。

信号的保存

信号的保存是用位图。
每一个bit位的位置，代表的是哪个信号
每一个bit位的内容，代表的是这个信号是否产生了。

实现：
修改task_struct里面的信号位图的bit位

struct task_struct
{
	unsigned int sigbitmap = 0
}
1
2
3
4

信号常见概念

1.递达。实际执行信号的处理动作称为信号递达(Delivery)，递达可以分为3种，分别为默认处理，忽略，捕捉自定义
2.信号未决。信号从产生到递达之间的状态。即信号被发送之后，但还没有被处理期间，叫未决
3.进程可以选择阻塞某个信号(9号信号不能被阻塞）。被阻塞的信号产生时将保持在未决状态，直到进程接触对此信号的阻塞，才执行递达

内核中信号的表示

block和pending都是位图。
pending位图代表信号是否处于未决状态，block位图代表信号是否被阻塞。（1代表阻塞）

这里之所以写成产生的原因是：未决状态时信号产生了之后才能未决。说成信号产生会更容易理解。
因此：

注：一个信号在递达之后，会由1变回0.因此0的状态可以理解成递达完成的信号，也可以理解成没有产生这个信号

看一下源码：

1. 在task_struct里面有block和pending和handler（sighand）。
   其中sigpending个结构体的原因是：普通信号和实时信号都要放在pending里，因此统一管理起来了。
   

2. sigset_t不同版本实现方式不同
   
   

3. handler数组，里面放的是函数指针
   

信号的处理

handler代表自定义方法。handler是一个数组，里面存放着函数指针。就是递达的行为

handler有三个宏：分别为SIG_DFL,SIG_IGN,SIG_ERR

最后再解释一下完整的过程：
如果2号信号产生，就会被阻塞。当阻塞结束之后，就会递达，执行SIG_IGN的操作，即忽略此信号。

信号集操作函数

如果要把一些信号阻塞，这是操作流程：

用户可以通过信号集函数来操控底层的位图。（两个位图都可以使用这几个函数）

注：用这几个函数操作的位图只是修改了自己的值而已，并没有把位图放进进程当中。设置完成之后需要使用sigprocmask来放入block位图

#include <signal.h>
int sigemptyset(sigset_t *set);//全部bit位清0
int sigfillset(sigset_t *set);//全部bit位填1
int sigaddset (sigset_t *set, int signo);//设置信号
int sigdelset(sigset_t *set, int signo);//删除信号
int sigismember（const sigset_t *set, int signo);//判定一个信号是否存在 
1
2
3
4
5
6

sigprocmask

block位图可以叫做信号屏蔽字
调用这个函数可以读取或者更改进程的信号屏蔽字。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 
返回值:若成功则为0,若出错则为-1
1
2
3

第一个参数：how
how有三个可选值：

• SIG_BLOCK 添加我们想要添加到当前信号屏蔽字的信号，相当于mask = mask|set
• SIG_UNBLOCK 解除当前在信号屏蔽字中的信号，相当于mask = mask & ~set
• SIG_SETMASK 设置当前信号屏蔽字为set所指向的值，相当于mask = set

第二个参数：set。即你想设置的新的信号屏蔽字。要配合第一个参数

第三个参数: oset。是一个输出型参数，把老的oldset给保留起来，存到oldset里面

sigpending

#include <signal.h>
sigpending(sigset_t *set)
读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。
1
2
3

set是输出型参数，获取当前的pending表的位图

获取pending位图的程序

先设置所有信号都为0，然后产生2号信号，并把它阻塞，使他不能递达，这样就能看到pending位图里面的2号信号了。
在没有发送2号信号的时候，应该是0000000000000000000…
发送之后，应该是010000000000…

代码：

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

void show_pending(sigset_t *pending)
{
  int sig = 1;
  for(; sig <= 31; sig++)
  {
    if(sigismember(pending, sig)) printf("1");
    else printf("0");
  }

  printf("\n");
}

int main()
{
  sigset_t pending;

  sigset_t block, oblock;

  sigemptyset(&block);//设置block位图(栈上的变量，并没有进进程里)  
  sigemptyset(&oblock);//设置block位图(栈上的变量，并没有进进程里)

  sigaddset(&block, 2);
  sigprocmask(SIG_SETMASK, &block, &oblock);//设置block位图（进程里）

  while(1)
  {
    sigemptyset(&pending);
    sigpending(&pending);//获取进程里面的pending位图
    show_pending(&pending);
    sleep(1);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

第二个实验：现在想让产生2号信号之后变1之后，二十秒后又变回0.

我们知道，2号信号变成1，再变成0就会使进程退出。我们就看不到这种现象了，因此要捕捉2号信号。

代码：

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

void show_pending(sigset_t *pending)
{
  int sig = 1;
  for(; sig <= 31; sig++)
  {
    if(sigismember(pending, sig)) printf("1");
    else printf("0");
  }

  printf("\n");
}

void handler(int sig)
{
  printf("get a sig : %d\n", sig);
}

int main()
{
  sigset_t pending;

  sigset_t block, oblock;

  //捕捉
  signal(2, handler);

  sigemptyset(&block);//设置block位图(栈上的变量，并没有进进程里)  
  sigemptyset(&oblock);//设置block位图(栈上的变量，并没有进进程里)

  sigaddset(&block, 2);
  sigprocmask(SIG_SETMASK, &block, &oblock);//设置block位图（进程里）

  int count = 0;
  while(1)
  {
    sigemptyset(&pending);
    sigpending(&pending);//获取进程里面的pending位图
    show_pending(&pending);
    sleep(1);
    count ++;
    //二十秒后阻塞结束，由1变0
    if(count == 20)
    {
      printf("recover sig_mask!\n");
      sigprocmask(SIG_SETMASK, &oblock, NULL);//把2号信号取消阻塞，即把老的block给它即可
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

内核态和用户态

我们写的程序是在不断的在内核态和用户态之间相互转化的。
原因：我们写的代码，是由库函数和系统调用同时构成的。比如printf就是调用的write

程序运行时示意图：

内核解释：
内核态就是进程在使用内核区的代码，用户区就是进程在使用用户区的代码。

信号捕捉（重点）

信号不是立即处理的，是从内核态切换成用户态时进行相关检测

信号处理方式分为两种，一种是没有自定义行为的，一种是自定义信号行为的。

• 没有自定义行为的，在内核返回用户的时候处理完直接返回main函数。

• 自定义行为的，在内核返回用户的时候，执行自定义行为函数，然后通过系统调用回到内核，再从内核回到main函数中

可以用一个符号来记忆这个过程。（正无穷）

sigaction

sigaction和signal函数实现的功能是一样的。用起来还很麻烦。建议用signal直接捕捉信号。

int sigaction(int signum, const struct sigaction *act,
								struct sigaction *oldact);
1
2

当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。

如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags字段包含一些选项,这里都把sa_flags设为0,sa_sigaction是实时信号的处理函数,这里不解释。

使用这个函数要初始化两个结构体，struct sigaction。

代码：

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

void show_pending(sigset_t *pending)
{
  int sig = 1;
  for(; sig <= 31; sig++)
  {
    if(sigismember(pending, sig)) printf("1");
    else printf("0");
  }

  printf("\n");
}

void handler(int sig)
{
  printf("get a sig : %d\n", sig);
}

int main()
{
	//初始化结构体
  struct sigaction act, oact;
  act.sa_handler = handler;
  act.sa_flags = 0;
  
  sigemptyset(&act.sa_mask);//切记不要直接赋值为0，要用sigemptyset
  sigaction(2,&act, &oact);
  
  while(1);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

结果：

signal

signal捕捉信号很简单，

下面这样就算捕捉完成了，动作时忽略此信号

signal(2, SIG_IGN);
1

可重入函数

多个执行流执行同一份代码的时候是否会出现问题？
不出现则是可重入的，出现问题则是不可重入的。
多线程要考虑这个问题很多。

一般来说：
1.用new 和 delete的都不可重入
2.调用了标准I/O库函数。比如stl库基本都不可重入

volatile（多执行流用）

先看一段代码：

#include <stdio.h>
#include <signal.h>

int quit = 0;

void handler(int signo)
{
  quit = 1;
  printf("quit is already set to 1\n");
}

int main()
{
  signal(2, handler);

  while(!quit);
  printf("end process\n");
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

讲一下执行过程：

我们知道，信号捕捉和main函数不是同一条执行流。因此quit的修改不是在main函数执行流里修改的，而是在信号捕捉的执行流修改的。信号捕捉的时候，由于quit变量在进程的内存里面，因此要去内存里面拿到这个数据并修改它。因此当发送2号信号的手，while退出循环，程序结束。

结果也是如此：

问题来了：我们知道程序的优化有O1,O2,O3优化，我们开启O2优化看一下这段代码会不会有不同的结果。

结果：我们发现，无法退出循环。

原因：在判断quit是否为0的时候，是需要把quit从内存里拿到cpu判断的（做运算都要跑到cpu里），开了优化之后，系统不想老是拿来拿去，浪费时间，干脆直接在cpu的寄存器里面存放了quit这个变量的备份。

由于main函数执行流和信号不同。quit变量是被信号对应的执行流修改的，因此内粗里的quit确实变成了1，但是cpu寄存器里面的quit还是0，因此无法退出循环。

怎么解决这个问题呢？
使用volatile变量，编译器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。

在多执行流的时候才有可能会用这个关键字

#include <stdio.h>
#include <signal.h>

volatile quit = 0;

void handler(int signo)
{
  quit = 1;
  printf("quit is already set to 1\n");
}

int main()
{
  signal(2, handler);

  while(!quit);
  printf("end process\n");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

又可以退出了。

SIGCHLD

1. 子进程退出的时候，会给父进程发送SIGCHLD信号。
2. 在Linux平台（其他平台不一定），让父进程把SIGCHLD信号的行为变成SIG_IGN，子进程就不会变成僵尸，而会直接退出
3. 系统默认的忽略动作和用户用sigaction函数自定义的忽略 通常是没有区别的,但这是一个特例。调用SIG_IGN就不会出现Zombie，自定义捕捉就会出现Zombie

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
void handler(int signo)
{
  printf("pid : %d , get a sig , No. %d\n",getpid(),signo);
}


int main()
{
  signal(SIGCHLD, handler);

if(fork() == 0)
{
  printf("child running ... pid : %d, ppid : %d \n", getpid(), getppid());
  sleep(5);
  printf("child quit \n");
  exit(1);
}
 while(1);//父进程死循环一直等信号

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

结果：

又运行了一次，并调用了监视窗口看了一下，发现自定义捕捉确实会zombie

---

把handler变成SIG_IGN看一下会怎样。
结果：子进程直接退出了，没有出现zombie