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
Advantages
Fault tolerance. Two members (fault tolerance), 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. RAID 6 goes through the same rebuild with one failure still tolerated.
Rebuild safety. An unreadable sector found on a survivor during the rebuild is recomputed instead of lost. This is the argument for the level, and it gets stronger as disks get larger.
Disadvantages
Capacity. All but two disks' worth (capacity): on four disks it keeps half, the same as a mirror, and only from six disks up does it beat RAID 10 on space.
Write cost. 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.
Processor cost.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).
Minimum disk count
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
Definition
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.
The grid below is the placement of a RAID 6 array of 4 disks, as the Linux md rule produces it. Each column is one disk, each row is one stripe, and each cell names the block that lands there: D followed by a number for a data chunk, and P and Q for the two parity blocks of the stripe. Reading a row from left to right shows how one stripe is dealt across the members; reading a column from top to bottom shows what one disk ends up holding.
RAID 6 · 4 disks · left-symmetric
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
Definition
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 covers.
Three quantities follow from the redundancy alone: usable capacity, fault tolerance and write penalty. Below they are worked out for the example array, 4 disks of 2 TB each. Each block states the general rule on its first line, then substitutes the numbers of the example on the lines that follow.
(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
Definition
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.
A placement algorithm decides where the parity blocks or the copies go within each stripe. The list below is the set of algorithms this level accepts, each with what it does; the one marked default is what mdadm chooses when none is named.
Left Asymmetric
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.
RAID engine
Definition
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.
The components that can be the RAID engine of RAID 6
In any given system, exactly one component holds the role of RAID engine: a hardware controller with its own processor, a firmware chip that keeps the metadata while the operating system's driver does the work, or the operating system alone. They are alternatives, not layers, so a system has one of them and not the others. The list below names the components that can hold that role for a RAID 6 array, and what each of them does with the level.
RAID Engine (RoC)
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
On the components below, a power loss during a write can leave a stripe inconsistent, because nothing protects the write cache:
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.
What happens with fewer disks than the minimum
Every level has a disk count below which it is no longer itself. For RAID 6 the kernel enforces the minimum: Linux md refuses to start it with fewer disks. The rows below give that minimum and what a smaller array would have been, had it started — the shape the minimum protects the level from becoming.
The smallest array that is a RAID 6
4 disks
The smallest array Linux md starts as RAID 6
4 disks, the same drivers/md/raid5.c setup_conf(): 'not enough configured devices (%d, minimum 4)'
What a 3-disk RAID 6 would have been
linear + mirror, the shape of RAID 1: 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
Strengths
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
Limitations
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
Use cases
Large disk arrays (more disks = higher chance of failure during rebuild)
Archival and backup storage
Any environment where data loss is catastrophic
Not suited for
Small arrays (two disks' worth of overhead hurts efficiency)