About this article: This article is reviewed against the cited sources. This is source research, not lab validation. Check the stated versions and your own requirements before making changes.
It depends on how the store keeps its history. In a chain of a full backup plus incrementals, a bad block makes its own restore point and every later point on that chain unusable, and a bad block in the full backup can take the whole chain with it. In a deduplicated store where every snapshot points at shared blocks, one bad block can break every snapshot that references it, old and new alike, even though the damage is a tiny part of the data. Read your product's design before you decide how many restore points one fault can cost.
Why does the shape of the store decide the damage?
A restore point is only as good as every block it needs. What differs between products is which blocks a given point needs, and how many points share them.
Two designs are compared here:
- Chains. A full backup is followed by incrementals that store only what changed. A point is rebuilt from the full plus the incrementals up to it.
- Shared blocks. Data is cut into chunks that are stored once. Each snapshot is a list of chunks. A chunk that has not changed is referenced by many snapshots instead of being stored again.
What does a bad block do in a chain of incrementals?
Veeam documents the dependence plainly. To restore from a forward incremental chain you need the full backup file and the chain of incremental files after it. If you delete the full file, "the entire chain of incremental backup files will become useless", and if you delete an incremental before the point you want, you cannot restore, because later incrementals depend on earlier ones.
Its health check describes what happens when corruption is found rather than deletion. For a forward incremental chain:
- Corrupted metadata in the full backup file: the chain starting from that full is marked corrupted.
- Corrupted metadata in an incremental file: the system removes information about that incremental restore point and the incrementals after it.
- Corrupted VM disk blocks in the full or an incremental: the restore point holding the corrupted blocks and the incremental points after it are marked corrupted.
So the rule for chains is forward damage. Points before the fault are intact. The faulty point and every later point on the chain are affected. A fault in the full reaches the whole chain.
Forever-forward-incremental chains add a twist. When the retention limit is exceeded, Veeam injects the data blocks of the first incremental into the full backup file, so the full file moves one step forward in the chain and the first incremental is removed. The full file is therefore rewritten during normal operation. It follows that a bad block in that file affects every later point that relies on it. That is a consequence of the design described, not a sentence on the Veeam page.
Corrupted does not have to mean lost for good. The same page describes a health check retry: Veeam transports the affected blocks from the source datastore again and stores the repaired data, as a new full or incremental backup file depending on what was corrupted. That works only while the source still holds the data.
What does a bad block do in a deduplicated store?
Proxmox Backup Server states the design in its FAQ: backups are sent incrementally and deduplicated on the server, and "each backup still references all data and such is a full backup". Its technical overview says multiple indexes can reference the same chunks, "even across backup snapshots". A fixed-size chunk for a VM disk is typically 4 MiB.
The consequence is that damage is not forward only. A chunk that sits in an unchanged part of a disk is referenced by every snapshot taken since it was first stored. If that chunk is corrupt, every snapshot that lists it fails verification, old and new alike. The source code of Proxmox Backup Server shows what verification does next: it renames the corrupt chunk file to <digest>.<n>.bad, where n is a counter from 0 to 9, and marks the snapshot's verify state as failed. It also refuses to treat a failed latest snapshot as the starting point for the next backup.
restic's design document lists invariants that must hold in a correct repository, including that a snapshot "must only reference an existing tree blob" and that a reachable tree blob must only reference blobs that exist. Its check documentation says that as long as a repository is damaged, restoring some files or directories will fail.
restic's troubleshooting guide describes the repair in practice. Running the backup again can heal older snapshots "if the missing data is also contained in the new snapshot". That works only when the source still holds the data. If the content is gone from the source and from every copy, restic repair snapshots removes the inaccessible data from the snapshots, which is documented as "a limited amount of data loss", and its output lists the files whose content was removed.
How do the designs compare?
| Store design | Where a bad block hurts | Earlier restore points | Later restore points |
|---|---|---|---|
| Forward incremental chain (Veeam) | The point holding the block, and the points after it on that chain | Intact | Marked corrupted (the incrementals after the faulty point) |
| Forward chain, fault in the full | Every point on the chain | Not applicable | All affected |
| Deduplicated snapshots (Proxmox Backup Server, restic) | Every snapshot that references the block | Affected if they reference it | Affected if they reference it |
The last column for a forward chain needs care. Veeam's documentation says the incrementals after the faulty point are marked corrupted. It does not say that a later full backup is affected. Its retention page shows a second full backup, and says the first chain is removed only after the last incremental in it becomes outdated. Whether a new full is built from the old blocks or read fresh from the source depends on the type of full, so ask what your product does.
What does this look like with real numbers?
Example (illustrative): fs01 is backed up daily to backup01 for ten days.
Chain. The first full is point 1. Points 2 to 10 are incrementals. A bad block is found in point 4. Points 1 to 3 are intact. Points 4 to 10 are affected: 7 of 10 points. If the bad block is in point 1, all 10 are affected.
Shared blocks. A 200 GiB disk is stored in 4 MiB chunks. 200 × 1,024 ÷ 4 = 51,200 chunks. One unchanged chunk goes bad. That is 1 ÷ 51,200, about 0.002% of the disk. The chunk has been referenced by all 10 daily snapshots since the first backup, so 10 of 10 snapshots reference it. The size of the fault says little about the number of restore points it costs.
What do the checks actually cover?
Veeam's backup file health check "always verifies only the latest restore point in the backup chain" using a CRC for metadata and a hash check for data blocks. Blocks that only an older point needs are not listed as verified. Its default schedule is 05:00 on the last Saturday of each month.
Proxmox Backup Server verification reads the chunks of each snapshot and records the result in the snapshot's manifest, so you can see which snapshots failed. restic's check --read-data reads all pack data in the repository.
None of these replaces a restore of an older point. See the related pieces on detecting corruption and on repository checks for what each tool proves.
What should you do when you find a bad block?
- Stop deleting. restic's troubleshooting guide says to disable
forgetandprunewhile you repair, because they could remove data unexpectedly. The same logic applies to any store: do not let retention remove the last good copy of anything. - Copy first. The same guide advises a full copy of the repository, or at least the index and snapshots folders, so that a failed repair can be rolled back.
- Find the cause of the bad block. If the cause is hardware, investigate it first. restic's guide warns that otherwise the repository will soon be damaged again.
- Repair the index first if you use restic. The guide says "you must always repair the index first", and that if
restic checktells you to runrestic repair packs, you should use that command instead. Risk:restic repair indexremoves index entries for packs that are not found, rebuilds the index and deletes the obsolete index files; the way back is the copy from step 2. The guide also says it is not recommended unless the repository is actually damaged. - Run a fresh backup and check it when the source still holds the data.
- Remove unrecoverable points only when you must. Disruptive step:
restic repair snapshots --forgetrewrites affected snapshots without the missing content and removes the originals. There is no way back unless you made the copy in step 2.
Version 4.2.11-1 of the Proxmox documentation has no matching source tag. The .bad rename and the failed-latest-snapshot rule are present, with the same text, in tag v4.2.10, the newest tag, as well as on the main branch.
How should you check your own system or provider?
Ask these questions in writing:
- Is each restore point stored as a chain of increments, as a list of shared blocks, or both?
- When a block fails verification, which restore points does the product mark as failed?
- Which restore points does the scheduled check read: the latest only, or all?
- Does a new full read the source again, or is it assembled from stored blocks?
- After a failed check, does the next backup rely on the damaged point or ignore it?
- How many independent copies exist, and are they checked separately?
Read next
Related articles you may want next.
- Backup & RecoveryFinding a bad backup before the day you need itWhat hashes, signatures and sample restores detect in backups, which faults they miss, and when to treat a copy as unusable.Read article
- Backup & RecoveryChoosing the least-untrusted recovery copy after encryptionA decision order for picking a recovery copy after encryption, using reachability, time, integrity, and keys rather than the newest green job.Read article
- Backup & RecoveryWhat restic and Borg repository checks prove, and what only a restore canWhat restic check, --read-data, borg check and --verify-data actually prove, what they cost, and the restore test that covers what they cannot.Read article
Risks and limits
The Veeam behaviour described is for the forward incremental and forever forward incremental methods in build 13.1.2.57. The Proxmox Backup Server .bad rename and the rule about a failed latest snapshot come from the project's public source (main branch and tag v4.2.10), not from the user documentation, and releases may differ. Real products also differ in how they build a new full, so treat the table as the documented minimum and confirm the rest.
These commands have not been run or lab-tested.
NetLeverage includes a daily full disaster-recovery backup of each hosted server at no extra charge. Talk to an engineer.
Sources
- Forward Incremental Backup Retention Policy — Veeam, page updated 2026-01-12, accessed 17 November 2026
- Forever Forward Incremental Backup Retention Policy — Veeam, page updated 2025-08-27, accessed 17 November 2026
- Health Check for Backup Files — Veeam, page updated 2026-08-04, accessed 17 November 2026
- FAQ — Proxmox Server Solutions, date not shown, accessed 17 November 2026
- Technical Overview — Proxmox Server Solutions, date not shown, accessed 17 November 2026
- Source file src/backup/verify.rs — Proxmox Server Solutions, date not shown, accessed 17 November 2026
- Source file src/api2/backup/mod.rs — Proxmox Server Solutions, date not shown, accessed 17 November 2026
- Design — restic project, date not shown, accessed 17 November 2026
- Troubleshooting — restic project, date not shown, accessed 17 November 2026
- Working with repositories — restic project, date not shown, accessed 17 November 2026
- Source file pbs-datastore/src/chunk_store.rs, tag v4.2.10 — Proxmox Server Solutions, date not shown, accessed 17 November 2026
This article was originally published on .