RAID 10

The TechTarget RAID 10 reference captures the essential definition: “RAID 10, also known as RAID 1+0, is a RAID configuration that combines disk mirroring and disk striping to protect data. It requires a minimum of four disks and stripes data across mirrored pairs. As long as one disk in each mirrored pair is functional, data can be retrieved. If two disks in the same mirrored pair fail, all data will be lost because there is no parity in the striped sets.”¹

A “nested RAID” configuration

RAID 10 is not one of the original five RAID levels from the 1988 Patterson, Gibson, and Katz paper. Instead, it’s a “nested” or “hybrid” RAID configuration that builds on the original primitives. The LinkedIn RAID 10 reference captures the classification: “RAID 10 is a combination of RAID 1 and RAID 0. It is considered a Hybrid RAID, it is not one of the original RAID standards types. Hybrid RAID is when you combine two different types of RAID together like in this case RAID 1 and 0.”² Other nested RAID configurations include:

• RAID 50: stripe of RAID 5 sets; combines parity protection with striping.
• RAID 60: stripe of RAID 6 sets; combines double parity with striping.
• RAID 100 (RAID 1+0+0): stripe of RAID 10 sets; rare configuration for very large arrays.
• RAID 01: mirror of stripes; the inverse arrangement of RAID 10 (with very different fault tolerance properties).

The “best of both worlds” framing

The macperformanceguide RAID 1+0 reference captures the design intent: “The goal of RAID 1+0 is to double performance and capacity while allowing slightly more fault tolerance than RAID-5: Data is striped (RAID 0) over mirrored sets (RAID 1) of drives for fast redundancy.”³ The “best of both worlds” framing comes from RAID 10’s inheritance of advantages from both RAID 0 and RAID 1:

Property	From RAID 0	From RAID 1	RAID 10 result
Read performance	Striping = parallel reads	Mirror reads = doubling	Excellent (N-way parallel)
Write performance	Striping = parallel writes	No parity = no penalty	Excellent (no RMW cycle)
Capacity efficiency	100%	50%	50% (mirror dominates)
Fault tolerance	None	1 disk per pair	1 per pair (up to N/2 total)
Rebuild complexity	N/A (no rebuild)	Simple disk copy	Simple disk copy
Write hole risk	N/A	None (no parity)	None (no parity)

The minimum disk count

RAID 10 requires a minimum of 4 disks: 2 mirrored pairs of 2 disks each. Disk count must be even because mirrored pairs are the building blocks. Practical RAID 10 deployments commonly use:

• 4 disks: minimum configuration; 2 mirror pairs; common for small servers.
• 6 disks: 3 mirror pairs; good IOPS scaling for medium databases.
• 8 disks: 4 mirror pairs; common for medium-to-large server deployments.
• 10-12 disks: 5-6 mirror pairs; large database storage.
• 16+ disks: typically reserved for enterprise; expansion difficulty becomes a factor.

Capacity always 50%

One of RAID 10’s defining characteristics is its fixed capacity overhead: regardless of the disk count, RAID 10 always uses 50% of the raw capacity for redundancy. This contrasts with parity-based RAID where larger arrays improve efficiency:

• 4 disks RAID 10: 50% (2 disks usable).
• 4 disks RAID 5: 75% (3 disks usable).
• 8 disks RAID 10: 50% (4 disks usable).
• 8 disks RAID 5: 87.5% (7 disks usable).
• 8 disks RAID 6: 75% (6 disks usable).

For capacity-focused deployments, RAID 5 or RAID 6 deliver better efficiency; for performance-focused or fault-tolerance-focused deployments, RAID 10’s predictable 50% is often acceptable.

Understanding RAID 10’s data layout clarifies both its performance characteristics and its fault tolerance properties.

The two-level construction

The PITS RAID 10 reference describes the layered construction: “In a RAID 10 array, the drives are usually divided into pairs, and each pair is mirrored. This means that for every data block written to one drive, an identical block is written to its mirror drive. Once the mirroring is complete, the data is then striped across the mirrored pairs. This striping enables concurrent read and write operations, resulting in improved performance compared to a single disk.”⁴ The construction has two distinct levels:

1. Level 1 (mirror): Pairs of disks form RAID 1 mirrors. Each pair holds an identical copy of its assigned data.
2. Level 2 (stripe): The mirror pairs are treated as logical units that are then striped together (RAID 0).

A 4-disk RAID 10 layout

For a 4-disk RAID 10 array (2 mirror pairs), data flows like:

Stripe	Pair 1: Drive 0	Pair 1: Drive 1	Pair 2: Drive 2	Pair 2: Drive 3
Stripe 1	D1 (data)	D1 (mirror)	D2 (data)	D2 (mirror)
Stripe 2	D3 (data)	D3 (mirror)	D4 (data)	D4 (mirror)
Stripe 3	D5 (data)	D5 (mirror)	D6 (data)	D6 (mirror)
Stripe 4	D7 (data)	D7 (mirror)	D8 (data)	D8 (mirror)

Drive 0 and Drive 1 always hold identical data (mirror). Drive 2 and Drive 3 always hold identical data (mirror). The striping distributes data D1, D2, D3… across the two pairs in alternating fashion.

An 8-disk RAID 10 layout

Scaling to 8 disks (4 mirror pairs):

Stripe	Pair 1	Pair 2	Pair 3	Pair 4
Stripe 1	D1, D1m	D2, D2m	D3, D3m	D4, D4m
Stripe 2	D5, D5m	D6, D6m	D7, D7m	D8, D8m
Stripe 3	D9, D9m	D10, D10m	D11, D11m	D12, D12m

Performance scales with the number of pairs; an 8-disk RAID 10 has 4-way striping for reads and writes (each operation can use 4 pairs in parallel).

The deployment pattern: stripe two RAID 1 enclosures

The macperformanceguide reference describes a practical deployment pattern: “A simple way to create a RAID 1+0 mirror is to stripe two hardware-based RAID 1 mirror enclosures, such as the OWC Mercury Elite Pro Dual. The concept can be extended to stripe 2/3/4/etc RAID-1 mirrors, thus raising performance to higher and higher levels while having fault tolerance within each hardware mirror enclosure. However, the more stripes used, the more the risk of a double-fault within one enclosure. A triple stripe RAID 1+0 carries the concept about as far as it makes sense to go in most cases.” This deployment approach uses dedicated hardware RAID 1 enclosures (each handling one mirror pair) striped together at the OS level.

Read operation flow

RAID 10 reads can use any of the mirror members in each pair, providing maximum read performance:

• For striped reads larger than the stripe size, the controller reads from all pairs simultaneously.
• Within each pair, the controller can choose either mirror member.
• Best implementations alternate between pair members for load balancing.
• For multi-user random reads, the array can theoretically deliver up to N times single-disk IOPS (each pair contributes 2× IOPS, and there are N/2 pairs).

Write operation flow

RAID 10 writes follow the inverse construction:

• The data is split into stripes targeting different pairs.
• Each stripe is written to its assigned pair.
• Within each pair, the write is duplicated to both mirror members in parallel.
• No parity calculation is required; the write completes when both members of the targeted pair acknowledge.
• The total write performance scales close to (N/2) × single-disk write speed (the number of pairs, since each write involves both members of one pair).

Fault tolerance behavior

The DiskInternals RAID 10 fault tolerance reference captures the redundancy model: “RAID 10 can tolerate multiple disk failures without data loss, as long as no two drives in the same mirrored pair fail. This high level of fault tolerance is crucial for critical systems where uptime is essential.”⁵ The fault tolerance details:

• If one drive fails in any pair, the array continues operating with that pair in degraded mode.
• Reads from the failed pair come from the surviving member only.
• Writes still go to both members of the pair (the surviving member; the failed member is taken offline).
• Other pairs continue operating normally.
• Multiple failures are tolerated as long as each pair retains at least one functional member.

The order of mirroring vs striping creates two related but importantly different configurations: RAID 10 (1+0, mirror-then-stripe) and RAID 01 (0+1, stripe-then-mirror). The fault tolerance difference is the main reason RAID 10 is preferred.

The construction order

• RAID 10 (1+0): Create N/2 mirror pairs of 2 disks each, then stripe across the pairs. The base unit is a mirror; the array is built up from many mirrors.
• RAID 01 (0+1): Create 2 stripe sets of N/2 disks each, then mirror the entire stripe set. The base unit is a stripe; the array consists of two large stripes mirrored together.

Capacity, performance, and disk count are identical between the two configurations; only the fault tolerance differs.

The fault tolerance difference

The TheGeekStuff RAID 10 vs RAID 01 reference captures the crucial distinction: “Performance on both RAID 10 and RAID 01 will be the same. The storage capacity on these will be the same. The main difference is the fault tolerance level. On most implementations of RAID controllers, RAID 01 fault tolerance is less. On RAID 01, since we have only two groups of RAID 0, if two drives (one in each group) fails, the entire RAID 01 will fail. On RAID 10, since there are many groups (as the individual group is only two disks), even if three disks fails (one in each group), the RAID 10 is still functional.”⁶

A worked 8-disk example

Consider an 8-disk array with 3 simultaneous failures: Disk 1 (Pair 1), Disk 3 (Pair 2), and Disk 5 (Pair 3) all fail at the same time. The fault tolerance results:

Configuration	3 disk failures	Result
RAID 10 (1+0)	One per mirror pair	Survives; each pair has 1 surviving member
RAID 01 (0+1)	Multiple in one stripe set	Likely fails; if even 2 of the 3 are in the same stripe set, the entire stripe is broken and the mirror loses one entire stripe

RAID 10 has higher granularity of redundancy; many small pairs provide more failure paths than two large stripes.

The naming-confusion warning

Some sources use the names “RAID 10” and “RAID 01” inconsistently. The Nfina reference exhibits this confusion explicitly: it names “RAID 0+1 (also known as RAID10)” and “RAID 1+0 (also known as RAID01)” in a way that is the opposite of standard industry usage. The correct conventional usage:

• RAID 10 = RAID 1+0 = mirror first, then stripe (the better fault tolerance configuration)
• RAID 01 = RAID 0+1 = stripe first, then mirror (the worse fault tolerance configuration)

When evaluating documentation or vendor materials, verify which configuration is actually being described regardless of the label used; the underlying construction (mirror-of-stripes vs stripe-of-mirrors) is what determines fault tolerance properties.

Why RAID 01 is rarely used

RAID 01’s worse fault tolerance for the same cost makes it strictly inferior to RAID 10 in modern deployments. Specific reasons RAID 01 has fallen out of favor:

• Same disk count, same capacity, same performance as RAID 10.
• Worse fault tolerance for any failure pattern involving more than one disk.
• Worse rebuild characteristics: rebuilding RAID 01 requires copying an entire stripe (multiple disks worth of data); rebuilding RAID 10 requires copying one disk’s worth.
• No advantage that compensates for these disadvantages.

RAID 01 is occasionally encountered on legacy systems but is essentially never the right choice for new deployments.

RAID 10’s performance and fault tolerance characteristics differ substantially from parity-based RAID. Understanding the differences clarifies when RAID 10 is the right choice.

Read performance

RAID 10 read performance is excellent and scales with disk count:

• Sequential reads: close to N × single-disk bandwidth (every disk can contribute reads).
• Random reads: can scale up to N × single-disk IOPS for multi-user workloads.
• Mixed workloads: read performance roughly tracks RAID 0 with the same disk count.
• Degraded reads: if one disk in a pair fails, reads from that pair come from the surviving member; performance is slightly reduced for the affected pair but unchanged for others.

Write performance

RAID 10 write performance is good but constrained by mirroring:

• Sequential writes: approximately (N/2) × single-disk bandwidth (the number of pairs).
• Random writes: good IOPS scaling because writes don’t require parity reads.
• Small random writes: RAID 10 dramatically outperforms RAID 5/6 for small writes because there’s no read-modify-write cycle.
• Database OLTP: the canonical workload where RAID 10 outperforms parity-based RAID; small random writes are fast and predictable.

No parity, no write hole

RAID 10 lacks the vulnerabilities that affect parity-based RAID:

• No write hole: there’s no parity to become inconsistent during power failures.
• No parity calculation overhead: writes simply duplicate to mirror members; no XOR or Reed-Solomon math.
• No read-modify-write penalty: small writes don’t require reading the rest of a stripe.
• No rebuild storm: rebuild is a simple copy from the surviving mirror member.

Fault tolerance scaling

RAID 10’s fault tolerance scales with the number of pairs:

Disk count	Mirror pairs	Max simultaneous failures	Worst case (same pair)
4 disks	2 pairs	2 (one per pair)	Total failure if both in one pair
6 disks	3 pairs	3 (one per pair)	Total failure if both in any pair
8 disks	4 pairs	4 (one per pair)	Total failure if both in any pair
12 disks	6 pairs	6 (one per pair)	Total failure if both in any pair
16 disks	8 pairs	8 (one per pair)	Total failure if both in any pair

The “double failure same pair” worst case

RAID 10’s defining vulnerability: if both disks in a single mirror pair fail simultaneously, the entire array is lost. The probability of this scenario depends on:

• Number of pairs (more pairs = more chances for a same-pair double failure).
• Drive AFR (annualized failure rate).
• Time to replace and rebuild after first failure.
• Correlation between failure modes (drives from same batch may fail together).

For typical deployments, the same-pair double-failure probability is much lower than a 2-disk failure in RAID 5 (which exceeds RAID 5’s tolerance). RAID 10 is therefore generally more robust than RAID 5 for similar disk counts.

Rebuild performance

RAID 10 rebuild after disk failure has favorable characteristics:

• Rebuild is a simple disk-to-disk copy from the surviving mirror member.
• Rebuild time scales with disk size (linearly), not disk count.
• Rebuild stress is concentrated on a single mirror member, not all surviving disks.
• No URE multiplication problem like RAID 5 has on large drives.
• Rebuild typically takes the time to copy one full disk (several hours for multi-TB drives).

RAID 10 deployment scenarios

The PITS reference captures the typical deployment context: “RAID level 10 is well-suited for mission-critical environments such as databases, virtualization platforms, and high-performance computing, where high-speed data access, fault tolerance, and rapid data recovery are essential.” Specific deployment scenarios:

• Database OLTP storage: SQL Server, Oracle, MySQL/MariaDB, PostgreSQL data files.
• Database transaction logs: sequential writes that benefit from striped mirrors.
• VMware/ESXi datastores: hosting busy VMs with mixed workloads.
• Hyper-V virtual machine storage: Microsoft’s hypervisor.
• Email server message stores: Exchange, Postfix, Dovecot.
• High-frequency trading systems: where IOPS predictability matters.
• Real-time analytics platforms: mixed read/write workloads.

RAID 10 recovery is generally the most straightforward of any redundant RAID configuration because each mirror member contains complete data for its pair. Different scenarios have different optimal approaches.

Single-disk failure (most common)

The standard RAID 10 maintenance scenario: one disk has failed, all other disks are healthy. The recovery process:

1. Identify which disk failed and which mirror pair it belongs to.
2. Verify the surviving member of that pair is healthy.
3. Replace the failed disk with a healthy one (often hot-swap if hardware supports it).
4. Initiate rebuild; the controller copies all data from the surviving mirror member to the new disk.
5. Rebuild is fast because it’s a simple disk-to-disk copy, not parity reconstruction.
6. After rebuild completes, the array returns to fully redundant state.

This scenario typically doesn’t require recovery software; standard RAID maintenance handles it. RAID 10 rebuild is much safer than RAID 5 rebuild because it doesn’t trigger the URE-on-all-disks problem; only one disk’s worth of reads is required.

Multiple-disk failure across different pairs

If multiple disks fail but each failure is in a different mirror pair, the array remains operational:

• Each affected pair operates in degraded mode.
• Reads come from surviving members.
• Writes go to surviving members.
• The array can be rebuilt one disk at a time as replacement disks are installed.
• No data loss occurs as long as each pair retains at least one functional member.

Two-disk failure within the same pair (catastrophic)

The defining failure mode of RAID 10: if both disks in a single mirror pair fail simultaneously, the entire array is lost:

• The pair has no remaining redundant copy of its data.
• Other pairs contain unrelated data, not the lost pair’s data.
• The striping makes the array’s contents depend on every pair being intact.
• Recovery from this scenario is essentially impossible without backups.
• If both failed disks are partially readable, professional services with disk imaging may recover partial data, but full recovery is unlikely.

Recovery from individual mirror disks

One of RAID 10’s recovery advantages is that individual mirror disks contain complete file system images:

1. Identify which mirror member of each pair to use.
2. Connect the disk to a non-RAID system (USB enclosure, separate HBA).
3. The disk contains the complete data for its pair, but only that pair’s portion of the array.
4. To reconstruct the entire RAID 10 array, all pairs’ data must be combined; this requires understanding the stripe pattern.
5. Software tools can reassemble the array from the individual disks.

Controller failure recovery

When a hardware RAID controller fails but disks are intact:

• Replace with same controller model: often works directly.
• Software RAID assembly: tools like UFS Explorer can read RAID 10 arrays from individual disks.
• RAID-aware recovery software: R-Studio, ReclaiMe, DiskInternals RAID Recovery handle RAID 10.
• Mount one mirror member directly: sometimes works for RAID 10 with simple mirror layouts.

Reconstruction parameters

Software-based RAID 10 reconstruction requires identification of:

• Pair structure: which disks are mirror partners.
• Stripe size: the chunk size used for striping across pairs.
• Stripe order: which pair holds which stripes.
• Start offset: where the RAID data begins on each disk.
• RAID metadata format: typically simpler than parity-based RAID.

Recovery tools

Tools handling RAID 10 reconstruction:

• R-Studio: commercial RAID-aware recovery; full RAID 10 support.
• ReclaiMe Free RAID Recovery: automated parameter detection includes RAID 10.
• DiskInternals RAID Recovery: RAID 10 in supported formats.
• UFS Explorer: handles RAID 10 along with other configurations.
• Linux mdadm: open-source software RAID 10 implementation.
• Direct mounting: often works for one mirror member from each pair on Linux/macOS.

Professional services for RAID 10

Professional services apply for RAID 10 in narrow scenarios:

• Both disks in a mirror pair have physical damage requiring cleanroom recovery.
• Multiple pairs have lost both members.
• Hardware RAID metadata is in a non-standard format that can’t be parsed.
• Initial software recovery has failed.

The DiskInternals RAID 10 reference summarizes the recovery picture: “Simplified Recovery: In the event of a drive failure, recovery in a RAID 10 array is straightforward, as only the affected drive needs to be replaced and rebuilt.” Most RAID 10 failures are recoverable through standard maintenance; professional services are needed only for unusual catastrophic scenarios.