From 6a8d00949b18747376cc6608b8c0ae7c859be707 Mon Sep 17 00:00:00 2001 From: Tomasz Zawadzki Date: Tue, 21 May 2019 10:17:19 -0400 Subject: [PATCH] test/bdevio: setup separate suites for each target With this patch each target has separate suite, tests are ran just once for all setup suites. Suite init/fini functions were added that move current g_current_io_target ahead for next suite. Results what works for particular bdev are of more use rather than combination for all bdevs. This will come useful when we want to perform RPC for only select targets. In case of CUnit library error, application is stopped without returning number of failures. This is because at that point its numbers are not reliable. Change-Id: Ie82b6e33374841bf829da09a16a401fddd1fd81c Signed-off-by: Tomasz Zawadzki Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/455199 Tested-by: SPDK CI Jenkins Reviewed-by: Ben Walker Reviewed-by: Jim Harris Reviewed-by: Shuhei Matsumoto Reviewed-by: Darek Stojaczyk --- test/bdev/bdevio/bdevio.c | 231 +++++++++++++++++++++----------------- 1 file changed, 125 insertions(+), 106 deletions(-) diff --git a/test/bdev/bdevio/bdevio.c b/test/bdev/bdevio/bdevio.c index 4e4e452cf..b50ec0f16 100644 --- a/test/bdev/bdevio/bdevio.c +++ b/test/bdev/bdevio/bdevio.c @@ -70,6 +70,7 @@ struct bdevio_request { }; struct io_target *g_io_targets = NULL; +struct io_target *g_current_io_target = NULL; static void execute_spdk_function(spdk_event_fn fn, void *arg1, void *arg2) @@ -356,48 +357,44 @@ blockdev_write_read(uint32_t data_length, uint32_t iov_len, int pattern, uint64_ char *rx_buf = NULL; int rc; - target = g_io_targets; - while (target != NULL) { - if (data_length < spdk_bdev_get_block_size(target->bdev) || - data_length / spdk_bdev_get_block_size(target->bdev) > spdk_bdev_get_num_blocks(target->bdev)) { - target = target->next; - continue; - } + target = g_current_io_target; - if (!write_zeroes) { - initialize_buffer(&tx_buf, pattern, data_length); - initialize_buffer(&rx_buf, 0, data_length); + if (data_length < spdk_bdev_get_block_size(target->bdev) || + data_length / spdk_bdev_get_block_size(target->bdev) > spdk_bdev_get_num_blocks(target->bdev)) { + return; + } - blockdev_write(target, tx_buf, offset, data_length, iov_len); - } else { - initialize_buffer(&tx_buf, 0, data_length); - initialize_buffer(&rx_buf, pattern, data_length); + if (!write_zeroes) { + initialize_buffer(&tx_buf, pattern, data_length); + initialize_buffer(&rx_buf, 0, data_length); - blockdev_write_zeroes(target, tx_buf, offset, data_length); - } + blockdev_write(target, tx_buf, offset, data_length, iov_len); + } else { + initialize_buffer(&tx_buf, 0, data_length); + initialize_buffer(&rx_buf, pattern, data_length); + + blockdev_write_zeroes(target, tx_buf, offset, data_length); + } - if (expected_rc == 0) { - CU_ASSERT_EQUAL(g_completion_success, true); - } else { - CU_ASSERT_EQUAL(g_completion_success, false); - } - blockdev_read(target, rx_buf, offset, data_length, iov_len); + if (expected_rc == 0) { + CU_ASSERT_EQUAL(g_completion_success, true); + } else { + CU_ASSERT_EQUAL(g_completion_success, false); + } + blockdev_read(target, rx_buf, offset, data_length, iov_len); - if (expected_rc == 0) { - CU_ASSERT_EQUAL(g_completion_success, true); - } else { - CU_ASSERT_EQUAL(g_completion_success, false); - } + if (expected_rc == 0) { + CU_ASSERT_EQUAL(g_completion_success, true); + } else { + CU_ASSERT_EQUAL(g_completion_success, false); + } - if (g_completion_success) { - rc = blockdev_write_read_data_match(rx_buf, tx_buf, data_length); - /* Assert the write by comparing it with values read - * from each blockdev */ - CU_ASSERT_EQUAL(rc, 0); - } - - target = target->next; + if (g_completion_success) { + rc = blockdev_write_read_data_match(rx_buf, tx_buf, data_length); + /* Assert the write by comparing it with values read + * from each blockdev */ + CU_ASSERT_EQUAL(rc, 0); } } @@ -686,33 +683,29 @@ blockdev_write_read_offset_plus_nbytes_equals_bdev_size(void) uint32_t block_size; int rc; - target = g_io_targets; - while (target != NULL) { - bdev = target->bdev; + target = g_current_io_target; + bdev = target->bdev; - block_size = spdk_bdev_get_block_size(bdev); + block_size = spdk_bdev_get_block_size(bdev); - /* The start offset has been set to a marginal value - * such that offset + nbytes == Total size of - * blockdev. */ - offset = ((spdk_bdev_get_num_blocks(bdev) - 1) * block_size); + /* The start offset has been set to a marginal value + * such that offset + nbytes == Total size of + * blockdev. */ + offset = ((spdk_bdev_get_num_blocks(bdev) - 1) * block_size); - initialize_buffer(&tx_buf, 0xA3, block_size); - initialize_buffer(&rx_buf, 0, block_size); + initialize_buffer(&tx_buf, 0xA3, block_size); + initialize_buffer(&rx_buf, 0, block_size); - blockdev_write(target, tx_buf, offset, block_size, 0); - CU_ASSERT_EQUAL(g_completion_success, true); + blockdev_write(target, tx_buf, offset, block_size, 0); + CU_ASSERT_EQUAL(g_completion_success, true); - blockdev_read(target, rx_buf, offset, block_size, 0); - CU_ASSERT_EQUAL(g_completion_success, true); + blockdev_read(target, rx_buf, offset, block_size, 0); + CU_ASSERT_EQUAL(g_completion_success, true); - rc = blockdev_write_read_data_match(rx_buf, tx_buf, block_size); - /* Assert the write by comparing it with values read - * from each blockdev */ - CU_ASSERT_EQUAL(rc, 0); - - target = target->next; - } + rc = blockdev_write_read_data_match(rx_buf, tx_buf, block_size); + /* Assert the write by comparing it with values read + * from each blockdev */ + CU_ASSERT_EQUAL(rc, 0); } static void @@ -731,26 +724,22 @@ blockdev_write_read_offset_plus_nbytes_gt_bdev_size(void) CU_ASSERT_TRUE(data_length < BUFFER_SIZE); pattern = 0xA3; - target = g_io_targets; - while (target != NULL) { - bdev = target->bdev; + target = g_current_io_target; + bdev = target->bdev; - /* The start offset has been set to a valid value - * but offset + nbytes is greater than the Total size - * of the blockdev. The test should fail. */ - offset = ((spdk_bdev_get_num_blocks(bdev) * spdk_bdev_get_block_size(bdev)) - 1024); + /* The start offset has been set to a valid value + * but offset + nbytes is greater than the Total size + * of the blockdev. The test should fail. */ + offset = ((spdk_bdev_get_num_blocks(bdev) * spdk_bdev_get_block_size(bdev)) - 1024); - initialize_buffer(&tx_buf, pattern, data_length); - initialize_buffer(&rx_buf, 0, data_length); + initialize_buffer(&tx_buf, pattern, data_length); + initialize_buffer(&rx_buf, 0, data_length); - blockdev_write(target, tx_buf, offset, data_length, 0); - CU_ASSERT_EQUAL(g_completion_success, false); + blockdev_write(target, tx_buf, offset, data_length, 0); + CU_ASSERT_EQUAL(g_completion_success, false); - blockdev_read(target, rx_buf, offset, data_length, 0); - CU_ASSERT_EQUAL(g_completion_success, false); - - target = target->next; - } + blockdev_read(target, rx_buf, offset, data_length, 0); + CU_ASSERT_EQUAL(g_completion_success, false); } static void @@ -837,17 +826,13 @@ blockdev_test_reset(void) { struct io_target *target; - target = g_io_targets; - while (target != NULL) { - blockdev_reset(target); - /* Workaround: NVMe-oF target doesn't support reset yet - so for now - * don't fail the test if it's an NVMe bdev. - */ - if (!spdk_bdev_io_type_supported(target->bdev, SPDK_BDEV_IO_TYPE_NVME_IO)) { - CU_ASSERT_EQUAL(g_completion_success, true); - } - - target = target->next; + target = g_current_io_target; + blockdev_reset(target); + /* Workaround: NVMe-oF target doesn't support reset yet - so for now + * don't fail the test if it's an NVMe bdev. + */ + if (!spdk_bdev_io_type_supported(target->bdev, SPDK_BDEV_IO_TYPE_NVME_IO)) { + CU_ASSERT_EQUAL(g_completion_success, true); } } @@ -933,11 +918,8 @@ blockdev_test_nvme_passthru_rw(void) { struct io_target *target; - target = g_io_targets; - while (target != NULL) { - blockdev_nvme_passthru_rw(target); - target = target->next; - } + target = g_current_io_target; + blockdev_nvme_passthru_rw(target); } static void @@ -966,11 +948,8 @@ blockdev_test_nvme_passthru_vendor_specific(void) { struct io_target *target; - target = g_io_targets; - while (target != NULL) { - blockdev_nvme_passthru_vendor_specific(target); - target = target->next; - } + target = g_current_io_target; + blockdev_nvme_passthru_vendor_specific(target); } static void @@ -992,22 +971,37 @@ stop_init_thread(unsigned num_failures) spdk_event_call(event); } -static void -__run_ut_thread(void *arg1, void *arg2) +static int +suite_init(void) { - CU_pSuite suite = NULL; - unsigned num_failures; - - if (CU_initialize_registry() != CUE_SUCCESS) { - stop_init_thread(CU_get_error()); - return; + if (g_current_io_target == NULL) { + g_current_io_target = g_io_targets; } + return 0; +} - suite = CU_add_suite("components_suite", NULL, NULL); +static int +suite_fini(void) +{ + g_current_io_target = g_current_io_target->next; + return 0; +} + +#define SUITE_NAME_MAX 64 + +static int +__setup_ut_on_single_target(struct io_target *target) +{ + unsigned rc = 0; + CU_pSuite suite = NULL; + char name[SUITE_NAME_MAX]; + + snprintf(name, sizeof(name), "bdevio tests on: %s", spdk_bdev_get_name(target->bdev)); + suite = CU_add_suite(name, suite_init, suite_fini); if (suite == NULL) { CU_cleanup_registry(); - stop_init_thread(CU_get_error()); - return; + rc = CU_get_error(); + return -rc; } if ( @@ -1047,14 +1041,39 @@ __run_ut_thread(void *arg1, void *arg2) blockdev_test_nvme_passthru_vendor_specific) == NULL ) { CU_cleanup_registry(); - stop_init_thread(CU_get_error()); - return; + rc = CU_get_error(); + return -rc; + } + return 0; +} + +static void +__run_ut_thread(void *arg1, void *arg2) +{ + int rc = 0; + struct io_target *target; + unsigned num_failures; + + if (CU_initialize_registry() != CUE_SUCCESS) { + /* CUnit error, probably won't recover */ + rc = CU_get_error(); + stop_init_thread(-rc); } + target = g_io_targets; + while (target != NULL) { + rc = __setup_ut_on_single_target(target); + if (rc < 0) { + /* CUnit error, probably won't recover */ + stop_init_thread(-rc); + } + target = target->next; + } CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); num_failures = CU_get_number_of_failures(); CU_cleanup_registry(); + stop_init_thread(num_failures); }