Devoir Surveillé - Systèmes d'Exploitation I
Devoir Surveillé - Systèmes d'Exploitation I
Programming, Operating Systems · exam
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
Cette question valide vos connaissances sur les commandes de base d'administration système sous Linux. Voici les réponses correspondantes à chaque définition :
rmmodkillallpidofsizelsmodIl s'agit d'identifier et de corriger l'erreur factuelle dans chaque affirmation.
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).
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.
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.
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;
}
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.
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;
}
Il faut que seul le processus fils exécute le second fork().
if (fork() == 0) fork();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;
}
Il faut que seul le processus père exécute le second fork().
if (fork() > 0) fork();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;
}
Le corrigé propose de combiner les opérateurs pour cibler les bons processus.
fork() && (fork() || fork());
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.&&, il s'arrête immédiatement.||, 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;
}
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 |
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]
Le temps de séjour (Turnaround Time) se calcule par la formule : Date de fin - Date d'arrivée.
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.
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).
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.
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.
Pour réussir ce type d'épreuve (Systèmes d'Exploitation) :
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.&& (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.