30af21b025
Redacted send/receive allows users to send subsets of their data to a target system. One possible use case for this feature is to not transmit sensitive information to a data warehousing, test/dev, or analytics environment. Another is to save space by not replicating unimportant data within a given dataset, for example in backup tools like zrepl. Redacted send/receive is a three-stage process. First, a clone (or clones) is made of the snapshot to be sent to the target. In this clone (or clones), all unnecessary or unwanted data is removed or modified. This clone is then snapshotted to create the "redaction snapshot" (or snapshots). Second, the new zfs redact command is used to create a redaction bookmark. The redaction bookmark stores the list of blocks in a snapshot that were modified by the redaction snapshot(s). Finally, the redaction bookmark is passed as a parameter to zfs send. When sending to the snapshot that was redacted, the redaction bookmark is used to filter out blocks that contain sensitive or unwanted information, and those blocks are not included in the send stream. When sending from the redaction bookmark, the blocks it contains are considered as candidate blocks in addition to those blocks in the destination snapshot that were modified since the creation_txg of the redaction bookmark. This step is necessary to allow the target to rehydrate data in the case where some blocks are accidentally or unnecessarily modified in the redaction snapshot. The changes to bookmarks to enable fast space estimation involve adding deadlists to bookmarks. There is also logic to manage the life cycles of these deadlists. The new size estimation process operates in cases where previously an accurate estimate could not be provided. In those cases, a send is performed where no data blocks are read, reducing the runtime significantly and providing a byte-accurate size estimate. Reviewed-by: Dan Kimmel <dan.kimmel@delphix.com> Reviewed-by: Matt Ahrens <mahrens@delphix.com> Reviewed-by: Prashanth Sreenivasa <pks@delphix.com> Reviewed-by: John Kennedy <john.kennedy@delphix.com> Reviewed-by: George Wilson <george.wilson@delphix.com> Reviewed-by: Chris Williamson <chris.williamson@delphix.com> Reviewed-by: Pavel Zhakarov <pavel.zakharov@delphix.com> Reviewed-by: Sebastien Roy <sebastien.roy@delphix.com> Reviewed-by: Prakash Surya <prakash.surya@delphix.com> Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov> Signed-off-by: Paul Dagnelie <pcd@delphix.com> Closes #7958
542 lines
15 KiB
C
542 lines
15 KiB
C
/*
|
|
* CDDL HEADER START
|
|
*
|
|
* The contents of this file are subject to the terms of the
|
|
* Common Development and Distribution License (the "License").
|
|
* You may not use this file except in compliance with the License.
|
|
*
|
|
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
* or http://www.opensolaris.org/os/licensing.
|
|
* See the License for the specific language governing permissions
|
|
* and limitations under the License.
|
|
*
|
|
* When distributing Covered Code, include this CDDL HEADER in each
|
|
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
* If applicable, add the following below this CDDL HEADER, with the
|
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
|
* information: Portions Copyright [yyyy] [name of copyright owner]
|
|
*
|
|
* CDDL HEADER END
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2011, 2018 by Delphix. All rights reserved.
|
|
* Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
|
|
* Copyright (c) 2013, Joyent, Inc. All rights reserved.
|
|
* Copyright (c) 2014, Nexenta Systems, Inc. All rights reserved.
|
|
* Copyright (c) 2017, Intel Corporation.
|
|
*/
|
|
|
|
#ifndef _KERNEL
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#endif
|
|
#include <sys/debug.h>
|
|
#include <sys/fs/zfs.h>
|
|
#include <sys/inttypes.h>
|
|
#include <sys/types.h>
|
|
#include <sys/zfs_sysfs.h>
|
|
#include "zfeature_common.h"
|
|
|
|
/*
|
|
* Set to disable all feature checks while opening pools, allowing pools with
|
|
* unsupported features to be opened. Set for testing only.
|
|
*/
|
|
boolean_t zfeature_checks_disable = B_FALSE;
|
|
|
|
zfeature_info_t spa_feature_table[SPA_FEATURES];
|
|
|
|
/*
|
|
* Valid characters for feature guids. This list is mainly for aesthetic
|
|
* purposes and could be expanded in the future. There are different allowed
|
|
* characters in the guids reverse dns portion (before the colon) and its
|
|
* short name (after the colon).
|
|
*/
|
|
static int
|
|
valid_char(char c, boolean_t after_colon)
|
|
{
|
|
return ((c >= 'a' && c <= 'z') ||
|
|
(c >= '0' && c <= '9') ||
|
|
(after_colon && c == '_') ||
|
|
(!after_colon && (c == '.' || c == '-')));
|
|
}
|
|
|
|
/*
|
|
* Every feature guid must contain exactly one colon which separates a reverse
|
|
* dns organization name from the feature's "short" name (e.g.
|
|
* "com.company:feature_name").
|
|
*/
|
|
boolean_t
|
|
zfeature_is_valid_guid(const char *name)
|
|
{
|
|
int i;
|
|
boolean_t has_colon = B_FALSE;
|
|
|
|
i = 0;
|
|
while (name[i] != '\0') {
|
|
char c = name[i++];
|
|
if (c == ':') {
|
|
if (has_colon)
|
|
return (B_FALSE);
|
|
has_colon = B_TRUE;
|
|
continue;
|
|
}
|
|
if (!valid_char(c, has_colon))
|
|
return (B_FALSE);
|
|
}
|
|
|
|
return (has_colon);
|
|
}
|
|
|
|
boolean_t
|
|
zfeature_is_supported(const char *guid)
|
|
{
|
|
if (zfeature_checks_disable)
|
|
return (B_TRUE);
|
|
|
|
for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
|
|
zfeature_info_t *feature = &spa_feature_table[i];
|
|
if (strcmp(guid, feature->fi_guid) == 0)
|
|
return (B_TRUE);
|
|
}
|
|
return (B_FALSE);
|
|
}
|
|
|
|
int
|
|
zfeature_lookup_guid(const char *guid, spa_feature_t *res)
|
|
{
|
|
for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
|
|
zfeature_info_t *feature = &spa_feature_table[i];
|
|
if (!feature->fi_zfs_mod_supported)
|
|
continue;
|
|
if (strcmp(guid, feature->fi_guid) == 0) {
|
|
if (res != NULL)
|
|
*res = i;
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
return (ENOENT);
|
|
}
|
|
|
|
int
|
|
zfeature_lookup_name(const char *name, spa_feature_t *res)
|
|
{
|
|
for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
|
|
zfeature_info_t *feature = &spa_feature_table[i];
|
|
if (!feature->fi_zfs_mod_supported)
|
|
continue;
|
|
if (strcmp(name, feature->fi_uname) == 0) {
|
|
if (res != NULL)
|
|
*res = i;
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
return (ENOENT);
|
|
}
|
|
|
|
boolean_t
|
|
zfeature_depends_on(spa_feature_t fid, spa_feature_t check)
|
|
{
|
|
zfeature_info_t *feature = &spa_feature_table[fid];
|
|
|
|
for (int i = 0; feature->fi_depends[i] != SPA_FEATURE_NONE; i++) {
|
|
if (feature->fi_depends[i] == check)
|
|
return (B_TRUE);
|
|
}
|
|
return (B_FALSE);
|
|
}
|
|
|
|
static boolean_t
|
|
deps_contains_feature(const spa_feature_t *deps, const spa_feature_t feature)
|
|
{
|
|
for (int i = 0; deps[i] != SPA_FEATURE_NONE; i++)
|
|
if (deps[i] == feature)
|
|
return (B_TRUE);
|
|
|
|
return (B_FALSE);
|
|
}
|
|
|
|
#if !defined(_KERNEL) && !defined(LIB_ZPOOL_BUILD)
|
|
static boolean_t
|
|
zfs_mod_supported_impl(const char *scope, const char *name, const char *sysfs)
|
|
{
|
|
boolean_t supported = B_FALSE;
|
|
char *path;
|
|
|
|
int len = asprintf(&path, "%s%s%s%s%s", sysfs,
|
|
scope == NULL ? "" : "/", scope == NULL ? "" : scope,
|
|
name == NULL ? "" : "/", name == NULL ? "" : name);
|
|
if (len > 0) {
|
|
struct stat64 statbuf;
|
|
supported = !!(stat64(path, &statbuf) == 0);
|
|
free(path);
|
|
}
|
|
|
|
return (supported);
|
|
}
|
|
|
|
boolean_t
|
|
zfs_mod_supported(const char *scope, const char *name)
|
|
{
|
|
boolean_t supported;
|
|
|
|
/*
|
|
* Check both the primary and alternate sysfs locations to determine
|
|
* if the required functionality is supported.
|
|
*/
|
|
supported = (zfs_mod_supported_impl(scope, name, ZFS_SYSFS_DIR) ||
|
|
zfs_mod_supported_impl(scope, name, ZFS_SYSFS_ALT_DIR));
|
|
|
|
/*
|
|
* For backwards compatibility with kernel modules that predate
|
|
* supported feature/property checking. Report the feature/property
|
|
* as supported if the kernel module is loaded but the requested
|
|
* scope directory does not exist.
|
|
*/
|
|
if (supported == B_FALSE) {
|
|
struct stat64 statbuf;
|
|
if ((stat64(ZFS_SYSFS_DIR, &statbuf) == 0) &&
|
|
!zfs_mod_supported_impl(scope, NULL, ZFS_SYSFS_DIR) &&
|
|
!zfs_mod_supported_impl(scope, NULL, ZFS_SYSFS_ALT_DIR)) {
|
|
supported = B_TRUE;
|
|
}
|
|
}
|
|
|
|
return (supported);
|
|
}
|
|
#endif
|
|
|
|
static boolean_t
|
|
zfs_mod_supported_feature(const char *name)
|
|
{
|
|
/*
|
|
* The zfs module spa_feature_table[], whether in-kernel or in
|
|
* libzpool, always supports all the features. libzfs needs to
|
|
* query the running module, via sysfs, to determine which
|
|
* features are supported.
|
|
*/
|
|
#if defined(_KERNEL) || defined(LIB_ZPOOL_BUILD)
|
|
return (B_TRUE);
|
|
#else
|
|
return (zfs_mod_supported(ZFS_SYSFS_POOL_FEATURES, name));
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
zfeature_register(spa_feature_t fid, const char *guid, const char *name,
|
|
const char *desc, zfeature_flags_t flags, zfeature_type_t type,
|
|
const spa_feature_t *deps)
|
|
{
|
|
zfeature_info_t *feature = &spa_feature_table[fid];
|
|
static spa_feature_t nodeps[] = { SPA_FEATURE_NONE };
|
|
|
|
ASSERT(name != NULL);
|
|
ASSERT(desc != NULL);
|
|
ASSERT((flags & ZFEATURE_FLAG_READONLY_COMPAT) == 0 ||
|
|
(flags & ZFEATURE_FLAG_MOS) == 0);
|
|
ASSERT3U(fid, <, SPA_FEATURES);
|
|
ASSERT(zfeature_is_valid_guid(guid));
|
|
|
|
if (deps == NULL)
|
|
deps = nodeps;
|
|
|
|
VERIFY(((flags & ZFEATURE_FLAG_PER_DATASET) == 0) ||
|
|
(deps_contains_feature(deps, SPA_FEATURE_EXTENSIBLE_DATASET)));
|
|
|
|
feature->fi_feature = fid;
|
|
feature->fi_guid = guid;
|
|
feature->fi_uname = name;
|
|
feature->fi_desc = desc;
|
|
feature->fi_flags = flags;
|
|
feature->fi_type = type;
|
|
feature->fi_depends = deps;
|
|
feature->fi_zfs_mod_supported = zfs_mod_supported_feature(guid);
|
|
}
|
|
|
|
void
|
|
zpool_feature_init(void)
|
|
{
|
|
zfeature_register(SPA_FEATURE_ASYNC_DESTROY,
|
|
"com.delphix:async_destroy", "async_destroy",
|
|
"Destroy filesystems asynchronously.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
zfeature_register(SPA_FEATURE_EMPTY_BPOBJ,
|
|
"com.delphix:empty_bpobj", "empty_bpobj",
|
|
"Snapshots use less space.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
zfeature_register(SPA_FEATURE_LZ4_COMPRESS,
|
|
"org.illumos:lz4_compress", "lz4_compress",
|
|
"LZ4 compression algorithm support.",
|
|
ZFEATURE_FLAG_ACTIVATE_ON_ENABLE, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
zfeature_register(SPA_FEATURE_MULTI_VDEV_CRASH_DUMP,
|
|
"com.joyent:multi_vdev_crash_dump", "multi_vdev_crash_dump",
|
|
"Crash dumps to multiple vdev pools.",
|
|
0, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
zfeature_register(SPA_FEATURE_SPACEMAP_HISTOGRAM,
|
|
"com.delphix:spacemap_histogram", "spacemap_histogram",
|
|
"Spacemaps maintain space histograms.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
zfeature_register(SPA_FEATURE_ENABLED_TXG,
|
|
"com.delphix:enabled_txg", "enabled_txg",
|
|
"Record txg at which a feature is enabled",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
{
|
|
static const spa_feature_t hole_birth_deps[] = {
|
|
SPA_FEATURE_ENABLED_TXG,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_HOLE_BIRTH,
|
|
"com.delphix:hole_birth", "hole_birth",
|
|
"Retain hole birth txg for more precise zfs send",
|
|
ZFEATURE_FLAG_MOS | ZFEATURE_FLAG_ACTIVATE_ON_ENABLE,
|
|
ZFEATURE_TYPE_BOOLEAN, hole_birth_deps);
|
|
}
|
|
|
|
zfeature_register(SPA_FEATURE_POOL_CHECKPOINT,
|
|
"com.delphix:zpool_checkpoint", "zpool_checkpoint",
|
|
"Pool state can be checkpointed, allowing rewind later.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
zfeature_register(SPA_FEATURE_SPACEMAP_V2,
|
|
"com.delphix:spacemap_v2", "spacemap_v2",
|
|
"Space maps representing large segments are more efficient.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT | ZFEATURE_FLAG_ACTIVATE_ON_ENABLE,
|
|
ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
zfeature_register(SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
"com.delphix:extensible_dataset", "extensible_dataset",
|
|
"Enhanced dataset functionality, used by other features.",
|
|
0, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
{
|
|
static const spa_feature_t bookmarks_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
|
|
zfeature_register(SPA_FEATURE_BOOKMARKS,
|
|
"com.delphix:bookmarks", "bookmarks",
|
|
"\"zfs bookmark\" command",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN,
|
|
bookmarks_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t filesystem_limits_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_FS_SS_LIMIT,
|
|
"com.joyent:filesystem_limits", "filesystem_limits",
|
|
"Filesystem and snapshot limits.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN,
|
|
filesystem_limits_deps);
|
|
}
|
|
|
|
zfeature_register(SPA_FEATURE_EMBEDDED_DATA,
|
|
"com.delphix:embedded_data", "embedded_data",
|
|
"Blocks which compress very well use even less space.",
|
|
ZFEATURE_FLAG_MOS | ZFEATURE_FLAG_ACTIVATE_ON_ENABLE,
|
|
ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
{
|
|
static const spa_feature_t large_blocks_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_LARGE_BLOCKS,
|
|
"org.open-zfs:large_blocks", "large_blocks",
|
|
"Support for blocks larger than 128KB.",
|
|
ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_BOOLEAN,
|
|
large_blocks_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t large_dnode_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_LARGE_DNODE,
|
|
"org.zfsonlinux:large_dnode", "large_dnode",
|
|
"Variable on-disk size of dnodes.",
|
|
ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_BOOLEAN,
|
|
large_dnode_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t sha512_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_SHA512,
|
|
"org.illumos:sha512", "sha512",
|
|
"SHA-512/256 hash algorithm.",
|
|
ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_BOOLEAN,
|
|
sha512_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t skein_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_SKEIN,
|
|
"org.illumos:skein", "skein",
|
|
"Skein hash algorithm.",
|
|
ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_BOOLEAN,
|
|
skein_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t edonr_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_EDONR,
|
|
"org.illumos:edonr", "edonr",
|
|
"Edon-R hash algorithm.",
|
|
ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_BOOLEAN,
|
|
edonr_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t redact_books_deps[] = {
|
|
SPA_FEATURE_BOOKMARK_V2,
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_BOOKMARKS,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_REDACTION_BOOKMARKS,
|
|
"com.delphix:redaction_bookmarks", "redaction_bookmarks",
|
|
"Support for bookmarks which store redaction lists for zfs "
|
|
"redacted send/recv.", 0, ZFEATURE_TYPE_BOOLEAN,
|
|
redact_books_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t redact_datasets_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_REDACTED_DATASETS,
|
|
"com.delphix:redacted_datasets", "redacted_datasets", "Support for "
|
|
"redacted datasets, produced by receiving a redacted zfs send "
|
|
"stream.", ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_UINT64_ARRAY,
|
|
redact_datasets_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t bookmark_written_deps[] = {
|
|
SPA_FEATURE_BOOKMARK_V2,
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_BOOKMARKS,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_BOOKMARK_WRITTEN,
|
|
"com.delphix:bookmark_written", "bookmark_written",
|
|
"Additional accounting, enabling the written#<bookmark> property"
|
|
"(space written since a bookmark), and estimates of send stream "
|
|
"sizes for incrementals from bookmarks.",
|
|
0, ZFEATURE_TYPE_BOOLEAN, bookmark_written_deps);
|
|
}
|
|
|
|
zfeature_register(SPA_FEATURE_DEVICE_REMOVAL,
|
|
"com.delphix:device_removal", "device_removal",
|
|
"Top-level vdevs can be removed, reducing logical pool size.",
|
|
ZFEATURE_FLAG_MOS, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
|
|
{
|
|
static const spa_feature_t obsolete_counts_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_DEVICE_REMOVAL,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_OBSOLETE_COUNTS,
|
|
"com.delphix:obsolete_counts", "obsolete_counts",
|
|
"Reduce memory used by removed devices when their blocks are "
|
|
"freed or remapped.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN,
|
|
obsolete_counts_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t userobj_accounting_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_USEROBJ_ACCOUNTING,
|
|
"org.zfsonlinux:userobj_accounting", "userobj_accounting",
|
|
"User/Group object accounting.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT | ZFEATURE_FLAG_PER_DATASET,
|
|
ZFEATURE_TYPE_BOOLEAN, userobj_accounting_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t bookmark_v2_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_BOOKMARKS,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_BOOKMARK_V2,
|
|
"com.datto:bookmark_v2", "bookmark_v2",
|
|
"Support for larger bookmarks",
|
|
0, ZFEATURE_TYPE_BOOLEAN, bookmark_v2_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t encryption_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_BOOKMARK_V2,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_ENCRYPTION,
|
|
"com.datto:encryption", "encryption",
|
|
"Support for dataset level encryption",
|
|
ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_BOOLEAN,
|
|
encryption_deps);
|
|
}
|
|
|
|
{
|
|
static const spa_feature_t project_quota_deps[] = {
|
|
SPA_FEATURE_EXTENSIBLE_DATASET,
|
|
SPA_FEATURE_NONE
|
|
};
|
|
zfeature_register(SPA_FEATURE_PROJECT_QUOTA,
|
|
"org.zfsonlinux:project_quota", "project_quota",
|
|
"space/object accounting based on project ID.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT | ZFEATURE_FLAG_PER_DATASET,
|
|
ZFEATURE_TYPE_BOOLEAN, project_quota_deps);
|
|
}
|
|
|
|
{
|
|
zfeature_register(SPA_FEATURE_ALLOCATION_CLASSES,
|
|
"org.zfsonlinux:allocation_classes", "allocation_classes",
|
|
"Support for separate allocation classes.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
}
|
|
|
|
zfeature_register(SPA_FEATURE_RESILVER_DEFER,
|
|
"com.datto:resilver_defer", "resilver_defer",
|
|
"Support for defering new resilvers when one is already running.",
|
|
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL);
|
|
}
|
|
|
|
#if defined(_KERNEL)
|
|
EXPORT_SYMBOL(zfeature_lookup_guid);
|
|
EXPORT_SYMBOL(zfeature_lookup_name);
|
|
EXPORT_SYMBOL(zfeature_is_supported);
|
|
EXPORT_SYMBOL(zfeature_is_valid_guid);
|
|
EXPORT_SYMBOL(zfeature_depends_on);
|
|
EXPORT_SYMBOL(zpool_feature_init);
|
|
EXPORT_SYMBOL(spa_feature_table);
|
|
#endif
|