Win32 Systemprogrammierung - cs.hs-rm.deweber/sysprog/proj0809/win32.pdf · 30.01.2009 Win32 Systemprogrammierung 6 1.1 Einführung Versionen Win32 ist die 32-Bit-API für moderne

30.01.2009 Win32 Systemprogrammierung 1

BegrüßungBegrüßung

Win32 Systemprogrammierung

Fachhochschule Wiesbaden

Lehrveranstaltung: Systemprogrammierung

Prof. Dr. Weber

Christian Geiler [email protected]

Daniel Pielok [email protected]

Fouad Aberkane [email protected]


InhaltsverzeichnisInhaltsverzeichnis

Kapitel 1 11.Einführung2.Dateisysteme3.I/O Systemaufrufe4.Mutex/File Locking


1.1 Einführung1.1 Einführung

WinApi

Ausgeschrieben steht WinAPI fürWindows Application Programming Interface.Zu dt. bedeutet es Windows Anwendungs-Programmierungs- Schnittstelle.Die WinApi ist nix anderes als eine Programmierschnittstelle und Laufzeitumgebung. Mit dieser Api kann man Anwendungsprogrammen für Microsoft Windows-Betriebssysteme erstellen



WinApi

Die existierenden Funktionen der WinAPI sind ausschließlich in der Programmiersprache C und Assembler geschrieben.Die Funktionen befinden sich in Bibliotheken, den sogenannten DLL-Dateien, wie beispielsweise kernel32.dll, user32.dll und gdi32.dll. Die Api kann in Verbindung mit C, C++ oder Delphi eingesetzt werden.



Versionen

Win16 war die erste API, für die 16-Bit Versionen von Microsoft Windows. Gängiger Begriff war schlicht Windows API, wurde aber später umbenannt in Win16, um sie von der neueren Windows API der 32-Bit-Architektur unterscheiden zu können. Die Funktionen der Win16 API liegen hauptsächlich im Kern des Betriebssystems: kernel.exe (oder krnl286.exe oder krnl386.exe), user.exe und gdi.exe. Trotz der Dateiendung exe sind diese Dateien tatsächlich sogenannte Programmbibliotheken.



Versionen

Win32 ist die 32-Bit-API für moderne Versionen von Windows. Die API besteht aus Funktionen, die, wie bei Win16, in Programmbibliotheken implementiert sind. Die Kern-DLLs von Win32 sind kernel32.dll, user32.dll und gdi32.dll. Win32 wurde mit Windows NT eingeführt. Die Version von Win32, die mit Windows 95 ausgeliefert wurde, lief ursprünglich unter dem Namen Win32c, wobei das 'c' für Kompatibilität (engl. compatibility) stand, aber dieser Ausdruck wurde später von Microsoft zugunsten von Win32 wieder verworfen.



Versionen

Win32s ist die 32-Bit-API für die Windows 3.1x-Familie von Microsoft Windows und als solche die 32-Bit-Erweiterung für die ansonsten 16-bittigen Betriebssysteme. Das „s“ steht für Teilmenge (engl.: „subset“). Dabei wurden die Funktionsbibliotheken aus Windows NT nicht komplett übernommen, sondern lediglich eine Auswahl daraus, so ist beispielsweise MS Office 97 unter Windows NT 3.51 lauffähig, nicht jedoch unter Windows 3.1x. In Kombination mit Grafikschnittstellen wie OpenGL oder Video for Windows sollte damit jedoch bis zum Erscheinen von Windows 95 ein ausreichender Standard für Heimanwender gesetzt werden.



Versionen

Win32 für 64-Bit-Windows, auch bekannt unter dem Namen Win64, ist die Version der API die für 64-Bit-Versionen von Windows – namentlich Windows XP „x64 Edition“, Windows Server 2003 „x64 Edition“ (für AMD64 Prozessoren), Windows XP 64-Bit Edition und Windows Server 2003 für Itanium-Serien - entworfen wurde. Bei den 64-Bit-Versionen handelt es sich nur um zwei weitere unterstützte Plattformen innerhalb der Windows-NT-Architektur, so dass sowohl die 32-Bit- als auch die 64-Bit-Version einer Anwendung aus demselben Quellcode kompiliert werden können.


1.2 Dateisysteme1.2 Dateisysteme

Dateisysteme

Das Dateisystem ist die Ablageorganisation auf einem Datenträger eines Computers. Dateien müssen gelesen, gespeichert oder verschoben werden. Für den Menschen müssen Dateiname und computerinterne Dateiadressen in Einklang gebracht werden. Das leichte Wiederfinden und das sichere Abspeichern ist wesentlich. Das Ordnungs- und Zugriffssystem berücksichtigt die Geräteeigenschaften und ist normalerweise Bestandteil des Betriebssystems.



Welche Dateisysteme gibt es?

FAT16 FAT32HPFSNTFS NetWareISO 9660 (CD-ROM) und ISO 13346 (DVD)UDFReiserFS, ext, ext2, ext3, XFS, JFS



Betriebssysteme & Dateisysteme

Die Betriebssysteme Windows 95 bis Windows ME benutzen ausschließlich FAT16 & FAT32 Systeme. Die folgenden Systeme Windows NT / 2000 / XP benutzen NTFS. Anders als bei Windows Betriebssystemen benutzt Unix/Linux ext2, ext3, ReiserFS, XFS, JFS.


1.3 I/O Systemaufrufe1.3 I/O Systemaufrufe

Systemaufrufe

Ein Systemaufruf ist eine vom Anwendungsprogrammen benutzte Methode, um vom Betriebssystem bereitgestellte Funktionalitäten auszuführen.Systemaufrufe werden im Quellcode wie Bibliotheksfunktionen aufgerufen. Jedoch die Leistung solch eines Systemaufrufs wird im Kern des Betriebssystems erbracht. Ein Systemaufruf führt Assemblercode und C Code aus. In der folgenden Abbildung wird ein Systemaufruf schematisch dargestellt.



Ablauf

In der Definition der Funktionwrite befindet sich C/Assemblercode diese Zeilen haben die Aufgabe den Adressraumzu wechseln und zwarvom Adressraum des Prozessesin den Adressraum des Kern's



Systemaufruf BeispieleUnix Win32 Beschreibungopen CreateFile Neue Datei erzeugen oder Datei öffnen

close CloseHandle 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



CreateFileDie Funktion CreateFile erzeugt eine Datei der Rückgabewert dieser Funktion ist ein Handle womit man später die Datei eindeutig identifizieren kann.HANDLE CreateFile (

LPCTSTR lpFileName, /*Name der Datei*/

DWORD dwDesiredAccess, /*Lesen, Schreiben, Beides*/

DWORD dwShareMode, /*Share Modus für Prozesse*/

[LPSECURITY_ATTRIBUTES lpSecurityAttributes,]

DWORD dwCreationDisposition, /*Überschreiben, Öffnen...*/

DWORD dwFlagsAndAttributes, /*Schreibgesch., Versteckt*/

[HANDLE hTemplateFile]);



ReadFileDie Funktion ReadFile liest aus einer gegebenen Datei mithilfe eines HANDLE's.

BOOL ReadFile (

HANDLE hFile, /*Das Objekt das gelesen werden soll*/

LPVOID lpBuffer,/*Buffer*/

DWORD nNumberOfBytesToRead, /*Anzahl Max. Bytes*/

LPDWORD lpNumberOfBytesRead, /*Wirkl. gel. Bytes*/

[LPOVERLAPPED lpOverlapped]);



CloseFileDie Funktion CloseFile schließt eine Datei.BOOL CloseFile (HANDLE hFile);



Lese Beispiel

#include<windows.h>

#define SOURCE source.txt#define MAXREADSIZE 1024

int main(int argc, char **argv[]) {

HANDLE hread;DWORD readsize;char buffer [MAXREADSIZE];

hread = CreateFile(SOURCE, GENERIC_READ, 0, NULL,OPEN_EXISTING, 0, NULL);/*Mögliche Fehler abfangen*/

ReadFile (hread, buffer, MAXREADSIZE, &readsize, NULL);/*Mögliche Fehler abfangen*/

printf(„%s“, buffer);CloseFile(hread);


1.4 Mutex1.4 Mutex

Mutex

Mutex bedeutet Wechselseitiger Ausschluss (mutual exclusion).Ein Mutex ist nix anderes als eine Gruppe von Verfahren mit denen das Problem des kritischen Abschnitts gelöst wird.Damit wird verhindert, dass nebenläufige Prozesse gleichzeitig oder zeitlich verschränkt gemeinsam genutzte Datenstrukturen unkoordiniert verändern. Zu dieser Gruppe gehören zB. Semaphore, Monitore, Lock.


1.4 File Locking1.4 File Locking

File Locking

Das File Locking ist einfaches Prinzipe das folgendermaßen vorgeht nach dem dem Öffnen einer Datei für andere automatisch gesperrt. Es ist notwendig damit zwei Nutzer nicht gleichzeitig eine Datei manipulieren.Es kann immer nur ein Anwender bzw. immer nur ein Anwendungsprogramm zu einer Zeit die Datei manipulieren. File Locking wird in Netzwerkumgebungen oder auf multitaskingfähigen Systemen wie beispielsweise Windows-Rechnern eingesetzt



LockFile

Die WinApi stellt die Funktionalität für das File Locking zur Verfügung mit der Methode LockFile kann man eine ganze Datei oder bestimmte Abschnitte in Bytes für andere Prozesse sperren.BOOL WINAPI LockFile(

HANDLE hFile, /*Datei*/

DWORD dwFileOffsetLow, /*Offset*/

DWORD dwFileOffsetHigh, /*Offset*/

DWORD nNumberOfBytesToLockLow, /*Lock bytes*/

DWORD nNumberOfBytesToLockHigh /*Lock bytes*/

);



UnlockFile

Natürlich muss die gesperrte Datei bzw. der Abschnitt wieder für andere Prozesse zugänglich sein dafür gibt’s die Funktion UnlockFile sie besitzt dieselben argumente wie die Funktion LockFile.BOOL WINAPI UnlockFile(

HANDLE hFile, /*Datei*/

DWORD dwFileOffsetLow, /*Offset*/

DWORD dwFileOffsetHigh, /*Offset*/

DWORD nNumberOfBytesToUnlockLow, /*Unlock bytes*/

DWORD nNumberOfBytesToUnlockHigh /*Unlock bytes*/

);



File Locking Beispiel#include<windows.h>

#define ANFANG 10#define ENDE 20

HANDLE hFile;

hFile = CreateFile(TEXT("two.txt"), /* Datei öffnen*/ GENERIC_READ, /* Datei lesen*/ FILE_SHARE_READ, /* Mehrfache Lesen*/ NULL, /* Security Atrribut wird nich gebraucht */ OPEN_EXISTING, /* Öffnen oder erstellen*/ FILE_ATTRIBUTE_NORMAL, /* Normale Datei*/ NULL); /* Kein Template*/

/*Fehler abfangen*/

LockFile(hFile, ANFANG, 0, ENDE, 0);

/*Datei lesen*/

UnlockFile(hFile, ANFANG, 0, ENDE, 0);



Kapitel 2 21.Windows Registry2.Fehlerbehandlung3.Windows Sockets


2.1 Windows Registry2.1 Windows Registry

Registry

Zentrale, hierarchische Datenbank für Applikations- und KonfigurationsinformationenRegistry-Editor wird durch den „regedit“ Befehl geöffnet auf der KommandozeileZugriff durch SchlüsselProgramme kommunizieren mit der Registry durch Registry API FunktionsaufrufeRegistry-Programmierung ähnlich zur Dateiverarbeitung



Registry

Registry enthält folgende Informationen:Betriebssystem-Versionsnr., Build-Nr. und registrierte Userähnliche Informationen für jede installierte ApplikationHardware-Informationen über Prozessortyp, Anzahl an

Prozessoren, Arbeitsspeicher, etc.Benutzerspezifische Informationen (Home-Verzeichnis,

bevorzugte Anwendungen)installierte ServicesMappings von Dateiendungen zu deren ausführbaren

Programmen und Mappings von Netzwerkadressen zu deren Hostnamen



Registry



Registry-Schlüssel

HKEY_LOCAL_MACHINE – Informationen über den Rechner und darauf installierte SoftwareHKEY_USERS – Informationen über Benutzer-KonfigurationenHKEY_CURRENT_CONFIG – Informationen wie Bildschirmauflösung und SchriftartenHKEY_CLASSES_ROOT – Mappings von Dateiendungen zu deren AnwendungHKEY_CURRENT_USER – Benutzerspezifische Informationen (Umgebungsvariablen, Drucker, ...)



Registry API Calls

RegOpenKeyEx - vorhandenen Key öffnenRegDeleteKeyEx - vorhandenen Key löschenRegCreateKeyEx - neuen Key erzeugenRegEnumKeyEx - Auflisten aller Subkeys im geöffneten KeyRegSetValueEx – Setzen eines Name/Wert-Paares im geöffneten KeyRegEnumValue - Auflisten aller Values im geöffneten Key



RegOpenKeyEx

LONG RegOpenKeyEx ( HKEY hKey, /* Parent Key-Handle */

LPCTSTR lpSubKey, /* Name des Subkeys */

DWORD ulOptions, /* = 0 */

REGSAM samDesired, /* Zugriffsrechte */

PHKEY phkResult); /* Key-Handle des neu geöffneten Keys*/



RegOpenKeyEx Beispiel

#include <windows.h>

HKEY hKey = Null;

/* Schlüssel öffnen */ if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,

L“Software\\Alias\\Common“, 0, KEY_READ, &hKey)) {

printf(“Fehler beim Öffnen des Keys“);}



RegEnumKeyEx

LONG RegEnumKeyEx ( HKEY hKey, /* Parent Key-Handle */

DWORD dwIndex, /* Indexwert */

LPTSTR lpName, /* Name des Schlüssels */

LPDWORD lpcbName, /* Größe des Keynamen*/

LPDWORD lpReserved, /* reserviert */

LPTSTR lpClass, /* Klassenname */

LPDWORD lpcbClass, /* Größe des Klassennames*/

PFILETIME lpftLastWriteTime); /*Zeit des letzten Schreibens*/



RegCreateKeyEx

LONG RegCreateKeyEx ( HKEY hKey, LPCTSTR lpSubKey, DWORD Reserved, /* = 0 */

LPTSTR lpClass, /* Typ des neuen Keys */

DWORD dwOptions, REGSAM samDesired, /* Zugriffsrechte */

LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition);



RegCreateKeyEx Beispiel


HKEY hKey = Null;DWORD dwDisp = NULL;

/* Schlüssel mit Schreibrechten erzeugen */ if (ERROR_SUCCESS != RegCreateKeyEx(HKEY_LOCAL_MACHINE,

L“SYSTEM\\CurrentControlSet\\Services\\EventLog\\MyLog“, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE,NULL, &hKey, &dwDisp)) {

printf(“Fehler beim Erzeugen des Keys“);}



Values in der Registry

Values sind typisiertEinige Typen:

REG_BINARY – BinärdatenREG_DWORD – 32 Bit ZahlenREG_SZ – StringsREG_EXPAND_SZ – Strings mit Verweisen auf

Umgebungsvariablen



RegSetValueEx

LONG RegSetValueEx ( HKEY hKey, /* Key-Handle */

LPCTSTR lpValueName, /* Name des Values */

DWORD Reserved, /* = 0 */

DWORD dwType, /* Datentyp des Values */

CONST BYTE * lpData, /* Daten (Value) */

DWORD cbData); /* Größe der Daten */



RegSetValueEx Beispiel


HKEY hKey = Null;wchar_t *value = L“New Registry Value“;

/* Key öffnen oder neu erzeugen */ ...

/* Wert setzen */ if (ERROR_SUCCESS != RegSetValueEx(hKey, L“MyValue“, 0,

REG_SZ, (LPBYTE) value,(DWORD) ((lstrlen(value)+1) * sizeof(TCHAR))) {

printf(“Fehler beim Setzen des Wertes“);}



RegEnumValue

LONG RegEnumValue ( HKEY hKey, /* Parent Key-Handle */

DWORD dwIndex, /* Indexwert */

LPTSTR lpValueName, /* Name des Values */

LPDWORD lpcbValueName, /* Größe des Valuenamens */

LPDWORD lpReserved, /* reserviert */

LPDWORD lpType, /* Typ des Values */

LPBYTE lpData, /* der zurückgegebene Wert */

LPDWORD lpcbData); /* Größe des Rückgabewertes */


2.2 Fehlerbehandlung2.2 Fehlerbehandlung

Fehlerbehandlung

Win32 Structured Exception Handling (SEH)Exceptions, Arithmetikfehler und SystemfehlerSEH Support durch Win32 Funktionen, Sprachensupport des Compilers und Run-Time SupportBeispiele für Fehlerbehandlungen:

Array-Out-Of-Bound-ExceptionsPointer DereferenzierungDivision durch Null



Try / Except

ähnlich zum gewöhnlichen try-catch-Block:

Filter expression: nur auf bestimmte Fehlerereignisse im except-Block reagieren

__try {/* Code, der einen Fehler werfen könnte */

}__except (filter expression) {

/* Fehlerbehandlung */}



Filterexpressions

Filterexpression in __except Anweisung wird direkt nach Auftreten der Exception überprüftnormalerweise eine Konstante, eine Filterfunktion oder ein konditionaler Ausdruck, wobei immer einer der folgenden drei Typen zurückgegeben werden muss:

EXCEPTION_EXECUTE_HANDLEREXCEPTION_CONTINUE_SEARCHEXCEPTION_CONTINUE_EXECUTION



Exceptions Beispiel 1

#include <windows.h> GetTempFileName (TempFile, ...);while (...) __try {

/* Datei erzeugen */hFile = CreateFile (TempFile, ..., OPEN_ALWAYS, ...);SetFilePointer (hFile, 0, NULL, FILE_END);…/* in Datei schreiben */WriteFile (hFile, ...);/* hier kann ein Addressierungsfehler auftreten!!! */i = *p;...CloseHandle (hFile);

}__except (EXCEPTION_EXECUTE_HANDLER) {

CloseHandle (hFile);DeleteFile (TempFile);

}

/* Datei am Ende immer geschlossen*/



Fehlercodes

DWORD GetExceptionCode (VOID); Funktion gibt Fehlercode zurück → Reagieren auf bestimmte Fehlerereignisse möglicheinige wichtige Fehlercodes:

EXCEPTION_ACCESS_VIOLATIONEXCEPTION_NONCONTINUABLE_EXECUTIONEXCEPTION_INT_DIVIDE_BY_ZEROEXCEPTION_BREAKPOINT



Exceptions Beispiel 2

#include <windows.h> __try {

...i = j / 0;...

}__except (Filter (GetExceptionCode ())) {

...}

/* Filter Funktion, die auf bestimmte Fehler reagiert*/DWORD Filter (DWORD ExCode) {

switch (ExCode) {...case EXCEPTION_INT_DIVISION_BY_ZERO:

...return EXCEPTION_EXECUTE_HANDLER;

case ...}

}


2.3 Windows Sockets2.3 Windows Sockets

Windows Sockets

dienen der Interprozess-Kommunikation fast identisch zu Berkeley SocketsInitialisierung der WinSock API: int WSAStartup (

WORD wVersionRequired, /* Socket Version (Minimum) */

LPWSADATA lpWSAData); /* Pointer zu WSADATA Struct */



Sockets (TCP)

Quelle: Folienbeispiel von Herr Weber



Sockets – socket, bind

Socket erzeugen: SOCKET socket (int af, /* Adress-Familie */

int type, /* Typ des Sockets (DGRAM, STREAM) */

int protocol); /* Protokoll */

Server: binden eines Sockets an einen Port:int bind (SOCKET s, /* Socket-Handle */

const struct sockaddr *saddr, /* Adresse/Port */

int namelen); /* Größe der Adresse */



Sockets - sockaddr_in

sockaddr_in Struktur bei AF_INET verwenden:struct sockaddr_in {

short sin_family; /* AF_INET */

u_short sin_port; /* Portnummer */

struct in_addr sin_addr; /* 4-Byte IP-Adresse */

char sin_zero [8]; /* optional */

}



Sockets - listen

Struktur sin_addr besitzt eine Variable s_addr, die die IP Adresse speichertBsp.:

sa.sin_addr.s_addr = inet_addr (“192.13.12.1“);Server: Socket auf Akzeptieren von Clients vorbereiten:

int listen ( SOCKET s, /* Socket-Handle */

int nQueueSize); /* Größe der Warteschlange an Clients*/



Sockets – accept, connect

Server: Warten auf Verbindungsanfrage:SOCKET accept (SOCKET s, /* Socket-Handle */

LPSOCKADDR lpAddr, /* Definition von Port und Adresse */

LPINT lpAddrLen); /* Größe der Adresse */

Client: Verbindung aufbauen:int connect (SOCKET s, /* Socket-Handle */

LPSOCKADDR lpAddr, /* Definition von Port und Adresse */

int nAddrLen); /* Größe der Adresse */



Sockets – recv, send

Empfangen von Daten:int recv ( SOCKET s, /* Socket-Handle */

LPSTR lpBuffer, int nBufferLen, /*Puffer und -größe*/

int nFlags);Senden von Daten:

int send ( SOCKET s, /* Socket-Handle *

LPSTR lpBuffer, int nBufferLen, /*Puffer und -größe*/

int nFlags);



Server Beispiel

#include <winsock.h>struct sockaddr_in SrvSAddr,ConnectAddr;SOCKET SrvSock, sockio;... SrvSock = socket (AF_INET, SOCK_STREAM, 0);SrvSAddr.sin_family = AF_INET;SrvSAddr.sin_addr.s_addr = htonl (INADDR_ANY);SrvSAddr.sin_port = htons (SERVER_PORT);/* Socket an Adresse binden */ bind (SrvSock, (struct sockaddr *) &SrvSAddr, sizeof (SrvSAddr);listen (SrvSock, 5);AddrLen = sizeof (ConnectAddr);/* Client Verbindung akzeptieren*/sockio = accept (SrvSock, (struct sockaddr *) &ConnectAddr,

&AddrLen);.../* Daten empfangen*/ret = recv (sockio, buffer, sizeof(buffer), 0); ...closesocket (sockio);



Client Beispiel

#include <winsock.h>

SOCKET ClientSock;…/* Socket erzeugen */ ClientSock = socket (AF_INET, SOCK_STREAM, 0);memset (&ClientSAddr, sizeof (ClientSAddr), 0);ClientSAddr.sin_family = AF_INET;ClientSAddr.sin_addr.s_addr = inet_addr (argv[1]);ClientSAddr.sin_port = htons (SERVER_PORT);/* Verbindung zu Server aufbauen */ ret = connect (ClientSock, (struct sockaddr *) &ClientSAddr,

sizeof (ClientSAddr));.../* Daten senden */ ret = send (ClientSock, buffer, sizeof(buffer), 0);... /* Socket und Verbindung schliessen*/shutdown (ClientSock);closesocket (ClientSock);



Kapitel 3 31.Win32 Adressraum2.Virtuelle Adressierung3.Heaps4.Memory Mapped Files5.Bibliotheken6.Prozesse


3.1 Win32 Adressraum3.1 Win32 Adressraum

32-Bit Adressraum

32-Bit Zeiger (z.B.: LPCTSTR, LPDWORD...)

4GB adressierbarer Speicher

RING 0: Kernel-Mode, Prozesse können die vollen 4GB adressieren.

RING 3: User-Mode, Prozesse können nur 2-3 GB adressieren (versionsabhängig). Der Rest ist exklusiv für Kernel, Gerätetreiber, DLL‘s also für von mehreren Diensten genutzten Code Reserviert.


3.2 Virtuelle Adressierung: Einführung I3.2 Virtuelle Adressierung: Einführung I

Rechtfertigung: nicht alle Teile eines Programms werden immer gleichzeitig benötigt

Funktionsweise: - virtueller Speicher ist in „Seiten“ aufgeteilt.

- physikalischer Speicher ist in gleich große „Rahmen“ aufgeteilt.

- Zuordnung von Seiten zu Rahmen (Mappen).

- Auslagern von Rahmen (Swapen)

- Seitentausch-Strategien (swapen dann mappen): random=schwach, RR=fair, FIFO=Sehr fair


3.2 Virtuelle Adressierung: Einführung II3.2 Virtuelle Adressierung: Einführung II

Vorteil: Es ist mit nur 32MB physical Memory möglich einen 1GB Prozess laufen zu lassen. Dazu werden die aktuell benötigten Speicherbereiche in den RAM geladen und nicht benötigte aus diesem verdrängt .

Funktionen auf Seiten-Basis: VirtualAlloc, VirtualFree, VirtualLock, VirtualUnlock ...

Funktionen auf definierbarer Basis (byte, word,...): HeapAlloc, HeapCreate, HeapDestroy, HeapFree...


3.2 Memory Management Architecture3.2 Memory Management Architecture

Windows Program

Heap API: H e a p C r e a t e , H e a p D e s t r o y , H e a p A l l o c , H e a p F r e e

MMF API: C r e a t e F i l e M a p p i n g , C r e a t e V i e w O f F i l e

Virtual Memory API

Windows Kernel withVirtual Memory Manager

PhysicalMemory

Disc &FileSystem

C library: malloc, free


3.3 Heaps: Einführung3.3 Heaps: Einführung

Ein Heap (engl: Haufen) ist ein Speichervorrat, welcher dem Stack (lokaler Prozedur-Speicher) entgegen wächst.

Jeder Prozess besitzt min. einen Default-Heap.

Speicheranforderungen durch malloc, realloc, calloc, werden vom Default-Heap abgezogen.

Jeder Heap wird automatisch bis zur definierten Obergrenze erweitert => und immer auf ganze Seiten gerundet.

Ein Heap in Windows ist ein Objekt somit existiert zu diesem ein Handle: HANDLE GetProcessHeap(VOID)


3.3 Heaps: Beispiel separater Heaps3.3 Heaps: Beispiel separater Heaps

Node

Node

Node

Record

Record

Record

Not allocated

Not allocated

Not allocated

Not allocated

ProcessHeap

RecHeap

NodeHeap

Virtual Address Space Program

P r o c H e a p = G e t P r o c e s s H e a p ( ) ;

p R o o t = H e a p A l l o c ( P r o c H e a p ) ;

R e c H e a p = H e a p C r e a t e ( ) ;

N o d e H e a p = H e a p C r e a t e ( ) ;

w h i l e ( ) {

p R e c = H e a p A l l o c ( R e c H e a p ) ;

p N o d e = H e a p A l l o c ( N o d e H e a p ) ;· · ·

}H e a p F r e e ( R e c H e a p , 0 , p R e c ) ;

H e a p F r e e ( N o d e H e a p , 0 , p N o d e ) ;

H e a p D e s t r o y ( R e c H e a p ) ;

H e a p D e s t r o y ( N o d e H e a p ) ;

· · ·

· · ·

· · ·


3.3 Heaps: Vorteile separater Heaps3.3 Heaps: Vorteile separater HeapsFairness: kein Thread kann mehr Speicher anfordern als für dessen Heap reserviert ist. (Memory-Leaks betreffen nur diesen Thread)

Multithreaded-Preformence: Der Wettstreit um den default Heap des Prozesses entfällt, dies kann substantielle preformence Verbesserung mit sich bringen.

Allocation Efficency: Speicheranforderungen auf einen kleinen Heap welche nur in einer bestimmten Größe auftreten sind effizienter als Anforderungen auf einen großen Heap, welche in den verschiedensten Größen auftreten. Somit Reduzierung von Fragmentration.

Deallocation Efficeny: Der gesamte Heap kann mit nur einem Funktionsaufruf beseitigt werden, wobei auch Memory-Leaks beseitigtwerden.

Locality of Reference Efficency: Wird für eine Datenstruktur ein kleiner Heap verwendet, so wird das Risiko von Page-Faults reduziert, da sich die Struktur dann nur über wenige Speicherseiten erstreckt.


3.3 Heaps: Optionen der Heap API3.3 Heaps: Optionen der Heap API

HEAP_GENERATE_EXCEPTIONS: Nutzung eines SEH (StructuredExceptionHandler) zur Fehlerbehandlung. Vorteil: Kein Fehlertest nach einer Heapoperation notwendig

HEAP_NO_SERIALIZE:Schaltet Mutal-Exclusion Mechanismus bei zugriff auf Heap aus.

Sicher wenn: 1.) Der Prozess (Hauptthread) exklusiv den Default-

Heap und keinen der Thread-Heaps verwendet.2.) Jeder Thread exklusiv seinen eigenen Heap besitzt.

sonst: Bei gleichzeitiger Nutzung eines Heaps durch mehrere Threads muss ein Mutal-Exclusion Mechanismus implementiert werden.

HEAP_ZERO_MEMORY: Angeforderter Speicher wird mit 0 Initialisiert.


3.3 Heaps: Erstellung3.3 Heaps: Erstellung

HANDLE HeapCreate ( DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize );

Rückgabewerte: NULL bei fehler sonst Heap-Handle.

Parameter:

Anmerkungen:

- flOptions: HEAP_GENERATE_EXCEPTIONS, HEAP_NO_SERIALIZE

- dwInitialSize: Initiale Heapgröße (wird in der Pagefile reserviert)

- dwMaximumSize: Maximale Heapgröße (wenn nicht 0, kein wachsen möglich)

- dwMaximumSize=0: bei bedarf gesamter freier virtueller Adressraum- dwMaximumSize<>0: dwMaximumSize wird allokiert aber es wird nur

dwInitialsize in der Pagefile reserviert.


3.3 Heaps: Loeschen3.3 Heaps: Loeschen

BOOL HeapDestroy ( HANDLE hHeap );

Rückgabewerte:

Parameter:

Anmerkungen:

- hHeap: Handle eines mit HeapCreate erstellten Heaps.

- Loeschen eines Heaps

- Der Default-Heap des Prozesses darf niemals zerstört werden.

- Es werden auch die in der Pageing-File ausgelagerten Teile freigegeben.

- Man kann somit durch nur einen Funktionsaufruf alle allokierten Datenstrukturen des Heaps löschen => Sehr schnell!

- Erfolg <> 0, sonst Misserfolg


3.3 Heaps: Speicherbereich anfordern3.3 Heaps: Speicherbereich anfordernHANDLE HeapAlloc ( HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes );

Rückgabewerte:

Parameter:

Anmerkungen:

- hHeap: Handle eines Heaps (GetProcessHeap, HeapCreate)- dwFlags: HEAP_GENERATE_EXCEPTIONS,

HEAP_NO_SERIALIZE, HEAP_ZERO_MEMORY

- dwBytes : Speicher in Byte welcher reserviert werden soll.

- NULL bei Fehler (wenn kein SHE) sonst Zeiger auf Speicherbereich der Größe dwBytes.

- Anfordern eines Speicherberiches vom Heap


3.3 Heaps: Speicherbereich freigeben3.3 Heaps: Speicherbereich freigebenBOOL HeapFree ( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem );

Rückgabewerte:

Parameter:

Anmerkungen:

- hHeap: Handle eines Heaps (HeapCreate)- dwFlags: HEAP_NO_SERIALIZE,- lpMem : Zeiger auf einen durch HeapAlloc oder HeapRelloc

allokierten Speicherbereich

- Freigabe eines allokierten Speicherbereiches eines Heaps

- Erfolg <> 0, sonst Misserfolg


3.3 Heaps: Speicherbereichsgröße ändern3.3 Heaps: Speicherbereichsgröße ändernLPVOID HeapReAlloc ( HANDLE hHeap, DWORD dwFlags,

LPVOID lpMem, DWORD dwBytes );Rückgabewerte:

Parameter:

Anmerkungen:

- hHeap: Handle eines Heaps (HeapCreate)- dwFlags: HEAP_GENERATE_EXCEPTIONS,

HEAP_NO_SERIALIZE, HEAP_ZERO_MEMORY (neu allokierter Speicher),

HEAP_REALLOC_IN_PLACE_ONLY (Block nicht verschieben)- lpMem : Zeiger auf einen durch HeapAlloc oder HeapRelloc

allokierten Speicherbereich - dwBytes : Speicher in Byte welcher reallokiert werden soll.

- Keine

- NULL bei Fehler (wenn kein SHE) sonst Zeiger auf Speicherbereich der Größe dwBytes.


3.3 Heaps: Speicherbereichsgröße ermitteln3.3 Heaps: Speicherbereichsgröße ermittelnDWORD HeapSize ( HANDLE hHeap, DWORD dwFlags,

LPVOID lpMem );

Rückgabewerte:

Parameter:

Anmerkungen:

- hHeap: Handle eines Heaps (HeapCreate)- dwFlags: HEAP_NO_SERIALIZE,- lpMem : Zeiger auf einen durch HeapAlloc oder HeapRelloc

allokierten Speicherbereich

- Ermittelt die Größe eines Speicherbereiches eines Heaps, nicht die Größe des Heaps!

- 0 bei Fehler (wenn kein SHE) sonst Größe des Speicherbereiches in Bytes.


3.3 Heaps: weitere Funktionen3.3 Heaps: weitere Funktionen

HeapValidate: Feststellen ob ein Heap korrupiert wurde.

HeapCompact: Defragmentieren eines Heaps durch zusammenfassen von freien Blöcken und freigeben von großen Freibereichen.

HeapWalk: Ermittelt alle allokierten Speicherbereiche eines Heaps.

HeapLock, HeapUnlock: Dient Mutal-Exclusion Mechanismen.


SystemaufrufeUNIX Win32 BeschreibungNur default-Heap HeapCreate Erstellt einen Heap

Nicht vorhanden! HeapDestroy Löscht einen Heap

malloc da nur default-Heap

HeapAlloc Allokiert einen Speicherbereich vom Haeap

realloc Da nur default-Heap

HeapReAlloc Heap-Speicherbereichneu dimensionieren.

Nicht vorhanden! HeapSize Heap-Speicherbereichgröße.

Nicht vorhanden! HeapValidate Heap korrupiert?

Nicht vorhanden! HeapCompact Heap defragmentieren

Nicht vorhanden! HeapWalk Heapgröße ermitteln

Nicht vorhanden! HeapLock Heap sperren (mutal exc.)

Nicht vorhanden! HeapUnlock Heap freigabe (mutal exc.)

3.3 Heaps: Systemaufrufe3.3 Heaps: Systemaufrufe


3.4 Memory-Mapped Files3.4 Memory-Mapped Files: Einführung: Einführung

Rechtfertigung:- Bei der Virtuellenspeicherverwaltung muss Speicher für Objekte (Heap-Bereiche) in der Auslagerrungsdatei (Swaping) bereitgestellt werden. - Wird ein Prozess terminiert, so geht der zugehörige Auslagerrungsdateispeicher verloren. - Lösung: Man nutzt MMF's statt der Auslagerrungsdatei.

Vorteile:- Ermöglichen das Einblenden eines Objektes in den virtuellen Adressraum eines Prozesses.- Für MMF‘s wird keine File-I/O-API benötigt- Inhalte von Datenstrukturen können wiederverwendet werden.- Implementierung für Dateipuffer entfällt! - Bietet die Möglichkeit Daten mit anderen Prozessen zu teilen.- Die Auslagerungsdatei wird entlastet.


3.4 Memory-Mapped Files: Rechte3.4 Memory-Mapped Files: Rechte

Für MMF‘s werden Rechte wie bei Dateien vergeben.

PAGE_READONLY:Die Seiten des allokierten Speicherbereiches können nur gelesen werden.

PAGE_READWRITE:Vollzugriff, die Die Seiten des allokierten Speicherbereiches können gelesen und beschrieben werden insofern für die zugehörige Datei sowohl GENERIC_READ als auch GENERIC_WRITE definiert wurden.

PAGE_WRITECOPY: Wird die MMF verändert (beschrieben), so wird eine Kopie dieser in der Pageing-File angelegt.


3.4 Memory-Mapped Files3.4 Memory-Mapped Files: Erstellen I: Erstellen IHANDLE CreateFileMapping( HANDLE hFile,

LPSECURITY_ATTRIBUTES lpsa, DWORD fdwProtect,

DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCTSTR lpMapName );

Parameter:- hFile: Datei-Handle mit kompatiblen Rechten zu fdwProtect.

- lpsa : Spezielle Zugriffsrechte, für normale Dateien: NULL (wird z.B.: dann genutzt, wenn das MMF eine EXE-Datei ist)

- fdwProtect : Zugriffsrechte der MMF siehe HIER

- dwMaximumSizeHigh : Absolute Maximalgröße der MMF, MMF kann nicht darüber hinaus wachsen!

- dwMaximumSizeLow : Mindestgröße der MMF

- lpMapName: Namensraum, erlaubt den Zugriff von anderen Prozessen aus.


3.4 Memory-Mapped Files3.4 Memory-Mapped Files: Erstellen II: Erstellen IIHANDLE CreateFileMapping( HANDLE hFile,

LPSECURITY_ATTRIBUTES lpsa, DWORD fdwProtect,

DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCTSTR lpMapName );

Rückgabewerte:

Anmerkungen:

- NULL bei Fehler sonst MMF-Handle.

- Wenn dwMaximumSizeHigh=0 und dwMaximumSizeLow=0, dann größe der MMF = Dateigröße


3.4 Memory-Mapped Files3.4 Memory-Mapped Files: Öffnen: ÖffnenHANDLE OpenFileMapping ( DWORD dwDesiredAccess,

BOOL bInheritHandle,LPCTSTR lpNameP );

Rückgabewerte:

Parameter:

Anmerkungen:

- dwDesiredAccess: Zugriffsrechte der MMF siehe HIER- bInheritHandle: Dient der Vererbung des Objektes.- lpNameP: Namensraum welcher durch

CreateFileMapping vergeben wurde.


- Kann mit CloseHandle gelöscht werden.


3.4 Memory-Mapped Files3.4 Memory-Mapped Files: Einblenden: EinblendenHANDLE MapViewOfFile ( HANDLE hMapObject, DWORD dwAccess,

DWORD dwOffsetHigh, DWORD dwOffsetLow, DWORD cbMap);

Rückgabewerte:

Parameter:

Anmerkungen:

- hMapObject: Handle eines MMF-Objektes.- dwAccess: Zugriffsrechte (Kompatibel zu MMF-Objekt wählen!)- cbMap: Größe der gemappten Region in Byte.- dwOffsetHigh, dwOffsetLow: Startadresse der View im Objekt.

- NULL bei Fehler sonst Startadresse der file-view.

- cbMap = 0 => ganzes File Mappen- dwOffsetHigh und dwOffsetLow = 0 dann vom Dateianfang mappen, sonst immer ein Vielfaches von 64K wählen


3.4 Memory-Mapped Files3.4 Memory-Mapped Files: Beispiel: Beispiel


SystemaufrufeUNIX Win32 BeschreibungNicht vorhanden! CreateFileMapping Erstellt ein MMFNicht vorhanden! OpenFileMapping Öffnet eine MMFmmap (jede reguläre Datei)

MapViewOfFile MMF in Addressraum einblenden.

munmap UnmapViewOfFile MMF schließen

3.4 MMF: Systemaufrufe3.4 MMF: Systemaufrufe


3.5 Statische Bibliotheken3.5 Statische Bibliotheken

Eigenschaften:beim Kompilationsvorgang werden Bibliothekskomponenten ins Programm hineinkopiert. (Code und Daten)Programm ist nach Kompilation unabhängig von der Bibliothek. (Version bzw. Vorhandensein der Bibliothek)Programme werden größer (Speicherbedarf!)Um von Updates zu profitieren, muss das Programm neu kompiliert werden.Es findet eine statische Typenkontrolle statt.

Beim Linken des Programmes:Linker verbindet Statische Bibliotheken mit dem Kompilat. Linker setzt daraus ein ausführbares Programm zusammen.Linker sucht aus den Bibliotheksdateien die im Programm referenzierten, Komponenten heraus, und fügt sie dann in das Programm ein.


3.5 Dynamische Bibliotheken3.5 Dynamische Bibliotheken

DLL allgemein:werden bei bedarf von der Festplatte geladen (Ladeverzögerung!)Versionswahl zur Laufzeit möglich (explizites linken).

DLL als shared library:können von mehreren Programmen gleichzeitig benutzt werdenbefinden sich nur ein mal im SpeicherDLL-Komponenten werden in den Adressraum des Programms eingeblendet (gemappt)


//mydll.cpp

extern "C" int summe( int a, int b ){

return a + b;}

#include <stdio.h>extern "C" void _init( void ){

printf(„Bibliothek geöffnet“}

extern "C" void _fini( void ){

printf(„Bibliothek geschlossen“}

g++ -Wall -shared mydll.cpp -o libmydll.so

3.5 Dyn. Bibliothek erstellen UNIX:3.5 Dyn. Bibliothek erstellen UNIX:


//mydll.cpp

extern "C" __declspec(dllexport) int summe( int a, int b ){ return a + b;}

BOOL APIENTRY DllMain( HANDLE ModulHandle, DWORD state, LPVOID lpReserved ){ switch( state ) { case DLL_PROCESS_ATTACH: // Die DLL wird in den Adreßraum eines Prozesses eingeblendet case DLL_THREAD_ATTACH: // Der zugehörige Prozeß hat einen neuen thread gestartet. case DLL_THREAD_DETACH: // Der zugehörige Prozeß hat einen thread gestoppt. case DLL_PROCESS_DETACH: // Die DLL wird aus dem Prozeßraum eines Prozesses entfernt default: /*ERROR*/ break; } return TRUE;}

cl -LD -GX mydll.cpp

3.5 Dyn. Bibliothek erstellen Windows:3.5 Dyn. Bibliothek erstellen Windows:


3.5 Dyn. Bibliotheken: implizietes linken3.5 Dyn. Bibliotheken: implizietes linken

Unter Windows entstehen beim Erzeugen einer DLL zwei Dateien: lib-Datei: enthält Platzhalter für Programmcode bzw. Daten die sog.„stubs“ dll-Datei: enthält Programmcode bzw. die Daten

Beim Linken des Programmes:Es werden lediglich die Platzhalter in das Programm eingebunden.Das Programm wird nicht so groß.Es findet eine statische Typenkontrolle statt.

Beim starten des Programmes:Benötigte DLL's werden geladen.Verweise auf Dummyfunktionen im Programm werden ersetzt. Dann Programmstart.

Beim ausführen des Programmes:Kein Unterschied.


#include <stdio.h>

extern "C" int summe( int, int );

int main(){ printf( "Summe von %d und %d ist %d\n",i,i/2,summe( i, i/2 )); return 0;}

- Beim impliziten linken ist das Einbinden der Bibliothek für UNIX und Windows gleich

Windows oder UNIX:

3.5 Dyn. Bibliotheken: Einbinden (implizietes linken)3.5 Dyn. Bibliotheken: Einbinden (implizietes linken)


3.5 Dyn. Bibliotheken: explizites linken3.5 Dyn. Bibliotheken: explizites linken

Beim Linken des Programmes:Dem Compiler und damit dem Linker werden die Komponenten der Bibliothek nicht bekannt gemacht.Es findet für Bibliotheksfunktionen keine Typenkontrolle statt.Nutzung On-Demand. (Programmierer hat mehr Kontrolle.)

Beim starten des Programmes:Kein Unterschied.

Beim ausführen des Programmes:Bibliotheken werden durch Betriebssystemfunktionen geladen.Bibliothekskomponenten werden durch Betriebssystemfunktionen genutzt.


3.5 Dyn. Bibliotheken explizites linken Systemaufrufe:3.5 Dyn. Bibliotheken explizites linken Systemaufrufe:

SystemaufrufeUNIX Win32 Beschreibungvoid* HINSTANCE Typ des Objektesdlopen LoadLibrary Bibliothek öffnendlclose FreeLibrary Bibliothek schließen

dlsym GetProcAddress Funktionspointer ermitteln


// einmalig die Bibliothek laden:so_handle = dlopen( "libmydll.so", RTLD_LAZY );

// Typ: Zeiger auf Funktion, die int liefert, zwei int erhält:typedef int ( *pFuncSumme )( int, int );

// Zeiger auf die Funktion in der DLL:pFuncSumme summe_pf = NULL;

if( !so_handle ){ // Laden der Bibliothek hat nicht geklapppt! char *Fehlertext = dlerror(); perror(Fehlertext); exit(EXIT_FAILURE);}

// Zeiger auf die darin enthaltenen Funktionen holen: summe_pf = (pFuncSumme)dlsym( so_handle, "summe" );

UNIX:

3.5 Dyn. Bibliotheken: Einbinden (explizites linken)3.5 Dyn. Bibliotheken: Einbinden (explizites linken)


// Typ: Zeiger auf Funktion, die int liefert, zwei int erhält:typedef int ( *pFuncSumme )( int, int );

// Zeiger auf die Funktion in der DLL:pFuncSumme summe_pf = NULL;

// einmalig die Bibliothek laden:DLL_Handle = LoadLibrary( "mydll.dll");

if( !DLL_Handle ){

GetLastError() fprintf( stderr, "Fehler beim Laden der DLL!\n" ); exit( 2 );}

// Zeiger auf die darin enthaltenen Funktionen holen:summe_pf = (pFuncSumme) GetProcAddress( DLL_Handle, "summe" );

Windows:

3.5 Dyn. Bibliotheken: Einbinden (explizites linken)3.5 Dyn. Bibliotheken: Einbinden (explizites linken)


3.6 Prozesse: Einführung3.6 Prozesse: EinführungBeim Linken des Programmes:

DJeder Prozess besitzt seinen eigenen und unabhängigen virtuellen Adressraum.Jeder Prozess besitzt 1..N Threads. (Leichtgewichtsprozesse)

Jeder Prozess kann: - Neue Threads erstellen (vom Prozess abhängig).- Neue unabhängige Prozesse erstellen.- Mit anderen Prozessen Kommunizieren.

Jeder Prozess hat:- Ein oder mehr Datensegmente mit Globalen variablen- Ein oder mehr Codesegmente- Ein oder mehr Heaps- Einen Stack (Prozess-Thread)

Jeder Thread:- Nutzt Daten, Code, Heaps und die Umgebungsvariablen des Prozesses. (Synchronisation!)

Code

Global Variables

Process Heap

Process ResourcesOpen Files, Heaps,

· · ·Environment Block

· · ·TLS

Stack

Thread N

TLS

Stack

Thread 1


3.6 Prozesse: erstellen I3.6 Prozesse: erstellen ILBOOL CreateProcess ( LPCTSTR lpImageName,

LPTSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpsaProcess,

LPSECURITY_ATTRIBUTES lpsaThread,BOOL bInheritHandles,

DWORD dwCreate, LPVOID lpvEnvironment, LPCTSTR lpCurDir,

LPSTARTUPINFO lpsiStartInfo,LPPROCESS_INFORMATION lppiProcInfo)

Rückgabewerte: - NULL bei Fehler (wenn kein SHE) sonst Zeiger auf Speicherbereich der Größe dwBytes.


3.6 Prozesse: erstellen II3.6 Prozesse: erstellen IIParameter:

- lpImageName:- lpCommandLine:- lpsaProcess:- lpsaThread:- bInheritHandles:

- dwCreate:- lpvEnvironment:

- lpCurDir:- lpsiStartInfo:- lppiProcInfo:

Name des auszuführenden Programms. Komandozeilen ArgumenteSicherheitsattribute des Programms. (NULL=Default)Sicherheitsattribute des Threads. (NULL=Default)Option: Handles an Kinder vererben (Flag)Handles müssen dennoch als vererbbar markiert sein.Verschiedene Prozesserstellungsoptionen (Flags) siehe HierUmgebungsvariablen (NULL=Parrent's)Umgebungsvariablen sind Paare: (Name;Wert)aktuelles Arbeitsverzeichnis (NULL=Parrent's)Eigenschaften des Hauptfensters des Programms.Informationen über den erstellten Prozess(Ausgabeparameter)


3.6 Prozesse: Erstellungsoptionen 3.6 Prozesse: Erstellungsoptionen (dwCreate)(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 alleteilnehmenden Prozesse die gleiche Konsole benutzen.


3.6 Prozesse: Prozessinformationen3.6 Prozesse: ProzessinformationenProzesse 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.


3.6 Prozesse: Terminieren3.6 Prozesse: Terminieren

VOID ExitProcess (UINT nExitCode);Parameter:

An merkungen:

- nExitCode: Terminierungsstatus

- Beendet den aufrufenden Prozess mit all seinen Threads - Ignoriert _finaly und _except Handler des SEH! (Resourcen vorher freigeben!)

BOOL TerminateProcess ( HANDLE hProcess, UINT uExitCode );Parameter:

An merkungen:- hProcess: Handle eines Prozesses.- uExitCode: Terminirungsstatus (Eingabe-Parameter)

- Beendet einen anderen Prozess mit all einen Threads- Ignoriert SEH komplett!- Resourcen werden nicht freigeben!


3.6 Prozesse: Auf Terminierung warten3.6 Prozesse: Auf Terminierung wartenHANDLE OpenProcess ( DWORD fdwAccess, BOOL fInherit,

DWORD IDProcess );

Parameter:

Rückgabewerte:

Anmerkungen:

- hObject: Handle eines Objektes. Hier: Prozess-Handle.

- dwTimeOut: Wartezeit in Millisekunden.

0=>blockiert nicht, INFINITE=>blockiert

- Keine

- WAIT_OBJECT_0: Prozess wurde beendet.

- WAIT_TIMEOUT: Wartezeit ist abgelaufen.

- WAIT_FAILED: Warten fehlgeschlagen (z.B.: keine SYNCHONIZE-Option gesetzt)


3.6 Prozesse: Terminierungssignale3.6 Prozesse: Terminierungssignale

BOOL GenerateConsoleCtrlEvent ( DWORD dwCtrlEvent, DWORD dwProcessGroup );

Rückgabewerte:

Parameter:

Anmerkungen:

- 0 bei Fehler sonst Erfolg.

- Ermöglicht es anderen Prozessen ihre Resourcen freizugeben bevor sie terminieren.

- dwCtrlEvent: Beenden: CTRL_C_EVENT (Dabei: dwProcessGroup=NULL) Unterbrechen: CTRL_BREAK_EVENT

- dwProcessGroup: Spezifiziert die betreffende Prozessgruppe


3.6 Prozesse: öffnen3.6 Prozesse: öffnenHANDLE OpenProcess ( DWORD fdwAccess, BOOL fInherit,

DWORD IDProcess );

Rückgabewerte:

Parameter:

Anmerkungen:

- fdwAccess: Terminierungs Optionen: - PROCESS_ALL_ACCESS: Alle Zugriffsrechte erlauben. (Default von CreateProcess)

- SYNCHRONIZE: Erlaubt warten auf Beendigung.- PROCESS_TERMINATE: Erlaubt Terminierung durch TerminateProcess()- PROCESS_QUERY_INFORMATION: Erlaubt Abfrage von Prozessinformationen durch

GetExitCodeProcess() und GetPriorityClass()

- fInherit: Option: Rückgabe-Handle vererbbar?- IDProcess: Idendifiziert den zu öffnenden Prozess.


- Kann mit CloseHandle gelöscht werden.


3.6 Prozesse: Terminierungsstatus abfragen3.6 Prozesse: Terminierungsstatus abfragen

BOOL GetExitCodeProcess ( HANDLE hProcess, LPDWORD lpdwExitCode );

Rückgabewerte:

Parameter:

Anmerkungen:

- hProcess: Handle eines Prozesses.- lpdwExitCode: Terminirungsstatus (Ausgabeparameter)

- Ungleich 0 bei Erfolg sonst Fehler.

- Ermittelt den Terminierungsstatus eines Prozesses.

- Der Prozess muss die Abfrage durch PROCESS_QUERY_INFORMATION erlauben


SystemaufrufeUNIX Win32 Beschreibungfork, das Kind ruft execl oder execle oder … auf.

CreateProcess Einen neuen Prozess erstellen

exit- schliesst Dateien- schreibt Pufferdaten in Dateien

ExitProcess- terminiet den Prozess sofort

Prozess beendet sich selbst.

Waitpid(unblocking option) wait (blocking)

WaitForSingleObject Auf Terminierung von Prozessen warten

kill GenerateConsoleCtrlEvent

Terminierungssignal senden

Nicht vorhanden! OpenProcess öffnet einen existierenden Prozess

Waitpid(unblocking option) wait (blocking)

GetExitCodeProcess Terminierungsstatus

kill mit SIGKILL, SIGTERM

TerminateProcess anderen Prozess beenden

3.6 Prozesse: Systemaufrufe3.6 Prozesse: Systemaufrufe


int pid;pid = fork();if(pid==0){ // Kindprozess execle ("/bin/ls", NULL);}

// Wait until child process exits.int status=0;wait(&status);

3.6 Prozesserstellung: Unix3.6 Prozesserstellung: Unix


STARTUPINFO si; PROCESS_INFORMATION pi;

// Start the child process. CreateProcess( NULL, // No module name (use command line) argv[1], // Command line

NULL, // Process handle not inheritable NULL, // Thread handle not inheritable FALSE, // Set handle inheritance to FALSE 0, // No creation flags NULL, // Use parent's environment block NULL, // Use parent's starting directory &si, // Pointer to STARTUPINFO structure &pi ) // Pointer to PROCESS_INFORMATION structure ) ;

// Wait until child process exits. WaitForSingleObject( pi.hProcess, INFINITE );

// Close process and thread handles. CloseHandle( pi.hProcess ); CloseHandle( pi.hThread );

3.6 Prozesserstellung: Windows3.6 Prozesserstellung: Windows


3.6 Prozesse: Vererbung von Handles I3.6 Prozesse: Vererbung von Handles I

Vorteil: Erlaubt Zugriff auf Objekte des Elternprozesses.

Funktionsweise:Handle muss (bei Erstellung bzw. Duplizierung) vererbbar definiert werden (SECURITY_ATTRIBUTES)

Elternprozess erlaubt Nutzung seiner HandlesbInheritHandle=TRUE für CreateProcess()

Elternprozess sendet Handles an das Kind.- durch die Struktur STARTUPINFO für CreateProcess() in der STDIN bzw. STDOUT überschreiben werden.- durch IPC, Umgebungsvariablen, CML-Parameter

Anmerkungen:- vererbte Handles sind eigenständige Kopien.

(z.B.: unabhängiger File-Pointer bei Dateihandle)- auch vererbte Handles müssen geschlossen werden


3.6 Prozesse: Vererbung von Handles II3.6 Prozesse: Vererbung von Handles II

Handle Übermittlung: Überschreiben von hStdInput bzw. hStdOutput mit File-Handles welche an das Kind weitergereicht werden sollen.

dwFlags muss auf STARTF_USESTDHANDLES setzen.

Kindprozess erstellen.

typedef struct _STARTUPINFO { ...

DWORD dwFlags;HANDLE hStdInput;HANDLE hStdOutput;HANDLE hStdError;

} STARTUPINFO;


3.6 Prozesse: Vererbung von Handles III3.6 Prozesse: Vererbung von Handles III

Erstellen von vererbaren Handles:

Handle h1, h2, h3;SECURITY_ATTRIBUTES sa = (sizeof (SECURITY_ATTRIBUTES), NULL, TRUE);...h1 = CreateFile (..., &sa, ...) // vererbbares Handleh2 = CreateFile (..., NULL,...) // nicht vererbbares Handle

typedef struct SECURITY_ATTRIBUTES {

DWORD nLength;LPVOID lpSecurityDescriptor;BOOL bInheritHandle;

} SECURITY_ATTRIBUTES;


3.6 Prozesse: Vererbung von Handles IV3.6 Prozesse: Vererbung von Handles IV

Process 1’sObject Table

Process 2’sObject Table

File A

File B

File C

File D

File E

Handle 1

Handle 2

Handle 3

Handle 4

Inheritable Inherited Handle 1

Handle 2

Handle 3

Handle 4Create File

Create File

Inherited

Not Inheritable

Not Inheritable

Inheritable

ChildParent

Win32 Systemprogrammierung - cs.hs-rm.deweber/sysprog/proj0809/win32.pdf · 30.01.2009 Win32 Systemprogrammierung 6 1.1 Einführung Versionen Win32 ist die 32-Bit-API für moderne

Documents