shmat()¶

shmat() blendet das durch shmid bezeichnete gemeinsame System-V-Speichersegment in den Adressraum des aufrufenden Prozesses ein. Die Adresse der Einblendung wird durch shmaddr nach einem der folgenden Kriterien bestimmt:

• Falls shmaddr NULL ist, wählt das System eine geeignete (freie), an einer Speicherseite ausgerichtete Adresse, um das Segment einzublenden.
• Wenn shmaddr nicht NULL ist und SHM_RND in shmflg angegeben wurde, wird die Adresse durch Abrundung von shmaddr bis auf ein Vielfaches von SHMLBA bestimmt.
• Andernfalls muss shmaddr eine an einer Speicherseite ausgerichtete Adresse sein, an welcher das Einblenden beginnt.

Zusätzlich zu SHM_RND dürfen die folgenden Schalter im Bitmask-Argument von shmflg angegeben werden:

SHM_EXEC (Linux-spezifisch; seit Linux 2.6.9)

ermöglicht, dass der Inhalt des Segments ausgeführt wird. Der Aufrufende muss auf dem Segment Ausführungsrechte besitzen.

SHM_RDONLY

blendet das Segment mit Lesezugriff ein. Der Prozess muss die Berechtigung für Lesezugriffe auf das Segment besitzen. Falls dieser Schalter nicht angegeben ist, wird das Segment mit Lese- und Schreibzugriff eingeblendet und der Prozess muss die Berechtigung für Lese- und Schreibzugriffe auf das Segment besitzen. Ein gemeinsames Speichersegment mit reinem Schreibzugriff ist nicht vorgesehen.

SHM_REMAP (Linux-spezifisch)

Dieser Schalter gibt an, dass das Abbilden des Segments jedes existierende Abbilden im Bereich von shmaddr bis zur Größe des Segments ersetzen soll. (Falls bereits eine Abbildung in diesem Adressbereich existiert, würde dies normalerweise zu dem Fehler EINVAL führen.) In diesem Fall darf shmaddr nicht NULL sein.

Der brk(2)-Wert des aufrufenden Prozesses wird durch das Einblenden nicht verändert. Das Segment wird bei Beenden des Prozesses automatisch abgetrennt. Das gleiche Segment kann mit Lese- sowie mit Lese- und Schreibzugriff einmal oder mehrfach in den Adressraum des Prozesses eingeblendet werden.

Nach einem erfolgreichen shmat()-Aufruf aktualisiert das System die Bestandteile der dem Speichersegment zugeordneten shmid_ds-Struktur (siehe shmctl(2)) wie folgt:

• shm_atime wird auf die aktuelle Zeit gesetzt.
• shm_lpid wird auf die Prozesskennung des aufrufenden Prozesses gesetzt.
• shm_nattch wird um Eins erhöht.

shmdt()¶

shmdt() löst das gemeinsame Speichersegment, das an der Adresse shmaddr liegt, aus dem Adressraum des aufrufenden Prozesses. Das zu entfernende gemeinsame Speichersegment muss momentan mit shmaddr eingeblendet sein, das dem Rückgabewert des einbendenden shat()-Aufrufs entspricht.

Nach einem erfolgreichen shmdt()-Aufruf aktualisiert das System die Bestandteile der dem Speichersegment zugeordneten Struktur shmid_ds wie folgt:

• shm_dtime wird auf die aktuelle Zeit gesetzt.
• shm_lpid wird auf die Prozesskennung des aufrufenden Prozesses gesetzt.
• shm_nattch wird um Eins verringert. Wenn es dabei zu 0 wird und das Segment zum Löschen markiert ist, wird es gelöscht.

Quelle des Programms: svshm_string.h¶

Die folgende Header-Datei wird von den »Lese«- und »Schreibe«-Programmen eingebunden:

#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(Nachricht)    do { perror(Nachricht); exit(EXIT_FAILURE); \


                        } while (0)
union semun {                   /* Wird in Aufrufen von semctl() verwandt */


    int                 val;


    struct semid_ds *   buf;


    unsigned short *    array;
#if defined(__linux__)


    struct seminfo *    __buf;
#endif
};
#define MEM_SIZE 4096

Quelle des Programms: svshm_string_read.c¶

Das »Lese«-Programm erstellt ein gemeinsam benutztes Speichersegment und eine Semaphore-Gruppe, die eine Semaphore enthält. Es blendet dann das gemeinsam benutzte Speicherobjekt in seinen Adressraum ein und initialisiert den Semaphoren-Wert auf 1. Schließlich wartet das Programm darauf, dass der Semaphoren-Wert 0 wird und gibt danach die Zeichenkette aus, die durch den »Schreiber« in das gemeinsam benutzte Speichersegment kopiert wurde.

/* svshm_string_read.c


   Lizenziert unter der GNU General Public License v2 oder neuer.
*/
#include "svshm_string.h"
int
main(int argc, char *argv[])
{


    int semid, shmid;


    union semun arg, dummy;


    struct sembuf sop;


    char *addr;
int
main(int argc, char *argv[])
{


    struct stat sb;


    char *buf;


    ssize_t nbytes, bufsiz;


    /* Gemeinsam benutzten Speicher und eine Semaphoren-Gruppe, die eine


       Semaphore enthält, erstellen */


    shmid = shmget(IPC_PRIVATE, MEM_SIZE, IPC_CREAT | 0600);


    if (shmid == -1)


        errExit("shmget");


    semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);


    if (shmid == -1)


        errExit("shmget");


    /* Gemeinsamen Speicher in unseren Adressraum einblenden */


    addr = shmat(shmid, NULL, SHM_RDONLY);


    if (addr == (void *) -1)


        errExit("shmat");


    /* Semaphore 0 in der Gruppe mit dem Wert 1 initialisieren */


    arg.val = 1;


    if (semctl(semid, 0, SETVAL, arg) == -1)


        errExit("semctl");


    printf("shmid = %d; semid = %d\n", shmid, semid);


    /* Darauf warten, dass der Semaphore-Wert 0 wird */


    sop.sem_num = 0;


    sop.sem_op = 0;


    sop.sem_flg = 0;


    if (semop(semid, &sop, 1) == -1)


        errExit("semop");


    /* Die Zeichenkette aus dem gemeinsamen Speicher ausgeben */


    printf("%s\n", addr);


    /* Den gemeinsam benutzten Speicher und die Semaphoren-Gruppe entfernen */


    if (shmctl(shmid, IPC_RMID, NULL) == -1)


        errExit("shmctl");


    if (semctl(semid, 0, IPC_RMID, dummy) == -1)


        errExit("semctl");


    exit(EXIT_SUCCESS);
}

Quelle des Programms: svshm_string_write.c¶

Das Schreibe-Programm akzeptiert drei Befehlszeilenargumente: die Kennungen des vom »Lese«-Programm bereits erstellten, gemeinsam benutzten Speichersegments und die Sempahoren-Gruppe und eine Zeichenkette. Es blendet das bestehende gemeinsam benutzte Speichersegment in seinen Adressraum ein, verringert den Semaphoren-Wert auf 0, um den »Leser« zu informieren, dass er jetzt den Inhalt des gemeinsam benutzten Speichers untersuchen kann.

/* svshm_string_write.c


   Lizenziert unter der GNU General Public License v2 oder neuer.
*/
#include "svshm_string.h"
int
main(int argc, char *argv[])
{


    int semid, shmid;


    struct sembuf sop;


    char *addr;


    size_t len;


    if (argc != 4) {


        fprintf(stderr, "Aufruf: %s Shmid Semid Zeichenkette\n", argv[0]);


        exit(EXIT_FAILURE);


    }


    len = strlen(argv[3]) + 1;  /* +1, um abschließende '\0' einzuschließen */


    if (len > MEM_SIZE) {


        fprintf(stderr, "Zeichenkette ist zu groß!\n");


        exit(EXIT_FAILURE);


    }


    /* Objektkennungen von der Befehlszeile erhalten */


    shmid = atoi(argv[1]);


    semid = atoi(argv[2]);


    /* Gemeinsam benutzten Speicher in unseren Adressraum einblenden und Zeichenkette


       (einschließlich abschließendem NULL-Byte) in den Speicher kopieren */


    addr = shmat(shmid, NULL, 0);


    if (addr == (void *) -1)


        errExit("shmat");


    memcpy(addr, argv[3], len);


    /* Semaphore auf 0 verringern */


    sop.sem_num = 0;


    sop.sem_op = -1;


    sop.sem_flg = 0;


    if (semop(semid, &sop, 1) == -1)


        errExit("semop");


    exit(EXIT_SUCCESS);
}