Commit 32cc0199 authored by Shuhei Matsumoto's avatar Shuhei Matsumoto Committed by Jim Harris
Browse files

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



Change-Id: I1023a509f938fcbe6ac0c35dca5192c36990de91
Signed-off-by: default avatarShuhei 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: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarKunal Sablok <kunal.sablok@intel.com>
Reviewed-by: default avatarChangpeng Liu <changpeng.liu@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
parent 8cdff7ed

lib/bdev/raid/bdev_raid.c

+57 −57
Original line number Diff line number Diff line
@@ -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

lib/bdev/raid/bdev_raid_rpc.c

+29 −29
Original line number Diff line number Diff line
@@ -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);

		}

test/unit/lib/bdev/bdev_raid.c/bdev_raid_ut.c

+74 −74

File changed.

Preview size limit exceeded, changes collapsed.