Nachrichten

21

Offtopic / Re: Betriebssystem für FileServer

« am: 30. July 2008, 06:03 »

kann man so sagen, ja. du solltest noch an sicherheit denken. ganz besonders dann, wenn der rechner auch an ein netzwek angeschlossen ist, welches anbindung ans internet hat... also firewall (iptables) und antivirus installieren...

das wars dann eigendlich

22

Offtopic / Re: Betriebssystem für FileServer

« am: 29. July 2008, 10:55 »

also, ich konfiguriere alles auf dem system auf der konsole. wenns sein muss, wird noch mal, per ssh, nachgelegt...

ich glaube, du solltest dir webmin installieren. ist zwar auch ein, eigendlich, unnötiger dienst. aber, das erleichtert dir die arbeit, zumal du nicht konsolen- fit bist... ich kenne auch nur die wichtigsten befehle, aber das reicht. für alles andere dienen nano und die konfigurationsdateien....

ach ja, raid wird per konfigurationsdateien und treibern eingerichtet... aber, dazu kann ich dir nich viel schreiben. hab noch kein raid eingerichtet und auch nie genutzt. ich benutze ftp basierte backup maßnahmen...

23

Offtopic / Re: Betriebssystem für FileServer

« am: 29. July 2008, 09:35 »

von haus aus hat windows so seine sorgen mit raid

Damit scheidet Microsoft für mich ganz aus.

für den heimanwender sicher oversized.

Das kannst du aber laut sagen. Trotzdem danke für den Link.

Dann bleibt blos no Linux als Alternative übrig. Ich denk aber mal, dass die openSuSE Version mit ca. 20 GB auch ein bisl zu groß ist. Klar, da geht mit Sicherheit ein großer Teil für die grafische Oberfläche und anderes drauf, aber Linux von einer Konsole aus zu administrieren, zumal ich fast keine Befehle für Linux kenne, ist dann wohl sinnlos, oder ? 

Welche anderen Linux-Derivate mit grafischer Oberfläche, kleinerem Speichervolumen und RAID-Unterstütztung würdet ihr empfehlen ?

evtl. Ubuntu oder Knoppix ?

ubuntu/ knoppix frisst auch viel speicherplatz... da wäre ein debian 4.x angebrachter... frisst, minimal ca 300mb. mit samba wohl so 20mb mehr...
[edit]
mit ner (einfachen) gui so ca 500mb
[/edit]

ach ja, hier mal nen link zu galileocomputing openbook projekt. da sind auch gute ebooks zu linux bei: http://www.galileocomputing.de/katalog/openbook

du kannst natürlich auch das selflinux ebook nehmen: http://www.selflinux.org/

24

Offtopic / Re: Betriebssystem für FileServer

« am: 28. July 2008, 20:27 »

also,

freenas sollte auch zugriffsberechtigungen machen.

von haus aus hat windows so seine sorgen mit raid... das seh ich bei mein cousin. aber, evtl hat ja jemand mehr glück damit gehabt...

amsonsten soltest du den wikipedia lesen. siehe beitrag von termite

25

Offtopic / Re: Betriebssystem für FileServer

« am: 28. July 2008, 18:10 »

Wie im Betreff beschrieben, bin ich derzeit dabei, Brainstorming für den Aufbau eines FileServers zu machen. Die Hardware ist dabei nicht das Problem, sondern eher der Einsatz der passenden Software.

Anforderungen an das Betriebssystem:
1. Das BS muss fähig sein, einen RAID-1-Verbund (Spiegelung einer Platte auf die andere) zur Datensicherheit zu realisieren.
2. Datenzugriff über RJ45, WLAN nicht benötigt.

Derzeit ist FreeNAS mein Favorit, will aber eine Alternative haben, falls im Worst Case exotische Hardware dabei ist.

ich glaube, das ist sogar die beste wahl...

Meine Alternative Nr. 1 ist Linux. Hab gelesen, dass man für einen Einsatz als FileServer dazu Samba benötigt. Kann ich mit Samba RAID-1 realisieren ?
Bin kein Linux-Profi. Benötigt man gute Kenntnisse, um Samba einrichten zu können ?

Wisst ihr eventuell als zweite Alternative passende Windows-Versionen ?
(Bitte nicht Windows Home Server, glaub das läuft nur auf speziellen Home-Server-PCs von Fujitsu usw. )

die raid geschichte läuft unter linux. samba stellt, afaik, nur die möglichkeit zur verfügung - unter windows drauf zugreifen zu können. ähnlich den freigaben unter windows.

du könntest noch ein linux drauf laufen lassen, was du um alles unnötige kastrierst und nen ftp server drauf setzt. aber, ich glaube das hattest du schon im sinn...

26

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 3] makros wiederholt nutzen

« am: 25. July 2008, 19:15 »

mov ax, 0x1000              ; Den Kernel an Adresse 1000h Positionieren
mov ds, ax                      ; Die Segement Register aktualisieren
mov es, ax

Du "positionierst" damit nicht den Kernel und schon garnicht an Adresse 0x1000. Schau dir die Adressierung über Segment:Offset im Realmode nochmal genauer an. In dem Fall wäre es wenn überhaupt Adresse 0x10000, wobei du da nichts "positionierst", sondern einfach die Segmentregister setzt, damit du bei Speicherzugriffen auf die richtige Stelle zugreifst.

edit: Vielleicht sag ich da doch noch dazu : Sobald du mit einem mov auf den Speicher zugreifst, wird implizit (zumindest meisten, die Ausnahmen führen hier allerdings zu weit, aber es wird implizit immer eines der Segmentregister hergenommen) ds als Segmentregister hergenommen. Also Beispiel:

Code: [Auswählen]

mov ax, [somestuff]
Dann wird das Word an der Adress ds:somestuff (physikalisch dann ds * 16 + somestuff) ausgelesen. Deswegen ist es so wichtig die Segmentregister richtig zu setzen, sondern schreibst/liest/führst aus irgendeinen Mist im Speicher.

also, wenn ich dich grad richtig verstehe, dann darf ich die zusäte ( ,13,10, 0 ) nicht verwenden...?

Das ist natürlich Blödsinn, du brauchst das 13 und 10 um in eine neue Zeile zu kommen und das 0 um das Ende der Zeichenkette zu erkennen. Ich hab das nur aus Unachtsamkeit vergessen.

macht nix. meine strings werden nun korrekt ausgegeben. siehe kopie des kernel quelltextes über dir. die angabe der tabellen (13,10,0) habe ich den rohstring angehängt, was auch ohne problem funktioniert.

alles andere..: das muss ich noch korrigieren. das ganze ist eine, etwas, ältere kopie des quelltextes...

27

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 3] makros wiederholt nutzen

« am: 25. July 2008, 18:33 »

problem gelöst... mein kernel sieht nun so aus:

Code: [Auswählen]

; miniKernel Ver.s 0.1.0
;
; Aufgaben:
; * Kern des Betriebssystems
;   * Das heist:
;      + Stellt Grundlegende Funktionen und Routinen desBetriebssystems bereit
;      + Verwaltet Grundlegende Funktionen der Datenträger,
;         insbesondere das Lese,Schreiben und Ändern von Dateien und Daten
;      + Verwaltet den Speicher, Threats etc..
;
; Kernel- Typ:
; * Monolitsch
;   + Nur in der Start- bzw. Entwicklungsphase
;      Später wir der Kernel Modular Struckturiert sein....

mov ax, 0x1000 ; Den Kernel an Adresse 1000h Positionieren
mov ds, ax ; Die Segement Register aktualisieren
mov es, ax


; Um Software Interupts nutzen zu können, müssen Hardware Interupts/ Bios Funktionen "umgeleitet" werden.
; Dafür muss eine Interrupt Vector Table erzeugt werden...:

push ax ; Inhalt speichern
push es ; Inhalt speichern
xor ax, ax ; AX Register leeren
mov es, ax ; den Inhalt von AX in ES Speichern
cli ; Hardware Interrupts ausschalten
mov word [es:0x21*4], _int0x21 ; Pointer auf den Handler zeigen lassen
mov [es:0x21*4+2], cs ; Pointer auf cs zeigen lassen
sti ; Hardware Interrupts wieder einschalten
pop es
pop ax

; Makros erleichtern die Arbeit. Unter Assembler erst recht.
;Also basteln wir uns ein Makro, welcher die Ausgabe von Textnachrichten erleichtert.
%macro TextAusgabe 1
mov al, 0x01
mov si, %1
int 0x21
%endmacro

start:
; Anschliesend verwenden wir unseren neuen Software Interrupt, um Benutzer- Nachrichten auszugeben
mov si, msg_start ; Wir holen uns die Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

mov si,msg_boot ; Wir holen uns eine weitere Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

; Ab hier erledigt nur noch unser Software Interupt die Textausgabe
; Und: Wir benutzen Macros, welche die Arbeit erheblich erleichtern
TextAusgabe msg_interruptsLoaded
TextAusgabe msg_reboot

call getkey ; Hier rufen wir nun eine Subroutine auf, die auf einem Tastendruck wartet...
jmp reboot ; Weiter gehts zu einer Subrouten, die den PC neustartet

;  Wir speichern die Nachrichten, in den nachfolgenden Variablen...:
msg_start db "Willkommen beim minOS Version 0.1.0",13,10,0
msg_boot db "Initialisiere...",13,10,0

; Texte, die unser Makro benutzt
msg_interruptsLoaded db "Interrupt 21 (mit Funktion 0x01) arbeitet",13,10,0
msg_reboot db "Druecke eine Taste, um den Computer neu zu starten...",13,10,0
; Das Makro TextAusgabe" enthält alle Anweisungen, um den Text korrekt an unser Interrupt 0x21 (mit Funktion 0x01)
; übergeben zu können

; Nachrichten, ohne Software Interrupts ausgeben...
; "Klassische" Methode, die die Bios Funktionen benutzt
putstr:
lodsb ; Beginne zu lesen
or al,al
jz short putstrd ; Muss noch etwas gelesen werden, oder ist alles gelesen worden...?
; Wenn alles gelesen wurde, dann ENDE!
mov ah,0x0E ; Ruft die Funktion 0x0E des BIOS auf
mov bx,0x0007 ; Nicht notwendig, aber dennoch... Setzt das Atribut
int 0x10 ; Schreiben des Textes auf den Bildschirm
jmp putstr ; Solange noch etwas zu lesen ist, wird diese Subroutine neu gestartet und weiter gelesen
putstrd:
retn ; Fertig mit dem lesen? wenn ja, dann geht es hier zurück zur Hauptroutine

; Die Routinen und Aufrufe zum Ausgeben von Textnachrichten wurden getauscht
; Der Software Interrupt 0x21 übernimmt nun diese Aufgabe.

_int0x21: ; Unser erster eigener Interupt
 _int0x21_ser0x01: ; Die Funktion unseres Interrupts (Text ausgeben)
 cmp al, 0x01 ; wurde die Funktion wirklich aufgerufen? Dies wird hier abgefragt
 jne _int0x21_end ; wenn nein, dann weiter zur nächsten Funktion

; Nun wird es Zeit, die Funktion zu nutzen
; Dieser Software Interupt, mit der Funktion 0x01, gibt Text auf dem Bildschirm aus
 _int0x21_ser0x01_start:
 lodsb ; Jeweils ein Byte laden
 or al, al ; Zeichenkette zuende?
 jz _int0x21_ser0x01_end ; wenn ja, dann Funktion beenden. Wenn nein, dann nachfolgend weiter machen
 mov ah, 0x0E ; Bios Teletype Funktion nutzen
 mov bh, 0x00 ; Auf Page 0 schreiben
 mov bl, 0x07 ; Text Atribute
 int 0x10 ; Bios Call (Text schreiben)
 jmp _int0x21_ser0x01_start
 _int0x21_ser0x01_end:
 jmp _int0x21_end
 
 _int0x21_end:
 iret ; Software Interrupt beenden

 
; Diese Funktion starte den Computer, nach einem Tastendruck, neu
getkey:
mov ah, 0 ; Prozessor Funktion 0, oder anders gesagt, Neustart, ausführen
; Dieser Aufruf bereitet den Prozessor hierfür vor
int 0x16 ; Dieser Befehl löd den Reboot Befehl aus
ret

reboot:
jmp 0xffff:0x0000 ; Alle Befehle entfernen, sowie dem Prozessor neustarten

; Das wars....
; Das ist unserer Mini- Kernel...

auch diesem code können zukünftige os dev´s nutzen

[edit]

stimmen meine, für mich gedachten, erklärungen in den kommentaren?

28

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 3] makros wiederholt nutzen

« am: 25. July 2008, 18:16 »

soo... ich habe den kernel, wie folgt, verändert:

Code: [Auswählen]

; miniKernel Ver.s 0.1.0
;
; Aufgaben:
; * Kern des Betriebssystems
;   * Das heist:
;      + Stellt Grundlegende Funktionen und Routinen desBetriebssystems bereit
;      + Verwaltet Grundlegende Funktionen der Datenträger,
;         insbesondere das Lese,Schreiben und Ändern von Dateien und Daten
;      + Verwaltet den Speicher, Threats etc..
;
; Kernel- Typ:
; * Monolitsch
;   + Nur in der Start- bzw. Entwicklungsphase
;      Später wir der Kernel Modular Struckturiert sein....

mov ax, 0x1000 ; Den Kernel an Adresse 1000h Positionieren
mov ds, ax ; Die Segement Register aktualisieren
mov es, ax


; Um Software Interupts nutzen zu können, müssen Hardware Interupts/ Bios Funktionen "umgeleitet" werden.
; Dafür muss eine Interrupt Vector Table erzeugt werden...:

push ax ; Inhalt speichern
push es ; Inhalt speichern
xor ax, ax ; AX Register leeren
mov es, ax ; den Inhalt von AX in ES Speichern
cli ; Hardware Interrupts ausschalten
mov word [es:0x21*4], _int0x21 ; Pointer auf den Handler zeigen lassen
mov [es:0x21*4+2], cs ; Pointer auf cs zeigen lassen
sti ; Hardware Interrupts wieder einschalten
pop es
pop ax

start:
; Anschliesend verwenden wir unseren neuen Software Interrupt, um Benutzer- Nachrichten auszugeben
mov si, msg_start ; Wir holen uns die Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

mov si,msg_boot ; Wir holen uns eine weitere Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

; Makros erleichtern die Arbeit. Unter Assembler erst recht.
;Also basteln wir uns ein Makro, welcher die Ausgabe von Textnachrichten erleichtert.
%macro TextAusgabe 1
mov al, 0x01
mov si, %1
int 0x21
%endmacro

call getkey ; Hier rufen wir nun eine Subroutine auf, die auf einem Tastendruck wartet...
jmp reboot ; Weiter gehts zu einer Subrouten, die den PC neustartet




;  Wir speichern die Nachrichten, in den nachfolgenden Variablen...:
msg_start db "Willkommen beim minOS Version 0.1.0",13,10,0
msg_boot db "Initialisiere...",13,10,0

; Ab hier erledigt nur noch unser Software Interupt die Textausgabe
; Und: Wir benutzen Macros, welche die Arbeit erheblich erleichtern
;
msg_interruptsLoaded db "Interrupt 21 (mit Funktion 0x01) arbeitet",13,10,0
msg_reboot db "Druecke eine Taste, um den Computer neu zu starten...",13,10,0
; Das Makro TextAusgabe" enthält alle Anweisungen, um den Text korrekt an unser Interrupt 0x21 (mit Funktion 0x01)
; übergeben zu können
TextAusgabe msg_interruptsLoaded
TextAusgabe msg_reboot

; Es wir Zeit, die Nachrichten auszugeben...:
putstr:
lodsb ; Beginne zu lesen
or al,al
jz short putstrd ; Muss noch etwas gelesen werden, oder ist alles gelesen worden...?
; Wenn alles gelesen wurde, dann ENDE!
mov ah,0x0E ; Ruft die Funktion 0x0E des BIOS auf
mov bx,0x0007 ; Nicht notwendig, aber dennoch... Setzt das Atribut
int 0x10 ; Schreiben des Textes auf den Bildschirm
jmp putstr ; Solange noch etwas zu lesen ist, wird diese Subroutine neu gestartet und weiter gelesen
putstrd:
retn ; Fertig mit dem lesen? wenn ja, dann geht es hier zurück zur Hauptroutine

; Die Routinen und Aufrufe zum Ausgeben von Textnachrichten wurden getauscht
; Der Software Interrupt 0x21 übernimmt nun diese Aufgabe.

_int0x21: ; Unser erster eigener Interupt
 _int0x21_ser0x01: ; Die Funktion unseres Interrupts (Text ausgeben)
 cmp al, 0x01 ; wurde die Funktion wirklich aufgerufen? Dies wird hier abgefragt
 jne _int0x21_end ; wenn nein, dann weiter zur nächsten Funktion

; Nun wird es Zeit, die Funktion zu nutzen
; Dieser Software Interupt, mit der Funktion 0x01, gibt Text auf dem Bildschirm aus
 _int0x21_ser0x01_start:
 lodsb ; Jeweils ein Byte laden
 or al, al ; Zeichenkette zuende?
 jz _int0x21_ser0x01_end ; wenn ja, dann Funktion beenden. Wenn nein, dann nachfolgend weiter machen
 mov ah, 0x0E ; Bios Teletype Funktion nutzen
 mov bh, 0x00 ; Auf Page 0 schreiben
 mov bl, 0x07 ; Text Atribute
 int 0x10 ; Bios Call (Text schreiben)
 jmp _int0x21_ser0x01_start
 _int0x21_ser0x01_end:
 jmp _int0x21_end
 
 _int0x21_end:
 iret ; Software Interrupt beenden

 
; Diese Funktion starte den Computer, nach einem Tastendruck, neu
getkey:
mov ah, 0 ; Prozessor Funktion 0, oder anders gesagt, Neustart, ausführen
; Dieser Aufruf bereitet den Prozessor hierfür vor
int 0x16 ; Dieser Befehl löd den Reboot Befehl aus
ret

reboot:
jmp 0xffff:0x0000 ; Alle Befehle entfernen, sowie dem Prozessor neustarten

; Das wars....
; Das ist unserer Mini- Kernel...

nasm kompiliert das ganze anstandslos. allerdings sehe ich die 2 textzeilen, als output, nicht mehr... schreibe ich in den falschen speicherbereich, oder wo liegt das problem...?

29

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 3] makros wiederholt nutzen

« am: 25. July 2008, 17:48 »

was kann ich machen, damit ich die makros, wiederholt, nutzen kann..?

Du kannst das Makro in der Form wiederholt benutzen. Du benutzt es momentan aber garnicht... Du definierst da einfach zwei Strings denen du den gleichen Namen (das TextAusgabe db blabla) gibts (warüber sich der Assembler beschwert) und das auch noch mitten im Codeteil. Also: Definier die zwei Strings im Dateinteil.
Das Makro rufst du dann über (Dazu musst du wahrscheinlich das Makro früher definieren, d.h. bevor du es benutzt)

Code: [Auswählen]

TextAusgabe meinString
auf (im Codeteil), falls meinString eben ein String ist.Also sowas in der Richtung im Datenteil:

Code: [Auswählen]

meinString db "I am a tool."

Ich hoffe ich konnte helfen.

also, wenn ich dich grad richtig verstehe, dann darf ich die zusäte ( ,13,10, 0 ) nicht verwenden...?

ich probiere das mal...

[edit] ok, das war nix...

[edit]
ich habs jetzt mal so notiert:

Code: [Auswählen]

; miniKernel Ver.s 0.1.0
;
; Aufgaben:
; * Kern des Betriebssystems
;   * Das heist:
;      + Stellt Grundlegende Funktionen und Routinen desBetriebssystems bereit
;      + Verwaltet Grundlegende Funktionen der Datenträger,
;         insbesondere das Lese,Schreiben und Ändern von Dateien und Daten
;      + Verwaltet den Speicher, Threats etc..
;
; Kernel- Typ:
; * Monolitsch
;   + Nur in der Start- bzw. Entwicklungsphase
;      Später wir der Kernel Modular Struckturiert sein....

mov ax, 0x1000 ; Den Kernel an Adresse 1000h Positionieren
mov ds, ax ; Die Segement Register aktualisieren
mov es, ax


; Um Software Interupts nutzen zu können, müssen Hardware Interupts/ Bios Funktionen "umgeleitet" werden.
; Dafür muss eine Interrupt Vector Table erzeugt werden...:

push ax ; Inhalt speichern
push es ; Inhalt speichern
xor ax, ax ; AX Register leeren
mov es, ax ; den Inhalt von AX in ES Speichern
cli ; Hardware Interrupts ausschalten
mov word [es:0x21*4], _int0x21 ; Pointer auf den Handler zeigen lassen
mov [es:0x21*4+2], cs ; Pointer auf cs zeigen lassen
sti ; Hardware Interrupts wieder einschalten
pop es
pop ax

start:
; Anschliesend verwenden wir unseren neuen Software Interrupt, um Benutzer- Nachrichten auszugeben
mov si, msg_start ; Wir holen uns die Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

mov si,msg_boot ; Wir holen uns eine weitere Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

; Ab hier erledigt nur noch unser Software Interupt die Textausgabe
; Und: Wir benutzen Macros, welche die Arbeit erheblich erleichtern
;
; Das Makro TextAusgabe" enthält alle Anweisungen, um den Text korrekt an unser Interrupt 0x21 (mit Funktion 0x01)
; übergeben zu können
TextAusgabe msg_interruptsLoad
textAusgabe msg_reboot

call getkey ; Hier rufen wir nun eine Subroutine auf, die auf einem Tastendruck wartet...
jmp reboot ; Weiter gehts zu einer Subrouten, die den PC neustartet

;  Wir speichern die Nachrichten, in den nachfolgenden Variablen...:
msg_start db "Willkommen beim minOS Version 0.1.0",13,10,0
msg_boot db "Initialisiere...",13,10,0
msg_interruptsLoaded db "Interrupt 21 (mit Funktion 0x01) arbeitet",13,10,0
msg_reboot db "Druecke eine Taste, um den Computer neu zu starten..."

; Es wir Zeit, die Nachrichten auszugeben...:
putstr:
lodsb ; Beginne zu lesen
or al,al
jz short putstrd ; Muss noch etwas gelesen werden, oder ist alles gelesen worden...?
; Wenn alles gelesen wurde, dann ENDE!
mov ah,0x0E ; Ruft die Funktion 0x0E des BIOS auf
mov bx,0x0007 ; Nicht notwendig, aber dennoch... Setzt das Atribut
int 0x10 ; Schreiben des Textes auf den Bildschirm
jmp putstr ; Solange noch etwas zu lesen ist, wird diese Subroutine neu gestartet und weiter gelesen
putstrd:
retn ; Fertig mit dem lesen? wenn ja, dann geht es hier zurück zur Hauptroutine

; Die Routinen und Aufrufe zum Ausgeben von Textnachrichten wurden getauscht
; Der Software Interrupt 0x21 übernimmt nun diese Aufgabe.

_int0x21: ; Unser erster eigener Interupt
 _int0x21_ser0x01: ; Die Funktion unseres Interrupts (Text ausgeben)
 cmp al, 0x01 ; wurde die Funktion wirklich aufgerufen? Dies wird hier abgefragt
 jne _int0x21_end ; wenn nein, dann weiter zur nächsten Funktion

; Nun wird es Zeit, die Funktion zu nutzen
; Dieser Software Interupt, mit der Funktion 0x01, gibt Text auf dem Bildschirm aus
 _int0x21_ser0x01_start:
 lodsb ; Jeweils ein Byte laden
 or al, al ; Zeichenkette zuende?
 jz _int0x21_ser0x01_end ; wenn ja, dann Funktion beenden. Wenn nein, dann nachfolgend weiter machen
 mov ah, 0x0E ; Bios Teletype Funktion nutzen
 mov bh, 0x00 ; Auf Page 0 schreiben
 mov bl, 0x07 ; Text Atribute
 int 0x10 ; Bios Call (Text schreiben)
 jmp _int0x21_ser0x01_start
 _int0x21_ser0x01_end:
 jmp _int0x21_end
 
 _int0x21_end:
 iret ; Software Interrupt beenden

; Makros erleichtern die Arbeit. Unter Assembler erst recht.
;Also basteln wir uns ein Makro, welcher die Ausgabe von Textnachrichten erleichtert.
%macro TextAusgabe 1
mov al, 0x01
mov si, %1
int 0x21
%endmacro
 
; Diese Funktion starte den Computer, nach einem Tastendruck, neu
getkey:
mov ah, 0 ; Prozessor Funktion 0, oder anders gesagt, Neustart, ausführen
; Dieser Aufruf bereitet den Prozessor hierfür vor
int 0x16 ; Dieser Befehl löd den Reboot Befehl aus
ret

reboot:
jmp 0xffff:0x0000 ; Alle Befehle entfernen, sowie dem Prozessor neustarten

; Das wars....
; Das ist unserer Mini- Kernel...

nasm meldet: kernel.asm: 48: error: instruction expected
ich denke, da fehlt noch ein befehl.... mal sehen, was ich da machen kann...

[edit] tipp fehler bei msg_interruptsLoad.. gefixt

30

Lowlevel-Coding / [lowlevel magazin - ausgabe 3] makros wiederholt nutzen

« am: 25. July 2008, 16:55 »

hallo,

ich habe folgendes problem:

ich möchte das makro, zur ausgabe von texten, aus der 3. ausgabe benutzen um mir das programmieren etwas zu erleichtern. allerdings meldet nasm dies hier:

Code: [Auswählen]

kernel.asm: 50: error: symbol 'TextAusgabe' redefinet

das stimt auch soweit. ich gebe 2 texte nacheinander aus. oder, besser gesagt, ich will diese nacheinander ausgeben.

hier mal mein kernel:

Code: [Auswählen]

; miniKernel Ver.s 0.1.0
;
; Aufgaben:
; * Kern des Betriebssystems
;   * Das heist:
;      + Stellt Grundlegende Funktionen und Routinen desBetriebssystems bereit
;      + Verwaltet Grundlegende Funktionen der Datenträger,
;         insbesondere das Lese,Schreiben und Ändern von Dateien und Daten
;      + Verwaltet den Speicher, Threats etc..
;
; Kernel- Typ:
; * Monolitsch
;   + Nur in der Start- bzw. Entwicklungsphase
;      Später wir der Kernel Modular Struckturiert sein....

mov ax, 0x1000 ; Den Kernel an Adresse 1000h Positionieren
mov ds, ax ; Die Segement Register aktualisieren
mov es, ax


; Um Software Interupts nutzen zu können, müssen Hardware Interupts/ Bios Funktionen "umgeleitet" werden.
; Dafür muss eine Interrupt Vector Table erzeugt werden...:

push ax ; Inhalt speichern
push es ; Inhalt speichern
xor ax, ax ; AX Register leeren
mov es, ax ; den Inhalt von AX in ES Speichern
cli ; Hardware Interrupts ausschalten
mov word [es:0x21*4], _int0x21 ; Pointer auf den Handler zeigen lassen
mov [es:0x21*4+2], cs ; Pointer auf cs zeigen lassen
sti ; Hardware Interrupts wieder einschalten
pop es
pop ax

start:
; Anschliesend verwenden wir unseren neuen Software Interrupt, um Benutzer- Nachrichten auszugeben
mov si, msg_start ; Wir holen uns die Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

mov si,msg_boot ; Wir holen uns eine weitere Adresse der Nachricht
call putstr ; Und leiten das ganze an die "Textausgabe" weiter

; Ab hier erledigt nur noch unser Software Interupt die Textausgabe
; Und: Wir benutzen Macros, welche die Arbeit erheblich erleichtern
;
; Das Makro TextAusgabe" enthält alle Anweisungen, um den Text korrekt an unser Interrupt 0x21 (mit Funktion 0x01)
; übergeben zu können
TextAusgabe db "Interrupt 21 (mit Funktion 0x01) arbeitet",13,10,0

TextAusgabe db "Druecke eine Taste, um den Computer neu zu starten...",10,0

call getkey ; Hier rufen wir nun eine Subroutine auf, die auf einem Tastendruck wartet...
jmp reboot ; Weiter gehts zu einer Subrouten, die den PC neustartet

;  Wir speichern die Nachrichten, in den nachfolgenden Variablen...:
msg_start db "Willkommen beim minOS Version 0.1.0",13,10,0
msg_boot db "Initialisiere...",13,10,0


; Es wir Zeit, die Nachrichten auszugeben...:
putstr:
lodsb ; Beginne zu lesen
or al,al
jz short putstrd ; Muss noch etwas gelesen werden, oder ist alles gelesen worden...?
; Wenn alles gelesen wurde, dann ENDE!
mov ah,0x0E ; Ruft die Funktion 0x0E des BIOS auf
mov bx,0x0007 ; Nicht notwendig, aber dennoch... Setzt das Atribut
int 0x10 ; Schreiben des Textes auf den Bildschirm
jmp putstr ; Solange noch etwas zu lesen ist, wird diese Subroutine neu gestartet und weiter gelesen
putstrd:
retn ; Fertig mit dem lesen? wenn ja, dann geht es hier zurück zur Hauptroutine

; Die Routinen und Aufrufe zum Ausgeben von Textnachrichten wurden getauscht
; Der Software Interrupt 0x21 übernimmt nun diese Aufgabe.

_int0x21: ; Unser erster eigener Interupt
 _int0x21_ser0x01: ; Die Funktion unseres Interrupts (Text ausgeben)
 cmp al, 0x01 ; wurde die Funktion wirklich aufgerufen? Dies wird hier abgefragt
 jne _int0x21_end ; wenn nein, dann weiter zur nächsten Funktion

; Nun wird es Zeit, die Funktion zu nutzen
; Dieser Software Interupt, mit der Funktion 0x01, gibt Text auf dem Bildschirm aus
 _int0x21_ser0x01_start:
 lodsb ; Jeweils ein Byte laden
 or al, al ; Zeichenkette zuende?
 jz _int0x21_ser0x01_end ; wenn ja, dann Funktion beenden. Wenn nein, dann nachfolgend weiter machen
 mov ah, 0x0E ; Bios Teletype Funktion nutzen
 mov bh, 0x00 ; Auf Page 0 schreiben
 mov bl, 0x07 ; Text Atribute
 int 0x10 ; Bios Call (Text schreiben)
 jmp _int0x21_ser0x01_start
 _int0x21_ser0x01_end:
 jmp _int0x21_end
 
 _int0x21_end:
 iret ; Software Interrupt beenden

; Makros erleichtern die Arbeit. Unter Assembler erst recht.
;Also basteln wir uns ein Makro, welcher die Ausgabe von Textnachrichten erleichtert.
%macro TextAusgabe 1
mov al, 0x01
mov si, %1
int 0x21
%endmacro
 
; Diese Funktion starte den Computer, nach einem Tastendruck, neu
getkey:
mov ah, 0 ; Prozessor Funktion 0, oder anders gesagt, Neustart, ausführen
; Dieser Aufruf bereitet den Prozessor hierfür vor
int 0x16 ; Dieser Befehl löd den Reboot Befehl aus
ret

reboot:
jmp 0xffff:0x0000 ; Alle Befehle entfernen, sowie dem Prozessor neustarten

; Das wars....
; Das ist unserer Mini- Kernel...

wie man sieht, habe ich mein kernel, siehe vorherigen beitrag( [lowlevel magazin - ausgabe 1] ... ) , erweitert.

was kann ich machen, damit ich die makros, wiederholt, nutzen kann..?

31

Offtopic / Re: [forum] ich bekomme andauernt e403...

« am: 23. July 2008, 17:29 »

das brachte nur soviel, dass ich dank unfertiger aktueller rendering engine, fehler im layout sehe. ich habe die vorherigen seamonkey/ k-meleon releases wieder installiert...

32

Offtopic / Re: [forum] ich bekomme andauernt e403...

« am: 23. July 2008, 16:50 »

ich hab noch seamonkey auf mein pc. damit habe ich die selbigen probleme...

33

Offtopic / [forum] ich bekomme andauernt e403...

« am: 23. July 2008, 14:39 »

wie im titel geschrieben, bekomme ich andauernd (beim aufruf des forums und nach dem login) die fehlermeldung "forbidden...", also halt ein e403...

kann der forum betreiber dies mal fixen..?

ach ja, die daten...:

seamonkey 1.1.5 und k-meleon 1.1.5 unter windows xp

[edit] irgendwie geht jetzt fast garnix mehr... ich kann nicht mal das wiki vernünftig nutzen, bzw. die tutorials lesen....

34

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 1] tutorial - kernel zeigt wirre zeichen

« am: 23. July 2008, 13:03 »

ich habe den bootloader etwas umgebaut..

Code: [Auswählen]

; Bootloader Vers. 0.1.0
;
; Aufgaben:
; * Laden des Kernels und deren Start
; * Übergabe der Kontrolle des Computer an den Kernel

org 0x7C00 ; Startadresse des Bootloaders

jmp 0x0000:start ; Zu Startadresse springen

start:
cli ; Interups sind hier noch nicht erlaubt!
mov ax, 0x9000 ; Die Stackadresse auf 9000h Positionieren
mov ss, ax ; Den Stack an die Adresse 9000h anbinden
mov sp, 0 ; Den Stackpointer auf 0h Positionieren
sti ; Interups sind nun erlaubt!

; Nun suchen wir uns das Bootlaufwerk
mov [bootdrv], dl ; Die Nummer des Bootlaufwerks wird aus "DL" nach "[bootdrv] " verschoben

mov si,BootMsg ; Nachricht beim Start ausgeben
call putstr ; Routine zum Ausgeben der Nachricht aufrufen

mov si,LoadMsg ; Nachricht zum Laden des Kernels ausgeben
call putstr ; Die Routine zum Ausgen der Nachricht erneut aufrufne

; Es wird zeit, den Kernel zu laden...
call load ; Wir rufen die Subroutine "load" auf. Diese läd für uns den Kernel
; Sobald der Kernel geladen ist, geht es hiernach weiter

mov ax, 0x1000 ; Unser Kernel ist an Adresse 10000h.
; Die Startadresse ergibt sich so:
; Segementregister x 16 (also mal 10h) + Offset
; Das heist: 1000h x 10h + 0
; Diese Adresse muss natürlich gespeichert werden.
; Also verschieben wir die Startadresse in das Segement Register
mov es, ax ; Die Segement Register müssen aktualisiert werden
mov ds, ax
jmp 0x1000:0x0000 ; Der Kernel soll natürlich auch gestartet werden.
; Also springen wir zum Kernel

; Als nächstes einige Variablen, die die Arbeit erleichtern
bootdrv db 0 ; Wir sichern als erstes die Nummer des startfähigen Laufwerks 0 nach "bootdrv"
BootMsg db "MiniLoader Vers. 0.1.0", 13,10,0
LoadMsg db "Lade den Kernel", 13,10,0
LoadDoneMsg db "Fertig. Starte den Kernel...",13,10,0 ; Wir hinterlegen eine Nachricht, damit der Benutzer sieht, das der Computer arbeitet...

; Damit der Benutzer sieht, das der Computer den Kernel läd, lassen wir dies auf dem Bildschirm ausgeben...
putstr:
lodsb ; Wir fangen einfach mal an, die Daten zu lesen
or al,al
jz short putstrd ; Muss noch etwas gelesen werden, oder ist alles gelesen worden...?
; Wenn alles gelesen wurde, dann ENDE!
mov ah,0x0E ; Ruft die Funktion 0x0E des BIOS auf
mov bx,0x0007 ; Nicht notwendig, aber dennoch... Setzt das Atribut
int 0x10 ; Schreiben des Textes auf den Bildschirm
jmp putstr ; Solange noch etwas zu lesen ist, wird diese Subroutine neu gestartet und weiter gelesen
putstrd:
retn ; Fertig mit dem lesen? wenn ja, dann geht es hier zurück zur Hauptroutine

; Dies ist die Routine zum laden des Kernels...:
load:
mov ax, 0 ; Als erstes setzen wir das Bootlaufwerk zurück, um von ganz vorn lesen zu können
mov dl, [bootdrv] ;  Wir verschieben den Namen des Bootlaufwerks in den Speicher
int 13h ; Anschliessend sagen wir dem BIOS, das es vom Diskettenlaufwerk lesen soll
jc load ; Ist dies nicht gelungen, soll es dies erneut versuchen.
; Wir springen dazu einfach noch mal an den Anfang dieser Routine

; War dies erfolgreich, geht es hier weiter...
load1:
mov ax,0x1000 ; Wir markieren den Speicherbereich 0x1000 als Ziel für unserem Kernel
mov es,ax ; Wir aktualisieren die Segement Register. Somit sind sie bereit für unserem Kernel
mov bx, 0
mov ah, 2 ; Nun wirds interissant... Wir sagen den BIOS, das es etwas von einem Datenträger lesen soll
mov al, 5 ; Gelesen werden sollen die ersten 5 Sektoren...
mov cx, 2 ; Und zwar ab Cylinder 0, Sector 2
mov dh, 0 ; Mit hilfe von Head 0
mov dl, [bootdrv] ; Als Quelle dient das erste Bootlaufwerk (meistens Diskette)
int 13h
jc load1 ; Hat nicht geklappt? Dann noch mal von vorn...

; Wenn das Lesen erfolgreich war, gehts hier weiter...
mov si,LoadDoneMsg ; Als erstes holen wir uns die Bootmsg aus dieser Variable.
; Das ist die Nachricht, die der Benutzer auf dem Bildschirm sehen soll...
call putstr ; Dann geben wir diese mit Hilfe dieser Suroutine aus...
retn ; Dann schliessen wir das Laden des Kernels hier ab...

; Nun müssen wir den Bootloader nur noch die richtige Größe bringen.
; Um es kurz zu machen: Der Bootloader darf nur 512 Bytes groß sein.
; Also bringen wir unserem Bootloader in Form...
times 512-($-$$)-2 db 0

; Anschliessend markieren wir den Datenträger als Bootähig...
dw 0AA55h

; Das wars...
; Das ist unser Bootloader...

die textausgabe vor dem laden des kernels funktioniert.

evtl kann ja jemand den code gebrauchen

35

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 1] tutorial - kernel zeigt wirre zeichen

« am: 23. July 2008, 12:37 »

Als erstes holen wir uns die Bootmsg aus dieser Variable.

Ich würde sagen die Adresse der Bootmsg, nicht die Bootmsg selber.

naja, ohne die adresse auch keine nachricht, oder...? aber, gut zu wissen

Zwischen deiner Hausnummer und deinem Haus ist m.E. schon nochmal ein großer Unterschied. Zumindest macht es einen Unterschied ob ich deine Hausnummer oder dein Haus besitze.  

das stimmt. hier aber brauchen wir die adresse, um uns die nachricht holen zu können... oder, denke ich da jetzt gerade in die falsche richtung...

Ja, aber wir "holen" uns die Nachricht mit der Anweisung überhaupt nicht. In das Register wird nunmal die Addresse der Nachricht geschrieben. Auf die Nachricht selber wird hier garnicht zugegriffen, das macht erst der BIOS-Interrupt.

hmmm, also ich würde das auch noch als "holen" bezeichnen. auch, wenn dies das bios übernimmt... als "logischen" schritt würde ich da mal sagen... kann schon sein, das ich hier "logisch" falsch denke

36

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 1] tutorial - kernel zeigt wirre zeichen

« am: 23. July 2008, 11:39 »

hmmm, kann man auch als "name" verstehen. da schau ich mal ins buch "moderne betriebssysteme", sobald es meins it

Ich würde Name für falsch halten, einfach weil es nicht aus "lesbaren" Zeichen besteht. Das Buch von Tannenbaum wird dich dahingehend auch nicht wesentlich weiterbringen. Es beschäftigt sich eher von abstrakterer Sicht mit Betriebssystemen.

das ist mir schon klar, das man es "nicht lesen" kann... aber, es hat ja eine bezeichnung. ob es nun "0", oder "a" (...) ist, lassen wir mal dahin gestellt. man will ja die bezeichung "nehmen" und diese übergeben...

Als erstes holen wir uns die Bootmsg aus dieser Variable.

Ich würde sagen die Adresse der Bootmsg, nicht die Bootmsg selber.

naja, ohne die adresse auch keine nachricht, oder...? aber, gut zu wissen

Zwischen deiner Hausnummer und deinem Haus ist m.E. schon nochmal ein großer Unterschied. Zumindest macht es einen Unterschied ob ich deine Hausnummer oder dein Haus besitze.  

das stimmt. hier aber brauchen wir die adresse, um uns die nachricht holen zu können... oder, denke ich da jetzt gerade in die falsche richtung...

Prozessor Funktion 0...

Nur um das klarzustellen. Die Funktion wird vom BIOS und nicht vom Prozessor zu Verfügung gestellt. Der Prozessor stellt nur die Instruktion "int" zur Verfügung, hinter welcher sich ein Sprung ins BIOS verbirgt. Wobei man den Prozessor dahin springen lassen kann wo man will, man muss nur die IVT (Interrupt Vector Table) entsprechend anpassen. Das BIOS hat die halt beim Start so erstellt, dass die einzelnen Interrupts auf BIOS-routinen zeigen.

hmm, ok. wieder was gelernt.

Alle Befehle entfernen, sowie dem Prozessor neustarten

Hmm... Befehle entfernen hört sich komisch an.

passt evtl. "befehlsregister leeren"...?

Eher Sprung zum BIOS-Einsprungpunkt. 0xFFFF:0x0000 _wäre_ nämlich die Adresse in CS:IP nach einem Prozessor-Reset. An dieser Adresse ist das BIOS eingeblendet, welches dann den ganzen Hardwaregobledigu initialisiert.

hmm, habs dann wohl falsch verstanden... wieder was gelernt.

einwenig? ja jetzt, wo man "blut gelegt" hat, gehts natürlich weiter

ROFL... es heißt "Blut geleckt"...

war wohl doch noch etwas früh, oder die nacht zu lang hab etwas weiter gebastelt und das 2. tutorial gelesen...

37

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 1] tutorial - kernel zeigt wirre zeichen

« am: 23. July 2008, 08:41 »

boot.asm:

Der Name des Bootlaufwerks wird aus "DL" nach "[bootdrv] " verschoben

Na ja, ich würde nicht Name sagen. Eher BIOS-Laufwerknummer oder so etwas.

hmmm, kann man auch als "name" verstehen. da schau ich mal ins buch "moderne betriebssysteme", sobald es meins it

Unser Kernel ist an Adresse 1000h abgelegt worden.

Nee, der Kernel befindet sich an Adresse 10000h (also eine Null mehr). Ich weiß nicht, ob du dich schon mit der Adressierung im Real-Mode beschäftigt hast. Um im RM (Real-Mode) ganze 1 MByte ansprechen zu können wird so adressiert: Segmentregister mal 16 (also mal 10h) plus Offset. Das heißt in deinem Fall: 1000h * 10h + 0 = 10000h.

darüber weiss ich dann wohl doch noch etwas zuwenig... ich gehe halt davon aus, das der speicherplatz des kernels an dieser adresse beginnt...

Wir sichern als erstes den Namen des startfähigen Laufwerks 0 nach "bootdrv"

Wie schon gesagt, Name eher nicht.

wie schon gesagt, sobald das buch da ist, weiss ich mehr darüber...

loadmsg db "Lade den Kernel...",13,10,0 ; Wir hinterlegen eine Nachricht, damit der Benutzer sieht, das der Computer arbeitet...

Ist nicht so wichtig, aber wenn du schreibst "Lade den Kernel", dann würde ich die Nachricht schon vor dem Laden des Kernels ausgeben (ansonsten vielleicht "Kernel wurde geladen" oder so).

hmm, da setze ich wohl noch eine zweite nachricht vor der laderoutine des kernels und passe diese hier an...

Wir verschieben den Namen des Bootlaufwerks in den Speicher

Wie oben schon gesagt, nicht Name. Aber in dem Speicher wird dort auch nichts verschoben. Eher vom Speicher in dem Register dl kopiert.

da kommen wir dem ganzen schon etwas näher. danke

Als erstes holen wir uns die Bootmsg aus dieser Variable.

Ich würde sagen die Adresse der Bootmsg, nicht die Bootmsg selber.

naja, ohne die adresse auch keine nachricht, oder...? aber, gut zu wissen

kernel.asm:

Den Kernel an Adresse 1000h Positionieren

Den Kernel positionieren? KA würde ich anders ausdrücken.

ok, darum kümmere ich mich noch...

Prozessor Funktion 0...

Nee Funktion Null des BIOS-Interrupts 16h.

ok, dann heist es, bücher über das bios noch mal rausholen...

Dieser Befehl löd den Reboot Befehl aus

Nee, der "Befehl" hat mit dem reboot nichts zu tun. Er wartet bis eine Taste (außer Systemtasten wie Strg, Alt etc.) gedrückt wird und kopiert dessen Scancode nach ah und den evtl. vorhandenen ASCII-Code nach al.

ah, falsch verstanden.... danke dir

Alle Befehle entfernen, sowie dem Prozessor neustarten

Hmm... Befehle entfernen hört sich komisch an.

passt evtl. "befehlsregister leeren"...?

Der Text wird so "komisch" ausgegeben, weil du bei msg_boot und msg_boot2 vor/nach der 10 (zeile = zeile + 1) die 13 (spalte = 0) vergessen hast.

das hatte ich schon bemerkt. ich hab die zeilen und die ergebnisse verglichen. ich hab einfach nur die "13" entsprechend eingefügt. danke für die erklärung der spalten und zeilen. das werde ich später noch für weitere ausgaben brauchen...

So, hoffe dass ich dir einwenig helfen konnte. Immer am Ball bleiben.

bitmaster

einwenig? ja jetzt, wo man "blut gelegt" hat, gehts natürlich weiter

38

Lowlevel-Coding / Re: [lowlevel magazin - ausgabe 1] tutorial - kernel zeigt wirre zeichen

« am: 23. July 2008, 07:13 »

Hi,

In der boot.asm steht:

Code: [Auswählen]

jp short putstr
Aber wieso jp? Ich würde wie du es auch in der kernel.asm getan hast jz nehmen und vor allen Dingen putstrd nicht putstr, also so:

Code: [Auswählen]

jz short putstrd

So mal schauen, evtl. finde ich noch mehr.


EDIT: So noch etwas gefunden. In der routine load1 fehlt der Aufruf des int 13h. Also es sollte so aussehen:

Code: [Auswählen]

load1:
mov ax,0x1000 ; Wir markieren den Speicherbereich 0x1000 als Ziel für unserem Kernel
mov es,ax ; Wir aktualisieren die Segement Register. Somit sind sie bereit für unserem Kernel
mov bx, 0
mov ah, 2 ; Nun wirds interissant... Wir sagen den BIOS, das es etwas von einem Datenträger lesen soll
mov al, 5 ; Gelesen werden sollen die ersten 5 Sektoren...
mov cx, 2 ; Und zwar ab Cylinder 0, Sector 2
mov dh, 0 ; Mit hilfe von Head 0
mov dl, [bootdrv] ; Als Quelle dient das erste Bootlaufwerk (meistens Diskette)
int 13h
jc load1
EDIT: Ich habs mal getestet. Also auf VMware funktionierts, auf Qemu und VirtualBox leider nicht. Weiß ich jetzt leider auch nicht warum es dort nicht funktioniert.

EDIT: Habs jetzt mal auf Bochs getestet. Da funktioniert es.

bitmaster

thx da hab ich doch glatt tippfehler drinn und auch eine zeile vergessen...

qemu stürzt nach der fehlerbereinigung ab... auf mein noteboot (p3 @600mhz) läuft alles so wie es sein soll. nur die 3. zeile meiner textausgabe ist ziemlich weit nach rechts gerutscht. aber, das korrigiere ich noch.

wie sieht es mit meinem kommentaren aus. hab ich das alles richtig verstanden (siehe kommentare) ?

39

Lowlevel-Coding / [lowlevel magazin - ausgabe 1] tutorial - kernel zeigt wirre zeichen

« am: 22. July 2008, 12:53 »

also, wie als titel bereits geschrieben... mein kernel wird geladen, er zeigt einige textzeilen, anschliessend aber nur wirres zeug...

hier erst mal mein bereits etwas geänderter source:

boot.asm

Code: [Auswählen]

; Bootloader Vers. 0.1.0
;
; Aufgaben:
; * Laden des Kernels und deren Start
; * Übergabe der Kontrolle des Computer an den Kernel

org 0x7C00 ; Startadresse des Bootloaders

jmp 0x0000:start ; Zu Startadresse springen

start:
cli ; Interups sind hier noch nicht erlaubt!
mov ax, 0x9000 ; Die Stackadresse auf 9000h Positionieren
mov ss, ax ; Den Stack an die Adresse 9000h anbinden
mov sp, 0 ; Den Stackpointer auf 0h Positionieren
sti ; Interups sind nun erlaubt!

; Nun suchen wir uns das Bootlaufwerk
mov [bootdrv], dl ; Der Name des Bootlaufwerks wird aus "DL" nach "[bootdrv] " verschoben

; Es wird zeit, den Kernel zu laden...
call load ; Wir rufen die Subroutine "load" auf. Diese läd für uns den Kernel
; Sobald der Kernel geladen ist, geht es hiernach weiter

mov ax, 0x1000 ; Unser Kernel ist an Adresse 1000h abgelegt worden.
; Diese Adresse muss natürlich gespeichert werden.
; Also verschieben wir die Startadresse in das Segement Register
mov es, ax ; Die Segement Register müssen aktualisiert werden
mov ds, ax
jmp 0x1000:0x0000 ; Der Kernel soll natürlich auch gestartet werden.
; Also springen wir zum Kernel

; Als nächstes einige Variablen, die die Arbeit erleichtern
bootdrv db 0 ; Wir sichern als erstes den Namen des startfähigen Laufwerks 0 nach "bootdrv"
loadmsg db "Lade den Kernel...",13,10,0 ; Wir hinterlegen eine Nachricht, damit der Benutzer sieht, das der Computer arbeitet...

; Damit der Benutzer sieht, das der Computer den Kernel läd, lassen wir dies auf dem Bildschirm ausgeben...
putstr:
lodsb ; Wir fangen einfach mal an, die Daten zu lesen
or al,al
jp short putstr ; Muss noch etwas gelesen werden, oder ist alles gelesen worden...?
; Wenn alles gelesen wurde, dann ENDE!
mov ah,0x0E ; Ruft die Funktion 0x0E des BIOS auf
mov bx,0x0007 ; Nicht notwendig, aber dennoch... Setzt das Atribut
int 0x10 ; Schreiben des Textes auf den Bildschirm
jmp putstr ; Solange noch etwas zu lesen ist, wird diese Subroutine neu gestartet und weiter gelesen
putstrd:
retn ; Fertig mit dem lesen? wenn ja, dann geht es hier zurück zur Hauptroutine

; Dies ist die Routine zum laden des Kernels...:
load:
mov ax, 0 ; Als erstes setzen wir das Bootlaufwerk zurück, um von ganz vorn lesen zu können
mov dl, [bootdrv] ;  Wir verschieben den Namen des Bootlaufwerks in den Speicher
int 13h ; Anschliessend sagen wir dem BIOS, das es vom Diskettenlaufwerk lesen soll
jc load ; Ist dies nicht gelungen, soll es dies erneut versuchen.
; Wir springen dazu einfach noch mal an den Anfang dieser Routine

; War dies erfolgreich, geht es hier weiter...
load1:
mov ax,0x1000 ; Wir markieren den Speicherbereich 0x1000 als Ziel für unserem Kernel
mov es,ax ; Wir aktualisieren die Segement Register. Somit sind sie bereit für unserem Kernel
mov bx, 0
mov ah, 2 ; Nun wirds interissant... Wir sagen den BIOS, das es etwas von einem Datenträger lesen soll
mov al, 5 ; Gelesen werden sollen die ersten 5 Sektoren...
mov cx, 2 ; Und zwar ab Cylinder 0, Sector 2
mov dh, 0 ; Mit hilfe von Head 0
mov dl, [bootdrv] ; Als Quelle dient das erste Bootlaufwerk (meistens Diskette)
jc load1 ; Hat nicht geklappt? Dann noch mal von vorn...

; Wenn das Lesen erfolgreich war, gehts hier weiter...
mov si,loadmsg ; Als erstes holen wir uns die Bootmsg aus dieser Variable.
; Das ist die Nachricht, die der Benutzer auf dem Bildschirm sehen soll...
call putstr ; Dann geben wir diese mit Hilfe dieser Suroutine aus...
retn ; Dann schliessen wir das Laden des Kernels hier ab...

; Nun müssen wir den Bootloader nur noch die richtige Größe bringen.
; Um es kurz zu machen: Der Bootloader darf nur 512 Bytes groß sein.
; Also bringen wir unserem Bootloader in Form...
times 512-($-$$)-2 db 0

; Anschliessend markieren wir den Datenträger als Bootähig...
dw 0AA55h

; Das wars...
; Das ist unser Bootloader...

kernel.asm

Code: [Auswählen]

; miniKernel Ver.s 0.1.0
;
; Aufgaben:
; * Kern des Betriebssystems
;   * Das heist:
;      + Stellt Grundlegende Funktionen und Routinen desBetriebssystems bereit
;      + Verwaltet Grundlegende Funktionen der Datenträger,
;         insbesondere das Lese,Schreiben und Ändern von Dateien und Daten
;      + Verwaltet den Speicher, Threats etc..
;
; Kernel- Typ:
; * Monolitsch
;   + Nur in der Start- bzw. Entwicklungsphase
;      Später wir der Kernel Modular Struckturiert sein....

mov ax, 0x1000 ; Den Kernel an Adresse 1000h Positionieren
mov ds, ax ; Die Segement Register aktualisieren
mov es, ax

start:
; Anschliesend verwenden wir die Subroutine "putstrg", um Benutzer- Nachrichten auszugeben
mov si,msg ; Wir holen als erstes die Nachricht
call putstr ; Und diese geben wir nun aus...

mov si,msg_boot ; Wir holen uns eine weitere Nachricht...
call putstr ; Auch diese geben wir nun aus...

mov si, msg_boot2 ; Wir holen uns eine weitere Nachricht...
call putstr ; Auch diese geben wir nun aus..

call getkey ; Hier rufen wir nun eine Subroutine auf, die auf einem Tastendruck wartet...
jmp reboot ; Weiter gehts zu einer Subrouten, die den PC neustartet

;  Wir speichern die Nachrichten, in den nachfolgenden Variablen...:
msg db "Willkommen beim minOS Version 0.1.0",13,10,0
msg_boot db "Kernel wurde erfolgreich geladen...",10,0
msg_boot2 db "Druecke eine Taste, um den Computer neu zu starten...",10,0

; Es wir Zeit, die Nachrichten auszugeben...:
putstr:
lodsb ; Beginne zu lesen
or al,al
jz short putstrd ; Muss noch etwas gelesen werden, oder ist alles gelesen worden...?
; Wenn alles gelesen wurde, dann ENDE!
mov ah,0x0E ; Ruft die Funktion 0x0E des BIOS auf
mov bx,0x0007 ; Nicht notwendig, aber dennoch... Setzt das Atribut
int 0x10 ; Schreiben des Textes auf den Bildschirm
jmp putstr ; Solange noch etwas zu lesen ist, wird diese Subroutine neu gestartet und weiter gelesen
putstrd:
retn ; Fertig mit dem lesen? wenn ja, dann geht es hier zurück zur Hauptroutine

; Diese Funktion starte den Computer, nach einem Tastendruck, neu
getkey:
mov ah, 0 ; Prozessor Funktion 0, oder anders gesagt, Neustart, ausführen
; Dieser Aufruf bereitet den Prozessor hierfür vor
int 0x16 ; Dieser Befehl löd den Reboot Befehl aus
ret

reboot:
jmp 0xffff:0x0000 ; Alle Befehle entfernen, sowie dem Prozessor neustarten

; Das wars....
; Das ist unserer Mini- Kernel...

entweder wird das laden der textzeilen nicht korrekt abgeschlossen, oder ich habe den aufruf der funktion zum neustarten falsch intergriert...

wo liegt hier der fehler...?

---

ps: sind meine, für mich intergrierten, kommentare korrekt? ich meine die erklärungen der anweisungen. damit will ich sicherstellen, das ich das tutorial richtig verstanden habe...

[edit]
ich füge mal noch hinzu, das ich unter windows xp mit nasm kompiliere und auch, als vergleich, den code aus dem magazin per c&p in notepad++ kopiert und nasm diesen dann assemblieren lassen habe. da tritt seltsamerweise das selbige problem auf...