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

ut/bdev/raid: Use cached pointer to expected output in IO verification

Browse Source 
Use cached pointer to g_io_output in IO verification to improve
readability.

Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Change-Id: I71ced5d1e438d5046b9a5913a1a2860f8435d79b
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/464485
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Broadcom SPDK FC-NVMe CI <spdk-ci.pdl@broadcom.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
This commit is contained in:
Shuhei Matsumoto 2019-08-08 12:57:19 +09:00 committed by Jim Harris
parent 2b015b7a26
commit 47155be6f3
1 changed files with 26 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -643,6 +643,7 @@ verify_reset_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, uint32_t io_status) struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, uint32_t io_status)
{ {
uint8_t index = 0; uint8_t index = 0;
struct io_output *output;
SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); SPDK_CU_ASSERT_FATAL(raid_bdev != NULL);
SPDK_CU_ASSERT_FATAL(num_base_drives != 0); SPDK_CU_ASSERT_FATAL(num_base_drives != 0);
@ -651,9 +652,10 @@ verify_reset_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
CU_ASSERT(g_io_output_index == num_base_drives); CU_ASSERT(g_io_output_index == num_base_drives);
for (index = 0; index < g_io_output_index; index++) { for (index = 0; index < g_io_output_index; index++) {
CU_ASSERT(ch_ctx->base_channel[index] == g_io_output[index].ch); output = &g_io_output[index];
CU_ASSERT(raid_bdev->base_bdev_info[index].desc == g_io_output[index].desc); CU_ASSERT(ch_ctx->base_channel[index] == output->ch);
CU_ASSERT(bdev_io->type == g_io_output[index].iotype); CU_ASSERT(raid_bdev->base_bdev_info[index].desc == output->desc);
CU_ASSERT(bdev_io->type == output->iotype);
} }
CU_ASSERT(g_io_comp_status == io_status); CU_ASSERT(g_io_comp_status == io_status);
} }
@ -675,6 +677,7 @@ verify_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
uint64_t pd_blocks; uint64_t pd_blocks;
uint32_t index = 0; uint32_t index = 0;
uint8_t *buf = bdev_io->u.bdev.iovs->iov_base; uint8_t *buf = bdev_io->u.bdev.iovs->iov_base;
struct io_output *output;
if (io_status == INVALID_IO_SUBMIT) { if (io_status == INVALID_IO_SUBMIT) {
CU_ASSERT(g_io_comp_status == false); CU_ASSERT(g_io_comp_status == false);
@ -703,11 +706,12 @@ verify_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
pd_lba = pd_strip << raid_bdev->strip_size_shift; pd_lba = pd_strip << raid_bdev->strip_size_shift;
pd_blocks = raid_bdev->strip_size; pd_blocks = raid_bdev->strip_size;
} }
CU_ASSERT(pd_lba == g_io_output[index].offset_blocks); output = &g_io_output[index];
CU_ASSERT(pd_blocks == g_io_output[index].num_blocks); CU_ASSERT(pd_lba == output->offset_blocks);
CU_ASSERT(ch_ctx->base_channel[pd_idx] == g_io_output[index].ch); CU_ASSERT(pd_blocks == output->num_blocks);
CU_ASSERT(raid_bdev->base_bdev_info[pd_idx].desc == g_io_output[index].desc); CU_ASSERT(ch_ctx->base_channel[pd_idx] == output->ch);
CU_ASSERT(bdev_io->type == g_io_output[index].iotype); CU_ASSERT(raid_bdev->base_bdev_info[pd_idx].desc == output->desc);
CU_ASSERT(bdev_io->type == output->iotype);
buf += (pd_blocks << spdk_u32log2(g_block_len)); buf += (pd_blocks << spdk_u32log2(g_block_len));
} }
CU_ASSERT(g_io_comp_status == io_status); CU_ASSERT(g_io_comp_status == io_status);
@ -732,6 +736,7 @@ verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
uint8_t disk_idx; uint8_t disk_idx;
uint64_t base_io_idx; uint64_t base_io_idx;
uint64_t sum_nblocks = 0; uint64_t sum_nblocks = 0;
struct io_output *output;
if (io_status == INVALID_IO_SUBMIT) { if (io_status == INVALID_IO_SUBMIT) {
CU_ASSERT(g_io_comp_status == false); CU_ASSERT(g_io_comp_status == false);
@ -747,6 +752,7 @@ verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
start_strip_disk_idx = start_strip % num_base_drives; start_strip_disk_idx = start_strip % num_base_drives;
end_strip_disk_idx = end_strip % num_base_drives; end_strip_disk_idx = end_strip % num_base_drives;
offset_in_start_disk = g_io_output[0].offset_blocks; offset_in_start_disk = g_io_output[0].offset_blocks;
nblocks_in_start_disk = g_io_output[0].num_blocks; nblocks_in_start_disk = g_io_output[0].num_blocks;
@ -755,6 +761,8 @@ verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
uint64_t start_offset_in_disk; uint64_t start_offset_in_disk;
uint64_t end_offset_in_disk; uint64_t end_offset_in_disk;
output = &g_io_output[base_io_idx];
/* round disk_idx */ /* round disk_idx */
if (disk_idx >= num_base_drives) { if (disk_idx >= num_base_drives) {
disk_idx %= num_base_drives; disk_idx %= num_base_drives;
@ -764,7 +772,7 @@ verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
* The first base io has a same start_offset_in_strip with the whole raid io. * The first base io has a same start_offset_in_strip with the whole raid io.
* Other base io should have aligned start_offset_in_strip which is 0. * Other base io should have aligned start_offset_in_strip which is 0.
*/ */
start_offset_in_disk = g_io_output[base_io_idx].offset_blocks; start_offset_in_disk = output->offset_blocks;
if (base_io_idx == 0) { if (base_io_idx == 0) {
CU_ASSERT(start_offset_in_disk % g_strip_size == start_offset_in_strip); CU_ASSERT(start_offset_in_disk % g_strip_size == start_offset_in_strip);
} else { } else {
@ -775,8 +783,7 @@ verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
* Base io on disk at which end_strip is located, has a same end_offset_in_strip with the whole raid io. * Base io on disk at which end_strip is located, has a same end_offset_in_strip with the whole raid io.
* Other base io should have aligned end_offset_in_strip. * Other base io should have aligned end_offset_in_strip.
*/ */
end_offset_in_disk = g_io_output[base_io_idx].offset_blocks + end_offset_in_disk = output->offset_blocks + output->num_blocks - 1;
g_io_output[base_io_idx].num_blocks - 1;
if (disk_idx == end_strip_disk_idx) { if (disk_idx == end_strip_disk_idx) {
CU_ASSERT(end_offset_in_disk % g_strip_size == end_offset_in_strip); CU_ASSERT(end_offset_in_disk % g_strip_size == end_offset_in_strip);
} else { } else {
@ -794,23 +801,23 @@ verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives,
CU_ASSERT(offset_in_start_disk - start_offset_in_disk < g_strip_size); CU_ASSERT(offset_in_start_disk - start_offset_in_disk < g_strip_size);
} else if (disk_idx < start_strip_disk_idx) { } else if (disk_idx < start_strip_disk_idx) {
CU_ASSERT(start_offset_in_disk > offset_in_start_disk); CU_ASSERT(start_offset_in_disk > offset_in_start_disk);
CU_ASSERT(g_io_output[base_io_idx].offset_blocks - offset_in_start_disk <= g_strip_size); CU_ASSERT(output->offset_blocks - offset_in_start_disk <= g_strip_size);
} }
/* nblocks compared with start_disk: /* nblocks compared with start_disk:
* The gap between them must be within a strip size. * The gap between them must be within a strip size.
*/ */
if (g_io_output[base_io_idx].num_blocks <= nblocks_in_start_disk) { if (output->num_blocks <= nblocks_in_start_disk) {
CU_ASSERT(nblocks_in_start_disk - g_io_output[base_io_idx].num_blocks <= g_strip_size); CU_ASSERT(nblocks_in_start_disk - output->num_blocks <= g_strip_size);
} else { } else {
CU_ASSERT(g_io_output[base_io_idx].num_blocks - nblocks_in_start_disk < g_strip_size); CU_ASSERT(output->num_blocks - nblocks_in_start_disk < g_strip_size);
} }
sum_nblocks += g_io_output[base_io_idx].num_blocks; sum_nblocks += output->num_blocks;
CU_ASSERT(ch_ctx->base_channel[disk_idx] == g_io_output[base_io_idx].ch); CU_ASSERT(ch_ctx->base_channel[disk_idx] == output->ch);
CU_ASSERT(raid_bdev->base_bdev_info[disk_idx].desc == g_io_output[base_io_idx].desc); CU_ASSERT(raid_bdev->base_bdev_info[disk_idx].desc == output->desc);
CU_ASSERT(bdev_io->type == g_io_output[base_io_idx].iotype); CU_ASSERT(bdev_io->type == output->iotype);
} }
/* Sum of each nblocks should be same with raid bdev_io */ /* Sum of each nblocks should be same with raid bdev_io */