ZFS

Infobox Filesystem
full_name = ZFS
name = ZFS
developer = Sun Microsystems
introduction_os = OpenSolaris
introduction_date = November 2005
partition_id =
directory_struct = Extensible hash table
file_struct =
bad_blocks_struct =
max_filename_size = 255 bytes
max_files_no = 2⁴⁸
max_volume_size = 16 EiB
max_file_size = 16 EiB
filename_character_set =
dates_recorded =
date_range =
date_resolution =
forks_streams = Yes (called Extended Attributes)
attributes = POSIX
file_system_permissions = POSIX, ACL
compression = Yes
single_instance_storage =
encryption = Yes (currently beta)
OS = Sun Solaris, Apple Mac OS X Server 10.5, FreeBSD, Linux via FUSE

In computing, ZFS is a file system designed by Sun Microsystems for the Solaris Operating System. 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, on-line integrity checking and repair, and RAID-Z. ZFS is implemented as open-source software, licensed under the Common Development and Distribution License (CDDL).

History

ZFS was designed and implemented by a team at Sun led by Jeff Bonwick. It was announced on September 14 2004.cite web
url = http://www.sun.com/2004-0914/feature/ | title = ZFS: the last word in file systems | accessdate = 2006-04-30 | publisher = Sun Microsystems | date = September 14 2004 ] Source code for ZFS was integrated into the main trunk of Solaris development on October 31 2005 [ cite web | url = http://blogs.sun.com/roller/page/bonwick?entry=zfs_the_last_word_in | title = ZFS: The Last Word in Filesystems | author = Jeff Bonwick | work = Jeff Bonwick's Blog |date=October 31, 2005 | accessdate = 2006-04-30 ] 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. [ cite web | url = http://www.sun.com/smi/Press/sunflash/2006-06/sunflash.20060620.1.xml | title = Sun Celebrates Successful One-Year Anniversary of OpenSolaris | publisher = Sun Microsystems | date = June 20 2006 ]

The name originally stood for "Zettabyte File System", but is now an orphan acronym. [ cite web | title = You say zeta, I say zetta | author = Jeff Bonwick| date = 2006-05-04 | work = Jeff Bonwick's Blog | accessdate = 2006-09-08 | url = http://blogs.sun.com/bonwick/entry/you_say_zeta_i_say ]

Features

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. [ cite web | url = http://docs.sun.com/app/docs/doc/819-5461/6n7ht6qrr?a=view#gazdp | title = Solaris ZFS Administration Guide | publisher = Sun Microsystems | accessdate = 2007-10-02] 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. [ cite web | url = http://www.solarisinternals.com/wiki/index.php/ZFS_Best_Practices_Guide#RAID-Z_Configuration_Requirements_and_Recommendations | title = ZFS Best Practices Guide | publisher = Solaris Performance Wiki | accessdate = 2007-10-02] 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.

Capacity

ZFS is a 128-bit file system, so it can store 18 billion billion (1.84 × 10¹⁹) times more data than current 64-bit systems. The limitations of ZFS are designed to be so large that they will not be encountered in practice for some time. Some theoretical limits in ZFS are:

* 2⁶⁴ — Number of snapshots of any file system [ cite web | url = http://docs.sun.com/app/docs/doc/819-5461/6n7ht6qsb?a=view | title = Solaris ZFS Administration Guide | publisher = Sun Microsystems | accessdate = 2007-10-05]
* 2⁴⁸ — Number of entries in any individual directory [ cite web | url = http://docs.sun.com/app/docs/doc/819-5461/6n7ht6qr0?a=view | title = Solaris ZFS Administration Guide | publisher = Sun Microsystems | accessdate = 2007-10-05]
* 16 EiB (2⁶⁴ bytes) — Maximum size of a file system
* 16 EiB — Maximum size of a single file
* 16 EiB — Maximum size of any attribute
* 256 ZiB (2⁷⁸ bytes) — Maximum size of any zpool
* 2⁵⁶ — Number of attributes of a file (actually constrained to 2⁴⁸ for the number of files in a ZFS file system)
* 2⁵⁶ — Number of files in a directory (actually constrained to 2⁴⁸ for the number of files in a ZFS file system)
* 2⁶⁴ — Number of devices in any zpool
* 2⁶⁴ — Number of zpools in a system
* 2⁶⁴ — Number of file systems in a zpool

Project leader Bonwick said, "Populating 128-bit file systems would exceed the quantum limits of earth-based storage. You couldn't fill a 128-bit storage pool without boiling the oceans." However, there are no known independent sources that verify this claim.

Copy-on-write transactional model

ZFS uses a copy-on-write transactional object model. All block pointers within the filesystem contain a 256-bit checksum 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, and 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.

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.

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.

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.Fact|date=May 2007

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).

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.

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, allowing data corruption detection (and recovery if you have redundancy in the pool).
* Intelligent scrubbing and resilvering. [cite web | title = Smokin' Mirrors | work = Jeff Bonwick's Weblog | date = 2006-05-02 | accessdate = 2007-02-23 | url = http://blogs.sun.com/bonwick/entry/smokin_mirrors]
* Load and space usage sharing between disks in the pool. [cite web | title = ZFS Block Allocation | work = Jeff Bonwick's Weblog | date = 2006-11-04 | accessdate = 2007-02-23 | url = http://blogs.sun.com/bonwick/entry/zfs_block_allocation]
* Ditto blocks: Metadata is replicated inside the pool, two or three times (according to metadata importance). [cite web | title = Ditto Blocks - The Amazing Tape Repellent | work = Flippin' off bits Weblog | date = 2006-05-12 | accessdate = 2007-03-01 | url = http://blogs.sun.com/bill/entry/ditto_blocks_the_amazing_tape] If the pool has several devices, ZFS tries to replicate over different devices. So a pool without redundancy can lose data if you find bad sectors, but metadata should be fairly safe even in this scenario.
* ZFS design (copy-on-write + superblocks) is safe when using disks with write cache enabled, if they support the cache flush commands issued by ZFS. 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.
* Filesystem encryption is supported, though is currently in a beta stage. cite web | url = http://opensolaris.org/os/project/zfs-crypto | title = OpenSolaris.org | publisher = Sun Microsystems | accessdate = 2007-10-21]

Cache management

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

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.

Limitations

* ZFS doesn't support per-user or per-group quotas. Instead, it is possible to create user-owned filesystems, each with its own size limit. Intrinsically, there is no practical quota solution for the file systems shared among several users (such as team projects, for example), where the data cannot be separated per user, although it could be implemented on top of the ZFS stack.

* Capacity expansion is normally achieved by adding groups of disks as a vdev (stripe, RAID-Z, RAID-Z2, 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. If a snapshot is taken during this process, it will cause the heal to be restarted.

* It is currently not possible to reduce the number of vdevs in a pool nor otherwise reduce pool capacity. However, it is currently being [http://www.opensolaris.org/jive/thread.jspa?messageID=118280 worked on] by the ZFS team. Still not available as of Solaris 10 05/08 (AKA update 5).

* It is not possible to add a disk to a RAID-Z or RAID-Z2 vdev. This feature appears very difficult to implement. You can however create a new RAIDZ vdev and add it to the zpool.

* You cannot mix vdev types in a zpool. For example, if you had a striped ZFS pool consisting of disks on a SAN, you cannot add the local-disks as a mirrored vdev.

* Reconfiguring storage requires copying data offline, destroying the pool, and recreating the pool with the new policy.

* 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 1.8, which will be released in Q2 2008update after|2008|06|30. [ cite web | url = http://arch.lustre.org/index.php?title=Architecture_ZFS_for_Lustre | title = Architecture ZFS for Lustre | accessdate = 2008-02-18 | publisher = Sun Microsystems]

Solaris implementation issues

The current ZFS implementation (Solaris 10 11/06) has some issues administrators should know before deploying it. Many of these issues are scheduled to be addressed in future releases.

* ZFS root filesystem support is currently set to off on Solaris 10 default installations, since the standard installer still does not fully support ZFS roots. The ZFS Boot project successfully added boot support to the OpenSolaris project in March 2007. [cite web
title = Latest ZFS add-ons
date = 2007-03-28
work = milek's blog
accessdate = 2007-03-29
url = http://milek.blogspot.com/2007/03/latest-zfs-add-ons.html ] [cite web
title = ZFS Bootable datasets - happily rumbling
date = 2007-03-29
work = Tim Foster's blog
accessdate = 2007-04-01
url = http://blogs.sun.com/timf/entry/zfs_bootable_datasets_happily_rumbling] Bootable ZFS file systems are available for x86 systems in Solaris Indiana, and the Solaris Nevada installer supports ZFS boot on both SPARC and x86 platforms as of build 90 [cite web
title = ZFS Boot FAQ
date = 2008-06-12
accessdate = 2008-06-13
url = http://opensolaris.org/os/community/zfs/boot/zfsbootFAQ/] .

* If a Solaris Zone is put on ZFS, the system cannot be upgraded; the OS will need to be reinstalled. This issue is planned to be addressed in a Solaris 10 update in 2007Fact|date=August 2007.update after|2007|12|31

* A file "fsync" will commit to disk all pending modifications on the filesystem. That is, an "fsync" on a file will flush out all deferred (cached) operations to the filesystem (not the pool) in which the file is located. This can make some fsync() slow when running alongside a workload which writes a lot of data to filesystem cache. [cite web | title = The Dynamics of ZFS | work = Roch Bourbonnais' Weblog | date = 2006-06-21 | accessdate = 2007-02-19 | url = http://blogs.sun.com/roch/entry/the_dynamics_of_zfs] The issue is currently fixed in the OpenSolaris code baseFact|date=April 2008.

* New vdevs can be added to a storage pool, but they cannot be removed. A vdev can be exchanged for a bigger one, but it cannot be removed (even if the size to be removed is less than the pool's unused space). The ability to shrink a zpool is a work in progress, but is said to be a very challenging problem. Originally targeted for Solaris 10 update 5, this is still not fixed in Solaris Nevada (up to build 95), so it is unlikely that this feature will appear in any Solaris 10 release until at least 2009. Refer to this [http://www.opensolaris.org/jive/thread.jspa?threadID=8125 zfs-discuss thread on OpenSolaris] for updates. update after|2008|12|31

* ZFS encourages creation of many filesystems inside the pool (for example, for quota control), but importing a pool with thousands of filesystems is a slow operation (can take minutes).

* ZFS uses a lot of CPU when doing small writes (for example, a single byte). There are two root causes, currently being worked on: a) Translating from znode to dnode is slower than necessary because ZFS doesn't use translation information it already has, and b) Current partial-block update code is very inefficient. [cite web | title = Implementing fbarrier() on ZFS | work = zfs-discuss | date = 2007-02-13 | accessdate = 2007-02-13 | url = http://www.opensolaris.org/jive/thread.jspa?messageID=93115&93115]

* ZFS copy-on-write operation can degrade on-disk file layout (file fragmentation) when files are modified, decreasing performance.Fact|date=August 2007.update after|2007|12|31

* ZFS blocksize is configurable per filesystem, currently 128 KB by default. Reads or writes which are smaller than the block size suffer a performance penalty. If your workload reads/writes data in fixed sizes (blocks), for example a database, you should (manually) configure ZFS blocksize equal to the application blocksize, for better performance and to conserve cache memory and disk bandwidth.

* ZFS only offlines a faulty hard disk if it can't be opened. Read/write errors or slow/timed-out operations do not currently cause a disk to be marked as faulty. This is fixed in Solaris Nevada via [http://bugs.opensolaris.org/view_bug.do?bug_id=6520519 6520519] .

* There is work in progress to provide automatic and periodic disk scrubbing, in order to provide corruption detection and early disk-rotting detection. Currently the data scrubbing must be done manually with "zpool scrub" command.

* Current ZFS compression/decompression code is very fast, but the compression ratio is not comparable to gzip or similar algorithms. The gzip compression algorithm was added in Solaris Nevada as part of [http://bugs.opensolaris.org/view_bug.do?bug_id=6536606 6536606] and is planned for a Solaris 10 update in Spring 2008.update after|2008|05|31 [cite web | title = zfs-discuss ZFS gzip compression | work = Prabahar Jeyaram | date = 2007-09-29 | accessdate = 2007-12-11 | url = http://mail.opensolaris.org/pipermail/zfs-discuss/2007-September/043228.html]

* If a snapshot is taken or destroyed while the zpool is scrubbing/resilvering, the process will be restarted from the beginning. [cite web | title = scrub/resilver has to start over when a snapshot is taken | work = OpenSolaris Bug Tracker | date = 2005-10-30 | accessdate = 2007-03-14 | url = http://bugs.opensolaris.org/view_bug.do?bug_id=6343667] This bug is now resolved in the OpenSolaris code base.

* Not all symbolic links are protected by ditto blocks. [cite web | title = symlinks and ditto blocks | work = OpenSolaris Forums | date = 2007-03-28 | accessdate = 2007-07-13 | url = http://www.opensolaris.org/jive/thread.jspa?threadID=27183&tstart=315] [cite web | title = zpl symlinks should have their own object type | work = OpenSolaris Bug Tracker | date = 2007-01-23 | accessdate = 2007-07-13 | url = http://bugs.opensolaris.org/view_bug.do?bug_id=6516171]

* Swapping over ZVOL pseudo-devices can hang the system. [cite web | title = Plans for swapping to part of a pool | work = OpenSolaris Forums | date = 2007-07-12 | accessdate = 2007-07-14 | url = http://www.opensolaris.org/jive/hread.jspa?messageID=137230&#137230] [cite web | title = system hang while zvol swap space shorted | work = OpenSolaris Bug Tracker | date = 2007-02-26 | accessdate = 2007-07-14 | url = http://bugs.opensolaris.org/view_bug.do?bug_id=6528296] This was resolved in the OpenSolaris code base at the same time that ZFS root/boot support was added for SPARC. Zvols can also be used as the system crash dump device. A separate zvol is required for swap and dump.

* If a non-redundant disk in a zpool goes offline the entire operating system will panic on the next read or write. This can be a problem when for example a large server has multiple filesystems used for different purposes - one filesystem failure shouldn't cause the entire system to go down. This is fixed with the zpool "failmode" option added in Nevada b77 [cite web | title = Bug ID: 6322646 ZFS should gracefully handle all devices failing (when writing): | work = OpenSolaris Bug Tracker | date = 2008-04-12 | url = http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=6322646] [cite web | title = zpool failmode property [PSARC/2007/567 FastTrack timeout 10/08/2007] | date = 2007-10-10 | url = http://opensolaris.org/os/community/arc/caselog/2007/567/mail]

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.

OpenSolaris

OpenSolaris 2008.05 uses ZFS as its default filesystem. [http://www.opensolaris.org/os/community/distribution/links/ There are a half dozen 3rd party distributions.]

Nexenta OS, a complete GNU-based open source operating system built on top of the OpenSolaris kernel and runtime, includes a ZFS implementation, added in version alpha1. More recently, [http://www.nexenta.com Nexenta Systems] announced NexentaStor, their ZFS storage appliance providing NAS/SAN/iSCSI capabilities and based on Nexenta OS. NexentaStor includes a GUI that simplifies the process of utilizing ZFS.

Nexenta announced in February of 2008 a significant release, called version NexentaCore Platform 1.0, of their operating system which serves as a basis for software appliances from Nexenta and other distributions. As of June 15 '08 "NexentaCore 2.0 Alpha1 Release (unstable)" is available. [http://www.nexenta.org/os/DownloadMirrors Nexenta downloads] .

BSD

Pawel Jakub Dawidek has ported and committed ZFS to FreeBSD in experimental capacity for inclusion in FreeBSD 7.0, released on February 28, 2008. cite web | url = http://lists.freebsd.org/pipermail/freebsd-current/2007-April/070544.html | title = ZFS committed to the FreeBSD base | first = Pawel | last = Dawidek | accessdate = 2007-04-06 | date = April 6 2007] The current recommendation is to use it only on amd64 platforms with sufficient memory but there is a newer port (uncommited yet) which fixes the memory issue.

As a part of the 2007 Google Summer of Code a ZFS port was started for NetBSD. cite web | url = http://www.netbsd.org/contrib/soc-projects.html#zfs-port | title = NetBSD Google Summer of Code projects: ZFS ]

Mac OS X Server

In a post on the [http://opensolaris.org/ opensolaris.org] zfs-discuss mailing list, Apple Inc. announced it was porting ZFS to their Mac OS X operating system. [cite web | url = http://mail.opensolaris.org/pipermail/zfs-discuss/2006-April/002119.html | title = Porting ZFS to OSX | work = zfs-discuss | date = April 27 2006 | accessdate = 2006-04-30 ] From Mac OS X 10.5 Developer Seed 9A321, support for ZFS has been included, but lacks the ability to act as a root partition, noted above. Also, attempts to format local drives using ZFS were unsuccessful; this is a known bug. [ cite web | url=http://forum.insanelymac.com/index.php?showtopic=35356&st=80&gopid=254997&entry254997 | title=Mac OS X 10.5 9A326 Seeded | work = InsanelyMac Forums | date = December 14 2006 | accessdate = 2006-12-14 ]

On June 6, 2007, Sun's CEO Jonathan I. Schwartz announced that Apple would make ZFS "the" filesystem in Mac OS 10.5 Leopard. [ cite web | url=http://www.sun.com/jsp_utils/rvideo.jsp?video=74cd4547-01df-440b-823d-48878ae34c73 | title=Sun announce ZFS is "the file system" in Mac OS X v10.5 | work=Sun | date = June 6 2007 | accessdate = 2007-06-06] Marc Hamilton, VP for Solaris Marketing later wrote to clarify that, in his opinion, Apple is planning to use ZFS in future versions of Mac OS X, but not necessarily as the default filesystem for Mac OS X 10.5 Leopard. [ cite web | url=http://blogs.sun.com/marchamilton/entry/sun_s_new_modular_blade | title=Marc Hamilton's weblog: Apple is planning to use the ZFS file system from OpenSolaris in future versions of their OS | work = Marc Hamilton's weblog | date = June 7 2007 | accessdate = 2007-06-07 ] In the release version of Mac OS X 10.5, ZFS is available in read-only mode from the command line, which lacks the possibility to create zpools or write to them, [ cite web | url=http://www.macnn.com/articles/07/06/12/leopard.uses.hfs.not.zfs/ | title=Apple: Leopard offers limited ZFS read-only | work = MacNN | date = June 12 2007 | accessdate = 2007-06-23 ] but Apple has also released the ""ZFS Beta Seed v1.1", [ cite web | url=http://arstechnica.com/journals/apple.ars/2007/10/07/apple-delivers-zfs-readwrite-developer-preview-1-1-for-leopard | title=Apple delivers ZFS Read/Write Developer Preview 1.1 for Leopard | work = Ars Technica | date = October 7 2007 | accessdate = 2007-10-07 ] which allows read-write access and the creation of zpools. Apple states at their Developer Connection site "This seed requires installation on systems running Leopard9A559 or later." [ cite web | url=https://connect.apple.com/ | title=ADC Member Site « requires member login for access | date = October 26 2007 | accessdate = 2008-08-01 ] 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. [ cite web | url=http://synesius.wordpress.com/2007/11/18/zfs-beta-seed-v11-will-not-install-on-leopard1-1051/ | title=ZFS Beta Seed v1.1 will not install on Leopard.1 (10.5.1) « ideas are free | author = Ché Kristo | date = November 18 2007 | accessdate = 2007-12-30 ] As of January 2008, Apple provides read-write [http://zfs.macosforge.org/?page_id=5 binaries and source] , but they must be installed by hand. Alex Blewitt put together an installer for [http://www.bandlem.com/ZFS-102-A.pkg the 102-A binaries] , which doesn't need any hand-holding to install.

The current Mac OS Forge release of the Mac OS X ZFS project is version 119 and synchronized with the OpenSolaris ZFS SVN version 72 [ cite web | url = http://zfs.macosforge.org/trac/wiki/downloads | title = Mac OS Forge ZFS Project | date = May 23 2008 | accessdate = 2008-05-23] See: [http://zfs.macosforge.org/trac/wiki/downloads Mac OS X ZFS Project Downloads]

Apple has also unveiled support for ZFS in its development version of [http://www.apple.com/server/macosx/snowleopard/ Mac OS X Server "Snow Leopard"] , a 64-bit OS optimized for machines with multi-core processors. [ cite web | url = http://www.apple.com/server/macosx/snowleopard/ | title = Snow Leopard | date = June 10 2008 | accessdate = 2008-06-10]

Linux

Porting ZFS to Linux is complicated by the fact that the GNU General Public License, which governs the Linux kernel, prohibits linking with code under certain licenses, such as CDDL, the license ZFS is released under. cite web |url = http://kerneltrap.org/node/8066 | title = Linux: ZFS, Licenses and Patents | author = Jeremy Andrews | accessdate = 2007-04-21 | date = April 19 2007 ] One solution to this problem is to port ZFS to Linux's FUSE system so the filesystem runs in userspace instead. A project to do this was sponsored by Google's Summer of Code program in 2006, and is in Beta stage as of March 2008. cite web |url = http://zfs-on-fuse.blogspot.com/ | title = ZFS on FUSE/Linux | author = Ricardo Correia | accessdate = 2006-07-15 | date = May 26 2006 ] The [http://www.wizy.org/wiki/ZFS_on_FUSE ZFS on FUSE project is available here.] Running a file system outside the kernel on traditional Unix-like systems can have a significant performance impact. However, NTFS-3G (another file system driver built on FUSE) performs well when compared to other traditional file system drivers. cite web |url = http://ntfs-3g.org/performance.html | title = NTFS-3G Read/Write Driver Performance | author = Szabolcs Szakacsits | accessdate = 2008-01-20 | date = November 28 2007 ] This shows that reasonable performance is possible with ZFS on Linux after proper optimization.Sun Microsystems has stated that a Linux port is being investigated. cite web | url = http://www.sun.com/emrkt/campaign_docs/expertexchange/knowledge/solaris_zfs_gen.html#10 | title = Fast Track to Solaris 10 Adoption: ZFS Technology | work = Solaris 10 Technical Knowledge Base | publisher = Sun Microsystems | accessdate = 2006-04-24 ]

See also

* List of file systems
* Comparison of file systems
* Veritas File System and Veritas Volume Manager — ZFS's main (cross-platform) competitor
* Write Anywhere File Layout — a similar file system by NetApp
* NILFS — a Linux filesystem by Nippon Telegraph and Telephone (NTT) supporting snapshots
* LZJB — data compression algorithm used in ZFS
* Versioning file systems - List of versioning file systems

References

External links

* [http://www.opensolaris.org/os/community/zfs/ ZFS Development Community and detailed ZFS Documentation]
* [http://www.solarisinternals.com/wiki/index.php/ZFS_Best_Practices_Guide ZFS Best Practices Guide]
* [http://www.opensolaris.org/os/community/zfs/docs/zfs_last.pdf ZFS The Last word in File Systems]
* [http://www.opensolaris.org/os/community/zfs/boot/ ZFS Boot Project]
* [http://www.opensolaris.org/os/project/zfs-crypto ZFS Encryption Project]
* [http://www.sun.com/software/media/real/zfs_learningcenter/high_bandwidth.html Sun's ZFS Learning Center Presentations on ZFS by Bill Moore]