Print this page
    
NEX-15425 rework share man pages
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15425 rework share man pages
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-9406 Add a property to show that a dataset has been modified since a snapshot
Reviewed by: Alexey Komarov <alexey.komarov@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
NEX-5728 Autosync Destination retention policy not being honoured
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
NEX-5795 Rename 'wrc' as 'wbc' in the source and in the tech docs
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
NEX-5060 WBC: Writecache and deduplication should not be used together
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
NEX-5058 WBC: Race between the purging of window and opening new one
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
NEX-2830 ZFS smart compression
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
6358 A faulted pool with only unavailable vdevs triggers assertion failure in libzfs
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Andrew Stormont <andyjstormont@gmail.com>
Reviewed by: Serban Maduta <serban.maduta@gmail.com>
Approved by: Dan McDonald <danmcd@omniti.com>
6393 zfs receive a full send as a clone
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Prakash Surya <prakash.surya@delphix.com>
Reviewed by: Richard Elling <Richard.Elling@RichardElling.com>
Approved by: Dan McDonald <danmcd@omniti.com>
6434 sa_find_sizes() may compute wrong SA header size
Reviewed-by: Ned Bass <bass6@llnl.gov>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Reviewed by: Andriy Gapon <avg@freebsd.org>
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Approved by: Robert Mustacchi <rm@joyent.com>
6346 zfs(1M) has spurious comma
Reviewed by: Garrett D'Amore <garrett@damore.org>
Reviewed by: Igor Kozhukhov <ikozhukhov@gmail.com>
Reviewed by: Robert Mustacchi <rm@joyent.com>
Approved by: Gordon Ross <gwr@nexenta.com>
2605 want to resume interrupted zfs send
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Paul Dagnelie <pcd@delphix.com>
Reviewed by: Richard Elling <Richard.Elling@RichardElling.com>
Reviewed by: Xin Li <delphij@freebsd.org>
Reviewed by: Arne Jansen <sensille@gmx.net>
Approved by: Dan McDonald <danmcd@omniti.com>
4185 add new cryptographic checksums to ZFS: SHA-512, Skein, Edon-R (fix studio build)
4185 add new cryptographic checksums to ZFS: SHA-512, Skein, Edon-R
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Prakash Surya <prakash.surya@delphix.com>
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Richard Lowe <richlowe@richlowe.net>
Approved by: Garrett D'Amore <garrett@damore.org>
NEX-4582 update wrc test cases for allow to use write back cache per tree of datasets
Reviewed by: Steve Peng <steve.peng@nexenta.com>
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
5960 zfs recv should prefetch indirect blocks
5925 zfs receive -o origin=
Reviewed by: Prakash Surya <prakash.surya@delphix.com>
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
5409 Remove shareiscsi description and example from zfs(1M)
5988 zfs(1M) diff is excessively indented
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Approved by: Gordon Ross <gwr@nexenta.com>
5745 zfs set allows only one dataset property to be set at a time
Reviewed by: Christopher Siden <christopher.siden@delphix.com>
Reviewed by: George Wilson <george@delphix.com>
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Bayard Bell <buffer.g.overflow@gmail.com>
Reviewed by: Richard PALO <richard@NetBSD.org>
Reviewed by: Steven Hartland <killing@multiplay.co.uk>
Approved by: Rich Lowe <richlowe@richlowe.net>
5764 "zfs send -nv" directs output to stderr
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Paul Dagnelie <paul.dagnelie@delphix.com>
Reviewed by: Basil Crow <basil.crow@delphix.com>
Reviewed by: Steven Hartland <killing@multiplay.co.uk>
Reviewed by: Bayard Bell <buffer.g.overflow@gmail.com>
Approved by: Dan McDonald <danmcd@omniti.com>
NEX-4476 WRC: Allow to use write back cache per tree of datasets
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
Revert "NEX-4476 WRC: Allow to use write back cache per tree of datasets"
This reverts commit fe97b74444278a6f36fec93179133641296312da.
NEX-4476 WRC: Allow to use write back cache per tree of datasets
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
NEX-4028 use lz4 by default
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
NEX-1456 Part 2, port FreeBSD patch - new zfs recv options support
SUP-817 Further clean-up of zfs manpage
OS-123 aclinherit=restricted masks inherited permissions by group perms (groupmask)
OS-102 add man page info and tests for vdev/CoS properties and ZFS meta features
re #11781 rb3701 Update man related tools (add missed files)
re #11781 rb3701 Update man related tools
--HG--
rename : usr/src/cmd/man/src/THIRDPARTYLICENSE => usr/src/cmd/man/THIRDPARTYLICENSE
rename : usr/src/cmd/man/src/THIRDPARTYLICENSE.descrip => usr/src/cmd/man/THIRDPARTYLICENSE.descrip
rename : usr/src/cmd/man/src/man.c => usr/src/cmd/man/man.c
Bug 10481 - Dry run option in 'zfs send' isn't the same as in NexentaStor 3.1
    
      
        | Split | 
	Close | 
      
      | Expand all | 
      | Collapse all | 
    
    
          --- old/usr/src/man/man1m/zfs.1m.man.txt
          +++ new/usr/src/man/man1m/zfs.1m.man.txt
   1    1  ZFS(1M)                      Maintenance Commands                      ZFS(1M)
   2    2  
   3    3  NAME
   4    4       zfs - configures ZFS file systems
   5    5  
   6    6  SYNOPSIS
   7    7       zfs [-?]
   8    8       zfs create [-p] [-o property=value]... filesystem
   9    9       zfs create [-ps] [-b blocksize] [-o property=value]... -V size volume
  10   10       zfs destroy [-Rfnprv] filesystem|volume
  11   11       zfs destroy [-Rdnprv] filesystem|volume@snap[%snap[,snap[%snap]]]...
  12   12       zfs destroy filesystem|volume#bookmark
  
    | 
      ↓ open down ↓ | 
    12 lines elided | 
    
      ↑ open up ↑ | 
  
  13   13       zfs snapshot [-r] [-o property=value]...
  14   14           filesystem@snapname|volume@snapname...
  15   15       zfs rollback [-Rfr] snapshot
  16   16       zfs clone [-p] [-o property=value]... snapshot filesystem|volume
  17   17       zfs promote clone-filesystem
  18   18       zfs rename [-f] filesystem|volume|snapshot filesystem|volume|snapshot
  19   19       zfs rename [-fp] filesystem|volume filesystem|volume
  20   20       zfs rename -r snapshot snapshot
  21   21       zfs list [-r|-d depth] [-Hp] [-o property[,property]...] [-s property]...
  22   22           [-S property]... [-t type[,type]...] [filesystem|volume|snapshot]...
  23      -     zfs remap filesystem|volume
  24   23       zfs set property=value [property=value]... filesystem|volume|snapshot...
  25   24       zfs get [-r|-d depth] [-Hp] [-o field[,field]...] [-s source[,source]...]
  26   25           [-t type[,type]...] all | property[,property]...
  27   26           filesystem|volume|snapshot|bookmark...
  28   27       zfs inherit [-rS] property filesystem|volume|snapshot...
  29   28       zfs upgrade
  30   29       zfs upgrade -v
  31   30       zfs upgrade [-r] [-V version] -a | filesystem
  32   31       zfs userspace [-Hinp] [-o field[,field]...] [-s field]... [-S field]...
  33   32           [-t type[,type]...] filesystem|snapshot
  34   33       zfs groupspace [-Hinp] [-o field[,field]...] [-s field]... [-S field]...
  35   34           [-t type[,type]...] filesystem|snapshot
  36   35       zfs mount
  37   36       zfs mount [-Ov] [-o options] -a | filesystem
  38   37       zfs unmount [-f] -a | filesystem|mountpoint
  39   38       zfs share -a | filesystem
  40   39       zfs unshare -a | filesystem|mountpoint
  41   40       zfs bookmark snapshot bookmark
  42      -     zfs send [-DLPRcenpv] [[-I|-i] snapshot] snapshot
       41 +     zfs send [-DLPRcenpsv] [[-I|-i] snapshot] snapshot
  43   42       zfs send [-Lce] [-i snapshot|bookmark] filesystem|volume|snapshot
  44   43       zfs send [-Penv] -t receive_resume_token
  45      -     zfs receive [-Fnsuv] [-o origin=snapshot] filesystem|volume|snapshot
  46      -     zfs receive [-Fnsuv] [-d|-e] [-o origin=snapshot] filesystem
       44 +     zfs receive [-FKnsuv] [-l filesystem|volume]... [-o property=value]...
       45 +         [-x property]... filesystem|volume|snapshot
       46 +     zfs receive [-FKnsuv] [-d|-e] [-l filesystem|volume]...
       47 +         [-o property=value]... [-x property]... filesystem
  47   48       zfs receive -A filesystem|volume
  48   49       zfs allow filesystem|volume
  49   50       zfs allow [-dglu] user|group[,user|group]...
  50   51           perm|@setname[,perm|@setname]... filesystem|volume
  51   52       zfs allow [-dl] -e|everyone perm|@setname[,perm|@setname]...
  52   53           filesystem|volume
  53   54       zfs allow -c perm|@setname[,perm|@setname]... filesystem|volume
  54   55       zfs allow -s @setname perm|@setname[,perm|@setname]... filesystem|volume
  55   56       zfs unallow [-dglru] user|group[,user|group]...
  56   57           [perm|@setname[,perm|@setname]...] filesystem|volume
  57   58       zfs unallow [-dlr] -e|everyone [perm|@setname[,perm|@setname]...]
  58   59           filesystem|volume
  59   60       zfs unallow [-r] -c [perm|@setname[,perm|@setname]...] filesystem|volume
  60   61       zfs unallow [-r] -s -@setname [perm|@setname[,perm|@setname]...]
  61   62           filesystem|volume
  62   63       zfs hold [-r] tag snapshot...
  63   64       zfs holds [-r] snapshot...
  64   65       zfs release [-r] tag snapshot...
  65   66       zfs diff [-FHt] snapshot snapshot|filesystem
  66   67       zfs program [-n] [-t timeout] [-m memory_limit] pool script [arg1 ...]
  67   68  
  68   69  DESCRIPTION
  69   70       The zfs command configures ZFS datasets within a ZFS storage pool, as
  70   71       described in zpool(1M).  A dataset is identified by a unique path within
  71   72       the ZFS namespace.  For example:
  72   73  
  73   74       pool/{filesystem,volume,snapshot}
  74   75  
  75   76       where the maximum length of a dataset name is MAXNAMELEN (256 bytes).
  76   77  
  77   78       A dataset can be one of the following:
  78   79  
  79   80       file system  A ZFS dataset of type filesystem can be mounted within the
  80   81                    standard system namespace and behaves like other file
  81   82                    systems.  While ZFS file systems are designed to be POSIX
  82   83                    compliant, known issues exist that prevent compliance in
  83   84                    some cases.  Applications that depend on standards
  84   85                    conformance might fail due to non-standard behavior when
  85   86                    checking file system free space.
  86   87  
  87   88       volume       A logical volume exported as a raw or block device.  This
  88   89                    type of dataset should only be used under special
  89   90                    circumstances.  File systems are typically used in most
  90   91                    environments.
  91   92  
  92   93       snapshot     A read-only version of a file system or volume at a given
  93   94                    point in time.  It is specified as filesystem@name or
  94   95                    volume@name.
  95   96  
  96   97     ZFS File System Hierarchy
  97   98       A ZFS storage pool is a logical collection of devices that provide space
  98   99       for datasets.  A storage pool is also the root of the ZFS file system
  99  100       hierarchy.
 100  101  
 101  102       The root of the pool can be accessed as a file system, such as mounting
 102  103       and unmounting, taking snapshots, and setting properties.  The physical
 103  104       storage characteristics, however, are managed by the zpool(1M) command.
 104  105  
 105  106       See zpool(1M) for more information on creating and administering pools.
 106  107  
 107  108     Snapshots
 108  109       A snapshot is a read-only copy of a file system or volume.  Snapshots can
 109  110       be created extremely quickly, and initially consume no additional space
 110  111       within the pool.  As data within the active dataset changes, the snapshot
 111  112       consumes more data than would otherwise be shared with the active
 112  113       dataset.
 113  114  
 114  115       Snapshots can have arbitrary names.  Snapshots of volumes can be cloned
 115  116       or rolled back, but cannot be accessed independently.
 116  117  
 117  118       File system snapshots can be accessed under the .zfs/snapshot directory
 118  119       in the root of the file system.  Snapshots are automatically mounted on
 119  120       demand and may be unmounted at regular intervals.  The visibility of the
 120  121       .zfs directory can be controlled by the snapdir property.
 121  122  
 122  123     Clones
 123  124       A clone is a writable volume or file system whose initial contents are
 124  125       the same as another dataset.  As with snapshots, creating a clone is
 125  126       nearly instantaneous, and initially consumes no additional space.
 126  127  
 127  128       Clones can only be created from a snapshot.  When a snapshot is cloned,
 128  129       it creates an implicit dependency between the parent and child.  Even
 129  130       though the clone is created somewhere else in the dataset hierarchy, the
 130  131       original snapshot cannot be destroyed as long as a clone exists.  The
 131  132       origin property exposes this dependency, and the destroy command lists
 132  133       any such dependencies, if they exist.
 133  134  
 134  135       The clone parent-child dependency relationship can be reversed by using
 135  136       the promote subcommand.  This causes the "origin" file system to become a
 136  137       clone of the specified file system, which makes it possible to destroy
 137  138       the file system that the clone was created from.
 138  139  
 139  140     Mount Points
 140  141       Creating a ZFS file system is a simple operation, so the number of file
 141  142       systems per system is likely to be numerous.  To cope with this, ZFS
 142  143       automatically manages mounting and unmounting file systems without the
 143  144       need to edit the /etc/vfstab file.  All automatically managed file
 144  145       systems are mounted by ZFS at boot time.
 145  146  
 146  147       By default, file systems are mounted under /path, where path is the name
 147  148       of the file system in the ZFS namespace.  Directories are created and
 148  149       destroyed as needed.
 149  150  
 150  151       A file system can also have a mount point set in the mountpoint property.
 151  152       This directory is created as needed, and ZFS automatically mounts the
 152  153       file system when the zfs mount -a command is invoked (without editing
 153  154       /etc/vfstab).  The mountpoint property can be inherited, so if pool/home
 154  155       has a mount point of /export/stuff, then pool/home/user automatically
 155  156       inherits a mount point of /export/stuff/user.
 156  157  
 157  158       A file system mountpoint property of none prevents the file system from
 158  159       being mounted.
 159  160  
 160  161       If needed, ZFS file systems can also be managed with traditional tools
 161  162       (mount, umount, /etc/vfstab).  If a file system's mount point is set to
 162  163       legacy, ZFS makes no attempt to manage the file system, and the
 163  164       administrator is responsible for mounting and unmounting the file system.
 164  165  
 165  166     Zones
 166  167       A ZFS file system can be added to a non-global zone by using the zonecfg
 167  168       add fs subcommand.  A ZFS file system that is added to a non-global zone
 168  169       must have its mountpoint property set to legacy.
 169  170  
 170  171       The physical properties of an added file system are controlled by the
 171  172       global administrator.  However, the zone administrator can create,
 172  173       modify, or destroy files within the added file system, depending on how
 173  174       the file system is mounted.
 174  175  
 175  176       A dataset can also be delegated to a non-global zone by using the zonecfg
 176  177       add dataset subcommand.  You cannot delegate a dataset to one zone and
 177  178       the children of the same dataset to another zone.  The zone administrator
 178  179       can change properties of the dataset or any of its children.  However,
 179  180       the quota, filesystem_limit and snapshot_limit properties of the
 180  181       delegated dataset can be modified only by the global administrator.
 181  182  
 182  183       A ZFS volume can be added as a device to a non-global zone by using the
 183  184       zonecfg add device subcommand.  However, its physical properties can be
 184  185       modified only by the global administrator.
 185  186  
 186  187       For more information about zonecfg syntax, see zonecfg(1M).
 187  188  
 188  189       After a dataset is delegated to a non-global zone, the zoned property is
 189  190       automatically set.  A zoned file system cannot be mounted in the global
 190  191       zone, since the zone administrator might have to set the mount point to
 191  192       an unacceptable value.
 192  193  
 193  194       The global administrator can forcibly clear the zoned property, though
 194  195       this should be done with extreme care.  The global administrator should
 195  196       verify that all the mount points are acceptable before clearing the
 196  197       property.
 197  198  
 198  199     Native Properties
 199  200       Properties are divided into two types, native properties and user-defined
 200  201       (or "user") properties.  Native properties either export internal
 201  202       statistics or control ZFS behavior.  In addition, native properties are
 202  203       either editable or read-only.  User properties have no effect on ZFS
 203  204       behavior, but you can use them to annotate datasets in a way that is
 204  205       meaningful in your environment.  For more information about user
 205  206       properties, see the User Properties section, below.
 206  207  
 207  208       Every dataset has a set of properties that export statistics about the
 208  209       dataset as well as control various behaviors.  Properties are inherited
 209  210       from the parent unless overridden by the child.  Some properties apply
 210  211       only to certain types of datasets (file systems, volumes, or snapshots).
 211  212  
 212  213       The values of numeric properties can be specified using human-readable
 213  214       suffixes (for example, k, KB, M, Gb, and so forth, up to Z for
 214  215       zettabyte).  The following are all valid (and equal) specifications:
 215  216       1536M, 1.5g, 1.50GB.
 216  217  
 217  218       The values of non-numeric properties are case sensitive and must be
 218  219       lowercase, except for mountpoint, sharenfs, and sharesmb.
 219  220  
 220  221       The following native properties consist of read-only statistics about the
 221  222       dataset.  These properties can be neither set, nor inherited.  Native
 222  223       properties apply to all dataset types unless otherwise noted.
 223  224  
 224  225       available             The amount of space available to the dataset and
 225  226                             all its children, assuming that there is no other
 226  227                             activity in the pool.  Because space is shared
 227  228                             within a pool, availability can be limited by any
 228  229                             number of factors, including physical pool size,
 229  230                             quotas, reservations, or other datasets within the
 230  231                             pool.
 231  232  
 232  233                             This property can also be referred to by its
 233  234                             shortened column name, avail.
 234  235  
 235  236       compressratio         For non-snapshots, the compression ratio achieved
 236  237                             for the used space of this dataset, expressed as a
 237  238                             multiplier.  The used property includes descendant
 238  239                             datasets, and, for clones, does not include the
 239  240                             space shared with the origin snapshot.  For
 240  241                             snapshots, the compressratio is the same as the
 241  242                             refcompressratio property.  Compression can be
 242  243                             turned on by running: zfs set compression=on
 243  244                             dataset.  The default value is off.
 244  245  
 245  246       creation              The time this dataset was created.
 246  247  
 247  248       clones                For snapshots, this property is a comma-separated
 248  249                             list of filesystems or volumes which are clones of
 249  250                             this snapshot.  The clones' origin property is this
 250  251                             snapshot.  If the clones property is not empty,
 251  252                             then this snapshot can not be destroyed (even with
 252  253                             the -r or -f options).
 253  254  
 254  255       defer_destroy         This property is on if the snapshot has been marked
 255  256                             for deferred destroy by using the zfs destroy -d
 256  257                             command.  Otherwise, the property is off.
 257  258  
 258  259       filesystem_count      The total number of filesystems and volumes that
 259  260                             exist under this location in the dataset tree.
 260  261                             This value is only available when a
 261  262                             filesystem_limit has been set somewhere in the tree
 262  263                             under which the dataset resides.
 263  264  
 264  265       logicalreferenced     The amount of space that is "logically" accessible
 265  266                             by this dataset.  See the referenced property.  The
 266  267                             logical space ignores the effect of the compression
 267  268                             and copies properties, giving a quantity closer to
 268  269                             the amount of data that applications see.  However,
 269  270                             it does include space consumed by metadata.
 270  271  
 271  272                             This property can also be referred to by its
 272  273                             shortened column name, lrefer.
 273  274  
 274  275       logicalused           The amount of space that is "logically" consumed by
  
    | 
      ↓ open down ↓ | 
    218 lines elided | 
    
      ↑ open up ↑ | 
  
 275  276                             this dataset and all its descendents.  See the used
 276  277                             property.  The logical space ignores the effect of
 277  278                             the compression and copies properties, giving a
 278  279                             quantity closer to the amount of data that
 279  280                             applications see.  However, it does include space
 280  281                             consumed by metadata.
 281  282  
 282  283                             This property can also be referred to by its
 283  284                             shortened column name, lused.
 284  285  
      286 +     modified              For a snapshot, indicates whether the parent
      287 +                           filesystem or volume has been modified since the
      288 +                           snapshot.  This property can be either yes or no.
      289 +
 285  290       mounted               For file systems, indicates whether the file system
 286  291                             is currently mounted.  This property can be either
 287  292                             yes or no.
 288  293  
 289  294       origin                For cloned file systems or volumes, the snapshot
 290  295                             from which the clone was created.  See also the
 291  296                             clones property.
 292  297  
 293  298       receive_resume_token  For filesystems or volumes which have saved
 294  299                             partially-completed state from zfs receive -s, this
 295  300                             opaque token can be provided to zfs send -t to
 296  301                             resume and complete the zfs receive.
 297  302  
 298  303       referenced            The amount of data that is accessible by this
 299  304                             dataset, which may or may not be shared with other
 300  305                             datasets in the pool.  When a snapshot or clone is
 301  306                             created, it initially references the same amount of
 302  307                             space as the file system or snapshot it was created
 303  308                             from, since its contents are identical.
 304  309  
 305  310                             This property can also be referred to by its
 306  311                             shortened column name, refer.
 307  312  
 308  313       refcompressratio      The compression ratio achieved for the referenced
 309  314                             space of this dataset, expressed as a multiplier.
 310  315                             See also the compressratio property.
 311  316  
 312  317       snapshot_count        The total number of snapshots that exist under this
 313  318                             location in the dataset tree.  This value is only
 314  319                             available when a snapshot_limit has been set
 315  320                             somewhere in the tree under which the dataset
 316  321                             resides.
 317  322  
 318  323       type                  The type of dataset: filesystem, volume, or
 319  324                             snapshot.
 320  325  
 321  326       used                  The amount of space consumed by this dataset and
 322  327                             all its descendents.  This is the value that is
 323  328                             checked against this dataset's quota and
 324  329                             reservation.  The space used does not include this
 325  330                             dataset's reservation, but does take into account
 326  331                             the reservations of any descendent datasets.  The
 327  332                             amount of space that a dataset consumes from its
 328  333                             parent, as well as the amount of space that is
 329  334                             freed if this dataset is recursively destroyed, is
 330  335                             the greater of its space used and its reservation.
 331  336  
 332  337                             The used space of a snapshot (see the Snapshots
 333  338                             section) is space that is referenced exclusively by
 334  339                             this snapshot.  If this snapshot is destroyed, the
 335  340                             amount of used space will be freed.  Space that is
 336  341                             shared by multiple snapshots isn't accounted for in
 337  342                             this metric.  When a snapshot is destroyed, space
 338  343                             that was previously shared with this snapshot can
 339  344                             become unique to snapshots adjacent to it, thus
 340  345                             changing the used space of those snapshots.  The
 341  346                             used space of the latest snapshot can also be
 342  347                             affected by changes in the file system.  Note that
 343  348                             the used space of a snapshot is a subset of the
 344  349                             written space of the snapshot.
 345  350  
 346  351                             The amount of space used, available, or referenced
 347  352                             does not take into account pending changes.
 348  353                             Pending changes are generally accounted for within
 349  354                             a few seconds.  Committing a change to a disk using
 350  355                             fsync(3C) or O_SYNC does not necessarily guarantee
 351  356                             that the space usage information is updated
 352  357                             immediately.
 353  358  
 354  359       usedby*               The usedby* properties decompose the used
 355  360                             properties into the various reasons that space is
 356  361                             used.  Specifically, used = usedbychildren +
 357  362                             usedbydataset + usedbyrefreservation +
 358  363                             usedbysnapshots.  These properties are only
 359  364                             available for datasets created on zpool "version
 360  365                             13" pools.
 361  366  
 362  367       usedbychildren        The amount of space used by children of this
 363  368                             dataset, which would be freed if all the dataset's
 364  369                             children were destroyed.
 365  370  
 366  371       usedbydataset         The amount of space used by this dataset itself,
 367  372                             which would be freed if the dataset were destroyed
 368  373                             (after first removing any refreservation and
 369  374                             destroying any necessary snapshots or descendents).
 370  375  
 371  376       usedbyrefreservation  The amount of space used by a refreservation set on
 372  377                             this dataset, which would be freed if the
 373  378                             refreservation was removed.
 374  379  
 375  380       usedbysnapshots       The amount of space consumed by snapshots of this
 376  381                             dataset.  In particular, it is the amount of space
 377  382                             that would be freed if all of this dataset's
 378  383                             snapshots were destroyed.  Note that this is not
 379  384                             simply the sum of the snapshots' used properties
 380  385                             because space can be shared by multiple snapshots.
 381  386  
 382  387       userused@user         The amount of space consumed by the specified user
 383  388                             in this dataset.  Space is charged to the owner of
 384  389                             each file, as displayed by ls -l.  The amount of
 385  390                             space charged is displayed by du and ls -s.  See
 386  391                             the zfs userspace subcommand for more information.
 387  392  
 388  393                             Unprivileged users can access only their own space
 389  394                             usage.  The root user, or a user who has been
 390  395                             granted the userused privilege with zfs allow, can
 391  396                             access everyone's usage.
 392  397  
 393  398                             The userused@... properties are not displayed by
 394  399                             zfs get all.  The user's name must be appended
 395  400                             after the @ symbol, using one of the following
 396  401                             forms:
 397  402  
 398  403                             o POSIX name (for example, joe)
 399  404  
 400  405                             o POSIX numeric ID (for example, 789)
 401  406  
 402  407                             o SID name (for example, joe.smith@mydomain)
 403  408  
 404  409                             o SID numeric ID (for example, S-1-123-456-789)
 405  410  
 406  411       userrefs              This property is set to the number of user holds on
 407  412                             this snapshot.  User holds are set by using the zfs
 408  413                             hold command.
 409  414  
 410  415       groupused@group       The amount of space consumed by the specified group
 411  416                             in this dataset.  Space is charged to the group of
 412  417                             each file, as displayed by ls -l.  See the
 413  418                             userused@user property for more information.
 414  419  
 415  420                             Unprivileged users can only access their own
 416  421                             groups' space usage.  The root user, or a user who
 417  422                             has been granted the groupused privilege with zfs
 418  423                             allow, can access all groups' usage.
 419  424  
 420  425       volblocksize          For volumes, specifies the block size of the
 421  426                             volume.  The blocksize cannot be changed once the
 422  427                             volume has been written, so it should be set at
 423  428                             volume creation time.  The default blocksize for
 424  429                             volumes is 8 Kbytes.  Any power of 2 from 512 bytes
 425  430                             to 128 Kbytes is valid.
 426  431  
 427  432                             This property can also be referred to by its
 428  433                             shortened column name, volblock.
 429  434  
 430  435       written               The amount of space referenced by this dataset,
 431  436                             that was written since the previous snapshot (i.e.
 432  437                             that is not referenced by the previous snapshot).
 433  438  
 434  439       written@snapshot      The amount of referenced space written to this
 435  440                             dataset since the specified snapshot.  This is the
 436  441                             space that is referenced by this dataset but was
 437  442                             not referenced by the specified snapshot.
 438  443  
 439  444                             The snapshot may be specified as a short snapshot
 440  445                             name (just the part after the @), in which case it
 441  446                             will be interpreted as a snapshot in the same
 442  447                             filesystem as this dataset.  The snapshot may be a
 443  448                             full snapshot name (filesystem@snapshot), which for
 444  449                             clones may be a snapshot in the origin's filesystem
 445  450                             (or the origin of the origin's filesystem, etc.)
 446  451  
 447  452       The following native properties can be used to change the behavior of a
 448  453       ZFS dataset.
 449  454  
 450  455       aclinherit=discard|noallow|restricted|passthrough|passthrough-x
 451  456         Controls how ACEs are inherited when files and directories are created.
 452  457  
 453  458         discard        does not inherit any ACEs.
 454  459  
 455  460         noallow        only inherits inheritable ACEs that specify "deny"
 456  461                        permissions.
 457  462  
 458  463         restricted     default, removes the write_acl and write_owner
 459  464                        permissions when the ACE is inherited.
 460  465  
 461  466         passthrough    inherits all inheritable ACEs without any modifications.
 462  467  
 463  468         passthrough-x  same meaning as passthrough, except that the owner@,
 464  469                        group@, and everyone@ ACEs inherit the execute
 465  470                        permission only if the file creation mode also requests
 466  471                        the execute bit.
 467  472  
 468  473         When the property value is set to passthrough, files are created with a
 469  474         mode determined by the inheritable ACEs.  If no inheritable ACEs exist
 470  475         that affect the mode, then the mode is set in accordance to the
 471  476         requested mode from the application.
 472  477  
 473  478       aclmode=discard|groupmask|passthrough|restricted
 474  479         Controls how an ACL is modified during chmod(2) and how inherited ACEs
 475  480         are modified by the file creation mode.
 476  481  
 477  482         discard      default, deletes all ACEs except for those representing
 478  483                      the mode of the file or directory requested by chmod(2).
 479  484  
 480  485         groupmask    reduces permissions granted by all ALLOW entries found in
 481  486                      the ACL such that they are no greater than the group
 482  487                      permissions specified by the mode.
 483  488  
 484  489         passthrough  indicates that no changes are made to the ACL other than
 485  490                      creating or updating the necessary ACEs to represent the
 486  491                      new mode of the file or directory.
 487  492  
 488  493         restricted   causes the chmod(2) operation to return an error when used
 489  494                      on any file or directory which has a non-trivial ACL, with
 490  495                      entries in addition to those that represent the mode.
 491  496  
 492  497         chmod(2) is required to change the set user ID, set group ID, or sticky
 493  498         bit on a file or directory, as they do not have equivalent ACEs.  In
 494  499         order to use chmod(2) on a file or directory with a non-trivial ACL
 495  500         when aclmode is set to restricted, you must first remove all ACEs
 496  501         except for those that represent the current mode.
 497  502  
 498  503       atime=on|off
 499  504         Controls whether the access time for files is updated when they are
 500  505         read.  Turning this property off avoids producing write traffic when
 501  506         reading files and can result in significant performance gains, though
 502  507         it might confuse mailers and other similar utilities.  The default
 503  508         value is on.
 504  509  
 505  510       canmount=on|off|noauto
 506  511         If this property is set to off, the file system cannot be mounted, and
 507  512         is ignored by zfs mount -a.  Setting this property to off is similar to
 508  513         setting the mountpoint property to none, except that the dataset still
 509  514         has a normal mountpoint property, which can be inherited.  Setting this
 510  515         property to off allows datasets to be used solely as a mechanism to
 511  516         inherit properties.  One example of setting canmount=off is to have two
 512  517         datasets with the same mountpoint, so that the children of both
 513  518         datasets appear in the same directory, but might have different
 514  519         inherited characteristics.
 515  520  
 516  521         When set to noauto, a dataset can only be mounted and unmounted
 517  522         explicitly.  The dataset is not mounted automatically when the dataset
 518  523         is created or imported, nor is it mounted by the zfs mount -a command
 519  524         or unmounted by the zfs unmount -a command.
 520  525  
 521  526         This property is not inherited.
 522  527  
 523  528       checksum=on|off|fletcher2|fletcher4|sha256|noparity|sha512|skein|edonr
 524  529         Controls the checksum used to verify data integrity.  The default value
 525  530         is on, which automatically selects an appropriate algorithm (currently,
 526  531         fletcher4, but this may change in future releases).  The value off
 527  532         disables integrity checking on user data.  The value noparity not only
 528  533         disables integrity but also disables maintaining parity for user data.
 529  534         This setting is used internally by a dump device residing on a RAID-Z
 530  535         pool and should not be used by any other dataset.  Disabling checksums
 531  536         is NOT a recommended practice.
 532  537  
 533  538         The sha512, skein, and edonr checksum algorithms require enabling the
 534  539         appropriate features on the pool.  Please see zpool-features(5) for
 535  540         more information on these algorithms.
 536  541  
 537  542         Changing this property affects only newly-written data.
 538  543  
 539  544         Salted checksum algorithms (edonr, skein) are currently not supported
 540  545         for any filesystem on the boot pools.
 541  546  
 542  547       compression=on|off|gzip|gzip-N|lz4|lzjb|zle
 543  548         Controls the compression algorithm used for this dataset.
 544  549  
 545  550         Setting compression to on indicates that the current default
 546  551         compression algorithm should be used.  The default balances compression
 547  552         and decompression speed, with compression ratio and is expected to work
 548  553         well on a wide variety of workloads.  Unlike all other settings for
 549  554         this property, on does not select a fixed compression type.  As new
 550  555         compression algorithms are added to ZFS and enabled on a pool, the
 551  556         default compression algorithm may change.  The current default
 552  557         compression algorithm is either lzjb or, if the lz4_compress feature is
 553  558         enabled, lz4.
 554  559  
 555  560         The lz4 compression algorithm is a high-performance replacement for the
 556  561         lzjb algorithm.  It features significantly faster compression and
 557  562         decompression, as well as a moderately higher compression ratio than
 558  563         lzjb, but can only be used on pools with the lz4_compress feature set
 559  564         to enabled.  See zpool-features(5) for details on ZFS feature flags and
 560  565         the lz4_compress feature.
 561  566  
 562  567         The lzjb compression algorithm is optimized for performance while
 563  568         providing decent data compression.
 564  569  
 565  570         The gzip compression algorithm uses the same compression as the gzip(1)
  
    | 
      ↓ open down ↓ | 
    271 lines elided | 
    
      ↑ open up ↑ | 
  
 566  571         command.  You can specify the gzip level by using the value gzip-N,
 567  572         where N is an integer from 1 (fastest) to 9 (best compression ratio).
 568  573         Currently, gzip is equivalent to gzip-6 (which is also the default for
 569  574         gzip(1)).
 570  575  
 571  576         The zle compression algorithm compresses runs of zeros.
 572  577  
 573  578         This property can also be referred to by its shortened column name
 574  579         compress.  Changing this property affects only newly-written data.
 575  580  
      581 +     smartcompression=on|off
      582 +       Smart compression is a feature which optimizes compression performance
      583 +       on filesystems which contain a mixture of compressible and
      584 +       incompressible data.  When compression is enabled on a filesystem,
      585 +       smart compression dynamically tracks per-file compression ratios to
      586 +       determine if a file is compressible or not.  When the compression ratio
      587 +       being achieved is too low, smart compression progressively backs off
      588 +       attempting to compress the file.
      589 +
      590 +       The algorithm periodically checks whether new data written to a file
      591 +       previously deemed incompressible is still not compressible and adjusts
      592 +       behavior accordingly.  Certain types of files, such as virtual machine
      593 +       disk files or large database files, can contain a mixture of both types
      594 +       of data.  Although smart compression tries to detect these situations,
      595 +       in marginal cases it can be too pessimistic, which results in a
      596 +       reduction of the overall compression ratio.  In this case, setting the
      597 +       smartcompression property to off turns off smart compression on a
      598 +       filesystem, so that data is always compressed regardless of the
      599 +       compression ratio achieved.
      600 +
      601 +       The default value is on.
      602 +
 576  603       copies=1|2|3
 577  604         Controls the number of copies of data stored for this dataset.  These
 578  605         copies are in addition to any redundancy provided by the pool, for
 579  606         example, mirroring or RAID-Z.  The copies are stored on different
 580  607         disks, if possible.  The space used by multiple copies is charged to
 581  608         the associated file and dataset, changing the used property and
 582  609         counting against quotas and reservations.
 583  610  
 584  611         Changing this property only affects newly-written data.  Therefore, set
 585  612         this property at file system creation time by using the -o copies=N
 586  613         option.
 587  614  
 588  615       devices=on|off
 589  616         Controls whether device nodes can be opened on this file system.  The
 590  617         default value is on.
 591  618  
 592  619       exec=on|off
 593  620         Controls whether processes can be executed from within this file
 594  621         system.  The default value is on.
 595  622  
 596  623       filesystem_limit=count|none
 597  624         Limits the number of filesystems and volumes that can exist under this
 598  625         point in the dataset tree.  The limit is not enforced if the user is
 599  626         allowed to change the limit.  Setting a filesystem_limit to on a
 600  627         descendent of a filesystem that already has a filesystem_limit does not
 601  628         override the ancestor's filesystem_limit, but rather imposes an
 602  629         additional limit.  This feature must be enabled to be used (see
 603  630         zpool-features(5)).
 604  631  
 605  632       mountpoint=path|none|legacy
 606  633         Controls the mount point used for this file system.  See the Mount
 607  634         Points section for more information on how this property is used.
 608  635  
 609  636         When the mountpoint property is changed for a file system, the file
 610  637         system and any children that inherit the mount point are unmounted.  If
 611  638         the new value is legacy, then they remain unmounted.  Otherwise, they
 612  639         are automatically remounted in the new location if the property was
 613  640         previously legacy or none, or if they were mounted before the property
 614  641         was changed.  In addition, any shared file systems are unshared and
 615  642         shared in the new location.
 616  643  
 617  644       nbmand=on|off
 618  645         Controls whether the file system should be mounted with nbmand (Non
 619  646         Blocking mandatory locks).  This is used for SMB clients.  Changes to
 620  647         this property only take effect when the file system is umounted and
 621  648         remounted.  See mount(1M) for more information on nbmand mounts.
 622  649  
 623  650       primarycache=all|none|metadata
 624  651         Controls what is cached in the primary cache (ARC).  If this property
 625  652         is set to all, then both user data and metadata is cached.  If this
 626  653         property is set to none, then neither user data nor metadata is cached.
 627  654         If this property is set to metadata, then only metadata is cached.  The
 628  655         default value is all.
 629  656  
 630  657       quota=size|none
 631  658         Limits the amount of space a dataset and its descendents can consume.
 632  659         This property enforces a hard limit on the amount of space used.  This
 633  660         includes all space consumed by descendents, including file systems and
 634  661         snapshots.  Setting a quota on a descendent of a dataset that already
 635  662         has a quota does not override the ancestor's quota, but rather imposes
 636  663         an additional limit.
 637  664  
 638  665         Quotas cannot be set on volumes, as the volsize property acts as an
 639  666         implicit quota.
 640  667  
 641  668       snapshot_limit=count|none
 642  669         Limits the number of snapshots that can be created on a dataset and its
 643  670         descendents.  Setting a snapshot_limit on a descendent of a dataset
 644  671         that already has a snapshot_limit does not override the ancestor's
 645  672         snapshot_limit, but rather imposes an additional limit.  The limit is
 646  673         not enforced if the user is allowed to change the limit.  For example,
 647  674         this means that recursive snapshots taken from the global zone are
 648  675         counted against each delegated dataset within a zone.  This feature
 649  676         must be enabled to be used (see zpool-features(5)).
 650  677  
 651  678       userquota@user=size|none
 652  679         Limits the amount of space consumed by the specified user.  User space
 653  680         consumption is identified by the userspace@user property.
 654  681  
 655  682         Enforcement of user quotas may be delayed by several seconds.  This
 656  683         delay means that a user might exceed their quota before the system
 657  684         notices that they are over quota and begins to refuse additional writes
 658  685         with the EDQUOT error message.  See the zfs userspace subcommand for
 659  686         more information.
 660  687  
 661  688         Unprivileged users can only access their own groups' space usage.  The
 662  689         root user, or a user who has been granted the userquota privilege with
 663  690         zfs allow, can get and set everyone's quota.
 664  691  
 665  692         This property is not available on volumes, on file systems before
 666  693         version 4, or on pools before version 15.  The userquota@... properties
 667  694         are not displayed by zfs get all.  The user's name must be appended
 668  695         after the @ symbol, using one of the following forms:
 669  696  
 670  697         o   POSIX name (for example, joe)
 671  698  
 672  699         o   POSIX numeric ID (for example, 789)
 673  700  
 674  701         o   SID name (for example, joe.smith@mydomain)
 675  702  
 676  703         o   SID numeric ID (for example, S-1-123-456-789)
 677  704  
 678  705       groupquota@group=size|none
 679  706         Limits the amount of space consumed by the specified group.  Group
 680  707         space consumption is identified by the groupused@group property.
 681  708  
 682  709         Unprivileged users can access only their own groups' space usage.  The
 683  710         root user, or a user who has been granted the groupquota privilege with
 684  711         zfs allow, can get and set all groups' quotas.
 685  712  
 686  713       readonly=on|off
 687  714         Controls whether this dataset can be modified.  The default value is
 688  715         off.
 689  716  
 690  717         This property can also be referred to by its shortened column name,
 691  718         rdonly.
 692  719  
 693  720       recordsize=size
 694  721         Specifies a suggested block size for files in the file system.  This
 695  722         property is designed solely for use with database workloads that access
 696  723         files in fixed-size records.  ZFS automatically tunes block sizes
 697  724         according to internal algorithms optimized for typical access patterns.
 698  725  
 699  726         For databases that create very large files but access them in small
 700  727         random chunks, these algorithms may be suboptimal.  Specifying a
 701  728         recordsize greater than or equal to the record size of the database can
 702  729         result in significant performance gains.  Use of this property for
 703  730         general purpose file systems is strongly discouraged, and may adversely
 704  731         affect performance.
 705  732  
 706  733         The size specified must be a power of two greater than or equal to 512
 707  734         and less than or equal to 128 Kbytes.  If the large_blocks feature is
 708  735         enabled on the pool, the size may be up to 1 Mbyte.  See
 709  736         zpool-features(5) for details on ZFS feature flags.
 710  737  
 711  738         Changing the file system's recordsize affects only files created
 712  739         afterward; existing files are unaffected.
 713  740  
 714  741         This property can also be referred to by its shortened column name,
 715  742         recsize.
 716  743  
 717  744       redundant_metadata=all|most
 718  745         Controls what types of metadata are stored redundantly.  ZFS stores an
 719  746         extra copy of metadata, so that if a single block is corrupted, the
 720  747         amount of user data lost is limited.  This extra copy is in addition to
 721  748         any redundancy provided at the pool level (e.g. by mirroring or
 722  749         RAID-Z), and is in addition to an extra copy specified by the copies
 723  750         property (up to a total of 3 copies).  For example if the pool is
 724  751         mirrored, copies=2, and redundant_metadata=most, then ZFS stores 6
 725  752         copies of most metadata, and 4 copies of data and some metadata.
 726  753  
 727  754         When set to all, ZFS stores an extra copy of all metadata.  If a single
 728  755         on-disk block is corrupt, at worst a single block of user data (which
 729  756         is recordsize bytes long) can be lost.
 730  757  
 731  758         When set to most, ZFS stores an extra copy of most types of metadata.
 732  759         This can improve performance of random writes, because less metadata
 733  760         must be written.  In practice, at worst about 100 blocks (of recordsize
 734  761         bytes each) of user data can be lost if a single on-disk block is
 735  762         corrupt.  The exact behavior of which metadata blocks are stored
 736  763         redundantly may change in future releases.
 737  764  
 738  765         The default value is all.
 739  766  
 740  767       refquota=size|none
 741  768         Limits the amount of space a dataset can consume.  This property
 742  769         enforces a hard limit on the amount of space used.  This hard limit
 743  770         does not include space used by descendents, including file systems and
 744  771         snapshots.
 745  772  
 746  773       refreservation=size|none
 747  774         The minimum amount of space guaranteed to a dataset, not including its
 748  775         descendents.  When the amount of space used is below this value, the
 749  776         dataset is treated as if it were taking up the amount of space
 750  777         specified by refreservation.  The refreservation reservation is
 751  778         accounted for in the parent datasets' space used, and counts against
 752  779         the parent datasets' quotas and reservations.
 753  780  
 754  781         If refreservation is set, a snapshot is only allowed if there is enough
 755  782         free pool space outside of this reservation to accommodate the current
 756  783         number of "referenced" bytes in the dataset.
 757  784  
 758  785         This property can also be referred to by its shortened column name,
 759  786         refreserv.
 760  787  
 761  788       reservation=size|none
 762  789         The minimum amount of space guaranteed to a dataset and its
 763  790         descendants.  When the amount of space used is below this value, the
 764  791         dataset is treated as if it were taking up the amount of space
 765  792         specified by its reservation.  Reservations are accounted for in the
 766  793         parent datasets' space used, and count against the parent datasets'
 767  794         quotas and reservations.
 768  795  
 769  796         This property can also be referred to by its shortened column name,
 770  797         reserv.
 771  798  
 772  799       secondarycache=all|none|metadata
 773  800         Controls what is cached in the secondary cache (L2ARC).  If this
 774  801         property is set to all, then both user data and metadata is cached.  If
 775  802         this property is set to none, then neither user data nor metadata is
 776  803         cached.  If this property is set to metadata, then only metadata is
 777  804         cached.  The default value is all.
  
    | 
      ↓ open down ↓ | 
    192 lines elided | 
    
      ↑ open up ↑ | 
  
 778  805  
 779  806       setuid=on|off
 780  807         Controls whether the setuid bit is respected for the file system.  The
 781  808         default value is on.
 782  809  
 783  810       sharesmb=on|off|opts
 784  811         Controls whether the file system is shared via SMB, and what options
 785  812         are to be used.  A file system with the sharesmb property set to off is
 786  813         managed through traditional tools such as sharemgr(1M).  Otherwise, the
 787  814         file system is automatically shared and unshared with the zfs share and
 788      -       zfs unshare commands.  If the property is set to on, the sharemgr(1M)
 789      -       command is invoked with no options.  Otherwise, the sharemgr(1M)
 790      -       command is invoked with options equivalent to the contents of this
 791      -       property.
      815 +       zfs unshare commands.  See sharesmb(5) for the share options
      816 +       description.
 792  817  
 793  818         Because SMB shares requires a resource name, a unique resource name is
 794  819         constructed from the dataset name.  The constructed name is a copy of
 795  820         the dataset name except that the characters in the dataset name, which
 796  821         would be invalid in the resource name, are replaced with underscore (_)
 797  822         characters.  A pseudo property "name" is also supported that allows you
 798  823         to replace the data set name with a specified name.  The specified name
 799  824         is then used to replace the prefix dataset in the case of inheritance.
 800  825         For example, if the dataset data/home/john is set to name=john, then
 801  826         data/home/john has a resource name of john.  If a child dataset
 802  827         data/home/john/backups is shared, it has a resource name of
 803  828         john_backups.
 804  829  
 805  830         When SMB shares are created, the SMB share name appears as an entry in
 806  831         the .zfs/shares directory.  You can use the ls or chmod command to
 807  832         display the share-level ACLs on the entries in this directory.
 808  833  
 809  834         When the sharesmb property is changed for a dataset, the dataset and
  
    | 
      ↓ open down ↓ | 
    8 lines elided | 
    
      ↑ open up ↑ | 
  
 810  835         any children inheriting the property are re-shared with the new
 811  836         options, only if the property was previously set to off, or if they
 812  837         were shared before the property was changed.  If the new property is
 813  838         set to off, the file systems are unshared.
 814  839  
 815  840       sharenfs=on|off|opts
 816  841         Controls whether the file system is shared via NFS, and what options
 817  842         are to be used.  A file system with a sharenfs property of off is
 818  843         managed through traditional tools such as share(1M), unshare(1M), and
 819  844         dfstab(4).  Otherwise, the file system is automatically shared and
 820      -       unshared with the zfs share and zfs unshare commands.  If the property
 821      -       is set to on, share(1M) command is invoked with no options.  Otherwise,
 822      -       the share(1M) command is invoked with options equivalent to the
 823      -       contents of this property.
      845 +       unshared with the zfs share and zfs unshare commands.  See sharenfs(5)
      846 +       for the share options description.
 824  847  
 825  848         When the sharenfs property is changed for a dataset, the dataset and
 826  849         any children inheriting the property are re-shared with the new
 827  850         options, only if the property was previously off, or if they were
 828  851         shared before the property was changed.  If the new property is off,
 829  852         the file systems are unshared.
 830  853  
 831  854       logbias=latency|throughput
 832  855         Provide a hint to ZFS about handling of synchronous requests in this
 833  856         dataset.  If logbias is set to latency (the default), ZFS will use pool
 834  857         log devices (if configured) to handle the requests at low latency.  If
 835  858         logbias is set to throughput, ZFS will not use configured pool log
 836  859         devices.  ZFS will instead optimize synchronous operations for global
 837  860         pool throughput and efficient use of resources.
 838  861  
 839  862       snapdir=hidden|visible
 840  863         Controls whether the .zfs directory is hidden or visible in the root of
 841  864         the file system as discussed in the Snapshots section.  The default
 842  865         value is hidden.
 843  866  
 844  867       sync=standard|always|disabled
 845  868         Controls the behavior of synchronous requests (e.g. fsync, O_DSYNC).
 846  869         standard is the POSIX specified behavior of ensuring all synchronous
 847  870         requests are written to stable storage and all devices are flushed to
 848  871         ensure data is not cached by device controllers (this is the default).
 849  872         always causes every file system transaction to be written and flushed
 850  873         before its system call returns.  This has a large performance penalty.
 851  874         disabled disables synchronous requests.  File system transactions are
 852  875         only committed to stable storage periodically.  This option will give
 853  876         the highest performance.  However, it is very dangerous as ZFS would be
 854  877         ignoring the synchronous transaction demands of applications such as
 855  878         databases or NFS.  Administrators should only use this option when the
 856  879         risks are understood.
 857  880  
 858  881       version=N|current
 859  882         The on-disk version of this file system, which is independent of the
 860  883         pool version.  This property can only be set to later supported
 861  884         versions.  See the zfs upgrade command.
 862  885  
 863  886       volsize=size
 864  887         For volumes, specifies the logical size of the volume.  By default,
 865  888         creating a volume establishes a reservation of equal size.  For storage
 866  889         pools with a version number of 9 or higher, a refreservation is set
 867  890         instead.  Any changes to volsize are reflected in an equivalent change
 868  891         to the reservation (or refreservation).  The volsize can only be set to
 869  892         a multiple of volblocksize, and cannot be zero.
 870  893  
 871  894         The reservation is kept equal to the volume's logical size to prevent
 872  895         unexpected behavior for consumers.  Without the reservation, the volume
 873  896         could run out of space, resulting in undefined behavior or data
 874  897         corruption, depending on how the volume is used.  These effects can
 875  898         also occur when the volume size is changed while it is in use
 876  899         (particularly when shrinking the size).  Extreme care should be used
 877  900         when adjusting the volume size.
 878  901  
 879  902         Though not recommended, a "sparse volume" (also known as "thin
 880  903         provisioning") can be created by specifying the -s option to the zfs
 881  904         create -V command, or by changing the reservation after the volume has
 882  905         been created.  A "sparse volume" is a volume where the reservation is
  
    | 
      ↓ open down ↓ | 
    49 lines elided | 
    
      ↑ open up ↑ | 
  
 883  906         less then the volume size.  Consequently, writes to a sparse volume can
 884  907         fail with ENOSPC when the pool is low on space.  For a sparse volume,
 885  908         changes to volsize are not reflected in the reservation.
 886  909  
 887  910       vscan=on|off
 888  911         Controls whether regular files should be scanned for viruses when a
 889  912         file is opened and closed.  In addition to enabling this property, the
 890  913         virus scan service must also be enabled for virus scanning to occur.
 891  914         The default value is off.
 892  915  
      916 +     wbc_mode=on|off
      917 +       Controls the mode of write back cache.  After the property has been set
      918 +       on a dataset all the child datasets inherit the property.  Due to its
      919 +       recursive nature the property will conflict with any child dataset or
      920 +       any parent dataset having this property enabled as well.  The property
      921 +       cannot be set if the target pool does not have special device (special
      922 +       vdev).  The default value is off.  This property cannot be enabled
      923 +       together with the dedup property.
      924 +
 893  925       xattr=on|off
 894  926         Controls whether extended attributes are enabled for this file system.
 895  927         The default value is on.
 896  928  
 897  929       zoned=on|off
 898  930         Controls whether the dataset is managed from a non-global zone.  See
 899  931         the Zones section for more information.  The default value is off.
 900  932  
 901  933       The following three properties cannot be changed after the file system is
 902  934       created, and therefore, should be set when the file system is created.
 903  935       If the properties are not set with the zfs create or zpool create
 904  936       commands, these properties are inherited from the parent dataset.  If the
 905  937       parent dataset lacks these properties due to having been created prior to
 906  938       these features being supported, the new file system will have the default
 907  939       values for these properties.
 908  940  
 909  941       casesensitivity=sensitive|insensitive|mixed
 910  942         Indicates whether the file name matching algorithm used by the file
 911  943         system should be case-sensitive, case-insensitive, or allow a
 912  944         combination of both styles of matching.  The default value for the
 913  945         casesensitivity property is sensitive.  Traditionally, UNIX and POSIX
 914  946         file systems have case-sensitive file names.
 915  947  
 916  948         The mixed value for the casesensitivity property indicates that the
 917  949         file system can support requests for both case-sensitive and case-
 918  950         insensitive matching behavior.  Currently, case-insensitive matching
 919  951         behavior on a file system that supports mixed behavior is limited to
 920  952         the SMB server product.  For more information about the mixed value
 921  953         behavior, see the "ZFS Administration Guide".
 922  954  
 923  955       normalization=none|formC|formD|formKC|formKD
 924  956         Indicates whether the file system should perform a unicode
 925  957         normalization of file names whenever two file names are compared, and
 926  958         which normalization algorithm should be used.  File names are always
 927  959         stored unmodified, names are normalized as part of any comparison
 928  960         process.  If this property is set to a legal value other than none, and
 929  961         the utf8only property was left unspecified, the utf8only property is
 930  962         automatically set to on.  The default value of the normalization
 931  963         property is none.  This property cannot be changed after the file
 932  964         system is created.
 933  965  
 934  966       utf8only=on|off
 935  967         Indicates whether the file system should reject file names that include
 936  968         characters that are not present in the UTF-8 character code set.  If
 937  969         this property is explicitly set to off, the normalization property must
 938  970         either not be explicitly set or be set to none.  The default value for
 939  971         the utf8only property is off.  This property cannot be changed after
 940  972         the file system is created.
 941  973  
 942  974       The casesensitivity, normalization, and utf8only properties are also new
 943  975       permissions that can be assigned to non-privileged users by using the ZFS
 944  976       delegated administration feature.
 945  977  
 946  978     Temporary Mount Point Properties
 947  979       When a file system is mounted, either through mount(1M) for legacy mounts
 948  980       or the zfs mount command for normal file systems, its mount options are
 949  981       set according to its properties.  The correlation between properties and
 950  982       mount options is as follows:
 951  983  
 952  984           PROPERTY                MOUNT OPTION
 953  985           devices                 devices/nodevices
 954  986           exec                    exec/noexec
 955  987           readonly                ro/rw
 956  988           setuid                  setuid/nosetuid
 957  989           xattr                   xattr/noxattr
 958  990  
 959  991       In addition, these options can be set on a per-mount basis using the -o
 960  992       option, without affecting the property that is stored on disk.  The
 961  993       values specified on the command line override the values stored in the
 962  994       dataset.  The nosuid option is an alias for nodevices,nosetuid.  These
 963  995       properties are reported as "temporary" by the zfs get command.  If the
 964  996       properties are changed while the dataset is mounted, the new setting
 965  997       overrides any temporary settings.
 966  998  
 967  999     User Properties
 968 1000       In addition to the standard native properties, ZFS supports arbitrary
 969 1001       user properties.  User properties have no effect on ZFS behavior, but
 970 1002       applications or administrators can use them to annotate datasets (file
 971 1003       systems, volumes, and snapshots).
 972 1004  
 973 1005       User property names must contain a colon (":") character to distinguish
 974 1006       them from native properties.  They may contain lowercase letters,
 975 1007       numbers, and the following punctuation characters: colon (":"), dash
 976 1008       ("-"), period ("."), and underscore ("_").  The expected convention is
 977 1009       that the property name is divided into two portions such as
 978 1010       module:property, but this namespace is not enforced by ZFS.  User
 979 1011       property names can be at most 256 characters, and cannot begin with a
 980 1012       dash ("-").
 981 1013  
 982 1014       When making programmatic use of user properties, it is strongly suggested
 983 1015       to use a reversed DNS domain name for the module component of property
 984 1016       names to reduce the chance that two independently-developed packages use
 985 1017       the same property name for different purposes.
 986 1018  
 987 1019       The values of user properties are arbitrary strings, are always
 988 1020       inherited, and are never validated.  All of the commands that operate on
 989 1021       properties (zfs list, zfs get, zfs set, and so forth) can be used to
 990 1022       manipulate both native properties and user properties.  Use the zfs
 991 1023       inherit command to clear a user property.  If the property is not defined
 992 1024       in any parent dataset, it is removed entirely.  Property values are
 993 1025       limited to 8192 bytes.
 994 1026  
 995 1027     ZFS Volumes as Swap or Dump Devices
 996 1028       During an initial installation a swap device and dump device are created
 997 1029       on ZFS volumes in the ZFS root pool.  By default, the swap area size is
 998 1030       based on 1/2 the size of physical memory up to 2 Gbytes.  The size of the
 999 1031       dump device depends on the kernel's requirements at installation time.
1000 1032       Separate ZFS volumes must be used for the swap area and dump devices.  Do
1001 1033       not swap to a file on a ZFS file system.  A ZFS swap file configuration
1002 1034       is not supported.
1003 1035  
1004 1036       If you need to change your swap area or dump device after the system is
1005 1037       installed or upgraded, use the swap(1M) and dumpadm(1M) commands.
1006 1038  
1007 1039  SUBCOMMANDS
1008 1040       All subcommands that modify state are logged persistently to the pool in
1009 1041       their original form.
1010 1042  
1011 1043       zfs -?
1012 1044         Displays a help message.
1013 1045  
1014 1046       zfs create [-p] [-o property=value]... filesystem
1015 1047         Creates a new ZFS file system.  The file system is automatically
1016 1048         mounted according to the mountpoint property inherited from the parent.
1017 1049  
1018 1050         -o property=value
1019 1051             Sets the specified property as if the command zfs set
1020 1052             property=value was invoked at the same time the dataset was
1021 1053             created.  Any editable ZFS property can also be set at creation
1022 1054             time.  Multiple -o options can be specified.  An error results if
1023 1055             the same property is specified in multiple -o options.
1024 1056  
1025 1057         -p  Creates all the non-existing parent datasets.  Datasets created in
1026 1058             this manner are automatically mounted according to the mountpoint
1027 1059             property inherited from their parent.  Any property specified on
1028 1060             the command line using the -o option is ignored.  If the target
1029 1061             filesystem already exists, the operation completes successfully.
1030 1062  
1031 1063       zfs create [-ps] [-b blocksize] [-o property=value]... -V size volume
1032 1064         Creates a volume of the given size.  The volume is exported as a block
1033 1065         device in /dev/zvol/{dsk,rdsk}/path, where path is the name of the
1034 1066         volume in the ZFS namespace.  The size represents the logical size as
1035 1067         exported by the device.  By default, a reservation of equal size is
1036 1068         created.
1037 1069  
1038 1070         size is automatically rounded up to the nearest 128 Kbytes to ensure
1039 1071         that the volume has an integral number of blocks regardless of
1040 1072         blocksize.
1041 1073  
1042 1074         -b blocksize
1043 1075             Equivalent to -o volblocksize=blocksize.  If this option is
1044 1076             specified in conjunction with -o volblocksize, the resulting
1045 1077             behavior is undefined.
1046 1078  
1047 1079         -o property=value
1048 1080             Sets the specified property as if the zfs set property=value
1049 1081             command was invoked at the same time the dataset was created.  Any
1050 1082             editable ZFS property can also be set at creation time.  Multiple
1051 1083             -o options can be specified.  An error results if the same property
1052 1084             is specified in multiple -o options.
1053 1085  
1054 1086         -p  Creates all the non-existing parent datasets.  Datasets created in
1055 1087             this manner are automatically mounted according to the mountpoint
1056 1088             property inherited from their parent.  Any property specified on
1057 1089             the command line using the -o option is ignored.  If the target
1058 1090             filesystem already exists, the operation completes successfully.
1059 1091  
1060 1092         -s  Creates a sparse volume with no reservation.  See volsize in the
1061 1093             Native Properties section for more information about sparse
1062 1094             volumes.
1063 1095  
1064 1096       zfs destroy [-Rfnprv] filesystem|volume
1065 1097         Destroys the given dataset.  By default, the command unshares any file
1066 1098         systems that are currently shared, unmounts any file systems that are
1067 1099         currently mounted, and refuses to destroy a dataset that has active
1068 1100         dependents (children or clones).
1069 1101  
1070 1102         -R  Recursively destroy all dependents, including cloned file systems
1071 1103             outside the target hierarchy.
1072 1104  
1073 1105         -f  Force an unmount of any file systems using the unmount -f command.
1074 1106             This option has no effect on non-file systems or unmounted file
1075 1107             systems.
1076 1108  
1077 1109         -n  Do a dry-run ("No-op") deletion.  No data will be deleted.  This is
1078 1110             useful in conjunction with the -v or -p flags to determine what
1079 1111             data would be deleted.
1080 1112  
1081 1113         -p  Print machine-parsable verbose information about the deleted data.
1082 1114  
1083 1115         -r  Recursively destroy all children.
1084 1116  
1085 1117         -v  Print verbose information about the deleted data.
1086 1118  
1087 1119         Extreme care should be taken when applying either the -r or the -R
1088 1120         options, as they can destroy large portions of a pool and cause
1089 1121         unexpected behavior for mounted file systems in use.
1090 1122  
1091 1123       zfs destroy [-Rdnprv] filesystem|volume@snap[%snap[,snap[%snap]]]...
1092 1124         The given snapshots are destroyed immediately if and only if the zfs
1093 1125         destroy command without the -d option would have destroyed it.  Such
1094 1126         immediate destruction would occur, for example, if the snapshot had no
1095 1127         clones and the user-initiated reference count were zero.
1096 1128  
1097 1129         If a snapshot does not qualify for immediate destruction, it is marked
1098 1130         for deferred deletion.  In this state, it exists as a usable, visible
1099 1131         snapshot until both of the preconditions listed above are met, at which
1100 1132         point it is destroyed.
1101 1133  
1102 1134         An inclusive range of snapshots may be specified by separating the
1103 1135         first and last snapshots with a percent sign.  The first and/or last
1104 1136         snapshots may be left blank, in which case the filesystem's oldest or
1105 1137         newest snapshot will be implied.
1106 1138  
1107 1139         Multiple snapshots (or ranges of snapshots) of the same filesystem or
1108 1140         volume may be specified in a comma-separated list of snapshots.  Only
1109 1141         the snapshot's short name (the part after the @) should be specified
1110 1142         when using a range or comma-separated list to identify multiple
1111 1143         snapshots.
1112 1144  
1113 1145         -R  Recursively destroy all clones of these snapshots, including the
1114 1146             clones, snapshots, and children.  If this flag is specified, the -d
1115 1147             flag will have no effect.
1116 1148  
1117 1149         -d  Defer snapshot deletion.
1118 1150  
1119 1151         -n  Do a dry-run ("No-op") deletion.  No data will be deleted.  This is
1120 1152             useful in conjunction with the -p or -v flags to determine what
1121 1153             data would be deleted.
1122 1154  
1123 1155         -p  Print machine-parsable verbose information about the deleted data.
1124 1156  
1125 1157         -r  Destroy (or mark for deferred deletion) all snapshots with this
1126 1158             name in descendent file systems.
1127 1159  
1128 1160         -v  Print verbose information about the deleted data.
1129 1161  
1130 1162             Extreme care should be taken when applying either the -r or the -R
1131 1163             options, as they can destroy large portions of a pool and cause
1132 1164             unexpected behavior for mounted file systems in use.
1133 1165  
1134 1166       zfs destroy filesystem|volume#bookmark
1135 1167         The given bookmark is destroyed.
1136 1168  
1137 1169       zfs snapshot [-r] [-o property=value]...
1138 1170         filesystem@snapname|volume@snapname...
1139 1171         Creates snapshots with the given names.  All previous modifications by
1140 1172         successful system calls to the file system are part of the snapshots.
1141 1173         Snapshots are taken atomically, so that all snapshots correspond to the
1142 1174         same moment in time.  See the Snapshots section for details.
1143 1175  
1144 1176         -o property=value
1145 1177             Sets the specified property; see zfs create for details.
1146 1178  
1147 1179         -r  Recursively create snapshots of all descendent datasets
1148 1180  
1149 1181       zfs rollback [-Rfr] snapshot
1150 1182         Roll back the given dataset to a previous snapshot.  When a dataset is
1151 1183         rolled back, all data that has changed since the snapshot is discarded,
1152 1184         and the dataset reverts to the state at the time of the snapshot.  By
1153 1185         default, the command refuses to roll back to a snapshot other than the
1154 1186         most recent one.  In order to do so, all intermediate snapshots and
1155 1187         bookmarks must be destroyed by specifying the -r option.
1156 1188  
1157 1189         The -rR options do not recursively destroy the child snapshots of a
1158 1190         recursive snapshot.  Only direct snapshots of the specified filesystem
1159 1191         are destroyed by either of these options.  To completely roll back a
1160 1192         recursive snapshot, you must rollback the individual child snapshots.
1161 1193  
1162 1194         -R  Destroy any more recent snapshots and bookmarks, as well as any
1163 1195             clones of those snapshots.
1164 1196  
1165 1197         -f  Used with the -R option to force an unmount of any clone file
1166 1198             systems that are to be destroyed.
1167 1199  
1168 1200         -r  Destroy any snapshots and bookmarks more recent than the one
1169 1201             specified.
1170 1202  
1171 1203       zfs clone [-p] [-o property=value]... snapshot filesystem|volume
1172 1204         Creates a clone of the given snapshot.  See the Clones section for
1173 1205         details.  The target dataset can be located anywhere in the ZFS
1174 1206         hierarchy, and is created as the same type as the original.
1175 1207  
1176 1208         -o property=value
1177 1209             Sets the specified property; see zfs create for details.
1178 1210  
1179 1211         -p  Creates all the non-existing parent datasets.  Datasets created in
1180 1212             this manner are automatically mounted according to the mountpoint
1181 1213             property inherited from their parent.  If the target filesystem or
1182 1214             volume already exists, the operation completes successfully.
1183 1215  
1184 1216       zfs promote clone-filesystem
1185 1217         Promotes a clone file system to no longer be dependent on its "origin"
1186 1218         snapshot.  This makes it possible to destroy the file system that the
1187 1219         clone was created from.  The clone parent-child dependency relationship
1188 1220         is reversed, so that the origin file system becomes a clone of the
1189 1221         specified file system.
1190 1222  
1191 1223         The snapshot that was cloned, and any snapshots previous to this
1192 1224         snapshot, are now owned by the promoted clone.  The space they use
1193 1225         moves from the origin file system to the promoted clone, so enough
1194 1226         space must be available to accommodate these snapshots.  No new space
1195 1227         is consumed by this operation, but the space accounting is adjusted.
1196 1228         The promoted clone must not have any conflicting snapshot names of its
1197 1229         own.  The rename subcommand can be used to rename any conflicting
1198 1230         snapshots.
1199 1231  
1200 1232       zfs rename [-f] filesystem|volume|snapshot filesystem|volume|snapshot
1201 1233  
1202 1234       zfs rename [-fp] filesystem|volume filesystem|volume
1203 1235         Renames the given dataset.  The new target can be located anywhere in
1204 1236         the ZFS hierarchy, with the exception of snapshots.  Snapshots can only
1205 1237         be renamed within the parent file system or volume.  When renaming a
1206 1238         snapshot, the parent file system of the snapshot does not need to be
1207 1239         specified as part of the second argument.  Renamed file systems can
1208 1240         inherit new mount points, in which case they are unmounted and
1209 1241         remounted at the new mount point.
1210 1242  
1211 1243         -f  Force unmount any filesystems that need to be unmounted in the
1212 1244             process.
1213 1245  
1214 1246         -p  Creates all the nonexistent parent datasets.  Datasets created in
1215 1247             this manner are automatically mounted according to the mountpoint
1216 1248             property inherited from their parent.
1217 1249  
1218 1250       zfs rename -r snapshot snapshot
1219 1251         Recursively rename the snapshots of all descendent datasets.  Snapshots
1220 1252         are the only dataset that can be renamed recursively.
1221 1253  
1222 1254       zfs list [-r|-d depth] [-Hp] [-o property[,property]...] [-s property]...
1223 1255         [-S property]... [-t type[,type]...] [filesystem|volume|snapshot]...
1224 1256         Lists the property information for the given datasets in tabular form.
1225 1257         If specified, you can list property information by the absolute
1226 1258         pathname or the relative pathname.  By default, all file systems and
1227 1259         volumes are displayed.  Snapshots are displayed if the listsnaps
1228 1260         property is on (the default is off).  The following fields are
1229 1261         displayed, name,used,available,referenced,mountpoint.
1230 1262  
1231 1263         -H  Used for scripting mode.  Do not print headers and separate fields
1232 1264             by a single tab instead of arbitrary white space.
1233 1265  
1234 1266         -S property
1235 1267             Same as the -s option, but sorts by property in descending order.
1236 1268  
1237 1269         -d depth
1238 1270             Recursively display any children of the dataset, limiting the
1239 1271             recursion to depth.  A depth of 1 will display only the dataset and
1240 1272             its direct children.
1241 1273  
1242 1274         -o property
1243 1275             A comma-separated list of properties to display.  The property must
1244 1276             be:
1245 1277  
1246 1278             o   One of the properties described in the Native Properties
1247 1279                 section
1248 1280  
1249 1281             o   A user property
1250 1282  
1251 1283             o   The value name to display the dataset name
1252 1284  
1253 1285             o   The value space to display space usage properties on file
1254 1286                 systems and volumes.  This is a shortcut for specifying -o
1255 1287                 name,avail,used,usedsnap,usedds,usedrefreserv,usedchild -t
1256 1288                 filesystem,volume syntax.
1257 1289  
1258 1290         -p  Display numbers in parsable (exact) values.
1259 1291  
1260 1292         -r  Recursively display any children of the dataset on the command
1261 1293             line.
1262 1294  
1263 1295         -s property
1264 1296             A property for sorting the output by column in ascending order
1265 1297             based on the value of the property.  The property must be one of
1266 1298             the properties described in the Properties section, or the special
1267 1299             value name to sort by the dataset name.  Multiple properties can be
1268 1300             specified at one time using multiple -s property options.  Multiple
1269 1301             -s options are evaluated from left to right in decreasing order of
1270 1302             importance.  The following is a list of sorting criteria:
1271 1303  
1272 1304             o   Numeric types sort in numeric order.
1273 1305  
1274 1306             o   String types sort in alphabetical order.
1275 1307  
1276 1308             o   Types inappropriate for a row sort that row to the literal
1277 1309                 bottom, regardless of the specified ordering.
1278 1310  
1279 1311             If no sorting options are specified the existing behavior of zfs
1280 1312             list is preserved.
1281 1313  
1282 1314         -t type
1283 1315             A comma-separated list of types to display, where type is one of
1284 1316             filesystem, snapshot, volume, bookmark, or all.  For example,
1285 1317             specifying -t snapshot displays only snapshots.
1286 1318  
1287 1319       zfs set property=value [property=value]... filesystem|volume|snapshot...
1288 1320         Sets the property or list of properties to the given value(s) for each
1289 1321         dataset.  Only some properties can be edited.  See the Properties
1290 1322         section for more information on what properties can be set and
1291 1323         acceptable values.  Numeric values can be specified as exact values, or
1292 1324         in a human-readable form with a suffix of B, K, M, G, T, P, E, Z (for
1293 1325         bytes, kilobytes, megabytes, gigabytes, terabytes, petabytes, exabytes,
1294 1326         or zettabytes, respectively).  User properties can be set on snapshots.
1295 1327         For more information, see the User Properties section.
1296 1328  
1297 1329       zfs get [-r|-d depth] [-Hp] [-o field[,field]...] [-s source[,source]...]
1298 1330         [-t type[,type]...] all | property[,property]...
1299 1331         filesystem|volume|snapshot|bookmark...
1300 1332         Displays properties for the given datasets.  If no datasets are
1301 1333         specified, then the command displays properties for all datasets on the
1302 1334         system.  For each property, the following columns are displayed:
1303 1335  
1304 1336             name      Dataset name
1305 1337             property  Property name
1306 1338             value     Property value
1307 1339             source    Property source.  Can either be local, default,
1308 1340                       temporary, inherited, or none (-).
1309 1341  
1310 1342         All columns are displayed by default, though this can be controlled by
1311 1343         using the -o option.  This command takes a comma-separated list of
1312 1344         properties as described in the Native Properties and User Properties
1313 1345         sections.
1314 1346  
1315 1347         The special value all can be used to display all properties that apply
1316 1348         to the given dataset's type (filesystem, volume, snapshot, or
1317 1349         bookmark).
1318 1350  
1319 1351         -H  Display output in a form more easily parsed by scripts.  Any
1320 1352             headers are omitted, and fields are explicitly separated by a
1321 1353             single tab instead of an arbitrary amount of space.
1322 1354  
1323 1355         -d depth
1324 1356             Recursively display any children of the dataset, limiting the
1325 1357             recursion to depth.  A depth of 1 will display only the dataset and
1326 1358             its direct children.
1327 1359  
1328 1360         -o field
1329 1361             A comma-separated list of columns to display.
1330 1362             name,property,value,source is the default value.
1331 1363  
1332 1364         -p  Display numbers in parsable (exact) values.
1333 1365  
1334 1366         -r  Recursively display properties for any children.
1335 1367  
1336 1368         -s source
1337 1369             A comma-separated list of sources to display.  Those properties
1338 1370             coming from a source other than those in this list are ignored.
1339 1371             Each source must be one of the following: local, default,
1340 1372             inherited, temporary, and none.  The default value is all sources.
1341 1373  
1342 1374         -t type
1343 1375             A comma-separated list of types to display, where type is one of
1344 1376             filesystem, snapshot, volume, bookmark, or all.
1345 1377  
1346 1378       zfs inherit [-rS] property filesystem|volume|snapshot...
1347 1379         Clears the specified property, causing it to be inherited from an
  
    | 
      ↓ open down ↓ | 
    445 lines elided | 
    
      ↑ open up ↑ | 
  
1348 1380         ancestor, restored to default if no ancestor has the property set, or
1349 1381         with the -S option reverted to the received value if one exists.  See
1350 1382         the Properties section for a listing of default values, and details on
1351 1383         which properties can be inherited.
1352 1384  
1353 1385         -r  Recursively inherit the given property for all children.
1354 1386  
1355 1387         -S  Revert the property to the received value if one exists; otherwise
1356 1388             operate as if the -S option was not specified.
1357 1389  
1358      -     zfs remap filesystem|volume
1359      -       Remap the indirect blocks in the given fileystem or volume so that they
1360      -       no longer reference blocks on previously removed vdevs and we can
1361      -       eventually shrink the size of the indirect mapping objects for the
1362      -       previously removed vdevs. Note that remapping all blocks might not be
1363      -       possible and that references from snapshots will still exist and cannot
1364      -       be remapped.
1365      -
1366 1390       zfs upgrade
1367 1391         Displays a list of file systems that are not the most recent version.
1368 1392  
1369 1393       zfs upgrade -v
1370 1394         Displays a list of currently supported file system versions.
1371 1395  
1372 1396       zfs upgrade [-r] [-V version] -a | filesystem
1373 1397         Upgrades file systems to a new on-disk version.  Once this is done, the
1374 1398         file systems will no longer be accessible on systems running older
1375 1399         versions of the software.  zfs send streams generated from new
1376 1400         snapshots of these file systems cannot be accessed on systems running
1377 1401         older versions of the software.
1378 1402  
1379 1403         In general, the file system version is independent of the pool version.
1380 1404         See zpool(1M) for information on the zpool upgrade command.
1381 1405  
1382 1406         In some cases, the file system version and the pool version are
1383 1407         interrelated and the pool version must be upgraded before the file
1384 1408         system version can be upgraded.
1385 1409  
1386 1410         -V version
1387 1411             Upgrade to the specified version.  If the -V flag is not specified,
1388 1412             this command upgrades to the most recent version.  This option can
1389 1413             only be used to increase the version number, and only up to the
1390 1414             most recent version supported by this software.
1391 1415  
1392 1416         -a  Upgrade all file systems on all imported pools.
1393 1417  
1394 1418         filesystem
1395 1419             Upgrade the specified file system.
1396 1420  
1397 1421         -r  Upgrade the specified file system and all descendent file systems.
1398 1422  
1399 1423       zfs userspace [-Hinp] [-o field[,field]...] [-s field]... [-S field]...
1400 1424         [-t type[,type]...] filesystem|snapshot
1401 1425         Displays space consumed by, and quotas on, each user in the specified
1402 1426         filesystem or snapshot.  This corresponds to the userused@user and
1403 1427         userquota@user properties.
1404 1428  
1405 1429         -H  Do not print headers, use tab-delimited output.
1406 1430  
1407 1431         -S field
1408 1432             Sort by this field in reverse order.  See -s.
1409 1433  
1410 1434         -i  Translate SID to POSIX ID.  The POSIX ID may be ephemeral if no
1411 1435             mapping exists.  Normal POSIX interfaces (for example, stat(2), ls
1412 1436             -l) perform this translation, so the -i option allows the output
1413 1437             from zfs userspace to be compared directly with those utilities.
1414 1438             However, -i may lead to confusion if some files were created by an
1415 1439             SMB user before a SMB-to-POSIX name mapping was established.  In
1416 1440             such a case, some files will be owned by the SMB entity and some by
1417 1441             the POSIX entity.  However, the -i option will report that the
1418 1442             POSIX entity has the total usage and quota for both.
1419 1443  
1420 1444         -n  Print numeric ID instead of user/group name.
1421 1445  
1422 1446         -o field[,field]...
1423 1447             Display only the specified fields from the following set: type,
1424 1448             name, used, quota.  The default is to display all fields.
1425 1449  
1426 1450         -p  Use exact (parsable) numeric output.
1427 1451  
1428 1452         -s field
1429 1453             Sort output by this field.  The -s and -S flags may be specified
1430 1454             multiple times to sort first by one field, then by another.  The
1431 1455             default is -s type -s name.
1432 1456  
1433 1457         -t type[,type]...
1434 1458             Print only the specified types from the following set: all,
1435 1459             posixuser, smbuser, posixgroup, smbgroup.  The default is -t
1436 1460             posixuser,smbuser.  The default can be changed to include group
1437 1461             types.
1438 1462  
1439 1463       zfs groupspace [-Hinp] [-o field[,field]...] [-s field]... [-S field]...
1440 1464         [-t type[,type]...] filesystem|snapshot
1441 1465         Displays space consumed by, and quotas on, each group in the specified
1442 1466         filesystem or snapshot.  This subcommand is identical to zfs userspace,
1443 1467         except that the default types to display are -t posixgroup,smbgroup.
1444 1468  
1445 1469       zfs mount
1446 1470         Displays all ZFS file systems currently mounted.
1447 1471  
1448 1472       zfs mount [-Ov] [-o options] -a | filesystem
1449 1473         Mounts ZFS file systems.
1450 1474  
1451 1475         -O  Perform an overlay mount.  See mount(1M) for more information.
1452 1476  
1453 1477         -a  Mount all available ZFS file systems.  Invoked automatically as
1454 1478             part of the boot process.
1455 1479  
1456 1480         filesystem
1457 1481             Mount the specified filesystem.
1458 1482  
1459 1483         -o options
1460 1484             An optional, comma-separated list of mount options to use
1461 1485             temporarily for the duration of the mount.  See the Temporary Mount
1462 1486             Point Properties section for details.
1463 1487  
1464 1488         -v  Report mount progress.
1465 1489  
1466 1490       zfs unmount [-f] -a | filesystem|mountpoint
1467 1491         Unmounts currently mounted ZFS file systems.
1468 1492  
1469 1493         -a  Unmount all available ZFS file systems.  Invoked automatically as
1470 1494             part of the shutdown process.
1471 1495  
1472 1496         filesystem|mountpoint
1473 1497             Unmount the specified filesystem.  The command can also be given a
1474 1498             path to a ZFS file system mount point on the system.
1475 1499  
1476 1500         -f  Forcefully unmount the file system, even if it is currently in use.
1477 1501  
1478 1502       zfs share -a | filesystem
1479 1503         Shares available ZFS file systems.
1480 1504  
1481 1505         -a  Share all available ZFS file systems.  Invoked automatically as
1482 1506             part of the boot process.
1483 1507  
1484 1508         filesystem
1485 1509             Share the specified filesystem according to the sharenfs and
1486 1510             sharesmb properties.  File systems are shared when the sharenfs or
1487 1511             sharesmb property is set.
1488 1512  
1489 1513       zfs unshare -a | filesystem|mountpoint
1490 1514         Unshares currently shared ZFS file systems.
1491 1515  
1492 1516         -a  Unshare all available ZFS file systems.  Invoked automatically as
1493 1517             part of the shutdown process.
1494 1518  
1495 1519         filesystem|mountpoint
1496 1520             Unshare the specified filesystem.  The command can also be given a
  
    | 
      ↓ open down ↓ | 
    121 lines elided | 
    
      ↑ open up ↑ | 
  
1497 1521             path to a ZFS file system shared on the system.
1498 1522  
1499 1523       zfs bookmark snapshot bookmark
1500 1524         Creates a bookmark of the given snapshot.  Bookmarks mark the point in
1501 1525         time when the snapshot was created, and can be used as the incremental
1502 1526         source for a zfs send command.
1503 1527  
1504 1528         This feature must be enabled to be used.  See zpool-features(5) for
1505 1529         details on ZFS feature flags and the bookmarks feature.
1506 1530  
1507      -     zfs send [-DLPRcenpv] [[-I|-i] snapshot] snapshot
     1531 +     zfs send [-DLPRcenpsv] [[-I|-i] snapshot] snapshot
1508 1532         Creates a stream representation of the second snapshot, which is
1509 1533         written to standard output.  The output can be redirected to a file or
1510 1534         to a different system (for example, using ssh(1)).  By default, a full
1511 1535         stream is generated.
1512 1536  
1513 1537         -D, --dedup
1514 1538             Generate a deduplicated stream.  Blocks which would have been sent
1515 1539             multiple times in the send stream will only be sent once.  The
1516 1540             receiving system must also support this feature to receive a
1517 1541             deduplicated stream.  This flag can be used regardless of the
1518 1542             dataset's dedup property, but performance will be much better if
1519 1543             the filesystem uses a dedup-capable checksum (for example, sha256).
1520 1544  
1521 1545         -I snapshot
1522 1546             Generate a stream package that sends all intermediary snapshots
1523 1547             from the first snapshot to the second snapshot.  For example, -I @a
1524 1548             fs@d is similar to -i @a fs@b; -i @b fs@c; -i @c fs@d.  The
1525 1549             incremental source may be specified as with the -i option.
1526 1550  
1527 1551         -L, --large-block
1528 1552             Generate a stream which may contain blocks larger than 128KB.  This
1529 1553             flag has no effect if the large_blocks pool feature is disabled, or
1530 1554             if the recordsize property of this filesystem has never been set
1531 1555             above 128KB.  The receiving system must have the large_blocks pool
1532 1556             feature enabled as well.  See zpool-features(5) for details on ZFS
1533 1557             feature flags and the large_blocks feature.
1534 1558  
1535 1559         -P, --parsable
1536 1560             Print machine-parsable verbose information about the stream package
1537 1561             generated.
1538 1562  
1539 1563         -R, --replicate
  
    | 
      ↓ open down ↓ | 
    22 lines elided | 
    
      ↑ open up ↑ | 
  
1540 1564             Generate a replication stream package, which will replicate the
1541 1565             specified file system, and all descendent file systems, up to the
1542 1566             named snapshot.  When received, all properties, snapshots,
1543 1567             descendent file systems, and clones are preserved.
1544 1568  
1545 1569             If the -i or -I flags are used in conjunction with the -R flag, an
1546 1570             incremental replication stream is generated.  The current values of
1547 1571             properties, and current snapshot and file system names are set when
1548 1572             the stream is received.  If the -F flag is specified when this
1549 1573             stream is received, snapshots and file systems that do not exist on
1550      -           the sending side are destroyed.
     1574 +           the sending side are destroyed.  If the -K flag is specified in
     1575 +           conjunction with -F flag, then it modifies the conventional force-
     1576 +           receive behavior to not destroy destination snapshots that are not
     1577 +           present at the replication source.
1551 1578  
1552 1579         -e, --embed
1553 1580             Generate a more compact stream by using WRITE_EMBEDDED records for
1554 1581             blocks which are stored more compactly on disk by the embedded_data
1555 1582             pool feature.  This flag has no effect if the embedded_data feature
1556 1583             is disabled.  The receiving system must have the embedded_data
1557 1584             feature enabled.  If the lz4_compress feature is active on the
1558 1585             sending system, then the receiving system must have that feature
1559 1586             enabled as well.  See zpool-features(5) for details on ZFS feature
1560 1587             flags and the embedded_data feature.
1561 1588  
1562 1589         -c, --compressed
1563 1590             Generate a more compact stream by using compressed WRITE records
1564 1591             for blocks which are compressed on disk and in memory (see the
1565 1592             compression property for details).  If the lz4_compress feature is
1566 1593             active on the sending system, then the receiving system must have
1567 1594             that feature enabled as well.  If the large_blocks feature is
1568 1595             enabled on the sending system but the -L option is not supplied in
1569 1596             conjunction with -c, then the data will be decompressed before
1570 1597             sending so it can be split into smaller block sizes.
1571 1598  
1572 1599         -i snapshot
1573 1600             Generate an incremental stream from the first snapshot (the
1574 1601             incremental source) to the second snapshot (the incremental
1575 1602             target).  The incremental source can be specified as the last
1576 1603             component of the snapshot name (the @ character and following) and
1577 1604             it is assumed to be from the same file system as the incremental
1578 1605             target.
1579 1606  
1580 1607             If the destination is a clone, the source may be the origin
1581 1608             snapshot, which must be fully specified (for example,
1582 1609             pool/fs@origin, not just @origin).
1583 1610  
1584 1611         -n, --dryrun
1585 1612             Do a dry-run ("No-op") send.  Do not generate any actual send data.
1586 1613             This is useful in conjunction with the -v or -P flags to determine
  
    | 
      ↓ open down ↓ | 
    26 lines elided | 
    
      ↑ open up ↑ | 
  
1587 1614             what data will be sent.  In this case, the verbose output will be
1588 1615             written to standard output (contrast with a non-dry-run, where the
1589 1616             stream is written to standard output and the verbose output goes to
1590 1617             standard error).
1591 1618  
1592 1619         -p, --props
1593 1620             Include the dataset's properties in the stream.  This flag is
1594 1621             implicit when -R is specified.  The receiving system must also
1595 1622             support this feature.
1596 1623  
     1624 +       -s  Calculate send stream size.  Do not generate any actual send data.
     1625 +           This is useful when one needs to know stream size in order to store
     1626 +           the stream externally.  With -v specified, provides info on stream
     1627 +           header and stream data portion sizes, in addition to the total
     1628 +           stream size.
     1629 +
1597 1630         -v, --verbose
1598 1631             Print verbose information about the stream package generated.  This
1599 1632             information includes a per-second report of how much data has been
1600 1633             sent.
1601 1634  
1602 1635             The format of the stream is committed.  You will be able to receive
1603 1636             your streams on future versions of ZFS .
1604 1637  
1605 1638       zfs send [-Lce] [-i snapshot|bookmark] filesystem|volume|snapshot
1606 1639         Generate a send stream, which may be of a filesystem, and may be
1607 1640         incremental from a bookmark.  If the destination is a filesystem or
1608 1641         volume, the pool must be read-only, or the filesystem must not be
1609 1642         mounted.  When the stream generated from a filesystem or volume is
1610 1643         received, the default snapshot name will be "--head--".
1611 1644  
1612 1645         -L, --large-block
1613 1646             Generate a stream which may contain blocks larger than 128KB.  This
1614 1647             flag has no effect if the large_blocks pool feature is disabled, or
1615 1648             if the recordsize property of this filesystem has never been set
1616 1649             above 128KB.  The receiving system must have the large_blocks pool
1617 1650             feature enabled as well.  See zpool-features(5) for details on ZFS
1618 1651             feature flags and the large_blocks feature.
1619 1652  
1620 1653         -c, --compressed
1621 1654             Generate a more compact stream by using compressed WRITE records
1622 1655             for blocks which are compressed on disk and in memory (see the
1623 1656             compression property for details).  If the lz4_compress feature is
1624 1657             active on the sending system, then the receiving system must have
1625 1658             that feature enabled as well.  If the large_blocks feature is
1626 1659             enabled on the sending system but the -L option is not supplied in
1627 1660             conjunction with -c, then the data will be decompressed before
1628 1661             sending so it can be split into smaller block sizes.
1629 1662  
1630 1663         -e, --embed
1631 1664             Generate a more compact stream by using WRITE_EMBEDDED records for
1632 1665             blocks which are stored more compactly on disk by the embedded_data
1633 1666             pool feature.  This flag has no effect if the embedded_data feature
1634 1667             is disabled.  The receiving system must have the embedded_data
1635 1668             feature enabled.  If the lz4_compress feature is active on the
1636 1669             sending system, then the receiving system must have that feature
1637 1670             enabled as well.  See zpool-features(5) for details on ZFS feature
1638 1671             flags and the embedded_data feature.
1639 1672  
1640 1673         -i snapshot|bookmark
1641 1674             Generate an incremental send stream.  The incremental source must
1642 1675             be an earlier snapshot in the destination's history.  It will
1643 1676             commonly be an earlier snapshot in the destination's file system,
1644 1677             in which case it can be specified as the last component of the name
1645 1678             (the # or @ character and following).
1646 1679  
  
    | 
      ↓ open down ↓ | 
    40 lines elided | 
    
      ↑ open up ↑ | 
  
1647 1680             If the incremental target is a clone, the incremental source can be
1648 1681             the origin snapshot, or an earlier snapshot in the origin's
1649 1682             filesystem, or the origin's origin, etc.
1650 1683  
1651 1684       zfs send [-Penv] -t receive_resume_token
1652 1685         Creates a send stream which resumes an interrupted receive.  The
1653 1686         receive_resume_token is the value of this property on the filesystem or
1654 1687         volume that was being received into.  See the documentation for zfs
1655 1688         receive -s for more details.
1656 1689  
1657      -     zfs receive [-Fnsuv] [-o origin=snapshot] filesystem|volume|snapshot
     1690 +     zfs receive [-FKsnuv] [-l filesystem|volume]... [-o property=value]...
     1691 +       [-x property]... filesystem|volume|snapshot
1658 1692  
1659      -     zfs receive [-Fnsuv] [-d|-e] [-o origin=snapshot] filesystem
     1693 +     zfs receive [-FKnsuv] [-d|-e] [-l filesystem|volume]... [-o
     1694 +       property=value]... [-x property]... filesystem
1660 1695         Creates a snapshot whose contents are as specified in the stream
1661 1696         provided on standard input.  If a full stream is received, then a new
1662 1697         file system is created as well.  Streams are created using the zfs send
1663 1698         subcommand, which by default creates a full stream.  zfs recv can be
1664 1699         used as an alias for zfs receive.
1665 1700  
1666 1701         If an incremental stream is received, then the destination file system
1667 1702         must already exist, and its most recent snapshot must match the
1668 1703         incremental stream's source.  For zvols, the destination device link is
1669 1704         destroyed and recreated, which means the zvol cannot be accessed during
1670 1705         the receive operation.
1671 1706  
1672 1707         When a snapshot replication package stream that is generated by using
1673 1708         the zfs send -R command is received, any snapshots that do not exist on
1674 1709         the sending location are destroyed by using the zfs destroy -d command.
1675 1710  
1676 1711         The name of the snapshot (and file system, if a full stream is
1677 1712         received) that this subcommand creates depends on the argument type and
1678 1713         the use of the -d or -e options.
1679 1714  
1680 1715         If the argument is a snapshot name, the specified snapshot is created.
1681 1716         If the argument is a file system or volume name, a snapshot with the
1682 1717         same name as the sent snapshot is created within the specified
1683 1718         filesystem or volume.  If neither of the -d or -e options are
1684 1719         specified, the provided target snapshot name is used exactly as
1685 1720         provided.
1686 1721  
1687 1722         The -d and -e options cause the file system name of the target snapshot
1688 1723         to be determined by appending a portion of the sent snapshot's name to
1689 1724         the specified target filesystem.  If the -d option is specified, all
1690 1725         but the first element of the sent snapshot's file system path (usually
1691 1726         the pool name) is used and any required intermediate file systems
1692 1727         within the specified one are created.  If the -e option is specified,
  
    | 
      ↓ open down ↓ | 
    23 lines elided | 
    
      ↑ open up ↑ | 
  
1693 1728         then only the last element of the sent snapshot's file system name
1694 1729         (i.e. the name of the source file system itself) is used as the target
1695 1730         file system name.
1696 1731  
1697 1732         -F  Force a rollback of the file system to the most recent snapshot
1698 1733             before performing the receive operation.  If receiving an
1699 1734             incremental replication stream (for example, one generated by zfs
1700 1735             send -R [-i|-I]), destroy snapshots and file systems that do not
1701 1736             exist on the sending side.
1702 1737  
     1738 +       -K  When force receive is enabled, do not destroy snapshots on the
     1739 +           receiving side that do not exist on the sending side.
     1740 +
1703 1741         -d  Discard the first element of the sent snapshot's file system name,
1704 1742             using the remaining elements to determine the name of the target
1705 1743             file system for the new snapshot as described in the paragraph
1706 1744             above.
1707 1745  
1708 1746         -e  Discard all but the last element of the sent snapshot's file system
1709 1747             name, using that element to determine the name of the target file
1710 1748             system for the new snapshot as described in the paragraph above.
1711 1749  
     1750 +       -l filesystem|volume
     1751 +           Limits the receive to only the filesystem or volume specified.  As
     1752 +           multiple options may be specified, this can be used to restore
     1753 +           specific filesystems or volumes from the received stream.
     1754 +
1712 1755         -n  Do not actually receive the stream.  This can be useful in
1713 1756             conjunction with the -v option to verify the name the receive
1714 1757             operation would use.
1715 1758  
     1759 +       -o property=value
     1760 +           Sets the specified property to value during receive of the stream.
     1761 +           Specifying multiple -o options is allowed.
     1762 +
1716 1763         -o origin=snapshot
1717 1764             Forces the stream to be received as a clone of the given snapshot.
1718 1765             If the stream is a full send stream, this will create the
1719 1766             filesystem described by the stream as a clone of the specified
1720 1767             snapshot.  Which snapshot was specified will not affect the success
1721 1768             or failure of the receive, as long as the snapshot does exist.  If
1722 1769             the stream is an incremental send stream, all the normal
1723 1770             verification will be performed.
1724 1771  
1725 1772         -u  File system that is associated with the received stream is not
1726 1773             mounted.
1727 1774  
1728 1775         -v  Print verbose information about the stream and the time required to
1729 1776             perform the receive operation.
1730 1777  
     1778 +       -x property
     1779 +           Excludes the specified property from the received stream as if it
     1780 +           was not included in the send stream.  Specifying multiple -x
     1781 +           options is allowed.
     1782 +
1731 1783         -s  If the receive is interrupted, save the partially received state,
1732 1784             rather than deleting it.  Interruption may be due to premature
1733 1785             termination of the stream (e.g. due to network failure or failure
1734 1786             of the remote system if the stream is being read over a network
1735 1787             connection), a checksum error in the stream, termination of the zfs
1736 1788             receive process, or unclean shutdown of the system.
1737 1789  
1738 1790             The receive can be resumed with a stream generated by zfs send -t
1739 1791             token, where the token is the value of the receive_resume_token
1740 1792             property of the filesystem or volume which is received into.
1741 1793  
1742 1794             To use this flag, the storage pool must have the extensible_dataset
1743 1795             feature enabled.  See zpool-features(5) for details on ZFS feature
1744 1796             flags.
1745 1797  
1746 1798       zfs receive -A filesystem|volume
1747 1799         Abort an interrupted zfs receive -s, deleting its saved partially
1748 1800         received state.
1749 1801  
1750 1802       zfs allow filesystem|volume
1751 1803         Displays permissions that have been delegated on the specified
1752 1804         filesystem or volume.  See the other forms of zfs allow for more
1753 1805         information.
1754 1806  
1755 1807       zfs allow [-dglu] user|group[,user|group]...
1756 1808         perm|@setname[,perm|@setname]... filesystem|volume
1757 1809       zfs
1758 1810       allow
1759 1811       [-dl]
1760 1812       -e|everyone
1761 1813       perm|@setname[,perm|@setname]...
1762 1814       filesystem|volume
1763 1815         Delegates ZFS administration permission for the file systems to non-
1764 1816         privileged users.
1765 1817  
1766 1818         -d  Allow only for the descendent file systems.
1767 1819  
1768 1820         -e|everyone
1769 1821             Specifies that the permissions be delegated to everyone.
1770 1822  
1771 1823         -g group[,group]...
1772 1824             Explicitly specify that permissions are delegated to the group.
1773 1825  
1774 1826         -l  Allow "locally" only for the specified file system.
1775 1827  
1776 1828         -u user[,user]...
1777 1829             Explicitly specify that permissions are delegated to the user.
1778 1830  
1779 1831         user|group[,user|group]...
1780 1832             Specifies to whom the permissions are delegated.  Multiple entities
1781 1833             can be specified as a comma-separated list.  If neither of the -gu
1782 1834             options are specified, then the argument is interpreted
1783 1835             preferentially as the keyword everyone, then as a user name, and
1784 1836             lastly as a group name.  To specify a user or group named
1785 1837             "everyone", use the -g or -u options.  To specify a group with the
1786 1838             same name as a user, use the -g options.
1787 1839  
1788 1840         perm|@setname[,perm|@setname]...
1789 1841             The permissions to delegate.  Multiple permissions may be specified
1790 1842             as a comma-separated list.  Permission names are the same as ZFS
1791 1843             subcommand and property names.  See the property list below.
1792 1844             Property set names, which begin with @, may be specified.  See the
1793 1845             -s form below for details.
1794 1846  
1795 1847         If neither of the -dl options are specified, or both are, then the
1796 1848         permissions are allowed for the file system or volume, and all of its
1797 1849         descendents.
1798 1850  
1799 1851         Permissions are generally the ability to use a ZFS subcommand or change
1800 1852         a ZFS property.  The following permissions are available:
1801 1853  
1802 1854         NAME             TYPE           NOTES
1803 1855         allow            subcommand     Must also have the permission that is
1804 1856                                         being allowed
1805 1857         clone            subcommand     Must also have the 'create' ability and
1806 1858                                         'mount' ability in the origin file system
1807 1859         create           subcommand     Must also have the 'mount' ability
1808 1860         destroy          subcommand     Must also have the 'mount' ability
1809 1861         diff             subcommand     Allows lookup of paths within a dataset
1810 1862                                         given an object number, and the ability
1811 1863                                         to create snapshots necessary to
1812 1864                                         'zfs diff'.
1813 1865         mount            subcommand     Allows mount/umount of ZFS datasets
1814 1866         promote          subcommand     Must also have the 'mount' and 'promote'
1815 1867                                         ability in the origin file system
1816 1868         receive          subcommand     Must also have the 'mount' and 'create'
1817 1869                                         ability
1818 1870         rename           subcommand     Must also have the 'mount' and 'create'
1819 1871                                         ability in the new parent
1820 1872         rollback         subcommand     Must also have the 'mount' ability
1821 1873         send             subcommand
1822 1874         share            subcommand     Allows sharing file systems over NFS
1823 1875                                         or SMB protocols
1824 1876         snapshot         subcommand     Must also have the 'mount' ability
1825 1877  
1826 1878         groupquota       other          Allows accessing any groupquota@...
1827 1879                                         property
1828 1880         groupused        other          Allows reading any groupused@... property
1829 1881         userprop         other          Allows changing any user property
1830 1882         userquota        other          Allows accessing any userquota@...
1831 1883                                         property
1832 1884         userused         other          Allows reading any userused@... property
1833 1885  
1834 1886         aclinherit       property
1835 1887         aclmode          property
1836 1888         atime            property
1837 1889         canmount         property
1838 1890         casesensitivity  property
1839 1891         checksum         property
1840 1892         compression      property
1841 1893         copies           property
1842 1894         devices          property
1843 1895         exec             property
1844 1896         filesystem_limit property
1845 1897         mountpoint       property
1846 1898         nbmand           property
1847 1899         normalization    property
1848 1900         primarycache     property
1849 1901         quota            property
1850 1902         readonly         property
1851 1903         recordsize       property
1852 1904         refquota         property
1853 1905         refreservation   property
1854 1906         reservation      property
1855 1907         secondarycache   property
1856 1908         setuid           property
1857 1909         sharenfs         property
1858 1910         sharesmb         property
1859 1911         snapdir          property
1860 1912         snapshot_limit   property
1861 1913         utf8only         property
1862 1914         version          property
1863 1915         volblocksize     property
1864 1916         volsize          property
1865 1917         vscan            property
1866 1918         xattr            property
1867 1919         zoned            property
1868 1920  
1869 1921       zfs allow -c perm|@setname[,perm|@setname]... filesystem|volume
1870 1922         Sets "create time" permissions.  These permissions are granted
1871 1923         (locally) to the creator of any newly-created descendent file system.
1872 1924  
1873 1925       zfs allow -s @setname perm|@setname[,perm|@setname]... filesystem|volume
1874 1926         Defines or adds permissions to a permission set.  The set can be used
1875 1927         by other zfs allow commands for the specified file system and its
1876 1928         descendents.  Sets are evaluated dynamically, so changes to a set are
1877 1929         immediately reflected.  Permission sets follow the same naming
1878 1930         restrictions as ZFS file systems, but the name must begin with @, and
1879 1931         can be no more than 64 characters long.
1880 1932  
1881 1933       zfs unallow [-dglru] user|group[,user|group]...
1882 1934         [perm|@setname[,perm|@setname]...] filesystem|volume
1883 1935         zfs unallow [-dlr] -e|everyone [perm|@setname[,perm|@setname]...]
1884 1936         filesystem|volume
1885 1937       zfs
1886 1938       unallow
1887 1939       [-r]
1888 1940       -c
1889 1941       [perm|@setname[,perm|@setname]...]
1890 1942       filesystem|volume
1891 1943         Removes permissions that were granted with the zfs allow command.  No
1892 1944         permissions are explicitly denied, so other permissions granted are
1893 1945         still in effect.  For example, if the permission is granted by an
1894 1946         ancestor.  If no permissions are specified, then all permissions for
1895 1947         the specified user, group, or everyone are removed.  Specifying
1896 1948         everyone (or using the -e option) only removes the permissions that
1897 1949         were granted to everyone, not all permissions for every user and group.
1898 1950         See the zfs allow command for a description of the -ldugec options.
1899 1951  
1900 1952         -r  Recursively remove the permissions from this file system and all
1901 1953             descendents.
1902 1954  
1903 1955       zfs unallow [-r] -s @setname [perm|@setname[,perm|@setname]...]
1904 1956         filesystem|volume
1905 1957         Removes permissions from a permission set.  If no permissions are
1906 1958         specified, then all permissions are removed, thus removing the set
1907 1959         entirely.
1908 1960  
1909 1961       zfs hold [-r] tag snapshot...
1910 1962         Adds a single reference, named with the tag argument, to the specified
1911 1963         snapshot or snapshots.  Each snapshot has its own tag namespace, and
1912 1964         tags must be unique within that space.
1913 1965  
1914 1966         If a hold exists on a snapshot, attempts to destroy that snapshot by
1915 1967         using the zfs destroy command return EBUSY.
1916 1968  
1917 1969         -r  Specifies that a hold with the given tag is applied recursively to
1918 1970             the snapshots of all descendent file systems.
1919 1971  
1920 1972       zfs holds [-r] snapshot...
1921 1973         Lists all existing user references for the given snapshot or snapshots.
1922 1974  
1923 1975         -r  Lists the holds that are set on the named descendent snapshots, in
1924 1976             addition to listing the holds on the named snapshot.
1925 1977  
1926 1978       zfs release [-r] tag snapshot...
1927 1979         Removes a single reference, named with the tag argument, from the
1928 1980         specified snapshot or snapshots.  The tag must already exist for each
1929 1981         snapshot.  If a hold exists on a snapshot, attempts to destroy that
1930 1982         snapshot by using the zfs destroy command return EBUSY.
1931 1983  
1932 1984         -r  Recursively releases a hold with the given tag on the snapshots of
1933 1985             all descendent file systems.
1934 1986  
1935 1987       zfs diff [-FHt] snapshot snapshot|filesystem
1936 1988         Display the difference between a snapshot of a given filesystem and
1937 1989         another snapshot of that filesystem from a later time or the current
1938 1990         contents of the filesystem.  The first column is a character indicating
1939 1991         the type of change, the other columns indicate pathname, new pathname
1940 1992         (in case of rename), change in link count, and optionally file type
1941 1993         and/or change time.  The types of change are:
1942 1994  
1943 1995         -       The path has been removed
1944 1996         +       The path has been created
1945 1997         M       The path has been modified
1946 1998         R       The path has been renamed
1947 1999  
1948 2000         -F  Display an indication of the type of file, in a manner similar to
1949 2001             the - option of ls(1).
1950 2002  
1951 2003             B       Block device
1952 2004             C       Character device
1953 2005             /       Directory
1954 2006             >       Door
1955 2007             |       Named pipe
1956 2008             @       Symbolic link
1957 2009             P       Event port
1958 2010             =       Socket
1959 2011             F       Regular file
1960 2012  
1961 2013         -H  Give more parsable tab-separated output, without header lines and
1962 2014             without arrows.
1963 2015  
1964 2016         -t  Display the path's inode change time as the first column of output.
1965 2017  
1966 2018       zfs program [-n] [-t timeout] [-m memory_limit] pool script [arg1 ...]
1967 2019         Executes script as a ZFS channel program on pool.  The ZFS channel
1968 2020         program interface allows ZFS administrative operations to be run
1969 2021         programmatically via a Lua script.  The entire script is executed
1970 2022         atomically, with no other administrative operations taking effect
1971 2023         concurrently.  A library of ZFS calls is made available to channel
1972 2024         program scripts.  Channel programs may only be run with root
1973 2025         privileges.
1974 2026  
1975 2027         For full documentation of the ZFS channel program interface, see the
1976 2028         manual page for
1977 2029  
1978 2030         -n
1979 2031           Executes a read-only channel program, which runs faster.  The program
1980 2032           cannot change on-disk state by calling functions from the zfs.sync
1981 2033           submodule.  The program can be used to gather information such as
1982 2034           properties and determining if changes would succeed (zfs.check.*).
1983 2035           Without this flag, all pending changes must be synced to disk before
1984 2036           a channel program can complete.
1985 2037  
1986 2038         -t timeout
1987 2039           Execution time limit, in milliseconds.  If a channel program executes
1988 2040           for longer than the provided timeout, it will be stopped and an error
1989 2041           will be returned.  The default timeout is 1000 ms, and can be set to
1990 2042           a maximum of 10000 ms.
1991 2043  
1992 2044         -m memory-limit
1993 2045           Memory limit, in bytes.  If a channel program attempts to allocate
1994 2046           more memory than the given limit, it will be stopped and an error
1995 2047           returned.  The default memory limit is 10 MB, and can be set to a
1996 2048           maximum of 100 MB.
1997 2049  
1998 2050           All remaining argument strings are passed directly to the channel
1999 2051           program as arguments.  See zfs-program(1M) for more information.
2000 2052  
2001 2053  EXIT STATUS
2002 2054       The zfs utility exits 0 on success, 1 if an error occurs, and 2 if
2003 2055       invalid command line options were specified.
2004 2056  
2005 2057  EXAMPLES
2006 2058       Example 1 Creating a ZFS File System Hierarchy
2007 2059         The following commands create a file system named pool/home and a file
2008 2060         system named pool/home/bob.  The mount point /export/home is set for
2009 2061         the parent file system, and is automatically inherited by the child
2010 2062         file system.
2011 2063  
2012 2064         # zfs create pool/home
2013 2065         # zfs set mountpoint=/export/home pool/home
2014 2066         # zfs create pool/home/bob
2015 2067  
2016 2068       Example 2 Creating a ZFS Snapshot
2017 2069         The following command creates a snapshot named yesterday.  This
2018 2070         snapshot is mounted on demand in the .zfs/snapshot directory at the
2019 2071         root of the pool/home/bob file system.
2020 2072  
2021 2073         # zfs snapshot pool/home/bob@yesterday
2022 2074  
2023 2075       Example 3 Creating and Destroying Multiple Snapshots
2024 2076         The following command creates snapshots named yesterday of pool/home
2025 2077         and all of its descendent file systems.  Each snapshot is mounted on
2026 2078         demand in the .zfs/snapshot directory at the root of its file system.
2027 2079         The second command destroys the newly created snapshots.
2028 2080  
2029 2081         # zfs snapshot -r pool/home@yesterday
2030 2082         # zfs destroy -r pool/home@yesterday
2031 2083  
2032 2084       Example 4 Disabling and Enabling File System Compression
2033 2085         The following command disables the compression property for all file
2034 2086         systems under pool/home.  The next command explicitly enables
2035 2087         compression for pool/home/anne.
2036 2088  
2037 2089         # zfs set compression=off pool/home
2038 2090         # zfs set compression=on pool/home/anne
2039 2091  
2040 2092       Example 5 Listing ZFS Datasets
2041 2093         The following command lists all active file systems and volumes in the
2042 2094         system.  Snapshots are displayed if the listsnaps property is on.  The
2043 2095         default is off.  See zpool(1M) for more information on pool properties.
2044 2096  
2045 2097         # zfs list
2046 2098         NAME                      USED  AVAIL  REFER  MOUNTPOINT
2047 2099         pool                      450K   457G    18K  /pool
2048 2100         pool/home                 315K   457G    21K  /export/home
2049 2101         pool/home/anne             18K   457G    18K  /export/home/anne
2050 2102         pool/home/bob             276K   457G   276K  /export/home/bob
2051 2103  
2052 2104       Example 6 Setting a Quota on a ZFS File System
2053 2105         The following command sets a quota of 50 Gbytes for pool/home/bob.
2054 2106  
2055 2107         # zfs set quota=50G pool/home/bob
2056 2108  
2057 2109       Example 7 Listing ZFS Properties
2058 2110         The following command lists all properties for pool/home/bob.
2059 2111  
2060 2112         # zfs get all pool/home/bob
2061 2113         NAME           PROPERTY              VALUE                  SOURCE
2062 2114         pool/home/bob  type                  filesystem             -
2063 2115         pool/home/bob  creation              Tue Jul 21 15:53 2009  -
2064 2116         pool/home/bob  used                  21K                    -
2065 2117         pool/home/bob  available             20.0G                  -
2066 2118         pool/home/bob  referenced            21K                    -
2067 2119         pool/home/bob  compressratio         1.00x                  -
2068 2120         pool/home/bob  mounted               yes                    -
2069 2121         pool/home/bob  quota                 20G                    local
2070 2122         pool/home/bob  reservation           none                   default
2071 2123         pool/home/bob  recordsize            128K                   default
2072 2124         pool/home/bob  mountpoint            /pool/home/bob         default
2073 2125         pool/home/bob  sharenfs              off                    default
2074 2126         pool/home/bob  checksum              on                     default
2075 2127         pool/home/bob  compression           on                     local
2076 2128         pool/home/bob  atime                 on                     default
2077 2129         pool/home/bob  devices               on                     default
2078 2130         pool/home/bob  exec                  on                     default
2079 2131         pool/home/bob  setuid                on                     default
2080 2132         pool/home/bob  readonly              off                    default
2081 2133         pool/home/bob  zoned                 off                    default
2082 2134         pool/home/bob  snapdir               hidden                 default
2083 2135         pool/home/bob  aclmode               discard                default
2084 2136         pool/home/bob  aclinherit            restricted             default
2085 2137         pool/home/bob  canmount              on                     default
2086 2138         pool/home/bob  xattr                 on                     default
2087 2139         pool/home/bob  copies                1                      default
2088 2140         pool/home/bob  version               4                      -
2089 2141         pool/home/bob  utf8only              off                    -
2090 2142         pool/home/bob  normalization         none                   -
2091 2143         pool/home/bob  casesensitivity       sensitive              -
2092 2144         pool/home/bob  vscan                 off                    default
2093 2145         pool/home/bob  nbmand                off                    default
2094 2146         pool/home/bob  sharesmb              off                    default
2095 2147         pool/home/bob  refquota              none                   default
2096 2148         pool/home/bob  refreservation        none                   default
2097 2149         pool/home/bob  primarycache          all                    default
2098 2150         pool/home/bob  secondarycache        all                    default
2099 2151         pool/home/bob  usedbysnapshots       0                      -
2100 2152         pool/home/bob  usedbydataset         21K                    -
2101 2153         pool/home/bob  usedbychildren        0                      -
2102 2154         pool/home/bob  usedbyrefreservation  0                      -
2103 2155  
2104 2156         The following command gets a single property value.
2105 2157  
2106 2158         # zfs get -H -o value compression pool/home/bob
2107 2159         on
2108 2160         The following command lists all properties with local settings for
2109 2161         pool/home/bob.
2110 2162  
2111 2163         # zfs get -r -s local -o name,property,value all pool/home/bob
2112 2164         NAME           PROPERTY              VALUE
2113 2165         pool/home/bob  quota                 20G
2114 2166         pool/home/bob  compression           on
2115 2167  
2116 2168       Example 8 Rolling Back a ZFS File System
2117 2169         The following command reverts the contents of pool/home/anne to the
2118 2170         snapshot named yesterday, deleting all intermediate snapshots.
2119 2171  
2120 2172         # zfs rollback -r pool/home/anne@yesterday
2121 2173  
2122 2174       Example 9 Creating a ZFS Clone
2123 2175         The following command creates a writable file system whose initial
2124 2176         contents are the same as pool/home/bob@yesterday.
2125 2177  
2126 2178         # zfs clone pool/home/bob@yesterday pool/clone
2127 2179  
2128 2180       Example 10 Promoting a ZFS Clone
2129 2181         The following commands illustrate how to test out changes to a file
2130 2182         system, and then replace the original file system with the changed one,
2131 2183         using clones, clone promotion, and renaming:
2132 2184  
2133 2185         # zfs create pool/project/production
2134 2186           populate /pool/project/production with data
2135 2187         # zfs snapshot pool/project/production@today
2136 2188         # zfs clone pool/project/production@today pool/project/beta
2137 2189           make changes to /pool/project/beta and test them
2138 2190         # zfs promote pool/project/beta
2139 2191         # zfs rename pool/project/production pool/project/legacy
2140 2192         # zfs rename pool/project/beta pool/project/production
2141 2193           once the legacy version is no longer needed, it can be destroyed
2142 2194         # zfs destroy pool/project/legacy
2143 2195  
2144 2196       Example 11 Inheriting ZFS Properties
2145 2197         The following command causes pool/home/bob and pool/home/anne to
2146 2198         inherit the checksum property from their parent.
2147 2199  
2148 2200         # zfs inherit checksum pool/home/bob pool/home/anne
2149 2201  
2150 2202       Example 12 Remotely Replicating ZFS Data
2151 2203         The following commands send a full stream and then an incremental
2152 2204         stream to a remote machine, restoring them into poolB/received/fs@a and
2153 2205         poolB/received/fs@b, respectively.  poolB must contain the file system
2154 2206         poolB/received, and must not initially contain poolB/received/fs.
2155 2207  
2156 2208         # zfs send pool/fs@a | \
2157 2209           ssh host zfs receive poolB/received/fs@a
2158 2210         # zfs send -i a pool/fs@b | \
2159 2211           ssh host zfs receive poolB/received/fs
2160 2212  
2161 2213       Example 13 Using the zfs receive -d Option
2162 2214         The following command sends a full stream of poolA/fsA/fsB@snap to a
2163 2215         remote machine, receiving it into poolB/received/fsA/fsB@snap.  The
2164 2216         fsA/fsB@snap portion of the received snapshot's name is determined from
2165 2217         the name of the sent snapshot.  poolB must contain the file system
2166 2218         poolB/received.  If poolB/received/fsA does not exist, it is created as
2167 2219         an empty file system.
2168 2220  
2169 2221         # zfs send poolA/fsA/fsB@snap | \
2170 2222           ssh host zfs receive -d poolB/received
2171 2223  
2172 2224       Example 14 Setting User Properties
2173 2225         The following example sets the user-defined com.example:department
2174 2226         property for a dataset.
2175 2227  
2176 2228         # zfs set com.example:department=12345 tank/accounting
2177 2229  
2178 2230       Example 15 Performing a Rolling Snapshot
2179 2231         The following example shows how to maintain a history of snapshots with
2180 2232         a consistent naming scheme.  To keep a week's worth of snapshots, the
2181 2233         user destroys the oldest snapshot, renames the remaining snapshots, and
2182 2234         then creates a new snapshot, as follows:
2183 2235  
2184 2236         # zfs destroy -r pool/users@7daysago
2185 2237         # zfs rename -r pool/users@6daysago @7daysago
2186 2238         # zfs rename -r pool/users@5daysago @6daysago
2187 2239         # zfs rename -r pool/users@yesterday @5daysago
2188 2240         # zfs rename -r pool/users@yesterday @4daysago
2189 2241         # zfs rename -r pool/users@yesterday @3daysago
2190 2242         # zfs rename -r pool/users@yesterday @2daysago
2191 2243         # zfs rename -r pool/users@today @yesterday
2192 2244         # zfs snapshot -r pool/users@today
2193 2245  
2194 2246       Example 16 Setting sharenfs Property Options on a ZFS File System
2195 2247         The following commands show how to set sharenfs property options to
2196 2248         enable rw access for a set of IP addresses and to enable root access
2197 2249         for system neo on the tank/home file system.
2198 2250  
2199 2251         # zfs set sharenfs='rw=@123.123.0.0/16,root=neo' tank/home
2200 2252  
2201 2253         If you are using DNS for host name resolution, specify the fully
2202 2254         qualified hostname.
2203 2255  
2204 2256       Example 17 Delegating ZFS Administration Permissions on a ZFS Dataset
2205 2257         The following example shows how to set permissions so that user cindys
2206 2258         can create, destroy, mount, and take snapshots on tank/cindys.  The
2207 2259         permissions on tank/cindys are also displayed.
2208 2260  
2209 2261         # zfs allow cindys create,destroy,mount,snapshot tank/cindys
2210 2262         # zfs allow tank/cindys
2211 2263         ---- Permissions on tank/cindys --------------------------------------
2212 2264         Local+Descendent permissions:
2213 2265                 user cindys create,destroy,mount,snapshot
2214 2266  
2215 2267         Because the tank/cindys mount point permission is set to 755 by
2216 2268         default, user cindys will be unable to mount file systems under
2217 2269         tank/cindys.  Add an ACE similar to the following syntax to provide
2218 2270         mount point access:
2219 2271  
2220 2272         # chmod A+user:cindys:add_subdirectory:allow /tank/cindys
2221 2273  
2222 2274       Example 18 Delegating Create Time Permissions on a ZFS Dataset
2223 2275         The following example shows how to grant anyone in the group staff to
2224 2276         create file systems in tank/users.  This syntax also allows staff
2225 2277         members to destroy their own file systems, but not destroy anyone
2226 2278         else's file system.  The permissions on tank/users are also displayed.
2227 2279  
2228 2280         # zfs allow staff create,mount tank/users
2229 2281         # zfs allow -c destroy tank/users
2230 2282         # zfs allow tank/users
2231 2283         ---- Permissions on tank/users ---------------------------------------
2232 2284         Permission sets:
2233 2285                 destroy
2234 2286         Local+Descendent permissions:
2235 2287                 group staff create,mount
2236 2288  
2237 2289       Example 19 Defining and Granting a Permission Set on a ZFS Dataset
2238 2290         The following example shows how to define and grant a permission set on
2239 2291         the tank/users file system.  The permissions on tank/users are also
2240 2292         displayed.
2241 2293  
2242 2294         # zfs allow -s @pset create,destroy,snapshot,mount tank/users
2243 2295         # zfs allow staff @pset tank/users
2244 2296         # zfs allow tank/users
2245 2297         ---- Permissions on tank/users ---------------------------------------
2246 2298         Permission sets:
2247 2299                 @pset create,destroy,mount,snapshot
2248 2300         Local+Descendent permissions:
2249 2301                 group staff @pset
2250 2302  
2251 2303       Example 20 Delegating Property Permissions on a ZFS Dataset
2252 2304         The following example shows to grant the ability to set quotas and
2253 2305         reservations on the users/home file system.  The permissions on
2254 2306         users/home are also displayed.
2255 2307  
2256 2308         # zfs allow cindys quota,reservation users/home
2257 2309         # zfs allow users/home
2258 2310         ---- Permissions on users/home ---------------------------------------
2259 2311         Local+Descendent permissions:
2260 2312                 user cindys quota,reservation
2261 2313         cindys% zfs set quota=10G users/home/marks
2262 2314         cindys% zfs get quota users/home/marks
2263 2315         NAME              PROPERTY  VALUE  SOURCE
2264 2316         users/home/marks  quota     10G    local
2265 2317  
2266 2318       Example 21 Removing ZFS Delegated Permissions on a ZFS Dataset
2267 2319         The following example shows how to remove the snapshot permission from
2268 2320         the staff group on the tank/users file system.  The permissions on
2269 2321         tank/users are also displayed.
2270 2322  
2271 2323         # zfs unallow staff snapshot tank/users
2272 2324         # zfs allow tank/users
2273 2325         ---- Permissions on tank/users ---------------------------------------
2274 2326         Permission sets:
2275 2327                 @pset create,destroy,mount,snapshot
2276 2328         Local+Descendent permissions:
2277 2329                 group staff @pset
2278 2330  
2279 2331       Example 22 Showing the differences between a snapshot and a ZFS Dataset
2280 2332         The following example shows how to see what has changed between a prior
2281 2333         snapshot of a ZFS dataset and its current state.  The -F option is used
2282 2334         to indicate type information for the files affected.
2283 2335  
2284 2336         # zfs diff -F tank/test@before tank/test
2285 2337         M       /       /tank/test/
  
    | 
      ↓ open down ↓ | 
    545 lines elided | 
    
      ↑ open up ↑ | 
  
2286 2338         M       F       /tank/test/linked      (+1)
2287 2339         R       F       /tank/test/oldname -> /tank/test/newname
2288 2340         -       F       /tank/test/deleted
2289 2341         +       F       /tank/test/created
2290 2342         M       F       /tank/test/modified
2291 2343  
2292 2344  INTERFACE STABILITY
2293 2345       Committed.
2294 2346  
2295 2347  SEE ALSO
2296      -     gzip(1), ssh(1), mount(1M), share(1M), sharemgr(1M), unshare(1M),
2297      -     zonecfg(1M), zpool(1M), chmod(2), stat(2), write(2), fsync(3C),
2298      -     dfstab(4), acl(5), attributes(5)
     2348 +     gzip(1), ssh(1), mount(1M), sharemgr(1M), zonecfg(1M), zpool(1M),
     2349 +     chmod(2), stat(2), write(2), fsync(3C), dfstab(4), acl(5), attributes(5),
     2350 +     sharenfs(5), sharesmb(5)
2299 2351  
2300 2352  illumos                        December 6, 2017                        illumos
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX