I/O-apparaten, schijven en RAID

Een I/O-apparaat verplaatst gegevens naar of uit een computer of bewaart ze persistent. Een toetsenbord levert invoer; een netwerkkaart verzendt en ontvangt pakketten; een schijf bewaart gegevens nadat de stroom is uitgeschakeld. Apparaten zijn verbonden via bussen, oftewel verbindingen. PCI Express (PCIe) verbindt apparaten met hoge prestaties, zoals NVMe-SSD's. SATA en USB bedienen andere opslag- en randapparaten verderop in de hiërarchie. Snelle verbindingen zijn duurder om te bouwen en hebben strengere fysieke beperkingen, dus een computer combineert verschillende soorten.

De interface is wat de software ziet

Een controller kan processoren, geheugen en firmware bevatten, de software die binnen het apparaat draait. Het besturingssysteem bestuurt de controller via een beschikbaar gestelde hardware-interface. Twee controllers kunnen intern sterk verschillen en toch dezelfde commando's ondersteunen.

Een eenvoudig apparaat heeft drie registers:

Voor een eenvoudige uitvoerbewerking controleert de kernel eerst de status totdat het apparaat gereed is. Daarna schrijft de kernel de gegevens, schrijft het commando en controleert de status totdat de bewerking voltooid is. Tot slot controleert de kernel op een fout. Als het commando wordt geschreven voordat de gegevens zijn aangeleverd, kan een bewerking met de verkeerde inhoud starten. Het herhaaldelijk controleren van de status is polling; de CPU de bruikbare gegevens laten verplaatsen is geprogrammeerde I/O (PIO).

Benader registers veilig

Poortgeadresseerde I/O geeft registers een aparte adresruimte. Op x86 benaderen instructies zoals in en out die poorten. De kernel bepaalt welke code ze mag uitvoeren. Geheugengeadresseerde I/O (MMIO) plaatst registers in de fysieke adresruimte, zodat laad- en opslaginstructies ze kunnen bereiken via koppelingen die door de paginatabellen van de kernel worden beheerd. PCIe-apparaten gebruiken normaal gesproken MMIO.

Een MMIO-adres duidt een apparaatbewerking aan, ook al lijkt de toegang op een geheugentoegang. Een leesbewerking kan een vlag wissen. Een schrijfbewerking kan een overdracht starten. De status kan veranderen doordat het apparaat zijn werk voltooit, zonder dat de CPU naar dat adres schrijft. Gewoon cachegedrag zou die veranderingen kunnen verbergen of toegangen kunnen samenvoegen die het apparaat afzonderlijk nodig heeft.

Linux-stuurprogramma's gebruiken daarom toegangsfuncties zoals readl() en writel(), geschikte koppelingsattributen en vereiste geheugenbarrières. Een volatile pointer kan voorkomen dat de compiler toegangen verwijdert of samenvoegt, maar biedt niet alle vereiste ordening ten opzichte van gewoon geheugen of herordening door de CPU. Een commandodescriptor in RAM moet bijvoorbeeld zichtbaar zijn voor het apparaat voordat een meldingsregister het apparaat vertelt die descriptor op te halen.

Houd de besturing van apparaten in de kernel

Een toepassing roept normaal gesproken read() of write() aan. De kernel controleert de rechten en voert namens de toepassing het apparaatprotocol uit. Dit voorkomt dat één programma commando's geeft die het verzoek van een ander programma verstoren. Een gebruikersbuffer is het gegevensgebied van de toepassing; een commandoregister is het besturingspunt van de controller. Ze vervullen verschillende rollen, ook al hebben beide een adres.

Een apparaat kan veel langer nodig hebben om een verzoek af te ronden dan de CPU nodig heeft om het in te dienen. De wachtstrategie bepaalt of de CPU die tijd besteedt aan het controleren van het apparaat of aan ander werk. Ze verandert niet hoe snel het apparaat zelf het verzoek voltooit.

Pollen of slapen

Bij polling leest de CPU herhaaldelijk de status. Een voltooiing kan snel worden opgemerkt, maar controles terwijl het apparaat nog bezig is, verbruiken CPU-tijd. Bij interrupts wordt een proces dat op een leesbewerking wacht geblokkeerd en kan een ander gereed proces draaien. Als het apparaat klaar is, geeft het de CPU een signaal. De interruptafhandelaar van de kernel, ook wel interruptserviceroutine genoemd, controleert de voltooiing, handelt het resultaat af en maakt het wachtende proces gereed. De scheduler bepaalt wanneer dat proces weer draait.

Stel dat proces A een schijfleesbewerking start die 10 ms duurt. Polling houdt de CPU tijdens dat wachten bezig. Bij interruptgestuurde I/O kan proces B gedurende dezelfde 10 ms berekeningen uitvoeren. De apparaatbewerking van A duurt nog steeds 10 ms; nuttige berekeningen overlappen het wachten.

Interrupts kosten ook werk: de CPU slaat de toestand op, voert de afhandelaar uit, herstelt de toestand en wisselt mogelijk van proces en vult caches opnieuw. De kosten bedragen doorgaans enkele microseconden. Als een apparaat binnen 2 µs reageert, kan een korte pollinglus goedkoper zijn dan het blokkeren en wekken van het proces. Interrupts zijn geschikt voor langzame bewerkingen; kort pollen is geschikt voor zeer snelle bewerkingen.

Pas je aan de voltooiingssnelheid en belasting aan

Een hybride strategie, in twee fasen, gebruikt eerst kort polling en slaapt daarna tot een interrupt als het verzoek nog niet voltooid is. Snelle voltooiingen vermijden de kosten van het wekken, terwijl langzame voltooiingen de CPU niet de hele tijd bezighouden. Linux ondersteunt voltooiing via polling voor geschikte snelle opslagverzoeken.

Zwaar interruptverkeer veroorzaakt een ander probleem. Als bijna elke CPU-cyclus wordt besteed aan het afhandelen van nieuw binnenkomende gebeurtenissen, krijgt de code die hun gegevens verwerkt weinig tijd om te draaien. Dit is livelock: de machine is bezig, maar de nuttige voortgang stort in. Het NAPI-netwerkmechanisme van Linux beperkt het werk aan interrupts en schakelt bij belasting over op polling van reeksen pakketten.

Interruptbundeling groepeert meerdere voltooiingen in één melding. Bij 100.000 voltooiingen per seconde en 5 µs CPU-werk per interrupt kosten afzonderlijke meldingen:

Dat is elke seconde de helft van de tijd van één CPU-kern. Acht voltooiingen per interrupt combineren levert 12.500 interrupts en 62,5 ms CPU-werk per seconde op, oftewel 6,25% van een processorkern. Een verzoek kan kort op de rest van de reeks wachten, dus lagere overhead gaat samen met extra meldingslatentie.

Stuur meldingen naar de juiste kern

PCIe-apparaten gebruiken vaak MSI of MSI-X: interrupts die als berichten op een speciaal adres worden afgeleverd. Met meerdere interruptvectoren kan een apparaat voltooiingen van verschillende wachtrijen naar verschillende kernen sturen. Een NVMe-controller kan wachtrijen per kern koppelen aan geschikte interruptvectoren, zodat het indienen en afhandelen van voltooiingen dicht bij elkaar blijven. Meer vectoren ordenen het CPU-werk; ze verkorten een leesbewerking op flashgeheugen of een schijfrotatie niet.

Wachten en kopiëren zijn afzonderlijke taken. Interrupts kunnen voorkomen dat de CPU actief wacht terwijl een apparaat werkt, maar de CPU zou nog steeds bezig zijn als die elk woord via een gegevensregister moest verplaatsen. Directe geheugentoegang (DMA) draagt die overdracht op aan een hardware-eenheid, meestal binnen de apparaatcontroller.

Meet het werk dat PIO aan de CPU overlaat

Stel je een gegevensregister van 4 bytes voor waarbij elke toegang 100 ns duurt. Een blok van 4 KiB verplaatsen vereist:

Die registerbewerkingen houden de CPU bezig. Grotere buffers vereisen evenredig meer toegangen. DMA neemt dat kopiëren per woord via het register weg; de CPU bereidt het verzoek nog steeds voor en handelt de voltooiing af.

Volg een leesbewerking met DMA

1. Het stuurprogramma bereidt een doelbuffer voor en maakt die beschikbaar voor toegang door het apparaat.
2. Het geeft het DMA-adres of de DMA-adressen, het aantal bytes, de richting en het leescommando door.
3. Het apparaat leest de gevraagde opslagblokken en schrijft de bytes naar het geheugen.
4. De CPU voert ander werk uit terwijl het apparaat gegevens overdraagt.
5. De voltooiing wordt gemeld, meestal door een interrupt. De afhandelaar controleert de status en wekt het wachtende proces.

De DMA-eenheid treedt op als busmaster en start geheugenoverdrachten. De kosten van het instellen hangen af van de geheugenkoppeling, het platform en het aantal geheugengebieden. DMA verbruikt ook geheugenbandbreedte die met de CPU wordt gedeeld. DMA maakt CPU-instructies vrij, niet alle bronnen.

Beschrijf verspreid geheugen

Een buffer kan aaneengesloten zijn in de virtuele adresruimte van een proces en tegelijk afzonderlijke fysieke pagina's bezetten. Een scatter-gatherlijst beschrijft die gebieden als paren van adres en lengte. Een apparaat kan één verzoek over meerdere gebieden overdragen zonder dat de CPU ze eerst naar één fysiek aaneengesloten buffer kopieert.

Een buffer van drie pagina's kan bijvoorbeeld worden ondersteund door drie niet-aangrenzende pagina's. Het stuurprogramma maakt descriptoren voor de gebieden die het apparaat kan zien en houdt de onderliggende pagina's stabiel totdat de overdracht is voltooid. Vastzetten voorkomt dat die pagina's worden verwijderd of hergebruikt terwijl hardware er nog toegang toe kan hebben. Als ze te vroeg worden losgemaakt, kan een latere DMA-schrijfbewerking gegevens van een ander overschrijven.

Gebruik de adresruimte van het apparaat

Een apparaat gebruikt normaal gesproken niet de virtuele pointer van een toepassing. De DMA-API van de kernel levert busadressen, die kunnen verschillen van de fysieke adressen van de CPU. Een IOMMU vertaalt apparaatadressen naar fysiek geheugen en beperkt tot welk geheugen een apparaat toegang heeft. Deze isolatie helpt een hypervisor ook om een apparaat aan een virtuele machine toe te wijzen.

CPU-caches voegen nog een coördinatiestap toe. Vóór een uitgaande DMA-overdracht moet het apparaat de meest recente bytes van de CPU zien; na een inkomende overdracht moet de CPU de wijzigingen van het apparaat zien. Sommige hardware zorgt automatisch voor coherentie. Andere platforms vereisen cachesynchronisatie via de DMA-API. Adreskoppeling, de levensduur van pagina's en zichtbaarheid via de cache lossen elk een ander deel van de veilige overdracht op.

Een apparaatstuurprogramma vertaalt een algemeen verzoek naar de commando's en registertoegangen van een controller en handelt de voltooiing af. Zo kan een bestandssysteem om een blok vragen zonder te weten of de hardware SATA, NVMe of USB gebruikt. Het stuurprogramma kent het specifieke protocol en de eigenaardigheden van de controller.

Geef elke laag een taak

Een opslagleesbewerking in Linux doorloopt meestal deze keten:

Toepassing → systeemaanroep → bestandssysteem → algemene bloklaag → stuurprogramma → controller → opslagapparaat.

Het bestandssysteem koppelt een bestandspositie aan opslagblokken. De bloklaag plaatst verzoeken in wachtrijen, voegt aangrenzende verzoeken samen en kan de volgorde ervan plannen. Het stuurprogramma dient de resulterende bewerkingen in. Rechtstreekse toegang tot een ruw blokapparaat kan het bestandssysteem overslaan en toch de lagere lagen gebruiken.

Dankzij de standaardinterface is nieuwe hardware bruikbaar zonder elke toepassing te herschrijven. Die verbergt ook sommige speciale functies. Via interfaces zoals ioctl() of het rechtstreeks doorgeven van commando's kan software om besturingsfuncties vragen die niet passen bij een gewone lees- of schrijfbewerking van een blok.

Onderscheid apparaatklassen

Linux stelt blok- en tekenapparaten beschikbaar als speciale bestanden, zoals /dev/sda en /dev/nvme0n1. Stuurprogramma's draaien meestal in kernelmodus, dus een fout in een stuurprogramma kan de kernel laten crashen of het geheugen beschadigen. Isolatie van stuurprogramma's beperkt de gevolgen in systemen die dat ondersteunen. De verzameling stuurprogramma's van Linux vormt een groot deel van de broncode; onderzoek heeft ook uitgewezen dat code van stuurprogramma's bijzonder foutgevoelig is.

Plaats werk in wachtrijen voor meerdere kernen

De blk-mq-bloklaag van Linux gebruikt softwarewachtrijen per CPU en hardwareverzendwachtrijen. Een I/O-scheduler zoals mq-deadline, bfq of kyber kan werk herordenen of eerlijk verdelen; none vermijdt extra planningsbeleid. Harde schijven hebben baat bij minder zoekbewegingen. Snelle NVMe-apparaten gebruiken vaak none, omdat ze geen kop hebben die opnieuw moet worden gepositioneerd. De geselecteerde scheduler staat tussen vierkante haken in /sys/block/<device>/queue/scheduler.

SATA met AHCI/NCQ ondersteunt per apparaat een commandowachtrij met maximaal 32 uitstaande commando's. NVMe ondersteunt veel indienings- en voltooiingswachtrijen in het geheugen: maximaal 65.535 I/O-wachtrijen, met maximaal ongeveer 64.000 commando's per wachtrij. Werkelijke controllers hebben lagere limieten. Wachtrijparen per kern verminderen de concurrentie om gedeelde indieningsroutes.

Volg één NVMe-leesbewerking

Een proces roept read(fd, buf, 4096) aan. Bij een cachemisser zoekt het bestandssysteem het schijfblok en bouwt de bloklaag een verzoek op. Het NVMe-stuurprogramma schrijft een descriptor in een indieningswachtrij en schrijft daarna naar het MMIO-meldingsregister ervan. De controller haalt het commando op, draagt de gegevens via DMA over naar het geheugen en plaatst een voltooiingsvermelding. Een MSI-X-interrupt leidt ertoe dat de kernel het verzoek afhandelt. Bij een gebufferde leesbewerking bereiken de gegevens via de paginacache de buffer van de toepassing en retourneert read() 4096. Een cachetreffer kan de leesbewerking afhandelen voordat I/O met het apparaat nodig is.

Een harde schijf biedt een reeks sectoren aan die vanaf nul zijn genummerd. Deze nummers zijn logische blokadressen (LBA's). Traditioneel was een sector 512 bytes groot; veel schijven gebruiken nu fysieke sectoren van 4.096 bytes. Een 512e-schijf accepteert logische sectoren van 512 bytes boven op dat grotere fysieke formaat. Een blok van 4 KiB van een bestandssysteem kan daardoor meerdere logische sectoren beslaan.

Stel je de bewegende onderdelen voor

Magnetische schijfplaten draaien op een spil. Elk oppervlak heeft concentrische sporen die in sectoren zijn verdeeld en een lees-/schrijfkop op een bewegende arm. De koppen bewegen samen. Sporen op dezelfde armpositie op verschillende oppervlakken vormen een cilinder. Veelvoorkomende spilsnelheden zijn 5.400 en 7.200 RPM, met 10.000 en 15.000 RPM bij snellere schijffamilies.

Nabijgelegen LBA's worden meestal dicht bij elkaar geplaatst, zodat sequentiële leesbewerkingen herhaalde zoekbewegingen vermijden. Een sector die aan een reservesector is gekoppeld, kan die samenhang doorbreken. Software ziet zo een bruikbare lineaire adresruimte zonder de exacte fysieke plaatsing te kennen.

Buitenste sporen hebben meer ruimte voor sectoren. Opslag in zones plaatst meer sectoren op die sporen, zodat per omwenteling meer bytes onder de kop passeren. De sequentiële doorvoer kan dalen wanneer een leesbewerking naar het midden beweegt. Sectorverschuiving tussen sporen verschuift sectorposities tussen aangrenzende sporen: nadat de kop van spoor is veranderd, komt de volgende sequentiële sector op het juiste moment aan in plaats van net te zijn gepasseerd.

Onderscheid voltooiing van duurzaamheid

Een schijfcache kan recent gelezen gegevens bewaren en schrijfbewerkingen aannemen. Deze buffers variëren van enkele megabytes tot honderden megabytes; een leescache kan de rest bewaren van een spoor dat al onder de kop passeert. Bij terugschrijven kan een schrijfbewerking worden voltooid terwijl de gegevens nog in een vluchtige cache staan. Bij doorschrijven wordt op het medium gewacht. Een commando om de cache weg te schrijven vraagt om gebufferde schrijfbewerkingen op duurzame opslag vast te leggen; verplichte opslag op het persistente medium (FUA) vraagt om duurzame voltooiing van de betreffende schrijfbewerking.

Atomiciteit bij stroomuitval is een andere eigenschap. Een atomaire schrijfeenheid verandert volledig of blijft ongewijzigd als de stroom uitvalt. De sectorgrootte alleen biedt die garantie niet: het apparaat moet de garantie documenteren. Een schrijfbewerking over meerdere atomaire eenheden kan een gedeeltelijk uitgevoerde schrijfbewerking achterlaten, met enkele nieuwe en enkele oude eenheden. Het wegschrijven van de cache zorgt voor duurzaamheid; atomaire eenheden gaan over gedeeltelijke wijzigingen.

Lees capaciteitsaanduidingen correct

Schijfcapaciteiten gebruiken decimale SI-voorvoegsels. Binaire eenheden gebruiken machten van twee:

Een schijf van 4 TB bevat daarom:

Beide aanduidingen beschrijven hetzelfde aantal bytes. Een hulpprogramma dat ongeveer 3,64 toont met het label “TB”, heeft binair gerekend met een decimaal ogend label; door de omzetting is geen ruimte verdwenen.

Herken een extra beperking bij schrijven

Dakpansgewijze magnetische opslag (SMR) laat aangrenzende sporen overlappen om meer gegevens op te slaan. Het herschrijven van één spoor kan het buurspoor verstoren, waardoor kleine willekeurige wijzigingen duur zijn. Grote sequentiële schrijfbewerkingen in geschikte zones werken beter. Dit is een magnetische schijf met een beperking in het schrijfbeheer, hoewel gewone leesbewerkingen nog steeds dezelfde koppen en draaiende schijfplaten gebruiken.

Een schijfverzoek kost tijd om de gegevens te bereiken voordat de overdracht begint. Verdeel voor een eenvoudig verzoek zonder wachtrijtijd of cachetreffer de afhandelingstijd in drie delen:

Bij het zoeken beweegt de arm naar het spoor en komt daar tot rust. Tijdens de rotatievertraging wordt gewacht tot de sector de kop bereikt. De overdrachtstijd omvat de bytes die eronder passeren. Een eventuele wachtrij voegt wachttijd toe voordat de afhandeling begint.

Reken RPM om naar wachttijd

Eén omwenteling duurt 60.000 ms gedeeld door het toerental in RPM. Bij 7.200 RPM:

Bij een willekeurige sectorpositie is de gemiddelde wachttijd een halve omwenteling, ongeveer 4,17 ms. Bij 15.000 RPM duurt een omwenteling 4 ms en is de gemiddelde wachttijd 2 ms. Een hoger toerental vermindert de rotatievertraging; het vermindert de zoektijd van de arm niet rechtstreeks.

Specificatiebladen geven een gemiddelde zoektijd. Bij gelijkmatig verdeelde verzoeken is de gemiddelde zoekafstand ongeveer een derde van de volledige bewegingsafstand, maar zoektijd is niet evenredig met afstand. Versnellen en tot rust komen overheersen bij korte zoekbewegingen; lange zoekbewegingen omvatten meer afstand op volle snelheid.

Bereken een kleine willekeurige leesbewerking

Gebruik een schijf van 7.200 RPM met een gemiddelde zoektijd van 8 ms en een overdrachtssnelheid van 200 MB/s. Een verzoek van 4 KiB bevat 4.096 bytes. Bereken eerst de overdracht in seconden:

Tel daarna positionering en overdracht bij elkaar op:

Steeds één uitstaand verzoek geeft ongeveer:

De effectieve snelheid is ongeveer 4.096 bytes vermenigvuldigd met 82 per seconde, oftewel 0,34 MB/s. Een opgegeven overdrachtssnelheid van 200 MB/s beschrijft het verplaatsen van gegevens nadat de schijf is gepositioneerd; die snelheid neemt de ongeveer 12 ms positionering per klein willekeurig verzoek niet weg.

Bereken een lange sequentiële leesbewerking

Lees nu 100 MB met één zoekbeweging en rotatiewachttijd aan het begin. De overdrachtstijd is 100/200 s, oftewel 500 ms. De totale tijd is ongeveer 512,17 ms, wat geeft:

De effectieve snelheid is ongeveer 580 keer de snelheid bij kleine willekeurige leesbewerkingen. Eén positionering wordt over veel meer bytes verdeeld. Bij grote sequentiële overdrachten overheerst de overdrachtstijd; bij kleine willekeurige verzoeken overheerst de positionering.

Gebruik bytes consequent wanneer je KiB met MB/s combineert en reken milliseconden om naar seconden voordat je bytes door tijd deelt. IOPS past bij kleine willekeurige bewerkingen; MB/s past bij sequentiële stromen. Vooruit lezen, nabije plaatsing en kleine schrijfbewerkingen samenvoegen tot sequentiële reeksen verbeteren de prestaties doordat minder vaak positionering nodig is.

Een schijfscheduler kiest welk wachtend verzoek als volgende wordt afgehandeld. De positie geeft nuttige informatie over de afhandelingskosten. Minder armbeweging helpt, maar beleid moet ook rekening houden met hoe lang afzonderlijke verzoeken wachten.

Vergelijk het beleid

SSTF kan steeds nieuwe verzoeken in de buurt kiezen terwijl een verafgelegen verzoek wacht. Een besturingssysteem dat de exacte geometrie niet kent, benadert dit vaak met de LBA-afstand; dit heet dichtstbijzijnde blok eerst. Eerlijkheid bij SCAN-achtig beleid veronderstelt dat het systeem tijdens de beweging verzoeken kan blijven afhandelen; een overbelast apparaat kan nog steeds niet voor elk binnenkomend verzoek een vaste responstijd bieden.

Tel de beweging per traject op

Neem sporen 0–199, een kop op 50 die naar hogere spoornummers beweegt en binnenkomende verzoeken 82, 170, 43, 140, 24, 16, 190. Stop met tellen zodra alle verzoeken zijn afgehandeld.

FCFS volgt de lijst. De beweging is 32 + 88 + 127 + 97 + 116 + 8 + 174 = 642 sporen. SSTF bezoekt 43, 24, 16, 82, 140, 170, 190, in totaal 208 sporen.

SCAN bezoekt de hogere verzoeken, gaat door naar 199 en keert dan om naar 16. De afstand is 149 + 183 = 332. LOOK keert om bij 190, wat 140 + 174 = 314 geeft. C-LOOK gaat van 50 naar 190, keert terug naar 16 en eindigt bij 43: 140 + 174 + 27 = 341 sporen. De terugkeer is een echte beweging, ook al wordt onderweg geen verzoek afgehandeld. C-SCAN zou naar 199 gaan, zonder afhandeling terugkeren naar 0 en daarna in oplopende richting verzoeken afhandelen tot en met 43.

Het beste totaal in deze eindige wachtrij bepaalt niet welk beleid het beste is voor een stroom toekomstige verzoeken. De geringe beweging van SSTF gaat hier bij aanhoudende belasting samen met een risico op uithongering.

Neem rotatie en firmware mee

Kortste positioneringstijd eerst (SPTF) minimaliseert de som van zoek- en rotatievertraging. Een verder gelegen spoor kan winnen als de sector ervan eerder aankomt. Nauwkeurige keuzes vereisen kennis van de geometrie en rotatiepositie, dus de firmware van de schijf kan die beter maken dan het besturingssysteem.

Het besturingssysteem kan verzoeken om aangrenzende blokken samenvoegen en daarna meerdere commando's via NCQ indienen. Firmware herordent die reeks met interne informatie. Anticiperende planning kan de schijf kort ongebruikt laten om te wachten op een waarschijnlijk vervolgverzoek in de buurt. Deadlineplanning beperkt uitstel; mq-deadline van Linux houdt bij wanneer verzoeken verlopen en geeft voorrang aan leesbewerkingen. SSD-planning richt zich op eerlijkheid en latentie, omdat er geen zoekbeweging of rotatie te besparen valt.

NAND-flashgeheugen slaat informatie op als elektrische lading in cellen. De controller onderscheidt ladingsniveaus om de bits te lezen. Een cel die meer bits bevat, heeft meer onderscheidbare niveaus nodig. Dat levert meer capaciteit op, maar maakt programmeren en foutcontrole moeilijker.

Tel de ladingsniveaus

Voor een cel met b bits is het aantal niveaus $2^b$. Meer bits per cel verlagen doorgaans de kosten per gigabyte, terwijl programmeren langzamer wordt en het aantal verdraagbare wiscycli afneemt. Dit zijn eigenschappen van de celindeling; ook de controller en het parallellisme van de hele SSD beïnvloeden de prestaties.

Koppel elke bewerking aan de juiste eenheid

Flashchips bevatten wisblokken, die elk veel pagina's bevatten. Een pagina is meestal 4–16 KiB groot, terwijl een wisblok honderden pagina's kan bevatten en honderden KiB tot meerdere MiB kan beslaan. Een flashpagina, een virtuele geheugenpagina en een bestandssysteemblok zijn verschillende eenheden, ook als sommige groottes toevallig overeenkomen.

Een leesbewerking levert een pagina op, meestal in tientallen microseconden. Een programmeerbewerking schrijft een gewiste pagina en duurt honderden microseconden. Een wisbewerking zet een heel blok terug naar enen en duurt milliseconden. Pagina's worden geprogrammeerd in de volgorde die de chip vereist, meestal van lagere naar hogere pagina's. De controller moet bij het plaatsen van gegevens die volgorderegels volgen.

Een gebruikte pagina kan niet zomaar een vervangende versie ontvangen. Het wisblok moet eerst worden gewist, waardoor de inhoud van elke pagina in dat blok verloren gaat. Dit is het centrale verschil: schrijfbewerkingen hebben de grootte van een pagina, wisbewerkingen die van een blok.

Bekijk de kosten van een wijziging op dezelfde plaats

Stel je één blok voor met de pagina's A, B, C en D. Om A door A′ te vervangen en dezelfde fysieke plaatsing te behouden:

1. Lees B, C en D naar tijdelijke opslag.
2. Wis het hele blok, inclusief de oude A.
3. Programmeer A′, B, C en D in de gewiste pagina's.

Eén pagina met nieuwe informatie heeft drie leesbewerkingen, vier programmeerbewerkingen en een wisbewerking veroorzaakt. Alleen A wissen is niet mogelijk. Een SSD vermijdt deze kosten bij elke overschrijving door het hostsysteem door de vervanging elders te schrijven en de koppeling te veranderen.

Beheer schade en het vasthouden van lading

Elke programmeer-wiscyclus (P/E-cyclus) beschadigt de cellen een beetje. Representatieve bereiken voor de levensduur zijn ongeveer 50.000–100.000 cycli voor SLC, 1.000–3.000 voor TLC en ongeveer 1.000 of minder voor QLC; werkelijke opgaven verschillen sterk per chipgeneratie en fabrikant. Controllers nemen blokken die onbetrouwbaar worden buiten gebruik.

Lading lekt ook na verloop van tijd weg, vooral in versleten cellen. Lezen of programmeren kan nabijgelegen cellen verstoren. Sterke foutcorrigerende codes (ECC) herstellen veel van de resulterende bitfouten en de controller kan gegevens waarvan het aantal fouten stijgt verversen. Flashgeheugen is persistente opslag met asymmetrische bewerkingen en een beperkte levensduur, dus een snelle leesbewerking van een pagina zegt op zichzelf weinig over de kosten van aanhoudend overschrijven.

Het hostsysteem leest en overschrijft logische blokken. De flashvertaallaag (FTL) van de SSD koppelt die adressen aan fysieke flashpagina's en beheert de onderliggende wisbewerkingen die voor het hostsysteem verborgen blijven. Logische pagina N permanent op fysieke pagina N houden, zou ertoe leiden dat bij veelvuldig overschrijven steeds dezelfde blokken worden gewist.

Schrijf een nieuwe versie elders

Een loggestructureerde FTL programmeert nieuwe gegevens in een vrije pagina en verandert de koppeling. Stel dat LBA 100 naar fysieke pagina 0 verwijst en LBA 101 naar pagina 1. Een overschrijving van LBA 100 wordt op pagina 2 geprogrammeerd. De koppeling wordt 100 → 2; pagina 0 wordt ongeldig. Het hostsysteem vraagt nog steeds om LBA 100 en krijgt de nieuwe versie.

Ongeldig is een toestand van de koppeling, geen onmiddellijke fysieke wisbewerking. De oude bits blijven staan totdat hun wisblok wordt vrijgemaakt. Een bestand verwijderen of overschrijven biedt daarom geen betrouwbare garantie over wanneer elke oude fysieke kopie verdwijnt. Betrouwbaar wissen gebruikt een geschikte sanitiseerbewerking van de schijf of een correct beheerd versleutelingsschema voor de hele schijf met vernietiging van de sleutel.

Maak ruimte vrij en tel extra schrijfbewerkingen

Bij het opruimen van ongeldige flashgegevens (GC) kiest de FTL een blok, kopieert de geldige pagina's elders naartoe, werkt de vertaaltabel bij en wist het oude blok. Ongeldige pagina's hoeven niet te worden gekopieerd. Een blok met veel ongeldige pagina's levert meer vrije ruimte op per gekopieerde geldige pagina.

Schrijfversterking (WA) meet dat extra programmeren:

In een blok van 64 pagina's met 48 geldige en 16 ongeldige pagina's kopieert GC 48 pagina's. Het wissen van het blok creëert 64 vrije pagina's, maar de kopieën hebben elders 48 pagina's verbruikt: de nettowinst is 16. Als die winst wordt gevuld met 16 pagina's van het hostsysteem, levert dat 64 programmeerbewerkingen van flashpagina's op voor 16 schrijfbewerkingen van hostpagina's, dus WA = 4. Hogere versterking verbruikt bandbreedte en de beschikbare wiscycli sneller.

Reservecapaciteit reserveert flashruimte die het hostsysteem niet kan vullen. Meer vrije ruimte geeft GC de mogelijkheid om goedkopere blokken te kiezen. TRIM, Deallocate genoemd in NVMe en UNMAP in SCSI, vertelt het apparaat welke logische bereiken geen benodigde gegevens meer bevatten. De pagina's van een verwijderd bestand kunnen dan als ongeldig worden behandeld in plaats van tijdens GC te worden gekopieerd.

Houd rekening met geheugen voor de vertaaltabel en met slijtage

Een vertaaltabel op paginaniveau heeft één vermelding per logische pagina nodig. Een apparaat van 1 TiB met pagina's van 4 KiB heeft:

Bij 4 bytes per vermelding neemt de tabel 1 GiB in. Koppeling op blokniveau verkleint de tabel maar maakt kleine wijzigingen duur. Hybride koppeling combineert bloktabellen met loggebieden die op paginaniveau worden gekoppeld; een andere aanpak cachet alleen actieve vermeldingen uit de paginatabel voor de vertaling.

Slijtageverdeling spreidt wisbewerkingen over blokken. Nieuwe schrijfbewerkingen worden al verspreid, maar blokken met koude, ongewijzigde gegevens kunnen anders voorgoed slijtage vermijden terwijl hete gebieden verslijten. Door sommige koude gegevens te verplaatsen, komen weinig gebruikte blokken vrij om mee te doen aan schrijfbewerkingen. Die migratie kan extra schrijfbewerkingen opleveren, dus de controller weegt gelijkmatige slijtage af tegen kopieerkosten.

Een SSD heeft geen schijfarm of draaiende schijfplaat. Die vermijdt positioneringsvertragingen van milliseconden, maar de snelheid hangt nog steeds af van de verzoekgrootte, het parallellisme, de schrijfgeschiedenis en het werk dat de controller op de achtergrond uitvoert.

Vergelijk latentie en doorvoer

Dit zijn representatieve apparaatklassen, geen garanties voor elke schijf. De doorvoer van SATA-SSD's wordt beperkt door de verbinding van 6 Gb/s. NVMe gebruikt PCIe en kan veel flashkanalen tegelijk bezighouden.

Een programma dat één kleine leesbewerking aanvraagt en wacht tot die klaar is voordat het de volgende aanvraagt, merkt de latentie van elk verzoek. Bij een latentie van 80 µs staat dat seriële patroon ongeveer 12.500 bewerkingen per seconde toe. Een apparaat waarvoor een veel hoger aantal IOPS wordt opgegeven, heeft veel uitstaande verzoeken nodig, aangeleverd door threads of asynchrone I/O. Wachtrijdiepte biedt kansen voor parallel werk; die kan ook wachttijd toevoegen wanneer het apparaat verzadigd is.

Houd rekening met de schrijfgeschiedenis

Willekeurige en sequentiële schrijfbewerkingen blijven verschillen. Willekeurige wijzigingen kunnen ongeldige pagina's verspreid tussen geldige pagina's achterlaten, waardoor GC meer moet kopiëren. Sequentiële werklasten kunnen hele gebieden tegelijk ongeldig maken, waardoor vrijmaken goedkoper wordt en WA dichter bij één blijft. Een lege SSD kan rechtstreeks in vrije ruimte programmeren; een gevulde SSD moet ruimte vrijmaken. Prestaties in de stationaire toestand omvatten die voortdurende GC-kosten, terwijl tests direct uit de doos dat mogelijk niet doen.

Lees levensduuropgaven als een schrijfbudget

TBW is het opgegeven totale aantal terabytes dat door het hostsysteem wordt geschreven. DWPD drukt het aantal volledige schijfbeschrijvingen door het hostsysteem per dag uit gedurende de garantieperiode. Voor een apparaat van 1 TB met een opgave van 600 TBW over vijf jaar:

Bij 50 GB per dag loopt het aantal schrijfbewerkingen van het hostsysteem na 12.000 dagen, ongeveer 33 jaar, op tot 600 TB. Die berekening vergelijkt werklasten en is geen voorspelling van de levensduur: uitval van de controller, veroudering en garantiegrenzen blijven van belang. Hoge interne versterking laat cellen sneller slijten, ook al telt de levensduuropgave de schrijfbewerkingen van het hostsysteem.

Stem het apparaat af op het werk

Harde schijven bieden lage kosten per terabyte voor grote, weinig geraadpleegde gegevensverzamelingen. SSD's zijn geschikt voor werk waarbij latentie belangrijk is. Gelaagde opslag bewaart hete gegevens op SSD's en koudere gegevens op schijven. Beide kunnen uitvallen: schijven hebben mechanische defecten en slechte sectoren; SSD's hebben slijtage, controllerdefecten en firmwarefouten. Redundantie en afzonderlijke back-ups blijven voor beide nuttig.

Bij SSD's voegt defragmentatie schrijfbewerkingen toe met weinig voordeel voor zoekbewegingen. TRIM helpt de controller ongebruikte gegevens te herkennen. Huidige partitioneringsprogramma's lijnen het begin vaak uit op grenzen van 1 MiB, zodat slecht uitgelijnde blokverzoeken worden vermeden.

RAID, een redundante array van goedkope of onafhankelijke schijven, presenteert meerdere fysieke schijven als één logisch blokapparaat. Intern stuurt een koppeling elk logisch blok naar gegevenskopieën of naar een strook met redundantie. Toepassingen en bestandssystemen kunnen de blokinterface blijven gebruiken zonder die indeling te begrijpen.

Vergelijk drie afzonderlijke maten

Capaciteit is de bruikbare ruimte voor gebruikersgegevens. Betrouwbaarheid beschrijft de uitval die een indeling kan verdragen. Prestaties omvatten zowel doorvoer over veel bewerkingen als latentie voor één bewerking. Een niveau kan de ene maat verbeteren terwijl een andere afneemt. Meer totale doorvoer hoeft ook de latentie van één blokverzoek niet te verlagen.

Gebruik dit eenvoudige model voor schijven van gelijke grootte:

S en R gebruiken dezelfde snelheidseenheden, zoals MB/s. Bij een harde schijf verschillen ze sterk: het eerdere tijdvoorbeeld gaf ongeveer 195 MB/s sequentieel en 0,34 MB/s voor kleine willekeurige leesbewerkingen. De modelformules gaan uit van voldoende gelijktijdig werk en geen knelpunt bij de controller; hun doel is de kosten van de indeling zichtbaar te maken.

Benoem het foutmodel

Een schijf volgens het model van volledige, detecteerbare uitval werkt correct totdat die volledig en zichtbaar uitvalt. Dit maakt de basisredenering over RAID overzichtelijk: de array weet welke schijf ontbreekt. Echte schijven kunnen ook onleesbare sectoren hebben of onjuiste bytes teruggeven. Die gedeeltelijke en ongemerkte fouten vereisen integriteitscontroles naast een indeling die het verlies van een hele schijf overleeft.

Een redundante array werkt in gedegradeerde modus zolang de uitgevallen schijven binnen de fouttolerantie blijven. De array levert nog steeds gegevens, maar overgebleven schijven verrichten extra werk of hebben minder resterende leescapaciteit. Bij een wederopbouw wordt een vervangende schijf gevuld met de overgebleven informatie. Een direct inzetbare reserveschijf is een ongebruikte geïnstalleerde schijf waarmee de wederopbouw snel kan beginnen. RAID-0 heeft geen redundantie en na verlies van een schijf ook geen dergelijke gedegradeerde werking.

Houd wijzigingen op meerdere schijven consistent

RAID kan draaien in een hardwarecontroller met een eigen processor en beschermde cache, in software van het besturingssysteem zoals Linux md, of binnen een bestandssysteem zoals ZFS. Elk moet omgaan met een schrijfbewerking die tussen wijzigingen op verschillende schijven wordt onderbroken. Spiegelkopieën kunnen verschillen; gegevens en pariteit kunnen verschillende versies beschrijven. Het geval met pariteit is de pariteitsinconsistentie door een onderbroken schrijfbewerking.

Een beschermde niet-vluchtige cache of een geschikt journaal kan wachtende wijzigingen bewaren voor herstel. Een bitmap voor voorgenomen schrijfbewerkingen legt vast welke gebieden na een onderbreking opnieuw moeten worden gesynchroniseerd. Die bewaart de nieuwe gegevens niet en is op zichzelf geen volledige oplossing voor de pariteitsinconsistentie als ook een schijf ontbreekt.

RAID houdt gegevens beschikbaar bij de opgegeven schijfuitval. Een verwijdering of schrijfbewerking door ransomware bereikt de kopieën van de array via de normale interface. Brand of diefstal kan de hele array wegnemen. Afzonderlijke back-ups bieden herstelbare versies of kopieën die zulke gezamenlijke gebeurtenissen overleven.

RAID-0 verdeelt gegevens in stroken over schijven zonder redundante informatie te bewaren. Bij een strookdeel van één blok en nummering vanaf nul gaat logisch blok A naar:

Bij vier schijven hoort blok 14 op schijf 2 op offset 3. Modulo kiest de schijf; geheeldelige deling telt de volledige strookrijen vóór dat blok.

Neem de strookdeelgrootte mee in de koppeling

Een strookdeel is een reeks opeenvolgende blokken die op één schijf wordt geplaatst voordat de volgende aan de beurt is. Noem de grootte c blokken. Bepaal eerst het strookdeel, daarna de schijf en de lokale offset:

Voor blok 14, c = 2 en N = 4 is het strookdeel 7, de schijf 3 en de offset 2. Rechtstreeks A modulo N gebruiken zou de strookdelen van twee blokken negeren. Kleine strookdelen kunnen een groot verzoek over meer schijven verspreiden; grotere strookdelen houden meer werk in de buurt op één schijf. Gebruikelijke strookdelen in arrays variëren van 64 tot 512 KiB; Linux md gebruikt doorgaans standaard 512 KiB.

RAID-0 heeft capaciteit NB en ideale totale sequentiële en willekeurige snelheden NS en NR. Een klein verzoek aan één schijf duurt nog steeds ongeveer T. Uitval van een willekeurige schijf veroorzaakt verlies van een deel van de arraygegevens. Daarom is deze indeling geschikt voor reproduceerbare tijdelijke gegevens wanneer beschikbaarheid onbelangrijk is.

Voeg spiegelkopieën toe

Een RAID-1-spiegel met twee schijven schrijft elk blok naar beide schijven. RAID-10 verdeelt gegevens in stroken over gespiegelde paren. Bij vier schijven en strookdelen van één blok over paren gaat blok A naar paar A modulo 2 op offset ⌊A/2⌋, en beide schijven van het paar slaan het op.

RAID-10 gebruikt de helft van de ruwe capaciteit. Het overleeft elke afzonderlijke uitval en kan N/2 uitgevallen schijven overleven als elk een ander paar treft. Als beide schijven van één paar uitvallen, gaan de gegevens van dat paar verloren, zelfs als alle andere paren gezond blijven.

Tel het nuttige werk per schijf

Elke gespiegelde schrijfbewerking werkt twee schijven parallel bij. De latentie is ongeveer T, bepaald door de langzaamste schijf, terwijl de totale willekeurige schrijfdoorvoer NR/2 is. Leesbewerkingen kunnen over alle kopieën worden verdeeld, wat NR oplevert bij voldoende onafhankelijke willekeurige leesbewerkingen.

Het eenvoudige model voor gespiegelde sequentiële leesbewerkingen geeft NS/2 omdat partners elkaars blokken overslaan. Implementaties die hele leesbereiken aan elke kopie toewijzen, kunnen beter presteren. Spiegeling biedt meer capaciteit om leesverzoeken af te handelen; ze zorgt er niet voor dat één schijf een afzonderlijke leesbewerking in de helft van de tijd voltooit.

Een pariteitsstrook slaat gegevensblokken op en een redundant blok dat gelijk is aan hun bitsgewijze XOR. Voor elke bitpositie is XOR één als een oneven aantal invoerwaarden één is. XOR op een waarde met zichzelf toepassen heft die op. Door die opheffing kan de array één ontbrekend blok berekenen.

Herstel een bekend ontbrekend blok

Voor de gegevens 0011, 0101 en 1001:

Als het tweede blok ontbreekt:

De array moet weten welk blok moet worden gereconstrueerd. Een pariteitsverschil tussen ogenschijnlijk gezonde blokken toont inconsistentie, maar wijst de slechte schijf niet aan. Een controlesom kan helpen vaststellen welke gegevens geldig zijn.

Werk één blok bij zonder de hele strook te lezen

Pariteit uit de andere gegevens reconstrueren is additieve pariteit. Bij vijf gegevensschijven vereist het wijzigen van één blok dat de andere vier gegevensblokken worden gelezen en daarna met de nieuwe waarde worden gecombineerd. Subtractieve pariteit, oftewel lezen-wijzigen-schrijven, verwijdert de bijdrage van het oude blok en voegt die van het nieuwe toe:

Verander 0101 in 1100 in de strook hierboven:

Dit vereist twee leesbewerkingen, van oude gegevens en oude pariteit, gevolgd door twee schrijfbewerkingen, van nieuwe gegevens en nieuwe pariteit. De leesfase moet voltooid zijn vóór de schrijffase, wat ongeveer 2T latentie geeft. Bij het schrijven van een volledige strook zijn alle nieuwe gegevensblokken beschikbaar, zodat nieuwe pariteit direct wordt berekend en geen oude blokken hoeven te worden gelezen.

Verdeel het pariteitswerk

De pariteitsschijf van RAID-4 voert voor elke kleine wijziging een lees- en een schrijfbewerking uit, wat een vast knelpunt veroorzaakt. RAID-5 verspreidt pariteit over de schijven, zodat wijzigingen aan onafhankelijke stroken gelijktijdig kunnen plaatsvinden. Het kost nog steeds vier fysieke I/O-bewerkingen per logische kleine schrijfbewerking. Willekeurige leesbewerkingen kunnen alle schijven gebruiken met NR; grote sequentiële schrijfbewerkingen halen ongeveer (N − 1)S.

RAID-6 voegt onafhankelijke P- en Q-redundantie toe, meestal met een Reed–Solomon-code voor Q. Twee kopieën van dezelfde XOR zouden slechts één vergelijking opleveren. Eén gegevensblok bijwerken met lezen-wijzigen-schrijven leest oude gegevens, P en Q en schrijft daarna alle drie: zes I/O-bewerkingen.

Voor vier schijven van 4 TB met R = 1 MB/s bieden RAID-4 en RAID-5 12 TB en willekeurige schrijfsnelheden van 0,5 en 1 MB/s. RAID-6 biedt 8 TB en ongeveer 0,67 MB/s. In gedegradeerde RAID-5 zijn voor een ontbrekend gegevensblok N − 1 leesbewerkingen van overgebleven blokken nodig. Bij RAID-6 met één ontbrekend gegevensblok vereist reconstructie met P N − 2 leesbewerkingen en blijft Q buiten beschouwing; twee ontbrekende blokken vereisen beide onafhankelijke vergelijkingen.

Begin bij de keuze van RAID met de werklast en de uitval die het systeem moet overleven. Capaciteit alleen houdt geen rekening met schrijfkosten, prestaties in gedegradeerde modus en de tijd die nodig is om redundantie te herstellen. Een grotere array heeft meer schijven die capaciteit bijdragen, maar ook meer schijven en sectoren die tijdens herstel aan risico's blootstaan.

Stem de indeling af op de werklast

RAID-0 is geschikt voor tijdelijke gegevens die opnieuw kunnen worden gemaakt en geen tolerantie voor schijfuitval nodig hebben. RAID-10 is geschikt voor veel kleine willekeurige lees- en schrijfbewerkingen wanneer het aanvaardbaar is de helft van de capaciteit op te geven. RAID met pariteit gebruikt ruimte efficiënt en werkt goed voor grote schrijfbewerkingen van volledige stroken. RAID-6 voegt bescherming toe tegen elke combinatie van twee uitgevallen schijven, wat nuttig is wanneer de wederopbouw van grote schijven lang duurt.

Met vier schijven bieden RAID-10 en RAID-6 elk de helft van de ruwe capaciteit. RAID-10 heeft twee fysieke schrijfbewerkingen per kleine logische schrijfbewerking nodig; lezen-wijzigen-schrijven bij RAID-6 vereist zes I/O-bewerkingen. RAID-6 overleeft elke combinatie van twee uitgevallen schijven, terwijl die bij RAID-10 verschillende paren moeten treffen. Geen van beide keuzes is op elke maat beter.

Bereken een ondergrens voor de wederopbouwtijd

Bij wederopbouw van een spiegel wordt de overgebleven partnerschijf gekopieerd. Een volledige wederopbouw van een array met pariteit leest overgebleven gegevens en reconstrueert ontbrekende blokken. De P-vergelijking van RAID-6 kan één ontbrekend gegevensblok zonder Q reconstrueren; welke gegevens bij herstel daadwerkelijk worden gelezen, hangt af van de indeling en implementatie. Bij wederopbouw van volledige apparaten kunnen de overgebleven schijven uitgebreid worden gelezen.

Een vervangende schijf van 20 TB beschrijven met 200 MB/s duurt minimaal:

Dat is ongeveer 27,8 uur zonder concurrerende belasting of extra knelpunten. Normale I/O, zoekbewegingen, controllerwerk en begrenzing van de herstelsnelheid kunnen het langer laten duren. Een direct inzetbare reserveschijf verkort de wachttijd voordat de wederopbouw begint; die neemt de kopieertijd niet weg.

Onderzoek de risico's tijdens herstel

Een gedegradeerde RAID-5-array heeft zijn enige tolerantie voor schijfuitval al gebruikt. Nog een uitgevallen schijf maakt herstel onmogelijk. Een onleesbare sector op een overgebleven schijf kan ook een strook achterlaten met twee onbekende blokken: het blok van de ontbrekende schijf en het onleesbare blok van de overgebleven schijf. Andere stroken kunnen mogelijk nog worden hersteld.

Als voorbeeldberekening: bij de wederopbouw van vier RAID-5-schijven van 4 TB worden drie volledige overgebleven schijven gelezen:

Als fouten worden gemodelleerd met één per 10¹⁴ bits, is het verwachte aantal 0,96. Dit is een verwacht aantal onder dat foutmodel, geen kans op uitval van 96%. Een grens voor het foutpercentage op een specificatieblad is geen gemeten voorspelling voor een bepaalde wederopbouw. Specificaties voor zakelijk gebruik geven vaak een strengere grens, zoals één per 10¹⁵ bits.

RAID-5 uitbreiden van vier naar acht schijven verhoogt de bruikbare capaciteit van 75% naar 87,5% van de ruwe ruimte, terwijl tijdens herstel meer overgebleven gegevens worden gelezen. Gelijke leeftijd en slijtage maken ook de aanname van onafhankelijke uitval minder sterk. Een database met veel schrijfbewerkingen kan baat hebben bij RAID-10; een groot sequentieel archief bij RAID-6. Plan periodieke gegevenscontroles om slechte sectoren op te sporen zolang redundantie aanwezig is en bewaar afzonderlijke back-ups.

Het model van volledige, detecteerbare uitval merkt een hele schijf als ontbrekend aan. Een apparaat volgens het model van gedeeltelijk falen werkt grotendeels, terwijl sommige blokken onleesbaar of onjuist zijn. Zulke fouten kunnen verborgen blijven in zelden geraadpleegde gegevens totdat die blokken door een andere uitval nodig zijn voor wederopbouw.

Onderscheid een gemelde leesfout van verkeerde bytes

Een latente sectorfout (LSE) betekent dat de schijf een sector niet kan lezen en een fout meldt. Fysieke schade of bitfouten die de interne ECC niet kan corrigeren, kunnen dit veroorzaken. Omdat de locatie bekend is, kan een redundant systeem een spiegelkopie lezen of dat blok uit pariteit reconstrueren. Door herstelde gegevens terug te schrijven kan de schijf de beschadigde locatie buiten gebruik stellen of opnieuw koppelen.

Ongemerkte gegevensbeschadiging betekent dat een leesbewerking onjuiste bytes teruggeeft zonder een fout te melden. Foutieve firmware, een defecte controller of bus, of een schrijfbewerking naar een verkeerde locatie kan dit veroorzaken. De successtatus van het commando zegt dat de overdracht is voltooid; het is geen controle van de inhoud over de volledige gegevensketen.

Onderscheid adres- en versiefouten

Een schrijfbewerking naar een verkeerde locatie kan een niet-gerelateerd blok overschrijven terwijl de bedoelde bestemming verouderd blijft. Een verloren schrijfbewerking laat de oude versie van het bedoelde blok staan. Een adresidentificatie helpt de eerste fout op te sporen; een onafhankelijk opgeslagen verwachting van de nieuwe versie helpt bij de tweede.

De interne ECC van de schijf corrigeert veel fouten in opgeslagen bits. Die kan niet alle fouten elders in het traject controleren, zoals een waarde die wordt beschadigd voordat de schijf de code berekent of nadat de schijf de waarde teruggeeft. Bescherming die beperkt blijft tot het medium laat andere onderdelen ongecontroleerd.

Begrijp waarom schaal ertoe doet

Een praktijkonderzoek volgde 1,53 miljoen operationele schijven gedurende 32 maanden. LSE's troffen ongeveer 8,5% van de nearline-schijven en 1,9% van de schijven voor zakelijk gebruik. Een afzonderlijk onderzoek naar gegevensbeschadiging in dezelfde populatie gedurende 41 maanden vond afwijkende controlesommen op respectievelijk ongeveer 0,86% en 0,065%. Dit zijn historische waarnemingen over verschillende onderzoeksperioden, geen jaarlijkse kansen of huidige garanties. Bij een grote verzameling schijven worden zelfs zeldzame fouten per schijf regelmatige gebeurtenissen tijdens het gebruik.

Gebruik redundantie met verificatie

Een gewone leesbewerking uit een spiegel met twee kopieën kan één kopie kiezen zonder die met de andere te vergelijken. Zonder controlesomcontrole kan die beschadigde bytes teruggeven. Als de kopieën worden vergeleken en verschillen, vertellen twee kopieën alleen niet welke juist is. Een geldige controlesom biedt een basis om een goede versie te kiezen.

Tijdens een RAID-5-wederopbouw kan een LSE op een overgebleven schijf de laatste informatie wegnemen die voor de betreffende strook nodig is. De array heeft al één ontbrekend blok en één XOR-vergelijking kan geen twee onbekenden herstellen. Latente fouten vinden en herstellen terwijl alle schijven nog beschikbaar zijn, behoudt mogelijkheden voor de volgende uitval.

Een controlesom vat een gegevensblok samen in een veel kleinere waarde. Bereken die bij het lezen opnieuw en vergelijk de uitkomst met de opgeslagen verwachte waarde. Een verschil toont inconsistentie. Verschillende invoerwaarden kunnen dezelfde waarde opleveren, een botsing. Overeenkomende controlesommen vormen dus een sterke aanwijzing waarvan de sterkte afhangt van de gekozen functie en het foutpatroon.

Probeer XOR en optelling

Voor de bytes 0x36, 0x5A, 0xC1 en 0x0F geeft bitsgewijze XOR 0xA2. Binair is de berekening:

Laat het laagste bit in beide eerste bytes omslaan, waardoor 0x37 en 0x5B ontstaan. De twee wijzigingen heffen elkaar bij XOR op, zodat 0xA2 overblijft. Een goedkope bewerking kan een voorspelbare blinde vlek hebben.

Een 8-bits-controlesom door optelling telt de bytewaarden op modulo 256:

De dubbele bitomslag hierboven verandert de som in 0x62, dus optelling detecteert die fout. Maar een andere volgorde van bytes laat zowel eenvoudige optelling als XOR ongewijzigd.

Maak de uitkomst gevoelig voor positie

Een Fletcher-controlesom houdt twee sommen bij die op nul beginnen. Werk voor elke byte d de eerste som bij en tel de nieuwe waarde daarvan vervolgens bij de tweede op:

Het resultaat is (97, 122). Als je de eerste twee bytes verwisselt, krijg je (97, 158). De eerste som negeert de volgorde, maar de tweede weegt posities mee door de lopende optelling. Fletcher detecteert enkele bitfouten en veel foutreeksen tegen lage kosten, al blijven botsingen mogelijk.

Volg een korte CRC-deling

Een cyclische redundantiecontrole (CRC) behandelt bits als coëfficiënten van een polynoom en deelt met XOR. Met generator 1011, die x³ + x + 1 voorstelt, beschermt een rest van drie bits de gegevens. Voeg voor gegevens 1101 drie nullen toe:

1. Begin met 1101000 en pas XOR toe met 1011000; 0110000 blijft over.
2. Lijn de generator uit op de eerste één en pas XOR toe met 0101100; 0011100 blijft over.
3. Pas XOR toe met 0010110; 0001010 blijft over.
4. Pas XOR toe met 0001011; 0000001 blijft over.

De rest is 001, dus sla 1101001 op. Delen van dat codewoord geeft nul; wijziging in 1111001 geeft rest 110. Een n-bits-CRC detecteert elke foutreeks van maximaal n bits. CPU-ondersteuning maakt CRC praktisch voor opslag en netwerkverkeer, waaronder CRC32C in ext4-metadata en Btrfs.

Cryptografische hashes zoals SHA-256 zijn ook bestand tegen opzettelijke pogingen om botsingen te veroorzaken. Een hash tegen manipulatie heeft een vertrouwde verwachte waarde nodig; als zowel de gegevens als de niet-vertrouwde hash worden vervangen, werkt de vergelijking niet. OpenZFS gebruikt normaal gesproken Fletcher voor gewone gegevens en SHA-256 voor deduplicatie. Acht bytes aan controlesommen per blok van 4 KiB kosten ongeveer 0,2% ruimte. Detectie alleen levert geen vervangende bytes: herstel vereist redundantie of een foutcorrigerende code.

Een controlesomfunctie bepaalt welke veranderingen detecteerbaar zijn. Het opslagontwerp bepaalt met welke waarde de controlesom wordt vergeleken, bij welk adres die hoort en of een goede vervanging bestaat. Een sterke controlesom die bij de verkeerde versie hoort, kan nog steeds verouderde gegevens accepteren.

Kies een plaats voor de verwachte waarde

ZFS gebruikt controlesommen in verwijzingen vanuit ouderblokken en maakt zo een verificatieboom tot aan de wortel. Beschermingsinformatie kan ook het verwachte adres bevatten. Het referentielabel van T10 gebruikt de laagste 32 bits van het logische blokadres naast een 16-bits-CRC van de gegevens en een toepassingslabel. Een adrescontrole kan correcte bytes afwijzen die van de verkeerde locatie zijn teruggegeven.

Onderscheid een verkeerde locatie van een verkeerde versie

Stel dat een leesbewerking van schijf 3, blok 1.207 een geldig paar van gegevens en controlesom teruggeeft met een label voor een ander adres. De controlesom alleen klopt, maar de adresidentificatie onthult de verkeerde locatie.

Een verloren schrijfbewerking is lastiger: de oude inhoud kan een geldige controlesom en het juiste adres hebben. Verificatie door teruglezen na schrijven vergelijkt een nieuwe leesbewerking met de verwachte nieuwe inhoud en voegt ongeveer één extra I/O-bewerking toe. Die moet het opgeslagen resultaat waarnemen, niet alleen dezelfde vluchtige cachekopie. Een afzonderlijk opgeslagen verwachte controlesom, bijvoorbeeld in een vastgelegde verwijzing vanuit het ouderblok, kan in plaats daarvan de verouderde versie van het kindblok afwijzen. De afzonderlijke verwachte waarde moet zelf de bedoelde wijziging beschrijven.

Controleer voordat je gegevens teruggeeft of herstelt

Haal bij een leesbewerking het blok en de verwachte controlesom op, bereken de controlesom opnieuw en vergelijk. Als de eerste kopie niet door de controle komt, lees je een andere kopie of reconstrueer je het blok uit redundante gegevens. Controleer dat resultaat voordat je het teruggeeft. Als het door de controle komt, geef je de goede gegevens terug en herschrijf je de beschadigde kopie. Dit is zelfherstel. Als geen geldige kopie kan worden gevonden, geef je een fout terug in plaats van ongecontroleerde bytes.

Een gespiegelde ZFS-pool leest bijvoorbeeld schijf A en detecteert een afwijkende controlesom. De kopie op schijf B komt wel door de controle. Het systeem geeft de gegevens van B terug, herstelt A en registreert de fout van A. Gewone spiegeling zonder controlesomverificatie had de slechte bytes van A ongemerkt kunnen teruggeven.

Zoek fouten voordat uitval herstel afdwingt

Periodieke gegevenscontrole leest en controleert opgeslagen gegevens regelmatig, inclusief blokken die toepassingen zelden gebruiken. Zolang redundantie beschikbaar is, kan het systeem fouten herstellen voordat een andere schijf uitvalt. In het historische LSE-onderzoek vond periodieke controle meer dan 60% van de fouten.

Verificatie kost CPU-tijd, controlesomruimte en soms extra I/O. Acht bytes per 4 KiB kosten ongeveer 0,2%; acht per 512 gegevensbytes kosten ongeveer 1,6%. Leesbewerkingen voor periodieke controle concurreren met verzoeken op de voorgrond, dus rustige perioden zijn nuttig. Het eind-tot-eindargument plaatst de laatste controle dicht bij het bestandssysteem of de toepassing en dekt zo meer van het traject dan ECC die alleen het schijfmedium beschermt.