Thema: Speicherbestückung überprüfen

[joachim_neu]

also, dieser code soll den speicher außerhalb des 1MB-Rahmens des RM messen:

Code: [Auswählen]


mov eax,0x100000
mov ds,eax
mov es,eax
xor esi,esi
xor edi,edi
check_ram_loop:
mov al,0x80
stosb
xor al,al
lodsb
cmp al,0x80
je check_ram_loop
dec esi
mov eax,esi
mov ebx,0x100000
div ebx
mov eax,0x50
mov ds,eax
mov es,eax
add [ram],eax  


er soll also jedes byte schreiben, wieder lesen, schauen ob das ergebniss gleich dem geschriebenen ist, und fortfahren, solange, bis er was falsches (warsch. 0) zurückbekommt, d.h. den speicher nichtmehr ansprechen kann. dann soll er esi dekrementieren, weil das ja schon eine zelle weiter ist, und da das falsche gefunden hat, und es dann in eax schieben. eax wird dann mithilfe von ebx durch 0x100000 geteilt, um die MB zu erhalten. am ende werden die register wieder richtig gestellt, um das dann in die variable "ram" zu kopieren.

jetzt zu meinem problem: der code geht nicht (was ein wunder   )

bei BOCHS kommt immer: RIP > CS.limit

kennt sich da jemand aus? danke!

[TeeJay]

Im Realmode kann man garnicht mehr als 1 MB ansprechen....
wie willste da also den Speicher AUßERHALB des 1 MB Rahmens testen?...

[joachim_neu]

Im Realmode kann man garnicht mehr als 1 MB ansprechen....
wie willste da also den Speicher AUßERHALB des 1 MB Rahmens testen?...

ich bin im unreal-mode, auch flat real-mode genannt.

[Jidder]

Code: [Auswählen]

mov eax,0x100000
mov ds,eax
mov es,eax
das geht nicht. du versuchst da ds und es mit einem 32bit wert (soll wohl ein offset sein) zu laden. sie werden danach den wert 0 haben, weil sie 16bit register sind. (die oberen 16 bit sollten abgeschnitten werden) mich wundert dass du keine exception bekommst. du musst sie mit einem gültigen 32bit datenselektor mit basis 0x00000000 und limit 0xFFFFF (4GB) laden.

Code: [Auswählen]

check_ram_loop:
mov al,0x80
stosb
xor al,al
lodsb
cmp al,0x80
je check_ram_loop
diese schleife testet in 1 byte schritten! das ist ein bisschen langsam und sinnlos. besser wären schritte von 1 MByte. vor allem weil du das mit einer division sowieso nochmal in MByte umrechnest.  außerdem überschreibst du den gesamten arbeitsspeicher. du könntest wichtige datenstrukturen kaputt machen/beeinflussen! du solltest zumindest die einzelnen speicherstellen sichern, dann testen und dann wieder die "sicherung" zurückschreiben.

außerdem überschreibst du dein eigenes programm, denn du fängst bei 0 an. den startwert solltest du in edi und esi laden, nicht in die segment register. (aber eigentlich hättest du vorher eine exception bekommen müssen, weil du einen nullselektor geladen hast. vielleicht ist das ein bug in bochs, der denkt "0x100000 ist ungleich 0, also alles ok" oder so ...)

porkchicken

[GhostCoder]

Hiho,

wenn bochs wirklich im flat rmode arbeitet (der eigentlich nur ein bug ist, soweit ich) musst du die 32-bit offsets trotzdem über segment:offset paare bilden. Meine Idee wäre(wenn du z.b. mit es:si) arbeitest, si auf null setzen, es auf 0x10 (womit du bei der 1mb grenze wärst, die sowieso jeder Rechner hat) und dann zählst du in einer Schleife es immer um 0x10 (1mb hoch).

MfG GhostCoder

[joachim_neu]

1. wie heißen denn die 32-bit-register von ds und es? ees und eds? soweit ich weiß bleiben die doch ds und es, außerdem geht es an einer anderen stelle, wenn ich das so belade.
2. was sollte ich zerstören? außerhalb von den 1 MB ist ja nix!
3. ich überschreibe nicht mein OS, da ich ja bei 0x10000 also an der grenze zu 1 MB anfange, also schon ausm bios-bereich raus bin.
4. warum bin ich bei es = 0x10 auf 1 MB? kapier ich nicht! dann müsste ich doch auf 0x100 linear sein...
5. ich habe den gesamten raum mit einem selektor belegt, das geht schon.

[Jidder]

zu 1. nein das hast du falsch verstanden. du lädst ds und es mit einem selektor. in deiner gdt sollte einer deiner selektoren ein 32bit datenselektor sein.

ds und es sind noch 16bit register, die aber einen sogenannten hidden part haben. in dem stehen die basis und das limit. wenn du einen wert in ds oder es lädst schaut die cpu in der gdt nach und liest dort basis und limit aus und schreibt es in diesen hidden part.

du lädst z.b. ds mit dem selektor 0x10, den du in der gdt zuvor als datenselektor mit basis 0x01000000 (16 MByte) und limit 0xFFFFF (4 GByte) festgelegt hast. wenn du dann in esi z.B. 0x100000 (=1 MByte) stehen hast und dann ein dword aus ds:esi einliest, kann hast du in eax den wert, der im speicher an 0x01100000 (=0x01000000 + 0x00100000, also 17 MByte) steht. Das echte Offset berechnet sich aus der Basis plus angegebenen Offset.

Ich hoffe das ist verständlich. ich weiss jetzt auch nicht wie ich das anders ausdrücken könnte.

zu 2.+3.: ja ich weiss, aber du fängst ja nicht bei 1 mb an sondern bei 0 (esi = edi = 00000000!).

nein du bist nicht unbedingt bei es = 0x10 auf 1 mbyte. 0x10 ist ein selektor. aus der 0x10 lässt sich nicht rückschließen wo du bist. das kommt drauf an was du in deiner gdt stehen hast.