1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2021 Intel Corporation. All rights reserved. 3 */ 4 5 #include "spdk/stdinc.h" 6 #include "spdk_internal/cunit.h" 7 #include "common/lib/test_env.c" 8 #include "nvmf/vfio_user.c" 9 #include "nvmf/transport.c" 10 11 DEFINE_STUB(spdk_nvmf_ctrlr_get_regs, const struct spdk_nvmf_registers *, 12 (struct spdk_nvmf_ctrlr *ctrlr), NULL); 13 DEFINE_STUB(spdk_mem_register, int, (void *vaddr, size_t len), 0); 14 DEFINE_STUB(spdk_mem_unregister, int, (void *vaddr, size_t len), 0); 15 DEFINE_STUB_V(spdk_nvmf_request_exec, (struct spdk_nvmf_request *req)); 16 DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req), 0); 17 DEFINE_STUB_V(spdk_nvmf_tgt_new_qpair, (struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair)); 18 DEFINE_STUB(nvmf_ctrlr_abort_request, int, (struct spdk_nvmf_request *req), 0); 19 DEFINE_STUB(spdk_nvmf_qpair_disconnect, int, (struct spdk_nvmf_qpair *qpair), 0); 20 DEFINE_STUB(spdk_nvmf_subsystem_get_nqn, const char *, 21 (const struct spdk_nvmf_subsystem *subsystem), NULL); 22 DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 512); 23 DEFINE_STUB(spdk_nvmf_subsystem_pause, int, (struct spdk_nvmf_subsystem *subsystem, 24 uint32_t nsid, spdk_nvmf_subsystem_state_change_done cb_fn, void *cb_arg), 0); 25 DEFINE_STUB(spdk_nvmf_subsystem_resume, int, (struct spdk_nvmf_subsystem *subsystem, 26 spdk_nvmf_subsystem_state_change_done cb_fn, void *cb_arg), 0); 27 DEFINE_STUB_V(spdk_nvmf_ctrlr_abort_aer, (struct spdk_nvmf_ctrlr *ctrlr)); 28 DEFINE_STUB(spdk_nvmf_ctrlr_async_event_error_event, int, (struct spdk_nvmf_ctrlr *ctrlr, 29 enum spdk_nvme_async_event_info_error info), 0); 30 DEFINE_STUB(spdk_nvme_transport_id_adrfam_str, const char *, (enum spdk_nvmf_adrfam adrfam), NULL); 31 DEFINE_STUB(spdk_nvmf_qpair_get_listen_trid, int, (struct spdk_nvmf_qpair *qpair, 32 struct spdk_nvme_transport_id *trid), 0); 33 DEFINE_STUB(spdk_nvme_transport_id_compare, int, (const struct spdk_nvme_transport_id *trid1, 34 const struct spdk_nvme_transport_id *trid2), 0); 35 DEFINE_STUB(nvmf_subsystem_get_ctrlr, struct spdk_nvmf_ctrlr *, 36 (struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid), NULL); 37 DEFINE_STUB_V(nvmf_ctrlr_set_fatal_status, (struct spdk_nvmf_ctrlr *ctrlr)); 38 DEFINE_STUB(spdk_nvmf_ctrlr_save_migr_data, int, (struct spdk_nvmf_ctrlr *ctrlr, 39 struct spdk_nvmf_ctrlr_migr_data *data), 0); 40 DEFINE_STUB(spdk_nvmf_ctrlr_restore_migr_data, int, (struct spdk_nvmf_ctrlr *ctrlr, 41 const struct spdk_nvmf_ctrlr_migr_data *data), 0); 42 DEFINE_STUB(spdk_mempool_lookup, struct spdk_mempool *, (const char *name), NULL); 43 DEFINE_STUB(nvmf_subsystem_gen_cntlid, uint16_t, (struct spdk_nvmf_subsystem *subsystem), 1) 44 45 static void * 46 gpa_to_vva(void *prv, uint64_t addr, uint64_t len, uint32_t flags) 47 { 48 return (void *)(uintptr_t)addr; 49 } 50 51 static void 52 test_nvme_cmd_map_prps(void) 53 { 54 struct spdk_nvme_cmd cmd = {}; 55 struct iovec iovs[33]; 56 uint64_t phy_addr, *prp; 57 uint32_t len; 58 void *buf, *prps; 59 int i, ret; 60 size_t mps = 4096; 61 62 buf = spdk_zmalloc(132 * 1024, 4096, &phy_addr, 0, 0); 63 CU_ASSERT(buf != NULL); 64 prps = spdk_zmalloc(4096, 4096, &phy_addr, 0, 0); 65 CU_ASSERT(prps != NULL); 66 67 /* test case 1: 4KiB with PRP1 only */ 68 cmd.dptr.prp.prp1 = (uint64_t)(uintptr_t)buf; 69 len = 4096; 70 ret = nvme_cmd_map_prps(NULL, &cmd, iovs, 33, len, mps, gpa_to_vva); 71 CU_ASSERT(ret == 1); 72 CU_ASSERT(iovs[0].iov_base == (void *)(uintptr_t)cmd.dptr.prp.prp1); 73 CU_ASSERT(iovs[0].iov_len == len); 74 75 /* test case 2: 4KiB with PRP1 and PRP2, 1KiB in first iov, and 3KiB in second iov */ 76 cmd.dptr.prp.prp1 = (uint64_t)(uintptr_t)buf + 1024 * 3; 77 cmd.dptr.prp.prp2 = (uint64_t)(uintptr_t)buf + 4096; 78 len = 4096; 79 ret = nvme_cmd_map_prps(NULL, &cmd, iovs, 1, len, mps, gpa_to_vva); 80 CU_ASSERT(ret == -ERANGE); 81 ret = nvme_cmd_map_prps(NULL, &cmd, iovs, 33, len, mps, gpa_to_vva); 82 CU_ASSERT(ret == 2); 83 CU_ASSERT(iovs[0].iov_base == (void *)(uintptr_t)cmd.dptr.prp.prp1); 84 CU_ASSERT(iovs[0].iov_len == 1024); 85 CU_ASSERT(iovs[1].iov_base == (void *)(uintptr_t)cmd.dptr.prp.prp2); 86 CU_ASSERT(iovs[1].iov_len == 1024 * 3); 87 88 /* test case 3: 128KiB with PRP list, 1KiB in first iov, 3KiB in last iov */ 89 cmd.dptr.prp.prp1 = (uint64_t)(uintptr_t)buf + 1024 * 3; 90 cmd.dptr.prp.prp2 = (uint64_t)(uintptr_t)prps; 91 len = 128 * 1024; 92 prp = prps; 93 for (i = 1; i < 33; i++) { 94 *prp = (uint64_t)(uintptr_t)buf + i * 4096; 95 prp++; 96 } 97 ret = nvme_cmd_map_prps(NULL, &cmd, iovs, 33, len, mps, gpa_to_vva); 98 CU_ASSERT(ret == 33); 99 CU_ASSERT(iovs[0].iov_base == (void *)(uintptr_t)cmd.dptr.prp.prp1); 100 CU_ASSERT(iovs[0].iov_len == 1024); 101 for (i = 1; i < 32; i++) { 102 CU_ASSERT(iovs[i].iov_base == (void *)((uintptr_t)buf + i * 4096)); 103 CU_ASSERT(iovs[i].iov_len == 4096); 104 } 105 CU_ASSERT(iovs[32].iov_base == (void *)((uintptr_t)buf + 32 * 4096)); 106 CU_ASSERT(iovs[32].iov_len == 1024 * 3); 107 108 /* test case 4: 256KiB with PRP list, not enough iovs */ 109 cmd.dptr.prp.prp1 = (uint64_t)(uintptr_t)buf + 1024 * 3; 110 cmd.dptr.prp.prp2 = (uint64_t)(uintptr_t)prps; 111 len = 256 * 1024; 112 ret = nvme_cmd_map_prps(NULL, &cmd, iovs, 33, len, mps, gpa_to_vva); 113 CU_ASSERT(ret == -ERANGE); 114 115 spdk_free(buf); 116 spdk_free(prps); 117 } 118 119 static void 120 test_nvme_cmd_map_sgls(void) 121 { 122 struct spdk_nvme_cmd cmd = {}; 123 struct iovec iovs[33]; 124 uint64_t phy_addr; 125 uint32_t len; 126 void *buf, *sgls; 127 struct spdk_nvme_sgl_descriptor *sgl; 128 int i, ret; 129 size_t mps = 4096; 130 131 buf = spdk_zmalloc(132 * 1024, 4096, &phy_addr, 0, 0); 132 CU_ASSERT(buf != NULL); 133 sgls = spdk_zmalloc(4096, 4096, &phy_addr, 0, 0); 134 CU_ASSERT(sgls != NULL); 135 136 /* test case 1: 8KiB with 1 data block */ 137 len = 8192; 138 cmd.dptr.sgl1.unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 139 cmd.dptr.sgl1.unkeyed.length = len; 140 cmd.dptr.sgl1.address = (uint64_t)(uintptr_t)buf; 141 142 ret = nvme_cmd_map_sgls(NULL, &cmd, iovs, 33, len, mps, gpa_to_vva); 143 CU_ASSERT(ret == 1); 144 CU_ASSERT(iovs[0].iov_base == buf); 145 CU_ASSERT(iovs[0].iov_len == 8192); 146 147 /* test case 2: 8KiB with 2 data blocks and 1 last segment */ 148 sgl = (struct spdk_nvme_sgl_descriptor *)sgls; 149 sgl[0].unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 150 sgl[0].unkeyed.length = 2048; 151 sgl[0].address = (uint64_t)(uintptr_t)buf; 152 sgl[1].unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 153 sgl[1].unkeyed.length = len - 2048; 154 sgl[1].address = (uint64_t)(uintptr_t)buf + 16 * 1024; 155 156 cmd.dptr.sgl1.unkeyed.type = SPDK_NVME_SGL_TYPE_LAST_SEGMENT; 157 cmd.dptr.sgl1.unkeyed.length = 2 * sizeof(*sgl); 158 cmd.dptr.sgl1.address = (uint64_t)(uintptr_t)sgls; 159 160 ret = nvme_cmd_map_sgls(NULL, &cmd, iovs, 33, len, mps, gpa_to_vva); 161 CU_ASSERT(ret == 2); 162 CU_ASSERT(iovs[0].iov_base == (void *)(uintptr_t)buf); 163 CU_ASSERT(iovs[0].iov_len == 2048); 164 CU_ASSERT(iovs[1].iov_base == (void *)((uintptr_t)buf + 16 * 1024)); 165 CU_ASSERT(iovs[1].iov_len == len - 2048); 166 167 /* test case 3: 8KiB with 1 segment, 1 last segment and 3 data blocks */ 168 sgl[0].unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 169 sgl[0].unkeyed.length = 2048; 170 sgl[0].address = (uint64_t)(uintptr_t)buf; 171 sgl[1].unkeyed.type = SPDK_NVME_SGL_TYPE_LAST_SEGMENT; 172 sgl[1].unkeyed.length = 2 * sizeof(*sgl); 173 sgl[1].address = (uint64_t)(uintptr_t)&sgl[9]; 174 175 sgl[9].unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 176 sgl[9].unkeyed.length = 4096; 177 sgl[9].address = (uint64_t)(uintptr_t)buf + 4 * 1024; 178 sgl[10].unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 179 sgl[10].unkeyed.length = 2048; 180 sgl[10].address = (uint64_t)(uintptr_t)buf + 16 * 1024; 181 182 cmd.dptr.sgl1.unkeyed.type = SPDK_NVME_SGL_TYPE_SEGMENT; 183 cmd.dptr.sgl1.unkeyed.length = 2 * sizeof(*sgl); 184 cmd.dptr.sgl1.address = (uint64_t)(uintptr_t)&sgl[0]; 185 186 ret = nvme_cmd_map_sgls(NULL, &cmd, iovs, 33, len, mps, gpa_to_vva); 187 CU_ASSERT(ret == 3); 188 CU_ASSERT(iovs[0].iov_base == (void *)(uintptr_t)buf); 189 CU_ASSERT(iovs[0].iov_len == 2048); 190 CU_ASSERT(iovs[1].iov_base == (void *)((uintptr_t)buf + 4 * 1024)); 191 CU_ASSERT(iovs[1].iov_len == 4096); 192 CU_ASSERT(iovs[2].iov_base == (void *)((uintptr_t)buf + 16 * 1024)); 193 CU_ASSERT(iovs[2].iov_len == 2048); 194 195 /* test case 4: not enough iovs */ 196 len = 12 * 1024; 197 for (i = 0; i < 6; i++) { 198 sgl[0].unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 199 sgl[0].unkeyed.length = 2048; 200 sgl[0].address = (uint64_t)(uintptr_t)buf + i * 4096; 201 } 202 203 cmd.dptr.sgl1.unkeyed.type = SPDK_NVME_SGL_TYPE_LAST_SEGMENT; 204 cmd.dptr.sgl1.unkeyed.length = 6 * sizeof(*sgl); 205 cmd.dptr.sgl1.address = (uint64_t)(uintptr_t)sgls; 206 207 ret = nvme_cmd_map_sgls(NULL, &cmd, iovs, 4, len, mps, gpa_to_vva); 208 CU_ASSERT(ret == -ERANGE); 209 210 spdk_free(buf); 211 spdk_free(sgls); 212 } 213 214 static void 215 ut_transport_destroy_done_cb(void *cb_arg) 216 { 217 int *done = cb_arg; 218 *done = 1; 219 } 220 221 static void 222 test_nvmf_vfio_user_create_destroy(void) 223 { 224 struct spdk_nvmf_transport *transport = NULL; 225 struct nvmf_vfio_user_transport *vu_transport = NULL; 226 struct nvmf_vfio_user_endpoint *endpoint = NULL; 227 struct spdk_nvmf_transport_opts opts = {}; 228 int rc; 229 int done; 230 231 /* Initialize transport_specific NULL to avoid decoding json */ 232 opts.transport_specific = NULL; 233 234 transport = nvmf_vfio_user_create(&opts); 235 CU_ASSERT(transport != NULL); 236 237 vu_transport = SPDK_CONTAINEROF(transport, struct nvmf_vfio_user_transport, 238 transport); 239 /* Allocate a endpoint for destroy */ 240 endpoint = calloc(1, sizeof(*endpoint)); 241 pthread_mutex_init(&endpoint->lock, NULL); 242 TAILQ_INSERT_TAIL(&vu_transport->endpoints, endpoint, link); 243 done = 0; 244 245 rc = nvmf_vfio_user_destroy(transport, ut_transport_destroy_done_cb, &done); 246 CU_ASSERT(rc == 0); 247 CU_ASSERT(done == 1); 248 } 249 250 int 251 main(int argc, char **argv) 252 { 253 CU_pSuite suite = NULL; 254 unsigned int num_failures; 255 256 CU_initialize_registry(); 257 258 suite = CU_add_suite("vfio_user", NULL, NULL); 259 260 CU_ADD_TEST(suite, test_nvme_cmd_map_prps); 261 CU_ADD_TEST(suite, test_nvme_cmd_map_sgls); 262 CU_ADD_TEST(suite, test_nvmf_vfio_user_create_destroy); 263 264 num_failures = spdk_ut_run_tests(argc, argv, NULL); 265 CU_cleanup_registry(); 266 return num_failures; 267 } 268