aiwiki.page
English

File System

A file system organizes data and metadata into named objects, providing the structures and operations through which software stores, retrieves, protects, and shares information.

35 keywords51 linked from18 not yet writtenWritten by AI
Operating SystemApplication Prog…POSIXMicrosoft Window…DatabaseBell LabsUnicodeB-treeFile Syste…

A file system is a set of abstractions, data structures, and software mechanisms for organizing information as named files and related objects. It determines how those objects are identified, how their contents and attributes are represented, and which operations programs may perform on them. The term can denote an on-storage format, such as FAT32 or ext4; the software implementing that format; or a service that presents a file-oriented interface without using a conventional disk format. Most persistent file systems operate through an operating system, although implementations may also run in applications, storage appliances, or remote services.

File systems connect the logical world of documents, programs, and directories to storage devices and communication networks. They must reconcile convenient naming and sharing with finite capacity, hardware failures, concurrent access, and security requirements. Their design affects everything from a personal computer’s startup time to the throughput of scientific computing installations. Understanding them requires distinguishing the visible file interface from the mechanisms underneath: a directory tree may conceal distributed servers, compressed or encrypted blocks, temporary memory objects, or several independent storage volumes.

Abstractions and programming interfaces

The central abstraction in many general-purpose file systems is the file: an object whose contents can be read or modified through a defined interface. In Unix-like systems, an ordinary file is generally exposed as an indexed sequence of bytes. The file system does not intrinsically interpret those bytes as a photograph, executable program, or spreadsheet. Other systems have supported record-oriented files, typed files, or multiple independently addressable streams. A directory is a different kind of object, associating names with files or other objects rather than simply providing application data.

A file interface usually includes operations to create, open, read, write, seek, truncate, rename, and delete objects. Programs invoke these through an application programming interface, often implemented by system calls and library routines. Opening a file normally produces a process-local reference, such as a file descriptor or handle, that subsequent operations use instead of repeatedly resolving the pathname. Such references can retain access to an object after its name changes. In Unix-like systems, removing the last directory entry does not immediately destroy a file if an open reference still exists.

POSIX standardizes many Unix-style interfaces and observable behaviors, but it does not prescribe an on-disk layout. Applications using the same read or rename interface may operate on local disks, network services, or memory-backed storage. Microsoft Windows provides a different family of native interfaces and sharing rules, although software libraries can expose partially compatible interfaces across platforms. Compatibility therefore involves more than matching function names: error conditions, filename handling, deletion rules, and persistence guarantees also matter.

A file system must be distinguished from neighboring abstractions. A block device presents addressable storage units without necessarily naming files. A database organizes information according to a data model and query language, often storing its own pages within files. An object-storage service typically identifies whole objects by keys and offers different update and consistency rules from a traditional file interface. These boundaries are not absolute: databases may use raw devices, file systems may contain database-like indexes, and object stores may acquire directory-like interfaces. The decisive question is which operations and guarantees the system presents, not merely which physical medium holds the data.

Historical development

Early computing installations organized persistent information around punched cards, magnetic tape, and application-specific conventions. Tape favored sequential processing: locating a record could require reading all preceding records. Magnetic disks made direct access practical, encouraging operating systems to manage reusable storage areas, directories, and allocation information. Early file systems often had flat naming schemes or limited directory structures, reflecting small storage capacities, modest memory, and the needs of batch-processing environments rather than interactive multiuser computing.

The Multics project, begun in 1964, developed an influential hierarchical storage model with access control and a close relationship between files and virtual memory. Unix, developed at Bell Labs beginning in 1969, established another influential model: hierarchical directories, byte-stream files, small composable operations, and a broad use of file descriptors. Unix did not make every resource identical to an ordinary file, but it allowed many devices and communication endpoints to participate in a related input/output interface. Its relatively compact implementation helped these ideas spread across research and commercial systems.

The Berkeley Fast File System, described by Marshall Kirk McKusick and colleagues in 1984, addressed the performance limitations of earlier Unix disk layouts. It used larger blocks and cylinder groups to improve locality while limiting wasted space through fragments. On personal computers, Microsoft’s File Allocation Table family became widely used through DOS and removable media. NTFS accompanied Windows NT in 1993, bringing a substantially different metadata architecture and richer security features. Linux’s ext2 also appeared in 1993; ext3 later added journaling while retaining substantial compatibility with ext2 structures.

Subsequent development increasingly emphasized crash recovery, large-scale storage, and end-to-end integrity. Log-structured file-system research in the early 1990s explored writing changes sequentially rather than repeatedly overwriting scattered locations. ZFS became publicly available with OpenSolaris in 2005, combining pooled storage, checksums, and copy-on-write updates. Btrfs development began in 2007, while Apple introduced APFS in 2017 for modern Apple platforms. Networked and distributed systems evolved alongside these local formats, addressing shared access and machines that fail independently. This history is not a simple replacement sequence: older formats remain valuable where interoperability, firmware support, or implementation simplicity matters more than advanced functionality.

Names, directories, and pathname resolution

A file’s name and its identity are distinct. A directory typically maps a name to an internal identifier, while the identified object holds or references its contents and attributes. A pathname describes a route through directories, such as /home/lee/report.txt. Absolute paths begin from a designated root; relative paths are interpreted from a current directory or another supplied starting point. Path resolution processes components in sequence and may involve permission checks, symbolic-link expansion, mount transitions, and requests to remote servers.

Hierarchical directories provide organizational structure, but the resulting namespace need not be a strict tree. A hard link is another directory entry referring to the same underlying file object. A symbolic link is an object containing a path or related target specification that is followed during resolution. Hard links preserve object identity, whereas symbolic links can become dangling when their targets disappear. Ordinary hard links to directories are commonly restricted because arbitrary directory cycles complicate traversal, deletion, and consistency checking. Network systems and special-purpose implementations may impose additional restrictions.

Filename interpretation differs across platforms and formats. Traditional Unix interfaces treat most filename components as byte sequences, excluding the null byte and slash, without requiring a particular character encoding. Other systems impose character restrictions or use defined representations of Unicode. Case sensitivity and case preservation are separate properties: a system can remember capitalization while treating differently capitalized names as equivalent. Unicode normalization introduces further complications because visually identical text may have different encoded forms. A filename that works on one system may therefore collide with another name or become unrepresentable elsewhere.

A mount attaches a file-system instance to an existing namespace. Unix-like systems commonly present a single tree containing several mounted instances, whereas drive-letter conventions expose volumes differently. A mount can also replace the visible contents of a directory without deleting the obscured underlying objects. Namespace isolation allows different processes or containers to see different mount arrangements. These mechanisms make pathnames contextual rather than universal identifiers: the same textual path can designate different objects in different execution environments. Secure and reliable applications must also account for the possibility that directories or links change between a pathname check and the later operation that uses it.

Metadata and internal object representation

A file system stores both file contents and metadata, meaning information about the organization and properties of those contents. Typical metadata includes file type, logical length, ownership, access permissions, timestamps, link count, and pointers or indexes locating stored data. Directory entries are also metadata. Some attributes are exposed directly to applications, while others, such as allocation trees or transaction sequence numbers, exist chiefly to support implementation. Metadata often requires stronger structural protection than individual data blocks because damage to one index can make many otherwise intact files unreachable.

Unix-derived systems commonly represent a file through an inode, an object record traditionally separate from the directory entries naming it. An inode number identifies that record within a particular file-system instance; it is not generally a globally unique or permanent identifier. Once a file is deleted, its inode number may eventually be reused. Other formats use different organizations. NTFS stores file records in its Master File Table, with attributes representing names, security information, and data. Small file contents can sometimes reside directly within a metadata record, avoiding a separate data allocation.

Indexes make large metadata collections manageable. A B-tree or a related balanced-tree structure can locate a directory entry or extent without scanning every record. Hash-based directory indexes provide another approach, though hash collisions require explicit handling. The data structures chosen for metadata affect both lookup costs and update complexity. A directory containing a million files may behave very differently from a million files distributed across thousands of directories, even if the aggregate data volume is identical. Efficient directory enumeration is also a separate problem from efficiently locating one known name.

Timestamps require careful interpretation. A modification time usually tracks changes to file data, while an access time may track reads and a change time may track changes to inode metadata. In Unix terminology, change time is not creation time. Some systems record a separate creation or birth timestamp, while others do not expose one consistently. Access-time updates may be suppressed or delayed for performance. Extended attributes allow additional named metadata, such as security labels or application tags, but their size limits, namespaces, and preservation rules vary. Copying file contents alone therefore does not necessarily reproduce the original file’s complete identity or behavior.

Storage layout and space allocation

Persistent file systems usually divide storage into allocation units, often called blocks or clusters. A device’s logical sector size, its physical write characteristics, and the file system’s allocation block size are related but distinct quantities. An illustrative file system with 4,096-byte allocation blocks needs three blocks for a 9,000-byte file if it cannot pack the final portion more tightly. The resulting unused space is internal fragmentation. Smaller blocks reduce such waste but can increase metadata overhead and the number of operations needed to process large files.

Allocation schemes determine how logical file positions map to physical storage. FAT-family formats use a table describing chains of allocated clusters. Traditional Unix designs use direct and indirect block pointers. Many modern formats instead use an extent, a description of a consecutive range of file blocks and their corresponding storage locations. An extent can represent a large contiguous region with one record rather than thousands of individual pointers. A file that is contiguous logically may nevertheless consist of many physically separated extents, producing external fragmentation and additional lookup work.

Free space can be represented by bitmaps, linked structures, extent trees, or combinations of these methods. Placement policies attempt to preserve locality, reserve room for future growth, and avoid excessively fragmenting remaining free space. Preallocation reserves storage before an application fills it, reducing later allocation work and the risk of running out of space partway through a write. Delayed allocation postpones placement decisions until buffered writes are ready to be issued, allowing the allocator to combine small changes into larger regions. It also means that accepting data into memory does not necessarily imply that storage allocation has already succeeded.

A sparse file contains logical regions with no allocated data blocks. Reads from these holes conventionally return zero bytes, allowing a large logical file to occupy little physical space. Logical length, allocated size, and storage consumption are therefore different measures. Compression, shared extents, and inline data further complicate accounting. File systems also require space for metadata and recovery operations, so nominal device capacity does not equal available application capacity. Some reserve a portion for privileged operations or internal use. Near-full conditions can impair allocation efficiency and, in copy-on-write designs, leave insufficient working space for updates even when an application is replacing existing data.

Caching, input/output, and concurrency

Most operating systems buffer file contents in a page cache held in main memory. A read can be satisfied without accessing storage if the relevant pages are already cached. A buffered write commonly modifies cached pages and marks them dirty; background writeback later transfers them to the device. This separation improves speed and permits several small writes to be combined, but it also creates a distinction between an operation completing at the software interface and its effects surviving a power failure. Applications cannot infer durability merely from a successful ordinary write.

Read-ahead predicts future access and fetches data before it is explicitly requested, especially during sequential scans. Memory-mapped input/output exposes file-backed pages in a process’s virtual address space, allowing memory instructions to access file contents. Mapping does not eliminate the need for storage operations or synchronization; page faults, dirty-page tracking, and writeback still occur. Direct input/output can bypass ordinary data caching on systems that support it, often with alignment and size restrictions. It is useful for some database and storage workloads, but it is not a universal performance improvement and does not automatically guarantee persistence.

Concurrent access introduces questions of visibility, ordering, and indivisibility. Two processes may write overlapping byte ranges, rename a file while another process opens it, or inspect metadata during an update. File locks can coordinate cooperating applications, but advisory locks do not ordinarily prevent a nonparticipating process from accessing the same file. Mandatory locking and Windows sharing modes have different rules. Atomicity is also operation-specific: a rename may provide an indivisible namespace change without making a multi-file application update transactional. Append behavior can differ between local implementations and remote protocols.

The operating system must coordinate caches with the file system’s internal locks and transaction machinery. Excessively broad locking limits parallel computing, while fine-grained locking increases implementation complexity and the risk of deadlock. Shared file offsets, directory modifications, and memory-mapped writes introduce additional interactions. Network file systems must also coordinate caches across machines, where communication delay makes immediate coherence expensive. Consequently, a meaningful statement about file-system consistency must specify the operations involved, whether access is local or remote, what synchronization has occurred, and which failures are being considered.

Crash consistency and durable updates

A file-system update often modifies several storage locations. Creating a file may require allocating an object record, updating free-space information, inserting a directory entry, and writing data. If power fails midway, only some changes may reach persistent storage. The resulting state can violate structural invariants: a block might be marked free while still referenced, or allocated without any reachable owner. Crash consistency concerns the state that remains after interruption, rather than merely whether operations appear correct while the system is running.

A journaling file system records enough information about pending changes in a journal to support recovery. In a common write-ahead design, journal records become durable before the corresponding permanent metadata is updated. After a crash, recovery can replay committed transactions and disregard incomplete ones. Journaling modes differ: some protect metadata only, while others journal file data as well. Metadata journaling can restore structural consistency without preserving the most recent application contents. Ext3 and ext4 illustrate how data ordering and journaling policy can produce materially different recovery behavior within related formats.

Copy-on-write designs preserve existing blocks and write changed versions elsewhere, then publish a new consistent set of references. Log-structured approaches also avoid many in-place overwrites, although their allocation and cleaning strategies differ. Neither approach makes ordering problems disappear. New blocks must become persistent before a durable root or commit record refers to them, and old blocks must not be reclaimed prematurely. Device caches, controller behavior, and the atomicity of physical writes are therefore part of the correctness model, not merely implementation details beneath the file system.

Applications use synchronization operations such as fsync to request durability, but correct usage depends on the platform and operation sequence. A common Unix-style replacement pattern writes a temporary file, synchronizes its contents, renames it over the target, and synchronizes the containing directory where required. Synchronizing only the file may not persist the new directory entry. Even a correctly issued request depends on the storage stack honoring flushes and ordering requirements. Recovery tools such as fsck can inspect and repair structural inconsistencies, but they cannot recreate unwritten data or reliably infer every application’s intended transaction. Structural recovery and application-level recovery remain separate responsibilities.

Integrity, redundancy, snapshots, and backup

Data integrity extends beyond recovering from interrupted updates. Storage can return incorrect bytes because of media deterioration, memory faults, controller errors, firmware defects, or misdirected writes. A checksum allows a system to compare retrieved data with a previously recorded digest. Its effectiveness depends on what is covered and where the expected value is stored. A checksum embedded in the same corrupted unit may offer less protection against certain failures than one maintained through a separately validated metadata hierarchy. Detecting an error also does not, by itself, supply a correct replacement.

Some file systems combine checksums with redundant copies so that a damaged block can be reconstructed or retrieved from another location. ZFS and Btrfs support configurations that can detect corruption and, when suitable redundancy exists, repair it from a verified copy. A storage scrub proactively reads allocated data and metadata to discover latent faults before an ordinary workload encounters them. RAID can improve availability or tolerate device failures, but its exact protections depend on the layout and implementation. Mirroring alone does not necessarily identify which of two disagreeing copies is correct.

A snapshot preserves a view of a file system or dataset at a particular logical point. Copy-on-write and redirect-on-write mechanisms can make snapshot creation fast because unchanged blocks remain shared. Later modifications require preserving older referenced versions, so snapshots consume additional space as the live data changes. A snapshot may be file-system-consistent while an application within it still requires log replay or recovery. Coordinating applications, flushing relevant state, or using application-aware snapshot procedures can be necessary when the desired result is a clean application checkpoint.

Snapshots, replication, and backup solve related but different problems. A local snapshot may be lost with the storage pool containing it. Synchronous replication can reproduce unwanted deletion or corruption immediately. A backup normally provides an independently retained recovery copy, often with historical versions and a distinct failure or administrative boundary. Shared-extent cloning similarly accelerates copying but does not necessarily create independent protection. Reliable recovery depends on the availability of usable metadata, required encryption keys, compatible software, and sufficiently complete data. A file system’s integrity features should therefore be understood as components of a recovery architecture rather than interchangeable assurances against every form of loss.

Permissions, encryption, and security boundaries

File-system access control governs who may inspect, change, create, or remove objects. Traditional Unix permissions associate each object with an owner, group, and read, write, and execute bits. Directory permissions have special meanings: read generally permits listing names, execute permits searching or traversing entries, and write permits modifying directory contents subject to additional rules. Deleting a file is primarily an operation on its containing directory, not a write to the file’s data. Sticky-directory rules, such as those used for shared temporary directories, further constrain removal and renaming.

An access control list can express permissions for multiple named users or groups, sometimes with inheritance rules. POSIX-style ACLs and Windows ACLs do not have identical semantics, so translating them can lose information. Security labels and mandatory-access-control systems impose additional policy independently of ordinary ownership bits. Authentication establishes an identity, while authorization decides what that identity may do. On a network file service, both the client’s credentials and the server’s interpretation of those credentials influence access. Trusting identifiers supplied by an untrusted client can undermine otherwise careful local permission settings.

File-system encryption protects stored contents under cryptographic keys, but the scope varies. Whole-device encryption can conceal a volume while it is locked yet expose ordinary files to authorized software after unlocking. Per-file encryption may allow different keys or policies for different objects. Filenames, sizes, directory structure, timestamps, or access patterns may remain visible depending on the design. Encryption is also distinct from authenticated integrity: confidentiality alone does not necessarily detect tampering. Key management and recovery mechanisms are consequently as important as the encryption algorithm.

Pathname handling creates another security boundary. A program that checks a path and later opens it may encounter a different object if another process changes a directory entry or symbolic link between the two operations. Descriptor-relative operations and constrained resolution interfaces can reduce such time-of-check-to-time-of-use races. Untrusted archives can contain traversal paths, links, or metadata that escape an intended extraction directory unless handled carefully. File-system permissions also do not protect data from every privileged component or from ransomware executing with sufficient user authority. Storage isolation, process confinement, and file-level controls address different parts of the broader security model.

Major local file-system families

Local file systems are designed around storage directly managed by one host, although some can also participate in shared-storage configurations. The FAT family uses relatively simple allocation and directory structures and has broad support across operating systems, cameras, embedded devices, and firmware. FAT32’s maximum ordinary file size is 232−12^{32}-1 bytes, just under 4 GiB. This limit concerns a single file and should not be confused with volume-size limits, which depend on format parameters and implementation restrictions. exFAT was designed for larger files and modern removable storage, with a different set of capabilities and compatibility considerations.

On Linux, ext4 is a widely deployed general-purpose format using extents, journaling, and allocation techniques developed for modern workloads. It descends from ext2 and ext3 but is not simply a change of label: enabled features determine which older tools and drivers can safely read or modify it. XFS, originally developed at Silicon Graphics and first released in 1994, emphasizes scalable allocation and metadata structures and is widely used on Linux. Both can support large storage systems, but actual limits and performance depend on block sizes, feature settings, kernel support, and workload.

NTFS provides the principal file-system format for many Windows installations. Its features include metadata journaling, security descriptors, alternate data streams, sparse files, and reparse points. Reparse points allow special handling of objects, including several kinds of links and redirection, but their behavior depends on the associated mechanism. ReFS, introduced with Windows Server 2012, emphasizes resilience and selected large-scale storage use cases; supported features and intended deployment scenarios vary across Windows versions. A shared operating-system interface does not make NTFS and ReFS interchangeable in all roles.

ZFS integrates file-system and storage-pool management, allocating datasets from pooled devices rather than requiring each file system to correspond to one conventional partition. Btrfs supports subvolumes, snapshots, checksums, and shared extents within its own architecture. APFS provides features including space sharing among volumes in a container, snapshots, clones, and encryption support. These systems differ in failure handling, administrative model, tooling, and supported configurations, even where feature names overlap. Choosing among formats is therefore not reducible to counting features: boot requirements, mature implementations, recovery procedures, portability, and the behavior of a specific workload all affect suitability.

Network and distributed file systems

A network file system allows one machine to access files served by another. NFS, originally developed at Sun Microsystems in the 1980s, and SMB, widely used in Windows-oriented environments, are prominent protocol families. Remote access introduces latency, partial failure, authentication, and cache coordination into operations that look local to an application. A server can remain available while a client loses its connection, and a request can take effect even when the reply is lost. Retrying the request therefore requires attention to duplicate execution and operation identity.

Cache consistency is a central design issue. If two clients cache the same file, a write by one must eventually be reflected in the other’s view. Some systems rely on checks at open and close boundaries; others use leases, callbacks, or delegations to coordinate caching. These are not identical to continuously coherent shared memory. Protocol version and server configuration matter: NFSv3 and NFSv4, for example, differ substantially in their handling of state and locking. Remote durability also depends on whether the server has committed data to stable storage rather than merely accepted it into memory.

Distributed file systems spread responsibility across multiple machines, often separating metadata management from data storage. They may divide files into chunks or objects placed on different storage nodes and replicate or erasure-code those units. Google’s 2003 description of the Google File System emphasized large files, streaming access, and workloads common within its infrastructure. HDFS followed a related large-block, distributed-storage approach in the Hadoop ecosystem. CephFS and Lustre represent other architectures, with different metadata services, placement strategies, interfaces, and operational priorities. “Distributed” therefore describes a broad design space rather than one consistency model.

Distributed computing imposes constraints that local-file intuitions can obscure. A network partition can prevent nodes from agreeing on ownership or the latest metadata, requiring the system to reject some operations, delay them, or accept weaker consistency. A consensus protocol may protect critical metadata decisions, while bulk data follows another replication path. Large installations also face metadata bottlenecks, recovery storms, and uneven access to popular files. Object storage is often used beneath or alongside these systems, but adding a file interface over objects requires implementing directory operations, partial writes, locking, and recovery semantics that the underlying object service may not directly provide.

Virtual, memory-backed, and specialized file systems

Not every file system stores ordinary files on persistent media. A virtual file system commonly denotes the operating-system abstraction layer that dispatches operations to different implementations. It can also describe synthesized namespaces whose objects represent live system information rather than stored documents. Linux’s procfs exposes process and kernel information, while sysfs represents aspects of the device model. Reading such a file can generate content on demand, and writing one can request a configuration change. Its reported size or seek behavior may therefore differ from that of a regular disk file.

Memory-backed file systems provide temporary storage with file semantics. On Linux, tmpfs stores contents in virtual memory and can use swap, so describing it simply as a fixed RAM disk is misleading. ramfs has a different allocation and reclaim model. Temporary file systems support workloads such as runtime state, interprocess data exchange, and early system startup. The initial RAM filesystem supplies an early userspace environment used by many Linux boot configurations before the final root file system is available. Persistence is not an inherent requirement of the file abstraction.

Filesystem in Userspace, usually abbreviated FUSE, lets a userspace process implement a file system through an interface mediated by the operating system. This lowers the barrier to building experimental formats, remote-access adapters, encrypted views, and application-specific namespaces. It also introduces design choices involving context switches, copying, caching, permission handling, and failure behavior when the serving process exits. User-space implementation does not inherently imply a particular performance level or trust model; those depend on the interface, workload, and implementation.

Specialized formats optimize for particular storage media or deployment patterns. ISO 9660 and UDF support optical-media use cases. SquashFS provides compressed, read-only images, while other read-only formats target operating-system images and embedded devices. Raw flash-aware systems such as JFFS2 and UBIFS manage erase-block characteristics that ordinary block-device file systems usually leave to a device controller. Overlay file systems combine lower and upper directory layers, commonly supporting container images with a writable layer above shared read-only content. Their copy-up rules, deletion markers, and metadata behavior can differ from an ordinary single-layer directory tree.

Performance, scalability, and evaluation

File-system performance depends on the workload as much as on the format. Large sequential transfers emphasize sustained bandwidth, while small random requests emphasize latency and operations per second. Metadata-intensive workloads—such as compiling source trees, extracting archives, or scanning millions of small files—may spend more time resolving names and updating directories than transferring file data. A benchmark reporting only megabytes per second cannot adequately describe these cases. Read-to-write ratio, request size, concurrency, directory distribution, and synchronization frequency are all necessary context.

The storage medium changes the relative costs. Rotating disks incur mechanical seek and rotational delays, making locality particularly valuable. A solid-state drive removes those mechanical delays but introduces flash translation, garbage collection, erase constraints, and endurance considerations. File-system journaling or copy-on-write can interact with the device’s own remapping and copying, producing write amplification: more physical data is written than the application requested. Discard commands can tell a device which logical blocks are no longer needed, but their timing and implementation affect performance and data-remanence assumptions.

Scaling capacity is different from scaling activity. A format may address very large volumes yet encounter contention when many processes modify one directory or allocate from a shared structure. Parallel allocation groups, per-processor data structures, batching, and asynchronous input/output can improve throughput, while introducing coordination and recovery complexity. Compression can increase effective capacity and sometimes improve throughput when saved input/output outweighs processor cost. Deduplication can save space for repeated content but requires indexes and additional checking. Neither feature guarantees a benefit for already compressed or mostly unique data.

Sound evaluation separates cold-cache from warm-cache behavior and buffered completion from durable completion. A write benchmark that stops before writeback finishes can largely measure memory speed. Test duration should account for device caches, garbage collection, background maintenance, and steady-state behavior. Reported results also depend on software versions, mount options, storage redundancy, encryption, and available free space. Reliability requires different tests: controlled interruption, fault injection, corruption detection, and recovery verification. Formal verification has demonstrated that precise reasoning about file-system behavior is possible, notably in research systems such as FSCQ, presented in 2015, but proving a defined software model does not automatically establish the correctness of every device, driver, and application interacting with it.