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