【Linux篇】信号从哪来?到哪去?—— Linux信号的产生方式与保存机制

📌 个人主页: 孙同学_

🔧 文章专栏: Liunx

💡 关注我,分享经验,助你少走弯路!

文章目录

    • [一. 认识信号](#一. 认识信号)
    • [二. 产生信号的方式](#二. 产生信号的方式)
      • [2.1 键盘产生信号](#2.1 键盘产生信号)
      • [2.2 系统调用](#2.2 系统调用)
      • [2.3 硬件异常产生信号](#2.3 硬件异常产生信号)
      • [2.4 软件条件产生信号](#2.4 软件条件产生信号)
    • [三. 信号的保存](#三. 信号的保存)
      • [3.1 信号其他的相关常见概念](#3.1 信号其他的相关常见概念)
      • [3.2 这些概念在内核中的表现](#3.2 这些概念在内核中的表现)
      • [3.3 sigset_t](#3.3 sigset_t)
      • [3.4 信号集操作函数](#3.4 信号集操作函数)
        • [3.4.1 sigprocmask](#3.4.1 sigprocmask)
        • [3.4.2 sigpending](#3.4.2 sigpending)

一. 认识信号

首先我们应该知道信号和信号量之间没有任何关系。

生活中的信号比如说:闹钟,红绿灯,上课铃声,狼烟,电话铃声,肚子叫,脸色等。

闹钟响了我们就得起床,上课铃声响了我们就得进教室进行上课,狼烟起来了士兵们就知道要打仗了,电话铃声响了我们就知道来电话了,肚子叫我们就知道我们的肚子饿了,一个人的脸色不好,我们就能直到他可能生气了。

什么是信号?中断我们人正在做的事情,是一种事件的异步通知机制

其实进程就相当于我们的人,当进程收到信号时,进程就要中断进程正在做的事情,这种方式就叫做信号,所以信号是给进程发送的,用来进行事件异步通知的机制

  • 信号的产生相对于进程的运行是异步的
  • 信号是发给进程的

基本结论:

  1. 信号处理在信号没有产生时就知道该如何处理了
  2. 信号的处理不是立即处理,可以等一会再处理,在合适的时候进行处理
  3. 人能识别信号前提是被"教育"过的(红灯亮了要等一等),进程也是如此,OS程序员设计的进程,进程早已经内置的对于信号的识别和处理方式!
  4. 信号源是非常多的,给进程产生信号的信号源也非常多

二. 产生信号的方式

2.1 键盘产生信号

我们先编写一段代码testSig.cc

cpp 复制代码
#include <iostream>
#include <unistd.h>
int main()
{
    while(true)
    {
        std::cout << "Hello world" << std::endl;
        sleep(1);
    }

    return 0;
}

当这段代码运行起来后我么想终止,我们可以使用ctrl + c,但为什么ctrl + c可以终止呢?

因为ctrl + c是给目标进程发送信号的。相当一部分信号的处理动作就是让进程自己终止。

查看linux中的信号列表

指令:kill -l

在我们计算机中,信号就是一个整数的数字,我们未来想要用进程的话,可以用该数字向目标进程发送信号,但是数字的可读性不是很好,未来我们在使用的时候,会把数字定义成为大写的字母宏 ,该宏对应的值就是前面匹配的数字。

在Linux系统里一共有62和信号,从34到64这部分信号称为实时信号,这种信号往往一旦产生就需要立即处理。

而我们上面的ctrl + c就是通过键盘给目标进程发送2号信号。

进程收到信号的处理方式:

1.默认动作处理

2.自定义动作处理

3.忽略处理!

更改一个信号的默认处理动作:signal

cpp 复制代码
       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);
  • 参数
    • signum:信号对应的数字
    • handler:返回值为void,参数为int的函数

信号不再执行默认的方法,反而执行自定义的函数中指针指向的方法。

案例:将2号信号的默认处理改成打印:"获得了一个信号:" << sig

cpp 复制代码
#include <iostream>
#include <unistd.h>
#include <signal.h>

void headlerSig(int sig)
{
    std::cout << "获得了一个信号:" << sig << std::endl;    
}

int main()
{
    signal(SIGINT,headlerSig);
    int cnt = 0;
    while(true)
    {
        std::cout << "Hello world: " << cnt++ << std::endl;
        sleep(1);
    }

    return 0;
}

当我们ctrl + c的时候就会发现,此时的ctrl + c不再是终止,而是打印出这段话。

此时我们想终止的话可以用ctrl + \3号信号来终止。

查看所有信号的额默认处理:man 7 signal

我们上面说过,信号是发送给目标进程的,可是目标进程是谁呢?

前台进程和后台进程

 当我们在命令行直接./XXX运行时,这种进程叫做前台进程 ;当我们直接在命令行./XXX &,这叫做后台进程。

当我们没有启动任何程序的时候,我们的系统里有一个进程一直在给我们提供的服务,这个进程叫做命令行shell进程,命令行shell进程就是在前台的。

当我们的进程是后台进程时,我们ctrl + c无法处理我们的信号,所以键盘产生的信号只能发送给前台进程。

我们再来谈谈前后台的问题:

当我们登陆Linux系统,不管我们是拿桌面登录还是拿Xshell登陆,Linux系统首先会帮我们创建一个进程,这个进程叫做shell,在ubuntu下这个进程叫做bash进程,这个bash进程首先会输出命令行,然后等待用户输入。当我们./xxx它就会创建一个子进程,这个进程是前台进程,前台进程能从标准输入(键盘)中获取内容,后台进程是相反的。但是不管是前台进程还是后台进程,它们两个都能向标准输出上打印。

前台进程只能有一个,后台进程可以有多个。

前台进程的本质是从键盘上获取数据的。

我们以前的父进程退出,子进程ctrl + c就杀不掉了,原因是父进程退出了子进程就变成了孤儿进程,被自动提到后台了,所以只能用kill杀掉。

jobs查看所有的后台任务
fg + 任务号:表示把特定的进程提到前台
ctrl + z:暂停进程

前台进程不能被暂停,因为前台进程永远要接收用户输入

所以一个进程一旦被暂停,就会被自动提到后台

让暂停的进程运行起来:bg + 任务号,但是此时运行起来的进程是后台进程

什么叫做给进程发送信号?

信号产生之后并不是立即处理的,所以进程要把接收到的信号记录下来。记录的目的是为了在合适的时候处理。

记录在哪里?

进程的struct task_struct

如何记录?

在进程的pcb里维护一个整数,位图结构,用比特位的位置表示信号编号,用内容表示是否收到信号。
发送信号的本质是向目标进程写信号,本质上是修改位图 (需要两个东西,一个是进程的pid,一个是信号的编号)
task_struct舒徐操作系统内的数据结构对象,所以修改位图的本质是修改内核的数据。

不管信号怎么产生,发送信号在底层必须让给OS发送。所以操作系统必须提供发送信号的系统调用。kill命令是用c语言写的,它调的就是操作系统的系统调用接口,来完成对目标进程发信号。

信号 VS 通信IPC

狭义上讲,通信IPC和信号不一样

2.2 系统调用

给目标进程发送信号的系统调用:kill

原型

cpp 复制代码
       #include <sys/types.h>
       #include <signal.h>

       int kill(pid_t pid, int sig);

代码示例:
Makefile

cpp 复制代码
.PHONY:all
all:testsig mykill

testsig:testSig.cc
	g++ -o $@ $^ -std=c++11
mykill:mykill.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -f testsig mykill

mykill.cc

cpp 复制代码
#include <iostream>
#include <sys/types.h>
#include <signal.h>

//./mykill signumber pid
int main(int argc,char *argv[])//命令行参数
{
    if(argc != 3)
    {
        std::cout <<  "./mykilee signumber pid" << std::endl;
        return 1;//退出码设置为1
    }
    int signum = std::stoi(argv[1]); //给进程发送几号信号
    pid_t target = std::stoi(argv[2]); //给哪个进程发送信号

    int n = kill(target,signum);//给哪个进程发,发什么
    if(n == 0)//发送成功
    {
        std::cout << "send" << signum << "to" << target << "success";
        return 0;
    }

    return 0;
}

testSig.cc

cpp 复制代码
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

void headlerSig(int sig)
{
    std::cout << "获得了一个信号:" << sig << std::endl;    
}

int main()
{
    signal(SIGINT,headlerSig);
    int cnt = 0;
    while(true)
    {
        std::cout << "Hello world: " << cnt++ <<",pid"<< getpid() << std::endl;
        sleep(1);
    }

    return 0;
}

我们的信号大部分都是可以自定义捕捉的,但是有一个信号不能自定义捕捉,这个信号是9号信号SIGKILL,所以9号信号不能被自定义捕捉。

产生信号的第二个系统调用:raise

cpp 复制代码
       #include <signal.h>

       int raise(int sig);

raise表示自己给自己发送信号,raise可以指明自己给自己发送哪一个信号

cpp 复制代码
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

void headlerSig(int sig)
{
    std::cout << "获得了一个信号:" << sig << std::endl;
}

int main()
{
    for (int i = 1; i < 32; i++)
        signal(i, headlerSig); // 捕捉所有信号
    for (int i = 1; i < 32; i++)
    {
        //每隔1秒自己给自己发一个信号
        sleep(1);
        raise(i);
    }

        int cnt = 0;
    while (true)
    {
        std::cout << "Hello world: " << cnt++ << ",pid" << getpid() << std::endl;
        sleep(1);
    }

    return 0;
}

到9号信号停了下来原因是9号信号不能被捕捉。

第三个系统调用:abort(其实不属于系统调用)
abort也是自己给自己发送信号,这个信号要求进程必须处理,它是用来终止进程的

2.3 硬件异常产生信号

先说问题:我们在执行C/C++代码时,我们的程序有时会崩掉,一种叫做除0,一种叫做野指针。

我们的代码里要是有除0错误代码就会崩掉是因为进程收到了8号信号(SIGFPE)。

我们的代码中要是有野指针,就会收到11号信号(SIGSEGV)。段错误

信号全部都是由操作系统发送的,我们的程序出错了,操作系统会识别我们的进程犯错了并且分析犯错类型,然后向我们的目标进程发送信号,整个过程其实和我们的用户是没有关系的。

现在的核心问题是操作系统怎么知道我们的进程犯错了???

  • 操作系统怎么知道我们的程序除0了?
    除0运算本质是在CPU上运行的,CPU上有各种的寄存器,比如标志寄存器(EFLAGS)这个寄存器是若干个比特位,比如000100,有一个比特位表示我们CPU当前计算时是否出现溢出。换句话说我们的操作系统怎么知道CPU计算出问题了呢?
    答案是我们的CPU属于硬件,操作系统是软硬件资源的管理者,当我们的程序一旦出错,操作系统是能识别到是硬件上出错了的,然后它这个计算是溢出了的,而我们的CPU寄存器保存的是当前进程的上下文,当然也包括当前进程的task_struct,它的硬件上出错了,所以操作系统就能识别到哪一个进程出错了,操作系统转而给我们的目标进程发送对应的信号。
  • 操作系统怎么知道野指针(段错误)的问题?
    我们在拿野指针访问0号地址,则进程的虚拟地址就是0,而0号地址在我们的页表中并不存在映射关系,所以无法映射到我们的内存当中,CPU中存在的地址都是虚拟地址,在我们的CPU内部存在着一个寄存器叫做CR3寄存器,这个寄存器会记录下当前页表的起始地址。在CPU内部继承了一种硬件单元,这个硬件单元叫做MMU,将来CPU寻址是将虚拟地址交给MMU,把CR3寄存器里的内容也交给MMU,此时虚拟地址有了,页表有了,MMU在硬件层面上拿着对应的页表完成虚拟地址到物理地址的转化。
    MMU在转化时也有可能转化失败,此时再往0号地址去写就会发生硬件报错。操作系统作为软硬件资源的管理者,硬件报错了,当前运行的依旧是当前进程的上下文,并且知道当前错误是虚拟到物理转化失败了,并且还要写入,所以就会给当前进程发送11号信号,让进程直接终止。

2.4 软件条件产生信号

存在一个系统调用,为当前进程设置闹钟:alarm

当闹钟时间到了的时候,它就会为当前进程推送一个信号。

比如alarm(5)定一个5秒的闹钟,5秒之后它就会为当前进程发送一个信号。alarm(0)表示取消闹钟。

cpp 复制代码
       #include <unistd.h>

       unsigned int alarm(unsigned int seconds);

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

  • 返回值
    这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。

我们来设定一种闹钟,这个闹钟1秒钟发送一个闹钟信号,此时进程就执行某种任务。以闹钟为驱动力,让进程每隔1秒做一次,每隔1秒做一次。

cpp 复制代码
#include<iostream>
#include<unistd.h>
#include<signal.h>
#include<sys/types.h>

void handlerSig(int sig)
{
    std::cout<<"获得了一个信号" << sig << "pid:" << getpid() << std::endl;
    alarm(1);
}
int main()
{
    signal(SIGALRM,handlerSig);
    alarm(1);

    while(true)
    {
        std::cout << ".," << "pid:" << getpid() << std::endl;
        sleep(1);
    }
    return 0;
}

等待一个信号的接口:pause

cpp 复制代码
       #include <unistd.h>

       int pause(void);

pause的作用是等待一个信号,也就是没有信号时pause就暂停了,只有当我们的信号被捕捉,并且从信号捕捉函数返回的时候它才会直接返回。出错的时候会返回-1,否则就会暂停起来。

我们让我们的进程每隔一秒完成一些任务

让我们的进程一直处于暂停状态,受外部信号的驱动每隔一秒发送一个信号,信号到来时它会执行对应的任务,这就是操作系统的本质

cpp 复制代码
#include <iostream>
#include <vector>
#include <functional>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

///////func/////////

void Sche()
{
    std::cout << "我是进程调度" << std::endl;
}

void MemManger()
{
    std::cout << "我是周期性的内存管理,正在检查有没有内存问题" << std::endl;
}

void Fflush()
{
    std::cout << "我是刷新程序,我在定期刷新内存数据" << std::endl;
}

////////////////////

using func_t = std::function<void()>; // 用来存储没有返回值且没有参数的函数
std::vector<func_t> funcs;          // 这个容器中包含了一堆方法

// 每隔一秒,完成一些任务
void handlerSig(int sig)
{
    std::cout << "#########################" << std::endl;
    for(auto f : funcs)
    {
        f();
    }
    std::cout << "#########################" << std::endl;
    alarm(1);
}

int main()
{
    funcs.push_back(Sche);
    funcs.push_back(MemManger);
    funcs.push_back(Fflush);

    signal(SIGALRM, handlerSig);
    alarm(1);

    while (true) //操作系统的本质! 
    {
       pause();
    }
    return 0;
}

快速理解闹钟:

OS内可能同时存在很多闹钟,所以操作系统就要对闹钟进行管理。所以所谓的闹钟就是一种数据结构,创建闹钟就是创建一种闹钟的结构体对象。

下面这就是一个闹钟的描述结构:

cpp 复制代码
struct timer_list
{
    struct list_head entry;
    unsigned long expires;    //闹钟自己的过期时间
    void (*function)(unsigned long);//闹钟要执行的方法
    unsigned long data;
    struct tvec_t_base_s *base;
};

我们之前学过数据结构中的堆,我们设置的闹钟是以最小堆的方式,即堆顶元素为最短超时的闹钟,通过和时间戳做比较,如果堆顶元素的时间小于了我们的时间戳,则堆顶的闹钟出堆,向目标进程发送信号,执行对应的SIGALRM。

所以闹钟超时之后,向目标进程发送信号的这种方式,叫做软件条件产生信号。

总结:上面产生信号的五中方式当中,不论哪一种方式,都是由OS进行信号的发送的。所谓的信号发送其实是向目标进程修改比特位。

三. 信号的保存

我们上面就已经说过了,进程接受到信号不一定立即处理,所以前提就先得保存信号。

3.1 信号其他的相关常见概念

  • 实际执行信号的处理动作称为信号抵达(Delivery)。
  • 信号从产生到信号抵达中间的的状态称为信号未决(Pending)。
  • 进程可以选择阻塞(Block)某个信号,我们把阻塞信号也叫做屏蔽信号。
  • 被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行抵达的动作。
  • 注意,忽略和信号阻塞是不同的,忽略是信号抵达状态时一种可选择的执行信号的方式。

3.2 这些概念在内核中的表现

在进程的PCB中不仅仅有位图,其实进程当中与普通信号相关的有三张表,block表pending表handler表。

pending:(unsigned int pending)表其实就是保存我们信号收到的位图,也叫做未决图。

  • 比特位的位置:表示的是第几个信号
  • 比特位的内容:是否收到信号,0表示未收到该信号,1表示收到了该信号

block:(unsigned int block)也是位图。

  • 比特位的位置:表示的是第几个信号
  • 比特位的内容:是否阻塞,0表示可以直接抵达,1表示不能直接抵达


pending&(~block):表示可以直接抵达的信号

handler:我们之前用的系统调用signal,它里面的一个参数就是handler

这个表是一个函数指针数组。这个表的下标表示的就是信号编号。

所以我们的signal函数的本质就是在系统调用的内部,拿着我们传进去的信号编号作为该数组的索引,找到特定的位置,把我们自己设置的函数的地址传进去。

所以当前有没有信号,有没有被阻塞,怎么处理我们就知道了。这三张表合起来,共同承担了进程怎么识别信号。

回到最开始我们说的,信号再没抵达时我们就知道该信号如何处理了,即便是没有block,pending,我们也知道它的handler是SIG_DFL默认处理动作,进程未来处理信号的方式本质上就是修改handler表

所以我们应该如何看待信号的处理呢?

我们应该横着来看这张表,从上往下对应了31组描述信号的关系。这3这表支撑了进程对信号的识别。

3.3 sigset_t

从上图来看,每个信号只有一个比特位的未决标志,即非0即1,不记录信号产生了多少次,阻塞信号也是这样的。因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示信号的"有效"或者"无效"状态。在阻塞信号集中"有效"和"无效"的含义是该信号是否被阻塞,在未决信号集中,"有效"和"无效"表示该信号是否处于未决状态。

阻塞信号集也叫当前进程的信号屏蔽字(Signal Mask),这里的"屏蔽"应该理解为阻塞而不是忽略。

3.4 信号集操作函数

sigset_t类型对于每种信号用一个比特位表示"有效"或者"无效"状态,至于内部如何存储这些比特位依赖于系统的实现,从使用者的角度是不关心的,使用者只需要调用下面的函数来操作sigset_t变量,而不需要对它的内部做任何解释。

cpp 复制代码
#include <signal.h> 
int sigemptyset(sigset_t *set); //表示把其中一个信号集清空
int sigfillset(sigset_t *set); //把位图全部置1
int sigaddset(sigset_t *set, int signo); //把一个信号添加到集合里(这个信号是几,就把其比特位置1)
int sigdelset(sigset_t *set, int signo); //把一个信号删掉(比特位置0)
int sigismember(const sigset_t *set, int signo);//判断一个信号是否在集合里(其实就是判断第几个比特位是否为1)
  • sigemptyset:函数sigemptyset用来初始化set所指向的信号集,使其中所有信号的对应比特位清零,表示该信号集不包含任何有效信号。
  • sigfillset:函数sigfillset用来初始化set所指向的信号集,使其中所有信号的对应比特位全部置1,表示该信号集包含所有信号。
  • 注意:在使用sigset_t变量之前,一定要调用sigemptyset或者sigfillset初始化,使信号集处于确定状态。初始化sigset_t后,就可以调用sigaddset和sigdelset在信号集中添加或者删除某种有效信号了。
3.4.1 sigprocmask

调用函数sigprocmask可以读取或者更改进程的信号屏蔽字(阻塞信号集)

哪一个进程调用这个函数就是在设置或者更新自己的block表

  • 参数
    • how:表示你想做什么操作

      sig_block:表示把传进来的设置为1的信号新增到block表中,如果已经屏蔽了就继续屏蔽,没有屏蔽的信号设置成屏蔽
      sig_unblock:表示把已经屏蔽的信号设置为未屏蔽的
      sig_setmask:表示未来自己定义的信号集,把整个block表全部更新一遍
    • 第二个参数是未来我们用户自己传入的sigset_t类型(输入型)
    • 第三个参数是一个输出型参数,在我们改block之前把旧的block带出去,这样如果我们就可以恢复到之前的block
  • 返回值
    设置成功0被返回,否则-1被返回
3.4.2 sigpending
cpp 复制代码
       #include <signal.h>

       int sigpending(sigset_t *set);

这个函数是用来获取当前进程的pending信号集的,这个参数是一个输出型参数

demo代码: 先将2号信号屏蔽,然后不断获取pending表,不断打印,再向目标进程发送2号信号,因为2号信号不会被立即抵达(执行),只是pending表由0变1,不执行对应的操作,所以我们才能看到信号由0变为1的过程。

cpp 复制代码
#include <iostream>
#include <cstdio>
#include <vector>
#include <functional>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

void PrintPending(sigset_t &pending)
{
    printf("我是一个进程(%d),pending:", getpid());
    // 遍历所有信号
    for (int signo = 31; signo >= 1; signo--) // 先打印出来的第一个比特位是最高位
    {
        // 判断指定信号是否在当前集合里
        if (sigismember(&pending, signo))
        {
            std::cout << "1";
        }
        else
        {
            std::cout << "0";
        }
    }
    std::cout << std::endl;
}
void handler(int sig)
{
    std::cout << "抵达" << sig << "信号!" << std::endl;
}

int main()
{
    signal(SIGINT, handler);
    // 1.屏蔽2号信号
    sigset_t block, oblock;
    sigemptyset(&block); // 将信号集清空
    sigemptyset(&oblock);

    // 将2号信号添加到信号集中
    sigaddset(&block, SIGINT);

    // 将32个信号全部添加到信号集当中
    // for(int i = 1; i < 32; i++)
    // sigaddset(&block,i);

    int n = sigprocmask(SIG_SETMASK, &block, &oblock);
    (void)n; // 防止出现n只有定义但并没有被使用

    // 4. 重复获取打印过程
    int cnt = 10;
    while (true)
    {
        // 2.获取pending信号集
        sigset_t pending;
        int m = sigpending(&pending);

        // 3.打印
        PrintPending(pending);
        if (cnt == 0)
        {
            // 5.恢复对2号信号的block情况
            std::cout << "解除对2号信号的屏蔽" << std::endl;
            sigprocmask(SIG_SETMASK, &oblock, nullptr);
        }

        sleep(1);
        cnt--;
    }
    return 0;
}

在这个过程中我们会发现一个现象,我们要是把所有信号都屏蔽的话,那么这个进程就有了"金刚不坏之身了",这个进程要是病毒的话那岂不是完蛋了!但是由实验现象可以知道,9号信号是不能被屏蔽的。所以9号信号不可被捕捉,不可被阻塞!!!

pending表中的由1变0,是在handler执行之前变的还是handler执行之后变的。

结论是:当我们准备抵达的时候,首先要清空pending信号集中的对应的位图 1 -> 0。(在抵达之前由1变0)

🌵补充细节问题: 我们保存信号用的是pending位图,pending位图用一个比特位来表示是否收到,那如果将来有一种信号产生很多次该怎么办呢?

比如说今天向目标进程发了一百个2号信号,因为进程不一定是对信号做立即处理的,此时的普通信号该怎么处理呢?Linux中是这样设计的,常规信号在抵达之前产生多次只记录一次,而实时信号在抵达之前产生多次,可以一次放在一个队列里。

🍒信号终止进程的方式有两种,core,term

core 🆚 term
core是核心的意思,如果一个进程以core退出,往往会在当前路径下形成一个文件,进程异常退出的时候,进程在内存中的核心数据会从内存拷贝在磁盘,形成一个文件,称为核心转储 ,只要是为了支持debug调试的。
term是进程因为异常而退出,但是term不做任何转储功能,直接退出

注意:在我们的云服务器上 core dump功能是被禁止掉的。

为什么要禁止掉?

未来如果我们的程序发生错误,core dump是要在当前路径下形成一个文件的,如果我们的程序挂一次,它形成一个文件,挂一次,形成一个文件就很容易把我们的磁盘打满。

如何查看?

ulimit -a ,其中有一个core file size为0表示关闭

如何打开?

ulimit -c (临时方案)

为什么要进行核心转储?

答案是:为了支持debug

如果我们未来在找bug找不到,我们可以开启core dump,直接让程序运行崩溃,gdb,core-file core,直接帮助我们来定位到出错行。(事后调试)

我们之前的进程等待,次低8位代表的是进程退出时的退出码,低7位表示的是该进程退出时的退出信号,一个进程在退出的时候如果信号为0表示正常退出的(因为信号是从1-31的,没有0号信号)。除了次低8位和低7位,还有一个标志位就是core dump标志位,表示是否core dump


👍 如果对你有帮助,欢迎:

  • 点赞 ⭐️
  • 收藏 📌
  • 关注 🔔
相关推荐
无忧.芙桃7 小时前
Linux系统编程(四):用户与权限管理
linux·运维·服务器
最强小杰8 小时前
某 OpenAI 兼容网关上的 `kimi-k3.1-pro`:Cline、Zed 接入与 SSE 排错示例
java·服务器·网络·ai
谙弆悕博士10 小时前
多智能体架构详解:层级树状架构(分级主从型)
运维·架构·大模型·agent·多智能体·langgraph·层级树状
戊本菌10 小时前
进程(三)进程优先级:谁先上 CPU
linux·c语言·硬件架构
aningx11 小时前
Arch 系用 greetd 实现开机自动进 Plasma Wayland,注销自动回桌面
linux
张小姐的猫12 小时前
【基于 WebSocket 的多用户网页五子棋】—— 整合封装服务器模块设计实现2️⃣
服务器·websocket·网络协议
江无行者12 小时前
Linux 服务器 top 命令详解
linux
HMS工业网络12 小时前
工业远程访问的五项安全部署原则
运维·服务器·安全
吴建旭 智宅焕13 小时前
智能家居全国交付中执行端能力评估与分级调度架构设计:从注册数量到交付确定性的系统实现
运维·智能家居·devops
嵌入式 Linux手记14 小时前
一块内存,三种解释:union 的真实用法
linux·c语言·驱动开发·嵌入式