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/conf.h" 39 #include "spdk/thread.h" 40 #include "spdk/nvmf.h" 41 #include "spdk/trace.h" 42 #include "spdk/endian.h" 43 #include "spdk/string.h" 44 45 #include "spdk/log.h" 46 47 #include "nvmf_internal.h" 48 #include "transport.h" 49 50 SPDK_LOG_REGISTER_COMPONENT(nvmf) 51 52 #define SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS 1024 53 #define SPDK_NVMF_DEFAULT_ACCEPT_POLL_RATE_US 10000 54 55 static TAILQ_HEAD(, spdk_nvmf_tgt) g_nvmf_tgts = TAILQ_HEAD_INITIALIZER(g_nvmf_tgts); 56 57 typedef void (*nvmf_qpair_disconnect_cpl)(void *ctx, int status); 58 static void nvmf_tgt_destroy_poll_group(void *io_device, void *ctx_buf); 59 60 /* supplied to a single call to nvmf_qpair_disconnect */ 61 struct nvmf_qpair_disconnect_ctx { 62 struct spdk_nvmf_qpair *qpair; 63 struct spdk_nvmf_ctrlr *ctrlr; 64 nvmf_qpair_disconnect_cb cb_fn; 65 struct spdk_thread *thread; 66 void *ctx; 67 uint16_t qid; 68 }; 69 70 /* 71 * There are several times when we need to iterate through the list of all qpairs and selectively delete them. 72 * In order to do this sequentially without overlap, we must provide a context to recover the next qpair from 73 * to enable calling nvmf_qpair_disconnect on the next desired qpair. 74 */ 75 struct nvmf_qpair_disconnect_many_ctx { 76 struct spdk_nvmf_subsystem *subsystem; 77 struct spdk_nvmf_poll_group *group; 78 spdk_nvmf_poll_group_mod_done cpl_fn; 79 void *cpl_ctx; 80 }; 81 82 static void 83 nvmf_qpair_set_state(struct spdk_nvmf_qpair *qpair, 84 enum spdk_nvmf_qpair_state state) 85 { 86 assert(qpair != NULL); 87 assert(qpair->group->thread == spdk_get_thread()); 88 89 qpair->state = state; 90 } 91 92 static int 93 nvmf_poll_group_poll(void *ctx) 94 { 95 struct spdk_nvmf_poll_group *group = ctx; 96 int rc; 97 int count = 0; 98 struct spdk_nvmf_transport_poll_group *tgroup; 99 100 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 101 rc = nvmf_transport_poll_group_poll(tgroup); 102 if (rc < 0) { 103 return SPDK_POLLER_BUSY; 104 } 105 count += rc; 106 } 107 108 return count > 0 ? SPDK_POLLER_BUSY : SPDK_POLLER_IDLE; 109 } 110 111 static int 112 nvmf_tgt_create_poll_group(void *io_device, void *ctx_buf) 113 { 114 struct spdk_nvmf_tgt *tgt = io_device; 115 struct spdk_nvmf_poll_group *group = ctx_buf; 116 struct spdk_nvmf_transport *transport; 117 uint32_t sid; 118 119 TAILQ_INIT(&group->tgroups); 120 TAILQ_INIT(&group->qpairs); 121 122 TAILQ_FOREACH(transport, &tgt->transports, link) { 123 nvmf_poll_group_add_transport(group, transport); 124 } 125 126 group->num_sgroups = tgt->max_subsystems; 127 group->sgroups = calloc(tgt->max_subsystems, sizeof(struct spdk_nvmf_subsystem_poll_group)); 128 if (!group->sgroups) { 129 return -ENOMEM; 130 } 131 132 for (sid = 0; sid < tgt->max_subsystems; sid++) { 133 struct spdk_nvmf_subsystem *subsystem; 134 135 subsystem = tgt->subsystems[sid]; 136 if (!subsystem) { 137 continue; 138 } 139 140 if (nvmf_poll_group_add_subsystem(group, subsystem, NULL, NULL) != 0) { 141 nvmf_tgt_destroy_poll_group(io_device, ctx_buf); 142 return -1; 143 } 144 } 145 146 pthread_mutex_lock(&tgt->mutex); 147 TAILQ_INSERT_TAIL(&tgt->poll_groups, group, link); 148 pthread_mutex_unlock(&tgt->mutex); 149 150 group->poller = SPDK_POLLER_REGISTER(nvmf_poll_group_poll, group, 0); 151 group->thread = spdk_get_thread(); 152 153 return 0; 154 } 155 156 static void 157 nvmf_tgt_destroy_poll_group(void *io_device, void *ctx_buf) 158 { 159 struct spdk_nvmf_tgt *tgt = io_device; 160 struct spdk_nvmf_poll_group *group = ctx_buf; 161 struct spdk_nvmf_transport_poll_group *tgroup, *tmp; 162 struct spdk_nvmf_subsystem_poll_group *sgroup; 163 uint32_t sid, nsid; 164 165 pthread_mutex_lock(&tgt->mutex); 166 TAILQ_REMOVE(&tgt->poll_groups, group, link); 167 pthread_mutex_unlock(&tgt->mutex); 168 169 TAILQ_FOREACH_SAFE(tgroup, &group->tgroups, link, tmp) { 170 TAILQ_REMOVE(&group->tgroups, tgroup, link); 171 nvmf_transport_poll_group_destroy(tgroup); 172 } 173 174 for (sid = 0; sid < group->num_sgroups; sid++) { 175 sgroup = &group->sgroups[sid]; 176 177 for (nsid = 0; nsid < sgroup->num_ns; nsid++) { 178 if (sgroup->ns_info[nsid].channel) { 179 spdk_put_io_channel(sgroup->ns_info[nsid].channel); 180 sgroup->ns_info[nsid].channel = NULL; 181 } 182 } 183 184 free(sgroup->ns_info); 185 } 186 187 free(group->sgroups); 188 189 spdk_poller_unregister(&group->poller); 190 191 if (group->destroy_cb_fn) { 192 group->destroy_cb_fn(group->destroy_cb_arg, 0); 193 } 194 } 195 196 static void 197 _nvmf_tgt_disconnect_next_qpair(void *ctx) 198 { 199 struct spdk_nvmf_qpair *qpair; 200 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 201 struct spdk_nvmf_poll_group *group = qpair_ctx->group; 202 struct spdk_io_channel *ch; 203 int rc = 0; 204 205 qpair = TAILQ_FIRST(&group->qpairs); 206 207 if (qpair) { 208 rc = spdk_nvmf_qpair_disconnect(qpair, _nvmf_tgt_disconnect_next_qpair, ctx); 209 } 210 211 if (!qpair || rc != 0) { 212 /* When the refcount from the channels reaches 0, nvmf_tgt_destroy_poll_group will be called. */ 213 ch = spdk_io_channel_from_ctx(group); 214 spdk_put_io_channel(ch); 215 free(qpair_ctx); 216 } 217 } 218 219 static void 220 nvmf_tgt_destroy_poll_group_qpairs(struct spdk_nvmf_poll_group *group) 221 { 222 struct nvmf_qpair_disconnect_many_ctx *ctx; 223 224 ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx)); 225 226 if (!ctx) { 227 SPDK_ERRLOG("Failed to allocate memory for destroy poll group ctx\n"); 228 return; 229 } 230 231 ctx->group = group; 232 _nvmf_tgt_disconnect_next_qpair(ctx); 233 } 234 235 static int 236 nvmf_tgt_accept(void *ctx) 237 { 238 struct spdk_nvmf_tgt *tgt = ctx; 239 struct spdk_nvmf_transport *transport, *tmp; 240 int count = 0; 241 242 TAILQ_FOREACH_SAFE(transport, &tgt->transports, link, tmp) { 243 count += nvmf_transport_accept(transport); 244 } 245 246 return count; 247 } 248 249 struct spdk_nvmf_tgt * 250 spdk_nvmf_tgt_create(struct spdk_nvmf_target_opts *opts) 251 { 252 struct spdk_nvmf_tgt *tgt, *tmp_tgt; 253 uint32_t acceptor_poll_rate; 254 255 if (strnlen(opts->name, NVMF_TGT_NAME_MAX_LENGTH) == NVMF_TGT_NAME_MAX_LENGTH) { 256 SPDK_ERRLOG("Provided target name exceeds the max length of %u.\n", NVMF_TGT_NAME_MAX_LENGTH); 257 return NULL; 258 } 259 260 TAILQ_FOREACH(tmp_tgt, &g_nvmf_tgts, link) { 261 if (!strncmp(opts->name, tmp_tgt->name, NVMF_TGT_NAME_MAX_LENGTH)) { 262 SPDK_ERRLOG("Provided target name must be unique.\n"); 263 return NULL; 264 } 265 } 266 267 tgt = calloc(1, sizeof(*tgt)); 268 if (!tgt) { 269 return NULL; 270 } 271 272 snprintf(tgt->name, NVMF_TGT_NAME_MAX_LENGTH, "%s", opts->name); 273 274 if (!opts || !opts->max_subsystems) { 275 tgt->max_subsystems = SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS; 276 } else { 277 tgt->max_subsystems = opts->max_subsystems; 278 } 279 280 if (!opts || !opts->acceptor_poll_rate) { 281 acceptor_poll_rate = SPDK_NVMF_DEFAULT_ACCEPT_POLL_RATE_US; 282 } else { 283 acceptor_poll_rate = opts->acceptor_poll_rate; 284 } 285 286 tgt->discovery_genctr = 0; 287 TAILQ_INIT(&tgt->transports); 288 TAILQ_INIT(&tgt->poll_groups); 289 290 tgt->subsystems = calloc(tgt->max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); 291 if (!tgt->subsystems) { 292 free(tgt); 293 return NULL; 294 } 295 296 pthread_mutex_init(&tgt->mutex, NULL); 297 298 tgt->accept_poller = SPDK_POLLER_REGISTER(nvmf_tgt_accept, tgt, acceptor_poll_rate); 299 if (!tgt->accept_poller) { 300 pthread_mutex_destroy(&tgt->mutex); 301 free(tgt->subsystems); 302 free(tgt); 303 return NULL; 304 } 305 306 spdk_io_device_register(tgt, 307 nvmf_tgt_create_poll_group, 308 nvmf_tgt_destroy_poll_group, 309 sizeof(struct spdk_nvmf_poll_group), 310 tgt->name); 311 312 TAILQ_INSERT_HEAD(&g_nvmf_tgts, tgt, link); 313 314 return tgt; 315 } 316 317 static void 318 nvmf_tgt_destroy_cb(void *io_device) 319 { 320 struct spdk_nvmf_tgt *tgt = io_device; 321 struct spdk_nvmf_transport *transport, *transport_tmp; 322 spdk_nvmf_tgt_destroy_done_fn *destroy_cb_fn; 323 void *destroy_cb_arg; 324 uint32_t i; 325 326 if (tgt->subsystems) { 327 for (i = 0; i < tgt->max_subsystems; i++) { 328 if (tgt->subsystems[i]) { 329 nvmf_subsystem_remove_all_listeners(tgt->subsystems[i], true); 330 spdk_nvmf_subsystem_destroy(tgt->subsystems[i]); 331 } 332 } 333 free(tgt->subsystems); 334 } 335 336 TAILQ_FOREACH_SAFE(transport, &tgt->transports, link, transport_tmp) { 337 TAILQ_REMOVE(&tgt->transports, transport, link); 338 spdk_nvmf_transport_destroy(transport); 339 } 340 341 destroy_cb_fn = tgt->destroy_cb_fn; 342 destroy_cb_arg = tgt->destroy_cb_arg; 343 344 pthread_mutex_destroy(&tgt->mutex); 345 free(tgt); 346 347 if (destroy_cb_fn) { 348 destroy_cb_fn(destroy_cb_arg, 0); 349 } 350 } 351 352 void 353 spdk_nvmf_tgt_destroy(struct spdk_nvmf_tgt *tgt, 354 spdk_nvmf_tgt_destroy_done_fn cb_fn, 355 void *cb_arg) 356 { 357 tgt->destroy_cb_fn = cb_fn; 358 tgt->destroy_cb_arg = cb_arg; 359 360 spdk_poller_unregister(&tgt->accept_poller); 361 362 TAILQ_REMOVE(&g_nvmf_tgts, tgt, link); 363 364 spdk_io_device_unregister(tgt, nvmf_tgt_destroy_cb); 365 } 366 367 const char * 368 spdk_nvmf_tgt_get_name(struct spdk_nvmf_tgt *tgt) 369 { 370 return tgt->name; 371 } 372 373 struct spdk_nvmf_tgt * 374 spdk_nvmf_get_tgt(const char *name) 375 { 376 struct spdk_nvmf_tgt *tgt; 377 uint32_t num_targets = 0; 378 379 TAILQ_FOREACH(tgt, &g_nvmf_tgts, link) { 380 if (name) { 381 if (!strncmp(tgt->name, name, NVMF_TGT_NAME_MAX_LENGTH)) { 382 return tgt; 383 } 384 } 385 num_targets++; 386 } 387 388 /* 389 * special case. If there is only one target and 390 * no name was specified, return the only available 391 * target. If there is more than one target, name must 392 * be specified. 393 */ 394 if (!name && num_targets == 1) { 395 return TAILQ_FIRST(&g_nvmf_tgts); 396 } 397 398 return NULL; 399 } 400 401 struct spdk_nvmf_tgt * 402 spdk_nvmf_get_first_tgt(void) 403 { 404 return TAILQ_FIRST(&g_nvmf_tgts); 405 } 406 407 struct spdk_nvmf_tgt * 408 spdk_nvmf_get_next_tgt(struct spdk_nvmf_tgt *prev) 409 { 410 return TAILQ_NEXT(prev, link); 411 } 412 413 static void 414 nvmf_write_subsystem_config_json(struct spdk_json_write_ctx *w, 415 struct spdk_nvmf_subsystem *subsystem) 416 { 417 struct spdk_nvmf_host *host; 418 struct spdk_nvmf_subsystem_listener *listener; 419 const struct spdk_nvme_transport_id *trid; 420 struct spdk_nvmf_ns *ns; 421 struct spdk_nvmf_ns_opts ns_opts; 422 uint32_t max_namespaces; 423 char uuid_str[SPDK_UUID_STRING_LEN]; 424 const char *adrfam; 425 426 if (spdk_nvmf_subsystem_get_type(subsystem) != SPDK_NVMF_SUBTYPE_NVME) { 427 return; 428 } 429 430 /* { */ 431 spdk_json_write_object_begin(w); 432 spdk_json_write_named_string(w, "method", "nvmf_create_subsystem"); 433 434 /* "params" : { */ 435 spdk_json_write_named_object_begin(w, "params"); 436 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 437 spdk_json_write_named_bool(w, "allow_any_host", spdk_nvmf_subsystem_get_allow_any_host(subsystem)); 438 spdk_json_write_named_string(w, "serial_number", spdk_nvmf_subsystem_get_sn(subsystem)); 439 spdk_json_write_named_string(w, "model_number", spdk_nvmf_subsystem_get_mn(subsystem)); 440 441 max_namespaces = spdk_nvmf_subsystem_get_max_namespaces(subsystem); 442 if (max_namespaces != 0) { 443 spdk_json_write_named_uint32(w, "max_namespaces", max_namespaces); 444 } 445 446 /* } "params" */ 447 spdk_json_write_object_end(w); 448 449 /* } */ 450 spdk_json_write_object_end(w); 451 452 for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL; 453 listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) { 454 trid = spdk_nvmf_subsystem_listener_get_trid(listener); 455 456 adrfam = spdk_nvme_transport_id_adrfam_str(trid->adrfam); 457 458 spdk_json_write_object_begin(w); 459 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_listener"); 460 461 /* "params" : { */ 462 spdk_json_write_named_object_begin(w, "params"); 463 464 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 465 466 /* "listen_address" : { */ 467 spdk_json_write_named_object_begin(w, "listen_address"); 468 469 spdk_json_write_named_string(w, "trtype", trid->trstring); 470 if (adrfam) { 471 spdk_json_write_named_string(w, "adrfam", adrfam); 472 } 473 474 spdk_json_write_named_string(w, "traddr", trid->traddr); 475 spdk_json_write_named_string(w, "trsvcid", trid->trsvcid); 476 /* } "listen_address" */ 477 spdk_json_write_object_end(w); 478 479 /* } "params" */ 480 spdk_json_write_object_end(w); 481 482 /* } */ 483 spdk_json_write_object_end(w); 484 } 485 486 for (host = spdk_nvmf_subsystem_get_first_host(subsystem); host != NULL; 487 host = spdk_nvmf_subsystem_get_next_host(subsystem, host)) { 488 489 spdk_json_write_object_begin(w); 490 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_host"); 491 492 /* "params" : { */ 493 spdk_json_write_named_object_begin(w, "params"); 494 495 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 496 spdk_json_write_named_string(w, "host", spdk_nvmf_host_get_nqn(host)); 497 498 /* } "params" */ 499 spdk_json_write_object_end(w); 500 501 /* } */ 502 spdk_json_write_object_end(w); 503 } 504 505 for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); ns != NULL; 506 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) { 507 spdk_nvmf_ns_get_opts(ns, &ns_opts, sizeof(ns_opts)); 508 509 spdk_json_write_object_begin(w); 510 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_ns"); 511 512 /* "params" : { */ 513 spdk_json_write_named_object_begin(w, "params"); 514 515 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 516 517 /* "namespace" : { */ 518 spdk_json_write_named_object_begin(w, "namespace"); 519 520 spdk_json_write_named_uint32(w, "nsid", spdk_nvmf_ns_get_id(ns)); 521 spdk_json_write_named_string(w, "bdev_name", spdk_bdev_get_name(spdk_nvmf_ns_get_bdev(ns))); 522 523 if (!spdk_mem_all_zero(ns_opts.nguid, sizeof(ns_opts.nguid))) { 524 SPDK_STATIC_ASSERT(sizeof(ns_opts.nguid) == sizeof(uint64_t) * 2, "size mismatch"); 525 spdk_json_write_named_string_fmt(w, "nguid", "%016"PRIX64"%016"PRIX64, from_be64(&ns_opts.nguid[0]), 526 from_be64(&ns_opts.nguid[8])); 527 } 528 529 if (!spdk_mem_all_zero(ns_opts.eui64, sizeof(ns_opts.eui64))) { 530 SPDK_STATIC_ASSERT(sizeof(ns_opts.eui64) == sizeof(uint64_t), "size mismatch"); 531 spdk_json_write_named_string_fmt(w, "eui64", "%016"PRIX64, from_be64(&ns_opts.eui64)); 532 } 533 534 if (!spdk_mem_all_zero(&ns_opts.uuid, sizeof(ns_opts.uuid))) { 535 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &ns_opts.uuid); 536 spdk_json_write_named_string(w, "uuid", uuid_str); 537 } 538 539 /* "namespace" */ 540 spdk_json_write_object_end(w); 541 542 /* } "params" */ 543 spdk_json_write_object_end(w); 544 545 /* } */ 546 spdk_json_write_object_end(w); 547 } 548 } 549 550 void 551 spdk_nvmf_tgt_write_config_json(struct spdk_json_write_ctx *w, struct spdk_nvmf_tgt *tgt) 552 { 553 struct spdk_nvmf_subsystem *subsystem; 554 struct spdk_nvmf_transport *transport; 555 556 spdk_json_write_object_begin(w); 557 spdk_json_write_named_string(w, "method", "nvmf_set_max_subsystems"); 558 559 spdk_json_write_named_object_begin(w, "params"); 560 spdk_json_write_named_uint32(w, "max_subsystems", tgt->max_subsystems); 561 spdk_json_write_object_end(w); 562 563 spdk_json_write_object_end(w); 564 565 /* write transports */ 566 TAILQ_FOREACH(transport, &tgt->transports, link) { 567 spdk_json_write_object_begin(w); 568 spdk_json_write_named_string(w, "method", "nvmf_create_transport"); 569 570 spdk_json_write_named_object_begin(w, "params"); 571 spdk_json_write_named_string(w, "trtype", spdk_nvme_transport_id_trtype_str(transport->ops->type)); 572 spdk_json_write_named_uint32(w, "max_queue_depth", transport->opts.max_queue_depth); 573 spdk_json_write_named_uint32(w, "max_io_qpairs_per_ctrlr", 574 transport->opts.max_qpairs_per_ctrlr - 1); 575 spdk_json_write_named_uint32(w, "in_capsule_data_size", transport->opts.in_capsule_data_size); 576 spdk_json_write_named_uint32(w, "max_io_size", transport->opts.max_io_size); 577 spdk_json_write_named_uint32(w, "io_unit_size", transport->opts.io_unit_size); 578 spdk_json_write_named_uint32(w, "max_aq_depth", transport->opts.max_aq_depth); 579 if (transport->ops->type == SPDK_NVME_TRANSPORT_RDMA) { 580 spdk_json_write_named_uint32(w, "max_srq_depth", transport->opts.max_srq_depth); 581 } 582 spdk_json_write_named_uint32(w, "abort_timeout_sec", transport->opts.abort_timeout_sec); 583 spdk_json_write_object_end(w); 584 585 spdk_json_write_object_end(w); 586 } 587 588 subsystem = spdk_nvmf_subsystem_get_first(tgt); 589 while (subsystem) { 590 nvmf_write_subsystem_config_json(w, subsystem); 591 subsystem = spdk_nvmf_subsystem_get_next(subsystem); 592 } 593 } 594 595 int 596 spdk_nvmf_tgt_listen(struct spdk_nvmf_tgt *tgt, 597 struct spdk_nvme_transport_id *trid) 598 { 599 struct spdk_nvmf_transport *transport; 600 const char *trtype; 601 int rc; 602 603 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 604 if (!transport) { 605 trtype = spdk_nvme_transport_id_trtype_str(trid->trtype); 606 if (trtype != NULL) { 607 SPDK_ERRLOG("Unable to listen on transport %s. The transport must be created first.\n", trtype); 608 } else { 609 SPDK_ERRLOG("The specified trtype %d is unknown. Please make sure that it is properly registered.\n", 610 trid->trtype); 611 } 612 613 return -EINVAL; 614 } 615 616 rc = spdk_nvmf_transport_listen(transport, trid); 617 if (rc < 0) { 618 SPDK_ERRLOG("Unable to listen on address '%s'\n", trid->traddr); 619 } 620 621 return rc; 622 } 623 624 int 625 spdk_nvmf_tgt_stop_listen(struct spdk_nvmf_tgt *tgt, 626 struct spdk_nvme_transport_id *trid) 627 { 628 struct spdk_nvmf_transport *transport; 629 const char *trtype; 630 int rc; 631 632 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 633 if (!transport) { 634 trtype = spdk_nvme_transport_id_trtype_str(trid->trtype); 635 if (trtype != NULL) { 636 SPDK_ERRLOG("Unable to stop listen on transport %s. The transport must be created first.\n", 637 trtype); 638 } else { 639 SPDK_ERRLOG("The specified trtype %d is unknown. Please make sure that it is properly registered.\n", 640 trid->trtype); 641 } 642 return -EINVAL; 643 } 644 645 rc = spdk_nvmf_transport_stop_listen(transport, trid); 646 if (rc < 0) { 647 SPDK_ERRLOG("Failed to stop listening on address '%s'\n", trid->traddr); 648 return rc; 649 } 650 return 0; 651 } 652 653 struct spdk_nvmf_tgt_add_transport_ctx { 654 struct spdk_nvmf_tgt *tgt; 655 struct spdk_nvmf_transport *transport; 656 spdk_nvmf_tgt_add_transport_done_fn cb_fn; 657 void *cb_arg; 658 }; 659 660 static void 661 _nvmf_tgt_add_transport_done(struct spdk_io_channel_iter *i, int status) 662 { 663 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 664 665 ctx->cb_fn(ctx->cb_arg, status); 666 667 free(ctx); 668 } 669 670 static void 671 _nvmf_tgt_add_transport(struct spdk_io_channel_iter *i) 672 { 673 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 674 struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i); 675 struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch); 676 int rc; 677 678 rc = nvmf_poll_group_add_transport(group, ctx->transport); 679 spdk_for_each_channel_continue(i, rc); 680 } 681 682 void spdk_nvmf_tgt_add_transport(struct spdk_nvmf_tgt *tgt, 683 struct spdk_nvmf_transport *transport, 684 spdk_nvmf_tgt_add_transport_done_fn cb_fn, 685 void *cb_arg) 686 { 687 struct spdk_nvmf_tgt_add_transport_ctx *ctx; 688 689 if (spdk_nvmf_tgt_get_transport(tgt, transport->ops->name)) { 690 cb_fn(cb_arg, -EEXIST); 691 return; /* transport already created */ 692 } 693 694 transport->tgt = tgt; 695 TAILQ_INSERT_TAIL(&tgt->transports, transport, link); 696 697 ctx = calloc(1, sizeof(*ctx)); 698 if (!ctx) { 699 cb_fn(cb_arg, -ENOMEM); 700 return; 701 } 702 703 ctx->tgt = tgt; 704 ctx->transport = transport; 705 ctx->cb_fn = cb_fn; 706 ctx->cb_arg = cb_arg; 707 708 spdk_for_each_channel(tgt, 709 _nvmf_tgt_add_transport, 710 ctx, 711 _nvmf_tgt_add_transport_done); 712 } 713 714 struct spdk_nvmf_subsystem * 715 spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) 716 { 717 struct spdk_nvmf_subsystem *subsystem; 718 uint32_t sid; 719 720 if (!subnqn) { 721 return NULL; 722 } 723 724 /* Ensure that subnqn is null terminated */ 725 if (!memchr(subnqn, '\0', SPDK_NVMF_NQN_MAX_LEN + 1)) { 726 SPDK_ERRLOG("Connect SUBNQN is not null terminated\n"); 727 return NULL; 728 } 729 730 for (sid = 0; sid < tgt->max_subsystems; sid++) { 731 subsystem = tgt->subsystems[sid]; 732 if (subsystem == NULL) { 733 continue; 734 } 735 736 if (strcmp(subnqn, subsystem->subnqn) == 0) { 737 return subsystem; 738 } 739 } 740 741 return NULL; 742 } 743 744 struct spdk_nvmf_transport * 745 spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name) 746 { 747 struct spdk_nvmf_transport *transport; 748 749 TAILQ_FOREACH(transport, &tgt->transports, link) { 750 if (!strncasecmp(transport->ops->name, transport_name, SPDK_NVMF_TRSTRING_MAX_LEN)) { 751 return transport; 752 } 753 } 754 return NULL; 755 } 756 757 struct nvmf_new_qpair_ctx { 758 struct spdk_nvmf_qpair *qpair; 759 struct spdk_nvmf_poll_group *group; 760 }; 761 762 static void 763 _nvmf_poll_group_add(void *_ctx) 764 { 765 struct nvmf_new_qpair_ctx *ctx = _ctx; 766 struct spdk_nvmf_qpair *qpair = ctx->qpair; 767 struct spdk_nvmf_poll_group *group = ctx->group; 768 769 free(_ctx); 770 771 if (spdk_nvmf_poll_group_add(group, qpair) != 0) { 772 SPDK_ERRLOG("Unable to add the qpair to a poll group.\n"); 773 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 774 } 775 } 776 777 void 778 spdk_nvmf_tgt_new_qpair(struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair) 779 { 780 struct spdk_nvmf_poll_group *group; 781 struct nvmf_new_qpair_ctx *ctx; 782 783 group = spdk_nvmf_get_optimal_poll_group(qpair); 784 if (group == NULL) { 785 if (tgt->next_poll_group == NULL) { 786 tgt->next_poll_group = TAILQ_FIRST(&tgt->poll_groups); 787 if (tgt->next_poll_group == NULL) { 788 SPDK_ERRLOG("No poll groups exist.\n"); 789 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 790 return; 791 } 792 } 793 group = tgt->next_poll_group; 794 tgt->next_poll_group = TAILQ_NEXT(group, link); 795 } 796 797 ctx = calloc(1, sizeof(*ctx)); 798 if (!ctx) { 799 SPDK_ERRLOG("Unable to send message to poll group.\n"); 800 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 801 return; 802 } 803 804 ctx->qpair = qpair; 805 ctx->group = group; 806 807 spdk_thread_send_msg(group->thread, _nvmf_poll_group_add, ctx); 808 } 809 810 struct spdk_nvmf_poll_group * 811 spdk_nvmf_poll_group_create(struct spdk_nvmf_tgt *tgt) 812 { 813 struct spdk_io_channel *ch; 814 815 ch = spdk_get_io_channel(tgt); 816 if (!ch) { 817 SPDK_ERRLOG("Unable to get I/O channel for target\n"); 818 return NULL; 819 } 820 821 return spdk_io_channel_get_ctx(ch); 822 } 823 824 void 825 spdk_nvmf_poll_group_destroy(struct spdk_nvmf_poll_group *group, 826 spdk_nvmf_poll_group_destroy_done_fn cb_fn, 827 void *cb_arg) 828 { 829 assert(group->destroy_cb_fn == NULL); 830 group->destroy_cb_fn = cb_fn; 831 group->destroy_cb_arg = cb_arg; 832 833 /* This function will put the io_channel associated with this poll group */ 834 nvmf_tgt_destroy_poll_group_qpairs(group); 835 } 836 837 int 838 spdk_nvmf_poll_group_add(struct spdk_nvmf_poll_group *group, 839 struct spdk_nvmf_qpair *qpair) 840 { 841 int rc = -1; 842 struct spdk_nvmf_transport_poll_group *tgroup; 843 844 TAILQ_INIT(&qpair->outstanding); 845 qpair->group = group; 846 qpair->ctrlr = NULL; 847 qpair->disconnect_started = false; 848 849 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 850 if (tgroup->transport == qpair->transport) { 851 rc = nvmf_transport_poll_group_add(tgroup, qpair); 852 break; 853 } 854 } 855 856 /* We add the qpair to the group only it is succesfully added into the tgroup */ 857 if (rc == 0) { 858 TAILQ_INSERT_TAIL(&group->qpairs, qpair, link); 859 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ACTIVE); 860 } 861 862 return rc; 863 } 864 865 static void 866 _nvmf_ctrlr_destruct(void *ctx) 867 { 868 struct spdk_nvmf_ctrlr *ctrlr = ctx; 869 870 nvmf_ctrlr_destruct(ctrlr); 871 } 872 873 static void 874 _nvmf_transport_qpair_fini(void *ctx) 875 { 876 struct spdk_nvmf_qpair *qpair = ctx; 877 878 nvmf_transport_qpair_fini(qpair); 879 } 880 881 static void 882 _nvmf_ctrlr_free_from_qpair(void *ctx) 883 { 884 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 885 struct spdk_nvmf_ctrlr *ctrlr = qpair_ctx->ctrlr; 886 uint32_t count; 887 888 spdk_bit_array_clear(ctrlr->qpair_mask, qpair_ctx->qid); 889 count = spdk_bit_array_count_set(ctrlr->qpair_mask); 890 if (count == 0) { 891 ctrlr->in_destruct = true; 892 spdk_thread_send_msg(ctrlr->subsys->thread, _nvmf_ctrlr_destruct, ctrlr); 893 } 894 895 spdk_thread_send_msg(qpair_ctx->thread, _nvmf_transport_qpair_fini, qpair_ctx->qpair); 896 if (qpair_ctx->cb_fn) { 897 spdk_thread_send_msg(qpair_ctx->thread, qpair_ctx->cb_fn, qpair_ctx->ctx); 898 } 899 free(qpair_ctx); 900 } 901 902 void 903 spdk_nvmf_poll_group_remove(struct spdk_nvmf_qpair *qpair) 904 { 905 struct spdk_nvmf_ctrlr *ctrlr = qpair->ctrlr; 906 struct spdk_nvmf_transport_poll_group *tgroup; 907 struct spdk_nvmf_request *req, *tmp; 908 struct spdk_nvmf_subsystem_poll_group *sgroup; 909 int rc; 910 911 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ERROR); 912 913 /* Find the tgroup and remove the qpair from the tgroup */ 914 TAILQ_FOREACH(tgroup, &qpair->group->tgroups, link) { 915 if (tgroup->transport == qpair->transport) { 916 rc = nvmf_transport_poll_group_remove(tgroup, qpair); 917 if (rc && (rc != ENOTSUP)) { 918 SPDK_ERRLOG("Cannot remove qpair=%p from transport group=%p\n", 919 qpair, tgroup); 920 } 921 break; 922 } 923 } 924 925 if (ctrlr) { 926 sgroup = &qpair->group->sgroups[ctrlr->subsys->id]; 927 TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) { 928 if (req->qpair == qpair) { 929 TAILQ_REMOVE(&sgroup->queued, req, link); 930 if (nvmf_transport_req_free(req)) { 931 SPDK_ERRLOG("Transport request free error!\n"); 932 } 933 } 934 } 935 } 936 937 TAILQ_REMOVE(&qpair->group->qpairs, qpair, link); 938 qpair->group = NULL; 939 } 940 941 static void 942 _nvmf_qpair_destroy(void *ctx, int status) 943 { 944 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 945 struct spdk_nvmf_qpair *qpair = qpair_ctx->qpair; 946 struct spdk_nvmf_ctrlr *ctrlr = qpair->ctrlr; 947 948 assert(qpair->state == SPDK_NVMF_QPAIR_DEACTIVATING); 949 qpair_ctx->qid = qpair->qid; 950 951 spdk_nvmf_poll_group_remove(qpair); 952 953 if (!ctrlr || !ctrlr->thread) { 954 nvmf_transport_qpair_fini(qpair); 955 if (qpair_ctx->cb_fn) { 956 spdk_thread_send_msg(qpair_ctx->thread, qpair_ctx->cb_fn, qpair_ctx->ctx); 957 } 958 free(qpair_ctx); 959 return; 960 } 961 962 qpair_ctx->ctrlr = ctrlr; 963 spdk_thread_send_msg(ctrlr->thread, _nvmf_ctrlr_free_from_qpair, qpair_ctx); 964 } 965 966 static void 967 _nvmf_qpair_disconnect_msg(void *ctx) 968 { 969 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 970 971 spdk_nvmf_qpair_disconnect(qpair_ctx->qpair, qpair_ctx->cb_fn, qpair_ctx->ctx); 972 free(ctx); 973 } 974 975 int 976 spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) 977 { 978 struct nvmf_qpair_disconnect_ctx *qpair_ctx; 979 980 if (__atomic_test_and_set(&qpair->disconnect_started, __ATOMIC_RELAXED)) { 981 if (cb_fn) { 982 cb_fn(ctx); 983 } 984 return 0; 985 } 986 987 /* If we get a qpair in the uninitialized state, we can just destroy it immediately */ 988 if (qpair->state == SPDK_NVMF_QPAIR_UNINITIALIZED) { 989 nvmf_transport_qpair_fini(qpair); 990 if (cb_fn) { 991 cb_fn(ctx); 992 } 993 return 0; 994 } 995 996 assert(qpair->group != NULL); 997 if (spdk_get_thread() != qpair->group->thread) { 998 /* clear the atomic so we can set it on the next call on the proper thread. */ 999 __atomic_clear(&qpair->disconnect_started, __ATOMIC_RELAXED); 1000 qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx)); 1001 if (!qpair_ctx) { 1002 SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n"); 1003 return -ENOMEM; 1004 } 1005 qpair_ctx->qpair = qpair; 1006 qpair_ctx->cb_fn = cb_fn; 1007 qpair_ctx->thread = qpair->group->thread; 1008 qpair_ctx->ctx = ctx; 1009 spdk_thread_send_msg(qpair->group->thread, _nvmf_qpair_disconnect_msg, qpair_ctx); 1010 return 0; 1011 } 1012 1013 assert(qpair->state == SPDK_NVMF_QPAIR_ACTIVE); 1014 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_DEACTIVATING); 1015 1016 qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx)); 1017 if (!qpair_ctx) { 1018 SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n"); 1019 return -ENOMEM; 1020 } 1021 1022 qpair_ctx->qpair = qpair; 1023 qpair_ctx->cb_fn = cb_fn; 1024 qpair_ctx->thread = qpair->group->thread; 1025 qpair_ctx->ctx = ctx; 1026 1027 /* Check for outstanding I/O */ 1028 if (!TAILQ_EMPTY(&qpair->outstanding)) { 1029 qpair->state_cb = _nvmf_qpair_destroy; 1030 qpair->state_cb_arg = qpair_ctx; 1031 nvmf_qpair_free_aer(qpair); 1032 return 0; 1033 } 1034 1035 _nvmf_qpair_destroy(qpair_ctx, 0); 1036 1037 return 0; 1038 } 1039 1040 int 1041 spdk_nvmf_qpair_get_peer_trid(struct spdk_nvmf_qpair *qpair, 1042 struct spdk_nvme_transport_id *trid) 1043 { 1044 return nvmf_transport_qpair_get_peer_trid(qpair, trid); 1045 } 1046 1047 int 1048 spdk_nvmf_qpair_get_local_trid(struct spdk_nvmf_qpair *qpair, 1049 struct spdk_nvme_transport_id *trid) 1050 { 1051 return nvmf_transport_qpair_get_local_trid(qpair, trid); 1052 } 1053 1054 int 1055 spdk_nvmf_qpair_get_listen_trid(struct spdk_nvmf_qpair *qpair, 1056 struct spdk_nvme_transport_id *trid) 1057 { 1058 return nvmf_transport_qpair_get_listen_trid(qpair, trid); 1059 } 1060 1061 int 1062 nvmf_poll_group_add_transport(struct spdk_nvmf_poll_group *group, 1063 struct spdk_nvmf_transport *transport) 1064 { 1065 struct spdk_nvmf_transport_poll_group *tgroup; 1066 1067 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 1068 if (tgroup->transport == transport) { 1069 /* Transport already in the poll group */ 1070 return 0; 1071 } 1072 } 1073 1074 tgroup = nvmf_transport_poll_group_create(transport); 1075 if (!tgroup) { 1076 SPDK_ERRLOG("Unable to create poll group for transport\n"); 1077 return -1; 1078 } 1079 1080 tgroup->group = group; 1081 TAILQ_INSERT_TAIL(&group->tgroups, tgroup, link); 1082 1083 return 0; 1084 } 1085 1086 static int 1087 poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 1088 struct spdk_nvmf_subsystem *subsystem) 1089 { 1090 struct spdk_nvmf_subsystem_poll_group *sgroup; 1091 uint32_t new_num_ns, old_num_ns; 1092 uint32_t i, j; 1093 struct spdk_nvmf_ns *ns; 1094 struct spdk_nvmf_registrant *reg, *tmp; 1095 struct spdk_io_channel *ch; 1096 struct spdk_nvmf_subsystem_pg_ns_info *ns_info; 1097 struct spdk_nvmf_ctrlr *ctrlr; 1098 bool ns_changed; 1099 1100 /* Make sure our poll group has memory for this subsystem allocated */ 1101 if (subsystem->id >= group->num_sgroups) { 1102 return -ENOMEM; 1103 } 1104 1105 sgroup = &group->sgroups[subsystem->id]; 1106 1107 /* Make sure the array of namespace information is the correct size */ 1108 new_num_ns = subsystem->max_nsid; 1109 old_num_ns = sgroup->num_ns; 1110 1111 ns_changed = false; 1112 1113 if (old_num_ns == 0) { 1114 if (new_num_ns > 0) { 1115 /* First allocation */ 1116 sgroup->ns_info = calloc(new_num_ns, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1117 if (!sgroup->ns_info) { 1118 return -ENOMEM; 1119 } 1120 } 1121 } else if (new_num_ns > old_num_ns) { 1122 void *buf; 1123 1124 /* Make the array larger */ 1125 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1126 if (!buf) { 1127 return -ENOMEM; 1128 } 1129 1130 sgroup->ns_info = buf; 1131 1132 /* Null out the new namespace information slots */ 1133 for (i = old_num_ns; i < new_num_ns; i++) { 1134 memset(&sgroup->ns_info[i], 0, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1135 } 1136 } else if (new_num_ns < old_num_ns) { 1137 void *buf; 1138 1139 /* Free the extra I/O channels */ 1140 for (i = new_num_ns; i < old_num_ns; i++) { 1141 ns_info = &sgroup->ns_info[i]; 1142 1143 if (ns_info->channel) { 1144 spdk_put_io_channel(ns_info->channel); 1145 ns_info->channel = NULL; 1146 } 1147 } 1148 1149 /* Make the array smaller */ 1150 if (new_num_ns > 0) { 1151 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1152 if (!buf) { 1153 return -ENOMEM; 1154 } 1155 sgroup->ns_info = buf; 1156 } else { 1157 free(sgroup->ns_info); 1158 sgroup->ns_info = NULL; 1159 } 1160 } 1161 1162 sgroup->num_ns = new_num_ns; 1163 1164 /* Detect bdevs that were added or removed */ 1165 for (i = 0; i < sgroup->num_ns; i++) { 1166 ns = subsystem->ns[i]; 1167 ns_info = &sgroup->ns_info[i]; 1168 ch = ns_info->channel; 1169 1170 if (ns == NULL && ch == NULL) { 1171 /* Both NULL. Leave empty */ 1172 } else if (ns == NULL && ch != NULL) { 1173 /* There was a channel here, but the namespace is gone. */ 1174 ns_changed = true; 1175 spdk_put_io_channel(ch); 1176 ns_info->channel = NULL; 1177 } else if (ns != NULL && ch == NULL) { 1178 /* A namespace appeared but there is no channel yet */ 1179 ns_changed = true; 1180 ch = spdk_bdev_get_io_channel(ns->desc); 1181 if (ch == NULL) { 1182 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1183 return -ENOMEM; 1184 } 1185 ns_info->channel = ch; 1186 } else if (spdk_uuid_compare(&ns_info->uuid, spdk_bdev_get_uuid(ns->bdev)) != 0) { 1187 /* A namespace was here before, but was replaced by a new one. */ 1188 ns_changed = true; 1189 spdk_put_io_channel(ns_info->channel); 1190 memset(ns_info, 0, sizeof(*ns_info)); 1191 1192 ch = spdk_bdev_get_io_channel(ns->desc); 1193 if (ch == NULL) { 1194 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1195 return -ENOMEM; 1196 } 1197 ns_info->channel = ch; 1198 } else if (ns_info->num_blocks != spdk_bdev_get_num_blocks(ns->bdev)) { 1199 /* Namespace is still there but size has changed */ 1200 SPDK_DEBUGLOG(nvmf, "Namespace resized: subsystem_id %d," 1201 " nsid %u, pg %p, old %lu, new %lu\n", 1202 subsystem->id, 1203 ns->nsid, 1204 group, 1205 ns_info->num_blocks, 1206 spdk_bdev_get_num_blocks(ns->bdev)); 1207 ns_changed = true; 1208 } 1209 1210 if (ns == NULL) { 1211 memset(ns_info, 0, sizeof(*ns_info)); 1212 } else { 1213 ns_info->uuid = *spdk_bdev_get_uuid(ns->bdev); 1214 ns_info->num_blocks = spdk_bdev_get_num_blocks(ns->bdev); 1215 ns_info->crkey = ns->crkey; 1216 ns_info->rtype = ns->rtype; 1217 if (ns->holder) { 1218 ns_info->holder_id = ns->holder->hostid; 1219 } 1220 1221 memset(&ns_info->reg_hostid, 0, SPDK_NVMF_MAX_NUM_REGISTRANTS * sizeof(struct spdk_uuid)); 1222 j = 0; 1223 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 1224 if (j >= SPDK_NVMF_MAX_NUM_REGISTRANTS) { 1225 SPDK_ERRLOG("Maximum %u registrants can support.\n", SPDK_NVMF_MAX_NUM_REGISTRANTS); 1226 return -EINVAL; 1227 } 1228 ns_info->reg_hostid[j++] = reg->hostid; 1229 } 1230 } 1231 } 1232 1233 if (ns_changed) { 1234 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1235 if (ctrlr->admin_qpair->group == group) { 1236 nvmf_ctrlr_async_event_ns_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