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 = 0; 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 nvmf_update_discovery_log(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 spdk_bit_array_get(ctrlr->visible_ns, nsid - 1) == visible) { 925 continue; 926 } 927 if (visible) { 928 spdk_bit_array_set(ctrlr->visible_ns, nsid - 1); 929 } else { 930 spdk_bit_array_clear(ctrlr->visible_ns, nsid - 1); 931 } 932 send_async_event_ns_notice(ctrlr); 933 nvmf_ctrlr_ns_changed(ctrlr, nsid); 934 } 935 936 return 0; 937 } 938 939 int 940 spdk_nvmf_ns_add_host(struct spdk_nvmf_subsystem *subsystem, 941 uint32_t nsid, 942 const char *hostnqn, 943 uint32_t flags) 944 { 945 SPDK_DTRACE_PROBE4(spdk_nvmf_ns_add_host, 946 subsystem->subnqn, 947 nsid, 948 hostnqn, 949 flags); 950 return nvmf_ns_visible(subsystem, nsid, hostnqn, true); 951 } 952 953 int 954 spdk_nvmf_ns_remove_host(struct spdk_nvmf_subsystem *subsystem, 955 uint32_t nsid, 956 const char *hostnqn, 957 uint32_t flags) 958 { 959 SPDK_DTRACE_PROBE4(spdk_nvmf_ns_remove_host, 960 subsystem->subnqn, 961 nsid, 962 hostnqn, 963 flags); 964 return nvmf_ns_visible(subsystem, nsid, hostnqn, false); 965 } 966 967 /* Must hold subsystem->mutex while calling this function */ 968 static struct spdk_nvmf_host * 969 nvmf_subsystem_find_host(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 970 { 971 struct spdk_nvmf_host *host = NULL; 972 973 TAILQ_FOREACH(host, &subsystem->hosts, link) { 974 if (strcmp(hostnqn, host->nqn) == 0) { 975 return host; 976 } 977 } 978 979 return NULL; 980 } 981 982 int 983 spdk_nvmf_subsystem_add_host_ext(struct spdk_nvmf_subsystem *subsystem, 984 const char *hostnqn, struct spdk_nvmf_host_opts *opts) 985 { 986 struct spdk_nvmf_host *host; 987 struct spdk_nvmf_transport *transport; 988 struct spdk_key *key; 989 int rc; 990 991 if (!nvmf_nqn_is_valid(hostnqn)) { 992 return -EINVAL; 993 } 994 995 pthread_mutex_lock(&subsystem->mutex); 996 997 if (nvmf_subsystem_find_host(subsystem, hostnqn)) { 998 /* This subsystem already allows the specified host. */ 999 pthread_mutex_unlock(&subsystem->mutex); 1000 return -EINVAL; 1001 } 1002 1003 host = calloc(1, sizeof(*host)); 1004 if (!host) { 1005 pthread_mutex_unlock(&subsystem->mutex); 1006 return -ENOMEM; 1007 } 1008 1009 key = SPDK_GET_FIELD(opts, dhchap_key, NULL); 1010 if (key != NULL) { 1011 if (!nvmf_auth_is_supported()) { 1012 SPDK_ERRLOG("NVMe in-band authentication is unsupported\n"); 1013 pthread_mutex_unlock(&subsystem->mutex); 1014 nvmf_host_free(host); 1015 return -EINVAL; 1016 } 1017 host->dhchap_key = spdk_key_dup(key); 1018 if (host->dhchap_key == NULL) { 1019 pthread_mutex_unlock(&subsystem->mutex); 1020 nvmf_host_free(host); 1021 return -EINVAL; 1022 } 1023 key = SPDK_GET_FIELD(opts, dhchap_ctrlr_key, NULL); 1024 if (key != NULL) { 1025 host->dhchap_ctrlr_key = spdk_key_dup(key); 1026 if (host->dhchap_ctrlr_key == NULL) { 1027 pthread_mutex_unlock(&subsystem->mutex); 1028 nvmf_host_free(host); 1029 return -EINVAL; 1030 } 1031 } 1032 } else if (SPDK_GET_FIELD(opts, dhchap_ctrlr_key, NULL) != NULL) { 1033 SPDK_ERRLOG("DH-HMAC-CHAP controller key requires host key to be set\n"); 1034 pthread_mutex_unlock(&subsystem->mutex); 1035 nvmf_host_free(host); 1036 return -EINVAL; 1037 } 1038 1039 snprintf(host->nqn, sizeof(host->nqn), "%s", hostnqn); 1040 1041 SPDK_DTRACE_PROBE2(nvmf_subsystem_add_host, subsystem->subnqn, host->nqn); 1042 1043 TAILQ_INSERT_HEAD(&subsystem->hosts, host, link); 1044 1045 if (!TAILQ_EMPTY(&subsystem->listeners)) { 1046 nvmf_update_discovery_log(subsystem->tgt, hostnqn); 1047 } 1048 1049 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 1050 transport = spdk_nvmf_transport_get_next(transport)) { 1051 if (transport->ops->subsystem_add_host) { 1052 rc = transport->ops->subsystem_add_host(transport, subsystem, hostnqn, 1053 SPDK_GET_FIELD(opts, params, NULL)); 1054 if (rc) { 1055 SPDK_ERRLOG("Unable to add host to %s transport\n", transport->ops->name); 1056 /* Remove this host from all transports we've managed to add it to. */ 1057 pthread_mutex_unlock(&subsystem->mutex); 1058 spdk_nvmf_subsystem_remove_host(subsystem, hostnqn); 1059 return rc; 1060 } 1061 } 1062 } 1063 1064 pthread_mutex_unlock(&subsystem->mutex); 1065 1066 return 0; 1067 } 1068 1069 int 1070 spdk_nvmf_subsystem_add_host(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn, 1071 const struct spdk_json_val *params) 1072 { 1073 struct spdk_nvmf_host_opts opts = {}; 1074 1075 opts.size = SPDK_SIZEOF(&opts, params); 1076 opts.params = params; 1077 1078 return spdk_nvmf_subsystem_add_host_ext(subsystem, hostnqn, &opts); 1079 } 1080 1081 int 1082 spdk_nvmf_subsystem_remove_host(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 1083 { 1084 struct spdk_nvmf_host *host; 1085 struct spdk_nvmf_transport *transport; 1086 1087 pthread_mutex_lock(&subsystem->mutex); 1088 1089 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1090 if (host == NULL) { 1091 pthread_mutex_unlock(&subsystem->mutex); 1092 return -ENOENT; 1093 } 1094 1095 SPDK_DTRACE_PROBE2(nvmf_subsystem_remove_host, subsystem->subnqn, host->nqn); 1096 1097 nvmf_subsystem_remove_host(subsystem, host); 1098 1099 if (!TAILQ_EMPTY(&subsystem->listeners)) { 1100 nvmf_update_discovery_log(subsystem->tgt, hostnqn); 1101 } 1102 1103 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 1104 transport = spdk_nvmf_transport_get_next(transport)) { 1105 if (transport->ops->subsystem_remove_host) { 1106 transport->ops->subsystem_remove_host(transport, subsystem, hostnqn); 1107 } 1108 } 1109 1110 pthread_mutex_unlock(&subsystem->mutex); 1111 1112 return 0; 1113 } 1114 1115 int 1116 spdk_nvmf_subsystem_set_keys(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn, 1117 struct spdk_nvmf_subsystem_key_opts *opts) 1118 { 1119 struct spdk_nvmf_host *host; 1120 struct spdk_key *key, *ckey; 1121 1122 if (!nvmf_auth_is_supported()) { 1123 SPDK_ERRLOG("NVMe in-band authentication is unsupported\n"); 1124 return -EINVAL; 1125 } 1126 1127 pthread_mutex_lock(&subsystem->mutex); 1128 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1129 if (host == NULL) { 1130 pthread_mutex_unlock(&subsystem->mutex); 1131 return -EINVAL; 1132 } 1133 1134 if (SPDK_GET_FIELD(opts, dhchap_key, host->dhchap_key) == NULL && 1135 SPDK_GET_FIELD(opts, dhchap_ctrlr_key, host->dhchap_ctrlr_key) != NULL) { 1136 SPDK_ERRLOG("DH-HMAC-CHAP controller key requires host key to be set\n"); 1137 pthread_mutex_unlock(&subsystem->mutex); 1138 return -EINVAL; 1139 } 1140 key = SPDK_GET_FIELD(opts, dhchap_key, NULL); 1141 if (key != NULL) { 1142 key = spdk_key_dup(key); 1143 if (key == NULL) { 1144 pthread_mutex_unlock(&subsystem->mutex); 1145 return -EINVAL; 1146 } 1147 } 1148 ckey = SPDK_GET_FIELD(opts, dhchap_ctrlr_key, NULL); 1149 if (ckey != NULL) { 1150 ckey = spdk_key_dup(ckey); 1151 if (ckey == NULL) { 1152 pthread_mutex_unlock(&subsystem->mutex); 1153 spdk_keyring_put_key(key); 1154 return -EINVAL; 1155 } 1156 } 1157 if (SPDK_FIELD_VALID(opts, dhchap_key)) { 1158 spdk_keyring_put_key(host->dhchap_key); 1159 host->dhchap_key = key; 1160 } 1161 if (SPDK_FIELD_VALID(opts, dhchap_ctrlr_key)) { 1162 spdk_keyring_put_key(host->dhchap_ctrlr_key); 1163 host->dhchap_ctrlr_key = ckey; 1164 } 1165 pthread_mutex_unlock(&subsystem->mutex); 1166 1167 return 0; 1168 } 1169 1170 struct nvmf_subsystem_disconnect_host_ctx { 1171 struct spdk_nvmf_subsystem *subsystem; 1172 char *hostnqn; 1173 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn; 1174 void *cb_arg; 1175 }; 1176 1177 static void 1178 nvmf_subsystem_disconnect_host_fini(struct spdk_io_channel_iter *i, int status) 1179 { 1180 struct nvmf_subsystem_disconnect_host_ctx *ctx; 1181 1182 ctx = spdk_io_channel_iter_get_ctx(i); 1183 1184 if (ctx->cb_fn) { 1185 ctx->cb_fn(ctx->cb_arg, status); 1186 } 1187 free(ctx->hostnqn); 1188 free(ctx); 1189 } 1190 1191 static void 1192 nvmf_subsystem_disconnect_qpairs_by_host(struct spdk_io_channel_iter *i) 1193 { 1194 struct nvmf_subsystem_disconnect_host_ctx *ctx; 1195 struct spdk_nvmf_poll_group *group; 1196 struct spdk_io_channel *ch; 1197 struct spdk_nvmf_qpair *qpair, *tmp_qpair; 1198 struct spdk_nvmf_ctrlr *ctrlr; 1199 1200 ctx = spdk_io_channel_iter_get_ctx(i); 1201 ch = spdk_io_channel_iter_get_channel(i); 1202 group = spdk_io_channel_get_ctx(ch); 1203 1204 TAILQ_FOREACH_SAFE(qpair, &group->qpairs, link, tmp_qpair) { 1205 ctrlr = qpair->ctrlr; 1206 1207 if (ctrlr == NULL || ctrlr->subsys != ctx->subsystem) { 1208 continue; 1209 } 1210 1211 if (strncmp(ctrlr->hostnqn, ctx->hostnqn, sizeof(ctrlr->hostnqn)) == 0) { 1212 /* Right now this does not wait for the queue pairs to actually disconnect. */ 1213 spdk_nvmf_qpair_disconnect(qpair); 1214 } 1215 } 1216 spdk_for_each_channel_continue(i, 0); 1217 } 1218 1219 int 1220 spdk_nvmf_subsystem_disconnect_host(struct spdk_nvmf_subsystem *subsystem, 1221 const char *hostnqn, 1222 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1223 void *cb_arg) 1224 { 1225 struct nvmf_subsystem_disconnect_host_ctx *ctx; 1226 1227 ctx = calloc(1, sizeof(struct nvmf_subsystem_disconnect_host_ctx)); 1228 if (ctx == NULL) { 1229 return -ENOMEM; 1230 } 1231 1232 ctx->hostnqn = strdup(hostnqn); 1233 if (ctx->hostnqn == NULL) { 1234 free(ctx); 1235 return -ENOMEM; 1236 } 1237 1238 ctx->subsystem = subsystem; 1239 ctx->cb_fn = cb_fn; 1240 ctx->cb_arg = cb_arg; 1241 1242 spdk_for_each_channel(subsystem->tgt, nvmf_subsystem_disconnect_qpairs_by_host, ctx, 1243 nvmf_subsystem_disconnect_host_fini); 1244 1245 return 0; 1246 } 1247 1248 int 1249 spdk_nvmf_subsystem_set_allow_any_host(struct spdk_nvmf_subsystem *subsystem, bool allow_any_host) 1250 { 1251 pthread_mutex_lock(&subsystem->mutex); 1252 subsystem->allow_any_host = allow_any_host; 1253 if (!TAILQ_EMPTY(&subsystem->listeners)) { 1254 nvmf_update_discovery_log(subsystem->tgt, NULL); 1255 } 1256 pthread_mutex_unlock(&subsystem->mutex); 1257 1258 return 0; 1259 } 1260 1261 bool 1262 spdk_nvmf_subsystem_get_allow_any_host(const struct spdk_nvmf_subsystem *subsystem) 1263 { 1264 bool allow_any_host; 1265 struct spdk_nvmf_subsystem *sub; 1266 1267 /* Technically, taking the mutex modifies data in the subsystem. But the const 1268 * is still important to convey that this doesn't mutate any other data. Cast 1269 * it away to work around this. */ 1270 sub = (struct spdk_nvmf_subsystem *)subsystem; 1271 1272 pthread_mutex_lock(&sub->mutex); 1273 allow_any_host = sub->allow_any_host; 1274 pthread_mutex_unlock(&sub->mutex); 1275 1276 return allow_any_host; 1277 } 1278 1279 bool 1280 spdk_nvmf_subsystem_host_allowed(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 1281 { 1282 bool allowed; 1283 1284 if (!hostnqn) { 1285 return false; 1286 } 1287 1288 pthread_mutex_lock(&subsystem->mutex); 1289 1290 if (subsystem->allow_any_host) { 1291 pthread_mutex_unlock(&subsystem->mutex); 1292 return true; 1293 } 1294 1295 allowed = nvmf_subsystem_find_host(subsystem, hostnqn) != NULL; 1296 pthread_mutex_unlock(&subsystem->mutex); 1297 1298 return allowed; 1299 } 1300 1301 bool 1302 nvmf_subsystem_host_auth_required(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn) 1303 { 1304 struct spdk_nvmf_host *host; 1305 bool status; 1306 1307 pthread_mutex_lock(&subsystem->mutex); 1308 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1309 status = host != NULL && host->dhchap_key != NULL; 1310 pthread_mutex_unlock(&subsystem->mutex); 1311 1312 return status; 1313 } 1314 1315 struct spdk_key * 1316 nvmf_subsystem_get_dhchap_key(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn, 1317 enum nvmf_auth_key_type type) 1318 { 1319 struct spdk_nvmf_host *host; 1320 struct spdk_key *key = NULL; 1321 1322 pthread_mutex_lock(&subsystem->mutex); 1323 host = nvmf_subsystem_find_host(subsystem, hostnqn); 1324 if (host != NULL) { 1325 switch (type) { 1326 case NVMF_AUTH_KEY_HOST: 1327 key = host->dhchap_key; 1328 break; 1329 case NVMF_AUTH_KEY_CTRLR: 1330 key = host->dhchap_ctrlr_key; 1331 break; 1332 } 1333 if (key != NULL) { 1334 key = spdk_key_dup(key); 1335 } 1336 } 1337 pthread_mutex_unlock(&subsystem->mutex); 1338 1339 return key; 1340 } 1341 1342 struct spdk_nvmf_host * 1343 spdk_nvmf_subsystem_get_first_host(struct spdk_nvmf_subsystem *subsystem) 1344 { 1345 return TAILQ_FIRST(&subsystem->hosts); 1346 } 1347 1348 1349 struct spdk_nvmf_host * 1350 spdk_nvmf_subsystem_get_next_host(struct spdk_nvmf_subsystem *subsystem, 1351 struct spdk_nvmf_host *prev_host) 1352 { 1353 return TAILQ_NEXT(prev_host, link); 1354 } 1355 1356 const char * 1357 spdk_nvmf_host_get_nqn(const struct spdk_nvmf_host *host) 1358 { 1359 return host->nqn; 1360 } 1361 1362 struct spdk_nvmf_subsystem_listener * 1363 nvmf_subsystem_find_listener(struct spdk_nvmf_subsystem *subsystem, 1364 const struct spdk_nvme_transport_id *trid) 1365 { 1366 struct spdk_nvmf_subsystem_listener *listener; 1367 1368 TAILQ_FOREACH(listener, &subsystem->listeners, link) { 1369 if (spdk_nvme_transport_id_compare(listener->trid, trid) == 0) { 1370 return listener; 1371 } 1372 } 1373 1374 return NULL; 1375 } 1376 1377 /** 1378 * Function to be called once the target is listening. 1379 * 1380 * \param ctx Context argument passed to this function. 1381 * \param status 0 if it completed successfully, or negative errno if it failed. 1382 */ 1383 static void 1384 _nvmf_subsystem_add_listener_done(void *ctx, int status) 1385 { 1386 struct spdk_nvmf_subsystem_listener *listener = ctx; 1387 1388 if (status) { 1389 listener->cb_fn(listener->cb_arg, status); 1390 free(listener); 1391 return; 1392 } 1393 1394 TAILQ_INSERT_HEAD(&listener->subsystem->listeners, listener, link); 1395 1396 if (spdk_nvmf_subsystem_is_discovery(listener->subsystem)) { 1397 status = nvmf_tgt_update_mdns_prr(listener->subsystem->tgt); 1398 if (status) { 1399 TAILQ_REMOVE(&listener->subsystem->listeners, listener, link); 1400 listener->cb_fn(listener->cb_arg, status); 1401 free(listener); 1402 return; 1403 } 1404 } 1405 1406 nvmf_update_discovery_log(listener->subsystem->tgt, NULL); 1407 listener->cb_fn(listener->cb_arg, status); 1408 } 1409 1410 void 1411 spdk_nvmf_subsystem_listener_opts_init(struct spdk_nvmf_listener_opts *opts, size_t size) 1412 { 1413 if (opts == NULL) { 1414 SPDK_ERRLOG("opts should not be NULL\n"); 1415 assert(false); 1416 return; 1417 } 1418 if (size == 0) { 1419 SPDK_ERRLOG("size should not be zero\n"); 1420 assert(false); 1421 return; 1422 } 1423 1424 memset(opts, 0, size); 1425 opts->opts_size = size; 1426 1427 #define FIELD_OK(field) \ 1428 offsetof(struct spdk_nvmf_listener_opts, field) + sizeof(opts->field) <= size 1429 1430 #define SET_FIELD(field, value) \ 1431 if (FIELD_OK(field)) { \ 1432 opts->field = value; \ 1433 } \ 1434 1435 SET_FIELD(secure_channel, false); 1436 SET_FIELD(ana_state, SPDK_NVME_ANA_OPTIMIZED_STATE); 1437 SET_FIELD(sock_impl, NULL); 1438 1439 #undef FIELD_OK 1440 #undef SET_FIELD 1441 } 1442 1443 static int 1444 listener_opts_copy(struct spdk_nvmf_listener_opts *src, struct spdk_nvmf_listener_opts *dst) 1445 { 1446 if (src->opts_size == 0) { 1447 SPDK_ERRLOG("source structure size should not be zero\n"); 1448 assert(false); 1449 return -EINVAL; 1450 } 1451 1452 memset(dst, 0, sizeof(*dst)); 1453 dst->opts_size = src->opts_size; 1454 1455 #define FIELD_OK(field) \ 1456 offsetof(struct spdk_nvmf_listener_opts, field) + sizeof(src->field) <= src->opts_size 1457 1458 #define SET_FIELD(field) \ 1459 if (FIELD_OK(field)) { \ 1460 dst->field = src->field; \ 1461 } \ 1462 1463 SET_FIELD(secure_channel); 1464 SET_FIELD(ana_state); 1465 SET_FIELD(sock_impl); 1466 /* We should not remove this statement, but need to update the assert statement 1467 * if we add a new field, and also add a corresponding SET_FIELD statement. */ 1468 SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_listener_opts) == 24, "Incorrect size"); 1469 1470 #undef SET_FIELD 1471 #undef FIELD_OK 1472 1473 return 0; 1474 } 1475 1476 static void 1477 _nvmf_subsystem_add_listener(struct spdk_nvmf_subsystem *subsystem, 1478 struct spdk_nvme_transport_id *trid, 1479 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1480 void *cb_arg, struct spdk_nvmf_listener_opts *opts) 1481 { 1482 struct spdk_nvmf_transport *transport; 1483 struct spdk_nvmf_subsystem_listener *listener; 1484 struct spdk_nvmf_listener *tr_listener; 1485 uint32_t i; 1486 uint32_t id; 1487 int rc = 0; 1488 1489 assert(cb_fn != NULL); 1490 1491 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 1492 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 1493 cb_fn(cb_arg, -EAGAIN); 1494 return; 1495 } 1496 1497 if (nvmf_subsystem_find_listener(subsystem, trid)) { 1498 /* Listener already exists in this subsystem */ 1499 cb_fn(cb_arg, 0); 1500 return; 1501 } 1502 1503 transport = spdk_nvmf_tgt_get_transport(subsystem->tgt, trid->trstring); 1504 if (!transport) { 1505 SPDK_ERRLOG("Unable to find %s transport. The transport must be created first also make sure it is properly registered.\n", 1506 trid->trstring); 1507 cb_fn(cb_arg, -EINVAL); 1508 return; 1509 } 1510 1511 tr_listener = nvmf_transport_find_listener(transport, trid); 1512 if (!tr_listener) { 1513 SPDK_ERRLOG("Cannot find transport listener for %s\n", trid->traddr); 1514 cb_fn(cb_arg, -EINVAL); 1515 return; 1516 } 1517 1518 listener = calloc(1, sizeof(*listener)); 1519 if (!listener) { 1520 cb_fn(cb_arg, -ENOMEM); 1521 return; 1522 } 1523 1524 listener->trid = &tr_listener->trid; 1525 listener->transport = transport; 1526 listener->cb_fn = cb_fn; 1527 listener->cb_arg = cb_arg; 1528 listener->subsystem = subsystem; 1529 listener->ana_state = calloc(subsystem->max_nsid, sizeof(enum spdk_nvme_ana_state)); 1530 if (!listener->ana_state) { 1531 free(listener); 1532 cb_fn(cb_arg, -ENOMEM); 1533 return; 1534 } 1535 1536 spdk_nvmf_subsystem_listener_opts_init(&listener->opts, sizeof(listener->opts)); 1537 if (opts != NULL) { 1538 rc = listener_opts_copy(opts, &listener->opts); 1539 if (rc) { 1540 SPDK_ERRLOG("Unable to copy listener options\n"); 1541 free(listener->ana_state); 1542 free(listener); 1543 cb_fn(cb_arg, -EINVAL); 1544 return; 1545 } 1546 } 1547 1548 id = spdk_bit_array_find_first_clear(subsystem->used_listener_ids, 0); 1549 if (id == UINT32_MAX) { 1550 SPDK_ERRLOG("Cannot add any more listeners\n"); 1551 free(listener->ana_state); 1552 free(listener->opts.sock_impl); 1553 free(listener); 1554 cb_fn(cb_arg, -EINVAL); 1555 return; 1556 } 1557 1558 spdk_bit_array_set(subsystem->used_listener_ids, id); 1559 listener->id = id; 1560 1561 for (i = 0; i < subsystem->max_nsid; i++) { 1562 listener->ana_state[i] = listener->opts.ana_state; 1563 } 1564 1565 if (transport->ops->listen_associate != NULL) { 1566 rc = transport->ops->listen_associate(transport, subsystem, trid); 1567 } 1568 1569 SPDK_DTRACE_PROBE4(nvmf_subsystem_add_listener, subsystem->subnqn, listener->trid->trtype, 1570 listener->trid->traddr, listener->trid->trsvcid); 1571 1572 _nvmf_subsystem_add_listener_done(listener, rc); 1573 } 1574 1575 void 1576 spdk_nvmf_subsystem_add_listener(struct spdk_nvmf_subsystem *subsystem, 1577 struct spdk_nvme_transport_id *trid, 1578 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1579 void *cb_arg) 1580 { 1581 _nvmf_subsystem_add_listener(subsystem, trid, cb_fn, cb_arg, NULL); 1582 } 1583 1584 void 1585 spdk_nvmf_subsystem_add_listener_ext(struct spdk_nvmf_subsystem *subsystem, 1586 struct spdk_nvme_transport_id *trid, 1587 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, 1588 void *cb_arg, struct spdk_nvmf_listener_opts *opts) 1589 { 1590 _nvmf_subsystem_add_listener(subsystem, trid, cb_fn, cb_arg, opts); 1591 } 1592 1593 int 1594 spdk_nvmf_subsystem_remove_listener(struct spdk_nvmf_subsystem *subsystem, 1595 const struct spdk_nvme_transport_id *trid) 1596 { 1597 struct spdk_nvmf_subsystem_listener *listener; 1598 1599 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 1600 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 1601 return -EAGAIN; 1602 } 1603 1604 listener = nvmf_subsystem_find_listener(subsystem, trid); 1605 if (listener == NULL) { 1606 return -ENOENT; 1607 } 1608 1609 SPDK_DTRACE_PROBE4(nvmf_subsystem_remove_listener, subsystem->subnqn, listener->trid->trtype, 1610 listener->trid->traddr, listener->trid->trsvcid); 1611 1612 _nvmf_subsystem_remove_listener(subsystem, listener, false); 1613 1614 return 0; 1615 } 1616 1617 void 1618 nvmf_subsystem_remove_all_listeners(struct spdk_nvmf_subsystem *subsystem, 1619 bool stop) 1620 { 1621 struct spdk_nvmf_subsystem_listener *listener, *listener_tmp; 1622 1623 TAILQ_FOREACH_SAFE(listener, &subsystem->listeners, link, listener_tmp) { 1624 _nvmf_subsystem_remove_listener(subsystem, listener, stop); 1625 } 1626 } 1627 1628 bool 1629 spdk_nvmf_subsystem_listener_allowed(struct spdk_nvmf_subsystem *subsystem, 1630 const struct spdk_nvme_transport_id *trid) 1631 { 1632 struct spdk_nvmf_subsystem_listener *listener; 1633 1634 TAILQ_FOREACH(listener, &subsystem->listeners, link) { 1635 if (spdk_nvme_transport_id_compare(listener->trid, trid) == 0) { 1636 return true; 1637 } 1638 } 1639 1640 if (!strcmp(subsystem->subnqn, SPDK_NVMF_DISCOVERY_NQN)) { 1641 SPDK_WARNLOG("Allowing connection to discovery subsystem on %s/%s/%s, " 1642 "even though this listener was not added to the discovery " 1643 "subsystem. This behavior is deprecated and will be removed " 1644 "in a future release.\n", 1645 spdk_nvme_transport_id_trtype_str(trid->trtype), trid->traddr, trid->trsvcid); 1646 return true; 1647 } 1648 1649 return false; 1650 } 1651 1652 struct spdk_nvmf_subsystem_listener * 1653 spdk_nvmf_subsystem_get_first_listener(struct spdk_nvmf_subsystem *subsystem) 1654 { 1655 return TAILQ_FIRST(&subsystem->listeners); 1656 } 1657 1658 struct spdk_nvmf_subsystem_listener * 1659 spdk_nvmf_subsystem_get_next_listener(struct spdk_nvmf_subsystem *subsystem, 1660 struct spdk_nvmf_subsystem_listener *prev_listener) 1661 { 1662 return TAILQ_NEXT(prev_listener, link); 1663 } 1664 1665 const struct spdk_nvme_transport_id * 1666 spdk_nvmf_subsystem_listener_get_trid(struct spdk_nvmf_subsystem_listener *listener) 1667 { 1668 return listener->trid; 1669 } 1670 1671 void 1672 spdk_nvmf_subsystem_allow_any_listener(struct spdk_nvmf_subsystem *subsystem, 1673 bool allow_any_listener) 1674 { 1675 subsystem->flags.allow_any_listener = allow_any_listener; 1676 } 1677 1678 bool 1679 spdk_nvmf_subsystem_any_listener_allowed(struct spdk_nvmf_subsystem *subsystem) 1680 { 1681 return subsystem->flags.allow_any_listener; 1682 } 1683 1684 struct subsystem_update_ns_ctx { 1685 struct spdk_nvmf_subsystem *subsystem; 1686 1687 spdk_nvmf_subsystem_state_change_done cb_fn; 1688 void *cb_arg; 1689 }; 1690 1691 static void 1692 subsystem_update_ns_done(struct spdk_io_channel_iter *i, int status) 1693 { 1694 struct subsystem_update_ns_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 1695 1696 if (ctx->cb_fn) { 1697 ctx->cb_fn(ctx->subsystem, ctx->cb_arg, status); 1698 } 1699 free(ctx); 1700 } 1701 1702 static void 1703 subsystem_update_ns_on_pg(struct spdk_io_channel_iter *i) 1704 { 1705 int rc; 1706 struct subsystem_update_ns_ctx *ctx; 1707 struct spdk_nvmf_poll_group *group; 1708 struct spdk_nvmf_subsystem *subsystem; 1709 1710 ctx = spdk_io_channel_iter_get_ctx(i); 1711 group = spdk_io_channel_get_ctx(spdk_io_channel_iter_get_channel(i)); 1712 subsystem = ctx->subsystem; 1713 1714 rc = nvmf_poll_group_update_subsystem(group, subsystem); 1715 spdk_for_each_channel_continue(i, rc); 1716 } 1717 1718 static int 1719 nvmf_subsystem_update_ns(struct spdk_nvmf_subsystem *subsystem, 1720 spdk_nvmf_subsystem_state_change_done cb_fn, void *cb_arg) 1721 { 1722 struct subsystem_update_ns_ctx *ctx; 1723 1724 ctx = calloc(1, sizeof(*ctx)); 1725 if (ctx == NULL) { 1726 SPDK_ERRLOG("Can't alloc subsystem poll group update context\n"); 1727 return -ENOMEM; 1728 } 1729 ctx->subsystem = subsystem; 1730 ctx->cb_fn = cb_fn; 1731 ctx->cb_arg = cb_arg; 1732 1733 spdk_for_each_channel(subsystem->tgt, 1734 subsystem_update_ns_on_pg, 1735 ctx, 1736 subsystem_update_ns_done); 1737 return 0; 1738 } 1739 1740 static void 1741 nvmf_subsystem_ns_changed(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid) 1742 { 1743 struct spdk_nvmf_ctrlr *ctrlr; 1744 1745 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1746 if (nvmf_ctrlr_ns_is_visible(ctrlr, nsid)) { 1747 nvmf_ctrlr_ns_changed(ctrlr, nsid); 1748 } 1749 } 1750 } 1751 1752 static uint32_t nvmf_ns_reservation_clear_all_registrants(struct spdk_nvmf_ns *ns); 1753 1754 int 1755 spdk_nvmf_subsystem_remove_ns(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid) 1756 { 1757 struct spdk_nvmf_transport *transport; 1758 struct spdk_nvmf_ns *ns; 1759 struct spdk_nvmf_host *host, *tmp; 1760 struct spdk_nvmf_ctrlr *ctrlr; 1761 1762 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 1763 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 1764 assert(false); 1765 return -1; 1766 } 1767 1768 if (nsid == 0 || nsid > subsystem->max_nsid) { 1769 return -1; 1770 } 1771 1772 ns = subsystem->ns[nsid - 1]; 1773 if (!ns) { 1774 return -1; 1775 } 1776 1777 subsystem->ns[nsid - 1] = NULL; 1778 1779 assert(ns->anagrpid - 1 < subsystem->max_nsid); 1780 assert(subsystem->ana_group[ns->anagrpid - 1] > 0); 1781 1782 subsystem->ana_group[ns->anagrpid - 1]--; 1783 1784 TAILQ_FOREACH_SAFE(host, &ns->hosts, link, tmp) { 1785 nvmf_ns_remove_host(ns, host); 1786 } 1787 1788 free(ns->ptpl_file); 1789 nvmf_ns_reservation_clear_all_registrants(ns); 1790 spdk_bdev_module_release_bdev(ns->bdev); 1791 spdk_bdev_close(ns->desc); 1792 free(ns); 1793 1794 if (subsystem->fdp_supported && !spdk_nvmf_subsystem_get_first_ns(subsystem)) { 1795 subsystem->fdp_supported = false; 1796 SPDK_DEBUGLOG(nvmf, "Subsystem with id: %u doesn't have FDP capability.\n", 1797 subsystem->id); 1798 } 1799 1800 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 1801 transport = spdk_nvmf_transport_get_next(transport)) { 1802 if (transport->ops->subsystem_remove_ns) { 1803 transport->ops->subsystem_remove_ns(transport, subsystem, nsid); 1804 } 1805 } 1806 1807 nvmf_subsystem_ns_changed(subsystem, nsid); 1808 1809 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1810 spdk_bit_array_clear(ctrlr->visible_ns, nsid - 1); 1811 } 1812 1813 return 0; 1814 } 1815 1816 struct subsystem_ns_change_ctx { 1817 struct spdk_nvmf_subsystem *subsystem; 1818 spdk_nvmf_subsystem_state_change_done cb_fn; 1819 uint32_t nsid; 1820 }; 1821 1822 static void 1823 _nvmf_ns_hot_remove(struct spdk_nvmf_subsystem *subsystem, 1824 void *cb_arg, int status) 1825 { 1826 struct subsystem_ns_change_ctx *ctx = cb_arg; 1827 int rc; 1828 1829 rc = spdk_nvmf_subsystem_remove_ns(subsystem, ctx->nsid); 1830 if (rc != 0) { 1831 SPDK_ERRLOG("Failed to make changes to NVME-oF subsystem with id: %u\n", subsystem->id); 1832 } 1833 1834 rc = spdk_nvmf_subsystem_resume(subsystem, NULL, NULL); 1835 if (rc != 0) { 1836 SPDK_ERRLOG("Failed to resume NVME-oF subsystem with id: %u\n", subsystem->id); 1837 } 1838 1839 free(ctx); 1840 } 1841 1842 static void 1843 nvmf_ns_change_msg(void *ns_ctx) 1844 { 1845 struct subsystem_ns_change_ctx *ctx = ns_ctx; 1846 int rc; 1847 1848 SPDK_DTRACE_PROBE2(nvmf_ns_change, ctx->nsid, ctx->subsystem->subnqn); 1849 1850 rc = spdk_nvmf_subsystem_pause(ctx->subsystem, ctx->nsid, ctx->cb_fn, ctx); 1851 if (rc) { 1852 if (rc == -EBUSY) { 1853 /* Try again, this is not a permanent situation. */ 1854 spdk_thread_send_msg(spdk_get_thread(), nvmf_ns_change_msg, ctx); 1855 } else { 1856 free(ctx); 1857 SPDK_ERRLOG("Unable to pause subsystem to process namespace removal!\n"); 1858 } 1859 } 1860 } 1861 1862 static void 1863 nvmf_ns_hot_remove(void *remove_ctx) 1864 { 1865 struct spdk_nvmf_ns *ns = remove_ctx; 1866 struct subsystem_ns_change_ctx *ns_ctx; 1867 int rc; 1868 1869 /* We have to allocate a new context because this op 1870 * is asynchronous and we could lose the ns in the middle. 1871 */ 1872 ns_ctx = calloc(1, sizeof(struct subsystem_ns_change_ctx)); 1873 if (!ns_ctx) { 1874 SPDK_ERRLOG("Unable to allocate context to process namespace removal!\n"); 1875 return; 1876 } 1877 1878 ns_ctx->subsystem = ns->subsystem; 1879 ns_ctx->nsid = ns->opts.nsid; 1880 ns_ctx->cb_fn = _nvmf_ns_hot_remove; 1881 1882 rc = spdk_nvmf_subsystem_pause(ns->subsystem, ns_ctx->nsid, _nvmf_ns_hot_remove, ns_ctx); 1883 if (rc) { 1884 if (rc == -EBUSY) { 1885 /* Try again, this is not a permanent situation. */ 1886 spdk_thread_send_msg(spdk_get_thread(), nvmf_ns_change_msg, ns_ctx); 1887 } else { 1888 SPDK_ERRLOG("Unable to pause subsystem to process namespace removal!\n"); 1889 free(ns_ctx); 1890 } 1891 } 1892 } 1893 1894 static void 1895 _nvmf_ns_resize(struct spdk_nvmf_subsystem *subsystem, void *cb_arg, int status) 1896 { 1897 struct subsystem_ns_change_ctx *ctx = cb_arg; 1898 1899 nvmf_subsystem_ns_changed(subsystem, ctx->nsid); 1900 if (spdk_nvmf_subsystem_resume(subsystem, NULL, NULL) != 0) { 1901 SPDK_ERRLOG("Failed to resume NVME-oF subsystem with id: %u\n", subsystem->id); 1902 } 1903 1904 free(ctx); 1905 } 1906 1907 static void 1908 nvmf_ns_resize(void *event_ctx) 1909 { 1910 struct spdk_nvmf_ns *ns = event_ctx; 1911 struct subsystem_ns_change_ctx *ns_ctx; 1912 int rc; 1913 1914 /* We have to allocate a new context because this op 1915 * is asynchronous and we could lose the ns in the middle. 1916 */ 1917 ns_ctx = calloc(1, sizeof(struct subsystem_ns_change_ctx)); 1918 if (!ns_ctx) { 1919 SPDK_ERRLOG("Unable to allocate context to process namespace removal!\n"); 1920 return; 1921 } 1922 1923 ns_ctx->subsystem = ns->subsystem; 1924 ns_ctx->nsid = ns->opts.nsid; 1925 ns_ctx->cb_fn = _nvmf_ns_resize; 1926 1927 /* Specify 0 for the nsid here, because we do not need to pause the namespace. 1928 * Namespaces can only be resized bigger, so there is no need to quiesce I/O. 1929 */ 1930 rc = spdk_nvmf_subsystem_pause(ns->subsystem, 0, _nvmf_ns_resize, ns_ctx); 1931 if (rc) { 1932 if (rc == -EBUSY) { 1933 /* Try again, this is not a permanent situation. */ 1934 spdk_thread_send_msg(spdk_get_thread(), nvmf_ns_change_msg, ns_ctx); 1935 } else { 1936 SPDK_ERRLOG("Unable to pause subsystem to process namespace resize!\n"); 1937 free(ns_ctx); 1938 } 1939 } 1940 } 1941 1942 static void 1943 nvmf_ns_event(enum spdk_bdev_event_type type, 1944 struct spdk_bdev *bdev, 1945 void *event_ctx) 1946 { 1947 SPDK_DEBUGLOG(nvmf, "Bdev event: type %d, name %s, subsystem_id %d, ns_id %d\n", 1948 type, 1949 spdk_bdev_get_name(bdev), 1950 ((struct spdk_nvmf_ns *)event_ctx)->subsystem->id, 1951 ((struct spdk_nvmf_ns *)event_ctx)->nsid); 1952 1953 switch (type) { 1954 case SPDK_BDEV_EVENT_REMOVE: 1955 nvmf_ns_hot_remove(event_ctx); 1956 break; 1957 case SPDK_BDEV_EVENT_RESIZE: 1958 nvmf_ns_resize(event_ctx); 1959 break; 1960 default: 1961 SPDK_NOTICELOG("Unsupported bdev event: type %d\n", type); 1962 break; 1963 } 1964 } 1965 1966 void 1967 spdk_nvmf_ns_opts_get_defaults(struct spdk_nvmf_ns_opts *opts, size_t opts_size) 1968 { 1969 if (!opts) { 1970 SPDK_ERRLOG("opts should not be NULL.\n"); 1971 return; 1972 } 1973 1974 if (!opts_size) { 1975 SPDK_ERRLOG("opts_size should not be zero.\n"); 1976 return; 1977 } 1978 1979 memset(opts, 0, opts_size); 1980 opts->opts_size = opts_size; 1981 1982 #define FIELD_OK(field) \ 1983 offsetof(struct spdk_nvmf_ns_opts, field) + sizeof(opts->field) <= opts_size 1984 1985 #define SET_FIELD(field, value) \ 1986 if (FIELD_OK(field)) { \ 1987 opts->field = value; \ 1988 } \ 1989 1990 /* All current fields are set to 0 by default. */ 1991 SET_FIELD(nsid, 0); 1992 if (FIELD_OK(nguid)) { 1993 memset(opts->nguid, 0, sizeof(opts->nguid)); 1994 } 1995 if (FIELD_OK(eui64)) { 1996 memset(opts->eui64, 0, sizeof(opts->eui64)); 1997 } 1998 if (FIELD_OK(uuid)) { 1999 spdk_uuid_set_null(&opts->uuid); 2000 } 2001 SET_FIELD(anagrpid, 0); 2002 SET_FIELD(transport_specific, NULL); 2003 2004 #undef FIELD_OK 2005 #undef SET_FIELD 2006 } 2007 2008 static void 2009 nvmf_ns_opts_copy(struct spdk_nvmf_ns_opts *opts, 2010 const struct spdk_nvmf_ns_opts *user_opts, 2011 size_t opts_size) 2012 { 2013 #define FIELD_OK(field) \ 2014 offsetof(struct spdk_nvmf_ns_opts, field) + sizeof(opts->field) <= user_opts->opts_size 2015 2016 #define SET_FIELD(field) \ 2017 if (FIELD_OK(field)) { \ 2018 opts->field = user_opts->field; \ 2019 } \ 2020 2021 SET_FIELD(nsid); 2022 if (FIELD_OK(nguid)) { 2023 memcpy(opts->nguid, user_opts->nguid, sizeof(opts->nguid)); 2024 } 2025 if (FIELD_OK(eui64)) { 2026 memcpy(opts->eui64, user_opts->eui64, sizeof(opts->eui64)); 2027 } 2028 if (FIELD_OK(uuid)) { 2029 spdk_uuid_copy(&opts->uuid, &user_opts->uuid); 2030 } 2031 SET_FIELD(anagrpid); 2032 SET_FIELD(no_auto_visible); 2033 SET_FIELD(transport_specific); 2034 2035 opts->opts_size = user_opts->opts_size; 2036 2037 /* We should not remove this statement, but need to update the assert statement 2038 * if we add a new field, and also add a corresponding SET_FIELD statement. 2039 */ 2040 SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_ns_opts) == 72, "Incorrect size"); 2041 2042 #undef FIELD_OK 2043 #undef SET_FIELD 2044 } 2045 2046 /* Dummy bdev module used to to claim bdevs. */ 2047 static struct spdk_bdev_module ns_bdev_module = { 2048 .name = "NVMe-oF Target", 2049 }; 2050 2051 static int nvmf_ns_reservation_update(const struct spdk_nvmf_ns *ns, 2052 const struct spdk_nvmf_reservation_info *info); 2053 static int nvmf_ns_reservation_load(const struct spdk_nvmf_ns *ns, 2054 struct spdk_nvmf_reservation_info *info); 2055 static int nvmf_ns_reservation_restore(struct spdk_nvmf_ns *ns, 2056 struct spdk_nvmf_reservation_info *info); 2057 2058 bool 2059 nvmf_subsystem_zone_append_supported(struct spdk_nvmf_subsystem *subsystem) 2060 { 2061 struct spdk_nvmf_ns *ns; 2062 2063 for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); 2064 ns != NULL; 2065 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) { 2066 if (spdk_bdev_is_zoned(ns->bdev) && 2067 spdk_bdev_io_type_supported(ns->bdev, SPDK_BDEV_IO_TYPE_ZONE_APPEND)) { 2068 return true; 2069 } 2070 } 2071 2072 return false; 2073 } 2074 2075 uint32_t 2076 spdk_nvmf_subsystem_add_ns_ext(struct spdk_nvmf_subsystem *subsystem, const char *bdev_name, 2077 const struct spdk_nvmf_ns_opts *user_opts, size_t opts_size, 2078 const char *ptpl_file) 2079 { 2080 struct spdk_nvmf_transport *transport; 2081 struct spdk_nvmf_ns_opts opts; 2082 struct spdk_nvmf_ns *ns, *first_ns; 2083 struct spdk_nvmf_ctrlr *ctrlr; 2084 struct spdk_nvmf_reservation_info info = {0}; 2085 struct spdk_nvme_ns *nvme_ns; 2086 int rc; 2087 bool zone_append_supported; 2088 uint64_t max_zone_append_size_kib; 2089 2090 if (!(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 2091 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED)) { 2092 return 0; 2093 } 2094 2095 spdk_nvmf_ns_opts_get_defaults(&opts, sizeof(opts)); 2096 if (user_opts) { 2097 nvmf_ns_opts_copy(&opts, user_opts, opts_size); 2098 } 2099 2100 if (opts.nsid == SPDK_NVME_GLOBAL_NS_TAG) { 2101 SPDK_ERRLOG("Invalid NSID %" PRIu32 "\n", opts.nsid); 2102 return 0; 2103 } 2104 2105 if (opts.nsid == 0) { 2106 /* 2107 * NSID not specified - find a free index. 2108 * 2109 * If no free slots are found, return error. 2110 */ 2111 for (opts.nsid = 1; opts.nsid <= subsystem->max_nsid; opts.nsid++) { 2112 if (_nvmf_subsystem_get_ns(subsystem, opts.nsid) == NULL) { 2113 break; 2114 } 2115 } 2116 if (opts.nsid > subsystem->max_nsid) { 2117 SPDK_ERRLOG("No free namespace slot available in the subsystem\n"); 2118 return 0; 2119 } 2120 } 2121 2122 if (opts.nsid > subsystem->max_nsid) { 2123 SPDK_ERRLOG("NSID greater than maximum not allowed\n"); 2124 return 0; 2125 } 2126 2127 if (_nvmf_subsystem_get_ns(subsystem, opts.nsid)) { 2128 SPDK_ERRLOG("Requested NSID %" PRIu32 " already in use\n", opts.nsid); 2129 return 0; 2130 } 2131 2132 if (opts.anagrpid == 0) { 2133 opts.anagrpid = opts.nsid; 2134 } 2135 2136 if (opts.anagrpid > subsystem->max_nsid) { 2137 SPDK_ERRLOG("ANAGRPID greater than maximum NSID not allowed\n"); 2138 return 0; 2139 } 2140 2141 ns = calloc(1, sizeof(*ns)); 2142 if (ns == NULL) { 2143 SPDK_ERRLOG("Namespace allocation failed\n"); 2144 return 0; 2145 } 2146 2147 TAILQ_INIT(&ns->hosts); 2148 ns->always_visible = !opts.no_auto_visible; 2149 if (ns->always_visible) { 2150 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 2151 spdk_bit_array_set(ctrlr->visible_ns, opts.nsid - 1); 2152 } 2153 } 2154 2155 rc = spdk_bdev_open_ext(bdev_name, true, nvmf_ns_event, ns, &ns->desc); 2156 if (rc != 0) { 2157 SPDK_ERRLOG("Subsystem %s: bdev %s cannot be opened, error=%d\n", 2158 subsystem->subnqn, bdev_name, rc); 2159 free(ns); 2160 return 0; 2161 } 2162 2163 ns->bdev = spdk_bdev_desc_get_bdev(ns->desc); 2164 2165 if (spdk_bdev_get_md_size(ns->bdev) != 0) { 2166 if (!spdk_bdev_is_md_interleaved(ns->bdev)) { 2167 SPDK_ERRLOG("Can't attach bdev with separate metadata.\n"); 2168 spdk_bdev_close(ns->desc); 2169 free(ns); 2170 return 0; 2171 } 2172 2173 if (spdk_bdev_get_md_size(ns->bdev) > SPDK_BDEV_MAX_INTERLEAVED_MD_SIZE) { 2174 SPDK_ERRLOG("Maximum supported interleaved md size %u, current md size %u\n", 2175 SPDK_BDEV_MAX_INTERLEAVED_MD_SIZE, spdk_bdev_get_md_size(ns->bdev)); 2176 spdk_bdev_close(ns->desc); 2177 free(ns); 2178 return 0; 2179 } 2180 } 2181 2182 rc = spdk_bdev_module_claim_bdev(ns->bdev, ns->desc, &ns_bdev_module); 2183 if (rc != 0) { 2184 spdk_bdev_close(ns->desc); 2185 free(ns); 2186 return 0; 2187 } 2188 2189 if (!strncmp(spdk_bdev_get_module_name(ns->bdev), "nvme", 2190 strlen(spdk_bdev_get_module_name(ns->bdev)))) { 2191 nvme_ns = (struct spdk_nvme_ns *) spdk_bdev_get_module_ctx(ns->desc); 2192 ns->passthrough_nsid = spdk_nvme_ns_get_id(nvme_ns); 2193 } else if (subsystem->passthrough) { 2194 SPDK_ERRLOG("Only bdev_nvme namespaces can be added to a passthrough subsystem.\n"); 2195 goto err; 2196 } 2197 2198 /* Cache the zcopy capability of the bdev device */ 2199 ns->zcopy = spdk_bdev_io_type_supported(ns->bdev, SPDK_BDEV_IO_TYPE_ZCOPY); 2200 2201 if (spdk_uuid_is_null(&opts.uuid)) { 2202 opts.uuid = *spdk_bdev_get_uuid(ns->bdev); 2203 } 2204 2205 /* if nguid descriptor is supported by bdev module (nvme) then uuid = nguid */ 2206 if (spdk_mem_all_zero(opts.nguid, sizeof(opts.nguid))) { 2207 SPDK_STATIC_ASSERT(sizeof(opts.nguid) == sizeof(opts.uuid), "size mismatch"); 2208 memcpy(opts.nguid, spdk_bdev_get_uuid(ns->bdev), sizeof(opts.nguid)); 2209 } 2210 2211 if (spdk_bdev_is_zoned(ns->bdev)) { 2212 SPDK_DEBUGLOG(nvmf, "The added namespace is backed by a zoned block device.\n"); 2213 ns->csi = SPDK_NVME_CSI_ZNS; 2214 2215 zone_append_supported = spdk_bdev_io_type_supported(ns->bdev, 2216 SPDK_BDEV_IO_TYPE_ZONE_APPEND); 2217 max_zone_append_size_kib = spdk_bdev_get_max_zone_append_size( 2218 ns->bdev) * spdk_bdev_get_block_size(ns->bdev); 2219 2220 if (_nvmf_subsystem_get_first_zoned_ns(subsystem) != NULL && 2221 (nvmf_subsystem_zone_append_supported(subsystem) != zone_append_supported || 2222 subsystem->max_zone_append_size_kib != max_zone_append_size_kib)) { 2223 SPDK_ERRLOG("Namespaces with different zone append support or different zone append size are not allowed.\n"); 2224 goto err; 2225 } 2226 2227 subsystem->max_zone_append_size_kib = max_zone_append_size_kib; 2228 } 2229 2230 first_ns = spdk_nvmf_subsystem_get_first_ns(subsystem); 2231 if (!first_ns) { 2232 if (spdk_bdev_get_nvme_ctratt(ns->bdev).bits.fdps) { 2233 SPDK_DEBUGLOG(nvmf, "Subsystem with id: %u has FDP capability.\n", 2234 subsystem->id); 2235 subsystem->fdp_supported = true; 2236 } 2237 } else { 2238 if (spdk_bdev_get_nvme_ctratt(first_ns->bdev).bits.fdps != 2239 spdk_bdev_get_nvme_ctratt(ns->bdev).bits.fdps) { 2240 SPDK_ERRLOG("Subsystem with id: %u can%s FDP namespace.\n", subsystem->id, 2241 spdk_bdev_get_nvme_ctratt(first_ns->bdev).bits.fdps ? " only add" : "not add"); 2242 goto err; 2243 } 2244 } 2245 2246 ns->opts = opts; 2247 ns->subsystem = subsystem; 2248 subsystem->ns[opts.nsid - 1] = ns; 2249 ns->nsid = opts.nsid; 2250 ns->anagrpid = opts.anagrpid; 2251 subsystem->ana_group[ns->anagrpid - 1]++; 2252 TAILQ_INIT(&ns->registrants); 2253 if (ptpl_file) { 2254 ns->ptpl_file = strdup(ptpl_file); 2255 if (!ns->ptpl_file) { 2256 SPDK_ERRLOG("Namespace ns->ptpl_file allocation failed\n"); 2257 goto err; 2258 } 2259 } 2260 2261 if (nvmf_ns_is_ptpl_capable(ns)) { 2262 rc = nvmf_ns_reservation_load(ns, &info); 2263 if (rc) { 2264 SPDK_ERRLOG("Subsystem load reservation failed\n"); 2265 goto err; 2266 } 2267 2268 rc = nvmf_ns_reservation_restore(ns, &info); 2269 if (rc) { 2270 SPDK_ERRLOG("Subsystem restore reservation failed\n"); 2271 goto err; 2272 } 2273 } 2274 2275 for (transport = spdk_nvmf_transport_get_first(subsystem->tgt); transport; 2276 transport = spdk_nvmf_transport_get_next(transport)) { 2277 if (transport->ops->subsystem_add_ns) { 2278 rc = transport->ops->subsystem_add_ns(transport, subsystem, ns); 2279 if (rc) { 2280 SPDK_ERRLOG("Namespace attachment is not allowed by %s transport\n", transport->ops->name); 2281 nvmf_ns_reservation_clear_all_registrants(ns); 2282 goto err; 2283 } 2284 } 2285 } 2286 2287 /* JSON value obj is freed before sending the response. Set NULL to prevent usage of dangling pointer. */ 2288 ns->opts.transport_specific = NULL; 2289 2290 SPDK_DEBUGLOG(nvmf, "Subsystem %s: bdev %s assigned nsid %" PRIu32 "\n", 2291 spdk_nvmf_subsystem_get_nqn(subsystem), 2292 bdev_name, 2293 opts.nsid); 2294 2295 nvmf_subsystem_ns_changed(subsystem, opts.nsid); 2296 2297 SPDK_DTRACE_PROBE2(nvmf_subsystem_add_ns, subsystem->subnqn, ns->nsid); 2298 2299 return opts.nsid; 2300 err: 2301 subsystem->ns[opts.nsid - 1] = NULL; 2302 spdk_bdev_module_release_bdev(ns->bdev); 2303 spdk_bdev_close(ns->desc); 2304 free(ns->ptpl_file); 2305 free(ns); 2306 2307 return 0; 2308 } 2309 2310 static uint32_t 2311 nvmf_subsystem_get_next_allocated_nsid(struct spdk_nvmf_subsystem *subsystem, 2312 uint32_t prev_nsid) 2313 { 2314 uint32_t nsid; 2315 2316 if (prev_nsid >= subsystem->max_nsid) { 2317 return 0; 2318 } 2319 2320 for (nsid = prev_nsid + 1; nsid <= subsystem->max_nsid; nsid++) { 2321 if (subsystem->ns[nsid - 1]) { 2322 return nsid; 2323 } 2324 } 2325 2326 return 0; 2327 } 2328 2329 struct spdk_nvmf_ns * 2330 spdk_nvmf_subsystem_get_first_ns(struct spdk_nvmf_subsystem *subsystem) 2331 { 2332 uint32_t first_nsid; 2333 2334 first_nsid = nvmf_subsystem_get_next_allocated_nsid(subsystem, 0); 2335 return _nvmf_subsystem_get_ns(subsystem, first_nsid); 2336 } 2337 2338 struct spdk_nvmf_ns * 2339 spdk_nvmf_subsystem_get_next_ns(struct spdk_nvmf_subsystem *subsystem, 2340 struct spdk_nvmf_ns *prev_ns) 2341 { 2342 uint32_t next_nsid; 2343 2344 next_nsid = nvmf_subsystem_get_next_allocated_nsid(subsystem, prev_ns->opts.nsid); 2345 return _nvmf_subsystem_get_ns(subsystem, next_nsid); 2346 } 2347 2348 struct spdk_nvmf_ns * 2349 spdk_nvmf_subsystem_get_ns(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid) 2350 { 2351 return _nvmf_subsystem_get_ns(subsystem, nsid); 2352 } 2353 2354 uint32_t 2355 spdk_nvmf_ns_get_id(const struct spdk_nvmf_ns *ns) 2356 { 2357 return ns->opts.nsid; 2358 } 2359 2360 struct spdk_bdev * 2361 spdk_nvmf_ns_get_bdev(struct spdk_nvmf_ns *ns) 2362 { 2363 return ns->bdev; 2364 } 2365 2366 void 2367 spdk_nvmf_ns_get_opts(const struct spdk_nvmf_ns *ns, struct spdk_nvmf_ns_opts *opts, 2368 size_t opts_size) 2369 { 2370 memset(opts, 0, opts_size); 2371 memcpy(opts, &ns->opts, spdk_min(sizeof(ns->opts), opts_size)); 2372 } 2373 2374 const char * 2375 spdk_nvmf_subsystem_get_sn(const struct spdk_nvmf_subsystem *subsystem) 2376 { 2377 return subsystem->sn; 2378 } 2379 2380 int 2381 spdk_nvmf_subsystem_set_sn(struct spdk_nvmf_subsystem *subsystem, const char *sn) 2382 { 2383 size_t len, max_len; 2384 2385 max_len = sizeof(subsystem->sn) - 1; 2386 len = strlen(sn); 2387 if (len > max_len) { 2388 SPDK_DEBUGLOG(nvmf, "Invalid sn \"%s\": length %zu > max %zu\n", 2389 sn, len, max_len); 2390 return -1; 2391 } 2392 2393 if (!nvmf_valid_ascii_string(sn, len)) { 2394 SPDK_DEBUGLOG(nvmf, "Non-ASCII sn\n"); 2395 SPDK_LOGDUMP(nvmf, "sn", sn, len); 2396 return -1; 2397 } 2398 2399 snprintf(subsystem->sn, sizeof(subsystem->sn), "%s", sn); 2400 2401 return 0; 2402 } 2403 2404 const char * 2405 spdk_nvmf_subsystem_get_mn(const struct spdk_nvmf_subsystem *subsystem) 2406 { 2407 return subsystem->mn; 2408 } 2409 2410 int 2411 spdk_nvmf_subsystem_set_mn(struct spdk_nvmf_subsystem *subsystem, const char *mn) 2412 { 2413 size_t len, max_len; 2414 2415 if (mn == NULL) { 2416 mn = MODEL_NUMBER_DEFAULT; 2417 } 2418 max_len = sizeof(subsystem->mn) - 1; 2419 len = strlen(mn); 2420 if (len > max_len) { 2421 SPDK_DEBUGLOG(nvmf, "Invalid mn \"%s\": length %zu > max %zu\n", 2422 mn, len, max_len); 2423 return -1; 2424 } 2425 2426 if (!nvmf_valid_ascii_string(mn, len)) { 2427 SPDK_DEBUGLOG(nvmf, "Non-ASCII mn\n"); 2428 SPDK_LOGDUMP(nvmf, "mn", mn, len); 2429 return -1; 2430 } 2431 2432 snprintf(subsystem->mn, sizeof(subsystem->mn), "%s", mn); 2433 2434 return 0; 2435 } 2436 2437 const char * 2438 spdk_nvmf_subsystem_get_nqn(const struct spdk_nvmf_subsystem *subsystem) 2439 { 2440 return subsystem->subnqn; 2441 } 2442 2443 /* We have to use the typedef in the function declaration to appease astyle. */ 2444 typedef enum spdk_nvmf_subtype spdk_nvmf_subtype_t; 2445 2446 spdk_nvmf_subtype_t 2447 spdk_nvmf_subsystem_get_type(struct spdk_nvmf_subsystem *subsystem) 2448 { 2449 return subsystem->subtype; 2450 } 2451 2452 uint32_t 2453 spdk_nvmf_subsystem_get_max_nsid(struct spdk_nvmf_subsystem *subsystem) 2454 { 2455 return subsystem->max_nsid; 2456 } 2457 2458 int 2459 spdk_nvmf_subsystem_set_cntlid_range(struct spdk_nvmf_subsystem *subsystem, 2460 uint16_t min_cntlid, uint16_t max_cntlid) 2461 { 2462 if (subsystem->state != SPDK_NVMF_SUBSYSTEM_INACTIVE) { 2463 return -EAGAIN; 2464 } 2465 2466 if (min_cntlid > max_cntlid) { 2467 return -EINVAL; 2468 } 2469 /* The spec reserves cntlid values in the range FFF0h to FFFFh. */ 2470 if (min_cntlid < NVMF_MIN_CNTLID || min_cntlid > NVMF_MAX_CNTLID || 2471 max_cntlid < NVMF_MIN_CNTLID || max_cntlid > NVMF_MAX_CNTLID) { 2472 return -EINVAL; 2473 } 2474 subsystem->min_cntlid = min_cntlid; 2475 subsystem->max_cntlid = max_cntlid; 2476 if (subsystem->next_cntlid < min_cntlid || subsystem->next_cntlid > max_cntlid - 1) { 2477 subsystem->next_cntlid = min_cntlid - 1; 2478 } 2479 2480 return 0; 2481 } 2482 2483 uint16_t 2484 nvmf_subsystem_gen_cntlid(struct spdk_nvmf_subsystem *subsystem) 2485 { 2486 int count; 2487 2488 /* 2489 * In the worst case, we might have to try all CNTLID values between min_cntlid and max_cntlid 2490 * before we find one that is unused (or find that all values are in use). 2491 */ 2492 for (count = 0; count < subsystem->max_cntlid - subsystem->min_cntlid + 1; count++) { 2493 subsystem->next_cntlid++; 2494 if (subsystem->next_cntlid > subsystem->max_cntlid) { 2495 subsystem->next_cntlid = subsystem->min_cntlid; 2496 } 2497 2498 /* Check if a controller with this cntlid currently exists. */ 2499 if (nvmf_subsystem_get_ctrlr(subsystem, subsystem->next_cntlid) == NULL) { 2500 /* Found unused cntlid */ 2501 return subsystem->next_cntlid; 2502 } 2503 } 2504 2505 /* All valid cntlid values are in use. */ 2506 return 0xFFFF; 2507 } 2508 2509 int 2510 nvmf_subsystem_add_ctrlr(struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr) 2511 { 2512 2513 if (ctrlr->dynamic_ctrlr) { 2514 ctrlr->cntlid = nvmf_subsystem_gen_cntlid(subsystem); 2515 if (ctrlr->cntlid == 0xFFFF) { 2516 /* Unable to get a cntlid */ 2517 SPDK_ERRLOG("Reached max simultaneous ctrlrs\n"); 2518 return -EBUSY; 2519 } 2520 } else if (nvmf_subsystem_get_ctrlr(subsystem, ctrlr->cntlid) != NULL) { 2521 SPDK_ERRLOG("Ctrlr with cntlid %u already exist\n", ctrlr->cntlid); 2522 return -EEXIST; 2523 } 2524 2525 TAILQ_INSERT_TAIL(&subsystem->ctrlrs, ctrlr, link); 2526 2527 SPDK_DTRACE_PROBE3(nvmf_subsystem_add_ctrlr, subsystem->subnqn, ctrlr, ctrlr->hostnqn); 2528 2529 return 0; 2530 } 2531 2532 void 2533 nvmf_subsystem_remove_ctrlr(struct spdk_nvmf_subsystem *subsystem, 2534 struct spdk_nvmf_ctrlr *ctrlr) 2535 { 2536 SPDK_DTRACE_PROBE3(nvmf_subsystem_remove_ctrlr, subsystem->subnqn, ctrlr, ctrlr->hostnqn); 2537 2538 assert(spdk_get_thread() == subsystem->thread); 2539 assert(subsystem == ctrlr->subsys); 2540 SPDK_DEBUGLOG(nvmf, "remove ctrlr %p id 0x%x from subsys %p %s\n", ctrlr, ctrlr->cntlid, subsystem, 2541 subsystem->subnqn); 2542 TAILQ_REMOVE(&subsystem->ctrlrs, ctrlr, link); 2543 } 2544 2545 struct spdk_nvmf_ctrlr * 2546 nvmf_subsystem_get_ctrlr(struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid) 2547 { 2548 struct spdk_nvmf_ctrlr *ctrlr; 2549 2550 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 2551 if (ctrlr->cntlid == cntlid) { 2552 return ctrlr; 2553 } 2554 } 2555 2556 return NULL; 2557 } 2558 2559 uint32_t 2560 spdk_nvmf_subsystem_get_max_namespaces(const struct spdk_nvmf_subsystem *subsystem) 2561 { 2562 return subsystem->max_nsid; 2563 } 2564 2565 uint16_t 2566 spdk_nvmf_subsystem_get_min_cntlid(const struct spdk_nvmf_subsystem *subsystem) 2567 { 2568 return subsystem->min_cntlid; 2569 } 2570 2571 uint16_t 2572 spdk_nvmf_subsystem_get_max_cntlid(const struct spdk_nvmf_subsystem *subsystem) 2573 { 2574 return subsystem->max_cntlid; 2575 } 2576 2577 struct _nvmf_ns_registrant { 2578 uint64_t rkey; 2579 char *host_uuid; 2580 }; 2581 2582 struct _nvmf_ns_registrants { 2583 size_t num_regs; 2584 struct _nvmf_ns_registrant reg[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 2585 }; 2586 2587 struct _nvmf_ns_reservation { 2588 bool ptpl_activated; 2589 enum spdk_nvme_reservation_type rtype; 2590 uint64_t crkey; 2591 char *bdev_uuid; 2592 char *holder_uuid; 2593 struct _nvmf_ns_registrants regs; 2594 }; 2595 2596 static const struct spdk_json_object_decoder nvmf_ns_pr_reg_decoders[] = { 2597 {"rkey", offsetof(struct _nvmf_ns_registrant, rkey), spdk_json_decode_uint64}, 2598 {"host_uuid", offsetof(struct _nvmf_ns_registrant, host_uuid), spdk_json_decode_string}, 2599 }; 2600 2601 static int 2602 nvmf_decode_ns_pr_reg(const struct spdk_json_val *val, void *out) 2603 { 2604 struct _nvmf_ns_registrant *reg = out; 2605 2606 return spdk_json_decode_object(val, nvmf_ns_pr_reg_decoders, 2607 SPDK_COUNTOF(nvmf_ns_pr_reg_decoders), reg); 2608 } 2609 2610 static int 2611 nvmf_decode_ns_pr_regs(const struct spdk_json_val *val, void *out) 2612 { 2613 struct _nvmf_ns_registrants *regs = out; 2614 2615 return spdk_json_decode_array(val, nvmf_decode_ns_pr_reg, regs->reg, 2616 SPDK_NVMF_MAX_NUM_REGISTRANTS, ®s->num_regs, 2617 sizeof(struct _nvmf_ns_registrant)); 2618 } 2619 2620 static const struct spdk_json_object_decoder nvmf_ns_pr_decoders[] = { 2621 {"ptpl", offsetof(struct _nvmf_ns_reservation, ptpl_activated), spdk_json_decode_bool, true}, 2622 {"rtype", offsetof(struct _nvmf_ns_reservation, rtype), spdk_json_decode_uint32, true}, 2623 {"crkey", offsetof(struct _nvmf_ns_reservation, crkey), spdk_json_decode_uint64, true}, 2624 {"bdev_uuid", offsetof(struct _nvmf_ns_reservation, bdev_uuid), spdk_json_decode_string}, 2625 {"holder_uuid", offsetof(struct _nvmf_ns_reservation, holder_uuid), spdk_json_decode_string, true}, 2626 {"registrants", offsetof(struct _nvmf_ns_reservation, regs), nvmf_decode_ns_pr_regs}, 2627 }; 2628 2629 static int 2630 nvmf_ns_reservation_load_json(const struct spdk_nvmf_ns *ns, 2631 struct spdk_nvmf_reservation_info *info) 2632 { 2633 size_t json_size; 2634 ssize_t values_cnt, rc; 2635 void *json = NULL, *end; 2636 struct spdk_json_val *values = NULL; 2637 struct _nvmf_ns_reservation res = {}; 2638 const char *file = ns->ptpl_file; 2639 uint32_t i; 2640 2641 /* It's not an error if the file does not exist */ 2642 if (access(file, F_OK) != 0) { 2643 SPDK_DEBUGLOG(nvmf, "File %s does not exist\n", file); 2644 return 0; 2645 } 2646 2647 /* Load all persist file contents into a local buffer */ 2648 json = spdk_posix_file_load_from_name(file, &json_size); 2649 if (!json) { 2650 SPDK_ERRLOG("Load persist file %s failed\n", file); 2651 return -ENOMEM; 2652 } 2653 2654 rc = spdk_json_parse(json, json_size, NULL, 0, &end, 0); 2655 if (rc < 0) { 2656 SPDK_NOTICELOG("Parsing JSON configuration failed (%zd)\n", rc); 2657 goto exit; 2658 } 2659 2660 values_cnt = rc; 2661 values = calloc(values_cnt, sizeof(struct spdk_json_val)); 2662 if (values == NULL) { 2663 goto exit; 2664 } 2665 2666 rc = spdk_json_parse(json, json_size, values, values_cnt, &end, 0); 2667 if (rc != values_cnt) { 2668 SPDK_ERRLOG("Parsing JSON configuration failed (%zd)\n", rc); 2669 goto exit; 2670 } 2671 2672 /* Decode json */ 2673 if (spdk_json_decode_object(values, nvmf_ns_pr_decoders, 2674 SPDK_COUNTOF(nvmf_ns_pr_decoders), 2675 &res)) { 2676 SPDK_ERRLOG("Invalid objects in the persist file %s\n", file); 2677 rc = -EINVAL; 2678 goto exit; 2679 } 2680 2681 if (res.regs.num_regs > SPDK_NVMF_MAX_NUM_REGISTRANTS) { 2682 SPDK_ERRLOG("Can only support up to %u registrants\n", SPDK_NVMF_MAX_NUM_REGISTRANTS); 2683 rc = -ERANGE; 2684 goto exit; 2685 } 2686 2687 rc = 0; 2688 info->ptpl_activated = res.ptpl_activated; 2689 info->rtype = res.rtype; 2690 info->crkey = res.crkey; 2691 snprintf(info->bdev_uuid, sizeof(info->bdev_uuid), "%s", res.bdev_uuid); 2692 snprintf(info->holder_uuid, sizeof(info->holder_uuid), "%s", res.holder_uuid); 2693 info->num_regs = res.regs.num_regs; 2694 for (i = 0; i < res.regs.num_regs; i++) { 2695 info->registrants[i].rkey = res.regs.reg[i].rkey; 2696 snprintf(info->registrants[i].host_uuid, sizeof(info->registrants[i].host_uuid), "%s", 2697 res.regs.reg[i].host_uuid); 2698 } 2699 2700 exit: 2701 free(json); 2702 free(values); 2703 free(res.bdev_uuid); 2704 free(res.holder_uuid); 2705 for (i = 0; i < res.regs.num_regs; i++) { 2706 free(res.regs.reg[i].host_uuid); 2707 } 2708 2709 return rc; 2710 } 2711 2712 static bool nvmf_ns_reservation_all_registrants_type(struct spdk_nvmf_ns *ns); 2713 2714 static int 2715 nvmf_ns_reservation_restore(struct spdk_nvmf_ns *ns, struct spdk_nvmf_reservation_info *info) 2716 { 2717 uint32_t i; 2718 struct spdk_nvmf_registrant *reg, *holder = NULL; 2719 struct spdk_uuid bdev_uuid, holder_uuid; 2720 bool rkey_flag = false; 2721 2722 SPDK_DEBUGLOG(nvmf, "NSID %u, PTPL %u, Number of registrants %u\n", 2723 ns->nsid, info->ptpl_activated, info->num_regs); 2724 2725 /* it's not an error */ 2726 if (!info->ptpl_activated || !info->num_regs) { 2727 return 0; 2728 } 2729 2730 /* Check info->crkey exist or not in info->registrants[i].rkey */ 2731 for (i = 0; i < info->num_regs; i++) { 2732 if (info->crkey == info->registrants[i].rkey) { 2733 rkey_flag = true; 2734 } 2735 } 2736 if (!rkey_flag && info->crkey != 0) { 2737 return -EINVAL; 2738 } 2739 2740 spdk_uuid_parse(&bdev_uuid, info->bdev_uuid); 2741 if (spdk_uuid_compare(&bdev_uuid, spdk_bdev_get_uuid(ns->bdev))) { 2742 SPDK_ERRLOG("Existing bdev UUID is not same with configuration file\n"); 2743 return -EINVAL; 2744 } 2745 2746 ns->crkey = info->crkey; 2747 ns->rtype = info->rtype; 2748 ns->ptpl_activated = info->ptpl_activated; 2749 spdk_uuid_parse(&holder_uuid, info->holder_uuid); 2750 2751 SPDK_DEBUGLOG(nvmf, "Bdev UUID %s\n", info->bdev_uuid); 2752 if (info->rtype) { 2753 SPDK_DEBUGLOG(nvmf, "Holder UUID %s, RTYPE %u, RKEY 0x%"PRIx64"\n", 2754 info->holder_uuid, info->rtype, info->crkey); 2755 } 2756 2757 for (i = 0; i < info->num_regs; i++) { 2758 reg = calloc(1, sizeof(*reg)); 2759 if (!reg) { 2760 return -ENOMEM; 2761 } 2762 spdk_uuid_parse(®->hostid, info->registrants[i].host_uuid); 2763 reg->rkey = info->registrants[i].rkey; 2764 TAILQ_INSERT_TAIL(&ns->registrants, reg, link); 2765 if (info->crkey != 0 && !spdk_uuid_compare(&holder_uuid, ®->hostid)) { 2766 holder = reg; 2767 } 2768 SPDK_DEBUGLOG(nvmf, "Registrant RKEY 0x%"PRIx64", Host UUID %s\n", 2769 info->registrants[i].rkey, info->registrants[i].host_uuid); 2770 } 2771 2772 if (nvmf_ns_reservation_all_registrants_type(ns)) { 2773 ns->holder = TAILQ_FIRST(&ns->registrants); 2774 } else { 2775 ns->holder = holder; 2776 } 2777 2778 return 0; 2779 } 2780 2781 static int 2782 nvmf_ns_json_write_cb(void *cb_ctx, const void *data, size_t size) 2783 { 2784 char *file = cb_ctx; 2785 size_t rc; 2786 FILE *fd; 2787 2788 fd = fopen(file, "w"); 2789 if (!fd) { 2790 SPDK_ERRLOG("Can't open file %s for write\n", file); 2791 return -ENOENT; 2792 } 2793 rc = fwrite(data, 1, size, fd); 2794 fclose(fd); 2795 2796 return rc == size ? 0 : -1; 2797 } 2798 2799 static int 2800 nvmf_ns_reservation_update_json(const struct spdk_nvmf_ns *ns, 2801 const struct spdk_nvmf_reservation_info *info) 2802 { 2803 const char *file = ns->ptpl_file; 2804 struct spdk_json_write_ctx *w; 2805 uint32_t i; 2806 int rc = 0; 2807 2808 w = spdk_json_write_begin(nvmf_ns_json_write_cb, (void *)file, 0); 2809 if (w == NULL) { 2810 return -ENOMEM; 2811 } 2812 /* clear the configuration file */ 2813 if (!info->ptpl_activated) { 2814 goto exit; 2815 } 2816 2817 spdk_json_write_object_begin(w); 2818 spdk_json_write_named_bool(w, "ptpl", info->ptpl_activated); 2819 spdk_json_write_named_uint32(w, "rtype", info->rtype); 2820 spdk_json_write_named_uint64(w, "crkey", info->crkey); 2821 spdk_json_write_named_string(w, "bdev_uuid", info->bdev_uuid); 2822 spdk_json_write_named_string(w, "holder_uuid", info->holder_uuid); 2823 2824 spdk_json_write_named_array_begin(w, "registrants"); 2825 for (i = 0; i < info->num_regs; i++) { 2826 spdk_json_write_object_begin(w); 2827 spdk_json_write_named_uint64(w, "rkey", info->registrants[i].rkey); 2828 spdk_json_write_named_string(w, "host_uuid", info->registrants[i].host_uuid); 2829 spdk_json_write_object_end(w); 2830 } 2831 spdk_json_write_array_end(w); 2832 spdk_json_write_object_end(w); 2833 2834 exit: 2835 rc = spdk_json_write_end(w); 2836 return rc; 2837 } 2838 2839 static int 2840 nvmf_ns_update_reservation_info(struct spdk_nvmf_ns *ns) 2841 { 2842 struct spdk_nvmf_reservation_info info; 2843 struct spdk_nvmf_registrant *reg, *tmp; 2844 uint32_t i = 0; 2845 2846 assert(ns != NULL); 2847 2848 if (!ns->bdev || !nvmf_ns_is_ptpl_capable(ns)) { 2849 return 0; 2850 } 2851 2852 memset(&info, 0, sizeof(info)); 2853 spdk_uuid_fmt_lower(info.bdev_uuid, sizeof(info.bdev_uuid), spdk_bdev_get_uuid(ns->bdev)); 2854 2855 if (ns->rtype) { 2856 info.rtype = ns->rtype; 2857 info.crkey = ns->crkey; 2858 if (!nvmf_ns_reservation_all_registrants_type(ns)) { 2859 assert(ns->holder != NULL); 2860 spdk_uuid_fmt_lower(info.holder_uuid, sizeof(info.holder_uuid), &ns->holder->hostid); 2861 } 2862 } 2863 2864 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 2865 spdk_uuid_fmt_lower(info.registrants[i].host_uuid, sizeof(info.registrants[i].host_uuid), 2866 ®->hostid); 2867 info.registrants[i++].rkey = reg->rkey; 2868 } 2869 2870 info.num_regs = i; 2871 info.ptpl_activated = ns->ptpl_activated; 2872 2873 return nvmf_ns_reservation_update(ns, &info); 2874 } 2875 2876 static struct spdk_nvmf_registrant * 2877 nvmf_ns_reservation_get_registrant(struct spdk_nvmf_ns *ns, 2878 struct spdk_uuid *uuid) 2879 { 2880 struct spdk_nvmf_registrant *reg, *tmp; 2881 2882 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 2883 if (!spdk_uuid_compare(®->hostid, uuid)) { 2884 return reg; 2885 } 2886 } 2887 2888 return NULL; 2889 } 2890 2891 /* Generate reservation notice log to registered HostID controllers */ 2892 static void 2893 nvmf_subsystem_gen_ctrlr_notification(struct spdk_nvmf_subsystem *subsystem, 2894 struct spdk_nvmf_ns *ns, 2895 struct spdk_uuid *hostid_list, 2896 uint32_t num_hostid, 2897 enum spdk_nvme_reservation_notification_log_page_type type) 2898 { 2899 struct spdk_nvmf_ctrlr *ctrlr; 2900 uint32_t i; 2901 2902 for (i = 0; i < num_hostid; i++) { 2903 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 2904 if (!spdk_uuid_compare(&ctrlr->hostid, &hostid_list[i])) { 2905 nvmf_ctrlr_reservation_notice_log(ctrlr, ns, type); 2906 } 2907 } 2908 } 2909 } 2910 2911 /* Get all registrants' hostid other than the controller who issued the command */ 2912 static uint32_t 2913 nvmf_ns_reservation_get_all_other_hostid(struct spdk_nvmf_ns *ns, 2914 struct spdk_uuid *hostid_list, 2915 uint32_t max_num_hostid, 2916 struct spdk_uuid *current_hostid) 2917 { 2918 struct spdk_nvmf_registrant *reg, *tmp; 2919 uint32_t num_hostid = 0; 2920 2921 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 2922 if (spdk_uuid_compare(®->hostid, current_hostid)) { 2923 if (num_hostid == max_num_hostid) { 2924 assert(false); 2925 return max_num_hostid; 2926 } 2927 hostid_list[num_hostid++] = reg->hostid; 2928 } 2929 } 2930 2931 return num_hostid; 2932 } 2933 2934 /* Calculate the unregistered HostID list according to list 2935 * prior to execute preempt command and list after executing 2936 * preempt command. 2937 */ 2938 static uint32_t 2939 nvmf_ns_reservation_get_unregistered_hostid(struct spdk_uuid *old_hostid_list, 2940 uint32_t old_num_hostid, 2941 struct spdk_uuid *remaining_hostid_list, 2942 uint32_t remaining_num_hostid) 2943 { 2944 struct spdk_uuid temp_hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 2945 uint32_t i, j, num_hostid = 0; 2946 bool found; 2947 2948 if (!remaining_num_hostid) { 2949 return old_num_hostid; 2950 } 2951 2952 for (i = 0; i < old_num_hostid; i++) { 2953 found = false; 2954 for (j = 0; j < remaining_num_hostid; j++) { 2955 if (!spdk_uuid_compare(&old_hostid_list[i], &remaining_hostid_list[j])) { 2956 found = true; 2957 break; 2958 } 2959 } 2960 if (!found) { 2961 spdk_uuid_copy(&temp_hostid_list[num_hostid++], &old_hostid_list[i]); 2962 } 2963 } 2964 2965 if (num_hostid) { 2966 memcpy(old_hostid_list, temp_hostid_list, sizeof(struct spdk_uuid) * num_hostid); 2967 } 2968 2969 return num_hostid; 2970 } 2971 2972 /* current reservation type is all registrants or not */ 2973 static bool 2974 nvmf_ns_reservation_all_registrants_type(struct spdk_nvmf_ns *ns) 2975 { 2976 return (ns->rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS || 2977 ns->rtype == SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS); 2978 } 2979 2980 /* current registrant is reservation holder or not */ 2981 static bool 2982 nvmf_ns_reservation_registrant_is_holder(struct spdk_nvmf_ns *ns, 2983 struct spdk_nvmf_registrant *reg) 2984 { 2985 if (!reg) { 2986 return false; 2987 } 2988 2989 if (nvmf_ns_reservation_all_registrants_type(ns)) { 2990 return true; 2991 } 2992 2993 return (ns->holder == reg); 2994 } 2995 2996 static int 2997 nvmf_ns_reservation_add_registrant(struct spdk_nvmf_ns *ns, 2998 struct spdk_nvmf_ctrlr *ctrlr, 2999 uint64_t nrkey) 3000 { 3001 struct spdk_nvmf_registrant *reg; 3002 3003 reg = calloc(1, sizeof(*reg)); 3004 if (!reg) { 3005 return -ENOMEM; 3006 } 3007 3008 reg->rkey = nrkey; 3009 /* set hostid for the registrant */ 3010 spdk_uuid_copy(®->hostid, &ctrlr->hostid); 3011 TAILQ_INSERT_TAIL(&ns->registrants, reg, link); 3012 ns->gen++; 3013 3014 return 0; 3015 } 3016 3017 static void 3018 nvmf_ns_reservation_release_reservation(struct spdk_nvmf_ns *ns) 3019 { 3020 ns->rtype = 0; 3021 ns->crkey = 0; 3022 ns->holder = NULL; 3023 } 3024 3025 /* release the reservation if the last registrant was removed */ 3026 static void 3027 nvmf_ns_reservation_check_release_on_remove_registrant(struct spdk_nvmf_ns *ns, 3028 struct spdk_nvmf_registrant *reg) 3029 { 3030 struct spdk_nvmf_registrant *next_reg; 3031 3032 /* no reservation holder */ 3033 if (!ns->holder) { 3034 assert(ns->rtype == 0); 3035 return; 3036 } 3037 3038 next_reg = TAILQ_FIRST(&ns->registrants); 3039 if (next_reg && nvmf_ns_reservation_all_registrants_type(ns)) { 3040 /* the next valid registrant is the new holder now */ 3041 ns->holder = next_reg; 3042 } else if (nvmf_ns_reservation_registrant_is_holder(ns, reg)) { 3043 /* release the reservation */ 3044 nvmf_ns_reservation_release_reservation(ns); 3045 } 3046 } 3047 3048 static void 3049 nvmf_ns_reservation_remove_registrant(struct spdk_nvmf_ns *ns, 3050 struct spdk_nvmf_registrant *reg) 3051 { 3052 TAILQ_REMOVE(&ns->registrants, reg, link); 3053 nvmf_ns_reservation_check_release_on_remove_registrant(ns, reg); 3054 free(reg); 3055 ns->gen++; 3056 return; 3057 } 3058 3059 static uint32_t 3060 nvmf_ns_reservation_remove_registrants_by_key(struct spdk_nvmf_ns *ns, 3061 uint64_t rkey) 3062 { 3063 struct spdk_nvmf_registrant *reg, *tmp; 3064 uint32_t count = 0; 3065 3066 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 3067 if (reg->rkey == rkey) { 3068 nvmf_ns_reservation_remove_registrant(ns, reg); 3069 count++; 3070 } 3071 } 3072 return count; 3073 } 3074 3075 static uint32_t 3076 nvmf_ns_reservation_remove_all_other_registrants(struct spdk_nvmf_ns *ns, 3077 struct spdk_nvmf_registrant *reg) 3078 { 3079 struct spdk_nvmf_registrant *reg_tmp, *reg_tmp2; 3080 uint32_t count = 0; 3081 3082 TAILQ_FOREACH_SAFE(reg_tmp, &ns->registrants, link, reg_tmp2) { 3083 if (reg_tmp != reg) { 3084 nvmf_ns_reservation_remove_registrant(ns, reg_tmp); 3085 count++; 3086 } 3087 } 3088 return count; 3089 } 3090 3091 static uint32_t 3092 nvmf_ns_reservation_clear_all_registrants(struct spdk_nvmf_ns *ns) 3093 { 3094 struct spdk_nvmf_registrant *reg, *reg_tmp; 3095 uint32_t count = 0; 3096 3097 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, reg_tmp) { 3098 nvmf_ns_reservation_remove_registrant(ns, reg); 3099 count++; 3100 } 3101 return count; 3102 } 3103 3104 static void 3105 nvmf_ns_reservation_acquire_reservation(struct spdk_nvmf_ns *ns, uint64_t rkey, 3106 enum spdk_nvme_reservation_type rtype, 3107 struct spdk_nvmf_registrant *holder) 3108 { 3109 ns->rtype = rtype; 3110 ns->crkey = rkey; 3111 assert(ns->holder == NULL); 3112 ns->holder = holder; 3113 } 3114 3115 static bool 3116 nvmf_ns_reservation_register(struct spdk_nvmf_ns *ns, 3117 struct spdk_nvmf_ctrlr *ctrlr, 3118 struct spdk_nvmf_request *req) 3119 { 3120 struct spdk_nvme_reservation_register_data key = { 0 }; 3121 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3122 uint8_t rrega, iekey, cptpl, rtype; 3123 struct spdk_nvmf_registrant *reg; 3124 uint8_t status = SPDK_NVME_SC_SUCCESS; 3125 bool update_sgroup = false; 3126 struct spdk_uuid hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3127 uint32_t num_hostid = 0; 3128 int rc; 3129 3130 rrega = cmd->cdw10_bits.resv_register.rrega; 3131 iekey = cmd->cdw10_bits.resv_register.iekey; 3132 cptpl = cmd->cdw10_bits.resv_register.cptpl; 3133 3134 if (req->iovcnt > 0 && req->length >= sizeof(key)) { 3135 struct spdk_iov_xfer ix; 3136 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3137 spdk_iov_xfer_to_buf(&ix, &key, sizeof(key)); 3138 } else { 3139 SPDK_ERRLOG("No key provided. Failing request.\n"); 3140 status = SPDK_NVME_SC_INVALID_FIELD; 3141 goto exit; 3142 } 3143 3144 SPDK_DEBUGLOG(nvmf, "REGISTER: RREGA %u, IEKEY %u, CPTPL %u, " 3145 "NRKEY 0x%"PRIx64", NRKEY 0x%"PRIx64"\n", 3146 rrega, iekey, cptpl, key.crkey, key.nrkey); 3147 3148 if (cptpl == SPDK_NVME_RESERVE_PTPL_CLEAR_POWER_ON) { 3149 /* True to OFF state, and need to be updated in the configuration file */ 3150 if (ns->ptpl_activated) { 3151 ns->ptpl_activated = 0; 3152 update_sgroup = true; 3153 } 3154 } else if (cptpl == SPDK_NVME_RESERVE_PTPL_PERSIST_POWER_LOSS) { 3155 if (!nvmf_ns_is_ptpl_capable(ns)) { 3156 status = SPDK_NVME_SC_INVALID_FIELD; 3157 goto exit; 3158 } else if (ns->ptpl_activated == 0) { 3159 ns->ptpl_activated = 1; 3160 update_sgroup = true; 3161 } 3162 } 3163 3164 /* current Host Identifier has registrant or not */ 3165 reg = nvmf_ns_reservation_get_registrant(ns, &ctrlr->hostid); 3166 3167 switch (rrega) { 3168 case SPDK_NVME_RESERVE_REGISTER_KEY: 3169 if (!reg) { 3170 /* register new controller */ 3171 if (key.nrkey == 0) { 3172 SPDK_ERRLOG("Can't register zeroed new key\n"); 3173 status = SPDK_NVME_SC_INVALID_FIELD; 3174 goto exit; 3175 } 3176 rc = nvmf_ns_reservation_add_registrant(ns, ctrlr, key.nrkey); 3177 if (rc < 0) { 3178 status = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3179 goto exit; 3180 } 3181 update_sgroup = true; 3182 } else { 3183 /* register with same key is not an error */ 3184 if (reg->rkey != key.nrkey) { 3185 SPDK_ERRLOG("The same host already register a " 3186 "key with 0x%"PRIx64"\n", 3187 reg->rkey); 3188 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3189 goto exit; 3190 } 3191 } 3192 break; 3193 case SPDK_NVME_RESERVE_UNREGISTER_KEY: 3194 if (!reg || (!iekey && reg->rkey != key.crkey)) { 3195 SPDK_ERRLOG("No registrant or current key doesn't match " 3196 "with existing registrant key\n"); 3197 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3198 goto exit; 3199 } 3200 3201 rtype = ns->rtype; 3202 num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, hostid_list, 3203 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3204 &ctrlr->hostid); 3205 3206 nvmf_ns_reservation_remove_registrant(ns, reg); 3207 3208 if (!ns->rtype && num_hostid && (rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY || 3209 rtype == SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY)) { 3210 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3211 hostid_list, 3212 num_hostid, 3213 SPDK_NVME_RESERVATION_RELEASED); 3214 } 3215 update_sgroup = true; 3216 break; 3217 case SPDK_NVME_RESERVE_REPLACE_KEY: 3218 if (key.nrkey == 0) { 3219 SPDK_ERRLOG("Can't register zeroed new key\n"); 3220 status = SPDK_NVME_SC_INVALID_FIELD; 3221 goto exit; 3222 } 3223 /* Registrant exists */ 3224 if (reg) { 3225 if (!iekey && reg->rkey != key.crkey) { 3226 SPDK_ERRLOG("Current key doesn't match " 3227 "existing registrant key\n"); 3228 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3229 goto exit; 3230 } 3231 if (reg->rkey == key.nrkey) { 3232 goto exit; 3233 } 3234 reg->rkey = key.nrkey; 3235 } else if (iekey) { /* No registrant but IEKEY is set */ 3236 /* new registrant */ 3237 rc = nvmf_ns_reservation_add_registrant(ns, ctrlr, key.nrkey); 3238 if (rc < 0) { 3239 status = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3240 goto exit; 3241 } 3242 } else { /* No registrant */ 3243 SPDK_ERRLOG("No registrant\n"); 3244 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3245 goto exit; 3246 3247 } 3248 update_sgroup = true; 3249 break; 3250 default: 3251 status = SPDK_NVME_SC_INVALID_FIELD; 3252 goto exit; 3253 } 3254 3255 exit: 3256 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3257 req->rsp->nvme_cpl.status.sc = status; 3258 return update_sgroup; 3259 } 3260 3261 static bool 3262 nvmf_ns_reservation_acquire(struct spdk_nvmf_ns *ns, 3263 struct spdk_nvmf_ctrlr *ctrlr, 3264 struct spdk_nvmf_request *req) 3265 { 3266 struct spdk_nvme_reservation_acquire_data key = { 0 }; 3267 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3268 uint8_t racqa, iekey, rtype; 3269 struct spdk_nvmf_registrant *reg; 3270 bool all_regs = false; 3271 uint32_t count = 0; 3272 bool update_sgroup = true; 3273 struct spdk_uuid hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3274 uint32_t num_hostid = 0; 3275 struct spdk_uuid new_hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3276 uint32_t new_num_hostid = 0; 3277 bool reservation_released = false; 3278 uint8_t status = SPDK_NVME_SC_SUCCESS; 3279 3280 racqa = cmd->cdw10_bits.resv_acquire.racqa; 3281 iekey = cmd->cdw10_bits.resv_acquire.iekey; 3282 rtype = cmd->cdw10_bits.resv_acquire.rtype; 3283 3284 if (req->iovcnt > 0 && req->length >= sizeof(key)) { 3285 struct spdk_iov_xfer ix; 3286 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3287 spdk_iov_xfer_to_buf(&ix, &key, sizeof(key)); 3288 } else { 3289 SPDK_ERRLOG("No key provided. Failing request.\n"); 3290 status = SPDK_NVME_SC_INVALID_FIELD; 3291 goto exit; 3292 } 3293 3294 SPDK_DEBUGLOG(nvmf, "ACQUIRE: RACQA %u, IEKEY %u, RTYPE %u, " 3295 "NRKEY 0x%"PRIx64", PRKEY 0x%"PRIx64"\n", 3296 racqa, iekey, rtype, key.crkey, key.prkey); 3297 3298 if (iekey || rtype > SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS) { 3299 SPDK_ERRLOG("Ignore existing key field set to 1\n"); 3300 status = SPDK_NVME_SC_INVALID_FIELD; 3301 update_sgroup = false; 3302 goto exit; 3303 } 3304 3305 reg = nvmf_ns_reservation_get_registrant(ns, &ctrlr->hostid); 3306 /* must be registrant and CRKEY must match */ 3307 if (!reg || reg->rkey != key.crkey) { 3308 SPDK_ERRLOG("No registrant or current key doesn't match " 3309 "with existing registrant key\n"); 3310 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3311 update_sgroup = false; 3312 goto exit; 3313 } 3314 3315 all_regs = nvmf_ns_reservation_all_registrants_type(ns); 3316 3317 switch (racqa) { 3318 case SPDK_NVME_RESERVE_ACQUIRE: 3319 /* it's not an error for the holder to acquire same reservation type again */ 3320 if (nvmf_ns_reservation_registrant_is_holder(ns, reg) && ns->rtype == rtype) { 3321 /* do nothing */ 3322 update_sgroup = false; 3323 } else if (ns->holder == NULL) { 3324 /* first time to acquire the reservation */ 3325 nvmf_ns_reservation_acquire_reservation(ns, key.crkey, rtype, reg); 3326 } else { 3327 SPDK_ERRLOG("Invalid rtype or current registrant is not holder\n"); 3328 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3329 update_sgroup = false; 3330 goto exit; 3331 } 3332 break; 3333 case SPDK_NVME_RESERVE_PREEMPT: 3334 /* no reservation holder */ 3335 if (!ns->holder) { 3336 /* unregister with PRKEY */ 3337 nvmf_ns_reservation_remove_registrants_by_key(ns, key.prkey); 3338 break; 3339 } 3340 num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, hostid_list, 3341 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3342 &ctrlr->hostid); 3343 3344 /* only 1 reservation holder and reservation key is valid */ 3345 if (!all_regs) { 3346 /* preempt itself */ 3347 if (nvmf_ns_reservation_registrant_is_holder(ns, reg) && 3348 ns->crkey == key.prkey) { 3349 ns->rtype = rtype; 3350 reservation_released = true; 3351 break; 3352 } 3353 3354 if (ns->crkey == key.prkey) { 3355 nvmf_ns_reservation_remove_registrant(ns, ns->holder); 3356 nvmf_ns_reservation_acquire_reservation(ns, key.crkey, rtype, reg); 3357 reservation_released = true; 3358 } else if (key.prkey != 0) { 3359 nvmf_ns_reservation_remove_registrants_by_key(ns, key.prkey); 3360 } else { 3361 /* PRKEY is zero */ 3362 SPDK_ERRLOG("Current PRKEY is zero\n"); 3363 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3364 update_sgroup = false; 3365 goto exit; 3366 } 3367 } else { 3368 /* release all other registrants except for the current one */ 3369 if (key.prkey == 0) { 3370 nvmf_ns_reservation_remove_all_other_registrants(ns, reg); 3371 assert(ns->holder == reg); 3372 } else { 3373 count = nvmf_ns_reservation_remove_registrants_by_key(ns, key.prkey); 3374 if (count == 0) { 3375 SPDK_ERRLOG("PRKEY doesn't match any registrant\n"); 3376 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3377 update_sgroup = false; 3378 goto exit; 3379 } 3380 } 3381 } 3382 break; 3383 default: 3384 status = SPDK_NVME_SC_INVALID_FIELD; 3385 update_sgroup = false; 3386 break; 3387 } 3388 3389 exit: 3390 if (update_sgroup && racqa == SPDK_NVME_RESERVE_PREEMPT) { 3391 new_num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, new_hostid_list, 3392 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3393 &ctrlr->hostid); 3394 /* Preempt notification occurs on the unregistered controllers 3395 * other than the controller who issued the command. 3396 */ 3397 num_hostid = nvmf_ns_reservation_get_unregistered_hostid(hostid_list, 3398 num_hostid, 3399 new_hostid_list, 3400 new_num_hostid); 3401 if (num_hostid) { 3402 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3403 hostid_list, 3404 num_hostid, 3405 SPDK_NVME_REGISTRATION_PREEMPTED); 3406 3407 } 3408 /* Reservation released notification occurs on the 3409 * controllers which are the remaining registrants other than 3410 * the controller who issued the command. 3411 */ 3412 if (reservation_released && new_num_hostid) { 3413 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3414 new_hostid_list, 3415 new_num_hostid, 3416 SPDK_NVME_RESERVATION_RELEASED); 3417 3418 } 3419 } 3420 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3421 req->rsp->nvme_cpl.status.sc = status; 3422 return update_sgroup; 3423 } 3424 3425 static bool 3426 nvmf_ns_reservation_release(struct spdk_nvmf_ns *ns, 3427 struct spdk_nvmf_ctrlr *ctrlr, 3428 struct spdk_nvmf_request *req) 3429 { 3430 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3431 uint8_t rrela, iekey, rtype; 3432 struct spdk_nvmf_registrant *reg; 3433 uint64_t crkey = 0; 3434 uint8_t status = SPDK_NVME_SC_SUCCESS; 3435 bool update_sgroup = true; 3436 struct spdk_uuid hostid_list[SPDK_NVMF_MAX_NUM_REGISTRANTS]; 3437 uint32_t num_hostid = 0; 3438 3439 rrela = cmd->cdw10_bits.resv_release.rrela; 3440 iekey = cmd->cdw10_bits.resv_release.iekey; 3441 rtype = cmd->cdw10_bits.resv_release.rtype; 3442 3443 if (req->iovcnt > 0 && req->length >= sizeof(crkey)) { 3444 struct spdk_iov_xfer ix; 3445 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3446 spdk_iov_xfer_to_buf(&ix, &crkey, sizeof(crkey)); 3447 } else { 3448 SPDK_ERRLOG("No key provided. Failing request.\n"); 3449 status = SPDK_NVME_SC_INVALID_FIELD; 3450 goto exit; 3451 } 3452 3453 SPDK_DEBUGLOG(nvmf, "RELEASE: RRELA %u, IEKEY %u, RTYPE %u, " 3454 "CRKEY 0x%"PRIx64"\n", rrela, iekey, rtype, crkey); 3455 3456 if (iekey) { 3457 SPDK_ERRLOG("Ignore existing key field set to 1\n"); 3458 status = SPDK_NVME_SC_INVALID_FIELD; 3459 update_sgroup = false; 3460 goto exit; 3461 } 3462 3463 reg = nvmf_ns_reservation_get_registrant(ns, &ctrlr->hostid); 3464 if (!reg || reg->rkey != crkey) { 3465 SPDK_ERRLOG("No registrant or current key doesn't match " 3466 "with existing registrant key\n"); 3467 status = SPDK_NVME_SC_RESERVATION_CONFLICT; 3468 update_sgroup = false; 3469 goto exit; 3470 } 3471 3472 num_hostid = nvmf_ns_reservation_get_all_other_hostid(ns, hostid_list, 3473 SPDK_NVMF_MAX_NUM_REGISTRANTS, 3474 &ctrlr->hostid); 3475 3476 switch (rrela) { 3477 case SPDK_NVME_RESERVE_RELEASE: 3478 if (!ns->holder) { 3479 SPDK_DEBUGLOG(nvmf, "RELEASE: no holder\n"); 3480 update_sgroup = false; 3481 goto exit; 3482 } 3483 if (ns->rtype != rtype) { 3484 SPDK_ERRLOG("Type doesn't match\n"); 3485 status = SPDK_NVME_SC_INVALID_FIELD; 3486 update_sgroup = false; 3487 goto exit; 3488 } 3489 if (!nvmf_ns_reservation_registrant_is_holder(ns, reg)) { 3490 /* not the reservation holder, this isn't an error */ 3491 update_sgroup = false; 3492 goto exit; 3493 } 3494 3495 rtype = ns->rtype; 3496 nvmf_ns_reservation_release_reservation(ns); 3497 3498 if (num_hostid && rtype != SPDK_NVME_RESERVE_WRITE_EXCLUSIVE && 3499 rtype != SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS) { 3500 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3501 hostid_list, 3502 num_hostid, 3503 SPDK_NVME_RESERVATION_RELEASED); 3504 } 3505 break; 3506 case SPDK_NVME_RESERVE_CLEAR: 3507 nvmf_ns_reservation_clear_all_registrants(ns); 3508 if (num_hostid) { 3509 nvmf_subsystem_gen_ctrlr_notification(ns->subsystem, ns, 3510 hostid_list, 3511 num_hostid, 3512 SPDK_NVME_RESERVATION_PREEMPTED); 3513 } 3514 break; 3515 default: 3516 status = SPDK_NVME_SC_INVALID_FIELD; 3517 update_sgroup = false; 3518 goto exit; 3519 } 3520 3521 exit: 3522 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3523 req->rsp->nvme_cpl.status.sc = status; 3524 return update_sgroup; 3525 } 3526 3527 static void 3528 nvmf_ns_reservation_report(struct spdk_nvmf_ns *ns, 3529 struct spdk_nvmf_ctrlr *ctrlr, 3530 struct spdk_nvmf_request *req) 3531 { 3532 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3533 struct spdk_nvmf_registrant *reg, *tmp; 3534 struct spdk_nvme_reservation_status_extended_data status_data = { 0 }; 3535 struct spdk_iov_xfer ix; 3536 uint32_t transfer_len; 3537 uint32_t regctl = 0; 3538 uint8_t status = SPDK_NVME_SC_SUCCESS; 3539 3540 if (req->iovcnt == 0) { 3541 SPDK_ERRLOG("No data transfer specified for request. " 3542 " Unable to transfer back response.\n"); 3543 status = SPDK_NVME_SC_INVALID_FIELD; 3544 goto exit; 3545 } 3546 3547 if (!cmd->cdw11_bits.resv_report.eds) { 3548 SPDK_ERRLOG("NVMeoF uses extended controller data structure, " 3549 "please set EDS bit in cdw11 and try again\n"); 3550 status = SPDK_NVME_SC_HOSTID_INCONSISTENT_FORMAT; 3551 goto exit; 3552 } 3553 3554 /* Number of Dwords of the Reservation Status data structure to transfer */ 3555 transfer_len = (cmd->cdw10 + 1) * sizeof(uint32_t); 3556 3557 if (transfer_len < sizeof(struct spdk_nvme_reservation_status_extended_data)) { 3558 status = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3559 goto exit; 3560 } 3561 3562 spdk_iov_xfer_init(&ix, req->iov, req->iovcnt); 3563 3564 status_data.data.gen = ns->gen; 3565 status_data.data.rtype = ns->rtype; 3566 status_data.data.ptpls = ns->ptpl_activated; 3567 3568 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 3569 regctl++; 3570 } 3571 3572 /* 3573 * We report the number of registrants as per the spec here, even if 3574 * the iov isn't big enough to contain them all. In that case, the 3575 * spdk_iov_xfer_from_buf() won't actually copy any of the remaining 3576 * data; as it keeps track of the iov cursor itself, it's simplest to 3577 * just walk the entire list anyway. 3578 */ 3579 status_data.data.regctl = regctl; 3580 3581 spdk_iov_xfer_from_buf(&ix, &status_data, sizeof(status_data)); 3582 3583 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 3584 struct spdk_nvme_registered_ctrlr_extended_data ctrlr_data = { 0 }; 3585 3586 /* Set to 0xffffh for dynamic controller */ 3587 ctrlr_data.cntlid = 0xffff; 3588 ctrlr_data.rcsts.status = (ns->holder == reg) ? true : false; 3589 ctrlr_data.rkey = reg->rkey; 3590 spdk_uuid_copy((struct spdk_uuid *)ctrlr_data.hostid, ®->hostid); 3591 3592 spdk_iov_xfer_from_buf(&ix, &ctrlr_data, sizeof(ctrlr_data)); 3593 } 3594 3595 exit: 3596 req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC; 3597 req->rsp->nvme_cpl.status.sc = status; 3598 return; 3599 } 3600 3601 static void 3602 nvmf_ns_reservation_complete(void *ctx) 3603 { 3604 struct spdk_nvmf_request *req = ctx; 3605 3606 spdk_nvmf_request_complete(req); 3607 } 3608 3609 static void 3610 _nvmf_ns_reservation_update_done(struct spdk_nvmf_subsystem *subsystem, 3611 void *cb_arg, int status) 3612 { 3613 struct spdk_nvmf_request *req = (struct spdk_nvmf_request *)cb_arg; 3614 struct spdk_nvmf_poll_group *group = req->qpair->group; 3615 3616 spdk_thread_send_msg(group->thread, nvmf_ns_reservation_complete, req); 3617 } 3618 3619 void 3620 nvmf_ns_reservation_request(void *ctx) 3621 { 3622 struct spdk_nvmf_request *req = (struct spdk_nvmf_request *)ctx; 3623 struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; 3624 struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr; 3625 uint32_t nsid; 3626 struct spdk_nvmf_ns *ns; 3627 bool update_sgroup = false; 3628 int status = 0; 3629 3630 nsid = cmd->nsid; 3631 ns = _nvmf_subsystem_get_ns(ctrlr->subsys, nsid); 3632 assert(ns != NULL); 3633 3634 switch (cmd->opc) { 3635 case SPDK_NVME_OPC_RESERVATION_REGISTER: 3636 update_sgroup = nvmf_ns_reservation_register(ns, ctrlr, req); 3637 break; 3638 case SPDK_NVME_OPC_RESERVATION_ACQUIRE: 3639 update_sgroup = nvmf_ns_reservation_acquire(ns, ctrlr, req); 3640 break; 3641 case SPDK_NVME_OPC_RESERVATION_RELEASE: 3642 update_sgroup = nvmf_ns_reservation_release(ns, ctrlr, req); 3643 break; 3644 case SPDK_NVME_OPC_RESERVATION_REPORT: 3645 nvmf_ns_reservation_report(ns, ctrlr, req); 3646 break; 3647 default: 3648 break; 3649 } 3650 3651 /* update reservation information to subsystem's poll group */ 3652 if (update_sgroup) { 3653 if (ns->ptpl_activated || cmd->opc == SPDK_NVME_OPC_RESERVATION_REGISTER) { 3654 if (nvmf_ns_update_reservation_info(ns) != 0) { 3655 req->rsp->nvme_cpl.status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR; 3656 } 3657 } 3658 status = nvmf_subsystem_update_ns(ctrlr->subsys, _nvmf_ns_reservation_update_done, req); 3659 if (status == 0) { 3660 return; 3661 } 3662 } 3663 3664 _nvmf_ns_reservation_update_done(ctrlr->subsys, req, status); 3665 } 3666 3667 static bool 3668 nvmf_ns_is_ptpl_capable_json(const struct spdk_nvmf_ns *ns) 3669 { 3670 return ns->ptpl_file != NULL; 3671 } 3672 3673 static struct spdk_nvmf_ns_reservation_ops g_reservation_ops = { 3674 .is_ptpl_capable = nvmf_ns_is_ptpl_capable_json, 3675 .update = nvmf_ns_reservation_update_json, 3676 .load = nvmf_ns_reservation_load_json, 3677 }; 3678 3679 bool 3680 nvmf_ns_is_ptpl_capable(const struct spdk_nvmf_ns *ns) 3681 { 3682 return g_reservation_ops.is_ptpl_capable(ns); 3683 } 3684 3685 static int 3686 nvmf_ns_reservation_update(const struct spdk_nvmf_ns *ns, 3687 const struct spdk_nvmf_reservation_info *info) 3688 { 3689 return g_reservation_ops.update(ns, info); 3690 } 3691 3692 static int 3693 nvmf_ns_reservation_load(const struct spdk_nvmf_ns *ns, struct spdk_nvmf_reservation_info *info) 3694 { 3695 return g_reservation_ops.load(ns, info); 3696 } 3697 3698 void 3699 spdk_nvmf_set_custom_ns_reservation_ops(const struct spdk_nvmf_ns_reservation_ops *ops) 3700 { 3701 g_reservation_ops = *ops; 3702 } 3703 3704 int 3705 spdk_nvmf_subsystem_set_ana_reporting(struct spdk_nvmf_subsystem *subsystem, 3706 bool ana_reporting) 3707 { 3708 if (subsystem->state != SPDK_NVMF_SUBSYSTEM_INACTIVE) { 3709 return -EAGAIN; 3710 } 3711 3712 subsystem->flags.ana_reporting = ana_reporting; 3713 3714 return 0; 3715 } 3716 3717 bool 3718 spdk_nvmf_subsystem_get_ana_reporting(struct spdk_nvmf_subsystem *subsystem) 3719 { 3720 return subsystem->flags.ana_reporting; 3721 } 3722 3723 struct subsystem_listener_update_ctx { 3724 struct spdk_nvmf_subsystem_listener *listener; 3725 3726 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn; 3727 void *cb_arg; 3728 }; 3729 3730 static void 3731 subsystem_listener_update_done(struct spdk_io_channel_iter *i, int status) 3732 { 3733 struct subsystem_listener_update_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 3734 3735 if (ctx->cb_fn) { 3736 ctx->cb_fn(ctx->cb_arg, status); 3737 } 3738 free(ctx); 3739 } 3740 3741 static void 3742 subsystem_listener_update_on_pg(struct spdk_io_channel_iter *i) 3743 { 3744 struct subsystem_listener_update_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 3745 struct spdk_nvmf_subsystem_listener *listener; 3746 struct spdk_nvmf_poll_group *group; 3747 struct spdk_nvmf_ctrlr *ctrlr; 3748 3749 listener = ctx->listener; 3750 group = spdk_io_channel_get_ctx(spdk_io_channel_iter_get_channel(i)); 3751 3752 TAILQ_FOREACH(ctrlr, &listener->subsystem->ctrlrs, link) { 3753 if (ctrlr->thread != spdk_get_thread()) { 3754 continue; 3755 } 3756 3757 if (ctrlr->admin_qpair && ctrlr->admin_qpair->group == group && ctrlr->listener == listener) { 3758 nvmf_ctrlr_async_event_ana_change_notice(ctrlr); 3759 } 3760 } 3761 3762 spdk_for_each_channel_continue(i, 0); 3763 } 3764 3765 void 3766 spdk_nvmf_subsystem_set_ana_state(struct spdk_nvmf_subsystem *subsystem, 3767 const struct spdk_nvme_transport_id *trid, 3768 enum spdk_nvme_ana_state ana_state, uint32_t anagrpid, 3769 spdk_nvmf_tgt_subsystem_listen_done_fn cb_fn, void *cb_arg) 3770 { 3771 struct spdk_nvmf_subsystem_listener *listener; 3772 struct subsystem_listener_update_ctx *ctx; 3773 uint32_t i; 3774 3775 assert(cb_fn != NULL); 3776 assert(subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE || 3777 subsystem->state == SPDK_NVMF_SUBSYSTEM_PAUSED); 3778 3779 if (!subsystem->flags.ana_reporting) { 3780 SPDK_ERRLOG("ANA reporting is disabled\n"); 3781 cb_fn(cb_arg, -EINVAL); 3782 return; 3783 } 3784 3785 /* ANA Change state is not used, ANA Persistent Loss state 3786 * is not supported yet. 3787 */ 3788 if (!(ana_state == SPDK_NVME_ANA_OPTIMIZED_STATE || 3789 ana_state == SPDK_NVME_ANA_NON_OPTIMIZED_STATE || 3790 ana_state == SPDK_NVME_ANA_INACCESSIBLE_STATE)) { 3791 SPDK_ERRLOG("ANA state %d is not supported\n", ana_state); 3792 cb_fn(cb_arg, -ENOTSUP); 3793 return; 3794 } 3795 3796 if (anagrpid > subsystem->max_nsid) { 3797 SPDK_ERRLOG("ANA group ID %" PRIu32 " is more than maximum\n", anagrpid); 3798 cb_fn(cb_arg, -EINVAL); 3799 return; 3800 } 3801 3802 listener = nvmf_subsystem_find_listener(subsystem, trid); 3803 if (!listener) { 3804 SPDK_ERRLOG("Unable to find listener.\n"); 3805 cb_fn(cb_arg, -EINVAL); 3806 return; 3807 } 3808 3809 if (anagrpid != 0 && listener->ana_state[anagrpid - 1] == ana_state) { 3810 cb_fn(cb_arg, 0); 3811 return; 3812 } 3813 3814 ctx = calloc(1, sizeof(*ctx)); 3815 if (!ctx) { 3816 SPDK_ERRLOG("Unable to allocate context\n"); 3817 cb_fn(cb_arg, -ENOMEM); 3818 return; 3819 } 3820 3821 for (i = 1; i <= subsystem->max_nsid; i++) { 3822 if (anagrpid == 0 || i == anagrpid) { 3823 listener->ana_state[i - 1] = ana_state; 3824 } 3825 } 3826 listener->ana_state_change_count++; 3827 3828 ctx->listener = listener; 3829 ctx->cb_fn = cb_fn; 3830 ctx->cb_arg = cb_arg; 3831 3832 spdk_for_each_channel(subsystem->tgt, 3833 subsystem_listener_update_on_pg, 3834 ctx, 3835 subsystem_listener_update_done); 3836 } 3837 3838 int 3839 spdk_nvmf_subsystem_get_ana_state(struct spdk_nvmf_subsystem *subsystem, 3840 const struct spdk_nvme_transport_id *trid, 3841 uint32_t anagrpid, 3842 enum spdk_nvme_ana_state *ana_state) 3843 { 3844 assert(ana_state != NULL); 3845 3846 struct spdk_nvmf_subsystem_listener *listener; 3847 3848 if (!subsystem->flags.ana_reporting) { 3849 SPDK_ERRLOG("ANA reporting is disabled\n"); 3850 return -EINVAL; 3851 } 3852 3853 if (anagrpid <= 0 || anagrpid > subsystem->max_nsid) { 3854 SPDK_ERRLOG("ANA group ID %" PRIu32 " is invalid\n", anagrpid); 3855 return -EINVAL; 3856 } 3857 3858 listener = nvmf_subsystem_find_listener(subsystem, trid); 3859 if (!listener) { 3860 SPDK_ERRLOG("Unable to find listener.\n"); 3861 return -EINVAL; 3862 } 3863 3864 *ana_state = listener->ana_state[anagrpid - 1]; 3865 return 0; 3866 } 3867 3868 bool 3869 spdk_nvmf_subsystem_is_discovery(struct spdk_nvmf_subsystem *subsystem) 3870 { 3871 return subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT || 3872 subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY; 3873 } 3874 3875 bool 3876 nvmf_nqn_is_discovery(const char *nqn) 3877 { 3878 return strcmp(nqn, SPDK_NVMF_DISCOVERY_NQN) == 0; 3879 } 3880