Was bedeutet Linux-Core?

In Linux bedeutet Core Speicher. Wenn während der Ausführung des Programms eine Ausnahme erkannt wird und das Programm abnormal beendet wird, speichert das System den aktuellen Speicherstatus des Programms in einer Kerndatei, die als „Core Dump“ bezeichnet wird. Dabei handelt es sich auch um einen Informationsspeicherauszug, wenn das Betriebssystem eine Ausnahme erkennt Der aktuelle Prozess verwendet ein Signal, um den Zielprozess über die entsprechenden Fehlerinformationen zu informieren. Zu den gängigen Signalen gehören SIGSEGV, SIGBUS usw. Standardmäßig verfügt der Prozess über einen entsprechenden Verarbeitungsmechanismus, wenn er das entsprechende Signal empfängt.

Die Betriebsumgebung dieses Tutorials: Linux7.3-System, Dell G3-Computer.

Bei der Entwicklung unter Linux hören wir oft, dass Programmierer sagen, dass der Kern meines Programms ausgefallen ist. Solche Probleme treten normalerweise aufgrund von Fehlern auf niedriger Ebene auf, wie z. B. Speicherzugriff außerhalb der Grenzen, Verwendung von Nullzeigern, Stapelüberlauf usw . Wenn das Programm während der Ausführung beendet wird oder abnormal beendet wird, werden Kerndateien generiert, wenn diese Bedingungen erfüllt sind.

Warum kommt es zu Coredump?

Core bedeutet Speicher. Dieses Wort stammt aus dem Material, das vor langer Zeit zur Speichererstellung verwendet wurde, und wird bis heute verwendet, wenn während der Ausführung des Programms eine Anomalie festgestellt wird Wenn das Programm abnormal beendet wird, speichert das System den aktuellen Speicherstatus des Programms in einer Kerndatei, die als „Core Dump“ bezeichnet wird und auch als „Information Dump“ bezeichnet wird. Wenn das Betriebssystem eine Ausnahme im aktuellen Prozess erkennt, benachrichtigt es den Zielprozess Die entsprechenden Fehlerinformationen werden über ein Signal übermittelt. Zu den gängigen Signalen gehören SIGSEGV, SIGBUS usw. Standardmäßig verfügt der Prozess über einen entsprechenden Verarbeitungsmechanismus, wenn er das entsprechende Signal empfängt.
Nehmen Sie Linux als Beispiel. Die roten Kästchen sind als allgemeine Signale markiert. Zuvor ist es am besten, das Speicherlayout des Prozesses zu verstehen Unix- und Linux-Systeme werden etwas anders sein, der Kernel-Speicherplatz wird kleiner sein als bei Linux, insbesondere der Kernel- und Benutzerprozesse verwenden einen separaten Adressraummodus:

Der Speicher Speicherort der Coredump-Datei

Wir wissen, dass im Linux-System bei einem Prozessabsturz der Systemkern die Prozessabsturzinformationen erfasst und dann die Coredump-Informationen des Prozesses in eine Datei schreibt. Der Standarddateiname lautet Kern. Der Speicherort befindet sich im selben Verzeichnis wie das entsprechende ausführbare Programm. Sie können den Speicherort der Kerndatei über den folgenden Befehl anzeigen:

Core_pattern-Format:

%u (Zahl) Tatsächliche UID des gedumpten Prozesses %G (Zahl) Tatsächliche GID des gedumpten Prozesses

%s Anzahl der Signale, die den Dump verursacht haben

%t Zeit des Dumps, ausgedrückt als seit 1970 Anzahl der Sekunden seit dem 1. Monat 00:00:00 +0000 (UTC)
%H Hostname (identisch mit dem von uname(2) zurückgegebenen Knotennamen)

%e Name der ausführbaren Datei (kein Pfadpräfix)

%E Ja Der Pfadname von die ausführbare Datei, wobei Schrägstriche ('/') durch Ausrufezeichen ('!') ersetzt werden.
%C Weiche Ressourcenbeschränkung der Kerndateigröße für den Absturzprozess (seit Linux 2.6.24)


Das folgende Programm kann verwendet werden, um die Verwendung der Pipe-Syntax in der Datei /proc/sys/kernel/core_pattern zu demonstrieren.

#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define BUF_SIZE 1024

int main(int argc, char *argv[])
{
    int tot, j;
    ssize_t nread;
    char buf[BUF_SIZE];
    FILE *fp;
    char cwd[PATH_MAX];

   /* 属性的当前工作目录崩溃的过程*/

    snprintf(cwd, PATH_MAX, "/proc/%s/cwd", argv[1]);
    chdir(cwd);

   /* 将输出写到该目录下的文件"core.info" */

    fp = fopen("core.info", "w+");
	if (fp == NULL)
	{
		exit(EXIT_FAILURE);
	}


   fprintf(fp, "argc=%d\n", argc);
    for (j = 0; j < argc; j++)
	{
        fprintf(fp, "argc[%d]=<%s>\n", j, argv[j]);
	}

   /* 计算标准输入(核心转储)中的字节数*/

    tot = 0;
    while ((nread = read(STDIN_FILENO, buf, BUF_SIZE)) > 0)
	{
        tot += nread;
	}
	
    fprintf(fp, "Total bytes in core dump: %d\n", tot);

   return 0;
}

注意一下： 这里是指在进程当前工作目录的下创建。通常与程序在相同的路径下。但如果程序中调用了chdir函数，则有可能改变了当前工作目录。这时core文件创建在chdir指定的路径下。有好多程序崩溃了，我们却找不到core文件放在什么位置。和chdir函数就有关系。当然程序崩溃了不一定都产生 core文件。

下面通过的命令可以更改coredump文件的存储位置，如下：

echo “|$PWD/core_pattern_pipe_test %p UID=%u GID=%g sig=%s” > 
/proc/sys/kernel/core_pattern

cat /proc/sys/kernel/core_pattern 查看路径已经变为如下：

下面带大家配置永久的core。只要出现内存访问越界、使用空指针、堆栈溢出等情况，都可以在这个目录下查看。

配置 core

1、首先在根目录下建立一个储存coredump文件的文件夹，命令如下：

mkdir /corefile

2、设置产生coredump文件的大小，命令如下：

ulimit -c unlimited

3、 执行以下两条命令：

echo “1” > /proc/sys/kernel/core_uses_pid       //将1写入到该文件里
echo “/corefile/core-%e-%p-%t” > /proc/sys/kernel/core_pattern

将coredump产生的格式制定好写入core_pattern文件，这样当coredump产生时会直接以这种格式存入到根目录下的文件夹corefile中。

4、修改配置文件/etc/profile

vim /etc/profile

添加 ulimit -S -c unlimited > /dev/null 2>&1

执行命令生效该文件

5、 在配置文件/etc/rc.local中最后面添加信息（机器重启时会自动加载该命令）：添加命令：

rm -rf /corefile/*

机器重启时清空该文件夹，由于产生的coredump文件很大，若不清空的话时间长了会将硬盘占满；

再执行以下两条命令：

echo “1” > /proc/sys/kernel/core_uses_pid
echo “/corefile/core-%e-%p-%t” > /proc/sys/kernel/core_pattern

测试
下面写个例子测试一下是否配置好了corefile文件

#include int main(int argc, char *argv[]){ int *p = NULL; *p = 3; return 0; }

编译运行，注意这里需要-g选项编译。

进入前面创建的corefile文件夹：

出现core文件表示完成coredump配置。可以用通过readelf命令进行判断是否是core文件：

Führen Sie gdb aus, um die Kerndatei zu lesen. Der Befehl lautet „GDB-Programm entsprechende Coredump-Datei“. Zu diesem Zeitpunkt geben Sie die GDB-Eingabeaufforderung „(gdb)“ ein. .

Wie Sie dem roten Kästchen-Screenshot entnehmen können, wird das Programm aufgrund von Signal 11 beendet.

Sie können den Aufrufstapel der Funktion über den Befehl bt (backtrace) (oder wo) sehen:

Das heißt, wenn das Programm bis Zeile 6 von test.cpp ausgeführt wird, tritt ein Segfault auf. Der Grund dafür ist, dass es auf einen Nullzeiger zeigt.

Zusammenfassung

Es gibt viele Gründe für den Programm-Coredump. Hier ist eine Zusammenfassung, hauptsächlich der Speicherzugriff von Grenzen, Verwendung von Thread-unsicheren Funktionen, Verwendung von Nullzeigern, Stapelüberlauf usw.

Ich möchte hier sagen, dass man beim Debuggen von Coredump mit GDB meistens nur den intuitiven Grund für den Kern aus der Kerndatei herausfinden kann, im Allgemeinen jedoch den grundlegenderen Grund muss zusammen mit dem Code analysiert werden. Nur aus der Betrachtung des laufenden Kontexts des Prozesses können wir schließen, wo das Problem im Programmcode liegt.

Verwandte Empfehlungen: „

Linux-Video-Tutorial“

Das obige ist der detaillierte Inhalt vonWas bedeutet Linux-Core?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!