Thema: Pmode?

[Roshl]

Natürlich wie willst du sonst nen Tastaturtreiber schreiben oder nen FDC treiber?
Das Programm muss dann aber im Ring0  laufen^^

[joachim_neu]

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!

[Another Stupid Coder]

@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^^

[GhostCoder]

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

[Another Stupid Coder]

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.

[TeeJay]

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.

[GhostCoder]

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

[TeeJay]

Ah stimmt

So wars....scho ne weile her mit dem PMode Tut

[Another Stupid Coder]

Ähm...das soll jetzt wirklich nicht nerven oder so, aber ihr könnt mir nicht zufällig helfen?

[Another Stupid Coder]

Was bedeutet "23" in der vorletzten Zeile?

[TeeJay]

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.

[Another Stupid Coder]

Ä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...

[GhostCoder]

Hiho,

sicher das dein Loader läuft?
Nochma zum GDT:
Ich bin eigentlich ziemlich überzeugt, das

Code: [Auswählen]


 dd    gdt

nich passen, kann, da der z.b. 0x1500 ist, der Prozessor aber ne 32-Bit Addresse verlangt
Hier stehts (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

[Another Stupid Coder]

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

[TeeJay]

Code: [Auswählen]


[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

[Another Stupid Coder]

Danke, mit TeeJay's Code klappts daweil^^

[GhostCoder]

Code: [Auswählen]


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!

Code: [Auswählen]


   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

[TeeJay]

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.

[Another Stupid Coder]

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  )
Bootloader

Code: [Auswählen]


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

Code: [Auswählen]


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

[TeeJay]

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.