Organisation du TP:

1ère partie	Exemples à faire fonctionner
2ème partie	Exercice à rendre. L'envoyer par `mail` à l'enseignant qui vous fait les , par exemple : `dupouy@enst.fr` Le texte du sujet ( `subject` ) doit contenir le mot : `TPAST` pour les AST maîtrises `TP1A` pour les éléves de 1ère année

Documentation

Le support de cours sur les processus se trouve ici.

I.Utilisation des commandes du shell

Les exercices suivants s'attachent à montrer les différences entre processus et utilisateur et à mettre en évidence quelques points importants du système Unix.

Pour constater la différence utilisateur/processus, on essaiera la séquence de commandes suivantes:

who		(liste des utilisateurs connectés)
who am i	(qui suis-je ...)
ps -l		(liste des processus attachés au terminal)
ps -edf         (liste  des processus présents sur le système)
ps -axl	        (idem avec plus de détails)
 ou
ps -ael         ...suivant le système utilisé

On remarquera les différents processus :

init de pid 1 et le swapper-scheduler de pid 0.
les démons (notés ?),
ceux qui déroulent un shell (sh, csh ou ksh),

Accès au système. Voir, en les listant avec les commandes ypcatou getent, le contenu des fichiers suivants :
- passwd (commande : ypcat passwd ou getent passwd ) (fichier utilisé par login),
- hosts (commande : ypcat hosts ou getent hosts ) (fichier contenant la liste des machines connues),

Envoi d'une commande en arrière plan (option &) : sleep n met le processus qui l'exécute en pause pendant n secondes.
Envoyer la séquence suivante et observer la filiation des processus : ps -l (liste des processus attachés au terminal courant) sleep 20& (processus qui dort pendant 20s en arrière plan) sleep 30& (processus qui dort pendant 30s en arrière plan) ps -l (pour voir la nouvelle configuration de processus et constater que le processus qui exécute le shell a plusieurs processus fils, chacun faisant tourner le programme sleep)

Effet de la commande exec.
1. Faire : exec ps
  que se passe-t-il et pourquoi ?
  Indication : pour exec, comme pour quelques autres commandes (built-in commands) le shell ne créée pas de nouveau processus, c'est à qu'il ne fait pas appel à fork (cf. man exec).
2. Travailler dans une nouvelle fenêtre,
3. Entrer maintenant la commande : zsh,
4. Relever le numéro du processus qui fait tourner ce nouveau shell courant (en faisant ps -l),
5. Faire maintenant : exec ps -l.
  Relever le pid du processus qui exécute ce programme ps -l.
  Quelle est sa valeur et pourquoi ?

II.Introduction aux exercices en C

Créer un répertoire appelé TPProc dans lequel vous travaillerez :

cd                            Pour aller dans le home directory           
mkdir TPProc
cd TPProc

Par la suite, pour compiler les fichiers et créer les exécutables, utiliser la commande gcc.
Par exemple (premier exercice) :

gcc exo1.c -o exo1
ou, mieux :
gcc -Wall exo1.c -o exo1

Sur une machine multi-processeur on peut avoir à forcer l'exécution sur un seul processeur, dans ce cas il faut utiliser la commande taskset, par exemple :
taskset -c 0 ./exo1

III. Création de processus (fonction fork)

III.1 Fonctions utilisées

On va tout d'abord utiliser les fonctions UNIX suivantes :

fork() :
Cette fonction va créer un processus. La valeur de retour n de cette fonction indique :
- n > 0
  On est dans le processus père,
- n = 0
  On est dans le processus fils,
- n = -1
  fork a échoué, on n'a pas pu créer de processus.
getpid() :
Cette fonction retourne le numéro du processus courant.
getppid() :
Cette fonction retourne le numéro du processus père.

III.2 Exercice 1

Après compilation de exo1.c, on exécutera le programme exo1 plusieurs fois.
Pourquoi cinq lignes sont-elles affichées alors qu'il n'y a que deux printf dans le programme ?
Pour récupérer ce programme exo1.c, cliquer ici.
Ajouter maintenant la ligne suivante derrière l'appel à fork :
if (valeur == 0) sleep (4);
Que se passe-t-il ? Pourquoi ?

III. 3 Exercice 2

Pour récupérer le programme suivant : fork-mul.c, cliquer ici.
Compiler fork-mul.c, puis l'exécuter.

Après exécution et à l'aide du schéma suivant, relever les numéros des processus et numéroter l'ordre d'exécution des instructions printf de façon à retrouver l'ordre d'exécution des processus.

Remarque:
si on relève un numero de processus égal à 1, il s'agit du processus init, père de tous les processus. Init adopte les processus orphelins, c'est à dire qu'un processus dont le père s'est terminé devient fils de 1, et getppid() renvoie 1.

IV.Synchronisation de processus père et fils (mécanisme wait/exit)

IV.1 Fonctions utilisées

exit( i ) :
termine un processus, i est un octet (donc valeurs possibles : 0 à 255) renvoyé dans une variable du type int au processus père.
wait( &Etat ):
met le processus en attente de la fin de l'un de ses processus fils.
Quand un processus se termine, le signal SIGCHILD est envoyé à son père. La recéption de ce signal fait passer le processus père de l'état bloqué à l'état prêt. Le processus père sort donc de la fonction wait.

La valeur de retour de wait est le numéro du processus fils venant de se terminer.
Lorsqu'il n'y a plus (ou pas) de processus fils dont il faut attendre la fin, la fonction wait renvoie -1.
Chaque fois qu'un fils se termine le processus père sort de wait, et il peut consulter Etat pour obtenir des informations sur le fils qui vient de se terminer.

Etat est un pointeur sur un mot de deux octets :

L'octet de poids fort contient la valeur renvoyée par le fils ( i de la fonctionexit( i )),
l'octet de poids faible :
- contient 0 dans le cas général,
- En cas de terminaison anormale du processus fils, cet octet de poids faible contient la valeur du signal reçu par le fils.
  Cette valeur est augmentée de 80 en hexadécimal (128 décimal), si ce signal a entrainé la sauvegarde de l'image mémoire du processus dans un fichier core.

Schéma résumant le contenu du mot pointé par Etat à la sortie de wait :

IV.2 Mécanisme wait/exit

Compiler et exécuter fork-sync.c après l'avoir récupéré en cliquant ici.

V.Père et fils exécutent des programmes différents

V.1 Fonction utilisée

La fonction exec charge un fichier dans la zone de code du processus qui l'appelle, remplaçant ainsi le code courant par ce fichier. Une des formes de cette fonction est execl :

int execl (char *fic, char * arg0, [arg1, ... argn,])

Commentaires :

fic est le nom du fichier exécutable qui sera chargé dans la zone de code du processus qui appelle execl.
Si ce fichier n'est pas dans le répertoire courant, il faut donner son nom complet (chemin absolu).
Les paramètres suivants sont des pointeurs sur des chaines de caractères contenant les arguments passés à ce programme (cf. argv en C).
La convention UNIX impose que la première soit le nom du fichier lui-même et que le dernier soit un pointeur nul.
Par exemple, si on veut charger le fichier appelé prog qui se trouve dans le répertoire courant et qui n'utilise auncun argument passé sur la ligne de commande :
execl ("prog", "prog", (char *)0)

V.2 Fonctionnement de exec

Compiler puis exécuter le fichier fexec.c (il est ici).
Pour en vérifier le bon fonctionnement, on fera exécuter par execl un fichier très simple, par exemple celui dont le source est ci-dessous :

int main (void) { 
   printf("Bonjour, ici %d !\n", (int)getpid() );
   sleep (4);
   return 6;
}

On peut exécuter ce programme en lui passant diverses commandes en argument, par exemple, si l'exécutable s'appelle fexec : fexec /usr/bin/xclock fexec /bin/ps fexec exo1 (si on a fait : gcc -Wall exo1.c -o exo1) fexec /usr/bin/emacs ...

VI. Exercice à rendre

D'après les exemples précédents, écrire un programme dont le fonctionnement est le suivant (compiler en utilisant l'option -Wall de gcc, il ne doit pas y avoir de warnings après la compilation) :

il lit sur la ligne de commande (utiliser argc et argv) le nombre N de processus à créer.
il crée ces N processus en faisant N appels à fork (cf. plus loin la tâche assignée à ces processus).
Pour obtenir un canevas du programme à écrire ainsi que des indications sur l'utilisation de argc, argv et sur la création des N fils, cliquer ici.
il se met en attente (appel à Pid_Fils = wait(&Etat)) de ces N processus fils et visualise leur identité (Pid_Fils et valeur de Etat) au fur et à mesure de leurs terminaisons.
Pour attendre la fin de tous les fils, utiliser le fait que wait renvoie la valeur -1 quand il n'y a plus de processus fils à attendre.
Ce que fait chacun des processus fils Pi:
- il visualise son pid (getpid) et celui de son père (getppid),
- il se met en attente pendant 2*i secondes (sleep (2*i)), visualise la fin de l'attente,
- il se termine par exit (i).

Après avoir vérifié que le programme fonctionne correctement :

Faire en sorte que l'un des processus fils se termine anormalement (par exemple en faisant une division entière par zéro ou en déréférençant un pointeur nul) et constater que le système ne renvoie pas zéro en poids faible de Etat, mais y dépose un indicateur d'erreur.