Übung zu Betriebssysteme

Transkript

1 Übung zu Betriebssysteme Threadumschaltung 7. & 10. Dezember 2017 Andreas Ziegler Bernhard Heinloth Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl für Verteilte Systeme und Betriebssysteme

2 CPU Memory tatsächliche Hardware

3 vcpu0 Mem0 CPU Memory vcpu1 Mem1 vcpu2 Mem2 tatsächliche Hardware illusionierte Hardware

4 Speicher virtualisieren CPU virtualiseren

5 Speicher virtualisieren ist einfach: #define MEMSIZE 100 char Mem0[MEMSIZE]; char Mem1[MEMSIZE]; char Mem2[MEMSIZE]; Memory CPU virtualiseren Mem0 Mem1 Mem2

6 Speicher virtualisieren ist einfach: #define MEMSIZE 100 char Mem0[MEMSIZE]; char Mem1[MEMSIZE]; char Mem2[MEMSIZE]; Memory CPU virtualiseren - nicht teilbar im Ort Mem0 Mem1 Mem2

7 Speicher virtualisieren ist einfach: #define MEMSIZE 100 char Mem0[MEMSIZE]; char Mem1[MEMSIZE]; char Mem2[MEMSIZE]; Memory CPU virtualiseren Mem0 Mem1 Mem2 - nicht teilbar im Ort - aber teilbar in der Zeit

8 Koroutinen

9 Motivation: mehr Aktivitätsträger als CPUs void foo(){ int f = 42; } while (f--){ kout << "foo" << f << endl; } void bar(){ int b = 23; } while (b--){ kout << "bar" << b << endl; }

10 Einseitiger Aufruf

11 Einseitiger Aufruf void foo(){ int f = 42; while (f--){ kout << "foo" << f << endl; void bar(){ int b = 23; while (b--){ kout << "bar" << b << endl; } } bar(); } }

12 Einseitiger Aufruf foo41 foo40 foo1 foo0 bar22 bar0 foo() bar()

13 Einseitiger Aufruf foo41 foo40 foo1 foo0 bar22 bar0 foo() bar() nicht parallel

14 Gegenseitiger Aufruf

15 Gegenseitiger Aufruf void foo(){ static int f = 42; } while (f--){ kout << "foo" << f << endl; bar(); } void bar(){ static int b = 23; } while (b--){ kout << "bar" << b << endl; foo(); }

16 Gegenseitiger Aufruf foo() foo41 bar() bar22 foo() foo40 bar() bar21 foo() foo39 bar() bar20

17 Gegenseitiger Aufruf foo() foo41 bar() bar22 foo() foo40 bar() bar21 foo() foo39 bar() bar20 hoher Speicherverbrauch & Endlosrekursion

18 Umschaltung foo() vcpu0 Mem0 bar() vcpu1 Mem1

19 Umschaltung foo() vcpu0 Mem0 bar() vcpu1 Mem1 Kontrollflusszustand sichern & laden

20 Umschaltung foo() vcpu0 Mem0 bar() vcpu1 Mem1 Kontrollflusszustand sichern & laden Stack Register

21 Umschaltung foo() vcpu0 Mem0 bar() vcpu1 Mem1 Kontrollflusszustand sichern & laden } Stack toc (Thread of control) Register

22 Umschaltung foo() vcpu0 Mem0 bar() vcpu1 Mem1 Kontrollflusszustand sichern & laden } Stack toc (Thread of control) Register Umschaltefunktion

23 Umschaltung foo() vcpu0 Mem0 bar() vcpu1 Mem1 Kontrollflusszustand sichern & laden } Stack toc (Thread of control) Register Umschaltefunktion toc_switch(toc *now, toc *then); Wechselt vom aktuellen Kontext now nach then

24 Umschaltung void foo(){ int f = 42; } while (f--){ kout << "foo" << f << endl; toc_switch( &toc_foo, &toc_bar ); } void bar(){ int b = 23; } while (b--){ kout << "bar" << b << endl; toc_switch( &toc_bar, &toc_foo ); }

25 Umschaltung foo() bar() foo41 bar22 foo40 bar21 foo39 bar20

26 Kontextsicherung

27 Kontextsicherung durch den Übersetzer

28 Kontextsicherung durch den Übersetzer void foo(){ // flüchtige Register // sichern bar(); // flüchtige Register // wiederherstellen }

29 Kontextsicherung durch den Übersetzer void foo(){ // flüchtige Register // sichern bar(); // flüchtige Register // wiederherstellen void bar(){ // nicht-flüchtige // Register // sichern // nicht-flüchtige // Register // wiederherstellen } return; }

30 EAX EBX ECX EDX AX AH AL BX BH BL CX CH CL DX DH DL

31 EAX EBX ECX EDX AX AH BX BH CX CH DX DH AL BL CL DL ursprünglich Akkumulatorregister ursprünglich Basisregister ursprünglich Zählerregister Daten-/Allzweckregister

32 EAX EBX ECX EDX ESI EDI AX AH BX BH CX CH DX DH SI DI AL BL CL DL ursprünglich Zeichenkettenquellindex ursprünglich Zeichenkettenzielindex

33 EAX EBX ECX EDX ESI EDI EBP ESP AX AH BX BH CX CH DX DH SI DI BP SP AL BL CL DL Basiszeiger für Stapelrahmen Stapelzeiger

34 EAX EBX ECX EDX ESI EDI EBP ESP EIP AX AH BX BH CX CH DX DH SI DI BP SP IP AL BL CL DL Befehls-/Instruktionszeiger

35 EAX AX AH AL EBX BX BH BL EFLAGS FLAGS ECX CX CH CL EDX DX DH DL ESI SI EDI DI EBP BP ESP SP EIP IP

36 EAX AX AH AL EBX BX BH BL EFLAGS FLAGS ECX CX CH CL CS EDX DX DH DL DS ESI SI SS EDI DI ES EBP BP FS ESP SP GS EIP IP + FPU, MMX, SSE,

37 EAX AX AH AL EBX BX BH BL EFLAGS FLAGS ECX CX CH CL EDX DX DH DL ESI SI EDI DI EBP BP ESP SP EIP IP Flüchtige versus nicht-flüchtige Register

38 EAX AX AH AL EBX BX BH BL EFLAGS FLAGS ECX CX CH CL EDX DX DH DL ESI SI EDI DI EBP BP ESP SP EIP IP Flüchtige versus nicht-flüchtige Register

39 Struktur zur Kontextsicherung struct toc { void *ebx; void *esi; void *edi; void *ebp; void *esp; };

40 Struktur zur Kontextsicherung struct toc { void *ebx; void *esi; void *edi; void *ebp; void *esp; }; Kontext sichern nach struct toc * toc_obj;

41 Struktur zur Kontextsicherung struct toc { void *ebx; void *esi; void *edi; void *ebp; void *esp; }; Kontext sichern nach struct toc * toc_obj; in Assembler mov eax, toc_obj mov [eax + 0], ebx mov [eax + 4], esi mov [eax + 8], edi mov [eax + 12], ebp mov [eax + 16], esp

42 Struktur zur Kontextsicherung struct toc { void *ebx; void *esi; void *edi; void *ebp; void *esp; }; Kontext sichern nach struct toc * toc_obj; in Assembler mov eax, toc_obj mov [eax + ebx_offset], ebx mov [eax + esi_offset], esi mov [eax + edi_offset], edi mov [eax + ebp_offset], ebp mov [eax + esp_offset], esp Die Abstände sind auch in der vorgegebenen Datei toc.inc definiert

43 ! Syntaxunterschiede bei x86-assembler Intel: mov ebx, 0x17 (Ziel, Quelle) AT&T: mov $0x17, %ebx (Quelle, Ziel) objdump -M intel Standard bei objdump

44 Kontextwechsel

45 Ziel: Instruktionszeiger eip ändern

46 Ziel: Instruktionszeiger eip ändern Problem: Register eip kann nicht direkt beschrieben werden

47 Ziel: Instruktionszeiger eip ändern Problem: Register eip kann nicht direkt beschrieben werden Lösung: Änderung über ret und Adresse auf Stack (wie bei der Rückkehr nach einer Funktion)

48 Übersetung eines Funktionsaufrufs int i = func(23, 42);

49 Übersetung eines Funktionsaufrufs int i = func(23, 42); ; 2. Parameter auf Stack push 0x2a ; 1. Parameter auf Stack push 0x17 ; Funktionsaufruf call func ; pushed implizit die ; Rücksprungadresse L1:

50 Übersetung eines Funktionsaufrufs int i = func(23, 42); ; 2. Parameter auf Stack push 0x2a ; 1. Parameter auf Stack push 0x17 ; Funktionsaufruf call func ; pushed implizit die ; Rücksprungadresse L1: Stack beim Funktionsaufruf: ffff ffff ebp 0x2a esp + 8 0x17 esp + 4 esp L1 esp

51 Übersetung eines Funktionsaufrufs int i = func(23, 42); ; 2. Parameter auf Stack push 0x2a ; 1. Parameter auf Stack push 0x17 ; Funktionsaufruf call func ; pushed implizit die ; Rücksprungadresse L1: ; SP wiederherstellen add esp, 8 Stack beim Funktionsaufruf: ffff ffff ebp 0x2a esp + 8 0x17 esp + 4 esp L1 esp ; Rückgabe sichern mov ebx, eax

52 ! Zur Erinnerung für den Stack auf x86 gilt Der Stack wächst von oben (hohe Adresse) nach unten (niedrige Adresse). Der Stackzeiger (esp) zeigt auf das zuletzt hinzugefügte Datum push X verringert zuerst den Wert von esp um 4 Byte und legt dann X an die resultierende Adresse pop X liest den Inhalt des Speichers, auf das esp zeigt, in X und erhöht anschließend den Wert von ESP um 4 Byte. Adressen sollten an der 4 Byte-Grenze ausgerichtet sein (sonst droht Performanzverlust)

53 Kontextwechsel void foo(){ int f = 42; while (f--){ kout << "foo" << f << endl; toc_switch( &toc_foo, &toc_bar ); LFOO: } }

54 Kontextwechsel void foo(){ int f = 42; ffff ffff while (f--){ kout << "foo" << f << endl; toc_switch( &toc_foo, &toc_bar ); LFOO: } } &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

55 Kontextwechsel ; in Assembler toc_switch: ffff ffff &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

56 Kontextwechsel ; in Assembler toc_switch: ffff ffff &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

57 Kontextwechsel ; in Assembler toc_switch: ffff ffff toc_foo.esp toc_foo.ebx &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

58 Kontextwechsel ; in Assembler toc_switch: ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp ffff ffff toc_foo.esp toc_foo.ebx &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

59 Kontextwechsel ; in Assembler toc_switch: ffff ffff ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

60 Kontextwechsel ; in Assembler toc_switch: ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp ffff ffff toc_bar.esp toc_bar.ebx &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

61 Kontextwechsel ; in Assembler toc_switch: ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp ; neue Register laden mov eax, [esp + 8] mov ebx, [eax + ebx_offset] mov esp, [eax + esp_offset] ffff ffff toc_bar.esp toc_bar.ebx &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

62 Kontextwechsel ; in Assembler toc_switch: ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp ; neue Register laden mov eax, [esp + 8] mov ebx, [eax + ebx_offset] mov esp, [eax + esp_offset] ffff ffff toc_bar.esp toc_bar.ebx &toc_bar esp + 8 &toc_foo esp + 4 esp LFOO esp

63 Kontextwechsel ; in Assembler toc_switch: ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp ; neue Register laden mov eax, [esp + 8] mov ebx, [eax + ebx_offset] mov esp, [eax + esp_offset] ffff ffff toc_bar.esp toc_bar.ebx esp + 8 esp + 4 esp + 0 &toc_bar &toc_foo LFOO

64 Kontextwechsel ; in Assembler toc_switch: ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp ; neue Register laden mov eax, [esp + 8] mov ebx, [eax + ebx_offset] mov esp, [eax + esp_offset] ffff ffff toc_bar.esp toc_bar.ebx &toc_foo esp + 8 &toc_bar esp + 4 LBAR esp + 0 &toc_bar &toc_foo LFOO

65 Kontextwechsel ; in Assembler toc_switch: ; vorherige Register sichern mov eax, [esp + 4] mov [eax + ebx_offset], ebx mov [eax + esp_offset], esp ; neue Register laden mov eax, [esp + 8] mov ebx, [eax + ebx_offset] mov esp, [eax + esp_offset] ; "Zurückkehren" ret ffff ffff &toc_foo esp + 8 &toc_bar esp + 4 esp LBAR esp

66 Koroutine (erstmalig) starten void coroutine(void *arg){ }

67 Koroutine (erstmalig) starten void coroutine(void *arg){ } Wie rufe ich die aller erste Koroutine auf?

68 Koroutine (erstmalig) starten void coroutine(void *arg){ } Wie rufe ich die aller erste Koroutine auf? - Kann ich mit leeren Registern starten?

69 Koroutine (erstmalig) starten void coroutine(void *arg){ } Wie rufe ich die aller erste Koroutine auf? - Kann ich mit leeren Registern starten? Nicht ganz. - Einsprungsfunktion toc_go(toc *regs); Lädt den Kontext regs (quasi 2. Hälfte von toc_switch, ohne Sichern des aktuellen Kontexts)

70 Koroutine (erstmalig) starten void coroutine(void *arg){ } Wie rufe ich die aller erste Koroutine auf? - Kann ich mit leeren Registern starten? Nicht ganz. - Einsprungsfunktion toc_go(toc *regs); Lädt den Kontext regs (quasi 2. Hälfte von toc_switch, ohne Sichern des aktuellen Kontexts) Was wird für jede Koroutine gebraucht?

71 Koroutine (erstmalig) starten void coroutine(void *arg){ } Wie rufe ich die aller erste Koroutine auf? - Kann ich mit leeren Registern starten? Nicht ganz. - Einsprungsfunktion toc_go(toc *regs); Lädt den Kontext regs (quasi 2. Hälfte von toc_switch, ohne Sichern des aktuellen Kontexts) Was wird für jede Koroutine gebraucht? - Kontextstruktur toc - eigenen, präparierter Stack

72 Stack aufsetzen Parameter esp + 4 esp Rücksprungadresse esp + 0

73 Stack aufsetzen void coroutine(void *arg){ } arg esp + 4 esp 0xBADF00D esp + 0

74 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 esp 0xBADF00D tos - 8

75 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 0xBADF00D tos - 8 esp coroutine tos - 12 was passiert nun bei toc_go/toc_switch?

76 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 0xBADF00D tos - 8 esp coroutine tos - 12 was passiert wenn coroutine abgearbeitet ist?

77 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 0xBADF00D tos - 8 esp coroutine tos - 12 void toc_settle(struct toc *regs, void *tos, void (*coroutine)(void*), void* arg); Präperiert den Stack für den ersten Einsprung

78 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 0xBADF00D tos - 8 esp coroutine tos - 12 void toc_settle(struct toc *regs, void *tos, void (*coroutine)(void*), void* arg); Präperiert den Stack für den ersten Einsprung - in C[++] (statt Assembler)

79 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 0xBADF00D tos - 8 esp coroutine tos - 12 void toc_settle(struct toc *regs, void *tos, void (*coroutine)(void*), void* arg); Präperiert den Stack für den ersten Einsprung - in C[++] (statt Assembler) - statisch übergebenen Speicher tos als Stack aufsetzen

80 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 0xBADF00D tos - 8 esp coroutine tos - 12 void toc_settle(struct toc *regs, void *tos, void (*coroutine)(void*), void* arg); Präperiert den Stack für den ersten Einsprung - in C[++] (statt Assembler) - statisch übergebenen Speicher tos als Stack aufsetzen - Pointerarithmetik ist hilfreich

81 Stack aufsetzen void coroutine(void *arg){ } tos (top of stack) arg tos - 4 0xBADF00D tos - 8 esp coroutine tos - 12 void toc_settle(struct toc *regs, void *tos, void (*coroutine)(void*), void* arg); Präperiert den Stack für den ersten Einsprung - in C[++] (statt Assembler) - statisch übergebenen Speicher tos als Stack aufsetzen - Pointerarithmetik ist hilfreich - esp in Kontextstruktur regs entsprechend setzen

82 Umsetzung in OOStuBS/MPStuBS

83 Threads class Thread { struct toc regs; public: Thread(void* tos); virtual void action() = 0; }

84 Threads class Thread { struct toc regs; public: Thread(void* tos); virtual void action() = 0; } Adresse einer virtuellen Member-Funktion nicht (ohne weiteres) ermittelbar

85 Threads class Thread { struct toc regs; public: Thread(void* tos); virtual void action() = 0; } Adresse einer virtuellen Member-Funktion nicht (ohne weiteres) ermittelbar void kickoff (Thread* t){ t->action(); }

86 Scheduler Scheduler verwaltet Koroutinen zentral class Scheduler { Queue<Thread> routines; public: void ready(thread *); void schedule(); void resume(); };

87 Scheduler (Beispiel) // Thread AppFoo void AppFoo::action(){ while (1){ kout << "foo" << endl; scheduler.resume(); } } // Thread AppBar void AppBar::action(){ while (1){ kout << "bar" << endl; scheduler.resume(); } }

88 Scheduler (Beispiel) // Thread AppFoo void AppFoo::action(){ while (1){ kout << "foo" << endl; scheduler.resume(); } } // Thread AppBar void AppBar::action(){ while (1){ kout << "bar" << endl; scheduler.resume(); } } // main.cc AppFoo appfoo; AppBar appbar; int main (){ // scheduler.ready(&appfoo); scheduler.ready(&appbar); scheduler.schedule(); }

89 Scheduler (Beispiel) main() // scheduler.ready(&appfoo) scheduler.ready(&appbar) scheduler.schedule() toc_go(appfoo.toc) AppFoo kickoff() appfoo->action() kout << "foo" scheduler.resume() toc_switch() toc_switch() kout << "foo" scheduler.resume() AppBar kickoff() appbar->action() kout << "bar" scheduler.resume() foo bar foo toc_switch() toc_switch() kout << "bar" scheduler.resume() bar

90 Scheduler Scheduler verwaltet Koroutinen zentral class Scheduler { Queue<Thread> routines; public: void ready(thread *); void schedule(); void resume(); }; OOStuBS immer synchrone Aufrufe Konsistenz gesichert

91 Scheduler Scheduler verwaltet Koroutinen zentral class Scheduler { Queue<Thread> routines; public: void ready(thread *); void schedule(); void resume(); }; OOStuBS immer synchrone Aufrufe Konsistenz gesichert MPStuBS Synchronisation notwendig

92 Scheduler (synchronisiert) main() // guard.enter() scheduler.schedule() toc_go(appfoo.toc) AppFoo kickoff() guard.leave() appfoo->action() kout << "foo" guard.enter() scheduler.resume() toc_switch() toc_switch() AppBar kickoff() guard.leave() appbar->action() kout << "bar" guard.enter() scheduler.resume() foo bar guard.leave() kout << "foo" guard.enter() scheduler.resume() foo toc_switch() guard.leave() kout << "bar" bar

93 Fragen? Nächste Woche (14. & 17. Dezember) Abgabe von Aufgabe 3 im Huber-CIP

94 #define STACKSIZE 4096 int something=0x ; char stackfoo[stacksize]; char stackbar[stacksize];

95 #define STACKSIZE 4096 ffff ffff int something=0x ; char stackfoo[stacksize]; char stackbar[stacksize]; stackbar[3] stackbar[2] stackbar[1] stackbar[0] stackfoo[4095] stackfoo[4094] stackfoo[4093] stackfoo[4092] stackfoo[4091] stackfoo[4090] stackfoo[4089] stackfoo[4088] 010c e32f 010c e32e 010c e32d 010c e32c 010c e32b 010c e32a 010c e c e c e c e c e c e324 stackfoo[4087] stackfoo[2] stackfoo[1] stackfoo[0] 010c e c d32e 010c d32d 010c d32c c d32b c d32a c d329 something c d

96 #define STACKSIZE 4096 ffff ffff int something=0x ; char stackfoo[stacksize]; char stackbar[stacksize]; void* tos = &(stackfoo[4092]); void** esp = (void**) tos; stackbar[3] stackbar[2] stackbar[1] stackbar[0] stackfoo[4095] stackfoo[4094] stackfoo[4093] stackfoo[4092] stackfoo[4091] stackfoo[4090] stackfoo[4089] stackfoo[4088] 010c e32f 010c e32e 010c e32d 010c e32c 010c e32b 010c e32a 010c e c e c e c e c e c e324 stackfoo[4087] stackfoo[2] stackfoo[1] stackfoo[0] 010c e c d32e 010c d32d 010c d32c c d32b c d32a c d329 something c d

97 #define STACKSIZE 4096 ffff ffff int something=0x ; char stackfoo[stacksize]; char stackbar[stacksize]; void* tos = &(stackfoo[4092]); void** esp = (void**) tos; stackbar[3] 010c e32f stackbar[2] 010c e32e stackbar[1] 010c e32d stackbar[0] 010c e32c stackfoo[4095] AA 010c e32b stackfoo[4094] BB 010c e32a stackfoo[4093] CC 010c e329 stackfoo[4092] DD 010c e328 stackfoo[4091] 010c e327 *esp = 0xAABBCCDD; stackfoo[4090] stackfoo[4089] stackfoo[4088] 010c e c e c e324 stackfoo[4087] stackfoo[2] stackfoo[1] stackfoo[0] 010c e c d32e 010c d32d 010c d32c c d32b c d32a c d329 something c d

98 #define STACKSIZE 4096 ffff ffff int something=0x ; char stackfoo[stacksize]; char stackbar[stacksize]; void* tos = &(stackfoo[4092]); void** esp = (void**) tos; *esp = 0xAABBCCDD; esp--; *esp = 0xBADF00D; stackbar[3] 010c e32f stackbar[2] 010c e32e stackbar[1] 010c e32d stackbar[0] 010c e32c stackfoo[4095] AA 010c e32b stackfoo[4094] BB 010c e32a stackfoo[4093] CC 010c e329 stackfoo[4092] DD 010c e328 stackfoo[4091] 0B 010c e327 stackfoo[4090] AD 010c e326 stackfoo[4089] F0 010c e325 stackfoo[4088] 0D 010c e324 stackfoo[4087] 010c e323 stackfoo[2] 010c d32e stackfoo[1] stackfoo[0] 010c d32d 010c d32c c d32b c d32a c d329 something c d

99 #define STACKSIZE 4096 ffff ffff int something=0x ; char stackfoo[stacksize]; char stackbar[stacksize]; void* tos = &(stackfoo[4092]); void** esp = (void**) tos; *esp = 0xAABBCCDD; esp--; *esp = 0xBADF00D; stackbar[3] 010c e32f stackbar[2] 010c e32e stackbar[1] 010c e32d stackbar[0] 010c e32c stackfoo[4095] AA 010c e32b stackfoo[4094] BB 010c e32a stackfoo[4093] CC 010c e329 stackfoo[4092] DD 010c e328 stackfoo[4091] 0B 010c e327 stackfoo[4090] AD 010c e326 stackfoo[4089] F0 010c e325 stackfoo[4088] 0D 010c e324 stackfoo[4087] 010c e323 stackfoo[2] 010c d32e // stackfoo[1] stackfoo[0] 010c d32d 010c d32c // Anschliessend: // esp in toc schreiben c d32b c d32a c d329 something c d