Beiträge anzeigen

Diese Sektion erlaubt es dir alle Beiträge dieses Mitglieds zu sehen. Beachte, dass du nur solche Beiträge sehen kannst, zu denen du auch Zugriffsrechte hast.


Themen - joachim_neu

Seiten: 1 2 [3] 4 5
41
Lowlevel-Coding / Problem mit Zeitmarke
« am: 19. February 2005, 01:43 »
hallo,

ich hab in meinem system (written in ASM) eine variable "millisecs", die speichert, wie viele millisekunden das system schon an ist. die is dazu gut, dass ich zeitfunktionen (delay) einbauen kann. allerdings hab ich ein altes problem: es geht nicht. wundert mich, muss was ganz banales sein:


irq0x00:
;timer-irq
push ds
push eax
mov eax,dssys-GDT
mov ds,eax
mov eax,[millisecs]
add eax,0x05
mov [millisecs],eax

mov esi,init_ok
mov ebx,0x00FF0000
call PrintString                 ;dies hier ist temporär zum testen, ob
call UpdateScreen            ;das int aufgerufen wird!

mov al,0x20
out 0x20,al
out 0xA0,al
pop eax
pop ds
iret  


ich habs auch schon so versucht:


irq0x00:
;timer-irq
push ds
push eax
mov eax,dssys-GDT
mov ds,eax
add dword [millisecs],0x05

mov esi,init_ok
mov ebx,0x00FF0000
call PrintString                 ;dies hier ist temporär zum testen, ob
call UpdateScreen            ;das int aufgerufen wird!

mov al,0x20
out 0x20,al
out 0xA0,al
pop eax
pop ds
iret  


geht aber auch nicht... dann hab ich geschaut, ob der fehler vll. bei meinem delay is, was ich einfach getestet hab, indem ich in die hauptschleife öfters mal ne phrase "mov eax,[millisecs]" reingemacht hab, die dann mit bochs angesteuert und die werte ausgelesen. der wert ist immer 0x0F, was auch komisch is, weil die var mit 0x00 initialisiert wird... würde mich freuen, wenn jemand den fehler findet. danke,

J!N
42
Lowlevel-Coding / VESA -> LinearFrameBuffer
« am: 27. January 2005, 15:06 »
hallo, everybody!

da bin ich wieder, mit einem neuen problem ;-) diesmal gehts (wie das Topic schon sagt) um den LFB bei VESA. ich setze meinen modus mit folgendem code:


;vesamode setzen
mov bx,[vesa_mode]
add bx,0x4000
mov ax,0x4F02
int 0x10  


"vesa_mode" ist dabei eine variable, die ich davor durch prioritätisches heraussuchen festgelegt hab. und dazu addiere ich dann 0x4000 für den LFB. bochs macht (mal wieder) keinen terror, aber mein echter PC schon. auf dem geht das ganze dann, allerdings bekomme ich für den BasePhysPtr immer die adresse auf das 1. fenster, also als währe es bankswitchig...

ich hoffe auf hilfe,

J!N
43
Lowlevel-Coding / Bootloader
« am: 24. January 2005, 15:03 »
hallo zusammen!

ich hab mal nen bootloader geschrieben, der unter bochs auch geht, aber im real-pc net... das hier ist er:


;~~~~~~~~~~~~~~~~~~~~
;~      HighOS      ~
;~~~~~~~~~~~~~~~~~~~~
;@typ    :   bootloader
;@author :   Joachim Neu
;@date   :   17.01.2005 - 23.01.2005
;@version:   1.0

[ORG 0x7C00]      ;startup
[BITS 16]         ;16 bit

mov [bootdrv],dl  ;bootdrive sichern

xor eax,eax
xor ebx,ebx
xor ecx,ecx
xor edx,edx
xor esi,esi
xor edi,edi

;STACK AUFBAUEN!
mov ax,0x9000
mov ss,ax
mov sp,0xFFFF

;VESA AKTIVIEREN!
push ds
;vorbereitungen treffen
mov di,0x50
mov es,di
xor di,di
mov al,'V'
stosb
mov al,'B'
stosb
mov al,'E'
stosb
mov al,'2'
stosb
xor di,di
mov ax,0x4F00
int 0x10             ;vesa auslösen
;verfügbarkeit testen
cmp ax,0x004F
jne near vesa_error
mov si,0x50
mov ds,si
xor si,si
lodsb
lodsb
cmp al,'E'
jne near vesa_error
mov cx,0x06
rep lodsw
lodsw
;liste der modi holen
mov bx,ax
lodsw
mov ds,ax
mov si,bx
push ds
push si
;mode suchen (0x0118)
find_right_mode1:
lodsw
cmp ax,0xFFFF
je check_115_mode
cmp ax,0x0118
jne find_right_mode1
mov bx,0x0118
jmp before_set_vesa
check_115_mode:
pop si
pop ds
;mode suchen (0x0115)
find_right_mode2:
lodsw
cmp ax,0xFFFF
je near vesa_error
cmp ax,0x0115
jne find_right_mode2
mov bx,0x0115
jmp set_vesa_mode
before_set_vesa:
pop si
pop ds
;modeinfos holen
set_vesa_mode:
mov cx,bx
pop ds
mov [vesa_mode],cx
push ds
mov ax,0x4F01
mov di,0x50
mov es,di
xor di,di
int 0x10
;modeinfos auslesen
mov si,0x50
mov ds,si
xor si,si
mov cx,0x0C
rep lodsw
lodsb
lodsb
pop ds
mov [vesa_bits_per_pixel],al
push ds
mov si,0x50
mov ds,si
xor si,si
mov cx,0x14
rep lodsw
lodsd
pop ds
mov [vesa_physical_base_adress],eax
;vesamode setzen
mov bx,[vesa_mode]
;mov bx,0x115
;mov word [vesa_mode],0x115
add bx,0x4000
mov ax,0x4F02
int 0x10

;KERNEL LADEN!
load:
xor ax,ax          ; Funktion 0 (reset)
mov dl,[bootdrv]   ; Dieses Laufwerk ist gewünscht
int 13h            ; Reset
jc load            ; Fehler? -> Noch mal!
load1:
mov ax,0x50        ; ES:BX = 0x500
mov es,ax          ; adresse mit ES:BX bilden (0x50:0x00)
xor bx,bx
mov ah,0x02       ; Funktion 2 (Lesen)
mov al,0x11       ; Lese 11h, also 17 Sektoren
mov cx,0x0002     ; Cylinder=0,Sector=2
xor dx,dx         ; Head=0,Laufwerk=0
mov dl,[bootdrv]  ; bootlaufwerk
int 13h           ; ES:BX =  Daten vom Laufwerk
jc load1          ; Fehler? Noch mal!

load2:
mov ax,0x270       ; ES:BX = 0x2700
mov es,ax          ; adresse mit ES:BX bilden (0x270:0x00)
xor bx,bx
mov ah,0x02       ; Funktion 2 (Lesen)
mov al,0x12       ; Lese 12h, also 18 Sektoren
mov cx,0x0001     ; Cylinder=0,Sector=1
mov dh,0x01       ; Head=1,Laufwerk=0
mov dl,[bootdrv]  ; bootlaufwerk
int 13h           ; ES:BX =  Daten vom Laufwerk
jc load2          ; Fehler? Noch mal!

load3:
mov ax,0x4B0       ; ES:BX = 0x4B00
mov es,ax          ; adresse mit ES:BX bilden (0x4B0:0x00)
xor bx,bx
mov ah,0x02       ; Funktion 2 (Lesen)
mov al,0x12       ; Lese 12h, also 18 Sektoren
mov cx,0x0101     ; Cylinder=1,Sector=1
xor dh,dh         ; Head=0,Laufwerk=0
mov dl,[bootdrv]  ; bootlaufwerk
int 13h           ; ES:BX =  Daten vom Laufwerk
jc load3          ; Fehler? Noch mal!

;PM AKTIVIEREN!
lgdt [GDT]        ;gdt laden
mov eax,cr0
or eax,1
mov cr0,eax       ;pm an
jmp 0x08:flash    ;flashen
[BITS 32]
flash:            ;flashen fertig
mov eax,dseg-GDT  ;+
mov ds,eax        ;|
mov es,eax        ;>richtigstellen der datenregister
mov fs,eax        ;|
mov gs,eax        ;|
mov ss,eax        ;+
mov esp,0x9FFFF   ;stack einrichten

mov dl,[bootdrv]                        ;übergabe des bootdrives an den kernel
mov al,[vesa_bits_per_pixel]            ;übergabe der bits pro pixel an den kernel
mov cx,[vesa_mode]                      ;übergabe des modus
mov ebx,[vesa_physical_base_adress]     ;übergabe der physbaseptr-var an den kernel
jmp 0x08:0x500                          ;zum kernel springen

jmp $             ;stop, damit kein crash in die vars erfolgt

[BITS 16]
;fehlerbehandlung
vesa_error:
pop ds
mov si,vesa_error_text
call putstr
call getkey
call reboot

;funktionen
putstr:
lodsb          
or al,al
jz short putstrd
mov ah,0x0E  
mov bx,0x0007    
int 0x10          
jmp putstr        
putstrd:
ret
getkey:
mov ah, 0
int 016h
ret
reboot:
db 0EAh
dw 0000h
dw 0FFFFh

;vars
bootdrv db 0x00
vesa_bits_per_pixel db 0x00
vesa_physical_base_adress dd 0x00000000
vesa_mode dw 0x0000
vesa_error_text db "Error in VESA 2.0!",13,10,0

;global deskriptor tabelle
GDT:
dw gdt_limit ; NULL-deskriptor
dd GDT
dw 0
cseg dd 0x0000FFFF,0x00CF9800 ; code segment,32-bit,0 bis 4GB
dseg dd 0x0000FFFF,0x00CF9200 ; data segment,32-bit,0 bis 4GB
gdt_limit equ $-GDT-1

times 512-($-$$)-2 db 0   ; Dateilänge: 512 Bytes
dw 0AA55h                 ; Bootsignatur


was könnte also einen echten PC dabei zu einem reboot bewegen, was bochs nix ausmacht? ich hab bis jetzt noch nix gefunden...  :cry:

in hoffnung auf hilfe,

J!N
44
Lowlevel-Coding / X-Faktor, das Unfassbare ;-)
« am: 23. January 2005, 19:27 »
tja, da bin ich wieder, mit einem neuen mysterium:
was ist der unterschied zwischen:

call ClearScreen                         ;\
mov esi,init_ok                          ;|
mov ebx,0x00FFFFFF                       ;>erfolgreicher start ausgeben
call PrintString                         ;|
call UpdateScreen                        ;/

und

call ClearScreen
mov esi,init_ok
mov ebx,0x00FFFFFF
call PrintString
call UpdateScreen      

?????????
eigendlich nur die kommentare, aber bochs macht beim 1. nur schrott, und beim 2. gehts... echt genial o_O...

mfg

J!N
45
Lowlevel-Coding / Big-Small-Sonstwas-Endian
« am: 23. January 2005, 02:42 »
hallo,

weiß jemand einen "trick", mit dem man dem rechner dieses ewige verändern von DBs, DWs und DDs mit "hilfe" von big- oder sonstwas endian abgewöhnen kann? ich mache gerade eine BitFont, und da nervt das schon sehr, wenn der mir meine buchstaben und Co. einfach verdreht und soweiter...

mfg

J!N
46
Lowlevel-Coding / VESA...
« am: 22. January 2005, 00:09 »
hallo,

ich habe mir gerade einen vesacode geschrieben. der schaut, ob der mode da ist, nimmt die eigenschaften (X bits per pixel, PhysBasePtr) und setzt den mode. beim testen bin ich drauf gekommen, dass (wenn ich das richtig abgelesen hab) der PhysBasePtr bei 0xE0000000 ist... wie soll ich da hinkommen, bei einem rechner, der nur 256 MB hat...

thx,

J!N
47
Lowlevel-Coding / Ich raffs net! Spinne ich oder mein PC?!
« am: 21. January 2005, 17:46 »
hallo,

ich bin kurz vorm ausflippen! ich habe hier so ne nette GDT:

GDT:
dw gdt_limit
dd GDT
dw 0
cssys:
dw 0x0100
dw 0x0000
db 0x00
db 10011010b
db 11000000b
db 0x0000
dssys:
dw 0x0100
dw 0x0000
db 0x00
db 10010010b
db 11000000b
db 0x0000
csprg:
dw 0xFFFF
dw 0x0000
db 0x10
db 11111010b
db 11001111b
db 0x00
dsprg:
dw 0xFFFF
dw 0x0000
db 0x10
db 11110010b
db 11001111b
db 0x00
gdt_limit equ $-GDT-1

wenn ich jetzt ein register mit dssys-GDT (also dem datenregister des systems) belegen will, dann gibt das laut meinem assembler 0x0A... nach meiner berechnung müsste da aber 0x10 rauskommen, denn für den 0-deskriptor sind es 1word+1double+1word = 8bytes und für den systemcodedeskriptor auch nochmal 2words + 4 bytes, was auch 8bytes macht... und 0x08*2 sind meiner meinung nach 0x10 und net 0x0A... wo ist da der fehler?

vielen dank,

J!N
48
Lowlevel-Coding / Standart...
« am: 21. January 2005, 14:51 »
gibbet irgendwie einen standart, der alle verschiedenen platten und laufwerke (Floppy, HDD,...) unter einen hut bringt? oder muss man sich immer mit verschiedenen für HDD, FDC und so weiter rumplagen? IDE ist dochn "typ" von platte. wird da auch wieder unterschieden zw. IDE und SCSI oder kann man das wie gesagt irgendwie unter einen hut bringen? danke für ne antwort!
49
OS-Design / Aufgaben eines OS
« am: 30. December 2004, 00:05 »
hallo,

was sind die aufgaben eines OS eurer meinung nach? meine meinung:

- verteilung der ressourcen (speicher, CPU,...)
- verwaltung der daten (RAM, Harddrive,...)
- schnittstelle zu Programmen und Hardware (API,...)
- sicherung der programme untereinander (MT,...)

was ist eure meinung?

mfg

J!N
50
Lowlevel-Coding / Stackbereich im RM
« am: 29. December 2004, 01:00 »
hallo,

ich habe ein großes problem. immer, wenn ich mit meinem paging eine page kopieren will, in der ein task ist, dann muss ich ja auch den stack des tasks, der in der page ist mitkopieren. da ich schon rausgefunden habe, dass das net geht, wenn man ss und sp normal läst, hab ich mir gedacht, dass ich einfach mal ss vor dem kopieren aus dem bereich raushole! was passiert? klar: es geht immernoch net. ich setze ss danach auch wieder richtig, das ist es net, aber irgendwie bekommt ss dann nen falschen wert in den hals, und bei dem iret geht er auf was falsches... ich hoffe mir kann jemand helfen! danke!

mfg

JN!
51
Offtopic / Frohe Weihnachten!!!
« am: 24. December 2004, 22:20 »
hallo @alle:

FROHE WEIHNACHTEN!!!

mfg

JN!
52
OS-Design / GUI
« am: 20. December 2004, 21:40 »
so, da mein Paging ja hoffentlich bald funktionieren wird, mein MT steht, und das Task-Kommunikationssystem läuft, mache ich mir gedanken über eine GUI. ich weiß, einige halten die Idee eines OSs im RM für ein bisschen eigenartig ;-) aber ich werd das schon hinbekommen. hab mir jetzt folgende kommunikationsweise für die windows gedacht.
es gibt eine tabelle, in der steht für jedes proggy dessen caption, x- und y-koordinate und höhe und breite, welcher task es aktiviert hat, und ob es gerade aktiviert ist. wenn jetzt jemand mit der maus klickt, schaut die routine, wo er hingeklickt hat. schaut, welches fenster sich da im vordergrund befindet, und schickt an den inhabertask per msg-system die meldung, dass geklickt wurde, und wohin. der task muss also immer wieder schauen, ob ein klick erfolgte, wohin, und ob er da einen button oder so hat.
vorteile: man muss sich net um objekte, wie buttons & co kümmern. jeder task kann seine eigenen objekte machen, und muss sich net an die systemeigenen sachen, wie buttons und so halten, sondern kann auch eigenes proggen, und kann auch auf klicks auf ein bild und so reagieren. einfacher zu machen. jedes proggy kann entscheiden, wie und wann es auf was reagiert.

was haltet ihr davon? habt ihr euch darüber schon gedanken gemacht? wie würdet ihr es machen?

mfg

JN!

p.S: könnt auch was sagen, wenn ihr noch net mit dem gedanken spielt.
53
Lowlevel-Coding / Swapping/Paging
« am: 20. December 2004, 14:56 »
hiho zusammen!

mein MultiTasking funktioniert jetzt. Wie vielleicht manche wissen hat jedes Programm eine Page. und die mappe ich immer unter 1MB, um sie auszuführen. in dieser page is auch der stack des progies. und immer, wenn meine copyroutine versucht, diesen stack zu kopieren, stürzt es ab. ich hoffe, dass sich da jemand auskennt. vielleicht hat ja der stack im FRM/RM, in dem ich bin sowas, wie einen schutz, dass man net drinne rumschreiben/lesen kann, denn wenn ich den stack aus der page verlege, dann geht es wunderbar. allerdings geht das ja net, weil sonst die proggys sich selber überschreiben. wie gesagt, ich hoffe, jemand kann mir helfen! danke im vorraus!

mfg

JN!
54
Lowlevel-Coding / Verdammte Ints 0x13 & 0x08!!!
« am: 16. December 2004, 20:36 »
hallo! ich hoffe, ihr könnt mir helfen! ich habe ein krasses problem! und zwar implementiere ich gerade MultiTasking. und da verwende ich int 0x08 (also 0x00 hardware) zum taskswitch! am anfang ging alles ganz fein. jetzt nimmer! das diskettenlaufwerk ist immer an. und am anfang der shell schreibt er manchmal einfach so ein " ". so ein schrott! aber ich schreibe da net im BIOS-Bereich rum, das hab ich mit Bochs herausgefunden! hat jemand gleiche probleme? ich stehe kurz vorm verzweifeln, dieser verdammte shit geht nicht. und am anfang ging er! nur leider hab ich keine sicherung mehr von damals! so ein mist!
55
Offtopic / Wer ist alles im RM?
« am: 07. December 2004, 14:20 »
hallo,

ich wollte mal wissen, wer hier außer mir noch so im RM oder FRM codet. irgendwie habe ich das gefühl, dass die meisten im PM coden ;-)... deswegen will ich mal die paar wenigen suchen, die, wie ich, versuchen ein OS im RM aufzubauen.

mfg

Joachim_Neu

p.S. ich melde mich mal als erster! bitte jeder melden.
56
Lowlevel-Coding / MultiTasking im RM
« am: 06. December 2004, 21:05 »
hallo everybody! da bin ich wieder! und zwar mit einem neuen problem.

diesmal geht es um (die der titel schon sagt) MultiTasking. dazu habe ich einen Tasktable, der so aufgebaut ist:

    - ID 2 bytes
    - Name 12 bytes
    - SS 2 bytes
    - SP 2 bytes
    - Reserviert 2 bytes
    [/list:u]

    am ende des tables steht 0xFFFF als ID. ich habe den task "kernel" so initialisiert:


mov ax,0x0000
mov [fs:0x100000],ax
mov byte [fs:0x100002],'K'
mov byte [fs:0x100003],'E'
mov byte [fs:0x100004],'R'
mov byte [fs:0x100005],'N'
mov byte [fs:0x100006],'E'
mov byte [fs:0x100007],'L'
mov byte [fs:0x100008],0x00
mov byte [fs:0x100009],0x00
mov byte [fs:0x10000A],0x00
mov byte [fs:0x10000B],0x00
mov byte [fs:0x10000C],0x00
mov byte [fs:0x10000D],0x00
mov word [fs:0x10000E],0x9000
mov word [fs:0x100010],0xFFEF
mov byte [fs:0x100012],0xFF
mov byte [fs:0x100013],0x00
mov ax,0xFFFF
mov [fs:0x100014],ax    


mein table ist also an 0x100000 linear. das geht mit dem FRM. jetzt will ich die einzellnen Tasks abrufen, bis als ID 0xFFFF da steht. es gibt dazu die vars task_offset, die den offset in der table merkt, task_current, die die aktuelle ID merkt, und task_name, die den namen merkt. die register werden auf dem stack gesichert (danke Roshl, für die Idee). geswitcht wird mit dem folgenden code als timerinterrupt 0x08 software oder 0x00 hardware:


_int0x08:
cli
pusha
push ds
push es

mov ax,0x50
mov ds,ax
mov cx,[task_current]
mov ah,0x07
int 0x67
mov si,[task_offset]
sub si,0x06
mov [fs:si],ss
add si,0x02
mov [fs:si],sp
add si,0x04
;müsste am ende des taskentrys sein
mov ax,[fs:si]
read_next_task:
mov [task_current],ax
cmp ax,0xFFFF
je near task_get_next
add si,0x02
mov al,[fs:si]
mov byte [task_name],al
mov al,[fs:si+1]
mov byte [task_name+1],al
mov al,[fs:si+2]
mov byte [task_name+2],al
mov al,[fs:si+3]
mov byte [task_name+3],al
mov al,[fs:si+4]
mov byte [task_name+4],al
mov al,[fs:si+5]
mov byte [task_name+5],al
mov al,[fs:si+6]
mov byte [task_name+6],al
mov al,[fs:si+7]
mov byte [task_name+7],al
mov al,[fs:si+8]
mov byte [task_name+8],al
mov al,[fs:si+9]
mov byte [task_name+9],al
mov al,[fs:si+10]
mov byte [task_name+10],al
mov al,[fs:si+11]
mov byte [task_name+11],al
add si,0x0C
mov ax,[fs:si]
mov ss,ax
add si,0x02
mov ax,[fs:si]
mov sp,ax
add si,0x04
mov [task_offset],si

mov cx,[task_current]
mov ah,0x06
int 0x67

pop es
pop ds
popa

task_ende:
push ax
mov al,0x20       ;ende des ints abschicken
out 0x20,al
pop ax
sti
iret

task_get_next:
mov si,0x0000
mov [task_offset],si
mov ax,[fs:si]
jmp read_next_task        


problem: er geht nicht. ich weiß nicht, warum, aber er geht nicht. jedoch bleibt der code nicht einfach stecken, sondern geht schon, aber er kommt irgendwie nichtmehr richtig an, sodass der kernel nichtmehr ausgeführt wird. bochs zeigt allerdings keinen fehler an. hat jemand eine idee, wo der fehler sein könnte?

mfg

joachim_neu
57
Lowlevel-Coding / PM-Jump
« am: 02. December 2004, 18:24 »
hallo,
ich hoffe mir kann jemand helfen! mit dem befehl hier will ich in den PM springen, nachdem ich ihn an gemacht habe:
jmp dword 0x08:ser0x08_1
mein kernel ist an 0x50 und dieser code steht im kernel, und der deskriptor ist der:
dw 0FFFFh               ; maximum limit 0FFFFFh (1 meg or 4 gig)
dw 0                    ; linear base address
db 0
db 9Ah                  ; present,ring 0,code,non-conforming,readable
db 0CFh                 ; page-granular (4 gig limit), 32-bit
db 0    

ich hoffe, mir kann jemand helfen! es entsteht immer ein reboot unter bocsh...

mfg

JN!
58
Lowlevel-Coding / Mappen und dismappen
« am: 01. December 2004, 17:22 »
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:

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:

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!
59
Lowlevel-Coding / Speicherbestückung überprüfen
« am: 30. November 2004, 17:49 »
also, dieser code soll den speicher außerhalb des 1MB-Rahmens des RM messen:

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  :lol: )

bei BOCHS kommt immer: RIP > CS.limit

kennt sich da jemand aus? danke!
60
Lowlevel-Coding / EMS und Int 0x67
« am: 28. November 2004, 10:37 »
hallo,

Kennt sich hier jemand mit EMS aus? ich habe eine menge tuts und zeug gelesen, ich kapier das aber net.
Und weiß jemand, ob Int 0x67 von DOS ist? Das muss man ja benutzen, und das geht bei BOCHS und in real nicht.

danke!
Seiten: 1 2 [3] 4 5

Einloggen