1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * Copyright (c) 2021, 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * * Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * * Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * * Neither the name of Intel Corporation nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include "spdk/stdinc.h" 36 #include "spdk_cunit.h" 37 #include "spdk/thread.h" 38 #include "spdk/bdev_module.h" 39 #include "spdk/bdev_module.h" 40 41 #include "common/lib/ut_multithread.c" 42 43 #include "bdev/nvme/bdev_nvme.c" 44 45 #include "unit/lib/json_mock.c" 46 47 static void *g_accel_p = (void *)0xdeadbeaf; 48 49 DEFINE_STUB(spdk_nvme_probe_async, struct spdk_nvme_probe_ctx *, 50 (const struct spdk_nvme_transport_id *trid, void *cb_ctx, 51 spdk_nvme_probe_cb probe_cb, spdk_nvme_attach_cb attach_cb, 52 spdk_nvme_remove_cb remove_cb), NULL); 53 54 DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid, 55 enum spdk_nvme_transport_type trtype)); 56 57 DEFINE_STUB(spdk_nvme_transport_id_trtype_str, const char *, (enum spdk_nvme_transport_type trtype), 58 NULL); 59 60 DEFINE_STUB(spdk_nvme_transport_id_adrfam_str, const char *, (enum spdk_nvmf_adrfam adrfam), NULL); 61 62 DEFINE_STUB(spdk_nvme_ctrlr_set_trid, int, (struct spdk_nvme_ctrlr *ctrlr, 63 struct spdk_nvme_transport_id *trid), 0); 64 65 DEFINE_STUB_V(spdk_nvme_ctrlr_set_remove_cb, (struct spdk_nvme_ctrlr *ctrlr, 66 spdk_nvme_remove_cb remove_cb, void *remove_ctx)); 67 68 DEFINE_STUB(spdk_nvme_ctrlr_get_flags, uint64_t, (struct spdk_nvme_ctrlr *ctrlr), 0); 69 70 DEFINE_STUB(accel_engine_create_cb, int, (void *io_device, void *ctx_buf), 0); 71 DEFINE_STUB_V(accel_engine_destroy_cb, (void *io_device, void *ctx_buf)); 72 73 DEFINE_RETURN_MOCK(spdk_nvme_ctrlr_get_memory_domain, int); 74 75 DEFINE_STUB(spdk_nvme_ctrlr_get_discovery_log_page, int, 76 (struct spdk_nvme_ctrlr *ctrlr, spdk_nvme_discovery_cb cb_fn, void *cb_arg), 0); 77 78 int spdk_nvme_ctrlr_get_memory_domains(const struct spdk_nvme_ctrlr *ctrlr, 79 struct spdk_memory_domain **domains, int array_size) 80 { 81 HANDLE_RETURN_MOCK(spdk_nvme_ctrlr_get_memory_domain); 82 83 return 0; 84 } 85 86 struct spdk_io_channel * 87 spdk_accel_engine_get_io_channel(void) 88 { 89 return spdk_get_io_channel(g_accel_p); 90 } 91 92 void 93 spdk_nvme_ctrlr_get_default_io_qpair_opts(struct spdk_nvme_ctrlr *ctrlr, 94 struct spdk_nvme_io_qpair_opts *opts, size_t opts_size) 95 { 96 /* Avoid warning that opts is used uninitialised */ 97 memset(opts, 0, opts_size); 98 } 99 100 DEFINE_STUB(spdk_nvme_ctrlr_get_max_xfer_size, uint32_t, 101 (const struct spdk_nvme_ctrlr *ctrlr), 0); 102 103 DEFINE_STUB(spdk_nvme_ctrlr_get_transport_id, const struct spdk_nvme_transport_id *, 104 (struct spdk_nvme_ctrlr *ctrlr), NULL); 105 106 DEFINE_STUB_V(spdk_nvme_ctrlr_register_aer_callback, (struct spdk_nvme_ctrlr *ctrlr, 107 spdk_nvme_aer_cb aer_cb_fn, void *aer_cb_arg)); 108 109 DEFINE_STUB_V(spdk_nvme_ctrlr_register_timeout_callback, (struct spdk_nvme_ctrlr *ctrlr, 110 uint64_t timeout_io_us, uint64_t timeout_admin_us, spdk_nvme_timeout_cb cb_fn, void *cb_arg)); 111 112 DEFINE_STUB(spdk_nvme_ctrlr_is_ocssd_supported, bool, (struct spdk_nvme_ctrlr *ctrlr), false); 113 114 DEFINE_STUB(spdk_nvme_ctrlr_cmd_abort, int, (struct spdk_nvme_ctrlr *ctrlr, 115 struct spdk_nvme_qpair *qpair, uint16_t cid, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 116 117 DEFINE_STUB(spdk_nvme_ctrlr_cmd_io_raw, int, (struct spdk_nvme_ctrlr *ctrlr, 118 struct spdk_nvme_qpair *qpair, struct spdk_nvme_cmd *cmd, void *buf, 119 uint32_t len, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 120 121 DEFINE_STUB(spdk_nvme_ctrlr_cmd_io_raw_with_md, int, (struct spdk_nvme_ctrlr *ctrlr, 122 struct spdk_nvme_qpair *qpair, struct spdk_nvme_cmd *cmd, void *buf, 123 uint32_t len, void *md_buf, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 124 125 DEFINE_STUB(spdk_nvme_ns_get_max_io_xfer_size, uint32_t, (struct spdk_nvme_ns *ns), 0); 126 127 DEFINE_STUB(spdk_nvme_ns_get_extended_sector_size, uint32_t, (struct spdk_nvme_ns *ns), 0); 128 129 DEFINE_STUB(spdk_nvme_ns_get_sector_size, uint32_t, (struct spdk_nvme_ns *ns), 0); 130 131 DEFINE_STUB(spdk_nvme_ns_get_pi_type, enum spdk_nvme_pi_type, (struct spdk_nvme_ns *ns), 0); 132 133 DEFINE_STUB(spdk_nvme_ns_supports_compare, bool, (struct spdk_nvme_ns *ns), false); 134 135 DEFINE_STUB(spdk_nvme_ns_get_md_size, uint32_t, (struct spdk_nvme_ns *ns), 0); 136 137 DEFINE_STUB(spdk_nvme_ns_get_dealloc_logical_block_read_value, 138 enum spdk_nvme_dealloc_logical_block_read_value, (struct spdk_nvme_ns *ns), 0); 139 140 DEFINE_STUB(spdk_nvme_ns_get_optimal_io_boundary, uint32_t, (struct spdk_nvme_ns *ns), 0); 141 142 DEFINE_STUB(spdk_nvme_cuse_get_ns_name, int, (struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, 143 char *name, size_t *size), 0); 144 145 DEFINE_STUB(spdk_nvme_zns_ns_get_zone_size_sectors, uint64_t, 146 (struct spdk_nvme_ns *ns), 0); 147 148 DEFINE_STUB(spdk_nvme_zns_ctrlr_get_max_zone_append_size, uint32_t, 149 (const struct spdk_nvme_ctrlr *ctrlr), 0); 150 151 DEFINE_STUB(spdk_nvme_zns_ns_get_max_open_zones, uint32_t, 152 (struct spdk_nvme_ns *ns), 0); 153 154 DEFINE_STUB(spdk_nvme_zns_ns_get_max_active_zones, uint32_t, 155 (struct spdk_nvme_ns *ns), 0); 156 157 DEFINE_STUB(spdk_nvme_zns_ns_get_num_zones, uint64_t, 158 (struct spdk_nvme_ns *ns), 0); 159 160 DEFINE_STUB(spdk_nvme_zns_zone_append_with_md, int, 161 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, void *buffer, void *metadata, 162 uint64_t zslba, uint32_t lba_count, spdk_nvme_cmd_cb cb_fn, void *cb_arg, 163 uint32_t io_flags, uint16_t apptag_mask, uint16_t apptag), 0); 164 165 DEFINE_STUB(spdk_nvme_zns_zone_appendv_with_md, int, 166 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, uint64_t zslba, 167 uint32_t lba_count, spdk_nvme_cmd_cb cb_fn, void *cb_arg, uint32_t io_flags, 168 spdk_nvme_req_reset_sgl_cb reset_sgl_fn, spdk_nvme_req_next_sge_cb next_sge_fn, 169 void *metadata, uint16_t apptag_mask, uint16_t apptag), 0); 170 171 DEFINE_STUB(spdk_nvme_zns_report_zones, int, 172 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 173 void *payload, uint32_t payload_size, uint64_t slba, 174 enum spdk_nvme_zns_zra_report_opts report_opts, bool partial_report, 175 spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 176 177 DEFINE_STUB(spdk_nvme_zns_close_zone, int, 178 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, uint64_t slba, 179 bool select_all, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 180 181 DEFINE_STUB(spdk_nvme_zns_finish_zone, int, 182 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, uint64_t slba, 183 bool select_all, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 184 185 DEFINE_STUB(spdk_nvme_zns_open_zone, int, 186 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, uint64_t slba, 187 bool select_all, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 188 189 DEFINE_STUB(spdk_nvme_zns_reset_zone, int, 190 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, uint64_t slba, 191 bool select_all, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 192 193 DEFINE_STUB(spdk_nvme_ns_get_nguid, const uint8_t *, (const struct spdk_nvme_ns *ns), NULL); 194 195 DEFINE_STUB(spdk_nvme_zns_offline_zone, int, 196 (struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, uint64_t slba, 197 bool select_all, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0); 198 199 DEFINE_STUB_V(spdk_bdev_module_fini_done, (void)); 200 201 DEFINE_STUB_V(spdk_bdev_module_list_add, (struct spdk_bdev_module *bdev_module)); 202 203 DEFINE_STUB(spdk_opal_dev_construct, struct spdk_opal_dev *, (struct spdk_nvme_ctrlr *ctrlr), NULL); 204 205 DEFINE_STUB_V(spdk_opal_dev_destruct, (struct spdk_opal_dev *dev)); 206 207 DEFINE_STUB(spdk_accel_submit_crc32cv, int, (struct spdk_io_channel *ch, uint32_t *dst, 208 struct iovec *iov, 209 uint32_t iov_cnt, uint32_t seed, spdk_accel_completion_cb cb_fn, void *cb_arg), 0); 210 211 DEFINE_STUB_V(spdk_nvme_ctrlr_prepare_for_reset, (struct spdk_nvme_ctrlr *ctrlr)); 212 213 struct ut_nvme_req { 214 uint16_t opc; 215 spdk_nvme_cmd_cb cb_fn; 216 void *cb_arg; 217 struct spdk_nvme_cpl cpl; 218 TAILQ_ENTRY(ut_nvme_req) tailq; 219 }; 220 221 struct spdk_nvme_ns { 222 struct spdk_nvme_ctrlr *ctrlr; 223 uint32_t id; 224 bool is_active; 225 struct spdk_uuid *uuid; 226 enum spdk_nvme_ana_state ana_state; 227 enum spdk_nvme_csi csi; 228 }; 229 230 struct spdk_nvme_qpair { 231 struct spdk_nvme_ctrlr *ctrlr; 232 uint8_t failure_reason; 233 bool is_connected; 234 bool in_completion_context; 235 bool delete_after_completion_context; 236 TAILQ_HEAD(, ut_nvme_req) outstanding_reqs; 237 uint32_t num_outstanding_reqs; 238 TAILQ_ENTRY(spdk_nvme_qpair) poll_group_tailq; 239 struct spdk_nvme_poll_group *poll_group; 240 void *poll_group_tailq_head; 241 TAILQ_ENTRY(spdk_nvme_qpair) tailq; 242 }; 243 244 struct spdk_nvme_ctrlr { 245 uint32_t num_ns; 246 struct spdk_nvme_ns *ns; 247 struct spdk_nvme_ns_data *nsdata; 248 struct spdk_nvme_qpair adminq; 249 struct spdk_nvme_ctrlr_data cdata; 250 bool attached; 251 bool is_failed; 252 bool fail_reset; 253 struct spdk_nvme_transport_id trid; 254 TAILQ_HEAD(, spdk_nvme_qpair) active_io_qpairs; 255 TAILQ_ENTRY(spdk_nvme_ctrlr) tailq; 256 struct spdk_nvme_ctrlr_opts opts; 257 }; 258 259 struct spdk_nvme_poll_group { 260 void *ctx; 261 struct spdk_nvme_accel_fn_table accel_fn_table; 262 TAILQ_HEAD(, spdk_nvme_qpair) connected_qpairs; 263 TAILQ_HEAD(, spdk_nvme_qpair) disconnected_qpairs; 264 }; 265 266 struct spdk_nvme_probe_ctx { 267 struct spdk_nvme_transport_id trid; 268 void *cb_ctx; 269 spdk_nvme_attach_cb attach_cb; 270 struct spdk_nvme_ctrlr *init_ctrlr; 271 }; 272 273 uint32_t 274 spdk_nvme_ctrlr_get_first_active_ns(struct spdk_nvme_ctrlr *ctrlr) 275 { 276 uint32_t nsid; 277 278 for (nsid = 1; nsid <= ctrlr->num_ns; nsid++) { 279 if (ctrlr->ns[nsid - 1].is_active) { 280 return nsid; 281 } 282 } 283 284 return 0; 285 } 286 287 uint32_t 288 spdk_nvme_ctrlr_get_next_active_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid) 289 { 290 for (nsid = nsid + 1; nsid <= ctrlr->num_ns; nsid++) { 291 if (ctrlr->ns[nsid - 1].is_active) { 292 return nsid; 293 } 294 } 295 296 return 0; 297 } 298 299 static TAILQ_HEAD(, spdk_nvme_ctrlr) g_ut_init_ctrlrs = TAILQ_HEAD_INITIALIZER(g_ut_init_ctrlrs); 300 static TAILQ_HEAD(, spdk_nvme_ctrlr) g_ut_attached_ctrlrs = TAILQ_HEAD_INITIALIZER( 301 g_ut_attached_ctrlrs); 302 static int g_ut_attach_ctrlr_status; 303 static size_t g_ut_attach_bdev_count; 304 static int g_ut_register_bdev_status; 305 static uint16_t g_ut_cntlid; 306 static struct nvme_path_id g_any_path = {}; 307 308 static void 309 ut_init_trid(struct spdk_nvme_transport_id *trid) 310 { 311 trid->trtype = SPDK_NVME_TRANSPORT_TCP; 312 snprintf(trid->subnqn, SPDK_NVMF_NQN_MAX_LEN, "%s", "nqn.2016-06.io.spdk:cnode1"); 313 snprintf(trid->traddr, SPDK_NVMF_TRADDR_MAX_LEN, "%s", "192.168.100.8"); 314 snprintf(trid->trsvcid, SPDK_NVMF_TRSVCID_MAX_LEN, "%s", "4420"); 315 } 316 317 static void 318 ut_init_trid2(struct spdk_nvme_transport_id *trid) 319 { 320 trid->trtype = SPDK_NVME_TRANSPORT_TCP; 321 snprintf(trid->subnqn, SPDK_NVMF_NQN_MAX_LEN, "%s", "nqn.2016-06.io.spdk:cnode1"); 322 snprintf(trid->traddr, SPDK_NVMF_TRADDR_MAX_LEN, "%s", "192.168.100.9"); 323 snprintf(trid->trsvcid, SPDK_NVMF_TRSVCID_MAX_LEN, "%s", "4420"); 324 } 325 326 static void 327 ut_init_trid3(struct spdk_nvme_transport_id *trid) 328 { 329 trid->trtype = SPDK_NVME_TRANSPORT_TCP; 330 snprintf(trid->subnqn, SPDK_NVMF_NQN_MAX_LEN, "%s", "nqn.2016-06.io.spdk:cnode1"); 331 snprintf(trid->traddr, SPDK_NVMF_TRADDR_MAX_LEN, "%s", "192.168.100.10"); 332 snprintf(trid->trsvcid, SPDK_NVMF_TRSVCID_MAX_LEN, "%s", "4420"); 333 } 334 335 static int 336 cmp_int(int a, int b) 337 { 338 return a - b; 339 } 340 341 int 342 spdk_nvme_transport_id_compare(const struct spdk_nvme_transport_id *trid1, 343 const struct spdk_nvme_transport_id *trid2) 344 { 345 int cmp; 346 347 /* We assume trtype is TCP for now. */ 348 CU_ASSERT(trid1->trtype == SPDK_NVME_TRANSPORT_TCP); 349 350 cmp = cmp_int(trid1->trtype, trid2->trtype); 351 if (cmp) { 352 return cmp; 353 } 354 355 cmp = strcasecmp(trid1->traddr, trid2->traddr); 356 if (cmp) { 357 return cmp; 358 } 359 360 cmp = cmp_int(trid1->adrfam, trid2->adrfam); 361 if (cmp) { 362 return cmp; 363 } 364 365 cmp = strcasecmp(trid1->trsvcid, trid2->trsvcid); 366 if (cmp) { 367 return cmp; 368 } 369 370 cmp = strcmp(trid1->subnqn, trid2->subnqn); 371 if (cmp) { 372 return cmp; 373 } 374 375 return 0; 376 } 377 378 static struct spdk_nvme_ctrlr * 379 ut_attach_ctrlr(const struct spdk_nvme_transport_id *trid, uint32_t num_ns, 380 bool ana_reporting, bool multipath) 381 { 382 struct spdk_nvme_ctrlr *ctrlr; 383 uint32_t i; 384 385 TAILQ_FOREACH(ctrlr, &g_ut_init_ctrlrs, tailq) { 386 if (spdk_nvme_transport_id_compare(&ctrlr->trid, trid) == 0) { 387 /* There is a ctrlr whose trid matches. */ 388 return NULL; 389 } 390 } 391 392 ctrlr = calloc(1, sizeof(*ctrlr)); 393 if (ctrlr == NULL) { 394 return NULL; 395 } 396 397 ctrlr->attached = true; 398 ctrlr->adminq.ctrlr = ctrlr; 399 TAILQ_INIT(&ctrlr->adminq.outstanding_reqs); 400 ctrlr->adminq.is_connected = true; 401 402 if (num_ns != 0) { 403 ctrlr->num_ns = num_ns; 404 ctrlr->ns = calloc(num_ns, sizeof(struct spdk_nvme_ns)); 405 if (ctrlr->ns == NULL) { 406 free(ctrlr); 407 return NULL; 408 } 409 410 ctrlr->nsdata = calloc(num_ns, sizeof(struct spdk_nvme_ns_data)); 411 if (ctrlr->nsdata == NULL) { 412 free(ctrlr->ns); 413 free(ctrlr); 414 return NULL; 415 } 416 417 for (i = 0; i < num_ns; i++) { 418 ctrlr->ns[i].id = i + 1; 419 ctrlr->ns[i].ctrlr = ctrlr; 420 ctrlr->ns[i].is_active = true; 421 ctrlr->ns[i].ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 422 ctrlr->nsdata[i].nsze = 1024; 423 ctrlr->nsdata[i].nmic.can_share = multipath; 424 } 425 426 ctrlr->cdata.nn = num_ns; 427 ctrlr->cdata.nanagrpid = num_ns; 428 } 429 430 ctrlr->cdata.cntlid = ++g_ut_cntlid; 431 ctrlr->cdata.cmic.multi_ctrlr = multipath; 432 ctrlr->cdata.cmic.ana_reporting = ana_reporting; 433 ctrlr->trid = *trid; 434 TAILQ_INIT(&ctrlr->active_io_qpairs); 435 436 TAILQ_INSERT_TAIL(&g_ut_init_ctrlrs, ctrlr, tailq); 437 438 return ctrlr; 439 } 440 441 static void 442 ut_detach_ctrlr(struct spdk_nvme_ctrlr *ctrlr) 443 { 444 CU_ASSERT(TAILQ_EMPTY(&ctrlr->active_io_qpairs)); 445 446 TAILQ_REMOVE(&g_ut_attached_ctrlrs, ctrlr, tailq); 447 free(ctrlr->nsdata); 448 free(ctrlr->ns); 449 free(ctrlr); 450 } 451 452 static int 453 ut_submit_nvme_request(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 454 uint16_t opc, spdk_nvme_cmd_cb cb_fn, void *cb_arg) 455 { 456 struct ut_nvme_req *req; 457 458 req = calloc(1, sizeof(*req)); 459 if (req == NULL) { 460 return -ENOMEM; 461 } 462 463 req->opc = opc; 464 req->cb_fn = cb_fn; 465 req->cb_arg = cb_arg; 466 467 req->cpl.status.sc = SPDK_NVME_SC_SUCCESS; 468 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 469 470 TAILQ_INSERT_TAIL(&qpair->outstanding_reqs, req, tailq); 471 qpair->num_outstanding_reqs++; 472 473 return 0; 474 } 475 476 static struct ut_nvme_req * 477 ut_get_outstanding_nvme_request(struct spdk_nvme_qpair *qpair, void *cb_arg) 478 { 479 struct ut_nvme_req *req; 480 481 TAILQ_FOREACH(req, &qpair->outstanding_reqs, tailq) { 482 if (req->cb_arg == cb_arg) { 483 break; 484 } 485 } 486 487 return req; 488 } 489 490 static struct spdk_bdev_io * 491 ut_alloc_bdev_io(enum spdk_bdev_io_type type, struct nvme_bdev *nbdev, 492 struct spdk_io_channel *ch) 493 { 494 struct spdk_bdev_io *bdev_io; 495 496 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct nvme_bdev_io)); 497 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 498 bdev_io->type = type; 499 bdev_io->bdev = &nbdev->disk; 500 bdev_io->internal.ch = (struct spdk_bdev_channel *)ch; 501 502 return bdev_io; 503 } 504 505 static void 506 ut_bdev_io_set_buf(struct spdk_bdev_io *bdev_io) 507 { 508 bdev_io->u.bdev.iovs = &bdev_io->iov; 509 bdev_io->u.bdev.iovcnt = 1; 510 511 bdev_io->iov.iov_base = (void *)0xFEEDBEEF; 512 bdev_io->iov.iov_len = 4096; 513 } 514 515 static void 516 nvme_ctrlr_poll_internal(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_probe_ctx *probe_ctx) 517 { 518 if (ctrlr->is_failed) { 519 free(ctrlr); 520 return; 521 } 522 523 spdk_nvme_ctrlr_get_default_ctrlr_opts(&ctrlr->opts, sizeof(ctrlr->opts)); 524 if (probe_ctx->cb_ctx) { 525 ctrlr->opts = *(struct spdk_nvme_ctrlr_opts *)probe_ctx->cb_ctx; 526 } 527 528 TAILQ_INSERT_TAIL(&g_ut_attached_ctrlrs, ctrlr, tailq); 529 530 if (probe_ctx->attach_cb) { 531 probe_ctx->attach_cb(probe_ctx->cb_ctx, &ctrlr->trid, ctrlr, &ctrlr->opts); 532 } 533 } 534 535 int 536 spdk_nvme_probe_poll_async(struct spdk_nvme_probe_ctx *probe_ctx) 537 { 538 struct spdk_nvme_ctrlr *ctrlr, *tmp; 539 540 TAILQ_FOREACH_SAFE(ctrlr, &g_ut_init_ctrlrs, tailq, tmp) { 541 if (spdk_nvme_transport_id_compare(&ctrlr->trid, &probe_ctx->trid) != 0) { 542 continue; 543 } 544 TAILQ_REMOVE(&g_ut_init_ctrlrs, ctrlr, tailq); 545 nvme_ctrlr_poll_internal(ctrlr, probe_ctx); 546 } 547 548 free(probe_ctx); 549 550 return 0; 551 } 552 553 struct spdk_nvme_probe_ctx * 554 spdk_nvme_connect_async(const struct spdk_nvme_transport_id *trid, 555 const struct spdk_nvme_ctrlr_opts *opts, 556 spdk_nvme_attach_cb attach_cb) 557 { 558 struct spdk_nvme_probe_ctx *probe_ctx; 559 560 if (trid == NULL) { 561 return NULL; 562 } 563 564 probe_ctx = calloc(1, sizeof(*probe_ctx)); 565 if (probe_ctx == NULL) { 566 return NULL; 567 } 568 569 probe_ctx->trid = *trid; 570 probe_ctx->cb_ctx = (void *)opts; 571 probe_ctx->attach_cb = attach_cb; 572 573 return probe_ctx; 574 } 575 576 int 577 spdk_nvme_detach(struct spdk_nvme_ctrlr *ctrlr) 578 { 579 if (ctrlr->attached) { 580 ut_detach_ctrlr(ctrlr); 581 } 582 583 return 0; 584 } 585 586 int 587 spdk_nvme_detach_async(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_detach_ctx **ctx) 588 { 589 SPDK_CU_ASSERT_FATAL(ctx != NULL); 590 *(struct spdk_nvme_ctrlr **)ctx = ctrlr; 591 592 return 0; 593 } 594 595 int 596 spdk_nvme_detach_poll_async(struct spdk_nvme_detach_ctx *ctx) 597 { 598 return spdk_nvme_detach((struct spdk_nvme_ctrlr *)ctx); 599 } 600 601 void 602 spdk_nvme_ctrlr_get_default_ctrlr_opts(struct spdk_nvme_ctrlr_opts *opts, size_t opts_size) 603 { 604 memset(opts, 0, opts_size); 605 606 snprintf(opts->hostnqn, sizeof(opts->hostnqn), 607 "nqn.2014-08.org.nvmexpress:uuid:7391e776-0716-11ec-9a03-0242ac130003"); 608 } 609 610 const struct spdk_nvme_ctrlr_data * 611 spdk_nvme_ctrlr_get_data(struct spdk_nvme_ctrlr *ctrlr) 612 { 613 return &ctrlr->cdata; 614 } 615 616 uint32_t 617 spdk_nvme_ctrlr_get_num_ns(struct spdk_nvme_ctrlr *ctrlr) 618 { 619 return ctrlr->num_ns; 620 } 621 622 struct spdk_nvme_ns * 623 spdk_nvme_ctrlr_get_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid) 624 { 625 if (nsid < 1 || nsid > ctrlr->num_ns) { 626 return NULL; 627 } 628 629 return &ctrlr->ns[nsid - 1]; 630 } 631 632 bool 633 spdk_nvme_ctrlr_is_active_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid) 634 { 635 if (nsid < 1 || nsid > ctrlr->num_ns) { 636 return false; 637 } 638 639 return ctrlr->ns[nsid - 1].is_active; 640 } 641 642 union spdk_nvme_csts_register 643 spdk_nvme_ctrlr_get_regs_csts(struct spdk_nvme_ctrlr *ctrlr) 644 { 645 union spdk_nvme_csts_register csts; 646 647 csts.raw = 0; 648 649 return csts; 650 } 651 652 union spdk_nvme_vs_register 653 spdk_nvme_ctrlr_get_regs_vs(struct spdk_nvme_ctrlr *ctrlr) 654 { 655 union spdk_nvme_vs_register vs; 656 657 vs.raw = 0; 658 659 return vs; 660 } 661 662 struct spdk_nvme_qpair * 663 spdk_nvme_ctrlr_alloc_io_qpair(struct spdk_nvme_ctrlr *ctrlr, 664 const struct spdk_nvme_io_qpair_opts *user_opts, 665 size_t opts_size) 666 { 667 struct spdk_nvme_qpair *qpair; 668 669 qpair = calloc(1, sizeof(*qpair)); 670 if (qpair == NULL) { 671 return NULL; 672 } 673 674 qpair->ctrlr = ctrlr; 675 TAILQ_INIT(&qpair->outstanding_reqs); 676 TAILQ_INSERT_TAIL(&ctrlr->active_io_qpairs, qpair, tailq); 677 678 return qpair; 679 } 680 681 static void 682 nvme_poll_group_connect_qpair(struct spdk_nvme_qpair *qpair) 683 { 684 struct spdk_nvme_poll_group *group = qpair->poll_group; 685 686 CU_ASSERT(qpair->poll_group_tailq_head == &group->disconnected_qpairs); 687 688 qpair->poll_group_tailq_head = &group->connected_qpairs; 689 TAILQ_REMOVE(&group->disconnected_qpairs, qpair, poll_group_tailq); 690 TAILQ_INSERT_TAIL(&group->connected_qpairs, qpair, poll_group_tailq); 691 } 692 693 static void 694 nvme_poll_group_disconnect_qpair(struct spdk_nvme_qpair *qpair) 695 { 696 struct spdk_nvme_poll_group *group = qpair->poll_group; 697 698 CU_ASSERT(qpair->poll_group_tailq_head == &group->connected_qpairs); 699 700 qpair->poll_group_tailq_head = &group->disconnected_qpairs; 701 TAILQ_REMOVE(&group->connected_qpairs, qpair, poll_group_tailq); 702 TAILQ_INSERT_TAIL(&group->disconnected_qpairs, qpair, poll_group_tailq); 703 } 704 705 int 706 spdk_nvme_ctrlr_connect_io_qpair(struct spdk_nvme_ctrlr *ctrlr, 707 struct spdk_nvme_qpair *qpair) 708 { 709 if (qpair->is_connected) { 710 return -EISCONN; 711 } 712 713 qpair->is_connected = true; 714 qpair->failure_reason = SPDK_NVME_QPAIR_FAILURE_NONE; 715 716 if (qpair->poll_group) { 717 nvme_poll_group_connect_qpair(qpair); 718 } 719 720 return 0; 721 } 722 723 void 724 spdk_nvme_ctrlr_disconnect_io_qpair(struct spdk_nvme_qpair *qpair) 725 { 726 if (!qpair->is_connected) { 727 return; 728 } 729 730 qpair->is_connected = false; 731 732 if (qpair->poll_group != NULL) { 733 nvme_poll_group_disconnect_qpair(qpair); 734 } 735 } 736 737 int 738 spdk_nvme_ctrlr_free_io_qpair(struct spdk_nvme_qpair *qpair) 739 { 740 SPDK_CU_ASSERT_FATAL(qpair->ctrlr != NULL); 741 742 if (qpair->in_completion_context) { 743 qpair->delete_after_completion_context = true; 744 return 0; 745 } 746 747 spdk_nvme_ctrlr_disconnect_io_qpair(qpair); 748 749 if (qpair->poll_group != NULL) { 750 spdk_nvme_poll_group_remove(qpair->poll_group, qpair); 751 } 752 753 TAILQ_REMOVE(&qpair->ctrlr->active_io_qpairs, qpair, tailq); 754 755 CU_ASSERT(qpair->num_outstanding_reqs == 0); 756 757 free(qpair); 758 759 return 0; 760 } 761 762 int 763 spdk_nvme_ctrlr_reconnect_poll_async(struct spdk_nvme_ctrlr *ctrlr) 764 { 765 if (ctrlr->fail_reset) { 766 ctrlr->is_failed = true; 767 return -EIO; 768 } 769 770 ctrlr->adminq.is_connected = true; 771 return 0; 772 } 773 774 void 775 spdk_nvme_ctrlr_reconnect_async(struct spdk_nvme_ctrlr *ctrlr) 776 { 777 } 778 779 int 780 spdk_nvme_ctrlr_disconnect(struct spdk_nvme_ctrlr *ctrlr) 781 { 782 ctrlr->adminq.is_connected = false; 783 ctrlr->is_failed = false; 784 785 return 0; 786 } 787 788 void 789 spdk_nvme_ctrlr_fail(struct spdk_nvme_ctrlr *ctrlr) 790 { 791 ctrlr->is_failed = true; 792 } 793 794 bool 795 spdk_nvme_ctrlr_is_failed(struct spdk_nvme_ctrlr *ctrlr) 796 { 797 return ctrlr->is_failed; 798 } 799 800 spdk_nvme_qp_failure_reason 801 spdk_nvme_ctrlr_get_admin_qp_failure_reason(struct spdk_nvme_ctrlr *ctrlr) 802 { 803 return spdk_nvme_qpair_get_failure_reason(&ctrlr->adminq); 804 } 805 806 #define UT_ANA_DESC_SIZE (sizeof(struct spdk_nvme_ana_group_descriptor) + \ 807 sizeof(uint32_t)) 808 static void 809 ut_create_ana_log_page(struct spdk_nvme_ctrlr *ctrlr, char *buf, uint32_t length) 810 { 811 struct spdk_nvme_ana_page ana_hdr; 812 char _ana_desc[UT_ANA_DESC_SIZE]; 813 struct spdk_nvme_ana_group_descriptor *ana_desc; 814 struct spdk_nvme_ns *ns; 815 uint32_t i; 816 817 memset(&ana_hdr, 0, sizeof(ana_hdr)); 818 ana_hdr.num_ana_group_desc = ctrlr->num_ns; 819 820 SPDK_CU_ASSERT_FATAL(sizeof(ana_hdr) <= length); 821 memcpy(buf, (char *)&ana_hdr, sizeof(ana_hdr)); 822 823 buf += sizeof(ana_hdr); 824 length -= sizeof(ana_hdr); 825 826 ana_desc = (struct spdk_nvme_ana_group_descriptor *)_ana_desc; 827 828 for (i = 0; i < ctrlr->num_ns; i++) { 829 ns = &ctrlr->ns[i]; 830 831 if (!ns->is_active) { 832 continue; 833 } 834 835 memset(ana_desc, 0, UT_ANA_DESC_SIZE); 836 837 ana_desc->ana_group_id = ns->id; 838 ana_desc->num_of_nsid = 1; 839 ana_desc->ana_state = ns->ana_state; 840 ana_desc->nsid[0] = ns->id; 841 842 SPDK_CU_ASSERT_FATAL(UT_ANA_DESC_SIZE <= length); 843 memcpy(buf, (char *)ana_desc, UT_ANA_DESC_SIZE); 844 845 buf += UT_ANA_DESC_SIZE; 846 length -= UT_ANA_DESC_SIZE; 847 } 848 } 849 850 int 851 spdk_nvme_ctrlr_cmd_get_log_page(struct spdk_nvme_ctrlr *ctrlr, 852 uint8_t log_page, uint32_t nsid, 853 void *payload, uint32_t payload_size, 854 uint64_t offset, 855 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 856 { 857 if (log_page == SPDK_NVME_LOG_ASYMMETRIC_NAMESPACE_ACCESS) { 858 SPDK_CU_ASSERT_FATAL(offset == 0); 859 ut_create_ana_log_page(ctrlr, payload, payload_size); 860 } 861 862 return ut_submit_nvme_request(NULL, &ctrlr->adminq, SPDK_NVME_OPC_GET_LOG_PAGE, 863 cb_fn, cb_arg); 864 } 865 866 int 867 spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr *ctrlr, 868 struct spdk_nvme_cmd *cmd, void *buf, uint32_t len, 869 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 870 { 871 return ut_submit_nvme_request(NULL, &ctrlr->adminq, cmd->opc, cb_fn, cb_arg); 872 } 873 874 int 875 spdk_nvme_ctrlr_cmd_abort_ext(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair, 876 void *cmd_cb_arg, 877 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 878 { 879 struct ut_nvme_req *req = NULL, *abort_req; 880 881 if (qpair == NULL) { 882 qpair = &ctrlr->adminq; 883 } 884 885 abort_req = calloc(1, sizeof(*abort_req)); 886 if (abort_req == NULL) { 887 return -ENOMEM; 888 } 889 890 TAILQ_FOREACH(req, &qpair->outstanding_reqs, tailq) { 891 if (req->cb_arg == cmd_cb_arg) { 892 break; 893 } 894 } 895 896 if (req == NULL) { 897 free(abort_req); 898 return -ENOENT; 899 } 900 901 req->cpl.status.sc = SPDK_NVME_SC_ABORTED_BY_REQUEST; 902 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 903 904 abort_req->opc = SPDK_NVME_OPC_ABORT; 905 abort_req->cb_fn = cb_fn; 906 abort_req->cb_arg = cb_arg; 907 908 abort_req->cpl.status.sc = SPDK_NVME_SC_SUCCESS; 909 abort_req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 910 abort_req->cpl.cdw0 = 0; 911 912 TAILQ_INSERT_TAIL(&ctrlr->adminq.outstanding_reqs, abort_req, tailq); 913 ctrlr->adminq.num_outstanding_reqs++; 914 915 return 0; 916 } 917 918 int32_t 919 spdk_nvme_ctrlr_process_admin_completions(struct spdk_nvme_ctrlr *ctrlr) 920 { 921 return spdk_nvme_qpair_process_completions(&ctrlr->adminq, 0); 922 } 923 924 uint32_t 925 spdk_nvme_ns_get_id(struct spdk_nvme_ns *ns) 926 { 927 return ns->id; 928 } 929 930 struct spdk_nvme_ctrlr * 931 spdk_nvme_ns_get_ctrlr(struct spdk_nvme_ns *ns) 932 { 933 return ns->ctrlr; 934 } 935 936 static inline struct spdk_nvme_ns_data * 937 _nvme_ns_get_data(struct spdk_nvme_ns *ns) 938 { 939 return &ns->ctrlr->nsdata[ns->id - 1]; 940 } 941 942 const struct spdk_nvme_ns_data * 943 spdk_nvme_ns_get_data(struct spdk_nvme_ns *ns) 944 { 945 return _nvme_ns_get_data(ns); 946 } 947 948 uint64_t 949 spdk_nvme_ns_get_num_sectors(struct spdk_nvme_ns *ns) 950 { 951 return _nvme_ns_get_data(ns)->nsze; 952 } 953 954 const struct spdk_uuid * 955 spdk_nvme_ns_get_uuid(const struct spdk_nvme_ns *ns) 956 { 957 return ns->uuid; 958 } 959 960 enum spdk_nvme_csi 961 spdk_nvme_ns_get_csi(const struct spdk_nvme_ns *ns) { 962 return ns->csi; 963 } 964 965 int 966 spdk_nvme_ns_cmd_read_with_md(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, void *buffer, 967 void *metadata, uint64_t lba, uint32_t lba_count, 968 spdk_nvme_cmd_cb cb_fn, void *cb_arg, 969 uint32_t io_flags, uint16_t apptag_mask, uint16_t apptag) 970 { 971 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_READ, cb_fn, cb_arg); 972 } 973 974 int 975 spdk_nvme_ns_cmd_write_with_md(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 976 void *buffer, void *metadata, uint64_t lba, 977 uint32_t lba_count, spdk_nvme_cmd_cb cb_fn, void *cb_arg, 978 uint32_t io_flags, uint16_t apptag_mask, uint16_t apptag) 979 { 980 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_WRITE, cb_fn, cb_arg); 981 } 982 983 int 984 spdk_nvme_ns_cmd_readv_with_md(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 985 uint64_t lba, uint32_t lba_count, 986 spdk_nvme_cmd_cb cb_fn, void *cb_arg, uint32_t io_flags, 987 spdk_nvme_req_reset_sgl_cb reset_sgl_fn, 988 spdk_nvme_req_next_sge_cb next_sge_fn, void *metadata, 989 uint16_t apptag_mask, uint16_t apptag) 990 { 991 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_READ, cb_fn, cb_arg); 992 } 993 994 int 995 spdk_nvme_ns_cmd_writev_with_md(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 996 uint64_t lba, uint32_t lba_count, 997 spdk_nvme_cmd_cb cb_fn, void *cb_arg, uint32_t io_flags, 998 spdk_nvme_req_reset_sgl_cb reset_sgl_fn, 999 spdk_nvme_req_next_sge_cb next_sge_fn, void *metadata, 1000 uint16_t apptag_mask, uint16_t apptag) 1001 { 1002 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_WRITE, cb_fn, cb_arg); 1003 } 1004 1005 static bool g_ut_readv_ext_called; 1006 int 1007 spdk_nvme_ns_cmd_readv_ext(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 1008 uint64_t lba, uint32_t lba_count, 1009 spdk_nvme_cmd_cb cb_fn, void *cb_arg, 1010 spdk_nvme_req_reset_sgl_cb reset_sgl_fn, 1011 spdk_nvme_req_next_sge_cb next_sge_fn, 1012 struct spdk_nvme_ns_cmd_ext_io_opts *opts) 1013 { 1014 g_ut_readv_ext_called = true; 1015 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_READ, cb_fn, cb_arg); 1016 } 1017 1018 static bool g_ut_writev_ext_called; 1019 int 1020 spdk_nvme_ns_cmd_writev_ext(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 1021 uint64_t lba, uint32_t lba_count, 1022 spdk_nvme_cmd_cb cb_fn, void *cb_arg, 1023 spdk_nvme_req_reset_sgl_cb reset_sgl_fn, 1024 spdk_nvme_req_next_sge_cb next_sge_fn, 1025 struct spdk_nvme_ns_cmd_ext_io_opts *opts) 1026 { 1027 g_ut_writev_ext_called = true; 1028 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_WRITE, cb_fn, cb_arg); 1029 } 1030 1031 int 1032 spdk_nvme_ns_cmd_comparev_with_md(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 1033 uint64_t lba, uint32_t lba_count, 1034 spdk_nvme_cmd_cb cb_fn, void *cb_arg, uint32_t io_flags, 1035 spdk_nvme_req_reset_sgl_cb reset_sgl_fn, 1036 spdk_nvme_req_next_sge_cb next_sge_fn, 1037 void *metadata, uint16_t apptag_mask, uint16_t apptag) 1038 { 1039 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_COMPARE, cb_fn, cb_arg); 1040 } 1041 1042 int 1043 spdk_nvme_ns_cmd_dataset_management(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 1044 uint32_t type, const struct spdk_nvme_dsm_range *ranges, uint16_t num_ranges, 1045 spdk_nvme_cmd_cb cb_fn, void *cb_arg) 1046 { 1047 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_DATASET_MANAGEMENT, cb_fn, cb_arg); 1048 } 1049 1050 int 1051 spdk_nvme_ns_cmd_write_zeroes(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair, 1052 uint64_t lba, uint32_t lba_count, 1053 spdk_nvme_cmd_cb cb_fn, void *cb_arg, 1054 uint32_t io_flags) 1055 { 1056 return ut_submit_nvme_request(ns, qpair, SPDK_NVME_OPC_WRITE_ZEROES, cb_fn, cb_arg); 1057 } 1058 1059 struct spdk_nvme_poll_group * 1060 spdk_nvme_poll_group_create(void *ctx, struct spdk_nvme_accel_fn_table *table) 1061 { 1062 struct spdk_nvme_poll_group *group; 1063 1064 group = calloc(1, sizeof(*group)); 1065 if (group == NULL) { 1066 return NULL; 1067 } 1068 1069 group->ctx = ctx; 1070 if (table != NULL) { 1071 group->accel_fn_table = *table; 1072 } 1073 TAILQ_INIT(&group->connected_qpairs); 1074 TAILQ_INIT(&group->disconnected_qpairs); 1075 1076 return group; 1077 } 1078 1079 int 1080 spdk_nvme_poll_group_destroy(struct spdk_nvme_poll_group *group) 1081 { 1082 if (!TAILQ_EMPTY(&group->connected_qpairs) || 1083 !TAILQ_EMPTY(&group->disconnected_qpairs)) { 1084 return -EBUSY; 1085 } 1086 1087 free(group); 1088 1089 return 0; 1090 } 1091 1092 spdk_nvme_qp_failure_reason 1093 spdk_nvme_qpair_get_failure_reason(struct spdk_nvme_qpair *qpair) 1094 { 1095 return qpair->failure_reason; 1096 } 1097 1098 int32_t 1099 spdk_nvme_qpair_process_completions(struct spdk_nvme_qpair *qpair, 1100 uint32_t max_completions) 1101 { 1102 struct ut_nvme_req *req, *tmp; 1103 uint32_t num_completions = 0; 1104 1105 if (!qpair->is_connected) { 1106 return -ENXIO; 1107 } 1108 1109 qpair->in_completion_context = true; 1110 1111 TAILQ_FOREACH_SAFE(req, &qpair->outstanding_reqs, tailq, tmp) { 1112 TAILQ_REMOVE(&qpair->outstanding_reqs, req, tailq); 1113 qpair->num_outstanding_reqs--; 1114 1115 req->cb_fn(req->cb_arg, &req->cpl); 1116 1117 free(req); 1118 num_completions++; 1119 } 1120 1121 qpair->in_completion_context = false; 1122 if (qpair->delete_after_completion_context) { 1123 spdk_nvme_ctrlr_free_io_qpair(qpair); 1124 } 1125 1126 return num_completions; 1127 } 1128 1129 int64_t 1130 spdk_nvme_poll_group_process_completions(struct spdk_nvme_poll_group *group, 1131 uint32_t completions_per_qpair, 1132 spdk_nvme_disconnected_qpair_cb disconnected_qpair_cb) 1133 { 1134 struct spdk_nvme_qpair *qpair, *tmp_qpair; 1135 int64_t local_completions = 0, error_reason = 0, num_completions = 0; 1136 1137 SPDK_CU_ASSERT_FATAL(completions_per_qpair == 0); 1138 1139 if (disconnected_qpair_cb == NULL) { 1140 return -EINVAL; 1141 } 1142 1143 TAILQ_FOREACH_SAFE(qpair, &group->disconnected_qpairs, poll_group_tailq, tmp_qpair) { 1144 disconnected_qpair_cb(qpair, group->ctx); 1145 } 1146 1147 TAILQ_FOREACH_SAFE(qpair, &group->connected_qpairs, poll_group_tailq, tmp_qpair) { 1148 if (qpair->failure_reason != SPDK_NVME_QPAIR_FAILURE_NONE) { 1149 spdk_nvme_ctrlr_disconnect_io_qpair(qpair); 1150 /* Bump the number of completions so this counts as "busy" */ 1151 num_completions++; 1152 continue; 1153 } 1154 1155 local_completions = spdk_nvme_qpair_process_completions(qpair, 1156 completions_per_qpair); 1157 if (local_completions < 0 && error_reason == 0) { 1158 error_reason = local_completions; 1159 } else { 1160 num_completions += local_completions; 1161 assert(num_completions >= 0); 1162 } 1163 } 1164 1165 return error_reason ? error_reason : num_completions; 1166 } 1167 1168 int 1169 spdk_nvme_poll_group_add(struct spdk_nvme_poll_group *group, 1170 struct spdk_nvme_qpair *qpair) 1171 { 1172 CU_ASSERT(!qpair->is_connected); 1173 1174 qpair->poll_group = group; 1175 qpair->poll_group_tailq_head = &group->disconnected_qpairs; 1176 TAILQ_INSERT_TAIL(&group->disconnected_qpairs, qpair, poll_group_tailq); 1177 1178 return 0; 1179 } 1180 1181 int 1182 spdk_nvme_poll_group_remove(struct spdk_nvme_poll_group *group, 1183 struct spdk_nvme_qpair *qpair) 1184 { 1185 CU_ASSERT(!qpair->is_connected); 1186 1187 if (qpair->poll_group == NULL) { 1188 return -ENOENT; 1189 } 1190 1191 CU_ASSERT(qpair->poll_group_tailq_head == &group->disconnected_qpairs); 1192 1193 TAILQ_REMOVE(&group->disconnected_qpairs, qpair, poll_group_tailq); 1194 1195 qpair->poll_group = NULL; 1196 qpair->poll_group_tailq_head = NULL; 1197 1198 return 0; 1199 } 1200 1201 int 1202 spdk_bdev_register(struct spdk_bdev *bdev) 1203 { 1204 return g_ut_register_bdev_status; 1205 } 1206 1207 void 1208 spdk_bdev_unregister(struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg) 1209 { 1210 int rc; 1211 1212 rc = bdev->fn_table->destruct(bdev->ctxt); 1213 if (rc <= 0 && cb_fn != NULL) { 1214 cb_fn(cb_arg, rc); 1215 } 1216 } 1217 1218 int 1219 spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size) 1220 { 1221 bdev->blockcnt = size; 1222 1223 return 0; 1224 } 1225 1226 struct spdk_io_channel * 1227 spdk_bdev_io_get_io_channel(struct spdk_bdev_io *bdev_io) 1228 { 1229 return (struct spdk_io_channel *)bdev_io->internal.ch; 1230 } 1231 1232 void 1233 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 1234 { 1235 bdev_io->internal.status = status; 1236 bdev_io->internal.in_submit_request = false; 1237 } 1238 1239 void 1240 spdk_bdev_io_complete_nvme_status(struct spdk_bdev_io *bdev_io, uint32_t cdw0, int sct, int sc) 1241 { 1242 if (sct == SPDK_NVME_SCT_GENERIC && sc == SPDK_NVME_SC_SUCCESS) { 1243 bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 1244 } else if (sct == SPDK_NVME_SCT_GENERIC && sc == SPDK_NVME_SC_ABORTED_BY_REQUEST) { 1245 bdev_io->internal.status = SPDK_BDEV_IO_STATUS_ABORTED; 1246 } else { 1247 bdev_io->internal.status = SPDK_BDEV_IO_STATUS_NVME_ERROR; 1248 } 1249 1250 bdev_io->internal.error.nvme.cdw0 = cdw0; 1251 bdev_io->internal.error.nvme.sct = sct; 1252 bdev_io->internal.error.nvme.sc = sc; 1253 1254 spdk_bdev_io_complete(bdev_io, bdev_io->internal.status); 1255 } 1256 1257 void 1258 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 1259 { 1260 struct spdk_io_channel *ch = spdk_bdev_io_get_io_channel(bdev_io); 1261 1262 ut_bdev_io_set_buf(bdev_io); 1263 1264 cb(ch, bdev_io, true); 1265 } 1266 1267 static void 1268 test_create_ctrlr(void) 1269 { 1270 struct spdk_nvme_transport_id trid = {}; 1271 struct spdk_nvme_ctrlr ctrlr = {}; 1272 int rc; 1273 1274 ut_init_trid(&trid); 1275 1276 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid, NULL); 1277 CU_ASSERT(rc == 0); 1278 1279 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") != NULL); 1280 1281 rc = bdev_nvme_delete("nvme0", &g_any_path); 1282 CU_ASSERT(rc == 0); 1283 1284 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") != NULL); 1285 1286 poll_threads(); 1287 spdk_delay_us(1000); 1288 poll_threads(); 1289 1290 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1291 } 1292 1293 static void 1294 test_reset_ctrlr(void) 1295 { 1296 struct spdk_nvme_transport_id trid = {}; 1297 struct spdk_nvme_ctrlr ctrlr = {}; 1298 struct nvme_ctrlr *nvme_ctrlr = NULL; 1299 struct nvme_path_id *curr_trid; 1300 struct spdk_io_channel *ch1, *ch2; 1301 struct nvme_ctrlr_channel *ctrlr_ch1, *ctrlr_ch2; 1302 int rc; 1303 1304 ut_init_trid(&trid); 1305 TAILQ_INIT(&ctrlr.active_io_qpairs); 1306 1307 set_thread(0); 1308 1309 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid, NULL); 1310 CU_ASSERT(rc == 0); 1311 1312 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1313 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1314 1315 curr_trid = TAILQ_FIRST(&nvme_ctrlr->trids); 1316 SPDK_CU_ASSERT_FATAL(curr_trid != NULL); 1317 1318 ch1 = spdk_get_io_channel(nvme_ctrlr); 1319 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 1320 1321 ctrlr_ch1 = spdk_io_channel_get_ctx(ch1); 1322 CU_ASSERT(ctrlr_ch1->qpair != NULL); 1323 1324 set_thread(1); 1325 1326 ch2 = spdk_get_io_channel(nvme_ctrlr); 1327 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 1328 1329 ctrlr_ch2 = spdk_io_channel_get_ctx(ch2); 1330 CU_ASSERT(ctrlr_ch2->qpair != NULL); 1331 1332 /* Reset starts from thread 1. */ 1333 set_thread(1); 1334 1335 /* Case 1: ctrlr is already being destructed. */ 1336 nvme_ctrlr->destruct = true; 1337 1338 rc = bdev_nvme_reset(nvme_ctrlr); 1339 CU_ASSERT(rc == -ENXIO); 1340 1341 /* Case 2: reset is in progress. */ 1342 nvme_ctrlr->destruct = false; 1343 nvme_ctrlr->resetting = true; 1344 1345 rc = bdev_nvme_reset(nvme_ctrlr); 1346 CU_ASSERT(rc == -EBUSY); 1347 1348 /* Case 3: reset completes successfully. */ 1349 nvme_ctrlr->resetting = false; 1350 curr_trid->is_failed = true; 1351 ctrlr.is_failed = true; 1352 1353 rc = bdev_nvme_reset(nvme_ctrlr); 1354 CU_ASSERT(rc == 0); 1355 CU_ASSERT(nvme_ctrlr->resetting == true); 1356 CU_ASSERT(ctrlr_ch1->qpair != NULL); 1357 CU_ASSERT(ctrlr_ch2->qpair != NULL); 1358 1359 poll_thread_times(0, 3); 1360 CU_ASSERT(ctrlr_ch1->qpair->qpair == NULL); 1361 CU_ASSERT(ctrlr_ch2->qpair->qpair != NULL); 1362 1363 poll_thread_times(0, 1); 1364 poll_thread_times(1, 1); 1365 CU_ASSERT(ctrlr_ch1->qpair->qpair == NULL); 1366 CU_ASSERT(ctrlr_ch2->qpair->qpair == NULL); 1367 CU_ASSERT(ctrlr.is_failed == true); 1368 1369 poll_thread_times(1, 1); 1370 poll_thread_times(0, 1); 1371 CU_ASSERT(ctrlr.is_failed == false); 1372 CU_ASSERT(ctrlr.adminq.is_connected == false); 1373 1374 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1375 poll_thread_times(0, 2); 1376 CU_ASSERT(ctrlr.adminq.is_connected == true); 1377 1378 poll_thread_times(0, 1); 1379 CU_ASSERT(ctrlr_ch1->qpair->qpair != NULL); 1380 CU_ASSERT(ctrlr_ch2->qpair->qpair == NULL); 1381 1382 poll_thread_times(1, 1); 1383 CU_ASSERT(ctrlr_ch1->qpair->qpair != NULL); 1384 CU_ASSERT(ctrlr_ch2->qpair->qpair != NULL); 1385 CU_ASSERT(nvme_ctrlr->resetting == true); 1386 CU_ASSERT(curr_trid->is_failed == true); 1387 1388 poll_thread_times(0, 2); 1389 CU_ASSERT(nvme_ctrlr->resetting == true); 1390 poll_thread_times(1, 1); 1391 CU_ASSERT(nvme_ctrlr->resetting == true); 1392 poll_thread_times(0, 1); 1393 CU_ASSERT(nvme_ctrlr->resetting == false); 1394 CU_ASSERT(curr_trid->is_failed == false); 1395 1396 spdk_put_io_channel(ch2); 1397 1398 set_thread(0); 1399 1400 spdk_put_io_channel(ch1); 1401 1402 poll_threads(); 1403 1404 rc = bdev_nvme_delete("nvme0", &g_any_path); 1405 CU_ASSERT(rc == 0); 1406 1407 poll_threads(); 1408 spdk_delay_us(1000); 1409 poll_threads(); 1410 1411 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1412 } 1413 1414 static void 1415 test_race_between_reset_and_destruct_ctrlr(void) 1416 { 1417 struct spdk_nvme_transport_id trid = {}; 1418 struct spdk_nvme_ctrlr ctrlr = {}; 1419 struct nvme_ctrlr *nvme_ctrlr; 1420 struct spdk_io_channel *ch1, *ch2; 1421 int rc; 1422 1423 ut_init_trid(&trid); 1424 TAILQ_INIT(&ctrlr.active_io_qpairs); 1425 1426 set_thread(0); 1427 1428 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid, NULL); 1429 CU_ASSERT(rc == 0); 1430 1431 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1432 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1433 1434 ch1 = spdk_get_io_channel(nvme_ctrlr); 1435 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 1436 1437 set_thread(1); 1438 1439 ch2 = spdk_get_io_channel(nvme_ctrlr); 1440 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 1441 1442 /* Reset starts from thread 1. */ 1443 set_thread(1); 1444 1445 rc = bdev_nvme_reset(nvme_ctrlr); 1446 CU_ASSERT(rc == 0); 1447 CU_ASSERT(nvme_ctrlr->resetting == true); 1448 1449 /* Try destructing ctrlr while ctrlr is being reset, but it will be deferred. */ 1450 set_thread(0); 1451 1452 rc = bdev_nvme_delete("nvme0", &g_any_path); 1453 CU_ASSERT(rc == 0); 1454 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == nvme_ctrlr); 1455 CU_ASSERT(nvme_ctrlr->destruct == true); 1456 CU_ASSERT(nvme_ctrlr->resetting == true); 1457 1458 poll_threads(); 1459 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1460 poll_threads(); 1461 1462 /* Reset completed but ctrlr is not still destructed yet. */ 1463 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == nvme_ctrlr); 1464 CU_ASSERT(nvme_ctrlr->destruct == true); 1465 CU_ASSERT(nvme_ctrlr->resetting == false); 1466 1467 /* New reset request is rejected. */ 1468 rc = bdev_nvme_reset(nvme_ctrlr); 1469 CU_ASSERT(rc == -ENXIO); 1470 1471 /* Additional polling called spdk_io_device_unregister() to ctrlr, 1472 * However there are two channels and destruct is not completed yet. 1473 */ 1474 poll_threads(); 1475 1476 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == nvme_ctrlr); 1477 1478 set_thread(0); 1479 1480 spdk_put_io_channel(ch1); 1481 1482 set_thread(1); 1483 1484 spdk_put_io_channel(ch2); 1485 1486 poll_threads(); 1487 spdk_delay_us(1000); 1488 poll_threads(); 1489 1490 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1491 } 1492 1493 static void 1494 test_failover_ctrlr(void) 1495 { 1496 struct spdk_nvme_transport_id trid1 = {}, trid2 = {}; 1497 struct spdk_nvme_ctrlr ctrlr = {}; 1498 struct nvme_ctrlr *nvme_ctrlr = NULL; 1499 struct nvme_path_id *curr_trid, *next_trid; 1500 struct spdk_io_channel *ch1, *ch2; 1501 int rc; 1502 1503 ut_init_trid(&trid1); 1504 ut_init_trid2(&trid2); 1505 TAILQ_INIT(&ctrlr.active_io_qpairs); 1506 1507 set_thread(0); 1508 1509 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid1, NULL); 1510 CU_ASSERT(rc == 0); 1511 1512 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1513 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1514 1515 ch1 = spdk_get_io_channel(nvme_ctrlr); 1516 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 1517 1518 set_thread(1); 1519 1520 ch2 = spdk_get_io_channel(nvme_ctrlr); 1521 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 1522 1523 /* First, test one trid case. */ 1524 curr_trid = TAILQ_FIRST(&nvme_ctrlr->trids); 1525 SPDK_CU_ASSERT_FATAL(curr_trid != NULL); 1526 1527 /* Failover starts from thread 1. */ 1528 set_thread(1); 1529 1530 /* Case 1: ctrlr is already being destructed. */ 1531 nvme_ctrlr->destruct = true; 1532 1533 rc = bdev_nvme_failover(nvme_ctrlr, false); 1534 CU_ASSERT(rc == -ENXIO); 1535 CU_ASSERT(curr_trid->is_failed == false); 1536 1537 /* Case 2: reset is in progress. */ 1538 nvme_ctrlr->destruct = false; 1539 nvme_ctrlr->resetting = true; 1540 1541 rc = bdev_nvme_failover(nvme_ctrlr, false); 1542 CU_ASSERT(rc == -EBUSY); 1543 1544 /* Case 3: reset completes successfully. */ 1545 nvme_ctrlr->resetting = false; 1546 1547 rc = bdev_nvme_failover(nvme_ctrlr, false); 1548 CU_ASSERT(rc == 0); 1549 1550 CU_ASSERT(nvme_ctrlr->resetting == true); 1551 CU_ASSERT(curr_trid->is_failed == true); 1552 1553 poll_threads(); 1554 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1555 poll_threads(); 1556 1557 curr_trid = TAILQ_FIRST(&nvme_ctrlr->trids); 1558 SPDK_CU_ASSERT_FATAL(curr_trid != NULL); 1559 1560 CU_ASSERT(nvme_ctrlr->resetting == false); 1561 CU_ASSERT(curr_trid->is_failed == false); 1562 1563 set_thread(0); 1564 1565 /* Second, test two trids case. */ 1566 rc = bdev_nvme_add_secondary_trid(nvme_ctrlr, &ctrlr, &trid2); 1567 CU_ASSERT(rc == 0); 1568 1569 curr_trid = TAILQ_FIRST(&nvme_ctrlr->trids); 1570 SPDK_CU_ASSERT_FATAL(curr_trid != NULL); 1571 CU_ASSERT(curr_trid == nvme_ctrlr->active_path_id); 1572 CU_ASSERT(spdk_nvme_transport_id_compare(&curr_trid->trid, &trid1) == 0); 1573 1574 /* Failover starts from thread 1. */ 1575 set_thread(1); 1576 1577 /* Case 4: reset is in progress. */ 1578 nvme_ctrlr->resetting = true; 1579 1580 rc = bdev_nvme_failover(nvme_ctrlr, false); 1581 CU_ASSERT(rc == -EBUSY); 1582 1583 /* Case 5: failover completes successfully. */ 1584 nvme_ctrlr->resetting = false; 1585 1586 rc = bdev_nvme_failover(nvme_ctrlr, false); 1587 CU_ASSERT(rc == 0); 1588 1589 CU_ASSERT(nvme_ctrlr->resetting == true); 1590 1591 next_trid = TAILQ_FIRST(&nvme_ctrlr->trids); 1592 SPDK_CU_ASSERT_FATAL(next_trid != NULL); 1593 CU_ASSERT(next_trid != curr_trid); 1594 CU_ASSERT(next_trid == nvme_ctrlr->active_path_id); 1595 CU_ASSERT(spdk_nvme_transport_id_compare(&next_trid->trid, &trid2) == 0); 1596 1597 poll_threads(); 1598 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1599 poll_threads(); 1600 1601 CU_ASSERT(nvme_ctrlr->resetting == false); 1602 1603 spdk_put_io_channel(ch2); 1604 1605 set_thread(0); 1606 1607 spdk_put_io_channel(ch1); 1608 1609 poll_threads(); 1610 1611 rc = bdev_nvme_delete("nvme0", &g_any_path); 1612 CU_ASSERT(rc == 0); 1613 1614 poll_threads(); 1615 spdk_delay_us(1000); 1616 poll_threads(); 1617 1618 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1619 } 1620 1621 /* We had a bug when running test/nvmf/host/multipath.sh. The bug was the following. 1622 * 1623 * A nvme_ctrlr had trid1 and trid2 first. trid1 was active. A connection to trid1 was 1624 * disconnected and reset ctrlr failed repeatedly before starting failover from trid1 1625 * to trid2. While processing the failed reset, trid3 was added. trid1 should 1626 * have been active, i.e., the head of the list until the failover completed. 1627 * However trid3 was inserted to the head of the list by mistake. 1628 * 1629 * I/O qpairs have smaller polling period than admin qpair. When a connection is 1630 * detected, I/O qpair may detect the error earlier than admin qpair. I/O qpair error 1631 * invokes reset ctrlr and admin qpair error invokes failover ctrlr. Hence reset ctrlr 1632 * may be executed repeatedly before failover is executed. Hence this bug is real. 1633 * 1634 * The following test verifies the fix. 1635 */ 1636 static void 1637 test_race_between_failover_and_add_secondary_trid(void) 1638 { 1639 struct spdk_nvme_transport_id trid1 = {}, trid2 = {}, trid3 = {}; 1640 struct spdk_nvme_ctrlr ctrlr = {}; 1641 struct nvme_ctrlr *nvme_ctrlr = NULL; 1642 struct nvme_path_id *path_id1, *path_id2, *path_id3; 1643 struct spdk_io_channel *ch1, *ch2; 1644 int rc; 1645 1646 ut_init_trid(&trid1); 1647 ut_init_trid2(&trid2); 1648 ut_init_trid3(&trid3); 1649 TAILQ_INIT(&ctrlr.active_io_qpairs); 1650 1651 set_thread(0); 1652 1653 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid1, NULL); 1654 CU_ASSERT(rc == 0); 1655 1656 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1657 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1658 1659 ch1 = spdk_get_io_channel(nvme_ctrlr); 1660 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 1661 1662 set_thread(1); 1663 1664 ch2 = spdk_get_io_channel(nvme_ctrlr); 1665 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 1666 1667 set_thread(0); 1668 1669 rc = bdev_nvme_add_secondary_trid(nvme_ctrlr, &ctrlr, &trid2); 1670 CU_ASSERT(rc == 0); 1671 1672 path_id1 = TAILQ_FIRST(&nvme_ctrlr->trids); 1673 SPDK_CU_ASSERT_FATAL(path_id1 != NULL); 1674 CU_ASSERT(path_id1 == nvme_ctrlr->active_path_id); 1675 CU_ASSERT(spdk_nvme_transport_id_compare(&path_id1->trid, &trid1) == 0); 1676 path_id2 = TAILQ_NEXT(path_id1, link); 1677 SPDK_CU_ASSERT_FATAL(path_id2 != NULL); 1678 CU_ASSERT(spdk_nvme_transport_id_compare(&path_id2->trid, &trid2) == 0); 1679 1680 ctrlr.fail_reset = true; 1681 1682 rc = bdev_nvme_reset(nvme_ctrlr); 1683 CU_ASSERT(rc == 0); 1684 1685 poll_threads(); 1686 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1687 poll_threads(); 1688 1689 CU_ASSERT(path_id1->is_failed == true); 1690 CU_ASSERT(path_id1 == nvme_ctrlr->active_path_id); 1691 1692 rc = bdev_nvme_reset(nvme_ctrlr); 1693 CU_ASSERT(rc == 0); 1694 1695 rc = bdev_nvme_add_secondary_trid(nvme_ctrlr, &ctrlr, &trid3); 1696 CU_ASSERT(rc == 0); 1697 1698 CU_ASSERT(path_id1 == TAILQ_FIRST(&nvme_ctrlr->trids)); 1699 CU_ASSERT(path_id1 == nvme_ctrlr->active_path_id); 1700 CU_ASSERT(spdk_nvme_transport_id_compare(&path_id1->trid, &trid1) == 0); 1701 CU_ASSERT(path_id2 == TAILQ_NEXT(path_id1, link)); 1702 CU_ASSERT(spdk_nvme_transport_id_compare(&path_id2->trid, &trid2) == 0); 1703 path_id3 = TAILQ_NEXT(path_id2, link); 1704 SPDK_CU_ASSERT_FATAL(path_id3 != NULL); 1705 CU_ASSERT(spdk_nvme_transport_id_compare(&path_id3->trid, &trid3) == 0); 1706 1707 poll_threads(); 1708 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1709 poll_threads(); 1710 1711 spdk_put_io_channel(ch1); 1712 1713 set_thread(1); 1714 1715 spdk_put_io_channel(ch2); 1716 1717 poll_threads(); 1718 1719 set_thread(0); 1720 1721 rc = bdev_nvme_delete("nvme0", &g_any_path); 1722 CU_ASSERT(rc == 0); 1723 1724 poll_threads(); 1725 spdk_delay_us(1000); 1726 poll_threads(); 1727 1728 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1729 } 1730 1731 static void 1732 attach_ctrlr_done(void *cb_ctx, size_t bdev_count, int rc) 1733 { 1734 CU_ASSERT(rc == g_ut_attach_ctrlr_status); 1735 CU_ASSERT(bdev_count == g_ut_attach_bdev_count); 1736 } 1737 1738 static void 1739 test_pending_reset(void) 1740 { 1741 struct spdk_nvme_transport_id trid = {}; 1742 struct spdk_nvme_ctrlr *ctrlr; 1743 struct nvme_ctrlr *nvme_ctrlr = NULL; 1744 const int STRING_SIZE = 32; 1745 const char *attached_names[STRING_SIZE]; 1746 struct nvme_bdev *bdev; 1747 struct spdk_bdev_io *first_bdev_io, *second_bdev_io; 1748 struct spdk_io_channel *ch1, *ch2; 1749 struct nvme_bdev_channel *nbdev_ch1, *nbdev_ch2; 1750 struct nvme_io_path *io_path1, *io_path2; 1751 struct nvme_ctrlr_channel *ctrlr_ch1, *ctrlr_ch2; 1752 int rc; 1753 1754 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 1755 ut_init_trid(&trid); 1756 1757 set_thread(0); 1758 1759 ctrlr = ut_attach_ctrlr(&trid, 1, false, false); 1760 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 1761 1762 g_ut_attach_ctrlr_status = 0; 1763 g_ut_attach_bdev_count = 1; 1764 1765 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 1766 attach_ctrlr_done, NULL, NULL, NULL, false); 1767 CU_ASSERT(rc == 0); 1768 1769 spdk_delay_us(1000); 1770 poll_threads(); 1771 1772 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1773 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1774 1775 bdev = nvme_ctrlr_get_ns(nvme_ctrlr, 1)->bdev; 1776 SPDK_CU_ASSERT_FATAL(bdev != NULL); 1777 1778 ch1 = spdk_get_io_channel(bdev); 1779 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 1780 1781 nbdev_ch1 = spdk_io_channel_get_ctx(ch1); 1782 io_path1 = STAILQ_FIRST(&nbdev_ch1->io_path_list); 1783 SPDK_CU_ASSERT_FATAL(io_path1 != NULL); 1784 ctrlr_ch1 = io_path1->qpair->ctrlr_ch; 1785 SPDK_CU_ASSERT_FATAL(ctrlr_ch1 != NULL); 1786 1787 first_bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_RESET, bdev, ch1); 1788 first_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_FAILED; 1789 1790 set_thread(1); 1791 1792 ch2 = spdk_get_io_channel(bdev); 1793 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 1794 1795 nbdev_ch2 = spdk_io_channel_get_ctx(ch2); 1796 io_path2 = STAILQ_FIRST(&nbdev_ch2->io_path_list); 1797 SPDK_CU_ASSERT_FATAL(io_path2 != NULL); 1798 ctrlr_ch2 = io_path2->qpair->ctrlr_ch; 1799 SPDK_CU_ASSERT_FATAL(ctrlr_ch2 != NULL); 1800 1801 second_bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_RESET, bdev, ch2); 1802 second_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_FAILED; 1803 1804 /* The first reset request is submitted on thread 1, and the second reset request 1805 * is submitted on thread 0 while processing the first request. 1806 */ 1807 bdev_nvme_submit_request(ch2, first_bdev_io); 1808 CU_ASSERT(nvme_ctrlr->resetting == true); 1809 CU_ASSERT(TAILQ_EMPTY(&ctrlr_ch2->pending_resets)); 1810 1811 set_thread(0); 1812 1813 bdev_nvme_submit_request(ch1, second_bdev_io); 1814 CU_ASSERT(TAILQ_FIRST(&ctrlr_ch1->pending_resets) == second_bdev_io); 1815 1816 poll_threads(); 1817 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1818 poll_threads(); 1819 1820 CU_ASSERT(nvme_ctrlr->resetting == false); 1821 CU_ASSERT(first_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1822 CU_ASSERT(second_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1823 1824 /* The first reset request is submitted on thread 1, and the second reset request 1825 * is submitted on thread 0 while processing the first request. 1826 * 1827 * The difference from the above scenario is that the controller is removed while 1828 * processing the first request. Hence both reset requests should fail. 1829 */ 1830 set_thread(1); 1831 1832 bdev_nvme_submit_request(ch2, first_bdev_io); 1833 CU_ASSERT(nvme_ctrlr->resetting == true); 1834 CU_ASSERT(TAILQ_EMPTY(&ctrlr_ch2->pending_resets)); 1835 1836 set_thread(0); 1837 1838 bdev_nvme_submit_request(ch1, second_bdev_io); 1839 CU_ASSERT(TAILQ_FIRST(&ctrlr_ch1->pending_resets) == second_bdev_io); 1840 1841 ctrlr->fail_reset = true; 1842 1843 poll_threads(); 1844 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 1845 poll_threads(); 1846 1847 CU_ASSERT(nvme_ctrlr->resetting == false); 1848 CU_ASSERT(first_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 1849 CU_ASSERT(second_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 1850 1851 spdk_put_io_channel(ch1); 1852 1853 set_thread(1); 1854 1855 spdk_put_io_channel(ch2); 1856 1857 poll_threads(); 1858 1859 set_thread(0); 1860 1861 rc = bdev_nvme_delete("nvme0", &g_any_path); 1862 CU_ASSERT(rc == 0); 1863 1864 poll_threads(); 1865 spdk_delay_us(1000); 1866 poll_threads(); 1867 1868 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1869 1870 free(first_bdev_io); 1871 free(second_bdev_io); 1872 } 1873 1874 static void 1875 test_attach_ctrlr(void) 1876 { 1877 struct spdk_nvme_transport_id trid = {}; 1878 struct spdk_nvme_ctrlr *ctrlr; 1879 struct nvme_ctrlr *nvme_ctrlr; 1880 const int STRING_SIZE = 32; 1881 const char *attached_names[STRING_SIZE]; 1882 struct nvme_bdev *nbdev; 1883 int rc; 1884 1885 set_thread(0); 1886 1887 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 1888 ut_init_trid(&trid); 1889 1890 /* If ctrlr fails, no nvme_ctrlr is created. Failed ctrlr is removed 1891 * by probe polling. 1892 */ 1893 ctrlr = ut_attach_ctrlr(&trid, 0, false, false); 1894 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 1895 1896 ctrlr->is_failed = true; 1897 g_ut_attach_ctrlr_status = -EIO; 1898 g_ut_attach_bdev_count = 0; 1899 1900 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 1901 attach_ctrlr_done, NULL, NULL, NULL, false); 1902 CU_ASSERT(rc == 0); 1903 1904 spdk_delay_us(1000); 1905 poll_threads(); 1906 1907 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1908 1909 /* If ctrlr has no namespace, one nvme_ctrlr with no namespace is created */ 1910 ctrlr = ut_attach_ctrlr(&trid, 0, false, false); 1911 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 1912 1913 g_ut_attach_ctrlr_status = 0; 1914 1915 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 1916 attach_ctrlr_done, NULL, NULL, NULL, false); 1917 CU_ASSERT(rc == 0); 1918 1919 spdk_delay_us(1000); 1920 poll_threads(); 1921 1922 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1923 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1924 CU_ASSERT(nvme_ctrlr->ctrlr == ctrlr); 1925 1926 rc = bdev_nvme_delete("nvme0", &g_any_path); 1927 CU_ASSERT(rc == 0); 1928 1929 poll_threads(); 1930 spdk_delay_us(1000); 1931 poll_threads(); 1932 1933 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1934 1935 /* If ctrlr has one namespace, one nvme_ctrlr with one namespace and 1936 * one nvme_bdev is created. 1937 */ 1938 ctrlr = ut_attach_ctrlr(&trid, 1, false, false); 1939 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 1940 1941 g_ut_attach_bdev_count = 1; 1942 1943 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 1944 attach_ctrlr_done, NULL, NULL, NULL, false); 1945 CU_ASSERT(rc == 0); 1946 1947 spdk_delay_us(1000); 1948 poll_threads(); 1949 1950 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1951 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1952 CU_ASSERT(nvme_ctrlr->ctrlr == ctrlr); 1953 1954 CU_ASSERT(attached_names[0] != NULL && strcmp(attached_names[0], "nvme0n1") == 0); 1955 attached_names[0] = NULL; 1956 1957 nbdev = nvme_ctrlr_get_ns(nvme_ctrlr, 1)->bdev; 1958 SPDK_CU_ASSERT_FATAL(nbdev != NULL); 1959 CU_ASSERT(bdev_nvme_get_ctrlr(&nbdev->disk) == ctrlr); 1960 1961 rc = bdev_nvme_delete("nvme0", &g_any_path); 1962 CU_ASSERT(rc == 0); 1963 1964 poll_threads(); 1965 spdk_delay_us(1000); 1966 poll_threads(); 1967 1968 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 1969 1970 /* Ctrlr has one namespace but one nvme_ctrlr with no namespace is 1971 * created because creating one nvme_bdev failed. 1972 */ 1973 ctrlr = ut_attach_ctrlr(&trid, 1, false, false); 1974 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 1975 1976 g_ut_register_bdev_status = -EINVAL; 1977 g_ut_attach_bdev_count = 0; 1978 1979 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 1980 attach_ctrlr_done, NULL, NULL, NULL, false); 1981 CU_ASSERT(rc == 0); 1982 1983 spdk_delay_us(1000); 1984 poll_threads(); 1985 1986 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 1987 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 1988 CU_ASSERT(nvme_ctrlr->ctrlr == ctrlr); 1989 1990 CU_ASSERT(attached_names[0] == NULL); 1991 1992 rc = bdev_nvme_delete("nvme0", &g_any_path); 1993 CU_ASSERT(rc == 0); 1994 1995 poll_threads(); 1996 spdk_delay_us(1000); 1997 poll_threads(); 1998 1999 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2000 2001 g_ut_register_bdev_status = 0; 2002 } 2003 2004 static void 2005 test_aer_cb(void) 2006 { 2007 struct spdk_nvme_transport_id trid = {}; 2008 struct spdk_nvme_ctrlr *ctrlr; 2009 struct nvme_ctrlr *nvme_ctrlr; 2010 struct nvme_bdev *bdev; 2011 const int STRING_SIZE = 32; 2012 const char *attached_names[STRING_SIZE]; 2013 union spdk_nvme_async_event_completion event = {}; 2014 struct spdk_nvme_cpl cpl = {}; 2015 int rc; 2016 2017 set_thread(0); 2018 2019 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 2020 ut_init_trid(&trid); 2021 2022 /* Attach a ctrlr, whose max number of namespaces is 4, and 2nd, 3rd, and 4th 2023 * namespaces are populated. 2024 */ 2025 ctrlr = ut_attach_ctrlr(&trid, 4, true, false); 2026 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 2027 2028 ctrlr->ns[0].is_active = false; 2029 2030 g_ut_attach_ctrlr_status = 0; 2031 g_ut_attach_bdev_count = 3; 2032 2033 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 2034 attach_ctrlr_done, NULL, NULL, NULL, false); 2035 CU_ASSERT(rc == 0); 2036 2037 spdk_delay_us(1000); 2038 poll_threads(); 2039 2040 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2041 poll_threads(); 2042 2043 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2044 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2045 2046 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 1) == NULL); 2047 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 2) != NULL); 2048 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 3) != NULL); 2049 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 4) != NULL); 2050 2051 bdev = nvme_ctrlr_get_ns(nvme_ctrlr, 4)->bdev; 2052 SPDK_CU_ASSERT_FATAL(bdev != NULL); 2053 CU_ASSERT(bdev->disk.blockcnt == 1024); 2054 2055 /* Dynamically populate 1st namespace and depopulate 3rd namespace, and 2056 * change the size of the 4th namespace. 2057 */ 2058 ctrlr->ns[0].is_active = true; 2059 ctrlr->ns[2].is_active = false; 2060 ctrlr->nsdata[3].nsze = 2048; 2061 2062 event.bits.async_event_type = SPDK_NVME_ASYNC_EVENT_TYPE_NOTICE; 2063 event.bits.async_event_info = SPDK_NVME_ASYNC_EVENT_NS_ATTR_CHANGED; 2064 cpl.cdw0 = event.raw; 2065 2066 aer_cb(nvme_ctrlr, &cpl); 2067 2068 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 1) != NULL); 2069 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 2) != NULL); 2070 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 3) == NULL); 2071 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 4) != NULL); 2072 CU_ASSERT(bdev->disk.blockcnt == 2048); 2073 2074 /* Change ANA state of active namespaces. */ 2075 ctrlr->ns[0].ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 2076 ctrlr->ns[1].ana_state = SPDK_NVME_ANA_INACCESSIBLE_STATE; 2077 ctrlr->ns[3].ana_state = SPDK_NVME_ANA_CHANGE_STATE; 2078 2079 event.bits.async_event_type = SPDK_NVME_ASYNC_EVENT_TYPE_NOTICE; 2080 event.bits.async_event_info = SPDK_NVME_ASYNC_EVENT_ANA_CHANGE; 2081 cpl.cdw0 = event.raw; 2082 2083 aer_cb(nvme_ctrlr, &cpl); 2084 2085 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2086 poll_threads(); 2087 2088 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 1)->ana_state == SPDK_NVME_ANA_NON_OPTIMIZED_STATE); 2089 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 2)->ana_state == SPDK_NVME_ANA_INACCESSIBLE_STATE); 2090 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 4)->ana_state == SPDK_NVME_ANA_CHANGE_STATE); 2091 2092 rc = bdev_nvme_delete("nvme0", &g_any_path); 2093 CU_ASSERT(rc == 0); 2094 2095 poll_threads(); 2096 spdk_delay_us(1000); 2097 poll_threads(); 2098 2099 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2100 } 2101 2102 static void 2103 ut_test_submit_nvme_cmd(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, 2104 enum spdk_bdev_io_type io_type) 2105 { 2106 struct nvme_bdev_channel *nbdev_ch = spdk_io_channel_get_ctx(ch); 2107 struct nvme_io_path *io_path; 2108 struct spdk_nvme_qpair *qpair; 2109 2110 io_path = bdev_nvme_find_io_path(nbdev_ch); 2111 SPDK_CU_ASSERT_FATAL(io_path != NULL); 2112 qpair = io_path->qpair->qpair; 2113 SPDK_CU_ASSERT_FATAL(qpair != NULL); 2114 2115 bdev_io->type = io_type; 2116 bdev_io->internal.in_submit_request = true; 2117 2118 bdev_nvme_submit_request(ch, bdev_io); 2119 2120 CU_ASSERT(bdev_io->internal.in_submit_request == true); 2121 CU_ASSERT(qpair->num_outstanding_reqs == 1); 2122 2123 poll_threads(); 2124 2125 CU_ASSERT(bdev_io->internal.in_submit_request == false); 2126 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 2127 CU_ASSERT(qpair->num_outstanding_reqs == 0); 2128 } 2129 2130 static void 2131 ut_test_submit_nop(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, 2132 enum spdk_bdev_io_type io_type) 2133 { 2134 struct nvme_bdev_channel *nbdev_ch = spdk_io_channel_get_ctx(ch); 2135 struct nvme_io_path *io_path; 2136 struct spdk_nvme_qpair *qpair; 2137 2138 io_path = bdev_nvme_find_io_path(nbdev_ch); 2139 SPDK_CU_ASSERT_FATAL(io_path != NULL); 2140 qpair = io_path->qpair->qpair; 2141 SPDK_CU_ASSERT_FATAL(qpair != NULL); 2142 2143 bdev_io->type = io_type; 2144 bdev_io->internal.in_submit_request = true; 2145 2146 bdev_nvme_submit_request(ch, bdev_io); 2147 2148 CU_ASSERT(bdev_io->internal.in_submit_request == false); 2149 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 2150 CU_ASSERT(qpair->num_outstanding_reqs == 0); 2151 } 2152 2153 static void 2154 ut_test_submit_fused_nvme_cmd(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io) 2155 { 2156 struct nvme_bdev_channel *nbdev_ch = spdk_io_channel_get_ctx(ch); 2157 struct nvme_bdev_io *bio = (struct nvme_bdev_io *)bdev_io->driver_ctx; 2158 struct ut_nvme_req *req; 2159 struct nvme_io_path *io_path; 2160 struct spdk_nvme_qpair *qpair; 2161 2162 io_path = bdev_nvme_find_io_path(nbdev_ch); 2163 SPDK_CU_ASSERT_FATAL(io_path != NULL); 2164 qpair = io_path->qpair->qpair; 2165 SPDK_CU_ASSERT_FATAL(qpair != NULL); 2166 2167 /* Only compare and write now. */ 2168 bdev_io->type = SPDK_BDEV_IO_TYPE_COMPARE_AND_WRITE; 2169 bdev_io->internal.in_submit_request = true; 2170 2171 bdev_nvme_submit_request(ch, bdev_io); 2172 2173 CU_ASSERT(bdev_io->internal.in_submit_request == true); 2174 CU_ASSERT(qpair->num_outstanding_reqs == 2); 2175 CU_ASSERT(bio->first_fused_submitted == true); 2176 2177 /* First outstanding request is compare operation. */ 2178 req = TAILQ_FIRST(&qpair->outstanding_reqs); 2179 SPDK_CU_ASSERT_FATAL(req != NULL); 2180 CU_ASSERT(req->opc == SPDK_NVME_OPC_COMPARE); 2181 req->cpl.cdw0 = SPDK_NVME_OPC_COMPARE; 2182 2183 poll_threads(); 2184 2185 CU_ASSERT(bdev_io->internal.in_submit_request == false); 2186 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 2187 CU_ASSERT(qpair->num_outstanding_reqs == 0); 2188 } 2189 2190 static void 2191 ut_test_submit_admin_cmd(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, 2192 struct spdk_nvme_ctrlr *ctrlr) 2193 { 2194 bdev_io->type = SPDK_BDEV_IO_TYPE_NVME_ADMIN; 2195 bdev_io->internal.in_submit_request = true; 2196 bdev_io->u.nvme_passthru.cmd.opc = SPDK_NVME_OPC_GET_FEATURES; 2197 2198 bdev_nvme_submit_request(ch, bdev_io); 2199 2200 CU_ASSERT(bdev_io->internal.in_submit_request == true); 2201 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 2202 2203 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2204 poll_thread_times(1, 1); 2205 2206 CU_ASSERT(bdev_io->internal.in_submit_request == true); 2207 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 2208 2209 poll_thread_times(0, 1); 2210 2211 CU_ASSERT(bdev_io->internal.in_submit_request == false); 2212 } 2213 2214 static void 2215 test_submit_nvme_cmd(void) 2216 { 2217 struct spdk_nvme_transport_id trid = {}; 2218 struct spdk_nvme_ctrlr *ctrlr; 2219 struct nvme_ctrlr *nvme_ctrlr; 2220 const int STRING_SIZE = 32; 2221 const char *attached_names[STRING_SIZE]; 2222 struct nvme_bdev *bdev; 2223 struct spdk_bdev_io *bdev_io; 2224 struct spdk_io_channel *ch; 2225 struct spdk_bdev_ext_io_opts ext_io_opts = {}; 2226 int rc; 2227 2228 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 2229 ut_init_trid(&trid); 2230 2231 set_thread(1); 2232 2233 ctrlr = ut_attach_ctrlr(&trid, 1, false, false); 2234 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 2235 2236 g_ut_attach_ctrlr_status = 0; 2237 g_ut_attach_bdev_count = 1; 2238 2239 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 2240 attach_ctrlr_done, NULL, NULL, NULL, false); 2241 CU_ASSERT(rc == 0); 2242 2243 spdk_delay_us(1000); 2244 poll_threads(); 2245 2246 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2247 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2248 2249 bdev = nvme_ctrlr_get_ns(nvme_ctrlr, 1)->bdev; 2250 SPDK_CU_ASSERT_FATAL(bdev != NULL); 2251 2252 set_thread(0); 2253 2254 ch = spdk_get_io_channel(bdev); 2255 SPDK_CU_ASSERT_FATAL(ch != NULL); 2256 2257 bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_INVALID, bdev, ch); 2258 2259 bdev_io->u.bdev.iovs = NULL; 2260 2261 ut_test_submit_nvme_cmd(ch, bdev_io, SPDK_BDEV_IO_TYPE_READ); 2262 2263 ut_bdev_io_set_buf(bdev_io); 2264 2265 ut_test_submit_nvme_cmd(ch, bdev_io, SPDK_BDEV_IO_TYPE_READ); 2266 ut_test_submit_nvme_cmd(ch, bdev_io, SPDK_BDEV_IO_TYPE_WRITE); 2267 ut_test_submit_nvme_cmd(ch, bdev_io, SPDK_BDEV_IO_TYPE_COMPARE); 2268 ut_test_submit_nvme_cmd(ch, bdev_io, SPDK_BDEV_IO_TYPE_UNMAP); 2269 2270 ut_test_submit_nop(ch, bdev_io, SPDK_BDEV_IO_TYPE_FLUSH); 2271 2272 ut_test_submit_fused_nvme_cmd(ch, bdev_io); 2273 2274 /* Verify that ext NVME API is called if bdev_io ext_opts is set */ 2275 bdev_io->u.bdev.ext_opts = &ext_io_opts; 2276 g_ut_readv_ext_called = false; 2277 ut_test_submit_nvme_cmd(ch, bdev_io, SPDK_BDEV_IO_TYPE_READ); 2278 CU_ASSERT(g_ut_readv_ext_called == true); 2279 g_ut_readv_ext_called = false; 2280 2281 g_ut_writev_ext_called = false; 2282 ut_test_submit_nvme_cmd(ch, bdev_io, SPDK_BDEV_IO_TYPE_WRITE); 2283 CU_ASSERT(g_ut_writev_ext_called == true); 2284 g_ut_writev_ext_called = false; 2285 bdev_io->u.bdev.ext_opts = NULL; 2286 2287 ut_test_submit_admin_cmd(ch, bdev_io, ctrlr); 2288 2289 free(bdev_io); 2290 2291 spdk_put_io_channel(ch); 2292 2293 poll_threads(); 2294 2295 set_thread(1); 2296 2297 rc = bdev_nvme_delete("nvme0", &g_any_path); 2298 CU_ASSERT(rc == 0); 2299 2300 poll_threads(); 2301 spdk_delay_us(1000); 2302 poll_threads(); 2303 2304 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2305 } 2306 2307 static void 2308 test_add_remove_trid(void) 2309 { 2310 struct nvme_path_id path1 = {}, path2 = {}, path3 = {}; 2311 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2, *ctrlr3; 2312 struct nvme_ctrlr *nvme_ctrlr = NULL; 2313 const int STRING_SIZE = 32; 2314 const char *attached_names[STRING_SIZE]; 2315 struct nvme_path_id *ctrid; 2316 int rc; 2317 2318 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 2319 ut_init_trid(&path1.trid); 2320 ut_init_trid2(&path2.trid); 2321 ut_init_trid3(&path3.trid); 2322 2323 set_thread(0); 2324 2325 g_ut_attach_ctrlr_status = 0; 2326 g_ut_attach_bdev_count = 0; 2327 2328 ctrlr1 = ut_attach_ctrlr(&path1.trid, 0, false, false); 2329 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 2330 2331 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 2332 attach_ctrlr_done, NULL, NULL, NULL, false); 2333 CU_ASSERT(rc == 0); 2334 2335 spdk_delay_us(1000); 2336 poll_threads(); 2337 2338 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2339 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2340 2341 CU_ASSERT(spdk_nvme_transport_id_compare(&nvme_ctrlr->active_path_id->trid, &path1.trid) == 0); 2342 2343 ctrlr2 = ut_attach_ctrlr(&path2.trid, 0, false, false); 2344 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 2345 2346 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 2347 attach_ctrlr_done, NULL, NULL, NULL, false); 2348 CU_ASSERT(rc == 0); 2349 2350 spdk_delay_us(1000); 2351 poll_threads(); 2352 2353 CU_ASSERT(spdk_nvme_transport_id_compare(&nvme_ctrlr->active_path_id->trid, &path1.trid) == 0); 2354 TAILQ_FOREACH(ctrid, &nvme_ctrlr->trids, link) { 2355 if (spdk_nvme_transport_id_compare(&ctrid->trid, &path2.trid) == 0) { 2356 break; 2357 } 2358 } 2359 CU_ASSERT(ctrid != NULL); 2360 2361 /* trid3 is not in the registered list. */ 2362 rc = bdev_nvme_delete("nvme0", &path3); 2363 CU_ASSERT(rc == -ENXIO); 2364 2365 /* trid2 is not used, and simply removed. */ 2366 rc = bdev_nvme_delete("nvme0", &path2); 2367 CU_ASSERT(rc == 0); 2368 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == nvme_ctrlr); 2369 TAILQ_FOREACH(ctrid, &nvme_ctrlr->trids, link) { 2370 CU_ASSERT(spdk_nvme_transport_id_compare(&ctrid->trid, &path2.trid) != 0); 2371 } 2372 2373 ctrlr3 = ut_attach_ctrlr(&path3.trid, 0, false, false); 2374 SPDK_CU_ASSERT_FATAL(ctrlr3 != NULL); 2375 2376 rc = bdev_nvme_create(&path3.trid, "nvme0", attached_names, STRING_SIZE, 2377 attach_ctrlr_done, NULL, NULL, NULL, false); 2378 CU_ASSERT(rc == 0); 2379 2380 spdk_delay_us(1000); 2381 poll_threads(); 2382 2383 CU_ASSERT(spdk_nvme_transport_id_compare(&nvme_ctrlr->active_path_id->trid, &path1.trid) == 0); 2384 TAILQ_FOREACH(ctrid, &nvme_ctrlr->trids, link) { 2385 if (spdk_nvme_transport_id_compare(&ctrid->trid, &path3.trid) == 0) { 2386 break; 2387 } 2388 } 2389 CU_ASSERT(ctrid != NULL); 2390 2391 /* path1 is currently used and path3 is an alternative path. 2392 * If we remove path1, path is changed to path3. 2393 */ 2394 rc = bdev_nvme_delete("nvme0", &path1); 2395 CU_ASSERT(rc == 0); 2396 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == nvme_ctrlr); 2397 CU_ASSERT(nvme_ctrlr->resetting == true); 2398 TAILQ_FOREACH(ctrid, &nvme_ctrlr->trids, link) { 2399 CU_ASSERT(spdk_nvme_transport_id_compare(&ctrid->trid, &path1.trid) != 0); 2400 } 2401 CU_ASSERT(spdk_nvme_transport_id_compare(&nvme_ctrlr->active_path_id->trid, &path3.trid) == 0); 2402 2403 poll_threads(); 2404 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2405 poll_threads(); 2406 2407 CU_ASSERT(nvme_ctrlr->resetting == false); 2408 2409 /* path3 is the current and only path. If we remove path3, the corresponding 2410 * nvme_ctrlr is removed. 2411 */ 2412 rc = bdev_nvme_delete("nvme0", &path3); 2413 CU_ASSERT(rc == 0); 2414 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == nvme_ctrlr); 2415 2416 poll_threads(); 2417 spdk_delay_us(1000); 2418 poll_threads(); 2419 2420 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2421 2422 ctrlr1 = ut_attach_ctrlr(&path1.trid, 0, false, false); 2423 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 2424 2425 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 2426 attach_ctrlr_done, NULL, NULL, NULL, false); 2427 CU_ASSERT(rc == 0); 2428 2429 spdk_delay_us(1000); 2430 poll_threads(); 2431 2432 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2433 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2434 2435 CU_ASSERT(spdk_nvme_transport_id_compare(&nvme_ctrlr->active_path_id->trid, &path1.trid) == 0); 2436 2437 ctrlr2 = ut_attach_ctrlr(&path2.trid, 0, false, false); 2438 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 2439 2440 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 2441 attach_ctrlr_done, NULL, NULL, NULL, false); 2442 CU_ASSERT(rc == 0); 2443 2444 spdk_delay_us(1000); 2445 poll_threads(); 2446 2447 CU_ASSERT(spdk_nvme_transport_id_compare(&nvme_ctrlr->active_path_id->trid, &path1.trid) == 0); 2448 TAILQ_FOREACH(ctrid, &nvme_ctrlr->trids, link) { 2449 if (spdk_nvme_transport_id_compare(&ctrid->trid, &path2.trid) == 0) { 2450 break; 2451 } 2452 } 2453 CU_ASSERT(ctrid != NULL); 2454 2455 /* If trid is not specified, nvme_ctrlr itself is removed. */ 2456 rc = bdev_nvme_delete("nvme0", &g_any_path); 2457 CU_ASSERT(rc == 0); 2458 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == nvme_ctrlr); 2459 2460 poll_threads(); 2461 spdk_delay_us(1000); 2462 poll_threads(); 2463 2464 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2465 } 2466 2467 static void 2468 test_abort(void) 2469 { 2470 struct spdk_nvme_transport_id trid = {}; 2471 struct nvme_ctrlr_opts opts = {}; 2472 struct spdk_nvme_ctrlr *ctrlr; 2473 struct nvme_ctrlr *nvme_ctrlr; 2474 const int STRING_SIZE = 32; 2475 const char *attached_names[STRING_SIZE]; 2476 struct nvme_bdev *bdev; 2477 struct spdk_bdev_io *write_io, *admin_io, *abort_io; 2478 struct spdk_io_channel *ch1, *ch2; 2479 struct nvme_bdev_channel *nbdev_ch1; 2480 struct nvme_io_path *io_path1; 2481 struct nvme_qpair *nvme_qpair1; 2482 int rc; 2483 2484 /* Create ctrlr on thread 1 and submit I/O and admin requests to be aborted on 2485 * thread 0. Aborting I/O requests are submitted on thread 0. Aborting admin requests 2486 * are submitted on thread 1. Both should succeed. 2487 */ 2488 2489 ut_init_trid(&trid); 2490 2491 ctrlr = ut_attach_ctrlr(&trid, 1, false, false); 2492 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 2493 2494 g_ut_attach_ctrlr_status = 0; 2495 g_ut_attach_bdev_count = 1; 2496 2497 set_thread(1); 2498 2499 opts.ctrlr_loss_timeout_sec = -1; 2500 opts.reconnect_delay_sec = 1; 2501 2502 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 2503 attach_ctrlr_done, NULL, NULL, &opts, false); 2504 CU_ASSERT(rc == 0); 2505 2506 spdk_delay_us(1000); 2507 poll_threads(); 2508 2509 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2510 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2511 2512 bdev = nvme_ctrlr_get_ns(nvme_ctrlr, 1)->bdev; 2513 SPDK_CU_ASSERT_FATAL(bdev != NULL); 2514 2515 write_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, NULL); 2516 ut_bdev_io_set_buf(write_io); 2517 2518 admin_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_NVME_ADMIN, bdev, NULL); 2519 admin_io->u.nvme_passthru.cmd.opc = SPDK_NVME_OPC_GET_FEATURES; 2520 2521 abort_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_ABORT, bdev, NULL); 2522 2523 set_thread(0); 2524 2525 ch1 = spdk_get_io_channel(bdev); 2526 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 2527 nbdev_ch1 = spdk_io_channel_get_ctx(ch1); 2528 io_path1 = STAILQ_FIRST(&nbdev_ch1->io_path_list); 2529 SPDK_CU_ASSERT_FATAL(io_path1 != NULL); 2530 nvme_qpair1 = io_path1->qpair; 2531 SPDK_CU_ASSERT_FATAL(nvme_qpair1 != NULL); 2532 2533 set_thread(1); 2534 2535 ch2 = spdk_get_io_channel(bdev); 2536 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 2537 2538 write_io->internal.ch = (struct spdk_bdev_channel *)ch1; 2539 abort_io->internal.ch = (struct spdk_bdev_channel *)ch1; 2540 2541 /* Aborting the already completed request should fail. */ 2542 write_io->internal.in_submit_request = true; 2543 bdev_nvme_submit_request(ch1, write_io); 2544 poll_threads(); 2545 2546 CU_ASSERT(write_io->internal.in_submit_request == false); 2547 2548 abort_io->u.abort.bio_to_abort = write_io; 2549 abort_io->internal.in_submit_request = true; 2550 2551 bdev_nvme_submit_request(ch1, abort_io); 2552 2553 poll_threads(); 2554 2555 CU_ASSERT(abort_io->internal.in_submit_request == false); 2556 CU_ASSERT(abort_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 2557 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 2558 2559 admin_io->internal.ch = (struct spdk_bdev_channel *)ch1; 2560 abort_io->internal.ch = (struct spdk_bdev_channel *)ch2; 2561 2562 admin_io->internal.in_submit_request = true; 2563 bdev_nvme_submit_request(ch1, admin_io); 2564 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2565 poll_threads(); 2566 2567 CU_ASSERT(admin_io->internal.in_submit_request == false); 2568 2569 abort_io->u.abort.bio_to_abort = admin_io; 2570 abort_io->internal.in_submit_request = true; 2571 2572 bdev_nvme_submit_request(ch2, abort_io); 2573 2574 poll_threads(); 2575 2576 CU_ASSERT(abort_io->internal.in_submit_request == false); 2577 CU_ASSERT(abort_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 2578 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 2579 2580 /* Aborting the write request should succeed. */ 2581 write_io->internal.in_submit_request = true; 2582 bdev_nvme_submit_request(ch1, write_io); 2583 2584 CU_ASSERT(write_io->internal.in_submit_request == true); 2585 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 1); 2586 2587 abort_io->internal.ch = (struct spdk_bdev_channel *)ch1; 2588 abort_io->u.abort.bio_to_abort = write_io; 2589 abort_io->internal.in_submit_request = true; 2590 2591 bdev_nvme_submit_request(ch1, abort_io); 2592 2593 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2594 poll_threads(); 2595 2596 CU_ASSERT(abort_io->internal.in_submit_request == false); 2597 CU_ASSERT(abort_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 2598 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 2599 CU_ASSERT(write_io->internal.in_submit_request == false); 2600 CU_ASSERT(write_io->internal.status == SPDK_BDEV_IO_STATUS_ABORTED); 2601 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 0); 2602 2603 /* Aborting the admin request should succeed. */ 2604 admin_io->internal.in_submit_request = true; 2605 bdev_nvme_submit_request(ch1, admin_io); 2606 2607 CU_ASSERT(admin_io->internal.in_submit_request == true); 2608 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 2609 2610 abort_io->internal.ch = (struct spdk_bdev_channel *)ch2; 2611 abort_io->u.abort.bio_to_abort = admin_io; 2612 abort_io->internal.in_submit_request = true; 2613 2614 bdev_nvme_submit_request(ch2, abort_io); 2615 2616 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2617 poll_threads(); 2618 2619 CU_ASSERT(abort_io->internal.in_submit_request == false); 2620 CU_ASSERT(abort_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 2621 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 2622 CU_ASSERT(admin_io->internal.in_submit_request == false); 2623 CU_ASSERT(admin_io->internal.status == SPDK_BDEV_IO_STATUS_ABORTED); 2624 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 2625 2626 set_thread(0); 2627 2628 /* If qpair is disconnected, it is freed and then reconnected via resetting 2629 * the corresponding nvme_ctrlr. I/O should be queued if it is submitted 2630 * while resetting the nvme_ctrlr. 2631 */ 2632 nvme_qpair1->qpair->failure_reason = SPDK_NVME_QPAIR_FAILURE_UNKNOWN; 2633 2634 poll_thread_times(0, 3); 2635 2636 CU_ASSERT(nvme_qpair1->qpair == NULL); 2637 CU_ASSERT(nvme_ctrlr->resetting == true); 2638 2639 write_io->internal.in_submit_request = true; 2640 2641 bdev_nvme_submit_request(ch1, write_io); 2642 2643 CU_ASSERT(write_io->internal.in_submit_request == true); 2644 CU_ASSERT(write_io == TAILQ_FIRST(&nbdev_ch1->retry_io_list)); 2645 2646 /* Aborting the queued write request should succeed immediately. */ 2647 abort_io->internal.ch = (struct spdk_bdev_channel *)ch1; 2648 abort_io->u.abort.bio_to_abort = write_io; 2649 abort_io->internal.in_submit_request = true; 2650 2651 bdev_nvme_submit_request(ch1, abort_io); 2652 2653 CU_ASSERT(abort_io->internal.in_submit_request == false); 2654 CU_ASSERT(abort_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 2655 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 2656 CU_ASSERT(write_io->internal.in_submit_request == false); 2657 CU_ASSERT(write_io->internal.status == SPDK_BDEV_IO_STATUS_ABORTED); 2658 2659 poll_threads(); 2660 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2661 poll_threads(); 2662 2663 spdk_put_io_channel(ch1); 2664 2665 set_thread(1); 2666 2667 spdk_put_io_channel(ch2); 2668 2669 poll_threads(); 2670 2671 free(write_io); 2672 free(admin_io); 2673 free(abort_io); 2674 2675 set_thread(1); 2676 2677 rc = bdev_nvme_delete("nvme0", &g_any_path); 2678 CU_ASSERT(rc == 0); 2679 2680 poll_threads(); 2681 spdk_delay_us(1000); 2682 poll_threads(); 2683 2684 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2685 } 2686 2687 static void 2688 test_get_io_qpair(void) 2689 { 2690 struct spdk_nvme_transport_id trid = {}; 2691 struct spdk_nvme_ctrlr ctrlr = {}; 2692 struct nvme_ctrlr *nvme_ctrlr = NULL; 2693 struct spdk_io_channel *ch; 2694 struct nvme_ctrlr_channel *ctrlr_ch; 2695 struct spdk_nvme_qpair *qpair; 2696 int rc; 2697 2698 ut_init_trid(&trid); 2699 TAILQ_INIT(&ctrlr.active_io_qpairs); 2700 2701 set_thread(0); 2702 2703 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid, NULL); 2704 CU_ASSERT(rc == 0); 2705 2706 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2707 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2708 2709 ch = spdk_get_io_channel(nvme_ctrlr); 2710 SPDK_CU_ASSERT_FATAL(ch != NULL); 2711 ctrlr_ch = spdk_io_channel_get_ctx(ch); 2712 CU_ASSERT(ctrlr_ch->qpair->qpair != NULL); 2713 2714 qpair = bdev_nvme_get_io_qpair(ch); 2715 CU_ASSERT(qpair == ctrlr_ch->qpair->qpair); 2716 2717 spdk_put_io_channel(ch); 2718 2719 rc = bdev_nvme_delete("nvme0", &g_any_path); 2720 CU_ASSERT(rc == 0); 2721 2722 poll_threads(); 2723 spdk_delay_us(1000); 2724 poll_threads(); 2725 2726 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2727 } 2728 2729 /* Test a scenario that the bdev subsystem starts shutdown when there still exists 2730 * any NVMe bdev. In this scenario, spdk_bdev_unregister() is called first. Add a 2731 * test case to avoid regression for this scenario. spdk_bdev_unregister() calls 2732 * bdev_nvme_destruct() in the end, and so call bdev_nvme_destruct() directly. 2733 */ 2734 static void 2735 test_bdev_unregister(void) 2736 { 2737 struct spdk_nvme_transport_id trid = {}; 2738 struct spdk_nvme_ctrlr *ctrlr; 2739 struct nvme_ctrlr *nvme_ctrlr; 2740 struct nvme_ns *nvme_ns1, *nvme_ns2; 2741 const int STRING_SIZE = 32; 2742 const char *attached_names[STRING_SIZE]; 2743 struct nvme_bdev *bdev1, *bdev2; 2744 int rc; 2745 2746 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 2747 ut_init_trid(&trid); 2748 2749 ctrlr = ut_attach_ctrlr(&trid, 2, false, false); 2750 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 2751 2752 g_ut_attach_ctrlr_status = 0; 2753 g_ut_attach_bdev_count = 2; 2754 2755 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 2756 attach_ctrlr_done, NULL, NULL, NULL, false); 2757 CU_ASSERT(rc == 0); 2758 2759 spdk_delay_us(1000); 2760 poll_threads(); 2761 2762 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2763 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2764 2765 nvme_ns1 = nvme_ctrlr_get_ns(nvme_ctrlr, 1); 2766 SPDK_CU_ASSERT_FATAL(nvme_ns1 != NULL); 2767 2768 bdev1 = nvme_ns1->bdev; 2769 SPDK_CU_ASSERT_FATAL(bdev1 != NULL); 2770 2771 nvme_ns2 = nvme_ctrlr_get_ns(nvme_ctrlr, 2); 2772 SPDK_CU_ASSERT_FATAL(nvme_ns2 != NULL); 2773 2774 bdev2 = nvme_ns2->bdev; 2775 SPDK_CU_ASSERT_FATAL(bdev2 != NULL); 2776 2777 bdev_nvme_destruct(&bdev1->disk); 2778 bdev_nvme_destruct(&bdev2->disk); 2779 2780 poll_threads(); 2781 2782 CU_ASSERT(nvme_ns1->bdev == NULL); 2783 CU_ASSERT(nvme_ns2->bdev == NULL); 2784 2785 nvme_ctrlr->destruct = true; 2786 _nvme_ctrlr_destruct(nvme_ctrlr); 2787 2788 poll_threads(); 2789 spdk_delay_us(1000); 2790 poll_threads(); 2791 2792 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2793 } 2794 2795 static void 2796 test_compare_ns(void) 2797 { 2798 struct spdk_nvme_ns_data nsdata1 = {}, nsdata2 = {}; 2799 struct spdk_nvme_ctrlr ctrlr1 = { .nsdata = &nsdata1, }, ctrlr2 = { .nsdata = &nsdata2, }; 2800 struct spdk_nvme_ns ns1 = { .id = 1, .ctrlr = &ctrlr1, }, ns2 = { .id = 1, .ctrlr = &ctrlr2, }; 2801 struct spdk_uuid uuid1 = { .u.raw = { 0xAA } }; 2802 struct spdk_uuid uuid2 = { .u.raw = { 0xAB } }; 2803 2804 /* No IDs are defined. */ 2805 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == true); 2806 2807 /* Only EUI64 are defined and not matched. */ 2808 nsdata1.eui64 = 0xABCDEF0123456789; 2809 nsdata2.eui64 = 0xBBCDEF0123456789; 2810 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == false); 2811 2812 /* Only EUI64 are defined and matched. */ 2813 nsdata2.eui64 = 0xABCDEF0123456789; 2814 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == true); 2815 2816 /* Only NGUID are defined and not matched. */ 2817 nsdata1.eui64 = 0x0; 2818 nsdata2.eui64 = 0x0; 2819 nsdata1.nguid[0] = 0x12; 2820 nsdata2.nguid[0] = 0x10; 2821 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == false); 2822 2823 /* Only NGUID are defined and matched. */ 2824 nsdata2.nguid[0] = 0x12; 2825 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == true); 2826 2827 /* Only UUID are defined and not matched. */ 2828 nsdata1.nguid[0] = 0x0; 2829 nsdata2.nguid[0] = 0x0; 2830 ns1.uuid = &uuid1; 2831 ns2.uuid = &uuid2; 2832 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == false); 2833 2834 /* Only one UUID is defined. */ 2835 ns1.uuid = NULL; 2836 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == false); 2837 2838 /* Only UUID are defined and matched. */ 2839 ns1.uuid = &uuid2; 2840 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == true); 2841 2842 /* All EUI64, NGUID, and UUID are defined and matched. */ 2843 nsdata1.eui64 = 0x123456789ABCDEF; 2844 nsdata2.eui64 = 0x123456789ABCDEF; 2845 nsdata1.nguid[15] = 0x34; 2846 nsdata2.nguid[15] = 0x34; 2847 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == true); 2848 2849 /* CSI are not matched. */ 2850 ns1.csi = SPDK_NVME_CSI_ZNS; 2851 CU_ASSERT(bdev_nvme_compare_ns(&ns1, &ns2) == false); 2852 } 2853 2854 static void 2855 test_init_ana_log_page(void) 2856 { 2857 struct spdk_nvme_transport_id trid = {}; 2858 struct spdk_nvme_ctrlr *ctrlr; 2859 struct nvme_ctrlr *nvme_ctrlr; 2860 const int STRING_SIZE = 32; 2861 const char *attached_names[STRING_SIZE]; 2862 int rc; 2863 2864 set_thread(0); 2865 2866 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 2867 ut_init_trid(&trid); 2868 2869 ctrlr = ut_attach_ctrlr(&trid, 5, true, false); 2870 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 2871 2872 ctrlr->ns[0].ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 2873 ctrlr->ns[1].ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 2874 ctrlr->ns[2].ana_state = SPDK_NVME_ANA_INACCESSIBLE_STATE; 2875 ctrlr->ns[3].ana_state = SPDK_NVME_ANA_PERSISTENT_LOSS_STATE; 2876 ctrlr->ns[4].ana_state = SPDK_NVME_ANA_CHANGE_STATE; 2877 2878 g_ut_attach_ctrlr_status = 0; 2879 g_ut_attach_bdev_count = 5; 2880 2881 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 2882 attach_ctrlr_done, NULL, NULL, NULL, false); 2883 CU_ASSERT(rc == 0); 2884 2885 spdk_delay_us(1000); 2886 poll_threads(); 2887 2888 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 2889 poll_threads(); 2890 2891 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2892 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2893 2894 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 1) != NULL); 2895 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 2) != NULL); 2896 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 3) != NULL); 2897 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 4) != NULL); 2898 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 5) != NULL); 2899 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 1)->ana_state == SPDK_NVME_ANA_OPTIMIZED_STATE); 2900 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 2)->ana_state == SPDK_NVME_ANA_NON_OPTIMIZED_STATE); 2901 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 3)->ana_state == SPDK_NVME_ANA_INACCESSIBLE_STATE); 2902 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 4)->ana_state == SPDK_NVME_ANA_PERSISTENT_LOSS_STATE); 2903 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 5)->ana_state == SPDK_NVME_ANA_CHANGE_STATE); 2904 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 1)->bdev != NULL); 2905 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 2)->bdev != NULL); 2906 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 3)->bdev != NULL); 2907 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 4)->bdev != NULL); 2908 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr, 5)->bdev != NULL); 2909 2910 rc = bdev_nvme_delete("nvme0", &g_any_path); 2911 CU_ASSERT(rc == 0); 2912 2913 poll_threads(); 2914 spdk_delay_us(1000); 2915 poll_threads(); 2916 2917 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 2918 } 2919 2920 static void 2921 init_accel(void) 2922 { 2923 spdk_io_device_register(g_accel_p, accel_engine_create_cb, accel_engine_destroy_cb, 2924 sizeof(int), "accel_p"); 2925 } 2926 2927 static void 2928 fini_accel(void) 2929 { 2930 spdk_io_device_unregister(g_accel_p, NULL); 2931 } 2932 2933 static void 2934 test_get_memory_domains(void) 2935 { 2936 struct nvme_ctrlr ctrlr = { .ctrlr = (struct spdk_nvme_ctrlr *) 0xbaadbeef }; 2937 struct nvme_ns ns = { .ctrlr = &ctrlr }; 2938 struct nvme_bdev nbdev = { .nvme_ns_list = TAILQ_HEAD_INITIALIZER(nbdev.nvme_ns_list) }; 2939 struct spdk_memory_domain *domains[2] = {}; 2940 int rc = 0; 2941 2942 TAILQ_INSERT_TAIL(&nbdev.nvme_ns_list, &ns, tailq); 2943 2944 /* nvme controller doesn't have memory domainы */ 2945 MOCK_SET(spdk_nvme_ctrlr_get_memory_domain, 0); 2946 rc = bdev_nvme_get_memory_domains(&nbdev, domains, 2); 2947 CU_ASSERT(rc == 0) 2948 2949 /* nvme controller has a memory domain */ 2950 MOCK_SET(spdk_nvme_ctrlr_get_memory_domain, 1); 2951 rc = bdev_nvme_get_memory_domains(&nbdev, domains, 2); 2952 CU_ASSERT(rc == 1); 2953 MOCK_CLEAR(spdk_nvme_ctrlr_get_memory_domain); 2954 } 2955 2956 static void 2957 test_reconnect_qpair(void) 2958 { 2959 struct spdk_nvme_transport_id trid = {}; 2960 struct spdk_nvme_ctrlr *ctrlr; 2961 struct nvme_ctrlr *nvme_ctrlr; 2962 const int STRING_SIZE = 32; 2963 const char *attached_names[STRING_SIZE]; 2964 struct nvme_bdev *bdev; 2965 struct spdk_io_channel *ch1, *ch2; 2966 struct nvme_bdev_channel *nbdev_ch1, *nbdev_ch2; 2967 struct nvme_io_path *io_path1, *io_path2; 2968 struct nvme_qpair *nvme_qpair1, *nvme_qpair2; 2969 int rc; 2970 2971 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 2972 ut_init_trid(&trid); 2973 2974 set_thread(0); 2975 2976 ctrlr = ut_attach_ctrlr(&trid, 1, false, false); 2977 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 2978 2979 g_ut_attach_ctrlr_status = 0; 2980 g_ut_attach_bdev_count = 1; 2981 2982 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 2983 attach_ctrlr_done, NULL, NULL, NULL, false); 2984 CU_ASSERT(rc == 0); 2985 2986 spdk_delay_us(1000); 2987 poll_threads(); 2988 2989 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 2990 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 2991 2992 bdev = nvme_ctrlr_get_ns(nvme_ctrlr, 1)->bdev; 2993 SPDK_CU_ASSERT_FATAL(bdev != NULL); 2994 2995 ch1 = spdk_get_io_channel(bdev); 2996 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 2997 2998 nbdev_ch1 = spdk_io_channel_get_ctx(ch1); 2999 io_path1 = STAILQ_FIRST(&nbdev_ch1->io_path_list); 3000 SPDK_CU_ASSERT_FATAL(io_path1 != NULL); 3001 nvme_qpair1 = io_path1->qpair; 3002 SPDK_CU_ASSERT_FATAL(nvme_qpair1 != NULL); 3003 3004 set_thread(1); 3005 3006 ch2 = spdk_get_io_channel(bdev); 3007 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 3008 3009 nbdev_ch2 = spdk_io_channel_get_ctx(ch2); 3010 io_path2 = STAILQ_FIRST(&nbdev_ch2->io_path_list); 3011 SPDK_CU_ASSERT_FATAL(io_path2 != NULL); 3012 nvme_qpair2 = io_path2->qpair; 3013 SPDK_CU_ASSERT_FATAL(nvme_qpair2 != NULL); 3014 3015 /* If a qpair is disconnected, it is freed and then reconnected via 3016 * resetting the corresponding nvme_ctrlr. 3017 */ 3018 nvme_qpair2->qpair->failure_reason = SPDK_NVME_QPAIR_FAILURE_UNKNOWN; 3019 ctrlr->is_failed = true; 3020 3021 poll_thread_times(1, 3); 3022 CU_ASSERT(nvme_qpair1->qpair != NULL); 3023 CU_ASSERT(nvme_qpair2->qpair == NULL); 3024 CU_ASSERT(nvme_ctrlr->resetting == true); 3025 3026 poll_thread_times(0, 3); 3027 CU_ASSERT(nvme_qpair1->qpair == NULL); 3028 CU_ASSERT(nvme_qpair2->qpair == NULL); 3029 CU_ASSERT(ctrlr->is_failed == true); 3030 3031 poll_thread_times(1, 2); 3032 poll_thread_times(0, 1); 3033 CU_ASSERT(ctrlr->is_failed == false); 3034 CU_ASSERT(ctrlr->adminq.is_connected == false); 3035 3036 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3037 poll_thread_times(0, 2); 3038 CU_ASSERT(ctrlr->adminq.is_connected == true); 3039 3040 poll_thread_times(0, 1); 3041 poll_thread_times(1, 1); 3042 CU_ASSERT(nvme_qpair1->qpair != NULL); 3043 CU_ASSERT(nvme_qpair2->qpair != NULL); 3044 CU_ASSERT(nvme_ctrlr->resetting == true); 3045 3046 poll_thread_times(0, 2); 3047 poll_thread_times(1, 1); 3048 poll_thread_times(0, 1); 3049 CU_ASSERT(nvme_ctrlr->resetting == false); 3050 3051 poll_threads(); 3052 3053 /* If a qpair is disconnected and resetting the corresponding nvme_ctrlr 3054 * fails, the qpair is just freed. 3055 */ 3056 nvme_qpair2->qpair->failure_reason = SPDK_NVME_QPAIR_FAILURE_UNKNOWN; 3057 ctrlr->is_failed = true; 3058 ctrlr->fail_reset = true; 3059 3060 poll_thread_times(1, 3); 3061 CU_ASSERT(nvme_qpair1->qpair != NULL); 3062 CU_ASSERT(nvme_qpair2->qpair == NULL); 3063 CU_ASSERT(nvme_ctrlr->resetting == true); 3064 3065 poll_thread_times(0, 3); 3066 poll_thread_times(1, 1); 3067 CU_ASSERT(nvme_qpair1->qpair == NULL); 3068 CU_ASSERT(nvme_qpair2->qpair == NULL); 3069 CU_ASSERT(ctrlr->is_failed == true); 3070 3071 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3072 poll_thread_times(0, 3); 3073 poll_thread_times(1, 1); 3074 poll_thread_times(0, 1); 3075 CU_ASSERT(ctrlr->is_failed == true); 3076 CU_ASSERT(nvme_ctrlr->resetting == false); 3077 CU_ASSERT(nvme_qpair1->qpair == NULL); 3078 CU_ASSERT(nvme_qpair2->qpair == NULL); 3079 3080 poll_threads(); 3081 3082 spdk_put_io_channel(ch2); 3083 3084 set_thread(0); 3085 3086 spdk_put_io_channel(ch1); 3087 3088 poll_threads(); 3089 3090 rc = bdev_nvme_delete("nvme0", &g_any_path); 3091 CU_ASSERT(rc == 0); 3092 3093 poll_threads(); 3094 spdk_delay_us(1000); 3095 poll_threads(); 3096 3097 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 3098 } 3099 3100 static void 3101 test_create_bdev_ctrlr(void) 3102 { 3103 struct nvme_path_id path1 = {}, path2 = {}; 3104 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2; 3105 struct nvme_bdev_ctrlr *nbdev_ctrlr; 3106 const int STRING_SIZE = 32; 3107 const char *attached_names[STRING_SIZE]; 3108 int rc; 3109 3110 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 3111 ut_init_trid(&path1.trid); 3112 ut_init_trid2(&path2.trid); 3113 3114 ctrlr1 = ut_attach_ctrlr(&path1.trid, 0, true, true); 3115 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 3116 3117 g_ut_attach_ctrlr_status = 0; 3118 g_ut_attach_bdev_count = 0; 3119 3120 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 3121 attach_ctrlr_done, NULL, NULL, NULL, true); 3122 CU_ASSERT(rc == 0); 3123 3124 spdk_delay_us(1000); 3125 poll_threads(); 3126 3127 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3128 poll_threads(); 3129 3130 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 3131 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 3132 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid) != NULL); 3133 3134 /* cntlid is duplicated, and adding the second ctrlr should fail. */ 3135 g_ut_attach_ctrlr_status = -EINVAL; 3136 3137 ctrlr2 = ut_attach_ctrlr(&path2.trid, 0, true, true); 3138 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3139 3140 ctrlr2->cdata.cntlid = ctrlr1->cdata.cntlid; 3141 3142 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 3143 attach_ctrlr_done, NULL, NULL, NULL, true); 3144 CU_ASSERT(rc == 0); 3145 3146 spdk_delay_us(1000); 3147 poll_threads(); 3148 3149 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3150 poll_threads(); 3151 3152 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) == NULL); 3153 3154 /* cntlid is not duplicated, and adding the third ctrlr should succeed. */ 3155 g_ut_attach_ctrlr_status = 0; 3156 3157 ctrlr2 = ut_attach_ctrlr(&path2.trid, 0, true, true); 3158 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3159 3160 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 3161 attach_ctrlr_done, NULL, NULL, NULL, true); 3162 CU_ASSERT(rc == 0); 3163 3164 spdk_delay_us(1000); 3165 poll_threads(); 3166 3167 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3168 poll_threads(); 3169 3170 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) != NULL); 3171 3172 /* Delete two ctrlrs at once. */ 3173 rc = bdev_nvme_delete("nvme0", &g_any_path); 3174 CU_ASSERT(rc == 0); 3175 3176 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == nbdev_ctrlr); 3177 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid) != NULL); 3178 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) != NULL); 3179 3180 poll_threads(); 3181 spdk_delay_us(1000); 3182 poll_threads(); 3183 3184 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 3185 3186 /* Add two ctrlrs and delete one by one. */ 3187 ctrlr1 = ut_attach_ctrlr(&path1.trid, 0, true, true); 3188 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 3189 3190 ctrlr2 = ut_attach_ctrlr(&path2.trid, 0, true, true); 3191 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3192 3193 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 3194 attach_ctrlr_done, NULL, NULL, NULL, true); 3195 CU_ASSERT(rc == 0); 3196 3197 spdk_delay_us(1000); 3198 poll_threads(); 3199 3200 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3201 poll_threads(); 3202 3203 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 3204 attach_ctrlr_done, NULL, NULL, NULL, true); 3205 CU_ASSERT(rc == 0); 3206 3207 spdk_delay_us(1000); 3208 poll_threads(); 3209 3210 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3211 poll_threads(); 3212 3213 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 3214 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 3215 3216 rc = bdev_nvme_delete("nvme0", &path1); 3217 CU_ASSERT(rc == 0); 3218 3219 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == nbdev_ctrlr); 3220 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid) != NULL); 3221 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) != NULL); 3222 3223 poll_threads(); 3224 spdk_delay_us(1000); 3225 poll_threads(); 3226 3227 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == nbdev_ctrlr); 3228 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid) == NULL); 3229 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) != NULL); 3230 3231 rc = bdev_nvme_delete("nvme0", &path2); 3232 CU_ASSERT(rc == 0); 3233 3234 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == nbdev_ctrlr); 3235 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid) == NULL); 3236 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) != NULL); 3237 3238 poll_threads(); 3239 spdk_delay_us(1000); 3240 poll_threads(); 3241 3242 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 3243 } 3244 3245 static struct nvme_ns * 3246 _nvme_bdev_get_ns(struct nvme_bdev *bdev, struct nvme_ctrlr *nvme_ctrlr) 3247 { 3248 struct nvme_ns *nvme_ns; 3249 3250 TAILQ_FOREACH(nvme_ns, &bdev->nvme_ns_list, tailq) { 3251 if (nvme_ns->ctrlr == nvme_ctrlr) { 3252 return nvme_ns; 3253 } 3254 } 3255 3256 return NULL; 3257 } 3258 3259 static void 3260 test_add_multi_ns_to_bdev(void) 3261 { 3262 struct nvme_path_id path1 = {}, path2 = {}; 3263 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2; 3264 struct nvme_ctrlr *nvme_ctrlr1, *nvme_ctrlr2; 3265 struct nvme_bdev_ctrlr *nbdev_ctrlr; 3266 struct nvme_ns *nvme_ns1, *nvme_ns2; 3267 struct nvme_bdev *bdev1, *bdev2, *bdev3, *bdev4; 3268 const int STRING_SIZE = 32; 3269 const char *attached_names[STRING_SIZE]; 3270 struct spdk_uuid uuid1 = { .u.raw = { 0x1 } }; 3271 struct spdk_uuid uuid2 = { .u.raw = { 0x2 } }; 3272 struct spdk_uuid uuid3 = { .u.raw = { 0x3 } }; 3273 struct spdk_uuid uuid4 = { .u.raw = { 0x4 } }; 3274 struct spdk_uuid uuid44 = { .u.raw = { 0x44 } }; 3275 int rc; 3276 3277 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 3278 ut_init_trid(&path1.trid); 3279 ut_init_trid2(&path2.trid); 3280 3281 /* Create nvme_bdevs, some of which have shared namespaces between two ctrlrs. */ 3282 3283 /* Attach 1st ctrlr, whose max number of namespaces is 5, and 1st, 3rd, and 4th 3284 * namespaces are populated. 3285 */ 3286 ctrlr1 = ut_attach_ctrlr(&path1.trid, 5, true, true); 3287 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 3288 3289 ctrlr1->ns[1].is_active = false; 3290 ctrlr1->ns[4].is_active = false; 3291 ctrlr1->ns[0].uuid = &uuid1; 3292 ctrlr1->ns[2].uuid = &uuid3; 3293 ctrlr1->ns[3].uuid = &uuid4; 3294 3295 g_ut_attach_ctrlr_status = 0; 3296 g_ut_attach_bdev_count = 3; 3297 3298 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, 32, 3299 attach_ctrlr_done, NULL, NULL, NULL, true); 3300 CU_ASSERT(rc == 0); 3301 3302 spdk_delay_us(1000); 3303 poll_threads(); 3304 3305 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3306 poll_threads(); 3307 3308 /* Attach 2nd ctrlr, whose max number of namespaces is 5, and 1st, 2nd, and 4th 3309 * namespaces are populated. The uuid of 4th namespace is different, and hence 3310 * adding 4th namespace to a bdev should fail. 3311 */ 3312 ctrlr2 = ut_attach_ctrlr(&path2.trid, 5, true, true); 3313 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3314 3315 ctrlr2->ns[2].is_active = false; 3316 ctrlr2->ns[4].is_active = false; 3317 ctrlr2->ns[0].uuid = &uuid1; 3318 ctrlr2->ns[1].uuid = &uuid2; 3319 ctrlr2->ns[3].uuid = &uuid44; 3320 3321 g_ut_attach_ctrlr_status = 0; 3322 g_ut_attach_bdev_count = 2; 3323 3324 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, 32, 3325 attach_ctrlr_done, NULL, NULL, NULL, true); 3326 CU_ASSERT(rc == 0); 3327 3328 spdk_delay_us(1000); 3329 poll_threads(); 3330 3331 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3332 poll_threads(); 3333 3334 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 3335 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 3336 3337 nvme_ctrlr1 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid); 3338 SPDK_CU_ASSERT_FATAL(nvme_ctrlr1 != NULL); 3339 3340 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr1, 1) != NULL); 3341 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr1, 2) == NULL); 3342 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr1, 3) != NULL); 3343 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr1, 4) != NULL); 3344 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr1, 5) == NULL); 3345 3346 nvme_ctrlr2 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid); 3347 SPDK_CU_ASSERT_FATAL(nvme_ctrlr2 != NULL); 3348 3349 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr2, 1) != NULL); 3350 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr2, 2) != NULL); 3351 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr2, 3) == NULL); 3352 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr2, 4) == NULL); 3353 CU_ASSERT(nvme_ctrlr_get_ns(nvme_ctrlr2, 5) == NULL); 3354 3355 bdev1 = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 3356 SPDK_CU_ASSERT_FATAL(bdev1 != NULL); 3357 bdev2 = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 2); 3358 SPDK_CU_ASSERT_FATAL(bdev2 != NULL); 3359 bdev3 = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 3); 3360 SPDK_CU_ASSERT_FATAL(bdev3 != NULL); 3361 bdev4 = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 4); 3362 SPDK_CU_ASSERT_FATAL(bdev4 != NULL); 3363 CU_ASSERT(nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 5) == NULL); 3364 3365 CU_ASSERT(bdev1->ref == 2); 3366 CU_ASSERT(bdev2->ref == 1); 3367 CU_ASSERT(bdev3->ref == 1); 3368 CU_ASSERT(bdev4->ref == 1); 3369 3370 /* Test if nvme_bdevs can be deleted by deleting ctrlr one by one. */ 3371 rc = bdev_nvme_delete("nvme0", &path1); 3372 CU_ASSERT(rc == 0); 3373 3374 poll_threads(); 3375 spdk_delay_us(1000); 3376 poll_threads(); 3377 3378 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == nbdev_ctrlr); 3379 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid) == NULL); 3380 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) == nvme_ctrlr2); 3381 3382 rc = bdev_nvme_delete("nvme0", &path2); 3383 CU_ASSERT(rc == 0); 3384 3385 poll_threads(); 3386 spdk_delay_us(1000); 3387 poll_threads(); 3388 3389 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 3390 3391 /* Test if a nvme_bdev which has a shared namespace between two ctrlrs 3392 * can be deleted when the bdev subsystem shutdown. 3393 */ 3394 g_ut_attach_bdev_count = 1; 3395 3396 ctrlr1 = ut_attach_ctrlr(&path1.trid, 1, true, true); 3397 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 3398 3399 ctrlr1->ns[0].uuid = &uuid1; 3400 3401 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, 32, 3402 attach_ctrlr_done, NULL, NULL, NULL, true); 3403 CU_ASSERT(rc == 0); 3404 3405 spdk_delay_us(1000); 3406 poll_threads(); 3407 3408 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3409 poll_threads(); 3410 3411 ut_init_trid2(&path2.trid); 3412 3413 ctrlr2 = ut_attach_ctrlr(&path2.trid, 1, true, true); 3414 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3415 3416 ctrlr2->ns[0].uuid = &uuid1; 3417 3418 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, 32, 3419 attach_ctrlr_done, NULL, NULL, NULL, true); 3420 CU_ASSERT(rc == 0); 3421 3422 spdk_delay_us(1000); 3423 poll_threads(); 3424 3425 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3426 poll_threads(); 3427 3428 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 3429 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 3430 3431 bdev1 = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 3432 SPDK_CU_ASSERT_FATAL(bdev1 != NULL); 3433 3434 nvme_ctrlr1 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid); 3435 SPDK_CU_ASSERT_FATAL(nvme_ctrlr1 != NULL); 3436 3437 nvme_ctrlr2 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid); 3438 SPDK_CU_ASSERT_FATAL(nvme_ctrlr2 != NULL); 3439 3440 /* Check if a nvme_bdev has two nvme_ns. */ 3441 nvme_ns1 = _nvme_bdev_get_ns(bdev1, nvme_ctrlr1); 3442 SPDK_CU_ASSERT_FATAL(nvme_ns1 != NULL); 3443 CU_ASSERT(nvme_ns1->bdev == bdev1); 3444 3445 nvme_ns2 = _nvme_bdev_get_ns(bdev1, nvme_ctrlr2); 3446 SPDK_CU_ASSERT_FATAL(nvme_ns2 != NULL); 3447 CU_ASSERT(nvme_ns2->bdev == bdev1); 3448 3449 /* Delete nvme_bdev first when the bdev subsystem shutdown. */ 3450 bdev_nvme_destruct(&bdev1->disk); 3451 3452 poll_threads(); 3453 3454 CU_ASSERT(nvme_ns1->bdev == NULL); 3455 CU_ASSERT(nvme_ns2->bdev == NULL); 3456 3457 nvme_ctrlr1->destruct = true; 3458 _nvme_ctrlr_destruct(nvme_ctrlr1); 3459 3460 poll_threads(); 3461 spdk_delay_us(1000); 3462 poll_threads(); 3463 3464 nvme_ctrlr2->destruct = true; 3465 _nvme_ctrlr_destruct(nvme_ctrlr2); 3466 3467 poll_threads(); 3468 spdk_delay_us(1000); 3469 poll_threads(); 3470 3471 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 3472 } 3473 3474 static void 3475 test_add_multi_io_paths_to_nbdev_ch(void) 3476 { 3477 struct nvme_path_id path1 = {}, path2 = {}, path3 = {}; 3478 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2, *ctrlr3; 3479 struct nvme_bdev_ctrlr *nbdev_ctrlr; 3480 struct nvme_ctrlr *nvme_ctrlr1, *nvme_ctrlr2, *nvme_ctrlr3; 3481 struct nvme_ns *nvme_ns1, *nvme_ns2, *nvme_ns3; 3482 const int STRING_SIZE = 32; 3483 const char *attached_names[STRING_SIZE]; 3484 struct nvme_bdev *bdev; 3485 struct spdk_io_channel *ch; 3486 struct nvme_bdev_channel *nbdev_ch; 3487 struct nvme_io_path *io_path1, *io_path2, *io_path3; 3488 struct spdk_uuid uuid1 = { .u.raw = { 0x1 } }; 3489 int rc; 3490 3491 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 3492 ut_init_trid(&path1.trid); 3493 ut_init_trid2(&path2.trid); 3494 ut_init_trid3(&path3.trid); 3495 g_ut_attach_ctrlr_status = 0; 3496 g_ut_attach_bdev_count = 1; 3497 3498 set_thread(1); 3499 3500 ctrlr1 = ut_attach_ctrlr(&path1.trid, 1, true, true); 3501 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 3502 3503 ctrlr1->ns[0].uuid = &uuid1; 3504 3505 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 3506 attach_ctrlr_done, NULL, NULL, NULL, true); 3507 CU_ASSERT(rc == 0); 3508 3509 spdk_delay_us(1000); 3510 poll_threads(); 3511 3512 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3513 poll_threads(); 3514 3515 ctrlr2 = ut_attach_ctrlr(&path2.trid, 1, true, true); 3516 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3517 3518 ctrlr2->ns[0].uuid = &uuid1; 3519 3520 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 3521 attach_ctrlr_done, NULL, NULL, NULL, true); 3522 CU_ASSERT(rc == 0); 3523 3524 spdk_delay_us(1000); 3525 poll_threads(); 3526 3527 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3528 poll_threads(); 3529 3530 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 3531 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 3532 3533 nvme_ctrlr1 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid); 3534 SPDK_CU_ASSERT_FATAL(nvme_ctrlr1 != NULL); 3535 3536 nvme_ctrlr2 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid); 3537 SPDK_CU_ASSERT_FATAL(nvme_ctrlr2 != NULL); 3538 3539 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 3540 SPDK_CU_ASSERT_FATAL(bdev != NULL); 3541 3542 nvme_ns1 = _nvme_bdev_get_ns(bdev, nvme_ctrlr1); 3543 SPDK_CU_ASSERT_FATAL(nvme_ns1 != NULL); 3544 3545 nvme_ns2 = _nvme_bdev_get_ns(bdev, nvme_ctrlr2); 3546 SPDK_CU_ASSERT_FATAL(nvme_ns2 != NULL); 3547 3548 set_thread(0); 3549 3550 ch = spdk_get_io_channel(bdev); 3551 SPDK_CU_ASSERT_FATAL(ch != NULL); 3552 nbdev_ch = spdk_io_channel_get_ctx(ch); 3553 3554 io_path1 = _bdev_nvme_get_io_path(nbdev_ch, nvme_ns1); 3555 SPDK_CU_ASSERT_FATAL(io_path1 != NULL); 3556 3557 io_path2 = _bdev_nvme_get_io_path(nbdev_ch, nvme_ns2); 3558 SPDK_CU_ASSERT_FATAL(io_path2 != NULL); 3559 3560 set_thread(1); 3561 3562 /* Check if I/O path is dynamically added to nvme_bdev_channel. */ 3563 ctrlr3 = ut_attach_ctrlr(&path3.trid, 1, true, true); 3564 SPDK_CU_ASSERT_FATAL(ctrlr3 != NULL); 3565 3566 ctrlr3->ns[0].uuid = &uuid1; 3567 3568 rc = bdev_nvme_create(&path3.trid, "nvme0", attached_names, STRING_SIZE, 3569 attach_ctrlr_done, NULL, NULL, NULL, true); 3570 CU_ASSERT(rc == 0); 3571 3572 spdk_delay_us(1000); 3573 poll_threads(); 3574 3575 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3576 poll_threads(); 3577 3578 nvme_ctrlr3 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path3.trid); 3579 SPDK_CU_ASSERT_FATAL(nvme_ctrlr3 != NULL); 3580 3581 nvme_ns3 = _nvme_bdev_get_ns(bdev, nvme_ctrlr3); 3582 SPDK_CU_ASSERT_FATAL(nvme_ns3 != NULL); 3583 3584 io_path3 = _bdev_nvme_get_io_path(nbdev_ch, nvme_ns3); 3585 SPDK_CU_ASSERT_FATAL(io_path3 != NULL); 3586 3587 /* Check if I/O path is dynamically deleted from nvme_bdev_channel. */ 3588 rc = bdev_nvme_delete("nvme0", &path2); 3589 CU_ASSERT(rc == 0); 3590 3591 poll_threads(); 3592 spdk_delay_us(1000); 3593 poll_threads(); 3594 3595 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid) == nvme_ctrlr1); 3596 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid) == NULL); 3597 CU_ASSERT(nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path3.trid) == nvme_ctrlr3); 3598 3599 CU_ASSERT(_bdev_nvme_get_io_path(nbdev_ch, nvme_ns1) == io_path1); 3600 CU_ASSERT(_bdev_nvme_get_io_path(nbdev_ch, nvme_ns2) == NULL); 3601 CU_ASSERT(_bdev_nvme_get_io_path(nbdev_ch, nvme_ns3) == io_path3); 3602 3603 set_thread(0); 3604 3605 spdk_put_io_channel(ch); 3606 3607 poll_threads(); 3608 3609 set_thread(1); 3610 3611 rc = bdev_nvme_delete("nvme0", &g_any_path); 3612 CU_ASSERT(rc == 0); 3613 3614 poll_threads(); 3615 spdk_delay_us(1000); 3616 poll_threads(); 3617 3618 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 3619 } 3620 3621 static void 3622 test_admin_path(void) 3623 { 3624 struct nvme_path_id path1 = {}, path2 = {}; 3625 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2; 3626 struct nvme_bdev_ctrlr *nbdev_ctrlr; 3627 const int STRING_SIZE = 32; 3628 const char *attached_names[STRING_SIZE]; 3629 struct nvme_bdev *bdev; 3630 struct spdk_io_channel *ch; 3631 struct spdk_bdev_io *bdev_io; 3632 struct spdk_uuid uuid1 = { .u.raw = { 0x1 } }; 3633 int rc; 3634 3635 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 3636 ut_init_trid(&path1.trid); 3637 ut_init_trid2(&path2.trid); 3638 g_ut_attach_ctrlr_status = 0; 3639 g_ut_attach_bdev_count = 1; 3640 3641 set_thread(0); 3642 3643 ctrlr1 = ut_attach_ctrlr(&path1.trid, 1, true, true); 3644 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 3645 3646 ctrlr1->ns[0].uuid = &uuid1; 3647 3648 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 3649 attach_ctrlr_done, NULL, NULL, NULL, true); 3650 CU_ASSERT(rc == 0); 3651 3652 spdk_delay_us(1000); 3653 poll_threads(); 3654 3655 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3656 poll_threads(); 3657 3658 ctrlr2 = ut_attach_ctrlr(&path2.trid, 1, true, true); 3659 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3660 3661 ctrlr2->ns[0].uuid = &uuid1; 3662 3663 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 3664 attach_ctrlr_done, NULL, NULL, NULL, true); 3665 CU_ASSERT(rc == 0); 3666 3667 spdk_delay_us(1000); 3668 poll_threads(); 3669 3670 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3671 poll_threads(); 3672 3673 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 3674 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 3675 3676 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 3677 SPDK_CU_ASSERT_FATAL(bdev != NULL); 3678 3679 ch = spdk_get_io_channel(bdev); 3680 SPDK_CU_ASSERT_FATAL(ch != NULL); 3681 3682 bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_NVME_ADMIN, bdev, ch); 3683 bdev_io->u.nvme_passthru.cmd.opc = SPDK_NVME_OPC_GET_FEATURES; 3684 3685 /* ctrlr1 is failed but ctrlr2 is not failed. admin command is 3686 * submitted to ctrlr2. 3687 */ 3688 ctrlr1->is_failed = true; 3689 bdev_io->internal.in_submit_request = true; 3690 3691 bdev_nvme_submit_request(ch, bdev_io); 3692 3693 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 0); 3694 CU_ASSERT(ctrlr2->adminq.num_outstanding_reqs == 1); 3695 CU_ASSERT(bdev_io->internal.in_submit_request == true); 3696 3697 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3698 poll_threads(); 3699 3700 CU_ASSERT(ctrlr2->adminq.num_outstanding_reqs == 0); 3701 CU_ASSERT(bdev_io->internal.in_submit_request == false); 3702 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 3703 3704 /* both ctrlr1 and ctrlr2 are failed. admin command is failed to submit. */ 3705 ctrlr2->is_failed = true; 3706 bdev_io->internal.in_submit_request = true; 3707 3708 bdev_nvme_submit_request(ch, bdev_io); 3709 3710 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 0); 3711 CU_ASSERT(ctrlr2->adminq.num_outstanding_reqs == 0); 3712 CU_ASSERT(bdev_io->internal.in_submit_request == false); 3713 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 3714 3715 free(bdev_io); 3716 3717 spdk_put_io_channel(ch); 3718 3719 poll_threads(); 3720 3721 rc = bdev_nvme_delete("nvme0", &g_any_path); 3722 CU_ASSERT(rc == 0); 3723 3724 poll_threads(); 3725 spdk_delay_us(1000); 3726 poll_threads(); 3727 3728 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 3729 } 3730 3731 static struct nvme_io_path * 3732 ut_get_io_path_by_ctrlr(struct nvme_bdev_channel *nbdev_ch, 3733 struct nvme_ctrlr *nvme_ctrlr) 3734 { 3735 struct nvme_io_path *io_path; 3736 3737 STAILQ_FOREACH(io_path, &nbdev_ch->io_path_list, stailq) { 3738 if (io_path->qpair->ctrlr == nvme_ctrlr) { 3739 return io_path; 3740 } 3741 } 3742 3743 return NULL; 3744 } 3745 3746 static void 3747 test_reset_bdev_ctrlr(void) 3748 { 3749 struct nvme_path_id path1 = {}, path2 = {}; 3750 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2; 3751 struct nvme_bdev_ctrlr *nbdev_ctrlr; 3752 struct nvme_ctrlr *nvme_ctrlr1, *nvme_ctrlr2; 3753 struct nvme_path_id *curr_path1, *curr_path2; 3754 const int STRING_SIZE = 32; 3755 const char *attached_names[STRING_SIZE]; 3756 struct nvme_bdev *bdev; 3757 struct spdk_bdev_io *first_bdev_io, *second_bdev_io; 3758 struct nvme_bdev_io *first_bio; 3759 struct spdk_io_channel *ch1, *ch2; 3760 struct nvme_bdev_channel *nbdev_ch1, *nbdev_ch2; 3761 struct nvme_io_path *io_path11, *io_path12, *io_path21, *io_path22; 3762 int rc; 3763 3764 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 3765 ut_init_trid(&path1.trid); 3766 ut_init_trid2(&path2.trid); 3767 g_ut_attach_ctrlr_status = 0; 3768 g_ut_attach_bdev_count = 1; 3769 3770 set_thread(0); 3771 3772 ctrlr1 = ut_attach_ctrlr(&path1.trid, 1, true, true); 3773 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 3774 3775 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 3776 attach_ctrlr_done, NULL, NULL, NULL, true); 3777 CU_ASSERT(rc == 0); 3778 3779 spdk_delay_us(1000); 3780 poll_threads(); 3781 3782 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3783 poll_threads(); 3784 3785 ctrlr2 = ut_attach_ctrlr(&path2.trid, 1, true, true); 3786 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 3787 3788 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 3789 attach_ctrlr_done, NULL, NULL, NULL, true); 3790 CU_ASSERT(rc == 0); 3791 3792 spdk_delay_us(1000); 3793 poll_threads(); 3794 3795 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3796 poll_threads(); 3797 3798 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 3799 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 3800 3801 nvme_ctrlr1 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid); 3802 SPDK_CU_ASSERT_FATAL(nvme_ctrlr1 != NULL); 3803 3804 curr_path1 = TAILQ_FIRST(&nvme_ctrlr1->trids); 3805 SPDK_CU_ASSERT_FATAL(curr_path1 != NULL); 3806 3807 nvme_ctrlr2 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid); 3808 SPDK_CU_ASSERT_FATAL(nvme_ctrlr2 != NULL); 3809 3810 curr_path2 = TAILQ_FIRST(&nvme_ctrlr2->trids); 3811 SPDK_CU_ASSERT_FATAL(curr_path2 != NULL); 3812 3813 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 3814 SPDK_CU_ASSERT_FATAL(bdev != NULL); 3815 3816 set_thread(0); 3817 3818 ch1 = spdk_get_io_channel(bdev); 3819 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 3820 3821 nbdev_ch1 = spdk_io_channel_get_ctx(ch1); 3822 io_path11 = ut_get_io_path_by_ctrlr(nbdev_ch1, nvme_ctrlr1); 3823 SPDK_CU_ASSERT_FATAL(io_path11 != NULL); 3824 io_path12 = ut_get_io_path_by_ctrlr(nbdev_ch1, nvme_ctrlr2); 3825 SPDK_CU_ASSERT_FATAL(io_path12 != NULL); 3826 3827 first_bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_RESET, bdev, ch1); 3828 first_bio = (struct nvme_bdev_io *)first_bdev_io->driver_ctx; 3829 3830 set_thread(1); 3831 3832 ch2 = spdk_get_io_channel(bdev); 3833 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 3834 3835 nbdev_ch2 = spdk_io_channel_get_ctx(ch2); 3836 io_path21 = ut_get_io_path_by_ctrlr(nbdev_ch2, nvme_ctrlr1); 3837 SPDK_CU_ASSERT_FATAL(io_path21 != NULL); 3838 io_path22 = ut_get_io_path_by_ctrlr(nbdev_ch2, nvme_ctrlr2); 3839 SPDK_CU_ASSERT_FATAL(io_path22 != NULL); 3840 3841 second_bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_RESET, bdev, ch2); 3842 3843 /* The first reset request from bdev_io is submitted on thread 0. 3844 * Check if ctrlr1 is reset and then ctrlr2 is reset. 3845 * 3846 * A few extra polls are necessary after resetting ctrlr1 to check 3847 * pending reset requests for ctrlr1. 3848 */ 3849 ctrlr1->is_failed = true; 3850 curr_path1->is_failed = true; 3851 ctrlr2->is_failed = true; 3852 curr_path2->is_failed = true; 3853 3854 set_thread(0); 3855 3856 bdev_nvme_submit_request(ch1, first_bdev_io); 3857 CU_ASSERT(first_bio->io_path == io_path11); 3858 CU_ASSERT(nvme_ctrlr1->resetting == true); 3859 CU_ASSERT(nvme_ctrlr1->reset_cb_arg == first_bio); 3860 3861 poll_thread_times(0, 3); 3862 CU_ASSERT(io_path11->qpair->qpair == NULL); 3863 CU_ASSERT(io_path21->qpair->qpair != NULL); 3864 3865 poll_thread_times(1, 2); 3866 CU_ASSERT(io_path11->qpair->qpair == NULL); 3867 CU_ASSERT(io_path21->qpair->qpair == NULL); 3868 CU_ASSERT(ctrlr1->is_failed == true); 3869 3870 poll_thread_times(0, 1); 3871 CU_ASSERT(nvme_ctrlr1->resetting == true); 3872 CU_ASSERT(ctrlr1->is_failed == false); 3873 CU_ASSERT(ctrlr1->adminq.is_connected == false); 3874 CU_ASSERT(curr_path1->is_failed == true); 3875 3876 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3877 poll_thread_times(0, 2); 3878 CU_ASSERT(ctrlr1->adminq.is_connected == true); 3879 3880 poll_thread_times(0, 1); 3881 CU_ASSERT(io_path11->qpair->qpair != NULL); 3882 CU_ASSERT(io_path21->qpair->qpair == NULL); 3883 3884 poll_thread_times(1, 1); 3885 CU_ASSERT(io_path11->qpair->qpair != NULL); 3886 CU_ASSERT(io_path21->qpair->qpair != NULL); 3887 3888 poll_thread_times(0, 2); 3889 CU_ASSERT(nvme_ctrlr1->resetting == true); 3890 poll_thread_times(1, 1); 3891 CU_ASSERT(nvme_ctrlr1->resetting == true); 3892 poll_thread_times(0, 2); 3893 CU_ASSERT(nvme_ctrlr1->resetting == false); 3894 CU_ASSERT(curr_path1->is_failed == false); 3895 CU_ASSERT(first_bio->io_path == io_path12); 3896 CU_ASSERT(nvme_ctrlr2->resetting == true); 3897 3898 poll_thread_times(0, 3); 3899 CU_ASSERT(io_path12->qpair->qpair == NULL); 3900 CU_ASSERT(io_path22->qpair->qpair != NULL); 3901 3902 poll_thread_times(1, 2); 3903 CU_ASSERT(io_path12->qpair->qpair == NULL); 3904 CU_ASSERT(io_path22->qpair->qpair == NULL); 3905 CU_ASSERT(ctrlr2->is_failed == true); 3906 3907 poll_thread_times(0, 2); 3908 CU_ASSERT(nvme_ctrlr2->resetting == true); 3909 CU_ASSERT(ctrlr2->is_failed == false); 3910 CU_ASSERT(ctrlr2->adminq.is_connected == false); 3911 CU_ASSERT(curr_path2->is_failed == true); 3912 3913 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3914 poll_thread_times(0, 2); 3915 CU_ASSERT(ctrlr2->adminq.is_connected == true); 3916 3917 poll_thread_times(0, 1); 3918 CU_ASSERT(io_path12->qpair->qpair != NULL); 3919 CU_ASSERT(io_path22->qpair->qpair == NULL); 3920 3921 poll_thread_times(1, 2); 3922 CU_ASSERT(io_path12->qpair->qpair != NULL); 3923 CU_ASSERT(io_path22->qpair->qpair != NULL); 3924 3925 poll_thread_times(0, 2); 3926 CU_ASSERT(nvme_ctrlr2->resetting == true); 3927 poll_thread_times(1, 1); 3928 CU_ASSERT(nvme_ctrlr2->resetting == true); 3929 poll_thread_times(0, 2); 3930 CU_ASSERT(first_bio->io_path == NULL); 3931 CU_ASSERT(nvme_ctrlr2->resetting == false); 3932 CU_ASSERT(curr_path2->is_failed == false); 3933 3934 poll_threads(); 3935 3936 /* There is a race between two reset requests from bdev_io. 3937 * 3938 * The first reset request is submitted on thread 0, and the second reset 3939 * request is submitted on thread 1 while the first is resetting ctrlr1. 3940 * The second is pending on ctrlr1. After the first completes resetting ctrlr1, 3941 * both reset requests go to ctrlr2. The first comes earlier than the second. 3942 * The second is pending on ctrlr2 again. After the first completes resetting 3943 * ctrl2, both complete successfully. 3944 */ 3945 ctrlr1->is_failed = true; 3946 curr_path1->is_failed = true; 3947 ctrlr2->is_failed = true; 3948 curr_path2->is_failed = true; 3949 first_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_FAILED; 3950 second_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_FAILED; 3951 3952 set_thread(0); 3953 3954 bdev_nvme_submit_request(ch1, first_bdev_io); 3955 3956 set_thread(1); 3957 3958 bdev_nvme_submit_request(ch2, second_bdev_io); 3959 3960 CU_ASSERT(nvme_ctrlr1->resetting == true); 3961 CU_ASSERT(nvme_ctrlr1->reset_cb_arg == first_bio); 3962 CU_ASSERT(TAILQ_FIRST(&io_path21->qpair->ctrlr_ch->pending_resets) == second_bdev_io); 3963 3964 poll_threads(); 3965 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3966 poll_threads(); 3967 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 3968 poll_threads(); 3969 3970 CU_ASSERT(ctrlr1->is_failed == false); 3971 CU_ASSERT(curr_path1->is_failed == false); 3972 CU_ASSERT(ctrlr2->is_failed == false); 3973 CU_ASSERT(curr_path2->is_failed == false); 3974 CU_ASSERT(first_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 3975 CU_ASSERT(second_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 3976 3977 set_thread(0); 3978 3979 spdk_put_io_channel(ch1); 3980 3981 set_thread(1); 3982 3983 spdk_put_io_channel(ch2); 3984 3985 poll_threads(); 3986 3987 set_thread(0); 3988 3989 rc = bdev_nvme_delete("nvme0", &g_any_path); 3990 CU_ASSERT(rc == 0); 3991 3992 poll_threads(); 3993 spdk_delay_us(1000); 3994 poll_threads(); 3995 3996 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 3997 3998 free(first_bdev_io); 3999 free(second_bdev_io); 4000 } 4001 4002 static void 4003 test_find_io_path(void) 4004 { 4005 struct nvme_bdev_channel nbdev_ch = { 4006 .io_path_list = STAILQ_HEAD_INITIALIZER(nbdev_ch.io_path_list), 4007 }; 4008 struct spdk_nvme_qpair qpair1 = {}, qpair2 = {}; 4009 struct spdk_nvme_ctrlr ctrlr1 = {}, ctrlr2 = {}; 4010 struct nvme_ctrlr nvme_ctrlr1 = { .ctrlr = &ctrlr1, }, nvme_ctrlr2 = { .ctrlr = &ctrlr2, }; 4011 struct nvme_ctrlr_channel ctrlr_ch1 = {}, ctrlr_ch2 = {}; 4012 struct nvme_qpair nvme_qpair1 = { .ctrlr_ch = &ctrlr_ch1, .ctrlr = &nvme_ctrlr1, }; 4013 struct nvme_qpair nvme_qpair2 = { .ctrlr_ch = &ctrlr_ch2, .ctrlr = &nvme_ctrlr2, }; 4014 struct nvme_ns nvme_ns1 = {}, nvme_ns2 = {}; 4015 struct nvme_io_path io_path1 = { .qpair = &nvme_qpair1, .nvme_ns = &nvme_ns1, }; 4016 struct nvme_io_path io_path2 = { .qpair = &nvme_qpair2, .nvme_ns = &nvme_ns2, }; 4017 4018 STAILQ_INSERT_TAIL(&nbdev_ch.io_path_list, &io_path1, stailq); 4019 4020 /* Test if io_path whose ANA state is not accessible is excluded. */ 4021 4022 nvme_qpair1.qpair = &qpair1; 4023 nvme_ns1.ana_state = SPDK_NVME_ANA_INACCESSIBLE_STATE; 4024 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == NULL); 4025 4026 nvme_ns1.ana_state = SPDK_NVME_ANA_PERSISTENT_LOSS_STATE; 4027 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == NULL); 4028 4029 nvme_ns1.ana_state = SPDK_NVME_ANA_CHANGE_STATE; 4030 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == NULL); 4031 4032 nvme_ns1.ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 4033 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path1); 4034 4035 nbdev_ch.current_io_path = NULL; 4036 4037 nvme_ns1.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 4038 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path1); 4039 4040 nbdev_ch.current_io_path = NULL; 4041 4042 /* Test if io_path whose qpair is resetting is excluded. */ 4043 4044 nvme_qpair1.qpair = NULL; 4045 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == NULL); 4046 4047 STAILQ_INSERT_TAIL(&nbdev_ch.io_path_list, &io_path2, stailq); 4048 4049 /* Test if ANA optimized state or the first found ANA non-optimized state 4050 * is prioritized. 4051 */ 4052 4053 nvme_qpair1.qpair = &qpair1; 4054 nvme_ns1.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 4055 nvme_qpair2.qpair = &qpair2; 4056 nvme_ns2.ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 4057 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path2); 4058 4059 nbdev_ch.current_io_path = NULL; 4060 4061 nvme_ns2.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 4062 CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path1); 4063 4064 nbdev_ch.current_io_path = NULL; 4065 } 4066 4067 static void 4068 test_retry_io_if_ana_state_is_updating(void) 4069 { 4070 struct nvme_path_id path = {}; 4071 struct nvme_ctrlr_opts opts = {}; 4072 struct spdk_nvme_ctrlr *ctrlr; 4073 struct nvme_bdev_ctrlr *nbdev_ctrlr; 4074 struct nvme_ctrlr *nvme_ctrlr; 4075 const int STRING_SIZE = 32; 4076 const char *attached_names[STRING_SIZE]; 4077 struct nvme_bdev *bdev; 4078 struct nvme_ns *nvme_ns; 4079 struct spdk_bdev_io *bdev_io1; 4080 struct spdk_io_channel *ch; 4081 struct nvme_bdev_channel *nbdev_ch; 4082 struct nvme_io_path *io_path; 4083 struct nvme_qpair *nvme_qpair; 4084 int rc; 4085 4086 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 4087 ut_init_trid(&path.trid); 4088 4089 set_thread(0); 4090 4091 ctrlr = ut_attach_ctrlr(&path.trid, 1, false, false); 4092 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 4093 4094 g_ut_attach_ctrlr_status = 0; 4095 g_ut_attach_bdev_count = 1; 4096 4097 opts.ctrlr_loss_timeout_sec = -1; 4098 opts.reconnect_delay_sec = 1; 4099 4100 rc = bdev_nvme_create(&path.trid, "nvme0", attached_names, STRING_SIZE, 4101 attach_ctrlr_done, NULL, NULL, &opts, false); 4102 CU_ASSERT(rc == 0); 4103 4104 spdk_delay_us(1000); 4105 poll_threads(); 4106 4107 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 4108 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 4109 4110 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path.trid); 4111 CU_ASSERT(nvme_ctrlr != NULL); 4112 4113 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 4114 CU_ASSERT(bdev != NULL); 4115 4116 nvme_ns = nvme_ctrlr_get_first_active_ns(nvme_ctrlr); 4117 CU_ASSERT(nvme_ns != NULL); 4118 4119 bdev_io1 = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, NULL); 4120 ut_bdev_io_set_buf(bdev_io1); 4121 4122 ch = spdk_get_io_channel(bdev); 4123 SPDK_CU_ASSERT_FATAL(ch != NULL); 4124 4125 nbdev_ch = spdk_io_channel_get_ctx(ch); 4126 4127 io_path = ut_get_io_path_by_ctrlr(nbdev_ch, nvme_ctrlr); 4128 SPDK_CU_ASSERT_FATAL(io_path != NULL); 4129 4130 nvme_qpair = io_path->qpair; 4131 SPDK_CU_ASSERT_FATAL(nvme_qpair != NULL); 4132 SPDK_CU_ASSERT_FATAL(nvme_qpair->qpair != NULL); 4133 4134 bdev_io1->internal.ch = (struct spdk_bdev_channel *)ch; 4135 4136 /* If qpair is connected, I/O should succeed. */ 4137 bdev_io1->internal.in_submit_request = true; 4138 4139 bdev_nvme_submit_request(ch, bdev_io1); 4140 CU_ASSERT(bdev_io1->internal.in_submit_request == true); 4141 4142 poll_threads(); 4143 CU_ASSERT(bdev_io1->internal.in_submit_request == false); 4144 CU_ASSERT(bdev_io1->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 4145 4146 /* If ANA state of namespace is inaccessible, I/O should be queued. */ 4147 nvme_ns->ana_state = SPDK_NVME_ANA_INACCESSIBLE_STATE; 4148 nbdev_ch->current_io_path = NULL; 4149 4150 bdev_io1->internal.in_submit_request = true; 4151 4152 bdev_nvme_submit_request(ch, bdev_io1); 4153 4154 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4155 CU_ASSERT(bdev_io1->internal.in_submit_request == true); 4156 CU_ASSERT(bdev_io1 == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 4157 4158 /* ANA state became accessible while I/O was queued. */ 4159 nvme_ns->ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 4160 4161 spdk_delay_us(1000000); 4162 4163 poll_thread_times(0, 1); 4164 4165 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 4166 CU_ASSERT(bdev_io1->internal.in_submit_request == true); 4167 CU_ASSERT(TAILQ_EMPTY(&nbdev_ch->retry_io_list)); 4168 4169 poll_threads(); 4170 4171 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4172 CU_ASSERT(bdev_io1->internal.in_submit_request == false); 4173 CU_ASSERT(bdev_io1->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4174 4175 free(bdev_io1); 4176 4177 spdk_put_io_channel(ch); 4178 4179 poll_threads(); 4180 4181 rc = bdev_nvme_delete("nvme0", &g_any_path); 4182 CU_ASSERT(rc == 0); 4183 4184 poll_threads(); 4185 spdk_delay_us(1000); 4186 poll_threads(); 4187 4188 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 4189 } 4190 4191 static void 4192 test_retry_io_for_io_path_error(void) 4193 { 4194 struct nvme_path_id path1 = {}, path2 = {}; 4195 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2; 4196 struct nvme_bdev_ctrlr *nbdev_ctrlr; 4197 struct nvme_ctrlr *nvme_ctrlr1, *nvme_ctrlr2; 4198 const int STRING_SIZE = 32; 4199 const char *attached_names[STRING_SIZE]; 4200 struct nvme_bdev *bdev; 4201 struct nvme_ns *nvme_ns1, *nvme_ns2; 4202 struct spdk_bdev_io *bdev_io; 4203 struct nvme_bdev_io *bio; 4204 struct spdk_io_channel *ch; 4205 struct nvme_bdev_channel *nbdev_ch; 4206 struct nvme_io_path *io_path1, *io_path2; 4207 struct nvme_qpair *nvme_qpair1, *nvme_qpair2; 4208 struct ut_nvme_req *req; 4209 struct spdk_uuid uuid1 = { .u.raw = { 0x1 } }; 4210 int rc; 4211 4212 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 4213 ut_init_trid(&path1.trid); 4214 ut_init_trid2(&path2.trid); 4215 4216 g_opts.bdev_retry_count = 1; 4217 4218 set_thread(0); 4219 4220 g_ut_attach_ctrlr_status = 0; 4221 g_ut_attach_bdev_count = 1; 4222 4223 ctrlr1 = ut_attach_ctrlr(&path1.trid, 1, true, true); 4224 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 4225 4226 ctrlr1->ns[0].uuid = &uuid1; 4227 4228 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 4229 attach_ctrlr_done, NULL, NULL, NULL, true); 4230 CU_ASSERT(rc == 0); 4231 4232 spdk_delay_us(1000); 4233 poll_threads(); 4234 4235 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4236 poll_threads(); 4237 4238 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 4239 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 4240 4241 nvme_ctrlr1 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid); 4242 CU_ASSERT(nvme_ctrlr1 != NULL); 4243 4244 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 4245 CU_ASSERT(bdev != NULL); 4246 4247 nvme_ns1 = nvme_ctrlr_get_first_active_ns(nvme_ctrlr1); 4248 CU_ASSERT(nvme_ns1 != NULL); 4249 CU_ASSERT(nvme_ns1 == _nvme_bdev_get_ns(bdev, nvme_ctrlr1)); 4250 4251 bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, NULL); 4252 ut_bdev_io_set_buf(bdev_io); 4253 4254 bio = (struct nvme_bdev_io *)bdev_io->driver_ctx; 4255 4256 ch = spdk_get_io_channel(bdev); 4257 SPDK_CU_ASSERT_FATAL(ch != NULL); 4258 4259 nbdev_ch = spdk_io_channel_get_ctx(ch); 4260 4261 io_path1 = ut_get_io_path_by_ctrlr(nbdev_ch, nvme_ctrlr1); 4262 SPDK_CU_ASSERT_FATAL(io_path1 != NULL); 4263 4264 nvme_qpair1 = io_path1->qpair; 4265 SPDK_CU_ASSERT_FATAL(nvme_qpair1 != NULL); 4266 SPDK_CU_ASSERT_FATAL(nvme_qpair1->qpair != NULL); 4267 4268 bdev_io->internal.ch = (struct spdk_bdev_channel *)ch; 4269 4270 /* I/O got a temporary I/O path error, but it should not retry if DNR is set. */ 4271 bdev_io->internal.in_submit_request = true; 4272 4273 bdev_nvme_submit_request(ch, bdev_io); 4274 4275 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 1); 4276 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4277 4278 req = ut_get_outstanding_nvme_request(nvme_qpair1->qpair, bio); 4279 SPDK_CU_ASSERT_FATAL(req != NULL); 4280 4281 req->cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR; 4282 req->cpl.status.sct = SPDK_NVME_SCT_PATH; 4283 req->cpl.status.dnr = 1; 4284 4285 poll_thread_times(0, 1); 4286 4287 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 0); 4288 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4289 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_NVME_ERROR); 4290 4291 /* I/O got a temporary I/O path error, but it should succeed after retry. */ 4292 bdev_io->internal.in_submit_request = true; 4293 4294 bdev_nvme_submit_request(ch, bdev_io); 4295 4296 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 1); 4297 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4298 4299 req = ut_get_outstanding_nvme_request(nvme_qpair1->qpair, bio); 4300 SPDK_CU_ASSERT_FATAL(req != NULL); 4301 4302 req->cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR; 4303 req->cpl.status.sct = SPDK_NVME_SCT_PATH; 4304 4305 poll_thread_times(0, 1); 4306 4307 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 0); 4308 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4309 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 4310 4311 poll_threads(); 4312 4313 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 0); 4314 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4315 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4316 4317 /* Add io_path2 dynamically, and create a multipath configuration. */ 4318 ctrlr2 = ut_attach_ctrlr(&path2.trid, 1, true, true); 4319 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 4320 4321 ctrlr2->ns[0].uuid = &uuid1; 4322 4323 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 4324 attach_ctrlr_done, NULL, NULL, NULL, true); 4325 CU_ASSERT(rc == 0); 4326 4327 spdk_delay_us(1000); 4328 poll_threads(); 4329 4330 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4331 poll_threads(); 4332 4333 nvme_ctrlr2 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid); 4334 CU_ASSERT(nvme_ctrlr2 != NULL); 4335 4336 nvme_ns2 = nvme_ctrlr_get_first_active_ns(nvme_ctrlr2); 4337 CU_ASSERT(nvme_ns2 != NULL); 4338 CU_ASSERT(nvme_ns2 == _nvme_bdev_get_ns(bdev, nvme_ctrlr2)); 4339 4340 io_path2 = ut_get_io_path_by_ctrlr(nbdev_ch, nvme_ctrlr2); 4341 SPDK_CU_ASSERT_FATAL(io_path2 != NULL); 4342 4343 nvme_qpair2 = io_path2->qpair; 4344 SPDK_CU_ASSERT_FATAL(nvme_qpair2 != NULL); 4345 SPDK_CU_ASSERT_FATAL(nvme_qpair2->qpair != NULL); 4346 4347 /* I/O is submitted to io_path1, but qpair of io_path1 was disconnected 4348 * and deleted. Hence the I/O was aborted. But io_path2 is available. 4349 * So after a retry, I/O is submitted to io_path2 and should succeed. 4350 */ 4351 bdev_io->internal.in_submit_request = true; 4352 4353 bdev_nvme_submit_request(ch, bdev_io); 4354 4355 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 1); 4356 CU_ASSERT(nvme_qpair2->qpair->num_outstanding_reqs == 0); 4357 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4358 4359 req = ut_get_outstanding_nvme_request(nvme_qpair1->qpair, bio); 4360 SPDK_CU_ASSERT_FATAL(req != NULL); 4361 4362 req->cpl.status.sc = SPDK_NVME_SC_ABORTED_SQ_DELETION; 4363 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 4364 4365 poll_thread_times(0, 1); 4366 4367 CU_ASSERT(nvme_qpair1->qpair->num_outstanding_reqs == 0); 4368 CU_ASSERT(nvme_qpair2->qpair->num_outstanding_reqs == 0); 4369 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4370 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 4371 4372 spdk_nvme_ctrlr_free_io_qpair(nvme_qpair1->qpair); 4373 nvme_qpair1->qpair = NULL; 4374 4375 poll_threads(); 4376 4377 CU_ASSERT(nvme_qpair2->qpair->num_outstanding_reqs == 0); 4378 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4379 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4380 4381 free(bdev_io); 4382 4383 spdk_put_io_channel(ch); 4384 4385 poll_threads(); 4386 4387 rc = bdev_nvme_delete("nvme0", &g_any_path); 4388 CU_ASSERT(rc == 0); 4389 4390 poll_threads(); 4391 spdk_delay_us(1000); 4392 poll_threads(); 4393 4394 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 4395 4396 g_opts.bdev_retry_count = 0; 4397 } 4398 4399 static void 4400 test_retry_io_count(void) 4401 { 4402 struct nvme_path_id path = {}; 4403 struct spdk_nvme_ctrlr *ctrlr; 4404 struct nvme_bdev_ctrlr *nbdev_ctrlr; 4405 struct nvme_ctrlr *nvme_ctrlr; 4406 const int STRING_SIZE = 32; 4407 const char *attached_names[STRING_SIZE]; 4408 struct nvme_bdev *bdev; 4409 struct nvme_ns *nvme_ns; 4410 struct spdk_bdev_io *bdev_io; 4411 struct nvme_bdev_io *bio; 4412 struct spdk_io_channel *ch; 4413 struct nvme_bdev_channel *nbdev_ch; 4414 struct nvme_io_path *io_path; 4415 struct nvme_qpair *nvme_qpair; 4416 struct ut_nvme_req *req; 4417 int rc; 4418 4419 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 4420 ut_init_trid(&path.trid); 4421 4422 set_thread(0); 4423 4424 ctrlr = ut_attach_ctrlr(&path.trid, 1, false, false); 4425 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 4426 4427 g_ut_attach_ctrlr_status = 0; 4428 g_ut_attach_bdev_count = 1; 4429 4430 rc = bdev_nvme_create(&path.trid, "nvme0", attached_names, STRING_SIZE, 4431 attach_ctrlr_done, NULL, NULL, NULL, false); 4432 CU_ASSERT(rc == 0); 4433 4434 spdk_delay_us(1000); 4435 poll_threads(); 4436 4437 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 4438 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 4439 4440 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path.trid); 4441 CU_ASSERT(nvme_ctrlr != NULL); 4442 4443 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 4444 CU_ASSERT(bdev != NULL); 4445 4446 nvme_ns = nvme_ctrlr_get_first_active_ns(nvme_ctrlr); 4447 CU_ASSERT(nvme_ns != NULL); 4448 4449 bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, NULL); 4450 ut_bdev_io_set_buf(bdev_io); 4451 4452 bio = (struct nvme_bdev_io *)bdev_io->driver_ctx; 4453 4454 ch = spdk_get_io_channel(bdev); 4455 SPDK_CU_ASSERT_FATAL(ch != NULL); 4456 4457 nbdev_ch = spdk_io_channel_get_ctx(ch); 4458 4459 io_path = ut_get_io_path_by_ctrlr(nbdev_ch, nvme_ctrlr); 4460 SPDK_CU_ASSERT_FATAL(io_path != NULL); 4461 4462 nvme_qpair = io_path->qpair; 4463 SPDK_CU_ASSERT_FATAL(nvme_qpair != NULL); 4464 SPDK_CU_ASSERT_FATAL(nvme_qpair->qpair != NULL); 4465 4466 bdev_io->internal.ch = (struct spdk_bdev_channel *)ch; 4467 4468 /* If I/O is aborted by request, it should not be retried. */ 4469 g_opts.bdev_retry_count = 1; 4470 4471 bdev_io->internal.in_submit_request = true; 4472 4473 bdev_nvme_submit_request(ch, bdev_io); 4474 4475 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 4476 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4477 4478 req = ut_get_outstanding_nvme_request(nvme_qpair->qpair, bio); 4479 SPDK_CU_ASSERT_FATAL(req != NULL); 4480 4481 req->cpl.status.sc = SPDK_NVME_SC_ABORTED_BY_REQUEST; 4482 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 4483 4484 poll_thread_times(0, 1); 4485 4486 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4487 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4488 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_ABORTED); 4489 4490 /* If bio->retry_count is not less than g_opts.bdev_retry_count, 4491 * the failed I/O should not be retried. 4492 */ 4493 g_opts.bdev_retry_count = 4; 4494 4495 bdev_io->internal.in_submit_request = true; 4496 4497 bdev_nvme_submit_request(ch, bdev_io); 4498 4499 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 4500 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4501 4502 req = ut_get_outstanding_nvme_request(nvme_qpair->qpair, bio); 4503 SPDK_CU_ASSERT_FATAL(req != NULL); 4504 4505 req->cpl.status.sc = SPDK_NVME_SC_NAMESPACE_NOT_READY; 4506 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 4507 bio->retry_count = 4; 4508 4509 poll_thread_times(0, 1); 4510 4511 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4512 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4513 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_NVME_ERROR); 4514 4515 /* If g_opts.bdev_retry_count is -1, the failed I/O always should be retried. */ 4516 g_opts.bdev_retry_count = -1; 4517 4518 bdev_io->internal.in_submit_request = true; 4519 4520 bdev_nvme_submit_request(ch, bdev_io); 4521 4522 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 4523 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4524 4525 req = ut_get_outstanding_nvme_request(nvme_qpair->qpair, bio); 4526 SPDK_CU_ASSERT_FATAL(req != NULL); 4527 4528 req->cpl.status.sc = SPDK_NVME_SC_NAMESPACE_NOT_READY; 4529 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 4530 bio->retry_count = 4; 4531 4532 poll_thread_times(0, 1); 4533 4534 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4535 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4536 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 4537 4538 poll_threads(); 4539 4540 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4541 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4542 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4543 4544 /* If bio->retry_count is less than g_opts.bdev_retry_count, 4545 * the failed I/O should be retried. 4546 */ 4547 g_opts.bdev_retry_count = 4; 4548 4549 bdev_io->internal.in_submit_request = true; 4550 4551 bdev_nvme_submit_request(ch, bdev_io); 4552 4553 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 4554 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4555 4556 req = ut_get_outstanding_nvme_request(nvme_qpair->qpair, bio); 4557 SPDK_CU_ASSERT_FATAL(req != NULL); 4558 4559 req->cpl.status.sc = SPDK_NVME_SC_NAMESPACE_NOT_READY; 4560 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 4561 bio->retry_count = 3; 4562 4563 poll_thread_times(0, 1); 4564 4565 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4566 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4567 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 4568 4569 poll_threads(); 4570 4571 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4572 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4573 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4574 4575 free(bdev_io); 4576 4577 spdk_put_io_channel(ch); 4578 4579 poll_threads(); 4580 4581 rc = bdev_nvme_delete("nvme0", &g_any_path); 4582 CU_ASSERT(rc == 0); 4583 4584 poll_threads(); 4585 spdk_delay_us(1000); 4586 poll_threads(); 4587 4588 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 4589 4590 g_opts.bdev_retry_count = 0; 4591 } 4592 4593 static void 4594 test_concurrent_read_ana_log_page(void) 4595 { 4596 struct spdk_nvme_transport_id trid = {}; 4597 struct spdk_nvme_ctrlr *ctrlr; 4598 struct nvme_ctrlr *nvme_ctrlr; 4599 const int STRING_SIZE = 32; 4600 const char *attached_names[STRING_SIZE]; 4601 int rc; 4602 4603 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 4604 ut_init_trid(&trid); 4605 4606 set_thread(0); 4607 4608 ctrlr = ut_attach_ctrlr(&trid, 1, true, false); 4609 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 4610 4611 ctrlr->ns[0].ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 4612 4613 g_ut_attach_ctrlr_status = 0; 4614 g_ut_attach_bdev_count = 1; 4615 4616 rc = bdev_nvme_create(&trid, "nvme0", attached_names, STRING_SIZE, 4617 attach_ctrlr_done, NULL, NULL, NULL, false); 4618 CU_ASSERT(rc == 0); 4619 4620 spdk_delay_us(1000); 4621 poll_threads(); 4622 4623 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4624 poll_threads(); 4625 4626 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 4627 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 4628 4629 nvme_ctrlr_read_ana_log_page(nvme_ctrlr); 4630 4631 CU_ASSERT(nvme_ctrlr->ana_log_page_updating == true); 4632 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 4633 4634 /* Following read request should be rejected. */ 4635 nvme_ctrlr_read_ana_log_page(nvme_ctrlr); 4636 4637 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 4638 4639 set_thread(1); 4640 4641 nvme_ctrlr_read_ana_log_page(nvme_ctrlr); 4642 4643 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 4644 4645 /* Reset request while reading ANA log page should not be rejected. */ 4646 rc = bdev_nvme_reset(nvme_ctrlr); 4647 CU_ASSERT(rc == 0); 4648 4649 poll_threads(); 4650 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4651 poll_threads(); 4652 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4653 poll_threads(); 4654 4655 CU_ASSERT(nvme_ctrlr->ana_log_page_updating == false); 4656 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 4657 4658 /* Read ANA log page while resetting ctrlr should be rejected. */ 4659 rc = bdev_nvme_reset(nvme_ctrlr); 4660 CU_ASSERT(rc == 0); 4661 4662 nvme_ctrlr_read_ana_log_page(nvme_ctrlr); 4663 4664 CU_ASSERT(nvme_ctrlr->ana_log_page_updating == false); 4665 4666 poll_threads(); 4667 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4668 poll_threads(); 4669 4670 set_thread(0); 4671 4672 rc = bdev_nvme_delete("nvme0", &g_any_path); 4673 CU_ASSERT(rc == 0); 4674 4675 poll_threads(); 4676 spdk_delay_us(1000); 4677 poll_threads(); 4678 4679 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 4680 } 4681 4682 static void 4683 test_retry_io_for_ana_error(void) 4684 { 4685 struct nvme_path_id path = {}; 4686 struct spdk_nvme_ctrlr *ctrlr; 4687 struct nvme_bdev_ctrlr *nbdev_ctrlr; 4688 struct nvme_ctrlr *nvme_ctrlr; 4689 const int STRING_SIZE = 32; 4690 const char *attached_names[STRING_SIZE]; 4691 struct nvme_bdev *bdev; 4692 struct nvme_ns *nvme_ns; 4693 struct spdk_bdev_io *bdev_io; 4694 struct nvme_bdev_io *bio; 4695 struct spdk_io_channel *ch; 4696 struct nvme_bdev_channel *nbdev_ch; 4697 struct nvme_io_path *io_path; 4698 struct nvme_qpair *nvme_qpair; 4699 struct ut_nvme_req *req; 4700 uint64_t now; 4701 int rc; 4702 4703 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 4704 ut_init_trid(&path.trid); 4705 4706 g_opts.bdev_retry_count = 1; 4707 4708 set_thread(0); 4709 4710 ctrlr = ut_attach_ctrlr(&path.trid, 1, true, false); 4711 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 4712 4713 g_ut_attach_ctrlr_status = 0; 4714 g_ut_attach_bdev_count = 1; 4715 4716 rc = bdev_nvme_create(&path.trid, "nvme0", attached_names, STRING_SIZE, 4717 attach_ctrlr_done, NULL, NULL, NULL, false); 4718 CU_ASSERT(rc == 0); 4719 4720 spdk_delay_us(1000); 4721 poll_threads(); 4722 4723 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4724 poll_threads(); 4725 4726 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 4727 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 4728 4729 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path.trid); 4730 CU_ASSERT(nvme_ctrlr != NULL); 4731 4732 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 4733 CU_ASSERT(bdev != NULL); 4734 4735 nvme_ns = nvme_ctrlr_get_first_active_ns(nvme_ctrlr); 4736 CU_ASSERT(nvme_ns != NULL); 4737 4738 bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, NULL); 4739 ut_bdev_io_set_buf(bdev_io); 4740 4741 bio = (struct nvme_bdev_io *)bdev_io->driver_ctx; 4742 4743 ch = spdk_get_io_channel(bdev); 4744 SPDK_CU_ASSERT_FATAL(ch != NULL); 4745 4746 nbdev_ch = spdk_io_channel_get_ctx(ch); 4747 4748 io_path = ut_get_io_path_by_ctrlr(nbdev_ch, nvme_ctrlr); 4749 SPDK_CU_ASSERT_FATAL(io_path != NULL); 4750 4751 nvme_qpair = io_path->qpair; 4752 SPDK_CU_ASSERT_FATAL(nvme_qpair != NULL); 4753 SPDK_CU_ASSERT_FATAL(nvme_qpair->qpair != NULL); 4754 4755 now = spdk_get_ticks(); 4756 4757 bdev_io->internal.ch = (struct spdk_bdev_channel *)ch; 4758 4759 /* If I/O got ANA error, it should be queued, the corresponding namespace 4760 * should be freezed and its ANA state should be updated. 4761 */ 4762 bdev_io->internal.in_submit_request = true; 4763 4764 bdev_nvme_submit_request(ch, bdev_io); 4765 4766 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 4767 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4768 4769 req = ut_get_outstanding_nvme_request(nvme_qpair->qpair, bio); 4770 SPDK_CU_ASSERT_FATAL(req != NULL); 4771 4772 nvme_ns->ana_state = SPDK_NVME_ANA_INACCESSIBLE_STATE; 4773 req->cpl.status.sc = SPDK_NVME_SC_ASYMMETRIC_ACCESS_INACCESSIBLE; 4774 req->cpl.status.sct = SPDK_NVME_SCT_PATH; 4775 4776 poll_thread_times(0, 1); 4777 4778 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4779 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4780 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 4781 /* I/O should be retried immediately. */ 4782 CU_ASSERT(bio->retry_ticks == now); 4783 CU_ASSERT(nvme_ns->ana_state_updating == true); 4784 CU_ASSERT(nvme_ctrlr->ana_log_page_updating == true); 4785 4786 poll_threads(); 4787 4788 /* Namespace is inaccessible, and hence I/O should be queued again. */ 4789 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4790 CU_ASSERT(bdev_io->internal.in_submit_request == true); 4791 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 4792 /* I/O should be retried after a second if no I/O path was found but 4793 * any I/O path may become available. 4794 */ 4795 CU_ASSERT(bio->retry_ticks == now + spdk_get_ticks_hz()); 4796 4797 /* Namespace should be unfreezed after completing to update its ANA state. */ 4798 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4799 poll_threads(); 4800 4801 CU_ASSERT(nvme_ns->ana_state_updating == false); 4802 CU_ASSERT(nvme_ns->ana_state == SPDK_NVME_ANA_OPTIMIZED_STATE); 4803 CU_ASSERT(nvme_ctrlr->ana_log_page_updating == false); 4804 4805 /* Retry the queued I/O should succeed. */ 4806 spdk_delay_us(spdk_get_ticks_hz() - g_opts.nvme_adminq_poll_period_us); 4807 poll_threads(); 4808 4809 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 4810 CU_ASSERT(bdev_io->internal.in_submit_request == false); 4811 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4812 4813 free(bdev_io); 4814 4815 spdk_put_io_channel(ch); 4816 4817 poll_threads(); 4818 4819 rc = bdev_nvme_delete("nvme0", &g_any_path); 4820 CU_ASSERT(rc == 0); 4821 4822 poll_threads(); 4823 spdk_delay_us(1000); 4824 poll_threads(); 4825 4826 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 4827 4828 g_opts.bdev_retry_count = 0; 4829 } 4830 4831 static void 4832 test_retry_admin_passthru_for_path_error(void) 4833 { 4834 struct nvme_path_id path1 = {}, path2 = {}; 4835 struct spdk_nvme_ctrlr *ctrlr1, *ctrlr2; 4836 struct nvme_bdev_ctrlr *nbdev_ctrlr; 4837 struct nvme_ctrlr *nvme_ctrlr1, *nvme_ctrlr2; 4838 const int STRING_SIZE = 32; 4839 const char *attached_names[STRING_SIZE]; 4840 struct nvme_bdev *bdev; 4841 struct spdk_bdev_io *admin_io; 4842 struct spdk_io_channel *ch; 4843 struct ut_nvme_req *req; 4844 struct spdk_uuid uuid1 = { .u.raw = { 0x1 } }; 4845 int rc; 4846 4847 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 4848 ut_init_trid(&path1.trid); 4849 ut_init_trid2(&path2.trid); 4850 4851 g_opts.bdev_retry_count = 1; 4852 4853 set_thread(0); 4854 4855 g_ut_attach_ctrlr_status = 0; 4856 g_ut_attach_bdev_count = 1; 4857 4858 ctrlr1 = ut_attach_ctrlr(&path1.trid, 1, true, true); 4859 SPDK_CU_ASSERT_FATAL(ctrlr1 != NULL); 4860 4861 ctrlr1->ns[0].uuid = &uuid1; 4862 4863 rc = bdev_nvme_create(&path1.trid, "nvme0", attached_names, STRING_SIZE, 4864 attach_ctrlr_done, NULL, NULL, NULL, true); 4865 CU_ASSERT(rc == 0); 4866 4867 spdk_delay_us(1000); 4868 poll_threads(); 4869 4870 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4871 poll_threads(); 4872 4873 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 4874 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 4875 4876 nvme_ctrlr1 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path1.trid); 4877 CU_ASSERT(nvme_ctrlr1 != NULL); 4878 4879 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 4880 CU_ASSERT(bdev != NULL); 4881 4882 admin_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_NVME_ADMIN, bdev, NULL); 4883 admin_io->u.nvme_passthru.cmd.opc = SPDK_NVME_OPC_GET_FEATURES; 4884 4885 ch = spdk_get_io_channel(bdev); 4886 SPDK_CU_ASSERT_FATAL(ch != NULL); 4887 4888 admin_io->internal.ch = (struct spdk_bdev_channel *)ch; 4889 4890 /* Admin passthrough got a path error, but it should not retry if DNR is set. */ 4891 admin_io->internal.in_submit_request = true; 4892 4893 bdev_nvme_submit_request(ch, admin_io); 4894 4895 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 1); 4896 CU_ASSERT(admin_io->internal.in_submit_request == true); 4897 4898 req = ut_get_outstanding_nvme_request(&ctrlr1->adminq, admin_io->driver_ctx); 4899 SPDK_CU_ASSERT_FATAL(req != NULL); 4900 4901 req->cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR; 4902 req->cpl.status.sct = SPDK_NVME_SCT_PATH; 4903 req->cpl.status.dnr = 1; 4904 4905 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4906 poll_thread_times(0, 2); 4907 4908 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 0); 4909 CU_ASSERT(admin_io->internal.in_submit_request == false); 4910 CU_ASSERT(admin_io->internal.status == SPDK_BDEV_IO_STATUS_NVME_ERROR); 4911 4912 /* Admin passthrough got a path error, but it should succeed after retry. */ 4913 admin_io->internal.in_submit_request = true; 4914 4915 bdev_nvme_submit_request(ch, admin_io); 4916 4917 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 1); 4918 CU_ASSERT(admin_io->internal.in_submit_request == true); 4919 4920 req = ut_get_outstanding_nvme_request(&ctrlr1->adminq, admin_io->driver_ctx); 4921 SPDK_CU_ASSERT_FATAL(req != NULL); 4922 4923 req->cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR; 4924 req->cpl.status.sct = SPDK_NVME_SCT_PATH; 4925 4926 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4927 poll_thread_times(0, 2); 4928 4929 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 1); 4930 CU_ASSERT(admin_io->internal.in_submit_request == true); 4931 4932 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4933 poll_threads(); 4934 4935 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 0); 4936 CU_ASSERT(admin_io->internal.in_submit_request == false); 4937 CU_ASSERT(admin_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4938 4939 /* Add ctrlr2 dynamically, and create a multipath configuration. */ 4940 ctrlr2 = ut_attach_ctrlr(&path2.trid, 1, true, true); 4941 SPDK_CU_ASSERT_FATAL(ctrlr2 != NULL); 4942 4943 ctrlr2->ns[0].uuid = &uuid1; 4944 4945 rc = bdev_nvme_create(&path2.trid, "nvme0", attached_names, STRING_SIZE, 4946 attach_ctrlr_done, NULL, NULL, NULL, true); 4947 CU_ASSERT(rc == 0); 4948 4949 spdk_delay_us(1000); 4950 poll_threads(); 4951 4952 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4953 poll_threads(); 4954 4955 nvme_ctrlr2 = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path2.trid); 4956 CU_ASSERT(nvme_ctrlr2 != NULL); 4957 4958 /* Admin passthrough was submitted to ctrlr1, but ctrlr1 was failed. 4959 * Hence the admin passthrough was aborted. But ctrlr2 is avaialble. 4960 * So after a retry, the admin passthrough is submitted to ctrlr2 and 4961 * should succeed. 4962 */ 4963 admin_io->internal.in_submit_request = true; 4964 4965 bdev_nvme_submit_request(ch, admin_io); 4966 4967 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 1); 4968 CU_ASSERT(ctrlr2->adminq.num_outstanding_reqs == 0); 4969 CU_ASSERT(admin_io->internal.in_submit_request == true); 4970 4971 req = ut_get_outstanding_nvme_request(&ctrlr1->adminq, admin_io->driver_ctx); 4972 SPDK_CU_ASSERT_FATAL(req != NULL); 4973 4974 req->cpl.status.sc = SPDK_NVME_SC_ABORTED_SQ_DELETION; 4975 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 4976 ctrlr1->is_failed = true; 4977 4978 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4979 poll_thread_times(0, 2); 4980 4981 CU_ASSERT(ctrlr1->adminq.num_outstanding_reqs == 0); 4982 CU_ASSERT(ctrlr2->adminq.num_outstanding_reqs == 1); 4983 CU_ASSERT(admin_io->internal.in_submit_request == true); 4984 4985 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 4986 poll_threads(); 4987 4988 CU_ASSERT(ctrlr2->adminq.num_outstanding_reqs == 0); 4989 CU_ASSERT(admin_io->internal.in_submit_request == false); 4990 CU_ASSERT(admin_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 4991 4992 free(admin_io); 4993 4994 spdk_put_io_channel(ch); 4995 4996 poll_threads(); 4997 4998 rc = bdev_nvme_delete("nvme0", &g_any_path); 4999 CU_ASSERT(rc == 0); 5000 5001 poll_threads(); 5002 spdk_delay_us(1000); 5003 poll_threads(); 5004 5005 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 5006 5007 g_opts.bdev_retry_count = 0; 5008 } 5009 5010 static void 5011 test_retry_admin_passthru_by_count(void) 5012 { 5013 struct nvme_path_id path = {}; 5014 struct spdk_nvme_ctrlr *ctrlr; 5015 struct nvme_bdev_ctrlr *nbdev_ctrlr; 5016 struct nvme_ctrlr *nvme_ctrlr; 5017 const int STRING_SIZE = 32; 5018 const char *attached_names[STRING_SIZE]; 5019 struct nvme_bdev *bdev; 5020 struct spdk_bdev_io *admin_io; 5021 struct nvme_bdev_io *admin_bio; 5022 struct spdk_io_channel *ch; 5023 struct ut_nvme_req *req; 5024 int rc; 5025 5026 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 5027 ut_init_trid(&path.trid); 5028 5029 set_thread(0); 5030 5031 ctrlr = ut_attach_ctrlr(&path.trid, 1, false, false); 5032 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 5033 5034 g_ut_attach_ctrlr_status = 0; 5035 g_ut_attach_bdev_count = 1; 5036 5037 rc = bdev_nvme_create(&path.trid, "nvme0", attached_names, STRING_SIZE, 5038 attach_ctrlr_done, NULL, NULL, NULL, false); 5039 CU_ASSERT(rc == 0); 5040 5041 spdk_delay_us(1000); 5042 poll_threads(); 5043 5044 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 5045 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 5046 5047 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path.trid); 5048 CU_ASSERT(nvme_ctrlr != NULL); 5049 5050 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 5051 CU_ASSERT(bdev != NULL); 5052 5053 admin_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_NVME_ADMIN, bdev, NULL); 5054 admin_io->u.nvme_passthru.cmd.opc = SPDK_NVME_OPC_GET_FEATURES; 5055 5056 admin_bio = (struct nvme_bdev_io *)admin_io->driver_ctx; 5057 5058 ch = spdk_get_io_channel(bdev); 5059 SPDK_CU_ASSERT_FATAL(ch != NULL); 5060 5061 admin_io->internal.ch = (struct spdk_bdev_channel *)ch; 5062 5063 /* If admin passthrough is aborted by request, it should not be retried. */ 5064 g_opts.bdev_retry_count = 1; 5065 5066 admin_io->internal.in_submit_request = true; 5067 5068 bdev_nvme_submit_request(ch, admin_io); 5069 5070 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 5071 CU_ASSERT(admin_io->internal.in_submit_request == true); 5072 5073 req = ut_get_outstanding_nvme_request(&ctrlr->adminq, admin_bio); 5074 SPDK_CU_ASSERT_FATAL(req != NULL); 5075 5076 req->cpl.status.sc = SPDK_NVME_SC_ABORTED_BY_REQUEST; 5077 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 5078 5079 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5080 poll_thread_times(0, 2); 5081 5082 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 5083 CU_ASSERT(admin_io->internal.in_submit_request == false); 5084 CU_ASSERT(admin_io->internal.status == SPDK_BDEV_IO_STATUS_ABORTED); 5085 5086 /* If bio->retry_count is not less than g_opts.bdev_retry_count, 5087 * the failed admin passthrough should not be retried. 5088 */ 5089 g_opts.bdev_retry_count = 4; 5090 5091 admin_io->internal.in_submit_request = true; 5092 5093 bdev_nvme_submit_request(ch, admin_io); 5094 5095 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 5096 CU_ASSERT(admin_io->internal.in_submit_request == true); 5097 5098 req = ut_get_outstanding_nvme_request(&ctrlr->adminq, admin_bio); 5099 SPDK_CU_ASSERT_FATAL(req != NULL); 5100 5101 req->cpl.status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 5102 req->cpl.status.sct = SPDK_NVME_SCT_GENERIC; 5103 admin_bio->retry_count = 4; 5104 5105 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5106 poll_thread_times(0, 2); 5107 5108 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 5109 CU_ASSERT(admin_io->internal.in_submit_request == false); 5110 CU_ASSERT(admin_io->internal.status == SPDK_BDEV_IO_STATUS_NVME_ERROR); 5111 5112 free(admin_io); 5113 5114 spdk_put_io_channel(ch); 5115 5116 poll_threads(); 5117 5118 rc = bdev_nvme_delete("nvme0", &g_any_path); 5119 CU_ASSERT(rc == 0); 5120 5121 poll_threads(); 5122 spdk_delay_us(1000); 5123 poll_threads(); 5124 5125 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 5126 5127 g_opts.bdev_retry_count = 0; 5128 } 5129 5130 static void 5131 test_check_multipath_params(void) 5132 { 5133 /* 1st parameter is ctrlr_loss_timeout_sec, 2nd parameter is reconnect_delay_sec, and 5134 * 3rd parameter is fast_io_fail_timeout_sec. 5135 */ 5136 CU_ASSERT(bdev_nvme_check_multipath_params(-2, 1, 0) == false); 5137 CU_ASSERT(bdev_nvme_check_multipath_params(-1, 0, 0) == false); 5138 CU_ASSERT(bdev_nvme_check_multipath_params(1, 0, 0) == false); 5139 CU_ASSERT(bdev_nvme_check_multipath_params(1, 2, 0) == false); 5140 CU_ASSERT(bdev_nvme_check_multipath_params(0, 1, 0) == false); 5141 CU_ASSERT(bdev_nvme_check_multipath_params(-1, 1, 0) == true); 5142 CU_ASSERT(bdev_nvme_check_multipath_params(2, 2, 0) == true); 5143 CU_ASSERT(bdev_nvme_check_multipath_params(2, 1, 0) == true); 5144 CU_ASSERT(bdev_nvme_check_multipath_params(INT32_MAX, INT32_MAX, 0) == true); 5145 CU_ASSERT(bdev_nvme_check_multipath_params(-1, UINT32_MAX, 0) == true); 5146 CU_ASSERT(bdev_nvme_check_multipath_params(0, 0, 1) == false); 5147 CU_ASSERT(bdev_nvme_check_multipath_params(-1, 2, 1) == false); 5148 CU_ASSERT(bdev_nvme_check_multipath_params(3, 2, 4) == false); 5149 CU_ASSERT(bdev_nvme_check_multipath_params(3, 2, 1) == false); 5150 CU_ASSERT(bdev_nvme_check_multipath_params(-1, 1, 1) == true); 5151 CU_ASSERT(bdev_nvme_check_multipath_params(2, 1, 2) == true); 5152 CU_ASSERT(bdev_nvme_check_multipath_params(2, 1, 1) == true); 5153 CU_ASSERT(bdev_nvme_check_multipath_params(INT32_MAX, INT32_MAX, INT32_MAX) == true); 5154 CU_ASSERT(bdev_nvme_check_multipath_params(-1, UINT32_MAX, UINT32_MAX) == true); 5155 } 5156 5157 static void 5158 test_retry_io_if_ctrlr_is_resetting(void) 5159 { 5160 struct nvme_path_id path = {}; 5161 struct nvme_ctrlr_opts opts = {}; 5162 struct spdk_nvme_ctrlr *ctrlr; 5163 struct nvme_bdev_ctrlr *nbdev_ctrlr; 5164 struct nvme_ctrlr *nvme_ctrlr; 5165 const int STRING_SIZE = 32; 5166 const char *attached_names[STRING_SIZE]; 5167 struct nvme_bdev *bdev; 5168 struct nvme_ns *nvme_ns; 5169 struct spdk_bdev_io *bdev_io1, *bdev_io2; 5170 struct spdk_io_channel *ch; 5171 struct nvme_bdev_channel *nbdev_ch; 5172 struct nvme_io_path *io_path; 5173 struct nvme_qpair *nvme_qpair; 5174 int rc; 5175 5176 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 5177 ut_init_trid(&path.trid); 5178 5179 set_thread(0); 5180 5181 ctrlr = ut_attach_ctrlr(&path.trid, 1, false, false); 5182 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 5183 5184 g_ut_attach_ctrlr_status = 0; 5185 g_ut_attach_bdev_count = 1; 5186 5187 opts.ctrlr_loss_timeout_sec = -1; 5188 opts.reconnect_delay_sec = 1; 5189 5190 rc = bdev_nvme_create(&path.trid, "nvme0", attached_names, STRING_SIZE, 5191 attach_ctrlr_done, NULL, NULL, &opts, false); 5192 CU_ASSERT(rc == 0); 5193 5194 spdk_delay_us(1000); 5195 poll_threads(); 5196 5197 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 5198 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 5199 5200 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path.trid); 5201 CU_ASSERT(nvme_ctrlr != NULL); 5202 5203 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 5204 CU_ASSERT(bdev != NULL); 5205 5206 nvme_ns = nvme_ctrlr_get_first_active_ns(nvme_ctrlr); 5207 CU_ASSERT(nvme_ns != NULL); 5208 5209 bdev_io1 = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, NULL); 5210 ut_bdev_io_set_buf(bdev_io1); 5211 5212 bdev_io2 = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, NULL); 5213 ut_bdev_io_set_buf(bdev_io2); 5214 5215 ch = spdk_get_io_channel(bdev); 5216 SPDK_CU_ASSERT_FATAL(ch != NULL); 5217 5218 nbdev_ch = spdk_io_channel_get_ctx(ch); 5219 5220 io_path = ut_get_io_path_by_ctrlr(nbdev_ch, nvme_ctrlr); 5221 SPDK_CU_ASSERT_FATAL(io_path != NULL); 5222 5223 nvme_qpair = io_path->qpair; 5224 SPDK_CU_ASSERT_FATAL(nvme_qpair != NULL); 5225 SPDK_CU_ASSERT_FATAL(nvme_qpair->qpair != NULL); 5226 5227 bdev_io1->internal.ch = (struct spdk_bdev_channel *)ch; 5228 bdev_io2->internal.ch = (struct spdk_bdev_channel *)ch; 5229 5230 /* If qpair is connected, I/O should succeed. */ 5231 bdev_io1->internal.in_submit_request = true; 5232 5233 bdev_nvme_submit_request(ch, bdev_io1); 5234 CU_ASSERT(bdev_io1->internal.in_submit_request == true); 5235 5236 poll_threads(); 5237 CU_ASSERT(bdev_io1->internal.in_submit_request == false); 5238 CU_ASSERT(bdev_io1->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 5239 5240 /* If qpair is disconnected, it is freed and then reconnected via resetting 5241 * the corresponding nvme_ctrlr. I/O should be queued if it is submitted 5242 * while resetting the nvme_ctrlr. 5243 */ 5244 nvme_qpair->qpair->failure_reason = SPDK_NVME_QPAIR_FAILURE_UNKNOWN; 5245 ctrlr->is_failed = true; 5246 5247 poll_thread_times(0, 5); 5248 5249 CU_ASSERT(nvme_qpair->qpair == NULL); 5250 CU_ASSERT(nvme_ctrlr->resetting == true); 5251 CU_ASSERT(ctrlr->is_failed == false); 5252 5253 bdev_io1->internal.in_submit_request = true; 5254 5255 bdev_nvme_submit_request(ch, bdev_io1); 5256 5257 spdk_delay_us(1); 5258 5259 bdev_io2->internal.in_submit_request = true; 5260 5261 bdev_nvme_submit_request(ch, bdev_io2); 5262 5263 CU_ASSERT(bdev_io1->internal.in_submit_request == true); 5264 CU_ASSERT(bdev_io2->internal.in_submit_request == true); 5265 CU_ASSERT(bdev_io1 == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 5266 CU_ASSERT(bdev_io2 == TAILQ_NEXT(bdev_io1, module_link)); 5267 5268 poll_threads(); 5269 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5270 poll_threads(); 5271 5272 CU_ASSERT(nvme_qpair->qpair != NULL); 5273 CU_ASSERT(nvme_ctrlr->resetting == false); 5274 5275 spdk_delay_us(999999 - g_opts.nvme_adminq_poll_period_us); 5276 5277 poll_thread_times(0, 1); 5278 5279 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 5280 CU_ASSERT(bdev_io1->internal.in_submit_request == true); 5281 CU_ASSERT(bdev_io2->internal.in_submit_request == true); 5282 CU_ASSERT(bdev_io2 == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 5283 5284 poll_threads(); 5285 5286 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 5287 CU_ASSERT(bdev_io1->internal.in_submit_request == false); 5288 CU_ASSERT(bdev_io1->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 5289 CU_ASSERT(bdev_io2->internal.in_submit_request == true); 5290 CU_ASSERT(bdev_io2 == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 5291 5292 spdk_delay_us(1); 5293 5294 poll_thread_times(0, 1); 5295 5296 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 1); 5297 CU_ASSERT(bdev_io2->internal.in_submit_request == true); 5298 CU_ASSERT(TAILQ_EMPTY(&nbdev_ch->retry_io_list)); 5299 5300 poll_threads(); 5301 5302 CU_ASSERT(nvme_qpair->qpair->num_outstanding_reqs == 0); 5303 CU_ASSERT(bdev_io2->internal.in_submit_request == false); 5304 CU_ASSERT(bdev_io2->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 5305 5306 free(bdev_io1); 5307 free(bdev_io2); 5308 5309 spdk_put_io_channel(ch); 5310 5311 poll_threads(); 5312 5313 rc = bdev_nvme_delete("nvme0", &g_any_path); 5314 CU_ASSERT(rc == 0); 5315 5316 poll_threads(); 5317 spdk_delay_us(1000); 5318 poll_threads(); 5319 5320 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 5321 } 5322 5323 static void 5324 test_retry_admin_passthru_if_ctrlr_is_resetting(void) 5325 { 5326 struct nvme_path_id path = {}; 5327 struct nvme_ctrlr_opts opts = {}; 5328 struct spdk_nvme_ctrlr *ctrlr; 5329 struct nvme_bdev_ctrlr *nbdev_ctrlr; 5330 struct nvme_ctrlr *nvme_ctrlr; 5331 const int STRING_SIZE = 32; 5332 const char *attached_names[STRING_SIZE]; 5333 struct nvme_bdev *bdev; 5334 struct spdk_bdev_io *admin_io; 5335 struct spdk_io_channel *ch; 5336 struct nvme_bdev_channel *nbdev_ch; 5337 int rc; 5338 5339 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 5340 ut_init_trid(&path.trid); 5341 5342 g_opts.bdev_retry_count = 1; 5343 5344 set_thread(0); 5345 5346 ctrlr = ut_attach_ctrlr(&path.trid, 1, false, false); 5347 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 5348 5349 g_ut_attach_ctrlr_status = 0; 5350 g_ut_attach_bdev_count = 1; 5351 5352 opts.ctrlr_loss_timeout_sec = -1; 5353 opts.reconnect_delay_sec = 1; 5354 5355 rc = bdev_nvme_create(&path.trid, "nvme0", attached_names, STRING_SIZE, 5356 attach_ctrlr_done, NULL, NULL, &opts, false); 5357 CU_ASSERT(rc == 0); 5358 5359 spdk_delay_us(1000); 5360 poll_threads(); 5361 5362 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 5363 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 5364 5365 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path.trid); 5366 CU_ASSERT(nvme_ctrlr != NULL); 5367 5368 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 5369 CU_ASSERT(bdev != NULL); 5370 5371 admin_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_NVME_ADMIN, bdev, NULL); 5372 admin_io->u.nvme_passthru.cmd.opc = SPDK_NVME_OPC_GET_FEATURES; 5373 5374 ch = spdk_get_io_channel(bdev); 5375 SPDK_CU_ASSERT_FATAL(ch != NULL); 5376 5377 nbdev_ch = spdk_io_channel_get_ctx(ch); 5378 5379 admin_io->internal.ch = (struct spdk_bdev_channel *)ch; 5380 5381 /* If ctrlr is available, admin passthrough should succeed. */ 5382 admin_io->internal.in_submit_request = true; 5383 5384 bdev_nvme_submit_request(ch, admin_io); 5385 5386 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 5387 CU_ASSERT(admin_io->internal.in_submit_request == true); 5388 5389 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5390 poll_threads(); 5391 5392 CU_ASSERT(admin_io->internal.in_submit_request == false); 5393 CU_ASSERT(admin_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 5394 5395 /* If ctrlr is resetting, admin passthrough request should be queued 5396 * if it is submitted while resetting ctrlr. 5397 */ 5398 bdev_nvme_reset(nvme_ctrlr); 5399 5400 poll_thread_times(0, 1); 5401 5402 admin_io->internal.in_submit_request = true; 5403 5404 bdev_nvme_submit_request(ch, admin_io); 5405 5406 CU_ASSERT(admin_io->internal.in_submit_request == true); 5407 CU_ASSERT(admin_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 5408 5409 poll_threads(); 5410 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5411 poll_threads(); 5412 5413 CU_ASSERT(nvme_ctrlr->resetting == false); 5414 5415 spdk_delay_us(1000000 - g_opts.nvme_adminq_poll_period_us); 5416 poll_thread_times(0, 1); 5417 5418 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 1); 5419 CU_ASSERT(admin_io->internal.in_submit_request == true); 5420 CU_ASSERT(TAILQ_EMPTY(&nbdev_ch->retry_io_list)); 5421 5422 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5423 poll_threads(); 5424 5425 CU_ASSERT(ctrlr->adminq.num_outstanding_reqs == 0); 5426 CU_ASSERT(admin_io->internal.in_submit_request == false); 5427 CU_ASSERT(admin_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 5428 5429 free(admin_io); 5430 5431 spdk_put_io_channel(ch); 5432 5433 poll_threads(); 5434 5435 rc = bdev_nvme_delete("nvme0", &g_any_path); 5436 CU_ASSERT(rc == 0); 5437 5438 poll_threads(); 5439 spdk_delay_us(1000); 5440 poll_threads(); 5441 5442 CU_ASSERT(nvme_bdev_ctrlr_get_by_name("nvme0") == NULL); 5443 5444 g_opts.bdev_retry_count = 0; 5445 } 5446 5447 static void 5448 test_reconnect_ctrlr(void) 5449 { 5450 struct spdk_nvme_transport_id trid = {}; 5451 struct spdk_nvme_ctrlr ctrlr = {}; 5452 struct nvme_ctrlr *nvme_ctrlr; 5453 struct spdk_io_channel *ch1, *ch2; 5454 struct nvme_ctrlr_channel *ctrlr_ch1, *ctrlr_ch2; 5455 int rc; 5456 5457 ut_init_trid(&trid); 5458 TAILQ_INIT(&ctrlr.active_io_qpairs); 5459 5460 set_thread(0); 5461 5462 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid, NULL); 5463 CU_ASSERT(rc == 0); 5464 5465 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 5466 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 5467 5468 nvme_ctrlr->opts.ctrlr_loss_timeout_sec = 2; 5469 nvme_ctrlr->opts.reconnect_delay_sec = 1; 5470 5471 ch1 = spdk_get_io_channel(nvme_ctrlr); 5472 SPDK_CU_ASSERT_FATAL(ch1 != NULL); 5473 5474 ctrlr_ch1 = spdk_io_channel_get_ctx(ch1); 5475 CU_ASSERT(ctrlr_ch1->qpair != NULL); 5476 5477 set_thread(1); 5478 5479 ch2 = spdk_get_io_channel(nvme_ctrlr); 5480 SPDK_CU_ASSERT_FATAL(ch2 != NULL); 5481 5482 ctrlr_ch2 = spdk_io_channel_get_ctx(ch2); 5483 5484 /* Reset starts from thread 1. */ 5485 set_thread(1); 5486 5487 /* The reset should fail and a reconnect timer should be registered. */ 5488 ctrlr.fail_reset = true; 5489 ctrlr.is_failed = true; 5490 5491 rc = bdev_nvme_reset(nvme_ctrlr); 5492 CU_ASSERT(rc == 0); 5493 CU_ASSERT(nvme_ctrlr->resetting == true); 5494 CU_ASSERT(ctrlr.is_failed == true); 5495 5496 poll_threads(); 5497 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5498 poll_threads(); 5499 5500 CU_ASSERT(nvme_ctrlr->resetting == false); 5501 CU_ASSERT(ctrlr.is_failed == false); 5502 CU_ASSERT(ctrlr_ch1->qpair->qpair == NULL); 5503 CU_ASSERT(ctrlr_ch2->qpair->qpair == NULL); 5504 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5505 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == false); 5506 5507 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5508 poll_threads(); 5509 5510 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer != NULL); 5511 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == true); 5512 5513 /* Then a reconnect retry should suceeed. */ 5514 ctrlr.fail_reset = false; 5515 5516 spdk_delay_us(SPDK_SEC_TO_USEC); 5517 poll_thread_times(0, 1); 5518 5519 CU_ASSERT(nvme_ctrlr->resetting == true); 5520 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5521 5522 poll_threads(); 5523 5524 CU_ASSERT(nvme_ctrlr->resetting == false); 5525 CU_ASSERT(ctrlr_ch1->qpair->qpair != NULL); 5526 CU_ASSERT(ctrlr_ch2->qpair->qpair != NULL); 5527 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == false); 5528 5529 /* The reset should fail and a reconnect timer should be registered. */ 5530 ctrlr.fail_reset = true; 5531 ctrlr.is_failed = true; 5532 5533 rc = bdev_nvme_reset(nvme_ctrlr); 5534 CU_ASSERT(rc == 0); 5535 CU_ASSERT(nvme_ctrlr->resetting == true); 5536 CU_ASSERT(ctrlr.is_failed == true); 5537 5538 poll_threads(); 5539 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5540 poll_threads(); 5541 5542 CU_ASSERT(nvme_ctrlr->resetting == false); 5543 CU_ASSERT(ctrlr.is_failed == false); 5544 CU_ASSERT(ctrlr_ch1->qpair->qpair == NULL); 5545 CU_ASSERT(ctrlr_ch2->qpair->qpair == NULL); 5546 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5547 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == false); 5548 5549 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5550 poll_threads(); 5551 5552 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer != NULL); 5553 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == true); 5554 5555 /* Then a reconnect retry should still fail. */ 5556 spdk_delay_us(SPDK_SEC_TO_USEC); 5557 poll_thread_times(0, 1); 5558 5559 CU_ASSERT(nvme_ctrlr->resetting == true); 5560 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5561 5562 poll_threads(); 5563 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5564 poll_threads(); 5565 5566 CU_ASSERT(nvme_ctrlr->resetting == false); 5567 CU_ASSERT(ctrlr.is_failed == false); 5568 CU_ASSERT(ctrlr_ch1->qpair->qpair == NULL); 5569 CU_ASSERT(ctrlr_ch2->qpair->qpair == NULL); 5570 CU_ASSERT(bdev_nvme_check_ctrlr_loss_timeout(nvme_ctrlr) == false); 5571 5572 /* Then a reconnect retry should still fail and the ctrlr should be deleted. */ 5573 spdk_delay_us(SPDK_SEC_TO_USEC); 5574 poll_threads(); 5575 5576 CU_ASSERT(nvme_ctrlr == nvme_ctrlr_get_by_name("nvme0")); 5577 CU_ASSERT(bdev_nvme_check_ctrlr_loss_timeout(nvme_ctrlr) == true); 5578 CU_ASSERT(nvme_ctrlr->destruct == true); 5579 5580 spdk_put_io_channel(ch2); 5581 5582 set_thread(0); 5583 5584 spdk_put_io_channel(ch1); 5585 5586 poll_threads(); 5587 spdk_delay_us(1000); 5588 poll_threads(); 5589 5590 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 5591 } 5592 5593 static struct nvme_path_id * 5594 ut_get_path_id_by_trid(struct nvme_ctrlr *nvme_ctrlr, 5595 const struct spdk_nvme_transport_id *trid) 5596 { 5597 struct nvme_path_id *p; 5598 5599 TAILQ_FOREACH(p, &nvme_ctrlr->trids, link) { 5600 if (spdk_nvme_transport_id_compare(&p->trid, trid) == 0) { 5601 break; 5602 } 5603 } 5604 5605 return p; 5606 } 5607 5608 static void 5609 test_retry_failover_ctrlr(void) 5610 { 5611 struct spdk_nvme_transport_id trid1 = {}, trid2 = {}, trid3 = {}; 5612 struct spdk_nvme_ctrlr ctrlr = {}; 5613 struct nvme_ctrlr *nvme_ctrlr = NULL; 5614 struct nvme_path_id *path_id1, *path_id2, *path_id3; 5615 struct spdk_io_channel *ch; 5616 struct nvme_ctrlr_channel *ctrlr_ch; 5617 int rc; 5618 5619 ut_init_trid(&trid1); 5620 ut_init_trid2(&trid2); 5621 ut_init_trid3(&trid3); 5622 TAILQ_INIT(&ctrlr.active_io_qpairs); 5623 5624 set_thread(0); 5625 5626 rc = nvme_ctrlr_create(&ctrlr, "nvme0", &trid1, NULL); 5627 CU_ASSERT(rc == 0); 5628 5629 nvme_ctrlr = nvme_ctrlr_get_by_name("nvme0"); 5630 SPDK_CU_ASSERT_FATAL(nvme_ctrlr != NULL); 5631 5632 nvme_ctrlr->opts.ctrlr_loss_timeout_sec = -1; 5633 nvme_ctrlr->opts.reconnect_delay_sec = 1; 5634 5635 rc = bdev_nvme_add_secondary_trid(nvme_ctrlr, &ctrlr, &trid2); 5636 CU_ASSERT(rc == 0); 5637 5638 rc = bdev_nvme_add_secondary_trid(nvme_ctrlr, &ctrlr, &trid3); 5639 CU_ASSERT(rc == 0); 5640 5641 ch = spdk_get_io_channel(nvme_ctrlr); 5642 SPDK_CU_ASSERT_FATAL(ch != NULL); 5643 5644 ctrlr_ch = spdk_io_channel_get_ctx(ch); 5645 5646 path_id1 = ut_get_path_id_by_trid(nvme_ctrlr, &trid1); 5647 SPDK_CU_ASSERT_FATAL(path_id1 != NULL); 5648 CU_ASSERT(path_id1->is_failed == false); 5649 CU_ASSERT(path_id1 == nvme_ctrlr->active_path_id); 5650 5651 /* If reset failed and reconnect is scheduled, path_id is switched from trid1 to trid2. */ 5652 ctrlr.fail_reset = true; 5653 ctrlr.is_failed = true; 5654 5655 rc = bdev_nvme_reset(nvme_ctrlr); 5656 CU_ASSERT(rc == 0); 5657 5658 poll_threads(); 5659 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5660 poll_threads(); 5661 5662 CU_ASSERT(nvme_ctrlr->resetting == false); 5663 CU_ASSERT(ctrlr.is_failed == false); 5664 CU_ASSERT(ctrlr_ch->qpair->qpair == NULL); 5665 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5666 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == false); 5667 5668 CU_ASSERT(path_id1->is_failed == true); 5669 5670 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5671 poll_threads(); 5672 5673 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer != NULL); 5674 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == true); 5675 5676 path_id2 = ut_get_path_id_by_trid(nvme_ctrlr, &trid2); 5677 SPDK_CU_ASSERT_FATAL(path_id2 != NULL); 5678 CU_ASSERT(path_id2->is_failed == false); 5679 CU_ASSERT(path_id2 == nvme_ctrlr->active_path_id); 5680 5681 /* If we remove trid2 while reconnect is scheduled, trid2 is removed and path_id is 5682 * switched to trid3 but reset is not started. 5683 */ 5684 rc = bdev_nvme_failover(nvme_ctrlr, true); 5685 CU_ASSERT(rc == 0); 5686 5687 CU_ASSERT(ut_get_path_id_by_trid(nvme_ctrlr, &trid2) == NULL); 5688 5689 path_id3 = ut_get_path_id_by_trid(nvme_ctrlr, &trid3); 5690 SPDK_CU_ASSERT_FATAL(path_id3 != NULL); 5691 CU_ASSERT(path_id3->is_failed == false); 5692 CU_ASSERT(path_id3 == nvme_ctrlr->active_path_id); 5693 5694 CU_ASSERT(nvme_ctrlr->resetting == false); 5695 5696 /* If reconnect succeeds, trid3 should be the active path_id */ 5697 ctrlr.fail_reset = false; 5698 5699 spdk_delay_us(SPDK_SEC_TO_USEC); 5700 poll_thread_times(0, 1); 5701 5702 CU_ASSERT(nvme_ctrlr->resetting == true); 5703 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5704 5705 poll_threads(); 5706 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5707 poll_threads(); 5708 5709 CU_ASSERT(path_id3->is_failed == false); 5710 CU_ASSERT(path_id3 == nvme_ctrlr->active_path_id); 5711 CU_ASSERT(nvme_ctrlr->resetting == false); 5712 CU_ASSERT(ctrlr_ch->qpair->qpair != NULL); 5713 CU_ASSERT(nvme_ctrlr->reconnect_is_delayed == false); 5714 5715 spdk_put_io_channel(ch); 5716 5717 poll_threads(); 5718 5719 rc = bdev_nvme_delete("nvme0", &g_any_path); 5720 CU_ASSERT(rc == 0); 5721 5722 poll_threads(); 5723 spdk_delay_us(1000); 5724 poll_threads(); 5725 5726 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 5727 } 5728 5729 static void 5730 test_fail_path(void) 5731 { 5732 struct nvme_path_id path = {}; 5733 struct nvme_ctrlr_opts opts = {}; 5734 struct spdk_nvme_ctrlr *ctrlr; 5735 struct nvme_bdev_ctrlr *nbdev_ctrlr; 5736 struct nvme_ctrlr *nvme_ctrlr; 5737 const int STRING_SIZE = 32; 5738 const char *attached_names[STRING_SIZE]; 5739 struct nvme_bdev *bdev; 5740 struct nvme_ns *nvme_ns; 5741 struct spdk_bdev_io *bdev_io; 5742 struct spdk_io_channel *ch; 5743 struct nvme_bdev_channel *nbdev_ch; 5744 struct nvme_io_path *io_path; 5745 struct nvme_ctrlr_channel *ctrlr_ch; 5746 int rc; 5747 5748 /* The test scenario is the following. 5749 * - We set ctrlr_fail_timeout_sec to be smaller than ctrlr_loss_timeout_sec. 5750 * - Rresetting a ctrlr fails and reconnecting the ctrlr is repeated. 5751 * - While reconnecting the ctrlr, an I/O is submitted and queued. 5752 * - The I/O waits until the ctrlr is recovered but ctrlr_fail_timeout_sec 5753 * comes first. The queued I/O is failed. 5754 * - After ctrlr_fail_timeout_sec, any I/O is failed immediately. 5755 * - Then ctrlr_loss_timeout_sec comes and the ctrlr is deleted. 5756 */ 5757 5758 memset(attached_names, 0, sizeof(char *) * STRING_SIZE); 5759 ut_init_trid(&path.trid); 5760 5761 set_thread(0); 5762 5763 ctrlr = ut_attach_ctrlr(&path.trid, 1, false, false); 5764 SPDK_CU_ASSERT_FATAL(ctrlr != NULL); 5765 5766 g_ut_attach_ctrlr_status = 0; 5767 g_ut_attach_bdev_count = 1; 5768 5769 opts.ctrlr_loss_timeout_sec = 4; 5770 opts.reconnect_delay_sec = 1; 5771 opts.fast_io_fail_timeout_sec = 2; 5772 5773 rc = bdev_nvme_create(&path.trid, "nvme0", attached_names, STRING_SIZE, 5774 attach_ctrlr_done, NULL, NULL, &opts, false); 5775 CU_ASSERT(rc == 0); 5776 5777 spdk_delay_us(1000); 5778 poll_threads(); 5779 5780 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name("nvme0"); 5781 SPDK_CU_ASSERT_FATAL(nbdev_ctrlr != NULL); 5782 5783 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr(nbdev_ctrlr, &path.trid); 5784 CU_ASSERT(nvme_ctrlr != NULL); 5785 5786 bdev = nvme_bdev_ctrlr_get_bdev(nbdev_ctrlr, 1); 5787 CU_ASSERT(bdev != NULL); 5788 5789 nvme_ns = nvme_ctrlr_get_first_active_ns(nvme_ctrlr); 5790 CU_ASSERT(nvme_ns != NULL); 5791 5792 ch = spdk_get_io_channel(bdev); 5793 SPDK_CU_ASSERT_FATAL(ch != NULL); 5794 5795 nbdev_ch = spdk_io_channel_get_ctx(ch); 5796 5797 io_path = ut_get_io_path_by_ctrlr(nbdev_ch, nvme_ctrlr); 5798 SPDK_CU_ASSERT_FATAL(io_path != NULL); 5799 5800 ctrlr_ch = io_path->qpair->ctrlr_ch; 5801 SPDK_CU_ASSERT_FATAL(ctrlr_ch != NULL); 5802 SPDK_CU_ASSERT_FATAL(ctrlr_ch->qpair->qpair != NULL); 5803 5804 bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, ch); 5805 ut_bdev_io_set_buf(bdev_io); 5806 5807 5808 /* Resetting a ctrlr should fail and a reconnect timer should be registered. */ 5809 ctrlr->fail_reset = true; 5810 ctrlr->is_failed = true; 5811 5812 rc = bdev_nvme_reset(nvme_ctrlr); 5813 CU_ASSERT(rc == 0); 5814 CU_ASSERT(nvme_ctrlr->resetting == true); 5815 CU_ASSERT(ctrlr->is_failed == true); 5816 5817 poll_threads(); 5818 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5819 poll_threads(); 5820 5821 CU_ASSERT(nvme_ctrlr->resetting == false); 5822 CU_ASSERT(ctrlr->is_failed == false); 5823 CU_ASSERT(ctrlr_ch->qpair->qpair == NULL); 5824 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5825 CU_ASSERT(nvme_ctrlr->reset_start_tsc != 0); 5826 CU_ASSERT(nvme_ctrlr->fast_io_fail_timedout == false); 5827 5828 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5829 poll_threads(); 5830 5831 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer != NULL); 5832 5833 /* I/O should be queued. */ 5834 bdev_io->internal.in_submit_request = true; 5835 5836 bdev_nvme_submit_request(ch, bdev_io); 5837 5838 CU_ASSERT(bdev_io->internal.in_submit_request == true); 5839 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 5840 5841 /* After a second, the I/O should be still queued and the ctrlr should be 5842 * still recovering. 5843 */ 5844 spdk_delay_us(SPDK_SEC_TO_USEC); 5845 poll_threads(); 5846 5847 CU_ASSERT(bdev_io->internal.in_submit_request == true); 5848 CU_ASSERT(bdev_io == TAILQ_FIRST(&nbdev_ch->retry_io_list)); 5849 5850 CU_ASSERT(nvme_ctrlr->resetting == false); 5851 CU_ASSERT(ctrlr->is_failed == false); 5852 CU_ASSERT(ctrlr_ch->qpair->qpair == NULL); 5853 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5854 CU_ASSERT(bdev_nvme_check_ctrlr_loss_timeout(nvme_ctrlr) == false); 5855 CU_ASSERT(nvme_ctrlr->fast_io_fail_timedout == false); 5856 5857 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5858 poll_threads(); 5859 5860 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer != NULL); 5861 5862 /* After two seconds, ctrlr_fail_timeout_sec should expire. */ 5863 spdk_delay_us(SPDK_SEC_TO_USEC); 5864 poll_threads(); 5865 5866 CU_ASSERT(nvme_ctrlr->resetting == false); 5867 CU_ASSERT(ctrlr->is_failed == false); 5868 CU_ASSERT(ctrlr_ch->qpair->qpair == NULL); 5869 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer == NULL); 5870 CU_ASSERT(bdev_nvme_check_ctrlr_loss_timeout(nvme_ctrlr) == false); 5871 CU_ASSERT(nvme_ctrlr->fast_io_fail_timedout == true); 5872 5873 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5874 poll_threads(); 5875 5876 CU_ASSERT(nvme_ctrlr->reconnect_delay_timer != NULL); 5877 5878 /* Then within a second, pending I/O should be failed. */ 5879 spdk_delay_us(SPDK_SEC_TO_USEC); 5880 poll_threads(); 5881 5882 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5883 poll_threads(); 5884 5885 CU_ASSERT(bdev_io->internal.in_submit_request == false); 5886 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 5887 CU_ASSERT(TAILQ_EMPTY(&nbdev_ch->retry_io_list)); 5888 5889 /* Another I/O submission should be failed immediately. */ 5890 bdev_io->internal.in_submit_request = true; 5891 5892 bdev_nvme_submit_request(ch, bdev_io); 5893 5894 CU_ASSERT(bdev_io->internal.in_submit_request == false); 5895 CU_ASSERT(bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 5896 5897 /* After four seconds, path_loss_timeout_sec should expire and ctrlr should 5898 * be deleted. 5899 */ 5900 spdk_delay_us(SPDK_SEC_TO_USEC); 5901 poll_threads(); 5902 5903 spdk_delay_us(g_opts.nvme_adminq_poll_period_us); 5904 poll_threads(); 5905 5906 CU_ASSERT(nvme_ctrlr == nvme_ctrlr_get_by_name("nvme0")); 5907 CU_ASSERT(bdev_nvme_check_ctrlr_loss_timeout(nvme_ctrlr) == true); 5908 CU_ASSERT(nvme_ctrlr->destruct == true); 5909 5910 spdk_put_io_channel(ch); 5911 5912 poll_threads(); 5913 spdk_delay_us(1000); 5914 poll_threads(); 5915 5916 CU_ASSERT(nvme_ctrlr_get_by_name("nvme0") == NULL); 5917 5918 free(bdev_io); 5919 } 5920 5921 static void 5922 test_nvme_ns_cmp(void) 5923 { 5924 struct nvme_ns nvme_ns1 = {}, nvme_ns2 = {}; 5925 5926 nvme_ns1.id = 0; 5927 nvme_ns2.id = UINT32_MAX; 5928 5929 CU_ASSERT(nvme_ns_cmp(&nvme_ns1, &nvme_ns2) < 0); 5930 CU_ASSERT(nvme_ns_cmp(&nvme_ns2, &nvme_ns1) > 0); 5931 } 5932 5933 int 5934 main(int argc, const char **argv) 5935 { 5936 CU_pSuite suite = NULL; 5937 unsigned int num_failures; 5938 5939 CU_set_error_action(CUEA_ABORT); 5940 CU_initialize_registry(); 5941 5942 suite = CU_add_suite("nvme", NULL, NULL); 5943 5944 CU_ADD_TEST(suite, test_create_ctrlr); 5945 CU_ADD_TEST(suite, test_reset_ctrlr); 5946 CU_ADD_TEST(suite, test_race_between_reset_and_destruct_ctrlr); 5947 CU_ADD_TEST(suite, test_failover_ctrlr); 5948 CU_ADD_TEST(suite, test_race_between_failover_and_add_secondary_trid); 5949 CU_ADD_TEST(suite, test_pending_reset); 5950 CU_ADD_TEST(suite, test_attach_ctrlr); 5951 CU_ADD_TEST(suite, test_aer_cb); 5952 CU_ADD_TEST(suite, test_submit_nvme_cmd); 5953 CU_ADD_TEST(suite, test_add_remove_trid); 5954 CU_ADD_TEST(suite, test_abort); 5955 CU_ADD_TEST(suite, test_get_io_qpair); 5956 CU_ADD_TEST(suite, test_bdev_unregister); 5957 CU_ADD_TEST(suite, test_compare_ns); 5958 CU_ADD_TEST(suite, test_init_ana_log_page); 5959 CU_ADD_TEST(suite, test_get_memory_domains); 5960 CU_ADD_TEST(suite, test_reconnect_qpair); 5961 CU_ADD_TEST(suite, test_create_bdev_ctrlr); 5962 CU_ADD_TEST(suite, test_add_multi_ns_to_bdev); 5963 CU_ADD_TEST(suite, test_add_multi_io_paths_to_nbdev_ch); 5964 CU_ADD_TEST(suite, test_admin_path); 5965 CU_ADD_TEST(suite, test_reset_bdev_ctrlr); 5966 CU_ADD_TEST(suite, test_find_io_path); 5967 CU_ADD_TEST(suite, test_retry_io_if_ana_state_is_updating); 5968 CU_ADD_TEST(suite, test_retry_io_for_io_path_error); 5969 CU_ADD_TEST(suite, test_retry_io_count); 5970 CU_ADD_TEST(suite, test_concurrent_read_ana_log_page); 5971 CU_ADD_TEST(suite, test_retry_io_for_ana_error); 5972 CU_ADD_TEST(suite, test_retry_admin_passthru_for_path_error); 5973 CU_ADD_TEST(suite, test_retry_admin_passthru_by_count); 5974 CU_ADD_TEST(suite, test_check_multipath_params); 5975 CU_ADD_TEST(suite, test_retry_io_if_ctrlr_is_resetting); 5976 CU_ADD_TEST(suite, test_retry_admin_passthru_if_ctrlr_is_resetting); 5977 CU_ADD_TEST(suite, test_reconnect_ctrlr); 5978 CU_ADD_TEST(suite, test_retry_failover_ctrlr); 5979 CU_ADD_TEST(suite, test_fail_path); 5980 CU_ADD_TEST(suite, test_nvme_ns_cmp); 5981 5982 CU_basic_set_mode(CU_BRM_VERBOSE); 5983 5984 allocate_threads(3); 5985 set_thread(0); 5986 bdev_nvme_library_init(); 5987 init_accel(); 5988 5989 CU_basic_run_tests(); 5990 5991 set_thread(0); 5992 bdev_nvme_library_fini(); 5993 fini_accel(); 5994 free_threads(); 5995 5996 num_failures = CU_get_number_of_failures(); 5997 CU_cleanup_registry(); 5998 5999 return num_failures; 6000 } 6001