Update core ZFS code from build 121 to build 141.

[mirror_zfs-debian.git] / module / zfs / dnode_sync.c

diff --git a/module/zfs/dnode_sync.c b/module/zfs/dnode_sync.c
index 184fe292b5ee717d76441053c83457f2ef735792..f9ec9f6023d2abc3c4feb63c2111756cd2ce58b9 100644 (file)
--- a/module/zfs/dnode_sync.c
+++ b/module/zfs/dnode_sync.c
@@ -19,8 +19,7 @@
  * CDDL HEADER END
  */
 /*
- * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
+ * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  */
 
 #include <sys/zfs_context.h>
@@ -120,7 +119,7 @@ free_blocks(dnode_t *dn, blkptr_t *bp, int num, dmu_tx_t *tx)
                if (BP_IS_HOLE(bp))
                        continue;
 
-               bytesfreed += dsl_dataset_block_kill(ds, bp, dn->dn_zio, tx);
+               bytesfreed += dsl_dataset_block_kill(ds, bp, tx, B_FALSE);
                ASSERT3U(bytesfreed, <=, DN_USED_BYTES(dn->dn_phys));
                bzero(bp, sizeof (blkptr_t));
                blocks_freed += 1;
@@ -228,7 +227,7 @@ free_children(dmu_buf_impl_t *db, uint64_t blkid, uint64_t nblks, int trunc,
        if (db->db_state != DB_CACHED)
                (void) dbuf_read(db, NULL, DB_RF_MUST_SUCCEED);
 
-       arc_release(db->db_buf, db);
+       dbuf_release_bp(db);
        bp = (blkptr_t *)db->db.db_data;
 
        epbs = db->db_dnode->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
@@ -424,6 +423,9 @@ dnode_undirty_dbufs(list_t *list)
                dmu_buf_impl_t *db = dr->dr_dbuf;
                uint64_t txg = dr->dr_txg;
 
+               if (db->db_level != 0)
+                       dnode_undirty_dbufs(&dr->dt.di.dr_children);
+
                mutex_enter(&db->db_mtx);
                /* XXX - use dbuf_undirty()? */
                list_remove(list, dr);
@@ -431,16 +433,12 @@ dnode_undirty_dbufs(list_t *list)
                db->db_last_dirty = NULL;
                db->db_dirtycnt -= 1;
                if (db->db_level == 0) {
-                       ASSERT(db->db_blkid == DB_BONUS_BLKID ||
+                       ASSERT(db->db_blkid == DMU_BONUS_BLKID ||
                            dr->dt.dl.dr_data == db->db_buf);
                        dbuf_unoverride(dr);
-                       mutex_exit(&db->db_mtx);
-               } else {
-                       mutex_exit(&db->db_mtx);
-                       dnode_undirty_dbufs(&dr->dt.di.dr_children);
                }
                kmem_free(dr, sizeof (dbuf_dirty_record_t));
-               dbuf_rele(db, (void *)(uintptr_t)txg);
+               dbuf_rele_and_unlock(db, (void *)(uintptr_t)txg);
        }
 }
 
@@ -491,6 +489,7 @@ dnode_sync_free(dnode_t *dn, dmu_tx_t *tx)
        dn->dn_maxblkid = 0;
        dn->dn_allocated_txg = 0;
        dn->dn_free_txg = 0;
+       dn->dn_have_spill = B_FALSE;
        mutex_exit(&dn->dn_mtx);
 
        ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT);
@@ -513,6 +512,7 @@ dnode_sync(dnode_t *dn, dmu_tx_t *tx)
        int txgoff = tx->tx_txg & TXG_MASK;
        list_t *list = &dn->dn_dirty_records[txgoff];
        static const dnode_phys_t zerodn = { 0 };
+       boolean_t kill_spill = B_FALSE;
 
        ASSERT(dmu_tx_is_syncing(tx));
        ASSERT(dnp->dn_type != DMU_OT_NONE || dn->dn_allocated_txg);
@@ -524,10 +524,12 @@ dnode_sync(dnode_t *dn, dmu_tx_t *tx)
 
        if (dmu_objset_userused_enabled(dn->dn_objset) &&
            !DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
-               ASSERT(dn->dn_oldphys == NULL);
-               dn->dn_oldphys = zio_buf_alloc(sizeof (dnode_phys_t));
-               *dn->dn_oldphys = *dn->dn_phys; /* struct assignment */
+               mutex_enter(&dn->dn_mtx);
+               dn->dn_oldused = DN_USED_BYTES(dn->dn_phys);
+               dn->dn_oldflags = dn->dn_phys->dn_flags;
                dn->dn_phys->dn_flags |= DNODE_FLAG_USERUSED_ACCOUNTED;
+               mutex_exit(&dn->dn_mtx);
+               dmu_objset_userquota_get_ids(dn, B_FALSE, tx);
        } else {
                /* Once we account for it, we should always account for it. */
                ASSERT(!(dn->dn_phys->dn_flags &
@@ -558,6 +560,7 @@ dnode_sync(dnode_t *dn, dmu_tx_t *tx)
                    SPA_MINBLOCKSIZE) == 0);
                ASSERT(BP_IS_HOLE(&dnp->dn_blkptr[0]) ||
                    dn->dn_maxblkid == 0 || list_head(list) != NULL ||
+                   avl_last(&dn->dn_ranges[txgoff]) ||
                    dn->dn_next_blksz[txgoff] >> SPA_MINBLOCKSHIFT ==
                    dnp->dn_datablkszsec);
                dnp->dn_datablkszsec =
@@ -574,6 +577,24 @@ dnode_sync(dnode_t *dn, dmu_tx_t *tx)
                dn->dn_next_bonuslen[txgoff] = 0;
        }
 
+       if (dn->dn_next_bonustype[txgoff]) {
+               ASSERT(dn->dn_next_bonustype[txgoff] < DMU_OT_NUMTYPES);
+               dnp->dn_bonustype = dn->dn_next_bonustype[txgoff];
+               dn->dn_next_bonustype[txgoff] = 0;
+       }
+
+       /*
+        * We will either remove a spill block when a file is being removed
+        * or we have been asked to remove it.
+        */
+       if (dn->dn_rm_spillblk[txgoff] ||
+           ((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) &&
+           dn->dn_free_txg > 0 && dn->dn_free_txg <= tx->tx_txg)) {
+               if ((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR))
+                       kill_spill = B_TRUE;
+               dn->dn_rm_spillblk[txgoff] = 0;
+       }
+
        if (dn->dn_next_indblkshift[txgoff]) {
                ASSERT(dnp->dn_nlevels == 1);
                dnp->dn_indblkshift = dn->dn_next_indblkshift[txgoff];
@@ -590,6 +611,13 @@ dnode_sync(dnode_t *dn, dmu_tx_t *tx)
 
        mutex_exit(&dn->dn_mtx);
 
+       if (kill_spill) {
+               (void) free_blocks(dn, &dn->dn_phys->dn_spill, 1, tx);
+               mutex_enter(&dn->dn_mtx);
+               dnp->dn_flags &= ~DNODE_FLAG_SPILL_BLKPTR;
+               mutex_exit(&dn->dn_mtx);
+       }
+
        /* process all the "freed" ranges in the file */
        while (rp = avl_last(&dn->dn_ranges[txgoff])) {
                dnode_sync_free_range(dn, rp->fr_blkid, rp->fr_nblks, tx);