Cours GNU/Linux: Gestion des processus

- Page 3 -

MP2L

Cours GNU/Linux

F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD

0 S 0 1115 1 0 72 0 - 580 wait4 tty2 0:0:00 login

0 S 0 1216 1115 0 77 0 - 638 wait4 tty2 0:0:00 bash

0 R 0 1262 1216 0 79 0 - 769 - tty2 0:0:00 ps –l

On remarque sur cet l'exemple précédent, que le processus parent du processus qui exécute la

commande login a comme PID la valeur 1 qui correspond au processus init. Le processus

exécutant la commande bash a comme parent le processus ayant comme PID la valeur 1115

(login) et il est en même temps parent du processus ps dont le PID est 1262.

3. Terminaison de processus

Chaque processus qui termine son exécution n'aura plus besoin, en principe, de ressources. Il

faudrait donc éliminer tout processus ayant terminé son exécution afin de libérer les

différentes tables du système référençant ces processus.

Un état, de processus, très particulier sous GNU/Linux est l'état zombie. Il correspond à la

terminaison d'un processus par son père. Ce dernier pourrait consulter les informations dont il

aura besoin pour savoir comment son fils s'est terminé.

Chaque processus qui se termine aura un code de retour (exit status). Ce code de retour sera

utilisé par le processus parent pour récupérer les informations nécessaires à sa progression.

Une valeur nulle, indique une terminaison normale du processus. Une valeur non nulle

indique une terminaison anormale.

Tout processus en cours d'exécution pourrait recevoir de la part d'autres processus des

signaux. On pourrait, à titre d'exemple, interrompre, à l'aide de la touche ctlr c, l'exécution du

processus ls qui affiche le contenu d'un répertoire. Dans ce cas, le terminal envoie un signal

particulier interprété par le shell au processus exécutant la commande ls. Un tel signal est

représenté génériquement par SIGINT. Le système GNU/Linux définit plusieurs signaux qui

pourraient être envoyés aux processus au cours de leur exécution.

Si un processus est en exécution et il reçoit un signal de type SIGINT (interrupt) ou SIGQUIT

(Quit) il sera mis immédiatement à l'état zombie. Si le signal reçu est SIGQUIT, une image du

processus (à sa terminaison) sera copiée sur disque et pour nom core et un message core

dumped sera affiché.

Certains types de processus ignorent l'interprétation de quelques types de signaux (notamment

SIGINT, SIGQUIT). Un exemple typique de tels processus celui associé à un interprète de

commandes.

Yahia SLIMANI/Habib SMEI

- Page 4 -

MP2L

Cours GNU/Linux

GNU/Linux offre un moyen pour envoyer manuellement des signaux à un ou plusieurs

processus. Il met à a disposition des utilisateurs la commande kill. Sa syntaxe est la suivante:

kill signal PID

4. La redirection des entrées-sorties

Le système GNU/Linux définit trois fichiers logiques conventionnels qui seront utilisés par

tous les processus. Le fichier entrée standard (standard input), le fichier sortie standard

(standard output) et le fichier erreur standard (standard error).

Lorsqu'un utilisateur se connecte au système, ce dernier fait l'association entre ces deux

fichiers logiques (fichiers standards) et le terminal de l'utilisateur. Ainsi, le fichier entrée

standard sera affecté au clavier du terminal et le fichier sortie standard est affecté à son écran.

Le système représente, par des entiers, chaque fichier standard dans la table de descripteurs

de fichiers utilisée par chaque processus. Le fichier entrée standard a comme numéro d'index

dans cette table la valeur 0 (premier élément de la table). Le fichier sortie standard a la valeur

1 (deuxième élément de la table). Le fichier erreur standard est le troisième élément de la

table et a, par conséquent, comme descripteur la valeur 2. Le fichier erreur standard est

associé, comme la sortie standard, à l'écran du terminal.

Entrée standard

Sortie standard

Erreur standard

Ce schéma pourrait être modifié de sorte que l'entrée, la sortie et l'erreur standard perdent

leurs valeurs habituelles (leurs associations par défaut). Il devient donc possible, pour un

processus donné, d'accepter ses données d'entrée non plus de l'entrée standard qui, pour les

processus shell et leurs descendants, est associée au clavier du terminal mais à partir d'un

autre emplacement tel qu'un fichier disque classique. Le même raisonnement peut s'appliquer

à la sortie standard qui pourrait être remplacée par un autre fichier (disque ou autre).

 Redirection de l'entrée standard

Pour rediriger l'entrée standard d'un processus, il suffit de taper, sur la ligne de commande, le

nom de la commande associée au processus suivie du caractère spécial '<' et une référence à

un fichier comme illustré par la syntaxe suivante:

$ commande < référence_fichier

Le processus associé à commande ne lit plus ses données à partir de l'entrée standard mais à

partir du fichier désigné par référence_fichier. À noter que l'opération de redirection de

l'entrée standard n'est possible que si le fichier référence_fichier est accessible par

l'utilisateur.

Yahia SLIMANI/Habib SMEI

- Page 5 -

MP2L

Exemple

$ wc < liste

3 8 26

Cours GNU/Linux

L'exemple montre la redirection de l'entrée standard. La commande wc (word count) ne lit

plus ses données à partir de l'entrée standard mais à partir du fichier liste

 Redirection de la sortie standard

Le principe de la redirection de la sortie standard est analogue à celui de l'entrée standard. Le

résultat du processus relatif la commande exécutée depuis le shell interactif ne sera plus

affiché sur la sortie standard (typiquement l'écran du terminal) mais envoyé vers un autre

fichier. La redirection de la sortie standard prend la forme suivante:

$ commande > référence_fichier

Comme dans le cas de la redirection de l'entrée standard, il faut que l'utilisateur aie le droit

d'écriture sur le fichier référence_fichier. Ici deux possibilités sont à évoquer: soit que le

fichier référence_fichier n'existe pas et dans ce cas il sera créé. Si le fichier référence_fichier

existe alors, et selon le shell utilisé, il peut être, ou non, écrasé par le processus relatif à

commande.

Par ailleurs, le système offre une deuxième forme de redirection de la standard: la redirection

en mode ajout (append) en fin de fichier. Un tel type de redirection aura la forme:

$ commande >> référence_fichier

Avec cette forme, si le fichier référence_fichier n'existe pas il sera créé. S'il existe, le

processus relatif à commande ouvrera le fichier référence_fichier en mode append et y écrira

ses résultats à sa fin.

Exemples

$ date > DATE_DU_JOUR

$ cat < DATE_DU_JOUR

Lun fév 18 15:36:48 CET 2002

$ pwd >> DATE_DU_JOUR

$ cat < DATE_DU_JOUR

Lun fév 18 15:36:48 CET 2002

/home/foulen

 Redirection de l'erreur standard

On suppose que sur le répertoire privé de l'utilisateur foulen i.e. /home/foulen, il existe un

fichier liste et un répertoire Desktop. Essayons de prendre l'exemple suivant et de l'analyser:

$ ls –ld liste Desktop LISTE > Liste_Fichiers

ls: LISTE : Aucun fichier ou répertoire de ce type

Yahia SLIMANI/Habib SMEI

- Page 6 -

MP2L

$ cat Liste_Fichiers

Cours GNU/Linux

drw xr-x r-x

3

-rwx- - - - - - 1

foulen

foulen

foulen

foulen

4096 fév 1 23:36 Desktop/

107

fév 5 23:08

liste

Le fichier LISTE n'étant pas existant dans le répertoire de travail, le système va générer un

message d'erreur concernant uniquement le fichier LISTE, par contre pour les deux autres

fichiers, la commande ls –ld a été redirigée vers le fichier Liste_Fichiers.

Avec des interprètes de commandes comme le Bourne Shell ou le Korn Shell, il est possible

de rediriger l'erreur standard séparément.

$ ls –ld liste Desktop LISTE 2>Erreurs >Liste_Fichiers

$ cat Liste_Fichiers

drw xr-x r-x

3

-rwx- - - - - - 1

$ cat <Erreurs

foulen

foulen

foulen

foulen

4096 fév 1 23:36 Desktop/

107

fév 5 23:08

liste

ls: LISTE : Aucun fichier ou répertoire de ce type

Dans l'exemple précédent, nous avons montré comment on pourrait rediriger la sortie erreur

standard vers un autre fichier en utilisant la syntaxe 2 > Nom_Fichier

5. Enchaînement de processus (gestion des jobs)

Le shell utilisé le plus fréquemment sur les systèmes GNU/Linux, bash, propose un système

de contrôle des jobs. Un job correspond à une tâche demandée par l'utilisateur. Cette tâche

peut être composée de plusieurs processus. Ce qui les regroupe est un tube. Un job est donc

un regroupement de plusieurs commandes devant s'exécuter les unes à la suite des autres en

communiquant leurs résultats.

Un exemple tout simple de job pourrait être le suivant :

$ ls | less

ls permet de lister les fichiers. Mais quand ils sont trop nombreux, la consultation est difficile.

less permet alors de paginer ce qui lui est passé sur son entrée standard et de naviguer

facilement à l'aide des touches fléchées.

Il faut bien voir que lorsque ceci aura été tapé, 2 processus seront créés. Un pour exécuter ls et

l'autre pour less. Mais bash fournit une abstraction permettant de manipuler ceci comme un

tout, appelée donc job.

Mais un job pourrait tout aussi bien être constitué d'une seule commande sans utilisation de

tube. L'utilisation de ls uniquement constituerait aussi le lancement d'un job.

Yahia SLIMANI/Habib SMEI

- Page 7 -

MP2L

Cours GNU/Linux

La commande intégrée à bash permettant de les lister s'appelle jobs. La lancer dans un shell

ne produira aucun résultat normalement.

Le système GNU/Linux permet aussi aux utilisateurs de lancer l'exécution de plusieurs processus

(jobs) en même temps. L'exécution peut se faire de manière indépendante en séquence ou en parallèle.

Dans le premier mode d'exécution, les processus sont exécutés en séquence et indépendamment les

uns des autres.

Exemple

La commande suivante produira, dans l'ordre, les résultats:

$ ls –ld ; cat liste; echo Fin du traitement

drw xr-x r-x

-rwx- - - - - -

3

1

foulen

foulen

foulen

foulen

4096

fév 1 23:36

Desktop/

107

fév 5 23:08

liste

Liste des ouvrages:

La Programmation sous UNIX

The C programming language

Manuel en ligne d'UNIX (man)

Fin du traitement

Pour rediriger la sortie standard d'une commande composée, il suffit de parenthésér l'ensemble comme

illustré par l'exemple suivant:

$ (ls –ld ; cat liste; echo Fin du traitement) > Resultat

$ cat < Resultat

drw xr-x r-x

-rwx- - - - - -

3

1

Liste des ouvrages:

foulen

foulen

foulen

foulen

4096

fév 1 23:36

Desktop/

107

fév 5 23:08

liste

La Programmation sous UNIX

The C programming language

Manuel en ligne d'UNIX (man)

Fin du traitement

Notons qu'avec ce mécanisme d'enchaînement, une commande n'est lancée que si celle qui la précède

s'est terminée. Ceci veut dire qu'il n'y a pas de communication entre les différents processus relatifs à

l'ensemble de commandes constituant la commande composée. Ceci n'empêche, qu'il est possible, via

le mécanisme de redirection, de créer une sorte de communication entre les commandes. Voyons

l'exemple suivant:

$ ls > FICHIERS ; wc –l < FICHIERS; rm FICHIERS

Cette méthode n'est pas commode; car elle nécessite à chaque fois, l'utilisation d'un ou de plusieurs

fichiers temporaires et puis leur suppression.

Comme alternative, GNU/Linux offre un mécanisme de communication qui permet aux processus de

s'exécuter simultanément (i.e en parallèle) et d'échanger ainsi des informations (dépendance entre les

processus): c'est le principe de la communication par tube. Un tube (pipe) est une entité temporaire

Yahia SLIMANI/Habib SMEI

- Page 8 -

MP2L

Cours GNU/Linux

qui servira à mettre en communication deux processus: l'un se comporte comme processus écrivain

dans le tube et l'autre comme processus lecteur.

Ainsi la sortie standard du processus écrivain est redirigée vers l'entrée du tube et l'entrée standard du

processus lecteur est redirigée vers la sortie du tube. De cette façon, les résultats produits par le

processus écrivain seront considérés comme données au processus lecteur. On pourrait mettre

plusieurs tubes en cascade; en effet, un processus pourrait se comporter comme lecteur et écrivain à la

fois. La syntaxe d'utilisation d'un tel mécanisme est la suivante:

commande1 ¦ commande2 ¦ … ¦ commanden

Exemple

$ ls –l ¦ wc -l

Cette commande crée deux processus concurrents (concurrence sur les ressources du système,

notamment le processeur). Un tube sera créé pour que le processus associé à la commande ls –l écrive

ses résultats dans l'entrée du tube. Le deuxième processus (associé à la commande wc –l) extraira ces

données (non plus de l'entrée standard ou d'un fichier classique) à partir de la sortie du tube. Quand le

processus écrivain (ls –l) se termine et que le processus lecteur (wc –l) a terminé sa lecture, le tube

sera vide et une fin de fichier sera détectée par le processus lecteur qui provoquera sa terminaison

normale.

Le système doit veiller à la bonne synchronisation des processus. En effet, il doit:

 bloquer le processus lecteur si le tube est vide (attente qu'il se remplisse)

 bloquer le processus écrivain si le tube est plein (cas d'un processus lecteur plus lent qu l'écrivain)

L'exemple suivant met en évidence l'existence des trois processus correspondant aux commandes: ps,

tee et wc :

$ ps ¦ tee RESULTATS ¦ wc –l

PID

641

653

654

655

5

TTY

tty1

tty1

tty1

tty1

$ cat < RESULTATS

PID

641

653

654

655

TTY

tty1

tty1

tty1

tty1

TIME

00:00:00

00:00:00

00:00:00

00:00:00

TIME

00:00:00

00:00:00

00:00:00

00:00:00

COMMAND (ou CMD)

-bash

ps

tee

wc

COMMAND (ou CMD)

-bash

ps

tee

wc

La commande tee, très particulière, peut être insérée pour stocker le résultat de la commande

qui la précède dans des tubes en cascade.

Yahia SLIMANI/Habib SMEI

- Page 9 -

MP2L

Cours GNU/Linux

Il est possible de lancer un job en arrière-plan. Cela permet alors de pouvoir continuer à

utiliser le shell pour d'autres tâches pendant qu'il s'exécute. Emacs est un éditeur de texte très

utilisé (notamment pour faire ce site). Si dans une console au sein d'un environnement

graphique on le lance en tapant son nom, une fenêtre Emacs va s'ouvrir par défaut. Mais la

console ne sera plus utilisable car le shell attendra la fin de l'exécution de l'éditeur avant de

laisser à nouveau la possibilité de lancer des commandes. Pour pouvoir donc lancer ce logiciel

par exemple, il faut rajouter le symbole & (lire esperluette ou ET commercial) à la fin de la

définition de la tâche. Pour cet exemple :

$ emacs &

[1] 6373

La première valeur est le numéro du job. Celui-ci est unique dans le shell courant. Si plusieurs

sont utilisés simultanément (comme par exemple avec plusieurs fenêtres de console), chacun

aura ses propres jobs et ne pourra agir sur ceux des autres.

La seconde valeur affichée est le PID du dernier processus lancé pour ce job. Il correspondra à

la dernière commande dans le tube. Étant donné qu'il n'y en a qu'une ici, ce sera donc le PID

pour le processus exécutant Emacs. Avec l'exemple précédent, ce serait celui correspondant à

less qui serait affiché.

On peut alors utiliser la commande jobs vue précédemment :

$ jobs

[1]+ Running emacs &

On retrouve ici le numéro du job et la commande utilisée pour le lancer (dans la dernière

colonne). La texte "Running" signifie qu'il est en train de s'exécuter. Le signe + indique qu'il

s'agit du job le plus récemment manipulé (ce qui sera utile pour les commandes qui seront

vues ensuite).

Si le programme avait été lancé en oubliant d'ajouter le $ il est tout de même possible de

pouvoir continuer d'utiliser le shell. Pour cela, il faut utiliser la combinaison de touches Ctrl-

Z (maintenir la touche Ctrl et appuyer sur la lettre Z). On aura alors ceci :

$ jobs

[1]+ Stopped emacs

Contrairement à l'exemple précédent, l'état du job est indiqué comme "Stopped". Le job est

alors en sommeil et ne réalise aucune action. La fenêtre d'Emacs est inactive et on ne peut

utiliser ce programme. Il existe toutefois une commande qui permet de demander à ce qu'un

job arrêté reprenne son exécution en arrière-plan. Il s'agit de bg qui prend en paramètre le

Yahia SLIMANI/Habib SMEI

- Page 10 -

MP2L

Cours GNU/Linux

numéro de job. Par défaut, bg agit sur le job portant le + dans la liste affichée. Voici ce que

l'on obtient alors :

$ bg

[1]+ emacs &

$ jobs

[1]+ Running emacs &

Tout se passe alors comme si le & avait été indiqué lors du lancement du programme. On peut

remarquer qu'il est d'ailleurs ajouté à l'affichage.

A l'opposé de bg, il existe fg qui permet de mettre en avant-plan un job. Celui-ci s'exécutera

alors dans le shell empêchant de saisir d'autres commandes. Le paramètre passé à fg est le

même que pour bg (le numéro de job et par défaut celui avec un +). fg peut être utilisé pour

un job tournant en arrière-plan ou arrêté.

L'avant-dernier job manipulé est lui aussi indiqué d'une manière particulière. Voici un

exemple fictif d'affichage :

$ jobs

[1] Running mozilla &

[2]- Stopped su

[3]+ Stopped emacs -nw &

[4] Running dtfile &

En tapant seulement fg (sans paramètre donc), c'est Emacs qui sera mis en avant-plan (l'option

-nw permet de l'utiliser en mode texte directement dans la console). Pour rendre le

programme su actif et utilisable, on peut taper indifféremment une des deux commandes

suivantes :

$ fg 2

$ fg -

L'utilisation du - permet donc d'accéder à l'avant-dernier job et d'ainsi facilement passer d'un

job à un autre sans connaître leurs numéros.

Etant donné que kill est une commande intégrée à bash, il permet aussi d'intéragir avec les

jobs. Pour cela, il faudra à la place du PID indiquer le numéro du job précédé du caractère %.

Comme par exemple :

$ kill -SIGSTOP %1

Qui stoppera le job numéro 3. En fait l'utilisation de Ctrl-Z vue précédemment est équivalente

à l'envoi d'un signal SIGSTOP.

Yahia SLIMANI/Habib SMEI

- Page 11 -