Commit a4e1703e authored by Artur Paszkiewicz's avatar Artur Paszkiewicz Committed by Tomasz Zawadzki
Browse files

module/raid: put relevant bdev_io data in raid_bdev_io 



Everything the raid modules need will be in struct raid_bdev_io, they
won't access spdk_bdev_io fields directly. This will simplify the raid
modules' code and expose only what's needed. It will also allow easier
implementation of functionality like raid_io splitting (in the following
patches), which needs to alter the io in some way.

Change-Id: I26abf6d3397109a15251d279926ad28d7ea22105
Signed-off-by: default avatarArtur Paszkiewicz <artur.paszkiewicz@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/18734


Reviewed-by: default avatarJim Harris <jim.harris@samsung.com>
Reviewed-by: default avatarKonrad Sztyber <konrad.sztyber@intel.com>
Community-CI: Mellanox Build Bot
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
parent d8e4cf1e

module/bdev/raid/bdev_raid.c

+29 −5
Original line number Diff line number Diff line
@@ -465,6 +465,31 @@ raid_bdev_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, 
	raid_io->raid_bdev->module->submit_rw_request(raid_io);

}



void

raid_bdev_io_init(struct raid_bdev_io *raid_io, struct raid_bdev_io_channel *raid_ch,

		  enum spdk_bdev_io_type type, uint64_t offset_blocks,

		  uint64_t num_blocks, struct iovec *iovs, int iovcnt, void *md_buf,

		  struct spdk_memory_domain *memory_domain, void *memory_domain_ctx)

{

	struct spdk_io_channel *ch = spdk_io_channel_from_ctx(raid_ch);

	struct raid_bdev *raid_bdev = spdk_io_channel_get_io_device(ch);



	raid_io->type = type;

	raid_io->offset_blocks = offset_blocks;

	raid_io->num_blocks = num_blocks;

	raid_io->iovs = iovs;

	raid_io->iovcnt = iovcnt;

	raid_io->memory_domain = memory_domain;

	raid_io->memory_domain_ctx = memory_domain_ctx;

	raid_io->md_buf = md_buf;



	raid_io->raid_bdev = raid_bdev;

	raid_io->raid_ch = raid_ch;

	raid_io->base_bdev_io_remaining = 0;

	raid_io->base_bdev_io_submitted = 0;

	raid_io->base_bdev_io_status = SPDK_BDEV_IO_STATUS_SUCCESS;

}



/*

 * brief:

 * raid_bdev_submit_request function is the submit_request function pointer of
@@ -481,11 +506,10 @@ raid_bdev_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_i 
{

	struct raid_bdev_io *raid_io = (struct raid_bdev_io *)bdev_io->driver_ctx;



	raid_io->raid_bdev = bdev_io->bdev->ctxt;

	raid_io->raid_ch = spdk_io_channel_get_ctx(ch);

	raid_io->base_bdev_io_remaining = 0;

	raid_io->base_bdev_io_submitted = 0;

	raid_io->base_bdev_io_status = SPDK_BDEV_IO_STATUS_SUCCESS;

	raid_bdev_io_init(raid_io, spdk_io_channel_get_ctx(ch), bdev_io->type,

			  bdev_io->u.bdev.offset_blocks, bdev_io->u.bdev.num_blocks,

			  bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt, bdev_io->u.bdev.md_buf,

			  bdev_io->u.bdev.memory_domain, bdev_io->u.bdev.memory_domain_ctx);



	switch (bdev_io->type) {

	case SPDK_BDEV_IO_TYPE_READ:

module/bdev/raid/bdev_raid.h

+13 −0
Original line number Diff line number Diff line
@@ -103,6 +103,15 @@ struct raid_bdev_io { 
	/* The raid bdev associated with this IO */

	struct raid_bdev *raid_bdev;



	enum spdk_bdev_io_type type;

	uint64_t offset_blocks;

	uint64_t num_blocks;

	struct iovec *iovs;

	int iovcnt;

	struct spdk_memory_domain *memory_domain;

	void *memory_domain_ctx;

	void *md_buf;



	/* WaitQ entry, used only in waitq logic */

	struct spdk_bdev_io_wait_entry	waitq_entry;
@@ -302,6 +311,10 @@ void raid_bdev_queue_io_wait(struct raid_bdev_io *raid_io, struct spdk_bdev *bde 
			     struct spdk_io_channel *ch, spdk_bdev_io_wait_cb cb_fn);

void raid_bdev_io_complete(struct raid_bdev_io *raid_io, enum spdk_bdev_io_status status);

void raid_bdev_module_stop_done(struct raid_bdev *raid_bdev);

void raid_bdev_io_init(struct raid_bdev_io *raid_io, struct raid_bdev_io_channel *raid_ch,

		       enum spdk_bdev_io_type type, uint64_t offset_blocks,

		       uint64_t num_blocks, struct iovec *iovs, int iovcnt, void *md_buf,

		       struct spdk_memory_domain *memory_domain, void *memory_domain_ctx);



static inline uint8_t

raid_bdev_base_bdev_slot(struct raid_base_bdev_info *base_info)

module/bdev/raid/concat.c

+18 −21
Original line number Diff line number Diff line
@@ -65,7 +65,6 @@ _concat_submit_rw_request(void *_raid_io) 
static void

concat_submit_rw_request(struct raid_bdev_io *raid_io)

{

	struct spdk_bdev_io		*bdev_io = spdk_bdev_io_from_ctx(raid_io);

	struct raid_bdev_io_channel	*raid_ch = raid_io->raid_ch;

	struct raid_bdev		*raid_bdev = raid_io->raid_bdev;

	struct concat_block_range	*block_range = raid_bdev->module_private;
@@ -80,15 +79,15 @@ concat_submit_rw_request(struct raid_bdev_io *raid_io) 


	pd_idx = -1;

	for (i = 0; i < raid_bdev->num_base_bdevs; i++) {

		if (block_range[i].start > bdev_io->u.bdev.offset_blocks) {

		if (block_range[i].start > raid_io->offset_blocks) {

			break;

		}

		pd_idx = i;

	}

	assert(pd_idx >= 0);

	assert(bdev_io->u.bdev.offset_blocks >= block_range[pd_idx].start);

	pd_lba = bdev_io->u.bdev.offset_blocks - block_range[pd_idx].start;

	pd_blocks = bdev_io->u.bdev.num_blocks;

	assert(raid_io->offset_blocks >= block_range[pd_idx].start);

	pd_lba = raid_io->offset_blocks - block_range[pd_idx].start;

	pd_blocks = raid_io->num_blocks;

	base_info = &raid_bdev->base_bdev_info[pd_idx];

	if (base_info->desc == NULL) {

		SPDK_ERRLOG("base bdev desc null for pd_idx %u\n", pd_idx);
@@ -105,22 +104,22 @@ concat_submit_rw_request(struct raid_bdev_io *raid_io) 
	base_ch = raid_ch->base_channel[pd_idx];



	io_opts.size = sizeof(io_opts);

	io_opts.memory_domain = bdev_io->u.bdev.memory_domain;

	io_opts.memory_domain_ctx = bdev_io->u.bdev.memory_domain_ctx;

	io_opts.metadata = bdev_io->u.bdev.md_buf;

	io_opts.memory_domain = raid_io->memory_domain;

	io_opts.memory_domain_ctx = raid_io->memory_domain_ctx;

	io_opts.metadata = raid_io->md_buf;



	if (bdev_io->type == SPDK_BDEV_IO_TYPE_READ) {

	if (raid_io->type == SPDK_BDEV_IO_TYPE_READ) {

		ret = raid_bdev_readv_blocks_ext(base_info, base_ch,

						 bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,

						 raid_io->iovs, raid_io->iovcnt,

						 pd_lba, pd_blocks, concat_bdev_io_completion,

						 raid_io, &io_opts);

	} else if (bdev_io->type == SPDK_BDEV_IO_TYPE_WRITE) {

	} else if (raid_io->type == SPDK_BDEV_IO_TYPE_WRITE) {

		ret = raid_bdev_writev_blocks_ext(base_info, base_ch,

						  bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,

						  raid_io->iovs, raid_io->iovcnt,

						  pd_lba, pd_blocks, concat_bdev_io_completion,

						  raid_io, &io_opts);

	} else {

		SPDK_ERRLOG("Recvd not supported io type %u\n", bdev_io->type);

		SPDK_ERRLOG("Recvd not supported io type %u\n", raid_io->type);

		assert(0);

	}
@@ -170,7 +169,6 @@ concat_base_io_complete(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg 
static void

concat_submit_null_payload_request(struct raid_bdev_io *raid_io)

{

	struct spdk_bdev_io		*bdev_io;

	struct raid_bdev		*raid_bdev;

	int				ret;

	struct raid_base_bdev_info	*base_info;
@@ -182,12 +180,11 @@ concat_submit_null_payload_request(struct raid_bdev_io *raid_io) 
	struct concat_block_range	*block_range;

	int				i, start_idx, stop_idx;



	bdev_io = spdk_bdev_io_from_ctx(raid_io);

	raid_bdev = raid_io->raid_bdev;

	block_range = raid_bdev->module_private;



	offset_blocks = bdev_io->u.bdev.offset_blocks;

	num_blocks = bdev_io->u.bdev.num_blocks;

	offset_blocks = raid_io->offset_blocks;

	num_blocks = raid_io->num_blocks;

	start_idx = -1;

	stop_idx = -1;

	/*
@@ -223,8 +220,8 @@ concat_submit_null_payload_request(struct raid_bdev_io *raid_io) 
	if (raid_io->base_bdev_io_remaining == 0) {

		raid_io->base_bdev_io_remaining = stop_idx - start_idx + 1;

	}

	offset_blocks = bdev_io->u.bdev.offset_blocks;

	num_blocks = bdev_io->u.bdev.num_blocks;

	offset_blocks = raid_io->offset_blocks;

	num_blocks = raid_io->num_blocks;

	for (i = start_idx; i <= stop_idx; i++) {

		assert(offset_blocks >= block_range[i].start);

		assert(offset_blocks < block_range[i].start + block_range[i].length);
@@ -240,7 +237,7 @@ concat_submit_null_payload_request(struct raid_bdev_io *raid_io) 
		}

		base_info = &raid_bdev->base_bdev_info[i];

		base_ch = raid_io->raid_ch->base_channel[i];

		switch (bdev_io->type) {

		switch (raid_io->type) {

		case SPDK_BDEV_IO_TYPE_UNMAP:

			ret = raid_bdev_unmap_blocks(base_info, base_ch,

						     pd_lba, pd_blocks,
@@ -252,7 +249,7 @@ concat_submit_null_payload_request(struct raid_bdev_io *raid_io) 
						     concat_base_io_complete, raid_io);

			break;

		default:

			SPDK_ERRLOG("submit request, invalid io type with null payload %u\n", bdev_io->type);

			SPDK_ERRLOG("submit request, invalid io type with null payload %u\n", raid_io->type);

			assert(false);

			ret = -EIO;

		}

module/bdev/raid/raid0.c

+15 −18
Original line number Diff line number Diff line
@@ -60,7 +60,6 @@ _raid0_submit_rw_request(void *_raid_io) 
static void

raid0_submit_rw_request(struct raid_bdev_io *raid_io)

{

	struct spdk_bdev_io		*bdev_io = spdk_bdev_io_from_ctx(raid_io);

	struct spdk_bdev_ext_io_opts	io_opts = {};

	struct raid_bdev_io_channel	*raid_ch = raid_io->raid_ch;

	struct raid_bdev		*raid_bdev = raid_io->raid_bdev;
@@ -75,8 +74,8 @@ raid0_submit_rw_request(struct raid_bdev_io *raid_io) 
	struct raid_base_bdev_info	*base_info;

	struct spdk_io_channel		*base_ch;



	start_strip = bdev_io->u.bdev.offset_blocks >> raid_bdev->strip_size_shift;

	end_strip = (bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) >>

	start_strip = raid_io->offset_blocks >> raid_bdev->strip_size_shift;

	end_strip = (raid_io->offset_blocks + raid_io->num_blocks - 1) >>

		    raid_bdev->strip_size_shift;

	if (start_strip != end_strip && raid_bdev->num_base_bdevs > 1) {

		assert(false);
@@ -87,9 +86,9 @@ raid0_submit_rw_request(struct raid_bdev_io *raid_io) 


	pd_strip = start_strip / raid_bdev->num_base_bdevs;

	pd_idx = start_strip % raid_bdev->num_base_bdevs;

	offset_in_strip = bdev_io->u.bdev.offset_blocks & (raid_bdev->strip_size - 1);

	offset_in_strip = raid_io->offset_blocks & (raid_bdev->strip_size - 1);

	pd_lba = (pd_strip << raid_bdev->strip_size_shift) + offset_in_strip;

	pd_blocks = bdev_io->u.bdev.num_blocks;

	pd_blocks = raid_io->num_blocks;

	base_info = &raid_bdev->base_bdev_info[pd_idx];

	if (base_info->desc == NULL) {

		SPDK_ERRLOG("base bdev desc null for pd_idx %u\n", pd_idx);
@@ -106,22 +105,22 @@ raid0_submit_rw_request(struct raid_bdev_io *raid_io) 
	base_ch = raid_ch->base_channel[pd_idx];



	io_opts.size = sizeof(io_opts);

	io_opts.memory_domain = bdev_io->u.bdev.memory_domain;

	io_opts.memory_domain_ctx = bdev_io->u.bdev.memory_domain_ctx;

	io_opts.metadata = bdev_io->u.bdev.md_buf;

	io_opts.memory_domain = raid_io->memory_domain;

	io_opts.memory_domain_ctx = raid_io->memory_domain_ctx;

	io_opts.metadata = raid_io->md_buf;



	if (bdev_io->type == SPDK_BDEV_IO_TYPE_READ) {

	if (raid_io->type == SPDK_BDEV_IO_TYPE_READ) {

		ret = raid_bdev_readv_blocks_ext(base_info, base_ch,

						 bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,

						 raid_io->iovs, raid_io->iovcnt,

						 pd_lba, pd_blocks, raid0_bdev_io_completion,

						 raid_io, &io_opts);

	} else if (bdev_io->type == SPDK_BDEV_IO_TYPE_WRITE) {

	} else if (raid_io->type == SPDK_BDEV_IO_TYPE_WRITE) {

		ret = raid_bdev_writev_blocks_ext(base_info, base_ch,

						  bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,

						  raid_io->iovs, raid_io->iovcnt,

						  pd_lba, pd_blocks, raid0_bdev_io_completion,

						  raid_io, &io_opts);

	} else {

		SPDK_ERRLOG("Recvd not supported io type %u\n", bdev_io->type);

		SPDK_ERRLOG("Recvd not supported io type %u\n", raid_io->type);

		assert(0);

	}
@@ -269,19 +268,17 @@ raid0_base_io_complete(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 
static void

raid0_submit_null_payload_request(struct raid_bdev_io *raid_io)

{

	struct spdk_bdev_io		*bdev_io;

	struct raid_bdev		*raid_bdev;

	struct raid_bdev_io_range	io_range;

	int				ret;

	struct raid_base_bdev_info	*base_info;

	struct spdk_io_channel		*base_ch;



	bdev_io = spdk_bdev_io_from_ctx(raid_io);

	raid_bdev = raid_io->raid_bdev;



	_raid0_get_io_range(&io_range, raid_bdev->num_base_bdevs,

			    raid_bdev->strip_size, raid_bdev->strip_size_shift,

			    bdev_io->u.bdev.offset_blocks, bdev_io->u.bdev.num_blocks);

			    raid_io->offset_blocks, raid_io->num_blocks);



	if (raid_io->base_bdev_io_remaining == 0) {

		raid_io->base_bdev_io_remaining = io_range.n_disks_involved;
@@ -301,7 +298,7 @@ raid0_submit_null_payload_request(struct raid_bdev_io *raid_io) 


		_raid0_split_io_range(&io_range, disk_idx, &offset_in_disk, &nblocks_in_disk);



		switch (bdev_io->type) {

		switch (raid_io->type) {

		case SPDK_BDEV_IO_TYPE_UNMAP:

			ret = raid_bdev_unmap_blocks(base_info, base_ch,

						     offset_in_disk, nblocks_in_disk,
@@ -315,7 +312,7 @@ raid0_submit_null_payload_request(struct raid_bdev_io *raid_io) 
			break;



		default:

			SPDK_ERRLOG("submit request, invalid io type with null payload %u\n", bdev_io->type);

			SPDK_ERRLOG("submit request, invalid io type with null payload %u\n", raid_io->type);

			assert(false);

			ret = -EIO;

		}

module/bdev/raid/raid1.c

+15 −28
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ raid1_read_bdev_io_completion(struct spdk_bdev_io *bdev_io, bool success, void * 
	struct raid_bdev_io *raid_io = cb_arg;



	raid1_channel_dec_read_counters(raid_io->raid_ch, raid_io->base_bdev_io_submitted,

					spdk_bdev_io_from_ctx(raid_io)->u.bdev.num_blocks);

					raid_io->num_blocks);



	raid1_bdev_io_completion(bdev_io, success, raid_io);

}
@@ -78,13 +78,13 @@ _raid1_submit_rw_request(void *_raid_io) 
}



static void

raid1_init_ext_io_opts(struct spdk_bdev_io *bdev_io, struct spdk_bdev_ext_io_opts *opts)

raid1_init_ext_io_opts(struct spdk_bdev_ext_io_opts *opts, struct raid_bdev_io *raid_io)

{

	memset(opts, 0, sizeof(*opts));

	opts->size = sizeof(*opts);

	opts->memory_domain = bdev_io->u.bdev.memory_domain;

	opts->memory_domain_ctx = bdev_io->u.bdev.memory_domain_ctx;

	opts->metadata = bdev_io->u.bdev.md_buf;

	opts->memory_domain = raid_io->memory_domain;

	opts->memory_domain_ctx = raid_io->memory_domain_ctx;

	opts->metadata = raid_io->md_buf;

}



static uint8_t
@@ -110,18 +110,13 @@ static int 
raid1_submit_read_request(struct raid_bdev_io *raid_io)

{

	struct raid_bdev *raid_bdev = raid_io->raid_bdev;

	struct spdk_bdev_io *bdev_io = spdk_bdev_io_from_ctx(raid_io);

	struct raid_bdev_io_channel *raid_ch = raid_io->raid_ch;

	struct spdk_bdev_ext_io_opts io_opts;

	struct raid_base_bdev_info *base_info;

	struct spdk_io_channel *base_ch;

	uint64_t pd_lba, pd_blocks;

	uint8_t idx;

	int ret;



	pd_lba = bdev_io->u.bdev.offset_blocks;

	pd_blocks = bdev_io->u.bdev.num_blocks;



	idx = raid1_channel_next_read_base_bdev(raid_bdev, raid_ch);

	if (spdk_unlikely(idx == UINT8_MAX)) {

		raid_bdev_io_complete(raid_io, SPDK_BDEV_IO_STATUS_FAILED);
@@ -133,14 +128,13 @@ raid1_submit_read_request(struct raid_bdev_io *raid_io) 


	raid_io->base_bdev_io_remaining = 1;



	raid1_init_ext_io_opts(bdev_io, &io_opts);

	ret = raid_bdev_readv_blocks_ext(base_info, base_ch,

					 bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,

					 pd_lba, pd_blocks, raid1_read_bdev_io_completion,

					 raid_io, &io_opts);

	raid1_init_ext_io_opts(&io_opts, raid_io);

	ret = raid_bdev_readv_blocks_ext(base_info, base_ch, raid_io->iovs, raid_io->iovcnt,

					 raid_io->offset_blocks, raid_io->num_blocks,

					 raid1_read_bdev_io_completion, raid_io, &io_opts);



	if (spdk_likely(ret == 0)) {

		raid1_channel_inc_read_counters(raid_ch, idx, pd_blocks);

		raid1_channel_inc_read_counters(raid_ch, idx, raid_io->num_blocks);

		raid_io->base_bdev_io_submitted = idx;

	} else if (spdk_unlikely(ret == -ENOMEM)) {

		raid_bdev_queue_io_wait(raid_io, spdk_bdev_desc_get_bdev(base_info->desc),
@@ -155,23 +149,18 @@ static int 
raid1_submit_write_request(struct raid_bdev_io *raid_io)

{

	struct raid_bdev *raid_bdev = raid_io->raid_bdev;

	struct spdk_bdev_io *bdev_io = spdk_bdev_io_from_ctx(raid_io);

	struct spdk_bdev_ext_io_opts io_opts;

	struct raid_base_bdev_info *base_info;

	struct spdk_io_channel *base_ch;

	uint64_t pd_lba, pd_blocks;

	uint8_t idx;

	uint64_t base_bdev_io_not_submitted;

	int ret = 0;



	pd_lba = bdev_io->u.bdev.offset_blocks;

	pd_blocks = bdev_io->u.bdev.num_blocks;



	if (raid_io->base_bdev_io_submitted == 0) {

		raid_io->base_bdev_io_remaining = raid_bdev->num_base_bdevs;

	}



	raid1_init_ext_io_opts(bdev_io, &io_opts);

	raid1_init_ext_io_opts(&io_opts, raid_io);

	for (idx = raid_io->base_bdev_io_submitted; idx < raid_bdev->num_base_bdevs; idx++) {

		base_info = &raid_bdev->base_bdev_info[idx];

		base_ch = raid_io->raid_ch->base_channel[idx];
@@ -183,10 +172,9 @@ raid1_submit_write_request(struct raid_bdev_io *raid_io) 
			continue;

		}



		ret = raid_bdev_writev_blocks_ext(base_info, base_ch,

						  bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,

						  pd_lba, pd_blocks, raid1_write_bdev_io_completion,

						  raid_io, &io_opts);

		ret = raid_bdev_writev_blocks_ext(base_info, base_ch, raid_io->iovs, raid_io->iovcnt,

						  raid_io->offset_blocks, raid_io->num_blocks,

						  raid1_write_bdev_io_completion, raid_io, &io_opts);

		if (spdk_unlikely(ret != 0)) {

			if (spdk_unlikely(ret == -ENOMEM)) {

				raid_bdev_queue_io_wait(raid_io, spdk_bdev_desc_get_bdev(base_info->desc),
@@ -214,10 +202,9 @@ raid1_submit_write_request(struct raid_bdev_io *raid_io) 
static void

raid1_submit_rw_request(struct raid_bdev_io *raid_io)

{

	struct spdk_bdev_io *bdev_io = spdk_bdev_io_from_ctx(raid_io);

	int ret;



	switch (bdev_io->type) {

	switch (raid_io->type) {

	case SPDK_BDEV_IO_TYPE_READ:

		ret = raid1_submit_read_request(raid_io);

		break;