Homelab / InfraAI-generated

Hoe ZFS en RAID je data beschermen tegen bit rot

Een harde schijf die stuk gaat, merk je meteen. Lastiger is een schijf die gewoon blijft draaien en af en toe iets anders teruggeeft dan je erop hebt gezet. Eén omgevallen bit in een foto, een archief dat niet meer uitpakt. Dat heet bit rot, of stille corruptie, en het is precies het soort fout waar klassieke RAID je niet tegen beschermt. ZFS wel, en het verschil zit in één ontwerpkeuze: waar de controlegetallen worden bewaard.

In dit artikel bouw ik het stap voor stap op. Eerst hoe pariteit een complete schijf kan terugrekenen, dan waarom een mirror niet weet welke kopie gelijk heeft, en daarna hoe ZFS met checksums wel kiest. Alles met een klein Python-script dat ik zelf heb gedraaid, en met de documentatie van OpenZFS ernaast.

Waar RAID vandaan komt

De term komt uit een technisch rapport van Berkeley uit december 1987: A Case for Redundant Arrays of Inexpensive Disks (RAID) van Patterson, Gibson en Katz. Het idee was dat een rij goedkope pc-schijven sneller en betrouwbaarder kon zijn dan één grote, dure schijf. Het rapport beschreef vijf RAID-niveaus. Twee daarvan kom je thuis nog steeds tegen: de mirror (RAID 1), waarbij elke schijf een identieke kopie heeft, en pariteit (RAID 5), waarbij je één schijf aan controle-informatie opoffert.

Pariteit: een schijf terugrekenen met XOR

De Linux-handleiding van md, de software-RAID in de kernel, omschrijft het pariteitsblok als het resultaat van een exclusive-or tussen alle datablokken in een stripe (md(4)). XOR heeft een handige eigenschap: als je één blok mist, krijg je het terug door de rest plus de pariteit opnieuw te XOR'en.

Met drie mini-blokken van vier bytes ziet dat er zo uit:

data: [b'Foto', b'Mail', b'Code']  pariteit: 48617966
schijf 2 weg; terug uit d1^d3^p: b'Mail'

Bij RAID 4 staat alle pariteit op één vaste schijf. RAID 5 verspreidt de pariteitsblokken over alle schijven, wat volgens dezelfde handleiding meer parallel lezen en schrijven mogelijk maakt. Het principe is hetzelfde. Wie het artikel over QR-codes heeft gelezen, herkent het: XOR-pariteit is de eenvoudigste vorm van foutcorrectie, die precies één ontbrekend stuk kan herstellen.

Waarom RAID niet weet welke kopie gelijk heeft

Pariteit werkt goed als een schijf hardop zegt dat hij stuk is. Dan weet de RAID-laag welk blok ontbreekt. Maar wat als een schijf zonder foutmelding verkeerde data teruggeeft?

Neem een mirror met twee kopieën van een blok van 4096 bytes, en draai in kopie B één bit om. Mijn script telt daarna precies 1 bit verschil tussen A en B. Bij een controle ziet een RAID-laag dat de kopieën niet gelijk zijn, maar heeft geen idee welke de goede is. De md-handleiding is daar eerlijk over: bij een repair op RAID 1 of RAID 10 worden "all but one block" overschreven met de inhoud van dat ene blok. Bij RAID 5 en 6 wordt simpelweg nieuwe pariteit geschreven. Als de fout in een datablok zat, maak je de fout daarmee definitief.

Dat dit geen theoretisch probleem is, laat een studie van Bairavasundaram en collega's zien (FAST '08). Zij bekeken productiesystemen met in totaal 1,53 miljoen schijven over 41 maanden en vonden meer dan 400.000 checksum-mismatches. Nearline-schijven hadden er duidelijk vaker last van dan enterprise-schijven.

ZFS-checksums: het controlegetal staat in de ouder

ZFS berekent voor elk blok, data en metadata, een checksum. Volgens de eigenschappen-documentatie is de standaardinstelling on, wat op dit moment fletcher4 betekent. Je kunt ook onder meer sha256, sha512 of blake3 kiezen.

Het slimme zit in de plek. Jeff Bonwick legde in 2005 op zijn blog bij Sun uit dat een checksum die naast de data op dezelfde sector staat weinig bewijst. Bij een phantom write, waarbij een schrijfactie nooit op de schijf aankwam, zijn oude data en oude checksum nog steeds met elkaar in overeenstemming. ZFS slaat de checksum van elk blok daarom op in de blokpointer van het bovenliggende blok. De hele pool is zo een boom waarin elk blok de checksums van zijn kinderen bevat, een Merkle-boom. Hetzelfde idee als bij een opgeslagen wachtwoord-hash: je vergelijkt met een getal dat je eerder op een andere plek hebt vastgelegd.

Fletcher4 is geen cryptografische hash maar een rekensom. In de OpenZFS-broncode (zfs_fletcher.c) zijn het vier 64-bit tellers die over 32-bit woorden lopen: a += woord; b += a; c += b; d += c. Samen 256 bits. Ik heb die lus nagebouwd in Python en losgelaten op de twee kopieën uit het vorige voorbeeld:

fletcher4(A) klopt: True
fletcher4(B) klopt: False

Nu is er wel een antwoord op de vraag welke kopie gelijk heeft.

Zelfherstel met RAID-Z

RAID-Z is de pariteitsvariant van ZFS. Volgens zpoolconcepts bestaat het met enkele, dubbele of drievoudige pariteit (raidz1, raidz2, raidz3), en overleeft een groep evenveel uitgevallen schijven. Een groep met N schijven van X groot en P pariteitsschijven kan ongeveer (N-P)·X bytes opslaan.

Wanneer een RAID-Z-blok de checksum niet haalt, leest ZFS volgens Bonwick de pariteit erbij en probeert het combinaties: stel dat schijf 1 loog, reken die terug, klopt de checksum nu? Zo niet, probeer schijf 2. Mijn script doet hetzelfde met drie datablokken van 4 KB, waarvan in het tweede één bit is omgedraaid:

eerste lezing klopt: False
aanname schijf 1 is fout -> checksum klopt: False
aanname schijf 2 is fout -> checksum klopt: True
aanname schijf 3 is fout -> checksum klopt: False

Daarna geeft ZFS de goede data aan het programma en herstelt het de kapotte kopie. In de documentatie staat dat letterlijk: "ZFS automatically repairs bad data from a good copy, when corruption is detected."

Het write hole

Bonwick beschrijft nog een zwakte van klassieke RAID 5. Bij elke wijziging moet je zowel het datablok als de pariteit bijwerken, en twee schijven tegelijk atomair beschrijven kan niet. Valt de stroom precies tussen die twee schrijfacties, dan klopt de pariteit van die stripe niet meer. Niemand merkt het, tot er een schijf uitvalt:

schijf 3 valt uit; gereconstrueerd: b'XXXX' (was CCCC)

RAID-Z omzeilt dit met een variabele stripe-breedte: elk blok is zijn eigen stripe, dus elke schrijfactie is een volledige stripe. Daarbij werkt ZFS copy-on-write: nieuwe data komt in vrije ruimte, en zolang een schrijfactie niet af is, verwijst nog niets naar die blokken. Een stroomstoring halverwege raakt dus geen data die in gebruik is. Linux md heeft voor RAID 5 een eigen oplossing, de Partial Parity Log, die volgens de kerneldocumentatie het write hole sluit.

Scrubben: bit rot opsporen voordat je het nodig hebt

Zelfherstel werkt alleen bij blokken die worden gelezen. Een foto die je drie jaar niet opent, kan intussen stilletjes beschadigen, en als de tweede kopie ook omvalt, ben je te laat. Daarom is er zpool scrub. Volgens de handleiding leest een scrub alle data in de pool en controleert de checksum van elk blok. Een resilver kijkt alleen naar data waarvan ZFS al weet dat die verouderd is, bijvoorbeeld na het vervangen van een schijf. De documentatie noemt geen vaste frequentie, maar levert systemd-timers mee voor wekelijks en maandelijks.

Zelf proberen

Het script dat ik gebruikte heeft alleen Python 3 nodig. De kern is de fletcher4-lus (hier ingekort, zonder de hex-weergave):

def fletcher4(data):
    a = b = c = d = 0
    for (w,) in struct.iter_unpack("<I", data):
        a = (a + w) % 2**64; b = (b + a) % 2**64
        c = (c + b) % 2**64; d = (d + c) % 2**64
    return (a, b, c, d)
$ python3 zfs_demo.py
== 2. Mirror met een omgevallen bit ==
bits verschillend tussen A en B: 1
checksum in ouder: 0000020150ed851f...
fletcher4(A) klopt: True
fletcher4(B) klopt: False

Heb je een machine met ZFS, dan start je een scrub en volg je die met:

zpool scrub -w tank
zpool status -v tank

Met -w wacht het commando tot de scrub klaar is. In zpool status staan per schijf de kolommen READ, WRITE en CKSUM. Een oplopend getal onder CKSUM is precies de stille corruptie uit dit artikel, die ZFS heeft gevonden. Met -v krijg je een lijst van bestanden met fouten. Een wekelijkse scrub zet je aan met systemctl enable zfs-scrub-weekly@tank.timer --now.

Tot slot

Wat me het meest verbaasde, is hoe eerlijk de md-handleiding is: bij een mismatch in een mirror wordt gewoon één kopie gekozen en over de rest heen geschreven. RAID beschermt tegen een schijf die uitvalt, ZFS ook tegen een schijf die liegt. Geen van beide beschermt tegen een bestand dat je per ongeluk weggooit, want die verwijdering wordt keurig naar alle schijven geschreven. Een back-up blijft dus nodig.