Lines Matching +full:dsp +full:- +full:based
41 dsl_dataset_t **dsp, const void *tag, char **shortnamep)
55 (void) strlcpy(buf, fullname, hashp - fullname + 1);
56 return (dsl_dataset_hold(dp, buf, tag, dsp));
71 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
72 uint64_t bmark_zapobj = ds->ds_bookmarks_obj;
79 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
96 * If later_ds is non-NULL, this will return EXDEV if the specified bookmark
117 if (!dsl_dataset_is_before(later_ds, ds, bmp->zbm_creation_txg))
126 * - bmark is a full dataset path of a bookmark (bookmark_namecheck)
127 * - source is a full path of a snapshot or bookmark
130 * Returns 0 if valid, -1 otherwise.
136 return (-1);
142 return (-1);
149 * { newbookmark -> source, ... }
151 * - each pair passes dsl_bookmark_create_nvl_validate_pair
152 * - all newbookmarks are in the same pool
153 * - all newbookmarks have unique names
159 * Returns -1 if it doesn't.
175 return (-1);
177 return (-1);
183 return (-1);
185 first_len = cp - bmark;
188 return (-1);
194 return (-1);
201 return (-1);
242 /* error is retval of the following if-cascade */
248 VERIFY(source_snap_ds->ds_is_snapshot);
296 ASSERT3P(dbca->dbca_bmarks, !=, NULL);
297 /* dbca->dbca_errors is allowed to be NULL */
301 if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARKS))
304 if (dsl_bookmark_create_nvl_validate(dbca->dbca_bmarks) != 0)
307 for (nvpair_t *pair = nvlist_next_nvpair(dbca->dbca_bmarks, NULL);
308 pair != NULL; pair = nvlist_next_nvpair(dbca->dbca_bmarks, pair)) {
321 if (dbca->dbca_errors != NULL)
322 fnvlist_add_int32(dbca->dbca_errors,
334 dbn->dbn_name = spa_strdup(shortname);
335 dbn->dbn_dirty = B_FALSE;
336 mutex_init(&dbn->dbn_lock, NULL, MUTEX_DEFAULT, NULL);
341 * Set the fields in the zfs_bookmark_phys_t based on the specified snapshot.
347 objset_t *mos = spa_get_dsl(spa)->dp_meta_objset;
348 dsl_dataset_phys_t *dsp = dsl_dataset_phys(snap);
351 zbm->zbm_guid = dsp->ds_guid;
352 zbm->zbm_creation_txg = dsp->ds_creation_txg;
353 zbm->zbm_creation_time = dsp->ds_creation_time;
354 zbm->zbm_redaction_obj = 0;
363 if (snap->ds_dir->dd_crypto_obj != 0 &&
365 (void) zap_lookup(mos, snap->ds_object,
367 &zbm->zbm_ivset_guid);
371 zbm->zbm_flags = ZBM_FLAG_SNAPSHOT_EXISTS | ZBM_FLAG_HAS_FBN;
372 zbm->zbm_referenced_bytes_refd = dsp->ds_referenced_bytes;
373 zbm->zbm_compressed_bytes_refd = dsp->ds_compressed_bytes;
374 zbm->zbm_uncompressed_bytes_refd = dsp->ds_uncompressed_bytes;
377 VERIFY0(dsl_dataset_hold_obj(snap->ds_dir->dd_pool,
378 dsp->ds_next_snap_obj, FTAG, &nextds));
379 dsl_deadlist_space(&nextds->ds_deadlist,
380 &zbm->zbm_referenced_freed_before_next_snap,
381 &zbm->zbm_compressed_freed_before_next_snap,
382 &zbm->zbm_uncompressed_freed_before_next_snap);
396 objset_t *mos = dp->dp_meta_objset;
398 if (hds->ds_bookmarks_obj == 0) {
399 hds->ds_bookmarks_obj = zap_create_norm(mos,
402 spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARKS, tx);
405 VERIFY0(zap_add(mos, hds->ds_object,
407 sizeof (hds->ds_bookmarks_obj), 1,
408 &hds->ds_bookmarks_obj, tx));
411 avl_add(&hds->ds_bookmarks, dbn);
419 if (spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2) &&
420 (dbn->dbn_phys.zbm_ivset_guid != 0 || dbn->dbn_phys.zbm_flags &
421 ZBM_FLAG_HAS_FBN || dbn->dbn_phys.zbm_redaction_obj != 0)) {
423 spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2, tx);
427 ASSERT0(memcmp(((char *)&dbn->dbn_phys) + bookmark_phys_size,
428 &zero_phys, sizeof (zfs_bookmark_phys_t) - bookmark_phys_size));
430 VERIFY0(zap_add(mos, hds->ds_bookmarks_obj, dbn->dbn_name,
432 &dbn->dbn_phys, tx));
436 * If redaction_list is non-null, we create a redacted bookmark and redaction
445 objset_t *mos = dp->dp_meta_objset;
457 dsl_bookmark_set_phys(&dbn->dbn_phys, snapds);
472 dbn->dbn_phys.zbm_redaction_obj = dmu_object_alloc(mos,
475 spa_feature_incr(dp->dp_spa,
478 spa_feature_incr(dp->dp_spa,
483 dbn->dbn_phys.zbm_redaction_obj, tag, &local_rl));
487 ASSERT3U(local_rl->rl_bonus->db_size, >=, bonuslen);
488 dmu_buf_will_dirty(local_rl->rl_bonus, tx);
491 VERIFY0(dmu_spill_hold_by_bonus(local_rl->rl_bonus,
496 local_rl->rl_phys = db->db_data;
497 local_rl->rl_dbuf = db;
499 memcpy(local_rl->rl_phys->rlp_snaps, redact_snaps,
501 local_rl->rl_phys->rlp_num_snaps = num_redact_snaps;
504 local_rl->rl_phys->rlp_last_blkid = UINT64_MAX;
505 local_rl->rl_phys->rlp_last_object = UINT64_MAX;
513 if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
514 spa_feature_incr(dp->dp_spa,
522 shortname, (longlong_t)dbn->dbn_phys.zbm_creation_txg,
523 (longlong_t)snapds->ds_object,
524 (longlong_t)dbn->dbn_phys.zbm_redaction_obj);
549 * -----------------------------------------------------------------
551 * - The zbm_redaction_obj would be referred to by both source and new
553 * destroyed, resulting in use-after-free of the referred object.
554 * - User expectation when issuing the `zfs bookmark` command is that
558 * - reference-count the redaction object => would require on-disk
560 * - Copy the redaction object => cannot be done in syncing context
568 memcpy(&new_dbn->dbn_phys, &source_phys, sizeof (source_phys));
569 new_dbn->dbn_phys.zbm_redaction_obj = 0;
572 if (new_dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
573 spa_feature_incr(dp->dp_spa,
577 /* dsl_bookmark_node_add bumps bookmarks and v2-bookmarks counter */
583 * v1 bookmark, the v2-only fields are zeroed.
584 * And dsl_bookmark_node_add writes back a v1-sized bookmark if
585 * v2 bookmarks are disabled and/or v2-only fields are zeroed.
586 * => bookmark copying works on pre-bookmark-v2 pools
592 new_shortname, (longlong_t)new_dbn->dbn_phys.zbm_creation_txg,
604 ASSERT(spa_feature_is_enabled(dmu_tx_pool(tx)->dp_spa,
607 for (nvpair_t *pair = nvlist_next_nvpair(dbca->dbca_bmarks, NULL);
608 pair != NULL; pair = nvlist_next_nvpair(dbca->dbca_bmarks, pair)) {
653 if (!spa_feature_is_enabled(dp->dp_spa,
661 uint64_t snaplimit = ((spa_feature_is_enabled(dp->dp_spa,
662 SPA_FEATURE_REDACTION_LIST_SPILL) ? spa_maxblocksize(dp->dp_spa) :
663 dmu_bonus_max()) -
665 if (dbcra->dbcra_numsnaps > snaplimit)
669 dbcra->dbcra_bmark, dbcra->dbcra_snap) != 0)
673 dbcra->dbcra_bmark, dbcra->dbcra_snap);
681 dsl_bookmark_create_sync_impl_snap(dbcra->dbcra_bmark,
682 dbcra->dbcra_snap, tx, dbcra->dbcra_numsnaps, dbcra->dbcra_snaps,
683 dbcra->dbcra_tag, dbcra->dbcra_rl);
716 ASSERT(RRW_LOCK_HELD(&dp->dp_config_rwlock));
721 ZFS_PROP_GUID, bmark_phys->zbm_guid);
726 ZFS_PROP_CREATETXG, bmark_phys->zbm_creation_txg);
731 ZFS_PROP_CREATION, bmark_phys->zbm_creation_time);
736 ZFS_PROP_IVSET_GUID, bmark_phys->zbm_ivset_guid);
738 if (bmark_phys->zbm_flags & ZBM_FLAG_HAS_FBN) {
743 bmark_phys->zbm_referenced_bytes_refd);
749 bmark_phys->zbm_uncompressed_bytes_refd);
754 bmark_phys->zbm_compressed_bytes_refd == 0 ? 100 :
755 bmark_phys->zbm_uncompressed_bytes_refd * 100 /
756 bmark_phys->zbm_compressed_bytes_refd;
764 bmark_phys->zbm_redaction_obj != 0) {
767 bmark_phys->zbm_redaction_obj, FTAG, &rl);
773 rl->rl_phys->rlp_snaps,
774 rl->rl_phys->rlp_num_snaps);
783 rl->rl_phys->rlp_last_blkid == UINT64_MAX &&
784 rl->rl_phys->rlp_last_object == UINT64_MAX);
797 dsl_pool_t *dp = ds->ds_dir->dd_pool;
804 for (dsl_bookmark_node_t *dbn = avl_first(&ds->ds_bookmarks);
805 dbn != NULL; dbn = AVL_NEXT(&ds->ds_bookmarks, dbn)) {
808 dsl_bookmark_fetch_props(dp, &dbn->dbn_phys, props, out_props);
810 fnvlist_add_nvlist(outnvl, dbn->dbn_name, out_props);
818 * their TXG, then by their FBN-ness. The "FBN-ness" component ensures
821 * multiple bookmarks at the same TXG (with the same FBN-ness). In this
831 int64_t cmp = TREE_CMP(ldbn->dbn_phys.zbm_creation_txg,
832 rdbn->dbn_phys.zbm_creation_txg);
835 cmp = TREE_CMP((ldbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN),
836 (rdbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN));
839 cmp = strcmp(ldbn->dbn_name, rdbn->dbn_name);
849 dsl_pool_t *dp = ds->ds_dir->dd_pool;
850 objset_t *mos = dp->dp_meta_objset;
852 ASSERT(!ds->ds_is_snapshot);
854 avl_create(&ds->ds_bookmarks, dsl_bookmark_compare,
861 int zaperr = zap_lookup(mos, ds->ds_object, DS_FIELD_BOOKMARK_NAMES,
862 sizeof (ds->ds_bookmarks_obj), 1, &ds->ds_bookmarks_obj);
868 if (ds->ds_bookmarks_obj == 0)
876 for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
880 dsl_bookmark_node_alloc(attr->za_name);
883 dbn->dbn_name, &dbn->dbn_phys);
889 avl_add(&ds->ds_bookmarks, dbn);
904 if (ds->ds_is_snapshot)
907 while ((dbn = avl_destroy_nodes(&ds->ds_bookmarks, &cookie)) != NULL) {
908 spa_strfree(dbn->dbn_name);
909 mutex_destroy(&dbn->dbn_lock);
912 avl_destroy(&ds->ds_bookmarks);
986 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
987 uint64_t bmark_zapobj = ds->ds_bookmarks_obj;
992 * dsl_bookmark_compare()) will be zeroed even if the on-disk
1000 * from the given name if the dataset is case-insensitive. Then
1004 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
1019 dsl_bookmark_node_t *dbn = avl_find(&ds->ds_bookmarks, &search, NULL);
1022 if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
1033 * HAS_FBN are adjacent (with no non-HAS_FBN bookmarks
1040 AVL_PREV(&ds->ds_bookmarks, dbn);
1042 AVL_NEXT(&ds->ds_bookmarks, dbn);
1045 (dbn_prev != NULL && dbn_prev->dbn_phys.zbm_creation_txg ==
1046 dbn->dbn_phys.zbm_creation_txg &&
1047 (dbn_prev->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) ||
1048 (dbn_next != NULL && dbn_next->dbn_phys.zbm_creation_txg ==
1049 dbn->dbn_phys.zbm_creation_txg &&
1050 (dbn_next->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN));
1052 if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_SNAPSHOT_EXISTS) &&
1054 dbn->dbn_phys.zbm_creation_txg <
1055 dsl_dataset_phys(ds)->ds_prev_snap_txg) {
1056 dsl_dir_remove_clones_key(ds->ds_dir,
1057 dbn->dbn_phys.zbm_creation_txg, tx);
1058 dsl_deadlist_remove_key(&ds->ds_deadlist,
1059 dbn->dbn_phys.zbm_creation_txg, tx);
1066 if (dbn->dbn_phys.zbm_redaction_obj != 0) {
1069 dbn->dbn_phys.zbm_redaction_obj, FTAG, &rl));
1070 if (rl->dn_have_spill) {
1076 dbn->dbn_phys.zbm_redaction_obj, tx));
1081 avl_remove(&ds->ds_bookmarks, dbn);
1082 spa_strfree(dbn->dbn_name);
1083 mutex_destroy(&dbn->dbn_lock);
1096 ASSERT(nvlist_empty(dbda->dbda_success));
1097 ASSERT(nvlist_empty(dbda->dbda_errors));
1099 if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARKS))
1102 for (nvpair_t *pair = nvlist_next_nvpair(dbda->dbda_bmarks, NULL);
1103 pair != NULL; pair = nvlist_next_nvpair(dbda->dbda_bmarks, pair)) {
1128 error = dsl_redaction_list_hold_obj(tx->tx_pool,
1143 fnvlist_add_boolean(dbda->dbda_success,
1147 fnvlist_add_int32(dbda->dbda_errors, fullname, error);
1159 objset_t *mos = dp->dp_meta_objset;
1161 for (nvpair_t *pair = nvlist_next_nvpair(dbda->dbda_success, NULL);
1162 pair != NULL; pair = nvlist_next_nvpair(dbda->dbda_success, pair)) {
1175 VERIFY0(zap_count(mos, ds->ds_bookmarks_obj, &zap_cnt));
1177 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1178 VERIFY0(zap_destroy(mos, ds->ds_bookmarks_obj, tx));
1179 ds->ds_bookmarks_obj = 0;
1180 spa_feature_decr(dp->dp_spa, SPA_FEATURE_BOOKMARKS, tx);
1181 VERIFY0(zap_remove(mos, ds->ds_object,
1219 return (!zfs_refcount_is_zero(&rl->rl_longholds));
1227 (void) zfs_refcount_add(&rl->rl_longholds, tag);
1233 (void) zfs_refcount_remove(&rl->rl_longholds, tag);
1240 zfs_refcount_destroy(&rl->rl_longholds);
1248 if (rl->rl_bonus != rl->rl_dbuf)
1249 dmu_buf_rele(rl->rl_dbuf, tag);
1250 dmu_buf_rele(rl->rl_bonus, tag);
1257 objset_t *mos = dp->dp_meta_objset;
1273 rl->rl_bonus = dbuf;
1275 rl->rl_dbuf = spill_dbuf;
1277 rl->rl_dbuf = dbuf;
1279 rl->rl_object = rlobj;
1280 rl->rl_phys = rl->rl_dbuf->db_data;
1281 rl->rl_mos = dp->dp_meta_objset;
1282 zfs_refcount_create(&rl->rl_longholds);
1283 dmu_buf_init_user(&rl->rl_dbu, redaction_list_evict_sync, NULL,
1284 &rl->rl_bonus);
1285 if ((winner = dmu_buf_set_user_ie(dbuf, &rl->rl_dbu)) != NULL) {
1313 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1317 dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj, FTAG, &head));
1319 dsl_dataset_phys(ds)->ds_next_snap_obj, FTAG, &next));
1328 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1331 * The empty-string name can't be in the AVL, and it compares
1335 VERIFY3P(avl_find(&head->ds_bookmarks, &search, &idx), ==, NULL);
1337 avl_nearest(&head->ds_bookmarks, idx, AVL_AFTER);
1342 * their FBN based on their new next snapshot.
1344 for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg <
1345 dsl_dataset_phys(ds)->ds_creation_txg;
1346 dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
1347 if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN))
1358 dsl_deadlist_space_range(&next->ds_deadlist,
1359 0, dbn->dbn_phys.zbm_creation_txg,
1361 dbn->dbn_phys.zbm_referenced_freed_before_next_snap +=
1363 dbn->dbn_phys.zbm_compressed_freed_before_next_snap +=
1365 dbn->dbn_phys.zbm_uncompressed_freed_before_next_snap +=
1367 VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
1368 dbn->dbn_name, sizeof (uint64_t),
1370 &dbn->dbn_phys, tx));
1382 for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg ==
1383 dsl_dataset_phys(ds)->ds_creation_txg;
1384 dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
1385 if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) {
1386 ASSERT(!(dbn->dbn_phys.zbm_flags &
1390 ASSERT(dbn->dbn_phys.zbm_flags & ZBM_FLAG_SNAPSHOT_EXISTS);
1391 dbn->dbn_phys.zbm_flags &= ~ZBM_FLAG_SNAPSHOT_EXISTS;
1392 VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
1393 dbn->dbn_name, sizeof (uint64_t),
1395 &dbn->dbn_phys, tx));
1416 for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1417 dbn != NULL && dbn->dbn_phys.zbm_creation_txg >
1418 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1419 dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
1420 uint64_t creation_txg = dbn->dbn_phys.zbm_creation_txg;
1428 if ((dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) &&
1430 dsl_deadlist_add_key(&ds->ds_deadlist,
1455 dsl_dataset_phys(origin)->ds_creation_txg;
1458 * The empty-string name can't be in the AVL, and it compares
1462 VERIFY3P(avl_find(&head->ds_bookmarks, &search, &idx), ==, NULL);
1464 avl_nearest(&head->ds_bookmarks, idx, AVL_AFTER);
1468 * Adjust their FBN based on their new next snapshot.
1470 for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg ==
1471 dsl_dataset_phys(origin)->ds_creation_txg &&
1472 (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN);
1473 dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
1481 ASSERT3U(dbn->dbn_phys.zbm_guid, ==,
1482 dsl_dataset_phys(origin)->ds_guid);
1483 ASSERT3U(dbn->dbn_phys.zbm_referenced_bytes_refd, ==,
1484 dsl_dataset_phys(origin)->ds_referenced_bytes);
1485 ASSERT(dbn->dbn_phys.zbm_flags &
1492 dbn->dbn_phys.zbm_redaction_obj;
1493 dsl_bookmark_set_phys(&dbn->dbn_phys, origin);
1494 dbn->dbn_phys.zbm_redaction_obj = redaction_obj;
1496 VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
1497 dbn->dbn_name, sizeof (uint64_t),
1499 &dbn->dbn_phys, tx));
1517 for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1518 dbn != NULL && dbn->dbn_phys.zbm_creation_txg >=
1519 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1520 dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
1526 dbn->dbn_phys.zbm_creation_txg &&
1527 (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) {
1528 mutex_enter(&dbn->dbn_lock);
1529 dbn->dbn_phys.zbm_referenced_freed_before_next_snap +=
1531 dbn->dbn_phys.zbm_compressed_freed_before_next_snap +=
1533 dbn->dbn_phys.zbm_uncompressed_freed_before_next_snap +=
1543 dbn->dbn_dirty = B_TRUE;
1544 mutex_exit(&dbn->dbn_lock);
1563 for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1564 dbn != NULL && dbn->dbn_phys.zbm_creation_txg >=
1565 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1566 dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
1567 if (dbn->dbn_dirty) {
1572 ASSERT(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN);
1573 VERIFY0(zap_update(dp->dp_meta_objset,
1574 ds->ds_bookmarks_obj,
1575 dbn->dbn_name, sizeof (uint64_t),
1577 &dbn->dbn_phys, tx));
1578 dbn->dbn_dirty = B_FALSE;
1582 for (dsl_bookmark_node_t *dbn = avl_first(&ds->ds_bookmarks);
1583 dbn != NULL; dbn = AVL_NEXT(&ds->ds_bookmarks, dbn)) {
1584 ASSERT(!dbn->dbn_dirty);
1595 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
1596 dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1599 return (dbn->dbn_phys.zbm_creation_txg);
1604 * redact_block_phys_t is before the bookmark, return -1. If the first block in
1617 if (first->rbp_object < second->zb_object ||
1618 (first->rbp_object == second->zb_object &&
1619 first->rbp_blkid + (redact_block_get_count(first) - 1) <
1620 second->zb_blkid)) {
1621 return (-1);
1629 if (first->rbp_object > second->zb_object ||
1630 (first->rbp_object == second->zb_object &&
1631 first->rbp_blkid > second->zb_blkid)) {
1646 objset_t *mos = rl->rl_mos;
1649 if (rl->rl_phys->rlp_last_object != UINT64_MAX ||
1650 rl->rl_phys->rlp_last_blkid != UINT64_MAX) {
1672 uint64_t maxidx = rl->rl_phys->rlp_num_entries - 1;
1677 uint64_t mididx = minidx + ((maxidx - minidx) / 2);
1678 err = dmu_read(mos, rl->rl_object, mididx * sizeof (rbp),
1690 (mididx == minidx ? minidx : mididx - 1);
1701 err = dmu_read(mos, rl->rl_object, start_block * bufsize, bufsize, buf,
1705 err == 0 && curidx < rl->rl_phys->rlp_num_entries;
1715 err = dmu_read(mos, rl->rl_object, curidx *
1723 * If resume is non-null, we should either not send the data, or
1752 if (resume->zb_object == rb->rbp_object &&
1753 resume->zb_blkid > rb->rbp_blkid) {
1754 uint64_t diff = resume->zb_blkid -
1755 rb->rbp_blkid;
1756 rb->rbp_blkid = resume->zb_blkid;
1758 redact_block_get_count(rb) - diff);