ZFS

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken

ZFS is een bestandssysteem ontworpen en geïmplementeerd door een team van Sun geleid door Jeff Bonwick. Op 31 oktober 2005 werd de broncode van het uiteindelijke product geïntegreerd in de main trunk van Solaris en op 16 november 2005 werd het uitgebracht in OpenSolaris build 27. In juni 2006 kondigde Sun aan dat ZFS geïntegreerd werd in update 6/06 van Solaris 10, één jaar na de start van de OpenSolaris-community.

De naam betekent Zettabyte File System, maar is nu bekend als een letterwoord. Dit omdat de datalimiet een zettabyte is.

ZFS is een 'nextgen'- of hybride-bestandsysteem, met name omdat door enkele functies, zoals RAID en LVM, geïntegreerd zijn. Dit is bij de gangbare (anno 2013) bestandssystemen niet het geval. Met ZFS kan indien data op een (RAID) set van meerdere harde schijven is opgeslagen, deze set schijven vervolgens aan een ander systeem (met ZFS) gekoppeld worden om verder te worden gebruikt. Verder tackelt ZFS een aantal problemen ten gevolge van schijffouten, zoals het probleem van 'silent corruption'. En er kunnen gewone (minder kostbare), van elkaar verschillende schijven zonder te veel nadelen in één set worden gebruikt.

Capaciteit[bewerken]

ZFS is een 128 bit-bestandssysteem, wat betekent dat het 18 triljoen keer zo veel data kan opslaan als de huidige 64 bit-bestandssystemen.

128 bit[bewerken]

Er bestaan al datasets in de orde van petabytes (250 byte), wat betekent dat de limiet van de huidige 64 bit-systemen nog 14 verdubbelingen verwijderd is, wat overeenkomt met ongeveer 20 jaar. Omdat bestandssystemen vaak enkele decennia blijven bestaan, zou het dom zijn om een nieuw bestandssysteem te creëren, dat binnen enkele jaren niet meer aan de noden voldoet, en heeft men dus voor een 128 bit-bestandssysteem gekozen.

De theoretische opslaglimiet[bewerken]

Alhoewel de theoretische limieten vooralsnog niet bereikt zijn, kent ZFS wel beperkingen. Deze zijn:

  • 248 - Aantal snapshots in elk bestandssysteem (2 x 1014)
  • 248 - Aantal bestanden in elk individueel bestandssysteem (2 x 1014)
  • 16 exabytes - Maximum grootte van het bestandssysteem
  • 16 exabytes - Maximum grootte van één enkel bestand
  • 16 exabytes - Maximum grootte van elk attribuut
  • 3 x 1023 petabytes - Maximum grootte van elke zpool
  • 256 - Aantal attributen van een bestand (beperkt tot 248 aangezien dit het aantal bestanden is per bestandssysteem)
  • 256 - Aantal bestanden in een map (beperkt tot 248 aangezien dit het aantal bestanden is per bestandssysteem)
  • 264 - Aantal apparaten in elke zpool
  • 264 - Aantal zpolen per systeem
  • 264 - Aantal bestandssystemen in een zpool

Om een idee te geven van de grootte van deze getallen, als er elke seconde 1000 bestanden worden gecreëerd duurt het nog 9000 jaar voor deze limieten worden bereikt.

Opslagpools[bewerken]

Met traditionele volumes wordt data gefragmenteerd opgeslagen. Er is daarom een volumemanager nodig om met verschillende apparaten te communiceren. Met ZFS' opslagpools hoeven er geen partities beheerd te worden. De gecombineerde I/O-bandbreedte van alle apparaten in de opslagpools is altijd bereikbaar voor elk bestandssysteem. Een pool bestaat uit virtuele apparaten (virtual devices - vdevs). Deze apparaten kunnen vaste schijven zijn, mirror (RAID 1)'s van één of meer apparaten of een RAID Z-groep van twee of meer apparaten. ZFS kan gebruikmaken van al deze virtuele apparaten door middel van de zpool. Een pool kan gereserveerd worden, zodat een bepaald bestandssysteem opslagruimte heeft. Er kunnen ook quota opgelegd worden zodat de pool niet te veel opslagruimte in beslag neemt.

Herstel van schijffouten[bewerken]

Copy-on-write-transactiemodel[bewerken]

Bij gebruik van de anno 2013 gangbare (wat voorbarig als 'legacy' te bestempelen, niet ZFS) bestandssystemen worden de fouten opgespoord en gecorrigeerd door 'checksum'-controle en door markering van een 'bad' sector op de schijf. De gegevens worden verplaatst naar een reserve-sector zonder de betrokkenheid van het besturingssysteem. Deze 'silent' correctie kan leiden tot 'silent corruption' als de schijftoestand snel verslechtert en daardoor de reserve sectoren plotseling opraken. S.M.A.R.T. kan weliswaar de gezondheid van een schijf bewaken, en er zijn tools beschikbaar voor de meeste besturingssystemen om automatisch de schijf voor dreigende storingen te waarschuwen, maar S.M.A.R.T. is geen geïntegreerd onderdeel van het bestandssysteem.

In ZFS echter zijn alle bewerkingen copy-on-write-transacties. Hierdoor hoeft het ZFS-bestandssysteem nooit nagekeken te worden op fouten. Elk blok wordt door ZFS gecontroleerd, de data worden indien nodig door ZFS hersteld.

RAID[bewerken]

Indien er gebruikgemaakt wordt van een redundante ('mirror') vorm van RAID en er een kopie beschadigd blijkt, zal ZFS dit detecteren en de correcte kopie gebruiken om de fout te herstellen. Dynamische stripesizes maakt ZFS ongevoelig voor 'write hole'. ZFS kent geen read-modify-write, een voordeel van RAID-Z boven RAID5 voor de betrouwbaarheid en de random-write prestaties.[1]

Snapshots en klonen[bewerken]

ZFS voorziet in ongelimiteerd gebruik van snapshots en klonen. Een snapshot is een momentopname van een bestandssysteem dat enkel te lezen is. Een kloon is een snapshot die aangepast kan worden. Door het gebruik van klonen ontstaat er een plaatsbesparende manier om vele kopieën van veel gedeelde data op te slaan.

Snapshots helpen in het back-up- en herstelproces van ZFS. Elke snapshot kan een volledige back-up genereren. De mogelijkheid bestaat ook om een incrementele back-up te genereren door verschillende snapshots samen te gebruiken. Incrementele back-ups maken het gebruik van herstel op afstand zeer efficiënt.

Variabele blokgrootte[bewerken]

De huidige bestandssystemen hebben meestal een vaste blokgrootte, hierdoor gaat er veel schijfruimte verloren aan overhead. Het voordeel van vaste blokgrootte is dat het gemakkelijk te implementeren is.

ZFS echter gebruikt variabele blokgrootte tot 128 KB. Het voordeel hiervan is dat je grote blokken voor grote bestanden kunt gebruiken en deze blokken kunt opdelen in kleine blokken voor kleine bestanden. Indien een klein bestand dan toch groot blijkt te worden kun je die gemakkelijk nog even uit een klein blok halen en in een groot blok plaatsen. Doordat het tot dan toe een klein bestand was geeft dat (eenmalig) verplaatsen ook niet echt veel overhead.

Redundantie (RAID)[bewerken]

ZFS kent een aantal RAID vormen die via software worden geïmplementeerd. Al deze vormen zijn direct afgeleiden van de bekende RAID-oplossingen. ZFS ondersteunt mirror (vergelijkbaar met RAID 1). Bovendien is er RAID-Z (een verbeterde versie van raid5, n+1) en raidz2 (vergelijkbaar met raid 6, n+2). Voordeel van ZFS is dat schijven van verschillende grootte en snelheid naast elkaar in een ZFS gebruikt worden. ZFS gebruikt de ongelijke schijven op een optimale manier. Een ander voordeel is dat een complete set van ZFS zonder meer ook te gebruiken is in een ander systeem. Een nadeel is dat een set niet achteraf uitgebreid kan worden met een extra schijf. Uitbreiding is mogelijk door een nieuwe set naast de bestaande set.

Meer recente toevoegingen[bewerken]

Voorheen was het niet mogelijk op te starten vanaf ZFS. Het "ZFS Boot" project bracht hier recentelijk verandering in, door middel van een plug-in voor grub.

ZFS ondersteunt transparante encryptie.

ZFS ondersteunt deduplicatie. Als een blok (bijvoorbeeld kopieën van virtuele machines) meerdere keren wordt opgeslagen, wordt naderhand vastgesteld welke blokken identiek zijn en worden deze blokken in de fysieke opslag samengevoegd. Dit spaart diskruimte en aangezien ze maar één keer in de cache staan kan ook de leesperformantie toenemen. Deduplicatie kost uiteraard wel processor- en geheugencapaciteit.

ZFS kan met L2ARC gebruik maken van caching. Een cache is een kopie van veel gebruikte data op een sneller leesbaar medium, bijvoorbeeld op een SSD. De gebruikelijke caching-methode, zoals met Intel SRT, kan corruptie van de cache op een SSD niet detecteren. ZFS wel en leest dan van de gewone schijf. Verder leest ZFS geen grote bestanden die sequentieel worden gelezen via de cache. Ook kan ZFS met L2ARC meerdere SSD's als L2ARC-cache gebruiken.

Beperkingen[bewerken]

Om de 64 bit-checksums, gebruikt bij copy-on-write, te berekenen gaat de processorbelasting wel wat omhoog, maar in de praktijk blijkt dat verwaarloosbaar. Zeker met de huidige processoren.

ZFS is geschreven voor recente hardware en heeft veel RAM nodig. Minimaal 256 MB geheugen is benodigd en 1 GB wordt aanbevolen. Op oudere hardware zal het te veel overhead veroorzaken en te veel geheugengebruik vergen.

ZFS-gebruikers moeten er van tevoren voor zorgen dat ze op hun harde schijven uitsluitend EFI-labels gebruiken. Alleen met behulp van deze labels kunnen namelijk de bestandssystemen die op sparc-hardware zijn aangemaakt gelezen worden op x86/x64-systemen. Met het oude labelformaat kan dat niet. Deze beperking geldt enkel voor harde schijven en niet voor andere vdevs.

Platforms[bewerken]

Solaris[bewerken]

ZFS wordt geïmplementeerd in Suns Solaris en OpenSolaris. Hierdoor is het bestandssysteem bruikbaar op SPARC- en x86-systemen. ZFS is open source en kan daarom zonder tussenkomst van Sun geïmplementeerd worden in andere besturingssystemen. OpenSolaris gebruikt vanaf 2008.05 ZFS als standaard bestandssysteem.

OS X[bewerken]

Apple heeft vanaf versie 10.5 van Mac OS X, codenaam Leopard, read-only-ondersteuning voor ZFS opgenomen. Er zijn vanaf OS X 10.5 (Leopard) respectievelijk 10.6 (Snow Leopard) twee implementaties van ZFS: MacZFS op basis van open source code van Apple en wordt door een community onderhouden en Zevo, hiervan is er een gratis 'Community Edition'.

Linux[bewerken]

ZFS implementeren (in plaats van ext3, ext4 of btrfs) in Linux is moeilijker omdat ZFS onder de CDDL-licentie is uitgegeven en de Linuxkernel onder GPL wordt gedistribueerd. ZFS is inmiddels wel beschikbaar via FUSE:[2] De 'work-around' is een losse kernelmodule voor ZFS. In bijvoorbeeld Gentoo en Ubuntu kunnen de betreffende pakketten worden geïnstalleerd met de packagemanager en het configureren is goed gedocumenteerd.

BSD-achtigen[bewerken]

Ook de BSD-wereld ziet een implementatie van ZFS wel zitten. Vanaf FreeBSD 8 is ZFS standaard meegeleverd. Enkele verwante varianten met de mogelijkheid van implementatie van ZFS (in plaats van UFS) zijn NetBSD, PC-BSD, MidnightBSD, FreeNAS en NAS4Free.

Gedistribueerde systemen[bewerken]

ZFS leent zich enorm goed voor gedistribueerde systemen, omdat alle schijven van alle systemen in één Zpool kunnen gezet worden. Zo lijkt er één grote schijf te zijn die in feite bestaat uit alle schijven van elke aparte computer. Het nadeel hiervan is wel dat je netwerk een knelpunt gaat vormen: de schijftoegang via een IDE- of SATA-kabel gaat vele malen sneller dan via het momenteel meest gebruikte ethernet.

Wat ZFS verder ook geschikt maakt voor gedistribueerde systemen is de aanpassende endian of in het Engels "adaptive endianness"; de ZFS-block-pointer laat toe dat de metadata in big, middle of little endian opgeslagen kan worden. De metadata wordt weggeschreven in de oorspronkelijke endianness en als er gelezen wordt van een andere endianness wordt de metadata op een correcte manier omgevormd in het geheugen naar de correcte endianness, zodat het leesbaar en beschrijfbaar is voor elk systeem.

Concurrentie[bewerken]

ZFS is een 'Nextgen'-bestandsysteem en heeft enkele concurrenten: BTRFS, Refs en VxFS. VxFS is speciaal ontworpen voor gedistribueerde systemen en heeft als hoofdvoordeel ten opzichte van andere file systemen dat de fragmentatie miniem tot nihil is. Bij ZFS is dit ook zo door middel van de variabele blokgrootte. ZFS heeft daarbij een praktisch onbereikbare datalimiet, hetgeen een enorm voordeel is ten opzichte van VxFS.

Een andere grote concurrent is WAFL (Write Anywhere File Layout), een gesloten filesystem van NetApp. WAFL is een bestandssysteem dat geen gebruik maakt van Copy-on-Write en ondersteunt daardoor 255 snapshots per volume zonder performanceverlies. WAFL is in combinatie met de NetApp-hardware beroemd om zijn performance op NFS-gebied, een protocol oorspronkelijk ontwikkeld door Sun. Sinds 2007 zijn NetApp en Sun in diverse rechtszaken verwikkeld omtrent ZFS, WAFL en NFS.

Toepassing[bewerken]

Bij gebruik van ZFS als onderdeel van bijvoorbeeld het besturingssysteem (bijvoorbeeld freeNAS) op een NAS is het ook voor andere pc's met allerlei andere besturingssystemen in het netwerk op diverse (zoals NFS, ISCSI) manieren mogelijk de bestanden te benaderen. Ook voor pc's met Microsoft Windows is mogelijk om de bestanden te benaderen middels het op het NAS geïnstalleerde Samba.

Bronnen, noten en/of referenties