RAID and backup: availability is not protection
Why redundancy keeps a system running and still loses the data — deletion, corruption.

A RAID array is built to keep answering when a disk stops. That is a claim about availability — the data stays reachable — and it is often heard as a claim about the data. The two are not the same. A redundant array is one copy spread across several disks, and damage to that copy is copied to every member. This sheet is about the gap: the events redundancy does not act on, the window in which it is weaker than its level promises, and the write hole parity levels carry until something closes it.
Availability and recoverability are different properties
AVAILABILITY RECOVERABILITY
"the service stays reachable" "the data can be brought back"
a disk stops ──► array keeps data is deleted, corrupted,
serving; the rebuild uses the encrypted or lost ──► restore
surviving members from a second, earlier copy
the array IS the copy the backup IS another copy
(spread over several disks) (made at a consistent moment,
held somewhere else)
covered: hardware failure of covered: wrong writes, silent
a defined number of disks corruption, ransomware, the
lost site, human error — and
also the disk failure above
NIST SP 800-34r1 keeps the two apart. Availability is what “ensures timely and reliable access to and use of information”, while backup is another discipline: “Backup and recovery methods and strategies are a means to restore system operations quickly and effectively following a service disruption.” It lists RAID only among the ways to keep serving: “redundant arrays of independent disks (RAID), automatic failover, UPS, server clustering, and mirrored systems”.
The SNIA dictionary sharpens it: a backup is data kept “in case the original copy of data is lost or becomes inaccessible”, and it must satisfy a condition an array never does — “a backup must be made by copying the source data image when it is in a consistent state.” A mirror is not that; it is one copy, written twice.
The events redundancy cannot see
Redundancy is arithmetic over disks. Everything the operating system writes reaches the array, applied to every member.
- Deletion and overwrite. A delete is a write: copied to every mirror side, encoded into parity. No member keeps the old value.
- Silent corruption. Damage can sit unread on a member — SNIA’s latent fault: “A failure of a system component that has not been observed because the failed aspect of the component has not been exercised since the occurrence of the failure”. Scrubbing — “A background function that reads user data and check data blocks in a storage device and relocates them if media defects or errors are found” — can repair a bad block, but a parity array without checksums cannot always tell which member is wrong (interpretation, not a quoted guarantee).
- Encryption by malware. Ransomware writes new content; the array stores it on every member.
- Loss of the site. Fire, flood, theft or a power event take the whole array at once.
- Human error. Formatting the wrong device or restoring onto the live volume is an ordinary write, replicated instantly.
None of these is a disk failure, so none is inside the property RAID adds.
Correlated failure and the rebuild window
Redundancy assumes failures arrive one at a time, independently. Hardware violates that: an enclosure, controller, power rail, firmware bug or batch can share a single point of failure — SNIA: “One component or path in a system, the failure of which would make the system inoperable”. An array tolerates a count of disk failures, not the loss of the shelf they sit in.
The assumption matters most while an array is degraded. Linux md exposes degraded as “a count of the number of devices by which the arrays is degraded”; the rebuild then reads every survivor to regenerate the spare that is “being built to replace a failed/missing device”. That window is the exposure SNIA measures as mean time to data loss: “The average time, in a large population of storage elements, from first use until a failure results in a permanent loss of user data.”
md treats one degraded state as too unsafe to start alone: “If a raid5 or raid6 array is both dirty and degraded, it could have undetectable data corruption”.
Running the array: mdadm, Storage Spaces, ZFS vdevs
What an operator builds is one of a few mechanisms, and each keeps the same boundary.
On Linux, software RAID is built with mdadm: an array is created with --level (“Set RAID level.”) and --spare-devices — “Specify the number of spare (eXtra) devices in the initial array.” — then maintained by marking a device as faulty with --fail, removing it with --remove (“remove listed devices. They must not be active.”), and adding a replacement. --replace marks a device “as requiring replacement” and rebuilds it while it stays in service; GROW mode (“changing the size or shape of an active array”) guards the reshape: mdadm “disables writes to the array while this “critical section” is reshaped, and takes a backup of the data that is in that section”.
Windows Server offers Storage Spaces, “conceptually similar to redundant array of independent disks (RAID)”: pooled drives and virtual disks of resiliency simple, mirror or parity. ZFS builds a vdev with its own redundancy, RAID-Z, “A form of RAID implemented in the open source ZFS project”; its pool and scrub model is another sheet.
None of these is a backup.
The write hole, and how it is closed
Parity levels carry a hazard: a write touches data and parity separately, and a crash between the two leaves them inconsistent. SNIA’s write hole: “A potential data corruption problem for parity RAID technology resulting from an array failure while application I/O is outstanding, followed by an unrelated member disk failure” — the array later regenerates from parity that no longer matches the data.
Linux md closes it with a per-array consistency policy: resync, bitmap — “Resync assisted by a write-intent bitmap.” — a journal, where a “journal device is used to log transactions and replay after unclean shutdown”, and for RAID 5 ppl, the “Partial Parity Log is used to close the write hole and eliminate resync”.
What to remember
- Availability is access; recoverability is content. RAID buys the first, not the second.
- A redundant array is one copy: deletion, corruption, encryption, site loss and error reach it as they reach the filesystem.
- The rebuild window is the most exposed state, and
mdwill not start a dirty, degraded parity array alone. - The write hole is closed by a consistency policy, not by hope.
Level and prerequisites
L3 — operational discontinuity: what redundancy does not cover. The reader should know what a RAID level is and what it costs in capacity and write performance; that table is the fundamentals sheet’s, not restated here. Only the SNIA vocabulary (array, member, degraded) is assumed.
Where to go next
- Server & Virtualization — this sheet’s area.
References
- NIST, SP 800-34 Rev. 1, Contingency Planning Guide for Federal Information Systems — https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-34r1.pdf — availability, backup and recovery, RAID as one of several recovery technologies.
- SNIA, SNIA Dictionary — URL not recorded in this batch — backup, write hole, scrubbing, latent fault, single point of failure, mean time to data loss, RAID-Z.
- Linux kernel documentation, RAID arrays (
md) — URL not recorded in this batch — degraded arrays, rebuild, the consistency policy and its options. mdadm(8), Linux manual page — https://man7.org/linux/man-pages/man8/mdadm.8.html — create, spare devices, fail/remove/replace, GROW mode and the reshape critical section.- Microsoft Learn, Storage Spaces overview — https://learn.microsoft.com/en-us/windows-server/storage/storage-spaces/overview — simple, mirror and parity resiliency.
- D. A. Patterson, G. Gibson and R. H. Katz, A Case for Redundant Arrays of Inexpensive Disks (RAID), SIGMOD 1988 — URL not recorded in this batch — the origin of the term (title page of the fetched copy).