4.2.39 · D5Operating Systems
Question bank — RAID — levels 0, 1, 5, 6, 10 — trade-offs
Before we start, a one-line reminder of the vocabulary every trap leans on:
Recall The words you must have pinned down first
Striping ::: cutting one file into blocks and scattering them across disks so they can be read/written in parallel. Mirroring ::: keeping a byte-for-byte identical copy of a disk on a second disk. Parity ::: a single computed check-block that lets you rebuild any one missing data block. XOR () ::: the "bits-differ" operation with the magic property and , so it undoes itself. Stripe ::: the set of blocks (data + parity) that sit at the same position across all disks.
True or false — justify
Every item here is a claim. Decide true or false first, then give the reason — the reveal always contains the why, never a bare verdict.
RAID 0 improves reliability because data is spread over many disks.
False. Spreading data over disks makes failure more likely — losing any one disk destroys the whole logical volume, so mean-time-to-failure gets worse, not better. See Reliability and MTBF.
A RAID 1 mirror is a valid replacement for nightly backups.
False. The mirror copies every write instantly, including an accidental
rm, a ransomware encrypt, or filesystem corruption — the mistake lands on both disks. RAID buys availability, not history.RAID 5 can survive two disks failing at the same time.
False. One parity block = one equation = one recoverable unknown. Two simultaneous failures give two unknowns and only one equation, so the data is unrecoverable.
RAID 6 survives two failures because it stores parity twice.
False. Storing XOR parity twice gives the same equation twice — still one usable equation. RAID 6's second parity is computed over $GF(2^8)$ so it is independent, giving a genuine second equation.
For the same number of disks, RAID 5 has more usable capacity than RAID 6.
True. RAID 5 sacrifices one disk's worth of space (), RAID 6 sacrifices two (), so RAID 5 wins on capacity — but loses on tolerating a second failure.
RAID 10 and RAID 0+1 give the same usable capacity.
True on capacity (both are ), but that is the only thing they share — their failure tolerance and rebuild behaviour differ because the order of mirroring and striping differs.
Reads on RAID 1 can be faster than on a single disk.
True. A read only needs one copy, so two mirrored disks can serve two independent reads at once, roughly doubling read throughput.
Writes on RAID 1 are as cheap as writes on a single disk.
False. Every write must land on both copies to keep them identical, so a mirror does double the write work (though the two writes happen in parallel).
Adding more parity disks always makes an array faster.
False. Parity adds write cost (read-modify-write), so RAID 6 is slower than RAID 5 on small writes, which is slower than RAID 0/10 which have no parity at all.
Because parity is "just XOR", computing it is essentially free.
Half-true. Computing is cheap; the expensive part is that updating it on a small write forces extra disk reads and writes — the cost is I/O, not arithmetic.
Spot the error
Each line contains a flawed statement. The reveal names the specific broken step.
"To rebuild disk 2 in RAID 5, XOR only the surviving data disks together."
Error: you must also XOR the parity block . The rule is — drop and the surviving data alone cannot reconstruct the missing block.
"A small RAID 5 write is 2 I/Os: write the new data, write the new parity."
Error: you first must read the old data and old parity to compute . That is 2 reads + 2 writes = 4 I/Os.
"RAID 6's write penalty is 4 I/Os, same as RAID 5."
Error: RAID 6 updates two parity blocks ( and ), so a small write is read old data + read old + read old + write data + write + write = 6 I/Os.
"With 8 disks of 4 TB, RAID 6 gives 28 TB usable."
Error: that is the RAID 5 answer. RAID 6 loses two disks to parity, so usable TB.
"During a RAID 5 rebuild the array is fully protected."
Error: while one disk is being rebuilt the array is running with zero redundancy — a second failure during the rebuild loses all data. This is why large arrays prefer RAID 6.
"RAID 10 stripes first, then mirrors the stripes."
Error: that describes RAID 0+1. RAID 10 mirrors first (into pairs), then stripes across the pairs — order matters for how many failure patterns survive.
"Since parity is the XOR of the data, the parity disk is idle most of the time."
Error: in RAID 5 parity is rotated across all disks, so no disk is a dedicated parity disk — every disk holds both data and parity blocks, spreading the write load.
Why questions
Answer the underlying reason, not just the fact.
Why does XOR (rather than plain addition) work for single-erasure recovery?
XOR is its own inverse (), so re-XORing the surviving blocks cancels their copies inside and leaves exactly the missing block — ordinary addition would need borrows/carries and would not self-cancel cleanly on bits. See XOR and Boolean Algebra.
Why can't RAID 6 use two ordinary XOR parities to survive two failures?
Two XOR parities produce the same linear equation over bits, so together they still solve for only one unknown. Independence requires a different coefficient per disk, which multiplication provides.
Why is the read-modify-write penalty unavoidable for a small write?
To keep parity valid you need the old data and old parity so the old term can be cancelled (); without reading them you cannot know what to remove from .
Why does RAID 5 rotate parity across disks instead of dedicating one parity disk?
A dedicated parity disk would be written on every update, becoming a bottleneck; rotating parity spreads write traffic evenly, so no single disk is hot. Relates to Disk Scheduling load balancing.
Why is RAID 10 preferred for write-heavy databases over RAID 5?
RAID 10 writes are plain mirrored writes (no parity recomputation), so no read-modify-write penalty — small random writes, common in databases, stay fast.
Why does striping across more disks improve throughput?
Each disk has its own head that can seek and transfer independently, so disks can move blocks in the time one disk moves one — parallelism, not faster individual disks. This is why File Systems care about stripe alignment.
Why does adding disks to a RAID 0 array make total failure more likely?
With no redundancy, the array survives only if all disks survive; the more disks, the higher the chance at least one dies, so combined reliability falls. See Reliability and MTBF.
Edge cases
Boundary and degenerate inputs — the scenarios that break sloppy mental models.
What does RAID 5 need at minimum, and what happens with exactly 3 disks?
RAID 5 needs at least 3 disks; with 3, two hold data and one (rotated) holds parity, giving usable capacity of 2 disks and tolerance of 1 failure.
What is the smallest valid RAID 6 array, and its usable capacity?
4 disks minimum; with 4, usable capacity is disks' worth, and it still tolerates 2 failures — the extreme case where redundancy equals capacity.
If a RAID 1 pair loses both disks, what is recoverable?
Nothing — mirroring tolerates only one failure per pair. Beyond that, redundancy is exhausted and the data is gone.
In RAID 10, can the array survive two disk failures?
Sometimes. It survives two failures only if they land in different mirror pairs; if both failures hit the same pair, that pair (and the array) is lost.
What happens to a data block that is all zeros when computing parity?
It contributes nothing, since — the parity is unchanged by a zero block, and recovery still works because zero is a perfectly valid recoverable value.
If every data block in a stripe is identical, what is the parity?
For an even number of identical blocks the XOR parity is all zeros (they cancel in pairs); for an odd number it equals that block — the parity still uniquely determines any single missing block.
What redundancy does a single-disk "array" have?
None — there is nothing to stripe against or mirror to. RAID levels only add value once (mirroring) or (single parity).