Thema: Bootbarer Mikrokernel mit Hypervisor für Semantischen Code

[Svenska]

Wann treten Call-Gates sonst noch auf?

Call-Gates sind nur eine Möglichkeit zum Kontextwechsel. Üblicherweise verwendet man sie nicht mehr und nutzt stattdessen Interrupts (ähnlich dem DOS Funktionsverteiler "int 21h") oder - prozessor- und modusspezifisch - die Befehle SYSENTER bzw. SYSCALL.

springe ich vom Hypervisor in die Prozedur und am Ende dieser an eine feste Adresse zurück in den Hypervisor. Die Frage ist: kann ich während diesen JMPs den Ring ändern? So wie ich das verstanden habe, wird der Ring im Segment festgelegt.

Mit einem JMP kannst du den Ring nicht ändern. Wenn du das möchtest, eignet sich ein Sprung durch ein Call-Gate. Prinzipiell kannst du auch die Prozeduren im Ring 0 ausführen lassen und in der eigentlichen Ziel-Architektur eine spezielle Instruktion (JMPUSER) vorsehen. Die Sicherheitsprobleme mit diesem Ansatz sollten bekannt sein, wenn x86 aber ohnehin nur eine Zwischenlösung ist, ist das vielleicht akzeptabel.

Andersrum gefragt: kann ich nur mit der Seitennummer aus dem Page Directory und dem Offset direkt auf physikalischen Speicher zugreifen? (Page Tables nutze ich erstmal nicht). Da meine Speicherverwaltung nur Virtuelle Adressen zurückgibt, brauche ich wohl kein LEA?

Wenn du physische Adressen bevorzugst, solltest du einen paginglosen Ansatz überdenken bzw. einfach den physischen Speicher 1:1 in deinen Adressraum mappen, dann sind virtuelle und physische Adressen immer gleich.

Wofür kann ich Tasks noch brauchen, eigentlich habe ich ja den Hypervisor?

Du brauchst in jedem Fall einen Task, um den Ring 3-Code auszuführen.

Was haben Tasks mit Multi-Core zu tun?

Nichts, außer, dass aus der Pseudoparallelität eine echte Parallelität wird.

Was bedeutet mehrere Threads per Core?

Das gleiche wie Multitasking auf einem Core, nur innerhalb eines Tasks.

Gruß,
Svenska

[erik.vikinger]

Hallo,

Ich kenne RISC bisher nur aus Dokumenten/Spezifikationen (IBM Power, Sun SPARC, HP PA-RISC), fühle mich jedoch definitiv von den Eigenschaften überzeugt. Speziell die Many-Core-Varianten (60+) haben es mir angetan.

Von welchen Eigenschaften konkret fühlst Du Dich den überzeugt? Sorry, wenn ich das so doof frage aber Du solltest IMHO schon wissen auf was Du Dich einlässt und vor allem was Du eigentlich erreichen möchtest. Für "Many-Core" benötigst Du entweder ein wirklich gutes Speicher-Kohärenz-Protokoll (und das ist bei weitem keine triviale Angelegenheit) oder Du beschränkst Dich auf AMP. Wie taljeth schon angedeutet hat beschäftige ich mich ebenfalls mit der Entwicklung einer eigenen CPU, ein kleiner Einblick ist dort http://forum.lowlevel.eu/index.php?topic=2470.msg27699#msg27699 (ließ Dir am besten die ganze Seite von oben bis unten durch, da sind noch mehr Leute die ne eigene CPU bauen), und muss ganz ehrlich sagen das dieses Thema auf jeden Fall deutlich komplexer ist als ich mir das vor 3 bis 4 Jahren vorgestellt hatte. Vor allem solltest Du eine konkrete Vorstellung davon haben was Dein Ziel sein soll, soll Deine Architektur möglichst einfach sein, spielt SMP eine Rolle, Speicherschutz (per Paging oder was anderes) oder möchtest Du eine möglichst hohe Performance. Da kann man sehr viele verschiedene Ziele miteinander kombinieren und deswegen muss man meiner persönlichen Meinung nach vorher wissen was man genau will und um genau das wirklich zu wissen sollte man auf möglichst vielen CPU-Architekturen praktisch fließend Assembler beherrschen, nur so entwickelt man ein gutes Gefühl dafür was die einzelnen CPU-Architekturen für Stärken und Schwächen haben, was ist elegant gelöst (viele empfinden ja MIPS aufgrund seiner extremen Beschränkung aufs wesentliche als sehr elegant, ich persönlich sehe das anders) oder was ist eventuell unintuitiv aber dafür performant (Itanium ist hierfür in gutes Beispiel). Fast alle CPUs haben die 4 üblichen Flags zusammen mit den 14 üblichen bedingten Sprüngen mit denen sie alle wichtigen integer-arithmetischen Bedingungen prüfen können aber diese Flags sind eigentlich immer auch ein Performance-Engpass da sie nur ein einziges mal vorhanden sind, Alpha hat aus diesem Grund gar keine Flags und ist schon deswegen mal einen genaueren Blick wert weil man aus der Art wie dieses Problem bei Alpha gelöst ist einiges lernen kann.

Bitte entschuldige meine Art Gedanken festzuhalten.

Dafür musst Du Dich nicht entschuldigen, vielmehr solltest Du bedenken das Du vielleicht selber nicht mehr weißt was Du mit einem kurzen Stichpunkt aus 4 oder 5 Worten eigentlich mal gemeint hast wenn Dein Projekt erst mal 5 Jahre läuft (und glaube lieber nicht das Du in 5 Jahren schon fertig bist).

Abgesehen davon vermute ich, dass es nicht unbedingt notwendig ist, alle Aspekte des Projekts zu kennen.

Wer den Überblick nicht hat kann auch bei Details nur selten gute Entscheidungen treffen.

Der Hypervisor führt immer nur kleine Prozeduren aus und springt dann wieder zurück.

Wozu dann überhaupt der Ring-Wechsel? Wenn dieser Code vom Hypervisor selber erzeugt wurde dann weiß dieser doch ob der gefährliche Operationen enthält bzw. kann sicherstellen das der Objekt-Code eben nichts gefährliches macht und schon ist alles Okay. Microsoft hat wimre mal mit .NET und Singularity (ich bin mir hier beim Namen nicht ganz sicher aber das iNetz kann Dir sicher weiterhelfen) mal etwas in der Richtung probiert, dort sollten wohl alle Programme und auch der Kernel im selben Adressraum liegen und da der Code grundsätzlich nur aus .NET-Byte-Code vom OS-Kernel selber in Objekt-Code überführt wurde kann so sichergestellt werden das keine Angriffe auf das restliche System enthalten sind.

Wann treten Call-Gates sonst noch auf?

Nur da wo Du sie aktiv einbaust.

kann ich während diesen JMPs den Ring ändern?

Nur mit einem CALL-Gate, zumindest fällt mir auf x86 kein anderer Weg ein wenn man das unbedingt mit einem JMP machen will.

(Page Tables nutze ich erstmal nicht). Da meine Speicherverwaltung nur Virtuelle Adressen zurückgibt

Äh, das ist ein Widerspruch in sich. Obwohl, warte, bei x86 gibt es ja noch die Segmente und nach der offiziellen Intel-Terminologie bezieht sich virtuell auf den segmentierten Adressraum und die Adressen die dann per Paging in physische Adressen umgewandelt werden sind die linearen Adressen. Bitte beschreibe erst mal was Du genau machen möchtest. Und ob Du LEA brauchst hängt nicht von Deinem Speichermodell ab.


Grüße
Erik

[kevin]

"Fahrplan": Java-Emulator -> x86 Mikrokernel -> HW-Design
Ziel ist eine Architektur in Silizium/FPGA, in welcher ein Teil des Kernels in Hardware implementiert ist. Bis es soweit ist, wird noch einige Zeit vergehen. Um Dinge besser zu verstehen, versuche ich x86 an meine Vorstellungen anzupassen. Ich mache keine VM. Der Emulator in Java is nur der erste Schritt um die Funktionalität zu implementieren.

Hm, ja, da war ich nicht aufmerksam. Ich hatte außerdem deine Pastebin-Dokumente noch nicht gelesen, was ich jetzt nachgeholt habe. Ich finde den ganzen Aufschrieb ein bisschen konfus, um ehrlich zu sein. Mein größtes Problem ist, dass du zwischen sehr verschiedenen Ebenen hin- und herspringst, ohne überhaupt mal das große Ganze beschrieben zu haben.

Aber gut, wenn ich mich mal an das hier gepostete halte, an welcher Stelle kommt der x86-Mikrokernel ins Spiel? Willst du den Userspace auf deiner Architektur x86-kompatibel halten, dass du das ganze auf x86 probelaufen lassen kannst oder wie?

Ich hoffe das Prinzip:
Java-> Import -> Semantic Code -> Export -> Bootbares Image
ist nachvollziehbar.

Das steht so nirgends, aber immerhin weiß ich jetzt, was ich mit dem Import/Export anfangen soll. Unter diesem Semantic Code kann ich mir noch nichts vorstellen, das ist für mich im Moment einfach eine Zwischensprache, wo Magie passiert. Da wären ein paar Beispiele schön, dass man sich was konkretes drunter vorstellen kann.

Ich kenne RISC bisher nur aus Dokumenten/Spezifikationen (IBM Power, Sun SPARC, HP PA-RISC), fühle mich jedoch definitiv von den Eigenschaften überzeugt. Speziell die Many-Core-Varianten (60+) haben es mir angetan.

Die haben aber eher viele Register und nicht gar keine.

Was ist denn der Grund, dass du auf Allzweckregister komplett verzichten willst? Ich halte das grundsätzlich für keine besonders gute Idee, weil der Compiler (bzw. dann wohl "Exporter" in deiner Terminologie) sich nicht um eine optimierte Registerallokation kümmern kann, sondern der Cache automagisch versucht rauszufinden, was grad ein Register (also im Cache) sein muss und was nicht.

Andersrum gefragt: kann ich nur mit der Seitennummer aus dem Page Directory und dem Offset direkt auf physikalischen Speicher zugreifen? (Page Tables nutze ich erstmal nicht). Da meine Speicherverwaltung nur Virtuelle Adressen zurückgibt, brauche ich wohl kein LEA?

Auf x86 arbeiten alle Instruktionen auf virtuellem Speicher. LEA hat damit nichts zu tun, das berechnet eine virtuelle Adresse, keine physische. Zum Beispiel legen beide folgenden Zeilen den gleichen Wert nach eax:

Code: [Auswählen]

mov %edx, %eax
lea (%edx), %eax
Man kann damit natürlich alle möglichen Adressierungsarten benutzen, also mit Displacement, Index, Skalierung. "Interessante" Anwendungsmöglichkeiten gibt es auch noch, wenn man gar keine Adressen nimmt, sondern es beispielsweise einfach als Drei-Operanden-add benutzt.

Was bedeutet mehrere Threads per Core?

Meinst du im Kontext von Hyperthreading? Dann wären es logische CPUs.

[Dimension]

Ich werde mich morgen ausführlicher auf die Posts eingehen. Zuerst muss ich leider feststellen, dass ich immer wieder merke, dass bestimmte Sätze, welche ich schrieb wenig bis gar keinen Sinn machen, bzw. einzelne Bezeichnungen ungeschickt gewählt sind. Möglicherweise kann ich besser programmieren als formulieren??? Abgesehen davon bin ich heute nicht sehr konzentrationsfähig.

(Page Tables nutze ich erstmal nicht). Da meine Speicherverwaltung nur Virtuelle Adressen zurückgibt

Äh, das ist ein Widerspruch in sich.

nein, ich meinte page directory entries (PDE), sagt Wikipedia.

[kevin]

Du meinst, du benutzt 4-MB-Pages, nehme ich an.

[Dimension]

Du meinst, du benutzt 4-MB-Pages, nehme ich an.

korrekt.

[Dimension]

@taljeth:
Ich habe eben deinen früheren Post gelesen und will noch mal darauf eingehen.

Wenn du sowieso nur x86 nachbaust, wäre es nicht vielleicht eine Option, die heutige Hardwarevirtualisierung (SVM/VMX) für deine VM zu nutzen? Was gewinnst du damit, überhaupt eine VM zu haben, im Vergleich dazu, den Code direkt auf der Hardware laufen zu lassen?

In der Tat habe ich bereits darüber nachgedacht, VTx für die Virtualisierung einzelner Prozesse zu verwenden. Allerdings mehr als (redundante) Sicherheitsvorkehrung. Irgendwie muss ich Treibern (im Usermode-Prozess in Ring 3) gestatten auf Speicher, I/O Ports (bzw. Ring-0 Instruktionen ?) zuzugreifen. Da das mit einer White-List geschehen soll, müsste ich hier eine art Abstraktionsschicht vorsehen, welche jedoch für die Treiber transparent und auf x86 spezialisiert bleibt. Die Idee, VTx zu nutzen habe ich zurückgestellt, da mir dort die Kosten (Komplexität, Mehraufwand) im Vergleich zum Nutzen (Sicherheit) zu hoch sind. Abgesehen davon werde ich natürlich das fertige Image in einer VM testen und, so bald es möglich ist, darin einen Editor starten und von da an innerhalb des neuen Systems entwickeln.

Aber gut, wenn ich mich mal an das hier gepostete halte, an welcher Stelle kommt der x86-Mikrokernel ins Spiel? Willst du den Userspace auf deiner Architektur x86-kompatibel halten, dass du das ganze auf x86 probelaufen lassen kannst oder wie?

Die Software, die in den Prozessen läuft kommt ausschließlich aus Semantic Code, dieser wiederum wird entweder von Java/C++ importiert und/oder im semantischen Editor geschrieben. D.h. Software kommt ausschließlich als source code. Beschreibung gibts im Brainstorm zu Semantic Code (siehe meinen Post weiter oben).

Ich kenne RISC bisher nur aus Dokumenten/Spezifikationen (IBM Power, Sun SPARC, HP PA-RISC), fühle mich jedoch definitiv von den Eigenschaften überzeugt. Speziell die Many-Core-Varianten (60+) haben es mir angetan.

Die haben aber eher viele Register und nicht gar keine.

Das ist richtig. Mir gefällt dieses Prinzip, will aber noch weiter gehen. Ein Register ist ja quasi nur ein Speicherplatz für temporäre Werte, welcher sich durch seine schnelle Verfügbarkeit auszeichnet. Was wäre, wenn nun der gesamte RAM quasi als Register funktioniert. Damit wäre die Integrität der Daten bei einem Taskwechsel immer gewährleistet, auch ohne Zurückschreiben. Jeder Prozess könnte seinen eigenen Cache bekommen, in dem er seine häufig verwendeten Daten speichert. Der Vorteil von Semantic Code ist hierbei, dass die Abhängigkeiten von Daten über mehrere Prozesse/Threads statisch analysiert werden können.

Ich bin mir im Klaren darüber, dass es bezüglich der Zugriffszeit eine große Diskrepanz zwischen Zugriffen auf ein Register, respektive den RAM gibt.

Hierzu noch 2 Dinge:
Speicherinhalt, Datenobjekt: z.B. Int32, String, Vektor, Klassenobjekt, ... . Diese werden anhand ihrer Speicherklasse (Größe, power of 2) in fixed size Arrays gehalten. Jeweils eine Speicherklasse verwendet pro Prozess ein oder mehrere Pages. Somit enthält eine Page nur Objekte einer Speicherklasse. Zu jedem Datenobjekt gehört eine eindeutige (lineare?) Adresse.
Klassenobjekt, Liste, Speicherstruktur: Die Properties in Klassenobjekten sind Verweise auf andere Datenobjekte. Ein Identifier.Properity wird beim Zugriff von der Speicherwaltung zu einer (linearen?) Adresse aufgelöst. Dies geschieht durch Hash Tables. Jede Speicherstruktur basiert auf Hash Tables, wobei jede Struktur eine eigene Hash Table besitzt. Identifier.Property sind nur für eine Struktur eindeutig. Es gibt allerdings noch einige Vorkehrungen zu treffen bezüglich der Organisation von Strukturen und Hash Tables, weswegen ich mich zuerst auf fixed Export, also feste Adressen konzentrieren werde.
Edit: werde das erst in Java testen


@erik, Svenska: Eure Posts werde ich wohl noch mal gründlich lesen, vielen Dank dafür. Ich werde doch einen relativ flachen Stack anlegen, für Interrupts und 2 Tasks. Usermode in Ring 0 ist leider keine Option. Ich werde mich nun erstmal wieder mit dem Opcode-Assembler beschäftigen, vielleicht ein paar Operationen implementieren und mich dann wieder melden.

[bluecode]

Aber gut, wenn ich mich mal an das hier gepostete halte, an welcher Stelle kommt der x86-Mikrokernel ins Spiel? Willst du den Userspace auf deiner Architektur x86-kompatibel halten, dass du das ganze auf x86 probelaufen lassen kannst oder wie?

Die Software, die in den Prozessen läuft kommt ausschließlich aus Semantic Code, dieser wiederum wird entweder von Java/C++ importiert und/oder im semantischen Editor geschrieben. D.h. Software kommt ausschließlich als source code. Beschreibung gibts im Brainstorm zu Semantic Code (siehe meinen Post weiter oben).

Die Beschreibung ist ehrlich gesagt völlig unklar. Es fängt eigentlich schon beim Namen an: Was soll "semantic code" sein? Jeder Code hat Semantik (= Bedeutung), sonst ist der Code an sich nutzlos (gilt aber für jede Sprache). Was ich mir so vorstellen könnte das du meinst:
* eine tolle neue Programmiersprache mit deinen Lieblingsfeatures
* einen tollen neuen Editor der semantic highlighting macht (wie zB kdevelop, siehe hier)
* in Anlehnung an das semantic web eine Art wie man sich aus vorhandenen Services, einer formalen Beschreibung was diese tun und einer formalen Beschreibung was die Zielanwendung tun soll, automagisch (durch Herleitung innerhalb eines logischen Kalküls) die Zielanwendung konstruiert wird
* ein modellgetriebener Ansatz zur Softwareentwicklung, bei der ausgehend von zB einem UML-Model source code generiert wird, d.h. die semantik des UML-Models wird in Code der Zielsprache mit der gleichen Semantik gegossen

[Svenska]

Ich halte ein Betriebssystem, bei dem jede Anwendung im Source-Code vorliegen muss außerhalb gewisser Elfenbeintürme für unsinnig.

[Dimension]

Ich konnte die letzten Tage dazu nutzen, den Opcode-Assembler zu erweitern und einen Wrapper für die Strukturen der diversen x86-Speicherverwaltungs-Tabellen zu schreiben. Bei den Strukturen brauche ich aber noch eine Rückmeldung, da ich mir nicht sicher bin, ob alle Felder richtig übersetzt wurden (Adressierungsarten, Little Endian). Die Instruktionen aus ExportOpcode.java habe ich testweise in eine Binärdatei geschrieben, disassembliert und das Ergebnis in den Listings hochgeladen.

Wer nicht gerade Ski fahren, Geschenke auspacken oder Feuerwerk zünden muss, kann sich das ja mal ansehen: http://forum.lowlevel.eu/index.php?topic=2948.msg34275#msg34275

Edit: Für das Listing der FPU Speicherzugriffe (misc) habe ich versehentlich 2x storeFloat(true) für Integer-Werte verwendet, was in FIST resultiert, die Option für Float-Werte fehlt dort im Listing.
Btw: In meinem Buch konnte ich keinen Opcode zur Instruktion FST mit 80-Bit Registern finden, weshalb ich auf FSTP ausweichen musste.

[Dimension]

Musste gerade feststellen, dass ich in den vorherigen Posts vermehrt den Begriff "Bytecode" verwendet habe. Mir war der Unterschied zwischen Bytecode und Maschinencode nicht bewusst, aus dem Kontext geht hoffentlich hervor, dass ich x86-Maschinencode meinte.