1. Bootloader + Kernel

[Admin]

Hallo hier werdet ihr lernen wie man ein winzig kleines Betriebssystem schreibt.


Ein Betriebsystem ist ein Programm das alles auf dem Computer regelt und es die Benutung des Computers zu erleichtern.

Ein Betriebsystem besteht aus folgenden Teilen :

Bootloader
Kernel
Dateisystem
Interrupts
Treiber
Applikationen

Ein Betriebsystem kann in vielen Programmiersprachen geschrieben werden.
Aber
für bestimmte Teile muss man Assembler verwenden (die
Maschinensprache), Assembler ist fast die niedrigste möglichkeit zu
programmieren, deshalb kann man die Hardware fast ganz steuern.

Wir schreiben zuerst einen kleinen Bootloader der "Hallo Name" ausgibt.

Code:


[size=9][i]org 0x7C00

start:
                ; Erst brauchen wir einen Stack.
cli            ; Keine Interrupts!
mov ax, 0x9000  ; Stackadresse
mov ss, ax      ; SS = 9000 (unser Stack)
mov sp, 0      ; SP = 0000  (der Stackpointer)
sti            ; Interrupts zulassen


mov [bootdrv], dl

;Lade unseren Kernel
call load

;Springe zu diesem Kernel
mov ax, 0x1000 ; Die Adresse des Programms
mov es, ax    ; Segmentregister updaten
mov ds, ax
push ax
mov ax, 0
push ax
retf

; ==============================================
; Funktionen und Variablen
; ==============================================

bootdrv db 0 ;Das Bootlaufwerk
loadmsg db "Hallo Name",13,10,0



; Einen String ausgeben:
putstr:
lodsb            ; Byte laden
or al,al
jz short putstrd  ; 0-Byte? -> Ende!

mov ah,0x0E      ; Funktion 0x0E
mov bx,0x0007    ; Attribut-Byte (wird nicht ben?t)
int 0x10          ; schreiben
jmp putstr        ; N?stes Byte
putstrd:
retn

; Lade den Kernel vom Bootlaufwerk
load:

; Diskdrive reset (Interrupt 13h, 0)
push ds            ; Sichere DS
mov ax, 0          ; Die gew?e Funktion (reset)
mov dl, [bootdrv]  ; Dieses Laufwerk ist gew?
int 13h            ; Den Interrupt ausf?
pop ds            ; DS wiederherstellen
jc load            ; Geht nicht? -> Noch mal!

delay:
XOR AH,AH
INT 0x1A
ADD DX,SI
MOV BX,DX
.WL:
INT 0x1A
CMP DX,BX
JNE .WL
RET

; Sektoren lesen (Interrupt 13h, 2)
load1:
mov ax,0x1000
mov es,ax
mov bx, 0
mov ah, 2
mov al, 5
mov cx, 2
mov dx, 0
int 13h
jc load1
mov si,loadmsg
call putstr

times 512-($-$$)-2 db 0 
dw 0AA55h [/i][/size]

Da gibt es nicht viel zu erklären.

Nur
das die letzten zwei Zeilen dazu dienen das die nachher compilierte
Binärdatei genau 512 Bytes groß ist, das muss sein ,weil nur so der
Bootloader wenn er auf eine Diskette geschrieben und diese in einen PC
gelegt wurde, geladen wird.
Der Bootloader ist also nur ein ASM-Code der vom BIOS geladen wird und der den Kernel lädt.

Hier der Kernel :

Code:

; ---------------------------------------------------
; Unser Kernel
; ---------------------------------------------------

mov ax, 1000h ; Segmentregister updaten
mov ds, ax
mov es, ax

mov AX, 0013h ; Graphik
INT 10h

mov AL, 193 ; hier wird Farbe 193 festgelegt
mov DX, 03C8h
out DX, AL ; an Port 3C8h senden
inc DX ; den Rest an 3C9 senden
mov AL, 00h ; ROTAnteil
out DX, AL
mov AL, 00h ; GRÜNAnteil
out DX, AL
mov AL, 00h ; BLAUAnteil
out DX, AL

start:
mov si, msg
call putstr  ; Schicke Bootmessage :)

mov si,msg_boot
call putstr  ; Noch eine Message :D

call getkey  ; Warte auf einen Tastendruck
jmp reboot    ; Reboot

; -------------------------------------------------
; Funktionen und Variablen
; -------------------------------------------------

msg db "Welcome to nameBetriebsystem",13,10,0
msg_boot db "Press any key...",10,0

; Stringausgabe
putstr:
lodsb            ; Byte laden
or al,al
jz short putstrd ; 0-Byte? -> Ende!
mov ah,0x0E      ; Funktion 0x0E
mov bx,0x0007    ; Atrribut-Byte
int 0x10        ; schreiben
jmp putstr      ; nächstes Byte
putstrd:
retn

; Warte auf einen Tastendruck
getkey:
mov ah, 0 ; Funktion 0
int 016h  ; Ausf?hren
ret

; Rebooten (HEX Dump).
reboot:
db 0EAh
dw 0000h
dw 0FFFFh

Wenn
man ein ein Betriebssystem schreiben möchte muss man nicht unbedingt
Assembler können(ist zwar besser), aber wenn man die nötigen ASM-Codes
von einer Quelle bekommt, kann man dann in C/C++ weiter programmieren.

Das Schreiben des OS auf die Diskette :

Man braucht :
den NASM Compiler http://nasm.sourceforge.net
Rawwrite http://www.chrysocome.net/rawwrite

1. erstellt einen Ordner, entzippt die nasm Datei und kopiert nasmw.exe, Bootloader.asm und Kernel.asm in diesen Ordner.

2.
erstellt eine .bat Datei(das macht man indem man einen TextEditor
öffnet und auf speichern unter geht und dann den NamenDerDatei und
statt .txt .bat schreibt.
In diese .bat Datei schreibt man dann das :

Code:

nasmw -f bin -o Boot.bin Bootloader.asm
nasmw -f bin -o kernel.bin Kernel.asm
copy Boot.bin+kernel.bin mf_OSEducating.img

Dann klickt ihr doppelt auf die .bat Datei, dann sollte in dem Ordner die Datei mf_OSEducating.img sein.

3.
legt eine Diskette in euer DLaufwerk, formatiert sie, dann öffnet
RawWrite.exe das ihr vorher entzippt habt und schreibt die Datei
mf_OSEducating.img auf diese Diskette.

4. Schaltet euren Computer ab und legt die Diskette in das Disketten Laufwerk. Schaltet euren Computer an und ihr seht das:

Welcome to NameBetriebssystem
press any kex to reboot...


Herzlichen Glückwunsch Ihr habt gerade ein Betriebssystem geschrieben!!!!!


by Mathias Fröhlich