X

News, tips, partners, and perspectives for the Oracle Solaris operating system

Speicherplatz bei ZFS und wie NFS dann mit Snapshots und Clones umgeht

Ich werde immer mal wieder danach gefragt, wie die Angaben von ZFS zum verbrauchten und verfügbaren Speicherplatz zu interpretieren sind.  Dazu gibt es schon länger einen guten Blog hier. Neulich ging es nun darum, wie das im Zusammenspiel mit NFS funktioniert, wenn das NFS aus einem ZFS Array kommt.  Ich habe dazu einige Beispiele durchgespielt.

Bevor es damit jedoch los geht, sollte man sich kurz die Solaris-Kommandos in Erinnerung rufen, die sich mit Platz im Dateisystem befassen:

  • du
    du (merke: "Disk Usage") berichtet, wie viel Platz die Dateien tatsächlich benötigen.  Die man page sagt dazu:
    The  du  utility  writes  to standard output the size of the file space
    allocated to, and the size of the file space allocated to each subdi-
    rectory of, the file hierarchy rooted in each of the specified files.
    The size of the file space allocated to a file of type directory is
    defined as the sum total of space allocated to all files in the file
    hierarchy rooted in the directory plus the space allocated to the
    directory itself. This sum will include the space allocated to any
    extended attributes encountered.
  • df
    Bei df geht es um das Dateisystem und wie viel Platz dort noch verfügbar ist. Merke: "disk free".  Die man page sagt:

    The df utility displays the amount of disk space occupied by mounted or
    unmounted file systems, the amount of used and available space, and how
    much of the file system's total capacity has been used. The file system
    is specified by device, or by referring to a file or directory on the
    specified file system.
  • ls
    Dieses Kommando ist vermutlich das erste, das ein Unix-Benutzer jeweils kennen gelernt hat. Kombiniert mit der Option "-l" gibt es Auskunft über die Größe von Dateien.  Genauer gesagt, über die Größe, wie sie im jeweiligen Directory File hinterlegt ist, in dem die Datei verwaltet wird.

In diesem Artikel soll es um diese Fragen gehen:

  • Wie viel Platz benötigt eine Datei?
  • Wie ändert sich das mit Kompression und Snapshots?
  • Wie stelle ich fest, wie viel Platz mein Filesystem noch hat?
  • Sind bei einem NFS aus einem ZFS Storage Array (oder einem Solaris System mit NFS auf ZFS) die Zahlen zwischen NFS und ZFS konsistent?  Und wie stelle ich das fest?

Der Hauptteil dieses Artikels ist ein etwas lang geratenes Beispiel, in dem ich die verschiedenen Varianten zeige.  Vorher möchte ich jedoch für all diejenigen, die nur eine kurze Erinnerung brauchen zeigen, wie man die Ausgaben der obigen Kommandos interpretiert.

root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 25G Sep 30 01:48 /mnt/25g.file
-rw------- 1 nobody nobody 25G Sep 30 01:55 /mnt/25g.file2
-rw-r--r-- 1 nobody nobody 148M Sep 30 01:58 /mnt/usr.bin.tar
root@mars:~# du -sh /mnt/*
25G /mnt/25g.file
0K /mnt/25g.file2
49M /mnt/usr.bin.tar
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
23T 25G 23T 1% /mnt

In diesem Beispiel sieht man folgendes:

  • Bei "ls" geht es um die Datei-Größen:
    • Die beiden Dateien "25g.file" und "25g.file2" sind jeweils 25GB gross.  Das ist die tatsächliche Größe dieser Dateien, man kann also jeweils 25GB Daten aus ihnen lesen.
    • Die Datei "usr.bin.tar"  ist mit 148 MB etwas kleiner.
  • du zeigt an, wie viel Platz dafür jeweils im Storage verbraucht wird:
    • "25g.file" belegt tatsächlich die vollen 25GB.
    • "25g.file2" belegt dagegen eigentlich nichts - 0k.  Das legt nahe, dass das Storage-Subsystem diese Datei sehr sehr gut komprimiert hat.  Die Größe der Datei bleibt dabei natürlich 25GB, es wird nur momentan nicht so viel belegt. Sollten sich die Daten in der Datei ändern und nicht mehr so gut komprimiert werden können, wird die benötigte Speichermenge entsprechend wachsen.
    • "usr.bin.tar"  wird ebenfalls komprimiert, allerdings weniger radikal.  Es belegt 49MB.
  • Mit "df" schliesslich betrachtet man das Dateisystem als ganzes:
    • Das Dateisystem ist derzeit 23TB gross.
    • Davon sind 25GB (genauer:  25.049GB) belegt.
    • Daraus ergibt sich die belegte Kapazität von 1% und der verfügbare Platz von 23TB.
    • Da wir die Option "-h" verwenden, werden alle Angaben auf volle GB bzw. TB gerundet.  Das erklärt dann auch, warum wir die Auswirkung dieser 49MB nicht sehen.

Als Erinnerung sollte das reichen.  Mehr Details gibt es im Rest dieses Artikels, der leider etwas lang geraten ist...

Zuerst loggen wir uns jetzt in eine ZFS Appliance ein und legen ein Dateisystem an.  Ich zeige hier die Kommandozeile, aber natürlich funktioniert das Ganze genauso auch im BUI.

zfs-array:shares stefan> filesystem quotademo
zfs-array:shares stefan/quotademo (uncommitted)> commit
zfs-array:shares stefan> show
Properties:
aclinherit = restricted
aclmode = discard
atime = true
checksum = fletcher4
compression = off
dedup = false
compressratio = 100
copies = 1
creation = Tue Jul 19 2016 13:36:09 GMT+0000 (UTC)
logbias = latency
mountpoint = /export
quota = 0
readonly = false
recordsize = 128K
reservation = 0
rstchown = true
secondarycache = all
nbmand = false
sharesmb = off
sharenfs = on
snapdir = hidden
vscan = false
defaultuserquota = 0
defaultgroupquota = 0
encryption = off
snaplabel =
sharedav = off
shareftp = off
sharesftp = off
sharetftp = off
pool = ssc
canonical_name = ssc/local/stefan
default_group = other
default_permissions = 700
default_sparse = false
default_user = nobody
default_volblocksize = 8K
default_volsize = 0
exported = true
nodestroy = false
maxblocksize = 1M
space_data = 31K
space_unused_res = 0
space_unused_res_shares = 0
space_snapshots = 0
space_available = 22.6T
space_total = 31K
origin =
Shares:
Filesystems:
NAME SIZE ENCRYPTED MOUNTPOINT
quotademo 31K off /export/quotademo
zfs-array:shares stefan/quotademo> get space_total space_available
space_snapshots quota compressratio
space_total = 31K
space_available = 22.6T
space_snapshots = 0
quota = 0
compressratio = 100

Man kann erkennen, dass das ZFS Array ziemlich genau die gleichen Metadaten anzeigt wie ein normales ZFS.  Im Moment zeigt es nur 31kB belegten Platz und eine verfügbare Kapazität von 22.6 TB.

Auf einem NFS Client sieht das dann so aus:

root@mars:~# mount 192.168.30.1:/export/quotademo /mnt
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
23T 31K 23T 1% /mnt

Und "df" zeigt natürlich die gleichen Werte wie das Array.

  • Die Dateisystemgröße entspricht der verfügbaren Kapazität von 22.6 TB (oder aufgerundet 23TB).
  • Belegt sind nur 31K - der eine Block mit Metadaten.
  • Und da wir noch keine Quotas oder sonstige Restriktionen haben, ist der verfügbare Platz gleich der Dateisystemgröße: 22.6
    TB.

Wie ändern sich diese Zahlen, wenn wir eine erste, einfache Datei anlegen:

root@mars:~# mkfile 25g /mnt/25g.file
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
23T 25G 23T 1% /mnt
root@mars:~# du -sh /mnt/*
25G /mnt/25g.file

Erwartungsgemäß zeigt df nun 25GB belegten Platz an.  Der verfügbare Platz ändert sich nicht, da 25GB bei 23TB nicht wirklich etwas ausmachen.  Auch die Ausgabe von "du" bietet keine Überraschungen, genau wie auch das ZFS Array:

zfs-array:shares stefan/quotademo> get space_total space_available 
space_snapshots quota compressratio
space_total = 25.0G
space_available = 22.6T
space_snapshots = 0
quota = 0
compressratio = 100

Nun wird die Kompression eingeschaltet um zu sehen, wie NFS und die Tools mit der daraus resultierenden Verwirrung umgeht.

zfs-array:shares stefan/quotademo> set compression=gzip
compression = gzip (uncommitted)
zfs-array:shares stefan/quotademo> commit
Natürlich werden bestehende Dateien nicht nachträglich komprimiert.  Wir brauchen also neue.  Das Beispiel zeigt auch sehr schön, wie hervorragend sich Dateien komprimieren lassen, wenn man sie mit mkfile anlegt...







root@mars:~# mkfile 25g /mnt/25g.file2
root@mars:~# tar cf /mnt/usr.bin.tar /usr/bin
root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 25G Sep 30 01:48 /mnt/25g.file
-rw------- 1 nobody nobody 25G Sep 30 01:55 /mnt/25g.file2
-rw-r--r-- 1 nobody nobody 148M Sep 30 01:58 /mnt/usr.bin.tar
root@mars:~# du -sh /mnt/*
25G /mnt/25g.file
0K /mnt/25g.file2
49M /mnt/usr.bin.tar
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
23T 25G 23T 1% /mnt

Wie erwartet zeigt uns "ls" die tatsächliche Dateigröße.  25GB für "25g.file2" und 148 MB für usr.bin.tar. Soweit alles in Ordnung.  Aber wird auch tatsächlich der ganze Platz gebraucht?  Nein - mit "du" erfahren wir, dass "25g.file2" 0k und das Tarfile nur 49M belegen.  Das bedeutet, dass die Kompression des ZFS auch im NFS sichtbar ist.  Die Tools zeigen die korrekten Dateigrößen, aber auch den korrekten belegten Speicherplatz für jede Datei an.  Im Falle der mit mkfile angelegten Datei ist das nicht eben viel.

Jetzt gibt es noch eine etwas grössere Datei, damit die Zahlen etwas interessanter werden.

root@mars:~# cp /tmp/bigfile /mnt
root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 25G Sep 30 01:48 /mnt/25g.file
-rw------- 1 nobody nobody 25G Sep 30 01:55 /mnt/25g.file2
-rw-r--r-- 1 nobody nobody 7.2G Sep 30 02:02 /mnt/bigfile
-rw-r--r-- 1 nobody nobody 148M Sep 30 01:58 /mnt/usr.bin.tar
root@mars:~# du -sh /mnt/*
25G /mnt/25g.file
0K /mnt/25g.file2
2.4G /mnt/bigfile
49M /mnt/usr.bin.tar
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
23T 27G 23T 1% /mnt

Die 7.2GB grosse Datei wird also auf 2.4 GB komprimiert.  Insgesamt haben wir jetzt Dateien für 57.3 GB, die jedoch wegen der Kompression nur 27.4 GB belegen.  Was sagt das Array dazu?

zfs-array:shares stefan/quotademo> get space_total space_available 
space_snapshots quota compressratio
space_total = 27.4G
space_available = 22.6T
space_snapshots = 0
quota = 0
compressratio = 116

Das gleiche, natürlich...

Für das nächste Beispiel mit Quotas brauchen wir ein frisches Dateisystem:

zfs-array:shares stefan/quotademo> destroy
This will destroy all data in "quotademo"! Are you sure? (Y/N)
zfs-array:shares stefan> filesystem quotademo
zfs-array:shares stefan/quotademo (uncommitted)> commit
zfs-array:shares stefan> select quotademo
zfs-array:shares stefan/quotademo> get space_total space_available
space_snapshots quota compressratio
space_total = 31K
space_available = 22.6T
space_snapshots = 0
quota = 0
compressratio = 100
Und auch auf dem Server sehen wir natürlich wieder die gleichen Zahlen.  Jetzt wieder die 25GB Datei...

root@mars:~# mount 192.168.30.1:/export/quotademo /mnt
root@mars:~# mkfile 25g /mnt/25g.file
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
23T 25G 23T 1% /mnt
root@mars:~# du -h /mnt/*
25G /mnt/25g.file
root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 25G Sep 30 02:11 /mnt/25g.file

...und natürlich gibt es keine Überraschungen.  Als nächstes kommt eine Quota von 100GB.  Wie wird das ins NFS übersetzt?

zfs-array:shares stefan/quotademo> set quota=100g
quota = 100G (uncommitted)
zfs-array:shares stefan/quotademo> commit
zfs-array:shares stefan/quotademo> get space_total space_available
space_snapshots quota compressratio
space_total = 25.0G
space_available = 75.0G
space_snapshots = 0
quota = 100G
compressratio = 100

root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
100G 25G 75G 26% /mnt
Nachdem die Quota eingerichtet wurde, zeigt das Array 25GB belegt und die verbleibenden 75GB als verfügbaren Platz an.  Auch auf dem NFS Client wird die Auswirkung sofort sichtbar.  Hier wird die Quota als Dateisystemgröße angezeigt.  Das ist sinnvoll - für das NFS macht es keinen Unterschied, ob die Dateisystemgröße physisch oder durch eine Quota begrenzt wird.

Reservations werden übrigens im NFS ebensowenig sichtbar wie bspw. thin provisioning.  Das liegt daran, dass beides Storage-Konzepte sind, die in einem Dateisystem nicht verfügbar sind.

Jetzt muss die Quota aber auch noch wirken:

root@mars:~# mkfile 70g /mnt/70g.file
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
100G 95G 5.0G 96% /mnt
root@mars:~# du -h /mnt/*
25G /mnt/25g.file
70G /mnt/70g.file
zfs-array:shares stefan/quotademo> get space_total space_available 
space_snapshots quota compressratio
space_total = 95.0G
space_available = 4.98G
space_snapshots = 0
quota = 100G
compressratio = 100

Ok, jetzt haben wir also noch knapp 5GB freien Platz.  Dann gilt es jetzt, die Grenze zu überschreiten:

root@mars:~# mkfile 10g /mnt/10g.file
/mnt/10g.file: initialized 3668647936 of 2147483648 bytes: Disc quota exceeded
root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 10G Sep 30 02:29 /mnt/10g.file
-rw------- 1 nobody nobody 25G Sep 30 02:11 /mnt/25g.file
-rw------- 1 nobody nobody 70G Sep 30 02:25 /mnt/70g.file
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
102G 102G 0K 100% /mnt
root@mars:~# du -h /mnt/*
7.4G /mnt/10g.file
25G /mnt/25g.file
70G /mnt/70g.file

Ok, ein wenig über den 100GB sind wir, aber es gab die erwartete Fehlermeldung und die Datei konnte nicht vollständig geschrieben werden.  Mit "ls" wird sie zwar als 10g angezeigt, weil sie so ins Directory File eingetragen wurde.  Das ist erwartetes Verhalten, nicht etwa ein Bug.  "du" zeigt uns jedoch, dass in Wirklichkeit nur 7.4 GB geschrieben wurden und die Datei somit unvollständig ist. 

Und wie immer zeigt auch das ZFS Array die gleichen Werte an:

zfs-array:shares stefan/quotademo> get space_total space_available 
space_snapshots quota compressratio
space_total = 102G
space_available = 0
space_snapshots = 0
quota = 100G
compressratio = 100

Nach dem Löschen der defekten Datei wird die Kompression wieder angeschaltet.  Dann kopieren wir "bigfile" wieder auf das NFS um zu sehen, wie sich die Zahlen verändern:

root@mars:~# rm /mnt/10g.file 
root@mars:~# du -h /mnt/*
25G /mnt/25g.file
70G /mnt/70g.file
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
100G 95G 5.0G 96% /mnt
root@mars:~# cp /tmp/verybigfile /mnt
root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 70G Sep 30 02:25 /mnt/70g.file
-rw-r--r-- 1 nobody nobody 3.6G Sep 30 02:38 /mnt/verybigfile
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
100G 71G 29G 72% /mnt
root@mars:~# du -h /mnt/*
70G /mnt/70g.file
1.2G /mnt/verybigfile

Die Datei "verybigfile" ist also 3.6 GB gross, braucht aber wegen der Kompression nur 1.2 GB Platz.  Das stimmt natürlich auch mit dem ZFS Array überein:

zfs-array:shares stefan/quotademo> get space_total space_available 
space_snapshots quota compressratio
space_total = 71.2G
space_available = 28.8G
space_snapshots = 0
quota = 100G
compressratio = 103

Wenn wir jetzt die Kompression wieder abschalten, sollten wir also immer noch in der Lage sein, eine 28.8 GB grosse Datei zu schreiben.  Mal versuchen...

zfs-array:shares stefan/quotademo> set compression=off
compression = off (uncommitted)
zfs-array:shares stefan/quotademo> commit
root@mars:~# mkfile 28g /mnt/28g.file
root@mars:~# du -h /mnt/*
28G /mnt/28g.file
70G /mnt/70g.file
1.2G /mnt/manytarfiles.tar
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
100G 99G 808M 100% /mnt
root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 28G Sep 30 02:42 /mnt/28g.file
-rw------- 1 nobody nobody 70G Sep 30 02:25 /mnt/70g.file
-rw-r--r-- 1 nobody nobody 3.6G Sep 30 02:38 /mnt/manytarfiles.ta
Die Summe der Dateigrößen ist jetzt 101.6 GB, also bereits über der Quota.  Wegen der Kompression werden jedoch nur 99.2 GB belegt, wir haben also noch ein ganz klein wenig "Luft"....
zfs-array:shares stefan/quotademo> get space_total space_available 
space_snapshots quota compressratio
space_total = 99.2G
space_available = 808M
space_snapshots = 0
quota = 100G
compressratio = 102

... die wir natürlich gerne noch aufbrauchen würden:

root@mars:~# mkfile 2g /mnt/2g.file
/mnt/2g.file: initialized 1510924288 of 2147483648 bytes: Disc quota exceeded
root@mars:~# ls -lh /mnt/*
-rw------- 1 nobody nobody 28G Sep 30 02:42 /mnt/28g.file
-rw------- 1 nobody nobody 2.0G Sep 30 02:48 /mnt/2g.file
-rw------- 1 nobody nobody 70G Sep 30 02:25 /mnt/70g.file
-rw-r--r-- 1 nobody nobody 3.6G Sep 30 02:38 /mnt/manytarfiles.tar
root@mars:~# du -h /mnt/*
28G /mnt/28g.file
1.4G /mnt/2g.file
70G /mnt/70g.file
1.2G /mnt/manytarfiles.tar
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
101G 101G 0K 100% /mnt

Nur dass 2GB natürlich zu viel war, was mit der erwarteten Fehlermeldung quittiert wurde.

Für den nächsten Versuch mit Snapshots ist erst wieder Aufräumen angesagt.

zfs-array:shares stefan/quotademo> destroy
This will destroy all data in "quotademo"! Are you sure? (Y/N)
zfs-array:shares stefan> filesystem quotademo
zfs-array:shares stefan/quotademo (uncommitted)> commit
zfs-array:shares stefan> select quotademo
zfs-array:shares stefan/quotademo> set quota=100g
quota = 100G (uncommitted)
zfs-array:shares stefan/quotademo> commit
zfs-array:shares stefan/quotademo> get space_total space_available
space_snapshots quota compressratio
space_total = 31K
space_available = 100G
space_snapshots = 0
quota = 100G
compressratio = 100

Wie üblich fangen wir mit einem Dateisystem mit 100GB Quota an.  Kompression gibt es jetzt keine, das wäre nur unnötig verwirrend.  Zum Anfang brauchen wir wieder unsere 25GB Datei:

root@mars:~# mkfile 25g /mnt/25g.file
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
100G 25G 75G 26% /mnt

So weit, so bekannt.  Jetzt legen wir einen Snapshot auf dem ZFS Array an:

zfs-array:shares stefan/quotademo snapshots> snapshot one25gfile
zfs-array:shares stefan/quotademo> get space_total space_available
space_snapshots quota compressratio
space_total = 25.0G
space_available = 75.0G
space_snapshots = 0
quota = 100G
compressratio = 100

Wie erwartet ändert sich dadurch erst einmal nichts.  Wir haben noch nichts verändert, also braucht der Snapshot auch keinen Platz.

Jetzt legen wir eine zweite Datei an:

root@mars:~# mkfile 25g /mnt/new.25g.file
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
100G 50G 50G 51% /mnt
zfs-array:shares stefan/quotademo> get space_total space_available
space_snapshots quota compressratio
                   space_total = 50.0G
               space_available = 50.0G
               space_snapshots = 19K
                         quota = 100G
                 compressratio = 100

Und der Snapshot enthält jetzt die Metadaten von vor der Veränderung.

Nun löschen wir die erste Datei:

root@mars:~# rm /mnt/25g.file 
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/quotademo
75G 25G 50G 34% /mnt

Der verfügbare Platz hat sich nicht verändert!!!  Dafür scheint unser Dateisystem um die Datenmenge geschrumpft zu sein, die wir eben gelöscht haben.  Das ist auf den ersten Blick etwas unerwartet, lässt sich aber natürlich mit den Daten erklären, die im Snapshot ja noch immer vorhanden sind:

zfs-array:shares stefan/quotademo> get space_total space_available
space_snapshots quota compressratio
                   space_total = 50.0G
               space_available = 50.0G
               space_snapshots = 25.0G
                         quota = 100G
                 compressratio = 100

Der Snapshot belegt jetzt 25GB.  Die anderen 25GB sind als "new.25g.file"  noch belegt.  Wir haben also immer noch 50GB frei, sehen aber im NFS nur die nicht geloeschten Daten, da NFS ja nichts von Snapshots weiss.  Die einzig logische Möglichkeit besteht daher darin, die Gesamtgröße jetzt mit 75GB anzugeben.  Das ist auf den ersten Blick etwas verwirrend, aber letztlich logisch.

Was passiert jetzt, wenn wir den Snapshot zurücksetzen?

zfs-array:shares stefan/quotademo@one25gfile> rollback
Rolling back will revert data to snapshot, destroying newer data. Active
initiators will be disconnected.

Continue? (Y/N)

root@mars:~# du -h /mnt/*
25G /mnt/25g.file

Wie erwartet ist die erste Datei noch vorhanden und das Dateisystem hat seine ursprüngliche Größe von 100GB wieder.

Als letztes Beispiel legen wir hiervon jetzt einen Clone an:

zfs-array:shares stefan/quotademo@one25gfile> clone stefan clonedemo
zfs-array:shares stefan/clonedemo (uncommitted clone)> commit
zfs-array:shares stefan> list filesystem

Filesystems:

NAME             SIZE   ENCRYPTED     MOUNTPOINT
quotademo        25.0G  off           /export/quotademo
clonedemo        18K    off           /export/clonedemo

zfs-array:shares stefan> select clonedemo
zfs-array:shares stefan/clonedemo> get space_total space_available
space_snapshots quota compressratio
                   space_total = 18K
               space_available = 100G
               space_snapshots = 0
                         quota = 100G
                 compressratio = 100

Das neue Dateisystem "clonedemo" belegt bis auf 18k Metadaten keinen Platz.  Wir haben also 100GB Quota zur Verfügung.  Wie sieht das im NFS aus?

root@mars:~# umount /mnt
root@mars:~# mount 192.168.30.1:/export/clonedemo /mnt
root@mars:~# df -h /mnt
Filesystem Size Used Available Capacity Mounted on
192.168.30.1:/export/clonedemo
125G 25G 100G 21% /mnt
root@mars:~# du -sh /mnt/*
25G /mnt/25g.file

Überraschung!  Unser Dateisystem ist 125GB gross!  Das liegt daran,  dass der Clone die 25GB Daten des ursprünglichen Dateisystems "erbt".  Sie gehen so lange nicht zu Lasten der Quota, solange sie nicht verändert werden.  Und da wir 100GB Quota für den Clone haben, ergibt sich daraus 125GB nutzbarer Platz.

Ich hoffe, diese Beispiele sind hilfreich, um die eine oder andere Verwirrung bei der Kombination von Kompression, Snapshots, Clones und den normalen Solaris Dateisystem-Kommandos auszuräumen.

Be the first to comment

Comments ( 0 )
Please enter your name.Please provide a valid email address.Please enter a comment.CAPTCHA challenge response provided was incorrect. Please try again.Captcha