Processus

Un processus est un programme en cours d’exécution.

1. La commande `ps`

La commande historique ps liste les processus :

les processus (les 15 premières lignes)

$ ps -ef | head -15
UID          PID    PPID   CMD
root           1       0  /usr/lib/systemd/systemd
root         980       1  /usr/lib/systemd/systemd-journald
rpc         1226       1  /usr/bin/rpcbind -w -f
systemd+    1234       1  /usr/lib/systemd/systemd-oomd
systemd+    1236       1  /usr/lib/systemd/systemd-resolved
dbus        1290       1  /usr/bin/dbus-broker-launch --scope system
chrony      1357       1  /usr/sbin/chronyd -F 2
root        1468       1  /usr/sbin/cupsd -l
root        1584       1  /usr/libexec/postfix/master -w
root        1692       1  /usr/sbin/automount --systemd-service
root        1769       1  /usr/sbin/crond -n
pcp         1803       1  /usr/libexec/pcp/bin/pmcd -A
root        1808    1803  /var/lib/pcp/pmdas/root/pmdaroot
root        1810    1808  /var/lib/pcp/pmdas/proc/pmdaproc -d 3
root        1812    1808  /var/lib/pcp/pmdas/linux/pmdalinux
jaclin      3168       1  /usr/lib/systemd/systemd --user

Chaque processus est identifié de façon unique par un entier : son PID.

Les processus se créent entre eux : chaque processus a été créé par un processus qui existait avant lui : son processus père. Le fils référence son père via son PPID.

Au boot de la machine, un premier processus est créé : celui dont le PID vaut 1. Sur les Unix System V, ce processus s’appelle init.

Le processus initial de PID 1 va ensuite créer des fils, qui eux aussi feront de même. Au final, on obtient donc une arborescence de processus, que la commande (non historique) pstree visualise :

l’arborescence des processus (les 20 premières lignes)

$ pstree | head -20
systemd─┬─NetworkManager───3*[{NetworkManager}]
        ├─abrtd───3*[{abrtd}]
        ├─anacron
        ├─atd
        ├─auditd─┬─sedispatch
        │        └─2*[{auditd}]
        ├─automount───6*[{automount}]
        ├─bluetoothd
        ├─chronyd
        ├─crond
        ├─cupsd
        ├─rpcbind
        ├─sshd
        ├─systemd───(sd-pam)
        ├─systemd-homed
        ├─systemd-journal
        ├─systemd-logind
        ├─systemd-machine
        ├─systemd-oomd
        └─systemd-udevd

2. La commande `top`

La commande top affiche la liste actualisée en temps réel des processus les plus actifs :

$ top
top - 15:38:20 up 1 day, 20:16,  2 users,  load average: 4,45, 4,36, 4,21
Tasks: 398 total,   2 running, 395 sleeping,   0 stopped,   1 zombie
%Cpu(s): 29,3 us,  0,8 sy,  0,0 ni, 69,9 id,  0,0 wa,  0,0 hi,  0,0 si,  0,0 st
MiB Mem :  31720,0 total,   9661,1 free,  16145,0 used,   7617,4 buff/cache
MiB Swap:   8192,0 total,   8192,0 free,      0,0 used.  15575,0 avail Mem

    PID USER      PR  %CPU  %MEM  COMMAND
  21336 jaclin    20   31,0  7,47 codium
   6934 jaclin    20   9,1   1,7  firefox
1571767 jaclin    20   9,1   0,6  Isolated Web Co
      1 root      20   0,0   0,1  systemd
      2 root      20   0,0   0,0  kthreadd
...

top fournit aussi le load average ainsi que l’utilisation du swap.

3. Premier plan

Habituellement, on exécute une commande au premier plan (foreground), ce qui signifie que l’on ne récupère la main que lorsque la commande se termine. Par exemple :

$ (for i in {1..20}; do echo -n "$i "; sleep 1; done)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
$

Pour interrompre un processus, il suffit de presser Ctrl+C :

$ (for i in {1..20}; do echo -n "$i "; sleep 1; done)
1 2 3 4 ^C
$

Le processus s’arrête définitivement. Moins radical est de le suspendre. Pour cela, on tape Ctrl+Z :

$ (for i in {1..20}; do echo -n "$i "; sleep 1; done)
1 2 3 4 5 ^Z
[1] Stoppé   (for i in {1..100};do echo -n "$i ";sleep 1;done)

Le processus est temporairement en pause. La commande jobs montre que le processus est toujours là :

$ jobs
[1] Stoppé    (for i in {1..100};do echo -n "$i ";sleep 1;done)

Un processus stoppé peut être réveillé. Et pour cela, 2 possibilités :

le remettre au premier plan (commande fg) :

$ fg
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
$

le repasser en arrière plan (commande bg) :

$ bg
6 $ 7 8 9 10 11 12 13 14 15 16 17 18 19 20

4. Arrière plan

On peut lancer une commande en tâche de fond (bakground), en la terminant avec un &. Dans ce cas, l’utilisateur récupère immédiatement la main, pendant que la commande s’exécute en arrière plan.

$ (for i in {1..10}; do echo -n "$i "; sleep 1; done) &
[1] 76971
1 $ 2 3 4 5 6
(for i in {1..10}; do echo -n "$i "; sleep 1; done)
7 1 8 2 9 3 10 4 5 6 7 8 9 10
[1] Fini
$

5. Redirections

Lorsqu’un processus tourne en arrière plan, l’utilisateur peut lancer d’autres commandes sans l’interrompre. Seulement, tous les affichages se mélangent sur l’écran : celui de la commande d’arrière plan, et celui de la commande de premier plan. Si les commandes sont verbeuses, cela devient vite incompréhensible. C’est pourquoi il est préférable qu’un processus d’arrière plan n’écrive rien sur l’écran.

Il est possible de lancer une commande en redirigeant tout ce qui devrait sortir sur l’écran dans un fichier.

Exemple, soit à trouver toutes les répertoires nommés lib :

$ find / -type d -name lib
/home/jaclin/.vscode-oss/lib
/home/jaclin/.npm/_npx/lib
find: ‘/boot/loader/entries’: Permission non accordée
find: ‘/boot/efi’: Permission non accordée
find: ‘/boot/grub2’: Permission non accordée
/tmp/lib

On constate que find sort 2 types de messages :

ceux correspondant aux répertoires trouvés
ceux correspondant aux interdictions

Pour rediriger les premiers dans un fichier, de sorte qu’ils n’apparaissent plus à l’écran, on écrit :

$ find / -type d -name lib >trouves.out
find: ‘/boot/loader/entries’: Permission non accordée
find: ‘/boot/efi’: Permission non accordée
find: ‘/boot/grub2’: Permission non accordée

Pour rediriger les seconds, on écrit :

$ find / -type d -name lib 2>interdits.err
/home/jaclin/.vscode-oss/lib
/home/jaclin/.npm/_npx/lib
/tmp/lib

Résumé

commandes à retenir : ps, top, kill