> For the complete documentation index, see [llms.txt](https://handbook.bsdcn.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://handbook.bsdcn.org/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md).

# 23.10.ZFS 特性和术语

ZFS 不仅仅是文件系统，它在本质上是不同的。ZFS 将文件系统和卷管理器的角色结合起来，使得新的存储设备可以添加到在线系统中，并且这些新的空间可以立刻在该池中现有的文件系统上使用。通过将传统上分开的角色合并，ZFS 能克服之前阻止 RAID 组扩展的限制。*vdev* 是池中的顶级设备，可以是简单的磁盘，也可以是 RAID 阵列，例如镜像或 RAID-Z 阵列。ZFS 文件系统（称为 *数据集*）每个都可以访问整个池的合并空闲空间。池中已使用的块会减少每个文件系统可用的空间。这种方法避免了大量分区时常见的陷阱，其中空闲空间在各个分区中变得碎片化。

| 术语           | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 池            | 存储 *池* 是 ZFS 的最基本构建模块。池由一个或多个 vdev 组成，这些 vdev 是存储数据的底层设备。然后，可以使用池来创建一个或多个文件系统（数据集）或块设备（卷）。这些数据集和卷共享池中的剩余空闲空间。每个池都有一个唯一的名称和 GUID。现代 OpenZFS 创建的池处于池版本 5000；从该版本起，各项能力由 *功能标志*（feature flags）管理，而不再由版本号管理。详见 **zpool-features(7)**。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| vdev 类型      | <p>池由一个或多个 vdev 组成，vdev 本身是磁盘或多个磁盘组成的 RAID。当使用多个 vdev 时，ZFS 会将数据分布到各个 vdev 上，以提高性能并最大化可用空间。所有 vdev 的大小必须至少为 64 MB。<br><strong>磁盘 (Disk)</strong> - 最基本的 vdev 类型是标准块设备。这可以是整个磁盘（如 <strong>/dev/ada0</strong> 或 <strong>/dev/da0</strong>）或一个分区（如 <strong>/dev/ada0p3</strong>）。在 FreeBSD 上，使用分区而不是整个磁盘不会带来性能损失。这与 Solaris 文档中的推荐不同。<br><strong>当心：</strong> 强烈不建议将整个磁盘作为引导池的一部分，因为这可能导致池无法引导。同样，不应将整个磁盘作为镜像或 RAID-Z vdev 的一部分。由于在引导时无法可靠地确定未分区磁盘的大小，因此没有地方可以放置引导代码。<br><strong>文件 (File)</strong> - 常规文件也可以构成 ZFS 池，这对于测试和实验非常有用。使用文件的完整路径作为设备路径来创建池（<code>zpool create</code>）。<br><strong>镜像 (Mirror)</strong> - 创建镜像时，指定 <code>mirror</code> 关键字，后跟镜像成员设备的列表。镜像由两个或更多设备组成，将所有数据写入所有成员设备。镜像 vdev 将保存与其最小成员相同数量的数据。镜像 vdev 可以承受除一个成员外的所有成员的故障，而不会丢失任何数据。<br><strong>注意：</strong> 要随时将常规单个磁盘 vdev 升级为镜像 vdev，请使用 <code>zpool attach</code>。<br><strong>RAID-Z</strong> - ZFS 使用 RAID-Z，它是标准 RAID-5 的一种变体，提供了更好的奇偶校验分布，并消除了“RAID-5 写入漏洞”，即在意外重启后数据和奇偶校验信息不一致的情况。ZFS 支持三个级别的 RAID-Z，提供不同程度的冗余，以换取递减的可用存储空间。ZFS 根据阵列中奇偶校验设备的数量和池停止运行前可以故障的磁盘数量，使用 RAID-Z1 到 RAID-Z3。<br>在 RAID-Z1 配置中，四个磁盘，每个 1 TB，实际可用存储为 3 TB，并且池可以在一个磁盘故障的情况下以降级模式运行。如果在更换和重新同步故障磁盘之前另一个磁盘掉线，则会丢失所有池数据。<br>在 RAID-Z3 配置中，八个 1 TB 的磁盘，卷提供 5 TB 的可用空间，并且在三个磁盘故障的情况下仍能运行。传统的建议是每个 vdev 最多不超过九个磁盘。如果配置中包含更多磁盘，建议将它们分成多个 vdev，并跨它们条带化池数据。<br>两个 RAID-Z2 vdev 配置，每个包含 8 个磁盘，类似于 RAID-60 阵列。RAID-Z 组的存储容量大约是最小磁盘大小乘以非奇偶校验磁盘的数量。四个 1 TB 磁盘的 RAID-Z1 配置有效大小约为 3 TB，而八个 1 TB 磁盘的 RAID-Z3 配置提供约 5 TB 的可用空间。<br>借助 RAID-Z 扩展（RAID-Z expansion）功能，可以一次向 raidz vdev 添加一块磁盘来扩展其容量，该功能需要 OpenZFS 2.3 或更高版本，首次在 FreeBSD 15.0 中提供。<br><strong>dRAID</strong> - RAID-Z 的一种变体，使用固定宽度的条带将数据、奇偶校验和备用容量分布到所有成员磁盘上。与专用的热备盘不同，dRAID 提供 <em>分布式备用</em>（distributed spares）：备用容量分布在每个成员磁盘上，允许故障磁盘的数据按顺序同时重建到所有剩余磁盘上，恢复冗余的速度远快于传统地向单个备用盘重新同步。dRAID vdev 的指定格式为 <code>draid\[parity]\[:datad]\[:childrenc]\[:sparess]</code>，详见 <strong>zpoolconcepts(7)</strong>。<br><strong>备用 (Spare)</strong> - ZFS 具有一种特殊的伪 vdev 类型，用于跟踪可用的热备份。当启用 <strong>zfsd(8)</strong> 时，ZFS 会自动部署已安装的热备份来替换故障设备；否则，需要手动配置它们来替换故障设备，使用 <code>zpool replace</code>。<br><strong>日志 (Log)</strong> - 每个池都有一个 ZFS 意图日志（<a href="/pages/0pPztdCSobpg1jmdU0i0">ZIL</a>），默认存储在常规池设备上。专用日志 vdev（通常称为 SLOG）将意图日志转移到独立设备，通常是 SSD。拥有专用日志设备可以提高高同步写入量应用程序（如数据库）的性能。日志设备可以镜像，但不支持 RAID-Z。如果使用多个日志设备，写入将会负载均衡。<br><strong>缓存 (Cache)</strong> - 向池中添加缓存 vdev 将会将缓存的存储添加到 <a href="/pages/0pPztdCSobpg1jmdU0i0">L2ARC</a>。缓存设备不能镜像。由于缓存设备仅存储现有数据的新副本，因此不会有数据丢失的风险。<br><strong>特殊/去重 (Special/Dedup)</strong> - 分配类 vdev，将池元数据、可选的小文件块（由 <code>special\_small\_blocks</code> 数据集属性控制）以及去重表存储在 SSD 等快速设备上，从而加速由较慢磁盘组成的池。这些 vdev 对池至关重要：丢失特殊或去重 vdev 会导致整个池丢失，因此应为它们提供与数据 vdev 相同级别的冗余。</p> |
| 事务组（TXG）     | <p>事务组（Transaction Groups）是 ZFS 将块更改组合在一起并写入池的方式。事务组是 ZFS 用于确保一致性的原子单位。ZFS 为每个事务组分配一个唯一的 64 位连续标识符。最多可以有三个活动事务组，分别处于以下三种状态之一：<br><strong>开放 (Open)</strong> - 新的事务组在开放状态下开始，并接受新的写入。如果事务组达到限制，它可能会拒绝新的写入。每个时候总会有一个事务组处于开放状态，但如果达到限制，或者达到 <a href="/pages/jyweHfk8DgTvjX6rMMOI"><code>vfs.zfs.txg.timeout</code></a>，事务组会进入下一个状态。<br><strong>静默 (Quiescing)</strong> - 一个短暂的状态，让任何挂起的操作能完成，而不阻塞新的开放事务组的创建。待该事务组中的所有事务完成，事务组会进入最终状态。<br><strong>同步 (Syncing)</strong> - 将事务组中的所有数据写入稳定存储。这个过程会反过来改变其他数据，如元数据和空间映射，ZFS 也会将它们写入稳定存储。同步过程包含多个阶段。在第一个阶段，所有更改过的数据块会被写入；接下来是元数据，它可能需要多个阶段才能完成。由于为数据块分配空间会生成新的元数据，因此同步状态不能在一个阶段完成，直到没有使用新空间的阶段完成。同步状态还是 <em>synctasks</em> 完成的地方。Synctasks 是管理操作，如创建或销毁快照和数据集，它们完成 uberblock 的更改。待同步状态完成，处于静默状态的事务组会进入同步状态。所有管理功能，如 <a href="/pages/0pPztdCSobpg1jmdU0i0">快照</a> 写入都会作为事务组的一部分。ZFS 会将创建的 synctask 添加到开放事务组，并尽可能快速地将该组推进到同步状态，以减少管理命令的延迟。</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 自适应替换缓存（ARC） | ZFS 使用自适应替换缓存（ARC），而不是传统的最近最少使用（LRU）缓存。LRU 缓存是简单的缓存项目列表，按对象被使用的最近时间排序，将新项目添加到列表头部。当缓存满时，从列表尾部驱逐项目，以为更多活跃对象腾出空间。ARC 由四个列表组成：最近使用（MRU）和最频繁使用（MFU）的对象，以及每个列表的幽灵列表。这些幽灵列表跟踪被驱逐的对象，以防止它们重新加入缓存。这通过避免有偶尔使用历史的对象，增加了缓存命中率。使用 MRU 和 MFU 的另一个优点是，扫描整个文件系统时，MRU 或 LRU 缓存中的所有数据都会被驱逐，以便容纳这些新访问的内容。而在 ZFS 中，还使用了 MFU 来跟踪最频繁使用的对象，最常访问的块的缓存保持在缓存中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| L2ARC        | L2ARC 是 ZFS 缓存系统的第二级。RAM 存储了主要的 ARC。由于可用 RAM 的数量通常有限，ZFS 还可以使用 [缓存 vdevs](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md)。固态硬盘（SSDs）常用作这些缓存设备，因为它们相比传统的旋转磁盘具有更高的速度和更低的延迟。L2ARC 是完全可选的，但如果有，它将提高从 SSD 上缓存文件的读取速度，而不必从常规磁盘中读取。L2ARC 还可以加速 [去重](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md)，因为一个适合放入 L2ARC 但不能放入 RAM 的去重表（DDT）将比必须从磁盘读取的 DDT 快得多。自 OpenZFS 2.0 起，L2ARC 是持久化的：重启后，ZFS 会从缓存设备上存储的头部重建缓存内容，而不是从空缓存开始。对添加到缓存设备的数据速率的限制可以防止通过额外写入过早耗损 SSD。直到缓存满（驱逐第一个块以腾出空间），写入到 L2ARC 的速度限制为写入限制和加速限制的总和，之后将限制为写入限制。成对的 [sysctl(8)](https://man.freebsd.org/cgi/man.cgi?query=sysctl\&sektion=8\&format=html) 值控制这些速率限制：`vfs.zfs.l2arc.write_max` 控制每秒写入到缓存的字节数，而 `vfs.zfs.l2arc.write_boost` 在缓存首次驱逐之前增加此限制。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ZIL          | ZFS 意图日志（ZIL）是 ZFS 在崩溃后重放同步写入时使用的磁盘记录。每个池都有一个 ZIL；默认情况下，它占用常规池设备上的一小部分空间。当应用程序请求同步写入（保证数据已写入磁盘，而不是仅缓存以便后续写入）时，ZFS 先将数据提交到 ZIL，再在下个事务组中将其刷新到常规存储。将 ZIL 转移到比主存储更快的专用 [日志 vdev](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md)（SLOG）上（如 SSD），可以大幅降低延迟并提高性能。像数据库这样的同步工作负载将从仅使用快速 ZIL 中受益。常规的异步写入（如复制文件）则完全不会使用 ZIL。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 写时复制         | 与传统文件系统不同，ZFS 写入的是不同的块，而不是在原地覆盖旧数据。完成写入时，元数据会更新以指向新位置。当发生短写（如系统崩溃或在写文件过程中断电）时，文件的原始全部内容仍然可用，ZFS 会丢弃不完整的写入。这也意味着 ZFS 在意外关机后不需要执行 [fsck(8)](https://man.freebsd.org/cgi/man.cgi?query=fsck\&sektion=8\&format=html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 数据集          | *数据集* 是 ZFS 文件系统、卷、快照或克隆的通用术语。每个数据集都有一个唯一的名称，格式为 *poolname/path\@snapshot*。池的根目录本身也是一个数据集。子数据集具有类似目录的层次结构名称。例如，*mypool/home* 作为 home 数据集，是 *mypool* 的子数据集，并继承其属性。可以通过创建 *mypool/home/user* 来进一步扩展。这个孙子数据集将继承父数据集和祖父数据集的属性。可以在子数据集上设置属性，覆盖从父数据集和祖父数据集继承的默认值。数据集及其子数据集的管理可以[委派](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.5.-wei-tuo-guan-li.md)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 文件系统         | ZFS 数据集通常用作文件系统。与大多数其他文件系统一样，ZFS 文件系统挂载在系统目录结构中的某个位置，并包含自己的文件和目录，这些文件和目录具有权限、标志以及其他元数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 卷            | ZFS 还可以创建卷，这些卷表现为磁盘设备。卷具有与数据集相似的许多特性，包括写时复制、快照、克隆和校验和。卷对于在 ZFS 上运行其他文件系统格式非常有用，例如 UFS 虚拟化或导出 iSCSI 扩展。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 快照           | ZFS 的 [写时复制](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md)（COW）设计能几乎瞬时地创建一致的快照，并可以使用任意名称。在对数据集创建快照或对父数据集递归创建快照（包括所有子数据集）后，新数据会写入新块，但不会回收旧块作为空闲空间。快照包含原始文件系统版本，而实时文件系统则包含自快照以来所做的任何更改，且不占用其他空间。写入实时文件系统的新数据会使用新块存储这些数据。快照将随着块在实时文件系统中不再使用，而仅在快照中使用而增长。以只读方式挂载这些快照可以恢复以前的文件版本。可以对实时文件系统执行 [回滚](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.4.-zfs-guan-li.md) 操作，将其恢复到特定快照，从而撤销自快照以来所做的任何更改。池中的每个块都有一个引用计数器，用于跟踪哪些快照、克隆、数据集或卷使用了该块。当文件和快照被删除时，引用计数减少，当不再引用块时，空闲空间被回收。标记快照为 [保留](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.4.-zfs-guan-li.md) 会导致任何尝试销毁该快照的操作返回 `EBUSY` 错误。每个快照可以有一个唯一名称的保留。使用 [释放](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.4.-zfs-guan-li.md) 命令移除保留，从而可以删除快照。快照、克隆和回滚可以在卷上操作，但无法独立挂载。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 克隆           | 快照的克隆也是可能的。克隆是快照的可写版本，能让文件系统作为新数据集分叉。与快照一样，克隆最初不消耗任何新空间。当新数据写入克隆时，它会使用新块，从而使克隆的大小增长。当克隆的文件系统或卷中的块被覆盖时，之前块的引用计数会减少。删除克隆所基于的快照是不可能的，因为克隆依赖于它。快照是父级，克隆是子级。克隆可以被提升，从而反转这个依赖关系，使克隆成为父级，原父级成为子级。这个操作不需要新的空间。由于父级和子级使用的空间量会反转，它可能会影响现有的配额和预留。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 校验和          | <p>每个块也都有校验和。使用的校验和算法是每个数据集的属性，参见 <a href="/pages/VbcZCn1GSRqHbE8CSxpj">set</a>。每个块的校验和在读取时会透明验证，这使得 ZFS 可以检测到静默损坏。如果读取的数据与预期的校验和不匹配，ZFS 将尝试从任何可用的冗余（如镜像或 RAID-Z）中恢复数据。可以使用 <a href="/pages/0pPztdCSobpg1jmdU0i0">scrub</a> 来触发所有校验和的验证。校验和算法包括：<code>fletcher2</code>、<code>fletcher4</code>、<code>sha256</code>、<code>sha512</code>、<code>skein</code>、<code>edonr</code>、<code>blake3</code>（自 FreeBSD 14.0 起）。<br><code>fletcher</code> 算法更快，但加密哈希（<code>sha256</code>、<code>sha512</code>、<code>skein</code>、<code>edonr</code> 和 <code>blake3</code>）具有更低的碰撞概率，但性能稍差。默认值 <code>on</code> 目前选择 <code>fletcher4</code>；<a href="/pages/0pPztdCSobpg1jmdU0i0">去重</a> 需要诸如 <code>sha256</code> 之类的加密哈希。禁用校验和是可能的，但极不推荐。</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 压缩           | <p>每个数据集都有一个压缩属性。自 OpenZFS 2.2 起，新数据集默认启用压缩（<code>compression=on</code>，选择 LZ4）。这会导致对所有新写入数据压缩。除了节省空间外，读取和写入吞吐量通常会增加，因为需要读取或写入的块较少。<br><strong>LZ4</strong> - 在 ZFS 池版本 5000（功能标志）中添加，LZ4 是 <code>compression=on</code> 所选择的算法，也是推荐的通用压缩算法。LZ4 在处理可压缩数据时比 LZJB 快约 50%，在处理不可压缩数据时快超过三倍。LZ4 的解压缩速度也比 LZJB 快约 80%。在现代 CPU 上，LZ4 通常可以在单个 CPU 核心上以超过 500 MB/s 的速度压缩，以超过 1.5 GB/s 的速度解压。<br><strong>ZSTD</strong> - Zstandard 提供比 LZ4 更高的压缩比，并在速度与压缩率之间提供可配置的折衷，从快速的 <code>zstd-fast</code> 变体到 <code>zstd-19</code>（最大空间节省）。<br><strong>LZJB</strong> - 一种传统的压缩算法，由 Jeff Bonwick（ZFS 的原始创建者之一）创建。LZJB 提供了较好的压缩效果，同时与 GZIP 相比，CPU 开销较小。LZ4 已取代它成为默认算法；对于新数据集，建议使用 LZ4 或 ZSTD。<br><strong>GZIP</strong> - 在 ZFS 中可用的流行流式压缩算法。使用 GZIP 的主要优点之一是它可以配置压缩级别。在设置 <code>compress</code> 属性时，管理员可以选择压缩级别，从 <code>gzip1</code>（最低压缩级别）到 <code>gzip9</code>（最高压缩级别）。这使管理员可以控制为节省磁盘空间而交换多少 CPU 时间。<br><strong>ZLE</strong> - 零长度编码是一种特殊的压缩算法，仅压缩连续的零块。当数据集包含大量零块时，这种压缩算法非常有用。</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 复制           | 当设置为大于 1 的值时，`copies` 属性指示 ZFS 在文件系统或 [卷](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md) 中维护每个块的副本。将此属性设置在重要数据集上可以提供额外的冗余，以便从与校验和不匹配的块中恢复。在没有冗余的池中，副本功能是唯一的冗余形式。副本功能可以从单个坏扇区或其他形式的小故障中恢复，但它不能保护池免受整个磁盘丢失的影响。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 去重           | 校验和使得在写入数据时能检测到重复的块。通过去重，现有的相同块的引用计数增加，从而节省存储空间。ZFS 在内存中保持一个去重表（DDT）来检测重复的块。该表包含唯一校验和的列表、这些块的位置以及引用计数。在写入新数据时，ZFS 计算校验和并将其与列表进行比较。当找到匹配项时，ZFS 会使用现有的块。使用 SHA256 校验和算法结合去重提供了一个安全的加密哈希。去重是可调的。如果 `dedup` 设置为 `on`，那么匹配的校验和表示数据是相同的。将 `dedup` 设置为 `verify`，ZFS 会逐字节检查数据，确保它们确实是相同的。如果数据不相同，ZFS 会记录哈希冲突并将这两个块分别存储。由于 DDT 必须存储每个唯一块的哈希，它会消耗大量内存。一个大致的经验法则是每去重 1 TB 数据需要 5-6 GB 的内存。在没有足够内存将整个 DDT 保存在内存中的情况下，性能会大幅下降，因为 DDT 必须在写入每个新块之前从磁盘读取。去重可以使用 L2ARC 来存储 DDT，提供系统内存和较慢磁盘之间的折衷。考虑改用压缩，它通常能提供几乎相同的空间节省，而不会增加内存消耗。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Scrub        | 与类似 [fsck(8)](https://man.freebsd.org/cgi/man.cgi?query=fsck\&sektion=8\&format=html) 的一致性检查不同，ZFS 使用 `zpool scrub`。`zpool scrub` 会读取池中存储的所有数据块，并对照存储在元数据中的已知良好校验和验证它们的校验和。定期检查池中存储的所有数据，确保在需要之前恢复任何损坏的块。`zpool scrub` 在非正常关机后不是必需的，但建议至少每月执行一次。ZFS 在正常使用过程中会验证每个块的校验和，但 `zpool scrub` 会确保检查那些即使是很少使用的块是否有静默损坏。ZFS 在归档存储情况下提高了数据安全性。可以使用 `zpool scrub -p` 暂停正在运行的 `scrub`，之后再次运行 `zpool scrub` 即可恢复。通过调整 [`vfs.zfs.scrub_delay`](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.8.-gao-ji-zhu-ti.md) 的相对优先级，防止 `zpool scrub` 降低池中其他工作负载的性能。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 数据集配额        | <p>ZFS 提供了快速准确的数据集、用户和组空间核算，以及配额和空间预留。这使管理员能精细地控制空间分配，并为关键文件系统保留空间。<br>ZFS 支持不同类型的配额：数据集配额、<a href="/pages/0pPztdCSobpg1jmdU0i0">参考配额 (refquota)</a>、<a href="/pages/0pPztdCSobpg1jmdU0i0">用户配额</a> 和 <a href="/pages/0pPztdCSobpg1jmdU0i0">组配额</a>。<br>配额限制数据集及其后代的总大小，包括数据集的快照、子数据集及其快照。<br><strong>注意：</strong> 卷不支持配额，因为 <code>volsize</code> 属性作为隐式配额。</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 参考配额         | 参考配额通过强制硬限制来限制数据集可以使用的空间量。这个硬限制只包括数据集本身引用的空间，不包括由后代（如文件系统或快照）使用的空间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 用户配额         | 用户配额用于限制指定用户使用的空间量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 组配额          | 组配额限制指定组可以使用的空间量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 数据集预留        | <p><code>reservation</code> 属性使得为特定数据集及其后代保证一定的空间成为可能。这意味着，在 <strong>storage/home/bob</strong> 上设置 10 GB 的 reservation，可以防止其他数据集占用所有的空闲空间，确保至少有 10 GB 的空间为该数据集预留。与常规的 <a href="/pages/0pPztdCSobpg1jmdU0i0"><code>refreservation</code></a> 不同，快照和后代所使用的空间<strong>计入</strong> reservation。<br>任何形式的 reservation 都在以下情况中非常有用，例如在新系统中规划和测试磁盘空间分配的适用性，或确保文件系统上有足够的空间用于音频日志或系统恢复过程和文件。</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 参考预留         | `refreservation` 属性使得可以为特定数据集保留一定的空间，但**不包括**其后代的数据集。这意味着，在 **storage/home/bob** 上设置 10 GB 的 reservation，另一个数据集尝试使用空闲空间时，仍会为该数据集保留至少 10 GB 的空间。与常规的 [reservation](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md) 不同，快照和后代数据集所使用的空间不计入该 reservation。例如，如果对 **storage/home/bob** 创建快照，除了 `refreservation` 部分外，必须有足够的磁盘空间才能成功完成操作。主数据集的后代不计入 `refreservation` 空间，因此不会占用已设置的空间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 重新同步         | 在更换故障磁盘时，ZFS 必须将丢失的数据填充到新磁盘中。*重新同步*（Resilvering）是将该数据写入替换设备的过程：镜像通过从幸存成员复制数据进行重新同步，而 RAID-Z 则根据分布在剩余磁盘上的奇偶校验信息重建数据。与传统 RAID 重建不同，重新同步只复制已分配的数据，而非设备的每个扇区。*顺序重新同步*（`zpool attach -s` 或 `zpool replace -s`）通过按磁盘顺序复制块、跳过校验和验证并将其推迟到自动调度的 `zpool scrub`，能更快地重建镜像和 dRAID vdev。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 在线           | 处于 `Online` 状态的池或 vdev 其成员设备已连接且完全正常运行。处于 `Online` 状态的单个设备也在正常工作。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 离线           | 管理员将单个设备置于 `Offline` 状态，如果存在足够的冗余以避免将池或 vdev 置于 [Faulted](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md) 状态。管理员可能选择将磁盘设置为离线，以便为更换磁盘做准备，或为了更容易识别它。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 降级           | 处于 `Degraded` 状态的池或 vdev 有一个或多个磁盘丢失或故障。该池仍然可用，但如果其他设备发生故障，池可能变得无法恢复。重新连接丢失的设备或更换故障磁盘后，池将恢复到 [Online](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md) 状态，前提是重新连接或新设备完成了 [重新同步](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md) 过程。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 故障           | 处于 `Faulted` 状态的池或 vdev 不再可操作，无法访问数据。当丢失或故障的设备数量超过 vdev 中冗余级别时，池或 vdev 进入 `Faulted` 状态。如果重新连接丢失的设备，池将恢复到 [Online](/di-23-zhang-z-wen-jian-xi-tong-zfs/23.10.-zfs-te-xing-he-shu-yu.md) 状态。如果冗余不足以弥补故障磁盘的数量，则会丢失池中的数据，需要从备份恢复。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
