Tafelübung zu BSRvS 1 4. Speicherverwaltung

Transkript

1 Tafelübung zu BSRvS 1 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de 1

2 Agenda Besprechung Aufgabe 3: Kreuzung 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 mit Bitliste Exkurs: Bitoperationen in C BSRvS 1: U4 Speicherverwaltung 2

3 Besprechung Aufgabe 3 Foliensatz Besprechung BSRvS 1: U4 Speicherverwaltung 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 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 BSRvS 1: U4 Speicherverwaltung 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; } BSRvS 1: U4 Speicherverwaltung 5

6 Systemstruktur Applikation read() Applikation Applikation... Userspace libc Systemcall Schnittstelle Kernel Subsysteme Kernelspace Gerätetreiber Hardware BSRvS 1: U4 Speicherverwaltung 6

7 Ablauf eines Systemcalls 1) Argumente Stack (Konvention: Letztes zuerst) 2) Aufruf der Bibliotheksfunktion (Implizit: push Rücksprungaddresse) 3) Argumente in Register laden (Stack für User und Kernel versch.) 4) Interrupt auslösen 5) Interruptnummer Index in Tabelle, hält Addressen 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ücksprungaddr. noch auf Stack 11) Stack aufräumen BSRvS 1: U4 Speicherverwaltung 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:~$ BSRvS 1: U4 Speicherverwaltung 8

9 Buddy-Algorithmus Speicherplatzierungsstrategie sukzessives Halbieren des freien Speichers bis zum best-fit der angeforderten Speichermenge BSRvS 1: U4 Speicherverwaltung 9

10 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 (kleinstmöglich!) 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 BSRvS 1: U4 Speicherverwaltung 10

11 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 Buddies, bis ein Speicherbereich belegt oder der ganze Speicher freigeben ist Buddies 256KiB 256KiB 512KiB 512KiB 512KiB 1024KiB BSRvS 1: U4 Speicherverwaltung 11

12 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 BSRvS 1: U4 Speicherverwaltung 12

13 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 (kleinstmöglich!) 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 Buddies, bis ein Speicherbereich belegt oder der ganze Speicher freigeben ist Beispiel: Gesamtspeicherplatz 1024KiB (Tafelbild) 1. A fordert 34K an 5. C gibt frei 2. B fordert 66K an 6. A gibt frei 3. C fordert 35K an 7. B gibt frei 4. D fordert 67K an 8. D gibt frei BSRvS 1: U4 Speicherverwaltung 13

14 Dynamische Speicherverwaltung in C malloc ( memory alloc ): Standardbibliotheksfunktion, 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() ist z.b. auch vom Typ size_t!) free: gibt zuvor mit malloc (oder calloc/realloc) belegten Speicher wieder frei void free(void *ptr) Speicher darf nur 1x free()d werden! BSRvS 1: U4 Speicherverwaltung 14

15 Dynamische Speicherverwaltung in C 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; } BSRvS 1: U4 Speicherverwaltung 15

16 Dynamische Speicherverwaltung in C char *ptr = malloc(42); ptr zeigt jetzt auf einen Speicherbereich der Länge 42 wie schreiben wir ein int mit dem Wert 0x 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) = 0x ; BSRvS 1: U4 Speicherverwaltung 16

17 A4: eigene Speicherverwaltung void *ff_alloc(size_t size): belegt Speicher (wie malloc(3)!) void ff_free(void *ptr, size_t size): gibt frei ([fast] wie free(3)!) ein großer Speicherpool (globales char-array: mem_pool) eine Bitliste (char-array: free_list), die belegte Chunks verwaltet Vorgehen beim Belegen/Freigeben? (Tafelbild) mem_pool A B C D Speicher } free_list F8 FF CF... ein Chunk, z.b. 16 Bytes Bitliste markiert belegte Chunks fester Größe, z.b. 16 Bytes (rechte Spalte: Hexadezimaldarstellung, wie sie dump_free_mem verwendet) BSRvS 1: U4 Speicherverwaltung 17

18 A4: eigene Speicherverwaltung Vorgehen beim Belegen (ff_alloc) Speichergröße in Chunks umrechnen (aufrunden!) Bitliste durchsuchen, genügend Chunks in Folge frei? nein: NULL zurückliefern ja: - Speicherbereich belegen (Bits setzen!) - Adresse berechnen (beginnend bei mem_pool!) und zurückliefern Vorgehen beim Freigeben (ff_free) Adresse verwenden, um Nummer des Chunks zu berechnen - Differenz ((char *) ptr) - mem_pool verwenden! Speicherbereich freigeben (Bits löschen!) BSRvS 1: U4 Speicherverwaltung 18

19 Exkurs: Bitoperationen Wie setzt man ein einzelnes Bit in einem Byte (bzw. unsigned char)? Wie löscht man ein einzelnes Bit in einem Byte? Wie testet man ein einzelnes Bit in einem Byte? Zur Verfügung stehende Operationen: bitweises UND (Operator in C: &) bitweises ODER (in C: ) bitweise NEGATION (in C: ~) SHIFT nach links/rechts (in C: << bzw. >>) [bitweises EXKLUSIVES ODER (in C: ^)] (Tafelbild) unsigned char c = 0xF3; c = c & 0x0F; c = c 0x10; c = ~c; c = c << 1; /* dasselbe kuerzer */ c &= 0x0F; F8 c = 0x10; OR = FA c = ~c; c <<= 1; BSRvS 1: U4 Speicherverwaltung 19

20 Exkurs: Bitoperationen Setzen eines Bits Verodern von Eingabe und Bitfolge, in der nur das entsprechende Bit gesetzt ist: OR = Herstellen der Bitfolge in C mit Linksshift (1 << 2) Löschen eines Bits Verunden von Eingabe und Bitfolge, in der nur das entsprechende Bit nicht gesetzt ist: AND = Herstellen der Bitfolge in C mit Linksshift und Negation: ~(1 << 4) Testen eines Bits Verunden von Eingabe und Bitfolge, in der nur das entsprechende Bit gesetzt ist: AND = Ergebnis > 0 Gesuchtes Bit in der Eingabe ist gesetzt Ergebnis = 0 Gesuchtes Bit nicht gesetzt BSRvS 1: U4 Speicherverwaltung 20

21 Exkurs: Bitoperationen vs. logische Op. Bitoperatoren (&,, ~, ^, <<, >>) vs. logische Operatoren (&&,,!) für XOR und Shift gibt es kein Logik-Äquivalent in C! int a = 1, b = 2, c; c = a & b; /* Wert von c? */ c = a && b; /* Wert von c? */ c = ~b; /* Wert von c? */ c =!b; /* Wert von c? */ c =!!b; /* Wert von c? */ Vorsicht mit der Operatoren-Rangfolge! Was tut dieser Code? if (a & 3 == 3) {... } if ((a & 3) == 3) {...} bei Interesse: mehr dazu im Web ( BSRvS 1: U4 Speicherverwaltung 21

22 Pointerarithmetik 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 ((int *)ptr) + 1;...? BSRvS 1: U4 Speicherverwaltung 22

23 Pointerarithmetik 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 ((int *)ptr) + 1;...? Bei Berechnungen (Addition, Subtraktion,...) mit Zeigern hängt die Adressdifferenz vom Zeigertyp ab! Erhöhung um sizeof(char) vs. sizeof(int)! BSRvS 1: U4 Speicherverwaltung 23