Fix all instances of for (int i;;) {} that were easily found

diff --git a/cmd/zdb/zdb.c b/cmd/zdb/zdb.c
index 253a1346a498681454e9215b95223d9f3065f462..ee2923e2c3d41e4ea7250faaed63ac8e262c4ed9 100644 (file)
--- a/cmd/zdb/zdb.c
+++ b/cmd/zdb/zdb.c
@@ -1389,10 +1389,11 @@ static void
 zdb_leak_init(spa_t *spa)
 {
        vdev_t *rvd = spa->spa_root_vdev;
+       int c, m;
 
-       for (int c = 0; c < rvd->vdev_children; c++) {
+       for (c = 0; c < rvd->vdev_children; c++) {
                vdev_t *vd = rvd->vdev_child[c];
-               for (int m = 0; m < vd->vdev_ms_count; m++) {
+               for (m = 0; m < vd->vdev_ms_count; m++) {
                        metaslab_t *msp = vd->vdev_ms[m];
                        mutex_enter(&msp->ms_lock);
                        VERIFY(space_map_load(&msp->ms_map, &zdb_space_map_ops,
@@ -1407,10 +1408,11 @@ static void
 zdb_leak_fini(spa_t *spa)
 {
        vdev_t *rvd = spa->spa_root_vdev;
+       int c, m;
 
-       for (int c = 0; c < rvd->vdev_children; c++) {
+       for (c = 0; c < rvd->vdev_children; c++) {
                vdev_t *vd = rvd->vdev_child[c];
-               for (int m = 0; m < vd->vdev_ms_count; m++) {
+               for (m = 0; m < vd->vdev_ms_count; m++) {
                        metaslab_t *msp = vd->vdev_ms[m];
                        mutex_enter(&msp->ms_lock);
                        space_map_unload(&msp->ms_map);
@@ -1445,7 +1447,9 @@ typedef struct zdb_cb {
 static void
 zdb_count_block(spa_t *spa, zdb_cb_t *zcb, blkptr_t *bp, dmu_object_type_t type)
 {
-       for (int i = 0; i < 4; i++) {
+       int i;
+
+       for (i = 0; i < 4; i++) {
                int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
                int t = (i & 1) ? type : DMU_OT_TOTAL;
                zdb_blkstats_t *zb = &zcb->zcb_type[l][t];

diff --git a/cmd/ztest/ztest.c b/cmd/ztest/ztest.c
index 53cc6c7093b727508f2efd750e7d2b750dedeb31..9274885b20e978045c44f0ca7119ceb2ba83fc3a 100644 (file)
--- a/cmd/ztest/ztest.c
+++ b/cmd/ztest/ztest.c
@@ -834,11 +834,12 @@ static vdev_t *
 vdev_lookup_by_path(vdev_t *vd, const char *path)
 {
        vdev_t *mvd;
+       int c;
 
        if (vd->vdev_path != NULL && strcmp(path, vd->vdev_path) == 0)
                return (vd);
 
-       for (int c = 0; c < vd->vdev_children; c++)
+       for (c = 0; c < vd->vdev_children; c++)
                if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
                    NULL)
                        return (mvd);

diff --git a/module/zfs/metaslab.c b/module/zfs/metaslab.c
index 87727fac2dbed5df46f3ed3e998137dd1923e484..9a4b436651cdc845e1298ff883234a471d1b4573 100644 (file)
--- a/module/zfs/metaslab.c
+++ b/module/zfs/metaslab.c
@@ -963,7 +963,7 @@ metaslab_alloc(spa_t *spa, metaslab_class_t *mc, uint64_t psize, blkptr_t *bp,
 {
        dva_t *dva = bp->blk_dva;
        dva_t *hintdva = hintbp->blk_dva;
-       int error = 0;
+       int d, error = 0;
 
        ASSERT(bp->blk_birth == 0);
 
@@ -978,7 +978,7 @@ metaslab_alloc(spa_t *spa, metaslab_class_t *mc, uint64_t psize, blkptr_t *bp,
        ASSERT(BP_GET_NDVAS(bp) == 0);
        ASSERT(hintbp == NULL || ndvas <= BP_GET_NDVAS(hintbp));
 
-       for (int d = 0; d < ndvas; d++) {
+       for (d = 0; d < ndvas; d++) {
                error = metaslab_alloc_dva(spa, mc, psize, dva, d, hintdva,
                    txg, flags);
                if (error) {
@@ -1004,14 +1004,14 @@ void
 metaslab_free(spa_t *spa, const blkptr_t *bp, uint64_t txg, boolean_t now)
 {
        const dva_t *dva = bp->blk_dva;
-       int ndvas = BP_GET_NDVAS(bp);
+       int d, ndvas = BP_GET_NDVAS(bp);
 
        ASSERT(!BP_IS_HOLE(bp));
        ASSERT(!now || bp->blk_birth >= spa->spa_syncing_txg);
 
        spa_config_enter(spa, SCL_FREE, FTAG, RW_READER);
 
-       for (int d = 0; d < ndvas; d++)
+       for (d = 0; d < ndvas; d++)
                metaslab_free_dva(spa, &dva[d], txg, now);
 
        spa_config_exit(spa, SCL_FREE, FTAG);
@@ -1022,7 +1022,7 @@ metaslab_claim(spa_t *spa, const blkptr_t *bp, uint64_t txg)
 {
        const dva_t *dva = bp->blk_dva;
        int ndvas = BP_GET_NDVAS(bp);
-       int error = 0;
+       int d, error = 0;
 
        ASSERT(!BP_IS_HOLE(bp));
 
@@ -1037,7 +1037,7 @@ metaslab_claim(spa_t *spa, const blkptr_t *bp, uint64_t txg)
 
        spa_config_enter(spa, SCL_ALLOC, FTAG, RW_READER);
 
-       for (int d = 0; d < ndvas; d++)
+       for (d = 0; d < ndvas; d++)
                if ((error = metaslab_claim_dva(spa, &dva[d], txg)) != 0)
                        break;
 

diff --git a/module/zfs/spa_misc.c b/module/zfs/spa_misc.c
index 36046e6df1c04e640d887e7b45acb0552966708c..ff2cf0a455e643444c13ecac6c7740048c8fe257 100644 (file)
--- a/module/zfs/spa_misc.c
+++ b/module/zfs/spa_misc.c
@@ -255,7 +255,9 @@ int zfs_recover = 0;
 static void
 spa_config_lock_init(spa_t *spa)
 {
-       for (int i = 0; i < SCL_LOCKS; i++) {
+       int i;
+
+       for (i = 0; i < SCL_LOCKS; i++) {
                spa_config_lock_t *scl = &spa->spa_config_lock[i];
                mutex_init(&scl->scl_lock, NULL, MUTEX_DEFAULT, NULL);
                cv_init(&scl->scl_cv, NULL, CV_DEFAULT, NULL);
@@ -268,7 +270,9 @@ spa_config_lock_init(spa_t *spa)
 static void
 spa_config_lock_destroy(spa_t *spa)
 {
-       for (int i = 0; i < SCL_LOCKS; i++) {
+       int i;
+
+       for (i = 0; i < SCL_LOCKS; i++) {
                spa_config_lock_t *scl = &spa->spa_config_lock[i];
                mutex_destroy(&scl->scl_lock);
                cv_destroy(&scl->scl_cv);
@@ -281,7 +285,9 @@ spa_config_lock_destroy(spa_t *spa)
 int
 spa_config_tryenter(spa_t *spa, int locks, void *tag, krw_t rw)
 {
-       for (int i = 0; i < SCL_LOCKS; i++) {
+       int i;
+
+       for (i = 0; i < SCL_LOCKS; i++) {
                spa_config_lock_t *scl = &spa->spa_config_lock[i];
                if (!(locks & (1 << i)))
                        continue;
@@ -310,7 +316,9 @@ spa_config_tryenter(spa_t *spa, int locks, void *tag, krw_t rw)
 void
 spa_config_enter(spa_t *spa, int locks, void *tag, krw_t rw)
 {
-       for (int i = 0; i < SCL_LOCKS; i++) {
+       int i;
+
+       for (i = 0; i < SCL_LOCKS; i++) {
                spa_config_lock_t *scl = &spa->spa_config_lock[i];
                if (!(locks & (1 << i)))
                        continue;
@@ -336,7 +344,9 @@ spa_config_enter(spa_t *spa, int locks, void *tag, krw_t rw)
 void
 spa_config_exit(spa_t *spa, int locks, void *tag)
 {
-       for (int i = SCL_LOCKS - 1; i >= 0; i--) {
+       int i;
+
+       for (i = SCL_LOCKS - 1; i >= 0; i--) {
                spa_config_lock_t *scl = &spa->spa_config_lock[i];
                if (!(locks & (1 << i)))
                        continue;
@@ -355,9 +365,9 @@ spa_config_exit(spa_t *spa, int locks, void *tag)
 int
 spa_config_held(spa_t *spa, int locks, krw_t rw)
 {
-       int locks_held = 0;
+       int i, locks_held = 0;
 
-       for (int i = 0; i < SCL_LOCKS; i++) {
+       for (i = 0; i < SCL_LOCKS; i++) {
                spa_config_lock_t *scl = &spa->spa_config_lock[i];
                if (!(locks & (1 << i)))
                        continue;

diff --git a/module/zfs/vdev.c b/module/zfs/vdev.c
index 16a27e514a41b6d1a0e29bceda2dc60d378914de..8b228dac9276c3cdae900805920e6e2470def67b 100644 (file)
--- a/module/zfs/vdev.c
+++ b/module/zfs/vdev.c
@@ -866,6 +866,7 @@ vdev_probe(vdev_t *vd, zio_t *pio)
        spa_t *spa = vd->vdev_spa;
        vdev_probe_stats_t *vps;
        zio_t *zio;
+       int l;
 
        vps = kmem_zalloc(sizeof (*vps), KM_SLEEP);
 
@@ -898,7 +899,7 @@ vdev_probe(vdev_t *vd, zio_t *pio)
        vps->vps_root = zio;
        vps->vps_vd = vd;
 
-       for (int l = 1; l < VDEV_LABELS; l++) {
+       for (l = 1; l < VDEV_LABELS; l++) {
                zio_nowait(zio_read_phys(zio, vd,
                    vdev_label_offset(vd->vdev_psize, l,
                    offsetof(vdev_label_t, vl_pad)),
@@ -1793,6 +1794,7 @@ void
 vdev_clear(spa_t *spa, vdev_t *vd)
 {
        vdev_t *rvd = spa->spa_root_vdev;
+       int c;
 
        ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
 
@@ -1803,7 +1805,7 @@ vdev_clear(spa_t *spa, vdev_t *vd)
        vd->vdev_stat.vs_write_errors = 0;
        vd->vdev_stat.vs_checksum_errors = 0;
 
-       for (int c = 0; c < vd->vdev_children; c++)
+       for (c = 0; c < vd->vdev_children; c++)
                vdev_clear(spa, vd->vdev_child[c]);
 
        /*
@@ -1886,6 +1888,7 @@ void
 vdev_get_stats(vdev_t *vd, vdev_stat_t *vs)
 {
        vdev_t *rvd = vd->vdev_spa->spa_root_vdev;
+       int c, t;
 
        mutex_enter(&vd->vdev_stat_lock);
        bcopy(&vd->vdev_stat, vs, sizeof (*vs));
@@ -1900,12 +1903,12 @@ vdev_get_stats(vdev_t *vd, vdev_stat_t *vs)
         * over all top-level vdevs (i.e. the direct children of the root).
         */
        if (vd == rvd) {
-               for (int c = 0; c < rvd->vdev_children; c++) {
+               for (c = 0; c < rvd->vdev_children; c++) {
                        vdev_t *cvd = rvd->vdev_child[c];
                        vdev_stat_t *cvs = &cvd->vdev_stat;
 
                        mutex_enter(&vd->vdev_stat_lock);
-                       for (int t = 0; t < ZIO_TYPES; t++) {
+                       for (t = 0; t < ZIO_TYPES; t++) {
                                vs->vs_ops[t] += cvs->vs_ops[t];
                                vs->vs_bytes[t] += cvs->vs_bytes[t];
                        }

diff --git a/module/zfs/vdev_label.c b/module/zfs/vdev_label.c
index bf930466fbd64ba911ab8f7c394fd498f160b0b3..901658e58181cf6bf78ed0f893123bdc9bca2dda 100644 (file)
--- a/module/zfs/vdev_label.c
+++ b/module/zfs/vdev_label.c
@@ -335,7 +335,7 @@ vdev_label_read_config(vdev_t *vd)
        nvlist_t *config = NULL;
        vdev_phys_t *vp;
        zio_t *zio;
-       int flags =
+       int l, flags =
            ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE;
 
        ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
@@ -345,7 +345,7 @@ vdev_label_read_config(vdev_t *vd)
 
        vp = zio_buf_alloc(sizeof (vdev_phys_t));
 
-       for (int l = 0; l < VDEV_LABELS; l++) {
+       for (l = 0; l < VDEV_LABELS; l++) {
 
                zio = zio_root(spa, NULL, NULL, flags);
 
@@ -496,10 +496,11 @@ vdev_label_init(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason)
        int error;
        uint64_t spare_guid, l2cache_guid;
        int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
+       int c, l, n;
 
        ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
 
-       for (int c = 0; c < vd->vdev_children; c++)
+       for (c = 0; c < vd->vdev_children; c++)
                if ((error = vdev_label_init(vd->vdev_child[c],
                    crtxg, reason)) != 0)
                        return (error);
@@ -655,7 +656,7 @@ vdev_label_init(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason)
         */
        zio = zio_root(spa, NULL, NULL, flags);
 
-       for (int l = 0; l < VDEV_LABELS; l++) {
+       for (l = 0; l < VDEV_LABELS; l++) {
 
                vdev_label_write(zio, vd, l, vp,
                    offsetof(vdev_label_t, vl_vdev_phys),
@@ -665,7 +666,7 @@ vdev_label_init(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason)
                    offsetof(vdev_label_t, vl_boot_header),
                    sizeof (vdev_boot_header_t), NULL, NULL, flags);
 
-               for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
+               for (n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
                        vdev_label_write(zio, vd, l, ub,
                            VDEV_UBERBLOCK_OFFSET(vd, n),
                            VDEV_UBERBLOCK_SIZE(vd), NULL, NULL, flags);
@@ -756,6 +757,7 @@ vdev_uberblock_load(zio_t *zio, vdev_t *vd, uberblock_t *ubbest)
        vdev_t *rvd = spa->spa_root_vdev;
        int flags =
            ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE;
+       int c, l, n;
 
        if (vd == rvd) {
                ASSERT(zio == NULL);
@@ -766,12 +768,12 @@ vdev_uberblock_load(zio_t *zio, vdev_t *vd, uberblock_t *ubbest)
 
        ASSERT(zio != NULL);
 
-       for (int c = 0; c < vd->vdev_children; c++)
+       for (c = 0; c < vd->vdev_children; c++)
                vdev_uberblock_load(zio, vd->vdev_child[c], ubbest);
 
        if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
-               for (int l = 0; l < VDEV_LABELS; l++) {
-                       for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
+               for (l = 0; l < VDEV_LABELS; l++) {
+                       for (n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
                                vdev_label_read(zio, vd, l,
                                    zio_buf_alloc(VDEV_UBERBLOCK_SIZE(vd)),
                                    VDEV_UBERBLOCK_OFFSET(vd, n),
@@ -807,9 +809,9 @@ static void
 vdev_uberblock_sync(zio_t *zio, uberblock_t *ub, vdev_t *vd, int flags)
 {
        uberblock_t *ubbuf;
-       int n;
+       int c, l, n;
 
-       for (int c = 0; c < vd->vdev_children; c++)
+       for (c = 0; c < vd->vdev_children; c++)
                vdev_uberblock_sync(zio, ub, vd->vdev_child[c], flags);
 
        if (!vd->vdev_ops->vdev_op_leaf)
@@ -824,7 +826,7 @@ vdev_uberblock_sync(zio_t *zio, uberblock_t *ub, vdev_t *vd, int flags)
        bzero(ubbuf, VDEV_UBERBLOCK_SIZE(vd));
        *ubbuf = *ub;
 
-       for (int l = 0; l < VDEV_LABELS; l++)
+       for (l = 0; l < VDEV_LABELS; l++)
                vdev_label_write(zio, vd, l, ubbuf,
                    VDEV_UBERBLOCK_OFFSET(vd, n), VDEV_UBERBLOCK_SIZE(vd),
                    vdev_uberblock_sync_done, zio->io_private,
@@ -839,10 +841,11 @@ vdev_uberblock_sync_list(vdev_t **svd, int svdcount, uberblock_t *ub, int flags)
        spa_t *spa = svd[0]->vdev_spa;
        zio_t *zio;
        uint64_t good_writes = 0;
+       int v;
 
        zio = zio_root(spa, NULL, &good_writes, flags);
 
-       for (int v = 0; v < svdcount; v++)
+       for (v = 0; v < svdcount; v++)
                vdev_uberblock_sync(zio, ub, svd[v], flags);
 
        (void) zio_wait(zio);
@@ -854,7 +857,7 @@ vdev_uberblock_sync_list(vdev_t **svd, int svdcount, uberblock_t *ub, int flags)
         */
        zio = zio_root(spa, NULL, NULL, flags);
 
-       for (int v = 0; v < svdcount; v++)
+       for (v = 0; v < svdcount; v++)
                zio_flush(zio, svd[v]);
 
        (void) zio_wait(zio);
@@ -907,8 +910,9 @@ vdev_label_sync(zio_t *zio, vdev_t *vd, int l, uint64_t txg, int flags)
        vdev_phys_t *vp;
        char *buf;
        size_t buflen;
+       int c;
 
-       for (int c = 0; c < vd->vdev_children; c++)
+       for (c = 0; c < vd->vdev_children; c++)
                vdev_label_sync(zio, vd->vdev_child[c], l, txg, flags);
 
        if (!vd->vdev_ops->vdev_op_leaf)

diff --git a/module/zfs/vdev_mirror.c b/module/zfs/vdev_mirror.c
index c4629ff45087c1efd23e45ddb715a79d72daeaac..ed2c251f5c21041f53067632d14d7f86422411f2 100644 (file)
--- a/module/zfs/vdev_mirror.c
+++ b/module/zfs/vdev_mirror.c
@@ -313,9 +313,9 @@ vdev_mirror_io_start(zio_t *zio)
 static int
 vdev_mirror_worst_error(mirror_map_t *mm)
 {
-       int error[2] = { 0, 0 };
+       int c, error[2] = { 0, 0 };
 
-       for (int c = 0; c < mm->mm_children; c++) {
+       for (c = 0; c < mm->mm_children; c++) {
                mirror_child_t *mc = &mm->mm_child[c];
                int s = mc->mc_speculative;
                error[s] = zio_worst_error(error[s], mc->mc_error);

diff --git a/module/zfs/vdev_queue.c b/module/zfs/vdev_queue.c
index 46fca0e3b629f4730fed00840df3c001837f5514..3e5aab173ac965a82585d85c69a8247cd4232cc3 100644 (file)
--- a/module/zfs/vdev_queue.c
+++ b/module/zfs/vdev_queue.c
@@ -285,12 +285,13 @@ void
 vdev_queue_io_done(zio_t *zio)
 {
        vdev_queue_t *vq = &zio->io_vd->vdev_queue;
+       int i;
 
        mutex_enter(&vq->vq_lock);
 
        avl_remove(&vq->vq_pending_tree, zio);
 
-       for (int i = 0; i < zfs_vdev_ramp_rate; i++) {
+       for (i = 0; i < zfs_vdev_ramp_rate; i++) {
                zio_t *nio = vdev_queue_io_to_issue(vq, zfs_vdev_max_pending);
                if (nio == NULL)
                        break;

diff --git a/module/zfs/vdev_raidz.c b/module/zfs/vdev_raidz.c
index 69e314468ee47d94aea1e14c79507b87a0f292d9..5bc4781fb0d6836d0f3d7b052bbd49e23b96845a 100644 (file)
--- a/module/zfs/vdev_raidz.c
+++ b/module/zfs/vdev_raidz.c
@@ -775,9 +775,9 @@ static uint64_t raidz_corrected_pq;
 static int
 vdev_raidz_worst_error(raidz_map_t *rm)
 {
-       int error = 0;
+       int c, error = 0;
 
-       for (int c = 0; c < rm->rm_cols; c++)
+       for (c = 0; c < rm->rm_cols; c++)
                error = zio_worst_error(error, rm->rm_col[c].rc_error);
 
        return (error);

diff --git a/module/zfs/zio.c b/module/zfs/zio.c
index d347920ea6bb79a183df87a997da0b03220909d7..e44d2e56c1233f120849b4d687cbbbddec02154b 100644 (file)
--- a/module/zfs/zio.c
+++ b/module/zfs/zio.c
@@ -1045,13 +1045,14 @@ static void
 zio_reexecute(zio_t *pio)
 {
        zio_t *zio, *zio_next;
+       int c;
 
        pio->io_flags = pio->io_orig_flags;
        pio->io_stage = pio->io_orig_stage;
        pio->io_pipeline = pio->io_orig_pipeline;
        pio->io_reexecute = 0;
        pio->io_error = 0;
-       for (int c = 0; c < ZIO_CHILD_TYPES; c++)
+       for (c = 0; c < ZIO_CHILD_TYPES; c++)
                pio->io_child_error[c] = 0;
 
        if (IO_IS_ALLOCATING(pio)) {
@@ -1309,8 +1310,9 @@ static void
 zio_gang_node_free(zio_gang_node_t **gnpp)
 {
        zio_gang_node_t *gn = *gnpp;
+       int g;
 
-       for (int g = 0; g < SPA_GBH_NBLKPTRS; g++)
+       for (g = 0; g < SPA_GBH_NBLKPTRS; g++)
                ASSERT(gn->gn_child[g] == NULL);
 
        zio_buf_free(gn->gn_gbh, SPA_GANGBLOCKSIZE);
@@ -1322,11 +1324,12 @@ static void
 zio_gang_tree_free(zio_gang_node_t **gnpp)
 {
        zio_gang_node_t *gn = *gnpp;
+       int g;
 
        if (gn == NULL)
                return;
 
-       for (int g = 0; g < SPA_GBH_NBLKPTRS; g++)
+       for (g = 0; g < SPA_GBH_NBLKPTRS; g++)
                zio_gang_tree_free(&gn->gn_child[g]);
 
        zio_gang_node_free(gnpp);
@@ -1351,6 +1354,7 @@ zio_gang_tree_assemble_done(zio_t *zio)
        zio_t *lio = zio->io_logical;
        zio_gang_node_t *gn = zio->io_private;
        blkptr_t *bp = zio->io_bp;
+       int g;
 
        ASSERT(zio->io_parent == lio);
        ASSERT(zio->io_child == NULL);
@@ -1365,7 +1369,7 @@ zio_gang_tree_assemble_done(zio_t *zio)
        ASSERT(zio->io_size == SPA_GANGBLOCKSIZE);
        ASSERT(gn->gn_gbh->zg_tail.zbt_magic == ZBT_MAGIC);
 
-       for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
+       for (g = 0; g < SPA_GBH_NBLKPTRS; g++) {
                blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g];
                if (!BP_IS_GANG(gbp))
                        continue;
@@ -1378,6 +1382,7 @@ zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, void *data)
 {
        zio_t *lio = pio->io_logical;
        zio_t *zio;
+       int g;
 
        ASSERT(BP_IS_GANG(bp) == !!gn);
        ASSERT(BP_GET_CHECKSUM(bp) == BP_GET_CHECKSUM(lio->io_bp));
@@ -1392,7 +1397,7 @@ zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, void *data)
        if (gn != NULL) {
                ASSERT(gn->gn_gbh->zg_tail.zbt_magic == ZBT_MAGIC);
 
-               for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
+               for (g = 0; g < SPA_GBH_NBLKPTRS; g++) {
                        blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g];
                        if (BP_IS_HOLE(gbp))
                                continue;
@@ -1449,6 +1454,7 @@ zio_write_gang_member_ready(zio_t *zio)
        dva_t *cdva = zio->io_bp->blk_dva;
        dva_t *pdva = pio->io_bp->blk_dva;
        uint64_t asize;
+       int d;
 
        if (BP_IS_HOLE(zio->io_bp))
                return;
@@ -1462,7 +1468,7 @@ zio_write_gang_member_ready(zio_t *zio)
        ASSERT3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp));
 
        mutex_enter(&pio->io_lock);
-       for (int d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) {
+       for (d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) {
                ASSERT(DVA_GET_GANG(&pdva[d]));
                asize = DVA_GET_ASIZE(&pdva[d]);
                asize += DVA_GET_ASIZE(&cdva[d]);
@@ -1486,7 +1492,7 @@ zio_write_gang_block(zio_t *pio)
        int ndvas = lio->io_prop.zp_ndvas;
        int gbh_ndvas = MIN(ndvas + 1, spa_max_replication(spa));
        zio_prop_t zp;
-       int error;
+       int g, error;
 
        error = metaslab_alloc(spa, spa->spa_normal_class, SPA_GANGBLOCKSIZE,
            bp, gbh_ndvas, txg, pio == lio ? NULL : lio->io_bp,
@@ -1516,7 +1522,7 @@ zio_write_gang_block(zio_t *pio)
        /*
         * Create and nowait the gang children.
         */
-       for (int g = 0; resid != 0; resid -= lsize, g++) {
+       for (g = 0; resid != 0; resid -= lsize, g++) {
                lsize = P2ROUNDUP(resid / (SPA_GBH_NBLKPTRS - g),
                    SPA_MINBLOCKSIZE);
                ASSERT(lsize >= SPA_MINBLOCKSIZE && lsize <= resid);
@@ -1606,6 +1612,7 @@ zio_dva_unallocate(zio_t *zio, zio_gang_node_t *gn, blkptr_t *bp)
 {
        spa_t *spa = zio->io_spa;
        boolean_t now = !(zio->io_flags & ZIO_FLAG_IO_REWRITE);
+       int g;
 
        ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp));
 
@@ -1636,7 +1643,7 @@ zio_dva_unallocate(zio_t *zio, zio_gang_node_t *gn, blkptr_t *bp)
                metaslab_free(spa, bp, bp->blk_birth, now);
 
        if (gn != NULL) {
-               for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
+               for (g = 0; g < SPA_GBH_NBLKPTRS; g++) {
                        zio_dva_unallocate(zio, gn->gn_child[g],
                            &gn->gn_gbh->zg_blkptr[g]);
                }
@@ -2080,6 +2087,7 @@ zio_done(zio_t *zio)
        blkptr_t *bp = zio->io_bp;
        vdev_t *vd = zio->io_vd;
        uint64_t psize = zio->io_size;
+       int c, w;
 
        /*
         * If our of children haven't all completed,
@@ -2090,8 +2098,8 @@ zio_done(zio_t *zio)
            zio_wait_for_children(zio, ZIO_CHILD_LOGICAL, ZIO_WAIT_DONE))
                return (ZIO_PIPELINE_STOP);
 
-       for (int c = 0; c < ZIO_CHILD_TYPES; c++)
-               for (int w = 0; w < ZIO_WAIT_TYPES; w++)
+       for (c = 0; c < ZIO_CHILD_TYPES; c++)
+               for (w = 0; w < ZIO_WAIT_TYPES; w++)
                        ASSERT(zio->io_children[c][w] == 0);
 
        if (bp != NULL) {