Der eigene Kernel
Aerona Aether OS ist ein Kernel in der eigenen Sprache .ae. Hier steht, was er kann, wo er an Grenzen stößt und was davon wirklich eingebaut ist. Er ist nicht das, worauf die Oberfläche von AetherOS läuft – das ist der Linux-Unterbau, im Simulator Windows. Der eigene Kernel läuft daneben im nachgebauten PC. Er ist das Stück, an dem sich zeigt, ob die eigene Sprache ein ganzes System tragen kann.
Auf einen Blick
Dateien Code in .ae
Zeilen
Module eingebunden
vorhandene Module abgeschaltet
Module nur als Name vorgemerkt
Bytes groß ist das Abbild – genau 64 KB
Im Ordner liegen 64 .ae-Dateien. Zwei davon, kernel_gui_installer.ae und kernel_spiel.ae, sind aber keine Programme. Es sind zwei gleiche Planungstexte eines fremden Werkzeugs, je 65 Zeilen lang, und sie werden nirgends geladen. Deshalb zählen hier nur 62 Dateien – und von den 9.865 Zeilen fallen ihre 130 weg, so kommen die 9.735 zustande. Die Unterscheidung zwischen eingebunden, abgeschaltet und nur vorgemerkt zieht sich durch die ganze Seite: Nur was die Startdatei wirklich lädt, landet im Abbild.
Die Schichten
Was im eingebauten Stand steckt – und bei jeder Schicht, wo sie aufhört. Die Aufteilung folgt dem, was jedes Betriebssystem braucht: Speicher verteilen, Programme abwechselnd rechnen lassen, Dateien ablegen, Geräte ansprechen. Wie diese Teile allgemein zusammenspielen, erklärt Wissen: Betriebssystem; hier steht, wie weit der eigene Kernel bei jedem davon ist.
Speicher
- Ein Heap, den der Start zwischen den ersten Schritten viermal auf Fehler prüft – ausgewertet wird das Ergebnis bisher nirgends
- Ein Buddy-Allokator für höchstens 16 Seiten zu je 4 KB
- Slab und
kmallocmit sechs Größenklassen von 32 bis 1.024 Bytes - Eine virtuelle Speicherverwaltung
Grenze: Die Verwaltung der Speicherbereiche und die Behandlung von Seitenfehlern sind abgeschaltet. vma_init ist darum nur ein Platzhalter. Welche fünf Speichermodule das sind, steht unten in der Tabelle „Eingebunden und abgeschaltet“.
Prozesse
- Prozess- und Thread-Verwaltung mit eigenen Kennungen
- Ein Planer nach dem Rundlaufverfahren (Round-Robin): Threads rechnen der Reihe nach und können sich schlafen legen
Grenze: Das Sichern und Wiederherstellen des Gleitkomma-Zustands beim Umschalten sind Platzhalter. Gebraucht wird dieses Sichern erst, wenn mehrere Threads im Wechsel mit Kommazahlen rechnen: Ohne es fände jeder die Zwischenwerte des anderen im Rechenwerk vor.
Dateisystem
- AetherFS, ein Dateisystem im Arbeitsspeicher: höchstens 4 Dateien und 800 Bytes Daten
- Schreibschutz, versteckte Dateien und eine Defragmentierung
- Darüber ein virtuelles Dateisystem mit ramfs und vier Dateinummern
Grenze: ext2 kommt nur als Name vor. ext2_init ist ein Platzhalter. Und weil AetherFS im Arbeitsspeicher liegt, ist nach einem Neustart weg, was dort stand – mehr dazu bei der Speicherkarte weiter unten.
Treiber
- Eine Treibertabelle mit acht Plätzen und der Schnittstellenversion 2
- Tastatur, Textbildschirm und Uhr
- Ein APM/ACPI-Treiber: erkennen, Leerlauf, Ausschalten, ACPI-Zeitgeber
- Zufallszahlen, deren Startwert aus der CMOS-Uhr kommt
Grenze: ACPI-Programme (AML) werden nicht ausgeführt, nur ihr Name wird ausgegeben. Ton, Netz, USB und Soundkarte antworten mit Platzhaltern. Was der Kernel ansprechen kann, hängt auch am Emulator: Dessen drei Netzwerkkarten schicken nichts ins echte Netz, wie die Seite zum Emulator zeigt.
Systemaufrufe
- Über den Interrupt
0x80, jeder Aufruf wird gezählt - Zwölf Nummern: exit, fork, read, write, open, close, waitpid, mmap, munmap, execve, getpid und brk
Grenze: waitpid, mmap, munmap und execve geben im eingebauten Stand nur einen Fehlercode zurück. Ein Programm kann sich also teilen, aber noch kein anderes Programm starten und nicht auf sein Ende warten – die Tabelle „Die Systemaufrufe“ führt jede Nummer einzeln.
Shell und Bildschirm
- Zwölf Befehle, vom Anlegen und Lesen bis zum Umbenennen von Dateien
- Ein Textbildschirm mit 80 × 25 Zeichen und einer Leiste mit „[ START ]“ und Uhr
Grenze: Der Befehl winrun ist ein Platzhalter: Der Lader für Windows-Programme ist abgeschaltet. Er gehört zu den 14 vorhandenen Modulen, die nicht mit ins Abbild kommen – mehr beim PE-Lader weiter unten.
Der Start, Schritt für Schritt
Vom ersten Byte des Abbilds bis zur Eingabezeile, so wie es im Quelltext von Compiler und Kernel steht. Welche Aufgabe ein Startlader allgemein hat und warum er so klein ist, erklärt Wissen: Betriebssystem. Hier die fünf Schritte des eigenen Kernels:
- Der Startlader verschiebt sich. Die ersten 512 Bytes kopieren sich an die Adresse 0x0600, legen den Stapel an und holen den Rest des Abbilds über das BIOS von der Platte nach. Mehr als 512 Bytes lädt das BIOS von sich aus nicht – alles Weitere muss der Startlader selbst holen.
- Sprung in den Kernel. Der Code beginnt bei 0x2000. Das Segment für Textausgaben zeigt auf den Bildschirmspeicher, so landet jedes Zeichen, das der Kernel schreibt, ohne Umweg auf dem Textbildschirm.
main()läuft ihre 23 Schritte ab. Zehn davon tun etwas: Heap, Seitenrahmen, Buddy,kmalloc, Dateisystem, Zufall, virtuelles Dateisystem, Systemaufrufe, Aufgaben und der Planer. Dreizehn sind Platzhalter oder leer – Netz, ext2, USB, Ton, Fenster, Treiber aus dem Konfigurationsspeicher und andere. Der Start ruft damit schon heute die Namen der späteren Teile auf – was dahinter wirklich fehlt, steht unter „Platzhalter, die mitlaufen“.- Die Eingabezeile. Auf dem Bildschirm steht „Aero“ und darunter
root#. Von hier aus nimmt die Shell ihre zwölf Befehle an. - Die Hauptschleife. Taste lesen, verarbeiten, dann mit dem Befehl
hltruhen, bis die nächste Unterbrechung kommt. Im Emulator ruht die Maschine dann jeweils 8 Millisekunden. So rechnet der Prozessor nicht im Kreis, während niemand tippt – die Seite zum Emulator zeigt, wie er das Ruhen auswertet.
Findet der Start keinen Speicher für seine Puffer – 64 Bytes für die Eingabe, 128 für den Verlauf, 12 für die Uhr –, schreibt er ERR: OOM mit dem Namen des Puffers auf den Bildschirm. Ein echter Zusammenbruch endet mit „PANIC:“ und einem angehaltenen Prozessor. So steht der Grund auf dem Bildschirm, statt dass der Kernel mit fehlendem Speicher still weiterläuft und später an einer ganz anderen Stelle scheitert.
Die Systemaufrufe
Programme bitten den Kernel über nummerierte Aufrufe um Dienste; die Namen sind die aus der Unix-Welt. Acht der zwölf haben einen echten Rumpf, vier sind Platzhalter, die „Fehler“ melden. Die Nummern sind nicht fortlaufend; manche stimmen mit dem 32-Bit-Linux überein (exit 1, write 4, getpid 20, brk 45), andere nicht. Programme für ein anderes System laufen damit also nicht. Wer die Unix-Namen kennt, weiß aber sofort, was ein Aufruf tun soll.
| Nummer | Aufruf | Stand |
|---|---|---|
| 1 | exit – beenden | echt |
| 2 | fork – sich teilen | echt |
| 3 | read – lesen | echt |
| 4 | write – schreiben | echt |
| 5 | open – öffnen | echt |
| 6 | close – schließen | echt |
| 7 | waitpid – auf einen Prozess warten | Platzhalter |
| 9 | mmap – Speicher einblenden | Platzhalter |
| 11 | munmap – Speicher ausblenden | Platzhalter |
| 12 | execve – ein Programm starten | Platzhalter |
| 20 | getpid – die eigene Kennung | echt |
| 45 | brk – Speicher erweitern | echt |
Wo was im Speicher liegt
| Adresse | Inhalt |
|---|---|
| ab 0x0500 | die Variablen, je 2 Bytes an einem festen Platz |
| 0x0600 | der verschobene Startlader |
| ab 0x2000 | der Code des Kernels |
| 0x7C00 | hierhin lädt das BIOS den ersten Sektor |
| 0x9000:FFFE | der Stapel |
| 0xB8000 | der Textbildschirm |
| 62400 bis 63200 | AetherFS, das Dateisystem im Arbeitsspeicher |
Der Emulator hebt zwischen zwei Sitzungen nur den Bereich 56000 bis 60352 auf. AetherFS liegt dahinter – nach dem Quelltext bleibt, was der Kernel dort ablegt, also nicht über einen Neustart erhalten. Ausprobiert ist das noch nicht, es folgt aus den beiden Adressbereichen. Die Adressen 0x7C00 und 0xB8000 sind keine eigene Wahl: Dorthin lädt jedes PC-BIOS den ersten Sektor, und dort liegt bei jedem PC der Textbildschirm.
Platzhalter, die mitlaufen
Zwei eingebundene Dateien, kernel_dummys.ae und kernel_dummys_2.ae, enthalten zusammen 75 Funktionen. 66 davon tun nichts, außer 0, 1 oder einen Fehlercode zurückzugeben. Sie tragen die Namen von Teilen, die es noch nicht gibt: Ton, Netz, USB, eine Registrierungsdatenbank, Fenster, Spiele und mehrere Shell-Befehle. Andere Module rufen diese Namen schon auf – kernel_main etwa audio_init und net_init, die beide nur 0 zurückgeben. Dass sie mitlaufen, heißt also nicht, dass es die Teile gibt – deshalb zählt sie diese Seite einzeln.
Funktionen in den zwei Platzhalter-Dateien
davon nur eine Rückgabe
Eine Lücke steckt nicht im Kernel, sondern im Übersetzer: Bedingungen, die mit und oder oder verknüpft sind, prüft er für x86 bisher nicht – der Teil dahinter läuft dann immer. In den 46 eingebundenen Modulen betrifft das 130 der 1.193 Zeilen mit wenn oder solange, also etwa jede neunte. Was das beim Laufen bewirkt, ist noch nicht ausprobiert. Bis das geklärt ist, gilt für diese Zeilen: Was der Quelltext sagt und was die Maschine tut, kann auseinanderliegen. Mehr dazu bei der Sprache
Die 64-KB-Grenze
Das Abbild
Der Compiler baut ein rohes x86-Programm für den Real Mode. aether.img ist genau 65.536 Bytes groß, also 64 KB. Dasselbe Abbild steckt Byte für Byte im Emulator. Ein Bauskript übersetzt echter_boot.ae und legt das Ergebnis dort ab. Die 64 KB sind keine Laune: Im Real Mode reicht ein Segment genau so weit. Der Compiler legt für den Maschinencode deshalb einen festen Puffer von 65.536 Bytes an – was nicht hineinpasst, kommt nicht ins Abbild.
Der Grund fürs Abschalten
In der Startdatei steht ein Kommentar: Optionale Teile sind abgeschaltet, damit der Code nicht über die 64 KB wächst. Er steht allerdings über 18 Namen, zu denen es gar keine Dateien gibt. Warum die 14 vorhandenen Module abgeschaltet sind, steht in der Startdatei nicht. Diese Seite nennt deshalb auch keinen – ein Grund, den niemand aufgeschrieben hat, wäre geraten.
… um Segment-Überlauf (64KB) durch echte x86-Instruktionen zu verhindern
Kommentar in echter_boot.ae
Eingebunden und abgeschaltet
echter_boot.ae bindet 43 Module direkt ein. Drei weitere holen andere Module nach: kernel_fs_2, kernel_sched_queue_2 und kernel_dummys_2. Zusammen sind das 46. Die Tabelle ordnet sie nach Aufgaben; die Namen sind die Dateinamen ohne .ae, so lässt sich jede Zeile im Ordner des Kernels wiederfinden.
| Bereich | eingebunden | abgeschaltet |
|---|---|---|
| Speicher | kernel_mem, kernel_mem_utils, kernel-mem-opt, kernel-mem-alloc, kernel-mem-io, kernel-mem-buddy, kernel-mem-slab, kernel-mem-slab-ext, kernel-mem-vmm (9) | kernel-mem-vmm-fault, kernel-mem-vmm-ext, kernel-mem-vmm-ext2, kernel-mem-vmm-ext3, kernel-mem-vma (5) |
| Prozesse | kernel_process, kernel_process_ext, kernel_task, kernel_task_helpers, kernel_task_wrappers, kernel_sched_queue, kernel_sched_queue_2, kernel_sched (8) | – |
| Dateisystem | kernel_vfs, kernel_vfs_ramfs, kernel_fs, kernel_fs_2, kernel_fs_dir, kernel_fs_defrag, kernel_apps_fs (7) | – |
| Treiber und Uhr | kernel_vga, kernel_treiber, kernel_treiber_sys, kernel_treiber_input, kernel_keyboard, kernel_keyboard_helper, kernel_input, kernel-apm-acpi, kernel_rand, kernel_time (10) | – |
| Systemaufrufe | kernel_syscall (1) | – |
| Shell und Oberfläche | kernel_term, kernel_shell, kernel_apps, kernel_app_terminal, kernel_gui, kernel_main (6) | – |
| Hilfen und Platzhalter | kernel_string, kernel_string_search, kernel_conv, kernel_dummys, kernel_dummys_2 (5) | – |
| Windows-Programme | – | kernel_win32_struct, kernel_win32_struct_ext, kernel_win32_pe, kernel_win32_api, kernel_win32_api_ext (5) |
| Daten aus Windows mitnehmen | – | kernel_migration_engine, kernel_migration_engine_ext, kernel_migration_engine_utils, kernel_gui_installer_migration (4) |
Der PE-Lader
Er sollte Windows-Programme laden, mit 16, 32 und 64 Bit. Er ist abgeschaltet, und damit auch alles, was an ihm hängt – fünf Dateien, die in der Tabelle unter „Windows-Programme“ stehen. Ein Kernel, der selbst ein 16-Bit-Programm ist, kann 32- und 64-Bit-Programme ohnehin nicht ausführen; der Emulator hätte die Befehle dafür angelegt, der Kernel nutzt sie nicht.
Die Datenmitnahme
Sie sollte beim Umstieg Daten von Windows mitnehmen, von SSH-Schlüsseln bis zu Browserprofilen. Die drei Kerndateien haben 90 Funktionen. 69 davon melden nur ein Ergebnis und tun nichts. Sie ist abgeschaltet. Mehr als drei Viertel davon sind also Hülle – der Plan ist aufgeschrieben, die Arbeit noch nicht getan.
Nirgends erwähnt
kernel_win32_mock.ae wird weder geladen noch als abgeschaltet geführt. Sie liegt im Ordner und zählt zu den 62 Dateien, taucht aber in keiner der beiden Listen der Startdatei auf.
kernel_vfs steht zweimal in der Startdatei: einmal geladen, weiter unten noch einmal abgeschaltet. Es gilt die geladene Zeile. Deshalb zählt kernel_vfs hier bei den eingebundenen Modulen und nicht bei den 14 abgeschalteten.
Nur als Name vorgemerkt
In der Startdatei stehen 97 abgeschaltete Namen. Zu 82 davon gibt es keine Datei. Sie sind Pläne, keine abgeschalteten Programme – darunter eine Krypto-Geldbörse, eine Blockchain, ein Gameboy, ein C-Compiler und ein Hypervisor. Die übrigen 15 Namen sind die 14 abgeschalteten Module und die doppelte Zeile für kernel_vfs. Die Liste zeigt, wie weit die Pläne reichen; wie viel davon je gebaut wird, sagt sie nicht.
Alle 82 Namen ansehen
kernel-panic, kernel_sched_fpu, kernel_sync, kernel_gui_window, kernel_gui_widget, kernel_gui_font, kernel_syscall_mem, kernel_syscall_proc, kernel_elf, kernel_ext2, kernel_fs_attr, kernel_treiber_scan, kernel_treiber_cmd, kernel_treiber_diag, kernel_registry, kernel_gdi, kernel_audio_sb16, kernel_pcie, kernel_usb_uhci, kernel_usb, kernel_shell_task, kernel_shell_avx, kernel_shell_fs, kernel_shell_utils, kernel_shell_diag_new, kernel_shell_net_new, kernel_shell_ext, kernel_toolchain, kernel_libc, kernel_apps_gui, kernel_filemanager, kernel_apps_paint, kernel_app_terminal_new, kernel_game_engine, kernel_app_tetris, kernel_audio_mixer, kernel_app_mines, kernel_dbms, kernel_crypto, kernel_parsers, kernel_docrender, kernel_ccompiler, kernel_math3d, kernel_rasterizer, kernel_app_3ddemo, kernel_apps_net, kernel_apps_netc, kernel_hypervisor, kernel_gui_winman, kernel_forth, kernel_scriptvm, kernel_sched_paging, kernel_sec_debug, kernel_profiler, kernel_leak_ui, kernel_usb_msc, kernel_usb_hid_parser, kernel_shell_script, kernel_shell_builtin, kernel_browser_net, kernel_css_parser, kernel_vmx_layout, kernel_virtio, kernel_containers, kernel_crypto_wallet, kernel_blockchain, kernel_wallet_nes, kernel_gameboy, kernel_retro_ui, kernel_shader_physics, kernel_scenegraph, kernel_game_tensor, kernel_layer_nn, kernel_ml_inference, kernel_asm_enc, kernel_linker, kernel_elf_wave, kernel_audio_effects, kernel_linguistics, kernel_tts_ssa, kernel_jit_cli, kernel_editor_hl
Eine Zeile in der Startdatei ist noch kein Modul. Deshalb zählt diese Seite die Namen getrennt von den Dateien. Wer nur die Zeilen zählte, käme auf 97 abgeschaltete Teile – vorhanden und abgeschaltet sind 14, der Rest ist ein Merkzettel.
Weiter
Die Sprache .ae
Programmieren auf Deutsch – und wie der Compiler das Abbild baut. Dort steht auch die Lücke bei und und oder im Einzelnen.
Ein PC im PC
Der x86-Emulator, in dem das Abbild läuft. Was er gründlich kann und was nur angelegt ist, steht dort bei jeder Gruppe.
Aufbau und Technik
Oberfläche, Linux-Unterbau und Abbild. Dort siehst du, wie klein der Kernel neben dem Rest von AetherOS ist.
