Lines Matching +full:os +full:- +full:manifest +full:- +full:offset
9 * or https://opensource.org/licenses/CDDL-1.0.
125 if (ds->ds_reserved == 0)
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);
132 ASSERT3U(ABS((int64_t)(new_bytes - old_bytes)), <=, ABS(delta));
133 return (new_bytes - old_bytes);
139 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
155 dsl_pool_mos_diduse_space(tx->tx_pool,
161 dsl_dataset_phys(ds)->ds_prev_snap_txg);
162 dmu_buf_will_dirty(ds->ds_dbuf, tx);
163 mutex_enter(&ds->ds_lock);
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;
223 ASSERT(birth <= tx->tx_txg);
224 ASSERT(!ds->ds_is_snapshot);
226 if (birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
227 spa_vdev_indirect_mark_obsolete(spa, vdev, offset, size, tx);
234 mutex_enter(&ds->ds_remap_deadlist_lock);
238 mutex_exit(&ds->ds_remap_deadlist_lock);
243 DVA_SET_OFFSET(dva, offset);
245 dsl_deadlist_insert(&ds->ds_remap_deadlist, &fakebp, B_FALSE,
254 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
264 ASSERT(BP_GET_LOGICAL_BIRTH(bp) <= tx->tx_txg);
267 dsl_free(tx->tx_pool, tx->tx_txg, bp);
268 dsl_pool_mos_diduse_space(tx->tx_pool,
269 -used, -compressed, -uncompressed);
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) {
297 * are very heavy and can lead to out-of-memory conditions if
306 bpobj_enqueue(&ds->ds_dir->dd_pool->dp_free_bpobj,
310 (u_longlong_t)ds->ds_object);
311 dsl_free(tx->tx_pool, tx->tx_txg, bp);
314 mutex_enter(&ds->ds_lock);
315 ASSERT(dsl_dataset_phys(ds)->ds_unique_bytes >= used ||
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,
322 delta, -compressed, -uncompressed, -used,
326 dsl_dir_diduse_space(tx->tx_pool->dp_free_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,
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);
387 struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
388 kmem_free(ftuaa->array, ftuaa->length * sizeof (uint64_t));
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,
429 ftuaa->length = num_int;
430 ftuaa->array = data;
431 ds->ds_feature[f] = ftuaa;
443 * failure would manifest itself as the fsid of this dataset changing
451 ASSERT(ds->ds_owner == NULL);
453 unique_remove(ds->ds_fsid_guid);
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;
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));
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);
507 dsl_pool_t *dp = ds->ds_dir->dd_pool;
508 objset_t *mos = dp->dp_meta_objset;
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,
519 headphys = headdbuf->db_data;
520 err = zap_value_search(dp->dp_meta_objset,
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),
526 "SNAPOBJ=%llu-ERR=%d",
527 (unsigned long long)ds->ds_object, err);
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)
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,
579 dmu_buf_t *dbuf = ds->ds_dbuf;
582 if (dbuf != NULL && dmu_buf_try_add_ref(dbuf, dp->dp_meta_objset,
583 ds->ds_object, DMU_BONUS_BLKID, tag)) {
598 objset_t *mos = dp->dp_meta_objset;
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);
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),
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);
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) {
687 &ds->ds_reserved);
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 &&
700 dp->dp_spa->spa_errata =
705 err = dsl_deadlist_open(&ds->ds_deadlist,
706 mos, dsl_dataset_phys(ds)->ds_deadlist_obj);
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);
729 if (ds->ds_prev)
730 dsl_dataset_rele(ds->ds_prev, ds);
731 dsl_dir_rele(ds->ds_dir, ds);
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);
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,
762 spa_name(dp->dp_spa),
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 ||
771 spa_version(dp->dp_spa) < SPA_VERSION_ORIGIN ||
772 dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
781 dsl_dir_t *dd = ds->ds_dir;
783 if (dd->dd_crypto_obj == 0)
786 return (spa_keystore_create_mapping(dd->dd_pool->dp_spa,
787 ds, ds, &ds->ds_key_mapping));
826 obj = dsl_dir_phys(dd)->dd_head_dataset_obj;
851 mutex_enter(&snap_ds->ds_lock);
852 if (snap_ds->ds_snapname[0] == 0)
853 (void) strlcpy(snap_ds->ds_snapname, snapname,
854 sizeof (snap_ds->ds_snapname));
855 mutex_exit(&snap_ds->ds_lock);
942 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
943 (void) zfs_refcount_add(&ds->ds_longholds, tag);
949 (void) zfs_refcount_remove(&ds->ds_longholds, tag);
956 return (!zfs_refcount_is_zero(&ds->ds_longholds));
965 dsl_dir_name(ds->ds_dir, name);
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,
993 mutex_enter(&ds->ds_lock);
994 int len = strlen(ds->ds_snapname);
995 mutex_exit(&ds->ds_lock);
999 len += dsl_dir_namelen(ds->ds_dir);
1006 dmu_buf_rele(ds->ds_dbuf, tag);
1012 dsl_dir_t *dd = ds->ds_dir;
1014 if (dd == NULL || dd->dd_crypto_obj == 0)
1017 (void) spa_keystore_remove_mapping(dd->dd_pool->dp_spa,
1018 ds->ds_object, ds);
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);
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) ||
1055 ds->ds_owner = tag;
1059 mutex_exit(&ds->ds_lock);
1067 mutex_enter(&ds->ds_lock);
1068 rv = (ds->ds_owner != NULL);
1069 mutex_exit(&ds->ds_lock);
1085 * if the array is non-null.
1097 return (zfeature_active(f, ds->ds_feature[f]));
1113 struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
1114 *outp = ftuaa->array;
1115 *outlength = ftuaa->length;
1123 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
1124 objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
1142 sizeof (uint64_t), ftuaa->length, ftuaa->array, tx));
1154 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
1155 objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
1156 uint64_t dsobj = ds->ds_object;
1162 ds->ds_feature[f] = NULL;
1176 dsl_pool_t *dp = dd->dd_pool;
1180 objset_t *mos = dp->dp_meta_objset;
1183 origin = dp->dp_origin_snap;
1185 ASSERT(origin == NULL || origin->ds_dir->dd_pool == dp);
1186 ASSERT(origin == NULL || dsl_dataset_phys(origin)->ds_num_children > 0);
1188 ASSERT(dsl_dir_phys(dd)->dd_head_dataset_obj == 0);
1194 dsphys = dbuf->db_data;
1196 dsphys->ds_dir_obj = dd->dd_object;
1197 dsphys->ds_flags = flags;
1198 dsphys->ds_fsid_guid = unique_create();
1199 (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
1200 sizeof (dsphys->ds_guid));
1201 dsphys->ds_snapnames_zapobj =
1204 dsphys->ds_creation_time = gethrestime_sec();
1205 dsphys->ds_creation_txg = tx->tx_txg == TXG_INITIAL ? 1 : tx->tx_txg;
1208 dsphys->ds_deadlist_obj = dsl_deadlist_alloc(mos, tx);
1212 dsphys->ds_prev_snap_obj = origin->ds_object;
1213 dsphys->ds_prev_snap_txg =
1214 dsl_dataset_phys(origin)->ds_creation_txg;
1215 dsphys->ds_referenced_bytes =
1216 dsl_dataset_phys(origin)->ds_referenced_bytes;
1217 dsphys->ds_compressed_bytes =
1218 dsl_dataset_phys(origin)->ds_compressed_bytes;
1219 dsphys->ds_uncompressed_bytes =
1220 dsl_dataset_phys(origin)->ds_uncompressed_bytes;
1221 rrw_enter(&origin->ds_bp_rwlock, RW_READER, FTAG);
1222 dsphys->ds_bp = dsl_dataset_phys(origin)->ds_bp;
1223 rrw_exit(&origin->ds_bp_rwlock, FTAG);
1229 dsphys->ds_flags |= dsl_dataset_phys(origin)->ds_flags &
1233 if (zfeature_active(f, origin->ds_feature[f])) {
1235 origin->ds_feature[f], tx);
1239 dmu_buf_will_dirty(origin->ds_dbuf, tx);
1240 dsl_dataset_phys(origin)->ds_num_children++;
1243 dsl_dir_phys(origin->ds_dir)->dd_head_dataset_obj,
1245 dsphys->ds_deadlist_obj = dsl_deadlist_clone(&ohds->ds_deadlist,
1246 dsphys->ds_prev_snap_txg, dsphys->ds_prev_snap_obj, tx);
1249 if (spa_version(dp->dp_spa) >= SPA_VERSION_NEXT_CLONES) {
1250 if (dsl_dataset_phys(origin)->ds_next_clones_obj == 0) {
1251 dsl_dataset_phys(origin)->ds_next_clones_obj =
1256 dsl_dataset_phys(origin)->ds_next_clones_obj,
1260 dmu_buf_will_dirty(dd->dd_dbuf, tx);
1261 dsl_dir_phys(dd)->dd_origin_obj = origin->ds_object;
1262 if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
1263 if (dsl_dir_phys(origin->ds_dir)->dd_clones == 0) {
1264 dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
1265 dsl_dir_phys(origin->ds_dir)->dd_clones =
1270 dsl_dir_phys(origin->ds_dir)->dd_clones,
1278 if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
1279 dsphys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1283 dmu_buf_will_dirty(dd->dd_dbuf, tx);
1284 dsl_dir_phys(dd)->dd_head_dataset_obj = dsobj;
1292 objset_t *os;
1294 VERIFY0(dmu_objset_from_ds(ds, &os));
1295 if (memcmp(&os->os_zil_header, &zero_zil, sizeof (zero_zil)) != 0) {
1296 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1299 memset(&os->os_zil_header, 0, sizeof (os->os_zil_header));
1300 if (os->os_encrypted)
1301 os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_TRUE;
1303 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
1315 dsl_pool_t *dp = pdd->dd_pool;
1328 ASSERT3P(origin, !=, dp->dp_origin_snap);
1343 spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LIVELIST)) {
1344 objset_t *mos = dd->dd_pool->dp_meta_objset;
1347 VERIFY0(zap_add(mos, dd->dd_object, DD_FIELD_LIVELIST,
1349 spa_feature_incr(dp->dp_spa, SPA_FEATURE_LIVELIST, tx);
1356 if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_FS_SS_LIMIT)) {
1358 objset_t *os = dd->dd_pool->dp_meta_objset;
1361 VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_FILESYSTEM_COUNT,
1363 VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_SNAPSHOT_COUNT,
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;
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);
1448 return (&dsl_dataset_phys(ds)->ds_bp);
1454 return (ds->ds_dir->dd_pool->dp_spa);
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 &&
1482 !os->os_raw_receive &&
1483 !os->os_next_write_raw[tx->tx_txg & TXG_MASK]) {
1484 ASSERT3P(ds->ds_key_mapping, !=, NULL);
1485 key_mapping_add_ref(ds->ds_key_mapping, ds);
1499 * If there's an fs-only reservation, any blocks that might become
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);
1525 ds->ds_trysnap_txg = tx->tx_txg;
1534 if (dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg)
1564 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1586 * Pre-compute how many total new snapshots will be created for each
1619 for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1621 pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1664 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1666 ddsa->ddsa_cr, ddsa->ddsa_proc);
1671 if (ddsa->ddsa_errors != NULL)
1672 fnvlist_add_int32(ddsa->ddsa_errors,
1682 for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1683 pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1697 (void) strlcpy(dsname, name, atp - name + 1);
1709 if (ddsa->ddsa_errors != NULL) {
1710 fnvlist_add_int32(ddsa->ddsa_errors,
1724 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1728 objset_t *mos = dp->dp_meta_objset;
1729 objset_t *os __maybe_unused;
1731 ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
1737 ASSERT(spa_version(dmu_tx_pool(tx)->dp_spa) >= SPA_VERSION_FAST_SNAP ||
1738 dmu_objset_from_ds(ds, &os) != 0 ||
1739 memcmp(&os->os_phys->os_zil_header, &zero_zil,
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);
1754 crtxg = tx->tx_txg;
1760 dsphys = dbuf->db_data;
1762 dsphys->ds_dir_obj = ds->ds_dir->dd_object;
1763 dsphys->ds_fsid_guid = unique_create();
1764 (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
1765 sizeof (dsphys->ds_guid));
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;
1769 dsphys->ds_num_children = 1;
1770 dsphys->ds_creation_time = gethrestime_sec();
1771 dsphys->ds_creation_txg = crtxg;
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;
1775 dsphys->ds_uncompressed_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,
1806 dsphys->ds_next_snap_obj, tx);
1813 * If we have a reference-reservation on this dataset, we will
1817 if (ds->ds_reserved) {
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);
1846 dsl_deadlist_close(&ds->ds_remap_deadlist);
1857 * field as part of the on-disk format for ZFS encryption
1868 if (ds->ds_dir->dd_crypto_obj != 0 &&
1869 spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2)) {
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;
1882 if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
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));
1895 dsl_dir_snap_cmtime_update(ds->ds_dir, tx);
1898 spa_history_log_internal_ds(ds->ds_prev, "snapshot", tx, " ");
1908 for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1909 pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1916 (void) strlcpy(dsname, name, atp - name + 1);
1920 if (ddsa->ddsa_props != NULL) {
1921 dsl_props_set_sync_impl(ds->ds_prev,
1922 ZPROP_SRC_LOCAL, ddsa->ddsa_props, tx);
1930 * All-or-nothing: if there are any failures, nothing will be modified.
1968 (void) strlcpy(fsname, snapname, atp - snapname + 1);
2024 error = dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds);
2029 error = dsl_dataset_snapshot_check_impl(ds, ddsta->ddsta_snapname,
2036 if (spa_version(dp->dp_spa) < SPA_VERSION_USERREFS) {
2040 error = dsl_dataset_user_hold_check_one(NULL, ddsta->ddsta_htag,
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,
2062 ddsta->ddsta_cleanup_minor, gethrestime_sec(), tx);
2063 dsl_destroy_snapshot_sync_impl(ds->ds_prev, B_TRUE, 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) {
2119 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
2120 ds->ds_object, DS_FIELD_RESUME_OBJECT, 8, 1,
2121 &ds->ds_resume_object[tx->tx_txg & TXG_MASK], tx));
2122 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
2123 ds->ds_object, DS_FIELD_RESUME_OFFSET, 8, 1,
2124 &ds->ds_resume_offset[tx->tx_txg & TXG_MASK], tx));
2125 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
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);
2147 used = dsl_dir_get_usedds(ds->ds_dir);
2151 percent_shared = (100 * (referenced - used)) / referenced;
2169 uint64_t total_free = first->dle_bpobj.bpo_phys->bpo_num_freed +
2170 next->dle_bpobj.bpo_phys->bpo_num_freed;
2171 uint64_t total_entries = first->dle_bpobj.bpo_phys->bpo_num_blkptrs +
2172 next->dle_bpobj.bpo_phys->bpo_num_blkptrs;
2173 if ((total_entries - (2 * total_free)) < zfs_livelist_max_entries)
2191 spa_t *spa = tca->spa;
2192 dsl_dataset_t *ds = tca->ds;
2193 dsl_deadlist_t *ll = &ds->ds_dir->dd_livelist;
2197 if (spa->spa_livelist_condense_zthr == NULL)
2201 if (spa->spa_to_condense.ds != NULL)
2204 next = AVL_NEXT(&ll->dl_tree, &first->dle_node);
2205 /* The livelist has only one entry - don't condense it */
2209 /* Next is the newest entry - don't condense it */
2210 if (AVL_NEXT(&ll->dl_tree, &next->dle_node) == NULL)
2222 dmu_buf_add_ref(ds->ds_dbuf, spa);
2224 spa->spa_to_condense.ds = ds;
2225 spa->spa_to_condense.first = first;
2226 spa->spa_to_condense.next = next;
2227 spa->spa_to_condense.syncing = B_FALSE;
2228 spa->spa_to_condense.cancelled = B_FALSE;
2230 zthr_wakeup(spa->spa_livelist_condense_zthr);
2237 dsl_dir_t *dd = ds->ds_dir;
2238 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
2239 dsl_deadlist_entry_t *last = dsl_deadlist_last(&dd->dd_livelist);
2241 /* Check if we need to add a new sub-livelist */
2244 dsl_deadlist_add_key(&dd->dd_livelist,
2245 tx->tx_txg - 1, tx);
2254 bpobj_t bpobj = last->dle_bpobj;
2255 uint64_t all = bpobj.bpo_phys->bpo_num_blkptrs;
2256 uint64_t free = bpobj.bpo_phys->bpo_num_freed;
2257 uint64_t alloc = all - free;
2259 dsl_deadlist_add_key(&dd->dd_livelist,
2260 tx->tx_txg - 1, tx);
2264 /* Insert each entry into the on-disk livelist */
2265 bplist_iterate(&dd->dd_pending_allocs,
2266 dsl_deadlist_insert_alloc_cb, &dd->dd_livelist, tx);
2267 bplist_iterate(&dd->dd_pending_frees,
2268 dsl_deadlist_insert_free_cb, &dd->dd_livelist, tx);
2275 dsl_deadlist_iterate(&dd->dd_livelist, dsl_livelist_try_condense,
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)) {
2290 dsl_dir_remove_livelist(ds->ds_dir, tx, B_TRUE);
2296 multilist_destroy(&os->os_synced_dnodes);
2298 if (os->os_encrypted)
2299 os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_FALSE;
2301 ASSERT0(os->os_next_write_raw[tx->tx_txg & TXG_MASK]);
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];
2314 ASSERT(!dmu_objset_is_dirty(os, dmu_tx_get_txg(tx)));
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,
2348 za->za_first_integer, FTAG, &clone));
2349 dsl_dir_name(clone->ds_dir, buf);
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,
2398 fnvlist_add_uint64(token_nv, "offset", val);
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,
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,
2476 size_t offset = i * 2;
2477 (void) snprintf(str + offset, alloc_size - offset,
2481 char *propval = kmem_asprintf("%u-%llx-%llx-%s",
2516 dsl_dataset_hold(ds->ds_dir->dd_pool, name, FTAG, &recv_ds) == 0) {
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);
2535 return (dsl_dataset_phys(ds)->ds_uncompressed_bytes);
2541 if (ds->ds_is_snapshot) {
2544 dsl_dir_t *dd = ds->ds_dir;
2545 mutex_enter(&dd->dd_lock);
2547 mutex_exit(&dd->dd_lock);
2555 if (ds->ds_is_snapshot) {
2556 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2558 dsl_dir_t *dd = ds->ds_dir;
2559 mutex_enter(&dd->dd_lock);
2561 mutex_exit(&dd->dd_lock);
2569 return (dsl_dataset_phys(ds)->ds_creation_time);
2575 return (dsl_dataset_phys(ds)->ds_creation_txg);
2581 return (ds->ds_quota);
2587 return (ds->ds_reserved);
2593 return (dsl_dataset_phys(ds)->ds_guid);
2599 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2605 return (ds->ds_object);
2611 return (ds->ds_userrefs);
2623 return (dsl_dataset_phys(ds)->ds_referenced_bytes);
2629 ASSERT(ds->ds_is_snapshot);
2630 return (dsl_dataset_phys(ds)->ds_num_children - 1);
2636 return ((dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT) ?
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);
2674 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2677 dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
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);
2725 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2759 spa_altroot(dp->dp_spa, root, ZAP_MAXVALUELEN);
2799 dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
2812 if (ds->ds_is_snapshot) {
2819 dsl_dir_stats(ds->ds_dir, nv);
2851 dsl_dir_snap_cmtime(ds->ds_dir).tv_sec);
2854 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
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);
2882 stat->dds_origin[0] = '\0';
2883 if (ds->ds_is_snapshot) {
2884 stat->dds_is_snapshot = B_TRUE;
2885 stat->dds_num_clones = dsl_get_numclones(ds);
2887 stat->dds_is_snapshot = B_FALSE;
2888 stat->dds_num_clones = 0;
2890 if (dsl_dir_is_clone(ds->ds_dir)) {
2891 dsl_dir_get_origin(ds->ds_dir, stat->dds_origin);
2899 return (ds->ds_fsid_guid);
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);
2925 *availobjsp = DN_MAX_OBJECT - *usedobjsp;
2931 dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
2937 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2939 rrw_exit(&ds->ds_bp_rwlock, FTAG);
2940 if (birth > dsl_dataset_phys(snap)->ds_creation_txg) {
2941 objset_t *os, *os_snap;
2947 if (dmu_objset_from_ds(ds, &os) != 0)
2951 return (memcmp(&os->os_phys->os_meta_dnode,
2952 &os_snap->os_phys->os_meta_dnode,
2953 sizeof (os->os_phys->os_meta_dnode)) != 0);
2967 error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
2974 error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_newsnapname, &val);
2981 if (dsl_dir_namelen(hds->ds_dir) + 1 +
2982 strlen(ddrsa->ddrsa_newsnapname) >= ZFS_MAX_DATASET_NAME_LEN)
2996 error = dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds);
3000 if (ddrsa->ddrsa_recursive) {
3001 error = dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
3018 dmu_tx_t *tx = ddrsa->ddrsa_tx;
3022 error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
3033 "-> @%s", ddrsa->ddrsa_newsnapname);
3035 VERIFY0(dsl_dataset_snap_remove(hds, ddrsa->ddrsa_oldsnapname, 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);
3041 VERIFY0(zap_add(dp->dp_meta_objset,
3042 dsl_dataset_phys(hds)->ds_snapnames_zapobj,
3043 ds->ds_snapname, 8, 1, &ds->ds_object, tx));
3045 oldname = kmem_asprintf("%s@%s", ddrsa->ddrsa_fsname,
3046 ddrsa->ddrsa_oldsnapname);
3047 newname = kmem_asprintf("%s@%s", ddrsa->ddrsa_fsname,
3048 ddrsa->ddrsa_newsnapname);
3049 zvol_rename_minors(dp->dp_spa, oldname, newname, B_TRUE);
3064 VERIFY0(dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds));
3065 ddrsa->ddrsa_tx = tx;
3066 if (ddrsa->ddrsa_recursive) {
3067 VERIFY0(dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
3107 dsl_dir_t *dd = ds->ds_dir;
3108 mutex_enter(&dd->dd_activity_lock);
3109 uint64_t holds = zfs_refcount_count(&ds->ds_longholds) -
3116 * non-waiters have long-holds, and all new long-holds will be
3119 if (holds != dd->dd_activity_waiters)
3121 mutex_exit(&dd->dd_activity_lock);
3138 error = dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds);
3143 if (ds->ds_is_snapshot) {
3149 if (dsl_dataset_phys(ds)->ds_prev_snap_txg < TXG_INITIAL) {
3161 dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg) {
3170 if (ddra->ddra_tosnap != NULL) {
3174 error = dsl_dataset_hold(dp, ddra->ddra_tosnap, FTAG, &snapds);
3189 ASSERT(snapds->ds_is_snapshot);
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 ==
3201 snapds->ds_object)) {
3215 dsl_dataset_phys(ds)->ds_prev_snap_txg) {
3220 error = dsl_dataset_handoff_check(ds, ddra->ddra_owner, tx);
3230 if (ds->ds_quota != 0 &&
3231 dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes > ds->ds_quota) {
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)) {
3266 VERIFY0(dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds));
3268 dsl_dataset_name(ds->ds_prev, namebuf);
3269 fnvlist_add_string(ddra->ddra_result, "target", namebuf);
3271 cloneobj = dsl_dataset_create_sync(ds->ds_dir, "%rollback",
3272 ds->ds_prev, DS_CREATE_FLAG_NODIRTY, kcred, NULL, tx);
3291 * - The existing dataset MUST be owned by the specified owner at entry
3292 * - Upon return, dataset will still be held by the same owner, whether we
3341 hds = ddpa->ddpa_clone;
3342 max_snap_len = MAXNAMELEN - strlen(ddpa->ddpa_clonename) - 1;
3344 if (dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE) {
3349 snap = list_head(&ddpa->shared_snaps);
3354 dsl_dataset_t *const origin_ds = snap->ds;
3362 err = dsl_dataset_promote_crypt_check(hds->ds_dir, origin_ds->ds_dir);
3376 snap = list_tail(&ddpa->clone_snaps);
3378 ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
3379 origin_ds->ds_object);
3380 dsl_deadlist_space_range(&snap->ds->ds_deadlist,
3381 dsl_dataset_phys(origin_ds)->ds_prev_snap_txg, UINT64_MAX,
3382 &ddpa->unique, &unused, &unused);
3389 * (my used) = (prev's used) + (blocks born) - (blocks killed)
3391 * (blocks born) = (my used) - (prev's used) + (blocks killed)
3393 * (uN - u(N-1) + kN) + ... + (u1 - u0 + k1) + (u0 - 0 + k0)
3395 * uN + kN + kN-1 + ... + k1 + k0
3397 * uN + kN + kN-1 + ... + kM - uM-1
3401 ddpa->used = dsl_dataset_phys(origin_ds)->ds_referenced_bytes;
3402 ddpa->comp = dsl_dataset_phys(origin_ds)->ds_compressed_bytes;
3403 ddpa->uncomp = dsl_dataset_phys(origin_ds)->ds_uncompressed_bytes;
3404 for (snap = list_head(&ddpa->shared_snaps); snap;
3405 snap = list_next(&ddpa->shared_snaps, snap)) {
3407 dsl_dataset_t *ds = snap->ds;
3422 if (strlen(ds->ds_snapname) >= max_snap_len) {
3426 err = dsl_dataset_snap_lookup(hds, ds->ds_snapname, &val);
3428 fnvlist_add_boolean(ddpa->err_ds,
3429 snap->ds->ds_snapname);
3436 if (dsl_dataset_phys(ds)->ds_prev_snap_obj == 0)
3439 dsl_deadlist_space(&ds->ds_deadlist,
3441 ddpa->used += dlused;
3442 ddpa->comp += dlcomp;
3443 ddpa->uncomp += dluncomp;
3450 for (dsl_bookmark_node_t *dbn = avl_first(&origin_ds->ds_bookmarks);
3451 dbn != NULL && dbn->dbn_phys.zbm_creation_txg <=
3452 dsl_dataset_phys(origin_ds)->ds_creation_txg;
3453 dbn = AVL_NEXT(&origin_ds->ds_bookmarks, dbn)) {
3454 if (strlen(dbn->dbn_name) >= max_snap_len) {
3459 err = dsl_bookmark_lookup_impl(ddpa->ddpa_clone,
3460 dbn->dbn_name, &bm);
3463 fnvlist_add_boolean(ddpa->err_ds, dbn->dbn_name);
3486 if (ddpa->origin_origin) {
3487 ddpa->used -=
3488 dsl_dataset_phys(ddpa->origin_origin)->ds_referenced_bytes;
3489 ddpa->comp -=
3490 dsl_dataset_phys(ddpa->origin_origin)->ds_compressed_bytes;
3491 ddpa->uncomp -=
3492 dsl_dataset_phys(ddpa->origin_origin)->
3497 err = dsl_dir_transfer_possible(origin_ds->ds_dir, hds->ds_dir,
3498 0, ss_mv_cnt, ddpa->used, ddpa->cr, ddpa->proc);
3508 if (dsl_dir_phys(hds->ds_dir)->dd_flags & DD_FLAG_USED_BREAKDOWN) {
3514 * these snaplist_space() -> dsl_deadlist_space_range()
3518 snap = list_head(&ddpa->origin_snaps);
3523 err = snaplist_space(&ddpa->shared_snaps,
3524 snap->ds->ds_dir->dd_origin_txg, &ddpa->cloneusedsnap);
3528 err = snaplist_space(&ddpa->clone_snaps,
3529 snap->ds->ds_dir->dd_origin_txg, &space);
3532 ddpa->cloneusedsnap += space;
3534 if (dsl_dir_phys(origin_ds->ds_dir)->dd_flags &
3536 err = snaplist_space(&ddpa->origin_snaps,
3537 dsl_dataset_phys(origin_ds)->ds_creation_txg,
3538 &ddpa->originusedsnap);
3562 ASSERT(nvlist_empty(ddpa->err_ds));
3565 hds = ddpa->ddpa_clone;
3567 ASSERT0(dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE);
3569 snap = list_head(&ddpa->shared_snaps);
3570 origin_ds = snap->ds;
3571 dd = hds->ds_dir;
3573 snap = list_head(&ddpa->origin_snaps);
3574 origin_head = snap->ds;
3580 VERIFY0(dsl_dir_hold_obj(dp, origin_ds->ds_dir->dd_object,
3583 dsl_dataset_promote_crypt_sync(hds->ds_dir, odd, tx);
3586 dmu_buf_will_dirty(origin_ds->ds_dbuf, tx);
3587 oldnext_obj = dsl_dataset_phys(origin_ds)->ds_next_snap_obj;
3588 snap = list_tail(&ddpa->clone_snaps);
3589 ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
3590 origin_ds->ds_object);
3591 dsl_dataset_phys(origin_ds)->ds_next_snap_obj = snap->ds->ds_object;
3594 if (dsl_dataset_phys(origin_ds)->ds_next_clones_obj) {
3596 snap->ds->ds_object, tx);
3597 VERIFY0(zap_add_int(dp->dp_meta_objset,
3598 dsl_dataset_phys(origin_ds)->ds_next_clones_obj,
3603 dmu_buf_will_dirty(dd->dd_dbuf, tx);
3604 ASSERT3U(dsl_dir_phys(dd)->dd_origin_obj, ==, origin_ds->ds_object);
3605 dsl_dir_phys(dd)->dd_origin_obj = dsl_dir_phys(odd)->dd_origin_obj;
3606 dd->dd_origin_txg = origin_head->ds_dir->dd_origin_txg;
3607 dmu_buf_will_dirty(odd->dd_dbuf, tx);
3608 dsl_dir_phys(odd)->dd_origin_obj = origin_ds->ds_object;
3609 origin_head->ds_dir->dd_origin_txg =
3610 dsl_dataset_phys(origin_ds)->ds_creation_txg;
3613 if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
3614 VERIFY0(zap_remove_int(dp->dp_meta_objset,
3615 dsl_dir_phys(odd)->dd_clones, hds->ds_object, tx));
3616 VERIFY0(zap_add_int(dp->dp_meta_objset,
3617 dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
3618 hds->ds_object, tx));
3620 VERIFY0(zap_remove_int(dp->dp_meta_objset,
3621 dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
3622 origin_head->ds_object, tx));
3623 if (dsl_dir_phys(dd)->dd_clones == 0) {
3624 dsl_dir_phys(dd)->dd_clones =
3625 zap_create(dp->dp_meta_objset, DMU_OT_DSL_CLONES,
3628 VERIFY0(zap_add_int(dp->dp_meta_objset,
3629 dsl_dir_phys(dd)->dd_clones, origin_head->ds_object, tx));
3636 for (dsl_bookmark_node_t *dbn = avl_first(&origin_head->ds_bookmarks);
3637 dbn != NULL && dbn->dbn_phys.zbm_creation_txg <=
3638 dsl_dataset_phys(origin_ds)->ds_creation_txg;
3640 dbn_next = AVL_NEXT(&origin_head->ds_bookmarks, dbn);
3642 avl_remove(&origin_head->ds_bookmarks, dbn);
3643 VERIFY0(zap_remove(dp->dp_meta_objset,
3644 origin_head->ds_bookmarks_obj, dbn->dbn_name, tx));
3652 for (snap = list_head(&ddpa->shared_snaps); snap;
3653 snap = list_next(&ddpa->shared_snaps, snap)) {
3654 dsl_dataset_t *ds = snap->ds;
3661 if (ds->ds_objset) {
3662 dmu_objset_evict(ds->ds_objset);
3663 ds->ds_objset = NULL;
3669 ds->ds_snapname, tx, B_TRUE));
3670 VERIFY0(zap_add(dp->dp_meta_objset,
3671 dsl_dataset_phys(hds)->ds_snapnames_zapobj, ds->ds_snapname,
3672 8, 1, &ds->ds_object, tx));
3673 dsl_fs_ss_count_adjust(hds->ds_dir, 1,
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);
3682 VERIFY0(dsl_dir_hold_obj(dp, dd->dd_object,
3683 NULL, ds, &ds->ds_dir));
3686 if (dsl_dataset_phys(ds)->ds_next_clones_obj &&
3687 spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
3691 for (zap_cursor_init(&zc, dp->dp_meta_objset,
3692 dsl_dataset_phys(ds)->ds_next_clones_obj);
3698 if (za->za_first_integer == oldnext_obj) {
3707 za->za_first_integer, FTAG, &cnds));
3708 o = dsl_dir_phys(cnds->ds_dir)->
3711 VERIFY0(zap_remove_int(dp->dp_meta_objset,
3712 dsl_dir_phys(odd)->dd_clones, o, tx));
3713 VERIFY0(zap_add_int(dp->dp_meta_objset,
3714 dsl_dir_phys(dd)->dd_clones, o, tx));
3726 * Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either
3731 delta = ddpa->cloneusedsnap -
3732 dsl_dir_phys(dd)->dd_used_breakdown[DD_USED_SNAP];
3734 ASSERT3U(ddpa->used, >=, delta);
3737 ddpa->used - delta, ddpa->comp, ddpa->uncomp, tx);
3739 delta = ddpa->originusedsnap -
3740 dsl_dir_phys(odd)->dd_used_breakdown[DD_USED_SNAP];
3742 ASSERT3U(ddpa->used, >=, -delta);
3745 -ddpa->used - delta, -ddpa->comp, -ddpa->uncomp, tx);
3747 dsl_dataset_phys(origin_ds)->ds_unique_bytes = ddpa->unique;
3768 if (spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_HEAD_ERRLOG)) {
3769 uint64_t old_head = origin_head->ds_object;
3770 uint64_t new_head = hds->ds_object;
3771 spa_swap_errlog(dp->dp_spa, new_head, old_head, tx);
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,
3834 if (l == NULL || !list_link_active(&l->list_head))
3838 dsl_dataset_rele(snap->ds, tag);
3851 error = dsl_dataset_hold(dp, ddpa->ddpa_clonename, tag,
3852 &ddpa->ddpa_clone);
3855 dd = ddpa->ddpa_clone->ds_dir;
3857 if (ddpa->ddpa_clone->ds_is_snapshot ||
3859 dsl_dataset_rele(ddpa->ddpa_clone, tag);
3863 error = snaplist_make(dp, 0, dsl_dir_phys(dd)->dd_origin_obj,
3864 &ddpa->shared_snaps, tag);
3868 error = snaplist_make(dp, 0, ddpa->ddpa_clone->ds_object,
3869 &ddpa->clone_snaps, tag);
3873 snap = list_head(&ddpa->shared_snaps);
3874 ASSERT3U(snap->ds->ds_object, ==, dsl_dir_phys(dd)->dd_origin_obj);
3875 error = snaplist_make(dp, dsl_dir_phys(dd)->dd_origin_obj,
3876 dsl_dir_phys(snap->ds->ds_dir)->dd_head_dataset_obj,
3877 &ddpa->origin_snaps, tag);
3881 if (dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj != 0) {
3883 dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj,
3884 tag, &ddpa->origin_origin);
3897 snaplist_destroy(&ddpa->shared_snaps, tag);
3898 snaplist_destroy(&ddpa->clone_snaps, tag);
3899 snaplist_destroy(&ddpa->origin_snaps, tag);
3900 if (ddpa->origin_origin != NULL)
3901 dsl_dataset_rele(ddpa->origin_origin, tag);
3902 dsl_dataset_rele(ddpa->ddpa_clone, tag);
3918 objset_t *os;
3924 error = dmu_objset_hold(name, FTAG, &os);
3927 error = zap_count(dmu_objset_pool(os)->dp_meta_objset,
3928 dsl_dataset_phys(dmu_objset_ds(os))->ds_snapnames_zapobj,
3930 dmu_objset_rele(os, FTAG);
3968 if (clone->ds_is_snapshot ||
3969 origin_head->ds_is_snapshot)
3973 if (!force && clone->ds_prev != origin_head->ds_prev)
3977 if (clone->ds_prev != NULL &&
3978 clone->ds_prev != clone->ds_dir->dd_pool->dp_origin_snap &&
3979 origin_head->ds_dir != clone->ds_prev->ds_dir)
3983 if (clone->ds_dir->dd_parent != origin_head->ds_dir)
3988 dsl_dataset_modified_since_snap(origin_head, origin_head->ds_prev))
3997 (int64_t)MIN(origin_head->ds_reserved,
3998 dsl_dataset_phys(origin_head)->ds_unique_bytes) -
3999 (int64_t)MIN(origin_head->ds_reserved,
4000 dsl_dataset_phys(clone)->ds_unique_bytes);
4004 dsl_dir_space_available(origin_head->ds_dir, NULL, 0, TRUE))
4020 if (origin_head->ds_quota != 0 &&
4021 dsl_dataset_phys(clone)->ds_referenced_bytes >
4022 origin_head->ds_quota + refquota_slack)
4041 dsl_deadlist_close(&clone->ds_remap_deadlist);
4045 dsl_deadlist_close(&origin->ds_remap_deadlist);
4052 VERIFY0(dsl_deadlist_open(&origin->ds_remap_deadlist,
4053 dp->dp_meta_objset, clone_remap_dl_obj));
4058 VERIFY0(dsl_deadlist_open(&clone->ds_remap_deadlist,
4059 dp->dp_meta_objset, origin_remap_dl_obj));
4070 ASSERT(clone->ds_reserved == 0);
4075 ASSERT(origin_head->ds_quota == 0 ||
4076 dsl_dataset_phys(clone)->ds_unique_bytes <= origin_head->ds_quota +
4078 ASSERT3P(clone->ds_prev, ==, origin_head->ds_prev);
4080 dsl_dir_cancel_waiters(origin_head->ds_dir);
4083 * Swap per-dataset feature flags.
4094 void *clone_feature = clone->ds_feature[f];
4097 void *origin_head_feature = origin_head->ds_feature[f];
4105 dsl_dataset_activate_feature(origin_head->ds_object, f,
4107 origin_head->ds_feature[f] = clone_feature;
4110 dsl_dataset_activate_feature(clone->ds_object, f,
4112 clone->ds_feature[f] = origin_head_feature;
4116 dmu_buf_will_dirty(clone->ds_dbuf, tx);
4117 dmu_buf_will_dirty(origin_head->ds_dbuf, tx);
4119 if (clone->ds_objset != NULL) {
4120 dmu_objset_evict(clone->ds_objset);
4121 clone->ds_objset = NULL;
4124 if (origin_head->ds_objset != NULL) {
4125 dmu_objset_evict(origin_head->ds_objset);
4126 origin_head->ds_objset = NULL;
4130 (int64_t)MIN(origin_head->ds_reserved,
4131 dsl_dataset_phys(origin_head)->ds_unique_bytes) -
4132 (int64_t)MIN(origin_head->ds_reserved,
4133 dsl_dataset_phys(clone)->ds_unique_bytes);
4139 dsl_dataset_t *origin = clone->ds_prev;
4142 dmu_buf_will_dirty(origin->ds_dbuf, tx);
4143 dsl_deadlist_space_range(&clone->ds_deadlist,
4144 dsl_dataset_phys(origin)->ds_prev_snap_txg, UINT64_MAX,
4145 &dsl_dataset_phys(origin)->ds_unique_bytes, &comp, &uncomp);
4150 rrw_enter(&clone->ds_bp_rwlock, RW_WRITER, FTAG);
4151 rrw_enter(&origin_head->ds_bp_rwlock, RW_WRITER, FTAG);
4153 tmp = dsl_dataset_phys(origin_head)->ds_bp;
4154 dsl_dataset_phys(origin_head)->ds_bp =
4155 dsl_dataset_phys(clone)->ds_bp;
4156 dsl_dataset_phys(clone)->ds_bp = tmp;
4157 rrw_exit(&origin_head->ds_bp_rwlock, FTAG);
4158 rrw_exit(&clone->ds_bp_rwlock, FTAG);
4167 ASSERT3U(dsl_dir_phys(clone->ds_dir)->
4170 dsl_deadlist_space(&clone->ds_deadlist,
4172 dsl_deadlist_space(&origin_head->ds_deadlist,
4175 dused = dsl_dataset_phys(clone)->ds_referenced_bytes +
4176 cdl_used -
4177 (dsl_dataset_phys(origin_head)->ds_referenced_bytes +
4179 dcomp = dsl_dataset_phys(clone)->ds_compressed_bytes +
4180 cdl_comp -
4181 (dsl_dataset_phys(origin_head)->ds_compressed_bytes +
4183 duncomp = dsl_dataset_phys(clone)->ds_uncompressed_bytes +
4184 cdl_uncomp -
4185 (dsl_dataset_phys(origin_head)->ds_uncompressed_bytes +
4188 dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_HEAD,
4190 dsl_dir_diduse_space(clone->ds_dir, DD_USED_HEAD,
4191 -dused, -dcomp, -duncomp, tx);
4199 dsl_deadlist_space_range(&clone->ds_deadlist,
4200 origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
4202 dsl_deadlist_space_range(&origin_head->ds_deadlist,
4203 origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
4205 dsl_dir_transfer_space(origin_head->ds_dir, cdl_used - odl_used,
4210 SWITCH64(dsl_dataset_phys(origin_head)->ds_referenced_bytes,
4211 dsl_dataset_phys(clone)->ds_referenced_bytes);
4212 SWITCH64(dsl_dataset_phys(origin_head)->ds_compressed_bytes,
4213 dsl_dataset_phys(clone)->ds_compressed_bytes);
4214 SWITCH64(dsl_dataset_phys(origin_head)->ds_uncompressed_bytes,
4215 dsl_dataset_phys(clone)->ds_uncompressed_bytes);
4216 SWITCH64(dsl_dataset_phys(origin_head)->ds_unique_bytes,
4217 dsl_dataset_phys(clone)->ds_unique_bytes);
4220 dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_REFRSRV,
4226 dsl_deadlist_close(&clone->ds_deadlist);
4227 dsl_deadlist_close(&origin_head->ds_deadlist);
4228 SWITCH64(dsl_dataset_phys(origin_head)->ds_deadlist_obj,
4229 dsl_dataset_phys(clone)->ds_deadlist_obj);
4230 VERIFY0(dsl_deadlist_open(&clone->ds_deadlist, dp->dp_meta_objset,
4231 dsl_dataset_phys(clone)->ds_deadlist_obj));
4232 VERIFY0(dsl_deadlist_open(&origin_head->ds_deadlist, dp->dp_meta_objset,
4233 dsl_dataset_phys(origin_head)->ds_deadlist_obj));
4240 dsl_bookmark_next_changed(origin_head, origin_head->ds_prev, tx);
4249 dsl_dir_remove_livelist(clone->ds_dir, tx, B_TRUE);
4250 dsl_dir_remove_livelist(origin_head->ds_dir, tx, B_TRUE);
4253 "parent=%s", origin_head->ds_dir->dd_myname);
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);
4302 *used -=
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);
4315 * on-disk is over quota and there are no pending changes (which
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);
4347 if (spa_version(dp->dp_spa) < SPA_VERSION_REFQUOTA)
4350 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
4354 if (ds->ds_is_snapshot) {
4359 error = dsl_prop_predict(ds->ds_dir,
4361 ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
4372 if (newval < dsl_dataset_phys(ds)->ds_referenced_bytes ||
4373 newval < ds->ds_reserved) {
4390 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
4394 ddsqra->ddsqra_source, sizeof (ddsqra->ddsqra_value), 1,
4395 &ddsqra->ddsqra_value, tx);
4400 if (ds->ds_quota != newval) {
4401 dmu_buf_will_dirty(ds->ds_dbuf, tx);
4402 ds->ds_quota = newval;
4431 if (spa_version(dp->dp_spa) < SPA_VERSION_REFRESERVATION)
4434 error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
4438 if (ds->ds_is_snapshot) {
4443 error = dsl_prop_predict(ds->ds_dir,
4445 ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
4460 mutex_enter(&ds->ds_lock);
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)) {
4467 uint64_t delta = MAX(unique, newval) -
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)) {
4496 dmu_buf_will_dirty(ds->ds_dbuf, tx);
4497 mutex_enter(&ds->ds_dir->dd_lock);
4498 mutex_enter(&ds->ds_lock);
4500 unique = dsl_dataset_phys(ds)->ds_unique_bytes;
4501 delta = MAX(0, (int64_t)(newval - unique)) -
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);
4517 VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
4519 ddsqra->ddsqra_source, ddsqra->ddsqra_value, tx);
4550 uint64_t compval = ZIO_COMPRESS_ALGO(ddsca->ddsca_value);
4556 if (!spa_feature_is_enabled(dp->dp_spa, f))
4569 uint64_t compval = ZIO_COMPRESS_ALGO(ddsca->ddsca_value);
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];
4610 * new's filesystem (or its origin) -- caller verifies this.
4620 * space freed [---------------------]
4621 * snapshots ---O-------O--------O-------O------
4633 dsl_pool_t *dp = new->ds_dir->dd_pool;
4637 ASSERT3U(bmp->zbm_creation_txg, <,
4638 dsl_dataset_phys(new)->ds_creation_txg);
4642 *usedp += dsl_dataset_phys(new)->ds_referenced_bytes;
4643 *usedp -= bmp->zbm_referenced_bytes_refd;
4646 *compp += dsl_dataset_phys(new)->ds_compressed_bytes;
4647 *compp -= bmp->zbm_compressed_bytes_refd;
4650 *uncompp += dsl_dataset_phys(new)->ds_uncompressed_bytes;
4651 *uncompp -= bmp->zbm_uncompressed_bytes_refd;
4655 while (dsl_dataset_phys(snap)->ds_prev_snap_txg >
4656 bmp->zbm_creation_txg) {
4659 dsl_deadlist_space_range(&snap->ds_deadlist,
4660 0, bmp->zbm_creation_txg,
4666 uint64_t snapobj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
4679 if (bmp->zbm_flags & ZBM_FLAG_HAS_FBN) {
4680 *usedp += bmp->zbm_referenced_freed_before_next_snap;
4681 *compp += bmp->zbm_compressed_freed_before_next_snap;
4682 *uncompp += bmp->zbm_uncompressed_freed_before_next_snap;
4684 ASSERT3U(dsl_dataset_phys(snap)->ds_prev_snap_txg, ==,
4685 bmp->zbm_creation_txg);
4687 dsl_deadlist_space(&snap->ds_deadlist, &used, &comp, &uncomp);
4701 * new's filesystem (or its origin) -- caller verifies this.
4707 if (!(bmp->zbm_flags & ZBM_FLAG_HAS_FBN))
4728 zbm.zbm_guid = dsp->ds_guid;
4729 zbm.zbm_creation_txg = dsp->ds_creation_txg;
4730 zbm.zbm_creation_time = dsp->ds_creation_time;
4731 zbm.zbm_referenced_bytes_refd = dsp->ds_referenced_bytes;
4732 zbm.zbm_compressed_bytes_refd = dsp->ds_compressed_bytes;
4733 zbm.zbm_uncompressed_bytes_refd = dsp->ds_uncompressed_bytes;
4750 * blocks that would be freed [---------------------------]
4751 * snapshots ---O-------O--------O-------O--------O
4755 * (birth > firstsnap->prev_snap_txg) and died before the snap after the
4756 * last snap (ie, is on lastsnap->ds_next->ds_deadlist or an earlier deadlist).
4768 dsl_pool_t *dp = firstsnap->ds_dir->dd_pool;
4770 ASSERT(firstsnap->ds_is_snapshot);
4771 ASSERT(lastsnap->ds_is_snapshot);
4777 if (firstsnap->ds_dir != lastsnap->ds_dir ||
4778 dsl_dataset_phys(firstsnap)->ds_creation_txg >
4779 dsl_dataset_phys(lastsnap)->ds_creation_txg)
4784 snapobj = dsl_dataset_phys(lastsnap)->ds_next_snap_obj;
4785 while (snapobj != firstsnap->ds_object) {
4793 dsl_deadlist_space_range(&ds->ds_deadlist,
4794 dsl_dataset_phys(firstsnap)->ds_prev_snap_txg, UINT64_MAX,
4800 snapobj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
4814 * If non-zero, earlier_txg is used instead of earlier's ds_creation_txg.
4820 dsl_pool_t *dp = later->ds_dir->dd_pool;
4825 ASSERT(earlier->ds_is_snapshot || earlier_txg != 0);
4828 earlier_txg = dsl_dataset_phys(earlier)->ds_creation_txg;
4830 if (later->ds_is_snapshot &&
4831 earlier_txg >= dsl_dataset_phys(later)->ds_creation_txg)
4834 if (later->ds_dir == earlier->ds_dir)
4843 if (dsl_dir_phys(later->ds_dir)->dd_origin_obj == 0)
4848 dsl_dir_phys(later->ds_dir)->dd_origin_obj, FTAG, &origin);
4851 if (dsl_dataset_phys(origin)->ds_creation_txg == earlier_txg &&
4852 origin->ds_dir == earlier->ds_dir) {
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);
4873 dmu_object_info_from_db(ds->ds_dbuf, &doi);
4881 zap_contains(ds->ds_dir->dd_pool->dp_meta_objset,
4882 ds->ds_object, DS_FIELD_RESUME_TOGUID) == 0);
4894 err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
4910 EQUIV(dsl_deadlist_is_open(&ds->ds_remap_deadlist),
4912 return (dsl_deadlist_is_open(&ds->ds_remap_deadlist));
4921 VERIFY0(zap_add(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
4928 VERIFY0(zap_remove(ds->ds_dir->dd_pool->dp_meta_objset,
4929 ds->ds_object, DS_FIELD_REMAP_DEADLIST, tx));
4936 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
4941 remap_deadlist_object = ds->ds_remap_deadlist.dl_object;
4942 dsl_deadlist_close(&ds->ds_remap_deadlist);
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);
4967 VERIFY0(dsl_deadlist_open(&ds->ds_remap_deadlist, spa_meta_objset(spa),
4976 uint64_t dsobj = ds->ds_object;
4979 ftuaa->length = (int64_t)num_redact_snaps;
4981 ftuaa->array = kmem_alloc(num_redact_snaps * sizeof (uint64_t),
4983 memcpy(ftuaa->array, redact_snaps, num_redact_snaps *
4988 ds->ds_feature[SPA_FEATURE_REDACTED_DATASETS] = ftuaa;
5000 dsl_pool_t *dp = spa->spa_dsl_pool;
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;
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;