Tafelübung zu BSRvS1 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/teaching/ss2008/bsrvs1/exercises/ 1
Agenda Besprechung Aufgabe 3: Philosophen System-Calls unter Linux wie funktioniert das eigentlich? dynamische Speicherverwaltung: Buddy-Verfahren Aufgabe 4: Speicherverwaltung dynamische Speicherverwaltung in C: malloc/free Speicherverwaltung im Eigenbau: First-Fit Umgang mit der Freispeicherliste Tipps zur Implementierung BSRvS1: Übung 04 Speicherverwaltung 2
Besprechung Aufgabe 3 Foliensatz Besprechung BSRvS1: Übung 04 Speicherverwaltung 3
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 sinnvoll Ein fehlerhaftes Anwendungsprogramm kann das System zum Absturz bringen Jedes Anwendungsprogramm hat volle Zugriffsrechte z.b. Scheduling und Rechteverwaltung unmöglich Kernel liegt in geschütztem Speicher BSRvS1: Übung 04 Speicherverwaltung 4
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; } BSRvS1: Übung 04 Speicherverwaltung 5
Systemstruktur Applikation read() Applikation Applikation... Userspace libc Systemcall Schnittstelle Kernel Subsysteme Kernelspace Gerätetreiber Hardware BSRvS1: Übung 04 Speicherverwaltung 6
Ablauf eines Systemcalls 0) Aufruf von read(...) 1) nbytes Stack 2) buffer Adresse Stack 3) Dateideskriptor Stack 4) Aufruf der Bibliotheksfunktion 5) Nr. des Syscalls sys_read eax Register 6) Parameter ebx, ecx, edx Register 7) Softwareinterrupt int 0x80 8) Zugriff auf Syscall Tabelle 9) Aufruf des passenden Handlers 10) Rückkehr der Handlerfunktion 11) Rückkehr zur aufrufenden Applikation 12) Argumente wegräumen durch Pointer-Anpassung BSRvS1: Übung 04 Speicherverwaltung 7
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() { asm("mov $0x01, %eax"); /* syscall # in eax */ asm("mov $0xff, %ebx"); /* Parameter 255 in ebx */ asm("int $0x80"); /* Softwareinterrupt an Kernel */ return 0; } pohl@host:~$./myexit pohl@host:~$ echo $? 255 pohl@host:~$ BSRvS1: Übung 04 Speicherverwaltung 8
Buddy-Algorithmus Speicherplatzierungsstrategie sukzessives Halbieren des freien Speichers bis zum best-fit der angeforderten Speichermenge BSRvS1: Übung 04 Speicherverwaltung 9
Buddy-Algorithmus: Reservierung Suche nach einem Speicherbereich, der die passende Größe hat (minimaler Block mit der Größe 2 k angeforderter Speicher) wird ein Speicherbereich der Größe 2 k gefunden reservieren, Ende sonst versuche diesen wie folgt zu erzeugen: 1. teile einen freien Speicherbereich > 2 k in zwei Hälften 2. ist eine Hälfte von der Größe 2 k (oder die untere Grenze erreicht) reservieren, Ende 3. gehe zu 1. Bsp.: Anforderung von 200KiB (auf 2 k aufgerundet: 256KiB) 1024KiB 512KiB 512KiB 256KiB 256KiB 512KiB BSRvS1: Übung 04 Speicherverwaltung 10
Buddy-Algorithmus: Freigabe Gebe den Speicherbereich frei und betrachte den angrenzenden Buddy ist dieser ebenfalls nicht belegt, so fasse diese beiden zusammen wiederhole die Zusammenfassung von Buddys, bis ein Speicherbereich belegt oder der ganze Speicher freigeben ist Buddies 256KiB 256KiB 512KiB 512KiB 512KiB 1024KiB BSRvS1: Übung 04 Speicherverwaltung 11
Buddy-Algorithmus: Beispiel Beispielablauf (1024K Speicher vorhanden): Programm A fordert 34K an Programm B fordert 66K an Programm C fordert 35K an Programm D fordert 67K an Programm C gibt den Speicherbereich frei Programm A gibt den Speicherbereich frei Programm B gibt den Speicherbereich frei Programm D gibt den Speicherbereich frei BSRvS1: Übung 04 Speicherverwaltung 12
Buddy-Algorithmus: Beispiel Tafel Reservierung: Suche nach einem Speicherbereich, der die passende Größe hat (minimaler Block mit der Größe 2 k angeforderter Speicher) wird ein Speicherbereich der Größe 2 k gefunden reservieren, Ende sonst versuche diesen wie folgt zu erzeugen: 1. teile einen freien Speicherbereich > 2 k in zwei Hälften 2. ist eine Hälfte von der Größe 2 k (oder die untere Grenze erreicht) reservieren, Ende 3. gehe zu 1. Freigabe: Gebe den Speicherbereich frei und betrachte den angrenzenden Buddy ist dieser ebenfalls nicht belegt, so fasse diese beiden zusammen wiederhole die Zusammenfassung von Buddys, bis ein Speicherbereich belegt oder der ganze Speicher freigeben ist Beispiel: 2. B fordert 66K an Gesamtspeicherplatz 1024KiB 6. A gibt frei 1. A fordert 34K an 5. C gibt frei 3. C fordert 35K an 7. B gibt frei 4. D fordert 67K an 8. D gibt frei BSRvS1: Übung 04 Speicherverwaltung 13
Aufgabe 4: Speicherverwaltung Aufgabenteil a) Testprogramm für malloc/free malloc ( memory alloc ): reserviert dynamisch Speicher auf dem Heap aus malloc(3): void *malloc(size_t size) reserviert size Bytes liefert einen Pointer auf den Anfang des Speicherbereichs oder im Fehlerfall (!): NULL size_t: plattformunabhängiger Typ für Speicherbereichsgrößen (sizeof() liefert z.b. auch ein size_t zurück!) free: gibt zuvor mit malloc() (oder calloc/realloc) belegten Speicher wieder frei void free(void *ptr) Speicher darf nur 1x free()d werden! BSRvS1: Übung 04 Speicherverwaltung 14
Aufgabe 4: malloc/free Beispiel für malloc/free: int *first_n_squares(unsigned n) { int *array, i; array = malloc(n * sizeof(int)); /* kein Cast notwendig! */ if (array == NULL) { /* Fehlerbehandlung */ perror( malloc ); exit(exit_failure); } for (i = 0; i < n; ++i) /* Array befüllen... */ array[i] = i * i; return array; /*... und zurückliefern */ } /* Die Variable array hoert hier auf zu existieren nicht * * aber der Speicherbereich, auf den sie zeigt! */ int main(void) { int *ptr; /*... */ ptr = first_n_squares(200); printf( 10*10 = %d\n, ptr[10]); free(ptr); return 0; } BSRvS1: Übung 04 Speicherverwaltung 15
A4: Daten beliebigen Typs schreiben Testprogramm: magischen Wert in allokierten Bereich schreiben char *ptr; /* ptr ist nicht initialisiert, zeigt ins Nirvana */ ptr = malloc(42); /*... Fehlerbehandlung... */ ptr zeigt jetzt auf einen Speicherbereich der Länge 42 wie schreiben wir ein int mit dem Wert 0x12345678 an den Anfang? (int *)ptr (int *)ptr vom Typ char * ( Zeiger auf char ) Cast auf den Typ int * ( Zeiger auf int ) und ab da wie üblich: Dereferenzieren (* davor), um den Wert anfassen zu können, auf den der Zeiger zeigt! (Klammerung!) *((int *)ptr) ist vom Typ int (char *, auf int * gecastet, dereferenziert) *((int *)ptr) = 0x12345678; BSRvS1: Übung 04 Speicherverwaltung 16
Aufgabe 4: Speicherverwaltung Aufgabenteil b) Eigenes malloc / free schreiben zu verwaltender Speicherbereich hat fixe Größe (1 MiB) Strategie: First-Fit nimm den ersten freien Speicherblock, der mindestens die angeforderte Größe hat der Rest des gefundenen Speicherblocks darf natürlich nicht verloren gehen! Verwaltung des Freispeichers: verkettete Liste free_mem zeigt auf das erste Element free_mem 5 3 6 4 7... BSRvS1: Übung 04 Speicherverwaltung 17
Aufgabe 4: ff_alloc Speicherbelegung: Block mit der richtigen Größe finden Liste ist mit NULL terminiert Vorgehen? free_mem 5 3 6 4 7... BSRvS1: Übung 04 Speicherverwaltung 18
Aufgabe 4: ff_alloc Speicherbelegung: Block mit der richtigen Größe finden Liste ist mit NULL terminiert Vorgehen: Liste sequentiell durchlaufen aktueller Block groß genug? (Platz für Verwaltungsstruktur berücksichtigen!) ja: Block gefunden (und jetzt?) nein: weitersuchen, bis Ende (NULL) erreicht, oder Block gefunden free_mem 5 3 6 4 7... BSRvS1: Übung 04 Speicherverwaltung 19
Aufgabe 4: ff_alloc Block der richtigen Größe gefunden, d.h. Blockgröße minus Verwaltungsstrukturgröße >= Anforderung Passt dahinter ein weiterer Freispeicherblock? d.h., ist der verbleibende Platz (Blockgröße minus Verwaltungsstrukturgröße minus angeforderte Größe) mindestens so groß, dass noch eine Verwaltungsstruktur plus ein bisschen Speicher reinpasst? ja: Verwaltungsstruktur dort anlegen, verbleibende Größe eintragen, in Freispeicherliste einhängen Block aus der Freispeicherliste aushängen, Adresse hinter der Verwaltungsdatenstruktur zurückliefern free_mem 5 3 6 4 7... BSRvS1: Übung 04 Speicherverwaltung 20
Aufgabe 4: ff_alloc Block der richtigen Größe gefunden, d.h. Blockgröße minus Verwaltungsstrukturgröße >= Anforderung Passt dahinter ein weiterer Freispeicherblock? d.h., ist der verbleibende Platz (Blockgröße minus Verwaltungsstrukturgröße minus angeforderte Größe) mindestens so groß, dass noch eine Verwaltungsstruktur plus ein bisschen Speicher reinpasst? ja: Verwaltungsstruktur dort anlegen, verbleibende Größe eintragen, in Freispeicherliste einhängen Block aus der Freispeicherliste aushängen, Adresse hinter der Verwaltungsdatenstruktur zurückliefern free_mem 5 3 6 4 4 3... BSRvS1: Übung 04 Speicherverwaltung 21
Aufgabe 4: ff_free Speicher muss auch wieder freigegeben werden können ff_free bekommt, wie das libc-free, die Adresse, die vorher ff_alloc zurückgeliefert hat (zeigt also hinter die Verwaltungsstruktur!) Vorgehen? free_mem 5 3 6 4 4 3... BSRvS1: Übung 04 Speicherverwaltung 22
Aufgabe 4: ff_free Speicher muss auch wieder freigegeben werden können ff_free bekommt, wie das libc-free, die Adresse, die vorher ff_alloc zurückgeliefert hat (zeigt also hinter die Verwaltungsstruktur!) Vorgehen: Verwaltungsstruktur-Größe von der übergebenen Adresse abziehen einfache Freigabe : Block wieder irgendwo (z.b. vorne) in die Freispeicherliste hängen suboptimal (warum?)! aber: genügt für die Aufgabenstellung. free_mem 5 3 6 4 4 3... BSRvS1: Übung 04 Speicherverwaltung 23
Aufgabe 4: ff_free besser: freigegebenen Block an der richtigen Stelle in die Freispeicherliste einhängen wie findet man diese Stelle? danach, falls möglich, mit freien Nachbarn verschmelzen sonst entstehen nach und nach immer kleinere Freispeicherbereiche größere Anfragen können nicht mehr beantwortet werden Aufgabenteil optional! free_mem 5 3 6 4 7... BSRvS1: Übung 04 Speicherverwaltung 24
Aufgabe 4: Implementierungshinweise Pseudocode Allozierung: verkettete Freispeicherliste ablaufen, bis Ende (NULL) oder Block geeigneter Größe gefunden Blockgröße minus Verwaltungsstruktur minus angeforderter Größe kleiner als Mindestgröße für neuen Freispeicherblock? - ja: Block einfach aus Freispeicherliste aushängen, Adresse hinter der Verwaltungsstruktur an Benutzer zurückgeben - nein: die neue Größe im Block eintragen, neue Verwaltungsstruktur dahinterschreiben (dort deren Größe eintragen), neuen Block in die Freispeicherliste hängen, alten Block aushängen, Adresse hinter der Verwaltungsstruktur an Benutzer zurückgeben BSRvS1: Übung 04 Speicherverwaltung 25
Aufgabe 4: Implementierungshinweise Verwaltungsstruktur: simples struct samt Initialisierung in der Vorgabe struct mem_block { size_t size; /* Groesse des Blocks inklusive der Struktur */ struct mem_block *next; /* Zeiger auf das naechste Element */ }; Struktur an den Anfang eines Blocks schreiben? wie zuvor mit dem magischen Wert! etwas einfacher: Umweg über weitere Zeigervariable char *ptr; struct mem_block *mem; /*... ptr zeigt jetzt auf den Anfang eines Blocks... */ mem = (struct mem_block *)ptr; /* mem zeigt jetzt an dieselbe Adresse */ mem->size = 123; mem->next =...; BSRvS1: Übung 04 Speicherverwaltung 26
Aufgabe 4: Implementierungshinweise Noch eine abschließende Quizfrage zu Pointerarithmetik... Was ist der Unterschied zwischen... /* ptr hat einen gueltigen Wert */ return ((char *)ptr) + 1;... und... /* ptr hat einen gueltigen Wert */ return ((struct mem_block *)ptr) + 1;...? BSRvS1: Übung 04 Speicherverwaltung 27
Aufgabe 4: Implementierungshinweise Noch eine abschließende Quizfrage zu Pointerarithmetik... Was ist der Unterschied zwischen... /* ptr hat einen gueltigen Wert */ return ((char *)ptr) + 1;... und... /* ptr hat einen gueltigen Wert */ return ((struct mem_block *)ptr) + 1;...? Bei Berechnungen (Addition, Subtraktion,...) mit Zeigern hängt die Adressdifferenz vom Zeigertyp ab! Erhöhung um sizeof(char) vs. sizeof(struct mem_block)! BSRvS1: Übung 04 Speicherverwaltung 28