[Cours système Linux – Episode 4] Visualiser les processus et l’environnement

Le but de ce module est de toucher du doigt ce que sont les processus et les variables d’environnement.

1) La commande de base pour visualiser les processus lancés est la commande ps. Cependant, on peut visualiser tous les processus de la machine avec l’arbre de filiation en tapant la commande :

pstree

2) Visualiser l’état des processus de la machine en tapant la commande :

ps aux

La colonne STAT donne le statut de chaque processus.

Etat S : sleeping

Etat R : running ou runnable (on run queue)

Etat D : sleeping non interruptible (généralement en attente d’entrée sortie)

Etat T : stoppé

Etat Z : zombie

Constatez qu’il n’y a de processus ni à l’état T, ni à l’état Z actuellement sur la machine.

3) Visualiser l’environnement des processus en tapant la commande :

env

rajouter une variable d’environnement TOTO en tapant la commande :

export TOTO= « ici toto »

Vérifier que cette nouvelle variable est prise en compte en tapant env

4) Visualiser la valeur des variables importantes en tapant les commandes suivantes :

env | grep HOME

env | grep PATH

env | grep USER

env | grep DISPLAY

5) Nous allons maintenant créer un processus à l’état T (stoppé). Pour ce faire, nous allons créer une boucle infinie en langage C dans un fichier processusT.c.

#include <stdio.h>

int main()
{
printf(“Appuyez maintenant sur Ctrl-Z\n”);
for(;;);
}

Compilez ce programme par la commande : gcc processusT.c -o processusT.

Créer un processus à l’état T est facile : il suffit de faire la combinaison Ctrl-Z, ce qui a pour conséquence que le shell envoie le signal SIGSTOP au processus en cours, et donc stoppe le processus. Visualiser un processus à l’état T (stoppé) en tapant la commande :

./processusT

puis en tapant Ctrl-Z suivi de ps aux

Relancer le processus en tapant la commande :

kill -CONT pid (remplacer pid par le vrai pid du processus).

Tuer définitivement le processus en tapant la commande :

kill -9 pid (remplacer pid par le vrai pid du processus).

6) Nous allons maintenant visualiser un processus à l’état zombie. Pour cela nous allons utiliser le programme processusZ.c suivant.

#include <stdio.h>
#include <stdlib.h>

int main()
{
if(fork()==0) exit(0);
printf(“Tapez maintenant Ctrl-Z suivi de ps aux\n”);
for(;;);
}

Ce programme crée un processus fils (appel système fork) qui meurt de suite en envoyant le code de retour 0 au processus courant, qui n’est autre que son père. Au lieu de lire ce code de retour (par l’appel système wait), le processus courant entre dans une boucle infinie, qu’on va casser en mettant le processus père en mode stoppé (par Ctrl-Z). On pourra ainsi visualiser le processus fils en mode zombie (état Z).

gcc processusZ.c -o processusZ ; ./processusZ suivi de Ctrl-Z puis ps aux

On voit bien le processus fils (defunct = défunt = mort) qui est à l’état Zombie (Z).

Tuer définitivement les 2 processus en tapant la commande :

killall -9 processusZ

PS : dans ces exercices, nous avons envoyé des signaux à nos processus. En l’occurence, lorsqu’on tape Ctrl-C le processus reçoit le signal SIGINT, lorsqu’on tape Ctrl-Z le processus reçoit le signal SIGSTOP, lorsqu’on fait kill -CONT le processus reçoit le signal SIGCONT. Tous les signaux peuvent être soit pris en charge par le processus (via une fonction de traitement à programmer), soit pas (absence de fonction de traitement). Seul le signal SIGKILL (qui porte le numéro 9) ne peut être pris en charge par une fonction de traitement. C’est pourquoi la commande kill -9 tue assurément le processus (kill étant la commande qui effectue l’appel système kill au noyau, lequel a pour fonction d’envoyer un signal au processus). Nous verrons les signaux dans un prochain épisode.

Tagués avec : , ,

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée.

Résoudre : *
8 + 23 =