Lines Matching defs:ds
93 extern inline dsl_dataset_phys_t *dsl_dataset_phys(dsl_dataset_t *ds);
95 static void dsl_dataset_set_remap_deadlist_object(dsl_dataset_t *ds,
97 static void dsl_dataset_unset_remap_deadlist_object(dsl_dataset_t *ds,
100 static void unload_zfeature(dsl_dataset_t *ds, spa_feature_t f);
112 parent_delta(dsl_dataset_t *ds, int64_t delta)
117 if (ds->ds_reserved == 0)
120 ds_phys = dsl_dataset_phys(ds);
121 old_bytes = MAX(ds_phys->ds_unique_bytes, ds->ds_reserved);
122 new_bytes = MAX(ds_phys->ds_unique_bytes + delta, ds->ds_reserved);
129 dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
138 dprintf_bp(bp, "ds=%p", ds);
146 if (ds == NULL) {
152 ASSERT3U(bp->blk_birth, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
153 dmu_buf_will_dirty(ds->ds_dbuf, tx);
154 mutex_enter(&ds->ds_lock);
155 delta = parent_delta(ds, used);
156 dsl_dataset_phys(ds)->ds_referenced_bytes += used;
157 dsl_dataset_phys(ds)->ds_compressed_bytes += compressed;
158 dsl_dataset_phys(ds)->ds_uncompressed_bytes += uncompressed;
159 dsl_dataset_phys(ds)->ds_unique_bytes += used;
162 ds->ds_feature_activation[SPA_FEATURE_LARGE_BLOCKS] =
171 ds->ds_feature_activation[f] = (void *)B_TRUE;
178 ds->ds_feature_activation[f] = (void *)B_TRUE;
185 if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
186 bp->blk_birth > ds->ds_dir->dd_origin_txg &&
188 ASSERT(dsl_dir_is_clone(ds->ds_dir));
191 bplist_append(&ds->ds_dir->dd_pending_allocs, bp);
194 mutex_exit(&ds->ds_lock);
195 dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD, delta,
197 dsl_dir_transfer_space(ds->ds_dir, used - delta,
209 dsl_dataset_block_remapped(dsl_dataset_t *ds, uint64_t vdev, uint64_t offset,
212 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
216 ASSERT(!ds->ds_is_snapshot);
218 if (birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
224 ASSERT(ds != NULL);
226 mutex_enter(&ds->ds_remap_deadlist_lock);
227 if (!dsl_dataset_remap_deadlist_exists(ds)) {
228 dsl_dataset_create_remap_deadlist(ds, tx);
230 mutex_exit(&ds->ds_remap_deadlist_lock);
237 dsl_deadlist_insert(&ds->ds_remap_deadlist, &fakebp, B_FALSE,
243 dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx,
258 if (ds == NULL) {
264 ASSERT3P(tx->tx_pool, ==, ds->ds_dir->dd_pool);
266 ASSERT(!ds->ds_is_snapshot);
267 dmu_buf_will_dirty(ds->ds_dbuf, tx);
273 if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
274 bp->blk_birth > ds->ds_dir->dd_origin_txg &&
276 ASSERT(dsl_dir_is_clone(ds->ds_dir));
279 bplist_append(&ds->ds_dir->dd_pending_frees, bp);
282 if (bp->blk_birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
285 dprintf_bp(bp, "freeing ds=%llu", ds->ds_object);
288 mutex_enter(&ds->ds_lock);
289 ASSERT(dsl_dataset_phys(ds)->ds_unique_bytes >= used ||
290 !DS_UNIQUE_IS_ACCURATE(ds));
291 delta = parent_delta(ds, -used);
292 dsl_dataset_phys(ds)->ds_unique_bytes -= used;
293 mutex_exit(&ds->ds_lock);
294 dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD,
296 dsl_dir_transfer_space(ds->ds_dir, -used - delta,
308 bplist_append(&ds->ds_pending_deadlist, bp);
310 dsl_deadlist_insert(&ds->ds_deadlist, bp, B_FALSE, tx);
312 ASSERT3U(ds->ds_prev->ds_object, ==,
313 dsl_dataset_phys(ds)->ds_prev_snap_obj);
314 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_num_children > 0);
316 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
317 ds->ds_object && bp->blk_birth >
318 dsl_dataset_phys(ds->ds_prev)->ds_prev_snap_txg) {
319 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
320 mutex_enter(&ds->ds_prev->ds_lock);
321 dsl_dataset_phys(ds->ds_prev)->ds_unique_bytes += used;
322 mutex_exit(&ds->ds_prev->ds_lock);
324 if (bp->blk_birth > ds->ds_dir->dd_origin_txg) {
325 dsl_dir_transfer_space(ds->ds_dir, used,
330 dsl_bookmark_block_killed(ds, bp, tx);
332 mutex_enter(&ds->ds_lock);
333 ASSERT3U(dsl_dataset_phys(ds)->ds_referenced_bytes, >=, used);
334 dsl_dataset_phys(ds)->ds_referenced_bytes -= used;
335 ASSERT3U(dsl_dataset_phys(ds)->ds_compressed_bytes, >=, compressed);
336 dsl_dataset_phys(ds)->ds_compressed_bytes -= compressed;
337 ASSERT3U(dsl_dataset_phys(ds)->ds_uncompressed_bytes, >=, uncompressed);
338 dsl_dataset_phys(ds)->ds_uncompressed_bytes -= uncompressed;
339 mutex_exit(&ds->ds_lock);
350 unload_zfeature(dsl_dataset_t *ds, spa_feature_t f)
357 struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
368 load_zfeature(objset_t *mos, dsl_dataset_t *ds, spa_feature_t f)
373 err = zap_contains(mos, ds->ds_object,
376 ds->ds_feature[f] = (void *)B_TRUE;
386 err = zap_length(mos, ds->ds_object,
395 VERIFY0(zap_lookup(mos, ds->ds_object,
401 ds->ds_feature[f] = ftuaa;
419 dsl_dataset_t *ds = dbu;
421 ASSERT(ds->ds_owner == NULL);
423 unique_remove(ds->ds_fsid_guid);
429 dsl_dataset_t *ds = dbu;
431 ASSERT(ds->ds_owner == NULL);
433 ds->ds_dbuf = NULL;
435 if (ds->ds_objset != NULL)
436 dmu_objset_evict(ds->ds_objset);
438 if (ds->ds_prev) {
439 dsl_dataset_rele(ds->ds_prev, ds);
440 ds->ds_prev = NULL;
443 dsl_bookmark_fini_ds(ds);
445 bplist_destroy(&ds->ds_pending_deadlist);
446 if (dsl_deadlist_is_open(&ds->ds_deadlist))
447 dsl_deadlist_close(&ds->ds_deadlist);
448 if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
449 dsl_deadlist_close(&ds->ds_remap_deadlist);
450 if (ds->ds_dir)
451 dsl_dir_async_rele(ds->ds_dir, ds);
453 ASSERT(!list_link_active(&ds->ds_synced_link));
456 if (dsl_dataset_feature_is_active(ds, f))
457 unload_zfeature(ds, f);
460 list_destroy(&ds->ds_prop_cbs);
461 mutex_destroy(&ds->ds_lock);
462 mutex_destroy(&ds->ds_opening_lock);
463 mutex_destroy(&ds->ds_sendstream_lock);
464 mutex_destroy(&ds->ds_remap_deadlist_lock);
465 zfs_refcount_destroy(&ds->ds_longholds);
466 rrw_destroy(&ds->ds_bp_rwlock);
468 kmem_free(ds, sizeof (dsl_dataset_t));
472 dsl_dataset_get_snapname(dsl_dataset_t *ds)
477 dsl_pool_t *dp = ds->ds_dir->dd_pool;
480 if (ds->ds_snapname[0])
482 if (dsl_dataset_phys(ds)->ds_next_snap_obj == 0)
485 err = dmu_bonus_hold(mos, dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj,
491 headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname);
494 (void) snprintf(ds->ds_snapname, sizeof (ds->ds_snapname),
496 (unsigned long long)ds->ds_object, err);
503 dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name, uint64_t *value)
505 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
506 uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
510 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
521 dsl_dataset_snap_remove(dsl_dataset_t *ds, const char *name, dmu_tx_t *tx,
524 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
525 uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
529 dsl_dir_snap_cmtime_update(ds->ds_dir);
531 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
539 dsl_fs_ss_count_adjust(ds->ds_dir, -1,
546 dsl_dataset_try_add_ref(dsl_pool_t *dp, dsl_dataset_t *ds, void *tag)
548 dmu_buf_t *dbuf = ds->ds_dbuf;
552 ds->ds_object, DMU_BONUS_BLKID, tag)) {
554 if (ds == dmu_buf_get_user(dbuf))
569 dsl_dataset_t *ds;
586 ds = dmu_buf_get_user(dbuf);
587 if (ds == NULL) {
590 ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
591 ds->ds_dbuf = dbuf;
592 ds->ds_object = dsobj;
593 ds->ds_is_snapshot = dsl_dataset_phys(ds)->ds_num_children != 0;
594 list_link_init(&ds->ds_synced_link);
596 err = dsl_dir_hold_obj(dp, dsl_dataset_phys(ds)->ds_dir_obj,
597 NULL, ds, &ds->ds_dir);
599 kmem_free(ds, sizeof (dsl_dataset_t));
604 mutex_init(&ds->ds_lock, NULL, MUTEX_DEFAULT, NULL);
605 mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL);
606 mutex_init(&ds->ds_sendstream_lock, NULL, MUTEX_DEFAULT, NULL);
607 mutex_init(&ds->ds_remap_deadlist_lock,
609 rrw_init(&ds->ds_bp_rwlock, B_FALSE);
610 zfs_refcount_create(&ds->ds_longholds);
612 bplist_create(&ds->ds_pending_deadlist);
614 list_create(&ds->ds_sendstreams, sizeof (dmu_sendstatus_t),
617 list_create(&ds->ds_prop_cbs, sizeof (dsl_prop_cb_record_t),
627 err = load_zfeature(mos, ds, f);
631 if (!ds->ds_is_snapshot) {
632 ds->ds_snapname[0] = '\0';
633 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
635 dsl_dataset_phys(ds)->ds_prev_snap_obj,
636 ds, &ds->ds_prev);
638 err = dsl_bookmark_init_ds(ds);
641 err = dsl_dataset_get_snapname(ds);
643 dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
645 ds->ds_dir->dd_pool->dp_meta_objset,
646 dsl_dataset_phys(ds)->ds_userrefs_obj,
647 &ds->ds_userrefs);
651 if (err == 0 && !ds->ds_is_snapshot) {
652 err = dsl_prop_get_int_ds(ds,
654 &ds->ds_reserved);
656 err = dsl_prop_get_int_ds(ds,
658 &ds->ds_quota);
661 ds->ds_reserved = ds->ds_quota = 0;
664 if (err == 0 && ds->ds_dir->dd_crypto_obj != 0 &&
665 ds->ds_is_snapshot &&
671 dsl_deadlist_open(&ds->ds_deadlist,
672 mos, dsl_dataset_phys(ds)->ds_deadlist_obj);
674 dsl_dataset_get_remap_deadlist_object(ds);
676 dsl_deadlist_open(&ds->ds_remap_deadlist, mos,
680 dmu_buf_init_user(&ds->ds_dbu, dsl_dataset_evict_sync,
681 dsl_dataset_evict_async, &ds->ds_dbuf);
683 winner = dmu_buf_set_user_ie(dbuf, &ds->ds_dbu);
686 bplist_destroy(&ds->ds_pending_deadlist);
687 dsl_deadlist_close(&ds->ds_deadlist);
688 if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
689 dsl_deadlist_close(&ds->ds_remap_deadlist);
690 dsl_bookmark_fini_ds(ds);
691 if (ds->ds_prev)
692 dsl_dataset_rele(ds->ds_prev, ds);
693 dsl_dir_rele(ds->ds_dir, ds);
695 if (dsl_dataset_feature_is_active(ds, f))
696 unload_zfeature(ds, f);
699 list_destroy(&ds->ds_prop_cbs);
700 list_destroy(&ds->ds_sendstreams);
701 mutex_destroy(&ds->ds_lock);
702 mutex_destroy(&ds->ds_opening_lock);
703 mutex_destroy(&ds->ds_sendstream_lock);
704 mutex_destroy(&ds->ds_remap_deadlist_lock);
705 zfs_refcount_destroy(&ds->ds_longholds);
706 rrw_destroy(&ds->ds_bp_rwlock);
707 kmem_free(ds, sizeof (dsl_dataset_t));
712 ds = winner;
714 ds->ds_fsid_guid =
715 unique_insert(dsl_dataset_phys(ds)->ds_fsid_guid);
716 if (ds->ds_fsid_guid !=
717 dsl_dataset_phys(ds)->ds_fsid_guid) {
721 dsl_dataset_phys(ds)->ds_fsid_guid,
722 (long long)ds->ds_fsid_guid,
729 ASSERT3P(ds->ds_dbuf, ==, dbuf);
730 ASSERT3P(dsl_dataset_phys(ds), ==, dbuf->db_data);
731 ASSERT(dsl_dataset_phys(ds)->ds_prev_snap_obj != 0 ||
733 dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
734 *dsp = ds;
740 dsl_dataset_create_key_mapping(dsl_dataset_t *ds)
742 dsl_dir_t *dd = ds->ds_dir;
748 ds, ds, &ds->ds_key_mapping));
780 dsl_dataset_t *ds;
789 err = dsl_dataset_hold_obj_flags(dp, obj, flags, tag, &ds);
798 dsl_dataset_rele_flags(ds, flags, tag);
804 err = dsl_dataset_snap_lookup(ds, snapname, &obj);
809 dsl_dataset_rele_flags(ds, flags, tag);
817 ds = snap_ds;
821 *dsp = ds;
901 dsl_dataset_long_hold(dsl_dataset_t *ds, void *tag)
903 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
904 (void) zfs_refcount_add(&ds->ds_longholds, tag);
908 dsl_dataset_long_rele(dsl_dataset_t *ds, void *tag)
910 (void) zfs_refcount_remove(&ds->ds_longholds, tag);
915 dsl_dataset_long_held(dsl_dataset_t *ds)
917 return (!zfs_refcount_is_zero(&ds->ds_longholds));
921 dsl_dataset_name(dsl_dataset_t *ds, char *name)
923 if (ds == NULL) {
926 dsl_dir_name(ds->ds_dir, name);
927 VERIFY0(dsl_dataset_get_snapname(ds));
928 if (ds->ds_snapname[0]) {
935 if (!MUTEX_HELD(&ds->ds_lock)) {
936 mutex_enter(&ds->ds_lock);
937 VERIFY3U(strlcat(name, ds->ds_snapname,
940 mutex_exit(&ds->ds_lock);
942 VERIFY3U(strlcat(name, ds->ds_snapname,
951 dsl_dataset_namelen(dsl_dataset_t *ds)
953 VERIFY0(dsl_dataset_get_snapname(ds));
954 mutex_enter(&ds->ds_lock);
955 int len = strlen(ds->ds_snapname);
956 mutex_exit(&ds->ds_lock);
957 /* add '@' if ds is a snap */
960 len += dsl_dir_namelen(ds->ds_dir);
965 dsl_dataset_rele(dsl_dataset_t *ds, void *tag)
967 dmu_buf_rele(ds->ds_dbuf, tag);
971 dsl_dataset_remove_key_mapping(dsl_dataset_t *ds)
973 dsl_dir_t *dd = ds->ds_dir;
979 ds->ds_object, ds);
983 dsl_dataset_rele_flags(dsl_dataset_t *ds, ds_hold_flags_t flags, void *tag)
986 dsl_dataset_remove_key_mapping(ds);
988 dsl_dataset_rele(ds, tag);
992 dsl_dataset_disown(dsl_dataset_t *ds, ds_hold_flags_t flags, void *tag)
994 ASSERT3P(ds->ds_owner, ==, tag);
995 ASSERT(ds->ds_dbuf != NULL);
997 mutex_enter(&ds->ds_lock);
998 ds->ds_owner = NULL;
999 mutex_exit(&ds->ds_lock);
1000 dsl_dataset_long_rele(ds, tag);
1001 dsl_dataset_rele_flags(ds, flags, tag);
1005 dsl_dataset_tryown(dsl_dataset_t *ds, void *tag, boolean_t override)
1009 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
1010 mutex_enter(&ds->ds_lock);
1011 if (ds->ds_owner == NULL && (override || !(DS_IS_INCONSISTENT(ds) ||
1012 (dsl_dataset_feature_is_active(ds,
1015 ds->ds_owner = tag;
1016 dsl_dataset_long_hold(ds, tag);
1019 mutex_exit(&ds->ds_lock);
1024 dsl_dataset_has_owner(dsl_dataset_t *ds)
1027 mutex_enter(&ds->ds_lock);
1028 rv = (ds->ds_owner != NULL);
1029 mutex_exit(&ds->ds_lock);
1055 dsl_dataset_feature_is_active(dsl_dataset_t *ds, spa_feature_t f)
1057 return (zfeature_active(f, ds->ds_feature[f]));
1066 dsl_dataset_get_uint64_array_feature(dsl_dataset_t *ds, spa_feature_t f,
1070 if (!dsl_dataset_feature_is_active(ds, f)) {
1073 struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
1111 dsl_dataset_deactivate_feature_impl(dsl_dataset_t *ds, spa_feature_t f,
1116 uint64_t dsobj = ds->ds_object;
1122 ds->ds_feature[f] = NULL;
1126 dsl_dataset_deactivate_feature(dsl_dataset_t *ds, spa_feature_t f, dmu_tx_t *tx)
1128 unload_zfeature(ds, f);
1129 dsl_dataset_deactivate_feature_impl(ds, f, tx);
1250 dsl_dataset_zero_zil(dsl_dataset_t *ds, dmu_tx_t *tx)
1254 VERIFY0(dmu_objset_from_ds(ds, &os));
1256 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1264 dsl_dataset_sync(ds, zio, tx);
1268 dmu_buf_add_ref(ds->ds_dbuf, ds);
1269 dsl_dataset_sync_done(ds, tx);
1337 dsl_dataset_t *ds;
1339 VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
1340 dsl_dataset_zero_zil(ds, tx);
1341 dsl_dataset_rele(ds, FTAG);
1356 dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds)
1361 ASSERT(!ds->ds_is_snapshot);
1363 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0)
1364 mrs_used = dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes;
1368 dsl_deadlist_space(&ds->ds_deadlist, &dlused, &dlcomp, &dluncomp);
1371 dsl_dataset_phys(ds)->ds_unique_bytes =
1372 dsl_dataset_phys(ds)->ds_referenced_bytes - (mrs_used - dlused);
1374 if (spa_version(ds->ds_dir->dd_pool->dp_spa) >=
1376 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1380 dsl_dataset_remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj,
1383 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1387 ASSERT(dsl_dataset_phys(ds)->ds_num_children >= 2);
1388 err = zap_remove_int(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1402 ASSERT0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1404 ASSERT3U(count, <=, dsl_dataset_phys(ds)->ds_num_children - 2);
1409 dsl_dataset_get_blkptr(dsl_dataset_t *ds)
1411 return (&dsl_dataset_phys(ds)->ds_bp);
1415 dsl_dataset_get_spa(dsl_dataset_t *ds)
1417 return (ds->ds_dir->dd_pool->dp_spa);
1421 dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx)
1425 if (ds == NULL) /* this is the meta-objset */
1428 ASSERT(ds->ds_objset != NULL);
1430 if (dsl_dataset_phys(ds)->ds_next_snap_obj != 0)
1434 ASSERT3U(tx->tx_txg, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
1436 dp = ds->ds_dir->dd_pool;
1437 if (txg_list_add(&dp->dp_dirty_datasets, ds, tx->tx_txg)) {
1438 objset_t *os = ds->ds_objset;
1441 dmu_buf_add_ref(ds->ds_dbuf, ds);
1444 if (ds->ds_dir->dd_crypto_obj != 0 &&
1447 ASSERT3P(ds->ds_key_mapping, !=, NULL);
1448 key_mapping_add_ref(ds->ds_key_mapping, ds);
1454 dsl_dataset_snapshot_reserve_space(dsl_dataset_t *ds, dmu_tx_t *tx)
1466 ASSERT(ds->ds_reserved == 0 || DS_UNIQUE_IS_ACCURATE(ds));
1467 asize = MIN(dsl_dataset_phys(ds)->ds_unique_bytes, ds->ds_reserved);
1468 if (asize > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
1476 dsl_dir_willuse_space(ds->ds_dir, asize, tx);
1482 dsl_dataset_snapshot_check_impl(dsl_dataset_t *ds, const char *snapname,
1488 ds->ds_trysnap_txg = tx->tx_txg;
1497 if (dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg)
1503 error = dsl_dataset_snap_lookup(ds, snapname, &value);
1518 if (!recv && DS_IS_INCONSISTENT(ds))
1527 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1533 error = dsl_dataset_snapshot_reserve_space(ds, tx);
1619 dsl_dataset_t *ds;
1625 error = dsl_dataset_hold(dp, name, FTAG, &ds);
1627 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1630 dsl_dataset_rele(ds, FTAG);
1648 dsl_dataset_t *ds;
1663 error = dsl_dataset_hold(dp, dsname, FTAG, &ds);
1666 error = dsl_dataset_snapshot_check_impl(ds,
1668 dsl_dataset_rele(ds, FTAG);
1684 dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname,
1687 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1702 dmu_objset_from_ds(ds, &os) != 0 ||
1707 ASSERT(!txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
1708 ds, tx->tx_txg));
1710 dsl_fs_ss_count_adjust(ds->ds_dir, 1, DD_FIELD_SNAPSHOT_COUNT, tx);
1726 dsphys->ds_dir_obj = ds->ds_dir->dd_object;
1730 dsphys->ds_prev_snap_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
1731 dsphys->ds_prev_snap_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
1732 dsphys->ds_next_snap_obj = ds->ds_object;
1736 dsphys->ds_deadlist_obj = dsl_dataset_phys(ds)->ds_deadlist_obj;
1737 dsphys->ds_referenced_bytes = dsl_dataset_phys(ds)->ds_referenced_bytes;
1738 dsphys->ds_compressed_bytes = dsl_dataset_phys(ds)->ds_compressed_bytes;
1740 dsl_dataset_phys(ds)->ds_uncompressed_bytes;
1741 dsphys->ds_flags = dsl_dataset_phys(ds)->ds_flags;
1742 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
1743 dsphys->ds_bp = dsl_dataset_phys(ds)->ds_bp;
1744 rrw_exit(&ds->ds_bp_rwlock, FTAG);
1748 if (zfeature_active(f, ds->ds_feature[f])) {
1750 ds->ds_feature[f], tx);
1754 ASSERT3U(ds->ds_prev != 0, ==,
1755 dsl_dataset_phys(ds)->ds_prev_snap_obj != 0);
1756 if (ds->ds_prev) {
1758 dsl_dataset_phys(ds->ds_prev)->ds_next_clones_obj;
1759 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1760 ds->ds_object ||
1761 dsl_dataset_phys(ds->ds_prev)->ds_num_children > 1);
1762 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1763 ds->ds_object) {
1764 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
1765 ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, ==,
1766 dsl_dataset_phys(ds->ds_prev)->ds_creation_txg);
1767 dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj = dsobj;
1769 dsl_dataset_remove_from_next_clones(ds->ds_prev,
1781 if (ds->ds_reserved) {
1783 ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
1784 delta = MIN(dsl_dataset_phys(ds)->ds_unique_bytes,
1785 ds->ds_reserved);
1786 dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV,
1790 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1791 dsl_dataset_phys(ds)->ds_deadlist_obj =
1792 dsl_deadlist_clone(&ds->ds_deadlist, UINT64_MAX,
1793 dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
1794 dsl_deadlist_close(&ds->ds_deadlist);
1795 dsl_deadlist_open(&ds->ds_deadlist, mos,
1796 dsl_dataset_phys(ds)->ds_deadlist_obj);
1797 dsl_deadlist_add_key(&ds->ds_deadlist,
1798 dsl_dataset_phys(ds)->ds_prev_snap_txg, tx);
1799 dsl_bookmark_snapshotted(ds, tx);
1801 if (dsl_dataset_remap_deadlist_exists(ds)) {
1803 dsl_dataset_get_remap_deadlist_object(ds);
1809 dsl_dataset_unset_remap_deadlist_object(ds, tx);
1810 dsl_deadlist_close(&ds->ds_remap_deadlist);
1832 if (ds->ds_dir->dd_crypto_obj != 0 &&
1841 ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, <, tx->tx_txg);
1842 dsl_dataset_phys(ds)->ds_prev_snap_obj = dsobj;
1843 dsl_dataset_phys(ds)->ds_prev_snap_txg = crtxg;
1844 dsl_dataset_phys(ds)->ds_unique_bytes = 0;
1847 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1849 VERIFY0(zap_add(mos, dsl_dataset_phys(ds)->ds_snapnames_zapobj,
1852 if (ds->ds_prev)
1853 dsl_dataset_rele(ds->ds_prev, ds);
1855 dsl_dataset_phys(ds)->ds_prev_snap_obj, ds, &ds->ds_prev));
1857 dsl_scan_ds_snapshotted(ds, tx);
1859 dsl_dir_snap_cmtime_update(ds->ds_dir);
1861 spa_history_log_internal_ds(ds->ds_prev, "snapshot", tx, " ");
1873 dsl_dataset_t *ds;
1880 VERIFY0(dsl_dataset_hold(dp, dsname, FTAG, &ds));
1882 dsl_dataset_snapshot_sync_impl(ds, atp + 1, tx);
1884 dsl_props_set_sync_impl(ds->ds_prev,
1887 dsl_dataset_rele(ds, FTAG);
1984 dsl_dataset_t *ds;
1987 error = dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds);
1992 error = dsl_dataset_snapshot_check_impl(ds, ddsta->ddsta_snapname,
1995 dsl_dataset_rele(ds, FTAG);
2000 dsl_dataset_rele(ds, FTAG);
2006 dsl_dataset_rele(ds, FTAG);
2010 dsl_dataset_rele(ds, FTAG);
2019 dsl_dataset_t *ds = NULL;
2021 VERIFY0(dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds));
2023 dsl_dataset_snapshot_sync_impl(ds, ddsta->ddsta_snapname, tx);
2024 dsl_dataset_user_hold_sync_one(ds->ds_prev, ddsta->ddsta_htag,
2026 dsl_destroy_snapshot_sync_impl(ds->ds_prev, B_TRUE, tx);
2028 dsl_dataset_rele(ds, FTAG);
2067 dsl_dataset_sync(dsl_dataset_t *ds, zio_t *zio, dmu_tx_t *tx)
2070 ASSERT(ds->ds_objset != NULL);
2071 ASSERT(dsl_dataset_phys(ds)->ds_next_snap_obj == 0);
2077 dmu_buf_will_dirty(ds->ds_dbuf, tx);
2078 dsl_dataset_phys(ds)->ds_fsid_guid = ds->ds_fsid_guid;
2080 if (ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] != 0) {
2082 ds->ds_object, DS_FIELD_RESUME_OBJECT, 8, 1,
2083 &ds->ds_resume_object[tx->tx_txg & TXG_MASK], tx));
2085 ds->ds_object, DS_FIELD_RESUME_OFFSET, 8, 1,
2086 &ds->ds_resume_offset[tx->tx_txg & TXG_MASK], tx));
2088 ds->ds_object, DS_FIELD_RESUME_BYTES, 8, 1,
2089 &ds->ds_resume_bytes[tx->tx_txg & TXG_MASK], tx));
2090 ds->ds_resume_object[tx->tx_txg & TXG_MASK] = 0;
2091 ds->ds_resume_offset[tx->tx_txg & TXG_MASK] = 0;
2092 ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] = 0;
2095 dmu_objset_sync(ds->ds_objset, zio, tx);
2098 if (zfeature_active(f, ds->ds_feature_activation[f])) {
2099 if (zfeature_active(f, ds->ds_feature[f]))
2101 dsl_dataset_activate_feature(ds->ds_object, f,
2102 ds->ds_feature_activation[f], tx);
2103 ds->ds_feature[f] = ds->ds_feature_activation[f];
2114 dsl_livelist_should_disable(dsl_dataset_t *ds)
2119 used = dsl_dir_get_usedds(ds->ds_dir);
2120 referenced = dsl_get_referenced(ds);
2154 dsl_dataset_t *ds;
2166 dsl_dataset_t *ds = tca->ds;
2167 dsl_deadlist_t *ll = &ds->ds_dir->dd_livelist;
2175 if (spa->spa_to_condense.ds != NULL)
2196 dmu_buf_add_ref(ds->ds_dbuf, spa);
2198 spa->spa_to_condense.ds = ds;
2209 dsl_flush_pending_livelist(dsl_dataset_t *ds, dmu_tx_t *tx)
2211 dsl_dir_t *dd = ds->ds_dir;
2212 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
2247 .ds = ds
2254 dsl_dataset_sync_done(dsl_dataset_t *ds, dmu_tx_t *tx)
2256 objset_t *os = ds->ds_objset;
2258 bplist_iterate(&ds->ds_pending_deadlist,
2259 dsl_deadlist_insert_alloc_cb, &ds->ds_deadlist, tx);
2261 if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist)) {
2262 dsl_flush_pending_livelist(ds, tx);
2263 if (dsl_livelist_should_disable(ds)) {
2264 dsl_dir_remove_livelist(ds->ds_dir, tx, B_TRUE);
2268 dsl_bookmark_sync_done(ds, tx);
2279 dmu_buf_rele(ds->ds_dbuf, ds);
2283 get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val)
2286 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
2290 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
2297 if (dsl_dataset_phys(ds)->ds_next_clones_obj != 0) {
2298 VERIFY0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
2301 if (count != dsl_dataset_phys(ds)->ds_num_children - 1) {
2305 dsl_dataset_phys(ds)->ds_next_clones_obj);
2310 VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
2321 get_clones_stat(dsl_dataset_t *ds, nvlist_t *nv)
2326 if (get_clones_stat_impl(ds, val) == 0) {
2341 get_receive_resume_stats_impl(dsl_dataset_t *ds)
2343 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2345 if (dsl_dataset_has_resume_receive_state(ds)) {
2353 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2357 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2361 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2365 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2369 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2374 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2378 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2382 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2386 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2390 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2394 if (dsl_dataset_feature_is_active(ds,
2398 VERIFY(dsl_dataset_get_uint64_array_feature(ds,
2404 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2408 VERIFY0(zap_length(dp->dp_meta_objset, ds->ds_object,
2415 VERIFY0(zap_lookup(dp->dp_meta_objset, ds->ds_object,
2457 get_child_receive_stats(dsl_dataset_t *ds)
2461 dsl_dataset_name(ds, recvname);
2466 dsl_dataset_hold(ds->ds_dir->dd_pool, recvname, FTAG,
2476 get_receive_resume_stats(dsl_dataset_t *ds, nvlist_t *nv)
2478 char *propval = get_receive_resume_stats_impl(ds);
2483 char *childval = get_child_receive_stats(ds);
2494 dsl_get_refratio(dsl_dataset_t *ds)
2496 uint64_t ratio = dsl_dataset_phys(ds)->ds_compressed_bytes == 0 ? 100 :
2497 (dsl_dataset_phys(ds)->ds_uncompressed_bytes * 100 /
2498 dsl_dataset_phys(ds)->ds_compressed_bytes);
2503 dsl_get_logicalreferenced(dsl_dataset_t *ds)
2505 return (dsl_dataset_phys(ds)->ds_uncompressed_bytes);
2509 dsl_get_compressratio(dsl_dataset_t *ds)
2511 if (ds->ds_is_snapshot) {
2512 return (dsl_get_refratio(ds));
2514 dsl_dir_t *dd = ds->ds_dir;
2523 dsl_get_used(dsl_dataset_t *ds)
2525 if (ds->ds_is_snapshot) {
2526 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2528 dsl_dir_t *dd = ds->ds_dir;
2537 dsl_get_creation(dsl_dataset_t *ds)
2539 return (dsl_dataset_phys(ds)->ds_creation_time);
2543 dsl_get_creationtxg(dsl_dataset_t *ds)
2545 return (dsl_dataset_phys(ds)->ds_creation_txg);
2549 dsl_get_refquota(dsl_dataset_t *ds)
2551 return (ds->ds_quota);
2555 dsl_get_refreservation(dsl_dataset_t *ds)
2557 return (ds->ds_reserved);
2561 dsl_get_guid(dsl_dataset_t *ds)
2563 return (dsl_dataset_phys(ds)->ds_guid);
2567 dsl_get_unique(dsl_dataset_t *ds)
2569 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2573 dsl_get_objsetid(dsl_dataset_t *ds)
2575 return (ds->ds_object);
2579 dsl_get_userrefs(dsl_dataset_t *ds)
2581 return (ds->ds_userrefs);
2585 dsl_get_defer_destroy(dsl_dataset_t *ds)
2587 return (DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
2591 dsl_get_referenced(dsl_dataset_t *ds)
2593 return (dsl_dataset_phys(ds)->ds_referenced_bytes);
2597 dsl_get_numclones(dsl_dataset_t *ds)
2599 ASSERT(ds->ds_is_snapshot);
2600 return (dsl_dataset_phys(ds)->ds_num_children - 1);
2604 dsl_get_inconsistent(dsl_dataset_t *ds)
2606 return ((dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT) ?
2611 dsl_get_redacted(dsl_dataset_t *ds)
2613 return (dsl_dataset_feature_is_active(ds,
2618 dsl_get_available(dsl_dataset_t *ds)
2620 uint64_t refdbytes = dsl_get_referenced(ds);
2621 uint64_t availbytes = dsl_dir_space_available(ds->ds_dir,
2623 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
2625 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
2627 if (ds->ds_quota != 0) {
2631 if (refdbytes < ds->ds_quota) {
2633 ds->ds_quota - refdbytes);
2642 dsl_get_written(dsl_dataset_t *ds, uint64_t *written)
2644 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2647 dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
2650 err = dsl_dataset_space_written(prev, ds, written,
2661 dsl_get_prev_snap(dsl_dataset_t *ds, char *snap)
2663 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2664 if (ds->ds_prev != NULL && ds->ds_prev != dp->dp_origin_snap) {
2665 dsl_dataset_name(ds->ds_prev, snap);
2673 dsl_get_redact_snaps(dsl_dataset_t *ds, nvlist_t *propval)
2677 if (dsl_dataset_get_uint64_array_feature(ds,
2691 dsl_get_mountpoint(dsl_dataset_t *ds, const char *dsname, char *value,
2695 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2698 error = dsl_prop_get_ds(ds, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1,
2764 dsl_dataset_stats(dsl_dataset_t *ds, nvlist_t *nv)
2766 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2771 dsl_get_refratio(ds));
2773 dsl_get_logicalreferenced(ds));
2775 dsl_get_compressratio(ds));
2777 dsl_get_used(ds));
2779 if (ds->ds_is_snapshot) {
2780 get_clones_stat(ds, nv);
2783 if (dsl_get_prev_snap(ds, buf) == 0)
2786 dsl_dir_stats(ds->ds_dir, nv);
2790 dsl_get_redact_snaps(ds, propval);
2796 dsl_get_available(ds));
2798 dsl_get_referenced(ds));
2800 dsl_get_creation(ds));
2802 dsl_get_creationtxg(ds));
2804 dsl_get_refquota(ds));
2806 dsl_get_refreservation(ds));
2808 dsl_get_guid(ds));
2810 dsl_get_unique(ds));
2812 dsl_get_objsetid(ds));
2814 dsl_get_userrefs(ds));
2816 dsl_get_defer_destroy(ds));
2817 dsl_dataset_crypt_stats(ds, nv);
2819 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
2821 if (dsl_get_written(ds, &written) == 0) {
2827 if (!dsl_dataset_is_snapshot(ds)) {
2832 get_receive_resume_stats(ds, nv);
2842 dsl_dataset_name(ds, recvname);
2855 dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat)
2857 dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
2860 stat->dds_creation_txg = dsl_get_creationtxg(ds);
2861 stat->dds_inconsistent = dsl_get_inconsistent(ds);
2862 stat->dds_guid = dsl_get_guid(ds);
2863 stat->dds_redacted = dsl_get_redacted(ds);
2865 if (ds->ds_is_snapshot) {
2867 stat->dds_num_clones = dsl_get_numclones(ds);
2872 if (dsl_dir_is_clone(ds->ds_dir)) {
2873 dsl_dir_get_origin(ds->ds_dir, stat->dds_origin);
2879 dsl_dataset_fsid_guid(dsl_dataset_t *ds)
2881 return (ds->ds_fsid_guid);
2885 dsl_dataset_space(dsl_dataset_t *ds,
2889 *refdbytesp = dsl_dataset_phys(ds)->ds_referenced_bytes;
2890 *availbytesp = dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE);
2891 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes)
2893 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
2894 if (ds->ds_quota != 0) {
2898 if (*refdbytesp < ds->ds_quota)
2900 ds->ds_quota - *refdbytesp);
2904 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2905 *usedobjsp = BP_GET_FILL(&dsl_dataset_phys(ds)->ds_bp);
2906 rrw_exit(&ds->ds_bp_rwlock, FTAG);
2911 dsl_dataset_modified_since_snap(dsl_dataset_t *ds, dsl_dataset_t *snap)
2913 dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
2919 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2920 birth = dsl_dataset_get_blkptr(ds)->blk_birth;
2921 rrw_exit(&ds->ds_bp_rwlock, FTAG);
2929 if (dmu_objset_from_ds(ds, &os) != 0)
3006 dsl_dataset_t *ds;
3018 VERIFY0(dsl_dataset_hold_obj(dp, val, FTAG, &ds));
3021 spa_history_log_internal_ds(ds, "rename", tx,
3026 mutex_enter(&ds->ds_lock);
3027 (void) strlcpy(ds->ds_snapname, ddrsa->ddrsa_newsnapname,
3028 sizeof (ds->ds_snapname));
3029 mutex_exit(&ds->ds_lock);
3032 ds->ds_snapname, 8, 1, &ds->ds_object, tx));
3036 dsl_dataset_rele(ds, FTAG);
3083 dsl_dataset_handoff_check(dsl_dataset_t *ds, void *owner, dmu_tx_t *tx)
3090 dsl_dir_t *dd = ds->ds_dir;
3092 uint64_t holds = zfs_refcount_count(&ds->ds_longholds) -
3117 dsl_dataset_t *ds;
3121 error = dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds);
3126 if (ds->ds_is_snapshot) {
3127 dsl_dataset_rele(ds, FTAG);
3132 if (dsl_dataset_phys(ds)->ds_prev_snap_txg < TXG_INITIAL) {
3133 dsl_dataset_rele(ds, FTAG);
3144 dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg) {
3145 dsl_dataset_rele(ds, FTAG);
3169 dsl_dataset_rele(ds, FTAG);
3175 if (snapds != ds->ds_prev) {
3181 if (snapds->ds_dir == ds->ds_dir ||
3182 (dsl_dir_is_clone(ds->ds_dir) &&
3183 dsl_dir_phys(ds->ds_dir)->dd_origin_obj ==
3190 dsl_dataset_rele(ds, FTAG);
3197 if (dsl_bookmark_latest_txg(ds) >
3198 dsl_dataset_phys(ds)->ds_prev_snap_txg) {
3199 dsl_dataset_rele(ds, FTAG);
3203 error = dsl_dataset_handoff_check(ds, ddra->ddra_owner, tx);
3205 dsl_dataset_rele(ds, FTAG);
3213 if (ds->ds_quota != 0 &&
3214 dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes > ds->ds_quota) {
3215 dsl_dataset_rele(ds, FTAG);
3226 unused_refres_delta = (int64_t)MIN(ds->ds_reserved,
3227 dsl_dataset_phys(ds)->ds_unique_bytes);
3231 dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE)) {
3232 dsl_dataset_rele(ds, FTAG);
3236 dsl_dataset_rele(ds, FTAG);
3245 dsl_dataset_t *ds, *clone;
3249 VERIFY0(dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds));
3251 dsl_dataset_name(ds->ds_prev, namebuf);
3254 cloneobj = dsl_dataset_create_sync(ds->ds_dir, "%rollback",
3255 ds->ds_prev, DS_CREATE_FLAG_NODIRTY, kcred, NULL, tx);
3259 dsl_dataset_clone_swap_sync_impl(clone, ds, tx);
3260 dsl_dataset_zero_zil(ds, tx);
3265 dsl_dataset_rele(ds, FTAG);
3299 dsl_dataset_t *ds;
3334 origin_head = snap->ds;
3339 origin_ds = snap->ds;
3363 ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
3365 dsl_deadlist_space_range(&snap->ds->ds_deadlist,
3392 dsl_dataset_t *ds = snap->ds;
3400 if (dsl_dataset_long_held(ds)) {
3406 VERIFY0(dsl_dataset_get_snapname(ds));
3407 if (strlen(ds->ds_snapname) >= max_snap_len) {
3411 err = dsl_dataset_snap_lookup(hds, ds->ds_snapname, &val);
3414 snap->ds->ds_snapname);
3421 if (dsl_dataset_phys(ds)->ds_prev_snap_obj == 0)
3424 dsl_deadlist_space(&ds->ds_deadlist,
3508 snap->ds->ds_dir->dd_origin_txg, &ddpa->cloneusedsnap);
3513 snap->ds->ds_dir->dd_origin_txg, &space);
3554 origin_ds = snap->ds;
3558 origin_head = snap->ds;
3573 ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
3575 dsl_dataset_phys(origin_ds)->ds_next_snap_obj = snap->ds->ds_object;
3580 snap->ds->ds_object, tx);
3638 dsl_dataset_t *ds = snap->ds;
3645 if (ds->ds_objset) {
3646 dmu_objset_evict(ds->ds_objset);
3647 ds->ds_objset = NULL;
3651 VERIFY0(dsl_dataset_get_snapname(ds));
3653 ds->ds_snapname, tx, B_TRUE));
3655 dsl_dataset_phys(hds)->ds_snapnames_zapobj, ds->ds_snapname,
3656 8, 1, &ds->ds_object, tx));
3661 dmu_buf_will_dirty(ds->ds_dbuf, tx);
3662 ASSERT3U(dsl_dataset_phys(ds)->ds_dir_obj, ==, odd->dd_object);
3663 dsl_dataset_phys(ds)->ds_dir_obj = dd->dd_object;
3664 ASSERT3P(ds->ds_dir, ==, odd);
3665 dsl_dir_rele(ds->ds_dir, ds);
3667 NULL, ds, &ds->ds_dir));
3670 if (dsl_dataset_phys(ds)->ds_next_clones_obj &&
3676 dsl_dataset_phys(ds)->ds_next_clones_obj);
3704 ASSERT(!dsl_prop_hascb(ds));
3764 dsl_dataset_t *ds;
3768 err = dsl_dataset_hold_obj(dp, obj, tag, &ds);
3774 first_obj = dsl_dir_phys(ds->ds_dir)->dd_origin_obj;
3777 snap->ds = ds;
3779 obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
3793 dsl_deadlist_space_range(&snap->ds->ds_deadlist,
3810 dsl_dataset_rele(snap->ds, tag);
3846 ASSERT3U(snap->ds->ds_object, ==, dsl_dir_phys(dd)->dd_origin_obj);
3848 dsl_dir_phys(snap->ds->ds_dir)->dd_head_dataset_obj,
3853 if (dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj != 0) {
3855 dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj,
4236 dsl_dataset_t *ds;
4243 error = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
4245 dsl_dataset_name(ds, buf);
4246 dsl_dataset_rele(ds, FTAG);
4254 dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
4267 mutex_enter(&ds->ds_lock);
4271 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
4273 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
4275 (ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
4277 asize - MIN(asize, parent_delta(ds, asize + inflight));
4280 if (!check_quota || ds->ds_quota == 0) {
4281 mutex_exit(&ds->ds_lock);
4290 if (dsl_dataset_phys(ds)->ds_referenced_bytes + inflight >=
4291 ds->ds_quota) {
4293 dsl_dataset_phys(ds)->ds_referenced_bytes < ds->ds_quota)
4298 mutex_exit(&ds->ds_lock);
4316 dsl_dataset_t *ds;
4323 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
4327 if (ds->ds_is_snapshot) {
4328 dsl_dataset_rele(ds, FTAG);
4332 error = dsl_prop_predict(ds->ds_dir,
4336 dsl_dataset_rele(ds, FTAG);
4341 dsl_dataset_rele(ds, FTAG);
4345 if (newval < dsl_dataset_phys(ds)->ds_referenced_bytes ||
4346 newval < ds->ds_reserved) {
4347 dsl_dataset_rele(ds, FTAG);
4351 dsl_dataset_rele(ds, FTAG);
4360 dsl_dataset_t *ds = NULL;
4363 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
4365 dsl_prop_set_sync_impl(ds,
4370 VERIFY0(dsl_prop_get_int_ds(ds,
4373 if (ds->ds_quota != newval) {
4374 dmu_buf_will_dirty(ds->ds_dbuf, tx);
4375 ds->ds_quota = newval;
4377 dsl_dataset_rele(ds, FTAG);
4400 dsl_dataset_t *ds;
4407 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
4411 if (ds->ds_is_snapshot) {
4412 dsl_dataset_rele(ds, FTAG);
4416 error = dsl_prop_predict(ds->ds_dir,
4420 dsl_dataset_rele(ds, FTAG);
4429 dsl_dataset_rele(ds, FTAG);
4433 mutex_enter(&ds->ds_lock);
4434 if (!DS_UNIQUE_IS_ACCURATE(ds))
4435 dsl_dataset_recalc_head_uniq(ds);
4436 unique = dsl_dataset_phys(ds)->ds_unique_bytes;
4437 mutex_exit(&ds->ds_lock);
4439 if (MAX(unique, newval) > MAX(unique, ds->ds_reserved)) {
4441 MAX(unique, ds->ds_reserved);
4444 dsl_dir_space_available(ds->ds_dir, NULL, 0, B_TRUE) ||
4445 (ds->ds_quota > 0 && newval > ds->ds_quota)) {
4446 dsl_dataset_rele(ds, FTAG);
4451 dsl_dataset_rele(ds, FTAG);
4456 dsl_dataset_set_refreservation_sync_impl(dsl_dataset_t *ds,
4463 dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
4466 VERIFY0(dsl_prop_get_int_ds(ds,
4469 dmu_buf_will_dirty(ds->ds_dbuf, tx);
4470 mutex_enter(&ds->ds_dir->dd_lock);
4471 mutex_enter(&ds->ds_lock);
4472 ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
4473 unique = dsl_dataset_phys(ds)->ds_unique_bytes;
4475 MAX(0, (int64_t)(ds->ds_reserved - unique));
4476 ds->ds_reserved = newval;
4477 mutex_exit(&ds->ds_lock);
4479 dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV, delta, 0, 0, tx);
4480 mutex_exit(&ds->ds_dir->dd_lock);
4488 dsl_dataset_t *ds = NULL;
4490 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
4491 dsl_dataset_set_refreservation_sync_impl(ds,
4493 dsl_dataset_rele(ds, FTAG);
4541 dsl_dataset_t *ds = NULL;
4547 VERIFY0(dsl_dataset_hold(dp, ddsca->ddsca_name, FTAG, &ds));
4548 if (zfeature_active(f, ds->ds_feature[f]) != B_TRUE) {
4549 ds->ds_feature_activation[f] = (void *)B_TRUE;
4550 dsl_dataset_activate_feature(ds->ds_object, f,
4551 ds->ds_feature_activation[f], tx);
4552 ds->ds_feature[f] = ds->ds_feature_activation[f];
4554 dsl_dataset_rele(ds, FTAG);
4759 dsl_dataset_t *ds;
4762 err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &ds);
4766 dsl_deadlist_space_range(&ds->ds_deadlist,
4773 snapobj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
4775 dsl_dataset_rele(ds, FTAG);
4835 dsl_dataset_zapify(dsl_dataset_t *ds, dmu_tx_t *tx)
4837 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
4838 dmu_object_zapify(mos, ds->ds_object, DMU_OT_DSL_DATASET, tx);
4842 dsl_dataset_is_zapified(dsl_dataset_t *ds)
4846 dmu_object_info_from_db(ds->ds_dbuf, &doi);
4851 dsl_dataset_has_resume_receive_state(dsl_dataset_t *ds)
4853 return (dsl_dataset_is_zapified(ds) &&
4854 zap_contains(ds->ds_dir->dd_pool->dp_meta_objset,
4855 ds->ds_object, DS_FIELD_RESUME_TOGUID) == 0);
4859 dsl_dataset_get_remap_deadlist_object(dsl_dataset_t *ds)
4864 if (!dsl_dataset_is_zapified(ds))
4867 err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
4881 dsl_dataset_remap_deadlist_exists(dsl_dataset_t *ds)
4883 EQUIV(dsl_deadlist_is_open(&ds->ds_remap_deadlist),
4884 dsl_dataset_get_remap_deadlist_object(ds) != 0);
4885 return (dsl_deadlist_is_open(&ds->ds_remap_deadlist));
4889 dsl_dataset_set_remap_deadlist_object(dsl_dataset_t *ds, uint64_t obj,
4893 dsl_dataset_zapify(ds, tx);
4894 VERIFY0(zap_add(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
4899 dsl_dataset_unset_remap_deadlist_object(dsl_dataset_t *ds, dmu_tx_t *tx)
4901 VERIFY0(zap_remove(ds->ds_dir->dd_pool->dp_meta_objset,
4902 ds->ds_object, DS_FIELD_REMAP_DEADLIST, tx));
4906 dsl_dataset_destroy_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx)
4909 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
4912 ASSERT(dsl_dataset_remap_deadlist_exists(ds));
4914 remap_deadlist_object = ds->ds_remap_deadlist.dl_object;
4915 dsl_deadlist_close(&ds->ds_remap_deadlist);
4917 dsl_dataset_unset_remap_deadlist_object(ds, tx);
4922 dsl_dataset_create_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx)
4925 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
4928 ASSERT(MUTEX_HELD(&ds->ds_remap_deadlist_lock));
4936 &ds->ds_deadlist, UINT64_MAX,
4937 dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
4938 dsl_dataset_set_remap_deadlist_object(ds,
4940 dsl_deadlist_open(&ds->ds_remap_deadlist, spa_meta_objset(spa),
4946 dsl_dataset_activate_redaction(dsl_dataset_t *ds, uint64_t *redact_snaps,
4949 uint64_t dsobj = ds->ds_object;
4961 ds->ds_feature[SPA_FEATURE_REDACTED_DATASETS] = ftuaa;