module/raid: assemble raid bdev from superblock (8a6bb6a8) · Commits · Public Repositories / spdk

module/bdev/raid/bdev_raid.c

+353 −30

Original line number	Diff line number	Diff line
		@@ -220,6 +220,9 @@ raid_bdev_free_base_bdev_resource(struct raid_base_bdev_info *base_info)

		free(base_info->name);
		base_info->name = NULL;
		if (raid_bdev->state != RAID_BDEV_STATE_CONFIGURING) {
		spdk_uuid_set_null(&base_info->uuid);
		}

		if (base_info->desc == NULL) {
		return;
		@@ -917,7 +920,7 @@ static struct spdk_bdev_module g_raid_if = {
		.fini_start = raid_bdev_fini_start,
		.module_fini = raid_bdev_exit,
		.get_ctx_size = raid_bdev_get_ctx_size,
		.examine_config = raid_bdev_examine,
		.examine_disk = raid_bdev_examine,
		.async_init = false,
		.async_fini = false,
		};
		@@ -1263,7 +1266,29 @@ raid_bdev_configure(struct raid_bdev *raid_bdev)
		}

		if (raid_bdev->sb != NULL) {
		if (spdk_uuid_is_null(&raid_bdev->sb->uuid)) {
		/* NULL UUID is not valid in the sb so it means that we are creating a new
		* raid bdev and should initialize the superblock.
		*/
		raid_bdev_init_superblock(raid_bdev);
		} else {
		assert(spdk_uuid_compare(&raid_bdev->sb->uuid, &raid_bdev->bdev.uuid) == 0);
		if (raid_bdev->sb->block_size != blocklen) {
		SPDK_ERRLOG("blocklen does not match value in superblock\n");
		rc = -EINVAL;
		}
		if (raid_bdev->sb->raid_size != raid_bdev->bdev.blockcnt) {
		SPDK_ERRLOG("blockcnt does not match value in superblock\n");
		rc = -EINVAL;
		}
		if (rc != 0) {
		if (raid_bdev->module->stop != NULL) {
		raid_bdev->module->stop(raid_bdev);
		}
		return rc;
		}
		}

		raid_bdev_write_superblock(raid_bdev, raid_bdev_configure_write_sb_cb, NULL);
		} else {
		raid_bdev_configure_cont(raid_bdev);
		@@ -1595,12 +1620,45 @@ raid_bdev_configure_base_bdev(struct raid_base_bdev_info *base_info)
		struct raid_bdev *raid_bdev = base_info->raid_bdev;
		struct spdk_bdev_desc *desc;
		struct spdk_bdev *bdev;
		const struct spdk_uuid *bdev_uuid;
		int rc;

		assert(spdk_get_thread() == spdk_thread_get_app_thread());
		assert(base_info->name != NULL);
		assert(base_info->desc == NULL);

		/*
		* Base bdev can be added by name or uuid. Here we assure both properties are set and valid
		* before claiming the bdev.
		*/

		if (!spdk_uuid_is_null(&base_info->uuid)) {
		char uuid_str[SPDK_UUID_STRING_LEN];
		const char *bdev_name;

		spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &base_info->uuid);

		/* UUID of a bdev is registered as its alias */
		bdev = spdk_bdev_get_by_name(uuid_str);
		if (bdev == NULL) {
		return -ENODEV;
		}

		bdev_name = spdk_bdev_get_name(bdev);

		if (base_info->name == NULL) {
		base_info->name = strdup(bdev_name);
		if (base_info->name == NULL) {
		return -ENOMEM;
		}
		} else if (strcmp(base_info->name, bdev_name) != 0) {
		SPDK_ERRLOG("Name mismatch for base bdev '%s' - expected '%s'\n",
		bdev_name, base_info->name);
		return -EINVAL;
		}
		}

		assert(base_info->name != NULL);

		rc = spdk_bdev_open_ext(base_info->name, true, raid_bdev_event_base_bdev, NULL, &desc);
		if (rc != 0) {
		if (rc != -ENODEV) {
		@@ -1610,6 +1668,15 @@ raid_bdev_configure_base_bdev(struct raid_base_bdev_info *base_info)
		}

		bdev = spdk_bdev_desc_get_bdev(desc);
		bdev_uuid = spdk_bdev_get_uuid(bdev);

		if (spdk_uuid_is_null(&base_info->uuid)) {
		spdk_uuid_copy(&base_info->uuid, bdev_uuid);
		} else if (spdk_uuid_compare(&base_info->uuid, bdev_uuid) != 0) {
		SPDK_ERRLOG("UUID mismatch for base bdev '%s'\n", base_info->name);
		spdk_bdev_close(desc);
		return -EINVAL;
		}

		rc = spdk_bdev_module_claim_bdev(bdev, NULL, &g_raid_if);
		if (rc != 0) {
		@@ -1632,38 +1699,60 @@ raid_bdev_configure_base_bdev(struct raid_base_bdev_info *base_info)

		base_info->desc = desc;
		base_info->blockcnt = bdev->blockcnt;
		base_info->data_offset = 0;
		base_info->data_size = bdev->blockcnt;
		raid_bdev->num_base_bdevs_discovered++;
		assert(raid_bdev->num_base_bdevs_discovered <= raid_bdev->num_base_bdevs);

		if (raid_bdev->sb != NULL) {
		uint64_t data_offset;

		if (base_info->data_offset == 0) {
		assert((RAID_BDEV_MIN_DATA_OFFSET_SIZE % bdev->blocklen) == 0);
		base_info->data_offset = RAID_BDEV_MIN_DATA_OFFSET_SIZE / bdev->blocklen;
		data_offset = RAID_BDEV_MIN_DATA_OFFSET_SIZE / bdev->blocklen;
		} else {
		data_offset = base_info->data_offset;
		}

		if (bdev->optimal_io_boundary) {
		base_info->data_offset = spdk_divide_round_up(base_info->data_offset,
		if (bdev->optimal_io_boundary != 0) {
		data_offset = spdk_divide_round_up(data_offset,
		bdev->optimal_io_boundary) * bdev->optimal_io_boundary;
		if (base_info->data_offset != 0 && base_info->data_offset != data_offset) {
		SPDK_WARNLOG("Data offset %lu on bdev '%s' is different than optimal value %lu\n",
		base_info->data_offset, base_info->name, data_offset);
		data_offset = base_info->data_offset;
		}
		}

		base_info->data_offset = data_offset;
		}

		if (base_info->data_offset >= bdev->blockcnt) {
		SPDK_ERRLOG("Data offset %lu exceeds base bdev capacity %lu on bdev '%s'\n",
		base_info->data_offset, bdev->blockcnt, base_info->name);
		return -EINVAL;
		rc = -EINVAL;
		goto out;
		}

		if (base_info->data_size == 0) {
		base_info->data_size = bdev->blockcnt - base_info->data_offset;
		} else if (base_info->data_offset + base_info->data_size > bdev->blockcnt) {
		SPDK_ERRLOG("Data offset and size exceeds base bdev capacity %lu on bdev '%s'\n",
		bdev->blockcnt, base_info->name);
		rc = -EINVAL;
		goto out;
		}

		raid_bdev->num_base_bdevs_discovered++;
		assert(raid_bdev->num_base_bdevs_discovered <= raid_bdev->num_base_bdevs);

		if (raid_bdev->num_base_bdevs_discovered == raid_bdev->num_base_bdevs) {
		rc = raid_bdev_configure(raid_bdev);
		if (rc != 0) {
		SPDK_ERRLOG("Failed to configure raid bdev\n");
		return rc;
		SPDK_ERRLOG("Failed to configure raid bdev: %s\n", spdk_strerror(-rc));
		}
		}

		return 0;
		out:
		if (rc != 0) {
		raid_bdev_free_base_bdev_resource(base_info);
		}
		return rc;
		}

		/*
		@@ -1697,6 +1786,15 @@ raid_bdev_add_base_device(struct raid_bdev raid_bdev, const char name, uint8_t
		return -EBUSY;
		}

		if (!spdk_uuid_is_null(&base_info->uuid)) {
		char uuid_str[SPDK_UUID_STRING_LEN];

		spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &base_info->uuid);
		SPDK_ERRLOG("Slot %u on raid bdev '%s' already assigned to bdev with uuid %s\n",
		slot, raid_bdev->bdev.name, uuid_str);
		return -EBUSY;
		}

		base_info->name = strdup(name);
		if (base_info->name == NULL) {
		return -ENOMEM;
		@@ -1713,6 +1811,210 @@ raid_bdev_add_base_device(struct raid_bdev raid_bdev, const char name, uint8_t
		return 0;
		}

		static int
		raid_bdev_create_from_sb(const struct raid_bdev_superblock sb, struct raid_bdev *raid_bdev_out)
		{
		struct raid_bdev *raid_bdev;
		uint8_t i;
		int rc;

		rc = raid_bdev_create(sb->name, (sb->strip_size * sb->block_size) / 1024, sb->num_base_bdevs,
		sb->level, true, &sb->uuid, &raid_bdev);
		if (rc != 0) {
		return rc;
		}

		assert(sb->length <= RAID_BDEV_SB_MAX_LENGTH);
		memcpy(raid_bdev->sb, sb, sb->length);

		for (i = 0; i < sb->base_bdevs_size; i++) {
		const struct raid_bdev_sb_base_bdev *sb_base_bdev = &sb->base_bdevs[i];
		struct raid_base_bdev_info *base_info = &raid_bdev->base_bdev_info[sb_base_bdev->slot];

		if (sb_base_bdev->state == RAID_SB_BASE_BDEV_CONFIGURED) {
		spdk_uuid_copy(&base_info->uuid, &sb_base_bdev->uuid);
		}

		base_info->data_offset = sb_base_bdev->data_offset;
		base_info->data_size = sb_base_bdev->data_size;
		}

		*raid_bdev_out = raid_bdev;
		return 0;
		}

		static void
		raid_bdev_examine_no_sb(struct spdk_bdev *bdev)
		{
		struct raid_bdev *raid_bdev;
		struct raid_base_bdev_info *base_info;

		TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) {
		RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) {
		if (base_info->desc == NULL && base_info->name != NULL &&
		strcmp(bdev->name, base_info->name) == 0) {
		assert(raid_bdev->sb == NULL);
		raid_bdev_configure_base_bdev(base_info);
		break;
		}
		}
		}
		}

		static void
		raid_bdev_examine_sb(const struct raid_bdev_superblock sb, struct spdk_bdev bdev)
		{
		const struct raid_bdev_sb_base_bdev *sb_base_bdev;
		struct raid_bdev *raid_bdev;
		struct raid_base_bdev_info iter, base_info;
		uint8_t i;
		int rc;

		if (sb->block_size != bdev->blocklen) {
		SPDK_WARNLOG("Bdev %s block size (%u) does not match the value in superblock (%u)\n",
		bdev->name, sb->block_size, bdev->blocklen);
		return;
		}

		if (spdk_uuid_is_null(&sb->uuid)) {
		SPDK_WARNLOG("NULL raid bdev UUID in superblock on bdev %s\n", bdev->name);
		return;
		}

		TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) {
		if (spdk_uuid_compare(&raid_bdev->bdev.uuid, &sb->uuid) == 0) {
		break;
		}
		}

		if (raid_bdev) {
		if (sb->seq_number > raid_bdev->sb->seq_number) {
		SPDK_DEBUGLOG(bdev_raid,
		"raid superblock seq_number on bdev %s (%lu) greater than existing raid bdev %s (%lu)\n",
		bdev->name, sb->seq_number, raid_bdev->bdev.name, raid_bdev->sb->seq_number);

		if (raid_bdev->state != RAID_BDEV_STATE_CONFIGURING) {
		SPDK_WARNLOG("Newer version of raid bdev %s superblock found on bdev %s but raid bdev is not in configuring state.\n",
		raid_bdev->bdev.name, bdev->name);
		return;
		}

		/* remove and then recreate the raid bdev using the newer superblock */
		raid_bdev_delete(raid_bdev, NULL, NULL);
		raid_bdev = NULL;
		} else if (sb->seq_number < raid_bdev->sb->seq_number) {
		SPDK_DEBUGLOG(bdev_raid,
		"raid superblock seq_number on bdev %s (%lu) smaller than existing raid bdev %s (%lu)\n",
		bdev->name, sb->seq_number, raid_bdev->bdev.name, raid_bdev->sb->seq_number);
		/* use the current raid bdev superblock */
		sb = raid_bdev->sb;
		}
		}

		for (i = 0; i < sb->base_bdevs_size; i++) {
		sb_base_bdev = &sb->base_bdevs[i];

		assert(spdk_uuid_is_null(&sb_base_bdev->uuid) == false);

		if (spdk_uuid_compare(&sb_base_bdev->uuid, spdk_bdev_get_uuid(bdev)) == 0) {
		break;
		}
		}

		if (i == sb->base_bdevs_size) {
		SPDK_DEBUGLOG(bdev_raid, "raid superblock does not contain this bdev's uuid\n");
		return;
		}

		if (!raid_bdev) {
		rc = raid_bdev_create_from_sb(sb, &raid_bdev);
		if (rc != 0) {
		SPDK_ERRLOG("Failed to create raid bdev %s: %s\n",
		sb->name, spdk_strerror(-rc));
		}
		}

		if (sb_base_bdev->state != RAID_SB_BASE_BDEV_CONFIGURED) {
		SPDK_NOTICELOG("Bdev %s is not an active member of raid bdev %s. Ignoring.\n",
		bdev->name, raid_bdev->bdev.name);
		return;
		}

		base_info = NULL;
		RAID_FOR_EACH_BASE_BDEV(raid_bdev, iter) {
		if (spdk_uuid_compare(&iter->uuid, spdk_bdev_get_uuid(bdev)) == 0) {
		base_info = iter;
		break;
		}
		}

		if (base_info == NULL) {
		SPDK_ERRLOG("Bdev %s is not a member of raid bdev %s\n",
		bdev->name, raid_bdev->bdev.name);
		return;
		}

		rc = raid_bdev_configure_base_bdev(base_info);
		if (rc != 0) {
		SPDK_ERRLOG("Failed to configure bdev %s as base bdev of raid %s: %s\n",
		bdev->name, raid_bdev->bdev.name, spdk_strerror(-rc));
		}
		}

		struct raid_bdev_examine_ctx {
		struct spdk_bdev_desc *desc;
		struct spdk_io_channel *ch;
		};

		static void
		raid_bdev_examine_ctx_free(struct raid_bdev_examine_ctx *ctx)
		{
		if (!ctx) {
		return;
		}

		if (ctx->ch) {
		spdk_put_io_channel(ctx->ch);
		}

		if (ctx->desc) {
		spdk_bdev_close(ctx->desc);
		}

		free(ctx);
		}

		static void
		raid_bdev_examine_load_sb_cb(const struct raid_bdev_superblock sb, int status, void _ctx)
		{
		struct raid_bdev_examine_ctx *ctx = _ctx;
		struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(ctx->desc);

		switch (status) {
		case 0:
		/* valid superblock found */
		SPDK_DEBUGLOG(bdev_raid, "raid superblock found on bdev %s\n", bdev->name);
		raid_bdev_examine_sb(sb, bdev);
		break;
		case -EINVAL:
		/* no valid superblock, check if it can be claimed anyway */
		raid_bdev_examine_no_sb(bdev);
		break;
		default:
		SPDK_ERRLOG("Failed to examine bdev %s: %s\n",
		bdev->name, spdk_strerror(-status));
		break;
		}

		raid_bdev_examine_ctx_free(ctx);
		spdk_bdev_module_examine_done(&g_raid_if);
		}

		static void
		raid_bdev_examine_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev bdev, void event_ctx)
		{
		}

		/*
		* brief:
		* raid_bdev_examine function is the examine function call by the below layers
		@@ -1726,19 +2028,40 @@ raid_bdev_add_base_device(struct raid_bdev raid_bdev, const char name, uint8_t
		static void
		raid_bdev_examine(struct spdk_bdev *bdev)
		{
		struct raid_bdev *raid_bdev;
		struct raid_base_bdev_info *base_info;
		struct raid_bdev_examine_ctx *ctx;
		int rc;

		TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) {
		RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) {
		if (base_info->desc == NULL && base_info->name != NULL &&
		strcmp(bdev->name, base_info->name) == 0) {
		raid_bdev_configure_base_bdev(base_info);
		break;
		ctx = calloc(1, sizeof(*ctx));
		if (!ctx) {
		SPDK_ERRLOG("Failed to examine bdev %s: %s\n",
		bdev->name, spdk_strerror(ENOMEM));
		goto err;
		}

		rc = spdk_bdev_open_ext(spdk_bdev_get_name(bdev), false, raid_bdev_examine_event_cb, NULL,
		&ctx->desc);
		if (rc) {
		SPDK_ERRLOG("Failed to open bdev %s: %s\n",
		bdev->name, spdk_strerror(-rc));
		goto err;
		}

		ctx->ch = spdk_bdev_get_io_channel(ctx->desc);
		if (!ctx->ch) {
		SPDK_ERRLOG("Failed to get io channel for bdev %s\n", bdev->name);
		goto err;
		}

		rc = raid_bdev_load_base_bdev_superblock(ctx->desc, ctx->ch, raid_bdev_examine_load_sb_cb, ctx);
		if (rc) {
		SPDK_ERRLOG("Failed to read bdev %s superblock: %s\n",
		bdev->name, spdk_strerror(-rc));
		goto err;
		}

		return;
		err:
		raid_bdev_examine_ctx_free(ctx);
		spdk_bdev_module_examine_done(&g_raid_if);
		}

module/bdev/raid/bdev_raid.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -57,6 +57,9 @@ struct raid_base_bdev_info {
		/* name of the bdev */
		char *name;

		/* uuid of the bdev */
		struct spdk_uuid uuid;

		/* pointer to base bdev descriptor opened by raid bdev */
		struct spdk_bdev_desc *desc;

		@@ -425,9 +428,12 @@ SPDK_STATIC_ASSERT(RAID_BDEV_SB_MAX_LENGTH < RAID_BDEV_MIN_DATA_OFFSET_SIZE,
		"Incorrect min data offset");

		typedef void (raid_bdev_write_sb_cb)(int status, struct raid_bdev raid_bdev, void *ctx);
		typedef void (raid_bdev_load_sb_cb)(const struct raid_bdev_superblock sb, int status, void *ctx);

		void raid_bdev_init_superblock(struct raid_bdev *raid_bdev);
		void raid_bdev_write_superblock(struct raid_bdev *raid_bdev, raid_bdev_write_sb_cb cb,
		void *cb_ctx);
		int raid_bdev_load_base_bdev_superblock(struct spdk_bdev_desc desc, struct spdk_io_channel ch,
		raid_bdev_load_sb_cb cb, void *cb_ctx);

		#endif /* SPDK_BDEV_RAID_INTERNAL_H */

module/bdev/raid/bdev_raid_rpc.c

+4 −0

Original line number	Diff line number	Diff line
		@@ -87,8 +87,12 @@ rpc_bdev_raid_get_bdevs(struct spdk_jsonrpc_request *request,
		/* Get raid bdev list based on the category requested */
		TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) {
		if (raid_bdev->state == state \|\| state == RAID_BDEV_STATE_MAX) {
		char uuid_str[SPDK_UUID_STRING_LEN];

		spdk_json_write_object_begin(w);
		spdk_json_write_named_string(w, "name", raid_bdev->bdev.name);
		spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &raid_bdev->bdev.uuid);
		spdk_json_write_named_string(w, "uuid", uuid_str);
		raid_bdev_write_info_json(raid_bdev, w);
		spdk_json_write_object_end(w);
		}

module/bdev/raid/bdev_raid_sb.c

+178 −2

Original line number	Diff line number	Diff line
		@@ -23,6 +23,21 @@ struct raid_bdev_write_sb_ctx {
		struct spdk_bdev_io_wait_entry wait_entry;
		};

		struct raid_bdev_read_sb_ctx {
		struct spdk_bdev_desc *desc;
		struct spdk_io_channel *ch;
		raid_bdev_load_sb_cb cb;
		void *cb_ctx;
		void *buf;
		uint32_t buf_size;
		};

		static inline uint64_t
		align_ceil(uint64_t val, uint64_t align)
		{
		return spdk_divide_round_up(val, align) * align;
		}

		void
		raid_bdev_init_superblock(struct raid_bdev *raid_bdev)
		{
		@@ -47,7 +62,7 @@ raid_bdev_init_superblock(struct raid_bdev *raid_bdev)

		sb_base_bdev = &sb->base_bdevs[0];
		RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) {
		spdk_uuid_copy(&sb_base_bdev->uuid, spdk_bdev_get_uuid(spdk_bdev_desc_get_bdev(base_info->desc)));
		spdk_uuid_copy(&sb_base_bdev->uuid, &base_info->uuid);
		sb_base_bdev->data_offset = base_info->data_offset;
		sb_base_bdev->data_size = base_info->data_size;
		sb_base_bdev->state = RAID_SB_BASE_BDEV_CONFIGURED;
		@@ -63,6 +78,167 @@ raid_bdev_sb_update_crc(struct raid_bdev_superblock *sb)
		sb->crc = spdk_crc32c_update(sb, sb->length, 0);
		}

		static bool
		raid_bdev_sb_check_crc(struct raid_bdev_superblock *sb)
		{
		uint32_t crc, prev = sb->crc;

		raid_bdev_sb_update_crc(sb);
		crc = sb->crc;
		sb->crc = prev;

		return crc == prev;
		}

		static int
		raid_bdev_parse_superblock(struct raid_bdev_read_sb_ctx *ctx)
		{
		struct raid_bdev_superblock *sb = ctx->buf;
		struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(ctx->desc);

		if (memcmp(sb->signature, RAID_BDEV_SB_SIG, sizeof(sb->signature))) {
		SPDK_DEBUGLOG(bdev_raid_sb, "invalid signature\n");
		return -EINVAL;
		}

		if (sb->length > ctx->buf_size) {
		if (sb->length > RAID_BDEV_SB_MAX_LENGTH) {
		SPDK_WARNLOG("Incorrect superblock length on bdev %s\n",
		spdk_bdev_get_name(bdev));
		return -EINVAL;
		}

		return -EAGAIN;
		}

		if (!raid_bdev_sb_check_crc(sb)) {
		SPDK_WARNLOG("Incorrect superblock crc on bdev %s\n", spdk_bdev_get_name(bdev));
		return -EINVAL;
		}

		if (sb->version.major != RAID_BDEV_SB_VERSION_MAJOR) {
		SPDK_ERRLOG("Not supported superblock major version %d on bdev %s\n",
		sb->version.major, spdk_bdev_get_name(bdev));
		return -EINVAL;
		}

		if (sb->version.minor > RAID_BDEV_SB_VERSION_MINOR) {
		SPDK_WARNLOG("Superblock minor version %d on bdev %s is higher than the currently supported: %d\n",
		sb->version.minor, spdk_bdev_get_name(bdev), RAID_BDEV_SB_VERSION_MINOR);
		}

		return 0;
		}

		static void
		raid_bdev_read_sb_ctx_free(struct raid_bdev_read_sb_ctx *ctx)
		{
		spdk_dma_free(ctx->buf);

		free(ctx);
		}

		static void raid_bdev_read_sb_cb(struct spdk_bdev_io bdev_io, bool success, void cb_arg);

		static int
		raid_bdev_read_sb_remainder(struct raid_bdev_read_sb_ctx *ctx)
		{
		struct raid_bdev_superblock *sb = ctx->buf;
		struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(ctx->desc);
		uint32_t buf_size_prev;
		void *buf;
		int rc;

		buf_size_prev = ctx->buf_size;
		ctx->buf_size = align_ceil(sb->length, spdk_bdev_get_block_size(bdev));
		buf = spdk_dma_realloc(ctx->buf, ctx->buf_size, spdk_bdev_get_buf_align(bdev), NULL);
		if (buf == NULL) {
		SPDK_ERRLOG("Failed to reallocate buffer\n");
		return -ENOMEM;
		}
		ctx->buf = buf;

		rc = spdk_bdev_read(ctx->desc, ctx->ch, ctx->buf + buf_size_prev, buf_size_prev,
		ctx->buf_size - buf_size_prev, raid_bdev_read_sb_cb, ctx);
		if (rc != 0) {
		SPDK_ERRLOG("Failed to read bdev %s superblock remainder: %s\n",
		spdk_bdev_get_name(bdev), spdk_strerror(-rc));
		return rc;
		}

		return 0;
		}

		static void
		raid_bdev_read_sb_cb(struct spdk_bdev_io bdev_io, bool success, void cb_arg)
		{
		struct raid_bdev_read_sb_ctx *ctx = cb_arg;
		struct raid_bdev_superblock *sb = NULL;
		int status;

		spdk_bdev_free_io(bdev_io);

		if (!success) {
		status = -EIO;
		goto out;
		}

		status = raid_bdev_parse_superblock(ctx);
		if (status == -EAGAIN) {
		status = raid_bdev_read_sb_remainder(ctx);
		if (status == 0) {
		return;
		}
		} else if (status != 0) {
		SPDK_DEBUGLOG(bdev_raid_sb, "failed to parse bdev %s superblock\n",
		spdk_bdev_get_name(spdk_bdev_desc_get_bdev(ctx->desc)));
		} else {
		sb = ctx->buf;
		}
		out:
		ctx->cb(sb, status, ctx->cb_ctx);

		raid_bdev_read_sb_ctx_free(ctx);
		}

		int
		raid_bdev_load_base_bdev_superblock(struct spdk_bdev_desc desc, struct spdk_io_channel ch,
		raid_bdev_load_sb_cb cb, void *cb_ctx)
		{
		struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(desc);
		struct raid_bdev_read_sb_ctx *ctx;
		int rc;

		assert(cb != NULL);

		ctx = calloc(1, sizeof(*ctx));
		if (!ctx) {
		return -ENOMEM;
		}

		ctx->desc = desc;
		ctx->ch = ch;
		ctx->cb = cb;
		ctx->cb_ctx = cb_ctx;
		ctx->buf_size = align_ceil(sizeof(struct raid_bdev_superblock), spdk_bdev_get_block_size(bdev));
		ctx->buf = spdk_dma_malloc(ctx->buf_size, spdk_bdev_get_buf_align(bdev), NULL);
		if (!ctx->buf) {
		rc = -ENOMEM;
		goto err;
		}

		rc = spdk_bdev_read(desc, ch, ctx->buf, 0, ctx->buf_size, raid_bdev_read_sb_cb, ctx);
		if (rc) {
		goto err;
		}

		return 0;
		err:
		raid_bdev_read_sb_ctx_free(ctx);

		return rc;
		}

		static void
		raid_bdev_write_sb_base_bdev_done(int status, struct raid_bdev_write_sb_ctx *ctx)
		{
		@@ -144,7 +320,7 @@ raid_bdev_write_superblock(struct raid_bdev *raid_bdev, raid_bdev_write_sb_cb cb
		}

		ctx->raid_bdev = raid_bdev;
		ctx->nbytes = SPDK_ALIGN_CEIL(sb->length, spdk_bdev_get_block_size(&raid_bdev->bdev));
		ctx->nbytes = align_ceil(sb->length, spdk_bdev_get_block_size(&raid_bdev->bdev));
		ctx->remaining = raid_bdev->num_base_bdevs + 1;
		ctx->cb = cb;
		ctx->cb_ctx = cb_ctx;

test/bdev/bdev_raid.sh

+49 −0

Original line number	Diff line number	Diff line
		@@ -322,6 +322,8 @@ function raid_superblock_test() {
		local raid_bdev_name="raid_bdev1"
		local strip_size
		local strip_size_create_arg
		local raid_bdev_uuid
		local raid_bdev

		if [ $raid_level != "raid1" ]; then
		strip_size=64
		@@ -352,6 +354,53 @@ function raid_superblock_test() {
		$rpc_py bdev_raid_create $strip_size_create_arg -r $raid_level -b "${base_bdevs_pt[*]}" -n $raid_bdev_name -s
		verify_raid_bdev_state $raid_bdev_name "online" $raid_level $strip_size

		# Get RAID bdev's UUID
		raid_bdev_uuid=$($rpc_py bdev_get_bdevs -b $raid_bdev_name \| jq -r '.[] \| .uuid')
		if [ -z "$raid_bdev_uuid" ]; then
		return 1
		fi

		# Stop the RAID bdev
		$rpc_py bdev_raid_delete $raid_bdev_name
		raid_bdev=$($rpc_py bdev_raid_get_bdevs all \| jq -r '.[]')
		if [ -n "$raid_bdev" ]; then
		return 1
		fi

		# Delete the passthru bdevs
		for i in "${base_bdevs_pt[@]}"; do
		$rpc_py bdev_passthru_delete $i
		done
		if [ "$($rpc_py bdev_get_bdevs \| jq -r '[.[] \| select(.product_name == "passthru")] \| any')" == "true" ]; then
		return 1
		fi

		# Re-add first base bdev
		$rpc_py bdev_passthru_create -b ${base_bdevs_malloc[0]} -p ${base_bdevs_pt[0]} -u ${base_bdevs_pt_uuid[0]}

		# Check if the RAID bdev was assembled from superblock
		verify_raid_bdev_state $raid_bdev_name "configuring" $raid_level $strip_size

		if [ $num_base_bdevs -gt 2 ]; then
		# Re-add the second base bdev and remove it again
		$rpc_py bdev_passthru_create -b ${base_bdevs_malloc[1]} -p ${base_bdevs_pt[1]} -u ${base_bdevs_pt_uuid[1]}
		$rpc_py bdev_passthru_delete ${base_bdevs_pt[1]}
		verify_raid_bdev_state $raid_bdev_name "configuring" $raid_level $strip_size $num_base_bdevs
		fi

		# Re-add remaining base bdevs
		for ((i = 1; i < num_base_bdevs; i++)); do
		$rpc_py bdev_passthru_create -b ${base_bdevs_malloc[$i]} -p ${base_bdevs_pt[$i]} -u ${base_bdevs_pt_uuid[$i]}
		done

		# Check if the RAID bdev is in online state
		verify_raid_bdev_state $raid_bdev_name "online" $raid_level $strip_size

		# Check if the RAID bdev has the same UUID as when first created
		if [ "$($rpc_py bdev_get_bdevs -b $raid_bdev_name \| jq -r '.[] \| .uuid')" != "$raid_bdev_uuid" ]; then
		return 1
		fi

		killprocess $raid_pid

		return 0