Topic domain
Filesystems
Naming, persistence, and crash-safe storage layout.
- Articles
- 80
- Clusters
- 8
- Foundational
- 24
- Intermediate
- 32
- Advanced
- 24
Inodes, directories, and the POSIX interface.
- What an Inode Stores, and Why It Stores No Name
- Directory Entries as a Name-to-Inode Map
- Open File Descriptions and the Offsets They Share
- Rename Atomicity and the Replacement of a Directory Entry
- Sparse Files and the Gap Between Length and Allocation
- Path Resolution Component by Component
Ordering guarantees and metadata updates.
- Write Ordering and the Crash Window Between Metadata Updates
- Write-Ahead Journaling and the Three-Phase Commit Record
- Metadata-Only Journaling and the Three ext3 Data Modes
- Torn Writes, Journal Checksums, and Detecting a Bad Commit
- Copy-on-Write and Block Shadowing Instead of a Log
- Path Copying in a Copy-on-Write B-Tree
Append-only layout and garbage collection.
- The Log as the Filesystem: Segments, Sequential Writes, and the End of the Free-Space Map
- Inode Maps and Block Indirection: Finding Data That Never Stays in Place
- Checkpoint Regions and Tail Recovery in an Append-Only Log
- Segment Liveness Accounting: How the Cleaner Knows What Is Already Dead
- Choosing What to Clean: Greedy, Cost-Benefit, and Age-Ordered Segment Policies
- Decomposing Write Amplification in Log-Structured Filesystems
Remote semantics, caching, and locking.
- NFS File Handles and the Server That Keeps No Open Files
- Retransmission and the Duplicate Request Cache
- Attribute Caching and Close-to-Open Consistency
- Unstable Writes, COMMIT, and the Verifier
- Byte-Range Locks and What Happens When a Client Dies
- Delegations, Callback Channels, and Recall
FTL behavior, discard, and I/O schedulers.
- Erase Blocks, Pages, and the Asymmetry That Shapes Flash Storage
- Mapping Granularity in a Flash Translation Layer
- Garbage Collection and Where Write Amplification Comes From
- Wear Leveling and the Erase-Cycle Budget of a Flash Device
- Discard and TRIM: Telling the Device Which Blocks Are Free
- Multi-Queue Block Dispatch and Why One Lock Was Not Enough
Erasure coding, replication, and placement.
- Failure Domains and the Arithmetic Behind Replication Factor
- Consistent Hashing and What Changes When a Node Joins
- Reed-Solomon Codes: The k-of-n Arithmetic and Its Repair Cost
- Quorum Intersection and Why R + W Must Exceed N
- Merkle Trees, Range Digests, and Finding Divergence Without Reading Everything
- CRUSH Placement: Deterministic Mapping Over a Weighted Hierarchy
On-disk formats and kernel interfaces.
- The Superblock: Magic Number, Geometry, and Feature Flags
- Block Groups and the Cost of Metadata Locality
- Inode Tables and the Arithmetic of Inode Numbers
- Extent Trees and the Replacement of Indirect Block Maps
- Directory Hash Trees: Indexing Names Without Breaking Enumeration
- VFS Objects and the Operation Vector
Checksums, scrubbing, and silent corruption.
- Silent Data Corruption and What Device Error Reporting Misses
- Checksum Strength: What CRC32C and SHA-256 Each Guarantee
- Checksum Placement: Block Pointers, Metadata Trees, and Payloads
- Read-Path Verification and What Happens When a Block Fails
- Checksum Granularity and the Read-Modify-Write Penalty
- Scrub Passes: Finding Latent Damage Before It Is Needed
All Filesystems articles
- Oct 20, 2026 fsck and the Ordering of Repairs Why the consistency passes run in a fixed order, how each pass builds the data the next one needs, and why some findings can only be resolved by discarding data.
- Oct 19, 2026 Hash Trees and the Root of Trust in a Checksummed Filesystem Why per-block checksums need a chain to a single trusted value, how Merkle trees make tampering localisable, and what the root itself has to be protected against.
- Oct 17, 2026 Zoned Block Devices and the Zone Append Model How zone semantics replace the random-write abstraction with explicit sequential-write regions, what append buys, and which costs move from the device to the host.
- Oct 8, 2026 Reading a Directory as a Stream: readdir and Its Weak Guarantees Directory listing is a cursor over mutable records, not a snapshot; what the offset cookie means, which entries can be missed or repeated, and why sorting requires reading everything first.
- Sep 29, 2026 Failure Domains and the Arithmetic Behind Replication Factor How a copy count becomes a durability estimate, why that estimate collapses when failures correlate, and what placement must do to keep the arithmetic honest.
- Sep 23, 2026 Unstable Writes, COMMIT, and the Verifier A write may be acknowledged before the server has put the data on stable storage. The reply says how stable it is, and the client decides whether to ask for a commit — a decision that trades latency against the risk of losing an acknowledged write.
- Sep 16, 2026 Erase Blocks, Pages, and the Asymmetry That Shapes Flash Storage Why NAND programs a page once and erases a whole block, and how that mismatch forces every layer above the device to maintain a mapping and a collector.
- Aug 27, 2026 VFS Objects and the Operation Vector The four in-kernel objects every filesystem must supply, the function table each one carries, and how a single open() call ends up in a filesystem-specific method.
- Aug 20, 2026 Attribute Caching and Close-to-Open Consistency Every stat over the network is a round trip, so clients cache attributes with short leases and validate them on reuse. The guarantee that emerges is not POSIX coherence but a weaker promise tied to open and close.
- Aug 6, 2026 CRUSH Placement: Deterministic Mapping Over a Weighted Hierarchy How a pseudorandom placement function turns an object identifier and a cluster map into a device list, why straw selection replaced simpler bucket types, and what changes on topology edits.
- Jul 28, 2026 Mounting: From Device Node to a Live Superblock The sequence a filesystem driver follows when it is handed a block device, the checks that must pass before the volume becomes writable, and what a failed mount must unwind.
- Jul 20, 2026 Consistent Hashing and What Changes When a Node Joins Why modulo placement reshuffles almost every key on a membership change, how a hash ring limits the movement, and where the ring still concentrates load.
- Jul 7, 2026 Checksum Strength: What CRC32C and SHA-256 Each Guarantee The detection guarantees a cyclic redundancy check actually provides, the different guarantee a cryptographic hash provides, and the cost of moving from one to the other.
- Jun 26, 2026 Copy-on-Write and Block Shadowing Instead of a Log How never modifying a reachable block replaces journal replay with a root pointer swap, and what the tree-copying cost buys in atomicity.
- Jun 22, 2026 Garbage Collection and Where Write Amplification Comes From Why reclaiming an erase block copies live pages, how the victim-selection policy sets the copy cost, and the closed-form relation between free space and amplification.
- Jun 11, 2026 Choosing an I/O Scheduler and Setting Queue Depth What an elevator can still do on a device with no seek cost, the difference between the none, mq-deadline, and Kyber schedulers, and how queue depth controls latency.
- Jun 8, 2026 Segment Liveness Accounting: How the Cleaner Knows What Is Already Dead Maintaining a live-byte count per segment as blocks are superseded, why the count must be exact rather than sampled, and how indirect blocks make the decrement easy to get wrong.
- May 25, 2026 Checksum Blind Spots: Misdirected Writes and Lost Updates The fault classes that survive a correct checksum, from acknowledged writes that never landed to corruption introduced above the filesystem, and the ordering machinery each one needs.
- Apr 11, 2026 Self-Healing Reads: Reconstructing a Copy From Redundancy How a filesystem repairs a damaged block during a read, what the repair costs on mirrored and parity layouts, and why the repair itself can fail.
- Apr 9, 2026 Scrub Passes: Finding Latent Damage Before It Is Needed What a scrub actually reads and in what order, why it must walk metadata rather than sweep the device, and how a pass is throttled so it does not starve foreground I/O.
- Mar 25, 2026 Path Resolution Component by Component The walk behind every open: how a pathname is split, when symlinks are expanded, how mount points and dot-dot interrupt the tree, and where the interface allows a race.
- Mar 19, 2026 Delayed Allocation and the Reservation Window Why holding back the block-allocation decision until writeback makes layout better and failure later, and how a per-file reservation prevents the space from being promised twice.
- Mar 13, 2026 Open File Descriptions and the Offsets They Share Three separate kernel objects stand behind a file descriptor, and knowing which one carries the offset explains dup, fork, append mode, and why two opens of one file disagree about position.
- Mar 7, 2026 Inode Tables and the Arithmetic of Inode Numbers How a fixed-size inode record is found from its number with one division, why the table is preallocated rather than grown, and what happens when the number of inodes runs out before the space does.
- Jan 28, 2026 End-to-End Protection Information and Where the Checksum Stops How T10 protection information moves a checksum onto the wire with the data, what the guard, application tag, and reference tag each defend, and why the host still needs its own check.
- Jan 20, 2026 The Page Cache and the Writeback Path Where a written byte actually lives before it reaches the device, how dirty pages are tracked and flushed, and why write() returning does not mean the data is on disk.
- Jan 5, 2026 Checksum Placement: Block Pointers, Metadata Trees, and Payloads Where a filesystem can store a block checksum, why the pointer is usually the right home for it, and how each placement choice changes what a torn write can do.
- Dec 24, 2025 Permission Checks at Open and the Bits That Change Meaning The mode word is consulted once, at open, against the whole path; umask, the sticky bit, setgid inheritance, and default ACLs each bend the rule in a way that surprises the caller.
- Dec 13, 2025 pNFS Layouts: Separating the Metadata Path from the Data Path A parallel NFS layout is a grant from the metadata server to read and write directly from storage devices it does not control. The layout type, the layout state, and the recall of a layout determine what the client can do without asking.
- Dec 5, 2025 The Degraded Window: Rebuild Rate, Exposure, and the Second Failure How the time between a device loss and the completion of its rebuild becomes a durability multiplier, and why the repair rate cannot be set independently of it.
- Nov 20, 2025 Inode Maps and Block Indirection: Finding Data That Never Stays in Place How a log-structured filesystem locates an inode whose address changes on every write, what the map costs per lookup, and why its cache is the deciding factor in read latency.
- Nov 20, 2025 Logical Block Size, Read-Modify-Write, and Misaligned I/O Why a device with 4 KiB pages can still accept 512-byte sectors, what that emulation costs internally, and how alignment and atomicity guarantees interact.
- Nov 14, 2025 Durability Barriers, Flushes, and What fsync Actually Waits For The storage-stack path a flush traverses, why a drive cache that ignores it voids every journal guarantee, and what a directory fsync must order.
- Nov 10, 2025 Grace Periods and Reclaiming State After a Server Restart A server that keeps open state loses it on reboot, while its clients still believe they hold locks and delegations. The grace period is the interval in which only reclaims are accepted, and its length is a bet on how fast clients notice.
- Oct 9, 2025 The Log as the Filesystem: Segments, Sequential Writes, and the End of the Free-Space Map Why writing every block at the end of a log converts scattered small updates into large sequential transfers, and what replaces the allocator once nothing is ever overwritten in place.
- Sep 26, 2025 Soft Updates and Dependency Ordering Without a Journal How FFS-style filesystems enforce partial write orders that keep metadata repairable, why cycles in the dependency graph force rollback, and what it saves.
- Sep 5, 2025 Chain Replication: Why the Head Writes and the Tail Reads How ordering replicas into a chain turns replication into a single ordered path, why reads are served at the tail, and what the head and tail failures require of the membership protocol.
- Aug 9, 2025 NFS File Handles and the Server That Keeps No Open Files A short opaque byte string replaces the path on the wire, and because it is the only identifier the server retains, every request must be self-describing. That choice explains reboot survival, silly renames, and ESTALE.
- Jul 30, 2025 Decomposing Write Amplification in Log-Structured Filesystems The four terms that add up to bytes written per byte of user data, namely cleaning copies, checkpoint rewrites, summary overhead, and segment slack, and how each responds to segment size.
- Jul 24, 2025 Merkle Trees, Range Digests, and Finding Divergence Without Reading Everything How a tree of hashes narrows a comparison between two replicas to the differing leaves, what it costs to maintain under writes, and why the leaves must align.
- Jul 22, 2025 Torn Writes, Journal Checksums, and Detecting a Bad Commit Why a commit record that exists is not proof that its transaction is intact, how checksumming the log closes that hole, and what remains undetectable.
- Jul 16, 2025 fsync, fdatasync, and What Survives a Power Loss The durability calls promise different things about data and metadata, and a file entry needs a second call on its directory; where the guarantees stop on each filesystem.
- Jul 16, 2025 Path Copying in a Copy-on-Write B-Tree How a single key update rewrites the nodes along one root-to-leaf path, why sibling splitting propagates upward, and what the node layout must guarantee.
- May 27, 2025 Copysets and the Tail of Random Placement Why uniformly random replica placement produces objects whose copies share a failure set, how many nodes one rack loss can take with it, and what bounded placement changes.
- May 26, 2025 Delegations, Callback Channels, and Recall A server can hand a client authority over a file so the client stops asking, but it must be able to take that authority back. The mechanism is a lease with a reverse direction, and its hard part is the recall path.
- May 20, 2025 Block Groups and the Cost of Metadata Locality Why a filesystem carves itself into groups with their own bitmaps and inode tables, what the descriptor table records, and how allocation policy turns locality into seek distance.
- May 8, 2025 Mapping Granularity in a Flash Translation Layer Page-level, block-level, and hybrid address mapping, the DRAM each one costs, and how a controller rebuilds its table from page spare areas after power loss.
- Apr 30, 2025 The Circular Log: Head, Tail, and the Distance Between Them How an append-only log wraps around a finite volume, the segment state machine that makes wrapping safe, and why the gap between the write head and the reclaim frontier sets the achievable throughput.
- Mar 25, 2025 Quorum Intersection and Why R + W Must Exceed N The arithmetic that guarantees a read sees the latest write, how sloppy quorums break it, and what read repair has to do to restore the guarantee.
- Mar 11, 2025 Data Temperature and the Cost of Cleaning Mixed Segments Why placing hot and cold data in the same segment forces the collector to copy live cold bytes to reclaim dead hot bytes, and how write segregation by expected lifetime bounds that cost.
- Feb 4, 2025 Silent Data Corruption and What Device Error Reporting Misses Why a read can succeed and still return the wrong bytes, how drives separate correctable from uncorrectable errors, and which corruption classes no device is able to report.
- Jan 26, 2025 Read-Path Verification and What Happens When a Block Fails The ordering constraints a verifying read must satisfy, the error classes a mismatch can be sorted into, and why retrying a failed checksum is usually pointless.
- Jan 16, 2025 The Superblock: Magic Number, Geometry, and Feature Flags How a filesystem announces its own layout at a fixed disk offset, why its feature bits are split into three classes with different contracts, and what a driver does when it meets a bit it does not understand.
- Dec 31, 2024 Repair Traffic in Erasure-Coded Sets and What Regenerating Codes Change Why rebuilding one fragment costs k fragments of reads, how the repair bandwidth bound is derived, and what local parity and regenerating codes buy against it.
- Dec 9, 2024 Directory Entries as a Name-to-Inode Map A directory is a file whose records map names to inode numbers, with a fixed record shape, a reserved pair of names, and a deletion policy that leaves gaps behind.
- Nov 25, 2024 Extent Trees and the Replacement of Indirect Block Maps What an extent record actually encodes, why the inode-sized root makes small files free of external metadata, and how the tree splits when a file fragments.
- Nov 7, 2024 Metadata-Only Journaling and the Three ext3 Data Modes What the data=journal, data=ordered, and data=writeback modes each guarantee about file contents after a crash, and why the ordered mode costs a dependency the other two avoid.
- Sep 27, 2024 Multi-Queue Block Dispatch and Why One Lock Was Not Enough The single-queue block layer, the contention that replaced it, and how software queues, hardware queues, and tags carry a request from submit to completion.
- Sep 9, 2024 Checksum Granularity and the Read-Modify-Write Penalty How the size of the region one checksum covers sets both the precision of damage reporting and the cost of small overwrites, and why 4 KiB sectors made granularity a hard constraint.
- Sep 6, 2024 Discard and TRIM: Telling the Device Which Blocks Are Free How discard requests travel from the filesystem to the device, why they are advisory, what a secure erase adds, and the cost of queuing them badly.
- Aug 5, 2024 Transaction Groups, Checkpointing, and Reclaiming Journal Space Why a committed transaction cannot free its journal space until its blocks are in place, and how checkpointing turns the log into a fixed-size ring.
- Jul 12, 2024 Cache Flush, FUA, and What a Write Completion Means How a device with a volatile write cache reorders writes, what a flush and a force-unit-access write each promise, and why the barrier is only as good as the drive.
- Jun 9, 2024 Hard and Soft Mounts: What a Client Does When the Server Stops Answering A hung server turns every file operation into an indefinite wait. The mount option decides whether the client retries forever, gives up with an error, or interrupts the call, and each choice moves the failure somewhere else.
- May 22, 2024 Choosing What to Clean: Greedy, Cost-Benefit, and Age-Ordered Segment Policies The three classical segment selection rules, the objective function each one optimizes, and why weighting freed space by the age of the data beats always cleaning the emptiest segment.
- May 15, 2024 Byte-Range Locks and What Happens When a Client Dies The server owns the lock, the client owns the local enforcement, and neither can see the other side. That split explains lock leasing, the difference between local and NLM locking, and why a dead client blocks a range until the server notices.
- May 8, 2024 Credentials on the Wire and Identity Squashing The client asserts who the caller is on every request, and the server decides whether to believe it. That decision is where network filesystems diverge from local permission checking, and where the root account becomes the recurring problem.
- Mar 14, 2024 Cleaner Interference and Foreground Latency in Append-Only Storage How a background collector steals device queue slots from the write path, why the resulting latency spikes are bursty rather than average, and the throttling and scheduling measures that bound them.
- Mar 4, 2024 Reed-Solomon Codes: The k-of-n Arithmetic and Its Repair Cost How a Reed-Solomon code turns k data fragments into n, why any k reconstruct the whole object, and what the encoding matrix demands of the arithmetic.
- Dec 20, 2023 Rename Atomicity and the Replacement of a Directory Entry How rename changes two directory entries without a window of invisibility, which cross-filesystem cases the guarantee excludes, and why the call is the primitive behind atomic file updates.
- Dec 16, 2023 Write-Ahead Journaling and the Three-Phase Commit Record How a journal turns many unordered block writes into one atomic transaction, why the commit block must be a single sector, and how replay stays idempotent.
- Nov 23, 2023 Checkpoint Regions and Tail Recovery in an Append-Only Log How a log-structured filesystem bounds what a crash can lose, and how it reconstructs the segment summaries written after the last durable checkpoint by scanning forward instead of backward.
- Nov 13, 2023 Wear Leveling and the Erase-Cycle Budget of a Flash Device How erase counts are tracked, what dynamic and static leveling each accomplish, and why the endurance rating is a property of the worst block rather than the average.
- Oct 16, 2023 Garbage Collection Under Space Pressure: When Cleaning Cannot Outrun Writes What happens when a log-structured volume fills to the point that the collector must run in the foreground, why the reclaim rate collapses near full, and the reserved-capacity arithmetic that prevents it.
- Oct 14, 2023 Snapshot Reference Counts and Why Deleting One Costs So Much How a snapshot is a copied root plus shared blocks, how per-extent reference counts make sharing safe, and why removal requires walking what it owned.
- Oct 2, 2023 Write Ordering and the Crash Window Between Metadata Updates Why a filesystem that issues correct writes in the right order can still be corrupt after a power loss, and how ordering constraints, atomicity, and recovery strategies separate.
- Mar 14, 2023 Directory Hash Trees: Indexing Names Without Breaking Enumeration How a hashed b-tree stores directory entries in blocks while preserving the linear order readdir requires, and how a fake dirent hides the interior nodes from a reader that does not know about them.
- Jan 23, 2023 Retransmission and the Duplicate Request Cache A lost reply is indistinguishable from a lost request, so a client resends and a server must decide whether the operation already ran. The reply cache is the mechanism that turns at-least-once delivery into at-most-once execution.
- Jul 14, 2022 Unlink While Open and the Life of an Orphaned Inode Removing the last name does not free a file that is still open; how the link count and the description reference interact, and why deleted files keep consuming disk.
- May 19, 2022 Sparse Files and the Gap Between Length and Allocation A file can report a length of terabytes while occupying a few blocks, and the interface keeps the two numbers separate; seeks into the gap, hole punching, and the copy that silently fills it.
- Mar 21, 2022 What an Inode Stores, and Why It Stores No Name The inode is the object a filesystem calls a file: its fields, what it deliberately omits, how stat exposes it, and why a full inode table can refuse a write on a filesystem with free space.