diff --git a/lib/bdev/raid/bdev_raid.c b/lib/bdev/raid/bdev_raid.c index ffd9a614b..abc4710d6 100644 --- a/lib/bdev/raid/bdev_raid.c +++ b/lib/bdev/raid/bdev_raid.c @@ -100,17 +100,17 @@ raid_bdev_create_cb(void *io_device, void *ctx_buf) SPDK_ERRLOG("Unable to allocate base bdevs io channel\n"); return -1; } - for (uint32_t iter = 0; iter < ch->raid_bdev_ctxt->raid_bdev.num_base_bdevs; iter++) { + for (uint32_t i = 0; i < ch->raid_bdev_ctxt->raid_bdev.num_base_bdevs; i++) { /* * Get the spdk_io_channel for all the base bdevs. This is used during * split logic to send the respective child bdev ios to respective base * bdev io channel. */ - ch->base_bdevs_io_channel[iter] = spdk_bdev_get_io_channel( - raid_bdev->base_bdev_info[iter].base_bdev_desc); - if (!ch->base_bdevs_io_channel[iter]) { - for (uint32_t iter1 = 0; iter1 < iter ; iter1++) { - spdk_put_io_channel(ch->base_bdevs_io_channel[iter1]); + ch->base_bdevs_io_channel[i] = spdk_bdev_get_io_channel( + raid_bdev->base_bdev_info[i].base_bdev_desc); + if (!ch->base_bdevs_io_channel[i]) { + for (uint32_t j = 0; j < i; j++) { + spdk_put_io_channel(ch->base_bdevs_io_channel[j]); } free(ch->base_bdevs_io_channel); SPDK_ERRLOG("Unable to create io channel for base bdev\n"); @@ -142,11 +142,11 @@ raid_bdev_destroy_cb(void *io_device, void *ctx_buf) assert(raid_bdev != NULL); assert(ch != NULL); assert(ch->base_bdevs_io_channel); - for (uint32_t iter = 0; iter < raid_bdev->num_base_bdevs; iter++) { + for (uint32_t i = 0; i < raid_bdev->num_base_bdevs; i++) { /* Free base bdev channels */ - assert(ch->base_bdevs_io_channel[iter] != NULL); - spdk_put_io_channel(ch->base_bdevs_io_channel[iter]); - ch->base_bdevs_io_channel[iter] = NULL; + assert(ch->base_bdevs_io_channel[i] != NULL); + spdk_put_io_channel(ch->base_bdevs_io_channel[i]); + ch->base_bdevs_io_channel[i] = NULL; } ch->raid_bdev_ctxt = NULL; free(ch->base_bdevs_io_channel); @@ -208,17 +208,17 @@ raid_bdev_destruct(void *ctxt) SPDK_DEBUGLOG(SPDK_LOG_BDEV_RAID, "raid_bdev_destruct\n"); raid_bdev->destruct_called = true; - for (uint16_t iter = 0; iter < raid_bdev->num_base_bdevs; iter++) { + for (uint16_t i = 0; i < raid_bdev->num_base_bdevs; i++) { /* * Close all base bdev descriptors for which call has come from below * layers */ - if ((raid_bdev->base_bdev_info[iter].base_bdev_remove_scheduled == true) && - (raid_bdev->base_bdev_info[iter].base_bdev != NULL)) { - spdk_bdev_module_release_bdev(raid_bdev->base_bdev_info[iter].base_bdev); - spdk_bdev_close(raid_bdev->base_bdev_info[iter].base_bdev_desc); - raid_bdev->base_bdev_info[iter].base_bdev_desc = NULL; - raid_bdev->base_bdev_info[iter].base_bdev = NULL; + if ((raid_bdev->base_bdev_info[i].base_bdev_remove_scheduled == true) && + (raid_bdev->base_bdev_info[i].base_bdev != NULL)) { + spdk_bdev_module_release_bdev(raid_bdev->base_bdev_info[i].base_bdev); + spdk_bdev_close(raid_bdev->base_bdev_info[i].base_bdev_desc); + raid_bdev->base_bdev_info[i].base_bdev_desc = NULL; + raid_bdev->base_bdev_info[i].base_bdev = NULL; assert(raid_bdev->num_base_bdevs_discovered); raid_bdev->num_base_bdevs_discovered--; } @@ -747,9 +747,9 @@ raid_bdev_dump_info_json(void *ctx, struct spdk_json_write_ctx *w) spdk_json_write_named_uint32(w, "num_base_bdevs_discovered", raid_bdev->num_base_bdevs_discovered); spdk_json_write_name(w, "base_bdevs_list"); spdk_json_write_array_begin(w); - for (uint16_t iter = 0; iter < raid_bdev->num_base_bdevs; iter++) { - if (raid_bdev->base_bdev_info[iter].base_bdev) { - spdk_json_write_string(w, raid_bdev->base_bdev_info[iter].base_bdev->name); + for (uint16_t i = 0; i < raid_bdev->num_base_bdevs; i++) { + if (raid_bdev->base_bdev_info[i].base_bdev) { + spdk_json_write_string(w, raid_bdev->base_bdev_info[i].base_bdev->name); } else { spdk_json_write_null(w); } @@ -784,9 +784,9 @@ raid_bdev_free(void) SPDK_DEBUGLOG(SPDK_LOG_BDEV_RAID, "raid_bdev_free\n"); for (uint32_t raid_bdev = 0; raid_bdev < g_spdk_raid_config.total_raid_bdev; raid_bdev++) { if (g_spdk_raid_config.raid_bdev_config[raid_bdev].base_bdev) { - for (uint32_t iter = 0; iter < g_spdk_raid_config.raid_bdev_config[raid_bdev].num_base_bdevs; - iter++) { - free(g_spdk_raid_config.raid_bdev_config[raid_bdev].base_bdev[iter].bdev_name); + for (uint32_t i = 0; i < g_spdk_raid_config.raid_bdev_config[raid_bdev].num_base_bdevs; + i++) { + free(g_spdk_raid_config.raid_bdev_config[raid_bdev].base_bdev[i].bdev_name); } free(g_spdk_raid_config.raid_bdev_config[raid_bdev].base_bdev); g_spdk_raid_config.raid_bdev_config[raid_bdev].base_bdev = NULL; @@ -836,7 +836,7 @@ raid_bdev_parse_raid(struct spdk_conf_section *conf_section) int num_base_bdevs; int raid_level; const char *base_bdev_name; - uint32_t iter; + uint32_t i; void *temp_ptr; struct raid_bdev_config *raid_bdev_config; @@ -864,8 +864,8 @@ raid_bdev_parse_raid(struct spdk_conf_section *conf_section) SPDK_DEBUGLOG(SPDK_LOG_BDEV_RAID, "%s %d %d %d\n", raid_name, strip_size, num_base_bdevs, raid_level); - for (iter = 0; iter < g_spdk_raid_config.total_raid_bdev; iter++) { - if (!strcmp(g_spdk_raid_config.raid_bdev_config[iter].name, raid_name)) { + for (i = 0; i < g_spdk_raid_config.total_raid_bdev; i++) { + if (!strcmp(g_spdk_raid_config.raid_bdev_config[i].name, raid_name)) { SPDK_ERRLOG("Duplicate raid bdev name found in config file %s\n", raid_name); return -1; } @@ -895,20 +895,20 @@ raid_bdev_parse_raid(struct spdk_conf_section *conf_section) return -1; } - for (iter = 0; true; iter++) { - base_bdev_name = spdk_conf_section_get_nmval(conf_section, "Devices", 0, iter); + for (i = 0; true; i++) { + base_bdev_name = spdk_conf_section_get_nmval(conf_section, "Devices", 0, i); if (base_bdev_name == NULL) { break; } - if (iter >= raid_bdev_config->num_base_bdevs) { + if (i >= raid_bdev_config->num_base_bdevs) { SPDK_ERRLOG("Number of devices mentioned is more than count\n"); return -1; } - for (uint32_t iter2 = 0; iter2 < g_spdk_raid_config.total_raid_bdev; iter2++) { - for (uint32_t iter3 = 0; iter3 < g_spdk_raid_config.raid_bdev_config[iter2].num_base_bdevs; - iter3++) { - if (g_spdk_raid_config.raid_bdev_config[iter2].base_bdev[iter3].bdev_name != NULL) { - if (!strcmp(g_spdk_raid_config.raid_bdev_config[iter2].base_bdev[iter3].bdev_name, + for (uint32_t j = 0; j < g_spdk_raid_config.total_raid_bdev; j++) { + for (uint32_t k = 0; k < g_spdk_raid_config.raid_bdev_config[j].num_base_bdevs; + k++) { + if (g_spdk_raid_config.raid_bdev_config[j].base_bdev[k].bdev_name != NULL) { + if (!strcmp(g_spdk_raid_config.raid_bdev_config[j].base_bdev[k].bdev_name, base_bdev_name)) { SPDK_ERRLOG("duplicate base bdev name %s mentioned\n", base_bdev_name); return -1; @@ -916,10 +916,10 @@ raid_bdev_parse_raid(struct spdk_conf_section *conf_section) } } } - raid_bdev_config->base_bdev[iter].bdev_name = strdup(base_bdev_name); + raid_bdev_config->base_bdev[i].bdev_name = strdup(base_bdev_name); } - if (iter != raid_bdev_config->num_base_bdevs) { + if (i != raid_bdev_config->num_base_bdevs) { SPDK_ERRLOG("Number of devices mentioned is less than count\n"); return -1; } @@ -1007,17 +1007,17 @@ raid_bdev_can_claim_bdev(const char *bdev_name, struct raid_bdev_config **raid_b { bool rv = false; - for (uint32_t iter1 = 0; iter1 < g_spdk_raid_config.total_raid_bdev && !rv; iter1++) { - for (uint32_t iter2 = 0; iter2 < g_spdk_raid_config.raid_bdev_config[iter1].num_base_bdevs; - iter2++) { + for (uint32_t i = 0; i < g_spdk_raid_config.total_raid_bdev && !rv; i++) { + for (uint32_t j = 0; j < g_spdk_raid_config.raid_bdev_config[i].num_base_bdevs; + j++) { /* * Check if the base bdev name is part of raid bdev configuration. * If match is found then return true and the slot information where * this base bdev should be inserted in raid bdev */ - if (!strcmp(bdev_name, g_spdk_raid_config.raid_bdev_config[iter1].base_bdev[iter2].bdev_name)) { - *raid_bdev_config = &g_spdk_raid_config.raid_bdev_config[iter1]; - *base_bdev_slot = iter2; + if (!strcmp(bdev_name, g_spdk_raid_config.raid_bdev_config[i].base_bdev[j].bdev_name)) { + *raid_bdev_config = &g_spdk_raid_config.raid_bdev_config[i]; + *base_bdev_slot = j; rv = true; break; } @@ -1090,15 +1090,15 @@ raid_bdev_remove_base_bdev(void *ctx) struct raid_bdev *raid_bdev; struct raid_bdev *next_raid_bdev; struct raid_bdev_ctxt *raid_bdev_ctxt; - uint16_t iter; + uint16_t i; bool found = false; SPDK_DEBUGLOG(SPDK_LOG_BDEV_RAID, "raid_bdev_remove_base_bdev\n"); /* Find the raid_bdev which has claimed this base_bdev */ TAILQ_FOREACH_SAFE(raid_bdev, &g_spdk_raid_bdev_list, link_global_list, next_raid_bdev) { - for (iter = 0; iter < raid_bdev->num_base_bdevs; iter++) { - if (raid_bdev->base_bdev_info[iter].base_bdev == base_bdev) { + for (i = 0; i < raid_bdev->num_base_bdevs; i++) { + if (raid_bdev->base_bdev_info[i].base_bdev == base_bdev) { found = true; break; } @@ -1114,17 +1114,17 @@ raid_bdev_remove_base_bdev(void *ctx) } assert(raid_bdev != NULL); - assert(raid_bdev->base_bdev_info[iter].base_bdev); - assert(raid_bdev->base_bdev_info[iter].base_bdev_desc); + assert(raid_bdev->base_bdev_info[i].base_bdev); + assert(raid_bdev->base_bdev_info[i].base_bdev_desc); raid_bdev_ctxt = SPDK_CONTAINEROF(raid_bdev, struct raid_bdev_ctxt, raid_bdev); - raid_bdev->base_bdev_info[iter].base_bdev_remove_scheduled = true; + raid_bdev->base_bdev_info[i].base_bdev_remove_scheduled = true; - if (raid_bdev->destruct_called == true && raid_bdev->base_bdev_info[iter].base_bdev != NULL) { + if (raid_bdev->destruct_called == true && raid_bdev->base_bdev_info[i].base_bdev != NULL) { /* As raid bdev is already unregistered, so cleanup should be done here itself */ - spdk_bdev_module_release_bdev(raid_bdev->base_bdev_info[iter].base_bdev); - spdk_bdev_close(raid_bdev->base_bdev_info[iter].base_bdev_desc); - raid_bdev->base_bdev_info[iter].base_bdev_desc = NULL; - raid_bdev->base_bdev_info[iter].base_bdev = NULL; + spdk_bdev_module_release_bdev(raid_bdev->base_bdev_info[i].base_bdev); + spdk_bdev_close(raid_bdev->base_bdev_info[i].base_bdev_desc); + raid_bdev->base_bdev_info[i].base_bdev_desc = NULL; + raid_bdev->base_bdev_info[i].base_bdev = NULL; assert(raid_bdev->num_base_bdevs_discovered); raid_bdev->num_base_bdevs_discovered--; if (raid_bdev->num_base_bdevs_discovered == 0) { @@ -1244,14 +1244,14 @@ raid_bdev_add_base_device(struct spdk_bdev *bdev) */ blocklen = raid_bdev->base_bdev_info[0].base_bdev->blocklen; min_blockcnt = raid_bdev->base_bdev_info[0].base_bdev->blockcnt; - for (uint32_t iter = 1; iter < raid_bdev->num_base_bdevs; iter++) { + for (uint32_t i = 1; i < raid_bdev->num_base_bdevs; i++) { /* Calculate minimum block count from all base bdevs */ - if (raid_bdev->base_bdev_info[iter].base_bdev->blockcnt < min_blockcnt) { - min_blockcnt = raid_bdev->base_bdev_info[iter].base_bdev->blockcnt; + if (raid_bdev->base_bdev_info[i].base_bdev->blockcnt < min_blockcnt) { + min_blockcnt = raid_bdev->base_bdev_info[i].base_bdev->blockcnt; } /* Check blocklen for all base bdevs that it should be same */ - if (blocklen != raid_bdev->base_bdev_info[iter].base_bdev->blocklen) { + if (blocklen != raid_bdev->base_bdev_info[i].base_bdev->blocklen) { /* * Assumption is that all the base bdevs for any raid bdev should * have same blocklen diff --git a/lib/bdev/raid/bdev_raid_rpc.c b/lib/bdev/raid/bdev_raid_rpc.c index 5c39ee0d0..10a48ab9f 100644 --- a/lib/bdev/raid/bdev_raid_rpc.c +++ b/lib/bdev/raid/bdev_raid_rpc.c @@ -301,14 +301,14 @@ check_and_remove_raid_bdev(struct raid_bdev_config *raid_bdev_config) */ assert(raid_bdev_ctxt->raid_bdev.state == RAID_BDEV_STATE_CONFIGURING); raid_bdev = &raid_bdev_ctxt->raid_bdev; - for (uint32_t iter = 0; iter < raid_bdev->num_base_bdevs; iter++) { + for (uint32_t i = 0; i < raid_bdev->num_base_bdevs; i++) { assert(raid_bdev->base_bdev_info != NULL); - if (raid_bdev->base_bdev_info[iter].base_bdev) { + if (raid_bdev->base_bdev_info[i].base_bdev) { /* Release base bdev related resources */ - spdk_bdev_module_release_bdev(raid_bdev->base_bdev_info[iter].base_bdev); - spdk_bdev_close(raid_bdev->base_bdev_info[iter].base_bdev_desc); - raid_bdev->base_bdev_info[iter].base_bdev_desc = NULL; - raid_bdev->base_bdev_info[iter].base_bdev = NULL; + spdk_bdev_module_release_bdev(raid_bdev->base_bdev_info[i].base_bdev); + spdk_bdev_close(raid_bdev->base_bdev_info[i].base_bdev_desc); + raid_bdev->base_bdev_info[i].base_bdev_desc = NULL; + raid_bdev->base_bdev_info[i].base_bdev = NULL; assert(raid_bdev->num_base_bdevs_discovered); raid_bdev->num_base_bdevs_discovered--; } @@ -390,9 +390,9 @@ spdk_rpc_construct_raid_bdev(struct spdk_jsonrpc_request *request, return; } g_spdk_raid_config.raid_bdev_config = temp_ptr; - for (size_t iter = 0; iter < g_spdk_raid_config.total_raid_bdev; iter++) { - g_spdk_raid_config.raid_bdev_config[iter].raid_bdev_ctxt->raid_bdev.raid_bdev_config = - &g_spdk_raid_config.raid_bdev_config[iter]; + for (size_t i = 0; i < g_spdk_raid_config.total_raid_bdev; i++) { + g_spdk_raid_config.raid_bdev_config[i].raid_bdev_ctxt->raid_bdev.raid_bdev_config = + &g_spdk_raid_config.raid_bdev_config[i]; } raid_bdev_config = &g_spdk_raid_config.raid_bdev_config[g_spdk_raid_config.total_raid_bdev]; memset(raid_bdev_config, 0, sizeof(*raid_bdev_config)); @@ -402,13 +402,13 @@ spdk_rpc_construct_raid_bdev(struct spdk_jsonrpc_request *request, raid_bdev_config->raid_level = req.raid_level; g_spdk_raid_config.total_raid_bdev++; raid_bdev_config->base_bdev = base_bdevs; - for (size_t iter = 0; iter < raid_bdev_config->num_base_bdevs; iter++) { - raid_bdev_config->base_bdev[iter].bdev_name = req.base_bdevs.base_bdevs[iter]; + for (size_t i = 0; i < raid_bdev_config->num_base_bdevs; i++) { + raid_bdev_config->base_bdev[i].bdev_name = req.base_bdevs.base_bdevs[i]; } - for (size_t iter = 0; iter < raid_bdev_config->num_base_bdevs; iter++) { + for (size_t i = 0; i < raid_bdev_config->num_base_bdevs; i++) { /* Check if base_bdev exists already, if not fail the command */ - base_bdev = spdk_bdev_get_by_name(req.base_bdevs.base_bdevs[iter]); + base_bdev = spdk_bdev_get_by_name(req.base_bdevs.base_bdevs[i]); if (base_bdev == NULL) { check_and_remove_raid_bdev(&g_spdk_raid_config.raid_bdev_config[g_spdk_raid_config.total_raid_bdev - 1]); @@ -513,7 +513,7 @@ static void raid_bdev_config_destroy(struct raid_bdev_config *raid_cfg) { void *temp_ptr; - uint8_t iter; + uint8_t i; struct raid_bdev_config *raid_cfg_next; uint8_t slot; @@ -528,25 +528,25 @@ raid_bdev_config_destroy(struct raid_bdev_config *raid_cfg) } /* Destroy raid bdev config and cleanup */ - for (uint8_t iter2 = 0; iter2 < raid_cfg->num_base_bdevs; iter2++) { - free(raid_cfg->base_bdev[iter2].bdev_name); + for (uint8_t j = 0; j < raid_cfg->num_base_bdevs; j++) { + free(raid_cfg->base_bdev[j].bdev_name); } free(raid_cfg->base_bdev); free(raid_cfg->name); slot = raid_cfg - g_spdk_raid_config.raid_bdev_config; assert(slot < g_spdk_raid_config.total_raid_bdev); if (slot != g_spdk_raid_config.total_raid_bdev - 1) { - iter = slot; - while (iter < g_spdk_raid_config.total_raid_bdev - 1) { - raid_cfg = &g_spdk_raid_config.raid_bdev_config[iter]; - raid_cfg_next = &g_spdk_raid_config.raid_bdev_config[iter + 1]; + i = slot; + while (i < g_spdk_raid_config.total_raid_bdev - 1) { + raid_cfg = &g_spdk_raid_config.raid_bdev_config[i]; + raid_cfg_next = &g_spdk_raid_config.raid_bdev_config[i + 1]; raid_cfg->base_bdev = raid_cfg_next->base_bdev; raid_cfg->raid_bdev_ctxt = raid_cfg_next->raid_bdev_ctxt; raid_cfg->name = raid_cfg_next->name; raid_cfg->strip_size = raid_cfg_next->strip_size; raid_cfg->num_base_bdevs = raid_cfg_next->num_base_bdevs; raid_cfg->raid_level = raid_cfg_next->raid_level; - iter++; + i++; } } temp_ptr = realloc(g_spdk_raid_config.raid_bdev_config, @@ -554,9 +554,9 @@ raid_bdev_config_destroy(struct raid_bdev_config *raid_cfg) if (temp_ptr != NULL) { g_spdk_raid_config.raid_bdev_config = temp_ptr; g_spdk_raid_config.total_raid_bdev--; - for (iter = 0; iter < g_spdk_raid_config.total_raid_bdev; iter++) { - g_spdk_raid_config.raid_bdev_config[iter].raid_bdev_ctxt->raid_bdev.raid_bdev_config = - &g_spdk_raid_config.raid_bdev_config[iter]; + for (i = 0; i < g_spdk_raid_config.total_raid_bdev; i++) { + g_spdk_raid_config.raid_bdev_config[i].raid_bdev_ctxt->raid_bdev.raid_bdev_config = + &g_spdk_raid_config.raid_bdev_config[i]; } } else { if (g_spdk_raid_config.total_raid_bdev == 1) { @@ -596,9 +596,9 @@ spdk_rpc_destroy_raid_bdev(struct spdk_jsonrpc_request *request, const struct sp } /* Find raid bdev config for this raid bdev */ - for (uint32_t iter = 0; iter < g_spdk_raid_config.total_raid_bdev; iter++) { - if (strcmp(g_spdk_raid_config.raid_bdev_config[iter].name, req.name) == 0) { - raid_bdev_config = &g_spdk_raid_config.raid_bdev_config[iter]; + for (uint32_t i = 0; i < g_spdk_raid_config.total_raid_bdev; i++) { + if (strcmp(g_spdk_raid_config.raid_bdev_config[i].name, req.name) == 0) { + raid_bdev_config = &g_spdk_raid_config.raid_bdev_config[i]; break; } } @@ -611,8 +611,8 @@ spdk_rpc_destroy_raid_bdev(struct spdk_jsonrpc_request *request, const struct sp } /* Remove all the base bdevs from this raid bdev before destroying the raid bdev */ - for (uint32_t iter = 0; iter < raid_bdev_config->num_base_bdevs; iter++) { - base_bdev = spdk_bdev_get_by_name(raid_bdev_config->base_bdev[iter].bdev_name); + for (uint32_t i = 0; i < raid_bdev_config->num_base_bdevs; i++) { + base_bdev = spdk_bdev_get_by_name(raid_bdev_config->base_bdev[i].bdev_name); if (base_bdev != NULL) { raid_bdev_remove_base_bdev(base_bdev); } diff --git a/test/unit/lib/bdev/bdev_raid.c/bdev_raid_ut.c b/test/unit/lib/bdev/bdev_raid.c/bdev_raid_ut.c index 489f4c2b9..a65186495 100644 --- a/test/unit/lib/bdev/bdev_raid.c/bdev_raid_ut.c +++ b/test/unit/lib/bdev/bdev_raid.c/bdev_raid_ut.c @@ -718,12 +718,12 @@ verify_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives, static void verify_raid_config_present(const char *name, bool presence) { - uint32_t iter; + uint32_t i; bool cfg_found; cfg_found = false; - for (iter = 0; iter < g_spdk_raid_config.total_raid_bdev; iter++) { - if (strcmp(name, g_spdk_raid_config.raid_bdev_config[iter].name) == 0) { + for (i = 0; i < g_spdk_raid_config.total_raid_bdev; i++) { + if (strcmp(name, g_spdk_raid_config.raid_bdev_config[i].name) == 0) { cfg_found = true; break; } @@ -761,12 +761,12 @@ static void verify_raid_config(struct rpc_construct_raid_bdev *r, bool presence) { struct raid_bdev_config *raid_cfg = NULL; - uint32_t iter, iter2; + uint32_t i, j; int val; - for (iter = 0; iter < g_spdk_raid_config.total_raid_bdev; iter++) { - if (strcmp(r->name, g_spdk_raid_config.raid_bdev_config[iter].name) == 0) { - raid_cfg = &g_spdk_raid_config.raid_bdev_config[iter]; + for (i = 0; i < g_spdk_raid_config.total_raid_bdev; i++) { + if (strcmp(r->name, g_spdk_raid_config.raid_bdev_config[i].name) == 0) { + raid_cfg = &g_spdk_raid_config.raid_bdev_config[i]; if (presence == false) { break; } @@ -774,8 +774,8 @@ verify_raid_config(struct rpc_construct_raid_bdev *r, bool presence) CU_ASSERT(raid_cfg->strip_size == r->strip_size); CU_ASSERT(raid_cfg->num_base_bdevs == r->base_bdevs.num_base_bdevs); CU_ASSERT(raid_cfg->raid_level == r->raid_level); - for (iter2 = 0; iter2 < raid_cfg->num_base_bdevs; iter2++) { - val = strcmp(raid_cfg->base_bdev[iter2].bdev_name, r->base_bdevs.base_bdevs[iter2]); + for (j = 0; j < raid_cfg->num_base_bdevs; j++) { + val = strcmp(raid_cfg->base_bdev[j].bdev_name, r->base_bdevs.base_bdevs[j]); CU_ASSERT(val == 0); } break; @@ -794,7 +794,7 @@ verify_raid_bdev(struct rpc_construct_raid_bdev *r, bool presence, uint32_t raid { struct raid_bdev_ctxt *pbdev_ctxt = NULL; struct raid_bdev *pbdev; - uint32_t iter; + uint32_t i; struct spdk_bdev *bdev = NULL; bool pbdev_found; uint64_t min_blockcnt = 0xFFFFFFFFFFFFFFFF; @@ -817,11 +817,11 @@ verify_raid_bdev(struct rpc_construct_raid_bdev *r, bool presence, uint32_t raid CU_ASSERT(pbdev->num_base_bdevs_discovered == r->base_bdevs.num_base_bdevs); CU_ASSERT(pbdev->raid_level == r->raid_level); CU_ASSERT(pbdev->destruct_called == false); - for (iter = 0; iter < pbdev->num_base_bdevs; iter++) { - if (pbdev->base_bdev_info && pbdev->base_bdev_info[iter].base_bdev) { - bdev = spdk_bdev_get_by_name(pbdev->base_bdev_info[iter].base_bdev->name); + for (i = 0; i < pbdev->num_base_bdevs; i++) { + if (pbdev->base_bdev_info && pbdev->base_bdev_info[i].base_bdev) { + bdev = spdk_bdev_get_by_name(pbdev->base_bdev_info[i].base_bdev->name); CU_ASSERT(bdev != NULL); - CU_ASSERT(pbdev->base_bdev_info[iter].base_bdev_remove_scheduled == false); + CU_ASSERT(pbdev->base_bdev_info[i].base_bdev_remove_scheduled == false); } else { CU_ASSERT(0); } @@ -922,15 +922,15 @@ verify_get_raids(struct rpc_construct_raid_bdev *construct_req, uint8_t g_max_raids, char **g_get_raids_output, uint32_t g_get_raids_count) { - uint32_t iter, iter2; + uint32_t i, j; bool found; CU_ASSERT(g_max_raids == g_get_raids_count); if (g_max_raids == g_get_raids_count) { - for (iter = 0; iter < g_max_raids; iter++) { + for (i = 0; i < g_max_raids; i++) { found = false; - for (iter2 = 0; iter2 < g_max_raids; iter2++) { - if (construct_req[iter].name && strcmp(construct_req[iter].name, g_get_raids_output[iter]) == 0) { + for (j = 0; j < g_max_raids; j++) { + if (construct_req[i].name && strcmp(construct_req[i].name, g_get_raids_output[i]) == 0) { found = true; break; } @@ -943,12 +943,12 @@ verify_get_raids(struct rpc_construct_raid_bdev *construct_req, static void create_base_bdevs(uint32_t bbdev_start_idx) { - uint32_t iter; + uint32_t i; struct spdk_bdev *base_bdev; char name[16]; uint16_t num_chars; - for (iter = 0; iter < g_max_base_drives; iter++, bbdev_start_idx++) { + for (i = 0; i < g_max_base_drives; i++, bbdev_start_idx++) { num_chars = snprintf(name, 16, "%s%u%s", "Nvme", bbdev_start_idx, "n1"); name[num_chars] = '\0'; base_bdev = calloc(1, sizeof(struct spdk_bdev)); @@ -965,7 +965,7 @@ static void create_test_req(struct rpc_construct_raid_bdev *r, const char *raid_name, uint32_t bbdev_start_idx, bool create_base_bdev) { - uint32_t iter; + uint32_t i; char name[16]; uint16_t num_chars; uint32_t bbdev_idx = bbdev_start_idx; @@ -975,11 +975,11 @@ create_test_req(struct rpc_construct_raid_bdev *r, const char *raid_name, uint32 r->strip_size = (g_strip_size * g_block_len) / 1024; r->raid_level = 0; r->base_bdevs.num_base_bdevs = g_max_base_drives; - for (iter = 0; iter < g_max_base_drives; iter++, bbdev_idx++) { + for (i = 0; i < g_max_base_drives; i++, bbdev_idx++) { num_chars = snprintf(name, 16, "%s%u%s", "Nvme", bbdev_idx, "n1"); name[num_chars] = '\0'; - r->base_bdevs.base_bdevs[iter] = strdup(name); - SPDK_CU_ASSERT_FATAL(r->base_bdevs.base_bdevs[iter] != NULL); + r->base_bdevs.base_bdevs[i] = strdup(name); + SPDK_CU_ASSERT_FATAL(r->base_bdevs.base_bdevs[i] != NULL); } if (create_base_bdev == true) { create_base_bdevs(bbdev_start_idx); @@ -989,11 +989,11 @@ create_test_req(struct rpc_construct_raid_bdev *r, const char *raid_name, uint32 static void free_test_req(struct rpc_construct_raid_bdev *r) { - uint8_t iter; + uint8_t i; free(r->name); - for (iter = 0; iter < r->base_bdevs.num_base_bdevs; iter++) { - free(r->base_bdevs.base_bdevs[iter]); + for (i = 0; i < r->base_bdevs.num_base_bdevs; i++) { + free(r->base_bdevs.base_bdevs[i]); } } @@ -1224,7 +1224,7 @@ test_io_channel(void) struct raid_bdev *pbdev; struct raid_bdev_ctxt *pbdev_ctxt = NULL; struct raid_bdev_io_channel *ch_ctx; - uint32_t iter; + uint32_t i; set_globals(); create_test_req(&req, "raid1", 0, true); @@ -1252,8 +1252,8 @@ test_io_channel(void) CU_ASSERT(raid_bdev_create_cb(&pbdev_ctxt->raid_bdev, ch_ctx) == 0); CU_ASSERT(ch_ctx->raid_bdev_ctxt == pbdev_ctxt); - for (iter = 0; iter < req.base_bdevs.num_base_bdevs; iter++) { - CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[iter] == (void *)0x1); + for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { + CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[i] == (void *)0x1); } raid_bdev_destroy_cb(&pbdev_ctxt->raid_bdev, ch_ctx); CU_ASSERT(ch_ctx->raid_bdev_ctxt == NULL); @@ -1283,7 +1283,7 @@ test_write_io(void) struct raid_bdev_ctxt *pbdev_ctxt = NULL; struct spdk_io_channel *ch; struct raid_bdev_io_channel *ch_ctx; - uint32_t iter; + uint32_t i; struct spdk_bdev_io *bdev_io; uint32_t count; uint64_t io_len; @@ -1315,8 +1315,8 @@ test_write_io(void) CU_ASSERT(raid_bdev_create_cb(&pbdev_ctxt->raid_bdev, ch_ctx) == 0); CU_ASSERT(ch_ctx->raid_bdev_ctxt == pbdev_ctxt); - for (iter = 0; iter < req.base_bdevs.num_base_bdevs; iter++) { - CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[iter] == (void *)0x1); + for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { + CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[i] == (void *)0x1); } lba = 0; @@ -1362,7 +1362,7 @@ test_read_io(void) struct raid_bdev_ctxt *pbdev_ctxt = NULL; struct spdk_io_channel *ch; struct raid_bdev_io_channel *ch_ctx; - uint32_t iter; + uint32_t i; struct spdk_bdev_io *bdev_io; uint32_t count; uint64_t io_len; @@ -1394,8 +1394,8 @@ test_read_io(void) CU_ASSERT(raid_bdev_create_cb(&pbdev_ctxt->raid_bdev, ch_ctx) == 0); CU_ASSERT(ch_ctx->raid_bdev_ctxt == pbdev_ctxt); - for (iter = 0; iter < req.base_bdevs.num_base_bdevs; iter++) { - CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[iter] == (void *)0x1); + for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { + CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[i] == (void *)0x1); } lba = 0; @@ -1442,7 +1442,7 @@ test_io_failure(void) struct raid_bdev_ctxt *pbdev_ctxt = NULL; struct spdk_io_channel *ch; struct raid_bdev_io_channel *ch_ctx; - uint32_t iter; + uint32_t i; struct spdk_bdev_io *bdev_io; uint32_t count; uint64_t io_len; @@ -1474,8 +1474,8 @@ test_io_failure(void) CU_ASSERT(raid_bdev_create_cb(&pbdev_ctxt->raid_bdev, ch_ctx) == 0); CU_ASSERT(ch_ctx->raid_bdev_ctxt == pbdev_ctxt); - for (iter = 0; iter < req.base_bdevs.num_base_bdevs; iter++) { - CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[iter] == (void *)0x1); + for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { + CU_ASSERT(ch_ctx->base_bdevs_io_channel && ch_ctx->base_bdevs_io_channel[i] == (void *)0x1); } lba = 0; @@ -1540,7 +1540,7 @@ test_io_waitq(void) struct raid_bdev_ctxt *pbdev_ctxt = NULL; struct spdk_io_channel *ch; struct raid_bdev_io_channel *ch_ctx; - uint32_t iter; + uint32_t i; struct spdk_bdev_io *bdev_io; struct spdk_bdev_io *bdev_io_next; uint32_t count; @@ -1575,8 +1575,8 @@ test_io_waitq(void) CU_ASSERT(raid_bdev_create_cb(&pbdev_ctxt->raid_bdev, ch_ctx) == 0); CU_ASSERT(ch_ctx->raid_bdev_ctxt == pbdev_ctxt); SPDK_CU_ASSERT_FATAL(ch_ctx->base_bdevs_io_channel != NULL); - for (iter = 0; iter < req.base_bdevs.num_base_bdevs; iter++) { - CU_ASSERT(ch_ctx->base_bdevs_io_channel[iter] == (void *)0x1); + for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { + CU_ASSERT(ch_ctx->base_bdevs_io_channel[i] == (void *)0x1); } lba = 0; @@ -1631,7 +1631,7 @@ test_multi_raid_no_io(void) struct rpc_construct_raid_bdev *construct_req; struct rpc_destroy_raid_bdev destroy_req; struct rpc_get_raid_bdevs get_raids_req; - uint32_t iter; + uint32_t i; char name[16]; uint32_t count; uint32_t bbdev_idx = 0; @@ -1640,20 +1640,20 @@ test_multi_raid_no_io(void) construct_req = calloc(MAX_RAIDS, sizeof(struct rpc_construct_raid_bdev)); SPDK_CU_ASSERT_FATAL(construct_req != NULL); CU_ASSERT(raid_bdev_init() == 0); - for (iter = 0; iter < g_max_raids; iter++) { - count = snprintf(name, 16, "%s%u", "raid", iter); + for (i = 0; i < g_max_raids; i++) { + count = snprintf(name, 16, "%s%u", "raid", i); name[count] = '\0'; - create_test_req(&construct_req[iter], name, bbdev_idx, true); + create_test_req(&construct_req[i], name, bbdev_idx, true); verify_raid_config_present(name, false); verify_raid_bdev_present(name, false); bbdev_idx += g_max_base_drives; - rpc_req = &construct_req[iter]; + rpc_req = &construct_req[i]; rpc_req_size = sizeof(construct_req[0]); g_rpc_err = 0; spdk_rpc_construct_raid_bdev(NULL, NULL); CU_ASSERT(g_rpc_err == 0); - verify_raid_config(&construct_req[iter], true); - verify_raid_bdev(&construct_req[iter], true, RAID_BDEV_STATE_ONLINE); + verify_raid_config(&construct_req[i], true); + verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE); } get_raids_req.category = strdup("all"); @@ -1664,8 +1664,8 @@ test_multi_raid_no_io(void) spdk_rpc_get_raid_bdevs(NULL, NULL); CU_ASSERT(g_rpc_err == 0); verify_get_raids(construct_req, g_max_raids, g_get_raids_output, g_get_raids_count); - for (iter = 0; iter < g_get_raids_count; iter++) { - free(g_get_raids_output[iter]); + for (i = 0; i < g_get_raids_count; i++) { + free(g_get_raids_output[i]); } g_get_raids_count = 0; @@ -1676,8 +1676,8 @@ test_multi_raid_no_io(void) spdk_rpc_get_raid_bdevs(NULL, NULL); CU_ASSERT(g_rpc_err == 0); verify_get_raids(construct_req, g_max_raids, g_get_raids_output, g_get_raids_count); - for (iter = 0; iter < g_get_raids_count; iter++) { - free(g_get_raids_output[iter]); + for (i = 0; i < g_get_raids_count; i++) { + free(g_get_raids_output[i]); } g_get_raids_count = 0; @@ -1726,9 +1726,9 @@ test_multi_raid_no_io(void) g_json_beg_res_ret_err = 0; CU_ASSERT(g_get_raids_count == 0); - for (iter = 0; iter < g_max_raids; iter++) { - SPDK_CU_ASSERT_FATAL(construct_req[iter].name != NULL); - destroy_req.name = strdup(construct_req[iter].name); + for (i = 0; i < g_max_raids; i++) { + SPDK_CU_ASSERT_FATAL(construct_req[i].name != NULL); + destroy_req.name = strdup(construct_req[i].name); count = snprintf(name, 16, "%s", destroy_req.name); name[count] = '\0'; rpc_req = &destroy_req; @@ -1752,7 +1752,7 @@ test_multi_raid_with_io(void) { struct rpc_construct_raid_bdev *construct_req; struct rpc_destroy_raid_bdev destroy_req; - uint32_t iter, iter2; + uint32_t i, j; char name[16]; uint32_t count; uint32_t bbdev_idx = 0; @@ -1774,34 +1774,34 @@ test_multi_raid_with_io(void) CU_ASSERT(raid_bdev_init() == 0); ch = calloc(g_max_raids, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel)); SPDK_CU_ASSERT_FATAL(ch != NULL); - for (iter = 0; iter < g_max_raids; iter++) { - count = snprintf(name, 16, "%s%u", "raid", iter); + for (i = 0; i < g_max_raids; i++) { + count = snprintf(name, 16, "%s%u", "raid", i); name[count] = '\0'; - create_test_req(&construct_req[iter], name, bbdev_idx, true); + create_test_req(&construct_req[i], name, bbdev_idx, true); verify_raid_config_present(name, false); verify_raid_bdev_present(name, false); bbdev_idx += g_max_base_drives; - rpc_req = &construct_req[iter]; + rpc_req = &construct_req[i]; rpc_req_size = sizeof(construct_req[0]); g_rpc_err = 0; spdk_rpc_construct_raid_bdev(NULL, NULL); CU_ASSERT(g_rpc_err == 0); - verify_raid_config(&construct_req[iter], true); - verify_raid_bdev(&construct_req[iter], true, RAID_BDEV_STATE_ONLINE); + verify_raid_config(&construct_req[i], true); + verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE); TAILQ_FOREACH(pbdev, &g_spdk_raid_bdev_list, link_global_list) { pbdev_ctxt = SPDK_CONTAINEROF(pbdev, struct raid_bdev_ctxt, raid_bdev); - if (strcmp(pbdev_ctxt->bdev.name, construct_req[iter].name) == 0) { + if (strcmp(pbdev_ctxt->bdev.name, construct_req[i].name) == 0) { break; } } CU_ASSERT(pbdev_ctxt != NULL); - ch_ctx = spdk_io_channel_get_ctx(&ch[iter]); + ch_ctx = spdk_io_channel_get_ctx(&ch[i]); SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); CU_ASSERT(raid_bdev_create_cb(&pbdev_ctxt->raid_bdev, ch_ctx) == 0); CU_ASSERT(ch_ctx->raid_bdev_ctxt == pbdev_ctxt); CU_ASSERT(ch_ctx->base_bdevs_io_channel != NULL); - for (iter2 = 0; iter2 < construct_req[iter].base_bdevs.num_base_bdevs; iter2++) { - CU_ASSERT(ch_ctx->base_bdevs_io_channel[iter2] == (void *)0x1); + for (j = 0; j < construct_req[i].base_bdevs.num_base_bdevs; j++) { + CU_ASSERT(ch_ctx->base_bdevs_io_channel[j] == (void *)0x1); } } @@ -1832,20 +1832,20 @@ test_multi_raid_with_io(void) free(bdev_io); } - for (iter = 0; iter < g_max_raids; iter++) { + for (i = 0; i < g_max_raids; i++) { TAILQ_FOREACH(pbdev, &g_spdk_raid_bdev_list, link_global_list) { pbdev_ctxt = SPDK_CONTAINEROF(pbdev, struct raid_bdev_ctxt, raid_bdev); - if (strcmp(pbdev_ctxt->bdev.name, construct_req[iter].name) == 0) { + if (strcmp(pbdev_ctxt->bdev.name, construct_req[i].name) == 0) { break; } } CU_ASSERT(pbdev_ctxt != NULL); - ch_ctx = spdk_io_channel_get_ctx(&ch[iter]); + ch_ctx = spdk_io_channel_get_ctx(&ch[i]); SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); raid_bdev_destroy_cb(&pbdev_ctxt->raid_bdev, ch_ctx); CU_ASSERT(ch_ctx->raid_bdev_ctxt == NULL); CU_ASSERT(ch_ctx->base_bdevs_io_channel == NULL); - destroy_req.name = strdup(construct_req[iter].name); + destroy_req.name = strdup(construct_req[i].name); count = snprintf(name, 16, "%s", destroy_req.name); name[count] = '\0'; rpc_req = &destroy_req; @@ -2048,7 +2048,7 @@ test_asym_base_drives_blockcnt(void) struct rpc_construct_raid_bdev construct_req; struct rpc_destroy_raid_bdev destroy_req; struct spdk_bdev *bbdev; - uint32_t iter; + uint32_t i; set_globals(); create_test_req(&construct_req, "raid1", 0, true); @@ -2058,8 +2058,8 @@ test_asym_base_drives_blockcnt(void) verify_raid_config_present(construct_req.name, false); verify_raid_bdev_present(construct_req.name, false); g_rpc_err = 0; - for (iter = 0; iter < construct_req.base_bdevs.num_base_bdevs; iter++) { - bbdev = spdk_bdev_get_by_name(construct_req.base_bdevs.base_bdevs[iter]); + for (i = 0; i < construct_req.base_bdevs.num_base_bdevs; i++) { + bbdev = spdk_bdev_get_by_name(construct_req.base_bdevs.base_bdevs[i]); SPDK_CU_ASSERT_FATAL(bbdev != NULL); bbdev->blockcnt = rand() + 1; }