1 Named Pipes alias FIFO Haben einen Eintrag im Dateisystem und sind somit durch Zugriffsrechte identifizierbar Ermöglichen die Kommunikation zwischen völlig Fremden Prozessen Halbduplex wie Pipes -> kein mehrfaches Lesen Erzeugen mit –int mknod(char *pfadname, int mode, int dev); –oder int mkfifo(const char *pfadname, mode_t mode); Owner ID is set to the effective user ID of the process Group ID of the file is set to the group ID of the parent directory if the SetGroupID attribute (S_ISGID) of the parent directory is set. Otherwise, the group ID of the file is set to the effective group ID of the calling process. Permission- und Attribut-Bits werden entsprechend dem Mode-Flag gesetzt. Vorhandene schließen mit unlink("fifo0001");

2 Named Pipes Beispiel: Erzeugen, Schreiben und Lesen 1 #include int main() { int fd_fifo; /*handle for FIFO*/ char puffer[]="This text is for the fifo\n"; char buf[100]; unlink("/tmp/fifo0001.1"); /*We create a FIFO*/ if((mkfifo("/tmp/fifo0001.1", O_RDWR)) == -1) { fprintf(stderr, "Can't creat a fifo \n"); exit(0); } /*We open the fifo for read and write*/ if((fd_fifo=open("/tmp/fifo0001.1", O_RDWR)) == - 1) { fprintf(stderr, "Can't open the fifo.....\n"); exit(0); } write(fd_fifo,puffer,strlen(puffer)) ; if(read(fd_fifo, &buf, sizeof(buf)) == -1) fprintf(stderr, "Error! can't read from FIFO \n"); else printf("read now from FIFO : %s\n",buf); return 0;}

3 Named Pipes Beispiel: Erzeugen, Schreiben und Lesen 2 Mit ls –l kann die für die Named Pipe angelegte Datei angesehen werden: p tot tot 0 Jun 9 11:33 fifo0001|

4 Named Pipes Beispiel: Drucken #include #define BUF 8192 void an_den_drucker(char *text) { FILE *p; /*Pipe zum Tool lpr erstellen zum Schreiben auf lpr*/ p=popen("lpr","w"); if(p == NULL) { fprintf(stderr,"Konnte keine Pipe zu \'lpr\' erstellen!!\n"); exit(0); } /*An den Drucker schreiben*/ printf("Sende Auftrag an den Drucker......\n"); fprintf(p, "%s", text); fflush(p); pclose(p); } int main() { char puffer[BUF], inhalt[BUF]; int fd,n; inhalt[0]='\0'; if(mkfifo("fifo1.1", O_RDWR) < 0){ fprintf(stderr,"Konnte keine FIFO erzeugen!!\n"); exit(0); } /*Empfänger ließt nur aus der FIFO*/ fd=open("fifo1.1", O_RDONLY); if(fd == -1) {perror("open : "); exit(0); } /*Endlosschleife*/ while(1) { if(n=read(fd,puffer,BUF)) an_den_drucker(puffer); sleep(2); } return 0;}

5 Pipes vs. Shared Memory Mit Pipes können sowohl 1:1 als auch 1:n Synchronisationen gemacht werden Mit Shared Memory können m:n Synchronisationen realisiert werden Pipe Zugriffe sind nicht so schnell wie Shared Memory Zugriffe Pipes eignen sich für Prozesskommunikation zwischen verschiedenen Diensten Shared Memory eignet sich besser für schnelle Interaktion zwischen mehreren Prozessen oder Threads

6 Shared Memory und Synchronisation Ein Shared Memory Segment (SMS) ist im Prinzip eine Art globaler Variable zwischen mehreren Prozessen. Bei (pseudo-)parallelen Prozessen kann es jedoch passieren, dass mehrere Prozesse zugleich auf den Speicher schreiben, wodurch es zu einem inkonsistenten Zustand kommen kann. Für Synchronisationen zwischen mehreren Prozessen, die auf ein gemeinsames SMS zugreifen, ist ein Prozesssynchronisationsalgorithmus (Striktes Alternieren, Petersons) nötig, der Zugriffe auf das SMS beschränkend sperrt (sequentialisiert). Wird keine Prozesssynchronisation gemacht, so entstehen bei parallelen Schreibzugriffen auf das SMS inkonsistente Zustände aka Race Conditions (Hackers Liebling ;) In Datenbanken wird das ganze unter Transaktionsmechanismen behandelt.