Lowlevel
Lowlevel => Lowlevel-Coding => Thema gestartet von: Another Stupid Coder am 14. November 2004, 23:54
-
Hallo,
Ich habe nun TeeJay's code kopiert (jaja, ich weiß, aber ich wollte mir halt mal den PMode in Asm ansehen ;)) und nun wollte ich ein Zeichen ausgeben, doch musste ich feststellen das es nicht funktioniert...mein (Test-) PC blinkt noch (also dieser "_") und rebootet nicht oder so...er gibt nur einfach kein Zeichen aus...kann mir da jemand helfen?
[BITS 16]
jmp Start
DescriptorNull:
dd 0
dd 0
DescriptorCode:
dw 0xFFFF
dw 0
db 0
db 0x9A
db 0xCF
db 0
DescriptorData:
dw 0xFFFF
dw 0
db 0
db 0x92
db 0xCF
db 0
GlobalDescriptorTable:
Limit dw 0
Base dd 0
Start:
cli
mov eax, cs
mov ds, ax
shl eax, 4
mov [DescriptorCode+2], ax
mov [DescriptorData+2], ax
shr eax, 16
mov [DescriptorCode+4], al
mov [DescriptorData+4], al
mov eax, cs
shl eax, 4
add eax, DescriptorNull
mov [Base], eax
mov [Limit],WORD GlobalDescriptorTable - DescriptorNull - 1
lgdt [GlobalDescriptorTable]
mov eax, cr0
or eax, 1
mov eax, cr0
db 0xea ;Bitmuster für einen FAR JUMP
dw ProtectedMode
dw 0x8
[BITS 32]
ProtectedMode:
mov WORD [DescriptorCode+2], 0
mov WORD [DescriptorData+2], 0
mov BYTE [DescriptorCode+4], 0
mov BYTE [DescriptorData+4], 0
mov eax, 2
shl eax, 3
mov ds, ax
mov ss, ax
mov es, ax
mov eax, 0
mov fs, ax
mov gs, ax
mov esp, 0x1FFFFF
jmp 0x8:0x10000 + ProtectedMode2
ProtectedMode2:
mov eax, 0xb800
mov bh, 'p'
mov [eax], bh
Endless:
jmp Endless
-
Ist die Vidomemadresse nicht 0xB8000 ?
-
Achja, Tippfehler...aber sollte es nicht dennoch klappen? So ein 0 er hinten ist doch egal oder? Danke jedenfalls ich versuche es gleich mit dem extra 0er :)
-
Testergebnis: Negativ...
Es muss an etwas anderem liegen, aber gebootet wird correct, ich hatte vorher schon einen RM-Kernel damit laufen...
-
Also erstmal isses relativ unsinnig mov eax,cs zu schreiben, cs=16Bit eax=32 Bit, das dürfte erstmal schon den Rechner erwirren^^
So und da du sowieso ne Exception erzwingst kanns nicht gehen^^
erst eax 0 setzten und dann fs und gs damit bestücken geht schief, da dies ein nicht gültiger selektor ist
des weiteren ist die Adresse wirklich 0xB8000
-
Logisch, danke ;)
-
Immer gern^^
-
Strange...selbst wenn ich den Tut-Code 1:1 kopiere (egal ob aus PMode oder C-Kernel Tutorial) klappt es nicht...kann das an dem Pentium-S (100Mhz) liegen? Aber sowohl Win98 als auch FreeBSD (kA, welche Version...aber von 2003 also SEHR sicher PMode) laufen...
-
Ja, aber falls du den Cpp-Kernel-Thread unten meinst, dort wurde das Problem doch auch nicht gelöst, oder habe ich da was übersehen?
-
Dorthin kommt er bei mir auch nicht...
-
Kann es sein, dass man eine IDT erzeugen muss bevor man irgendwas machen kann?...ich fänd's strange...
-
Solange du den Befehel LIDT nicht benutzt brauchst du auch keine IDT.
Nur die GDT muss vorhanden sein für den Sprung in den PMode.
Und ohne IDT sollten die Interrupts natürlich abgeschaltet sein.
-
Klar...hm...
-
Also ich habe noch eine Frage:
mov eax, cr0
or eax, 1
mov cr0, eax
diesen Teil sieht man immer wieder. Doch ist man da (zumindest beim 1. mov) noch im RM der nur 16Bit unterstützt und eax ist doch ein 32Bit Register oder? Naja, ich versuchte es mit ax statt eax doch dann sagte mir NASM bei den beiden beiden mov befehlen invaild combination of operator and operands...ich häng mal den ganzen Code ran (neu gecodet, jetzt nimmer nach TJ) bei dem machen sowohl Bochs als auch mein 2. Rechner 'nen Reboot...
kernel.asm:
org 0x1000
mov ah, 0
int 0x16
jmp GDT_End
GDT_Register:
dw GDT_End - GDT - 1
dw GDT
GDT:
GDT_Null equ $-GDT
dd 0x00000000
dd 0x00000000
GDT_Code equ $-GDT
dw 0xFFFF
dw 0x0000
db 0x00
db 0x9A
db 0xCF
db 0x00
GDT_Data equ $-GDT
dw 0xFFFF
dw 0x0000
db 0x00
db 0x92
db 0xCF
db 0x00
GDT_End:
cli
lgdt [GDT_Register]
mov ax, cr0
or ax, 1
mov cr0, ax
mov ax, GDT_Data
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
mov esp, 0x2FFFF
jmp 0x8:0x2000
kernel32.asm
org 0x2000
[bits 32]
Pmode:
Endless:
jmp Endless
-
Hiho,
Real und Protected Mode beziehen sich mehr auf Addressierung, anstatt auf Registergröße, die 32-Bit Versionen der meisten Register kannst du auch im RealMode aufrufen...
mov ax,cr0
klappt nicht, da cr0 32-Bit breit ist.
Man sieht, könnte man eax nicht im Real Mode benutzen, und da cr0 32-Bit groß ist, käme man nie in den PMode :)
MfG GhostCoder
-
Nochwas,
GDT_Register:
dw GDT_End - GDT - 1
dw GDT
da muss doch der zweite Wert ein DWORD (also dd) sein.
Außerdem muss der auch doch auch ne 32-Bit Addresse sein, nicht 16-Bit relativ zum codesegment.
xor eax,eax
mov ax,cs ; bzw. ds, kommt auf deinen vorherigen Code an...
shl eax,4
add ax,GDT_Null
mov dword [GDT_Register+2],eax
und den Code packst du nun vor lgdt [....], das sollte klappen.
MfG GhostCoder
-
Außerdem muss der auch doch auch ne 32-Bit Addresse sein, nicht 16-Bit relativ zum codesegment. <---Ãhm...sorry, das habe ich nicht verstanden...was genau meinst du...
Danke, ich teste es gleich aber könntest du mal kurz erklären wofür der Code ist?
-
Funzt alles nicht...
-
Hiho,
xor eax,eax
mov ax,cs ; bzw. ds, kommt auf deinen vorherigen Code an...
shl eax,4
add ax,GDT_Null
mov dword [GDT_Register+2],eax
der code wandelt eine RealMode Addresse (Segment:Offset) in eine lineare Addresse (Offset(32-Bit)) mittels addr=(Segment<<4)+Offset um. Den genau solch eine Addresse muss im gdt stehen.
Außerdem muss der auch doch auch ne 32-Bit Addresse sein, nicht 16-Bit relativ zum codesegment. <---Ãhm...sorry, das habe ich nicht verstanden...was genau meinst du...
Was ich oben gesagt habe, nicht Segment:Offset sondern nur 32-Bit Offset. Kannst dir das so vorstellen, das du 16 Segmente zu je 64kb hast (oder umgekehrt), daher ist der Offset relativ zum Segment...
Noch was, an welcher RMode Addresse liegt den der Kernel, und ist das Datensegment richtig gesetzt? Da du org benutzt, musst du wahrscheinlich noch nach dem "mov ax,ds" noch "add ax,0x1000" hinzufügen. Sonst sieht der Code eigentlich richtig aus. Btw, stimmen die Deskriptoren?
MfG GhostCoder
-
hat man im PM eigendlich zugriff auf die ports?
-
Natürlich wie willst du sonst nen Tastaturtreiber schreiben oder nen FDC treiber?
Das Programm muss dann aber im Ring0 laufen^^
-
ich meine ja, ob man es allgemein kann! sonst währe es ein bisschen gefährlich für viren! da muss nur einer in diesen Interruptport schreiben, dass er gerade das Interrupt 0 ausführt, und schon ist alles geblockt, was auf dem rechner über die interruptebene laufen soll, sprich tastatur, laufwerke, usw!
-
@joachim_neu Na eben nur die Ring0 Programme...sprich der Kernel :) und eventuell noch Ring1 (oder?) da dieser ja oft für Treiber benutzt wird, aber das weiß ich auch nicht so genau, so das ALLE Programme auf die ports zugreifen können ist es jedenfalls nur im RM soweit ich weiß
@GhostCoder Das könnte es sein, mein Kernel ist an der Position 0x1000 :) Ich gehe gleich testen
Danke für die ganze Hilfe^^
-
Ansich können aber doch auch Ring3 Programme auf Ports zugreifen, man errinnere sich an Windows 98. Aber man kann in der TSS direkt angeben, auf welche Ports der Prozess zugreifen kann. Hab habe keine Ahnung, ob ohne TSS direkt alle Ports gesperrt sind oder nicht.
MfG GhostCoder
-
org 0x1000
jmp GDT_End
GDT_Register:
dw GDT_End - GDT - 1
dd GDT
GDT:
GDT_Null equ $-GDT
dd 0x00000000
dd 0x00000000
GDT_Code equ $-GDT
dw 0xFFFF
dw 0x0000
db 0x01
db 0x9A
db 0xCF
db 0x00
GDT_Data equ $-GDT
dw 0xFFFF
dw 0x0000
db 0x00
db 0x92
db 0xCF
db 0x00
GDT_End:
cli
xor eax, eax
mov ax, ds
add ax, 0x1000
shl eax, 4
add ax, GDT_Null
mov dword [GDT_Register+2], eax
lgdt [GDT_Register]
mov eax, cr0
or eax, 1
mov cr0, eax
mov ax, GDT_Data
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
mov esp, 0xFFFFF
jmp GDT_Code:0x2000
[/code]
Das ist der aktuelle Code, der noch immer nicht funktioniert...ich habe einfach keine Ahnung was da falsch ist...der bootloader funzt ganz normal, ist im grunde nur der aus der 1. Ausgabe des Lowlevelmagazins (leicht modifiziert, funzt aber) und der kernel32-Code ist ja in diesem Thread schon einmal abgedruckt.
-
Ansich können aber doch auch Ring3 Programme auf Ports zugreifen, man errinnere sich an Windows 98. Aber man kann in der TSS direkt angeben, auf welche Ports der Prozess zugreifen kann. Hab habe keine Ahnung, ob ohne TSS direkt alle Ports gesperrt sind oder nicht.
MfG GhostCoder
Das ist eine Interessante Frage!!
Vor allem auch für Leute die Taskswitching in Software betreiben.
Ich denke aber mal, das Intel so umsichtig war und es so geregelt hat, das, sofern es kein TSS mit Port-Bitmap gibt, alle Ports für Ring3 gesperrt sind.
Soweit ich es noch in erinnerung hab, sind nur Ring3 Software für Ports gesperrt.
Ring1 und Ring2 dürfen auf die Ports zugreifen, haben aber ein paar andere Systembefehle (Taskswitching etc glaub ich) gesperrt.
-
Jo,
die Frage wie ich das mit den Ports regeln soll hab ich mir auch schon gestellt! (Software ts)
Aber am besten ist sowieso nur Ports für Treiber denk ich mal, von wegen Plattformunabhängigkeit (falls mein os sowas jemals haben sollte :) ) und so
MfG GhostCoder
-
Ah stimmt :)
So wars....scho ne weile her mit dem PMode Tut :)
-
Ãhm...das soll jetzt wirklich nicht nerven oder so, aber ihr könnt mir nicht zufällig helfen?
-
Was bedeutet "23" in der vorletzten Zeile?
-
Das ist die größe der GDT.
Ansich sind es 24 Bytes, aber es werden nur 23 angegeben. Das 0te Byte wird vom Prozessor mitgezählt.
-
Ãhm...selbst wenn ich diesen Code 1:1 kopiere, funzt er nicht, obwohl der Loader läuft...O_o...weder auf meinem 2. PC, in Bochs noch in VMWare...
-
Hiho,
sicher das dein Loader läuft?
Nochma zum GDT:
Ich bin eigentlich ziemlich überzeugt, das
dd gdt
nich passen, kann, da der z.b. 0x1500 ist, der Prozessor aber ne 32-Bit Addresse verlangt
Hier stehts (http://"http://www.fh-zwickau.de/doc/prmo/pmtutor/text/p_all5.htm") (ganz unten)
Zur Not kann ich dir aber auch meinen Bootloader geben, der in den PMode schaltet, Sektor 2-50 nach 0x10000 kopiert, und dahinspringt. Jaja, kein FAT ich weiß :)
MfG GhostCoder
-
Der Loader ist daweil auch nur zum testen ist wie gesagt aus dem 1. Lowlevel Magazin...genauso...und der funzt, ich habe bereits mehrmals am anfang des Kernels eine Msg ausgegeben...
Was genau meinst du? dd = define double(word) = 4 byte = 32 bit...oder nicht? Ich bin langsam echt ratlos...O_o
-
[BITS 16] ;16 Bit Code erstellen
jmp start ;GDT überspringen
NULL_Desc:
dd 0
dd 0
CODE_Desc:
dw 0xFFFF ;Segmentgröße Byte 0/1
dw 0 ;Segmentbasisadresse Byte 0/1
db 0 ;Segmentbasisadresse Byte 2
db 10011010b ;Zugriffsberechtigungen
db 11001111b ;Zusatz + Segmentgröße Bits 16 - 19
db 0 ;Segmentbasisadresse Byte 3
DATA_Desc:
dw 0xFFFF
dw 0
db 0
db 0x92
db 0xCF
db 0
gdt:
Limit dw 0 ;Größe der GDT (wird später eingetragen)
Base dd 0 ;Adresse der GDT (wird später eingetragen)
start:
cli ;Interrupts ausschalten
mov eax, cs ;EAX auf derzeitiges Codesegment setzen
mov ds, ax ;DS auf Codesegment setzen
shl eax, 4 ;EAX mit 16 multiplizieren (Lineare Adresse
;des Codesegments errechnen)
mov [CODE_Desc+2], ax ;Lineare Adresse des Codesegmentes als
mov [DATA_Desc+2], ax ;Startadresse des Code- und Datendeskriptors
shr eax, 16 ;eintragen
mov [CODE_Desc+4], al
mov [DATA_Desc+4], al
mov eax, cs ;Startadresse der GDT errechnen
shl eax, 4
add eax, NULL_Desc
mov [Base], eax ;Startadresse der GDT eintragen
mov [Limit], WORD gdt - NULL_Desc -1 ;Größe der GDT errechnen und eintragen
lgdt [gdt] ;GDT laden
mov eax, cr0 ;In den Protected Mode schalten,
or eax, 1 ;indem Bit 0 des CR0 Registers auf 1
mov cr0, eax ;gesetzt wird
db 0xea ;FAR-JUMP zum Codesegment
dw PMODE
dw 0x8
[BITS 32] ;32 Bit Code erstellen
PMODE:
mov WORD [CODE_Desc+2], 0 ;Code Segmentstartaddresse auf 0 setzen
mov WORD [DATA_Desc+2], 0 ;Daten Segmentstartadresse auf 0 setzen
mov BYTE [CODE_Desc+4], 0 ;Code Segmentstartaddresse auf 0 setzen
mov BYTE [DATA_Desc+4], 0 ;Daten Segmentstartadresse auf 0 setzen
mov eax, 2 ;Selektor für das Datensegment erstellen
shl eax, 3
mov ds, ax ;Daten- Stack- und Extrasegment mit
mov ss, ax ;Datensegmentdeskriptor laden
mov es, ax
mov eax, 0 ;FS und GS mit Null-Deskriptor laden
mov fs, ax
mov gs, ax
mov esp, 0x1FFFFF ;Stack auf unterhalb der 2 MB Grenze setzen
jmp 0x8:0x10000 + PMODE2 ;Sprung in das "neue" Codesegment
PMODE2:
jmp PMODE2
Das ist mein Code für den Sprung in den PMode und der funzt...bei mir ;)
-
Danke, mit TeeJay's Code klappts daweil^^
-
das
dd gdt
ist auch korrekt. das dd bedeutet DoubleWord.
der assembler macht da auf jeden fall eine 32 bit zahl hin.
Ja, na klar ist das ein Doubleword, aber das Label "gdt" hat nur 16-Bit belegt!
mov eax, cs ;Startadresse der GDT errechnen
shl eax, 4
add eax, NULL_Desc
mov [Base], eax ;Startadresse der GDT eintragen
Der Code von TeeJay macht es richtig, eine Segment:Offset Addresse in eine 32-Bit Addresse umwandeln, wie ich es weiter oben schon gesagt habe.
MfG GhostCoder
-
Jo.
Bei meinem Code wird deshalb so viel "gefummelt" weil ich den Kernel an 0x10000 laden lasse.
Und da kann ich leider leinen 16 Bit jmp hinmachen. Daher erstmal das erste Segment so legen, das es bei 0x10000 anfängt. In den PMode springen und dann die GDT so abändern das das Segment nun korrekterweise bei 0x0 beginnt.
-
Hm...vielleicht stimmt doch was mit dem Loader nicht...ist aber wie gesagt der Lowlevel-Loader...naja ich poste hier nochmal alles (größtenteils geklauter Code, aber es geht mal ums testen)...ich würde nämlich gerne blueXseven's Code verwenden, da der kürzer und überschaubarer ist (nicht persönlich nehmen TeeJay :D)
Bootloader
org 0x7C00
start:
cli ; Stack
mov ax, 0x9000 ; Stackadresse
mov ss, ax
mov sp, 0
sti
mov [BootDrive], dl ; Bootlaufwerk speichern
call LoadKernel ; Kernel laden
; Kernel ausfuehren
mov ax, 0x1000 ; Adresse des Kernels
mov es, ax ; Segmentregister updaten
mov ds, ax
push ax
mov ax, 0
push ax
mov dl, [BootDrive]
retf
;--------------------------------------
; Funktionen & Variablen
;--------------------------------------
BootDrive db 0
LoadMsg db "Loading Genesis...", 13, 10, 0
; Druckt eine Zeichenkette.
; Parameter: Zeichenkette in si
PutStr:
lodsb
or al, al
jz short putstrd ; \0 ?
mov ah, 0x0E ; Funktion
mov bx, 0x0014 ; Attribut
int 0x10
jmp PutStr
putstrd:
retn
; Laedt den Kernel.
LoadKernel:
push ds ; Diskdrive reseten
mov ax, 0 ; Funktion
mov dl, [BootDrive]
int 13h
pop ds
jc LoadKernel
Load1:
mov ax, 0x1000 ; ES:BX = 10000
mov es, ax
mov bx, 0
; Sektoren lesen
mov ah, 2 ; Funktion
mov al, 5 ; Anzahl der Sektoren
mov cx, 2 ; Cylinder 0 Sektor 2
mov dx, 0 ; Head & Laufwerk 0
int 13h ; ES:BX Daten vom Laufwerk
jc Load1
mov si, LoadMsg
call PutStr
retn
times 512-($-$$)-2 db 0 ; Bootsignatur
dw 0x0AA55
Kernel
org 0x1000
mov al, 0x50
mov ah, 0x0E
mov bx, 0x0014
int 0x10
xor ah, ah
int 0x16
;*************************************
org 0x1000
bits 16
;*************************************
mov ax, cs
mov ds, ax
cli
lgdt [gdt_p]
mov eax, cr0
or al, 00000001b
mov cr0, eax
jmp 0x0008:pmode
;*************************************
bits 32
;*************************************
pmode:
mov ax, 0x0010
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
mov esp, 0x001FFFFF
mov edi, 0x000B8000
mov Byte [edi ], 'L'
mov Byte [edi+2], 'O'
mov Byte [edi+4], 'W'
hang:
jmp hang
;*************************************
gdt dw 0x0000
dw 0x0000
db 0x00
db 0x00
db 0x00
db 0x00
dw 0xFFFF
dw 0x0000
db 0x00
db 0x9A
db 0xCF
db 0x00
dw 0xFFFF
dw 0x0000
db 0x00
db 0x92
db 0xCF
db 0x00
;*************************************
gdt_p dw 23
dd gdt
;*************************************
Gebootet wird ansich perfekt, "P" wird ausgegeben und ein Tastendruck wird erwartet, aber dann: reboot
Danke, für die ganze Hilfe übrigens :)
-
Nur so als kleine Anmerkung.
Es ist nicht verwunderlich das 2 von 2 verschiedenen personen für verschiedene OS' erstelle Codestücke nicht zusammen funktionieren.
Man sollte es daher strengstens vermeiden Code einfach zu kopieren.
Sondern eher verstehen wie es geht und den Code von anderen als Anregung oder auf die ersten Sprünge helfen nehmen um dann seinen eigenen Code so zu erstellen, das er für die eigenen Bedürfnisse passt.
Soviel Arbeit sollte man sich schon machen. Der Lerneffekt ist größer und man hat so auch die Möglichkeit das ganze so zu erstellen wie man das gerne hätte.
Denn Gerade auf ASM-Ebene gibt es keine Standards an die sich jeder halten müsste, was dazu führt das 2 Codes nicht zusammenarbeiten wie man das gerne hätte.
-
Ja, ist mir schon klar :)
Aber mir geht es darum das ich nicht verstehe warum der PMode bei mir nicht klappt, auch mit meiner Methode. Es ist nur so das ich für gewöhnlich erst schaue ob ein Code funktioniert. Wenn ja, sehe ich mir seine Funktionsweise an, tue dies je nach schwierigkeit des Themas noch mit einer Anzahl anderer Codes und versuche dann meinen eigenen zu schreiben, da meiner hier nicht funktioniert wollte ich mal schauen ob es blueXseven's Code tut um zu vergleichen, da ich seinen Bootloader allerdings nicht habe, kann ich auch nur mit "meinem" testen...
-
Ähm warum org 0x0 ?
-
Wenn du kein org an gibst nimmt er automatisch 0 als startadresse, man kanns ja aber nochmal hinschreiben damits der Programmierer der sich den Code anschaut übersichtlicher hat^^
-
Danke, es läuft ;) eigenartiger weise nicht in Bochs, sondern nur auf meinem 2. Rechner und in VMWare...
-
Bei mir isses bisher andersrum hab heute beschlossen mal auf echtem Rechner mein OS laufend zu machen^^ mein Bootloader funzt unter Bochs aber unter einen echten Rechner nit^^
-
Jetzt, nachdem ich etwas weiter gecodet habe (VGA statt normalem Text) läufts überall ;) (also von meinen 3 Testgebieten ^^)
-
So, ich will nicht gleich noch 'nen Thread aufmachen, deshalb frage ich hier. Ich habe jetzt nen C-Kernel dazu gebastelt und nun sagt Bochs folgendes:
prefetch: RIP > CS.limit
Tja, ich werde daraus nicht schlau, was meint er mit RIP...bezieht sich das IP auf "Instruction Pointer"? Ist damit gemeint das der Instruction Pointer das CodeSegementlimit überschreitet?
Das Code Segment (für den Descriptor, siehe blueXseven's Code, der Descriptor ist von dort) sollte doch groß genug sein, nämlich bis zu 4 GB (naja, ich habe halt 256MB^^)
-
Rip is glaub ich der IP, schon richtig.
Bei mir kam das immer wenn ich irgendnen Fehler beim laden des Kernels gemacht habe, der also nicht geladen wird, der Sprung also dann ins "nichts führt". An der stelle stehen bei Bochs dann lauter Nullen, und das ist für die CPU ein gültiger Opcode, die führt er dann aus bis zum Ende;)
Aber diesen Fehler sehe ich bei Bochs des öfteren aus unerklärlichen Gründen, kam sogar schon vor dass der bei einem direkten Neustart nicht mehr war^^
-
Okay, mir ist gerade aufgefallen, das es nur einer der GAAAAAAAAANZ dummen Fehler war ;) Ich hatte vergessen beim copy-Befehl eine *.bin-Endung vergessen...komischerweise hatte ich keine Fehlermeldung gesehen, naja jetzt funzt es ja :) Danke nochmals für die Hilfe^^
EDIT: Okay, von meinen, bereits des öfteren erwähnten, Testmedien funzt es wieder nur auf 2en, in VMWare funzt es diesmal nicht :-P
-
Tja, wie ich bereits gepostet habe, funzen bei mir keine Globalen Variablen und auch ein paar andere Sachen immer wieder nicht...(meist weil man dazu globale Variablen bräuchte) Nun habe ich "meinen" (also eigentlich BlueXSevens, ich benutze ihn nur) Code mit anderen Codes verglichen und mir ist dabei aufgefallen das zum Beispiel bei TeeJays Code der 0 descriptor in fs und gs geladen wird, bei BlueXSeven hingegen 16 (soweit ich mich erinnere) warum? Also es liegt wohl am unterschielichen Code, aber was bewirkt dieser Unterschied?
-
Okay, danke für die rasche Antwort...:
[bits 16]
org 0x0
jmp start
; ===============================
; = Global Descriptor Table =
; ===============================
Descriptoren dw 0x0000
dw 0x0000
db 0x00
db 0x00
db 0x00
db 0x00
dw 0xFFFF
dw 0x0000
db 0x00
db 0x9A
db 0xCF
db 0x00
dw 0xFFFF
dw 0x0000
db 0x00
db 0x92
db 0xCF
db 0x00
GDT dw 23
dd 0
; ===============================
; = Protected Mode Start =
; ===============================
start:
mov ax, cs
mov ds, ax
cli
xor eax, eax
mov ax, ds
shl eax, 4
add eax, Descriptoren
mov dword [GDT+2], eax
lgdt [GDT]
mov eax, cr0
or al, 00000001b
mov cr0, eax
jmp 0x0008:dword 0x10000+ProtectedMode
; =======================================
; = !Here starts 32bit protected mode! =
; =======================================
[bits 32]
ProtectedMode:
mov ax, 0x0010
mov ds, ax
mov es, ax
mov ss, ax
mov fs, ax
mov gs, ax
mov esp, 0x1FFFFF
Was ist daran dann falsch? (Funzt soweit, nur mit C dann nicht, obwohl der Code stimmt...der kann absolut keine Globalen Variablen (also nur wenn ihnen Global ein wert zugewiesen wird) und keine Parameter und Returnwerte bei Funktionen O_O)
Achja, warum eigentlich 0x0010?
@BlueXSeven hast du ICQ oder so?