Devoir Surveillé - Systèmes d'Exploitation I

Question 1 - Identifications des commandes (Qui suis-je ?)

Cette question valide vos connaissances sur les commandes de base d'administration système sous Linux. Voici les réponses correspondantes à chaque définition :

• (a) Commande pour décharger un module noyau : rmmod
• (b) Commande pour envoyer un signal à des processus par leur nom : killall
• (c) Commande pour afficher le PID d'un processus par son nom : pidof
• (d) Commande pour lister la taille des segments d'un processus : size
• (e) Commande pour lister les modules en cours d'exécution dans le noyau : lsmod

Question 2 - Correction des déclarations sur les processus

Il s'agit d'identifier et de corriger l'erreur factuelle dans chaque affirmation.

Déclaration (a)

Erreur : L'affirmation dit que le processus zombie n'a pas lu le code de retour de son père. Correction : C'est l'inverse. Un processus zombie est un processus terminé, mais dont le processus père n'a pas encore lu le code de retour (ou l'état de terminaison).

Déclaration (b)

Erreur : L'affirmation propose d'utiliser sleep pour éviter les zombies. Correction : L'appel système wait (ou waitpid) permet au processus père de récupérer l'état de son fils et ainsi d'éviter l'apparition prolongée de processus zombies.

Déclaration (c)

Erreur : L'affirmation dit que getppid affiche le PID du petit-fils. Correction : L'appel système getppid (Get Parent Process ID) retourne le PID du processus père. Note importante : Le corrigé original du sujet indique que la solution est "le PID du processus grand-père". C'est une erreur technique dans le document source. Sous les systèmes POSIX/Linux, getppid retourne systématiquement le PID du parent direct (le père), et non du grand-père.

Question 3 - Famille nombreuse (Création de processus)

L'objectif est d'écrire un programme en langage C qui demande à l'utilisateur un nombre entier n, puis génère n processus.

Le code extrait du sujet d'origine comporte des erreurs de syntaxe dues à la numérisation (comme if ( fork() > )) et des erreurs de logique. En effet, utiliser if (fork() == 0) fork(); dans une boucle sans instruction de sortie (exit ou break) pour l'enfant crée une croissance exponentielle de processus (fork bomb) au lieu du nombre exact n.

Voici le code corrigé et sécurisé pour qu'il soit syntaxiquement valide et qu'il génère très exactement n processus fils à partir du processus père :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    int i;
    int n;

    printf("n ?\n");
    if (scanf("%d", &n) != 1) {
        return 1;
    }

    /* Le processus père crée n fils */
    for (i = 0; i < n; i++) {
        if (fork() == 0) {
            /* L'enfant s'arrête ici pour ne pas créer d'autres processus */
            exit(0); 
        }
    }
    
    /* Le père attend la terminaison de tous ses enfants */
    for (i = 0; i < n; i++) {
        wait(NULL);
    }

    return 0;
}

Question 4 - Arborescences de processus

Cette question explore comment les opérateurs logiques (&&, ||) et les conditions agissent sur la valeur de retour de fork() pour créer des topologies spécifiques. Sous Linux, fork() retourne 0 pour l'enfant, et le PID de l'enfant (un entier > 0) pour le père.

Topologie (a) - Un père (P1) et un fils (P2)

Pour créer un seul enfant à partir d'un parent, un appel simple suffit.

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

int main() {
    fork();
    return 0;
}

Topologie (b) - Une chaîne (P1 crée P2, qui crée P3)

Il faut que seul le processus fils exécute le second fork().

• Méthode 1 : if (fork() == 0) fork();
• Méthode 2 (opérateur OU) : fork() || fork(); Le père P1 exécute le premier fork (retourne > 0, vrai), l'évaluation s'arrête (court-circuit). L'enfant P2 reçoit 0 (faux), il est donc forcé d'évaluer la partie droite et exécute le second fork(), créant P3.

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

int main() {
    fork() || fork();
    return 0;
}

Topologie (c) - Des frères (P1 crée P2, puis P1 crée P3)

Il faut que seul le processus père exécute le second fork().

• Méthode 1 : if (fork() > 0) fork();
• Méthode 2 (opérateur ET) : fork() && fork(); Le père P1 exécute le premier fork (retourne > 0, vrai), il doit donc évaluer la suite et exécute le second fork(), créant P3. L'enfant P2 reçoit 0 (faux), l'évaluation s'arrête (court-circuit).

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

int main() {
    fork() && fork();
    return 0;
}

Topologie (d) - Arbre asymétrique (P1 crée P2 et P3, P3 crée P4)

Le corrigé propose de combiner les opérateurs pour cibler les bons processus.

• Méthode principale : fork() && (fork() || fork());
  1. P1 passe le premier fork() (vrai) et entre dans la parenthèse. Il exécute le premier fork() du OU, créant P3. Ce fork retourne vrai (> 0) pour P1, qui s'arrête.
  2. P2 (issu du tout premier fork) reçoit 0 (faux). À cause du &&, il s'arrête immédiatement.
  3. P3 (issu du second fork, exécuté par P1) reçoit 0 (faux) au début de la parenthèse. À cause du ||, il doit évaluer la droite, exécute le dernier fork(), et crée P4.

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

int main() {
    fork() && (fork() || fork());
    return 0;
}

Question 5 - Ordonnancement des processus (Algorithme FCFS)

Nous étudions un système mono-processeur avec l'algorithme FCFS (First Come, First Served / Premier arrivé, premier servi).

Données du problème :

Processus	Date d'arrivée	Durée d'exécution
P1	0	3
P2	2	6
P3	4	4
P4	6	5
P5	8	2

(a) Diagramme de GANTT

Le processeur est libre à t=0. Chaque processus s'exécute jusqu'à complétion sans être interrompu, dans l'ordre strict de leurs arrivées.

[0] -- P1 -- [3] -- P2 -- [9] -- P3 -- [13] -- P4 -- [18] -- P5 -- [20]

(b) Temps de séjour moyen

Le temps de séjour (Turnaround Time) se calcule par la formule : Date de fin - Date d'arrivée.

• P1 : 3 - 0 = 3
• P2 : 9 - 2 = 7
• P3 : 13 - 4 = 9
• P4 : 18 - 6 = 12
• P5 : 20 - 8 = 12

Calcul de la moyenne : (3 + 7 + 9 + 12 + 12) / 5 = 43 / 5 = 8.6 Le temps de séjour moyen est de 8.6 unités de temps.

(c) Temps d'attente moyen

Le temps d'attente (Waiting Time) se calcule par la formule : Temps de séjour - Durée d'exécution. (Ou Date de début - Date d'arrivée).

• P1 : 3 - 3 = 0
• P2 : 7 - 6 = 1
• P3 : 9 - 4 = 5
• P4 : 12 - 5 = 7
• P5 : 12 - 2 = 10

Calcul de la moyenne : (0 + 1 + 5 + 7 + 10) / 5 = 23 / 5 = 4.6 Le temps d'attente moyen est de 4.6 unités de temps.

Question 6 - Le problème de famine avec FCFS

L'algorithme FCFS est un ordonnancement non préemptif (sans réquisition). Une fois qu'un processus obtient l'accès au processeur, il le conserve jusqu'à ce qu'il se termine ou qu'il bloque volontairement (pour une opération d'entrée/sortie, par exemple).

Cela peut conduire à une situation de famine (starvation) dans le cas où un processus engage une boucle infinie ou nécessite un temps de calcul extrêmement long. Puisqu'il n'y a aucune garantie ou mécanisme matériel/logiciel forçant ce processus à relâcher le CPU (pas de quantum de temps comme dans le Round Robin), tous les processus en file d'attente attendront indéfiniment sans jamais pouvoir s'exécuter.

Méthode

Pour réussir ce type d'épreuve (Systèmes d'Exploitation) :

1. Appels Système : Mémorisez rigoureusement les valeurs de retour des appels systèmes classiques (fork(), wait(), exec()). La majorité des exercices d'arborescence reposent sur la différence entre le PID retourné au père (un entier positif) et la valeur 0 retournée au fils.
2. Évaluation paresseuse (Court-circuit) : Dans les expressions booléennes en C, révisez la manière dont le compilateur évalue && (s'arrête dès qu'une condition est fausse, évaluée à 0) et || (s'arrête dès qu'une condition est vraie, évaluée à > 0). C'est la clé de l'exercice 4.
3. Ordonnancement : Tracez toujours le diagramme de Gantt au brouillon de manière proportionnelle. Les calculs des temps de séjour et d'attente ne sont que de simples soustractions, mais une erreur d'un point sur la date de fin d'un processus décale systématiquement toutes les moyennes qui suivent. Vérifiez toujours que la date de fin globale correspond à la somme des durées (ici, 3+6+4+5+2 = 20) lorsque le processeur n'est jamais resté inactif.