striped + mirror
Derived by hand from the Linux md rule — how the pages are sourced
The striped mirror of RAID 10 on an odd number of disks: every chunk is stored on two disks and the chunks are dealt across all of them, with the second copy of a chunk wrapping to the next stripe where the count does not divide. It keeps half the space and is guaranteed to survive one failure.
RAID 1E is the pair striped + mirror on an odd number of disks: the data is cut into chunks and dealt across the members (striping), and every chunk is stored on two different disks (mirroring), exactly as in RAID 10. What changes is only the count. With an even count the two copies of every chunk fit in the same stripe, side by side; with an odd count one chunk per stripe has no room left for its copy, and the copy goes to the first disk of the next stripe. The two copies are still on two different disks, and no disk holds both copies of any chunk.
In Linux md it is not a level of its own. The RAID10 driver accepts the odd count: "the number of devices in a RAID10 array need not be a multiple of the number of replica of each data block; however, there must be at least as many devices as replicas", and with five devices and two replicas "space equivalent to 2.5 of the devices will be available, and every block will be stored on two different devices". The wrap is the near placement algorithm doing what it always does: the driver fills the disks from left to right, stripe by stripe, with a stream in which every chunk appears twice, and when the stream reaches the last disk it continues on the first disk of the next stripe.1
The name is the controller vendors'. Adaptec's white paper Choosing the Right RAID defines it as the level that "combines data striping from RAID 0 with data mirroring from RAID 1", where "data written in a stripe on one drive is mirrored to a stripe on the next drive in the array", and sums it up: "in effect, RAID 1E is a mirror of an odd number of drives". Its figure of a three-drive array is, cell for cell, the grid under Segmentation below. On IBM's ServeRAID controllers a RAID 1E array "can contain only an odd number of drives between three (3) and nine (9)"; Adaptec puts the minimum at three and, "for scenarios with four or more drives", recommends RAID 10. So one layout carries two names, and the count decides which: even is RAID 10, odd is RAID 1E.
md it is RAID 10 with an odd count, and any md system runs it. On a hardware controller it exists only where the vendor offers it, under the vendor's name: Adaptec and IBM ServeRAID controllers do, and a controller that offers RAID 10 alone refuses the odd count.The rule is the near layout's, written for two copies. The legend first, then the rule, then the chunk of the example that wraps.
N the number of disks
c the chunk number, counted from 0
d the disk of the first copy d = (2 × c) mod N
s the stripe of the first copy s = (2 × c) div N
second copy: the next disk, d + 1, in the same stripe;
when d + 1 = N, disk 0 of the next stripe, s + 1
N = 3, c = 1: d = 2 mod 3 = 2, s = 2 div 3 = 0 → first copy on disk 2, stripe 0
d + 1 = 3 = N → second copy on disk 0, stripe 1With an even N the number 2 × c is never one short of a multiple of N, so the wrap never happens and the copies pair up: that is RAID 10. With an odd N it happens once every N chunks.
Three disks is the minimum, and it is a matter of the count's parity, not of what the driver accepts: two disks is an even count, which is RAID 10's shape, and two copies on two disks is a plain mirror, a RAID 1 by another name. Nothing collapses here; below three the array is another level.
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 1E array of 3 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 1E · 3 disks · near
disk 0 disk 1 disk 2
stripe 0 D0 D0' D1
stripe 1 D1' D2 D2'
stripe 2 D3 D3' D4
stripe 3 D4' D5 D5'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, 3 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 = 3 disks of 2 TB, 2 copies → (3 ÷ 2) × 2 TB = 3 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 1E array, and what each of them does with the level.
Some of the level's placement algorithms exist only on one engine:
RAID 1E has nothing below its minimum of 3 disks: drivers/md/raid10.c setup_conf(): no bound on the device count beyond copies ≤ raid_disks — 3 devices start; 2 is an even count, RAID 10's shape.
RAID 1E is the interleaved striped mirror used when the disk count is odd (so the chunks cannot pair into clean 2-copy stripes as flat RAID 10 does). The placement is the slot-stream "near" layout (md raid10 near with odd disks): copy k of chunk c lands at disk (c*2+k) mod N, so a chunk and its copy always sit on different disks, derived by hand from raid10.c's near layout at three disks.
Open this example in the sandbox
A desktop link: on a phone or in a narrow window the sandbox is not offered.