1. Start with the Familiar Assumption

When you open your computer's file explorer, you see your documents organized neatly:

It is natural to assume that these files are written directly onto the storage disk in the same way they are represented on your screen.

But this mental model is incorrect.

Fundamentally, a physical storage device has no concept of a "file," a "directory," a "path," or "file permissions." If you inspect the copper lines of an NVMe drive or the magnetic platter of a hard disk, you will not find folders or names.

A raw storage device provides only a flat sequence of addressable sectors. Every structure—from files to directories—is a virtual arrangement created and maintained entirely by operating system software.

2. Reveal the Storage Stack

To bridge the gap between human concepts and physical hardware, operating systems organize storage into a layered hierarchy called the Storage Stack:

* Application: Requests file operations using path names (open("/home/user/notes.txt")). * Logical File: Exposes the file stream to applications, hiding block offsets. * Filesystem: Translates paths into internal IDs (inodes/MFT records) and maps logical offsets to LBA storage block sectors. * Partition / Volume: Defines the boundaries of a raw disk space allocated to a single logical driver. * Block Device Interface: The operating system subsystem that manages block-oriented command flows. * Physical Storage Media: The actual hardware sectors that store charge states or magnetic orientation.

3. Raw Storage

At the lowest level, a storage device is a flat array of addressable slots called Logical Block Addresses (LBAs):

At this raw layer, files like notes.txt or photo.jpg do not exist. There are only index numbers. The OS reads or writes data by specifying the exact block index (e.g. "Read LBA block 120").

The filesystem is the organization layer that compiles these raw addresses into a structured digital workspace.

4. Formatting / Creating a Filesystem

Creating a filesystem—often referred to as formatting—is the step that establishes these directory and index tables on the raw storage media.

Formatting does not necessarily mean overwriting every single sector of the physical disk with zeros (which is a "Full Format"). Instead, a standard format simply initializes the master filesystem index tables, rendering the rest of the block addresses as empty space ready for reuse.

5. Partitions and Volumes

Before writing a filesystem index, raw disks are usually divided into independent virtual zones called partitions:

A partition represents a designated range of consecutive physical sectors reserved on the disk (e.g. LBA 00 to 47). This boundary allows a single storage drive to host multiple operating systems, separate configurations, or isolate user data from system binaries.

6. EdgeCase: From Raw Device to Filesystem

Use the simulator below to track how raw blocks are virtualized step-by-step into partitions, initialized with metadata indexes, and layered with file abstractions:

7. Important Distinction: Partition vs Filesystem

Understanding the boundary between partitions and filesystems is essential:

* Partition: Answers: Which sectors of the physical media belong to this volume boundary? It is defined by partition tables (like GPT or MBR) written at the start of the drive. * Filesystem: Answers: How should the sectors within this partition be structured into directories, metadata tables, and files?

A partition sets the physical playground limits; a filesystem establishes the rules of the game played inside.

8. Mounting

To make a filesystem accessible to applications, the operating system must attach it to its logical namespace—a process called mounting:

* Unix / Linux: Attach filesystems into a unified directory tree. For example, Partition 1 (/dev/nvme0n1p1) might be mounted at /, while a USB drive is mounted at /media/usb. * Windows: Exposes mounted partitions using drive letters (C:, D:) or paths.

Mounting takes the self-contained block structures of a filesystem volume and plugs them into the active directory structure.

9. Real Operating-System Connection

Production kernels use abstraction layers to ensure applications can access different filesystems uniformly:

* Linux (Virtual File System - VFS): VFS acts as a common interface layer. When an application calls read(), VFS intercepts it and translates the request into the appropriate filesystem driver call (e.g. ext4, FAT, or NTFS), which in turn requests data blocks from the device driver. * Windows (I/O Manager & Filter Drivers): A similar stack manages I/O requests, sending them down through filesystem filter drivers to logical volume managers and port drivers.

The layered architecture ensures that application developers write programs targeting files, rather than hardcoding disk sector commands.

10. HDD vs SSD/NVMe

The physical media underneath the block interface dictates how fast blocks can be read and written:

Hard Disk Drives (HDDs) Store data magnetically on spinning platters. Because a mechanical read head must physically travel to specific sector tracks, HDDs suffer from high latency (seek time and rotational delay) and perform sequential accesses much faster than random ones.

Solid State Drives (SSDs) Store data in flash memory cells. Since there are no moving parts, random reads are extremely fast. However, writes require erasing blocks before they can be rewritten, which requires internal wear leveling and block relocations.

NVMe SSDs Use the high-speed PCI Express (PCIe) bus rather than old SATA controller pathways, allowing thousands of parallel command queues to reduce I/O bottlenecks.

Regardless of the underlying hardware technology, the filesystem presents the same unified file abstraction to the operating system.

11. The Next Question

We have now crossed the boundary from files and filesystems into the storage device itself.

But storage requests do not all arrive in the same order, and on some devices the physical cost of serving those requests can be enormous.

When many storage requests are waiting, how should the operating system decide which one to serve first?