1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2016 Intel Corporation. All rights reserved. 3 * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved. 4 * Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk/stdinc.h" 8 9 #include "nvmf_internal.h" 10 #include "transport.h" 11 12 #include "spdk/assert.h" 13 #include "spdk/likely.h" 14 #include "spdk/string.h" 15 #include "spdk/trace.h" 16 #include "spdk/nvmf_spec.h" 17 #include "spdk/uuid.h" 18 #include "spdk/json.h" 19 #include "spdk/file.h" 20 #include "spdk/bit_array.h" 21 #include "spdk/bdev.h" 22 23 #define __SPDK_BDEV_MODULE_ONLY 24 #include "spdk/bdev_module.h" 25 #include "spdk/log.h" 26 #include "spdk_internal/utf.h" 27 #include "spdk_internal/usdt.h" 28 29 #define MODEL_NUMBER_DEFAULT "SPDK bdev Controller" 30 #define NVMF_SUBSYSTEM_DEFAULT_NAMESPACES 32 31 32 /* 33 * States for parsing valid domains in NQNs according to RFC 1034 34 */ 35 enum spdk_nvmf_nqn_domain_states { 36 /* First character of a domain must be a letter */ 37 SPDK_NVMF_DOMAIN_ACCEPT_LETTER = 0, 38 39 /* Subsequent characters can be any of letter, digit, or hyphen */ 40 SPDK_NVMF_DOMAIN_ACCEPT_LDH = 1, 41 42 /* A domain label must end with either a letter or digit */ 43 SPDK_NVMF_DOMAIN_ACCEPT_ANY = 2 44 }; 45 46 static int _nvmf_subsystem_destroy(struct spdk_nvmf_subsystem *subsystem); 47 48 /* Returns true if is a valid ASCII string as defined by the NVMe spec */ 49 static bool 50 nvmf_valid_ascii_string(const void *buf, size_t size) 51 { 52 const uint8_t *str = buf; 53 size_t i; 54 55 for (i = 0; i < size; i++) { 56 if (str[i] < 0x20 || str[i] > 0x7E) { 57 return false; 58 } 59 } 60 61 return true; 62 } 63 64 bool 65 nvmf_nqn_is_valid(const char *nqn) 66 { 67 size_t len; 68 struct spdk_uuid uuid_value; 69 uint32_t i; 70 int bytes_consumed; 71 uint32_t domain_label_length; 72 char *reverse_domain_end; 73 uint32_t reverse_domain_end_index; 74 enum spdk_nvmf_nqn_domain_states domain_state = SPDK_NVMF_DOMAIN_ACCEPT_LETTER; 75 76 /* Check for length requirements */ 77 len = strlen(nqn); 78 if (len > SPDK_NVMF_NQN_MAX_LEN) { 79 SPDK_ERRLOG("Invalid NQN \"%s\": length %zu > max %d\n", nqn, len, SPDK_NVMF_NQN_MAX_LEN); 80 return false; 81 } 82 83 /* The nqn must be at least as long as SPDK_NVMF_NQN_MIN_LEN to contain the necessary prefix. */ 84 if (len < SPDK_NVMF_NQN_MIN_LEN) { 85 SPDK_ERRLOG("Invalid NQN \"%s\": length %zu < min %d\n", nqn, len, SPDK_NVMF_NQN_MIN_LEN); 86 return false; 87 } 88 89 /* Check for discovery controller nqn */ 90 if (!strcmp(nqn, SPDK_NVMF_DISCOVERY_NQN)) { 91 return true; 92 } 93 94 /* Check for equality with the generic nqn structure of the form "nqn.2014-08.org.nvmexpress:uuid:11111111-2222-3333-4444-555555555555" */ 95 if (!strncmp(nqn, SPDK_NVMF_NQN_UUID_PRE, SPDK_NVMF_NQN_UUID_PRE_LEN)) { 96 if (len != SPDK_NVMF_NQN_UUID_PRE_LEN + SPDK_NVMF_UUID_STRING_LEN) { 97 SPDK_ERRLOG("Invalid NQN \"%s\": uuid is not the correct length\n", nqn); 98 return false; 99 } 100 101 if (spdk_uuid_parse(&uuid_value, &nqn[SPDK_NVMF_NQN_UUID_PRE_LEN])) { 102 SPDK_ERRLOG("Invalid NQN \"%s\": uuid is not formatted correctly\n", nqn); 103 return false; 104 } 105 return true; 106 } 107 108 /* If the nqn does not match the uuid structure, the next several checks validate the form "nqn.yyyy-mm.reverse.domain:user-string" */ 109 110 if (strncmp(nqn, "nqn.", 4) != 0) { 111 SPDK_ERRLOG("Invalid NQN \"%s\": NQN must begin with \"nqn.\".\n", nqn); 112 return false; 113 } 114 115 /* Check for yyyy-mm. */ 116 if (!(isdigit(nqn[4]) && isdigit(nqn[5]) && isdigit(nqn[6]) && isdigit(nqn[7]) && 117 nqn[8] == '-' && isdigit(nqn[9]) && isdigit(nqn[10]) && nqn[11] == '.')) { 118 SPDK_ERRLOG("Invalid date code in NQN \"%s\"\n", nqn); 119 return false; 120 } 121 122 reverse_domain_end = strchr(nqn, ':'); 123 if (reverse_domain_end != NULL && (reverse_domain_end_index = reverse_domain_end - nqn) < len - 1) { 124 } else { 125 SPDK_ERRLOG("Invalid NQN \"%s\". NQN must contain user specified name with a ':' as a prefix.\n", 126 nqn); 127 return false; 128 } 129 130 /* Check for valid reverse domain */ 131 domain_label_length = 0; 132 for (i = 12; i < reverse_domain_end_index; i++) { 133 if (domain_label_length > SPDK_DOMAIN_LABEL_MAX_LEN) { 134 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". At least one Label is too long.\n", nqn); 135 return false; 136 } 137 138 switch (domain_state) { 139 140 case SPDK_NVMF_DOMAIN_ACCEPT_LETTER: { 141 if (isalpha(nqn[i])) { 142 domain_state = SPDK_NVMF_DOMAIN_ACCEPT_ANY; 143 domain_label_length++; 144 break; 145 } else { 146 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". Label names must start with a letter.\n", nqn); 147 return false; 148 } 149 } 150 151 case SPDK_NVMF_DOMAIN_ACCEPT_LDH: { 152 if (isalpha(nqn[i]) || isdigit(nqn[i])) { 153 domain_state = SPDK_NVMF_DOMAIN_ACCEPT_ANY; 154 domain_label_length++; 155 break; 156 } else if (nqn[i] == '-') { 157 if (i == reverse_domain_end_index - 1) { 158 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". Label names must end with an alphanumeric symbol.\n", 159 nqn); 160 return false; 161 } 162 domain_state = SPDK_NVMF_DOMAIN_ACCEPT_LDH; 163 domain_label_length++; 164 break; 165 } else if (nqn[i] == '.') { 166 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". Label names must end with an alphanumeric symbol.\n", 167 nqn); 168 return false; 169 } else { 170 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". Label names must contain only [a-z,A-Z,0-9,'-','.'].\n", 171 nqn); 172 return false; 173 } 174 } 175 176 case SPDK_NVMF_DOMAIN_ACCEPT_ANY: { 177 if (isalpha(nqn[i]) || isdigit(nqn[i])) { 178 domain_state = SPDK_NVMF_DOMAIN_ACCEPT_ANY; 179 domain_label_length++; 180 break; 181 } else if (nqn[i] == '-') { 182 if (i == reverse_domain_end_index - 1) { 183 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". Label names must end with an alphanumeric symbol.\n", 184 nqn); 185 return false; 186 } 187 domain_state = SPDK_NVMF_DOMAIN_ACCEPT_LDH; 188 domain_label_length++; 189 break; 190 } else if (nqn[i] == '.') { 191 domain_state = SPDK_NVMF_DOMAIN_ACCEPT_LETTER; 192 domain_label_length = 0; 193 break; 194 } else { 195 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". Label names must contain only [a-z,A-Z,0-9,'-','.'].\n", 196 nqn); 197 return false; 198 } 199 } 200 } 201 } 202 203 i = reverse_domain_end_index + 1; 204 while (i < len) { 205 bytes_consumed = utf8_valid(&nqn[i], &nqn[len]); 206 if (bytes_consumed <= 0) { 207 SPDK_ERRLOG("Invalid domain name in NQN \"%s\". Label names must contain only valid utf-8.\n", nqn); 208 return false; 209 } 210 211 i += bytes_consumed; 212 } 213 return true; 214 } 215 216 static void subsystem_state_change_on_pg(struct spdk_io_channel_iter *i); 217 218 struct spdk_nvmf_subsystem * 219 spdk_nvmf_subsystem_create(struct spdk_nvmf_tgt *tgt, 220 const char *nqn, 221 enum spdk_nvmf_subtype type, 222 uint32_t num_ns) 223 { 224 struct spdk_nvmf_subsystem *subsystem; 225 uint32_t sid; 226 227 if (spdk_nvmf_tgt_find_subsystem(tgt, nqn)) { 228 SPDK_ERRLOG("Subsystem NQN '%s' already exists\n", nqn); 229 return NULL; 230 } 231 232 if (!nvmf_nqn_is_valid(nqn)) { 233 SPDK_ERRLOG("Subsystem NQN '%s' is invalid\n", nqn); 234 return NULL; 235 } 236 237 if (type == SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT || 238 type == SPDK_NVMF_SUBTYPE_DISCOVERY) { 239 if (num_ns != 0) { 240 SPDK_ERRLOG("Discovery subsystem cannot have namespaces.\n"); 241 return NULL; 242 } 243 } else if (num_ns == 0) { 244 num_ns = NVMF_SUBSYSTEM_DEFAULT_NAMESPACES; 245 } 246 247 /* Find a free subsystem id (sid) */ 248 sid = spdk_bit_array_find_first_clear(tgt->subsystem_ids, 0); 249 if (sid == UINT32_MAX) { 250 SPDK_ERRLOG("No free subsystem IDs are available for subsystem creation\n"); 251 return NULL; 252 } 253 subsystem = calloc(1, sizeof(struct spdk_nvmf_subsystem)); 254 if (subsystem == NULL) { 255 SPDK_ERRLOG("Subsystem memory allocation failed\n"); 256 return NULL; 257 } 258 259 subsystem->thread = spdk_get_thread(); 260 subsystem->state = SPDK_NVMF_SUBSYSTEM_INACTIVE; 261 subsystem->tgt = tgt; 262 subsystem->id = sid; 263 subsystem->subtype = type; 264 subsystem->max_nsid = num_ns; 265 subsystem->next_cntlid = 1; 266 subsystem->min_cntlid = NVMF_MIN_CNTLID; 267 subsystem->max_cntlid = NVMF_MAX_CNTLID; 268 snprintf(subsystem->subnqn, sizeof(subsystem->subnqn), "%s", nqn); 269 pthread_mutex_init(&subsystem->mutex, NULL); 270 TAILQ_INIT(&subsystem->listeners); 271 TAILQ_INIT(&subsystem->hosts); 272 TAILQ_INIT(&subsystem->ctrlrs); 273 TAILQ_INIT(&subsystem->state_changes); 274 subsystem->used_listener_ids = spdk_bit_array_create(NVMF_MAX_LISTENERS_PER_SUBSYSTEM); 275 if (subsystem->used_listener_ids == NULL) { 276 pthread_mutex_destroy(&subsystem->mutex); 277 free(subsystem); 278 SPDK_ERRLOG("Listener id array memory allocation failed\n"); 279 return NULL; 280 } 281 282 if (num_ns != 0) { 283 subsystem->ns = calloc(num_ns, sizeof(struct spdk_nvmf_ns *)); 284 if (subsystem->ns == NULL) { 285 SPDK_ERRLOG("Namespace memory allocation failed\n"); 286 pthread_mutex_destroy(&subsystem->mutex); 287 spdk_bit_array_free(&subsystem->used_listener_ids); 288 free(subsystem); 289 return NULL; 290 } 291 subsystem->ana_group = calloc(num_ns, sizeof(uint32_t)); 292 if (subsystem->ana_group == NULL) { 293 SPDK_ERRLOG("ANA group memory allocation failed\n"); 294 pthread_mutex_destroy(&subsystem->mutex); 295 free(subsystem->ns); 296 spdk_bit_array_free(&subsystem->used_listener_ids); 297 free(subsystem); 298 return NULL; 299 } 300 } 301 302 memset(subsystem->sn, '0', sizeof(subsystem->sn) - 1); 303 subsystem->sn[sizeof(subsystem->sn) - 1] = '\0'; 304 305 snprintf(subsystem->mn, sizeof(subsystem->mn), "%s", 306 MODEL_NUMBER_DEFAULT); 307 308 spdk_bit_array_set(tgt->subsystem_ids, sid); 309 RB_INSERT(subsystem_tree, &tgt->subsystems, subsystem); 310 311 SPDK_DTRACE_PROBE1(nvmf_subsystem_create, subsystem->subnqn); 312 313 return subsystem; 314 } 315 316 static void 317 nvmf_host_free(struct spdk_nvmf_host *host) 318 { 319 spdk_keyring_put_key(host->dhchap_key); 320 spdk_keyring_put_key(host->dhchap_ctrlr_key); 321 free(host); 322 } 323 324 /* Must hold subsystem->mutex while calling this function */ 325 static void 326 nvmf_subsystem_remove_host(struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_host *host) 327 { 328 TAILQ_REMOVE(&subsystem->hosts, host, link); 329 nvmf_host_free(host); 330 } 331 332 static void 333 _nvmf_subsystem_remove_listener(struct spdk_nvmf_subsystem *subsystem, 334 struct spdk_nvmf_subsystem_listener *listener, 335 bool stop) 336 { 337 struct spdk_nvmf_transport *transport; 338 struct spdk_nvmf_ctrlr *ctrlr; 339 340 if (stop) { 341 transport = spdk_nvmf_tgt_get_transport(subsystem->tgt, listener->trid->trstring); 342 if (transport != NULL) { 343 spdk_nvmf_transport_stop_listen(transport, listener->trid); 344 } 345 } 346 347 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 348 if (ctrlr->listener == listener) { 349 ctrlr->listener = NULL; 350 } 351 } 352 353 TAILQ_REMOVE(&subsystem->listeners, listener, link); 354 if (spdk_nvmf_subsystem_is_discovery(listener->subsystem)) { 355 nvmf_tgt_update_mdns_prr(listener->subsystem->tgt); 356 } 357 spdk_nvmf_send_discovery_log_notice(listener->subsystem->tgt, NULL); 358 free(listener->ana_state); 359 spdk_bit_array_clear(subsystem->used_listener_ids, listener->id); 360 free(listener->opts.sock_impl); 361 free(listener); 362 } 363 364 static void 365 _nvmf_subsystem_destroy_msg(void *cb_arg) 366 { 367 struct spdk_nvmf_subsystem *subsystem = cb_arg; 368 369 _nvmf_subsystem_destroy(subsystem); 370 } 371 372 static int 373 _nvmf_subsystem_destroy(struct spdk_nvmf_subsystem *subsystem) 374 { 375 struct nvmf_subsystem_state_change_ctx *ctx; 376 struct spdk_nvmf_ns *ns; 377 nvmf_subsystem_destroy_cb async_destroy_cb = NULL; 378 void *async_destroy_cb_arg = NULL; 379 int rc; 380 381 if (!TAILQ_EMPTY(&subsystem->ctrlrs)) { 382 SPDK_DEBUGLOG(nvmf, "subsystem %p %s has active controllers\n", subsystem, subsystem->subnqn); 383 subsystem->async_destroy = true; 384 rc = spdk_thread_send_msg(subsystem->thread, _nvmf_subsystem_destroy_msg, subsystem); 385 if (rc) { 386 SPDK_ERRLOG("Failed to send thread msg, rc %d\n", rc); 387 assert(0); 388 return rc; 389 } 390 return -EINPROGRESS; 391 } 392 393 ns = spdk_nvmf_subsystem_get_first_ns(subsystem); 394 while (ns != NULL) { 395 struct spdk_nvmf_ns *next_ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns); 396 397 spdk_nvmf_subsystem_remove_ns(subsystem, ns->opts.nsid); 398 ns = next_ns; 399 } 400 401 while ((ctx = TAILQ_FIRST(&subsystem->state_changes))) { 402 SPDK_WARNLOG("subsystem %s has pending state change requests\n", subsystem->subnqn); 403 TAILQ_REMOVE(&subsystem->state_changes, ctx, link); 404 if (ctx->cb_fn != NULL) { 405 ctx->cb_fn(subsystem, ctx->cb_arg, -ECANCELED); 406 } 407 free(ctx); 408 } 409 410 free(subsystem->ns); 411 free(subsystem->ana_group); 412 413 RB_REMOVE(subsystem_tree, &subsystem->tgt->subsystems, subsystem); 414 assert(spdk_bit_array_get(subsystem->tgt->subsystem_ids, subsystem->id) == true); 415 spdk_bit_array_clear(subsystem->tgt->subsystem_ids, subsystem->id); 416 417 pthread_mutex_destroy(&subsystem->mutex); 418 419 spdk_bit_array_free(&subsystem->used_listener_ids); 420 421 if (subsystem->async_destroy) { 422 async_destroy_cb = subsystem->async_destroy_cb; 423 async_destroy_cb_arg = subsystem->async_destroy_cb_arg; 424 } 425 426 free(subsystem); 427 428 if (async_destroy_cb) { 429 async_destroy_cb(async_destroy_cb_arg); 430 } 431 432 return 0; 433 } 434 435 static struct spdk_nvmf_ns * 436 _nvmf_subsystem_get_first_zoned_ns(struct spdk_nvmf_subsystem *subsystem) 437 { 438 struct spdk_nvmf_ns *ns = spdk_nvmf_subsystem_get_first_ns(subsystem); 439 while (ns != NULL) { 440 if (ns->csi == SPDK_NVME_CSI_ZNS) { 441 return ns; 442 } 443 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns); 444 } 445 return NULL; 446 } 447 448 int 449 spdk_nvmf_subsystem_destroy(struct spdk_nvmf_subsystem *subsystem, nvmf_subsystem_destroy_cb cpl_cb, 450 void *cpl_cb_arg) 451 { 452 struct spdk_nvmf_host *host, *host_tmp; 453 struct spdk_nvmf_transport *transport; 454 455 if (!subsystem) { 456 return -EINVAL; 457 } 458 459 SPDK_DTRACE_PROBE1(nvmf_subsystem_destroy, subsystem->subnqn); 460 461 assert(spdk_get_thread() == subsystem->thread); 462 463 if (subsystem->state != SPDK_NVMF_SUBSYSTEM_INACTIVE) { 464 SPDK_ERRLOG("Subsystem can only be destroyed in inactive state, %s state %d\n", 465 subsystem->subnqn, subsystem->state); 466 return -EAGAIN; 467 } 468 if (subsystem->destroying) { 469 SPDK_ERRLOG("Subsystem destruction is already started\n"); 470 assert(0); 471 return -EALREADY; 472 } 473 474 subsystem->destroying = true; 475 476 SPDK_DEBUGLOG(nvmf, "subsystem is %p %s\n", subsystem, subsystem->subnqn); 477 478 nvmf_subsystem_remove_all_listeners(subsystem, false); 479 480 pthread_mutex_lock(&subsystem->mutex); 481 482 TAILQ_FOREACH_SAFE(host, &subsystem->hosts, link, host_tmp) { 483 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 484 transport = spdk_nvmf_transport_get_next(transport)) { 485 if (transport->ops->subsystem_remove_host) { 486 transport->ops->subsystem_remove_host(transport, subsystem, host->nqn); 487 } 488 } 489 nvmf_subsystem_remove_host(subsystem, host); 490 } 491 492 pthread_mutex_unlock(&subsystem->mutex); 493 494 subsystem->async_destroy_cb = cpl_cb; 495 subsystem->async_destroy_cb_arg = cpl_cb_arg; 496 497 return _nvmf_subsystem_destroy(subsystem); 498 } 499 500 /* we have to use the typedef in the function declaration to appease astyle. */ 501 typedef enum spdk_nvmf_subsystem_state spdk_nvmf_subsystem_state_t; 502 503 static spdk_nvmf_subsystem_state_t 504 nvmf_subsystem_get_intermediate_state(enum spdk_nvmf_subsystem_state current_state, 505 enum spdk_nvmf_subsystem_state requested_state) 506 { 507 switch (requested_state) { 508 case SPDK_NVMF_SUBSYSTEM_INACTIVE: 509 return SPDK_NVMF_SUBSYSTEM_DEACTIVATING; 510 case SPDK_NVMF_SUBSYSTEM_ACTIVE: 511 if (current_state == SPDK_NVMF_SUBSYSTEM_PAUSED) { 512 return SPDK_NVMF_SUBSYSTEM_RESUMING; 513 } else { 514 return SPDK_NVMF_SUBSYSTEM_ACTIVATING; 515 } 516 case SPDK_NVMF_SUBSYSTEM_PAUSED: 517 return SPDK_NVMF_SUBSYSTEM_PAUSING; 518 default: 519 assert(false); 520 return SPDK_NVMF_SUBSYSTEM_NUM_STATES; 521 } 522 } 523 524 static int 525 nvmf_subsystem_set_state(struct spdk_nvmf_subsystem *subsystem, 526 enum spdk_nvmf_subsystem_state state) 527 { 528 enum spdk_nvmf_subsystem_state actual_old_state, expected_old_state; 529 bool exchanged; 530 531 switch (state) { 532 case SPDK_NVMF_SUBSYSTEM_INACTIVE: 533 expected_old_state = SPDK_NVMF_SUBSYSTEM_DEACTIVATING; 534 break; 535 case SPDK_NVMF_SUBSYSTEM_ACTIVATING: 536 expected_old_state = SPDK_NVMF_SUBSYSTEM_INACTIVE; 537 break; 538 case SPDK_NVMF_SUBSYSTEM_ACTIVE: 539 expected_old_state = SPDK_NVMF_SUBSYSTEM_ACTIVATING; 540 break; 541 case SPDK_NVMF_SUBSYSTEM_PAUSING: 542 expected_old_state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 543 break; 544 case SPDK_NVMF_SUBSYSTEM_PAUSED: 545 expected_old_state = SPDK_NVMF_SUBSYSTEM_PAUSING; 546 break; 547 case SPDK_NVMF_SUBSYSTEM_RESUMING: 548 expected_old_state = SPDK_NVMF_SUBSYSTEM_PAUSED; 549 break; 550 case SPDK_NVMF_SUBSYSTEM_DEACTIVATING: 551 expected_old_state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 552 break; 553 default: 554 assert(false); 555 return -1; 556 } 557 558 actual_old_state = expected_old_state; 559 exchanged = __atomic_compare_exchange_n(&subsystem->state, &actual_old_state, state, false, 560 __ATOMIC_RELAXED, __ATOMIC_RELAXED); 561 if (spdk_unlikely(exchanged == false)) { 562 if (actual_old_state == SPDK_NVMF_SUBSYSTEM_RESUMING && 563 state == SPDK_NVMF_SUBSYSTEM_ACTIVE) { 564 expected_old_state = SPDK_NVMF_SUBSYSTEM_RESUMING; 565 } 566 /* This is for the case when activating the subsystem fails. */ 567 if (actual_old_state == SPDK_NVMF_SUBSYSTEM_ACTIVATING && 568 state == SPDK_NVMF_SUBSYSTEM_DEACTIVATING) { 569 expected_old_state = SPDK_NVMF_SUBSYSTEM_ACTIVATING; 570 } 571 /* This is for the case when resuming the subsystem fails. */ 572 if (actual_old_state == SPDK_NVMF_SUBSYSTEM_RESUMING && 573 state == SPDK_NVMF_SUBSYSTEM_PAUSING) { 574 expected_old_state = SPDK_NVMF_SUBSYSTEM_RESUMING; 575 } 576 /* This is for the case when stopping paused subsystem */ 577 if (actual_old_state == SPDK_NVMF_SUBSYSTEM_PAUSED && 578 state == SPDK_NVMF_SUBSYSTEM_DEACTIVATING) { 579 expected_old_state = SPDK_NVMF_SUBSYSTEM_PAUSED; 580 } 581 actual_old_state = expected_old_state; 582 __atomic_compare_exchange_n(&subsystem->state, &actual_old_state, state, false, 583 __ATOMIC_RELAXED, __ATOMIC_RELAXED); 584 } 585 assert(actual_old_state == expected_old_state); 586 return actual_old_state - expected_old_state; 587 } 588 589 static void nvmf_subsystem_do_state_change(struct nvmf_subsystem_state_change_ctx *ctx); 590 591 static void 592 _nvmf_subsystem_state_change_complete(void *_ctx) 593 { 594 struct nvmf_subsystem_state_change_ctx *next, *ctx = _ctx; 595 struct spdk_nvmf_subsystem *subsystem = ctx->subsystem; 596 597 pthread_mutex_lock(&subsystem->mutex); 598 assert(TAILQ_FIRST(&subsystem->state_changes) == ctx); 599 TAILQ_REMOVE(&subsystem->state_changes, ctx, link); 600 next = TAILQ_FIRST(&subsystem->state_changes); 601 pthread_mutex_unlock(&subsystem->mutex); 602 603 if (ctx->cb_fn != NULL) { 604 ctx->cb_fn(subsystem, ctx->cb_arg, ctx->status); 605 } 606 free(ctx); 607 608 if (next != NULL) { 609 nvmf_subsystem_do_state_change(next); 610 } 611 } 612 613 static void 614 nvmf_subsystem_state_change_complete(struct nvmf_subsystem_state_change_ctx *ctx, int status) 615 { 616 ctx->status = status; 617 spdk_thread_exec_msg(ctx->thread, _nvmf_subsystem_state_change_complete, ctx); 618 } 619 620 static void 621 subsystem_state_change_revert_done(struct spdk_io_channel_iter *i, int status) 622 { 623 struct nvmf_subsystem_state_change_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 624 625 /* Nothing to be done here if the state setting fails, we are just screwed. */ 626 if (nvmf_subsystem_set_state(ctx->subsystem, ctx->requested_state)) { 627 SPDK_ERRLOG("Unable to revert the subsystem state after operation failure.\n"); 628 } 629 630 /* return a failure here. This function only exists in an error path. */ 631 nvmf_subsystem_state_change_complete(ctx, -1); 632 } 633 634 static void 635 subsystem_state_change_done(struct spdk_io_channel_iter *i, int status) 636 { 637 struct nvmf_subsystem_state_change_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 638 enum spdk_nvmf_subsystem_state intermediate_state; 639 640 SPDK_DTRACE_PROBE4(nvmf_subsystem_change_state_done, ctx->subsystem->subnqn, 641 ctx->requested_state, ctx->original_state, status); 642 643 if (status == 0) { 644 status = nvmf_subsystem_set_state(ctx->subsystem, ctx->requested_state); 645 if (status) { 646 status = -1; 647 } 648 } 649 650 if (status) { 651 intermediate_state = nvmf_subsystem_get_intermediate_state(ctx->requested_state, 652 ctx->original_state); 653 assert(intermediate_state != SPDK_NVMF_SUBSYSTEM_NUM_STATES); 654 655 if (nvmf_subsystem_set_state(ctx->subsystem, intermediate_state)) { 656 goto out; 657 } 658 ctx->requested_state = ctx->original_state; 659 spdk_for_each_channel(ctx->subsystem->tgt, 660 subsystem_state_change_on_pg, 661 ctx, 662 subsystem_state_change_revert_done); 663 return; 664 } 665 666 out: 667 nvmf_subsystem_state_change_complete(ctx, status); 668 } 669 670 static void 671 subsystem_state_change_continue(void *ctx, int status) 672 { 673 struct spdk_io_channel_iter *i = ctx; 674 struct nvmf_subsystem_state_change_ctx *_ctx __attribute__((unused)); 675 676 _ctx = spdk_io_channel_iter_get_ctx(i); 677 SPDK_DTRACE_PROBE3(nvmf_pg_change_state_done, _ctx->subsystem->subnqn, 678 _ctx->requested_state, spdk_thread_get_id(spdk_get_thread())); 679 680 spdk_for_each_channel_continue(i, status); 681 } 682 683 static void 684 subsystem_state_change_on_pg(struct spdk_io_channel_iter *i) 685 { 686 struct nvmf_subsystem_state_change_ctx *ctx; 687 struct spdk_io_channel *ch; 688 struct spdk_nvmf_poll_group *group; 689 690 ctx = spdk_io_channel_iter_get_ctx(i); 691 ch = spdk_io_channel_iter_get_channel(i); 692 group = spdk_io_channel_get_ctx(ch); 693 694 SPDK_DTRACE_PROBE3(nvmf_pg_change_state, ctx->subsystem->subnqn, 695 ctx->requested_state, spdk_thread_get_id(spdk_get_thread())); 696 switch (ctx->requested_state) { 697 case SPDK_NVMF_SUBSYSTEM_INACTIVE: 698 nvmf_poll_group_remove_subsystem(group, ctx->subsystem, subsystem_state_change_continue, i); 699 break; 700 case SPDK_NVMF_SUBSYSTEM_ACTIVE: 701 if (ctx->subsystem->state == SPDK_NVMF_SUBSYSTEM_ACTIVATING) { 702 nvmf_poll_group_add_subsystem(group, ctx->subsystem, subsystem_state_change_continue, i); 703 } else if (ctx->subsystem->state == SPDK_NVMF_SUBSYSTEM_RESUMING) { 704 nvmf_poll_group_resume_subsystem(group, ctx->subsystem, subsystem_state_change_continue, i); 705 } 706 break; 707 case SPDK_NVMF_SUBSYSTEM_PAUSED: 708 nvmf_poll_group_pause_subsystem(group, ctx->subsystem, ctx->nsid, subsystem_state_change_continue, 709 i); 710 break; 711 default: 712 assert(false); 713 break; 714 } 715 } 716 717 static void 718 nvmf_subsystem_do_state_change(struct nvmf_subsystem_state_change_ctx *ctx) 719 { 720 struct spdk_nvmf_subsystem *subsystem = ctx->subsystem; 721 enum spdk_nvmf_subsystem_state intermediate_state; 722 int rc; 723 724 SPDK_DTRACE_PROBE3(nvmf_subsystem_change_state, subsystem->subnqn, 725 ctx->requested_state, subsystem->state); 726 727 /* If we are already in the requested state, just call the callback immediately. */ 728 if (subsystem->state == ctx->requested_state) { 729 nvmf_subsystem_state_change_complete(ctx, 0); 730 return; 731 } 732 733 intermediate_state = nvmf_subsystem_get_intermediate_state(subsystem->state, 734 ctx->requested_state); 735 assert(intermediate_state != SPDK_NVMF_SUBSYSTEM_NUM_STATES); 736 737 ctx->original_state = subsystem->state; 738 rc = nvmf_subsystem_set_state(subsystem, intermediate_state); 739 if (rc) { 740 nvmf_subsystem_state_change_complete(ctx, -1); 741 return; 742 } 743 744 spdk_for_each_channel(subsystem->tgt, 745 subsystem_state_change_on_pg, 746 ctx, 747 subsystem_state_change_done); 748 } 749 750 751 static int 752 nvmf_subsystem_state_change(struct spdk_nvmf_subsystem *subsystem, 753 uint32_t nsid, 754 enum spdk_nvmf_subsystem_state requested_state, 755 spdk_nvmf_subsystem_state_change_done cb_fn, 756 void *cb_arg) 757 { 758 struct nvmf_subsystem_state_change_ctx *ctx; 759 struct spdk_thread *thread; 760 761 thread = spdk_get_thread(); 762 if (thread == NULL) { 763 return -EINVAL; 764 } 765 766 ctx = calloc(1, sizeof(*ctx)); 767 if (!ctx) { 768 return -ENOMEM; 769 } 770 771 ctx->subsystem = subsystem; 772 ctx->nsid = nsid; 773 ctx->requested_state = requested_state; 774 ctx->cb_fn = cb_fn; 775 ctx->cb_arg = cb_arg; 776 ctx->thread = thread; 777 778 pthread_mutex_lock(&subsystem->mutex); 779 TAILQ_INSERT_TAIL(&subsystem->state_changes, ctx, link); 780 if (ctx != TAILQ_FIRST(&subsystem->state_changes)) { 781 pthread_mutex_unlock(&subsystem->mutex); 782 return 0; 783 } 784 pthread_mutex_unlock(&subsystem->mutex); 785 786 nvmf_subsystem_do_state_change(ctx); 787 788 return 0; 789 } 790 791 int 792 spdk_nvmf_subsystem_start(struct spdk_nvmf_subsystem *subsystem, 793 spdk_nvmf_subsystem_state_change_done cb_fn, 794 void *cb_arg) 795 { 796 return nvmf_subsystem_state_change(subsystem, 0, SPDK_NVMF_SUBSYSTEM_ACTIVE, cb_fn, cb_arg); 797 } 798 799 int 800 spdk_nvmf_subsystem_stop(struct spdk_nvmf_subsystem *subsystem, 801 spdk_nvmf_subsystem_state_change_done cb_fn, 802 void *cb_arg) 803 { 804 return nvmf_subsystem_state_change(subsystem, 0, SPDK_NVMF_SUBSYSTEM_INACTIVE, cb_fn, cb_arg); 805 } 806 807 int 808 spdk_nvmf_subsystem_pause(struct spdk_nvmf_subsystem *subsystem, 809 uint32_t nsid, 810 spdk_nvmf_subsystem_state_change_done cb_fn, 811 void *cb_arg) 812 { 813 return nvmf_subsystem_state_change(subsystem, nsid, SPDK_NVMF_SUBSYSTEM_PAUSED, cb_fn, cb_arg); 814 } 815 816 int 817 spdk_nvmf_subsystem_resume(struct spdk_nvmf_subsystem *subsystem, 818 spdk_nvmf_subsystem_state_change_done cb_fn, 819 void *cb_arg) 820 { 821 return nvmf_subsystem_state_change(subsystem, 0, SPDK_NVMF_SUBSYSTEM_ACTIVE, cb_fn, cb_arg); 822 } 823 824 struct spdk_nvmf_subsystem * 825 spdk_nvmf_subsystem_get_first(struct spdk_nvmf_tgt *tgt) 826 { 827 return RB_MIN(subsystem_tree, &tgt->subsystems); 828 } 829 830 struct spdk_nvmf_subsystem * 831 spdk_nvmf_subsystem_get_next(struct spdk_nvmf_subsystem *subsystem) 832 { 833 if (!subsystem) { 834 return NULL; 835 } 836 837 return RB_NEXT(subsystem_tree, &tgt->subsystems, subsystem); 838 } 839 840 static int 841 nvmf_ns_add_host(struct spdk_nvmf_ns *ns, const char *hostnqn) 842 { 843 struct spdk_nvmf_host *host; 844 845 host = calloc(1, sizeof(*host)); 846 if (!host) { 847 return -ENOMEM; 848 } 849 snprintf(host->nqn, sizeof(host->nqn), "%s", hostnqn); 850 TAILQ_INSERT_HEAD(&ns->hosts, host, link); 851 return 0; 852 } 853 854 static void 855 nvmf_ns_remove_host(struct spdk_nvmf_ns *ns, struct spdk_nvmf_host *host) 856 { 857 TAILQ_REMOVE(&ns->hosts, host, link); 858 free(host); 859 } 860 861 static void 862 _async_event_ns_notice(void *_ctrlr) 863 { 864 struct spdk_nvmf_ctrlr *ctrlr = _ctrlr; 865 866 nvmf_ctrlr_async_event_ns_notice(ctrlr); 867 } 868 869 static void 870 send_async_event_ns_notice(struct spdk_nvmf_ctrlr *ctrlr) 871 { 872 spdk_thread_send_msg(ctrlr->thread, _async_event_ns_notice, ctrlr); 873 } 874 875 static int 876 nvmf_ns_visible(struct spdk_nvmf_subsystem *subsystem, 877 uint32_t nsid, 878 const char *hostnqn, 879 bool visible) 880 { 881 struct spdk_nvmf_ns *ns; 882 struct spdk_nvmf_ctrlr *ctrlr; 883 struct spdk_nvmf_host *host; 884 int rc; 885 886 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 887 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 888 assert(false); 889 return -1; 890 } 891 892 if (hostnqn == NULL || !nvmf_nqn_is_valid(hostnqn)) { 893 return -EINVAL; 894 } 895 896 if (nsid == 0 || nsid > subsystem->max_nsid) { 897 return -EINVAL; 898 } 899 900 ns = subsystem->ns[nsid - 1]; 901 if (!ns) { 902 return -ENOENT; 903 } 904 905 if (ns->always_visible) { 906 /* No individual host control */ 907 return -EPERM; 908 } 909 910 /* Save host info to use for any future controllers. */ 911 host = nvmf_ns_find_host(ns, hostnqn); 912 if (visible && host == NULL) { 913 rc = nvmf_ns_add_host(ns, hostnqn); 914 if (rc) { 915 return rc; 916 } 917 } else if (!visible && host != NULL) { 918 nvmf_ns_remove_host(ns, host); 919 } 920 921 /* Also apply to existing controllers. */ 922 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 923 if (strcmp(hostnqn, ctrlr->hostnqn) || 924 nvmf_ctrlr_ns_is_visible(ctrlr, nsid) == visible) { 925 continue; 926 } 927 nvmf_ctrlr_ns_set_visible(ctrlr, nsid, visible); 928 send_async_event_ns_notice(ctrlr); 929 nvmf_ctrlr_ns_changed(ctrlr, nsid); 930 } 931 932 return 0; 933 } 934 935 int 936 spdk_nvmf_ns_add_host(struct spdk_nvmf_subsystem *subsystem, 937 uint32_t nsid, 938 const char *hostnqn, 939 uint32_t flags) 940 { 941 SPDK_DTRACE_PROBE4(spdk_nvmf_ns_add_host, 942 subsystem->subnqn, 943 nsid, 944 hostnqn, 945 flags); 946 return nvmf_ns_visible(subsystem, nsid, hostnqn, true); 947 } 948 949 int 950 spdk_nvmf_ns_remove_host(struct spdk_nvmf_subsystem *subsystem, 951 uint32_t nsid, 952 const char *hostnqn, 953 uint32_t flags) 954 { 955 SPDK_DTRACE_PROBE4(spdk_nvmf_ns_remove_host, 956 subsystem->subnqn, 957 nsid, 958 hostnqn, 959 flags); 960 return nvmf_ns_visible(subsystem, nsid, hostnqn, false); 961 } 962 963 /* Must hold subsystem->mutex while calling this function */ 964 static struct spdk_nvmf_host * 965 nvmf_subsystem_find_host(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 966 { 967 struct spdk_nvmf_host *host = NULL; 968 969 TAILQ_FOREACH(host, &subsystem->hosts, link) { 970 if (strcmp(hostnqn, host->nqn) == 0) { 971 return host; 972 } 973 } 974 975 return NULL; 976 } 977 978 int 979 spdk_nvmf_subsystem_add_host_ext(struct spdk_nvmf_subsystem *subsystem, 980 const char *hostnqn, struct spdk_nvmf_host_opts *opts) 981 { 982 struct spdk_nvmf_host *host; 983 struct spdk_nvmf_transport *transport; 984 struct spdk_key *key; 985 int rc; 986 987 if (!nvmf_nqn_is_valid(hostnqn)) { 988 return -EINVAL; 989 } 990 991 pthread_mutex_lock(&subsystem->mutex); 992 993 if (nvmf_subsystem_find_host(subsystem, hostnqn)) { 994 /* This subsystem already allows the specified host. */ 995 pthread_mutex_unlock(&subsystem->mutex); 996 return -EINVAL; 997 } 998 999 host = calloc(1, sizeof(*host)); 1000 if (!host) { 1001 pthread_mutex_unlock(&subsystem->mutex); 1002 return -ENOMEM; 1003 } 1004 1005 key = SPDK_GET_FIELD(opts, dhchap_key, NULL); 1006 if (key != NULL) { 1007 if (!nvmf_auth_is_supported()) { 1008 SPDK_ERRLOG("NVMe in-band authentication is unsupported\n"); 1009 pthread_mutex_unlock(&subsystem->mutex); 1010 nvmf_host_free(host); 1011 return -EINVAL; 1012 } 1013 host->dhchap_key = spdk_key_dup(key); 1014 if (host->dhchap_key == NULL) { 1015 pthread_mutex_unlock(&subsystem->mutex); 1016 nvmf_host_free(host); 1017 return -EINVAL; 1018 } 1019 key = SPDK_GET_FIELD(opts, dhchap_ctrlr_key, NULL); 1020 if (key != NULL) { 1021 host->dhchap_ctrlr_key = spdk_key_dup(key); 1022 if (host->dhchap_ctrlr_key == NULL) { 1023 pthread_mutex_unlock(&subsystem->mutex); 1024 nvmf_host_free(host); 1025 return -EINVAL; 1026 } 1027 } 1028 } else if (SPDK_GET_FIELD(opts, dhchap_ctrlr_key, NULL) != NULL) { 1029 SPDK_ERRLOG("DH-HMAC-CHAP controller key requires host key to be set\n"); 1030 pthread_mutex_unlock(&subsystem->mutex); 1031 nvmf_host_free(host); 1032 return -EINVAL; 1033 } 1034 1035 snprintf(host->nqn, sizeof(host->nqn), "%s", hostnqn); 1036 1037 SPDK_DTRACE_PROBE2(nvmf_subsystem_add_host, subsystem->subnqn, host->nqn); 1038 1039 TAILQ_INSERT_HEAD(&subsystem->hosts, host, link); 1040 1041 if (!TAILQ_EMPTY(&subsystem->listeners)) { 1042 spdk_nvmf_send_discovery_log_notice(subsystem->tgt, hostnqn); 1043 } 1044 1045 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 1046 transport = spdk_nvmf_transport_get_next(transport)) { 1047 if (transport->ops->subsystem_add_host) { 1048 rc = transport->ops->subsystem_add_host(transport, subsystem, hostnqn, 1049 SPDK_GET_FIELD(opts, params, NULL)); 1050 if (rc) { 1051 SPDK_ERRLOG("Unable to add host to %s transport\n", transport->ops->name); 1052 /* Remove this host from all transports we've managed to add it to. */ 1053 pthread_mutex_unlock(&subsystem->mutex); 1054 spdk_nvmf_subsystem_remove_host(subsystem, hostnqn); 1055 return rc; 1056 } 1057 } 1058 } 1059 1060 pthread_mutex_unlock(&subsystem->mutex); 1061 1062 return 0; 1063 } 1064 1065 int 1066 spdk_nvmf_subsystem_add_host(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn, 1067 const struct spdk_json_val *params) 1068 { 1069 struct spdk_nvmf_host_opts opts = {}; 1070 1071 opts.size = SPDK_SIZEOF(&opts, params); 1072 opts.params = params; 1073 1074 return spdk_nvmf_subsystem_add_host_ext(subsystem, hostnqn, &opts); 1075 } 1076 1077 int 1078 spdk_nvmf_subsystem_remove_host(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 1079 { 1080 struct spdk_nvmf_host *host; 1081 struct spdk_nvmf_transport *transport; 1082 1083 pthread_mutex_lock(&subsystem->mutex); 1084 1085 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1086 if (host == NULL) { 1087 pthread_mutex_unlock(&subsystem->mutex); 1088 return -ENOENT; 1089 } 1090 1091 SPDK_DTRACE_PROBE2(nvmf_subsystem_remove_host, subsystem->subnqn, host->nqn); 1092 1093 nvmf_subsystem_remove_host(subsystem, host); 1094 1095 if (!TAILQ_EMPTY(&subsystem->listeners)) { 1096 spdk_nvmf_send_discovery_log_notice(subsystem->tgt, hostnqn); 1097 } 1098 1099 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 1100 transport = spdk_nvmf_transport_get_next(transport)) { 1101 if (transport->ops->subsystem_remove_host) { 1102 transport->ops->subsystem_remove_host(transport, subsystem, hostnqn); 1103 } 1104 } 1105 1106 pthread_mutex_unlock(&subsystem->mutex); 1107 1108 return 0; 1109 } 1110 1111 int 1112 spdk_nvmf_subsystem_set_keys(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn, 1113 struct spdk_nvmf_subsystem_key_opts *opts) 1114 { 1115 struct spdk_nvmf_host *host; 1116 struct spdk_key *key, *ckey; 1117 1118 if (!nvmf_auth_is_supported()) { 1119 SPDK_ERRLOG("NVMe in-band authentication is unsupported\n"); 1120 return -EINVAL; 1121 } 1122 1123 pthread_mutex_lock(&subsystem->mutex); 1124 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1125 if (host == NULL) { 1126 pthread_mutex_unlock(&subsystem->mutex); 1127 return -EINVAL; 1128 } 1129 1130 if (SPDK_GET_FIELD(opts, dhchap_key, host->dhchap_key) == NULL && 1131 SPDK_GET_FIELD(opts, dhchap_ctrlr_key, host->dhchap_ctrlr_key) != NULL) { 1132 SPDK_ERRLOG("DH-HMAC-CHAP controller key requires host key to be set\n"); 1133 pthread_mutex_unlock(&subsystem->mutex); 1134 return -EINVAL; 1135 } 1136 key = SPDK_GET_FIELD(opts, dhchap_key, NULL); 1137 if (key != NULL) { 1138 key = spdk_key_dup(key); 1139 if (key == NULL) { 1140 pthread_mutex_unlock(&subsystem->mutex); 1141 return -EINVAL; 1142 } 1143 } 1144 ckey = SPDK_GET_FIELD(opts, dhchap_ctrlr_key, NULL); 1145 if (ckey != NULL) { 1146 ckey = spdk_key_dup(ckey); 1147 if (ckey == NULL) { 1148 pthread_mutex_unlock(&subsystem->mutex); 1149 spdk_keyring_put_key(key); 1150 return -EINVAL; 1151 } 1152 } 1153 if (SPDK_FIELD_VALID(opts, dhchap_key)) { 1154 spdk_keyring_put_key(host->dhchap_key); 1155 host->dhchap_key = key; 1156 } 1157 if (SPDK_FIELD_VALID(opts, dhchap_ctrlr_key)) { 1158 spdk_keyring_put_key(host->dhchap_ctrlr_key); 1159 host->dhchap_ctrlr_key = ckey; 1160 } 1161 pthread_mutex_unlock(&subsystem->mutex); 1162 1163 return 0; 1164 } 1165 1166 struct nvmf_subsystem_disconnect_host_ctx { 1167 struct spdk_nvmf_subsystem *subsystem; 1168 char *hostnqn; 1169 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn; 1170 void *cb_arg; 1171 }; 1172 1173 static void 1174 nvmf_subsystem_disconnect_host_fini(struct spdk_io_channel_iter *i, int status) 1175 { 1176 struct nvmf_subsystem_disconnect_host_ctx *ctx; 1177 1178 ctx = spdk_io_channel_iter_get_ctx(i); 1179 1180 if (ctx->cb_fn) { 1181 ctx->cb_fn(ctx->cb_arg, status); 1182 } 1183 free(ctx->hostnqn); 1184 free(ctx); 1185 } 1186 1187 static void 1188 nvmf_subsystem_disconnect_qpairs_by_host(struct spdk_io_channel_iter *i) 1189 { 1190 struct nvmf_subsystem_disconnect_host_ctx *ctx; 1191 struct spdk_nvmf_poll_group *group; 1192 struct spdk_io_channel *ch; 1193 struct spdk_nvmf_qpair *qpair, *tmp_qpair; 1194 struct spdk_nvmf_ctrlr *ctrlr; 1195 1196 ctx = spdk_io_channel_iter_get_ctx(i); 1197 ch = spdk_io_channel_iter_get_channel(i); 1198 group = spdk_io_channel_get_ctx(ch); 1199 1200 TAILQ_FOREACH_SAFE(qpair, &group->qpairs, link, tmp_qpair) { 1201 ctrlr = qpair->ctrlr; 1202 1203 if (ctrlr == NULL || ctrlr->subsys != ctx->subsystem) { 1204 continue; 1205 } 1206 1207 if (strncmp(ctrlr->hostnqn, ctx->hostnqn, sizeof(ctrlr->hostnqn)) == 0) { 1208 /* Right now this does not wait for the queue pairs to actually disconnect. */ 1209 spdk_nvmf_qpair_disconnect(qpair); 1210 } 1211 } 1212 spdk_for_each_channel_continue(i, 0); 1213 } 1214 1215 int 1216 spdk_nvmf_subsystem_disconnect_host(struct spdk_nvmf_subsystem *subsystem, 1217 const char *hostnqn, 1218 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1219 void *cb_arg) 1220 { 1221 struct nvmf_subsystem_disconnect_host_ctx *ctx; 1222 1223 ctx = calloc(1, sizeof(struct nvmf_subsystem_disconnect_host_ctx)); 1224 if (ctx == NULL) { 1225 return -ENOMEM; 1226 } 1227 1228 ctx->hostnqn = strdup(hostnqn); 1229 if (ctx->hostnqn == NULL) { 1230 free(ctx); 1231 return -ENOMEM; 1232 } 1233 1234 ctx->subsystem = subsystem; 1235 ctx->cb_fn = cb_fn; 1236 ctx->cb_arg = cb_arg; 1237 1238 spdk_for_each_channel(subsystem->tgt, nvmf_subsystem_disconnect_qpairs_by_host, ctx, 1239 nvmf_subsystem_disconnect_host_fini); 1240 1241 return 0; 1242 } 1243 1244 int 1245 spdk_nvmf_subsystem_set_allow_any_host(struct spdk_nvmf_subsystem *subsystem, bool allow_any_host) 1246 { 1247 pthread_mutex_lock(&subsystem->mutex); 1248 subsystem->allow_any_host = allow_any_host; 1249 if (!TAILQ_EMPTY(&subsystem->listeners)) { 1250 spdk_nvmf_send_discovery_log_notice(subsystem->tgt, NULL); 1251 } 1252 pthread_mutex_unlock(&subsystem->mutex); 1253 1254 return 0; 1255 } 1256 1257 bool 1258 spdk_nvmf_subsystem_get_allow_any_host(const struct spdk_nvmf_subsystem *subsystem) 1259 { 1260 bool allow_any_host; 1261 struct spdk_nvmf_subsystem *sub; 1262 1263 /* Technically, taking the mutex modifies data in the subsystem. But the const 1264 * is still important to convey that this doesn't mutate any other data. Cast 1265 * it away to work around this. */ 1266 sub = (struct spdk_nvmf_subsystem *)subsystem; 1267 1268 pthread_mutex_lock(&sub->mutex); 1269 allow_any_host = sub->allow_any_host; 1270 pthread_mutex_unlock(&sub->mutex); 1271 1272 return allow_any_host; 1273 } 1274 1275 bool 1276 spdk_nvmf_subsystem_host_allowed(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 1277 { 1278 bool allowed; 1279 1280 if (!hostnqn) { 1281 return false; 1282 } 1283 1284 pthread_mutex_lock(&subsystem->mutex); 1285 1286 if (subsystem->allow_any_host) { 1287 pthread_mutex_unlock(&subsystem->mutex); 1288 return true; 1289 } 1290 1291 allowed = nvmf_subsystem_find_host(subsystem, hostnqn) != NULL; 1292 pthread_mutex_unlock(&subsystem->mutex); 1293 1294 return allowed; 1295 } 1296 1297 bool 1298 nvmf_subsystem_host_auth_required(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 1299 { 1300 struct spdk_nvmf_host *host; 1301 bool status; 1302 1303 pthread_mutex_lock(&subsystem->mutex); 1304 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1305 status = host != NULL && host->dhchap_key != NULL; 1306 pthread_mutex_unlock(&subsystem->mutex); 1307 1308 return status; 1309 } 1310 1311 struct spdk_key * 1312 nvmf_subsystem_get_dhchap_key(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn, 1313 enum nvmf_auth_key_type type) 1314 { 1315 struct spdk_nvmf_host *host; 1316 struct spdk_key *key = NULL; 1317 1318 pthread_mutex_lock(&subsystem->mutex); 1319 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1320 if (host != NULL) { 1321 switch (type) { 1322 case NVMF_AUTH_KEY_HOST: 1323 key = host->dhchap_key; 1324 break; 1325 case NVMF_AUTH_KEY_CTRLR: 1326 key = host->dhchap_ctrlr_key; 1327 break; 1328 } 1329 if (key != NULL) { 1330 key = spdk_key_dup(key); 1331 } 1332 } 1333 pthread_mutex_unlock(&subsystem->mutex); 1334 1335 return key; 1336 } 1337 1338 struct spdk_nvmf_host * 1339 spdk_nvmf_subsystem_get_first_host(struct spdk_nvmf_subsystem *subsystem) 1340 { 1341 return TAILQ_FIRST(&subsystem->hosts); 1342 } 1343 1344 1345 struct spdk_nvmf_host * 1346 spdk_nvmf_subsystem_get_next_host(struct spdk_nvmf_subsystem *subsystem, 1347 struct spdk_nvmf_host *prev_host) 1348 { 1349 return TAILQ_NEXT(prev_host, link); 1350 } 1351 1352 const char * 1353 spdk_nvmf_host_get_nqn(const struct spdk_nvmf_host *host) 1354 { 1355 return host->nqn; 1356 } 1357 1358 struct spdk_nvmf_subsystem_listener * 1359 nvmf_subsystem_find_listener(struct spdk_nvmf_subsystem *subsystem, 1360 const struct spdk_nvme_transport_id *trid) 1361 { 1362 struct spdk_nvmf_subsystem_listener *listener; 1363 1364 TAILQ_FOREACH(listener, &subsystem->listeners, link) { 1365 if (spdk_nvme_transport_id_compare(listener->trid, trid) == 0) { 1366 return listener; 1367 } 1368 } 1369 1370 return NULL; 1371 } 1372 1373 /** 1374 * Function to be called once the target is listening. 1375 * 1376 * \param ctx Context argument passed to this function. 1377 * \param status 0 if it completed successfully, or negative errno if it failed. 1378 */ 1379 static void 1380 _nvmf_subsystem_add_listener_done(void *ctx, int status) 1381 { 1382 struct spdk_nvmf_subsystem_listener *listener = ctx; 1383 1384 if (status) { 1385 listener->cb_fn(listener->cb_arg, status); 1386 free(listener); 1387 return; 1388 } 1389 1390 TAILQ_INSERT_HEAD(&listener->subsystem->listeners, listener, link); 1391 1392 if (spdk_nvmf_subsystem_is_discovery(listener->subsystem)) { 1393 status = nvmf_tgt_update_mdns_prr(listener->subsystem->tgt); 1394 if (status) { 1395 TAILQ_REMOVE(&listener->subsystem->listeners, listener, link); 1396 listener->cb_fn(listener->cb_arg, status); 1397 free(listener); 1398 return; 1399 } 1400 } 1401 1402 spdk_nvmf_send_discovery_log_notice(listener->subsystem->tgt, NULL); 1403 listener->cb_fn(listener->cb_arg, status); 1404 } 1405 1406 void 1407 spdk_nvmf_subsystem_listener_opts_init(struct spdk_nvmf_listener_opts *opts, size_t size) 1408 { 1409 if (opts == NULL) { 1410 SPDK_ERRLOG("opts should not be NULL\n"); 1411 assert(false); 1412 return; 1413 } 1414 if (size == 0) { 1415 SPDK_ERRLOG("size should not be zero\n"); 1416 assert(false); 1417 return; 1418 } 1419 1420 memset(opts, 0, size); 1421 opts->opts_size = size; 1422 1423 #define FIELD_OK(field) \ 1424 offsetof(struct spdk_nvmf_listener_opts, field) + sizeof(opts->field) <= size 1425 1426 #define SET_FIELD(field, value) \ 1427 if (FIELD_OK(field)) { \ 1428 opts->field = value; \ 1429 } \ 1430 1431 SET_FIELD(secure_channel, false); 1432 SET_FIELD(ana_state, SPDK_NVME_ANA_OPTIMIZED_STATE); 1433 SET_FIELD(sock_impl, NULL); 1434 1435 #undef FIELD_OK 1436 #undef SET_FIELD 1437 } 1438 1439 static int 1440 listener_opts_copy(struct spdk_nvmf_listener_opts *src, struct spdk_nvmf_listener_opts *dst) 1441 { 1442 if (src->opts_size == 0) { 1443 SPDK_ERRLOG("source structure size should not be zero\n"); 1444 assert(false); 1445 return -EINVAL; 1446 } 1447 1448 memset(dst, 0, sizeof(*dst)); 1449 dst->opts_size = src->opts_size; 1450 1451 #define FIELD_OK(field) \ 1452 offsetof(struct spdk_nvmf_listener_opts, field) + sizeof(src->field) <= src->opts_size 1453 1454 #define SET_FIELD(field) \ 1455 if (FIELD_OK(field)) { \ 1456 dst->field = src->field; \ 1457 } \ 1458 1459 SET_FIELD(secure_channel); 1460 SET_FIELD(ana_state); 1461 SET_FIELD(sock_impl); 1462 /* We should not remove this statement, but need to update the assert statement 1463 * if we add a new field, and also add a corresponding SET_FIELD statement. */ 1464 SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_listener_opts) == 24, "Incorrect size"); 1465 1466 #undef SET_FIELD 1467 #undef FIELD_OK 1468 1469 return 0; 1470 } 1471 1472 static void 1473 _nvmf_subsystem_add_listener(struct spdk_nvmf_subsystem *subsystem, 1474 struct spdk_nvme_transport_id *trid, 1475 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1476 void *cb_arg, struct spdk_nvmf_listener_opts *opts) 1477 { 1478 struct spdk_nvmf_transport *transport; 1479 struct spdk_nvmf_subsystem_listener *listener; 1480 struct spdk_nvmf_listener *tr_listener; 1481 uint32_t i; 1482 uint32_t id; 1483 int rc = 0; 1484 1485 assert(cb_fn != NULL); 1486 1487 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 1488 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 1489 cb_fn(cb_arg, -EAGAIN); 1490 return; 1491 } 1492 1493 if (nvmf_subsystem_find_listener(subsystem, trid)) { 1494 /* Listener already exists in this subsystem */ 1495 cb_fn(cb_arg, 0); 1496 return; 1497 } 1498 1499 transport = spdk_nvmf_tgt_get_transport(subsystem->tgt, trid->trstring); 1500 if (!transport) { 1501 SPDK_ERRLOG("Unable to find %s transport. The transport must be created first also make sure it is properly registered.\n", 1502 trid->trstring); 1503 cb_fn(cb_arg, -EINVAL); 1504 return; 1505 } 1506 1507 tr_listener = nvmf_transport_find_listener(transport, trid); 1508 if (!tr_listener) { 1509 SPDK_ERRLOG("Cannot find transport listener for %s\n", trid->traddr); 1510 cb_fn(cb_arg, -EINVAL); 1511 return; 1512 } 1513 1514 listener = calloc(1, sizeof(*listener)); 1515 if (!listener) { 1516 cb_fn(cb_arg, -ENOMEM); 1517 return; 1518 } 1519 1520 listener->trid = &tr_listener->trid; 1521 listener->transport = transport; 1522 listener->cb_fn = cb_fn; 1523 listener->cb_arg = cb_arg; 1524 listener->subsystem = subsystem; 1525 listener->ana_state = calloc(subsystem->max_nsid, sizeof(enum spdk_nvme_ana_state)); 1526 if (!listener->ana_state) { 1527 free(listener); 1528 cb_fn(cb_arg, -ENOMEM); 1529 return; 1530 } 1531 1532 spdk_nvmf_subsystem_listener_opts_init(&listener->opts, sizeof(listener->opts)); 1533 if (opts != NULL) { 1534 rc = listener_opts_copy(opts, &listener->opts); 1535 if (rc) { 1536 SPDK_ERRLOG("Unable to copy listener options\n"); 1537 free(listener->ana_state); 1538 free(listener); 1539 cb_fn(cb_arg, -EINVAL); 1540 return; 1541 } 1542 } 1543 1544 id = spdk_bit_array_find_first_clear(subsystem->used_listener_ids, 0); 1545 if (id == UINT32_MAX) { 1546 SPDK_ERRLOG("Cannot add any more listeners\n"); 1547 free(listener->ana_state); 1548 free(listener->opts.sock_impl); 1549 free(listener); 1550 cb_fn(cb_arg, -EINVAL); 1551 return; 1552 } 1553 1554 spdk_bit_array_set(subsystem->used_listener_ids, id); 1555 listener->id = id; 1556 1557 for (i = 0; i < subsystem->max_nsid; i++) { 1558 listener->ana_state[i] = listener->opts.ana_state; 1559 } 1560 1561 if (transport->ops->listen_associate != NULL) { 1562 rc = transport->ops->listen_associate(transport, subsystem, trid); 1563 } 1564 1565 SPDK_DTRACE_PROBE4(nvmf_subsystem_add_listener, subsystem->subnqn, listener->trid->trtype, 1566 listener->trid->traddr, listener->trid->trsvcid); 1567 1568 _nvmf_subsystem_add_listener_done(listener, rc); 1569 } 1570 1571 void 1572 spdk_nvmf_subsystem_add_listener(struct spdk_nvmf_subsystem *subsystem, 1573 struct spdk_nvme_transport_id *trid, 1574 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1575 void *cb_arg) 1576 { 1577 _nvmf_subsystem_add_listener(subsystem, trid, cb_fn, cb_arg, NULL); 1578 } 1579 1580 void 1581 spdk_nvmf_subsystem_add_listener_ext(struct spdk_nvmf_subsystem *subsystem, 1582 struct spdk_nvme_transport_id *trid, 1583 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1584 void *cb_arg, struct spdk_nvmf_listener_opts *opts) 1585 { 1586 _nvmf_subsystem_add_listener(subsystem, trid, cb_fn, cb_arg, opts); 1587 } 1588 1589 int 1590 spdk_nvmf_subsystem_remove_listener(struct spdk_nvmf_subsystem *subsystem, 1591 const struct spdk_nvme_transport_id *trid) 1592 { 1593 struct spdk_nvmf_subsystem_listener *listener; 1594 1595 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 1596 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 1597 return -EAGAIN; 1598 } 1599 1600 listener = nvmf_subsystem_find_listener(subsystem, trid); 1601 if (listener == NULL) { 1602 return -ENOENT; 1603 } 1604 1605 SPDK_DTRACE_PROBE4(nvmf_subsystem_remove_listener, subsystem->subnqn, listener->trid->trtype, 1606 listener->trid->traddr, listener->trid->trsvcid); 1607 1608 _nvmf_subsystem_remove_listener(subsystem, listener, false); 1609 1610 return 0; 1611 } 1612 1613 void 1614 nvmf_subsystem_remove_all_listeners(struct spdk_nvmf_subsystem *subsystem, 1615 bool stop) 1616 { 1617 struct spdk_nvmf_subsystem_listener *listener, *listener_tmp; 1618 1619 TAILQ_FOREACH_SAFE(listener, &subsystem->listeners, link, listener_tmp) { 1620 _nvmf_subsystem_remove_listener(subsystem, listener, stop); 1621 } 1622 } 1623 1624 bool 1625 spdk_nvmf_subsystem_listener_allowed(struct spdk_nvmf_subsystem *subsystem, 1626 const struct spdk_nvme_transport_id *trid) 1627 { 1628 struct spdk_nvmf_subsystem_listener *listener; 1629 1630 TAILQ_FOREACH(listener, &subsystem->listeners, link) { 1631 if (spdk_nvme_transport_id_compare(listener->trid, trid) == 0) { 1632 return true; 1633 } 1634 } 1635 1636 if (!strcmp(subsystem->subnqn, SPDK_NVMF_DISCOVERY_NQN)) { 1637 SPDK_WARNLOG("Allowing connection to discovery subsystem on %s/%s/%s, " 1638 "even though this listener was not added to the discovery " 1639 "subsystem. This behavior is deprecated and will be removed " 1640 "in a future release.\n", 1641 spdk_nvme_transport_id_trtype_str(trid->trtype), trid->traddr, trid->trsvcid); 1642 return true; 1643 } 1644 1645 return false; 1646 } 1647 1648 struct spdk_nvmf_subsystem_listener * 1649 spdk_nvmf_subsystem_get_first_listener(struct spdk_nvmf_subsystem *subsystem) 1650 { 1651 return TAILQ_FIRST(&subsystem->listeners); 1652 } 1653 1654 struct spdk_nvmf_subsystem_listener * 1655 spdk_nvmf_subsystem_get_next_listener(struct spdk_nvmf_subsystem *subsystem, 1656 struct spdk_nvmf_subsystem_listener *prev_listener) 1657 { 1658 return TAILQ_NEXT(prev_listener, link); 1659 } 1660 1661 const struct spdk_nvme_transport_id * 1662 spdk_nvmf_subsystem_listener_get_trid(struct spdk_nvmf_subsystem_listener *listener) 1663 { 1664 return listener->trid; 1665 } 1666 1667 void 1668 spdk_nvmf_subsystem_allow_any_listener(struct spdk_nvmf_subsystem *subsystem, 1669 bool allow_any_listener) 1670 { 1671 subsystem->flags.allow_any_listener = allow_any_listener; 1672 } 1673 1674 bool 1675 spdk_nvmf_subsystem_any_listener_allowed(struct spdk_nvmf_subsystem *subsystem) 1676 { 1677 return subsystem->flags.allow_any_listener; 1678 } 1679 1680 struct subsystem_update_ns_ctx { 1681 struct spdk_nvmf_subsystem *subsystem; 1682 1683 spdk_nvmf_subsystem_state_change_done cb_fn; 1684 void *cb_arg; 1685 }; 1686 1687 static void 1688 subsystem_update_ns_done(struct spdk_io_channel_iter *i, int status) 1689 { 1690 struct subsystem_update_ns_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 1691 1692 if (ctx->cb_fn) { 1693 ctx->cb_fn(ctx->subsystem, ctx->cb_arg, status); 1694 } 1695 free(ctx); 1696 } 1697 1698 static void 1699 subsystem_update_ns_on_pg(struct spdk_io_channel_iter *i) 1700 { 1701 int rc; 1702 struct subsystem_update_ns_ctx *ctx; 1703 struct spdk_nvmf_poll_group *group; 1704 struct spdk_nvmf_subsystem *subsystem; 1705 1706 ctx = spdk_io_channel_iter_get_ctx(i); 1707 group = spdk_io_channel_get_ctx(spdk_io_channel_iter_get_channel(i)); 1708 subsystem = ctx->subsystem; 1709 1710 rc = nvmf_poll_group_update_subsystem(group, subsystem); 1711 spdk_for_each_channel_continue(i, rc); 1712 } 1713 1714 static int 1715 nvmf_subsystem_update_ns(struct spdk_nvmf_subsystem *subsystem, 1716 spdk_nvmf_subsystem_state_change_done cb_fn, void *cb_arg) 1717 { 1718 struct subsystem_update_ns_ctx *ctx; 1719 1720 ctx = calloc(1, sizeof(*ctx)); 1721 if (ctx == NULL) { 1722 SPDK_ERRLOG("Can't alloc subsystem poll group update context\n"); 1723 return -ENOMEM; 1724 } 1725 ctx->subsystem = subsystem; 1726 ctx->cb_fn = cb_fn; 1727 ctx->cb_arg = cb_arg; 1728 1729 spdk_for_each_channel(subsystem->tgt, 1730 subsystem_update_ns_on_pg, 1731 ctx, 1732 subsystem_update_ns_done); 1733 return 0; 1734 } 1735 1736 static void 1737 nvmf_subsystem_ns_changed(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid) 1738 { 1739 struct spdk_nvmf_ctrlr *ctrlr; 1740 1741 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1742 if (nvmf_ctrlr_ns_is_visible(ctrlr, nsid)) { 1743 nvmf_ctrlr_ns_changed(ctrlr, nsid); 1744 } 1745 } 1746 } 1747 1748 static uint32_t nvmf_ns_reservation_clear_all_registrants(struct spdk_nvmf_ns *ns); 1749 1750 int 1751 spdk_nvmf_subsystem_remove_ns(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid) 1752 { 1753 struct spdk_nvmf_transport *transport; 1754 struct spdk_nvmf_ns *ns; 1755 struct spdk_nvmf_host *host, *tmp; 1756 struct spdk_nvmf_ctrlr *ctrlr; 1757 1758 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 1759 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 1760 assert(false); 1761 return -1; 1762 } 1763 1764 if (nsid == 0 || nsid > subsystem->max_nsid) { 1765 return -1; 1766 } 1767 1768 ns = subsystem->ns[nsid - 1]; 1769 if (!ns) { 1770 return -1; 1771 } 1772 1773 subsystem->ns[nsid - 1] = NULL; 1774 1775 assert(ns->anagrpid - 1 < subsystem->max_nsid); 1776 assert(subsystem->ana_group[ns->anagrpid - 1] > 0); 1777 1778 subsystem->ana_group[ns->anagrpid - 1]--; 1779 1780 TAILQ_FOREACH_SAFE(host, &ns->hosts, link, tmp) { 1781 nvmf_ns_remove_host(ns, host); 1782 } 1783 1784 free(ns->ptpl_file); 1785 nvmf_ns_reservation_clear_all_registrants(ns); 1786 spdk_bdev_module_release_bdev(ns->bdev); 1787 spdk_bdev_close(ns->desc); 1788 free(ns); 1789 1790 if (subsystem->fdp_supported && !spdk_nvmf_subsystem_get_first_ns(subsystem)) { 1791 subsystem->fdp_supported = false; 1792 SPDK_DEBUGLOG(nvmf, "Subsystem with id: %u doesn't have FDP capability.\n", 1793 subsystem->id); 1794 } 1795 1796 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 1797 transport = spdk_nvmf_transport_get_next(transport)) { 1798 if (transport->ops->subsystem_remove_ns) { 1799 transport->ops->subsystem_remove_ns(transport, subsystem, nsid); 1800 } 1801 } 1802 1803 nvmf_subsystem_ns_changed(subsystem, nsid); 1804 1805 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1806 nvmf_ctrlr_ns_set_visible(ctrlr, nsid, false); 1807 } 1808 1809 return 0; 1810 } 1811 1812 struct subsystem_ns_change_ctx { 1813 struct spdk_nvmf_subsystem *subsystem; 1814 spdk_nvmf_subsystem_state_change_done cb_fn; 1815 uint32_t nsid; 1816 }; 1817 1818 static void 1819 _nvmf_ns_hot_remove(struct spdk_nvmf_subsystem *subsystem, 1820 void *cb_arg, int status) 1821 { 1822 struct subsystem_ns_change_ctx *ctx = cb_arg; 1823 int rc; 1824 1825 rc = spdk_nvmf_subsystem_remove_ns(subsystem, ctx->nsid); 1826 if (rc != 0) { 1827 SPDK_ERRLOG("Failed to make changes to NVME-oF subsystem with id: %u\n", subsystem->id); 1828 } 1829 1830 rc = spdk_nvmf_subsystem_resume(subsystem, NULL, NULL); 1831 if (rc != 0) { 1832 SPDK_ERRLOG("Failed to resume NVME-oF subsystem with id: %u\n", subsystem->id); 1833 } 1834 1835 free(ctx); 1836 } 1837 1838 static void 1839 nvmf_ns_change_msg(void *ns_ctx) 1840 { 1841 struct subsystem_ns_change_ctx *ctx = ns_ctx; 1842 int rc; 1843 1844 SPDK_DTRACE_PROBE2(nvmf_ns_change, ctx->nsid, ctx->subsystem->subnqn); 1845 1846 rc = spdk_nvmf_subsystem_pause(ctx->subsystem, ctx->nsid, ctx->cb_fn, ctx); 1847 if (rc) { 1848 if (rc == -EBUSY) { 1849 /* Try again, this is not a permanent situation. */ 1850 spdk_thread_send_msg(spdk_get_thread(), nvmf_ns_change_msg, ctx); 1851 } else { 1852 free(ctx); 1853 SPDK_ERRLOG("Unable to pause subsystem to process namespace removal!\n"); 1854 } 1855 } 1856 } 1857 1858 static void 1859 nvmf_ns_hot_remove(void *remove_ctx) 1860 { 1861 struct spdk_nvmf_ns *ns = remove_ctx; 1862 struct subsystem_ns_change_ctx *ns_ctx; 1863 int rc; 1864 1865 /* We have to allocate a new context because this op 1866 * is asynchronous and we could lose the ns in the middle. 1867 */ 1868 ns_ctx = calloc(1, sizeof(struct subsystem_ns_change_ctx)); 1869 if (!ns_ctx) { 1870 SPDK_ERRLOG("Unable to allocate context to process namespace removal!\n"); 1871 return; 1872 } 1873 1874 ns_ctx->subsystem = ns->subsystem; 1875 ns_ctx->nsid = ns->opts.nsid; 1876 ns_ctx->cb_fn = _nvmf_ns_hot_remove; 1877 1878 rc = spdk_nvmf_subsystem_pause(ns->subsystem, ns_ctx->nsid, _nvmf_ns_hot_remove, ns_ctx); 1879 if (rc) { 1880 if (rc == -EBUSY) { 1881 /* Try again, this is not a permanent situation. */ 1882 spdk_thread_send_msg(spdk_get_thread(), nvmf_ns_change_msg, ns_ctx); 1883 } else { 1884 SPDK_ERRLOG("Unable to pause subsystem to process namespace removal!\n"); 1885 free(ns_ctx); 1886 } 1887 } 1888 } 1889 1890 static void 1891 _nvmf_ns_resize(struct spdk_nvmf_subsystem *subsystem, void *cb_arg, int status) 1892 { 1893 struct subsystem_ns_change_ctx *ctx = cb_arg; 1894 1895 nvmf_subsystem_ns_changed(subsystem, ctx->nsid); 1896 if (spdk_nvmf_subsystem_resume(subsystem, NULL, NULL) != 0) { 1897 SPDK_ERRLOG("Failed to resume NVME-oF subsystem with id: %u\n", subsystem->id); 1898 } 1899 1900 free(ctx); 1901 } 1902 1903 static void 1904 nvmf_ns_resize(void *event_ctx) 1905 { 1906 struct spdk_nvmf_ns *ns = event_ctx; 1907 struct subsystem_ns_change_ctx *ns_ctx; 1908 int rc; 1909 1910 /* We have to allocate a new context because this op 1911 * is asynchronous and we could lose the ns in the middle. 1912 */ 1913 ns_ctx = calloc(1, sizeof(struct subsystem_ns_change_ctx)); 1914 if (!ns_ctx) { 1915 SPDK_ERRLOG("Unable to allocate context to process namespace removal!\n"); 1916 return; 1917 } 1918 1919 ns_ctx->subsystem = ns->subsystem; 1920 ns_ctx->nsid = ns->opts.nsid; 1921 ns_ctx->cb_fn = _nvmf_ns_resize; 1922 1923 /* Specify 0 for the nsid here, because we do not need to pause the namespace. 1924 * Namespaces can only be resized bigger, so there is no need to quiesce I/O. 1925 */ 1926 rc = spdk_nvmf_subsystem_pause(ns->subsystem, 0, _nvmf_ns_resize, ns_ctx); 1927 if (rc) { 1928 if (rc == -EBUSY) { 1929 /* Try again, this is not a permanent situation. */ 1930 spdk_thread_send_msg(spdk_get_thread(), nvmf_ns_change_msg, ns_ctx); 1931 } else { 1932 SPDK_ERRLOG("Unable to pause subsystem to process namespace resize!\n"); 1933 free(ns_ctx); 1934 } 1935 } 1936 } 1937 1938 static void 1939 nvmf_ns_event(enum spdk_bdev_event_type type, 1940 struct spdk_bdev *bdev, 1941 void *event_ctx) 1942 { 1943 SPDK_DEBUGLOG(nvmf, "Bdev event: type %d, name %s, subsystem_id %d, ns_id %d\n", 1944 type, 1945 spdk_bdev_get_name(bdev), 1946 ((struct spdk_nvmf_ns *)event_ctx)->subsystem->id, 1947 ((struct spdk_nvmf_ns *)event_ctx)->nsid); 1948 1949 switch (type) { 1950 case SPDK_BDEV_EVENT_REMOVE: 1951 nvmf_ns_hot_remove(event_ctx); 1952 break; 1953 case SPDK_BDEV_EVENT_RESIZE: 1954 nvmf_ns_resize(event_ctx); 1955 break; 1956 default: 1957 SPDK_NOTICELOG("Unsupported bdev event: type %d\n", type); 1958 break; 1959 } 1960 } 1961 1962 void 1963 spdk_nvmf_ns_opts_get_defaults(struct spdk_nvmf_ns_opts *opts, size_t opts_size) 1964 { 1965 if (!opts) { 1966 SPDK_ERRLOG("opts should not be NULL.\n"); 1967 return; 1968 } 1969 1970 if (!opts_size) { 1971 SPDK_ERRLOG("opts_size should not be zero.\n"); 1972 return; 1973 } 1974 1975 memset(opts, 0, opts_size); 1976 opts->opts_size = opts_size; 1977 1978 #define FIELD_OK(field) \ 1979 offsetof(struct spdk_nvmf_ns_opts, field) + sizeof(opts->field) <= opts_size 1980 1981 #define SET_FIELD(field, value) \ 1982 if (FIELD_OK(field)) { \ 1983 opts->field = value; \ 1984 } \ 1985 1986 /* All current fields are set to 0 by default. */ 1987 SET_FIELD(nsid, 0); 1988 if (FIELD_OK(nguid)) { 1989 memset(opts->nguid, 0, sizeof(opts->nguid)); 1990 } 1991 if (FIELD_OK(eui64)) { 1992 memset(opts->eui64, 0, sizeof(opts->eui64)); 1993 } 1994 if (FIELD_OK(uuid)) { 1995 spdk_uuid_set_null(&opts->uuid); 1996 } 1997 SET_FIELD(anagrpid, 0); 1998 SET_FIELD(transport_specific, NULL); 1999 2000 #undef FIELD_OK 2001 #undef SET_FIELD 2002 } 2003 2004 static void 2005 nvmf_ns_opts_copy(struct spdk_nvmf_ns_opts *opts, 2006 const struct spdk_nvmf_ns_opts *user_opts, 2007 size_t opts_size) 2008 { 2009 #define FIELD_OK(field) \ 2010 offsetof(struct spdk_nvmf_ns_opts, field) + sizeof(opts->field) <= user_opts->opts_size 2011 2012 #define SET_FIELD(field) \ 2013 if (FIELD_OK(field)) { \ 2014 opts->field = user_opts->field; \ 2015 } \ 2016 2017 SET_FIELD(nsid); 2018 if (FIELD_OK(nguid)) { 2019 memcpy(opts->nguid, user_opts->nguid, sizeof(opts->nguid)); 2020 } 2021 if (FIELD_OK(eui64)) { 2022 memcpy(opts->eui64, user_opts->eui64, sizeof(opts->eui64)); 2023 } 2024 if (FIELD_OK(uuid)) { 2025 spdk_uuid_copy(&opts->uuid, &user_opts->uuid); 2026 } 2027 SET_FIELD(anagrpid); 2028 SET_FIELD(no_auto_visible); 2029 SET_FIELD(transport_specific); 2030 2031 opts->opts_size = user_opts->opts_size; 2032 2033 /* We should not remove this statement, but need to update the assert statement 2034 * if we add a new field, and also add a corresponding SET_FIELD statement. 2035 */ 2036 SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_ns_opts) == 72, "Incorrect size"); 2037 2038 #undef FIELD_OK 2039 #undef SET_FIELD 2040 } 2041 2042 /* Dummy bdev module used to to claim bdevs. */ 2043 static struct spdk_bdev_module ns_bdev_module = { 2044 .name = "NVMe-oF Target", 2045 }; 2046 2047 static int nvmf_ns_reservation_update(const struct spdk_nvmf_ns *ns, 2048 const struct spdk_nvmf_reservation_info *info); 2049 static int nvmf_ns_reservation_load(const struct spdk_nvmf_ns *ns, 2050 struct spdk_nvmf_reservation_info *info); 2051 static int nvmf_ns_reservation_restore(struct spdk_nvmf_ns *ns, 2052 struct spdk_nvmf_reservation_info *info); 2053 2054 bool 2055 nvmf_subsystem_zone_append_supported(struct spdk_nvmf_subsystem *subsystem) 2056 { 2057 struct spdk_nvmf_ns *ns; 2058 2059 for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); 2060 ns != NULL; 2061 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) { 2062 if (spdk_bdev_is_zoned(ns->bdev) && 2063 spdk_bdev_io_type_supported(ns->bdev, SPDK_BDEV_IO_TYPE_ZONE_APPEND)) { 2064 return true; 2065 } 2066 } 2067 2068 return false; 2069 } 2070 2071 uint32_t 2072 spdk_nvmf_subsystem_add_ns_ext(struct spdk_nvmf_subsystem *subsystem, const char *bdev_name, 2073 const struct spdk_nvmf_ns_opts *user_opts, size_t opts_size, 2074 const char *ptpl_file) 2075 { 2076 struct spdk_nvmf_transport *transport; 2077 struct spdk_nvmf_ns_opts opts; 2078 struct spdk_nvmf_ns *ns, *first_ns; 2079 struct spdk_nvmf_ctrlr *ctrlr; 2080 struct spdk_nvmf_reservation_info info = {0}; 2081 int rc; 2082 bool zone_append_supported; 2083 uint64_t max_zone_append_size_kib; 2084 2085 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 2086 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 2087 return 0; 2088 } 2089 2090 spdk_nvmf_ns_opts_get_defaults(&opts, sizeof(opts)); 2091 if (user_opts) { 2092 nvmf_ns_opts_copy(&opts, user_opts, opts_size); 2093 } 2094 2095 if (opts.nsid == SPDK_NVME_GLOBAL_NS_TAG) { 2096 SPDK_ERRLOG("Invalid NSID %" PRIu32 "\n", opts.nsid); 2097 return 0; 2098 } 2099 2100 if (opts.nsid == 0) { 2101 /* 2102 * NSID not specified - find a free index. 2103 * 2104 * If no free slots are found, return error. 2105 */ 2106 for (opts.nsid = 1; opts.nsid <= subsystem->max_nsid; opts.nsid++) { 2107 if (_nvmf_subsystem_get_ns(subsystem, opts.nsid) == NULL) { 2108 break; 2109 } 2110 } 2111 if (opts.nsid > subsystem->max_nsid) { 2112 SPDK_ERRLOG("No free namespace slot available in the subsystem\n"); 2113 return 0; 2114 } 2115 } 2116 2117 if (opts.nsid > subsystem->max_nsid) { 2118 SPDK_ERRLOG("NSID greater than maximum not allowed\n"); 2119 return 0; 2120 } 2121 2122 if (_nvmf_subsystem_get_ns(subsystem, opts.nsid)) { 2123 SPDK_ERRLOG("Requested NSID %" PRIu32 " already in use\n", opts.nsid); 2124 return 0; 2125 } 2126 2127 if (opts.anagrpid == 0) { 2128 opts.anagrpid = opts.nsid; 2129 } 2130 2131 if (opts.anagrpid > subsystem->max_nsid) { 2132 SPDK_ERRLOG("ANAGRPID greater than maximum NSID not allowed\n"); 2133 return 0; 2134 } 2135 2136 ns = calloc(1, sizeof(*ns)); 2137 if (ns == NULL) { 2138 SPDK_ERRLOG("Namespace allocation failed\n"); 2139 return 0; 2140 } 2141 2142 TAILQ_INIT(&ns->hosts); 2143 ns->always_visible = !opts.no_auto_visible; 2144 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 2145 nvmf_ctrlr_ns_set_visible(ctrlr, opts.nsid, ns->always_visible); 2146 } 2147 2148 rc = spdk_bdev_open_ext(bdev_name, true, nvmf_ns_event, ns, &ns->desc); 2149 if (rc != 0) { 2150 SPDK_ERRLOG("Subsystem %s: bdev %s cannot be opened, error=%d\n", 2151 subsystem->subnqn, bdev_name, rc); 2152 free(ns); 2153 return 0; 2154 } 2155 2156 ns->bdev = spdk_bdev_desc_get_bdev(ns->desc); 2157 2158 if (spdk_bdev_desc_get_md_size(ns->desc) != 0) { 2159 if (!spdk_bdev_desc_is_md_interleaved(ns->desc)) { 2160 SPDK_ERRLOG("Can't attach bdev with separate metadata.\n"); 2161 spdk_bdev_close(ns->desc); 2162 free(ns); 2163 return 0; 2164 } 2165 2166 if (spdk_bdev_desc_get_md_size(ns->desc) > SPDK_BDEV_MAX_INTERLEAVED_MD_SIZE) { 2167 SPDK_ERRLOG("Maximum supported interleaved md size %u, current md size %u\n", 2168 SPDK_BDEV_MAX_INTERLEAVED_MD_SIZE, 2169 spdk_bdev_desc_get_md_size(ns->desc)); 2170 spdk_bdev_close(ns->desc); 2171 free(ns); 2172 return 0; 2173 } 2174 } 2175 2176 rc = spdk_bdev_module_claim_bdev(ns->bdev, ns->desc, &ns_bdev_module); 2177 if (rc != 0) { 2178 spdk_bdev_close(ns->desc); 2179 free(ns); 2180 return 0; 2181 } 2182 2183 ns->passthru_nsid = spdk_bdev_get_nvme_nsid(ns->bdev); 2184 if (subsystem->passthrough && ns->passthru_nsid == 0) { 2185 SPDK_ERRLOG("Only bdev_nvme namespaces can be added to a passthrough subsystem.\n"); 2186 goto err; 2187 } 2188 2189 /* Cache the zcopy capability of the bdev device */ 2190 ns->zcopy = spdk_bdev_io_type_supported(ns->bdev, SPDK_BDEV_IO_TYPE_ZCOPY); 2191 2192 if (spdk_uuid_is_null(&opts.uuid)) { 2193 opts.uuid = *spdk_bdev_get_uuid(ns->bdev); 2194 } 2195 2196 /* if nguid descriptor is supported by bdev module (nvme) then uuid = nguid */ 2197 if (spdk_mem_all_zero(opts.nguid, sizeof(opts.nguid))) { 2198 SPDK_STATIC_ASSERT(sizeof(opts.nguid) == sizeof(opts.uuid), "size mismatch"); 2199 memcpy(opts.nguid, spdk_bdev_get_uuid(ns->bdev), sizeof(opts.nguid)); 2200 } 2201 2202 if (spdk_bdev_is_zoned(ns->bdev)) { 2203 SPDK_DEBUGLOG(nvmf, "The added namespace is backed by a zoned block device.\n"); 2204 ns->csi = SPDK_NVME_CSI_ZNS; 2205 2206 zone_append_supported = spdk_bdev_io_type_supported(ns->bdev, 2207 SPDK_BDEV_IO_TYPE_ZONE_APPEND); 2208 max_zone_append_size_kib = spdk_bdev_get_max_zone_append_size(ns->bdev) * 2209 spdk_bdev_desc_get_block_size(ns->desc); 2210 2211 if (_nvmf_subsystem_get_first_zoned_ns(subsystem) != NULL && 2212 (nvmf_subsystem_zone_append_supported(subsystem) != zone_append_supported || 2213 subsystem->max_zone_append_size_kib != max_zone_append_size_kib)) { 2214 SPDK_ERRLOG("Namespaces with different zone append support or different zone append size are not allowed.\n"); 2215 goto err; 2216 } 2217 2218 subsystem->max_zone_append_size_kib = max_zone_append_size_kib; 2219 } 2220 2221 first_ns = spdk_nvmf_subsystem_get_first_ns(subsystem); 2222 if (!first_ns) { 2223 if (spdk_bdev_get_nvme_ctratt(ns->bdev).bits.fdps) { 2224 SPDK_DEBUGLOG(nvmf, "Subsystem with id: %u has FDP capability.\n", 2225 subsystem->id); 2226 subsystem->fdp_supported = true; 2227 } 2228 } else { 2229 if (spdk_bdev_get_nvme_ctratt(first_ns->bdev).bits.fdps != 2230 spdk_bdev_get_nvme_ctratt(ns->bdev).bits.fdps) { 2231 SPDK_ERRLOG("Subsystem with id: %u can%s FDP namespace.\n", subsystem->id, 2232 spdk_bdev_get_nvme_ctratt(first_ns->bdev).bits.fdps ? " only add" : "not add"); 2233 goto err; 2234 } 2235 } 2236 2237 ns->opts = opts; 2238 ns->subsystem = subsystem; 2239 subsystem->ns[opts.nsid - 1] = ns; 2240 ns->nsid = opts.nsid; 2241 ns->anagrpid = opts.anagrpid; 2242 subsystem->ana_group[ns->anagrpid - 1]++; 2243 TAILQ_INIT(&ns->registrants); 2244 if (ptpl_file) { 2245 ns->ptpl_file = strdup(ptpl_file); 2246 if (!ns->ptpl_file) { 2247 SPDK_ERRLOG("Namespace ns->ptpl_file allocation failed\n"); 2248 goto err; 2249 } 2250 } 2251 2252 if (nvmf_ns_is_ptpl_capable(ns)) { 2253 rc = nvmf_ns_reservation_load(ns, &info); 2254 if (rc) { 2255 SPDK_ERRLOG("Subsystem load reservation failed\n"); 2256 goto err; 2257 } 2258 2259 rc = nvmf_ns_reservation_restore(ns, &info); 2260 if (rc) { 2261 SPDK_ERRLOG("Subsystem restore reservation failed\n"); 2262 goto err; 2263 } 2264 } 2265 2266 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 2267 transport = spdk_nvmf_transport_get_next(transport)) { 2268 if (transport->ops->subsystem_add_ns) { 2269 rc = transport->ops->subsystem_add_ns(transport, subsystem, ns); 2270 if (rc) { 2271 SPDK_ERRLOG("Namespace attachment is not allowed by %s transport\n", transport->ops->name); 2272 nvmf_ns_reservation_clear_all_registrants(ns); 2273 goto err; 2274 } 2275 } 2276 } 2277 2278 /* JSON value obj is freed before sending the response. Set NULL to prevent usage of dangling pointer. */ 2279 ns->opts.transport_specific = NULL; 2280 2281 SPDK_DEBUGLOG(nvmf, "Subsystem %s: bdev %s assigned nsid %" PRIu32 "\n", 2282 spdk_nvmf_subsystem_get_nqn(subsystem), 2283 bdev_name, 2284 opts.nsid); 2285 2286 nvmf_subsystem_ns_changed(subsystem, opts.nsid); 2287 2288 SPDK_DTRACE_PROBE2(nvmf_subsystem_add_ns, subsystem->subnqn, ns->nsid); 2289 2290 return opts.nsid; 2291 err: 2292 subsystem->ns[opts.nsid - 1] = NULL; 2293 spdk_bdev_module_release_bdev(ns->bdev); 2294 spdk_bdev_close(ns->desc); 2295 free(ns->ptpl_file); 2296 free(ns); 2297 2298 return 0; 2299 } 2300 2301 int 2302 spdk_nvmf_subsystem_set_ns_ana_group(struct spdk_nvmf_subsystem *subsystem, 2303 uint32_t nsid, uint32_t anagrpid) 2304 { 2305 struct spdk_nvmf_ns *ns; 2306 2307 if (anagrpid > subsystem->max_nsid) { 2308 SPDK_ERRLOG("ANAGRPID greater than maximum NSID not allowed\n"); 2309 return -1; 2310 } 2311 2312 if (anagrpid == 0) { 2313 SPDK_ERRLOG("Zero is not allowed to ANAGRPID\n"); 2314 return -1; 2315 } 2316 2317 if (nsid == 0 || nsid > subsystem->max_nsid) { 2318 return -1; 2319 } 2320 2321 ns = subsystem->ns[nsid - 1]; 2322 if (!ns) { 2323 return -1; 2324 } 2325 2326 assert(ns->anagrpid - 1 < subsystem->max_nsid); 2327 2328 assert(subsystem->ana_group[ns->anagrpid - 1] > 0); 2329 2330 subsystem->ana_group[ns->anagrpid - 1]--; 2331 2332 subsystem->ana_group[anagrpid - 1]++; 2333 2334 ns->anagrpid = anagrpid; 2335 ns->opts.anagrpid = anagrpid; 2336 2337 nvmf_subsystem_ns_changed(subsystem, nsid); 2338 2339 return 0; 2340 } 2341 2342 static uint32_t 2343 nvmf_subsystem_get_next_allocated_nsid(struct spdk_nvmf_subsystem *subsystem, 2344 uint32_t prev_nsid) 2345 { 2346 uint32_t nsid; 2347 2348 if (prev_nsid >= subsystem->max_nsid) { 2349 return 0; 2350 } 2351 2352 for (nsid = prev_nsid + 1; nsid <= subsystem->max_nsid; nsid++) { 2353 if (subsystem->ns[nsid - 1]) { 2354 return nsid; 2355 } 2356 } 2357 2358 return 0; 2359 } 2360 2361 struct spdk_nvmf_ns * 2362 spdk_nvmf_subsystem_get_first_ns(struct spdk_nvmf_subsystem *subsystem) 2363 { 2364 uint32_t first_nsid; 2365 2366 first_nsid = nvmf_subsystem_get_next_allocated_nsid(subsystem, 0); 2367 return _nvmf_subsystem_get_ns(subsystem, first_nsid); 2368 } 2369 2370 struct spdk_nvmf_ns * 2371 spdk_nvmf_subsystem_get_next_ns(struct spdk_nvmf_subsystem *subsystem, 2372 struct spdk_nvmf_ns *prev_ns) 2373 { 2374 uint32_t next_nsid; 2375 2376 next_nsid = nvmf_subsystem_get_next_allocated_nsid(subsystem, prev_ns->opts.nsid); 2377 return _nvmf_subsystem_get_ns(subsystem, next_nsid); 2378 } 2379 2380 struct spdk_nvmf_ns * 2381 spdk_nvmf_subsystem_get_ns(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid) 2382 { 2383 return _nvmf_subsystem_get_ns(subsystem, nsid); 2384 } 2385 2386 uint32_t 2387 spdk_nvmf_ns_get_id(const struct spdk_nvmf_ns *ns) 2388 { 2389 return ns->opts.nsid; 2390 } 2391 2392 struct spdk_bdev * 2393 spdk_nvmf_ns_get_bdev(struct spdk_nvmf_ns *ns) 2394 { 2395 return ns->bdev; 2396 } 2397 2398 void 2399 spdk_nvmf_ns_get_opts(const struct spdk_nvmf_ns *ns, struct spdk_nvmf_ns_opts *opts, 2400 size_t opts_size) 2401 { 2402 memset(opts, 0, opts_size); 2403 memcpy(opts, &ns->opts, spdk_min(sizeof(ns->opts), opts_size)); 2404 } 2405 2406 const char * 2407 spdk_nvmf_subsystem_get_sn(const struct spdk_nvmf_subsystem *subsystem) 2408 { 2409 return subsystem->sn; 2410 } 2411 2412 int 2413 spdk_nvmf_subsystem_set_sn(struct spdk_nvmf_subsystem *subsystem, const char *sn) 2414 { 2415 size_t len, max_len; 2416 2417 max_len = sizeof(subsystem->sn) - 1; 2418 len = strlen(sn); 2419 if (len > max_len) { 2420 SPDK_DEBUGLOG(nvmf, "Invalid sn \"%s\": length %zu > max %zu\n", 2421 sn, len, max_len); 2422 return -1; 2423 } 2424 2425 if (!nvmf_valid_ascii_string(sn, len)) { 2426 SPDK_DEBUGLOG(nvmf, "Non-ASCII sn\n"); 2427 SPDK_LOGDUMP(nvmf, "sn", sn, len); 2428 return -1; 2429 } 2430 2431 snprintf(subsystem->sn, sizeof(subsystem->sn), "%s", sn); 2432 2433 return 0; 2434 } 2435 2436 const char * 2437 spdk_nvmf_subsystem_get_mn(const struct spdk_nvmf_subsystem *subsystem) 2438 { 2439 return subsystem->mn; 2440 } 2441 2442 int 2443 spdk_nvmf_subsystem_set_mn(struct spdk_nvmf_subsystem *subsystem, const char *mn) 2444 { 2445 size_t len, max_len; 2446 2447 if (mn == NULL) { 2448 mn = MODEL_NUMBER_DEFAULT; 2449 } 2450 max_len = sizeof(subsystem->mn) - 1; 2451 len = strlen(mn); 2452 if (len > max_len) { 2453 SPDK_DEBUGLOG(nvmf, "Invalid mn \"%s\": length %zu > max %zu\n", 2454 mn, len, max_len); 2455 return -1; 2456 } 2457 2458 if (!nvmf_valid_ascii_string(mn, len)) { 2459 SPDK_DEBUGLOG(nvmf, "Non-ASCII mn\n"); 2460 SPDK_LOGDUMP(nvmf, "mn", mn, len); 2461 return -1; 2462 } 2463 2464 snprintf(subsystem->mn, sizeof(subsystem->mn), "%s", mn); 2465 2466 return 0; 2467 } 2468 2469 const char * 2470 spdk_nvmf_subsystem_get_nqn(const struct spdk_nvmf_subsystem *subsystem) 2471 { 2472 return subsystem->subnqn; 2473 } 2474 2475 /* We have to use the typedef in the function declaration to appease astyle. */ 2476 typedef enum spdk_nvmf_subtype spdk_nvmf_subtype_t; 2477 2478 spdk_nvmf_subtype_t 2479 spdk_nvmf_subsystem_get_type(struct spdk_nvmf_subsystem *subsystem) 2480 { 2481 return subsystem->subtype; 2482 } 2483 2484 uint32_t 2485 spdk_nvmf_subsystem_get_max_nsid(struct spdk_nvmf_subsystem *subsystem) 2486 { 2487 return subsystem->max_nsid; 2488 } 2489 2490 int 2491 spdk_nvmf_subsystem_set_cntlid_range(struct spdk_nvmf_subsystem *subsystem, 2492 uint16_t min_cntlid, uint16_t max_cntlid) 2493 { 2494 if (subsystem->state != SPDK_NVMF_SUBSYSTEM_INACTIVE) { 2495 return -EAGAIN; 2496 } 2497 2498 if (min_cntlid > max_cntlid) { 2499 return -EINVAL; 2500 } 2501 /* The spec reserves cntlid values in the range FFF0h to FFFFh. */ 2502 if (min_cntlid < NVMF_MIN_CNTLID || min_cntlid > NVMF_MAX_CNTLID || 2503 max_cntlid < NVMF_MIN_CNTLID || max_cntlid > NVMF_MAX_CNTLID) { 2504 return -EINVAL; 2505 } 2506 subsystem->min_cntlid = min_cntlid; 2507 subsystem->max_cntlid = max_cntlid; 2508 if (subsystem->next_cntlid < min_cntlid || subsystem->next_cntlid > max_cntlid) { 2509 subsystem->next_cntlid = min_cntlid; 2510 } 2511 2512 return 0; 2513 } 2514 2515 uint16_t 2516 nvmf_subsystem_gen_cntlid(struct spdk_nvmf_subsystem *subsystem) 2517 { 2518 int count; 2519 uint16_t cntlid; 2520 2521 /* 2522 * In the worst case, we might have to try all CNTLID values between min_cntlid and max_cntlid 2523 * before we find one that is unused (or find that all values are in use). 2524 */ 2525 for (count = 0; count < subsystem->max_cntlid - subsystem->min_cntlid + 1; count++) { 2526 cntlid = subsystem->next_cntlid; 2527 subsystem->next_cntlid++; 2528 2529 if (subsystem->next_cntlid > subsystem->max_cntlid) { 2530 subsystem->next_cntlid = subsystem->min_cntlid; 2531 } 2532 2533 /* Check if a controller with this cntlid currently exists. */ 2534 if (nvmf_subsystem_get_ctrlr(subsystem, cntlid) == NULL) { 2535 /* Found unused cntlid */ 2536 return cntlid; 2537 } 2538 } 2539 2540 /* All valid cntlid values are in use. */ 2541 return 0xFFFF; 2542 } 2543 2544 int 2545 nvmf_subsystem_add_ctrlr(struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr) 2546 { 2547 2548 if (ctrlr->dynamic_ctrlr) { 2549 ctrlr->cntlid = nvmf_subsystem_gen_cntlid(subsystem); 2550 if (ctrlr->cntlid == 0xFFFF) { 2551 /* Unable to get a cntlid */ 2552 SPDK_ERRLOG("Reached max simultaneous ctrlrs\n"); 2553 return -EBUSY; 2554 } 2555 } else if (nvmf_subsystem_get_ctrlr(subsystem, ctrlr->cntlid) != NULL) { 2556 SPDK_ERRLOG("Ctrlr with cntlid %u already exist\n", ctrlr->cntlid); 2557 return -EEXIST; 2558 } 2559 2560 TAILQ_INSERT_TAIL(&subsystem->ctrlrs, ctrlr, link); 2561 2562 SPDK_DTRACE_PROBE3(nvmf_subsystem_add_ctrlr, subsystem->subnqn, ctrlr, ctrlr->hostnqn); 2563 2564 return 0; 2565 } 2566 2567 void 2568 nvmf_subsystem_remove_ctrlr(struct spdk_nvmf_subsystem *subsystem, 2569 struct spdk_nvmf_ctrlr *ctrlr) 2570 { 2571 SPDK_DTRACE_PROBE3(nvmf_subsystem_remove_ctrlr, subsystem->subnqn, ctrlr, ctrlr->hostnqn); 2572 2573 assert(spdk_get_thread() == subsystem->thread); 2574 assert(subsystem == ctrlr->subsys); 2575 SPDK_DEBUGLOG(nvmf, "remove ctrlr %p id 0x%x from subsys %p %s\n", ctrlr, ctrlr->cntlid, subsystem, 2576 subsystem->subnqn); 2577 TAILQ_REMOVE(&subsystem->ctrlrs, ctrlr, link); 2578 } 2579 2580 struct spdk_nvmf_ctrlr * 2581 nvmf_subsystem_get_ctrlr(struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid) 2582 { 2583 struct spdk_nvmf_ctrlr *ctrlr; 2584 2585 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 2586 if (ctrlr->cntlid == cntlid) { 2587 return ctrlr; 2588 } 2589 } 2590 2591 return NULL; 2592 } 2593 2594 uint32_t 2595 spdk_nvmf_subsystem_get_max_namespaces(const struct spdk_nvmf_subsystem *subsystem) 2596 { 2597 return subsystem->max_nsid; 2598 } 2599 2600 uint16_t 2601 spdk_nvmf_subsystem_get_min_cntlid(const struct spdk_nvmf_subsystem *subsystem) 2602 { 2603 return subsystem->min_cntlid; 2604 } 2605 2606 uint16_t 2607 spdk_nvmf_subsystem_get_max_cntlid(const struct spdk_nvmf_subsystem *subsystem) 2608 { 2609 return subsystem->max_cntlid; 2610 } 2611 2612 struct _nvmf_ns_registrant { 2613 uint64_t rkey; 2614 char *host_uuid; 2615 }; 2616 2617 struct _nvmf_ns_registrants { 2618 size_t num_regs; 2619 struct _nvmf_ns_registrant reg[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 2620 }; 2621 2622 struct _nvmf_ns_reservation { 2623 bool ptpl_activated; 2624 enum spdk_nvme_reservation_type rtype; 2625 uint64_t crkey; 2626 char *bdev_uuid; 2627 char *holder_uuid; 2628 struct _nvmf_ns_registrants regs; 2629 }; 2630 2631 static const struct spdk_json_object_decoder nvmf_ns_pr_reg_decoders[] = { 2632 {"rkey", offsetof(struct _nvmf_ns_registrant, rkey), spdk_json_decode_uint64}, 2633 {"host_uuid", offsetof(struct _nvmf_ns_registrant, host_uuid), spdk_json_decode_string}, 2634 }; 2635 2636 static int 2637 nvmf_decode_ns_pr_reg(const struct spdk_json_val *val, void *out) 2638 { 2639 struct _nvmf_ns_registrant *reg = out; 2640 2641 return spdk_json_decode_object(val, nvmf_ns_pr_reg_decoders, 2642 SPDK_COUNTOF(nvmf_ns_pr_reg_decoders), reg); 2643 } 2644 2645 static int 2646 nvmf_decode_ns_pr_regs(const struct spdk_json_val *val, void *out) 2647 { 2648 struct _nvmf_ns_registrants *regs = out; 2649 2650 return spdk_json_decode_array(val, nvmf_decode_ns_pr_reg, regs->reg, 2651 SPDK_NVMF_MAX_NUM_REGISTRANTS, ®s->num_regs, 2652 sizeof(struct _nvmf_ns_registrant)); 2653 } 2654 2655 static const struct spdk_json_object_decoder nvmf_ns_pr_decoders[] = { 2656 {"ptpl", offsetof(struct _nvmf_ns_reservation, ptpl_activated), spdk_json_decode_bool, true}, 2657 {"rtype", offsetof(struct _nvmf_ns_reservation, rtype), spdk_json_decode_uint32, true}, 2658 {"crkey", offsetof(struct _nvmf_ns_reservation, crkey), spdk_json_decode_uint64, true}, 2659 {"bdev_uuid", offsetof(struct _nvmf_ns_reservation, bdev_uuid), spdk_json_decode_string}, 2660 {"holder_uuid", offsetof(struct _nvmf_ns_reservation, holder_uuid), spdk_json_decode_string, true}, 2661 {"registrants", offsetof(struct _nvmf_ns_reservation, regs), nvmf_decode_ns_pr_regs}, 2662 }; 2663 2664 static int 2665 nvmf_ns_reservation_load_json(const struct spdk_nvmf_ns *ns, 2666 struct spdk_nvmf_reservation_info *info) 2667 { 2668 size_t json_size; 2669 ssize_t values_cnt, rc; 2670 void *json = NULL, *end; 2671 struct spdk_json_val *values = NULL; 2672 struct _nvmf_ns_reservation res = {}; 2673 const char *file = ns->ptpl_file; 2674 uint32_t i; 2675 2676 /* It's not an error if the file does not exist */ 2677 if (access(file, F_OK) != 0) { 2678 SPDK_DEBUGLOG(nvmf, "File %s does not exist\n", file); 2679 return 0; 2680 } 2681 2682 /* Load all persist file contents into a local buffer */ 2683 json = spdk_posix_file_load_from_name(file, &json_size); 2684 if (!json) { 2685 SPDK_ERRLOG("Load persist file %s failed\n", file); 2686 return -ENOMEM; 2687 } 2688 2689 rc = spdk_json_parse(json, json_size, NULL, 0, &end, 0); 2690 if (rc < 0) { 2691 SPDK_NOTICELOG("Parsing JSON configuration failed (%zd)\n", rc); 2692 goto exit; 2693 } 2694 2695 values_cnt = rc; 2696 values = calloc(values_cnt, sizeof(struct spdk_json_val)); 2697 if (values == NULL) { 2698 goto exit; 2699 } 2700 2701 rc = spdk_json_parse(json, json_size, values, values_cnt, &end, 0); 2702 if (rc != values_cnt) { 2703 SPDK_ERRLOG("Parsing JSON configuration failed (%zd)\n", rc); 2704 goto exit; 2705 } 2706 2707 /* Decode json */ 2708 if (spdk_json_decode_object(values, nvmf_ns_pr_decoders, 2709 SPDK_COUNTOF(nvmf_ns_pr_decoders), 2710 &res)) { 2711 SPDK_ERRLOG("Invalid objects in the persist file %s\n", file); 2712 rc = -EINVAL; 2713 goto exit; 2714 } 2715 2716 if (res.regs.num_regs > SPDK_NVMF_MAX_NUM_REGISTRANTS) { 2717 SPDK_ERRLOG("Can only support up to %u registrants\n", SPDK_NVMF_MAX_NUM_REGISTRANTS); 2718 rc = -ERANGE; 2719 goto exit; 2720 } 2721 2722 rc = 0; 2723 info->ptpl_activated = res.ptpl_activated; 2724 info->rtype = res.rtype; 2725 info->crkey = res.crkey; 2726 snprintf(info->bdev_uuid, sizeof(info->bdev_uuid), "%s", res.bdev_uuid); 2727 snprintf(info->holder_uuid, sizeof(info->holder_uuid), "%s", res.holder_uuid); 2728 info->num_regs = res.regs.num_regs; 2729 for (i = 0; i < res.regs.num_regs; i++) { 2730 info->registrants[i].rkey = res.regs.reg[i].rkey; 2731 snprintf(info->registrants[i].host_uuid, sizeof(info->registrants[i].host_uuid), "%s", 2732 res.regs.reg[i].host_uuid); 2733 } 2734 2735 exit: 2736 free(json); 2737 free(values); 2738 free(res.bdev_uuid); 2739 free(res.holder_uuid); 2740 for (i = 0; i < res.regs.num_regs; i++) { 2741 free(res.regs.reg[i].host_uuid); 2742 } 2743 2744 return rc; 2745 } 2746 2747 static bool nvmf_ns_reservation_all_registrants_type(struct spdk_nvmf_ns *ns); 2748 2749 static int 2750 nvmf_ns_reservation_restore(struct spdk_nvmf_ns *ns, struct spdk_nvmf_reservation_info *info) 2751 { 2752 uint32_t i; 2753 struct spdk_nvmf_registrant *reg, *holder = NULL; 2754 struct spdk_uuid bdev_uuid, holder_uuid; 2755 bool rkey_flag = false; 2756 2757 SPDK_DEBUGLOG(nvmf, "NSID %u, PTPL %u, Number of registrants %u\n", 2758 ns->nsid, info->ptpl_activated, info->num_regs); 2759 2760 /* it's not an error */ 2761 if (!info->ptpl_activated || !info->num_regs) { 2762 return 0; 2763 } 2764 2765 /* Check info->crkey exist or not in info->registrants[i].rkey */ 2766 for (i = 0; i < info->num_regs; i++) { 2767 if (info->crkey == info->registrants[i].rkey) { 2768 rkey_flag = true; 2769 } 2770 } 2771 if (!rkey_flag && info->crkey != 0) { 2772 return -EINVAL; 2773 } 2774 2775 spdk_uuid_parse(&bdev_uuid, info->bdev_uuid); 2776 if (spdk_uuid_compare(&bdev_uuid, spdk_bdev_get_uuid(ns->bdev))) { 2777 SPDK_ERRLOG("Existing bdev UUID is not same with configuration file\n"); 2778 return -EINVAL; 2779 } 2780 2781 ns->crkey = info->crkey; 2782 ns->rtype = info->rtype; 2783 ns->ptpl_activated = info->ptpl_activated; 2784 spdk_uuid_parse(&holder_uuid, info->holder_uuid); 2785 2786 SPDK_DEBUGLOG(nvmf, "Bdev UUID %s\n", info->bdev_uuid); 2787 if (info->rtype) { 2788 SPDK_DEBUGLOG(nvmf, "Holder UUID %s, RTYPE %u, RKEY 0x%"PRIx64"\n", 2789 info->holder_uuid, info->rtype, info->crkey); 2790 } 2791 2792 for (i = 0; i < info->num_regs; i++) { 2793 reg = calloc(1, sizeof(*reg)); 2794 if (!reg) { 2795 return -ENOMEM; 2796 } 2797 spdk_uuid_parse(®->hostid, info->registrants[i].host_uuid); 2798 reg->rkey = info->registrants[i].rkey; 2799 TAILQ_INSERT_TAIL(&ns->registrants, reg, link); 2800 if (info->crkey != 0 && !spdk_uuid_compare(&holder_uuid, ®->hostid)) { 2801 holder = reg; 2802 } 2803 SPDK_DEBUGLOG(nvmf, "Registrant RKEY 0x%"PRIx64", Host UUID %s\n", 2804 info->registrants[i].rkey, info->registrants[i].host_uuid); 2805 } 2806 2807 if (nvmf_ns_reservation_all_registrants_type(ns)) { 2808 ns->holder = TAILQ_FIRST(&ns->registrants); 2809 } else { 2810 ns->holder = holder; 2811 } 2812 2813 return 0; 2814 } 2815 2816 static int 2817 nvmf_ns_json_write_cb(void *cb_ctx, const void *data, size_t size) 2818 { 2819 char *file = cb_ctx; 2820 size_t rc; 2821 FILE *fd; 2822 2823 fd = fopen(file, "w"); 2824 if (!fd) { 2825 SPDK_ERRLOG("Can't open file %s for write\n", file); 2826 return -ENOENT; 2827 } 2828 rc = fwrite(data, 1, size, fd); 2829 fclose(fd); 2830 2831 return rc == size ? 0 : -1; 2832 } 2833 2834 static int 2835 nvmf_ns_reservation_update_json(const struct spdk_nvmf_ns *ns, 2836 const struct spdk_nvmf_reservation_info *info) 2837 { 2838 const char *file = ns->ptpl_file; 2839 struct spdk_json_write_ctx *w; 2840 uint32_t i; 2841 int rc = 0; 2842 2843 w = spdk_json_write_begin(nvmf_ns_json_write_cb, (void *)file, 0); 2844 if (w == NULL) { 2845 return -ENOMEM; 2846 } 2847 /* clear the configuration file */ 2848 if (!info->ptpl_activated) { 2849 goto exit; 2850 } 2851 2852 spdk_json_write_object_begin(w); 2853 spdk_json_write_named_bool(w, "ptpl", info->ptpl_activated); 2854 spdk_json_write_named_uint32(w, "rtype", info->rtype); 2855 spdk_json_write_named_uint64(w, "crkey", info->crkey); 2856 spdk_json_write_named_string(w, "bdev_uuid", info->bdev_uuid); 2857 spdk_json_write_named_string(w, "holder_uuid", info->holder_uuid); 2858 2859 spdk_json_write_named_array_begin(w, "registrants"); 2860 for (i = 0; i < info->num_regs; i++) { 2861 spdk_json_write_object_begin(w); 2862 spdk_json_write_named_uint64(w, "rkey", info->registrants[i].rkey); 2863 spdk_json_write_named_string(w, "host_uuid", info->registrants[i].host_uuid); 2864 spdk_json_write_object_end(w); 2865 } 2866 spdk_json_write_array_end(w); 2867 spdk_json_write_object_end(w); 2868 2869 exit: 2870 rc = spdk_json_write_end(w); 2871 return rc; 2872 } 2873 2874 static int 2875 nvmf_ns_update_reservation_info(struct spdk_nvmf_ns *ns) 2876 { 2877 struct spdk_nvmf_reservation_info info; 2878 struct spdk_nvmf_registrant *reg, *tmp; 2879 uint32_t i = 0; 2880 2881 assert(ns != NULL); 2882 2883 if (!ns->bdev || !nvmf_ns_is_ptpl_capable(ns)) { 2884 return 0; 2885 } 2886 2887 memset(&info, 0, sizeof(info)); 2888 spdk_uuid_fmt_lower(info.bdev_uuid, sizeof(info.bdev_uuid), spdk_bdev_get_uuid(ns->bdev)); 2889 2890 if (ns->rtype) { 2891 info.rtype = ns->rtype; 2892 info.crkey = ns->crkey; 2893 if (!nvmf_ns_reservation_all_registrants_type(ns)) { 2894 assert(ns->holder != NULL); 2895 spdk_uuid_fmt_lower(info.holder_uuid, sizeof(info.holder_uuid), &ns->holder->hostid); 2896 } 2897 } 2898 2899 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 2900 spdk_uuid_fmt_lower(info.registrants[i].host_uuid, sizeof(info.registrants[i].host_uuid), 2901 ®->hostid); 2902 info.registrants[i++].rkey = reg->rkey; 2903 } 2904 2905 info.num_regs = i; 2906 info.ptpl_activated = ns->ptpl_activated; 2907 2908 return nvmf_ns_reservation_update(ns, &info); 2909 } 2910 2911 static struct spdk_nvmf_registrant * 2912 nvmf_ns_reservation_get_registrant(struct spdk_nvmf_ns *ns, 2913 struct spdk_uuid *uuid) 2914 { 2915 struct spdk_nvmf_registrant *reg, *tmp; 2916 2917 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 2918 if (!spdk_uuid_compare(®->hostid, uuid)) { 2919 return reg; 2920 } 2921 } 2922 2923 return NULL; 2924 } 2925 2926 /* Generate reservation notice log to registered HostID controllers */ 2927 static void 2928 nvmf_subsystem_gen_ctrlr_notification(struct spdk_nvmf_subsystem *subsystem, 2929 struct spdk_nvmf_ns *ns, 2930 struct spdk_uuid *hostid_list, 2931 uint32_t num_hostid, 2932 enum spdk_nvme_reservation_notification_log_page_type type) 2933 { 2934 struct spdk_nvmf_ctrlr *ctrlr; 2935 uint32_t i; 2936 2937 for (i = 0; i < num_hostid; i++) { 2938 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 2939 if (!spdk_uuid_compare(&ctrlr->hostid, &hostid_list[i])) { 2940 nvmf_ctrlr_reservation_notice_log(ctrlr, ns, type); 2941 } 2942 } 2943 } 2944 } 2945 2946 /* Get all registrants' hostid other than the controller who issued the command */ 2947 static uint32_t 2948 nvmf_ns_reservation_get_all_other_hostid(struct spdk_nvmf_ns *ns, 2949 struct spdk_uuid *hostid_list, 2950 uint32_t max_num_hostid, 2951 struct spdk_uuid *current_hostid) 2952 { 2953 struct spdk_nvmf_registrant *reg, *tmp; 2954 uint32_t num_hostid = 0; 2955 2956 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 2957 if (spdk_uuid_compare(®->hostid, current_hostid)) { 2958 if (num_hostid == max_num_hostid) { 2959 assert(false); 2960 return max_num_hostid; 2961 } 2962 hostid_list[num_hostid++] = reg->hostid; 2963 } 2964 } 2965 2966 return num_hostid; 2967 } 2968 2969 /* Calculate the unregistered HostID list according to list 2970 * prior to execute preempt command and list after executing 2971 * preempt command. 2972 */ 2973 static uint32_t 2974 nvmf_ns_reservation_get_unregistered_hostid(struct spdk_uuid *old_hostid_list, 2975 uint32_t old_num_hostid, 2976 struct spdk_uuid *remaining_hostid_list, 2977 uint32_t remaining_num_hostid) 2978 { 2979 struct spdk_uuid temp_hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 2980 uint32_t i, j, num_hostid = 0; 2981 bool found; 2982 2983 if (!remaining_num_hostid) { 2984 return old_num_hostid; 2985 } 2986 2987 for (i = 0; i < old_num_hostid; i++) { 2988 found = false; 2989 for (j = 0; j < remaining_num_hostid; j++) { 2990 if (!spdk_uuid_compare(&old_hostid_list[i], &remaining_hostid_list[j])) { 2991 found = true; 2992 break; 2993 } 2994 } 2995 if (!found) { 2996 spdk_uuid_copy(&temp_hostid_list[num_hostid++], &old_hostid_list[i]); 2997 } 2998 } 2999 3000 if (num_hostid) { 3001 memcpy(old_hostid_list, temp_hostid_list, sizeof(struct spdk_uuid) * num_hostid); 3002 } 3003 3004 return num_hostid; 3005 } 3006 3007 /* current reservation type is all registrants or not */ 3008 static bool 3009 nvmf_ns_reservation_all_registrants_type(struct spdk_nvmf_ns *ns) 3010 { 3011 return (ns->rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS || 3012 ns->rtype == SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS); 3013 } 3014 3015 /* current registrant is reservation holder or not */ 3016 static bool 3017 nvmf_ns_reservation_registrant_is_holder(struct spdk_nvmf_ns *ns, 3018 struct spdk_nvmf_registrant *reg) 3019 { 3020 if (!reg) { 3021 return false; 3022 } 3023 3024 if (nvmf_ns_reservation_all_registrants_type(ns)) { 3025 return true; 3026 } 3027 3028 return (ns->holder == reg); 3029 } 3030 3031 static int 3032 nvmf_ns_reservation_add_registrant(struct spdk_nvmf_ns *ns, 3033 struct spdk_nvmf_ctrlr *ctrlr, 3034 uint64_t nrkey) 3035 { 3036 struct spdk_nvmf_registrant *reg; 3037 3038 reg = calloc(1, sizeof(*reg)); 3039 if (!reg) { 3040 return -ENOMEM; 3041 } 3042 3043 reg->rkey = nrkey; 3044 /* set hostid for the registrant */ 3045 spdk_uuid_copy(®->hostid, &ctrlr->hostid); 3046 TAILQ_INSERT_TAIL(&ns->registrants, reg, link); 3047 ns->gen++; 3048 3049 return 0; 3050 } 3051 3052 static void 3053 nvmf_ns_reservation_release_reservation(struct spdk_nvmf_ns *ns) 3054 { 3055 ns->rtype = 0; 3056 ns->crkey = 0; 3057 ns->holder = NULL; 3058 } 3059 3060 /* release the reservation if the last registrant was removed */ 3061 static void 3062 nvmf_ns_reservation_check_release_on_remove_registrant(struct spdk_nvmf_ns *ns, 3063 struct spdk_nvmf_registrant *reg) 3064 { 3065 struct spdk_nvmf_registrant *next_reg; 3066 3067 /* no reservation holder */ 3068 if (!ns->holder) { 3069 assert(ns->rtype == 0); 3070 return; 3071 } 3072 3073 next_reg = TAILQ_FIRST(&ns->registrants); 3074 if (next_reg && nvmf_ns_reservation_all_registrants_type(ns)) { 3075 /* the next valid registrant is the new holder now */ 3076 ns->holder = next_reg; 3077 } else if (nvmf_ns_reservation_registrant_is_holder(ns, reg)) { 3078 /* release the reservation */ 3079 nvmf_ns_reservation_release_reservation(ns); 3080 } 3081 } 3082 3083 static void 3084 nvmf_ns_reservation_remove_registrant(struct spdk_nvmf_ns *ns, 3085 struct spdk_nvmf_registrant *reg) 3086 { 3087 TAILQ_REMOVE(&ns->registrants, reg, link); 3088 nvmf_ns_reservation_check_release_on_remove_registrant(ns, reg); 3089 free(reg); 3090 ns->gen++; 3091 return; 3092 } 3093 3094 static uint32_t 3095 nvmf_ns_reservation_remove_registrants_by_key(struct spdk_nvmf_ns *ns, 3096 uint64_t rkey) 3097 { 3098 struct spdk_nvmf_registrant *reg, *tmp; 3099 uint32_t count = 0; 3100 3101 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 3102 if (reg->rkey == rkey) { 3103 nvmf_ns_reservation_remove_registrant(ns, reg); 3104 count++; 3105 } 3106 } 3107 return count; 3108 } 3109 3110 static uint32_t 3111 nvmf_ns_reservation_remove_all_other_registrants(struct spdk_nvmf_ns *ns, 3112 struct spdk_nvmf_registrant *reg) 3113 { 3114 struct spdk_nvmf_registrant *reg_tmp, *reg_tmp2; 3115 uint32_t count = 0; 3116 3117 TAILQ_FOREACH_SAFE(reg_tmp, &ns->registrants, link, reg_tmp2) { 3118 if (reg_tmp != reg) { 3119 nvmf_ns_reservation_remove_registrant(ns, reg_tmp); 3120 count++; 3121 } 3122 } 3123 return count; 3124 } 3125 3126 static uint32_t 3127 nvmf_ns_reservation_clear_all_registrants(struct spdk_nvmf_ns *ns) 3128 { 3129 struct spdk_nvmf_registrant *reg, *reg_tmp; 3130 uint32_t count = 0; 3131 3132 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, reg_tmp) { 3133 nvmf_ns_reservation_remove_registrant(ns, reg); 3134 count++; 3135 } 3136 return count; 3137 } 3138 3139 static void 3140 nvmf_ns_reservation_acquire_reservation(struct spdk_nvmf_ns *ns, uint64_t rkey, 3141 enum spdk_nvme_reservation_type rtype, 3142 struct spdk_nvmf_registrant *holder) 3143 { 3144 ns->rtype = rtype; 3145 ns->crkey = rkey; 3146 assert(ns->holder == NULL); 3147 ns->holder = holder; 3148 } 3149 3150 static bool 3151 nvmf_ns_reservation_register(struct spdk_nvmf_ns *ns, 3152 struct spdk_nvmf_ctrlr *ctrlr, 3153 struct spdk_nvmf_request *req) 3154 { 3155 struct spdk_nvme_reservation_register_data key = { 0 }; 3156 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3157 uint8_t rrega, iekey, cptpl, rtype; 3158 struct spdk_nvmf_registrant *reg; 3159 uint8_t status = SPDK_NVME_SC_SUCCESS; 3160 bool update_sgroup = false; 3161 struct spdk_uuid hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3162 uint32_t num_hostid = 0; 3163 int rc; 3164 3165 rrega = cmd->cdw10_bits.resv_register.rrega; 3166 iekey = cmd->cdw10_bits.resv_register.iekey; 3167 cptpl = cmd->cdw10_bits.resv_register.cptpl; 3168 3169 if (req->iovcnt > 0 && req->length >= sizeof(key)) { 3170 struct spdk_iov_xfer ix; 3171 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3172 spdk_iov_xfer_to_buf(&ix, &key, sizeof(key)); 3173 } else { 3174 SPDK_ERRLOG("No key provided. Failing request.\n"); 3175 status = SPDK_NVME_SC_INVALID_FIELD; 3176 goto exit; 3177 } 3178 3179 SPDK_DEBUGLOG(nvmf, "REGISTER: RREGA %u, IEKEY %u, CPTPL %u, " 3180 "NRKEY 0x%"PRIx64", NRKEY 0x%"PRIx64"\n", 3181 rrega, iekey, cptpl, key.crkey, key.nrkey); 3182 3183 if (cptpl == SPDK_NVME_RESERVE_PTPL_CLEAR_POWER_ON) { 3184 /* True to OFF state, and need to be updated in the configuration file */ 3185 if (ns->ptpl_activated) { 3186 ns->ptpl_activated = 0; 3187 update_sgroup = true; 3188 } 3189 } else if (cptpl == SPDK_NVME_RESERVE_PTPL_PERSIST_POWER_LOSS) { 3190 if (!nvmf_ns_is_ptpl_capable(ns)) { 3191 status = SPDK_NVME_SC_INVALID_FIELD; 3192 goto exit; 3193 } else if (ns->ptpl_activated == 0) { 3194 ns->ptpl_activated = 1; 3195 update_sgroup = true; 3196 } 3197 } 3198 3199 /* current Host Identifier has registrant or not */ 3200 reg = nvmf_ns_reservation_get_registrant(ns, &ctrlr->hostid); 3201 3202 switch (rrega) { 3203 case SPDK_NVME_RESERVE_REGISTER_KEY: 3204 if (!reg) { 3205 /* register new controller */ 3206 if (key.nrkey == 0) { 3207 SPDK_ERRLOG("Can't register zeroed new key\n"); 3208 status = SPDK_NVME_SC_INVALID_FIELD; 3209 goto exit; 3210 } 3211 rc = nvmf_ns_reservation_add_registrant(ns, ctrlr, key.nrkey); 3212 if (rc < 0) { 3213 status = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3214 goto exit; 3215 } 3216 update_sgroup = true; 3217 } else { 3218 /* register with same key is not an error */ 3219 if (reg->rkey != key.nrkey) { 3220 SPDK_ERRLOG("The same host already register a " 3221 "key with 0x%"PRIx64"\n", 3222 reg->rkey); 3223 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3224 goto exit; 3225 } 3226 } 3227 break; 3228 case SPDK_NVME_RESERVE_UNREGISTER_KEY: 3229 if (!reg || (!iekey && reg->rkey != key.crkey)) { 3230 SPDK_ERRLOG("No registrant or current key doesn't match " 3231 "with existing registrant key\n"); 3232 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3233 goto exit; 3234 } 3235 3236 rtype = ns->rtype; 3237 num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, hostid_list, 3238 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3239 &ctrlr->hostid); 3240 3241 nvmf_ns_reservation_remove_registrant(ns, reg); 3242 3243 if (!ns->rtype && num_hostid && (rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY || 3244 rtype == SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY)) { 3245 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3246 hostid_list, 3247 num_hostid, 3248 SPDK_NVME_RESERVATION_RELEASED); 3249 } 3250 update_sgroup = true; 3251 break; 3252 case SPDK_NVME_RESERVE_REPLACE_KEY: 3253 if (key.nrkey == 0) { 3254 SPDK_ERRLOG("Can't register zeroed new key\n"); 3255 status = SPDK_NVME_SC_INVALID_FIELD; 3256 goto exit; 3257 } 3258 /* Registrant exists */ 3259 if (reg) { 3260 if (!iekey && reg->rkey != key.crkey) { 3261 SPDK_ERRLOG("Current key doesn't match " 3262 "existing registrant key\n"); 3263 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3264 goto exit; 3265 } 3266 if (reg->rkey == key.nrkey) { 3267 goto exit; 3268 } 3269 reg->rkey = key.nrkey; 3270 } else if (iekey) { /* No registrant but IEKEY is set */ 3271 /* new registrant */ 3272 rc = nvmf_ns_reservation_add_registrant(ns, ctrlr, key.nrkey); 3273 if (rc < 0) { 3274 status = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3275 goto exit; 3276 } 3277 } else { /* No registrant */ 3278 SPDK_ERRLOG("No registrant\n"); 3279 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3280 goto exit; 3281 3282 } 3283 update_sgroup = true; 3284 break; 3285 default: 3286 status = SPDK_NVME_SC_INVALID_FIELD; 3287 goto exit; 3288 } 3289 3290 exit: 3291 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3292 req->rsp->nvme_cpl.status.sc = status; 3293 return update_sgroup; 3294 } 3295 3296 static bool 3297 nvmf_ns_reservation_acquire(struct spdk_nvmf_ns *ns, 3298 struct spdk_nvmf_ctrlr *ctrlr, 3299 struct spdk_nvmf_request *req) 3300 { 3301 struct spdk_nvme_reservation_acquire_data key = { 0 }; 3302 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3303 uint8_t racqa, iekey, rtype; 3304 struct spdk_nvmf_registrant *reg; 3305 bool all_regs = false; 3306 uint32_t count = 0; 3307 bool update_sgroup = true; 3308 struct spdk_uuid hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3309 uint32_t num_hostid = 0; 3310 struct spdk_uuid new_hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3311 uint32_t new_num_hostid = 0; 3312 bool reservation_released = false; 3313 uint8_t status = SPDK_NVME_SC_SUCCESS; 3314 3315 racqa = cmd->cdw10_bits.resv_acquire.racqa; 3316 iekey = cmd->cdw10_bits.resv_acquire.iekey; 3317 rtype = cmd->cdw10_bits.resv_acquire.rtype; 3318 3319 if (req->iovcnt > 0 && req->length >= sizeof(key)) { 3320 struct spdk_iov_xfer ix; 3321 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3322 spdk_iov_xfer_to_buf(&ix, &key, sizeof(key)); 3323 } else { 3324 SPDK_ERRLOG("No key provided. Failing request.\n"); 3325 status = SPDK_NVME_SC_INVALID_FIELD; 3326 goto exit; 3327 } 3328 3329 SPDK_DEBUGLOG(nvmf, "ACQUIRE: RACQA %u, IEKEY %u, RTYPE %u, " 3330 "NRKEY 0x%"PRIx64", PRKEY 0x%"PRIx64"\n", 3331 racqa, iekey, rtype, key.crkey, key.prkey); 3332 3333 if (iekey || rtype > SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS) { 3334 SPDK_ERRLOG("Ignore existing key field set to 1\n"); 3335 status = SPDK_NVME_SC_INVALID_FIELD; 3336 update_sgroup = false; 3337 goto exit; 3338 } 3339 3340 reg = nvmf_ns_reservation_get_registrant(ns, &ctrlr->hostid); 3341 /* must be registrant and CRKEY must match */ 3342 if (!reg || reg->rkey != key.crkey) { 3343 SPDK_ERRLOG("No registrant or current key doesn't match " 3344 "with existing registrant key\n"); 3345 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3346 update_sgroup = false; 3347 goto exit; 3348 } 3349 3350 all_regs = nvmf_ns_reservation_all_registrants_type(ns); 3351 3352 switch (racqa) { 3353 case SPDK_NVME_RESERVE_ACQUIRE: 3354 /* it's not an error for the holder to acquire same reservation type again */ 3355 if (nvmf_ns_reservation_registrant_is_holder(ns, reg) && ns->rtype == rtype) { 3356 /* do nothing */ 3357 update_sgroup = false; 3358 } else if (ns->holder == NULL) { 3359 /* first time to acquire the reservation */ 3360 nvmf_ns_reservation_acquire_reservation(ns, key.crkey, rtype, reg); 3361 } else { 3362 SPDK_ERRLOG("Invalid rtype or current registrant is not holder\n"); 3363 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3364 update_sgroup = false; 3365 goto exit; 3366 } 3367 break; 3368 case SPDK_NVME_RESERVE_PREEMPT: 3369 /* no reservation holder */ 3370 if (!ns->holder) { 3371 /* unregister with PRKEY */ 3372 nvmf_ns_reservation_remove_registrants_by_key(ns, key.prkey); 3373 break; 3374 } 3375 num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, hostid_list, 3376 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3377 &ctrlr->hostid); 3378 3379 /* only 1 reservation holder and reservation key is valid */ 3380 if (!all_regs) { 3381 /* preempt itself */ 3382 if (nvmf_ns_reservation_registrant_is_holder(ns, reg) && 3383 ns->crkey == key.prkey) { 3384 ns->rtype = rtype; 3385 reservation_released = true; 3386 break; 3387 } 3388 3389 if (ns->crkey == key.prkey) { 3390 nvmf_ns_reservation_remove_registrant(ns, ns->holder); 3391 nvmf_ns_reservation_acquire_reservation(ns, key.crkey, rtype, reg); 3392 reservation_released = true; 3393 } else if (key.prkey != 0) { 3394 nvmf_ns_reservation_remove_registrants_by_key(ns, key.prkey); 3395 } else { 3396 /* PRKEY is zero */ 3397 SPDK_ERRLOG("Current PRKEY is zero\n"); 3398 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3399 update_sgroup = false; 3400 goto exit; 3401 } 3402 } else { 3403 /* release all other registrants except for the current one */ 3404 if (key.prkey == 0) { 3405 nvmf_ns_reservation_remove_all_other_registrants(ns, reg); 3406 assert(ns->holder == reg); 3407 } else { 3408 count = nvmf_ns_reservation_remove_registrants_by_key(ns, key.prkey); 3409 if (count == 0) { 3410 SPDK_ERRLOG("PRKEY doesn't match any registrant\n"); 3411 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3412 update_sgroup = false; 3413 goto exit; 3414 } 3415 } 3416 } 3417 break; 3418 default: 3419 status = SPDK_NVME_SC_INVALID_FIELD; 3420 update_sgroup = false; 3421 break; 3422 } 3423 3424 exit: 3425 if (update_sgroup && racqa == SPDK_NVME_RESERVE_PREEMPT) { 3426 new_num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, new_hostid_list, 3427 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3428 &ctrlr->hostid); 3429 /* Preempt notification occurs on the unregistered controllers 3430 * other than the controller who issued the command. 3431 */ 3432 num_hostid = nvmf_ns_reservation_get_unregistered_hostid(hostid_list, 3433 num_hostid, 3434 new_hostid_list, 3435 new_num_hostid); 3436 if (num_hostid) { 3437 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3438 hostid_list, 3439 num_hostid, 3440 SPDK_NVME_REGISTRATION_PREEMPTED); 3441 3442 } 3443 /* Reservation released notification occurs on the 3444 * controllers which are the remaining registrants other than 3445 * the controller who issued the command. 3446 */ 3447 if (reservation_released && new_num_hostid) { 3448 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3449 new_hostid_list, 3450 new_num_hostid, 3451 SPDK_NVME_RESERVATION_RELEASED); 3452 3453 } 3454 } 3455 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3456 req->rsp->nvme_cpl.status.sc = status; 3457 return update_sgroup; 3458 } 3459 3460 static bool 3461 nvmf_ns_reservation_release(struct spdk_nvmf_ns *ns, 3462 struct spdk_nvmf_ctrlr *ctrlr, 3463 struct spdk_nvmf_request *req) 3464 { 3465 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3466 uint8_t rrela, iekey, rtype; 3467 struct spdk_nvmf_registrant *reg; 3468 uint64_t crkey = 0; 3469 uint8_t status = SPDK_NVME_SC_SUCCESS; 3470 bool update_sgroup = true; 3471 struct spdk_uuid hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3472 uint32_t num_hostid = 0; 3473 3474 rrela = cmd->cdw10_bits.resv_release.rrela; 3475 iekey = cmd->cdw10_bits.resv_release.iekey; 3476 rtype = cmd->cdw10_bits.resv_release.rtype; 3477 3478 if (req->iovcnt > 0 && req->length >= sizeof(crkey)) { 3479 struct spdk_iov_xfer ix; 3480 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3481 spdk_iov_xfer_to_buf(&ix, &crkey, sizeof(crkey)); 3482 } else { 3483 SPDK_ERRLOG("No key provided. Failing request.\n"); 3484 status = SPDK_NVME_SC_INVALID_FIELD; 3485 goto exit; 3486 } 3487 3488 SPDK_DEBUGLOG(nvmf, "RELEASE: RRELA %u, IEKEY %u, RTYPE %u, " 3489 "CRKEY 0x%"PRIx64"\n", rrela, iekey, rtype, crkey); 3490 3491 if (iekey) { 3492 SPDK_ERRLOG("Ignore existing key field set to 1\n"); 3493 status = SPDK_NVME_SC_INVALID_FIELD; 3494 update_sgroup = false; 3495 goto exit; 3496 } 3497 3498 reg = nvmf_ns_reservation_get_registrant(ns, &ctrlr->hostid); 3499 if (!reg || reg->rkey != crkey) { 3500 SPDK_ERRLOG("No registrant or current key doesn't match " 3501 "with existing registrant key\n"); 3502 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3503 update_sgroup = false; 3504 goto exit; 3505 } 3506 3507 num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, hostid_list, 3508 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3509 &ctrlr->hostid); 3510 3511 switch (rrela) { 3512 case SPDK_NVME_RESERVE_RELEASE: 3513 if (!ns->holder) { 3514 SPDK_DEBUGLOG(nvmf, "RELEASE: no holder\n"); 3515 update_sgroup = false; 3516 goto exit; 3517 } 3518 if (ns->rtype != rtype) { 3519 SPDK_ERRLOG("Type doesn't match\n"); 3520 status = SPDK_NVME_SC_INVALID_FIELD; 3521 update_sgroup = false; 3522 goto exit; 3523 } 3524 if (!nvmf_ns_reservation_registrant_is_holder(ns, reg)) { 3525 /* not the reservation holder, this isn't an error */ 3526 update_sgroup = false; 3527 goto exit; 3528 } 3529 3530 rtype = ns->rtype; 3531 nvmf_ns_reservation_release_reservation(ns); 3532 3533 if (num_hostid && rtype != SPDK_NVME_RESERVE_WRITE_EXCLUSIVE && 3534 rtype != SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS) { 3535 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3536 hostid_list, 3537 num_hostid, 3538 SPDK_NVME_RESERVATION_RELEASED); 3539 } 3540 break; 3541 case SPDK_NVME_RESERVE_CLEAR: 3542 nvmf_ns_reservation_clear_all_registrants(ns); 3543 if (num_hostid) { 3544 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3545 hostid_list, 3546 num_hostid, 3547 SPDK_NVME_RESERVATION_PREEMPTED); 3548 } 3549 break; 3550 default: 3551 status = SPDK_NVME_SC_INVALID_FIELD; 3552 update_sgroup = false; 3553 goto exit; 3554 } 3555 3556 exit: 3557 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3558 req->rsp->nvme_cpl.status.sc = status; 3559 return update_sgroup; 3560 } 3561 3562 static void 3563 nvmf_ns_reservation_report(struct spdk_nvmf_ns *ns, 3564 struct spdk_nvmf_ctrlr *ctrlr, 3565 struct spdk_nvmf_request *req) 3566 { 3567 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3568 struct spdk_nvmf_registrant *reg, *tmp; 3569 struct spdk_nvme_reservation_status_extended_data status_data = { 0 }; 3570 struct spdk_iov_xfer ix; 3571 uint32_t transfer_len; 3572 uint32_t regctl = 0; 3573 uint8_t status = SPDK_NVME_SC_SUCCESS; 3574 3575 if (req->iovcnt == 0) { 3576 SPDK_ERRLOG("No data transfer specified for request. " 3577 " Unable to transfer back response.\n"); 3578 status = SPDK_NVME_SC_INVALID_FIELD; 3579 goto exit; 3580 } 3581 3582 if (!cmd->cdw11_bits.resv_report.eds) { 3583 SPDK_ERRLOG("NVMeoF uses extended controller data structure, " 3584 "please set EDS bit in cdw11 and try again\n"); 3585 status = SPDK_NVME_SC_HOSTID_INCONSISTENT_FORMAT; 3586 goto exit; 3587 } 3588 3589 /* Number of Dwords of the Reservation Status data structure to transfer */ 3590 transfer_len = (cmd->cdw10 + 1) * sizeof(uint32_t); 3591 3592 if (transfer_len < sizeof(struct spdk_nvme_reservation_status_extended_data)) { 3593 status = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3594 goto exit; 3595 } 3596 3597 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3598 3599 status_data.data.gen = ns->gen; 3600 status_data.data.rtype = ns->rtype; 3601 status_data.data.ptpls = ns->ptpl_activated; 3602 3603 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 3604 regctl++; 3605 } 3606 3607 /* 3608 * We report the number of registrants as per the spec here, even if 3609 * the iov isn't big enough to contain them all. In that case, the 3610 * spdk_iov_xfer_from_buf() won't actually copy any of the remaining 3611 * data; as it keeps track of the iov cursor itself, it's simplest to 3612 * just walk the entire list anyway. 3613 */ 3614 status_data.data.regctl = regctl; 3615 3616 spdk_iov_xfer_from_buf(&ix, &status_data, sizeof(status_data)); 3617 3618 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 3619 struct spdk_nvme_registered_ctrlr_extended_data ctrlr_data = { 0 }; 3620 3621 /* Set to 0xffffh for dynamic controller */ 3622 ctrlr_data.cntlid = 0xffff; 3623 ctrlr_data.rcsts.status = (ns->holder == reg) ? true : false; 3624 ctrlr_data.rkey = reg->rkey; 3625 spdk_uuid_copy((struct spdk_uuid *)ctrlr_data.hostid, ®->hostid); 3626 3627 spdk_iov_xfer_from_buf(&ix, &ctrlr_data, sizeof(ctrlr_data)); 3628 } 3629 3630 exit: 3631 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3632 req->rsp->nvme_cpl.status.sc = status; 3633 return; 3634 } 3635 3636 static void 3637 nvmf_ns_reservation_complete(void *ctx) 3638 { 3639 struct spdk_nvmf_request *req = ctx; 3640 3641 spdk_nvmf_request_complete(req); 3642 } 3643 3644 static void 3645 _nvmf_ns_reservation_update_done(struct spdk_nvmf_subsystem *subsystem, 3646 void *cb_arg, int status) 3647 { 3648 struct spdk_nvmf_request *req = (struct spdk_nvmf_request *)cb_arg; 3649 struct spdk_nvmf_poll_group *group = req->qpair->group; 3650 3651 spdk_thread_send_msg(group->thread, nvmf_ns_reservation_complete, req); 3652 } 3653 3654 void 3655 nvmf_ns_reservation_request(void *ctx) 3656 { 3657 struct spdk_nvmf_request *req = (struct spdk_nvmf_request *)ctx; 3658 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3659 struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr; 3660 uint32_t nsid; 3661 struct spdk_nvmf_ns *ns; 3662 bool update_sgroup = false; 3663 int status = 0; 3664 3665 nsid = cmd->nsid; 3666 ns = _nvmf_subsystem_get_ns(ctrlr->subsys, nsid); 3667 assert(ns != NULL); 3668 3669 switch (cmd->opc) { 3670 case SPDK_NVME_OPC_RESERVATION_REGISTER: 3671 update_sgroup = nvmf_ns_reservation_register(ns, ctrlr, req); 3672 break; 3673 case SPDK_NVME_OPC_RESERVATION_ACQUIRE: 3674 update_sgroup = nvmf_ns_reservation_acquire(ns, ctrlr, req); 3675 break; 3676 case SPDK_NVME_OPC_RESERVATION_RELEASE: 3677 update_sgroup = nvmf_ns_reservation_release(ns, ctrlr, req); 3678 break; 3679 case SPDK_NVME_OPC_RESERVATION_REPORT: 3680 nvmf_ns_reservation_report(ns, ctrlr, req); 3681 break; 3682 default: 3683 break; 3684 } 3685 3686 /* update reservation information to subsystem's poll group */ 3687 if (update_sgroup) { 3688 if (ns->ptpl_activated || cmd->opc == SPDK_NVME_OPC_RESERVATION_REGISTER) { 3689 if (nvmf_ns_update_reservation_info(ns) != 0) { 3690 req->rsp->nvme_cpl.status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3691 } 3692 } 3693 status = nvmf_subsystem_update_ns(ctrlr->subsys, _nvmf_ns_reservation_update_done, req); 3694 if (status == 0) { 3695 return; 3696 } 3697 } 3698 3699 _nvmf_ns_reservation_update_done(ctrlr->subsys, req, status); 3700 } 3701 3702 static bool 3703 nvmf_ns_is_ptpl_capable_json(const struct spdk_nvmf_ns *ns) 3704 { 3705 return ns->ptpl_file != NULL; 3706 } 3707 3708 static struct spdk_nvmf_ns_reservation_ops g_reservation_ops = { 3709 .is_ptpl_capable = nvmf_ns_is_ptpl_capable_json, 3710 .update = nvmf_ns_reservation_update_json, 3711 .load = nvmf_ns_reservation_load_json, 3712 }; 3713 3714 bool 3715 nvmf_ns_is_ptpl_capable(const struct spdk_nvmf_ns *ns) 3716 { 3717 return g_reservation_ops.is_ptpl_capable(ns); 3718 } 3719 3720 static int 3721 nvmf_ns_reservation_update(const struct spdk_nvmf_ns *ns, 3722 const struct spdk_nvmf_reservation_info *info) 3723 { 3724 return g_reservation_ops.update(ns, info); 3725 } 3726 3727 static int 3728 nvmf_ns_reservation_load(const struct spdk_nvmf_ns *ns, struct spdk_nvmf_reservation_info *info) 3729 { 3730 return g_reservation_ops.load(ns, info); 3731 } 3732 3733 void 3734 spdk_nvmf_set_custom_ns_reservation_ops(const struct spdk_nvmf_ns_reservation_ops *ops) 3735 { 3736 g_reservation_ops = *ops; 3737 } 3738 3739 int 3740 spdk_nvmf_subsystem_set_ana_reporting(struct spdk_nvmf_subsystem *subsystem, 3741 bool ana_reporting) 3742 { 3743 if (subsystem->state != SPDK_NVMF_SUBSYSTEM_INACTIVE) { 3744 return -EAGAIN; 3745 } 3746 3747 subsystem->flags.ana_reporting = ana_reporting; 3748 3749 return 0; 3750 } 3751 3752 bool 3753 spdk_nvmf_subsystem_get_ana_reporting(struct spdk_nvmf_subsystem *subsystem) 3754 { 3755 return subsystem->flags.ana_reporting; 3756 } 3757 3758 struct subsystem_listener_update_ctx { 3759 struct spdk_nvmf_subsystem_listener *listener; 3760 3761 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn; 3762 void *cb_arg; 3763 }; 3764 3765 static void 3766 subsystem_listener_update_done(struct spdk_io_channel_iter *i, int status) 3767 { 3768 struct subsystem_listener_update_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 3769 3770 if (ctx->cb_fn) { 3771 ctx->cb_fn(ctx->cb_arg, status); 3772 } 3773 free(ctx); 3774 } 3775 3776 static void 3777 subsystem_listener_update_on_pg(struct spdk_io_channel_iter *i) 3778 { 3779 struct subsystem_listener_update_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 3780 struct spdk_nvmf_subsystem_listener *listener; 3781 struct spdk_nvmf_poll_group *group; 3782 struct spdk_nvmf_ctrlr *ctrlr; 3783 3784 listener = ctx->listener; 3785 group = spdk_io_channel_get_ctx(spdk_io_channel_iter_get_channel(i)); 3786 3787 TAILQ_FOREACH(ctrlr, &listener->subsystem->ctrlrs, link) { 3788 if (ctrlr->thread != spdk_get_thread()) { 3789 continue; 3790 } 3791 3792 if (ctrlr->admin_qpair && ctrlr->admin_qpair->group == group && ctrlr->listener == listener) { 3793 nvmf_ctrlr_async_event_ana_change_notice(ctrlr); 3794 } 3795 } 3796 3797 spdk_for_each_channel_continue(i, 0); 3798 } 3799 3800 void 3801 spdk_nvmf_subsystem_set_ana_state(struct spdk_nvmf_subsystem *subsystem, 3802 const struct spdk_nvme_transport_id *trid, 3803 enum spdk_nvme_ana_state ana_state, uint32_t anagrpid, 3804 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, void *cb_arg) 3805 { 3806 struct spdk_nvmf_subsystem_listener *listener; 3807 struct subsystem_listener_update_ctx *ctx; 3808 uint32_t i; 3809 3810 assert(cb_fn != NULL); 3811 assert(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 3812 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED); 3813 3814 if (!subsystem->flags.ana_reporting) { 3815 SPDK_ERRLOG("ANA reporting is disabled\n"); 3816 cb_fn(cb_arg, -EINVAL); 3817 return; 3818 } 3819 3820 /* ANA Change state is not used, ANA Persistent Loss state 3821 * is not supported yet. 3822 */ 3823 if (!(ana_state == SPDK_NVME_ANA_OPTIMIZED_STATE || 3824 ana_state == SPDK_NVME_ANA_NON_OPTIMIZED_STATE || 3825 ana_state == SPDK_NVME_ANA_INACCESSIBLE_STATE)) { 3826 SPDK_ERRLOG("ANA state %d is not supported\n", ana_state); 3827 cb_fn(cb_arg, -ENOTSUP); 3828 return; 3829 } 3830 3831 if (anagrpid > subsystem->max_nsid) { 3832 SPDK_ERRLOG("ANA group ID %" PRIu32 " is more than maximum\n", anagrpid); 3833 cb_fn(cb_arg, -EINVAL); 3834 return; 3835 } 3836 3837 listener = nvmf_subsystem_find_listener(subsystem, trid); 3838 if (!listener) { 3839 SPDK_ERRLOG("Unable to find listener.\n"); 3840 cb_fn(cb_arg, -EINVAL); 3841 return; 3842 } 3843 3844 if (anagrpid != 0 && listener->ana_state[anagrpid - 1] == ana_state) { 3845 cb_fn(cb_arg, 0); 3846 return; 3847 } 3848 3849 ctx = calloc(1, sizeof(*ctx)); 3850 if (!ctx) { 3851 SPDK_ERRLOG("Unable to allocate context\n"); 3852 cb_fn(cb_arg, -ENOMEM); 3853 return; 3854 } 3855 3856 for (i = 1; i <= subsystem->max_nsid; i++) { 3857 if (anagrpid == 0 || i == anagrpid) { 3858 listener->ana_state[i - 1] = ana_state; 3859 } 3860 } 3861 listener->ana_state_change_count++; 3862 3863 ctx->listener = listener; 3864 ctx->cb_fn = cb_fn; 3865 ctx->cb_arg = cb_arg; 3866 3867 spdk_for_each_channel(subsystem->tgt, 3868 subsystem_listener_update_on_pg, 3869 ctx, 3870 subsystem_listener_update_done); 3871 } 3872 3873 int 3874 spdk_nvmf_subsystem_get_ana_state(struct spdk_nvmf_subsystem *subsystem, 3875 const struct spdk_nvme_transport_id *trid, 3876 uint32_t anagrpid, 3877 enum spdk_nvme_ana_state *ana_state) 3878 { 3879 assert(ana_state != NULL); 3880 3881 struct spdk_nvmf_subsystem_listener *listener; 3882 3883 if (!subsystem->flags.ana_reporting) { 3884 SPDK_ERRLOG("ANA reporting is disabled\n"); 3885 return -EINVAL; 3886 } 3887 3888 if (anagrpid <= 0 || anagrpid > subsystem->max_nsid) { 3889 SPDK_ERRLOG("ANA group ID %" PRIu32 " is invalid\n", anagrpid); 3890 return -EINVAL; 3891 } 3892 3893 listener = nvmf_subsystem_find_listener(subsystem, trid); 3894 if (!listener) { 3895 SPDK_ERRLOG("Unable to find listener.\n"); 3896 return -EINVAL; 3897 } 3898 3899 *ana_state = listener->ana_state[anagrpid - 1]; 3900 return 0; 3901 } 3902 3903 bool 3904 spdk_nvmf_subsystem_is_discovery(struct spdk_nvmf_subsystem *subsystem) 3905 { 3906 return subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT || 3907 subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY; 3908 } 3909 3910 bool 3911 nvmf_nqn_is_discovery(const char *nqn) 3912 { 3913 return strcmp(nqn, SPDK_NVMF_DISCOVERY_NQN) == 0; 3914 } 3915