Learn RAID - Core Concepts & RAID Levels

#Introduction

Episode 1 explained why RAID exists. Now it's time to build the technical foundation: how RAID actually works. Episode 2 introduces the three basic mechanisms — striping, mirroring, and parity — then assembles them into the RAID levels you'll encounter in production.

Understanding RAID levels properly is what separates an admin who merely runs commands from an admin who can design storage. You'll learn to read the numbers behind a level like "RAID 5" and know exactly what you gain and what you sacrifice. Let's start with the simplest mechanism.

#The Three Basic Mechanisms

#Striping: Distributing Data Across Disks

Striping divides data into pieces (stripes) and distributes them across multiple disks in turn. The size of each piece is called the chunk size. With striping, large reads and writes can use multiple disks at once, increasing throughput. Its biggest weakness: without parity or mirroring, one dead disk means the entire array is dead.

data: A1 A2 A3 A4 B1 B2 B3 B4
disk1: A1 B1 | disk2: A2 B2 | disk3: A3 B3 | disk4: A4 B4

A chunk size that is too small creates high seek overhead; too large and the distribution becomes uneven. Common values are 64K or 512K, and we'll discuss tuning in episode 18.

#Mirroring: Duplicating Data

Mirroring writes the same data to two or more disks in full. Every write produces a duplicate, so if one disk fails, the copy remains intact. Reads can be split across both disks to increase read throughput, while writes are charged double.

disk1: A1 B1 C1 | disk2: A1 B1 C1

Mirroring is the simplest mechanism and the fastest during recovery, because a rebuild only copies from the pair disk without computing anything.

#Parity: Distributed Checksum

Parity is checksum data computed from the contents of several data blocks, usually using XOR operations. If one data block is lost, it can be recomputed from the other data blocks plus the parity. Parity requires far less capacity than mirroring — only one or two disks — but every write forces the system to read other blocks and compute parity, adding overhead.

a = 0b1010, b = 0b1100
parity = a XOR b = 0b0110
a = parity XOR b (reconstruction when a is lost)

Later, in episode 18, we'll see how ZFS and mdadm choose efficient parity algorithms.

#RAID Levels and Capacity Formulas

#RAID 0 and RAID 1

• RAID 0 uses pure striping, with no redundancy. Capacity is N times the disk capacity. Suitable for data that can be lost or for maximum performance, such as caches and scratch space.
• RAID 1 uses mirroring. Capacity is N/2 for a pair of disks. Suitable for the OS, boot, and data that needs full redundancy.

# RAID 0: capacity = N * disk_capacity
# RAID 1: capacity = (N/2) * disk_capacity
# RAID 5: capacity = (N-1) * disk_capacity
# RAID 6: capacity = (N-2) * disk_capacity

Later, the mdadm --detail /dev/md0 command will show the number of active devices and the number in use, so you can check whether the capacity matches the formula.

#RAID 5 and RAID 6

• RAID 5 uses striping with single parity. Parity is distributed evenly across all disks, not on a single dedicated disk. Usable capacity is N-1. It tolerates one disk failure.
• RAID 6 uses striping with double parity (two parity blocks per stripe). Usable capacity is N-2. It tolerates two disk failures and is suitable for large arrays or high-capacity disks.

#RAID 4, RAID 10, and Nested Levels

• RAID 4 uses parity on a single dedicated disk. Simple in concept, but the parity disk becomes a write bottleneck, so it's rarely used.
• RAID 10 combines mirroring and striping: disks are paired up as mirrors, then all pairs are striped. Capacity is N/2, with fast rebuilds because it only copies from the pair.
• RAID 50 and 60 are nested levels: several RAID 5 or 6 arrays are combined with striping to balance redundancy and performance.

#URE and the RAID 5 vs RAID 6 Tradeoff

#Bit Error Rate and Failed Rebuilds

Every disk has an Unrecoverable Read Error (URE) rate — the probability that a single bit cannot be read when needed. For common HDDs, this is around 1 bit per 10 to the 14th bits read, meaning roughly 12.5TB. During a RAID 5 rebuild, the entire contents of the array must be read to recompute the data of the lost disk. If the array capacity is close to the URE figure, the chance of hitting an unreadable bit during a rebuild becomes significant.

sudo smartctl -a /dev/sda | grep -i read

The smartctl -a /dev/sda command displays SMART attributes including error rate. We'll read SMART on a routine basis in episode 13.

#Implications for Large Disks

For 4TB-and-up disks with many disks in one array, RAID 5 starts to become risky: one disk failing during a rebuild can be accompanied by a URE on another disk, and the array will fail completely. RAID 6 provides two layers of parity so it can still survive one more failure during a rebuild. This is the main reason many storage teams switch to RAID 6 or RAIDZ2 for large disks.

#Conclusion

Episode 2 gave you the technical language to talk about RAID: striping distributes data, mirroring duplicates it, and parity protects it with checksums. You can now also calculate capacity for levels 0, 1, 5, 6, and 10, and understand why URE makes RAID 6 more attractive for large disks.

Key takeaways:

• Striping adds performance, mirroring adds redundancy, and parity adds both at the cost of writes.
• Capacity formulas: RAID 0 uses N, RAID 1 and 10 use N/2, RAID 5 uses N-1, RAID 6 uses N-2.
• RAID 10 is a combination of mirroring and striping with fast rebuilds.
• URE makes RAID 5 rebuilds risky on large-disk arrays.
• RAID 6 and RAIDZ2 are the answer for capacity with large disks.

In the next episode, episode 3, we'll discuss software vs hardware vs firmware RAID — the pros and cons of the kernel MD driver with mdadm, hardware controllers with battery-backed cache, and the fake RAID IMSM and DDF. You'll know which implementation path fits your needs.