1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2018 Intel Corporation. 3 * All rights reserved. 4 * Copyright (c) 2021, 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk/stdinc.h" 8 #include "spdk/nvmf_spec.h" 9 #include "spdk_internal/cunit.h" 10 #include "spdk/bdev_zone.h" 11 12 #include "common/lib/test_env.c" 13 #include "common/lib/test_sock.c" 14 15 #include "nvmf/ctrlr.c" 16 #include "nvmf/tcp.c" 17 #include "spdk/sock.h" 18 #include "spdk/hexlify.h" 19 20 #define UT_IPV4_ADDR "192.168.0.1" 21 #define UT_PORT "4420" 22 #define UT_NVMF_ADRFAM_INVALID 0xf 23 #define UT_MAX_QUEUE_DEPTH 128 24 #define UT_MAX_QPAIRS_PER_CTRLR 128 25 #define UT_IN_CAPSULE_DATA_SIZE 1024 26 #define UT_MAX_IO_SIZE 4096 27 #define UT_IO_UNIT_SIZE 1024 28 #define UT_MAX_AQ_DEPTH 64 29 #define UT_SQ_HEAD_MAX 128 30 #define UT_NUM_SHARED_BUFFERS 128 31 32 static void *g_accel_p = (void *)0xdeadbeaf; 33 34 SPDK_LOG_REGISTER_COMPONENT(nvmf) 35 36 DEFINE_STUB(spdk_nvmf_qpair_get_listen_trid, 37 int, 38 (struct spdk_nvmf_qpair *qpair, struct spdk_nvme_transport_id *trid), 39 0); 40 DEFINE_STUB(spdk_nvmf_qpair_disconnect, int, (struct spdk_nvmf_qpair *qpair), 0); 41 42 DEFINE_STUB(nvmf_subsystem_add_ctrlr, 43 int, 44 (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr), 45 0); 46 47 DEFINE_STUB(nvmf_subsystem_get_ctrlr, 48 struct spdk_nvmf_ctrlr *, 49 (struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid), 50 NULL); 51 52 DEFINE_STUB(spdk_nvmf_tgt_find_subsystem, 53 struct spdk_nvmf_subsystem *, 54 (struct spdk_nvmf_tgt *tgt, const char *subnqn), 55 NULL); 56 57 DEFINE_STUB(spdk_nvmf_subsystem_listener_allowed, 58 bool, 59 (struct spdk_nvmf_subsystem *subsystem, const struct spdk_nvme_transport_id *trid), 60 true); 61 62 DEFINE_STUB(nvmf_subsystem_find_listener, 63 struct spdk_nvmf_subsystem_listener *, 64 (struct spdk_nvmf_subsystem *subsystem, 65 const struct spdk_nvme_transport_id *trid), 66 (void *)0x1); 67 68 DEFINE_STUB(spdk_nvmf_ns_find_host, 69 struct spdk_nvmf_host *, 70 (struct spdk_nvmf_ns *ns, const char *hostnqn), 71 NULL); 72 73 DEFINE_STUB_V(nvmf_get_discovery_log_page, 74 (struct spdk_nvmf_tgt *tgt, const char *hostnqn, struct iovec *iov, 75 uint32_t iovcnt, uint64_t offset, uint32_t length, struct spdk_nvme_transport_id *cmd_src_trid)); 76 77 DEFINE_STUB_V(nvmf_subsystem_remove_ctrlr, 78 (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr)); 79 80 DEFINE_STUB(spdk_nvmf_subsystem_get_first_ns, 81 struct spdk_nvmf_ns *, 82 (struct spdk_nvmf_subsystem *subsystem), 83 NULL); 84 85 DEFINE_STUB(spdk_nvmf_subsystem_get_next_ns, 86 struct spdk_nvmf_ns *, 87 (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ns *prev_ns), 88 NULL); 89 90 DEFINE_STUB(spdk_nvmf_subsystem_host_allowed, 91 bool, 92 (struct spdk_nvmf_subsystem *subsystem, const char *hostnqn), 93 true); 94 95 DEFINE_STUB(nvmf_ctrlr_dsm_supported, 96 bool, 97 (struct spdk_nvmf_ctrlr *ctrlr), 98 false); 99 100 DEFINE_STUB(nvmf_ctrlr_write_zeroes_supported, 101 bool, 102 (struct spdk_nvmf_ctrlr *ctrlr), 103 false); 104 105 DEFINE_STUB(nvmf_ctrlr_copy_supported, 106 bool, 107 (struct spdk_nvmf_ctrlr *ctrlr), 108 false); 109 110 DEFINE_STUB(nvmf_bdev_ctrlr_read_cmd, 111 int, 112 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 113 struct spdk_nvmf_request *req), 114 0); 115 116 DEFINE_STUB(nvmf_bdev_ctrlr_write_cmd, 117 int, 118 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 119 struct spdk_nvmf_request *req), 120 0); 121 122 DEFINE_STUB(nvmf_bdev_ctrlr_compare_cmd, 123 int, 124 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 125 struct spdk_nvmf_request *req), 126 0); 127 128 DEFINE_STUB(nvmf_bdev_ctrlr_compare_and_write_cmd, 129 int, 130 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 131 struct spdk_nvmf_request *cmp_req, struct spdk_nvmf_request *write_req), 132 0); 133 134 DEFINE_STUB(nvmf_bdev_ctrlr_write_zeroes_cmd, 135 int, 136 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 137 struct spdk_nvmf_request *req), 138 0); 139 140 DEFINE_STUB(nvmf_bdev_ctrlr_flush_cmd, 141 int, 142 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 143 struct spdk_nvmf_request *req), 144 0); 145 146 DEFINE_STUB(nvmf_bdev_ctrlr_dsm_cmd, 147 int, 148 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 149 struct spdk_nvmf_request *req), 150 0); 151 152 DEFINE_STUB(nvmf_bdev_ctrlr_copy_cmd, 153 int, 154 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 155 struct spdk_nvmf_request *req), 156 0); 157 158 DEFINE_STUB(nvmf_bdev_ctrlr_nvme_passthru_io, 159 int, 160 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 161 struct spdk_nvmf_request *req), 162 0); 163 164 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_abort_cmd, 165 int, 166 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 167 struct spdk_nvmf_request *req, struct spdk_nvmf_request *req_to_abort), 168 0); 169 170 DEFINE_STUB(nvmf_bdev_ctrlr_get_dif_ctx, 171 bool, 172 (struct spdk_bdev *bdev, struct spdk_nvme_cmd *cmd, struct spdk_dif_ctx *dif_ctx), 173 false); 174 175 DEFINE_STUB(nvmf_transport_req_complete, 176 int, 177 (struct spdk_nvmf_request *req), 178 0); 179 180 DEFINE_STUB(nvmf_bdev_zcopy_enabled, 181 bool, 182 (struct spdk_bdev *bdev), 183 false); 184 185 DEFINE_STUB(nvmf_bdev_ctrlr_zcopy_start, 186 int, 187 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 188 struct spdk_nvmf_request *req), 189 0); 190 191 DEFINE_STUB_V(nvmf_bdev_ctrlr_zcopy_end, (struct spdk_nvmf_request *req, bool commit)); 192 193 DEFINE_STUB_V(spdk_nvmf_request_free_buffers, 194 (struct spdk_nvmf_request *req, struct spdk_nvmf_transport_poll_group *group, 195 struct spdk_nvmf_transport *transport)); 196 197 DEFINE_STUB(spdk_sock_get_optimal_sock_group, 198 int, 199 (struct spdk_sock *sock, struct spdk_sock_group **group, struct spdk_sock_group *hint), 200 0); 201 202 DEFINE_STUB(spdk_sock_group_get_ctx, 203 void *, 204 (struct spdk_sock_group *group), 205 NULL); 206 207 DEFINE_STUB_V(nvmf_ns_reservation_request, (void *ctx)); 208 209 DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid, 210 enum spdk_nvme_transport_type trtype)); 211 DEFINE_STUB_V(spdk_nvmf_transport_register, (const struct spdk_nvmf_transport_ops *ops)); 212 213 DEFINE_STUB_V(spdk_nvmf_tgt_new_qpair, (struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair)); 214 215 DEFINE_STUB_V(nvmf_transport_qpair_abort_request, 216 (struct spdk_nvmf_qpair *qpair, struct spdk_nvmf_request *req)); 217 218 DEFINE_STUB_V(nvmf_qpair_set_state, (struct spdk_nvmf_qpair *q, enum spdk_nvmf_qpair_state s)); 219 220 DEFINE_STUB_V(spdk_nvme_print_command, (uint16_t qid, struct spdk_nvme_cmd *cmd)); 221 DEFINE_STUB_V(spdk_nvme_print_completion, (uint16_t qid, struct spdk_nvme_cpl *cpl)); 222 223 DEFINE_STUB(nvmf_transport_req_free, 224 int, 225 (struct spdk_nvmf_request *req), 226 0); 227 228 DEFINE_STUB(accel_channel_create, int, (void *io_device, void *ctx_buf), 0); 229 DEFINE_STUB_V(accel_channel_destroy, (void *io_device, void *ctx_buf)); 230 DEFINE_STUB(spdk_bdev_reset, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 231 spdk_bdev_io_completion_cb cb, void *cb_arg), 0); 232 DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io)); 233 234 DEFINE_STUB(spdk_bdev_get_max_active_zones, uint32_t, 235 (const struct spdk_bdev *bdev), 0); 236 DEFINE_STUB(spdk_bdev_get_max_open_zones, uint32_t, 237 (const struct spdk_bdev *bdev), 0); 238 DEFINE_STUB(spdk_bdev_is_zoned, bool, (const struct spdk_bdev *bdev), false); 239 DEFINE_STUB(spdk_bdev_get_zone_size, uint64_t, (const struct spdk_bdev *bdev), 0); 240 241 DEFINE_STUB(spdk_nvme_ns_get_format_index, uint32_t, 242 (const struct spdk_nvme_ns_data *nsdata), 0); 243 244 DEFINE_STUB(spdk_sock_get_impl_name, const char *, (struct spdk_sock *sock), ""); 245 246 DEFINE_STUB(spdk_nvmf_subsystem_is_discovery, bool, (struct spdk_nvmf_subsystem *subsystem), false); 247 DEFINE_STUB(spdk_nvmf_subsystem_get_nqn, const char *, 248 (const struct spdk_nvmf_subsystem *subsystem), NULL); 249 DEFINE_STUB(spdk_keyring_get_key, struct spdk_key *, (const char *name), NULL); 250 DEFINE_STUB_V(spdk_keyring_put_key, (struct spdk_key *k)); 251 DEFINE_STUB(spdk_key_get_name, const char *, (struct spdk_key *k), NULL); 252 DEFINE_STUB(spdk_key_get_key, int, (struct spdk_key *k, void *buf, int len), 1); 253 254 DEFINE_STUB(nvmf_ns_is_ptpl_capable, bool, (const struct spdk_nvmf_ns *ns), false); 255 256 struct spdk_io_channel * 257 spdk_accel_get_io_channel(void) 258 { 259 return spdk_get_io_channel(g_accel_p); 260 } 261 262 DEFINE_STUB(spdk_accel_submit_crc32cv, 263 int, 264 (struct spdk_io_channel *ch, uint32_t *dst, struct iovec *iovs, 265 uint32_t iovcnt, uint32_t seed, spdk_accel_completion_cb cb_fn, void *cb_arg), 266 0); 267 268 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_nvme_passthru_admin, 269 int, 270 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, 271 struct spdk_io_channel *ch, struct spdk_nvmf_request *req, 272 spdk_nvmf_nvme_passthru_cmd_cb cb_fn), 273 0) 274 275 struct spdk_bdev { 276 int ut_mock; 277 uint64_t blockcnt; 278 }; 279 280 int 281 spdk_nvme_transport_id_compare(const struct spdk_nvme_transport_id *trid1, 282 const struct spdk_nvme_transport_id *trid2) 283 { 284 return 0; 285 } 286 287 const char * 288 spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype) 289 { 290 switch (trtype) { 291 case SPDK_NVME_TRANSPORT_PCIE: 292 return "PCIe"; 293 case SPDK_NVME_TRANSPORT_RDMA: 294 return "RDMA"; 295 case SPDK_NVME_TRANSPORT_FC: 296 return "FC"; 297 default: 298 return NULL; 299 } 300 } 301 302 int 303 spdk_nvme_transport_id_populate_trstring(struct spdk_nvme_transport_id *trid, const char *trstring) 304 { 305 int len, i; 306 307 if (trstring == NULL) { 308 return -EINVAL; 309 } 310 311 len = strnlen(trstring, SPDK_NVMF_TRSTRING_MAX_LEN); 312 if (len == SPDK_NVMF_TRSTRING_MAX_LEN) { 313 return -EINVAL; 314 } 315 316 /* cast official trstring to uppercase version of input. */ 317 for (i = 0; i < len; i++) { 318 trid->trstring[i] = toupper(trstring[i]); 319 } 320 return 0; 321 } 322 323 int 324 spdk_nvmf_request_get_buffers(struct spdk_nvmf_request *req, 325 struct spdk_nvmf_transport_poll_group *group, 326 struct spdk_nvmf_transport *transport, 327 uint32_t length) 328 { 329 /* length more than 1 io unit length will fail. */ 330 if (length >= transport->opts.io_unit_size) { 331 return -EINVAL; 332 } 333 334 req->iovcnt = 1; 335 req->iov[0].iov_base = (void *)0xDEADBEEF; 336 337 return 0; 338 } 339 340 341 void 342 nvmf_bdev_ctrlr_identify_ns(struct spdk_nvmf_ns *ns, struct spdk_nvme_ns_data *nsdata, 343 bool dif_insert_or_strip) 344 { 345 uint64_t num_blocks; 346 347 SPDK_CU_ASSERT_FATAL(ns->bdev != NULL); 348 num_blocks = ns->bdev->blockcnt; 349 nsdata->nsze = num_blocks; 350 nsdata->ncap = num_blocks; 351 nsdata->nuse = num_blocks; 352 nsdata->nlbaf = 0; 353 nsdata->flbas.format = 0; 354 nsdata->flbas.msb_format = 0; 355 nsdata->lbaf[0].lbads = spdk_u32log2(512); 356 } 357 358 const char * 359 spdk_nvmf_subsystem_get_sn(const struct spdk_nvmf_subsystem *subsystem) 360 { 361 return subsystem->sn; 362 } 363 364 const char * 365 spdk_nvmf_subsystem_get_mn(const struct spdk_nvmf_subsystem *subsystem) 366 { 367 return subsystem->mn; 368 } 369 370 static void 371 test_nvmf_tcp_create(void) 372 { 373 struct spdk_thread *thread; 374 struct spdk_nvmf_transport *transport; 375 struct spdk_nvmf_tcp_transport *ttransport; 376 struct spdk_nvmf_transport_opts opts; 377 378 thread = spdk_thread_create(NULL, NULL); 379 SPDK_CU_ASSERT_FATAL(thread != NULL); 380 spdk_set_thread(thread); 381 382 /* case 1 */ 383 memset(&opts, 0, sizeof(opts)); 384 opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; 385 opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; 386 opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; 387 opts.max_io_size = UT_MAX_IO_SIZE; 388 opts.io_unit_size = UT_IO_UNIT_SIZE; 389 opts.max_aq_depth = UT_MAX_AQ_DEPTH; 390 opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; 391 /* expect success */ 392 transport = nvmf_tcp_create(&opts); 393 CU_ASSERT_PTR_NOT_NULL(transport); 394 ttransport = SPDK_CONTAINEROF(transport, struct spdk_nvmf_tcp_transport, transport); 395 SPDK_CU_ASSERT_FATAL(ttransport != NULL); 396 transport->opts = opts; 397 CU_ASSERT(transport->opts.max_queue_depth == UT_MAX_QUEUE_DEPTH); 398 CU_ASSERT(transport->opts.max_io_size == UT_MAX_IO_SIZE); 399 CU_ASSERT(transport->opts.in_capsule_data_size == UT_IN_CAPSULE_DATA_SIZE); 400 CU_ASSERT(transport->opts.io_unit_size == UT_IO_UNIT_SIZE); 401 /* destroy transport */ 402 CU_ASSERT(nvmf_tcp_destroy(transport, NULL, NULL) == 0); 403 404 /* case 2 */ 405 memset(&opts, 0, sizeof(opts)); 406 opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; 407 opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; 408 opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; 409 opts.max_io_size = UT_MAX_IO_SIZE; 410 opts.io_unit_size = UT_MAX_IO_SIZE + 1; 411 opts.max_aq_depth = UT_MAX_AQ_DEPTH; 412 opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; 413 /* expect success */ 414 transport = nvmf_tcp_create(&opts); 415 CU_ASSERT_PTR_NOT_NULL(transport); 416 ttransport = SPDK_CONTAINEROF(transport, struct spdk_nvmf_tcp_transport, transport); 417 SPDK_CU_ASSERT_FATAL(ttransport != NULL); 418 transport->opts = opts; 419 CU_ASSERT(transport->opts.max_queue_depth == UT_MAX_QUEUE_DEPTH); 420 CU_ASSERT(transport->opts.max_io_size == UT_MAX_IO_SIZE); 421 CU_ASSERT(transport->opts.in_capsule_data_size == UT_IN_CAPSULE_DATA_SIZE); 422 CU_ASSERT(transport->opts.io_unit_size == UT_MAX_IO_SIZE); 423 /* destroy transport */ 424 CU_ASSERT(nvmf_tcp_destroy(transport, NULL, NULL) == 0); 425 426 /* case 3 */ 427 memset(&opts, 0, sizeof(opts)); 428 opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; 429 opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; 430 opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; 431 opts.max_io_size = UT_MAX_IO_SIZE; 432 opts.io_unit_size = 16; 433 opts.max_aq_depth = UT_MAX_AQ_DEPTH; 434 /* expect fails */ 435 transport = nvmf_tcp_create(&opts); 436 CU_ASSERT_PTR_NULL(transport); 437 438 spdk_thread_exit(thread); 439 while (!spdk_thread_is_exited(thread)) { 440 spdk_thread_poll(thread, 0, 0); 441 } 442 spdk_thread_destroy(thread); 443 } 444 445 static void 446 test_nvmf_tcp_destroy(void) 447 { 448 struct spdk_thread *thread; 449 struct spdk_nvmf_transport *transport; 450 struct spdk_nvmf_transport_opts opts; 451 452 thread = spdk_thread_create(NULL, NULL); 453 SPDK_CU_ASSERT_FATAL(thread != NULL); 454 spdk_set_thread(thread); 455 456 /* case 1 */ 457 memset(&opts, 0, sizeof(opts)); 458 opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; 459 opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; 460 opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; 461 opts.max_io_size = UT_MAX_IO_SIZE; 462 opts.io_unit_size = UT_IO_UNIT_SIZE; 463 opts.max_aq_depth = UT_MAX_AQ_DEPTH; 464 opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; 465 transport = nvmf_tcp_create(&opts); 466 CU_ASSERT_PTR_NOT_NULL(transport); 467 transport->opts = opts; 468 /* destroy transport */ 469 CU_ASSERT(nvmf_tcp_destroy(transport, NULL, NULL) == 0); 470 471 spdk_thread_exit(thread); 472 while (!spdk_thread_is_exited(thread)) { 473 spdk_thread_poll(thread, 0, 0); 474 } 475 spdk_thread_destroy(thread); 476 } 477 478 static void 479 init_accel(void) 480 { 481 spdk_io_device_register(g_accel_p, accel_channel_create, accel_channel_destroy, 482 sizeof(int), "accel_p"); 483 } 484 485 static void 486 fini_accel(void) 487 { 488 spdk_io_device_unregister(g_accel_p, NULL); 489 } 490 491 static void 492 test_nvmf_tcp_poll_group_create(void) 493 { 494 struct spdk_nvmf_transport *transport; 495 struct spdk_nvmf_transport_poll_group *group; 496 struct spdk_nvmf_tcp_poll_group *tgroup; 497 struct spdk_thread *thread; 498 struct spdk_nvmf_transport_opts opts; 499 struct spdk_sock_group grp = {}; 500 501 thread = spdk_thread_create(NULL, NULL); 502 SPDK_CU_ASSERT_FATAL(thread != NULL); 503 spdk_set_thread(thread); 504 505 init_accel(); 506 507 memset(&opts, 0, sizeof(opts)); 508 opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; 509 opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; 510 opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; 511 opts.max_io_size = UT_MAX_IO_SIZE; 512 opts.io_unit_size = UT_IO_UNIT_SIZE; 513 opts.max_aq_depth = UT_MAX_AQ_DEPTH; 514 opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; 515 transport = nvmf_tcp_create(&opts); 516 CU_ASSERT_PTR_NOT_NULL(transport); 517 transport->opts = opts; 518 MOCK_SET(spdk_sock_group_create, &grp); 519 group = nvmf_tcp_poll_group_create(transport, NULL); 520 MOCK_CLEAR_P(spdk_sock_group_create); 521 SPDK_CU_ASSERT_FATAL(group); 522 if (opts.in_capsule_data_size < SPDK_NVME_TCP_IN_CAPSULE_DATA_MAX_SIZE) { 523 tgroup = SPDK_CONTAINEROF(group, struct spdk_nvmf_tcp_poll_group, group); 524 SPDK_CU_ASSERT_FATAL(tgroup->control_msg_list); 525 } 526 group->transport = transport; 527 nvmf_tcp_poll_group_destroy(group); 528 nvmf_tcp_destroy(transport, NULL, NULL); 529 530 fini_accel(); 531 spdk_thread_exit(thread); 532 while (!spdk_thread_is_exited(thread)) { 533 spdk_thread_poll(thread, 0, 0); 534 } 535 spdk_thread_destroy(thread); 536 } 537 538 static void 539 test_nvmf_tcp_send_c2h_data(void) 540 { 541 struct spdk_thread *thread; 542 struct spdk_nvmf_tcp_transport ttransport = {}; 543 struct spdk_nvmf_tcp_qpair tqpair = {}; 544 struct spdk_nvmf_tcp_req tcp_req = {}; 545 struct nvme_tcp_pdu pdu = {}; 546 struct spdk_nvme_tcp_c2h_data_hdr *c2h_data; 547 548 ttransport.tcp_opts.c2h_success = true; 549 thread = spdk_thread_create(NULL, NULL); 550 SPDK_CU_ASSERT_FATAL(thread != NULL); 551 spdk_set_thread(thread); 552 553 tcp_req.pdu = &pdu; 554 tcp_req.req.length = 300; 555 tcp_req.req.qpair = &tqpair.qpair; 556 557 tqpair.qpair.transport = &ttransport.transport; 558 559 /* Set qpair state to make unrelated operations NOP */ 560 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 561 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_ERROR; 562 563 tcp_req.req.cmd = (union nvmf_h2c_msg *)&tcp_req.cmd; 564 565 tcp_req.req.iov[0].iov_base = (void *)0xDEADBEEF; 566 tcp_req.req.iov[0].iov_len = 101; 567 tcp_req.req.iov[1].iov_base = (void *)0xFEEDBEEF; 568 tcp_req.req.iov[1].iov_len = 100; 569 tcp_req.req.iov[2].iov_base = (void *)0xC0FFEE; 570 tcp_req.req.iov[2].iov_len = 99; 571 tcp_req.req.iovcnt = 3; 572 tcp_req.req.length = 300; 573 574 nvmf_tcp_send_c2h_data(&tqpair, &tcp_req); 575 576 c2h_data = &pdu.hdr.c2h_data; 577 CU_ASSERT(c2h_data->datao == 0); 578 CU_ASSERT(c2h_data->datal = 300); 579 CU_ASSERT(c2h_data->common.plen == sizeof(*c2h_data) + 300); 580 CU_ASSERT(c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_LAST_PDU); 581 CU_ASSERT(c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_SUCCESS); 582 583 CU_ASSERT(pdu.data_iovcnt == 3); 584 CU_ASSERT((uint64_t)pdu.data_iov[0].iov_base == 0xDEADBEEF); 585 CU_ASSERT(pdu.data_iov[0].iov_len == 101); 586 CU_ASSERT((uint64_t)pdu.data_iov[1].iov_base == 0xFEEDBEEF); 587 CU_ASSERT(pdu.data_iov[1].iov_len == 100); 588 CU_ASSERT((uint64_t)pdu.data_iov[2].iov_base == 0xC0FFEE); 589 CU_ASSERT(pdu.data_iov[2].iov_len == 99); 590 591 tcp_req.pdu_in_use = false; 592 tcp_req.rsp.cdw0 = 1; 593 nvmf_tcp_send_c2h_data(&tqpair, &tcp_req); 594 595 CU_ASSERT(c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_LAST_PDU); 596 CU_ASSERT((c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_SUCCESS) == 0); 597 598 ttransport.tcp_opts.c2h_success = false; 599 tcp_req.pdu_in_use = false; 600 tcp_req.rsp.cdw0 = 0; 601 nvmf_tcp_send_c2h_data(&tqpair, &tcp_req); 602 603 CU_ASSERT(c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_LAST_PDU); 604 CU_ASSERT((c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_SUCCESS) == 0); 605 606 tcp_req.pdu_in_use = false; 607 tcp_req.rsp.cdw0 = 1; 608 nvmf_tcp_send_c2h_data(&tqpair, &tcp_req); 609 610 CU_ASSERT(c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_LAST_PDU); 611 CU_ASSERT((c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_SUCCESS) == 0); 612 613 spdk_thread_exit(thread); 614 while (!spdk_thread_is_exited(thread)) { 615 spdk_thread_poll(thread, 0, 0); 616 } 617 spdk_thread_destroy(thread); 618 } 619 620 #define NVMF_TCP_PDU_MAX_H2C_DATA_SIZE (128 * 1024) 621 622 static void 623 test_nvmf_tcp_h2c_data_hdr_handle(void) 624 { 625 struct spdk_nvmf_tcp_transport ttransport = {}; 626 struct spdk_nvmf_tcp_qpair tqpair = {}; 627 struct nvme_tcp_pdu pdu = {}; 628 struct spdk_nvmf_tcp_req tcp_req = {}; 629 struct spdk_nvme_tcp_h2c_data_hdr *h2c_data; 630 631 /* Set qpair state to make unrelated operations NOP */ 632 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 633 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_ERROR; 634 tqpair.resource_count = 1; 635 tqpair.reqs = &tcp_req; 636 637 tcp_req.req.iov[0].iov_base = (void *)0xDEADBEEF; 638 tcp_req.req.iov[0].iov_len = 101; 639 tcp_req.req.iov[1].iov_base = (void *)0xFEEDBEEF; 640 tcp_req.req.iov[1].iov_len = 99; 641 tcp_req.req.iovcnt = 2; 642 tcp_req.req.length = 200; 643 tcp_req.state = TCP_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER; 644 645 tcp_req.req.cmd = (union nvmf_h2c_msg *)&tcp_req.cmd; 646 tcp_req.req.cmd->nvme_cmd.cid = 1; 647 tcp_req.ttag = 1; 648 649 h2c_data = &pdu.hdr.h2c_data; 650 h2c_data->cccid = 1; 651 h2c_data->ttag = 1; 652 h2c_data->datao = 0; 653 h2c_data->datal = 200; 654 655 nvmf_tcp_h2c_data_hdr_handle(&ttransport, &tqpair, &pdu); 656 657 CU_ASSERT(pdu.data_iovcnt == 2); 658 CU_ASSERT((uint64_t)pdu.data_iov[0].iov_base == 0xDEADBEEF); 659 CU_ASSERT(pdu.data_iov[0].iov_len == 101); 660 CU_ASSERT((uint64_t)pdu.data_iov[1].iov_base == 0xFEEDBEEF); 661 CU_ASSERT(pdu.data_iov[1].iov_len == 99); 662 } 663 664 665 static void 666 test_nvmf_tcp_in_capsule_data_handle(void) 667 { 668 struct spdk_nvmf_tcp_transport ttransport = {}; 669 struct spdk_nvmf_tcp_qpair tqpair = {}; 670 struct nvme_tcp_pdu *pdu, pdu_in_progress = {}; 671 union nvmf_c2h_msg rsp0 = {}; 672 union nvmf_c2h_msg rsp = {}; 673 674 struct spdk_nvmf_request *req_temp = NULL; 675 struct spdk_nvmf_tcp_req tcp_req2 = {}; 676 struct spdk_nvmf_tcp_req tcp_req1 = {}; 677 678 struct spdk_nvme_tcp_cmd *capsule_data; 679 struct spdk_nvmf_capsule_cmd *nvmf_capsule_data; 680 struct spdk_nvme_sgl_descriptor *sgl; 681 682 struct spdk_nvmf_transport_poll_group *group; 683 struct spdk_nvmf_tcp_poll_group tcp_group = {}; 684 struct spdk_sock_group grp = {}; 685 686 tqpair.pdu_in_progress = &pdu_in_progress; 687 ttransport.transport.opts.max_io_size = UT_MAX_IO_SIZE; 688 ttransport.transport.opts.io_unit_size = UT_IO_UNIT_SIZE; 689 690 tcp_group.sock_group = &grp; 691 TAILQ_INIT(&tcp_group.qpairs); 692 group = &tcp_group.group; 693 group->transport = &ttransport.transport; 694 STAILQ_INIT(&group->pending_buf_queue); 695 tqpair.group = &tcp_group; 696 697 TAILQ_INIT(&tqpair.tcp_req_free_queue); 698 TAILQ_INIT(&tqpair.tcp_req_working_queue); 699 700 TAILQ_INSERT_TAIL(&tqpair.tcp_req_free_queue, &tcp_req2, state_link); 701 tqpair.state_cntr[TCP_REQUEST_STATE_FREE]++; 702 tqpair.qpair.transport = &ttransport.transport; 703 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 704 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PSH; 705 tqpair.qpair.state = SPDK_NVMF_QPAIR_ENABLED; 706 707 /* init a null tcp_req into tqpair TCP_REQUEST_STATE_FREE queue */ 708 tcp_req2.req.qpair = &tqpair.qpair; 709 tcp_req2.req.cmd = (union nvmf_h2c_msg *)&tcp_req2.cmd; 710 tcp_req2.req.rsp = &rsp; 711 712 /* init tcp_req1 */ 713 tcp_req1.req.qpair = &tqpair.qpair; 714 tcp_req1.req.cmd = (union nvmf_h2c_msg *)&tcp_req1.cmd; 715 tcp_req1.req.rsp = &rsp0; 716 tcp_req1.state = TCP_REQUEST_STATE_NEW; 717 718 TAILQ_INSERT_TAIL(&tqpair.tcp_req_working_queue, &tcp_req1, state_link); 719 tqpair.state_cntr[TCP_REQUEST_STATE_NEW]++; 720 721 /* init pdu, make pdu need sgl buff */ 722 pdu = tqpair.pdu_in_progress; 723 capsule_data = &pdu->hdr.capsule_cmd; 724 nvmf_capsule_data = (struct spdk_nvmf_capsule_cmd *)&pdu->hdr.capsule_cmd.ccsqe; 725 sgl = &capsule_data->ccsqe.dptr.sgl1; 726 727 capsule_data->common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD; 728 capsule_data->common.hlen = sizeof(*capsule_data); 729 capsule_data->common.plen = 1096; 730 capsule_data->ccsqe.opc = SPDK_NVME_OPC_FABRIC; 731 732 sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_TRANSPORT; 733 sgl->generic.type = SPDK_NVME_SGL_TYPE_TRANSPORT_DATA_BLOCK; 734 sgl->unkeyed.length = UT_IO_UNIT_SIZE; 735 736 nvmf_capsule_data->fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT; 737 738 /* insert tcp_req1 to pending_buf_queue, And this req takes precedence over the next req. */ 739 nvmf_tcp_req_process(&ttransport, &tcp_req1); 740 CU_ASSERT(STAILQ_FIRST(&group->pending_buf_queue) == &tcp_req1.req); 741 742 sgl->unkeyed.length = UT_IO_UNIT_SIZE - 1; 743 744 /* process tqpair capsule req. but we still remain req in pending_buff. */ 745 nvmf_tcp_capsule_cmd_hdr_handle(&ttransport, &tqpair, tqpair.pdu_in_progress); 746 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PAYLOAD); 747 CU_ASSERT(STAILQ_FIRST(&group->pending_buf_queue) == &tcp_req1.req); 748 STAILQ_FOREACH(req_temp, &group->pending_buf_queue, buf_link) { 749 if (req_temp == &tcp_req2.req) { 750 break; 751 } 752 } 753 CU_ASSERT(req_temp == NULL); 754 CU_ASSERT(tqpair.pdu_in_progress->req == (void *)&tcp_req2); 755 } 756 757 static void 758 test_nvmf_tcp_qpair_init_mem_resource(void) 759 { 760 int rc; 761 struct spdk_nvmf_tcp_qpair *tqpair = NULL; 762 struct spdk_nvmf_transport transport = {}; 763 struct spdk_thread *thread; 764 765 thread = spdk_thread_create(NULL, NULL); 766 SPDK_CU_ASSERT_FATAL(thread != NULL); 767 spdk_set_thread(thread); 768 769 tqpair = calloc(1, sizeof(*tqpair)); 770 tqpair->qpair.transport = &transport; 771 772 nvmf_tcp_opts_init(&transport.opts); 773 CU_ASSERT(transport.opts.max_queue_depth == SPDK_NVMF_TCP_DEFAULT_MAX_IO_QUEUE_DEPTH); 774 CU_ASSERT(transport.opts.max_qpairs_per_ctrlr == SPDK_NVMF_TCP_DEFAULT_MAX_QPAIRS_PER_CTRLR); 775 CU_ASSERT(transport.opts.in_capsule_data_size == SPDK_NVMF_TCP_DEFAULT_IN_CAPSULE_DATA_SIZE); 776 CU_ASSERT(transport.opts.max_io_size == SPDK_NVMF_TCP_DEFAULT_MAX_IO_SIZE); 777 CU_ASSERT(transport.opts.io_unit_size == SPDK_NVMF_TCP_DEFAULT_IO_UNIT_SIZE); 778 CU_ASSERT(transport.opts.max_aq_depth == SPDK_NVMF_TCP_DEFAULT_MAX_ADMIN_QUEUE_DEPTH); 779 CU_ASSERT(transport.opts.num_shared_buffers == SPDK_NVMF_TCP_DEFAULT_NUM_SHARED_BUFFERS); 780 CU_ASSERT(transport.opts.buf_cache_size == SPDK_NVMF_TCP_DEFAULT_BUFFER_CACHE_SIZE); 781 CU_ASSERT(transport.opts.dif_insert_or_strip == SPDK_NVMF_TCP_DEFAULT_DIF_INSERT_OR_STRIP); 782 CU_ASSERT(transport.opts.abort_timeout_sec == SPDK_NVMF_TCP_DEFAULT_ABORT_TIMEOUT_SEC); 783 CU_ASSERT(transport.opts.transport_specific == NULL); 784 785 rc = nvmf_tcp_qpair_init(&tqpair->qpair); 786 CU_ASSERT(rc == 0); 787 CU_ASSERT(tqpair->host_hdgst_enable == true); 788 CU_ASSERT(tqpair->host_ddgst_enable == true); 789 790 rc = nvmf_tcp_qpair_init_mem_resource(tqpair); 791 CU_ASSERT(rc == 0); 792 CU_ASSERT(tqpair->resource_count == SPDK_NVMF_TCP_DEFAULT_MAX_IO_QUEUE_DEPTH); 793 CU_ASSERT(tqpair->reqs != NULL); 794 CU_ASSERT(tqpair->bufs != NULL); 795 CU_ASSERT(tqpair->pdus != NULL); 796 /* Just to check the first and last entry */ 797 CU_ASSERT(tqpair->reqs[0].ttag == 1); 798 CU_ASSERT(tqpair->reqs[0].req.qpair == &tqpair->qpair); 799 CU_ASSERT(tqpair->reqs[0].pdu == &tqpair->pdus[0]); 800 CU_ASSERT(tqpair->reqs[0].pdu->qpair == &tqpair->qpair); 801 CU_ASSERT(tqpair->reqs[0].buf == (void *)((uintptr_t)tqpair->bufs)); 802 CU_ASSERT(tqpair->reqs[0].req.rsp == (void *)&tqpair->reqs[0].rsp); 803 CU_ASSERT(tqpair->reqs[0].req.cmd == (void *)&tqpair->reqs[0].cmd); 804 CU_ASSERT(tqpair->reqs[0].state == TCP_REQUEST_STATE_FREE); 805 CU_ASSERT(tqpair->reqs[127].ttag == 128); 806 CU_ASSERT(tqpair->reqs[127].req.qpair == &tqpair->qpair); 807 CU_ASSERT(tqpair->reqs[127].pdu == &tqpair->pdus[127]); 808 CU_ASSERT(tqpair->reqs[127].pdu->qpair == &tqpair->qpair); 809 CU_ASSERT(tqpair->reqs[127].buf == (void *)((uintptr_t)tqpair->bufs) + 127 * 4096); 810 CU_ASSERT(tqpair->reqs[127].req.rsp == (void *)&tqpair->reqs[127].rsp); 811 CU_ASSERT(tqpair->reqs[127].req.cmd == (void *)&tqpair->reqs[127].cmd); 812 CU_ASSERT(tqpair->reqs[127].state == TCP_REQUEST_STATE_FREE); 813 CU_ASSERT(tqpair->state_cntr[TCP_REQUEST_STATE_FREE] == SPDK_NVMF_TCP_DEFAULT_MAX_IO_QUEUE_DEPTH); 814 CU_ASSERT(tqpair->mgmt_pdu == &tqpair->pdus[2 * SPDK_NVMF_TCP_DEFAULT_MAX_IO_QUEUE_DEPTH]); 815 CU_ASSERT(tqpair->mgmt_pdu->qpair == tqpair); 816 CU_ASSERT(tqpair->pdu_in_progress == 817 &tqpair->pdus[2 * SPDK_NVMF_TCP_DEFAULT_MAX_IO_QUEUE_DEPTH - 1]); 818 CU_ASSERT(tqpair->recv_buf_size == (4096 + sizeof(struct spdk_nvme_tcp_cmd) + 2 * 819 SPDK_NVME_TCP_DIGEST_LEN) * SPDK_NVMF_TCP_RECV_BUF_SIZE_FACTOR); 820 821 /* Free all of tqpair resource */ 822 nvmf_tcp_qpair_destroy(tqpair); 823 824 spdk_thread_exit(thread); 825 while (!spdk_thread_is_exited(thread)) { 826 spdk_thread_poll(thread, 0, 0); 827 } 828 spdk_thread_destroy(thread); 829 } 830 831 static void 832 test_nvmf_tcp_send_c2h_term_req(void) 833 { 834 struct spdk_nvmf_tcp_qpair tqpair = {}; 835 struct nvme_tcp_pdu pdu = {}, mgmt_pdu = {}, pdu_in_progress = {}; 836 enum spdk_nvme_tcp_term_req_fes fes = SPDK_NVME_TCP_TERM_REQ_FES_INVALID_HEADER_FIELD; 837 uint32_t error_offset = 1; 838 839 mgmt_pdu.qpair = &tqpair; 840 tqpair.mgmt_pdu = &mgmt_pdu; 841 tqpair.pdu_in_progress = &pdu_in_progress; 842 tqpair.tcp_pdu_working_count = 1; 843 844 /* case1: hlen < SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE, Expect: copy_len == hlen */ 845 pdu.hdr.common.hlen = 64; 846 nvmf_tcp_send_c2h_term_req(&tqpair, &pdu, fes, error_offset); 847 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 848 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 849 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen + 850 pdu.hdr.common.hlen); 851 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 852 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fes == SPDK_NVME_TCP_TERM_REQ_FES_INVALID_HEADER_FIELD); 853 854 /* case2: hlen > SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE, Expect: copy_len == SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE */ 855 pdu.hdr.common.hlen = 255; 856 nvmf_tcp_send_c2h_term_req(&tqpair, &pdu, fes, error_offset); 857 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 858 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 859 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == (unsigned) 860 tqpair.mgmt_pdu->hdr.term_req.common.hlen + SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE); 861 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 862 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fes == SPDK_NVME_TCP_TERM_REQ_FES_INVALID_HEADER_FIELD); 863 } 864 865 static void 866 test_nvmf_tcp_send_capsule_resp_pdu(void) 867 { 868 struct spdk_nvmf_tcp_req tcp_req = {}; 869 struct spdk_nvmf_tcp_qpair tqpair = {}; 870 struct nvme_tcp_pdu pdu = {}; 871 872 tcp_req.pdu_in_use = false; 873 tcp_req.req.qpair = &tqpair.qpair; 874 tcp_req.pdu = &pdu; 875 tcp_req.req.rsp = (union nvmf_c2h_msg *)&tcp_req.rsp; 876 tcp_req.req.cmd = (union nvmf_h2c_msg *)&tcp_req.cmd; 877 tqpair.host_hdgst_enable = true; 878 879 nvmf_tcp_send_capsule_resp_pdu(&tcp_req, &tqpair); 880 CU_ASSERT(pdu.hdr.capsule_resp.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_CAPSULE_RESP); 881 CU_ASSERT(pdu.hdr.capsule_resp.common.plen == sizeof(struct spdk_nvme_tcp_rsp) + 882 SPDK_NVME_TCP_DIGEST_LEN); 883 CU_ASSERT(pdu.hdr.capsule_resp.common.hlen == sizeof(struct spdk_nvme_tcp_rsp)); 884 CU_ASSERT(!memcmp(&pdu.hdr.capsule_resp.rccqe, &tcp_req.req.rsp->nvme_cpl, 885 sizeof(struct spdk_nvme_cpl))); 886 CU_ASSERT(pdu.hdr.capsule_resp.common.flags & SPDK_NVME_TCP_CH_FLAGS_HDGSTF); 887 CU_ASSERT(pdu.cb_fn == nvmf_tcp_request_free); 888 CU_ASSERT(pdu.cb_arg == &tcp_req); 889 CU_ASSERT(pdu.iov[0].iov_base == &pdu.hdr.raw); 890 CU_ASSERT(pdu.iov[0].iov_len == sizeof(struct spdk_nvme_tcp_rsp) + SPDK_NVME_TCP_DIGEST_LEN); 891 892 /* hdgst disable */ 893 tqpair.host_hdgst_enable = false; 894 tcp_req.pdu_in_use = false; 895 memset(&pdu, 0, sizeof(pdu)); 896 897 nvmf_tcp_send_capsule_resp_pdu(&tcp_req, &tqpair); 898 CU_ASSERT(pdu.hdr.capsule_resp.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_CAPSULE_RESP); 899 CU_ASSERT(pdu.hdr.capsule_resp.common.plen == sizeof(struct spdk_nvme_tcp_rsp)); 900 CU_ASSERT(pdu.hdr.capsule_resp.common.hlen == sizeof(struct spdk_nvme_tcp_rsp)); 901 CU_ASSERT(!memcmp(&pdu.hdr.capsule_resp.rccqe, &tcp_req.req.rsp->nvme_cpl, 902 sizeof(struct spdk_nvme_cpl))); 903 CU_ASSERT(!(pdu.hdr.capsule_resp.common.flags & SPDK_NVME_TCP_CH_FLAGS_HDGSTF)); 904 CU_ASSERT(pdu.cb_fn == nvmf_tcp_request_free); 905 CU_ASSERT(pdu.cb_arg == &tcp_req); 906 CU_ASSERT(pdu.iov[0].iov_base == &pdu.hdr.raw); 907 CU_ASSERT(pdu.iov[0].iov_len == sizeof(struct spdk_nvme_tcp_rsp)); 908 } 909 910 static void 911 test_nvmf_tcp_icreq_handle(void) 912 { 913 struct spdk_nvmf_tcp_transport ttransport = {}; 914 struct spdk_nvmf_tcp_qpair tqpair = {}; 915 struct nvme_tcp_pdu pdu = {}; 916 struct nvme_tcp_pdu mgmt_pdu = {}; 917 struct nvme_tcp_pdu pdu_in_progress = {}; 918 struct spdk_nvme_tcp_ic_resp *ic_resp; 919 920 mgmt_pdu.qpair = &tqpair; 921 tqpair.mgmt_pdu = &mgmt_pdu; 922 tqpair.pdu_in_progress = &pdu_in_progress; 923 tqpair.tcp_pdu_working_count = 1; 924 925 /* case 1: Expected ICReq PFV 0 and got are different. */ 926 pdu.hdr.ic_req.pfv = 1; 927 928 nvmf_tcp_icreq_handle(&ttransport, &tqpair, &pdu); 929 930 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 931 932 /* case 2: Expected ICReq HPDA in range 0-31 and got are different. */ 933 pdu.hdr.ic_req.hpda = SPDK_NVME_TCP_HPDA_MAX + 1; 934 935 nvmf_tcp_icreq_handle(&ttransport, &tqpair, &pdu); 936 937 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 938 939 /* case 3: Expect: PASS. */ 940 ttransport.transport.opts.max_io_size = 32; 941 pdu.hdr.ic_req.pfv = 0; 942 tqpair.host_hdgst_enable = false; 943 tqpair.host_ddgst_enable = false; 944 tqpair.recv_buf_size = 64; 945 pdu.hdr.ic_req.hpda = 16; 946 947 nvmf_tcp_icreq_handle(&ttransport, &tqpair, &pdu); 948 949 ic_resp = &tqpair.mgmt_pdu->hdr.ic_resp; 950 CU_ASSERT(tqpair.recv_buf_size == MIN_SOCK_PIPE_SIZE); 951 CU_ASSERT(tqpair.cpda == pdu.hdr.ic_req.hpda); 952 CU_ASSERT(ic_resp->common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_IC_RESP); 953 CU_ASSERT(ic_resp->common.hlen == sizeof(struct spdk_nvme_tcp_ic_resp)); 954 CU_ASSERT(ic_resp->common.plen == sizeof(struct spdk_nvme_tcp_ic_resp)); 955 CU_ASSERT(ic_resp->pfv == 0); 956 CU_ASSERT(ic_resp->cpda == tqpair.cpda); 957 CU_ASSERT(ic_resp->maxh2cdata == ttransport.transport.opts.max_io_size); 958 CU_ASSERT(ic_resp->dgst.bits.hdgst_enable == 0); 959 CU_ASSERT(ic_resp->dgst.bits.ddgst_enable == 0); 960 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_READY); 961 } 962 963 static void 964 test_nvmf_tcp_check_xfer_type(void) 965 { 966 const uint16_t cid = 0xAA; 967 struct spdk_nvmf_tcp_transport ttransport = {}; 968 struct spdk_nvmf_tcp_qpair tqpair = {}; 969 struct nvme_tcp_pdu pdu_in_progress = {}; 970 union nvmf_c2h_msg rsp0 = {}; 971 972 struct spdk_nvmf_tcp_req tcp_req = {}; 973 struct nvme_tcp_pdu rsp_pdu = {}; 974 975 struct spdk_nvme_tcp_cmd *capsule_data; 976 struct spdk_nvme_sgl_descriptor *sgl; 977 978 struct spdk_nvmf_transport_poll_group *group; 979 struct spdk_nvmf_tcp_poll_group tcp_group = {}; 980 struct spdk_sock_group grp = {}; 981 982 tqpair.pdu_in_progress = &pdu_in_progress; 983 ttransport.transport.opts.max_io_size = UT_MAX_IO_SIZE; 984 ttransport.transport.opts.io_unit_size = UT_IO_UNIT_SIZE; 985 986 tcp_group.sock_group = &grp; 987 TAILQ_INIT(&tcp_group.qpairs); 988 group = &tcp_group.group; 989 group->transport = &ttransport.transport; 990 STAILQ_INIT(&group->pending_buf_queue); 991 tqpair.group = &tcp_group; 992 993 TAILQ_INIT(&tqpair.tcp_req_free_queue); 994 TAILQ_INIT(&tqpair.tcp_req_working_queue); 995 996 tqpair.qpair.transport = &ttransport.transport; 997 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 998 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PSH; 999 tqpair.qpair.state = SPDK_NVMF_QPAIR_ENABLED; 1000 1001 /* init tcp_req */ 1002 tcp_req.req.qpair = &tqpair.qpair; 1003 tcp_req.pdu = &rsp_pdu; 1004 tcp_req.req.cmd = (union nvmf_h2c_msg *)&tcp_req.cmd; 1005 tcp_req.req.rsp = &rsp0; 1006 tcp_req.state = TCP_REQUEST_STATE_NEW; 1007 1008 TAILQ_INSERT_TAIL(&tqpair.tcp_req_working_queue, &tcp_req, state_link); 1009 tqpair.state_cntr[TCP_REQUEST_STATE_NEW]++; 1010 1011 /* init pdu, make pdu need sgl buff */ 1012 capsule_data = &tqpair.pdu_in_progress->hdr.capsule_cmd; 1013 sgl = &capsule_data->ccsqe.dptr.sgl1; 1014 1015 capsule_data->common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD; 1016 capsule_data->common.hlen = sizeof(*capsule_data); 1017 capsule_data->common.plen = 1096; 1018 capsule_data->ccsqe.opc = 0x10 | SPDK_NVME_DATA_BIDIRECTIONAL; 1019 /* Need to set to a non zero valid to check it gets copied to the response */ 1020 capsule_data->ccsqe.cid = cid; 1021 1022 /* Set up SGL to ensure nvmf_tcp_req_parse_sgl returns an error */ 1023 sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_TRANSPORT; 1024 sgl->generic.type = SPDK_NVME_SGL_TYPE_TRANSPORT_DATA_BLOCK; 1025 sgl->unkeyed.length = UT_IO_UNIT_SIZE; 1026 1027 /* Process a command and ensure that it fails and the request is set up to return an error */ 1028 nvmf_tcp_req_process(&ttransport, &tcp_req); 1029 CU_ASSERT(STAILQ_EMPTY(&group->pending_buf_queue)); 1030 CU_ASSERT(tcp_req.state == TCP_REQUEST_STATE_TRANSFERRING_CONTROLLER_TO_HOST); 1031 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_READY); 1032 CU_ASSERT(tcp_req.req.rsp->nvme_cpl.cid == cid); 1033 CU_ASSERT(tcp_req.req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 1034 CU_ASSERT(tcp_req.req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_OPCODE); 1035 } 1036 1037 static void 1038 test_nvmf_tcp_invalid_sgl(void) 1039 { 1040 const uint16_t cid = 0xAABB; 1041 struct spdk_nvmf_tcp_transport ttransport = {}; 1042 struct spdk_nvmf_tcp_qpair tqpair = {}; 1043 struct nvme_tcp_pdu pdu_in_progress = {}; 1044 union nvmf_c2h_msg rsp0 = {}; 1045 1046 struct spdk_nvmf_tcp_req tcp_req = {}; 1047 struct nvme_tcp_pdu rsp_pdu = {}; 1048 struct nvme_tcp_pdu mgmt_pdu = {}; 1049 1050 struct spdk_nvme_tcp_cmd *capsule_data; 1051 struct spdk_nvme_sgl_descriptor *sgl; 1052 1053 struct spdk_nvmf_transport_poll_group *group; 1054 struct spdk_nvmf_tcp_poll_group tcp_group = {}; 1055 struct spdk_sock_group grp = {}; 1056 1057 tqpair.pdu_in_progress = &pdu_in_progress; 1058 ttransport.transport.opts.max_io_size = UT_MAX_IO_SIZE; 1059 ttransport.transport.opts.io_unit_size = UT_IO_UNIT_SIZE; 1060 1061 tcp_group.sock_group = &grp; 1062 TAILQ_INIT(&tcp_group.qpairs); 1063 group = &tcp_group.group; 1064 group->transport = &ttransport.transport; 1065 STAILQ_INIT(&group->pending_buf_queue); 1066 tqpair.group = &tcp_group; 1067 1068 TAILQ_INIT(&tqpair.tcp_req_free_queue); 1069 TAILQ_INIT(&tqpair.tcp_req_working_queue); 1070 1071 tqpair.qpair.transport = &ttransport.transport; 1072 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 1073 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PSH; 1074 tqpair.qpair.state = SPDK_NVMF_QPAIR_ENABLED; 1075 1076 /* init tcp_req */ 1077 tcp_req.req.qpair = &tqpair.qpair; 1078 tcp_req.pdu = &rsp_pdu; 1079 tcp_req.pdu->qpair = &tqpair; 1080 tqpair.mgmt_pdu = &mgmt_pdu; 1081 tqpair.mgmt_pdu->qpair = &tqpair; 1082 tcp_req.req.cmd = (union nvmf_h2c_msg *)&tcp_req.cmd; 1083 tcp_req.req.rsp = &rsp0; 1084 tcp_req.state = TCP_REQUEST_STATE_NEW; 1085 1086 TAILQ_INSERT_TAIL(&tqpair.tcp_req_working_queue, &tcp_req, state_link); 1087 tqpair.state_cntr[TCP_REQUEST_STATE_NEW]++; 1088 1089 /* init pdu, make pdu need sgl buff */ 1090 capsule_data = &tqpair.pdu_in_progress->hdr.capsule_cmd; 1091 sgl = &capsule_data->ccsqe.dptr.sgl1; 1092 1093 capsule_data->common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD; 1094 capsule_data->common.hlen = sizeof(*capsule_data); 1095 capsule_data->common.plen = 1096; 1096 capsule_data->ccsqe.opc = SPDK_NVME_OPC_WRITE; 1097 /* Need to set to a non zero valid to check it gets copied to the response */ 1098 capsule_data->ccsqe.cid = cid; 1099 1100 /* Set up SGL to ensure nvmf_tcp_req_parse_sgl returns an error */ 1101 sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_TRANSPORT; 1102 sgl->generic.type = SPDK_NVME_SGL_TYPE_TRANSPORT_DATA_BLOCK; 1103 sgl->unkeyed.length = UT_MAX_IO_SIZE + 1; 1104 1105 /* Process a command and ensure that it fails and the request is set up to return an error */ 1106 nvmf_tcp_req_process(&ttransport, &tcp_req); 1107 CU_ASSERT(!STAILQ_EMPTY(&group->pending_buf_queue)); 1108 CU_ASSERT(tcp_req.state == TCP_REQUEST_STATE_NEED_BUFFER); 1109 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1110 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1111 } 1112 1113 static void 1114 test_nvmf_tcp_pdu_ch_handle(void) 1115 { 1116 struct spdk_nvmf_tcp_qpair tqpair = {}; 1117 struct nvme_tcp_pdu mgmt_pdu = {}, pdu_in_progress = {}; 1118 1119 mgmt_pdu.qpair = &tqpair; 1120 tqpair.mgmt_pdu = &mgmt_pdu; 1121 tqpair.pdu_in_progress = &pdu_in_progress; 1122 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1123 tqpair.cpda = 0; 1124 1125 /* Test case: Already received ICreq PDU. Expect: fail */ 1126 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_IC_REQ; 1127 tqpair.state = NVME_TCP_QPAIR_STATE_INITIALIZING; 1128 nvmf_tcp_pdu_ch_handle(&tqpair); 1129 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1130 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1131 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1132 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen); 1133 1134 /* Test case: Expected PDU header length and received are different. Expect: fail */ 1135 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1136 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_IC_REQ; 1137 tqpair.state = NVME_TCP_QPAIR_STATE_INVALID; 1138 tqpair.pdu_in_progress->hdr.common.plen = sizeof(struct spdk_nvme_tcp_ic_req); 1139 tqpair.pdu_in_progress->hdr.common.hlen = 0; 1140 nvmf_tcp_pdu_ch_handle(&tqpair); 1141 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1142 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1143 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1144 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen); 1145 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fei[0] == 2); 1146 1147 /* Test case: The TCP/IP tqpair connection is not negotitated. Expect: fail */ 1148 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1149 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_IC_RESP; 1150 tqpair.state = NVME_TCP_QPAIR_STATE_INVALID; 1151 tqpair.pdu_in_progress->hdr.common.plen = sizeof(struct spdk_nvme_tcp_ic_req); 1152 tqpair.pdu_in_progress->hdr.common.hlen = 0; 1153 nvmf_tcp_pdu_ch_handle(&tqpair); 1154 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1155 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1156 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1157 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen); 1158 1159 /* Test case: Unexpected PDU type. Expect: fail */ 1160 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1161 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_CAPSULE_RESP; 1162 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 1163 tqpair.pdu_in_progress->hdr.common.plen = 0; 1164 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_ic_req); 1165 nvmf_tcp_pdu_ch_handle(&tqpair); 1166 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1167 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1168 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1169 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen + 1170 (unsigned)SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE); 1171 1172 /* Test case: PDU type is SPDK_NVME_TCP_PDU_TYPE_IC_REQ, let plen error. Expect: fail */ 1173 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1174 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_IC_REQ; 1175 tqpair.state = NVME_TCP_QPAIR_STATE_INVALID; 1176 tqpair.pdu_in_progress->hdr.common.plen = 0; 1177 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_ic_req); 1178 nvmf_tcp_pdu_ch_handle(&tqpair); 1179 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1180 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1181 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1182 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen + 1183 (unsigned)SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE); 1184 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fei[0] == 4); 1185 1186 /* Test case: PDU type is SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD, let plen error. Expect: fail */ 1187 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1188 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD; 1189 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 1190 tqpair.pdu_in_progress->hdr.common.flags = SPDK_NVME_TCP_CH_FLAGS_HDGSTF; 1191 tqpair.pdu_in_progress->hdr.common.plen = 0; 1192 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_cmd); 1193 nvmf_tcp_pdu_ch_handle(&tqpair); 1194 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1195 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1196 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1197 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == sizeof(struct spdk_nvme_tcp_cmd) + sizeof( 1198 struct spdk_nvme_tcp_term_req_hdr)); 1199 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fei[0] == 4); 1200 1201 /* Test case: PDU type is SPDK_NVME_TCP_PDU_TYPE_H2C_DATA, let plen error. Expect: fail */ 1202 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1203 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_H2C_DATA; 1204 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 1205 tqpair.pdu_in_progress->hdr.common.plen = 0; 1206 tqpair.pdu_in_progress->hdr.common.pdo = 64; 1207 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_h2c_data_hdr); 1208 nvmf_tcp_pdu_ch_handle(&tqpair); 1209 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1210 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1211 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1212 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen + 1213 (unsigned)sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1214 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fei[0] == 4); 1215 1216 /* Test case: PDU type is SPDK_NVME_TCP_PDU_TYPE_H2C_TERM_REQ, let plen error. Expect: fail */ 1217 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1218 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_H2C_TERM_REQ; 1219 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 1220 tqpair.pdu_in_progress->hdr.common.plen = 0; 1221 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_term_req_hdr); 1222 nvmf_tcp_pdu_ch_handle(&tqpair); 1223 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1224 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1225 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1226 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen + 1227 (unsigned)sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1228 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fei[0] == 4); 1229 1230 /* Test case: PDU type is SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD, let pdo error. Expect: fail */ 1231 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1232 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD; 1233 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 1234 tqpair.cpda = 1; 1235 tqpair.pdu_in_progress->hdr.common.flags = SPDK_NVME_TCP_CH_FLAGS_HDGSTF; 1236 tqpair.pdu_in_progress->hdr.common.plen = 0; 1237 tqpair.pdu_in_progress->hdr.common.pdo = 63; 1238 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_cmd); 1239 nvmf_tcp_pdu_ch_handle(&tqpair); 1240 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1241 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1242 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1243 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == sizeof(struct spdk_nvme_tcp_cmd) + sizeof( 1244 struct spdk_nvme_tcp_term_req_hdr)); 1245 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fei[0] == 3); 1246 1247 /* Test case: PDU type is SPDK_NVME_TCP_PDU_TYPE_H2C_DATA, let pdo error. Expect: fail */ 1248 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1249 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_H2C_DATA; 1250 tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; 1251 tqpair.cpda = 1; 1252 tqpair.pdu_in_progress->hdr.common.plen = 0; 1253 tqpair.pdu_in_progress->hdr.common.pdo = 63; 1254 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_h2c_data_hdr); 1255 nvmf_tcp_pdu_ch_handle(&tqpair); 1256 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_QUIESCING); 1257 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ); 1258 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.hlen == sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1259 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.common.plen == tqpair.mgmt_pdu->hdr.term_req.common.hlen + 1260 (unsigned)sizeof(struct spdk_nvme_tcp_term_req_hdr)); 1261 CU_ASSERT(tqpair.mgmt_pdu->hdr.term_req.fei[0] == 3); 1262 1263 /* Test case: All parameters is conformed to the function. Expect: PASS */ 1264 tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH; 1265 tqpair.pdu_in_progress->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_IC_REQ; 1266 tqpair.state = NVME_TCP_QPAIR_STATE_INVALID; 1267 tqpair.pdu_in_progress->hdr.common.plen = sizeof(struct spdk_nvme_tcp_ic_req); 1268 tqpair.pdu_in_progress->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_ic_req); 1269 nvmf_tcp_pdu_ch_handle(&tqpair); 1270 CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PSH); 1271 CU_ASSERT(tqpair.pdu_in_progress->psh_len == tqpair.pdu_in_progress->hdr.common.hlen - sizeof( 1272 struct spdk_nvme_tcp_common_pdu_hdr)); 1273 } 1274 1275 static void 1276 test_nvmf_tcp_tls_add_remove_credentials(void) 1277 { 1278 struct spdk_thread *thread; 1279 struct spdk_nvmf_transport *transport; 1280 struct spdk_nvmf_tcp_transport *ttransport; 1281 struct spdk_nvmf_transport_opts opts; 1282 struct spdk_nvmf_subsystem subsystem; 1283 struct tcp_psk_entry *entry; 1284 const char subnqn[] = {"nqn.2016-06.io.spdk:cnode1"}; 1285 const char hostnqn[] = {"nqn.2016-06.io.spdk:host1"}; 1286 const char *psk = "NVMeTLSkey-1:01:VRLbtnN9AQb2WXW3c9+wEf/DRLz0QuLdbYvEhwtdWwNf9LrZ:"; 1287 char *psk_file_path = "/tmp/psk.txt"; 1288 bool found = false; 1289 FILE *psk_file = NULL; 1290 mode_t oldmask; 1291 1292 thread = spdk_thread_create(NULL, NULL); 1293 SPDK_CU_ASSERT_FATAL(thread != NULL); 1294 spdk_set_thread(thread); 1295 1296 memset(&opts, 0, sizeof(opts)); 1297 opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; 1298 opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; 1299 opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; 1300 opts.max_io_size = UT_MAX_IO_SIZE; 1301 opts.io_unit_size = UT_IO_UNIT_SIZE; 1302 opts.max_aq_depth = UT_MAX_AQ_DEPTH; 1303 opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; 1304 transport = nvmf_tcp_create(&opts); 1305 1306 memset(&subsystem, 0, sizeof(subsystem)); 1307 snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn); 1308 1309 /* Create a text file containing PSK in interchange format. */ 1310 oldmask = umask(S_IXUSR | S_IRWXG | S_IRWXO); 1311 psk_file = fopen(psk_file_path, "w"); 1312 CU_ASSERT(psk_file != NULL); 1313 CU_ASSERT(fprintf(psk_file, "%s", psk) > 0); 1314 CU_ASSERT(fclose(psk_file) == 0); 1315 umask(oldmask); 1316 1317 struct spdk_json_val psk_json[] = { 1318 {"", 2, SPDK_JSON_VAL_OBJECT_BEGIN}, 1319 {"psk", 3, SPDK_JSON_VAL_NAME}, 1320 {psk_file_path, strlen(psk_file_path), SPDK_JSON_VAL_STRING}, 1321 {"", 0, SPDK_JSON_VAL_OBJECT_END}, 1322 }; 1323 1324 nvmf_tcp_subsystem_add_host(transport, &subsystem, hostnqn, psk_json); 1325 1326 ttransport = SPDK_CONTAINEROF(transport, struct spdk_nvmf_tcp_transport, transport); 1327 TAILQ_FOREACH(entry, &ttransport->psks, link) { 1328 if ((strcmp(subnqn, entry->subnqn) == 0) && 1329 (strcmp(hostnqn, entry->hostnqn) == 0)) { 1330 found = true; 1331 } 1332 } 1333 1334 CU_ASSERT(found == true); 1335 found = false; 1336 1337 nvmf_tcp_subsystem_remove_host(transport, &subsystem, hostnqn); 1338 1339 ttransport = SPDK_CONTAINEROF(transport, struct spdk_nvmf_tcp_transport, transport); 1340 TAILQ_FOREACH(entry, &ttransport->psks, link) { 1341 if ((strcmp(subnqn, entry->subnqn) == 0) && 1342 (strcmp(hostnqn, entry->hostnqn) == 0)) { 1343 found = true; 1344 } 1345 } 1346 1347 CU_ASSERT(found == false); 1348 1349 CU_ASSERT(remove(psk_file_path) == 0); 1350 1351 CU_ASSERT(nvmf_tcp_destroy(transport, NULL, NULL) == 0); 1352 1353 spdk_thread_exit(thread); 1354 while (!spdk_thread_is_exited(thread)) { 1355 spdk_thread_poll(thread, 0, 0); 1356 } 1357 spdk_thread_destroy(thread); 1358 } 1359 1360 static void 1361 test_nvmf_tcp_tls_generate_psk_id(void) 1362 { 1363 const char psk_id_reference[] = {"NVMe0R01 nqn.2016-06.io.spdk:host1 nqn.2016-06.io.spdk:cnode1"}; 1364 const char subnqn[] = {"nqn.2016-06.io.spdk:cnode1"}; 1365 const char hostnqn[] = {"nqn.2016-06.io.spdk:host1"}; 1366 char psk_id[NVMF_PSK_IDENTITY_LEN] = {}; 1367 char too_small_psk_id[5] = {}; 1368 1369 /* Check if we can generate expected PSK id. */ 1370 CU_ASSERT(nvme_tcp_generate_psk_identity(psk_id, NVMF_PSK_IDENTITY_LEN, hostnqn, 1371 subnqn, NVME_TCP_CIPHER_AES_128_GCM_SHA256) == 0); 1372 CU_ASSERT(strcmp(psk_id, psk_id_reference) == 0); 1373 1374 /* Test with a buffer that is too small to fit PSK id. */ 1375 CU_ASSERT(nvme_tcp_generate_psk_identity(too_small_psk_id, sizeof(too_small_psk_id), hostnqn, 1376 subnqn, NVME_TCP_CIPHER_AES_128_GCM_SHA256) != 0); 1377 1378 /* Test with unknown cipher suite. */ 1379 CU_ASSERT(nvme_tcp_generate_psk_identity(psk_id, NVMF_PSK_IDENTITY_LEN, hostnqn, 1380 subnqn, UINT8_MAX) != 0); 1381 } 1382 1383 static void 1384 test_nvmf_tcp_tls_generate_retained_psk(void) 1385 { 1386 const char hostnqn[] = {"nqn.2016-06.io.spdk:host1"}; 1387 const char psk_reference1[] = {"1234567890ABCDEF"}; 1388 const char psk_reference2[] = {"FEDCBA0987654321"}; 1389 uint8_t unhexlified_str1[SPDK_TLS_PSK_MAX_LEN] = {}; 1390 uint8_t unhexlified_str2[SPDK_TLS_PSK_MAX_LEN] = {}; 1391 char *unhexlified1; 1392 char *unhexlified2; 1393 uint8_t psk_retained1[SPDK_TLS_PSK_MAX_LEN] = {}; 1394 uint8_t psk_retained2[SPDK_TLS_PSK_MAX_LEN] = {}; 1395 uint8_t too_small_psk_retained[5] = {}; 1396 int psk_retained_len1, psk_retained_len2; 1397 int retained_size; 1398 1399 unhexlified1 = spdk_unhexlify(psk_reference1); 1400 SPDK_CU_ASSERT_FATAL(unhexlified1 != NULL); 1401 unhexlified2 = spdk_unhexlify(psk_reference2); 1402 SPDK_CU_ASSERT_FATAL(unhexlified2 != NULL); 1403 1404 memcpy(unhexlified_str1, unhexlified1, strlen(psk_reference1) / 2); 1405 memcpy(unhexlified_str2, unhexlified2, strlen(psk_reference2) / 2); 1406 free(unhexlified1); 1407 free(unhexlified2); 1408 1409 /* Make sure that retained PSKs are different with different input PSKs and the same hash. */ 1410 retained_size = nvme_tcp_derive_retained_psk(unhexlified_str1, strlen(psk_reference1) / 2, hostnqn, 1411 psk_retained1, SPDK_TLS_PSK_MAX_LEN, NVME_TCP_HASH_ALGORITHM_SHA256); 1412 CU_ASSERT(retained_size > 0); 1413 1414 CU_ASSERT(nvme_tcp_derive_retained_psk(unhexlified_str2, strlen(psk_reference2) / 2, hostnqn, 1415 psk_retained2, 1416 SPDK_TLS_PSK_MAX_LEN, NVME_TCP_HASH_ALGORITHM_SHA256) > 0); 1417 CU_ASSERT(memcmp(psk_retained1, psk_retained2, retained_size) != 0); 1418 1419 /* Make sure that retained PSKs are different with different hash and the same input PSKs. */ 1420 psk_retained_len1 = nvme_tcp_derive_retained_psk(unhexlified_str1, strlen(psk_reference1) / 2, 1421 hostnqn, psk_retained1, SPDK_TLS_PSK_MAX_LEN, NVME_TCP_HASH_ALGORITHM_SHA256); 1422 CU_ASSERT(psk_retained_len1 > 0); 1423 psk_retained_len2 = nvme_tcp_derive_retained_psk(unhexlified_str1, strlen(psk_reference1) / 2, 1424 hostnqn, psk_retained2, SPDK_TLS_PSK_MAX_LEN, NVME_TCP_HASH_ALGORITHM_SHA384); 1425 CU_ASSERT(psk_retained_len2 > 0); 1426 CU_ASSERT(psk_retained_len1 < psk_retained_len2); 1427 1428 /* Make sure that passing unknown value as hash errors out the function. */ 1429 CU_ASSERT(nvme_tcp_derive_retained_psk(unhexlified_str1, strlen(psk_reference1) / 2, hostnqn, 1430 psk_retained1, SPDK_TLS_PSK_MAX_LEN, -1) < 0); 1431 1432 /* Make sure that passing buffer insufficient in size errors out the function. */ 1433 CU_ASSERT(nvme_tcp_derive_retained_psk(unhexlified_str1, strlen(psk_reference1) / 2, hostnqn, 1434 too_small_psk_retained, sizeof(too_small_psk_retained), NVME_TCP_HASH_ALGORITHM_SHA256) < 0); 1435 } 1436 1437 static void 1438 test_nvmf_tcp_tls_generate_tls_psk(void) 1439 { 1440 const char psk_id_reference[] = {"NVMe0R01 nqn.2016-06.io.spdk:host1 nqn.2016-06.io.spdk:cnode1"}; 1441 const char hostnqn[] = {"nqn.2016-06.io.spdk:host1"}; 1442 const char psk_reference[] = {"1234567890ABCDEF"}; 1443 char *unhexlified; 1444 uint8_t unhexlified_str[SPDK_TLS_PSK_MAX_LEN] = {}; 1445 uint8_t psk_retained[SPDK_TLS_PSK_MAX_LEN] = {}; 1446 uint8_t psk_key1[SPDK_TLS_PSK_MAX_LEN] = {}, psk_key2[SPDK_TLS_PSK_MAX_LEN] = {}; 1447 uint8_t too_small_psk_tls[5] = {}; 1448 int retained_size, tls_size; 1449 1450 unhexlified = spdk_unhexlify(psk_reference); 1451 CU_ASSERT(unhexlified != NULL); 1452 1453 memcpy(unhexlified_str, unhexlified, strlen(psk_reference) / 2); 1454 free(unhexlified); 1455 1456 retained_size = nvme_tcp_derive_retained_psk(unhexlified_str, strlen(psk_reference) / 2, hostnqn, 1457 psk_retained, SPDK_TLS_PSK_MAX_LEN, NVME_TCP_HASH_ALGORITHM_SHA256); 1458 CU_ASSERT(retained_size > 0); 1459 1460 /* Make sure that different cipher suites produce different TLS PSKs. */ 1461 tls_size = nvme_tcp_derive_tls_psk(psk_retained, retained_size, psk_id_reference, psk_key1, 1462 SPDK_TLS_PSK_MAX_LEN, NVME_TCP_CIPHER_AES_128_GCM_SHA256); 1463 CU_ASSERT(tls_size > 0); 1464 CU_ASSERT(nvme_tcp_derive_tls_psk(psk_retained, retained_size, psk_id_reference, psk_key2, 1465 SPDK_TLS_PSK_MAX_LEN, NVME_TCP_CIPHER_AES_256_GCM_SHA384) > 0); 1466 CU_ASSERT(memcmp(psk_key1, psk_key2, tls_size) != 0); 1467 1468 /* Make sure that passing unknown value as hash errors out the function. */ 1469 CU_ASSERT(nvme_tcp_derive_tls_psk(psk_retained, retained_size, psk_id_reference, 1470 psk_key1, SPDK_TLS_PSK_MAX_LEN, UINT8_MAX) < 0); 1471 1472 /* Make sure that passing buffer insufficient in size errors out the function. */ 1473 CU_ASSERT(nvme_tcp_derive_tls_psk(psk_retained, retained_size, psk_id_reference, 1474 too_small_psk_tls, sizeof(too_small_psk_tls), 1475 NVME_TCP_CIPHER_AES_128_GCM_SHA256) < 0); 1476 } 1477 1478 int 1479 main(int argc, char **argv) 1480 { 1481 CU_pSuite suite = NULL; 1482 unsigned int num_failures; 1483 1484 CU_initialize_registry(); 1485 1486 suite = CU_add_suite("nvmf", NULL, NULL); 1487 1488 CU_ADD_TEST(suite, test_nvmf_tcp_create); 1489 CU_ADD_TEST(suite, test_nvmf_tcp_destroy); 1490 CU_ADD_TEST(suite, test_nvmf_tcp_poll_group_create); 1491 CU_ADD_TEST(suite, test_nvmf_tcp_send_c2h_data); 1492 CU_ADD_TEST(suite, test_nvmf_tcp_h2c_data_hdr_handle); 1493 CU_ADD_TEST(suite, test_nvmf_tcp_in_capsule_data_handle); 1494 CU_ADD_TEST(suite, test_nvmf_tcp_qpair_init_mem_resource); 1495 CU_ADD_TEST(suite, test_nvmf_tcp_send_c2h_term_req); 1496 CU_ADD_TEST(suite, test_nvmf_tcp_send_capsule_resp_pdu); 1497 CU_ADD_TEST(suite, test_nvmf_tcp_icreq_handle); 1498 CU_ADD_TEST(suite, test_nvmf_tcp_check_xfer_type); 1499 CU_ADD_TEST(suite, test_nvmf_tcp_invalid_sgl); 1500 CU_ADD_TEST(suite, test_nvmf_tcp_pdu_ch_handle); 1501 CU_ADD_TEST(suite, test_nvmf_tcp_tls_add_remove_credentials); 1502 CU_ADD_TEST(suite, test_nvmf_tcp_tls_generate_psk_id); 1503 CU_ADD_TEST(suite, test_nvmf_tcp_tls_generate_retained_psk); 1504 CU_ADD_TEST(suite, test_nvmf_tcp_tls_generate_tls_psk); 1505 1506 num_failures = spdk_ut_run_tests(argc, argv, NULL); 1507 CU_cleanup_registry(); 1508 return num_failures; 1509 } 1510