 @@ -1,1414 +1,1414 @@
 /*
  * CDDL HEADER START
+ *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
+ *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or http://www.opensolaris.org/os/licensing.
  * See the License for the specific language governing permissions
  * and limitations under the License.
+ *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
  * Copyright (c) 2014 Integros [integros.com]
  */
 #include <sys/dmu.h>
 #include <sys/dmu_impl.h>
 #include <sys/dbuf.h>
 #include <sys/dmu_tx.h>
 #include <sys/dmu_objset.h>
 #include <sys/dsl_dataset.h> /* for dsl_dataset_block_freeable() */
 #include <sys/dsl_dir.h> /* for dsl_dir_tempreserve_*() */
 #include <sys/dsl_pool.h>
 #include <sys/zap_impl.h> /* for fzap_default_block_shift */
 #include <sys/spa.h>
 #include <sys/sa.h>
 #include <sys/sa_impl.h>
 #include <sys/zfs_context.h>
 #include <sys/varargs.h>
 typedef void (*dmu_tx_hold_func_t)(dmu_tx_t *tx, struct dnode *dn,
     uint64_t arg1, uint64_t arg2);
 dmu_tx_t *
 dmu_tx_create_dd(dsl_dir_t *dd)
+{
 	dmu_tx_t *tx = kmem_zalloc(sizeof (dmu_tx_t), KM_SLEEP);
 	tx->tx_dir = dd;
 	if (dd != NULL)
 		tx->tx_pool = dd->dd_pool;
 	list_create(&tx->tx_holds, sizeof (dmu_tx_hold_t),
 	    offsetof(dmu_tx_hold_t, txh_node));
 	list_create(&tx->tx_callbacks, sizeof (dmu_tx_callback_t),
 	    offsetof(dmu_tx_callback_t, dcb_node));
 	tx->tx_start = gethrtime();
 #ifdef ZFS_DEBUG
 	refcount_create(&tx->tx_space_written);
 	refcount_create(&tx->tx_space_freed);
 #endif
 	return (tx);
+}
 dmu_tx_t *
 dmu_tx_create(objset_t *os)
+{
 	dmu_tx_t *tx = dmu_tx_create_dd(os->os_dsl_dataset->ds_dir);
 	tx->tx_objset = os;
 	tx->tx_lastsnap_txg = dsl_dataset_prev_snap_txg(os->os_dsl_dataset);
 	return (tx);
+}
 dmu_tx_t *
 dmu_tx_create_assigned(struct dsl_pool *dp, uint64_t txg)
+{
 	dmu_tx_t *tx = dmu_tx_create_dd(NULL);
 	ASSERT3U(txg, <=, dp->dp_tx.tx_open_txg);
 	tx->tx_pool = dp;
 	tx->tx_txg = txg;
 	tx->tx_anyobj = TRUE;
 	return (tx);
+}
 int
 dmu_tx_is_syncing(dmu_tx_t *tx)
+{
 	return (tx->tx_anyobj);
+}
 int
 dmu_tx_private_ok(dmu_tx_t *tx)
+{
 	return (tx->tx_anyobj);
+}
 static dmu_tx_hold_t *
 dmu_tx_hold_object_impl(dmu_tx_t *tx, objset_t *os, uint64_t object,
     enum dmu_tx_hold_type type, uint64_t arg1, uint64_t arg2)
+{
 	dmu_tx_hold_t *txh;
 	dnode_t *dn = NULL;
 	int err;
 	if (object != DMU_NEW_OBJECT) {
 		err = dnode_hold(os, object, tx, &dn);
 		if (err) {
 			tx->tx_err = err;
 			return (NULL);
+		}
 		if (err == 0 && tx->tx_txg != 0) {
 			mutex_enter(&dn->dn_mtx);
 			/*
 			 * dn->dn_assigned_txg == tx->tx_txg doesn't pose a
 			 * problem, but there's no way for it to happen (for
 			 * now, at least).
 			 */
 			ASSERT(dn->dn_assigned_txg == 0);
 			dn->dn_assigned_txg = tx->tx_txg;
 			(void) refcount_add(&dn->dn_tx_holds, tx);
 			mutex_exit(&dn->dn_mtx);
+		}
+	}
 	txh = kmem_zalloc(sizeof (dmu_tx_hold_t), KM_SLEEP);
 	txh->txh_tx = tx;
 	txh->txh_dnode = dn;
 	refcount_create(&txh->txh_space_towrite);
 	refcount_create(&txh->txh_space_tofree);
 	refcount_create(&txh->txh_space_tooverwrite);
 	refcount_create(&txh->txh_space_tounref);
 	refcount_create(&txh->txh_memory_tohold);
 	refcount_create(&txh->txh_fudge);
 #ifdef ZFS_DEBUG
 	txh->txh_type = type;
 	txh->txh_arg1 = arg1;
 	txh->txh_arg2 = arg2;
 #endif
 	list_insert_tail(&tx->tx_holds, txh);
 	return (txh);
+}
 void
 dmu_tx_add_new_object(dmu_tx_t *tx, objset_t *os, uint64_t object)
+{
 	/*
 	 * If we're syncing, they can manipulate any object anyhow, and
 	 * the hold on the dnode_t can cause problems.
 	 */
 	if (!dmu_tx_is_syncing(tx)) {
 		(void) dmu_tx_hold_object_impl(tx, os,
 		    object, THT_NEWOBJECT, 0, 0);
+	}
+}
 static int
 dmu_tx_check_ioerr(zio_t *zio, dnode_t *dn, int level, uint64_t blkid)
+{
 	int err;
 	dmu_buf_impl_t *db;
 	rw_enter(&dn->dn_struct_rwlock, RW_READER);
 	db = dbuf_hold_level(dn, level, blkid, FTAG);
 	rw_exit(&dn->dn_struct_rwlock);
 	if (db == NULL)
 		return (SET_ERROR(EIO));
 	err = dbuf_read(db, zio, DB_RF_CANFAIL | DB_RF_NOPREFETCH);
 	dbuf_rele(db, FTAG);
 	return (err);
+}
 static void
 dmu_tx_count_twig(dmu_tx_hold_t *txh, dnode_t *dn, dmu_buf_impl_t *db,
     int level, uint64_t blkid, boolean_t freeable, uint64_t *history)
+{
 	objset_t *os = dn->dn_objset;
 	dsl_dataset_t *ds = os->os_dsl_dataset;
 	int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
 	dmu_buf_impl_t *parent = NULL;
 	blkptr_t *bp = NULL;
 	uint64_t space;
 	if (level >= dn->dn_nlevels || history[level] == blkid)
 		return;
 	history[level] = blkid;
 	space = (level == 0) ? dn->dn_datablksz : (1ULL << dn->dn_indblkshift);
 	if (db == NULL || db == dn->dn_dbuf) {
 		ASSERT(level != 0);
 		db = NULL;
 	} else {
 		ASSERT(DB_DNODE(db) == dn);
 		ASSERT(db->db_level == level);
 		ASSERT(db->db.db_size == space);
 		ASSERT(db->db_blkid == blkid);
 		bp = db->db_blkptr;
 		parent = db->db_parent;
+	}
 	freeable = (bp && (freeable ||
 	    dsl_dataset_block_freeable(ds, bp, bp->blk_birth)));
 	if (freeable) {
 		(void) refcount_add_many(&txh->txh_space_tooverwrite,
 		    space, FTAG);
 	} else {
 		(void) refcount_add_many(&txh->txh_space_towrite,
 		    space, FTAG);
+	}
 	if (bp) {
 		(void) refcount_add_many(&txh->txh_space_tounref,
 		    bp_get_dsize(os->os_spa, bp), FTAG);
+	}
 	dmu_tx_count_twig(txh, dn, parent, level + 1,
 	    blkid >> epbs, freeable, history);
+}
 /* ARGSUSED */
 static void
 dmu_tx_count_write(dmu_tx_hold_t *txh, uint64_t off, uint64_t len)
+{
 	dnode_t *dn = txh->txh_dnode;
 	uint64_t start, end, i;
 	int min_bs, max_bs, min_ibs, max_ibs, epbs, bits;
 	int err = 0;
 	if (len == 0)
 		return;
 	min_bs = SPA_MINBLOCKSHIFT;
 	max_bs = highbit64(txh->txh_tx->tx_objset->os_recordsize) - 1;
 	min_ibs = DN_MIN_INDBLKSHIFT;
 	max_ibs = DN_MAX_INDBLKSHIFT;
 	if (dn) {
 		uint64_t history[DN_MAX_LEVELS];
 		int nlvls = dn->dn_nlevels;
 		int delta;
 		/*
 		 * For i/o error checking, read the first and last level-0
 		 * blocks (if they are not aligned), and all the level-1 blocks.
 		 */
 		if (dn->dn_maxblkid == 0) {
 			delta = dn->dn_datablksz;
 			start = (off < dn->dn_datablksz) ? 0 : 1;
 			end = (off+len <= dn->dn_datablksz) ? 0 : 1;
 			if (start == 0 && (off > 0 || len < dn->dn_datablksz)) {
 				err = dmu_tx_check_ioerr(NULL, dn, 0, 0);
 				if (err)
 					goto out;
 				delta -= off;
+			}
 		} else {
 			zio_t *zio = zio_root(dn->dn_objset->os_spa,
 			    NULL, NULL, ZIO_FLAG_CANFAIL);
 			/* first level-0 block */
 			start = off >> dn->dn_datablkshift;
 			if (P2PHASE(off, dn->dn_datablksz) ||
 			    len < dn->dn_datablksz) {
 				err = dmu_tx_check_ioerr(zio, dn, 0, start);
 				if (err)
 					goto out;
+			}
 			/* last level-0 block */
 			end = (off+len-1) >> dn->dn_datablkshift;
 			if (end != start && end <= dn->dn_maxblkid &&
 			    P2PHASE(off+len, dn->dn_datablksz)) {
 				err = dmu_tx_check_ioerr(zio, dn, 0, end);
 				if (err)
 					goto out;
+			}
 			/* level-1 blocks */
 			if (nlvls > 1) {
 				int shft = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
 				for (i = (start>>shft)+1; i < end>>shft; i++) {
 					err = dmu_tx_check_ioerr(zio, dn, 1, i);
 					if (err)
 						goto out;
+				}
+			}
 			err = zio_wait(zio);
 			if (err)
 				goto out;
 			delta = P2NPHASE(off, dn->dn_datablksz);
+		}
 		min_ibs = max_ibs = dn->dn_indblkshift;
 		if (dn->dn_maxblkid > 0) {
 			/*
 			 * The blocksize can't change,
 			 * so we can make a more precise estimate.
 			 */
 			ASSERT(dn->dn_datablkshift != 0);
 			min_bs = max_bs = dn->dn_datablkshift;
 		} else {
 			/*
 			 * The blocksize can increase up to the recordsize,
 			 * or if it is already more than the recordsize,
 			 * up to the next power of 2.
 			 */
 			min_bs = highbit64(dn->dn_datablksz - 1);
 			max_bs = MAX(max_bs, highbit64(dn->dn_datablksz - 1));
+		}
 		/*
 		 * If this write is not off the end of the file
 		 * we need to account for overwrites/unref.
 		 */
 		if (start <= dn->dn_maxblkid) {
 			for (int l = 0; l < DN_MAX_LEVELS; l++)
 				history[l] = -1ULL;
+		}
 		while (start <= dn->dn_maxblkid) {
 			dmu_buf_impl_t *db;
 			rw_enter(&dn->dn_struct_rwlock, RW_READER);
 			err = dbuf_hold_impl(dn, 0, start,
 			    FALSE, FALSE, FTAG, &db);
 			rw_exit(&dn->dn_struct_rwlock);
 			if (err) {
 				txh->txh_tx->tx_err = err;
 				return;
+			}
 			dmu_tx_count_twig(txh, dn, db, 0, start, B_FALSE,
 			    history);
 			dbuf_rele(db, FTAG);
 			if (++start > end) {
 				/*
 				 * Account for new indirects appearing
 				 * before this IO gets assigned into a txg.
 				 */
 				bits = 64 - min_bs;
 				epbs = min_ibs - SPA_BLKPTRSHIFT;
 				for (bits -= epbs * (nlvls - 1);
 				    bits >= 0; bits -= epbs) {
 					(void) refcount_add_many(
 					    &txh->txh_fudge,
 ULL << max_ibs, FTAG);
+				}
 				goto out;
+			}
 			off += delta;
 			if (len >= delta)
 				len -= delta;
 			delta = dn->dn_datablksz;
+		}
+	}
 	/*
 	 * 'end' is the last thing we will access, not one past.
 	 * This way we won't overflow when accessing the last byte.
 	 */
 	start = P2ALIGN(off, 1ULL << max_bs);
 	end = P2ROUNDUP(off + len, 1ULL << max_bs) - 1;
 	(void) refcount_add_many(&txh->txh_space_towrite,
 	    end - start + 1, FTAG);
 	start >>= min_bs;
 	end >>= min_bs;
 	epbs = min_ibs - SPA_BLKPTRSHIFT;
 	/*
 	 * The object contains at most 2^(64 - min_bs) blocks,
 	 * and each indirect level maps 2^epbs.
 	 */
 	for (bits = 64 - min_bs; bits >= 0; bits -= epbs) {
 		start >>= epbs;
 		end >>= epbs;
 		ASSERT3U(end, >=, start);
 		(void) refcount_add_many(&txh->txh_space_towrite,
 		    (end - start + 1) << max_ibs, FTAG);
 		if (start != 0) {
 			/*
 			 * We also need a new blkid=0 indirect block
 			 * to reference any existing file data.
 			 */
 			(void) refcount_add_many(&txh->txh_space_towrite,
 ULL << max_ibs, FTAG);
+		}
+	}
 out:
 	if (refcount_count(&txh->txh_space_towrite) +
 	    refcount_count(&txh->txh_space_tooverwrite) >
 * DMU_MAX_ACCESS)
 		err = SET_ERROR(EFBIG);
 	if (err)
 		txh->txh_tx->tx_err = err;
+}
 static void
 dmu_tx_count_dnode(dmu_tx_hold_t *txh)
+{
 	dnode_t *dn = txh->txh_dnode;
 	dnode_t *mdn = DMU_META_DNODE(txh->txh_tx->tx_objset);
 	uint64_t space = mdn->dn_datablksz +
-	    ((mdn->dn_nlevels-1) << mdn->dn_indblkshift);
+	    ((uint64_t)(mdn->dn_nlevels-1) << mdn->dn_indblkshift);
 	if (dn && dn->dn_dbuf->db_blkptr &&
 	    dsl_dataset_block_freeable(dn->dn_objset->os_dsl_dataset,
 	    dn->dn_dbuf->db_blkptr, dn->dn_dbuf->db_blkptr->blk_birth)) {
 		(void) refcount_add_many(&txh->txh_space_tooverwrite,
 		    space, FTAG);
 		(void) refcount_add_many(&txh->txh_space_tounref, space, FTAG);
 	} else {
 		(void) refcount_add_many(&txh->txh_space_towrite, space, FTAG);
 		if (dn && dn->dn_dbuf->db_blkptr) {
 			(void) refcount_add_many(&txh->txh_space_tounref,
 			    space, FTAG);
+		}
+	}
+}
 void
 dmu_tx_hold_write(dmu_tx_t *tx, uint64_t object, uint64_t off, int len)
+{
 	dmu_tx_hold_t *txh;
 	ASSERT(tx->tx_txg == 0);
 	ASSERT(len < DMU_MAX_ACCESS);
 	ASSERT(len == 0 || UINT64_MAX - off >= len - 1);
 	txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
 	    object, THT_WRITE, off, len);
 	if (txh == NULL)
 		return;
 	dmu_tx_count_write(txh, off, len);
 	dmu_tx_count_dnode(txh);
+}
 static void
 dmu_tx_count_free(dmu_tx_hold_t *txh, uint64_t off, uint64_t len)
+{
 	uint64_t blkid, nblks, lastblk;
 	uint64_t space = 0, unref = 0, skipped = 0;
 	dnode_t *dn = txh->txh_dnode;
 	dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;
 	spa_t *spa = txh->txh_tx->tx_pool->dp_spa;
 	int epbs;
 	uint64_t l0span = 0, nl1blks = 0;
 	if (dn->dn_nlevels == 0)
 		return;
 	/*
 	 * The struct_rwlock protects us against dn_nlevels
 	 * changing, in case (against all odds) we manage to dirty &
 	 * sync out the changes after we check for being dirty.
 	 * Also, dbuf_hold_impl() wants us to have the struct_rwlock.
 	 */
 	rw_enter(&dn->dn_struct_rwlock, RW_READER);
 	epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
 	if (dn->dn_maxblkid == 0) {
 		if (off == 0 && len >= dn->dn_datablksz) {
 			blkid = 0;
 			nblks = 1;
 		} else {
 			rw_exit(&dn->dn_struct_rwlock);
 			return;
+		}
 	} else {
 		blkid = off >> dn->dn_datablkshift;
 		nblks = (len + dn->dn_datablksz - 1) >> dn->dn_datablkshift;
 		if (blkid > dn->dn_maxblkid) {
 			rw_exit(&dn->dn_struct_rwlock);
 			return;
+		}
 		if (blkid + nblks > dn->dn_maxblkid)
 			nblks = dn->dn_maxblkid - blkid + 1;
+	}
 	l0span = nblks;    /* save for later use to calc level > 1 overhead */
 	if (dn->dn_nlevels == 1) {
 		int i;
 		for (i = 0; i < nblks; i++) {
 			blkptr_t *bp = dn->dn_phys->dn_blkptr;
 			ASSERT3U(blkid + i, <, dn->dn_nblkptr);
 			bp += blkid + i;
 			if (dsl_dataset_block_freeable(ds, bp, bp->blk_birth)) {
 				dprintf_bp(bp, "can free old%s", "");
 				space += bp_get_dsize(spa, bp);
+			}
 			unref += BP_GET_ASIZE(bp);
+		}
 		nl1blks = 1;
 		nblks = 0;
+	}
 	lastblk = blkid + nblks - 1;
 	while (nblks) {
 		dmu_buf_impl_t *dbuf;
 		uint64_t ibyte, new_blkid;
 		int epb = 1 << epbs;
 		int err, i, blkoff, tochk;
 		blkptr_t *bp;
 		ibyte = blkid << dn->dn_datablkshift;
 		err = dnode_next_offset(dn,
 		    DNODE_FIND_HAVELOCK, &ibyte, 2, 1, 0);
 		new_blkid = ibyte >> dn->dn_datablkshift;
 		if (err == ESRCH) {
 			skipped += (lastblk >> epbs) - (blkid >> epbs) + 1;
 			break;
+		}
 		if (err) {
 			txh->txh_tx->tx_err = err;
 			break;
+		}
 		if (new_blkid > lastblk) {
 			skipped += (lastblk >> epbs) - (blkid >> epbs) + 1;
 			break;
+		}
 		if (new_blkid > blkid) {
 			ASSERT((new_blkid >> epbs) > (blkid >> epbs));
 			skipped += (new_blkid >> epbs) - (blkid >> epbs) - 1;
 			nblks -= new_blkid - blkid;
 			blkid = new_blkid;
+		}
 		blkoff = P2PHASE(blkid, epb);
 		tochk = MIN(epb - blkoff, nblks);
 		err = dbuf_hold_impl(dn, 1, blkid >> epbs,
 		    FALSE, FALSE, FTAG, &dbuf);
 		if (err) {
 			txh->txh_tx->tx_err = err;
 			break;
+		}
 		(void) refcount_add_many(&txh->txh_memory_tohold,
 		    dbuf->db.db_size, FTAG);
 		/*
 		 * We don't check memory_tohold against DMU_MAX_ACCESS because
 		 * memory_tohold is an over-estimation (especially the >L1
 		 * indirect blocks), so it could fail.  Callers should have
 		 * already verified that they will not be holding too much
 		 * memory.
 		 */
 		err = dbuf_read(dbuf, NULL, DB_RF_HAVESTRUCT | DB_RF_CANFAIL);
 		if (err != 0) {
 			txh->txh_tx->tx_err = err;
 			dbuf_rele(dbuf, FTAG);
 			break;
+		}
 		bp = dbuf->db.db_data;
 		bp += blkoff;
 		for (i = 0; i < tochk; i++) {
 			if (dsl_dataset_block_freeable(ds, &bp[i],
 			    bp[i].blk_birth)) {
 				dprintf_bp(&bp[i], "can free old%s", "");
 				space += bp_get_dsize(spa, &bp[i]);
+			}
 			unref += BP_GET_ASIZE(bp);
+		}
 		dbuf_rele(dbuf, FTAG);
 		++nl1blks;
 		blkid += tochk;
 		nblks -= tochk;
+	}
 	rw_exit(&dn->dn_struct_rwlock);
 	/*
 	 * Add in memory requirements of higher-level indirects.
 	 * This assumes a worst-possible scenario for dn_nlevels and a
 	 * worst-possible distribution of l1-blocks over the region to free.
 	 */
+	{
 		uint64_t blkcnt = 1 + ((l0span >> epbs) >> epbs);
 		int level = 2;
 		/*
 		 * Here we don't use DN_MAX_LEVEL, but calculate it with the
 		 * given datablkshift and indblkshift. This makes the
 		 * difference between 19 and 8 on large files.
 		 */
 		int maxlevel = 2 + (DN_MAX_OFFSET_SHIFT - dn->dn_datablkshift) /
 		    (dn->dn_indblkshift - SPA_BLKPTRSHIFT);
 		while (level++ < maxlevel) {
 			(void) refcount_add_many(&txh->txh_memory_tohold,
 			    MAX(MIN(blkcnt, nl1blks), 1) << dn->dn_indblkshift,
 			    FTAG);
 			blkcnt = 1 + (blkcnt >> epbs);
+		}
+	}
 	/* account for new level 1 indirect blocks that might show up */
 	if (skipped > 0) {
 		(void) refcount_add_many(&txh->txh_fudge,
 		    skipped << dn->dn_indblkshift, FTAG);
 		skipped = MIN(skipped, DMU_MAX_DELETEBLKCNT >> epbs);
 		(void) refcount_add_many(&txh->txh_memory_tohold,
 		    skipped << dn->dn_indblkshift, FTAG);
+	}
 	(void) refcount_add_many(&txh->txh_space_tofree, space, FTAG);
 	(void) refcount_add_many(&txh->txh_space_tounref, unref, FTAG);
+}
 /*
  * This function marks the transaction as being a "net free".  The end
  * result is that refquotas will be disabled for this transaction, and
  * this transaction will be able to use half of the pool space overhead
  * (see dsl_pool_adjustedsize()).  Therefore this function should only
  * be called for transactions that we expect will not cause a net increase
  * in the amount of space used (but it's OK if that is occasionally not true).
  */
 void
 dmu_tx_mark_netfree(dmu_tx_t *tx)
+{
 	dmu_tx_hold_t *txh;
 	txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
 	    DMU_NEW_OBJECT, THT_FREE, 0, 0);
 	/*
 	 * Pretend that this operation will free 1GB of space.  This
 	 * should be large enough to cancel out the largest write.
 	 * We don't want to use something like UINT64_MAX, because that would
 	 * cause overflows when doing math with these values (e.g. in
 	 * dmu_tx_try_assign()).
 	 */
 	(void) refcount_add_many(&txh->txh_space_tofree,
 * 1024 * 1024, FTAG);
 	(void) refcount_add_many(&txh->txh_space_tounref,
 * 1024 * 1024, FTAG);
+}
 void
 dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off, uint64_t len)
+{
 	dmu_tx_hold_t *txh;
 	dnode_t *dn;
 	int err;
 	zio_t *zio;
 	ASSERT(tx->tx_txg == 0);
 	txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
 	    object, THT_FREE, off, len);
 	if (txh == NULL)
 		return;
 	dn = txh->txh_dnode;
 	dmu_tx_count_dnode(txh);
 	if (off >= (dn->dn_maxblkid+1) * dn->dn_datablksz)
 		return;
 	if (len == DMU_OBJECT_END)
 		len = (dn->dn_maxblkid+1) * dn->dn_datablksz - off;
 	/*
 	 * For i/o error checking, we read the first and last level-0
 	 * blocks if they are not aligned, and all the level-1 blocks.
+	 *
 	 * Note:  dbuf_free_range() assumes that we have not instantiated
 	 * any level-0 dbufs that will be completely freed.  Therefore we must
 	 * exercise care to not read or count the first and last blocks
 	 * if they are blocksize-aligned.
 	 */
 	if (dn->dn_datablkshift == 0) {
 		if (off != 0 || len < dn->dn_datablksz)
 			dmu_tx_count_write(txh, 0, dn->dn_datablksz);
 	} else {
 		/* first block will be modified if it is not aligned */
 		if (!IS_P2ALIGNED(off, 1 << dn->dn_datablkshift))
 			dmu_tx_count_write(txh, off, 1);
 		/* last block will be modified if it is not aligned */
 		if (!IS_P2ALIGNED(off + len, 1 << dn->dn_datablkshift))
 			dmu_tx_count_write(txh, off+len, 1);
+	}
 	/*
 	 * Check level-1 blocks.
 	 */
 	if (dn->dn_nlevels > 1) {
 		int shift = dn->dn_datablkshift + dn->dn_indblkshift -
 		    SPA_BLKPTRSHIFT;
 		uint64_t start = off >> shift;
 		uint64_t end = (off + len) >> shift;
 		ASSERT(dn->dn_indblkshift != 0);
 		/*
 		 * dnode_reallocate() can result in an object with indirect
 		 * blocks having an odd data block size.  In this case,
 		 * just check the single block.
 		 */
 		if (dn->dn_datablkshift == 0)
 			start = end = 0;
 		zio = zio_root(tx->tx_pool->dp_spa,
 		    NULL, NULL, ZIO_FLAG_CANFAIL);
 		for (uint64_t i = start; i <= end; i++) {
 			uint64_t ibyte = i << shift;
 			err = dnode_next_offset(dn, 0, &ibyte, 2, 1, 0);
 			i = ibyte >> shift;
 			if (err == ESRCH || i > end)
 				break;
 			if (err) {
 				tx->tx_err = err;
 				return;
+			}
 			err = dmu_tx_check_ioerr(zio, dn, 1, i);
 			if (err) {
 				tx->tx_err = err;
 				return;
+			}
+		}
 		err = zio_wait(zio);
 		if (err) {
 			tx->tx_err = err;
 			return;
+		}
+	}
 	dmu_tx_count_free(txh, off, len);
+}
 void
 dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name)
+{
 	dmu_tx_hold_t *txh;
 	dnode_t *dn;
 	int err;
 	ASSERT(tx->tx_txg == 0);
 	txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
 	    object, THT_ZAP, add, (uintptr_t)name);
 	if (txh == NULL)
 		return;
 	dn = txh->txh_dnode;
 	dmu_tx_count_dnode(txh);
 	if (dn == NULL) {
 		/*
 		 * We will be able to fit a new object's entries into one leaf
 		 * block.  So there will be at most 2 blocks total,
 		 * including the header block.
 		 */
 		dmu_tx_count_write(txh, 0, 2 << fzap_default_block_shift);
 		return;
+	}
 	ASSERT3P(DMU_OT_BYTESWAP(dn->dn_type), ==, DMU_BSWAP_ZAP);
 	if (dn->dn_maxblkid == 0 && !add) {
 		blkptr_t *bp;
 		/*
 		 * If there is only one block  (i.e. this is a micro-zap)
 		 * and we are not adding anything, the accounting is simple.
 		 */
 		err = dmu_tx_check_ioerr(NULL, dn, 0, 0);
 		if (err) {
 			tx->tx_err = err;
 			return;
+		}
 		/*
 		 * Use max block size here, since we don't know how much
 		 * the size will change between now and the dbuf dirty call.
 		 */
 		bp = &dn->dn_phys->dn_blkptr[0];
 		if (dsl_dataset_block_freeable(dn->dn_objset->os_dsl_dataset,
 		    bp, bp->blk_birth)) {
 			(void) refcount_add_many(&txh->txh_space_tooverwrite,
 			    MZAP_MAX_BLKSZ, FTAG);
 		} else {
 			(void) refcount_add_many(&txh->txh_space_towrite,
 			    MZAP_MAX_BLKSZ, FTAG);
+		}
 		if (!BP_IS_HOLE(bp)) {
 			(void) refcount_add_many(&txh->txh_space_tounref,
 			    MZAP_MAX_BLKSZ, FTAG);
+		}
 		return;
+	}
 	if (dn->dn_maxblkid > 0 && name) {
 		/*
 		 * access the name in this fat-zap so that we'll check
 		 * for i/o errors to the leaf blocks, etc.
 		 */
 		err = zap_lookup_by_dnode(dn, name, 8, 0, NULL);
 		if (err == EIO) {
 			tx->tx_err = err;
 			return;
+		}
+	}
 	err = zap_count_write_by_dnode(dn, name, add,
 	    &txh->txh_space_towrite, &txh->txh_space_tooverwrite);
 	/*
 	 * If the modified blocks are scattered to the four winds,
 	 * we'll have to modify an indirect twig for each.  We can make
 	 * modifications at up to 3 locations:
 	 *  - header block at the beginning of the object
 	 *  - target leaf block
 	 *  - end of the object, where we might need to write:
 	 *	- a new leaf block if the target block needs to be split
 	 *	- the new pointer table, if it is growing
 	 *	- the new cookie table, if it is growing
 	 */
 	int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
 	dsl_dataset_phys_t *ds_phys =
 	    dsl_dataset_phys(dn->dn_objset->os_dsl_dataset);
 	for (int lvl = 1; lvl < dn->dn_nlevels; lvl++) {
 		uint64_t num_indirects = 1 + (dn->dn_maxblkid >> (epbs * lvl));
 		uint64_t spc = MIN(3, num_indirects) << dn->dn_indblkshift;
 		if (ds_phys->ds_prev_snap_obj != 0) {
 			(void) refcount_add_many(&txh->txh_space_towrite,
 			    spc, FTAG);
 		} else {
 			(void) refcount_add_many(&txh->txh_space_tooverwrite,
 			    spc, FTAG);
+		}
+	}
+}
 void
 dmu_tx_hold_bonus(dmu_tx_t *tx, uint64_t object)
+{
 	dmu_tx_hold_t *txh;
 	ASSERT(tx->tx_txg == 0);
 	txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
 	    object, THT_BONUS, 0, 0);
 	if (txh)
 		dmu_tx_count_dnode(txh);
+}
 void
 dmu_tx_hold_space(dmu_tx_t *tx, uint64_t space)
+{
 	dmu_tx_hold_t *txh;
 	ASSERT(tx->tx_txg == 0);
 	txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
 	    DMU_NEW_OBJECT, THT_SPACE, space, 0);
 	(void) refcount_add_many(&txh->txh_space_towrite, space, FTAG);
+}
 int
 dmu_tx_holds(dmu_tx_t *tx, uint64_t object)
+{
 	dmu_tx_hold_t *txh;
 	int holds = 0;
 	/*
 	 * By asserting that the tx is assigned, we're counting the
 	 * number of dn_tx_holds, which is the same as the number of
 	 * dn_holds.  Otherwise, we'd be counting dn_holds, but
 	 * dn_tx_holds could be 0.
 	 */
 	ASSERT(tx->tx_txg != 0);
 	/* if (tx->tx_anyobj == TRUE) */
 		/* return (0); */
 	for (txh = list_head(&tx->tx_holds); txh;
 	    txh = list_next(&tx->tx_holds, txh)) {
 		if (txh->txh_dnode && txh->txh_dnode->dn_object == object)
 			holds++;
+	}
 	return (holds);
+}
 #ifdef ZFS_DEBUG
 void
 dmu_tx_dirty_buf(dmu_tx_t *tx, dmu_buf_impl_t *db)
+{
 	dmu_tx_hold_t *txh;
 	int match_object = FALSE, match_offset = FALSE;
 	dnode_t *dn;
 	DB_DNODE_ENTER(db);
 	dn = DB_DNODE(db);
 	ASSERT(tx->tx_txg != 0);
 	ASSERT(tx->tx_objset == NULL || dn->dn_objset == tx->tx_objset);
 	ASSERT3U(dn->dn_object, ==, db->db.db_object);
 	if (tx->tx_anyobj) {
 		DB_DNODE_EXIT(db);
 		return;
+	}
 	/* XXX No checking on the meta dnode for now */
 	if (db->db.db_object == DMU_META_DNODE_OBJECT) {
 		DB_DNODE_EXIT(db);
 		return;
+	}
 	for (txh = list_head(&tx->tx_holds); txh;
 	    txh = list_next(&tx->tx_holds, txh)) {
 		ASSERT(dn == NULL || dn->dn_assigned_txg == tx->tx_txg);
 		if (txh->txh_dnode == dn && txh->txh_type != THT_NEWOBJECT)
 			match_object = TRUE;
 		if (txh->txh_dnode == NULL || txh->txh_dnode == dn) {
 			int datablkshift = dn->dn_datablkshift ?
 			    dn->dn_datablkshift : SPA_MAXBLOCKSHIFT;
 			int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
 			int shift = datablkshift + epbs * db->db_level;
 			uint64_t beginblk = shift >= 64 ? 0 :
 			    (txh->txh_arg1 >> shift);
 			uint64_t endblk = shift >= 64 ? 0 :
 			    ((txh->txh_arg1 + txh->txh_arg2 - 1) >> shift);
 			uint64_t blkid = db->db_blkid;
 			/* XXX txh_arg2 better not be zero... */
 			dprintf("found txh type %x beginblk=%llx endblk=%llx\n",
 			    txh->txh_type, beginblk, endblk);
 			switch (txh->txh_type) {
 			case THT_WRITE:
 				if (blkid >= beginblk && blkid <= endblk)
 					match_offset = TRUE;
 				/*
 				 * We will let this hold work for the bonus
 				 * or spill buffer so that we don't need to
 				 * hold it when creating a new object.
 				 */
 				if (blkid == DMU_BONUS_BLKID ||
 				    blkid == DMU_SPILL_BLKID)
 					match_offset = TRUE;
 				/*
 				 * They might have to increase nlevels,
 				 * thus dirtying the new TLIBs.  Or the
 				 * might have to change the block size,
 				 * thus dirying the new lvl=0 blk=0.
 				 */
 				if (blkid == 0)
 					match_offset = TRUE;
 				break;
 			case THT_FREE:
 				/*
 				 * We will dirty all the level 1 blocks in
 				 * the free range and perhaps the first and
 				 * last level 0 block.
 				 */
 				if (blkid >= beginblk && (blkid <= endblk ||
 				    txh->txh_arg2 == DMU_OBJECT_END))
 					match_offset = TRUE;
 				break;
 			case THT_SPILL:
 				if (blkid == DMU_SPILL_BLKID)
 					match_offset = TRUE;
 				break;
 			case THT_BONUS:
 				if (blkid == DMU_BONUS_BLKID)
 					match_offset = TRUE;
 				break;
 			case THT_ZAP:
 				match_offset = TRUE;
 				break;
 			case THT_NEWOBJECT:
 				match_object = TRUE;
 				break;
 			default:
 				ASSERT(!"bad txh_type");
+			}
+		}
 		if (match_object && match_offset) {
 			DB_DNODE_EXIT(db);
 			return;
+		}
+	}
 	DB_DNODE_EXIT(db);
 	panic("dirtying dbuf obj=%llx lvl=%u blkid=%llx but not tx_held\n",
 	    (u_longlong_t)db->db.db_object, db->db_level,
 	    (u_longlong_t)db->db_blkid);
+}
 #endif
 /*
  * If we can't do 10 iops, something is wrong.  Let us go ahead
  * and hit zfs_dirty_data_max.
  */
 hrtime_t zfs_delay_max_ns = MSEC2NSEC(100);
 int zfs_delay_resolution_ns = 100 * 1000; /* 100 microseconds */
 /*
  * We delay transactions when we've determined that the backend storage
  * isn't able to accommodate the rate of incoming writes.
+ *
  * If there is already a transaction waiting, we delay relative to when
  * that transaction finishes waiting.  This way the calculated min_time
  * is independent of the number of threads concurrently executing
  * transactions.
+ *
  * If we are the only waiter, wait relative to when the transaction
  * started, rather than the current time.  This credits the transaction for
  * "time already served", e.g. reading indirect blocks.
+ *
  * The minimum time for a transaction to take is calculated as:
  *     min_time = scale * (dirty - min) / (max - dirty)
  *     min_time is then capped at zfs_delay_max_ns.
+ *
  * The delay has two degrees of freedom that can be adjusted via tunables.
  * The percentage of dirty data at which we start to delay is defined by
  * zfs_delay_min_dirty_percent. This should typically be at or above
  * zfs_vdev_async_write_active_max_dirty_percent so that we only start to
  * delay after writing at full speed has failed to keep up with the incoming
  * write rate. The scale of the curve is defined by zfs_delay_scale. Roughly
  * speaking, this variable determines the amount of delay at the midpoint of
  * the curve.
+ *
  * delay
  *  10ms +-------------------------------------------------------------*+
  *       |                                                             *|
  *   9ms +                                                             *+
  *       |                                                             *|
  *   8ms +                                                             *+
  *       |                                                            * |
  *   7ms +                                                            * +
  *       |                                                            * |
  *   6ms +                                                            * +
  *       |                                                            * |
  *   5ms +                                                           *  +
  *       |                                                           *  |
  *   4ms +                                                           *  +
  *       |                                                           *  |
  *   3ms +                                                          *   +
  *       |                                                          *   |
  *   2ms +                                              (midpoint) *    +
  *       |                                                  |    **     |
  *   1ms +                                                  v ***       +
  *       |             zfs_delay_scale ---------->     ********         |
  *     0 +-------------------------------------*********----------------+
  *       0%                    <- zfs_dirty_data_max ->               100%
+ *
  * Note that since the delay is added to the outstanding time remaining on the
  * most recent transaction, the delay is effectively the inverse of IOPS.
  * Here the midpoint of 500us translates to 2000 IOPS. The shape of the curve
  * was chosen such that small changes in the amount of accumulated dirty data
  * in the first 3/4 of the curve yield relatively small differences in the
  * amount of delay.
+ *
  * The effects can be easier to understand when the amount of delay is
  * represented on a log scale:
+ *
  * delay
  * 100ms +-------------------------------------------------------------++
  *       +                                                              +
  *       |                                                              |
  *       +                                                             *+
  *  10ms +                                                             *+
  *       +                                                           ** +
  *       |                                              (midpoint)  **  |
  *       +                                                  |     **    +
  *   1ms +                                                  v ****      +
  *       +             zfs_delay_scale ---------->        *****         +
  *       |                                             ****             |
  *       +                                          ****                +
  * 100us +                                        **                    +
  *       +                                       *                      +
  *       |                                      *                       |
  *       +                                     *                        +
  *  10us +                                     *                        +
  *       +                                                              +
  *       |                                                              |
  *       +                                                              +
  *       +--------------------------------------------------------------+
  *       0%                    <- zfs_dirty_data_max ->               100%
+ *
  * Note here that only as the amount of dirty data approaches its limit does
  * the delay start to increase rapidly. The goal of a properly tuned system
  * should be to keep the amount of dirty data out of that range by first
  * ensuring that the appropriate limits are set for the I/O scheduler to reach
  * optimal throughput on the backend storage, and then by changing the value
  * of zfs_delay_scale to increase the steepness of the curve.
  */
 static void
 dmu_tx_delay(dmu_tx_t *tx, uint64_t dirty)
+{
 	dsl_pool_t *dp = tx->tx_pool;
 	uint64_t delay_min_bytes =
 	    zfs_dirty_data_max * zfs_delay_min_dirty_percent / 100;
 	hrtime_t wakeup, min_tx_time, now;
 	if (dirty <= delay_min_bytes)
 		return;
 	/*
 	 * The caller has already waited until we are under the max.
 	 * We make them pass us the amount of dirty data so we don't
 	 * have to handle the case of it being >= the max, which could
 	 * cause a divide-by-zero if it's == the max.
 	 */
 	ASSERT3U(dirty, <, zfs_dirty_data_max);
 	now = gethrtime();
 	min_tx_time = zfs_delay_scale *
 	    (dirty - delay_min_bytes) / (zfs_dirty_data_max - dirty);
 	if (now > tx->tx_start + min_tx_time)
 		return;
 	min_tx_time = MIN(min_tx_time, zfs_delay_max_ns);
 	DTRACE_PROBE3(delay__mintime, dmu_tx_t *, tx, uint64_t, dirty,
 	    uint64_t, min_tx_time);
 	mutex_enter(&dp->dp_lock);
 	wakeup = MAX(tx->tx_start + min_tx_time,
 	    dp->dp_last_wakeup + min_tx_time);
 	dp->dp_last_wakeup = wakeup;
 	mutex_exit(&dp->dp_lock);
 #ifdef _KERNEL
 #ifdef illumos
 	mutex_enter(&curthread->t_delay_lock);
 	while (cv_timedwait_hires(&curthread->t_delay_cv,
 	    &curthread->t_delay_lock, wakeup, zfs_delay_resolution_ns,
 	    CALLOUT_FLAG_ABSOLUTE | CALLOUT_FLAG_ROUNDUP) > 0)
 		continue;
 	mutex_exit(&curthread->t_delay_lock);
 #endif
 #ifdef __FreeBSD__
 	pause_sbt("dmu_tx_delay", wakeup * SBT_1NS,
 	    zfs_delay_resolution_ns * SBT_1NS, C_ABSOLUTE);
 #endif
 #ifdef __NetBSD__
 	int timo = (wakeup - now) * hz / 1000000000;
 	if (timo == 0)
 		timo = 1;
 	kpause("dmu_tx_delay", false, timo, NULL);
 #endif
 #else
 	hrtime_t delta = wakeup - gethrtime();
 	struct timespec ts;
 	ts.tv_sec = delta / NANOSEC;
 	ts.tv_nsec = delta % NANOSEC;
 	(void) nanosleep(&ts, NULL);
 #endif
+}
 static int
 dmu_tx_try_assign(dmu_tx_t *tx, txg_how_t txg_how)
+{
 	dmu_tx_hold_t *txh;
 	spa_t *spa = tx->tx_pool->dp_spa;
 	uint64_t memory, asize, fsize, usize;
 	uint64_t towrite, tofree, tooverwrite, tounref, tohold, fudge;
 	ASSERT0(tx->tx_txg);
 	if (tx->tx_err)
 		return (tx->tx_err);
 	if (spa_suspended(spa)) {
 		/*
 		 * If the user has indicated a blocking failure mode
 		 * then return ERESTART which will block in dmu_tx_wait().
 		 * Otherwise, return EIO so that an error can get
 		 * propagated back to the VOP calls.
+		 *
 		 * Note that we always honor the txg_how flag regardless
 		 * of the failuremode setting.
 		 */
 		if (spa_get_failmode(spa) == ZIO_FAILURE_MODE_CONTINUE &&
 		    txg_how != TXG_WAIT)
 			return (SET_ERROR(EIO));
 		return (SET_ERROR(ERESTART));
+	}
 	if (!tx->tx_waited &&
 	    dsl_pool_need_dirty_delay(tx->tx_pool)) {
 		tx->tx_wait_dirty = B_TRUE;
 		return (SET_ERROR(ERESTART));
+	}
 	tx->tx_txg = txg_hold_open(tx->tx_pool, &tx->tx_txgh);
 	tx->tx_needassign_txh = NULL;
 	/*
 	 * NB: No error returns are allowed after txg_hold_open, but
 	 * before processing the dnode holds, due to the
 	 * dmu_tx_unassign() logic.
 	 */
 	towrite = tofree = tooverwrite = tounref = tohold = fudge = 0;
 	for (txh = list_head(&tx->tx_holds); txh;
 	    txh = list_next(&tx->tx_holds, txh)) {
 		dnode_t *dn = txh->txh_dnode;
 		if (dn != NULL) {
 			mutex_enter(&dn->dn_mtx);
 			if (dn->dn_assigned_txg == tx->tx_txg - 1) {
 				mutex_exit(&dn->dn_mtx);
 				tx->tx_needassign_txh = txh;
 				return (SET_ERROR(ERESTART));
+			}
 			if (dn->dn_assigned_txg == 0)
 				dn->dn_assigned_txg = tx->tx_txg;
 			ASSERT3U(dn->dn_assigned_txg, ==, tx->tx_txg);
 			(void) refcount_add(&dn->dn_tx_holds, tx);
 			mutex_exit(&dn->dn_mtx);
+		}
 		towrite += refcount_count(&txh->txh_space_towrite);
 		tofree += refcount_count(&txh->txh_space_tofree);
 		tooverwrite += refcount_count(&txh->txh_space_tooverwrite);
 		tounref += refcount_count(&txh->txh_space_tounref);
 		tohold += refcount_count(&txh->txh_memory_tohold);
 		fudge += refcount_count(&txh->txh_fudge);
+	}
 	/*
 	 * If a snapshot has been taken since we made our estimates,
 	 * assume that we won't be able to free or overwrite anything.
 	 */
 	if (tx->tx_objset &&
 	    dsl_dataset_prev_snap_txg(tx->tx_objset->os_dsl_dataset) >
 	    tx->tx_lastsnap_txg) {
 		towrite += tooverwrite;
 		tooverwrite = tofree = 0;
+	}
 	/* needed allocation: worst-case estimate of write space */
 	asize = spa_get_asize(tx->tx_pool->dp_spa, towrite + tooverwrite);
 	/* freed space estimate: worst-case overwrite + free estimate */
 	fsize = spa_get_asize(tx->tx_pool->dp_spa, tooverwrite) + tofree;
 	/* convert unrefd space to worst-case estimate */
 	usize = spa_get_asize(tx->tx_pool->dp_spa, tounref);
 	/* calculate memory footprint estimate */
 	memory = towrite + tooverwrite + tohold;
 #ifdef ZFS_DEBUG
 	/*
 	 * Add in 'tohold' to account for our dirty holds on this memory
 	 * XXX - the "fudge" factor is to account for skipped blocks that
 	 * we missed because dnode_next_offset() misses in-core-only blocks.
 	 */
 	tx->tx_space_towrite = asize +
 	    spa_get_asize(tx->tx_pool->dp_spa, tohold + fudge);
 	tx->tx_space_tofree = tofree;
 	tx->tx_space_tooverwrite = tooverwrite;
 	tx->tx_space_tounref = tounref;
 #endif
 	if (tx->tx_dir && asize != 0) {
 		int err = dsl_dir_tempreserve_space(tx->tx_dir, memory,
 		    asize, fsize, usize, &tx->tx_tempreserve_cookie, tx);
 		if (err)
 			return (err);
+	}
 	return (0);
+}
 static void
 dmu_tx_unassign(dmu_tx_t *tx)
+{
 	dmu_tx_hold_t *txh;
 	if (tx->tx_txg == 0)
 		return;
 	txg_rele_to_quiesce(&tx->tx_txgh);
 	/*
 	 * Walk the transaction's hold list, removing the hold on the
 	 * associated dnode, and notifying waiters if the refcount drops to 0.
 	 */
 	for (txh = list_head(&tx->tx_holds); txh != tx->tx_needassign_txh;
 	    txh = list_next(&tx->tx_holds, txh)) {
 		dnode_t *dn = txh->txh_dnode;
 		if (dn == NULL)
 			continue;
 		mutex_enter(&dn->dn_mtx);
 		ASSERT3U(dn->dn_assigned_txg, ==, tx->tx_txg);
 		if (refcount_remove(&dn->dn_tx_holds, tx) == 0) {
 			dn->dn_assigned_txg = 0;
 			cv_broadcast(&dn->dn_notxholds);
+		}
 		mutex_exit(&dn->dn_mtx);
+	}
 	txg_rele_to_sync(&tx->tx_txgh);
 	tx->tx_lasttried_txg = tx->tx_txg;
 	tx->tx_txg = 0;
+}
 /*
  * Assign tx to a transaction group.  txg_how can be one of:
+ *
  * (1)	TXG_WAIT.  If the current open txg is full, waits until there's
  *	a new one.  This should be used when you're not holding locks.
  *	It will only fail if we're truly out of space (or over quota).
+ *
  * (2)	TXG_NOWAIT.  If we can't assign into the current open txg without
  *	blocking, returns immediately with ERESTART.  This should be used
  *	whenever you're holding locks.  On an ERESTART error, the caller
  *	should drop locks, do a dmu_tx_wait(tx), and try again.
+ *
  * (3)  TXG_WAITED.  Like TXG_NOWAIT, but indicates that dmu_tx_wait()
  *      has already been called on behalf of this operation (though
  *      most likely on a different tx).
  */
 int
 dmu_tx_assign(dmu_tx_t *tx, txg_how_t txg_how)
+{
 	int err;
 	ASSERT(tx->tx_txg == 0);
 	ASSERT(txg_how == TXG_WAIT || txg_how == TXG_NOWAIT ||
 	    txg_how == TXG_WAITED);
 	ASSERT(!dsl_pool_sync_context(tx->tx_pool));
 	/* If we might wait, we must not hold the config lock. */
 	ASSERT(txg_how != TXG_WAIT || !dsl_pool_config_held(tx->tx_pool));
 	if (txg_how == TXG_WAITED)
 		tx->tx_waited = B_TRUE;
 	while ((err = dmu_tx_try_assign(tx, txg_how)) != 0) {
 		dmu_tx_unassign(tx);
 		if (err != ERESTART || txg_how != TXG_WAIT)
 			return (err);
 		dmu_tx_wait(tx);
+	}
 	txg_rele_to_quiesce(&tx->tx_txgh);
 	return (0);
+}
 void
 dmu_tx_wait(dmu_tx_t *tx)
+{
 	spa_t *spa = tx->tx_pool->dp_spa;
 	dsl_pool_t *dp = tx->tx_pool;
 	ASSERT(tx->tx_txg == 0);
 	ASSERT(!dsl_pool_config_held(tx->tx_pool));
 	if (tx->tx_wait_dirty) {
 		/*
 		 * dmu_tx_try_assign() has determined that we need to wait
 		 * because we've consumed much or all of the dirty buffer
 		 * space.
 		 */
 		mutex_enter(&dp->dp_lock);
 		while (dp->dp_dirty_total >= zfs_dirty_data_max)
 			cv_wait(&dp->dp_spaceavail_cv, &dp->dp_lock);
 		uint64_t dirty = dp->dp_dirty_total;
 		mutex_exit(&dp->dp_lock);
 		dmu_tx_delay(tx, dirty);
 		tx->tx_wait_dirty = B_FALSE;
 		/*
 		 * Note: setting tx_waited only has effect if the caller
 		 * used TX_WAIT.  Otherwise they are going to destroy
 		 * this tx and try again.  The common case, zfs_write(),
 		 * uses TX_WAIT.
 		 */
 		tx->tx_waited = B_TRUE;
 	} else if (spa_suspended(spa) || tx->tx_lasttried_txg == 0) {
 		/*
 		 * If the pool is suspended we need to wait until it
 		 * is resumed.  Note that it's possible that the pool
 		 * has become active after this thread has tried to
 		 * obtain a tx.  If that's the case then tx_lasttried_txg
 		 * would not have been set.
 		 */
 		txg_wait_synced(dp, spa_last_synced_txg(spa) + 1);
 	} else if (tx->tx_needassign_txh) {
 		/*
 		 * A dnode is assigned to the quiescing txg.  Wait for its
 		 * transaction to complete.
 		 */
 		dnode_t *dn = tx->tx_needassign_txh->txh_dnode;
 		mutex_enter(&dn->dn_mtx);
 		while (dn->dn_assigned_txg == tx->tx_lasttried_txg - 1)
 			cv_wait(&dn->dn_notxholds, &dn->dn_mtx);

 @@ -5297,1999 +5297,1999 @@ spa_vdev_detach(spa_t *spa, uint64_t gui
 			(void) spa_vdev_remove(altspa, unspare_guid, B_TRUE);
 			mutex_enter(&spa_namespace_lock);
 			spa_close(altspa, FTAG);
+		}
 		mutex_exit(&spa_namespace_lock);
 		/* search the rest of the vdevs for spares to remove */
 		spa_vdev_resilver_done(spa);
+	}
 	/* all done with the spa; OK to release */
 	mutex_enter(&spa_namespace_lock);
 	spa_close(spa, FTAG);
 	mutex_exit(&spa_namespace_lock);
 	return (error);
+}
 /*
  * Split a set of devices from their mirrors, and create a new pool from them.
  */
 int
 spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config,
     nvlist_t *props, boolean_t exp)
+{
 	int error = 0;
 	uint64_t txg, *glist;
 	spa_t *newspa;
 	uint_t c, children, lastlog;
 	nvlist_t **child, *nvl, *tmp;
 	dmu_tx_t *tx;
 	char *altroot = NULL;
 	vdev_t *rvd, **vml = NULL;			/* vdev modify list */
 	boolean_t activate_slog;
 	ASSERT(spa_writeable(spa));
 	txg = spa_vdev_enter(spa);
 	/* clear the log and flush everything up to now */
 	activate_slog = spa_passivate_log(spa);
 	(void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
 	error = spa_offline_log(spa);
 	txg = spa_vdev_config_enter(spa);
 	if (activate_slog)
 		spa_activate_log(spa);
 	if (error != 0)
 		return (spa_vdev_exit(spa, NULL, txg, error));
 	/* check new spa name before going any further */
 	if (spa_lookup(newname) != NULL)
 		return (spa_vdev_exit(spa, NULL, txg, EEXIST));
 	/*
 	 * scan through all the children to ensure they're all mirrors
 	 */
 	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvl) != 0 ||
 	    nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, &child,
 	    &children) != 0)
 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
 	/* first, check to ensure we've got the right child count */
 	rvd = spa->spa_root_vdev;
 	lastlog = 0;
 	for (c = 0; c < rvd->vdev_children; c++) {
 		vdev_t *vd = rvd->vdev_child[c];
 		/* don't count the holes & logs as children */
 		if (vd->vdev_islog || vd->vdev_ishole) {
 			if (lastlog == 0)
 				lastlog = c;
 			continue;
+		}
 		lastlog = 0;
+	}
 	if (children != (lastlog != 0 ? lastlog : rvd->vdev_children))
 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
 	/* next, ensure no spare or cache devices are part of the split */
 	if (nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_SPARES, &tmp) == 0 ||
 	    nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_L2CACHE, &tmp) == 0)
 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
 	vml = kmem_zalloc(children * sizeof (vdev_t *), KM_SLEEP);
 	glist = kmem_zalloc(children * sizeof (uint64_t), KM_SLEEP);
 	/* then, loop over each vdev and validate it */
 	for (c = 0; c < children; c++) {
 		uint64_t is_hole = 0;
 		(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
 		    &is_hole);
 		if (is_hole != 0) {
 			if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole ||
 			    spa->spa_root_vdev->vdev_child[c]->vdev_islog) {
 				continue;
 			} else {
 				error = SET_ERROR(EINVAL);
 				break;
+			}
+		}
 		/* which disk is going to be split? */
 		if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_GUID,
 		    &glist[c]) != 0) {
 			error = SET_ERROR(EINVAL);
 			break;
+		}
 		/* look it up in the spa */
 		vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE);
 		if (vml[c] == NULL) {
 			error = SET_ERROR(ENODEV);
 			break;
+		}
 		/* make sure there's nothing stopping the split */
 		if (vml[c]->vdev_parent->vdev_ops != &vdev_mirror_ops ||
 		    vml[c]->vdev_islog ||
 		    vml[c]->vdev_ishole ||
 		    vml[c]->vdev_isspare ||
 		    vml[c]->vdev_isl2cache ||
 		    !vdev_writeable(vml[c]) ||
 		    vml[c]->vdev_children != 0 ||
 		    vml[c]->vdev_state != VDEV_STATE_HEALTHY ||
 		    c != spa->spa_root_vdev->vdev_child[c]->vdev_id) {
 			error = SET_ERROR(EINVAL);
 			break;
+		}
 		if (vdev_dtl_required(vml[c])) {
 			error = SET_ERROR(EBUSY);
 			break;
+		}
 		/* we need certain info from the top level */
 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_ARRAY,
 		    vml[c]->vdev_top->vdev_ms_array) == 0);
 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_SHIFT,
 		    vml[c]->vdev_top->vdev_ms_shift) == 0);
 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASIZE,
 		    vml[c]->vdev_top->vdev_asize) == 0);
 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASHIFT,
 		    vml[c]->vdev_top->vdev_ashift) == 0);
 		/* transfer per-vdev ZAPs */
 		ASSERT3U(vml[c]->vdev_leaf_zap, !=, 0);
 		VERIFY0(nvlist_add_uint64(child[c],
 		    ZPOOL_CONFIG_VDEV_LEAF_ZAP, vml[c]->vdev_leaf_zap));
 		ASSERT3U(vml[c]->vdev_top->vdev_top_zap, !=, 0);
 		VERIFY0(nvlist_add_uint64(child[c],
 		    ZPOOL_CONFIG_VDEV_TOP_ZAP,
 		    vml[c]->vdev_parent->vdev_top_zap));
+	}
 	if (error != 0) {
 		kmem_free(vml, children * sizeof (vdev_t *));
 		kmem_free(glist, children * sizeof (uint64_t));
 		return (spa_vdev_exit(spa, NULL, txg, error));
+	}
 	/* stop writers from using the disks */
 	for (c = 0; c < children; c++) {
 		if (vml[c] != NULL)
 			vml[c]->vdev_offline = B_TRUE;
+	}
 	vdev_reopen(spa->spa_root_vdev);
 	/*
 	 * Temporarily record the splitting vdevs in the spa config.  This
 	 * will disappear once the config is regenerated.
 	 */
 	VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) == 0);
 	VERIFY(nvlist_add_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST,
 	    glist, children) == 0);
 	kmem_free(glist, children * sizeof (uint64_t));
 	mutex_enter(&spa->spa_props_lock);
 	VERIFY(nvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT,
 	    nvl) == 0);
 	mutex_exit(&spa->spa_props_lock);
 	spa->spa_config_splitting = nvl;
 	vdev_config_dirty(spa->spa_root_vdev);
 	/* configure and create the new pool */
 	VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, newname) == 0);
 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
 	    exp ? POOL_STATE_EXPORTED : POOL_STATE_ACTIVE) == 0);
 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VERSION,
 	    spa_version(spa)) == 0);
 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG,
 	    spa->spa_config_txg) == 0);
 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID,
 	    spa_generate_guid(NULL)) == 0);
 	VERIFY0(nvlist_add_boolean(config, ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS));
 	(void) nvlist_lookup_string(props,
 	    zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
 	/* add the new pool to the namespace */
 	newspa = spa_add(newname, config, altroot);
 	newspa->spa_avz_action = AVZ_ACTION_REBUILD;
 	newspa->spa_config_txg = spa->spa_config_txg;
 	spa_set_log_state(newspa, SPA_LOG_CLEAR);
 	/* release the spa config lock, retaining the namespace lock */
 	spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
 	if (zio_injection_enabled)
 		zio_handle_panic_injection(spa, FTAG, 1);
 	spa_activate(newspa, spa_mode_global);
 	spa_async_suspend(newspa);
 #ifndef illumos
 	/* mark that we are creating new spa by splitting */
 	newspa->spa_splitting_newspa = B_TRUE;
 #endif
 	/* create the new pool from the disks of the original pool */
 	error = spa_load(newspa, SPA_LOAD_IMPORT, SPA_IMPORT_ASSEMBLE, B_TRUE);
 #ifndef illumos
 	newspa->spa_splitting_newspa = B_FALSE;
 #endif
 	if (error)
 		goto out;
 	/* if that worked, generate a real config for the new pool */
 	if (newspa->spa_root_vdev != NULL) {
 		VERIFY(nvlist_alloc(&newspa->spa_config_splitting,
 		    NV_UNIQUE_NAME, KM_SLEEP) == 0);
 		VERIFY(nvlist_add_uint64(newspa->spa_config_splitting,
 		    ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)) == 0);
 		spa_config_set(newspa, spa_config_generate(newspa, NULL, -1ULL,
 		    B_TRUE));
+	}
 	/* set the props */
 	if (props != NULL) {
 		spa_configfile_set(newspa, props, B_FALSE);
 		error = spa_prop_set(newspa, props);
 		if (error)
 			goto out;
+	}
 	/* flush everything */
 	txg = spa_vdev_config_enter(newspa);
 	vdev_config_dirty(newspa->spa_root_vdev);
 	(void) spa_vdev_config_exit(newspa, NULL, txg, 0, FTAG);
 	if (zio_injection_enabled)
 		zio_handle_panic_injection(spa, FTAG, 2);
 	spa_async_resume(newspa);
 	/* finally, update the original pool's config */
 	txg = spa_vdev_config_enter(spa);
 	tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
 	error = dmu_tx_assign(tx, TXG_WAIT);
 	if (error != 0)
 		dmu_tx_abort(tx);
 	for (c = 0; c < children; c++) {
 		if (vml[c] != NULL) {
 			vdev_split(vml[c]);
 			if (error == 0)
 				spa_history_log_internal(spa, "detach", tx,
 				    "vdev=%s", vml[c]->vdev_path);
 			vdev_free(vml[c]);
+		}
+	}
 	spa->spa_avz_action = AVZ_ACTION_REBUILD;
 	vdev_config_dirty(spa->spa_root_vdev);
 	spa->spa_config_splitting = NULL;
 	nvlist_free(nvl);
 	if (error == 0)
 		dmu_tx_commit(tx);
 	(void) spa_vdev_exit(spa, NULL, txg, 0);
 	if (zio_injection_enabled)
 		zio_handle_panic_injection(spa, FTAG, 3);
 	/* split is complete; log a history record */
 	spa_history_log_internal(newspa, "split", NULL,
 	    "from pool %s", spa_name(spa));
 	kmem_free(vml, children * sizeof (vdev_t *));
 	/* if we're not going to mount the filesystems in userland, export */
 	if (exp)
 		error = spa_export_common(newname, POOL_STATE_EXPORTED, NULL,
 		    B_FALSE, B_FALSE);
 	return (error);
 out:
 	spa_unload(newspa);
 	spa_deactivate(newspa);
 	spa_remove(newspa);
 	txg = spa_vdev_config_enter(spa);
 	/* re-online all offlined disks */
 	for (c = 0; c < children; c++) {
 		if (vml[c] != NULL)
 			vml[c]->vdev_offline = B_FALSE;
+	}
 	vdev_reopen(spa->spa_root_vdev);
 	nvlist_free(spa->spa_config_splitting);
 	spa->spa_config_splitting = NULL;
 	(void) spa_vdev_exit(spa, NULL, txg, error);
 	kmem_free(vml, children * sizeof (vdev_t *));
 	return (error);
+}
 static nvlist_t *
 spa_nvlist_lookup_by_guid(nvlist_t **nvpp, int count, uint64_t target_guid)
+{
 	for (int i = 0; i < count; i++) {
 		uint64_t guid;
 		VERIFY(nvlist_lookup_uint64(nvpp[i], ZPOOL_CONFIG_GUID,
 		    &guid) == 0);
 		if (guid == target_guid)
 			return (nvpp[i]);
+	}
 	return (NULL);
+}
 static void
 spa_vdev_remove_aux(nvlist_t *config, char *name, nvlist_t **dev, int count,
     nvlist_t *dev_to_remove)
+{
 	nvlist_t **newdev = NULL;
 	if (count > 1)
 		newdev = kmem_alloc((count - 1) * sizeof (void *), KM_SLEEP);
 	for (int i = 0, j = 0; i < count; i++) {
 		if (dev[i] == dev_to_remove)
 			continue;
 		VERIFY(nvlist_dup(dev[i], &newdev[j++], KM_SLEEP) == 0);
+	}
 	VERIFY(nvlist_remove(config, name, DATA_TYPE_NVLIST_ARRAY) == 0);
 	VERIFY(nvlist_add_nvlist_array(config, name, newdev, count - 1) == 0);
 	for (int i = 0; i < count - 1; i++)
 		nvlist_free(newdev[i]);
 	if (count > 1)
 		kmem_free(newdev, (count - 1) * sizeof (void *));
+}
 /*
  * Evacuate the device.
  */
 static int
 spa_vdev_remove_evacuate(spa_t *spa, vdev_t *vd)
+{
 	uint64_t txg;
 	int error = 0;
 	ASSERT(MUTEX_HELD(&spa_namespace_lock));
 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
 	ASSERT(vd == vd->vdev_top);
 	/*
 	 * Evacuate the device.  We don't hold the config lock as writer
 	 * since we need to do I/O but we do keep the
 	 * spa_namespace_lock held.  Once this completes the device
 	 * should no longer have any blocks allocated on it.
 	 */
 	if (vd->vdev_islog) {
 		if (vd->vdev_stat.vs_alloc != 0)
 			error = spa_offline_log(spa);
 	} else {
 		error = SET_ERROR(ENOTSUP);
+	}
 	if (error)
 		return (error);
 	/*
 	 * The evacuation succeeded.  Remove any remaining MOS metadata
 	 * associated with this vdev, and wait for these changes to sync.
 	 */
 	ASSERT0(vd->vdev_stat.vs_alloc);
 	txg = spa_vdev_config_enter(spa);
 	vd->vdev_removing = B_TRUE;
 	vdev_dirty_leaves(vd, VDD_DTL, txg);
 	vdev_config_dirty(vd);
 	spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
 	return (0);
+}
 /*
  * Complete the removal by cleaning up the namespace.
  */
 static void
 spa_vdev_remove_from_namespace(spa_t *spa, vdev_t *vd)
+{
 	vdev_t *rvd = spa->spa_root_vdev;
 	uint64_t id = vd->vdev_id;
 	boolean_t last_vdev = (id == (rvd->vdev_children - 1));
 	ASSERT(MUTEX_HELD(&spa_namespace_lock));
 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
 	ASSERT(vd == vd->vdev_top);
 	/*
 	 * Only remove any devices which are empty.
 	 */
 	if (vd->vdev_stat.vs_alloc != 0)
 		return;
 	(void) vdev_label_init(vd, 0, VDEV_LABEL_REMOVE);
 	if (list_link_active(&vd->vdev_state_dirty_node))
 		vdev_state_clean(vd);
 	if (list_link_active(&vd->vdev_config_dirty_node))
 		vdev_config_clean(vd);
 	vdev_free(vd);
 	if (last_vdev) {
 		vdev_compact_children(rvd);
 	} else {
 		vd = vdev_alloc_common(spa, id, 0, &vdev_hole_ops);
 		vdev_add_child(rvd, vd);
+	}
 	vdev_config_dirty(rvd);
 	/*
 	 * Reassess the health of our root vdev.
 	 */
 	vdev_reopen(rvd);
+}
 /*
  * Remove a device from the pool -
+ *
  * Removing a device from the vdev namespace requires several steps
  * and can take a significant amount of time.  As a result we use
  * the spa_vdev_config_[enter/exit] functions which allow us to
  * grab and release the spa_config_lock while still holding the namespace
  * lock.  During each step the configuration is synced out.
+ *
  * Currently, this supports removing only hot spares, slogs, and level 2 ARC
  * devices.
  */
 int
 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare)
+{
 	vdev_t *vd;
 	sysevent_t *ev = NULL;
 	metaslab_group_t *mg;
 	nvlist_t **spares, **l2cache, *nv;
 	uint64_t txg = 0;
 	uint_t nspares, nl2cache;
 	int error = 0;
 	boolean_t locked = MUTEX_HELD(&spa_namespace_lock);
 	ASSERT(spa_writeable(spa));
 	if (!locked)
 		txg = spa_vdev_enter(spa);
 	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
 	if (spa->spa_spares.sav_vdevs != NULL &&
 	    nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
 	    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0 &&
 	    (nv = spa_nvlist_lookup_by_guid(spares, nspares, guid)) != NULL) {
 		/*
 		 * Only remove the hot spare if it's not currently in use
 		 * in this pool.
 		 */
 		if (vd == NULL || unspare) {
 			if (vd == NULL)
 				vd = spa_lookup_by_guid(spa, guid, B_TRUE);
 			ev = spa_event_create(spa, vd, ESC_ZFS_VDEV_REMOVE_AUX);
 			spa_vdev_remove_aux(spa->spa_spares.sav_config,
 			    ZPOOL_CONFIG_SPARES, spares, nspares, nv);
 			spa_load_spares(spa);
 			spa->spa_spares.sav_sync = B_TRUE;
 		} else {
 			error = SET_ERROR(EBUSY);
+		}
 	} else if (spa->spa_l2cache.sav_vdevs != NULL &&
 	    nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
 	    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0 &&
 	    (nv = spa_nvlist_lookup_by_guid(l2cache, nl2cache, guid)) != NULL) {
 		/*
 		 * Cache devices can always be removed.
 		 */
 		vd = spa_lookup_by_guid(spa, guid, B_TRUE);
 		ev = spa_event_create(spa, vd, ESC_ZFS_VDEV_REMOVE_AUX);
 		spa_vdev_remove_aux(spa->spa_l2cache.sav_config,
 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache, nv);
 		spa_load_l2cache(spa);
 		spa->spa_l2cache.sav_sync = B_TRUE;
 	} else if (vd != NULL && vd->vdev_islog) {
 		ASSERT(!locked);
 		ASSERT(vd == vd->vdev_top);
 		mg = vd->vdev_mg;
 		/*
 		 * Stop allocating from this vdev.
 		 */
 		metaslab_group_passivate(mg);
 		/*
 		 * Wait for the youngest allocations and frees to sync,
 		 * and then wait for the deferral of those frees to finish.
 		 */
 		spa_vdev_config_exit(spa, NULL,
 		    txg + TXG_CONCURRENT_STATES + TXG_DEFER_SIZE, 0, FTAG);
 		/*
 		 * Attempt to evacuate the vdev.
 		 */
 		error = spa_vdev_remove_evacuate(spa, vd);
 		txg = spa_vdev_config_enter(spa);
 		/*
 		 * If we couldn't evacuate the vdev, unwind.
 		 */
 		if (error) {
 			metaslab_group_activate(mg);
 			return (spa_vdev_exit(spa, NULL, txg, error));
+		}
 		/*
 		 * Clean up the vdev namespace.
 		 */
 		ev = spa_event_create(spa, vd, ESC_ZFS_VDEV_REMOVE_DEV);
 		spa_vdev_remove_from_namespace(spa, vd);
 	} else if (vd != NULL) {
 		/*
 		 * Normal vdevs cannot be removed (yet).
 		 */
 		error = SET_ERROR(ENOTSUP);
 	} else {
 		/*
 		 * There is no vdev of any kind with the specified guid.
 		 */
 		error = SET_ERROR(ENOENT);
+	}
 	if (!locked)
 		error = spa_vdev_exit(spa, NULL, txg, error);
 	if (ev)
 		spa_event_post(ev);
 	return (error);
+}
 /*
  * Find any device that's done replacing, or a vdev marked 'unspare' that's
  * currently spared, so we can detach it.
  */
 static vdev_t *
 spa_vdev_resilver_done_hunt(vdev_t *vd)
+{
 	vdev_t *newvd, *oldvd;
 	for (int c = 0; c < vd->vdev_children; c++) {
 		oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]);
 		if (oldvd != NULL)
 			return (oldvd);
+	}
 	/*
 	 * Check for a completed replacement.  We always consider the first
 	 * vdev in the list to be the oldest vdev, and the last one to be
 	 * the newest (see spa_vdev_attach() for how that works).  In
 	 * the case where the newest vdev is faulted, we will not automatically
 	 * remove it after a resilver completes.  This is OK as it will require
 	 * user intervention to determine which disk the admin wishes to keep.
 	 */
 	if (vd->vdev_ops == &vdev_replacing_ops) {
 		ASSERT(vd->vdev_children > 1);
 		newvd = vd->vdev_child[vd->vdev_children - 1];
 		oldvd = vd->vdev_child[0];
 		if (vdev_dtl_empty(newvd, DTL_MISSING) &&
 		    vdev_dtl_empty(newvd, DTL_OUTAGE) &&
 		    !vdev_dtl_required(oldvd))
 			return (oldvd);
+	}
 	/*
 	 * Check for a completed resilver with the 'unspare' flag set.
 	 */
 	if (vd->vdev_ops == &vdev_spare_ops) {
 		vdev_t *first = vd->vdev_child[0];
 		vdev_t *last = vd->vdev_child[vd->vdev_children - 1];
 		if (last->vdev_unspare) {
 			oldvd = first;
 			newvd = last;
 		} else if (first->vdev_unspare) {
 			oldvd = last;
 			newvd = first;
 		} else {
 			oldvd = NULL;
+		}
 		if (oldvd != NULL &&
 		    vdev_dtl_empty(newvd, DTL_MISSING) &&
 		    vdev_dtl_empty(newvd, DTL_OUTAGE) &&
 		    !vdev_dtl_required(oldvd))
 			return (oldvd);
 		/*
 		 * If there are more than two spares attached to a disk,
 		 * and those spares are not required, then we want to
 		 * attempt to free them up now so that they can be used
 		 * by other pools.  Once we're back down to a single
 		 * disk+spare, we stop removing them.
 		 */
 		if (vd->vdev_children > 2) {
 			newvd = vd->vdev_child[1];
 			if (newvd->vdev_isspare && last->vdev_isspare &&
 			    vdev_dtl_empty(last, DTL_MISSING) &&
 			    vdev_dtl_empty(last, DTL_OUTAGE) &&
 			    !vdev_dtl_required(newvd))
 				return (newvd);
+		}
+	}
 	return (NULL);
+}
 static void
 spa_vdev_resilver_done(spa_t *spa)
+{
 	vdev_t *vd, *pvd, *ppvd;
 	uint64_t guid, sguid, pguid, ppguid;
 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
 	while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
 		pvd = vd->vdev_parent;
 		ppvd = pvd->vdev_parent;
 		guid = vd->vdev_guid;
 		pguid = pvd->vdev_guid;
 		ppguid = ppvd->vdev_guid;
 		sguid = 0;
 		/*
 		 * If we have just finished replacing a hot spared device, then
 		 * we need to detach the parent's first child (the original hot
 		 * spare) as well.
 		 */
 		if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0 &&
 		    ppvd->vdev_children == 2) {
 			ASSERT(pvd->vdev_ops == &vdev_replacing_ops);
 			sguid = ppvd->vdev_child[1]->vdev_guid;
+		}
 		ASSERT(vd->vdev_resilver_txg == 0 || !vdev_dtl_required(vd));
 		spa_config_exit(spa, SCL_ALL, FTAG);
 		if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0)
 			return;
 		if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0)
 			return;
 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
+	}
 	spa_config_exit(spa, SCL_ALL, FTAG);
+}
 /*
  * Update the stored path or FRU for this vdev.
  */
 int
 spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value,
     boolean_t ispath)
+{
 	vdev_t *vd;
 	boolean_t sync = B_FALSE;
 	ASSERT(spa_writeable(spa));
 	spa_vdev_state_enter(spa, SCL_ALL);
 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
 		return (spa_vdev_state_exit(spa, NULL, ENOENT));
 	if (!vd->vdev_ops->vdev_op_leaf)
 		return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
 	if (ispath) {
 		if (strcmp(value, vd->vdev_path) != 0) {
 			spa_strfree(vd->vdev_path);
 			vd->vdev_path = spa_strdup(value);
 			sync = B_TRUE;
+		}
 	} else {
 		if (vd->vdev_fru == NULL) {
 			vd->vdev_fru = spa_strdup(value);
 			sync = B_TRUE;
 		} else if (strcmp(value, vd->vdev_fru) != 0) {
 			spa_strfree(vd->vdev_fru);
 			vd->vdev_fru = spa_strdup(value);
 			sync = B_TRUE;
+		}
+	}
 	return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0));
+}
 int
 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath)
+{
 	return (spa_vdev_set_common(spa, guid, newpath, B_TRUE));
+}
 int
 spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru)
+{
 	return (spa_vdev_set_common(spa, guid, newfru, B_FALSE));
+}
 /*
  * ==========================================================================
  * SPA Scanning
  * ==========================================================================
  */
 int
 spa_scan_stop(spa_t *spa)
+{
 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
 	if (dsl_scan_resilvering(spa->spa_dsl_pool))
 		return (SET_ERROR(EBUSY));
 	return (dsl_scan_cancel(spa->spa_dsl_pool));
+}
 int
 spa_scan(spa_t *spa, pool_scan_func_t func)
+{
 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
 	if (func >= POOL_SCAN_FUNCS || func == POOL_SCAN_NONE)
 		return (SET_ERROR(ENOTSUP));
 	/*
 	 * If a resilver was requested, but there is no DTL on a
 	 * writeable leaf device, we have nothing to do.
 	 */
 	if (func == POOL_SCAN_RESILVER &&
 	    !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
 		spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
 		return (0);
+	}
 	return (dsl_scan(spa->spa_dsl_pool, func));
+}
 /*
  * ==========================================================================
  * SPA async task processing
  * ==========================================================================
  */
 static void
 spa_async_remove(spa_t *spa, vdev_t *vd)
+{
 	if (vd->vdev_remove_wanted) {
 		vd->vdev_remove_wanted = B_FALSE;
 		vd->vdev_delayed_close = B_FALSE;
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE);
 		/*
 		 * We want to clear the stats, but we don't want to do a full
 		 * vdev_clear() as that will cause us to throw away
 		 * degraded/faulted state as well as attempt to reopen the
 		 * device, all of which is a waste.
 		 */
 		vd->vdev_stat.vs_read_errors = 0;
 		vd->vdev_stat.vs_write_errors = 0;
 		vd->vdev_stat.vs_checksum_errors = 0;
 		vdev_state_dirty(vd->vdev_top);
 		/* Tell userspace that the vdev is gone. */
 		zfs_post_remove(spa, vd);
+	}
 	for (int c = 0; c < vd->vdev_children; c++)
 		spa_async_remove(spa, vd->vdev_child[c]);
+}
 static void
 spa_async_probe(spa_t *spa, vdev_t *vd)
+{
 	if (vd->vdev_probe_wanted) {
 		vd->vdev_probe_wanted = B_FALSE;
 		vdev_reopen(vd);	/* vdev_open() does the actual probe */
+	}
 	for (int c = 0; c < vd->vdev_children; c++)
 		spa_async_probe(spa, vd->vdev_child[c]);
+}
 static void
 spa_async_autoexpand(spa_t *spa, vdev_t *vd)
+{
 	sysevent_id_t eid;
 	nvlist_t *attr;
 	char *physpath;
 	if (!spa->spa_autoexpand)
 		return;
 	for (int c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 		spa_async_autoexpand(spa, cvd);
+	}
 	if (!vd->vdev_ops->vdev_op_leaf || vd->vdev_physpath == NULL)
 		return;
 	physpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 	(void) snprintf(physpath, MAXPATHLEN, "/devices%s", vd->vdev_physpath);
 	VERIFY(nvlist_alloc(&attr, NV_UNIQUE_NAME, KM_SLEEP) == 0);
 	VERIFY(nvlist_add_string(attr, DEV_PHYS_PATH, physpath) == 0);
 	(void) ddi_log_sysevent(zfs_dip, SUNW_VENDOR, EC_DEV_STATUS,
 	    ESC_ZFS_VDEV_AUTOEXPAND, attr, &eid, DDI_SLEEP);
 	nvlist_free(attr);
 	kmem_free(physpath, MAXPATHLEN);
+}
 static void
 spa_async_thread(void *arg)
+{
 	spa_t *spa = arg;
 	int tasks;
 	ASSERT(spa->spa_sync_on);
 	mutex_enter(&spa->spa_async_lock);
 	tasks = spa->spa_async_tasks;
 	spa->spa_async_tasks &= SPA_ASYNC_REMOVE;
 	mutex_exit(&spa->spa_async_lock);
 	/*
 	 * See if the config needs to be updated.
 	 */
 	if (tasks & SPA_ASYNC_CONFIG_UPDATE) {
 		uint64_t old_space, new_space;
 		mutex_enter(&spa_namespace_lock);
 		old_space = metaslab_class_get_space(spa_normal_class(spa));
 		spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
 		new_space = metaslab_class_get_space(spa_normal_class(spa));
 		mutex_exit(&spa_namespace_lock);
 		/*
 		 * If the pool grew as a result of the config update,
 		 * then log an internal history event.
 		 */
 		if (new_space != old_space) {
 			spa_history_log_internal(spa, "vdev online", NULL,
 			    "pool '%s' size: %llu(+%llu)",
 			    spa_name(spa), new_space, new_space - old_space);
+		}
+	}
 	if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) {
 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 		spa_async_autoexpand(spa, spa->spa_root_vdev);
 		spa_config_exit(spa, SCL_CONFIG, FTAG);
+	}
 	/*
 	 * See if any devices need to be probed.
 	 */
 	if (tasks & SPA_ASYNC_PROBE) {
 		spa_vdev_state_enter(spa, SCL_NONE);
 		spa_async_probe(spa, spa->spa_root_vdev);
 		(void) spa_vdev_state_exit(spa, NULL, 0);
+	}
 	/*
 	 * If any devices are done replacing, detach them.
 	 */
 	if (tasks & SPA_ASYNC_RESILVER_DONE)
 		spa_vdev_resilver_done(spa);
 	/*
 	 * Kick off a resilver.
 	 */
 	if (tasks & SPA_ASYNC_RESILVER)
 		dsl_resilver_restart(spa->spa_dsl_pool, 0);
 	/*
 	 * Let the world know that we're done.
 	 */
 	mutex_enter(&spa->spa_async_lock);
 	spa->spa_async_thread = NULL;
 	cv_broadcast(&spa->spa_async_cv);
 	mutex_exit(&spa->spa_async_lock);
 	thread_exit();
+}
 static void
 spa_async_thread_vd(void *arg)
+{
 	spa_t *spa = arg;
 	int tasks;
 	ASSERT(spa->spa_sync_on);
 	mutex_enter(&spa->spa_async_lock);
 	tasks = spa->spa_async_tasks;
 retry:
 	spa->spa_async_tasks &= ~SPA_ASYNC_REMOVE;
 	mutex_exit(&spa->spa_async_lock);
 	/*
 	 * See if any devices need to be marked REMOVED.
 	 */
 	if (tasks & SPA_ASYNC_REMOVE) {
 		spa_vdev_state_enter(spa, SCL_NONE);
 		spa_async_remove(spa, spa->spa_root_vdev);
 		for (int i = 0; i < spa->spa_l2cache.sav_count; i++)
 			spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]);
 		for (int i = 0; i < spa->spa_spares.sav_count; i++)
 			spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]);
 		(void) spa_vdev_state_exit(spa, NULL, 0);
+	}
 	/*
 	 * Let the world know that we're done.
 	 */
 	mutex_enter(&spa->spa_async_lock);
 	tasks = spa->spa_async_tasks;
 	if ((tasks & SPA_ASYNC_REMOVE) != 0)
 		goto retry;
 	spa->spa_async_thread_vd = NULL;
 	cv_broadcast(&spa->spa_async_cv);
 	mutex_exit(&spa->spa_async_lock);
 	thread_exit();
+}
 void
 spa_async_suspend(spa_t *spa)
+{
 	mutex_enter(&spa->spa_async_lock);
 	spa->spa_async_suspended++;
 	while (spa->spa_async_thread != NULL &&
 	    spa->spa_async_thread_vd != NULL)
 		cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
 	mutex_exit(&spa->spa_async_lock);
+}
 void
 spa_async_resume(spa_t *spa)
+{
 	mutex_enter(&spa->spa_async_lock);
 	ASSERT(spa->spa_async_suspended != 0);
 	spa->spa_async_suspended--;
 	mutex_exit(&spa->spa_async_lock);
+}
 static boolean_t
 spa_async_tasks_pending(spa_t *spa)
+{
 	uint_t non_config_tasks;
 	uint_t config_task;
 	boolean_t config_task_suspended;
 	non_config_tasks = spa->spa_async_tasks & ~(SPA_ASYNC_CONFIG_UPDATE |
 	    SPA_ASYNC_REMOVE);
 	config_task = spa->spa_async_tasks & SPA_ASYNC_CONFIG_UPDATE;
 	if (spa->spa_ccw_fail_time == 0) {
 		config_task_suspended = B_FALSE;
 	} else {
 		config_task_suspended =
 		    (gethrtime() - spa->spa_ccw_fail_time) <
-		    (zfs_ccw_retry_interval * NANOSEC);
+		    ((hrtime_t)zfs_ccw_retry_interval * NANOSEC);
+	}
 	return (non_config_tasks || (config_task && !config_task_suspended));
+}
 static void
 spa_async_dispatch(spa_t *spa)
+{
 	mutex_enter(&spa->spa_async_lock);
 	if (spa_async_tasks_pending(spa) &&
 	    !spa->spa_async_suspended &&
 	    spa->spa_async_thread == NULL &&
 	    rootdir != NULL)
 		spa->spa_async_thread = thread_create(NULL, 0,
 		    spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
 	mutex_exit(&spa->spa_async_lock);
+}
 static void
 spa_async_dispatch_vd(spa_t *spa)
+{
 	mutex_enter(&spa->spa_async_lock);
 	if ((spa->spa_async_tasks & SPA_ASYNC_REMOVE) != 0 &&
 	    !spa->spa_async_suspended &&
 	    spa->spa_async_thread_vd == NULL &&
 	    rootdir != NULL)
 		spa->spa_async_thread_vd = thread_create(NULL, 0,
 		    spa_async_thread_vd, spa, 0, &p0, TS_RUN, maxclsyspri);
 	mutex_exit(&spa->spa_async_lock);
+}
 void
 spa_async_request(spa_t *spa, int task)
+{
 	zfs_dbgmsg("spa=%s async request task=%u", spa->spa_name, task);
 	mutex_enter(&spa->spa_async_lock);
 	spa->spa_async_tasks |= task;
 	mutex_exit(&spa->spa_async_lock);
 	spa_async_dispatch_vd(spa);
+}
 /*
  * ==========================================================================
  * SPA syncing routines
  * ==========================================================================
  */
 static int
 bpobj_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
+{
 	bpobj_t *bpo = arg;
 	bpobj_enqueue(bpo, bp, tx);
 	return (0);
+}
 static int
 spa_free_sync_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
+{
 	zio_t *zio = arg;
 	zio_nowait(zio_free_sync(zio, zio->io_spa, dmu_tx_get_txg(tx), bp,
 	    BP_GET_PSIZE(bp), zio->io_flags));
 	return (0);
+}
 /*
  * Note: this simple function is not inlined to make it easier to dtrace the
  * amount of time spent syncing frees.
  */
 static void
 spa_sync_frees(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx)
+{
 	zio_t *zio = zio_root(spa, NULL, NULL, 0);
 	bplist_iterate(bpl, spa_free_sync_cb, zio, tx);
 	VERIFY(zio_wait(zio) == 0);
+}
 /*
  * Note: this simple function is not inlined to make it easier to dtrace the
  * amount of time spent syncing deferred frees.
  */
 static void
 spa_sync_deferred_frees(spa_t *spa, dmu_tx_t *tx)
+{
 	zio_t *zio = zio_root(spa, NULL, NULL, 0);
 	VERIFY3U(bpobj_iterate(&spa->spa_deferred_bpobj,
 	    spa_free_sync_cb, zio, tx), ==, 0);
 	VERIFY0(zio_wait(zio));
+}
 static void
 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx)
+{
 	char *packed = NULL;
 	size_t bufsize;
 	size_t nvsize = 0;
 	dmu_buf_t *db;
 	VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0);
 	/*
 	 * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration
 	 * information.  This avoids the dmu_buf_will_dirty() path and
 	 * saves us a pre-read to get data we don't actually care about.
 	 */
 	bufsize = P2ROUNDUP((uint64_t)nvsize, SPA_CONFIG_BLOCKSIZE);
 	packed = kmem_alloc(bufsize, KM_SLEEP);
 	VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR,
 	    KM_SLEEP) == 0);
 	bzero(packed + nvsize, bufsize - nvsize);
 	dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx);
 	kmem_free(packed, bufsize);
 	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
 	dmu_buf_will_dirty(db, tx);
 	*(uint64_t *)db->db_data = nvsize;
 	dmu_buf_rele(db, FTAG);
+}
 static void
 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx,
     const char *config, const char *entry)
+{
 	nvlist_t *nvroot;
 	nvlist_t **list;
 	int i;
 	if (!sav->sav_sync)
 		return;
 	/*
 	 * Update the MOS nvlist describing the list of available devices.
 	 * spa_validate_aux() will have already made sure this nvlist is
 	 * valid and the vdevs are labeled appropriately.
 	 */
 	if (sav->sav_object == 0) {
 		sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
 		    DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE,
 		    sizeof (uint64_t), tx);
 		VERIFY(zap_update(spa->spa_meta_objset,
 		    DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1,
 		    &sav->sav_object, tx) == 0);
+	}
 	VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
 	if (sav->sav_count == 0) {
 		VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0);
 	} else {
 		list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
 		for (i = 0; i < sav->sav_count; i++)
 			list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
 			    B_FALSE, VDEV_CONFIG_L2CACHE);
 		VERIFY(nvlist_add_nvlist_array(nvroot, config, list,
 		    sav->sav_count) == 0);
 		for (i = 0; i < sav->sav_count; i++)
 			nvlist_free(list[i]);
 		kmem_free(list, sav->sav_count * sizeof (void *));
+	}
 	spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
 	nvlist_free(nvroot);
 	sav->sav_sync = B_FALSE;
+}
 /*
  * Rebuild spa's all-vdev ZAP from the vdev ZAPs indicated in each vdev_t.
  * The all-vdev ZAP must be empty.
  */
 static void
 spa_avz_build(vdev_t *vd, uint64_t avz, dmu_tx_t *tx)
+{
 	spa_t *spa = vd->vdev_spa;
 	if (vd->vdev_top_zap != 0) {
 		VERIFY0(zap_add_int(spa->spa_meta_objset, avz,
 		    vd->vdev_top_zap, tx));
+	}
 	if (vd->vdev_leaf_zap != 0) {
 		VERIFY0(zap_add_int(spa->spa_meta_objset, avz,
 		    vd->vdev_leaf_zap, tx));
+	}
 	for (uint64_t i = 0; i < vd->vdev_children; i++) {
 		spa_avz_build(vd->vdev_child[i], avz, tx);
+	}
+}
 static void
 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
+{
 	nvlist_t *config;
 	/*
 	 * If the pool is being imported from a pre-per-vdev-ZAP version of ZFS,
 	 * its config may not be dirty but we still need to build per-vdev ZAPs.
 	 * Similarly, if the pool is being assembled (e.g. after a split), we
 	 * need to rebuild the AVZ although the config may not be dirty.
 	 */
 	if (list_is_empty(&spa->spa_config_dirty_list) &&
 	    spa->spa_avz_action == AVZ_ACTION_NONE)
 		return;
 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
 	ASSERT(spa->spa_avz_action == AVZ_ACTION_NONE ||
 	    spa->spa_all_vdev_zaps != 0);
 	if (spa->spa_avz_action == AVZ_ACTION_REBUILD) {
 		/* Make and build the new AVZ */
 		uint64_t new_avz = zap_create(spa->spa_meta_objset,
 		    DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0, tx);
 		spa_avz_build(spa->spa_root_vdev, new_avz, tx);
 		/* Diff old AVZ with new one */
 		zap_cursor_t zc;
 		zap_attribute_t za;
 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
 		    spa->spa_all_vdev_zaps);
 		    zap_cursor_retrieve(&zc, &za) == 0;
 		    zap_cursor_advance(&zc)) {
 			uint64_t vdzap = za.za_first_integer;
 			if (zap_lookup_int(spa->spa_meta_objset, new_avz,
 			    vdzap) == ENOENT) {
 				/*
 				 * ZAP is listed in old AVZ but not in new one;
 				 * destroy it
 				 */
 				VERIFY0(zap_destroy(spa->spa_meta_objset, vdzap,
 				    tx));
+			}
+		}
 		zap_cursor_fini(&zc);
 		/* Destroy the old AVZ */
 		VERIFY0(zap_destroy(spa->spa_meta_objset,
 		    spa->spa_all_vdev_zaps, tx));
 		/* Replace the old AVZ in the dir obj with the new one */
 		VERIFY0(zap_update(spa->spa_meta_objset,
 		    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_VDEV_ZAP_MAP,
 		    sizeof (new_avz), 1, &new_avz, tx));
 		spa->spa_all_vdev_zaps = new_avz;
 	} else if (spa->spa_avz_action == AVZ_ACTION_DESTROY) {
 		zap_cursor_t zc;
 		zap_attribute_t za;
 		/* Walk through the AVZ and destroy all listed ZAPs */
 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
 		    spa->spa_all_vdev_zaps);
 		    zap_cursor_retrieve(&zc, &za) == 0;
 		    zap_cursor_advance(&zc)) {
 			uint64_t zap = za.za_first_integer;
 			VERIFY0(zap_destroy(spa->spa_meta_objset, zap, tx));
+		}
 		zap_cursor_fini(&zc);
 		/* Destroy and unlink the AVZ itself */
 		VERIFY0(zap_destroy(spa->spa_meta_objset,
 		    spa->spa_all_vdev_zaps, tx));
 		VERIFY0(zap_remove(spa->spa_meta_objset,
 		    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_VDEV_ZAP_MAP, tx));
 		spa->spa_all_vdev_zaps = 0;
+	}
 	if (spa->spa_all_vdev_zaps == 0) {
 		spa->spa_all_vdev_zaps = zap_create_link(spa->spa_meta_objset,
 		    DMU_OTN_ZAP_METADATA, DMU_POOL_DIRECTORY_OBJECT,
 		    DMU_POOL_VDEV_ZAP_MAP, tx);
+	}
 	spa->spa_avz_action = AVZ_ACTION_NONE;
 	/* Create ZAPs for vdevs that don't have them. */
 	vdev_construct_zaps(spa->spa_root_vdev, tx);
 	config = spa_config_generate(spa, spa->spa_root_vdev,
 	    dmu_tx_get_txg(tx), B_FALSE);
 	/*
 	 * If we're upgrading the spa version then make sure that
 	 * the config object gets updated with the correct version.
 	 */
 	if (spa->spa_ubsync.ub_version < spa->spa_uberblock.ub_version)
 		fnvlist_add_uint64(config, ZPOOL_CONFIG_VERSION,
 		    spa->spa_uberblock.ub_version);
 	spa_config_exit(spa, SCL_STATE, FTAG);
 	nvlist_free(spa->spa_config_syncing);
 	spa->spa_config_syncing = config;
 	spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
+}
 static void
 spa_sync_version(void *arg, dmu_tx_t *tx)
+{
 	uint64_t *versionp = arg;
 	uint64_t version = *versionp;
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 	/*
 	 * Setting the version is special cased when first creating the pool.
 	 */
 	ASSERT(tx->tx_txg != TXG_INITIAL);
 	ASSERT(SPA_VERSION_IS_SUPPORTED(version));
 	ASSERT(version >= spa_version(spa));
 	spa->spa_uberblock.ub_version = version;
 	vdev_config_dirty(spa->spa_root_vdev);
 	spa_history_log_internal(spa, "set", tx, "version=%lld", version);
+}
 /*
  * Set zpool properties.
  */
 static void
 spa_sync_props(void *arg, dmu_tx_t *tx)
+{
 	nvlist_t *nvp = arg;
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 	objset_t *mos = spa->spa_meta_objset;
 	nvpair_t *elem = NULL;
 	mutex_enter(&spa->spa_props_lock);
 	while ((elem = nvlist_next_nvpair(nvp, elem))) {
 		uint64_t intval;
 		char *strval, *fname;
 		zpool_prop_t prop;
 		const char *propname;
 		zprop_type_t proptype;
 		spa_feature_t fid;
 		switch (prop = zpool_name_to_prop(nvpair_name(elem))) {
 		case ZPROP_INVAL:
 			/*
 			 * We checked this earlier in spa_prop_validate().
 			 */
 			ASSERT(zpool_prop_feature(nvpair_name(elem)));
 			fname = strchr(nvpair_name(elem), '@') + 1;
 			VERIFY0(zfeature_lookup_name(fname, &fid));
 			spa_feature_enable(spa, fid, tx);
 			spa_history_log_internal(spa, "set", tx,
 			    "%s=enabled", nvpair_name(elem));
 			break;
 		case ZPOOL_PROP_VERSION:
 			intval = fnvpair_value_uint64(elem);
 			/*
 			 * The version is synced seperatly before other
 			 * properties and should be correct by now.
 			 */
 			ASSERT3U(spa_version(spa), >=, intval);
 			break;
 		case ZPOOL_PROP_ALTROOT:
 			/*
 			 * 'altroot' is a non-persistent property. It should
 			 * have been set temporarily at creation or import time.
 			 */
 			ASSERT(spa->spa_root != NULL);
 			break;
 		case ZPOOL_PROP_READONLY:
 		case ZPOOL_PROP_CACHEFILE:
 			/*
 			 * 'readonly' and 'cachefile' are also non-persisitent
 			 * properties.
 			 */
 			break;
 		case ZPOOL_PROP_COMMENT:
 			strval = fnvpair_value_string(elem);
 			if (spa->spa_comment != NULL)
 				spa_strfree(spa->spa_comment);
 			spa->spa_comment = spa_strdup(strval);
 			/*
 			 * We need to dirty the configuration on all the vdevs
 			 * so that their labels get updated.  It's unnecessary
 			 * to do this for pool creation since the vdev's
 			 * configuratoin has already been dirtied.
 			 */
 			if (tx->tx_txg != TXG_INITIAL)
 				vdev_config_dirty(spa->spa_root_vdev);
 			spa_history_log_internal(spa, "set", tx,
 			    "%s=%s", nvpair_name(elem), strval);
 			break;
 		default:
 			/*
 			 * Set pool property values in the poolprops mos object.
 			 */
 			if (spa->spa_pool_props_object == 0) {
 				spa->spa_pool_props_object =
 				    zap_create_link(mos, DMU_OT_POOL_PROPS,
 				    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS,
 				    tx);
+			}
 			/* normalize the property name */
 			propname = zpool_prop_to_name(prop);
 			proptype = zpool_prop_get_type(prop);
 			if (nvpair_type(elem) == DATA_TYPE_STRING) {
 				ASSERT(proptype == PROP_TYPE_STRING);
 				strval = fnvpair_value_string(elem);
 				VERIFY0(zap_update(mos,
 				    spa->spa_pool_props_object, propname,
 , strlen(strval) + 1, strval, tx));
 				spa_history_log_internal(spa, "set", tx,
 				    "%s=%s", nvpair_name(elem), strval);
 			} else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
 				intval = fnvpair_value_uint64(elem);
 				if (proptype == PROP_TYPE_INDEX) {
 					const char *unused;
 					VERIFY0(zpool_prop_index_to_string(
 					    prop, intval, &unused));
+				}
 				VERIFY0(zap_update(mos,
 				    spa->spa_pool_props_object, propname,
 , 1, &intval, tx));
 				spa_history_log_internal(spa, "set", tx,
 				    "%s=%lld", nvpair_name(elem), intval);
 			} else {
 				ASSERT(0); /* not allowed */
+			}
 			switch (prop) {
 			case ZPOOL_PROP_DELEGATION:
 				spa->spa_delegation = intval;
 				break;
 			case ZPOOL_PROP_BOOTFS:
 				spa->spa_bootfs = intval;
 				break;
 			case ZPOOL_PROP_FAILUREMODE:
 				spa->spa_failmode = intval;
 				break;
 			case ZPOOL_PROP_AUTOEXPAND:
 				spa->spa_autoexpand = intval;
 				if (tx->tx_txg != TXG_INITIAL)
 					spa_async_request(spa,
 					    SPA_ASYNC_AUTOEXPAND);
 				break;
 			case ZPOOL_PROP_DEDUPDITTO:
 				spa->spa_dedup_ditto = intval;
 				break;
 			default:
 				break;
+			}
+		}
+	}
 	mutex_exit(&spa->spa_props_lock);
+}
 /*
  * Perform one-time upgrade on-disk changes.  spa_version() does not
  * reflect the new version this txg, so there must be no changes this
  * txg to anything that the upgrade code depends on after it executes.
  * Therefore this must be called after dsl_pool_sync() does the sync
  * tasks.
  */
 static void
 spa_sync_upgrades(spa_t *spa, dmu_tx_t *tx)
+{
 	dsl_pool_t *dp = spa->spa_dsl_pool;
 	ASSERT(spa->spa_sync_pass == 1);
 	rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
 	if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
 	    spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
 		dsl_pool_create_origin(dp, tx);
 		/* Keeping the origin open increases spa_minref */
 		spa->spa_minref += 3;
+	}
 	if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
 	    spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
 		dsl_pool_upgrade_clones(dp, tx);
+	}
 	if (spa->spa_ubsync.ub_version < SPA_VERSION_DIR_CLONES &&
 	    spa->spa_uberblock.ub_version >= SPA_VERSION_DIR_CLONES) {
 		dsl_pool_upgrade_dir_clones(dp, tx);
 		/* Keeping the freedir open increases spa_minref */
 		spa->spa_minref += 3;
+	}
 	if (spa->spa_ubsync.ub_version < SPA_VERSION_FEATURES &&
 	    spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
 		spa_feature_create_zap_objects(spa, tx);
+	}
 	/*
 	 * LZ4_COMPRESS feature's behaviour was changed to activate_on_enable
 	 * when possibility to use lz4 compression for metadata was added
 	 * Old pools that have this feature enabled must be upgraded to have
 	 * this feature active
 	 */
 	if (spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
 		boolean_t lz4_en = spa_feature_is_enabled(spa,
 		    SPA_FEATURE_LZ4_COMPRESS);
 		boolean_t lz4_ac = spa_feature_is_active(spa,
 		    SPA_FEATURE_LZ4_COMPRESS);
 		if (lz4_en && !lz4_ac)
 			spa_feature_incr(spa, SPA_FEATURE_LZ4_COMPRESS, tx);
+	}
 	/*
 	 * If we haven't written the salt, do so now.  Note that the
 	 * feature may not be activated yet, but that's fine since
 	 * the presence of this ZAP entry is backwards compatible.
 	 */
 	if (zap_contains(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 	    DMU_POOL_CHECKSUM_SALT) == ENOENT) {
 		VERIFY0(zap_add(spa->spa_meta_objset,
 		    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CHECKSUM_SALT, 1,
 		    sizeof (spa->spa_cksum_salt.zcs_bytes),
 		    spa->spa_cksum_salt.zcs_bytes, tx));
+	}
 	rrw_exit(&dp->dp_config_rwlock, FTAG);
+}
 /*
  * Sync the specified transaction group.  New blocks may be dirtied as
  * part of the process, so we iterate until it converges.
  */
 void
 spa_sync(spa_t *spa, uint64_t txg)
+{
 	dsl_pool_t *dp = spa->spa_dsl_pool;
 	objset_t *mos = spa->spa_meta_objset;
 	bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK];
 	vdev_t *rvd = spa->spa_root_vdev;
 	vdev_t *vd;
 	dmu_tx_t *tx;
 	int error;
 	uint32_t max_queue_depth = zfs_vdev_async_write_max_active *
 	    zfs_vdev_queue_depth_pct / 100;
 	VERIFY(spa_writeable(spa));
 	/*
 	 * Lock out configuration changes.
 	 */
 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 	spa->spa_syncing_txg = txg;
 	spa->spa_sync_pass = 0;
 	mutex_enter(&spa->spa_alloc_lock);
 	VERIFY0(avl_numnodes(&spa->spa_alloc_tree));
 	mutex_exit(&spa->spa_alloc_lock);
 	/*
 	 * If there are any pending vdev state changes, convert them
 	 * into config changes that go out with this transaction group.
 	 */
 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
 	while (list_head(&spa->spa_state_dirty_list) != NULL) {
 		/*
 		 * We need the write lock here because, for aux vdevs,
 		 * calling vdev_config_dirty() modifies sav_config.
 		 * This is ugly and will become unnecessary when we
 		 * eliminate the aux vdev wart by integrating all vdevs
 		 * into the root vdev tree.
 		 */
 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
 		spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER);
 		while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) {
 			vdev_state_clean(vd);
 			vdev_config_dirty(vd);
+		}
 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
 		spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
+	}
 	spa_config_exit(spa, SCL_STATE, FTAG);
 	tx = dmu_tx_create_assigned(dp, txg);
 	spa->spa_sync_starttime = gethrtime();
 #ifdef illumos
 	VERIFY(cyclic_reprogram(spa->spa_deadman_cycid,
 	    spa->spa_sync_starttime + spa->spa_deadman_synctime));
 #endif	/* illumos */
 #ifdef __FreeBSD__
 #ifdef _KERNEL
 	callout_schedule(&spa->spa_deadman_cycid,
 	    hz * spa->spa_deadman_synctime / NANOSEC);
 #endif
 #endif /* __FreeBSD__ */
 #ifdef __NetBSD__
 #ifdef _KERNEL
 	callout_schedule(&spa->spa_deadman_cycid,
 	    hz * spa->spa_deadman_synctime / NANOSEC);
 #endif
 #endif
 	/*
 	 * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg,
 	 * set spa_deflate if we have no raid-z vdevs.
 	 */
 	if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
 	    spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
 		int i;
 		for (i = 0; i < rvd->vdev_children; i++) {
 			vd = rvd->vdev_child[i];
 			if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE)
 				break;
+		}
 		if (i == rvd->vdev_children) {
 			spa->spa_deflate = TRUE;
 			VERIFY(0 == zap_add(spa->spa_meta_objset,
 			    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
 			    sizeof (uint64_t), 1, &spa->spa_deflate, tx));
+		}
+	}
 	/*
 	 * Set the top-level vdev's max queue depth. Evaluate each
 	 * top-level's async write queue depth in case it changed.
 	 * The max queue depth will not change in the middle of syncing
 	 * out this txg.
 	 */
 	uint64_t queue_depth_total = 0;
 	for (int c = 0; c < rvd->vdev_children; c++) {
 		vdev_t *tvd = rvd->vdev_child[c];
 		metaslab_group_t *mg = tvd->vdev_mg;
 		if (mg == NULL || mg->mg_class != spa_normal_class(spa) ||
 		    !metaslab_group_initialized(mg))
 			continue;
 		/*
 		 * It is safe to do a lock-free check here because only async
 		 * allocations look at mg_max_alloc_queue_depth, and async
 		 * allocations all happen from spa_sync().
 		 */
 		ASSERT0(refcount_count(&mg->mg_alloc_queue_depth));
 		mg->mg_max_alloc_queue_depth = max_queue_depth;
 		queue_depth_total += mg->mg_max_alloc_queue_depth;
+	}
 	metaslab_class_t *mc = spa_normal_class(spa);
 	ASSERT0(refcount_count(&mc->mc_alloc_slots));
 	mc->mc_alloc_max_slots = queue_depth_total;
 	mc->mc_alloc_throttle_enabled = zio_dva_throttle_enabled;
 	ASSERT3U(mc->mc_alloc_max_slots, <=,
 	    max_queue_depth * rvd->vdev_children);
 	/*
 	 * Iterate to convergence.
 	 */
 	do {
 		int pass = ++spa->spa_sync_pass;
 		spa_sync_config_object(spa, tx);
 		spa_sync_aux_dev(spa, &spa->spa_spares, tx,
 		    ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES);
 		spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
 		    ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE);
 		spa_errlog_sync(spa, txg);
 		dsl_pool_sync(dp, txg);
 		if (pass < zfs_sync_pass_deferred_free) {
 			spa_sync_frees(spa, free_bpl, tx);
 		} else {
 			/*
 			 * We can not defer frees in pass 1, because
 			 * we sync the deferred frees later in pass 1.
 			 */
 			ASSERT3U(pass, >, 1);
 			bplist_iterate(free_bpl, bpobj_enqueue_cb,
 			    &spa->spa_deferred_bpobj, tx);
+		}
 		ddt_sync(spa, txg);
 		dsl_scan_sync(dp, tx);
 		while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg))
 			vdev_sync(vd, txg);
 		if (pass == 1) {
 			spa_sync_upgrades(spa, tx);
 			ASSERT3U(txg, >=,
 			    spa->spa_uberblock.ub_rootbp.blk_birth);
 			/*
 			 * Note: We need to check if the MOS is dirty
 			 * because we could have marked the MOS dirty
 			 * without updating the uberblock (e.g. if we
 			 * have sync tasks but no dirty user data).  We
 			 * need to check the uberblock's rootbp because
 			 * it is updated if we have synced out dirty
 			 * data (though in this case the MOS will most
 			 * likely also be dirty due to second order
 			 * effects, we don't want to rely on that here).
 			 */
 			if (spa->spa_uberblock.ub_rootbp.blk_birth < txg &&
 			    !dmu_objset_is_dirty(mos, txg)) {
 				/*
 				 * Nothing changed on the first pass,
 				 * therefore this TXG is a no-op.  Avoid
 				 * syncing deferred frees, so that we
 				 * can keep this TXG as a no-op.
 				 */
 				ASSERT(txg_list_empty(&dp->dp_dirty_datasets,
 				    txg));
 				ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
 				ASSERT(txg_list_empty(&dp->dp_sync_tasks, txg));
 				break;
+			}
 			spa_sync_deferred_frees(spa, tx);
+		}
 	} while (dmu_objset_is_dirty(mos, txg));
 	if (!list_is_empty(&spa->spa_config_dirty_list)) {
 		/*
 		 * Make sure that the number of ZAPs for all the vdevs matches
 		 * the number of ZAPs in the per-vdev ZAP list. This only gets
 		 * called if the config is dirty; otherwise there may be
 		 * outstanding AVZ operations that weren't completed in
 		 * spa_sync_config_object.
 		 */
 		uint64_t all_vdev_zap_entry_count;
 		ASSERT0(zap_count(spa->spa_meta_objset,
 		    spa->spa_all_vdev_zaps, &all_vdev_zap_entry_count));
 		ASSERT3U(vdev_count_verify_zaps(spa->spa_root_vdev), ==,
 		    all_vdev_zap_entry_count);
+	}
 	/*
 	 * Rewrite the vdev configuration (which includes the uberblock)
 	 * to commit the transaction group.
+	 *
 	 * If there are no dirty vdevs, we sync the uberblock to a few
 	 * random top-level vdevs that are known to be visible in the
 	 * config cache (see spa_vdev_add() for a complete description).
 	 * If there *are* dirty vdevs, sync the uberblock to all vdevs.
 	 */
 	for (;;) {
 		/*
 		 * We hold SCL_STATE to prevent vdev open/close/etc.
 		 * while we're attempting to write the vdev labels.
 		 */
 		spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
 		if (list_is_empty(&spa->spa_config_dirty_list)) {
 			vdev_t *svd[SPA_DVAS_PER_BP];
 			int svdcount = 0;
 			int children = rvd->vdev_children;
 			int c0 = spa_get_random(children);
 			for (int c = 0; c < children; c++) {
 				vd = rvd->vdev_child[(c0 + c) % children];
 				if (vd->vdev_ms_array == 0 || vd->vdev_islog)
 					continue;
 				svd[svdcount++] = vd;
 				if (svdcount == SPA_DVAS_PER_BP)
 					break;
+			}
 			error = vdev_config_sync(svd, svdcount, txg);
 		} else {
 			error = vdev_config_sync(rvd->vdev_child,
 			    rvd->vdev_children, txg);
+		}
 		if (error == 0)
 			spa->spa_last_synced_guid = rvd->vdev_guid;
 		spa_config_exit(spa, SCL_STATE, FTAG);
 		if (error == 0)
 			break;
 		zio_suspend(spa, NULL);
 		zio_resume_wait(spa);
+	}
 	dmu_tx_commit(tx);
 #ifdef illumos
 	VERIFY(cyclic_reprogram(spa->spa_deadman_cycid, CY_INFINITY));
 #endif	/* illumos */
 #ifdef __FreeBSD__
 #ifdef _KERNEL
 	callout_drain(&spa->spa_deadman_cycid);
 #endif
 #endif	/* __FreeBSD__ */
 #ifdef __NetBSD__
 #ifdef _KERNEL
 	callout_drain(&spa->spa_deadman_cycid);
 #endif
 #endif	/* __NetBSD__ */
 	/*
 	 * Clear the dirty config list.
 	 */
 	while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL)
 		vdev_config_clean(vd);
 	/*
 	 * Now that the new config has synced transactionally,
 	 * let it become visible to the config cache.
 	 */
 	if (spa->spa_config_syncing != NULL) {
 		spa_config_set(spa, spa->spa_config_syncing);
 		spa->spa_config_txg = txg;
 		spa->spa_config_syncing = NULL;
+	}
 	dsl_pool_sync_done(dp, txg);
 	mutex_enter(&spa->spa_alloc_lock);
 	VERIFY0(avl_numnodes(&spa->spa_alloc_tree));
 	mutex_exit(&spa->spa_alloc_lock);
 	/*
 	 * Update usable space statistics.
 	 */
 	while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
 		vdev_sync_done(vd, txg);
 	spa_update_dspace(spa);
 	/*
 	 * It had better be the case that we didn't dirty anything
 	 * since vdev_config_sync().
 	 */
 	ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg));
 	ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
 	ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));
 	spa->spa_sync_pass = 0;
 	/*
 	 * Update the last synced uberblock here. We want to do this at
 	 * the end of spa_sync() so that consumers of spa_last_synced_txg()
 	 * will be guaranteed that all the processing associated with
 	 * that txg has been completed.
 	 */
 	spa->spa_ubsync = spa->spa_uberblock;
 	spa_config_exit(spa, SCL_CONFIG, FTAG);
 	spa_handle_ignored_writes(spa);
 	/*
 	 * If any async tasks have been requested, kick them off.
 	 */
 	spa_async_dispatch(spa);
 	spa_async_dispatch_vd(spa);
+}
 /*
  * Sync all pools.  We don't want to hold the namespace lock across these
  * operations, so we take a reference on the spa_t and drop the lock during the
  * sync.
  */
 void
 spa_sync_allpools(void)
+{
 	spa_t *spa = NULL;
 	mutex_enter(&spa_namespace_lock);
 	while ((spa = spa_next(spa)) != NULL) {
 		if (spa_state(spa) != POOL_STATE_ACTIVE ||
 		    !spa_writeable(spa) || spa_suspended(spa))
 			continue;
 		spa_open_ref(spa, FTAG);
 		mutex_exit(&spa_namespace_lock);
 		txg_wait_synced(spa_get_dsl(spa), 0);
 		mutex_enter(&spa_namespace_lock);
 		spa_close(spa, FTAG);
+	}
 	mutex_exit(&spa_namespace_lock);
+}
 /*
  * ==========================================================================
  * Miscellaneous routines
  * ==========================================================================
  */
 /*
  * Remove all pools in the system.
  */
 void
 spa_evict_all(void)
+{
 	spa_t *spa;
 	/*
 	 * Remove all cached state.  All pools should be closed now,
 	 * so every spa in the AVL tree should be unreferenced.
 	 */
 	mutex_enter(&spa_namespace_lock);
 	while ((spa = spa_next(NULL)) != NULL) {
 		/*
 		 * Stop async tasks.  The async thread may need to detach
 		 * a device that's been replaced, which requires grabbing
 		 * spa_namespace_lock, so we must drop it here.
 		 */
 		spa_open_ref(spa, FTAG);
 		mutex_exit(&spa_namespace_lock);
 		spa_async_suspend(spa);
 		mutex_enter(&spa_namespace_lock);
 		spa_close(spa, FTAG);
 		if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
 			spa_unload(spa);
 			spa_deactivate(spa);
+		}
 		spa_remove(spa);
+	}
 	mutex_exit(&spa_namespace_lock);
+}
 vdev_t *
 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux)
+{
 	vdev_t *vd;
 	int i;
 	if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
 		return (vd);
 	if (aux) {
 		for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
 			vd = spa->spa_l2cache.sav_vdevs[i];
 			if (vd->vdev_guid == guid)
 				return (vd);
+		}
 		for (i = 0; i < spa->spa_spares.sav_count; i++) {
 			vd = spa->spa_spares.sav_vdevs[i];
 			if (vd->vdev_guid == guid)
 				return (vd);
+		}
+	}
 	return (NULL);
+}
 void
 spa_upgrade(spa_t *spa, uint64_t version)
+{
 	ASSERT(spa_writeable(spa));
 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
 	/*
 	 * This should only be called for a non-faulted pool, and since a
 	 * future version would result in an unopenable pool, this shouldn't be
 	 * possible.
 	 */
 	ASSERT(SPA_VERSION_IS_SUPPORTED(spa->spa_uberblock.ub_version));
 	ASSERT3U(version, >=, spa->spa_uberblock.ub_version);
 	spa->spa_uberblock.ub_version = version;
 	vdev_config_dirty(spa->spa_root_vdev);
 	spa_config_exit(spa, SCL_ALL, FTAG);
 	txg_wait_synced(spa_get_dsl(spa), 0);
+}
 boolean_t
 spa_has_spare(spa_t *spa, uint64_t guid)
+{
 	int i;
 	uint64_t spareguid;
 	spa_aux_vdev_t *sav = &spa->spa_spares;
 	for (i = 0; i < sav->sav_count; i++)
 		if (sav->sav_vdevs[i]->vdev_guid == guid)
 			return (B_TRUE);
 	for (i = 0; i < sav->sav_npending; i++) {
 		if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID,
 		    &spareguid) == 0 && spareguid == guid)
 			return (B_TRUE);
+	}
 	return (B_FALSE);