Beispiel Block 2 Stream I/O Parallele Prozesse: fork, exec und wait Interprozesskommunika>on mit Unnamed Pipes. Benedikt Huber WS 2011/2012

Transkript

1 Beispiel Block 2 Stream I/O Parallele Prozesse: fork, exec und wait Interprozesskommunika>on mit Unnamed Pipes Benedikt Huber WS 2011/2012 1

2 Stream I/O Portable Ein/Ausgabe API (gepuffert) 2

3 Aufbau des Dateisystems (Linux) Hierarchische Struktur von Dateien Verschiedenste Dateitypen in einer gemeinsamen Verzeichnisstruktur: everything is a file /bin /dev /etc /usr /var commands devices startup and configura>on files /lib /man /local / plain files (stream of characters) directories (Interpreta>on durch das OS) character, block special files (Geräte; z.b. Terminal, FestplaVe) named pipes sockets (z.b. TCP/IP sockets, UNIX domain sockets) symbolic links (Verweise)

4 Mounten von Dateisystemen Zusammenfassen mehrerer File Systeme in einer Verzeichnisstruktur Eingebundenes Dateisystem ist entweder: lokal verfügbar (z.b. untersch. Par>>on oder FestplaVe, Wechseldatenträger), verfügbar via Netzwerk (z.b. über NFS), oder befindet sich selbst in einem File (z.b. loop device für ISO Images) Vorteil: untersch. Filesysteme gleichzei>g verwendbar

5 Virtuelles Filesystem (VFS) > 15 physikalische Filesysteme unter Linux in Verwendung Kompa>bilität zu anderen Systemen (z.b. NTFS, FAT) Sicherheit, Zuverlässigkeit der Daten (z.b. Ext3, ReiserFS) Performance (z.b. XFS) Einführung einer zusätzlichen Abstrak>onsebene einheitliche SchniVstelle transparentes Mounten verschiedener physikalischer Dateisysteme (Par>>onen) in eine Directory Struktur

6 File Descriptors Verweis auf Eintrag in Tabelle offener Dateien (file descriptor table, Teil des aktuellen Prozesses) Standard I/O STDIN_FILENO = 0 (Standardeingabe) STDOUT_FILENO = 1 (Standardausgabe) STDERR_FILENO = 2 (Fehlerausgabe) Siehe auch: fileno(stdin), fileno(stdout),... Funk>onen: open(2), close(2), read(2), write(2),... 6

7 Stream IO in C Stream IO baut auf File Deskriptoren auf #include <stdio.h> Stream Datentyp: FILE Gepuffert (siehe fflush(3)) Konven>on: Befehle beginnen mit f fopen(3), fdopen(3), fwrite(3), fprin7(3), stdin, stdout, stderr sind vordefinierte Streams S t r eam I O Puf f er IO OS 7

8 fopen(3) FILE *fopen(const char *path, const char *mode); Die Datei path wird geöffnet, und mit Stream (Rückgabewert) verbunden mode: r nur lesen w nur schreiben (exis>erenden Inhalt löschen) a nur schreiben (am Ende anhängen) r+ / w+ / a+ lesen und schreiben 8

9 fdopen(3) FILE *fdopen(int fildes, const char *mode); Assoziiert einen Stream mit einem Filedescriptor FILE* f; int fd; int fd = socket(af_inet, SOCK_STREAM,0); f = fdopen(fd, r+ ); fprintf(f, Meine Prozess ID ist: %d\n, getpid()); 9

10 fflush(3), fclose(3) int fflush(file *stream); int fclose(file *stream); fflush erzwingt das Schreiben von gepufferten Daten fclose run fflush auf und schließt den Stream sowie den zugrundeliegenden Deskriptor. 10

11 Lesen/Schreiben Funk=on fread fgets fgetc fwrite fputs fprinp fputc fseek Lesen von n Elementen a size Bytes Lesen einer Zeile Lesen eines Zeichens Schreiben von n Elementen a size Bytes Schreiben eines C Strings Forma>ertes Schreiben Schreiben eines Zeichens Posi>onieren des Dateiposi>onszeigers 11

12 ferror(3), feof(3) int ferror(file *stream); int feof(file *stream); int clearerr(file *stream); ferror ergibt den Fehlerstatus des Streams zurück (0 ~ error flag nicht gesetzt). feof fragt ab, ob das End Of File Flag des Streams gesetzt ist (wird beispielsweise von fgets gesetzt, wenn das Ende der Datei erreicht wird) clearerr löscht Fehlerstatus und EOF Flag 12

13 Stream I/O Beispiel #define SIZE 512 int main(int argc, char **argv) { char buffer[size]; FILE *f; f = fopen(argv[1], r ); while (fgets(buffer,size,f)!= NULL) { fputs(buffer,stdout); } if (ferror(f)) { bail_out( IO Error ); } return 0; } 13

14 fork, exec und wait Prozess erzeugen / Programm ersetzen 14

15 Prozesseigenschanen Linux (1) Zustand Running, Stopped, Scheduling Iden>fika>on Speicherverwaltung Signale Priorität, CPU Zeit, PID, Owner, Gruppe, Pointer auf MMU Info Mask, Pending Prozessverwandschanen Parents, Siblings

16 Prozesseigenschaften Linux (2) Process Control Block Register, PC, Statuswort, Segmentregister, Page Table Info Kernelstack Dateideskriptorentabelle Berech>gungen, Accoun>ng Informa>on Timerverwaltung Interprozesskommunika>on Siehe: sched.h / struct task_struct UNIX Mechanismen 16

17 Prozesshierarchie Jeder Prozess hat Vaterprozess Ausnahme: init Jeder Prozess hat eine eindeutige ID (pid_t) init acpid ahc_dv_0 ahc_dv_1 bash clock-applet crond cups-config-dae cupsd 2*[dbus-daemon-1] dbus-launch dhcpd gdm-binary gdm-binary X gdmgreeter gdm-binary... 2*[sendmail] sesam_server sesam_server sesam_server... smbd 5*[smbd] sshd sshd sshd bash pine.. sshd sshd bash pine 17

18 Erstellen von Prozessen Prozesse werden üblicherweise mit fork(2) erzeugt. Weitere Möglichkeiten clone(2), vfork(2) In der Übung ist ausschließlich fork(2) zu verwenden exec(3) überschreibt den aktuellen Prozess durch ein anderes Programm. wait(3) wartet auf die Terminierung eines Kindes 18

19 fork() / exec() / wait() fork() erzeugt neuen Prozess exec*( program ) ersetzt image eines Prozesses durch neues Programm exit(status) Beendet Prozess wait*(&status) wartet auf Beendigung des Kindprozesses f or k parent wait i ni t i al i z e c hi l d c ont ex t f or k child ex it ex ec 19

20 fork() f or k parent f or k child Erzeugt einen neuen Prozess Neuer Prozess ist eine iden>sche Kopie des aufrufenden Prozesses (bis auf PID, Locks,...) Erzeugender Prozess ist Vater des erzeugten Prozesses Beide Prozesse laufen parallel und führen dasselbe Programm aus wait i ni t i al i z e c hi l d c ont ex t ex it ex ec 20

21 fork() Vaterprozess npi D = f or k ( ) P C Vor dem fork Nach dem fork Vaterprozess K indprozess npi D = f or k ( ) P C npi D = f or k ( ) P C 21

22 fork() Unterscheidung zwischen Vater und Kindprozess durch den Rückgabewert von fork(): 1 im Fehlerfall 0 im Kindprozess (child) >0 im aufrufenden Prozess (parent) 22

23 fork() Kindprozess erbt von Elternprozess offene Dateien (gemeinsamer Zugriff!) Dateipuffer Signaldefinitionen momentane Variablenwerte Jedoch gilt: Variablen sind lokal (keine Beeinflussung) Signale können lokal umgesetzt werden Kommunikation (IPC) via Pipes, Sockets, Shared Memory,... 23

24 C-Interface #include <sys/types.h> #include <unistd.h> pid_t fork(void); 24

25 Verwendung von fork() pid_t pid;... switch (pid= fork()) { case 1: bail_out( can t fork ); break; case 0: /* child: ChildProcess() */... exit(exit_success); break; default: /* parent: ParentProcess() */... break; } 25

26 clone(2), vfork(2) clone() wird von fork(2), vfork(2) aufgerufen. clone() erlaubt Kontrolle über die zu duplizierenden Eigenschanen (Linux spezifisch, nicht portabel!) fork() alles wird dupliziert vfork() nichts wird dupliziert, das Kind darf keine Variablen mehr ändern, und nur noch exec() ausführen. clone(), vfork() ist kein Teil des Stoffes! 26

27 exec() f or k parent f or k child Erlaubt es einem Prozess, ein anderes Programm auszuführen Startet ein neues Programm innerhalb eines Prozesses PID bleibt gleich i ni t i al i z e c hi l d c ont ex t ex ec wait ex it 27

28 Die exec() Familie (1) int execl(const char *path, const char *arg,...); int execlp(const char *file, const char *arg,...); int execle(const char *path, const char *arg,..., char * const envp[]); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]); int fexecve(int fd, char *const argv[], char *const envp[]); 28

29 Die exec() Familie (2) Ersetzt aktuelles Programm durch das in der Datei path enthaltene exec*p Variante sucht (wie Shell) in $PATH nach Programm mit dem spezifierten Namen Argumentübergabe beachten! Argumentliste muss mit NULL Zeiger enden Varianten mit variable Argumentanzahl (execl*) und Argumentarray (execv*) Variante execle: Environment kann verändert werden Variante fexecve: akzep>ert Dateideskriptor 29

30 execl(), execlp() #include <unistd.h> int execv(char *path, char *argv[] ); int execvp(char *filename, char *argv[] ); char *cmd[] = { "ls", " l", (char *) 0 }; (void) execv ("/bin/ls", cmd); (void) execvp ("ls", cmd); bail_out ( can t exec ); 30

31 execl(), execlp() #include <unistd.h> int execl(char *path, char *arg0,..., char *arg_n,(char*)0); int execlp(char *filename, char *arg0,..., char *arg_n, (char*)0); (void) execl ( /bin/ls, ls, l, (char*) 0 ); (void) execlp ( ls, ls, l, (char*) 0 ); bail_out ( can t exec ); 31

32 wait() f or k parent f or k child Wartet bis Kindprozess terminiert Liefert PID des terminierten Prozesses Wenn kein Kindprozess exis>ert, 1 als Rückgabewert (auch bei EINTR) i ni t i al i z e c hi l d c ont ex t ex ec wait ex it 32

33 exit() Terminiert den aktuellen Prozess void exit(int status); exit(exit_success) keine Fehler exit(exit_failure) Fehler aufgetreten 33

34 wait() Liefert Status des terminierten Kindprozesses wait(&status) Es immer notwendig auf Terminierung des Kindes zu warten unter UNIX besetzen auch bereits terminierte Prozesse einen Eintrag in der Prozesstabelle falls kein Platz mehr frei ist, kann kein neuer Prozess mehr gestartet werden 34

35 C-Interface Stoppt Prozessausführung bis entweder Kindprozess terminiert oder ein Fehler auftritt ( busy waiting). #include <sys/wait.h> pid_t wait ( int * status ); int status; pid_t child_pid, pid;... while ((pid = wait(&status))!= child_pid ) { if (pid!= 1) continue; /* other child */ if (errno == EINTR) continue; /* interrupted */ bail_out( can t wait, 1 ); } if (WEXITSTATUS(status) == EXIT_SUCCESS )... 35

36 waitpid(): verwandter Call to wait() Warten auf das Terminieren eines Prozesses mit einer bes>mmten Prozess Id: pid_t waitpid (pid_t pid, int *status, int options ); waitpid( 1,&status,0) äquivalent zu wait waitpid(pid, &status, 0) wartet auf Kind mit PID pid waitpid( 1,&status, WNOHANG) blockiert nicht. 36

37 Zombies und exit() Der Kindprozess terminiert und der Vaterprozess hat noch nicht wait ausgeführt Der Kindprozess wird auf Zustand Zombie gesetzt Eintrag in der Prozesstabelle bleibt erhalten bis der Vaterprozess wait ausführt Der Vaterprozess terminiert und der Kindprozess läun immer noch Kindprozesse werden dem INIT Prozess vererbt 37

38 Wurde ein Kind beendet? waitpid(-1,&status, WNOHANG) Blockiert nicht, holt Exit-Status falls ein Kind beendet wurde. (Polling) Eleganter: Wenn ein Kind beendet wurde wird das Signal SIGCHLD an den Elternprozess gesendet. signal(sigchld, chterm); void chterm(int sig) { wait( ); } 38

39 Fallstricke int main( ) { fprintf(stdout, Hallo ); fork(); return 0; } Ausgabe: HalloHallo Warum? 39

40 Fallstricke S t r eam I O H allo IO int main( ) { fprintf(stdout, Hallo ); fork(); return 0; } S t r eam I O H allo IO OS fork S t r eam I O H allo IO Ausgabe: HalloHallo Warum? OS 40

41 Fallstricke S t r eam I O <empt H allo y> IO int main( ) { OS fprintf(stdout, Hallo ); fork fflush(stdout); S t r eam I O S t r eam I O fork(); <empt H allo y> <empt H allo y> } return 0; IO IO Ausgabe: Hallo OS 41

42 Rückblende fork() - Kindprozess erzeugen exec() - neues Programm innerhalb eines Prozesses starten exit() den aktuellen Prozess beenden wait() - im Vaterprozess auf die Terminierung des Kindprozesses warten 42

43 Unnamed Pipes pipe() und dup() 43

44 Pipes Kommunikationskanal zwischen verwandten Prozessen Eigenschaften: Unidirektional (2 Pipes für Übertragung in beide Richtungen) Stream von Daten Implizite Synchronisation 44

45 Verwendung von Pipes (1) Pipe wird mittels eines Feldes von zwei Integer- Elementen deklariert int fildes[2]; Deskriptor fildes[0] ist Leseende Deskriptor fildes[1] ist Schreibende Nicht verwendete Enden müssen geschlossen werden Schreibender Prozess schließt das Leseende Lesender Prozess schließt das Schreibende 45

46 Verwendung von Pipes (1) P rozess wr i t e( ) p[ 1] ohne geschlossene Enden r ead( ) p[ 0] K indprozess Vaterprozess wr i t e( ) r ead( ) p[ 1] p[ 0] p[ 1] p[ 0] wr i t e( ) r ead( ) 46

47 Verwendung von Pipes (1) geschlossene Enden K indprozess Vaterprozess wr i t e( ) r ead( ) p[ 1] wr i t e( ) p[ 0] r ead( ) 47

48 Verwendung von Pipes (2) Öffnen einer Pipe mittels Systemaufruf pipe() fdopen() erstellt einen mit dem gegebenen Filedeskriptor assozierten Stream (FILE *) Verwendung von Funktionen, die auf Streams operieren z.b. fopen(), fclose() fclose() dup2() kann zum Umlenken von Dateien verwendet werden 48

49 C-Interface #include <limits.h> /* for PIPE_BUF */ #include <unistd.h> /* prototype */ int fildes[2]; if (pipe(fildes)!= 0) { bail_out( can t create pipe, 1 ); } 49

50 dup(2), dup2(2) dup() dupliziert einen File-Deskriptor. Der neue Deskriptor hat die niedrigste nicht verwendete ID dup2(old,new) Schließt Filedeskriptor mit ID new Dupliziert old, der neue Deskriptor erhält ID new 50

51 Umleiten der Standardein/ausgabe Anwendung: Kommunikation mit Kommandozeilen-Utility, welches über Standardeingabe / Standardausgabe kommuniziert Strategie: Umleiten der Standardeingabe (0) oder Standardausgabe (1) in neuem Prozess Schließen des Filedeskriptors (z.b. fileno(stdin)) für Standard I/O Duplizieren eines offenen FDs (z.b. file_descr[0]) auf eben geschlossenen (fileno(stdin)) Schließen des duplizierten FDs (file_descr[0]) 51

52 C-Interface #include <fcntl.h> #include <sys/types.h> #include <unistd.h> int fd; fd = open( log.txt,o_wronly O_CREAT); dup2(fd, /* old descriptor */ fileno(stdout)); /* new descriptor */ close(fd); /* close old desc. */ (void) execlp( grep, grep, max, (char *) 0); 52

53 Synchronisation Lesen von leerer Pipe ist blockierend Schreiben auf volle Pipe ebenso Achtung: Blockiert wenn vergessen Pipe zu schließen Lesen von Pipe ohne offene Schreibenden liefert EOF Schreiben auf Pipe ohne offene Leseenden liefert SIGPIPE Signal 53

54 Pipes: Pitfalls Pipes eignen sich gut für unidirektionale Kommunikation Bidirektional: Zwei Pipes Fehleranfällige Synchronisation (deadlock) Synchronisation & Puffer fflush() verwenden Puffer konfigurieren (setbuf(3), setvbuf(3)) 54

55 Rückblende Kommunikation zwischen verwandten Prozessen mittels Pipes. Implizite Synchronisation Nicht verwendete Enden schließen Filestream für Filedeskriptor der Pipe mittels fdopen() Umlenken von Pipes mittels dup2() 55

56 ENDE Danke für die Aufmerksamkeit! Block zum 2.Übungsbeispiel 56