Some of the links shared in this post are affiliate links. If you click on the link and make a purchase, we will receive an affiliate commission at no additional cost to you.
Pariteit wordt door unRAID gebruikt als bescherming tegen gegevensverlies. Als een schijf in de array uitvalt, kunnen de gegevens op de andere schijven worden gecombineerd met de pariteitsgegevens om de ontbrekende gegevens te reconstrueren.
Waarom pariteit? Omdat er maar twee soorten harde schijven in de wereld zijn:
- Harde schijven die het al eens hebben begeven.
- Harde schijven die nog niet defect zijn, maar gewoon wat meer tijd nodig hebben voordat ze defect raken.
Hoe pariteit werkt
In het algemeen is een pariteitsproces ontworpen om een enkele bitverandering in een bepaalde set bits te herkennen door de waarde van een toegevoegd bit zo in te stellen dat een sommatie over die set bits op een bekende waarde wordt geforceerd. Het toegevoegde bit wordt een pariteitsbit genoemd.
Bij unRAID worden de pariteitsbits opgeslagen op een pariteitsschijf die onafhankelijk is van de gegevensschijven. Deze pariteitsbit werkt via de set bits in dezelfde relatieve bitpositie op elke schijf. Zo is de 57e bit van de pariteitsschijf de pariteitsbit voor de 57e bit van alle gegevensschijven. Een pariteitscontrole van de 57e bitpositie telt daarom alle 57e bits van alle aandrijvingen op, inclusief de pariteitsaandrijving, en controleert of de som een EVEN getal is. Als de geretourneerde waarde niet EVEN is, wordt de pariteitsbit omgeschakeld zodat de pariteitscontrole een EVEN getal oplevert.
Waarom een EVEN getal? unRAID gebruikt “even pariteit”, wat simpelweg betekent dat het sommatieproces (met behulp van een wiskundige bewerking die “exclusieve OR” of “XOR” heet) over deze set bits een waarde moet opleveren die een EVEN getal is.
Digitale gegevens worden opgeslagen als een 1 of een 0:
Als je 4 schijven hebt met de bitwaarden 1,1,1,1, dan is de pariteit 0 (1+1+1+0=even). Als de bitwaarden 1,0,0,0 zijn, is de pariteit 1 (1+0+0+0+1=even).
Als een schijf wordt toegevoegd aan een unRAID array met pariteitsbeveiliging, wordt deze eerst verwijderd door nullen te schrijven naar alle bits van alle sectoren van deze schijf. Een nulwaarde heeft geen effect op de pariteit. Zodra de nieuwe schijf vol nullen is, kan unRAID deze eenvoudig in de array invoegen zonder de pariteit te hoeven herstellen. Op deze manier kunnen meerdere harde schijven tegelijk worden toegevoegd.
Reconstructie van gegevens
Er zijn slechts twee situaties waarin de pariteitsgegevens van unRAID worden gebruikt om gegevens te reconstrueren:
- wanneer een gegevensdrager wordt gereconstrueerd; en
- als er een defecte sector wordt gedetecteerd.
Op deze momenten worden alle schijven (inclusief de pariteit) gelezen om de gegevens te reconstrueren die naar de doelschijf moeten worden geschreven. Omdat de som van de bits altijd even is, kan unRAID elk ontbrekend data-element (de pariteit of een dataschijf) reconstrueren zolang de andere elementen correct zijn.
Laten we in de twee bovenstaande voorbeelden zeggen dat de 2.
- 1+x+1+1+0=even, x moet gelijk zijn aan 1
- 1+x+0+0+1=even, x moet gelijk zijn aan 0
Omdat pariteit zo belangrijk is voor gegevensreconstructie, moet je ervoor zorgen dat de pariteit correct is door regelmatig pariteitscontroles uit te voeren.
Als je een enkele schijf fysiek uit je array verwijdert, kun je er nog steeds naar lezen en schrijven. De schijf wordt gesimuleerd door alle andere gegevensschijven en de pariteit te lezen. Op dezelfde manier wordt de pariteitsschijf bijgewerkt als dat nodig is bij het schrijven naar de gesimuleerde schijf. Als je nu een vervangende schijf installeert, kan deze volledig opnieuw worden opgebouwd met de nieuw gereconstrueerde inhoud op basis van de pariteit en alle andere gegevensschijven.
Pariteitscontrole
Tijdens een pariteitssynchronisatie leest het systeem alle gegevensschijven en schrijft de berekende pariteit naar de pariteitschijf.
Tijdens een pariteitscontrole leest het systeem alle gegevensschijven en de pariteitsschijf en vergelijkt de berekende pariteit met de opgeslagen pariteit. Deze bewerking heeft een vlag:
CORRECT - als er een pariteitsmismatch optreedt, schrijf dan de pariteitsschijf met de berekende pariteit en rapporteer dit in syslog NOCORRECT - alleen rapporteren in syslog
Alleen de eerste 100 pariteitscontrolefouten worden gerapporteerd. (De berichten in het systeemlogboek worden gegenereerd voor elk sectoradres waar een onjuiste pariteit overeenkomt. Als je dus een pariteitscontrole uitvoert op een array die geen geldige pariteit heeft, zou het systeemlogboek snel erg groot worden; vandaar de limiet van 100 meldingen).
Deze pariteitsfouten worden “sync errors” of “parity sync errors” genoemd. Ze geven aan hoeveel blokadressen zijn gevonden waarbij de berekende pariteit niet “gesynchroniseerd” was (d.w.z. niet overeenkwam) met de opgeslagen pariteit. (Een “blok” bestaat uit 4096 bytes. Dit is ook de Linux PAGE grootte – de basiseenheid van I/O).
Een geldige pariteitsschijf betekent dat er een pariteitsschijf bestaat en dat een pariteitssynchronisatie op enig moment in het verleden zonder fouten (of afbreken) is voltooid. Zodra de pariteitssynchronisatie is voltooid, is de pariteitsschijf altijd “geldig” (en heeft een groene stip). Geldig” betekent in deze zin dat het gebruikt kan worden om een defecte gegevensschijf te reconstrueren.
(Eigenlijk is ‘geldig’ een status die geldt voor alle array-schijven, zowel de gegevensschijven als de pariteitsschijf. Als alle array-schijven op één na geldig zijn, betekent dit dat de ongeldige schijf kan worden gereconstrueerd met de gegevens van de andere).
Als een pariteitscontrole/correctie fouten oplevert, waarom wordt de pariteitsschijf dan nog steeds als “geldig” gemarkeerd? Als het systeem de pariteitsschijf als “ongeldig” markeert vanwege een handvol pariteitsfouten en vervolgens een andere schijf defect raakt, dan kan deze andere schijf niet meer gereconstrueerd worden (omdat er nu twee ongeldige schijven in de array zouden zijn). De hele pariteitsschijf wordt dus niet als ongeldig gemarkeerd vanwege de pariteitsfouten die zijn gedetecteerd. Natuurlijk kan een gebruiker de pariteit op elk moment ongeldig verklaren door de toewijzing te annuleren.
Zodra de pariteit is berekend, zouden er slechts 2 mogelijkheden moeten zijn voor pariteitscontrolefouten:
- Een onzuivere afsluiting, d.w.z. een plotselinge stroomstoring of een systeemreset. In dit geval kunnen schrijfbewerkingen naar de pariteits- en/of gegevensschijven in behandeling zijn maar niet zijn voltooid, waardoor de corresponderende strook inconsistente pariteit heeft.
- Een niet herkende hardwarefout (bijvoorbeeld een stille geheugenbeschadiging).
Pariteit harde schijf in Unraid
Maat
De grootte van de pariteitsschijf moet gelijk zijn aan of groter zijn dan de grootste gegevensschijf.
Prestaties
Het gebruik van pariteit om je gegevens te beschermen zal onvermijdelijk de prestaties beïnvloeden wanneer je gegevens naar de array schrijft. Elke keer dat er naar een gegevensschijf wordt geschreven, moet de pariteitsschijf ook worden bijgewerkt. Elke schrijfbewerking naar een unRAID-dataschijf met pariteitsbeveiliging resulteert in 4 schijfbewerkingen: Lezen en schrijven voor pariteit en lezen en schrijven voor gegevens. De plaat van elke schijf moet na het lezen een volledige rotatie maken om de schijfkop opnieuw te positioneren boven de sector waarnaar wordt geschreven.
Schrijven naar de unRAID array wordt ook beperkt door de langzaamste (rotatiesnelheid) van de betrokken schijven. Als alleen de pariteitsschijf een 7200 rpm schijf is, ben je nog steeds beperkt door de snelheid van de gegevensschijf. Je zult geen verbetering zien in de schrijfsnelheid, tenzij er tegelijkertijd naar meerdere langzamere gegevensschijven wordt geschreven en een snellere 7200 rpm pariteitsschijf beide probeert bij te houden.
Dubbele pariteit
Bij grote arrays is “dual parity”, oftewel de mogelijkheid om een tweede parity harde schijf te hebben, niet simpelweg een spiegeling van de eerste. Dit maakt twee gelijktijdige schijfstoringen mogelijk zonder gegevensverlies.
In een P + Q redundantie systeem (zoals in een RAID-6 systeem) zouden er twee redundantie schijven zijn: ‘P’, wat de gebruikelijke XOR pariteit is, en ‘Q’, wat een Reed-Solomon code is. Hierdoor kan unRAID herstellen van 2 schijfstoringen met minimale impact op de prestaties. (Verduidelijking vereist dat dit daadwerkelijk wordt gebruikt)