4. Interprozeßkommunikation in UNIX

Transkript

1 4. Interprozeßkommunikation in UNIX Kommunikation zwischen Unix-Prozessen (System V IPC) Pipes System V IPC Werkzeuge 1. Semaphore 2. Shared Memory 3. Message-Queues Gemeinsame Eigenschaften der System V IPC Werkzeuge Globale, persistente Ressourcen Eigene Datenstrukturen im Kernel Externer, eindeutiger IPC-ID Programmierer ist verantwortlich für die Identifizierung Hilfsbefehle ipcs(8) (provide information on ipc facilities) ipcrm(8) mit ipcrm <msg sem shm> <IPC ID> (will remove the resource speccified by id). Key-Erzeugung: manuell oder via ftok. Bsp. key_t mykey // key_t: Key type mykey = (ftok(".", 1 )) //Pfadname, Projektname Betriebssysteme Harald Kosch Seite 70

2 Semaphore in Linux Eine Semaphor-Datenstruktur speichert immer ein ganzes Semaphor-Array, Warteschlangen und Zeitstempel Ein Semaphor-Array ist definiert als: struct semid_ds struct ipc_perm sem_perm; time_t sem_otime; /*last semop time*/ time_t sem_ctime; /*change time*/ struct wait_queue *eventn; /*Proz. wartend auf V*/ struct wait_queue *eventz; /*Proz. w. auf semval=0*/ struct sem_undo *undo; /*undo entries */ ushort sem_nsems; /*#Semaphore im array */ 100% Ressourcenausnutzung: Wenn alle Wach-Semaphore auf 0 stehen. Entspricht Ereignis eventz im Semaphor Array. Ein Semaphor ist definiert als: struct sem { short sempid; /*pid der letzten Operation*/ ushort semval; /*Semaphorwert*/ ushort semncnt; /*#Proz. wartend auf V*/ ushort semzcnt; /*#Proz. wartend auf semval=0*/ Semaphoroperationen sind definiert als: Betriebssysteme Harald Kosch Seite 71

3 struct sembuf { ushort sem_num; /*Semaphorindex im Array*/ short sem_op ; /* #0: Wert addiert */ /* =0: warte auf semval=0 */ short sem_flg; /*op. Flaggen*/ Bsp.: struct sembuf P_in_mutex = {semid, -1, 0; struct sembuf V_in_mutex = {semid, 1, 0; Operationen (nicht alle) - int semop(int semid, struct sembuf *sops, unsigned nsops) /*Operation auf Sempahore*/ Bsp. if (semop(semid, &P_in_mutex, 1) == -1)... - int semget(key_t key, int nsems, int semflg); - int semctl (int semid, int semnum, int cmd, union semnum arg); Bsp. int createsemaphores(int *sid, int members, key_t k) { union semun sems; /*int val für Op. SETVAL*/ if( (*sid = semget(k, members, IPC_CREAT IPC_EXCL 0660))==-1){return -1; Betriebssysteme Harald Kosch Seite 72

4 sems.val = 1; /*initial value Mutex-Semaphore*/ semctl(*sid, Mutex1, SETVAL, sems); /*mutex*/ semctl(*sid, Mutex2, SETVAL, sems); /*mutex*/ sems.val = 0; /*Anfangswert für gefüllte slots*/ semctl(*sid, NUM_CARDS_SEMAPHORE, SETVAL, sems); semctl(*sid, NUM_LINES_SEMAPHORE, SETVAL, sems); sems.val = MAXELEMENTS; /*initial empty slots*/ semctl(*sid, FREE_CARDS_SEMAPHORE, SETVAL, sems); semctl(*sid, FREE_LINES_SEMAPHORE, SETVAL, sems); return 0; Betriebssysteme Harald Kosch Seite 73

5 #include <unistd.h> #include <sys/ipc.h> #include <sys/sem.h> int semaphore_id; Mutex Semaphore struct sembuf P_mutex = {0,-1,1; struct sembuf V_mutex = {0,1,1; union semun sems; /*= int val bei SETVAL*/ void process() { int i; for(;;) { semop(semaphore_id, &P_mutex, 1); /* Entry protocol */ /* Do something critical */ printf("process_id = %d\n", getpid()); semop(semaphore_id, &V_mutex, 1); /* Exit protocol */ /* Do any noncritical here */ i = sleep(1); void main() { key_t key = ftok(".", 1 ); int members = 1; int i; semaphore_id = semget(key, members, IPC_CREAT 0666); sems.val = 1; semctl(semaphore_id, 0, SETVAL, sems); /* Create 2 child processes */ for( i = 0; i < 2; i++) { if(fork() == 0) process(); Betriebssysteme Harald Kosch Seite 74

6 Endlicher Puffer mit Semaphoren und Shared Memory /* init: Initialize the semaphore-array and the two shared memory areas */ #include <stdio.h> #include "utils.h" void main() { int semid; /* ID of the semaphore-array, not used */ int smemid; /* ID of the shared memory, not used */ if(createsemaphores(&semid, NUMSEMAPHORES, KEY) == -1) exit(-1); if(createsharedmem(&smemid, SIZE, KEY) == -1) exit(-1); if(createsharedmem(&smemid, SIZE, KEY2) == -1) exit(-1); printf("init successful\n"); /* exit: Kill all connected processes and remove the semaphore-array and the shared memory */ #include <stdlib.h> #include "utils.h" void main() { int semid; int smemid; union semun sems; system("killall reader"); system("killall executer"); system("killall printer"); sems.val = 1; attachsemaphores(&semid, NUMSEMAPHORES, KEY); semctl(semid, 0, IPC_RMID, sems); smemid = shmget(key, 0, IPC_CREAT); shmctl(smemid, IPC_RMID, 0); smemid = shmget(key2, 0, IPC_CREAT); shmctl(smemid, IPC_RMID, 0); Betriebssysteme Harald Kosch Seite 75

7 /* reader-process: Read junk from stdin and place it in the shared buffer */ #include <stdio.h> #include "utils.h" int main() { int semaphore_id; /* ID of the semaphore-array */ char *memptr; /* The shared buffer: write */ char *ptr; int num_card; /* Position of a segment in the shared memory */ char string[segsize]; union semun sems; if(attachsemaphores(&semaphore_id, NUMSEMAPHORES, KEY) == -1) exit(-1); /*Verbindung zu Semaphor-Array*/ if( (memptr = attachsharedmem(key)) == NULL) exit(-1); /*Verbindung zu Read-Buffer*/ sems.val = 1; for(;;) { printf(": "); gets(string); /* Read keyboard */ semop(semaphore_id, &P_free_cards, 1); semop(semaphore_id, &P_in_mutex, 1); /* Write the string into the shared memory */ num_card = MAXELEMENTS \ semctl(semaphore_id, FREE_CARDS_SEMAPHORE, GETVAL, sems); ptr = memptr + num_card * SEGSIZE; strcpy(ptr, string); semop(semaphore_id, &V_in_mutex, 1); semop(semaphore_id, &V_num_cards, 1); /* executer-process: Read "strings" from the shared buffer, reverse them and place the result in the 2nd shared buffer */ #include <stdio.h> #include <string.h> #include "utils.h" int main() { int semaphore_id; /* ID of the semaphore-array */ char *memptr_in; /* The first shared buffer: read*/ Betriebssysteme Harald Kosch Seite 76

8 char *memptr_out; /* The second shared buffer: write */ char *ptr; char *rsptr; int num_card; /* Number of the segment for reading */ int num_line; /* Number of the segment for writing */ char string[segsize]; char reverse_string[segsize]; union semun sems; if(attachsemaphores(&semaphore_id, NUMSEMAPHORES, KEY) == -1) exit(-1); if( (memptr_in = attachsharedmem(key)) == NULL) exit(-1); if( (memptr_out = attachsharedmem(key2)) == NULL) exit(-1); sems.val = 1; for(;;) { semop(semaphore_id, &P_num_cards, 1); semop(semaphore_id, &P_in_mutex, 1); /* Read a segment from the first shared buffer */ num_card = semctl(semaphore_id, NUM_CARDS_SEMAPHORE, GETVAL, sems); ptr = memptr_in + num_card * SEGSIZE; strcpy(string, ptr); strcpy(ptr, "X"); semop(semaphore_id, &V_in_mutex, 1); semop(semaphore_id, &V_free_cards, 1); /* Reverse the string */ ptr = string + strlen(string) - 1; rsptr = reverse_string; while(ptr >= string) { *rsptr++ = *ptr--; *rsptr = \0 ; semop(semaphore_id, &P_free_lines, 1); semop(semaphore_id, &P_out_mutex, 1); /* Write the reversed string into a segment of the second shared memory */ num_line = MAXELEMENTS \ semctl(semaphore_id, FREE_LINES_SEMAPHORE, GETVAL, sems); ptr = memptr_out + num_line * SEGSIZE; strcpy(ptr, reverse_string); semop(semaphore_id, &V_out_mutex, 1); semop(semaphore_id, &V_num_lines, 1); Betriebssysteme Harald Kosch Seite 77

9 /* printer-process: Read a "string from the shared buffer an print it to stdout */ #include <stdio.h> #include "utils.h" int main() { int semaphore_id; /* ID of the semaphore-array */ char *memptr; /* The shared buffer: read */ char *ptr; int num_line; /* The number of a segment in the shared buffer */ char string[segsize]; union semun sems; if(attachsemaphores(&semaphore_id, NUMSEMAPHORES, KEY) == -1) exit(-1); if( (memptr = attachsharedmem(key2)) == NULL) exit(-1); sems.val = 1; for(;;) { semop(semaphore_id, &P_num_lines, 1); semop(semaphore_id, &P_out_mutex, 1); /* Read a segment from the shared memory */ num_line = semctl(semaphore_id, NUM_LINES_SEMAPHORE, GETVAL, sems); ptr = memptr + num_line * SEGSIZE; strcpy(string, ptr); strcpy(ptr, "X"); semop(semaphore_id, &V_out_mutex, 1); semop(semaphore_id, &V_free_lines, 1); /* Print */ printf("> %s\n", string); /* utils.h */ #include <sys/ipc.h> #include <sys/sem.h> #include <sys/shm.h> #define NUMSEMAPHORES 6 /* 6 semaphores, 2 for mutual exclusion, the rest as counters*/ #define SEGSIZE 80 Betriebssysteme Harald Kosch Seite 78

10 #define MAXELEMENTS 10 #define SIZE (MAXELEMENTS * SEGSIZE) #define KEY (ftok(".", 1 )) #define KEY2 (ftok(".", 2 )) #define Mutex1 0 #define Mutex2 3 #define FREE_CARDS_SEMAPHORE 1 #define NUM_CARDS_SEMAPHORE 2 #define NUM_LINES_SEMAPHORE 4 #define FREE_LINES_SEMAPHORE 5 extern struct sembuf P_in_mutex; extern struct sembuf V_in_mutex; extern struct sembuf P_out_mutex; extern struct sembuf V_out_mutex; extern struct sembuf P_free_cards; extern struct sembuf V_free_cards; extern struct sembuf P_num_cards; extern struct sembuf V_num_cards; extern struct sembuf P_num_lines; extern struct sembuf V_num_lines; extern struct sembuf P_free_lines; extern struct sembuf V_free_lines; int createsemaphores(int *sid, int members, key_t k); int attachsemaphores(int *sid, int members, key_t k); int createsharedmem(int *smemid, int size, key_t k); char *attachsharedmem(key_t k); /* utils.c */ #include "utils.h" #include <stdio.h> struct sembuf P_in_mutex = {Mutex1, -1, 0; struct sembuf V_in_mutex = {Mutex1, 1, 0; struct sembuf P_out_mutex = {Mutex2, -1, 0; struct sembuf V_out_mutex = {Mutex2, 1, 0; struct sembuf P_num_cards = {NUM_CARDS_SEMAPHORE, -1, 0; struct sembuf V_num_cards = {NUM_CARDS_SEMAPHORE, 1, 0; struct sembuf P_free_cards = {FREE_CARDS_SEMAPHORE, -1, 0; struct sembuf V_free_cards = {FREE_CARDS_SEMAPHORE, 1, 0; struct sembuf P_num_lines = {NUM_LINES_SEMAPHORE, -1, 0; struct sembuf V_num_lines = {NUM_LINES_SEMAPHORE, 1, 0; struct sembuf P_free_lines = {FREE_LINES_SEMAPHORE, -1, 0; Betriebssysteme Harald Kosch Seite 79

11 struct sembuf V_free_lines = {FREE_LINES_SEMAPHORE, 1, 0; int createsemaphores(int *sid, int members, key_t k) { union semun sems; if( (*sid = semget(k, members, IPC_CREAT IPC_EXCL 0666)) == -1) { return -1; sems.val = 1; semctl(*sid, Mutex1, SETVAL, sems); /* Used for mutual exclusion */ semctl(*sid, Mutex2, SETVAL, sems); sems.val = 0; semctl(*sid, NUM_CARDS_SEMAPHORE, SETVAL, sems); semctl(*sid, NUM_LINES_SEMAPHORE, SETVAL, sems); sems.val = MAXELEMENTS; semctl(*sid, FREE_CARDS_SEMAPHORE, SETVAL, sems); semctl(*sid, FREE_LINES_SEMAPHORE, SETVAL, sems); return 0; int attachsemaphores(int *sid, int members, key_t k) { if( (*sid = semget(k, members, 0)) == -1) { perror("semget failed\n"); return -1; return 0; int createsharedmem(int *smemid, int size, key_t k) { if( (*smemid = shmget(k, size, IPC_CREAT IPC_EXCL 0666)) == -1) { perror("shmget failed\n"); return -1; return 0; char *attachsharedmem(key_t k) { int sharedmem_id; if( (sharedmem_id = shmget(k, SIZE, 0)) == -1) { perror("shmget failed\n"); return NULL; return (shmat(sharedmem_id, 0,0)); /*map memory*/ Betriebssysteme Harald Kosch Seite 80

12 #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <sys/sem.h> #define NUMBER_PHILOSOPHERS 5 int fork_id, room_id; struct sembuf P_ROOM = {0, -1, 1; struct sembuf V_ROOM = {0, 1, 1; union semun value; Speisende Philosophen void philosopher(int i) { struct sembuf P_FORK = {i, -1, 1; struct sembuf P_FORKLEFT = {(i+1) % NUMBER_PHILOSOPHERS, -1,1; struct sembuf V_FORK = {i, 1, 1; struct sembuf V_FORKLEFT = {(i+1) % NUMBER_PHILOSOPHERS, 1, 1; for(;;) { sleep(rand() / (RAND_MAX / 5)); /* Think :-) */ semop(room_id, &P_ROOM, 1); semop(fork_id, &P_FORK, 1); semop(fork_id, &P_FORKLEFT, 1); printf("philosopher %d is eating\n", i); semop(fork_id, &V_FORK, 1); semop(fork_id, &V_FORKLEFT, 1); semop(room_id, &V_ROOM, 1); printf("philosopher %d is thinking\n", i); void main() { int i; /* Create 5 binary semaphores for the forks */ fork_id = semget((ftok(".", 1 )), NUMBER_PHILOSOPHERS, IPC_CREAT 0666); /* Create a semaphore to count the number of philosophers in the room */ room_id = semget((ftok(".", 2 )), 1, IPC_CREAT 0666); value.val = NUMBER_PHILOSOPHERS - 1; semctl(room_id, 0, SETVAL, value); value.val = 1; for(i = 0; i < NUMBER_PHILOSOPHERS; i++) { semctl(fork_id, i, SETVAL, value); if( fork() == 0) philosopher(i); Betriebssysteme Harald Kosch Seite 81

13 Kooperation durch Message Passing Prozesse kommunizieren via Kanäle (kein gemeinsamer Speicher) Kanäle können Byteströme sequentiell übertragen Grundoperationen: send, receive send(destination, message) receive(source,message) Das Senden und Empfangen über Kanäle ist sehr ähnlich zum Schreiben und Lesen auf Dateien Synchronisierung: Send: blockierend, nicht blockierend. Receive: blockierend, nicht blockierend, Eingangstest. Rendez-vous heißt eine Ereignis wenn sowohl der Sende als auch Empfangsprozeß blockierend ist. Unix Pipes: Temporäre Spezialfiles, die Prozesse verbinden, nur in eine Richtung verwendbar. ls sort more ls : ls->sort->more Vater Prozess Kernel Kind Prozess Figure 13: Verbindung von Prozessen durch Pipes Betriebssysteme Harald Kosch Seite 82

14 Alternative Begriffe für Kanal: mailbox (n:m) (System V IPC) port (n:1) (BSD sockets) link (1:1) (UNIX Pipes) Figure 14: Aus: Stallings, Operating Systems Betriebssysteme Harald Kosch Seite 83

15 Message Passing in UNIX via Pipes #include <sys/types.h> #include <sys/wait.h> #include <syscall.h> #include <stdio.h> #include <unistd.h> #define MSGSIZE 16 char *msg1 = "Hello world #1"; char *msg2 = "Hello world #2"; char *msg3 = "hello world #3"; void main() { char inbuf[msgsize]; int p[2], j; pid_t pid; /*p wird als pipe eröffnet*/ if(-1 == pipe(p)) { perror("pipe call"); exit(-1); if(-1 == (pid = fork())) { perror("fork call"); exit(-1); if(0 == pid) { /*Kind liest vom Vater*/ for(j = 0; j < 3; j++) { read(p[0], inbuf, MSGSIZE); /*p[0]: Inputkanal*/ printf("%s\n", inbuf); else { /*Vater sendet dem Kind*/ write(p[1], msg1, MSGSIZE); /*p[1]: Outputkanal*/ write(p[1], msg2, MSGSIZE); write(p[1], msg3, MSGSIZE); wait( (int *) 0); exit(0); Betriebssysteme Harald Kosch Seite 84

16 Halfduplex Pipes #include <sys/types.h> #include <sys/wait.h> #include <syscall.h> #include <stdio.h> #include <unistd.h> #define MSGSIZE 16 char *msg1 = "Hello world #1"; char *msg2 = "Hello world #2"; char *msg3 = "hello world #3"; void main() { char inbuf[msgsize]; int p[2], j; pid_t pid; if(-1 == pipe(p)) { perror("pipe call"); exit(-1); if(-1 == (pid = fork())) { perror("fork call"); exit(-1); if(0 == pid) { /* child: close write descriptor and read from pipe */ close(p[1]); for(j = 0; j < 3; j++) { read(p[0], inbuf, MSGSIZE); printf("%s\n", inbuf); else { /* parent: close read descriptor and write down pipe */ close(p[0]); write(p[1], msg1, MSGSIZE); write(p[1], msg2, MSGSIZE); write(p[1], msg3, MSGSIZE); wait( (int *) 0); exit(0); Betriebssysteme Harald Kosch Seite 85

17 Signale Signalisieren Ereignisse für einen Prozeß Kein sicherer Mechanismus (in 4.2BSD und SVR4 besser) Signale können bei einem Ereignis (z.b. Division durch 0) generiert werden (kill) Ursprünglicher Zweck: Terminierung (wie der Name zeigt) Ziemlich Unix-Verisonsabhängig (trotz POSIX) Ähnlich zu exceptions Signale können durch signal handlers aufgefangen und behandelt werden Für Signale ohne Benutzer-Handler gibt es eine default Aktion in Bezug auf den betroffenen Prozeß abort terminiert + core dump exit terminiert ohne core dump ignore schluckt das Signal stop blockiert den Prozess (suspend) continue fährt blockierten Prozess fort Signal handlers (gewöhnliche Prozeduren) müssen als solche registriert werden (signal) Beim Auftreten des Signals wird die normale Ausführung der Befehlssequenz unterbrochen, und der Handler wird asynchron aufgerufen Betriebssysteme Harald Kosch Seite 86

18 Beispiel für Signale #include <signal.h> /* static void sig_handler(int); */ static void sig_handler(int signo) { switch(signo) { case SIGUSR1: /*Incoming SIGUSR1 signal*/ printf("parent: Received %d\n",sigusr1); break; case SIGUSR2: /*Incoming SIGUSR2 signal*/ printf("child: Received %d\n", SIGUSR2); break; default: break; /*Should never get this case*/ main(void) { int i, parent_pid, child_pid, status; if (signal(sigusr1, sig_handler)!= SIG_ERR) printf("parent: Handler created for %d\n", SIGUSR1); if (signal(sigusr2, sig_handler)!= SIG_ERR) printf("parent: Handler created for %d\n", SIGUSR2); parent_pid = getpid(); if ((child_pid = fork()) == 0) { kill(parent_pid, SIGUSR1); /*Child raising SIGUSR1*/ for (;;) pause(); /*Child busy waiting for a signal*/ else { kill(child_pid, SIGUSR2); /* Parent raising SIGUSR2 */ pause(2); /*Race condition: not to kill child too soon*/ printf("terminating child..."); kill(child_pid, SIGTERM); /*Parent raising SIGTERM*/ wait(&status); /*Parent waiting child fot termination*/ printf("done\n"); Betriebssysteme Harald Kosch Seite 87

19 Gebräuchliche Signale in UNIX Name Num Default Action Description SIGHUP 1 terminate process terminal line hangup SIGINT 2 terminate process interrupt program SIGQUIT 3 create core image quit program SIGKILL 9 terminate process kill process unconditionally and immed. SIGTERM 15 terminate process software termination signal asks program to quit gracefully if poss. SIGSTOP 17 stop process stop process unconditionally and immed. this signal cannot be ignored - CONT SIGTSTP 18 stop process stop keyboard signal can be continued with CONT SIGCONT 19 discard signal continue after stop Use the kill command with the -l option to see a list of all signals supported on your system. For example, $ kill -l HUP INT QUIT... Users generally send signals via the keyboard or the kill command. For example: CTRL-c SIGINT 2 CTRL-\ SIGQUIT 3 CTRL-z SIGTSP 18 The kill command sends a signal to a process. kill -SIG ID SIG can be a signal name or signal number. ID is a process ID (PID). On some systems, ID can also be a job ID. Betriebssysteme Harald Kosch Seite 88

20 Probleme mit Signalen Schlafende Prozesse Es ist nicht gleich, ob ein Prozess auf einen disk I/O (endet bald) oder auf die Tastatur (endet vielleicht nie) wartet Uninterruptable sleep: Das Signal wird erst später vermittelt (z.b. disk I/O) Interruptable sleep: Der Prozess wird erweckt durchs Signal (z.b. beim Warten auf Tastatur (oder Godot)) Unreliable Signals (SVR2 und noch früher) Signal-Information in u-area: Prozess muß auch dann erweckt werden, wenn er das Signal ignoriert Vor dem Aufruf des Handlers wird die default-aktion zurückgesetzt um eine unendliche Reihe von Signalen zu hindern. Signale können verloren gehen (race condition) Handler müssen wiederholt registriert werden Reliable Signals (4.2BSD, SVR4, POSIX) Persistente Handlers bleiben immer installiert Masking Signal wird temporär zurückgehalten Wichtigste Signal-Information in proc-area sigpause Explizites Warten auf Signale Implementierungen oft unterschiedlich: Vorsicht! Betriebssysteme Harald Kosch Seite 89

21 SYSTEM V Message Queues #include <sys/types.h> #include <sys/msg.h> #include <sys/ipc.h> #include <stdio.h> #include <unistd.h> #define MSGSIZE 80 int msqid; /* Message queue identifier */ struct my_msgbuf { /* Our messages have that look */ long mtype; char message[80]; /* The real message-text */ ; /* Remove the message queue from the kernel */ void killmsgbuf() { msgctl(msqid, IPC_RMID, 0); /* Read junk from stdin and place it in the message queue */ void producer() { struct my_msgbuf pmbuf; pmbuf.mtype = 1; for(;;) { printf(": "); gets(pmbuf.message); if(0 == strcmp("end", pmbuf.message)) { /* Tell consumer that we wish to end the show now */ msgsnd(msqid, &pmbuf, MSGSIZE, 0); break; /* Messages may be lost if the message queue is full! */ if( -1 == (msgsnd(msqid, &pmbuf, MSGSIZE, IPC_NOWAIT))) perror("\nmessage NOT delivered!\n"); Betriebssysteme Harald Kosch Seite 90

22 /* Read messages from the queue and write them into a file */ void consumer() { struct my_msgbuf cmbuf; FILE *fd; fd = fopen("consumer.out", "w"); for(;;) { msgrcv(msqid, &cmbuf, MSGSIZE, 0, 0); if( 0 == (strcmp("end", cmbuf.message ))) { /* consumer has to kill the message buffer because he is the last who will access it */ killmsgbuf(); fclose(fd); break; fprintf(fd, "%s\n", cmbuf.message); /* Start the ball rolling */ void main() { if (-1 == (msqid = msgget( (ftok(".", 1 )), IPC_CREAT 0666))) { perror("msgget"); exit(-1); if( 0 == (fork()) ) { consumer(); else { producer(); exit(0); Im Prinzip ähnlich zu Pipes Konzept ist durchgängig Viel mehr Dienstleistungen Betriebssysteme Harald Kosch Seite 91