Lines Matching defs:ds
103 static void dsl_dataset_set_remap_deadlist_object(dsl_dataset_t *ds,
105 static void dsl_dataset_unset_remap_deadlist_object(dsl_dataset_t *ds,
108 static void unload_zfeature(dsl_dataset_t *ds, spa_feature_t f);
120 parent_delta(dsl_dataset_t *ds, int64_t delta)
125 if (ds->ds_reserved == 0)
128 ds_phys = dsl_dataset_phys(ds);
129 old_bytes = MAX(ds_phys->ds_unique_bytes, ds->ds_reserved);
130 new_bytes = MAX(ds_phys->ds_unique_bytes + delta, ds->ds_reserved);
137 dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
146 dprintf_bp(bp, "ds=%p", ds);
154 if (ds == NULL) {
161 dsl_dataset_phys(ds)->ds_prev_snap_txg);
162 dmu_buf_will_dirty(ds->ds_dbuf, tx);
163 mutex_enter(&ds->ds_lock);
164 delta = parent_delta(ds, used);
165 dsl_dataset_phys(ds)->ds_referenced_bytes += used;
166 dsl_dataset_phys(ds)->ds_compressed_bytes += compressed;
167 dsl_dataset_phys(ds)->ds_uncompressed_bytes += uncompressed;
168 dsl_dataset_phys(ds)->ds_unique_bytes += used;
171 ds->ds_feature_activation[SPA_FEATURE_LARGE_BLOCKS] =
180 ds->ds_feature_activation[f] = (void *)B_TRUE;
187 ds->ds_feature_activation[f] = (void *)B_TRUE;
194 if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
195 BP_GET_LOGICAL_BIRTH(bp) > ds->ds_dir->dd_origin_txg &&
197 ASSERT(dsl_dir_is_clone(ds->ds_dir));
200 bplist_append(&ds->ds_dir->dd_pending_allocs, bp);
203 mutex_exit(&ds->ds_lock);
204 dsl_dir_diduse_transfer_space(ds->ds_dir, delta,
217 dsl_dataset_block_remapped(dsl_dataset_t *ds, uint64_t vdev, uint64_t offset,
220 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
224 ASSERT(!ds->ds_is_snapshot);
226 if (birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
232 ASSERT(ds != NULL);
234 mutex_enter(&ds->ds_remap_deadlist_lock);
235 if (!dsl_dataset_remap_deadlist_exists(ds)) {
236 dsl_dataset_create_remap_deadlist(ds, tx);
238 mutex_exit(&ds->ds_remap_deadlist_lock);
245 dsl_deadlist_insert(&ds->ds_remap_deadlist, &fakebp, B_FALSE,
251 dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx,
266 if (ds == NULL) {
272 ASSERT3P(tx->tx_pool, ==, ds->ds_dir->dd_pool);
274 ASSERT(!ds->ds_is_snapshot);
275 dmu_buf_will_dirty(ds->ds_dbuf, tx);
281 if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
282 BP_GET_LOGICAL_BIRTH(bp) > ds->ds_dir->dd_origin_txg &&
284 ASSERT(dsl_dir_is_clone(ds->ds_dir));
287 bplist_append(&ds->ds_dir->dd_pending_frees, bp);
290 if (BP_GET_LOGICAL_BIRTH(bp) > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
306 bpobj_enqueue(&ds->ds_dir->dd_pool->dp_free_bpobj,
309 dprintf_bp(bp, "freeing ds=%llu",
310 (u_longlong_t)ds->ds_object);
314 mutex_enter(&ds->ds_lock);
315 ASSERT(dsl_dataset_phys(ds)->ds_unique_bytes >= used ||
316 !DS_UNIQUE_IS_ACCURATE(ds));
317 delta = parent_delta(ds, -used);
318 dsl_dataset_phys(ds)->ds_unique_bytes -= used;
319 mutex_exit(&ds->ds_lock);
321 dsl_dir_diduse_transfer_space(ds->ds_dir,
338 bplist_append(&ds->ds_pending_deadlist, bp);
340 dsl_deadlist_insert(&ds->ds_deadlist, bp, B_FALSE, tx);
342 ASSERT3U(ds->ds_prev->ds_object, ==,
343 dsl_dataset_phys(ds)->ds_prev_snap_obj);
344 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_num_children > 0);
346 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
347 ds->ds_object && BP_GET_LOGICAL_BIRTH(bp) >
348 dsl_dataset_phys(ds->ds_prev)->ds_prev_snap_txg) {
349 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
350 mutex_enter(&ds->ds_prev->ds_lock);
351 dsl_dataset_phys(ds->ds_prev)->ds_unique_bytes += used;
352 mutex_exit(&ds->ds_prev->ds_lock);
354 if (BP_GET_LOGICAL_BIRTH(bp) > ds->ds_dir->dd_origin_txg) {
355 dsl_dir_transfer_space(ds->ds_dir, used,
360 dsl_bookmark_block_killed(ds, bp, tx);
362 mutex_enter(&ds->ds_lock);
363 ASSERT3U(dsl_dataset_phys(ds)->ds_referenced_bytes, >=, used);
364 dsl_dataset_phys(ds)->ds_referenced_bytes -= used;
365 ASSERT3U(dsl_dataset_phys(ds)->ds_compressed_bytes, >=, compressed);
366 dsl_dataset_phys(ds)->ds_compressed_bytes -= compressed;
367 ASSERT3U(dsl_dataset_phys(ds)->ds_uncompressed_bytes, >=, uncompressed);
368 dsl_dataset_phys(ds)->ds_uncompressed_bytes -= uncompressed;
369 mutex_exit(&ds->ds_lock);
380 unload_zfeature(dsl_dataset_t *ds, spa_feature_t f)
387 struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
398 load_zfeature(objset_t *mos, dsl_dataset_t *ds, spa_feature_t f)
403 err = zap_contains(mos, ds->ds_object,
406 ds->ds_feature[f] = (void *)B_TRUE;
416 err = zap_length(mos, ds->ds_object,
425 VERIFY0(zap_lookup(mos, ds->ds_object,
431 ds->ds_feature[f] = ftuaa;
449 dsl_dataset_t *ds = dbu;
451 ASSERT(ds->ds_owner == NULL);
453 unique_remove(ds->ds_fsid_guid);
459 dsl_dataset_t *ds = dbu;
461 ASSERT(ds->ds_owner == NULL);
463 ds->ds_dbuf = NULL;
465 if (ds->ds_objset != NULL)
466 dmu_objset_evict(ds->ds_objset);
468 if (ds->ds_prev) {
469 dsl_dataset_rele(ds->ds_prev, ds);
470 ds->ds_prev = NULL;
473 dsl_bookmark_fini_ds(ds);
475 bplist_destroy(&ds->ds_pending_deadlist);
476 if (dsl_deadlist_is_open(&ds->ds_deadlist))
477 dsl_deadlist_close(&ds->ds_deadlist);
478 if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
479 dsl_deadlist_close(&ds->ds_remap_deadlist);
480 if (ds->ds_dir)
481 dsl_dir_async_rele(ds->ds_dir, ds);
483 ASSERT(!list_link_active(&ds->ds_synced_link));
486 if (dsl_dataset_feature_is_active(ds, f))
487 unload_zfeature(ds, f);
490 list_destroy(&ds->ds_prop_cbs);
491 mutex_destroy(&ds->ds_lock);
492 mutex_destroy(&ds->ds_opening_lock);
493 mutex_destroy(&ds->ds_sendstream_lock);
494 mutex_destroy(&ds->ds_remap_deadlist_lock);
495 zfs_refcount_destroy(&ds->ds_longholds);
496 rrw_destroy(&ds->ds_bp_rwlock);
498 kmem_free(ds, sizeof (dsl_dataset_t));
502 dsl_dataset_get_snapname(dsl_dataset_t *ds)
507 dsl_pool_t *dp = ds->ds_dir->dd_pool;
510 if (ds->ds_snapname[0])
512 if (dsl_dataset_phys(ds)->ds_next_snap_obj == 0)
515 err = dmu_bonus_hold(mos, dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj,
521 headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname,
522 sizeof (ds->ds_snapname));
525 (void) snprintf(ds->ds_snapname, sizeof (ds->ds_snapname),
527 (unsigned long long)ds->ds_object, err);
534 dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name, uint64_t *value)
536 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
537 uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
541 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
552 dsl_dataset_snap_remove(dsl_dataset_t *ds, const char *name, dmu_tx_t *tx,
555 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
556 uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
560 dsl_dir_snap_cmtime_update(ds->ds_dir, tx);
562 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
570 dsl_fs_ss_count_adjust(ds->ds_dir, -1,
577 dsl_dataset_try_add_ref(dsl_pool_t *dp, dsl_dataset_t *ds, const void *tag)
579 dmu_buf_t *dbuf = ds->ds_dbuf;
583 ds->ds_object, DMU_BONUS_BLKID, tag)) {
585 if (ds == dmu_buf_get_user(dbuf))
600 dsl_dataset_t *ds;
617 ds = dmu_buf_get_user(dbuf);
618 if (ds == NULL) {
621 ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
622 ds->ds_dbuf = dbuf;
623 ds->ds_object = dsobj;
624 ds->ds_is_snapshot = dsl_dataset_phys(ds)->ds_num_children != 0;
625 list_link_init(&ds->ds_synced_link);
627 err = dsl_dir_hold_obj(dp, dsl_dataset_phys(ds)->ds_dir_obj,
628 NULL, ds, &ds->ds_dir);
630 kmem_free(ds, sizeof (dsl_dataset_t));
635 mutex_init(&ds->ds_lock, NULL, MUTEX_DEFAULT, NULL);
636 mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL);
637 mutex_init(&ds->ds_sendstream_lock, NULL, MUTEX_DEFAULT, NULL);
638 mutex_init(&ds->ds_remap_deadlist_lock,
640 rrw_init(&ds->ds_bp_rwlock, B_FALSE);
641 zfs_refcount_create(&ds->ds_longholds);
643 bplist_create(&ds->ds_pending_deadlist);
645 list_create(&ds->ds_sendstreams, sizeof (dmu_sendstatus_t),
648 list_create(&ds->ds_prop_cbs, sizeof (dsl_prop_cb_record_t),
658 err = load_zfeature(mos, ds, f);
662 if (!ds->ds_is_snapshot) {
663 ds->ds_snapname[0] = '\0';
664 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
666 dsl_dataset_phys(ds)->ds_prev_snap_obj,
667 ds, &ds->ds_prev);
671 err = dsl_bookmark_init_ds(ds);
674 err = dsl_dataset_get_snapname(ds);
676 dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
678 ds->ds_dir->dd_pool->dp_meta_objset,
679 dsl_dataset_phys(ds)->ds_userrefs_obj,
680 &ds->ds_userrefs);
684 if (err == 0 && !ds->ds_is_snapshot) {
685 err = dsl_prop_get_int_ds(ds,
687 &ds->ds_reserved);
689 err = dsl_prop_get_int_ds(ds,
691 &ds->ds_quota);
694 ds->ds_reserved = ds->ds_quota = 0;
697 if (err == 0 && ds->ds_dir->dd_crypto_obj != 0 &&
698 ds->ds_is_snapshot &&
705 err = dsl_deadlist_open(&ds->ds_deadlist,
706 mos, dsl_dataset_phys(ds)->ds_deadlist_obj);
710 dsl_dataset_get_remap_deadlist_object(ds);
712 err = dsl_deadlist_open(&ds->ds_remap_deadlist,
717 dmu_buf_init_user(&ds->ds_dbu, dsl_dataset_evict_sync,
718 dsl_dataset_evict_async, &ds->ds_dbuf);
720 winner = dmu_buf_set_user_ie(dbuf, &ds->ds_dbu);
723 if (dsl_deadlist_is_open(&ds->ds_deadlist))
724 dsl_deadlist_close(&ds->ds_deadlist);
725 if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
726 dsl_deadlist_close(&ds->ds_remap_deadlist);
727 dsl_bookmark_fini_ds(ds);
729 if (ds->ds_prev)
730 dsl_dataset_rele(ds->ds_prev, ds);
731 dsl_dir_rele(ds->ds_dir, ds);
733 if (dsl_dataset_feature_is_active(ds, f))
734 unload_zfeature(ds, f);
737 list_destroy(&ds->ds_prop_cbs);
738 list_destroy(&ds->ds_sendstreams);
739 bplist_destroy(&ds->ds_pending_deadlist);
740 mutex_destroy(&ds->ds_lock);
741 mutex_destroy(&ds->ds_opening_lock);
742 mutex_destroy(&ds->ds_sendstream_lock);
743 mutex_destroy(&ds->ds_remap_deadlist_lock);
744 zfs_refcount_destroy(&ds->ds_longholds);
745 rrw_destroy(&ds->ds_bp_rwlock);
746 kmem_free(ds, sizeof (dsl_dataset_t));
751 ds = winner;
753 ds->ds_fsid_guid =
754 unique_insert(dsl_dataset_phys(ds)->ds_fsid_guid);
755 if (ds->ds_fsid_guid !=
756 dsl_dataset_phys(ds)->ds_fsid_guid) {
760 dsl_dataset_phys(ds)->ds_fsid_guid,
761 (long long)ds->ds_fsid_guid,
768 ASSERT3P(ds->ds_dbuf, ==, dbuf);
769 ASSERT3P(dsl_dataset_phys(ds), ==, dbuf->db_data);
770 ASSERT(dsl_dataset_phys(ds)->ds_prev_snap_obj != 0 ||
772 dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
773 *dsp = ds;
779 dsl_dataset_create_key_mapping(dsl_dataset_t *ds)
781 dsl_dir_t *dd = ds->ds_dir;
787 ds, ds, &ds->ds_key_mapping));
819 dsl_dataset_t *ds;
828 err = dsl_dataset_hold_obj_flags(dp, obj, flags, tag, &ds);
837 dsl_dataset_rele_flags(ds, flags, tag);
843 err = dsl_dataset_snap_lookup(ds, snapname, &obj);
848 dsl_dataset_rele_flags(ds, flags, tag);
856 ds = snap_ds;
860 *dsp = ds;
940 dsl_dataset_long_hold(dsl_dataset_t *ds, const void *tag)
942 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
943 (void) zfs_refcount_add(&ds->ds_longholds, tag);
947 dsl_dataset_long_rele(dsl_dataset_t *ds, const void *tag)
949 (void) zfs_refcount_remove(&ds->ds_longholds, tag);
954 dsl_dataset_long_held(dsl_dataset_t *ds)
956 return (!zfs_refcount_is_zero(&ds->ds_longholds));
960 dsl_dataset_name(dsl_dataset_t *ds, char *name)
962 if (ds == NULL) {
965 dsl_dir_name(ds->ds_dir, name);
966 VERIFY0(dsl_dataset_get_snapname(ds));
967 if (ds->ds_snapname[0]) {
974 if (!MUTEX_HELD(&ds->ds_lock)) {
975 mutex_enter(&ds->ds_lock);
976 VERIFY3U(strlcat(name, ds->ds_snapname,
979 mutex_exit(&ds->ds_lock);
981 VERIFY3U(strlcat(name, ds->ds_snapname,
990 dsl_dataset_namelen(dsl_dataset_t *ds)
992 VERIFY0(dsl_dataset_get_snapname(ds));
993 mutex_enter(&ds->ds_lock);
994 int len = strlen(ds->ds_snapname);
995 mutex_exit(&ds->ds_lock);
996 /* add '@' if ds is a snap */
999 len += dsl_dir_namelen(ds->ds_dir);
1004 dsl_dataset_rele(dsl_dataset_t *ds, const void *tag)
1006 dmu_buf_rele(ds->ds_dbuf, tag);
1010 dsl_dataset_remove_key_mapping(dsl_dataset_t *ds)
1012 dsl_dir_t *dd = ds->ds_dir;
1018 ds->ds_object, ds);
1022 dsl_dataset_rele_flags(dsl_dataset_t *ds, ds_hold_flags_t flags,
1026 dsl_dataset_remove_key_mapping(ds);
1028 dsl_dataset_rele(ds, tag);
1032 dsl_dataset_disown(dsl_dataset_t *ds, ds_hold_flags_t flags, const void *tag)
1034 ASSERT3P(ds->ds_owner, ==, tag);
1035 ASSERT(ds->ds_dbuf != NULL);
1037 mutex_enter(&ds->ds_lock);
1038 ds->ds_owner = NULL;
1039 mutex_exit(&ds->ds_lock);
1040 dsl_dataset_long_rele(ds, tag);
1041 dsl_dataset_rele_flags(ds, flags, tag);
1045 dsl_dataset_tryown(dsl_dataset_t *ds, const void *tag, boolean_t override)
1049 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
1050 mutex_enter(&ds->ds_lock);
1051 if (ds->ds_owner == NULL && (override || !(DS_IS_INCONSISTENT(ds) ||
1052 (dsl_dataset_feature_is_active(ds,
1055 ds->ds_owner = tag;
1056 dsl_dataset_long_hold(ds, tag);
1059 mutex_exit(&ds->ds_lock);
1064 dsl_dataset_has_owner(dsl_dataset_t *ds)
1067 mutex_enter(&ds->ds_lock);
1068 rv = (ds->ds_owner != NULL);
1069 mutex_exit(&ds->ds_lock);
1095 dsl_dataset_feature_is_active(dsl_dataset_t *ds, spa_feature_t f)
1097 return (zfeature_active(f, ds->ds_feature[f]));
1106 dsl_dataset_get_uint64_array_feature(dsl_dataset_t *ds, spa_feature_t f,
1110 if (!dsl_dataset_feature_is_active(ds, f)) {
1113 struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
1151 dsl_dataset_deactivate_feature_impl(dsl_dataset_t *ds, spa_feature_t f,
1156 uint64_t dsobj = ds->ds_object;
1162 ds->ds_feature[f] = NULL;
1166 dsl_dataset_deactivate_feature(dsl_dataset_t *ds, spa_feature_t f, dmu_tx_t *tx)
1168 unload_zfeature(ds, f);
1169 dsl_dataset_deactivate_feature_impl(ds, f, tx);
1290 dsl_dataset_zero_zil(dsl_dataset_t *ds, dmu_tx_t *tx)
1294 VERIFY0(dmu_objset_from_ds(ds, &os));
1296 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1304 dsl_dataset_sync(ds, zio, tx);
1306 dsl_dataset_sync_done(ds, tx);
1374 dsl_dataset_t *ds;
1376 VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
1377 dsl_dataset_zero_zil(ds, tx);
1378 dsl_dataset_rele(ds, FTAG);
1393 dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds)
1398 ASSERT(!ds->ds_is_snapshot);
1400 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0)
1401 mrs_used = dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes;
1405 dsl_deadlist_space(&ds->ds_deadlist, &dlused, &dlcomp, &dluncomp);
1408 dsl_dataset_phys(ds)->ds_unique_bytes =
1409 dsl_dataset_phys(ds)->ds_referenced_bytes - (mrs_used - dlused);
1411 if (spa_version(ds->ds_dir->dd_pool->dp_spa) >=
1413 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1417 dsl_dataset_remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj,
1420 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1424 ASSERT(dsl_dataset_phys(ds)->ds_num_children >= 2);
1425 err = zap_remove_int(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1439 ASSERT0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1441 ASSERT3U(count, <=, dsl_dataset_phys(ds)->ds_num_children - 2);
1446 dsl_dataset_get_blkptr(dsl_dataset_t *ds)
1448 return (&dsl_dataset_phys(ds)->ds_bp);
1452 dsl_dataset_get_spa(dsl_dataset_t *ds)
1454 return (ds->ds_dir->dd_pool->dp_spa);
1458 dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx)
1462 if (ds == NULL) /* this is the meta-objset */
1465 ASSERT(ds->ds_objset != NULL);
1467 if (dsl_dataset_phys(ds)->ds_next_snap_obj != 0)
1471 ASSERT3U(tx->tx_txg, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
1473 dp = ds->ds_dir->dd_pool;
1474 if (txg_list_add(&dp->dp_dirty_datasets, ds, tx->tx_txg)) {
1475 objset_t *os = ds->ds_objset;
1478 dmu_buf_add_ref(ds->ds_dbuf, ds);
1481 if (ds->ds_dir->dd_crypto_obj != 0 &&
1484 ASSERT3P(ds->ds_key_mapping, !=, NULL);
1485 key_mapping_add_ref(ds->ds_key_mapping, ds);
1491 dsl_dataset_snapshot_reserve_space(dsl_dataset_t *ds, dmu_tx_t *tx)
1503 ASSERT(ds->ds_reserved == 0 || DS_UNIQUE_IS_ACCURATE(ds));
1504 asize = MIN(dsl_dataset_phys(ds)->ds_unique_bytes, ds->ds_reserved);
1505 if (asize > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
1513 dsl_dir_willuse_space(ds->ds_dir, asize, tx);
1519 dsl_dataset_snapshot_check_impl(dsl_dataset_t *ds, const char *snapname,
1525 ds->ds_trysnap_txg = tx->tx_txg;
1534 if (dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg)
1540 error = dsl_dataset_snap_lookup(ds, snapname, &value);
1555 if (!recv && DS_IS_INCONSISTENT(ds))
1564 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1570 error = dsl_dataset_snapshot_reserve_space(ds, tx);
1656 dsl_dataset_t *ds;
1662 error = dsl_dataset_hold(dp, name, FTAG, &ds);
1664 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1667 dsl_dataset_rele(ds, FTAG);
1685 dsl_dataset_t *ds;
1700 error = dsl_dataset_hold(dp, dsname, FTAG, &ds);
1703 error = dsl_dataset_snapshot_check_impl(ds,
1705 dsl_dataset_rele(ds, FTAG);
1721 dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname,
1724 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1738 dmu_objset_from_ds(ds, &os) != 0 ||
1743 ASSERT(!txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
1744 ds, tx->tx_txg));
1746 dsl_fs_ss_count_adjust(ds->ds_dir, 1, DD_FIELD_SNAPSHOT_COUNT, tx);
1762 dsphys->ds_dir_obj = ds->ds_dir->dd_object;
1766 dsphys->ds_prev_snap_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
1767 dsphys->ds_prev_snap_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
1768 dsphys->ds_next_snap_obj = ds->ds_object;
1772 dsphys->ds_deadlist_obj = dsl_dataset_phys(ds)->ds_deadlist_obj;
1773 dsphys->ds_referenced_bytes = dsl_dataset_phys(ds)->ds_referenced_bytes;
1774 dsphys->ds_compressed_bytes = dsl_dataset_phys(ds)->ds_compressed_bytes;
1776 dsl_dataset_phys(ds)->ds_uncompressed_bytes;
1777 dsphys->ds_flags = dsl_dataset_phys(ds)->ds_flags;
1778 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
1779 dsphys->ds_bp = dsl_dataset_phys(ds)->ds_bp;
1780 rrw_exit(&ds->ds_bp_rwlock, FTAG);
1784 if (zfeature_active(f, ds->ds_feature[f])) {
1786 ds->ds_feature[f], tx);
1790 ASSERT3U(ds->ds_prev != 0, ==,
1791 dsl_dataset_phys(ds)->ds_prev_snap_obj != 0);
1792 if (ds->ds_prev) {
1794 dsl_dataset_phys(ds->ds_prev)->ds_next_clones_obj;
1795 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1796 ds->ds_object ||
1797 dsl_dataset_phys(ds->ds_prev)->ds_num_children > 1);
1798 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1799 ds->ds_object) {
1800 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
1801 ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, ==,
1802 dsl_dataset_phys(ds->ds_prev)->ds_creation_txg);
1803 dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj = dsobj;
1805 dsl_dataset_remove_from_next_clones(ds->ds_prev,
1817 if (ds->ds_reserved) {
1819 ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
1820 delta = MIN(dsl_dataset_phys(ds)->ds_unique_bytes,
1821 ds->ds_reserved);
1822 dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV,
1826 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1827 dsl_dataset_phys(ds)->ds_deadlist_obj =
1828 dsl_deadlist_clone(&ds->ds_deadlist, UINT64_MAX,
1829 dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
1830 dsl_deadlist_close(&ds->ds_deadlist);
1831 VERIFY0(dsl_deadlist_open(&ds->ds_deadlist, mos,
1832 dsl_dataset_phys(ds)->ds_deadlist_obj));
1833 dsl_deadlist_add_key(&ds->ds_deadlist,
1834 dsl_dataset_phys(ds)->ds_prev_snap_txg, tx);
1835 dsl_bookmark_snapshotted(ds, tx);
1837 if (dsl_dataset_remap_deadlist_exists(ds)) {
1839 dsl_dataset_get_remap_deadlist_object(ds);
1845 dsl_dataset_unset_remap_deadlist_object(ds, tx);
1846 dsl_deadlist_close(&ds->ds_remap_deadlist);
1868 if (ds->ds_dir->dd_crypto_obj != 0 &&
1877 ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, <, tx->tx_txg);
1878 dsl_dataset_phys(ds)->ds_prev_snap_obj = dsobj;
1879 dsl_dataset_phys(ds)->ds_prev_snap_txg = crtxg;
1880 dsl_dataset_phys(ds)->ds_unique_bytes = 0;
1883 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1885 VERIFY0(zap_add(mos, dsl_dataset_phys(ds)->ds_snapnames_zapobj,
1888 if (ds->ds_prev)
1889 dsl_dataset_rele(ds->ds_prev, ds);
1891 dsl_dataset_phys(ds)->ds_prev_snap_obj, ds, &ds->ds_prev));
1893 dsl_scan_ds_snapshotted(ds, tx);
1895 dsl_dir_snap_cmtime_update(ds->ds_dir, tx);
1898 spa_history_log_internal_ds(ds->ds_prev, "snapshot", tx, " ");
1910 dsl_dataset_t *ds;
1917 VERIFY0(dsl_dataset_hold(dp, dsname, FTAG, &ds));
1919 dsl_dataset_snapshot_sync_impl(ds, atp + 1, tx);
1921 dsl_props_set_sync_impl(ds->ds_prev,
1924 dsl_dataset_rele(ds, FTAG);
2021 dsl_dataset_t *ds;
2024 error = dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds);
2029 error = dsl_dataset_snapshot_check_impl(ds, ddsta->ddsta_snapname,
2032 dsl_dataset_rele(ds, FTAG);
2037 dsl_dataset_rele(ds, FTAG);
2043 dsl_dataset_rele(ds, FTAG);
2047 dsl_dataset_rele(ds, FTAG);
2056 dsl_dataset_t *ds = NULL;
2058 VERIFY0(dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds));
2060 dsl_dataset_snapshot_sync_impl(ds, ddsta->ddsta_snapname, tx);
2061 dsl_dataset_user_hold_sync_one(ds->ds_prev, ddsta->ddsta_htag,
2063 dsl_destroy_snapshot_sync_impl(ds->ds_prev, B_TRUE, tx);
2065 dsl_dataset_rele(ds, FTAG);
2105 dsl_dataset_sync(dsl_dataset_t *ds, zio_t *rio, dmu_tx_t *tx)
2108 ASSERT(ds->ds_objset != NULL);
2109 ASSERT(dsl_dataset_phys(ds)->ds_next_snap_obj == 0);
2115 dmu_buf_will_dirty(ds->ds_dbuf, tx);
2116 dsl_dataset_phys(ds)->ds_fsid_guid = ds->ds_fsid_guid;
2118 if (ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] != 0) {
2120 ds->ds_object, DS_FIELD_RESUME_OBJECT, 8, 1,
2121 &ds->ds_resume_object[tx->tx_txg & TXG_MASK], tx));
2123 ds->ds_object, DS_FIELD_RESUME_OFFSET, 8, 1,
2124 &ds->ds_resume_offset[tx->tx_txg & TXG_MASK], tx));
2126 ds->ds_object, DS_FIELD_RESUME_BYTES, 8, 1,
2127 &ds->ds_resume_bytes[tx->tx_txg & TXG_MASK], tx));
2128 ds->ds_resume_object[tx->tx_txg & TXG_MASK] = 0;
2129 ds->ds_resume_offset[tx->tx_txg & TXG_MASK] = 0;
2130 ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] = 0;
2133 dmu_objset_sync(ds->ds_objset, rio, tx);
2142 dsl_livelist_should_disable(dsl_dataset_t *ds)
2147 used = dsl_dir_get_usedds(ds->ds_dir);
2148 referenced = dsl_get_referenced(ds);
2180 dsl_dataset_t *ds;
2192 dsl_dataset_t *ds = tca->ds;
2193 dsl_deadlist_t *ll = &ds->ds_dir->dd_livelist;
2201 if (spa->spa_to_condense.ds != NULL)
2222 dmu_buf_add_ref(ds->ds_dbuf, spa);
2224 spa->spa_to_condense.ds = ds;
2235 dsl_flush_pending_livelist(dsl_dataset_t *ds, dmu_tx_t *tx)
2237 dsl_dir_t *dd = ds->ds_dir;
2238 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
2273 .ds = ds
2280 dsl_dataset_sync_done(dsl_dataset_t *ds, dmu_tx_t *tx)
2282 objset_t *os = ds->ds_objset;
2284 bplist_iterate(&ds->ds_pending_deadlist,
2285 dsl_deadlist_insert_alloc_cb, &ds->ds_deadlist, tx);
2287 if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist)) {
2288 dsl_flush_pending_livelist(ds, tx);
2289 if (dsl_livelist_should_disable(ds)) {
2290 dsl_dir_remove_livelist(ds->ds_dir, tx, B_TRUE);
2294 dsl_bookmark_sync_done(ds, tx);
2305 ds->ds_feature_activation[f])) {
2306 if (zfeature_active(f, ds->ds_feature[f]))
2308 dsl_dataset_activate_feature(ds->ds_object, f,
2309 ds->ds_feature_activation[f], tx);
2310 ds->ds_feature[f] = ds->ds_feature_activation[f];
2318 get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val)
2321 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
2325 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
2332 if (dsl_dataset_phys(ds)->ds_next_clones_obj != 0) {
2333 VERIFY0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
2336 if (count != dsl_dataset_phys(ds)->ds_num_children - 1) {
2342 dsl_dataset_phys(ds)->ds_next_clones_obj);
2347 VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
2359 get_clones_stat(dsl_dataset_t *ds, nvlist_t *nv)
2364 if (get_clones_stat_impl(ds, val) == 0) {
2375 get_receive_resume_token_impl(dsl_dataset_t *ds)
2377 if (!dsl_dataset_has_resume_receive_state(ds))
2380 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2388 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2392 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2396 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2400 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2404 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2409 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
2413 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2417 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2421 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2425 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2429 if (dsl_dataset_feature_is_active(ds,
2433 VERIFY3B(dsl_dataset_get_uint64_array_feature(ds,
2439 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
2443 VERIFY0(zap_length(dp->dp_meta_objset, ds->ds_object,
2450 VERIFY0(zap_lookup(dp->dp_meta_objset, ds->ds_object,
2496 get_receive_resume_token(dsl_dataset_t *ds)
2502 char *token = get_receive_resume_token_impl(ds);
2513 dsl_dataset_name(ds, name);
2516 dsl_dataset_hold(ds->ds_dir->dd_pool, name, FTAG, &recv_ds) == 0) {
2524 dsl_get_refratio(dsl_dataset_t *ds)
2526 uint64_t ratio = dsl_dataset_phys(ds)->ds_compressed_bytes == 0 ? 100 :
2527 (dsl_dataset_phys(ds)->ds_uncompressed_bytes * 100 /
2528 dsl_dataset_phys(ds)->ds_compressed_bytes);
2533 dsl_get_logicalreferenced(dsl_dataset_t *ds)
2535 return (dsl_dataset_phys(ds)->ds_uncompressed_bytes);
2539 dsl_get_compressratio(dsl_dataset_t *ds)
2541 if (ds->ds_is_snapshot) {
2542 return (dsl_get_refratio(ds));
2544 dsl_dir_t *dd = ds->ds_dir;
2553 dsl_get_used(dsl_dataset_t *ds)
2555 if (ds->ds_is_snapshot) {
2556 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2558 dsl_dir_t *dd = ds->ds_dir;
2567 dsl_get_creation(dsl_dataset_t *ds)
2569 return (dsl_dataset_phys(ds)->ds_creation_time);
2573 dsl_get_creationtxg(dsl_dataset_t *ds)
2575 return (dsl_dataset_phys(ds)->ds_creation_txg);
2579 dsl_get_refquota(dsl_dataset_t *ds)
2581 return (ds->ds_quota);
2585 dsl_get_refreservation(dsl_dataset_t *ds)
2587 return (ds->ds_reserved);
2591 dsl_get_guid(dsl_dataset_t *ds)
2593 return (dsl_dataset_phys(ds)->ds_guid);
2597 dsl_get_unique(dsl_dataset_t *ds)
2599 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2603 dsl_get_objsetid(dsl_dataset_t *ds)
2605 return (ds->ds_object);
2609 dsl_get_userrefs(dsl_dataset_t *ds)
2611 return (ds->ds_userrefs);
2615 dsl_get_defer_destroy(dsl_dataset_t *ds)
2617 return (DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
2621 dsl_get_referenced(dsl_dataset_t *ds)
2623 return (dsl_dataset_phys(ds)->ds_referenced_bytes);
2627 dsl_get_numclones(dsl_dataset_t *ds)
2629 ASSERT(ds->ds_is_snapshot);
2630 return (dsl_dataset_phys(ds)->ds_num_children - 1);
2634 dsl_get_inconsistent(dsl_dataset_t *ds)
2636 return ((dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT) ?
2641 dsl_get_redacted(dsl_dataset_t *ds)
2643 return (dsl_dataset_feature_is_active(ds,
2648 dsl_get_available(dsl_dataset_t *ds)
2650 uint64_t refdbytes = dsl_get_referenced(ds);
2651 uint64_t availbytes = dsl_dir_space_available(ds->ds_dir,
2653 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
2655 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
2657 if (ds->ds_quota != 0) {
2661 if (refdbytes < ds->ds_quota) {
2663 ds->ds_quota - refdbytes);
2672 dsl_get_written(dsl_dataset_t *ds, uint64_t *written)
2674 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2677 dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
2680 err = dsl_dataset_space_written(prev, ds, written,
2691 dsl_get_prev_snap(dsl_dataset_t *ds, char *snap)
2693 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2694 if (ds->ds_prev != NULL && ds->ds_prev != dp->dp_origin_snap) {
2695 dsl_dataset_name(ds->ds_prev, snap);
2703 dsl_get_redact_snaps(dsl_dataset_t *ds, nvlist_t *propval)
2707 if (dsl_dataset_get_uint64_array_feature(ds,
2721 dsl_get_mountpoint(dsl_dataset_t *ds, const char *dsname, char *value,
2725 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2728 error = dsl_prop_get_ds(ds, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1,
2797 dsl_dataset_stats(dsl_dataset_t *ds, nvlist_t *nv)
2799 dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
2804 dsl_get_refratio(ds));
2806 dsl_get_logicalreferenced(ds));
2808 dsl_get_compressratio(ds));
2810 dsl_get_used(ds));
2812 if (ds->ds_is_snapshot) {
2813 get_clones_stat(ds, nv);
2816 if (dsl_get_prev_snap(ds, buf) == 0)
2819 dsl_dir_stats(ds->ds_dir, nv);
2823 dsl_get_redact_snaps(ds, propval);
2829 dsl_get_available(ds));
2831 dsl_get_referenced(ds));
2833 dsl_get_creation(ds));
2835 dsl_get_creationtxg(ds));
2837 dsl_get_refquota(ds));
2839 dsl_get_refreservation(ds));
2841 dsl_get_guid(ds));
2843 dsl_get_unique(ds));
2845 dsl_get_objsetid(ds));
2847 dsl_get_userrefs(ds));
2849 dsl_get_defer_destroy(ds));
2851 dsl_dir_snap_cmtime(ds->ds_dir).tv_sec);
2852 dsl_dataset_crypt_stats(ds, nv);
2854 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
2856 if (dsl_get_written(ds, &written) == 0) {
2862 if (!dsl_dataset_is_snapshot(ds)) {
2863 char *token = get_receive_resume_token(ds);
2873 dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat)
2875 dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
2878 stat->dds_creation_txg = dsl_get_creationtxg(ds);
2879 stat->dds_inconsistent = dsl_get_inconsistent(ds);
2880 stat->dds_guid = dsl_get_guid(ds);
2881 stat->dds_redacted = dsl_get_redacted(ds);
2883 if (ds->ds_is_snapshot) {
2885 stat->dds_num_clones = dsl_get_numclones(ds);
2890 if (dsl_dir_is_clone(ds->ds_dir)) {
2891 dsl_dir_get_origin(ds->ds_dir, stat->dds_origin);
2897 dsl_dataset_fsid_guid(dsl_dataset_t *ds)
2899 return (ds->ds_fsid_guid);
2903 dsl_dataset_space(dsl_dataset_t *ds,
2907 *refdbytesp = dsl_dataset_phys(ds)->ds_referenced_bytes;
2908 *availbytesp = dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE);
2909 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes)
2911 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
2912 if (ds->ds_quota != 0) {
2916 if (*refdbytesp < ds->ds_quota)
2918 ds->ds_quota - *refdbytesp);
2922 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2923 *usedobjsp = BP_GET_FILL(&dsl_dataset_phys(ds)->ds_bp);
2924 rrw_exit(&ds->ds_bp_rwlock, FTAG);
2929 dsl_dataset_modified_since_snap(dsl_dataset_t *ds, dsl_dataset_t *snap)
2931 dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
2937 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2938 birth = BP_GET_LOGICAL_BIRTH(dsl_dataset_get_blkptr(ds));
2939 rrw_exit(&ds->ds_bp_rwlock, FTAG);
2947 if (dmu_objset_from_ds(ds, &os) != 0)
3016 dsl_dataset_t *ds;
3029 VERIFY0(dsl_dataset_hold_obj(dp, val, FTAG, &ds));
3032 spa_history_log_internal_ds(ds, "rename", tx,
3037 mutex_enter(&ds->ds_lock);
3038 (void) strlcpy(ds->ds_snapname, ddrsa->ddrsa_newsnapname,
3039 sizeof (ds->ds_snapname));
3040 mutex_exit(&ds->ds_lock);
3043 ds->ds_snapname, 8, 1, &ds->ds_object, tx));
3053 dsl_dataset_rele(ds, FTAG);
3100 dsl_dataset_handoff_check(dsl_dataset_t *ds, void *owner, dmu_tx_t *tx)
3107 dsl_dir_t *dd = ds->ds_dir;
3109 uint64_t holds = zfs_refcount_count(&ds->ds_longholds) -
3134 dsl_dataset_t *ds;
3138 error = dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds);
3143 if (ds->ds_is_snapshot) {
3144 dsl_dataset_rele(ds, FTAG);
3149 if (dsl_dataset_phys(ds)->ds_prev_snap_txg < TXG_INITIAL) {
3150 dsl_dataset_rele(ds, FTAG);
3161 dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg) {
3162 dsl_dataset_rele(ds, FTAG);
3186 dsl_dataset_rele(ds, FTAG);
3192 if (snapds != ds->ds_prev) {
3198 if (snapds->ds_dir == ds->ds_dir ||
3199 (dsl_dir_is_clone(ds->ds_dir) &&
3200 dsl_dir_phys(ds->ds_dir)->dd_origin_obj ==
3207 dsl_dataset_rele(ds, FTAG);
3214 if (dsl_bookmark_latest_txg(ds) >
3215 dsl_dataset_phys(ds)->ds_prev_snap_txg) {
3216 dsl_dataset_rele(ds, FTAG);
3220 error = dsl_dataset_handoff_check(ds, ddra->ddra_owner, tx);
3222 dsl_dataset_rele(ds, FTAG);
3230 if (ds->ds_quota != 0 &&
3231 dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes > ds->ds_quota) {
3232 dsl_dataset_rele(ds, FTAG);
3243 unused_refres_delta = (int64_t)MIN(ds->ds_reserved,
3244 dsl_dataset_phys(ds)->ds_unique_bytes);
3248 dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE)) {
3249 dsl_dataset_rele(ds, FTAG);
3253 dsl_dataset_rele(ds, FTAG);
3262 dsl_dataset_t *ds, *clone;
3266 VERIFY0(dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds));
3268 dsl_dataset_name(ds->ds_prev, namebuf);
3271 cloneobj = dsl_dataset_create_sync(ds->ds_dir, "%rollback",
3272 ds->ds_prev, DS_CREATE_FLAG_NODIRTY, kcred, NULL, tx);
3276 dsl_dataset_clone_swap_sync_impl(clone, ds, tx);
3277 dsl_dataset_zero_zil(ds, tx);
3282 dsl_dataset_rele(ds, FTAG);
3316 dsl_dataset_t *ds;
3354 dsl_dataset_t *const origin_ds = snap->ds;
3378 ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
3380 dsl_deadlist_space_range(&snap->ds->ds_deadlist,
3407 dsl_dataset_t *ds = snap->ds;
3415 if (dsl_dataset_long_held(ds)) {
3421 VERIFY0(dsl_dataset_get_snapname(ds));
3422 if (strlen(ds->ds_snapname) >= max_snap_len) {
3426 err = dsl_dataset_snap_lookup(hds, ds->ds_snapname, &val);
3429 snap->ds->ds_snapname);
3436 if (dsl_dataset_phys(ds)->ds_prev_snap_obj == 0)
3439 dsl_deadlist_space(&ds->ds_deadlist,
3524 snap->ds->ds_dir->dd_origin_txg, &ddpa->cloneusedsnap);
3529 snap->ds->ds_dir->dd_origin_txg, &space);
3570 origin_ds = snap->ds;
3574 origin_head = snap->ds;
3589 ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
3591 dsl_dataset_phys(origin_ds)->ds_next_snap_obj = snap->ds->ds_object;
3596 snap->ds->ds_object, tx);
3654 dsl_dataset_t *ds = snap->ds;
3661 if (ds->ds_objset) {
3662 dmu_objset_evict(ds->ds_objset);
3663 ds->ds_objset = NULL;
3667 VERIFY0(dsl_dataset_get_snapname(ds));
3669 ds->ds_snapname, tx, B_TRUE));
3671 dsl_dataset_phys(hds)->ds_snapnames_zapobj, ds->ds_snapname,
3672 8, 1, &ds->ds_object, tx));
3677 dmu_buf_will_dirty(ds->ds_dbuf, tx);
3678 ASSERT3U(dsl_dataset_phys(ds)->ds_dir_obj, ==, odd->dd_object);
3679 dsl_dataset_phys(ds)->ds_dir_obj = dd->dd_object;
3680 ASSERT3P(ds->ds_dir, ==, odd);
3681 dsl_dir_rele(ds->ds_dir, ds);
3683 NULL, ds, &ds->ds_dir));
3686 if (dsl_dataset_phys(ds)->ds_next_clones_obj &&
3692 dsl_dataset_phys(ds)->ds_next_clones_obj);
3721 ASSERT(!dsl_prop_hascb(ds));
3793 dsl_dataset_t *ds;
3797 err = dsl_dataset_hold_obj(dp, obj, tag, &ds);
3803 first_obj = dsl_dir_phys(ds->ds_dir)->dd_origin_obj;
3806 snap->ds = ds;
3808 obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
3822 dsl_deadlist_space_range(&snap->ds->ds_deadlist,
3838 dsl_dataset_rele(snap->ds, tag);
3874 ASSERT3U(snap->ds->ds_object, ==, dsl_dir_phys(dd)->dd_origin_obj);
3876 dsl_dir_phys(snap->ds->ds_dir)->dd_head_dataset_obj,
3881 if (dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj != 0) {
3883 dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj,
4264 dsl_dataset_t *ds;
4271 error = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
4273 dsl_dataset_name(ds, buf);
4274 dsl_dataset_rele(ds, FTAG);
4282 dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
4295 mutex_enter(&ds->ds_lock);
4299 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
4301 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
4303 (ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
4305 asize - MIN(asize, parent_delta(ds, asize + inflight));
4308 if (!check_quota || ds->ds_quota == 0) {
4309 mutex_exit(&ds->ds_lock);
4318 if (dsl_dataset_phys(ds)->ds_referenced_bytes + inflight >=
4319 ds->ds_quota) {
4321 dsl_dataset_phys(ds)->ds_referenced_bytes < ds->ds_quota)
4326 mutex_exit(&ds->ds_lock);
4343 dsl_dataset_t *ds;
4350 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
4354 if (ds->ds_is_snapshot) {
4355 dsl_dataset_rele(ds, FTAG);
4359 error = dsl_prop_predict(ds->ds_dir,
4363 dsl_dataset_rele(ds, FTAG);
4368 dsl_dataset_rele(ds, FTAG);
4372 if (newval < dsl_dataset_phys(ds)->ds_referenced_bytes ||
4373 newval < ds->ds_reserved) {
4374 dsl_dataset_rele(ds, FTAG);
4378 dsl_dataset_rele(ds, FTAG);
4387 dsl_dataset_t *ds = NULL;
4390 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
4392 dsl_prop_set_sync_impl(ds,
4397 VERIFY0(dsl_prop_get_int_ds(ds,
4400 if (ds->ds_quota != newval) {
4401 dmu_buf_will_dirty(ds->ds_dbuf, tx);
4402 ds->ds_quota = newval;
4404 dsl_dataset_rele(ds, FTAG);
4427 dsl_dataset_t *ds;
4434 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
4438 if (ds->ds_is_snapshot) {
4439 dsl_dataset_rele(ds, FTAG);
4443 error = dsl_prop_predict(ds->ds_dir,
4447 dsl_dataset_rele(ds, FTAG);
4456 dsl_dataset_rele(ds, FTAG);
4460 mutex_enter(&ds->ds_lock);
4461 if (!DS_UNIQUE_IS_ACCURATE(ds))
4462 dsl_dataset_recalc_head_uniq(ds);
4463 unique = dsl_dataset_phys(ds)->ds_unique_bytes;
4464 mutex_exit(&ds->ds_lock);
4466 if (MAX(unique, newval) > MAX(unique, ds->ds_reserved)) {
4468 MAX(unique, ds->ds_reserved);
4471 dsl_dir_space_available(ds->ds_dir, NULL, 0, B_TRUE) ||
4472 (ds->ds_quota > 0 && newval > ds->ds_quota)) {
4473 dsl_dataset_rele(ds, FTAG);
4478 dsl_dataset_rele(ds, FTAG);
4483 dsl_dataset_set_refreservation_sync_impl(dsl_dataset_t *ds,
4490 dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
4493 VERIFY0(dsl_prop_get_int_ds(ds,
4496 dmu_buf_will_dirty(ds->ds_dbuf, tx);
4497 mutex_enter(&ds->ds_dir->dd_lock);
4498 mutex_enter(&ds->ds_lock);
4499 ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
4500 unique = dsl_dataset_phys(ds)->ds_unique_bytes;
4502 MAX(0, (int64_t)(ds->ds_reserved - unique));
4503 ds->ds_reserved = newval;
4504 mutex_exit(&ds->ds_lock);
4506 dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV, delta, 0, 0, tx);
4507 mutex_exit(&ds->ds_dir->dd_lock);
4515 dsl_dataset_t *ds = NULL;
4517 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
4518 dsl_dataset_set_refreservation_sync_impl(ds,
4520 dsl_dataset_rele(ds, FTAG);
4567 dsl_dataset_t *ds = NULL;
4574 VERIFY0(dsl_dataset_hold(dp, ddsca->ddsca_name, FTAG, &ds));
4575 if (zfeature_active(f, ds->ds_feature[f]) != B_TRUE) {
4576 ds->ds_feature_activation[f] = (void *)B_TRUE;
4577 dsl_dataset_activate_feature(ds->ds_object, f,
4578 ds->ds_feature_activation[f], tx);
4579 ds->ds_feature[f] = ds->ds_feature_activation[f];
4581 dsl_dataset_rele(ds, FTAG);
4786 dsl_dataset_t *ds;
4789 err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &ds);
4793 dsl_deadlist_space_range(&ds->ds_deadlist,
4800 snapobj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
4802 dsl_dataset_rele(ds, FTAG);
4862 dsl_dataset_zapify(dsl_dataset_t *ds, dmu_tx_t *tx)
4864 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
4865 dmu_object_zapify(mos, ds->ds_object, DMU_OT_DSL_DATASET, tx);
4869 dsl_dataset_is_zapified(dsl_dataset_t *ds)
4873 dmu_object_info_from_db(ds->ds_dbuf, &doi);
4878 dsl_dataset_has_resume_receive_state(dsl_dataset_t *ds)
4880 return (dsl_dataset_is_zapified(ds) &&
4881 zap_contains(ds->ds_dir->dd_pool->dp_meta_objset,
4882 ds->ds_object, DS_FIELD_RESUME_TOGUID) == 0);
4886 dsl_dataset_get_remap_deadlist_object(dsl_dataset_t *ds)
4891 if (!dsl_dataset_is_zapified(ds))
4894 err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
4908 dsl_dataset_remap_deadlist_exists(dsl_dataset_t *ds)
4910 EQUIV(dsl_deadlist_is_open(&ds->ds_remap_deadlist),
4911 dsl_dataset_get_remap_deadlist_object(ds) != 0);
4912 return (dsl_deadlist_is_open(&ds->ds_remap_deadlist));
4916 dsl_dataset_set_remap_deadlist_object(dsl_dataset_t *ds, uint64_t obj,
4920 dsl_dataset_zapify(ds, tx);
4921 VERIFY0(zap_add(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
4926 dsl_dataset_unset_remap_deadlist_object(dsl_dataset_t *ds, dmu_tx_t *tx)
4928 VERIFY0(zap_remove(ds->ds_dir->dd_pool->dp_meta_objset,
4929 ds->ds_object, DS_FIELD_REMAP_DEADLIST, tx));
4933 dsl_dataset_destroy_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx)
4936 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
4939 ASSERT(dsl_dataset_remap_deadlist_exists(ds));
4941 remap_deadlist_object = ds->ds_remap_deadlist.dl_object;
4942 dsl_deadlist_close(&ds->ds_remap_deadlist);
4944 dsl_dataset_unset_remap_deadlist_object(ds, tx);
4949 dsl_dataset_create_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx)
4952 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
4955 ASSERT(MUTEX_HELD(&ds->ds_remap_deadlist_lock));
4963 &ds->ds_deadlist, UINT64_MAX,
4964 dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
4965 dsl_dataset_set_remap_deadlist_object(ds,
4967 VERIFY0(dsl_deadlist_open(&ds->ds_remap_deadlist, spa_meta_objset(spa),
4973 dsl_dataset_activate_redaction(dsl_dataset_t *ds, uint64_t *redact_snaps,
4976 uint64_t dsobj = ds->ds_object;
4988 ds->ds_feature[SPA_FEATURE_REDACTED_DATASETS] = ftuaa;
4999 dsl_dataset_t *ds;
5002 int error = dsl_dataset_hold_obj(dp, head_ds, FTAG, &ds);
5006 uint64_t prev_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
5007 uint64_t prev_obj_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
5010 dsl_dataset_rele(ds, FTAG);
5012 FTAG, &ds)) != 0)
5014 prev_obj_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
5015 prev_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
5017 *oldest_dsobj = ds->ds_object;
5018 dsl_dataset_rele(ds, FTAG);