Implement FAT12 Filesystem Writer: Create Files and Update FAT

Topic Overview

Mutating FAT Tables

Writing FAT12 means updating directory entries, allocating FAT clusters, and preserving boot sector invariants. Cluster chains are singly linked through 12-bit entries packed two per byte triplet in the FAT.

Allocate and Chain

Create file workflow:

• Find free cluster from FAT scan
• Write directory entry with starting cluster
• Extend chain with 0xFF8.. 0xFFF EOC markers

For example, a 3-cluster file might use clusters 2 → 3 → 4 with FAT entries linking forward.

Why This Matters in Production

Every field you pack here , the space-padded 8.3 filename, the 0xFFF end-of-chain marker , matches exactly what tools like mkfs.fat and fsck.fat validate, and what real DOS and early Windows machines wrote to floppies for two decades. Forgetting to write the FAT back to disk after updating it in memory is a classic bug that silently corrupts the whole filesystem on the next mount.

Debugging Checklist

Before you call the implementation done, walk failure modes on purpose. Test empty structures, single-element edge cases, maximum concurrency, and errno paths that must not crash the program. OS code usually fails in production when happy-path tests pass but invariants break under contention or memory pressure.

Implementation Notes

Keep structures small and name fields after kernel counterparts when possible. That lets you read man pages and kernel source side by side while you work. Print observable events during development; remove noisy logs once tests pass reliably.

For This Exercise

You will implement create, write, and close that updates FAT and directory on disk image. The task asks you to verify round-trip by re-reading with your FAT12 reader.

Your Task

Write to a FAT12 filesystem: format an image, then create, extend and delete files. Every change has to be made in the on-disk structures: allocate free clusters from the FAT and link them into a chain ending in 0xFFF, pack the 12-bit entries into both FAT copies, write the data into the clusters, and fill in 32-byte directory entries with space-padded 8.3 names. Report "disk full" and "directory full" before changing anything.

Image layout (created by format)

512-byte sectors, 1 sector per cluster, 1 reserved (boot) sector, 2 FAT copies of spf sectors each, then the root directory (ROOT_ENTRIES × 32 bytes, a multiple of 512), then the data area. spf is the smallest number of sectors such that the FAT holds an entry for every data cluster plus entries 0 and 1: (clusters + 2) × 3 / 2 ≤ spf × 512, where clusters = TOTAL − 1 − 2·spf − ROOT_ENTRIES·32/512. FAT entries 0 and 1 are 0xFF8 and 0xFFF. The boot sector gets the usual BPB fields (as in the reader task).

FAT12 entry n occupies the 16-bit little-endian word at byte ⌊3n/2⌋ of each FAT: the low 12 bits if n is even, the high 12 bits if odd. Writing one entry must preserve the neighbouring entry's nibble.

Commands

• Allocation always takes the lowest-numbered free clusters. An empty file has first cluster 0 and no chain.
• Directory slots: the first entry whose first byte is 0x00 or 0xE5.
• Names are converted to upper case 8.3. A name with an empty base, more than 8 + 3 characters, or two dots prints COMMAND NAME: invalid name.
• Errors: already exists (write/fill), not found (append/rm/cat), directory full, and disk full (need K clusters, F free), all as COMMAND NAME: MESSAGE. Checks run in the order: invalid name, already exists / not found, directory full, disk full.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Keep the whole image in one byte array and implement get_fat/set_fat on it; set_fat updates both copies.
2. Check free space and free directory slots before the first write, so a failed command leaves the image unchanged.

Hidden tests cover deleting a file and reusing its directory slot and clusters (producing a fragmented chain), appending to an empty file, a full disk, a full root directory, an existing name and invalid names.