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