Lyx OS – Systemarchitektur

Diese Seite beschreibt den Aufbau von Lyx OS: die Schichten vom UEFI-Boot bis zum Ring-3-Userspace, das Speicherlayout, die Kernel-Module und die Syscall-Grenze.

→ Übersicht · Syscall-ABI · Kernel-Interna

1. Systemschichten

┌─────────────────────────────────────────────────────┐
│  Ring-3 – Userspace                                 │
│  Anwendungen, Shell — kompiliert mit lyxc            │
│  Interaktion: ausschließlich via SYSCALL-Instruktion │
├─────────────────────────────────────────────────────┤
│  Syscall-Gate (Ring-0 / Ring-3 Grenze)              │
│  SYSCALL/SYSRET — rax = Syscall-Nr, rdx = Rückgabe  │
├─────────────────────────────────────────────────────┤
│  Ring-0 – Lyx-Kernel (Lyx-Sprache)                  │
│  PMM · VMM · Exceptions/IDT · SMP · Process         │
│  ATA · FAT32 · VFS · Keyboard · Sync                │
├─────────────────────────────────────────────────────┤
│  UEFI-Bootloader (NASM, boot.asm)                   │
│  PE32+-Binary — BOOTX64.EFI                         │
├─────────────────────────────────────────────────────┤
│  UEFI-Firmware (OVMF)  /  PC-Hardware               │
└─────────────────────────────────────────────────────┘

2. Boot-Ablauf

Der Bootloader (bootloader/boot.asm, NASM, ~2900 Zeilen) ist ein PE32+-Flat-Binary. UEFI lädt es als BOOTX64.EFI und ruft efi_main(ImageHandle, SystemTable) auf (MS x64 ABI).

Schritte:

Begrüßung über UEFI ConOut
Kernel laden — \\kernel.elf vom UEFI SimpleFileSystem lesen
ELF64 parsen — PT_LOAD-Segmente mappen, BSS nullen
UEFI Memory Map holen, ExitBootServices aufrufen
GDT laden (64-Bit Code 0x08, Data 0x10)
COM1 initialisieren (0x3F8 — serielle Debug-Ausgabe)
SYSCALL-MSR (IA32_LSTAR) auf den Ring-0-Einsprungpunkt setzen
Page Tables aufbauen (Identity-Map 4 GB)
Bump-Allocator ab physisch 0x2000000 (32 MB) initialisieren
Sprung in Kernel-Entry (pub fn main(boot_info_ptr: int64) in kernel.lyx)

3. Speicherlayout

Adressbereich	Inhalt
`0x0000` – `0x0FFF`	Null-Page (unmapped, für nil-Checks)
`0x1000` – `0x1FFFF`	Bootloader-Code (PE32+ Text-Section)
`0x100000` – `0x1FFFFF`	Bootloader-Heap / Temporäre Strukturen
`0x200000` – ~	Kernel-ELF (`PT_LOAD`-Segmente)
`0x2000000`	Bump-Allocator-Basis (Kernel-Heap)
`- 4 GB`	Identity-Map (1:1 physisch ↔ virtuell)
`0xFFFF800000000000`+	(Zukünftig: höhere Hälfte Kernel-Space)

Page-Größen:

Kernel: 2 MB Huge Pages (PDE mit PS-Bit) für die ersten 4 GB
Userspace (M5+): 4 KB Seiten für granulare Rechteverwaltung

4. Kernel-Module

Der Kernel besteht aus 11 Lyx-Units, die beim Build einzeln zu .lyu vorkompiliert und dann zu kernel.elf zusammengelinkt werden:

Modul	Datei	Aufgabe
Exceptions	`exceptions.lyx`	IDT (256 Gates), CPU-Fault-Routing, `panic`/`assert`
PMM	`pmm.lyx`	Physical Memory Manager — Bitmap-basiert, 4 GB, UEFI-Memory-Map als Basis
VMM	`vmm.lyx`	Virtual Memory Manager — PML4-Hierarchie, 2 MB Huge Pages, CR3-Operationen
Process	`process.lyx`	Prozess-Modell: `ProcCreate`, `ProcActivate`
Sync	`sync.lyx`	Synchronisations-Primitive (Mutex, Spinlock)
SMP	`smp.lyx`	Symmetric Multiprocessing — LAPIC, Trampoline-Code, AP-Startup
ATA	`ata.lyx`	ATA-Disk-I/O — Sektorweises Lesen und Schreiben
FAT32	`fat32.lyx`	Vollständige FAT32-Implementierung (~795 Zeilen)
VFS	`vfs.lyx`	Virtual-Filesystem-Layer — abstrahiert über FAT32
Keyboard	`keyboard.lyx`	Tastatureingabe (PS/2)
Kernel	`kernel.lyx`	Einstiegspunkt — initialisiert alle Module in der richtigen Reihenfolge

Initialisierungsreihenfolge in kernel.lyx:

PMM → VMM → Exceptions/IDT → SMP → ATA → FAT32 → VFS → Keyboard → Ring-3-Jump

5. Syscall-Grenze

Ring-3-Code kommuniziert mit dem Kernel ausschließlich über die SYSCALL-Instruktion (AMD64 Fast Syscall). Kein UIO, kein /proc, kein ioctl-Polymorphismus.

Register-Layout (kurz):

Eingabe:  rax = Syscall-Nummer   rdi/rsi/rdx/r10/r8/r9 = Argumente
Ausgabe:  rax = Fehlercode (0 = OK)   rdx = Rückgabewert

Fehler und Rückgabewert kommen in zwei getrennten Registern — kein Vorzeichentest, kein globales errno.
rcx und r11 werden vom SYSCALL-Mechanismus selbst überschrieben und stehen nicht als Argumente zur Verfügung.

→ Vollständige ABI-Spezifikation: Syscall-Referenz

6. Capabilities — alles ist ein fd

Lyx OS kennt keine root-Privileg-Eskalation. Jeder fd ist eine Capability: er kodiert sowohl die Ressource als auch die erlaubten Operationen (Lesen, Schreiben, Mappen, Löschen …). Capabilities können mit sys_cap_restrict nur eingeschränkt, nie erweitert werden.

Designprinzip	Konsequenz
Kein Root	Kein `chmod 4755`, kein `sudo`-Äquivalent
CLOEXEC by default	Neue `fd` werden nicht über `sys_spawn` vererbt — opt-in mit `O_INHERIT`
Ein `fd`-Typ	`fd` für Dateien, Sockets, Prozesse, AI-Sessions sind konzeptuell gleich
Alle Pfad-Syscalls nehmen `dir_fd`	`AT_CWD` als Default — keine TOCTOU-Lücken durch absolute Pfade

Letzte Aktualisierung: 2026-06-09