Processus Linux

Ce chapitre dédié aux processus Linux explique comment les identifier dans leur filiation, comment les sélectionner pour les mettre en pause ou les tuer, comment les mettre en avant-plan ou en arrière-plan, comment gérer les priorités en cas de concurrence, comment mesurer l’utilisation des ressources et résoudre des problèmes.

Les processus sont référencés par un identifiant unique, le PID. Ce nombre peut être utilisé pour changer la priorité d’un processus ou pour l’arrêter.

Un processus correspond à n’importe quel exécutable exécuté. Si le processus 2 a été lancé par le processus 1, on l’appelle un processus fils. Le processus qui l’a lancé est appelé processus parent.

La commande pstree donne une bonne illustration de la hiérarchie des processus parents et fils.

Par exemple, sous debian :

pstree

init─┬─acpid
     ├─atd
     ├─cron
     ├─dbus-daemon
     ├─dhclient
     ├─docker.io─┬─bash
     │           ├─controller───9*[{controller}]
     │           ├─rethinkdb─┬─rethinkdb
     │           │           └─69*[{rethinkdb}]
     │           └─12*[{docker.io}]
     ├─7*[getty]
     ├─irqbalance
     ├─rsyslogd───3*[{rsyslogd}]
     ├─sshd───sshd───sshd───bash───pstree

Par exemple, sous Centos :

pstree

systemd─┬─ModemManager───2*[{ModemManager}]
        ├─NetworkManager─┬─dhclient
        │                └─2*[{NetworkManager}]
        ├─2*[abrt-watch-log]
        ├─abrtd
        ├─accounts-daemon───2*[{accounts-daemon}]
        ├─alsactl
        ├─at-spi-bus-laun─┬─dbus-daemon───{dbus-daemon}
        │                 └─3*[{at-spi-bus-laun}]
        ├─at-spi2-registr───{at-spi2-registr}
        ├─atd
        ├─auditd─┬─audispd─┬─sedispatch
        │        │         └─{audispd}
        │        └─{auditd}
        ├─avahi-daemon───avahi-daemon
        ├─caribou───2*[{caribou}]
        ├─chronyd
        ├─colord───2*[{colord}]
        ├─crond
        ├─cupsd
        ├─2*[dbus-daemon───{dbus-daemon}]
        ├─dbus-launch
        ├─dconf-service───2*[{dconf-service}]
        ├─firewalld───{firewalld}
        ├─gdm─┬─Xorg───2*[{Xorg}]
        │     ├─gdm-session-wor─┬─gnome-session─┬─gnome-settings-───4*[{gnome-settings-}]
        │     │                 │               ├─gnome-shell─┬─ibus-daemon─┬─ibus-dconf───3*[{ibus-dconf}]
        │     │                 │               │             │             ├─ibus-engine-sim───2*[{ibus-engine-sim}]
        │     │                 │               │             │             └─2*[{ibus-daemon}]
        │     │                 │               │             └─8*[{gnome-shell}]
        │     │                 │               └─3*[{gnome-session}]
        │     │                 └─2*[{gdm-session-wor}]
        │     └─3*[{gdm}]
        ├─goa-daemon───3*[{goa-daemon}]
        ├─goa-identity-se───2*[{goa-identity-se}]
        ├─gssproxy───5*[{gssproxy}]
        ├─gvfs-afc-volume───2*[{gvfs-afc-volume}]
        ├─gvfs-goa-volume───{gvfs-goa-volume}
        ├─gvfs-gphoto2-vo───{gvfs-gphoto2-vo}
        ├─gvfs-mtp-volume───{gvfs-mtp-volume}
        ├─gvfs-udisks2-vo───2*[{gvfs-udisks2-vo}]
        ├─gvfsd───{gvfsd}
        ├─ibus-x11───2*[{ibus-x11}]
        ├─irqbalance
        ├─login───bash───su───bash───pstree
        ├─lsmd
        ├─lvmetad
        ├─master─┬─pickup
        │        └─qmgr
        ├─mission-control───2*[{mission-control}]
        ├─packagekitd───2*[{packagekitd}]
        ├─polkitd───5*[{polkitd}]
        ├─pulseaudio───2*[{pulseaudio}]
        ├─qemu-ga
        ├─rngd
        ├─rsyslogd───2*[{rsyslogd}]
        ├─rtkit-daemon───2*[{rtkit-daemon}]
        ├─smartd
        ├─spice-vdagentd
        ├─sshd
        ├─systemd-journal
        ├─systemd-logind
        ├─systemd-udevd
        ├─tuned───4*[{tuned}]
        ├─udisksd───4*[{udisksd}]
        ├─upowerd───2*[{upowerd}]
        ├─wpa_supplicant
        └─x2gocleansession

Les options les plus courantes de pstree sont -p pour afficher les PIDs et -h pour faire ressortir (en gras) les processus utilisateurs.

Une méthode plus directe pour déterminer les processus en cours d’exécution est d’utiliser la commande ps avec une combinaison d’options.

Tentez les différentes commandes :

$ ps
$ ps a
$ ps ax
$ ps aux
$ ps ax | grep cron

Exemples tirés de la page man de ps (en)

Tous les processus sur le système en syntaxe standard.

ps -e
ps -ef
ps -eF
ps -ely

Impression d’un arbre de processus.

ps -ejH
ps axjf

Obtenir des informations sur les “threads”.

ps -eLf
ps axms

Obtenir des informations de sécurité.

ps -eo euser,ruser,suser,fuser,f,comm,label
</ode>
Description des champs :
  * **PRI** Il s’agit d’un compteur dans la structure représentant la tâche. C’est la fréquence, en HZ des activations possibles du processus.
  * **NI** Valeur standard Unix de gentillesse (nice). Une valeur positive signifie un accès moindre au CPU.
  * **SIZE** Taille virtuelle de l’image du processus (code + données + pile).
  * **RSS** Taille résidente de l’image du processus. Nombre de kilo-octets se trouvant en mémoire.
  * **WCHAN** Nom de la fonction du noyau dans laquelle le processus est endormi.
  * **STAT** État du processus.
 
Le premier champ **PRI** correspond à :
  * **R** (runnable) prêt à être exécuté,
  * **S** (sleeping) endormi,
  * **D** sommeil ininterruptible,
  * **T** (traced) arrêté ou suivi,
  * **Z** (zombie).
Le second champ contient **W** si le processus n’a pas de pages résidentes.
 
Le troisième **NI** champ contient **N** si le processus a une valeur de gentillesse positive (**nice**, champ NI).
  * **TT** terminal de contrôle
  * **PAGEIN** Nombre de fautes de pages majeures (où l’on doit lire des pages sur le disque, y compris dans le buffer cache).
  * **TRS** Taille de code résident en mémoire.
  * **SWAP** Nombre de kilo-octets (ou de pages si l’option -p est utilisée) sur le périphérique de swap.
  * **SHARE** Mémoire partagée.
 
===== Gestion de tâches =====
 
On peut lancer directement une tâche en arrière plan en ajoutant & à la commande :
<code bash>
tail -f /var/log/messages &

Pour visualiser les tâches (jobs) :

jobs
[1]+  Stopped                 tail -f /var/log/syslog
[2]-  Running                 tail -f /var/log/syslog &

Pour reprendre une tâche en premier plan :

fg 2
tail -f /var/log/messages

On utilise la commande kill pour envoyer des signaux aux processus. Il existe 63 signaux. Le signal par défaut, nommé SIGTERM, termine le processus et a pour valeur numérique 15.

kill SIGNAL PID

Chaque processus peut choisir ou non de détecter un signal, à l’exception de SIGKILL qui est directement géré par le noyau. On peut également arrêter un processus sans connaître son PID avec la commande killall.

killall SIGNAL NOM_PROCESSUS

On trouve la liste des signaux sous le titre “Standard Signals” de la page man 7 signal

man 7 signal

“Nohup” est une commande Unix permettant de lancer un processus qui restera actif même après la déconnexion de l’utilisateur l’ayant initiée. Combiné à l’esperluette (&) qui permet le lancement en arrière-plan. nohup permet donc de créer des processus s’exécutant de manière transparente sans être dépendants de l’utilisateur.

Par exemple :

nohup tail -f /var/log/messages &

Les valeurs de nice (NI pour nice indice) modifient la priorité pour le processeur et sont utilisées pour adapter la charge du processeur dans un environnement multi-utilisateur. Chaque processus est lancé avec la valeur de nice par défaut : 0. Ces valeurs sont comprises entre 19 (la plus petite) et -20 (la plus importante). (moins un processus est gentil, plus il consomme de puissance).

Seul le super-utilisateur root peut diminuer la valeur nice d’un processus. En conséquence, tous les processus étant lancés par défaut avec un nice à 0, seul le root peut définir des valeurs de nice négatives !

On utilise la commande renice pour modifier la priorité d’un processus en cours d’exécution, et la commande nice pour définir la priorité d’un processus à son lancement.

nice –<NI>  <processus>
renice  <+/-NI>  -p <PID>

renice utilise les PID et peut gérer une liste de processus à la fois. L’option -u affecte tous les processus d’un utilisateur peut être très utile.

Exemples :

• passage des valeurs de nice à 1 pour les processus 234 et 765

renice +1  -p 234 765

• lancer xclock avec une valeur de nice à -5

nice  --5  xclock

Pour vérifier les valeurs nice :

ps -lax | head