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 "common/lib/test_env.c" 37 #include "nvmf/rdma.c" 38 39 uint64_t g_mr_size; 40 struct ibv_mr g_rdma_mr; 41 42 #define RDMA_UT_UNITS_IN_MAX_IO 16 43 44 struct spdk_nvmf_transport_opts g_rdma_ut_transport_opts = { 45 .max_queue_depth = SPDK_NVMF_RDMA_DEFAULT_MAX_QUEUE_DEPTH, 46 .max_qpairs_per_ctrlr = SPDK_NVMF_RDMA_DEFAULT_MAX_QPAIRS_PER_CTRLR, 47 .in_capsule_data_size = SPDK_NVMF_RDMA_DEFAULT_IN_CAPSULE_DATA_SIZE, 48 .max_io_size = (SPDK_NVMF_RDMA_DEFAULT_IO_BUFFER_SIZE * RDMA_UT_UNITS_IN_MAX_IO), 49 .io_unit_size = SPDK_NVMF_RDMA_DEFAULT_IO_BUFFER_SIZE, 50 .max_aq_depth = SPDK_NVMF_RDMA_DEFAULT_AQ_DEPTH, 51 }; 52 53 SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) 54 DEFINE_STUB(spdk_mem_map_set_translation, int, (struct spdk_mem_map *map, uint64_t vaddr, 55 uint64_t size, uint64_t translation), 0); 56 DEFINE_STUB(spdk_mem_map_clear_translation, int, (struct spdk_mem_map *map, uint64_t vaddr, 57 uint64_t size), 0); 58 DEFINE_STUB(spdk_mem_map_alloc, struct spdk_mem_map *, (uint64_t default_translation, 59 const struct spdk_mem_map_ops *ops, void *cb_ctx), NULL); 60 DEFINE_STUB(spdk_nvmf_qpair_disconnect, int, (struct spdk_nvmf_qpair *qpair, 61 nvmf_qpair_disconnect_cb cb_fn, void *ctx), 0); 62 DEFINE_STUB_V(spdk_mem_map_free, (struct spdk_mem_map **pmap)); 63 64 struct spdk_trace_histories *g_trace_histories; 65 DEFINE_STUB_V(spdk_trace_add_register_fn, (struct spdk_trace_register_fn *reg_fn)); 66 DEFINE_STUB_V(spdk_trace_register_object, (uint8_t type, char id_prefix)); 67 DEFINE_STUB_V(spdk_trace_register_description, (const char *name, const char *short_name, 68 uint16_t tpoint_id, uint8_t owner_type, uint8_t object_type, uint8_t new_object, 69 uint8_t arg1_is_ptr, const char *arg1_name)); 70 DEFINE_STUB_V(_spdk_trace_record, (uint64_t tsc, uint16_t tpoint_id, uint16_t poller_id, 71 uint32_t size, uint64_t object_id, uint64_t arg1)); 72 73 DEFINE_STUB_V(spdk_nvmf_request_exec, (struct spdk_nvmf_request *req)); 74 DEFINE_STUB(spdk_nvme_transport_id_compare, int, (const struct spdk_nvme_transport_id *trid1, 75 const struct spdk_nvme_transport_id *trid2), 0); 76 DEFINE_STUB_V(spdk_nvmf_ctrlr_abort_aer, (struct spdk_nvmf_ctrlr *ctrlr)); 77 78 uint64_t 79 spdk_mem_map_translate(const struct spdk_mem_map *map, uint64_t vaddr, uint64_t *size) 80 { 81 if (g_mr_size != 0) { 82 *(uint32_t *)size = g_mr_size; 83 } 84 85 return (uint64_t)&g_rdma_mr; 86 } 87 88 static void reset_nvmf_rdma_request(struct spdk_nvmf_rdma_request *rdma_req) 89 { 90 int i; 91 92 rdma_req->req.length = 0; 93 rdma_req->data_from_pool = false; 94 rdma_req->req.data = NULL; 95 rdma_req->data.wr.num_sge = 0; 96 rdma_req->data.wr.wr.rdma.remote_addr = 0; 97 rdma_req->data.wr.wr.rdma.rkey = 0; 98 99 for (i = 0; i < SPDK_NVMF_MAX_SGL_ENTRIES; i++) { 100 rdma_req->req.iov[i].iov_base = 0; 101 rdma_req->req.iov[i].iov_len = 0; 102 rdma_req->data.buffers[i] = 0; 103 rdma_req->data.wr.sg_list[i].addr = 0; 104 rdma_req->data.wr.sg_list[i].length = 0; 105 rdma_req->data.wr.sg_list[i].lkey = 0; 106 } 107 } 108 109 static void 110 test_spdk_nvmf_rdma_request_parse_sgl(void) 111 { 112 struct spdk_nvmf_rdma_transport rtransport; 113 struct spdk_nvmf_rdma_device device; 114 struct spdk_nvmf_rdma_request rdma_req; 115 struct spdk_nvmf_rdma_recv recv; 116 union nvmf_c2h_msg cpl; 117 union nvmf_h2c_msg cmd; 118 struct spdk_nvme_sgl_descriptor *sgl; 119 int rc, i; 120 121 sgl = &cmd.nvme_cmd.dptr.sgl1; 122 rdma_req.recv = &recv; 123 rdma_req.req.cmd = &cmd; 124 rdma_req.req.rsp = &cpl; 125 rdma_req.data.wr.sg_list = rdma_req.data.sgl; 126 127 rtransport.transport.opts = g_rdma_ut_transport_opts; 128 129 device.attr.device_cap_flags = 0; 130 g_rdma_mr.lkey = 0xABCD; 131 sgl->keyed.key = 0xEEEE; 132 sgl->address = 0xFFFF; 133 rdma_req.recv->buf = (void *)0xDDDD; 134 135 /* Test 1: sgl type: keyed data block subtype: address */ 136 sgl->generic.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; 137 sgl->keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; 138 139 /* Part 1: simple I/O, one SGL smaller than the transport io unit size */ 140 MOCK_SET(spdk_mempool_get, (void *)0x2000); 141 reset_nvmf_rdma_request(&rdma_req); 142 sgl->keyed.length = rtransport.transport.opts.io_unit_size / 2; 143 144 rc = spdk_nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); 145 CU_ASSERT(rc == 0); 146 CU_ASSERT(rdma_req.data_from_pool == true); 147 CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size / 2); 148 CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); 149 CU_ASSERT(rdma_req.data.wr.num_sge == 1); 150 CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); 151 CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); 152 CU_ASSERT((uint64_t)rdma_req.data.buffers[0] == 0x2000); 153 CU_ASSERT(rdma_req.data.wr.sg_list[0].addr == 0x2000); 154 CU_ASSERT(rdma_req.data.wr.sg_list[0].length == rtransport.transport.opts.io_unit_size / 2); 155 CU_ASSERT(rdma_req.data.wr.sg_list[0].lkey == g_rdma_mr.lkey); 156 157 /* Part 2: simple I/O, one SGL larger than the transport io unit size (equal to the max io size) */ 158 reset_nvmf_rdma_request(&rdma_req); 159 sgl->keyed.length = rtransport.transport.opts.io_unit_size * RDMA_UT_UNITS_IN_MAX_IO; 160 rc = spdk_nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); 161 162 CU_ASSERT(rc == 0); 163 CU_ASSERT(rdma_req.data_from_pool == true); 164 CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * RDMA_UT_UNITS_IN_MAX_IO); 165 CU_ASSERT(rdma_req.data.wr.num_sge == RDMA_UT_UNITS_IN_MAX_IO); 166 CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); 167 CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); 168 for (i = 0; i < RDMA_UT_UNITS_IN_MAX_IO; i++) { 169 CU_ASSERT((uint64_t)rdma_req.data.buffers[i] == 0x2000); 170 CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000); 171 CU_ASSERT(rdma_req.data.wr.sg_list[i].length == rtransport.transport.opts.io_unit_size); 172 CU_ASSERT(rdma_req.data.wr.sg_list[i].lkey == g_rdma_mr.lkey); 173 } 174 175 /* Part 3: simple I/O one SGL larger than the transport max io size */ 176 reset_nvmf_rdma_request(&rdma_req); 177 sgl->keyed.length = rtransport.transport.opts.max_io_size * 2; 178 rc = spdk_nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); 179 180 CU_ASSERT(rc == -1); 181 182 /* Part 4: Pretend there are no buffer pools */ 183 MOCK_SET(spdk_mempool_get, NULL); 184 reset_nvmf_rdma_request(&rdma_req); 185 sgl->keyed.length = rtransport.transport.opts.io_unit_size * RDMA_UT_UNITS_IN_MAX_IO; 186 rc = spdk_nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); 187 188 CU_ASSERT(rc == 0); 189 CU_ASSERT(rdma_req.data_from_pool == false); 190 CU_ASSERT(rdma_req.req.data == NULL); 191 CU_ASSERT(rdma_req.data.wr.num_sge == 0); 192 CU_ASSERT(rdma_req.data.buffers[0] == NULL); 193 CU_ASSERT(rdma_req.data.wr.sg_list[0].addr == 0); 194 CU_ASSERT(rdma_req.data.wr.sg_list[0].length == 0); 195 CU_ASSERT(rdma_req.data.wr.sg_list[0].lkey == 0); 196 197 198 rdma_req.recv->buf = (void *)0xDDDD; 199 /* Test 2: sgl type: keyed data block subtype: offset (in capsule data) */ 200 sgl->generic.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; 201 sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_OFFSET; 202 203 /* Part 1: Normal I/O smaller than in capsule data size no offset */ 204 reset_nvmf_rdma_request(&rdma_req); 205 sgl->address = 0; 206 sgl->unkeyed.length = rtransport.transport.opts.in_capsule_data_size; 207 rc = spdk_nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); 208 209 CU_ASSERT(rc == 0); 210 CU_ASSERT(rdma_req.req.data == (void *)0xDDDD); 211 CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.in_capsule_data_size); 212 CU_ASSERT(rdma_req.data_from_pool == false); 213 214 /* Part 2: I/O offset + length too large */ 215 reset_nvmf_rdma_request(&rdma_req); 216 sgl->address = rtransport.transport.opts.in_capsule_data_size; 217 sgl->unkeyed.length = rtransport.transport.opts.in_capsule_data_size; 218 rc = spdk_nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); 219 220 CU_ASSERT(rc == -1); 221 222 /* Part 3: I/O too large */ 223 reset_nvmf_rdma_request(&rdma_req); 224 sgl->address = 0; 225 sgl->unkeyed.length = rtransport.transport.opts.in_capsule_data_size * 2; 226 rc = spdk_nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); 227 228 CU_ASSERT(rc == -1); 229 } 230 231 int main(int argc, char **argv) 232 { 233 CU_pSuite suite = NULL; 234 unsigned int num_failures; 235 236 if (CU_initialize_registry() != CUE_SUCCESS) { 237 return CU_get_error(); 238 } 239 240 suite = CU_add_suite("nvmf", NULL, NULL); 241 if (suite == NULL) { 242 CU_cleanup_registry(); 243 return CU_get_error(); 244 } 245 246 if ( 247 CU_add_test(suite, "test_parse_sgl", test_spdk_nvmf_rdma_request_parse_sgl) == NULL) { 248 CU_cleanup_registry(); 249 return CU_get_error(); 250 } 251 252 CU_basic_set_mode(CU_BRM_VERBOSE); 253 CU_basic_run_tests(); 254 num_failures = CU_get_number_of_failures(); 255 CU_cleanup_registry(); 256 return num_failures; 257 } 258