striped + mirror
Derived by hand from the Linux md rule — how the pages are sourced
Striping and mirroring in one flat array: every chunk is stored on two disks, and the chunks are dealt across all of them. It reads like a stripe, writes at a mirror's cost with no parity to compute, keeps half the space, and is guaranteed to survive one failure, more if the failures miss each other.
RAID 10 is the pair striped + mirror: the data is cut into chunks and dealt across the members (striping), and each chunk is stored twice, on two different disks (mirroring). In Linux md it is one level, not a nesting: "every datablock is duplicated some number of times, and the resulting collection of datablocks are distributed over multiple drives". Where the second copy lands is the placement algorithm, near, far or offset; near, the default, puts the two copies side by side in the same stripe, which is the same arrangement a hardware controller reaches in a different way, by striping over mirror pairs.1 That nested form, RAID 1+0, has its own page; with the near layout the two put every block in the same place, and the difference is which engine built it and which other layouts it can offer. RAID 0+1, a mirror of two stripes, uses the same disks in a worse arrangement, and its page says why.
Speed, of both kinds. A large read spans the stripe, at the combined bandwidth of all N disks; a small read has two disks to choose from; and a write costs two operations, one per copy, with no parity to read or compute (write penalty). Among the redundant levels it has the best write numbers, which is why databases and virtual machine hosts run on it (performance).
Half the space: the capacity is N ÷ 2 disks' worth, the same as a two-way mirror, whatever the count. And its fault tolerance needs the word guaranteed: the array survives one failure for certain, and a second only if it lands on a disk that does not hold the other copy of the same chunks. On four disks with two copies, the second failure lands on the partner of the first in one case out of three; on a controller's RAID 1+0 the same rule reads "one failure per pair". The number to plan on is one.
An even count of disks is the natural shape, one copy per disk per stripe. md accepts an odd count too, with the copies wrapping across stripes; that array is what the industry names RAID 1E, and it has its own page. With two disks the distinction disappears: two copies on two devices is a mirror, and the array is a RAID 1 by another name.
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.
RAID 10 · 4 disks · near
disk 0 disk 1 disk 2 disk 3
stripe 0 D0 D0' D1 D1'
stripe 1 D2 D2' D3 D3'
stripe 2 D4 D4' D5 D5'
stripe 3 D6 D6' D7 D7'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 ÷ copies) × disk size
N = 4 disks of 2 TB, 2 copies → (4 ÷ 2) × 2 TB = 4 TB usable
the members an adversary must kill, minus one
two copies of every chunk: both copies of one chunk → 2 → tolerance 1
one logical write costs
every copy is written, no parity → 2 I/Os, random or sequentialThe 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.
Read more — Placement algorithm
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.
RAID 10 is distinct from nested RAID 1+0 (a stripe-over-mirror-pairs build). The flat form (this file) is mdadm's own RAID 10 level, which supports the near/far/offset layout algorithms — none of which decompose into mirror pairs. Nested RAID 1+0 is recognized separately, as its own level.
Open this example in the sandbox
A desktop link: below the desktop breakpoint the sandbox is not offered (ADR-003).