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

FreeBSD Manual Pages

  
 
  

home | help
ZFS(8)			    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
       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	[-DnPpRveL] [-i	snapshot | -I snapshot]	snapshot
       zfs send	[-eL] [-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 jail	jailid|jailname	filesystem
       zfs unjail jailid|jailname filesystem

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

	   pool/{filesystem,volume,snapshot}

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

       A dataset can be	one of the following:

       file  system   A	 ZFS  dataset of type filesystem can be	mounted	within
		     the standard system namespace and behaves like other file
		     systems. While ZFS	file systems are designed to be	 POSIX
		     compliant,	 known issues exist that prevent compliance in
		     some cases.  Applications that depend on  standards  con-
		     formance  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 ac-
       tive 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  original  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  de-
       stroy 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 au-
       tomatically  manages  mounting  and unmounting file systems without the
       need to edit the	/etc/fstab file. All automatically managed  file  sys-
       tems 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 prop-
       erty. 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 ad-
       ministrator is responsible for mounting and unmounting the file system.

   Jails
       A ZFS dataset can be attached to	a jail by using	the "zfs jail" subcom-
       mand. You cannot	attach a dataset to one	jail and the children  of  the
       same  dataset to	another	jails. To allow	management of the dataset from
       within a	jail, the jailed property has to be set	and the	jail needs ac-
       cess 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" sub-
       command.

       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 synchro-
       nously. The result is that only unique data is stored and common	compo-
       nents are shared	among files.

   Native Properties
       Properties are divided into two types, native properties	 and  user-de-
       fined  (or "user") properties. Native properties	either export internal
       statistics or control ZFS behavior. In addition,	native properties  are
       either editable or read-only. User properties have no effect on ZFS be-
       havior,	but  you  can  use  them to annotate datasets in a way that is
       meaningful in your environment. For more	information about user proper-
       ties, 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 snap-
       shots).

       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
       lowercase, 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
       properties 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	 prop-
	   erty	 includes  descendant  datasets, and, for clones, does not in-
	   clude the space shared with the origin  snapshot.   For  snapshots,
	   the	compressratio  is  the	same as	the refcompressratio property.
	   Compression can be turned on	by running:  "zfs  set	compression=on
	   dataset" The	default	value is off.

       creation
	   The time this dataset was created.

       clones
	   For	snapshots, this	property is a comma-separated list of filesys-
	   tems	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.

       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 in-
	   clude 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
	   property.

       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 descen-
	   dents. This is the value that is  checked  against  this  dataset's
	   quota  and  reservation.  The  space	 used  does  not  include this
	   dataset's reservation, but does take	into account the  reservations
	   of any descendent datasets. The amount of space that	a dataset con-
	   sumes  from	its  parent,  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
	   snapshots  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 ac-
	   counted for within a	few seconds. Committing	a change to a disk us-
	   ing fsync(2)	or O_SYNC does	not  necessarily  guarantee  that  the
	   space usage information is updated immediately.

       usedby*
	   The usedby* properties decompose the	used properties	into the vari-
	   ous	 reasons   that	  space	  is   used.   Specifically,   used  =
	   usedbysnapshots    +	   usedbydataset    +	  usedbychildren     +
	   usedbyrefreservation.   These  properties  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  par-
	   ticular,  it	 is  the amount	of space that would be freed if	all of
	   this	dataset's snapshots were destroyed. Note that this is not sim-
	   ply 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:

	     	 POSIX name (for example, joe)

	     	 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	privi-
	   lege	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
	   previous 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 snap-
	   shot	in the same filesystem as this dataset.	The snapshot may be  a
	   full	snapshot 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
	   property  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 creation 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 en-
	   tries 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 prop-
	   erty	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 represent 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 un-
	   mounted  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 ap-
	   propriate features on the pool.  Please see	zpool-features(7)  for
	   more	information on these algorithms.

	   Changing this property affects only newly-written data.

       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 de-
	   compression	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 compres-
	   sion	to on uses the lzjb compression	algorithm. The	gzip  compres-
	   sion	 algorithm  uses  the same compression as the gzip(1) command.
	   You can specify the gzip level by using the value gzip-N where N is
	   an integer from 1 (fastest) to 9  (best  compression	 ratio).  Cur-
	   rently, 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 fea-
	   ture	set to enabled.	 See zpool-features(7) for details on ZFS fea-
	   ture	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 prop-
	   erty	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 con-
	   tents 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
	   system. 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  im-
	   poses 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	 prop-
	   erty	 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 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.

       quota=size | none
	   Limits  the	amount of space	a dataset and its descendents can con-
	   sume. 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 an-
	   cestor'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 snap-
	   shots 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	privi-
	   lege	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:

	     	 POSIX name (for example, joe)

	     	 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	privi-
	   lege	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 ad-
	   dition 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
	   single  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	 meta-
	   data.   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 en-
	   forces  a  hard  limit on the amount	of space used. This hard limit
	   does	not include space used by descendents, including file  systems
	   and snapshots.

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

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

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

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

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

       secondarycache=all | none | metadata
	   Controls what is cached in the secondary  cache  (L2ARC).  If  this
	   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 meta-
	   data	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  op-
	   tions  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 ex-
	   port	options	are used. Otherwise, NFS export	options	are equivalent
	   to the contents 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  config-
	   ured	pool log devices.  ZFS will instead optimize synchronous oper-
	   ations 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
			 performance penalty.

	       disabled	 Disables  synchronous	requests. File system transac-
			 tions are only	committed to stable  storage  periodi-
			 cally.	This option will give the highest performance.
			 However,  it is very dangerous	as ZFS would be	ignor-
			 ing the synchronous transaction demands  of  applica-
			 tions	such  as  databases  or	 NFS.	Administrators
			 should	only use this option when the risks are	under-
			 stood.

       volsize=size
	   For volumes,	specifies the logical size of the volume. By  default,
	   creating  a	volume	establishes  a	reservation of equal size. For
	   storage  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 can-
	   not be zero.

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

	   Though not recommended, a "sparse volume" (also known as "thin pro-
	   visioning")	can be created by specifying the -s option to the "zfs
	   create -V" command, or by changing the reservation after the	volume
	   has been created. A "sparse volume" is a volume where the  reserva-
	   tion	 is  less  then	 the  volume  size.  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
	   reservation.

       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,  par-
	   ticipate  in	 RAIDs,	etc, but they are faster, and in some use sce-
	   narios with untrusted consumer, such	as NAS or VM storage,  can  be
	   more	 safe.	Volumes	with property set to none are not exposed out-
	   side	ZFS, but can be	snapshoted, cloned, replicated,	etc, that  can
	   be  suitable	for backup purposes.  Value default means that volumes
	   exposition	is   controlled	   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  cre-
       ated.  If  the  properties  are	not set	with the "zfs create" or zpool
       create  commands,  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 sys-
       tem 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 combination 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  nor-
	     malization	 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 property is automatically set	to  on.	  The  default
	     value  of the normalization property is none.  This property can-
	     not 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  normal-
	     ization  property	must either not	be explicitly set or be	set to
	     none.  The	default	value for the utf8only property	is off.	  This
	     property cannot 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 val-
       ues 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, num-
       bers, 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 sug-
       gested 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
       properties  ("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 de-
       fined in	any parent dataset, it is removed  entirely.  Property	values
       are limited to 1024 characters.

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

       zfs [-?]

	   Displays a help message.

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

	   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 cre-
		   ated	in this	manner are automatically mounted according  to
		   the	mountpoint  property  inherited	from their parent. Any
		   property specified on the command line using	the -o	option
		   is  ignored.	 If  the target	filesystem already exists, the
		   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 created.	Any editable ZFS property can also be  set  at
		   creation time. Multiple -o options can be specified.	An er-
		   ror	results	 if the	same property is specified in multiple
		   -o options.

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

	   Creates a volume of the given size. The volume  is  exported	 as  a
	   block  device in /dev/zvol/path, where path is the name of the vol-
	   ume 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  en-
	   sure	that the volume	has an integral	number of blocks regardless of
	   blocksize.

	   -p	   Creates all the non-existing	parent datasets. Datasets cre-
		   ated	 in this manner	are automatically mounted according to
		   the mountpoint property inherited from  their  parent.  Any
		   property  specified on the command line using the -o	option
		   is ignored. If the target filesystem	 already  exists,  the
		   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
		   specified in	conjunction with -o volblocksize, the  result-
		   ing behavior	is undefined.

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

       zfs destroy [-fnpRrv] filesystem|volume

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

	   -r	   Recursively destroy all children.

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

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

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

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

	   -v	   Print verbose information about the deleted data.

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

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

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

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

	   An inclusive	range of snapshots may be specified by separating  the
	   first and last snapshots with a percent sign	(%).  The first	and/or
	   last	 snapshots  may	 be left blank,	in which case the filesystem's
	   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, includ-
		   ing 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 un-
	   expected behavior for mounted file systems in use.

       zfs destroy filesystem|volume#bookmark

	   The given bookmark is destroyed.

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

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

	   -r	   Recursively create snapshots	of all descendent datasets

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

       zfs rollback [-rRf] snapshot

	   Roll	 back the given	dataset	to a previous snapshot.	When a dataset
	   is rolled back, all data that has changed  since  the  snapshot  is
	   discarded,  and the dataset reverts to the state at the time	of the
	   snapshot. By	default, the command refuses to	roll back to  a	 snap-
	   shot	 other than the	most recent one. In order to do	so, all	inter-
	   mediate snapshots and bookmarks 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.

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

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

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

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

       zfs promote clone-filesystem

	   Promotes a clone file system	to no longer be	dependent on its "ori-
	   gin"	snapshot. This makes it	possible to destroy  the  file	system
	   that	 the clone was created from. The clone parent-child dependency
	   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
	   snapshot, are now owned by the promoted clone. The space  they  use
	   moves  from the origin file system to the promoted clone, so	enough
	   space must be available to  accommodate  these  snapshots.  No  new
	   space  is  consumed	by this	operation, but the space accounting is
	   adjusted. The promoted clone	must not have any conflicting snapshot
	   names of its	own. The rename	subcommand can be used to  rename  any
	   conflicting snapshots.

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

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

       zfs rename -u [-p] filesystem filesystem

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

	   -p	   Creates  all	the nonexistent	parent datasets. Datasets cre-
		   ated	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 sys-
		   tem's mountpoint property is	set to legacy  or  none,  file
		   system is not unmounted even	if this	option is not given.

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

       zfs rename -r snapshot snapshot

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

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

	   Lists  the  property	 information for the given datasets in tabular
	   form. If specified, you can list property information  by  the  ab-
	   solute pathname or the relative pathname. By	default, all file sys-
	   tems	 and  volumes  are  displayed.	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 com-
		   mand	line.

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

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

	   -p	   Display numbers in parsable (exact) values.

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

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

		     	 A user	property

		     	 The value name	to display the dataset name

		     	 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  example,	 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 special value name to sort by  the  dataset
		   name.  Multiple properties can be specified at one time us-
		   ing multiple	-s property options. Multiple -s  options  are
		   evaluated  from left	to right in decreasing order of	impor-
		   tance.

		   The following is a list of sorting criteria:

		     	 Numeric types sort in numeric order.

		     	 String	types sort in alphabetical order.

		     	 Types inappropriate for a row sort that  row  to  the
			 literal bottom, regardless of the specified ordering.

		     	 If  no	sorting	options	are specified the existing be-
			 havior	of "zfs	list" is preserved.

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

       zfs set property=value [property=value]... filesystem|volume|snapshot

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

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

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

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

	   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
		   headers 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 columns.

	   -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 proper-
		   ties	coming from a source other than	those in this list are
		   ignored.   Each  source  must  be  one  of  the  following:
		   local,default,inherited,temporary,received,none.   The  de-
		   fault value is all sources.

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

	   Clears  the	specified property, causing it to be inherited from an
	   ancestor, 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;
		   otherwise operate as	if the -S option was not specified.

       zfs upgrade [-v]

	   Displays a list of file systems that	are not	the most  recent  ver-
	   sion.

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

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

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

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

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

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

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

	   -a	   Upgrade all file systems on all imported pools.

	   filesystem
		   Upgrade the specified file system.

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

	   Displays space consumed by, and quotas on, each user	in the	speci-
	   fied	 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 spec-
		   ified 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  ef-
		   fect	on FreeBSD.

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

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

       zfs mount

	   Displays all	ZFS file systems currently mounted.

	   -f

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

	   Mounts ZFS file systems.

	   -v	   Report mount	progress.

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

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

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

	   filesystem
		   Mount the specified filesystem.

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

	   Unmounts currently mounted ZFS file systems.

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

	   -a	   Unmount all available ZFS file systems.

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

       zfs share -a | filesystem

	   Shares ZFS file systems that	have the sharenfs property set.

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

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

       zfs unshare -a |	filesystem|mountpoint

	   Unshares ZFS	file systems that have the sharenfs property set.

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

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

       zfs bookmark snapshot bookmark

	   Creates a bookmark of the given snapshot.  Bookmarks	mark the point
	   in time when	the snapshot was created, and can be used as  the  in-
	   cremental 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.

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

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

	   -i snapshot
		   Generate an incremental stream from the 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  sys-
		   tem as the incremental target.

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

	   -I snapshot
		   Generate a stream package that sends	all intermediary snap-
		   shots from the 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	   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,  descendent  file	 systems,  and clones are pre-
		   served.

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

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

	   -L	   Generate  a	stream	which  may  contain blocks larger than
		   128KB.  This	flag has no effect if  the  large_blocks  pool
		   feature  is disabled, 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	   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	feature	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.

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

	   -n	   Do a	dry-run	("No-op") send.	 Do not	 generate  any	actual
		   send	data.  This is useful in conjunction with the -v or -P
		   flags  to  determine	what data will be sent.	 In this case,
		   the verbose output will be written to standard output (con-
		   trast with a	non-dry-run, where the stream  is  written  to
		   standard output and the verbose output goes to standard er-
		   ror).

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

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

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

       zfs send	[-eL] [-i snapshot|bookmark] filesystem|volume|snapshot

	   Generate  a	send  stream, which may	be of a	filesystem, and	may be
	   incremental 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	   Generate  a	stream	which  may  contain blocks larger than
		   128KB.  This	flag has no effect if  the  large_blocks  pool
		   feature  is disabled, 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	   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	feature	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.

       zfs send	[-Penv]	-t receive_resume_token
	   Creates  a  send  stream which resumes an interrupted receive.  The
	   receive_resume_token	is the value of	this property on the  filesys-
	   tem	or volume that was being received into.	 See the documentation
	   for zfs receive -s for more details.

       zfs	 receive|recv	    [-vnsFu]	   [-o	      origin=snapshot]
	   filesystem|volume|snapshot

       zfs receive|recv	[-vnsFu] [-d | -e] [-o origin=snapshot]	filesystem

	   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	incremental stream's source. For zvols,	the destination	device
	   link	is destroyed and recreated, which means	the zvol cannot	be ac-
	   cessed during the receive operation.

	   When	a snapshot replication package stream that is generated	by us-
	   ing 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  re-
	   ceived)  that  this subcommand creates depends on the argument type
	   and the -d or -e option.

	   If the argument is a	snapshot name, the specified snapshot is  cre-
	   ated.  If  the argument is a	file system or volume name, a snapshot
	   with	the same name as the sent snapshot is created within the spec-
	   ified filesystem or volume.	If the -d or -e	option	is  specified,
	   the	snapshot  name	is determined by appending the sent snapshot's
	   name	to the specified filesystem.  If the -d	option	is  specified,
	   all	but  the  pool name of the sent	snapshot path is appended (for
	   example, b/c@1 appended from	sent snapshot a/b/c@1),	and if the  -e
	   option is specified,	only the tail of the sent snapshot path	is ap-
	   pended  (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
		   (without pool name) to determine the	name of	the new	 snap-
		   shot	as described in	the paragraph above.

	   -e	   Use	only the last element of the sent snapshot path	to de-
		   termine 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 re-
		   quired to perform the receive operation.

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

	   -o origin=snapshot
		   Forces the stream to	be received as a clone	of  the	 given
		   snapshot.   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 success or failure of the receive, as long
		   as the snapshot does	exist.	If the stream is an  incremen-
		   tal	send  stream, all the normal verification will be per-
		   formed.

	   -F	   Force a rollback of the file	 system	 to  the  most	recent
		   snapshot  before  performing	 the receive operation.	If re-
		   ceiving an incremental 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 un-
		   clean 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.

       zfs receive|recv	-A filesystem|volume
	   Abort  an  interrupted zfs receive -s, deleting its saved partially
	   received state.

       zfs allow filesystem|volume

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

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

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

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

	   [-ug] user|group[, user|group]...
		   Specifies  to  whom the permissions are delegated. Multiple
		   entities can	be specified as	 a  comma-separated  list.  If
		   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".

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

	   [-ld] filesystem|volume
		   Specifies  where  the permissions are delegated. If neither
		   of the -ld options are specified, or	 both  are,  then  the
		   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 snap-
					       shots necessary to 'zfs diff'
	       hold		 subcommand    Allows  adding a	user hold to a
					       snapshot
	       mount		 subcommand    Allows  mount/umount   of   ZFS
					       datasets
	       promote		 subcommand    Must  also have the 'mount' and
					       'promote' ability in the	origin
					       file system
	       receive		 subcommand    Must also have the 'mount'  and
					       'create'	ability
	       release		 subcommand    Allows  releasing  a  user hold
					       which   might	destroy	   the
					       snapshot
	       rename		 subcommand    Must  also have the 'mount' and
					       'create'	 ability  in  the  new
					       parent
	       rollback		 subcommand    Must   also  have  the  'mount'
					       ability
	       send		 subcommand
	       share		 subcommand    Allows  sharing	file   systems
					       over the	NFS protocol
	       snapshot		 subcommand    Must   also  have  the  'mount'
					       ability
	       groupquota	 other	       Allows	   accessing	   any
					       groupquota@... property
	       groupused	 other	       Allows	     reading	   any
					       groupused@... property
	       userprop		 other	       Allows	changing   any	  user
					       property
	       userquota	 other	       Allows	    accessing	   any
					       userquota@... property
	       userused		 other	       Allows reading any userused@...
					       property
	       aclinherit	 property
	       aclmode		 property
	       atime		 property
	       canmount		 property
	       casesensitivity	 property
	       checksum		 property
	       compression	 property
	       copies		 property
	       dedup		 property
	       devices		 property
	       exec		 property
	       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

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

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

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

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

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

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

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

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

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

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

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

       zfs hold	[-r] tag snapshot...

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

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

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

       zfs holds [-Hp] [-r|-d depth] filesystem|volume|snapshot...

	   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.

       zfs release [-r]	tag snapshot...

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

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

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

	   Display the difference between a snapshot of	a given	filesystem and
	   another snapshot of that filesystem from a later time or  the  cur-
	   rent	 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 option-
	   ally	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 sim-
		   ilar	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.

       zfs jail	jailid filesystem

	   Attaches  the  specified  filesystem	 to the	jail identified	by JID
	   jailid.  From now on	this file system  tree	can  be	 managed  from
	   within  a  jail  if	the  jailed property has been set. To use this
	   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 parameters above.

       zfs unjail jailid filesystem

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

EXIT STATUS
       The following exit values are returned:

	 0   Successful	completion.

	 1   An	error occurred.

	 2   Invalid command line options were specified.

EXAMPLES
       Example 1 Creating a ZFS	File System Hierarchy

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

	   # 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	 prop-
	 erties.

	   # 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
	 contents 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
	 following 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 follow-
	 ing 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  in-
	 herit the checksum property from their	parent.

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

       Example 12 Remotely Replicating ZFS Data

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

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

       Example 13 Using	the "zfs receive -d" Option

	 The  following	command	sends a	full stream of poolA/fsA/fsB@snap to a
	 remote	machine, receiving it into  poolB/received/fsA/fsB@snap.   The
	 fsA/fsB@snap  portion	of  the	received snapshot's name is determined
	 from the name of the sent snapshot.  poolB must contain the file sys-
	 tem poolB/received.  If poolB/received/fsA does not exist, it is cre-
	 ated 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	 snap-
	 shots,	and then creates a new snapshot, as follows:

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

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

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

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

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

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

       Example 17 Delegating ZFS Administration	Permissions on a ZFS Dataset

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

	   # zfs allow cindys create,destroy,mount,snapshot tank/cindys
	   # zfs allow tank/cindys
	   ----	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
	 members 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

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

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

	   # 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  man-
       ual  page zfs(1M), modified and customized for FreeBSD and licensed un-
       der the Common Development and Distribution License (CDDL).

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

GNU				 May 31, 2016				ZFS(8)

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

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

home | help