Mis à jour le mercredi 30 octobre 2013
  • Facile
Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Introduction du cours

Une application qui plante, impossible de l'arrêter ?
Une copie de fichier qui ne veut pas s'annuler ?

Avec UNIX, ces soucis seront gérés sans interface graphique et avec une vitesse époustouflante (pour peu que votre console soit facilement accessible :p ).

En effet, les processus font partie intégrante de l'environnement, même si certains sont invisibles à nos yeux. Dans ce tutoriel, nous verrons comment surveiller ces processus : par exemple, voir son utilisation du processeur, ou encore la mémoire vive utilisée. Nous verrons également comment contrôler les processus, notamment les processus qui échappent au contrôle de la souris (plantage, par exemple :-° ).

À vos consoles, on décole !!

C'est quoi, un processus ?

Commençons par simple, comprendre le fonctionnement, et surtout savoir ce qu'est un processus.

Les processus...

Il existe en réalité deux types de processus. Les process, et les jobs.

Le process est un petit programme (ou parfois un gros :p ) qui s'exécute sous les ordres de son process parent, qui lui-même s'exécute sous les ordres de son parent, etc.

Le job est un process qui est le descendant uniquement d'un shell (bash pour GNU/Linux).

Par exemple

Vous exécutez la commande date dans un shell UNIX (en gros, une fenêtre de console :-° ). La commande date engendre un process, ou plus précisément un job, qui est l'héritier du shell, qui est lui-meme l'héritier de votre console, etc.

Si vous avez compris cela, vous avez fait le plus dur : après, c'est de la rigolade ;) .

... et leur fonctionnement

Un processus est donc avant tout un programme qui s'exécute.

Le navigateur internet que vous avez sous les yeux est un processus, votre serveur de fenêtres est un processus, tout programme qui s'exécute est un processus, en plus de nombreux processus que vous ne voyez pas (les systèmes de logs par exemple).

À son exécution, un processus se voit attribuer un numéro qui lui sera propre pour son exécution. Si le processus redémarre, il reçoit un nouveau numéro. Ce numéro est appelé PID.

Le processus reçoit aussi d'autres caractéristiques, comme le processus parent, un statut, et d'autres petites choses qui varient avec le temps, comme le temps d'utilisation du processeur.

Intéresserons-nous à l'état des processus. Un processus peut prendre plusieurs états, qui correspondent chacun à une lettre.

  • La lettre R (run) indique que le processus est en cours d'exécution, et qu'il mobilise le processeur.

  • La lettre S (short sleep) indique que le processus est en veille, mais prêt à fonctionner.

  • La lettre T indique que le processus est suspendu, il ne mobilise pas le processeur.

  • La lettre I indique que le processus est suspendu depuis plus de vingt secondes, il est en attente.

  • La lettre Z (zombie) indique que le processus s'est exécuté, qu'il n'a plus de raisons de vivre, mais vient quand même hanter le système :D . En fait son processus parent n'a pas été informé de sa "mort".

Ne vous en faites pas, ce n'est pas tous les jours que vous aurez à vous servir de ces informations.

Voilà, la partie barbante est terminée, passons à la pratique.

Surveiller les processus

On passe maintenant aux choses sérieuses : afficher toutes les informations que l'on vient de découvrir dans le terminal.

Première chose à faire, ouvrir un terminal :-° .

Maintenant, nous allons voir la petite commande ps.

La commande ps

La commande ps affiche les informations sur les jobs, dépendant uniquement du shell. Voici son utilisation :

ps [-aACcefhjlMmrSTuvwx] [-O fmt] [-o fmt] [-p pid] [-t tty]

Comme vous pouvez le voir, ce n'est pas trop compliqué o_O . J'expliquerai plus tard les options et leurs utilisations, contentez-vous de taper ps dans la console.

Voici un résultat possible, qui sera sûrement différent du vôtre, vu que nous n'avons pas le même ordinateur.

PID    TTY         TIME  CMD
2571 ttys000    0:00.01 -bash

Nous avons déjà vu ce qu'est le PID, intéressons-nous à la colonne TTY.

TTY est l'abréviation de terminal dans le langage UNIX. Cette colonne indique de quel terminal le job est issu. (Note : tty est aussi une commande, qui indique dans quel terminal vous vous trouvez.)

Voici quelques options intéressantes de la commande ps.

L'option

L'utilisation

-a

Affiche tous les jobs exécutés par l'utilisateur et le système

-x

Affiche jobs et process confondus

-A

Affiche tous les process exécutés par l'utilisateur et le système (équivalent à ps -ax)

-j

Affiche plus de caractéristiques sur le processus, comme l'état (colonne STAT), ou l'utilisateur qui exécute le processus

-m

Affiche les processus par ordre d'utilisation de la mémoire, à la place du PID

-r

Affiche les processus par ordre d'utilisation du processeur

-u nom_utilisateur

Donne la liste des processus associés à un utilisateur.

Une des combinaisons d'options les plus courantes pour ps est ps -jax, qui affiche tout les processus en activité et le nom de leur utilisateur.

La commande ps est intéressante, mais reste limitée, car elle n'affiche pas les informations en temps réel.

Ça, c'est le boulot d'une autre commande, la commande top.

La commande top

La commande top est beaucoup plus complète que ps. Elle indique beaucoup d'informations très intéressantes, et surtout lisibles ;) .

Tapez donc top dans le terminal.

Et voici le résultat ;) :

Processes:  69 total, 2 running, 2 stuck, 65 sleeping... 246 threads    18:46:53
Load Avg:  0.08,  0.07,  0.06    CPU usage:  2.40% user,  3.37% sys, 94.23% idle
SharedLibs: num =    7, resident =   57M code, 3092K data, 3964K linkedit.
MemRegions: num =  9678, resident =  223M +   18M private,  132M shared.
PhysMem:  154M wired,  519M active,  233M inactive,  906M used,  111M free.
VM: 6101M + 369M   238683(0) pageins, 32582(0) pageouts
 
  PID COMMAND      %CPU   TIME   #TH #PRTS #MREGS RPRVT  RSHRD  RSIZE  VSIZE
 4233 top          4.7%  0:03.94   1    18     29  488K   200K  1080K    18M 
 4187 mdworker     0.0%  0:00.12   3    51     32  632K  2656K  2148K    30M 
 4168 bash         0.0%  0:00.01   1    14     20  264K   672K   908K    18M 
 4167 login        0.0%  0:00.01   1    17     56  248K   268K  1064K    19M 
 4149 bash         0.0%  0:00.00   1    14     20  256K   672K   908K    18M 
 4148 login        0.0%  0:00.01   1    17     56  248K   268K  1064K    19M 
 4147 terminal     2.0%  0:04.10   3   104-   191 3176K    10M    12M   345M 
 4144 AppleSpell   0.0%  0:00.64   1    29     32  844K  5616K  4176K    33M

Je mets ici seulement une petite partie du résultat.

Pour quitter top, appuyez sur la touche q de votre clavier.

La liste que vous voyez est la liste des processus, avec le PID, le nom du processus, le pourcentage d'utilisation du processeur (CPU), et le temps d'utilisation cumulé du processeur. Les autres colonnes ne sont pas vraiment utiles.

L'en-tête est elle très intéressante, je vais expliquer les points les plus importants, et les informations les plus utiles.

Processes:  69 total, 2 running, 2 stuck, 65 sleeping...

Indique le nombre de processus, ceux qui sont d'état R (running), d'état T (stuck), d'état S (sleeping) et parfois d'autres états.

Load Avg:  0.08,  0.07,  0.06    CPU usage:  2.40% user,  3.37% sys, 94.23% idle

Ce qui est écrit après "Load Avg" (Load average, moyenne de la charge) indique la charge du CPU (voir la news charge des serveurs). On peut donc voir que mon ordinateur s'en sort pépère (très petite charge). La première charge est la moyenne des cinq dernières minutes, la deuxième est celle des dix dernières minutes, et la troisième celle de ces quinze derniers minutes :) . Notez que la commande uptime donne les mêmes résultats, mais pas en temps réel.

Le "CPU usage" (utilisation du processeur) est le pourcentage d'utilisation du processeur par l'utilisateur (vous :p ), le système et le pourcentage qui est au repos (idle).

PhysMem:  154M wired,  519M active,  233M inactive,  906M used,  111M free.

Le "519M active, 233M inactive" indique la mémoire utilisée (519 Mo) et la mémoire inactive (233 Mo).

Voyons maintenant comment classer les processus par leur utilisation de mémoire, de CPU, etc.

Il faut utiliser l'option -o avec un mot-clé, qui se trouve être cpu pour classer par utilisation du processeur, rsize pour la mémoire, mais voici une liste plus longue.

Citation : Manuel de la commande top

-o <key>
Order the process display by sorting on <key> in descending order. A + or - can be prefixed to the key name to specify ascending or descending order, respectively. The supported key are:

command Command name.

cpu CPU usage.

pid Process ID (default).

prt Number of Mach ports.

reg Number of memory regions.

rprvt Resident private address space size.

rshrd Resident shared address space size.

rsize Resident memory size.

th Number of threads.

time Execution time.

uid User ID.

username Username.

vprvt Private address space size.

vsize Total memory size.

Je ne pense pas que vous aurez besoin de tout cela, mais retenez bien cette option -o.

Voici une autre option bien utile, celle qui sert à régler la fréquence des mises à jour. C'est l'option -s, suivie du nombre de secondes entre chaque mise à jour.

top -s 5 -o cpu

Cette commande va me donner les processus rangés par utilisation du CPU, et mettra à jour l'affichage toutes les cinq secondes. Comme dit dans le manuel, on peut choisir l'ordre d'affichage, c'est-à-dire croissant ou décroissant, en ajoutant un + ou un - devant le mot-clé.

Passons maintenant au contrôle des processus :pirate: .

Gérer les processus

À présent que l'on peut espionner les processus ;) , voyons comment les faire obéir au doigt et à l'oeil.

Une affaire de signaux

Pour parler à un processus, on utilise des signaux, des petits messages que le processus va exécuter. Un signal peut être du type "mets-toi en veille" ou "termine-toi", ou encore "redémarre".

Ces signaux sont traduits en langage courant par TERM (pour terminate, "termine-toi"), KILL (pour tuer), HUP (raccroche, qui est principalement utilisé pour les jobs).

Ce sont trois signaux courants, et évidemment, il en existe plein d'autres.

Le signal TERM est utilisé en général pour quitter des applications, mais peut parfois être ignoré par le processus, comme par exemple un "processus fou", qui ne veut pas se terminer.

Le signal KILL est un signal qui ne peut être ignoré par le processus. Il lui ordonne de s'arrêter immédiatement, quelles qu'en soient les conséquences. C'est le signal que l'on utilise pour arrêter les fameux "processus fous".

Les signal HUP est surtout utilisé pour redémarrer un processus lancé par le système. Si c'est un autre processus, il s'arrêtera tranquillement, beaucoup moins violemment qu'avec TERM ou KILL.

Transmettre un signal

Il y a deux grandes commandes pour transmettre un signal. L'une utilise le PID du processus, l'autre son nom.

En utilisant le PID

La commande qui transmet un signal au processus est kill :pirate: .

Voici son utilisation :

kill -nom_du_signal PID
kill -numero_du_signal PID

Par défaut, kill envoie le signal TERM.

Quelques exemples valent mieux qu'un long discours.

kill 552

Envoie le signal TERM au processus 552.

kill -1 1224

Envoie le signal HUP (numéro 1) au processus 1224.

kill -KILL 144

Envoie le signal KILL au processus 144.

Voici la liste des signaux disponibles sur mon ordinateur, révélés par la commande kill -l.

Citation : kill -l

1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGEMT 8) SIGFPE
9) SIGKILL 10) SIGBUS 11) SIGSEGV 12) SIGSYS
13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGURG
17) SIGSTOP 18) SIGTSTP 19) SIGCONT 20) SIGCHLD
21) SIGTTIN 22) SIGTTOU 23) SIGIO 24) SIGXCPU
25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH
29) SIGINFO 30) SIGUSR1 31) SIGUSR2

Rassurez-vous, je n'utilise que TERM, et parfois KILL ; tous ces signaux ne sont pas franchement utiles, pas la peine de se prendre la tête avec ça.

En utilisant le nom

Si vous connaissez le nom exact d'un processus, vous pouvez l'arrêter en utilisant la commande killall.

Voici son utilisation (simplifiée ;) ) :

killall -nom_ou_numero_du_signal nom_du_processus

Exemples

killall screen

Envoie le signal TERM au processus "screen".

killall -9 vim

Envoie le signal KILL au processus "vim".

C'est fini.

À présent, vous savez contrôler les processus, et vous pouvez faire face à toute éventualité de plantage d'une application.
Un top et un kill suffisent pour réguler tous vos processus :) .

Évidemment, vous pouvez toujours utiliser l'interface graphique, mais je trouve que cette technique est particulièrement efficace.

Bon "killage" :p !

Exemple de certificat de réussite
Exemple de certificat de réussite