Lines Matching +full:os +full:- +full:initiated
9 * or https://opensource.org/licenses/CDDL-1.0.
45 int txgoff = tx->tx_txg & TXG_MASK;
46 int nblkptr = dn->dn_phys->dn_nblkptr;
47 int old_toplvl = dn->dn_phys->dn_nlevels - 1;
48 int new_level = dn->dn_next_nlevels[txgoff];
51 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
54 ASSERT(dn->dn_phys->dn_type != DMU_OT_NONE);
55 ASSERT(new_level > 1 && dn->dn_phys->dn_nlevels > 0);
57 db = dbuf_hold_level(dn, dn->dn_phys->dn_nlevels, 0, FTAG);
60 dn->dn_phys->dn_nlevels = new_level;
61 dprintf("os=%p obj=%llu, increase to %d\n", dn->dn_objset,
62 (u_longlong_t)dn->dn_object, dn->dn_phys->dn_nlevels);
73 children[i] = dbuf_find(dn->dn_objset, dn->dn_object,
79 if (dn->dn_dbuf != NULL)
80 rw_enter(&dn->dn_dbuf->db_rwlock, RW_WRITER);
81 rw_enter(&db->db_rwlock, RW_WRITER);
82 ASSERT(db->db.db_data);
83 ASSERT(arc_released(db->db_buf));
84 ASSERT3U(sizeof (blkptr_t) * nblkptr, <=, db->db.db_size);
85 memcpy(db->db.db_data, dn->dn_phys->dn_blkptr,
87 arc_buf_freeze(db->db_buf);
100 if (child->db_parent && child->db_parent != dn->dn_dbuf) {
101 ASSERT(child->db_parent->db_level == db->db_level);
102 ASSERT(child->db_blkptr !=
103 &dn->dn_phys->dn_blkptr[child->db_blkid]);
104 mutex_exit(&child->db_mtx);
107 ASSERT(child->db_parent == NULL ||
108 child->db_parent == dn->dn_dbuf);
110 child->db_parent = db;
112 if (db->db.db_data)
113 child->db_blkptr = (blkptr_t *)db->db.db_data + i;
115 child->db_blkptr = NULL;
116 dprintf_dbuf_bp(child, child->db_blkptr,
119 mutex_exit(&child->db_mtx);
122 memset(dn->dn_phys->dn_blkptr, 0, sizeof (blkptr_t) * nblkptr);
124 rw_exit(&db->db_rwlock);
125 if (dn->dn_dbuf != NULL)
126 rw_exit(&dn->dn_dbuf->db_rwlock);
130 rw_exit(&dn->dn_struct_rwlock);
136 dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;
139 dprintf("ds=%p obj=%llx num=%d\n", ds, (u_longlong_t)dn->dn_object,
147 ASSERT3U(bytesfreed, <=, DN_USED_BYTES(dn->dn_phys));
163 if (spa_feature_is_active(dn->dn_objset->os_spa,
171 dnode_diduse_space(dn, -bytesfreed);
181 uint64_t txg = tx->tx_txg;
186 epbs = dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
187 off = start - (db->db_blkid << epbs);
188 num = end - start + 1;
190 ASSERT3U(dn->dn_phys->dn_indblkshift, >=, SPA_BLKPTRSHIFT);
192 ASSERT3U(start, >=, (db->db_blkid << epbs));
193 ASSERT3U(db->db_level, >, 0);
194 ASSERT3U(db->db.db_size, ==, 1 << dn->dn_phys->dn_indblkshift);
195 ASSERT3U(off+num, <=, db->db.db_size >> SPA_BLKPTRSHIFT);
196 ASSERT(db->db_blkptr != NULL);
203 ASSERT(db->db_level == 1);
205 rw_enter(&dn->dn_struct_rwlock, RW_READER);
206 err = dbuf_hold_impl(dn, db->db_level - 1,
207 (db->db_blkid << epbs) + i, TRUE, FALSE, FTAG, &child);
208 rw_exit(&dn->dn_struct_rwlock);
212 ASSERT(child->db_level == 0);
217 buf = dr->dt.dl.dr_data->b_data;
218 for (j = 0; j < child->db.db_size >> 3; j++) {
234 mutex_enter(&child->db_mtx);
235 buf = child->db.db_data;
236 if (buf != NULL && child->db_state != DB_FILL &&
237 list_is_empty(&child->db_dirty_records)) {
238 for (j = 0; j < child->db.db_size >> 3; j++) {
249 mutex_exit(&child->db_mtx);
284 * 1 - if level > 1 and there are no children with level <= 1
285 * 2 - if this block was evicted since we read it from
288 if (db->db_state != DB_CACHED)
295 * be written (otherwise, we would have incorrect on-disk state
301 * dirty, but the open-context code happens to dirty. E.g. if the
308 VERIFY(BP_GET_FILL(db->db_blkptr) == 0 || db->db_dirtycnt > 0);
312 bp = db->db.db_data;
316 epbs = dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
318 shift = (db->db_level - 1) * epbs;
319 dbstart = db->db_blkid << epbs;
322 bp += start - dbstart;
326 dbend = ((db->db_blkid + 1) << epbs) - 1;
327 end = (blkid + nblks - 1) >> shift;
333 if (db->db_level == 1) {
335 rw_enter(&db->db_rwlock, RW_WRITER);
336 free_blocks(dn, bp, end - start + 1, tx);
337 rw_exit(&db->db_rwlock);
342 rw_enter(&dn->dn_struct_rwlock, RW_READER);
343 VERIFY0(dbuf_hold_impl(dn, db->db_level - 1,
345 rw_exit(&dn->dn_struct_rwlock);
346 ASSERT3P(bp, ==, subdb->db_blkptr);
354 rw_enter(&db->db_rwlock, RW_WRITER);
355 for (i = 0, bp = db->db.db_data; i < 1 << epbs; i++, bp++)
357 memset(db->db.db_data, 0, db->db.db_size);
358 free_blocks(dn, db->db_blkptr, 1, tx);
359 rw_exit(&db->db_rwlock);
363 arc_buf_freeze(db->db_buf);
374 blkptr_t *bp = dn->dn_phys->dn_blkptr;
375 int dnlevel = dn->dn_phys->dn_nlevels;
378 if (blkid > dn->dn_phys->dn_maxblkid)
381 ASSERT(dn->dn_phys->dn_maxblkid < UINT64_MAX);
382 if (blkid + nblks > dn->dn_phys->dn_maxblkid) {
383 nblks = dn->dn_phys->dn_maxblkid - blkid + 1;
389 if (blkid >= dn->dn_phys->dn_nblkptr) {
393 ASSERT3U(blkid + nblks, <=, dn->dn_phys->dn_nblkptr);
396 int shift = (dnlevel - 1) *
397 (dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT);
399 int end = (blkid + nblks - 1) >> shift;
402 ASSERT(start < dn->dn_phys->dn_nblkptr);
407 rw_enter(&dn->dn_struct_rwlock, RW_READER);
408 VERIFY0(dbuf_hold_impl(dn, dnlevel - 1, i,
410 rw_exit(&dn->dn_struct_rwlock);
430 if (trunc && !dn->dn_objset->os_raw_receive) {
432 dn->dn_phys->dn_maxblkid = blkid == 0 ? 0 : blkid - 1;
434 off = (dn->dn_phys->dn_maxblkid + 1) *
435 (dn->dn_phys->dn_datablkszsec << SPA_MINBLOCKSHIFT);
436 ASSERT(off < dn->dn_phys->dn_maxblkid ||
437 dn->dn_phys->dn_maxblkid == 0 ||
452 dnode_t *dn = dsfra->dsfra_dnode;
454 mutex_exit(&dn->dn_mtx);
456 dsfra->dsfra_free_indirects, dsfra->dsfra_tx);
457 mutex_enter(&dn->dn_mtx);
471 mutex_enter(&dn->dn_dbufs_mtx);
472 for (db = avl_first(&dn->dn_dbufs); db != NULL; db = db_next) {
480 mutex_enter(&db->db_mtx);
481 if (db->db_state != DB_EVICTING &&
482 zfs_refcount_is_zero(&db->db_holds)) {
483 db_marker->db_level = db->db_level;
484 db_marker->db_blkid = db->db_blkid;
491 db_marker->db_state = DB_MARKER;
492 db_marker->db_parent = (void *)((uintptr_t)db - 1);
493 avl_insert_here(&dn->dn_dbufs, db_marker, db,
511 db_next = AVL_NEXT(&dn->dn_dbufs, db_marker);
512 avl_remove(&dn->dn_dbufs, db_marker);
514 db->db_pending_evict = TRUE;
515 mutex_exit(&db->db_mtx);
516 db_next = AVL_NEXT(&dn->dn_dbufs, db);
519 mutex_exit(&dn->dn_dbufs_mtx);
529 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
530 if (dn->dn_bonus != NULL) {
531 if (zfs_refcount_is_zero(&dn->dn_bonus->db_holds)) {
532 mutex_enter(&dn->dn_bonus->db_mtx);
533 dbuf_destroy(dn->dn_bonus);
534 dn->dn_bonus = NULL;
536 dn->dn_bonus->db_pending_evict = TRUE;
539 rw_exit(&dn->dn_struct_rwlock);
548 dmu_buf_impl_t *db = dr->dr_dbuf;
549 uint64_t txg = dr->dr_txg;
551 if (db->db_level != 0)
552 dnode_undirty_dbufs(&dr->dt.di.dr_children);
554 mutex_enter(&db->db_mtx);
555 /* XXX - use dbuf_undirty()? */
557 ASSERT(list_head(&db->db_dirty_records) == dr);
558 list_remove_head(&db->db_dirty_records);
559 ASSERT(list_is_empty(&db->db_dirty_records));
560 db->db_dirtycnt -= 1;
561 if (db->db_level == 0) {
562 ASSERT(db->db_blkid == DMU_BONUS_BLKID ||
563 dr->dt.dl.dr_data == db->db_buf);
566 mutex_destroy(&dr->dt.di.dr_mtx);
567 list_destroy(&dr->dt.di.dr_children);
577 int txgoff = tx->tx_txg & TXG_MASK;
585 ASSERT0(DN_USED_BYTES(dn->dn_phys));
586 ASSERT(BP_IS_HOLE(dn->dn_phys->dn_blkptr));
588 dnode_undirty_dbufs(&dn->dn_dirty_records[txgoff]);
592 * XXX - It would be nice to assert this, but we may still
598 * ASSERT3U(zfs_refcount_count(&dn->dn_holds), ==, 1);
602 dn->dn_next_nlevels[txgoff] = 0;
603 dn->dn_next_indblkshift[txgoff] = 0;
604 dn->dn_next_blksz[txgoff] = 0;
605 dn->dn_next_maxblkid[txgoff] = 0;
608 ASSERT(dn->dn_phys->dn_type != DMU_OT_NONE);
609 ASSERT(dn->dn_type != DMU_OT_NONE);
611 ASSERT(dn->dn_free_txg > 0);
612 if (dn->dn_allocated_txg != dn->dn_free_txg)
613 dmu_buf_will_dirty(&dn->dn_dbuf->db, tx);
614 memset(dn->dn_phys, 0, sizeof (dnode_phys_t) * dn->dn_num_slots);
617 mutex_enter(&dn->dn_mtx);
618 dn->dn_type = DMU_OT_NONE;
619 dn->dn_maxblkid = 0;
620 dn->dn_allocated_txg = 0;
621 dn->dn_free_txg = 0;
622 dn->dn_have_spill = B_FALSE;
623 dn->dn_num_slots = 1;
624 mutex_exit(&dn->dn_mtx);
626 ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT);
628 dnode_rele(dn, (void *)(uintptr_t)tx->tx_txg);
642 objset_t *os = dn->dn_objset;
643 dnode_phys_t *dnp = dn->dn_phys;
644 int txgoff = tx->tx_txg & TXG_MASK;
645 list_t *list = &dn->dn_dirty_records[txgoff];
650 ASSERT(dnp->dn_type != DMU_OT_NONE || dn->dn_allocated_txg);
651 ASSERT(dnp->dn_type != DMU_OT_NONE ||
655 ASSERT(dn->dn_dbuf == NULL || arc_released(dn->dn_dbuf->db_buf));
661 if (dmu_objset_userused_enabled(os) &&
662 !DMU_OBJECT_IS_SPECIAL(dn->dn_object) &&
663 (!os->os_encrypted || !dmu_objset_is_receiving(os))) {
664 mutex_enter(&dn->dn_mtx);
665 dn->dn_oldused = DN_USED_BYTES(dn->dn_phys);
666 dn->dn_oldflags = dn->dn_phys->dn_flags;
667 dn->dn_phys->dn_flags |= DNODE_FLAG_USERUSED_ACCOUNTED;
668 if (dmu_objset_userobjused_enabled(dn->dn_objset))
669 dn->dn_phys->dn_flags |=
671 mutex_exit(&dn->dn_mtx);
673 } else if (!(os->os_encrypted && dmu_objset_is_receiving(os))) {
680 ASSERT(!(dn->dn_phys->dn_flags &
682 ASSERT(!(dn->dn_phys->dn_flags &
686 mutex_enter(&dn->dn_mtx);
687 if (dn->dn_allocated_txg == tx->tx_txg) {
689 if (dnp->dn_type == DMU_OT_NONE) {
691 dnp->dn_nlevels = 1;
692 dnp->dn_nblkptr = dn->dn_nblkptr;
695 dnp->dn_type = dn->dn_type;
696 dnp->dn_bonustype = dn->dn_bonustype;
697 dnp->dn_bonuslen = dn->dn_bonuslen;
700 dnp->dn_extra_slots = dn->dn_num_slots - 1;
702 ASSERT(dnp->dn_nlevels > 1 ||
703 BP_IS_HOLE(&dnp->dn_blkptr[0]) ||
704 BP_IS_EMBEDDED(&dnp->dn_blkptr[0]) ||
705 BP_GET_LSIZE(&dnp->dn_blkptr[0]) ==
706 dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
707 ASSERT(dnp->dn_nlevels < 2 ||
708 BP_IS_HOLE(&dnp->dn_blkptr[0]) ||
709 BP_GET_LSIZE(&dnp->dn_blkptr[0]) == 1 << dnp->dn_indblkshift);
711 if (dn->dn_next_type[txgoff] != 0) {
712 dnp->dn_type = dn->dn_type;
713 dn->dn_next_type[txgoff] = 0;
716 if (dn->dn_next_blksz[txgoff] != 0) {
717 ASSERT(P2PHASE(dn->dn_next_blksz[txgoff],
719 ASSERT(BP_IS_HOLE(&dnp->dn_blkptr[0]) ||
720 dn->dn_maxblkid == 0 || list_head(list) != NULL ||
721 dn->dn_next_blksz[txgoff] >> SPA_MINBLOCKSHIFT ==
722 dnp->dn_datablkszsec ||
723 !range_tree_is_empty(dn->dn_free_ranges[txgoff]));
724 dnp->dn_datablkszsec =
725 dn->dn_next_blksz[txgoff] >> SPA_MINBLOCKSHIFT;
726 dn->dn_next_blksz[txgoff] = 0;
729 if (dn->dn_next_bonuslen[txgoff] != 0) {
730 if (dn->dn_next_bonuslen[txgoff] == DN_ZERO_BONUSLEN)
731 dnp->dn_bonuslen = 0;
733 dnp->dn_bonuslen = dn->dn_next_bonuslen[txgoff];
734 ASSERT(dnp->dn_bonuslen <=
735 DN_SLOTS_TO_BONUSLEN(dnp->dn_extra_slots + 1));
736 dn->dn_next_bonuslen[txgoff] = 0;
739 if (dn->dn_next_bonustype[txgoff] != 0) {
740 ASSERT(DMU_OT_IS_VALID(dn->dn_next_bonustype[txgoff]));
741 dnp->dn_bonustype = dn->dn_next_bonustype[txgoff];
742 dn->dn_next_bonustype[txgoff] = 0;
745 boolean_t freeing_dnode = dn->dn_free_txg > 0 &&
746 dn->dn_free_txg <= tx->tx_txg;
752 if (dn->dn_rm_spillblk[txgoff] || freeing_dnode) {
753 if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR)
755 dn->dn_rm_spillblk[txgoff] = 0;
758 if (dn->dn_next_indblkshift[txgoff] != 0) {
759 ASSERT(dnp->dn_nlevels == 1);
760 dnp->dn_indblkshift = dn->dn_next_indblkshift[txgoff];
761 dn->dn_next_indblkshift[txgoff] = 0;
765 * Just take the live (open-context) values for checksum and compress.
769 dnp->dn_checksum = dn->dn_checksum;
770 dnp->dn_compress = dn->dn_compress;
772 mutex_exit(&dn->dn_mtx);
775 free_blocks(dn, DN_SPILL_BLKPTR(dn->dn_phys), 1, tx);
776 mutex_enter(&dn->dn_mtx);
777 dnp->dn_flags &= ~DNODE_FLAG_SPILL_BLKPTR;
778 mutex_exit(&dn->dn_mtx);
782 if (dn->dn_free_ranges[txgoff] != NULL) {
787 mutex_enter(&dn->dn_mtx);
789 ASSERT(range_tree_contains(dn->dn_free_ranges[txgoff],
790 0, dn->dn_maxblkid + 1));
800 range_tree_walk(dn->dn_free_ranges[txgoff],
802 range_tree_vacate(dn->dn_free_ranges[txgoff], NULL, NULL);
803 range_tree_destroy(dn->dn_free_ranges[txgoff]);
804 dn->dn_free_ranges[txgoff] = NULL;
805 mutex_exit(&dn->dn_mtx);
809 dn->dn_objset->os_freed_dnodes++;
814 if (dn->dn_num_slots > DNODE_MIN_SLOTS) {
815 dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;
816 mutex_enter(&ds->ds_lock);
817 ds->ds_feature_activation[SPA_FEATURE_LARGE_DNODE] =
819 mutex_exit(&ds->ds_lock);
822 if (dn->dn_next_nlevels[txgoff]) {
824 dn->dn_next_nlevels[txgoff] = 0;
832 if (dn->dn_next_maxblkid[txgoff]) {
833 mutex_enter(&dn->dn_mtx);
834 dnp->dn_maxblkid =
835 dn->dn_next_maxblkid[txgoff] & ~DMU_NEXT_MAXBLKID_SET;
836 dn->dn_next_maxblkid[txgoff] = 0;
837 mutex_exit(&dn->dn_mtx);
840 if (dn->dn_next_nblkptr[txgoff]) {
842 ASSERT(dn->dn_allocated_txg == tx->tx_txg);
843 if (dn->dn_next_nblkptr[txgoff] > dnp->dn_nblkptr) {
845 memset(dnp->dn_blkptr + dnp->dn_nblkptr, 0,
847 (dn->dn_next_nblkptr[txgoff] - dnp->dn_nblkptr));
851 ASSERT(dn->dn_next_nblkptr[txgoff] < dnp->dn_nblkptr);
853 for (i = 0; i < dnp->dn_nblkptr; i++) {
854 if (i >= dn->dn_next_nblkptr[txgoff])
855 ASSERT(BP_IS_HOLE(&dnp->dn_blkptr[i]));
859 mutex_enter(&dn->dn_mtx);
860 dnp->dn_nblkptr = dn->dn_next_nblkptr[txgoff];
861 dn->dn_next_nblkptr[txgoff] = 0;
862 mutex_exit(&dn->dn_mtx);
865 dbuf_sync_list(list, dn->dn_phys->dn_nlevels - 1, tx);
867 if (!DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
869 dnode_rele(dn, (void *)(uintptr_t)tx->tx_txg);
872 ASSERT3U(dnp->dn_bonuslen, <=, DN_MAX_BONUS_LEN(dnp));
877 * initiated the IO for the dnode's dbuf. Additionally, the caller