zfs - configures ZFS file systems zfs



  • System Administration Commands					       zfs(1M)
    
    
    
    NAME
           zfs - configures	ZFS file systems
    
    SYNOPSIS
           zfs [-?]
    
    
           zfs help	subcommand | help | property property-name | permission
    
    
           zfs help	-l properties
    
    
           zfs allow filesystem|volume
    
    
           zfs allow [-ldug] everyone|user|group[,...] perm|@setname[,...]
    
    	    filesystem|volume
    
    
           zfs allow [-ld] -e perm|@setname[,...] filesystem|volume
    
    
           zfs allow -c perm|@setname[,...]	filesystem|volume
    
    
           zfs allow -s @setname perm|@setname[,...] filesystem|volume
    
    
           zfs clone [-p] [-K] [-o property=value] ... snapshot filesystem|volume
    
    
           zfs create [-p] [-o property=value] ... filesystem
    
    
           zfs create [-ps]	[-b blocksize] [-o property=value] ... -V size volume
    
    
           zfs destroy [-rRf] filesystem|volume
    
    
           zfs destroy [-rRd] snapshot
    
    
           zfs destroy share
    
    
           zfs diff	[-FHNqrte] [-o field] ... snapshot [snapshot|filesystem]
    
    
           zfs diff	-E [-FHt] [-o field] ... snapshot|filesystem
    
    
           zfs get [-rHpe|-d max][-o all | field[,...]] [-s	source[,...]]
    
    	    all	| property[,...] filesystem|volume|snapshot|share ...
    
    
           zfs get share [filesystem]
    
    
           zfs groupspace [-hniHp] [-o field[,...]]	[-sS field] ...
    
    	    [-t	type [,...]] filesystem|snapshot
    
    
           zfs hold	[-r] tag snapshot...
    
    
           zfs holds [-r] snapshot...
    
    
           zfs key -l {-a |	[-r] filesystem|volume}
    
    
           zfs key -u [-f] {-a | [-r] filesystem|volume}
    
    
           zfs key -c [-o keysource=value] {-a | [-r] filesystem|volume}
    
    
           zfs key -K {-a |	[-r] filesystem|volume}
    
    
           zfs list	[-rH|-d	max][-o	property[,...]]	[-t type[,...]]
    
    	    [-s	property] ... [-S property] ...
    
    	    [filesystem|volume|snapshot|share|path] ...
    
    
           zfs inherit [-rS] property filesystem|volume|snapshot|share ...
    
    
           zfs mount
    
    
           zfs mount [-vOS]	[-o options] -a	| filesystem
    
    
           zfs promote clone-filesystem
    
    
           zfs receive [-vnFu] [[-o	property=value]	| [-x property]] ...
    
    	    filesystem|volume|snapshot
    
    
           zfs receive [-vnFu] [[-o	property=value]	| [-x property]] ...
    
    	    [-d	| -e] filesystem
    
    
           zfs release [-r]	tag snapshot...
    
    
           zfs rename filesystem|volume|snapshot
    
    	    filesystem|volume|snapshot
    
    
           zfs rename [-p] filesystem|volume filesystem|volume
    
    
           zfs rename -r snapshot snapshot
    
    
           zfs rename share	share
    
    
           zfs rollback [-rRf] snapshot
    
    
           zfs send	[-DRbpvn] [-[iI] snapshot] [-s streamsize] snapshot
    
    
           zfs send	-r [-Dbcpvn] [-i snapshot]  [-s	streamsize] snapshot
    
    
           zfs set [-r] property=value filesystem|volume|snapshot ...
    
    
           zfs share -u [-o	property=value]	filesystem%share
    
    
           zfs share filesystem|mountpoint|filesystem%share
    
    
           zfs share -a| -r	| filesystem
    
    
           zfs snapshot [-r] [-o property=value]...
    
    	     filesystem@snapname|volume@snapname
    
    
           zfs unmount [-f]	-a | filesystem|mountpoint
    
    
           zfs unshare filesystem|mountpoint|filesystem%share
    
    
           zfs unshare -a| -r filesystem|
    
    
           zfs upgrade
    
    
           zfs upgrade [-v]
    
    
           zfs upgrade [-r]	[-V version] -a	| filesystem
    
    
           zfs userspace [-hniHp] [-o field[,...]] [-sS field] ...
    
    	    [-t	type [,...]] filesystem|snapshot
    
    
           zfs unallow [-rldug] everyone|user|group[,...] [perm|@setname[,... ]]
    
    	    filesystem|volume
    
    
           zfs unallow [-rld] -e [perm|@setname[,... ]] filesystem|volume
    
    
           zfs unallow [-r]	-c [perm|@setname[ ... ]] filesystem|volume
    
    
           zfs unallow [-r]	-s @setname [perm|@setname[,...	]] filesystem|volume
    
    
    DESCRIPTION
           The  zfs	 command configures ZFS	datasets within	a ZFS storage pool, as
           described in zpool(1M). 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  conformance  might fail due to nonstandard behavior when
    	   checking free file system space.
    
    
           volume
    
    	   A logical volume exported as	a raw or block device.	This  type  of
    	   dataset  should only	be used	under special circumstances. File sys-
    	   tems	are typically used in most environments.
    
    
           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(1M) command.
    
    
           See zpool(1M) for more information on creating and administering	pools.
    
       Snapshots
           A  snapshot  is	a read-only copy of a file system or volume. Snapshots
           can be created extremely	quickly, and initially consume	no  additional
           space  within  the pool.	As data	within the active dataset changes, the
           snapshot	consumes more data than	would otherwise	 be  shared  with  the
           active dataset.
    
    
           Snapshots  can have arbitrary names. Snapshots of volumes can be	cloned
           or rolled back, but cannot be accessed independently.
    
    
           File system snapshots can be accessed under the .zfs/snapshot directory
           in  the root of the file	system.	Snapshots are automatically mounted on
           demand and may be unmounted at regular intervals. The visibility	of the
           .zfs directory can be controlled	by the snapdir property.
    
       Clones
           A  clone	is a writable volume or	file system whose initial contents are
           the same	as another dataset. As with snapshots,	creating  a  clone  is
           nearly instantaneous, and initially consumes no additional space.
    
    
           Clones  can only	be created from	a snapshot. When a snapshot is cloned,
           it creates an implicit dependency between the parent  and  child.  Even
           though  the  clone  is created somewhere	else in	the dataset hierarchy,
           the 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
           destroy the file	system that the	clone was created from.
    
       Mount Points
           Creating	a ZFS file system is a simple operation, so the	number of file
           systems per system is likely to be numerous. To	cope  with  this,  ZFS
           automatically  manages mounting and unmounting file systems without the
           need to edit the	/etc/vfstab 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 edit-
           ing /etc/vfstab). The mountpoint	 property  can	be  inherited,	so  if
           pool/home has a mount point of /export/stuff, then pool/home/user auto-
           matically inherits a mount point	of /export/stuff/user.
    
    
           A file system can be mounted temporarily	at a location other  than  the
           file  systems's	persistent  mount  point  by  specifying the -o	mount-
           point=value option to the zfs mount command. This is only permitted for
           file systems with non-legacy mount points.
    
    
           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,	umount,	/etc/vfstab). If a file	system's mount point is	set to
           legacy, ZFS makes no attempt to manage the file system, and the	admin-
           istrator	is responsible for mounting and	unmounting the file system.
    
       Zones
           The  physical  properties of an added file system are controlled	by the
           global administrator. However, the zone administrator can create,  mod-
           ify,  or	 destroy  files	within the added file system, depending	on how
           the file	system is mounted.
    
    
           A dataset can also be delegated to  a  non-global  zone	by  using  the
           zonecfg	add  dataset  subcommand. You cannot delegate a	dataset	to one
           zone and	the children of	the same dataset to  another  zone.  The  zone
           administrator  can change properties of the dataset or any of its chil-
           dren. However, the quota	property is controlled by the global  adminis-
           trator.
    
    
           A ZFS volume can	be added as a device to	a non-global zone by using the
           zonecfg add device subcommand. However, its physical properties can  be
           modified	only by	the global administrator.
    
    
           For more	information about zonecfg syntax, see zonecfg(1M).
    
    
           After  a	 dataset is delegated to a non-global zone, the	zoned property
           is automatically	set. A zoned file system can only be  mounted  in  the
           global  zone  by	 using a temporary mountpoint property (see "Temporary
           Mount Point Properties").
    
    
           The global administrator	can forcibly clear the zoned property,	though
           this  should be done with extreme care. The global administrator	should
           verify that all the mount points	are  acceptable	 before	 clearing  the
           property.
    
       Deduplication
           Deduplication  is  the process of removing redundant data at the	block-
           level, reducing the total amount	of data	stored.	Deduplication is pool-
           wide; each dataset can opt in or	out using its own dedup	property. If a
           file system has the dedup property enabled, duplicate data  blocks  are
           removed synchronously on	write. The result is that only unique data are
           stored and common components are	shared among files in all datasets  in
           the pool	that have dedup	enabled.
    
       Encryption
           For a full description of ZFS encryption	and the	ZFS encryption syntax,
           see zfs_encrypt(1M).
    
       Native Properties
           Properties are divided into two	types,	native	properties  and	 user-
           defined (or user) properties. Native properties either provide internal
           statistics or control ZFS behavior. In addition,	native properties  are
           either  editable	 or  read-only.	 User properties have no effect	on ZFS
           behavior, but you can use them to annotate datasets in a	 way  that  is
           meaningful in your environment. For more	information about user proper-
           ties, see the "User Properties" section,	below.
    
    
           Every dataset has a set of properties that provide 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 the mountpoint property.
    
    
           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
    
    	   The compression ratio achieved for this  dataset,  expressed	 as  a
    	   multiplier.	Compression  can be turned on by running: zfs set com-
    	   pression=on dataset.	The default value is off.
    
    
           creation
    
    	   The time this dataset was created.
    
    
           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.
    
    
           keychangedate
    
    	   For more information, see zfs_encrypt(1M).
    
    
           keystatus
    
    	   For more information, see zfs_encrypt(1M).
    
    
           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. The origin cannot	be destroyed (even with	the -r
    	   or -f options) so long as a clone exists.
    
    
           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.
    
    
           rekeydate
    
    	   For more information, see zfs_encrypt(1M).
    
    
           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	refreservation
    	   (through usedbyrefreservation) and the reservations of any  descen-
    	   dent	 datasets (through usedbychildren). The	amount of space	that a
    	   dataset consumes 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
    	   accounted for within	a few seconds. Committing a change to  a  disk
    	   using  fsync(3C)  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 =	usedbychildren
    	   + usedbydataset + usedbyrefreservation  +,  usedbysnapshots.	 These
    	   properties  are  only  available for	datasets created on pools that
    	   are version 13 or higher.
    
    
           usedbychildren
    
    	   The amount of space used by children	of this	dataset,  which	 would
    	   be freed if all the dataset's children were destroyed.
    
    
           usedbydataset
    
    	   The	amount	of  space  used	by this	dataset	itself,	which would be
    	   freed if the	 dataset  was  destroyed  (after  first	 removing  any
    	   refreservation  and	destroying  any	necessary snapshots or descen-
    	   dents).
    
    
           usedbyrefreservation
    
    	   The amount of space used by a refreservation	set on	this  dataset,
    	   which would be freed	if the refreservation was removed.
    
    	   Space  accounted for	by this	property represents potential consump-
    	   tion	by future writes, reserved in advance to prevent write alloca-
    	   tion	 failures  in  this  dataset. This can include unwritten data,
    	   space currently shared with snapshots, and compression savings  for
    	   volumes  (which  may	 be  lost when replaced	with less compressible
    	   data). When allocations for later writes increase usedbydataset  or
    	   usedbysnapshots, usedbyrefreservation will decrease accordingly.
    
    
           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.
    
    
           userused@user
    
    	   The amount of space consumed	by the specified user in this dataset.
    	   Space is charged to the owner of each file, as displayed by ls  -l.
    	   The	amount	of space charged is displayed by du and	ls -s. See the
    	   zfs userspace subcommand for	more information.
    
    	   Unprivileged	users can access only their own	space usage. The  root
    	   user,  or  a	 user who has been granted the userused	privilege with
    	   zfs allow, can access everyone's usage.
    
    	   The userused@... properties are not displayed by zfs	get  all.  The
    	   user's  name	 must be appended after	the @ symbol, using one	of the
    	   following forms:
    
    	       o      POSIX name (for example, joe)
    
    	       o      POSIX numeric ID (for example, 789)
    
    	       o      SID name (for example, joe.smith@mydomain)
    
    	       o      SID numeric ID (for example, S-1-123-456-789)
    
    
           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
    	   KB. Any power of 2 from 512 bytes to	1 MB is	valid.
    
    	   This	property can also be referred to by its	shortened column name,
    	   volblock.
    
    
    
           The following native properties can be used to change the behavior of a
           ZFS dataset.
    
           aclmode=discard | mask |	passthrough
    
    	   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 mask reduces user or group permissions. The permissions
    	   are reduced so that they are	no greater than	the  group  permission
    	   bits,  unless it is a user entry that has the same UID as the owner
    	   of the file or directory. In	this case,  the	 ACL  permissions  are
    	   reduced  so	that  they  are	no greater than	owner permission bits.
    	   mask	also preserves the ACL across mode changes (without an explict
    	   ACL	set  [by  means	of chmod(1)] between the mode changes).	A file
    	   system with an aclmode property of passthrough  indicates  that  no
    	   changes will	be made	to the ACL other than generating the necessary
    	   ACL entries to represent the	new mode of the	file or	directory.
    
    
           refreservation=size | none | dense
    
    	   The minimum amount of space guaranteed to a dataset,	not  including
    	   its	descendents.  The default refreservation is none for file sys-
    	   tems.
    
    	   For ZFS volumes, the	 refreservation	 is  automatically  set	 to  a
    	   slightly larger size	than the actual	volume size to account for ZFS
    	   metadata overhead. You can use the dense value  to  reserve	enough
    	   space  for  both data and metadata for the current volume size. For
    	   example, if you need	more space for other  file  systems,  you  can
    	   temporarily	reduce a volume's refreservation value,	which converts
    	   this	to a sparse volume. Then, you can revert the volume  refreser-
    	   vation  value  back	to  the	 original value	when it	was created by
    	   specifying the dense	value.
    
    	   When	the usedbydataset space	is below this value,  the  dataset  is
    	   treated  as	if  it were taking up the amount of space specified by
    	   refreservation. The	usedbyrefreservation  figure  represents  this
    	   extra space,	adding to the total used space charged to the dataset,
    	   and in turn consuming from the parent datasets' usage, quotas,  and
    	   reservations. This protects the dataset from	overcommitment of pool
    	   resources, by ensuring that space for future	writes is reserved  in
    	   advance.
    
    	   Space  shared  with	snapshots can later be replaced	with new data,
    	   and the snapshot represents a committment to	keep both  copies.  If
    	   refreservation  is  set,  usedbyrefreservation must be increased to
    	   the full  size  of  refreservation  when  taking  a	new  snapshot,
    	   accounting  for  this  commitment.  If  there is insufficient space
    	   available to	the dataset for	this increase, snapshot	creation  will
    	   be denied.
    
    	   This	property can also be referred to by its	shortened column name,
    	   refreserv.
    
    
           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 all	 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.
    
    
           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  option is	set, a dataset can only	be mounted and
    	   unmounted explicitly. The dataset is	not mounted automatically when
    	   the	dataset	 is  created or	imported, nor is it mounted by the zfs
    	   mount -a command or unmounted by the	zfs unmount -a command.
    
    	   This	property is not	inherited.
    
    
           checksum=on | off | fletcher2,| fletcher4 | sha256 | sha256+mac
    
    	   Controls the	checksum used to verify	data  integrity.  The  default
    	   value  is  on, which	automatically selects an appropriate algorithm
    	   (currently, fletcher4, but this may change in future	releases). The
    	   value  off  disables	 integrity  checking  on  user data. Disabling
    	   checksums is	NOT a recommended practice.
    
    	   Changing this property affects only newly-written data.
    
    	   The value of	 sha256+mac  is	 only  available  when	encryption  is
    	   enabled.  The checksum property becomes readonly when encryption is
    	   enabled, and	then is	always set to sha256+mac.
    
    
           compression=on |	off | lzjb | gzip | gzip-N | zle | lz4
    
    	   Controls the	compression algorithm used for this dataset. The  lzjb
    	   compression	algorithm is optimized for performance while providing
    	   decent data compression. Setting compression	to on  uses  the  lzjb
    	   compression algorithm. The gzip compression 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). Currently, gzip is equivalent to	gzip-6
    	   (which  is  also the	default	for gzip(1)). lz4 provides better com-
    	   pression than lzjb with lower CPU overhead.
    
    	   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.
    
    	   When	encryption is enabled on a dataset, copies can	be  set	 to  a
    	   maximum of 2.
    
    	   When	 the  dataset is an auto-provisioned ZFS volume, change	of the
    	   copies induces change  to  the  refreservation  as  well.  See  the
    	   "refreservation" for	details.
    
    
           dedup=on	| off |	verify | sha256[,verify]
    
    	   Controls  whether  deduplication  is	 in  effect for	a dataset. The
    	   default value is off. The default checksum used  for	 deduplication
    	   is  sha256  (subject	 to  change). When dedup is enabled, the dedup
    	   checksum algorithm overrides	the  checksum  property.  Setting  the
    	   value to verify is equivalent to specifying sha256,verify.
    
    	   If  the  property  is set to	verify,	then, whenever two blocks have
    	   the same signature, ZFS will	do a byte-for-byte comparison with the
    	   existing block to ensure that the contents are identical.
    
    
           devices=on | off
    
    	   Controls  whether  device  nodes can	be opened on this file system.
    	   The default value is	on.
    
    
           exec=on | off
    
    	   Controls whether processes can be executed from  within  this  file
    	   system. The default value is	on.
    
    
           logbias = latency | throughput
    
    	   Controls  how  ZFS optimizes	synchronous requests for this dataset.
    	   If logbias is set to	latency, ZFS  uses  the	 pool's	 separate  log
    	   devices,  if	any, to	handle the requests at low latency. If logbias
    	   is set to throughput, ZFS does not  use  the	 pool's	 separate  log
    	   devices.  Instead,  ZFS optimizes synchronous operations for	global
    	   pool	throughput and efficient use of	resources. The	default	 value
    	   is latency.
    
    
           mlslabel=label |	none
    
    	   See	the  multilevel	 property for a	description of the behavior of
    	   the mlslabel	property on multilevel	file  systems.	The  following
    	   mlslabel description	applies	to non-multilevel file systems
    
    	   The	mlslabel  property is a	sensitivity label that determines if a
    	   dataset can be mounted in a zone on a system	 with  Trusted	Exten-
    	   sions enabled. If the labeled dataset matches the labeled zone, the
    	   dataset can be mounted and accessed from the	labeled	zone.
    
    	   When	the mlslabel property is not set, the default value  is	 none.
    	   Setting the mlslabel	property to none is equivalent to removing the
    	   property.
    
    	   The mlslabel	property can be	modified only when Trusted  Extensions
    	   is enabled and only with appropriate	privilege. Rights to modify it
    	   cannot be delegated.	When changing a	label to  a  higher  label  or
    	   setting the initial dataset label, the {PRIV_FILE_UPGRADE_SL} priv-
    	   ilege is required. When changing a label to a lower	label  or  the
    	   default (none), the {PRIV_FILE_DOWNGRADE_SL}	privilege is required.
    	   Changing the	dataset	to labels other	than the default can  be  done
    	   only	 when  the  dataset  is	 not  mounted. When a dataset with the
    	   default label is mounted into a labeled-zone, the  mount  operation
    	   automatically sets the mlslabel property to the label of that zone.
    
    	   When	 Trusted  Extensions  is  not  enabled,	only datasets with the
    	   default label (none)	can be mounted.
    
    
           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
    
    	   For more information, see zfs_share(1M).
    
    
           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 includes all space consumed  by  descendents,  including
    	   file	systems	and snapshots. Enforcement of quotas may be delayed by
    	   several seconds. This delay means that  a  user  might  exceed  his
    	   quota  before  the  system notices that the user is over quota. The
    	   system would	then begin to  refuse  additional  writes.  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.
    
    
           sync=standard | always |	disabled
    
    	   Determines the degree to which file system  transactions  are  syn-
    	   chronized.  This  property can be set when a	dataset	is created, or
    	   dynamically,	and will take effect immediately.  This	 property  can
    	   have	one of the following settings:
    
    	   standard
    
    	       The  default  option.  Synchronous file system transactions are
    	       written to the intent log and  then  all	 devices  written  are
    	       flushed	to  ensure  the	data is	stable (that is, not cached by
    	       device controllers).
    
    
    	   always
    
    	       Each file system	transaction is written and flushed  to	stable
    	       storage.	 This  value has a significant performance penalty but
    	       might be	appropriate for	troubleshooting	synchronous file  sys-
    	       tem transactions.
    
    
    	   disabled
    
    	       Synchronous  requests  are  disabled.  File system transactions
    	       commit to stable	storage	only on	the next DMU transaction group
    	       commit,	which  might be	after many seconds. This setting gives
    	       the highest performance.	However, it is very dangerous  as  ZFS
    	       would be	ignoring the synchronous transaction demands of	appli-
    	       cations such as databases or NFS. Furthermore, when  this  set-
    	       ting  is	 in  effect  for  the  currently  active  root or /var
    	       filesystem, out-of-spec behavior, application  data  loss,  and
    	       increased  vulnerability	to replay attacks can result. Adminis-
    	       trators should only use this option only	when these  risks  are
    	       understood.
    
    
    
           defaultuserquota=size | none
    
    	   Sets	 the default user quota. The default value is none. This value
    	   will	apply to all users who do not have an explicit userquota spec-
    	   ified.
    
    
           defaultgroupquota=size |	none
    
    	   Sets	the default group quota. The default value is none. This value
    	   will	apply to all groups who	do  not	 have  an  explicit  userquota
    	   specified.
    
    
           userquota@user=size | none | default
    
    	   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	her quota  before  the	system
    	   notices  that  she  is  over	 quota.	The system would then begin to
    	   refuse additional writes with the EDQUOT error message  .  See  the
    	   zfs 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:
    
    	       o      POSIX name (for example, joe)
    
    	       o      POSIX numeric ID (for example, 789)
    
    	       o      SID name (for example, joe.smith@mydomain)
    
    	       o      SID numeric ID (for example, S-1-123-456-789)
    	   A value of default resets the quota to the default value defined by
    	   the defaultuserquota	property.
    
    
           groupquota@group=size | none | default
    
    	   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.
    
    	   A value of default resets  the  groupquota  to  the	default	 value
    	   defined by the defaultgroupquota property.
    
    
           readonly=on | off
    
    	   Controls whether this dataset can be	modified. The default value is
    	   off.
    
    	   This	property can also be referred to by its	shortened column name,
    	   rdonly.
    
    
           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 default recordsize is 128 KB. The  size	specified  must	 be  a
    	   power of two	greater	than or	equal to 512 and less than or equal to
    	   1 MB.
    
    	   Changing the	file system's recordsize affects  only	files  created
    	   afterward; existing files and received data are unaffected.
    
    	   This	property can also be referred to by its	shortened column name,
    	   recsize.
    
    
           refquota=size | none
    
    	   Limits the amount of	space a	dataset	can consume. This  limit  does
    	   not	include	 space used by descendents, including file systems and
    	   snapshots. Enforcement of refquotas may be delayed by several  sec-
    	   onds.  This	delay  means that a user might exceed his quota	before
    	   the system notices that the user is over quota.  The	 system	 would
    	   then	begin to refuse	additional writes.
    
    
           refreservation=size | none | auto
    
    	   The	minimum	amount of space	guaranteed to a	dataset, not including
    	   its descendents.
    
    	   The default refreservation is auto for ZFS  volumes	and  none  for
    	   other  types	 of  datasets.	When  refreservation= auto, sufficient
    	   space is reserved for the volume to	store  its  designated	volume
    	   size	 (volsize) and associated metadata. This effective reservation
    	   depends on both volsize and copies properties. A volume can also be
    	   manually provisioned	by setting refreservation to a numeric value (
    	   for example,	zfs set	refreservation=10g). Because of	metadata,  the
    	   actual  space  that	is guaranteed for volume data will be slightly
    	   less	than the requested numeric  refreservation.  A	sparse	volume
    	   (for	 example,  when	-s is specified	at volume creation) is equiva-
    	   lent	to one with a refreservation of	none. Note  that,  refreserva-
    	   tion=auto applies only to ZFS volumes.
    
    	   Space  that is reserved for a volume	but that is not	currently used
    	   by that volume is accounted for in usedbyrefreservation. Thus,  the
    	   effective  total  refreservation for	a zfs volume is	always the sum
    	   of usedbydataset and	usedbyrefreservation. This entire sum consumes
    	   from	 the  parent  datasets'	 usage,	quotas,	and reservations. This
    	   protects each dataset from overcommitment  of  pool	resources,  by
    	   ensuring that space for future writes is reserved in	advance.
    
    	   Space  shared  with	snapshots can later be replaced	with new data,
    	   and the snapshot represents a committment to	keep both  copies.  If
    	   refreservation  is  set,  usedbyrefreservation must be increased to
    	   the full  size  of  refreservation  when  taking  a	new  snapshot,
    	   accounting  for  this  commitment.  If  there is insufficient space
    	   available to	the dataset for	this increase, snapshot	creation  will
    	   be denied.
    
    	   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.
    
    
           rstchown=on | off
    
    	   Indicates whether the file system restricts users from giving  away
    	   their  files	 by means of chown(1) or the chown(2) system call. The
    	   default is to restrict chown. When rstchown is off then chown  will
    	   act as if the user has the PRIV_FILE_CHOWN_SELF privilege.
    
    
           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.
    
    
           shadow=URI | none
    
    	   Identifies a	ZFS file  system  as  a	 shadow	 of  the  file	system
    	   described by	the URI. Data is migrated to a shadow file system with
    	   this	property set from the file system identified by	the  URI.  The
    	   file	 system	to be migrated must be read-only for a complete	migra-
    	   tion.
    
    	   Access to a directory that is not yet migrated in the  shadow  file
    	   system is blocked until the entire directory	is migrated. Access to
    	   a file that is not yet migrated in the shadow  file	system	causes
    	   only	 a portion of the file being accessed to be migrated. Multiple
    	   processes can migrate different portions of	a  file	 at  the  same
    	   time.
    
    	   Two	forms of URI are accepted, one for migrating a local file sys-
    	   tem to another file system on the same physical system, and one for
    	   remotely migrating a	file system from an NFS	server.	The forms are:
    
    	     file:///path
    
    	     nfs://host/path
    
    
    	   If shadowd(1M) is still running when	the migration is complete, the
    	   file	system is automatically	remounted with the shadow property set
    	   to  none.  Or, when the migration is	complete, you can manually set
    	   the shadow property to none.
    
    
           sharenfs=on | off
    
    	   For more information, see zfs_share(1M).
    
    
           sharesmb=on | off
    
    	   For more information, see zfs_share(1M).
    
    
           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.
    
    
           version=1 | 2 | current
    
    	   The on-disk version of this file system, which  is  independent  of
    	   the	pool version. This property can	only be	set to later supported
    	   versions. See the zfs upgrade command.
    
    
           volsize=size
    
    	   Specifies the logical size of the volume. By	 default,  creating  a
    	   volume  establishes a refreservation	that is	a somewhat larger than
    	   the actual logical volume size, to account for ZFS  metadata	 over-
    	   head.  Any changes to volsize are reflected in an equivalent	change
    	   to the refreservation. The volsize can only be set to a multiple of
    	   volblocksize, and cannot be zero.
    
    	   The	refreservation	is  set	 on  the  volume to prevent unexpected
    	   behavior for	consumers. Without the reservation, the	 volume	 could
    	   run	out  of	space, resulting in undefined behavior or data corrup-
    	   tion, depending on how the volume is	used. These effects  can  also
    	   occur  when the volume size is changed while	it is in use (particu-
    	   larly when shrinking	the size). Extreme care	should	be  used  when
    	   adjusting  the  volume  size.  If  the  volume is auto-provisioned,
    	   change of its size also induces a change to the refreservation. For
    	   more	information, see the "refreservation" section for details.
    
    	   Though  not recommended, a sparse volume (also known	as thin	provi-
    	   sioning) can	be created by specifying the -s	option to the zfs cre-
    	   ate	-V  command. A sparse volume is	a volume where the reservation
    	   is less then	the volume size. Consequently, writes to a sparse vol-
    	   ume	can  fail  with	 ENOSPC	 when  the pool	is low on space. For a
    	   sparse volume, changes to volsize are not reflected in the reserva-
    	   tion.
    
    
           vscan=on	| off
    
    	   For more information, see zfs_share(1M).
    
    
           xattr=on	| off
    
    	   Controls whether extended attributes	are enabled for	this file sys-
    	   tem.	The default value is on.
    
    
           zoned=on	| off
    
    	   Controls whether the	dataset	is managed from	a non-global zone. See
    	   the "Zones" section for more	information. The default value is off.
    
    
    
           The  following  properties  cannot  be changed after the	file system is
           created and, therefore, should be set when the file system is  created.
           If  the properties are not set with the zfs create or zpool create com-
           mands, these properties are inherited from the parent dataset.  If  the
           parent  dataset lacks these properties due to having been created prior
           to these	features being supported, the new file system  will  have  the
           default values for these	properties.
    
           casesensitivity=sensitive | insensitive | mixed
    
    	   For more information, see zfs_share(1M).
    
    
           normalization = none | formC | formD | formKC | formKD
    
    	   For more information, see zfs_share(1M).
    
    
           utf8only=on | off
    
    	   For more information, see zfs_share(1M).
    
    
           encryption=off |	on | aes-128-ccm | aes-192-ccm | aes-256-ccm |
           aes-128-gcm | aes-192-gcm | aes-256-gcm
    
    	   For more information, see zfs_encrypt(1M).
    
    
           multilevel=on | off
    
    	   This	property can only be used on a system with Trusted  Extensions
    	   enabled. The	default	value is off.
    
    	   Objects  in	a multilevel file system are individually labeled with
    	   an explicit sensitivity label attribute that	is automatically  gen-
    	   erated.  Objects  can  be relabeled in place	by changing this label
    	   attribute, by using the setlabel(1) or setflabel(3TSOL) interfaces.
    
    	   Zone	datasets, system root datasets,	and other datasets  containing
    	   packaged Solaris code should	not be multilevel.
    
    	   There  are  differences in the mlslabel property on multilevel file
    	   systems. The	mlslabel value defines the highest possible label that
    	   objects  in	the file system	can have. Attempts to create a file at
    	   (or relabel a file to) a label higher than the mlslabel are	disal-
    	   lowed.  Mount policy	based on mlslabel does not apply to multilevel
    	   file	systems.
    
    	   For multilevel file systems,	 the  mlslabel	property  can  be  set
    	   explicitly  during file system creation, otherwise a	default	mlsla-
    	   bel property	of ADMIN_HIGH will  be	automatically  created.	 After
    	   creating a multilevel file system, the mlslabel can be changed, but
    	   it cannot be	changed	to a lower label, nor be removed, nor  set  to
    	   none.
    
    
    
           The following property must be specified	at creation time and can modi-
           fied by using special commands:
    
           keysource=raw | hex | passphrase,prompt | file
    
    	   For more information, see zfs_encrypt(1M).
    
    
       Temporary Mount Point Properties
           When a file system is mounted, either through the legacy	mount(1M) com-
           mand  or	 the zfs mount command,	its mount options are set according to
           its properties. The correlation between properties and mount options is
           as follows:
    
    	     PROPERTY		     MOUNT OPTION
    
    	      devices		      devices/nodevices
    
    	      mountpoint	      mountpoint
    
    	      exec		      exec/noexec
    
    	      readonly		      ro/rw
    
    	      setuid		      setuid/nosetuid
    
    	      xattr		      xattr/noxattr
    
    	      rstchown		      rstchown/norstchown
    
    
    
    
           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.	The -nosuid option is an alias for  nodevices,nosetuid.	 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. If the	property being modified	is the
           mountpoint, the dataset will be immediately unmounted from  the	tempo-
           rary mountpoint and remounted at	the new	persistent mountpoint.
    
       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. In the Ora-
           cle Solaris release, the	com.oracle user	property is reserved for beadm
           command and library
    
    
           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
           defined in any parent dataset, it is removed entirely. Property	values
           are limited to 1024 characters.
    
       ZFS Volumes as Swap or Dump Devices
           During  an initial installation,	a swap device and dump device are cre-
           ated on ZFS volumes in the ZFS root pool. Separate ZFS volumes must  be
           used for	the swap area and dump devices.	Do not swap to a file on a ZFS
           file system. A ZFS swap file configuration is not supported.
    
    
           You can encrypt a ZFS volume used as a swap device  by  specifying  the
           encryption property for that device and specifying the encrypted	option
           in vfstab(4). For more information about	the encryption	property,  see
           zfs_encrypt.1m.
    
    
           If you need to change your swap area or dump device after the system is
           installed or upgraded, use the swap(1M) and  dumpadm(1M)	 commands.  If
           you  need  to change the	size of	your swap area or dump device, see the
           Managing	ZFS File Systems in Oracle Solaris 11.3
    
    SUBCOMMANDS
           All subcommands that modify state are logged persistently to  the  pool
           in their	original form.
    
           zfs ?
    
    	   Displays a help message.
    
    
           zfs help	command	| help | property property-name	| permission
    
    	   Displays  zfs command usage information. You	can display help for a
    	   specific command, property, or delegated permission.	If you display
    	   help	 for  a	 specific  command  or property, the command syntax or
    	   property value is displayed.	Using zfs help without	any  arguments
    	   displays a complete list of zfs commands.
    
    
           zfs help	-l properties
    
    	   Displays  zfs  property information,	including whether the property
    	   value is editable and inheritable, and their	possible values.
    
    
           zfs allow filesystem | volume
           zfs allow [-ldug] everyone|user|group[,...] perm|@setname[,...]
           filesystem| volume
           zfs allow [-ld] -e perm|@setname[,...] filesystem | volume
           zfs allow -c perm|@setname[,...]	filesystem|volume
           zfs allow -s @setname perm|@setname[,...] filesystem|volume
    
    	   For	a  full	 description of	the zfs	allow syntax and examples, see
    	   zfs_allow(1M).
    
    
           zfs clone [-p] [-K] [-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  created
    	       in  this	 manner	 are  automatically  mounted  according	to the
    	       mountpoint property inherited from their	parent.	If the	target
    	       file  system  or	volume already exists, the operation completes
    	       successfully.
    
    
    	   -o property=value
    
    	       Sets the	specified property; see	zfs create for details.
    
    
    	   -K
    
    	       For information,	see zfs_encrypt(1M).
    
    
    
           zfs create [-p] [-o property=value] ... filesystem
    
    	   Creates a new ZFS file system. The  file  system  is	 automatically
    	   mounted  according  to  the	mountpoint property inherited from the
    	   parent.
    
    	   -p
    
    	       Creates all the non-existing parent datasets. Datasets  created
    	       in  this	 manner	 are  automatically  mounted  according	to the
    	       mountpoint property inherited from their	parent.	 Any  property
    	       specified  on  the command line using the -o option is ignored.
    	       If the target filesystem	already	 exists,  the  operation  com-
    	       pletes successfully.
    
    
    	   -o property=value
    
    	       Sets  the  specified  property  as if the command zfs set prop-
    	       erty=value was invoked at the same time the  dataset  was  cre-
    	       ated.  Any  editable  ZFS  property can also be set at creation
    	       time. Multiple -o options can be	specified. An error results if
    	       the same	property is specified in multiple -o options.
    
    
    
           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/{dsk,rdsk}/path, where path is  the  name
    	   of the volume in the	ZFS namespace. The size	represents the logical
    	   size	as exported by the device. By default, a reservation of	 equal
    	   size	is created.
    
    	   size	 is  automatically  rounded up to the nearest 128 KB to	ensure
    	   that	the volume has an integral  number  of	blocks	regardless  of
    	   blocksize.
    
    	   -p
    
    	       Creates	all the	non-existing parent datasets. Datasets created
    	       in this manner  are  automatically  mounted  according  to  the
    	       mountpoint  property  inherited from their parent. Any property
    	       specified on the	command	line using the -o option  is  ignored.
    	       If  the	target	filesystem  already exists, the	operation com-
    	       pletes successfully.
    
    
    	   -s
    
    	       Creates a sparse	volume with no reservation. See	volsize	in the
    	       Native  Properties  section  for	 more information about	sparse
    	       volumes.
    
    
    	   -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 multiple -o options.
    
    
    	   -b blocksize
    
    	       Equivalent to -o	 volblocksize=blocksize.  If  this  option  is
    	       specified  in  conjunction  with	-o volblocksize, the resulting
    	       behavior	is undefined.
    
    
    
           zfs destroy [-rRf] 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 sys-
    	       tems outside the	target hierarchy.
    
    
    	   -f
    
    	       Force an	unmount	of any file systems using the unmount -f  com-
    	       mand.  This  option  has	 no  effect  on	 non-file  systems  or
    	       unmounted file systems.
    
    	   Extreme care	should be taken	when applying either the -r or the  -f
    	   options,  as	 they  can  destroy large portions of a	pool and cause
    	   unexpected behavior for mounted file	systems	in use.
    
    
           zfs destroy [-rRd] snapshot
    
    	   The given snapshot is 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  the  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.
    
    	   -d
    
    	       Defer snapshot deletion.
    
    
    	   -r
    
    	       Destroy (or mark	for deferred deletion) all snapshots with this
    	       name in descendent file systems.
    
    
    	   -R
    
    	       Recursively destroy all dependents.
    
    
    
           zfs destroy [share
    
    	   The specified file system share is destroyed.
    
    
           zfs diff	[-FHNqrte] [-o field] ... snapshot [snapshot | filesystem]
           zfs diff	-E [-FHNqrt] [-o field]	... snapshot | filesystem
    
    	   Gives  a  high-level	description of the differences between a snap-
    	   shot	and a descendent dataset. The descendent can be	either a snap-
    	   shot	of the dataset or the current dataset.
    
    	   If  a  single  snapshot is specified, then differences between that
    	   snapshot and	the current dataset are	given.
    
    	   For each file that has undergone  a	change	between	 the  original
    	   snapshot  and the descendent, the type of change is described along
    	   with	the name of the	file. In the case of a rename,	both  the  old
    	   and	new  names are shown. Whitespace characters, backslash charac-
    	   ters, and other non-printable or non-7-bit ASCII  characters	 found
    	   in  file  names  are	displayed as a backslash character followed by
    	   the three-digit octal representation	of the byte value.
    
    	   If the -t option is specified, the first column of output from  the
    	   command is the file's st_ctim value.	For deleted files, this	is the
    	   final st_ctim in the	earlier	snapshot.
    
    	   The	type  of  change  follows  any	timestamp  displayed,  and  is
    	   described with a single character:
    
    	   +	Indicates the file was added in	the later dataset.
    
    
    	   -	Indicates the file was removed in the later dataset.
    
    
    	   M	Indicates the file was modified	in the later dataset.
    
    
    	   R	Indicates the file was renamed in the later dataset.
    
    	   If  the -F option is	specified, the next column of output is	a sin-
    	   gle character describing the	type of	the file. The mappings are:
    
    	   F	Regular	file
    
    
    	   /	Directory
    
    
    	   B	Block device
    
    
    	   >	Door
    
    
    	   |	FIFO
    
    
    	   @	Symbolic link
    
    
    	   P	Event portal
    
    
    	   =	Socket
    
    	   If the modification involved	a change in the	link count of  a  non-
    	   directory file, the change is expressed as a	delta within parenthe-
    	   ses on the modification line. If the	file was renamed, the old name
    	   is separated	from the new with the string ->.
    
    	   If  the  -H option is selected, easier-to-parse output is produced.
    	   Fields are separated	by a single tab, and no	arrow string  (->)  is
    	   placed between the old and new names	of a rename. No	guarantees are
    	   made	on the spacing between fields of non -H	output.
    
    	   If the -e option is selected, then  all  files  added  or  modified
    	   between  the	 two snapshots are enumerated and no deleted files are
    	   displayed. The change type always reports as	+  regardless  of  the
    	   type	of modification.
    
    	   If the -E option is selected, then differences are given as if from
    	   an empty snapshot to	the specified snapshot or dataset.
    
    	   If the -r option is selected, the differences between  the  dataset
    	   and all the children	datasets are displayed recursively. If a snap-
    	   shot	is given as a parameter, that snapshot name must exist for all
    	   the	children  datasets.  Otherwise,	 warnings  will	 be issued for
    	   datasets not	containing the snapshot. If  the  -q  option  is  also
    	   selected, these warnings will be silenced.
    
    	   If  the  -N	option	is  selected  with  -r,	then all the new child
    	   datasets added to the current dataset  will	be  enumerated,	 along
    	   with	the differences	among the existing datasets.
    
    	   If  the  -o	field option is	selected then only selected fields are
    	   displayed. Each line	starts with the	standard fields	 requested  by
    	   the	-F and -t options, followed by the fields requested in succes-
    	   sive	-o options. As with the	-H option, all fields are separated by
    	   a single tab. The allowable field names include:
    
    	   object	  The number printed by	ls -i for the file
    
    
    	   parent	  The  number printed by ls -i for enclosing directory
    			  of the file
    
    
    	   size		  The file size	as displayed by	ls -s
    
    
    	   links	  The number of	links to the file
    
    
    	   linkschange	  The change in	the number of links to the file
    
    
    	   name		  The name of the file
    
    
    	   oldname	  The name of  the  file  before  the  rename,	or  --
    			  (hyphen) if the file was not renamed
    
    
    	   user		  The owner name of the	file as	displayed by ls
    
    
    	   group	  The group name of the	file as	displayed by ls
    
    
    	   ctime	  Timestamp when the file's metadata was last modified
    
    
    	   mtime	  Timestamp when the file was last modified
    
    
    	   atime	  Timestamp when a file	was last accessed
    
    
    	   crtime	  Timestamp when a file	was created
    
    	   You	must be	granted	the diff permission with zfs allow to use this
    	   subcommand,	unless	you  already  have  the	 {PRIV_SYS_CONFIG}  or
    	   {PRIV_SYS_MOUNT} privilege.
    
    
           zfs get [-rHpe|-d max] [-o all |	field[,...] [-s	source[,...]] all |
           property[,...] filesystem|volume|snapshot|share ...
    
    	   Displays properties for the given  datasets.	 If  no	 datasets  are
    	   specified, then the command displays	properties for all datasets on
    	   the system. For each	property, the following	columns	are displayed:
    
    		  name	    Dataset name
    
    		  property  Property name
    
    		  value	    Property value
    
    		  source    Property source. Can either	be local, default,
    
    			    temporary, inherited, or none (-).
    
    
    	   All columns except the RECEIVED column are  displayed  by  default;
    	   specify  particular	or all columns,	using the -o option. This com-
    	   mand	takes a	comma-separated	list of	properties as described	in the
    	   "Native Properties" and "User Properties" sections.
    
    	   The	special	 value	all can	be used	to display all properties that
    	   apply to the	given dataset's	type  (filesystem,  volume,  or	 snap-
    	   shot).
    
    	   -r
    
    	       Recursively display properties for any 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
    
    	       Displays	numbers	in parseable (exact) values.
    
    
    	   -e
    
    	       Expands property	sublists to any	depth.
    
    
    	   -d max
    
    	       Recursively  displays any children of the dataset, limiting the
    	       recursion to depth. A depth of 1	will display only the  dataset
    	       and its direct children.
    
    
    	   -o field
    
    	       Set of fields to	display. One or	more of:
    
    		 name,property,value,received,source
    
    
    	       Present	multiple fields	as a comma-separated list. The default
    	       value is:
    
    		 name,property,value,source
    
    
    	       The keyword all specifies all sources.
    
    
    	   -s source
    
    	       A comma-separated list of sources to display. Those  properties
    	       coming from a source other than those in	this list are ignored.
    	       Each source must	be one of the following:
    
    		 local,default,inherited,temporary,received,none
    
    
    	       The default value is all	sources.
    
    
    
           zfs groupspace [-hniHp] [-o field[,...]]	[-sS field]... [-t 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	posix-
    	   group,smbgroup.
    
    	     -
    
    
    
    
           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	names-
    	   pace, 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 return EBUSY.
    
    	   -r
    
    	       Specifies that a	hold with the given tag	is applied recursively
    	       to the snapshots	of all descendent file systems.
    
    
    
           zfs holds [-r] snapshot ...
    
    	   Lists all existing user references for the given snapshot or	 snap-
    	   shots.
    
    	   -r
    
    	       Lists the holds that are	set on the named descendent snapshots,
    	       in addition to listing the holds	on the named snapshot.
    
    
    
           zfs inherit [-rS] property filesystem|volume|snapshot|share ...
    
    	   Clears the specified	property, causing it to	be inherited  from  an
    	   ancestor.  If  no  ancestor	has the	property set, then the default
    	   value is used. See  the  "Properties"  section  for	a  listing  of
    	   default values, and details on which	properties can be inherited.
    
    	   -r
    
    	       Recursively inherits the	given property for all children.
    
    
    	   -S
    
    	       Reverts to the received property	value, if any. If the property
    	       does not	have a received	value, the behavior of zfs inherit  -S
    	       is  the	same  as  zfs inherit without -S. If the property does
    	       have a received value, zfs inherit  masks  the  received	 value
    	       with  the  inherited  value until zfs inherit -S	reverts	to the
    	       received	value.
    
    
    
           zfs key -l | {-a	| [-r] filesystem|volume}
           zfs key -u [-f] | {-a | [-r] filesystem|volume
           zfs key -c [-o keysource=value] {-a | [-r] filesystem|volume}
           zfs key -K {-a |	[-r] filesystem|volume}
    
    	   For a full description of the zfs  key  syntax  and	examples,  see
    	   zfs_encrypt(1M).
    
    
           zfs list	[-rH|-d	max] [-o property[,...]] [ -t type[,...]] [ -s prop-
           erty ] ... [ -S property	] ... [filesystem|volume|snapshot|share|path]
           ...
    
    	   Lists  the  property	 information for the given datasets in tabular
    	   form. If specified, you can list property information by the	 abso-
    	   lute	 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.
    
    	   -H
    
    	       Used for	scripting mode.	Do  not	 print	headers	 and  separate
    	       fields by a single tab instead of arbitrary white space.
    
    
    	   -r
    
    	       Recursively displays any	children of the	dataset	on the command
    	       line.
    
    
    	   -d depth
    
    	       Recursively displays any	children of the	dataset, limiting  the
    	       recursion  to maximum depth. A depth of 1 will display only the
    	       dataset and its direct children.
    
    
    	   -o property
    
    	       A comma-separated list of properties to display.	 The  property
    	       must be:
    
    		   o	  One of the properties	described in the "Native Prop-
    			  erties" section
    
    		   o	  A user property
    
    		   o	  The value name to display the	dataset	name
    
    		   o	  The value space to display space usage properties on
    			  file	systems	 and  volumes.	This is	a shortcut for
    			  specifying  -o  name,avail,used,usedsnap,usedds,use-
    			  drefreserv,usedchild -t filesystem,volume syntax.
    
    
    	   -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	 prop-
    	       erties  can be specified	at one time using multiple -s property
    	       options.	Multiple -s options are	evaluated from left  to	 right
    	       in decreasing order of importance.
    
    	       The following is	a list of sorting criteria:
    
    		   o	  Numeric types	sort in	numeric	order.
    
    		   o	  String types sort in alphabetical order.
    
    		   o	  Types	 inappropriate	for a row sort that row	to the
    			  literal bottom, regardless of	the  specified	order-
    			  ing.
    
    		   o	  If  no  sorting  options  are	specified the existing
    			  behavior of zfs list is preserved.
    
    
    	   -S property
    
    	       Same as the -s option, but  sorts  by  property	in  descending
    	       order.
    
    
    	   -t type
    
    	       A  comma-separated  list	of types to display, where type	is one
    	       of filesystem, snapshot , volume, or all. For example, specify-
    	       ing  -t snapshot	displays only snapshots. The following aliases
    	       can be used in place of the type	specifiers:  fs	 (filesystem),
    	       snap (snapshot),	and vol	(volume).
    
    
    
           zfs mount
    
    	   Displays all	ZFS file systems currently mounted.
    
    
           zfs mount [-vOS]	[-o options] -a	| filesystem
    
    	   Mounts  ZFS file systems. Invoked automatically as part of the boot
    	   process.
    
    	   -o options
    
    	       An optional, comma-separated list of mount options to use  tem-
    	       porarily	 for  the  duration  of	 the mount. See	the "Temporary
    	       Mount Point Properties" section for details.
    
    
    	   -O
    
    	       Perform an overlay mount. See mount(1M) for more	information.
    
    
    	   -v
    
    	       Report mount progress.
    
    
    	   -a
    
    	       Mount all available ZFS file systems. Invoked automatically  as
    	       part of the boot	process.
    
    
    	   filesystem
    
    	       Mount the specified filesystem.
    
    	       A zfs mount operation for an encrypted dataset might prompt you
    	       for a key, depending on	the  keysource	property  value.  This
    	       might  occur,  for  example, if the keysource locator is	set to
    	       prompt.
    
    
    
           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 receive [-vnFu] [[-o	property=value]	| [-x property]] ... filesys-
           tem|volume|snapshot
           zfs receive [-vnFu] [[-o	property=value]	| [-x property]] ... [-d | -e]
           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 ZFS volumes, the destination
    	   device link is destroyed and	recreated, which means the volume can-
    	   not be accessed during the receive operation.
    
    	   When	 a  snapshot  replication  package stream that is generated by
    	   using the zfs send -R command is received, any  snapshots  that  do
    	   not	exist  on  the sending location	are destroyed by using the zfs
    	   destroy -d command. If -o property=value or -x property  is	speci-
    	   fied,  it applies to	the effective value of the property throughout
    	   the entire subtree of replicated datasets. Effective	property  val-
    	   ues	may be set or inherited, depending on the property and whether
    	   the dataset is the topmost  in  the	replicated  subtree.  Received
    	   properties  are  retained  in  spite	of being overridden and	may be
    	   restored with zfs inherit -rS or zfs	send -Rb.
    
    	   The name of the snapshot (and file system,  if  a  full  stream  is
    	   received) that this subcommand creates depends on the argument type
    	   and the -d or -e option.
    
    	   If the argument is a	snapshot name, the specified snapshot is  cre-
    	   ated.  If  the argument is a	file system or volume name, a snapshot
    	   with	the same name as the sent snapshot is created within the 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
    	   appended (for example, c@1 appended from sent snapshot a/b/c@1). In
    	   the case of -d, any file systems needed to replicate	 the  path  of
    	   the sent snapshot are created within	the specified file system.
    
    	   -d
    
    	       Uses  all  but the first	element	of the sent snapshot path (all
    	       but the pool name) to determine the name	of the new snapshot as
    	       described in the	paragraph above.
    
    
    	   -e
    
    	       Uses  the  last	element	of the sent snapshot path to determine
    	       the name	of the new snapshot  as	 described  in	the  paragraph
    	       above.
    
    
    	   -F
    
    	       Forces  a  rollback of the file system to the most recent snap-
    	       shot before performing the receive operation. If	 receiving  an
    	       incremental  replication	 stream	(for example, one generated by
    	       zfs send	-R -[iI]), destroy snapshots and file systems that  do
    	       not exist on the	sending	side.
    
    
    	   -n
    
    	       Do  not actually	receive	the stream. This can be	useful in con-
    	       junction	with the -v option to  verify  the  name  the  receive
    	       operation would use.
    
    
    	   -o property=value
    
    	       Sets  the  specified  property  as if the command zfs set prop-
    	       erty=value is invoked at	the same time the received dataset  is
    	       created	from  the  non-incremental send	stream or updated from
    	       the incremental send stream. Any	editable ZFS property can also
    	       be  set	at  receive  time.  Set-once  properties  bound	to the
    	       received	data, such as normalization and	casesensitivity,  can-
    	       not  be	set  at	 receive time even when	the datasets are newly
    	       created by zfs receive. Multiple	-o options can	be  specified.
    	       An  error results if the	same property is specified in multiple
    	       -o or -x	options.
    
    
    	   -u
    
    	       File system that	is associated with the received	stream is  not
    	       mounted.
    
    
    	   -v
    
    	       Print  verbose  information  about  the	stream	and  the  time
    	       required	to perform the receive operation.
    
    
    	   -x property
    
    	       Ensures that the	effective  value  of  the  specified  property
    	       after  the  receive is unaffected by the	value of that property
    	       in the send stream (if  any),  as  if  the  property  had  been
    	       excluded	from the send stream. If the specified property	is not
    	       present in the send stream, this	 option	 does  nothing.	 If  a
    	       received	 property  needs to be overridden, the effective value
    	       can be set or inherited,	depending on the property. In the case
    	       of  an incremental update, -x leaves any	existing local setting
    	       or explicit inheritance unchanged (since	the received  property
    	       is  already  overridden).  All -o restrictions apply equally to
    	       -x.
    
    
    
           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.
    
    	   If a	hold exists on a snapshot, attempts to destroy	that  snapshot
    	   by using the	zfs destroy command return EBUSY.
    
    	   -r
    
    	       Recursively releases a hold with	the given tag on the snapshots
    	       of all descendent file systems.
    
    
    
           zfs rename filesystem|volume|snapshot
           filesystem|volume|snapshot
           zfs rename [-p] filesystem|volume filesystem|volume
    
    	   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.
    
    	   Renaming root dataset is not	allowed. The root dataset can only  be
    	   renamed by renaming the pool, which will rename the root dataset to
    	   the new pool	name. Use zpool	export <pool> command and  then	 zpool
    	   import  <pool>  <newpoolname> command to rename the root dataset to
    	   the new pool	name.
    
    	   -p
    
    	       Creates all the nonexistent parent datasets.  Datasets  created
    	       in  this	 manner	 are  automatically  mounted  according	to the
    	       mountpoint property inherited from their	parent.
    
    
    
           zfs rename -r snapshot snapshot
    
    	   Recursively renames the snapshots of	all descendent datasets. Snap-
    	   shots are the only dataset that can be renamed recursively.
    
    
           zfs rename share	share
    
    	   Renames the specified share to a new	share name.
    
    
           zfs rollback [-rRf] snapshot
    
    	   Rolls 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 must be destroyed by specifying the -r option.
    
    	   The -rR options do not recursively destroy the child	snapshots of a
    	   recursive  snapshot.	 Only  the  top-level  recursive  snapshot  is
    	   destroyed by	either of these	options. To  completely	 roll  back  a
    	   recursive  snapshot,	 you  must rollback the	individual child snap-
    	   shots.
    
    	   -r
    
    	       Recursively destroys any	snapshots more	recent	than  the  one
    	       specified.
    
    
    	   -R
    
    	       Recursively  destroys any more recent snapshots,	as well	as any
    	       clones of those snapshots.
    
    
    	   -f
    
    	       Used with the -R	option to force	an unmount of any  clone  file
    	       systems that are	to be destroyed.
    
    
    
           zfs send	[-DRbpvn] [-[iI] snapshot] [-s streamsize] snapshot
           zfs send	-r [-Dbcpvn] [-i snapshot] [-s streamsize] snapshot
    
    	   Creates  a  stream  representation of the second snapshot, 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.
    
    	   -b
    
    	       Sends only received property values whether  or	not  they  are
    	       overridden  by local settings, but only if the dataset has ever
    	       been received. Use this option when you	want  zfs  receive  to
    	       restore	received  properties backed up on the sent dataset and
    	       to avoid	sending	local settings that may	 have  nothing	to  do
    	       with  the  source dataset, but only with	how the	data is	backed
    	       up.
    
    
    	   -c
    
    	       Creates a self-contained	stream.	A self-contained stream	is one
    	       that  is	 not  dependent	 on  any  datasets not included	in the
    	       stream package. Valid only with the -r option. If used with the
    	       -i  option, the stream will be dependent	on the snapshot	speci-
    	       fied as an argument to the that option.
    
    	       See the "ZFS Streams" section of	the ZFS	 Administration	 Guide
    	       for details.
    
    
    	   -D
    
    	       Performs	 dedup	processing on the stream. Deduplicated streams
    	       cannot be received on systems that do not  support  the	stream
    	       deduplication feature.
    
    	       See  the	 "ZFS Streams" section of the ZFS Administration Guide
    	       to understand how a replication stream package differs  from  a
    	       recursive stream	package.
    
    
    	   -i snapshot
    
    	       Generates  an incremental stream	from the first snapshot	to the
    	       second snapshot.	The incremental	source	(the  first  snapshot)
    	       can  be	specified  as  the last	component of the snapshot name
    	       (for example, the part after the	@), and	it is  assumed	to  be
    	       from the	same file system as the	second snapshot.
    
    	       If  the	destination  is	 a clone, the source may be the	origin
    	       snapshot,  which	 must  be  fully   specified   (for   example,
    	       pool/fs@origin, not just	@origin).
    
    
    	   -I snapshot
    
    	       Generates  a  stream  package that sends	all intermediary snap-
    	       shots from the first snapshot to	the second snapshot. For exam-
    	       ple,  -I	 @a  fs@d  is similar to -i @a fs@b; -i	@b fs@c; -i @c
    	       fs@d. The incremental source snapshot may be specified as  with
    	       the -i option.
    
    
    	   -n
    
    	       Do  not	actually send the stream. This option can also be used
    	       with the	-v option to see what snapshots	would have been	sent.
    
    
    	   -p
    
    	       Sends properties.
    
    
    	   -R
    
    	       Generates a replication	stream	package	 that  replicates  the
    	       specified  file	system,	and all	descendent file	systems, up to
    	       the named snapshot. When	received, all  properties,  snapshots,
    	       descendent file systems,	and clones are preserved.
    
    	       If the -i or -I flags are used in conjunction with the -R flag,
    	       an incremental replication stream  is  generated.  The  current
    	       values  of  properties,	and  current  snapshot and file	system
    	       names are set when the stream is	received. If the  -F  flag  is
    	       specified when this stream is received, snapshots and file sys-
    	       tems that do not	exist on the sending side are destroyed.
    
    
    	   -r
    
    	       Generates a recursive stream package. A recursive stream	 pack-
    	       age  contains a series of full and/or incremental streams. When
    	       received, all properties	and descendent file systems  are  pre-
    	       served.	Unlike	with the replication stream packages generated
    	       with the	-R flag,  intermediate	snapshots  are	not  preserved
    	       unless  the intermediate	snapshot is the	origin of a clone that
    	       is included in the stream.
    
    	       If the -i option	is used	in conjunction with the	-r option,  an
    	       incremental  recursive  stream is generated. The	current	values
    	       of properties as	well as	current	snapshot and file system names
    	       are set when the	stream is received. If the -F option is	speci-
    	       fied when this stream is	received, snapshots and	 file  systems
    	       that  do	 not  exist  on	the sending side are destroyed.	The -I
    	       option cannot be	used in	conjunction with the -r	option.
    
    	       When combined with the -c option,  a  self-contained  recursive
    	       stream  package	is  created. If	both the -c and	-i options are
    	       used, file systems and volumes that do not  have	 the  snapshot
    	       specified  with	the  -i	 option	 are  sent  as	self-contained
    	       streams.
    
    	       See the "ZFS Streams" section of	the ZFS	 Administration	 Guide
    	       to  understand  how  a  recursive stream	package	differs	from a
    	       replication stream package.
    
    
    	   -s streamsize
    
    	       Specifies that the size of the stream, in bytes,	will be	output
    	       to  stderr.  -s	cannot be used with -v.	streamsize is the only
    	       valid option to -s.
    
    
    	   -v
    
    	       Displays	verbose	information about the  stream  package	gener-
    	       ated.
    
    	   The	format of the stream is	committed. You will be able to receive
    	   your	streams	on future versions of ZFS.
    
    	   The snapshot	specified by the snapshot argument must	exist. If  the
    	   -R or -r options are	used then a recursive snapshot as specified by
    	   the snapshot	argument should	exist and will	be  sent  recursively.
    	   There  are  two  special cases. First, a descendant filesystem tree
    	   that	is completely missing the appropriate named snapshot  will  be
    	   skipped  and	will not be included in	the send stream. In this case,
    	   a warning message  will  be	printed	 for  each  snapshot  that  is
    	   skipped. Second, if a descendant filesystem tree is of mixed	status
    	   (that is, the root of the descendant	filesystem tree	is missing the
    	   requested snapshot but one or more of its child filesystems do have
    	   the requested snapshot), then an error is  generated	 to  terminate
    	   the send operation.
    
    
           zfs set [-r] property=value filesystem|volume|snapshot ...
    
    	   Sets	 the  property	to the given value for each dataset. Only some
    	   properties can be edited. See the  "Properties"  section  for  more
    	   information	on  what  properties can be set	and acceptable values.
    	   Numeric values can be specified as exact values,  or	 in  a	human-
    	   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.
    
    	   -r
    
    	       Recursively apply the effective value of	the setting throughout
    	       the  subtree  of	child datasets.	The effective value may	be set
    	       or inherited, depending on the property.	Use the	 zfs  help  -l
    	       properties  command to review whether a property	is settable or
    	       inheritable.
    
    
    
           zfs share [-u] -o property=value	... filesystem%share
           zfs share filesystem|mountpoint|filesystem%share
           zfs share -a | filesystem
    
    	   For a full description of zfs share syntax and examples and setting
    	   the share.nfs or share.smb property,	see zfs_share(1M).
    
    
           zfs snapshot [-r] [-o property=value] ... filesystem@snapname|vol-
           ume@snapname
    
    	   Creates a snapshot with the given name. All previous	 modifications
    	   by successful system	calls to the file system are part of the snap-
    	   shot. zfs snap can be used as an alias for zfs  snapshot.  See  the
    	   "Snapshots" section for details.
    
    	   -r
    
    	       Recursively creates snapshots of	all descendent datasets. Snap-
    	       shots are taken atomically, so  that  all  recursive  snapshots
    	       correspond to the same moment in	time.
    
    
    	   -o property=value
    
    	       Sets the	specified property; see	zfs create for details.
    
    
    
           zfs unallow [-rldug] everyone|user|group[,...] [perm|@setname[, ...]]
           filesystem|volume
           zfs unallow [-rld] -e [perm|@setname [,...]] filesystem|volume
           zfs unallow [-r]	-c [perm|@setname[,...]]
           filesystem|volume
           zfs unallow [-r]	-s @setname [perm|@setname[,...]]
           filesystem|volume
    
    	   For a full description of the zfs unallow syntax and	examples,  see
    	   zfs_allow(1M).
    
    
           zfs unmount [-f]	-a | filesystem|mountpoint
    
    	   Unmounts  currently mounted ZFS file	systems. Invoked automatically
    	   as part of the shutdown process.
    
    	   -f
    
    	       Forcefully unmount the file system, even	if it is currently  in
    	       use.
    
    
    	   -a
    
    	       Unmounts	 all available ZFS file	systems. Invoked automatically
    	       as part of the boot process.
    
    
    	   filesystem|mountpoint
    
    	       Unmounts	the specified filesystem.  The	command	 can  also  be
    	       given a path to a ZFS file system mount point on	the system.
    
    	   For	an  encrypted  dataset,	 the key is not	unloaded when the file
    	   system is unmounted.	To unload the key, see zfs key.
    
    
           zfs unshare filesystem|mountpoint|filesystem%share
           zfs unshare -a |	-r filesystem
    
    	   For a full description of zfs  unshare  syntax  and	examples,  see
    	   zfs_share(1M).
    
    
           zfs upgrade
    
    	   Identifies  a  file system version, which determines	available file
    	   system features in the currently running software release. You  can
    	   continue to use older file system versions, but some	features might
    	   not be available. A file system can be upgraded by  using  the  zfs
    	   upgrade -a command. You will	not be able to access a	file system of
    	   a later version on a	system that runs an earlier software version.
    
    
           zfs upgrade [-v]
    
    	   Displays ZFS	file system versions that are supported	by the current
    	   software.  The  current ZFS file system versions and	all previously
    	   supported versions are displayed, along with	an explanation of  the
    	   features provided with each version.
    
    
           zfs upgrade [-r]	[-V version] [-a | filesystem]
    
    	   Upgrades  file  systems to a	new, on-disk version. Upgrading	a file
    	   system means	that it	will no	longer be accessible on	a system  run-
    	   ning	an older software version. A zfs send stream that is generated
    	   from	a new file system snapshot cannot be accessed on a system that
    	   runs	an older software version.
    
    	   In general, the file	system version is independent of the pool ver-
    	   sion. See zpool(1M) for information on the zpool upgrade command.
    
    	   In some cases, the file system version and  the  pool  version  are
    	   interrelated	 and the pool version must be upgraded before the file
    	   system version can be upgraded.
    
    	   -a
    
    	       Upgrades	all file systems on all	imported pools.
    
    
    	   filesystem
    
    	       Upgrades	the specified file system.
    
    
    	   -r
    
    	       Upgrades	the specified file system and all descendent file sys-
    	       tems.
    
    
    	   -V version
    
    	       Upgrades	to the specified version. If the -V flag is not	speci-
    	       fied, this command upgrades to the most	recent	version.  This
    	       option  can  only  be  used to increase the version number, and
    	       only up to the most recent version supported by this software.
    
    
    
           zfs userspace [-hniHp] [-o field[,...]] [-sS field]... [-t 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.
    
    	   -h
    
    	       Displays	syntax help message and	exit.
    
    
    	   -n
    
    	       Prints numeric ID instead of user/group name.
    
    
    	   -H
    
    	       Does not	print headers, use tab-delimited output.
    
    
    	   -p
    
    	       Uses exact (parseable) numeric output.
    
    
    	   -o field[,...]
    
    	       Displays	 only  the  specified  fields  from the	following set,
    	       type,name,used,quota. The default is to display all fields.
    
    
    	   -s field
    
    	       Sorts output by this field. The s and S flags may be  specified
    	       multiple	times to sort first by one field, then by another. The
    	       default is -s type -s name.
    
    
    	   -S field
    
    	       Sorts by	this field in reverse order. See -s.
    
    
    	   -t type[,...]
    
    	       Prints  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
    
    	       Translates SID to POSIX ID. The POSIX ID	may be ephemeral if no
    	       mapping exists. Normal POSIX interfaces (for example,  stat(2),
    	       ls  -l)	perform	 this translation, so the -i option allows the
    	       output from zfs userspace to be compared	 directly  with	 those
    	       utilities. However, -i may lead to confusion if some files were
    	       created by an SMB user before a SMB-to-POSIX name  mapping  was
    	       established.  In	 such  a case, some files are owned by the SMB
    	       entity and some by the POSIX entity.  However,  the  -i	option
    	       will report that	the POSIX entity has the total usage and quota
    	       for both.
    
    
    
    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 /export/home	is set for the
           parent file system, and is automatically	inherited by  the  child  file
           system.
    
    
    	 # zfs create pool/home
    
    	 # zfs set mountpoint=/export/home pool/home
    
    	 # zfs create pool/home/bob
    
    
    
           Example 2 Creating a ZFS	Snapshot
    
    
           The following command creates a snapshot	named yesterday. This snapshot
           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 compres-
           sion 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(1M) for more information on pool properties.
    
    
    	 # zfs list
    
    	    NAME		      USED  AVAIL  REFER  MOUNTPOINT
    
    	    pool		      450K   457G    18K  /pool
    
    	    pool/home		      315K   457G    21K  /export/home
    
    	    pool/home/anne	       18K   457G    18K  /export/home/anne
    
    	    pool/home/bob	      276K   457G   276K  /export/home/bob
    
    
    
           Example 6 Setting a Quota on a ZFS File System
    
    
           The following command sets a quota of 30	GB for pool/home/bob.
    
    
    	 # zfs set quota=30G 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	aclinherit	      restricted	     default
    
    	 pool/home/bob	aclmode		      discard		     default
    
    	 pool/home/bob	atime		      on		     default
    
    	 pool/home/bob	available	      30.0G		     -
    
    	 pool/home/bob	canmount	      on		     default
    
    	 pool/home/bob	casesensitivity	      mixed		     -
    
    	 pool/home/bob	checksum	      on		     default
    
    	 pool/home/bob	compression	      on		     local
    
    	 pool/home/bob	compressratio	      1.00x		     -
    
    	 pool/home/bob	copies		      1			     default
    
    	 pool/home/bob	creation	      Tue Jul  3 10:39 2012  -
    
    	 pool/home/bob	dedup		      off		     default
    
    	 pool/home/bob	devices		      on		     default
    
    	 pool/home/bob	encryption	      off		     -
    
    	 pool/home/bob	exec		      on		     default
    
    	 pool/home/bob	keychangedate	      -			     default
    
    	 pool/home/bob	keysource	      none		     default
    
    	 pool/home/bob	keystatus	      none		     -
    
    	 pool/home/bob	logbias		      latency		     default
    
    	 pool/home/bob	mlslabel	      none		     -
    
    	 pool/home/bob	mounted		      yes		     -
    
    	 pool/home/bob	mountpoint	      /pool/home/bob	     default
    
    	 pool/home/bob	multilevel	      off		     -
    
    	 pool/home/bob	nbmand		      off		     default
    
    	 pool/home/bob	normalization	      none		     -
    
    	 pool/home/bob	primarycache	      all		     default
    
    	 pool/home/bob	quota		      30G		     local
    
    	 pool/home/bob	readonly	      off		     default
    
    	 pool/home/bob	recordsize	      128K		     default
    
    	 pool/home/bob	referenced	      31K		     -
    
    	 pool/home/bob	refquota	      none		     default
    
    	 pool/home/bob	refreservation	      none		     default
    
    	 pool/home/bob	rekeydate	      -			     default
    
    	 pool/home/bob	reservation	      none		     default
    
    	 pool/home/bob	rstchown	      on		     default
    
    	 pool/home/bob	secondarycache	      all		     default
    
    	 pool/home/bob	setuid		      on		     default
    
    	 pool/home/bob	shadow		      none		     -
    
    	 pool/home/bob	share.*		      ...		     inherited
    
    	 pool/home/bob	snapdir		      hidden		     default
    
    	 pool/home/bob	sync		      standard		     default
    
    	 pool/home/bob	type		      filesystem	     -
    
    	 pool/home/bob	used		      31K		     -
    
    	 pool/home/bob	usedbychildren	      0			     -
    
    	 pool/home/bob	usedbydataset	      31K		     -
    
    	 pool/home/bob	usedbyrefreservation  0			     -
    
    	 pool/home/bob	usedbysnapshots	      0			     -
    
    	 pool/home/bob	utf8only	      off		     -
    
    	 pool/home/bob	version		      6			     -
    
    	 pool/home/bob	vscan		      off		     default
    
    	 pool/home/bob	xattr		      on		     default
    
    	 pool/home/bob	zoned		      off		     default
    
    
    
    
           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 -r -s local -o name,property,value all pool/home/bob
    
    	 NAME		 PROPERTY  VALUE
    
    	 pool/home/bob	 compression  on
    
    	 pool/home/bob	 quota	   30G
    
    
    
           Example 8 Rolling Back a	ZFS File System
    
    
           The  following  command	reverts	 the contents of pool/home/anne	to the
           snapshot	named yesterday, deleting all intermediate snapshots.
    
    
    	 # zfs rollback	-r pool/home/anne@yesterday
    
    
    
           Example 9 Creating a ZFS	Clone
    
    
           The following command creates a writable	file system whose initial con-
           tents are the same as pool/home/bob@yesterday.
    
    
    	 # zfs clone pool/home/bob@yesterday pool/clone
    
    
    
           Example 10 Promoting a ZFS Clone
    
    
           The  following  commands	 illustrate  how to test out changes to	a file
           system, and then	replace	the original file system with the changed one,
           using clones, clone promotion, and renaming:
    
    
    	 # zfs create pool/project/production
    
    	   populate /pool/project/production with data
    
    	 # zfs snapshot	pool/project/production@today
    
    	 # zfs clone pool/project/production@today pool/project/beta
    
    	 make changes to /pool/project/beta and	test them
    
    	 # zfs promote pool/project/beta
    
    	 # zfs rename pool/project/production pool/project/legacy
    
    	 # zfs rename pool/project/beta	pool/project/production
    
    	 once the legacy version is no longer needed, it can be	destroyed
    
    	 # zfs destroy pool/project/legacy
    
    
    
           Example 11 Inheriting ZFS Properties
    
    
           The  following  command	causes	pool/home/bob  and  pool/home/anne  to
           inherit the checksum property from their	parent.
    
    
    	 # zfs inherit checksum	pool/home/bob pool/home/anne
    
    
    
           Example 12 Remotely Replicating ZFS Data
    
    
           The following commands send a  full  stream  and	 then  an  incremental
           stream  to a remote machine, restoring them into	poolB/received/fs@aand
           poolB/received/fs@b, respectively. poolB	must contain the  file	system
           poolB/received, and must	not initially contain poolB/received/fs.
    
    
    	 # zfs send pool/fs@a |	\
    
    	    ssh	host zfs receive poolB/received/fs@a
    
    	 # zfs send -i a pool/fs@b | ssh host \
    
    	    zfs	receive	poolB/received/fs
    
    
    
    
           The  above syntax assumes that sshd has been configured to allow	remote
           root access.
    
    
           Example 13 Using	the zfs	receive	-d Option
    
    
           The following command sends a full stream of  poolA/fsA/fsB@snap	 to  a
           remote  machine,	 receiving  it	into  poolB/received/fsA/fsB@snap. The
           fsA/fsB@snap portion of the received snapshot's name is determined from
           the  name  of  the  sent	 snapshot.  poolB must contain the file	system
           poolB/received. If poolB/received/fsA does not exist, it	is created  as
           an empty	file system.
    
    
    	 # zfs send poolA/fsA/fsB@snap | \
    
    	    ssh	host zfs receive -d poolB/received
    
    
    
           Example 14 Setting User Properties
    
    
           The  following  example	sets  the  user-defined	com.example:department
           property	for a dataset.
    
    
    	 # zfs set com.example:department=12345	tank/accounting
    
    
    
           Example 15 Performing a Rolling Snapshot
    
    
           The following example shows how to maintain a history of	snapshots with
           a  consistent  naming  scheme. To keep a	week's worth of	snapshots, the
           user destroys the oldest	snapshot, renames the remaining	snapshots, and
           then creates a new snapshot, as follows:
    
    
    	 # zfs destroy -r pool/users@7daysago
    
    	 # zfs rename -r pool/users@6daysago @7daysago
    
    	 # zfs rename -r pool/users@5daysago @6daysago
    
    	 # zfs rename -r pool/users@4daysago @5daysago
    
    	 # zfs rename -r pool/users@3daysago @4daysago
    
    	 # zfs rename -r pool/users@2daysago @3daysago
    
    	 # zfs rename -r pool/users@yesterday @2daysago
    
    	 # zfs rename -r pool/users@today @yesterday
    
    	 # zfs snapshot	-r pool/users@today
    
    
    
           Example 16 Displaying ZFS Snapshot Differences
    
    
           The following example is	output of the zfs diff -F and -t options spec-
           ified:
    
    
    	 # zfs diff -Ft	myfiles@snap1
    
    	 1269962501.206726811	M   /	/myfiles/
    
    	 1269962444.207369955	M   F	/myfiles/link_to_me	 (+1)
    
    	 1269962499.207519034	R	/myfiles/rename_me -> /myfiles/renamed
    
    	 1269962431.813566720	-   F	/myfiles/delete_me
    
    	 1269962518.666905544	+   F	/myfiles/new_file
    
    	 1269962501.393099817	+   |	/myfiles/new_pipe
    
    
    
    EXIT STATUS
           The following exit values are returned:
    
           0
    
    	   Successful completion.
    
    
           1
    
    	   An error occurred.
    
    
           2
    
    	   Invalid command line	options	were specified.
    
    
    ATTRIBUTES
           See attributes(5) for descriptions of the following attributes:
    
    
    
    
           +-----------------------------+-----------------------------+
           |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
           +-----------------------------+-----------------------------+
           |Availability		     |system/file-system/zfs	   |
           +-----------------------------+-----------------------------+
           |Interface Stability	     |Committed			   |
           +-----------------------------+-----------------------------+
    
    SEE ALSO
           chmod(1), chown(1), pktool(1), setlabel(1),  ssh(1),  mount(1M),	 shad-
           owd(1M),	   share(1M),	share_nfs(1M),	 share_smb(1M),	  unshare(1M),
           zonecfg(1M),  zpool(1M),	  chmod(2),   chown(2),	  stat(2),   write(2),
           fsync(3C), setflabel(3TSOL), dfstab(4), vfstab(4), attributes(5)
    
    
           See  the	gzip(1)	man page, which	is not part of the SunOS man page col-
           lection.
    
    
           For  information	 about	other	ZFS   features,	  see	zfs_allow(1M),
           zfs_encrypt(1M),	 zfs_share(1M),	 and  the Managing ZFS File Systems in
           Oracle Solaris 11.3.
    
    NOTES
           A file described	as modified by the diff	 subcommand  might  have  been
           modified	 in  multiple  ways.  Any  action  that	causes a change	in the
           st_ctim (see stat(2)) is	a basis	for reporting a	modification.
    
    
    
    SunOS 5.11			  23 Jul 2015			       zfs(1M)
    

Log in to reply
 

© Lightnetics 2024