Skip site navigation (1)Skip section navigation (2)

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
ZFS(8)			FreeBSD	System Manager's Manual			ZFS(8)

NAME
     zfs -- configures ZFS file	systems

SYNOPSIS
     zfs [-?]
     zfs create	[-p] [-o property=value]... filesystem
     zfs create	[-ps] [-b blocksize] [-o property=value]... -V size volume
     zfs destroy [-fnpRrv] filesystem|volume
     zfs destroy [-dnpRrv] snapshot[%snapname][,...]
     zfs snapshot [-r] [-o property=value]...
	 filesystem@snapname|volume@snapname
	 filesystem@snapname|volume@snapname...
     zfs rollback [-rRf] snapshot
     zfs clone [-p] [-o	property=value]... snapshot filesystem|volume
     zfs promote clone-filesystem
     zfs rename	[-f] filesystem|volume|snapshot	filesystem|volume|snapshot
     zfs rename	[-f] -p	filesystem|volume filesystem|volume
     zfs rename	-r snapshot snapshot
     zfs rename	-u [-p]	filesystem filesystem
     zfs list [-r|-d depth] [-H] [-o property[,property]...]
	 [-t type[,type]...] [-s property]... [-S property]...
	 filesystem|volume|snapshot
     zfs set property=value filesystem|volume|snapshot...
     zfs get [-r|-d depth] [-Hp] [-o all | field[,field]...]
	 [-t type[, type]...] [-s source[,source]...] all |
	 property[,property]...	filesystem|volume|snapshot...
     zfs inherit [-rS] property	filesystem|volume|snapshot...
     zfs upgrade [-v]
     zfs upgrade [-r] [-V version] -a |	filesystem
     zfs userspace [-Hinp] [-o field[,field]...] [-s field]... [-S field]...
	 [-t type[,type]...] filesystem|snapshot
     zfs groupspace [-Hinp] [-o	field[,field]...] [-s field]...	[-S field]...
	 [-t type[,type]...] filesystem|snapshot
     zfs mount
     zfs mount [-vO] [-o property[,property]...] -a | filesystem
     zfs unmount [-f] -a | filesystem|mountpoint
     zfs share -a | filesystem
     zfs unshare -a | filesystem|mountpoint
     zfs send [-DnPpRv]	[-i snapshot | -I snapshot] snapshot
     zfs receive [-vnFu] filesystem|volume|snapshot
     zfs receive [-vnFu] [-d | -e] filesystem
     zfs allow filesystem|volume
     zfs allow [-ldug] user|group[,user|group]...
	 perm|@setname[,perm|@setname]... filesystem|volume
     zfs allow [-ld] -e|everyone perm|@setname[,perm|@setname]...
	 filesystem|volume
     zfs allow -c perm|@setname[,perm|@setname]... filesystem|volume
     zfs allow -s @setname perm|@setname[,perm|@setname]... filesystem|volume
     zfs unallow [-rldug] user|group[,user|group]...
	 [perm|@setname[,perm|@setname]...] filesystem|volume
     zfs unallow [-rld]	-e|everyone [perm|@setname[,perm|@setname]...]
	 filesystem|volume
     zfs unallow [-r] -c [perm|@setname[,perm|@setname]...] filesystem|volume
     zfs unallow [-r] -s @setname [perm|@setname[,perm|@setname]...]
	 filesystem|volume
     zfs hold [-r] tag snapshot...
     zfs holds [-r] snapshot...
     zfs release [-r] tag snapshot...
     zfs diff [-FHt] snapshot [snapshot|filesystem]
     zfs jail jailid|jailname filesystem
     zfs unjail	jailid|jailname	filesystem

DESCRIPTION
     The zfs command configures	ZFS datasets within a ZFS storage pool,	as
     described in zpool(8).  A dataset is identified by	a unique path within
     the ZFS namespace.	For example:

	 pool/{filesystem,volume,snapshot}

     where the maximum length of a dataset name	is MAXNAMELEN (256 bytes).

     A dataset can be one of the following:

     file system   A ZFS dataset of type filesystem can	be mounted within the
		   standard system namespace and behaves like other file sys-
		   tems. While ZFS file	systems	are designed to	be POSIX com-
		   pliant, known issues	exist that prevent compliance in some
		   cases.  Applications	that depend on standards conformance
		   might fail due to nonstandard behavior when checking	file
		   system free space.

     volume	   A logical volume exported as	a raw or block device. This
		   type	of dataset should only be used under special circum-
		   stances. File systems are typically used in most environ-
		   ments.

     snapshot	   A read-only version of a file system	or volume at a given
		   point in time. It is	specified as filesystem@name or
		   volume@name.

   ZFS File System Hierarchy
     A ZFS storage pool	is a logical collection	of devices that	provide	space
     for datasets. A storage pool is also the root of the ZFS file system
     hierarchy.

     The root of the pool can be accessed as a file system, such as mounting
     and unmounting, taking snapshots, and setting properties. The physical
     storage characteristics, however, are managed by the zpool(8) command.

     See zpool(8) for more information on creating and administering pools.

   Snapshots
     A snapshot	is a read-only copy of a file system or	volume.	Snapshots can
     be	created	extremely quickly, and initially consume no additional space
     within the	pool. As data within the active	dataset	changes, the snapshot
     consumes more data	than would otherwise be	shared with the	active
     dataset.

     Snapshots can have	arbitrary names. Snapshots of volumes can be cloned or
     rolled back, but cannot be	accessed independently.

     File system snapshots can be accessed under the .zfs/snapshot directory
     in	the root of the	file system. Snapshots are automatically mounted on
     demand and	may be unmounted at regular intervals. The visibility of the
     .zfs directory can	be controlled by the snapdir property.

   Clones
     A clone is	a writable volume or file system whose initial contents	are
     the same as another dataset. As with snapshots, creating a	clone is
     nearly instantaneous, and initially consumes no additional	space.

     Clones can	only be	created	from a snapshot. When a	snapshot is cloned, it
     creates an	implicit dependency between the	parent and child. Even though
     the clone is created somewhere else in the	dataset	hierarchy, the origi-
     nal snapshot cannot be destroyed as long as a clone exists. The origin
     property exposes this dependency, and the destroy command lists any such
     dependencies, if they exist.

     The clone parent-child dependency relationship can	be reversed by using
     the promote subcommand. This causes the "origin" file system to become a
     clone of the specified file system, which makes it	possible to destroy
     the file system that the clone was	created	from.

   Mount Points
     Creating a	ZFS file system	is a simple operation, so the number of	file
     systems per system	is likely to be	numerous. To cope with this, ZFS auto-
     matically manages mounting	and unmounting file systems without the	need
     to	edit the /etc/fstab file. All automatically managed file systems are
     mounted by	ZFS at boot time.

     By	default, file systems are mounted under	/path, where path is the name
     of	the file system	in the ZFS namespace. Directories are created and
     destroyed as needed.

     A file system can also have a mount point set in the mountpoint property.
     This directory is created as needed, and ZFS automatically	mounts the
     file system when the "zfs mount -a" command is invoked (without editing
     /etc/fstab).  The mountpoint property can be inherited, so	if pool/home
     has a mount point of /home, then pool/home/user automatically inherits a
     mount point of /home/user.

     A file system mountpoint property of none prevents	the file system	from
     being mounted.

     If	needed,	ZFS file systems can also be managed with traditional tools
     (mount(8),	umount(8), fstab(5)).  If a file system's mount	point is set
     to	legacy,	ZFS makes no attempt to	manage the file	system,	and the	admin-
     istrator is responsible for mounting and unmounting the file system.

   Jails
     A ZFS dataset can be attached to a	jail by	using the "zfs jail" subcom-
     mand. You cannot attach a dataset to one jail and the children of the
     same dataset to another jails. To allow management	of the dataset from
     within a jail, the	jailed property	has to be set. The quota property can-
     not be changed from within	a jail.

     A ZFS dataset can be detached from	a jail using the "zfs unjail" subcom-
     mand.

     After a dataset is	attached to a jail and the jailed property is set, a
     jailed file system	cannot be mounted outside the jail, since the jail
     administrator might have set the mount point to an	unacceptable value.

   Deduplication
     Deduplication is the process for removing redundant data at the block-
     level, reducing the total amount of data stored. If a file	system has the
     dedup property enabled, duplicate data blocks are removed synchronously.
     The result	is that	only unique data is stored and common components are
     shared among files.

   Native Properties
     Properties	are divided into two types, native properties and user-defined
     (or "user") properties. Native properties either export internal statis-
     tics or control ZFS behavior. In addition,	native properties are either
     editable or read-only. User properties have no effect on ZFS behavior,
     but you can use them to annotate datasets in a way	that is	meaningful in
     your environment. For more	information about user properties, see the
     "User Properties" section,	below.

     Every dataset has a set of	properties that	export statistics about	the
     dataset as	well as	control	various	behaviors. Properties are inherited
     from the parent unless overridden by the child. Some properties apply
     only to certain types of datasets (file systems, volumes, or snapshots).

     The values	of numeric properties can be specified using human-readable
     suffixes (for example, k, KB, M, Gb, and so forth,	up to Z	for
     zettabyte). The following are all valid (and equal) specifications:

	 1536M,	1.5g, 1.50GB

     The values	of non-numeric properties are case sensitive and must be low-
     ercase, except for	mountpoint, sharenfs, and sharesmb.

     The following native properties consist of	read-only statistics about the
     dataset. These properties can be neither set, nor inherited. Native prop-
     erties apply to all dataset types unless otherwise	noted.

     available
	 The amount of space available to the dataset and all its children,
	 assuming that there is	no other activity in the pool. Because space
	 is shared within a pool, availability can be limited by any number of
	 factors, including physical pool size,	quotas,	reservations, or other
	 datasets within the pool.

	 This property can also	be referred to by its shortened	column name,
	 avail.

     compressratio
	 For non-snapshots, the	compression ratio achieved for the used	space
	 of this dataset, expressed as a multiplier.  The used property
	 includes descendant datasets, and, for	clones,	does not include the
	 space shared with the origin snapshot.	 For snapshots,	the
	 compressratio is the same as the refcompressratio property. Compres-
	 sion can be turned on by running: "zfs	set compression=on dataset"
	 The default value is off.

     creation
	 The time this dataset was created.

     clones
	 For snapshots,	this property is a comma-separated list	of filesystems
	 or volumes which are clones of	this snapshot.	The clones' origin
	 property is this snapshot.  If	the clones property is not empty, then
	 this snapshot can not be destroyed (even with the -r or -f options).

     defer_destroy
	 This property is on if	the snapshot has been marked for deferred
	 destroy by using the "zfs destroy -d" command.	Otherwise, the prop-
	 erty is off.

     logicalreferenced
	 The amount of space that is "logically" accessible by this dataset.
	 See the referenced property.  The logical space ignores the effect of
	 the compression and copies properties,	giving a quantity closer to
	 the amount of data that applications see.  However, it	does include
	 space consumed	by metadata.

	 This property can also	be referred to by its shortened	column name,
	 lrefer.

     logicalused
	 The amount of space that is "logically" consumed by this dataset and
	 all its descendents.  See the used property.  The logical space
	 ignores the effect of the compression and copies properties, giving a
	 quantity closer to the	amount of data that applications see.

	 This property can also	be referred to by its shortened	column name,
	 lused.

     mounted
	 For file systems, indicates whether the file system is	currently
	 mounted. This property	can be either yes or no.

     origin
	 For cloned file systems or volumes, the snapshot from which the clone
	 was created. See also the clones property.

     referenced
	 The amount of data that is accessible by this dataset,	which may or
	 may not be shared with	other datasets in the pool. When a snapshot or
	 clone is created, it initially	references the same amount of space as
	 the file system or snapshot it	was created from, since	its contents
	 are identical.

	 This property can also	be referred to by its shortened	column name,
	 refer.

     refcompressratio
	 The compression ratio achieved	for the	referenced space of this
	 dataset, expressed as a multiplier.  See also the compressratio prop-
	 erty.

     type
	 The type of dataset: filesystem, volume, or snapshot.

     used
	 The amount of space consumed by this dataset and all its descendents.
	 This is the value that	is checked against this	dataset's quota	and
	 reservation. The space	used does not include this dataset's reserva-
	 tion, but does	take into account the reservations of any descendent
	 datasets. The amount of space that a dataset consumes from its	par-
	 ent, as well as the amount of space that are freed if this dataset is
	 recursively destroyed,	is the greater of its space used and its
	 reservation.

	 When snapshots	(see the "Snapshots" section) are created, their space
	 is initially shared between the snapshot and the file system, and
	 possibly with previous	snapshots. As the file system changes, space
	 that was previously shared becomes unique to the snapshot, and
	 counted in the	snapshot's space used. Additionally, deleting snap-
	 shots can increase the	amount of space	unique to (and used by)	other
	 snapshots.

	 The amount of space used, available, or referenced does not take into
	 account pending changes. Pending changes are generally	accounted for
	 within	a few seconds. Committing a change to a	disk using fsync(2) or
	 O_SYNC	does not necessarily guarantee that the	space usage informa-
	 tion is updated immediately.

     usedby*
	 The usedby* properties	decompose the used properties into the various
	 reasons that space is used. Specifically, used	= usedbysnapshots +
	 usedbydataset + usedbychildren	+ usedbyrefreservation.	 These proper-
	 ties are only available for datasets created with ZFS pool version 13
	 pools and higher.

     usedbysnapshots
	 The amount of space consumed by snapshots of this dataset. In partic-
	 ular, it is the amount	of space that would be freed if	all of this
	 dataset's snapshots were destroyed. Note that this is not simply the
	 sum of	the snapshots' used properties because space can be shared by
	 multiple snapshots.

     usedbydataset
	 The amount of space used by this dataset itself, which	would be freed
	 if the	dataset	were destroyed (after first removing any
	 refreservation	and destroying any necessary snapshots or descen-
	 dents).

     usedbychildren
	 The amount of space used by children of this dataset, which would be
	 freed if all the dataset's children were destroyed.

     usedbyrefreservation
	 The amount of space used by a refreservation set on this dataset,
	 which would be	freed if the refreservation was	removed.

     userused@user
	 The amount of space consumed by the specified user in this dataset.
	 Space is charged to the owner of each file, as	displayed by "ls -l".
	 The amount of space charged is	displayed by "du" and "ls -s".	See
	 the "zfs userspace" subcommand	for more information.

	 Unprivileged users can	access only their own space usage. The root
	 user, or a user who has been granted the userused privilege with "zfs
	 allow", can access everyone's usage.

	 The userused@... properties are not displayed by "zfs get all".  The
	 user's	name must be appended after the	@ symbol, using	one of the
	 following forms:

	   +o   POSIX name (for example,	joe)

	   +o   POSIX numeric ID	(for example, 1001)

     userrefs
	 This property is set to the number of user holds on this snapshot.
	 User holds are	set by using the "zfs hold" command.

     groupused@group
	 The amount of space consumed by the specified group in	this dataset.
	 Space is charged to the group of each file, as	displayed by ls	-l.
	 See the userused@user property	for more information.

	 Unprivileged users can	only access their own groups' space usage. The
	 root user, or a user who has been granted the groupused privilege
	 with "zfs allow", can access all groups' usage.

     volblocksize=blocksize
	 For volumes, specifies	the block size of the volume. The blocksize
	 cannot	be changed once	the volume has been written, so	it should be
	 set at	volume creation	time. The default blocksize for	volumes	is 8
	 Kbytes. Any power of 2	from 512 bytes to 128 Kbytes is	valid.

	 This property can also	be referred to by its shortened	column name,
	 volblock.

     written
	 The amount of referenced space	written	to this	dataset	since the pre-
	 vious snapshot.

     written@snapshot
	 The amount of referenced space	written	to this	dataset	since the
	 specified snapshot.  This is the space	that is	referenced by this
	 dataset but was not referenced	by the specified snapshot.

	 The snapshot may be specified as a short snapshot name	(just the part
	 after the @), in which	case it	will be	interpreted as a snapshot in
	 the same filesystem as	this dataset. The snapshot may be a full snap-
	 shot name (filesystem@snapshot), which	for clones may be a snapshot
	 in the	origin's filesystem (or	the origin of the origin's filesystem,
	 etc).

     The following native properties can be used to change the behavior	of a
     ZFS dataset.

     aclinherit=discard	| noallow | restricted | passthrough | passthrough-x
	 Controls how ACL entries are inherited	when files and directories are
	 created. A file system	with an	aclinherit property of discard does
	 not inherit any ACL entries. A	file system with an aclinherit prop-
	 erty value of noallow only inherits inheritable ACL entries that
	 specify "deny"	permissions. The property value	restricted (the
	 default) removes the write_acl	and write_owner	permissions when the
	 ACL entry is inherited. A file	system with an aclinherit property
	 value of passthrough inherits all inheritable ACL entries without any
	 modifications made to the ACL entries when they are inherited.	A file
	 system	with an	aclinherit property value of passthrough-x has the
	 same meaning as passthrough, except that the owner@, group@, and
	 everyone@ ACEs	inherit	the execute permission only if the file	cre-
	 ation mode also requests the execute bit.

	 When the property value is set	to passthrough,	files are created with
	 a mode	determined by the inheritable ACEs. If no inheritable ACEs
	 exist that affect the mode, then the mode is set in accordance	to the
	 requested mode	from the application.

     aclmode=discard | groupmask | passthrough | restricted
	 Controls how an ACL is	modified during	chmod(2).  A file system with
	 an aclmode property of	discard	(the default) deletes all ACL entries
	 that do not represent the mode	of the file. An	aclmode	property of
	 groupmask reduces permissions granted in all ALLOW entries found in
	 the ACL such that they	are no greater than the	group permissions
	 specified by chmod(2).	 A file	system with an aclmode property	of
	 passthrough indicates that no changes are made	to the ACL other than
	 creating or updating the necessary ACL	entries	to represent the new
	 mode of the file or directory.	 An aclmode property of	restricted
	 will cause the	chmod(2) operation to return an	error when used	on any
	 file or directory which has a non-trivial ACL whose entries can not
	 be represented	by a mode.  chmod(2) is	required to change the set
	 user ID, set group ID,	or sticky bits on a file or directory, as they
	 do not	have equivalent	ACL entries.  In order to use chmod(2) on a
	 file or directory with	a non-trivial ACL when aclmode is set to
	 restricted, you must first remove all ACL entries which do not	repre-
	 sent the current mode.

     atime=on |	off
	 Controls whether the access time for files is updated when they are
	 read.	Turning	this property off avoids producing write traffic when
	 reading files and can result in significant performance gains,	though
	 it might confuse mailers and other similar utilities. The default
	 value is on.

     canmount=on | off | noauto
	 If this property is set to off, the file system cannot	be mounted,
	 and is	ignored	by "zfs	mount -a".  Setting this property to off is
	 similar to setting the	mountpoint property to none, except that the
	 dataset still has a normal mountpoint property, which can be inher-
	 ited. Setting this property to	off allows datasets to be used solely
	 as a mechanism	to inherit properties. One example of setting
	 canmount=off is to have two datasets with the same mountpoint,	so
	 that the children of both datasets appear in the same directory, but
	 might have different inherited	characteristics.

	 When the noauto value is set, a dataset can only be mounted and
	 unmounted explicitly. The dataset is not mounted automatically	when
	 the dataset is	created	or imported, nor is it mounted by the "zfs
	 mount -a" command or unmounted	by the "zfs umount -a" command.

	 This property is not inherited.

     checksum=on | off | fletcher2 | fletcher4 | sha256
	 Controls the checksum used to verify data integrity. The default
	 value is on, which automatically selects an appropriate algorithm
	 (currently, fletcher4,	but this may change in future releases). The
	 value off disables integrity checking on user data. Disabling check-
	 sums is NOT a recommended practice.

     compression=on | off | lzjb | gzip	| gzip-N | zle | lz4
	 Controls the compression algorithm used for this dataset. The com-
	 pression algorithm is optimized for performance while providing
	 decent	data compression. Setting compression to on uses the lzjb com-
	 pression algorithm. The gzip compression algorithm uses the same com-
	 pression as the gzip(1) command. You can specify the gzip level by
	 using the value gzip-N	where N	is an integer from 1 (fastest) to 9
	 (best compression ratio). Currently, gzip is equivalent to gzip-6
	 (which	is also	the default for	gzip(1)).  The zle compression algo-
	 rithm compresses runs of zeros.

	 The lz4 compression algorithm is a high-performance replacement for
	 the lzjb algorithm. It	features significantly faster compression and
	 decompression,	as well	as a moderately	higher compression ratio than
	 lzjb, but can only be used on pools with the lz4_compress feature set
	 to enabled.  See zpool-features(7) for	details	on ZFS feature flags
	 and the lz4_compress feature.

	 This property can also	be referred to by its shortened	column name
	 compress.  Changing this property affects only	newly-written data.

     copies=1 |	2 | 3
	 Controls the number of	copies of data stored for this dataset.	These
	 copies	are in addition	to any redundancy provided by the pool,	for
	 example, mirroring or RAID-Z. The copies are stored on	different
	 disks,	if possible. The space used by multiple	copies is charged to
	 the associated	file and dataset, changing the used property and
	 counting against quotas and reservations.

	 Changing this property	only affects newly-written data. Therefore,
	 set this property at file system creation time	by using the -o
	 copies=N option.

     dedup=on |	off | verify | sha256[,verify]
	 Configures deduplication for a	dataset. The default value is off.
	 The default deduplication checksum is sha256 (this may	change in the
	 future).  When	dedup is enabled, the checksum defined here overrides
	 the checksum property.	Setting	the value to verify has	the same
	 effect	as the setting sha256,verify.

	 If set	to verify, ZFS will do a byte-to-byte comparsion in case of
	 two blocks having the same signature to make sure the block contents
	 are identical.

     devices=on	| off
	 The devices property is currently not supported on FreeBSD.

     exec=on | off
	 Controls whether processes can	be executed from within	this file sys-
	 tem. The default value	is on.

     mlslabel=label | none
	 The mlslabel property is currently not	supported on FreeBSD.

     mountpoint=path | none | legacy
	 Controls the mount point used for this	file system. See the "Mount
	 Points" section for more information on how this property is used.

	 When the mountpoint property is changed for a file system, the	file
	 system	and any	children that inherit the mount	point are unmounted.
	 If the	new value is legacy, then they remain unmounted. Otherwise,
	 they are automatically	remounted in the new location if the property
	 was previously	legacy or none,	or if they were	mounted	before the
	 property was changed. In addition, any	shared file systems are
	 unshared and shared in	the new	location.

     nbmand=on | off
	 The nbmand property is	currently not supported	on FreeBSD.

     primarycache=all |	none | metadata
	 Controls what is cached in the	primary	cache (ARC). If	this property
	 is set	to all,	then both user data and	metadata is cached. If this
	 property is set to none, then neither user data nor metadata is
	 cached. If this property is set to metadata, then only	metadata is
	 cached. The default value is all.

     quota=size	| none
	 Limits	the amount of space a dataset and its descendents can consume.
	 This property enforces	a hard limit on	the amount of space used. This
	 includes all space consumed by	descendents, including file systems
	 and snapshots.	Setting	a quota	on a descendent	of a dataset that
	 already has a quota does not override the ancestor's quota, but
	 rather	imposes	an additional limit.

	 Quotas	cannot be set on volumes, as the volsize property acts as an
	 implicit quota.

     userquota@user=size | none
	 Limits	the amount of space consumed by	the specified user.  Similar
	 to the	refquota property, the userquota space calculation does	not
	 include space that is used by descendent datasets, such as snapshots
	 and clones. User space	consumption is identified by the
	 userspace@user	property.

	 Enforcement of	user quotas may	be delayed by several seconds. This
	 delay means that a user might exceed their quota before the system
	 notices that they are over quota and begins to	refuse additional
	 writes	with the EDQUOT	error message. See the userspace subcommand
	 for more information.

	 Unprivileged users can	only access their own groups' space usage. The
	 root user, or a user who has been granted the userquota privilege
	 with "zfs allow", can get and set everyone's quota.

	 This property is not available	on volumes, on file systems before
	 version 4, or on pools	before version 15. The userquota@... proper-
	 ties are not displayed	by "zfs	get all".  The user's name must	be
	 appended after	the @ symbol, using one	of the following forms:

	   +o   POSIX name (for example,	joe)

	   +o   POSIX numeric ID	(for example, 1001)

     groupquota@group=size | none
	 Limits	the amount of space consumed by	the specified group. Group
	 space consumption is identified by the	userquota@user property.

	 Unprivileged users can	access only their own groups' space usage. The
	 root user, or a user who has been granted the groupquota privilege
	 with "zfs allow", can get and set all groups' quotas.

     readonly=on | off
	 Controls whether this dataset can be modified.	The default value is
	 off.

     recordsize=size
	 Specifies a suggested block size for files in the file	system.	This
	 property is designed solely for use with database workloads that
	 access	files in fixed-size records.  ZFS automatically	tunes block
	 sizes according to internal algorithms	optimized for typical access
	 patterns.

	 For databases that create very	large files but	access them in small
	 random	chunks,	these algorithms may be	suboptimal. Specifying a
	 recordsize greater than or equal to the record	size of	the database
	 can result in significant performance gains. Use of this property for
	 general purpose file systems is strongly discouraged, and may
	 adversely affect performance.

	 The size specified must be a power of two greater than	or equal to
	 512 and less than or equal to 128 Kbytes.

	 Changing the file system's recordsize affects only files created
	 afterward; existing files are unaffected.

	 This property can also	be referred to by its shortened	column name,
	 recsize.

     refquota=size | none
	 Limits	the amount of space a dataset can consume. This	property
	 enforces a hard limit on the amount of	space used. This hard limit
	 does not include space	used by	descendents, including file systems
	 and snapshots.

     refreservation=size | none
	 The minimum amount of space guaranteed	to a dataset, not including
	 its descendents. When the amount of space used	is below this value,
	 the dataset is	treated	as if it were taking up	the amount of space
	 specified by refreservation.  The refreservation reservation is
	 accounted for in the parent datasets' space used, and counts against
	 the parent datasets' quotas and reservations.

	 If refreservation is set, a snapshot is only allowed if there is
	 enough	free pool space	outside	of this	reservation to accommodate the
	 current number	of "referenced"	bytes in the dataset.

	 This property can also	be referred to by its shortened	column name,
	 refreserv.

     reservation=size |	none
	 The minimum amount of space guaranteed	to a dataset and its descen-
	 dents.	When the amount	of space used is below this value, the dataset
	 is treated as if it were taking up the	amount of space	specified by
	 its reservation. Reservations are accounted for in the	parent
	 datasets' space used, and count against the parent datasets' quotas
	 and reservations.

	 This property can also	be referred to by its shortened	column name,
	 reserv.

     secondarycache=all	| none | metadata
	 Controls what is cached in the	secondary cache	(L2ARC). If this prop-
	 erty is set to	all, then both user data and metadata is cached. If
	 this property is set to none, then neither user data nor metadata is
	 cached. If this property is set to metadata, then only	metadata is
	 cached. The default value is all.

     setuid=on | off
	 Controls whether the set-UID bit is respected for the file system.
	 The default value is on.

     sharesmb=on | off | opts
	 The sharesmb property currently has no	effect on FreeBSD.

     sharenfs=on | off | opts
	 Controls whether the file system is shared via	NFS, and what options
	 are used. A file system with a	sharenfs property of off is managed
	 the traditional way via exports(5).  Otherwise, the file system is
	 automatically shared and unshared with	the "zfs share"	and "zfs
	 unshare" commands. If the property is set to on no NFS	export options
	 are used. Otherwise, NFS export options are equivalent	to the con-
	 tents of this property. The export options may	be comma-separated.
	 See exports(5)	for a list of valid options.

	 When the sharenfs property is changed for a dataset, the mountd(8)
	 daemon	is reloaded.

     logbias=latency | throughput
	 Provide a hint	to ZFS about handling of synchronous requests in this
	 dataset.  If logbias is set to	latency	(the default), ZFS will	use
	 pool log devices (if configured) to handle the	requests at low
	 latency. If logbias is	set to throughput, ZFS will not	use configured
	 pool log devices.  ZFS	will instead optimize synchronous operations
	 for global pool throughput and	efficient use of resources.

     snapdir=hidden | visible
	 Controls whether the .zfs directory is	hidden or visible in the root
	 of the	file system as discussed in the	"Snapshots" section. The
	 default value is hidden.

     sync=standard | always | disabled
	 Controls the behavior of synchronous requests (e.g.  fsync(2),
	 O_DSYNC). This	property accepts the following values:

	     standard  This is the POSIX specified behavior of ensuring	all
		       synchronous requests are	written	to stable storage and
		       all devices are flushed to ensure data is not cached by
		       device controllers (this	is the default).

	     always    All file	system transactions are	written	and flushed
		       before their system calls return. This has a large per-
		       formance	penalty.

	     disabled  Disables	synchronous requests. File system transactions
		       are only	committed to stable storage periodically. This
		       option will give	the highest performance.  However, it
		       is very dangerous as ZFS	would be ignoring the synchro-
		       nous transaction	demands	of applications	such as	data-
		       bases or	NFS.  Administrators should only use this
		       option when the risks are understood.

     volsize=size
	 For volumes, specifies	the logical size of the	volume.	By default,
	 creating a volume establishes a reservation of	equal size. For	stor-
	 age pools with	a version number of 9 or higher, a refreservation is
	 set instead. Any changes to volsize are reflected in an equivalent
	 change	to the reservation (or refreservation).	 The volsize can only
	 be set	to a multiple of volblocksize, and cannot be zero.

	 The reservation is kept equal to the volume's logical size to prevent
	 unexpected behavior for consumers. Without the	reservation, the vol-
	 ume could run out of space, resulting in undefined behavior or	data
	 corruption, depending on how the volume is used. These	effects	can
	 also occur when the volume size is changed while it is	in use (par-
	 ticularly when	shrinking the size). Extreme care should be used when
	 adjusting the volume size.

	 Though	not recommended, a "sparse volume" (also known as "thin	provi-
	 sioning") can be created by specifying	the -s option to the "zfs
	 create	-V" command, or	by changing the	reservation after the volume
	 has been created. A "sparse volume" is	a volume where the reservation
	 is less then the volume size.	Consequently, writes to	a sparse vol-
	 ume can fail with ENOSPC when the pool	is low on space. For a sparse
	 volume, changes to volsize are	not reflected in the reservation.

     vscan=off | on
	 The vscan property is currently not supported on FreeBSD.

     xattr=off | on
	 The xattr property is currently not supported on FreeBSD.

     jailed=off	| on
	 Controls whether the dataset is managed from a	jail. See the "Jails"
	 section for more information. The default value is off.

     The following three properties cannot be changed after the	file system is
     created, and therefore, should be set when	the file system	is created. If
     the properties are	not set	with the "zfs create" or zpool create com-
     mands, these properties are inherited from	the parent dataset. If the
     parent dataset lacks these	properties due to having been created prior to
     these features being supported, the new file system will have the default
     values for	these properties.

     casesensitivity=sensitive | insensitive | mixed
	   The casesensitivity property	is currently not supported on FreeBSD.

     normalization=none	| formC	| formD	| formKC | formKD
	   Indicates whether the file system should perform a unicode normal-
	   ization of file names whenever two file names are compared, and
	   which normalization algorithm should	be used. File names are	always
	   stored unmodified, names are	normalized as part of any comparison
	   process. If this property is	set to a legal value other than	none,
	   and the utf8only property was left unspecified, the utf8only	prop-
	   erty	is automatically set to	on.  The default value of the
	   normalization property is none.  This property cannot be changed
	   after the file system is created.

     utf8only=on | off
	   Indicates whether the file system should reject file	names that
	   include characters that are not present in the UTF-8	character code
	   set.	If this	property is explicitly set to off, the normalization
	   property must either	not be explicitly set or be set	to none.  The
	   default value for the utf8only property is off.  This property can-
	   not be changed after	the file system	is created.

     The casesensitivity, normalization, and utf8only properties are also new
     permissions that can be assigned to non-privileged	users by using the ZFS
     delegated administration feature.

   Temporary Mount Point Properties
     When a file system	is mounted, either through mount(8) for	legacy mounts
     or	the "zfs mount"	command	for normal file	systems, its mount options are
     set according to its properties. The correlation between properties and
     mount options is as follows:

	 PROPERTY    MOUNT OPTION
	 atime	     atime/noatime
	 exec	     exec/noexec
	 readonly    ro/rw
	 setuid	     suid/nosuid

     In	addition, these	options	can be set on a	per-mount basis	using the -o
     option, without affecting the property that is stored on disk. The	values
     specified on the command line override the	values stored in the dataset.
     These properties are reported as "temporary" by the "zfs get" command. If
     the properties are	changed	while the dataset is mounted, the new setting
     overrides any temporary settings.

   User	Properties
     In	addition to the	standard native	properties, ZFS	supports arbitrary
     user properties. User properties have no effect on	ZFS behavior, but
     applications or administrators can	use them to annotate datasets (file
     systems, volumes, and snapshots).

     User property names must contain a	colon (:) character to distinguish
     them from native properties. They may contain lowercase letters, numbers,
     and the following punctuation characters: colon (:), dash (-), period (.)
     and underscore (_).  The expected convention is that the property name is
     divided into two portions such as module:property,	but this namespace is
     not enforced by ZFS.  User	property names can be at most 256 characters,
     and cannot	begin with a dash (-).

     When making programmatic use of user properties, it is strongly suggested
     to	use a reversed DNS domain name for the module component	of property
     names to reduce the chance	that two independently-developed packages use
     the same property name for	different purposes. Property names beginning
     with com.sun are reserved for use by Sun Microsystems.

     The values	of user	properties are arbitrary strings, are always inher-
     ited, and are never validated. All	of the commands	that operate on	prop-
     erties ("zfs list", "zfs get", "zfs set" and so forth) can	be used	to
     manipulate	both native properties and user	properties. Use	the "zfs
     inherit" command to clear a user property.	If the property	is not defined
     in	any parent dataset, it is removed entirely. Property values are	lim-
     ited to 1024 characters.

SUBCOMMANDS
     All subcommands that modify state are logged persistently to the pool in
     their original form.

     zfs [-?]

	 Displays a help message.

     zfs create	[-p] [-o property=value]... filesystem

	 Creates a new ZFS file	system.	The file system	is automatically
	 mounted according to the mountpoint property inherited	from the par-
	 ent.

	 -p	 Creates all the non-existing parent datasets. Datasets	cre-
		 ated in this manner are automatically mounted according to
		 the mountpoint	property inherited from	their parent. Any
		 property specified on the command line	using the -o option is
		 ignored. If the target	filesystem already exists, the opera-
		 tion completes	successfully.

	 -o property=value
		 Sets the specified property as	if the command "zfs set
		 property=value" was invoked at	the same time the dataset was
		 created. Any editable ZFS property can	also be	set at cre-
		 ation time. Multiple -o options can be	specified. An error
		 results if the	same property is specified in multiple -o
		 options.

     zfs create	[-ps] [-b blocksize] [-o property=value]... -V size volume

	 Creates a volume of the given size. The volume	is exported as a block
	 device	in /dev/zvol/path, where path is the name of the volume	in the
	 ZFS namespace.	The size represents the	logical	size as	exported by
	 the device. By	default, a reservation of equal	size is	created.

	 size is automatically rounded up to the nearest 128 Kbytes to ensure
	 that the volume has an	integral number	of blocks regardless of
	 blocksize.

	 -p	 Creates all the non-existing parent datasets. Datasets	cre-
		 ated in this manner are automatically mounted according to
		 the mountpoint	property inherited from	their parent. Any
		 property specified on the command line	using the -o option is
		 ignored. If the target	filesystem already exists, the opera-
		 tion completes	successfully.

	 -s	 Creates a sparse volume with no reservation. See volsize in
		 the "Native Properties" section for more information about
		 sparse	volumes.

	 -b blocksize
		 Equivalent to -o volblocksize=blocksize.  If this option is
		 specified in conjunction with -o volblocksize,	the resulting
		 behavior is undefined.

	 -o property=value
		 Sets the specified property as	if the "zfs set
		 property=value" command was invoked at	the same time the
		 dataset was created. Any editable ZFS property	can also be
		 set at	creation time. Multiple	-o options can be specified.
		 An error results if the same property is specified in multi-
		 ple -o	options.

     zfs destroy [-fnpRrv] filesystem|volume

	 Destroys the given dataset. By	default, the command unshares any file
	 systems that are currently shared, unmounts any file systems that are
	 currently mounted, and	refuses	to destroy a dataset that has active
	 dependents (children or clones).

	 -r	 Recursively destroy all children.

	 -R	 Recursively destroy all dependents, including cloned file
		 systems outside the target hierarchy.

	 -f	 Force an unmount of any file systems using the	"zfs unmount
		 -f" command. This option has no effect	on non-file systems or
		 unmounted file	systems.

	 -n	 Do a dry-run ("No-op")	deletion. No data will be deleted.
		 This is useful	in conjunction with the	-v or -p flags to
		 determine what	data would be deleted.

	 -p	 Print machine-parsable	verbose	information about the deleted
		 data.

	 -v	 Print verbose information about the deleted data.

	 Extreme care should be	taken when applying either the -r or the -R
	 options, as they can destroy large portions of	a pool and cause unex-
	 pected	behavior for mounted file systems in use.

     zfs destroy [-dnpRrv] snapshot[%snapname][,...]

	 The given snapshots are destroyed immediately if and only if the "zfs
	 destroy" command without the -d option	would have destroyed it. Such
	 immediate destruction would occur, for	example, if the	snapshot had
	 no clones and the user-initiated reference count were zero.

	 If a snapshot does not	qualify	for immediate destruction, it is
	 marked	for deferred deletion. In this state, it exists	as a usable,
	 visible snapshot until	both of	the preconditions listed above are
	 met, at which point it	is destroyed.

	 An inclusive range of snapshots may be	specified by separating	the
	 first and last	snapshots with a percent sign (%).  The	first and/or
	 last snapshots	may be left blank, in which case the filesystem's old-
	 est or	newest snapshot	will be	implied.

	 Multiple snapshots (or	ranges of snapshots) of	the same filesystem or
	 volume	may be specified in a comma-separated list of snapshots.  Only
	 the snapshot's	short name (the	part after the @) should be specified
	 when using a range or comma-separated list to identify	multiple snap-
	 shots.

	 -r	 Destroy (or mark for deferred deletion) all snapshots with
		 this name in descendent file systems.

	 -R	 Recursively destroy all clones	of these snapshots, including
		 the clones, snapshots,	and children.  If this flag is speci-
		 fied, the [fl d] flag will have no effect.

	 -n	 Do a dry-run ("No-op")	deletion. No data will be deleted.
		 This is useful	in conjunction with the	-v or -p flags to
		 determine what	data would be deleted.

	 -p	 Print machine-parsable	verbose	information about the deleted
		 data.

	 -v	 Print verbose information about the deleted data.

	 -d	 Defer snapshot	deletion.

	 Extreme care should be	taken when applying either the -r or the -R
	 options, as they can destroy large portions of	a pool and cause unex-
	 pected	behavior for mounted file systems in use.

     zfs snapshot [-r] [-o property=value]...
	 filesystem@snapname|volume@snapname
	 filesystem@snapname|volume@snapname...

	 Creates snapshots with	the given names. All previous modifications by
	 successful system calls to the	file system are	part of	the snapshots.
	 Snapshots are taken atomically, so that all snapshots correspond to
	 the same moment in time. See the "Snapshots" section for details.

	 -r	 Recursively create snapshots of all descendent	datasets

	 -o property=value
		 Sets the specified property; see "zfs create" for details.

     zfs rollback [-rRf] snapshot

	 Roll back the given dataset to	a previous snapshot. When a dataset is
	 rolled	back, all data that has	changed	since the snapshot is dis-
	 carded, and the dataset reverts to the	state at the time of the snap-
	 shot. By default, the command refuses to roll back to a snapshot
	 other than the	most recent one. In order to do	so, all	intermediate
	 snapshots must	be destroyed by	specifying the -r option.

	 -r	 Recursively destroy any snapshots more	recent than the	one
		 specified.

	 -R	 Recursively destroy any more recent snapshots,	as well	as any
		 clones	of those snapshots.

	 -f	 Used with the -R option to force an unmount of	any clone file
		 systems that are to be	destroyed.

     zfs clone [-p] [-o	property=value]... snapshot filesystem|volume

	 Creates a clone of the	given snapshot.	See the	"Clones" section for
	 details. The target dataset can be located anywhere in	the ZFS	hier-
	 archy,	and is created as the same type	as the original.

	 -p	 Creates all the non-existing parent datasets. Datasets	cre-
		 ated in this manner are automatically mounted according to
		 the mountpoint	property inherited from	their parent. If the
		 target	filesystem or volume already exists, the operation
		 completes successfully.

	 -o property=value
		 Sets the specified property; see "zfs create" for details.

     zfs promote clone-filesystem

	 Promotes a clone file system to no longer be dependent	on its "ori-
	 gin" snapshot.	This makes it possible to destroy the file system that
	 the clone was created from. The clone parent-child dependency rela-
	 tionship is reversed, so that the origin file system becomes a	clone
	 of the	specified file system.

	 The snapshot that was cloned, and any snapshots previous to this
	 snapshot, are now owned by the	promoted clone.	The space they use
	 moves from the	origin file system to the promoted clone, so enough
	 space must be available to accommodate	these snapshots. No new	space
	 is consumed by	this operation,	but the	space accounting is adjusted.
	 The promoted clone must not have any conflicting snapshot names of
	 its own. The rename subcommand	can be used to rename any conflicting
	 snapshots.

     zfs rename	[-f] filesystem|volume|snapshot	filesystem|volume|snapshot

     zfs rename	[-f] -p	filesystem|volume filesystem|volume

     zfs rename	-u [-p]	filesystem filesystem

	 Renames the given dataset. The	new target can be located anywhere in
	 the ZFS hierarchy, with the exception of snapshots. Snapshots can
	 only be renamed within	the parent file	system or volume. When renam-
	 ing a snapshot, the parent file system	of the snapshot	does not need
	 to be specified as part of the	second argument. Renamed file systems
	 can inherit new mount points, in which	case they are unmounted	and
	 remounted at the new mount point.

	 -p	 Creates all the nonexistent parent datasets. Datasets created
		 in this manner	are automatically mounted according to the
		 mountpoint property inherited from their parent.

	 -u	 Do not	remount	file systems during rename. If a file system's
		 mountpoint property is	set to legacy or none, file system is
		 not unmounted even if this option is not given.

	 -f	 Force unmount any filesystems that need to be unmounted in
		 the process.  This flag has no	effect if used together	with
		 the -u	flag.

     zfs rename	-r snapshot snapshot

	 Recursively rename the	snapshots of all descendent datasets. Snap-
	 shots are the only dataset that can be	renamed	recursively.

     zfs list [-r|-d depth] [-H] [-o property[,property]...] [-t
	 type[,type]...] [-s property]... [-S property]...
	 filesystem|volume|snapshot...

	 Lists the property information	for the	given datasets in tabular
	 form. If specified, you can list property information by the absolute
	 pathname or the relative pathname. By default,	all file systems and
	 volumes are displayed.	 Snapshots are displayed if the	listsnaps
	 property is on	(the default is	off).  The following fields are	dis-
	 played, name, used, available,	referenced, mountpoint.

	 -r	 Recursively display any children of the dataset on the	com-
		 mand line.

	 -d depth
		 Recursively display any children of the dataset, limiting the
		 recursion to depth.  A	depth of 1 will	display	only the
		 dataset and its direct	children.

	 -H	 Used for scripting mode. Do not print headers and separate
		 fields	by a single tab	instead	of arbitrary white space.

	 -o property[,property]...
		 A comma-separated list	of properties to display. The property
		 must be:

		   +o   One of the properties described in the "Native
		       Properties" section

		   +o   A user property

		   +o   The value name to display the dataset name

		   +o   The value space to display space	usage properties on
		       file systems and	volumes. This is a shortcut for	speci-
		       fying -o
		       name,avail,used,usedsnap,usedds,usedrefreserv,usedchild
		       -t filesystem,volume syntax.

	 -t type[,type]...
		 A comma-separated list	of types to display, where type	is one
		 of filesystem,	snapshot, volume, or all.  For example,	speci-
		 fying -t snapshot displays only snapshots.

	 -s property
		 A property for	sorting	the output by column in	ascending
		 order based on	the value of the property. The property	must
		 be one	of the properties described in the "Properties"	sec-
		 tion, or the special value name to sort by the	dataset	name.
		 Multiple properties can be specified at one time using	multi-
		 ple -s	property options. Multiple -s options are evaluated
		 from left to right in decreasing order	of importance.

		 The following is a list of sorting criteria:

		   +o   Numeric types sort in numeric order.

		   +o   String types sort in alphabetical order.

		   +o   Types inappropriate for a row sort that row to the lit-
		       eral bottom, regardless of the specified	ordering.

		   +o   If no sorting options are specified the existing	behav-
		       ior of "zfs list" is preserved.

	 -S property
		 Same as the -s	option,	but sorts by property in descending
		 order.

     zfs set property=value filesystem|volume|snapshot

	 Sets the property to the given	value for each dataset.	Only some
	 properties can	be edited. See the "Properties"	section	for more
	 information on	what properties	can be set and acceptable values.
	 Numeric values	can be specified as exact values, or in	a human-read-
	 able form with	a suffix of B, K, M, G,	T, P, E, Z (for	bytes, kilo-
	 bytes,	megabytes, gigabytes, terabytes, petabytes, exabytes, or
	 zettabytes, respectively). User properties can	be set on snapshots.
	 For more information, see the "User Properties" section.

     zfs get [-r|-d depth] [-Hp] [-o all | field[,field]...] [-t
	 type[,type]...] [-s source[,source]...] all | property[,property]...
	 filesystem|volume|snapshot...

	 Displays properties for the given datasets. If	no datasets are	speci-
	 fied, then the	command	displays properties for	all datasets on	the
	 system. For each property, the	following columns are displayed:

	       name	 Dataset name
	       property	 Property name
	       value	 Property value
	       source	 Property source. Can either be	local, default,	tempo-
			 rary, inherited, or none (-).

	 All columns except the	RECEIVED column	are displayed by default. The
	 columns to display can	be specified by	using the -o option. This com-
	 mand takes a comma-separated list of properties as described in the
	 "Native Properties" and "User Properties" sections.

	 The special value all can be used to display all properties that
	 apply to the given dataset's type (filesystem,	volume,	or snapshot).

	 -r	 Recursively display properties	for any	children.

	 -d depth
		 Recursively display any children of the dataset, limiting the
		 recursion to depth.  A	depth of 1 will	display	only the
		 dataset and its direct	children.

	 -H	 Display output	in a form more easily parsed by	scripts. Any
		 headers are omitted, and fields are explicitly	separated by a
		 single	tab instead of an arbitrary amount of space.

	 -p	 Display numbers in parseable (exact) values.

	 -o all	| field[,field]...
		 A comma-separated list	of columns to display. Supported val-
		 ues are name,property,value,received,source.  Default values
		 are name,property,value,source.  The keyword all specifies
		 all columns.

	 -t type[,type]...
		 A comma-separated list	of types to display, where type	is one
		 of filesystem,	snapshot, volume, or all.  For example,	speci-
		 fying -t snapshot displays only snapshots.

	 -s source[,source]...
		 A comma-separated list	of sources to display. Those proper-
		 ties coming from a source other than those in this list are
		 ignored. Each source must be one of the following:
		 local,default,inherited,temporary,received,none.  The default
		 value is all sources.

     zfs inherit [-rS] property	filesystem|volume|snapshot...

	 Clears	the specified property,	causing	it to be inherited from	an
	 ancestor. If no ancestor has the property set,	then the default value
	 is used. See the "Properties" section for a listing of	default	val-
	 ues, and details on which properties can be inherited.

	 -r	 Recursively inherit the given property	for all	children.

	 -S	 For properties	with a received	value, revert to this value.
		 This flag has no effect on properties that do not have	a
		 received value.

     zfs upgrade [-v]

	 Displays a list of file systems that are not the most recent version.

	 -v	 Displays ZFS filesystem versions supported by the current
		 software. The current ZFS filesystem version and all previous
		 supported versions are	displayed, along with an explanation
		 of the	features provided with each version.

     zfs upgrade [-r] [-V version] -a |	filesystem

	 Upgrades file systems to a new	on-disk	version. Once this is done,
	 the file systems will no longer be accessible on systems running
	 older versions	of the software.  "zfs send" streams generated from
	 new snapshots of these	file systems cannot be accessed	on systems
	 running older versions	of the software.

	 In general, the file system version is	independent of the pool	ver-
	 sion. See zpool(8) for	information on the zpool upgrade command.

	 In some cases,	the file system	version	and the	pool version are
	 interrelated and the pool version must	be upgraded before the file
	 system	version	can be upgraded.

	 -r	 Upgrade the specified file system and all descendent file
		 systems.

	 -V version
		 Upgrade to the	specified version.  If the -V flag is not
		 specified, this command upgrades to the most recent version.
		 This option can only be used to increase the version number,
		 and only up to	the most recent	version	supported by this
		 software.

	 -a	 Upgrade all file systems on all imported pools.

	 filesystem
		 Upgrade the specified file system.

     zfs userspace [-Hinp] [-o field[,field]...] [-s field]... [-S field]...
	 [-t type[,type]...] filesystem|snapshot

	 Displays space	consumed by, and quotas	on, each user in the specified
	 filesystem or snapshot. This corresponds to the userused@user and
	 userquota@user	properties.

	 -n	 Print numeric ID instead of user/group	name.

	 -H	 Do not	print headers, use tab-delimited output.

	 -p	 Use exact (parsable) numeric output.

	 -o field[,field]...
		 Display only the specified fields from	the following set:
		 type,name,used,quota.	The default is to display all fields.

	 -s field
		 Sort output by	this field. The	-s and -S flags	may be speci-
		 fied multiple times to	sort first by one field, then by
		 another. The default is -s type -s name.

	 -S field
		 Sort by this field in reverse order. See -s.

	 -t type[,type]...
		 Print only the	specified types	from the following set:
		 all,posixuser,smbuser,posixgroup,smbgroup.

		 The default is	-t posixuser,smbuser.

		 The default can be changed to include group types.

	 -i	 Translate SID to POSIX	ID. This flag currently	has no effect
		 on FreeBSD.

     zfs groupspace [-Hinp] [-o	field[,field]...] [-s field]...	[-S field]...
	 [-t type[,type]...] filesystem|snapshot

	 Displays space	consumed by, and quotas	on, each group in the speci-
	 fied filesystem or snapshot. This subcommand is identical to "zfs
	 userspace", except that the default types to display are -t
	 posixgroup,smbgroup.

     zfs mount

	 Displays all ZFS file systems currently mounted.

	 -f

     zfs mount [-vO] [-o property[,property]...] -a | filesystem

	 Mounts	ZFS file systems.

	 -v	 Report	mount progress.

	 -O	 Perform an overlay mount. Overlay mounts are not supported on
		 FreeBSD.

	 -o property[,property]...
		 An optional, comma-separated list of mount options to use
		 temporarily for the duration of the mount. See	the "Temporary
		 Mount Point Properties" section for details.

	 -a	 Mount all available ZFS file systems.	This command may be
		 executed on FreeBSD system startup by /etc/rc.d/zfs.  For
		 more information, see variable	zfs_enable in rc.conf(5).

	 filesystem
		 Mount the specified filesystem.

     zfs unmount [-f] -a | filesystem|mountpoint

	 Unmounts currently mounted ZFS	file systems.

	 -f	 Forcefully unmount the	file system, even if it	is currently
		 in use.

	 -a	 Unmount all available ZFS file	systems.

	 filesystem | mountpoint
		 Unmount the specified filesystem. The command can also	be
		 given a path to a ZFS file system mount point on the system.

     zfs share -a | filesystem

	 Shares	ZFS file systems that have the sharenfs	property set.

	 -a	 Share all ZFS file systems that have the sharenfs property
		 set.  This command may	be executed on FreeBSD system startup
		 by /etc/rc.d/zfs.  For	more information, see variable
		 zfs_enable in rc.conf(5).

	 filesystem
		 Share the specified filesystem	according to the sharenfs
		 property. File	systems	are shared when	the sharenfs property
		 is set.

     zfs unshare -a | filesystem|mountpoint

	 Unshares ZFS file systems that	have the sharenfs property set.

	 -a	 Unshares ZFS file systems that	have the sharenfs property
		 set.  This command may	be executed on FreeBSD system shutdown
		 by /etc/rc.d/zfs.  For	more information, see variable
		 zfs_enable in rc.conf(5).

	 filesystem | mountpoint
		 Unshare the specified filesystem. The command can also	be
		 given a path to a ZFS file system shared on the system.

     zfs send [-DnPpRv]	[-i snapshot | -I snapshot] snapshot

	 Creates a stream representation of the	last snapshot argument (not
	 part of -i or -I) which is written to standard	output.	The output can
	 be redirected to a file or to a different system (for example,	using
	 ssh(1)).  By default, a full stream is	generated.

	 -i snapshot
		 Generate an incremental stream	from the -i snapshot to	the
		 last snapshot.	 The incremental source	(the -i	snapshot) can
		 be specified as the last component of the snapshot name (for
		 example, the part after the @), and it	is assumed to be from
		 the same file system as the last snapshot.

		 If the	destination is a clone,	the source may be the origin
		 snapshot, which must be fully specified (for example,
		 pool/fs@origin, not just @origin).

	 -I snapshot
		 Generate a stream package that	sends all intermediary snap-
		 shots from the	-I snapshot to the last	snapshot.  For exam-
		 ple, -I @a fs@d is similar to -i @a fs@b; -i @b fs@c; -i @c
		 fs@d.	The incremental	source snapshot	may be specified as
		 with the -i option.

	 -R	 Generate a replication	stream package,	which will replicate
		 the specified filesystem, and all descendent file systems, up
		 to the	named snapshot.	When received, all properties, snap-
		 shots,	descendent file	systems, and clones are	preserved.

		 If the	-i or -I flags are used	in conjunction with the	-R
		 flag, an incremental replication stream is generated. The
		 current values	of properties, and current snapshot and	file
		 system	names are set when the stream is received. If the -F
		 flag is specified when	this stream is received, snapshots and
		 file systems that do not exist	on the sending side are
		 destroyed.

	 -D	 Generate a deduplicated stream. Blocks	which would have been
		 sent multiple times in	the send stream	will only be sent
		 once.	The receiving system must also support this feature to
		 receive a deduplicated	stream.	 This flag can be used regard-
		 less of the dataset's dedup property, but performance will be
		 much better if	the filesystem uses a dedup-capable checksum
		 (eg.  sha256).

	 -p	 Include the dataset's properties in the stream. This flag is
		 implicit when -R is specified.	The receiving system must also
		 support this feature.

	 -n	 Do a dry-run ("No-op")	send.  Do not generate any actual send
		 data.	This is	useful in conjunction with the -v or -P	flags
		 to determine what data	will be	sent.

	 -P	 Print machine-parsable	verbose	information about the stream
		 package generated.

	 -v	 Print verbose information about the stream package generated.
		 This information includes a per-second	report of how much
		 data has been sent.

	 The format of the stream is committed.	You will be able to receive
	 your streams on future	versions of ZFS.

     zfs receive [-vnFu] filesystem|volume|snapshot

     zfs receive [-vnFu] [-d | -e] filesystem

	 Creates a snapshot whose contents are as specified in the stream pro-
	 vided on standard input. If a full stream is received,	then a new
	 file system is	created	as well. Streams are created using the "zfs
	 send" subcommand, which by default creates a full stream.  "zfs recv"
	 can be	used as	an alias for "zfs receive".

	 If an incremental stream is received, then the	destination file sys-
	 tem must already exist, and its most recent snapshot must match the
	 incremental stream's source. For zvols, the destination device	link
	 is destroyed and recreated, which means the zvol cannot be accessed
	 during	the receive operation.

	 When a	snapshot replication package stream that is generated by using
	 the "zfs send -R" command is received,	any snapshots that do not
	 exist on the sending location are destroyed by	using the "zfs destroy
	 -d" command.

	 The name of the snapshot (and file system, if a full stream is
	 received) that	this subcommand	creates	depends	on the argument	type
	 and the -d or -e option.

	 If the	argument is a snapshot name, the specified snapshot is cre-
	 ated. If the argument is a file system	or volume name,	a snapshot
	 with the same name as the sent	snapshot is created within the speci-
	 fied filesystem or volume.  If	the -d or -e option is specified, the
	 snapshot name is determined by	appending the sent snapshot's name to
	 the specified filesystem.  If the -d option is	specified, all but the
	 pool name of the sent snapshot	path is	appended (for example, b/c@1
	 appended from sent snapshot a/b/c@1), and if the -e option is speci-
	 fied, only the	tail of	the sent snapshot path is appended (for	exam-
	 ple, c@1 appended from	sent snapshot a/b/c@1).	 In the	case of	-d,
	 any file systems needed to replicate the path of the sent snapshot
	 are created within the	specified file system.

	 -d	 Use the full sent snapshot path without the first element
		 (without pool name) to	determine the name of the new snapshot
		 as described in the paragraph above.

	 -e	 Use only the last element of the sent snapshot	path to	deter-
		 mine the name of the new snapshot as described	in the para-
		 graph above.

	 -u	 File system that is associated	with the received stream is
		 not mounted.

	 -v	 Print verbose information about the stream and	the time
		 required to perform the receive operation.

	 -n	 Do not	actually receive the stream. This can be useful	in
		 conjunction with the -v option	to verify the name the receive
		 operation would use.

	 -F	 Force a rollback of the file system to	the most recent	snap-
		 shot before performing	the receive operation. If receiving an
		 incremental replication stream	(for example, one generated by
		 "zfs send -R -Fi -iI"), destroy snapshots and file systems
		 that do not exist on the sending side.

     zfs allow filesystem|volume

	 Displays permissions that have	been delegated on the specified
	 filesystem or volume. See the other forms of "zfs allow" for more
	 information.

     zfs allow [-ldug] user|group[,user|group]...
	 perm|@setname[,perm|@setname]... filesystem|volume

     zfs allow [-ld] -e|everyone perm|@setname[,perm|@setname]...
	 filesystem|volume

	 Delegates ZFS administration permission for the file systems to non-
	 privileged users.

	 [-ug] user|group[, user|group]...
		 Specifies to whom the permissions are delegated. Multiple
		 entities can be specified as a	comma-separated	list. If nei-
		 ther of the -ug options are specified,	then the argument is
		 interpreted preferentially as the keyword everyone, then as a
		 user name, and	lastly as a group name.	To specify a user or
		 group named "everyone", use the -u or -g options. To specify
		 a group with the same name as a user, use the -g option.

	 [-e|everyone]
		 Specifies that	the permissions	be delegated to	"everyone".

	 perm|@setname[,perm|@setname]...
		 The permissions to delegate. Multiple permissions may be
		 specified as a	comma-separated	list. Permission names are the
		 same as ZFS subcommand	and property names. See	the property
		 list below. Property set names, which begin with an at	sign
		 (@), may be specified.	See the	-s form	below for details.

	 [-ld] filesystem|volume
		 Specifies where the permissions are delegated.	If neither of
		 the -ld options are specified,	or both	are, then the permis-
		 sions are allowed for the file	system or volume, and all of
		 its descendents. If only the -l option	is used, then is
		 allowed "locally" only	for the	specified file system.	If
		 only the -d option is used, then is allowed only for the
		 descendent file systems.

	 Permissions are generally the ability to use a	ZFS subcommand or
	 change	a ZFS property.	The following permissions are available:

	     NAME	       TYPE	     NOTES
	     allow	       subcommand    Must also have the	permission
					     that is being allowed
	     clone	       subcommand    Must also have the	'create'
					     ability and 'mount' ability in
					     the origin	file system
	     create	       subcommand    Must also have the	'mount'
					     ability
	     destroy	       subcommand    Must also have the	'mount'
					     ability
	     diff	       subcommand    Allows lookup of paths within a
					     dataset given an object number,
					     and the ability to	create snap-
					     shots necessary to	'zfs diff'
	     hold	       subcommand    Allows adding a user hold to a
					     snapshot
	     mount	       subcommand    Allows mount/umount of ZFS
					     datasets
	     promote	       subcommand    Must also have the	'mount'	and
					     'promote' ability in the origin
					     file system
	     receive	       subcommand    Must also have the	'mount'	and
					     'create' ability
	     release	       subcommand    Allows releasing a	user hold
					     which might destroy the snapshot
	     rename	       subcommand    Must also have the	'mount'	and
					     'create' ability in the new
					     parent
	     rollback	       subcommand    Must also have the	'mount'
					     ability
	     send	       subcommand
	     share	       subcommand    Allows sharing file systems over
					     the NFS protocol
	     snapshot	       subcommand    Must also have the	'mount'
					     ability
	     groupquota	       other	     Allows accessing any
					     groupquota@... property
	     groupused	       other	     Allows reading any	groupused@...
					     property
	     userprop	       other	     Allows changing any user property
	     userquota	       other	     Allows accessing any
					     userquota@... property
	     userused	       other	     Allows reading any	userused@...
					     property
	     aclinherit	       property
	     aclmode	       property
	     atime	       property
	     canmount	       property
	     casesensitivity   property
	     checksum	       property
	     compression       property
	     copies	       property
	     dedup	       property
	     devices	       property
	     exec	       property
	     logbias	       property
	     jailed	       property
	     mlslabel	       property
	     mountpoint	       property
	     nbmand	       property
	     normalization     property
	     primarycache      property
	     quota	       property
	     readonly	       property
	     recordsize	       property
	     refquota	       property
	     refreservation    property
	     reservation       property
	     secondarycache    property
	     setuid	       property
	     sharenfs	       property
	     sharesmb	       property
	     snapdir	       property
	     sync	       property
	     utf8only	       property
	     version	       property
	     volblocksize      property
	     volsize	       property
	     vscan	       property
	     xattr	       property

     zfs allow -c perm|@setname[,perm|@setname]... filesystem|volume

	 Sets "create time" permissions. These permissions are granted
	 (locally) to the creator of any newly-created descendent file system.

     zfs allow -s @setname perm|@setname[,perm|@setname]... filesystem|volume

	 Defines or adds permissions to	a permission set. The set can be used
	 by other "zfs allow" commands for the specified file system and its
	 descendents. Sets are evaluated dynamically, so changes to a set are
	 immediately reflected.	Permission sets	follow the same	naming
	 restrictions as ZFS file systems, but the name	must begin with	an "at
	 sign" (@), and	can be no more than 64 characters long.

     zfs unallow [-rldug] user|group[,user|group]...
	 [perm|@setname[,perm|@setname]...] filesystem|volume

     zfs unallow [-rld]	-e|everyone [perm|@setname[,perm|@setname]...]
	 filesystem|volume

     zfs unallow [-r] -c [perm|@setname[,perm|@setname]...] filesystem|volume

	 Removes permissions that were granted with the	"zfs allow" command.
	 No permissions	are explicitly denied, so other	permissions granted
	 are still in effect. For example, if the permission is	granted	by an
	 ancestor. If no permissions are specified, then all permissions for
	 the specified user, group, or everyone	are removed. Specifying
	 everyone (or using the	-e option) only	removes	the permissions	that
	 were granted to everyone, not all permissions for every user and
	 group.	See the	"zfs allow" command for	a description of the -ldugec
	 options.

	 -r	 Recursively remove the	permissions from this file system and
		 all descendents.

     zfs unallow [-r] -s @setname [perm|@setname[,perm|@setname]...]
	 filesystem|volume

	 Removes permissions from a permission set. If no permissions are
	 specified, then all permissions are removed, thus removing the	set
	 entirely.

     zfs hold [-r] tag snapshot...

	 Adds a	single reference, named	with the tag argument, to the speci-
	 fied snapshot or snapshots. Each snapshot has its own tag namespace,
	 and tags must be unique within	that space.

	 If a hold exists on a snapshot, attempts to destroy that snapshot by
	 using the "zfs	destroy" command returns EBUSY.

	 -r	 Specifies that	a hold with the	given tag is applied recur-
		 sively	to the snapshots of all	descendent file	systems.

     zfs holds [-r] snapshot...

	 Lists all existing user references for	the given snapshot or snap-
	 shots.

	 -r	 Lists the holds that are set on the named descendent snap-
		 shots,	in addition to listing the holds on the	named snap-
		 shot.

     zfs release [-r] tag snapshot...

	 Removes a single reference, named with	the tag	argument, from the
	 specified snapshot or snapshots. The tag must already exist for each
	 snapshot.

	 -r	 Recursively releases a	hold with the given tag	on the snap-
		 shots of all descendent file systems.

     zfs diff [-FHt] snapshot [snapshot|filesystem]

	 Display the difference	between	a snapshot of a	given filesystem and
	 another snapshot of that filesystem from a later time or the current
	 contents of the filesystem.  The first	column is a character indicat-
	 ing the type of change, the other columns indicate pathname, new
	 pathname (in case of rename), change in link count, and optionally
	 file type and/or change time.

	 The types of change are:

	   -	     path was removed
	   +	     path was added
	   M	     path was modified
	   R	     path was renamed

	 -F	 Display an indication of the type of file, in a manner	simi-
		 lar to	the -F option of ls(1).

		   B	     block device
		   C	     character device
		   F	     regular file
		   /	     directory
		   @	     symbolic link
		   =	     socket
		   >	     door (not supported on FreeBSD)
		   |	     named pipe	(not supported on FreeBSD)
		   P	     event port	(not supported on FreeBSD)

	 -H	 Give more parseable tab-separated output, without header
		 lines and without arrows.

	 -t	 Display the path's inode change time as the first column of
		 output.

     zfs jail jailid filesystem

	 Attaches the specified	filesystem to the jail identified by JID
	 jailid.  From now on this file	system tree can	be managed from	within
	 a jail	if the jailed property has been	set. To	use this functional-
	 ity, the jail needs the enforce_statfs	parameter set to 0 and the
	 allow.mount parameter set to 1.

	 See jail(8) for more information on managing jails and	configuring
	 the parameters	above.

     zfs unjail	jailid filesystem

	 Detaches the specified	filesystem from	the jail identified by JID
	 jailid.

EXIT STATUS
     The following exit	values are returned:

       0   Successful completion.

       1   An error occurred.

       2   Invalid command line	options	were specified.

EXAMPLES
     Example 1 Creating	a ZFS File System Hierarchy

       The following commands create a file system named pool/home and a file
       system named pool/home/bob.  The	mount point /home is set for the par-
       ent file	system,	and is automatically inherited by the child file sys-
       tem.

	 # zfs create pool/home
	 # zfs set mountpoint=/home pool/home
	 # zfs create pool/home/bob

     Example 2 Creating	a ZFS Snapshot

       The following command creates a snapshot	named yesterday.  This snap-
       shot is mounted on demand in the	.zfs/snapshot directory	at the root of
       the pool/home/bob file system.

	 # zfs snapshot	pool/home/bob@yesterday

     Example 3 Creating	and Destroying Multiple	Snapshots

       The following command creates snapshots named yesterday of pool/home
       and all of its descendent file systems. Each snapshot is	mounted	on
       demand in the .zfs/snapshot directory at	the root of its	file system.
       The second command destroys the newly created snapshots.

	 # zfs snapshot	-r pool/home@yesterday
	 # zfs destroy -r pool/home@yesterday

     Example 4 Disabling and Enabling File System Compression

       The following command disables the compression property for all file
       systems under pool/home.	 The next command explicitly enables
       compression for pool/home/anne.

	 # zfs set compression=off pool/home
	 # zfs set compression=on pool/home/anne

     Example 5 Listing ZFS Datasets

       The following command lists all active file systems and volumes in the
       system.	Snapshots are displayed	if the listsnaps property is on.  The
       default is off.	See zpool(8) for more information on pool properties.

	 # zfs list
	    NAME		      USED  AVAIL  REFER  MOUNTPOINT
	    pool		      450K   457G    18K  /pool
	    pool/home		      315K   457G    21K  /home
	    pool/home/anne	       18K   457G    18K  /home/anne
	    pool/home/bob	      276K   457G   276K  /home/bob

     Example 6 Setting a Quota on a ZFS	File System

       The following command sets a quota of 50	Gbytes for pool/home/bob.

	 # zfs set quota=50G pool/home/bob

     Example 7 Listing ZFS Properties

       The following command lists all properties for pool/home/bob.

	 # zfs get all pool/home/bob
	 NAME		PROPERTY	      VALUE		     SOURCE
	 pool/home/bob	type		      filesystem	     -
	 pool/home/bob	creation	      Tue Jul 21 15:53 2009  -
	 pool/home/bob	used		      21K		     -
	 pool/home/bob	available	      20.0G		     -
	 pool/home/bob	referenced	      21K		     -
	 pool/home/bob	compressratio	      1.00x		     -
	 pool/home/bob	mounted		      yes		     -
	 pool/home/bob	quota		      20G		     local
	 pool/home/bob	reservation	      none		     default
	 pool/home/bob	recordsize	      128K		     default
	 pool/home/bob	mountpoint	      /home/bob		     default
	 pool/home/bob	sharenfs	      off		     default
	 pool/home/bob	checksum	      on		     default
	 pool/home/bob	compression	      on		     local
	 pool/home/bob	atime		      on		     default
	 pool/home/bob	devices		      on		     default
	 pool/home/bob	exec		      on		     default
	 pool/home/bob	setuid		      on		     default
	 pool/home/bob	readonly	      off		     default
	 pool/home/bob	jailed		      off		     default
	 pool/home/bob	snapdir		      hidden		     default
	 pool/home/bob	aclmode		      discard		     default
	 pool/home/bob	aclinherit	      restricted	     default
	 pool/home/bob	canmount	      on		     default
	 pool/home/bob	xattr		      on		     default
	 pool/home/bob	copies		      1			     default
	 pool/home/bob	version		      5			     -
	 pool/home/bob	utf8only	      off		     -
	 pool/home/bob	normalization	      none		     -
	 pool/home/bob	casesensitivity	      sensitive		     -
	 pool/home/bob	vscan		      off		     default
	 pool/home/bob	nbmand		      off		     default
	 pool/home/bob	sharesmb	      off		     default
	 pool/home/bob	refquota	      none		     default
	 pool/home/bob	refreservation	      none		     default
	 pool/home/bob	primarycache	      all		     default
	 pool/home/bob	secondarycache	      all		     default
	 pool/home/bob	usedbysnapshots	      0			     -
	 pool/home/bob	usedbydataset	      21K		     -
	 pool/home/bob	usedbychildren	      0			     -
	 pool/home/bob	usedbyrefreservation  0			     -
	 pool/home/bob	logbias		      latency		     default
	 pool/home/bob	dedup		      off		     default
	 pool/home/bob	mlslabel				     -
	 pool/home/bob	sync		      standard		     default
	 pool/home/bob	refcompressratio      1.00x		     -

       The following command gets a single property value.

	 # zfs get -H -o value compression pool/home/bob
	 on

       The following command lists all properties with local settings for
       pool/home/bob.

	 # zfs get -s local -o name,property,value all pool/home/bob
	 NAME		PROPERTY	      VALUE
	 pool/home/bob	quota		      20G
	 pool/home/bob	compression	      on

     Example 8 Rolling Back a ZFS File System

       The following command reverts the contents of pool/home/anne to the
       snapshot	named yesterday, deleting all intermediate snapshots.

	 # zfs rollback	-r pool/home/anne@yesterday

     Example 9 Creating	a ZFS Clone

       The following command creates a writable	file system whose initial con-
       tents are the same as pool/home/bob@yesterday.

	 # zfs clone pool/home/bob@yesterday pool/clone

     Example 10	Promoting a ZFS	Clone

       The following commands illustrate how to	test out changes to a file
       system, and then	replace	the original file system with the changed one,
       using clones, clone promotion, and renaming:

	 # zfs create pool/project/production

       Populate	/pool/project/production with data and continue	with the fol-
       lowing commands:

	 # zfs snapshot	pool/project/production@today
	 # zfs clone pool/project/production@today pool/project/beta

       Now make	changes	to /pool/project/beta and continue with	the following
       commands:

	 # zfs promote pool/project/beta
	 # zfs rename pool/project/production pool/project/legacy
	 # zfs rename pool/project/beta	pool/project/production

       Once the	legacy version is no longer needed, it can be destroyed.

	 # zfs destroy pool/project/legacy

     Example 11	Inheriting ZFS Properties

       The following command causes pool/home/bob and pool/home/anne to
       inherit the checksum property from their	parent.

	 # zfs inherit checksum	pool/home/bob pool/home/anne

     Example 12	Remotely Replicating ZFS Data

       The following commands send a full stream and then an incremental
       stream to a remote machine, restoring them into poolB/received/fs@a and
       poolB/received/fs@b, respectively.  poolB must contain the file system
       poolB/received, and must	not initially contain poolB/received/fs.

	 # zfs send pool/fs@a |	ssh host zfs receive poolB/received/fs@a
	 # zfs send -i a pool/fs@b | ssh host zfs receive poolB/received/fs

     Example 13	Using the "zfs receive -d" Option

       The following command sends a full stream of poolA/fsA/fsB@snap to a
       remote machine, receiving it into poolB/received/fsA/fsB@snap.  The
       fsA/fsB@snap portion of the received snapshot's name is determined from
       the name	of the sent snapshot.  poolB must contain the file system
       poolB/received.	If poolB/received/fsA does not exist, it is created as
       an empty	file system.

	 # zfs send poolA/fsA/fsB@snap | ssh host zfs receive -d poolB/received

     Example 14	Setting	User Properties

       The following example sets the user-defined com.example:department
       property	for a dataset.

	 # zfs set com.example:department=12345	tank/accounting

     Example 15	Performing a Rolling Snapshot

       The following example shows how to maintain a history of	snapshots with
       a consistent naming scheme. To keep a week's worth of snapshots,	the
       user destroys the oldest	snapshot, renames the remaining	snapshots, and
       then creates a new snapshot, as follows:

	 # zfs destroy -r pool/users@7daysago
	 # zfs rename -r pool/users@6daysago @7daysago
	 # zfs rename -r pool/users@5daysago @6daysago
	 # zfs rename -r pool/users@4daysago @5daysago
	 # zfs rename -r pool/users@3daysago @4daysago
	 # zfs rename -r pool/users@2daysago @3daysago
	 # zfs rename -r pool/users@yesterday @2daysago
	 # zfs rename -r pool/users@today @yesterday
	 # zfs snapshot	-r pool/users@today

     Example 16	Setting	"sharenfs" Property Options on a ZFS File System

       The following command shows how to set sharenfs property	options	to
       enable root access for a	specific network on the	tank/home file system.
       The contents of the sharenfs property are valid exports(5) options.

	 # zfs set sharenfs="maproot=root,network 192.168.0.0/24" tank/home

       Another way to write this command with the same result is:

	 # set zfs sharenfs="-maproot=root -network 192.168.0.0/24" tank/home

     Example 17	Delegating ZFS Administration Permissions on a ZFS Dataset

       The following example shows how to set permissions so that user cindys
       can create, destroy, mount, and take snapshots on tank/cindys.  The
       permissions on tank/cindys are also displayed.

	 # zfs allow cindys create,destroy,mount,snapshot tank/cindys
	 # zfs allow tank/cindys
	 -------------------------------------------------------------
	 Local+Descendent permissions on (tank/cindys)
		   user	cindys create,destroy,mount,snapshot
	 -------------------------------------------------------------

     Example 18	Delegating Create Time Permissions on a	ZFS Dataset

       The following example shows how to grant	anyone in the group staff to
       create file systems in tank/users.  This	syntax also allows staff mem-
       bers to destroy their own file systems, but not destroy anyone else's
       file system. The	permissions on tank/users are also displayed.

	 # zfs allow staff create,mount	tank/users
	 # zfs allow -c	destroy	tank/users
	 # zfs allow tank/users
	 -------------------------------------------------------------
	 Create	time permissions on (tank/users)
		   create,destroy
	 Local+Descendent permissions on (tank/users)
		   group staff create,mount
	 -------------------------------------------------------------

     Example 19	Defining and Granting a	Permission Set on a ZFS	Dataset

       The following example shows how to define and grant a permission	set on
       the tank/users file system. The permissions on tank/users are also dis-
       played.

	 # zfs allow -s	@pset create,destroy,snapshot,mount tank/users
	 # zfs allow staff @pset tank/users
	 # zfs allow tank/users
	 -------------------------------------------------------------
	 Permission sets on (tank/users)
		 @pset create,destroy,mount,snapshot
	 Create	time permissions on (tank/users)
		 create,destroy
	 Local+Descendent permissions on (tank/users)
		 group staff @pset,create,mount
	 -------------------------------------------------------------

     Example 20	Delegating Property Permissions	on a ZFS Dataset

       The following example shows to grant the	ability	to set quotas and
       reservations on the users/home file system. The permissions on
       users/home are also displayed.

	 # zfs allow cindys quota,reservation users/home
	 # zfs allow cindys
	 -------------------------------------------------------------
	 Local+Descendent permissions on (users/home)
		 user cindys quota,reservation
	 -------------------------------------------------------------
	 # su -	cindys
	 cindys% zfs set quota=10G users/home/marks
	 cindys% zfs get quota users/home/marks
	 NAME		   PROPERTY  VALUE	       SOURCE
	 users/home/marks  quota     10G	       local

     Example 21	Removing ZFS Delegated Permissions on a	ZFS Dataset

       The following example shows how to remove the snapshot permission from
       the staff group on the tank/users file system. The permissions on
       tank/users are also displayed.

	 # zfs unallow staff snapshot tank/users
	 # zfs allow tank/users
	 -------------------------------------------------------------
	 Permission sets on (tank/users)
		 @pset create,destroy,mount,snapshot
	 Create	time permissions on (tank/users)
		 create,destroy
	 Local+Descendent permissions on (tank/users)
		 group staff @pset,create,mount
	 -------------------------------------------------------------

     Example 22	Showing	the differences	between	a snapshot and a ZFS Dataset

       The following example shows how to see what has changed between a prior
       snapshot	of a ZFS Dataset and its current state.	 The -F	option is used
       to indicate type	information for	the files affected.

	 # zfs diff tank/test@before tank/test
	 M	 /	 /tank/test/
	 M	 F	 /tank/test/linked	(+1)
	 R	 F	 /tank/test/oldname -> /tank/test/newname
	 -	 F	 /tank/test/deleted
	 +	 F	 /tank/test/created
	 M	 F	 /tank/test/modified

SEE ALSO
     chmod(2), fsync(2), exports(5), fstab(5), rc.conf(5), jail(8), mount(8),
     umount(8),	zpool(8)

AUTHORS
     This manual page is a mdoc(7) reimplementation of the OpenSolaris manual
     page zfs(1M), modified and	customized for FreeBSD and licensed under the
     Common Development	and Distribution License (CDDL).

     The mdoc(7) implementation	of this	manual page was	initially written by
     Martin Matuska <mm@FreeBSD.org>.

FreeBSD	10.1			March 21, 2013			  FreeBSD 10.1

NAME | SYNOPSIS | DESCRIPTION | SUBCOMMANDS | EXIT STATUS | EXAMPLES | SEE ALSO | AUTHORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=zfs&sektion=8&manpath=FreeBSD+9.2-RELEASE>

home | help