Gestion des processus

État : {a_reli}

Retour au document principal

Pré-requis

Objectifs

Visualisation des processus en cours

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.

L'arborescence des processus

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

Exemple : extrait de la sortie de pstree

bash(1046)---xinit(1085)-+-X(1086)
                         `-xfwm(1094)-+-xfce(1100)---xterm(1111)---bash(1113)-+-pstree(1180)
                                      |                                       |-soffice.bin(1139)---soffice.bin(1152)-+
                                                                                                                     -soffice.bin(1153)
                                      |                                       |                                       |-soffice.bin(1154)
                                      |                                       |                                       |-soffice.bin(1155)
                                      |                                       |                                       |-soffice.bin(1156)
                                      |                                       |                                       `-soffice.bin(1157)
                                      |                                       `-xclock(1138)
                                      |-xfgnome(1109)
                                      |-xfpager(1108)
                                      |-xfsound(1107)
                                      `-xscreensaver(1098)

Dans l'exemple précédent, tous les PIDs sont affichés; ils sont évidemment incrémentés. Les options les plus courantes de pstree sont -p pour afficher les PIDs et -h pour faire ressortir (en gras) les processus utilisateurs.

Recherche des processus en cours d'exécution

Une méthode plus directe pour déterminer les processus en cours d'exécution est d'utiliser ps. La plupart des utilisateurs utilisent une combinaison d'options qui marche pour presque toutes les situations.

Voici 3 combinaisons :

Nous vous recommandons de lire la page de manuel de ps et de choisir les options que vous préférez ! on peut utiliser ps avec les options de type UNIX et BSD :

Utilisation :

Résumé des options importantes

-a

affiche tous les processus liés à une console pour l'utilisateur actuel sauf les maîtres de session (NdT : <!> -a est différent de a comme indiqué ci-dessus)

-e ou -A

affiche tous les processus

-f

donne le PPID (Parent Process ID) et le STIME (Start Time)

-l

affiche le format long

a

affiche tous les processus liés à une console et pour tous les utilisateurs

x

affiche également tous les processus non liés à une console

Mise à jour en continu des informations sur les processus

La commande top met à jour les informations sur les processus à une fréquence ajustable.

Pendant son utilisation, vous pouvez afficher une liste de commandes de top en tapant h. La barre espace met à jour les informations instantanément.

Vous pouvez également utiliser top pour changer la priorité d'un processus, comme nous le verrons dans la partie suivante.

Modification des processus

Arrêter les processus

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.

Chaque processus peut choisir ou non de détecter un signal, à l'exception de SIGKILL qui est directement géré par le noyau. De nombreux services refinissent le sens de SIGHUP en :"relire le fichier de configuration".

Signaux les plus courants

1 ou SIGHUP

déconnecter le processus

2 ou SIGINT

équivalent à Ctrl+C : interruption

3 ou SIGQUIT

quitter le processus

9 ou SIGKILL

tue le processus à travers un appel noyau

15 ou SIGTERM

termine un processus "gentiment". C'est le signal PAR DÉFAUT

On peut également arrêter un processus sans connaître son PID avec la commande killall.

Illustration : signaux entre processus

Schéma représentant les liens entre les processus et les signaux

Priorité des processus et valeurs de nice

Les valeurs de nice (NI pour nice indice) modifient la priorité pour le processeur et sont utilisés 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). (NdT : moins un processus est gentil, plus il consomme de puissance).

Seul le super-utilisateur root peut diminuer la valeur de nice (NdT : donc augmenter sa priorité) 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 !

Illustration : Valeurs de nice et priorité des processus

Schéma représentant les valeurs de nice et la priorité des processus

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.

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

Exemples :

Les processus et le shell

processus en arrière plan et au premier plan

Lorsque vous lancez un processus à partir du shell, vous quittez automatiquement l'interpréteur de commandes. Vous remarquerez que les commandes ne répondent pas. La raison à cela, c'est qu'il est possible de lancer des programmes au premier plan (fg pour foreground) ou à l'arrière plan (bgou background) du shell.

Lorsqu'un programme est lancé au premier plan, il est possible de récupérer l'invite de commandes en interrompant le programme un moment. Le signal d'interruption est Ctrl+Z.

lancement et arrêt des tâches (jobs)

Un processus lancé à partir du shell est également appelé tâche ou job. Lorsque la tâche reçoit le signal ^Z (NdT : SIGTSTP), le processus est stoppé et vous récupérez l'invite de commande. Pour relancer le programme en arrière plan, il vous suffit de taper bg.

Exemples :

Notez la symbole [1]+ ci-dessus. Le nombre correspond au numéro de job, auquel on peut se référer. Le signe + indique le dernier processus modifié. Un - indiquerait l'avant dernier processus modifié.

On ajoute & à une commande pour la lancer en arrière plan :

Lister les tâches (jobs)

La commande jobs donne la liste de tous les processus lancés à partir du shell actuel et affiche le numéro de job, son statut (lancé ou à l'arrêt), ainsi que les deux derniers processus modifiés :

Le numéro de job

On peut utiliser le numéro de job pour stopper ou lancer une sélection de tâches, grâce à la commande fg.

Exemple : on place le job 2 au premier plan et on tue le job 1

Empêcher le HUP avec nohup

Enfin, il existe un programme appelé nohup qui se comporte comme un processus père indépendamment de la session utilisateur. Lorsqu'un utilisateur ferme sa session, le système envoie le signal HUP à tous les processus liés à la session.

Par exemple, si vous souhaitez empêcher que le système envoie le signal HUP à votre script bigbang qui cherche à calculer l'âge de l'univers, vous devriez le lancer comme ceci :

Résumé et exercices

Questions de révision

Oui ou Non

  1. la commande kill lancée sur un processus tentera toujours de tuer le processus donné :

  2. Les commandes "kill $(pidof xeyes)" et "killall xeyes" sont équivalentes : _

  3. Un programme lancé avec le caractère "&" sera lancé en tâche de fond : _

  4. La valeur de nice d'un processus est la même que sa priorité de processeur : _

Voir les réponses

Glossaire

Terme

Description

processus en arrière plan

Processus lancé à partir du shell avec :

$commande & 

Contrairement aux processus au premier plan, vous pouvez lancer d'autres commandes dans le shell sans devoir attendre que ce processus soit terminé

processus au premier plan

Processus lancé à partir du shell avec :

$commande

Une fois le processus lancé, le shell doit attendre qu'il se termine avant de pouvoir lancer une autre commande

processus orphelin

Processus dont le père s'est terminé. Un processus orphelin est "adopté" par init

PID

Nombre associé au processus

processus zombie

processus terminé mais que le parent considère comme encore présent, en attendant le prochain appel système wait(). L'appel système wait() effectué par le processus père peut modifier l'état du processus fils en terminé, si le processus s'est terminé. En général, un processus zombie ne dure pas longtemps. Cependant, des bogues ou anomalies peuvent faire durer des processus zombies, qui monopolisent des ressources système même si le processus est physiquement terminé !

Commandes

Commande

Description (apropos)

bg

reprendre en arrière plan un job suspendu

Ctrl+Z

combinaison de touches utilisée pour suspendre le processus actif au premier plan

fg

placer un job au premier plan (il devient ainsi le processus actif)

jobs

liste des processus lancés à partir du terminal actif

kill

envoyer un signal spécifié à un processus en utilisant son PID

killall

envoyer un signal spécifié à un processus en utilisant son nom

nice

lance un processus en modifiant sa priorité

nohup

nohup (1) - Exécuter une commande en la rendant insensible aux déconnexions, avec une sortie hors terminal

ps

ps(1) - affiche un instantané des processus actifs. Si vous souhaitez que ce soit mis à jour régulièrement, utilisez top

pstree

affiche une arborescence des processus actifs en partant (par défaut) d'init

renice

modifie la priorité d'exécution d'un processus

top

top (1) - Afficher les tâches

Travaux pratiques

  1. Vérifiez la valeur de nice de votre x-terminal. Changez cette valeur avec top ou renice

  2. Quel signal est équivalent à ^Z ? (Vous obtiendrez la liste des lignaux avec kill -l)

  3. Quel signal, redéfini pour la plupart des services, les force à relire leur fichier de configuration ?
  4. Quel est le signal envoyé par défaut à un processus en utilisant kill ou killall ?

  5. Quel signal est directement géré par le noyau et ne oeut pas être redéfini ?
  6. Avant de continuer, connectez vous à un terminal virtuel (tty1 à tty6). Nous souhaitons lancer un script qui coninuera à être exécuté quand nous nous déconnecterons, en utilisant le processus père nohup.

    • dans le répertoire /tmp, créez un fichier nommé impression contenant :

       compte=0
       while (true) do
           echo iteration numero $compte
           let compte+=1
      done 
    • Nous commençons par taper les lignes suivantes, sans utiliser nohup :

      cd /tmp
      ./impression &
      exit
    • Il est possible que vous ne voyiez pas la ligne de commande en tapant exit mais ça devrait vous déconnecter. Reconnectez-vous et vérifier que impression n'est plus exécuté :

      ps ux |  grep  impression
    • Ensuite, lancez la commande avec :
      nohup /tmp/impression &
      exit
    • Reconnectez-vous puis testez ces commandes :
      ps ux |grep impression
      tail -f ~/nohup.out
      Ctrl+C
      killall impression
      ps ux|grep impression
      tail -f ~/nohup.out

Réponses aux questions

  1. Non : kill envoie un signak aux processus. Certains signaux mettent simplement le processus en pause, d'autres forcent les services à relire leur fichier de configuration. Cependant, la signal par défaut (15 ou SIGTERM) tente de terminer le processus.

  2. Oui

  3. Oui

  4. Non

Page consultée 456 fois