🚀 Révision Systèmes d'Exploitation

💡 Solution Question 1 :

Étape 1 : Construction du graphe

Allocations (Ressource → Processus):
R → A,  U → D,  T → E,  W → F,  V → G

Demandes (Processus → Ressource):
A → S,  B → T,  C → S,  D → S,T,  E → V,  F → S,  G → U
                        

Étape 2 : Détection de cycles

Cycle trouvé :

Conclusion :

DEADLOCK DÉTECTÉ

Processus en deadlock : D, E, G

💡 Solution Question 2 :

Étape 1 : Analyse des données

       R1  R2  R3
P1  [  1   0   0 ]
P2  [  0   2   0 ]
P3  [  1   0   0 ]
P4  [  0   0   2 ]
                        

       R1  R2  R3
P1  [  0   1   0 ]
P2  [  1   0   1 ]
P3  [  0   1   0 ]
P4  [  1   0   0 ]
                        

Étape 2 : Construction du graphe

Allocations:
R1 → P1,  R2 → P2 (×2),  R1 → P3,  R3 → P4 (×2)

Demandes:
P1 → R2,  P2 → R1,R3,  P3 → R2,  P4 → R1
                        

Étape 3 : Détection de cycles

Conclusion :

DEADLOCK DÉTECTÉ

Processus en deadlock : P1, P2, P3

(P4 n'est pas en deadlock car il ne fait pas partie d'un cycle)

💡 Solution Complète :

📊 Étape 1 : Construction des matrices

E = [4, 2, 3, 1]  (R1, R2, R3, R4)

       R1  R2  R3  R4
P1  [  0   0   1   0 ]
P2  [  2   0   0   1 ]
P3  [  0   1   2   0 ]
                        

       R1  R2  R3  R4
P1  [  2   0   0   1 ]
P2  [  1   0   1   0 ]
P3  [  2   1   0   0 ]
                        

A = E - ΣC = [4-2, 2-1, 3-3, 1-1] = [2, 1, 0, 0]

❓ Question 1 : L'état courant est-il sûr ?

❓ Question 2 : Peut-on accorder 2×R1 à P3 ?

C[3] devient [2, 1, 2, 0] (au lieu de [0, 1, 2, 0])

A = E - ΣC = [4-4, 2-1, 3-3, 1-1] = [0, 1, 0, 0]

❓ Question 3 : Peut-on accorder 1×R1 à P2 ?

C[2] devient [3, 0, 0, 1] (au lieu de [2, 0, 0, 1])

A = [4-3, 2-1, 3-3, 1-1] = [1, 1, 0, 0]

💡 Solution Complète :

Programme complet avec processus père et fils :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <unistd.h>

// Structure du message
struct msgbuf {
    long mtype;       // Type du message (doit être > 0)
    char mtext[100];  // Contenu du message
};

int main() {
    int msgid;
    struct msgbuf message;
    
    // Créer la file de messages avec clé 17
    msgid = msgget(17, IPC_CREAT | 0666);
    if (msgid == -1) {
        perror("msgget failed");
        exit(1);
    }
    
    printf("File de messages créée avec ID: %d\n", msgid);
    
    pid_t pid = fork();
    
    if (pid == 0) {
        // ========== PROCESSUS FILS (ÉMETTEUR) ==========
        printf("[FILS] Préparation du message...\n");
        
        message.mtype = 1;  // Type de message = 1
        strcpy(message.mtext, "Bonjour du processus fils!");
        
        // Envoyer le message
        if (msgsnd(msgid, &message, sizeof(message.mtext), 0) == -1) {
            perror("[FILS] Erreur lors de l'envoi");
            exit(1);
        }
        
        printf("[FILS] Message envoyé: %s\n", message.mtext);
        exit(0);
        
    } else if (pid > 0) {
        // ========== PROCESSUS PÈRE (RÉCEPTEUR) ==========
        printf("[PÈRE] En attente d'un message...\n");
        
        // Recevoir le message de type 1
        if (msgrcv(msgid, &message, sizeof(message.mtext), 1, 0) == -1) {
            perror("[PÈRE] Erreur lors de la réception");
            exit(1);
        }
        
        printf("[PÈRE] Message reçu: %s\n", message.mtext);
        
        // Attendre que le fils se termine
        wait(NULL);
        
        // Supprimer la file de messages
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("[PÈRE] Erreur lors de la suppression");
            exit(1);
        }
        
        printf("[PÈRE] File de messages supprimée\n");
        
    } else {
        perror("fork failed");
        exit(1);
    }
    
    return 0;
}

/* COMPILATION ET EXÉCUTION:
   gcc -o msgqueue msgqueue.c
   ./msgqueue
   
   RÉSULTAT ATTENDU:
   File de messages créée avec ID: 12345
   [PÈRE] En attente d'un message...
   [FILS] Préparation du message...
   [FILS] Message envoyé: Bonjour du processus fils!
   [PÈRE] Message reçu: Bonjour du processus fils!
   [PÈRE] File de messages supprimée
*/

Variante : Communication bidirectionnelle

// Le fils envoie un message de type 1
// Le père envoie une réponse de type 2
// Le fils reçoit la réponse

// Dans le fils:
msg.mtype = 1;
strcpy(msg.mtext, "Question du fils");
msgsnd(msgid, &msg, sizeof(msg.mtext), 0);

// Attendre la réponse (type 2)
msgrcv(msgid, &msg, sizeof(msg.mtext), 2, 0);
printf("Réponse reçue: %s\n", msg.mtext);

// Dans le père:
msgrcv(msgid, &msg, sizeof(msg.mtext), 1, 0);
printf("Question reçue: %s\n", msg.mtext);

// Envoyer la réponse
msg.mtype = 2;
strcpy(msg.mtext, "Réponse du père");
msgsnd(msgid, &msg, sizeof(msg.mtext), 0);

💡 Solution Complète Commentée :

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

// Variable globale pour la synchronisation
volatile int can_print = 0;

// Gestionnaire de signal
void signal_handler(int sig) {
    can_print = 1;  // Autoriser l'impression
}

int main() {
    pid_t pid1, pid2, pid3;
    
    // Enregistrer le gestionnaire pour SIGUSR1 et SIGUSR2
    signal(SIGUSR1, signal_handler);
    signal(SIGUSR2, signal_handler);
    
    // Créer le premier fils (affiche 1-30)
    pid1 = fork();
    if (pid1 == 0) {
        // ========== FILS 1: 1-30 ==========
        for (int i = 1; i <= 30; i++) {
            // Attendre le signal du père
            while (!can_print) {
                pause();  // Bloquer jusqu'au signal
            }
            
            printf("%d ", i);
            fflush(stdout);  // Forcer l'affichage immédiat
            
            can_print = 0;  // Réinitialiser
            
            // Signaler au père que j'ai fini
            kill(getppid(), SIGUSR1);
        }
        exit(0);
    }
    
    // Créer le deuxième fils (affiche 31-60)
    pid2 = fork();
    if (pid2 == 0) {
        // ========== FILS 2: 31-60 ==========
        for (int i = 31; i <= 60; i++) {
            while (!can_print) {
                pause();
            }
            
            printf("%d ", i);
            fflush(stdout);
            
            can_print = 0;
            kill(getppid(), SIGUSR1);
        }
        exit(0);
    }
    
    // Créer le troisième fils (affiche 61-90)
    pid3 = fork();
    if (pid3 == 0) {
        // ========== FILS 3: 61-90 ==========
        for (int i = 61; i <= 90; i++) {
            while (!can_print) {
                pause();
            }
            
            printf("%d ", i);
            fflush(stdout);
            
            can_print = 0;
            kill(getppid(), SIGUSR1);
        }
        exit(0);
    }
    
    // ========== PROCESSUS PÈRE (Orchestrateur) ==========
    sleep(1);  // Laisser les fils s'initialiser
    
    // Boucle de synchronisation
    for (int i = 1; i <= 90; i++) {
        // Déterminer quel fils doit afficher
        if (i <= 30) {
            kill(pid1, SIGUSR1);  // Réveiller fils 1
        } else if (i <= 60) {
            kill(pid2, SIGUSR1);  // Réveiller fils 2
        } else {
            kill(pid3, SIGUSR1);  // Réveiller fils 3
        }
        
        // Attendre la confirmation du fils
        can_print = 0;
        while (!can_print) {
            pause();
        }
    }
    
    printf("\n");
    
    // Attendre que tous les fils se terminent
    wait(NULL);
    wait(NULL);
    wait(NULL);
    
    printf("Affichage terminé !\n");
    
    return 0;
}

/* COMPILATION:
   gcc -o sync_signals sync_signals.c
   
   EXÉCUTION:
   ./sync_signals
   
   RÉSULTAT ATTENDU:
   1 2 3 4 5 ... 28 29 30 31 32 ... 88 89 90
   Affichage terminé !
*/

Version simplifiée (un seul signal) :

// Variante plus simple avec une seule variable de contrôle
// et communication directe père-fils

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

volatile int turn = 0;  // 0=fils1, 1=fils2, 2=fils3

void handler(int sig) { /* ne fait rien, juste réveille */ }

int main() {
    signal(SIGUSR1, handler);
    
    pid_t p1 = fork();
    if (p1 == 0) {
        // Fils 1
        for (int i = 1; i <= 30; i++) {
            while (turn != 0) pause();
            printf("%d ", i);
            turn = (i == 30) ? 1 : 0;
            kill(getppid(), SIGUSR1);
        }
        exit(0);
    }
    
    pid_t p2 = fork();
    if (p2 == 0) {
        // Fils 2
        for (int i = 31; i <= 60; i++) {
            while (turn != 1) pause();
            printf("%d ", i);
            turn = (i == 60) ? 2 : 1;
            kill(getppid(), SIGUSR1);
        }
        exit(0);
    }
    
    pid_t p3 = fork();
    if (p3 == 0) {
        // Fils 3
        for (int i = 61; i <= 90; i++) {
            while (turn != 2) pause();
            printf("%d ", i);
            if (i < 90) turn = 2;
            kill(getppid(), SIGUSR1);
        }
        exit(0);
    }
    
    // Père: démarrer la séquence
    turn = 0;
    kill(p1, SIGUSR1);
    
    // Attendre la fin
    wait(NULL); wait(NULL); wait(NULL);
    printf("\n");
    
    return 0;
}