Windows 32 Bit Systemprogrammierung

Transkript

1 Windows 32 Bit Systemprogrammierung Vertiefung Systemprogrammierung SS 09 Professor Dr. Helmut Weber Abdullah Kutlucan Manuel Köhler Roman Pompetzki

2 Inhaltsangabe Einführung in die Win32 API Dateisystem Prozesse/Threads Registry Win32Speichermanagement Asynchrones I/O 2 Pompetzki Windows 32 Bit

3 Einführung 1/2 Microsoft Windows: meistgenutztes Betriebssystem der Welt Win32 API!= UNIX API UNIX besteht im Open Standard Windows hingegen wird von einer Firma kontrolliert 3

4 Einführung 2/2 Vorteile für den Nutzer: Einheitlichkeit, kein Versionschaos keine patentrechtlichen Erweiterungen -> keine Verwirrung Unmengen Zusatzprogramme und Tools für alles und jeden Innovative Neuerungen zuerst für Windows 4

5 Technisches zur Win32 API Win32 Funktionsnamen sind lang und ausführlich -> schneller Rückschluss auf Rolle (z.b. WaitForSingleObject ) zahlreiche Synchronisationsmechanismen reichhaltiges und flexibles Interface 5 kernel Objekte von Win32-APIs manipulierbar - > keine Hintertürchen

6 Datentypen Datentyp BOOL BYTE COLORREF DWORD LONG LPARAM LPCSTR LPSTR LRESULT UINT WNDPROC WORD WPARAM Bedeutung boolscher Wert (32 Bit) vorzeichenloser 8-Bit-Wert Farbinformationen (32 Bit) wie unsigned int in C (32 Bit) wie int in C (32 Bit) Funktionsparameter (32 Bit) Zeiger auf konstanten String Zeiger auf String Rückgabewert von Funktionen (32 Bit) unsigned int Zeiger auf eine Windowsfunktion unsigned short Funktionsparameter (16 Bit) 6

7 Systemaufrufe UNIX Win32 Beschreibung open CreateFile Neue Datei erzeugen oder Datei öffnen close CloseFile Datei schließen read ReadFile Daten aus einer Datei lesen write WriteFile Daten in eine Datei schreiben lseek SetFilePointer Warten auf ein Ereignis stat GetFileAttributes Dateizeiger bewegen unlink DeleteFile Datei löschen mkdir CreateDirectory Neues Verzeichnis erzeugen rmdir RemoveDirectory Leeres Verzeichnis löschen 7

8 Beispielprogramm aus einer erstellten Datei lesen: 1. #include <windows.h> 2. #define SOURCE source.txt //Quelldatei 3. #define MAXREADSIZE Int main(int argc, char **argv[]) 5. { 6. HANDLE hread; 7. DWORD readsize; 8. char buffer [MAXREADSIZE]; 9. //Datei verfügbar machen 10. hread = CreateFile(SOURCE,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL); 11. /*mögliche Fehler könnten an dieser Stelle abgefangen werden*/ 12. ReadFile(hread,buffer,MAXREADSIZE,&readsize,NULL); //Datei lesen 13. /*mögliche Fehler könnten an dieser Stelle abgefangen werden*/ 14. CloseFile(hread);} 8

9 Dateisystem Ablageorganisation auf Datenträger lesen, speichern oder verschieben leichtes Wiederfinden / sicheres Abspeichern 9

10 FAT und NTFS FAT32 es gibt auch ältere Versionen (z.b. FAT12) für Datenträger bis 8TB (ca. 8000GB) max. Dateigröße 4GB NTFS sicherer und schneller max. Dateigröße 1 Million TB Nachteil NTFS Funktionsweise Betriebsgeheimnis v. Microsoft 10

11 Systemaufrufe HANDLE CreateFile( ) Öffnen oder Erzeugen von Dateien Rückgabewert ist ein Handle BOOL ReadFile (HANDLE hfile, ) Rückgabe true bei Erfolg BOOL CloseFile (HANDLE hfile); schließt Datei 11

12 CreateFile(..) Aufbau 12 Handle CreateFile ( LPCTSTR dateiname, /*Dateiname*/ DWORD dwdesiredaccess, /*Schreibrechte*/ DWORD dwsharemode, /*Gemeinsame Nutzung von mehr. CPU s regeln*/ [LPSECURITY_ATTRIBUTES lpsa] /*Sicherheitsaspekte*/ DWORD dwcreationdisposition, Öffnen*/ DWORD dwflagsandattributes, Dateieinstellungen*/ [HANDLE htemplatefile] /*Zustände beim /*erweit. /*erben von HANDLE Pompetzki (Schreibrechte,..)*/ Windows 32 Bit

13 Beispiel Cat (1/2) 1. /*typedef unsigned long DWORD*/ 2. #include <windows.h> 3. #include <stdio.h> 4. #define BUF_SIZE int main (int argc, char* argv []){ 7. HANDLE h1; //h1 = Handler 8. DWORD wirklichgelesenebyte; //DWORD ist ein int, wie in Unix size_t 9. char buffer [BUF_SIZE]; //buffer = das gelesene wird reingeschreiben 10. if (argc!= 2) { //BUF_SIZE = anzahl der zu lesenden Bytes 11. printf ("Nutze wie folgt: mycat Datei\n"); 12. return 0; 13. } 14. h1 = CreateFile (argv [1], GENERIC_READ, FILE_SHARE_READ, NULL, 15. OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 13

14 Beispiel Cat (2/2) 1. if (h1 == INVALID_HANDLE_VALUE) { 2. printf ("Konnte Datei nicht oeffnen.\n"); 3. return 0; 4. } 21. boolean b = ReadFile (h1, buffer, BUF_SIZE, &wirklichgelesenebyte,null); 22. /*wirklichgelesenebyte = Referenz auf diese Variable -> die Variable wird nach ReadFile gefüllt */ 23. if (b!=1) { printf("dateilesefehler!\n"); 21. } 22. printf("\n%s \n\nund tatsaechlich gelesen: %i",buffer, wirklichgelesenebyte); 23. } 24. CloseHandle (h1); 25. return 0; 14

15 Prozesse/Threads Jeder Prozess beinhaltet: Einen oder mehrere Threads Ein oder mehrere Code-Segmente, inklusive dll-code Ein oder mehrere Daten- Segmente mit globalen Variablen Den Prozess-Heap Prozess Ressourcen, mit z.b. Handles oder anderen Heaps Code Globale Variablen Prozess Heap Prozess Ressourcen Umgebungsblock Thread1 Thread N TLS < > TLS Stack Stack 15

16 Prozesserstellung BOOL CreateProcess ( LPCTSTR lpimagename, //Name des Programms LPTSTR lpcommandline, //Kommandozeilen-Argumente LPSECURITY_ATTRIBUTES lpsaprocess, //Sicherheitsattribute Prog. LPSECURITY_ATTRIBUTES lpsathread, //Sicherheitsattribute Threads BOOL binherithandles, //Handles an Kinder vererben DWORD dwcreate, //Prozesserstellungsoptionen LPVOID lpvenvironment, //Umgebungsvariablen LPCTSTR lpcurdir, //Arbeitsverzeichnis LPSTARTUPINFO lpsistartinfo, //Eigenschaften des Hauptfensters LPPROCESS_INFORMATION lppiprocinfo) //Prozessinformationen Rückgabewerte: NULL bei Fehler TRUE wenn der Prozess und Thread erfolgreich erstellt wurden 16

17 Erstellungsoptionen (dwcreate) CREATE_SUSPENDED: Erstellt einen Prozess, dessen Prozess-Thread schlafen gelegt wird. Der Prozess kann mit ResumeThread() geweckt werden. DETACHED_PROCESS: Erstellt einen Prozess ohne Konsole. CREATE_NEW_CONSOLE: Erstellt einen Prozess mit neuer Konsole CREATE_NEW_PROCESS_GROUP : Der Prozess eröffnet eine neue Gruppe in der alle teilnehmenden Prozesse die gleiche Konsole benutzen. 17

18 Prozessinformationen 18 Prozesse besitzen ID's und Handles: typedef struct _PROCESS_INFORMATION{ HANDLE hprocess; HANDLE hthread; DWORD dwprocessid; DWORD dwthreadid; } PROCESS_INFORMATION; ID's und Handles: Es kann mehrere Handles zu einem Objekt geben, ID's nicht Objekt-ID's sind einzigartig und unveränderlich Jedes Objekt besitzt eine ID solange es existiert

19 Terminieren von Prozessen 19 VOID ExitProcess (UINT nexitcode); Parameter: - nexitcode: Terminierungsstatus - Beendet den aufrufenden Prozess mit all seinen Threads - Ignoriert _finaly und _except Handler des SEH (Structured Exception Handling)! -> Ressourcen vorher freigeben! BOOL TerminateProcess ( HANDLE hprocess, UINT uexitcode ); Parameter: - hprocess: Handle eines Prozesses. - uexitcode: Terminierungsstatus (Eingabe-Parameter) - Beendet einen anderen Prozess mit all einen Threads - Ignoriert SEH komplett! - Resourcen werden nicht freigeben!

20 Systemaufrufe 20 UNIX Win32 Beschreibung fork, Kind ruft execl oder execle auf exit, schließt Dateien und schreibt waitpid Pufferdaten (unblocking) wait (blocking) kill CreateProcess ExitProcess, terminiet den Prozess sofort WaitForSingleObject oder GetExitCodeProcess GenerateConsoleCtrlE vent einen neuen Prozess erstellen Prozess beendet sich selbst Auf Terminierung von Prozessen warten bzw. Terminierungsstatus Terminierungssignal senden - OpenProcess öffnet existierenden kill, mit SIGKILL, TerminateProcess anderen Proz. Prozess SIGTERM beenden

21 Vergleich: Prozesserstellung Unix: int pid; pid = fork(); if(pid==0) { // Kindprozess execle ("/bin/ls", NULL); } int status=0; // Warten auf Beendigung des Kindprozesses wait(&status); 21

22 Vergleich: Prozesserstellung Windows: STARTUPINFO si; PROCESS_INFORMATION pi; // Start the child process CreateProcess( NULL, // Modulname (hier über Kommandozeilenparameter) argv[1], // Kommandozeile NULL, // Prozess-Handle nicht vererbbar NULL, // Thread-Handle nicht vererbbar FALSE, // Handle-Vererbbarkeit auf FALSE 0, // Keine Flags NULL, // Eltern-Umgebungsblock wird genutzt NULL, // Eltern-Startverzeichnis wird genutzt &si, // Pointer auf STARTUPINFO Struktur &pi ) ; // Pointer auf PROCESS_INFORMATION Struktur WaitForSingleObject( pi.hprocess, INFINITE ); // Auf Beendigung des Kind- Prozesses warten CloseHandle( pi.hprocess ); // Schließen des Prozesses und der Thread-Handles CloseHandle( pi.hthread ); 22

23 Registry Es werden in der Registry Datenbank Einstellungen von Windows, der Software und der Hardware hinterlegt Ab Win95 trifft Beschreibung oben zu, davor in NT Systemen vorhanden, aber nur für Dateizuordnungen 23

24 Wie kommt man zur Registry? regedit32 für Win2000/NT 24

25 HKCR: Verweist auf den Unterschlüssel HKLM\Software\Classes. (aus Kompatibil.) Für Beschreibung, Symbol und verknüpfte Anwendung von Dateien zuständig. HKCU: Profil des aktuellen Benutzers (von HKUSERS bestimmt) 25

26 HKLM: rechnerspezifische Hardware- und Software- Einstellungen (für alle Benutzer) HKU: Benutzerdefinierte Einstellungen der Benutzer 26 HKCC: verweist auf den Unterschlüssel HKLM\System\CurrentControlSet \Hardware\Profiles\Current Enthält Informationen wie Bildschirmauflösungen und Schriftarten.

27 Beispiel: In HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\ CurrentVersion\Run einen neuen Eintrag anlegen 27

28 28

29 Registry API Calls RegOpenKeyEx - vorhandene Key öffnen RegDeleteKeyEx - vorhandene Key löschen RegCreateKeyEx - neuen Key erzeugen RegEnumKeyEx - Auflisten aller Subkeys im geöffneten Key RegSetValueEx - Setzen eines Name/Wert-Paares im geöffneten Key RegEnumValue - Auflisten aller Values im geöffneten Key 29

30 RegOpenKeyEx 30 LONG RegOpenKeyEx ( HKEY hkey, //erwartet einen der Hauptschlüssel LPCTSTR lpsubkey, //erwartet Subkey d. Hauptkeys DWORD uloptions, //muss 0 sein REGSAM samdesired, //Für Zugriffsrechte PHKEY phkresult //Key-Handle des geöffneten Keys );

31 Beispiel 1. HKEY hkey = Null; 2. if (ERROR_SUCCESS!= RegOpenKeyEx HKEY_LOCAL_MACHINE, Software\Microsoft\Windows\ CurrentVersion\Run, 0, KEY_WRITE, &hkey) 3. { 4. printf( Fehler beim Öffnen des Keys ); 5. } 31

32 Exception Eine Exception tritt z.b. auf bei Division durch Null Null-Pointer Dereferenzierung Array Out Of Bound Nachdem eine Exception im Programm auftritt, wird das Programm an dieser Stelle sofort beendet Folgen? 32

33 Aufbau try { // Code, der einen Fehler verursachen könnte } except (erwartebestimmtekonstante*) { // Fehlerbehandlung } *auch Funktion möglich, die eine Konstante zurückgibt 33

34 Mögliche Konstanten EXCEPTION_EXECUTE_HANDLER Standardfall, führt Anweisungen in _except durch und Programm läuft dann nach except-block normal weiter EXCEPTION_CONTINUE_SEARCH Ausnahme wurde nicht erkannt. Suche weiter im Quellcode nach _exept() EXCEPTION_CONTINUE_EXECUTION Ausnahme wird zurückgewiesen und es wird versucht, an dem Punkt, wo die Ausnahme auftrat, weiterzumachen. 34

35 1. #include <stdio.h> 2. #include <windows.h> 3. #include <excpt.h> 4. int filter(unsigned int code) { 5. puts("in filter."); 6. if (code == EXCEPTION_INT_DIVIDE_BY_ZERO) { 7. puts("not allowed"); 8. return EXCEPTION_EXECUTE_HANDLER; 9. } 10. } 11. int main() 12. { 13. int p = 3; 14. puts("hello"); Ausgabe? 15. try{ 16. puts("in try"); 17. p = p / 0; // exception; 18. } 19. } except(filter(getexceptioncode()){ 20. puts("in except"); 21. } 22. puts("world"); 23. } 35

36 1. #include <stdio.h> 2. #include <windows.h> 3. #include <excpt.h> 4. int filter(unsigned int code) { 5. puts("in filter."); 6. if (code == EXCEPTION_INT_DIVIDE_BY_ZERO) { 7. puts("not allowed"); 8. return EXCEPTION_EXECUTE_HANDLER; 9. } 10. } 11. int main() 12. { 13. int p = 3; 14. puts("hello"); Ausgabe: try{ 16. puts("in try"); 17. p = p / 0; // exception; 18. } 19. } except(filter(getexceptioncode()){ 20. puts("in except"); 21. } 22. puts("world"); 23. } hello in try in filter. not allowed in except world

37 Bemerkungen zu Ausnahmen Empfehlung von Microsoft finally 37

38 Win32 Speichermanagement Win32 API: Maximal 4 GB an Speicher ansprechen/adressieren (2 hoch 32) Benutzer-Prozesse: Standardmäßig 2 GB Rest für den Kernel, Treiber und Dynamic Link Libaries (DLLs) 38 DLLs: Von mehreren Prozessen gleichzeitig benutzt (shared data bzw. shared code).

39 Win32 Speichermanagement Da Rechner wenig RAM: Konzept des virtuellen Speichers (virtual memory) Jeder Prozess hat seinen eigenen virtuellen Speicher. Virtueller Speicher viel größer als realer Speicher Betriebssystem: Mapping vom virtuellen auf den realen (physischen) Speicher. 39 3

40 Virtueller Speicher Virtual Memory Win32 API : Setzt auf Virtual Memory Manager auf Spricht komplette Seiten an. Die gängigsten Funktionen dafür sind: VirtualAlloc() VirtualFree() VirtualLock() VirtualUnlock() 40

41 Virtueller Speicher Um die Größe einer Seite auf dem aktuellen Betriebssystem herauszufinden (Win9x/NT/2000/XP/Vista), kann der folgende Systemaufruf benutzt werden: VOID GetSystemInfo (LPSYSTEM_INFO lpsysteminfo) Die übergebene SYSTEM_INFO Struktur enthält unter anderem Informationen über die Page-Größe 41 5

42 GetSystemInfo() Beispiel Aktuelle Seitengröße ermitteln: Ausgabe, z.b. auf IBM Thinkpad 600X mit Windows 2000): 4096 Bytes 42

43 Heaps Teile des Speichers werden in Heaps verwaltet. Pro Prozess können mehrere Heaps benutzt werden. Standard-Heap (Default-Heap) = Prozess-Heap Funktionen für Standard-Heap: malloc(), free(), calloc(), realloc() Handle für Standard-Heap holen mit: HANDLE GetProcessHeap(VOID) Es können auch mehrere Heaps allokiert werden 43

44 Mehrere Heaps - Vorteile Fairness: Jeder Thread hat einen gleich großen Speicher Speicherfehler betreffen nur diesen einen Thread Performance in mehreren Threads: Es kann nicht mehr um den Speicher gekämpft werden Kann Performance-Verbesserungen bringen 44 Effizienteres Freigeben von Speicher: 1x HeapDestroy() aufrufen: Alles inkl. Speicherlecks weg!

45 Heap erstellen Neuen Heap erstellen: HANDLE HeapCreate ( DWORD floptions, SIZE_T dwinitialsize, SIZE_T dwmaximumsize) Rückgabewert: Heap-Handle oder NULL floptions: Flag für Exception-Handler einschalten, Performance-Verbesserung, etc dwinitialsize: Initiale Größe (kann auch 0 sein) dwmaximumsize: Maximale Größe (kann ebenfalls 0 sein, dann wächst der Heap u.u. bis zur maximal möglichen virtuellen Speichergrenze 45

46 Heap löschen BOOL HeapDestroy (HANDLE hheap) Der Default-Heap sollte auf diese Weise nie gelöscht werden! So können auf einen Rutsch riesige Datenstrukturen aus dem (virtuellen) Speicher gelöscht werden! 46

47 Speicherblock erstellen LPVOID HeapAlloc ( HANDLE hheap, DWORD dwflags, SIZE_T dwbytes) Rückgabewert: Ein Pointer des allokierten Blockes oder NULL bei Fehler hheap: Der Prozess-Heap oder ein selbst erstellter Heap dwflags HEAP_GENERATE_EXCEPTIONS: Exception-Handler einschalten HEAP_ZERO_MEMORY: Block mit 0 initialisieren! dwbytes: Anzahl der Byte, die allokiert werden sollen 47

48 Blockgröße ermitteln Die Blockgröße kann wie folgt ermittelt werden: DWORD HeapSize ( /* BlockSize() wäre passender */ HANDLE hheap, DWORD dwflags, LPVOID lpmem) Rückgabewert: Blockgröße oder 0 (zero) bei Fehler Parameter: Wie gehabt 48

49 Weitere Funktionen HeapFree( ) Einzelne Blöcke freigeben HeapRealloc( ) Blockgröße nachträglich ändern HeapLock( ) / HeapUnlock( ) Hiermit kann man einen kritischen Abschnitt definieren 49

50 Dateimapping / MMF Solange der Prozess läuft, werden die allokierten Daten im virtuellen Speicher gehalten und nur bei Bedarf in den RAM geladen. Prozess beenden => Allokierte Daten sind weg! Virtueller Speicher = Auslagerungs-Datei Idee: Physikalische Dateien auf virtuellen Speicher mappen Festgelegter Bereich oder komplette Datei mappen 50

51 Vorteile MMF Dies hat folgende Vorteile: Keine I/O-Operationen (Zeitersparnis) Erstellte Datenstrukturen wiederverwendbar Mehrere Prozesse können den Speicher gleichzeitig mappen! 51

52 Mapping-Objekt erstellen Eine Datei kann gemappt werden mit: HANDLE CreateFileMapping ( HANDLE hfile, LPSECURITY_ATTRIBUTES lpsa, DWORD fdwprotect, DWORD dwmaximumsizehigh, DWORD dwmaximumsizelow, LPCTSTR lpszmapname) 52 Rückgabewert: NULL oder Handle der gemappten Datei hfile: Handle einer geöffneten Datei oder INVALID_HANDLE_VALUE eintragen, mit letzterem wird die Auslagerungsdatei selbst genommen, damit können verschiedene Prozesse ihren Speicher teilen, ohne eine Datei erstellen zu müssen

53 Mapping-Objekt öffnen Geöffnet wird es mit: HANDLE OpenFileMapping ( DWORD dwdesiredaccess, BOOL binherithandle, LPCTSTR lpname) Rückgabewert: NULL oder Mapping-Handle dwdesiredaccess: Nur Lesen, nur Schreiben, etc hinherithandle: TRUE oder FALSE, ob Handle an untergeordnete Prozesse vererbt werden kann lpname: Name des vorher erstellten Mapping-Objektes Mapping schließen mit: CloseHandle() 53

54 View(s) der Datei erstellen Letztendlich wird die Datei über das erstellte und geöffnete Mapping-Objekt in den virtuellen Adressraum des Prozesses geladen: LPVOID MapViewOfFile ( HANDLE hmapobject, DWORD fdwaccess, DWORD dwoffsethigh, DWORD dwoffsetlow, SIZE_T cbmap) Rückgabewert: NULL oder Startadresse des gemappten Speichers 54

55 Adressräume Die Grafik zeigt den Unterschied zwischen dem virtuellem und realem Adressbereich einer gemappten Datei: Programm Datei fh = CreateFile ( ); mh = CreateFileMapping (fh); Virtueller Prozess-Speicher while ( ) { preca = MapViewOfFile (mh); precb = MapViewOfFile (mh); precb -> Data = preca -> Data;... UnmapViewOfFile (preca); UnmapViewOfFile (precb); } CloseHandle (mh); CloseHandle (fh);

56 Reihenfolge Folgende Reihenfolge muss eingehalten werden, damit die (veränderte) Datei korrekt auf den Datenträger geschrieben wird: 1. Das Dateimapping mit UnmapViewOfFile() aus dem Speicher entfernen 2. Das Mapping-Objekt schließen mit CloseHandle() 3. Das mit CreateFile() geöffnete Handle ebenfalls mit CloseHandle() schließen Wichtig: Nebenher keine I/O-Operationen auf die gleiche Datei machen! 56

57 Dynamic Link Libraries Windows-Programme benötigen häufig sogenannte DLL-Dateien, sonst sind diese nicht lauffähig. Eine DLL-Datei ist eine gemappte Datei im (virtuellen) Speicher, auf die auch andere Prozesse zugreifen können (shared memory). Zur Ladezeit (load time) einbinden: implizites Linken Zur Laufzeit (run time) einbinden: explizites Linken 57 Hauptvorteil: Gemeinsame Benutzung der Funktionalität

58 Iimplizites Linken (1/2) 1. Im Code der DLL werden die einzelnen Funktionen wie folgt ergänzt: _declspec (dllexport) DWORD MyFunction (...); 2. Build-Prozesses erstellt.dll und.lib-datei 3..LIB-Datei wird vom Programm gebraucht, welches die.dll benutzt (.LIB -> Welche Funktionen/Variablen?). 58

59 Iimplizites Linken (2/2) 4. Programm gibt beim Kompilieren die.lib-datei an. 5. Dem Programm selber, werden die Funktionen aus der DLL fast wie bei Schritt 1 importiert: _declspec (dllimport) DWORD MyFunction (...); 59

60 Explizites Linken (1/2) 1. Dieses geschieht durch Aufruf der folgenden Win32 API-Funktion und Angabe des DLL-Dateinamens. Die Dateierweiterung muss nicht angegeben werden. HINSTANCE bedeutet soviel wie HANDLE und ist noch ein Überbleibsel der 16-Bit Programmierung. HINSTANCE LoadLibrary (LPCTSTR lplibfilename) 60

61 Explizites Linken (2/2) 2. Dann wird die Einsprungsadresse einer Funktion in der DLL geholt: FARPROC getprocaddress ( HMODULE hmodule, LPCSTR lpprocname) Rückgabewert im Fehlerfall: NULL oder Entry Point hmodule: Rückgabewert von LoadLibrary() lpprocname: Name der Funktion per String, die man benutzen möchte 3. Letztendlich will man die DLL auch wieder schließen und den virtuellen Speicher dafür freigeben: 61 BOOL FreeLibrary (HINSTANCE hlibmodule)

62 Asynchrones I/O - Einleitung Prozesse werden am meisten mit Ein- und Ausgabe- Operationen (I/O-Operationen) ausgebremst. Lange Wartezeit für Lesekopf der Festplatte bzw. optischer Laser für CD/DVD Verzögerungen im Netzwerkverkehr (z.b. Sockets). Verzögerungen zwischen Festplatte und RAM 62

63 Asynchrones I/O - Einleitung Klassischer Ablauf: Programme arbeiten Thread- Synchron, d. h. Funktionen blockieren I/O-Operation wird beendet, dann liefert Funktion Return-Wert Schneller wäre es aber, während der I/O-Operation schon wieder andere Operationen auszuführen. Asynchrones I/O: Funktionen, die sofort einen Rückgabewert liefern, obwohl I/O-Operation noch nicht abgeschlossen 63

64 Asynchrones I/O - Einleitung Verschiedene Techniken für asynchrones I/O: 1. Multithreaded I/O: Mit Threads 2. Overlapped I/O: Aktueller Thread läuft nach I/O-Operation einfach weiter 3. Completion Routines (Extended I/O): Fast wie Punkt 2, aber mit Extended Functions, z.b. ReadFileEx, WriteFileEx. 64

65 Overlapped I/O 1. Der entsprechenden Funktion (z.b. CreateFile()) wird ein Flag namens FILE_FLAG_OVERLAPPED mitgegeben. 2. I/O-Operation soll nun asynchron laufen 3. Dann wird die Adresse einer allokierten Overlapped- Struktur übergeben. Folgende Funktionen unterstützen dies: 65 ReadFile() WriteFile() TransactNamedPipe() ConnectNamedPipe()

66 Overlapped I/O - Struktur Definition: typedef struct_overlapped { DWORD Internal; DWORD InternalHigh; DWORD Offset; DWORD OffsetHigh; HANDLE hevent; } OVERLAPPED Benachrichtigung ob I/O-Operation fertig entweder durch Events (hevent in Struktur) Filehandle Operationen wie z.b. ReadFile() liefern nun sofortig den Return-Wert FALSE. GetLastError() wird ERROR_IO_PENDING zurückgeben. 66

67 Overlapped I/O Funktionen Zur Abfrage (Polling), ob eine I/O-Operation fertig ist, wird diese Funktion benutzt: BOOL GetOverlappedResult ( HANDLE hfile, LPOVERLAPPED lpoverlapped, LPWORD lpcbtransfer, BOOL fwait) Eine laufende I/O-Operation abbrechen mit: BOOL CancelIO ( HANDLE hfile) 67

68 Overlapped I/O Beispiel Asynchrone I/O-Operation mittels Dateihandle synchronisieren: OVERLAPPED ov = { 0, 0, 0, 0, NULL /* Kein Event. */ }; HANDLE hf; DWORD nread; BYTE Buffer[1024]; /* Weitere Programmanweisungen... */ hf = CreateFile(..., FILE_FLAG_OVERLAPPED,... ); ReadFile(hF, Buffer, sizeof(buffer), &nread, &ov); /* Hier können jetzt weitere Anweisungen ausgeführt werden, die I/O-Operation arbeitet jetzt im Hintergrund. Achtung! nread hat keinen gültigen Wert! */ WaitForSingleObject(hF, INFINITE); /* nread wird jetzt mit gültigem Wert gefüllt: */ GetOverlappedResult(hF, &ov, &nread, FALSE); 68

69 Literaturverzeichnis Johnson M. Hart, Win32 System Programming Second Edition A Windows 2000 Application Developer s Guide, Copyright 2001 by Addison-Wesley 69