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 - Gamepower

Seiten: [1]
1
hallöle :)

ich habe einige zeit nicht mehr an mein "MinOS" kernel gearbeitet... also hab ich mein projekt vorerst geworfen und verfolge das os-dev tutorial von herrn henkes. nun habe ich folgendes problem: ich habe diesen kernel abgetippt, der sich auch ohne fehlermeldungen kompilieren lässt. allerdings, wenn ich den befehl "help" eingebe, kommt dort die fehlermeldung, das der befehl nicht existiert.

hier ersteinmal meine adaption des kernels:

; MyOS Kernel Vers. 0.0.3 - 11 Juni 2009

;;;;;;;;;;;;;;;;;
; Realmode Code ;
;;;;;;;;;;;;;;;;;

org 0x8000 ; Kernel Startadresse
[BITS 16] ; 16 Bit Code

; RealMode Bereich des Kernels
RealMode:
xor ax, ax ; Segmente einrichten
mov es, ax
mov ds, ax
mov ss, ax
mov sp, ax

mov si, welcome
call print_string

add sp, -0x40 ; Input Buffer auf 64 Zeichen setzen

loop_start:
mov si, prompt ; Eingabeaufforderung Zeigen
call print_string

mov di, sp ; Hole Eingaben
call get_string
jcxz loop_start ; Leere Zeile? Wenn ja, ignorieren und zum Start zurück

mov si, sp
mov di, cmd_hi ; "hi" Kommando
call strcmp
je .helloworld

mov si, sp
mov di, cmd_questionmark ; "?" Kommando
call strcmp
je .help

mov si, sp
mov di, cmd_exit ; "exit" Kommando
call strcmp
je .exit

mov si, sp
mov di, cmd_pm ; "pm (protected mode)" Kommando
call strcmp
je .pm

mov si, badcommand
call print_string
jmp loop_start

.helloworld:
mov si, msg_helloworld
call print_string
jmp loop_start

.help:
    mov si, msg_help
    call print_string
    jmp loop_start

.exit:
mov si, msg_exit
call print_string
xor ax, ax
int 0x16 ; Warte auf Tastendruck
jmp 0xffff: 0x0000 ; Neustart

.pm:
call clrscr
mov si, msg_pm
call print_string
call Waitingloop

cli ; Interrups leeren
lgdt [gdtr] ; Lade die GDT per GDTR (Eingerichtet in der Datei "gdt.asm"

in al, 0x92 ; A20-Gate per schnellen A20 Port 92 einschalten
cmp al, 0xff ; Falls 0xFF zurück gegeben wird, ist der Port nicht Verfügbar...
je .no_fast_A20 ; ... in diesem fall, zu diesem Punkt springen...

; andernfalls geht es hier weiter:
or al, 2 ; A20-Gate Bit setzen (Bit 1)
and al, ~1 ; Init-Bit setzen
out 0x92, al
jmp .A20_done

; Steht kein schneller A20-Gate zur Verfügung...? Dann benutzt der Kernel den Weg über den KBC Chip
.no_fast_A20:
call empty_8042
mov al, 0xD1 ; KBC Kommando: Schreibe auf Output Port
call empty_8042

mov al, 0xDF ; Schreibe dies auf KBC Output Port zum einschalten des A20 Gate
out 0x60, al
call empty_8042

; Umschalten in den A20-Gate beenden
.A20_done:
mov eax, cr0
or eax, 1
mov cr0, eax
jmp 0x8:ProtectedMode


empty_8042:
call Waitingloop
in al, 0x64 ; Kein echter KBC...?
cmp al, 0xFF
je .done

test al, 1 ; something in Input Buffer
jz .no_output
call Waitingloop
in al, 0x60 ; Wenn ja, Buffer lesen...
jmp empty_8042 ; ... dann nocheinmal

.no_output:
test al, 2 ; Kommando Buffer leer?
jnz empty_8042 ; Wenn nein, dann Buffer als nicht leer markieren und zur "Leerungsroutine" springen

.done:
ret

print_string:
mov ah, 0x0E

.loop_start:
lodsb ; Hole ein Byte von SI
test al, al ; Alle Zeichen geholt? Wenn ja, dann...
jz .done ; Funktion verlassen
int 0x10 ; Wenn nein, dann Zeichen ausgeben...
jmp .loop_start ; ... Anschliessend nochmal von vorn

.done:
ret

get_string:
xor cx, cx
.loop_start:
xor ax, ax
int 0x16 ; Auf Tastendruck warten
cmp al, 8 ; Rücktaste gedrückt?
je .backspace ; Wenn ja, entsprechend behandeln
cmp al, 13 ; Entertaste gedrückt?
je .done ; Wenn ja, entsprechend behandeln
cmp cl, 63 ; 63 Zeichen eingegeben?
je .loop_start ; Wenn ja, nur noch Rücktaste und Enter erlauben
mov ah, 0x0E
int 0x10 ; Gebe Zeichen aus
stosb ; Speichere Zeichen in Puffer
inc cx
jmp .loop_start

.backspace:
jcxz .loop_start ; Leer (Keine Zeichen auf dem Bildschirm) ? Wenn ja, Rücktaste ignorieren
dec di
mov byte [di], 0 ; Lösche ein Zeichen
dec cx ; Reduziere Speicherplatz für Zeichenkette
mov ah, 0x0E
int 0x10 ; Rücktaste auf dem Bildschirm zeigen
mov al, ' '
int 0x10 ; Gebe "Rücktastenzeichen" (Leerzeichen) aus
mov al, 8
int 0x10 ; Zeige erneut die Rücktaste auf dem Bildschirm
jmp .loop_start

.done:
mov byte [di], 0 ; NULL terminator
mov ax, 0x0E0D
int 0x10
mov al, 0x0A
int 0x10 ; Neue Zeile
ret

strcmp:
.loop_start:
mov al, [si] ; Hole ein Zeichen von SI
cmp al, [di] ; Sind SI und DI identisch?
jne .done ; Nein? Wir sind fertig

test al, al ; Keine Zeichen mehr zu prüfen?
jz .done ; Wenn ja, sind wir fertig

inc di ; DI um 1 verringern
inc si ; SI um 1 verringern
jmp .loop_start

.done:
ret

clrscr:
; Funktion, um den Bildschirm zu "leeren"
mov ax, 0x0600
xor cx, cx
mov dx, 0x174F
mov bh, 0x07
int 0x10
ret

;;;;;;;;;;;;;;;;;;;;;;;
; Protected Mode Code ;
;;;;;;;;;;;;;;;;;;;;;;;

[Bits 32]

ProtectedMode:
mov ax, 0x10
mov ds, ax ;Daten Desciptor -> Daten, Stack und Extra Segment
mov ss, ax
mov es, ax
xor eax, eax ; NULL Descriptor -> FS und GS
mov fs, ax
mov gs, ax
mov esp, 0x200000 ; Setze Stack Limit auf 2MB

call clrscr_32
mov ah, 0x01

.endlessloop:
call Waitingloop
inc ah
and ah, 0x0f
mov esi, msg_pm2 ; Nachricht "Betriebssystem läuft im Protected Mode"
call PutStr_32
cmp dword [PutStr_Ptr], 25 * 80 * 2 + 0xB8000
jb .endlessloop
mov dword [PutStr_Ptr], 0xB8000 ; Text Zeiger Wrapper
jmp .endlessloop

Waitingloop:
mov ebx, 0x9FFFF
.loop_start:
dec ebx
jnz .loop_start
ret

PutStr_32:
; PM Mode Textausgabe
mov edi, [PutStr_Ptr]
.nextchar:
lodsb
test al, al
jz .end
stosw
jmp .nextchar
.end:
mov [PutStr_Ptr], edi
ret

clrscr_32:
mov edi, 0xb8000
mov [PutStr_Ptr], edi
mov ecx, 40 * 25
mov eax, 0x07200720 ; 2 Werte -> Weisser Text auf schwarzen Hintergrund | 0x20 -> Freier Platz
rep stosd
ret

PutStr_Ptr dd 0xb000

; Man läd die Adresse des Textes, den man haben möchte, über "[PutStr_Ptr]
; für die Textaugaben. Der Text muss NULL terminiert sein.
; you want to print in esi and the attributes in ah
; lodsb loads one byte from esi into al, then increments esi,
; then it checks for a NUL terminator,
; then it moves the char into the write position in video memory,
; then increments edi and writes the attributes,
; loops until it finds NUL pointer at which point it breaks ...

;;;;;;;;;;;;;;;;
; Textausgaben ;
;;;;;;;;;;;;;;;;

welcome db 'MinOS Vers. 0.03', 13, 10, 0
msg_helloworld db 'Hello World on MinOS Vers. 0.03', 13, 10, 0
badcommand db 'Unbekannter Befehl', 13, 10, 0
prompt db '> ', 0
cmd_hi db 'hi', 0
cmd_help db 'help', 0
cmd_questionmark db '?', 0
cmd_exit db 'exit', 0
cmd_pm db 'pm', 0
msg_help db 'Befehle: hi, help, ?, pm, exit', 13, 10, 0
msg_exit db 'Computer wurde herunter gefahren. Du kannst ihm nun ausschalten. Alternativ druecke eine Taste, um ihm neuzustarten.', 13, 10, 0
msg_pm db 'Schalte in den Protected Mode.', 13, 10, 0
msg_pm2 db 'MinOS arbeitet im Protected Mode.  ', 0

;;;;;;;;;;;;
; Includes ;
;;;;;;;;;;;;

%include "gdt.asm"

;;;;;;;;;;;;;;;
; Kernel Ende ;
;;;;;;;;;;;;;;;

times 1024-($-$$) hlt

hab ich mich da einfach nur irgendwo vertippt, was nasm nicht anmeckert, weil nasm alles sieht was es sehen muss...? ach ja, ich kompiliere mit nasm, nicht nasmw...

---

[ot]
herr henkes schreibt ein wirklich klasse tutorial. alles ist schön schrittweise strukturiert und erklärt.
2
tyndur / tyndur webseite down
« am: 22. March 2009, 07:53 »
hallöle,

ich wollte mir gerade tyndur als diskettenimage und den quelltest laden. aber, anstatt der webseite, diskettenimages bzw. dem quelltext kommt nur so ein hässlicher  e404....

ist die seite umgezogen, oder ist das projekt tod...?
3
Lowlevel-Coding / roadmap meines kernels - so realisierbar..?
« am: 21. March 2009, 07:30 »
hallöle :) erstmal die roadmap:

Bereits abgeschlossene Aufgaben:

Vers. 0.0.1
» Einfacher Bootloader (ohne real nutzbares Dateisystem)
» Hardcodet Textausgabe
» Funktion zum Neustart des Computers

Vers. 0.0.2
» Mini- IVT (nur Int 13h | Textausgabe läft nun über diesen Interupt)
» Makros für die Progammiererleichterung
» Erste Kernelmessages

Vers. 0.0.3
» Kleinerer Kernelbugfix (Kernelmessages wurden falsch ausgerichtet)
» Erster Versuch, eines Fat12 Bootloaders einzurichten

Vers. 0.1.0
» Fat12 Bootloader integriert
» Kerneloptimierung (Kernel ist nun ein wenig kleiner, als vorher)
» Vorbereitungen für das Fat12 Dateisystem und Speicherverwaltung

Geplante & kommende Funktionen:

Vers. 0.1.1
» Integration von Dateisystem Funktionen (lesen, schreiben & Ausführen von Dateien & Programmen) | Fat12 Dateisystem- Treiber
» Einrichtung der benötigten Software- Interupts
» Erster Teil der Speicherverwaltung

Vers. 0.1.2
» Ausgabe von Textdateien, bzw. vergleichbares mittels der Dateisystemfunktionen

Vers. 0.1.3
» Einfügen eines Speichermanagers - Vorbereitung(en) für den Protected Mode

» Vorbereitungen für die (erste kleine) Shell
» Teil 1 der API integriert

Vers. 0.2.0
» Erster Testrelease für die Öffentlichkeit
» 24h Langzeit- Test
» Ggf. Kernelbugfix

Vers. 0.2.1
» Falls Notwendig: Kernelbugfix
» Minimale Shell
» Ggf. Fat12 Dateisystem- Treiber Bugfix

Vers. 0.2.2
» Ausbau der minimalen Shell oder neue Shell
» Texteditor
» Ggf. Kernelbugfix

Vers. 0.3.0
» 2. 24h Langzeit- Test
» 2. Testrelease
» Teil 2 der API
» Ggf. Kernelbugfix

Vers. 0.3.1
» Ausbau des Texteditors, bzw. neuer Editor

Vers. 0.4.0
» (feste) Integration erster Anwendungen - darunter den Editor, Taschenrechner (bzw. ähnliches Programm), Datum- / Zeitanzeige & erste portierte Anwendungen
» 24h Langzeit- Test
» Teil 3 der API
» Ggf. Kernelbugfix

Vers. 0.5.0
» Erneuter Testrelease für die öffentlichkeit
» 24h Langzeit- Test
» Vorerst letzter Teil der API
» Ggf. Kernelbugfix

Vers. 0.6.0
» Ggf. weiter Programme » Ggf. Kernelbugfix

Vers. 0.7.0
» Phase 1 zum Umstieg in den Protected Mode
» Ggf. Kernelbugfix

Vers. 0.8.0
» A20 Gate fertig
» Weitere Treiber (Dateisystem usw.) für den Protected Mode umgeschrieben
» Tastaturtreiber fertig (für deutsche und englische Tastatur Layouts)
» IPC fertig
» Malloc fertig
» 24h Langzeit- Test
» Ggf. Kernelbugfix

Vers. 0.9.0
» Assembler Compiler portiert, bzw. einen eigenen geschrieben
» 24h Langzeit- Test
» Ggf. Kernelbugfix

Vers. 1.0.0
» Finaler Release
» 72h Langzeit- Test
» Ggf. Kernelbugfix

Das MinOS ist fertig! Hiernach finden nur noch Bugfixes statt, sofern in der Langzeitnutzung Fehler auftreten.

nun meine fragen:

1. kann man die roadmap so umsetzen?

2. ich stecke beim bauen der fat12 treiber fest. um genau zu sein, muss ich die funktionen zum auffinden, lesen, schreiben und erstellen von dateien einbauen. der beispielcode im tutorial 7 ist sehr umfangreich. aber, wie kann ich diesem so anpassen, das er eine textdatei liest und sie dann am bildschirm ausgiebt...

3. wie realisiere ich die speicherverwaltung im rm...? malloc hat dort sicher kein sinn, oder...?

thx in voraus
4
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:

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:

; 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..?
5
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....
6
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
; 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
; 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...
Seiten: [1]

Einloggen