Lines Matching defs: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 dn->dn_unlisted_l0_blkid = 0;
155 avl_create(&dn->dn_dbufs, dbuf_compare, sizeof (dmu_buf_impl_t),
158 dn->dn_moved = 0;
167 dnode_t *dn = arg;
169 rw_destroy(&dn->dn_struct_rwlock);
170 mutex_destroy(&dn->dn_mtx);
171 mutex_destroy(&dn->dn_dbufs_mtx);
172 cv_destroy(&dn->dn_notxholds);
173 refcount_destroy(&dn->dn_holds);
174 refcount_destroy(&dn->dn_tx_holds);
175 ASSERT(!list_link_active(&dn->dn_link));
178 ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
179 ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
180 list_destroy(&dn->dn_dirty_records[i]);
181 ASSERT0(dn->dn_next_nblkptr[i]);
182 ASSERT0(dn->dn_next_nlevels[i]);
183 ASSERT0(dn->dn_next_indblkshift[i]);
184 ASSERT0(dn->dn_next_bonustype[i]);
185 ASSERT0(dn->dn_rm_spillblk[i]);
186 ASSERT0(dn->dn_next_bonuslen[i]);
187 ASSERT0(dn->dn_next_blksz[i]);
190 ASSERT0(dn->dn_allocated_txg);
191 ASSERT0(dn->dn_free_txg);
192 ASSERT0(dn->dn_assigned_txg);
193 ASSERT0(dn->dn_dirtyctx);
194 ASSERT3P(dn->dn_dirtyctx_firstset, ==, NULL);
195 ASSERT3P(dn->dn_bonus, ==, NULL);
196 ASSERT(!dn->dn_have_spill);
197 ASSERT3P(dn->dn_zio, ==, NULL);
198 ASSERT0(dn->dn_oldused);
199 ASSERT0(dn->dn_oldflags);
200 ASSERT0(dn->dn_olduid);
201 ASSERT0(dn->dn_oldgid);
202 ASSERT0(dn->dn_newuid);
203 ASSERT0(dn->dn_newgid);
204 ASSERT0(dn->dn_id_flags);
206 ASSERT0(dn->dn_dbufs_count);
207 ASSERT0(dn->dn_unlisted_l0_blkid);
208 avl_destroy(&dn->dn_dbufs);
231 dnode_verify(dnode_t *dn)
235 ASSERT(dn->dn_phys);
236 ASSERT(dn->dn_objset);
237 ASSERT(dn->dn_handle->dnh_dnode == dn);
239 ASSERT(DMU_OT_IS_VALID(dn->dn_phys->dn_type));
244 if (!RW_WRITE_HELD(&dn->dn_struct_rwlock)) {
245 rw_enter(&dn->dn_struct_rwlock, RW_READER);
248 if (dn->dn_phys->dn_type != DMU_OT_NONE || dn->dn_allocated_txg != 0) {
250 ASSERT3U(dn->dn_indblkshift, >=, 0);
251 ASSERT3U(dn->dn_indblkshift, <=, SPA_MAXBLOCKSHIFT);
252 if (dn->dn_datablkshift) {
253 ASSERT3U(dn->dn_datablkshift, >=, SPA_MINBLOCKSHIFT);
254 ASSERT3U(dn->dn_datablkshift, <=, SPA_MAXBLOCKSHIFT);
255 ASSERT3U(1<<dn->dn_datablkshift, ==, dn->dn_datablksz);
257 ASSERT3U(dn->dn_nlevels, <=, 30);
258 ASSERT(DMU_OT_IS_VALID(dn->dn_type));
259 ASSERT3U(dn->dn_nblkptr, >=, 1);
260 ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);
261 ASSERT3U(dn->dn_bonuslen, <=, DN_MAX_BONUSLEN);
262 ASSERT3U(dn->dn_datablksz, ==,
263 dn->dn_datablkszsec << SPA_MINBLOCKSHIFT);
264 ASSERT3U(ISP2(dn->dn_datablksz), ==, dn->dn_datablkshift != 0);
265 ASSERT3U((dn->dn_nblkptr - 1) * sizeof (blkptr_t) +
266 dn->dn_bonuslen, <=, DN_MAX_BONUSLEN);
268 ASSERT3U(dn->dn_next_nlevels[i], <=, dn->dn_nlevels);
271 if (dn->dn_phys->dn_type != DMU_OT_NONE)
272 ASSERT3U(dn->dn_phys->dn_nlevels, <=, dn->dn_nlevels);
273 ASSERT(DMU_OBJECT_IS_SPECIAL(dn->dn_object) || dn->dn_dbuf != NULL);
274 if (dn->dn_dbuf != NULL) {
275 ASSERT3P(dn->dn_phys, ==,
276 (dnode_phys_t *)dn->dn_dbuf->db.db_data +
277 (dn->dn_object % (dn->dn_dbuf->db.db_size >> DNODE_SHIFT)));
280 rw_exit(&dn->dn_struct_rwlock);
353 dnode_setbonuslen(dnode_t *dn, int newsize, dmu_tx_t *tx)
355 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1);
357 dnode_setdirty(dn, tx);
358 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
360 (dn->dn_nblkptr-1) * sizeof (blkptr_t));
361 dn->dn_bonuslen = newsize;
363 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = DN_ZERO_BONUSLEN;
365 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen;
366 rw_exit(&dn->dn_struct_rwlock);
370 dnode_setbonus_type(dnode_t *dn, dmu_object_type_t newtype, dmu_tx_t *tx)
372 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1);
373 dnode_setdirty(dn, tx);
374 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
375 dn->dn_bonustype = newtype;
376 dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype;
377 rw_exit(&dn->dn_struct_rwlock);
381 dnode_rm_spill(dnode_t *dn, dmu_tx_t *tx)
383 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1);
384 ASSERT(RW_WRITE_HELD(&dn->dn_struct_rwlock));
385 dnode_setdirty(dn, tx);
386 dn->dn_rm_spillblk[tx->tx_txg&TXG_MASK] = DN_KILL_SPILLBLK;
387 dn->dn_have_spill = B_FALSE;
391 dnode_setdblksz(dnode_t *dn, int size)
397 1<<(sizeof (dn->dn_phys->dn_datablkszsec) * 8));
398 dn->dn_datablksz = size;
399 dn->dn_datablkszsec = size >> SPA_MINBLOCKSHIFT;
400 dn->dn_datablkshift = ISP2(size) ? highbit64(size - 1) : 0;
407 dnode_t *dn;
409 dn = kmem_cache_alloc(dnode_cache, KM_SLEEP);
410 ASSERT(!POINTER_IS_VALID(dn->dn_objset));
411 dn->dn_moved = 0;
417 dn->dn_object = object;
418 dn->dn_dbuf = db;
419 dn->dn_handle = dnh;
420 dn->dn_phys = dnp;
423 dnode_setdblksz(dn, dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
425 dn->dn_datablksz = 0;
426 dn->dn_datablkszsec = 0;
427 dn->dn_datablkshift = 0;
429 dn->dn_indblkshift = dnp->dn_indblkshift;
430 dn->dn_nlevels = dnp->dn_nlevels;
431 dn->dn_type = dnp->dn_type;
432 dn->dn_nblkptr = dnp->dn_nblkptr;
433 dn->dn_checksum = dnp->dn_checksum;
434 dn->dn_compress = dnp->dn_compress;
435 dn->dn_bonustype = dnp->dn_bonustype;
436 dn->dn_bonuslen = dnp->dn_bonuslen;
437 dn->dn_maxblkid = dnp->dn_maxblkid;
438 dn->dn_have_spill = ((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) != 0);
439 dn->dn_id_flags = 0;
441 dmu_zfetch_init(&dn->dn_zfetch, dn);
443 ASSERT(DMU_OT_IS_VALID(dn->dn_phys->dn_type));
449 kmem_cache_free(dnode_cache, dn);
461 list_insert_head(&os->os_dnodes, dn);
468 dn->dn_objset = os;
470 dnh->dnh_dnode = dn;
474 return (dn);
481 dnode_destroy(dnode_t *dn)
483 objset_t *os = dn->dn_objset;
486 ASSERT((dn->dn_id_flags & DN_ID_NEW_EXIST) == 0);
489 POINTER_INVALIDATE(&dn->dn_objset);
490 if (!DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
491 list_remove(&os->os_dnodes, dn);
499 zrl_remove(&dn->dn_handle->dnh_zrlock);
501 dn->dn_allocated_txg = 0;
502 dn->dn_free_txg = 0;
503 dn->dn_assigned_txg = 0;
505 dn->dn_dirtyctx = 0;
506 if (dn->dn_dirtyctx_firstset != NULL) {
507 kmem_free(dn->dn_dirtyctx_firstset, 1);
508 dn->dn_dirtyctx_firstset = NULL;
510 if (dn->dn_bonus != NULL) {
511 mutex_enter(&dn->dn_bonus->db_mtx);
512 dbuf_evict(dn->dn_bonus);
513 dn->dn_bonus = NULL;
515 dn->dn_zio = NULL;
517 dn->dn_have_spill = B_FALSE;
518 dn->dn_oldused = 0;
519 dn->dn_oldflags = 0;
520 dn->dn_olduid = 0;
521 dn->dn_oldgid = 0;
522 dn->dn_newuid = 0;
523 dn->dn_newgid = 0;
524 dn->dn_id_flags = 0;
525 dn->dn_unlisted_l0_blkid = 0;
527 dmu_zfetch_fini(&dn->dn_zfetch);
528 kmem_cache_free(dnode_cache, dn);
536 dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
542 spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
553 dprintf("os=%p obj=%llu txg=%llu blocksize=%d ibs=%d\n", dn->dn_objset,
554 dn->dn_object, tx->tx_txg, blocksize, ibs);
556 ASSERT(dn->dn_type == DMU_OT_NONE);
557 ASSERT(bcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t)) == 0);
558 ASSERT(dn->dn_phys->dn_type == DMU_OT_NONE);
566 ASSERT(dn->dn_type == DMU_OT_NONE);
567 ASSERT0(dn->dn_maxblkid);
568 ASSERT0(dn->dn_allocated_txg);
569 ASSERT0(dn->dn_assigned_txg);
570 ASSERT(refcount_is_zero(&dn->dn_tx_holds));
571 ASSERT3U(refcount_count(&dn->dn_holds), <=, 1);
572 ASSERT(avl_is_empty(&dn->dn_dbufs));
575 ASSERT0(dn->dn_next_nblkptr[i]);
576 ASSERT0(dn->dn_next_nlevels[i]);
577 ASSERT0(dn->dn_next_indblkshift[i]);
578 ASSERT0(dn->dn_next_bonuslen[i]);
579 ASSERT0(dn->dn_next_bonustype[i]);
580 ASSERT0(dn->dn_rm_spillblk[i]);
581 ASSERT0(dn->dn_next_blksz[i]);
582 ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
583 ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL);
584 ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
587 dn->dn_type = ot;
588 dnode_setdblksz(dn, blocksize);
589 dn->dn_indblkshift = ibs;
590 dn->dn_nlevels = 1;
592 dn->dn_nblkptr = 1;
594 dn->dn_nblkptr = 1 +
596 dn->dn_bonustype = bonustype;
597 dn->dn_bonuslen = bonuslen;
598 dn->dn_checksum = ZIO_CHECKSUM_INHERIT;
599 dn->dn_compress = ZIO_COMPRESS_INHERIT;
600 dn->dn_dirtyctx = 0;
602 dn->dn_free_txg = 0;
603 if (dn->dn_dirtyctx_firstset) {
604 kmem_free(dn->dn_dirtyctx_firstset, 1);
605 dn->dn_dirtyctx_firstset = NULL;
608 dn->dn_allocated_txg = tx->tx_txg;
609 dn->dn_id_flags = 0;
611 dnode_setdirty(dn, tx);
612 dn->dn_next_indblkshift[tx->tx_txg & TXG_MASK] = ibs;
613 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen;
614 dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype;
615 dn->dn_next_blksz[tx->tx_txg & TXG_MASK] = dn->dn_datablksz;
619 dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize,
626 spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
628 ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT || dmu_tx_private_ok(tx));
637 dnode_evict_dbufs(dn);
639 dn->dn_id_flags = 0;
641 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
642 dnode_setdirty(dn, tx);
643 if (dn->dn_datablksz != blocksize) {
645 ASSERT(dn->dn_maxblkid == 0 &&
646 (BP_IS_HOLE(&dn->dn_phys->dn_blkptr[0]) ||
647 dnode_block_freed(dn, 0)));
648 dnode_setdblksz(dn, blocksize);
649 dn->dn_next_blksz[tx->tx_txg&TXG_MASK] = blocksize;
651 if (dn->dn_bonuslen != bonuslen)
652 dn->dn_next_bonuslen[tx->tx_txg&TXG_MASK] = bonuslen;
658 if (dn->dn_bonustype != bonustype)
659 dn->dn_next_bonustype[tx->tx_txg&TXG_MASK] = bonustype;
660 if (dn->dn_nblkptr != nblkptr)
661 dn->dn_next_nblkptr[tx->tx_txg&TXG_MASK] = nblkptr;
662 if (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
663 dbuf_rm_spill(dn, tx);
664 dnode_rm_spill(dn, tx);
666 rw_exit(&dn->dn_struct_rwlock);
669 dn->dn_type = ot;
672 mutex_enter(&dn->dn_mtx);
673 dn->dn_bonustype = bonustype;
674 dn->dn_bonuslen = bonuslen;
675 dn->dn_nblkptr = nblkptr;
676 dn->dn_checksum = ZIO_CHECKSUM_INHERIT;
677 dn->dn_compress = ZIO_COMPRESS_INHERIT;
678 ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);
681 if (dn->dn_bonus) {
682 dn->dn_bonus->db.db_size =
683 DN_MAX_BONUSLEN - (dn->dn_nblkptr-1) * sizeof (blkptr_t);
684 ASSERT(dn->dn_bonuslen <= dn->dn_bonus->db.db_size);
687 dn->dn_allocated_txg = tx->tx_txg;
688 mutex_exit(&dn->dn_mtx);
987 dnode_t *dn = dnh->dnh_dnode;
995 while (refcount_count(&dn->dn_holds) > 0)
997 ASSERT(dn->dn_dbuf == NULL ||
998 dmu_buf_get_user(&dn->dn_dbuf->db) == NULL);
1000 dnode_destroy(dn); /* implicit zrl_remove() */
1009 dnode_t *dn;
1011 dn = dnode_create(os, dnp, NULL, object, dnh);
1013 DNODE_VERIFY(dn);
1024 dnode_t *dn;
1037 dn = dnh->dnh_dnode;
1044 ASSERT(refcount_is_zero(&dn->dn_holds));
1045 ASSERT(refcount_is_zero(&dn->dn_tx_holds));
1047 dnode_destroy(dn); /* implicit zrl_remove() */
1069 dnode_t *mdn, *dn;
1085 dn = (object == DMU_USERUSED_OBJECT) ?
1087 if (dn == NULL)
1089 type = dn->dn_type;
1094 DNODE_VERIFY(dn);
1095 (void) refcount_add(&dn->dn_holds, tag);
1096 *dnp = dn;
1161 dn = dnh->dnh_dnode;
1162 if (dn == NULL) {
1165 dn = dnode_create(os, phys, db, object, dnh);
1168 mutex_enter(&dn->dn_mtx);
1169 type = dn->dn_type;
1170 if (dn->dn_free_txg ||
1173 (type != DMU_OT_NONE || !refcount_is_zero(&dn->dn_holds)))) {
1174 mutex_exit(&dn->dn_mtx);
1179 if (refcount_add(&dn->dn_holds, tag) == 1)
1181 mutex_exit(&dn->dn_mtx);
1186 DNODE_VERIFY(dn);
1187 ASSERT3P(dn->dn_dbuf, ==, db);
1188 ASSERT3U(dn->dn_object, ==, object);
1191 *dnp = dn;
1210 dnode_add_ref(dnode_t *dn, void *tag)
1212 mutex_enter(&dn->dn_mtx);
1213 if (refcount_is_zero(&dn->dn_holds)) {
1214 mutex_exit(&dn->dn_mtx);
1217 VERIFY(1 < refcount_add(&dn->dn_holds, tag));
1218 mutex_exit(&dn->dn_mtx);
1223 dnode_rele(dnode_t *dn, void *tag)
1225 mutex_enter(&dn->dn_mtx);
1226 dnode_rele_and_unlock(dn, tag);
1230 dnode_rele_and_unlock(dnode_t *dn, void *tag)
1234 dmu_buf_impl_t *db = dn->dn_dbuf;
1235 dnode_handle_t *dnh = dn->dn_handle;
1237 refs = refcount_remove(&dn->dn_holds, tag);
1238 mutex_exit(&dn->dn_mtx);
1266 dnode_setdirty(dnode_t *dn, dmu_tx_t *tx)
1268 objset_t *os = dn->dn_objset;
1271 if (DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
1276 DNODE_VERIFY(dn);
1279 mutex_enter(&dn->dn_mtx);
1280 ASSERT(dn->dn_phys->dn_type || dn->dn_allocated_txg);
1281 ASSERT(dn->dn_free_txg == 0 || dn->dn_free_txg >= txg);
1282 mutex_exit(&dn->dn_mtx);
1288 dmu_objset_userquota_get_ids(dn, B_TRUE, tx);
1295 if (list_link_active(&dn->dn_dirty_link[txg & TXG_MASK])) {
1300 ASSERT(!refcount_is_zero(&dn->dn_holds) ||
1301 !avl_is_empty(&dn->dn_dbufs));
1302 ASSERT(dn->dn_datablksz != 0);
1303 ASSERT0(dn->dn_next_bonuslen[txg&TXG_MASK]);
1304 ASSERT0(dn->dn_next_blksz[txg&TXG_MASK]);
1305 ASSERT0(dn->dn_next_bonustype[txg&TXG_MASK]);
1308 dn->dn_object, txg);
1310 if (dn->dn_free_txg > 0 && dn->dn_free_txg <= txg) {
1311 list_insert_tail(&os->os_free_dnodes[txg&TXG_MASK], dn);
1313 list_insert_tail(&os->os_dirty_dnodes[txg&TXG_MASK], dn);
1327 VERIFY(dnode_add_ref(dn, (void *)(uintptr_t)tx->tx_txg));
1329 (void) dbuf_dirty(dn->dn_dbuf, tx);
1335 dnode_free(dnode_t *dn, dmu_tx_t *tx)
1339 dprintf("dn=%p txg=%llu\n", dn, tx->tx_txg);
1342 /* ASSERT3U(refcount_count(&dn->dn_holds), ==, 1); */
1344 mutex_enter(&dn->dn_mtx);
1345 if (dn->dn_type == DMU_OT_NONE || dn->dn_free_txg) {
1346 mutex_exit(&dn->dn_mtx);
1349 dn->dn_free_txg = tx->tx_txg;
1350 mutex_exit(&dn->dn_mtx);
1356 mutex_enter(&dn->dn_objset->os_lock);
1357 if (list_link_active(&dn->dn_dirty_link[txgoff])) {
1358 list_remove(&dn->dn_objset->os_dirty_dnodes[txgoff], dn);
1359 list_insert_tail(&dn->dn_objset->os_free_dnodes[txgoff], dn);
1360 mutex_exit(&dn->dn_objset->os_lock);
1362 mutex_exit(&dn->dn_objset->os_lock);
1363 dnode_setdirty(dn, tx);
1372 dnode_set_blksz(dnode_t *dn, uint64_t size, int ibs, dmu_tx_t *tx)
1377 ASSERT3U(size, <=, spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
1383 if (ibs == dn->dn_indblkshift)
1386 if (size >> SPA_MINBLOCKSHIFT == dn->dn_datablkszsec && ibs == 0)
1389 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1392 if (dn->dn_maxblkid != 0)
1395 mutex_enter(&dn->dn_dbufs_mtx);
1396 for (db = avl_first(&dn->dn_dbufs); db != NULL;
1397 db = AVL_NEXT(&dn->dn_dbufs, db)) {
1400 mutex_exit(&dn->dn_dbufs_mtx);
1404 mutex_exit(&dn->dn_dbufs_mtx);
1406 if (ibs && dn->dn_nlevels != 1)
1410 err = dbuf_hold_impl(dn, 0, 0, TRUE, FALSE, FTAG, &db);
1416 dnode_setdblksz(dn, size);
1417 dnode_setdirty(dn, tx);
1418 dn->dn_next_blksz[tx->tx_txg&TXG_MASK] = size;
1420 dn->dn_indblkshift = ibs;
1421 dn->dn_next_indblkshift[tx->tx_txg&TXG_MASK] = ibs;
1427 rw_exit(&dn->dn_struct_rwlock);
1431 rw_exit(&dn->dn_struct_rwlock);
1437 dnode_new_blkid(dnode_t *dn, uint64_t blkid, dmu_tx_t *tx, boolean_t have_read)
1446 RW_READ_HELD(&dn->dn_struct_rwlock) :
1447 RW_WRITE_HELD(&dn->dn_struct_rwlock));
1454 if (blkid <= dn->dn_maxblkid)
1457 if (!rw_tryupgrade(&dn->dn_struct_rwlock)) {
1458 rw_exit(&dn->dn_struct_rwlock);
1459 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1463 if (blkid <= dn->dn_maxblkid)
1466 dn->dn_maxblkid = blkid;
1472 epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
1473 for (sz = dn->dn_nblkptr;
1474 sz <= blkid && sz >= dn->dn_nblkptr; sz <<= epbs)
1477 if (new_nlevels > dn->dn_nlevels) {
1478 int old_nlevels = dn->dn_nlevels;
1483 dn->dn_nlevels = new_nlevels;
1485 ASSERT3U(new_nlevels, >, dn->dn_next_nlevels[txgoff]);
1486 dn->dn_next_nlevels[txgoff] = new_nlevels;
1489 db = dbuf_hold_level(dn, old_nlevels, 0, FTAG);
1495 mutex_enter(&dn->dn_mtx);
1497 list = &dn->dn_dirty_records[txgoff];
1499 dr_next = list_next(&dn->dn_dirty_records[txgoff], dr);
1504 list_remove(&dn->dn_dirty_records[txgoff], dr);
1510 mutex_exit(&dn->dn_mtx);
1515 rw_downgrade(&dn->dn_struct_rwlock);
1519 dnode_dirty_l1(dnode_t *dn, uint64_t l1blkid, dmu_tx_t *tx)
1521 dmu_buf_impl_t *db = dbuf_hold_level(dn, 1, l1blkid, FTAG);
1529 dnode_free_range(dnode_t *dn, uint64_t off, uint64_t len, dmu_tx_t *tx)
1537 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1538 blksz = dn->dn_datablksz;
1539 blkshift = dn->dn_datablkshift;
1540 epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
1553 if ((off >> blkshift) > dn->dn_maxblkid)
1556 ASSERT(dn->dn_maxblkid == 0);
1583 if (dbuf_hold_impl(dn, 0, dbuf_whichblock(dn, 0, off),
1590 rw_exit(&dn->dn_struct_rwlock);
1592 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1607 if ((off >> blkshift) > dn->dn_maxblkid)
1621 if (dbuf_hold_impl(dn, 0, dbuf_whichblock(dn, 0, off+len),
1626 rw_exit(&dn->dn_struct_rwlock);
1628 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
1667 if (dn->dn_nlevels > 1) {
1671 dnode_dirty_l1(dn, first, tx);
1673 last = dn->dn_maxblkid >> epbs;
1677 dnode_dirty_l1(dn, last, tx);
1679 int shift = dn->dn_datablkshift + dn->dn_indblkshift -
1689 int err = dnode_next_offset(dn, DNODE_FIND_HAVELOCK,
1708 dnode_dirty_l1(dn, i, tx);
1717 mutex_enter(&dn->dn_mtx);
1719 if (dn->dn_free_ranges[txgoff] == NULL) {
1720 dn->dn_free_ranges[txgoff] =
1721 range_tree_create(NULL, NULL, &dn->dn_mtx);
1723 range_tree_clear(dn->dn_free_ranges[txgoff], blkid, nblks);
1724 range_tree_add(dn->dn_free_ranges[txgoff], blkid, nblks);
1725 dprintf_dnode(dn, "blkid=%llu nblks=%llu txg=%llu\n",
1727 mutex_exit(&dn->dn_mtx);
1729 dbuf_free_range(dn, blkid, blkid + nblks - 1, tx);
1730 dnode_setdirty(dn, tx);
1733 rw_exit(&dn->dn_struct_rwlock);
1737 dnode_spill_freed(dnode_t *dn)
1741 mutex_enter(&dn->dn_mtx);
1743 if (dn->dn_rm_spillblk[i] == DN_KILL_SPILLBLK)
1746 mutex_exit(&dn->dn_mtx);
1752 dnode_block_freed(dnode_t *dn, uint64_t blkid)
1754 void *dp = spa_get_dsl(dn->dn_objset->os_spa);
1767 if (dn->dn_free_txg)
1771 return (dnode_spill_freed(dn));
1773 mutex_enter(&dn->dn_mtx);
1775 if (dn->dn_free_ranges[i] != NULL &&
1776 range_tree_contains(dn->dn_free_ranges[i], blkid, 1))
1779 mutex_exit(&dn->dn_mtx);
1785 dnode_diduse_space(dnode_t *dn, int64_t delta)
1788 dprintf_dnode(dn, "dn=%p dnp=%p used=%llu delta=%lld\n",
1789 dn, dn->dn_phys,
1790 (u_longlong_t)dn->dn_phys->dn_used,
1793 mutex_enter(&dn->dn_mtx);
1794 space = DN_USED_BYTES(dn->dn_phys);
1801 if (spa_version(dn->dn_objset->os_spa) < SPA_VERSION_DNODE_BYTES) {
1802 ASSERT((dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) == 0);
1804 dn->dn_phys->dn_used = space >> DEV_BSHIFT;
1806 dn->dn_phys->dn_used = space;
1807 dn->dn_phys->dn_flags |= DNODE_FLAG_USED_BYTES;
1809 mutex_exit(&dn->dn_mtx);
1817 dnode_willuse_space(dnode_t *dn, int64_t space, dmu_tx_t *tx)
1819 objset_t *os = dn->dn_objset;
1850 dnode_next_offset_level(dnode_t *dn, int flags, uint64_t *offset,
1855 uint64_t epbs = dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
1862 dn->dn_object, *offset, lvl, dn->dn_phys->dn_nlevels);
1868 if (lvl == dn->dn_phys->dn_nlevels) {
1870 epb = dn->dn_phys->dn_nblkptr;
1871 data = dn->dn_phys->dn_blkptr;
1873 uint64_t blkid = dbuf_whichblock(dn, lvl, *offset);
1874 error = dbuf_hold_impl(dn, lvl, blkid, TRUE, FALSE, FTAG, &db);
1909 ASSERT(dn->dn_type == DMU_OT_DNODE);
1922 span = (lvl - 1) * epbs + dn->dn_datablkshift;
1968 * dnode_next_offset(dn, flags, offset, 1, 1, 0);
1983 dnode_next_offset(dnode_t *dn, int flags, uint64_t *offset,
1991 rw_enter(&dn->dn_struct_rwlock, RW_READER);
1993 if (dn->dn_phys->dn_nlevels == 0) {
1998 if (dn->dn_datablkshift == 0) {
1999 if (*offset < dn->dn_datablksz) {
2001 *offset = dn->dn_datablksz;
2008 maxlvl = dn->dn_phys->dn_nlevels;
2011 error = dnode_next_offset_level(dn,
2018 error = dnode_next_offset_level(dn,
2036 rw_exit(&dn->dn_struct_rwlock);