Lines Matching refs:dn
105 dnode_t *dn = arg;
108 rw_init(&dn->dn_struct_rwlock, NULL, RW_DEFAULT, NULL);
109 mutex_init(&dn->dn_mtx, NULL, MUTEX_DEFAULT, NULL);
110 mutex_init(&dn->dn_dbufs_mtx, NULL, MUTEX_DEFAULT, NULL);
111 cv_init(&dn->dn_notxholds, NULL, CV_DEFAULT, NULL);
117 refcount_create_untracked(&dn->dn_holds);
118 refcount_create(&dn->dn_tx_holds);
119 list_link_init(&dn->dn_link);
121 bzero(&dn->dn_next_nblkptr[0], sizeof (dn->dn_next_nblkptr));
122 bzero(&dn->dn_next_nlevels[0], sizeof (dn->dn_next_nlevels));
123 bzero(&dn->dn_next_indblkshift[0], sizeof (dn->dn_next_indblkshift));
124 bzero(&dn->dn_next_bonustype[0], sizeof (dn->dn_next_bonustype));
125 bzero(&dn->dn_rm_spillblk[0], sizeof (dn->dn_rm_spillblk));
126 bzero(&dn->dn_next_bonuslen[0], sizeof (dn->dn_next_bonuslen));
127 bzero(&dn->dn_next_blksz[0], sizeof (dn->dn_next_blksz));
130 list_link_init(&dn->dn_dirty_link[i]);
131 dn->dn_free_ranges[i] = NULL;
132 list_create(&dn->dn_dirty_records[i],
137 dn->dn_allocated_txg = 0;
138 dn->dn_free_txg = 0;
139 dn->dn_assigned_txg = 0;
140 dn->dn_dirtyctx = 0;
141 dn->dn_dirtyctx_firstset = NULL;
142 dn->dn_bonus = NULL;
143 dn->dn_have_spill = B_FALSE;
144 dn->dn_zio = NULL;
145 dn->dn_oldused = 0;
146 dn->dn_oldflags = 0;
147 dn->dn_olduid = 0;
148 dn->dn_oldgid = 0;
149 dn->dn_newuid = 0;
150 dn->dn_newgid = 0;
151 dn->dn_id_flags = 0;
153 dn->dn_dbufs_count = 0;
154 avl_create(&dn->dn_dbufs, dbuf_compare, sizeof (dmu_buf_impl_t),
157 dn->dn_moved = 0;
166 dnode_t *dn = arg;
168 rw_destroy(&dn->dn_struct_rwlock);
169 mutex_destroy(&dn->dn_mtx);
170 mutex_destroy(&dn->dn_dbufs_mtx);
171 cv_destroy(&dn->dn_notxholds);
172 refcount_destroy(&dn->dn_holds);
173 refcount_destroy(&dn->dn_tx_holds);
174 ASSERT(!list_link_active(&dn->dn_link));
177 ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
178 ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
179 list_destroy(&dn->dn_dirty_records[i]);
180 ASSERT0(dn->dn_next_nblkptr[i]);
181 ASSERT0(dn->dn_next_nlevels[i]);
182 ASSERT0(dn->dn_next_indblkshift[i]);
183 ASSERT0(dn->dn_next_bonustype[i]);
184 ASSERT0(dn->dn_rm_spillblk[i]);
185 ASSERT0(dn->dn_next_bonuslen[i]);
186 ASSERT0(dn->dn_next_blksz[i]);
189 ASSERT0(dn->dn_allocated_txg);
190 ASSERT0(dn->dn_free_txg);
191 ASSERT0(dn->dn_assigned_txg);
192 ASSERT0(dn->dn_dirtyctx);
193 ASSERT3P(dn->dn_dirtyctx_firstset, ==, NULL);
194 ASSERT3P(dn->dn_bonus, ==, NULL);
195 ASSERT(!dn->dn_have_spill);
196 ASSERT3P(dn->dn_zio, ==, NULL);
197 ASSERT0(dn->dn_oldused);
198 ASSERT0(dn->dn_oldflags);
199 ASSERT0(dn->dn_olduid);
200 ASSERT0(dn->dn_oldgid);
201 ASSERT0(dn->dn_newuid);
202 ASSERT0(dn->dn_newgid);
203 ASSERT0(dn->dn_id_flags);
205 ASSERT0(dn->dn_dbufs_count);
206 avl_destroy(&dn->dn_dbufs);
229 dnode_verify(dnode_t *dn)
233 ASSERT(dn->dn_phys);
234 ASSERT(dn->dn_objset);
235 ASSERT(dn->dn_handle->dnh_dnode == dn);
237 ASSERT(DMU_OT_IS_VALID(dn->dn_phys->dn_type));
242 if (!RW_WRITE_HELD(&dn->dn_struct_rwlock)) {
243 rw_enter(&dn->dn_struct_rwlock, RW_READER);
246 if (dn->dn_phys->dn_type != DMU_OT_NONE || dn->dn_allocated_txg != 0) {
248 ASSERT3U(dn->dn_indblkshift, >=, 0);
249 ASSERT3U(dn->dn_indblkshift, <=, SPA_MAXBLOCKSHIFT);
250 if (dn->dn_datablkshift) {
251 ASSERT3U(dn->dn_datablkshift, >=, SPA_MINBLOCKSHIFT);
252 ASSERT3U(dn->dn_datablkshift, <=, SPA_MAXBLOCKSHIFT);
253 ASSERT3U(1<<dn->dn_datablkshift, ==, dn->dn_datablksz);
255 ASSERT3U(dn->dn_nlevels, <=, 30);
256 ASSERT(DMU_OT_IS_VALID(dn->dn_type));
257 ASSERT3U(dn->dn_nblkptr, >=, 1);
258 ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);
259 ASSERT3U(dn->dn_bonuslen, <=, DN_MAX_BONUSLEN);
260 ASSERT3U(dn->dn_datablksz, ==,
261 dn->dn_datablkszsec << SPA_MINBLOCKSHIFT);
262 ASSERT3U(ISP2(dn->dn_datablksz), ==, dn->dn_datablkshift != 0);
263 ASSERT3U((dn->dn_nblkptr - 1) * sizeof (blkptr_t) +
264 dn->dn_bonuslen, <=, DN_MAX_BONUSLEN);
266 ASSERT3U(dn->dn_next_nlevels[i], <=, dn->dn_nlevels);
269 if (dn->dn_phys->dn_type != DMU_OT_NONE)
270 ASSERT3U(dn->dn_phys->dn_nlevels, <=, dn->dn_nlevels);
271 ASSERT(DMU_OBJECT_IS_SPECIAL(dn->dn_object) || dn->dn_dbuf != NULL);
272 if (dn->dn_dbuf != NULL) {
273 ASSERT3P(dn->dn_phys, ==,
274 (dnode_phys_t *)dn->dn_dbuf->db.db_data +
275 (dn->dn_object % (dn->dn_dbuf->db.db_size >> DNODE_SHIFT)));
278 rw_exit(&dn->dn_struct_rwlock);
351 dnode_setbonuslen(dnode_t *dn, int newsize, dmu_tx_t *tx)
353 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1);
355 dnode_setdirty(dn, tx);
356 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
358 (dn->dn_nblkptr-1) * sizeof (blkptr_t));
359 dn->dn_bonuslen = newsize;
361 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = DN_ZERO_BONUSLEN;
363 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen;
364 rw_exit(&dn->dn_struct_rwlock);
368 dnode_setbonus_type(dnode_t *dn, dmu_object_type_t newtype, dmu_tx_t *tx)
370 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1);
371 dnode_setdirty(dn, tx);
372 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
373 dn->dn_bonustype = newtype;
374 dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype;
375 rw_exit(&dn->dn_struct_rwlock);
379 dnode_rm_spill(dnode_t *dn, dmu_tx_t *tx)
381 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1);
382 ASSERT(RW_WRITE_HELD(&dn->dn_struct_rwlock));
383 dnode_setdirty(dn, tx);
384 dn->dn_rm_spillblk[tx->tx_txg&TXG_MASK] = DN_KILL_SPILLBLK;
385 dn->dn_have_spill = B_FALSE;
389 dnode_setdblksz(dnode_t *dn, int size)
395 1<<(sizeof (dn->dn_phys->dn_datablkszsec) * 8));
396 dn->dn_datablksz = size;
397 dn->dn_datablkszsec = size >> SPA_MINBLOCKSHIFT;
398 dn->dn_datablkshift = ISP2(size) ? highbit64(size - 1) : 0;
405 dnode_t *dn;
407 dn = kmem_cache_alloc(dnode_cache, KM_SLEEP);
408 ASSERT(!POINTER_IS_VALID(dn->dn_objset));
409 dn->dn_moved = 0;
415 dn->dn_object = object;
416 dn->dn_dbuf = db;
417 dn->dn_handle = dnh;
418 dn->dn_phys = dnp;
421 dnode_setdblksz(dn, dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
423 dn->dn_datablksz = 0;
424 dn->dn_datablkszsec = 0;
425 dn->dn_datablkshift = 0;
427 dn->dn_indblkshift = dnp->dn_indblkshift;
428 dn->dn_nlevels = dnp->dn_nlevels;
429 dn->dn_type = dnp->dn_type;
430 dn->dn_nblkptr = dnp->dn_nblkptr;
431 dn->dn_checksum = dnp->dn_checksum;
432 dn->dn_compress = dnp->dn_compress;
433 dn->dn_bonustype = dnp->dn_bonustype;
434 dn->dn_bonuslen = dnp->dn_bonuslen;
435 dn->dn_maxblkid = dnp->dn_maxblkid;
436 dn->dn_have_spill = ((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) != 0);
437 dn->dn_id_flags = 0;
439 dmu_zfetch_init(&dn->dn_zfetch, dn);
441 ASSERT(DMU_OT_IS_VALID(dn->dn_phys->dn_type));
447 kmem_cache_free(dnode_cache, dn);
459 list_insert_head(&os->os_dnodes, dn);
466 dn->dn_objset = os;
468 dnh->dnh_dnode = dn;
472 return (dn);
479 dnode_destroy(dnode_t *dn)
481 objset_t *os = dn->dn_objset;
484 ASSERT((dn->dn_id_flags & DN_ID_NEW_EXIST) == 0);
487 POINTER_INVALIDATE(&dn->dn_objset);
488 if (!DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
489 list_remove(&os->os_dnodes, dn);
497 zrl_remove(&dn->dn_handle->dnh_zrlock);
499 dn->dn_allocated_txg = 0;
500 dn->dn_free_txg = 0;
501 dn->dn_assigned_txg = 0;
503 dn->dn_dirtyctx = 0;
504 if (dn->dn_dirtyctx_firstset != NULL) {
505 kmem_free(dn->dn_dirtyctx_firstset, 1);
506 dn->dn_dirtyctx_firstset = NULL;
508 if (dn->dn_bonus != NULL) {
509 mutex_enter(&dn->dn_bonus->db_mtx);
510 dbuf_destroy(dn->dn_bonus);
511 dn->dn_bonus = NULL;
513 dn->dn_zio = NULL;
515 dn->dn_have_spill = B_FALSE;
516 dn->dn_oldused = 0;
517 dn->dn_oldflags = 0;
518 dn->dn_olduid = 0;
519 dn->dn_oldgid = 0;
520 dn->dn_newuid = 0;
521 dn->dn_newgid = 0;
522 dn->dn_id_flags = 0;
524 dmu_zfetch_fini(&dn->dn_zfetch);
525 kmem_cache_free(dnode_cache, dn);
533 dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
539 spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
550 dprintf("os=%p obj=%llu txg=%llu blocksize=%d ibs=%d\n", dn->dn_objset,
551 dn->dn_object, tx->tx_txg, blocksize, ibs);
553 ASSERT(dn->dn_type == DMU_OT_NONE);
554 ASSERT(bcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t)) == 0);
555 ASSERT(dn->dn_phys->dn_type == DMU_OT_NONE);
563 ASSERT(dn->dn_type == DMU_OT_NONE);
564 ASSERT0(dn->dn_maxblkid);
565 ASSERT0(dn->dn_allocated_txg);
566 ASSERT0(dn->dn_assigned_txg);
567 ASSERT(refcount_is_zero(&dn->dn_tx_holds));
568 ASSERT3U(refcount_count(&dn->dn_holds), <=, 1);
569 ASSERT(avl_is_empty(&dn->dn_dbufs));
572 ASSERT0(dn->dn_next_nblkptr[i]);
573 ASSERT0(dn->dn_next_nlevels[i]);
574 ASSERT0(dn->dn_next_indblkshift[i]);
575 ASSERT0(dn->dn_next_bonuslen[i]);
576 ASSERT0(dn->dn_next_bonustype[i]);
577 ASSERT0(dn->dn_rm_spillblk[i]);
578 ASSERT0(dn->dn_next_blksz[i]);
579 ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
580 ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL);
581 ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
584 dn->dn_type = ot;
585 dnode_setdblksz(dn, blocksize);
586 dn->dn_indblkshift = ibs;
587 dn->dn_nlevels = 1;
589 dn->dn_nblkptr = 1;
591 dn->dn_nblkptr = 1 +
593 dn->dn_bonustype = bonustype;
594 dn->dn_bonuslen = bonuslen;
595 dn->dn_checksum = ZIO_CHECKSUM_INHERIT;
596 dn->dn_compress = ZIO_COMPRESS_INHERIT;
597 dn->dn_dirtyctx = 0;
599 dn->dn_free_txg = 0;
600 if (dn->dn_dirtyctx_firstset) {
601 kmem_free(dn->dn_dirtyctx_firstset, 1);
602 dn->dn_dirtyctx_firstset = NULL;
605 dn->dn_allocated_txg = tx->tx_txg;
606 dn->dn_id_flags = 0;
608 dnode_setdirty(dn, tx);
609 dn->dn_next_indblkshift[tx->tx_txg & TXG_MASK] = ibs;
610 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen;
611 dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype;
612 dn->dn_next_blksz[tx->tx_txg & TXG_MASK] = dn->dn_datablksz;
616 dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize,
623 spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
625 ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT || dmu_tx_private_ok(tx));
634 dnode_evict_dbufs(dn);
636 dn->dn_id_flags = 0;
638 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
639 dnode_setdirty(dn, tx);
640 if (dn->dn_datablksz != blocksize) {
642 ASSERT(dn->dn_maxblkid == 0 &&
643 (BP_IS_HOLE(&dn->dn_phys->dn_blkptr[0]) ||
644 dnode_block_freed(dn, 0)));
645 dnode_setdblksz(dn, blocksize);
646 dn->dn_next_blksz[tx->tx_txg&TXG_MASK] = blocksize;
648 if (dn->dn_bonuslen != bonuslen)
649 dn->dn_next_bonuslen[tx->tx_txg&TXG_MASK] = bonuslen;
655 if (dn->dn_bonustype != bonustype)
656 dn->dn_next_bonustype[tx->tx_txg&TXG_MASK] = bonustype;
657 if (dn->dn_nblkptr != nblkptr)
658 dn->dn_next_nblkptr[tx->tx_txg&TXG_MASK] = nblkptr;
659 if (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
660 dbuf_rm_spill(dn, tx);
661 dnode_rm_spill(dn, tx);
663 rw_exit(&dn->dn_struct_rwlock);
666 dn->dn_type = ot;
669 mutex_enter(&dn->dn_mtx);
670 dn->dn_bonustype = bonustype;
671 dn->dn_bonuslen = bonuslen;
672 dn->dn_nblkptr = nblkptr;
673 dn->dn_checksum = ZIO_CHECKSUM_INHERIT;
674 dn->dn_compress = ZIO_COMPRESS_INHERIT;
675 ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);
678 if (dn->dn_bonus) {
679 dn->dn_bonus->db.db_size =
680 DN_MAX_BONUSLEN - (dn->dn_nblkptr-1) * sizeof (blkptr_t);
681 ASSERT(dn->dn_bonuslen <= dn->dn_bonus->db.db_size);
684 dn->dn_allocated_txg = tx->tx_txg;
685 mutex_exit(&dn->dn_mtx);
982 dnode_t *dn = dnh->dnh_dnode;
990 while (refcount_count(&dn->dn_holds) > 0)
992 ASSERT(dn->dn_dbuf == NULL ||
993 dmu_buf_get_user(&dn->dn_dbuf->db) == NULL);
995 dnode_destroy(dn); /* implicit zrl_remove() */
1004 dnode_t *dn;
1006 dn = dnode_create(os, dnp, NULL, object, dnh);
1008 DNODE_VERIFY(dn);
1019 dnode_t *dn;
1032 dn = dnh->dnh_dnode;
1039 ASSERT(refcount_is_zero(&dn->dn_holds));
1040 ASSERT(refcount_is_zero(&dn->dn_tx_holds));
1042 dnode_destroy(dn); /* implicit zrl_remove() */
1064 dnode_t *mdn, *dn;
1080 dn = (object == DMU_USERUSED_OBJECT) ?
1082 if (dn == NULL)
1084 type = dn->dn_type;
1089 DNODE_VERIFY(dn);
1090 (void) refcount_add(&dn->dn_holds, tag);
1091 *dnp = dn;
1156 dn = dnh->dnh_dnode;
1157 if (dn == NULL) {
1160 dn = dnode_create(os, phys, db, object, dnh);
1163 mutex_enter(&dn->dn_mtx);
1164 type = dn->dn_type;
1165 if (dn->dn_free_txg ||
1168 (type != DMU_OT_NONE || !refcount_is_zero(&dn->dn_holds)))) {
1169 mutex_exit(&dn->dn_mtx);
1174 if (refcount_add(&dn->dn_holds, tag) == 1)
1176 mutex_exit(&dn->dn_mtx);
1181 DNODE_VERIFY(dn);
1182 ASSERT3P(dn->dn_dbuf, ==, db);
1183 ASSERT3U(dn->dn_object, ==, object);
1186 *dnp = dn;
1205 dnode_add_ref(dnode_t *dn, void *tag)
1207 mutex_enter(&dn->dn_mtx);
1208 if (refcount_is_zero(&dn->dn_holds)) {
1209 mutex_exit(&dn->dn_mtx);
1212 VERIFY(1 < refcount_add(&dn->dn_holds, tag));
1213 mutex_exit(&dn->dn_mtx);
1218 dnode_rele(dnode_t *dn, void *tag)
1220 mutex_enter(&dn->dn_mtx);
1221 dnode_rele_and_unlock(dn, tag);
1225 dnode_rele_and_unlock(dnode_t *dn, void *tag)
1229 dmu_buf_impl_t *db = dn->dn_dbuf;
1230 dnode_handle_t *dnh = dn->dn_handle;
1232 refs = refcount_remove(&dn->dn_holds, tag);
1233 mutex_exit(&dn->dn_mtx);
1261 dnode_setdirty(dnode_t *dn, dmu_tx_t *tx)
1263 objset_t *os = dn->dn_objset;
1266 if (DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
1271 DNODE_VERIFY(dn);
1274 mutex_enter(&dn->dn_mtx);
1275 ASSERT(dn->dn_phys->dn_type || dn->dn_allocated_txg);
1276 ASSERT(dn->dn_free_txg == 0 || dn->dn_free_txg >= txg);
1277 mutex_exit(&dn->dn_mtx);
1283 dmu_objset_userquota_get_ids(dn, B_TRUE, tx);
1290 if (list_link_active(&dn->dn_dirty_link[txg & TXG_MASK])) {
1295 ASSERT(!refcount_is_zero(&dn->dn_holds) ||
1296 !avl_is_empty(&dn->dn_dbufs));
1297 ASSERT(dn->dn_datablksz != 0);
1298 ASSERT0(dn->dn_next_bonuslen[txg&TXG_MASK]);
1299 ASSERT0(dn->dn_next_blksz[txg&TXG_MASK]);
1300 ASSERT0(dn->dn_next_bonustype[txg&TXG_MASK]);
1303 dn->dn_object, txg);
1305 if (dn->dn_free_txg > 0 && dn->dn_free_txg <= txg) {
1306 list_insert_tail(&os->os_free_dnodes[txg&TXG_MASK], dn);
1308 list_insert_tail(&os->os_dirty_dnodes[txg&TXG_MASK], dn);
1322 VERIFY(dnode_add_ref(dn, (void *)(uintptr_t)tx->tx_txg));
1324 (void) dbuf_dirty(dn->dn_dbuf, tx);
1330 dnode_free(dnode_t *dn, dmu_tx_t *tx)
1334 dprintf("dn=%p txg=%llu\n", dn, tx->tx_txg);
1337 /* ASSERT3U(refcount_count(&dn->dn_holds), ==, 1); */
1339 mutex_enter(&dn->dn_mtx);
1340 if (dn->dn_type == DMU_OT_NONE || dn->dn_free_txg) {
1341 mutex_exit(&dn->dn_mtx);
1344 dn->dn_free_txg = tx->tx_txg;
1345 mutex_exit(&dn->dn_mtx);
1351 mutex_enter(&dn->dn_objset->os_lock);
1352 if (list_link_active(&dn->dn_dirty_link[txgoff])) {
1353 list_remove(&dn->dn_objset->os_dirty_dnodes[txgoff], dn);
1354 list_insert_tail(&dn->dn_objset->os_free_dnodes[txgoff], dn);
1355 mutex_exit(&dn->dn_objset->os_lock);
1357 mutex_exit(&dn->dn_objset->os_lock);
1358 dnode_setdirty(dn, tx);
1367 dnode_set_blksz(dnode_t *dn, uint64_t size, int ibs, dmu_tx_t *tx)
1372 ASSERT3U(size, <=, spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
1378 if (ibs == dn->dn_indblkshift)
1381 if (size >> SPA_MINBLOCKSHIFT == dn->dn_datablkszsec && ibs == 0)
1384 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1387 if (dn->dn_maxblkid != 0)
1390 mutex_enter(&dn->dn_dbufs_mtx);
1391 for (db = avl_first(&dn->dn_dbufs); db != NULL;
1392 db = AVL_NEXT(&dn->dn_dbufs, db)) {
1395 mutex_exit(&dn->dn_dbufs_mtx);
1399 mutex_exit(&dn->dn_dbufs_mtx);
1401 if (ibs && dn->dn_nlevels != 1)
1405 err = dbuf_hold_impl(dn, 0, 0, TRUE, FALSE, FTAG, &db);
1411 dnode_setdblksz(dn, size);
1412 dnode_setdirty(dn, tx);
1413 dn->dn_next_blksz[tx->tx_txg&TXG_MASK] = size;
1415 dn->dn_indblkshift = ibs;
1416 dn->dn_next_indblkshift[tx->tx_txg&TXG_MASK] = ibs;
1422 rw_exit(&dn->dn_struct_rwlock);
1426 rw_exit(&dn->dn_struct_rwlock);
1432 dnode_new_blkid(dnode_t *dn, uint64_t blkid, dmu_tx_t *tx, boolean_t have_read)
1441 RW_READ_HELD(&dn->dn_struct_rwlock) :
1442 RW_WRITE_HELD(&dn->dn_struct_rwlock));
1449 if (blkid <= dn->dn_maxblkid)
1452 if (!rw_tryupgrade(&dn->dn_struct_rwlock)) {
1453 rw_exit(&dn->dn_struct_rwlock);
1454 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1458 if (blkid <= dn->dn_maxblkid)
1461 dn->dn_maxblkid = blkid;
1467 epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
1468 for (sz = dn->dn_nblkptr;
1469 sz <= blkid && sz >= dn->dn_nblkptr; sz <<= epbs)
1472 if (new_nlevels > dn->dn_nlevels) {
1473 int old_nlevels = dn->dn_nlevels;
1478 dn->dn_nlevels = new_nlevels;
1480 ASSERT3U(new_nlevels, >, dn->dn_next_nlevels[txgoff]);
1481 dn->dn_next_nlevels[txgoff] = new_nlevels;
1484 db = dbuf_hold_level(dn, old_nlevels, 0, FTAG);
1490 mutex_enter(&dn->dn_mtx);
1492 list = &dn->dn_dirty_records[txgoff];
1494 dr_next = list_next(&dn->dn_dirty_records[txgoff], dr);
1499 list_remove(&dn->dn_dirty_records[txgoff], dr);
1505 mutex_exit(&dn->dn_mtx);
1510 rw_downgrade(&dn->dn_struct_rwlock);
1514 dnode_dirty_l1(dnode_t *dn, uint64_t l1blkid, dmu_tx_t *tx)
1516 dmu_buf_impl_t *db = dbuf_hold_level(dn, 1, l1blkid, FTAG);
1524 dnode_free_range(dnode_t *dn, uint64_t off, uint64_t len, dmu_tx_t *tx)
1532 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1533 blksz = dn->dn_datablksz;
1534 blkshift = dn->dn_datablkshift;
1535 epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
1548 if ((off >> blkshift) > dn->dn_maxblkid)
1551 ASSERT(dn->dn_maxblkid == 0);
1578 if (dbuf_hold_impl(dn, 0, dbuf_whichblock(dn, 0, off),
1585 rw_exit(&dn->dn_struct_rwlock);
1587 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1602 if ((off >> blkshift) > dn->dn_maxblkid)
1616 if (dbuf_hold_impl(dn, 0, dbuf_whichblock(dn, 0, off+len),
1621 rw_exit(&dn->dn_struct_rwlock);
1623 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1662 if (dn->dn_nlevels > 1) {
1666 dnode_dirty_l1(dn, first, tx);
1668 last = dn->dn_maxblkid >> epbs;
1672 dnode_dirty_l1(dn, last, tx);
1674 int shift = dn->dn_datablkshift + dn->dn_indblkshift -
1684 int err = dnode_next_offset(dn, DNODE_FIND_HAVELOCK,
1703 dnode_dirty_l1(dn, i, tx);
1712 mutex_enter(&dn->dn_mtx);
1714 if (dn->dn_free_ranges[txgoff] == NULL) {
1715 dn->dn_free_ranges[txgoff] =
1716 range_tree_create(NULL, NULL, &dn->dn_mtx);
1718 range_tree_clear(dn->dn_free_ranges[txgoff], blkid, nblks);
1719 range_tree_add(dn->dn_free_ranges[txgoff], blkid, nblks);
1720 dprintf_dnode(dn, "blkid=%llu nblks=%llu txg=%llu\n",
1722 mutex_exit(&dn->dn_mtx);
1724 dbuf_free_range(dn, blkid, blkid + nblks - 1, tx);
1725 dnode_setdirty(dn, tx);
1728 rw_exit(&dn->dn_struct_rwlock);
1732 dnode_spill_freed(dnode_t *dn)
1736 mutex_enter(&dn->dn_mtx);
1738 if (dn->dn_rm_spillblk[i] == DN_KILL_SPILLBLK)
1741 mutex_exit(&dn->dn_mtx);
1747 dnode_block_freed(dnode_t *dn, uint64_t blkid)
1749 void *dp = spa_get_dsl(dn->dn_objset->os_spa);
1762 if (dn->dn_free_txg)
1766 return (dnode_spill_freed(dn));
1768 mutex_enter(&dn->dn_mtx);
1770 if (dn->dn_free_ranges[i] != NULL &&
1771 range_tree_contains(dn->dn_free_ranges[i], blkid, 1))
1774 mutex_exit(&dn->dn_mtx);
1780 dnode_diduse_space(dnode_t *dn, int64_t delta)
1783 dprintf_dnode(dn, "dn=%p dnp=%p used=%llu delta=%lld\n",
1784 dn, dn->dn_phys,
1785 (u_longlong_t)dn->dn_phys->dn_used,
1788 mutex_enter(&dn->dn_mtx);
1789 space = DN_USED_BYTES(dn->dn_phys);
1796 if (spa_version(dn->dn_objset->os_spa) < SPA_VERSION_DNODE_BYTES) {
1797 ASSERT((dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) == 0);
1799 dn->dn_phys->dn_used = space >> DEV_BSHIFT;
1801 dn->dn_phys->dn_used = space;
1802 dn->dn_phys->dn_flags |= DNODE_FLAG_USED_BYTES;
1804 mutex_exit(&dn->dn_mtx);
1812 dnode_willuse_space(dnode_t *dn, int64_t space, dmu_tx_t *tx)
1814 objset_t *os = dn->dn_objset;
1845 dnode_next_offset_level(dnode_t *dn, int flags, uint64_t *offset,
1850 uint64_t epbs = dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
1857 dn->dn_object, *offset, lvl, dn->dn_phys->dn_nlevels);
1863 if (lvl == dn->dn_phys->dn_nlevels) {
1865 epb = dn->dn_phys->dn_nblkptr;
1866 data = dn->dn_phys->dn_blkptr;
1868 uint64_t blkid = dbuf_whichblock(dn, lvl, *offset);
1869 error = dbuf_hold_impl(dn, lvl, blkid, TRUE, FALSE, FTAG, &db);
1904 ASSERT(dn->dn_type == DMU_OT_DNODE);
1917 span = (lvl - 1) * epbs + dn->dn_datablkshift;
1963 * dnode_next_offset(dn, flags, offset, 1, 1, 0);
1978 dnode_next_offset(dnode_t *dn, int flags, uint64_t *offset,
1986 rw_enter(&dn->dn_struct_rwlock, RW_READER);
1988 if (dn->dn_phys->dn_nlevels == 0) {
1993 if (dn->dn_datablkshift == 0) {
1994 if (*offset < dn->dn_datablksz) {
1996 *offset = dn->dn_datablksz;
2003 maxlvl = dn->dn_phys->dn_nlevels;
2006 error = dnode_next_offset_level(dn,
2013 error = dnode_next_offset_level(dn,
2031 rw_exit(&dn->dn_struct_rwlock);