RAID 5 with a second parity block per stripe, computed a different way, so that any two disks can fail at once. It keeps all but two disks' worth of space, survives a second failure during a rebuild, and pays for each small write with six disk operations.
What it is
RAID 6 is the pair striped + double parity: the data is dealt across the members (striping), and every stripe carries two check blocks, P, the XOR of the data as in RAID 5, and Q, a Reed-Solomon code over the same blocks (parity). Two blocks give two equations, and two equations recover two unknowns: "RAID-6 supports losing any two drives", in the words of the paper behind the Linux implementation. Which disks hold P and Q in each stripe is the placement algorithm, the same four names as RAID 5.1
What it buys
The second failure, and the second failure is not a rare event but the ordinary risk of a rebuild. A RAID 5 that has lost a disk has no tolerance left while the replacement is being written, and the writing takes as long as the disk is large; the 1988 paper's formula has that repair time in its denominator (fault tolerance). RAID 6 goes through the same rebuild with one failure still tolerated, and an unreadable sector found on a survivor during it is recomputed instead of lost. That is the whole argument for the level, and the argument gets stronger as disks get larger.
What it pays
Space and writes. The capacity is all but two disks' worth, so on four disks it keeps half, the same as a mirror, and only from six disks up does it beat RAID 10 on space. A small write must read the old data, the old P and the old Q, and write all three back: six operations for one (write penalty), the highest of any standard level. A write that covers a whole stripe pays none of the reads, as in RAID 5. And Q is arithmetic in a Galois field rather than a plain XOR, so computing it costs more processor time, which is felt on a software engine more than on a controller with an accelerator for it (raid engine).
The minimum
Four disks is the minimum, and here the kernel enforces it: raid5.c refuses to start a RAID 6 with fewer, "not enough configured devices (minimum 4)". With three the array would be a three-way mirror under another name, P and Q both equal to the single data block, which is why nothing is lost by refusing it.
Notes
The grids here draw Q on the disk before P, the DDF convention a controller follows; an array mdadm creates as left-symmetric puts Q after P. A choice of the sandbox — see the model's choices. ↩
Segmentation
How an array splits its data across its member disks. Striped cuts the data into fixed-size chunks and deals them out to every member in turn; linear writes it as one run, filling the first member before touching the next. Segmentation is about how many disks take part in one request, not about whether the data survives a failure.
disk 0 disk 1 disk 2 disk 3
stripe 0 D0 D1 Q P
stripe 1 D3 Q P D2
stripe 2 Q P D4 D5
stripe 3 P D6 D7 Q
Redundancy
How an array keeps its data readable when a member fails: by storing more than the data itself. Two techniques do it. Mirroring keeps whole copies on separate disks; parity keeps a computed summary from which any one missing block, or two with a second parity, can be rebuilt. Redundancy always costs capacity; the question is how much, and how many failures it buys.
(N − 2) × disk size
N = 4 disks of 2 TB → (4 − 2) × 2 TB = 4 TB usable
the members an adversary must kill, minus one
double parity: three members gone is one too many → 3 → tolerance 2
one logical write costs
random: read old data, old P and old Q, write all three → 6 I/Os
sequential: a full stripe computes P and Q once → 1 I/O
Algorithm
The rule that says, stripe by stripe, which member holds the parity and where the data starts, or where a mirror's copies go. The level says what is stored; the algorithm says where. Left-symmetric for the parity levels and near for RAID 10 are the defaults nearly everything uses. The choice changes speed and compatibility, not capacity or safety.
Parity rotates leftward (same direction as left-symmetric). Data fills from disk 0 each stripe, going right and skipping the parity position — it does NOT continue from where the previous stripe left off.
Left Symmetric default
Parity rotates leftward (starts at the rightmost disk, moves one position left each stripe). Data fills from immediately right of parity, wrapping around — so consecutive data segments span all disks evenly.
Right Asymmetric
Parity rotates rightward (starts at disk 0, moves one position right each stripe). Data fills from disk 0 each stripe, going right and skipping the parity position.
Right Symmetric
Parity rotates rightward (starts at disk 0, moves one position right each stripe). Data fills from immediately right of parity, wrapping around. Mirror image of left-symmetric: same sequential-read locality, opposite parity rotation direction.
Where it runs
The component that turns a RAID layout into disk operations. It owns the array's metadata, translates every request from the array's addresses to the members', writes the copies or computes the parity, and keeps serving when a disk fails. It is a role, not a fixed device: a RAID-on-Chip on a controller card, the operating system's own driver, or a boot firmware working with that driver.
A dedicated PCIe card that includes BOTH the HBA (protocol translation) AND a RAID-on-Chip (RoC) processor. The RoC computes parity, manages the stripe, and exposes one or more Virtual Drives to the OS — the OS never sees the individual physical disks. Examples: Broadcom MegaRAID, Adaptec SmartRAID.
RAID Engine (RoC, tri-mode)
A RAID-on-Chip controller whose ports speak SAS, SATA and NVMe alike (Broadcom MegaRAID 9500/9600 "tri-mode", Adaptec SmartRAID 3200). NVMe drives plug straight into it — no HBA, no SAS/SATA backplane in between — and it still builds the array itself and exposes one virtual drive to the OS. It is the one way hardware RAID over NVMe exists.
RAID Engine (metadata)
A dedicated chip placed between the HBA and the CPU (on the motherboard or near it) that owns the RAID metadata and boot firmware — no compute silicon of its own. The OS still sees individual disks (unlike hardware RAID) but uses a driver to participate in RAID operations; the actual parity computation runs on the CPU. The canonical example is Intel RST (Rapid Storage Technology) on Intel chipsets. Also known as "motherboard RAID", "BIOS RAID", or, once its wiring reveals what it is, "fake RAID".
OS — Linux
Linux operating system managing the RAID array in software. Uses mdadm (for traditional RAID 0/1/5/6/10) or ZFS (with integrated volume management and checksums). The CPU computes all parity; no dedicated hardware required.
OS — Windows
Windows operating system managing RAID in software via Storage Spaces (Windows 8+/Server 2012+) or legacy Disk Management (dynamic volumes). Storage Spaces supports mirroring, striping, and parity spaces with optional journaling for crash consistency.
The write hole
RAID Engine (metadata)
The parity for each stripe is computed on the CPU and written after the data, so a power cut between the two can leave a stripe whose parity no longer matches, and a later rebuild trusts it. This chip owns the array metadata but has no write cache of its own to protect, so on fake RAID nothing here holds the write — that job falls to a UPS.
OS — Linux
Parity is computed from the data and written as a separate step, so a power cut between the two can leave a stripe whose parity no longer matches its data — and a later rebuild recomputes a missing disk from that wrong parity without noticing. Linux md can close this write hole with a journal device, or with mdadm's --consistency-policy=ppl on RAID 5; without one, a software parity array needs a UPS or a controller with a battery-backed write cache.
OS — Windows
Parity is computed on the CPU and written as a separate step, so a power cut between the two can leave a stripe whose parity no longer matches its data — and a later rebuild recomputes a missing disk from it without noticing. Nothing on a software path holds the write until both halves are safe; a UPS, or a controller with a battery-backed write cache, is what closes the gap.
with one data block per stripe both P and Q are that block itself — every disk holds a copy algebra: P = D0, Q = g⁰·D0 = D0 — three copies; drivers/md/raid5.c setup_conf() refuses to start it
In practice
Good at
Survives any two simultaneous disk failures
Safe during rebuild: a second failure during rebuild does not cause data loss
Essential for large arrays where rebuild window risk is significant
Costs
Highest write overhead of any standard RAID level (6 I/Os per small write)
Rebuilding Q (Galois Field arithmetic) is more CPU-intensive than RAID 5
Used for
Large disk arrays (more disks = higher chance of failure during rebuild)
Archival and backup storage
Any environment where data loss is catastrophic
Not for
Small arrays (two disks' worth of overhead hurts efficiency)