Thema: Bootloader

[TeeJay]

Alloa.
Da ich selbst hin und wieder ein bisschen am OS-Coden bin, hab ich mir mal einen Bootloader geschrieben um mir das ausprobieren etwas komfortabler zu machen. Mir war es lästig jedes mal mit RawWrite auf eine Diskette schreiben zu müsen. Daher hab ich einen Bootloader geschrieben der eine binäre Datei aus dem Root-Verzeichnis einer FAT12 formatierten Diskette in den Speicher läd und dann ausführt.

Da hier leider noch keine Funktion vorhanden is um bequem Code zu posten, stelle ich diesen auf meiner HP zum DL bereit.

http://www.sub--zero.de/scripts/htmlgenerator.php?page=bootloader&directory=tutorials

Ganz am Ende ist der Link zur Zip mit dem Code.

[bscreator]

Hallo Leute,
ich bin gerade dabei, dem Benutzer das Eingeben von Zeichen zu erlauben.
Das Auswerten einzelner Zeichen ist einfach, ob Return-Taste oder andere Sonderzeichen (F1-F12,Pos1,Einfg,...) gedrückt wurden, funktioniert einwandfrei. Lediglich habe ich Probleme, eine ganze, vom Benutzer eingegebene Zeichenkette auszuwerten. Meine Idee war, ein Byte-Array anzulegen, das alle eingegebenen Zeichen speichert. Mit der Return-Taste wird der ganze Text zu einem String zusammengesetzt. Bis jetzt konnte mir jedoch keiner sagen, wie man ein Array in NASM erstellt, noch wie man auf das erstellte Array zugreift und die einzelnen Inhalte der Elemente auswertet. Langer Rede kurzer Sinn: Wie erstellt und greift man auf ein Byte-Array in NASM zu?
Habt vielen Dank Leute, Tschüss.

[TeeJay]

Variable resb 100

So erstellst du ein Array das 100 bytes lang ist.
Das erste Byte wird über das Offset "Variable" adressiert.
Alle weitere Bytes adressierst du mit einem Displacement.
Sprich Variable+1, Variable+2

Ich hatte mal eine Art Shell programmiert.
Da hab ich es so gemacht, das ich ein 100 Byte langes Array hatte.
Wenn eine taste gedrückt wird, wird das Zeichen in das Array geschrieben.
Wenn nun Return gedrückt wurde, so wird ein NULL-Byte hinter das letzte eingegebene Zeichen geschrieben.
So kannst du dann die Eingabezeile als String ansprechen.
Du musst natürlich überprüfen das nicht mehr als 99 Zeichen eingegeben werden, weil du ja noch Platz für das NULL-Byte brauchst.

Auch musst du berücksichtigen das man mit Backspace ein Zeichen löschen kann.

[bscreator]

Hallo TeeJay,
Ich habe Deinen Plan beherzigt und mal ein bischen rumgespielt. Mit den Arrays hab´ ich seltsamerweise nur unter NASM Schwierigkeiten. Die Meldung
"warning: uninitialised space declared in .text section: zeroing". Mein derzeitiger Bootcode:
[BITS 16]
ORG 0x7C00

start:
mov si,InfoScreen
call SetString
call GetAndSet

GetAndSet:
mov AH,0x10
int 0x16
cmp AL,0x0d   ;Vergleich, ob Enter-Taste gedrückt wurde...
je Return        ;Wenn gleich, springe zu Return
mov AH,0x0E   ;Taste Return nicht betätigt
mov BL,0x07
int 0x10
jmp GetAndSet

InfoScreen db 'TestOS, Version 1.0',13,10,0
Array resb 100

Return:
ret

times 512-($-$$)-2 db 0
dw 0AA55h

Das ist mein derzeitiger Tastaturcode. Die Abfragen für die Sondertasten hab´ ich mal weggelassen. Das Deklarieren der Strings, sprich InfoScreen, Booting,... funktioniert in diesem Teil des Codes wunderbar. Nur das Deklarieren des Arrays funktioniert in diesem Abschnitt des Codes nicht (obige Fehlermeldung).

Was mach ich falsch?
Danke, bscreator

[TeeJay]

Das ist nur eine Warnung und kein Fehler.
Das besagt nur das du ein Array erstellst, dessen Werte nicht initalisiert sind.
Das macht aber nix, da du das Array ja erst zur Laufzeit mit Buchstaben füllst und DANN erst benutzt.

Du kannst auch folgedendes machen:

Variable db "                       "

Sprich du erstellst einen String der mit lauter Leerzeichen gefüllt ist.
Damit hast du dann keine Fehlermeldung mehr. Jedoch ist es schwer zu erkennen wie groß dein Array ist.

Die Warnung kannst du also ignorieren. Ist nur ein Hinweis das du dich nicht fälschlicher weise darauf verlässt das den Array zu Beginn schon sinnvolle Daten enthält.

[Lizer]

Wie die Warnung besagt, hast du den Array nicht initialisiert, weshalb der Assembler in nullt, also die einzelnen Bytes mit 0 initialisiert. Probiers doch mal statt dessen mit:

Array: times 100 db 0x00

Sollte den gleichen Effekt haben.

[Lizer]

Ui, TeeJay war schneller...

[TeeJay]

Japp

Du könntest auch schreiben:
Variable db 0
times 100 db 0

So hättest du ein 101 Byte großes Array das am Offeset Variable beginnt.

Damit hättest du wohl auch keine Warnung mehr und du könntest also auch sehen wie groß das Array ist.

[mastermesh]

Ja, der Loader scheint nützlich zu sein. Zusammen mit MTools und Bochs das ultimative Werkzeug zum Testen von OSes

[bscreator]

Lizer, TeeJay und mastermash - habt Dank.

[neq]

Also ich hab mal grad auf die Site des Loaders geklickt und das überflogen... das sind ja mindestens unendlich seiten TEXT !!!

ich weiss das der loader fat12 lädt
so aber die anderen Features kenn ich leider nicht...

ist das nur ein standart loader oder kann er auch protected mode und so

vielleicht kannst du ja ein bisl mehr dazu schreiben, ob es sich für mich lohnt den endloslangen text .. oder den source durchzuarbeiten

würde mich freuen

[bscreator]

Hi Leute, ich bins nochmal,
Jetzt versuch´ ich gerade, auf das Array zuzugreifen. Meine erste Idee
war die Syntax von C, in NASM: mov Array[9],9 (Sollte in das neunte Element des Arrays "Array" den Wert 9 speichern. Allerdings bin ich mit der Idee ganz schön auf die Nase geflogen. Ich hab´ zig klammern gesetzt, mit der Hoffnung im Hintergrund, durch Zufall auf die richtige Lösung zu kommen. Als ich jetzt mal deine Shell betrachtet hab´, hab´ ich ganz aufgegeben. Könnt ihr mir erklären, welche Register ich wie verwenden muss, um z.B. in ein Byte-Array mit 100 Elementen, in das 4. Element den Wert 9 zu schreiben? Und wie man dann auch wieder auf diesen Wert zugreift?

Dafür wäre ich euch wirklich sehr dankbar.
Tschüss

[TeeJay]

Zum Bootloader.


Dieser enthält nur die Minimalfunktionen um:
- Die FAT-Tabelle in den Speicher zu laden.
- Einträge aus der FAT-Tabelle zu lesen
- Das Root-Directory nach einer Datei zu durchsuchen
- Die Datei komplett in den Speicher zu lesen
- Die Datei auszuführen (Sprich an die Speicherstelle zu springen an welche die Datei geladen wurde).

Da ich mich auf die 512 Bytes begrenzt habe, blieb kein Platz mehr um in den PMode zu schalten.
Ich halte es auch nicht für Sinnvoll, da jeder ja seine eigen GDT für sein OS einrichten möchte/sollte. Und daher wäre es wohl blöd das im Bootloader vorwegzunehmen.


Sobald ich aber damit fertig bin, werde ich Code und Zusatztools mit denen man "bequem" in den PMode schalten kann im Resource-Center posten.

[TeeJay]

@bscreator

Das mit den Arrays kannst du so machen:

So erstellst du ein 100 byte langes Array dessen Startoffset "Test" ist:
Variable  db 0
times 99 db 0

Wenn du nun auf das Array zugreifen willst, dann machst du das wie folgt:

So schreibst du in das erste Element eine 9:
mov       [Variable  ],  BYTE 9

So schreibst du in das 6te Element eine 10:
mov       [Variable+5], BYTE 10

geschnallt?

[bscreator]

Funktioniert einwandfrei - vielen Dank, TeeJay

[neq]

ja wäre cool wenn du so ne zusatzfunktion machen würdest.

[bscreator]

Hi Leute,
Bevor ich das Array in mein Betriebssystem einbette, hab ich zuerst einmal ein bischen geübt. Um ein Array zu testen hab´ ich mal ein kleines Programm geschrieben:

[BITS 16]

jmp start

ORG 0x0

start:

Eingabe db 0
times 255 db 0 ;reserviert ein Array mit 255 Elementen, jedes mit 0 initialisiert
Counter db 0    ;Array-Zähler
Msg db 'Array Ende erreicht',13,10,0

call GetAndSet

GetAndSet:
mov AH,0x10   ;Videomodus setzen
int 0x16      ;Interrupt
cmp AL,0x0d   ;Vergleich, ob Enter-Taste gedrückt wurde
je Return        
xchg [Counter],eax ;Speichere ASCII-Wert von Taste in Counter
mov [Eingabe+eax], byte AL  ;Array aktualisieren
inc eax         ;Array-Zähler erhöhen
cmp eax,10   ;11 Einträge? (0 bis 10 = 11 Elemente)
je ArrayEnde ;Wenn eax Wert 10, dann Meldung ausgeben
xchg [Counter],eax ;Array-Zähler nach Counter
je Return    
mov AH,0x0E   ;Taste ist nicht Enter-Taste...
mov BL,0x07
int 0x10
jmp GetAndSet

SetString:
lodsb              ;Byte laden
or al,al
jz Return
mov ah,0x0E        ;Funktion 0x0E
mov bx,0x0007      ;Attribut-Byte (wird nicht ben”tigt)
int 0x10           ;schreiben
jmp SetString      ;Nächstes Byte

ArrayEnde:
mov si,Msg  
call SetString ;Meldung ausgeben
call Return

Return:
ret

Ich weiss, das Programm ist unterste Schublade, aber zum Testen des
Arrays reichts. Da ich nicht gerade viel Ahnung davon hab´, wie man Zahlen in Variablen speichert, hab ich es, mehr oder weniger, mit dem eax-Register und dem xchg-Befehl versucht. Wenn 10 Einträge gemacht worden sind (255 Zeichen einzugeben, um das Array zu testen war mir zuviel) sollte eigentlich die Meldung ausgegeben werden "Array Ende erreicht". Das Programm wird allerdings nur normal beendet. Wo liegt der Fehler ?

[TeeJay]

Zahlen in Variablen speichern:

mov [Variable], BYTE 10
anstatt BYTE kannst du auch WORD oder DWORD nehmen.
Das kommt halt darauf an wie groß deine Variable ist.

mov [Variable], al
geht auch. Hier brauchst du nicht extra angeben ob es sich um ein BYTE/WORD oder DWORD handelt, da es aus der Angabe des Registers ersichtlich ist.

Du arbeitest ja wie oben angegeben im 16-BIT Mode.
Daher solltest du auch möglichst nur 16-BIT Register (AX,BX, CX usw) verwenden.
Du benutzt häufig eax. Das ist zwar möglich, jedoch ist das dann teilweise 32-Bit. Mal abgesehen das du eine größe von 32-BIT an Zahl garnicht benötigst, da weder dein Array noch die Werte darin größer als 65535 sind.

xchg [Counter], eax
das sollte zu chaos führen, weil du hier einen 32-Bit Wert vom Register in eine BYTE Variable speichern willst (Counter db 0).

mov [Eingabe+eax], byte al
Du machst hier einen gedankenfehler. Du benutzt eax um ein Feld im Array anzugeben und gleichzeitig willst du mit einem Teil von eax, nämlich al einen Wert in das Array schreiben. Das kann eigentlich nur zu blödsinn führen

Daher bricht auch deine Schleife nie ab. Weil du in AL immer eine Taste einlädst. Und da wird eher per Zufall die Zahl 10 in eax stehen.
Du solltest also für das ansprechen der einzelnen Felder im Array lieber bx benutzen.

PS: Nimms nicht als Beleidigung, aber du solltest dich vielleicht in Sachen Assembler noch etwas schlau machen bevor es ans OS-Coding gibt.
Dein Code zeigt das du noch starke schwächen hast. Ich würde dir empfehlen ein Buch zu kaufen. Ich selbst habe mir mal das Buch "Programmiersprache Assembler - Eine strukturierte Einführung" von "Reiner Becker" gekauft.
Das ist zwar mehr ein Taschenbuch (also nicht sehr dick) und in erster Linie auf DOS ausgeichtet. Jedoch fand ich es für den Einstieg ganz gut, weil dort auch grundlegende Sachen über Assembler zu lesen waren. Sprich wie man mit SI und DI Strings bearbeitet usw.

Ansonsten könnte ich dir anbieten ein eBook zu schicken. Das ist zwar in Englisch und auch auf DOS ausgelegt, jedoch umfasst es 1000 Seiten und da steht wirklich alles drin.

[bscreator]

Bücher hab´ ich schon genug. Das von Dir angesprochene Buch hab´ ich auch, allerdings find ich es halt blöd, dass diese ganzen Programme in den Büchern die MASM oder TASM-Syntax verwenden. Diese beiden Assembler brauchen WINDOWS oder DOS als Betriebssystem, wodurch meine erstellten Programme plattformabhängig, sprich WINDOWS oder DOS, werden. Weil die Syntax der beiden jedoch kaum der von NASM ähnelt, zumindest was ich bisher verglichen habe, kann ich die Bücher für NASM-Programmieren wohl fast vergessen. Zugegeben, die Bücher beinhalten auch eine Menge Wissen, was Rechnerarchitektur beinhaltet. Diese Kapitel hab´ ich allerdings nur überflogen - sollte wohl mal genauer nachsehen. Wenn ich Bücher über den NASM-Assembler kennen würde, hätt ich die längst gekauft. Daher denke ich, da sowieso die meisten Betriebssysteme mit dem NASM-Assembler geschrieben sind (habe ich zumindest gehört), dass ich gleich NASM verwenden sollte.
Da Du, dem Buch zufolge, mit MASM angefangen hast, und soviel Wissen über NASM hast, sollte ich das vielleicht auch machen, oder?
PS: Wäre nett, wenn Du mir so ein EBook schicken würdest.
Danke nochmal und machs gut!

[bscreator]

Wenn Du mit MASM angefangen hast (Die Codes des Buches sind, soviel ich gehört habe, mit diesem Assembler geschrieben), sollte ich das vielleicht auch tun.
Ich hab´ nen 32-Bit-Macro Assembler (MASM) gefunden. Was ist der Unterschied zwischen nem "normalen" Assembler und einem Macro-Assembler?
Tschüss.

PS: MASM32 Version 8 [32Bit Macro Assembler] zum Download (2,98 MB) bei:
     http://www.codingcrew.de/masm32/index.php