# strace — Systemaufrufe und Signale eines Prozesses verfolgen > Praxis-Guide zu strace: Systemaufrufe verfolgen, fehlschlagende Programme diagnostizieren und Performance-Engpässe auf OS-Ebene aufspüren. Source: https://www.jpkc.com/db/cheatsheets/shell-system/strace/ strace zeigt dir, was ein Programm wirklich tut: Es protokolliert jeden Systemaufruf an den Linux-Kernel samt Argumenten und Rückgabewert – vom Öffnen einer Datei über Netzwerkverbindungen bis zum empfangenen Signal. Damit findest du heraus, warum ein Prozess hängt, welche Konfigurationsdatei er vergeblich sucht oder wo die Zeit verloren geht, ohne den Quellcode zu kennen. Dieser Guide führt dich vom einfachen Mitschneiden über gezielte Filter bis zur Syscall-Statistik fürs Profiling. ## Grundlegendes Tracing `strace ` — Verfolgt alle Systemaufrufe eines Kommandos. ```bash strace ls -la ``` `strace -p ` — Hängt sich an einen laufenden Prozess und verfolgt ihn (braucht ptrace-Recht, ggf. `sudo`). ```bash strace -p 1234 ``` `strace -f ` — Folgt auch Kindprozessen (Forks). ```bash strace -f nginx ``` `strace -o ` — Schreibt die Trace-Ausgabe in eine Datei. ```bash strace -o trace.log ./myapp ``` `strace -ff -o ` — Schreibt den Trace jedes Prozesses in eine eigene Datei. ```bash strace -ff -o traces/app ./myapp ``` ## Nach Systemaufruf filtern `strace -e trace= ` — Verfolgt nur bestimmte Systemaufrufe. ```bash strace -e trace=open,read,write ls ``` `strace -e trace=file ` — Verfolgt dateibezogene Systemaufrufe. ```bash strace -e trace=file cat /etc/hosts ``` `strace -e trace=network ` — Verfolgt netzwerkbezogene Systemaufrufe. ```bash strace -e trace=network curl -s https://example.com ``` `strace -e trace=process ` — Verfolgt Prozessverwaltungs-Aufrufe (fork, exec, wait). ```bash strace -e trace=process bash -c 'ls | grep txt' ``` `strace -e trace=memory ` — Verfolgt Speicherverwaltungs-Aufrufe (mmap, brk usw.). ```bash strace -e trace=memory ./myapp ``` `strace -e trace=signal ` — Verfolgt signalbezogene Systemaufrufe. ```bash strace -e trace=signal ./myapp ``` ## Timing & Performance `strace -T ` — Zeigt die in jedem Systemaufruf verbrachte Zeit an. ```bash strace -T ./myapp ``` `strace -t ` — Stellt jeder Zeile die Uhrzeit voran. ```bash strace -t ./myapp ``` `strace -tt ` — Stellt die Uhrzeit inklusive Mikrosekunden voran. ```bash strace -tt ./myapp ``` `strace -r ` — Zeigt relative Zeitstempel (Zeit seit dem vorherigen Aufruf). ```bash strace -r ./myapp ``` `strace -c ` — Zählt Systemaufrufe und fasst sie als Statistik zusammen. ```bash strace -c ls -la /usr ``` `strace -C ` — Zeigt sowohl den normalen Trace als auch die Zusammenfassung. ```bash strace -C ./myapp ``` `strace -c -S time ` — Sortiert die Zusammenfassung nach verbrauchter Zeit (Standard: Aufrufe). ```bash strace -c -S time ./myapp ``` ## Ausgabeoptionen `strace -s ` — Legt die maximale String-Länge in der Ausgabe fest (Standard 32). ```bash strace -s 1024 -e trace=read ./myapp ``` `strace -v ` — Ausführlicher Modus: kürzt Strukturen nicht ab. ```bash strace -v stat /etc/hosts ``` `strace -y ` — Zeigt Dateipfade zu Dateideskriptor-Argumenten an. ```bash strace -y -e trace=read,write ./myapp ``` `strace -yy ` — Zeigt Socket-Adressen und Gerätedetails zu Deskriptoren an. ```bash strace -yy -e trace=network curl -s https://example.com ``` ## Typische Anwendungsfälle `strace -e trace=openat 2>&1 | grep ` — Findet heraus, welche Dateien ein Programm zu öffnen versucht. ```bash strace -e trace=openat python app.py 2>&1 | grep config ``` `strace -e trace=connect ` — Zeigt, welche Netzwerkverbindungen ein Programm aufbaut. ```bash strace -e trace=connect curl -s https://example.com ``` `strace -e trace=openat -p 2>&1 | grep -v ENOENT` — Beobachtet die Dateizugriffe eines laufenden Prozesses (ohne Fehlversuche). ```bash strace -e trace=openat -p $(pidof nginx) 2>&1 | grep -v ENOENT ``` `strace -c -p -e trace=all` — Profilt die Systemaufruf-Nutzung eines laufenden Prozesses. ```bash strace -c -p $(pidof php-fpm) -e trace=all ``` `strace -e trace=write -s 1024 -p ` — Beobachtet, was ein Prozess schreibt (Debugging von Ausgabeproblemen). ```bash strace -e trace=write -s 1024 -p 1234 ``` ## Fazit strace ist das erste Werkzeug, zu dem du greifst, wenn ein Programm sich rätselhaft verhält und Logs nichts hergeben: `strace -f -e trace=file` deckt fehlende Dateien auf, `-e trace=network` zeigt blockierte Verbindungen, und `-c` liefert ein schnelles Syscall-Profil. Beachte aber zwei Dinge. Erstens verlangsamt das Tracing das Ziel deutlich – auf Produktionssystemen mit Bedacht und am besten zeitlich begrenzt einsetzen. Zweitens, und wichtiger: strace zeigt Syscall-Argumente im Klartext und kann dabei Passwörter, Tokens oder Schlüssel offenlegen. Hänge dich daher nur an eigene oder ausdrücklich autorisierte Prozesse; `strace -p` braucht ohnehin das ptrace-Recht (yama `ptrace_scope`, meist `sudo`). Unter macOS gibt es kein strace – dort nutzt du `dtruss` beziehungsweise `dtrace`. ## Weiterführende Links - [strace.io](https://strace.io/) – offizielle Projektseite mit Dokumentation und Downloads - [Wikipedia: strace](https://de.wikipedia.org/wiki/Strace) – Hintergrund und Funktionsweise des System-Call-Tracers ## Verwandte Kommandos - [lsof](https://www.jpkc.com/db/cheatsheets/shell-system/lsof/) – zeigt offene Dateien und Sockets eines Prozesses - [ps](https://www.jpkc.com/db/cheatsheets/shell-system/ps/) – listet laufende Prozesse samt PIDs für `strace -p` - [dmesg](https://www.jpkc.com/db/cheatsheets/shell-system/dmesg/) – liest den Kernel-Ringpuffer für systemnahe Fehlermeldungen