• slider image 168

9-6-1 man zfs ( Proxmox VE )

zfs(8)                  System Administration Commands                  zfs(8)

       zfs - configures ZFS file systems

       zfs [-?]

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

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

       zfs destroy [-fnpRrv] filesystem|volume

       zfs destroy [-dnpRrv] filesystem|volume@snap[%snap][,...]

       zfs destroy filesystem|volume#bookmark

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

       zfs rollback [-rRf] snapshot

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

       zfs promote clone-filesystem

       zfs rename [-f] filesystem|volume|snapshot

       zfs rename [-fp] filesystem|volume filesystem|volume

       zfs rename -r snapshot snapshot

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

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

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

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

       zfs upgrade [-v]

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

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

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

       zfs mount

       zfs mount [-vO] [-o options] -a | filesystem

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

       zfs share -a | filesystem

       zfs unshare -a filesystem|mountpoint

       zfs bookmark snapshot bookmark

       zfs send [-DnPpRveL] [-[iI] snapshot] snapshot

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

       zfs receive | recv [-vnFus] filesystem|volume|snapshot

       zfs receive | recv [-vnFus] [-d|-e] filesystem

       zfs allow filesystem|volume

       zfs allow [-ldug] "everyone"|user|group[,...] perm|@setname[,...]

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

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

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

       zfs unallow [-rldug] "everyone"|user|group[,...] [perm|@setname[,... ]]

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

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

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

       zfs hold [-r] tag snapshot...

       zfs holds [-r] snapshot...

       zfs release [-r] tag snapshot...

       zfs diff [-FHt] snapshot snapshot|filesystem

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


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

       A dataset can be one of the following:

       file system

           A ZFS dataset of type filesystem can be mounted within the standard
           system namespace and behaves like other  file  systems.  While  ZFS
           file systems are designed to be POSIX compliant, known issues exist
           that prevent compliance in some cases. Applications that depend  on
           standards  conformance  might fail due to nonstandard behavior when
           checking file system free space.


           A logical volume exported as a raw or block device.  This  type  of
           dataset  should only be used under special circumstances. File sys??           tems are typically used in most environments.


           A read-only version of a file system or volume at a given point  in
           time. It is specified as filesystem@name or volume@name.


           Much  like a snapshot, but without the hold on on-disk data. It can
           be used as the source of a send (but not for  a  receive).   It  is
           specified as filesystem#name or volume#name.

   ZFS File System Hierarchy
       A  ZFS  storage  pool  is  a logical collection of devices that provide
       space for datasets. A storage pool is also the root  of  the  ZFS  file
       system hierarchy.

       The root of the pool can be accessed as a file system, such as mounting
       and unmounting, taking snapshots, and setting properties. The  physical
       storage characteristics, however, are managed by the zpool(8) command.

       See zpool(8) for more information on creating and administering pools.

       A  snapshot  is  a read-only copy of a file system or volume. Snapshots
       can be created extremely quickly, and initially consume  no  additional
       space  within  the pool. As data within the active dataset changes, the
       snapshot consumes more data than would otherwise  be  shared  with  the
       active dataset.

       Snapshots  can have arbitrary names. Snapshots of volumes can be cloned
       or rolled back.  Visibility is determined by the  snapdev  property  of
       the parent volume.

       File system snapshots can be accessed under the .zfs/snapshot directory
       in the root of the file system. Snapshots are automatically mounted  on
       demand and may be unmounted at regular intervals. The visibility of the
       .zfs directory can be controlled by the snapdir property.

       A bookmark is like a snapshot, a read-only copy of  a  file  system  or
       volume.  Bookmarks  can be created extremely quickly, compared to snap??       shots, and they consume no additional space within the pool.  Bookmarks
       can also have arbitrary names, much like snapshots.

       Unlike  snapshots, bookmarks can not be accessed through the filesystem
       in any way. From a storage standpoint a bookmark just provides a way to
       reference  when a snapshot was created as a distinct object.  Bookmarks
       are initially tied to a snapshot, not the filesystem/volume,  and  they
       will  survive if the snapshot itself is destroyed.  Since they are very
       light weight there's little incentive to destroy them.

       A clone is a writable volume or file system whose initial contents  are
       the  same  as  another  dataset. As with snapshots, creating a clone is
       nearly instantaneous, and initially consumes no additional space.

       Clones can only be created from a snapshot. When a snapshot is  cloned,
       it  creates  an  implicit dependency between the parent and child. Even
       though the clone is created somewhere else in  the  dataset  hierarchy,
       the  original  snapshot  cannot be destroyed as long as a clone exists.
       The origin property exposes this dependency, and  the  destroy  command
       lists any such dependencies, if they exist.

       The clone parent-child dependency relationship can be reversed by using
       the promote subcommand. This causes the "origin" file system to  become
       a  clone  of  the  specified  file  system,  which makes it possible to
       destroy the file system that the clone was created from.

   Mount Points
       Creating a ZFS file system is a simple operation, so the number of file
       systems  per  system  is  likely to be numerous. To cope with this, ZFS
       automatically manages mounting and unmounting file systems without  the
       need  to  edit the /etc/fstab file. All automatically managed file sys??       tems are mounted by ZFS at boot time.

       By default, file systems are mounted under /path,  where  path  is  the
       name  of  the file system in the ZFS namespace. Directories are created
       and destroyed as needed.

       A file system can also have a mount point set in the  mountpoint  prop??       erty. This directory is created as needed, and ZFS automatically mounts
       the file system when the zfs mount -a command is invoked (without edit??       ing  /etc/fstab).  The  mountpoint  property  can  be  inherited, so if
       pool/home has a mount point of /export/stuff, then pool/home/user auto??       matically inherits a mount point of /export/stuff/user.

       A file system mountpoint property of none prevents the file system from
       being mounted.

       If needed, ZFS file systems can also be managed with traditional  tools
       (mount,  umount,  /etc/fstab). If a file system's mount point is set to
       legacy, ZFS makes no attempt to manage the file system, and the  admin??       istrator is responsible for mounting and unmounting the file system.

       Deduplication  is the process for removing redundant data at the block-
       level, reducing the total amount of data stored. If a file  system  has
       the  dedup  property  enabled,  duplicate  data blocks are removed syn??       chronously.  The result is that only unique data is stored  and  common
       components are shared among files.


       Deduplicating data is a very resource-intensive operation. It is gener??       ally  recommended  that  you  have  at least 1.25 GB of RAM per 1 TB of
       storage when  you  enable  deduplication.  But  calculating  the  exact
       requirenments  is  a somewhat complicated affair. Please see the Oracle
       Dedup Guide for more information..

       Enabling deduplication on an improperly-designed system will result  in
       extreme  performance  issues  (extremely  slow  filesystem and snapshot
       deletions etc.) and can potentially  lead  to  data  loss  (i.e.  unim??       portable pool due to memory exhaustion) if your system is not built for
       this purpose. Deduplication affects the processing power  (CPU),  disks
       (and the controller) as well as primary (real) memory.

       Before creating a pool with deduplication enabled, ensure that you have
       planned your hardware requirements appropriately and implemented appro??       priate recovery practices, such as regular backups.

       Unless  necessary,  deduplication  should  NOT  be enabled on a system.
       Instead, consider using compression=lz4, as a  less  resource-intensive

   Native Properties
       Properties  are  divided  into  two  types, native properties and user-
       defined (or "user") properties. Native properties either export  inter??       nal  statistics or control ZFS behavior. In addition, native properties
       are either editable or read-only. User properties have no effect on ZFS
       behavior,  but  you  can use them to annotate datasets in a way that is
       meaningful in your environment. For more information about user proper??       ties, see the "User Properties" section, below.

       Every  dataset has a set of properties that export statistics about the
       dataset as well as control various behaviors. Properties are  inherited
       from  the  parent unless overridden by the child. Some properties apply
       only to certain types of datasets  (file  systems,  volumes,  or  snap??       shots).

       The  values of numeric properties can be specified using human-readable
       suffixes (for example, k, KB,  M,  Gb,  and  so  forth,  up  to  Z  for
       zettabyte). The following are all valid (and equal) specifications:

         1536M, 1.5g, 1.50GB

       The  values  of  non-numeric  properties are case sensitive and must be
       lowercase, except for mountpoint, sharenfs, and sharesmb.

       The following native properties consist of read-only  statistics  about
       the dataset. These properties can be neither set, nor inherited. Native
       properties apply to all dataset types unless otherwise noted.


           The amount of space available to the dataset and all its  children,
           assuming that there is no other activity in the pool. Because space
           is shared within a pool, availability can be limited by any  number
           of  factors, including physical pool size, quotas, reservations, or
           other datasets within the pool.

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


           For  non-snapshots,  the  compression  ratio  achieved for the used
           space of this dataset, expressed as a multiplier.  The  used  prop??           erty  includes  descendant  datasets,  and,  for  clones,  does not
           include the space shared with the origin snapshot.  For  snapshots,
           the  compressratio  is  the  same as the refcompressratio property.
           Compression can be turned on by  running:  zfs  set  compression=on
           dataset. The default value is off.


           The time this dataset was created.


           For  snapshots, this property is a comma-separated list of filesys??           tems or volumes which are clones of  this  snapshot.   The  clones'
           origin  property  is  this snapshot.  If the clones property is not
           empty, then this snapshot can not be destroyed (even with the -r or
           -f options).


           This  property  is  on if the snapshot has been marked for deferred
           destruction by using the zfs destroy  -d  command.  Otherwise,  the
           property is off.


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


           The amount of space that is "logically" accessible by this dataset.
           See  the referenced property.  The logical space ignores the effect
           of the compression and copies properties, giving a quantity  closer
           to  the  amount  of  data  that applications see.  However, it does
           include space consumed by metadata.

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


           The  amount  of  space that is "logically" consumed by this dataset
           and all its descendents.  See the used property.  The logical space
           ignores the effect of the compression and copies properties, giving
           a quantity closer to the amount  of  data  that  applications  see.
           However, it does include space consumed by metadata.

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


           For file systems, indicates whether the file  system  is  currently
           mounted. This property can be either yes or no.


           For  cloned  file  systems  or volumes, the snapshot from which the
           clone was created. See also the clones property.


           The amount of data that is accessible by this dataset, which may or
           may  not be shared with other datasets in the pool. When a snapshot
           or clone is created, it initially references  the  same  amount  of
           space as the file system or snapshot it was created from, since its
           contents are identical.

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


           The  compression  ratio  achieved  for the referenced space of this
           dataset, expressed as a multiplier.   See  also  the  compressratio


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


           The type of dataset: filesystem, volume, or snapshot.


           The  amount  of  space consumed by this dataset and all its descen??           dents. This is the value that is  checked  against  this  dataset's
           quota  and  reservation.  The  space  used  does  not  include this
           dataset's reservation, but does take into account the  reservations
           of any descendent datasets. The amount of space that a dataset con??           sumes from its parent, as well as the  amount  of  space  that  are
           freed  if  this dataset is recursively destroyed, is the greater of
           its space used and its reservation.

           When snapshots (see the "Snapshots"  section)  are  created,  their
           space is initially shared between the snapshot and the file system,
           and possibly with previous snapshots. As the file  system  changes,
           space  that  was  previously shared becomes unique to the snapshot,
           and counted in the snapshot's space  used.  Additionally,  deleting
           snapshots  can increase the amount of space unique to (and used by)
           other snapshots.

           The amount of space used, available, or referenced  does  not  take
           into   account  pending  changes.  Pending  changes  are  generally
           accounted for within a few seconds. Committing a change to  a  disk
           using  fsync(2)  or  O_SYNC does not necessarily guarantee that the
           space usage information is updated immediately.


           The usedby* properties decompose the used properties into the vari??           ous reasons that space is used. Specifically, used = usedbychildren
           + usedbydataset + usedbyrefreservation  +,  usedbysnapshots.  These
           properties  are  only available for datasets created on zpool "ver??           sion 13" pools.


           The amount of space used by children of this dataset,  which  would
           be freed if all the dataset's children were destroyed.


           The  amount  of  space  used by this dataset itself, which would be
           freed if the dataset  were  destroyed  (after  first  removing  any
           refreservation  and  destroying  any necessary snapshots or descen??           dents).


           The amount of space used by a refreservation set on  this  dataset,
           which would be freed if the refreservation was removed.


           The  amount of space consumed by snapshots of this dataset. In par??           ticular, it is the amount of space that would be freed  if  all  of
           this dataset's snapshots were destroyed. Note that this is not sim??           ply the sum of the snapshots' used properties because space can  be
           shared by multiple snapshots.


           The amount of space consumed by the specified user in this dataset.
           Space is charged to the owner of each file, as displayed by ls  -l.
           The  amount  of space charged is displayed by du and ls -s. See the
           zfs userspace subcommand for more information.

           Unprivileged users can access only their own space usage. The  root
           user,  or  a  user who has been granted the userused privilege with
           zfs allow, can access everyone's usage.

           The userused@... properties are not displayed by zfs get  all.  The
           user's  name  must be appended after the @ symbol, using one of the
           following forms:

               o      POSIX name (for example, joe)

               o      POSIX numeric ID (for example, 789)

               o      SID name (for example, joe.smith@mydomain)

               o      SID numeric ID (for example, S-1-123-456-789)


           This property is set to the number of user holds on this  snapshot.
           User holds are set by using the zfs hold command.


           The  amount  of  space  consumed  by  the  specified  group in this
           dataset. Space is charged to the group of each file,  as  displayed
           by ls -l. See the userused@user property for more information.

           Unprivileged  users  can only access their own groups' space usage.
           The root user, or a user who has been granted the groupused  privi??           lege with zfs allow, can access all groups' usage.


           For  volumes, specifies the block size of the volume. The blocksize
           cannot be changed once the volume has been written, so it should be
           set at volume creation time. The default blocksize for volumes is 8
           Kbytes. Any power of 2 from 512 bytes to 128 Kbytes is valid.

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


           The  amount  of  referenced space written to this dataset since the
           previous snapshot.


           The amount of referenced space written to this  dataset  since  the
           specified  snapshot.   This is the space that is referenced by this
           dataset but was not referenced by the specified snapshot.

           The snapshot may be specified as a short snapshot  name  (just  the
           part  after the @), in which case it will be interpreted as a snap??           shot in the same filesystem as this dataset.   The  snapshot  be  a
           full snapshot name (filesystem@snapshot), which for clones may be a
           snapshot in the origin's filesystem (or the origin of the  origin's
           filesystem, etc).

       The following native properties can be used to change the behavior of a
       ZFS dataset.

       aclinherit=discard | noallow | restricted | passthrough | passthrough-x

           Controls how ACL entries are inherited when files  and  directories
           are  created.  A file system with an aclinherit property of discard
           does not inherit any ACL entries. A file system with an  aclinherit
           property  value  of  noallow  only inherits inheritable ACL entries
           that specify "deny" permissions. The property value restricted (the
           default) removes the write_acl and write_owner permissions when the
           ACL entry is inherited. A file system with an  aclinherit  property
           value  of  passthrough inherits all inheritable ACL entries without
           any modifications made to the ACL entries when they are  inherited.
           A  file  system  with an aclinherit property value of passthrough-x
           has the same  meaning  as  passthrough,  except  that  the  owner@,
           group@,  and  everyone@ ACEs inherit the execute permission only if
           the file creation mode also requests the execute bit.

           When the property value is set to passthrough,  files  are  created
           with  a  mode determined by the inheritable ACEs. If no inheritable
           ACEs exist that affect the mode, then the mode is set in accordance
           to the requested mode from the application.

           The aclinherit property does not apply to Posix ACLs.

       acltype=noacl | posixacl

           Controls  whether  ACLs  are  enabled and if so what type of ACL to
           use.  When a file system has the acltype property set to noacl (the
           default)  then  ACLs are disabled.  Setting the acltype property to
           posixacl indicates Posix ACLs should be used.  Posix ACLs are  spe??           cific  to  Linux  and are not functional on other platforms.  Posix
           ACLs are stored as an xattr and therefore will  not  overwrite  any
           existing ZFS/NFSv4 ACLs which may be set.  Currently only posixacls
           are supported on Linux.

           To obtain the best performance  when  setting  posixacl  users  are
           strongly encouraged to set the xattr=sa property.  This will result
           in the Posix ACL being stored more efficiently on disk.  But  as  a
           consequence of this all new xattrs will only be accessible from ZFS
           implementations which support the xattr=sa property.  See the xattr
           property for more details.

       atime=on | off

           Controls whether the access time for files is updated when they are
           read. Turning this property off avoids producing write traffic when
           reading  files  and  can  result  in significant performance gains,
           though it might confuse mailers and other  similar  utilities.  The
           default value is on.  See also relatime below.

       canmount=on | off | noauto

           If  this property is set to off, the file system cannot be mounted,
           and is ignored by zfs mount -a. Setting this  property  to  off  is
           similar to setting the mountpoint property to none, except that the
           dataset still has a normal mountpoint property, which can be inher??           ited.  Setting  this  property  to  off  allows datasets to be used
           solely as a mechanism to inherit properties. One example of setting
           canmount=off  is  to have two datasets with the same mountpoint, so
           that the children of both datasets appear in  the  same  directory,
           but might have different inherited characteristics.

           When  the  noauto  option is set, a dataset can only be mounted and
           unmounted explicitly. The dataset is not mounted automatically when
           the  dataset  is  created or imported, nor is it mounted by the zfs
           mount -a command or unmounted by the zfs unmount -a command.

           This property is not inherited.

       checksum=on | off | fletcher2,| fletcher4 | sha256

           Controls the checksum used to verify data  integrity.  The  default
           value  is  on, which automatically selects an appropriate algorithm
           (currently, fletcher4, but this may change in future releases). The
           value  off  disables  integrity  checking  on  user data. Disabling
           checksums is NOT a recommended practice.

           Changing this property affects only newly-written data.

       compression=on | off | lzjb | lz4 | gzip | gzip-N | zle

           Controls the compression algorithm used for this dataset.

           Setting compression to on indicates that the current  default  com??           pression  algorithm  should be used.  The default balances compres??           sion  and  decompression  speed,  with  compression  ratio  and  is
           expected  to  work well on a wide variety of workloads.  Unlike all
           other settings for this property, on does not select a  fixed  com??           pression  type.  As new compression algorithms are added to ZFS and
           enabled on a pool, the default compression  algorithm  may  change.
           The  current default compression algorthm is either lzjb or, if the
           lz4_compress feature is enabled, lz4.

           The lzjb compression algorithm is optimized for  performance  while
           providing decent data compression.

           The lz4 compression algorithm is a high-performance replacement for
           the lzjb algorithm. It features  significantly  faster  compression
           and decompression, as well as a moderately higher compression ratio
           than lzjb, but can only be used on pools with the lz4_compress fea??           ture  set to enabled. See zpool-features(5) for details on ZFS fea??           ture flags and the lz4_compress feature.

           The gzip compression algorithm uses the  same  compression  as  the
           gzip(1)  command. You can specify the gzip level by using the value
           gzip-N where N is an integer from 1 (fastest) to 9  (best  compres??           sion ratio). Currently, gzip is equivalent to gzip-6 (which is also
           the default for gzip(1)). The zle compression algorithm  compresses
           runs of zeros.

           This  property can also be referred to by its shortened column name
           compress. Changing this property affects only newly-written data.

       copies=1 | 2 | 3

           Controls the number of copies of  data  stored  for  this  dataset.
           These  copies  are  in  addition  to any redundancy provided by the
           pool, for example, mirroring or RAID-Z. The copies  are  stored  on
           different  disks, if possible. The space used by multiple copies is
           charged to the associated file and dataset, changing the used prop??           erty and counting against quotas and reservations.

           Changing  this property only affects newly-written data. Therefore,
           set this property at file system creation  time  by  using  the  -o
           copies=N option.

       dedup=on | off | verify | sha256[,verify]

           Controls  whether  deduplication  is  in  effect for a dataset. The
           default value is off. The default checksum used  for  deduplication
           is  sha256  (subject  to  change). When dedup is enabled, the dedup
           checksum algorithm overrides the  checksum  property.  Setting  the
           value to verify is equivalent to specifying sha256,verify.

           If  the  property  is set to verify, then, whenever two blocks have
           the same signature, ZFS will do a byte-for-byte comparison with the
           existing block to ensure that the contents are identical.

           Unless  necessary, deduplication should NOT be enabled on a system.
           See Deduplication above.

       devices=on | off

           Controls whether device nodes can be opened on  this  file  system.
           The default value is on.

       exec=on | off

           Controls  whether  processes  can be executed from within this file
           system. The default value is on.

       mlslabel=label | none

           The mlslabel property is a sensitivity label that determines  if  a
           dataset   can  be mounted in a zone on a system with Trusted Exten??           sions enabled. If the labeled dataset matches the labeled zone, the
           dataset can be mounted  and accessed from the labeled zone.

           When  the  mlslabel property is not set, the default value is none.
           Setting the  mlslabel property to none is  equivalent  to  removing
           the property.

           The  mlslabel property can be modified only when Trusted Extensions
           is enabled and only with appropriate privilege. Rights to modify it
           cannot  be  delegated.  When  changing a label to a higher label or
           setting the initial dataset label, the {PRIV_FILE_UPGRADE_SL} priv??           ilege  is  required.  When changing a label to a lower label or the
           default (none), the {PRIV_FILE_DOWNGRADE_SL} privilege is required.
           Changing  the  dataset to labels other than the default can be done
           only when the dataset is not  mounted.  When  a  dataset  with  the
           default  label  is mounted into a labeled-zone, the mount operation
           automatically sets the mlslabel property to the label of that zone.

           When Trusted Extensions is not  enabled,  only  datasets  with  the
           default label (none) can be mounted.

           Zones are a Solaris feature and are not relevant on Linux.

       filesystem_limit=count | none

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

       mountpoint=path | none | legacy

           Controls  the mount point used for this file system. See the "Mount
           Points" section for more information on how this property is used.

           When the mountpoint property is changed for a file system, the file
           system and any children that inherit the mount point are unmounted.
           If the new value is legacy, then they remain unmounted.  Otherwise,
           they  are  automatically remounted in the new location if the prop??           erty was previously legacy or none, or if they were mounted  before
           the  property was changed. In addition, any shared file systems are
           unshared and shared in the new location.

       nbmand=on | off

           Controls whether the file system should be mounted with nbmand (Non
           Blocking  mandatory  locks). This is used for CIFS clients. Changes
           to this property only take effect when the file system is  umounted
           and remounted. See mount(8) for more information on nbmand mounts.

       primarycache=all | none | metadata

           Controls  what  is cached in the primary cache (ARC). If this prop??           erty is set to all, then both user data and metadata is cached.  If
           this  property  is set to none, then neither user data nor metadata
           is cached. If this property is set to metadata, then only  metadata
           is cached. The default value is all.

       quota=size | none

           Limits  the  amount of space a dataset and its descendents can con??           sume. This property enforces a hard limit on the  amount  of  space
           used.  This  includes  all space consumed by descendents, including
           file systems and snapshots. Setting a quota on a  descendent  of  a
           dataset  that  already has a quota does not override the ancestor's
           quota, but rather imposes an additional limit.

           Quotas cannot be set on volumes, as the volsize property acts as an
           implicit quota.

       snapshot_limit=count | none

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

       userquota@user=size | none

           Limits  the amount of space consumed by the specified user. Similar
           to the refquota property, the userquota space calculation does  not
           include  space  that  is used by descendent datasets, such as snap??           shots and clones. User  space  consumption  is  identified  by  the
           userspace@user property.

           Enforcement  of user quotas may be delayed by several seconds. This
           delay means that a user might exceed their quota before the  system
           notices  that  they  are over quota and begins to refuse additional
           writes with the EDQUOT error message . See the zfs  userspace  sub??           command for more information.

           Unprivileged  users  can only access their own groups' space usage.
           The root user, or a user who has been granted the userquota  privi??           lege with zfs allow, can get and set everyone's quota.

           This  property  is not available on volumes, on file systems before
           version 4, or on pools before version 15. The userquota@... proper??           ties  are  not  displayed  by  zfs get all. The user's name must be
           appended after the @ symbol, using one of the following forms:

               o      POSIX name (for example, joe)

               o      POSIX numeric ID (for example, 789)

               o      SID name (for example, joe.smith@mydomain)

               o      SID numeric ID (for example, S-1-123-456-789)

       groupquota@group=size | none

           Limits the amount of space consumed by the specified  group.  Group
           space consumption is identified by the userquota@user property.

           Unprivileged  users  can access only their own groups' space usage.
           The root user, or a user who has been granted the groupquota privi??           lege with zfs allow, can get and set all groups' quotas.

       readonly=on | off

           Controls whether this dataset can be modified. The default value is

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


           Specifies a suggested block size for files in the file system. This
           property is designed solely for use with  database  workloads  that
           access  files  in fixed-size records. ZFS automatically tunes block
           sizes according to internal algorithms optimized for typical access

           For databases that create very large files but access them in small
           random chunks, these algorithms may  be  suboptimal.  Specifying  a
           recordsize greater than or equal to the record size of the database
           can result in significant performance gains. Use of  this  property
           for  general  purpose file systems is strongly discouraged, and may
           adversely affect performance.

           The size specified must be a power of two greater than or equal  to
           512 and less than or equal to 128 Kbytes.

           Changing  the  file  system's recordsize affects only files created
           afterward; existing files are unaffected.

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

       redundant_metadata=all | most

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

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

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

           The default value is all.

       refquota=size | none


展開 | 闔起



展開 | 闔起


2人線上 (2人在瀏覽線上書籍)

會員: 0

訪客: 2