Signaux & sémaphores

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 Part 1 - Programmation Réseaux - Concepts de base

  Professeur Mohamed YOUSSFI · 38:34 · 33k vues — AboutPressCopyrightContact usCreatorsAdvertiseDevelopersTermsPrivacyPolicy & SafetyHow YouTube worksTest new features · © 2024 Google LLC

• 🇫🇷 Cours programmation socket (réseau) n°6 p.1 - UDP en langage C

  Jean-Baptiste Yunès · 29:58 · 8k vues — L'API en langage C de communication par paquet.L'envoi simple. Envoi-réponse, l'exemple d'un service ECHO.Plus d'informations : http://yunes.informatique.uni

• 🇬🇧 Socket Programming Tutorial In C For Beginners | Part 1 | Eduonix

  Eduonix Learning Solutions · 40:07 · 243k vues — Learn Programming, anywhere anytime - http://bit.ly/Programming19 Sockets are the low-level endpoints used for processing information across a network. Some ...

1. Besoins de communication entre processus

On peut néanmoins créer une application multitâche et avoir besoin de synchroniser ces tâches ou d'échanger des informations entre elles. Les systèmes d'exploitation sont donc munis de mécanismes appropriés.

2. Qu'est-ce qu'un signal ?

• Les signaux sont identifiés par un numéro entier et un nom symbolique décrit dans signal.h.
• Comme pour une interruption matérielle, la réception d'un signal interrompt le traitement en cours et exécute automatiquement la fonction associée au signal (programmation événementielle).
• En langage C, l'association entre le numéro du signal et la fonction est réalisée par un appel à la fonction système signal().
• La fonction sigaction() peut être utilisée à la place de signal().

Comment réagit un processus qui reçoit un signal ?

1. Il interrompt le traitement en cours.
2. Il exécute la fonction de traitement du signal.
3. Il reprend l'exécution du traitement interrompu.

Comportement associé à la réception

3. Origine des signaux

$ kill -KILL 2400
$ kill -9 2400

4. Liste des signaux les plus fréquents

5. Envoi de signaux en C — kill()

#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);

La primitive kill permet d'émettre le signal sig (désigné par son nom symbolique ou son numéro) à :

• le processus d'identité pid, si pid > 0 ;
• tous les processus du même groupe que le processus appelant, si pid = 0 ;
• tous les processus du groupe dont le gid est la valeur absolue de pid, si pid < -1.

6. Les trois manières de répondre à un signal

1. Exécution de l'action par défaut

Cinq traitements par défaut sont possibles :

2. Ignorance du signal

3. Interception puis invocation d'une fonction (handler)

Le signal peut être rattrapé par le processus destinataire, ce qui provoque un déroutement et le lancement d'une routine spécifique de traitement (handler). Après le traitement, le processus reprend où il a été interrompu.

7. Pipeline d'un signal — vue d'ensemble

Le noyau filtre via le masque, met le signal en attente si bloqué, sinon déroute vers le handler ; puis le contexte interrompu est restauré.

8. Préparer la réception — signal()

#include <signal.h>

void (*signal(int signum, void (*handler)(int)))(int);

L'appel système signal() permet d'installer handler comme fonction de traitement lors de la réception du signal signum. Cette fonction ne pourra prendre qu'un argument de type entier : le numéro du signal qui l'aura appelée. La fonction renvoie SIG_ERR en cas d'échec.

Récupérer le nom symbolique

#include <string.h>

char *strsignal(int sig);

La fonction strsignal permet de renvoyer le nom symbolique du signal correspondant au numéro sig.

Exemple complet

#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>

/* fonction de déroutement */
void handler(int sig) {
    printf("Bien reçu %d %s\n", sig, strsignal(sig));
    if (sig == SIGINT) {
        printf("Fin volontaire\n");
        exit(1);
    }
}

void main(void) {
    signal(SIGINT,  handler); /* Ctrl-c  : signal 2  */
    signal(SIGQUIT, handler); /* Ctrl-\  : signal 3  */
    signal(SIGTSTP, handler); /* Ctrl-z  : signal 20 */
    /* SIGKILL est non déroutable */
    if (signal(SIGKILL, handler) == SIG_ERR) perror("SIGKILL");
    for (;;);
}

Constantes SIG_IGN et SIG_DFL

La fonction de traitement peut être remplacée par une des constantes suivantes :

• SIG_IGN — indique que le signal doit être ignoré.
• SIG_DFL — indique de rétablir l'action par défaut.

/* Rendre Ctrl-C (SIGINT) inopérant
   l'arrêt de ce programme doit se faire avec kill -9 pid */
#include <signal.h>

void main(void) {
    signal(SIGINT, SIG_IGN);
    for (;;);
}

9. L'appel système sigaction()

La primitive sigaction() associe un signal à un contexte de déroutement, représenté par une structure sigaction.

struct sigaction {
    void     (*sa_handler)();  /* SIG_DFL ou SIG_IGN ou ptr sur handler */
    sigset_t   sa_mask;        /* signaux supplémentaires à bloquer
                                  pendant l'exécution du gestionnaire   */
    int        sa_flags;       /* indicateurs optionnels pour modifier
                                  le comportement du signal             */
};

Exemple

#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>

void handler(int sig) {
    printf("Bien reçu %d %s\n", sig, strsignal(sig));
    if (sig == SIGINT) {
        printf("Fin volontaire\n");
        exit(1);
    }
}

void main(void) {
    struct sigaction act;
    act.sa_handler = handler;
    sigaction(SIGINT,  &act, NULL); /* Ctrl-c  : signal 2  */
    sigaction(SIGQUIT, &act, NULL); /* Ctrl-\  : signal 3  */
    sigaction(SIGTSTP, &act, NULL); /* Ctrl-z  : signal 20 */
    /* SIGKILL est non déroutable */
    if (sigaction(SIGKILL, &act, NULL) == -1) perror("SIGKILL");
    for (;;);
}

10. Sémaphores — outils de coordination

Exemple : gestion d'un stock

1. Un processus p1 lit dans un registre la valeur courante V du stock et veut la décrémenter.
2. Un autre processus p2 préempte le premier avant ; il lit la valeur courante (toujours V), la décrémente et met à jour le registre qui contient alors V-1.
3. p1 reprend son exécution et met à jour le registre en écrivant V-1, au lieu de V-2.

11. Pourquoi utiliser un sémaphore ?

Un sémaphore sert à la synchronisation entre les processus. Un sémaphore utilisé pour l'exclusion mutuelle (garantir qu'un seul processus accède à un moment donné à une variable partagée) utilisera 2 primitives :

Remarque : aux sémaphores sont associés des droits d'accès de type Unix.

12. Le mécanisme des sémaphores

Un sémaphore est un objet composé :

• une variable (la valeur du sémaphore) ;
• une file d'attente (les processus bloqués attendant la ressource).

Primitives associées

Algorithmes des primitives P et V

/* P(sémaphore) */
si (valeur[sémaphore] > 0) alors
    valeur[sémaphore] = valeur[sémaphore] - 1
sinon
    si (valeur[sémaphore] == 0)
        étatProcessus = Bloqué
        mettre processus en file d'attente
    fsi
finSi
invoquer l'ordonnanceur

/* V(sémaphore) */
valeur[sémaphore] = valeur[sémaphore] + 1
si (valeur[sémaphore] > 0) alors
    extraire processus de file d'attente
    étatProcessus = Prêt
finSi
invoquer l'ordonnanceur

13. Les différents types de sémaphores

14. Sémaphores POSIX.4

Les sémaphores POSIX.4 existent sous deux formes :

Sémaphores nommés — création

sem_t *sem_open(const char *sem_name,
                int oflags,
                mode_t creation_mode,
                unsigned int initial_val);

• sem_name : nom du sémaphore. Il est recommandé de fournir un nom « compatible » avec un nom de fichier, commençant par un / (barre oblique) et pouvant contenir jusqu'à 255 caractères (ex. "/semaphore1").
• oflags :
  • O_CREAT pour créer un sémaphore ;
  • O_CREAT | O_EXCL erreur si existe déjà.
• initial_val : valeur initiale.
• creation_mode : permissions (mode de création) du sémaphore.

Ouverture d'un sémaphore existant

sem_t *sem_open(const char *sem_name, int oflags);

• Accède à un sémaphore déjà créé.
• oflags :
  • O_CREAT : crée un sémaphore nommé s'il n'existe pas déjà ;
  • O_EXCL : si O_CREAT est spécifié et que le sémaphore existe déjà, l'appel échoue ;
  • O_RDWR : ouvre le sémaphore en mode lecture/écriture (habituellement non utilisé pour les sémaphores).

Fermeture et suppression

int sem_close(sem_t *sem_id);

Ferme le sémaphore. Retour : renvoie 0, en cas d'erreur -1 + errno.

int sem_unlink(const char *sem_name);

Supprime le sémaphore. Permet de supprimer un sémaphore nommé du système, précédemment créé avec sem_open.

Retour : renvoie 0, en cas d'erreur -1 + errno.

Sémaphores anonymes

Sont des sémaphores qui n'ont pas de nom associé dans le système de fichiers. Contrairement aux sémaphores nommés, ils sont basés sur la mémoire.

int sem_init(sem_t *sem_location,
             int    pshared,
             unsigned int initial_value);

• sem_location : zone mémoire, éventuellement en zone partagée.
• pshared : visibilité du sémaphore :
  • pshared == 0 → local au processus courant ;
  • pshared != 0 → partagé entre plusieurs processus.

Retour : renvoie 0, en cas d'erreur -1 + errno.

int sem_destroy(sem_t *sem_location);

Détruit le sémaphore. Retour : renvoie 0, en cas d'erreur -1 + errno.

Opérations P() et V()

/* P() — verrouille (décrémente) */
int sem_wait(sem_t *sem_id);

/* V() — déverrouille (incrémente) */
int sem_post(sem_t *sem_id);

Tableau récapitulatif POSIX.4

15. Application — producteur / consommateur

Un classique : un buffer circulaire de taille N partagé entre un producteur (qui dépose) et un consommateur (qui retire). Trois sémaphores coordonnent l'accès :

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

#define N 8

int       buffer[N];
int       in = 0, out = 0;
sem_t     empty, full, mutex;

void *producteur(void *arg) {
    int item = 0;
    for (;;) {
        item++;                       /* produire un item */
        sem_wait(&empty);             /* P(empty) — attend une case vide */
        sem_wait(&mutex);             /* P(mutex) — entrée section critique */
        buffer[in] = item;
        in = (in + 1) % N;
        sem_post(&mutex);             /* V(mutex) — sortie SC */
        sem_post(&full);              /* V(full)  — une case pleine de plus */
    }
    return NULL;
}

void *consommateur(void *arg) {
    int item;
    for (;;) {
        sem_wait(&full);              /* P(full)  — attend une case pleine */
        sem_wait(&mutex);             /* P(mutex) */
        item = buffer[out];
        out = (out + 1) % N;
        sem_post(&mutex);             /* V(mutex) */
        sem_post(&empty);             /* V(empty) — libère une case vide */
        printf("consommé %d\n", item);
    }
    return NULL;
}

int main(void) {
    pthread_t tp, tc;
    sem_init(&empty, 0, N);           /* N cases vides au départ */
    sem_init(&full,  0, 0);           /* 0 case pleine          */
    sem_init(&mutex, 0, 1);           /* mutex binaire          */

    pthread_create(&tp, NULL, producteur,   NULL);
    pthread_create(&tc, NULL, consommateur, NULL);
    pthread_join(tp, NULL);
    pthread_join(tc, NULL);

    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);
    return 0;
}

16. Réviser

❓ Q/R

🃏 Flashcards

✎ Quiz éclair

📌 À retenir