Provided by: manpages-de_0.5-4.1ubuntu1_all bug

BEZEICHNUNG

       ipc - System V Mechanismen für Kommunikation zwischen Prozessen

ÜBERSICHT

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

BESCHREIBUNG

       Diese  Handbuchseite  bezieht  sich  auf  die  System V Mechanismen für
       Kommunikation zwischen Prozessen, wie sie in Linux verwirklicht wurden:
       message  queues, semaphore sets und shared memory segments.  (Zumindest
       einmal soll denn doch eine Übersetzung versucht werden:  Nachrichten  -
       Warteschlangen,   Semaphoren  (Sperr/Frei  -  Vermerke)  und  gemeinsam
       genutzte Speicherbereiche. Oh Himmel. A.d.Üb.)  Im  Folgenden  bedeutet
       das  Wort  Ressource  eine  konkrete  Erscheinung (instantiation) einer
       dieser Mechanismen.

   Ressource Zugriffsrechte
       Für jede Ressource verwaltet das System in einer  allgemeinen  Struktur
       des  Typs  struct  ipc_perm  die  Informationen, die zur Bestimmung der
       Rechte auf eine ipc - Operation notwendig sind.  Die ipc_perm Structur,
       definiert  von  der  <sys/ipc.h>  system header Datei, enthält folgende
       Elemente:

            ushort cuid;    /* Benutzerkennung des Erzeugers */
            ushort cgid;    /* Gruppenkennung des Erzeugers */
            ushort uid; /* Kennung des Eigentümers */
            ushort gid; /* Gruppenkennung des Eigentümers */
            ushort mode; /* Lese/Schreib - Rechte */

       Das  mode  Element  der  ipc_perm  Struktur  bestimmt  mit   seinen   9
       niedrigstwertigen  Bits  die Zugriffsrechte auf die Ressource für einen
       Prozess, der einen ipc-Systemaufruf ausführt.  Die  Rechte  werden  wie
       folgt interpretiert:

            0400 Eigentümer darf lesen
            0200 Eigentümer darf schreiben
            0040 Gruppe darf lesen
            0020 Gruppe darf schreiben
            0004 Andere dürfen lesen
            0002 Andere dürfen schreiben

       Bits  0100,  0010  und 0001 (die Ausführungsbits) werden nicht benutzt.
       Darüber hinaus bedeutet "schreiben" eigentlich "verändern",  soweit  es
       sich auf ein semaphore set bezieht.

       Die  selbe  system  header  Datei  definiert  auch folgende symbolische
       Konstanten:

       IPC_CREAT     Eintrag erzeugen, wenn Schlüssel nicht vorhanden.

       IPC_EXCL      Mißerfolg, wenn Schlüssel vorhanden.

       IPC_NOWAIT    Fehlermeldung, wenn die Anforderung warten muss.

       IPC_PRIVATE   Privater Schlüssel.

       IPC_RMID      Ressource beseitigen.

       IPC_SET       Setzen von Optionen der Ressource.

       IPC_STAT      Ansehen der Optionen der Ressource.

       Beachten  Sie,  dass  IPC_PRIVATE  vom  Typ  key_t  ist.  Alle  anderen
       symbolischen  Konstanten sind Flag - Felder, die mit Variablen des Typs
       int ODER - verknüpft werden können.

   Message Queues
       Eine message queue wird eindeutig identifiziert  über  einen  positiven
       Integerwert (ihre msqid) und ist mit einer Datenstruktur verbunden, die
       vom Typ struct msquid_ds ist,  definiert  in  <sys/msg.h>.   Diese  hat
       folgende Elemente:

            struct ipc_perm msg_perm;
            ushort msg_qnum;     /* Anzahl wartende messages */
            ushort msg_qbytes;   /* Bytes max in einer queue */
            ushort msg_lspid;    /* pid des letzten msgsnd */
            ushort msg_lrpid;    /* pid des letzten msgrcv */
            time_t msg_stime;    /* Zeit des letzten msgsnd */
            time_t msg_rtime;    /* Zeit des letzten  msgrcv */
            time_t msg_ctime;    /* Zeit der letzten Änderung */

       msg_perm   ipc_perm  Struktur,  die  die Zugriffsrechte auf die message
                  queue angibt.

       msg_qnum   derzeitige Anzahl der Messages in der Queue.

       msg_qbytes Maximale Anzahl an Bytes Messagetext,  die  in  der  Message
                  Queue erlaubt sind.

       msg_lspid  ID  des  Prozesses,  der  zuletzt  den  msgsnd  Systemaufruf
                  getätigt hat.

       msg_lrpid  ID  des  Prozesses,  der  zuletzt  den  msgrcv  Systemaufruf
                  getätigt hat.

       msg_stime  Zeitpunkt des letzten msgsnd Systemaufrufs.

       msg_rtime  Zeitpunkt des letzten msgcv Systemaufrufs.

       msg_ctime  Zeitpunkt des letzten Systemaufrufs, bei dem ein Element der
                  msqid_ds Struktur geändert wurde.

   Semaphore Sets
       Ein Semaphore Set wird eindeutig identifiziert  durch  einen  positiven
       Integerwert  (seine  semid)  und  ist  mit  einer Datenstruktur vom Typ
       struct semid_ds, verbunden,  definiert  in  <sys/sem.h>,  die  folgende
       Elemente enthält:

            struct ipc_perm sem_perm;
            time_t sem_otime;    /* Zeit des letzten Aufrufs */
            time_t sem_ctime;    /* Zeit der letzten Änderung */
            ushort sem_nsems;    /* Anzahl Semaphoren im Set */

       sem_perm   ipc_perm   Struktur   für   die   Zugriffsrechte   auf   das
                  Semphorenset.

       sem_otime  Zeitpunkt des letzten semop Systemaufrufs.

       sem_ctime  Zeitpunkt  des  letzten  semctl  Systemaufrufs,  der   einen
                  Eintrag  o.g. Struktur oder eine zum Set gehörende Semaphore
                  geändert hat.

       sem_nsems  Anzahl der Semaphoren im Set. Jede Semaphore des  Sets  wird
                  repräsentiert   durch   einen  nicht  negativen  Integerwert
                  zwischen 0 und sem_nsems-1.

       Eine Semaphore ist eine Datenstruktur des Typs struct sem mit folgenden
       Einträgen:

            ushort semval;  /* Semaphorenwert */
            short sempid;   /* pid des letzten Aufrufs */
            ushort semncnt;      /* Anzahl Prozesse 1 (s.w.u.) */
            ushort semzcnt;      /* Anzahl Prozesse 2 (s.w.u.) */

       semval     Semaphorenwert: eine nicht - negativea Ganzzahl.

       sempid     ID  des  letzten  Prozesses,  der  mit dieser Semaphore eine
                  Semaphorenoperation ausführte.

       semncnt    Anzahl Prozesse 1. Gemeint sind  die  Prozesse,  die  darauf
                  warten, dass semval erhöht wird.

       semznt     Anzahl  Prozesse  2.  Gemeint  sind die Prozesse, die darauf
                  warten, dass semval den Wert 0 annimmt.

   Shared Memory Segments
       Ein Shared Memory  Segment  wird  eindeutig  identifiziert  durch  eine
       positive   Ganzzahl   (seine   shmid)   und  ist  verbunden  mit  einer
       Datenstruktur vom Typ struct shmid_ds, definiert  in  <sys/shm.h>,  mit
       folgenden Einträgen:

            struct ipc_perm shm_perm;
            int shm_segsz;  /* Größe des Segments */
            ushort shm_cpid;     /* pid des Erzeugers */
            ushort shm_lpid;     /* pid, letzte Operation */
            short shm_nattch;    /* Anzahl derzeitiger Anbindungen */
            time_t shm_atime;    /* Zeit der letzten Anbindung */
            time_t shm_dtime;    /* Zeit der letzten Freigabe */
            time_t shm_ctime;    /* Zeit der letzten Änderung */

       shm_perm   ipc_perm  Struktur,  die  die  Zugriffsrechte auf das Shared
                  Memory Segment definiert.

       shm_segsz  Größe des Segments in Bytes.

       shm_cpid   ID des Prozesses, der das Shared Memory Segment erzeugt hat.

       shm_lpid   ID   des   letzten  Prozesses,  der  den  shmat  oder  shmdt
                  Systemaufruf ausgeführt hat.

       shm_nattch Anzahl von Prozessen, die derzeit mit diesem  Shared  Memory
                  Segment arbeiten (attaches).

       shm_atime  Zeit des letzten shmat Systemaufrufs.

       shm_dtime  Zeit des letzten shmdt Systemaufrufs.

       shm_ctime  Zeit des letzten shmctl Systemaufrufs,der shmid_ds verändert
                  hat.

SIEHE AUCH

       ftok(3),  msgctl(2),  msgget(2),   msgrcv(2),   msgsnd(2),   semctl(2),
       semget(2), semop(2), shmat(2), shmctl(2), shmget(2), shmdt(2).