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 "common/lib/test_env.c" 37 #include "spdk_cunit.h" 38 #include "spdk_internal/mock.h" 39 40 #include "nvmf/subsystem.c" 41 42 SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) 43 44 DEFINE_STUB(spdk_bdev_module_claim_bdev, 45 int, 46 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, 47 struct spdk_bdev_module *module), 0); 48 49 DEFINE_STUB_V(spdk_bdev_module_release_bdev, 50 (struct spdk_bdev *bdev)); 51 52 static void 53 _subsystem_send_msg(spdk_thread_fn fn, void *ctx, void *thread_ctx) 54 { 55 fn(ctx); 56 } 57 58 static void 59 subsystem_ns_remove_cb(struct spdk_nvmf_subsystem *subsystem, void *cb_arg, int status) 60 { 61 } 62 63 uint32_t 64 spdk_env_get_current_core(void) 65 { 66 return 0; 67 } 68 69 struct spdk_event * 70 spdk_event_allocate(uint32_t core, spdk_event_fn fn, void *arg1, void *arg2) 71 { 72 return NULL; 73 } 74 75 void 76 spdk_event_call(struct spdk_event *event) 77 { 78 79 } 80 81 int 82 spdk_nvmf_transport_listen(struct spdk_nvmf_transport *transport, 83 const struct spdk_nvme_transport_id *trid) 84 { 85 return 0; 86 } 87 88 void 89 spdk_nvmf_transport_listener_discover(struct spdk_nvmf_transport *transport, 90 struct spdk_nvme_transport_id *trid, 91 struct spdk_nvmf_discovery_log_page_entry *entry) 92 { 93 entry->trtype = 42; 94 } 95 96 bool 97 spdk_nvmf_transport_qpair_is_idle(struct spdk_nvmf_qpair *qpair) 98 { 99 return false; 100 } 101 102 static struct spdk_nvmf_transport g_transport = {}; 103 104 struct spdk_nvmf_transport * 105 spdk_nvmf_transport_create(struct spdk_nvmf_tgt *tgt, 106 enum spdk_nvme_transport_type type, 107 struct spdk_nvmf_transport_opts *tprt_opts) 108 { 109 if (type == SPDK_NVME_TRANSPORT_RDMA) { 110 g_transport.tgt = tgt; 111 return &g_transport; 112 } 113 114 return NULL; 115 } 116 117 struct spdk_nvmf_subsystem * 118 spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) 119 { 120 return NULL; 121 } 122 123 struct spdk_nvmf_transport * 124 spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, enum spdk_nvme_transport_type trtype) 125 { 126 if (trtype == SPDK_NVME_TRANSPORT_RDMA) { 127 return &g_transport; 128 } 129 130 return NULL; 131 } 132 133 int 134 spdk_nvmf_poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 135 struct spdk_nvmf_subsystem *subsystem) 136 { 137 return 0; 138 } 139 140 void 141 spdk_nvmf_poll_group_add_subsystem(struct spdk_nvmf_poll_group *group, 142 struct spdk_nvmf_subsystem *subsystem, 143 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 144 { 145 } 146 147 void 148 spdk_nvmf_poll_group_remove_subsystem(struct spdk_nvmf_poll_group *group, 149 struct spdk_nvmf_subsystem *subsystem, 150 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 151 { 152 } 153 154 void 155 spdk_nvmf_poll_group_pause_subsystem(struct spdk_nvmf_poll_group *group, 156 struct spdk_nvmf_subsystem *subsystem, 157 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 158 { 159 } 160 161 void 162 spdk_nvmf_poll_group_resume_subsystem(struct spdk_nvmf_poll_group *group, 163 struct spdk_nvmf_subsystem *subsystem, 164 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 165 { 166 } 167 168 int 169 spdk_nvme_transport_id_parse_trtype(enum spdk_nvme_transport_type *trtype, const char *str) 170 { 171 if (trtype == NULL || str == NULL) { 172 return -EINVAL; 173 } 174 175 if (strcasecmp(str, "PCIe") == 0) { 176 *trtype = SPDK_NVME_TRANSPORT_PCIE; 177 } else if (strcasecmp(str, "RDMA") == 0) { 178 *trtype = SPDK_NVME_TRANSPORT_RDMA; 179 } else { 180 return -ENOENT; 181 } 182 return 0; 183 } 184 185 int 186 spdk_nvme_transport_id_compare(const struct spdk_nvme_transport_id *trid1, 187 const struct spdk_nvme_transport_id *trid2) 188 { 189 return 0; 190 } 191 192 int32_t 193 spdk_nvme_ctrlr_process_admin_completions(struct spdk_nvme_ctrlr *ctrlr) 194 { 195 return -1; 196 } 197 198 int32_t 199 spdk_nvme_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_completions) 200 { 201 return -1; 202 } 203 204 int 205 spdk_nvme_detach(struct spdk_nvme_ctrlr *ctrlr) 206 { 207 return -1; 208 } 209 210 void 211 spdk_nvmf_ctrlr_destruct(struct spdk_nvmf_ctrlr *ctrlr) 212 { 213 } 214 215 void 216 spdk_nvmf_ctrlr_ns_changed(struct spdk_nvmf_ctrlr *ctrlr, uint32_t nsid) 217 { 218 } 219 220 int 221 spdk_bdev_open(struct spdk_bdev *bdev, bool write, spdk_bdev_remove_cb_t remove_cb, 222 void *remove_ctx, struct spdk_bdev_desc **desc) 223 { 224 return 0; 225 } 226 227 void 228 spdk_bdev_close(struct spdk_bdev_desc *desc) 229 { 230 } 231 232 const char * 233 spdk_bdev_get_name(const struct spdk_bdev *bdev) 234 { 235 return "test"; 236 } 237 238 const struct spdk_uuid * 239 spdk_bdev_get_uuid(const struct spdk_bdev *bdev) 240 { 241 return &bdev->uuid; 242 } 243 244 static void 245 test_spdk_nvmf_subsystem_add_ns(void) 246 { 247 struct spdk_nvmf_tgt tgt = {}; 248 struct spdk_nvmf_subsystem subsystem = { 249 .max_nsid = 0, 250 .ns = NULL, 251 .tgt = &tgt 252 }; 253 struct spdk_bdev bdev1 = {}, bdev2 = {}; 254 struct spdk_nvmf_ns_opts ns_opts; 255 uint32_t nsid; 256 257 tgt.opts.max_subsystems = 1024; 258 tgt.subsystems = calloc(tgt.opts.max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); 259 SPDK_CU_ASSERT_FATAL(tgt.subsystems != NULL); 260 261 /* Allow NSID to be assigned automatically */ 262 spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); 263 nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev1, &ns_opts, sizeof(ns_opts)); 264 /* NSID 1 is the first unused ID */ 265 CU_ASSERT(nsid == 1); 266 CU_ASSERT(subsystem.max_nsid == 1); 267 SPDK_CU_ASSERT_FATAL(subsystem.ns != NULL); 268 SPDK_CU_ASSERT_FATAL(subsystem.ns[nsid - 1] != NULL); 269 CU_ASSERT(subsystem.ns[nsid - 1]->bdev == &bdev1); 270 271 /* Request a specific NSID */ 272 spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); 273 ns_opts.nsid = 5; 274 nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev2, &ns_opts, sizeof(ns_opts)); 275 CU_ASSERT(nsid == 5); 276 CU_ASSERT(subsystem.max_nsid == 5); 277 SPDK_CU_ASSERT_FATAL(subsystem.ns[nsid - 1] != NULL); 278 CU_ASSERT(subsystem.ns[nsid - 1]->bdev == &bdev2); 279 280 /* Request an NSID that is already in use */ 281 spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); 282 ns_opts.nsid = 5; 283 nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev2, &ns_opts, sizeof(ns_opts)); 284 CU_ASSERT(nsid == 0); 285 CU_ASSERT(subsystem.max_nsid == 5); 286 287 /* Request 0xFFFFFFFF (invalid NSID, reserved for broadcast) */ 288 spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); 289 ns_opts.nsid = 0xFFFFFFFF; 290 nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev2, &ns_opts, sizeof(ns_opts)); 291 CU_ASSERT(nsid == 0); 292 CU_ASSERT(subsystem.max_nsid == 5); 293 294 spdk_nvmf_subsystem_remove_ns(&subsystem, 1, subsystem_ns_remove_cb, NULL); 295 spdk_nvmf_subsystem_remove_ns(&subsystem, 5, subsystem_ns_remove_cb, NULL); 296 297 free(subsystem.ns); 298 free(tgt.subsystems); 299 } 300 301 static void 302 nvmf_test_create_subsystem(void) 303 { 304 struct spdk_nvmf_tgt tgt = {}; 305 char nqn[256]; 306 struct spdk_nvmf_subsystem *subsystem; 307 308 tgt.opts.max_subsystems = 1024; 309 tgt.subsystems = calloc(tgt.opts.max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); 310 SPDK_CU_ASSERT_FATAL(tgt.subsystems != NULL); 311 312 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:subsystem1"); 313 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 314 SPDK_CU_ASSERT_FATAL(subsystem != NULL); 315 CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); 316 spdk_nvmf_subsystem_destroy(subsystem); 317 318 /* valid name with complex reverse domain */ 319 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk-full--rev-domain.name:subsystem1"); 320 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 321 SPDK_CU_ASSERT_FATAL(subsystem != NULL); 322 CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); 323 spdk_nvmf_subsystem_destroy(subsystem); 324 325 /* Valid name discovery controller */ 326 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:subsystem1"); 327 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 328 SPDK_CU_ASSERT_FATAL(subsystem != NULL); 329 CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); 330 spdk_nvmf_subsystem_destroy(subsystem); 331 332 333 /* Invalid name, no user supplied string */ 334 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:"); 335 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 336 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 337 338 /* Valid name, only contains top-level domain name */ 339 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:subsystem1"); 340 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 341 SPDK_CU_ASSERT_FATAL(subsystem != NULL); 342 CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); 343 spdk_nvmf_subsystem_destroy(subsystem); 344 345 /* Invalid name, domain label > 63 characters */ 346 snprintf(nqn, sizeof(nqn), 347 "nqn.2016-06.io.abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz:sub"); 348 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 349 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 350 351 /* Invalid name, domain label starts with digit */ 352 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.3spdk:sub"); 353 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 354 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 355 356 /* Invalid name, domain label starts with - */ 357 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.-spdk:subsystem1"); 358 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 359 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 360 361 /* Invalid name, domain label ends with - */ 362 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk-:subsystem1"); 363 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 364 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 365 366 /* Invalid name, domain label with multiple consecutive periods */ 367 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io..spdk:subsystem1"); 368 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 369 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 370 371 /* Longest valid name */ 372 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:"); 373 memset(nqn + strlen(nqn), 'a', 223 - strlen(nqn)); 374 nqn[223] = '\0'; 375 CU_ASSERT(strlen(nqn) == 223); 376 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 377 SPDK_CU_ASSERT_FATAL(subsystem != NULL); 378 CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); 379 spdk_nvmf_subsystem_destroy(subsystem); 380 381 /* Invalid name, too long */ 382 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:"); 383 memset(nqn + strlen(nqn), 'a', 224 - strlen(nqn)); 384 nqn[224] = '\0'; 385 CU_ASSERT(strlen(nqn) == 224); 386 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 387 CU_ASSERT(subsystem == NULL); 388 389 /* Valid name using uuid format */ 390 snprintf(nqn, sizeof(nqn), "nqn.2014-08.org.nvmexpress:uuid:11111111-aaaa-bbdd-FFEE-123456789abc"); 391 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 392 SPDK_CU_ASSERT_FATAL(subsystem != NULL); 393 CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); 394 spdk_nvmf_subsystem_destroy(subsystem); 395 396 /* Invalid name user string contains an invalid utf-8 character */ 397 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:\xFFsubsystem1"); 398 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 399 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 400 401 /* Valid name with non-ascii but valid utf-8 characters */ 402 snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:\xe1\x8a\x88subsystem1\xca\x80"); 403 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 404 SPDK_CU_ASSERT_FATAL(subsystem != NULL); 405 CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); 406 spdk_nvmf_subsystem_destroy(subsystem); 407 408 /* Invalid uuid (too long) */ 409 snprintf(nqn, sizeof(nqn), 410 "nqn.2014-08.org.nvmexpress:uuid:11111111-aaaa-bbdd-FFEE-123456789abcdef"); 411 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 412 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 413 414 /* Invalid uuid (dashes placed incorrectly) */ 415 snprintf(nqn, sizeof(nqn), "nqn.2014-08.org.nvmexpress:uuid:111111-11aaaa-bbdd-FFEE-123456789abc"); 416 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 417 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 418 419 /* Invalid uuid (invalid characters in uuid) */ 420 snprintf(nqn, sizeof(nqn), "nqn.2014-08.org.nvmexpress:uuid:111hg111-aaaa-bbdd-FFEE-123456789abc"); 421 subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); 422 SPDK_CU_ASSERT_FATAL(subsystem == NULL); 423 424 free(tgt.subsystems); 425 } 426 427 static void 428 test_spdk_nvmf_subsystem_set_sn(void) 429 { 430 struct spdk_nvmf_subsystem subsystem = {}; 431 432 /* Basic valid serial number */ 433 CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "abcd xyz") == 0); 434 CU_ASSERT(strcmp(subsystem.sn, "abcd xyz") == 0); 435 436 /* Exactly 20 characters (valid) */ 437 CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "12345678901234567890") == 0); 438 CU_ASSERT(strcmp(subsystem.sn, "12345678901234567890") == 0); 439 440 /* 21 characters (too long, invalid) */ 441 CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "123456789012345678901") < 0); 442 443 /* Non-ASCII characters (invalid) */ 444 CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "abcd\txyz") < 0); 445 } 446 447 int main(int argc, char **argv) 448 { 449 CU_pSuite suite = NULL; 450 unsigned int num_failures; 451 452 if (CU_initialize_registry() != CUE_SUCCESS) { 453 return CU_get_error(); 454 } 455 456 suite = CU_add_suite("nvmf", NULL, NULL); 457 if (suite == NULL) { 458 CU_cleanup_registry(); 459 return CU_get_error(); 460 } 461 462 if ( 463 CU_add_test(suite, "create_subsystem", nvmf_test_create_subsystem) == NULL || 464 CU_add_test(suite, "nvmf_subsystem_add_ns", test_spdk_nvmf_subsystem_add_ns) == NULL || 465 CU_add_test(suite, "nvmf_subsystem_set_sn", test_spdk_nvmf_subsystem_set_sn) == NULL) { 466 CU_cleanup_registry(); 467 return CU_get_error(); 468 } 469 470 spdk_allocate_thread(_subsystem_send_msg, NULL, NULL, NULL, "thread0"); 471 CU_basic_set_mode(CU_BRM_VERBOSE); 472 CU_basic_run_tests(); 473 num_failures = CU_get_number_of_failures(); 474 CU_cleanup_registry(); 475 spdk_free_thread(); 476 477 return num_failures; 478 } 479