Foundations — RAID — levels 0, 1, 5, 6, 10 — trade-offs

Before you can read the parent note, you need a small toolbox of ideas: what a disk even is here, what a block is, what striping/mirroring/parity mean as pictures, and the one piece of algebra — XOR — that makes parity magic. We build each from nothing, in an order where every new idea leans only on the ones before it.

1. Disk — the thing we are protecting

The whole topic exists because one box is not enough. We need this word first because "array of disks" (the A and D in RAID) is literally many of these boxes lined up.

2. Block — the unit we move around

We need blocks because RAID never moves "a whole file" onto "a whole disk" — it moves pages onto different disks. Everything after this (striping, parity) is a rule for which page goes where.

Look at the figure: one file (the tall stack) is sliced into equal blocks $D_1,D_2,D_3,D_4$. Those blocks are the atoms we shuffle across disks.

3. $n$ — how many disks we have

4. Striping — spreading pages for speed

The picture: instead of one door, you have $n$ doors all open at once. That is the whole win of striping — parallelism — and the whole risk — losing any one disk loses those pages forever.

The left panel shows striping: each disk holds a different page (fast, no safety). Keep this picture — RAID 0 is this picture.

5. Mirroring — the copy for survival

Look at the right panel of the same figure: two disks hold the same pages $D_1,D_2$. That redundancy is why RAID 1 survives a failure — and why it costs 50% of your space.

6. XOR ($\oplus$) — the algebra behind parity

Parity is the clever, cheap safety net, and it runs entirely on one operation: XOR, written $\oplus$. We must earn this symbol fully, because the parent's whole derivation depends on it. See XOR and Boolean Algebra for the deeper treatment.

Why XOR and not plain addition? Because XOR has three magic properties that let us undo it perfectly:

The figure shows why parity recovers a lost block: XOR all blocks into a "summary" $P$; when one block vanishes, XOR the survivors with $P$ and every survivor cancels its own copy inside $P$ (the $x\oplus x=0$ law), leaving only the missing block. That cancellation is the entire trick behind RAID 5.

7. $⨁$ and subscripts — reading the big formula

So the parent's recovery rule $D_k=P\oplus {⨁}_{i\ne k}{D}_i$ reads in plain words: "the lost block equals the summary XORed with every surviving block." Nothing here is new — it is section 6 written compactly.

8. $P$, $Q$, and $GF(2^8)$ — one parity vs two

Why can't $Q$ just be another XOR? Because two XOR summaries would be the same equation twice — no new information. To make $Q$ genuinely independent, RAID 6 weights each block differently using arithmetic in a Galois field $GF(2^8)$ (see Galois Fields GF(2^n)). You do not need the field's internals here — only the idea: two different recipes = two solvable equations = two disks recoverable.

9. I/O — counting the cost of a write

How these foundations feed the topic

Read it top-down: the atoms (disk, block, XOR) build the three tools (striping, mirroring, parity), which combine into the five RAID levels.

Related groundwork

• Reliability and MTBF — why more disks means more failures to plan for.
• Backups vs Redundancy — why RAID is availability, not backup.
• File Systems — the layer that sits on top of the logical disk RAID presents.
• Return to the parent: 4.2.39 RAID — levels 0, 1, 5, 6, 10 — trade-offs (index 4.2.39).

Equipment checklist

Test yourself — you are ready for the parent note when each of these comes instantly.