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