My kernel Paull-kernel (32‑bit x86, protected mode) already had a command line and could run built‑in commands like hew → hello world. But everything was hardcoded. To load and run external programs, I needed a real file system.

I chose FAT12 – the classic floppy disk file system. Simple, well documented, and perfect for a hobby OS.

🧱 FAT12 structure (short version)

A FAT12 disk looks like this:

1. Boot Sector (512 bytes) – contains the BIOS Parameter Block (BPB) with geometry info.
2. First FAT (File Allocation Table) – a table that tells you which clusters belong to a file.
3. Second FAT (optional, backup).
4. Root Directory – a list of files (each entry is 32 bytes).
5. Data Area – the actual file content, split into clusters (usually 512 bytes per cluster).

Names in the root directory use the 8.3 format (e.g. HELLO BIN). Each cluster is a chain: a number in the FAT points to the next cluster; 0xFFF means end of file.

🔧 Reading a file step by step

1. Read the boot sector first

The boot sector (sector 0) contains the BPB. From there I read:

• BytesPerSector (usually 512)
• SectorsPerCluster (usually 1 for floppies)
• ReservedSectors (often 1)
• NumFATs (usually 2)
• SectorsPerFAT
• RootDirEntries (224 for a standard 1.44 MB floppy)

These values tell me where the FAT, root directory, and data area start.

2. Locate the file in the root directory

The root directory starts after the boot sector and both FATs:

root_dir_sector = reserved_sectors + (num_fats * sectors_per_fat);

I load the root directory into memory and scan each 32‑byte entry. I compare the name (padded with spaces) to the file I’m looking for, e.g. "HELLO BIN".

1. Follow the cluster chain

Once I have the first cluster number from the directory entry, I read that cluster from the data area:
c

first_data_sector = root_dir_sector + (root_dir_entries * 32 + bytes_per_sector - 1) / bytes_per_sector;
cluster_sector = first_data_sector + (cluster - 2) * sectors_per_cluster;

Then I use the FAT to find the next cluster:

• Load the FAT sector that contains the entry for my cluster.

• Read the 12‑bit value (FAT12 uses 12‑bit entries).

• If the value is 0xFFF (or 0xFF8–0xFFF) – end of file. Otherwise, move to that cluster and repeat.

🐞 Problems I ran into

Wrong first sector of root directory – I forgot to add the reserved sectors. Always recalculate.

Cluster numbers start from 2 – I tried to use cluster 0 as the first data cluster. No.

Reading beyond the sector – I had to handle cases where a cluster spans two FAT sectors.

Disk geometry – The BIOS int 0x13 expects CHS (cylinder/head/sector). I had to convert LBA to CHS manually. It’s annoying but doable.

Debugging was a pain. I printed sector numbers to the screen (using video memory at 0xB8000) to see what was actually being read.
🎉 Result

Now my kernel can load a file from disk:
bash

load HELLO.BIN
Loading HELLO.BIN ... done.
Executing...
Hello from user program!

I can write small assembly programs, compile them into a raw binary, and copy them to a FAT12 floppy image. Then Paull‑kernel loads and runs them.

🔜 What’s next

• A dir command to list all files in the root directory.

• Better error handling (file not found, end of disk).

• Maybe later: support for long file names (LFN) or FAT32.

🔗 Links

• Source code of Paull‑kernel: github.com/Paullknya/Paull-kernel

• Discuss this article: Community forum

• My GitHub profile: github.com/Paullknya

Happy low‑level coding! 🦫