1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) Intel Corporation. All rights reserved. 3 * Copyright (c) 2020, 2021 Mellanox Technologies LTD. All rights reserved. 4 * Copyright (c) 2021, 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk/stdinc.h" 8 9 #include "spdk_cunit.h" 10 11 #include "spdk/log.h" 12 13 #include "common/lib/test_env.c" 14 15 #include "nvme/nvme_ctrlr.c" 16 #include "nvme/nvme_quirks.c" 17 18 SPDK_LOG_REGISTER_COMPONENT(nvme) 19 20 pid_t g_spdk_nvme_pid; 21 22 struct nvme_driver _g_nvme_driver = { 23 .lock = PTHREAD_MUTEX_INITIALIZER, 24 }; 25 26 struct nvme_driver *g_spdk_nvme_driver = &_g_nvme_driver; 27 28 struct spdk_nvme_registers g_ut_nvme_regs = {}; 29 typedef void (*set_reg_cb)(void); 30 set_reg_cb g_set_reg_cb; 31 32 __thread int nvme_thread_ioq_index = -1; 33 34 uint32_t set_size = 1; 35 36 int set_status_cpl = -1; 37 38 DEFINE_STUB(nvme_ctrlr_cmd_set_host_id, int, 39 (struct spdk_nvme_ctrlr *ctrlr, void *host_id, uint32_t host_id_size, 40 spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 41 DEFINE_STUB_V(nvme_ns_set_identify_data, (struct spdk_nvme_ns *ns)); 42 DEFINE_STUB_V(nvme_ns_set_id_desc_list_data, (struct spdk_nvme_ns *ns)); 43 DEFINE_STUB_V(nvme_ns_free_iocs_specific_data, (struct spdk_nvme_ns *ns)); 44 DEFINE_STUB_V(nvme_qpair_abort_all_queued_reqs, (struct spdk_nvme_qpair *qpair, uint32_t dnr)); 45 DEFINE_STUB(spdk_nvme_poll_group_remove, int, (struct spdk_nvme_poll_group *group, 46 struct spdk_nvme_qpair *qpair), 0); 47 DEFINE_STUB_V(nvme_io_msg_ctrlr_update, (struct spdk_nvme_ctrlr *ctrlr)); 48 DEFINE_STUB(nvme_io_msg_process, int, (struct spdk_nvme_ctrlr *ctrlr), 0); 49 DEFINE_STUB(nvme_transport_ctrlr_reserve_cmb, int, (struct spdk_nvme_ctrlr *ctrlr), 0); 50 DEFINE_STUB(spdk_nvme_ctrlr_cmd_security_receive, int, (struct spdk_nvme_ctrlr *ctrlr, 51 uint8_t secp, uint16_t spsp, uint8_t nssf, void *payload, 52 uint32_t payload_size, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 53 DEFINE_STUB(spdk_nvme_ctrlr_cmd_security_send, int, (struct spdk_nvme_ctrlr *ctrlr, 54 uint8_t secp, uint16_t spsp, uint8_t nssf, void *payload, 55 uint32_t payload_size, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 56 DEFINE_STUB_V(nvme_qpair_abort_queued_reqs, (struct spdk_nvme_qpair *qpair, uint32_t dnr)); 57 58 DEFINE_RETURN_MOCK(nvme_transport_ctrlr_get_memory_domains, int); 59 int 60 nvme_transport_ctrlr_get_memory_domains(const struct spdk_nvme_ctrlr *ctrlr, 61 struct spdk_memory_domain **domains, int array_size) 62 { 63 HANDLE_RETURN_MOCK(nvme_transport_ctrlr_get_memory_domains); 64 65 return 0; 66 } 67 68 struct spdk_nvme_ctrlr *nvme_transport_ctrlr_construct(const struct spdk_nvme_transport_id *trid, 69 const struct spdk_nvme_ctrlr_opts *opts, 70 void *devhandle) 71 { 72 return NULL; 73 } 74 75 int 76 nvme_transport_ctrlr_destruct(struct spdk_nvme_ctrlr *ctrlr) 77 { 78 nvme_ctrlr_destruct_finish(ctrlr); 79 80 return 0; 81 } 82 83 int 84 nvme_transport_ctrlr_enable(struct spdk_nvme_ctrlr *ctrlr) 85 { 86 return 0; 87 } 88 89 int 90 nvme_transport_ctrlr_set_reg_4(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, uint32_t value) 91 { 92 SPDK_CU_ASSERT_FATAL(offset <= sizeof(struct spdk_nvme_registers) - 4); 93 *(uint32_t *)((uintptr_t)&g_ut_nvme_regs + offset) = value; 94 if (g_set_reg_cb) { 95 g_set_reg_cb(); 96 } 97 return 0; 98 } 99 100 int 101 nvme_transport_ctrlr_set_reg_8(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, uint64_t value) 102 { 103 SPDK_CU_ASSERT_FATAL(offset <= sizeof(struct spdk_nvme_registers) - 8); 104 *(uint64_t *)((uintptr_t)&g_ut_nvme_regs + offset) = value; 105 if (g_set_reg_cb) { 106 g_set_reg_cb(); 107 } 108 return 0; 109 } 110 111 int 112 nvme_transport_ctrlr_get_reg_4(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, uint32_t *value) 113 { 114 SPDK_CU_ASSERT_FATAL(offset <= sizeof(struct spdk_nvme_registers) - 4); 115 *value = *(uint32_t *)((uintptr_t)&g_ut_nvme_regs + offset); 116 return 0; 117 } 118 119 int 120 nvme_transport_ctrlr_get_reg_8(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, uint64_t *value) 121 { 122 SPDK_CU_ASSERT_FATAL(offset <= sizeof(struct spdk_nvme_registers) - 8); 123 *value = *(uint64_t *)((uintptr_t)&g_ut_nvme_regs + offset); 124 return 0; 125 } 126 127 int 128 nvme_transport_ctrlr_set_reg_4_async(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, 129 uint32_t value, spdk_nvme_reg_cb cb_fn, void *cb_arg) 130 { 131 struct spdk_nvme_cpl cpl = {}; 132 133 cpl.status.sct = SPDK_NVME_SCT_GENERIC; 134 cpl.status.sc = SPDK_NVME_SC_SUCCESS; 135 136 nvme_transport_ctrlr_set_reg_4(ctrlr, offset, value); 137 cb_fn(cb_arg, value, &cpl); 138 return 0; 139 } 140 141 int 142 nvme_transport_ctrlr_set_reg_8_async(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, 143 uint64_t value, spdk_nvme_reg_cb cb_fn, void *cb_arg) 144 { 145 struct spdk_nvme_cpl cpl = {}; 146 147 cpl.status.sct = SPDK_NVME_SCT_GENERIC; 148 cpl.status.sc = SPDK_NVME_SC_SUCCESS; 149 150 nvme_transport_ctrlr_set_reg_8(ctrlr, offset, value); 151 cb_fn(cb_arg, value, &cpl); 152 return 0; 153 } 154 155 int 156 nvme_transport_ctrlr_get_reg_4_async(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, 157 spdk_nvme_reg_cb cb_fn, void *cb_arg) 158 { 159 struct spdk_nvme_cpl cpl = {}; 160 uint32_t value; 161 162 cpl.status.sct = SPDK_NVME_SCT_GENERIC; 163 cpl.status.sc = SPDK_NVME_SC_SUCCESS; 164 165 nvme_transport_ctrlr_get_reg_4(ctrlr, offset, &value); 166 cb_fn(cb_arg, value, &cpl); 167 return 0; 168 } 169 170 int 171 nvme_transport_ctrlr_get_reg_8_async(struct spdk_nvme_ctrlr *ctrlr, uint32_t offset, 172 spdk_nvme_reg_cb cb_fn, void *cb_arg) 173 { 174 struct spdk_nvme_cpl cpl = {}; 175 uint64_t value; 176 177 cpl.status.sct = SPDK_NVME_SCT_GENERIC; 178 cpl.status.sc = SPDK_NVME_SC_SUCCESS; 179 180 nvme_transport_ctrlr_get_reg_8(ctrlr, offset, &value); 181 cb_fn(cb_arg, value, &cpl); 182 return 0; 183 } 184 185 uint32_t 186 nvme_transport_ctrlr_get_max_xfer_size(struct spdk_nvme_ctrlr *ctrlr) 187 { 188 return UINT32_MAX; 189 } 190 191 uint16_t 192 nvme_transport_ctrlr_get_max_sges(struct spdk_nvme_ctrlr *ctrlr) 193 { 194 return 1; 195 } 196 197 void * 198 nvme_transport_ctrlr_map_cmb(struct spdk_nvme_ctrlr *ctrlr, size_t *size) 199 { 200 return NULL; 201 } 202 203 int 204 nvme_transport_ctrlr_unmap_cmb(struct spdk_nvme_ctrlr *ctrlr) 205 { 206 return 0; 207 } 208 209 int 210 nvme_transport_ctrlr_enable_pmr(struct spdk_nvme_ctrlr *ctrlr) 211 { 212 return 0; 213 } 214 215 int 216 nvme_transport_ctrlr_disable_pmr(struct spdk_nvme_ctrlr *ctrlr) 217 { 218 return 0; 219 } 220 221 void * 222 nvme_transport_ctrlr_map_pmr(struct spdk_nvme_ctrlr *ctrlr, size_t *size) 223 { 224 return NULL; 225 } 226 227 int 228 nvme_transport_ctrlr_unmap_pmr(struct spdk_nvme_ctrlr *ctrlr) 229 { 230 return 0; 231 } 232 233 struct spdk_nvme_qpair * 234 nvme_transport_ctrlr_create_io_qpair(struct spdk_nvme_ctrlr *ctrlr, uint16_t qid, 235 const struct spdk_nvme_io_qpair_opts *opts) 236 { 237 struct spdk_nvme_qpair *qpair; 238 239 qpair = calloc(1, sizeof(*qpair)); 240 SPDK_CU_ASSERT_FATAL(qpair != NULL); 241 242 qpair->ctrlr = ctrlr; 243 qpair->id = qid; 244 qpair->qprio = opts->qprio; 245 246 return qpair; 247 } 248 249 void 250 nvme_transport_ctrlr_delete_io_qpair(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair) 251 { 252 free(qpair); 253 } 254 255 void 256 nvme_transport_ctrlr_disconnect_qpair(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair) 257 { 258 } 259 260 int 261 nvme_transport_qpair_reset(struct spdk_nvme_qpair *qpair) 262 { 263 return 0; 264 } 265 266 void 267 nvme_transport_admin_qpair_abort_aers(struct spdk_nvme_qpair *qpair) 268 { 269 } 270 271 void 272 nvme_transport_qpair_abort_reqs(struct spdk_nvme_qpair *qpair, uint32_t dnr) 273 { 274 } 275 276 int 277 nvme_driver_init(void) 278 { 279 return 0; 280 } 281 282 int 283 nvme_qpair_init(struct spdk_nvme_qpair *qpair, uint16_t id, 284 struct spdk_nvme_ctrlr *ctrlr, 285 enum spdk_nvme_qprio qprio, 286 uint32_t num_requests, bool async) 287 { 288 qpair->id = id; 289 qpair->qprio = qprio; 290 qpair->ctrlr = ctrlr; 291 qpair->async = async; 292 293 return 0; 294 } 295 296 static struct spdk_nvme_cpl fake_cpl = {}; 297 static enum spdk_nvme_generic_command_status_code set_status_code = SPDK_NVME_SC_SUCCESS; 298 299 static void 300 fake_cpl_sc(spdk_nvme_cmd_cb cb_fn, void *cb_arg) 301 { 302 fake_cpl.status.sc = set_status_code; 303 cb_fn(cb_arg, &fake_cpl); 304 } 305 306 static uint32_t g_ut_cdw11; 307 308 int 309 spdk_nvme_ctrlr_cmd_set_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature, 310 uint32_t cdw11, uint32_t cdw12, void *payload, uint32_t payload_size, 311 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 312 { 313 g_ut_cdw11 = cdw11; 314 return 0; 315 } 316 317 int 318 spdk_nvme_ctrlr_cmd_get_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature, 319 uint32_t cdw11, void *payload, uint32_t payload_size, 320 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 321 { 322 fake_cpl_sc(cb_fn, cb_arg); 323 return 0; 324 } 325 326 struct spdk_nvme_ana_page *g_ana_hdr; 327 struct spdk_nvme_ana_group_descriptor **g_ana_descs; 328 329 int 330 spdk_nvme_ctrlr_cmd_get_log_page(struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page, 331 uint32_t nsid, void *payload, uint32_t payload_size, 332 uint64_t offset, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 333 { 334 if ((log_page == SPDK_NVME_LOG_ASYMMETRIC_NAMESPACE_ACCESS) && g_ana_hdr) { 335 uint32_t i; 336 uint8_t *ptr = payload; 337 338 memset(payload, 0, payload_size); 339 memcpy(ptr, g_ana_hdr, sizeof(*g_ana_hdr)); 340 ptr += sizeof(*g_ana_hdr); 341 for (i = 0; i < g_ana_hdr->num_ana_group_desc; ++i) { 342 uint32_t desc_size = sizeof(**g_ana_descs) + 343 g_ana_descs[i]->num_of_nsid * sizeof(uint32_t); 344 memcpy(ptr, g_ana_descs[i], desc_size); 345 ptr += desc_size; 346 } 347 } else if (log_page == SPDK_NVME_INTEL_LOG_PAGE_DIRECTORY) { 348 struct spdk_nvme_intel_log_page_directory *log_page_directory = payload; 349 log_page_directory->read_latency_log_len = true; 350 log_page_directory->write_latency_log_len = true; 351 log_page_directory->temperature_statistics_log_len = true; 352 log_page_directory->smart_log_len = true; 353 log_page_directory->marketing_description_log_len = true; 354 } 355 356 fake_cpl_sc(cb_fn, cb_arg); 357 return 0; 358 } 359 360 int 361 spdk_nvme_ctrlr_cmd_get_log_page_ext(struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page, 362 uint32_t nsid, void *payload, uint32_t payload_size, 363 uint64_t offset, uint32_t cdw10, uint32_t cdw11, 364 uint32_t cdw14, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 365 { 366 fake_cpl_sc(cb_fn, cb_arg); 367 return 0; 368 } 369 370 int 371 nvme_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_request *req) 372 { 373 CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_ASYNC_EVENT_REQUEST); 374 STAILQ_INSERT_HEAD(&qpair->free_req, req, stailq); 375 376 /* 377 * For the purposes of this unit test, we don't need to bother emulating request submission. 378 */ 379 380 return 0; 381 } 382 383 static int32_t g_wait_for_completion_return_val; 384 385 int32_t 386 spdk_nvme_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_completions) 387 { 388 return g_wait_for_completion_return_val; 389 } 390 391 void 392 nvme_qpair_complete_error_reqs(struct spdk_nvme_qpair *qpair) 393 { 394 } 395 396 397 void 398 nvme_completion_poll_cb(void *arg, const struct spdk_nvme_cpl *cpl) 399 { 400 struct nvme_completion_poll_status *status = arg; 401 /* This should not happen it test env since this callback is always called 402 * before wait_for_completion_* while this field can only be set to true in 403 * wait_for_completion_* functions */ 404 CU_ASSERT(status->timed_out == false); 405 406 status->cpl = *cpl; 407 status->done = true; 408 } 409 410 static struct nvme_completion_poll_status *g_failed_status; 411 412 int 413 nvme_wait_for_completion_robust_lock_timeout( 414 struct spdk_nvme_qpair *qpair, 415 struct nvme_completion_poll_status *status, 416 pthread_mutex_t *robust_mutex, 417 uint64_t timeout_in_usecs) 418 { 419 if (spdk_nvme_qpair_process_completions(qpair, 0) < 0) { 420 g_failed_status = status; 421 status->timed_out = true; 422 return -1; 423 } 424 425 status->done = true; 426 if (set_status_cpl == 1) { 427 status->cpl.status.sc = 1; 428 } 429 return spdk_nvme_cpl_is_error(&status->cpl) ? -EIO : 0; 430 } 431 432 int 433 nvme_wait_for_completion_robust_lock( 434 struct spdk_nvme_qpair *qpair, 435 struct nvme_completion_poll_status *status, 436 pthread_mutex_t *robust_mutex) 437 { 438 return nvme_wait_for_completion_robust_lock_timeout(qpair, status, robust_mutex, 0); 439 } 440 441 int 442 nvme_wait_for_completion(struct spdk_nvme_qpair *qpair, 443 struct nvme_completion_poll_status *status) 444 { 445 return nvme_wait_for_completion_robust_lock_timeout(qpair, status, NULL, 0); 446 } 447 448 int 449 nvme_wait_for_completion_timeout(struct spdk_nvme_qpair *qpair, 450 struct nvme_completion_poll_status *status, 451 uint64_t timeout_in_usecs) 452 { 453 return nvme_wait_for_completion_robust_lock_timeout(qpair, status, NULL, timeout_in_usecs); 454 } 455 456 int 457 nvme_ctrlr_cmd_set_async_event_config(struct spdk_nvme_ctrlr *ctrlr, 458 union spdk_nvme_feat_async_event_configuration config, spdk_nvme_cmd_cb cb_fn, 459 void *cb_arg) 460 { 461 fake_cpl_sc(cb_fn, cb_arg); 462 return 0; 463 } 464 465 static uint32_t *g_active_ns_list = NULL; 466 static uint32_t g_active_ns_list_length = 0; 467 static struct spdk_nvme_ctrlr_data *g_cdata = NULL; 468 static bool g_fail_next_identify = false; 469 470 int 471 nvme_ctrlr_cmd_identify(struct spdk_nvme_ctrlr *ctrlr, uint8_t cns, uint16_t cntid, uint32_t nsid, 472 uint8_t csi, void *payload, size_t payload_size, 473 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 474 { 475 if (g_fail_next_identify) { 476 g_fail_next_identify = false; 477 return 1; 478 } 479 480 memset(payload, 0, payload_size); 481 if (cns == SPDK_NVME_IDENTIFY_ACTIVE_NS_LIST) { 482 uint32_t count = 0; 483 uint32_t i = 0; 484 struct spdk_nvme_ns_list *ns_list = (struct spdk_nvme_ns_list *)payload; 485 486 if (g_active_ns_list == NULL) { 487 for (i = 1; i <= ctrlr->cdata.nn; i++) { 488 if (i <= nsid) { 489 continue; 490 } 491 492 ns_list->ns_list[count++] = i; 493 if (count == SPDK_COUNTOF(ns_list->ns_list)) { 494 break; 495 } 496 } 497 } else { 498 for (i = 0; i < g_active_ns_list_length; i++) { 499 uint32_t cur_nsid = g_active_ns_list[i]; 500 if (cur_nsid <= nsid) { 501 continue; 502 } 503 504 ns_list->ns_list[count++] = cur_nsid; 505 if (count == SPDK_COUNTOF(ns_list->ns_list)) { 506 break; 507 } 508 } 509 } 510 } else if (cns == SPDK_NVME_IDENTIFY_CTRLR) { 511 if (g_cdata) { 512 memcpy(payload, g_cdata, sizeof(*g_cdata)); 513 } 514 } else if (cns == SPDK_NVME_IDENTIFY_NS_IOCS) { 515 return 0; 516 } 517 518 fake_cpl_sc(cb_fn, cb_arg); 519 return 0; 520 } 521 522 int 523 nvme_ctrlr_cmd_set_num_queues(struct spdk_nvme_ctrlr *ctrlr, 524 uint32_t num_queues, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 525 { 526 fake_cpl_sc(cb_fn, cb_arg); 527 return 0; 528 } 529 530 int 531 nvme_ctrlr_cmd_get_num_queues(struct spdk_nvme_ctrlr *ctrlr, 532 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 533 { 534 CU_ASSERT(0); 535 return -1; 536 } 537 538 int 539 nvme_ctrlr_cmd_attach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, 540 struct spdk_nvme_ctrlr_list *payload, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 541 { 542 return 0; 543 } 544 545 int 546 nvme_ctrlr_cmd_detach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, 547 struct spdk_nvme_ctrlr_list *payload, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 548 { 549 return 0; 550 } 551 552 int 553 nvme_ctrlr_cmd_create_ns(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_ns_data *payload, 554 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 555 { 556 fake_cpl_sc(cb_fn, cb_arg); 557 return 0; 558 } 559 560 int 561 nvme_ctrlr_cmd_delete_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, spdk_nvme_cmd_cb cb_fn, 562 void *cb_arg) 563 { 564 return 0; 565 } 566 567 int 568 nvme_ctrlr_cmd_format(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, struct spdk_nvme_format *format, 569 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 570 { 571 return 0; 572 } 573 574 int 575 spdk_nvme_ctrlr_cmd_directive_send(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, 576 uint32_t doper, uint32_t dtype, uint32_t dspec, 577 void *payload, uint32_t payload_size, uint32_t cdw12, 578 uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 579 { 580 return 0; 581 } 582 583 int 584 spdk_nvme_ctrlr_cmd_directive_receive(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, 585 uint32_t doper, uint32_t dtype, uint32_t dspec, 586 void *payload, uint32_t payload_size, uint32_t cdw12, 587 uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 588 { 589 return 0; 590 } 591 592 int 593 nvme_ctrlr_cmd_fw_commit(struct spdk_nvme_ctrlr *ctrlr, const struct spdk_nvme_fw_commit *fw_commit, 594 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 595 { 596 CU_ASSERT(fw_commit->ca == SPDK_NVME_FW_COMMIT_REPLACE_IMG); 597 if (fw_commit->fs == 0) { 598 return -1; 599 } 600 set_status_cpl = 1; 601 if (ctrlr->is_resetting == true) { 602 set_status_cpl = 0; 603 } 604 return 0; 605 } 606 607 int 608 nvme_ctrlr_cmd_fw_image_download(struct spdk_nvme_ctrlr *ctrlr, 609 uint32_t size, uint32_t offset, void *payload, 610 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 611 { 612 if ((size != 0 && payload == NULL) || (size == 0 && payload != NULL)) { 613 return -1; 614 } 615 CU_ASSERT(offset == 0); 616 return 0; 617 } 618 619 bool 620 nvme_ns_has_supported_iocs_specific_data(struct spdk_nvme_ns *ns) 621 { 622 switch (ns->csi) { 623 case SPDK_NVME_CSI_NVM: 624 /* 625 * NVM Command Set Specific Identify Namespace data structure 626 * is currently all-zeroes, reserved for future use. 627 */ 628 return false; 629 case SPDK_NVME_CSI_ZNS: 630 return true; 631 default: 632 SPDK_WARNLOG("Unsupported CSI: %u for NSID: %u\n", ns->csi, ns->id); 633 return false; 634 } 635 } 636 637 void 638 nvme_ns_free_zns_specific_data(struct spdk_nvme_ns *ns) 639 { 640 if (!ns->id) { 641 return; 642 } 643 644 if (ns->nsdata_zns) { 645 spdk_free(ns->nsdata_zns); 646 ns->nsdata_zns = NULL; 647 } 648 } 649 650 void 651 nvme_ns_destruct(struct spdk_nvme_ns *ns) 652 { 653 } 654 655 int 656 nvme_ns_construct(struct spdk_nvme_ns *ns, uint32_t id, 657 struct spdk_nvme_ctrlr *ctrlr) 658 { 659 return 0; 660 } 661 662 void 663 spdk_pci_device_detach(struct spdk_pci_device *device) 664 { 665 } 666 667 #define DECLARE_AND_CONSTRUCT_CTRLR() \ 668 struct spdk_nvme_ctrlr ctrlr = {}; \ 669 struct spdk_nvme_qpair adminq = {}; \ 670 struct nvme_request req; \ 671 \ 672 STAILQ_INIT(&adminq.free_req); \ 673 STAILQ_INSERT_HEAD(&adminq.free_req, &req, stailq); \ 674 ctrlr.adminq = &adminq; 675 676 static void 677 test_nvme_ctrlr_init_en_1_rdy_0(void) 678 { 679 DECLARE_AND_CONSTRUCT_CTRLR(); 680 681 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 682 683 /* 684 * Initial state: CC.EN = 1, CSTS.RDY = 0 685 */ 686 g_ut_nvme_regs.cc.bits.en = 1; 687 g_ut_nvme_regs.csts.bits.rdy = 0; 688 689 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 690 ctrlr.cdata.nn = 1; 691 ctrlr.page_size = 0x1000; 692 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 693 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 694 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 695 } 696 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 697 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_1); 698 699 /* 700 * Transition to CSTS.RDY = 1. 701 * init() should set CC.EN = 0. 702 */ 703 g_ut_nvme_regs.csts.bits.rdy = 1; 704 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 705 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_EN_0); 706 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 707 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 708 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 709 710 /* 711 * Transition to CSTS.RDY = 0. 712 */ 713 g_ut_nvme_regs.csts.bits.rdy = 0; 714 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 715 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 716 717 /* 718 * Start enabling the controller. 719 */ 720 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 721 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 722 723 /* 724 * Transition to CC.EN = 1 725 */ 726 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 727 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 728 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 729 730 /* 731 * Transition to CSTS.RDY = 1. 732 */ 733 g_ut_nvme_regs.csts.bits.rdy = 1; 734 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 735 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 736 737 /* 738 * Transition to READY. 739 */ 740 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 741 nvme_ctrlr_process_init(&ctrlr); 742 } 743 744 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 745 nvme_ctrlr_destruct(&ctrlr); 746 } 747 748 static void 749 test_nvme_ctrlr_init_en_1_rdy_1(void) 750 { 751 DECLARE_AND_CONSTRUCT_CTRLR(); 752 753 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 754 755 /* 756 * Initial state: CC.EN = 1, CSTS.RDY = 1 757 * init() should set CC.EN = 0. 758 */ 759 g_ut_nvme_regs.cc.bits.en = 1; 760 g_ut_nvme_regs.csts.bits.rdy = 1; 761 762 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 763 ctrlr.cdata.nn = 1; 764 ctrlr.page_size = 0x1000; 765 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 766 while (ctrlr.state != NVME_CTRLR_STATE_SET_EN_0) { 767 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 768 } 769 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 770 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 771 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 772 773 /* 774 * Transition to CSTS.RDY = 0. 775 */ 776 g_ut_nvme_regs.csts.bits.rdy = 0; 777 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 778 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 779 780 /* 781 * Start enabling the controller. 782 */ 783 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 784 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 785 786 /* 787 * Transition to CC.EN = 1 788 */ 789 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 790 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 791 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 792 793 /* 794 * Transition to CSTS.RDY = 1. 795 */ 796 g_ut_nvme_regs.csts.bits.rdy = 1; 797 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 798 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 799 800 /* 801 * Transition to READY. 802 */ 803 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 804 nvme_ctrlr_process_init(&ctrlr); 805 } 806 807 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 808 nvme_ctrlr_destruct(&ctrlr); 809 } 810 811 static void 812 test_nvme_ctrlr_init_en_0_rdy_0_ams_rr(void) 813 { 814 DECLARE_AND_CONSTRUCT_CTRLR(); 815 816 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 817 818 /* 819 * Initial state: CC.EN = 0, CSTS.RDY = 0 820 * init() should set CC.EN = 1. 821 */ 822 g_ut_nvme_regs.cc.bits.en = 0; 823 g_ut_nvme_regs.csts.bits.rdy = 0; 824 825 /* 826 * Default round robin enabled 827 */ 828 g_ut_nvme_regs.cap.bits.ams = 0x0; 829 ctrlr.cap = g_ut_nvme_regs.cap; 830 831 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 832 ctrlr.cdata.nn = 1; 833 ctrlr.page_size = 0x1000; 834 /* 835 * Case 1: default round robin arbitration mechanism selected 836 */ 837 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_RR; 838 839 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 840 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 841 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 842 } 843 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 844 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 845 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 846 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 847 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 848 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 849 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 850 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 851 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 852 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_RR); 853 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_RR); 854 855 /* 856 * Complete and destroy the controller 857 */ 858 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 859 nvme_ctrlr_destruct(&ctrlr); 860 861 /* 862 * Reset to initial state 863 */ 864 g_ut_nvme_regs.cc.bits.en = 0; 865 g_ut_nvme_regs.csts.bits.rdy = 0; 866 867 /* 868 * Case 2: weighted round robin arbitration mechanism selected 869 */ 870 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 871 ctrlr.cdata.nn = 1; 872 ctrlr.page_size = 0x1000; 873 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_WRR; 874 875 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 876 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 877 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 878 } 879 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 880 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 881 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 882 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 883 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 884 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 885 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) != 0); 886 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 887 888 /* 889 * Complete and destroy the controller 890 */ 891 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 892 nvme_ctrlr_destruct(&ctrlr); 893 894 /* 895 * Reset to initial state 896 */ 897 g_ut_nvme_regs.cc.bits.en = 0; 898 g_ut_nvme_regs.csts.bits.rdy = 0; 899 900 /* 901 * Case 3: vendor specific arbitration mechanism selected 902 */ 903 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 904 ctrlr.cdata.nn = 1; 905 ctrlr.page_size = 0x1000; 906 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_VS; 907 908 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 909 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 910 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 911 } 912 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 913 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 914 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 915 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 916 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 917 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 918 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) != 0); 919 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 920 921 /* 922 * Complete and destroy the controller 923 */ 924 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 925 nvme_ctrlr_destruct(&ctrlr); 926 927 /* 928 * Reset to initial state 929 */ 930 g_ut_nvme_regs.cc.bits.en = 0; 931 g_ut_nvme_regs.csts.bits.rdy = 0; 932 933 /* 934 * Case 4: invalid arbitration mechanism selected 935 */ 936 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 937 ctrlr.cdata.nn = 1; 938 ctrlr.page_size = 0x1000; 939 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_VS + 1; 940 941 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 942 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 943 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 944 } 945 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 946 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 947 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 948 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 949 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 950 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 951 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) != 0); 952 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 953 954 /* 955 * Complete and destroy the controller 956 */ 957 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 958 nvme_ctrlr_destruct(&ctrlr); 959 960 /* 961 * Reset to initial state 962 */ 963 g_ut_nvme_regs.cc.bits.en = 0; 964 g_ut_nvme_regs.csts.bits.rdy = 0; 965 966 /* 967 * Case 5: reset to default round robin arbitration mechanism 968 */ 969 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 970 ctrlr.cdata.nn = 1; 971 ctrlr.page_size = 0x1000; 972 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_RR; 973 974 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 975 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 976 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 977 } 978 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 979 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 980 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 981 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 982 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 983 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 984 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 985 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 986 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 987 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_RR); 988 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_RR); 989 990 /* 991 * Transition to CSTS.RDY = 1. 992 */ 993 g_ut_nvme_regs.csts.bits.rdy = 1; 994 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 995 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 996 997 /* 998 * Transition to READY. 999 */ 1000 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 1001 nvme_ctrlr_process_init(&ctrlr); 1002 } 1003 1004 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1005 nvme_ctrlr_destruct(&ctrlr); 1006 } 1007 1008 static void 1009 test_nvme_ctrlr_init_en_0_rdy_0_ams_wrr(void) 1010 { 1011 DECLARE_AND_CONSTRUCT_CTRLR(); 1012 1013 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 1014 1015 /* 1016 * Initial state: CC.EN = 0, CSTS.RDY = 0 1017 * init() should set CC.EN = 1. 1018 */ 1019 g_ut_nvme_regs.cc.bits.en = 0; 1020 g_ut_nvme_regs.csts.bits.rdy = 0; 1021 1022 /* 1023 * Weighted round robin enabled 1024 */ 1025 g_ut_nvme_regs.cap.bits.ams = SPDK_NVME_CAP_AMS_WRR; 1026 ctrlr.cap = g_ut_nvme_regs.cap; 1027 1028 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1029 ctrlr.cdata.nn = 1; 1030 ctrlr.page_size = 0x1000; 1031 /* 1032 * Case 1: default round robin arbitration mechanism selected 1033 */ 1034 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_RR; 1035 1036 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1037 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1038 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1039 } 1040 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1041 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1042 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1043 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1044 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1045 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1046 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1047 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1048 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1049 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_RR); 1050 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_RR); 1051 1052 /* 1053 * Complete and destroy the controller 1054 */ 1055 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1056 nvme_ctrlr_destruct(&ctrlr); 1057 1058 /* 1059 * Reset to initial state 1060 */ 1061 g_ut_nvme_regs.cc.bits.en = 0; 1062 g_ut_nvme_regs.csts.bits.rdy = 0; 1063 1064 /* 1065 * Case 2: weighted round robin arbitration mechanism selected 1066 */ 1067 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1068 ctrlr.cdata.nn = 1; 1069 ctrlr.page_size = 0x1000; 1070 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_WRR; 1071 1072 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1073 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1074 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1075 } 1076 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1077 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1078 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1079 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1080 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1081 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1082 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1083 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1084 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1085 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_WRR); 1086 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_WRR); 1087 1088 /* 1089 * Complete and destroy the controller 1090 */ 1091 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1092 nvme_ctrlr_destruct(&ctrlr); 1093 1094 /* 1095 * Reset to initial state 1096 */ 1097 g_ut_nvme_regs.cc.bits.en = 0; 1098 g_ut_nvme_regs.csts.bits.rdy = 0; 1099 1100 /* 1101 * Case 3: vendor specific arbitration mechanism selected 1102 */ 1103 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1104 ctrlr.cdata.nn = 1; 1105 ctrlr.page_size = 0x1000; 1106 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_VS; 1107 1108 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1109 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1110 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1111 } 1112 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1113 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1114 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1115 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1116 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1117 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1118 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) != 0); 1119 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 1120 1121 /* 1122 * Complete and destroy the controller 1123 */ 1124 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1125 nvme_ctrlr_destruct(&ctrlr); 1126 1127 /* 1128 * Reset to initial state 1129 */ 1130 g_ut_nvme_regs.cc.bits.en = 0; 1131 g_ut_nvme_regs.csts.bits.rdy = 0; 1132 1133 /* 1134 * Case 4: invalid arbitration mechanism selected 1135 */ 1136 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1137 ctrlr.cdata.nn = 1; 1138 ctrlr.page_size = 0x1000; 1139 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_VS + 1; 1140 1141 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1142 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1143 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1144 } 1145 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1146 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1147 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1148 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1149 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1150 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1151 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) != 0); 1152 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 1153 1154 /* 1155 * Complete and destroy the controller 1156 */ 1157 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1158 nvme_ctrlr_destruct(&ctrlr); 1159 1160 /* 1161 * Reset to initial state 1162 */ 1163 g_ut_nvme_regs.cc.bits.en = 0; 1164 g_ut_nvme_regs.csts.bits.rdy = 0; 1165 1166 /* 1167 * Case 5: reset to weighted round robin arbitration mechanism 1168 */ 1169 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1170 ctrlr.cdata.nn = 1; 1171 ctrlr.page_size = 0x1000; 1172 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_WRR; 1173 1174 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1175 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1176 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1177 } 1178 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1179 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1180 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1181 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1182 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1183 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1184 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1185 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1186 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1187 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_WRR); 1188 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_WRR); 1189 1190 /* 1191 * Transition to CSTS.RDY = 1. 1192 */ 1193 g_ut_nvme_regs.csts.bits.rdy = 1; 1194 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1195 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 1196 1197 /* 1198 * Transition to READY. 1199 */ 1200 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 1201 nvme_ctrlr_process_init(&ctrlr); 1202 } 1203 1204 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1205 nvme_ctrlr_destruct(&ctrlr); 1206 } 1207 static void 1208 test_nvme_ctrlr_init_en_0_rdy_0_ams_vs(void) 1209 { 1210 DECLARE_AND_CONSTRUCT_CTRLR(); 1211 1212 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 1213 1214 /* 1215 * Initial state: CC.EN = 0, CSTS.RDY = 0 1216 * init() should set CC.EN = 1. 1217 */ 1218 g_ut_nvme_regs.cc.bits.en = 0; 1219 g_ut_nvme_regs.csts.bits.rdy = 0; 1220 1221 /* 1222 * Default round robin enabled 1223 */ 1224 g_ut_nvme_regs.cap.bits.ams = SPDK_NVME_CAP_AMS_VS; 1225 ctrlr.cap = g_ut_nvme_regs.cap; 1226 1227 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1228 ctrlr.cdata.nn = 1; 1229 ctrlr.page_size = 0x1000; 1230 /* 1231 * Case 1: default round robin arbitration mechanism selected 1232 */ 1233 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_RR; 1234 1235 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1236 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1237 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1238 } 1239 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1240 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1241 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1242 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1243 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1244 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1245 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1246 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1247 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1248 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_RR); 1249 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_RR); 1250 1251 /* 1252 * Complete and destroy the controller 1253 */ 1254 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1255 nvme_ctrlr_destruct(&ctrlr); 1256 1257 /* 1258 * Reset to initial state 1259 */ 1260 g_ut_nvme_regs.cc.bits.en = 0; 1261 g_ut_nvme_regs.csts.bits.rdy = 0; 1262 1263 /* 1264 * Case 2: weighted round robin arbitration mechanism selected 1265 */ 1266 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1267 ctrlr.cdata.nn = 1; 1268 ctrlr.page_size = 0x1000; 1269 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_WRR; 1270 1271 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1272 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1273 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1274 } 1275 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1276 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1277 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1278 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1279 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1280 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1281 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) != 0); 1282 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 1283 1284 /* 1285 * Complete and destroy the controller 1286 */ 1287 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1288 nvme_ctrlr_destruct(&ctrlr); 1289 1290 /* 1291 * Reset to initial state 1292 */ 1293 g_ut_nvme_regs.cc.bits.en = 0; 1294 g_ut_nvme_regs.csts.bits.rdy = 0; 1295 1296 /* 1297 * Case 3: vendor specific arbitration mechanism selected 1298 */ 1299 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1300 ctrlr.cdata.nn = 1; 1301 ctrlr.page_size = 0x1000; 1302 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_VS; 1303 1304 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1305 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1306 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1307 } 1308 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1309 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1310 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1311 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1312 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1313 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1314 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1315 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1316 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1317 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_VS); 1318 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_VS); 1319 1320 /* 1321 * Complete and destroy the controller 1322 */ 1323 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1324 nvme_ctrlr_destruct(&ctrlr); 1325 1326 /* 1327 * Reset to initial state 1328 */ 1329 g_ut_nvme_regs.cc.bits.en = 0; 1330 g_ut_nvme_regs.csts.bits.rdy = 0; 1331 1332 /* 1333 * Case 4: invalid arbitration mechanism selected 1334 */ 1335 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1336 ctrlr.cdata.nn = 1; 1337 ctrlr.page_size = 0x1000; 1338 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_VS + 1; 1339 1340 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1341 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1342 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1343 } 1344 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1345 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1346 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1347 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1348 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1349 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1350 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) != 0); 1351 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 0); 1352 1353 /* 1354 * Complete and destroy the controller 1355 */ 1356 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1357 nvme_ctrlr_destruct(&ctrlr); 1358 1359 /* 1360 * Reset to initial state 1361 */ 1362 g_ut_nvme_regs.cc.bits.en = 0; 1363 g_ut_nvme_regs.csts.bits.rdy = 0; 1364 1365 /* 1366 * Case 5: reset to vendor specific arbitration mechanism 1367 */ 1368 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1369 ctrlr.cdata.nn = 1; 1370 ctrlr.page_size = 0x1000; 1371 ctrlr.opts.arb_mechanism = SPDK_NVME_CC_AMS_VS; 1372 1373 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1374 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1375 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1376 } 1377 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1378 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1379 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1380 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1381 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1382 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1383 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1384 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1385 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1386 CU_ASSERT(g_ut_nvme_regs.cc.bits.ams == SPDK_NVME_CC_AMS_VS); 1387 CU_ASSERT(ctrlr.opts.arb_mechanism == SPDK_NVME_CC_AMS_VS); 1388 1389 /* 1390 * Transition to CSTS.RDY = 1. 1391 */ 1392 g_ut_nvme_regs.csts.bits.rdy = 1; 1393 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1394 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 1395 1396 /* 1397 * Transition to READY. 1398 */ 1399 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 1400 nvme_ctrlr_process_init(&ctrlr); 1401 } 1402 1403 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1404 nvme_ctrlr_destruct(&ctrlr); 1405 } 1406 1407 static void 1408 test_nvme_ctrlr_init_en_0_rdy_0(void) 1409 { 1410 DECLARE_AND_CONSTRUCT_CTRLR(); 1411 1412 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 1413 1414 /* 1415 * Initial state: CC.EN = 0, CSTS.RDY = 0 1416 * init() should set CC.EN = 1. 1417 */ 1418 g_ut_nvme_regs.cc.bits.en = 0; 1419 g_ut_nvme_regs.csts.bits.rdy = 0; 1420 1421 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1422 ctrlr.cdata.nn = 1; 1423 ctrlr.page_size = 0x1000; 1424 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1425 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1426 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1427 } 1428 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1429 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1430 1431 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1432 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1433 1434 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1435 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1436 1437 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1438 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1439 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1440 1441 /* 1442 * Transition to CSTS.RDY = 1. 1443 */ 1444 g_ut_nvme_regs.csts.bits.rdy = 1; 1445 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1446 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 1447 1448 /* 1449 * Transition to READY. 1450 */ 1451 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 1452 nvme_ctrlr_process_init(&ctrlr); 1453 } 1454 1455 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1456 nvme_ctrlr_destruct(&ctrlr); 1457 } 1458 1459 static void 1460 test_nvme_ctrlr_init_en_0_rdy_1(void) 1461 { 1462 DECLARE_AND_CONSTRUCT_CTRLR(); 1463 1464 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 1465 1466 /* 1467 * Initial state: CC.EN = 0, CSTS.RDY = 1 1468 */ 1469 g_ut_nvme_regs.cc.bits.en = 0; 1470 g_ut_nvme_regs.csts.bits.rdy = 1; 1471 1472 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 1473 ctrlr.cdata.nn = 1; 1474 ctrlr.page_size = 0x1000; 1475 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 1476 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 1477 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1478 } 1479 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1480 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 1481 1482 /* 1483 * Transition to CSTS.RDY = 0. 1484 */ 1485 g_ut_nvme_regs.csts.bits.rdy = 0; 1486 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1487 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 1488 1489 /* 1490 * Start enabling the controller. 1491 */ 1492 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1493 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 1494 1495 /* 1496 * Transition to CC.EN = 1 1497 */ 1498 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1499 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 1500 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 1501 1502 /* 1503 * Transition to CSTS.RDY = 1. 1504 */ 1505 g_ut_nvme_regs.csts.bits.rdy = 1; 1506 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 1507 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 1508 1509 /* 1510 * Transition to READY. 1511 */ 1512 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 1513 nvme_ctrlr_process_init(&ctrlr); 1514 } 1515 1516 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 1517 nvme_ctrlr_destruct(&ctrlr); 1518 } 1519 1520 static void 1521 setup_qpairs(struct spdk_nvme_ctrlr *ctrlr, uint32_t num_io_queues) 1522 { 1523 uint32_t i; 1524 1525 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(ctrlr) == 0); 1526 1527 ctrlr->page_size = 0x1000; 1528 ctrlr->opts.num_io_queues = num_io_queues; 1529 ctrlr->free_io_qids = spdk_bit_array_create(num_io_queues + 1); 1530 ctrlr->state = NVME_CTRLR_STATE_READY; 1531 SPDK_CU_ASSERT_FATAL(ctrlr->free_io_qids != NULL); 1532 1533 spdk_bit_array_clear(ctrlr->free_io_qids, 0); 1534 for (i = 1; i <= num_io_queues; i++) { 1535 spdk_bit_array_set(ctrlr->free_io_qids, i); 1536 } 1537 } 1538 1539 static void 1540 cleanup_qpairs(struct spdk_nvme_ctrlr *ctrlr) 1541 { 1542 nvme_ctrlr_destruct(ctrlr); 1543 } 1544 1545 static void 1546 test_alloc_io_qpair_rr_1(void) 1547 { 1548 struct spdk_nvme_io_qpair_opts opts; 1549 struct spdk_nvme_ctrlr ctrlr = {}; 1550 struct spdk_nvme_qpair *q0; 1551 1552 setup_qpairs(&ctrlr, 1); 1553 1554 /* 1555 * Fake to simulate the controller with default round robin 1556 * arbitration mechanism. 1557 */ 1558 g_ut_nvme_regs.cc.bits.ams = SPDK_NVME_CC_AMS_RR; 1559 1560 spdk_nvme_ctrlr_get_default_io_qpair_opts(&ctrlr, &opts, sizeof(opts)); 1561 1562 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, NULL, 0); 1563 SPDK_CU_ASSERT_FATAL(q0 != NULL); 1564 SPDK_CU_ASSERT_FATAL(q0->qprio == 0); 1565 /* Only 1 I/O qpair was allocated, so this should fail */ 1566 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, NULL, 0) == NULL); 1567 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q0) == 0); 1568 1569 /* 1570 * Now that the qpair has been returned to the free list, 1571 * we should be able to allocate it again. 1572 */ 1573 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, NULL, 0); 1574 SPDK_CU_ASSERT_FATAL(q0 != NULL); 1575 SPDK_CU_ASSERT_FATAL(q0->qprio == 0); 1576 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q0) == 0); 1577 1578 /* Only 0 qprio is acceptable for default round robin arbitration mechanism */ 1579 opts.qprio = 1; 1580 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1581 SPDK_CU_ASSERT_FATAL(q0 == NULL); 1582 1583 opts.qprio = 2; 1584 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1585 SPDK_CU_ASSERT_FATAL(q0 == NULL); 1586 1587 opts.qprio = 3; 1588 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1589 SPDK_CU_ASSERT_FATAL(q0 == NULL); 1590 1591 /* Only 0 ~ 3 qprio is acceptable */ 1592 opts.qprio = 4; 1593 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)) == NULL); 1594 opts.qprio = 0; 1595 1596 /* IO qpair can only be created when ctrlr is in READY state */ 1597 ctrlr.state = NVME_CTRLR_STATE_ENABLE; 1598 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1599 SPDK_CU_ASSERT_FATAL(q0 == NULL); 1600 ctrlr.state = NVME_CTRLR_STATE_READY; 1601 1602 cleanup_qpairs(&ctrlr); 1603 } 1604 1605 static void 1606 test_alloc_io_qpair_wrr_1(void) 1607 { 1608 struct spdk_nvme_io_qpair_opts opts; 1609 struct spdk_nvme_ctrlr ctrlr = {}; 1610 struct spdk_nvme_qpair *q0, *q1; 1611 1612 setup_qpairs(&ctrlr, 2); 1613 1614 /* 1615 * Fake to simulate the controller with weighted round robin 1616 * arbitration mechanism. 1617 */ 1618 ctrlr.process_init_cc.bits.ams = SPDK_NVME_CC_AMS_WRR; 1619 1620 spdk_nvme_ctrlr_get_default_io_qpair_opts(&ctrlr, &opts, sizeof(opts)); 1621 1622 /* 1623 * Allocate 2 qpairs and free them 1624 */ 1625 opts.qprio = 0; 1626 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1627 SPDK_CU_ASSERT_FATAL(q0 != NULL); 1628 SPDK_CU_ASSERT_FATAL(q0->qprio == 0); 1629 1630 opts.qprio = 1; 1631 q1 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1632 SPDK_CU_ASSERT_FATAL(q1 != NULL); 1633 SPDK_CU_ASSERT_FATAL(q1->qprio == 1); 1634 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q1) == 0); 1635 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q0) == 0); 1636 1637 /* 1638 * Allocate 2 qpairs and free them in the reverse order 1639 */ 1640 opts.qprio = 2; 1641 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1642 SPDK_CU_ASSERT_FATAL(q0 != NULL); 1643 SPDK_CU_ASSERT_FATAL(q0->qprio == 2); 1644 1645 opts.qprio = 3; 1646 q1 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1647 SPDK_CU_ASSERT_FATAL(q1 != NULL); 1648 SPDK_CU_ASSERT_FATAL(q1->qprio == 3); 1649 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q0) == 0); 1650 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q1) == 0); 1651 1652 /* Only 0 ~ 3 qprio is acceptable */ 1653 opts.qprio = 4; 1654 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)) == NULL); 1655 1656 cleanup_qpairs(&ctrlr); 1657 } 1658 1659 static void 1660 test_alloc_io_qpair_wrr_2(void) 1661 { 1662 struct spdk_nvme_io_qpair_opts opts; 1663 struct spdk_nvme_ctrlr ctrlr = {}; 1664 struct spdk_nvme_qpair *q0, *q1, *q2, *q3; 1665 1666 setup_qpairs(&ctrlr, 4); 1667 1668 /* 1669 * Fake to simulate the controller with weighted round robin 1670 * arbitration mechanism. 1671 */ 1672 ctrlr.process_init_cc.bits.ams = SPDK_NVME_CC_AMS_WRR; 1673 1674 spdk_nvme_ctrlr_get_default_io_qpair_opts(&ctrlr, &opts, sizeof(opts)); 1675 1676 opts.qprio = 0; 1677 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1678 SPDK_CU_ASSERT_FATAL(q0 != NULL); 1679 SPDK_CU_ASSERT_FATAL(q0->qprio == 0); 1680 1681 opts.qprio = 1; 1682 q1 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1683 SPDK_CU_ASSERT_FATAL(q1 != NULL); 1684 SPDK_CU_ASSERT_FATAL(q1->qprio == 1); 1685 1686 opts.qprio = 2; 1687 q2 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1688 SPDK_CU_ASSERT_FATAL(q2 != NULL); 1689 SPDK_CU_ASSERT_FATAL(q2->qprio == 2); 1690 1691 opts.qprio = 3; 1692 q3 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1693 SPDK_CU_ASSERT_FATAL(q3 != NULL); 1694 SPDK_CU_ASSERT_FATAL(q3->qprio == 3); 1695 1696 /* Only 4 I/O qpairs was allocated, so this should fail */ 1697 opts.qprio = 0; 1698 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)) == NULL); 1699 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q3) == 0); 1700 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q2) == 0); 1701 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q1) == 0); 1702 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q0) == 0); 1703 1704 /* 1705 * Now that the qpair has been returned to the free list, 1706 * we should be able to allocate it again. 1707 * 1708 * Allocate 4 I/O qpairs and half of them with same qprio. 1709 */ 1710 opts.qprio = 1; 1711 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1712 SPDK_CU_ASSERT_FATAL(q0 != NULL); 1713 SPDK_CU_ASSERT_FATAL(q0->qprio == 1); 1714 1715 opts.qprio = 1; 1716 q1 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1717 SPDK_CU_ASSERT_FATAL(q1 != NULL); 1718 SPDK_CU_ASSERT_FATAL(q1->qprio == 1); 1719 1720 opts.qprio = 3; 1721 q2 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1722 SPDK_CU_ASSERT_FATAL(q2 != NULL); 1723 SPDK_CU_ASSERT_FATAL(q2->qprio == 3); 1724 1725 opts.qprio = 3; 1726 q3 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, &opts, sizeof(opts)); 1727 SPDK_CU_ASSERT_FATAL(q3 != NULL); 1728 SPDK_CU_ASSERT_FATAL(q3->qprio == 3); 1729 1730 /* 1731 * Free all I/O qpairs in reverse order 1732 */ 1733 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q0) == 0); 1734 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q1) == 0); 1735 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q2) == 0); 1736 SPDK_CU_ASSERT_FATAL(spdk_nvme_ctrlr_free_io_qpair(q3) == 0); 1737 1738 cleanup_qpairs(&ctrlr); 1739 } 1740 1741 bool g_connect_qpair_called = false; 1742 int g_connect_qpair_return_code = 0; 1743 int 1744 nvme_transport_ctrlr_connect_qpair(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair) 1745 { 1746 g_connect_qpair_called = true; 1747 qpair->state = NVME_QPAIR_CONNECTED; 1748 return g_connect_qpair_return_code; 1749 } 1750 1751 static void 1752 test_spdk_nvme_ctrlr_reconnect_io_qpair(void) 1753 { 1754 struct spdk_nvme_ctrlr ctrlr = {}; 1755 struct spdk_nvme_qpair qpair = {}; 1756 int rc; 1757 1758 CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0); 1759 1760 /* Various states of controller disconnect. */ 1761 qpair.id = 1; 1762 qpair.ctrlr = &ctrlr; 1763 ctrlr.is_removed = 1; 1764 ctrlr.is_failed = 0; 1765 ctrlr.is_resetting = 0; 1766 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1767 CU_ASSERT(rc == -ENODEV) 1768 1769 ctrlr.is_removed = 0; 1770 ctrlr.is_failed = 1; 1771 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1772 CU_ASSERT(rc == -ENXIO) 1773 1774 ctrlr.is_failed = 0; 1775 ctrlr.is_resetting = 1; 1776 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1777 CU_ASSERT(rc == -EAGAIN) 1778 1779 /* Confirm precedence for controller states: removed > resetting > failed */ 1780 ctrlr.is_removed = 1; 1781 ctrlr.is_failed = 1; 1782 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1783 CU_ASSERT(rc == -ENODEV) 1784 1785 ctrlr.is_removed = 0; 1786 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1787 CU_ASSERT(rc == -EAGAIN) 1788 1789 ctrlr.is_resetting = 0; 1790 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1791 CU_ASSERT(rc == -ENXIO) 1792 1793 /* qpair not failed. Make sure we don't call down to the transport */ 1794 ctrlr.is_failed = 0; 1795 qpair.state = NVME_QPAIR_CONNECTED; 1796 g_connect_qpair_called = false; 1797 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1798 CU_ASSERT(g_connect_qpair_called == false); 1799 CU_ASSERT(rc == 0) 1800 1801 /* transport qpair is failed. make sure we call down to the transport */ 1802 qpair.state = NVME_QPAIR_DISCONNECTED; 1803 rc = spdk_nvme_ctrlr_reconnect_io_qpair(&qpair); 1804 CU_ASSERT(g_connect_qpair_called == true); 1805 CU_ASSERT(rc == 0) 1806 1807 CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0); 1808 } 1809 1810 static void 1811 test_nvme_ctrlr_fail(void) 1812 { 1813 struct spdk_nvme_ctrlr ctrlr = {}; 1814 1815 ctrlr.opts.num_io_queues = 0; 1816 nvme_ctrlr_fail(&ctrlr, false); 1817 1818 CU_ASSERT(ctrlr.is_failed == true); 1819 } 1820 1821 static void 1822 test_nvme_ctrlr_construct_intel_support_log_page_list(void) 1823 { 1824 bool res; 1825 struct spdk_nvme_ctrlr ctrlr = {}; 1826 struct spdk_nvme_intel_log_page_directory payload = {}; 1827 struct spdk_pci_id pci_id = {}; 1828 1829 /* Get quirks for a device with all 0 vendor/device id */ 1830 ctrlr.quirks = nvme_get_quirks(&pci_id); 1831 CU_ASSERT(ctrlr.quirks == 0); 1832 1833 nvme_ctrlr_construct_intel_support_log_page_list(&ctrlr, &payload); 1834 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_TEMPERATURE); 1835 CU_ASSERT(res == false); 1836 1837 /* Set the vendor to Intel, but provide no device id */ 1838 pci_id.class_id = SPDK_PCI_CLASS_NVME; 1839 ctrlr.cdata.vid = pci_id.vendor_id = SPDK_PCI_VID_INTEL; 1840 payload.temperature_statistics_log_len = 1; 1841 ctrlr.quirks = nvme_get_quirks(&pci_id); 1842 memset(ctrlr.log_page_supported, 0, sizeof(ctrlr.log_page_supported)); 1843 1844 nvme_ctrlr_construct_intel_support_log_page_list(&ctrlr, &payload); 1845 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_PAGE_DIRECTORY); 1846 CU_ASSERT(res == true); 1847 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_TEMPERATURE); 1848 CU_ASSERT(res == true); 1849 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_READ_CMD_LATENCY); 1850 CU_ASSERT(res == false); 1851 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_SMART); 1852 CU_ASSERT(res == false); 1853 1854 /* set valid vendor id, device id and sub device id */ 1855 ctrlr.cdata.vid = SPDK_PCI_VID_INTEL; 1856 payload.temperature_statistics_log_len = 0; 1857 pci_id.vendor_id = SPDK_PCI_VID_INTEL; 1858 pci_id.device_id = 0x0953; 1859 pci_id.subvendor_id = SPDK_PCI_VID_INTEL; 1860 pci_id.subdevice_id = 0x3702; 1861 ctrlr.quirks = nvme_get_quirks(&pci_id); 1862 memset(ctrlr.log_page_supported, 0, sizeof(ctrlr.log_page_supported)); 1863 1864 nvme_ctrlr_construct_intel_support_log_page_list(&ctrlr, &payload); 1865 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_PAGE_DIRECTORY); 1866 CU_ASSERT(res == true); 1867 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_TEMPERATURE); 1868 CU_ASSERT(res == false); 1869 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_READ_CMD_LATENCY); 1870 CU_ASSERT(res == true); 1871 res = spdk_nvme_ctrlr_is_log_page_supported(&ctrlr, SPDK_NVME_INTEL_LOG_SMART); 1872 CU_ASSERT(res == false); 1873 } 1874 1875 static void 1876 test_nvme_ctrlr_set_supported_features(void) 1877 { 1878 bool res; 1879 struct spdk_nvme_ctrlr ctrlr = {}; 1880 1881 /* set a invalid vendor id */ 1882 ctrlr.cdata.vid = 0xFFFF; 1883 nvme_ctrlr_set_supported_features(&ctrlr); 1884 res = spdk_nvme_ctrlr_is_feature_supported(&ctrlr, SPDK_NVME_FEAT_ARBITRATION); 1885 CU_ASSERT(res == true); 1886 res = spdk_nvme_ctrlr_is_feature_supported(&ctrlr, SPDK_NVME_INTEL_FEAT_MAX_LBA); 1887 CU_ASSERT(res == false); 1888 1889 ctrlr.cdata.vid = SPDK_PCI_VID_INTEL; 1890 nvme_ctrlr_set_supported_features(&ctrlr); 1891 res = spdk_nvme_ctrlr_is_feature_supported(&ctrlr, SPDK_NVME_FEAT_ARBITRATION); 1892 CU_ASSERT(res == true); 1893 res = spdk_nvme_ctrlr_is_feature_supported(&ctrlr, SPDK_NVME_INTEL_FEAT_MAX_LBA); 1894 CU_ASSERT(res == true); 1895 } 1896 1897 static void 1898 test_ctrlr_get_default_ctrlr_opts(void) 1899 { 1900 struct spdk_nvme_ctrlr_opts opts = {}; 1901 1902 CU_ASSERT(spdk_uuid_parse(&g_spdk_nvme_driver->default_extended_host_id, 1903 "e53e9258-c93b-48b5-be1a-f025af6d232a") == 0); 1904 1905 memset(&opts, 0, sizeof(opts)); 1906 1907 /* set a smaller opts_size */ 1908 CU_ASSERT(sizeof(opts) > 8); 1909 spdk_nvme_ctrlr_get_default_ctrlr_opts(&opts, 8); 1910 CU_ASSERT_EQUAL(opts.num_io_queues, DEFAULT_MAX_IO_QUEUES); 1911 CU_ASSERT_FALSE(opts.use_cmb_sqs); 1912 /* check below fields are not initialized by default value */ 1913 CU_ASSERT_EQUAL(opts.arb_mechanism, 0); 1914 CU_ASSERT_EQUAL(opts.keep_alive_timeout_ms, 0); 1915 CU_ASSERT_EQUAL(opts.io_queue_size, 0); 1916 CU_ASSERT_EQUAL(opts.io_queue_requests, 0); 1917 for (int i = 0; i < 8; i++) { 1918 CU_ASSERT(opts.host_id[i] == 0); 1919 } 1920 for (int i = 0; i < 16; i++) { 1921 CU_ASSERT(opts.extended_host_id[i] == 0); 1922 } 1923 CU_ASSERT(strlen(opts.hostnqn) == 0); 1924 CU_ASSERT(strlen(opts.src_addr) == 0); 1925 CU_ASSERT(strlen(opts.src_svcid) == 0); 1926 CU_ASSERT_EQUAL(opts.admin_timeout_ms, 0); 1927 1928 /* set a consistent opts_size */ 1929 spdk_nvme_ctrlr_get_default_ctrlr_opts(&opts, sizeof(opts)); 1930 CU_ASSERT_EQUAL(opts.num_io_queues, DEFAULT_MAX_IO_QUEUES); 1931 CU_ASSERT_FALSE(opts.use_cmb_sqs); 1932 CU_ASSERT_EQUAL(opts.arb_mechanism, SPDK_NVME_CC_AMS_RR); 1933 CU_ASSERT_EQUAL(opts.keep_alive_timeout_ms, 10 * 1000); 1934 CU_ASSERT_EQUAL(opts.io_queue_size, DEFAULT_IO_QUEUE_SIZE); 1935 CU_ASSERT_EQUAL(opts.io_queue_requests, DEFAULT_IO_QUEUE_REQUESTS); 1936 for (int i = 0; i < 8; i++) { 1937 CU_ASSERT(opts.host_id[i] == 0); 1938 } 1939 CU_ASSERT_STRING_EQUAL(opts.hostnqn, 1940 "nqn.2014-08.org.nvmexpress:uuid:e53e9258-c93b-48b5-be1a-f025af6d232a"); 1941 CU_ASSERT(memcmp(opts.extended_host_id, &g_spdk_nvme_driver->default_extended_host_id, 1942 sizeof(opts.extended_host_id)) == 0); 1943 CU_ASSERT(strlen(opts.src_addr) == 0); 1944 CU_ASSERT(strlen(opts.src_svcid) == 0); 1945 CU_ASSERT_EQUAL(opts.admin_timeout_ms, NVME_MAX_ADMIN_TIMEOUT_IN_SECS * 1000); 1946 } 1947 1948 static void 1949 test_ctrlr_get_default_io_qpair_opts(void) 1950 { 1951 struct spdk_nvme_ctrlr ctrlr = {}; 1952 struct spdk_nvme_io_qpair_opts opts = {}; 1953 1954 memset(&opts, 0, sizeof(opts)); 1955 1956 /* set a smaller opts_size */ 1957 ctrlr.opts.io_queue_size = DEFAULT_IO_QUEUE_SIZE; 1958 CU_ASSERT(sizeof(opts) > 8); 1959 spdk_nvme_ctrlr_get_default_io_qpair_opts(&ctrlr, &opts, 8); 1960 CU_ASSERT_EQUAL(opts.qprio, SPDK_NVME_QPRIO_URGENT); 1961 CU_ASSERT_EQUAL(opts.io_queue_size, DEFAULT_IO_QUEUE_SIZE); 1962 /* check below field is not initialized by default value */ 1963 CU_ASSERT_EQUAL(opts.io_queue_requests, 0); 1964 1965 /* set a consistent opts_size */ 1966 ctrlr.opts.io_queue_size = DEFAULT_IO_QUEUE_SIZE; 1967 ctrlr.opts.io_queue_requests = DEFAULT_IO_QUEUE_REQUESTS; 1968 spdk_nvme_ctrlr_get_default_io_qpair_opts(&ctrlr, &opts, sizeof(opts)); 1969 CU_ASSERT_EQUAL(opts.qprio, SPDK_NVME_QPRIO_URGENT); 1970 CU_ASSERT_EQUAL(opts.io_queue_size, DEFAULT_IO_QUEUE_SIZE); 1971 CU_ASSERT_EQUAL(opts.io_queue_requests, DEFAULT_IO_QUEUE_REQUESTS); 1972 } 1973 1974 #if 0 /* TODO: move to PCIe-specific unit test */ 1975 static void 1976 test_nvme_ctrlr_alloc_cmb(void) 1977 { 1978 int rc; 1979 uint64_t offset; 1980 struct spdk_nvme_ctrlr ctrlr = {}; 1981 1982 ctrlr.cmb_size = 0x1000000; 1983 ctrlr.cmb_current_offset = 0x100; 1984 rc = nvme_ctrlr_alloc_cmb(&ctrlr, 0x200, 0x1000, &offset); 1985 CU_ASSERT(rc == 0); 1986 CU_ASSERT(offset == 0x1000); 1987 CU_ASSERT(ctrlr.cmb_current_offset == 0x1200); 1988 1989 rc = nvme_ctrlr_alloc_cmb(&ctrlr, 0x800, 0x1000, &offset); 1990 CU_ASSERT(rc == 0); 1991 CU_ASSERT(offset == 0x2000); 1992 CU_ASSERT(ctrlr.cmb_current_offset == 0x2800); 1993 1994 rc = nvme_ctrlr_alloc_cmb(&ctrlr, 0x800000, 0x100000, &offset); 1995 CU_ASSERT(rc == 0); 1996 CU_ASSERT(offset == 0x100000); 1997 CU_ASSERT(ctrlr.cmb_current_offset == 0x900000); 1998 1999 rc = nvme_ctrlr_alloc_cmb(&ctrlr, 0x8000000, 0x1000, &offset); 2000 CU_ASSERT(rc == -1); 2001 } 2002 #endif 2003 2004 static void 2005 test_spdk_nvme_ctrlr_update_firmware(void) 2006 { 2007 struct spdk_nvme_ctrlr ctrlr = {}; 2008 void *payload = NULL; 2009 int point_payload = 1; 2010 int slot = 0; 2011 int ret = 0; 2012 struct spdk_nvme_status status; 2013 enum spdk_nvme_fw_commit_action commit_action = SPDK_NVME_FW_COMMIT_REPLACE_IMG; 2014 2015 CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0); 2016 2017 /* Set invalid size check function return value */ 2018 set_size = 5; 2019 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2020 CU_ASSERT(ret == -1); 2021 2022 /* When payload is NULL but set_size < min_page_size */ 2023 set_size = 4; 2024 ctrlr.min_page_size = 5; 2025 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2026 CU_ASSERT(ret == -1); 2027 2028 /* When payload not NULL but min_page_size is 0 */ 2029 set_size = 4; 2030 ctrlr.min_page_size = 0; 2031 payload = &point_payload; 2032 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2033 CU_ASSERT(ret == -1); 2034 2035 /* Check firmware image download when payload not NULL and min_page_size not 0 , status.cpl value is 1 */ 2036 set_status_cpl = 1; 2037 set_size = 4; 2038 ctrlr.min_page_size = 5; 2039 payload = &point_payload; 2040 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2041 CU_ASSERT(ret == -ENXIO); 2042 2043 /* Check firmware image download and set status.cpl value is 0 */ 2044 set_status_cpl = 0; 2045 set_size = 4; 2046 ctrlr.min_page_size = 5; 2047 payload = &point_payload; 2048 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2049 CU_ASSERT(ret == -1); 2050 2051 /* Check firmware commit */ 2052 ctrlr.is_resetting = false; 2053 set_status_cpl = 0; 2054 slot = 1; 2055 set_size = 4; 2056 ctrlr.min_page_size = 5; 2057 payload = &point_payload; 2058 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2059 CU_ASSERT(ret == -ENXIO); 2060 2061 /* Set size check firmware download and firmware commit */ 2062 ctrlr.is_resetting = true; 2063 set_status_cpl = 0; 2064 slot = 1; 2065 set_size = 4; 2066 ctrlr.min_page_size = 5; 2067 payload = &point_payload; 2068 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2069 CU_ASSERT(ret == 0); 2070 2071 /* nvme_wait_for_completion returns an error */ 2072 g_wait_for_completion_return_val = -1; 2073 ret = spdk_nvme_ctrlr_update_firmware(&ctrlr, payload, set_size, slot, commit_action, &status); 2074 CU_ASSERT(ret == -ENXIO); 2075 CU_ASSERT(g_failed_status != NULL); 2076 CU_ASSERT(g_failed_status->timed_out == true); 2077 /* status should be freed by callback, which is not triggered in test env. 2078 Store status to global variable and free it manually. 2079 If spdk_nvme_ctrlr_update_firmware changes its behaviour and frees the status 2080 itself, we'll get a double free here.. */ 2081 free(g_failed_status); 2082 g_failed_status = NULL; 2083 g_wait_for_completion_return_val = 0; 2084 2085 CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0); 2086 set_status_cpl = 0; 2087 } 2088 2089 int 2090 nvme_ctrlr_cmd_doorbell_buffer_config(struct spdk_nvme_ctrlr *ctrlr, uint64_t prp1, uint64_t prp2, 2091 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 2092 { 2093 fake_cpl_sc(cb_fn, cb_arg); 2094 return 0; 2095 } 2096 2097 static void 2098 test_spdk_nvme_ctrlr_doorbell_buffer_config(void) 2099 { 2100 struct spdk_nvme_ctrlr ctrlr = {}; 2101 int ret = -1; 2102 2103 ctrlr.cdata.oacs.doorbell_buffer_config = 1; 2104 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE; 2105 ctrlr.page_size = 0x1000; 2106 MOCK_CLEAR(spdk_malloc); 2107 MOCK_CLEAR(spdk_zmalloc); 2108 ret = nvme_ctrlr_set_doorbell_buffer_config(&ctrlr); 2109 CU_ASSERT(ret == 0); 2110 nvme_ctrlr_free_doorbell_buffer(&ctrlr); 2111 } 2112 2113 static void 2114 test_nvme_ctrlr_test_active_ns(void) 2115 { 2116 uint32_t nsid, minor; 2117 size_t ns_id_count; 2118 struct spdk_nvme_ctrlr ctrlr = {}; 2119 uint32_t active_ns_list[1531]; 2120 2121 for (nsid = 1; nsid <= 1531; nsid++) { 2122 active_ns_list[nsid - 1] = nsid; 2123 } 2124 2125 g_active_ns_list = active_ns_list; 2126 2127 ctrlr.page_size = 0x1000; 2128 2129 for (minor = 0; minor <= 2; minor++) { 2130 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2131 ctrlr.state = NVME_CTRLR_STATE_READY; 2132 2133 ctrlr.vs.bits.mjr = 1; 2134 ctrlr.vs.bits.mnr = minor; 2135 ctrlr.vs.bits.ter = 0; 2136 ctrlr.cdata.nn = 1531; 2137 2138 RB_INIT(&ctrlr.ns); 2139 2140 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2141 nvme_ctrlr_identify_active_ns(&ctrlr); 2142 2143 for (nsid = 1; nsid <= ctrlr.cdata.nn; nsid++) { 2144 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, nsid) == true); 2145 } 2146 2147 for (; nsid <= 1559; nsid++) { 2148 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, nsid) == false); 2149 } 2150 2151 g_active_ns_list_length = 0; 2152 if (minor <= 1) { 2153 ctrlr.cdata.nn = 0; 2154 } 2155 nvme_ctrlr_identify_active_ns(&ctrlr); 2156 CU_ASSERT(spdk_nvme_ctrlr_get_first_active_ns(&ctrlr) == 0); 2157 2158 g_active_ns_list_length = 1; 2159 if (minor <= 1) { 2160 ctrlr.cdata.nn = 1; 2161 } 2162 nvme_ctrlr_identify_active_ns(&ctrlr); 2163 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1) == true); 2164 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 2) == false); 2165 nsid = spdk_nvme_ctrlr_get_first_active_ns(&ctrlr); 2166 CU_ASSERT(nsid == 1); 2167 2168 if (minor >= 2) { 2169 /* For NVMe 1.2 and newer, the namespace list can have "holes" where 2170 * some namespaces are not active. Test this. */ 2171 g_active_ns_list_length = 2; 2172 g_active_ns_list[1] = 3; 2173 nvme_ctrlr_identify_active_ns(&ctrlr); 2174 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1) == true); 2175 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 2) == false); 2176 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 3) == true); 2177 nsid = spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, nsid); 2178 CU_ASSERT(nsid == 3); 2179 nsid = spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, nsid); 2180 CU_ASSERT(nsid == 0); 2181 2182 /* Reset the active namespace list array */ 2183 g_active_ns_list[1] = 2; 2184 } 2185 2186 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2187 if (minor <= 1) { 2188 ctrlr.cdata.nn = 1531; 2189 } 2190 nvme_ctrlr_identify_active_ns(&ctrlr); 2191 2192 ns_id_count = 0; 2193 for (nsid = spdk_nvme_ctrlr_get_first_active_ns(&ctrlr); 2194 nsid != 0; nsid = spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, nsid)) { 2195 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, nsid) == true); 2196 ns_id_count++; 2197 } 2198 CU_ASSERT(ns_id_count == ctrlr.cdata.nn); 2199 2200 nvme_ctrlr_destruct(&ctrlr); 2201 } 2202 2203 g_active_ns_list = NULL; 2204 g_active_ns_list_length = 0; 2205 } 2206 2207 static void 2208 test_nvme_ctrlr_test_active_ns_error_case(void) 2209 { 2210 int rc; 2211 struct spdk_nvme_ctrlr ctrlr = {.state = NVME_CTRLR_STATE_READY}; 2212 2213 ctrlr.page_size = 0x1000; 2214 ctrlr.vs.bits.mjr = 1; 2215 ctrlr.vs.bits.mnr = 2; 2216 ctrlr.vs.bits.ter = 0; 2217 ctrlr.cdata.nn = 2; 2218 2219 set_status_code = SPDK_NVME_SC_INVALID_FIELD; 2220 rc = nvme_ctrlr_identify_active_ns(&ctrlr); 2221 CU_ASSERT(rc == -ENXIO); 2222 set_status_code = SPDK_NVME_SC_SUCCESS; 2223 } 2224 2225 static void 2226 test_nvme_ctrlr_init_delay(void) 2227 { 2228 DECLARE_AND_CONSTRUCT_CTRLR(); 2229 2230 memset(&g_ut_nvme_regs, 0, sizeof(g_ut_nvme_regs)); 2231 2232 /* 2233 * Initial state: CC.EN = 0, CSTS.RDY = 0 2234 * init() should set CC.EN = 1. 2235 */ 2236 g_ut_nvme_regs.cc.bits.en = 0; 2237 g_ut_nvme_regs.csts.bits.rdy = 0; 2238 2239 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2240 /* Test that the initialization delay works correctly. We only 2241 * do the initialization delay on SSDs that require it, so 2242 * set that quirk here. 2243 */ 2244 ctrlr.quirks = NVME_QUIRK_DELAY_BEFORE_INIT; 2245 ctrlr.cdata.nn = 1; 2246 ctrlr.page_size = 0x1000; 2247 ctrlr.state = NVME_CTRLR_STATE_INIT_DELAY; 2248 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2249 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 2250 CU_ASSERT(ctrlr.sleep_timeout_tsc != 0); 2251 2252 /* delay 1s, just return as sleep time isn't enough */ 2253 spdk_delay_us(1 * spdk_get_ticks_hz()); 2254 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2255 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_INIT); 2256 CU_ASSERT(ctrlr.sleep_timeout_tsc != 0); 2257 2258 /* sleep timeout, start to initialize */ 2259 spdk_delay_us(2 * spdk_get_ticks_hz()); 2260 while (ctrlr.state != NVME_CTRLR_STATE_CHECK_EN) { 2261 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2262 } 2263 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2264 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0); 2265 2266 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2267 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_DISABLED); 2268 2269 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2270 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE); 2271 2272 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2273 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1); 2274 CU_ASSERT(g_ut_nvme_regs.cc.bits.en == 1); 2275 2276 /* 2277 * Transition to CSTS.RDY = 1. 2278 */ 2279 g_ut_nvme_regs.csts.bits.rdy = 1; 2280 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2281 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_RESET_ADMIN_QUEUE); 2282 2283 /* 2284 * Transition to READY. 2285 */ 2286 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 2287 nvme_ctrlr_process_init(&ctrlr); 2288 } 2289 2290 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 2291 nvme_ctrlr_destruct(&ctrlr); 2292 } 2293 2294 static void 2295 test_spdk_nvme_ctrlr_set_trid(void) 2296 { 2297 struct spdk_nvme_ctrlr ctrlr = {{0}}; 2298 struct spdk_nvme_transport_id new_trid = {{0}}; 2299 2300 CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0); 2301 2302 ctrlr.is_failed = false; 2303 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_RDMA; 2304 snprintf(ctrlr.trid.subnqn, SPDK_NVMF_NQN_MAX_LEN, "%s", "nqn.2016-06.io.spdk:cnode1"); 2305 snprintf(ctrlr.trid.traddr, SPDK_NVMF_TRADDR_MAX_LEN, "%s", "192.168.100.8"); 2306 snprintf(ctrlr.trid.trsvcid, SPDK_NVMF_TRSVCID_MAX_LEN, "%s", "4420"); 2307 CU_ASSERT(spdk_nvme_ctrlr_set_trid(&ctrlr, &new_trid) == -EPERM); 2308 2309 ctrlr.is_failed = true; 2310 new_trid.trtype = SPDK_NVME_TRANSPORT_TCP; 2311 CU_ASSERT(spdk_nvme_ctrlr_set_trid(&ctrlr, &new_trid) == -EINVAL); 2312 CU_ASSERT(ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_RDMA); 2313 2314 new_trid.trtype = SPDK_NVME_TRANSPORT_RDMA; 2315 snprintf(new_trid.subnqn, SPDK_NVMF_NQN_MAX_LEN, "%s", "nqn.2016-06.io.spdk:cnode2"); 2316 CU_ASSERT(spdk_nvme_ctrlr_set_trid(&ctrlr, &new_trid) == -EINVAL); 2317 CU_ASSERT(strncmp(ctrlr.trid.subnqn, "nqn.2016-06.io.spdk:cnode1", SPDK_NVMF_NQN_MAX_LEN) == 0); 2318 2319 2320 snprintf(new_trid.subnqn, SPDK_NVMF_NQN_MAX_LEN, "%s", "nqn.2016-06.io.spdk:cnode1"); 2321 snprintf(new_trid.traddr, SPDK_NVMF_TRADDR_MAX_LEN, "%s", "192.168.100.9"); 2322 snprintf(new_trid.trsvcid, SPDK_NVMF_TRSVCID_MAX_LEN, "%s", "4421"); 2323 CU_ASSERT(spdk_nvme_ctrlr_set_trid(&ctrlr, &new_trid) == 0); 2324 CU_ASSERT(strncmp(ctrlr.trid.traddr, "192.168.100.9", SPDK_NVMF_TRADDR_MAX_LEN) == 0); 2325 CU_ASSERT(strncmp(ctrlr.trid.trsvcid, "4421", SPDK_NVMF_TRSVCID_MAX_LEN) == 0); 2326 2327 CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0); 2328 } 2329 2330 static void 2331 test_nvme_ctrlr_init_set_nvmf_ioccsz(void) 2332 { 2333 struct spdk_nvme_ctrlr_data cdata = {}; 2334 DECLARE_AND_CONSTRUCT_CTRLR(); 2335 /* equivalent of 4096 bytes */ 2336 cdata.nvmf_specific.ioccsz = 260; 2337 cdata.nvmf_specific.icdoff = 1; 2338 g_cdata = &cdata; 2339 2340 /* Check PCI trtype, */ 2341 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2342 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE; 2343 2344 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY; 2345 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2346 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_CONFIGURE_AER); 2347 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2348 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2349 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2350 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2351 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2352 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_NUM_QUEUES); 2353 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2354 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS); 2355 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2356 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2357 2358 CU_ASSERT(ctrlr.ioccsz_bytes == 0); 2359 CU_ASSERT(ctrlr.icdoff == 0); 2360 2361 nvme_ctrlr_destruct(&ctrlr); 2362 2363 /* Check RDMA trtype, */ 2364 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2365 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_RDMA; 2366 2367 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY; 2368 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2369 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_CONFIGURE_AER); 2370 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2371 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2372 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2373 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2374 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2375 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_NUM_QUEUES); 2376 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2377 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS); 2378 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2379 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2380 2381 CU_ASSERT(ctrlr.ioccsz_bytes == 4096); 2382 CU_ASSERT(ctrlr.icdoff == 1); 2383 ctrlr.ioccsz_bytes = 0; 2384 ctrlr.icdoff = 0; 2385 2386 nvme_ctrlr_destruct(&ctrlr); 2387 2388 /* Check TCP trtype, */ 2389 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2390 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_TCP; 2391 2392 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY; 2393 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2394 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_CONFIGURE_AER); 2395 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2396 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2397 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2398 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2399 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2400 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_NUM_QUEUES); 2401 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2402 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS); 2403 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2404 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2405 2406 CU_ASSERT(ctrlr.ioccsz_bytes == 4096); 2407 CU_ASSERT(ctrlr.icdoff == 1); 2408 ctrlr.ioccsz_bytes = 0; 2409 ctrlr.icdoff = 0; 2410 2411 nvme_ctrlr_destruct(&ctrlr); 2412 2413 /* Check FC trtype, */ 2414 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2415 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_FC; 2416 2417 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY; 2418 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2419 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_CONFIGURE_AER); 2420 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2421 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2422 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2423 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2424 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2425 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_NUM_QUEUES); 2426 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2427 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS); 2428 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2429 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2430 2431 CU_ASSERT(ctrlr.ioccsz_bytes == 4096); 2432 CU_ASSERT(ctrlr.icdoff == 1); 2433 ctrlr.ioccsz_bytes = 0; 2434 ctrlr.icdoff = 0; 2435 2436 nvme_ctrlr_destruct(&ctrlr); 2437 2438 /* Check CUSTOM trtype, */ 2439 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2440 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_CUSTOM; 2441 2442 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY; 2443 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2444 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_CONFIGURE_AER); 2445 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2446 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2447 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2448 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2449 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2450 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_NUM_QUEUES); 2451 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2452 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS); 2453 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2454 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2455 2456 CU_ASSERT(ctrlr.ioccsz_bytes == 0); 2457 CU_ASSERT(ctrlr.icdoff == 0); 2458 2459 nvme_ctrlr_destruct(&ctrlr); 2460 2461 g_cdata = NULL; 2462 } 2463 2464 static void 2465 test_nvme_ctrlr_init_set_num_queues(void) 2466 { 2467 DECLARE_AND_CONSTRUCT_CTRLR(); 2468 2469 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2470 2471 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY; 2472 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2473 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_CONFIGURE_AER); 2474 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2475 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2476 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2477 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2478 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 2479 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_NUM_QUEUES); 2480 2481 ctrlr.opts.num_io_queues = 64; 2482 /* Num queues is zero-based. So, use 31 to get 32 queues */ 2483 fake_cpl.cdw0 = 31 + (31 << 16); 2484 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); /* -> IDENTIFY_ACTIVE_NS */ 2485 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS); 2486 CU_ASSERT(ctrlr.opts.num_io_queues == 32); 2487 fake_cpl.cdw0 = 0; 2488 2489 nvme_ctrlr_destruct(&ctrlr); 2490 } 2491 2492 static void 2493 test_nvme_ctrlr_init_set_keep_alive_timeout(void) 2494 { 2495 DECLARE_AND_CONSTRUCT_CTRLR(); 2496 2497 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2498 2499 ctrlr.opts.keep_alive_timeout_ms = 60000; 2500 ctrlr.cdata.kas = 1; 2501 ctrlr.state = NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT; 2502 fake_cpl.cdw0 = 120000; 2503 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); /* -> IDENTIFY_IOCS_SPECIFIC */ 2504 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2505 CU_ASSERT(ctrlr.opts.keep_alive_timeout_ms == 120000); 2506 fake_cpl.cdw0 = 0; 2507 2508 /* Target does not support Get Feature "Keep Alive Timer" */ 2509 ctrlr.opts.keep_alive_timeout_ms = 60000; 2510 ctrlr.cdata.kas = 1; 2511 ctrlr.state = NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT; 2512 set_status_code = SPDK_NVME_SC_INVALID_FIELD; 2513 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); /* -> IDENTIFY_IOCS_SPECIFIC */ 2514 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_IOCS_SPECIFIC); 2515 CU_ASSERT(ctrlr.opts.keep_alive_timeout_ms == 60000); 2516 set_status_code = SPDK_NVME_SC_SUCCESS; 2517 2518 /* Target fails Get Feature "Keep Alive Timer" for another reason */ 2519 ctrlr.opts.keep_alive_timeout_ms = 60000; 2520 ctrlr.cdata.kas = 1; 2521 ctrlr.state = NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT; 2522 set_status_code = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 2523 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); /* -> ERROR */ 2524 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ERROR); 2525 set_status_code = SPDK_NVME_SC_SUCCESS; 2526 2527 nvme_ctrlr_destruct(&ctrlr); 2528 } 2529 2530 static void 2531 test_alloc_io_qpair_fail(void) 2532 { 2533 struct spdk_nvme_ctrlr ctrlr = {}; 2534 struct spdk_nvme_qpair *q0; 2535 2536 setup_qpairs(&ctrlr, 1); 2537 2538 /* Modify the connect_qpair return code to inject a failure */ 2539 g_connect_qpair_return_code = 1; 2540 2541 /* Attempt to allocate a qpair, this should fail */ 2542 q0 = spdk_nvme_ctrlr_alloc_io_qpair(&ctrlr, NULL, 0); 2543 SPDK_CU_ASSERT_FATAL(q0 == NULL); 2544 2545 /* Verify that the qpair is removed from the lists */ 2546 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&ctrlr.active_io_qpairs)); 2547 2548 g_connect_qpair_return_code = 0; 2549 cleanup_qpairs(&ctrlr); 2550 } 2551 2552 static void 2553 test_nvme_ctrlr_add_remove_process(void) 2554 { 2555 struct spdk_nvme_ctrlr ctrlr = {}; 2556 void *devhandle = (void *)0xDEADBEEF; 2557 struct spdk_nvme_ctrlr_process *proc = NULL; 2558 int rc; 2559 2560 ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE; 2561 TAILQ_INIT(&ctrlr.active_procs); 2562 2563 rc = nvme_ctrlr_add_process(&ctrlr, devhandle); 2564 CU_ASSERT(rc == 0); 2565 proc = TAILQ_FIRST(&ctrlr.active_procs); 2566 SPDK_CU_ASSERT_FATAL(proc != NULL); 2567 CU_ASSERT(proc->is_primary == true); 2568 CU_ASSERT(proc->pid == getpid()); 2569 CU_ASSERT(proc->devhandle == (void *)0xDEADBEEF); 2570 CU_ASSERT(proc->ref == 0); 2571 2572 nvme_ctrlr_remove_process(&ctrlr, proc); 2573 CU_ASSERT(TAILQ_EMPTY(&ctrlr.active_procs)); 2574 } 2575 2576 static void 2577 test_nvme_ctrlr_set_arbitration_feature(void) 2578 { 2579 struct spdk_nvme_ctrlr ctrlr = {}; 2580 2581 ctrlr.opts.arbitration_burst = 6; 2582 ctrlr.flags |= SPDK_NVME_CTRLR_WRR_SUPPORTED; 2583 ctrlr.opts.low_priority_weight = 1; 2584 ctrlr.opts.medium_priority_weight = 2; 2585 ctrlr.opts.high_priority_weight = 3; 2586 /* g_ut_cdw11 used to record value command feature set. */ 2587 g_ut_cdw11 = 0; 2588 2589 /* arbitration_burst count available. */ 2590 nvme_ctrlr_set_arbitration_feature(&ctrlr); 2591 CU_ASSERT((uint8_t)g_ut_cdw11 == 6); 2592 CU_ASSERT((uint8_t)(g_ut_cdw11 >> 8) == 1); 2593 CU_ASSERT((uint8_t)(g_ut_cdw11 >> 16) == 2); 2594 CU_ASSERT((uint8_t)(g_ut_cdw11 >> 24) == 3); 2595 2596 /* arbitration_burst unavailable. */ 2597 g_ut_cdw11 = 0; 2598 ctrlr.opts.arbitration_burst = 8; 2599 2600 nvme_ctrlr_set_arbitration_feature(&ctrlr); 2601 CU_ASSERT(g_ut_cdw11 == 0); 2602 } 2603 2604 static void 2605 test_nvme_ctrlr_set_state(void) 2606 { 2607 struct spdk_nvme_ctrlr ctrlr = {}; 2608 MOCK_SET(spdk_get_ticks, 0); 2609 2610 nvme_ctrlr_set_state(&ctrlr, NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT, 1000); 2611 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2612 CU_ASSERT(ctrlr.state_timeout_tsc == 1000000); 2613 2614 nvme_ctrlr_set_state(&ctrlr, NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT, 0); 2615 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2616 CU_ASSERT(ctrlr.state_timeout_tsc == NVME_TIMEOUT_INFINITE); 2617 2618 /* Time out ticks causes integer overflow. */ 2619 MOCK_SET(spdk_get_ticks, UINT64_MAX); 2620 2621 nvme_ctrlr_set_state(&ctrlr, NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT, 1000); 2622 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_KEEP_ALIVE_TIMEOUT); 2623 CU_ASSERT(ctrlr.state_timeout_tsc == NVME_TIMEOUT_INFINITE); 2624 MOCK_CLEAR(spdk_get_ticks); 2625 } 2626 2627 static void 2628 test_nvme_ctrlr_active_ns_list_v0(void) 2629 { 2630 DECLARE_AND_CONSTRUCT_CTRLR(); 2631 2632 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2633 2634 ctrlr.vs.bits.mjr = 1; 2635 ctrlr.vs.bits.mnr = 0; 2636 ctrlr.vs.bits.ter = 0; 2637 ctrlr.cdata.nn = 1024; 2638 2639 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS; 2640 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2641 SPDK_CU_ASSERT_FATAL(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2642 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1)); 2643 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1024)); 2644 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1025)); 2645 CU_ASSERT(spdk_nvme_ctrlr_get_first_active_ns(&ctrlr) == 1); 2646 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1023) == 1024); 2647 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1024) == 0); 2648 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1025) == 0); 2649 2650 nvme_ctrlr_destruct(&ctrlr); 2651 } 2652 2653 static void 2654 test_nvme_ctrlr_active_ns_list_v2(void) 2655 { 2656 uint32_t i; 2657 uint32_t active_ns_list[1024]; 2658 DECLARE_AND_CONSTRUCT_CTRLR(); 2659 2660 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2661 2662 ctrlr.vs.bits.mjr = 1; 2663 ctrlr.vs.bits.mnr = 2; 2664 ctrlr.vs.bits.ter = 0; 2665 ctrlr.cdata.nn = 4096; 2666 2667 g_active_ns_list = active_ns_list; 2668 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2669 2670 /* No active namespaces */ 2671 memset(active_ns_list, 0, sizeof(active_ns_list)); 2672 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS; 2673 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2674 SPDK_CU_ASSERT_FATAL(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2675 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1)); 2676 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1024)); 2677 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1025)); 2678 CU_ASSERT(spdk_nvme_ctrlr_get_first_active_ns(&ctrlr) == 0); 2679 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1024) == 0); 2680 2681 nvme_ctrlr_destruct(&ctrlr); 2682 2683 /* 1024 active namespaces - one full page */ 2684 memset(active_ns_list, 0, sizeof(active_ns_list)); 2685 for (i = 0; i < 1024; ++i) { 2686 active_ns_list[i] = i + 1; 2687 } 2688 2689 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2690 2691 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS; 2692 g_active_ns_list = active_ns_list; 2693 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2694 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2695 SPDK_CU_ASSERT_FATAL(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2696 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1)); 2697 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1024)); 2698 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1025)); 2699 CU_ASSERT(spdk_nvme_ctrlr_get_first_active_ns(&ctrlr) == 1); 2700 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1023) == 1024); 2701 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1024) == 0); 2702 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1025) == 0); 2703 2704 nvme_ctrlr_destruct(&ctrlr); 2705 2706 /* 1023 active namespaces - full page minus one */ 2707 memset(active_ns_list, 0, sizeof(active_ns_list)); 2708 for (i = 0; i < 1023; ++i) { 2709 active_ns_list[i] = i + 1; 2710 } 2711 2712 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2713 2714 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS; 2715 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2716 SPDK_CU_ASSERT_FATAL(ctrlr.state == NVME_CTRLR_STATE_IDENTIFY_NS); 2717 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1)); 2718 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1023)); 2719 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1024)); 2720 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 1025)); 2721 CU_ASSERT(spdk_nvme_ctrlr_get_first_active_ns(&ctrlr) == 1); 2722 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1023) == 0); 2723 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1024) == 0); 2724 CU_ASSERT(spdk_nvme_ctrlr_get_next_active_ns(&ctrlr, 1025) == 0); 2725 2726 nvme_ctrlr_destruct(&ctrlr); 2727 2728 g_active_ns_list = NULL; 2729 g_active_ns_list_length = 0; 2730 } 2731 2732 static void 2733 test_nvme_ctrlr_ns_mgmt(void) 2734 { 2735 DECLARE_AND_CONSTRUCT_CTRLR(); 2736 uint32_t active_ns_list[] = { 1, 2, 100, 1024 }; 2737 uint32_t active_ns_list2[] = { 1, 2, 3, 100, 1024 }; 2738 struct spdk_nvme_ns_data nsdata = {}; 2739 struct spdk_nvme_ctrlr_list ctrlr_list = {}; 2740 uint32_t nsid; 2741 2742 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2743 2744 ctrlr.vs.bits.mjr = 1; 2745 ctrlr.vs.bits.mnr = 2; 2746 ctrlr.vs.bits.ter = 0; 2747 ctrlr.cdata.nn = 4096; 2748 2749 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS; 2750 g_active_ns_list = active_ns_list; 2751 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2752 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 2753 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2754 } 2755 2756 fake_cpl.cdw0 = 3; 2757 nsid = spdk_nvme_ctrlr_create_ns(&ctrlr, &nsdata); 2758 fake_cpl.cdw0 = 0; 2759 CU_ASSERT(nsid == 3); 2760 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 3)); 2761 CU_ASSERT(spdk_nvme_ctrlr_get_ns(&ctrlr, 3) != NULL); 2762 2763 g_active_ns_list = active_ns_list2; 2764 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list2); 2765 CU_ASSERT(spdk_nvme_ctrlr_attach_ns(&ctrlr, 3, &ctrlr_list) == 0); 2766 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 3)); 2767 CU_ASSERT(spdk_nvme_ctrlr_get_ns(&ctrlr, 3) != NULL); 2768 2769 g_active_ns_list = active_ns_list; 2770 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2771 CU_ASSERT(spdk_nvme_ctrlr_detach_ns(&ctrlr, 3, &ctrlr_list) == 0); 2772 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 3)); 2773 CU_ASSERT(spdk_nvme_ctrlr_get_ns(&ctrlr, 3) != NULL); 2774 2775 CU_ASSERT(spdk_nvme_ctrlr_delete_ns(&ctrlr, 3) == 0); 2776 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 3)); 2777 CU_ASSERT(spdk_nvme_ctrlr_get_ns(&ctrlr, 3) != NULL); 2778 g_active_ns_list = NULL; 2779 g_active_ns_list_length = 0; 2780 2781 nvme_ctrlr_destruct(&ctrlr); 2782 } 2783 2784 static void 2785 check_en_set_rdy(void) 2786 { 2787 if (g_ut_nvme_regs.cc.bits.en == 1) { 2788 g_ut_nvme_regs.csts.bits.rdy = 1; 2789 } 2790 } 2791 2792 static void 2793 test_nvme_ctrlr_reset(void) 2794 { 2795 DECLARE_AND_CONSTRUCT_CTRLR(); 2796 struct spdk_nvme_ctrlr_data cdata = { .nn = 4096 }; 2797 uint32_t active_ns_list[] = { 1, 2, 100, 1024 }; 2798 uint32_t active_ns_list2[] = { 1, 100, 1024 }; 2799 2800 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2801 2802 g_ut_nvme_regs.vs.bits.mjr = 1; 2803 g_ut_nvme_regs.vs.bits.mnr = 2; 2804 g_ut_nvme_regs.vs.bits.ter = 0; 2805 nvme_ctrlr_get_vs(&ctrlr, &ctrlr.vs); 2806 ctrlr.cdata.nn = 2048; 2807 2808 ctrlr.state = NVME_CTRLR_STATE_IDENTIFY_ACTIVE_NS; 2809 g_active_ns_list = active_ns_list; 2810 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2811 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 2812 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2813 } 2814 CU_ASSERT(spdk_nvme_ctrlr_get_num_ns(&ctrlr) == 2048); 2815 CU_ASSERT(spdk_nvme_ctrlr_get_ns(&ctrlr, 2) != NULL); 2816 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 2)); 2817 2818 /* Reset controller with changed number of namespaces */ 2819 g_cdata = &cdata; 2820 g_active_ns_list = active_ns_list2; 2821 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list2); 2822 STAILQ_INSERT_HEAD(&adminq.free_req, &req, stailq); 2823 g_ut_nvme_regs.cc.raw = 0; 2824 g_ut_nvme_regs.csts.raw = 0; 2825 g_set_reg_cb = check_en_set_rdy; 2826 g_wait_for_completion_return_val = -ENXIO; 2827 CU_ASSERT(spdk_nvme_ctrlr_reset(&ctrlr) == 0); 2828 g_set_reg_cb = NULL; 2829 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_READY); 2830 g_cdata = NULL; 2831 g_active_ns_list = NULL; 2832 g_active_ns_list_length = 0; 2833 2834 CU_ASSERT(spdk_nvme_ctrlr_get_num_ns(&ctrlr) == 4096); 2835 CU_ASSERT(spdk_nvme_ctrlr_get_ns(&ctrlr, 2) != NULL); 2836 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 2)); 2837 2838 g_ut_nvme_regs.csts.bits.shst = SPDK_NVME_SHST_COMPLETE; 2839 nvme_ctrlr_destruct(&ctrlr); 2840 2841 g_wait_for_completion_return_val = 0; 2842 } 2843 2844 static uint32_t g_aer_cb_counter; 2845 2846 static void 2847 aer_cb(void *aer_cb_arg, const struct spdk_nvme_cpl *cpl) 2848 { 2849 g_aer_cb_counter++; 2850 } 2851 2852 static void 2853 test_nvme_ctrlr_aer_callback(void) 2854 { 2855 DECLARE_AND_CONSTRUCT_CTRLR(); 2856 uint32_t active_ns_list[] = { 1, 2, 100, 1024 }; 2857 union spdk_nvme_async_event_completion aer_event = { 2858 .bits.async_event_type = SPDK_NVME_ASYNC_EVENT_TYPE_NOTICE, 2859 .bits.async_event_info = SPDK_NVME_ASYNC_EVENT_NS_ATTR_CHANGED 2860 }; 2861 struct spdk_nvme_cpl aer_cpl = { 2862 .status.sct = SPDK_NVME_SCT_GENERIC, 2863 .status.sc = SPDK_NVME_SC_SUCCESS, 2864 .cdw0 = aer_event.raw 2865 }; 2866 2867 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2868 2869 ctrlr.vs.bits.mjr = 1; 2870 ctrlr.vs.bits.mnr = 2; 2871 ctrlr.vs.bits.ter = 0; 2872 ctrlr.cdata.nn = 4096; 2873 2874 ctrlr.state = NVME_CTRLR_STATE_CONFIGURE_AER; 2875 g_active_ns_list = active_ns_list; 2876 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2877 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 2878 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2879 } 2880 2881 CU_ASSERT(nvme_ctrlr_add_process(&ctrlr, NULL) == 0); 2882 spdk_nvme_ctrlr_register_aer_callback(&ctrlr, aer_cb, NULL); 2883 2884 /* Async event */ 2885 g_aer_cb_counter = 0; 2886 nvme_ctrlr_async_event_cb(&ctrlr.aer[0], &aer_cpl); 2887 nvme_ctrlr_complete_queued_async_events(&ctrlr); 2888 CU_ASSERT(g_aer_cb_counter == 1); 2889 g_active_ns_list = NULL; 2890 g_active_ns_list_length = 0; 2891 2892 nvme_ctrlr_free_processes(&ctrlr); 2893 nvme_ctrlr_destruct(&ctrlr); 2894 } 2895 2896 static void 2897 test_nvme_ctrlr_ns_attr_changed(void) 2898 { 2899 DECLARE_AND_CONSTRUCT_CTRLR(); 2900 uint32_t active_ns_list[] = { 1, 2, 100, 1024 }; 2901 uint32_t active_ns_list2[] = { 1, 2, 1024 }; 2902 uint32_t active_ns_list3[] = { 1, 2, 101, 1024 }; 2903 union spdk_nvme_async_event_completion aer_event = { 2904 .bits.async_event_type = SPDK_NVME_ASYNC_EVENT_TYPE_NOTICE, 2905 .bits.async_event_info = SPDK_NVME_ASYNC_EVENT_NS_ATTR_CHANGED 2906 }; 2907 struct spdk_nvme_cpl aer_cpl = { 2908 .status.sct = SPDK_NVME_SCT_GENERIC, 2909 .status.sc = SPDK_NVME_SC_SUCCESS, 2910 .cdw0 = aer_event.raw 2911 }; 2912 2913 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 2914 2915 ctrlr.vs.bits.mjr = 1; 2916 ctrlr.vs.bits.mnr = 3; 2917 ctrlr.vs.bits.ter = 0; 2918 ctrlr.cap.bits.css |= SPDK_NVME_CAP_CSS_IOCS; 2919 ctrlr.cdata.nn = 4096; 2920 2921 ctrlr.state = NVME_CTRLR_STATE_CONFIGURE_AER; 2922 g_active_ns_list = active_ns_list; 2923 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list); 2924 2925 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 2926 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 2927 } 2928 2929 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 100)); 2930 2931 CU_ASSERT(nvme_ctrlr_add_process(&ctrlr, NULL) == 0); 2932 spdk_nvme_ctrlr_register_aer_callback(&ctrlr, aer_cb, NULL); 2933 2934 /* Remove NS 100 */ 2935 g_aer_cb_counter = 0; 2936 g_active_ns_list = active_ns_list2; 2937 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list2); 2938 nvme_ctrlr_async_event_cb(&ctrlr.aer[0], &aer_cpl); 2939 nvme_ctrlr_complete_queued_async_events(&ctrlr); 2940 CU_ASSERT(g_aer_cb_counter == 1); 2941 CU_ASSERT(!spdk_nvme_ctrlr_is_active_ns(&ctrlr, 100)); 2942 2943 /* Add NS 101 */ 2944 g_active_ns_list = active_ns_list3; 2945 g_active_ns_list_length = SPDK_COUNTOF(active_ns_list3); 2946 nvme_ctrlr_async_event_cb(&ctrlr.aer[0], &aer_cpl); 2947 nvme_ctrlr_complete_queued_async_events(&ctrlr); 2948 CU_ASSERT(g_aer_cb_counter == 2); 2949 CU_ASSERT(spdk_nvme_ctrlr_is_active_ns(&ctrlr, 101)); 2950 2951 g_active_ns_list = NULL; 2952 g_active_ns_list_length = 0; 2953 nvme_ctrlr_free_processes(&ctrlr); 2954 nvme_ctrlr_destruct(&ctrlr); 2955 } 2956 2957 static void 2958 test_nvme_ctrlr_identify_namespaces_iocs_specific_next(void) 2959 { 2960 struct spdk_nvme_ctrlr ctrlr = {}; 2961 uint32_t prev_nsid; 2962 struct spdk_nvme_ns ns[5] = {}; 2963 struct spdk_nvme_ctrlr ns_ctrlr[5] = {}; 2964 int rc = 0; 2965 int i; 2966 2967 RB_INIT(&ctrlr.ns); 2968 for (i = 0; i < 5; i++) { 2969 ns[i].id = i + 1; 2970 ns[i].active = true; 2971 } 2972 2973 CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0); 2974 2975 ctrlr.cdata.nn = 5; 2976 /* case 1: No first/next active NS, move on to the next state, expect: pass */ 2977 prev_nsid = 0; 2978 ctrlr.active_ns_count = 0; 2979 ctrlr.opts.admin_timeout_ms = NVME_TIMEOUT_INFINITE; 2980 rc = nvme_ctrlr_identify_namespaces_iocs_specific_next(&ctrlr, prev_nsid); 2981 CU_ASSERT(rc == 0); 2982 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_SUPPORTED_LOG_PAGES); 2983 CU_ASSERT(ctrlr.state_timeout_tsc == NVME_TIMEOUT_INFINITE); 2984 2985 /* case 2: move on to the next active NS, and no namespace with (supported) iocs specific data found , expect: pass */ 2986 memset(&ctrlr.state, 0x00, sizeof(ctrlr.state)); 2987 memset(&ctrlr.state_timeout_tsc, 0x00, sizeof(ctrlr.state_timeout_tsc)); 2988 prev_nsid = 1; 2989 for (i = 0; i < 5; i++) { 2990 RB_INSERT(nvme_ns_tree, &ctrlr.ns, &ns[i]); 2991 } 2992 ctrlr.active_ns_count = 5; 2993 ns[1].csi = SPDK_NVME_CSI_NVM; 2994 ns[1].id = 2; 2995 rc = nvme_ctrlr_identify_namespaces_iocs_specific_next(&ctrlr, prev_nsid); 2996 CU_ASSERT(rc == 0); 2997 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_SUPPORTED_LOG_PAGES); 2998 CU_ASSERT(ctrlr.state_timeout_tsc == NVME_TIMEOUT_INFINITE); 2999 3000 /* case 3: ns.csi is SPDK_NVME_CSI_ZNS, do not loop, expect: pass */ 3001 memset(&ctrlr.state, 0x00, sizeof(ctrlr.state)); 3002 memset(&ctrlr.state_timeout_tsc, 0x00, sizeof(ctrlr.state_timeout_tsc)); 3003 ctrlr.opts.admin_timeout_ms = NVME_TIMEOUT_INFINITE; 3004 prev_nsid = 0; 3005 ctrlr.active_ns_count = 5; 3006 3007 for (int i = 0; i < 5; i++) { 3008 ns[i].csi = SPDK_NVME_CSI_NVM; 3009 ns[i].id = i + 1; 3010 ns[i].ctrlr = &ns_ctrlr[i]; 3011 } 3012 ns[4].csi = SPDK_NVME_CSI_ZNS; 3013 ns_ctrlr[4].opts.admin_timeout_ms = NVME_TIMEOUT_INFINITE; 3014 3015 rc = nvme_ctrlr_identify_namespaces_iocs_specific_next(&ctrlr, prev_nsid); 3016 CU_ASSERT(rc == 0); 3017 CU_ASSERT(ctrlr.state == 0); 3018 CU_ASSERT(ctrlr.state_timeout_tsc == NVME_TIMEOUT_INFINITE); 3019 CU_ASSERT(ns_ctrlr[4].state == NVME_CTRLR_STATE_WAIT_FOR_IDENTIFY_NS_IOCS_SPECIFIC); 3020 CU_ASSERT(ns_ctrlr[4].state_timeout_tsc == NVME_TIMEOUT_INFINITE); 3021 3022 for (int i = 0; i < 5; i++) { 3023 nvme_ns_free_zns_specific_data(&ns[i]); 3024 } 3025 3026 /* case 4: nvme_ctrlr_identify_ns_iocs_specific_async return 1, expect: false */ 3027 memset(&ctrlr.state, 0x00, sizeof(ctrlr.state)); 3028 memset(&ctrlr.state_timeout_tsc, 0x00, sizeof(ctrlr.state_timeout_tsc)); 3029 prev_nsid = 1; 3030 ctrlr.active_ns_count = 5; 3031 ns[1].csi = SPDK_NVME_CSI_ZNS; 3032 g_fail_next_identify = true; 3033 rc = nvme_ctrlr_identify_namespaces_iocs_specific_next(&ctrlr, prev_nsid); 3034 CU_ASSERT(rc == 1); 3035 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_ERROR); 3036 CU_ASSERT(ctrlr.state_timeout_tsc == NVME_TIMEOUT_INFINITE); 3037 3038 CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0); 3039 } 3040 3041 static void 3042 test_nvme_ctrlr_set_supported_log_pages(void) 3043 { 3044 int rc; 3045 struct spdk_nvme_ctrlr ctrlr = {}; 3046 3047 /* ana supported */ 3048 memset(&ctrlr, 0, sizeof(ctrlr)); 3049 ctrlr.cdata.cmic.ana_reporting = true; 3050 ctrlr.cdata.lpa.celp = 1; 3051 ctrlr.cdata.nanagrpid = 1; 3052 ctrlr.active_ns_count = 1; 3053 3054 rc = nvme_ctrlr_set_supported_log_pages(&ctrlr); 3055 CU_ASSERT(rc == 0); 3056 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_LOG_ERROR] == true); 3057 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_LOG_HEALTH_INFORMATION] == true); 3058 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_LOG_FIRMWARE_SLOT] == true); 3059 CU_ASSERT(ctrlr.ana_log_page_size == sizeof(struct spdk_nvme_ana_page) + 3060 sizeof(struct spdk_nvme_ana_group_descriptor) * 1 + sizeof(uint32_t) * 1); 3061 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_LOG_ASYMMETRIC_NAMESPACE_ACCESS] == true); 3062 free(ctrlr.ana_log_page); 3063 free(ctrlr.copied_ana_desc); 3064 } 3065 3066 static void 3067 test_nvme_ctrlr_set_intel_supported_log_pages(void) 3068 { 3069 DECLARE_AND_CONSTRUCT_CTRLR(); 3070 3071 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 3072 3073 ctrlr.opts.admin_timeout_ms = NVME_TIMEOUT_INFINITE; 3074 ctrlr.cdata.vid = SPDK_PCI_VID_INTEL; 3075 ctrlr.state = NVME_CTRLR_STATE_SET_SUPPORTED_LOG_PAGES; 3076 3077 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 3078 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_SET_SUPPORTED_INTEL_LOG_PAGES); 3079 3080 set_status_code = SPDK_NVME_SC_SUCCESS; 3081 CU_ASSERT(nvme_ctrlr_process_init(&ctrlr) == 0); 3082 CU_ASSERT(ctrlr.state == NVME_CTRLR_STATE_WAIT_FOR_SUPPORTED_INTEL_LOG_PAGES); 3083 3084 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_LOG_ERROR] == true); 3085 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_LOG_HEALTH_INFORMATION] == true); 3086 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_LOG_FIRMWARE_SLOT] == true); 3087 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_INTEL_LOG_READ_CMD_LATENCY] == true); 3088 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_INTEL_LOG_WRITE_CMD_LATENCY] == true); 3089 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_INTEL_LOG_TEMPERATURE] == true); 3090 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_INTEL_LOG_SMART] == true); 3091 CU_ASSERT(ctrlr.log_page_supported[SPDK_NVME_INTEL_MARKETING_DESCRIPTION] == true); 3092 3093 nvme_ctrlr_destruct(&ctrlr); 3094 } 3095 3096 #define UT_ANA_DESC_SIZE (sizeof(struct spdk_nvme_ana_group_descriptor) + \ 3097 sizeof(uint32_t)) 3098 static void 3099 test_nvme_ctrlr_parse_ana_log_page(void) 3100 { 3101 int rc, i; 3102 struct spdk_nvme_ctrlr ctrlr = {}; 3103 struct spdk_nvme_ns ns[3] = {}; 3104 struct spdk_nvme_ana_page ana_hdr; 3105 char _ana_desc[UT_ANA_DESC_SIZE]; 3106 struct spdk_nvme_ana_group_descriptor *ana_desc; 3107 uint32_t offset; 3108 3109 RB_INIT(&ctrlr.ns); 3110 for (i = 0; i < 3; i++) { 3111 ns[i].id = i + 1; 3112 ns[i].active = true; 3113 RB_INSERT(nvme_ns_tree, &ctrlr.ns, &ns[i]); 3114 } 3115 3116 CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0); 3117 3118 ctrlr.cdata.nn = 3; 3119 ctrlr.cdata.nanagrpid = 3; 3120 ctrlr.active_ns_count = 3; 3121 3122 rc = nvme_ctrlr_init_ana_log_page(&ctrlr); 3123 CU_ASSERT(rc == 0); 3124 CU_ASSERT(ctrlr.ana_log_page != NULL); 3125 CU_ASSERT(ctrlr.copied_ana_desc != NULL); 3126 3127 /* 3128 * Create ANA log page data - There are three ANA groups. 3129 * Each ANA group has a namespace and has a different ANA state. 3130 */ 3131 memset(&ana_hdr, 0, sizeof(ana_hdr)); 3132 ana_hdr.num_ana_group_desc = 3; 3133 3134 SPDK_CU_ASSERT_FATAL(sizeof(ana_hdr) <= ctrlr.ana_log_page_size); 3135 memcpy((char *)ctrlr.ana_log_page, (char *)&ana_hdr, sizeof(ana_hdr)); 3136 offset = sizeof(ana_hdr); 3137 3138 ana_desc = (struct spdk_nvme_ana_group_descriptor *)_ana_desc; 3139 memset(ana_desc, 0, UT_ANA_DESC_SIZE); 3140 ana_desc->num_of_nsid = 1; 3141 3142 ana_desc->ana_group_id = 1; 3143 ana_desc->ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 3144 ana_desc->nsid[0] = 3; 3145 3146 SPDK_CU_ASSERT_FATAL(offset + UT_ANA_DESC_SIZE <= ctrlr.ana_log_page_size); 3147 memcpy((char *)ctrlr.ana_log_page + offset, (char *)ana_desc, UT_ANA_DESC_SIZE); 3148 offset += UT_ANA_DESC_SIZE; 3149 3150 ana_desc->ana_group_id = 2; 3151 ana_desc->ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 3152 ana_desc->nsid[0] = 2; 3153 3154 SPDK_CU_ASSERT_FATAL(offset + UT_ANA_DESC_SIZE <= ctrlr.ana_log_page_size); 3155 memcpy((char *)ctrlr.ana_log_page + offset, (char *)ana_desc, UT_ANA_DESC_SIZE); 3156 offset += UT_ANA_DESC_SIZE; 3157 3158 ana_desc->ana_group_id = 3; 3159 ana_desc->ana_state = SPDK_NVME_ANA_INACCESSIBLE_STATE; 3160 ana_desc->nsid[0] = 1; 3161 3162 SPDK_CU_ASSERT_FATAL(offset + UT_ANA_DESC_SIZE <= ctrlr.ana_log_page_size); 3163 memcpy((char *)ctrlr.ana_log_page + offset, (char *)ana_desc, UT_ANA_DESC_SIZE); 3164 3165 /* Parse the created ANA log page data, and update ANA states. */ 3166 rc = nvme_ctrlr_parse_ana_log_page(&ctrlr, nvme_ctrlr_update_ns_ana_states, 3167 &ctrlr); 3168 CU_ASSERT(rc == 0); 3169 CU_ASSERT(ns[0].ana_group_id == 3); 3170 CU_ASSERT(ns[0].ana_state == SPDK_NVME_ANA_INACCESSIBLE_STATE); 3171 CU_ASSERT(ns[1].ana_group_id == 2); 3172 CU_ASSERT(ns[1].ana_state == SPDK_NVME_ANA_NON_OPTIMIZED_STATE); 3173 CU_ASSERT(ns[2].ana_group_id == 1); 3174 CU_ASSERT(ns[2].ana_state == SPDK_NVME_ANA_OPTIMIZED_STATE); 3175 3176 CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0); 3177 3178 free(ctrlr.ana_log_page); 3179 free(ctrlr.copied_ana_desc); 3180 } 3181 3182 static void 3183 test_nvme_ctrlr_ana_resize(void) 3184 { 3185 DECLARE_AND_CONSTRUCT_CTRLR(); 3186 uint32_t active_ns_list[] = { 1, 2, 3, 4 }; 3187 struct spdk_nvme_ana_page ana_hdr = { 3188 .change_count = 0, 3189 .num_ana_group_desc = 1 3190 }; 3191 uint8_t ana_desc_buf[sizeof(struct spdk_nvme_ana_group_descriptor) + 4 * sizeof(uint32_t)] = {}; 3192 struct spdk_nvme_ana_group_descriptor *ana_desc = 3193 (struct spdk_nvme_ana_group_descriptor *)ana_desc_buf; 3194 struct spdk_nvme_ns *ns; 3195 union spdk_nvme_async_event_completion aer_event = { 3196 .bits.async_event_type = SPDK_NVME_ASYNC_EVENT_TYPE_NOTICE, 3197 .bits.async_event_info = SPDK_NVME_ASYNC_EVENT_NS_ATTR_CHANGED 3198 }; 3199 struct spdk_nvme_cpl aer_cpl = { 3200 .status.sct = SPDK_NVME_SCT_GENERIC, 3201 .status.sc = SPDK_NVME_SC_SUCCESS, 3202 .cdw0 = aer_event.raw 3203 }; 3204 uint32_t i; 3205 3206 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_construct(&ctrlr) == 0); 3207 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_add_process(&ctrlr, NULL) == 0); 3208 3209 ctrlr.vs.bits.mjr = 1; 3210 ctrlr.vs.bits.mnr = 4; 3211 ctrlr.vs.bits.ter = 0; 3212 ctrlr.cdata.nn = 4096; 3213 ctrlr.cdata.cmic.ana_reporting = true; 3214 ctrlr.cdata.nanagrpid = 1; 3215 3216 ctrlr.state = NVME_CTRLR_STATE_CONFIGURE_AER; 3217 /* Start with 2 active namespaces */ 3218 g_active_ns_list = active_ns_list; 3219 g_active_ns_list_length = 2; 3220 g_ana_hdr = &ana_hdr; 3221 g_ana_descs = &ana_desc; 3222 ana_desc->ana_group_id = 1; 3223 ana_desc->ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 3224 ana_desc->num_of_nsid = 2; 3225 for (i = 0; i < ana_desc->num_of_nsid; ++i) { 3226 ana_desc->nsid[i] = i + 1; 3227 } 3228 3229 /* Bring controller to ready state */ 3230 while (ctrlr.state != NVME_CTRLR_STATE_READY) { 3231 SPDK_CU_ASSERT_FATAL(nvme_ctrlr_process_init(&ctrlr) == 0); 3232 } 3233 3234 for (i = 0; i < ana_desc->num_of_nsid; ++i) { 3235 ns = spdk_nvme_ctrlr_get_ns(&ctrlr, i + 1); 3236 CU_ASSERT(ns->ana_state == SPDK_NVME_ANA_NON_OPTIMIZED_STATE); 3237 } 3238 3239 /* Add more namespaces */ 3240 g_active_ns_list_length = 4; 3241 nvme_ctrlr_async_event_cb(&ctrlr.aer[0], &aer_cpl); 3242 nvme_ctrlr_complete_queued_async_events(&ctrlr); 3243 3244 /* Update ANA log with new namespaces */ 3245 ana_desc->ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 3246 ana_desc->num_of_nsid = 4; 3247 for (i = 0; i < ana_desc->num_of_nsid; ++i) { 3248 ana_desc->nsid[i] = i + 1; 3249 } 3250 aer_event.bits.async_event_info = SPDK_NVME_ASYNC_EVENT_ANA_CHANGE; 3251 aer_cpl.cdw0 = aer_event.raw; 3252 nvme_ctrlr_async_event_cb(&ctrlr.aer[0], &aer_cpl); 3253 nvme_ctrlr_complete_queued_async_events(&ctrlr); 3254 3255 for (i = 0; i < ana_desc->num_of_nsid; ++i) { 3256 ns = spdk_nvme_ctrlr_get_ns(&ctrlr, i + 1); 3257 CU_ASSERT(ns->ana_state == SPDK_NVME_ANA_OPTIMIZED_STATE); 3258 } 3259 3260 g_active_ns_list = NULL; 3261 g_active_ns_list_length = 0; 3262 g_ana_hdr = NULL; 3263 g_ana_descs = NULL; 3264 nvme_ctrlr_free_processes(&ctrlr); 3265 nvme_ctrlr_destruct(&ctrlr); 3266 } 3267 3268 static void 3269 test_nvme_ctrlr_get_memory_domains(void) 3270 { 3271 struct spdk_nvme_ctrlr ctrlr = {}; 3272 3273 MOCK_SET(nvme_transport_ctrlr_get_memory_domains, 1); 3274 CU_ASSERT(spdk_nvme_ctrlr_get_memory_domains(&ctrlr, NULL, 0) == 1); 3275 3276 MOCK_SET(nvme_transport_ctrlr_get_memory_domains, 0); 3277 CU_ASSERT(spdk_nvme_ctrlr_get_memory_domains(&ctrlr, NULL, 0) == 0); 3278 3279 MOCK_CLEAR(nvme_transport_ctrlr_get_memory_domains); 3280 } 3281 3282 int 3283 main(int argc, char **argv) 3284 { 3285 CU_pSuite suite = NULL; 3286 unsigned int num_failures; 3287 3288 CU_set_error_action(CUEA_ABORT); 3289 CU_initialize_registry(); 3290 3291 suite = CU_add_suite("nvme_ctrlr", NULL, NULL); 3292 3293 CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_1_rdy_0); 3294 CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_1_rdy_1); 3295 CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0); 3296 CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_1); 3297 CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0_ams_rr); 3298 CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0_ams_wrr); 3299 CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0_ams_vs); 3300 CU_ADD_TEST(suite, test_nvme_ctrlr_init_delay); 3301 CU_ADD_TEST(suite, test_alloc_io_qpair_rr_1); 3302 CU_ADD_TEST(suite, test_ctrlr_get_default_ctrlr_opts); 3303 CU_ADD_TEST(suite, test_ctrlr_get_default_io_qpair_opts); 3304 CU_ADD_TEST(suite, test_alloc_io_qpair_wrr_1); 3305 CU_ADD_TEST(suite, test_alloc_io_qpair_wrr_2); 3306 CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_update_firmware); 3307 CU_ADD_TEST(suite, test_nvme_ctrlr_fail); 3308 CU_ADD_TEST(suite, test_nvme_ctrlr_construct_intel_support_log_page_list); 3309 CU_ADD_TEST(suite, test_nvme_ctrlr_set_supported_features); 3310 CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_doorbell_buffer_config); 3311 #if 0 /* TODO: move to PCIe-specific unit test */ 3312 CU_ADD_TEST(suite, test_nvme_ctrlr_alloc_cmb); 3313 #endif 3314 CU_ADD_TEST(suite, test_nvme_ctrlr_test_active_ns); 3315 CU_ADD_TEST(suite, test_nvme_ctrlr_test_active_ns_error_case); 3316 CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_reconnect_io_qpair); 3317 CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_set_trid); 3318 CU_ADD_TEST(suite, test_nvme_ctrlr_init_set_nvmf_ioccsz); 3319 CU_ADD_TEST(suite, test_nvme_ctrlr_init_set_num_queues); 3320 CU_ADD_TEST(suite, test_nvme_ctrlr_init_set_keep_alive_timeout); 3321 CU_ADD_TEST(suite, test_alloc_io_qpair_fail); 3322 CU_ADD_TEST(suite, test_nvme_ctrlr_add_remove_process); 3323 CU_ADD_TEST(suite, test_nvme_ctrlr_set_arbitration_feature); 3324 CU_ADD_TEST(suite, test_nvme_ctrlr_set_state); 3325 CU_ADD_TEST(suite, test_nvme_ctrlr_active_ns_list_v0); 3326 CU_ADD_TEST(suite, test_nvme_ctrlr_active_ns_list_v2); 3327 CU_ADD_TEST(suite, test_nvme_ctrlr_ns_mgmt); 3328 CU_ADD_TEST(suite, test_nvme_ctrlr_reset); 3329 CU_ADD_TEST(suite, test_nvme_ctrlr_aer_callback); 3330 CU_ADD_TEST(suite, test_nvme_ctrlr_ns_attr_changed); 3331 CU_ADD_TEST(suite, test_nvme_ctrlr_identify_namespaces_iocs_specific_next); 3332 CU_ADD_TEST(suite, test_nvme_ctrlr_set_supported_log_pages); 3333 CU_ADD_TEST(suite, test_nvme_ctrlr_set_intel_supported_log_pages); 3334 CU_ADD_TEST(suite, test_nvme_ctrlr_parse_ana_log_page); 3335 CU_ADD_TEST(suite, test_nvme_ctrlr_ana_resize); 3336 CU_ADD_TEST(suite, test_nvme_ctrlr_get_memory_domains); 3337 3338 CU_basic_set_mode(CU_BRM_VERBOSE); 3339 CU_basic_run_tests(); 3340 num_failures = CU_get_number_of_failures(); 3341 CU_cleanup_registry(); 3342 return num_failures; 3343 } 3344