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

FreeBSD Manual Pages

  
 
  

home | help
ZFS(8)			FreeBSD	System Manager's Manual			ZFS(8)

NAME
     zfs -- configures ZFS file	systems

SYNOPSIS
     zfs [-?]
     zfs create	[-pu] [-o property=value]... filesystem
     zfs create	[-ps] [-b blocksize] [-o property=value]... -V size volume
     zfs destroy [-fnpRrv] filesystem|volume
     zfs destroy [-dnpRrv] filesystem|volume@snap[%snap][,snap[%snap]][,...]
     zfs destroy filesystem|volume#bookmark
     zfs snapshot|snap [-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] [-Hp] [-o property[,property]...]
	 [-t type[,type]...] [-s property]... [-S property]...
	 filesystem|volume|snapshot |bookmark...
     zfs remap filesystem|volume
     zfs set property=value [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|umount	[-f] -a	| filesystem|mountpoint
     zfs share -a | filesystem
     zfs unshare -a | filesystem|mountpoint
     zfs bookmark snapshot bookmark
     zfs send [-DLPRcenpv] [-i snapshot	| -I snapshot] snapshot
     zfs send [-Lce] [-i snapshot|bookmark] filesystem|volume|snapshot
     zfs send [-Penv] -t receive_resume_token
     zfs receive|recv [-vnsFu] [-o origin=snapshot] filesystem|volume|snapshot
     zfs receive|recv [-vnsFu] [-d | -e] [-o origin=snapshot] filesystem
     zfs receive|recv -A filesystem|volume
     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 [-Hp] [-r|-d depth] filesystem|volume|snapshot...
     zfs release [-r] tag snapshot...
     zfs diff [-FHt] snapshot [snapshot|filesystem]
     zfs program [-n] [-t timeout] [-m memory_limit] pool script [arg1 ...]
     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) and
     the maximum amount	of nesting allowed in a	path is	50 levels deep.

     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 jail. You can also	not attach the root file sys-
     tem of the	jail or	any dataset which needs	to be mounted before the zfs
     rc	script is run inside the jail, as it would be attached unmounted until
     it	is mounted from	the rc script inside the jail. To allow	management of
     the dataset from within a jail, the jailed	property has to	be set and the
     jail needs	access to the /dev/zfs device. The quota property cannot be
     changed from within a jail. See jail(8) for information on	how to allow
     mounting ZFS datasets 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.

     createtxg
	 The transaction group (txg) in	which the dataset was created.	Book-
	 marks have the	same createtxg as the snapshot they are	initially tied
	 to.  This property is suitable	for ordering a list of snapshots, e.g.
	 for incremental send and receive.

     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.

     filesystem_count
	 The total number of filesystems and volumes that exist	under this
	 location in the dataset tree.	This value is only available when a
	 filesystem_limit has been set somewhere in the	tree under which the
	 dataset resides.

     guid
	 The 64	bit GUID of this dataset or bookmark which does	not change
	 over its entire lifetime.  When a snapshot is sent to another pool,
	 the received snapshot has the same GUID.  Thus, the guid is suitable
	 to identify a snapshot	across pools.

     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.

     receive_resume_token
	 For filesystems or volumes which have saved partially-completed state
	 from zfs receive -s, this opaque token	can be provided	to zfs send -t
	 to resume and complete	the zfs	receive.

     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.

     snapshot_count
	 The total number of snapshots that exist under	this location in the
	 dataset tree.	This value is only available when a snapshot_limit has
	 been set somewhere in the tree	under which the	dataset	resides.

     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	| noparity | sha512 |
	 skein
	 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.  The value
	 noparity not only disables integrity but also disables	maintaining
	 parity	for user data.	This setting is	used internally	by a dump
	 device	residing on a RAID-Z pool and should not be used by any	other
	 dataset.  Disabling checksums is NOT a	recommended practice.  The
	 sha512, and skein checksum algorithms require enabling	the appropri-
	 ate features on the pool.  Please see zpool-features(7) for more
	 information on	these algorithms.

	 Changing this property	affects	only newly-written data.

	 Salted	checksum algorithms (edonr, skein) are currently not supported
	 for any filesystem on the boot	pools.

     compression=on | off | lzjb | gzip	| gzip-N | zle | lz4
	 Controls the compression algorithm used for this dataset.  Setting
	 compression to	on indicates that the current default compression
	 algorithm should be used.  The	default	balances compression and
	 decompression speed, with compression ratio and is expected to	work
	 well on a wide	variety	of workloads.  Unlike all other	settings for
	 this property,	on does	not select a fixed compression type.  As new
	 compression algorithms	are added to ZFS and enabled on	a pool,	the
	 default compression algorithm may change.  The	current	default	com-
	 pression algorthm is either lzjb or, if the lz4_compress feature is
	 enabled, lz4.	The lzjb compression algorithm is optimized for	per-
	 formance while	providing decent data compression. Setting compression
	 to on uses the	lzjb compression algorithm. The	gzip compression algo-
	 rithm uses the	same compression as the	gzip(1)	command. You can spec-
	 ify 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 algorithm 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] | sha512[,verify] |
	 skein[,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.

     filesystem_limit=count | none
	 Limits	the number of filesystems and volumes that can exist under
	 this point in the dataset tree.  The limit is not enforced if the
	 user is allowed to change the limit.  Setting a filesystem_limit on a
	 descendent of a filesystem that already has a filesystem_limit	does
	 not override the ancestor's filesystem_limit, but rather imposes an
	 additional limit.  This feature must be enabled to be used (see
	 zpool-features(7)).

     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.

     snapshot_limit=count | none
	 Limits	the number of snapshots	that can be created on a dataset and
	 its descendents.  Setting a snapshot_limit on a descendent of a
	 dataset that already has a snapshot_limit does	not override the
	 ancestor's snapshot_limit, but	rather imposes an additional limit.
	 The limit is not enforced if the user is allowed to change the	limit.
	 For example, this means that recursive	snapshots taken	from the
	 global	zone are counted against each delegated	dataset	within a jail.
	 This feature must be enabled to be used (see zpool-features(7)).

     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.  If the large_blocks	fea-
	 ture is enabled on the	pool, the size may be up to 1 Mbyte.  See
	 zpool-features(7) for details on ZFS feature flags.

	 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.

     redundant_metadata=all | most
	 Controls what types of	metadata are stored redundantly.  ZFS stores
	 an extra copy of metadata, so that if a single	block is corrupted,
	 the amount of user data lost is limited.  This	extra copy is in addi-
	 tion to any redundancy	provided at the	pool level (e.g. by mirroring
	 or RAID-Z), and is in addition	to an extra copy specified by the
	 copies	property (up to	a total	of 3 copies).  For example if the pool
	 is mirrored, copies=2,	and redundant_metadata=most, then ZFS stores 6
	 copies	of most	metadata, and 4	copies of data and some	metadata.

	 When set to all, ZFS stores an	extra copy of all metadata.  If	a sin-
	 gle on-disk block is corrupt, at worst	a single block of user data
	 (which	is recordsize bytes long can be	lost.)

	 When set to most, ZFS stores an extra copy of most types of metadata.
	 This can improve performance of random	writes,	because	less metadata
	 must be written.  In practice,	at worst about 100 blocks (of
	 recordsize bytes each)	of user	data can be lost if a single on-disk
	 block is corrupt.  The	exact behavior of which	metadata blocks	are
	 stored	redundantly may	change in future releases.

	 The default value is all.

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

	 If refreservation is set to auto, a volume is thick provisioned or
	 not sparse.  refreservation= auto is only supported on	volumes.  See
	 volsize in the	Native Properties section for more information about
	 sparse	volumes.

	 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-
	 sioned") can be created by specifying the -s option to	the "zfs
	 create	-V" command, or	by changing the	value of the refreservation
	 property, or reservation property on pool version 8 or	earlier
	 ) after the volume has	been created.  A "sparse volume" is a volume
	 where the value of refreservation is less then	the size of the	volume
	 plus the space	required to store its metadata.	 Consequently, writes
	 to a sparse volume can	fail with ENOSPC when the pool is low on
	 space.	For a sparse volume, changes to	volsize	are not	reflected in
	 the refreservation.  A	volume that is not sparse is said to be	"thick
	 provisioned".	A sparse volume	can become thick provisioned by	set-
	 ting refreservation to	auto.

     volmode=default | geom | dev | none
	 This property specifies how volumes should be exposed to the OS.
	 Setting it to geom exposes volumes as geom(4) providers, providing
	 maximal functionality.	 Setting it to dev exposes volumes only	as
	 cdev device in	devfs.	Such volumes can be accessed only as raw disk
	 device	files, i.e. they can not be partitioned, mounted, participate
	 in RAIDs, etc,	but they are faster, and in some use scenarios with
	 untrusted consumer, such as NAS or VM storage,	can be more safe.
	 Volumes with property set to none are not exposed outside ZFS,	but
	 can be	snapshoted, cloned, replicated,	etc, that can be suitable for
	 backup	purposes.  Value default means that volumes exposition is con-
	 trolled by system-wide	sysctl/tunable vfs.zfs.vol.mode, where geom,
	 dev and none are encoded as 1,	2 and 3	respectively.  The default
	 values	is geom.  This property	can be changed any time, but so	far it
	 is processed only during volume creation and pool import.

     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
	   Indicates whether the file name matching algorithm used by the file
	   system should be case-sensitive, case-insensitive, or allow a com-
	   bination of both styles of matching.	The default value for the
	   casesensitivity property is sensitive.  Traditionally, UNIX and
	   POSIX file systems have case-sensitive file names.

	   The mixed value for the casesensitivity property indicates that the
	   file	system can support requests for	both case-sensitive and	case-
	   insensitive matching	behavior.

     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.

     Displays a	help message.

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

     -p	     Creates all the non-existing parent datasets. Datasets created 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 operation completes	successfully.

     -u	     Newly created file	system is not mounted.

     -o	property=value
	     Sets the specified	property as if the command "zfs	set
	     property=value" was invoked at the	same time the dataset was cre-
	     ated. 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 multiple -o options.

     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 created 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 operation 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 spec-
	     ified 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 prop-
	     erty is specified in multiple -o options.

     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.

     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	snap-
     shots may be left blank, in which case the	filesystem's oldest 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	snapshots.

     -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 specified, the
	     -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.

     The given bookmark	is destroyed.

     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.

     Roll back the given dataset to a previous snapshot. When a	dataset	is
     rolled back, all data that	has changed since the snapshot is discarded,
     and the dataset reverts to	the state at the time of the snapshot. 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 and	book-
     marks must	be destroyed by	specifying the -r option.

     The -rR options do	not recursively	destroy	the child snapshots of a
     recursive snapshot.  Only direct snapshots	of the specified filesystem
     are destroyed by either of	these options.	To completely roll back	a
     recursive snapshot, you must rollback the individual child	snapshots.

     -r	     Destroy any snapshots and bookmarks more recent than the one
	     specified.

     -R	     Destroy any more recent snapshots and bookmarks, 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.

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

     -p	     Creates all the non-existing parent datasets. Datasets created 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.

     Promotes a	clone file system to no	longer be dependent on its "origin"
     snapshot. This makes it possible to destroy the file system that the
     clone was created from. The clone parent-child dependency relationship 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 snap-
     shot, 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 sub-
     command can be used to rename any conflicting snapshots.

     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 renaming a snap-
     shot, the parent file system of the snapshot does not need	to be speci-
     fied 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.

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

     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 dis-
     played.  Snapshots	are displayed if the listsnaps property	is on (the
     default is	off).  The following fields are	displayed, name, used,
     available,	referenced, mountpoint.

     -r	     Recursively display any children of the dataset on	the command
	     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.

     -p	     Display numbers in	parsable (exact) values.

     -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 specifying -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, snap, volume, bookmark, or all.  For	exam-
	     ple, specifying -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" section, or the spe-
	     cial value	name to	sort by	the dataset name. Multiple properties
	     can be specified at one time using	multiple -s property options.
	     Multiple -s options are evaluated from left to right in decreas-
	     ing 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 literal
		   bottom, regardless of the specified ordering.

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

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

     Sets the property or list of properties to	the given value(s) for each
     dataset.  Only some properties can	be edited. See the "Properties"	sec-
     tion for more information on what properties can be set and acceptable
     values. Numeric values can	be specified as	exact values, or in a human-
     readable 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.

     Displays properties for the given datasets. If no datasets	are specified,
     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, temporary,
		     inherited,	received, or none (-).

     All columns except	the RECEIVED column are	displayed by default. The col-
     umns to display can be specified by using the -o option. This command
     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, snapshot, or	bookmark).

     -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 head-
	     ers are omitted, and fields are explicitly	separated by a single
	     tab instead of an arbitrary amount	of space.

     -p	     Display numbers in	parsable (exact) values.

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

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

     -s	source[,source]...
	     A comma-separated list of sources to display. Those properties
	     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.

     Clears the	specified property, causing it to be inherited from an ances-
     tor, restored to default if no ancestor has the property set, or with the
     -S	option reverted	to the received	value if one exists.  See the
     "Properties" section for a	listing	of default values, and details on
     which properties can be inherited.

     -r	     Recursively inherit the given property for	all children.

     -S	     Revert the	property to the	received value if one exists; other-
	     wise operate as if	the -S option was not specified.

     Remap the indirect	blocks in the given fileystem or volume	so that	they
     no	longer reference blocks	on previously removed vdevs and	we can eventu-
     ally shrink the size of the indirect mapping objects for the previously
     removed vdevs. Note that remapping	all blocks might not be	possible and
     that references from snapshots will still exist and cannot	be remapped.

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

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

     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	ver-
     sions of the software.  "zfs send"	streams	generated from new snapshots
     of	these file systems cannot be accessed on systems running older ver-
     sions of the software.

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

     In	some cases, the	file system version and	the pool version are interre-
     lated and the pool	version	must be	upgraded before	the file system	ver-
     sion can be upgraded.

     -r	     Upgrade the specified file	system and all descendent file sys-
	     tems.

     -V	version
	     Upgrade to	the specified version.	If the -V flag is not speci-
	     fied, 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.

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

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

     Displays all ZFS file systems currently mounted.

     -f

     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 tempo-
	     rarily 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	exe-
	     cuted 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.

     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.

     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 prop-
	     erty. File	systems	are shared when	the sharenfs property is set.

     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.

     Creates a bookmark	of the given snapshot.	Bookmarks mark the point in
     time when the snapshot was	created, and can be used as the	incremental
     source for	a "zfs send" command.

     This feature must be enabled to be	used.  See zpool-features(7) for
     details on	ZFS feature flags and the bookmark feature.

     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 redi-
     rected 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 first snapshot (the
	     incremental source) to the	second snapshot	(the incremental
	     target).  The incremental source can be specified as the last
	     component of the snapshot name (the @ character and following)
	     and it is assumed to be from the same file	system as the incre-
	     mental target.

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

     -I	snapshot
	     Generate a	stream package that sends all intermediary snapshots
	     from the first snapshot to	the second snapshot.  For example, -I
	     @a	fs@d is	similar	to -i @a fs@b; -i @b fs@c; -i @c fs@d.	The
	     incremental source	may be specified as with the -i	option.

     -R, --replicate
	     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, snapshots, descen-
	     dent 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 val-
	     ues 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, --dedup
	     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 regardless of the
	     dataset's dedup property, but performance will be much better if
	     the filesystem uses a dedup-capable checksum (eg.	sha256).

     -L, --large-block
	     Generate a	stream which may contain blocks	larger than 128KB.
	     This flag has no effect if	the large_blocks pool feature is dis-
	     abled, or if the recordsize property of this filesystem has never
	     been set above 128KB.  The	receiving system must have the
	     large_blocks pool feature enabled as well.	 See zpool-features(7)
	     for details on ZFS	feature	flags and the large_blocks feature.

     -e, --embed
	     Generate a	more compact stream by using WRITE_EMBEDDED records
	     for blocks	which are stored more compactly	on disk	by the
	     embedded_data pool	feature.  This flag has	no effect if the
	     embedded_data feature is disabled.	 The receiving system must
	     have the embedded_data feature enabled.  If the lz4_compress fea-
	     ture is active on the sending system, then	the receiving system
	     must have that feature enabled as well.  See zpool-features(7)
	     for details on ZFS	feature	flags and the embedded_data feature.

     -c, --compressed
	     Generate a	more compact stream by using compressed	WRITE records
	     for blocks	which are compressed on	disk and in memory (see	the
	     compression property for details).	 If the	lz4_compress feature
	     is	active on the sending system, then the receiving system	must
	     have that feature enabled as well.	If the large_blocks feature is
	     enabled on	the sending system but the -L option is	not supplied
	     in	conjunction with -c then the data will be decompressed before
	     sending so	it can be split	into smaller block sizes.

     -p, --props
	     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, --dryrun
	     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.	In this	case, the verbose out-
	     put will be written to standard output (contrast with a non-dry-
	     run, where	the stream is written to standard output and the ver-
	     bose output goes to standard error).

     -P, --parsable
	     Print machine-parsable verbose information	about the stream pack-
	     age generated.

     -v, --verbose
	     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.

     Generate a	send stream, which may be of a filesystem, and may be incre-
     mental from a bookmark.  If the destination is a filesystem or volume,
     the pool must be read-only, or the	filesystem must	not be mounted.	 When
     the stream	generated from a filesystem or volume is received, the default
     snapshot name will	be (--head--).

     -i	snapshot|bookmark
	     Generate an incremental send stream.  The incremental source must
	     be	an earlier snapshot in the destination's history.  It will
	     commonly be an earlier snapshot in	the destination's filesystem,
	     in	which case it can be specified as the last component of	the
	     name (the # or @ character	and following).

	     If	the incremental	target is a clone, the incremental source can
	     be	the origin snapshot, or	an earlier snapshot in the origin's
	     filesystem, or the	origin's origin, etc.

     -L, --large-block
	     Generate a	stream which may contain blocks	larger than 128KB.
	     This flag has no effect if	the large_blocks pool feature is dis-
	     abled, or if the recordsize property of this filesystem has never
	     been set above 128KB.  The	receiving system must have the
	     large_blocks pool feature enabled as well.	 See zpool-features(7)
	     for details on ZFS	feature	flags and the large_blocks feature.

     -c, --compressed
	     Generate a	more compact stream by using compressed	WRITE records
	     for blocks	which are compressed on	disk and in memory (see	the
	     compression property for details).	 If the	lz4_compress feature
	     is	active on the sending system, then the receiving system	must
	     have that feature enabled as well.	If the large_blocks feature is
	     enabled on	the sending system but the -L option is	not supplied
	     in	conjunction with -c then the data will be decompressed before
	     sending so	it can be split	into smaller block sizes.

     -e, --embed
	     Generate a	more compact stream by using WRITE_EMBEDDED records
	     for blocks	which are stored more compactly	on disk	by the
	     embedded_data pool	feature.  This flag has	no effect if the
	     embedded_data feature is disabled.	 The receiving system must
	     have the embedded_data feature enabled.  If the lz4_compress fea-
	     ture is active on the sending system, then	the receiving system
	     must have that feature enabled as well.  See zpool-features(7)
	     for details on ZFS	feature	flags and the embedded_data feature.
      Creates a	send stream which resumes an interrupted receive.  The
     receive_resume_token is the value of this property	on the filesystem or
     volume that was being received into.  See the documentation for zfs
     receive -s	for more details.

     Creates a snapshot	whose contents are as specified	in the stream provided
     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 system
     must already exist, and its most recent snapshot must match the incremen-
     tal 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 created. If
     the argument is a file system or volume name, a snapshot with the same
     name as the sent snapshot is created within the specified filesystem or
     volume.  If the -d	or -e option is	specified, the snapshot	name is	deter-
     mined 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 specified, only the tail	of the sent
     snapshot path is appended (for example, 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 (with-
	     out 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 determine
	     the name of the new snapshot as described in the paragraph	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 con-
	     junction with the -v option to verify the name the	receive	opera-
	     tion would	use.

     -o	origin=snapshot
	     Forces the	stream to be received as a clone of the	given snap-
	     shot.  If the stream is a full send stream, this will create the
	     filesystem	described by the stream	as a clone of the specified
	     snapshot. Which snapshot wa

NAME | SYNOPSIS | DESCRIPTION | SUBCOMMANDS

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

home | help