1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. All rights reserved. 5 * Copyright (c) 2018-2019 Mellanox Technologies LTD. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "spdk/bdev.h" 37 #include "spdk/bit_array.h" 38 #include "spdk/thread.h" 39 #include "spdk/nvmf.h" 40 #include "spdk/trace.h" 41 #include "spdk/endian.h" 42 #include "spdk/string.h" 43 44 #include "spdk/log.h" 45 46 #include "nvmf_internal.h" 47 #include "transport.h" 48 49 SPDK_LOG_REGISTER_COMPONENT(nvmf) 50 51 #define SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS 1024 52 #define SPDK_NVMF_DEFAULT_ACCEPT_POLL_RATE_US 10000 53 54 static TAILQ_HEAD(, spdk_nvmf_tgt) g_nvmf_tgts = TAILQ_HEAD_INITIALIZER(g_nvmf_tgts); 55 56 typedef void (*nvmf_qpair_disconnect_cpl)(void *ctx, int status); 57 static void nvmf_tgt_destroy_poll_group(void *io_device, void *ctx_buf); 58 59 /* supplied to a single call to nvmf_qpair_disconnect */ 60 struct nvmf_qpair_disconnect_ctx { 61 struct spdk_nvmf_qpair *qpair; 62 struct spdk_nvmf_ctrlr *ctrlr; 63 nvmf_qpair_disconnect_cb cb_fn; 64 struct spdk_thread *thread; 65 void *ctx; 66 uint16_t qid; 67 }; 68 69 /* 70 * There are several times when we need to iterate through the list of all qpairs and selectively delete them. 71 * In order to do this sequentially without overlap, we must provide a context to recover the next qpair from 72 * to enable calling nvmf_qpair_disconnect on the next desired qpair. 73 */ 74 struct nvmf_qpair_disconnect_many_ctx { 75 struct spdk_nvmf_subsystem *subsystem; 76 struct spdk_nvmf_poll_group *group; 77 spdk_nvmf_poll_group_mod_done cpl_fn; 78 void *cpl_ctx; 79 }; 80 81 static void 82 nvmf_qpair_set_state(struct spdk_nvmf_qpair *qpair, 83 enum spdk_nvmf_qpair_state state) 84 { 85 assert(qpair != NULL); 86 assert(qpair->group->thread == spdk_get_thread()); 87 88 qpair->state = state; 89 } 90 91 static int 92 nvmf_poll_group_poll(void *ctx) 93 { 94 struct spdk_nvmf_poll_group *group = ctx; 95 int rc; 96 int count = 0; 97 struct spdk_nvmf_transport_poll_group *tgroup; 98 99 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 100 rc = nvmf_transport_poll_group_poll(tgroup); 101 if (rc < 0) { 102 return SPDK_POLLER_BUSY; 103 } 104 count += rc; 105 } 106 107 return count > 0 ? SPDK_POLLER_BUSY : SPDK_POLLER_IDLE; 108 } 109 110 static int 111 nvmf_tgt_create_poll_group(void *io_device, void *ctx_buf) 112 { 113 struct spdk_nvmf_tgt *tgt = io_device; 114 struct spdk_nvmf_poll_group *group = ctx_buf; 115 struct spdk_nvmf_transport *transport; 116 uint32_t sid; 117 118 TAILQ_INIT(&group->tgroups); 119 TAILQ_INIT(&group->qpairs); 120 121 TAILQ_FOREACH(transport, &tgt->transports, link) { 122 nvmf_poll_group_add_transport(group, transport); 123 } 124 125 group->num_sgroups = tgt->max_subsystems; 126 group->sgroups = calloc(tgt->max_subsystems, sizeof(struct spdk_nvmf_subsystem_poll_group)); 127 if (!group->sgroups) { 128 return -ENOMEM; 129 } 130 131 for (sid = 0; sid < tgt->max_subsystems; sid++) { 132 struct spdk_nvmf_subsystem *subsystem; 133 134 subsystem = tgt->subsystems[sid]; 135 if (!subsystem) { 136 continue; 137 } 138 139 if (nvmf_poll_group_add_subsystem(group, subsystem, NULL, NULL) != 0) { 140 nvmf_tgt_destroy_poll_group(io_device, ctx_buf); 141 return -1; 142 } 143 } 144 145 pthread_mutex_lock(&tgt->mutex); 146 TAILQ_INSERT_TAIL(&tgt->poll_groups, group, link); 147 pthread_mutex_unlock(&tgt->mutex); 148 149 group->poller = SPDK_POLLER_REGISTER(nvmf_poll_group_poll, group, 0); 150 group->thread = spdk_get_thread(); 151 152 return 0; 153 } 154 155 static void 156 nvmf_tgt_destroy_poll_group(void *io_device, void *ctx_buf) 157 { 158 struct spdk_nvmf_tgt *tgt = io_device; 159 struct spdk_nvmf_poll_group *group = ctx_buf; 160 struct spdk_nvmf_transport_poll_group *tgroup, *tmp; 161 struct spdk_nvmf_subsystem_poll_group *sgroup; 162 uint32_t sid, nsid; 163 164 pthread_mutex_lock(&tgt->mutex); 165 TAILQ_REMOVE(&tgt->poll_groups, group, link); 166 pthread_mutex_unlock(&tgt->mutex); 167 168 TAILQ_FOREACH_SAFE(tgroup, &group->tgroups, link, tmp) { 169 TAILQ_REMOVE(&group->tgroups, tgroup, link); 170 nvmf_transport_poll_group_destroy(tgroup); 171 } 172 173 for (sid = 0; sid < group->num_sgroups; sid++) { 174 sgroup = &group->sgroups[sid]; 175 176 for (nsid = 0; nsid < sgroup->num_ns; nsid++) { 177 if (sgroup->ns_info[nsid].channel) { 178 spdk_put_io_channel(sgroup->ns_info[nsid].channel); 179 sgroup->ns_info[nsid].channel = NULL; 180 } 181 } 182 183 free(sgroup->ns_info); 184 } 185 186 free(group->sgroups); 187 188 spdk_poller_unregister(&group->poller); 189 190 if (group->destroy_cb_fn) { 191 group->destroy_cb_fn(group->destroy_cb_arg, 0); 192 } 193 } 194 195 static void 196 _nvmf_tgt_disconnect_next_qpair(void *ctx) 197 { 198 struct spdk_nvmf_qpair *qpair; 199 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 200 struct spdk_nvmf_poll_group *group = qpair_ctx->group; 201 struct spdk_io_channel *ch; 202 int rc = 0; 203 204 qpair = TAILQ_FIRST(&group->qpairs); 205 206 if (qpair) { 207 rc = spdk_nvmf_qpair_disconnect(qpair, _nvmf_tgt_disconnect_next_qpair, ctx); 208 } 209 210 if (!qpair || rc != 0) { 211 /* When the refcount from the channels reaches 0, nvmf_tgt_destroy_poll_group will be called. */ 212 ch = spdk_io_channel_from_ctx(group); 213 spdk_put_io_channel(ch); 214 free(qpair_ctx); 215 } 216 } 217 218 static void 219 nvmf_tgt_destroy_poll_group_qpairs(struct spdk_nvmf_poll_group *group) 220 { 221 struct nvmf_qpair_disconnect_many_ctx *ctx; 222 223 ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx)); 224 225 if (!ctx) { 226 SPDK_ERRLOG("Failed to allocate memory for destroy poll group ctx\n"); 227 return; 228 } 229 230 ctx->group = group; 231 _nvmf_tgt_disconnect_next_qpair(ctx); 232 } 233 234 static int 235 nvmf_tgt_accept(void *ctx) 236 { 237 struct spdk_nvmf_tgt *tgt = ctx; 238 struct spdk_nvmf_transport *transport, *tmp; 239 int count = 0; 240 241 TAILQ_FOREACH_SAFE(transport, &tgt->transports, link, tmp) { 242 count += nvmf_transport_accept(transport); 243 } 244 245 return count; 246 } 247 248 struct spdk_nvmf_tgt * 249 spdk_nvmf_tgt_create(struct spdk_nvmf_target_opts *opts) 250 { 251 struct spdk_nvmf_tgt *tgt, *tmp_tgt; 252 uint32_t acceptor_poll_rate; 253 254 if (strnlen(opts->name, NVMF_TGT_NAME_MAX_LENGTH) == NVMF_TGT_NAME_MAX_LENGTH) { 255 SPDK_ERRLOG("Provided target name exceeds the max length of %u.\n", NVMF_TGT_NAME_MAX_LENGTH); 256 return NULL; 257 } 258 259 TAILQ_FOREACH(tmp_tgt, &g_nvmf_tgts, link) { 260 if (!strncmp(opts->name, tmp_tgt->name, NVMF_TGT_NAME_MAX_LENGTH)) { 261 SPDK_ERRLOG("Provided target name must be unique.\n"); 262 return NULL; 263 } 264 } 265 266 tgt = calloc(1, sizeof(*tgt)); 267 if (!tgt) { 268 return NULL; 269 } 270 271 snprintf(tgt->name, NVMF_TGT_NAME_MAX_LENGTH, "%s", opts->name); 272 273 if (!opts || !opts->max_subsystems) { 274 tgt->max_subsystems = SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS; 275 } else { 276 tgt->max_subsystems = opts->max_subsystems; 277 } 278 279 if (!opts || !opts->acceptor_poll_rate) { 280 acceptor_poll_rate = SPDK_NVMF_DEFAULT_ACCEPT_POLL_RATE_US; 281 } else { 282 acceptor_poll_rate = opts->acceptor_poll_rate; 283 } 284 285 tgt->discovery_genctr = 0; 286 TAILQ_INIT(&tgt->transports); 287 TAILQ_INIT(&tgt->poll_groups); 288 289 tgt->subsystems = calloc(tgt->max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); 290 if (!tgt->subsystems) { 291 free(tgt); 292 return NULL; 293 } 294 295 pthread_mutex_init(&tgt->mutex, NULL); 296 297 tgt->accept_poller = SPDK_POLLER_REGISTER(nvmf_tgt_accept, tgt, acceptor_poll_rate); 298 if (!tgt->accept_poller) { 299 pthread_mutex_destroy(&tgt->mutex); 300 free(tgt->subsystems); 301 free(tgt); 302 return NULL; 303 } 304 305 spdk_io_device_register(tgt, 306 nvmf_tgt_create_poll_group, 307 nvmf_tgt_destroy_poll_group, 308 sizeof(struct spdk_nvmf_poll_group), 309 tgt->name); 310 311 TAILQ_INSERT_HEAD(&g_nvmf_tgts, tgt, link); 312 313 return tgt; 314 } 315 316 static void 317 nvmf_tgt_destroy_cb(void *io_device) 318 { 319 struct spdk_nvmf_tgt *tgt = io_device; 320 struct spdk_nvmf_transport *transport, *transport_tmp; 321 spdk_nvmf_tgt_destroy_done_fn *destroy_cb_fn; 322 void *destroy_cb_arg; 323 uint32_t i; 324 325 if (tgt->subsystems) { 326 for (i = 0; i < tgt->max_subsystems; i++) { 327 if (tgt->subsystems[i]) { 328 nvmf_subsystem_remove_all_listeners(tgt->subsystems[i], true); 329 spdk_nvmf_subsystem_destroy(tgt->subsystems[i]); 330 } 331 } 332 free(tgt->subsystems); 333 } 334 335 TAILQ_FOREACH_SAFE(transport, &tgt->transports, link, transport_tmp) { 336 TAILQ_REMOVE(&tgt->transports, transport, link); 337 spdk_nvmf_transport_destroy(transport); 338 } 339 340 destroy_cb_fn = tgt->destroy_cb_fn; 341 destroy_cb_arg = tgt->destroy_cb_arg; 342 343 pthread_mutex_destroy(&tgt->mutex); 344 free(tgt); 345 346 if (destroy_cb_fn) { 347 destroy_cb_fn(destroy_cb_arg, 0); 348 } 349 } 350 351 void 352 spdk_nvmf_tgt_destroy(struct spdk_nvmf_tgt *tgt, 353 spdk_nvmf_tgt_destroy_done_fn cb_fn, 354 void *cb_arg) 355 { 356 tgt->destroy_cb_fn = cb_fn; 357 tgt->destroy_cb_arg = cb_arg; 358 359 spdk_poller_unregister(&tgt->accept_poller); 360 361 TAILQ_REMOVE(&g_nvmf_tgts, tgt, link); 362 363 spdk_io_device_unregister(tgt, nvmf_tgt_destroy_cb); 364 } 365 366 const char * 367 spdk_nvmf_tgt_get_name(struct spdk_nvmf_tgt *tgt) 368 { 369 return tgt->name; 370 } 371 372 struct spdk_nvmf_tgt * 373 spdk_nvmf_get_tgt(const char *name) 374 { 375 struct spdk_nvmf_tgt *tgt; 376 uint32_t num_targets = 0; 377 378 TAILQ_FOREACH(tgt, &g_nvmf_tgts, link) { 379 if (name) { 380 if (!strncmp(tgt->name, name, NVMF_TGT_NAME_MAX_LENGTH)) { 381 return tgt; 382 } 383 } 384 num_targets++; 385 } 386 387 /* 388 * special case. If there is only one target and 389 * no name was specified, return the only available 390 * target. If there is more than one target, name must 391 * be specified. 392 */ 393 if (!name && num_targets == 1) { 394 return TAILQ_FIRST(&g_nvmf_tgts); 395 } 396 397 return NULL; 398 } 399 400 struct spdk_nvmf_tgt * 401 spdk_nvmf_get_first_tgt(void) 402 { 403 return TAILQ_FIRST(&g_nvmf_tgts); 404 } 405 406 struct spdk_nvmf_tgt * 407 spdk_nvmf_get_next_tgt(struct spdk_nvmf_tgt *prev) 408 { 409 return TAILQ_NEXT(prev, link); 410 } 411 412 static void 413 nvmf_write_subsystem_config_json(struct spdk_json_write_ctx *w, 414 struct spdk_nvmf_subsystem *subsystem) 415 { 416 struct spdk_nvmf_host *host; 417 struct spdk_nvmf_subsystem_listener *listener; 418 const struct spdk_nvme_transport_id *trid; 419 struct spdk_nvmf_ns *ns; 420 struct spdk_nvmf_ns_opts ns_opts; 421 uint32_t max_namespaces; 422 char uuid_str[SPDK_UUID_STRING_LEN]; 423 const char *adrfam; 424 425 if (spdk_nvmf_subsystem_get_type(subsystem) != SPDK_NVMF_SUBTYPE_NVME) { 426 return; 427 } 428 429 /* { */ 430 spdk_json_write_object_begin(w); 431 spdk_json_write_named_string(w, "method", "nvmf_create_subsystem"); 432 433 /* "params" : { */ 434 spdk_json_write_named_object_begin(w, "params"); 435 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 436 spdk_json_write_named_bool(w, "allow_any_host", spdk_nvmf_subsystem_get_allow_any_host(subsystem)); 437 spdk_json_write_named_string(w, "serial_number", spdk_nvmf_subsystem_get_sn(subsystem)); 438 spdk_json_write_named_string(w, "model_number", spdk_nvmf_subsystem_get_mn(subsystem)); 439 440 max_namespaces = spdk_nvmf_subsystem_get_max_namespaces(subsystem); 441 if (max_namespaces != 0) { 442 spdk_json_write_named_uint32(w, "max_namespaces", max_namespaces); 443 } 444 445 /* } "params" */ 446 spdk_json_write_object_end(w); 447 448 /* } */ 449 spdk_json_write_object_end(w); 450 451 for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL; 452 listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) { 453 trid = spdk_nvmf_subsystem_listener_get_trid(listener); 454 455 adrfam = spdk_nvme_transport_id_adrfam_str(trid->adrfam); 456 457 spdk_json_write_object_begin(w); 458 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_listener"); 459 460 /* "params" : { */ 461 spdk_json_write_named_object_begin(w, "params"); 462 463 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 464 465 /* "listen_address" : { */ 466 spdk_json_write_named_object_begin(w, "listen_address"); 467 468 spdk_json_write_named_string(w, "trtype", trid->trstring); 469 if (adrfam) { 470 spdk_json_write_named_string(w, "adrfam", adrfam); 471 } 472 473 spdk_json_write_named_string(w, "traddr", trid->traddr); 474 spdk_json_write_named_string(w, "trsvcid", trid->trsvcid); 475 /* } "listen_address" */ 476 spdk_json_write_object_end(w); 477 478 /* } "params" */ 479 spdk_json_write_object_end(w); 480 481 /* } */ 482 spdk_json_write_object_end(w); 483 } 484 485 for (host = spdk_nvmf_subsystem_get_first_host(subsystem); host != NULL; 486 host = spdk_nvmf_subsystem_get_next_host(subsystem, host)) { 487 488 spdk_json_write_object_begin(w); 489 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_host"); 490 491 /* "params" : { */ 492 spdk_json_write_named_object_begin(w, "params"); 493 494 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 495 spdk_json_write_named_string(w, "host", spdk_nvmf_host_get_nqn(host)); 496 497 /* } "params" */ 498 spdk_json_write_object_end(w); 499 500 /* } */ 501 spdk_json_write_object_end(w); 502 } 503 504 for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); ns != NULL; 505 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) { 506 spdk_nvmf_ns_get_opts(ns, &ns_opts, sizeof(ns_opts)); 507 508 spdk_json_write_object_begin(w); 509 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_ns"); 510 511 /* "params" : { */ 512 spdk_json_write_named_object_begin(w, "params"); 513 514 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 515 516 /* "namespace" : { */ 517 spdk_json_write_named_object_begin(w, "namespace"); 518 519 spdk_json_write_named_uint32(w, "nsid", spdk_nvmf_ns_get_id(ns)); 520 spdk_json_write_named_string(w, "bdev_name", spdk_bdev_get_name(spdk_nvmf_ns_get_bdev(ns))); 521 522 if (!spdk_mem_all_zero(ns_opts.nguid, sizeof(ns_opts.nguid))) { 523 SPDK_STATIC_ASSERT(sizeof(ns_opts.nguid) == sizeof(uint64_t) * 2, "size mismatch"); 524 spdk_json_write_named_string_fmt(w, "nguid", "%016"PRIX64"%016"PRIX64, from_be64(&ns_opts.nguid[0]), 525 from_be64(&ns_opts.nguid[8])); 526 } 527 528 if (!spdk_mem_all_zero(ns_opts.eui64, sizeof(ns_opts.eui64))) { 529 SPDK_STATIC_ASSERT(sizeof(ns_opts.eui64) == sizeof(uint64_t), "size mismatch"); 530 spdk_json_write_named_string_fmt(w, "eui64", "%016"PRIX64, from_be64(&ns_opts.eui64)); 531 } 532 533 if (!spdk_mem_all_zero(&ns_opts.uuid, sizeof(ns_opts.uuid))) { 534 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &ns_opts.uuid); 535 spdk_json_write_named_string(w, "uuid", uuid_str); 536 } 537 538 /* "namespace" */ 539 spdk_json_write_object_end(w); 540 541 /* } "params" */ 542 spdk_json_write_object_end(w); 543 544 /* } */ 545 spdk_json_write_object_end(w); 546 } 547 } 548 549 void 550 spdk_nvmf_tgt_write_config_json(struct spdk_json_write_ctx *w, struct spdk_nvmf_tgt *tgt) 551 { 552 struct spdk_nvmf_subsystem *subsystem; 553 struct spdk_nvmf_transport *transport; 554 555 spdk_json_write_object_begin(w); 556 spdk_json_write_named_string(w, "method", "nvmf_set_max_subsystems"); 557 558 spdk_json_write_named_object_begin(w, "params"); 559 spdk_json_write_named_uint32(w, "max_subsystems", tgt->max_subsystems); 560 spdk_json_write_object_end(w); 561 562 spdk_json_write_object_end(w); 563 564 /* write transports */ 565 TAILQ_FOREACH(transport, &tgt->transports, link) { 566 spdk_json_write_object_begin(w); 567 spdk_json_write_named_string(w, "method", "nvmf_create_transport"); 568 569 spdk_json_write_named_object_begin(w, "params"); 570 spdk_json_write_named_string(w, "trtype", transport->ops->name); 571 spdk_json_write_named_uint32(w, "max_queue_depth", transport->opts.max_queue_depth); 572 spdk_json_write_named_uint32(w, "max_io_qpairs_per_ctrlr", 573 transport->opts.max_qpairs_per_ctrlr - 1); 574 spdk_json_write_named_uint32(w, "in_capsule_data_size", transport->opts.in_capsule_data_size); 575 spdk_json_write_named_uint32(w, "max_io_size", transport->opts.max_io_size); 576 spdk_json_write_named_uint32(w, "io_unit_size", transport->opts.io_unit_size); 577 spdk_json_write_named_uint32(w, "max_aq_depth", transport->opts.max_aq_depth); 578 if (transport->ops->dump_opts) { 579 transport->ops->dump_opts(transport, w); 580 } 581 spdk_json_write_named_uint32(w, "abort_timeout_sec", transport->opts.abort_timeout_sec); 582 spdk_json_write_object_end(w); 583 584 spdk_json_write_object_end(w); 585 } 586 587 subsystem = spdk_nvmf_subsystem_get_first(tgt); 588 while (subsystem) { 589 nvmf_write_subsystem_config_json(w, subsystem); 590 subsystem = spdk_nvmf_subsystem_get_next(subsystem); 591 } 592 } 593 594 int 595 spdk_nvmf_tgt_listen(struct spdk_nvmf_tgt *tgt, 596 struct spdk_nvme_transport_id *trid) 597 { 598 struct spdk_nvmf_transport *transport; 599 const char *trtype; 600 int rc; 601 602 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 603 if (!transport) { 604 trtype = spdk_nvme_transport_id_trtype_str(trid->trtype); 605 if (trtype != NULL) { 606 SPDK_ERRLOG("Unable to listen on transport %s. The transport must be created first.\n", trtype); 607 } else { 608 SPDK_ERRLOG("The specified trtype %d is unknown. Please make sure that it is properly registered.\n", 609 trid->trtype); 610 } 611 612 return -EINVAL; 613 } 614 615 rc = spdk_nvmf_transport_listen(transport, trid); 616 if (rc < 0) { 617 SPDK_ERRLOG("Unable to listen on address '%s'\n", trid->traddr); 618 } 619 620 return rc; 621 } 622 623 int 624 spdk_nvmf_tgt_stop_listen(struct spdk_nvmf_tgt *tgt, 625 struct spdk_nvme_transport_id *trid) 626 { 627 struct spdk_nvmf_transport *transport; 628 const char *trtype; 629 int rc; 630 631 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 632 if (!transport) { 633 trtype = spdk_nvme_transport_id_trtype_str(trid->trtype); 634 if (trtype != NULL) { 635 SPDK_ERRLOG("Unable to stop listen on transport %s. The transport must be created first.\n", 636 trtype); 637 } else { 638 SPDK_ERRLOG("The specified trtype %d is unknown. Please make sure that it is properly registered.\n", 639 trid->trtype); 640 } 641 return -EINVAL; 642 } 643 644 rc = spdk_nvmf_transport_stop_listen(transport, trid); 645 if (rc < 0) { 646 SPDK_ERRLOG("Failed to stop listening on address '%s'\n", trid->traddr); 647 return rc; 648 } 649 return 0; 650 } 651 652 struct spdk_nvmf_tgt_add_transport_ctx { 653 struct spdk_nvmf_tgt *tgt; 654 struct spdk_nvmf_transport *transport; 655 spdk_nvmf_tgt_add_transport_done_fn cb_fn; 656 void *cb_arg; 657 }; 658 659 static void 660 _nvmf_tgt_add_transport_done(struct spdk_io_channel_iter *i, int status) 661 { 662 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 663 664 ctx->cb_fn(ctx->cb_arg, status); 665 666 free(ctx); 667 } 668 669 static void 670 _nvmf_tgt_add_transport(struct spdk_io_channel_iter *i) 671 { 672 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 673 struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i); 674 struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch); 675 int rc; 676 677 rc = nvmf_poll_group_add_transport(group, ctx->transport); 678 spdk_for_each_channel_continue(i, rc); 679 } 680 681 void spdk_nvmf_tgt_add_transport(struct spdk_nvmf_tgt *tgt, 682 struct spdk_nvmf_transport *transport, 683 spdk_nvmf_tgt_add_transport_done_fn cb_fn, 684 void *cb_arg) 685 { 686 struct spdk_nvmf_tgt_add_transport_ctx *ctx; 687 688 if (spdk_nvmf_tgt_get_transport(tgt, transport->ops->name)) { 689 cb_fn(cb_arg, -EEXIST); 690 return; /* transport already created */ 691 } 692 693 transport->tgt = tgt; 694 TAILQ_INSERT_TAIL(&tgt->transports, transport, link); 695 696 ctx = calloc(1, sizeof(*ctx)); 697 if (!ctx) { 698 cb_fn(cb_arg, -ENOMEM); 699 return; 700 } 701 702 ctx->tgt = tgt; 703 ctx->transport = transport; 704 ctx->cb_fn = cb_fn; 705 ctx->cb_arg = cb_arg; 706 707 spdk_for_each_channel(tgt, 708 _nvmf_tgt_add_transport, 709 ctx, 710 _nvmf_tgt_add_transport_done); 711 } 712 713 struct spdk_nvmf_subsystem * 714 spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) 715 { 716 struct spdk_nvmf_subsystem *subsystem; 717 uint32_t sid; 718 719 if (!subnqn) { 720 return NULL; 721 } 722 723 /* Ensure that subnqn is null terminated */ 724 if (!memchr(subnqn, '\0', SPDK_NVMF_NQN_MAX_LEN + 1)) { 725 SPDK_ERRLOG("Connect SUBNQN is not null terminated\n"); 726 return NULL; 727 } 728 729 for (sid = 0; sid < tgt->max_subsystems; sid++) { 730 subsystem = tgt->subsystems[sid]; 731 if (subsystem == NULL) { 732 continue; 733 } 734 735 if (strcmp(subnqn, subsystem->subnqn) == 0) { 736 return subsystem; 737 } 738 } 739 740 return NULL; 741 } 742 743 struct spdk_nvmf_transport * 744 spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name) 745 { 746 struct spdk_nvmf_transport *transport; 747 748 TAILQ_FOREACH(transport, &tgt->transports, link) { 749 if (!strncasecmp(transport->ops->name, transport_name, SPDK_NVMF_TRSTRING_MAX_LEN)) { 750 return transport; 751 } 752 } 753 return NULL; 754 } 755 756 struct nvmf_new_qpair_ctx { 757 struct spdk_nvmf_qpair *qpair; 758 struct spdk_nvmf_poll_group *group; 759 }; 760 761 static void 762 _nvmf_poll_group_add(void *_ctx) 763 { 764 struct nvmf_new_qpair_ctx *ctx = _ctx; 765 struct spdk_nvmf_qpair *qpair = ctx->qpair; 766 struct spdk_nvmf_poll_group *group = ctx->group; 767 768 free(_ctx); 769 770 if (spdk_nvmf_poll_group_add(group, qpair) != 0) { 771 SPDK_ERRLOG("Unable to add the qpair to a poll group.\n"); 772 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 773 } 774 } 775 776 void 777 spdk_nvmf_tgt_new_qpair(struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair) 778 { 779 struct spdk_nvmf_poll_group *group; 780 struct nvmf_new_qpair_ctx *ctx; 781 782 group = spdk_nvmf_get_optimal_poll_group(qpair); 783 if (group == NULL) { 784 if (tgt->next_poll_group == NULL) { 785 tgt->next_poll_group = TAILQ_FIRST(&tgt->poll_groups); 786 if (tgt->next_poll_group == NULL) { 787 SPDK_ERRLOG("No poll groups exist.\n"); 788 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 789 return; 790 } 791 } 792 group = tgt->next_poll_group; 793 tgt->next_poll_group = TAILQ_NEXT(group, link); 794 } 795 796 ctx = calloc(1, sizeof(*ctx)); 797 if (!ctx) { 798 SPDK_ERRLOG("Unable to send message to poll group.\n"); 799 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 800 return; 801 } 802 803 ctx->qpair = qpair; 804 ctx->group = group; 805 806 spdk_thread_send_msg(group->thread, _nvmf_poll_group_add, ctx); 807 } 808 809 struct spdk_nvmf_poll_group * 810 spdk_nvmf_poll_group_create(struct spdk_nvmf_tgt *tgt) 811 { 812 struct spdk_io_channel *ch; 813 814 ch = spdk_get_io_channel(tgt); 815 if (!ch) { 816 SPDK_ERRLOG("Unable to get I/O channel for target\n"); 817 return NULL; 818 } 819 820 return spdk_io_channel_get_ctx(ch); 821 } 822 823 void 824 spdk_nvmf_poll_group_destroy(struct spdk_nvmf_poll_group *group, 825 spdk_nvmf_poll_group_destroy_done_fn cb_fn, 826 void *cb_arg) 827 { 828 assert(group->destroy_cb_fn == NULL); 829 group->destroy_cb_fn = cb_fn; 830 group->destroy_cb_arg = cb_arg; 831 832 /* This function will put the io_channel associated with this poll group */ 833 nvmf_tgt_destroy_poll_group_qpairs(group); 834 } 835 836 int 837 spdk_nvmf_poll_group_add(struct spdk_nvmf_poll_group *group, 838 struct spdk_nvmf_qpair *qpair) 839 { 840 int rc = -1; 841 struct spdk_nvmf_transport_poll_group *tgroup; 842 843 TAILQ_INIT(&qpair->outstanding); 844 qpair->group = group; 845 qpair->ctrlr = NULL; 846 qpair->disconnect_started = false; 847 848 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 849 if (tgroup->transport == qpair->transport) { 850 rc = nvmf_transport_poll_group_add(tgroup, qpair); 851 break; 852 } 853 } 854 855 /* We add the qpair to the group only it is succesfully added into the tgroup */ 856 if (rc == 0) { 857 TAILQ_INSERT_TAIL(&group->qpairs, qpair, link); 858 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ACTIVE); 859 } 860 861 return rc; 862 } 863 864 static void 865 _nvmf_ctrlr_destruct(void *ctx) 866 { 867 struct spdk_nvmf_ctrlr *ctrlr = ctx; 868 869 nvmf_ctrlr_destruct(ctrlr); 870 } 871 872 static void 873 _nvmf_transport_qpair_fini(void *ctx) 874 { 875 struct spdk_nvmf_qpair *qpair = ctx; 876 877 nvmf_transport_qpair_fini(qpair); 878 } 879 880 static void 881 _nvmf_ctrlr_free_from_qpair(void *ctx) 882 { 883 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 884 struct spdk_nvmf_ctrlr *ctrlr = qpair_ctx->ctrlr; 885 uint32_t count; 886 887 spdk_bit_array_clear(ctrlr->qpair_mask, qpair_ctx->qid); 888 count = spdk_bit_array_count_set(ctrlr->qpair_mask); 889 if (count == 0) { 890 ctrlr->in_destruct = true; 891 spdk_thread_send_msg(ctrlr->subsys->thread, _nvmf_ctrlr_destruct, ctrlr); 892 } 893 894 spdk_thread_send_msg(qpair_ctx->thread, _nvmf_transport_qpair_fini, qpair_ctx->qpair); 895 if (qpair_ctx->cb_fn) { 896 spdk_thread_send_msg(qpair_ctx->thread, qpair_ctx->cb_fn, qpair_ctx->ctx); 897 } 898 free(qpair_ctx); 899 } 900 901 void 902 spdk_nvmf_poll_group_remove(struct spdk_nvmf_qpair *qpair) 903 { 904 struct spdk_nvmf_ctrlr *ctrlr = qpair->ctrlr; 905 struct spdk_nvmf_transport_poll_group *tgroup; 906 struct spdk_nvmf_request *req, *tmp; 907 struct spdk_nvmf_subsystem_poll_group *sgroup; 908 int rc; 909 910 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ERROR); 911 912 /* Find the tgroup and remove the qpair from the tgroup */ 913 TAILQ_FOREACH(tgroup, &qpair->group->tgroups, link) { 914 if (tgroup->transport == qpair->transport) { 915 rc = nvmf_transport_poll_group_remove(tgroup, qpair); 916 if (rc && (rc != ENOTSUP)) { 917 SPDK_ERRLOG("Cannot remove qpair=%p from transport group=%p\n", 918 qpair, tgroup); 919 } 920 break; 921 } 922 } 923 924 if (ctrlr) { 925 sgroup = &qpair->group->sgroups[ctrlr->subsys->id]; 926 TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) { 927 if (req->qpair == qpair) { 928 TAILQ_REMOVE(&sgroup->queued, req, link); 929 if (nvmf_transport_req_free(req)) { 930 SPDK_ERRLOG("Transport request free error!\n"); 931 } 932 } 933 } 934 } 935 936 TAILQ_REMOVE(&qpair->group->qpairs, qpair, link); 937 qpair->group = NULL; 938 } 939 940 static void 941 _nvmf_qpair_destroy(void *ctx, int status) 942 { 943 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 944 struct spdk_nvmf_qpair *qpair = qpair_ctx->qpair; 945 struct spdk_nvmf_ctrlr *ctrlr = qpair->ctrlr; 946 947 assert(qpair->state == SPDK_NVMF_QPAIR_DEACTIVATING); 948 qpair_ctx->qid = qpair->qid; 949 950 spdk_nvmf_poll_group_remove(qpair); 951 952 if (!ctrlr || !ctrlr->thread) { 953 nvmf_transport_qpair_fini(qpair); 954 if (qpair_ctx->cb_fn) { 955 spdk_thread_send_msg(qpair_ctx->thread, qpair_ctx->cb_fn, qpair_ctx->ctx); 956 } 957 free(qpair_ctx); 958 return; 959 } 960 961 qpair_ctx->ctrlr = ctrlr; 962 spdk_thread_send_msg(ctrlr->thread, _nvmf_ctrlr_free_from_qpair, qpair_ctx); 963 } 964 965 static void 966 _nvmf_qpair_disconnect_msg(void *ctx) 967 { 968 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 969 970 spdk_nvmf_qpair_disconnect(qpair_ctx->qpair, qpair_ctx->cb_fn, qpair_ctx->ctx); 971 free(ctx); 972 } 973 974 int 975 spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) 976 { 977 struct nvmf_qpair_disconnect_ctx *qpair_ctx; 978 979 if (__atomic_test_and_set(&qpair->disconnect_started, __ATOMIC_RELAXED)) { 980 if (cb_fn) { 981 cb_fn(ctx); 982 } 983 return 0; 984 } 985 986 /* If we get a qpair in the uninitialized state, we can just destroy it immediately */ 987 if (qpair->state == SPDK_NVMF_QPAIR_UNINITIALIZED) { 988 nvmf_transport_qpair_fini(qpair); 989 if (cb_fn) { 990 cb_fn(ctx); 991 } 992 return 0; 993 } 994 995 assert(qpair->group != NULL); 996 if (spdk_get_thread() != qpair->group->thread) { 997 /* clear the atomic so we can set it on the next call on the proper thread. */ 998 __atomic_clear(&qpair->disconnect_started, __ATOMIC_RELAXED); 999 qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx)); 1000 if (!qpair_ctx) { 1001 SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n"); 1002 return -ENOMEM; 1003 } 1004 qpair_ctx->qpair = qpair; 1005 qpair_ctx->cb_fn = cb_fn; 1006 qpair_ctx->thread = qpair->group->thread; 1007 qpair_ctx->ctx = ctx; 1008 spdk_thread_send_msg(qpair->group->thread, _nvmf_qpair_disconnect_msg, qpair_ctx); 1009 return 0; 1010 } 1011 1012 assert(qpair->state == SPDK_NVMF_QPAIR_ACTIVE); 1013 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_DEACTIVATING); 1014 1015 qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx)); 1016 if (!qpair_ctx) { 1017 SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n"); 1018 return -ENOMEM; 1019 } 1020 1021 qpair_ctx->qpair = qpair; 1022 qpair_ctx->cb_fn = cb_fn; 1023 qpair_ctx->thread = qpair->group->thread; 1024 qpair_ctx->ctx = ctx; 1025 1026 /* Check for outstanding I/O */ 1027 if (!TAILQ_EMPTY(&qpair->outstanding)) { 1028 qpair->state_cb = _nvmf_qpair_destroy; 1029 qpair->state_cb_arg = qpair_ctx; 1030 nvmf_qpair_free_aer(qpair); 1031 return 0; 1032 } 1033 1034 _nvmf_qpair_destroy(qpair_ctx, 0); 1035 1036 return 0; 1037 } 1038 1039 int 1040 spdk_nvmf_qpair_get_peer_trid(struct spdk_nvmf_qpair *qpair, 1041 struct spdk_nvme_transport_id *trid) 1042 { 1043 return nvmf_transport_qpair_get_peer_trid(qpair, trid); 1044 } 1045 1046 int 1047 spdk_nvmf_qpair_get_local_trid(struct spdk_nvmf_qpair *qpair, 1048 struct spdk_nvme_transport_id *trid) 1049 { 1050 return nvmf_transport_qpair_get_local_trid(qpair, trid); 1051 } 1052 1053 int 1054 spdk_nvmf_qpair_get_listen_trid(struct spdk_nvmf_qpair *qpair, 1055 struct spdk_nvme_transport_id *trid) 1056 { 1057 return nvmf_transport_qpair_get_listen_trid(qpair, trid); 1058 } 1059 1060 int 1061 nvmf_poll_group_add_transport(struct spdk_nvmf_poll_group *group, 1062 struct spdk_nvmf_transport *transport) 1063 { 1064 struct spdk_nvmf_transport_poll_group *tgroup; 1065 1066 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 1067 if (tgroup->transport == transport) { 1068 /* Transport already in the poll group */ 1069 return 0; 1070 } 1071 } 1072 1073 tgroup = nvmf_transport_poll_group_create(transport); 1074 if (!tgroup) { 1075 SPDK_ERRLOG("Unable to create poll group for transport\n"); 1076 return -1; 1077 } 1078 1079 tgroup->group = group; 1080 TAILQ_INSERT_TAIL(&group->tgroups, tgroup, link); 1081 1082 return 0; 1083 } 1084 1085 static int 1086 poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 1087 struct spdk_nvmf_subsystem *subsystem) 1088 { 1089 struct spdk_nvmf_subsystem_poll_group *sgroup; 1090 uint32_t new_num_ns, old_num_ns; 1091 uint32_t i, j; 1092 struct spdk_nvmf_ns *ns; 1093 struct spdk_nvmf_registrant *reg, *tmp; 1094 struct spdk_io_channel *ch; 1095 struct spdk_nvmf_subsystem_pg_ns_info *ns_info; 1096 struct spdk_nvmf_ctrlr *ctrlr; 1097 bool ns_changed; 1098 1099 /* Make sure our poll group has memory for this subsystem allocated */ 1100 if (subsystem->id >= group->num_sgroups) { 1101 return -ENOMEM; 1102 } 1103 1104 sgroup = &group->sgroups[subsystem->id]; 1105 1106 /* Make sure the array of namespace information is the correct size */ 1107 new_num_ns = subsystem->max_nsid; 1108 old_num_ns = sgroup->num_ns; 1109 1110 ns_changed = false; 1111 1112 if (old_num_ns == 0) { 1113 if (new_num_ns > 0) { 1114 /* First allocation */ 1115 sgroup->ns_info = calloc(new_num_ns, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1116 if (!sgroup->ns_info) { 1117 return -ENOMEM; 1118 } 1119 } 1120 } else if (new_num_ns > old_num_ns) { 1121 void *buf; 1122 1123 /* Make the array larger */ 1124 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1125 if (!buf) { 1126 return -ENOMEM; 1127 } 1128 1129 sgroup->ns_info = buf; 1130 1131 /* Null out the new namespace information slots */ 1132 for (i = old_num_ns; i < new_num_ns; i++) { 1133 memset(&sgroup->ns_info[i], 0, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1134 } 1135 } else if (new_num_ns < old_num_ns) { 1136 void *buf; 1137 1138 /* Free the extra I/O channels */ 1139 for (i = new_num_ns; i < old_num_ns; i++) { 1140 ns_info = &sgroup->ns_info[i]; 1141 1142 if (ns_info->channel) { 1143 spdk_put_io_channel(ns_info->channel); 1144 ns_info->channel = NULL; 1145 } 1146 } 1147 1148 /* Make the array smaller */ 1149 if (new_num_ns > 0) { 1150 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1151 if (!buf) { 1152 return -ENOMEM; 1153 } 1154 sgroup->ns_info = buf; 1155 } else { 1156 free(sgroup->ns_info); 1157 sgroup->ns_info = NULL; 1158 } 1159 } 1160 1161 sgroup->num_ns = new_num_ns; 1162 1163 /* Detect bdevs that were added or removed */ 1164 for (i = 0; i < sgroup->num_ns; i++) { 1165 ns = subsystem->ns[i]; 1166 ns_info = &sgroup->ns_info[i]; 1167 ch = ns_info->channel; 1168 1169 if (ns == NULL && ch == NULL) { 1170 /* Both NULL. Leave empty */ 1171 } else if (ns == NULL && ch != NULL) { 1172 /* There was a channel here, but the namespace is gone. */ 1173 ns_changed = true; 1174 spdk_put_io_channel(ch); 1175 ns_info->channel = NULL; 1176 } else if (ns != NULL && ch == NULL) { 1177 /* A namespace appeared but there is no channel yet */ 1178 ns_changed = true; 1179 ch = spdk_bdev_get_io_channel(ns->desc); 1180 if (ch == NULL) { 1181 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1182 return -ENOMEM; 1183 } 1184 ns_info->channel = ch; 1185 } else if (spdk_uuid_compare(&ns_info->uuid, spdk_bdev_get_uuid(ns->bdev)) != 0) { 1186 /* A namespace was here before, but was replaced by a new one. */ 1187 ns_changed = true; 1188 spdk_put_io_channel(ns_info->channel); 1189 memset(ns_info, 0, sizeof(*ns_info)); 1190 1191 ch = spdk_bdev_get_io_channel(ns->desc); 1192 if (ch == NULL) { 1193 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1194 return -ENOMEM; 1195 } 1196 ns_info->channel = ch; 1197 } else if (ns_info->num_blocks != spdk_bdev_get_num_blocks(ns->bdev)) { 1198 /* Namespace is still there but size has changed */ 1199 SPDK_DEBUGLOG(nvmf, "Namespace resized: subsystem_id %d," 1200 " nsid %u, pg %p, old %lu, new %lu\n", 1201 subsystem->id, 1202 ns->nsid, 1203 group, 1204 ns_info->num_blocks, 1205 spdk_bdev_get_num_blocks(ns->bdev)); 1206 ns_changed = true; 1207 } 1208 1209 if (ns == NULL) { 1210 memset(ns_info, 0, sizeof(*ns_info)); 1211 } else { 1212 ns_info->uuid = *spdk_bdev_get_uuid(ns->bdev); 1213 ns_info->num_blocks = spdk_bdev_get_num_blocks(ns->bdev); 1214 ns_info->crkey = ns->crkey; 1215 ns_info->rtype = ns->rtype; 1216 if (ns->holder) { 1217 ns_info->holder_id = ns->holder->hostid; 1218 } 1219 1220 memset(&ns_info->reg_hostid, 0, SPDK_NVMF_MAX_NUM_REGISTRANTS * sizeof(struct spdk_uuid)); 1221 j = 0; 1222 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 1223 if (j >= SPDK_NVMF_MAX_NUM_REGISTRANTS) { 1224 SPDK_ERRLOG("Maximum %u registrants can support.\n", SPDK_NVMF_MAX_NUM_REGISTRANTS); 1225 return -EINVAL; 1226 } 1227 ns_info->reg_hostid[j++] = reg->hostid; 1228 } 1229 } 1230 } 1231 1232 if (ns_changed) { 1233 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1234 if (ctrlr->admin_qpair->group == group) { 1235 nvmf_ctrlr_async_event_ns_notice(ctrlr); 1236 nvmf_ctrlr_async_event_ana_change_notice(ctrlr); 1237 } 1238 } 1239 } 1240 1241 return 0; 1242 } 1243 1244 int 1245 nvmf_poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 1246 struct spdk_nvmf_subsystem *subsystem) 1247 { 1248 return poll_group_update_subsystem(group, subsystem); 1249 } 1250 1251 int 1252 nvmf_poll_group_add_subsystem(struct spdk_nvmf_poll_group *group, 1253 struct spdk_nvmf_subsystem *subsystem, 1254 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1255 { 1256 int rc = 0; 1257 struct spdk_nvmf_subsystem_poll_group *sgroup = &group->sgroups[subsystem->id]; 1258 1259 TAILQ_INIT(&sgroup->queued); 1260 1261 rc = poll_group_update_subsystem(group, subsystem); 1262 if (rc) { 1263 nvmf_poll_group_remove_subsystem(group, subsystem, NULL, NULL); 1264 goto fini; 1265 } 1266 1267 sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1268 fini: 1269 if (cb_fn) { 1270 cb_fn(cb_arg, rc); 1271 } 1272 1273 return rc; 1274 } 1275 1276 static void 1277 _nvmf_poll_group_remove_subsystem_cb(void *ctx, int status) 1278 { 1279 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 1280 struct spdk_nvmf_subsystem *subsystem; 1281 struct spdk_nvmf_poll_group *group; 1282 struct spdk_nvmf_subsystem_poll_group *sgroup; 1283 spdk_nvmf_poll_group_mod_done cpl_fn = NULL; 1284 void *cpl_ctx = NULL; 1285 uint32_t nsid; 1286 1287 group = qpair_ctx->group; 1288 subsystem = qpair_ctx->subsystem; 1289 cpl_fn = qpair_ctx->cpl_fn; 1290 cpl_ctx = qpair_ctx->cpl_ctx; 1291 sgroup = &group->sgroups[subsystem->id]; 1292 1293 if (status) { 1294 goto fini; 1295 } 1296 1297 for (nsid = 0; nsid < sgroup->num_ns; nsid++) { 1298 if (sgroup->ns_info[nsid].channel) { 1299 spdk_put_io_channel(sgroup->ns_info[nsid].channel); 1300 sgroup->ns_info[nsid].channel = NULL; 1301 } 1302 } 1303 1304 sgroup->num_ns = 0; 1305 free(sgroup->ns_info); 1306 sgroup->ns_info = NULL; 1307 fini: 1308 free(qpair_ctx); 1309 if (cpl_fn) { 1310 cpl_fn(cpl_ctx, status); 1311 } 1312 } 1313 1314 static void 1315 _nvmf_subsystem_disconnect_next_qpair(void *ctx) 1316 { 1317 struct spdk_nvmf_qpair *qpair; 1318 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 1319 struct spdk_nvmf_subsystem *subsystem; 1320 struct spdk_nvmf_poll_group *group; 1321 int rc = 0; 1322 1323 group = qpair_ctx->group; 1324 subsystem = qpair_ctx->subsystem; 1325 1326 TAILQ_FOREACH(qpair, &group->qpairs, link) { 1327 if ((qpair->ctrlr != NULL) && (qpair->ctrlr->subsys == subsystem)) { 1328 break; 1329 } 1330 } 1331 1332 if (qpair) { 1333 rc = spdk_nvmf_qpair_disconnect(qpair, _nvmf_subsystem_disconnect_next_qpair, qpair_ctx); 1334 } 1335 1336 if (!qpair || rc != 0) { 1337 _nvmf_poll_group_remove_subsystem_cb(ctx, rc); 1338 } 1339 return; 1340 } 1341 1342 void 1343 nvmf_poll_group_remove_subsystem(struct spdk_nvmf_poll_group *group, 1344 struct spdk_nvmf_subsystem *subsystem, 1345 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1346 { 1347 struct spdk_nvmf_qpair *qpair; 1348 struct spdk_nvmf_subsystem_poll_group *sgroup; 1349 struct nvmf_qpair_disconnect_many_ctx *ctx; 1350 int rc = 0; 1351 1352 ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx)); 1353 1354 if (!ctx) { 1355 SPDK_ERRLOG("Unable to allocate memory for context to remove poll subsystem\n"); 1356 goto fini; 1357 } 1358 1359 ctx->group = group; 1360 ctx->subsystem = subsystem; 1361 ctx->cpl_fn = cb_fn; 1362 ctx->cpl_ctx = cb_arg; 1363 1364 sgroup = &group->sgroups[subsystem->id]; 1365 sgroup->state = SPDK_NVMF_SUBSYSTEM_INACTIVE; 1366 1367 TAILQ_FOREACH(qpair, &group->qpairs, link) { 1368 if ((qpair->ctrlr != NULL) && (qpair->ctrlr->subsys == subsystem)) { 1369 break; 1370 } 1371 } 1372 1373 if (qpair) { 1374 rc = spdk_nvmf_qpair_disconnect(qpair, _nvmf_subsystem_disconnect_next_qpair, ctx); 1375 } else { 1376 /* call the callback immediately. It will handle any channel iteration */ 1377 _nvmf_poll_group_remove_subsystem_cb(ctx, 0); 1378 } 1379 1380 if (rc != 0 && rc != -EINPROGRESS) { 1381 free(ctx); 1382 goto fini; 1383 } 1384 1385 return; 1386 fini: 1387 if (cb_fn) { 1388 cb_fn(cb_arg, rc); 1389 } 1390 } 1391 1392 void 1393 nvmf_poll_group_pause_subsystem(struct spdk_nvmf_poll_group *group, 1394 struct spdk_nvmf_subsystem *subsystem, 1395 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1396 { 1397 struct spdk_nvmf_subsystem_poll_group *sgroup; 1398 int rc = 0; 1399 1400 if (subsystem->id >= group->num_sgroups) { 1401 rc = -1; 1402 goto fini; 1403 } 1404 1405 sgroup = &group->sgroups[subsystem->id]; 1406 if (sgroup == NULL) { 1407 rc = -1; 1408 goto fini; 1409 } 1410 1411 if (sgroup->state == SPDK_NVMF_SUBSYSTEM_PAUSED) { 1412 goto fini; 1413 } 1414 sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSING; 1415 1416 if (sgroup->io_outstanding > 0) { 1417 sgroup->cb_fn = cb_fn; 1418 sgroup->cb_arg = cb_arg; 1419 return; 1420 } 1421 1422 assert(sgroup->io_outstanding == 0); 1423 sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSED; 1424 fini: 1425 if (cb_fn) { 1426 cb_fn(cb_arg, rc); 1427 } 1428 } 1429 1430 void 1431 nvmf_poll_group_resume_subsystem(struct spdk_nvmf_poll_group *group, 1432 struct spdk_nvmf_subsystem *subsystem, 1433 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1434 { 1435 struct spdk_nvmf_request *req, *tmp; 1436 struct spdk_nvmf_subsystem_poll_group *sgroup; 1437 int rc = 0; 1438 1439 if (subsystem->id >= group->num_sgroups) { 1440 rc = -1; 1441 goto fini; 1442 } 1443 1444 sgroup = &group->sgroups[subsystem->id]; 1445 1446 if (sgroup->state == SPDK_NVMF_SUBSYSTEM_ACTIVE) { 1447 goto fini; 1448 } 1449 1450 rc = poll_group_update_subsystem(group, subsystem); 1451 if (rc) { 1452 goto fini; 1453 } 1454 1455 sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1456 1457 /* Release all queued requests */ 1458 TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) { 1459 TAILQ_REMOVE(&sgroup->queued, req, link); 1460 spdk_nvmf_request_exec(req); 1461 } 1462 fini: 1463 if (cb_fn) { 1464 cb_fn(cb_arg, rc); 1465 } 1466 } 1467 1468 1469 struct spdk_nvmf_poll_group * 1470 spdk_nvmf_get_optimal_poll_group(struct spdk_nvmf_qpair *qpair) 1471 { 1472 struct spdk_nvmf_transport_poll_group *tgroup; 1473 1474 tgroup = nvmf_transport_get_optimal_poll_group(qpair->transport, qpair); 1475 1476 if (tgroup == NULL) { 1477 return NULL; 1478 } 1479 1480 return tgroup->group; 1481 } 1482 1483 int 1484 spdk_nvmf_poll_group_get_stat(struct spdk_nvmf_tgt *tgt, 1485 struct spdk_nvmf_poll_group_stat *stat) 1486 { 1487 struct spdk_io_channel *ch; 1488 struct spdk_nvmf_poll_group *group; 1489 1490 if (tgt == NULL || stat == NULL) { 1491 return -EINVAL; 1492 } 1493 1494 ch = spdk_get_io_channel(tgt); 1495 group = spdk_io_channel_get_ctx(ch); 1496 *stat = group->stat; 1497 spdk_put_io_channel(ch); 1498 return 0; 1499 } 1500