ZFSPROPS(7)

📦
version 2.4.4 · 8 versions
, in alpine 3.23, alpine 3.24, nixos 26.05, nixpkgs unstable, ubuntu resolute, ubuntu stonking

✨ NAME ✨

okay bestie, welcome to zfsprops(7) from the Miscellaneous Information Manual 💖

zfsprops — native and user-defined properties of ZFS datasets.

🌸 DESCRIPTION 🌸

So properties are split into two types: native properties and user-defined (or "user") properties. Native properties either export internal statistics or control ZFS behavior. On top of that, native properties are either editable or read-only. User properties? They 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 info about user properties, see the “User Properties” section, below. 🫶

🧚 Native Properties

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

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

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

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

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

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

  • compressratio — For non-snapshots, the compression ratio achieved for the used space of this dataset, expressed as a multiplier. The used property includes descendant datasets, and, for clones, does not include the space shared with the origin snapshot. For snapshots, the compressratio is the same as the refcompressratio property. Compression can be turned on by running: zfs set compression=on dataset. The default value is off.
  • createtxg — The transaction group (txg) in which the dataset was created. Bookmarks have the same createtxg as the snapshot they are initially tied to. This property is suitable for ordering a list of snapshots, e.g. for incremental send and receive.
  • creation — The time this dataset was created.
  • clones — For snapshots, this property is a comma-separated list of filesystems or volumes which are clones of this snapshot. The clones' origin property is this snapshot. If the clones property is not empty, then this snapshot can not be destroyed (even with the -r or -f options). The roles of origin and clone can be swapped by promoting the clone with the zfs promote command.
  • defer_destroy — This property is on if the snapshot has been marked for deferred destroy by using the zfs destroy -d command. Otherwise, the property is off.
  • encryptionroot — For encrypted datasets, indicates where the dataset is currently inheriting its encryption key from. Loading or unloading a key for the encryptionroot will implicitly load / unload the key for any inheriting datasets (see zfs load-key and zfs unload-key for details). Clones will always share an encryption key with their origin. See the “Encryption” section of zfs-load-key(8) for details.
  • filesystem_count — The total number of filesystems and volumes that exist under this location in the dataset tree. This value is only available when a filesystem_limit has been set somewhere in the tree under which the dataset resides.
  • keystatus — Indicates if an encryption key is currently loaded into ZFS. The possible values are none, available, and unavailable. See zfs load-key and zfs unload-key.
  • guid — The 64 bit GUID of this dataset or bookmark which does not change over its entire lifetime. When a snapshot is sent to another pool, the received snapshot has the same GUID. Thus, the guid is suitable to identify a snapshot across pools.
  • logicalreferenced — The amount of space that is "logically" accessible by this dataset. See the referenced property. The logical space ignores the effect of the compression and copies properties, giving a quantity closer to the amount of data that applications see. However, it does include space consumed by metadata.

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

  • logicalused — The amount of space that is "logically" consumed by this dataset and all its descendants. 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, lused.

  • mounted — For file systems, indicates whether the file system is currently mounted. This property can be either yes or no.
  • objsetid — A unique identifier for this dataset within the pool. Unlike the dataset's guid, the objsetid of a dataset is not transferred to other pools when the snapshot is copied with a send/receive operation. The objsetid can be reused (for a new dataset) after the dataset is deleted.
  • origin — For cloned file systems or volumes, the snapshot from which the clone was created. See also the clones property.
  • receive_resume_token — For filesystems or volumes which have saved partially-completed state from zfs receive -s, this opaque token can be provided to zfs send -t to resume and complete the zfs receive.
  • redact_snaps — For bookmarks, this is the list of snapshot GUIDs the bookmark contains a redaction list for. For snapshots, this is the list of snapshot GUIDs the snapshot is redacted with respect to.
  • referenced — The amount of data that is accessible by this dataset, which may or may not be shared with other datasets in the pool. When a snapshot or clone is created, it initially references the same amount of space as the file system or snapshot it was created from, since its contents are identical.

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

  • refcompressratio — The compression ratio achieved for the referenced space of this dataset, expressed as a multiplier. See also the compressratio property.
  • snapshot_count — The total number of snapshots that exist under this location in the dataset tree. This value is only available when a snapshot_limit has been set somewhere in the tree under which the dataset resides.
  • type — The type of dataset: filesystem, volume, snapshot, or bookmark.
  • used — The amount of space consumed by this dataset and all its descendants. 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 consumes from its parent, as well as the amount of space that is freed if this dataset is recursively destroyed, is the greater of its space used and its reservation.

The used space of a snapshot (see the “Snapshots” section of zfsconcepts(7)) is space that is referenced exclusively by this snapshot. If this snapshot is destroyed, the amount of used space will be freed. Space that is shared by multiple snapshots isn't accounted for in this metric. When a snapshot is destroyed, space that was previously shared with this snapshot can become unique to snapshots adjacent to it, thus changing the used space of those snapshots. The used space of the latest snapshot can also be affected by changes in the file system. Note that the used space of a snapshot is a subset of the written space of the snapshot.

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. Periodt. 💅

  • usedby* — the usedby* properties decompose the used properties into the various reasons that space is used. Specifically, used = usedbychildren + usedbydataset + usedbyrefreservation + usedbysnapshots. These properties are only available for datasets created on zpool "version 13" pools. ✨
    • usedbychildren — the amount of space used by children of this dataset, which would be freed if all the dataset's children were destroyed. 🧚
    • usedbydataset — the amount of space used by this dataset itself, which would be freed if the dataset were destroyed (after first removing any refreservation and destroying any necessary snapshots or descendants). 💖
    • usedbyrefreservation — the amount of space used by a refreservation set on this dataset, which would be freed if the refreservation was removed. 🎀
    • usedbysnapshots — the amount of space consumed by snapshots of this dataset. In particular, it is the amount of space that would be freed if all of this dataset's snapshots were destroyed. Note that this is not simply the sum of the snapshots' used properties because space can be shared by multiple snapshots. 🌸
  • userused@user — the amount of space consumed by the specified user in this dataset. Space is charged to the owner of each file, as displayed by ls -l. The amount of space charged is displayed by du and ls -s. See the zfs userspace command for more information. 🫶

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

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

  • POSIX name ("joe")
  • POSIX numeric ID ("789")
  • SID name ("joe.smith@mydomain")
  • SID numeric ID ("S-1-123-456-789")

Files created on Linux always have POSIX owners. 🐧

  • userobjused@user — the userobjused property is similar to userused but instead it counts the number of objects consumed by a user. This property counts all objects allocated on behalf of the user, it may differ from the results of system tools such as df -i. 😭

When the property xattr=on is set on a file system additional objects will be created per-file to store extended attributes. These additional objects are reflected in the userobjused value and are counted against the user's userobjquota. When a file system is configured to use xattr=sa no additional internal objects are normally required. 💀

  • userrefs — this property is set to the number of user holds on this snapshot. User holds are set by using the zfs hold command. 🙈
  • groupused@group — the amount of space consumed by the specified group in this dataset. Space is charged to the group of each file, as displayed by ls -l. See the userused@user property for more information. 🍓

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

  • groupobjused@group — the number of objects consumed by the specified group in this dataset. Multiple objects may be charged to the group for each file when extended attributes are in use. See the userobjused@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 groupobjused privilege with zfs allow, can access all groups' usage. 👑

  • projectused@project — the amount of space consumed by the specified project in this dataset. Project is identified via the project identifier (ID) that is object-based numeral attribute. An object can inherit the project ID from its parent object (if the parent has the flag of inherit project ID that can be set and changed via chattr -/+P or zfs project -s) when being created. The privileged user can set and change object's project ID via chattr -p or zfs project -s anytime. Space is charged to the project of each file, as displayed by lsattr -p or zfs project. See the userused@user property for more information. ⭐

The root user, or a user who has been granted the projectused privilege with zfs allow, can access all projects' usage. 👑

  • projectobjused@project — the projectobjused is similar to projectused but instead it counts the number of objects consumed by project. When the property xattr=on is set on a fileset, ZFS will create additional objects per-file to store extended attributes. These additional objects are reflected in the projectobjused value and are counted against the project's projectobjquota. When a filesystem is configured to use xattr=sa no additional internal objects are required. See the userobjused@user property for more information. 💜

The root user, or a user who has been granted the projectobjused privilege with zfs allow, can access all projects' objects usage. 👑

  • snapshots_changed — provides a mechanism to quickly determine whether snapshot list has changed without having to mount a dataset or iterate the snapshot list. Specifies the time at which a snapshot for a dataset was last created or deleted. 🕒

This allows us to be more efficient how often we query snapshots. The property is persistent across mount and unmount operations only if the extensible_dataset feature is enabled. 🔥

  • volblocksize — 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 size specified must be a power of two greater than or equal to 512 B and less than or equal to 128 KiB. If the large_blocks feature is enabled on the pool, the size may be up to 16 MiB. The default size is 16 KiB. 💾

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

  • written — the amount of space referenced by this dataset, that was written since the previous snapshot (i.e. that is not referenced by the previous snapshot). ✍️
  • written@snapshot — the amount of referenced space written to this dataset since the specified snapshot. This is the space that is referenced by this dataset but was not referenced by the specified snapshot. 📝

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

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

  • aclinherit=discard|noallow|restricted|passthrough|passthrough-x — controls how ACEs are inherited when files and directories are created. 🎀
    • discard — does not inherit any ACEs. 🗑️
    • noallow — only inherits inheritable ACEs that specify "deny" permissions. 🚫
    • restricted — default, removes the write_acl and write_owner permissions when the ACE is inherited. 🔒
    • passthrough — inherits all inheritable ACEs without any modifications. 🌊
    • passthrough-x — 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 get created with a mode that's decided by the inheritable ACEs. And if there are, like, no inheritable ACEs hanging around that affect the mode? Then the mode is set according to the requested mode from the application. Simple as that. 💖

Heads up tho: the aclinherit property does not apply to POSIX ACLs. Periodt.

  • aclmode=discard|groupmask|passthrough|restricted — controls how an ACL gets modified during chmod(2), and how inherited ACEs get modified by the file creation mode:
    • discard — the default, bestie. It deletes all ACEs except for the ones representing the mode of the file or directory requested by chmod(2). Clean slate energy. 💅
    • groupmask — reduces the permissions granted in every single ALLOW entry in the ACL so they're no greater than the group permissions specified by chmod(2).
    • passthrough — no changes get made to the ACL at all, other than creating or updating the necessary ACL entries to represent the new mode of the file or directory.
    • restricted — this one's spicy 🌶️. It makes the chmod(2) operation return an error whenever it's used on any file or directory that has a non-trivial ACL whose entries can't be represented by a mode. chmod(2) is required to change the set user ID, set group ID, or sticky bits on a file or directory, since those don't have equivalent ACL entries. So if you wanna use chmod(2) on a file or directory with a non-trivial ACL while aclmode is set to restricted, you gotta first remove all the ACL entries that don't represent the current mode. Sorry, that's the rules. 🙈
  • acltype=off|nfsv4|posix — controls whether ACLs are even enabled, and if so, which type of ACL to use. When you set this to a type of ACL that the current platform doesn't support, the behavior is the same as if it were set to off. 😌
    • off — default on Linux. When a file system has the acltype property set to off, ACLs are disabled, full stop.
    • noacl — an alias for off.
    • nfsv4 — default on FreeBSD, and it means NFSv4-style ZFS ACLs should be used. These ACLs can be managed with the getfacl(1) and setfacl(1). The nfsv4 ZFS ACL type is not yet supported on Linux, just so you know. 😭
    • posix — means POSIX ACLs should be used. POSIX ACLs are specific to Linux and are not functional on other platforms. They're stored as an extended attribute, which means they will not overwrite any existing NFSv4 ACLs that might be set. 🦋
    • posixacl — an alias for posix.

To obtain the best performance when setting posix, users are strongly encouraged to set the xattr=sa property. This results in the POSIX ACL being stored more efficiently on disk. But — and this is the catch — as a consequence, all new extended attributes will only be accessible from OpenZFS implementations which support the xattr=sa property. See the xattr property for more details. 👑

  • atime=on|off — controls whether the access time for files gets updated when they're read. Turning this property off avoids producing write traffic when reading files, and it can result in significant performance gains — though it might confuse mailers and other similar utilities, ngl. The values on and off are equivalent to the atime and noatime mount options. 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 it's ignored by zfs mount -a. Setting this to off is similar to setting the mountpoint property to none, except that the dataset still has a normal mountpoint property, which can be inherited. 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. Cute, right? 🎀

When set to noauto, 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|noparity|sha512|skein|edonr|blake3 — controls the checksum used to verify data integrity. The default value is on, which automatically selects an appropriate algorithm (currently fletcher4, but this may change in future releases). The value off disables integrity checking on user data. The value noparity not only disables integrity but also disables maintaining parity for user data. This setting is used internally by a dump device residing on a RAID-Z pool and should not be used by any other dataset. Disabling checksums is NOT a recommended practice, bestie. Don't do it. 🚫

The sha512, skein, edonr, and blake3 checksum algorithms require enabling the appropriate features on the pool.

Please see zpool-features(7) for more information on these algorithms.

Changing this property affects only newly-written data. ✨

  • compression=on|off|gzip|gzip-N|lz4|lzjb|zle|zstd|zstd-N|zstd-fast|zstd-fast-N — controls the compression algorithm used for this dataset.

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

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 it can only be used on pools with the lz4_compress feature set to enabled. See zpool-features(7) for details on ZFS feature flags and the lz4_compress feature. 🔥

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

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

The zstd compression algorithm provides both high compression ratios and good performance. You can specify the zstd level by using the value zstd-N, where N is an integer from 1 (fastest) to 19 (best compression ratio). zstd is equivalent to zstd-3.

Faster speeds at the cost of the compression ratio can be requested by setting a negative zstd level. This is done using zstd-fast-N, where N is an integer in [1-10, 20, 30, …, 100, 500, 1000] which maps to a negative zstd level. The lower the level the faster the compression — 1000 provides the fastest compression and lowest compression ratio. zstd-fast is equivalent to zstd-fast-1.

The zle compression algorithm compresses runs of zeros. (Iconic behavior honestly. 🫶)

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

When any setting except off is selected, compression will explicitly check for blocks consisting of only zeroes (the NUL byte). When a zero-filled block is detected, it's stored as a hole and not compressed using the indicated compression algorithm.

All blocks are allocated as a whole number of sectors (chunks of 2^ashift bytes, e.g. 512B or 4KB). Compression may result in a non-sector-aligned size, which will be rounded up to a whole number of sectors. If compression saves less than one whole sector, the block will be stored uncompressed. Therefore, blocks whose logical size is a small number of sectors will experience less compression (e.g. for recordsize=16K with 4K sectors, which have 4 sectors per block, compression needs to save at least 25% to actually save space on disk).

There is a 12.5% default compression threshold in addition to sector rounding. The math is mathing. 💅

  • context=none|SELinux-User:SELinux-Role:SELinux-Type:Sensitivity-Level — this flag sets the SELinux context for all files in the file system under a mount point for that file system. See selinux(8) for more information.
  • fscontext=none|SELinux-User:SELinux-Role:SELinux-Type:Sensitivity-Level — this flag sets the SELinux context for the file system file system being mounted. See selinux(8) for more information.
  • defcontext=none|SELinux-User:SELinux-Role:SELinux-Type:Sensitivity-Level — this flag sets the SELinux default context for unlabeled files. See selinux(8) for more information.
  • rootcontext=none|SELinux-User:SELinux-Role:SELinux-Type:Sensitivity-Level — this flag sets the SELinux context for the root inode of the file system. See selinux(8) for more information.
  • copies=1|2|3 — controls the number of copies of data stored for this dataset. These copies are in addition to any redundancy provided by the pool — for example, mirroring or RAID-Z. The copies are stored on different disks, if possible. The space used by multiple copies is charged to the associated file and dataset, changing the used property and counting against quotas and reservations. 📊

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

Okay bestie, listen up, this is the important part. 🚨 Remember that ZFS will not import a pool with a missing top-level vdev. Do NOT create, for example, a two-disk striped pool and set copies=2 on some datasets thinking you have set up redundancy for them. When a disk fails you will not be able to import the pool and will have lost all of your data. I am not playing. 😭

Encrypted datasets may not have copies=3, since the implementation stores some encryption metadata where the third copy would normally be. 🧚

  • devices=on|off — controls whether device nodes can be opened on this file system. The default value is on. The values on and off are equivalent to the dev and nodev mount options. 🌈

dedup

dedup=off|on|verify|sha256[,verify]|sha512[,verify]|skein[,verify]|edonr,verify|blake3[,verify]

okay so this one configures deduplication for a dataset. the default value is off. the default deduplication checksum is sha256 (and yeah, that may change in the future, they warned us). when dedup is enabled, the checksum you define here overrides the checksum property. and setting the value to verify does the exact same thing as setting sha256,verify. slay, two paths one outcome ✨

if you set it to verify, ZFS does a byte-to-byte comparison whenever two blocks have the same signature, just to make sure the block contents are actually identical. and heads up bestie — specifying verify is mandatory for the edonr algorithm. no verify, no edonr, periodt.

Unless necessary, deduplication should not be enabled on a system. See the “Deduplication” section of zfsconcepts(7).

direct

direct=disabled|standard|always

this controls the behavior of Direct I/O requests (think O_DIRECT). the standard behavior for Direct I/O requests is to bypass the ARC when possible — those requests don't get cached, and performance is limited by the raw speed of the underlying disks. that's the default, btw. always makes every properly aligned read or write get treated as a direct request. disabled makes the O_DIRECT flag get silently ignored and all direct requests get handled by the ARC — and that was the default behavior for OpenZFS 2.2 and prior releases. 🙈

bypassing the ARC requires that a direct request be correctly aligned. for write requests, the starting offset and size of the request must be recordsize-aligned — if not, then the unaligned portion of the request gets silently redirected through the ARC. for read requests, there's no recordsize alignment restriction on either the starting offset or the size. all direct requests must use a page-aligned memory buffer, and the request size must be a multiple of the page size, or an error is returned. 💀

concurrently mixing buffered and direct requests to overlapping regions of a file can decrease performance — however, the resulting file will always be coherent. for example, a direct read after a buffered write will return the data from the buffered write. furthermore, if an application uses mmap(2) based file access, then in order to maintain coherency all direct requests are converted to buffered requests while the file is mapped. currently Direct I/O is not supported with zvols. and if dedup is enabled on a dataset, Direct I/O writes will not check for deduplication. Deduplication and Direct I/O writes are currently incompatible. it's giving situationship 😭

dnodesize

dnodesize=legacy|auto|1k|2k|4k|8k|16k

specifies a compatibility mode or a literal value for the size of dnodes in the file system. the default value is legacy. setting this property to anything other than legacy requires the large_dnode pool feature to be enabled. ⭐

consider setting dnodesize to auto if the dataset uses the xattr=sa property setting and the workload makes heavy use of extended attributes. this may be applicable to SELinux-enabled systems, Lustre servers, and Samba servers, for example. literal values are supported for cases where the optimal size is known in advance, and for performance testing. 🎀

leave dnodesize set to legacy if you need to receive a send stream of this dataset on a pool that doesn't enable the large_dnode feature, or if you need to import this pool on a system that doesn't support the large_dnode feature. lowkey important, don't skip this one.

this property can also be referred to by its shortened column name, dnsize. iykyk 💅

encryption

encryption=off|on|aes-128-ccm|aes-192-ccm|aes-256-ccm|aes-128-gcm|aes-192-gcm|aes-256-gcm

controls the encryption cipher suite (that's the block cipher, key length, and mode, bestie) used for this dataset. it requires the encryption feature to be enabled on the pool, and it requires a keyformat to be set at dataset creation time. 🔥

selecting encryption=on when you're creating a dataset means the default encryption suite gets selected, which is currently aes-256-gcm. and in order to provide consistent data protection, encryption must be specified at dataset creation time and it cannot be changed afterwards. one shot, no take-backs.

for more details and caveats about encryption, see the “Encryption” section of zfs-load-key(8).

keyformat

keyformat=raw|hex|passphrase

controls what format the user's encryption key will be provided as. this property is only set when the dataset is encrypted. 🦋

Raw keys and hex keys must be 32 bytes long (regardless of the chosen encryption suite) and must be randomly generated. a raw key can be generated with the following command:

# dd if=/dev/urandom bs=32 count=1 of=/path/to/output/key

Passphrases must be between 8 and 512 bytes long and will be processed through PBKDF2 before being used (see the pbkdf2iters property). and even though the encryption suite cannot be changed after dataset creation, the keyformat can be — with zfs change-key. glow up ✨

keylocation

keylocation=prompt|file:///absolute/file/path|https://address|http://address

controls where the user's encryption key will be loaded from by default, for commands such as zfs load-key and zfs mount -l. this property is only set for encrypted datasets which are encryption roots. if unspecified, the default is prompt. 🧚

even though the encryption suite cannot be changed after dataset creation, the keylocation can be — with either zfs set or zfs change-key.

if prompt is selected, ZFS will expect the key to be provided when it is required to access the encrypted data (see zfs load-key for details). if stdin is a TTY, then ZFS will ask for the key to be provided. otherwise, stdin is expected to be the key to use and will be processed as such. users should be careful not to place keys which should be kept secret on the command line, as most operating systems may expose command line arguments to other processes. 😭 and if the “raw” keyformat was used, then the key must be provided via stdin.

if a file URL is selected, the key will be loaded from the specified absolute file path.

if an HTTPS or HTTP URL is selected, it will be GETted using fetch(3), libcurl, or nothing, depending on compile-time configuration and run-time availability. the SSL_CA_CERT_FILE environment variable can be set to set the location of the concatenated certificate store. the SSL_CA_CERT_PATH environment variable can be set to override the location of the directory containing the certificate authority bundle. the SSL_CLIENT_CERT_FILE and SSL_CLIENT_KEY_FILE environment variables can be set to configure the path to the client certificate and its key. 💜

pbkdf2iters

pbkdf2iters=iterations

controls the number of PBKDF2 iterations that a passphrase encryption key should be run through when processing it into an encryption key. this property is only defined when encryption is enabled and a keyformat of passphrase is selected. the goal of PBKDF2 is to significantly increase the computational difficulty needed to brute force a user's passphrase — it does that by forcing the attacker to run each passphrase through a computationally expensive hashing function many times before they arrive at the resulting key. a user who actually knows the passphrase only has to pay this cost once. 😌

as CPUs become better at processing, this number should be raised to ensure that a brute force attack is still not possible. the current default is 350000 and the minimum is 100000. this property may be changed with zfs change-key. 👑

exec

exec=on|off

controls whether processes can be executed from within this file system. the default value is on. the values on and off are equivalent to the exec and noexec mount options. 🍓

volthreading

volthreading=on|off

controls internal zvol threading. the value off disables zvol threading, and zvol relies on application threads. the default value is on, which enables threading within a zvol. please note that this property will be overridden by the zvol_request_sync module parameter. this property is only applicable to Linux. 🌈

filesystem_limit

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 descendant of a filesystem that already has a filesystem_limit does not override the ancestor's filesystem_limit — instead it imposes an additional limit. this feature must be enabled to be used (see zpool-features(7)). no sneaky workarounds bestie 💅

special_small_blocks

special_small_blocks=size

this value represents the threshold block size for including small file or zvol blocks into the special allocation class. blocks smaller than or equal to this value — after compression and encryption — will be assigned to the special allocation class, while greater blocks will be assigned to the regular class. valid values are from 0 to maximum block size ( 16 MiB ). the default size is 0, which means no small file or zvol blocks will be allocated in the special class. 🎀

before setting this property, a special class vdev must be added to the pool. see zpoolconcepts(7) for more details on the special allocation class.

mountpoint

mountpoint=path|none|legacy

controls the mount point used for this file system. see the “Mount Points” section of zfsconcepts(7) for more information on how this property is used. 🌸

when the mountpoint property is changed for a file system, the file system and any children that inherit the mount point are unmounted. if the new value is legacy, then they remain unmounted. otherwise, they are automatically remounted in the new location if the property was previously legacy or none. in addition, any shared file systems are unshared and shared in the new location.

when the mountpoint property is set with zfs set -u , the mountpoint property is updated but dataset is not mounted or unmounted and remains as it was before. ✨

nbmand

nbmand=on|off

controls whether the file system should be mounted with nbmand (Non-blocking mandatory locks). changes to this property only take effect when the file system is unmounted and remounted. this was only supported by Linux prior to 5.15, and was buggy there, and is not supported by FreeBSD. on Solaris it's used for SMB clients. 💀 yeah, proceed with caution.

overlay

overlay=on|off

allow mounting on a busy directory or a directory which already contains files or directories. this is the default mount behavior for Linux and FreeBSD file systems — on these platforms the property is on by default. set to off to disable overlay mounts for consistency with OpenZFS on other platforms. 🫶

primarycache=all|none|metadata

okay so this one controls what goes in the primary cache — that's the ARC, the main character of caching 💅

  • all — both user data and metadata get cached
  • none — neither user data nor metadata gets cached, we're in our minimalist era
  • metadata — only metadata gets cached

The default value is all. Periodt.

quota=size|none

Caps how much space a dataset and its descendants can eat up. It's a hard limit on the space used, no negotiating.

And bestie, "descendants" is doing heavy lifting here — that includes all the space consumed by descendants, file systems and snapshots included.

Setting a quota on a descendant of a dataset that already has a quota does not override the ancestor's quota — it just piles on an additional limit. Both apply. No cap.

Quotas cannot be set on volumes, because the volsize property acts as an implicit quota. That's just how it is 🫶

snapshot_limit=count|none

Limits how many snapshots can be created on a dataset and its descendants. Same stacking rule as quotas: setting a snapshot_limit on a descendant of a dataset that already has one does not override the ancestor's — it 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-features(7)). iykyk.

userquota@user=size|none

Limits the amount of space consumed by the specified user. User space consumption is identified by the userspace@user property.

Enforcement of user quotas may be delayed by several seconds. That delay means a user might exceed their quota before the system notices they're over quota and begins to refuse additional writes with the EDQUOT error message. See the zfs userspace 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 privilege with zfs allow, can get and set everyone's quota.

This property is not available on volumes, on file systems before version 4, or on pools before version 15. The userquota@… properties are not displayed by zfs get all.

The user's name must be appended after the @ symbol, using one of the following forms:

  • POSIX name ("joe")
  • POSIX numeric ID ("789")
  • SID name ("joe.smith@mydomain")
  • SID numeric ID ("S-1-123-456-789")

Files created on Linux always have POSIX owners. 🐧

defaultuserquota=size|none

Sets a default user quota to be applied to each user for whom no user-specific quota is set. The value 0 disables defaultuserquota.

userobjquota@user=size|none

The userobjquota is similar to userquota but it limits the number of objects a user can create. Please refer to userobjused for more information about how objects are counted.

defaultuserobjquota=size|none

Sets a default user object quota to be applied to each user for whom no userobj-specific quota is set. The value 0 disables defaultuserobjquota.

groupquota@group=size|none

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

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

defaultgroupquota=size|none

Sets a default group quota to be applied to each group for whom no group-specific quota is set. The value 0 disables defaultgroupquota.

groupobjquota@group=size|none

The groupobjquota is similar to groupquota but it limits number of objects a group can consume. Please refer to userobjused for more information about how objects are counted.

defaultgroupobjquota=size|none

Sets a default group object quota to be applied to each group for whom no groupobj-specific quota is set. The value 0 disables defaultgroupobjquota.

projectquota@project=size|none

Limits the amount of space consumed by the specified project. Project space consumption is identified by the projectused@project property. Please refer to projectused for more information about how project is identified and set/changed.

The root user, or a user who has been granted the projectquota privilege with zfs allow, can access all projects' quota.

defaultprojectquota=size|none

Sets a default project quota to be applied to each project for whom no project-specific quota is set. The value 0 disables defaultprojectquota.

projectobjquota@project=size|none

The projectobjquota is similar to projectquota but it limits number of objects a project can consume. Please refer to userobjused for more information about how objects are counted.

defaultprojectobjquota=size|none

Sets a default project object quota to be applied to each project for whom no projectobj-specific quota is set. The value 0 disables defaultprojectobjquota.

readonly=on|off

Controls whether this dataset can be modified. The default value is off. The values on and off are equivalent to the ro and rw mount options.

This property can also be referred to by its shortened column name, rdonly. cute little nickname, we love that

recordsize=size

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

For databases that create very large files but access them in small random chunks, these algorithms may be suboptimal. Specifying a recordsize greater than or equal to the record size of the database can result in significant performance gains.

Use of this property for general purpose file systems is strongly discouraged, and may adversely affect performance. fr fr, don't do it just because it sounds fun 😭

The size specified must be a power of two greater than or equal to 512 B and less than or equal to 128 KiB. If the large_blocks feature is enabled on the pool, the size may be up to 16 MiB. See zpool-features(7) for details on ZFS feature flags.

Note that maximum size is still limited by default to 1 MiB on x86_32, see zfs_max_recordsize module parameter.

Changing the file system's recordsize affects only files created afterward; existing files are unaffected. No retroactive glow-ups.

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

redundant_metadata=all|most|some|none

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 mirroring or RAID-Z), and is in addition to an extra copy specified by the copies property (up to a total of 3 copies).

For example if the pool is mirrored, copies=2, and redundant_metadata=most, then ZFS stores 6 copies of most metadata, and 4 copies of data and some metadata. The math is mathing ✨

  • 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.
  • most — ZFS stores an extra copy of most types of metadata. This can improve performance of random writes, because less metadata must be written. In practice, at worst about 1000 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.
  • some — ZFS stores an extra copy of only critical metadata. This can improve file create performance since less metadata needs to be written. If a single on-disk block is corrupt, multiple user files or directories can be lost. 😬
  • none — ZFS does not store any copies of metadata redundantly. If a single on-disk block is corrupt, an entire dataset can be lost. bestie no. do not.

The default value is all.

refquota=size|none

Limits the amount of space a dataset can consume. This property enforces a hard limit on the amount of space used. This hard limit does not include space used by descendants, including file systems and snapshots. It's the "just me" quota, main character energy only 💅

refreservation=size|none|auto

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

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

If refreservation is set to auto, a volume is thick provisioned (or "not sparse"). refreservation=auto is only supported on volumes. See volsize in the “Native Properties” section for more information about sparse volumes.

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

relatime=on|off

Controls the manner in which the access time is updated when atime=on is set. Turning this property on causes the access time to be updated relative to the modify or change time. Access time is only updated if the previous access time was earlier than the current modify or change time or if the existing access time hasn't been updated within the past 24 hours. The default value is on. The values on and off are equivalent to the relatime and norelatime mount options.

reservation=size|none

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

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

secondarycache=all|none|metadata

Controls what is cached in the secondary cache — that's the L2ARC, the backup dancer of caching 🦋

  • all — both user data and metadata is cached
  • none — neither user data nor metadata is cached
  • metadata — only metadata is cached

The default value is all.

  • prefetch=all|none|metadata — this one controls what speculative prefetch is actually out here doing. 🌈
    • all → user data and metadata both get prefetched.
    • none → neither user data nor metadata. We are fasting.
    • metadata → only metadata gets prefetched, user data can wait its turn.

Default value is all.

Heads up bestie 💖 the module parameter zfs_prefetch_disable=1 can totally disable speculative prefetch — like, it bypasses anything this property does. No cap.
  • setuid=on|off — says whether the setuid bit gets respected for the file system. Default is on. And the values on and off are equivalent to the suid and nosuid mount options, periodt. 💅
  • sharesmb=on|off|opts — controls whether the file system is shared using Samba USERSHARES, and which options get used. 🎀
    • If it's not doing that, the file system is automatically shared and unshared with the zfs share and zfs unshare commands.
    • If the property is on, the net(8) command is invoked to create a USERSHARE.

SMB shares need a resource name, so a unique one gets constructed from the dataset name. The constructed name is a copy of the dataset name, except that characters which would be invalid in a resource name are replaced with underscore (_) characters. Linux does not currently support the additional options which might be available on Solaris. 😭

If the sharesmb property is set to off, the file systems are unshared.

The share is created with the ACL (Access Control List) "Everyone:F" ("F" stands for "full permissions", i.e. read and write permissions) and no guest access by default — which means Samba must be able to authenticate a real user (passwd(5)/shadow(5)-, LDAP- or smbpasswd(5)-based). So any additional access control (disallowing specific user access etc.) has to be done on the underlying file system.

When the sharesmb property is updated with zfs set -u, the property is set to the desired value, but the operation to share, reshare or unshare the dataset is not performed. That's the whole point, bestie. 👑
  • sharenfs=on|off|opts — controls whether the file system is shared via NFS, and what options are to be used. ✨
    • A file system with a sharenfs property of off is managed with the exportfs(8) command and entries in the /etc/exports file.
    • Otherwise, the file system is automatically shared and unshared with the zfs share and zfs unshare commands.
    • If the property is set to on, the dataset is shared using the default options:
sec=sys,rw,crossmnt,no_subtree_check
Real talk: these options are comma-separated, unlike the ones found in exports(5). That's deliberate — it negates the need for quoting and makes parsing with scripts way easier. 🧚

For FreeBSD, there may be multiple sets of options separated by semicolon(s). Each set of options must apply to different hosts or networks, and each set of options will create a separate line for exports(5). Any semicolon-separated option set that consists entirely of whitespace will be ignored. This use of semicolons is only for FreeBSD at this time.

See exports(5) for the meaning of the default options. Otherwise, the exportfs(8) command is invoked with options equivalent to the contents of this property.

When the sharenfs property is changed for a dataset, the dataset and any children inheriting the property are re-shared with the new options — but only if the property was previously off, or if they were shared before the property was changed. If the new property is off, the file systems are unshared.

Same energy as sharesmb: when sharenfs is updated with zfs set -u, the property is set to the desired value, but the operation to share, reshare or unshare the dataset is not performed. 🙈
  • logbias=latency|throughput — a lil hint to ZFS about how to handle synchronous write requests in this dataset. 🫶
    • latency (the default) → ZFS will use pool log devices (if configured) to handle the write requests at low latency.
    • throughput → ZFS will not use configured pool log devices to store written data. Instead it optimizes synchronous operations for global pool throughput and efficient use of resources.
  • snapdev=hidden|visible — controls whether the volume snapshot devices under /dev/zvol/⟨pool⟩ are hidden or visible. Default value is hidden. ⭐
  • snapdir=disabled|hidden|visible — controls whether the .zfs directory is disabled, hidden or visible in the root of the file system, as discussed in the "Snapshots" section of zfsconcepts(7). Default value is hidden.
  • sync=standard|always|disabled — controls the behavior of synchronous requests (e.g. fsync, O_DSYNC). 🦋
    • standard → the POSIX-specified behavior of ensuring all synchronous requests are written to stable storage and all devices are flushed to ensure data isn't cached by device controllers. This is the default.
    • always → every file system transaction is written and flushed before its system call returns. This has a large performance penalty, we're so serious.
    • disabled → synchronous requests are disabled. File system transactions are only committed to stable storage periodically. This option gives the highest performance...
...however, it is very dangerous 😭 because ZFS would be ignoring the synchronous transaction demands of applications such as databases or NFS. Administrators should only use this option when the risks are understood. That's not a vibe, that's a whole warning. 🚨
  • version=N|current — the on-disk version of this file system, which is independent of the pool version. This property can only be set to later supported versions. See the zfs upgrade command. 👑
  • volsize=size — for volumes, specifies the logical size of the volume. 🌸

By default, creating a volume establishes a reservation of equal size. For storage pools with a version number of 9 or higher, a refreservation is set instead. Any changes to volsize are reflected in an equivalent change to the reservation (or refreservation). The volsize can only be set to a multiple of volblocksize, and cannot be zero.

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

Though not recommended, a "sparse volume" (also known as "thin provisioned") can be created by specifying the -s option to the zfs create -V command, or by changing the value of the refreservation property (or reservation property on pool version 8 or earlier) after the volume has been created. A "sparse volume" is a volume where the value of refreservation is less than the size of the volume plus the space required to store its metadata. Consequently, writes to a sparse volume can fail with ENOSPC when the pool is low on space. For a sparse volume, changes to volsize are not reflected in the refreservation. A volume that is not sparse is said to be "thick provisioned". A sparse volume can become thick provisioned by setting refreservation to auto.

  • volmode=default|full|geom|dev|none — this property specifies how volumes should be exposed to the OS. 🔥
    • full → exposes volumes as fully fledged block devices, providing maximal functionality.
    • geom → literally just an alias for full, kept for compatibility.
    • dev → hides its partitions.
    • none → volumes with the property set to none are not exposed outside ZFS, but can be snapshotted, cloned, replicated, etc. — which can be suitable for backup purposes.
    • default → volume exposition is controlled by the system-wide tunable zvol_volmode, where full, dev and none are encoded as 1, 2 and 3 respectively.

Default value is full.

  • vscan=on|off — controls whether regular files should be scanned for viruses when a file is opened and closed. In addition to enabling this property, the virus scan service must also be enabled for virus scanning to occur. Default value is off. This property is not used by OpenZFS.
  • xattr=on|off|dir|sa — controls whether extended attributes are enabled for this file system. Two styles are supported: either directory-based or system-attribute-based. 💅
    • dir → directory-based extended attributes. This style imposes no practical limit on either the size or number of attributes which can be set on a file. Although under Linux the getxattr(2) and setxattr(2) system calls limit the maximum size to 64K. This is the most compatible style of extended attribute and is supported by all ZFS implementations.
    • sa → system-attribute-based xattrs (default, and equal to on). The key advantage of this type of xattr is improved performance — storing extended attributes as system attributes significantly decreases the amount of disk I/O required. Up to 64K of data may be stored per-file in the space reserved for system attributes. If there is not enough space available for an extended attribute then it will automatically be written as a directory-based xattr. System-attribute-based extended attributes are not accessible on platforms which do not support the xattr=sa feature. OpenZFS supports xattr=sa on both FreeBSD and Linux. 🌈

The use of system-attribute-based xattrs is strongly encouraged for users of SELinux or POSIX ACLs. Both of these features heavily rely on extended attributes and benefit significantly from the reduced access time.

The values on and off are equivalent to the xattr and noxattr mount options.

  • jailed=off|on — controls whether the dataset is managed from a jail. See zfs-jail(8) for more information. Jails are a FreeBSD feature and this property is not available on other platforms. 🧚
  • zoned=off|on — controls whether the dataset is managed from a non-global zone or namespace. See zfs-zone(8) for more information. Zoning is a Linux feature and this property is not available on other platforms. 🎀

Okay so listen up bestie, because these next three properties are locked in the second your file system is born and there is no take-backs. 💅 You cannot change them after the file system is created, so you should set them when you create it. If you don't set them with the zfs create or zpool create commands, they get inherited from the parent dataset. And if the parent dataset doesn't have them — like, because it was created back before these features were even supported — then the new file system just gets the default values. No cap, just defaults. 🎀

💖 casesensitivity=sensitive|insensitive|mixed

This one tells you whether the file name matching algorithm your file system uses is case-sensitive, case-insensitive, or allows a mix of both styles of matching. The default value for the casesensitivity property is sensitive, and traditionally Unix and POSIX file systems have case-sensitive file names. That's just the vibe.

The mixed value means the file system can support requests for both case-sensitive and case-insensitive matching behavior. Currently, case-insensitive matching behavior on a file system that supports mixed behavior is limited to the SMB server product. Want the full tea on what mixed actually does? Check the "ZFS Administration Guide". 🦋

✨ normalization=none|formC|formD|formKC|formKD

Indicates whether the file system should perform a Unicode normalization of file names whenever two file names are compared — and if so, which normalization algorithm it uses. Important: file names are always stored unmodified, names are only normalized as part of any comparison process. If this property is set to a legal value other than none, and the utf8only property was left unspecified, then utf8only is automatically set to on. The default value of the normalization property is none. And yes, this property cannot be changed after the file system is created. 🚫

🌸 utf8only=on|off

Indicates whether the file system should reject file names that include characters that aren't present in the UTF-8 character code set. If this property is explicitly set to off, the normalization property must either not be explicitly set or be set to none. The default value for the utf8only property is off. And nope — this property cannot be changed after the file system is created either. 💀

Also! The casesensitivity, normalization, and utf8only properties are also new permissions that can be assigned to non-privileged users by using the ZFS delegated administration feature. Iconic behavior honestly. 👑

🎀 Temporary Mount Point Properties 🎀

When a file system is mounted — either through mount(8) for legacy mounts, or via the zfs mount command for normal file systems — its mount options are set according to its properties. Here's the correlation, write it down:

atime         atime/noatime
canmount      auto/noauto
devices       dev/nodev
exec          exec/noexec
readonly      ro/rw
relatime      relatime/norelatime
setuid        suid/nosuid
xattr         xattr/noxattr
nbmand        mand/nomand
context=      context=
fscontext=    fscontext=
defcontext=   defcontext=
rootcontext=  rootcontext=

In addition, these options can be set on a per-mount basis using the -o option, without affecting the property that's stored on disk. The values you specify on the command line override the values stored in the dataset. Heads up: the nosuid option is an alias for nodevices,nosetuid. These properties are reported as "temporary" by the zfs get command. And if the properties are changed while the dataset is mounted, the new setting overrides any temporary settings. 🔥

🌈 User Properties 🌈

In addition to all the standard native properties, ZFS supports arbitrary user properties. User properties have no effect on ZFS behavior — but applications or administrators can use them to annotate datasets (file systems, volumes, and snapshots). Cute little sticky notes for your datasets. 🍓

User property names must contain a colon (":") character to distinguish them from native properties. They may contain lowercase letters, numbers, and the following punctuation characters: colon (":"), dash ("-"), period ("."), and underscore ("_"). The expected convention is that the property name is divided into two portions such as module:property, but this namespace is not enforced by ZFS. User property names can be at most 256 characters, and cannot begin with a dash ("-"). 🙈

When making programmatic use of user properties, it is strongly suggested to use a reversed DNS domain name for the module component of property names — that way two independently-developed packages are way less likely to use the same property name for different purposes. iykyk.

The values of user properties are arbitrary strings, are always inherited, and are never validated. All of the commands that operate on properties (zfs list, zfs get, zfs set, and so forth) can be used to manipulate both native properties and user properties. Use the zfs inherit command to clear a user property — and if the property isn't defined in any parent dataset, it's removed entirely. Property values are limited to 8192 bytes. 🦋

And that's a wrap on the whole page, bestie! This one came to you from OpenZFS, dated September 13, 2025, and it lives in the manual as ZFSPROPS(7). Go forth and set your properties responsibly. 💖✨🎀🫶

📦 where this page comes from