Lines Matching refs:db
52 static boolean_t dbuf_undirty(dmu_buf_impl_t *db, dmu_tx_t *tx);
139 dmu_buf_impl_t *db = vdb;
141 bzero(db, sizeof (dmu_buf_impl_t));
142 mutex_init(&db->db_mtx, NULL, MUTEX_DEFAULT, NULL);
143 cv_init(&db->db_changed, NULL, CV_DEFAULT, NULL);
144 multilist_link_init(&db->db_cache_link);
145 refcount_create(&db->db_holds);
154 dmu_buf_impl_t *db = vdb;
156 mutex_destroy(&db->db_mtx);
157 cv_destroy(&db->db_changed);
158 ASSERT(!multilist_link_active(&db->db_cache_link));
159 refcount_destroy(&db->db_holds);
189 ((dbuf)->db.db_object == (obj) && \
200 dmu_buf_impl_t *db;
203 for (db = h->hash_table[idx]; db != NULL; db = db->db_hash_next) {
204 if (DBUF_EQUAL(db, os, obj, level, blkid)) {
205 mutex_enter(&db->db_mtx);
206 if (db->db_state != DB_EVICTING) {
208 return (db);
210 mutex_exit(&db->db_mtx);
221 dmu_buf_impl_t *db = NULL;
226 db = dn->dn_bonus;
227 mutex_enter(&db->db_mtx);
232 return (db);
242 dbuf_hash_insert(dmu_buf_impl_t *db)
245 objset_t *os = db->db_objset;
246 uint64_t obj = db->db.db_object;
247 int level = db->db_level;
248 uint64_t blkid = db->db_blkid;
265 mutex_enter(&db->db_mtx);
266 db->db_hash_next = h->hash_table[idx];
267 h->hash_table[idx] = db;
278 dbuf_hash_remove(dmu_buf_impl_t *db)
281 uint64_t hv = dbuf_hash(db->db_objset, db->db.db_object,
282 db->db_level, db->db_blkid);
290 ASSERT(refcount_is_zero(&db->db_holds));
291 ASSERT(db->db_state == DB_EVICTING);
292 ASSERT(!MUTEX_HELD(&db->db_mtx));
296 while ((dbf = *dbp) != db) {
300 *dbp = db->db_hash_next;
301 db->db_hash_next = NULL;
312 dbuf_verify_user(dmu_buf_impl_t *db, dbvu_verify_type_t verify_type)
317 if (db->db_user == NULL)
321 ASSERT(db->db_level == 0);
324 ASSERT(db->db.db_data != NULL);
325 ASSERT3U(db->db_state, ==, DB_CACHED);
327 holds = refcount_count(&db->db_holds);
338 ASSERT3U(holds, >=, db->db_dirtycnt);
340 if (db->db_user_immediate_evict == TRUE)
341 ASSERT3U(holds, >=, db->db_dirtycnt);
349 dbuf_evict_user(dmu_buf_impl_t *db)
351 dmu_buf_user_t *dbu = db->db_user;
353 ASSERT(MUTEX_HELD(&db->db_mtx));
358 dbuf_verify_user(db, DBVU_EVICTING);
359 db->db_user = NULL;
388 dbuf_is_metadata(dmu_buf_impl_t *db)
390 if (db->db_level > 0) {
395 DB_DNODE_ENTER(db);
396 is_metadata = DMU_OT_IS_METADATA(DB_DNODE(db)->dn_type);
397 DB_DNODE_EXIT(db);
413 dmu_buf_impl_t *db = obj;
427 return (dbuf_hash(db->db_objset, db->db.db_object,
428 db->db_level, db->db_blkid) %
471 dmu_buf_impl_t *db = multilist_sublist_tail(mls);
472 while (db != NULL && mutex_tryenter(&db->db_mtx) == 0) {
473 db = multilist_sublist_prev(mls, db);
476 DTRACE_PROBE2(dbuf__evict__one, dmu_buf_impl_t *, db,
479 if (db != NULL) {
480 multilist_sublist_remove(mls, db);
483 db->db.db_size, db);
484 dbuf_destroy(db);
673 dbuf_verify(dmu_buf_impl_t *db)
678 ASSERT(MUTEX_HELD(&db->db_mtx));
683 ASSERT(db->db_objset != NULL);
684 DB_DNODE_ENTER(db);
685 dn = DB_DNODE(db);
687 ASSERT(db->db_parent == NULL);
688 ASSERT(db->db_blkptr == NULL);
690 ASSERT3U(db->db.db_object, ==, dn->dn_object);
691 ASSERT3P(db->db_objset, ==, dn->dn_objset);
692 ASSERT3U(db->db_level, <, dn->dn_nlevels);
693 ASSERT(db->db_blkid == DMU_BONUS_BLKID ||
694 db->db_blkid == DMU_SPILL_BLKID ||
697 if (db->db_blkid == DMU_BONUS_BLKID) {
699 ASSERT3U(db->db.db_size, >=, dn->dn_bonuslen);
700 ASSERT3U(db->db.db_offset, ==, DMU_BONUS_BLKID);
701 } else if (db->db_blkid == DMU_SPILL_BLKID) {
703 ASSERT3U(db->db.db_size, >=, dn->dn_bonuslen);
704 ASSERT0(db->db.db_offset);
706 ASSERT3U(db->db.db_offset, ==, db->db_blkid * db->db.db_size);
709 for (dr = db->db_data_pending; dr != NULL; dr = dr->dr_next)
710 ASSERT(dr->dr_dbuf == db);
712 for (dr = db->db_last_dirty; dr != NULL; dr = dr->dr_next)
713 ASSERT(dr->dr_dbuf == db);
720 if (db->db_level == 0 && db->db.db_object == DMU_META_DNODE_OBJECT) {
721 dr = db->db_data_pending;
726 ASSERT(dr == NULL || dr->dt.dl.dr_data == db->db_buf);
729 /* verify db->db_blkptr */
730 if (db->db_blkptr) {
731 if (db->db_parent == dn->dn_dbuf) {
732 /* db is pointed to by the dnode */
733 /* ASSERT3U(db->db_blkid, <, dn->dn_nblkptr); */
734 if (DMU_OBJECT_IS_SPECIAL(db->db.db_object))
735 ASSERT(db->db_parent == NULL);
737 ASSERT(db->db_parent != NULL);
738 if (db->db_blkid != DMU_SPILL_BLKID)
739 ASSERT3P(db->db_blkptr, ==,
740 &dn->dn_phys->dn_blkptr[db->db_blkid]);
742 /* db is pointed to by an indirect block */
743 int epb = db->db_parent->db.db_size >> SPA_BLKPTRSHIFT;
744 ASSERT3U(db->db_parent->db_level, ==, db->db_level+1);
745 ASSERT3U(db->db_parent->db.db_object, ==,
746 db->db.db_object);
753 ASSERT3P(db->db_blkptr, ==,
754 ((blkptr_t *)db->db_parent->db.db_data +
755 db->db_blkid % epb));
759 if ((db->db_blkptr == NULL || BP_IS_HOLE(db->db_blkptr)) &&
760 (db->db_buf == NULL || db->db_buf->b_data) &&
761 db->db.db_data && db->db_blkid != DMU_BONUS_BLKID &&
762 db->db_state != DB_FILL && !dn->dn_free_txg) {
774 if (db->db_dirtycnt == 0) {
775 if (db->db_level == 0) {
776 uint64_t *buf = db->db.db_data;
779 for (i = 0; i < db->db.db_size >> 3; i++) {
783 blkptr_t *bps = db->db.db_data;
784 ASSERT3U(1 << DB_DNODE(db)->dn_indblkshift, ==,
785 db->db.db_size);
794 i < db->db.db_size / sizeof (blkptr_t);
813 DB_DNODE_EXIT(db);
818 dbuf_clear_data(dmu_buf_impl_t *db)
820 ASSERT(MUTEX_HELD(&db->db_mtx));
821 dbuf_evict_user(db);
822 ASSERT3P(db->db_buf, ==, NULL);
823 db->db.db_data = NULL;
824 if (db->db_state != DB_NOFILL)
825 db->db_state = DB_UNCACHED;
829 dbuf_set_data(dmu_buf_impl_t *db, arc_buf_t *buf)
831 ASSERT(MUTEX_HELD(&db->db_mtx));
834 db->db_buf = buf;
836 db->db.db_data = buf->b_data;
843 dbuf_loan_arcbuf(dmu_buf_impl_t *db)
847 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
848 mutex_enter(&db->db_mtx);
849 if (arc_released(db->db_buf) || refcount_count(&db->db_holds) > 1) {
850 int blksz = db->db.db_size;
851 spa_t *spa = db->db_objset->os_spa;
853 mutex_exit(&db->db_mtx);
855 bcopy(db->db.db_data, abuf->b_data, blksz);
857 abuf = db->db_buf;
858 arc_loan_inuse_buf(abuf, db);
859 db->db_buf = NULL;
860 dbuf_clear_data(db);
861 mutex_exit(&db->db_mtx);
904 dmu_buf_impl_t *db = vdb;
906 mutex_enter(&db->db_mtx);
907 ASSERT3U(db->db_state, ==, DB_READ);
911 ASSERT(refcount_count(&db->db_holds) > 0);
912 ASSERT(db->db_buf == NULL);
913 ASSERT(db->db.db_data == NULL);
914 if (db->db_level == 0 && db->db_freed_in_flight) {
916 arc_release(buf, db);
917 bzero(buf->b_data, db->db.db_size);
919 db->db_freed_in_flight = FALSE;
920 dbuf_set_data(db, buf);
921 db->db_state = DB_CACHED;
923 dbuf_set_data(db, buf);
924 db->db_state = DB_CACHED;
926 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
927 ASSERT3P(db->db_buf, ==, NULL);
928 arc_buf_destroy(buf, db);
929 db->db_state = DB_UNCACHED;
931 cv_broadcast(&db->db_changed);
932 dbuf_rele_and_unlock(db, NULL);
936 dbuf_read_impl(dmu_buf_impl_t *db, zio_t *zio, uint32_t flags)
942 DB_DNODE_ENTER(db);
943 dn = DB_DNODE(db);
944 ASSERT(!refcount_is_zero(&db->db_holds));
947 ASSERT(MUTEX_HELD(&db->db_mtx));
948 ASSERT(db->db_state == DB_UNCACHED);
949 ASSERT(db->db_buf == NULL);
951 if (db->db_blkid == DMU_BONUS_BLKID) {
954 ASSERT3U(bonuslen, <=, db->db.db_size);
955 db->db.db_data = zio_buf_alloc(DN_MAX_BONUSLEN);
958 bzero(db->db.db_data, DN_MAX_BONUSLEN);
960 bcopy(DN_BONUS(dn->dn_phys), db->db.db_data, bonuslen);
961 DB_DNODE_EXIT(db);
962 db->db_state = DB_CACHED;
963 mutex_exit(&db->db_mtx);
972 if (db->db_blkptr == NULL || BP_IS_HOLE(db->db_blkptr) ||
973 (db->db_level == 0 && (dnode_block_freed(dn, db->db_blkid) ||
974 BP_IS_HOLE(db->db_blkptr)))) {
975 arc_buf_contents_t type = DBUF_GET_BUFC_TYPE(db);
977 dbuf_set_data(db, arc_alloc_buf(db->db_objset->os_spa,
978 db->db.db_size, db, type));
979 bzero(db->db.db_data, db->db.db_size);
981 if (db->db_blkptr != NULL && db->db_level > 0 &&
982 BP_IS_HOLE(db->db_blkptr) &&
983 db->db_blkptr->blk_birth != 0) {
984 blkptr_t *bps = db->db.db_data;
986 DB_DNODE(db)->dn_indblkshift) / sizeof (blkptr_t));
989 ASSERT3U(BP_GET_LSIZE(db->db_blkptr), ==,
992 BP_GET_LEVEL(db->db_blkptr) == 1 ?
994 BP_GET_LSIZE(db->db_blkptr));
995 BP_SET_TYPE(bp, BP_GET_TYPE(db->db_blkptr));
997 BP_GET_LEVEL(db->db_blkptr) - 1);
998 BP_SET_BIRTH(bp, db->db_blkptr->blk_birth, 0);
1001 DB_DNODE_EXIT(db);
1002 db->db_state = DB_CACHED;
1003 mutex_exit(&db->db_mtx);
1007 DB_DNODE_EXIT(db);
1009 db->db_state = DB_READ;
1010 mutex_exit(&db->db_mtx);
1012 if (DBUF_IS_L2CACHEABLE(db))
1015 SET_BOOKMARK(&zb, db->db_objset->os_dsl_dataset ?
1016 db->db_objset->os_dsl_dataset->ds_object : DMU_META_OBJSET,
1017 db->db.db_object, db->db_level, db->db_blkid);
1019 dbuf_add_ref(db, NULL);
1021 (void) arc_read(zio, db->db_objset->os_spa, db->db_blkptr,
1022 dbuf_read_done, db, ZIO_PRIORITY_SYNC_READ,
1028 dbuf_read(dmu_buf_impl_t *db, zio_t *zio, uint32_t flags)
1039 ASSERT(!refcount_is_zero(&db->db_holds));
1041 if (db->db_state == DB_NOFILL)
1044 DB_DNODE_ENTER(db);
1045 dn = DB_DNODE(db);
1049 prefetch = db->db_level == 0 && db->db_blkid != DMU_BONUS_BLKID &&
1051 DBUF_IS_CACHEABLE(db);
1053 mutex_enter(&db->db_mtx);
1054 if (db->db_state == DB_CACHED) {
1055 mutex_exit(&db->db_mtx);
1057 dmu_zfetch(&dn->dn_zfetch, db->db_blkid, 1, B_TRUE);
1060 DB_DNODE_EXIT(db);
1061 } else if (db->db_state == DB_UNCACHED) {
1066 dbuf_read_impl(db, zio, flags);
1071 dmu_zfetch(&dn->dn_zfetch, db->db_blkid, 1, B_TRUE);
1075 DB_DNODE_EXIT(db);
1088 mutex_exit(&db->db_mtx);
1090 dmu_zfetch(&dn->dn_zfetch, db->db_blkid, 1, B_TRUE);
1093 DB_DNODE_EXIT(db);
1096 mutex_enter(&db->db_mtx);
1098 while (db->db_state == DB_READ ||
1099 db
1100 ASSERT(db->db_state == DB_READ ||
1103 db, zio_t *, zio);
1104 cv_wait(&db->db_changed, &db->db_mtx);
1106 if (db->db_state == DB_UNCACHED)
1109 mutex_exit(&db->db_mtx);
1112 ASSERT(err || havepzio || db->db_state == DB_CACHED);
1117 dbuf_noread(dmu_buf_impl_t *db)
1119 ASSERT(!refcount_is_zero(&db->db_holds));
1120 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1121 mutex_enter(&db->db_mtx);
1122 while (db->db_state == DB_READ || db->db_state == DB_FILL)
1123 cv_wait(&db->db_changed, &db->db_mtx);
1124 if (db->db_state == DB_UNCACHED) {
1125 arc_buf_contents_t type = DBUF_GET_BUFC_TYPE(db);
1126 spa_t *spa = db->db_objset->os_spa;
1128 ASSERT(db->db_buf == NULL);
1129 ASSERT(db->db.db_data == NULL);
1130 dbuf_set_data(db, arc_alloc_buf(spa, db->db.db_size, db, type));
1131 db->db_state = DB_FILL;
1132 } else if (db->db_state == DB_NOFILL) {
1133 dbuf_clear_data(db);
1135 ASSERT3U(db->db_state, ==, DB_CACHED);
1137 mutex_exit(&db->db_mtx);
1154 dbuf_fix_old_data(dmu_buf_impl_t *db, uint64_t txg)
1156 dbuf_dirty_record_t *dr = db->db_last_dirty;
1158 ASSERT(MUTEX_HELD(&db->db_mtx));
1159 ASSERT(db->db.db_data != NULL);
1160 ASSERT(db->db_level == 0);
1161 ASSERT(db->db.db_object != DMU_META_DNODE_OBJECT);
1165 ((db->db_blkid == DMU_BONUS_BLKID) ? db->db.db_data : db->db_buf)))
1176 if (db->db_blkid == DMU_BONUS_BLKID) {
1180 bcopy(db->db.db_data, dr->dt.dl.dr_data, DN_MAX_BONUSLEN);
1181 } else if (refcount_count(&db->db_holds) > db->db_dirtycnt) {
1182 int size = db->db.db_size;
1183 arc_buf_contents_t type = DBUF_GET_BUFC_TYPE(db);
1184 spa_t *spa = db->db_objset->os_spa;
1186 dr->dt.dl.dr_data = arc_alloc_buf(spa, size, db, type);
1187 bcopy(db->db.db_data, dr->dt.dl.dr_data->b_data, size);
1189 db->db_buf = NULL;
1190 dbuf_clear_data(db);
1197 dmu_buf_impl_t *db = dr->dr_dbuf;
1201 ASSERT(MUTEX_HELD(&db->db_mtx));
1203 ASSERT(db->db_level == 0);
1205 if (db->db_blkid == DMU_BONUS_BLKID ||
1209 ASSERT(db->db_data_pending != dr);
1213 zio_free(db->db_objset->os_spa, txg, bp);
1226 arc_release(dr->dt.dl.dr_data, db);
1239 dmu_buf_impl_t *db, *db_next;
1253 db = avl_find(&dn->dn_dbufs, &db_search, &where);
1254 ASSERT3P(db, ==, NULL);
1256 db = avl_nearest(&dn->dn_dbufs, where, AVL_AFTER);
1258 for (; db != NULL; db = db_next) {
1259 db_next = AVL_NEXT(&dn->dn_dbufs, db);
1260 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1262 if (db->db_level != 0 || db->db_blkid > end_blkid) {
1265 ASSERT3U(db->db_blkid, >=, start_blkid);
1268 mutex_enter(&db->db_mtx);
1269 if (dbuf_undirty(db, tx)) {
1274 if (db->db_state == DB_UNCACHED ||
1275 db->db_state == DB_NOFILL ||
1276 db->db_state == DB_EVICTING) {
1277 ASSERT(db->db.db_data == NULL);
1278 mutex_exit(&db->db_mtx);
1281 if (db->db_state == DB_READ || db->db_state == DB_FILL) {
1283 db->db_freed_in_flight = TRUE;
1284 mutex_exit(&db->db_mtx);
1287 if (refcount_count(&db->db_holds) == 0) {
1288 ASSERT(db->db_buf);
1289 dbuf_destroy(db);
1294 if (db->db_last_dirty != NULL) {
1295 dbuf_dirty_record_t *dr = db->db_last_dirty;
1303 if (db->db_blkid != DMU_SPILL_BLKID &&
1304 db->db_blkid > dn->dn_maxblkid)
1305 dn->dn_maxblkid = db->db_blkid;
1314 dbuf_fix_old_data(db, txg);
1318 if (db->db_state == DB_CACHED) {
1319 ASSERT(db->db.db_data != NULL);
1320 arc_release(db->db_buf, db);
1321 bzero(db->db.db_data, db->db.db_size);
1322 arc_buf_freeze(db->db_buf);
1325 mutex_exit(&db->db_mtx);
1331 dbuf_block_freeable(dmu_buf_impl_t *db)
1333 dsl_dataset_t *ds = db->db_objset->os_dsl_dataset;
1344 ASSERT(MUTEX_HELD(&db->db_mtx));
1345 if (db->db_last_dirty && (db->db_blkptr == NULL ||
1346 !BP_IS_HOLE(db->db_blkptr))) {
1347 birth_txg = db->db_last_dirty->dr_txg;
1348 } else if (db->db_blkptr != NULL && !BP_IS_HOLE(db->db_blkptr)) {
1349 birth_txg = db->db_blkptr->blk_birth;
1366 dbuf_new_size(dmu_buf_impl_t *db, int size, dmu_tx_t *tx)
1369 int osize = db->db.db_size;
1370 arc_buf_contents_t type = DBUF_GET_BUFC_TYPE(db);
1373 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1375 DB_DNODE_ENTER(db);
1376 dn = DB_DNODE(db);
1383 * is OK, because there can be no other references to the db
1391 dmu_buf_will_dirty(&db->db, tx);
1394 buf = arc_alloc_buf(dn->dn_objset->os_spa, size, db, type);
1397 obuf = db->db_buf;
1403 mutex_enter(&db->db_mtx);
1404 dbuf_set_data(db, buf);
1405 arc_buf_destroy(obuf, db);
1406 db->db.db_size = size;
1408 if (db->db_level == 0) {
1409 ASSERT3U(db->db_last_dirty->dr_txg, ==, tx->tx_txg);
1410 db->db_last_dirty->dt.dl.dr_data = buf;
1412 mutex_exit(&db->db_mtx);
1415 DB_DNODE_EXIT(db);
1419 dbuf_release_bp(dmu_buf_impl_t *db)
1421 objset_t *os = db->db_objset;
1426 ASSERT(db->db_parent == NULL || arc_released(db->db_parent->db_buf));
1428 (void) arc_release(db->db_buf, db);
1438 dmu_buf_impl_t *db = dr->dr_dbuf;
1440 ASSERT(MUTEX_HELD(&db->db_mtx));
1442 if (db->db_level == 0 && db->db_blkid != DMU_BONUS_BLKID) {
1448 if (db->db.db_object != DMU_META_DNODE_OBJECT &&
1449 db->db_state != DB_NOFILL) {
1451 ASSERT(arc_released(db->db_buf));
1452 arc_buf_thaw(db->db_buf);
1458 dbuf_dirty(dmu_buf_impl_t *db, dmu_tx_t *tx)
1468 ASSERT(!refcount_is_zero(&db->db_holds));
1469 DMU_TX_DIRTY_BUF(tx, db);
1471 DB_DNODE_ENTER(db);
1472 dn = DB_DNODE(db);
1499 mutex_enter(&db->db_mtx);
1505 ASSERT(db->db_level != 0 ||
1506 db->db_state == DB_CACHED || db->db_state == DB_FILL ||
1507 db->db_state == DB_NOFILL);
1532 if (db->db_blkid == DMU_SPILL_BLKID)
1538 drp = &db->db_last_dirty;
1540 db->db.db_object == DMU_META_DNODE_OBJECT);
1544 DB_DNODE_EXIT(db);
1547 mutex_exit(&db->db_mtx);
1558 ASSERT3U(dn->dn_nlevels, >, db->db_level);
1559 ASSERT((dn->dn_phys->dn_nlevels == 0 && db->db_level == 0) ||
1560 dn->dn_phys->dn_nlevels > db->db_level ||
1561 dn->dn_next_nlevels[txgoff] > db->db_level ||
1562 dn->dn_next_nlevels[(tx->tx_txg-1) & TXG_MASK] > db->db_level ||
1563 dn->dn_next_nlevels[(tx->tx_txg-2) & TXG_MASK] > db->db_level);
1581 ASSERT(db->db.db_size != 0);
1583 dprintf_dbuf(db, "size=%llx\n", (u_longlong_t)db->db.db_size);
1585 if (db->db_blkid != DMU_BONUS_BLKID) {
1593 dnode_willuse_space(dn, db->db.db_size, tx);
1594 do_free_accounting = dbuf_block_freeable(db);
1603 if (db->db_level == 0) {
1604 void *data_old = db->db_buf;
1606 if (db->db_state != DB_NOFILL) {
1607 if (db->db_blkid == DMU_BONUS_BLKID) {
1608 dbuf_fix_old_data(db, tx->tx_txg);
1609 data_old = db->db.db_data;
1610 } else if (db->db.db_object != DMU_META_DNODE_OBJECT) {
1620 arc_release(db->db_buf, db);
1621 dbuf_fix_old_data(db, tx->tx_txg);
1622 data_old = db->db_buf;
1633 if (db->db_blkid != DMU_BONUS_BLKID && os->os_dsl_dataset != NULL)
1634 dr->dr_accounted = db->db.db_size;
1635 dr->dr_dbuf = db;
1645 if (db->db_level == 0 && db->db_blkid != DMU_BONUS_BLKID &&
1646 db->db_blkid != DMU_SPILL_BLKID) {
1650 db->db_blkid, 1);
1653 db->db_freed_in_flight = FALSE;
1659 dbuf_add_ref(db
1660 db->db_dirtycnt += 1;
1661 ASSERT3U(db->db_dirtycnt, <=, 3);
1663 mutex_exit(&db->db_mtx);
1665 if (db->db_blkid == DMU_BONUS_BLKID ||
1666 db->db_blkid == DMU_SPILL_BLKID) {
1672 DB_DNODE_EXIT(db);
1688 blkptr_t *bp = db->db_blkptr;
1690 bp_get_dsize(os->os_spa, bp) : db->db.db_size;
1703 if (db->db_level == 0) {
1704 dnode_new_blkid(dn, db->db_blkid, tx, drop_struct_lock);
1705 ASSERT(dn->dn_maxblkid >= db->db_blkid);
1708 if (db->db_level+1 < dn->dn_nlevels) {
1709 dmu_buf_impl_t *parent = db->db_parent;
1713 if (db->db_parent == NULL || db->db_parent == dn->dn_dbuf) {
1716 parent = dbuf_hold_level(dn, db->db_level+1,
1717 db->db_blkid >> epbs, FTAG);
1723 ASSERT3U(db->db_level+1, ==, parent->db_level);
1728 mutex_enter(&db->db_mtx);
1733 if (db->db_last_dirty == dr ||
1742 mutex_exit(&db->db_mtx);
1744 ASSERT(db->db_level+1 == dn->dn_nlevels);
1745 ASSERT(db->db_blkid < dn->dn_nblkptr);
1746 ASSERT(db->db_parent == NULL || db->db_parent == dn->dn_dbuf);
1756 DB_DNODE_EXIT(db);
1765 dbuf_undirty(dmu_buf_impl_t *db, dmu_tx_t *tx)
1779 ASSERT(db->db_objset ==
1780 dmu_objset_pool(db->db_objset)->dp_meta_objset ||
1781 txg != spa_syncing_txg(dmu_objset_spa(db->db_objset)));
1782 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1783 ASSERT0(db->db_level);
1784 ASSERT(MUTEX_HELD(&db->db_mtx));
1789 for (drp = &db->db_last_dirty; (dr = *drp) != NULL; drp = &dr->dr_next)
1795 ASSERT(dr->dr_dbuf == db);
1797 DB_DNODE_ENTER(db);
1798 dn = DB_DNODE(db);
1800 dprintf_dbuf(db, "size=%llx\n", (u_longlong_t)db->db.db_size);
1802 ASSERT(db->db.db_size != 0);
1819 } else if (db->db_blkid == DMU_SPILL_BLKID ||
1820 db->db_level + 1 == dn->dn_nlevels) {
1821 ASSERT(db->db_blkptr == NULL || db->db_parent == dn->dn_dbuf);
1826 DB_DNODE_EXIT(db);
1828 if (db->db_state != DB_NOFILL) {
1831 ASSERT(db->db_buf != NULL);
1833 if (dr->dt.dl.dr_data != db->db_buf)
1834 arc_buf_destroy(dr->dt.dl.dr_data, db);
1839 ASSERT(db->db_dirtycnt > 0);
1840 db->db_dirtycnt -= 1;
1842 if (refcount_remove(&db->db_holds, (void *)(uintptr_t)txg) == 0) {
1843 ASSERT(db->db_state == DB_NOFILL || arc_released(db->db_buf));
1844 dbuf_destroy(db);
1854 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
1858 ASSERT(!refcount_is_zero(&db->db_holds));
1866 mutex_enter(&db->db_mtx);
1868 for (dr = db->db_last_dirty;
1875 if (dr->dr_txg == tx->tx_txg && db->db_state == DB_CACHED) {
1878 mutex_exit(&db->db_mtx);
1882 mutex_exit(&db->db_mtx);
1884 DB_DNODE_ENTER(db);
1885 if (RW_WRITE_HELD(&DB_DNODE(db)->dn_struct_rwlock))
1887 DB_DNODE_EXIT(db);
1888 (void) dbuf_read(db, NULL, rf);
1889 (void) dbuf_dirty(db, tx);
1895 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
1897 db->db_state = DB_NOFILL;
1905 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
1907 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1909 ASSERT(db->db_level == 0);
1910 ASSERT(!refcount_is_zero(&db->db_holds));
1912 ASSERT(db->db.db_object != DMU_META_DNODE_OBJECT ||
1915 dbuf_noread(db);
1916 (void) dbuf_dirty(db, tx);
1922 dbuf_fill_done(dmu_buf_impl_t *db, dmu_tx_t *tx)
1924 mutex_enter(&db->db_mtx);
1925 DBUF_VERIFY(db);
1927 if (db->db_state == DB_FILL) {
1928 if (db->db_level == 0 && db->db_freed_in_flight) {
1929 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1932 bzero(db->db.db_data, db->db.db_size);
1933 db->db_freed_in_flight = FALSE;
1935 db->db_state = DB_CACHED;
1936 cv_broadcast(&db->db_changed);
1938 mutex_exit(&db->db_mtx);
1947 dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbuf;
1952 ASSERT(spa_feature_is_active(dmu_objset_spa(db->db_objset),
1956 DB_DNODE_ENTER(db);
1957 type = DB_DNODE(db)->dn_type;
1958 DB_DNODE_EXIT(db);
1960 ASSERT0(db->db_level);
1961 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1965 ASSERT3U(db->db_last_dirty->dr_txg, ==, tx->tx_txg);
1966 dl = &db->db_last_dirty->dt.dl;
1975 dl->dr_overridden_by.blk_birth = db->db_last_dirty->dr_txg;
1983 dbuf_assign_arcbuf(dmu_buf_impl_t *db, arc_buf_t *buf, dmu_tx_t *tx)
1985 ASSERT(!refcount_is_zero(&db->db_holds));
1986 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
1987 ASSERT(db->db_level == 0);
1988 ASSERT(DBUF_GET_BUFC_TYPE(db) == ARC_BUFC_DATA);
1990 ASSERT(arc_buf_size(buf) == db->db.db_size);
1993 arc_return_buf(buf, db);
1996 mutex_enter(&db->db_mtx);
1998 while (db->db_state == DB_READ || db->db_state == DB_FILL)
1999 cv_wait(&db->db_changed, &db->db_mtx);
2001 ASSERT(db->db_state == DB_CACHED || db->db_state == DB_UNCACHED);
2003 if (db->db_state == DB_CACHED &&
2004 refcount_count(&db->db_holds) - 1 > db->db_dirtycnt) {
2005 mutex_exit(&db->db_mtx);
2006 (void) dbuf_dirty(db, tx);
2007 bcopy(buf->b_data, db->db.db_data, db->db.db_size);
2008 arc_buf_destroy(buf, db);
2014 if (db->db_state == DB_CACHED) {
2015 dbuf_dirty_record_t *dr = db->db_last_dirty;
2017 ASSERT(db->db_buf != NULL);
2019 ASSERT(dr->dt.dl.dr_data == db->db_buf);
2020 if (!arc_released(db->db_buf)) {
2023 arc_release(db->db_buf, db);
2026 arc_buf_destroy(db->db_buf, db);
2027 } else if (dr == NULL || dr->dt.dl.dr_data != db->db_buf) {
2028 arc_release(db->db_buf, db);
2029 arc_buf_destroy(db->db_buf, db);
2031 db->db_buf = NULL;
2033 ASSERT(db->db_buf == NULL);
2034 dbuf_set_data(db, buf);
2035 db->db_state = DB_FILL;
2036 mutex_exit(&db->db_mtx);
2037 (void) dbuf_dirty(db, tx);
2038 dmu_buf_fill_done(&db->db, tx);
2042 dbuf_destroy(dmu_buf_impl_t *db)
2045 dmu_buf_impl_t *parent = db->db_parent;
2048 ASSERT(MUTEX_HELD(&db->db_mtx));
2049 ASSERT(refcount_is_zero(&db->db_holds));
2051 if (db->db_buf != NULL) {
2052 arc_buf_destroy(db->db_buf, db);
2053 db->db_buf = NULL;
2056 if (db->db_blkid == DMU_BONUS_BLKID) {
2057 ASSERT(db->db.db_data != NULL);
2058 zio_buf_free(db->db.db_data, DN_MAX_BONUSLEN);
2060 db->db_state = DB_UNCACHED;
2063 dbuf_clear_data(db);
2065 if (multilist_link_active(&db->db_cache_link)) {
2066 multilist_remove(&dbuf_cache, db);
2068 db->db.db_size, db);
2071 ASSERT(db->db_state == DB_UNCACHED || db->db_state == DB_NOFILL);
2072 ASSERT(db->db_data_pending == NULL);
2074 db->db_state = DB_EVICTING;
2075 db->db_blkptr = NULL;
2082 mutex_exit(&db->db_mtx);
2084 DB_DNODE_ENTER(db);
2085 dn = DB_DNODE(db);
2087 if (db->db_blkid != DMU_BONUS_BLKID) {
2091 avl_remove(&dn->dn_dbufs, db);
2094 DB_DNODE_EXIT(db);
2105 dnode_rele(dn, db);
2106 db->db_dnode_handle = NULL;
2108 dbuf_hash_remove(db);
2110 DB_DNODE_EXIT(db);
2113 ASSERT(refcount_is_zero(&db->db_holds));
2115 db->db_parent = NULL;
2117 ASSERT(db->db_buf == NULL);
2118 ASSERT(db->db.db_data == NULL);
2119 ASSERT(db->db_hash_next == NULL);
2120 ASSERT(db->db_blkptr == NULL);
2121 ASSERT(db->db_data_pending == NULL);
2122 ASSERT(!multilist_link_active(&db->db_cache_link));
2124 kmem_cache_free(dbuf_kmem_cache, db);
2132 dbuf_rele(parent, db);
2191 *bpp = ((blkptr_t *)(*parentp)->db.db_data) +
2213 dmu_buf_impl_t *db, *odb;
2218 db = kmem_cache_alloc(dbuf_kmem_cache, KM_SLEEP);
2220 db->db_objset = os;
2221 db->db.db_object = dn->dn_object;
2222 db->db_level = level;
2223 db->db_blkid = blkid;
2224 db->db_last_dirty = NULL;
2225 db->db_dirtycnt = 0;
2226 db->db_dnode_handle = dn->dn_handle;
2227 db->db_parent = parent;
2228 db->db_blkptr = blkptr;
2230 db->db_user = NULL;
2231 db->db_user_immediate_evict = FALSE;
2232 db->db_freed_in_flight = FALSE;
2233 db->db_pending_evict = FALSE;
2237 db->db.db_size = DN_MAX_BONUSLEN -
2239 ASSERT3U(db->db.db_size, >=, dn->dn_bonuslen);
2240 db->db.db_offset = DMU_BONUS_BLKID;
2241 db->db_state = DB_UNCACHED;
2244 return (db);
2246 db->db.db_size = (blkptr != NULL) ?
2248 db->db.db_offset = 0;
2251 db->db_level ? 1 << dn->dn_indblkshift : dn->dn_datablksz;
2252 db->db.db_size = blocksize;
2253 db->db.db_offset = db->db_blkid * blocksize;
2264 db->db_state = DB_EVICTING;
2265 if ((odb = dbuf_hash_insert(db)) != NULL) {
2267 kmem_cache_free(dbuf_kmem_cache, db);
2271 avl_add(&dn->dn_dbufs, db);
2273 db->db_state = DB_UNCACHED;
2278 dbuf_add_ref(parent, db);
2282 (void) refcount_add(&dn->dn_holds, db);
2285 dprintf_dbuf(db, "db=%p\n", db);
2287 return (db);
2359 dmu_buf_impl_t *db = dbuf_hold_level(dpa->dpa_dnode,
2361 (void) dbuf_read(db, NULL,
2363 dbuf_rele(db, FTAG);
2431 dmu_buf_impl_t *db = dbuf_find(dn->dn_objset, dn->dn_object,
2433 if (db != NULL) {
2434 mutex_exit(&db->db_mtx);
2452 dmu_buf_impl_t *db;
2455 FALSE, TRUE, FTAG, &db) == 0) {
2456 blkptr_t *bpp = db->db_buf->b_data;
2458 dbuf_rele(db, FTAG);
2529 dmu_buf_impl_t *db, *parent = NULL;
2538 db = dbuf_find(dn->dn_objset, dn->dn_object, level, blkid);
2540 if (db == NULL) {
2560 db = dbuf_create(dn, level, blkid, parent, bp);
2563 if (fail_uncached && db->db_state != DB_CACHED) {
2564 mutex_exit(&db->db_mtx);
2568 if (db->db_buf != NULL)
2569 ASSERT3P(db->db.db_data, ==, db->db_buf->b_data);
2571 ASSERT(db->db_buf == NULL || arc_referenced(db->db_buf));
2578 if (db->db_level == 0 && db->db_blkid != DMU_BONUS_BLKID &&
2580 db->db_state == DB_CACHED && db->db_data_pending) {
2581 dbuf_dirty_record_t *dr = db->db_data_pending;
2583 if (dr->dt.dl.dr_data == db->db_buf) {
2584 arc_buf_contents_t type = DBUF_GET_BUFC_TYPE(db);
2586 dbuf_set_data(db,
2588 db->db.db_size, db, type));
2589 bcopy(dr->dt.dl.dr_data->b_data, db->db.db_data,
2590 db->db.db_size);
2594 if (multilist_link_active(&db->db_cache_link)) {
2595 ASSERT(refcount_is_zero(&db->db_holds));
2596 multilist_remove(&dbuf_cache, db);
2598 db->db.db_size, db);
2600 (void) refcount_add(&db->db_holds, tag);
2601 DBUF_VERIFY(db);
2602 mutex_exit(&db->db_mtx);
2608 ASSERT3P(DB_DNODE(db), ==, dn);
2609 ASSERT3U(db->db_blkid, ==, blkid);
2610 ASSERT3U(db->db_level, ==, level);
2611 *dbp = db;
2625 dmu_buf_impl_t *db;
2626 int err = dbuf_hold_impl(dn, level, blkid, FALSE, FALSE, tag, &db);
2627 return (err ? NULL : db);
2642 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
2645 if (db->db_blkid != DMU_SPILL_BLKID)
2649 ASSERT3U(blksz, <=, spa_maxblocksize(dmu_objset_spa(db->db_objset)));
2652 DB_DNODE_ENTER(db);
2653 dn = DB_DNODE(db);
2655 dbuf_new_size(db, blksz, tx);
2657 DB_DNODE_EXIT(db);
2670 dbuf_add_ref(dmu_buf_impl_t *db, void *tag)
2672 int64_t holds = refcount_add(&db->db_holds, tag);
2681 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
2685 if (db->db_blkid == DMU_BONUS_BLKID)
2691 if (db == found_db && dbuf_refcount(db) > db->db_dirtycnt) {
2692 (void) refcount_add(&db->db_holds, tag);
2695 mutex_exit(&db->db_mtx);
2708 dbuf_rele(dmu_buf_impl_t *db, void *tag)
2710 mutex_enter(&db->db_mtx);
2711 dbuf_rele_and_unlock(db, tag);
2715 dmu_buf_rele(dmu_buf_t *db, void *tag)
2717 dbuf_rele((dmu_buf_impl_t *)db, tag);
2725 dbuf_rele_and_unlock(dmu_buf_impl_t *db, void *tag)
2729 ASSERT(MUTEX_HELD(&db->db_mtx));
2730 DBUF_VERIFY(db);
2737 holds = refcount_remove(&db->db_holds, tag);
2744 if (db->db_buf != NULL &&
2745 holds == (db->db_level == 0 ? db->db_dirtycnt : 0)) {
2746 arc_buf_freeze(db->db_buf);
2749 if (holds == db->db_dirtycnt &&
2750 db->db_level == 0 && db->db_user_immediate_evict)
2751 dbuf_evict_user(db);
2754 if (db->db_blkid == DMU_BONUS_BLKID) {
2756 boolean_t evict_dbuf = db->db_pending_evict;
2762 DB_DNODE_ENTER(db);
2764 dn = DB_DNODE(db);
2773 DB_DNODE_EXIT(db);
2776 * Do not reference db after its lock is dropped.
2779 mutex_exit(&db->db_mtx);
2784 dnode_rele(dn, db);
2785 } else if (db->db_buf == NULL) {
2790 ASSERT(db->db_state == DB_UNCACHED ||
2791 db->db_state == DB_NOFILL);
2792 dbuf_destroy(db);
2793 } else if (arc_released(db->db_buf)) {
2797 dbuf_destroy(db);
2801 spa_t *spa = dmu_objset_spa(db->db_objset);
2803 if (!DBUF_IS_CACHEABLE(db) &&
2804 db->db_blkptr != NULL &&
2805 !BP_IS_HOLE(db->db_blkptr) &&
2806 !BP_IS_EMBEDDED(db->db_blkptr)) {
2808 bp = *db->db_blkptr;
2811 if (!DBUF_IS_CACHEABLE(db) ||
2812 db->db_pending_evict) {
2813 dbuf_destroy(db);
2814 } else if (!multilist_link_active(&db->db_cache_link)) {
2815 multilist_insert(&dbuf_cache, db);
2817 db->db.db_size, db);
2818 mutex_exit(&db->db_mtx);
2827 mutex_exit(&db->db_mtx);
2834 dbuf_refcount(dmu_buf_impl_t *db)
2836 return (refcount_count(&db->db_holds));
2843 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
2845 mutex_enter(&db->db_mtx);
2846 dbuf_verify_user(db, DBVU_NOT_EVICTING);
2847 if (db->db_user == old_user)
2848 db->db_user = new_user;
2850 old_user = db->db_user;
2851 dbuf_verify_user(db, DBVU_NOT_EVICTING);
2852 db->db_mtx);
2866 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
2868 db->db_user_immediate_evict = TRUE;
2881 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
2883 dbuf_verify_user(db, DBVU_NOT_EVICTING);
2884 return (db->db_user);
2897 dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbuf;
2899 if (db->db_blkptr)
2900 res = dsl_dataset_block_freeable(db->db_objset->os_dsl_dataset,
2901 db->db_blkptr, db->db_blkptr->blk_birth);
2907 dmu_buf_get_blkptr(dmu_buf_t *db)
2909 dmu_buf_impl_t *dbi = (dmu_buf_impl_t *)db;
2914 dmu_buf_get_objset(dmu_buf_t *db)
2916 dmu_buf_impl_t *dbi = (dmu_buf_impl_t *)db;
2921 dmu_buf_dnode_enter(dmu_buf_t *db)
2923 dmu_buf_impl_t *dbi = (dmu_buf_impl_t *)db;
2929 dmu_buf_dnode_exit(dmu_buf_t *db)
2931 dmu_buf_impl_t *dbi = (dmu_buf_impl_t *)db;
2936 dbuf_check_blkptr(dnode_t *dn, dmu_buf_impl_t *db)
2939 ASSERT(MUTEX_HELD(&db->db_mtx));
2941 if (db->db_blkptr != NULL)
2944 if (db->db_blkid == DMU_SPILL_BLKID) {
2945 db->db_blkptr = &dn->dn_phys->dn_spill;
2946 BP_ZERO(db->db_blkptr);
2949 if (db->db_level == dn->dn_phys->dn_nlevels-1) {
2955 ASSERT(db->db_blkid < dn->dn_phys->dn_nblkptr);
2956 ASSERT(db->db_parent == NULL);
2957 db->db_parent = dn->dn_dbuf;
2958 db->db_blkptr = &dn->dn_phys->dn_blkptr[db->db_blkid];
2959 DBUF_VERIFY(db);
2961 dmu_buf_impl_t *parent = db->db_parent;
2966 mutex_exit(&db->db_mtx);
2968 parent = dbuf_hold_level(dn, db->db_level + 1,
2969 db->db_blkid >> epbs, db);
2971 mutex_enter(&db->db_mtx);
2972 db->db_parent = parent;
2974 db->db_blkptr = (blkptr_t *)parent->db.db_data +
2975 (db->db_blkid & ((1ULL << epbs) - 1));
2976 DBUF_VERIFY(db);
2983 dmu_buf_impl_t *db = dr->dr_dbuf;
2989 dprintf_dbuf_bp(db, db->db_blkptr, "blkptr=%p", db->db_blkptr);
2991 mutex_enter(&db->db_mtx);
2993 ASSERT(db->db_level > 0);
2994 DBUF_VERIFY(db);
2997 if (db->db_buf == NULL) {
2998 mutex_exit(&db->db_mtx);
2999 (void) dbuf_read(db, NULL, DB_RF_MUST_SUCCEED);
3000 mutex_enter(&db->db_mtx);
3002 ASSERT3U(db->db_state, ==, DB_CACHED);
3003 ASSERT(db->db_buf != NULL);
3005 DB_DNODE_ENTER(db);
3006 dn = DB_DNODE(db);
3008 ASSERT3U(db->db.db_size, ==, 1<<dn->dn_phys->dn_indblkshift);
3009 dbuf_check_blkptr(dn, db);
3010 DB_DNODE_EXIT(db);
3013 db->db_data_pending = dr;
3015 mutex_exit(&db->db_mtx);
3016 dbuf_write(dr, db->db_buf, tx);
3020 dbuf_sync_list(&dr->dt.di.dr_children, db->db_level - 1, tx);
3030 dmu_buf_impl_t *db = dr->dr_dbuf;
3037 dprintf_dbuf_bp(db, db->db_blkptr, "blkptr=%p", db->db_blkptr);
3039 mutex_enter(&db->db_mtx);
3044 if (db->db_state == DB_UNCACHED) {
3046 ASSERT(db->db.db_data == NULL);
3047 } else if (db->db_state == DB_FILL) {
3049 ASSERT(db->db.db_data != dr->dt.dl.dr_data);
3051 ASSERT(db->db_state == DB_CACHED || db->db_state == DB_NOFILL);
3053 DBUF_VERIFY(db);
3055 DB_DNODE_ENTER(db);
3056 dn = DB_DNODE(db);
3058 if (db->db_blkid == DMU_SPILL_BLKID) {
3070 if (db->db_blkid == DMU_BONUS_BLKID) {
3074 ASSERT0(db->db_level);
3077 DB_DNODE_EXIT(db);
3079 if (*datap != db->db.db_data) {
3083 db->db_data_pending = NULL;
3084 drp = &db->db_last_dirty;
3088 ASSERT(dr->dr_dbuf == db);
3095 ASSERT(db->db_dirtycnt > 0);
3096 db->db_dirtycnt -= 1;
3097 dbuf_rele_and_unlock(db, (void *)(uintptr_t)txg);
3109 dbuf_check_blkptr(dn, db);
3117 cv_wait(&db->db_changed, &db->db_mtx);
3121 if (db->db_state != DB_NOFILL &&
3123 refcount_count(&db->db_holds) > 1 &&
3125 *datap == db->db_buf) {
3138 arc_buf_contents_t type = DBUF_GET_BUFC_TYPE(db);
3139 *datap = arc_alloc_buf(os->os_spa, blksz, db, type);
3140 bcopy(db->db.db_data, (*datap)->b_data, blksz);
3142 db->db_data_pending = dr;
3144 mutex_exit(&db->db_mtx);
3151 DB_DNODE_EXIT(db);
3160 DB_DNODE_EXIT(db);
3179 ASSERT3U(dr->dr_dbuf->db.db_object, ==,
3199 dmu_buf_impl_t *db = vdb;
3208 ASSERT3P(db->db_blkptr, !=, NULL);
3209 ASSERT3P(&db->db_data_pending->dr_bp_copy, ==, bp);
3211 DB_DNODE_ENTER(db);
3212 dn = DB_DNODE(db);
3218 ASSERT((db->db_blkid != DMU_SPILL_BLKID &&
3220 (db->db_blkid == DMU_SPILL_BLKID &&
3223 ASSERT(BP_GET_LEVEL(bp) == db->db_level);
3226 mutex_enter(&db->db_mtx);
3229 if (db->db_blkid == DMU_SPILL_BLKID) {
3232 db->db_blkptr == &dn->dn_phys->dn_spill);
3236 if (db->db_level == 0) {
3238 if (db->db_blkid > dn->dn_phys->dn_maxblkid &&
3239 db->db_blkid != DMU_SPILL_BLKID)
3240 dn->dn_phys->dn_maxblkid = db->db_blkid;
3244 dnode_phys_t *dnp = db->db.db_data;
3245 for (i = db->db.db_size >> DNODE_SHIFT; i > 0;
3258 blkptr_t *ibp = db->db.db_data;
3259 ASSERT3U(db->db.db_size, ==, 1<<dn->dn_phys->dn_indblkshift);
3260 for (i = db->db.db_size >> SPA_BLKPTRSHIFT; i > 0; i--, ibp++) {
3266 DB_DNODE_EXIT(db);
3271 mutex_exit(&db->db_mtx);
3274 *db->db_blkptr = *bp;
3289 dmu_buf_impl_t *db = vdb;
3295 ASSERT3U(db->db_level, >, 0);
3296 DB_DNODE_ENTER(db);
3297 dn = DB_DNODE(db);
3301 for (i = 0, bp = db->db.db_data; i < 1 << epbs; i++, bp++) {
3312 bzero(db->db.db_data, db->db.db_size);
3314 DB_DNODE_EXIT(db);
3330 dmu_buf_impl_t *db = arg;
3331 objset_t *os = db->db_objset;
3336 dr = db->db_data_pending;
3353 dmu_buf_impl_t *db = vdb;
3355 blkptr_t *bp = db->db_blkptr;
3356 objset_t *os = db->db_objset;
3361 ASSERT(db->db_blkptr == bp);
3375 mutex_enter(&db->db_mtx);
3377 DBUF_VERIFY(db);
3379 drp = &db->db_last_dirty;
3380 while ((dr = *drp) != db->db_data_pending)
3383 ASSERT(dr->dr_dbuf == db);
3388 if (db->db_blkid == DMU_SPILL_BLKID) {
3391 DB_DNODE_ENTER(db);
3392 dn = DB_DNODE(db);
3394 ASSERT(!(BP_IS_HOLE(db->db_blkptr)) &&
3395 db->db_blkptr == &dn->dn_phys->dn_spill);
3396 DB_DNODE_EXIT(db);
3400 if (db->db_level == 0) {
3401 ASSERT(db->db_blkid != DMU_BONUS_BLKID);
3403 if (db->db_state != DB_NOFILL) {
3404 if (dr->dt.dl.dr_data != db->db_buf)
3405 arc_buf_destroy(dr->dt.dl.dr_data, db);
3410 DB_DNODE_ENTER(db);
3411 dn = DB_DNODE(db);
3413 ASSERT3U(db->db.db_size, ==, 1 << dn->dn_phys->dn_indblkshift);
3414 if (!BP_IS_HOLE(db->db_blkptr)) {
3417 ASSERT3U(db->db_blkid, <=,
3418 dn->dn_phys->dn_maxblkid >> (db->db_level * epbs));
3419 ASSERT3U(BP_GET_LSIZE(db->db_blkptr), ==,
3420 db->db.db_size);
3422 DB_DNODE_EXIT(db);
3428 cv_broadcast(&db->db_changed);
3429 ASSERT(db->db_dirtycnt > 0);
3430 db->db_dirtycnt -= 1;
3431 db->db_data_pending = NULL;
3432 dbuf_rele_and_unlock(db, (void *)(uintptr_t)tx->tx_txg);
3451 dmu_buf_impl_t *db = dr->dr_dbuf;
3453 dbuf_write_ready(zio, NULL, db);
3460 dmu_buf_impl_t *db = dr->dr_dbuf;
3463 mutex_enter(&db->db_mtx);
3467 arc_release(dr->dt.dl.dr_data, db);
3469 mutex_exit(&db->db_mtx);
3471 dbuf_write_done(zio, NULL, db);
3478 dmu_buf_impl_t *db = dr->dr_dbuf;
3481 dmu_buf_impl_t *parent = db->db_parent;
3490 DB_DNODE_ENTER(db);
3491 dn = DB_DNODE(db);
3494 if (db->db_state != DB_NOFILL) {
3495 if (db->db_level > 0 || dn->dn_type == DMU_OT_DNODE) {
3502 if (BP_IS_HOLE(db->db_blkptr)) {
3505 dbuf_release_bp(db);
3515 ASSERT(db->db_level == parent->db_level-1);
3524 ASSERT((db->db_level == dn->dn_phys->dn_nlevels-1 &&
3525 db->db_blkid != DMU_SPILL_BLKID) ||
3526 (db->db_blkid == DMU_SPILL_BLKID && db->db_level == 0));
3527 if (db->db_blkid != DMU_SPILL_BLKID)
3528 ASSERT3P(db->db_blkptr, ==,
3529 &dn->dn_phys->dn_blkptr[db->db_blkid]);
3533 ASSERT(db->db_level == 0 || data == db->db_buf);
3534 ASSERT3U(db->db_blkptr->blk_birth, <=, txg);
3539 db->db.db_object, db->db_level, db->db_blkid);
3541 if (db->db_blkid == DMU_SPILL_BLKID)
3543 wp_flag |= (db->db_state == DB_NOFILL) ? WP_NOFILL : 0;
3545 dmu_write_policy(os, dn, db->db_level, wp_flag, &zp);
3546 DB_DNODE_EXIT(db);
3554 dr->dr_bp_copy = *db->db_blkptr;
3556 if (db->db_level == 0 &&
3565 &dr->dr_bp_copy, contents, db->db.db_size, &zp,
3569 mutex_enter(&db->db_mtx);
3573 mutex_exit(&db->db_mtx);
3574 } else if (db->db_state == DB_NOFILL) {
3578 &dr->dr_bp_copy, NULL, db->db.db_size, &zp,
3580 dbuf_write_nofill_done, db,
3592 if (db->db_level != 0)
3596 &dr->dr_bp_copy, data, DBUF_IS_L2CACHEABLE(db),
3598 dbuf_write_physdone, dbuf_write_done, db,
Indexes created Sat Feb 28 05:31:39 UTC 2026