std.fs.exfat — exFAT lesen

import std.fs.exfat;

Liest exFAT-Dateisysteme: Bootsektor auswerten, Clusterketten verfolgen, Verzeichnisse durchlaufen, Dateien lesen. Nur lesend.

exFAT teilt mit FAT32 den Namen und die Grundidee — Cluster, eine Zuordnungstabelle —, aber kaum ein Strukturfeld. Deshalb eine eigene Unit und kein Zweig in std.fs.fat.

→ Die Dateisystem-Sammlung · std.fs.fat · Guide: Fremde Dateisysteme lesen

• Sektor- und Clustergröße stehen als Zweierpotenz-Exponent im Bootsektor, nicht als Zahl: 9 heißt 512 Byte, 3 heißt 8 Sektoren je Cluster. Wer die Zahlen direkt liest, bekommt eine Sektorgröße von 9 Byte und rechnet ab da alles falsch — unauffällig, denn die Adressen bleiben plausibel.
• Keine feste Wurzel, keine 8.3-Namen. Namen sind UTF-16 und stehen in eigenen Eintragssätzen.
• Zusammenhängende Dateien stehen gar nicht in der Tabelle. Sie tragen das Kennzeichen NoFatChain; ihre Cluster folgen einfach aufeinander, und ein Blick in die FAT liefert dort nichts.
• Ein Verzeichniseintrag ist ein Satz aus mehreren Einträgen: Dateieintrag (0x85), Stromeintrag (0xC0) und so viele Namenseinträge (0xC1), wie der Name braucht.

pub type ExfatVolume = struct {
  fd:             int64;
  partOffset:     int64;   // Byte-Versatz des Volumes im Deskriptor
  bytesPerSector: int64;   // schon aus dem Exponenten gerechnet
  sectorsPerClus: int64;
  fatOffset:      int64;   // Sektoren
  fatLength:      int64;   // Sektoren
  heapOffset:     int64;   // Sektoren
  clusterCount:   int64;
  rootCluster:    int64;
  numFats:        int64;
  gueltig:        bool;
}

pub type ExfatEntry = struct {
  attr:       int64;
  cluster:    int64;
  size:       int64;
  isDir:      bool;
  noFatChain: bool;   // Strom liegt zusammenhängend, die FAT ist unbeteiligt
}

pub type ExfatDir = struct {
  cluster:    int64;
  sectorInCl: int64;
  entryInSec: int64;
  fertig:     bool;
  sekPuffer:  int64;
}

byteOffset kommt üblicherweise aus ''PartByteOffset''.

Bei Dateien mit noFatChain wird die Kette nicht gebraucht: die Cluster folgen aufeinander. ExfatReadFile berücksichtigt beide Fälle.

Bitmap, Upcase-Tabelle und Datenträgerkennung werden übergangen — sie sind keine Dateien. Wer sie mitliefert, hat in jedem Verzeichnislisting drei Geistereinträge.

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

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

    var vol: ExfatVolume := ExfatMount(fd, 0);
    if (!ExfatValid(vol)) { PrintLn("kein exFAT"); close(fd); return 1; }

    var name: int64 := alloc(300);
    var d: ExfatDir := ExfatDirOpen(vol, vol.rootCluster);
    var e: ExfatEntry;

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

    ExfatDirClose(vol, d);
    free(name, 300);
    close(fd);
    return 0;
}

Nur lesen — aus denselben Gründen wie bei FAT, und hier noch etwas mehr: exFAT verlangt beim Schreiben zusätzlich die Pflege der Belegungsbitmap und Prüfsummen über jeden Eintragssatz.

Prüfstand: tests/exfat_test.sh — 42 Prüfungen gegen ein erzeugtes Abbild.

Letzte Aktualisierung: 2026-09-05 — Seite neu angelegt; erhoben aus std/fs/exfat.lyx (#1922).