开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 系统运维 -> linux进程信号 -> 正文阅读

[系统运维]linux进程信号

信号入门

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

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

技术应用角度的信号

问题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);
  }
}

运行后发现：ctrl + c就是二号信号
在这里插入图片描述
换另一个终端，发送kill -2信号结果也是这样，证明了ctrl + c就是二号信号

信号种类

用kill -l命令查看
在这里插入图片描述
总共有62个信号（没有32，33信号）。
前31个信号是普通信号，后31个信号是实时信号。

信号处理常见方式

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

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");
}

生成可执行文件并运行：
发生了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]));//由于命令行是字符串，因此要转为整型
}

效果：
在这里插入图片描述

raise

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

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

int main(int argc, char* argv[])
{
  raise(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;
}

在这里插入图片描述
问题：系统是怎么知道知道发生了段错误的？

答：指针指向的地址是虚拟地址，当解引用要拿到物理地址的时候，需要通过页表和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;
}

在这里插入图片描述

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

总结

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

信号的保存

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

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

struct task_struct
{
	unsigned int sigbitmap = 0
}

信号常见概念

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

内核中信号的表示

在这里插入图片描述
block和pending都是位图。
pending位图代表信号是否产生，block位图代表信号是否被阻塞。（1代表阻塞）
因此：

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

看一下源码：

在task_struct里面有block和pending和handler（sighand）。
其中sigpending个结构体的原因是：普通信号和实时信号都要放在pending里，因此统一管理起来了。
sigset_t不同版本实现方式不同
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);//判定一个信号是否存在

sigprocmask

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

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

第一个参数：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。

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);
  }
}

在这里插入图片描述

第二个实验：现在想让产生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给它即可
    }
  }
}

在这里插入图片描述

内核态和用户态

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

程序运行时示意图：
在这里插入图片描述

内核解释：
内核态就是进程在使用内核区的代码，用户区就是进程在使用用户区的代码。
在这里插入图片描述

信号捕捉（重点）

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

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

没有自定义行为的，在内核返回用户的时候处理完直接返回main函数。
自定义行为的，在内核返回用户的时候，执行自定义行为函数，然后通过系统调用回到内核，再从内核回到main函数中

在这里插入图片描述
可以用一个符号来记忆这个过程。（正无穷）

sigaction

sigaction和signal函数实现的功能是一样的。

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

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

如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用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.用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");
}

讲一下执行过程：

我们知道，信号捕捉和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");
}

又可以退出了。

SIGCHLD

子进程退出的时候，会给父进程发送SIGCHLD信号。
在Linux平台（其他平台不一定），让父进程把SIGCHLD信号的行为变成SIG_IGN，子进程就不会变成僵尸，而会直接退出
系统默认的忽略动作和用户用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);//父进程死循环一直等信号

}