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_transport transport; 283 struct spdk_nvmf_subsystem subsystem; 284 struct spdk_nvmf_request req; 285 struct spdk_nvmf_qpair admin_qpair; 286 struct spdk_nvmf_qpair qpair; 287 struct spdk_nvmf_qpair qpair2; 288 struct spdk_nvmf_ctrlr ctrlr; 289 struct spdk_nvmf_tgt tgt; 290 union nvmf_h2c_msg cmd; 291 union nvmf_c2h_msg rsp; 292 const uint8_t hostid[16] = { 293 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 294 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 295 }; 296 const char subnqn[] = "nqn.2016-06.io.spdk:subsystem1"; 297 const char hostnqn[] = "nqn.2016-06.io.spdk:host1"; 298 int rc; 299 300 memset(&group, 0, sizeof(group)); 301 group.thread = spdk_get_thread(); 302 303 memset(&ctrlr, 0, sizeof(ctrlr)); 304 ctrlr.subsys = &subsystem; 305 ctrlr.qpair_mask = spdk_bit_array_create(3); 306 SPDK_CU_ASSERT_FATAL(ctrlr.qpair_mask != NULL); 307 ctrlr.vcprop.cc.bits.en = 1; 308 ctrlr.vcprop.cc.bits.iosqes = 6; 309 ctrlr.vcprop.cc.bits.iocqes = 4; 310 311 memset(&admin_qpair, 0, sizeof(admin_qpair)); 312 admin_qpair.group = &group; 313 314 memset(&tgt, 0, sizeof(tgt)); 315 memset(&transport, 0, sizeof(transport)); 316 transport.opts.max_queue_depth = 64; 317 transport.opts.max_qpairs_per_ctrlr = 3; 318 transport.tgt = &tgt; 319 320 memset(&qpair, 0, sizeof(qpair)); 321 qpair.transport = &transport; 322 qpair.group = &group; 323 qpair.state = SPDK_NVMF_QPAIR_ACTIVE; 324 TAILQ_INIT(&qpair.outstanding); 325 326 memset(&connect_data, 0, sizeof(connect_data)); 327 memcpy(connect_data.hostid, hostid, sizeof(hostid)); 328 connect_data.cntlid = 0xFFFF; 329 snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn); 330 snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn); 331 332 memset(&subsystem, 0, sizeof(subsystem)); 333 subsystem.thread = spdk_get_thread(); 334 subsystem.id = 1; 335 TAILQ_INIT(&subsystem.ctrlrs); 336 subsystem.tgt = &tgt; 337 subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; 338 subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 339 snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn); 340 341 memset(&cmd, 0, sizeof(cmd)); 342 cmd.connect_cmd.opcode = SPDK_NVME_OPC_FABRIC; 343 cmd.connect_cmd.cid = 1; 344 cmd.connect_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT; 345 cmd.connect_cmd.recfmt = 0; 346 cmd.connect_cmd.qid = 0; 347 cmd.connect_cmd.sqsize = 31; 348 cmd.connect_cmd.cattr = 0; 349 cmd.connect_cmd.kato = 120000; 350 351 memset(&req, 0, sizeof(req)); 352 req.qpair = &qpair; 353 req.length = sizeof(connect_data); 354 req.xfer = SPDK_NVME_DATA_HOST_TO_CONTROLLER; 355 req.data = &connect_data; 356 req.cmd = &cmd; 357 req.rsp = &rsp; 358 359 MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem); 360 MOCK_SET(spdk_nvmf_poll_group_create, &group); 361 362 /* Valid admin connect command */ 363 memset(&rsp, 0, sizeof(rsp)); 364 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 365 rc = spdk_nvmf_ctrlr_connect(&req); 366 poll_threads(); 367 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 368 CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); 369 CU_ASSERT(qpair.ctrlr != NULL); 370 spdk_nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr); 371 spdk_bit_array_free(&qpair.ctrlr->qpair_mask); 372 free(qpair.ctrlr); 373 qpair.ctrlr = NULL; 374 375 /* Invalid data length */ 376 memset(&rsp, 0, sizeof(rsp)); 377 req.length = sizeof(connect_data) - 1; 378 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 379 rc = spdk_nvmf_ctrlr_connect(&req); 380 poll_threads(); 381 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 382 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 383 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); 384 CU_ASSERT(qpair.ctrlr == NULL); 385 req.length = sizeof(connect_data); 386 387 /* Invalid recfmt */ 388 memset(&rsp, 0, sizeof(rsp)); 389 cmd.connect_cmd.recfmt = 1234; 390 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 391 rc = spdk_nvmf_ctrlr_connect(&req); 392 poll_threads(); 393 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 394 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 395 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INCOMPATIBLE_FORMAT); 396 CU_ASSERT(qpair.ctrlr == NULL); 397 cmd.connect_cmd.recfmt = 0; 398 399 /* Unterminated subnqn */ 400 memset(&rsp, 0, sizeof(rsp)); 401 memset(connect_data.subnqn, 'a', sizeof(connect_data.subnqn)); 402 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 403 rc = spdk_nvmf_ctrlr_connect(&req); 404 poll_threads(); 405 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 406 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 407 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 408 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 409 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 256); 410 CU_ASSERT(qpair.ctrlr == NULL); 411 snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn); 412 413 /* Subsystem not found */ 414 memset(&rsp, 0, sizeof(rsp)); 415 MOCK_SET(spdk_nvmf_tgt_find_subsystem, NULL); 416 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 417 rc = spdk_nvmf_ctrlr_connect(&req); 418 poll_threads(); 419 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 420 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 421 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 422 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 423 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 256); 424 CU_ASSERT(qpair.ctrlr == NULL); 425 MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem); 426 427 /* Unterminated hostnqn */ 428 memset(&rsp, 0, sizeof(rsp)); 429 memset(connect_data.hostnqn, 'b', sizeof(connect_data.hostnqn)); 430 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 431 rc = spdk_nvmf_ctrlr_connect(&req); 432 poll_threads(); 433 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 434 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 435 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 436 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 437 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 512); 438 CU_ASSERT(qpair.ctrlr == NULL); 439 snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn); 440 441 /* Host not allowed */ 442 memset(&rsp, 0, sizeof(rsp)); 443 MOCK_SET(spdk_nvmf_subsystem_host_allowed, false); 444 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 445 rc = spdk_nvmf_ctrlr_connect(&req); 446 poll_threads(); 447 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 448 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 449 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_HOST); 450 CU_ASSERT(qpair.ctrlr == NULL); 451 MOCK_SET(spdk_nvmf_subsystem_host_allowed, true); 452 453 /* Invalid sqsize == 0 */ 454 memset(&rsp, 0, sizeof(rsp)); 455 cmd.connect_cmd.sqsize = 0; 456 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 457 rc = spdk_nvmf_ctrlr_connect(&req); 458 poll_threads(); 459 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 460 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 461 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 462 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 463 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44); 464 CU_ASSERT(qpair.ctrlr == NULL); 465 cmd.connect_cmd.sqsize = 31; 466 467 /* Invalid sqsize > max_queue_depth */ 468 memset(&rsp, 0, sizeof(rsp)); 469 cmd.connect_cmd.sqsize = 64; 470 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 471 rc = spdk_nvmf_ctrlr_connect(&req); 472 poll_threads(); 473 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 474 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 475 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 476 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 477 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44); 478 CU_ASSERT(qpair.ctrlr == NULL); 479 cmd.connect_cmd.sqsize = 31; 480 481 /* Invalid cntlid for admin queue */ 482 memset(&rsp, 0, sizeof(rsp)); 483 connect_data.cntlid = 0x1234; 484 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 485 rc = spdk_nvmf_ctrlr_connect(&req); 486 poll_threads(); 487 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 488 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 489 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 490 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 491 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16); 492 CU_ASSERT(qpair.ctrlr == NULL); 493 connect_data.cntlid = 0xFFFF; 494 495 ctrlr.admin_qpair = &admin_qpair; 496 ctrlr.subsys = &subsystem; 497 498 /* Valid I/O queue connect command */ 499 memset(&rsp, 0, sizeof(rsp)); 500 MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, &ctrlr); 501 cmd.connect_cmd.qid = 1; 502 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 503 rc = spdk_nvmf_ctrlr_connect(&req); 504 poll_threads(); 505 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 506 CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); 507 CU_ASSERT(qpair.ctrlr == &ctrlr); 508 qpair.ctrlr = NULL; 509 510 /* Non-existent controller */ 511 memset(&rsp, 0, sizeof(rsp)); 512 MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, NULL); 513 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 514 rc = spdk_nvmf_ctrlr_connect(&req); 515 poll_threads(); 516 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 517 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 518 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 519 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); 520 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16); 521 CU_ASSERT(qpair.ctrlr == NULL); 522 MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, &ctrlr); 523 524 /* I/O connect to discovery controller */ 525 memset(&rsp, 0, sizeof(rsp)); 526 subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY; 527 subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 528 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 529 rc = spdk_nvmf_ctrlr_connect(&req); 530 poll_threads(); 531 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 532 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 533 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 534 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 535 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 536 CU_ASSERT(qpair.ctrlr == NULL); 537 subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; 538 539 /* I/O connect to disabled controller */ 540 memset(&rsp, 0, sizeof(rsp)); 541 ctrlr.vcprop.cc.bits.en = 0; 542 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 543 rc = spdk_nvmf_ctrlr_connect(&req); 544 poll_threads(); 545 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 546 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 547 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 548 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 549 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 550 CU_ASSERT(qpair.ctrlr == NULL); 551 ctrlr.vcprop.cc.bits.en = 1; 552 553 /* I/O connect with invalid IOSQES */ 554 memset(&rsp, 0, sizeof(rsp)); 555 ctrlr.vcprop.cc.bits.iosqes = 3; 556 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 557 rc = spdk_nvmf_ctrlr_connect(&req); 558 poll_threads(); 559 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 560 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 561 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 562 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 563 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 564 CU_ASSERT(qpair.ctrlr == NULL); 565 ctrlr.vcprop.cc.bits.iosqes = 6; 566 567 /* I/O connect with invalid IOCQES */ 568 memset(&rsp, 0, sizeof(rsp)); 569 ctrlr.vcprop.cc.bits.iocqes = 3; 570 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 571 rc = spdk_nvmf_ctrlr_connect(&req); 572 poll_threads(); 573 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 574 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 575 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); 576 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); 577 CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); 578 CU_ASSERT(qpair.ctrlr == NULL); 579 ctrlr.vcprop.cc.bits.iocqes = 4; 580 581 /* I/O connect with too many existing qpairs */ 582 memset(&rsp, 0, sizeof(rsp)); 583 spdk_bit_array_set(ctrlr.qpair_mask, 0); 584 spdk_bit_array_set(ctrlr.qpair_mask, 1); 585 spdk_bit_array_set(ctrlr.qpair_mask, 2); 586 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 587 rc = spdk_nvmf_ctrlr_connect(&req); 588 poll_threads(); 589 CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); 590 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); 591 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER); 592 CU_ASSERT(qpair.ctrlr == NULL); 593 spdk_bit_array_clear(ctrlr.qpair_mask, 0); 594 spdk_bit_array_clear(ctrlr.qpair_mask, 1); 595 spdk_bit_array_clear(ctrlr.qpair_mask, 2); 596 597 /* I/O connect with duplicate queue ID */ 598 memset(&rsp, 0, sizeof(rsp)); 599 memset(&qpair2, 0, sizeof(qpair2)); 600 qpair2.group = &group; 601 qpair2.qid = 1; 602 spdk_bit_array_set(ctrlr.qpair_mask, 1); 603 cmd.connect_cmd.qid = 1; 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_NVME_SC_INVALID_QUEUE_IDENTIFIER); 610 CU_ASSERT(qpair.ctrlr == NULL); 611 612 /* Clean up globals */ 613 MOCK_CLEAR(spdk_nvmf_tgt_find_subsystem); 614 MOCK_CLEAR(spdk_nvmf_poll_group_create); 615 616 spdk_bit_array_free(&ctrlr.qpair_mask); 617 } 618 619 static void 620 test_get_ns_id_desc_list(void) 621 { 622 struct spdk_nvmf_subsystem subsystem; 623 struct spdk_nvmf_qpair qpair; 624 struct spdk_nvmf_ctrlr ctrlr; 625 struct spdk_nvmf_request req; 626 struct spdk_nvmf_ns *ns_ptrs[1]; 627 struct spdk_nvmf_ns ns; 628 union nvmf_h2c_msg cmd; 629 union nvmf_c2h_msg rsp; 630 struct spdk_bdev bdev; 631 uint8_t buf[4096]; 632 633 memset(&subsystem, 0, sizeof(subsystem)); 634 ns_ptrs[0] = &ns; 635 subsystem.ns = ns_ptrs; 636 subsystem.max_nsid = 1; 637 subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; 638 639 memset(&ns, 0, sizeof(ns)); 640 ns.opts.nsid = 1; 641 ns.bdev = &bdev; 642 643 memset(&qpair, 0, sizeof(qpair)); 644 qpair.ctrlr = &ctrlr; 645 646 memset(&ctrlr, 0, sizeof(ctrlr)); 647 ctrlr.subsys = &subsystem; 648 ctrlr.vcprop.cc.bits.en = 1; 649 650 memset(&req, 0, sizeof(req)); 651 req.qpair = &qpair; 652 req.cmd = &cmd; 653 req.rsp = &rsp; 654 req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST; 655 req.data = buf; 656 req.length = sizeof(buf); 657 658 memset(&cmd, 0, sizeof(cmd)); 659 cmd.nvme_cmd.opc = SPDK_NVME_OPC_IDENTIFY; 660 cmd.nvme_cmd.cdw10 = SPDK_NVME_IDENTIFY_NS_ID_DESCRIPTOR_LIST; 661 662 /* Invalid NSID */ 663 cmd.nvme_cmd.nsid = 0; 664 memset(&rsp, 0, sizeof(rsp)); 665 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 666 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 667 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 668 669 /* Valid NSID, but ns has no IDs defined */ 670 cmd.nvme_cmd.nsid = 1; 671 memset(&rsp, 0, sizeof(rsp)); 672 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 673 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 674 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 675 CU_ASSERT(spdk_mem_all_zero(buf, sizeof(buf))); 676 677 /* Valid NSID, only EUI64 defined */ 678 ns.opts.eui64[0] = 0x11; 679 ns.opts.eui64[7] = 0xFF; 680 memset(&rsp, 0, sizeof(rsp)); 681 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 682 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 683 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 684 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); 685 CU_ASSERT(buf[1] == 8); 686 CU_ASSERT(buf[4] == 0x11); 687 CU_ASSERT(buf[11] == 0xFF); 688 CU_ASSERT(buf[13] == 0); 689 690 /* Valid NSID, only NGUID defined */ 691 memset(ns.opts.eui64, 0, sizeof(ns.opts.eui64)); 692 ns.opts.nguid[0] = 0x22; 693 ns.opts.nguid[15] = 0xEE; 694 memset(&rsp, 0, sizeof(rsp)); 695 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 696 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 697 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 698 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_NGUID); 699 CU_ASSERT(buf[1] == 16); 700 CU_ASSERT(buf[4] == 0x22); 701 CU_ASSERT(buf[19] == 0xEE); 702 CU_ASSERT(buf[21] == 0); 703 704 /* Valid NSID, both EUI64 and NGUID defined */ 705 ns.opts.eui64[0] = 0x11; 706 ns.opts.eui64[7] = 0xFF; 707 ns.opts.nguid[0] = 0x22; 708 ns.opts.nguid[15] = 0xEE; 709 memset(&rsp, 0, sizeof(rsp)); 710 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 711 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 712 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 713 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); 714 CU_ASSERT(buf[1] == 8); 715 CU_ASSERT(buf[4] == 0x11); 716 CU_ASSERT(buf[11] == 0xFF); 717 CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID); 718 CU_ASSERT(buf[13] == 16); 719 CU_ASSERT(buf[16] == 0x22); 720 CU_ASSERT(buf[31] == 0xEE); 721 CU_ASSERT(buf[33] == 0); 722 723 /* Valid NSID, EUI64, NGUID, and UUID defined */ 724 ns.opts.eui64[0] = 0x11; 725 ns.opts.eui64[7] = 0xFF; 726 ns.opts.nguid[0] = 0x22; 727 ns.opts.nguid[15] = 0xEE; 728 ns.opts.uuid.u.raw[0] = 0x33; 729 ns.opts.uuid.u.raw[15] = 0xDD; 730 memset(&rsp, 0, sizeof(rsp)); 731 CU_ASSERT(spdk_nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 732 CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); 733 CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); 734 CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); 735 CU_ASSERT(buf[1] == 8); 736 CU_ASSERT(buf[4] == 0x11); 737 CU_ASSERT(buf[11] == 0xFF); 738 CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID); 739 CU_ASSERT(buf[13] == 16); 740 CU_ASSERT(buf[16] == 0x22); 741 CU_ASSERT(buf[31] == 0xEE); 742 CU_ASSERT(buf[32] == SPDK_NVME_NIDT_UUID); 743 CU_ASSERT(buf[33] == 16); 744 CU_ASSERT(buf[36] == 0x33); 745 CU_ASSERT(buf[51] == 0xDD); 746 CU_ASSERT(buf[53] == 0); 747 } 748 749 static void 750 test_identify_ns(void) 751 { 752 struct spdk_nvmf_subsystem subsystem = {}; 753 struct spdk_nvmf_transport transport = {}; 754 struct spdk_nvmf_qpair admin_qpair = { .transport = &transport}; 755 struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair }; 756 struct spdk_nvme_cmd cmd = {}; 757 struct spdk_nvme_cpl rsp = {}; 758 struct spdk_nvme_ns_data nsdata = {}; 759 struct spdk_bdev bdev[3] = {{.blockcnt = 1234}, {.blockcnt = 0}, {.blockcnt = 5678}}; 760 struct spdk_nvmf_ns ns[3] = {{.bdev = &bdev[0]}, {.bdev = NULL}, {.bdev = &bdev[2]}}; 761 struct spdk_nvmf_ns *ns_arr[3] = {&ns[0], NULL, &ns[2]}; 762 763 subsystem.ns = ns_arr; 764 subsystem.max_nsid = SPDK_COUNTOF(ns_arr); 765 766 /* Invalid NSID 0 */ 767 cmd.nsid = 0; 768 memset(&nsdata, 0, sizeof(nsdata)); 769 memset(&rsp, 0, sizeof(rsp)); 770 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 771 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 772 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 773 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 774 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 775 776 /* Valid NSID 1 */ 777 cmd.nsid = 1; 778 memset(&nsdata, 0, sizeof(nsdata)); 779 memset(&rsp, 0, sizeof(rsp)); 780 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 781 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 782 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 783 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); 784 CU_ASSERT(nsdata.nsze == 1234); 785 786 /* Valid but inactive NSID 2 */ 787 cmd.nsid = 2; 788 memset(&nsdata, 0, sizeof(nsdata)); 789 memset(&rsp, 0, sizeof(rsp)); 790 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 791 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 792 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 793 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); 794 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 795 796 /* Valid NSID 3 */ 797 cmd.nsid = 3; 798 memset(&nsdata, 0, sizeof(nsdata)); 799 memset(&rsp, 0, sizeof(rsp)); 800 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 801 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 802 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 803 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); 804 CU_ASSERT(nsdata.nsze == 5678); 805 806 /* Invalid NSID 4 */ 807 cmd.nsid = 4; 808 memset(&nsdata, 0, sizeof(nsdata)); 809 memset(&rsp, 0, sizeof(rsp)); 810 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 811 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 812 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 813 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 814 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 815 816 /* Invalid NSID 0xFFFFFFFF (NS management not supported) */ 817 cmd.nsid = 0xFFFFFFFF; 818 memset(&nsdata, 0, sizeof(nsdata)); 819 memset(&rsp, 0, sizeof(rsp)); 820 CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, 821 &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); 822 CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); 823 CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); 824 CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); 825 } 826 827 /* 828 * Reservation Unit Test Configuration 829 * -------- -------- -------- 830 * | Host A | | Host B | | Host C | 831 * -------- -------- -------- 832 * / \ | | 833 * -------- -------- ------- ------- 834 * |Ctrlr1_A| |Ctrlr2_A| |Ctrlr_B| |Ctrlr_C| 835 * -------- -------- ------- ------- 836 * \ \ / / 837 * \ \ / / 838 * \ \ / / 839 * -------------------------------------- 840 * | NAMESPACE 1 | 841 * -------------------------------------- 842 */ 843 844 static struct spdk_nvmf_ctrlr g_ctrlr1_A, g_ctrlr2_A, g_ctrlr_B, g_ctrlr_C; 845 struct spdk_nvmf_subsystem_pg_ns_info g_ns_info; 846 847 static void 848 ut_reservation_init(enum spdk_nvme_reservation_type rtype) 849 { 850 /* Host A has two controllers */ 851 spdk_uuid_generate(&g_ctrlr1_A.hostid); 852 spdk_uuid_copy(&g_ctrlr2_A.hostid, &g_ctrlr1_A.hostid); 853 854 /* Host B has 1 controller */ 855 spdk_uuid_generate(&g_ctrlr_B.hostid); 856 857 /* Host C has 1 controller */ 858 spdk_uuid_generate(&g_ctrlr_C.hostid); 859 860 memset(&g_ns_info, 0, sizeof(g_ns_info)); 861 g_ns_info.rtype = rtype; 862 g_ns_info.reg_hostid[0] = g_ctrlr1_A.hostid; 863 g_ns_info.reg_hostid[1] = g_ctrlr_B.hostid; 864 g_ns_info.reg_hostid[2] = g_ctrlr_C.hostid; 865 } 866 867 static void 868 test_reservation_write_exclusive(void) 869 { 870 struct spdk_nvmf_request req = {}; 871 union nvmf_h2c_msg cmd = {}; 872 union nvmf_c2h_msg rsp = {}; 873 int rc; 874 875 req.cmd = &cmd; 876 req.rsp = &rsp; 877 878 /* Host A holds reservation with type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE */ 879 ut_reservation_init(SPDK_NVME_RESERVE_WRITE_EXCLUSIVE); 880 g_ns_info.holder_id = g_ctrlr1_A.hostid; 881 882 /* Test Case: Issue a Read command from Host A and Host B */ 883 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 884 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 885 SPDK_CU_ASSERT_FATAL(rc == 0); 886 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 887 SPDK_CU_ASSERT_FATAL(rc == 0); 888 889 /* Test Case: Issue a DSM Write command from Host A and Host B */ 890 cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT; 891 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 892 SPDK_CU_ASSERT_FATAL(rc == 0); 893 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 894 SPDK_CU_ASSERT_FATAL(rc < 0); 895 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 896 897 /* Test Case: Issue a Write command from Host C */ 898 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 899 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 900 SPDK_CU_ASSERT_FATAL(rc < 0); 901 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 902 903 /* Test Case: Issue a Read command from Host B */ 904 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 905 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 906 SPDK_CU_ASSERT_FATAL(rc == 0); 907 908 /* Unregister Host C */ 909 memset(&g_ns_info.reg_hostid[2], 0, sizeof(struct spdk_uuid)); 910 911 /* Test Case: Read and Write commands from non-registrant Host C */ 912 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 913 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 914 SPDK_CU_ASSERT_FATAL(rc < 0); 915 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 916 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 917 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 918 SPDK_CU_ASSERT_FATAL(rc == 0); 919 } 920 921 static void 922 test_reservation_exclusive_access(void) 923 { 924 struct spdk_nvmf_request req = {}; 925 union nvmf_h2c_msg cmd = {}; 926 union nvmf_c2h_msg rsp = {}; 927 int rc; 928 929 req.cmd = &cmd; 930 req.rsp = &rsp; 931 932 /* Host A holds reservation with type SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS */ 933 ut_reservation_init(SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS); 934 g_ns_info.holder_id = g_ctrlr1_A.hostid; 935 936 /* Test Case: Issue a Read command from Host B */ 937 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 938 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 939 SPDK_CU_ASSERT_FATAL(rc < 0); 940 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 941 942 /* Test Case: Issue a Reservation Release command from a valid Registrant */ 943 cmd.nvme_cmd.opc = SPDK_NVME_OPC_RESERVATION_RELEASE; 944 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 945 SPDK_CU_ASSERT_FATAL(rc == 0); 946 } 947 948 static void 949 _test_reservation_write_exclusive_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype) 950 { 951 struct spdk_nvmf_request req = {}; 952 union nvmf_h2c_msg cmd = {}; 953 union nvmf_c2h_msg rsp = {}; 954 int rc; 955 956 req.cmd = &cmd; 957 req.rsp = &rsp; 958 959 /* SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY and SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS */ 960 ut_reservation_init(rtype); 961 g_ns_info.holder_id = g_ctrlr1_A.hostid; 962 963 /* Test Case: Issue a Read command from Host A and Host C */ 964 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 965 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 966 SPDK_CU_ASSERT_FATAL(rc == 0); 967 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 968 SPDK_CU_ASSERT_FATAL(rc == 0); 969 970 /* Test Case: Issue a DSM Write command from Host A and Host C */ 971 cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT; 972 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); 973 SPDK_CU_ASSERT_FATAL(rc == 0); 974 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 975 SPDK_CU_ASSERT_FATAL(rc == 0); 976 977 /* Unregister Host C */ 978 memset(&g_ns_info.reg_hostid[2], 0, sizeof(struct spdk_uuid)); 979 980 /* Test Case: Read and Write commands from non-registrant Host C */ 981 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 982 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 983 SPDK_CU_ASSERT_FATAL(rc == 0); 984 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 985 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); 986 SPDK_CU_ASSERT_FATAL(rc < 0); 987 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 988 } 989 990 static void 991 test_reservation_write_exclusive_regs_only_and_all_regs(void) 992 { 993 _test_reservation_write_exclusive_regs_only_and_all_regs( 994 SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); 995 _test_reservation_write_exclusive_regs_only_and_all_regs( 996 SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS); 997 } 998 999 static void 1000 _test_reservation_exclusive_access_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype) 1001 { 1002 struct spdk_nvmf_request req = {}; 1003 union nvmf_h2c_msg cmd = {}; 1004 union nvmf_c2h_msg rsp = {}; 1005 int rc; 1006 1007 req.cmd = &cmd; 1008 req.rsp = &rsp; 1009 1010 /* SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY and SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS */ 1011 ut_reservation_init(rtype); 1012 g_ns_info.holder_id = g_ctrlr1_A.hostid; 1013 1014 /* Test Case: Issue a Write command from Host B */ 1015 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 1016 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 1017 SPDK_CU_ASSERT_FATAL(rc == 0); 1018 1019 /* Unregister Host B */ 1020 memset(&g_ns_info.reg_hostid[1], 0, sizeof(struct spdk_uuid)); 1021 1022 /* Test Case: Issue a Read command from Host B */ 1023 cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; 1024 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 1025 SPDK_CU_ASSERT_FATAL(rc < 0); 1026 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 1027 cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; 1028 rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); 1029 SPDK_CU_ASSERT_FATAL(rc < 0); 1030 SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); 1031 } 1032 1033 static void 1034 test_reservation_exclusive_access_regs_only_and_all_regs(void) 1035 { 1036 _test_reservation_exclusive_access_regs_only_and_all_regs( 1037 SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY); 1038 _test_reservation_exclusive_access_regs_only_and_all_regs( 1039 SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS); 1040 } 1041 1042 static void 1043 test_reservation_notification_log_page(void) 1044 { 1045 struct spdk_nvmf_ctrlr ctrlr; 1046 struct spdk_nvmf_qpair qpair; 1047 struct spdk_nvmf_ns ns; 1048 struct spdk_nvmf_request req; 1049 union nvmf_h2c_msg cmd; 1050 union nvmf_c2h_msg rsp; 1051 union spdk_nvme_async_event_completion event = {0}; 1052 struct spdk_nvme_reservation_notification_log logs[3]; 1053 1054 memset(&ctrlr, 0, sizeof(ctrlr)); 1055 ctrlr.thread = spdk_get_thread(); 1056 TAILQ_INIT(&ctrlr.log_head); 1057 ns.nsid = 1; 1058 1059 /* Test Case: Mask all the reservation notifications */ 1060 ns.mask = SPDK_NVME_REGISTRATION_PREEMPTED_MASK | 1061 SPDK_NVME_RESERVATION_RELEASED_MASK | 1062 SPDK_NVME_RESERVATION_PREEMPTED_MASK; 1063 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1064 SPDK_NVME_REGISTRATION_PREEMPTED); 1065 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1066 SPDK_NVME_RESERVATION_RELEASED); 1067 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1068 SPDK_NVME_RESERVATION_PREEMPTED); 1069 poll_threads(); 1070 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&ctrlr.log_head)); 1071 1072 /* Test Case: Unmask all the reservation notifications, 1073 * 3 log pages are generated, and AER was triggered. 1074 */ 1075 ns.mask = 0; 1076 ctrlr.num_avail_log_pages = 0; 1077 req.cmd = &cmd; 1078 req.rsp = &rsp; 1079 ctrlr.aer_req = &req; 1080 req.qpair = &qpair; 1081 TAILQ_INIT(&qpair.outstanding); 1082 qpair.state = SPDK_NVMF_QPAIR_ACTIVE; 1083 TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); 1084 1085 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1086 SPDK_NVME_REGISTRATION_PREEMPTED); 1087 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1088 SPDK_NVME_RESERVATION_RELEASED); 1089 spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, 1090 SPDK_NVME_RESERVATION_PREEMPTED); 1091 poll_threads(); 1092 event.raw = rsp.nvme_cpl.cdw0; 1093 SPDK_CU_ASSERT_FATAL(event.bits.async_event_type == SPDK_NVME_ASYNC_EVENT_TYPE_IO); 1094 SPDK_CU_ASSERT_FATAL(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_RESERVATION_LOG_AVAIL); 1095 SPDK_CU_ASSERT_FATAL(event.bits.log_page_identifier == SPDK_NVME_LOG_RESERVATION_NOTIFICATION); 1096 SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 3); 1097 1098 /* Test Case: Get Log Page to clear the log pages */ 1099 spdk_nvmf_get_reservation_notification_log_page(&ctrlr, (void *)logs, 0, sizeof(logs)); 1100 SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 0); 1101 } 1102 1103 int main(int argc, char **argv) 1104 { 1105 CU_pSuite suite = NULL; 1106 unsigned int num_failures; 1107 1108 if (CU_initialize_registry() != CUE_SUCCESS) { 1109 return CU_get_error(); 1110 } 1111 1112 suite = CU_add_suite("nvmf", NULL, NULL); 1113 if (suite == NULL) { 1114 CU_cleanup_registry(); 1115 return CU_get_error(); 1116 } 1117 1118 if ( 1119 CU_add_test(suite, "get_log_page", test_get_log_page) == NULL || 1120 CU_add_test(suite, "process_fabrics_cmd", test_process_fabrics_cmd) == NULL || 1121 CU_add_test(suite, "connect", test_connect) == NULL || 1122 CU_add_test(suite, "get_ns_id_desc_list", test_get_ns_id_desc_list) == NULL || 1123 CU_add_test(suite, "identify_ns", test_identify_ns) == NULL || 1124 CU_add_test(suite, "reservation_write_exclusive", test_reservation_write_exclusive) == NULL || 1125 CU_add_test(suite, "reservation_exclusive_access", test_reservation_exclusive_access) == NULL || 1126 CU_add_test(suite, "reservation_write_exclusive_regs_only_and_all_regs", 1127 test_reservation_write_exclusive_regs_only_and_all_regs) == NULL || 1128 CU_add_test(suite, "reservation_exclusive_access_regs_only_and_all_regs", 1129 test_reservation_exclusive_access_regs_only_and_all_regs) == NULL || 1130 CU_add_test(suite, "reservation_notification_log_page", 1131 test_reservation_notification_log_page) == NULL 1132 ) { 1133 CU_cleanup_registry(); 1134 return CU_get_error(); 1135 } 1136 1137 allocate_threads(1); 1138 set_thread(0); 1139 1140 CU_basic_set_mode(CU_BRM_VERBOSE); 1141 CU_basic_run_tests(); 1142 num_failures = CU_get_number_of_failures(); 1143 CU_cleanup_registry(); 1144 1145 free_threads(); 1146 1147 return num_failures; 1148 } 1149