Exit-Codes

Konvention

Die Unix-Konvention ist denkbar einfach: 0 bedeutet Erfolg, jeder andere Wert von 1 bis 255 bedeutet einen Fehler. Welcher konkrete Wert für welchen Fehler steht, entscheidet das jeweilige Programm. Diese Asymmetrie hat einen praktischen Grund — es gibt nur einen Weg, etwas richtig zu machen, aber viele Möglichkeiten, daran zu scheitern.

Ein Skript, das ohne explizites exit endet, gibt automatisch den Exit-Code des letzten ausgeführten Befehls zurück. Das ist häufig genau das, was du willst — kann aber zu Überraschungen führen, wenn der letzte Befehl etwa ein echo ist, das immer mit 0 endet, obwohl davor ein Fehler aufgetreten ist.

#!/usr/bin/env bash
ls /nichtvorhanden
echo "fertig"

ls: cannot access '/nichtvorhanden': No such file or directory
fertig

Aufgerufen mit ./skript.sh; echo $? zeigt sich der Wert 0, denn echo "fertig" war der letzte Befehl. Wer den Fehler nach außen tragen will, muss explizit exit setzen oder mit set -e arbeiten.

$? — letzter Exit-Code

Die Spezialvariable $? hält den Exit-Code des zuletzt ausgeführten Vordergrundbefehls. Sie wird nach jedem Befehl neu gesetzt — auch nach einem echo. Wer einen Exit-Code mehrfach prüfen will, sollte ihn deshalb sofort in eine eigene Variable kopieren.

ls /nichtvorhanden
echo "Exit-Code: $?"

ls: cannot access '/nichtvorhanden': No such file or directory
Exit-Code: 2

Die Falle: Schon das echo selbst hat einen Exit-Code (0). Folgt direkt danach ein zweites echo $?, zeigt es nur noch 0.

ls /nichtvorhanden
rc=$?
echo "rc ist $rc"
echo "rc ist immer noch $rc"

Diese Idee — rc=$? als allerersten Befehl nach dem zu prüfenden Aufruf — ist eines der wichtigsten Muster in robusten Skripten und wird auch in Trap-Handlern weiter unten gebraucht.

exit N und return N

Mit exit N beendest du das gesamte Skript und gibst den Wert N an den Aufrufer zurück. Das Pendant für Funktionen ist return N — es verlässt nur die Funktion, nicht das Skript. Beide akzeptieren Werte zwischen 0 und 255.

pruefen() {
    [[ -f "$1" ]] || return 1
    return 0
}

pruefen "/etc/hostname" || exit 1
echo "Datei existiert"

Der Wertebereich ist auf 8 Bit (0-255) begrenzt. Größere Werte werden modulo 256 abgeschnitten — ein klassischer Bug:

bash -c 'exit 256'; echo $?
bash -c 'exit 300'; echo $?
bash -c 'exit -1'; echo $?

0
44
255

exit 256 wird zu 0 — und damit fälschlich zum Erfolgssignal. exit -1 wird zu 255. Wer Fehler-Codes manuell vergibt, sollte sich auf den Bereich 1 bis 125 beschränken; die Werte ab 126 haben besondere Bedeutung (siehe nächster Abschnitt).

Standard-Fehlercodes

Über die Jahre haben sich einige Konventionen für bestimmte Exit-Codes etabliert. Sie sind nicht in einem einzelnen Standard festgeschrieben — die Bash-Manpage, BSDs sysexits.h und einzelne Tools beschreiben jeweils Teile davon — aber so weit verbreitet, dass man sie kennen sollte.

Programme definieren zusätzlich eigene Codes. grep etwa unterscheidet bewusst zwischen „kein Treffer” und „Fehler”:

Wichtig: Bei grep und diff ist 1 normales Verhalten, kein Fehler. Wer das nicht weiß, schreibt Skripte, die mit set -e reihenweise abbrechen, wenn grep einfach nichts findet.

Pipes und Exit-Codes

Eine Pipeline cmd1 | cmd2 | cmd3 startet alle drei Befehle parallel. Welcher Exit-Code zählt am Ende? Standardmäßig nur der des letzten Befehls — also der von cmd3. Die Codes der vorderen Stufen gehen verloren, was in Skripten oft genau das Gegenteil dessen ist, was man will.

false | true
echo $?

0

false schlägt mit 1 fehl, true liefert 0 — und die Pipeline gilt als erfolgreich. Mit set -o pipefail wechselt Bash das Verhalten: Die Pipeline liefert dann den Exit-Code des am weitesten links gelegenen Befehls, der mit Fehler endete; nur wenn alle Stufen 0 zurückgeben, ist auch die Pipeline 0.

set -o pipefail
false | true
echo $?

1

Empfehlung: In jedem ernsthaften Skript gehört set -o pipefail an den Anfang — meistens zusammen mit set -e und set -u als set -euo pipefail.

set -e (errexit)

set -e (kurz für errexit) lässt das Skript beim ersten fehlschlagenden Befehl abbrechen — in der Theorie. In der Praxis hat die Option eine Reihe von Ausnahmen, die regelmäßig zu Verwirrung führen. Ein Befehl mit Fehler-Exit beendet das Skript nicht, wenn er an einer der folgenden Stellen steht:

• in der Bedingung von if, while, until
• vor && oder || (außer es ist der letzte Befehl)
• mit vorangestelltem ! (Negation)
• als nicht-letzter Befehl in einer Pipe (sofern pipefail nicht aktiv ist)

set -e
if grep "muster" datei.txt; then
    echo "gefunden"
fi
echo "weiter"

Findet grep nichts, liefert es Exit-Code 1. Trotz set -e läuft das Skript weiter, weil grep Teil der if-Bedingung ist — genau das soll if ja prüfen. Das ist beabsichtigt und in den meisten Fällen die richtige Semantik.

Die häufigste Falle ist die Kombination mit Pipes: cmd | grep "x" bricht nicht ab, wenn cmd fehlschlägt, weil nur der Exit-Code von grep gewertet wird. Erst set -o pipefail macht set -e an dieser Stelle zuverlässig.

set -euo pipefail
cat /nichtvorhanden | grep "x"
echo "wird nicht erreicht"

PIPESTATUS-Array

Manchmal ist pipefail zu grob — du willst wissen, welche Stufe der Pipeline genau fehlschlug, oder unterschiedlich auf verschiedene Fehler reagieren. Bash stellt dafür das Array PIPESTATUS bereit: Pro Stufe ein Eintrag, in der Reihenfolge der Pipe.

false | true | false
echo "${PIPESTATUS[@]}"
echo "Erste Stufe: ${PIPESTATUS[0]}"
echo "Zweite Stufe: ${PIPESTATUS[1]}"
echo "Dritte Stufe: ${PIPESTATUS[2]}"

1 0 1
Erste Stufe: 1
Zweite Stufe: 0
Dritte Stufe: 1

PIPESTATUS ist nur direkt nach der Pipeline gültig — schon der nächste Befehl überschreibt das Array. Wer es weiterverwenden will, kopiert es in eine eigene Variable: codes=("${PIPESTATUS[@]}").

Praxis-Patterns

Die folgenden Muster decken die häufigsten Anwendungsfälle in Skripten ab. Jedes lässt sich isoliert verwenden, viele tauchen in Kombination am Anfang produktiver Skripte auf.

Status-Check kompakt

cmd && echo OK || echo FAIL

Die Kette && ... || ... ist die kürzeste Form einer Erfolgsverzweigung. Vorsicht: Wenn der Befehl im &&-Zweig (hier echo OK) selbst fehlschlägt, läuft der ||-Zweig zusätzlich — für robuste Logik ist if/else die sicherere Wahl.

Skript-Header

#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

set -e bricht bei Fehlern ab, set -u bei undefinierten Variablen, set -o pipefail propagiert Pipe-Fehler korrekt. Die IFS-Zuweisung verhindert das berüchtigte Wort-Splitting an Leerzeichen — eine Quelle vieler Skript-Bugs. Diese drei Zeilen sind die Mindestausstattung für jedes Skript, das im Fehlerfall nichts kaputtmachen darf.

Pipeline mit voller Status-Kontrolle

cmd1 | cmd2 | cmd3
echo "Codes: ${PIPESTATUS[@]}"
if [[ ${PIPESTATUS[0]} -ne 0 ]]; then
    echo "cmd1 ist fehlgeschlagen"
fi

So lässt sich gezielt auf eine bestimmte Stufe reagieren — etwa eine fehlende Eingabedatei in cmd1 anders behandeln als einen grep-Misserfolg in cmd2.

Cleanup-Trap mit Exit-Code-Erhalt

cleanup() {
    rm -f /tmp/skript.lock
}

trap 'rc=$?; cleanup; exit $rc' EXIT

Der Trap auf EXIT läuft bei jedem Skript-Ende — egal ob normal, durch exit, durch Signal oder durch set -e. rc=$? sichert den Exit-Code als allerersten Schritt; ohne diese Zeile würden Befehle innerhalb von cleanup den Wert überschreiben und das Skript würde am Ende mit dem Status der Aufräumarbeit terminieren.

Conditional Bail mit Fehlermeldung

cmd || { echo "fail: cmd lieferte $?" >&2; exit 1; }

Schlägt cmd fehl, schreibt der Block eine Meldung auf stderr und beendet das Skript mit Code 1. Die geschweiften Klammern fassen mehrere Befehle in derselben Shell zusammen — runde Klammern würden eine Subshell aufmachen, dann hätte exit keine Wirkung auf das Hauptskript.

Weiterführende Ressourcen

Externe Quellen

• Bash-Manpage: EXIT STATUS (man7.org) — Offizielle Definition aller Bash-Exit-Codes
• GNU Bash-Handbuch: Exit Status — Vollständige Referenz mit Beispielen
• GNU Bash-Handbuch: The Set Builtin — set -e, set -o pipefail und alle weiteren Optionen
• sysexits.h (FreeBSD) — BSD-Konventionen für strukturierte Exit-Codes (64-78)
• Greg’s Wiki: BashFAQ/105 — Why doesn’t set -e do what I expected? — Detaillierte Analyse der set -e-Fallen

Verwandte Artikel

• Linux Streams und Pipes — stdin, stdout, stderr und Pipe-Mechanik im Detail
• Linux Shell — Bash-Grundlagen und Built-ins
• Shell-Scripting Bedingungen — if, test, [[ ]] und Vergleichsoperatoren
• Shell-Scripting Funktionen — Funktionen, return und lokale Variablen
• Linux Manpages — Hilfeseiten effizient durchsuchen