Thema: Problem mit der IDT

[Hauke]

Ich habe für den ProtectMode ein Kernel programmier nur notwendige Sachen (GDT). Dann habe ich es mit der IDT erweitert jedoch stürzt der Rechner nun immer ab, und ich weiß nicht, was am Code falsch ist, jedoch muss die IDT falsch sein, weil ohne sie funktioniert alles. Ich hab zwar die Exceptions noch nicht richtig behandelt aber trotzdem müsste der Code funktionier, weil keine Exceptions ausgelöst werden. Zu den Exceptions noch ein paar Fragen, welche Exceptions muss man den jetzt programmieren und was bedeutet das, wenn sie Exceptions reserviert sind wie 20 – 31 habe ich das so richtig gemacht?

Code: [Auswählen]

[BITS 16] ;16 Bit Code erstellen
jmp start ;GDT überspringen

sCODE equ 1000b
%macro makeIDT 3
dw %1
dw %2
db 0
db %3
dw 0
%endmacro

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

dk3:
dw 0x1F40
dw 0x8000
db 0xB
db 10110010b
dw 0

gdt:
Limit    dw 0   ;Größe der GDT (wird später eingetragen)
Base dd 0 ;Adresse der GDT (wird später eingetragen)

;******************************

idts:
makeIDT IRQ_00 ,sCODE, 10001110b
makeIDT IRQ_01, sCODE, 10001110b
makeIDT IRQ_02, sCODE, 10001110b
makeIDT IRQ_03, sCODE, 10001110b
makeIDT IRQ_04, sCODE, 10001110b
makeIDT IRQ_05, sCODE, 10001110b
makeIDT IRQ_06, sCODE, 10001110b
makeIDT IRQ_07, sCODE, 10001110b
makeIDT IRQ_08, sCODE, 10001110b
makeIDT IRQ_09, sCODE, 10001110b
makeIDT IRQ_10, sCODE, 10001110b
makeIDT IRQ_11, sCODE, 10001110b
makeIDT IRQ_12, sCODE, 10001110b
makeIDT IRQ_13, sCODE, 10001110b
makeIDT IRQ_14, sCODE, 10001110b
makeIDT IRQ_15, sCODE, 10001110b
makeIDT IRQ_16, sCODE, 10001110b
makeIDT IRQ_17, sCODE, 10001110b
makeIDT IRQ_18, sCODE, 10001110b
makeIDT IRQ_19, sCODE, 10001110b
makeIDT IRQ_20, sCODE, 10001110b
makeIDT IRQ_21, sCODE, 10001110b
makeIDT IRQ_22, sCODE, 10001110b
makeIDT IRQ_23, sCODE, 10001110b
makeIDT IRQ_24, sCODE, 10001110b
makeIDT IRQ_25, sCODE, 10001110b
makeIDT IRQ_26, sCODE, 10001110b
makeIDT IRQ_27, sCODE, 10001110b
makeIDT IRQ_28, sCODE, 10001110b
makeIDT IRQ_29, sCODE, 10001110b
makeIDT IRQ_30, sCODE, 10001110b
makeIDT IRQ_31, sCODE, 10001110b
makeIDT IRQ_32, sCODE, 10001110b




idt:
Limiti dw 0 ;Größe der IDT (wird später eingetragen)
Basei dd 0 ;Adresse der IDT (wird später eingetragen)

;*******************************************
start:
mov ax,3
int 0x10

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 Codesegmentesals
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 [Limiti], word idt - idts -1


mov eax, cs ;Startadresse der GDT errechnen
shl eax, 4
add eax, idts
mov [Basei], eax


mov si, idts
mov ecx, 33
idv:
xor edx,edx
mov dx, [si]
cmp dx, 0
je son
add edx, eax
mov [si], dx
add si, 6
shr edx, 16
mov [si], dx
inc si
inc si
loop idv
jmp schl
son:
add si, 8
loop idv
schl:


lidt [idt]

;*****************************************************************
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 END ;Zum Ende Springen

;*********************************************



IRQ_00:
xor al, al
jmp irqA

IRQ_01:
mov al, 1
jmp irqA

IRQ_02:
mov al, 2
jmp irqA

IRQ_03:
mov al, 3
jmp irqA

IRQ_04:
mov al, 4
jmp irqA

IRQ_05:
mov al, 5
jmp irqA

IRQ_06:
mov al, 6
jmp irqA

IRQ_07:
mov al, 7
jmp irqA

IRQ_08:
mov al, 8
jmp irqA

IRQ_09:
mov al, 9
jmp irqA

IRQ_10:
mov al, 10
jmp irqA

IRQ_11:
mov al, 11
jmp irqA

IRQ_12:
mov al, 12
jmp irqA

IRQ_13:
mov al, 13
jmp irqA

IRQ_14:
mov al, 14
jmp irqA

IRQ_15:
mov al, 15
jmp irqA

IRQ_16:
mov al, 16
jmp irqA

IRQ_17:
mov al, 17
jmp irqA

IRQ_18:
mov al, 18
jmp irqA

IRQ_19:
mov al, 19
jmp irqA

IRQ_20:
mov al, 20
jmp irqA

IRQ_21:
mov al, 21
jmp irqA

IRQ_22:
mov al, 22
jmp irqA

IRQ_23:
mov al, 23
jmp irqA

IRQ_24:
mov al, 24
jmp irqA

IRQ_25:
mov al, 25
jmp irqA

;*

IRQ_26:
mov ax, 256
jmp irqA


;*

IRQ_27:
mov al, 27
jmp irqA

IRQ_28:
mov al, 28
jmp irqA

IRQ_29:
mov al, 29
jmp irqA

IRQ_30:
mov al, 30
jmp irqA

IRQ_31:
mov al, 31
jmp irqA

IRQ_32:
xor si, si
mov ax,3
shl eax, 3
mov ds, ax
mov cl, 'h'
mov [si],cl
inc si
inc si
mov cl, 'a'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'o'
mov [si],cl
inc si
inc si
xor ecx, ecx
not ecx
zz:
loop zz
h:
jmp h

irqA:
xor si, si
mov cl, al
mov ax,3
shl eax, 3
mov ds, ax

mov al, cl
mov ch, '0'
aam
add ah, ch
mov [si],ah
mov cl, al
xor eax, eax
mov al, ah
mov bl, 10
mul bl
sub al, cl
add al, ch
inc si
inc si
mov [si],al
zui:
jmp zui

;************************************************


END:
xor si, si
mov ax,3
shl eax, 3
mov ds, ax
xor esi, esi
mov ax, 3
shl eax, 3
mov ds, ax
mov cl, 'a'
mov byte [esi],48
inc esi
inc esi
mov [esi],cl
;mov ax, 0x1000
;mov es, ax
mov ax, 0x1000
mov ds, ax
g:
jmp g

[Hauke]

Ich hab es selbst herausgefunden was der Fehler war, aber ein neues Problem ist da. Wenn die Register vor den Exceptions oder Interrupt gesichert und nach dem Code wieder hergestellt werden funktionier das Laden der IDT ohne Absturz. Aber jetzt wollte ich den selbst gemachten Interrupt 32 ausprobieren,  die Anweisungen des Int 32 funktionier ja, aber Exceptions 13 ausgelöst, wenn mit Iret zurück gesprungen wird, wonach der Rechner abstürzt. Was ist die Fehler Ursache.

Code: [Auswählen]

IRQ_01:
pusha
push es
push ds
push fs
push gs
mov al, 1
jmp irqA
So sehen alle Exceptions aus, nur ein anderer Wert wir zu al gemovt, die Nummer des Exceptions.

Code: [Auswählen]

IRQ_32:
pusha
push es
push ds
push fs
push gs
xor si, si
mov ax,3
shl eax, 3
mov ds, ax
mov cl, 'h'
mov [si],cl
inc si
inc si
mov cl, 'a'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'o'
mov [si],cl
pop gs
pop fs
pop ds
pop es
popa
pop eax
mov ecx, 0x2fffff
rr2:
loop rr2 ;warteschleife
iret  

irqA:
xor si, si
mov cl, al
mov ax,3
shl eax, 3
mov ds, ax

mov al, cl
mov ch, '0'
aam
add ah, ch
mov [si],ah
inc si
inc si
add al, ch
mov [si],al
mov ecx, 0xffff ;warteschleife
kk5:
loop kk5
pop gs
pop fs
pop ds
pop es
popa
iret