shmat()

La fonction shmat() attache le segment de mémoire partagée System V identifié par shmid au segment de données du processus appelant. L'adresse d'attachement est indiquée par shmaddr avec les critères suivants :

• Si shmaddr vaut NULL, le système choisit une adresse (non utilisée) alignée sur la page convenant pour attacher le segment.
• Si shmaddr n'est pas NULL et si SHM_RND est indiqué dans shmflg, l'attachement a lieu à l'adresse égale à shmaddr arrondie au multiple inférieur de SHMLBA.
• Sinon, shmaddr doit être alignée sur une frontière de page, où l'attachement a lieu.

En plus de SHM_RND, les attributs suivants peuvent être indiqués dans le paramètre de masque shmflg :

SHM_EXEC (spécifique à Linux, depuis Linux 2.6.9)

Autoriser l'exécution du contenu du segment. L'appelant doit disposer du droit d'exécution sur le segment.

SHM_RDONLY

Attacher le segment en lecture seule. Le processus doit disposer de la permission de lecture dessus. Si cet attribut n'est pas indiqué, le segment est attaché en lecture et écriture, et le processus doit disposer des deux permissions d'accès. Il n'y a pas de notion d'écriture seule pour les segments de mémoire partagée.

SHM_REMAP (spécifique à Linux)

Cet attribut indique que la projection du segment doit remplacer une projection précédente dans l'intervalle commençant en shmaddr et s'étendant sur la taille du segment. Normalement une erreur EINVAL devrait se produire si une projection existe déjà dans l'intervalle indiqué. Dans ce cas, shmaddr ne doit pas être NULL.

La valeur brk(2) du processus appelant n'est pas altérée par l'attachement. Le segment est automatiquement détaché quand le processus se termine. Le même segment peut être attaché à la fois en lecture seule et en lecture/écriture. Il peut également être attaché en plusieurs endroits de l'espace d'adressage du processus.

Quand shmat() réussit, les membres de la structure shmid_ds associée au segment de mémoire partagée (consultez shmctl(2)) sont mis à jour ainsi :

• shm_atime correspond à l'heure actuelle.
• shm_lpid contient le PID de l'appelant.
• shm_nattch est incrémenté de 1.

shmdt()

La fonction shmdt() détache le segment de mémoire partagée situé à l'adresse indiquée par shmaddr. Le segment doit être effectivement attaché, et l'adresse shmaddr doit être celle renvoyée précédemment par l'appel shmat().

Quand shmdt() réussit, les membres de la structure shmid_ds associée au segment de mémoire partagée sont mis à jour ainsi par le système :

• shm_dtime correspond à l'heure actuelle.
• shm_lpid contient le PID de l'appelant.
• shm_nattch est décrémenté de 1. S'il devient nul et si le segment est marqué pour destruction, il est effectivement détruit.

Source du programme : svshm_string.h

Le fichier d'en-tête suivant est inclus dans les programmes « reader » et « writer » :

/* svshm_string.h
   Sous la GNU General Public License v2 ou supérieure.
*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                        } while (0)
union semun {                   /* Utilisé dans les appels semctl() */
    int                 val;
    struct semid_ds *   buf;
    unsigned short *    array;
#if defined(__linux__)
    struct seminfo *    __buf;
#endif
};
#define MEM_SIZE 4096

Source du programme : svshm_string_read.c

Le programme « reader » crée un segment de mémoire partagée et un ensemble de sémaphores contenant un sémaphore. Il attache ensuite l'objet en mémoire partagée à son espace d'adressage et initialise la valeur du sémaphore à 1. Enfin, il attend que la valeur du sémaphore devienne 0, après quoi il affiche la chaîne qui a été copiée dans le segment de mémoire partagée par « writer ».

/* svshm_string_read.c
   Sous la GNU General Public License v2 ou supérieure.
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include "svshm_string.h"
int
main(void)
{
    int            semid, shmid;
    char           *addr;
    union semun    arg, dummy;
    struct sembuf  sop;
    /* Créer la mémoire partagée et le jeu de sémaphores contenant
       un sémaphore. */
    shmid = shmget(IPC_PRIVATE, MEM_SIZE, IPC_CREAT | 0600);
    if (shmid == -1)
        errExit("shmget");
    semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
    if (semid == -1)
        errExit("semget");
    /* Attacher la mémoire partagée à notre espace d'adressage. */
    addr = shmat(shmid, NULL, SHM_RDONLY);
    if (addr == (void *) -1)
        errExit("shmat");
    /* Initialiser le sémaphore 0 du jeu à la valeur 1. */
    arg.val = 1;
    if (semctl(semid, 0, SETVAL, arg) == -1)
        errExit("semctl");
    printf("shmid = %d; semid = %d\n", shmid, semid);
    /* Attendre que la valeur du sémaphore devienne 0. */
    sop.sem_num = 0;
    sop.sem_op = 0;
    sop.sem_flg = 0;
    if (semop(semid, &sop, 1) == -1)
        errExit("semop");
    /* Afficher la chaîne à partir de la mémoire partagée. */
    printf("%s\n", addr);
    /* Supprimer la mémoire partagée et le jeu de sémaphores. */
    if (shmctl(shmid, IPC_RMID, NULL) == -1)
        errExit("shmctl");
    if (semctl(semid, 0, IPC_RMID, dummy) == -1)
        errExit("semctl");
    exit(EXIT_SUCCESS);
}

Source du programme : svshm_string_write.c

Le programme « writer » prend trois paramètres en ligne de commande : les identifiants du segment de mémoire partagée et du jeu de sémaphore créés par « reader » et une chaîne. Il attache le segment de mémoire partagée à son espace d'adressage, puis décrémente la valeur du sémaphore à 0 pour informer « reader » qu'il peut examiner le contenu de la mémoire partagée.

/* svshm_string_write.c
   Sous la GNU General Public License v2 ou supérieure.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include "svshm_string.h"
int
main(int argc, char *argv[])
{
    int            semid, shmid;
    char           *addr;
    size_t         len;
    struct sembuf  sop;
    if (argc != 4) {
        fprintf(stderr, "Utilisation : %s shmid semid string\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    len = strlen(argv[3]) + 1;  /* +1 pour inclure le '\0' final */
    if (len > MEM_SIZE) {
        fprintf(stderr, "La chaîne est trop longue!\n");
        exit(EXIT_FAILURE);
    }
    /* Obtenir les identifiants de l'objet depuis la ligne de commande. */
    shmid = atoi(argv[1]);
    semid = atoi(argv[2]);
    /* Attacher la mémoire partagée dans notre espace d'adressage et copier
       la chaîne (et notamment l'octet NULL final) dans la mémoire. */
    addr = shmat(shmid, NULL, 0);
    if (addr == (void *) -1)
        errExit("shmat");
    memcpy(addr, argv[3], len);
    /* Décrémenter le sémaphore à 0 */
    sop.sem_num = 0;
    sop.sem_op = -1;
    sop.sem_flg = 0;
    if (semop(semid, &sop, 1) == -1)
        errExit("semop");
    exit(EXIT_SUCCESS);
}