From 77e4ebe8b2a366899778388b0cb67db36b217332 Mon Sep 17 00:00:00 2001 From: Daniel Verkamp Date: Tue, 6 Sep 2016 15:29:58 -0700 Subject: [PATCH] scsi: import initialization unit test Change-Id: I10729699c539b2e28ee09444238cb6b65606c8bc Signed-off-by: Daniel Verkamp --- test/lib/scsi/Makefile | 2 +- test/lib/scsi/init/Makefile | 58 +++++ test/lib/scsi/init/init_ut.c | 421 +++++++++++++++++++++++++++++++++++ test/lib/scsi/scsi.sh | 1 + 4 files changed, 481 insertions(+), 1 deletion(-) create mode 100644 test/lib/scsi/init/Makefile create mode 100644 test/lib/scsi/init/init_ut.c diff --git a/test/lib/scsi/Makefile b/test/lib/scsi/Makefile index 295ce65c3..500783718 100644 --- a/test/lib/scsi/Makefile +++ b/test/lib/scsi/Makefile @@ -34,7 +34,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..) include $(SPDK_ROOT_DIR)/mk/spdk.common.mk -DIRS-y = dev lun scsi_bdev +DIRS-y = dev init lun scsi_bdev .PHONY: all clean $(DIRS-y) diff --git a/test/lib/scsi/init/Makefile b/test/lib/scsi/init/Makefile new file mode 100644 index 000000000..fd30772a7 --- /dev/null +++ b/test/lib/scsi/init/Makefile @@ -0,0 +1,58 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../..) +include $(SPDK_ROOT_DIR)/mk/spdk.common.mk + +SPDK_LIBS += $(SPDK_ROOT_DIR)/lib/log/libspdk_log.a \ + $(SPDK_ROOT_DIR)/lib/conf/libspdk_conf.a \ + $(SPDK_ROOT_DIR)/lib/trace/libspdk_trace.a \ + $(SPDK_ROOT_DIR)/lib/util/libspdk_util.a + +CFLAGS += -I$(SPDK_ROOT_DIR)/lib/scsi +LIBS += $(SPDK_LIBS) +LIBS += $(DPDK_LIB) +LIBS += -lcunit + +APP = init_ut +C_SRCS = init_ut.c + +all: $(APP) + +$(APP): $(OBJS) $(SPDK_LIBS) + $(LINK_C) + +clean: + $(CLEAN_C) $(APP) + +include $(SPDK_ROOT_DIR)/mk/spdk.deps.mk diff --git a/test/lib/scsi/init/init_ut.c b/test/lib/scsi/init/init_ut.c new file mode 100644 index 000000000..3de26fcfb --- /dev/null +++ b/test/lib/scsi/init/init_ut.c @@ -0,0 +1,421 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +#include "spdk/event.h" +#include "spdk/scsi.h" + +#include "CUnit/Basic.h" + +#include "scsi.c" + +/* Unit test stubbed bdev subsystem dependency */ +SPDK_SUBSYSTEM_REGISTER(bdev, NULL, NULL, NULL) + +static int +null_init(void) +{ + return 0; +} + +static int +null_clean(void) +{ + return 0; +} + +void +spdk_add_subsystem(struct spdk_subsystem *subsystem) +{ +} + +void +spdk_add_subsystem_depend(struct spdk_subsystem_depend *depend) +{ +} + +static struct spdk_conf * +spdk_config_init_scsi_params(char *key, char *value) +{ + struct spdk_conf *spdk_config; + struct spdk_conf_section *sp; + struct spdk_conf_item *ip; + struct spdk_conf_value *val; + + spdk_config = calloc(1, sizeof(struct spdk_conf)); + if (!spdk_config) { + perror("spdk_config"); + return NULL; + } + + sp = calloc(1, sizeof(struct spdk_conf_section)); + if (!sp) { + perror("sp"); + free(spdk_config); + return NULL; + } + + ip = calloc(1, sizeof(struct spdk_conf_item)); + if (!ip) { + perror("ip"); + free(spdk_config); + free(sp); + return NULL; + } + + val = calloc(1, sizeof(struct spdk_conf_value)); + if (!val) { + perror("val"); + free(spdk_config); + free(sp); + free(ip); + return NULL; + } + + sp->name = "Scsi"; + ip->key = malloc(strlen(key) + 1); + if (!ip->key) { + free(spdk_config); + free(sp); + free(ip); + free(val); + return NULL; + } + val->value = malloc(strlen(value) + 1); + if (!val->value) { + free(spdk_config); + free(sp); + free(ip->key); + free(ip); + free(val); + return NULL; + } + strcpy(ip->key, key); + strcpy(val->value, value); + + ip->val = val; + sp->item = ip; + spdk_config->section = sp; + + spdk_conf_set_as_default(spdk_config); + + return spdk_config; +} + +static void +set_default_scsi_params(struct spdk_scsi_parameters *params) +{ + memset(params, 0, sizeof(*params)); + params->max_unmap_lba_count = DEFAULT_MAX_UNMAP_LBA_COUNT; + params->max_unmap_block_descriptor_count = DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT; + params->optimal_unmap_granularity = DEFAULT_OPTIMAL_UNMAP_GRANULARITY; + params->unmap_granularity_alignment = DEFAULT_UNMAP_GRANULARITY_ALIGNMENT; + params->ugavalid = DEFAULT_UGAVALID; + params->max_write_same_length = DEFAULT_MAX_WRITE_SAME_LENGTH; +} + +static void +scsi_init_sp_null(void) +{ + struct spdk_conf config; + int rc; + + memset(&config, 0, sizeof(config)); + + spdk_conf_set_as_default(&config); + + rc = spdk_scsi_subsystem_init(); + + /* sp = null; set default scsi params */ + CU_ASSERT_EQUAL(rc, 0); + + spdk_conf_set_as_default(NULL); +} + +static void +scsi_init_set_max_unmap_lba_count_config_param(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* set scsi_params.max_unmap_lba_count = 65536 of Scsi section*/ + config = spdk_config_init_scsi_params("MaxUnmapLbaCount", "65536"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Assert the scsi_params.max_unmap_lba_count == 65536 and + * assert the rest of the params are set to their default values */ + set_default_scsi_params(¶ms); + params.max_unmap_lba_count = 65536; + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_set_max_unmap_block_descriptor_count_config_param(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* set scsi_params.max_unmap_block_descriptor_count = 1 + * of Scsi section*/ + config = spdk_config_init_scsi_params("MaxUnmapBlockDescriptorCount", "1"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Assert the scsi_params.max_unmap_block_descriptor_count == 1 and + * assert the rest of the params are set to their default values */ + set_default_scsi_params(¶ms); + params.max_unmap_block_descriptor_count = 1; + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_set_optimal_unmap_granularity_config_param(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* set scsi_params.optimal_unmap_granularity = 0 + * of Scsi section*/ + config = spdk_config_init_scsi_params("OptimalUnmapGranularity", "0"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Assert the scsi_params.optimal_unmap_granularity == 0 and + * assert the rest of the params are set to their default values */ + set_default_scsi_params(¶ms); + params.optimal_unmap_granularity = 0; + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_set_unmap_granularity_alignment_config_param(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* set scsi_params.unmap_granularity_alignment = 0 + * of Scsi section*/ + config = spdk_config_init_scsi_params("UnmapGranularityAlignment", "0"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Assert the scsi_params.unmap_granularity_alignment == 0 and + * assert the rest of the params are set to their default values */ + set_default_scsi_params(¶ms); + params.unmap_granularity_alignment = 0; + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_ugavalid_yes(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* set scsi_params.ugavalid = Yes + * of Scsi section*/ + config = spdk_config_init_scsi_params("Ugavalid", "Yes"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Assert the scsi_params.ugavalid == 1 and + * assert the rest of the params are set to their default values */ + set_default_scsi_params(¶ms); + params.ugavalid = 1; + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_ugavalid_no(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* set scsi_params.ugavalid = No + * of Scsi section*/ + config = spdk_config_init_scsi_params("Ugavalid", "No"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Assert the scsi_params.ugavalid == 0 and + * assert the rest of the params are set to their default values */ + set_default_scsi_params(¶ms); + params.ugavalid = 0; + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_ugavalid_unknown_value_failure(void) +{ + int rc; + struct spdk_conf *config; + + /* set scsi_params.ugavalid = unknown value + * of Scsi section*/ + config = spdk_config_init_scsi_params("Ugavalid", "unknown value"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* returns -1 since scsi_params.ugavalid is set to + * 'unknown value' */ + CU_ASSERT_TRUE(rc < 0); +} + +static void +scsi_init_max_write_same_length(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* set scsi_params.max_write_same_length = 512 + * of Scsi section*/ + config = spdk_config_init_scsi_params("MaxWriteSameLength", "512"); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Assert the scsi_params.max_write_same_length == 512 and + * assert the rest of the params are set to their default values */ + set_default_scsi_params(¶ms); + params.max_write_same_length = 512; + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_read_config_scsi_params(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* Set null for item's key and value; + * set default scsi parameters */ + config = spdk_config_init_scsi_params("", ""); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Sets the default values for all the parameters + * of the Scsi section and returns success */ + set_default_scsi_params(¶ms); + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +static void +scsi_init_success(void) +{ + struct spdk_scsi_parameters params; + struct spdk_conf *config; + int rc; + + /* Set null for item's key and value; + * set default scsi parameters */ + config = spdk_config_init_scsi_params("", ""); + spdk_conf_set_as_default(config); + rc = spdk_scsi_subsystem_init(); + + /* Sets the default values for all the parameters + * of the Scsi section, initialize th device + * and returns success */ + set_default_scsi_params(¶ms); + CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, ¶ms, sizeof(params)) == 0); + CU_ASSERT_EQUAL(rc, 0); +} + +int +main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + if (CU_initialize_registry() != CUE_SUCCESS) { + return CU_get_error(); + } + + suite = CU_add_suite("scsi_suite", null_init, null_clean); + if (suite == NULL) { + CU_cleanup_registry(); + return CU_get_error(); + } + + if ( + CU_add_test(suite, "scsi init - set default scsi params", \ + scsi_init_sp_null) == NULL + || CU_add_test(suite, "scsi init - set max_unmap_lba_count", \ + scsi_init_set_max_unmap_lba_count_config_param) == NULL + || CU_add_test(suite, "scsi init - set max_unmap_block_descriptor_count", \ + scsi_init_set_max_unmap_block_descriptor_count_config_param) == NULL + || CU_add_test(suite, "scsi init - set optimal_unmap_granularity", \ + scsi_init_set_optimal_unmap_granularity_config_param) == NULL + || CU_add_test(suite, "scsi init - set unmap_granularity_alignment", \ + scsi_init_set_unmap_granularity_alignment_config_param) == NULL + || CU_add_test(suite, "scsi init - ugavalid value yes", \ + scsi_init_ugavalid_yes) == NULL + || CU_add_test(suite, "scsi init - ugavalid value no", \ + scsi_init_ugavalid_no) == NULL + || CU_add_test(suite, "scsi init - ugavalid unknown value", \ + scsi_init_ugavalid_unknown_value_failure) == NULL + || CU_add_test(suite, "scsi init - set max_write_same_length", \ + scsi_init_max_write_same_length) == NULL + || CU_add_test(suite, "scsi init - read config scsi parameters", \ + scsi_init_read_config_scsi_params) == NULL + || CU_add_test(suite, "scsi init - success", scsi_init_success) == NULL + ) { + CU_cleanup_registry(); + return CU_get_error(); + } + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + return num_failures; +} diff --git a/test/lib/scsi/scsi.sh b/test/lib/scsi/scsi.sh index 9dd01128b..fcf5ce98c 100755 --- a/test/lib/scsi/scsi.sh +++ b/test/lib/scsi/scsi.sh @@ -9,6 +9,7 @@ source $rootdir/scripts/autotest_common.sh timing_enter scsi $testdir/dev/dev_ut +$testdir/init/init_ut $testdir/lun/lun_ut $testdir/scsi_bdev/scsi_bdev_ut