103.5 Lektion 1

Zertifikat:

LPIC-1

Version:

5.0

Thema:

103 GNU- und Unix-Befehle

Lernziel:

103.5 Prozesse erzeugen, überwachen und beenden

Lesson:

1 von 2

Einführung

Jedes Mal, wenn wir einen Befehl aufrufen, werden ein oder mehrere Prozesse gestartet. Ein gut ausgebildeter Systemadministrator muss nicht nur Prozesse erstellen, sondern auch in der Lage sein, diese zu verfolgen und diesen bei Bedarf verschiedene Arten von Signalen zu senden. In dieser Lektion werden wir uns mit der Steuerung und der Überwachung von Prozessen (auch Jobs genannt) befassen.

Steuerung von Jobs

Jobs sind Prozesse, die interaktiv über ein Terminal gestartet, in den Hintergrund geschickt und noch nicht fertiggestellt wurden. Sie können sich über die aktiven Jobs (und ihren Status) in Ihrem Linux-System informieren, indem Sie den Befehl jobs ausführen:

$ jobs

Der obige Befehl jobs hat keine Ausgabe produziert, was bedeutet, dass es im Moment keine aktiven Jobs gibt. Lassen Sie uns unseren ersten Job erstellen, indem wir einen Befehl ausführen, dessen Ausführung einige Zeit in Anspruch nimmt (den Befehl sleep mit einem Parameter von 60) und — während er läuft — Strg+Z drücken:

$ sleep 60
^Z
[1]+  Stopped                 sleep 60

Die Ausführung des Befehls wurde gestoppt (oder — besser gesagt — angehalten) und die Eingabeaufforderung ist wieder verfügbar. Sie können ein zweites Mal nach Jobs suchen und finden jetzt den angehaltenen Job:

$ jobs
[1]+  Stopped                 sleep 60

Lassen Sie uns das Ergebnis genauer betrachten:

[1]: Diese Nummer ist die Job-ID und kann — durch ein vorangestelltes Prozentsymbol (%) — verwendet werden, um den Status des Jobs durch die Hilfsprogramme fg, bg und kill zu ändern (was später noch gezeigt wird).
+: Das Pluszeichen zeigt den aktuellen Standardauftrag an (d.h. den letzten Job, der angehalten oder in den Hintergrund geschickt wurde). Der vorherige Job wird mit einem Minuszeichen (-) gekennzeichnet. Alle anderen früheren Jobs werden nicht gekennzeichnet.
Stopped: Beschreibung des Jobstatuses.
sleep 60: Der Befehl oder Job selbst.

Mit der Option -l wird bei Jobs zusätzlich die Prozess-ID (PID) direkt vor dem Status angezeigt:

$ jobs -l
[1]+  1114 Stopped                 sleep 60

Weitere Optionen von jobs lauten:

-n: Listet nur Prozesse auf, die seit der letzten Meldung ihren Status geändert haben. Mögliche Status sind Running, Stopped, Terminated oder Done.
-p: Listet Prozess-IDs auf.
-r: Listet nur laufende Jobs auf.
-s: Listen nur gestoppte (oder angehaltene) Jobs.

Note	Denken Sie daran, dass ein Job sowohl eine Job-ID als auch eine Prozess-ID (PID) besitzt.

Spezifikation von Jobs

Der Befehl jobs sowie andere Dienstprogramme wie fg, bg und kill (die wir im nächsten Abschnitt betrachten werden) benötigen eine Job-Spezifikation (oder jobspec), um einen bestimmten Job ausführen zu können. Wie wir gerade gesehen haben, kann dies — und so ist es normalerweise — die Job-ID sein, welcher ein % vorangestellt ist. Es sind jedoch auch andere Job-Spezifikation möglich. Schauen wir sie uns folgendes an:

%n

Job, dessen ID-Nummer n ist:

$ jobs %1
[1]+  Stopped                 sleep 60

%str

Job, dessen Befehlszeile mit str beginnt:

$ jobs %sl
[1]+  Stopped                 sleep 60

%?str

Job, dessen Befehlszeile str enthält:

$ jobs %?le
[1]+  Stopped                 sleep 60

%+ oder %%

Aktueller Job (derjenige, der zuletzt im Hintergrund gestartet oder aus dem Vordergrund angehalten wurde):

$ jobs %+
[1]+  Stopped                 sleep 60

%-

Vorhergehender Job (derjenige, der vor %+ war):

$ jobs %-
[1]+  Stopped                 sleep 60

Da es in unserem Fall nur einen Job gibt, ist dieser sowohl der Aktuelle als auch der Vorherige.

Status von Jobs: Anhalten, Vordergrund und Hintergrund

Sobald ein Job im Hintergrund läuft oder angehalten wurde, können wir drei Dinge mit ihm machen:

Bringen Sie den Job mit fg in den Vordergrund:
```
$ fg %1
sleep 60
```
fg rückt den angegebenen Job in den Vordergrund und macht ihn zum aktuellen Job. Jetzt können wir warten bis er beendet ist, ihn erneut mit Strg+Z stoppen oder mit Strg+C abbrechen.
Bringen Sie den Job nun mittels bg in den Hintergrund:
```
$ bg %1
[1]+ sleep 60 &
```
Einmal im Hintergrund, kann der Auftrag mit fg wieder in den Vordergrund geholt oder abgebrochen werden (siehe unten). Beachten Sie das kaufmännische Und (&), was bedeutet, dass der Job in den Hintergrund geschickt wurde. Tatsächlich können Sie das kaufmännische Und auch verwenden, um einen Prozess direkt im Hintergrund zu starten:
```
$ sleep 100 &
[2] 970
```
Zusammen mit der Job-ID des neuen Jobs ([2]) erhalten wir nun auch dessen Prozess-ID (970). Nun laufen beide Jobs im Hintergrund:
```
$ jobs
[1]-  Running                 sleep 60 &
[2]+  Running                 sleep 100 &
```
Etwas später ist die Ausführung des ersten Auftrags beendet:
```
$ jobs
[1]-  Done                    sleep 60
[2]+  Running                 sleep 100 &
```
Beenden Sie den Job durch das Signal SIGTERM mittels kill:
```
$ kill %2
```
Um sicherzugehen, dass der Job abgebrochen wurde, führen Sie jobs erneut aus:
```
$ jobs
[2]+  Terminated                 sleep 100
```

Note	Wenn kein Job angegeben ist, werden `fg` und `bg` auf den aktuellen, voreingestellten Job reagieren. `kill` benötigt jedoch immer eine Job-Spezifikation.

Losgelöste Jobs: `nohup`

Die Jobs, die wir in den vorherigen Abschnitten gesehen haben, waren alle an die Sitzung des Benutzers angehängt, der sie aufgerufen hat. Das heißt, wenn die Sitzung beendet wird, sind die Jobs weg. Es ist jedoch möglich, Jobs von Sitzungen zu trennen und sie auch nach dem Beenden der Sitzung weiterlaufen zu lassen. Dies wird mit dem Befehl nohup (“no hangup”) erreicht. Die Syntax lautet wie folgt:

nohup BEFEHL &

Denken Sie daran, dass das & den Prozess in den Hintergrund schickt und das Terminal, an dem Sie arbeiten, freigibt.

Lösen wir den Hintergrundauftrag ping localhost von der aktuellen Sitzung:

$ nohup ping localhost &
[1] 1251
$ nohup: ignoring input and appending output to 'nohup.out'
^C

Die Ausgabe zeigt uns die Job-ID ([1]) und die PID (1251), gefolgt von einer Nachricht, die uns über die Datei nohup.out informiert. Dies ist die Standarddatei, in der stdout und stderr gespeichert werden. Jetzt können wir Strg+C drücken, um die Eingabeaufforderung freizugeben, die Sitzung schließen, eine weitere Sitzung als root starten und tail -f benutzen, um zu überprüfen, ob der Befehl läuft und die Ausgabe in die Standarddatei geschrieben wird:

$ exit
logout
$ tail -f /home/carol/nohup.out
64 bytes from localhost (::1): icmp_seq=3 ttl=64 time=0.070 ms
64 bytes from localhost (::1): icmp_seq=4 ttl=64 time=0.068 ms
64 bytes from localhost (::1): icmp_seq=5 ttl=64 time=0.070 ms
^C

Tip	Anstatt die Standarddatei `nohup.out` zu verwenden, hätten Sie die Ausgabedatei Ihrer Wahl mit `nohup ping localhost > /Pfad/zu/ihrer/ Datei &` angeben können.

Wenn wir den Prozess beenden wollen, sollten wir nun seine PID nutzen:

# kill 1251

Prozessüberwachung

Ein Prozess oder Task ist eine Instanz eines laufenden Programms. Daher erstellen Sie jedes Mal, wenn Sie Befehle in das Terminal eingeben, neue Prozesse.

Der Befehl watch führt ein Programm periodisch (standardmäßig aller 2 Sekunden) aus und erlaubt es uns, die zeitliche Veränderung der Ausgabe des Programms zu beobachten. So können wir zum Beispiel beobachten, wie sich die durchschnittliche Last ändert, wenn mehrere Prozesse ausgeführt werden, indem wir watch uptime ausführen:

Every  2.0s: uptime          debian: Tue Aug 20 23:31:27 2019

 23:31:27 up 21 min,  1 user,  load average: 0.00, 0.00, 0.00

Der Befehl läuft bis zur manuellen Unterbrechung, so dass wir ihn mit Strg+C abbrechen müssen. Als Ausgabe erhalten wir zwei Zeilen: Die Erste entspricht watch und sagt uns, wie oft der Befehl ausgeführt wird (Every 2.0s: uptime), welchen Befehl/welches Programm wir beobachten (uptime) sowie den Hostnamen und das Datum (debian: Tue Aug 20 23:31:27 2019). Die zweite Ausgabezeile ist jene von uptime und enthält die Zeit (23:31:27), wie lange das System bereits läuft (up 21 min), die Anzahl der aktiven Benutzer (1 user) und die durchschnittliche Systemauslastung oder die Anzahl der Prozesse in Ausführung oder im Wartezustand für die letzten 1, 5 und 15 Minuten (load average: 0.00, 0.00, 0.00).

Auf ähnliche Weise können Sie die Speichernutzung mit watch free überprüfen, wenn neue Prozesse erstellt werden:

Every  2.0s: free            debian: Tue Aug 20 23:43:37 2019

 23:43:37 up 24 min,  1 user,  load average: 0.00, 0.00, 0.00
              total        used        free      shared  buff/cache   available
Mem:       16274868      493984    14729396       35064     1051488    15462040
Swap:      16777212           0    16777212

Um das Aktualisierungsintervall für watch zu ändern, benutzen Sie die Optionen -n oder --interval plus die Anzahl der Sekunden wie folgt:

$ watch -n 5 free

Nun wird der Befehl free alle 5 Sekunden ausgeführt.

Für weitere Informationen über die Optionen für uptime, free und watch lesen Sie bitte deren Handbuchseiten.

Note	Die von `uptime` und `free` bereitgestellten Informationen sind auch in die umfassenderen Werkzeuge `top` und `ps` (siehe unten) integriert.

Signale an Prozesse senden: `kill`

Jeder einzelne Prozess hat einen eindeutigen Prozessidentifikator oder PID. Eine Möglichkeit, die PID eines Prozesses herauszufinden, besteht darin, den Befehl pgrep gefolgt vom Namen des Prozesses zu verwenden:

$ pgrep sleep
1201

Note	Die Kennung eines Prozesses kann auch durch den Befehl `pidof` herausgefunden werden (z.B. `pidof sleep`).

Ähnlich wie pgrep beendet der Befehl pkill einen Prozess aufgrund seines Namens:

$ pkill sleep
[1]+  Terminated              sleep 60

Um mehrere Instanzen desselben Prozesses zu beenden, kann der Befehl killall verwendet werden:

$ sleep 60 &
[1] 1246
$ sleep 70 &
[2] 1247
$ killall sleep
[1]-  Terminated              sleep 60
[2]+  Terminated              sleep 70

Sowohl pkill als auch killall funktionieren ähnlich wie kill, indem sie ein Abschlusssignal an den/die angegebenen Prozess(e) senden. Wenn kein Signal bereitgestellt wird, wird als Vorgabe SIGTERM gesendet. Allerdings nimmt kill nur entweder einen Job oder eine Prozess-ID als Argument an.

Signale können entweder spezifiziert werden durch:

Name:
```
$ kill -SIGHUP 1247
```
Nummer:
```
$ kill -1 1247
```
Option:
```
$ kill -s SIGHUP 1247
```

Damit kill ähnlich wie pkill oder killall funktioniert (und wir uns die Befehle ersparen, um zuerst die PIDs herauszufinden), können wir das Ersetzen von Befehlen verwenden:

$ kill -1 $(pgrep sleep)

Wie Sie bereits wissen sollten, lautet eine alternative Syntax kill -1 `pgrep sleep`.

Tip	Eine ausführliche Liste aller `kill`-Signale und ihrer Codes erhalten Sie, wenn Sie `kill -l` in ein Terminal eingeben. Benutzen Sie `-KILL` (`-9` oder `-s KILL`), um Rebellenprozesse zu beenden, wenn andere Signale fehlschlagen.

`top` und `ps`

Wenn es um die Prozessüberwachung geht, sind zwei Werkzeuge von unschätzbarem Wert: top und ps. Während Ersteres die Ausgabe dynamisch erzeugt, geschieht dies bei Letzterem statisch. In jedem Fall sind beide ausgezeichnete Hilfsmittel, um einen umfassenden Überblick über alle Prozesse im System zu erlangen.

Interagieren mit `top`

Um top aufzurufen, geben Sie einfach top ein:

$ top

top - 11:10:29 up  2:21,  1 user,  load average: 0,11, 0,20, 0,14
Tasks:  73 total,   1 running,  72 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0,0 us,  0,3 sy,  0,0 ni, 99,7 id,  0,0 wa,  0,0 hi,  0,0 si,  0,0 st
KiB Mem :  1020332 total,   909492 free,    38796 used,    72044 buff/cache
KiB Swap:  1046524 total,  1046524 free,        0 used.   873264 avail Mem

   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
   436 carol     20   0   42696   3624   3060 R  0,7  0,4   0:00.30 top
     4 root      20   0       0      0      0 S  0,3  0,0   0:00.12 kworker/0:0
   399 root      20   0   95204   6748   5780 S  0,3  0,7   0:00.22 sshd
     1 root      20   0   56872   6596   5208 S  0,0  0,6   0:01.29 systemd
     2 root      20   0       0      0      0 S  0,0  0,0   0:00.00 kthreadd
     3 root      20   0       0      0      0 S  0,0  0,0   0:00.02 ksoftirqd/0
     5 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 kworker/0:0H
     6 root      20   0       0      0      0 S  0,0  0,0   0:00.00 kworker/u2:0
     7 root      20   0       0      0      0 S  0,0  0,0   0:00.08 rcu_sched
     8 root      20   0       0      0      0 S  0,0  0,0   0:00.00 rcu_bh
     9 root      rt   0       0      0      0 S  0,0  0,0   0:00.00 migration/0
    10 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 lru-add-drain
    (...)

top erlaubt dem Benutzer eine gewisse Interaktion. Standardmäßig wird die Ausgabe in absteigender Reihenfolge nach dem Prozentsatz der von jedem Prozess verbrauchten CPU-Zeit sortiert. Dieses Verhalten kann durch Drücken der folgenden Tasten (von top aus) verändert werden:

M: Sortieren nach Speicherbenutzung.
N: Sortieren nach Prozess-ID Nummer.
T: Sortieren nach Ausführungszeit.
P: Sortieren nach Prozentsatz der CPU-Nutzung.

Tip	Um zwischen absteigender/aufsteigender Reihenfolge zu wechseln, drücken Sie einfach `R`.

Andere interessante Schlüssel zur Interaktion mit top sind:

? oder h: Hilfe.
k: Beenden einen Prozesses. top fragt sowohl nach der PID des zu beendenden Prozesses als auch nach dem zu sendenden Signal (standardmäßig SIGTERM oder 15).
r: Die Priorität eines Prozesses ändern (renice). top wird Sie nach dem nice-Wert fragen. Mögliche Werte sind -20 bis 19, aber nur der Superuser (root) kann ihn auf einen Wert setzen, der negativ oder niedriger als der Aktuelle ist.
u: Prozesse von einem bestimmten Benutzer auflisten (standardmäßig werden Prozesse von allen Benutzern angezeigt).
c: Zeigen Sie die absoluten Pfade von Programmen an und unterscheiden Sie zwischen Userspaceprozessen und Kernelspaceprozessen (in eckigen Klammern).
V: Baum-/Hierarchieansicht der Prozesse.
t und m: Ändern Sie das Aussehen der CPU- bzw. Speicherdarstellung in einem vierstufigen Zyklus: Die ersten beiden Eingaben bilden den Fortschrittsbalken ab, der Dritte blendet den Balken aus und der Vierte bringt ihn zurück.
W: Speichert die Konfigurationseinstellungen unter ~/.toprc.

Tip	Eine schickere und benutzerfreundlichere Version von `top` ist `htop`. Eine andere — vielleicht zu ausführliche — Alternative ist `atop`. Falls nicht bereits in Ihrem System installiert, benutzen Sie Ihren Paketmanager, um `atop` zu installieren und auszuprobieren.

Erläuterung der Ausgabe von `top`

Die Ausgabe von top ist in zwei Bereiche unterteilt: den Summarybereich und den Taskbereich.

Der Summarybereich von `top`

Der Summarybereich setzt sich aus den fünf obersten Reihen zusammen und gibt folgende Informationen wieder:

top - 11:10:29 up 2:21, 1 user, load average: 0,11, 0,20, 0,14
- aktuelle Zeit (im 24-Stunden-Format): 11:20:29
- Betriebszeit (wie lange das System bereits in Betrieb ist): up 2:21
- Anzahl der eingeloggten Benutzer und durchschnittliche Auslastung der CPU in den letzten 1, 5 und 15 Minuten: load average: 0,11, 0,20, 0,14
Tasks: 73 total, 1 running, 72 sleeping, 0 stopped, 0 zombie (information about the processes)
- Gesamtzahl der Prozesse im aktiven Modus: 73 total
- laufend (diejenigen, die ausgeführt werden): 1 running
- schlafend (diejenigen, die auf die Wiederausführung warten): 72 sleeping
- angehalten (durch ein Job-Steuersignal): 0 stopped
- Zombie (diejenigen, die die Ausführung abgeschlossen haben, aber immer noch darauf warten, dass ihr Elternprozess sie aus der Prozesstabelle entfernt): 0 zombie
%Cpu(s): 0,0 us, 0,3 sy, 0,0 ni, 99,7 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st (percentage of CPU time spent on)
- Benutzerprozesse: 0,0 us
- System/Kernelprozesse: 0,4 sy
- Prozesse mit einen nice-Wert — je höher der Wert, desto niedriger die Priorität: 0,0 ni
- nichts — CPU-Idle-Zeit: 99,7 id
- Prozesse, die auf E/A-Operationen warten: 0,0 wa
- Prozesse, die Hardwareinterrupts bedienen — Peripheriegeräte, die dem Prozessor Signale senden, welche Aufmerksamkeit erfordern: 0,0 hi
- Prozesse, die Softwareinterrupts bedienen: 0,0 si
- Prozesse, die Aufgaben anderer virtueller Maschinen in einer virtuellen Umgebung erledigen, also Zeit stehlen: 0,0 st
KiB Mem : 1020332 total, 909492 free, 38796 used, 72044 buff/cache (memory information in kilobytes)
- die Gesamtmenge des Speichers: 1020332 total
- ungenutzter Speicher: 909492 free
- verwendeter Speicher: 38796 used
- der Speicher, der gepuffert und zwischengespeichert ist, um übermäßigen Plattenzugriffe zu vermeiden: 72044 buff/cache
  
  Beachten Sie, dass die Gesamtmenge die Summe der anderen drei Werte — free, used und buff/cache-- entspricht (in unserem Fall etwa 1 GB).
KiB Swap: 1046524 total, 1046524 free, 0 used. 873264 avail Mem (swap information in kilobytes)
- die Gesamtmenge des Auslagerungsspeichers: 1046524 total
- ungenutzter Auslagerungsspeicher: 1046524 free
- Auslagerungsspeicher in Gebrauch: 0 used
- die Menge des Auslagerungsspeichers, die den Prozessen zugewiesen werden kann, ohne mehr Auslagerung zu verursachen: 873264 avail Mem

Der Taskbereich in `top`: Felder und Spalten

Unterhalb des Summarybereichs befindet sich der Taskbereich, der eine Reihe von Feldern und Spalten mit Informationen über die laufenden Prozesse enthält:

PID: Prozess-Identifikator.
USER: Benutzer, der den Befehl erteilt hat den Prozess zu erzeugen.
PR: Priorität des Prozesses für den Kernel.
NI: Nice Wert des Prozesses. Niedrigere Werte haben eine höhere Priorität als höhere Werte.
VIRT: Gesamtmenge des vom Prozess verwendeten Speichers (einschließlich Swap).
RES: Vom Prozess verwendeter RAM-Speicher.
SHR: Gemeinsame Erinnerung an den Prozess mit anderen Prozessen.
S: Status des Prozesses. Die Werte umfassen: S (unterbrechbarer Stillstand — wartet auf die Beendigung eines Ereignisses), R (lauffähig — entweder in Ausführung oder in der Warteschlange zur Ausführung) oder Z (Zombie — beendeter Kindprozesse, deren Datenstrukturen noch nicht aus der Prozesstabelle entfernt wurde).
%CPU: Prozentualer Anteil der vom Prozess verwendeten CPU.
%MEM: Prozentualer Anteil des vom Prozess verwendeten RAM, bezeichnet als der RES-Wert, ausgedrückt in Prozent.
TIME+: Gesamtaktivitätszeit eines Prozesses.
COMMAND: Name des Befehls/Programms, welcher den Prozess erzeugt hat.

Statische Betrachtung von Prozessen: `ps`

Wie oben angesprochen, zeigt ps eine Momentaufnahme von Prozessen. Um alle Prozesse in einem Terminal (tty) zu sehen, geben Sie ps a ein:

$ ps a
  PID TTY      STAT   TIME COMMAND
  386 tty1     Ss+    0:00 /sbin/agetty --noclear tty1 linux
  424 tty7     Ssl+   0:00 /usr/lib/xorg/Xorg :0 -seat seat0 (...)
  655 pts/0    Ss     0:00 -bash
 1186 pts/0    R+     0:00 ps a
 (...)

Erläuterung der `ps` Optionssyntax und Ausgabe

Was die Optionen betrifft, kann ps drei verschiedene Stile akzeptieren: BSD, UNIX und GNU. Lassen Sie uns betrachten, wie jeder dieser Stile beim Berichten von Informationen über eine bestimmte Prozess-ID funktioniert:

BSD

Optionen folgen keinem führenden Bindestrich:

$ ps p 811
  PID TTY      STAT   TIME COMMAND
  811 pts/0    S      0:00 -su

UNIX

Optionen folgen einem führenden Bindestrich:

$ ps -p 811
  PID TTY          TIME CMD
  811 pts/0    00:00:00 bash

GNU

Optionen folgen doppelten führenden Bindestrichen:

$ ps --pid 811
  PID TTY          TIME CMD
  811 pts/0    00:00:00 bash

In allen drei Fällen berichtet ps Informationen über den Prozess, dessen PID 811 lautet - in diesem Fall bash.

In ähnlicher Weise können Sie ps verwenden, um nach den von einem bestimmten Benutzer gestarteten Prozessen zu suchen:

ps U carol (BSD)
ps -u carol (UNIX)
ps --user carol (GNU)

Schauen wir uns die Prozesse an, die von carol gestartet wurden:

$ ps U carol
  PID TTY      STAT   TIME COMMAND
  811 pts/0    S      0:00 -su
  898 pts/0    R+     0:00 ps U carol

Sie startete zwei Prozesse: bash (-su) und ps (ps U carol). Die Spalte STAT informiert uns über den Stand des Prozesses (siehe unten). Wir können das Beste aus ps herausholen, indem wir einige seiner Optionen kombinieren. Ein sehr nützlicher Befehl (der eine Ausgabe ähnlich der von top erzeugt) ist ps aux (im BSD-Stil). In diesem Fall werden Prozesse aus allen Shells (und nicht nur aus der aktuellen Shell) angezeigt. Die Bedeutung der Optionen lauten wie folgt:

a: Zeigt Prozesse, die mit einem tty oder Terminal verbunden sind.
u: Benutzerorientiertes Format anzeigen.
x: Zeigt Prozesse, die nicht mit einem tty oder Terminal verbunden sind.

$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 204504  6780 ?        Ss   14:04   0:00 /sbin/init
root         2  0.0  0.0      0     0 ?        S    14:04   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S    14:04   0:00 [ksoftirqd/0]
root         5  0.0  0.0      0     0 ?        S<   14:04   0:00 [kworker/0:0H]
root         7  0.0  0.0      0     0 ?        S    14:04   0:00 [rcu_sched]
root         8  0.0  0.0      0     0 ?        S    14:04   0:00 [rcu_bh]
root         9  0.0  0.0      0     0 ?        S    14:04   0:00 [migration/0]
(...)

Folgend die Erklärung der einzelnen Spalten:

USER: Eigentümer des Prozesses.
PID: Prozess-Identifikator.
%CPU: Prozentualer Anteil der verwendeten CPU.
%MEM: Prozentualer Anteil des verwendeten physischen Speichers.
VSZ: Virtueller Speicher des Prozesses in KiB.
RSS: Nicht ausgelagerter physischer Speicher, der vom Prozess in KiB verwendet wird.
TT: Terminal (tty), das den Prozess steuert.
STAT: Code, der den Stand des Prozesses darstellt. Abgesehen von S, R und Z (bekannt aus der Ausgabe von top), sind auch andere Werte möglich: D (unterbrechungsfreier Stillstand - wartet normalerweise auf E/A), T (angehalten - normalerweise durch ein Steuersignal). Einige zusätzliche Modifikatoren beinhalten: < (hohe Priorität - nicht nett zu anderen Prozessen), N (niedrige Priorität - nett zu anderen Prozessen), oder + (in der Prozessgruppe im Vordergrund).
STARTED: Zeitpunkt, zu dem der Prozess gestartet wurde.
TIME: Akkumulierte CPU-Zeit.
COMMAND: Befehl, mit dem der Prozess gestartet wurde.

Geführte Übungen

oneko ist ein nettes, lustiges Programm, das eine Katze darstellt, welche Ihren Mauszeiger jagt. Wenn es nicht bereits auf Ihrem Desktopsystem installiert ist, installieren Sie es mit dem Paketmanager Ihrer Distribution. Wir werden es benutzen, um die Kontrolle von Jobs zu studieren.
- Starten Sie das Programm. Wie machen Sie das?
- Bewegen Sie den Mauszeiger, um zu sehen, wie die Katze ihn jagt. Halten Sie nun den entsprechenden Prozess an. Wie machen Sie das? Welche Ausgabe wird erzeugt?
- Prüfen Sie, wie viele Jobs Sie derzeit haben. Was geben Sie ein? Welche Ausgabe erscheint?
- Senden Sie den Prozess nun unter Angabe seiner Job-ID in den Hintergrund. Wie lautet die Ausgabe? Woran können Sie erkennen, dass der Job im Hintergrund läuft?
- Beenden Sie schließlich den Job unter Angabe seiner Job-ID. Was geben Sie ein?
Nennen Sie die PIDs aller Prozesse, die vom Apache HTTPD Webserver (apache2) erzeugt wurden, mittels zwei verschiedener Befehle:
Beenden Sie alle Prozesse von apache2 ohne Verwendung ihrer PIDs und mit zwei verschiedenen Befehlen:
Angenommen, Sie müssen alle Instanzen von apache2 beenden und haben keine Zeit, um herauszufinden, wie deren PIDs lauten. Wie wäre dies, unter Benutzung von`kill` mit dem Standardsignal SIGTERM in einem Einzeiler, erreichbar:
Starten Sie top und interagieren Sie, indem Sie Folgendes ausführen:
- Eine Baumhierarchie der Prozesse zeigen:
- Die vollständige Pfade aller Prozessen anzeigen, die zwischen Userspace und Kernelspace unterscheiden:
Geben Sie den Befehl ps ein, um alle vom Benutzer Apache HTTPD Webserver gestarteten Prozesse anzuzeigen (www-data):
- Unter Verwendung der BSD-Syntax:
- Unter Verwendung der UNIX-Syntax:
- Unter Verwendung der GNU-Syntax:

Offene Übungen

Das Signal SIGHUP kann als eine Möglichkeit benutzt werden, bestimmte Daemons neu zu starten. Mit dem Apache HTTPD Webserver — zum Beispiel — beendet das Senden von SIGHUP an den Elternprozess (der durch init gestartet wurde) seine Kinder. Der Elternprozess liest jedoch seine Konfigurationsdateien erneut ein, öffnet die Logdateien erneut und erzeugt einen neuen Satz von Kindern. Führen Sie die folgenden Aufgaben aus:
- Starten Sie den Webserver:
- Stellen Sie sicher, dass Sie die PID des übergeordneten Prozesses kennen:
- Starten Sie den Apache HTTPD Webserver neu, indem Sie ihm das Signal SIGHUP an den Elternprozess senden:
- Überprüfen Sie, ob das Elternteil nicht beendet wurde und ob neue Kinder erzeugt wurden:
Obwohl anfänglich statisch, kann die Ausgabe von ps durch die Kombination von ps und watch dynamisch erzeugt werden. Wir werden den Apache HTTPD Webserver auf neue Verbindungen überwachen. Bevor Sie die unten beschriebenen Aufgaben durchführen, wird empfohlen, dass Sie die Beschreibung der Direktive MaxConnectionsPerChild in Apache MPM Common Directives lesen.
- Fügen Sie die Direktive MaxConnectionsPerChild mit einem Wert von 1 in der Konfigurationsdatei von apache2 hinzu — in Debian und seinen Derivaten ist diese in /etc/apache2/apache2.conf zu finden; in der CentOS-Familie in /etc/httpd/conf/httpd.conf. Vergessen Sie nicht, apache2 neu zu starten, damit die Änderungen wirksam werden.
- Geben Sie einen Befehl ein, der watch, ps und grep kombiniert, um Verbindungen von apache2 zu überwachen.
- Öffnen Sie nun einen Web-Browser oder verwenden Sie einen Befehlszeilen basierten Browser wie lynx, um über seine IP-Adresse eine Verbindung zum Web-Server herzustellen. Was beobachten Sie bei der Ausgabe von watch?
Wie Sie gelernt haben, sortiert top die Aufgaben standardmäßig nach dem Prozentsatz der CPU-Auslastung in absteigender Reihenfolge (die höheren Werte oben). Dieses Verhalten kann mit den interaktiven Tasten M (Speichernutzung), N (Kennung der Prozesse), T (Laufzeit) und P (Prozentsatz der CPU-Zeit) modifiziert werden. Sie können die Aufgabenliste jedoch auch nach Ihren Wünschen sortieren, indem Sie top mit dem Schalter -o starten (weitere Informationen finden Sie auf der top man-Seite). Führen Sie nun die folgenden Aufgaben aus:
- Starten Sie top, so dass die Aufgaben nach Speicherverbrauch sortiert werden:
- Überprüfen Sie, ob Sie den richtigen Befehl eingegeben haben, indem Sie die Speicherspalte markieren:
ps besitzt ebenfalls die Option o, um die Spalten anzugeben, die angezeigt werden sollen. Untersuchen Sie diese Option und führen Sie die folgenden Aufgaben durch:
- Starten Sie ps, so dass nur Informationen über Benutzer, prozentualer Anteil des verwendeten Speichers, prozentualer Anteil der verwendeten CPU-Zeit und der vollständige Befehl angezeigt werden:
- Starten Sie nun ps, so dass nur die Informationen über den Benutzer und die Namen der von ihm benutzten Programme angezeigt werden:

Zusammenfassung

In dieser Lektion haben Sie etwas über Jobs und die Kontrolle von Jobs gelernt. Wichtige Fakten und Konzepte, die es zu beachten gilt, sind:

Jobs sind Prozesse, die in den Hintergrund gesendet werden.
Abgesehen von einer Prozess-ID werden Jobs beim Anlegen auch eine Job-ID zugewiesen.
Zur Kontrolle von Jobs ist eine Job-Spezifikation (jobspec) erforderlich.
Jobs können in den Vordergrund gebracht, in den Hintergrund geschickt, angehalten und beendet (oder terminiert) werden.
Ein Job kann von dem Terminal und der Sitzung, in dem er erstellt wurde, getrennt werden.

Zugleich wurden auch das Konzept der Prozesse und der Prozessüberwachung diskutiert. Die wichtigsten Ideen sind:

Prozesse sind laufende Programme.
Prozesse können überwacht werden.
Verschiedene Hilfsprogramme ermöglichen es uns, die Prozess-ID von Prozessen herauszufinden und Signale zu senden, um sie zu beenden.
Signale können mit Namen (z.B. -SIGTERM), Nummer (z.B. -15) oder Option (z.B. -s SIGTERM) angegeben werden.
top und ps sind sehr mächtig, wenn es um die Überwachung von Prozessen geht. Der Output des Ersteren ist dynamisch und wird ständig aktualisiert; andererseits zeigt ps den Output statisch an.

In dieser Lektion verwendete Befehle:

jobs: Zeigt aktive Jobs und ihren Status an.
sleep: Verzögert für die angegebene Anzahl von Sekunden.
fg: Bringt einen Job in den Vordergrund.
bg: Verschiebt einen Job in den Hintergrund.
kill: Beendet einen Job.
nohup: Trennt einen Job von der Sitzung/dem Terminal.
exit: Beendet die aktuelle Shell.
tail: Zeigt die letzten Zeilen einer Datei an.
watch: Führt ein Programm periodisch aus (standardmäßig aller 2 Sekunden).
uptime: Zeigt an, wie lange das System bereits läuft, die Anzahl der aktuellen Benutzer und die durchschnittliche Systemlast.
free: Zeigt die Speichernutzung an.
pgrep: Prozess-ID basierend auf dem Namen nachschlagen.
pidof: Prozess-ID basierend auf dem Namen nachschlagen.
pkill: Signal an Prozess anhand des Namens senden.
killall: Beendet Prozess(e) anhand deren Namen.
top: Listet Linuxprozesse auf.
ps: Listet eine Momentaufnahme der laufenden Prozesse auf.

Lösungen zu den geführten Übungen

oneko ist ein nettes, lustiges Programm, das eine Katze darstellt, welche Ihren Mauszeiger jagt. Wenn es nicht bereits auf Ihrem Desktopsystem installiert ist, installieren Sie es mit dem Paketmanager Ihrer Distribution. Wir werden es benutzen, um die Kontrolle von Jobs zu studieren.
- Starten Sie das Programm. Wie machen Sie das?
  
  Durch Eingabe von oneko in das Terminal.
- Bewegen Sie den Mauszeiger, um zu sehen, wie die Katze ihn jagt. Halten Sie nun den entsprechenden Prozess an. Wie machen Sie das? Welche Ausgabe wird erzeugt?
  
  Durch Drücken der Tastenkombination Strg+Z:
  [1]+ Stopped oneko
- Prüfen Sie, wie viele Jobs Sie derzeit haben. Was geben Sie ein? Welche Ausgabe erscheint?
  $ jobs [1]+ Stopped oneko
- Senden Sie den Prozess nun unter Angabe seiner Job-ID in den Hintergrund. Wie lautet die Ausgabe? Woran können Sie erkennen, dass der Job im Hintergrund läuft?
  $ bg %1 [1]+ oneko &
  Die Katze bewegt sich wieder.
- Beenden Sie schließlich den Job unter Angabe seiner Job-ID. Was geben Sie ein?
  $ kill %1
Nennen Sie die PIDs aller Prozesse, die vom Apache HTTPD Webserver (apache2) erzeugt wurden, mittels zwei verschiedener Befehle:
```
$ pgrep apache2
```
oder
```
$ pidof apache2
```
Beenden Sie alle Prozesse von apache2 ohne Verwendung ihrer PIDs und mit zwei verschiedenen Befehlen:
```
$ pkill apache2
```
oder
```
$ killall apache2
```
Angenommen, Sie müssen alle Instanzen von apache2 beenden und haben keine Zeit, um herauszufinden, wie deren PIDs lauten. Wie wäre dies, unter Benutzung von`kill` mit dem Standardsignal SIGTERM in einem Einzeiler, erreichbar:
```
$ kill $(pgrep apache2)
$ kill `pgrep apache2`
```
oder
```
$ kill $(pidof apache2)
$ kill `pidof apache2`
```
Note

Da SIGTERM (15) das Standardsignal darstellt, ist es nicht erforderlich diese Option an kill zu übergeben.
Starten Sie top und interagieren Sie, indem Sie Folgendes ausführen:
- Eine Baumhierarchie der Prozesse zeigen:
  
  Drücken Sie V.
- Die vollständigen Pfade aller Prozessen anzeigen, die zwischen Userspace und Kernelspace unterscheiden:
  
  Drücken Sie c.
Geben Sie den Befehl ps ein, um alle vom Benutzer Apache HTTPD Webserver gestarteten Prozesse anzuzeigen (www-data):
- Unter Verwendung der BSD-Syntax:
  $ ps U www-data
- Unter Verwendung der UNIX-Syntax:
  $ ps -u www-data
- Unter Verwendung der GNU-Syntax:
  $ ps --user www-data

Lösungen zu den offenen Übungen

Das Signal SIGHUP kann als eine Möglichkeit benutzt werden, bestimmte Daemons neu zu starten. Mit dem Apache HTTPD Webserver — zum Beispiel — beendet das Senden von SIGHUP an den Elternprozess (der durch init gestartet wurde) seine Kinder. Der Elternprozess liest jedoch seine Konfigurationsdateien erneut ein, öffnet die Logdateien erneut und erzeugt einen neuen Satz von Kindern. Führen Sie die folgenden Aufgaben aus:
- Starten Sie den Webserver:
  $ sudo systemctl start apache2
- Stellen Sie sicher, dass Sie die PID des übergeordneten Prozesses kennen:
  $ ps aux | grep apache2
  Der Elternprozess ist derjenige, der vom root-Benutzer gestartet wurde. In unserem Fall derjenige mit der PID 1653.
- Starten Sie den Apache HTTPD Webserver neu, indem Sie ihm das Signal SIGHUP an den Elternprozess senden:
  $ kill -SIGHUP 1653
- Überprüfen Sie, ob das Elternteil nicht beendet wurde und ob neue Kinder erzeugt wurden:
  $ ps aux | grep apache2
  Nun sollten Sie den übergeordneten Prozess von apache2 zusammen mit zwei neuen Kindern sehen.
Obwohl anfänglich statisch, kann die Ausgabe von ps durch die Kombination von ps und watch dynamisch erzeugt werden. Wir werden den Apache HTTPD Webserver auf neue Verbindungen überwachen. Bevor Sie die unten beschriebenen Aufgaben durchführen, wird empfohlen, dass Sie die Beschreibung der Direktive MaxConnectionsPerChild in Apache MPM Common Directives lesen.
- Fügen Sie die Direktive MaxConnectionsPerChild mit einem Wert von 1 in der Konfigurationsdatei von apache2 hinzu — in Debian und seinen Derivaten ist diese in /etc/apache2/apache2.conf zu finden; in der CentOS-Familie in /etc/httpd/conf/httpd.conf. Vergessen Sie nicht, apache2 neu zu starten, damit die Änderungen wirksam werden.
  
  Die in die Konfigurationsdatei aufzunehmende Zeile lautet MaxConnectionsPerChild 1. Eine Möglichkeit, den Webserver neu zu starten, ist sudo systemctl restart apache2.
- Geben Sie einen Befehl ein, der watch, ps und grep kombiniert, um Verbindungen von apache2 zu überwachen.
  $ watch 'ps aux | grep apache2'
  oder
  $ watch "ps aux | grep apache2"
- Öffnen Sie nun einen Web-Browser oder verwenden Sie einen Befehlszeilen basierten Browser wie lynx, um über seine IP-Adresse eine Verbindung zum Web-Server herzustellen. Was beobachten Sie bei der Ausgabe von watch?
  
  Einer der Kindprozesse im Besitz von www-data verschwindet.
Wie Sie gelernt haben, sortiert top die Aufgaben standardmäßig nach dem Prozentsatz der CPU-Auslastung in absteigender Reihenfolge (die höheren Werte oben). Dieses Verhalten kann mit den interaktiven Tasten M (Speichernutzung), N (Kennung der Prozesse), T (Laufzeit) und P (Prozentsatz der CPU-Zeit) modifiziert werden. Sie können die Aufgabenliste jedoch auch nach Ihren Wünschen sortieren, indem Sie top mit dem Schalter -o starten (weitere Informationen finden Sie auf der top man-Seite). Führen Sie nun die folgenden Aufgaben aus:
- Starten Sie top, so dass die Aufgaben nach Speicherverbrauch sortiert werden:
  $ top -o %MEM
- Überprüfen Sie, ob Sie den richtigen Befehl eingegeben haben, indem Sie die Speicherspalte markieren:
  
  Drücken Sie X.
ps besitzt ebenfalls die Option o, um die Spalten anzugeben, die angezeigt werden sollen. Untersuchen Sie diese Option und führen Sie die folgenden Aufgaben durch:
- Starten Sie ps, so dass nur Informationen über Benutzer, prozentualer Anteil des verwendeten Speichers, prozentualer Anteil der verwendeten CPU-Zeit und der vollständige Befehl angezeigt werden:
  $ ps o user,%mem,%cpu,cmd
- Starten Sie nun ps, so dass nur die Informationen über den Benutzer und die Namen der von ihm benutzten Programme angezeigt werden:
  $ ps o user,comm