Eigenes Betriebssystem schreiben ?

[mwiesbau]

Wenn du mit Delphi (Pascal) ein eigenes Betriebsystem schreiben willst musst du dir zu erst einen Bootloader schreiben.

Du musst nur deinen Kernel soweit entwickeln um Delphi sourcecode kompilieren und verarbeiten zu können.


Mein tipp für alle die ein eigenes Betriebsystem Programmieren wollen:

nehmt euch ein mini Linux und entwickelt es weiter.



http://web105.essen082.server4free.de/lowlevel/

Das nimmst du und Speicherst es in einem file z.b.: Bootloader.asm
------

org 0x7C00
;--------------------------------------------------------
;Bootloader
;--------------------------------------------------------
start:
cli ; Keine Interrupts verwenden!
mov ax, 0x9000 ; Adresse des Stack speichern
mov ss, ax ; Stackadresse festlegen
mov sp, 0 ; Stackpointer auf 0 setzen
sti ; Jetzt lassen wir wieder Interrupts zu

mov [bootdriv], dl ; Bootlaufwerk aus DL speichern

call load ; Lade Kernel
mov ax, 0x1000 ; 0x1000 ist die Speicheradresse unserer Shell
mov es, ax
mov ds, ax
push ax
mov ax, 0
push ax
retf

bootdriv db 0 ; Das Bootlaufwerk
loadmsg db "Lade ...WieOS 0.09",13,10,0

; Mit dieser Funktion geben wir einen String aus
putstr:
lodsb
or al,al
jz short putstrd
mov ah,0x0E
mov bx,0x0007
int 0x10
jmp putstr
putstrd:
retn

; Mit dieser Funktion laden wir unseren Kernel vom Bootlaufwerk
load:
push ds
mov ax, 0
mov dl, [bootdriv]
int 13h
pop ds
jc load

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
retn
times 512-($-$$)-2 db 0
dw 0AA55h

----------------------------------

Wenn du das hast besorgst du dir gleich den NASM (Netwide Asembler)
und machst dir eine Binary daraus --> nasm -f bin -o bootloader.bin bootloader.asm

Als nächstes kommt dein eigener Kernel
--------------------------------------------------------
mov ax, 1000h
mov ds, ax
mov es, ax

start: ; Hier fängt unser eigentliches "Betriebssystem" an
mov si, msg_0 ; Wir zeigen einfach nur einen String an
call schreiben

mov si, msg_1
call schreiben

mov si, msg_2
call schreiben ; "schreiben" gibt den String am Bildschirm aus

call lesen ; "lesen" wartet bis eine Taste gedrückt wurde
jmp reset ; Danach wird die Funktion "reset" aufgerufen

msg_0 db "WieOS 0.09 started...",13,10,0
msg_1 db "Programmed and Developped by hdkiller",10,0
msg_2 db "Press any key to reboot",10,0

schreiben:
lodsb
or al, al
jz short schreiben_d
mov ah, 0x0E
mov bx, 0x0007
int 0x10
jmp schreiben

schreiben_d:
retn

lesen:
mov ah, 0
int 016h
ret

reset:
db 0Eah
dw 0000h
dw 0FFFFh
-----------------------------------------
Wieder Speichern in z.b.: Kernel.asm
und natürlich wieder die binary erzeugen.

jezt Fügst du die beiden binarys zu einem Image zusammen --> copy bootloader.bin+kernel.bin betriebssystem.raw

das ganze jetzt mit rawrite auf diskette schreiben und booten


War doch nicht so schwer oder ??

[tommie-lie]

@dizzy: Mag sein, daß die 99% ein wenig übertrieben sind (60%-80%, wenn Inline-Assembler mitzählt und man nur das zum OS zählt, was wirklich benötigt wird) und daß eine GUI nicht zum OS gehört, aber sämtliche Strukturen kann man in C oder Pascal schreiben. Scheduling z.B. Den Timer programmiert man mit Assembler (sind ein paar Zeilen an INs und OUTs und ein bisschen Eumgeschiebe), den Handler an sich in C oder Pascal. Alles, was z.B. an einem Scheduler in Assembler sein muss, ist das eigentliche Ausführen der Aktion, also Taskstatussegment aktualisieren, coderegister aktualisieren, LDT austauschen, usw. Der eigentliche Algorithmus kann durchaus in C geschrieben sein, und die Algorithmen und Strukturen, die dahinter stecken, sind teilweise viel bequemer in einer Hochsprache geschrieben.
Der benötigte Anteil an Assembler wird meist überschätzt, obwohl man sogar den Videospeicher im RealMode in C ansprechen kann, wenn man einen entsprechenden Compiler hat der 16bit-Code erzeugt.


@mwiesbau: Linux erweitern um ein Betriebssystem zu programmieren?
Ich weiß ja nicht, ob du sowas schonmal gemacht hast, aber bevor ich mich du ein so komplexes System wie das weit vorgeschrittene Linux mache, schreib ich mir eher ein Betriebssystem selbst...
Außerdem ist alles, was man so braucht, schon sehr lange in Linux enthalten. Alles, was sich lohnen würde, wären irgendwelche Spezialtreiber für exotischste Hardware, und da muss man mehr über die Hardware an sich wissen, als über ein Betriebssystem. Dann schon eher DOS 5.0 mit anständigen Treibern, ProtectedMode und 'ner neuen command.com ausstatten, das wäre wesentlich einfacher.
-----
Und warum soll der Kernel den Delphi-Quellcode kompilieren? Wieso meint jeder, zu einem Betriebssystem gehört ein eigener Compiler (kürzlich schonmal gesehen)?
Wenn man den Kernel soweit hat, daß er den PE32-Header interpretieren kann und entsprechend die EXE laden kann, muss man "nur noch" die Laufzeitumgebung aufbauen. Denn selbst wenn man keine API-Aufrufe hat, verbergen sich in der VCL genug davon. Und wie schwierig es ist, die Windows-API-Calls zu reimplementieren, zeigt das WinE-Projekt...
Delphi hat den großen Nachteil, daß es ganz streng an Windows gebunden ist, daher ist Delphi für Betriebssystementwicklung nicht zu gebrauchen. Wer Pascal nehmen will, findet in FreePascal und dem GPC-Frontend zur GCC zwei gute Alternativen.

[dizzy]

Überzeugt - es lässt sich sicher einiges via C oder Pascal lösen. Nur allein schon einen Bootloader zu entwickeln finde ich schon relativ deftig. Grundvoraussetung bleibt aber nach wie vor das in- und auswendige kennen der x86-Specs und der calls an das BIOS.
Wenn man sich genügend damit beschäftigt mag das auch gehen, aber "genügend" ist hier schon nicht mehr sooo wenig .

Als kleines Freizeitprojekt für nebenbei für meinen Geschmack zu dick. Wer allerdings ausreichend Zeit über hat... okay. (Hätt' ich wohl auch gerne... Je mehr ich feststelle, das das nicht so einfach ist, desto mehr bekomm ich Bock drauf )

Einen Loader oder Kernel(-ansatz) kopieren fände ich alledings nicht wirklich toll. Damit Lerneffekt und Stolz voll zur Geltung kommen können muss man schon bei null anfangen .

[tommie-lie]

Zitat von dizzy:

Überzeugt - es lässt sich sicher einiges via C oder Pascal lösen. Nur allein schon einen Bootloader zu entwickeln finde ich schon relativ deftig. Grundvoraussetung bleibt aber nach wie vor das in- und auswendige kennen der x86-Specs und der calls an das BIOS.

In- und Auswendig? Ganz so isses ja nicht. Man sollte vielleicht wissen, was der Unterschied zwischen Protected und RealMode ist, aber in- und auswendig kann keiner die x86-Spezifikationen kennen. Genauso wie die BIOS-funktionen. Es gibt zwar nur 256 mögliche Interrupts, aber die, die das BIOS verwaltet haben beinahe alle Unterfunktionen, und das nicht zu knapp.
Zusammen mit einem guten Hardwarebuch, ein paar Beispielcodes und "Ralf Brown's Interrupt List" ist man für alles gewappnet. Am Anfang schlägt man alles nach, nach einer Woche kennt man die Parameter für die Textausgabe auswendig (leider braucht man sie nach einer Woche auch nicht mehr, wenn man schnell ist...), für die selteneres Befehle steht ja weiterhin die RBIL bereit.

[marvin.maybe]

Hallo,

Zitat von dizzy:

Was glaubst du ist ein OS?

Habe mal an der Uni "Betriebssysteme" als Vertiefungsfach gehabt (und dort auch Diplom gemacht) und denke, dass ich eine ungefähre Vorstellung davon habe, was ein OS ist.

Vielleicht versuche ich mal so zu argumentieren: Jeden Algorithmus, den man in Assembler programmieren kann, den kann man auch in einer Hochsprache entwickeln und auch Betriebssysteme bestehen nicht nur aus Treibern, sondern zum großen Teil aus anderen Dingen. Ich gebe Dir Recht, dass man einige Funktionen besser in Assembler programmieren kann (wie vielleicht den Boot Loader).

Nochmal zurück zum Assembler-Anteil an Betriebssystem: Wie groß ist das Betriebssystem Windows? 100 MB 200 MB, keine Ahnung. Wie groß ist der Anteil der Assemblerteile? 1 MB? (Und das ist wohl schon übertrieben).
Werden bei Linux nicht megabyteweise Sourcen mitgeliefert? Sind die in Assembler? Nein. in C/C++.

Zitat von dizzy:

Um aber erstmal Anwendungen erstellen zu können brauchts halt das "eigenliche" OS. Und ein Compiler IST eine Anwendung.

Die Sachen gibt es doch schon... oder hast Du im Hinterkopf, die auch programmieren zu wollen?

Zitat von dizzy:

D.h. solange du nicht eine Speicherverwaltung, grundlegende Treiberstruktur, Festplatten und generell Datenträgerverwaltung, Tastatur- und Maussteuerung, BIOS-Schnittstellen, IRQ-Implementierung und so weiter hast, ists einfach Essig mit einer Hochsprache.

Ich denke nicht, dass Tastatur oder Maustreiber die grundlegenden Probleme bei der OS Entwicklung sind.
IRQ-Implementierung? Ich hoffe mal, dass nicht mal in Assembler jemand wieder mit dem Unsinn anfängt. Glücklicherweise ist mit ASM32 dieser Quatsch selbst auf x86-Platforms ausgestorben.

Zitat von dizzy:

:gruebel: ich WILL gar kein OS schreiben müssen *g*.

Auf ein schickes Filesystem hätte ich fast Lust :-)

Gruß,
Marvin.

[edit=sakura] BB-Code zugelassen. Mfg, sakura[/edit]

[Plague]

Ich habe in Nero 6.0 nun mal gesehen, dass man da eine CD mit Boot-Sektor brennen kann. Nun stellt sich mir dir Frage, ob ich da theoretisch einfach eine *.exe Datei reinkopieren kann und die dann gebootet wird. Wie seht ihr das?
Die Idee ein eigenes kleines Betriebssystem zu schreiben hatte ich auch schon mal, hab sie dann aber wieder verworfen. Interessant wäre es aber schon mal.
Gleichzeitig denke ich aber, dass es theoretisch möglich sein müsste mit Delphi ein Betriebssystem zu schreiben da es ja auch Kylix gibt, das im Prinzip Delphi auf Linux Basis ist und nichts mit Windows zu tun hat.
Mein Lehrer in Info meinte auch mal, dass es möglich sein müsste man aber ein paar umwege gehen müsse.

Thomas

[dizzy]

Zitat von marvin.maybe:

Habe mal an der Uni "Betriebssysteme" als Vertiefungsfach gehabt (und dort auch Diplom gemacht) und denke, dass ich eine ungefähre Vorstellung davon habe, was ein OS ist.

oki

Zitat von marvin.maybe:

Vielleicht versuche ich mal so zu argumentieren: Jeden Algorithmus, den man in Assembler programmieren kann, den kann man auch in einer Hochsprache entwickeln und auch Betriebssysteme bestehen nicht nur aus Treibern, sondern zum großen Teil aus anderen Dingen. Ich gebe Dir Recht, dass man einige Funktionen besser in Assembler programmieren kann (wie vielleicht den Boot Loader).

Okay, ich ging jetzt davon aus, dass man auf seinem eignen OS auch die weiteren Klamotten entwickelt. Dann wörds wohl echt ekelig...

Zitat von marvin.maybe:

Nochmal zurück zum Assembler-Anteil an Betriebssystem: Wie groß ist das Betriebssystem Windows? 100 MB 200 MB, keine Ahnung. Wie groß ist der Anteil der Assemblerteile? 1 MB? (Und das ist wohl schon übertrieben).
Werden bei Linux nicht megabyteweise Sourcen mitgeliefert? Sind die in Assembler? Nein. in C/C++.

s.o.

Zitat von marvin.maybe:

Die Sachen gibt es doch schon... oder hast Du im Hinterkopf, die auch programmieren zu wollen?

s.o.

Zitat von marvin.maybe:

Ich denke nicht, dass Tastatur oder Maustreiber die grundlegenden Probleme bei der OS Entwicklung sind.

s.o. ...

Zitat von marvin.maybe:

IRQ-Implementierung? Ich hoffe mal, dass nicht mal in Assembler jemand wieder mit dem Unsinn anfängt. Glücklicherweise ist mit ASM32 dieser Quatsch selbst auf x86-Platforms ausgestorben.

wär doch hübsch!?

Zitat von marvin.maybe:

Auf ein schickes Filesystem hätte ich fast Lust

Na wie gut, dass du nicht größenwahnsinnig bischt
(Aber wenn, dann mach ich mit! *inputwill*)

gruss,
dizzy

[dizzy]

Zitat von Plague:

Gleichzeitig denke ich aber, dass es theoretisch möglich sein müsste mit Delphi ein Betriebssystem zu schreiben [...]
Mein Lehrer in Info meinte auch mal, dass es möglich sein müsste man aber ein paar umwege gehen müsse.

Irgendwo hatte ich mal gelesen, dass der Delphi-Compiler nicht in der Lage dazu ist Binaries zu erstellen, die ohne Win lauffähig sind. Einzig für FreePascal soll es eine Lösung geben, die aber auch alles andere als einfach wäre.

=> OS mit Delphi: Fehlanzeige

[Chewie]

Zitat von Plague:

Gleichzeitig denke ich aber, dass es theoretisch möglich sein müsste mit Delphi ein Betriebssystem zu schreiben da es ja auch Kylix gibt, das im Prinzip Delphi auf Linux Basis ist und nichts mit Windows zu tun hat.
Mein Lehrer in Info meinte auch mal, dass es möglich sein müsste man aber ein paar umwege gehen müsse.

Thomas

Delphi erzeugt 1. nur Dateien im PE-Format (dem Windows-Dateiformat für ausführbare Dateien) und 2. erzeugt teilweise betriebssystemabhängigen Code (kann ich nichts weiter zu sagen, da kenn ich mich nicht aus). Kylix kompiliert wohl Dateien im Linux-Pendant zu PE. Deshlab ist es nicht möglich, mit dem Delphi-Compiler Betriebssysteme zu erzeugen.

[Luckie]

Delphi ruft im Endeffekt nur Windows API's auf und Kylix eben Linux API's. Und wenn der Unterbau des OS nicht da ist, geht gar nichts.