TP n°6 : Utilisation des IPC Unix

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 KEY                  0x00012347

typedef struct {
    int value;
} COUNTER;

int main(void) {
    COUNTER *c;
    int memid;

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

    return (EXIT_SUCCESS); 
}

Partager un tampon en mémoire

Nous allons utiliser la mémoire partagée IPC pour inplanter un petit exemple de producteur / consommateur. La zone partagée pourrait être du type suivant :

struct {
    int the_char;        /* '\0' si vide           */
    int end;             /* signal de fin d'entrée */
} ...

Le consommateur peut consommer si, et seulement si (the_char != 0). Le producteur peut produire ssi (the_char == 0). Je vous propose de suivre les étapes ci-dessous :

  1. Créez un programme C pour le producteur (en partant de l'exemple précédent).
  2. Créez un programme C pour le consommateur (en partant de l'exemple précédent).
  3. Prévoyez un fichier tampon.h qui contient la définition du tampon.
  4. Le producteur lit des caractères au clavier et les place dans le tampon. Le consommateur les récupère et les affiche. Ces deux acteurs appliquent la méthode de l'attente active pour se synchroniser.
  5. Faites en sorte que la zone partagée soit créée et initialisée par le producteur. Si le consommateur est plus rapide, il doit attendre que la zone partagée soit disponible.
  6. Prenez soin de ralentir le producteur et le consommateur pour tester tous les cas de figure.
  7. La fin de la lecture au clavier est indiquée au consommateur par la mise à un du drapeau end. Ce dernier a la charge de supprimer la ressource partagée avant de se terminer.
  8. Consultez la carte mémoire de ces processus.

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> 

/* Partie commune aux clients et au serveur */

#define REQUEST_KEY         0x00012345
#define RESPONSE_KEY        0x00012346 
#define LG_MAX              512

typedef struct { 
    long mtype;
    char mtext[ LG_MAX ]; 
} MESSAGE; 

/* Fin de la partie commune aux clients et au serveur */


int main(void) { 
    int requests, responses;
    MESSAGE msg;
    int res; 

    /* se connecter aux IPC de requête et de réponse */
    requests = msgget(REQUEST_KEY, 0700 | IPC_CREAT); 
    if (requests == -1) { perror("msgget"); return (EXIT_FAILURE); } 

    responses = msgget(RESPONSE_KEY, 0700 | IPC_CREAT); 
    if (responses == -1) { perror("msgget"); return (EXIT_FAILURE); }
    
    /* demander un message à l'utilisateur */
    printf("Enter message : ");
    fgets(msg.mtext, LG_MAX, stdin);

    /* envoyer la requête signée par son numéro de processus */
    msg.mtype = getpid();
    res = msgsnd(requests, & msg, strlen(msg.mtext) + 1, 0); 
    if (res == -1) { perror("msgsnd"); return (EXIT_FAILURE); } 

    /* récupérer sa réponse signée par son numéro de processus */
    res = msgrcv(responses, & msg, LG_MAX, getpid(), 0); 
    if (res == -1) { perror("msgrcv"); return (EXIT_FAILURE); } 

    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> 

/* Partie commune aux clients et au serveur */

#define REQUEST_KEY         0x00012345
#define RESPONSE_KEY        0x00012346 
#define LG_MAX              512

typedef struct { 
    long mtype;
    char mtext[ LG_MAX ]; 
} MESSAGE; 

/* Fin de la partie commune aux clients et au serveur */


int main(void) { 
    int requests, responses;
    int counter = 0;
    MESSAGE msg;
    int res, i; 

    /* Se connecter aux IPC de requête et de réponse */
    requests = msgget(REQUEST_KEY, 0700 | IPC_CREAT); 
    if (requests == -1) { perror("msgget"); return (EXIT_FAILURE); } 

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

    while (1) {
        printf("Waiting a request (%d processed)...\n", counter);
        res = msgrcv(requests, & msg, LG_MAX, 0, 0);
        if (res == -1) { perror("msgrcv"); return (EXIT_FAILURE); } 

        /* Traiter la requête (passage en majuscule) */
        for(i=0; i < strlen(msg.mtext); i++) {
            msg.mtext[i] = toupper(msg.mtext[i]);
        }

        /* Envoyer la réponse (signée par le client) */
        res = msgsnd(responses, & msg, strlen(msg.mtext) + 1, 0); 
        if (res == -1) { perror("msgsnd"); return (EXIT_FAILURE); }
        
        counter++;
    }

    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.

Travail à faire : Refaites le même exercice (producteur / consommateur) mais en remplaçant la mémoire partagée par un envoi de message entre le producteur et le consommateur.

Montage de fichiers en mémoire

La fonction mmap permet de projeter un fichier en mémoire (plus de précisions avec man mmap). Voila un petit exemple :

#include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>

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


void create_file(int size) {
    FILE *f = fopen("data", "w");
    int i;

    for(i=1; i<size; i++) {
        fputc('A', f);
    }
    fputc('\n', f);
    fclose(f);
}


int main() {
    int file;
    char* zone;
    int size = 60;
    int i;

    /* création du fichier pour l'exemple */
    create_file(size);

    /* ouverture en utilisant les fonctions UNIX */
    file = open("data", O_RDWR, 0700);
    if (file < 0) {
        perror("open");
        return (EXIT_FAILURE);
    }

    /* montage en mémoire */
    zone = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, file, 0);
    if (zone == NULL) {
        perror("mmap");
        return (EXIT_FAILURE);
    }
    
    /* utilisation */
    printf("Affichage du contenu\n");
    for(i=0; (i<size); i++) {
        putchar(zone[i]);
    }

    return (EXIT_SUCCESS);
}

Travail à faire :