Lines Matching defs:dn
373 dnode_t *dn;
376 if (dnode_hold(os, object, FTAG, &dn) == 0) {
377 rw_enter(&dn->dn_struct_rwlock, RW_READER);
378 if (dn->dn_bonus != NULL) {
379 db = dn->dn_bonus;
382 rw_exit(&dn->dn_struct_rwlock);
383 dnode_rele(dn, FTAG);
666 dnode_level_is_l2cacheable(blkptr_t *bp, dnode_t *dn, int64_t level)
668 if (dn->dn_objset->os_secondary_cache == ZFS_CACHE_ALL ||
669 (dn->dn_objset->os_secondary_cache == ZFS_CACHE_METADATA &&
671 DMU_OT_IS_METADATA(dn->dn_handle->dnh_dnode->dn_type)))) {
678 vdev_t *rvd = dn->dn_objset->os_spa->spa_root_vdev;
1096 dnode_t *dn;
1107 dn = DB_DNODE(db);
1108 if (dn == NULL) {
1112 ASSERT3U(db->db.db_object, ==, dn->dn_object);
1113 ASSERT3P(db->db_objset, ==, dn->dn_objset);
1114 ASSERT3U(db->db_level, <, dn->dn_nlevels);
1117 !avl_is_empty(&dn->dn_dbufs));
1120 ASSERT(dn != NULL);
1121 ASSERT3U(db->db.db_size, >=, dn->dn_bonuslen);
1124 ASSERT(dn != NULL);
1157 if (db->db_parent == dn->dn_dbuf) {
1159 /* ASSERT3U(db->db_blkid, <, dn->dn_nblkptr); */
1166 &dn->dn_phys->dn_blkptr[db->db_blkid]);
1189 db->db_state != DB_FILL && (dn == NULL || !dn->dn_free_txg)) {
1308 dbuf_whichblock(const dnode_t *dn, const int64_t level, const uint64_t offset)
1310 if (dn->dn_datablkshift != 0 && dn->dn_indblkshift != 0) {
1331 const unsigned exp = dn->dn_datablkshift +
1332 level * (dn->dn_indblkshift - SPA_BLKPTRSHIFT);
1336 ASSERT3U(level, ==, dn->dn_nlevels - 1);
1344 ASSERT3U(offset, <, dn->dn_datablksz);
1437 dbuf_read_bonus(dmu_buf_impl_t *db, dnode_t *dn)
1441 bonuslen = MIN(dn->dn_bonuslen, dn->dn_phys->dn_bonuslen);
1442 max_bonuslen = DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots);
1451 memcpy(db->db.db_data, DN_BONUS(dn->dn_phys), bonuslen);
1458 dbuf_handle_indirect_hole(dmu_buf_impl_t *db, dnode_t *dn, blkptr_t *dbbp)
1461 uint32_t indbs = 1ULL << dn->dn_indblkshift;
1469 dn->dn_datablksz : BP_GET_LSIZE(dbbp));
1482 dbuf_read_hole(dmu_buf_impl_t *db, dnode_t *dn, blkptr_t *bp)
1494 is_hole = dnode_block_freed(dn, db->db_blkid) || BP_IS_HOLE(bp);
1502 dbuf_handle_indirect_hole(db, dn, bp);
1524 dbuf_read_verify_dnode_crypt(dmu_buf_impl_t *db, dnode_t *dn, uint32_t flags)
1534 (dndb = dn->dn_dbuf) == NULL)
1571 !DMU_OT_IS_ENCRYPTED(dn->dn_type)) ||
1573 !DMU_OT_IS_ENCRYPTED(dn->dn_bonustype))))
1586 dbuf_read_impl(dmu_buf_impl_t *db, dnode_t *dn, zio_t *zio, uint32_t flags,
1601 err = dbuf_read_bonus(db, dn);
1605 err = dbuf_read_hole(db, dn, bp);
1711 dnode_t *dn = DB_DNODE(db);
1712 int bonuslen = DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots);
1717 dnode_t *dn = DB_DNODE(db);
1734 dmu_objset_id(dn->dn_objset), byteorder, salt, iv,
1735 mac, dn->dn_type, size, arc_buf_lsize(db->db_buf),
1755 dnode_t *dn;
1762 dn = DB_DNODE(db);
1768 err = dbuf_read_verify_dnode_crypt(db, dn, flags);
1823 spa_t *spa = dn->dn_objset->os_spa;
1849 spa_t *spa = dn->dn_objset->os_spa;
1856 dbuf_read_impl(db, dn, pio, flags, dblt, bp, FTAG);
1866 dmu_zfetch(&dn->dn_zfetch, db->db_blkid, 1, B_TRUE, miss,
1978 dbuf_free_range(dnode_t *dn, uint64_t start_blkid, uint64_t end_blkid,
1987 if (end_blkid > dn->dn_maxblkid &&
1989 end_blkid = dn->dn_maxblkid;
1990 dprintf_dnode(dn, "start=%llu end=%llu\n", (u_longlong_t)start_blkid,
1998 mutex_enter(&dn->dn_dbufs_mtx);
1999 db = avl_find(&dn->dn_dbufs, db_search, &where);
2002 db = avl_nearest(&dn->dn_dbufs, where, AVL_AFTER);
2005 db_next = AVL_NEXT(&dn->dn_dbufs, db);
2049 db->db_blkid > dn->dn_maxblkid)
2050 dn->dn_maxblkid = db->db_blkid;
2075 mutex_exit(&dn->dn_dbufs_mtx);
2086 dnode_t *dn;
2091 dn = DB_DNODE(db);
2102 buf = arc_alloc_buf(dn->dn_objset->os_spa, db, type, size);
2126 dmu_objset_willuse_space(dn->dn_objset, size - osize, tx);
2170 dbuf_dirty_lightweight(dnode_t *dn, uint64_t blkid, dmu_tx_t *tx)
2172 rw_enter(&dn->dn_struct_rwlock, RW_READER);
2173 IMPLY(dn->dn_objset->os_raw_receive, dn->dn_maxblkid >= blkid);
2174 dnode_new_blkid(dn, blkid, tx, B_TRUE, B_FALSE);
2175 ASSERT(dn->dn_maxblkid >= blkid);
2180 dr->dr_dnode = dn;
2183 dr->dr_accounted = dn->dn_datablksz;
2190 ASSERT3P(NULL, ==, dbuf_find(dn->dn_objset, dn->dn_object, 0, blkid,
2193 mutex_enter(&dn->dn_mtx);
2195 if (dn->dn_free_ranges[txgoff] != NULL) {
2196 range_tree_clear(dn->dn_free_ranges[txgoff], blkid, 1);
2199 if (dn->dn_nlevels == 1) {
2200 ASSERT3U(blkid, <, dn->dn_nblkptr);
2201 list_insert_tail(&dn->dn_dirty_records[txgoff], dr);
2202 mutex_exit(&dn->dn_mtx);
2203 rw_exit(&dn->dn_struct_rwlock);
2204 dnode_setdirty(dn, tx);
2206 mutex_exit(&dn->dn_mtx);
2208 int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
2209 dmu_buf_impl_t *parent_db = dbuf_hold_level(dn,
2211 rw_exit(&dn->dn_struct_rwlock);
2233 dmu_objset_willuse_space(dn->dn_objset, dr->dr_accounted, tx);
2241 dnode_t *dn;
2252 dn = DB_DNODE(db);
2259 if (dn->dn_objset->os_dsl_dataset != NULL) {
2260 rrw_enter(&dn->dn_objset->os_dsl_dataset->ds_bp_rwlock,
2264 BP_IS_HOLE(dn->dn_objset->os_rootbp) ||
2265 DMU_OBJECT_IS_SPECIAL(dn->dn_object) ||
2266 dn->dn_objset->os_dsl_dataset == NULL);
2267 if (dn->dn_objset->os_dsl_dataset != NULL)
2268 rrw_exit(&dn->dn_objset->os_dsl_dataset->ds_bp_rwlock, FTAG);
2275 ASSERT(dn->dn_object == DMU_META_DNODE_OBJECT ||
2276 dn->dn_dirtyctx == DN_UNDIRTIED || dn->dn_dirtyctx ==
2289 mutex_enter(&dn->dn_mtx);
2290 dnode_set_dirtyctx(dn, tx, db);
2291 if (tx->tx_txg > dn->dn_dirty_txg)
2292 dn->dn_dirty_txg = tx->tx_txg;
2293 mutex_exit(&dn->dn_mtx);
2296 dn->dn_have_spill = B_TRUE;
2316 ASSERT(dn->dn_object == 0 ||
2317 dn->dn_dirtyctx == DN_UNDIRTIED || dn->dn_dirtyctx ==
2320 ASSERT3U(dn->dn_nlevels, >, db->db_level);
2329 os = dn->dn_objset;
2332 if (dn->dn_objset->os_dsl_dataset != NULL)
2334 ASSERT(!dmu_tx_is_syncing(tx) || DMU_OBJECT_IS_SPECIAL(dn->dn_object) ||
2336 if (dn->dn_objset->os_dsl_dataset != NULL)
2356 dr->dr_dnode = dn;
2401 mutex_enter(&dn->dn_mtx);
2402 if (dn->dn_free_ranges[txgoff] != NULL) {
2403 range_tree_clear(dn->dn_free_ranges[txgoff],
2406 mutex_exit(&dn->dn_mtx);
2421 mutex_enter(&dn->dn_mtx);
2423 list_insert_tail(&dn->dn_dirty_records[txgoff], dr);
2424 mutex_exit(&dn->dn_mtx);
2425 dnode_setdirty(dn, tx);
2430 if (!RW_WRITE_HELD(&dn->dn_struct_rwlock)) {
2431 rw_enter(&dn->dn_struct_rwlock, RW_READER);
2451 ASSERT((dn->dn_phys->dn_nlevels == 0 && db->db_level == 0) ||
2452 dn->dn_phys->dn_nlevels > db->db_level ||
2453 dn->dn_next_nlevels[txgoff] > db->db_level ||
2454 dn->dn_next_nlevels[(tx->tx_txg-1) & TXG_MASK] > db->db_level ||
2455 dn->dn_next_nlevels[(tx->tx_txg-2) & TXG_MASK] > db->db_level);
2460 dn->dn_maxblkid >= db->db_blkid);
2461 dnode_new_blkid(dn, db->db_blkid, tx,
2463 ASSERT(dn->dn_maxblkid >= db->db_blkid);
2466 if (db->db_level+1 < dn->dn_nlevels) {
2471 if (db->db_parent == NULL || db->db_parent == dn->dn_dbuf) {
2472 int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
2473 parent = dbuf_hold_level(dn, db->db_level + 1,
2479 rw_exit(&dn->dn_struct_rwlock);
2491 dn->dn_object == DMU_META_DNODE_OBJECT) {
2501 ASSERT(db->db_level + 1 == dn->dn_nlevels);
2502 ASSERT(db->db_blkid < dn->dn_nblkptr);
2503 ASSERT(db->db_parent == NULL || db->db_parent == dn->dn_dbuf);
2504 mutex_enter(&dn->dn_mtx);
2506 list_insert_tail(&dn->dn_dirty_records[txgoff], dr);
2507 mutex_exit(&dn->dn_mtx);
2509 rw_exit(&dn->dn_struct_rwlock);
2512 dnode_setdirty(dn, tx);
2523 struct dnode *dn = dr->dr_dnode;
2524 int max_bonuslen = DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots);
2590 dnode_t *dn = dr->dr_dnode;
2596 dsl_pool_undirty_space(dmu_objset_pool(dn->dn_objset),
2612 db->db_level + 1 == dn->dn_nlevels) {
2613 ASSERT(db->db_blkptr == NULL || db->db_parent == dn->dn_dbuf);
2614 mutex_enter(&dn->dn_mtx);
2615 list_remove(&dn->dn_dirty_records[txg & TXG_MASK], dr);
2616 mutex_exit(&dn->dn_mtx);
2768 dnode_t *dn = DB_DNODE(db);
2777 err = dbuf_read_verify_dnode_crypt(db, dn, 0);
3178 dnode_t *dn;
3241 dn = DB_DNODE(db);
3242 dndb = dn->dn_dbuf;
3244 boolean_t needlock = !MUTEX_HELD(&dn->dn_dbufs_mtx);
3246 mutex_enter_nested(&dn->dn_dbufs_mtx,
3248 avl_remove(&dn->dn_dbufs, db);
3252 mutex_exit(&dn->dn_dbufs_mtx);
3261 mutex_enter(&dn->dn_mtx);
3262 dnode_rele_and_unlock(dn, db, B_TRUE);
3307 dbuf_findbp(dnode_t *dn, int level, uint64_t blkid, int fail_sparse,
3316 mutex_enter(&dn->dn_mtx);
3317 if (dn->dn_have_spill &&
3318 (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR))
3319 *bpp = DN_SPILL_BLKPTR(dn->dn_phys);
3322 dbuf_add_ref(dn->dn_dbuf, NULL);
3323 *parentp = dn->dn_dbuf;
3324 mutex_exit(&dn->dn_mtx);
3329 (dn->dn_phys->dn_nlevels == 0) ? 1 : dn->dn_phys->dn_nlevels;
3330 int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
3333 ASSERT(RW_LOCK_HELD(&dn->dn_struct_rwlock));
3351 highbit64(dn->dn_phys->dn_nblkptr) <= 64);
3353 blkid >= ((uint64_t)dn->dn_phys->dn_nblkptr <<
3356 blkid > (dn->dn_phys->dn_maxblkid >> (level * epbs)))) {
3363 err = dbuf_hold_impl(dn, level + 1,
3378 if (blkid > (dn->dn_phys->dn_maxblkid >> (level * epbs)))
3385 ASSERT(dn->dn_phys->dn_nblkptr == 0 ||
3386 blkid < dn->dn_phys->dn_nblkptr);
3387 if (dn->dn_dbuf) {
3388 dbuf_add_ref(dn->dn_dbuf, NULL);
3389 *parentp = dn->dn_dbuf;
3391 *bpp = &dn->dn_phys->dn_blkptr[blkid];
3397 dbuf_create(dnode_t *dn, uint8_t level, uint64_t blkid,
3400 objset_t *os = dn->dn_objset;
3403 ASSERT(RW_LOCK_HELD(&dn->dn_struct_rwlock));
3404 ASSERT(dn->dn_type != DMU_OT_NONE);
3412 db->db.db_object = dn->dn_object;
3417 db->db_dnode_handle = dn->dn_handle;
3419 db->db_dnode = dn;
3431 ASSERT3P(parent, ==, dn->dn_dbuf);
3432 db->db.db_size = DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots) -
3433 (dn->dn_nblkptr-1) * sizeof (blkptr_t);
3434 ASSERT3U(db->db.db_size, >=, dn->dn_bonuslen);
3448 db->db_level ? 1 << dn->dn_indblkshift : dn->dn_datablksz;
3460 mutex_enter(&dn->dn_dbufs_mtx);
3464 mutex_exit(&dn->dn_dbufs_mtx);
3469 avl_add(&dn->dn_dbufs, db);
3474 mutex_exit(&dn->dn_dbufs_mtx);
3477 if (parent && parent != dn->dn_dbuf)
3480 ASSERT(dn->dn_object == DMU_META_DNODE_OBJECT ||
3481 zfs_refcount_count(&dn->dn_holds) > 0);
3482 (void) zfs_refcount_add(&dn->dn_holds, db);
3497 dbuf_dnode_findbp(dnode_t *dn, uint64_t level, uint64_t blkid,
3503 ASSERT(RW_LOCK_HELD(&dn->dn_struct_rwlock));
3505 err = dbuf_findbp(dn, level, blkid, B_FALSE, &dbp, &bp2);
3512 *datablkszsec = dn->dn_phys->dn_datablkszsec;
3514 *indblkshift = dn->dn_phys->dn_indblkshift;
3695 dbuf_prefetch_impl(dnode_t *dn, int64_t level, uint64_t blkid,
3704 ASSERT(RW_LOCK_HELD(&dn->dn_struct_rwlock));
3706 if (blkid > dn->dn_maxblkid)
3709 if (level == 0 && dnode_block_freed(dn, blkid))
3716 nlevels = dn->dn_phys->dn_nlevels;
3717 if (level >= nlevels || dn->dn_phys->dn_nblkptr == 0)
3720 epbs = dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
3721 if (dn->dn_phys->dn_maxblkid < blkid << (epbs * level))
3724 dmu_buf_impl_t *db = dbuf_find(dn->dn_objset, dn->dn_object,
3747 if (dbuf_hold_impl(dn, parent_level, parent_blkid,
3761 ASSERT3U(curblkid, <, dn->dn_phys->dn_nblkptr);
3762 bp = dn->dn_phys->dn_blkptr[curblkid];
3765 dsl_dataset_feature_is_active(dn->dn_objset->os_dsl_dataset,
3772 zio_t *pio = zio_root(dmu_objset_spa(dn->dn_objset), NULL, NULL,
3776 dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;
3778 dn->dn_object, level, blkid);
3782 dpa->dpa_spa = dn->dn_objset->os_spa;
3783 dpa->dpa_dnode = dn;
3789 if (!DNODE_LEVEL_IS_CACHEABLE(dn, level))
3791 else if (dnode_level_is_l2cacheable(&bp, dn, level))
3809 if (dnode_level_is_l2cacheable(&bp, dn, level))
3813 dn->dn_object, curlevel, curblkid);
3833 dbuf_prefetch(dnode_t *dn, int64_t level, uint64_t blkid, zio_priority_t prio,
3837 return (dbuf_prefetch_impl(dn, level, blkid, prio, aflags, NULL, NULL));
3849 dbuf_hold_copy(dnode_t *dn, dmu_buf_impl_t *db)
3863 dbuf_set_data(db, arc_alloc_raw_buf(dn->dn_objset->os_spa, db,
3864 dmu_objset_id(dn->dn_objset), byteorder, salt, iv, mac,
3865 dn->dn_type, arc_buf_size(data), arc_buf_lsize(data),
3869 dn->dn_objset->os_spa, db, arc_buf_size(data),
3872 dbuf_set_data(db, arc_alloc_buf(dn->dn_objset->os_spa, db,
3886 dbuf_hold_impl(dnode_t *dn, uint8_t level, uint64_t blkid,
3894 spa_t *spa = dn->dn_objset->os_spa;
3901 ASSERT(RW_LOCK_HELD(&dn->dn_struct_rwlock));
3902 ASSERT3U(dn->dn_nlevels, >, level);
3907 db = dbuf_find(dn->dn_objset, dn->dn_object, level, blkid, &hv);
3917 err = dbuf_findbp(dn, level, blkid, fail_sparse, &parent, &bp);
3929 db = dbuf_create(dn, level, blkid, parent, bp, hv);
3950 dn->dn_object != DMU_META_DNODE_OBJECT &&
3955 dbuf_hold_copy(dn, db);
3992 ASSERT3P(DB_DNODE(db), ==, dn);
4001 dbuf_hold(dnode_t *dn, uint64_t blkid, const void *tag)
4003 return (dbuf_hold_level(dn, 0, blkid, tag));
4007 dbuf_hold_level(dnode_t *dn, int level, uint64_t blkid, const void *tag)
4010 int err = dbuf_hold_impl(dn, level, blkid, FALSE, FALSE, tag, &db);
4015 dbuf_create_bonus(dnode_t *dn)
4017 ASSERT(RW_WRITE_HELD(&dn->dn_struct_rwlock));
4019 ASSERT(dn->dn_bonus == NULL);
4020 dn->dn_bonus = dbuf_create(dn, 0, DMU_BONUS_BLKID, dn->dn_dbuf, NULL,
4021 dbuf_hash(dn->dn_objset, dn->dn_object, 0, DMU_BONUS_BLKID));
4042 dbuf_rm_spill(dnode_t *dn, dmu_tx_t *tx)
4044 dbuf_free_range(dn, DMU_SPILL_BLKID, DMU_SPILL_BLKID, tx);
4144 dnode_t *dn;
4153 dn = DB_DNODE(db);
4154 atomic_dec_32(&dn->dn_dbufs_count);
4171 dnode_evict_bonus(dn);
4173 dnode_rele(dn, db);
4347 dbuf_check_blkptr(dnode_t *dn, dmu_buf_impl_t *db)
4356 db->db_blkptr = DN_SPILL_BLKPTR(dn->dn_phys);
4360 if (db->db_level == dn->dn_phys->dn_nlevels-1) {
4366 ASSERT(db->db_blkid < dn->dn_phys->dn_nblkptr);
4368 db->db_parent = dn->dn_dbuf;
4369 db->db_blkptr = &dn->dn_phys->dn_blkptr[db->db_blkid];
4373 int epbs = dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
4375 ASSERT(dn->dn_phys->dn_nlevels > 1);
4378 rw_enter(&dn->dn_struct_rwlock, RW_READER);
4379 parent = dbuf_hold_level(dn, db->db_level + 1,
4381 rw_exit(&dn->dn_struct_rwlock);
4402 dnode_t *dn = dr->dr_dnode;
4403 ASSERT3U(DN_MAX_BONUS_LEN(dn->dn_phys), <=,
4404 DN_SLOTS_TO_BONUSLEN(dn->dn_phys->dn_extra_slots + 1));
4405 memcpy(DN_BONUS(dn->dn_phys), data, DN_MAX_BONUS_LEN(dn->dn_phys));
4464 dnode_t *dn = dr->dr_dnode;
4485 ASSERT3U(db->db.db_size, ==, 1<<dn->dn_phys->dn_indblkshift);
4486 dbuf_check_blkptr(dn, db);
4520 dnode_t *dn = dr->dr_dnode;
4526 if (DMU_OT_IS_ENCRYPTED(dn->dn_bonustype))
4529 uint16_t bonuslen = dn->dn_phys->dn_bonuslen;
4530 uint16_t maxbonuslen = DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots);
4548 dnode_t *dn = dr->dr_dnode;
4550 if (dn->dn_phys->dn_nlevels == 1) {
4551 VERIFY3U(dr->dt.dll.dr_blkid, <, dn->dn_phys->dn_nblkptr);
4552 return (&dn->dn_phys->dn_blkptr[dr->dt.dll.dr_blkid]);
4555 int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
4557 VERIFY3P(DB_DNODE(parent_db), ==, dn);
4573 dnode_t *dn = dr->dr_dnode;
4576 spa_t *spa = dmu_objset_spa(dn->dn_objset);
4579 dnode_diduse_space(dn, delta);
4582 mutex_enter(&dn->dn_mtx);
4583 if (blkid > dn->dn_phys->dn_maxblkid) {
4584 ASSERT0(dn->dn_objset->os_raw_receive);
4585 dn->dn_phys->dn_maxblkid = blkid;
4587 mutex_exit(&dn->dn_mtx);
4595 EQUIV(dr->dr_parent == NULL, dn->dn_phys->dn_nlevels == 1);
4597 parent_db = dn->dn_dbuf;
4634 dnode_t *dn = dr->dr_dnode;
4636 if (dn->dn_phys->dn_nlevels == 1) {
4637 pio = dn->dn_zio;
4643 .zb_objset = dmu_objset_id(dn->dn_objset),
4644 .zb_object = dn->dn_object,
4655 dr->dr_zio = zio_write(pio, dmu_objset_spa(dn->dn_objset),
4657 dn->dn_datablksz, abd_get_size(dr->dt.dll.dr_abd),
4675 dnode_t *dn = dr->dr_dnode;
4717 mutex_enter(&dn->dn_mtx);
4718 if (!(dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR)) {
4734 dn->dn_phys->dn_flags |= DNODE_FLAG_SPILL_BLKPTR;
4735 mutex_exit(&dn->dn_mtx);
4750 os = dn->dn_objset;
4758 dbuf_check_blkptr(dn, db);
4769 ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT);
4777 if (os->os_encrypted && dn->dn_object == DMU_META_DNODE_OBJECT)
4781 dn->dn_object != DMU_META_DNODE_OBJECT &&
4809 dn->dn_type, psize, lsize, compress_type,
4827 if (dn->dn_object == DMU_META_DNODE_OBJECT) {
4828 list_insert_tail(&dn->dn_dirty_records[txg & TXG_MASK], dr);
4877 dnode_t *dn;
4889 dn = DB_DNODE(db);
4891 dnode_diduse_space(dn, delta - zio->io_prev_space_delta);
4896 BP_GET_TYPE(bp) == dn->dn_type) ||
4898 BP_GET_TYPE(bp) == dn->dn_bonustype) ||
4907 ASSERT(dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR);
4909 db->db_blkptr == DN_SPILL_BLKPTR(dn->dn_phys));
4914 mutex_enter(&dn->dn_mtx);
4915 if (db->db_blkid > dn->dn_phys->dn_maxblkid &&
4918 dn->dn_phys->dn_maxblkid = db->db_blkid;
4920 mutex_exit(&dn->dn_mtx);
4922 if (dn->dn_type == DMU_OT_DNODE) {
4958 ASSERT3U(db->db.db_size, ==, 1<<dn->dn_phys->dn_indblkshift);
5052 dnode_t *dn = dr->dr_dnode;
5060 ASSERT(dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR);
5062 db->db_blkptr == DN_SPILL_BLKPTR(dn->dn_phys));
5079 ASSERT3U(db->db.db_size, ==, 1 << dn->dn_phys->dn_indblkshift);
5081 int epbs __maybe_unused = dn->dn_phys->dn_indblkshift -
5084 dn->dn_phys->dn_maxblkid >> (db->db_level * epbs));
5172 dbuf_remap_impl(dnode_t *dn, blkptr_t *bp, krwlock_t *rw, dmu_tx_t *tx)
5175 spa_t *spa = dmu_objset_spa(dn->dn_objset);
5180 drica.drica_os = dn->dn_objset;
5193 if (dn->dn_objset != spa_meta_objset(spa)) {
5194 dsl_dataset_t *ds = dmu_objset_ds(dn->dn_objset);
5227 dbuf_remap(dnode_t *dn, dmu_buf_impl_t *db, dmu_tx_t *tx)
5238 dbuf_remap_impl(dn, &bp[i], &db->db_rwlock, tx);
5242 ASSERT3U(dn->dn_type, ==, DMU_OT_DNODE);
5246 krwlock_t *lock = (dn->dn_dbuf == NULL ? NULL :
5247 &dn->dn_dbuf->db_rwlock);
5248 dbuf_remap_impl(dn, &dnp[i].dn_blkptr[j], lock,
5264 dnode_t *dn = dr->dr_dnode;
5275 os = dn->dn_objset;
5277 if (db->db_level > 0 || dn->dn_type == DMU_OT_DNODE) {
5288 dbuf_remap(dn, db, tx);
5291 if (parent != dn->dn_dbuf) {
5305 ASSERT((db->db_level == dn->dn_phys->dn_nlevels-1 &&
5310 &dn->dn_phys->dn_blkptr[db->db_blkid]);
5311 pio = dn->dn_zio;
5326 dmu_write_policy(os, dn, db->db_level, wp_flag, &zp);