Attachment 204179 Details for Bug 237721 – Exapmle of man page for `12-stable`

Exapmle of man page for `12-stable`

man.txt (text/plain), 100.56 KB, created by John Y. on 2019-05-03 07:38:18 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: John Y.

Created: 2019-05-03 07:38:18 UTC

Size: 100.56 KB

patch

obsolete

>ZFS(8)			  BSD 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 was specified will not affect the	suc-
>	     cess or failure of	the receive, as	long as	the snapshot does
>	     exist.  If	the stream is an incremental send stream, all the nor-
>	     mal verification will be performed.
>
>     -F	     Force a rollback of the file system to the	most recent snapshot
>	     before performing the receive operation. If receiving an incre-
>	     mental replication	stream (for example, one generated by "zfs
>	     send -R {-i | -I}"), destroy snapshots and	file systems that do
>	     not exist on the sending side.
>
>     -s	     If	the receive is interrupted, save the partially received	state,
>	     rather than deleting it.  Interruption may	be due to premature
>	     termination of the	stream (e.g. due to network failure or failure
>	     of	the remote system if the stream	is being read over a network
>	     connection), a checksum error in the stream, termination of the
>	     zfs receive process, or unclean shutdown of the system.
>
>	     The receive can be	resumed	with a stream generated	by zfs send -t
>	     token, where the token is the value of the	receive_resume_token
>	     property of the filesystem	or volume which	is received into.
>
>	     To	use this flag, the storage pool	must have the
>	     extensible_dataset	feature	enabled.  See zpool-features(5)	for
>	     details on	ZFS feature flags.
>      Abort an interrupted zfs receive -s, deleting its	saved partially
>     received state.
>
>
>     Displays permissions that have been delegated on the specified filesystem
>     or	volume.	See the	other forms of "zfs allow" for more information.
>
>
>
>     Delegates ZFS administration permission for the file systems to non-priv-
>     ileged users.
>      Specifies	to whom	the permissions	are delegated. Multiple	entities can
>     be	specified as a comma-separated list. If	neither	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".
>      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.
>      Specifies	where the permissions are delegated. If	neither	of the -ld
>     options are specified, or both are, then the permissions 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 snapshots 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
>    filesystem_limit  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
>    snapshot_limit    property
>    sync	      property
>    utf8only	      property
>    version	      property
>    volblocksize      property
>    volsize	      property
>    vscan	      property
>    xattr	      property
>
>
>Sets "create time" permissions.	These permissions are granted (locally)	to the
>creator	of any newly-created descendent	file system.
>
>
>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. Per-
>mission	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.
>
>
>
>
>Removes	permissions that were granted with the "zfs allow" command. No permis-
>sions 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.
>
>
>Removes	permissions from a permission set. If no permissions are specified,
>then all permissions are removed, thus removing	the set	entirely.
>
>
>Adds a single reference, named with the	tag argument, to the specified snap-
>shot 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 recursively	to the
>	snapshots of all descendent file systems.
>
>
>Lists all existing user	references for the given dataset or datasets.
>
>-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.
>
>-r	Lists the holds	that are set on	the descendent snapshots of the	named
>	datasets or snapshots, in addition to listing the holds	on the named
>	snapshots, if any.
>
>-d depth
>	Recursively display any	holds on the named snapshots, or descendent
>	snapshots of the named datasets	or snapshots, limiting the recursion
>	to depth.
>
>
>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 snapshots	of all
>	descendent file	systems.
>
>
>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 indicating	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 similar 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 parsable tab-separated output, without header	lines and
>	without	arrows.
>
>-t	Display	the path's inode change	time as	the first column of output.
>
>
>Executes script	as a ZFS channel program on pool.  The ZFS channel program
>interface allows ZFS administrative operations to be run programmatically via
>a Lua script.  The entire script is executed atomically, with no other admin-
>istrative operations taking effect concurrently.  A library of ZFS calls is
>made available to channel program scripts.  Channel programs may only be run
>with root privileges.
>
>For full documentation of the ZFS channel program interface, see the manual
>page for zfs-program(8).
>
>-n	Executes a read-only channel program, which runs faster.  The program
>	cannot change on-disk state by calling functions from the zfs.sync
>	submodule.  The	program	can be used to gather information such as
>	properties and determining if changes would succeed (zfs.check.*).
>	Without	this flag, all pending changes must be synced to disk before a
>	channel	program	can complete.
>
>-t timeout
>	Execution time limit, in milliseconds.	If a channel program executes
>	for longer than	the provided timeout, it will be stopped and an	error
>	will be	returned.  The default timeout is 1000 ms, and can be set to a
>	maximum	of 10000 ms.
>
>-m memory-limit
>	Memory limit, in bytes.	 If a channel program attempts to allocate
>	more memory than the given limit, it will be stopped and an error
>	returned.  The default memory limit is 10 MB, and can be set to	a max-
>	imum of	100 MB.
>
>	All remaining argument strings are passed directly to the channel pro-
>	gram as	arguments.  See	zfs-program(8) for more	information.
>
>
>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 functionality, the jail needs the
>allow.mount and	allow.mount.zfs	parameters set to 1 and	the enforce_statfs
>parameter set to a value lower than 2.
>
>See jail(8) for	more information on managing jails and configuring the parame-
>ters above.
>
>
>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	filesystem_limit      none		     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	snapshot_limit	      none		     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
>
>
>       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
>
>
>       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
>
>
>       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
>	 ---- Permissions on tank/cindys --------------------------------------
>	 Local+Descendent permissions:
>		 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
>	 ---- Permissions on tank/users	---------------------------------------
>	 Permission sets:
>		 destroy
>	 Local+Descendent permissions:
>		 group staff create,mount
>
>
>       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
>	 ---- Permissions on tank/users	---------------------------------------
>	 Permission sets:
>		 @pset create,destroy,mount,snapshot
>	 Local+Descendent permissions:
>		 group staff @pset
>
>     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 users/home
>	 ---- Permissions on users/home	---------------------------------------
>	 Local+Descendent permissions:
>		 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
>	 ---- Permissions on tank/users	---------------------------------------
>	 Permission sets:
>		 @pset create,destroy,mount,snapshot
>	 Local+Descendent permissions:
>		 group staff @pset
>
>     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>.
>
>BSD				August 11, 2018				   BSD

Actions: View

Attachments on bug 237721: 204179