Thema: Softwaremultitasking, aber wie?

[bitmaster]

Also ich muss mein OS kräftig umschreiben sonst ist es bald nicht mehr existens fähig. Die neueren CPUs (und der 64-bit Modus) unterstützen nämlich kein Hardwaremultitasking mehr. Jetzt steh ich doof da. Ich muss also zu Softwaremultitasking wechseln. Aber davon habe ich überhaubt keine Ahnung. Hat man dann kein TSS oder wie? Wie speichert man die Register und wo? Please help me!!!

bitmaster

[scales of justice]

hmm? ich dachte immer der Prozessor emuliert das von alleine.
Sicher das der OS-Programmierer das machen muss?

[bluecode]

hmm? ich dachte immer der Prozessor emuliert das von alleine.
Sicher das der OS-Programmierer das machen muss?

ROFLMAO  

Ne mal im ernst, du hast schon noch ein TSS benutzt es aber nichtmehr zum speichern der Register sondern nur noch, um SS0 und ESP0 bei Interupts zu bekommen. Evtl. hilf dir das tutorial von beyond infinity. Wenn nicht dann einfach fragen, was du nicht verstehst

[bitmaster]

hmm? ich dachte immer der Prozessor emuliert das von alleine.
Sicher das der OS-Programmierer das machen muss?

Ja, ich bin mir da ganz sicher. Im Intel Manual steht sogar drin, dass im 64-Bit Modus kein Hardwaremultitasking mehr möglich ist. Und der AMD64 kann das sogar im 32-Bit Modus nicht mehr (soweit ich weiß). Deswegen muss ich zu Softwaremultitasking wechseln, sonst ist mein OS nicht zufunftssicher. Hat einer 'ne Ahnung wie das mit Softwaremultitasking funktioniert?

danke!!!

[bluecode]

Hat einer 'ne Ahnung wie das mit Softwaremultitasking funktioniert?

Siehe mein Post, welches du mit Sicherheit überlesen hast

[n3Ro]

Da die 64 Bit CPUs von AMD 100% abwärtskompatibel zu allen 32bit x86ern ist geht da natürlich auch noch Hardwaremultitasking in den "alten" Modi.
Softwaremultitasking funktioniert im Prinzip ganz einfach. Du rufst ja in Regelmäßigen Zeitabständen den Timerinterupt auf. Bei diesem wird im Stack CS:EIP,SS:ESP und eFlags abgelegt die beim IRET wieder ausgelesen werden. Wenn du nun vor dem IRET deine alten Register von Task A abgespeichert hast und die von Task B lädst und dabei auf deine Stackwerte umänderst, springst du beim IRET in deine Task B

[bitmaster]

Aso, danke für die vielen Antworten. Also ich lade einmal mit ltr ein TSS und mehr habe ich dann auch nicht, oder wie? Und mein IRQ0 macht dann das oder wie? :

Code: [Auswählen]

pusha
push ds
push es
push fs
push gs

kA was dann

pop gs
pop fs
pop es
pop ds
popa
iret

Aber dann habe ich doch die vorherigen Register wieder? Und wieso überhaubt dann ein TSS? Hmm... blick da nicht so ganz durch.

bitmaster

[Jidder]

Aber dann habe ich doch die vorherigen Register wieder?

Nicht, wenn du bei "kA was dann" den Stack wechselst. Das ist der Trick beim Softwaremultitasking.

Und wieso überhaubt dann ein TSS? Hmm... blick da nicht so ganz durch.

Das TSS brauchst du für einen Privilegwechsel von Ring 3 nach Ring 0. (Die Schwierigkeit ist SS und CS gleichzeitig zu ändern.) Anders kommst du nicht in den Kernel.

[bitmaster]

OK, also das mit den anderen Werten durch den anderen Stack verstehe ich jetzt. Aber wie wechsle ich denn den Stack? Und wie bekomme ich dann das neue CS?

bitmaster

[Jidder]

Stack wechseln:

Code: [Auswählen]

mov [alter_stack], esp
mov esp, [neuer_stack]

Das neue CS bekommst entweder durch einen far-jump oder bei einem Privilegwechsel durch ein iret.

[bitmaster]

Stack wechseln:

Code: [Auswählen]

mov [alter_stack], esp
mov esp, [neuer_stack]

Das neue CS bekommst entweder durch einen far-jump oder bei einem Privilegwechsel durch ein iret.

Hmm.. Also brauche ich nur sp und nicht ss ändern? Hä? Und muss also eine Zeichenkette voller Stackwerte von jedem Task haben? Und wenn ich einen Task starte muss ich auf seinem Stack vorher alle Werte für die Register draufpushen um nacher auch durch iret z.B. den cs und eip an der richtig Position zu haben?

[Jidder]

Hmm.. Also brauche ich nur sp und nicht ss ändern? Hä?

Doch. Wenn du nicht sicherstellen kannst, dass deine Programme mit ss irgendwelchen Unfug machen, dann solltest du ss auch jedes mal ändern.

Und muss also eine Zeichenkette voller Stackwerte von jedem Task haben?

Korrekt. Ich würds nicht Zeichenkette nennen, sondern Speicherbereich. Und das ist ja eigentlich nix besonderes, denn ich gehe mal davon aus, dass all deine Tasks irgendwie irgendwo eigenen Speicher haben.  

Und wenn ich einen Task starte muss ich auf seinem Stack vorher alle Werte für die Register draufpushen um nacher auch durch iret z.B. den cs und eip an der richtig Position zu haben?

Jupp, genau so geht es.

[bitmaster]

Gut, das habe ich jetzt kapiert. Aber was meintest du mit schwer wenn der Ring gewechselt wird? In den Deskritoren der Segmente steht doch der Ring, das hat doch dann nichts mit dem Taskwechsel zu tun?

EDIT: Also so habe ich es bis jetzt verstanden:

Code: [Auswählen]

;Task wechsel:
IRQ0:
cli
pusha
push ds
push es
push fs
push gs
mov eax,ss
mov [mem],eax
mov [mem],sp

mov eax,[mem]
mov ss,eax
mov sp,[mem]
mov al,20h
out 20h,al
pop fs
pop es
pop ds
popa
sti
iret

;[mem] ist jeweils ein anderer Speicherbereich!!!

Aber wenn ich jetzt einen Task zum aller ersten mal starte, dann holt der IRQ0 Werte vom Stack die ich aber noch nie gespeichert habe??? komisch, scheck gerade gar nichts mehr...

[bitmaster]

So, ich speichere im IRQ0 die aktuellen Register. Wechsle dann den Stack. Hole dann vom Stack Werte zu Register. Nee, halt stop. In diesem Stack habe ich ja noch gar keine Register Werte. Was jetzt?

[bluecode]

Du musst beim erstellen eines neues Tasks den Stack so aufsetzten, dass es halt stimmt Eigentlich alles wie in dem tutorial das ich gepostet hab beschrieben.

[bitmaster]

Du musst beim erstellen eines neues Tasks den Stack so aufsetzten, dass es halt stimmt Eigentlich alles wie in dem tutorial das ich gepostet hab beschrieben.

Aso, gut dann habe ich das jetzt glaube ich verstanden. Nur verstehe ich immer noch nicht wieso wir überhaubt ein TSS brauchen. Das ganze kann ich doch auch ohne TSS machen. Was meinst du mit ss0 und esp0?

Ach ja, und so tu ich einen Task für den ersten Start vorbereiten:

Code: [Auswählen]

cli ;IRQ0 nicht aufrufen

push ss
push esp

mov eax,neuer Stack Selector
mov ss,eax
mov esp,neuer Stackpointer

push 0000001000000010b ;eflags
push 1 << 3 ;cs
push task1  ;eip
push 0 ;eax
push 0 ;ecx
push 0 ;edx
push 0 ;ebx
push ? ;esp was muss hier hin?
push 0 ;ebp
push 0 ;esi
push 0 ;edi
push 2 << 3 ;ds
push 2 << 3 ;es
push 2 << 3 ;fs
push 2 << 3 ;gs

pop esp
pop ss

sti ;jetzt kann der IRQ0 wieder aufgerufen werden


So, was muss ich bei

Code: [Auswählen]

push ? ;esp was muss hier hin? schreiben? Was muss bei dem ? hin? Weil da muss ja ein gültiger Wert hin, sonst ist esp ja kaput.

Ist das bis jetzt alles richtig?

danke!!!

[bluecode]

Nur verstehe ich immer noch nicht wieso wir überhaubt ein TSS brauchen. Das ganze kann ich doch auch ohne TSS machen. Was meinst du mit ss0 und esp0?

esp0/ss0 sind nur beim software-taskswitching mit änderung des Priviledgelevels wichtig, da soe dort aus dem TSS entnommen werden und eben als neues SS/ESP genommen werden (des is dann der ich nenns mal "kernel-level task stack"). Auf dem Stack werden dann des alte SS/ESP, die EFlags, CS/EIP gesichert, welche beim iret widerhergestellt werden.
Beim softwaretaskswitching ohne änderung des Priviledgelevels wird der Stack nicht gewechselt, sondern nur EFlags/CS/EIP auf dem Stack gesichert, welche auch beim iret wiederhergestellt werden.
Zusätzlich zu den bereits gesicherten Regs musst dann halt noch die Generalpurpose regs sichern.

So, was muss ich bei

Code: [Auswählen]

push ? ;esp was muss hier hin? schreiben? Was muss bei dem ? hin? Weil da muss ja ein gültiger Wert hin, sonst ist esp ja kaput.

Du musst das push esp weglassen, da bei pusha/popa esp nicht gesichert/wiederhergestellt wird (Das scheint in dem Tutorial falsch zu sein...).

[bitmaster]

@bluecode: danke

aber:

esp0/ss0 sind nur beim software-taskswitching mit änderung des Priviledgelevels wichtig, da soe dort aus dem TSS entnommen werden und eben als neues SS/ESP genommen werden (des is dann der ich nenns mal "kernel-level task stack").

Und woher weiß ich, wann ich die esp0/ss0 auslesen muss und wann nicht.

Auf dem Stack werden dann des alte SS/ESP, die EFlags, CS/EIP gesichert, welche beim iret widerhergestellt werden.

iret läd aber ss und esp nicht. Sondern nur die EFlags, cs/eip.

Zusätzlich zu den bereits gesicherten Regs musst dann halt noch die Generalpurpose regs sichern.

Was ist das?

Du musst das push esp weglassen, da bei pusha/popa esp nicht gesichert/wiederhergestellt wird (Das scheint in dem Tutorial falsch zu sein...).

Doch, pusha und popa verändern auch das esp.

bitmaster

[bluecode]

iret läd aber ss und esp nicht. Sondern nur die EFlags, cs/eip.

Doch genau das macht iret, wenn in den EFlags das PL != das PL von CS ist Damit hat sich wohl auch die erste Frage erledigt

Zusätzlich zu den bereits gesicherten Regs musst dann halt noch die Generalpurpose regs sichern.

Was ist das?

halt eax, ebx, ecx, edx (esi, edi, ebp)

Du musst das push esp weglassen, da bei pusha/popa esp nicht gesichert/wiederhergestellt wird (Das scheint in dem Tutorial falsch zu sein...).

Doch, pusha und popa verändern auch das esp.

sry, habs grad auch nochma nachgeschaut. pusha sichert zwar esp, aber popa ignoriert den gepushten wert einfach => 0 setzten.

[bitmaster]

sry, habs grad auch nochma nachgeschaut. pusha sichert zwar esp, aber popa ignoriert den gepushten wert einfach => 0 setzten.

Wie kommst du denn darauf?