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