Thema: Mappen und dismappen

[joachim_neu]

hallo,

ich mache gerade meine speicherverwaltung im FRM (flat real mode) und bin dabei, dass mit banks zu machen. die erste bank ist ab 0x120000 linear, und jede bank ist 0x80000 bytes lang. alle banks sind hintereinander. ich habe jetzt funktionen geschrieben, um diese banks zu mappen, bzw. dismappen:

mappen:

Code: [Auswählen]


pusha
push ds
push es
[BITS 32]
mov eax,0x00
[BITS 16]
mov ax,cx       ;offset berechnen, indem man die page in CX mit der länge
mov bx,0x08   ;multipliziert
mul bx
add ax,0x04    ;dann noch 0x04 dazuaddieren, wg. start bei 0x120000
[BITS 32]
shl eax,0x20   ;um 5 stellen nach links verschieben
mov ds,eax     ;leseregister stellen
mov eax,0x1000  ;schreiberegister auf framebase stellen
mov es,eax
xor si,si
xor di,di
mov ecx,0x40000   ;0x80000 bytes = 0x40000 words lesen
rep movsw
[BITS 16]
pop es
pop ds
popa


dismappen:

Code: [Auswählen]


pusha               ;kommentare wie beim mappen, außer es und ds
push ds             ;beim kopieren vertauscht, um vom frame in die page zu
push es           ;schreiben
[BITS 32]
mov eax,0x00
[BITS 16]
mov ax,cx
mov bx,0x08
mul bx
add ax,0x04
[BITS 32]
shl eax,0x20
mov es,eax
mov eax,0x1000
mov ds,eax
xor si,si
xor di,di
mov ecx,0x40000
rep movsw
[BITS 16]
pop es
pop ds
popa    



allerdings verstehe ich nicht, warum das nicht funktioniert... ich hoffe mir kann jemand helfen, danke!

[Jidder]

hi

wenn du im flat real mode bist muss der gesamte code 16bit code sein. nur die datenaddressierung ist 32 bit. also ich würde erstmal die ganzen [BITS 32] und [BITS 16] rausmachen.

du lädst ds und es (schon wieder ) mit einem offset. in ds und es kommen nur selektoren. in esi und edi kommen die offsets.

btw, statt
mov ax, cx
mov bx, 0x08
mul bx
würd ich eher schreiben:
mov ax, cx
shl ax, 3
spart ein reg

mfg porkchicken

[joachim_neu]

sorry, aber ich kapiere das irgendwie nicht!!! hier ist nochmal mein code:

Code: [Auswählen]


;INT 0x67-0x06
_int0x67_ser0x06:
pusha
push ds
push es
mov eax,0x00
mov ax,cx
shl ax,3
add ax,0x12
shl eax,0x20
mov esi,eax
mov eax,0x10000
mov edi,eax
xor ax,ax
mov es,ax
mov ds,ax
mov ecx,0x40000
rep movsw
pop es
pop ds
popa
jmp _int0x67_end
;INT 0x67-0x07
_int0x67_ser0x07:
pusha
push ds
push es
mov eax,0x00
mov ax,cx
shl ax,3
add ax,0x12
shl eax,0x20
mov edi,eax
mov eax,0x10000
mov esi,eax
xor ax,ax
mov es,ax
mov ds,ax
mov ecx,0x40000
rep movsw
pop es
pop ds
popa
jmp _int0x67_end  


diesmal in API-Fassung. das erste ist wieder mappen und das zweite dismappen. ich habe das mit dem registersparen eingebaut. ich habe die segmente auf 0x00 gestellt und die offsets mit den lineare adressen geladen. und ratet mal: ES geht WIEDER nicht... ich kapier das alles nicht. pork: hast du ICQ? da könntest du es mir vielleicht erklären. ich habe im moment eine GDT und zwar:

Code: [Auswählen]


        cseg:   dd 0x0000FFFF, 0x00CF9800 ; code segment, 32-bit, 0 to 4GB
        dseg:   dd 0x0000FFFF, 0x00CF9200 ; data segment, 32-bit, 0 to 4GB
        cs16:   dd 0x0000FFFF, 0x00009800 ; code segment, 16-bit, 0 to 64KB
        ds16:   dd 0x0000FFFF, 0x00009200 ; data segment, 16-bit, 0 to 64KB

davon sind die 1. 2 für den adressraum über 1 MB und die 2. 2 für den 1 MB-Raum. in dem teil, das ich gelesen habe stand aber, dass man dem assembler mitteilen muss, wenn man 32 bit benutzt...

mfg

jN!

[Jidder]

ich seh da zur Zeit nur, dass du ds und es mit einem ungültigen selektor lädst. du musst den 32bit daten selektor (dein dseg) da reinladen. ich hoffe mal der dseg-selektor ist dein dritter (wenn man so zählt, dass der null-selektor der erste ist).

das:

Code: [Auswählen]

xor ax,ax
mov es,ax
mov ds,ax
müsste also so lauten:

Code: [Auswählen]

mov ax, 0x10
mov es,ax
mov ds,ax

was mir dabei einfällt ist, dass ich mir nicht sicher bin ob man im FRM die selektoren überhaupt ändern darf. ich habe das nie getestet, aber ich habe die vermutung, dass wenn du mov ax, 0x10 und dann mov ds, ax oder so machst, dass du dann keinen selektor mehr lädst, sondern ein normales, langweiliges 16bit-segment. das werd ich mal testen...

meine ICQ#: 173196533

in dem teil, das ich gelesen habe stand aber, dass man dem assembler mitteilen muss, wenn man 32 bit benutzt...

jepp, du musst ihm sagen in wieviel bit der code geschrieben ist. und das ist im flat real mode 16bit. sonst wäre es schon protected mode. die bits bei den daten operationen verklickerst du dem assembler ja schon, indem du statt ax, si, di usw. einfach eax, esi, edi usw. schreibst.

edit: übrigens schreibst du ziemlich viel von deinem arbeitsspeicher voll mit int 0x67, function 6. von 0x10000 schreibst du ein halbes megabyte (0x80000) voll. pass auf, dass du dein programm nicht dabei erwischst.   ich hoffe mal, du hast dein programm unter 0x10000 oder über 0x90000 geladen.

mfg porkchicken

[joachim_neu]

aso! deswegen war das auch in dem beispiel so, weil man ja da in den PM schalten muss, um rein zu kommen!

[joachim_neu]

ich kann dich beruhigen, mein kernel ist nur 17 sektoren groß, und ist sicher!! der liegt bei 0x50 segment und danach kommen noch platz fürs root-dir und so, und dann ist noch was frei, und dann kommt erst das andere!

[Jidder]

hehe ich bin beruhigt ^^

also um die anderen leute hier mal auf den aktuellsten standzubringen:
man darf im FRM wie vermutet ds und es usw. nicht ändern. ich habs durch probieren rausbekommen, sicherlich wäre das auch durch nachlesen gegangen ...

man muss um ds und es mit selektoren zu laden im echten protected mode sein. es gibt also zwei möglichkeiten:
1. beim booten in den protected mode wechseln, dsund es mit 4GB selektoren beladen und in den unreal mode gehen (bit 0 von cr0 löschen). Danach kann man zwar schön im ganzen arbeitsspeicher herumwüten, muss aber dafür sorgen, dass ds und es unter keinen umständen beschrieben werden.

2. man lässt die sau raus und macht was man will mit ds und es, muss aber jedes mal um sie zu ändern in den protected mode gehen, sie dann ändern und dann wieder in den unreal mode gehen. ist langsam und aufwändig. ist mMn keine echte alternative.

achso unreal mode = flat real mode = FRM

[joachim_neu]

1. ok, danke. dann habe ich aber ein problem: wenn ich im unreal-mode BIOS-Ints benutzen will, muss ich ja die segment mit den segmenten laden, zum beispiel bei sektoroperationen. dass würde ja dann nicht gehen, weil ich sonst meine 4BG-Selektoren kaput mache...
2. ich habe ein gegenbeispiel:

Code: [Auswählen]


[BITS 32]
mov eax,0x200000
mov ds,eax
mov es,eax
xor di,di
xor si,si
mov al,0x01
stosb
xor al,al
lodsb
[BITS 16]
push ax
mov ax,0x50
mov ds,ax
mov es,ax
xor si,si
xor di,di
pop ax
mov [ems],al


mit dem wert wird mit den segment in einen bereich über 1 MB gezeigt, da ein byte hingeschrieben, al auf 0 gesetzt, und dann das byte wieder gelesen. damit wird erkannt, ob das wechseln funktioniert hat, da al nach dem lodsb nur 0x01 ist, wenn das lesen erfolgreich war. und dieser code funktioniert...

[Jidder]

ja der code scheint zu funzen.

aber er schreibt nicht in den bereich über 1 mbyte. du lädst ds und es mit 0x0000. das sind immer noch 16bit register, die immer noch nur werte von 0x0000 bis 0xFFFF aufnehmen. der rest wird abgeschnitten. dann schreibst du ans offset 0. du schreibst also gerade in der IVT rum.

beweisen kann man es in dem du am anfang eax mal mit 0xF0000000 (=3,75 GByte) lädst und dann das auf einem rechner ausprobierst, der weniger als 3,75 GByte RAM hat. Das wird auf dem auch funzen, weil eben die oberen 16bit abgeschnitten werden und ds und es mit 0x0000 geladen werden.

[joachim_neu]

du hast mal wieder recht...

[joachim_neu]

so, nachdem wir das problem mit dem unreal-mode gelöst haben, kommen wir wieder hierhin zurück. ich habe ja das unreal-mode-zeug in ein int gepackt. aber es geht immernoch nicht. ich habe jetzt folgenden code:

Code: [Auswählen]


;INT 0x67-0x06
_int0x67_ser0x06:
pusha
pusha
mov ah,0x08
int 0x67
popa
mov eax,0x00
mov ax,cx
shl ax,3
add ax,0x12
shl eax,0x20
mov esi,eax
mov eax,0x10000
mov edi,eax
xor ax,ax
mov es,ax
mov ds,ax
mov ecx,0x40000
rep movsw
popa
jmp _int0x67_end
;INT 0x67-0x07
_int0x67_ser0x07:
pusha
pusha
mov ah,0x08
int 0x67
popa
mov eax,0x00
mov ax,cx
shl ax,3
add ax,0x12
shl eax,0x20
mov edi,eax
mov eax,0x10000
mov esi,eax
xor ax,ax
mov es,ax
mov ds,ax
mov ecx,0x40000
rep movsw
popa
jmp _int0x67_end


und der funktioniert nicht. allerdings verstehe ich nicht, warum. ich hoffe, mir kann jemand helfen...

DANKE!

[Jidder]

das shl ax,3 würd ich lieber zum shl eax,3 machen. sonst kannst du nur zahlen < 8192 korrekt verarbeiten.

Code: [Auswählen]

xor ax,ax
mov es,ax
mov ds,ax
muss raus. du lädst ds und es mit nulldeskriptoren, was du wohl nicht wirklich beabsichtigst. dein int 0x67, function 0x08 lädt die ja außerdem schon mit korrekten 4GB selektoren.

das ist alles was mit dazu auffällt ...

achso, du kannst übrigens auch direkt werte in esi und edi schreiben. den umweg über eax musst du nicht machen ...

[joachim_neu]

ok... mach ich!

EDIT: geht trotzdem nicht... ich kapiers nicht!

[joachim_neu]

das problem hat sich gelöst. nochmals vielen dank!