1. Écrivez un programme avec un fork où :

   • le père affiche le PID du processus créé (du fils),

   • le fils affiche un message simple,

   • les processus ne se terminent pas instantanément. (Vous pouvez par exemple utiliser une boucle while(1); ou un sleep(10)).

2. Compilez et lancez votre programme en arrière plan :

   $ make
   gcc     question1.c   -o question1
   $ ./question1 &
   Salut, je m'appelle Bob et je suis le père. Mon fils a le PID 185.
   Hej, je suis le fils de Bob.

3. En utilisant la commande ps, vérifiez que vous avez bien créé 2 processus, et que l'un d'eux a effectivement le PID du fils (affiché par le père).

4. Vérifiez que vous pouvez tuer le processus père (avec la commande kill depuis le shell) et que le fils est adopté par init.

5. Vérifiez que vous pouvez tuer le processus fils (avec la commande kill depuis le shell) et qu'il reste sous forme de processus zombie.

On considère le programme suivant

#include <stdio.h>
#include <unistd.h>

int main() {
  int p;
  int n = 0;
  printf("Bonjour,\n");
  while(++n) {
    sleep(1);
    p = fork();
    if (p > 0) {
      printf("J'ai un nouveau fils: %i!\n", p);
    } else if (p == 0) {
      printf("Je suis le fils n° %i, je me termine!\n", n);
      return 0;
    } else {
      printf("ERREUR lors du fork...\n");
    }
  }
  return 0;
}

1. Faites un petit schéma pour montrer l'arborescence des processus engendré par ce programme.

2. Au nème passage dans la boucle, combien de processus sont actifs ?

3. Au nème passage dans la boucle, combien de processus sont présents dans la table des processus ?

4. Que va t'il se passer si on attend trop longtemps ? Supprimez la ligne sleep(1) pour confirmer votre conjecture.

5. "Corrigez" le programme pour éviter de créer un nouveau fils si l'ancien ne s'est pas terminé.

   L'appel système wait(NULL) attend que l'un des fils du processus courant se termine et renvoie son PID. Si l'un des fils s'est terminé avant l'appel à wait(NULL), son PID est immédiatement renvoyé. (N'oubliez pas la ligne #include <sys/wait.h>.)

1. Écrivez un programme qui se comporte de la manière suivante :

   • le processus initial créé un fils et se termine,

   • le fils créé un fils (petit fils du processus initial) et se termine,

   • le petit fils créé un fils (petit petit fils du processus initial) et se termine,

   • ad infinitum

2. Expliquez pourquoi le programme obtenu ne sature pas la table des processus.

On considère le programme suivant.

#include <unistd.h>
int main() {
  while(1) {
    sleep(1);
    fork();
  }
  return 0;
}

1. Comment va t'il se comporter ?

2. Faite des petits schémas pour dessiner l'arborescence des processus aux étapes 3 et 4 de la boucle.

$ :(){ :|:& };:

Écrivez un programme C qui

• créé un fils

• le père et le fils rentrent dans une boucle infinie qui fait des affichages (printf).

Répondez aux questions suivantes :

1. Dans quel ordre se font les affichages ?

2. Est-ce que cet ordre est toujours le même ?

N'oubliez pas de décrire comment vous procédez...

Que se passe t'il lorsqu'un processus fait un fork(), et que le père et le fils lisent sur l'entrée standard (avec getchar() par exemple) ?

Décrivez votre méthodologie ainsi que les résultats trouvés.

$ stty -icanon
...
...
...
$ stty icanon

1. Testez le programme suivant

   #include <stdio.h>
   #include <unistd.h>
   int main() {
       int p = getpid();
       printf("DÉBUT %i\n", p);
       unsigned n = 0x7fffffff;
       while(n--);
       printf("FIN %i\n", p);
       return 0;
   }
   

   et ajustez la valeur de n pour que l'exécution du programme prenne entre 2 et 5 secondes.

2. Lancez 2 instances de ce programme "en même temps". Quelle est la durée d'exécution totale pour les deux processus ?

   Expliquez ce que vous constatez.

   N'hésitez pas à utilisez la commande top dans un autre terminal pour visualiser les processus...

3. idem pour 4 ou 8 processus, ou plus.

4. Que se passe t'il si on remplace la boucle while(n--); par un sleep(5); ?

1. Lancez deux instances du processus précédent "en même temps", mais en diminuant la priorité d'une des instances.

   Décrivez ce que vous constatez et expliquez.

2. Idem pour 4 ou 8 instances, dont 3 ou 7 sont moins prioritaires.

La première commande à interpréter est la commande exit. Dans tous les autres cas, votre shell affichera un message d'erreur...

Fonction C à utiliser :

• fflush et stdout (variable globale), théoriquement nécessaire, mais probablement facultative en pratique,

• fgets pour lire une ligne (attention, le caractère '\n' fait partie de la chaine renvoyée par fgets),

• stdin (variable globale),

• strtok pour récupérer le premier mot de la ligne et supprimer les espaces autour (note : on peut donner plusieurs séparateurs à strtok, par exemple " \t\n\r" pour couper sur tous les caractères blancs et les supprimer),

• strcmp pour comparer les chaines de caractères.

Remarque : pour simplifier, n'hésitez pas à imposer une limite (raisonnable) sur le nombre de caractères autorisés sur une ligne.

Interprétez maintenant les commandes pwd et cd <PATH>.

Fonction C à utiliser :

• getcwd pour récupérer la valeur courante du répertoire de travail,

• chdir pour changer le répertoire de travail,

• strtok pour récupérer le second mot de la ligne (argument <PATH>).

"exit" ou "pwd" sont des commandes internes au shell ("builtin" en anglais). Le shell permet également de lancer de nouveaux processus en exécutant un fichier. Vous devez maintenant gérer ceci.

1. On suppose dans ce cas que la ligne contient uniquement un chemin d'accès vers un fichier exécutable qu'il faudra lancer dans un nouveau processus. Votre shell devra attendre la fin de ce processus avant de réafficher le prompt et de continuer...

   Fonctions C à utiliser :

   • fork,

   • execl pour exécuter un nouveau programme,

   • wait ou waitpid.

   Les commandes de la famille de execl gèrent automatiquement les chemins absolus et relatifs.

   Pour tester, vous pouvez soit exécuter des commandes système (avec un chemin absolu complet), soit tester avec des commandes locales (avec un chemin relatif) :

   # /bin/date
   Thu Nov 7 15:39:15 CET 2019
   # ./question1
   Salut, je m'appelle Bob et je suis le père. Mon fils a le PID 217.
   Hej, je suis le fils de Bob.

2. La plupart des programmes acceptent des arguments sur la ligne de commandes. Vous devrez donc découper la ligne en mots et utiliser le premier mot comme chemin d'accès au fichier exécutable, et les mots suivant comme tableau d'arguments (pour la commande execv).

   Fonction C à utiliser :

   • strtok pour découper la ligne,

   • execv, pour remplacer le execl de la question précédente (faites attention à bien initialiser les premières et dernières cases de l'argument argv !).

   Remarque : n'hésitez pas à imposer une limite (raisonnable) sur le nombre d'arguments possibles des commandes,

   Vous pouvez par exemple tester la commande printf:

     # /usr/bin/printf %i+%i=%i 1 2 3
     1+2=3

   (Attention à ne pas rajouter d'espace pour que les arguments soient bien lus correctement avec strtok.)

La commande ls est une commande externe (fichier /bin/ls sur mon système). Nous allons en programmer une version simple interne : lorsque la ligne commence par ls, votre code appellera une fonction que vous écrirez qui affichera la liste des fichiers / répertoires du répertoire de travail.

Fonctions C à utiliser :

• getcwd (ou une variante) pour obtenir le répertoire de travail,

• opendir pour ouvrir un répertoire,

• readdir pour lire la liste des fichiers / répertoires d'un répertoire.

Ajoutez des fonctionnalités (au choix) dans votre shell.

Par exemple :

1. Possibilité de quitter le shell avec Ctrl-d, qui ferme l'entrée standard du programme.

2. Gestion des variables d'environnement $PWD et $OLDPWD et de l'abréviation cd - pour aller au répertoire précédent, cd pour aller au répertoire $HOME de l'utilisateur.

   Fonctions C pertinentes :

   • getenv,

   • setenv.

3. Utilisation de la variable d'environnement PATH pour chercher les exécutables afin d'éviter d'avoir à taper le chemin absolu des commandes. (Regardez dans la page de manuel de execv pour voir comment faire.)

4. Redirection de la sortie standard dans un fichier avec

   # CMD > FICHIER

   Fonctions C à utiliser :

   • open,

   • dup2,

   • STDOUT_FILENO (constante).

   Vous pouvez imposer que les tokens ">" et "FICHIER" soient les derniers sur la ligne.

5. Redirection de l'entrée standard avec "< FICHIER", ou redirection de la sortie en mode append avec ">> FICHIER".

   C'est encore mieux si on peut faire plusieurs redirections sur la même ligne...

6. Lancement d'un processus externe en arrière plan avec

   # CMD &

   Remarque : il n'est pas demandé d'implanter les fonctionnalités bg et fg des shells usuels.

7. Plus difficile : redirection de la sortie standard d'une commande vers l'entrée standard d'une autre commande avec

   # CMD1 | CMD2

   Fonctions C à utiliser:

   • pipe,

   • dup2,

   • STDOUT_FILENO et STDIN_FILENO (constantes).

8. ...