ZFS

From Wikipedia, the free encyclopedia

Jump to: navigation, search
For other uses, see ZFS (disambiguation).
ZFS
Developer Sun Microsystems (Owned by Oracle Corporation)
Full name ZFS
Introduced November 2005 (OpenSolaris)
Structures
Directory contents Extensible hash table
Limits
Max file size 16 EiB
Max number of files 248
Max filename length 255 bytes
Max volume size 16 EiB
Features
Forks Yes (called Extended Attributes)
Attributes POSIX
File system permissions POSIX, NFSv4 ACLs
Transparent compression Yes
Transparent encryption Yes (currently beta)[1]
Data deduplication Yes
Supported operating systems Solaris, Mac OS X Server 10.5, FreeBSD, Linux via FUSE

In computing, ZFS is a combined file system and logical volume manager designed by Sun Microsystems, a subsidiary of Oracle Corporation. The features of ZFS include support for high storage capacities, integration of the concepts of filesystem and volume management, snapshots and copy-on-write clones, continuous integrity checking and automatic repair, RAID-Z and native NFSv4 ACLs. ZFS is implemented as open-source software, licensed under the Common Development and Distribution License (CDDL). The ZFS name is a trademark of Sun.[2]

Contents

[edit] History

ZFS was designed and implemented by a team at Sun led by Jeff Bonwick. It was announced on September 14, 2004.[3] Source code for ZFS was integrated into the main trunk of Solaris development on October 31, 2005[4] and released as part of build 27 of OpenSolaris on November 16, 2005. Sun announced that ZFS was included in the 6/06 update to Solaris 10 in June 2006, one year after the opening of the OpenSolaris community.[5]

The name originally stood for "Zettabyte File System". The original name selectors happened to like the name, and a ZFS file system has the ability to store 340 quadrillion zettabytes (256 pebi-zebibytes exactly, or 2128 bytes). Every ZiB is 270 bytes.[6]

[edit] Features

[edit] Storage pools

Unlike traditional file systems, which reside on single devices and thus require a volume manager to use more than one device, ZFS filesystems are built on top of virtual storage pools called zpools. A zpool is constructed of virtual devices (vdevs), which are themselves constructed of block devices: files, hard drive partitions, or entire drives, with the last being the recommended usage.[7] Thus, a vdev can be viewed as a group of hard drives. This means a zpool consists of one or more groups of drives. Block devices within a vdev may be configured in different ways, depending on needs and space available: non-redundantly (similar to RAID 0), as a mirror (RAID 1) of two or more devices, as a RAID-Z group of three or more devices, or as a RAID-Z2 group of four or more devices.[8] In July 2009, triple-parity RAID-Z3 was added to OpenSolaris.[9][10]

In addition, pools can have hot spares to compensate for failing disks. In addition, ZFS supports both read and write caching, for which special devices can be used. Solid State Devices can be used for the L2ARC, or Level 2 ARC, speeding up read operations, while NVRAM buffered SLC memory can be boosted with supercapacitors to implement a fast, non-volatile write cache, improving synchronous writes. Finally, when mirroring, block devices can be grouped according to physical chassis, so that the filesystem can continue in the face of the failure of an entire chassis.

Storage pool composition is not limited to similar devices but can consist of ad-hoc, heterogeneous collections of devices, which ZFS seamlessly pools together, subsequently doling out space to diverse filesystems as needed. Arbitrary storage device types can be added to existing pools to expand their size at any time. [11]

The storage capacity of all vdevs is available to all of the file system instances in the zpool. A quota can be set to limit the amount of space a file system instance can occupy, and a reservation can be set to guarantee that space will be available to a file system instance.

[edit] Capacity

ZFS is a 128-bit file system, so it can address 18 quintillion (1.84 × 1019) times more data than current 64-bit systems. The limitations of ZFS are designed to be so large that they would never be encountered, given the known limits of physics (and the number of atoms in the earth's crust to build such a storage device). Some theoretical limits in ZFS are:

  • 264 — Number of snapshots of any file system[12]
  • 248 — Number of entries in any individual directory[13]
  • 16 EiB (264 bytes) — Maximum size of a file system
  • 16 EiB — Maximum size of a single file
  • 16 EiB — Maximum size of any attribute
  • 256 ZiB (278 bytes) — Maximum size of any zpool
  • 256 — Number of attributes of a file (actually constrained to 248 for the number of files in a ZFS file system)
  • 264 — Number of devices in any zpool
  • 264 — Number of zpools in a system
  • 264 — Number of file systems in a zpool

[edit] Copy-on-write transactional model

ZFS uses a copy-on-write transactional object model. All block pointers within the filesystem contain a 32-bit checksum or 256-bit hash (currently a choice between Fletcher-2, Fletcher-4, or SHA-256)[14] of the target block which is verified when the block is read. Blocks containing active data are never overwritten in place; instead, a new block is allocated, modified data is written to it, then any metadata blocks referencing it are similarly read, reallocated, and written. To reduce the overhead of this process, multiple updates are grouped into transaction groups, and an intent log is used when synchronous write semantics are required.

[edit] Snapshots and clones

An advantage of copy-on-write is that when ZFS writes new data, the blocks containing the old data can be retained, allowing a snapshot version of the file system to be maintained. ZFS snapshots are created very quickly, since all the data composing the snapshot is already stored; they are also space efficient, since any unchanged data is shared among the file system and its snapshots.

Writeable snapshots ("clones") can also be created, resulting in two independent file systems that share a set of blocks. As changes are made to any of the clone file systems, new data blocks are created to reflect those changes, but any unchanged blocks continue to be shared, no matter how many clones exist.

[edit] Dynamic striping

Dynamic striping across all devices to maximize throughput means that as additional devices are added to the zpool, the stripe width automatically expands to include them; thus all disks in a pool are used, which balances the write load across them.

[edit] Variable block sizes

ZFS uses variable-sized blocks of up to 128 kilobytes. The currently available code allows the administrator to tune the maximum block size used as certain workloads do not perform well with large blocks. Automatic tuning to match workload characteristics is contemplated.[citation needed]

If data compression (LZJB) is enabled, variable block sizes are used. If a block can be compressed to fit into a smaller block size, the smaller size is used on the disk to use less storage and improve IO throughput (though at the cost of increased CPU use for the compression and decompression operations).

[edit] Lightweight filesystem creation

In ZFS, filesystem manipulation within a storage pool is easier than volume manipulation within a traditional filesystem; the time and effort required to create or resize a ZFS filesystem is closer to that of making a new directory than it is to volume manipulation in some other systems.

[edit] Cache management

ZFS also uses the ARC, a new method for cache management, instead of the traditional Solaris virtual memory page cache.

[edit] Adaptive endianness

Pools and their associated ZFS file systems can be moved between different platform architectures, including systems implementing different byte orders. The ZFS block pointer format stores filesystem metadata in an endian-adaptive way; individual metadata blocks are written with the native byte order of the system writing the block. When reading, if the stored endianness doesn't match the endianness of the system, the metadata is byte-swapped in memory.

This does not affect the stored data itself; as is usual in POSIX systems, files appear to applications as simple arrays of bytes, so applications creating and reading data remain responsible for doing so in a way independent of the underlying system's endianness.

[edit] Deduplication

Deduplication support has been added to the ZFS source repository at the end of October 2009. [15] The OpenSolaris ZFS development packages has been available since December 3rd (build 128), and the OpenSolaris release packages will be rolled in the first quarter of 2010.

[edit] Additional capabilities

  • Explicit I/O priority with deadline scheduling.
  • Claimed globally optimal I/O sorting and aggregation.
  • Multiple independent prefetch streams with automatic length and stride detection.
  • Parallel, constant-time directory operations.
  • End-to-end checksumming, using a kind of "Data Integrity Field", allowing data corruption detection (and recovery if you have redundancy in the pool).
  • Transparent filesystem compression. Supports LZJB and gzip.[16]
  • Intelligent scrubbing and resilvering.[17]
  • Load and space usage sharing between disks in the pool.[18]
  • Ditto blocks: Configurable data replication per filesystem, with zero, one or two extra copies requested per write for user data, and with that same base number of copies plus one or two for metadata (according to metadata importance).[19] If the pool has several devices, ZFS tries to replicate over different devices. Ditto blocks are primarily an additional protection against corrupted sectors, not against total disk failure.[20]
  • ZFS design (copy-on-write + superblocks) is safe when using disks with write cache enabled, if they honor the write barriers. This feature provides safety and a performance boost compared with some other filesystems.
  • When entire disks are added to a ZFS pool, ZFS automatically enables their write cache. This is not done when ZFS only manages discrete slices of the disk, since it doesn't know if other slices are managed by non-write-cache safe filesystems, like UFS.
  • Per-user and per-group quotas support.[21]
  • Planned features:
    • Filesystem encryption is due for integration in Q1 2010[1] and is currently not available in production environments under Solaris or OpenSolaris.
    • The so-called Block Pointer rewrite functionality is due to be added in the same time frame, paving the way for resizing pools, defragmentation, (re-)applying compression on filesystems and so on.[22]
    • Recovery tools will be added for recovering from the loss of a pool.

[edit] Limitations

  • Capacity expansion is normally achieved by adding groups of disks as a top-level vdev: simple device, RAID-Z, RAID-Z2, RAID-Z3, or mirrored. Newly written data will dynamically start to use all available vdevs. It is also possible to expand the array by iteratively swapping each drive in the array with a bigger drive and waiting for ZFS to heal itself — the heal time will depend on amount of stored information, not the disk size. The new free space will not be available until all the disks have been swapped.
  • It is currently not possible to reduce the number of top-level vdevs in a pool nor otherwise reduce pool capacity.[23] This functionality was said to be in development already in 2007[24]. It is not available as of Solaris 10 10/09 (AKA update 8).
  • It is not possible to add a disk as a column to a RAID-Z, RAID-Z2, or RAID-Z3 vdev. This feature depends on the block pointer rewrite functionality due to be added soon. You can however create a new RAID-Z vdev and add it to the zpool.
  • Vdevs cannot be nested, so a mirror or RAID-Z top-level vdev can only contain files or disks. Mirrors of mirrors (or other combinations) are not allowed.
  • Reconfiguring the number of top-level vdev requires copying data offline, destroying the pool, and recreating the pool with the new top-level vdev configuration.
  • ZFS is not a native cluster, distributed, or parallel file system and cannot provide concurrent access from multiple hosts as ZFS is a local file system. Sun's Lustre distributed filesystem will adapt ZFS as back-end storage for both data and metadata in version 3.0, which is scheduled to be released in 2010.[25]
  • ZFS expects a disk cache flush command to commit cached data to media. Some virtualization software are configured by default to ignore cache flush commands, and some consumer-grade hardware 'lies' about actually executing the command as well. For example, VirtualBox can be, but is not by default configured to properly respect cache flushes (configuration would be using the procedure described in section 11.1.3 Responding to guest IDE flush requests of the Sun VirtualBox User Manual[26]); consumer grade USB disk enclosures are said to be particularly vulnerable to this problem. In the event of an outage or fault this can quite possibly lead to damage to the pool; as ZFS ships without any recovery tools (such as fsck or chdsk), this damage is currently almost irrecoverable [27]. Special pool recovery tools are ready for integration in Q4 2009 to overcome this robustness issue by restoring a pool to an older uberblock.
  • ZFS has no defragmentation utility. Usage of COW with often changed files lead to high fragmentation.
  • "Copies" are not the same thing as "replicas" for purposes of data recovery. Therefore, pools of non-replicated vdevs have the resiliency of RAID-0 with none of the performance. [28]

[edit] Platforms

ZFS is part of Sun's own Solaris operating system and is thus available on both SPARC and x86-based systems. Since the code for ZFS is open source, a port to other operating systems and platforms can be produced without Sun's involvement.

[edit] OpenSolaris

OpenSolaris 2008.05 and 2009.06 use ZFS as their default filesystem. There are a half dozen 3rd party distributions.

[edit] FreeBSD

FreeBSD version 8 includes a much-updated implementation of ZFS.[29]. zpool version 13 is now supported. [29]

Pawel Jakub Dawidek ported ZFS to FreeBSD, and it has been part of FreeBSD since version 7.0.[30] 7-stable and 8-stable is on zpool version 13 while the current development branch uses ZFS version 14. Moreover, zfsboot has been implemented in both branches.[31][32] It's fully functional; the only missing features are kernel CIFS server and iSCSI.

[edit] NetBSD

ZFS port was started as a part of the 2007 Google Summer of Code and in August 2009 the code has made it into NetBSD's source tree.[33]

[edit] Mac OS X

The first indication of Apple Inc.'s interest in ZFS was an April 2006 post on the opensolaris.org zfs-discuss mailing list where an Apple employee mentioned being interested in porting ZFS to their Mac OS X operating system.[34]

In the release version of Mac OS X 10.5, ZFS was available in read-only mode from the command line, which lacks the possibility to create zpools or write to them.[35] Before the 10.5 release, Apple released the "ZFS Beta Seed v1.1", which allowed read-write access and the creation of zpools,[36] however the installer for the "ZFS Beta Seed v1.1" has been reported to only work on version 10.5.0, and has not been updated for version 10.5.1 and above.[37]

In August 2007, Apple opened a ZFS project on their Mac OS Forge site. On that site, Apple provided the source code and binaries of their port of ZFS which includes read-write access, but there was no installer available[38] until a third-party developer created one.[39]

In October 2009, Apple announced a shutdown of the ZFS project on Mac OS Forge. No explanation was given, just the following statement: "The ZFS project has been discontinued. The mailing list and repository will also be removed shortly." Versions of the previously released source and binaries, as well as the wiki, have been preserved and development has been adopted by a group of enthusiasts.[40][41]

Complete ZFS support was once advertised as a feature of Snow Leopard Server (Mac OS X Server 10.6). However, all references to this feature have been silently removed; it is no longer listed on the Snow Leopard Server features page.[42] Apple has not commented regarding the omission.

[edit] Linux

Porting ZFS to Linux is complicated by the fact that the GNU General Public License, which governs the Linux kernel, is incompatible with the Sun CDDL under which ZFS is distributed. A single derived work of both projects cannot be legally distributed, as it is not possible to simultaneously meet both licenses' requirements. To include ZFS in the Linux kernel it would have to be cleanly reimplemented, and patents may hamper this.[43]

The solution to this problem was to port ZFS to Linux's FUSE system so the filesystem runs in userspace instead, where it is not considered a derived work of the kernel. A project to do this was sponsored by Google's Summer of Code program in 2006, and is in a bugfix-only state as of March 2009.[44] The original ZFS on FUSE project is available here. Sun Microsystems has stated that a Linux port is being investigated.[45] Development for ZFS on FUSE/Linux now takes place at zfs-fuse.net.

[edit] See also

Free software portal

[edit] References

  1. ^ a b "OpenSolaris.org". Sun Microsystems. http://opensolaris.org/os/project/zfs-crypto. Retrieved 2007-10-21. 
  2. ^ "Sun Trademarks - ZFS". Sun Microsystems. http://www.sun.com/suntrademarks/. 
  3. ^ "ZFS: the last word in file systems". Sun Microsystems. September 14, 2004. http://www.sun.com/2004-0914/feature/. Retrieved 2006-04-30. 
  4. ^ Jeff Bonwick (October 31, 2005). "ZFS: The Last Word in Filesystems". Jeff Bonwick's Blog. http://blogs.sun.com/roller/page/bonwick?entry=zfs_the_last_word_in. Retrieved 2006-04-30. 
  5. ^ "Sun Celebrates Successful One-Year Anniversary of OpenSolaris". Sun Microsystems. June 20, 2006. http://www.sun.com/smi/Press/sunflash/2006-06/sunflash.20060620.1.xml. 
  6. ^ "ZFS FAQ at OpenSolaris.org". Sun Microsystems. http://opensolaris.org/os/community/zfs/faq/#whatstandfor. Retrieved 2009-03-03. 
  7. ^ "Solaris ZFS Administration Guide". Sun Microsystems. http://docs.sun.com/app/docs/doc/819-5461/6n7ht6qrr?a=view#gazdp. Retrieved 2007-10-02. 
  8. ^ "ZFS Best Practices Guide". Solaris Performance Wiki. http://www.solarisinternals.com/wiki/index.php/ZFS_Best_Practices_Guide#RAID-Z_Configuration_Requirements_and_Recommendations. Retrieved 2007-10-02. 
  9. ^ Leventhal, Adam. "Bug ID: 6854612 triple-parity RAID-Z". Sun Microsystems. http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=6854612. Retrieved 2009-07-17. 
  10. ^ Leventhal, Adam (2009-07-16). "6854612 triple-parity RAID-Z". zfs-discuss mailing list. http://mail.opensolaris.org/pipermail/onnv-notify/2009-July/009872.html. Retrieved 2009-07-17. 
  11. ^ "Solaris ZFS Enables Hybrid Storage Pools—Shatters Economic and Performance Barriers"
  12. ^ "Solaris ZFS Administration Guide". Sun Microsystems. http://docs.sun.com/app/docs/doc/819-5461/6n7ht6qsb?a=view. Retrieved 2007-10-05. 
  13. ^ "Solaris ZFS Administration Guide". Sun Microsystems. http://docs.sun.com/app/docs/doc/819-5461/6n7ht6qr0?a=view. Retrieved 2007-10-05. 
  14. ^ "ZFS On-Disk Specification". Sun Microsystems, Inc.. 2006. http://opensolaris.org/os/community/zfs/docs/ondiskformat0822.pdf.  See section 2.4.
  15. ^ ""ZFS Deduplication"". http://blogs.sun.com/bonwick/en_US/entry/zfs_dedup. 
  16. ^ "Solaris ZFS Administration Guide". Chapter 6 Managing ZFS File Systems. http://docs.sun.com/app/docs/doc/819-5461/gavwq?a=view. Retrieved 2009-03-17. 
  17. ^ "Smokin' Mirrors". Jeff Bonwick's Weblog. 2006-05-02. http://blogs.sun.com/bonwick/entry/smokin_mirrors. Retrieved 2007-02-23. 
  18. ^ "ZFS Block Allocation". Jeff Bonwick's Weblog. 2006-11-04. http://blogs.sun.com/bonwick/entry/zfs_block_allocation. Retrieved 2007-02-23. 
  19. ^ "Ditto Blocks - The Amazing Tape Repellent". Flippin' off bits Weblog. 2006-05-12. http://blogs.sun.com/bill/entry/ditto_blocks_the_amazing_tape. Retrieved 2007-03-01. 
  20. ^ "Adding new disks and ditto block behaviour". http://opensolaris.org/jive/thread.jspa?messageID=417776. Retrieved 2009-10-19. 
  21. ^ "OpenSolaris.org". Sun Microsystems. http://www.opensolaris.org/os/community/zfs/version/15/. Retrieved 2009-05-22. 
  22. ^ Jeff Bonwick Keynote at Kernel Conference Australia 2009
  23. ^ "Bug ID 4852783: reduce pool capacity". OpenSolaris Project. http://bugs.opensolaris.org/view_bug.do?bug_id=4852783. Retrieved 2009-03-28. 
  24. ^ Goebbels, Mario (2007-04-19). "Permanently removing vdevs from a pool". zfs-discuss mailing list. http://mail.opensolaris.org/pipermail/zfs-discuss/2007-April/010384.html. 
  25. ^ ""Lustre Roadmap"". http://wiki.lustre.org/index.php?title=Lustre_Roadmap. 
  26. ^ ""Sun VirtualBox User Manual version 3.0.4". http://dlc-cdn-rd.sun.com/c1/virtualbox/3.0.4/UserManual.pdf. 
  27. ^ ""Another user looses his pool (10TB) in this case and 40 days work"". http://www.opensolaris.org/jive/thread.jspa?threadID=108213&tstart=0. 
  28. ^ ""The official error message for a vdev going missing, even if it's replaced"". http://www.sun.com/msg/ZFS-8000-5E. 
  29. ^ a b "FreeBSD 8.0-RELEASE Release Notes". FreeBSD. http://www.freebsd.org/releases/8.0R/relnotes.html. Retrieved 2009-11-27. 
  30. ^ Dawidek, Pawel (April 6, 2007). "ZFS committed to the FreeBSD base". http://lists.freebsd.org/pipermail/freebsd-current/2007-April/070544.html. Retrieved 2007-04-06. 
  31. ^ "Revision 192498". May 20, 2009. http://svn.freebsd.org/viewvc/base?view=revision&revision=192498. Retrieved 2009-05-22. 
  32. ^ "ZFS v13 in 7-STABLE". May 21, 2009. http://ivoras.sharanet.org/blog/tree/2009-05-21.zfs-v13-in-7-stable.html. Retrieved 2009-05-22. 
  33. ^ "NetBSD Google Summer of Code projects: ZFS". http://www.netbsd.org/contrib/soc-projects.html#zfs-port. 
  34. ^ "Porting ZFS to OSX". zfs-discuss. April 27, 2006. http://mail.opensolaris.org/pipermail/zfs-discuss/2006-April/002119.html. Retrieved 2006-04-30. 
  35. ^ "Apple: Leopard offers limited ZFS read-only". MacNN. June 12, 2007. http://www.macnn.com/articles/07/06/12/leopard.uses.hfs.not.zfs/. Retrieved 2007-06-23. 
  36. ^ "Apple delivers ZFS Read/Write Developer Preview 1.1 for Leopard". Ars Technica. October 7, 2007. http://arstechnica.com/journals/apple.ars/2007/10/07/apple-delivers-zfs-readwrite-developer-preview-1-1-for-leopard. Retrieved 2007-10-07. 
  37. ^ Ché Kristo (November 18, 2007). "ZFS Beta Seed v1.1 will not install on Leopard.1 (10.5.1) « ideas are free". http://synesius.wordpress.com/2007/11/18/zfs-beta-seed-v11-will-not-install-on-leopard1-1051/. Retrieved 2007-12-30. 
  38. ^ http://zfs.macosforge.org
  39. ^ http://alblue.blogspot.com/2008/11/zfs-119-on-mac-os-x.html
  40. ^ http://code.google.com/p/maczfs/
  41. ^ http://groups.google.com/group/zfs-macos/?pli=1
  42. ^ "Snow Leopard". June 9, 2009. http://www.apple.com/server/macosx/snowleopard/. Retrieved 2008-06-10. 
  43. ^ Jeremy Andrews (April 19, 2007). "Linux: ZFS, Licenses and Patents". http://kerneltrap.org/node/8066. Retrieved 2007-04-21. 
  44. ^ Ricardo Correia (March 16, 2009). "ZFS on FUSE/Linux". http://zfs-on-fuse.blogspot.com/. Retrieved 2009-03-16. 
  45. ^ "Fast Track to Solaris 10 Adoption: ZFS Technology". Solaris 10 Technical Knowledge Base. Sun Microsystems. http://www.sun.com/emrkt/campaign_docs/expertexchange/knowledge/solaris_zfs_gen.html#10. Retrieved 2006-04-24. 

[edit] Bibliography

[edit] External links

v • d • e
Solaris
Technologies
OpenSolaris
v • d • e
Mac OS X
Versions
Applications
Utilities
Technology and
user interface
Retrieved from "http://en.wikipedia.org/wiki/ZFS"