【Linux--信号】

龙里出生的蛋2023-12-29 17:09

目录

一、信号的概念

1.1查看系统的信号

kill -l

1-31是普通信号，34-64是实时信号

每一个信号都有一个编号和一个宏定义名称。

1.2信号的处理方式

  1. 忽略信号。忽略信号也是处理了信号
  2. 执行信号的默认处理动作
  3. 利用signal系统调用，提供一个信号处理函数，要求在内核处理该信号时切换到用户态执行这个函数，这种方式称为捕捉一个信号。就像上面的代码，将2号信号捕捉为一个
cpp 复制代码 
handler函数。
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>

void myhandler(int signo)
{
    cout<<"process get a signal:"<<signo<<endl;
}
int main()
{

    signal(2,myhandler);
    while(true)
    {
        cout<<"i am a happy process:"<<getpid()<<endl;
        sleep(1);

    }

    return 0;
}

二、信号的产生方式

2.1通过终端按键

比如上面的ctrl + c 就给进程发送了2号信号SIGINT。而ctrl + \可以给进程发送3号信号SIGQUIT。

通过按键组合的方式来给进程发送信号。

2.2kill命令

kill 系统调用，作用：给当进程为pid的进程发送信号

2.3系统调用

  • kill系统调用

参数：pid:进程pid

sig:几号信号

返回值：成功返回0，失败返回-1

作用：给进程pid发送sig信号
mykill.cc

cpp 复制代码 
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<string.h>
int main(int argc,char* argv[])
{
    kill(atoi(argv[1]),atoi(argv[2]));
    return 0;
}

myproc.cc

cpp 复制代码 
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
int main()
{
    while(true)
    {
        cout<<"i am p process pid:"<<getpid()<<endl;
        sleep(1);
    }
    return 0;
}

现象：

  • raise系统调用

    作用：给当前进程发送信号
    myproc.cc
cpp 复制代码 
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
int main()
{
    int cnt=5;
    while(true)
    {
        if(cnt==0)
        {
            raise(2);
        }
        cout<<"i am p process pid:"<<getpid()<<endl;
        sleep(1);
        cnt--;
    }
    return 0;
}
  • abort系统调用

    作用：给进程发送6号信号，终止进程
    注意：abort函数一定会成功终止进程。不管有没有重新捕捉信号。
    myproc.cc
cpp 复制代码 
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
int main()
{
    int cnt=5;
    while(true)
    {
        if(cnt==0)
        {
            //raise(2);
            abort();
        }
        cout<<"i am p process pid:"<<getpid()<<endl;
        sleep(1);
        cnt--;
    }
    return 0;
}


2.4软条件产生信号

这里也有一个函数alarm，相当于设置一个闹钟，告诉内核多少秒后，发送一个SIGALRM信号给当前进程。

cpp 复制代码 
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>

void myhandler(int signo)
{
    cout<<"process get a signal:"<<signo<<endl;
}
int main()
{
    alarm(5);

    while(true)
    {
        cout<<"i am a happy process:"<<getpid()<<endl;
        sleep(1);

    }

    return 0;
}

2.5硬件异常产生信号

硬件异常产生信号就是硬件发现进程的某种异常，而硬件是被操作系统管理。硬件会将异常通知给系统，系统就会向当前进程发送适当的信号。

例如：野指针的情况、除0问题

cpp 复制代码 
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>

void myhandler(int signo)
{
    cout<<"process get a signal:"<<signo<<endl;
}
int main()
{

    signal(11,myhandler);
    int* ptr;
    cout<<*ptr<<endl;

    return 0;
}

原因：由于p是野指针，p指针变量里保存的是随机值，进程执行到野指针这一行。进程在页表中找映射的物理内存时，硬件mmu会发现该虚拟地址是一个 野指针，会产生异常，由于操作系统管理硬件，硬件会将异常发送给系统。系统会发送适当的信号给当前进程。

上面代码有野指针，系统会发送11号信号给进程。但是在循环里面并没有野指针，但是发现一直在打印，说明系统一直在往进程发送11号信号，这是因为硬件异常并没有消除。

只能向进程发送终止信号，终止进程才能结束。
总结

信号是由OS发出来的，上面的五种产生情况，是操作系统发出信号的触发条件。

  • 上面所有信号的产生都会需要操作系统的参与，为什么？

    因为操作系统是进程的管理者，只有操作系统能管理进程。

  • 信号处理是什么时候被处理的？

    在合适的时候处理，并不是信号来了就处理。所以需要记录下来。

  • OS怎么向进程发送信号？

    普通信号有31个，进程PCB中有一个数据结构，是位图(只需要一个整数即可)。来记录当前进程是否收到对应位置的信号，OS向进程发送信号时，将对应位置置1即可。

实时信号是由链表构成的，一个时间可以收到多个信号，不会丢失。

三、信号的保存

3.1概念的认识

  • 执行信号的处理动作称为信号递达（Delivery）
  • 信号从产生到递达之间的状态，称为信号未决（pending）。上面说明过信号不是一产生就立即处理的。
  • 进程可以选择阻塞某一个信号，被阻塞的信号产生时保持未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。
  • 阻塞和忽略是有本质的不同，只要信号被阻塞就不会递达，而忽略是在递达之后的处理方法。

    如上图：
  • SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作（SIG_DEL）（未产生则不会递达）
  • SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然其处理动作是忽略（SIG_IGN），但在没有递达前不能忽略这个信号，因为进程仍有机会在改变处理动作之后再解除阻塞
  • SIGQUIT信号未产生过，但一旦产生SIGQUIT信号，该信号将被阻塞，它的处理动作是用户自定义函数sighandler
  • 如果进程解除对某一个信号阻塞之前，该信号产生了很多次只会被记录一次即pending表里对应位置记录的值为1，而实时信号在递达之前产生多次可以依次放在一个队列里（这里只讨论普通信号）

3.2sigset_t

上面提到了三张表，那作为用户想要拿到表里面的内容是不能直接拿到的。需要通过一些接口还有输出型参数才能拿到。而这个输出型参数的类型就是sigset_t。

sigset_t被称为信号集，这个类型可以表示每个信号的"有效"或"无效"状态

  • 在阻塞信号集中"有效"和"无效"的含义是该信号是否被阻塞。
  • 在未决信号集中"有效"和"无效"的含义是该信号是否处于未决状态
    阻塞信号集也被称为当前进程的信号屏蔽字，"屏蔽"应该理解为阻塞而不是忽略

3.3信号集操作函数

cpp 复制代码 
#include <signal.h>
 
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signum);
int sigdelset(sigset_t *set, int signum);
int sigismember(const sigset_t *set, int signum);
  • sigemptyset函数：初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号
  • sigfillset函数：初始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号
  • sigaddset函数：在set所指向的信号集中添加某种有效信号
  • sigdelset函数：在set所指向的信号集中删除某种有效信号
  • sigemptyset、sigfillset、sigaddset和sigdelset函数都是成功返回0，出错返回-1
  • sigismember函数：判断在set所指向的信号集中是否包含某种信号，若包含则返回1，不包含则返回0，调用失败返回-1
    注意：
  • 在使用sigset_t类型的变量前，一定要调用sigemptyset()或sigfillset()初始化，使信号处于确定的状态
  • 代码中定义的sigset_t类型的变量s存在栈区，使用上面的函数只会对变量s造成影响，并不会影响进程的任何行为。还需通过sigprocmask()函数，才能将变量s的数据设置进操作系统

3.4sigprocmask && sigpending

3.4.1sigprocmask

作用：sigprocmask()函数可用于读取或更改进程的信号屏蔽字（阻塞信号集）

cpp 复制代码 
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

参数：

  • 若oset是非空指针，则读取进程当前的信号屏蔽字通过oset参数传出
  • 若set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改
  • 若oset和set都是非空指针，则先将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字
  • how

    返回值：sigprocmask函数调用成功返回0，出错返回-1

3.4.2 sigpending

cpp 复制代码 
int sigpending(sigset_t *set)；

作用 ：sigpending()函数用于读取进程的未决信号集

sigpending()函数读取当前进程的未决信号集，通过set参数传出。该函数调用成功返回0，出错返回-1

3.5函数使用

mysignal.cc

cpp 复制代码 
#include<iostream>
using namespace std;
#include<signal.h>
#include<unistd.h>
void PrintPending(sigset_t& pending)
{
    for(size_t i=31;i>=1;i--)
    {
        if(sigismember(&pending,i)) cout<<"1";
        else    cout<<"0";
    }
    cout<<"\n\n";
}
void handler(int signo)
{
    cout<<"catch a singal:"<<signo<<endl;
}
int main()
{
    //对2号信号进行捕捉
    signal(2,handler);


    sigset_t bset,oset;
    sigemptyset(&bset);
    sigemptyset(&oset);
    sigfillset(&bset);
    sigfillset(&oset);
    //1.将2号信号进行屏蔽
    sigaddset(&bset,2);

    //1.2调用系统调用，将数据设置系统内核
    sigprocmask(SIG_SETMASK,&bset,&oset);//将bset设置系统内核，在将系统内核原始的带回oset

    //2.打印pengding
    int cnt=15;
    while(true)
    {
        //15秒后解除阻塞
        if(cnt==0)
        {
            sigprocmask(SIG_SETMASK,&oset,nullptr);
        }
        sigset_t pending;
        sigpending(&pending);
        PrintPending(pending);
        sleep(1);
        cnt--;
    }
    return 0;
}

现象：

四、信号的捕捉

进程收到信号之后，并不是立即处理信号，而是在合适的时候进行处理。"合适的时候"就是指，从内核态切换回用户态的时候。

当我们的进程从内核态返回用户态的时候，进行信号的检测和处理。

4.1内核态与用户态

  • 内核态通常用来执行操作系统的代码，是一种权限非常高的状态

  • 用户态是一种用来执行普通用户代码的状态，是一种受监管的普通状态

从用户态切换为内核态：

  • 需要进行系统调用时

  • 当前进程的时间片到了，导致进程切换

  • 产生异常、中断、陷阱等

从内核态切换为用户态：

  • 系统调用返回时
  • 进程切换完毕
  • 异常、中断、陷阱等处理完毕

由用户态切换为内核态被称之为陷入内核。每当需要陷入内核时，本质上是因为需要执行操作系统的代码。比如系统调用函数是由操作系统实现的，要进行系统调用就必须先由用户态切换为内核态

4.2内核空间与用户空间

每个进程都有自己的进程地址空间，该进程地址空间由内核空间和用户空间组成：

用户所写的代码和数据位于用户空间，通过用户级页表与物理内存之间建立映射关系

内核空间存储的实际上是操作系统代码和数据，通过内核级页表与物理内存之间建立映射关系

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，所有进程看到的都是一样的内容

4.3信号捕捉

流程图：

简化图：

该图形与直线有几个交点就代表在这期间有几次状态切换，而箭头的方向就代表着此次状态切换的方向，图形中间的圆点就代表着检查pending表。

4.4sigcation

捕捉信号除了使用signal()函数外，还可以使用sigaction()函数

cpp 复制代码 
 int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

sigaction()函数可以读取和修改与指定信号相关联的处理动作，该函数调用成功返回0，出错返回-1

  • signum代表指定信号的编号
  • 若act指针非空，则根据act修改该信号的处理动作
  • 若oldact指针非空，则通过oldact传出该信号原来的处理动作
cpp 复制代码 
struct sigaction {
	void(*sa_handler)(int);
	void(*sa_sigaction)(int, siginfo_t *, void *);
	sigset_t   sa_mask;
	int        sa_flags;
	void(*sa_restorer)(void);
};

sa_handler

  • 将sa_handler赋值为SIG_IGN传给sigaction函数，表示忽略信号
  • 将sa_handler赋值为SIG_DFL传给sigaction函数，表示执行系统默认动作
  • 将sa_handler赋值为一个函数指针，表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数

sa_sigaction

sa_sigaction是实时信号的处理函数
sa_mask

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

若在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时，会自动恢复成原来的信号屏蔽字。
sa_flags

sa_flags字段包含一些选项，这里直接将sa_flags设置为0即可
sa_restorer

暂时不使用该参数

五、可重入函数

我们都知道链表在进行头插的时候需要两个步骤。步骤1，将需要头插的结点的next指向head。步骤2，head更新。

假设在执行完步骤1后突然来了一个信号并进行信号捕捉，对信号的处理方法是再进行头插node2。再头插完node2后回来执行步骤2就会出现下面的状况。

insert函数访问一个全局链表，有可能因为重入而造成错乱，这样的函数被称之为不可重入函数；反之，若一个函数只访问自己的局部变量或参数，则称之为可重入函数
一个函数符合以下条件之一就一定是不可重入的：

调用了malloc或free，因为malloc也是用全局链表来管理堆的

调用了标准I/O库函数，因为标准I/O库的很多实现都以不可重入的方式使用全局数据结构

六、volatile

代码：

cpp 复制代码 
#include <stdio.h>
#include <signal.h>
int flag = 0;
void handler(int sig)
{
	 printf("chage flag 0 to 1\n");
	 flag = 1;
}
int main()
{
	 signal(2, handler);
	 while(!flag);//在优化的条件下，flag可能会被优化到cpu内的寄存器中
	 printf("process quit normal\n");
	 return 0;
}

优化情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ，但是 while 条件依旧满足,进程继续运行！但是很明显flag肯定已经被修改了，但是为何循环依旧执行？很明显， while 循环检查的flag，并不是内存中最新的flag，这就存在了数据二异性的问题。 while 检测的flag其实已经因为优化，被放在了CPU寄存器当中。如何解决呢？很明显需要 volatile

volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作

七、SIGCHLD信号

其实，子进程在终止时操作系统会给父进程发生SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理动作，这样父进程就只需专心处理自己的工作，不必关心子进程了，子进程终止时会通知父进程，父进程在信号处理函数中调用wait或waitpid函数清理子进程即可。

cpp 复制代码 
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
using namespace std;
 
void handler(int signo)
{
	cout << "get a signal:" << signo << endl;
	int ret = 0;
	while ((ret = waitpid(-1, NULL, WNOHANG)) > 0) {
		cout << "wait child " << ret << " success" << endl;
	}
    exit(0);
}
int main()
{
	signal(SIGCHLD, handler);
	if (fork() == 0) {//child
		cout << "child is running, PID: " << getpid() << endl;
		exit(1);
	}
	//father
	while (1);
 
	return 0;
}

要想不产生僵尸进程还有另外一种办法：父进程调用signal或sigaction函数将SIGCHLD信号的处理动作设置为SIG_IGN，这样子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程。系统默认的忽略动作和用户用signal或sigaction函数自定义的忽略通常是没有区别的，但这是一个特列。此方法对于Linux可用，但不保证在其他UNIX系统上都可用

cpp 复制代码 
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
using namespace std;
 
int main()
{
	signal(SIGCHLD, SIG_IGN);
	if (fork() == 0) { //child
		cout << "child is running, PID: " << getpid() << endl;
		sleep(3);
		exit(1);
	}
	//father
	while (1);
 
	return 0;
}
相关推荐
小糖学代码8 小时前
LLM系列：1.python入门：3.布尔型对象
linux·开发语言·python
shizhan_cloud8 小时前
Shell 函数的知识与实践
linux·运维
Deng8723473488 小时前
代码语法检查工具
linux·服务器·windows
霍夫曼11 小时前
UTC时间与本地时间转换问题
java·linux·服务器·前端·javascript
月熊11 小时前
在root无法通过登录界面进去时，通过原本的普通用户qiujian如何把它修改为自己指定的用户名
linux·运维·服务器
大江东去浪淘尽千古风流人物12 小时前
【DSP】向量化操作的误差来源分析及其经典解决方案
linux·运维·人工智能·算法·vr·dsp开发·mr
赖small强13 小时前
【Linux驱动开发】NOR Flash 技术原理与 Linux 系统应用全解析
linux·驱动开发·nor flash·芯片内执行
IT运维爱好者14 小时前
【Linux】LVM理论介绍、实战操作
linux·磁盘扩容·lvm
LEEE@FPGA14 小时前
ZYNQ MPSOC linux hello world
linux·运维·服务器
郝学胜-神的一滴14 小时前
Linux定时器编程：深入理解setitimer函数
linux·服务器·开发语言·c++·程序人生
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践04React CVE-2025-55182漏洞排查与修复指南05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06BongoCat - 跨平台键盘猫动画工具07UV安装并设置国内源08打造高效订单处理！ZKmall开源商城的统一履约中心架构解析09本地部署阿里最新开源的Z-Image10Linux下V2Ray安装配置指南