A – Z | Suche | Kontakt

• Der login-Prozess
• Die Login-Umgebung
• Unix-Shells
  • Verfügbare Shells
  • Die Bash-Shell
    • Bash-Shell-interne Befehle
    • Shell-Variablen
    • Vordefinierte Shell-Variablen
    • Eingabeaufforderung (Prompt)
    • Verwendung von Wildcards
    • Umlenkung von Eingabe und Ausgabe: Filter
    • Pipe-Mechanismus
    • Suchpfad für Programme
    • History
    • Completing
    • Alias-Definitionen
• Prozeduren der Shell (Shellskripte)
  • Parameterübergabe
  • die Anweisungen for und case
  • Die Anweisungen if, while, until und test
• Kenndaten der Prozesse

Unter Unix ist ein Prozess der Ablauf einer Folge von Aktionen. Innerhalb eines Prozesses können nacheinander mehrere Programme ablaufen. Ein einzelnes Programm kann auch mehrere gleichzeitig laufende Tochterprozesse erzeugen und kontrollieren. Jedem Prozess ist eine eindeutige Nummer, PID (Process IDentification), zugeordnet.

Der Login-Prozess

Ein laufendes Unix-System verwaltet eine baumartige Struktur von Prozessen. Die Wurzel der Prozess-Struktur, der Prozess mit der PID 0, wird beim Start des Systems erzeugt. Dieser Prozess startet mehrere Systemprozesse, darunter den Prozess init mit der PID 1. Der Prozess init ist dann der Ausgangsprozess für alle weiteren Tochterprozesse des Systems. Dies können sowohl Benutzerprozesse als auch Dämonprozesse sein. Dämonprozesse sind systemseitig erzeugte Hintergrundprozesse, die unterschiedliche Dienstleistungen zur Verfügung stellen.

Nach erfolgreicher Anmeldung (login) startet der init-Prozess für jeden Benutzer einen eigenen Prozess, nämlich die systemseitig definierte Login-Shell. Mit dem Login wird der Benutzer Eigentümer genau dieses Prozesses und damit aller von diesem erzeugten Tochterprozesse. Verläßt der Benutzer die Login-Shell (exit), so ist seine Sitzung beendet.

Einen Überblick über die laufenden Prozesse kann man mit dem Kommando ps (process status) erhalten.

Beispiel:
ps

PID      TTY       TIME         CMD
4712     pts/0     0:00         ps
4711     pts/0     0:01         /bin/bash

Zwei Prozesse werden angezeigt, nämlich die Login-Shell mit der PID 4711 und der dem Kommando ps entsprechende Prozess mit der PID 4712.

Will man alle im System laufenden Prozesse sehen, so muss man die Option -a (alle an ein Terminal gebundenen Prozesse) und -x (alle nicht an ein Terminal gebundenen Prozesse) benutzen. Mit dem Kommando who kann man sich anzeigen lassen, welche Benutzer momentan an welchem Gerät arbeiten.

Beispiel:
who

x18      pts/2   Mar 26 11:26   (vulcan.urz.uni-h)
x41      pts/3   Mar 26 10:23   (guenther.urz.uni)
b09      pts/0   Mar 26 13:09   (xst0.urz.uni-hei)
b09      pts/4   Mar 13 13:39   (xst0.urz.uni-hei)
x13      pts/5   Mar 26 14:45   (xst1.urz.uni-hei)
b09      pts/1   Mar 18 15:50   (xst0.urz.uni-hei)
x13      pts/7   Mar 26 14:47   (xst1.urz.uni-hei)

Manchmal ist es auch notwendig, den Namen der eigenen Sitzung zu erfragen mit dem Kommando:
who am i

x18    pts/1           Mar 27  10:09

oder mit
id

uid=1018(x18) gid=0(system)

Die Login-Umgebung

Bei dem Login-Vorgang werden in Abhängigkeit von der eingestellten Login-Shell verschiedene Kommandoprozeduren ausgeführt. In der Bourne-Shell und ihren Abwandlungen (URZ) werden in der Regel zwei verschiedene Skripts ausgeführt. Bei dem ersten handelt es sich um ein für das ganze System gültiges Skript, das die Umgebung standardmäßig einrichtet. Dieses Skript ist in der Regel in der Datei /etc/profile enthalten und kann von allen Benutzern gelesen werden. Dieses Skript wird als erstes unmittelbar nach Login aufgerufen. Als zweites Skript wird - falls vorhanden - das benutzereigene Skript .profile aufgerufen.

Mit Hilfe dieses Skripts kann jeder Anwender seine Umgebung nach seinen persönlichen Präferenzen einrichten und z. B. die Umgebungsvariablen definieren, die von den nachfolgend verwendeten Kommandos benutzt werden.

Die sogenannten Umgebungsvariablen können bereits während des Login-Vorganges gesetzt werden. Bei einer Umgebungsvariablen handelt es sich um eine Zeichenfolge im Format name=wert, wobei name eine Folge von beliebigen Zeichen, mit Ausnahme des Dollarzeichens und des Leerzeichens, sein kann. Jedem Benutzer sind in der Regel eine Reihe von Umgebungsvariablen zugeordnet. Ihre Definition hängt vom benutzten System, der installierten Software und den Anforderungen des Anwenders ab.

Die Werte aller Umgebungsvariablen können mit dem Kommando env abgerufen werden. Das Kommando env gibt eine vollständige Auflistung aller definierten Umgebungsvariablen aus.

Unix-Shells

Verfügbare Shells

Während einer Sitzung am Rechner kommuniziert der Benutzer normalerweise nicht direkt mit dem Betriebssystem, sondern mit einem Programm, welches seine Kommandos liest, analysiert und dann entweder selbst ausführt oder an andere Programme weiterreicht. Dieses Programm wird als Kommandointerpreter bezeichnet und trägt den Namen Shell.

Die Unix-Shell ist kein Bestandteil des Betriebssystemkerns, sondern ein eigenes Programm, das wie jedes andere Unix-Kommando aufgerufen werden und auch ausgetauscht werden kann.

Auf den unterschiedlichen Unix-Implementierungen existiert eine Reihe verschiedener Shell-Programme. Die Bourne-Shell, benannt nach ihrem Autor Steve Bourne, ist auf praktisch allen Systemen vorhanden. Sie ist, was Komfort und Bedienerfreundlichkeit angeht, nicht mehr zeitgemäß. Allerdings hat sich ihre Skriptsprache als Quasistandard etabliert: Die meisten Shellskripte werden in der Skriptsprache der Bourne-Shell geschrieben und sind so auf allen Unix-Rechnern lauffähig.

Eine zweite, ebenfalls sehr weit verbreitete Shell, die C-Shell, entwickelt an der Universität von Kalifornien in Berkeley, stellt eine beträchtliche Erweiterung der Bourne-Shell dar, ist aber nicht auf allen Unix-Systemen vorhanden.

Die Shell, welche nach dem Login eines Benutzers gestartet wird, wird zunächst vom Systemverwalter festgelegt, sie kann vom Benutzer nachträglich mit dem Kommando chcs geändert werden. Man kann auch während einer Sitzung jederzeit eine Unter-Shell aufrufen, indem man z. B. das Kommando /bin/sh für eine Bourne-Shell eingibt. Im Unix-Pool des URZ sind unter anderem folgende Shells aufrufbar:

Kommando        Name der Shell
/bin/sh          Bourne-Shell
/bin/csh         C-Shell
/bin/ksh         Korne-Shell
/bin/tcsh        tcsh-Shell
/bin/bash        bash-Shell

Normalerweise steht der Ordner /bin im Suchpfad, sodass die Pfadangabe entfallen kann.

Mit dem Kommando exit wird diese Unter-Shell wieder verlassen und in die aufrufende Shell zurückgekehrt. Man kann die alte Shell auch ganz durch eine neue Shell ersetzen, in dem man die neue Shell mit dem Befehl exec aufruft, z. B. für die C-Shell den Befehl
exec /bin/csh benutzt. Jetzt würde aber der Befehl exit nicht nur die Shell, sondern die ganze Dialogsitzung (bzw. an einem X-Terminal zumindest das Fenster) schließen.

Die Bash-Shell

Die Bash-Shell ist ein sogenanntes Public-Domain-Programm und als Erweiterung der Bourne-Shell zu dieser aufwärtskompatibel. Sie bietet zudem wesentliche Ergänzungen gegenüber der Bourne-Shell und viele nützliche Funktionen der C-Shell. Die Skriptsprache ist identisch mit der der Bourne-Shell, sodass dafür geschriebene Shell-Skripte unverändert ablauffähig sind. All diese Tatsachen haben zu dem inzwischen recht hohen Verbreitungsgrad der Bash-Shell beigetragen, weshalb die Bash-Shell auch im Unix-Pool des URZ die standardmäßige Login-Shell ist.

Die Aufwärtskompatibilität zur Bourne-Shell bedeutet auch, dass alles, was in der Standardliteratur über diese zu finden ist, auch für die Bash-Shell gilt. Daher wird im folgenden auch in erster Linie auf die Erweiterungen der Bash-Shell eingegangen.

Sofern die Bash-Shell nicht schon als Login-Shell eingetragen ist, erfolgt ihr Aufruf durch: /bin/bash

Bash-Shell-interne Befehle

Die Bash-Shell kennt eine ganze Reihe sogenannter interner Befehle. Das sind Befehle, welche nicht von Platte geladen, sondern direkt von der Shell interpretiert und ausgeführt werden. Es wird auch kein eigener Prozess gestartet, wie es beim Aufruf eines Unix-Befehls oder -Programms der Fall wäre. Der Vorrat an internen Befehlen des Bash-Shell umfasst alle Befehle der Bourne-Shell, teilweise mit erweitertem Funktionsumfang bzw. weiteren Parametern. Außerdem sind einige Befehle neu hinzugekommen. Im einzelnen besitzt die Bash-Shell folgende interne Befehle:

alias, bg, bind, break, builtin, bye, cd, command, continue, declare, dirs, echo, enable, eval, exec, exit, export, fc, fg, getopts, hash, help, history, jobs, kill, let, local, logout, popd, pushd, pwd, read, readonly, return, set, shift, suspend, test, times, trap, type, ulimit, umask, unalias, unset, wait.

Selbstverständlich braucht man im Normalfall nur einige wenige Befehle aus dieser Liste. Die Befehle wurden jedoch aus folgendem Grund vollständig aufgelistet: Bei der Benennung eigener Programme oder Shell-Skripte ist darauf zu achten, dass man den Namen dafür von denen interner Befehle verschieden wählt, da sonst ohne besondere Vorkehrungen der entsprechende interne Befehl anstelle des eigenen Programms aufgerufen wird.

Eine Liste der internen Befehle mit deren Syntax erhält man über den Bash-Shell-internen Befehl help. Eine ausführliche Beschreibung einzelner Befehle liefert die Befehlsfolge help befehl. Der man-Befehl liefert keine Information zu shell-internen Befehlen. In manchen Fällen gibt er, irreführenderweise, Information aus zu eventuell gleichnamigen Befehlen und Unterkommandos anderer Unix-Befehle.

Shell-Variable

Shell-Variable sind stets Zeichenkettenvariable. Ihr Name besteht aus Buchstaben und Ziffern, muss aber mit einem Buchstaben beginnen. Zudem darf der Name auch noch das Unterstreichungszeichen enthalten. Groß-/Kleinschreibung wird unterschieden. Die Variablen dienen zum Teil zur Steuerung der Shell selbst, zur Steuerung anderer Programme oder einfach nur zur Aufnahme von Informationen, insbesondere im Zusammenhang mit Shell-Skripten.

Es gibt einige Variable, welche von der Shell selbst mit Werten vorbelegt werden. Dies sind die folgenden Variablen:

PPID, PWD, OLDPWD, REPLY, UID, BASH, BASH_VERSION, SHLVL, RANDOM, SECONDS, LINENO, OPTARG, OPTIND.

Eine ganze Reihe weiterer Variablen werden von der Shell benutzt, wobei ihnen in manchen Fällen auch ein Standardwert zugewiesen wird:

IFS, PATH, HOME, CDPATH, ENV, MAIL, MAILCHECK, MAILPATH, MAIL_EARNING, PS1, PS2, PS4, NO_PROMPT_VARS, HISTSIZE, HISTFILESIZE, OPTERR, PROMPT_COMMAND, IGNOREEOF, IGNORFEOF, HOSTTYPE, TMOUT, FCEDIT, FIGNORE, NOTIFY, NOTIFY, HISTORY_CONTROL, COMMAND_ORIENTED_HISTORY, GLOB_DOT_FILENAMES, ALLOW_NULL_GLOB_EXPANSION, HISTCHARS, NOLINKS, HOSTNAME_COMPLETION_FILE, NOCLOBBER, AUTO_RESUME, NO_EXIT_ON_FAILED_EXEC, CDABLE_VARS, PUSHD_SILENT.

Bei der Wahl der Namen für eigene Variable ist darauf zu achten, dass diese von den Namen aus den beiden obigen Listen verschieden gewählt werden. Am einfachsten geht das, wenn man für Namen eigener Variablen nur Kleinbuchstaben verwendet.

Variable werden nicht explizit deklariert oder vereinbart. Durch Benutzung eines neuen Namens wird automatisch eine entsprechende neue Variable vereinbart. Einen Wert weist man einer Variablen durch folgende Anweisung zu: Variable=wert wert kann in Hochkomma (Zeichen ' auf der <#>-Taste, nicht den Akzent) oder Gänsefüßchen eingeschlossen werden, insbesondere falls dort Sonderzeichen enthalten sind, welche andernfalls von der Shell als Metazeichen interpretiert würden. Auch wenn wert nur aus Ziffern besteht, handelt es sich um eine Zeichenkette.

Möchte man sich den Inhalt einer Variablen ausgeben lassen, so kann man dazu den shell-internen Befehl echo benutzen: echo $Variable Der echo-Befehl gibt einfach den ihm als Parameter übergebenen Text auf dem Bildschirm aus. Das $-Zeichen vor dem Variablennamen bewirkt, dass dieser durch den Inhalt der Variablen ersetzt wird. Insofern wird also hier dem echo-Befehl der Inhalt der angegebenen Variablen als Parameter übergeben. Die Liste aller vereinbarten Variablen einschließlich deren Inhalte kann man sich mit dem Befehl set anzeigen lassen.

Wie auch in vielen höheren Programmiersprachen, wird auch bei Shell-Variablen zwischen lokalen und globalen Variablen unterschieden. Ohne weitere explizite Vereinbarung sind Shell-Variable zunächst lokal. Das bedeutet, sie gelten nur für die aktuelle Shell. Sie werden nicht an eventuell daraus gestartete Prozesse oder Sub-Shells übergeben. Gleichnamige, ebenfalls lokale Variable in einer Subshell sind nicht mit denen der aktuellen Shell identisch.

Globale Variable hingegen, welche auch Umgebungsvariable genannt werden, sind auch allen von der aktuellen Shell aus gestarteten Programmen bekannt, also insbesondere auch in einer neuen Shell. Werden also Shell-Variable z. B dazu benutzt, um Informationen an Programme weiterzugeben, sind zu diesem Zweck globale Variable zu benutzen. Eine lokale Variable kann global gemacht werden mit dem Befehl export: export Variable

Hierbei kann auch gleich ein Wert mit zugewiesen werden: export Variable=Wert Man kann die zugewiesene Zeichenkette Wert wie bei der normalen Zuweisung auch wieder in Hochkomma oder Gänsefüßchen einschließen. Soll das Attribut global wieder aufgehoben werden, so benutzt man die Option -n des export-Befehles: export -n Variable

Die Namen aller globalen Variablen einschließlich der ihnen zugewiesenen Werte bekommt man durch Eingabe des export-Befehls ohne weitere Parameter.

Möchte man als Beispiel beim Aufruf des Editors vi erreichen, dass immer automatisch die Optionen showmode und number gesetzt sind, so kann man diese Informationen über die von vi dafür vorgesehene Shell-Variable EXINIT an den Editor übergeben. Das funktioniert aber nur, wenn diese Variable global ist, da für den Editor ein eigener Prozess gestartet wird.: export EXINIT="set showmode number" In den folgenden Abschnitten werden noch einige besondere Shellvariablen vorgestellt, welche insbesondere Ablauf und Verhalten der aktuellen Shell selbst steuern.

Vordefinierte Shell-Variablen

Eine Reihe von Variablen haben eine feste Bedeutung in der Shell und können nur zu diesem Zweck benutzt werden:

PATH

gibt den Kommando-Suchpfad für die Shell an. Diese Variable enthält volle Pfadnamen zu den Dateiordnern, die durchsucht werden müssen. Ein Doppelpunkt (:) schließt jeweils einen Pfad ab. Die angegebenen Ordner werden in der Reihenfolge durchsucht, in der sie in PATH angegeben worden sind.

HOME

enthält den vollen Pfadnamen des Login-Ordner (home-directory). HOME wird im Kommando cd als Standard-Parameter benutzt, falls kein anderer angegeben wird.

MAIL

Die Shell durchsucht nach jeder Kommandoausführung die in MAIL angegebene Datei nach einem neuen Eintrag. Wird ein Eintrag gefunden, so erscheint am Bildschirm eine entsprechende Meldung.

PS1

enthält das Zeichen, das die Shell bei interaktiver Benutzung ausgibt, sobald eine Eingabe erwartet wird.

PS2

Falls im Dialog syntaktische Shell-Strukturen benutzt werden, die über mehrere Zeilen gehen, so gibt die Shell am Beginn einer jeden neuen Zeile den Inhalt von PS2 aus, bis die Struktur abgeschlossen ist.

TERM

Bezeichnung des angeschlossenen Terminaltyps

USER

Benutzerkennung

SHELL

voller Pfadname des Shellinterpreters

UMASK

Aktuelle Einstellung für umask

Eingabeaufforderung (Prompt)

Standardmäßig fordert die Bash-Shell genau wie die Bourne-Shell mit einem Dollar-Zeichen ($) zur Eingabe auf. An dessen Stelle kann aber auch ein beliebiger, frei wählbarer Text ausgegeben werden, wobei hier auch der Inhalt von Variablen oder sogar die Ausgabe von Unix-Befehlen mit verarbeitet werden kann. Dieser sogenannte Prompttext wird einfach in der Shell-Variablen PS1 (groß geschrieben) abgelegt. Im einfachsten Fall enthält diese Variable nur konstanten Text so wie Zeichen aus folgender Tabelle (Auswahl):

Zeichen       Bedeutung
\d           Datum
\w           Arbeitsordner
\t           Uhrzeit
\h           Rechnername
\n           neue Zeile
\#           laufende Nummer

Der Prompttext sollte in Hochkomma eingeschlossen werden: PS1='Prompttext'

Um einen veränderlichen Prompttext zu erhalten, können innerhalb der Prompttextes aber auch Shellvariablen benutzt werden. Sie werden jeweils vor der jeweiligen Ausgabe des Textes durch ihren aktuellen Inhalt ersetzt. Dem Namen der Variablen ist ein $-Zeichen voranzustellen. Analog dazu können auch Befehle mit einbezogen werden. Sie werden jeweils vor Ausgabe des Prompttextes ausgeführt, sofern der Befehl zusammen mit eventuellen Parametern in ` eingeschlossen ist. Anstelle des Befehles selbst wird die Ausgabe des Befehles in den Prompttext übernommen.

Folgende Tabelle gibt einige Beispiele:

Inhalt von PS1                    Prompttext
'\h:$PWD>'                     aixfile2:/u/urz/x29>
'\h:\w>'                       aixfile2:~>
'`fs q`  \t\n\h:$PWD>'         27% of quota used.
                               14:00:09
                               aixfile2:/u/urz/x29>

Das erste Beispiel ist die Voreinstellung für den Prompttext im Unix-Pool des URZ. Anstelle der Shell-Variablen $PWD hätte auch die Zeichenkombination \w benutzt werden können, jedoch unterscheidet sich die Ausgabe etwas im Format.

Verwendung von Wildcards

Eine Wildcard ist ein Ersatzzeichen, das anstelle eines oder mehrerer beliebiger anderer Zeichen verwendet wird. Mit einem einzigen Befehl kann so eine gewünschte Aktion auf mehrere Dateien angewandt werden.

Folgende Wildcards können verwendet werden:

*          beliebige, 0-14 Zeichen lange Zeichenkette
?          genau ein beliebiges Zeichen
[bdz7]     genau eines der Zeichen b, d, z oder 7
[g-r]      genau ein Zeichen aus dem Bereich g bis r

Beispiele:

rm *	löscht alle Dateien im aktuellen Ordner
rm ?	löscht alle Dateien, deren Name aus genau einem Zeichen besteht
chmod 700 *	ändert die Zugriffsrechte aller Dateien im aktuellen Ordner
rm dat[1-3]a	löscht die Dateien dat1a, dat2a und dat3a

Hinweis:
Die aufgeführten Beispiele zum Löschen ganzer Dateigruppen sind nicht ganz ungefährlich. Vorsichtshalber sollte das rm-Kommando in folgender Form verwendet werden: rm -i (interaktives Löschen)

Umlenkung von Eingabe und Ausgabe: Filter

Ein Filter ist ein Programm mit folgenden Eigenschaften:

• Es liest von der Standardeingabe (stdin).
• Es schreibt auf die Standardausgabe (stdout).
• Fehlermeldungen gelangen auf die Standardfehlerausgabe (stderr).

Viele Kommandos sind Filter. Auch Benutzerprogramme sollten nach Möglichkeit als Filter geschrieben werden. Filter verfolgen ein virtuelles Dateikonzept. Es gibt folgende Voreinstellungen:

stdin       Tastatur
stdout      Bildschirm
stderr      Bildschirm

Durch Umlenkung auf der Shellebene können andere Dateien angeschlossen werden. Die Programme bleiben dabei völlig unberührt.

Folgende Umlenkzeichen können verwendet werden:

>	Ausgabeumlenkung (alter Dateiinhalt wird überschrieben)
>>	Ausgabeumlenkung (die Ausgabe wird an alten Dateiinhalt angehängt)
2>	Ausgabeumlenkung für stderr, stdout wird auf stderr gelegt
2>>	analog zu >>
1>&2	Standardkanal 1 wird auf Kanal 2 gelegt
<	Eingabeumlenkung

Beispiel:

Das Kommando ls -l > datei.liste speichert die Ausgabe des Kommandos ls -l in der Datei datei.liste.

Pipe-Mechanismus

Pipes sind namenlose, aus Benutzersicht transparente Dateien, die sich ausschließlich im Hauptspeicher befinden (RAM-Dateien). Mit Hilfe von Pipes können mehrere Filter zu Ketten verbunden werden. Die Standardausgabe (stdout) des ersten Filters wird zur Standardeingabe (stdin) des zweiten Filters usw. Dadurch erspart man sich die Angabe von temporären Zwischendateien. Das Pipezeichen ist der senkrechte Strich (|). Mit Hilfe von Pipes lassen sich mächtige und eventuell auch langlaufende Kommandos erzeugen.

Beispiel:
ls -l | more erzeugt eine bildschirmgerechte Ausgabe

Während mit Hilfe der Zeichen > und < die Dateiausgabe bzw. die Dateieingabe umgelenkt werden können, lassen sich mit Hilfe des |-Zeichens verschiedene Programme direkt verbinden, ohne dass Zwischendateien angegeben werden müssen.

Suchpfad für Programme

Eigentlich müßte beim Aufruf von Programmen oder auch Unix-Kommandos außer dem eigentlichen Dateinamen auch der komplette Pfad im Ordnerbaum mit angegeben werden. Zum einen würde das eine unnötig große Tipparbeit und damit auch Fehlerquelle bedeuten, zum anderen ist dem Benutzer bei vielen Befehlen gar nicht bekannt, wo diese abgelegt sind. Die Shell unterstützt hier den Benutzer durch Bereitstellung eines sogenannten Suchpfades.

In der Shellvariablen PATH steht dazu eine Liste von Ordnernamen. Die einzelnen Einträge sind jeweils durch Doppelpunkt getrennt. Wird nun ein Programmname oder Kommandoname eingegeben, so durchsucht die Shell nacheinander die einzelnen Ordner, welche in PATH angegeben sind, ob dort das betreffende Kommando zu finden ist.

Um nicht bei jedem Befehlsaufruf den gewünschten Befehl unter Zuhilfenahme des Suchpfades aufs neue suchen zu müssen, legt die Shell eine Tabelle an, in der alle bereits aufgerufenen Befehle zusammen mit der Pfadangabe eingetragen werden. Vor dem Durchsuchen der Ordner im Suchpfad wird zunächst in dieser Tabelle nachgeschaut. Ist ein Befehl dort bereits vorhanden, so wird die hier vermerkte Pfadangabe benutzt, um Zeit zu sparen. Diese Tabelle kann mit dem Shell-Befehl hash aufgelistet werden.

Für den seltenen, aber denkbaren Fall, dass sich der Ordner, in dem ein Befehl abgelegt ist, ändert (man hat z. B. ein Programm in einen anderen Ordner verschoben), muss man dafür Sorge tragen, dass ein eventuell bereits vorhandener Eintrag in der oben genannten Tabelle vorher gelöscht wird, da der Befehl sonst nicht gefunden wird, obwohl er in einem im Suchpfad enthaltenen Ordner steht. Hierzu benutzt man den hash-Befehl:

hash Kommando
hash -r Kommando

Im ersten Fall wird der Tabelleneintrag für das angegebene Kommando aktualisiert, im zweiten Fall gelöscht.

History

Die bash-Shell bietet eine wesentlich komfortablere Möglichkeit der Befehlseingabe als die C-Shell oder Bourne-Shell. Solange eine Befehlszeile noch nicht durch Drücken der Eingabetaste abgeschlossen wurde, kann sie beliebig korrigiert werden. Hierbei können auch die Tasten <Cursor links> und <Cursor rechts> benutzt werden.

Desweiteren werden alle eingegebenen Befehlszeilen in einem Puffer zwischengespeichert. Die Anzahl der Zeilen, welche in diesem Puffer Platz hat, wird in der Shell-Variablen HISTSIZE festgelegt (URZ-Voreinstellung: 500). Ist der Puffer voll, wird die älteste Zeile entfernt. Mit den Tasten <Cursor rauf> und <Cursor runter> kann in diesem Puffer geblättert werden, wobei die Befehlszeilen nacheinander in der Eingabezeile erscheinen. Eine solche Zeile kann beliebig verändert werden. Erst nach Betätigen der Eingabetaste wird sie ausgeführt. Diese Zeile steht dann als aktuelle Zeile im Puffer, gleichgültig, ob sie verändert wurde oder nicht. Dieser Mechanismus ist sehr hilfreich, wenn immer wieder eine bestimmte Befehlsfolge benötigt wird, sich aber die Programmierung eines Skriptes noch nicht lohnt: Beispiel: Quellenprogramm editieren, Compiler aufrufen, Programm aufrufen, wieder das Quellenprogramm editieren usw.

Dieser Puffer wird sogar nach Beendigung der Shell permanent abgespeichert. Hierzu wird normalerweise die Datei .bash_history benutzt. Der Name dieser Datei steht in der Shell-Variablen HISTFILE, die Anzahl der Zeilen, welche in dieser Datei abgelegt werden, ist der Variablen HISTFILESIZE abgelegt (URZ: 500). Beim Starten einer Shell, also insbesondere bei einem neuen Login, wird diese Datei wieder in den temporären Puffer kopiert, sodass sofort wieder die letzten Befehle aus der letzten Sitzung zur Verfügung stehen. Achtung:
Der temporäre Puffer wird nur zurückgeschrieben, wenn die Shell beendet wird (etwa durch die Befehle exit oder logout oder auch durch die Tastenkombination <Strg>+d). Schließen des Fensters oder gar Benutzung des Logout-Knopfes am X-Terminal "killt" den Prozess, in welchem die Shell abläuft, ohne die Shell ordnungsgemäß zu beenden.

Completing

Eine erhebliche Arbeitserleichterung bietet die Bash-Shell, indem sie, soweit möglich, eingetippte Namensanfänge durch Drücken der Tabulator-Taste vervollständigt. Es kann sich hierbei um Dateinamen, Rechnernamen oder auch um Namen von Shell-Variablen handeln. Ist der eingetippte Namensanfang bereits eindeutig, so wird er in der Eingabezeile so vervollständigt, als hätte man ihn eingetippt. Gibt es keinen Namen mit einem solchen Namensanfang, so ertönt ein akustisches Signal. Ist der eingetippte Bestandteil des Namens nicht eindeutig, so ertönt ebenfalls ein Signal. Danach kann aber durch nochmaliges Drücken der Tabulatortaste eine Liste aller infrage kommenden Namen angezeigt werden. Man sollte dann den eingegebenen Namensanfang soweit selbst vervollständigen, bis dieser eindeutig ist.

Normalerweise benutzt man diese Funktion zur Vervollständigung von Dateinamen. Da Unix-Befehle nichts anderes als in Dateien abgelegte Programme sind, gilt das gleiche auch für Namen von Befehlen und Skripten sowie shellinternen Befehlen. Steht vor dem eingetippten Namensanfang ein Leerzeichen (oder wird in der ersten Spalte der Eingabezeile begonnen), so versucht die Shell hier immer, auf einen gültigen Dateinamen zu vervollständigen. Beginnt der Namensanfang hingegen mit einem $-Zeichen, so wird, falls möglich, auf den Namen einer vorhandenen Shellvariablen ergänzt. Bei einer Tilde (~) nimmt die Shell an, es handele sich um einen Benutzerkennung, bei einem @-Zeichen wird auf einen gültigen Rechnernamen ergänzt.

Beginn mit ...      ergänze auf ...
                Befehl bzw. Datei
$               Variablenname
~               Benutzerkennung
@               Rechnername

Die Ergänzung auf Rechnernamen funktioniert allerdings nur mit Rechnern, welche in der Datei /etc/hosts eingetragen sind. Am URZ enthält die Datei /etc/hosts nur die minimal notwendigen Einträge. Ansonsten wird der domain naming service (DNS) verwendet.

Alias-Definitionen

Der shell-interne alias-Befehl ermöglicht das Vereinbaren sogenannter Kürzel für eine mehr oder weniger lange Befehlszeile: alias Kürzel=Text. Der Text rechts vom Gleichheitszeichen kann in Hochkomma oder Gänsefüßchen eingeschlossen werden. Die Eingabe des Kürzels als Befehl bewirkt dann die Ausführung des ihm zugewiesenen Textes so, als wäre dieser direkt eingegeben worden. Es folgen drei Beispiele

alias new="ls -lat | head"
alias ll="ls -la"
alias ls="ls -la"

Das erste Kürzel new liefert eine Liste der zehn zuletzt geänderten Dateien, das Kürzel ll eine ausführliche Dateiliste. Im dritten Beispiel erkennt man, dass man auch ein Kürzel definieren kann, dessen Name mit dem eines Befehles identisch ist. Der Befehl wird dadurch überschrieben; bei Eingabe von ls wird das entsprechende Kürzel benutzt. Soll dennoch einmal der Originalbefehl aufgerufen werden, so kann dazu der interne Befehl command benutzt werden: command ls bewirkt die direkte Ausführung des Unix-Befehles ls, obwohl ein gleichnamiges Kürzel vereinbart wurde.

Werden bei Aufruf des Kürzels Parameter mit angegeben, so werden diese an den betreffenden Text angehängt. Als Beispiel diene das eben vereinbarte Kürzel ll: ll otto führt folgenden Befehl aus. ls -la otto

Prozeduren der Shell (Shellskripte)

In Unix können Kommandos nicht nur interaktiv eingegeben werden. Eine Folge von Kommandos kann auch in eine Datei geschrieben werden und als Ganzes dann der jeweiligen Shell zur Ausführung gegeben werden, wobei hierzu nur noch der Name dieser Datei anzugeben ist. Dies ist besonders bei häufiger gebrauchten Kommandofolgen sehr nützlich. Eine solche Datei heißt Shellskript oder auch einfach Skriptdatei.

Im einfachsten Fall enthält ein solches Shellskript eine Folge von Unix-Befehlen, Programmaufrufen und shellinternen Befehlen, welche nach Aufruf des Skriptes sequentiell abgearbeitet wird. Zur Abarbeitung dieses Skriptes wird ein eigener Prozess mit einer Subshell gestartet, welche die Befehle dann interpretiert.

Zudem hat man noch die Möglichkeit, durch speziell dafür vorgesehene Sprachelemente von dieser sequentiellen Abarbeitung abzuweichen. Es gibt Anweisungen zur Programmierung von Schleifen und Verzweigungen. Sprünge sind jedoch nicht möglich. Zudem kann der Ablauf eines Shellskriptes auch durch Parameter gesteuert werden, welche beim Aufruf des Skriptes angegeben werden können. Diese Parameter stehen dann während der Ausführung des Skriptes in speziellen Shell-Variablen zur Verfügung und können beliebig verarbeitet werden.

Ein Shellskript ist aus Sicht des Betriebssystems eine normale Textdatei, welche mit jedem beliebigen Editor erstellt und bearbeitet werden kann. Zur Ausführung der Datei ist Leseberechtigung erforderlich. Der Aufruf geschieht über den Befehl sh: sh Shellskript-Datei Der Befehl sh startet eine Sub-Shell (Bourne-Shell), in welcher dann die Anweisungen der Skriptdatei ablaufen. Steht die Skriptdatei in einem Ordner, welches im Suchpfad enthalten ist, so kann sie direkt durch Eingabe ihres Namens aufgerufen werden. Voraussetzung hierfür ist jedoch, dass für den Aufrufer zusätzlich zur Leseberechtigung auch noch Ausführberechtigung besteht.

Parameterübergabe

Beim Aufruf eines Shellskriptes können Parameter an das Skript übergeben werden. Diese Parameter, welche durch Leerzeichen zu trennen sind, werden nacheinander den Shell-Variablen $1, $2, ..., $9 usw. zugewiesen. Die Anzahl der übergebenen Parameter steht in der Variablen $# zur Verfügung.

Werden mehr als 9 Parameter übergeben, so stehen der zehnte und alle weiteren Parameter nicht direkt zur Verfügung. Eine Möglichkeit ist hier die Benutzung der Variablen $*. Sie enthält die komplette Parameter-Zeichenkette wie beim Aufruf angegeben. Diese kann dann z. B. mit einer for-Schleife (siehe dort) ausgewertet werden. Eine andere Möglichkeit stellt der shellinterne Befehl shift dar: Durch den Aufruf von shift werden alle Parameter in die Variable mit der nächst niedrigeren Nummer verschoben. Der alte Inhalt von $2 steht dann in $1, der von $3 nun in $2 usw. Der Inhalt von $1 steht danach also nicht mehr zur Verfügung und muss daher gegebenenfalls vorher ausgewertet werden. Der zehnte, bisher unzugängliche Parameter steht nunmehr in $9 zur Verfügung. Durch Angabe einer positiven, ganze Zahl n kann dieser Vorgang beschleunigt werden: Der Aufruf shift 5 entspricht z. B. dem fünfmaligen Aufruf von shift.

Zudem gibt es noch die Variable $0, welche den Namen der aufgerufenen Skriptdatei in der Form enthält, wie dieser beim Aufruf angegeben wurde, also z. B. gegebenenfalls mit Pfadangabe. $0 wird durch den Befehl shift nicht verändert. Die Variable $$ enthält die PID, d. h. die Prozessnummer des das Skript ausführenden Prozesses.

Folgende Tabelle stellt die in diesem Abschnitt behandelten Variablen noch einmal zusammen:

Variable            Bedeutung
$0                Name der Skriptdatei mit Pfadangabe
$1, $2, ..., $9   erster bis neunter Parameter
$*                kompletter Parameterstring
$#                Anzahl der Parameter
$$                PID des Skriptes

Das Ganze soll nun noch durch ein kleines Beispiel verdeutlicht werden. Der Aufruf des Shellskriptes skript /u/urz/x29/skript Montag 17.5.1993 führt zu folgender Variablenbelegung:

Variable      Belegung
$0          /u/urz/x29/skript
$1          Montag
$2          17.5.1993
$#          2
$*          Montag 17.5.1993

Anweisungen for und case

Mit der for-Anweisung kann eine Folge von Anweisungen innerhalb der Skriptes mehrfach abgearbeitet werden. Eine Shellvariable dient hierbei als Laufvariable; ihr Inhalt wird bei jedem Schleifendurchlauf verändert. Die for-Anweisung hat folgende Syntax:

for Variable in Liste
  do
   ...
  done

Variable steht für den Namen der zu benutzenden Laufvariablen. Dieser ist ohne $-Zeichen anzugeben. Liste ist eine Zeichenkette. Der Schleifenkörper, das sind die Anweisungen zwischen do und done (oben durch ... dargestellt), wird entsprechend der Anzahl der Wörter in Liste durchlaufen, wobei der Laufvariablen Variable vor jedem Durchlauf jeweils das nächste Wort aus Liste zugewiesen wird. Die Wörter in Liste werden durch ein oder mehrere Leerzeichen getrennt. Fehlt das Schlüsselwort in zusammen mit Liste, so wird die Zeichenkette $*, also die beim Aufruf der Skriptes als Parameter angegebene Zeichenkette benutzt.

Folgender Ausschnitt aus einem Shell-Skript löscht alle Dateien im aktuellen Ordner, deren Name mit .text endet, und gibt für jede Datei eine entsprechende Meldung aus:

for i  in  *.text
   do
     rm -r $i
     echo Datei $i geloescht
   done

Hierbei wird von der Shell der Text *.text durch eine Liste aller diesen Namensmuster entsprechenden Dateinamen ersetzt.

Eine for-Schleife kann vorzeitig verlassen werden. Die Anweisung break beendet die Schleifenausführung durch einen Sprung nach außerhalb auf die der Schleife folgende Anweisung. continue hingegen bewirkt einen Sprung auf die erste Anweisung innerhalb der Schleife, wobei die Laufvariable mit dem nächsten Wert belegt wird. Beiden Anweisungen kann noch eine positive ganze Zahl als Parameter übergeben werden, wobei dann bei geschachtelten Schleifen gleich mehrere innere Schleifen verlassen werden bzw. an den Anfang einer entsprechend weit außen liegenden Schleife gesprungen wird.

Die case-Anweisung arbeitet ähnlich wie gleichnamige Anweisung in Programmiersprachen wie etwa Pascal oder C, wenn auch mit etwas anderer Syntax.:

case Wort in
  muster1)  Kommandofolge1;;
  muster2)  Kommandofolge2;;
    .....
  *) KommandofolgeN;;
esac

Wort sowie die verschiedenen Vegleichsmuster Muster sind Zeichenketten; die rechte Klammer dahinter dient zur Trennung und gehört nicht zur Zeichenkette selbst. Wort, normalerweise der Inhalt einer Shellvariablen, wird zuerst mit dem ersten angegebenen Muster verglichen. Bei Übereinstimmung wird die dort angegebene Kommandofolge ausgeführt, danach an die nächste Anweisung hinter esac verzweigt. Andernfalls wird mit dem nächsten Muster verglichen usw. Tritt bei keinem Vergleich Übereinstimmung auf, so wird die Kommandofolge in der mit * beginnenden Zeile ausgeführt. Diese Zeile kann auch weggelassen werden. Ohne Übereinstimmung mit einem Vergleichsmuster wird dann ebenfalls mit der auf esac folgenden Anweisung fortgefahren.

Enthalten die einzelnen Kommandofolgen mehrere Kommandos, so sind diese durch Semikolon (;) zu trennen und können auch auf mehrere Zeilen verteilt werden. Aus diesem Grund muss stets mit einem doppelten Semikolon abgeschlossen werden, auch wenn die Kommandofolge nur aus einem einzelnen Kommando besteht.

Es folgt ein Beispiel zur Verwendung der case-Anweisung. Zur Demonstration diene ein kleines Shellskript namens dirprint. Das Skript druckt den Inhalt des aktuellen Ordners aus. Als Parameter können -kurz, -lang oder -ganzlang angegeben werden, je nach dem, wie ausführlich die Liste sein soll. Bei allen anderen Parameterangaben erfolgt eine (knappe) Fehlermeldung:

case  $1  in
  -kurz)        ls | lpr;;
  -lang)        ls -lag | lpr;;
  -ganzlang)    ls -lagR | lpr;;
  *)            echo "haeh ??";;
esac

Der einzige zu übergebende Parameter steht in der Variablen $1 zur Verfügung. Sollte beim Aufruf gar kein Parameter angegeben worden sein, so ist $1 leer, was ebenfalls zur Ausgabe der Fehlermeldung führt.

Anweisungen if, while, until und test

Die Anweisungen if, while und until erlauben die Ablaufsteuerung in Abhängigkeit des sogenannten Exit-Status eines oder mehrerer Kommandos. Jedes Kommando oder Programm liefert bei Beendigung einen Exit-Status. So ist zum Beispiel der Exit-Status des C-Compilers gleich 0, wenn bei der Compilation keine Fehlermeldungen auftraten. Er ist größer als 0 je nach der Schwere der aufgetretenen Fehler. Wann welches Kommando oder Programm welchen Exit-Status liefert, ist der zugehörigen Dokumentation zu entnehmen.

Zur Formulierung von Vergleichsoperationen dient die test-Anweisung. Hiermit können, speziell im Zusammenhang mit den Anweisungen if, while und until, Verzweigungen und bedingte Schleifen programmiert werden.

Die einfache Form der if-Anweisung hat folgende Syntax:

if Kommandofolge
  then Kommandofolge
  else Kommandofolge
fi

Besteht Kommandofolge aus mehr als einem Kommando, so sind diese durch Semikolon (;) zu trennen. Es können auch mehrere Zeilen benutzt werden. Ist der Exit-Status der Kommandofolge hinter if gleich 0, so wird die Kommandofolge hinter then abgearbeitet, andernfalls die hinter else. Danach wird mit der auf fi folgenden Anweisung fortgefahren. Die else-Klausel kann auch entfallen.

In der erweiterten Form der if-Aweisung können noch eine oder mehrere elif-Klauseln verwendet werden:

if Kommandofolge
  then Kommandofolge
  elif Kommandofolge
    then Kommandofolge
  elif Kommandofolge
    then Kommandofolge
         ...
  else Kommandofolge
fi

Ist der Exit-Status der Kommandofolge hinter if von 0 verschieden, so kommt die Kommandofolge hinter der ersten elif-Klausel zur Ausführung, wobei dann in Abhängigkeit dessen Exit-Status entweder die Kommandofolge hinter der zugehörigen then-Klausel oder aber der nächsten elif-Klausel abgearbeitet wird.

Sicher kommt es häufig vor, dass man mit der if-Anweisung eine Programmverzweigung in Abhängigkeit einer oder mehrerer Bedingungen programmieren kann. Da aber auf if immer Kommandos folgen, also keine Bedingung, benutzt man hier die test-Anweisung. Ihr wird als Parameter eine Bedingung übergeben. test liefert dann seinerseits einen Exit-Status 0, falls die Bedingung erfüllt ist. Andernfalls ist der Exit-Status von 0 verschieden.

Mit test kann entweder das Vorhandensein einer Datei oder das Ergebnis einer Vergleichsoperation abgefragt werden. Im folgenden werden beide Möglichkeiten kurz angerissen. Weitere Informationen erhält man durch help test, da test ein shellinterner Befehl ist.

Möchte man das Vorhandensein einer bestimmten Datei abfragen, so übergibt man test den entsprechenden Dateinamen und stellt diesem noch ein Attribut voran, welches zusätzlich abgefragt wird. Existiert die Datei und hat zusätzlich das gewünschte Attribut, so gibt test den Exit-Status 0 zurück.

Mögliche Argumente für test sind folgende:

-r Datei      Datei existiert und es besteht Leseerlaubnis
-w Datei      Schreiberlaubnis
-x Datei      ausführbar
-f Datei      "normale" Datei
-d Datei      Ordner (Directory)
-s Datei      Datei nicht leer

So kann zum Beispiel abgefragt werden, ob die Datei /etc/hosts existiert und eine gewöhnliche Datei, also z. B. kein Ordner o. ä. ist, mit folgender if-Anweisung: if test -f /etc/hosts Eine andere häufig anzutreffende Schreibweise ist die folgende: if [ -f /etc/hosts ] Beide Zeilen sind jedoch in der Wirkung identisch. Man beachte die Leerzeichen neben den eckigen Klammern, welche wesentlich sind.

Die andere Möglichkeit ist, als Parameter für test eine Vergleichsbedingung zu formulieren, wobei hier sowohl Zeichenkettenvergleiche als auch arithmetische Vergleiche möglich sind. Arithmetische Vergleiche setzen natürlich voraus, dass die Operanden numerisch interpretiert werden können.

Im einzelnen sind folgende arithmetische Vergleiche möglich:

-lt      kleiner
-le      kleiner gleich
-eq      gleich
-ne      ungleich
-ge      größer gleich
-gt      größer

Hingegen gibt es nur zwei Zeichenkettenvergleiche:

=       gleich
!=      ungleich

Der Unterschied z. B. zwischen = und -eq wird schnell durch folgendes Beispiel deutlich: Es gilt zwar 012 -eq 12, aber 012 != 12.

Mehrere Vergleiche bzw. Bedingungen können logisch verknüpft werden, und zwar durch -a (und-Verknüpfung) oder -o (oder-Verknüpfung). Beispiel:

if test $a = Fehler -a -f /etc/error
if [ $a = Fehler -a -f /etc/error ]

Zur Programmierung von Schleifen dienen neben der bereits vorgestellten for-Anweisung insbesondere die Anweisungen while und until. Hier wird eine Gruppe von Anweisungen solange wiederholt abgearbeitet, bis eine bestimmte Kommandofolge einen Exit-Status ungleich 0 (while) oder den Exit-Status 0 (until) liefert. Die Syntax beider Befehle ist recht ähnlich:

while Kommandofolge
  do
     ...
  done

bzw.

until Kommandofolge
  do
     ...
  done

Auch bei der until-Schleife wird die Kommandofolge, deren Exit-Status über einen erneuten Schleifendurchlauf entscheidet, immer zu Beginn ausgeführt. Hier unterscheidet sich die until-Anweisung von den gleichnamigen Anweisungen in C oder Pascal. Analog zur for-Anweisung können auch wieder die Anweisungen break und continue verwendet werden.

Kenndaten der Prozesse

Jedem Prozess ist eine Reihe von Prozessdaten zugeordnet. Einen Teil dieser Daten kann man sich mit dem Kommando

ps -aefl anzeigen lassen.

Neben den angezeigten Prozessdaten existieren noch weitere Kenndaten, die nicht angezeigt werden, wie z. B. die GID des Prozesses oder der Ordner, von dem aus der Prozess gestartet wurde.

    F  S  UID  PID   PPID  C  PRI NI  ADDR  SZ   WCHAN   STIME   TTY   TIME  CMD
202803 S  root 1     0     0  60  20  1004  160          Mar 10   -    15:31 /etc/init
240801 S  root 1977  1     0  60  20  34ad   88  1cd4a18 Mar 10   -    4:25  /etc/syncd 60
260801 S  root 2259  1     0  60  20  18c6  240          Mar 10   -    0:00  /etc/srcmstr
42801  S  root 3259  1     0  60  20  50b4  240  bb18    Mar 10   -    0:00  /usr/lib/errdemon
240801 S  root 3350  2259  0  60  20  314c  144          Mar 10   -    0:00  /etc/qdaemon
240801 S  x18  3717  1     0  60  20  11a4  120          11:25:01hft/1 0:00  ksh usr/bin/X11/xinit
260801 S  x18  4490  3717  0  60  20  6539  436          11:25:10hft/1 0:00  mwm
200001 R  x18  4795  5017  8  64  20  1104  140          12:06:40pts/1 0:00  ps -aelf
240801 S  x18  5017  7320  1  60  20  7a5e  136          11:55:02pts/1 0:00  /bin/ksh
260801 S  root 5855  2259  0  60  20  30ec  152          Mar 10   -    0:10  /etc/syslogd
260801 S  root 6114  2259  0  60  20  58f6  228          Mar 10   -    0:00  /usr/lib/sendmail -bd -q30m
60801  S  root 6892  1     0  60  20  290a  288          Mar 10   -    0:00  /etc/inetd
260801 S  x18  7059  1     0  60  20  4e1   280          11:25:57 -    0:04  aixterm
260801 S  x18  7320  1     0  60  20  1ca7  280          11:55:02 -    0:02  aixterm
250001 Z  x18  7565  4490  0  60  20                                   0:00  <defunct>
260801 S  root 8704  2259  0  60  20  7d1f  176          Mar 10   -    0:00  /usr/etc/rpc.mountd
260801 S  root 8962  2259  0  60  20  922   152          Mar 10   -    0:00  /usr/etc/rpc.statd
260801 S  root 9220  2259  0  60  20  1d27  164          Mar 10   -    0:00  /usr/etc/rpc.lockd
240801 S  root 9478  1     0  26  20  1926  228  1db614  Mar 10   -    5:05  /etc/cron
60801  S  root 9752  1     0  60  20  4411  616          Mar 10   -    0:27  /usr/vice/etc/afsd -rmtsys
240801 S  x18  10486 1     0  60  20  318c  132  1bce07c Mar 24  hft/0 0:02  -ksh
260801 S  x18  10887 1     2  61  20  5d77  2244         11:25:02hft/1 0:30  /usr/lpp/X11/bin/X c 0
250001 Z  x18  11151 4490  0  60  20                                   0:00  <defunct>
240801 S  root 11278 1     0  60  20  5d37   92  1daf4c  Mar 10   -    4:48  /usr/lpp/monitor/loadavgd
40001  S  root 11792 1     0  60  20  1144  228          Mar 10   -    2:17  /usr/vice/etc/afsd -rmtsys
40001  S  root 12049 1     0  23  20  1946  244  1db5d4  Mar 10   -    0:00  /usr/vice/etc/afsd -rmtsys
40001  S  root 12306 1     0  23  20  2148  256  1db5d4  Mar 10   -    0:00  /usr/vice/etc/afsd -rmtsys
240801 S  root 12567 2259  0  60  20  4551  112  1dae7c  Mar 10   -    0:00  /etc/writesrv
240801 S  x18  13460 7059  0  60  20  7c5f  124          11:25:58pts/0 0:00  /bin/ksh
220801 S  x18  13717 13460 0  60  20  2449  248          11:26:03pts/0 0:05  telnet aix950a

Die verschiedenen Ausgabefelder bedeuten folgendes:

F

systemintern benutzte Flags; z. B. bedeutet 000001, dass dieser Prozess sich im Arbeitsspeicher befindet.

UID

UID-Nummer des Prozesseigentümers

PID

Prozessnummer des laufenden Prozesses

PPID

Prozessnummer des übergeordneten Prozesses (Parent Process IDentification)

C

Scheduling-Parameter

PRI

Priorität

NI

Nice-Wert für die Prioritätenberechnung

ADDR

Hauptspeicher oder Plattenadresse des Prozesses

SZ

virtuelle Speichergröße des Prozesses

WCHAN

Eventnummer, auf die der Prozeß wartet

S

bezeichnet den Zustand des Prozesses
- O Der Prozess existiert nicht
- W Der Prozess wartet auf ein Ereignis
- I Der Prozess ist in einem Zwischenzustand
- T Der Prozess wurde angehalten
- S Der Prozess wurde suspendiert
- R Der Prozess ist aktiv
- Z Der Prozess ist terminiert (Zombie)
- X Der Prozess wächst

TTY

gibt das Peripheriegerät an, von dem aus der Prozess gestartet wurde. Ist an dieser Stelle ein Fragezeichen, so bedeutet dies, dass dieser Prozess keinem Terminal zuzuordnen ist.

CMD

Name des Kommandos, das den Prozess gestartet hat