Interprozesskommunikation in Unix. WS 08/09 Universität Innsbruck

Transkript

1 Interprozesskommunikation in Unix Betriebssysteme WS 08/09 Universität Innsbruck

2 Unix-Standardisierung (kurzer Einschub) Erste Unix-Version 1969 (Ken Thompson) Im Laufe der Zeit bildete sich eine Vielzahl von unterschiedlichen Unix-Varianten heraus Standardisierung war notwendig Unix-Standardisierung POSIX (Portable Operating System Interface) Ganze Familie von Standards (System-Schnittstelle, Thread-Programmierung, Shells etc.) Die meisten heutigen Unix-Systeme genügen dem POSIX Standard POSIX-Standard basiert auf Unix-Systemen ist aber nicht darauf beschränkt (auch andere Betriebssysteme können diesen Standard erfüllen) X/Open XPG Industriestandard für offene Systeme Die meisten heutigen Unix-Implementierungen unterstützen die 4. Ausgabe (XPG 4) Unterschiedliche UNIX-Implementierungen 2

3 Unix-Implementierungen (kurzer Einschub) Standardisierungen werden von unabhängigen Organisationen durchgeführt Unix-Implementierungen (die diese Standards mehr oder weniger entsprechen) werden durch Firmen vorgenommen 3 wichtige Beispiele System V Release 4 (SVR 4) USL (Unix System Laboratories) von AT&T SVR 4 erfüllt POSIX und X/Open XPG 3 Heute üblicherweise Bezeichnung für eine ganze Klasse von Unix-Derivaten (Beispiel Solaris) BSD (Berkeley Software Distribution) UCB (University of California at Berkeley) Begriff BSD bezeichnet heute eine ganze Klasse von Unix-Derivaten, die ihre Wurzel in der eigentlichen BSD haben Linux Frei verfügbar und umfasst Teile der Funktionalität von SVR 4, der POSIX- Standards und der BSD-Linie 3

4 Prozesse und Kommunikation Mehrere Prozesse können gleichzeitig ablaufen Verwandt (z.b. Vaterprozess und Kindprozess) Nicht verwandt Prozesse, die nebeneinander herlaufen, wissen so gut wie nichts voneinander (z.b. welche Daten andere Prozesse enthalten etc.) Realisiert über Speicherschutz (siehe spätere Vorlesung) Es gibt aber Situationen, in denen man mit anderen Prozessen kommunizieren muss Mehrere Prozesse müssen spezielle Daten gemeinsam verwenden Die Prozesse sind untereinander abhängig und müssen aufeinander warten Daten müssen von einem Prozess zu einem anderen weitergereicht werden Die Verwendung von System-Ressourcen müssen koordiniert werden 4

5 Kommunikation über Dateien Würden keine spezielle Funktionen zur Verfügung stehen, dann müsste man über Dateien kommunizieren Umständlich Langsam Gemeinsame Benutzung muss koordiniert werden Probleme mit Dateien können teilweise gelöst werden Sperrdateien Record-Locking Ermöglicht das Sperren einer Datei oder eines Dateibereichs Memory-Mapped-I/O Herstellung einer Beziehung zwischen einer Datei und einem Puffer (im Hauptspeicher) Schnellere und einfachere Dateizugriffe Es gibt aber schnellere und elegantere Techniken für die Interprozesskommunikation (InterprocessCommunication oder kurz IPC) 5

6 Kommunikation zwischen Prozessen in UNIX Pipes Pipes (halbduplex) FIFOs (benannte Pipes) SVR 4 Interprozesskommunikation Message-Queues Semaphore Shared-Memory STREAMS STREAM Pipes Benannte STREAM Pipes Sockets Rechnernetze (4. Semester) 6

7 Überblick über die unterschiedlichen IPC-Arten IPC-Art POSIX XPG3 SVR4 BSD Pipes (halbduplex) X X X X FIFOs (benannte Pipes) X X X X STREAM Pipes X X Benannte STREAM Pipes X X Message-Queues X X Semaphore X X Shared-Memory X X Sockets X X STREAMS X Werden genau besprochen Werden ganz kurz besprochen 7

8 PIPES 8

9 Waren die erste Form der IPC Pipes Werden heute von allen Unix-Systemen angeboten Besitzen 2 Eigenschaften Sie können nur zwischen Prozessen eingerichtet werden, die einen gemeinsamen Vorfahren haben Pipes sind halbduplex, d.h. die Daten können immer nur in eine Richtung fließen Wiederholung aus der Übung Einrichten einer Pipe mit dem Befehl pipe Richtet eine Pipe im Kern ein Für den Prozess selbst zunächst nutzlos Daher wird forkaufgerufen um einen Kindprozessfür die Kommunikation zu erzeugen 9

10 Pipes (schematisch) nach pipe-aufruf Prozess A fd[0] fd[1] Vaterprozess A fd[0] fd[1] Kern fork Kern fd[0] fd[1] Kindprozess B 10

11 Beispiele Vaterprozess A close fd[0] fd[1] Vaterprozess A fd[0] close fd[1] Kern Kern fd[0] close fd[1] Kindprozess B close fd[0] fd[1] Kindprozess B 11

12 Typische Anwendung Weiterleiten über eine Pipe (Vaterprozess an Kindprozess) Pipe einrichten Kindprozess erzeugen Standardeingabe des Kindprozesses auf die Leseseite der Pipe einrichten Mit execden Kindprozessmit einem entsprechenden Programm überlagern Zusammenfassung typischer Abfolge in popen und pclose popen (Rückgabewert ist ein Dateizeiger) Einrichten einer Pipe mit pipe Kreieren eines Kindprozesses mit fork Schließen der nicht benutzten Seiten der Pipe im Vater- und Kindprozess Überlagern des Kindprozesses durch ein Shellprogramm mit exec Warten auf die Beendigung der exec-ausführung pclose Eine mit popen geöffnete Pipe wieder schließen 12

13 Benannte Pipes (FIFOs) Pipes können nur zwischen verwandten Prozessen verwendet werden FIFOs (namedpipes) können zwischen beliebigen Prozessen verwendet werden FIFO Ist eine Pipe die einen Namen hat Wird wie eine Datei behandelt Daten können aber nur einmal gelesen werden Nach dem Lesen sind die Daten nicht mehr vorhanden! Unterstützt mehrere Schreibprozesse 13

14 Beispiel (Kommandozeile) In der ersten Shell mkfifo /tmp/test cat </tmp/test liest Daten aus der FIFO und gibt sie in der Shell aus In einer zweiten Shell: cat >/tmp/test wartet auf Tastatureingaben und schreibt sie in die FIFO Text, der in der zweiten Shell eingegeben wird, erscheint nach einem Return in der ersten Shell Benutzerrechte Erzeuger kann Benutzungsrechte setzen p zeigt an, dass es sich um eine FIFO handelt (Beispiel:"prwxrwxrwx") 14

15 FIFOS in C #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode); pathnamesteht für den FIFO-Dateinamen modelegt die Zugriffsrechte für die FIFO fest (symbolische Konstante, z.b. O_NONBLOCK) Tritt ein Fehler auf, gibt mkfifo-1 zurück, ansonsten 0 Wurde die FIFO erfolgreich angelegt, kann sie danach wie eine gewöhnliche Datei geöffnet und benutzt werden fopen, open, fprintf, write etc. 15

16 Regeln für FIFOs open auf eine FIFO Ohne O_NONBLOCK Leser/Schreiber blockiert bis ein anderer Prozess die FIFO zum Schreiben/Lesen öffnet Mit O_NONBLOCK Ein open für Nur-Lesen kehrt sofort zurück Ein open für Nur-Schreiben führt zu einem Fehler, wenn kein Leser vorhanden ist Schreiben in eine FIFO ohne Leseprozess SIGPIPE-Signal Schließen durch letzten Schreiber Für den Leseprozess wird ein EOF generiert Gleichzeitiges Schreiben durch mehrere Prozesse Wenn mit writenicht mehr als PIPE_BUFBytes geschrieben werden ist alles in Ordnung Ansonsten können Daten vermischt werden 16

17 Beispiel (1) #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <stdio.h> #include <stdlib.h> int main(int argc, char** argv) { FILE *fp_fifo; int count; char buf[4096]; if ( mkfifo("fifo_test", 0777) == -1) { perror("mkfifo"); exit(exit_failure); } if ( (fp_fifo = fopen("fifo_test", "r")) == NULL){ perror("fopen"); exit(exit_failure); } printf("you told my child: "); while( (count = fscanf(fp_fifo, "%s", buf)) > 0) { printf("%s", buf); } printf("\n"); if ( fclose(fp_fifo) == EOF ) {perror("fclose");exit(exit_failure);} if ( unlink("fifo_test") == -1) {perror("unlink");exit(exit_failure);} exit(exit_success); } 17

18 Beispiel (2) #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <stdio.h> #include <stdlib.h> int main(int argc, char** argv){ FILE *fp_fifo; char buf[4096]; if ( (fp_fifo = fopen("fifo_test", "w")) == NULL){ perror("fopen"); exit(exit_failure); } printf("i am child %d, tell me something: ", getpid()); scanf("%s", buf); fprintf(fp_fifo, "%s", buf); if ( fclose(fp_fifo) == EOF ) { perror("fclose"); exit(exit_failure); } exit(exit_success); } 18

19 Beispiel für eine Anwendung 19

20 SVR 4 - INTERPROZESSKOMMUNIKATION 20

21 SVR 4 -IPC Nachfolgend werden drei Methoden für die IPC vorgestellt Austausch von Nachrichten zwischen Prozessen (Message-Queues) Synchronisation über Semaphore Austausch von Daten über gemeinsame Speicherbereiche (Shared- Memory) Die Methoden nutzen unterschiedliche Objekte Nachrichtenwarteschlangen Semaphore gemeinsame Hauptspeicherbereiche Die Verwaltung dieser Objekte ist aber einheitlich Alle drei Methoden verwenden dieselben systemweiten Ressourcen, welche von mehreren Prozessen gemeinsam genutzt werden können Somit ist eine Kommunikation zwischen nicht verwandten Prozessen möglich Hier werden keine File-Deskriptoren etc. verwendet 21

22 Kennung und Schlüssel Kennung (Identifier) Jedem Objekt wird intern vom Kern eine eindeutige Kennung (nichtnegative Zahl) zugeteilt Diese Zuteilung erfolgt beim Einrichten des Objekts Kennungszahlen können sehr groß werden Kennungszahlen von gelöschten Objekten werden nicht unmittelbar wieder vergeben (Unterschied zu Filedeskriptoren!) Es wird immer weiter bis zu einem maximalen Wert hochgezählt und dann wieder bei 0 begonnen Schlüssel (Key) Ein Schlüssel muss angegeben werden, wenn ein neues Objekt eingerichtet wird Dieser Schlüssel hat der Typ key_t(meist in <sys/types.h> als long definiert) Der Schlüssel wird vom Kern mit der Kennung verbunden Dadurch können nicht verwandte Prozesse ein Objekt gemeinsam benutzen Die Prozesse müssen nur den Schlüssel kennen Schlüssel sollte eindeutig sein 22

23 Einrichten eines neuen Objekts Für das Einrichten existieren die drei Funktionen msgget, semget und shmget(siehe nachfolgende Abschnitte) Alle drei Funktionen haben neben dem Schlüssel noch ein weiteres Argument flag Eine neues Objekt kann auf zwei verschiedene Arten kreiert werden: Angabe von IPC_PRIVATE als Schlüssel Damit wird ein privates Objekt eingerichtet (kein Schlüssel zugeordnet) Angabe eines noch nicht existierenden Schlüssels wobei im aktuellen flag-argument IPC_CREAT gesetzt ist Um sicherzustellen, dass beim Einrichten eines Objekts wirklich ein neues Objekt angelegt wird, muss im aktuellen flag Argument sowohl IPC_CREAT als auch IPC_EXCL gesetzt sein (siehe spätere Beispiele) 23

24 Herstellen einer Verbindung Client-Prozesse können zu einem bereits existierenden Objekt eine Verbindung herstellen Aufruf der entsprechenden Funktionen (msgget, semgetund shmget) mit dem gleichen Schlüssel, der beim Kreieren verwendet wurde Im flag-argument darf dabei IPC-CREAT nicht gesetzt sein Existierende IPC-Objekte können auf der Kommandozeile angezeigt werden Kommando ipcs listet die aktuellen Objekte auf Bei allen Objekten werden standardmäßig Schlüssel, Kennung, Benutzer und Zugriffsrechte angegeben Weitere Informationen sind vom Objekt oder von den entsprechenden Argumenten abhängig (siehe man ipcs) 24

25 Ein Objekt existiert so lange, bis es explizit gelöscht wird Löschen von Objekten bis ein Shutdown für das System erfolgt Ein Objekt kann von jedem Benutzer mit den entsprechenden Zugriffsrechten oder immer vom Eigentümer gelöscht werden Für das Löschen werden die Funktionen msgctl, semctlund shmctl verwendet Dazu muss das Argument IPC_RMID angegeben werden Auf der Kommandozeile steht das Kommando ipcrmzur Verfügung Das zu löschende Objekt kann über den Schlüssel oder die Kennung identifiziert werden 25

26 Zugriffsrechte und Limits Zu jedem Objekt existiert die Struktur ipc_perm, die Zugriffsrechte für das Objekt und dessen Eigentumsverhältnisse festlegt Einige Komponenten dieser Struktur können mit den Befehlen msgctl, semctl und shmctl gesetzt werden (mit dem kdo- Argument IPC_SET) Die Zugriffsrechte sind ähnlich zu den Zugriffsrechten von Dateien Es existieren aber keine Ausführrechte Limits Für alle drei Objektarten sind Limits festgelegt Die meisten Limits können nur durch eine Neukonfiguration des Kernels geändert werden 26

27 Kommunikationsmöglichkeiten mit SVR 4 - IPC Mit IPC_PRIVATE Nicht verwandte Prozesse Ein Prozess A kreiert ein Objekt mit IPC_PRIVATEund speichert die Kennung in einer Datei Prozesse B, C.. etc. lesen aus dieser Datei die Kennung und greifen auf das Objekt zu Verwandte Prozesse Vaterprozess kreiert das Objekt mit IPC_PRIVATEund speichert die Kennung in einer Variable Bei fork wird diese Kennung an den Kindprozess weitervererbt Ohne IPC_PRIVATE Mehrere Prozesse können einen gemeinsamen Schlüssel vereinbaren Z.B. in einer Headerdatei Ein Prozess (Server) kreiert das Objekt mit diesem Schlüssel Mehrere Prozesse (Clients) greifen über diesen Schlüssel auf das Objekt zu Wenn der Schlüssel schon vergeben wurde, dann muss der Server-Prozess eine entsprechende Fehlerbehandlung durchführen 27

28 MESSAGE-QUEUES 28

29 Message-Queues Message-Queues (Nachrichtenwarteschlangen ) werden im Kern in Form einer verketteten Liste verwaltet standardmäßig nach dem FIFO-Prinzip Prioritäten möglich Befehle msgget: Eine Message-Queue einrichten oder eine bestehende öffnen msgsnd: Nachricht schicken (d.h. am Ende der betreffende Queue anhängen) msgrcv: Nachrichten aus einer Queue empfangen (die Nachrichten müssen nicht in der Reihenfolge aus der Queue gelesen werden, in der sie dort eingetragen wurden) Jede Nachricht setzt sich zusammen aus Message-Typ (Datentyp long, benutzerdefiniert) Länge der Message (Datentyp size_t) Message-String (Nachricht) 29

30 Funktionsweise, Status, Limits 2 oder mehrere Prozesse tauschen Informationen über solch eine Message-Queue aus Der Sender gibt mit Hilfe eines Systemaufrufs eine Nachricht in die Message-Queue Der Empfänger liest die Nachricht aus der Message-Queue Zu jeder Message-Queue existiert eine msqid_ds-struktur, die den aktuellen Status der Queue festlegt Limits MSGMAX Maximale Anzahl der Bytes einer Nachricht MSGMNB Maximale Anzahl von Bytes in einer Message-Queue MSGMNI Maximale Anzahl von Message-Queues im System MSGTQL Maximale Anzahl von Messages im System 30

31 Benutzung #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgget(key_t key, int msgflg) int msgctl(int ID, int cmd, struct msqid_ds *buf) int msgsnd(int ID, struct msgbuf *msgp, size_t msgsz,int msgflg) ssize_t msgrcv(int ID, struct msgbuf *msgp, size_t msgsz, long msg-typ, int msgflg) 31

32 Systemaufruf msgget Syntax int msgget ( key_t key, int msgflg ) Beschreibung key Eindeutiger Schlüssel (Name) der Message-Queue IPC_PRIVATE: Spezieller Wert für key ignoriert msgflgund gibt die ID der Message-Queue (bei Erzeugung) zurück msgflg IPC_CREAT: Erzeugt eine Message-Queue, wenn sie noch nicht existiert IPC_EXCL: In Kombination mit IPC_CREAT, Aufruf von msggetbricht ab, wenn die Message-Queue schon existiert Rückgabewert ID der Warteschlange (wenn angelegt) -1 (sonst) 32

33 Systemaufruf msgsnd Syntax int msgsnd ( int msqid, const void *msgp, size_t msgsz, int msgflg ) Beschreibung msqid: ID der Warteschlange msgp: Pointer auf einen Nachrichtenpuffer der Form struct msgbuf { long mtype; /* Typ */ char mtext[msgsz]; /* Daten */ }; MSGSZ: Größe von mtext in Bytes msgflg: 0 (blockieren, wenn Queue voll) IPC_NOWAIT(sofort zurückkehren, wenn Queue voll und Setzen von errno) Rückgabewert 0(wenn erfolgreich), -1(bei Fehler, errno wird gesetzt) 33

34 Syntax Systemaufruf msgrcv ssize_t msgrcv (int msqid, void *msgp, size_t msgsz, long msgtype, int msgflg ) Beschreibung msqid, msgp: siehe msgsnd msgsz: Maximale Länge von mtextin Bytes msgtype: 0 = erste Nachricht aus der Message-Queue (FIFO) >0 = Erste Nachricht mit Typ msgtyp(wenn FlagMSG_EXCEPTgesetzt ist, wird die erste Nachricht empfangen, die nicht von diesem Typ ist)) <0 = Erste Nachricht mit kleinstem Typ <= abs(msgtyp) msgflg: 0 (blockieren, wenn Queue leer) IPC_NOWAIT (sofort zurückkehren, wenn Queue leer und Setzen von errno) Rückgabewert 0(wenn erfolgreich), -1 (bei Fehler, errno wird gesetzt) 34

35 Systemaufruf msgctl Syntax int msgctl ( int msqid, int cmd, struct msqid_ds *buf ) Beschreibung msqid: ID der Message-Queue cmd: IPC_STAT Abfragen des Status der Message-Queue (msgctlschreibt die Statusinformationen an die Adresse buf) IPC_SET Setzen des Eigentümers, der Zugriffsrechte und der maximalen Größe (Werte aus bufin die entsprechende Datenstruktur der Message-Queue schreiben) msg_perm.uid msg_perm.gid msg_perm.mode /* only lowest 9-bits */ msg_qbytes IPC_RMID die Message-Queue entfernen Andere Prozesse erhalten bei einem nachfolgenden Zugriff auf die Queue einen Fehler (errno wird auf EIDRM gesetzt) buf: für IPC_SET oder IPC_STAT Operationen Rückgabewert zeigt an, ob die Operation erfolgreich war 35

36 Beispiel (1) #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define MSGSZ 128 /* message size */ #define KEY 1024 /* common key */ typedef struct msgbuf { long mtype; char mtext[msgsz]; } message_buf; /* Message structure */ 36

37 Beispiel (2, msg_send.c) #include "mymsg.h" int main(int argc, char* argv[]) { int msqid, msgflg = IPC_CREAT IPC_EXCL 0666; message_buf sbuf; size_t buf_length; fprintf(stderr, "\nmsgget: Calling msgget(%d,%o)\n\n ",KEY,msgflg); if ((msqid = msgget(key, msgflg )) < 0) { perror("can not create message queue"); exit(exit_failure); } sbuf.mtype = 1; /* message type 1 */ strcpy(sbuf.mtext, "Did you get this?"); /* this is the message */ buf_length = strlen(sbuf.mtext) + 1 ; } msgsnd(msqid, &sbuf, buf_length, IPC_NOWAIT); /* Send message */ printf ("%d, %d, %s, %d\n\n",msqid, (int) sbuf.mtype, sbuf.mtext, (int) buf_length); printf("message: \"%s\" Sent\n\n", sbuf.mtext); exit(exit_success); 37

38 Beispiel (3, msg_recv.c) #include "mymsg.h" int main(int argc, char *argv[]) { int msqid; message_buf rbuf; /* get the MQ with name KEY created by the server */ msqid = msgget(key, 0666); /* get message with type 1 */ msgrcv(msqid, &rbuf, MSGSZ, 1, 0); printf("%s\n", rbuf.mtext); /* print answer */ } exit(exit_success); 38

39 SEMAPHORE 39

40 Semaphor Eine klassische Methode um den Zugriff mehrerer Prozesse auf gemeinsame Ressourcen zu beschränken (synchronisieren) Eine geschützte Variable (oder ADT) die von eine Menge von Prozessen gelesen/geschrieben werden kann Ein Prozess, der auf einen gemeinsamen Datenbereich zugreifen möchte führt folgende Schritte durch Überprüfen des Semaphors Wert > 0: Ressource kann benutzt werden Prozess dekrementiert den Semaphor um 1 bevor er zugreift Wert = 0: Ressource wird benutzt Prozess wartet, bis der Bereich frei wird, d.h. der Semaphor positiv wird Inkrementieren des Semaphors um 1, wenn der Zugriff auf den gemeinsamen Bereich beendet wurde Überprüfen und Dekrementieren müssen atomare Operationen sein und sind daher normalerweise im Kern implementiert 40

41 Beispiele Beispiel für die Benutzung P(s) = Operation Reduziere Semaphor um 1 V(s) = Operation Erhöhe Semaphor um 1 Prozess 1 Anweisung;. P(s); /*kritische Region*/ V(s); end; Prozess 2 Anweisung; P(s); /*kritische Region */ V(s);. end; Prozess 1 und 2 rufen Funktion P() auf Nur 1 (!) Prozess kann den kritischen Bereich betreten Der zweite blockiert bei P() 41

42 Mehrere Semaphore Synchronisierung mit mehreren Semaphorvariablen Beispiel: Zugriff auf gemeinsamen Speicher mit 2 Semaphoren schützen Prozess 1 (Speicher schreiben) Anweisung. P(write); /*kritische Region*/ /* Schreiben in den Speicherbereich*/ V(read); end; Vorsicht bei Initialisierung Beispiele write=1,read=0 - Strikte Ordnung write=read=0 Deadlock Hinweis Prozess 2 (Speicher lesen) Anweisung; P(read); /*kritische Region */ /* Auslesen des Speicherbereichs */ V(write);. end; Binäre Semaphore nehmen nur die Werte 0 oder 1 an Allgemeine Semaphore können Werte von 0.. N annehmen, wobei der aktuelle Wert anzeigt, wie viele Prozesse den kritischen Bereich noch benutzen dürfen 42

43 Arten von Semaphorvariablen(1) Hängt vom Unix-System ab Namenlose Semaphore (analog zu Pipes) Einfache Semaphorvariablenfür die Synchronisierung von Threads oder Vater-/Kindprozessen #include <semaphore.h> sem_t sem; int sem_init(sem_t *sem, int pshared, unsigned value); int sem_post(sem_t *sem); int sem_wait(sem_t *sem); int sem_destroy(sem_t *sem); // V(sem) // P(sem) 43

44 Arten von Semaphorvariablen(2) Benannte Semaphore (analog zu FIFOs) Damit kann man auch Prozesse synchronisieren, die keinen gemeinsamen Speicherbereich haben Ähnlich zu FIFOs (Pseudo-Datei) mit Zugriffsrechten etc. sem_t sem_open(const char*name, int oflag,...); int sem_post(sem_t *sem); int sem_wait(sem_t *sem); int sem_close(sem_t sem); // V(sem) // P(sem) 44

45 Eigenschaften SVR 4 -Semaphore Ein Semaphor ist eine Menge von einem oder mehreren Semaphorwerten Beim Kreieren wird die Anzahl der Werte dieser Menge festgelegt Erlaubt eine detaillierte Aufteilung von kritischen Bereichen Das Kreieren ist unabhängig vom Initialisieren (2 Befehle) Eher ein Nachteil! Ein Semaphor muss immer explizit freigegeben (gelöscht) werden Systemaufrufe Einen Semaphorvektoranlegen bzw. Zugriff zu einem bestehenden Semaphorvektor besorgen: semget Statuskontrolle, Initialisierung, Löschen: semctl Operationen P() und V(): semop, semtimedop 45

46 Status und Limits Zu jedem Semaphore existiert eine semid_ds-struktur Limits SEMVMX Maximaler Wert eines Semaphors (typischer Wert: 32767) SEMMNI Maximale Anzahl von Semaphormengen(typischer Wert: 128) SEMMNS Maximale Anzahl von Semaphoren (typischer Wert: 3000) SEMMSL Maximale Anzahl von Semaphoren pro Semaphormenge (typischer Wert: 250) SEMOPN Maximale Anzahl von Operationen pro semop-aufruf (typischer Wert: 32) 46

47 Systemaufruf semget Syntax int semget( key_t key, int nsems, int semflag ); Beschreibung key, semflag: wie bisher nsems: Anzahl der Semaphore in der Menge Bei der Erzeugung muss das Argument angegeben werden Wird eine existierende Semaphormenge geöffnet, dann kann 0 übergeben werden Rückgabewert ID des Semaphors (für spätere Benutzung) -1 (sonst) Beispiel #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> if(( semid =semget( 5L, 1, IPC_CREAT 0666 )) < 0 ) { perror("semget failed"); exit(exit_failure); } 47

48 Syntax Systemaufruf semctl int semctl(int semid, int semnum, int cmd, union semun arg ); Beschreibung semnum: Bestimmter Wert aus der Semaphormenge(0.. nsems-1) cmd: IPC_STAT Abfragen der Struktur semid_ds IPC_SET Eigentümer/Zugriffsrechte setzen IPC_RMID Löschen der Semaphormenge GETVAL, SETVAL Abfragen/Setzen eines Wertes der Semaphormenge GETALL, SETALL Abfragen/Setzen aller Werte der Semaphormenge semun union semun { }; int val; /* value of SETVAL */ struct semid_ds *buf; /* buffer for IPC_STAT,IPC_SET */ ushort *array; /* array for GETALL, SETALL */ - Rückgabewert hängt von der Operation ab (siehe man semctl) 48

49 Beispiel (Systemaufruf semctl) #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> /* initialize */ union semun arg; arg.val = 1; if( semctl( semid, 0, SETVAL, arg ) < 0 ) { perror("semctl SETVAL failed"); exit(exit_failure); } /* remove semaphore 0 */ if( semctl( semid, 0, IPC_RMID, arg ) < 0 ) { perror("semctl IPC_RMID failed"); exit(exit_failure); } 49

50 Systemaufruf semop Syntax int semop( int semid, struct sembuf *sops, size_t nsops ); Beschreibung sembuf struct sembuf { ushort sem_num; /* no of semaphore 0..n-1*/ short sem_op; /* operation */ short sem_flg; /* flags (IPC_NOWAIT, SEM_UNDO) */ }; sosp: Ist die Adresse eines Arrays von Semaphoroperationen(Elemente des Arrays haben den Datentyp struct sembuf) sem_op: > 0 : Ressourcen freigeben, Semaphore um Wert erhöhen < 0 : Ressourcen anfordern, Semaphore um Wert erniedrigen (Funktioniert nur, wenn der Wert des Semaphors größer oder gleich dem absoluten wert von sem_op ist) == 0: Warten, bis Semaphore gleich 0 ist nsops: Die Anzahl der Operationen (Elemente) im Array Rückgabewert zeigt an, ob die Operation erfolgreich war 50

51 semop (2) P() und V()-Operationen ausführen P()-Operation: sem_op = -1 V()-Operation: sem_op = +1 In sem-numwird die Nummer der angesprochenen Semaphorvariable gesetzt (0 n-1) sem_flg in sops IPC_NOWAIT 0 Abbruch wenn der Semaphorwert kleiner als der absolute Wert von sem_opist (bei sem_op< 0) nicht gleich 0 ist (bei ==0) Wartet wenn der Semaphorwertkleiner als der absolute Wert von sem_opist (bei sem_op< 0) bis er größer oder gleich dem absolute Wert wird, oder der Semaphor gelöscht wird oder ein Signal eintrifft Wartet wenn der Semaphorwertnicht gleich 0 ist (bei ==0) bis er gleich 0 ist, oder der Semaphor gelöscht wird oder ein Signal eintrifft 51

52 semop(3) Wenn man bei Prozessen, die sich freiwillig oder unfreiwillig vorzeitig beenden, sicherstellen will, dass die gesetzten Semaphore wieder zurückgesetzt werden Setzen von SEM_UNDO in der sem_flg-komponente Wird SEM_UNDO gesetzt, dann merkt sich der Kern in einem sogenannten undo-zähler, wie viele Ressourcen durch diese spezielle Semaphorvariable belegt werden Beim Beenden des Prozesses setzt der Kern den entsprechenden Semaphor wieder zurück 52

53 Beispiel (Systemaufruf semop) #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> /* reset a semaphore: V-operation */ struct sembuf ops[1]; ops[0].sem_num = 0; ops[0].sem_flg = 0; ops[0].sem_op = +1; if( semop( semid, ops, 1 ) < 0 ) { perror("semop V() failed); exit(exit_failure); } 53

54 SHARED-MEMORY 54

55 Shared-Memory Abschnitt im Speicher, auf den beliebige Prozesse zugreifen können Vorteil: Schnellster IPC-Mechanismus Nachteil: Der Zugriff muss extern synchronisiert werden (z.b. durch Semaphore) Adressraum Prozess 1 Adressraum Prozess 2 Textsegment Datensegment Virtueller Adressbereich Shared- Memory- Segment Textsegment Datensegment Virtueller Adressbereich Stack Stack 55

56 Status, Limits und Benutzung Zu jedem Shared-Memory-Segment existiert eine shmid_ds- Struktur im Kern Limits SHMMAX Maximale Größe (in Bytes) eines Shared-Memory-Segments (typischer Wert: 0x ) SHMMIN Minimale Größe (in Bytes) eines Shared-Memory-Segments (typischer Wert: 1) SHMMNI Maximale Anzahl von Shared-Memory-Segmenten (typischer Wert: 4096) SHMSEG Maximale Anzahl von Shared-Memory-Segmenten (typischer Wert: 4096) 56

57 Benutzung Shared-Memory-Segment anfordern: shmget Ein Shared-Memory-Segment in den Adressraum eines Prozesses einbinden: shmat Schreiben in ein Shared-Memory-Segment: memcpy Abkoppeln eines angebundenen Shared-Memory-Segments: shmdt Optionen setzen, Informationen abfragen: shmctl 57

58 Systemaufruf shmget Syntax int shmget(key_t key, int size, int shmflag); Beschreibung key, shmflag: wie bisher size: minimale Größe Bei Erzeugung angeben Beim Öffnen eines existierenden Segments kann 0 angegeben werden Rückgabewert ID des Segments -1 (sonst) Beispiel #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> if(( shmid = shmget( 5L, 200, IPC_CREAT 0666 )) < 0 ) { perror("shmget failed"); exit(exit_failure); } 58

59 Systemaufruf shmat Syntax void *shmat(int shmid, const void *shmaddr, int shmflag ); Beschreibung shmid: ID des Segments shmaddr: Adresse an die das Segment angebunden wird NULL (empfehlenswert): Segment wird an die erste verfügbare Adresse angebunden shmflag: SHM_RDONLY: Segment wird nur zum Lesen angebunden, ansonsten Lesen und Schreiben erlaubt Rückgabewert ist ein Zeiger auf das Segment oder -1 Beispiel #include <sys/types.h> #include <sys/shm.h> if (( shm_p = shmat( shmid, (char *)0, 0 )) < (char *)0 ) { perror("shmat failed"); exit(exit_failure); } 59

60 Schreiben mit memcpy Syntax void * memcpy( void *dest, void *src, size_t n ); Funktionen Kopiert von einer Quelle (src) in eine Senke (dest) Liefert einen Zeiger auf den Anfang von dest Beispiel (Kopieren in ein Shared-Memory-Segment) #include <string.h> memcpy( shm_p, p_str, strlen(p_str) ); 60

61 Systemaufruf shmdt Syntax int shmdt( const void *shmaddr ); Beschreibung shmaddr: Adresse an die das Segment angebunden ist Rückgabewert zeigt an, ob die Operation erfolgreich war Beispiel #include <sys/shm.h> if (shmdt( shm_p ) < 0 ) { perror("shmdt failed"); } exit(exit_failure); 61

62 Systemaufruf shmctl Syntax int shmctl( int shmid, int cmd, struct shmid_ds *buf ); Beschreibung shmid: ID des Segments cmd: Festlegen der Aktion IPC_STAT: Status abfragen IPC_SET: Setzen des Eigentümers bzw. der Zugriffsrechte (Benutzung von buf) IPC_RMID: Löschen des Segments buf: Struktur mit entsprechenden Werte Rückgabewert zeigt an, ob die Operation erfolgreich war Beispiel #include <sys/ipc.h> #include <sys/shm.h> if( shmctl( shmid, IPC_RMID, 0) < 0 ) { perror("shmctl failed"); exit(exit_failure); } 62

63 Code-Fragmente (1) #define SHMSZ 27 char c; int shmid; key_t key; char *shm, *s; key = 5678; if ((shmid = shmget(key, SHMSZ, IPC_CREAT 0666)) < 0) { perror("shmget"); exit(exit_failure); } if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) { perror("shmat"); exit(exit_failure); } s = shm; for (c = 'a'; c <= 'z'; c++) *s++ = c; while (*shm!= '*') sleep(1); 63

64 Code-Fragmente (2) #define SHMSZ 27 int shmid; key_t key; char *shm, *s; key = 5678; if ((shmid = shmget(key, SHMSZ, 0666)) < 0) { perror("shmget"); exit(exit_failure); } if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) { perror("shmat"); exit(exit_failure); } for (s = shm; *s!= NULL; s++) putchar(*s); putchar('\n'); *shm = '*'; 64

65 Gängige Praxis Weiteres Beispiel Shared-Memory-Zugriffe mit Semaphorvariablen synchronisieren Umfangreicheres Beispiel (mit Semaphoren) 65

66 Shared Memory und fork/exec/exit Bei einem fork erbt der Kindprozess alle angebundenen Shared- Memory-Segmente Bei execwerden alle angebundenen Shared-Memory-Segmente getrennt (nicht zerstört!) Bei einem exit werden alle angebundenen Shared-Memory- Segmente getrennt (nicht zerstört!) Ein Shared-Memory-Segment wird erst dann gelöscht, wenn der letzte Prozess, der es benutzt, sich beendet oder die Anbindung aufhebt Nach einem Aufruf von shmdt führt ein Zugriff zu einem Fehler 66

67 ZUSAMMENFASSUNG UND AUSBLICK 67

68 Zusammenfassung In dieser Vorlesungseinheit wurden die klassischen Formen der Interprozesskommunikation besprochen Pipes FIFOs Message-Queues Semaphore Shared-Memory Daneben gibt es neuere Formen Stream Pipes und benannte Stream Pipes Erlauben zum Beispiel den Austausch von Filedeskriptoren 68

69 Pipes Client-Server-Eigenschaften klassischer IPC (1) Client-Prozess richtet 2 Pipes ein Mit fork und exec wird ein eigener Server-Prozess gestartet Kommunikation über Pipes FIFOS Server und Clients sind unabhängige Prozesse Für die Anforderungen der Clients reicht eine FIFO aus Diese ist allen Clients bekannt Jeder Client schickt bei seiner Anforderung seine Prozess-ID mit Für die Server-Antworten je Client muss eine eigene FIFO eingerichtet werden Eindeutiger Name durch Verwendung der Prozess-ID im FIFO-Namen Nur der entsprechende Client sollte aus der FIFO lesen Entsprechende Fehlerbehandlung notwendig 69

70 Client-Server-Eigenschaften klassischer IPC (2) Message-Queue Message-Typ wird verwendet, um den Empfänger der Nachricht festzulegen Alle Client-Anfragen haben den Typ 1 (Prozess-ID wird in der Anfrage mitgeschickt) und benutzen eine Message-Queue (Schlüssel bekannt) Bei den Server-Antworten wird dann die Prozess-ID als Message-Typ verwendet Client-spezifische Message-Queue Es existiert eine Message-Queue für alle Client-Anforderungen (über vereinbarten Schlüssel allen Clients bekannt) Jeder Client richtet seine private Message-Queue (IPC_PRIVATE) ein und schickt die Kennung bei seiner ersten Anfrage mit Shared-Memory und Semaphore Ähnlich wie Message-Queue Zusätzlich Semaphore oder auch Signale benutzen 70

71 Nachteile klassischer IPC Korrekte Identifizierung der Clients durch den Server ist nicht möglich Wenn der Client einen privilegierten Zugriff durch den Server verlangt, muss der Server unbedingt wissen, wer der Client ist Dazu benötigt man andere Methoden Z. B. Stream Pipes Stream Pipe arbeitet vollduplex Filedeskriptoren sind gleichzeitig zum Lesen und zum Schreiben geöffnet 71

72 Stream Pipes in SVR4 Unter SVR4 ist eine einfache Pipe eine Vollduplex-Pipe Unter SVR4 ist eine Pipe eine Verbindung zwischen STREAM- Köpfen Ein STREAM stellt eine Vollduplex-Verbindung zwischen einem Benutzerprozess und einem Gerätetreiber zur Verfügung Ein einfacher STREAM im Kern besteht aus einem STREAM-Kopf (Systemaufrufschnittstelle) und einem Gerätetreiber (oder Pseudogerätetreiber) Kommunikation in beide Richtungen Zwischen Kopf und Gerätetreiber können beliebig viele Steuermodule eingetragen werden Bei der Pipe werden einfach 2 STREAM-Köpfe verbunden 72

73 Stream Pipe in BSD/Linux Hier wird nicht das STREAM-Konzept benutzt Eine Stream Pipe kann mit Hilfe zweier UNIX Domain Sockets realisiert werden Sockets werden mit Hilfe des Dateisystems implementiert und sind vergleichbar mit Filedeskriptoren Über int-wert ansprechen Sind aber unterschiedlich (kann Adresse zugewiesen werden etc.) Sockets werden meist für die Kommunikation zwischen Rechnern in einem Netzwerk verwendet Sockets können aber auch für die IPC auf einem lokalen Rechner benutzt werden UNIX Domain Sockets: Sind spezielle Sockets für die Kommunikation auf einem lokalen Rechner Mehr dazu in der LV Rechnernetze (4. Semester) 73