Devoir Surveillé Systèmes D'Exploitation I

CORRIGÉ - Module carte réseaux sans-fil récalcitrant

Question 1(a) - Identification de la carte réseau

Solution : Intel Corporation Centrino Wireless-N 2230 (rev c4)

EXPLICATION : La commande lspci liste tous les périphériques connectés au bus PCI. Pour identifier la carte réseau sans-fil, il faut repérer la ligne contenant la classe Network controller. La ligne Ethernet controller correspond quant à elle à la carte réseau filaire (Realtek).

Question 1(b) - Liste triée des modules chargés

Solution :

lsmod | sort

EXPLICATION : La commande lsmod liste les modules actuellement chargés dans le noyau. Le symbole | (tube ou pipe) permet de rediriger la sortie de cette commande vers l'entrée de la commande sort, qui trie les résultats par ordre alphabétique.

Question 1(c) - Vérification d'un module spécifique

Solution :

lsmod | grep iwlwifi

EXPLICATION : La commande grep permet de filtrer la sortie de lsmod pour ne conserver que les lignes contenant le motif iwlwifi. Si la commande ne retourne rien, cela confirme que le module n'est pas chargé.

Question 1(d) - Décompression de l'archive

Solution :

tar -zxvf iwlwifi.tar.gz

EXPLICATION : Les drapeaux utilisés avec tar signifient :

• -z : filtrer l'archive via gzip (pour décompresser le .gz)
• -x : extraire les fichiers
• -v : mode verbeux (affiche les fichiers traités)
• -f : utiliser le fichier d'archive spécifié

Question 1(e) - Compilation du pilote

Solution :

make

Question 1(f) - Chargement du module et de ses dépendances

Solution :

modprobe iwlwifi

EXPLICATION : Contrairement à la commande insmod qui ne charge qu'un module spécifique et échoue si les dépendances ne sont pas présentes, modprobe est l'outil recommandé car il lit les dépendances (via modules.dep) et charge automatiquement tous les modules préalablement requis.

CORRIGÉ - Vie et mort d'un processus Unix

Note : Le code source fourni dans l'énoncé comportait de nombreuses erreurs d'espacement dues à l'extraction du PDF (ex: p i d_ t p i d ;). Le code a été reconstitué avec une syntaxe C valide.

Question 2(a) - Identification des liens de parenté

Solution :

• (1) : Fils (puisque pid == 0 identifie le processus enfant)
• (2) : Père (la fonction getppid() retourne le PID du processus parent)
• (3) : Père (le bloc else est exécuté par le processus créateur)
• (4) : Fils (dans le bloc du parent, la variable pid contient le PID de l'enfant nouvellement créé)

Question 2(b) - Éviter l'apparition d'un processus orphelin

Pour éviter qu'un processus fils ne devienne orphelin, le processus père doit s'assurer d'attendre la fin de l'exécution de son fils avant de se terminer lui-même, en utilisant la fonction wait().

Solution :

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    
    if (pid > 0) {
        /* Le père attend la fin de l'exécution de son fils */
        wait(NULL);
    }
    
    return 0;
}

Question 2(c) - Mettre en évidence un processus zombie

Un processus devient un "zombie" lorsqu'il a terminé son exécution (il a appelé exit()) mais que son père n'a pas encore lu son code de retour via wait(). Le processus fils reste alors dans la table des processus.

Solution :

#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        /* Le fils se termine immédiatement */
        exit(0);
    } else if (pid > 0) {
        /* Le père s'endort sans faire de wait(), laissant le fils à l'état zombie */
        sleep(10);
    }
    
    return 0;
}

CORRIGÉ - Ordonnancement des processus (Temps de commutation négligeable)

L'algorithme Shortest Remaining Time (SRT) est la version préemptive du plus court d'abord (SJF). À chaque nouvel arrivage ou à chaque fin d'exécution, le processeur est alloué au processus dont le temps d'exécution restant est le plus court.

Déroulement :

• t=0 : P1 arrive. Temps restant : 7. P1 s'exécute.
• t=1 : P2 et P3 arrivent. Temps restants -> P1: 6, P2: 4, P3: 2. Le plus court est P3. P1 est préempté, P3 s'exécute.
• t=2 : P4 arrive. Temps restants -> P3: 1, P4: 2, P2: 4, P1: 6. Le plus court est P3. P3 continue.
• t=3 : P3 termine. P5 arrive. Temps restants -> P5: 1, P4: 2, P2: 4, P1: 6. Le plus court est P5. P5 s'exécute.
• t=4 : P5 termine. Temps restants -> P4: 2, P2: 4, P1: 6. P4 s'exécute.
• t=6 : P4 termine. Temps restants -> P2: 4, P1: 6. P2 s'exécute.
• t=10 : P2 termine. Temps restants -> P1: 6. P1 reprend et s'exécute jusqu'à la fin.
• t=16 : P1 termine.

Question 3(a) - Diagramme de GANTT

Temps	0 - 1	1 - 3	3 - 4	4 - 6	6 - 10	10 - 16
Processus	P1	P3	P5	P4	P2	P1

Question 3(b) - Temps de traitement moyen

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

Processus	Date de fin	Date d'arrivée	Temps de traitement
P1	16	0	16 - 0 = 16
P2	10	1	10 - 1 = 9
P3	3	1	3 - 1 = 2
P4	6	2	6 - 2 = 4
P5	4	3	4 - 3 = 1

• Calcul de la moyenne : (16 + 9 + 2 + 4 + 1) ÷ 5 = 32 ÷ 5 = 6,4 secondes.

CORRIGÉ - Ordonnancement des processus (Commutation de 0,5s)

Hypothèse de résolution : Nous appliquerons le temps de commutation de 0,5s à chaque fois qu'un processus prend possession du processeur, y compris lors du chargement initial à t=0, ce qui correspond au modèle classique strict d'ordonnancement avec surcoût.

Déroulement :

• t=0 : Arrivée de P1. Commutation de contexte [0 - 0,5].
• t=0,5 à 1 : P1 s'exécute pendant 0,5s. Temps restant pour P1 = 6,5s.
• t=1 : Arrivée de P2(4) et P3(2). Le processus le plus court est P3 (2 < 6,5). P1 est préempté.
• t=1 à 1,5 : Commutation de contexte vers P3.
• t=1,5 à 2 : P3 s'exécute (0,5s effectuées, reste 1,5s).
• t=2 : Arrivée de P4(2). Le plus court est P3 (1,5 < 2). P3 continue.
• t=2 à 3 : P3 s'exécute (1s effectuée, reste 0,5s).
• t=3 : Arrivée de P5(1). Le plus court est P3 (0,5 < 1). P3 continue.
• t=3 à 3,5 : P3 termine son exécution.
• t=3,5 : Le processeur est libre. P5 est le plus court parmi ceux en attente (P5:1, P4:2, P2:4, P1:6,5).
• t=3,5 à 4,0 : Commutation de contexte vers P5.
• t=4,0 à 5,0 : P5 s'exécute et termine.
• t=5,0 : Sélection de P4 (2s restantes).
• t=5,0 à 5,5 : Commutation de contexte vers P4.
• t=5,5 à 7,5 : P4 s'exécute et termine.
• t=7,5 : Sélection de P2 (4s restantes).
• t=7,5 à 8,0 : Commutation de contexte vers P2.
• t=8,0 à 12,0 : P2 s'exécute et termine.
• t=12,0 : Sélection de P1 (6,5s restantes).
• t=12,0 à 12,5 : Commutation de contexte vers P1.
• t=12,5 à 19,0 : P1 s'exécute et termine.

Question 4(a) - Diagramme de GANTT (avec commutations = C)

Temps	0-0,5	0,5-1	1-1,5	1,5-3,5	3,5-4	4-5	5-5,5	5,5-7,5	7,5-8	8-12	12-12,5	12,5-19
Action	C	P1	C	P3	C	P5	C	P4	C	P2	C	P1

Question 4(b) - Temps de traitement moyen

Processus	Date de fin	Date d'arrivée	Temps de traitement
P1	19,0	0	19,0 - 0 = 19,0
P2	12,0	1	12,0 - 1 = 11,0
P3	3,5	1	3,5 - 1 = 2,5
P4	7,5	2	7,5 - 2 = 5,5
P5	5,0	3	5,0 - 3 = 2,0

• Calcul de la moyenne : (19,0 + 11,0 + 2,5 + 5,5 + 2,0) ÷ 5 = 40 ÷ 5 = 8,0 secondes.

Méthode

Pour réussir les épreuves de Systèmes d'Exploitation abordant les commandes Linux, le langage C et l'ordonnancement, il faut structurer sa réflexion en plusieurs axes :

1. Administration Système : Apprenez à lire et comprendre la finalité des commandes plutôt que de mémoriser des chaînes de caractères par cœur. La connaissance de la pipeline (|) et des outils de filtrage (grep, sort) est essentielle car ils s'associent pour extraire l'information pertinente.
2. Programmation Système (Processus) : Un arbre de processus est indispensable au brouillon. La primitive fork() renvoie le PID de l'enfant au parent, et 0 à l'enfant. Vérifiez toujours la présence d'un mécanisme de synchronisation (wait()) pour vous prémunir des états "zombies" ou "orphelins".
3. Ordonnancement : Tracez toujours l'axe du temps en listant à chaque événement (arrivée d'un processus ou fin d'une tâche) les processus présents dans la file d'attente avec leur temps restant. Si une pénalité de commutation de contexte s'applique, bloquez d'abord le temps CPU pour le système (la commutation) avant d'attribuer le temps restant à l'exécution du processus. Assurez-vous enfin que la somme des temps d'exécution et des commutations de contexte correspond bien à la date de fin globale sur votre diagramme.