信号【Linux】

news/2024/11/14 9:26:26/

文章目录

1、信号就算没有产生，进程也必须识别和能够处理信号，要具备处理信号的能力，信号的处理能力，属于进程内置功能的一部分
2、当进程收到一个具体的信号时，进程可能并不会立即处理这个信号，在合适的时候处理信号

3、当信号产生，到信号开始被处理，这段时间，哪些信号已经产生，进程必须知道

信号处理方式（信号递达）

信号处理方式：
1、进程内置了对信号的处理，默认动作
2、进程可以忽略信号
3、自定义动作，会更改进程内置的默认动作，比如：信号的捕捉

信号捕捉 ，会将信号的默认处理方式修改,比如一个信号本来默认处理方式是终止进程并退出进程，信号捕捉之后该信号的默认处理方式被修改，会出现只捕捉而不退出进程了

signal,修改特定进程对于信号的处理动作的

 typedef void (*sighandler_t)(int);sighandler_t signal(int signum, sighandler_t handler);

handler这个参数是自定义的动作

前后台进程

关于前后台进程：
前台进程：能获取键盘输入

后台进程：不能获取键盘输入

./myprocess & ，加了& ,就变成后台进程了

[cxq@iZwz9fjj2ssnshikw14avaZ lesson31]$ ll
total 36
-rw-rw-r-- 1 cxq cxq    90 Jul 15 22:41 Makefile
-rwxrwxr-x 1 cxq cxq 26440 Jul 15 15:31 myprocess
-rw-rw-r-- 1 cxq cxq   443 Jul 15 22:41 mysignal.cc
-rw-rw-r-- 1 cxq cxq     0 Jul 14 16:59 test.c
[cxq@iZwz9fjj2ssnshikw14avaZ lesson31]$ ./myprocess &

Linux中，一次登陆中，一个终端，一般会配上一个bash，每一个登陆，只允讲一个进程是前台进程，但是可以允许多个进程是后台进程

终端按键产生信号

ctrl +c为什么能够杀掉我们前台进程？

ctrl +c产生的信号只能发给前台进程， ctrl +c本质是被进程解释成为收到了信号，2号信号

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

信号的产生和我们自己的代码的运行时异步的 ,
异步：代码在运行时，信号什么时候产生是不清楚的，代码不用管信息什么时候产生，代码继续运行就可以了

ctrl +c : 2号信号

#include<iostream>
#include<stdio.h>#include <signal.h>#include<unistd.h>
using namespace std ;void myhandler(int signo)
{cout << "process get a signal: " << signo <<endl;// exit(1);
}
int main()
{
//捕捉 2号信号signal(2 , myhandler);//myhandler是函数指针//signal只需要设置一次，往后都有效//信号的产生和我们自己的代码的运行时异步的 ,异步：代码在运行时，信号什么时候产生是不清楚的，代码不用管信息什么时候产生，代码继续运行就可以了while(true){cout << "I am a crazy process : " << getpid() << endl;sleep(1);}return 0 ;
}

ctrl + : 3号信号
不是所有的信号都是可以被signal捕捉的，比如:19 （暂停进程）， 9（杀死进程）

kill系统调用接口向进程发信号

kill给pid进程发sig信号

int kill(pid_t pid, int sig);

#include<iostream>
#include<stdio.h>#include <signal.h>#include<unistd.h>#include <stdlib.h>#include<string>
using namespace std ;
void Usage(string proc)
{cout << "Usage:\n\t" << proc << " signum pid\n\n";
}//   mykill signum pidint main(int argc ,char* argv[]) //命令行参数
{//告诉用户如何使用if(argc !=3){Usage(argv[0]);exit(1);}string signumStr(argv[1]);string pidStr(argv[2]);int signum = stoi(signumStr); pid_t pid = stoi(pidStr);int n =kill(pid,signum); if(n == -1){   perror("kill");exit(2);}return 0 ;
}

raise：发送一个信号给调用者

  int raise(int sig);

举例：

#include<iostream>
#include<stdio.h>#include <signal.h>#include<unistd.h>#include <stdlib.h>#include<string>
using namespace std ;
void myhandler(int signo)
{cout << "process get a signal: " << signo <<endl;//   exit(1);
}
int main()
{int cnt =5 ;signal(2,myhandler); //捕捉2号信号while (true){cout << "I am a process, pid: " << getpid() << endl;sleep(1);cnt--;if(cnt== 0) {raise(2);  //等价于 kill(getpid() , 2) }}return 0 ;
}

abort 发送6号信号和终止进程

       void abort(void);

信号产生的方式，但是无论信号如何产生，最终操作系统发送给进程，因为操作系统是进程的管理者

alarm ，设置一个闹钟

 unsigned int alarm(unsigned int seconds);

return val:
alarm 函数返回的是之前设置的定时器的剩余时间。如果之前没有设置定时器，或者定时器已经到期，返回 0。
返回的剩余时间是指在调用新的 alarm 之前，定时器还有多少秒才会发送 SIGALRM 信号。

#include <iostream>#include <unistd.h>#include <signal.h>using namespace std;
void myhandler(int signo)
{cout<<"xxxxxxxxxx"<<signo<<endl;//理解alarm的返回值int n = alarm(3);cout<<"剩余时间："<<n<<endl;//exit(1);
}int main()
{int n = alarm(50);//alarm发送的是14号信号signal(14,myhandler);//myha ndler是一个函数指针while(1){cout << "proc is running  pid :%d" <<" "<<getpid()<< endl;sleep(1);}return 0 ;
}

打开系统的core dump （核心转储）功能，一旦进程出异常，操作系统会将进程在内存中的运行信息，给转诸到进程的当前目录，并形成core.pid文件

ulimit ：显示和设置用户可以启动的进程的资源限制

[cxq@iZwz9fjj2ssnshikw14avaZ output]$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 6943
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 65535
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 4096
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

打开系统的core dump （核心转储）功能，将core file size 设置为10240

[cxq@iZwz9fjj2ssnshikw14avaZ output]$ ulimit -c 10240
[cxq@iZwz9fjj2ssnshikw14avaZ output]$ ulimit -a
core file size          (blocks, -c) 10240
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 6943
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 65535
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 4096
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

测试 core dump功能

#include <iostream>#include <unistd.h>#include <signal.h>#include <sys/types.h>#include <sys/wait.h>
using namespace std;
int main()
{//测试  core dump功能cout << " a = " << a << endl;pid_t id = fork();if(id==0){//childint cnt = 500;while(cnt){cout << "i am a child process, pid: " << getpid() << "cnt: " << cnt << endl;sleep(1);cnt--;}exit(0);}//father //进程等待int status =0 ;pid_t rid=waitpid(id,&status,0);//阻塞等待if(rid==id){cout << "child quit info, rid: " << rid << " exit code: " << ((status>>8)&0xFF) << " exit signal: " << (status&0x7F) <<" core dump: " << ((status>>7)&1) << endl; //  (0000 0000 ... 0001)}return 0 ;
}

在这里插入图片描述
生成的core.pid文件，可以通过gdb直接定位到出错行
在这里插入图片描述

阻塞信号

信号常见概念
1、实际执行信号的处理动作，称为信号递达（Delivery）。
例：进程内置了对信号处理的默认动作、进程可以忽略信号、还是自定义动作 这些都是信号的处理动作，都是信号递达

2、信号从产生到递达之间的状态，称为信号未决（pending）。
信号从产生到递达之前，此时信号处于位图中，此时信号处于保存状态 ，这种状态称为信号未决

3、进程可以选择阻塞（Block）某个信号。这里的阻塞可以理解为屏蔽

  • 默认情况下，所有信号都是没有被屏蔽的 ， 进程可以屏蔽某些信号，在解除屏蔽之前，信号 也不会被操作系统进行递达

  • 如果进程没有收到某一个信号，也可以屏蔽这个信号

4、被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。

  • 一个信息如果被阻塞了（屏蔽），如果此时用户向进程发送了指定的信号，该信号不会被递达，直到解除了阻塞 ，也就是说阻塞了还是可以给进程发送信号，只不过信号暂时被屏蔽罢了

5阻塞和忽略是完全不同的，只要信号被阻塞就不会递达，而忽略是在递达之后的一种处理动作

  • 只要信号被阻塞就不会递达，即不会被处理，屏蔽和解决屏蔽一定是在递达之前做的
  • 忽略的本质是处理信号，忽略是信号递达的三种方式之一，忽略是在递达之后的一种处理动作
  • 阻塞可以理解为未读，忽略可以理解为已读不回

block表：.比特位的内容是1还是0，表明是否屏蔽信号
比特位的位置(第几个)，表示信号的编号

pending表：
比特位的内容是1还是0，表明是否收到信号
比特位的位置(第几个)，表示信号的编号
handler表：
handler表本质上是一个函数指针数组，数组的下标代表某一个信号，数组的内容代表该信号递达时的处理动作，处理动作包括默认、忽略以及自定义
block、pending和handler这三张表的每一个位置是一一对应的
在这里插入图片描述

  • 每个信号都有两个标志位分别表示阻塞（block）和未决（pending），还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。在上图中，SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作。
  • SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会在改变处理动作之后再接触阻塞。
  • SIGQUIT信号未产生过，但一旦产生SIGQUIT信号，该信号将被阻塞，它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前，这种信号产生过多次，POSIX.1允许系统递达该信号一次或多次。Linux是这样实现的：普通信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里，这里只讨论普通信号
#include <iostream>#include <unistd.h>#include <signal.h>#include <sys/types.h>#include <sys/wait.h>
using namespace std;
int main()
{//理解handler表的SIG_IGN，SIG_DFL//signal(2,SIG_IGN);//忽略2号信号signal(2,SIG_DFL);//使用2号信号的默认处理方法while(1){cout << "hello signal" << endl;sleep(1);}return  0; 
}

sigset_t

根据信号在内核中的表示方法，每个信号的未决标志只有一个比特位，非0即1，如果不记录该信号产生了多少次，那么阻塞标志也只有一个比特位。因此，未决和阻塞标志可以用相同的数据类型sigset_t来存储

在我当前的云服务器中，sigset_t类型的定义如下：（不同操作系统实现sigset_t的方案可能不同）

typedef __sigset_t sigset_t;

# define _SIGSET_NWORDS	(1024 / (8 * sizeof (unsigned long int)))
typedef struct{unsigned long int __val[_SIGSET_NWORDS];} __sigset_t;

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

  • 在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞。
  • 在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

阻塞信号集也叫做当前进程的信号屏蔽字（Signal Mask），这里的“屏蔽”应该理解为阻塞而不是忽略

#include <signal.h>//sigemptyset、sigfillset、sigaddset和sigdelset函数都是成功返回0，出错返回-1。int sigemptyset(sigset_t *set);//初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号int sigfillset(sigset_t *set);//始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号。int sigaddset(sigset_t *set, int signum);//在set所指向的信号集中添加某种有效信号。int sigdelset(sigset_t *set, int signum);//在set所指向的信号集中删除某种有效信号。int sigismember(const sigset_t *set, int signum);  //判断在set所指向的信号集中是否包含某种信号，若包含则返回1，不包含则返回0，调用失败返回-1。

sigprocmask

sigprocmask ：用于读取或更改进程的信号屏蔽字（阻塞信号集）

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

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

how参数的可选值及其含义: 以下三个只能选一个作为how参数

  • SIG_BLOCK set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask=mask|set
  • SIG_UNBLOCK set包含了我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask=mask|~set
  • SIG_SETMASK 覆盖式的设置当前信号屏蔽字为set所指向的值，相当于mask=set

return val: sigprocmask函数调用成功返回0，出错返回-1。

如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask函数返回前，至少将其中一个信号递达

sigpending

sigpending：用于读取进程的未决信号集，

int sigpending(sigset_t *set);

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

1、将2号信号进行屏蔽（阻塞）。

2、使用kill命令或组合按键向进程发送2号信号。
3、此时2号信号会一直被阻塞，并一直处于pending（未决）状态。
4、使用sigpending函数获取当前进程的pending信号集进行验证
测试代码：

#include<iostream>#include <signal.h>
#include<unistd.h>
using namespace std ;void PrintPending(sigset_t & pending)
{for(int signo = 31 ;   signo>=1 ; signo--){if(sigismember(&pending , signo)  ==1)//判断在set所指向的信号集中是否包含某种信号{//存在cout << "1";}else{//不存在cout << "0";}}// cout << "\n\n";//将光标从当前位置向下移动两行cout<<endl;cout<<endl;}
int main()
{//将2号信号进行屏蔽（阻塞）。
// 使用kill命令或组合按键向进程发送2号信号。
// 此时2号信号会一直被阻塞，并一直处于pending（未决）状态。
// 使用sigpending函数获取当前进程的pending信号集进行验证
sigset_t  bset,oset ;
sigemptyset(&bset);//使bset其中所有信号的对应bit清零
sigemptyset(&oset);//使oset其中所有信号的对应bit清零sigaddset(&bset,2);//在set所指向的信号集中添加2号信号。
sigprocmask(SIG_SETMASK ,&bset, &oset);//把bset覆盖式的设置到进程的block位图中//代码走到这里，已经屏蔽2号信号了//重复打印当前进程的pendingsigset_t pending ;
int cnt =0 ;
while(true)
{// 2.1 获取int n = sigpending(&pending);if (n < 0)continue;// 2.2 打印PrintPending(pending);sleep(1);// 2.3 解除阻塞cnt ++;if(cnt ==20){cout << "unblock 2 signo" << endl;sigprocmask(SIG_SETMASK ,&oset,nullptr);//更改进程的信号屏蔽字,覆盖式的设置当前信号屏蔽字为bset所指向的值}
}return 0 ; 
}

内核态与用户态：

  • 内核态：允许访问操作系统的代码和数据，是一种权限非常高的状态。
  • 用户态：只能访问用户自己的代码和数据，是一种受监管的普通状态。

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

调用系统调用时，操作系统是自动会"身份"切换的 ，从用户身份变成内核身份，或者从内核身份变成用户身份

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

内核空间与用户空间

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

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

在这里插入图片描述

CR3 寄存器存储了页表的起始物理地址，这个地址指向了页全局目录的起始位置

用户页表有几份?
有几个进程，就有几份用户级页表 , 进程具有独立性

内核页表有几份?
1份

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

总结：

  • 每一个进程看到的3到4GB的东西都是一样的
  • 整个系统中，进程再怎么切换，3到4GB的空间的内容是不变的

进程视角:我们调用系统中的方法，就是在我自己的地址空间中进行执行的。

操作系统视角:任何一个时刻，都有有进程执行。我们想执行操作系统的代码，就可以随时执行
在这里插入图片描述

操作系统的本质:基于时钟中断的一个死循环

计算机硬件中，有一个时钟芯片，每个很短的时间，向计算机发送时钟中断

如何理解进程切换？
1、在当前进程的进程地址空间中的内核空间，找到操作系统的代码和数据。
2、执行操作系统的代码，将当前进程的代码和数据剥离下来，并换上另一个进程的代码和数据。
当你访问用户空间时你必须处于用户态，当你访问内核空间时你必须处于内核态

内核如何实现信号的捕捉

当我们在执行主控制流程的时候，可能因为某些情况而陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending的检查。（此时仍处于内核态，有权力查看当前进程的pending位图）

在查看pending位图时，如果发现有未决信号，并且该信号没有被阻塞，那么此时就需要该信号进行处理。

如果待处理信号的处理动作是默认或者忽略，则执行该信号的处理动作后清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，从主控制流程中上次被中断的地方继续向下执行即可

在这里插入图片描述
但如果待处理信号是自定义捕捉的，即该信号的处理动作是由用户提供的，那么处理该信号时就需要先返回用户态执行对应的自定义处理动作，执行完后再通过特殊的系统调用sigreturn再次陷入内核并清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，继续执行主控制流程的代码。
在这里插入图片描述
sighandler和main函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程


http://www.ppmy.cn/news/1499818.html

相关文章

【论文速读】| LLMCloudHunter：利用大语言模型（LLMs）从基于云的网络威胁情报（CTI）中自动提取检测规则

【论文速读】| LLMCloudHunter：利用大语言模型（LLMs）从基于云的网络威胁情报（CTI）中自动提取检测规则

本次分享论文&#xff1a;LLMCloudHunter: Harnessing LLMs for Automated Extraction of Detection Rules from Cloud-Based CTI 基本信息 原文作者&#xff1a;Yuval Schwartz, Lavi Benshimol, Dudu Mimran, Yuval Elovici, Asaf Shabtai 作者单位&#xff1a;Ben-Gurion…
阅读更多...
微服务:网关

微服务:网关

网关 网关,即网络的关口,当一个网络传输到另一个网络时就需要经过网关来实现 数据的路由和转发 以及 数据安全的校验 网关技术实现 SpringCloudGateWay: 基于Spring的WebFlux技术,完全支持响应式编程,吞吐能力更强 SpringCloudGateWay 依赖 <!--网关--><depe…
阅读更多...
【Android】性能实践—编码优化与布局优化学习笔记

【Android】性能实践—编码优化与布局优化学习笔记

编码优化 使用场景 如果需要拼接字符串&#xff0c;优先使用StringBuffer和StringBuilder进行凭借&#xff0c;他们的性能优于直接用加号进行拼接&#xff0c;因为使用加号连接符会创建多余的对象一般情况下使用基本数据类来代替封装数据类型&#xff08;比如int优于Integer&…
阅读更多...
四步实现网站HTTPS访问

四步实现网站HTTPS访问

随着网络安全的重要性日益凸显&#xff0c;HTTPS&#xff08;超文本传输安全协议&#xff09;已成为现代网站的标准配置。HTTPS协议作为HTTP协议的安全版本&#xff0c;通过SSL协议加密数据传输&#xff0c;不仅能保护用户数据的安全&#xff0c;还能提升搜索引擎排名&#xff…
阅读更多...
3U/6U CPCI 系统核心模块，可应用于电力、轨道交通等领域

3U/6U CPCI 系统核心模块，可应用于电力、轨道交通等领域

一、3U CPCI核心模块 提供CPCI系列产品&#xff0c;具有&#xff0c;高性能&#xff0c;应用扩展灵活&#xff0c;X86软件兼容&#xff0c;无风扇设计&#xff0c;宽工作温度范围&#xff0c;长嵌入式生命周期等特点&#xff0c;满足不同客户的需求。 产品特点 Intel Pentium …
阅读更多...
openCv -- 优势

openCv -- 优势

OpenCV（开源计算机视觉库）是一个广泛使用的计算机视觉和机器学习软件框架。它最初由Intel开发，后来由Itseez公司维护，最终于2015年成为非营利组织OpenCV.org的一部分。OpenCV的目的是实现一个易于使用且高效的计算机视觉框架，支持实时视觉应用。 以下是关于OpenCV的一些关…
阅读更多...
聚观早报 | Meta发布Llama 3.1 405B；特斯拉发布二季度财报

聚观早报 | Meta发布Llama 3.1 405B；特斯拉发布二季度财报

聚观早报每日整理最值得关注的行业重点事件&#xff0c;帮助大家及时了解最新行业动态&#xff0c;每日读报&#xff0c;就读聚观365资讯简报。 整理丨Cutie 7月25日消息 Meta发布Llama 3.1 405B 特斯拉发布二季度财报 NVIDIA AI Foundry上线 iPhone 16将改进内部设计 快…
阅读更多...
Python入门------pycharm加载虚拟环境

Python入门------pycharm加载虚拟环境

pycharm虚拟环境配置&#xff1a; 在按照前面的办法&#xff0c;配置好虚拟环境后,如果我们需要到虚拟环境开发&#xff0c;就需要给编译器配置虚拟环境 1.打开编译器&#xff0c;点击右下角的interpreter选项 2. 点击ADD Interpreter,添加虚拟环境 3. 因为我们使用的是原始…
阅读更多...
最新文章

Copyright @ 2022~2023