Fremde Dateisysteme lesen

Lyx kann sechs Dateisysteme lesen, ohne den Kernel zu fragen: FAT, exFAT, ext2/3/4, NTFS und SquashFS — dazu die Partitionstabelle davor. Dieser Guide zeigt, wie die Units zusammenspielen, und erklärt, warum es sechs sind und nicht eine.

→ Guides · Die Dateisystem-Sammlung · std.fs · Lyx OS: IOFS

import std.fs.part;       // MBR und GPT — wo faengt was an?
import std.fs.fat;        // FAT12/16/32
import std.fs.exfat;      // exFAT
import std.fs.ext4;       // ext2, ext3, ext4
import std.fs.ntfs;       // NTFS
import std.fs.squashfs;   // SquashFS 4.0

Ein Programm, das ein Dateisystem selbst liest, braucht kein Betriebssystem darunter, das es schon eingehängt hat. Das ist der Unterschied zwischen „ich lese eine Datei„ und „ich lese eine Datei aus einem Abbild“:

• Forensik und Wiederherstellung — ein Abbild untersuchen, ohne es einzuhängen und dabei zu verändern.
• Bare-Metal und Lyx OS — dort gibt es keinen Linux-Kernel, der die Arbeit abnimmt.
• Prüfwerkzeuge — ein erzeugtes Abbild gegen die Erwartung halten, ohne Root-Rechte.
• Installer und Startmedien — auf einem fremden Datenträger nachsehen, was darauf liegt.

Alle Units arbeiten auf einem offenen Deskriptor plus Byte-Versatz. Ob dahinter eine Abbilddatei, eine Partition oder ein ganzes Gerät liegt, ist ihnen gleich.

unit main;
import std.fs.part;
import std.io;
import std.string;

fn main(): int64 {
    var fd: int64 := open("/tmp/platte.img"c, 0, 0);
    if (fd < 0) { PrintLn("Abbild fehlt"); return 1; }

    var t: PartTable := PartScan(fd, 512);
    if (!PartValid(t)) { PrintLn("keine Partitionstabelle"); close(fd); return 1; }

    PrintLn(StrConcat("Schema: ", IntToStr(PartSchema(t))));

    var i: int64 := 0;
    while (i < PartCount(t)) {
        var e: PartEntry;
        PartGet(t, i, e);
        PrintLn(StrConcat(StrConcat("  #", IntToStr(i)),
                          StrConcat("  Versatz ", IntToStr(PartByteOffset(t, i)))));
        i := i + 1;
    }

    PartFree(t);
    close(fd);
    return 0;
}

Der Rückgabewert von PartByteOffset ist genau das zweite Argument von FatMount, ExfatMount, Ext4Mount, NtfsMount und SquashMount. Damit hängt die Kette:

var off: int64 := PartByteOffset(t, 0);
var vol: Ext4Volume := Ext4Mount(fd, off);

Die Namen folgen demselben Schnitt (…Mount, …DirOpen, …DirNext, …FindPath, …ReadFile), der Aufbau dahinter ist jedes Mal ein anderer:

Eine gemeinsame Oberschicht müsste all das unter einen Hut zwängen und verlöre dabei genau die Eigenheiten, auf die es beim Lesen ankommt. Deshalb: sechs Units, ein gemeinsames Namensmuster, keine erzwungene Abstraktion.

Jede davon ist still — das Programm läuft weiter und liefert plausible, falsche Zahlen:

Alle diese Fälle sind in den Units behandelt — die Tabelle steht hier, weil sie erklärt, warum der Code an manchen Stellen umständlicher aussieht, als er sein müsste.

Am Beispiel ext4; bei den anderen Formaten heißen nur die Bezeichner anders.

unit main;
import std.fs.ext4;
import std.alloc;
import std.io;
import std.string;

fn main(): int64 {
    var fd: int64 := open("/tmp/ext4.img"c, 0, 0);
    if (fd < 0) { return 1; }

    var vol: Ext4Volume := Ext4Mount(fd, 0);
    if (!Ext4Valid(vol)) { PrintLn("kein ext-Dateisystem"); close(fd); return 1; }

    var wurzel: Ext4Inode;
    Ext4ReadInode(vol, EXT4_ROOT_INO, wurzel);

    var name: int64 := alloc(300);
    var d: Ext4Dir := Ext4DirOpen(vol, wurzel);
    var e: Ext4Entry;

    while (Ext4DirNext(vol, d, e, name, 300) > 0) {
        PrintLn(StrConcat(name as pchar, StrConcat("  Inode ", IntToStr(e.ino))));
    }

    Ext4DirClose(vol, d);      // erst das Verzeichnis …
    Ext4InodeFree(wurzel);     // … dann der Inode
    free(name, 300);
    close(fd);
    return 0;
}

• Sie schreiben nicht. Bei FAT wäre die Pflege beider FAT-Kopien nötig, bei exFAT zusätzlich Belegungsbitmap und Prüfsummen, bei ext3/ext4 und NTFS die Journalführung — und ein Schreiber, der das Journal nicht führt, macht aus einem Absturz einen Datenverlust. SquashFS ist von Haus aus nur lesbar.
• Sie hängen nichts ein. Es entsteht kein Mountpoint und kein VFS-Eintrag; die Units lesen Strukturen, mehr nicht. Unter Lyx OS macht das Einhängen der Kernel (→ ''sys_mount'', ''sys_mount_part'').
• Sie raten nicht. Was nicht umgesetzt ist — die doppelt indirekte Blockzuordnung in ext4, komprimierte Attribute in NTFS, xattr in SquashFS —, wird gemeldet. Still das Falsche zu liefern wäre schlimmer als die Meldung.
• Namen werden nach ASCII gelesen; alles darüber wird zu ?.

Jede Unit hat einen eigenen Testlauf gegen echte, im Test erzeugte Abbilder — nicht gegen Attrappen:

Letzte Aktualisierung: 2026-09-05 — Seite neu angelegt; erhoben aus std/fs/*.lyx, Beispiele gegen lyxc 1.2.2A übersetzt.

Prüflauf 2026-09-05 mit doku-pruefer.py (Repo-Compiler lyxc 1.2.2A): 7 Vollprogramme der Sammlung, 7 übersetzen, 0 echte Fehler; 53 Aufrufe gegen die pub fn-Signaturen gehalten, 0 Abweichungen.