bootsektor schreiben

[Go2EITS]

Zitat:

The memory problem
------------------
There is a memory problem.
As I've written bootstraps are always loaded to address
07C00. We don't know what segment and offset the BIOS has
put us in. The segment can be anything between 0000 and
07C0. This is a problem when we want to use variables.
The solution is simple. Begin your bootstrap by jumping
to your bootstrap, but jump to a known segment.

Here is an example:

; JUMP.ASM
; Make a jump and then hang

; Tell the compiler that this is offset 0.
; It isn't offset 0, but it will be after the jump.
[ORG 0]

jmp 07C0h:start ; Goto segment 07C0

start:
; Update the segment registers
mov ax, cs
mov ds, ax
mov es, ax

hang: ; Hang!
jmp hang

times 510-($-$$) db 0
dw 0AA55h

If you compile and test this bootstrap, there will be no
visible difference to the minimal bootstrap presented
earlier. The computer will just hang.

"We don't know what segment and offset the BIOS has put us in."
Heißt: Wir wissen nicht welches Segment bzw. Offset uns das Bios zuweist. Daher der Sprung.

Im übrigen würde ich mal das Tutorial von vorne beginnen, so wie es dasteht. Und Du weißt auch,
dass der Computer nach der Ausführung 'hängt': "The computer will just hang."

Ich schlage vor, Du benutzt mal Leo.org für die Englischkenntnisse und schaust, ob Du die Beispiele von vorne schaffst.

[Roter Kasten] Na dann ist ja gut! Waren meine Experimente mit Assembler vor 10 Jahren doch nicht umsonst. :wink:
Beste Grüße Go2EITS

[sancho1980]

also ich versteh immer noch nicht so ganz, was hier genau abgeht:

wie gesagt, die "hello cyberspace" nachricht bekomm ich jetzt..aber es schein als würde der das in einer endlosschleife auf den bildschirm schreiben..eigentlich sollte er ja sich aufhängen, wenn er am ende des strings angekommen ist...

ich hab jetz mal das programm etwas umgeändert und ein loop unrolling gemacht..um zu sehen was hier genau vorgeht..aber es tun sich mir immer neue rätsel auf..die abänderung ist folgendermaßen:

Zitat:

; start hellocyberspace.asm
; 2.ASM
; Print "Hello Cyberspace!" on the screen and hang

; Tell the compiler that this is offset 0.
; It isn't offset 0, but it will be after the jump.
[ORG 0]

jmp 07C0h:start ; Goto segment 07C0

; Declare the string that will be printed
msg db 'Hello Cyberspace!'


start:
; Update the segment registers
mov ax, cs
mov ds, ax
mov es, ax


mov si, msg ; Print msg


lodsb ; AL=memory contents at DS:SI

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

hang:
jmp hang

times 510-($-$$) db 0
dw 0AA55h
; end hellocyberspace.asm

wenn ich das vom stick boote, bekomm ich auf dem bildschirm (!!) folgendes:

LLLLLLLLLLLLLLLL

also 16 mal großes L...und das obwohl in 'Hello Cyberspace!' kein einziges großes L vorkommt!
was genau macht eigentlich int 10h? gibt es irgendwo eine liste aller interrupt handlers, in der steht, was da genau ausgeführt wird? vor dem interrupt-aufruf steht ja noch:

Zitat:

mov ah, 0Eh ; Print AL
mov bx, 7
int 10h

mir ist schleierhaft, was 0E in ah soll und wozu 7 in bx geladen wird...bitte erklärt mir das mal

und was hat es mit den folgenden drei mov-instructions auf sich:

Zitat:

; Update the segment registers
mov ax, cs
mov ds, ax
mov es, ax

wär echt nett wenn sich einer mal die zeit nimmt!

danke,

martin

[sancho1980]

Zitat:

Zitat von Go2EITS

Ich schlage vor, Du benutzt mal Leo.org für die Englischkenntnisse und schaust, ob Du die Beispiele von vorne schaffst.

ich versteh das mit dem offset und segment tatsächlich nicht; aber glaub mir mal: an meinen englisch-kenntnissen liegt das nicht sonst hätt ich meinen beruf als dolmetscher verfehlt :-)..evtl mangelnde hardware-kenntnisse?

edit1: und ja, ich hab das tutorial ganz durchgelesen aber da wird das mit dem segment und dem offset einfach nicht erklärt..finds irgendwie doof wenn da in einem tutorial beispielcode drin ist, der (jedenfalls GENAU so wie er da steht) gar nicht funktioniert :-(

edit2: hab folgendes gefunden unter:

http://www.pcmag.com/encyclopedia_te...i=51062,00.asp

Zitat:

A PC running in 16-bit mode (Real Mode) uses a segmented address space. Memory is broken up into 64KB segments, and a segment register always points to the base of the segment that is currently being addressed. The PC's 32-bit mode is considered a flat address space, but it too uses segments. However, since one 32-bit segment addresses 4GB, one segment covers all of memory.

Ich hab doch 32 bit..also warum muss ich mir dann um sowas wie segmente gedanken machen?

[Go2EITS]

Delphi-Quellcode:

// Tell the compiler that this is offset 0. 
//; It isn't offset 0, but it will be after the jump. 
[ORG 0] 

jmp 07C0h:start ; Goto segment 07C0 
//Das ist die Message, die von Print durchlaufen wird, bis die 0 kommt. Wenn al=0 ist 
//wird hang angesprungen.
; Declare the string that will be printed 
msg db 'Hello Cyberspace!',0  

// Zuvor wurde das Segment und der Offset aus dem Bios geholt.
// Dann muss das Segmentregister wohl Updatet werden.
start: 
// Update the segment registers 
mov ax, cs 
mov ds, ax 
mov es, ax 

//Hier wird die Adresse von msg geladen. 
mov si, msg ; Print msg 
print: 
lodsb ; AL=memory contents at DS:SI //Der Zeiger steht auf dem H von Hello.

// Vergleiche al = 0, wenn ja, springe zu hang
cmp al, 0 ; If AL=0 then hang 
je hang 

// Dieser Abschnitt ist für das Printen eines Buchstaben der mgs auf dem Bildschirm bis eine Null kommt,
// mehr nicht.
mov ah, 0Eh ; Print AL  // Laden der Funktion: Print
mov bx, 7               // Wohl noch eine Unterfunktionsnummer für Print. 
int 10h                 // Funktion ausführen.

// Das ist der Schlüssel
jmp print ; Print next character 
//Schreibe nächsten Buschstaben
//Solange cmp al, 0 nicht 0 ist wird zum label Print gesprungen.
//Wenn aber die 0 gelesen wird, wird nach hang gesprungen, der Leerlaufroutine.Es ist kein üblicher Exit aus Deinem Programm.
times 510-($-$$) db 0 
dw 0AA55h

Dein
mov ah, 0Eh ; Print AL
mov bx, 7
int 10h
ist daher Fehl am Platze.

Und? Verstanden warum Du LLLLLLL bekommst? Übrigens dürfte dies von der Diskette gleich sein.

[Muetze1]

1. Der Bootsektor wird nicht im 32 Bit Modus ausgeführt, du befindest dich im 16 Bit Real Mode! Also vergiss das mit dem 32 Bit Modus mal schnell wieder.

2. Das Tutorial geht davon aus, dass man sich mit Assembler sowie Grundlagen auskennt. Dazu gehört genauso gut die Segment:Offset Speicherangaben im Realmode!

3. Das BIOS lädt den Bootsektor immer an die gleiche lineare Adresse, aber von BIOS zu BIOS sind die Angaben dafür unterschiedlich. Folgende Angaben stellen alle die gleiche Adresse dar:

07C0:0000
0700:0C00
0000:7C00

etc. Daher auch der Sprung, da der Quellcode nunmal so compiliert wurde dass von einem Offset von 0 ausgegangen wird, erfolgt der Sprung zu einem definierten Segment:Offsetpaar. Und dabei gleich so, dass die Offsetberechnungen mit einer Basis von 0000h im Code stimmen.

4. Wenn du nicht weisst, was der Quellcode macht, ist das schon sehr schlecht. Du musst schon wissen was die BIOS ISR Funktionen machen, sonst kommt man schlecht weiter. z.B. die BIOS Routine Ausgabe eines Zeichens die benutzt wird (INT 10h, Func 0Eh). Ansonsten findest du hier ein Index nach der Interrupt Nummer.

[Go2EITS]

@sancho1980
Ehrlich gesagt, man sollte ohne Assembler-Kenntisse nicht einen Bootsektor programmieren.
Das ist wie einem Schuhverkäufer eine Granate entschäfen lassen. (Blödes Beispiel, aber der Bootsektor ist brisant.)
Da gibt es haufenweise Tutorials, die Du über Goggle finden kannst. Und ich würde zum Einstieg Fasm nehmen.

Beste Grüße. Na, dann hoffen wir mal, das Du noch ins Internet kannst. :zwinker:
Go2EITS

[Nils_13]

Zitat:

Zitat von Go2EITS

@sancho1980
Ehrlich gesagt, man sollte ohne Assembler-Kenntisse nicht einen Bootsektor programmieren.
Das ist wie einem Schuhverkäufer eine Granate entschäfen lassen. (Blödes Beispiel, aber der Bootsektor ist brisant.)
Da gibt es haufenweise Tutorials, die Du über Goggle finden kannst. Und ich würde zum Einstieg Fasm nehmen.

Beste Grüße. Na, dann hoffen wir mal, das Du noch ins Internet kannst. :zwinker:
Go2EITS

FASM ist, da es eine kleine und zufriedendstellende "IDE" gibt, für den Einstieg gut. Später würde ich aber NASM nehmen, da es da mehr Tutorials gibt.
http://www.tutorials.de/forum/progra...ebssystem.html
http://www.mega-tokyo.com/osfaq2/index.php
Dann gab es da noch eine Seite mit massig Tutorials, weiß den Link aber nicht mehr und kann ihn auch nicht finden.

[himitsu]

Zu den 512 Bytes ... die Bootsektoren sind immer 512 Byte groß, denn darin steht ja unteranderem erst wie weiter auf die Platte zuzugreifen ist, also muß es da noch einheitlich sein, damit auch Ordnungsgemäß darauf zugegriffen werden kann ;)
(wie die restlichen Sectoren aussehn ist dabei unerheblich)

Aber wenn das einem nicht ausreicht, kann man sich weitere Sectoren reservieren und darin dann den restlichen Bootcode unterbringen.
Wie das gemacht wird ist unterschiedlich und hängt von der Partition (FAT, NTFS ...) ab - falls nötig, empfehle ich ein Studium der entsprechenden Definitionen für den gewünschten Partitionstyp.
Ich weise da einfach mal auf die "Hidden sectors" hin :zwinker:

[add]
Ach ja, da du ja mit 'nem HexEditor, oder wie das war "rumpfuschst", sollte auch noch der Hinweis auf die letzten 2 Bytes im Bootsector fallen, denn das sind Prüfbytes und wenn die nicht stimmen, dann macht das BIOS nichts.
Und die restlichen Daten für die Art/Aufteilung der Partition sollten auch beachtet werden, sonst gibt's zwar 'nen Bootsector, aber mit der Partition ist nichts mehr anzufannen.