1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "spdk_cunit.h" 37 #include "spdk_internal/mock.h" 38 #include "spdk_internal/thread.h" 39 40 #include "common/lib/ut_multithread.c" 41 #include "nvmf/ctrlr.c" 42 43 SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) 44 45 struct spdk_bdev { 46 int ut_mock; 47 uint64_t blockcnt; 48 }; 49 50 DEFINE_STUB(spdk_nvmf_tgt_find_subsystem, 51 struct spdk_nvmf_subsystem *, 52 (struct spdk_nvmf_tgt *tgt, const char *subnqn), 53 NULL); 54 55 DEFINE_STUB(spdk_nvmf_poll_group_create, 56 struct spdk_nvmf_poll_group *, 57 (struct spdk_nvmf_tgt *tgt), 58 NULL); 59 60 DEFINE_STUB(spdk_nvmf_subsystem_get_sn, 61 const char *, 62 (const struct spdk_nvmf_subsystem *subsystem), 63 NULL); 64 65 DEFINE_STUB(spdk_nvmf_subsystem_get_mn, 66 const char *, 67 (const struct spdk_nvmf_subsystem *subsystem), 68 NULL); 69 70 DEFINE_STUB(spdk_nvmf_subsystem_get_first_ns, 71 struct spdk_nvmf_ns *, 72 (struct spdk_nvmf_subsystem *subsystem), 73 NULL); 74 75 DEFINE_STUB(spdk_nvmf_subsystem_get_next_ns, 76 struct spdk_nvmf_ns *, 77 (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ns *prev_ns), 78 NULL); 79 80 DEFINE_STUB(spdk_nvmf_subsystem_host_allowed, 81 bool, 82 (struct spdk_nvmf_subsystem *subsystem, const char *hostnqn), 83 true); 84 85 DEFINE_STUB(spdk_nvmf_subsystem_add_ctrlr, 86 int, 87 (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr), 88 0); 89 90 DEFINE_STUB(spdk_nvmf_subsystem_get_ctrlr, 91 struct spdk_nvmf_ctrlr *, 92 (struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid), 93 NULL); 94 95 DEFINE_STUB(spdk_nvmf_ctrlr_dsm_supported, 96 bool, 97 (struct spdk_nvmf_ctrlr *ctrlr), 98 false); 99 100 DEFINE_STUB(spdk_nvmf_ctrlr_write_zeroes_supported, 101 bool, 102 (struct spdk_nvmf_ctrlr *ctrlr), 103 false); 104 105 DEFINE_STUB_V(spdk_nvmf_get_discovery_log_page, 106 (struct spdk_nvmf_tgt *tgt, struct iovec *iov, uint32_t iovcnt, uint64_t offset, uint32_t length)); 107 108 DEFINE_STUB(spdk_nvmf_qpair_get_listen_trid, 109 int, 110 (struct spdk_nvmf_qpair *qpair, struct spdk_nvme_transport_id *trid), 111 0); 112 113 DEFINE_STUB(spdk_nvmf_subsystem_listener_allowed, 114 bool, 115 (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvme_transport_id *trid), 116 true); 117 118 DEFINE_STUB(spdk_nvmf_transport_qpair_set_sqsize, 119 int, 120 (struct spdk_nvmf_qpair *qpair), 121 0); 122 123 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_read_cmd, 124 int, 125 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 126 struct spdk_nvmf_request *req), 127 0); 128 129 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_write_cmd, 130 int, 131 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 132 struct spdk_nvmf_request *req), 133 0); 134 135 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_write_zeroes_cmd, 136 int, 137 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 138 struct spdk_nvmf_request *req), 139 0); 140 141 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_flush_cmd, 142 int, 143 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 144 struct spdk_nvmf_request *req), 145 0); 146 147 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_dsm_cmd, 148 int, 149 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 150 struct spdk_nvmf_request *req), 151 0); 152 153 DEFINE_STUB(spdk_nvmf_bdev_ctrlr_nvme_passthru_io, 154 int, 155 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 156 struct spdk_nvmf_request *req), 157 0); 158 159 DEFINE_STUB(spdk_nvmf_transport_req_complete, 160 int, 161 (struct spdk_nvmf_request *req), 162 0); 163 164 DEFINE_STUB_V(spdk_nvmf_ns_reservation_request, (void *ctx)); 165 166 int 167 spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) 168 { 169 return 0; 170 } 171 172 void 173 spdk_nvmf_bdev_ctrlr_identify_ns(struct spdk_nvmf_ns *ns, struct spdk_nvme_ns_data *nsdata) 174 { 175 uint64_t num_blocks; 176 177 SPDK_CU_ASSERT_FATAL(ns->bdev != NULL); 178 num_blocks = ns->bdev->blockcnt; 179 nsdata->nsze = num_blocks; 180 nsdata->ncap = num_blocks; 181 nsdata->nuse = num_blocks; 182 nsdata->nlbaf = 0; 183 nsdata->flbas.format = 0; 184 nsdata->lbaf[0].lbads = spdk_u32log2(512); 185 } 186 187 static void 188 test_get_log_page(void) 189 { 190 struct spdk_nvmf_subsystem subsystem = {}; 191 struct spdk_nvmf_request req = {}; 192 struct spdk_nvmf_qpair qpair = {}; 193 struct spdk_nvmf_ctrlr ctrlr = {}; 194 union nvmf_h2c_msg cmd = {}; 195 union nvmf_c2h_msg rsp = {}; 196 char data[4096]; 197 198 subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; 199 200 ctrlr.subsys = &subsystem; 201 202 qpair.ctrlr = &ctrlr; 203 204 req.qpair = &qpair; 205 req.cmd = &cmd; 206 req.rsp = &rsp; 207 req.data = &data; 208 req.length = sizeof(data); 209 210 /* Get Log Page - all valid */ 211 memset(&cmd, 0, sizeof(cmd)); 212 memset(&rsp, 0, sizeof(rsp)); 213 cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; 214 cmd.nvme_cmd.cdw10 = SPDK_NVME_LOG_ERROR | (req.length / 4 - 1) << 16; 215 CU_ASSERT(spdk_nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 216 CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 217 CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 218 219 /* Get Log Page with invalid log ID */ 220 memset(&cmd, 0, sizeof(cmd)); 221 memset(&rsp, 0, sizeof(rsp)); 222 cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; 223 cmd.nvme_cmd.cdw10 = 0; 224 CU_ASSERT(spdk_nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 225 CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 226 CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); 227 228 /* Get Log Page with invalid offset (not dword aligned) */ 229 memset(&cmd, 0, sizeof(cmd)); 230 memset(&rsp, 0, sizeof(rsp)); 231 cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; 232 cmd.nvme_cmd.cdw10 = SPDK_NVME_LOG_ERROR | (req.length / 4 - 1) << 16; 233 cmd.nvme_cmd.cdw12 = 2; 234 CU_ASSERT(spdk_nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 235 CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 236 CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); 237 238 /* Get Log Page without data buffer */ 239 memset(&cmd, 0, sizeof(cmd)); 240 memset(&rsp, 0, sizeof(rsp)); 241 req.data = NULL; 242 cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; 243 cmd.nvme_cmd.cdw10 = SPDK_NVME_LOG_ERROR | (req.length / 4 - 1) << 16; 244 CU_ASSERT(spdk_nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 245 CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 246 CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); 247 req.data = data; 248 } 249 250 static void 251 test_process_fabrics_cmd(void) 252 { 253 struct spdk_nvmf_request req = {}; 254 int ret; 255 struct spdk_nvmf_qpair req_qpair = {}; 256 union nvmf_h2c_msg req_cmd = {}; 257 union nvmf_c2h_msg req_rsp = {}; 258 259 req.qpair = &req_qpair; 260 req.cmd = &req_cmd; 261 req.rsp = &req_rsp; 262 req.qpair->ctrlr = NULL; 263 264 /* No ctrlr and invalid command check */ 265 req.cmd->nvmf_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET; 266 ret = spdk_nvmf_ctrlr_process_fabrics_cmd(&req); 267 CU_ASSERT_EQUAL(req.rsp->nvme_cpl.status.sc, SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR); 268 CU_ASSERT_EQUAL(ret, SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 269 } 270 271 static bool 272 nvme_status_success(const struct spdk_nvme_status *status) 273 { 274 return status->sct == SPDK_NVME_SCT_GENERIC && status->sc == SPDK_NVME_SC_SUCCESS; 275 } 276 277 static void 278 test_connect(void) 279 { 280 struct spdk_nvmf_fabric_connect_data connect_data; 281 struct spdk_nvmf_poll_group group; 282 struct spdk_nvmf_subsystem_poll_group *sgroups; 283 struct spdk_nvmf_transport transport; 284 struct spdk_nvmf_subsystem subsystem; 285 struct spdk_nvmf_request req; 286 struct spdk_nvmf_qpair admin_qpair; 287 struct spdk_nvmf_qpair qpair; 288 struct spdk_nvmf_qpair qpair2; 289 struct spdk_nvmf_ctrlr ctrlr; 290 struct spdk_nvmf_tgt tgt; 291 union nvmf_h2c_msg cmd; 292 union nvmf_c2h_msg rsp; 293 const uint8_t hostid[16] = { 294 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 295 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 296 }; 297 const char subnqn[] = "nqn.2016-06.io.spdk:subsystem1"; 298 const char hostnqn[] = "nqn.2016-06.io.spdk:host1"; 299 int rc; 300 301 memset(&group, 0, sizeof(group)); 302 group.thread = spdk_get_thread(); 303 304 memset(&ctrlr, 0, sizeof(ctrlr)); 305 ctrlr.subsys = &subsystem; 306 ctrlr.qpair_mask = spdk_bit_array_create(3); 307 SPDK_CU_ASSERT_FATAL(ctrlr.qpair_mask != NULL); 308 ctrlr.vcprop.cc.bits.en = 1; 309 ctrlr.vcprop.cc.bits.iosqes = 6; 310 ctrlr.vcprop.cc.bits.iocqes = 4; 311 312 memset(&admin_qpair, 0, sizeof(admin_qpair)); 313 admin_qpair.group = &group; 314 315 memset(&tgt, 0, sizeof(tgt)); 316 memset(&transport, 0, sizeof(transport)); 317 transport.opts.max_aq_depth = 32; 318 transport.opts.max_queue_depth = 64; 319 transport.opts.max_qpairs_per_ctrlr = 3; 320 transport.tgt = &tgt; 321 322 memset(&qpair, 0, sizeof(qpair)); 323 qpair.transport = &transport; 324 qpair.group = &group; 325 qpair.state = SPDK_NVMF_QPAIR_ACTIVE; 326 TAILQ_INIT(&qpair.outstanding); 327 328 memset(&connect_data, 0, sizeof(connect_data)); 329 memcpy(connect_data.hostid, hostid, sizeof(hostid)); 330 connect_data.cntlid = 0xFFFF; 331 snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn); 332 snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn); 333 334 memset(&subsystem, 0, sizeof(subsystem)); 335 subsystem.thread = spdk_get_thread(); 336 subsystem.id = 1; 337 TAILQ_INIT(&subsystem.ctrlrs); 338 subsystem.tgt = &tgt; 339 subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; 340 subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 341 snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn); 342 343 sgroups = calloc(subsystem.id + 1, sizeof(struct spdk_nvmf_subsystem_poll_group)); 344 sgroups[subsystem.id].io_outstanding = 5; 345 group.sgroups = sgroups; 346 347 memset(&cmd, 0, sizeof(cmd)); 348 cmd.connect_cmd.opcode = SPDK_NVME_OPC_FABRIC; 349 cmd.connect_cmd.cid = 1; 350 cmd.connect_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT; 351 cmd.connect_cmd.recfmt = 0; 352 cmd.connect_cmd.qid = 0; 353 cmd.connect_cmd.sqsize = 31; 354 cmd.connect_cmd.cattr = 0; 355 cmd.connect_cmd.kato = 120000; 356 357 memset(&req, 0, sizeof(req)); 358 req.qpair = &qpair; 359 req.length = sizeof(connect_data); 360 req.xfer = SPDK_NVME_DATA_HOST_TO_CONTROLLER; 361 req.data = &connect_data; 362 req.cmd = &cmd; 363 req.rsp = &rsp; 364 365 MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem); 366 MOCK_SET(spdk_nvmf_poll_group_create, &group); 367 368 /* Valid admin connect command */ 369 memset(&rsp, 0, sizeof(rsp)); 370 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 371 rc = spdk_nvmf_ctrlr_connect(&req); 372 poll_threads(); 373 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 374 CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); 375 CU_ASSERT(qpair.ctrlr != NULL); 376 spdk_nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr); 377 spdk_bit_array_free(&qpair.ctrlr->qpair_mask); 378 free(qpair.ctrlr); 379 qpair.ctrlr = NULL; 380 381 /* Valid admin connect command with kato = 0 */ 382 cmd.connect_cmd.kato = 0; 383 memset(&rsp, 0, sizeof(rsp)); 384 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 385 rc = spdk_nvmf_ctrlr_connect(&req); 386 poll_threads(); 387 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 388 CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); 389 CU_ASSERT(qpair.ctrlr != NULL && qpair.ctrlr->keep_alive_poller == NULL); 390 spdk_bit_array_free(&qpair.ctrlr->qpair_mask); 391 free(qpair.ctrlr); 392 qpair.ctrlr = NULL; 393 cmd.connect_cmd.kato = 120000; 394 395 /* Invalid data length */ 396 memset(&rsp, 0, sizeof(rsp)); 397 req.length = sizeof(connect_data) - 1; 398 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 399 rc = spdk_nvmf_ctrlr_connect(&req); 400 poll_threads(); 401 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 402 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 403 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); 404 CU_ASSERT(qpair.ctrlr == NULL); 405 req.length = sizeof(connect_data); 406 407 /* Invalid recfmt */ 408 memset(&rsp, 0, sizeof(rsp)); 409 cmd.connect_cmd.recfmt = 1234; 410 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 411 rc = spdk_nvmf_ctrlr_connect(&req); 412 poll_threads(); 413 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 414 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 415 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INCOMPATIBLE_FORMAT); 416 CU_ASSERT(qpair.ctrlr == NULL); 417 cmd.connect_cmd.recfmt = 0; 418 419 /* Unterminated subnqn */ 420 memset(&rsp, 0, sizeof(rsp)); 421 memset(connect_data.subnqn, 'a', sizeof(connect_data.subnqn)); 422 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 423 rc = spdk_nvmf_ctrlr_connect(&req); 424 poll_threads(); 425 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 426 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 427 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 428 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 429 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 256); 430 CU_ASSERT(qpair.ctrlr == NULL); 431 snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn); 432 433 /* Subsystem not found */ 434 memset(&rsp, 0, sizeof(rsp)); 435 MOCK_SET(spdk_nvmf_tgt_find_subsystem, NULL); 436 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 437 rc = spdk_nvmf_ctrlr_connect(&req); 438 poll_threads(); 439 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 440 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 441 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 442 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 443 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 256); 444 CU_ASSERT(qpair.ctrlr == NULL); 445 MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem); 446 447 /* Unterminated hostnqn */ 448 memset(&rsp, 0, sizeof(rsp)); 449 memset(connect_data.hostnqn, 'b', sizeof(connect_data.hostnqn)); 450 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 451 rc = spdk_nvmf_ctrlr_connect(&req); 452 poll_threads(); 453 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 454 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 455 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 456 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 457 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 512); 458 CU_ASSERT(qpair.ctrlr == NULL); 459 snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn); 460 461 /* Host not allowed */ 462 memset(&rsp, 0, sizeof(rsp)); 463 MOCK_SET(spdk_nvmf_subsystem_host_allowed, false); 464 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 465 rc = spdk_nvmf_ctrlr_connect(&req); 466 poll_threads(); 467 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 468 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 469 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_HOST); 470 CU_ASSERT(qpair.ctrlr == NULL); 471 MOCK_SET(spdk_nvmf_subsystem_host_allowed, true); 472 473 /* Invalid sqsize == 0 */ 474 memset(&rsp, 0, sizeof(rsp)); 475 cmd.connect_cmd.sqsize = 0; 476 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 477 rc = spdk_nvmf_ctrlr_connect(&req); 478 poll_threads(); 479 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 480 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 481 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 482 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 483 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44); 484 CU_ASSERT(qpair.ctrlr == NULL); 485 cmd.connect_cmd.sqsize = 31; 486 487 /* Invalid sqsize > max_queue_depth */ 488 memset(&rsp, 0, sizeof(rsp)); 489 cmd.connect_cmd.sqsize = 64; 490 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 491 rc = spdk_nvmf_ctrlr_connect(&req); 492 poll_threads(); 493 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 494 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 495 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 496 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 497 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44); 498 CU_ASSERT(qpair.ctrlr == NULL); 499 cmd.connect_cmd.sqsize = 31; 500 501 /* Invalid cntlid for admin queue */ 502 memset(&rsp, 0, sizeof(rsp)); 503 connect_data.cntlid = 0x1234; 504 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 505 rc = spdk_nvmf_ctrlr_connect(&req); 506 poll_threads(); 507 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 508 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 509 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 510 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 511 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16); 512 CU_ASSERT(qpair.ctrlr == NULL); 513 connect_data.cntlid = 0xFFFF; 514 515 ctrlr.admin_qpair = &admin_qpair; 516 ctrlr.subsys = &subsystem; 517 518 /* Valid I/O queue connect command */ 519 memset(&rsp, 0, sizeof(rsp)); 520 MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, &ctrlr); 521 cmd.connect_cmd.qid = 1; 522 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 523 rc = spdk_nvmf_ctrlr_connect(&req); 524 poll_threads(); 525 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 526 CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); 527 CU_ASSERT(qpair.ctrlr == &ctrlr); 528 qpair.ctrlr = NULL; 529 530 /* Non-existent controller */ 531 memset(&rsp, 0, sizeof(rsp)); 532 MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, NULL); 533 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 534 rc = spdk_nvmf_ctrlr_connect(&req); 535 poll_threads(); 536 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 537 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 538 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 539 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 540 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16); 541 CU_ASSERT(qpair.ctrlr == NULL); 542 MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, &ctrlr); 543 544 /* I/O connect to discovery controller */ 545 memset(&rsp, 0, sizeof(rsp)); 546 subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY; 547 subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 548 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 549 rc = spdk_nvmf_ctrlr_connect(&req); 550 poll_threads(); 551 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 552 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 553 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 554 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 555 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 556 CU_ASSERT(qpair.ctrlr == NULL); 557 558 /* I/O connect to discovery controller keep-alive-timeout should be 0 */ 559 cmd.connect_cmd.qid = 0; 560 memset(&rsp, 0, sizeof(rsp)); 561 subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY; 562 subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 563 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 564 rc = spdk_nvmf_ctrlr_connect(&req); 565 poll_threads(); 566 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 567 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 568 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INTERNAL_DEVICE_ERROR); 569 CU_ASSERT(qpair.ctrlr == NULL); 570 cmd.connect_cmd.qid = 1; 571 subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; 572 573 /* I/O connect to disabled controller */ 574 memset(&rsp, 0, sizeof(rsp)); 575 ctrlr.vcprop.cc.bits.en = 0; 576 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 577 rc = spdk_nvmf_ctrlr_connect(&req); 578 poll_threads(); 579 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 580 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 581 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 582 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 583 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 584 CU_ASSERT(qpair.ctrlr == NULL); 585 ctrlr.vcprop.cc.bits.en = 1; 586 587 /* I/O connect with invalid IOSQES */ 588 memset(&rsp, 0, sizeof(rsp)); 589 ctrlr.vcprop.cc.bits.iosqes = 3; 590 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 591 rc = spdk_nvmf_ctrlr_connect(&req); 592 poll_threads(); 593 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 594 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 595 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 596 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 597 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 598 CU_ASSERT(qpair.ctrlr == NULL); 599 ctrlr.vcprop.cc.bits.iosqes = 6; 600 601 /* I/O connect with invalid IOCQES */ 602 memset(&rsp, 0, sizeof(rsp)); 603 ctrlr.vcprop.cc.bits.iocqes = 3; 604 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 605 rc = spdk_nvmf_ctrlr_connect(&req); 606 poll_threads(); 607 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 608 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 609 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 610 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 611 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 612 CU_ASSERT(qpair.ctrlr == NULL); 613 ctrlr.vcprop.cc.bits.iocqes = 4; 614 615 /* I/O connect with too many existing qpairs */ 616 memset(&rsp, 0, sizeof(rsp)); 617 spdk_bit_array_set(ctrlr.qpair_mask, 0); 618 spdk_bit_array_set(ctrlr.qpair_mask, 1); 619 spdk_bit_array_set(ctrlr.qpair_mask, 2); 620 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 621 rc = spdk_nvmf_ctrlr_connect(&req); 622 poll_threads(); 623 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 624 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 625 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER); 626 CU_ASSERT(qpair.ctrlr == NULL); 627 spdk_bit_array_clear(ctrlr.qpair_mask, 0); 628 spdk_bit_array_clear(ctrlr.qpair_mask, 1); 629 spdk_bit_array_clear(ctrlr.qpair_mask, 2); 630 631 /* I/O connect with duplicate queue ID */ 632 memset(&rsp, 0, sizeof(rsp)); 633 memset(&qpair2, 0, sizeof(qpair2)); 634 qpair2.group = &group; 635 qpair2.qid = 1; 636 spdk_bit_array_set(ctrlr.qpair_mask, 1); 637 cmd.connect_cmd.qid = 1; 638 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 639 rc = spdk_nvmf_ctrlr_connect(&req); 640 poll_threads(); 641 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 642 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 643 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER); 644 CU_ASSERT(qpair.ctrlr == NULL); 645 646 /* Clean up globals */ 647 MOCK_CLEAR(spdk_nvmf_tgt_find_subsystem); 648 MOCK_CLEAR(spdk_nvmf_poll_group_create); 649 650 spdk_bit_array_free(&ctrlr.qpair_mask); 651 free(sgroups); 652 } 653 654 static void 655 test_get_ns_id_desc_list(void) 656 { 657 struct spdk_nvmf_subsystem subsystem; 658 struct spdk_nvmf_qpair qpair; 659 struct spdk_nvmf_ctrlr ctrlr; 660 struct spdk_nvmf_request req; 661 struct spdk_nvmf_ns *ns_ptrs[1]; 662 struct spdk_nvmf_ns ns; 663 union nvmf_h2c_msg cmd; 664 union nvmf_c2h_msg rsp; 665 struct spdk_bdev bdev; 666 uint8_t buf[4096]; 667 668 memset(&subsystem, 0, sizeof(subsystem)); 669 ns_ptrs[0] = &ns; 670 subsystem.ns = ns_ptrs; 671 subsystem.max_nsid = 1; 672 subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; 673 674 memset(&ns, 0, sizeof(ns)); 675 ns.opts.nsid = 1; 676 ns.bdev = &bdev; 677 678 memset(&qpair, 0, sizeof(qpair)); 679 qpair.ctrlr = &ctrlr; 680 681 memset(&ctrlr, 0, sizeof(ctrlr)); 682 ctrlr.subsys = &subsystem; 683 ctrlr.vcprop.cc.bits.en = 1; 684 685 memset(&req, 0, sizeof(req)); 686 req.qpair = &qpair; 687 req.cmd = &cmd; 688 req.rsp = &rsp; 689 req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST; 690 req.data = buf; 691 req.length = sizeof(buf); 692 693 memset(&cmd, 0, sizeof(cmd)); 694 cmd.nvme_cmd.opc = SPDK_NVME_OPC_IDENTIFY; 695 cmd.nvme_cmd.cdw10 = SPDK_NVME_IDENTIFY_NS_ID_DESCRIPTOR_LIST; 696 697 /* Invalid NSID */ 698 cmd.nvme_cmd.nsid = 0; 699 memset(&rsp, 0, sizeof(rsp)); 700 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 701 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 702 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 703 704 /* Valid NSID, but ns has no IDs defined */ 705 cmd.nvme_cmd.nsid = 1; 706 memset(&rsp, 0, sizeof(rsp)); 707 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 708 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 709 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 710 CU_ASSERT(spdk_mem_all_zero(buf, sizeof(buf))); 711 712 /* Valid NSID, only EUI64 defined */ 713 ns.opts.eui64[0] = 0x11; 714 ns.opts.eui64[7] = 0xFF; 715 memset(&rsp, 0, sizeof(rsp)); 716 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 717 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 718 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 719 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); 720 CU_ASSERT(buf[1] == 8); 721 CU_ASSERT(buf[4] == 0x11); 722 CU_ASSERT(buf[11] == 0xFF); 723 CU_ASSERT(buf[13] == 0); 724 725 /* Valid NSID, only NGUID defined */ 726 memset(ns.opts.eui64, 0, sizeof(ns.opts.eui64)); 727 ns.opts.nguid[0] = 0x22; 728 ns.opts.nguid[15] = 0xEE; 729 memset(&rsp, 0, sizeof(rsp)); 730 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 731 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 732 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 733 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_NGUID); 734 CU_ASSERT(buf[1] == 16); 735 CU_ASSERT(buf[4] == 0x22); 736 CU_ASSERT(buf[19] == 0xEE); 737 CU_ASSERT(buf[21] == 0); 738 739 /* Valid NSID, both EUI64 and NGUID defined */ 740 ns.opts.eui64[0] = 0x11; 741 ns.opts.eui64[7] = 0xFF; 742 ns.opts.nguid[0] = 0x22; 743 ns.opts.nguid[15] = 0xEE; 744 memset(&rsp, 0, sizeof(rsp)); 745 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 746 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 747 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 748 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); 749 CU_ASSERT(buf[1] == 8); 750 CU_ASSERT(buf[4] == 0x11); 751 CU_ASSERT(buf[11] == 0xFF); 752 CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID); 753 CU_ASSERT(buf[13] == 16); 754 CU_ASSERT(buf[16] == 0x22); 755 CU_ASSERT(buf[31] == 0xEE); 756 CU_ASSERT(buf[33] == 0); 757 758 /* Valid NSID, EUI64, NGUID, and UUID defined */ 759 ns.opts.eui64[0] = 0x11; 760 ns.opts.eui64[7] = 0xFF; 761 ns.opts.nguid[0] = 0x22; 762 ns.opts.nguid[15] = 0xEE; 763 ns.opts.uuid.u.raw[0] = 0x33; 764 ns.opts.uuid.u.raw[15] = 0xDD; 765 memset(&rsp, 0, sizeof(rsp)); 766 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 767 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 768 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 769 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); 770 CU_ASSERT(buf[1] == 8); 771 CU_ASSERT(buf[4] == 0x11); 772 CU_ASSERT(buf[11] == 0xFF); 773 CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID); 774 CU_ASSERT(buf[13] == 16); 775 CU_ASSERT(buf[16] == 0x22); 776 CU_ASSERT(buf[31] == 0xEE); 777 CU_ASSERT(buf[32] == SPDK_NVME_NIDT_UUID); 778 CU_ASSERT(buf[33] == 16); 779 CU_ASSERT(buf[36] == 0x33); 780 CU_ASSERT(buf[51] == 0xDD); 781 CU_ASSERT(buf[53] == 0); 782 } 783 784 static void 785 test_identify_ns(void) 786 { 787 struct spdk_nvmf_subsystem subsystem = {}; 788 struct spdk_nvmf_transport transport = {}; 789 struct spdk_nvmf_qpair admin_qpair = { .transport = &transport}; 790 struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair }; 791 struct spdk_nvme_cmd cmd = {}; 792 struct spdk_nvme_cpl rsp = {}; 793 struct spdk_nvme_ns_data nsdata = {}; 794 struct spdk_bdev bdev[3] = {{.blockcnt = 1234}, {.blockcnt = 0}, {.blockcnt = 5678}}; 795 struct spdk_nvmf_ns ns[3] = {{.bdev = &bdev[0]}, {.bdev = NULL}, {.bdev = &bdev[2]}}; 796 struct spdk_nvmf_ns *ns_arr[3] = {&ns[0], NULL, &ns[2]}; 797 798 subsystem.ns = ns_arr; 799 subsystem.max_nsid = SPDK_COUNTOF(ns_arr); 800 801 /* Invalid NSID 0 */ 802 cmd.nsid = 0; 803 memset(&nsdata, 0, sizeof(nsdata)); 804 memset(&rsp, 0, sizeof(rsp)); 805 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 806 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 807 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 808 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 809 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 810 811 /* Valid NSID 1 */ 812 cmd.nsid = 1; 813 memset(&nsdata, 0, sizeof(nsdata)); 814 memset(&rsp, 0, sizeof(rsp)); 815 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 816 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 817 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 818 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); 819 CU_ASSERT(nsdata.nsze == 1234); 820 821 /* Valid but inactive NSID 2 */ 822 cmd.nsid = 2; 823 memset(&nsdata, 0, sizeof(nsdata)); 824 memset(&rsp, 0, sizeof(rsp)); 825 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 826 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 827 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 828 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); 829 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 830 831 /* Valid NSID 3 */ 832 cmd.nsid = 3; 833 memset(&nsdata, 0, sizeof(nsdata)); 834 memset(&rsp, 0, sizeof(rsp)); 835 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 836 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 837 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 838 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); 839 CU_ASSERT(nsdata.nsze == 5678); 840 841 /* Invalid NSID 4 */ 842 cmd.nsid = 4; 843 memset(&nsdata, 0, sizeof(nsdata)); 844 memset(&rsp, 0, sizeof(rsp)); 845 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 846 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 847 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 848 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 849 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 850 851 /* Invalid NSID 0xFFFFFFFF (NS management not supported) */ 852 cmd.nsid = 0xFFFFFFFF; 853 memset(&nsdata, 0, sizeof(nsdata)); 854 memset(&rsp, 0, sizeof(rsp)); 855 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 856 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 857 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 858 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 859 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 860 } 861 862 /* 863 * Reservation Unit Test Configuration 864 * -------- -------- -------- 865 * | Host A | | Host B | | Host C | 866 * -------- -------- -------- 867 * / \ | | 868 * -------- -------- ------- ------- 869 * |Ctrlr1_A| |Ctrlr2_A| |Ctrlr_B| |Ctrlr_C| 870 * -------- -------- ------- ------- 871 * \ \ / / 872 * \ \ / / 873 * \ \ / / 874 * -------------------------------------- 875 * | NAMESPACE 1 | 876 * -------------------------------------- 877 */ 878 879 static struct spdk_nvmf_ctrlr g_ctrlr1_A, g_ctrlr2_A, g_ctrlr_B, g_ctrlr_C; 880 struct spdk_nvmf_subsystem_pg_ns_info g_ns_info; 881 882 static void 883 ut_reservation_init(enum spdk_nvme_reservation_type rtype) 884 { 885 /* Host A has two controllers */ 886 spdk_uuid_generate(&g_ctrlr1_A.hostid); 887 spdk_uuid_copy(&g_ctrlr2_A.hostid, &g_ctrlr1_A.hostid); 888 889 /* Host B has 1 controller */ 890 spdk_uuid_generate(&g_ctrlr_B.hostid); 891 892 /* Host C has 1 controller */ 893 spdk_uuid_generate(&g_ctrlr_C.hostid); 894 895 memset(&g_ns_info, 0, sizeof(g_ns_info)); 896 g_ns_info.rtype = rtype; 897 g_ns_info.reg_hostid[0] = g_ctrlr1_A.hostid; 898 g_ns_info.reg_hostid[1] = g_ctrlr_B.hostid; 899 g_ns_info.reg_hostid[2] = g_ctrlr_C.hostid; 900 } 901 902 static void 903 test_reservation_write_exclusive(void) 904 { 905 struct spdk_nvmf_request req = {}; 906 union nvmf_h2c_msg cmd = {}; 907 union nvmf_c2h_msg rsp = {}; 908 int rc; 909 910 req.cmd = &cmd; 911 req.rsp = &rsp; 912 913 /* Host A holds reservation with type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE */ 914 ut_reservation_init(SPDK_NVME_RESERVE_WRITE_EXCLUSIVE); 915 g_ns_info.holder_id = g_ctrlr1_A.hostid; 916 917 /* Test Case: Issue a Read command from Host A and Host B */ 918 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 919 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 920 SPDK_CU_ASSERT_FATAL(rc == 0); 921 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 922 SPDK_CU_ASSERT_FATAL(rc == 0); 923 924 /* Test Case: Issue a DSM Write command from Host A and Host B */ 925 cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT; 926 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 927 SPDK_CU_ASSERT_FATAL(rc == 0); 928 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 929 SPDK_CU_ASSERT_FATAL(rc < 0); 930 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 931 932 /* Test Case: Issue a Write command from Host C */ 933 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 934 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 935 SPDK_CU_ASSERT_FATAL(rc < 0); 936 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 937 938 /* Test Case: Issue a Read command from Host B */ 939 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 940 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 941 SPDK_CU_ASSERT_FATAL(rc == 0); 942 943 /* Unregister Host C */ 944 memset(&g_ns_info.reg_hostid[2], 0, sizeof(struct spdk_uuid)); 945 946 /* Test Case: Read and Write commands from non-registrant Host C */ 947 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 948 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 949 SPDK_CU_ASSERT_FATAL(rc < 0); 950 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 951 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 952 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 953 SPDK_CU_ASSERT_FATAL(rc == 0); 954 } 955 956 static void 957 test_reservation_exclusive_access(void) 958 { 959 struct spdk_nvmf_request req = {}; 960 union nvmf_h2c_msg cmd = {}; 961 union nvmf_c2h_msg rsp = {}; 962 int rc; 963 964 req.cmd = &cmd; 965 req.rsp = &rsp; 966 967 /* Host A holds reservation with type SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS */ 968 ut_reservation_init(SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS); 969 g_ns_info.holder_id = g_ctrlr1_A.hostid; 970 971 /* Test Case: Issue a Read command from Host B */ 972 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 973 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 974 SPDK_CU_ASSERT_FATAL(rc < 0); 975 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 976 977 /* Test Case: Issue a Reservation Release command from a valid Registrant */ 978 cmd.nvme_cmd.opc = SPDK_NVME_OPC_RESERVATION_RELEASE; 979 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 980 SPDK_CU_ASSERT_FATAL(rc == 0); 981 } 982 983 static void 984 _test_reservation_write_exclusive_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype) 985 { 986 struct spdk_nvmf_request req = {}; 987 union nvmf_h2c_msg cmd = {}; 988 union nvmf_c2h_msg rsp = {}; 989 int rc; 990 991 req.cmd = &cmd; 992 req.rsp = &rsp; 993 994 /* SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY and SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS */ 995 ut_reservation_init(rtype); 996 g_ns_info.holder_id = g_ctrlr1_A.hostid; 997 998 /* Test Case: Issue a Read command from Host A and Host C */ 999 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 1000 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 1001 SPDK_CU_ASSERT_FATAL(rc == 0); 1002 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 1003 SPDK_CU_ASSERT_FATAL(rc == 0); 1004 1005 /* Test Case: Issue a DSM Write command from Host A and Host C */ 1006 cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT; 1007 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 1008 SPDK_CU_ASSERT_FATAL(rc == 0); 1009 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 1010 SPDK_CU_ASSERT_FATAL(rc == 0); 1011 1012 /* Unregister Host C */ 1013 memset(&g_ns_info.reg_hostid[2], 0, sizeof(struct spdk_uuid)); 1014 1015 /* Test Case: Read and Write commands from non-registrant Host C */ 1016 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 1017 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 1018 SPDK_CU_ASSERT_FATAL(rc == 0); 1019 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 1020 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 1021 SPDK_CU_ASSERT_FATAL(rc < 0); 1022 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 1023 } 1024 1025 static void 1026 test_reservation_write_exclusive_regs_only_and_all_regs(void) 1027 { 1028 _test_reservation_write_exclusive_regs_only_and_all_regs( 1029 SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); 1030 _test_reservation_write_exclusive_regs_only_and_all_regs( 1031 SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS); 1032 } 1033 1034 static void 1035 _test_reservation_exclusive_access_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype) 1036 { 1037 struct spdk_nvmf_request req = {}; 1038 union nvmf_h2c_msg cmd = {}; 1039 union nvmf_c2h_msg rsp = {}; 1040 int rc; 1041 1042 req.cmd = &cmd; 1043 req.rsp = &rsp; 1044 1045 /* SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY and SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS */ 1046 ut_reservation_init(rtype); 1047 g_ns_info.holder_id = g_ctrlr1_A.hostid; 1048 1049 /* Test Case: Issue a Write command from Host B */ 1050 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 1051 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 1052 SPDK_CU_ASSERT_FATAL(rc == 0); 1053 1054 /* Unregister Host B */ 1055 memset(&g_ns_info.reg_hostid[1], 0, sizeof(struct spdk_uuid)); 1056 1057 /* Test Case: Issue a Read command from Host B */ 1058 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 1059 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 1060 SPDK_CU_ASSERT_FATAL(rc < 0); 1061 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 1062 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 1063 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 1064 SPDK_CU_ASSERT_FATAL(rc < 0); 1065 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 1066 } 1067 1068 static void 1069 test_reservation_exclusive_access_regs_only_and_all_regs(void) 1070 { 1071 _test_reservation_exclusive_access_regs_only_and_all_regs( 1072 SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY); 1073 _test_reservation_exclusive_access_regs_only_and_all_regs( 1074 SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS); 1075 } 1076 1077 static void 1078 test_reservation_notification_log_page(void) 1079 { 1080 struct spdk_nvmf_ctrlr ctrlr; 1081 struct spdk_nvmf_qpair qpair; 1082 struct spdk_nvmf_ns ns; 1083 struct spdk_nvmf_request req; 1084 union nvmf_h2c_msg cmd; 1085 union nvmf_c2h_msg rsp; 1086 union spdk_nvme_async_event_completion event = {0}; 1087 struct spdk_nvme_reservation_notification_log logs[3]; 1088 1089 memset(&ctrlr, 0, sizeof(ctrlr)); 1090 ctrlr.thread = spdk_get_thread(); 1091 TAILQ_INIT(&ctrlr.log_head); 1092 ns.nsid = 1; 1093 1094 /* Test Case: Mask all the reservation notifications */ 1095 ns.mask = SPDK_NVME_REGISTRATION_PREEMPTED_MASK | 1096 SPDK_NVME_RESERVATION_RELEASED_MASK | 1097 SPDK_NVME_RESERVATION_PREEMPTED_MASK; 1098 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1099 SPDK_NVME_REGISTRATION_PREEMPTED); 1100 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1101 SPDK_NVME_RESERVATION_RELEASED); 1102 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1103 SPDK_NVME_RESERVATION_PREEMPTED); 1104 poll_threads(); 1105 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&ctrlr.log_head)); 1106 1107 /* Test Case: Unmask all the reservation notifications, 1108 * 3 log pages are generated, and AER was triggered. 1109 */ 1110 ns.mask = 0; 1111 ctrlr.num_avail_log_pages = 0; 1112 req.cmd = &cmd; 1113 req.rsp = &rsp; 1114 ctrlr.aer_req = &req; 1115 req.qpair = &qpair; 1116 TAILQ_INIT(&qpair.outstanding); 1117 qpair.ctrlr = NULL; 1118 qpair.state = SPDK_NVMF_QPAIR_ACTIVE; 1119 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 1120 1121 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1122 SPDK_NVME_REGISTRATION_PREEMPTED); 1123 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1124 SPDK_NVME_RESERVATION_RELEASED); 1125 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1126 SPDK_NVME_RESERVATION_PREEMPTED); 1127 poll_threads(); 1128 event.raw = rsp.nvme_cpl.cdw0; 1129 SPDK_CU_ASSERT_FATAL(event.bits.async_event_type == SPDK_NVME_ASYNC_EVENT_TYPE_IO); 1130 SPDK_CU_ASSERT_FATAL(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_RESERVATION_LOG_AVAIL); 1131 SPDK_CU_ASSERT_FATAL(event.bits.log_page_identifier == SPDK_NVME_LOG_RESERVATION_NOTIFICATION); 1132 SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 3); 1133 1134 /* Test Case: Get Log Page to clear the log pages */ 1135 spdk_nvmf_get_reservation_notification_log_page(&ctrlr, (void *)logs, 0, sizeof(logs)); 1136 SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 0); 1137 } 1138 1139 int main(int argc, char **argv) 1140 { 1141 CU_pSuite suite = NULL; 1142 unsigned int num_failures; 1143 1144 if (CU_initialize_registry() != CUE_SUCCESS) { 1145 return CU_get_error(); 1146 } 1147 1148 suite = CU_add_suite("nvmf", NULL, NULL); 1149 if (suite == NULL) { 1150 CU_cleanup_registry(); 1151 return CU_get_error(); 1152 } 1153 1154 if ( 1155 CU_add_test(suite, "get_log_page", test_get_log_page) == NULL || 1156 CU_add_test(suite, "process_fabrics_cmd", test_process_fabrics_cmd) == NULL || 1157 CU_add_test(suite, "connect", test_connect) == NULL || 1158 CU_add_test(suite, "get_ns_id_desc_list", test_get_ns_id_desc_list) == NULL || 1159 CU_add_test(suite, "identify_ns", test_identify_ns) == NULL || 1160 CU_add_test(suite, "reservation_write_exclusive", test_reservation_write_exclusive) == NULL || 1161 CU_add_test(suite, "reservation_exclusive_access", test_reservation_exclusive_access) == NULL || 1162 CU_add_test(suite, "reservation_write_exclusive_regs_only_and_all_regs", 1163 test_reservation_write_exclusive_regs_only_and_all_regs) == NULL || 1164 CU_add_test(suite, "reservation_exclusive_access_regs_only_and_all_regs", 1165 test_reservation_exclusive_access_regs_only_and_all_regs) == NULL || 1166 CU_add_test(suite, "reservation_notification_log_page", 1167 test_reservation_notification_log_page) == NULL 1168 ) { 1169 CU_cleanup_registry(); 1170 return CU_get_error(); 1171 } 1172 1173 allocate_threads(1); 1174 set_thread(0); 1175 1176 CU_basic_set_mode(CU_BRM_VERBOSE); 1177 CU_basic_run_tests(); 1178 num_failures = CU_get_number_of_failures(); 1179 CU_cleanup_registry(); 1180 1181 free_threads(); 1182 1183 return num_failures; 1184 } 1185