[hydrixOS] : HydrixOS Handbuch: Erste Kostprobe
- From: Friedrich Gräter <webmaster@xxxxxxxxxxx>
- To: Mailingliste <hydrixos@xxxxxxxxxxxxx>
- Date: Thu, 23 May 2002 17:16:02 +0200
Hallo,
hier einmal ein kurzer Teil des bisher vorhandenen Handbuches. Die noch
neu hinzukommenden Kapitel sind noch nicht im Inhalt aufgeführt.
Was haltet ihr davon?
---------------------------------------------------------------------
[ Ausug aus dem neuen HydrixOS Handbuch ]
---------------------------------------------------------------------
Inhalt
------
Inhalt
Vorwort
Teil A - Einführung in HydrixOS
---------------------------------------------------------------------------
1. Grundlagen
1.1 Das Prinzip von HydrixOS
1.2 Aufbau von HydrixOS
1.3 Virtueller Prozessor
1.4 Prozesse
1.5 Tasks
1.6 Threads
1.7 Virtueller Adressraum
1.8 Segmente
1.9 Ports und Nachrichten
1.10 Benutzer und Zugriffslisten
2. Speicherverwaltung
2.1 Kernelspeicher
2.2 Virtueller Adressraum
2.3 Lokale Segmente
2.4 Globale Segmente
2.5 Deskriptor Caches
2.6 Speicherauslagerung
2.7 Copy-on-write
3. Virtuelle Prozessoren
3.1 Organisation eines virtuellen Prozessors
3.2 Virtual Processor Interface (VPCI)
3.3 Kernelaufrufe
3.4 Problematik bei der Entwicklung eines VPCs
4. Prozesse und Threads
4.1 Organisation eines Prozesses
4.2 Erzeugen neuer Prozesse
4.3 Erzeugen neuer Threads
4.4 Kopieren von Prozessen und Threads
4.5 Fehlerbehandlung in Prozessen
4.6 Scheduling
5. Wege der Interprozesskommunikation
5.1 Erzeugen von Ports
5.2 Nachrichtenprozeduren
5.3 Globale Segmente für IPC
5.4 Synchronisation Globaler Segmente
6. Client-Server-Modell
6.1 Organisation eines Servers
6.2 Das HydrixOS-RPC-Format
6.3 Treiberaufrufe
7. Hardware-Spezifische Teile
7.1 IRQs
7.2 I/O Ports
7.3 Memory-Mapped I/O
8. Sicherheit unter HydrixOS
8.1 Automatische Sicherheitsprüfung
8.2 Empfohlener Logon-Mechanismus
9. Start des HydrixOS Betriebssystems
9.1 Maschinenseitiger Start
9.2 Kernelseitiger Start
9.3 Init-Prozess
9.4 Aufgaben des Init-Prozesses
Teil B - Einführung in die Programmierung unter HydrixOS
---------------------------------------------------------------------------
1. Der HydrixOS Kernel
1.1 Organisation des Kernels
1.2 Wichtige Hintergrundfunktionen des Kernels
1.3 Wichtige Variablen im Kernel
1.4 Warum C?
1.5 Kernelversionen
1.6 Kompilieren des Kernels
1.7 Portieren des Kernels
1.8 Programmieren von VPCs
2. HydrixOS C v386 Bibliothek
2.1 Aufbau der Bibliothek
2.2 OS spezifische Funktionen der Bilbiothek
2.3 Funktionen nach C99-Standard
3. Programmierung von Treibern auf Init-Ebene
3.1 Wann ist ein Treiber ein Init-Treiber
3.2 Installation eines Init-Treibers
3.3 Aufbau eines Init-Treibers
3.4 Zugriff auf die Hardware
Anhang
---------------------------------------------------------------------------
A. Fehlernummern des Kernels
A.1 Klassifizierung von Fehlern
A.2 Übersicht über die Fehler
A.3 Erläuterung der Fehler
B. HydrixOS Systemaufrufe
B.1 Sortierung nach Namen
B.2 Sortierung nach Aufrufsnummern
B.3 Erläuterung der Aufrufe
C. Kernel interne Strukturen
C.1 Tabellenstrukturen
C.2 Current-Struktur
D. HydrixOS FAQ
D.1 Allgemeine Fragen
D.2 Fragen zum Kernel
D.3 Fragen zur Emulation
E. Rechtliche Hinweise
E.1 Änderungen am Dokument
E.2 GNU Free Document License
...........................................................................
===========================================================================
Vorwort
===========================================================================
[ FEHLT NOCH ]
===========================================================================
Teil A
Einführung in HydrixOS
===========================================================================
In diesem Teil werde ich versuchen, Ihnen die Grundlagen des HydrixOS
Betriebssystems zu erklären. Es geht weniger um die praktische
Programmierung, sondern um die theoretische Erklärung der Organisation und
der Strukturen von HydrixOS.
1. Definitionen
===============
In erster Linie sind für HydrixOS einheitliche Definitionen für Begriffe
nötig. Darum bemüht sich dieses Kapitel Ihnen die wichtigsten und
grundlegensten Begriffe im HydrixOS System zu erläutern.
1.1 Das Prinzip von HydrixOS
----------------------------
HydrixOS soll ein Betriebssystem sein, dass Zuverlässig, Portabel,
Kompatibel und Modular ist. Diese vier Punkte werden in der Welt der EDV
immer wichtiger. Computer werden immer kleiner und sind heutzutage in
großer Komplexität in kleiner Form integriert in Mobiltelefonen und
Waschmaschinen vorzufinden. Das Internet ist mittlerweile vielen Menschen
zugänglich und hat in den letzten zwanzig Jahren die Menschen verändert.
Dennoch ist es bis jetzt immer noch nicht möglich ein Programm geschrieben
für den Mac auf einem IBM PC zu starten, da die Prozessoren und die
Hardware sich auf grundlegenster Ebene unterscheiden. Es ist sogar oft
nichtmal möglich Programme gleicher Hardware-Plattformen die für
unterschiedliche Betriebssysteme geschrieben worden sind, in einem
Betriebssystem integriert auszuführen. Jedoch wird es in Zukunft nötig sein
diesen historischen Hinkelstein vom Bein des technischen Fortschritts zu
lösen, um Platz für die ungehinderte Entwicklung neuer Technologien zu
schaffen.
HydrixOS will einen wichtigen Grundstein legen, als Betriebssystem, das
durch eine > allgemeingültige und portable Schnittstelle < und das mittels
> Emulation von Hardware und Systemsoftware < die Verbindung von Programmen
über die Grenzen der Hardware und Betriebssysteme ermöglichen will.
1.2 Aufbau von HydrixOS
-----------------------
HydrixOS ist ein System, das nahe an das Prinzip des Mikrokernels
herankommt. Der Kernel übernimmt kaum Aufgaben zur Steuerung und
Abstraktion der Hardware. Er übernimmt nur die Emulation,
Prozess-/Threadverwaltung, Speicherverwaltung, IPC und Abstraktion bzw.
Steuerung grundlegenster Hardware (IRQ; I/O-Ports; Speicher)
Grob würde HydrixOS im Schema folgenden Aufbau besitzen:
[Anwendungen und Treiber]
-------------------------
[Kernel]
-------------------------
[Hardware]
In einem genaueren Schema würde HydrixOS wie folgt aufgebaut sein:
---------------------------------------------------------------------------
Benutzer-Modus
---------------------------------------------------------------------------
[ Client-Prozesse ]
---------------------------------------------------------------------------
[ Server-Prozesse ]
---------------------------------------------------------------------------
Kernel-Modus
---------------------------------------------------------------------------
[ Virtuelle Prozessoren ]
---------------------------------------------------------------------------
[ HydrixOS Schnittstellen- und Ausführungsschicht ]
---------------------------------------------------------------------------
[ Systemverwaltungs- und Aufrufsschicht ]
---------------------------------------------------------------------------
[ Hardwareanbindungsschicht ] | [ Speicheremulationsschicht ]
---------------------------------------------------------------------------
Hardware
---------------------------------------------------------------------------
[ CPU ] | [ Hardware ] | [ Speicher ]
---------------------------------------------------------------------------
Die unterste Ebene bildet die Hardware.
Direkt nach der Hardware, steht die Hardwareanbindungsschicht (Hardware
connection layer, HCL). Die HCL stellt wichtige plattformspezifische
Dienste zur Initialisierung des Kernels, für IRQ und Exception-Handling,
sowie für den Zugriff auf die I/O-Ports (falls auf der jeweiligen Plattform
vorhanden) zur Verfügung. Paralell zu dieser Schicht steht die
Speicheremulationsschicht (Memory emulation layer, MML). Die MML stellt für
das restliche Betriebssystem ein allgemeingültiges und portiebares System
für den Arbeitsspeicher zur Verfügung, das u.a. virtuelle Adressräume und
Segmentierung unterstützt.
Auf diese Schichten setzt die Systemverwaltungs- und Aufrufsschicht (System
managment and system call layer, SMCL). Diese Schicht bietet verschiedene
Dienste, wie Speicherverwaltung, Prozessverwaltung, IPC und den Zugriff zu
diesen Diensten über Systemaufrufe zur Verfüung.
Wiederum setzt auf die SMCL die HydrixOS Schnittstellen- und
Ausführungsschicht auf (HydrixOS Interface and Executive layer, HIEL).
Diese Schicht ermöglicht für virtuelle Prozessoren (und die durch diese
ausgeführten Programme) den Zugriff auf die Systemaufrufe. Ebenfalls ist in
dieser Schicht der Scheduler enthalten.
Über der HIEL liegen die virtuellen Prozessoren (virtual Processors, VPCs)
auf. Diese führen Binärprogramme mittels Emulation oder Übersetzung dieser
aus.
Die HCL, MML, SMCL und die HIEL, sowie die VPCs bilden den Kernel. Alle
ihre Operationen laufen im Kernel-Modus (Kernel mode, KM) ab und haben
komplette Kontrolle über die Hardware. Im Kernel-Modus müssen sich die
einzelnen Programmteile an die Sicherheitsregeln selbstverantwortlich
halten.
Auf dem Kernel-Modus liegt der Benutzer-modus (User mode, UM). Hier gibt es
keine Schichten mehr, sondern logische Trennung in Server-Prozesse, die
Dienste anbieten und Client-Prozesse, die Dienste nutzen. Prozesse im
Benutzer-Modus teilen sich in Prozesse im 'Root-Modus' (Root mode, RM),
die über hohe Rechte verfügen (auch 'Supervisor Modus' genannt) und in
Prozesse des 'Anwender-Modus' (Application mode, AM), die über wenig Rechte
verfügen.
1.3 Virtuelle Prozessoren
-------------------------
Virtuelle Prozessoren (virtual Processors, VPCs) sind Module des Kernels,
die einen bestimmten Prozessor emulieren. Emuliert wird nur der jeweilige
Prozess, nicht die restliche Hardware, da andere Hardware direkt durch das
Betriebssystem abstrahiert wird. Virtuelle Prozessoren stellen eher eine
Prozessor-Abstraktionsschicht dar.
1.4 Prozesse
------------
Prozesse sind die Ausführungsrahmen von Programmen (Threads). Sie enthalten
einen Adressraum, in dem mehrere Threads ausgeführt werden können. Ein
Prozess enthält mindestens einen Thread und gehört höchstens einem
Benutzer. Ein Prozess besitzt mehrere lokale Segmente und kann mehrere
Ports und Segmente für andere Prozesse anbieten. Seine Threads werden von
ein und dem selben virtuellen Prozessor ausgeführt.
Schematisch ist ein Prozess unter HydrixOS wie folgt aufgebaut:
---------------------------------------------
|
|
| ---------------------- |
| | | ----------------- |
| | | | Thread 1 | |
| | virtueller | |---------------| |
| | Adressraum | | Thread n | |
| | (eingeteilt in | ----------------- |
| | lokale Segmente) | |
| | | ----------------- |
| ---------------------- | Port 1 | |
| |---------------| |
| | Port n | |
| ----------------- |
| |
---------------------------------------------
1.5 Tasks
---------
Tasks sind die gespeicherten oder abzuarbeitenden Programme aus Sicht eines
virtuellen Prozessors. Ihr Zustand wird in einem von VPC zu VPC wechselndem
Task Status Segment gespeichert.
1.6 Threads
-----------
Threads sind die wartenden oder arbeitenden Tasks aus Sicht des HydrixOS
Betriebssystems. Ein Thread kann unter HydrixOS folgende Zustände annehmen:
1. Arbeitend
2. Wartend
3. Blockierend
Alle Threads bekommen, wenn sie sich nicht im blockierenden Zustand
befinden, in regelmäßigen Abständen, abhängig von ihrer Priorität Zeit zum
Arbeiten vom System zugewiesen. Sie wechseln dann vom wartenden in den
arbeitenden Zustand. Ist die Arbeit vollbracht, wechseln sie vom
arbeitenden in den wartenden Zustand.
Der blockierende Zustand wird aktiviert, wenn ein Thread auf die Freigabe
eines globalen Segments, auf eine Nachricht oder auf das Eintreten eines
Ereignisses wartet. Dieser Zustand dauert an, bis der Thread durch den
Kernel oder durch einen anderen Thread aus diesem Zustand befreit wird. Ein
Thread kann durch den Kernel oder durch sich selbst in den blockierenden
Zustand versetzt werden. Solange der Thread sich in diesem Zustand
befindet, wird er nicht weiter verarbeitet.
1.7 Virtueller Adressraum
-------------------------
Ein Virtueller Adressraum ist ein kontinuierlicher Adressbereich, der mit
der Adresse 0 anfängt und an einer bestimmten Adresse aufhört. Die Größe
eines solchen Adressraums kann unter HydrixOS 2^64 Bytes (16 Exabytes)
nicht überschreiten.
Ein virtueller Adressraum ist aus Sicht seines Verbrauchers (z.B. des
Prozesses, der ihn benutzt) scheinbar kontinuierlich. Physikalisch müssen
die Daten eines virtuellen Adressraums jedoch nicht kontinuierlich, ja
nicht mal an gleichem Ort und Stelle gespeichert sein.
Die Summe aller Speicherbereiche, auf die der virtuelle Adressraum
abgebildet wird, ist der Hintergrundspeicher.
1.8 Segmente
------------
Segmente sind logische Einheiten in einem virtuellen Adressraum. Alle
Adressen innerhalb eines Segments werden zur Startadresse des Segments
addiert. Die Startadresse befindet sich also irgendwo in einem virtuellen
Adressraum.
Eine Adresse für ein Segemnt wird in zwei Teile geteilt:
1. Einen Segment-Teil, der die Nummer des Segments nennt. Diese Nummer
referenziert wieder einen Segmentdeskriptor, in dem die Startadresse,
Zugriffsrechte und die Größe des Segments gespeichert sind.
2. Einen Offset-Teil, der die relative Adresse zum Segmentbeginn enthält.
Die tatsächliche Adresse in einem virtuellen Adressraum aus einer
Segmentadresse wird demnach wie folgt gebildet:
(Offset im Segment) + (Segmentbegin) = Adresse
1.9 Ports und Nachrichten
-------------------------
Eine Nachricht ist eine abgeschlossene Datenmenge, die von einem Thread, zu
einem anderen vom Kernel transportiert wird. Sie kann auch zwischen
Prozessen wechseln.
Ein Port ist eine Nachrichtenwarteschlange, die Nach dem First-In First-Out
Prinzip (FIFO-Prinzip) organisiert ist. Die Nachricht, die zuerst dort
eintrifft muss auch zuerst gelesen werden. Ein Port kann einschränken von
welchem Thread und wieviele Nachrichten bei ihm eintreffen dürfen.
1.10 Benutzer und Zugriffslisten
--------------------------------
Die Prozesse eines Benutzer idendifizieren sich durch eine Nummer.
Prozesse des Benutzers '0' (auch 'root' und 'Supervisor' genannt) haben
besondere Vorrechte.
Für bestimmte Objekte (globale Segmente; Ports) kann es Zugriffslisten
geben. In diesen Zugriffslisten wird bestimmt welcher Benutzer welche
Rechte auf ein Objekt hat.
Zugriffsrechte werden unter HydrixOS wie folgt notiert
Kürzel
Bedeutung
---------------------------------------------------------------------------
r
Leserecht
w
Schreibrecht
x
Ausführungsrecht
d
Löschungsrecht
c
Recht zur Änderung von Zugriffsrechten (Kontrollrecht)
o
Besitzerrecht
Stellt man vor ein Kürzel ein Plus-Zeichen, so heißt dies, dass der
Benutzer über das Recht verfügt. Stellt man hingegen davor ein
Minus-Zeichen, heißt dies, dass der Benutzer nicht über das Recht
verfügt. Fehlt ein Plus oder Minuszeichen, so ist die erst genannte
Bedeutung zutreffend.
Beispiele:
-r
Lesen nicht gestattet
+d
Löschen gestattet
c
Ändern der Zugriffsrechte gestattet
Die Zugriffsrechte werden normalerweise in einer Reihe geschrieben, so
dass eindeutig alle Rechte für ein Objekt zu sehen sind. Die Reihenfolge
ist immer "rwxdco"
Beispiele:
+r-w-x+d-c+o
Benutzer darf lesen, nicht schreiben, nicht ausführen, löschen, die
Rechte nicht ändern und ist Besitzer des Objektes.
-r+w+x+d-c-o
Benutzer darf nicht lesen, aber schreiben, ausführen und löschen. er
darf die Rechte nicht ändern und ist auch nicht Besitzer des Objektes.
Für den Root-Benutzer gelten keien Zugriffsrechte. Bei der
Zugriffsprüfung werden sie für den Root-Benutzer ignoriert.
---------------------------------------------------------------------
[ Ende Ausug aus dem neuen HydrixOS Handbuch ]
---------------------------------------------------------------------
cu
FG
---
This is not SPAM! You can unsubscribe sending an e-mail to
hydrixos-request@xxxxxxxxxxxxx with subject "unsubscribe". If
you've got questions contact webmaster@xxxxxxxxxxxx
hydrixOS kernel: http://www.hydrixos.de/downl.htm
Other related posts:
- » [hydrixOS] : HydrixOS Handbuch: Erste Kostprobe
