Thema: Ausführen und Speicher...

[joachim_neu]

hallo,

wie schaffe ich es einen anderen Sector auszuführen? Ich bekomm das einfach net hin... Man muss doch den IP verändern, oder?
Ich hab einfach mal euren Code genommen:


;Lade unseren Kernel
call execute  

;Springt zum Kernel
mov ax, 0x2000 ; Die Adresse des Programms
mov es, ax     ; Segmentregister updaten
mov ds, ax
push ax
mov ax, 0
push ax
retf

; Lade den Kernel vom Bootlaufwerk
execute:

; Diskdrive reset (Interrupt 13h, 0)
push ds            ; Sichere DS
mov ax, 0          ; Die gewünschte Funktion (reset)
mov dl, 0         ; Dieses Laufwerk ist gewünscht
int 13h            ; Den Interrupt ausführen
pop ds             ; DS wiederherstellen
jc execute            ; Geht nicht? -> Noch mal!

execute1:
mov ax,0x2000      ; ES:BX = 20000
mov es,ax
mov bx, 0

; Sektoren lesen (Interrupt 13h, 2)
mov ah, 2       ; Funktion 2 (Lesen)
mov al, 1       ; Lese 1 Sektor
mov cx, 2       ; Cylinder=0, Sector=2
mov dx, 0       ; Head=0, Laufwerk=0
int 13h         ; ES:BX =  Daten vom Laufwerk
jc execute1        ; Fehler? Noch mal!    


Was geht daran nicht? Wo würde dieser Sector hingespeichert? Ist der Arbeitsspeicher sowas wie ein Quadrat, also das Programm dann an Stelle 2000x2000? Die Shell liegt bei 1000x1000, stimmts?

Bitte helft mir

[Lizer]

Boah, der Arbeitsspeicher ist mit Sicherheit kein Quadrat. Es nur einfach so, dass du mit einem Word (2 Bytes) max. Speicherstelle 65535, was grad mal ~64K wären. Nicht genaug? Genau! Daher nimmt man noch es dazu, und schon hat man 'n Double (4 Bytes), um Speicher zu addressieren: 0xFFFFFFFF -> 4G Speicher addressierbar. So, jetzt trink ich Kaffee.

[joachim_neu]

und was ist jetzt mit meinem code? ist der richtig?

[TeeJay]

ANsich könnte er gehen. Aber am Ende (nach jc execute1) musst du noch ein "ret" setzen. Sonst springt er nicht wieder nach oben um deinen Kernel zu starten.

Mit den Segmente ist das wie folgt. Du hast eine Segmentadresse und eine Offsetadresse. Die Segmentadresse ist jene VOR dem Doppelpunkt und die Offsetadresse isz jene NACH dem Doppeltpunkt.

Nehmen wir mal an du hast die Adresse 0x1000:0x50.
Das heisst du hast Segmentadresse 0x1000 und Offsettadresse 0x50. Wenn du daraus jetzt eine Lineare Adresse errechnen willst, dann machst du das wie folgt.
Du multiplizierst die Segmentadresse mit 16. Das hat zur Folge das dort einfach eine Null nachgeschoben wird. Also erhälst du 0x10000.
Und jetzt addierst du noch die Offsetadresse dazu. Ergebnis : 0x10050

[joachim_neu]

also müsste das funktionieren.

;Lade unseren Kernel
call execute

;Springt zum Kernel
mov ax, 0x2000 ; Die Adresse des Programms
mov es, ax ; Segmentregister updaten
mov ds, ax
push ax
mov ax, 0
push ax
retf

; Lade den Kernel vom Bootlaufwerk
execute:

; Diskdrive reset (Interrupt 13h, 0)
push ds ; Sichere DS
mov ax, 0 ; Die gewünschte Funktion (reset)
mov dl, 0 ; Dieses Laufwerk ist gewünscht
int 13h ; Den Interrupt ausführen
pop ds ; DS wiederherstellen
jc execute ; Geht nicht? -> Noch mal!

execute1:
mov ax,0x2000 ; ES:BX = 20000
mov es,ax
mov bx, 0

; Sektoren lesen (Interrupt 13h, 2)
mov ah, 2 ; Funktion 2 (Lesen)
mov al, 1 ; Lese 1 Sektor
mov cx, 2 ; Cylinder=0, Sector=2
mov dx, 0 ; Head=0, Laufwerk=0
int 13h ; ES:BX = Daten vom Laufwerk
jc execute1 ; Fehler? Noch mal!
ret

[TeeJay]

probier es doch einfach aus

So auf Anhieb sehe ich keinen Fehler.

[Fawkes]

Wenn du damit dein OS starten willst, musst du natürlich auch noch dem Kernel bescheid sagen (d.h. in der Kernel.asm noch die 2000 eintragen) also die Segmentregister updaten, oder nicht???
Ich hab meine Position nämlich auch geändert, auf 500, und es funktioniert.

[TeeJay]

Jo das musst du machen. Du musst die Segentregister setzen, damit diese auf das Segment zeigen an welches du deinen Kernel lädst.

Das kannst du schon im Bootloader machen, bevor du zu deinem Kernel springst, oder ganz am Anfang im Kernel, was ich empfehlen würde.

Tip: Ladet euren Kernel im Real-Mode immer direkt an ein Segment und lasst das Offset auf 0.

Wenn ihr das nicht macht, müßt ihr nämlich noch beim compilen des Kernels angeben mit "org" an welchem Offset er beginnt.

[joachim_neu]

nein, ich will nicht meinen Kernel laden, sondern ein anderes Programm, eben einen X-beliebigen Sektor...

[TeeJay]

Jo da kannst du genauso wie beim Kernel verfahren.

Du lädst das Programm einfach in ein Segment und springst mit einem Call dahin.

Dann wird das Programm ausgeführt bis es in der "main" Funktion mit ret wieder zurückspringt.

[joachim_neu]

hallo, hab meine routinen verändert und einen beispielsector zum laden geschrieben:


;************out.asm*********************
;Datei, bzw. Sector zum Laden

mov ax, 0x2200 ; Segmentregister updaten
mov ds, ax
xor ax,ax
mov es, ax
mov si, will
call putstr
;!!!!!!!!!FUNKTIONEN!!!!!!!!!
;Stringausgabe
putstr:
lodsb
or al,al
jz short putstrd ; 0-Byte? -> Ende!
mov ah,0x0E      ; Funktion 0x0E
mov bx,0x0007    ; Atrribut-Byte
int 0x10         ; schreiben
jmp putstr       ; nächstes Byte
putstrd:
retn
willkommen db "willkommen"
times 512-($-$$) db 0   ; Dateilänge: 512 Bytes              


;*************teil von kernel.asm******************
;lade routine

;fürt sectoren aus...
; Lade den Programm vom Bootlaufwerk
; Diskdrive reset (Interrupt 13h, 0)
push ds ; Sichere DS
mov ax, 0 ; Die gewünschte Funktion (reset)
mov dl, 0 ; Dieses Laufwerk ist gewünscht
int 13h ; Den Interrupt ausführen
pop ds ; DS wiederherstellen
jc execute ; Geht nicht? nochmal!
; Sektoren lesen (Interrupt 13h, 2)
mov ax,0x2200 ; ES:BX = 22000
mov es,ax
mov bx,0
;startsector
mov si,exe_start
call putstr
call getkey
dec ah
mov cl,ah ; Sector zum starten
;anzahl der zu lesenden sectoren
mov si,exe_number
call putstr
call getkey
dec ah
mov al,ah ; Lese Sektorn zum lesen ein
mov dl, 0 ;Laufwerk 0
mov dh, [head]
mov ch, [track]
mov ah, 2 ; Funktion 2 (Lesen)
int 13h ; ES:BX = Daten vom Laufwerk
mov ax, 0x2200 ; Die Adresse des Programms
mov es, ax ; Segmentregister updaten
mov ds, ax
push ax
mov ax, 0
push ax
retf

aber irgendwie geht es nicht, manchmal passiert garnichts, und wann anderst komische zeichen und irgenwo in den zeichen dann diese
willkommen-Zeichenkette...