Écrivez un petit programme C qui ne s'arrête pas tout de suite et vérifiez que vous pouvez le voir avec la commande ps.

Remarque : pour empêcher un programme C de se terminer, vous pouvez :

• mettre une boucle infinie while(1); avant l'instruction return finale,

• mettre une instruction getchar(); avant l'instruction return finale,

• mettre une instruction sleep(N); qui met le processus en pause pendant (environ) N secondes.

Dans le premier cas, vous devrez arrêter le programme avec un "Control-c", ou bien avec la commande kill...

Dans le deuxième cas, il ne faut pas oublier la ligne #include <stdio.h> au début de votre fichier... Vous pouvez arrêter le programme en appuyant sur la touche "Entrée".

Dans le troisième cas, il ne faut pas oublier la ligne #include <unistd.h>.

Que doit afficher le programme suivant ?

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

int main() {
  printf("Bonjour,\n");
  fork();
  printf("J'ai fait un 'fork' !\n");
  return 0;
}

Testez et vérifiez que le résultat correspond à vos attentes.

1. Modifiez le programme précédent pour que :

   • 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 (avec une boucle while(1); ou un sleep(10)).

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

   $ make
   gcc     question3.c   -o question3
   $ ./question3 &
   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) sans que le fils ne disparaisse.

Créez un processus zombie. Vous devez :

• expliquez comment vous vous y prenez en donnant le code C correspondant,

• expliquez comment vous vérifiez l'existence du 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.

"Corrigez" le programme de la question précédente pour éviter de créer un nouveau fils si l'ancien ne s'est pas terminé...

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.

Remarque : la commande killall permet de tuer tous les processus avec un nom donné.

$ killall PROCESS_NAME

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.

(*bonus*)

Expliquez ce que fait l'incantation ésotérique suivante dans un shell:

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

É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.

Le programme suivant n'a pas le comportement attendu...

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

int main() {
    printf("Je vais faire un 'fork'... ");
    int p = fork();
    if (p == 0) {
      printf("Je suis le fils...\n");
    } else {
      printf("Je suis le père...\n");
    }
    return 0;
}

Testez et proposez une explication.

Comparez l'utilisation du processeur lors de l'exécution des programmes suivants :

int main() {
  while(1);
  return 0;
}

#include <stdio.h>
int main() {
  getchar();
  return 0;
}

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

Expliquez les différences constatées, en particulier entre le premier et le troisième programme.

$ top

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 5 et 10 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.

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 version du shell n'interprètera que 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 lue 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),

• strcmp pour comparer les chaines de caractères.

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

Dans la deuxième version du shell, vous devrez interpréter 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).

La troisième version du shell lancera un nouveau processus lorsque la ligne n'est pas exit.

On suppose dans ce cas que la ligne consiste uniquement en 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.

La quatrième version du shell lancera un nouveau processus lorsque la ligne n'est pas exit, mais utilisera la suite de la ligne pour spécifier les argument de la commande.

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 (facultatif mais conseillé),

• execv, pour remplacer le execl de la question précédente.

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

La cinquième version du shell doit gérer la commande ls, qui 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. Utilisation de la variable d'environnement PATH pour chercher les exécutables afin d'éviter d'avoir à taper le chemin absolu des commandes.

   Fonction C à utiliser:

   • getenv,

   • execvp (qu'elle est la différence avec execv ?).

2. 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.

3. 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...

4. 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.

5. 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).

6. ...