---

• Gestion de processus : fork(), getpid(), getppid(), exit(), wait()
  
• Tubes sans nom : pipe()
• Exécution de commandes : primitives de la famille exec()
• Duplication de descripteurs : dup(), dup2()
  

Exercice 1.

Examiner ce programme et prévoir ce qui s'affichera à l'écran (sans exécuter le programme). Y a t-il une possibilité pour que le mot Fils apparaisse avant le mot Père ? Y a t-il une possibilité pour que le programme affiche Père : x = 2 ? Justifier vos réponses.

#include <stdio.h>
#include <stdlib.h>
  
main()
{
   int x;

   x = 1;
   if(fork () == 0)
     {
       x++;
       printf("Fils : x = %d\n", x);
       exit(0);
     }
   else
     {
       printf("Père : x = %d\n", x);
       wait(NULL);
       exit(0);
     }
}


Exercice 2.

Exécuter le programme suivant. Expliquer pourquoi le mot "Bonjour" apparaît deux fois à l'écran alors qu'il n'y a qu'un seul printf("Bonjour ");.

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

main()
{
   printf("Bonjour ");
   if(fork () == 0)
      {
       printf("Monsieur\n");
       exit(0);
     }
   else
      {
       printf("Madame\n");
       wait(NULL);
       exit(0);
       }
   return 0 ;
}


Exercice 3.

Attention cet exercice est dangereux ! Si vous vous trompez vous pouvez générer un très grand nombre de processus et éventuellement bloquer votre session. Donc, réfléchissez bien avant de lancer l'exécution de votre programme. Ecrire un programme ayant la syntaxe suivante:

L'action de ce programme doit être de générer n processus, chacun d'entre eux devant générer n processus à son tour et ainsi de suite jusqu'à m niveaux. Combien de processus sont générés au total ?


Exercice 4.

Un tube a une capacité finie : il ne peut contenir qu'un nombre limité d'octets. Dans cet exercice, on désire connaître la capacité d'un tube c'est-à-dire le nombre maximum d'octets qu'il peut contenir. Pour cela, on propose d'écrire un programme qui crée un tube, envoie une à une des données, en les comptant et en affichant à chaque fois le nombre de données envoyées, dans le tube qu'aucun lecteur ne consulte (ouvert en lecture, mais jamais lu par un processus). Au bout d'un certain temps, le programme se bloque en attendant que le tube se vide. Il suffit alors de lire le nombre de données envoyées pour connaître la capacité du tube.


Exercice 5.

    On se propose d'écrire un programme qui liste les n premiers nombres premiers. Pour cela on choisit d'implémenter l'algorithme du crible d'Eratosthène. Ecrire un programme qui crée n processus. Le premier processus passe (via un tube) au deuxième processus tous les nombres entiers de 2 à n², le deuxième processus affiche le premier nombre qu'il reçoit (i.e. le nombre 2) et passe ensuite (via un autre tube) au troisième processus tous les nombres reçus qui ne sont pas des multiples de 2, le troisième processus affiche le premier nombre qu'il reçoit (i.e. le nombre 3) et passe ensuite (via un autre tube) au quatrième processus tous les nombres reçus qui ne sont pas des multiples de 3, et ainsi de suite jusqu'au (n-1)-ième processus qui affiche  le premier nombre qu'il reçoit (disons p) et passe ensuite au dernier processus (via un dernier tube) tous les nombres reçus qui ne sont pas des multiples de p, le dernier processus affiche le premier nombre qu'il reçoit, attend la terminaison de tous les autres processus et se termine.

Exercice 6.

Ecrire un programme qui crée 2 processus l’un faisant la commande ls -l, l’autre la commande ps -l. Le père devra attendre la fin de ses deux fils et afficher quel a été le premier processus à terminer.


Exercice 7.

Ecrire un programme qui :

1. lit une commande sur l'entrée standard (vous pouvez utiliser la fonction de bibliothèque fgets()),
2. décompose la commande en plusieurs mots (le mots sont séparés par des espaces),
3. exécute cette commande en utilisant la primitive système execvp().
4. revient au point 1.

Félicitations vous avez écrit un shell !


Exercice 8.

Reprendre le programme précédent et ajouter un traitement spécial dans le cas où la commande est terminée par le symbole &. Dans ce cas la commande doit être exécutées en tâche de fond et le programme doit lire une nouvelle commande sans attendre que la commande se termine.


Exercice 9.

Le but de cet exercice est d'implémenter quelques unes des redirections du shell.
a) Construire une commande redirige-entree, telle que redirige-entree cmd fichier se comporte comme la commande shell : cmd < fichier_.
b) Construire une commande redirige-sortie, telle que redirige-sortie cmd fichier se comporte comme la commande shell : cmd > fichier_.
c)  Comment implémenter les redirections suivantes     >>     <<     2>     2>>  ?


Exercice 10.

Construire une commande compose, telle que compose cmd₁ cmd₂ … cmd_n se comporte comme la commande shell cmd₁ ∣ cmd₂ ∣ ⋯ ∣ cmd_n.