Core-Dump-Datei unter Linux
I. Überblick
1.1 Was ist eine Core-Dump-Datei?
Core-Dump-Datei bezieht sich auf die Datei, in der das Betriebssystem Speicherinformationen, Registerstatus, Stack-Informationen usw. des Programms zum Debuggen und Analysieren in der Datei speichert, wenn das Programm abstürzt oder abnormal endet. Die Core-Dump-Datei enthält normalerweise alle Statusinformationen, wenn das Programm abstürzt, was Programmierern helfen kann, die Ursache des Programmabsturzes schnell zu finden und zu beheben.
Die Core-Dump-Datei enthält hauptsächlich die Speicherinformationen des Benutzerbereichs, einschließlich des Benutzerbereichsstapels, des Codesegments, des Datensegments und des Heaps. Wenn ein Prozess aus irgendeinem Grund (z. B. illegaler Speicherzugriff, illegale Anweisung usw.) abnormal beendet wird, kann das Betriebssystem die Speicherinformationen des Prozesses in einer Core-Dump-Datei speichern. Diese Datei kann für das anschließende Debuggen verwendet werden, um die Ursache des Problems zu finden.
Core-Dump-Dateien enthalten in der Regel keine Kernel-Space-Stack-Informationen, da das Betriebssystem aus Sicherheits- und Isolationsgründen keine Kernel-Space-Informationen für Programme im Benutzermodus offenlegt. Daher werden Core-Dump-Dateien hauptsächlich verwendet, um Programmprobleme im User Space zu analysieren, nicht Kernel-Probleme.
1.2 Funktion und Bedeutung der Core-Dump-Datei
Die Rolle der Core-Dump-Datei ist sehr wichtig: Sie kann Programmierern helfen, die Zustandsinformationen zu analysieren, wenn das Programm abstürzt, die Ursache des Programmabsturzes zu lokalisieren und zu beheben. Durch die Analyse der Core-Dump-Datei können Programmierer die Speicherinformationen, den Registerstatus, Stapelinformationen usw. verstehen, wenn das Programm abstürzt, sowie andere Statusinformationen, wenn das Programm ausgeführt wird. Diese Informationen können Programmierern helfen, die Ursache von Programmabstürzen schnell zu finden und die Programmstabilität und -zuverlässigkeit zu verbessern.
1.3 Der Speicherpfad und die Benennungsregeln von Core-Dump-Dateien in Linux
Unter Linux können der Speicherpfad und die Benennungsregeln von Core-Dump-Dateien konfiguriert werden. Standardmäßig wird die Core-Dump-Datei im aktuellen Arbeitsverzeichnis gespeichert, und der Dateiname beginnt mit core, gefolgt von der Prozessnummer. Der Core-Dump-Dateiname des Prozesses mit der Prozess-ID 123 lautet beispielsweise core.123.
Sie können den Speicherpfad und die Benennungsregeln der Core-Dump-Datei angeben, indem Sie die Systemkonfigurationsdatei ändern. Unter Linux werden der Speicherpfad und die Benennungsregeln von Core-Dump-Dateien normalerweise durch die folgenden zwei Dateien bestimmt:
/proc/sys/kernel/core_pattern: Diese Datei gibt die Benennungsregeln und den Speicherpfad der Core-Dump-Datei an. Sie können beispielsweise die Core-Dump-Datei im Verzeichnis /var/crash speichern und den Prozessnamen plus die Prozessnummer als Dateinamen verwenden. Die Befehlsregel lautet: /var/crash/%!e(MISSING).% !p(FEHLEND).core.
/etc/security/limits.conf: Diese Datei gibt die Größenbeschränkung für das Generieren von Core-Dump-Dateien an. Sie können die Größe der Core-Dump-Datei begrenzen, indem Sie diese Datei ändern, um zu vermeiden, dass zu viel Speicherplatz belegt wird.
2. So aktivieren Sie die Generierung von Core-Dump-Dateien
Unter Linux wird die Core-Dump-Datei nicht standardmäßig generiert und muss manuell geöffnet werden. Hier sind drei Möglichkeiten, um die Generierung von Core-Dump-Dateien zu aktivieren:
2.1 ulimit-Befehl
Der Befehl ulimit kann verwendet werden, um die Ressourcennutzung eines Prozesses zu begrenzen, z. B. Dateigröße, Speichernutzung usw. Durch Einstellen der Parameter des Befehls ulimit kann die Generierung von Core-Dump-Dateien aktiviert werden. Konkrete Schritte sind wie folgt:
Führen Sie den Befehl ulimit -c unlimited aus, um die Größenbeschränkung der Core-Dump-Datei auf unbegrenzt zu setzen.
Führen Sie das Programm aus, wenn das Programm abstürzt oder abnormal beendet wird, wird die Core-Dump-Datei automatisch generiert.
2.2 sysctl-Befehl
Der Befehl sysctl kann verwendet werden, um Kernelparameter zu ändern. Durch Einstellen der Parameter des Befehls sysctl kann die Generierung von Core-Dump-Dateien aktiviert werden. Konkrete Schritte sind wie folgt:
Führen Sie sysctl -w kernel.core_pattern=/tmp/core-%!e(MISSING)-%!s(MISSING)-%!u(MISSING)-%!g(MISSING)-%!p(MISSING)-% aus! t(MISSING)-Befehl setzen Sie die Namensregel der Core-Dump-Datei auf /tmp/core-%!e(MISSING)-%!s(MISSING)-%!u(MISSING)-%!g(MISSING)-% !p(FEHLEND)-%!t(FEHLEND).
Führen Sie den Befehl ulimit -c unlimited aus, um die Größenbeschränkung der Core-Dump-Datei auf unbegrenzt zu setzen.
Führen Sie das Programm aus, wenn das Programm abstürzt oder abnormal beendet wird, wird die Core-Dump-Datei automatisch generiert.
2.3 /proc/sys/kernel/core_pattern-Datei
Sie können die Generierung von Core-Dump-Dateien aktivieren, indem Sie die Datei /proc/sys/kernel/core_pattern ändern. Konkrete Schritte sind wie folgt:
echo "/tmp/core-%!e(MISSING)-%!s(MISSING)-%!u(MISSING)-%!g(MISSING)-%!p(MISSING)-%!t(MISSING)" ausführen > /proc/sys/kernel/core_pattern setzen Sie die Namensregel der Core-Dump-Datei auf /tmp/core-%!e(MISSING)-%!s(MISSING)-%!u(MISSING)-%!g ( FEHLT)-%!p(FEHLT)-%!t(FEHLT).
Führen Sie den Befehl ulimit -c unlimited aus, um die Größenbeschränkung der Core-Dump-Datei auf unbegrenzt zu setzen.
Führen Sie das Programm aus, wenn das Programm abstürzt oder abnormal beendet wird, wird die Core-Dump-Datei automatisch generiert.
Durch die oben genannten Methoden können Sie die Generierung von Core-Dump-Dateien aktivieren, um den Absturz oder die anormale Situation des Programms zu debuggen und zu analysieren.
3. So analysieren Sie die Core-Dump-Datei
Wenn im Programm eine Ausnahme oder ein Absturz auftritt, generiert das Betriebssystem eine Core-Dump-Datei. Diese Datei enthält den Speicherstatus, wenn das Programm abstürzt, was Entwicklern helfen kann, Probleme schnell zu lokalisieren. Im Folgenden werden einige häufig verwendete Tools zum Analysieren von Core-Dump-Dateien vorgestellt.
3.1 GDB-Debugging-Tool
gdb ist ein leistungsstarkes Debugging-Tool, das zum Debuggen von C- und C++-Programmen verwendet werden kann. Es kann Core-Dump-Dateien lesen und eine Reihe von Befehlen bereitstellen, um den Speicherstatus zu analysieren, wenn das Programm abstürzt.
Die Schritte zum Analysieren der Core-Dump-Datei mit gdb sind wie folgt:
Öffnen Sie die Core-Dump-Datei:
gdb
, um die Stapelinformationen anzuzeigen, wenn das Programm abstürzt:
(gdb) bt
, um die Variablenwerte anzuzeigen, wenn das Programm abstürzt:
(gdb) p
, um den Registerstatus anzuzeigen, wenn das Programm abstürzt:
( gdb) info registriert sich
, um den Assemblercode anzuzeigen, wenn das Programm abstürzt:
(gdb) disassemble
3.2 objdump-Tool
objdump ist ein Disassemblierungstool, das ausführbare Dateien und gemeinsam genutzte Bibliotheksdateien in Assemblercode disassemblieren kann. Es kann verwendet werden, um den Assemblercode zu analysieren, wenn das Programm abstürzt, und das Problem herauszufinden.
Die Schritte zur Verwendung von objdump zum Analysieren der Core-Dump-Datei lauten wie folgt:
Anzeigen des Programmcodesegments in der Core-Dump-Datei:
objdump -d -j .text
Anzeigen des Programmdatensegments in der Core-Dump-Datei:
objdump -s -j .data
Anzeigen der Programmsymboltabelle in der Core-Dump-Datei:
objdump -t
3.3 Lesewerkzeug
readelf ist ein Tool zum Anzeigen von Headern im ELF-Format von ausführbaren und gemeinsam genutzten Bibliotheksdateien. Es kann verwendet werden, um das Speicherlayout zu analysieren, wenn das Programm abstürzt, und das Problem herauszufinden.
Die Schritte zum Analysieren der Core-Dump-Datei mit readelf sind wie folgt:
Zeigen Sie das Programmsegment in der Core-Dump-Datei an:
readelf -S <executable>
Zeigen Sie die Programmsymboltabelle in der Core-Dump-Datei an:
readelf -s <executable>
Zeigen Sie die dynamischen Linkinformationen des Programms in der Core-Dump-Datei an:
readelf -d <executable>
3.4 coredumpctl-Befehl
coredumpctl ist ein Befehlszeilentool zum Verwalten von Core-Dump-Dateien im System. Es kann verwendet werden, um die neuesten Core-Dump-Dateien im System anzuzeigen und zu analysieren.
Die Schritte zum Analysieren der Core-Dump-Datei mit dem Befehl coredumpctl lauten wie folgt:
Zeigen Sie die neuesten Core-Dump-Dateien im System an:
coredumpctl list
Zeigen Sie die angegebene Core-Dump-Datei an:
coredumpctl info <coredump>
Analysieren Sie die angegebene Core-Dump-Datei:
coredumpctl gdb <coredump>
4. So begrenzen Sie die Größe der Core-Dump-Datei
In vielen Fällen kann die resultierende Core-Dump-Datei sehr groß sein und viel Speicherplatz beanspruchen. Um dies zu vermeiden, können Sie die Größe der Core-Dump-Datei begrenzen. Hier sind einige Möglichkeiten:
4.1 ulimit-Befehl
Sie können den Befehl ulimit verwenden, um die Größe der Core-Dump-Datei des Benutzers zu begrenzen. Hier ist ein Beispiel:
$ ulimit -c 1000000
Dieser Befehl begrenzt die Größe der vom Benutzer erstellten Core-Dump-Datei auf 1 MB. Beim Versuch, eine größere Datei zu erzeugen, bricht das Programm mit einem Fehler ab.
4.2 /etc/security/limits.conf-Datei
Sie können die Größenbeschränkung für Core-Dump-Dateien auch in der Datei /etc/security/limits.conf festlegen. Hier ist ein Beispiel:
* soft core 1000000
Diese Zeile begrenzt die Größe aller benutzergenerierten Core-Dump-Dateien auf 1 MB. Sie können diesen Wert nach Bedarf anpassen.
Damit diese Änderung wirksam wird, müssen Sie Ihr System neu starten oder sich ab- und wieder anmelden.
4.3 core_pattern-Datei
Auf Linux-Systemen werden Name und Speicherort der generierten Core-Dump-Dateien durch die Datei core_pattern definiert. %!h(MISSING)/%!e(MISSING).%!p(MISSING).core.%!t(MISSING)Wenn Sie die Größe der Core-Dump-Datei beim Generieren begrenzen möchten, können Sie und |/bin/dd of=/path/to/core/files/core.%!e(MISSING).%!p(MISSING).%!t(MISSING) bs=1M count=10wie folgt zur core_pattern-Datei hinzufügen:
echo "%!h(MISSING)/%!e(MISSING).%!p(MISSING).core.%!t(MISSING)" > /proc/sys/kernel/core_pattern
echo "|/bin/dd of=/path/to/core/files/core.%!e(MISSING).%!p(MISSING).%!t(MISSING) bs=1M count=10" >> /proc/sys/kernel/core_pattern
Dadurch wird die Core-Dump-Datei in das Verzeichnis /path/to/core/files/ geschrieben und ihre Größe auf 10 MB begrenzt. Sie können diesen Wert nach Bedarf anpassen.
Beachten Sie, dass das Ändern der core_pattern-Datei alle laufenden Programme betreffen kann. Wenn Sie sich nicht sicher sind, wie Sie diese Datei ändern können, sichern Sie bitte zuerst die Originaldatei.
5. So bereinigen Sie nutzlose Core-Dump-Dateien
5.1 Manuelle Löschung
Das manuelle Löschen nutzloser Core-Dump-Dateien ist der einfachste Weg. Sie können die folgenden Befehle verwenden, um sie zu entfernen:
$ rm /path/to/core/files/*.core
Beachten Sie, dass dadurch alle .core-Dateien im Verzeichnis /path/to/core/files/ gelöscht werden. Wenn Sie nur Dateien löschen möchten, die älter als ein bestimmtes Datum sind, können Sie den Befehl find verwenden:
$ find /path/to/core/files/ -type f -name "*.core" -mtime +7 -delete
Dieser Befehl löscht alle .core-Dateien im Verzeichnis /path/to/core/files/, die älter als 7 Tage sind.
5.2 Automatisches Bereinigungsskript
Um das manuelle Bereinigen von Core-Dump-Dateien zu vermeiden, können Sie ein automatisches Bereinigungsskript schreiben. Hier ist ein Beispielskript:
#!/bin/bash
CORE_DIR=/path/to/core/files/
DAYS_TO_KEEP=7
find $CORE_DIR -type f -name "*.core" -mtime +$DAYS_TO_KEEP -delete
Speichern Sie das obige Skript als clean_core_files.sh und fügen Sie ausführbare Berechtigungen hinzu:
$ chmod +x clean_core_files.sh
Sie können dieses Skript zu cron hinzufügen, um es regelmäßig auszuführen:
$ crontab -e
Fügen Sie dann die folgenden Zeilen hinzu:
0 0 * * * /path/to/clean_core_files.sh
Dadurch wird die Core-Dump-Datei jeden Tag um Mitternacht gelöscht.
5.3 coredumpctl-Befehl
Wenn Sie Systemd verwenden, können Sie den Befehl coredumpctl verwenden, um Core-Dump-Dateien zu verwalten.
Hier sind einige häufig verwendete coredumpctl-Befehle:
Alle Core-Dump-Dateien auflisten:
$ coredumpctl list
Löschen Sie alle Core-Dump-Dateien:
$ coredumpctl purge
Details einer bestimmten Core-Dump-Datei anzeigen:
$ coredumpctl info /path/to/core/file
Extrahieren Sie den Stack-Trace aus der Core-Dump-Datei:
$ coredumpctl gdb /path/to/core/file
Beachten Sie, dass der Befehl coredumpctl Systemd-Unterstützung erfordert und nur auf Systemen verwendet werden kann, auf denen Systemd ausgeführt wird.
6. Beispielanalyse
Bevor Sie Core-Dump-Dateien analysieren, müssen Sie das GDB-Tool installieren. Hier sind die Befehle zum Installieren von GDB unter Ubuntu:
$ sudo apt-get install gdb
6.1 Analysieren Sie die Stack-Informationen in der Core-Dump-Datei
Verwenden Sie den folgenden Befehl, um Stack-Informationen in einer Core-Dump-Datei zu analysieren:
$ gdb /path/to/executable /path/to/core/file
Dadurch wird die GDB-Befehlszeilenschnittstelle geöffnet und die Core-Dump-Datei geladen. Sie können den Befehl bt verwenden, um Stack-Trace-Informationen anzuzeigen:
(gdb) bt
Dieser Befehl zeigt Stack-Traces von Funktionsaufrufen an, damit Sie feststellen können, warum Ihr Programm abgestürzt ist.
6.2 Analysieren Sie die Registerinformationen in der Core-Dump-Datei
Um Registerinformationen in einer Core-Dump-Datei zu analysieren, verwenden Sie den folgenden Befehl:
$ gdb /path/to/executable /path/to/core/file
Verwenden Sie dann den Befehl info registers, um die Werte aller Register anzuzeigen:
(gdb) info registers
Dieser Befehl zeigt die Werte aller Register an, um Ihnen zu helfen, den Zustand des Programms beim Absturz zu verstehen.
6.3 Analysieren Sie die Speicherinformationen in der Core-Dump-Datei
Verwenden Sie den folgenden Befehl, um Speicherinformationen in einer Core-Dump-Datei zu analysieren:
$ gdb /path/to/executable /path/to/core/file
Verwenden Sie dann den Befehl x, um den Speicherinhalt anzuzeigen:
(gdb) x/nfu address
Dabei ist n die Anzahl der anzuzeigenden Speicherzellen, f das Anzeigeformat, u die Zellengröße und address die anzuzeigende Speicheradresse. Der folgende Befehl zeigt beispielsweise die ersten 16 Bytes ab Adresse 0x0 an:
(gdb) x/16xb 0x0
Dieser Befehl zeigt 16 Bytes im Hexadezimalformat an, damit Sie den Zustand des Speichers nachvollziehen können, als das Programm abgestürzt ist.
7. Allgemeine Probleme und Lösungen
Es gibt einige allgemeine Probleme, auf die Sie stoßen können, wenn Sie Core-Dump-Dateien zum Debuggen und Analysieren verwenden. Hier sind einige häufige Probleme und Lösungen:
7.1 Core-Dump-Datei kann nicht generiert werden
Wenn Sie keine Core-Dump-Datei generieren können, stellen Sie sicher, dass die folgenden Bedingungen erfüllt sind:
Das Betriebssystem ermöglicht die Generierung von Core-Dump-Dateien.
Das Programm hat Beschränkungen für das Generieren von Core-Dump-Dateien festgelegt (z. B. mit dem Befehl ulimit).
Das Programm maskiert das Signal zur Generierung einer Core-Dump-Datei zur Laufzeit nicht.
Wenn Sie immer noch keine Core-Dump-Datei generieren können, versuchen Sie, das Programm mit dem Befehl strace zu verfolgen und zu sehen, ob es Fehlermeldungen gibt.
7.2 Die Core-Dump-Datei ist zu groß, was zu unzureichendem Speicherplatz führt
Wenn die von Ihrem Programm generierte Core-Dump-Datei zu groß ist, kann dies zu unzureichendem Speicherplatz führen. In diesem Fall können Sie die folgenden Lösungen ausprobieren:
Begrenzen Sie die Größe der generierten Core-Dump-Datei (z. B. mit dem Befehl ulimit).
Schreiben Sie die Core-Dump-Datei auf eine andere Festplatte oder ein anderes Speichergerät.
Bereinigen Sie regelmäßig nutzlose Core-Dump-Dateien.
7.3 Die Informationen in der Core-Dump-Datei sind unvollständig oder ungenau
Wenn Sie feststellen, dass die Informationen in der generierten Core-Dump-Datei unvollständig oder ungenau sind, kann dies folgende Gründe haben:
Das Programm hat beim Generieren der Core-Dump-Datei Speicher oder Status geändert.
Die generierte Core-Dump-Datei darf nur Teilinformationen enthalten (z. B. nur die Informationen des aktuellen Threads).
Die verwendeten Debugging-Tools sind möglicherweise nicht in der Lage, die Informationen in der Core-Dump-Datei korrekt zu analysieren.
In diesem Fall können Sie andere Debugging-Tools ausprobieren oder andere Methoden zum Debuggen und Profiling verwenden.
8. Zusammenfassung
In diesem Artikel haben wir vorgestellt, was Core-Dump-Dateien sind und was sie tun, und wir haben gelernt, wie man sie generiert, erfasst und analysiert. Wir haben gelernt, wie man das GDB-Tool verwendet, um den Stack, die Register und die Speicherinformationen in der Core-Dump-Datei zu analysieren, um uns bei der Diagnose der Ursache des Programmabsturzes und der Fehlerbehebung zu helfen.
Wir haben auch besprochen, wie nutzlose Core-Dump-Dateien bereinigt werden können, einschließlich manuellem Entfernen, Schreiben automatischer Bereinigungsskripts und Verwenden des Befehls coredumpctl.
Abschließend betonen wir, wie wichtig es ist, Core-Dump-Dateien während der Entwicklung und beim Testen zu generieren und zu analysieren, da sie nützliche Informationen über Programmabstürze liefern und uns dabei helfen können, die Codequalität und Systemstabilität zu verbessern.