Les IPC system V (Inter Processus Communication)

Présentation

Les trois mécanismes ainsi désignés ont un certain nombre de propriétés en commun :

Les commandes ipcs et ipcrm permettent respectivement l'affichage des IPC actifs et la destruction de l'un des IPC (si vous avez les droits nécessaires). Bien entendu, une aide plus complète peut être obtenue sur chaque fonction en utilisant le manuel UNIX.

Une dernière petite remarque : si vous avez du mal à trouver une (ou plusieurs) clés d'identification, vous pouvez vous retourner vers la fonction ftok qui construit une clé à partir d'un nom de fichier (par exemple votre "home directory").

Mémoires partagées

Les principales fonctions

Cette méthode évite de faire des copies de/vers l'espace système pour transférer de l'information. En effet, plusieurs processus voient la même zone mémoire dans leurs espaces virtuels respectifs et cette mémoire leur est accessible comme de la mémoire ordinaire: c'est donc à eux de gérer les problèmes des accès concurrents. Cette méthode est particulièrement recommandée dans la communication de gros volumes de données (images par exemple).

Note : La mémoire reste allouée même lorsque tous les processus qui y accèdent se terminent : (le même problème que pour les autres IPC, la mémoire partagée doit donc être libérée explicitement).

Les primitives pour gérer la mémoire partagée sont :

shmid = shmget(key,size,flags)
Permet la création d'une zone mémoire partagée, ou l'accès à une zone déjà existante. Les drapeaux permettent de spécifier les modalités d'ouverture, et notamment les droits de lecture et d'écriture.
adr = shmat(shmid,adr,flags)
Permet d'attacher la mémoire référencée à l'adresse virtuelle spécifiée en argument. Le résultat est l'adresse à laquelle le système a effectivement réalisé l'attachement (elle peut être différente de l'argument).
int shmdt(adr)
Détachement d'une zone partagée de l'espace virtuel du processus.
int shmctl(shmid,command,result)
Permet de consulter ou de modifier les caractéristiques d'un segment mémoire ainsi que de le supprimer. Il est notamment possible de demander son verrouillage en mémoire centrale.

Un exemple

Ce petit exemple va simplement utiliser (ou créer la première fois) une zone partagée pour l'afficher et la modifier. Ce programme doit être utilisé plusieurs fois pour faire apparaître l'unicité de cette zone mémoire. Bien entendu, les commandes ipcs et ipcrm sont utilisables.

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

#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/shm.h>

#define CLEF                  0x00012347

typedef struct {
    int valeur;
} COMPTEUR;

int main(void) {
    COMPTEUR *zone;
    int memid;

    /* création ou lien avec la zone partagée */
    memid = shmget(CLEF, sizeof(COMPTEUR), 0700 | IPC_CREAT); 
    if (memid == -1) { perror("shmget"); return (EXIT_FAILURE); }
    
    /* montage en mémoire */
    zone = shmat(memid, NULL, 0);
    printf("compteur = %d\n", zone->valeur++ );

    return (EXIT_SUCCESS); 
}

Envoi et réception de messages

Les principales fonctions

Elle se fait par l'utilisation de quatre primitives permettant d'opérer sur une des queues de message :

msgid = msgget(key,flags)
Pour la création ou l'accès à une queue de message de nom key. Cette fonction renvoie un entier comme référence, que nous appellerons msgid.
int msgsnd(msgid,msgbuf,size,flags)
Écriture de messages. Elle se fait par copie vers une zone de données du système. Pour envoyer ou recevoir un message, le processus appelant alloue une structure comme celle-ci :
struct msgbuf {
   long  mtype;    /* type de message ( > 0 ) */
   char  mtext[1]; /* contenu du message      */
};
avec une table mtext de taille size, valeur entière non-négative. Le membre mtype doit avoir une valeur strictement positive qui puisse être utilisée par le processus lecteur pour la sélection de messages (voir plus bas).
int msgrcv(msgid,msgbuf,maxsize,type,flags)
Lecture de messages. Elle se fait par copie depuis une zone de données du système. Si le type est 0, le premier message de la queue est renvoyé, s'il est positif, le premier message de même type est renvoyé.
int msgctl(msgid,command,buffer)
Permet de consulter, modifier ou supprimer une queue de messages.

Note : Une file de messages, même privée, doit être détruite explicitement. Elle n'est pas supprimée lors de la mort du processus créateur.

Un exemple

Dans cet exemple, chaque client met son numéro de processus (fonction getpid) dans le champ type des messages de requête ce qui permet au serveur de l'identifier. Le serveur copie ce champ dans la réponse, ce qui permet au client de récupérer dans la queue des réponses les seuls messages qui le concernent.

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

#include <unistd.h> 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/msg.h> 

#define CLEF_REQUETES         0x00012345
#define CLEF_REPONSES         0x00012346 
#define LG_MAX                512 

struct msgform { 
    long mtype; 
    char mtext[ LG_MAX ]; 
    } 
    msg; 

int main(void) { 
    int res; 
    int frequete, freponse; 

    frequete = msgget(CLEF_REQUETES, 0700 | IPC_CREAT); 
    if (frequete == -1) { perror("msgget"); return (EXIT_FAILURE); } 

    freponse = msgget(CLEF_REPONSES, 0700 | IPC_CREAT); 
    if (freponse == -1) { perror("msgget"); return (EXIT_FAILURE); } 

    msg.mtype = getpid(); 
    strcpy(msg.mtext, "Hello"); 
    res = msgsnd(frequete, & msg, strlen(msg.mtext) + 1, 0); 
    if (res == -1) { perror("msgsnd"); exit(0); } 

    res = msgrcv(freponse, & msg, LG_MAX, getpid(), 0); 
    if (res == -1) { perror("msgrcv"); exit(0); } 

    printf("result : %s\n", msg.mtext); 
    return (EXIT_SUCCESS); 
    }

Et voilà le serveur :

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

#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/msg.h> 

#define CLEF_REQUETES         0x00012345
#define CLEF_REPONSES         0x00012346 
#define LG_MAX                512 

struct msgform { 
    long mtype; 
    char mtext[ LG_MAX ]; 
    } 
    msg; 

int main(void) { 
    int res, i; 
    int frequete, freponse; 

    frequete = msgget(CLEF_REQUETES, 0700 | IPC_CREAT); 
    if (frequete == -1) { perror("msgget"); return (EXIT_FAILURE); } 

    freponse = msgget(CLEF_REPONSES, 0700 | IPC_CREAT); 
    if (freponse == -1) { perror("msgget"); return (EXIT_FAILURE); } 

    printf("Waiting a request...\n");
    res = msgrcv(frequete, & msg, LG_MAX, 0, 0); 
    if (res == -1) { perror("msgrcv"); exit(0); } 

    for(i=0; i < strlen(msg.mtext); i++) 
        msg.mtext[i] = toupper(msg.mtext[i]); 
    res = msgsnd(freponse, & msg, strlen(msg.mtext) + 1, 0); 
    if (res == -1) { perror("msgsnd"); exit(0); } 

    return (EXIT_SUCCESS); 
    }

Attention : les structures partagées ne sont jamais détruites automatiquement. Après avoir testé cet exemple, vous pouvez le vérifier en utilisant la commande ipcs qui liste les ressources partagées actives. Vous pouvez également faire le ménage avec ipcrm.

Les sémaphores

Les primitives IPC pour les sémaphores sont une généralisation des sémaphores de Dijkstra pour la gestion des accès concurrents à une ressource. Ces primitives permettent de réaliser de manière atomique un ensemble d'opérations sur un ensemble de sémaphores. Cette extension permet d'éviter les verrous mortels : tous les sémaphores désignés sont modifiés ou aucun.

Chaque ensemble de sémaphores est repéré par une clef qui représente un tableau de sémaphores. Un sémaphore, en système V, est constitué de :

Primitives pour la manipulation des sémaphores

semid = semget(key,n,flags)
Permet d'allouer une entrée pour un tableau de n sémaphores ou d'accéder à une entrée existante. Chaque entrée indique les droits, le nombre de sémaphores, la datation des dernières opérations. A la création, tous les sémaphores sont initialises à zéro.
int semop(semid,oplist,nbop)
permet de modifier les sémaphores indiqués dans oplist qui est un tableau de nbop éléments, chaque élément étant formé d'un triplet : < index du sémaphore, opération, drapeaux >. opération est définie par une valeur entière interprétée comme suit :
  • Supérieure à zéro : La valeur du sémaphore est augmentée de la valeur correspondante. Tous les processus en attente d'une augmentation du sémaphores sont réveillés.
  • Egale à zéro : Teste si le sémaphore a la valeur 0. Si ce n'est pas le cas, le processus est mis en attente de la mise à zéro du sémaphore.
  • Inférieur à zéro : La valeur (absolue) est retranchée du sémaphore. Si le résultat est nul, tous les processus en attente de cet événement sont réveillés. Si le résultat est négatif, le processus est mis en attente d'une augmentation du sémaphore.
Note : Lorsqu'un processus est mis en attente d'un événement, tous les sémaphores qui ont été modifiés par semop sont restaurés afin de garantir l'atomicité.
int semctl(scmid,semnum,command,arg)
Permet de consulter, initialiser ou supprimer un tableau de sémaphores.