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 has a name of its own, RAID 1+0, and it is built in two steps. First the disks are joined in pairs, each pair a RAID 1 mirror that holds the same data on both of its disks. Then the pairs are striped together, as a RAID 0 whose members are the pairs instead of the disks. With the near layout the two constructions put every block in the same place: the grid below, read as pairs of columns, is also the grid of a RAID 1+0 on four disks. What differs is not the placement but who built the array and what else it can do. A nested RAID 1+0 is what a hardware controller builds, one mirror at a time, and it has no far or offset layout: those layouts move the copies across the pairs, and a mirror pair cannot place anything outside itself.
RAID 0+1 is the same two steps in the opposite order: first two stripes, each across half of the disks, then a mirror of the two stripes. It uses the same disks in a worse arrangement. When one disk fails, the whole stripe it belongs to is lost, because a stripe with a missing member cannot be read; the array is left with one working stripe and no copy of it. When the disk is replaced, the rebuild does not copy one disk's worth of data, as a mirror pair would, but the whole stripe, from the surviving one. In a RAID 1+0 the same failure costs one pair its copy, and the rebuild reads one disk.
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.
The grid below is the placement of a RAID 10 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 the same number with a prime mark (D0, D0') for the copy of that chunk. 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 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 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 ÷ 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
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.
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.
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 10 array, and what each of them does with the level.
Some of the level's placement algorithms exist only on one engine:
Every level has a disk count below which it is no longer itself. Linux md starts a RAID 10 with fewer disks anyway, and what runs then is a simpler level under the name of the one requested. The rows below give the smallest array that is a RAID 10, the smallest one Linux md still starts under that name, and what the array actually is at each count in between.
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: on a phone or in a narrow window the sandbox is not offered.