FAT12

Read, write, delete, mkdir, move, format — all in C, no assembly.

Every FAT12 tutorial on the internet stops at "read a file" — assembly-only, dead links, code that hasn't compiled since 2009. This book goes all the way: from a raw sector to a complete, dual-platform FAT12 implementation. 11 chapters, ~1500 lines of C, one evolving codebase that compiles zero-warning on your machine and boots as a 32-bit kernel in QEMU.

✅ All C, no assembly
FAT table walking, directory parsing — all of it

✅ Complete operations
Read, write, delete, mkdir, move, format

✅ 12-bit packing finally explained
Diagrams + step-by-step C for straddling entries

✅ Portable to your kernel
Same code runs in CLI tool and QEMU

✅ Verified at every step
Hexdumps and fsck.fat checks, not assertions

✅ Compiles zero-warning
GCC — no 2009-era bit-rot to patch through

Buy on Leanpub Read Free Sample (PDF)

Leanpub sample includes chapters 1–4 — including the 12-bit FAT packing chapter. No email required for the PDF.

🔒 Backed by Leanpub's no-questions-asked refund policy · free updates for life

What makes this book different

Visual, byte-accurate diagrams

Every on-disk structure comes with a color-coded field map — no guesswork, no "offset 27 stores the first cluster, trust me." Here's the chapter every FAT12 forum thread is really asking about: 12-bit entries packed across byte boundaries, in little-endian byte order. Most tutorials wave their hands here. This book walks a real worked example by hand, cluster by cluster, until the bit math actually clicks:

From Chapter 4 — decoding clusters 5, 6, and 7 of a real file's cluster chain, byte by byte.

What's Inside

11 chapters across three parts, ~1500 lines of C, one evolving codebase from first sector read to full format:

How it's built

One FAT12 library, two platform frontends. The exact same src/fat12.c compiles unmodified into a CLI tool on your machine and into a 32-bit kernel booting in QEMU — only the BlockDevice underneath changes, from a file descriptor to raw ATA port I/O.

Clean C, no magic — copied straight from Chapter 2. Here's the core typesystem your FAT12 driver starts with:

#pragma pack(push, 1)

typedef struct {
    uint16_t bytes_per_sector;
    uint8_t  sectors_per_cluster;
    uint16_t reserved_sector_count;
    uint8_t  num_fats;
    uint16_t root_entry_count;
    uint16_t total_sectors_16;
    uint8_t  media;
    uint16_t fat_size_16;
    uint16_t sectors_per_track;
    uint16_t number_of_heads;
    uint32_t hidden_sectors;
    uint32_t total_sectors_32;
} BPB;

#pragma pack(pop)

And here's the payoff — a real terminal session against a freshly formatted disk image:

$ ./build.sh
$ ./fat12-cli mkdir /DATA
$ ./fat12-cli mkdir /DATA/CONFIG
$ ./fat12-cli write /DATA/CONFIG/SETTINGS.TXT settings.txt
$ ./fat12-cli cat /DATA/CONFIG/SETTINGS.TXT
verbose=true
$ fsck.fat -n disk.img
fsck.fat 4.2 (2021-01-31)
disk.img: 4 files, 3/4067 clusters

Who is this for?

You — if you're building a hobby OS and need a filesystem driver. You know C (pointers, structs, bit manipulation) and want a complete FAT12 implementation you can drop into your kernel. Small, 1–4 MiB disk images mean every structure fits in a handful of sectors you can hexdump end to end — no dependencies beyond a C compiler.

Frequently Asked Questions