Tafelübung zu BS 5. Dateioperationen

Transkript

1 Tafelübung zu BS 5. Dateioperationen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund 1

2 Agenda Besprechung Aufgabe 4: Interprozesskommunikation Systemcalls unter Linux: Wie funktioniert das eigentlich? Arbeiten mit Dateien Low-Level Dateioperationen High-Level Dateioperationen - Schreiben und Lesen - Schreibe/Lese-Position - Fehlerbehandlung High-Level Verzeichnisoperationen BS: U5 Dateioperationen 2

3 Besprechung Aufgabe 4 Foliensatz Besprechung BS: U5 Dateioperationen 3

4 Systemaufrufe durch Programme Systemaufruf = Aufruf von Funktionen, die das Betriebssystem zur Verfügung stellt Zugriffe auf angeschlossene Hardware Funktionen zur Speicherverwaltung Funktionen zur Prozessverwaltung Syscalls: Funktionen, die nur in einem privilegierten Modus ausgeführt werden können, d.h. mit erweiterten Rechten Linux: Aufteilung in User- und Kernelspace Problem: Ein einfacher Funktionsaufruf in die Kernelfunktionen ist nicht möglich Ein fehlerhaftes Anwendungsprogramm könnte das System zum Absturz bringen Jedes Anwendungsprogramm hätte volle Zugriffsrechte z.b. Scheduling und Rechteverwaltung BS: U5 Dateioperationen 4

5 Linux-Systemcalls (hier für x86) Einzige Möglichkeit für Userspace-Programme auf Kernelspace-Funktionen zuzugreifen Jedem Systemcall ist eine eindeutige Nummer zugeordnet arch/x86/kernel/syscall_table_32.s ENTRY(sys_call_table).long sys_restart_syscall /* 0 */.long sys_exit /* 1 */.long sys_fork /* 2 */.long sys_read /* 3 */.long sys_write /* 4 */.long sys_open /* 5 */... Direkter Aufruf von Systemcalls z.b. per syscall(2) #define _GNU_SOURCE #include <unistd.h> #include <sys/syscall.h> /* hier wird SYS_read=3 definiert */ #include <sys/types.h> int main(int argc, char *argv[]) {... syscall(sys_read, fd, &buffer, nbytes); /* read(fd, &buffer, nbytes) */ return 0; } BS: U5 Dateioperationen 5

6 Systemstruktur Applikation read() Applikation Applikation... Userspace libc Systemcall Schnittstelle Kernel Subsysteme Kernelspace Gerätetreiber Hardware BS: U5 Dateioperationen 6

7 Ablauf eines Systemcalls 1) Argumente Stack (Konvention: Letztes zuerst) 2) Aufruf der Bibliotheksfunktion (Implizit: push Rücksprungadresse) 3) Argumente in Register laden (Stack für User und Kernel versch.) 4) Interrupt auslösen 5) Interruptnummer Index in Tabelle, hält Adressen der Zielfunktionen 6) Zielfunktion wählt mit eax Funktion aus (Array aus Funktionspointern) 7) Kernel: sys_read() 8) Mode-Wechsel (alter Userstack) 9) Ausführung fährt fort 10) Rücksprungadr. noch auf Stack 11) Stack aufräumen BS: U5 Dateioperationen 7

8 Beispiel: _exit(255) per Hand Parameter von Systemcalls: < 6 Parameter: Parameter werden in den Registern ebx, ecx, edx, esi, edi abgelegt >= 6 Parameter: ebx enthält Pointer auf Userspace mit Parametern Aufruf des sys_exit Systemcalls per Assembler void _exit(int status) (beende den aktuellen Prozess mit Statuscode status) sys_exit Systemcall hat die Nr. 0x01 myexit.c int main(void) { asm("mov $0x01, %eax\n" /* syscall # in eax */ "mov $0xff, %ebx\n" /* Parameter 255 in ebx */ "int $0x80\n"); /* Softwareinterrupt an Kernel */ return 0; } pohl@host:~$./myexit pohl@host:~$ echo $? 255 pohl@host:~$ BS: U5 Dateioperationen 8

9 Arbeiten mit Dateien Alles unter Linux/Unix wird auf Dateien abgebildet viele verschiedene Dateitypen (Geräte, Sockets,...) Typische Dateioperationen sind Öffnen/Lesen/Schreiben/Schließen Unter Linux mehrere Möglichkeiten Syscall-Wrapper der C-Bibliothek ( low-level ), z.b. open(2) int open(const char *path, int flags) syscall( NR_open, path, flags) - keine Abstraktion, sondern direkte Umsetzung in Systemcall Abstrakte Stream Schnittstelle der C-Bibliothek ( high-level ), z.b. fopen(3) FILE* fopen(const char *path, const char *mode) Abstraktion von Filedeskriptor Stream (FILE*) open(path, flags) BS: U5 Dateioperationen 9

10 Low-Level Dateioperationen Öffnen von Dateien mit open(2) int open(const char *path, int flags); gibt einen Dateideskriptor zurück, der für die anderen Funktionen verwendet wird Lesen aus Dateien mit read(2) ssize_t read(int fd, void *buf, size_t count); Schreiben in Dateien mit write(2) ssize_t write(int fd, void *buf, size_t count); Schließen von offenen Dateien mit close(2) int close(int fd); BS: U5 Dateioperationen 10

11 Beispiel low-level #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #define SIZE 64 int main(void) { int r_fd = 0, w_fd = 0; ssize_t r_bytes = 0, w_bytes = 0; char buf[size] = {0}; } /* Datei zum Lesen öffnen */ r_fd = open( /tmp/inputfile, O_RDONLY); if (r_fd == -1) { /*... Fehler... */ } r_bytes = read(r_fd, buf, SIZE); /* SIZE Bytes aus der Datei lesen */ If (r_bytes == -1) { /*... Fehler... */ } /* Ausgabedatei öffnen und leeren; nicht vorhanden? -> erzeugen! */ w_fd = open( /tmp/outputfile, O_CREAT O_WRONLY O_TRUNC); if (w_fd == -1) { /*... Fehler... */ } w_bytes = write(w_fd, buf, r_bytes); /* gelesene Bytes schreiben */ If (w_bytes == -1) { /*... Fehler... */ } close(r_fd); close(w_fd); return 0; BS: U5 Dateioperationen 11

12 High-Level Dateioperationen Öffnen von Dateien mit fopen(3) FILE *fopen(const char *path, const char *mode); Modi: - r / r+ (lesen/+schreiben) - w / w+ (schreiben/+lesen) - a / a+ (anhängen/+lesen) Beispiel: stream = fopen("/tmp/inputfile", "r"); if (stream == NULL) { } perror("fopen"); fclose(stream); exit(exit_failure); Rückgabewert: NULL im Fehlerfall, ansonsten einen FILE-Zeiger bzw. Datenstrom BS: U5 Dateioperationen 12

13 High-Level Dateioperationen (2) Öffnen von Dateien mit fopen(3) FILE *fopen(const char *path, const char *mode); Modi: - r / r+ (lesen/+schreiben) struct FILE enthält Informationen - w / w+ (schreiben/+lesen) die zur Kontrolle des Datenstroms - a / a+ (anhängen/+lesen) benötigt werden. Beispiel: stream = fopen("/tmp/inputfile", "r"); if (stream == NULL) { } perror("fopen"); fclose(stream); exit(exit_failure); Rückgabewert: NULL im Fehlerfall, ansonsten einen FILE-Zeiger bzw. Datenstrom BS: U5 Dateioperationen 13

14 High-Level Dateioperationen (3) Öffnen von Dateien mit fopen(3) FILE *fopen(const char *path, const char *mode); Modi: - r / r+ (lesen/+schreiben) - w / w+ (schreiben/+lesen) - a / a+ (anhängen/+lesen) Beispiel: stream = fopen("/tmp/inputfile", "r"); if (stream == NULL) { } perror("fopen"); fclose(stream); exit(exit_failure); Rückgabewert: NULL im Fehlerfall, ansonsten einen FILE-Zeiger bzw. Datenstrom BS: U5 Dateioperationen 14

15 High-Level Dateioperationen (4) Schließen von offenen Dateien mit fclose(3) int fclose(file *stream); Beispiel: fclose(stream); Rückgabewert: EOF im Fehlerfall, ansonsten 0. BS: U5 Dateioperationen 15

16 High-Level Dateioperationen (5) int fprintf(file *stream, const char *format,..); wird dazu verwendet, um einen String mit einem bestimmten format zu erzeugen und auf einem stream auszugeben Beispiel: fprintf(stream,"%15s Line number %10u\n", student, matrikelnummer); Rückgabewert: -1 im Fehlerfall, ansonsten die Anzahl der geschriebenen Zeichen. Siehe fprintf(3) BS: U5 Dateioperationen 16

17 High-Level Dateioperationen (6) int fscanf(file *stream, const char *format,..); wird dazu verwendet, um aus einem stream mit einem bestimmten format zu lesen Beispiel: stream = fopen("/tmp/inputfilef", "r"); fscanf (stream, "%15s", str); Rückgabewert: EOF im Fehlerfall, ansonsten die Anzahl der erfolgreich eingelesen Daten Siehe fscanf(3) BS: U5 Dateioperationen 17

18 High-Level Dateioperationen (7) int feof(file *stream); überprüft, ob das Ende der Datei erreicht wurde Beispiel: while (!feof(stream)){ }... Rückgabewert: ungleich 0, wenn das Ende der Datei erreicht wird - muss explizit mit clearerr(3) zurückgesetzt werden Siehe feof(3) BS: U5 Dateioperationen 18

19 Schreibe/Lese-Position Schreibe/Lese- Position Datei wird zum Lesen oder Schreiben geöffnet Schreibe/Lese- Position Datei wird zum Anhängen geöffnet Kader2012.txt 59 Nummer Vorname Nachname Verein 1 Manuel Neuer FC Bayern München 14 Holger Badstuber FC Bayern München 16 Philipp Lahm FC Bayern München 20 Jérôme Boateng FC Bayern München 5 Mats Hummels Borussia Dortmund 6 Sami Khedira Real Madrid 7 Bastian Schweinst. FC Bayern München 10 Lukas Podolski 1. FC Köln 8 Mesut Özil Real Madrid 13 Thomas Müller FC Bayern München 11 Miroslav Klose Lazio Rom \n 1 Zeile = 60 Zeichen BS: U5 Dateioperationen 19

20 Schreibe/Lese-Position (2) long ftell(file *stream); ftell kann die aktuelle Schreibe/Lese-Position im Stream bzw. in der Datei ermitteln Rückgabewert: -1 im Fehlerfall, ansonsten die aktuelle Position des Streams in der Datei (aktuelle Offset) Siehe ftell(3) BS: U5 Dateioperationen 20

21 Schreibe/Lese-Position (3) 59 \n ftell=0 ftell=120 ftell=300 ftell=feof Nummer Vorname Nachname Verein 1 Manuel Neuer FC Bayern München 14 Holger Badstuber FC Bayern München 16 Philipp Lahm FC Bayern München 20 Jérôme Boateng FC Bayern München 5 Mats Hummels Borussia Dortmund 6 Sami Khedira Real Madrid 7 Bastian Schweinst. FC Bayern München 10 Lukas Podolski 1. FC Köln 8 Mesut Özil Real Madrid 13 Thomas Müller FC Bayern München 11 Miroslav Klose Lazio Rom Kader2012.txt 1 Zeile = 60 Zeichen BS: U5 Dateioperationen 21

22 Schreibe/Lese-Position (4) int fseek(file *stream, long offset, int whence); setzt die Schreibe/Lese-Position neue Position = offset (bytes) + whence whence: - SEEK_SET: Anfang der Datei - SEEK_CUR: Indikator für die aktuelle Position - SEEK_END: Ende der Datei Rückgabewert: -1 im Fehlerfall, ansonsten 0. Siehe fseek(3) BS: U5 Dateioperationen 22

23 Schreibe/Lese-Position (5) 59 \n 1.fseek(fp,120,SEEK_SET) 3.fseek(fp, 120,SEEK_CUR) 2.fseek(fp,300,SEEK_CUR) 4.fseek(fp,0,SEEK_END) Nummer Vorname Nachname Verein 1 Manuel Neuer FC Bayern München 14 Holger Badstuber FC Bayern München 16 Philipp Lahm FC Bayern München 20 Jérôme Boateng FC Bayern München 5 Mats Hummels Borussia Dortmund 6 Sami Khedira Real Madrid 7 Bastian Schweinst. FC Bayern München 10 Lukas Podolski 1. FC Köln 8 Mesut Özil Real Madrid 13 Thomas Müller FC Bayern München 11 Miroslav Klose Lazio Rom Kader2012.txt 1 Zeile = 60 Zeichen BS: U5 Dateioperationen 23

24 Fehlerbehandlung int ferror(file *stream); Beispiel: fscanf(stream, %15s,str) if (ferror(stream)) { } perror( fscanf"); fclose(stream); exit(exit_failure); Rückgabewert: ungleich 0, wenn es gesetzt ist Siehe ferror(3) BS: U5 Dateioperationen 24

25 High-Level Verzeichnisoperationen Öffnen von Verzeichnissen mit opendir(3) DIR *opendir(const char *path); Auslesen der Verzeichnisinhalte mit readdir(3) struct dirent *readdir(dir *dir); Rückgabe = NULL alle Verzeichniseinträge gelesen, keine weiteren vorhanden oder Fehler sonst: in dirent.d_name steht der Name des Verzeichniseintrages Schließen von geöffneten Verzeichnissen (closedir(3)) int closedir(dir *dir); Benötigte Header: <sys/types.h>, <dirent.h> BS: U5 Dateioperationen 25

26 Beispiel: Verzeichnis Auslesen #include <sys/types.h> #include <dirent.h> #include <stdio.h> int main(void) { int retval = 0, count = 0; DIR *dir = NULL; struct dirent *entry = NULL; dir = opendir("/tmp"); /* Verzeichnis öffnen, DIR-Zeiger erstellen */ if (!dir) { /*... Fehler... */ } /* jeder Aufruf liefert einen Eintrag, NULL -> Listenende */ while ((entry = readdir(dir))) { printf("eintrag %d: %s\n", ++count, entry->d_name); } printf("anzahl: %d\n", count); retval = closedir(dir); /* Verzeichnis wieder schließen */ if (retval == -1) { /*... Fehler... */ }; } return 0; BS: U5 Dateioperationen 26