1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 #include "spdk_cunit.h" 36 #include "nvme/nvme_fabric.c" 37 #include "common/lib/test_env.c" 38 39 SPDK_LOG_REGISTER_COMPONENT(nvme) 40 41 struct spdk_nvmf_fabric_prop_set_cmd g_ut_cmd = {}; 42 struct spdk_nvmf_fabric_prop_get_rsp g_ut_response = {}; 43 44 DEFINE_STUB_V(nvme_completion_poll_cb, (void *arg, const struct spdk_nvme_cpl *cpl)); 45 46 DEFINE_STUB(nvme_wait_for_completion, int, 47 (struct spdk_nvme_qpair *qpair, 48 struct nvme_completion_poll_status *status), 0); 49 50 DEFINE_STUB_V(spdk_nvme_ctrlr_get_default_ctrlr_opts, 51 (struct spdk_nvme_ctrlr_opts *opts, size_t opts_size)); 52 53 DEFINE_STUB(nvme_transport_ctrlr_set_reg_4, int, 54 (struct spdk_nvme_ctrlr *ctrlr, 55 uint32_t offset, uint32_t value), 0); 56 57 DEFINE_STUB_V(nvme_ctrlr_destruct, (struct spdk_nvme_ctrlr *ctrlr)); 58 59 DEFINE_STUB(nvme_ctrlr_cmd_identify, int, 60 (struct spdk_nvme_ctrlr *ctrlr, uint8_t cns, uint16_t cntid, 61 uint32_t nsid, uint8_t csi, void *payload, size_t payload_size, 62 spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 63 64 DEFINE_STUB_V(nvme_ctrlr_connected, (struct spdk_nvme_probe_ctx *probe_ctx, 65 struct spdk_nvme_ctrlr *ctrlr)); 66 DEFINE_STUB(nvme_ctrlr_add_process, int, 67 (struct spdk_nvme_ctrlr *ctrlr, void *devhandle), 0); 68 69 DEFINE_STUB(spdk_nvme_ctrlr_cmd_get_log_page, int, 70 (struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page, 71 uint32_t nsid, void *payload, uint32_t payload_size, 72 uint64_t offset, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 73 74 DEFINE_STUB(spdk_nvme_transport_id_populate_trstring, int, 75 (struct spdk_nvme_transport_id *trid, const char *trstring), 0); 76 77 DEFINE_STUB(spdk_nvme_transport_available_by_name, bool, 78 (const char *transport_name), true); 79 80 DEFINE_STUB(nvme_transport_ctrlr_construct, struct spdk_nvme_ctrlr *, 81 (const struct spdk_nvme_transport_id *trid, 82 const struct spdk_nvme_ctrlr_opts *opts, 83 void *devhandle), NULL); 84 85 DEFINE_STUB(nvme_ctrlr_probe, int, 86 (const struct spdk_nvme_transport_id *trid, 87 struct spdk_nvme_probe_ctx *probe_ctx, void *devhandle), 0); 88 89 DEFINE_STUB(spdk_nvme_ctrlr_cmd_io_raw, int, (struct spdk_nvme_ctrlr *ctrlr, 90 struct spdk_nvme_qpair *qpair, struct spdk_nvme_cmd *cmd, void *buf, 91 uint32_t len, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 92 93 DEFINE_STUB(nvme_wait_for_completion_timeout, int, 94 (struct spdk_nvme_qpair *qpair, 95 struct nvme_completion_poll_status *status, 96 uint64_t timeout_in_usecs), 0); 97 98 DEFINE_STUB(spdk_nvme_transport_id_trtype_str, const char *, 99 (enum spdk_nvme_transport_type trtype), NULL); 100 101 DEFINE_STUB(spdk_nvme_transport_id_adrfam_str, const char *, 102 (enum spdk_nvmf_adrfam adrfam), NULL); 103 104 DEFINE_RETURN_MOCK(spdk_nvme_ctrlr_cmd_admin_raw, int); 105 int 106 spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr *ctrlr, 107 struct spdk_nvme_cmd *cmd, 108 void *buf, uint32_t len, 109 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 110 { 111 struct spdk_nvmf_fabric_prop_set_cmd *cmd_tmp = (void *)cmd; 112 struct nvme_completion_poll_status *status = cb_arg; 113 struct spdk_nvmf_fabric_prop_get_rsp *response = (void *)&status->cpl; 114 115 g_ut_cmd.opcode = cmd_tmp->opcode; 116 g_ut_cmd.fctype = cmd_tmp->fctype; 117 g_ut_cmd.ofst = cmd_tmp->ofst; 118 g_ut_cmd.attrib.size = cmd_tmp->attrib.size; 119 120 if (cmd_tmp->fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_SET) { 121 g_ut_cmd.value.u64 = cmd_tmp->value.u64; 122 } else if (cmd_tmp->fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET) { 123 memcpy(&g_ut_response, response, sizeof(g_ut_response)); 124 } 125 126 HANDLE_RETURN_MOCK(spdk_nvme_ctrlr_cmd_admin_raw); 127 return 0; 128 } 129 130 static void 131 test_nvme_fabric_prop_set_cmd(void) 132 { 133 int rc; 134 struct spdk_nvme_ctrlr ctrlr = {}; 135 136 memset(&g_ut_cmd, 0, sizeof(g_ut_cmd)); 137 138 rc = nvme_fabric_prop_set_cmd(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_8, 4096); 139 CU_ASSERT(rc == 0); 140 CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC); 141 CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_SET); 142 CU_ASSERT(g_ut_cmd.ofst == 1024); 143 CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_8); 144 CU_ASSERT(g_ut_cmd.value.u64 == 4096); 145 } 146 147 static void 148 test_nvme_fabric_prop_get_cmd(void) 149 { 150 int rc; 151 uint64_t value; 152 struct spdk_nvme_ctrlr ctrlr = {}; 153 154 memset(&g_ut_cmd, 0, sizeof(g_ut_cmd)); 155 memset(&g_ut_response, 0, sizeof(g_ut_response)); 156 value = 0xFFDEADBEEF; 157 158 /* Case 1: size is SPDK_NVMF_PROP_SIZE_4 */ 159 rc = nvme_fabric_prop_get_cmd(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_4, &value); 160 CU_ASSERT(rc == 0); 161 CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC); 162 CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET); 163 CU_ASSERT(g_ut_cmd.ofst == 1024); 164 CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_4); 165 CU_ASSERT(g_ut_response.value.u32.low == (value & 0xFFFFFFFF)); 166 167 /* Case 2: size is SPDK_NVMF_PROP_SIZE_8 */ 168 memset(&g_ut_cmd, 0, sizeof(g_ut_cmd)); 169 memset(&g_ut_response, 0, sizeof(g_ut_response)); 170 171 rc = nvme_fabric_prop_get_cmd(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_8, &value); 172 CU_ASSERT(rc == 0); 173 CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC); 174 CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET); 175 CU_ASSERT(g_ut_cmd.ofst == 1024); 176 CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_8); 177 CU_ASSERT(g_ut_response.value.u64 == value); 178 } 179 180 int main(int argc, char **argv) 181 { 182 CU_pSuite suite = NULL; 183 unsigned int num_failures; 184 185 CU_set_error_action(CUEA_ABORT); 186 CU_initialize_registry(); 187 188 suite = CU_add_suite("nvme_fabric", NULL, NULL); 189 CU_ADD_TEST(suite, test_nvme_fabric_prop_set_cmd); 190 CU_ADD_TEST(suite, test_nvme_fabric_prop_get_cmd); 191 192 CU_basic_set_mode(CU_BRM_VERBOSE); 193 CU_basic_run_tests(); 194 num_failures = CU_get_number_of_failures(); 195 CU_cleanup_registry(); 196 return num_failures; 197 } 198