ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bdev/raid: Use single character variables to index and loop iterator

Browse Source 
Change-Id: I1023a509f938fcbe6ac0c35dca5192c36990de91
Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-on: https://review.gerrithub.io/420216
Chandler-Test-Pool: SPDK Automated Test System <sys_sgsw@intel.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Kunal Sablok <kunal.sablok@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
This commit is contained in:
Shuhei Matsumoto 2018-07-23 15:03:28 +09:00 committed by Jim Harris
parent 8cdff7ed79
commit 32cc0199d1
3 changed files with 160 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
lib/bdev/raid/bdev_raid.c
View File

@ -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

58
lib/bdev/raid/bdev_raid_rpc.c
View File

@ -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);
}

148
test/unit/lib/bdev/bdev_raid.c/bdev_raid_ut.c
View File

@ -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;
}