diff --git a/cmd/ztest/ztest.c b/cmd/ztest/ztest.c index 22cfa2fe5..a6820dede 100644 --- a/cmd/ztest/ztest.c +++ b/cmd/ztest/ztest.c @@ -359,7 +359,6 @@ ztest_func_t ztest_dsl_prop_get_set; ztest_func_t ztest_spa_prop_get_set; ztest_func_t ztest_spa_create_destroy; ztest_func_t ztest_fault_inject; -ztest_func_t ztest_ddt_repair; ztest_func_t ztest_dmu_snapshot_hold; ztest_func_t ztest_mmp_enable_disable; ztest_func_t ztest_scrub; @@ -414,7 +413,6 @@ ztest_info_t ztest_info[] = { ZTI_INIT(ztest_dmu_snapshot_create_destroy, 1, &zopt_sometimes), ZTI_INIT(ztest_spa_create_destroy, 1, &zopt_sometimes), ZTI_INIT(ztest_fault_inject, 1, &zopt_sometimes), - ZTI_INIT(ztest_ddt_repair, 1, &zopt_sometimes), ZTI_INIT(ztest_dmu_snapshot_hold, 1, &zopt_sometimes), ZTI_INIT(ztest_mmp_enable_disable, 1, &zopt_sometimes), ZTI_INIT(ztest_reguid, 1, &zopt_rarely), @@ -1523,31 +1521,6 @@ ztest_tx_assign(dmu_tx_t *tx, uint64_t txg_how, const char *tag) return (txg); } -static void -ztest_pattern_set(void *buf, uint64_t size, uint64_t value) -{ - uint64_t *ip = buf; - uint64_t *ip_end = (uint64_t *)((uintptr_t)buf + (uintptr_t)size); - - while (ip < ip_end) - *ip++ = value; -} - -#ifndef NDEBUG -static boolean_t -ztest_pattern_match(void *buf, uint64_t size, uint64_t value) -{ - uint64_t *ip = buf; - uint64_t *ip_end = (uint64_t *)((uintptr_t)buf + (uintptr_t)size); - uint64_t diff = 0; - - while (ip < ip_end) - diff |= (value - *ip++); - - return (diff == 0); -} -#endif - static void ztest_bt_generate(ztest_block_tag_t *bt, objset_t *os, uint64_t object, uint64_t dnodesize, uint64_t offset, uint64_t gen, uint64_t txg, @@ -5574,9 +5547,6 @@ ztest_spa_prop_get_set(ztest_ds_t *zd, uint64_t id) (void) pthread_rwlock_rdlock(&ztest_name_lock); - (void) ztest_spa_prop_set_uint64(ZPOOL_PROP_DEDUPDITTO, - ZIO_DEDUPDITTO_MIN + ztest_random(ZIO_DEDUPDITTO_MIN)); - (void) ztest_spa_prop_set_uint64(ZPOOL_PROP_AUTOTRIM, ztest_random(2)); VERIFY0(spa_prop_get(ztest_spa, &props)); @@ -6017,136 +5987,6 @@ out: umem_free(pathrand, MAXPATHLEN); } -/* - * Verify that DDT repair works as expected. - */ -void -ztest_ddt_repair(ztest_ds_t *zd, uint64_t id) -{ - ztest_shared_t *zs = ztest_shared; - spa_t *spa = ztest_spa; - objset_t *os = zd->zd_os; - ztest_od_t *od; - uint64_t object, blocksize, txg, pattern; - enum zio_checksum checksum = spa_dedup_checksum(spa); - dmu_buf_t *db; - dmu_tx_t *tx; - - od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL); - ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, 0); - - if (ztest_object_init(zd, od, sizeof (ztest_od_t), B_FALSE) != 0) { - umem_free(od, sizeof (ztest_od_t)); - return; - } - - /* - * Take the name lock as writer to prevent anyone else from changing - * the pool and dataset properties we need to maintain during this test. - */ - (void) pthread_rwlock_wrlock(&ztest_name_lock); - - if (ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_DEDUP, checksum, - B_FALSE) != 0 || - ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_COPIES, 1, - B_FALSE) != 0) { - (void) pthread_rwlock_unlock(&ztest_name_lock); - umem_free(od, sizeof (ztest_od_t)); - return; - } - - dmu_objset_stats_t dds; - dsl_pool_config_enter(dmu_objset_pool(os), FTAG); - dmu_objset_fast_stat(os, &dds); - dsl_pool_config_exit(dmu_objset_pool(os), FTAG); - - object = od[0].od_object; - blocksize = od[0].od_blocksize; - pattern = zs->zs_guid ^ dds.dds_guid; - - /* - * The numbers of copies written must always be greater than or - * equal to the threshold set by the dedupditto property. This - * is initialized in ztest_run() and then randomly changed by - * ztest_spa_prop_get_set(), these function will never set it - * larger than 2 * ZIO_DEDUPDITTO_MIN. - */ - int copies = 2 * ZIO_DEDUPDITTO_MIN; - - /* - * The block size is limited by DMU_MAX_ACCESS (64MB) which - * caps the maximum transaction size. A block size of up to - * SPA_OLD_MAXBLOCKSIZE is allowed which results in a maximum - * transaction size of: 128K * 200 (copies) = ~25MB - * - * The actual block size is checked here, rather than requested - * above, because the way ztest_od_init() is implemented it does - * not guarantee the block size requested will be used. - */ - if (blocksize > SPA_OLD_MAXBLOCKSIZE) { - (void) pthread_rwlock_unlock(&ztest_name_lock); - umem_free(od, sizeof (ztest_od_t)); - return; - } - - ASSERT(object != 0); - - tx = dmu_tx_create(os); - dmu_tx_hold_write(tx, object, 0, copies * blocksize); - txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); - if (txg == 0) { - (void) pthread_rwlock_unlock(&ztest_name_lock); - umem_free(od, sizeof (ztest_od_t)); - return; - } - - /* - * Write all the copies of our block. - */ - for (int i = 0; i < copies; i++) { - uint64_t offset = i * blocksize; - int error = dmu_buf_hold(os, object, offset, FTAG, &db, - DMU_READ_NO_PREFETCH); - if (error != 0) { - fatal(B_FALSE, "dmu_buf_hold(%p, %llu, %llu) = %u", - os, (long long)object, (long long) offset, error); - } - ASSERT(db->db_offset == offset); - ASSERT(db->db_size == blocksize); - ASSERT(ztest_pattern_match(db->db_data, db->db_size, pattern) || - ztest_pattern_match(db->db_data, db->db_size, 0ULL)); - dmu_buf_will_fill(db, tx); - ztest_pattern_set(db->db_data, db->db_size, pattern); - dmu_buf_rele(db, FTAG); - } - - dmu_tx_commit(tx); - txg_wait_synced(spa_get_dsl(spa), txg); - - /* - * Find out what block we got. - */ - VERIFY0(dmu_buf_hold(os, object, 0, FTAG, &db, DMU_READ_NO_PREFETCH)); - blkptr_t blk = *((dmu_buf_impl_t *)db)->db_blkptr; - dmu_buf_rele(db, FTAG); - - /* - * Damage the block. Dedup-ditto will save us when we read it later. - */ - uint64_t psize = BP_GET_PSIZE(&blk); - abd_t *abd = abd_alloc_linear(psize, B_TRUE); - ztest_pattern_set(abd_to_buf(abd), psize, ~pattern); - - (void) zio_wait(zio_rewrite(NULL, spa, 0, &blk, - abd, psize, NULL, NULL, ZIO_PRIORITY_SYNC_WRITE, - ZIO_FLAG_CANFAIL | ZIO_FLAG_INDUCE_DAMAGE, NULL)); - - abd_free(abd); - - (void) pthread_rwlock_unlock(&ztest_name_lock); - umem_free(od, sizeof (ztest_od_t)); -} - /* * By design ztest will never inject uncorrectable damage in to the pool. * Issue a scrub, wait for it to complete, and verify there is never any @@ -7103,8 +6943,6 @@ ztest_run(ztest_shared_t *zs) zs->zs_guid = dds.dds_guid; dmu_objset_disown(os, B_TRUE, FTAG); - spa->spa_dedup_ditto = 2 * ZIO_DEDUPDITTO_MIN; - /* * Create a thread to periodically resume suspended I/O. */ diff --git a/include/sys/ddt.h b/include/sys/ddt.h index fb1445d8d..21b76f7ba 100644 --- a/include/sys/ddt.h +++ b/include/sys/ddt.h @@ -103,6 +103,10 @@ typedef struct ddt_phys { uint64_t ddp_phys_birth; } ddt_phys_t; +/* + * Note, we no longer generate new DDT_PHYS_DITTO-type blocks. However, + * we maintain the ability to free existing dedup-ditto blocks. + */ enum ddt_phys_type { DDT_PHYS_DITTO = 0, DDT_PHYS_SINGLE = 1, @@ -216,10 +220,6 @@ extern void ddt_get_dedup_stats(spa_t *spa, ddt_stat_t *dds_total); extern uint64_t ddt_get_dedup_dspace(spa_t *spa); extern uint64_t ddt_get_pool_dedup_ratio(spa_t *spa); -extern int ddt_ditto_copies_needed(ddt_t *ddt, ddt_entry_t *dde, - ddt_phys_t *ddp_willref); -extern int ddt_ditto_copies_present(ddt_entry_t *dde); - extern size_t ddt_compress(void *src, uchar_t *dst, size_t s_len, size_t d_len); extern void ddt_decompress(uchar_t *src, void *dst, size_t s_len, size_t d_len); diff --git a/include/sys/spa_impl.h b/include/sys/spa_impl.h index 66032d9aa..d49b970c9 100644 --- a/include/sys/spa_impl.h +++ b/include/sys/spa_impl.h @@ -350,7 +350,6 @@ struct spa { ddt_t *spa_ddt[ZIO_CHECKSUM_FUNCTIONS]; /* in-core DDTs */ uint64_t spa_ddt_stat_object; /* DDT statistics */ uint64_t spa_dedup_dspace; /* Cache get_dedup_dspace() */ - uint64_t spa_dedup_ditto; /* dedup ditto threshold */ uint64_t spa_dedup_checksum; /* default dedup checksum */ uint64_t spa_dspace; /* dspace in normal class */ kmutex_t spa_vdev_top_lock; /* dueling offline/remove */ diff --git a/include/sys/zio.h b/include/sys/zio.h index e69bf9208..bf441ff8d 100644 --- a/include/sys/zio.h +++ b/include/sys/zio.h @@ -102,7 +102,6 @@ enum zio_checksum { #define ZIO_CHECKSUM_VERIFY (1 << 8) #define ZIO_DEDUPCHECKSUM ZIO_CHECKSUM_SHA256 -#define ZIO_DEDUPDITTO_MIN 100 /* supported encryption algorithms */ enum zio_encrypt { diff --git a/lib/libzfs/libzfs_pool.c b/lib/libzfs/libzfs_pool.c index a6e26ebcd..653335b6e 100644 --- a/lib/libzfs/libzfs_pool.c +++ b/lib/libzfs/libzfs_pool.c @@ -722,15 +722,8 @@ zpool_valid_proplist(libzfs_handle_t *hdl, const char *poolname, } break; case ZPOOL_PROP_DEDUPDITTO: - if (intval < ZIO_DEDUPDITTO_MIN && intval != 0) { - zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, - "property '%s' value %d is invalid; only " - "values of 0 or >= %" PRId32 " are allowed " - "for this property."), - propname, intval, ZIO_DEDUPDITTO_MIN); - (void) zfs_error(hdl, EZFS_BADPROP, errbuf); - goto error; - } + printf("Note: property '%s' no longer has " + "any effect\n", propname); break; default: diff --git a/man/man8/zpool.8 b/man/man8/zpool.8 index bdad81149..230004f1b 100644 --- a/man/man8/zpool.8 +++ b/man/man8/zpool.8 @@ -806,17 +806,7 @@ such that it is available even if the pool becomes faulted. An administrator can provide additional information about a pool using this property. .It Sy dedupditto Ns = Ns Ar number -This property is deprecated. In a future release, it will no longer have any -effect. -.Pp -Threshold for the number of block ditto copies. -If the reference count for a deduplicated block increases above this number, a -new ditto copy of this block is automatically stored. -The default setting is -.Sy 0 -which causes no ditto copies to be created for deduplicated blocks. -The minimum legal nonzero setting is -.Sy 100 . +This property is deprecated and no longer has any effect. .It Sy delegation Ns = Ns Sy on Ns | Ns Sy off Controls whether a non-privileged user is granted access based on the dataset permissions defined on the dataset. diff --git a/module/zcommon/zpool_prop.c b/module/zcommon/zpool_prop.c index ac1c42b3f..539de5645 100644 --- a/module/zcommon/zpool_prop.c +++ b/module/zcommon/zpool_prop.c @@ -104,8 +104,6 @@ zpool_prop_init(void) /* default number properties */ zprop_register_number(ZPOOL_PROP_VERSION, "version", SPA_VERSION, PROP_DEFAULT, ZFS_TYPE_POOL, "", "VERSION"); - zprop_register_number(ZPOOL_PROP_DEDUPDITTO, "dedupditto", 0, - PROP_DEFAULT, ZFS_TYPE_POOL, "", "DEDUPDITTO"); zprop_register_number(ZPOOL_PROP_ASHIFT, "ashift", 0, PROP_DEFAULT, ZFS_TYPE_POOL, "", "ASHIFT"); @@ -143,6 +141,8 @@ zpool_prop_init(void) PROP_ONETIME, ZFS_TYPE_POOL, "TNAME"); zprop_register_hidden(ZPOOL_PROP_MAXDNODESIZE, "maxdnodesize", PROP_TYPE_NUMBER, PROP_READONLY, ZFS_TYPE_POOL, "MAXDNODESIZE"); + zprop_register_hidden(ZPOOL_PROP_DEDUPDITTO, "dedupditto", + PROP_TYPE_NUMBER, PROP_DEFAULT, ZFS_TYPE_POOL, "DEDUPDITTO"); } /* diff --git a/module/zfs/ddt.c b/module/zfs/ddt.c index a38c2b24e..05424d875 100644 --- a/module/zfs/ddt.c +++ b/module/zfs/ddt.c @@ -552,65 +552,6 @@ ddt_get_pool_dedup_ratio(spa_t *spa) return (dds_total.dds_ref_dsize * 100 / dds_total.dds_dsize); } -int -ddt_ditto_copies_needed(ddt_t *ddt, ddt_entry_t *dde, ddt_phys_t *ddp_willref) -{ - spa_t *spa = ddt->ddt_spa; - uint64_t total_refcnt = 0; - uint64_t ditto = spa->spa_dedup_ditto; - int total_copies = 0; - int desired_copies = 0; - int copies_needed = 0; - - for (int p = DDT_PHYS_SINGLE; p <= DDT_PHYS_TRIPLE; p++) { - ddt_phys_t *ddp = &dde->dde_phys[p]; - zio_t *zio = dde->dde_lead_zio[p]; - uint64_t refcnt = ddp->ddp_refcnt; /* committed refs */ - if (zio != NULL) - refcnt += zio->io_parent_count; /* pending refs */ - if (ddp == ddp_willref) - refcnt++; /* caller's ref */ - if (refcnt != 0) { - total_refcnt += refcnt; - total_copies += p; - } - } - - if (ditto == 0 || ditto > UINT32_MAX) - ditto = UINT32_MAX; - - if (total_refcnt >= 1) - desired_copies++; - if (total_refcnt >= ditto) - desired_copies++; - if (total_refcnt >= ditto * ditto) - desired_copies++; - - copies_needed = MAX(desired_copies, total_copies) - total_copies; - - /* encrypted blocks store their IV in DVA[2] */ - if (DDK_GET_CRYPT(&dde->dde_key)) - copies_needed = MIN(copies_needed, SPA_DVAS_PER_BP - 1); - - return (copies_needed); -} - -int -ddt_ditto_copies_present(ddt_entry_t *dde) -{ - ddt_phys_t *ddp = &dde->dde_phys[DDT_PHYS_DITTO]; - dva_t *dva = ddp->ddp_dva; - int copies = 0 - DVA_GET_GANG(dva); - - for (int d = 0; d < DDE_GET_NDVAS(dde); d++, dva++) - if (DVA_IS_VALID(dva)) - copies++; - - ASSERT(copies >= 0 && copies < SPA_DVAS_PER_BP); - - return (copies); -} - size_t ddt_compress(void *src, uchar_t *dst, size_t s_len, size_t d_len) { @@ -1088,8 +1029,11 @@ ddt_sync_entry(ddt_t *ddt, ddt_entry_t *dde, dmu_tx_t *tx, uint64_t txg) continue; } if (p == DDT_PHYS_DITTO) { - if (ddt_ditto_copies_needed(ddt, dde, NULL) == 0) - ddt_phys_free(ddt, ddk, ddp, txg); + /* + * Note, we no longer create DDT-DITTO blocks, but we + * don't want to leak any written by older software. + */ + ddt_phys_free(ddt, ddk, ddp, txg); continue; } if (ddp->ddp_refcnt == 0) @@ -1097,9 +1041,9 @@ ddt_sync_entry(ddt_t *ddt, ddt_entry_t *dde, dmu_tx_t *tx, uint64_t txg) total_refcnt += ddp->ddp_refcnt; } - if (dde->dde_phys[DDT_PHYS_DITTO].ddp_phys_birth != 0) - nclass = DDT_CLASS_DITTO; - else if (total_refcnt > 1) + /* We do not create new DDT-DITTO blocks. */ + ASSERT0(dde->dde_phys[DDT_PHYS_DITTO].ddp_phys_birth); + if (total_refcnt > 1) nclass = DDT_CLASS_DUPLICATE; else nclass = DDT_CLASS_UNIQUE; diff --git a/module/zfs/spa.c b/module/zfs/spa.c index 5e0338d3e..23cf17a58 100644 --- a/module/zfs/spa.c +++ b/module/zfs/spa.c @@ -694,16 +694,6 @@ spa_prop_validate(spa_t *spa, nvlist_t *props) error = SET_ERROR(E2BIG); break; - case ZPOOL_PROP_DEDUPDITTO: - if (spa_version(spa) < SPA_VERSION_DEDUP) - error = SET_ERROR(ENOTSUP); - else - error = nvpair_value_uint64(elem, &intval); - if (error == 0 && - intval != 0 && intval < ZIO_DEDUPDITTO_MIN) - error = SET_ERROR(EINVAL); - break; - default: break; } @@ -712,6 +702,9 @@ spa_prop_validate(spa_t *spa, nvlist_t *props) break; } + (void) nvlist_remove_all(props, + zpool_prop_to_name(ZPOOL_PROP_DEDUPDITTO)); + if (!error && reset_bootfs) { error = nvlist_remove(props, zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING); @@ -3604,8 +3597,6 @@ spa_ld_get_props(spa_t *spa) spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode); spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand); spa_prop_find(spa, ZPOOL_PROP_MULTIHOST, &spa->spa_multihost); - spa_prop_find(spa, ZPOOL_PROP_DEDUPDITTO, - &spa->spa_dedup_ditto); spa_prop_find(spa, ZPOOL_PROP_AUTOTRIM, &spa->spa_autotrim); spa->spa_autoreplace = (autoreplace != 0); } @@ -7983,9 +7974,6 @@ spa_sync_props(void *arg, dmu_tx_t *tx) case ZPOOL_PROP_MULTIHOST: spa->spa_multihost = intval; break; - case ZPOOL_PROP_DEDUPDITTO: - spa->spa_dedup_ditto = intval; - break; default: break; } diff --git a/module/zfs/zio.c b/module/zfs/zio.c index 78dff51af..e36a7893d 100644 --- a/module/zfs/zio.c +++ b/module/zfs/zio.c @@ -3118,35 +3118,6 @@ zio_ddt_child_write_done(zio_t *zio) ddt_exit(ddt); } -static void -zio_ddt_ditto_write_done(zio_t *zio) -{ - int p = DDT_PHYS_DITTO; - ASSERTV(zio_prop_t *zp = &zio->io_prop); - blkptr_t *bp = zio->io_bp; - ddt_t *ddt = ddt_select(zio->io_spa, bp); - ddt_entry_t *dde = zio->io_private; - ddt_phys_t *ddp = &dde->dde_phys[p]; - ddt_key_t *ddk = &dde->dde_key; - - ddt_enter(ddt); - - ASSERT(ddp->ddp_refcnt == 0); - ASSERT(dde->dde_lead_zio[p] == zio); - dde->dde_lead_zio[p] = NULL; - - if (zio->io_error == 0) { - ASSERT(ZIO_CHECKSUM_EQUAL(bp->blk_cksum, ddk->ddk_cksum)); - ASSERT(zp->zp_copies < SPA_DVAS_PER_BP); - ASSERT(zp->zp_copies == BP_GET_NDVAS(bp) - BP_IS_GANG(bp)); - if (ddp->ddp_phys_birth != 0) - ddt_phys_free(ddt, ddk, ddp, zio->io_txg); - ddt_phys_fill(ddp, bp); - } - - ddt_exit(ddt); -} - static zio_t * zio_ddt_write(zio_t *zio) { @@ -3155,9 +3126,7 @@ zio_ddt_write(zio_t *zio) uint64_t txg = zio->io_txg; zio_prop_t *zp = &zio->io_prop; int p = zp->zp_copies; - int ditto_copies; zio_t *cio = NULL; - zio_t *dio = NULL; ddt_t *ddt = ddt_select(spa, bp); ddt_entry_t *dde; ddt_phys_t *ddp; @@ -3192,41 +3161,6 @@ zio_ddt_write(zio_t *zio) return (zio); } - ditto_copies = ddt_ditto_copies_needed(ddt, dde, ddp); - ASSERT(ditto_copies < SPA_DVAS_PER_BP); - - if (ditto_copies > ddt_ditto_copies_present(dde) && - dde->dde_lead_zio[DDT_PHYS_DITTO] == NULL) { - zio_prop_t czp = *zp; - - czp.zp_copies = ditto_copies; - - /* - * If we arrived here with an override bp, we won't have run - * the transform stack, so we won't have the data we need to - * generate a child i/o. So, toss the override bp and restart. - * This is safe, because using the override bp is just an - * optimization; and it's rare, so the cost doesn't matter. - */ - if (zio->io_bp_override) { - zio_pop_transforms(zio); - zio->io_stage = ZIO_STAGE_OPEN; - zio->io_pipeline = ZIO_WRITE_PIPELINE; - zio->io_bp_override = NULL; - BP_ZERO(bp); - ddt_exit(ddt); - return (zio); - } - - dio = zio_write(zio, spa, txg, bp, zio->io_orig_abd, - zio->io_orig_size, zio->io_orig_size, &czp, NULL, NULL, - NULL, zio_ddt_ditto_write_done, dde, zio->io_priority, - ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark); - - zio_push_transform(dio, zio->io_abd, zio->io_size, 0, NULL); - dde->dde_lead_zio[DDT_PHYS_DITTO] = dio; - } - if (ddp->ddp_phys_birth != 0 || dde->dde_lead_zio[p] != NULL) { if (ddp->ddp_phys_birth != 0) ddt_bp_fill(ddp, bp, txg); @@ -3254,8 +3188,6 @@ zio_ddt_write(zio_t *zio) if (cio) zio_nowait(cio); - if (dio) - zio_nowait(dio); return (zio); } diff --git a/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get.cfg b/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get.cfg index 9e2f00f6a..a9ca718cc 100644 --- a/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get.cfg +++ b/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get.cfg @@ -46,7 +46,6 @@ typeset -a properties=( "failmode" "listsnapshots" "autoexpand" - "dedupditto" "dedupratio" "free" "allocated" diff --git a/tests/zfs-tests/tests/functional/cli_root/zpool_split/zpool_split_props.ksh b/tests/zfs-tests/tests/functional/cli_root/zpool_split/zpool_split_props.ksh index 67dbed693..32078ad3f 100755 --- a/tests/zfs-tests/tests/functional/cli_root/zpool_split/zpool_split_props.ksh +++ b/tests/zfs-tests/tests/functional/cli_root/zpool_split/zpool_split_props.ksh @@ -53,10 +53,10 @@ if [ -e $HOSTID_FILE ]; then fi typeset good_props=('comment=text' 'ashift=12' 'multihost=on' - 'listsnapshots=on' 'autoexpand=on' 'autoreplace=on' 'dedupditto=1234' + 'listsnapshots=on' 'autoexpand=on' 'autoreplace=on' 'delegation=off' 'failmode=continue') typeset bad_props=("bootfs=$TESTPOOL2/bootfs" 'version=28' 'ashift=4' - 'allocated=1234' 'capacity=5678' 'dedupditto=42' 'multihost=none' + 'allocated=1234' 'capacity=5678' 'multihost=none' 'feature@async_destroy=disabled' 'feature@xxx_fake_xxx=enabled' 'propname=propval' 'readonly=on')