Ein Systemaufruf ist eine programmatische Methode, mit der ein Programm einen Dienst vom Kernel und strace anfordert ist ein leistungsstarkes Tool, mit dem Sie die dünne Schicht zwischen Benutzerprozessen und dem Linux-Kernel verfolgen können.
Um zu verstehen, wie ein Betriebssystem funktioniert, müssen Sie zunächst verstehen, wie Systemaufrufe funktionieren. Eine der Hauptfunktionen eines Betriebssystems besteht darin, Benutzerprogrammen Abstraktionen bereitzustellen.
Ein Betriebssystem kann grob in zwei Modi unterteilt werden:
- Kernel-Modus: Ein privilegierter und leistungsfähiger Modus, der vom Betriebssystem-Kernel verwendet wird
- Benutzermodus: Wo die meisten Benutzeranwendungen ausgeführt werden
Benutzer arbeiten hauptsächlich mit Befehlszeilendienstprogrammen und grafischen Benutzeroberflächen (GUI), um alltägliche Aufgaben zu erledigen. Systemaufrufe arbeiten still im Hintergrund und stellen eine Schnittstelle zum Kernel her, um die Arbeit zu erledigen.
Weitere Linux-Ressourcen
- Spickzettel für Linux-Befehle
- Spickzettel für fortgeschrittene Linux-Befehle
- Kostenloser Online-Kurs:RHEL Technical Overview
- Spickzettel für Linux-Netzwerke
- SELinux-Spickzettel
- Spickzettel für allgemeine Linux-Befehle
- Was sind Linux-Container?
- Unsere neuesten Linux-Artikel
Systemaufrufe sind Funktionsaufrufen sehr ähnlich, was bedeutet, dass sie Argumente und Rückgabewerte akzeptieren und bearbeiten. Der einzige Unterschied besteht darin, dass Systemaufrufe in einen Kernel eintreten, während Funktionsaufrufe dies nicht tun. Das Umschalten vom Userspace zum Kernelspace erfolgt über einen speziellen Trap-Mechanismus.
Das meiste davon wird dem Benutzer durch die Verwendung von Systembibliotheken (auch bekannt als glibc auf Linux-Systemen). Auch wenn Systemaufrufe generischer Natur sind, sind die Mechanismen zum Ausgeben eines Systemaufrufs sehr stark maschinenabhängig.
Dieser Artikel untersucht einige praktische Beispiele, indem er einige allgemeine Befehle verwendet und die Systemaufrufe analysiert, die von jedem Befehl mit strace ausgeführt werden . Diese Beispiele verwenden Red Hat Enterprise Linux, aber die Befehle sollten auf anderen Linux-Distributionen gleich funktionieren:
[root@sandbox ~]# cat /etc/redhat-release
Red Hat Enterprise Linux Server release 7.7 (Maipo)
[root@sandbox ~]#
[root@sandbox ~]# uname -r
3.10.0-1062.el7.x86_64
[root@sandbox ~]#
Stellen Sie zunächst sicher, dass die erforderlichen Tools auf Ihrem System installiert sind. Sie können überprüfen, ob strace wird mit dem folgenden RPM-Befehl installiert; Wenn ja, können Sie den Strace überprüfen Versionsnummer des Dienstprogramms mit -V Möglichkeit:
[root@sandbox ~]# rpm -qa | grep -i strace
strace-4.12-9.el7.x86_64
[root@sandbox ~]#
[root@sandbox ~]# strace -V
strace -- version 4.12
[root@sandbox ~]#
Wenn das nicht funktioniert, installieren Sie strace durch Ausführen von:
yum install straceErstellen Sie für dieses Beispiel ein Testverzeichnis innerhalb von /tmp und erstellen Sie zwei Dateien mit dem Berühren Befehl mit:
[root@sandbox ~]# cd /tmp/
[root@sandbox tmp]#
[root@sandbox tmp]# mkdir testdir
[root@sandbox tmp]#
[root@sandbox tmp]# touch testdir/file1
[root@sandbox tmp]# touch testdir/file2
[root@sandbox tmp]#
(Ich habe die Datei /tmp verwendet Verzeichnis, weil jeder Zugriff darauf hat, aber Sie können ein anderes Verzeichnis wählen, wenn Sie dies bevorzugen.)
Überprüfen Sie, ob die Dateien mit ls erstellt wurden Befehl im testdir Verzeichnis:
[root@sandbox tmp]# ls testdir/
file1 file2
[root@sandbox tmp]#
Sie verwenden wahrscheinlich das ls Befehl jeden Tag, ohne zu merken, dass darunter Systemaufrufe am Werk sind. Hier ist Abstraktion im Spiel; So funktioniert dieser Befehl:
Command-line utility -> Invokes functions from system libraries (glibc) -> Invokes system callsDie ls Der Befehl ruft intern Funktionen aus Systembibliotheken (auch bekannt als glibc ) unter Linux. Diese Bibliotheken rufen die Systemaufrufe auf, die die meiste Arbeit erledigen.
Wenn Sie wissen möchten, welche Funktionen von der glibc aufgerufen wurden Bibliothek verwenden Sie den ltrace Befehl, gefolgt vom regulären ls testdir/ Befehl:
ltrace ls testdir/Wenn ltrace nicht installiert ist, installieren Sie es durch Eingabe von:
yum install ltraceEine Reihe von Ausgaben wird auf den Bildschirm ausgegeben; Machen Sie sich keine Sorgen – folgen Sie einfach. Einige der wichtigen Bibliotheksfunktionen aus der Ausgabe von ltrace Befehle, die für dieses Beispiel relevant sind, sind:
opendir("testdir/") = { 3 }
readdir({ 3 }) = { 101879119, "." }
readdir({ 3 }) = { 134, ".." }
readdir({ 3 }) = { 101879120, "file1" }
strlen("file1") = 5
memcpy(0x1665be0, "file1\0", 6) = 0x1665be0
readdir({ 3 }) = { 101879122, "file2" }
strlen("file2") = 5
memcpy(0x166dcb0, "file2\0", 6) = 0x166dcb0
readdir({ 3 }) = nil
closedir({ 3 }) Wenn Sie sich die obige Ausgabe ansehen, können Sie wahrscheinlich verstehen, was passiert. Ein Verzeichnis namens testdir wird vom opendir geöffnet Bibliotheksfunktion, gefolgt von Aufrufen von readdir Funktion, die den Inhalt des Verzeichnisses liest. Am Ende gibt es einen Aufruf zum closedir Funktion, die das zuvor geöffnete Verzeichnis schließt. Ignorieren Sie die anderen strlen und memcpy funktioniert vorerst.
Sie können sehen, welche Bibliotheksfunktionen aufgerufen werden, aber dieser Artikel konzentriert sich auf Systemaufrufe, die von den Systembibliotheksfunktionen aufgerufen werden.
Ähnlich wie oben, um zu verstehen, welche Systemaufrufe aufgerufen werden, geben Sie einfach strace ein vor dem ls testdir Befehl, wie unten gezeigt. Wieder einmal wird ein Haufen Kauderwelsch auf Ihren Bildschirm gekippt, dem Sie hier folgen können:
[root@sandbox tmp]# strace ls testdir/
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
brk(NULL) = 0x1f12000
<<< truncated strace output >>>
write(1, "file1 file2\n", 13file1 file2
) = 13
close(1) = 0
munmap(0x7fd002c8d000, 4096) = 0
close(2) = 0
exit_group(0) = ?
+++ exited with 0 +++
[root@sandbox tmp]#
Die Ausgabe auf dem Bildschirm nach Ausführung des strace Befehl bestand einfach aus Systemaufrufen zum Ausführen von ls Befehl. Jeder Systemaufruf dient einem bestimmten Zweck für das Betriebssystem und kann grob in die folgenden Abschnitte eingeteilt werden:
- Aufrufe des Prozessmanagementsystems
- Aufrufe des Dateiverwaltungssystems
- Verzeichnis- und Dateisystemverwaltungssystemaufrufe
- Andere Systemaufrufe
Eine einfachere Möglichkeit, die auf Ihrem Bildschirm angezeigten Informationen zu analysieren, besteht darin, die Ausgabe mit strace in einer Datei zu protokollieren ist praktisch -o Flagge. Fügen Sie nach dem -o einen passenden Dateinamen hinzu markieren und den Befehl erneut ausführen:
[root@sandbox tmp]# strace -o trace.log ls testdir/
file1 file2
[root@sandbox tmp]#
Diesmal wird keine Ausgabe auf den Bildschirm ausgegeben – das ls funktionierte wie erwartet, indem er die Dateinamen anzeigte und die gesamte Ausgabe in der Datei trace.log protokollierte . Die Datei hat fast 100 Zeilen Inhalt nur für ein einfaches ls Befehl:
[root@sandbox tmp]# ls -l trace.log
-rw-r--r--. 1 root root 7809 Oct 12 13:52 trace.log
[root@sandbox tmp]#
[root@sandbox tmp]# wc -l trace.log
114 trace.log
[root@sandbox tmp]#
Sehen Sie sich die erste Zeile im trace.log des Beispiels an:
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0- Das erste Wort der Zeile, execve , ist der Name eines ausgeführten Systemaufrufs.
- Der Text in Klammern sind die Argumente, die für den Systemaufruf bereitgestellt werden.
- Die Zahl nach dem = Zeichen (das ist 0 in diesem Fall) ist ein Wert, der von execve zurückgegeben wird Systemaufruf.
Die Ausgabe scheint jetzt nicht allzu einschüchternd zu sein, oder? Und Sie können die gleiche Logik anwenden, um andere Zeilen zu verstehen.
Konzentrieren Sie sich jetzt auf den einzelnen Befehl, den Sie aufgerufen haben, d. h. ls testdir . Sie kennen den Verzeichnisnamen, der vom Befehl ls verwendet wird , also warum nicht grep für testdir in Ihrem trace.log Datei und sehen, was Sie bekommen? Sehen Sie sich jede Zeile der Ergebnisse im Detail an:
[root@sandbox tmp]# grep testdir trace.log
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0
openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3
[root@sandbox tmp]#
Denken Sie zurück an die Analyse von execve Können Sie sagen, was dieser Systemaufruf tut?
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0Sie müssen sich nicht alle Systemaufrufe oder deren Funktionsweise merken, da Sie bei Bedarf auf die Dokumentation zurückgreifen können. Manpages zur Rettung! Stellen Sie sicher, dass das folgende Paket installiert ist, bevor Sie man ausführen Befehl:
[root@sandbox tmp]# rpm -qa | grep -i man-pages
man-pages-3.53-5.el7.noarch
[root@sandbox tmp]#
Denken Sie daran, dass Sie eine 2 hinzufügen müssen zwischen dem Mann Befehl und den Namen des Systemaufrufs. Wenn Sie Mann lesen 's Manpage mit man man , können Sie sehen, dass Abschnitt 2 für Systemaufrufe reserviert ist. Ebenso müssen Sie eine 3 hinzufügen, wenn Sie Informationen zu Bibliotheksfunktionen benötigen zwischen Menschen und den Bibliotheksfunktionsnamen.
Im Folgenden finden Sie die Abschnittsnummern des Handbuchs und die darin enthaltenen Seitentypen:
1. Executable programs or shell commands
2. System calls (functions provided by the kernel)
3. Library calls (functions within program libraries)
4. Special files (usually found in /dev)
Führen Sie den folgenden Mann aus Befehl mit dem Namen des Systemaufrufs, um die Dokumentation für diesen Systemaufruf anzuzeigen:
man 2 execveGemäß der Exekutive Manpage führt dies ein Programm aus, das in den Argumenten übergeben wird (in diesem Fall ist das ls ). Es gibt zusätzliche Argumente, die für ls bereitgestellt werden können , wie zum Beispiel testdir in diesem Beispiel. Daher führt dieser Systemaufruf einfach ls aus mit testdir als Argument:
'execve - execute program'
'DESCRIPTION
execve() executes the program pointed to by filename'
Der nächste Systemaufruf namens stat , verwendet das testdir Argument:
stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0Verwenden Sie Mann-2-Statistik um auf die Dokumentation zuzugreifen. Statistik ist der Systemaufruf, der den Status einer Datei erhält – denken Sie daran, dass alles in Linux eine Datei ist, einschließlich eines Verzeichnisses.
Als nächstes das openat Systemaufruf öffnet testdir. Behalten Sie die 3 im Auge das wird zurückgegeben. Dies ist eine Dateibeschreibung, die von späteren Systemaufrufen verwendet wird:
openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3So weit, ist es gut. Öffnen Sie nun die trace.log Datei und gehen Sie zu der Zeile nach dem openat Systemaufruf. Sie sehen die getdents Systemaufruf aufgerufen, der das meiste erledigt, was zum Ausführen von ls testdir erforderlich ist Befehl. Jetzt grep getdents aus der trace.log Datei:
[root@sandbox tmp]# grep getdents trace.log
getdents(3, /* 4 entries */, 32768) = 112
getdents(3, /* 0 entries */, 32768) = 0
[root@sandbox tmp]#
Die getdents Manpage beschreibt es als Verzeichniseinträge abrufen , was Sie tun möchten. Beachten Sie, dass das Argument für getdents ist 3 , das ist der Dateideskriptor von openat Systemaufruf oben.
Jetzt, da Sie die Verzeichnisliste haben, brauchen Sie eine Möglichkeit, sie in Ihrem Terminal anzuzeigen. Also, grupp für einen weiteren Systemaufruf write , die verwendet wird, um in das Terminal zu schreiben, in den Protokollen:
[root@sandbox tmp]# grep write trace.log
write(1, "file1 file2\n", 13) = 13
[root@sandbox tmp]#
In diesen Argumenten sehen Sie die Dateinamen, die angezeigt werden:Datei1 und Datei2 . Zum ersten Argument (1 ), denken Sie daran, dass unter Linux standardmäßig drei Dateideskriptoren geöffnet werden, wenn ein Prozess ausgeführt wird. Im Folgenden sind die Standarddateideskriptoren aufgeführt:
- 0 – Standardeingabe
- 1 – Standardausgabe
- 2 – Standardfehler
Also, das Schreiben Systemaufruf zeigt file1 an und Datei2 auf der Standardanzeige, das ist das Terminal, gekennzeichnet durch 1 .
Jetzt wissen Sie, welche Systemaufrufe die meiste Arbeit für ls testdir/ geleistet haben Befehl. Aber was ist mit den anderen über 100 Systemaufrufen in der trace.log Datei? Das Betriebssystem muss viel Arbeit leisten, um einen Prozess auszuführen, sodass Sie in der Protokolldatei viel von der Prozessinitialisierung und -bereinigung sehen. Lesen Sie das gesamte trace.log Datei und versuchen Sie zu verstehen, was passiert, um die ls zu erstellen Befehlsarbeit.
Nachdem Sie nun wissen, wie Systemaufrufe für einen bestimmten Befehl analysiert werden, können Sie dieses Wissen für andere Befehle verwenden, um zu verstehen, welche Systemaufrufe ausgeführt werden. Strich bietet viele nützliche Befehlszeilen-Flags, um es Ihnen einfacher zu machen, und einige davon werden unten beschrieben.
Standardmäßig strace enthält nicht alle Systemaufrufinformationen. Es hat jedoch ein praktisches -v verbose Option, die zusätzliche Informationen zu jedem Systemaufruf liefern kann:
strace -v ls testdirEs hat sich bewährt, immer das -f zu verwenden -Option beim Ausführen von strace Befehl. Es erlaubt strace um alle untergeordneten Prozesse zu verfolgen, die von dem Prozess erstellt wurden, der gerade verfolgt wird:
strace -f ls testdirAngenommen, Sie möchten nur die Namen der Systemaufrufe, die Häufigkeit ihrer Ausführung und den Prozentsatz der Zeit, die für jeden Systemaufruf aufgewendet wurde. Sie können das -c verwenden Flag, um diese Statistiken zu erhalten:
strace -c ls testdir/Angenommen, Sie möchten sich auf einen bestimmten Systemaufruf konzentrieren, z. B. auf Öffnen Systemaufrufe und den Rest ignorieren. Sie können das -e verwenden Flag gefolgt vom Namen des Systemaufrufs:
[root@sandbox tmp]# strace -e open ls testdir
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libcap.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libacl.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpcre.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libattr.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
open("/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
file1 file2
+++ exited with 0 +++
[root@sandbox tmp]#
Was ist, wenn Sie sich auf mehr als einen Systemaufruf konzentrieren möchten? Keine Sorge, Sie können dasselbe -e verwenden Befehlszeilen-Flag mit einem Komma zwischen den beiden Systemaufrufen. Zum Beispiel, um das Schreiben zu sehen und getdents Systemaufrufe:
[root@sandbox tmp]# strace -e write,getdents ls testdir
getdents(3, /* 4 entries */, 32768) = 112
getdents(3, /* 0 entries */, 32768) = 0
write(1, "file1 file2\n", 13file1 file2
) = 13
+++ exited with 0 +++
[root@sandbox tmp]#
Die bisherigen Beispiele haben explizit ausgeführte Befehle verfolgt. Aber was ist mit Befehlen, die bereits ausgeführt wurden und in Ausführung sind? Was ist zum Beispiel, wenn Sie Daemons verfolgen möchten, die nur lang andauernde Prozesse sind? Dafür strace bietet ein spezielles -p Flag, dem Sie eine Prozess-ID zuweisen können.
Anstatt einen Strace auszuführen Nehmen Sie für einen Daemon das Beispiel einer Katze Befehl, der normalerweise den Inhalt einer Datei anzeigt, wenn Sie einen Dateinamen als Argument angeben. Wenn kein Argument angegeben wird, die Katze Der Befehl wartet einfach an einem Terminal darauf, dass der Benutzer Text eingibt. Sobald Text eingegeben wurde, wird der angegebene Text wiederholt, bis ein Benutzer Strg+C zum Beenden drückt.
Führen Sie die Katze aus Befehl von einem Terminal; Es zeigt Ihnen eine Eingabeaufforderung und warten Sie einfach dort (denken Sie an Katze läuft noch und wurde nicht beendet):
[root@sandbox tmp]# catSuchen Sie auf einem anderen Terminal die Prozesskennung (PID) mithilfe von ps Befehl:
[root@sandbox ~]# ps -ef | grep cat
root 22443 20164 0 14:19 pts/0 00:00:00 cat
root 22482 20300 0 14:20 pts/1 00:00:00 grep --color=auto cat
[root@sandbox ~]#
Führen Sie jetzt strace aus im laufenden Prozess mit dem -p Flag und die PID (die Sie oben mit ps gefunden haben ). Nach dem Ausführen von strace , gibt die Ausgabe an, woran der Prozess zusammen mit der PID-Nummer angehängt wurde. Nun, strace verfolgt die Systemaufrufe der Katze Befehl. Der erste Systemaufruf, den Sie sehen, ist read , die auf Eingaben von 0 wartet, oder Standardeingabe, das ist das Terminal, an dem die Katze Befehl lief:
[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0,
Gehen Sie jetzt zurück zum Terminal, wo Sie die Katze zurückgelassen haben Befehl ausgeführt und geben Sie einen Text ein. Ich habe x0x0 eingegeben zu Demozwecken. Beachten Sie, wie Katze wiederholte einfach, was ich eingegeben hatte; daher x0x0 taucht zweimal auf. Ich habe die erste eingegeben und die zweite war die Ausgabe, die von der Katze wiederholt wurde Befehl:
[root@sandbox tmp]# cat
x0x0
x0x0
Gehen Sie zurück zum Terminal, wo strace wurde an der Katze befestigt Prozess. Sie sehen jetzt zwei zusätzliche Systemaufrufe:den vorherigen read Systemaufruf, der jetzt x0x0 lautet im Terminal und ein weiteres für write , die x0x0 geschrieben hat zurück zum Terminal und wieder ein neues Lesen , die darauf wartet, vom Terminal gelesen zu werden. Beachten Sie, dass die Standardeingabe (0 ) und Standardausgang (1 ) befinden sich beide im selben Terminal:
[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0, "x0x0\n", 65536) = 5
write(1, "x0x0\n", 5) = 5
read(0,
Stellen Sie sich vor, wie hilfreich dies beim Ausführen von strace ist gegen Daemons, um alles zu sehen, was es im Hintergrund tut. Töte die Katze Befehl durch Drücken von Strg+C; dies tötet auch Ihren Strace Sitzung, da der Prozess nicht mehr ausgeführt wird.
Wenn Sie einen Zeitstempel für alle Ihre Systemaufrufe sehen möchten, verwenden Sie einfach das -t Option mit strace :
[root@sandbox ~]#strace -t ls testdir/
14:24:47 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
14:24:47 brk(NULL) = 0x1f07000
14:24:47 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2530bc8000
14:24:47 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
14:24:47 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
Was ist, wenn Sie wissen möchten, wie viel Zeit zwischen Systemaufrufen vergangen ist? Strich hat ein praktisches -r Befehl, der die Zeit anzeigt, die für die Ausführung jedes Systemaufrufs aufgewendet wurde. Ziemlich nützlich, nicht wahr?
[root@sandbox ~]#strace -r ls testdir/
0.000000 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
0.000368 brk(NULL) = 0x1966000
0.000073 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fb6b1155000
0.000047 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
0.000119 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
Schlussfolgerung
Die Strasse Das Dienstprogramm ist sehr praktisch, um Systemaufrufe unter Linux zu verstehen. Um mehr über die anderen Befehlszeilen-Flags zu erfahren, lesen Sie bitte die Manpages und die Online-Dokumentation.