Snapshots and their limits
Point-in-time copies, copy-on-write chains and consistency: what a snapshot is and is not.

A snapshot is a reference to the state of a storage object at one instant, not a copy of its data. The blocks live at that moment are kept; a later write goes elsewhere. That makes it almost free to take — and the origin of every limit that follows.
snapshot = references to the blocks live at one instant, not a copy of them
origin volume (live) snapshot @ T0
+----------------+ +----------------+
| block A |------------------>| -> same A |
| block B |------------------>| -> same B |
| block C |------------------>| -> same C |
+----------------+ +----------------+
write B after T0: copy-on-write keeps the old B for the snapshot
+----------------+ +----------------+
| block A |------------------>| -> same A |
| block B' (new)| | -> old B kept |
| block C |------------------>| -> same C |
+----------------+ +----------------+
cost so far = space for B' and its metadata, never a second full volume
What a snapshot is: a reference, not a copy
The OpenZFS documentation calls a snapshot “a read-only copy of a file system or volume at a point in time”, and gives the reason it is cheap: “Because ZFS never modifies a block in place, keeping an old version of a dataset costs nothing more than a reference to the blocks that were live at that moment.” NIST SP 800-209 generalises: “A snapshot is a storage-efficient form of point-in-time copy, that stores only the individual portions of the data changed from a given point in time in reference to the source data.”
LVM behaves the same way: lvcreate -s makes a “frozen image” of an origin LV, and “The data in a new snapshot LV represents the content of the original LV from the time the snapshot was created.”
Creation is atomic in the sense that matters for time: “Snapshots are created atomically. That is, a snapshot is a consistent image of a dataset at a specific point in time; it includes all modifications to the dataset made by system calls that have successfully completed before that point in time.” Completed writes are in, in-flight writes are not.
The copy-on-write chain, and what a write costs
The mechanism that makes a snapshot cheap makes it grow: copy-on-write. The first time a block a snapshot references is about to change, the old content is preserved. An LVM snapshot keeps the changed blocks in dedicated space: “The size is allocated from space in the VG, and is the amount of space that can be used for saving COW blocks as writes occur to the origin or snapshot.” It holds “the chunks that differ from the origin LV along with metadata describing them”.
The cost is paid not at creation but by the writes that follow. ZFS states it from the other side: the live dataset “starts to account for space as the live dataset diverges and blocks only the snapshot references can no longer be freed.” The snapshot’s share grows by what those writes replaced.
Where the space goes: dedicated volumes, thin pools and the same pool
Where does the snapshot’s space come from?
An LVM copy-on-write snapshot is a separate logical volume with a size you choose, and the choice can be wrong: “often 20% of the origin LV is enough”, but it depends on how much will be written, and “If COW space runs low, it can be extended with lvextend”.
A thin snapshot removes that reservation: “Thin snapshots share the same blocks in the thin pool, and do not allocate new space from the VG”, so the safety moves to the free space of the pool.
On ZFS the snapshot is accounted from its pool and can pin far more than a nominal share: “A single old snapshot can pin an arbitrary amount of space: if a large file was deleted after the snapshot was taken, the space stays allocated until the snapshot goes away.”
Consistency: crash-consistent and application-consistent
A snapshot taken at one instant is crash-consistent: it is what the data would look like if power had been cut at that moment — completed writes present, in-flight writes not, and the application left to decide whether that state is usable. That is the guarantee in the atomic wording above, and the word Microsoft uses for the storage side: “crash-consistent volumes”.
An application-consistent copy is stronger, and the storage layer cannot make it alone: the application must be quieted and its buffers flushed first. “By using VSS snapshots, you can get application-consistent data snapshots for point-in-time recovery”. NIST SP 800-209 treats the opposite as a failure — a live database backup “performed without applying techniques to ensure consistency or write-order fidelity” — and asks that “if two components should be recovered to the same point in time to function properly, then federated consistency mechanisms or equivalent should be planned and implemented”. Separate volumes snapshotted one after another are not that set.
The limits: same storage, a growing chain, and never a backup
The snapshot lives on the same storage as the data. An LVM snapshot’s blocks are taken from the volume group; a ZFS snapshot stays in its pool. Lose that storage and the snapshot goes with it; NIST states the dependency plainly: “This often means that if the source data is unavailable, the snapshots will not be usable as well.” A fault, or ransomware overwriting the whole set, takes the snapshot too. NIST’s remedy is to keep the set small: “Obsolete snapshots and clones should be removed to reduce the attack surface.”
The chain grows, and an old link holds the rest. Later snapshots depend on blocks earlier ones still reference, so cost accumulates: on EBS, “Because snapshots are incremental, deleting a snapshot might not reduce your data storage costs.” A snapshot is not a backup. A backup survives the loss of the original; a snapshot shares its storage and fails with it. Microsoft says it outright: “A snapshot is not a full backup and can cause data consistency issues with systems that replicate data between different nodes such as Active Directory.” It can serve inside a backup scheme only if its interval and retention are chosen against the objective: NIST requires that “if the business or compliance standards require that no more than five minutes of committed data could be lost in recovery, then the snapshot interval should be five minutes or less”.
Level and prerequisites
L3 — concept-bearing, mechanism-tracing, cost-aware, limit-drawing storage copies: this sheet takes the storage view of the point-in-time copy — what it is, what it costs and where it stops — and leaves the snapshot of the machine to the virtual-machine sheet. Prerequisites are the local-storage sheet and the RAID sheet that precede it.
Where to go next
For the ZFS case in full, the sheet on ZFS pools, datasets, snapshots and scrub develops the pool accounting treated here as an example. For what a real copy is, the sheet on full, incremental and differential backup shows the restore chains, and the sheet on retention, immutability and separate copies explains why a deletable copy is not a backup. The sheet on templates, clones and snapshots handles the snapshot of a virtual machine. Area routes: Knowledge, Server and virtualization, Storage.
References
- LVM2 — lvcreate(8) — https://man7.org/linux/man-pages/man8/lvcreate.8.html — creating a copy-on-write or thin snapshot, the dedicated size in the volume group, the “frozen image” wording and the sentence that the copy reflects the original at creation time.
- LVM2 — lvconvert(8) — https://man7.org/linux/man-pages/man8/lvconvert.8.html — merging a COW snapshot into its origin, separating a snapshot from its origin (
--splitsnapshot) and merging a thin snapshot (--mergethin). - OpenZFS — zfs-snapshot(8) — https://openzfs.github.io/openzfs-docs/man/master/8/zfs-snapshot.8.html — atomic snapshot creation and the consistent image at a point in time.
- OpenZFS — Snapshots, Clones and Bookmarks — https://openzfs.github.io/openzfs-docs/Basic%20Concepts/Datasets/Snapshots%20and%20Clones.html — the cost of a snapshot as a reference, the space accounting as the live dataset diverges, and the pinned space of an old snapshot.
- Amazon Web Services — Amazon EBS snapshots — https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshots.html — point-in-time copies, the incremental behaviour, restore information and the effect of deleting one snapshot.
- Microsoft — Using checkpoints (Hyper-V) — https://learn.microsoft.com/en-us/windows-server/virtualization/hyper-v/checkpoints — the warning that a snapshot is not a full backup and can cause data consistency issues.
- Microsoft — Storage Replica overview — https://learn.microsoft.com/en-us/windows-server/storage/storage-replica/storage-replica-overview — “crash-consistent volumes” and the VSS route to application-consistent point-in-time copies.
- NIST — SP 800-209, Security Guidelines for Storage Infrastructure — https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-209.pdf — the snapshot as a storage-efficient point-in-time copy, its dependence on the source data, the interval-versus-RPO requirement, the removal of obsolete snapshots and the write-order-fidelity failure mode.