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_internal/log.h" 46 47 #include "nvmf_internal.h" 48 #include "transport.h" 49 50 SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) 51 52 #define SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS 1024 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 spdk_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 spdk_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 spdk_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 = spdk_nvmf_transport_poll_group_poll(tgroup); 101 if (rc < 0) { 102 return -1; 103 } 104 count += rc; 105 } 106 107 return count; 108 } 109 110 static int 111 spdk_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 spdk_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 (spdk_nvmf_poll_group_add_subsystem(group, subsystem, NULL, NULL) != 0) { 140 spdk_nvmf_tgt_destroy_poll_group(io_device, ctx_buf); 141 return -1; 142 } 143 } 144 145 group->poller = SPDK_POLLER_REGISTER(spdk_nvmf_poll_group_poll, group, 0); 146 group->thread = spdk_get_thread(); 147 148 return 0; 149 } 150 151 static void 152 spdk_nvmf_tgt_destroy_poll_group(void *io_device, void *ctx_buf) 153 { 154 struct spdk_nvmf_poll_group *group = ctx_buf; 155 struct spdk_nvmf_transport_poll_group *tgroup, *tmp; 156 struct spdk_nvmf_subsystem_poll_group *sgroup; 157 uint32_t sid, nsid; 158 159 TAILQ_FOREACH_SAFE(tgroup, &group->tgroups, link, tmp) { 160 TAILQ_REMOVE(&group->tgroups, tgroup, link); 161 spdk_nvmf_transport_poll_group_destroy(tgroup); 162 } 163 164 for (sid = 0; sid < group->num_sgroups; sid++) { 165 sgroup = &group->sgroups[sid]; 166 167 for (nsid = 0; nsid < sgroup->num_ns; nsid++) { 168 if (sgroup->ns_info[nsid].channel) { 169 spdk_put_io_channel(sgroup->ns_info[nsid].channel); 170 sgroup->ns_info[nsid].channel = NULL; 171 } 172 } 173 174 free(sgroup->ns_info); 175 } 176 177 free(group->sgroups); 178 179 if (group->destroy_cb_fn) { 180 group->destroy_cb_fn(group->destroy_cb_arg, 0); 181 } 182 } 183 184 static void 185 _nvmf_tgt_disconnect_next_qpair(void *ctx) 186 { 187 struct spdk_nvmf_qpair *qpair; 188 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 189 struct spdk_nvmf_poll_group *group = qpair_ctx->group; 190 struct spdk_io_channel *ch; 191 int rc = 0; 192 193 qpair = TAILQ_FIRST(&group->qpairs); 194 195 if (qpair) { 196 rc = spdk_nvmf_qpair_disconnect(qpair, _nvmf_tgt_disconnect_next_qpair, ctx); 197 } 198 199 if (!qpair || rc != 0) { 200 /* When the refcount from the channels reaches 0, spdk_nvmf_tgt_destroy_poll_group will be called. */ 201 ch = spdk_io_channel_from_ctx(group); 202 spdk_put_io_channel(ch); 203 free(qpair_ctx); 204 } 205 } 206 207 static void 208 spdk_nvmf_tgt_destroy_poll_group_qpairs(struct spdk_nvmf_poll_group *group) 209 { 210 struct nvmf_qpair_disconnect_many_ctx *ctx; 211 212 ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx)); 213 214 if (!ctx) { 215 SPDK_ERRLOG("Failed to allocate memory for destroy poll group ctx\n"); 216 return; 217 } 218 219 spdk_poller_unregister(&group->poller); 220 221 ctx->group = group; 222 _nvmf_tgt_disconnect_next_qpair(ctx); 223 } 224 225 struct spdk_nvmf_tgt * 226 spdk_nvmf_tgt_create(struct spdk_nvmf_target_opts *opts) 227 { 228 struct spdk_nvmf_tgt *tgt, *tmp_tgt; 229 230 if (strnlen(opts->name, NVMF_TGT_NAME_MAX_LENGTH) == NVMF_TGT_NAME_MAX_LENGTH) { 231 SPDK_ERRLOG("Provided target name exceeds the max length of %u.\n", NVMF_TGT_NAME_MAX_LENGTH); 232 return NULL; 233 } 234 235 TAILQ_FOREACH(tmp_tgt, &g_nvmf_tgts, link) { 236 if (!strncmp(opts->name, tmp_tgt->name, NVMF_TGT_NAME_MAX_LENGTH)) { 237 SPDK_ERRLOG("Provided target name must be unique.\n"); 238 return NULL; 239 } 240 } 241 242 tgt = calloc(1, sizeof(*tgt)); 243 if (!tgt) { 244 return NULL; 245 } 246 247 snprintf(tgt->name, NVMF_TGT_NAME_MAX_LENGTH, "%s", opts->name); 248 249 if (!opts || !opts->max_subsystems) { 250 tgt->max_subsystems = SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS; 251 } else { 252 tgt->max_subsystems = opts->max_subsystems; 253 } 254 255 tgt->discovery_genctr = 0; 256 TAILQ_INIT(&tgt->transports); 257 258 tgt->subsystems = calloc(tgt->max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); 259 if (!tgt->subsystems) { 260 free(tgt); 261 return NULL; 262 } 263 264 TAILQ_INSERT_HEAD(&g_nvmf_tgts, tgt, link); 265 266 spdk_io_device_register(tgt, 267 spdk_nvmf_tgt_create_poll_group, 268 spdk_nvmf_tgt_destroy_poll_group, 269 sizeof(struct spdk_nvmf_poll_group), 270 tgt->name); 271 272 return tgt; 273 } 274 275 static void 276 spdk_nvmf_tgt_destroy_cb(void *io_device) 277 { 278 struct spdk_nvmf_tgt *tgt = io_device; 279 struct spdk_nvmf_transport *transport, *transport_tmp; 280 spdk_nvmf_tgt_destroy_done_fn *destroy_cb_fn; 281 void *destroy_cb_arg; 282 uint32_t i; 283 284 if (tgt->subsystems) { 285 for (i = 0; i < tgt->max_subsystems; i++) { 286 if (tgt->subsystems[i]) { 287 spdk_nvmf_subsystem_remove_all_listeners(tgt->subsystems[i], true); 288 spdk_nvmf_subsystem_destroy(tgt->subsystems[i]); 289 } 290 } 291 free(tgt->subsystems); 292 } 293 294 TAILQ_FOREACH_SAFE(transport, &tgt->transports, link, transport_tmp) { 295 TAILQ_REMOVE(&tgt->transports, transport, link); 296 spdk_nvmf_transport_destroy(transport); 297 } 298 299 destroy_cb_fn = tgt->destroy_cb_fn; 300 destroy_cb_arg = tgt->destroy_cb_arg; 301 302 free(tgt); 303 304 if (destroy_cb_fn) { 305 destroy_cb_fn(destroy_cb_arg, 0); 306 } 307 } 308 309 void 310 spdk_nvmf_tgt_destroy(struct spdk_nvmf_tgt *tgt, 311 spdk_nvmf_tgt_destroy_done_fn cb_fn, 312 void *cb_arg) 313 { 314 tgt->destroy_cb_fn = cb_fn; 315 tgt->destroy_cb_arg = cb_arg; 316 317 TAILQ_REMOVE(&g_nvmf_tgts, tgt, link); 318 319 spdk_io_device_unregister(tgt, spdk_nvmf_tgt_destroy_cb); 320 } 321 322 const char * 323 spdk_nvmf_tgt_get_name(struct spdk_nvmf_tgt *tgt) 324 { 325 return tgt->name; 326 } 327 328 struct spdk_nvmf_tgt * 329 spdk_nvmf_get_tgt(const char *name) 330 { 331 struct spdk_nvmf_tgt *tgt; 332 uint32_t num_targets = 0; 333 334 TAILQ_FOREACH(tgt, &g_nvmf_tgts, link) { 335 if (name) { 336 if (!strncmp(tgt->name, name, NVMF_TGT_NAME_MAX_LENGTH)) { 337 return tgt; 338 } 339 } 340 num_targets++; 341 } 342 343 /* 344 * special case. If there is only one target and 345 * no name was specified, return the only available 346 * target. If there is more than one target, name must 347 * be specified. 348 */ 349 if (!name && num_targets == 1) { 350 return TAILQ_FIRST(&g_nvmf_tgts); 351 } 352 353 return NULL; 354 } 355 356 struct spdk_nvmf_tgt * 357 spdk_nvmf_get_first_tgt(void) 358 { 359 return TAILQ_FIRST(&g_nvmf_tgts); 360 } 361 362 struct spdk_nvmf_tgt * 363 spdk_nvmf_get_next_tgt(struct spdk_nvmf_tgt *prev) 364 { 365 return TAILQ_NEXT(prev, link); 366 } 367 368 static void 369 spdk_nvmf_write_subsystem_config_json(struct spdk_json_write_ctx *w, 370 struct spdk_nvmf_subsystem *subsystem) 371 { 372 struct spdk_nvmf_host *host; 373 struct spdk_nvmf_subsystem_listener *listener; 374 const struct spdk_nvme_transport_id *trid; 375 struct spdk_nvmf_ns *ns; 376 struct spdk_nvmf_ns_opts ns_opts; 377 uint32_t max_namespaces; 378 char uuid_str[SPDK_UUID_STRING_LEN]; 379 const char *adrfam; 380 381 if (spdk_nvmf_subsystem_get_type(subsystem) != SPDK_NVMF_SUBTYPE_NVME) { 382 return; 383 } 384 385 /* { */ 386 spdk_json_write_object_begin(w); 387 spdk_json_write_named_string(w, "method", "nvmf_create_subsystem"); 388 389 /* "params" : { */ 390 spdk_json_write_named_object_begin(w, "params"); 391 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 392 spdk_json_write_named_bool(w, "allow_any_host", spdk_nvmf_subsystem_get_allow_any_host(subsystem)); 393 spdk_json_write_named_string(w, "serial_number", spdk_nvmf_subsystem_get_sn(subsystem)); 394 spdk_json_write_named_string(w, "model_number", spdk_nvmf_subsystem_get_mn(subsystem)); 395 396 max_namespaces = spdk_nvmf_subsystem_get_max_namespaces(subsystem); 397 if (max_namespaces != 0) { 398 spdk_json_write_named_uint32(w, "max_namespaces", max_namespaces); 399 } 400 401 /* } "params" */ 402 spdk_json_write_object_end(w); 403 404 /* } */ 405 spdk_json_write_object_end(w); 406 407 for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL; 408 listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) { 409 trid = spdk_nvmf_subsystem_listener_get_trid(listener); 410 411 adrfam = spdk_nvme_transport_id_adrfam_str(trid->adrfam); 412 413 spdk_json_write_object_begin(w); 414 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_listener"); 415 416 /* "params" : { */ 417 spdk_json_write_named_object_begin(w, "params"); 418 419 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 420 421 /* "listen_address" : { */ 422 spdk_json_write_named_object_begin(w, "listen_address"); 423 424 spdk_json_write_named_string(w, "trtype", trid->trstring); 425 if (adrfam) { 426 spdk_json_write_named_string(w, "adrfam", adrfam); 427 } 428 429 spdk_json_write_named_string(w, "traddr", trid->traddr); 430 spdk_json_write_named_string(w, "trsvcid", trid->trsvcid); 431 /* } "listen_address" */ 432 spdk_json_write_object_end(w); 433 434 /* } "params" */ 435 spdk_json_write_object_end(w); 436 437 /* } */ 438 spdk_json_write_object_end(w); 439 } 440 441 for (host = spdk_nvmf_subsystem_get_first_host(subsystem); host != NULL; 442 host = spdk_nvmf_subsystem_get_next_host(subsystem, host)) { 443 444 spdk_json_write_object_begin(w); 445 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_host"); 446 447 /* "params" : { */ 448 spdk_json_write_named_object_begin(w, "params"); 449 450 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 451 spdk_json_write_named_string(w, "host", spdk_nvmf_host_get_nqn(host)); 452 453 /* } "params" */ 454 spdk_json_write_object_end(w); 455 456 /* } */ 457 spdk_json_write_object_end(w); 458 } 459 460 for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); ns != NULL; 461 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) { 462 spdk_nvmf_ns_get_opts(ns, &ns_opts, sizeof(ns_opts)); 463 464 spdk_json_write_object_begin(w); 465 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_ns"); 466 467 /* "params" : { */ 468 spdk_json_write_named_object_begin(w, "params"); 469 470 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 471 472 /* "namespace" : { */ 473 spdk_json_write_named_object_begin(w, "namespace"); 474 475 spdk_json_write_named_uint32(w, "nsid", spdk_nvmf_ns_get_id(ns)); 476 spdk_json_write_named_string(w, "bdev_name", spdk_bdev_get_name(spdk_nvmf_ns_get_bdev(ns))); 477 478 if (!spdk_mem_all_zero(ns_opts.nguid, sizeof(ns_opts.nguid))) { 479 SPDK_STATIC_ASSERT(sizeof(ns_opts.nguid) == sizeof(uint64_t) * 2, "size mismatch"); 480 spdk_json_write_named_string_fmt(w, "nguid", "%016"PRIX64"%016"PRIX64, from_be64(&ns_opts.nguid[0]), 481 from_be64(&ns_opts.nguid[8])); 482 } 483 484 if (!spdk_mem_all_zero(ns_opts.eui64, sizeof(ns_opts.eui64))) { 485 SPDK_STATIC_ASSERT(sizeof(ns_opts.eui64) == sizeof(uint64_t), "size mismatch"); 486 spdk_json_write_named_string_fmt(w, "eui64", "%016"PRIX64, from_be64(&ns_opts.eui64)); 487 } 488 489 if (!spdk_mem_all_zero(&ns_opts.uuid, sizeof(ns_opts.uuid))) { 490 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &ns_opts.uuid); 491 spdk_json_write_named_string(w, "uuid", uuid_str); 492 } 493 494 /* "namespace" */ 495 spdk_json_write_object_end(w); 496 497 /* } "params" */ 498 spdk_json_write_object_end(w); 499 500 /* } */ 501 spdk_json_write_object_end(w); 502 } 503 } 504 505 void 506 spdk_nvmf_tgt_write_config_json(struct spdk_json_write_ctx *w, struct spdk_nvmf_tgt *tgt) 507 { 508 struct spdk_nvmf_subsystem *subsystem; 509 struct spdk_nvmf_transport *transport; 510 511 spdk_json_write_object_begin(w); 512 spdk_json_write_named_string(w, "method", "nvmf_set_max_subsystems"); 513 514 spdk_json_write_named_object_begin(w, "params"); 515 spdk_json_write_named_uint32(w, "max_subsystems", tgt->max_subsystems); 516 spdk_json_write_object_end(w); 517 518 spdk_json_write_object_end(w); 519 520 /* write transports */ 521 TAILQ_FOREACH(transport, &tgt->transports, link) { 522 spdk_json_write_object_begin(w); 523 spdk_json_write_named_string(w, "method", "nvmf_create_transport"); 524 525 spdk_json_write_named_object_begin(w, "params"); 526 spdk_json_write_named_string(w, "trtype", spdk_nvme_transport_id_trtype_str(transport->ops->type)); 527 spdk_json_write_named_uint32(w, "max_queue_depth", transport->opts.max_queue_depth); 528 spdk_json_write_named_uint32(w, "max_qpairs_per_ctrlr", transport->opts.max_qpairs_per_ctrlr); 529 spdk_json_write_named_uint32(w, "in_capsule_data_size", transport->opts.in_capsule_data_size); 530 spdk_json_write_named_uint32(w, "max_io_size", transport->opts.max_io_size); 531 spdk_json_write_named_uint32(w, "io_unit_size", transport->opts.io_unit_size); 532 spdk_json_write_named_uint32(w, "max_aq_depth", transport->opts.max_aq_depth); 533 if (transport->ops->type == SPDK_NVME_TRANSPORT_RDMA) { 534 spdk_json_write_named_uint32(w, "max_srq_depth", transport->opts.max_srq_depth); 535 } 536 spdk_json_write_object_end(w); 537 538 spdk_json_write_object_end(w); 539 } 540 541 subsystem = spdk_nvmf_subsystem_get_first(tgt); 542 while (subsystem) { 543 spdk_nvmf_write_subsystem_config_json(w, subsystem); 544 subsystem = spdk_nvmf_subsystem_get_next(subsystem); 545 } 546 } 547 548 int 549 spdk_nvmf_tgt_listen(struct spdk_nvmf_tgt *tgt, 550 struct spdk_nvme_transport_id *trid) 551 { 552 struct spdk_nvmf_transport *transport; 553 const char *trtype; 554 int rc; 555 556 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 557 if (!transport) { 558 trtype = spdk_nvme_transport_id_trtype_str(trid->trtype); 559 if (trtype != NULL) { 560 SPDK_ERRLOG("Unable to listen on transport %s. The transport must be created first.\n", trtype); 561 } else { 562 SPDK_ERRLOG("The specified trtype %d is unknown. Please make sure that it is properly registered.\n", 563 trid->trtype); 564 } 565 566 return -EINVAL; 567 } 568 569 rc = spdk_nvmf_transport_listen(transport, trid); 570 if (rc < 0) { 571 SPDK_ERRLOG("Unable to listen on address '%s'\n", trid->traddr); 572 } 573 574 return rc; 575 } 576 577 int 578 spdk_nvmf_tgt_stop_listen(struct spdk_nvmf_tgt *tgt, 579 struct spdk_nvme_transport_id *trid) 580 { 581 struct spdk_nvmf_transport *transport; 582 const char *trtype; 583 int rc; 584 585 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 586 if (!transport) { 587 trtype = spdk_nvme_transport_id_trtype_str(trid->trtype); 588 if (trtype != NULL) { 589 SPDK_ERRLOG("Unable to stop listen on transport %s. The transport must be created first.\n", 590 trtype); 591 } else { 592 SPDK_ERRLOG("The specified trtype %d is unknown. Please make sure that it is properly registered.\n", 593 trid->trtype); 594 } 595 return -EINVAL; 596 } 597 598 rc = spdk_nvmf_transport_stop_listen(transport, trid); 599 if (rc < 0) { 600 SPDK_ERRLOG("Failed to stop listening on address '%s'\n", trid->traddr); 601 return rc; 602 } 603 return 0; 604 } 605 606 struct spdk_nvmf_tgt_add_transport_ctx { 607 struct spdk_nvmf_tgt *tgt; 608 struct spdk_nvmf_transport *transport; 609 spdk_nvmf_tgt_add_transport_done_fn cb_fn; 610 void *cb_arg; 611 }; 612 613 static void 614 _spdk_nvmf_tgt_add_transport_done(struct spdk_io_channel_iter *i, int status) 615 { 616 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 617 618 ctx->cb_fn(ctx->cb_arg, status); 619 620 free(ctx); 621 } 622 623 static void 624 _spdk_nvmf_tgt_add_transport(struct spdk_io_channel_iter *i) 625 { 626 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 627 struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i); 628 struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch); 629 int rc; 630 631 rc = spdk_nvmf_poll_group_add_transport(group, ctx->transport); 632 spdk_for_each_channel_continue(i, rc); 633 } 634 635 void spdk_nvmf_tgt_add_transport(struct spdk_nvmf_tgt *tgt, 636 struct spdk_nvmf_transport *transport, 637 spdk_nvmf_tgt_add_transport_done_fn cb_fn, 638 void *cb_arg) 639 { 640 struct spdk_nvmf_tgt_add_transport_ctx *ctx; 641 642 if (spdk_nvmf_tgt_get_transport(tgt, transport->ops->name)) { 643 cb_fn(cb_arg, -EEXIST); 644 return; /* transport already created */ 645 } 646 647 transport->tgt = tgt; 648 TAILQ_INSERT_TAIL(&tgt->transports, transport, link); 649 650 ctx = calloc(1, sizeof(*ctx)); 651 if (!ctx) { 652 cb_fn(cb_arg, -ENOMEM); 653 return; 654 } 655 656 ctx->tgt = tgt; 657 ctx->transport = transport; 658 ctx->cb_fn = cb_fn; 659 ctx->cb_arg = cb_arg; 660 661 spdk_for_each_channel(tgt, 662 _spdk_nvmf_tgt_add_transport, 663 ctx, 664 _spdk_nvmf_tgt_add_transport_done); 665 } 666 667 struct spdk_nvmf_subsystem * 668 spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) 669 { 670 struct spdk_nvmf_subsystem *subsystem; 671 uint32_t sid; 672 673 if (!subnqn) { 674 return NULL; 675 } 676 677 /* Ensure that subnqn is null terminated */ 678 if (!memchr(subnqn, '\0', SPDK_NVMF_NQN_MAX_LEN + 1)) { 679 SPDK_ERRLOG("Connect SUBNQN is not null terminated\n"); 680 return NULL; 681 } 682 683 for (sid = 0; sid < tgt->max_subsystems; sid++) { 684 subsystem = tgt->subsystems[sid]; 685 if (subsystem == NULL) { 686 continue; 687 } 688 689 if (strcmp(subnqn, subsystem->subnqn) == 0) { 690 return subsystem; 691 } 692 } 693 694 return NULL; 695 } 696 697 struct spdk_nvmf_transport * 698 spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name) 699 { 700 struct spdk_nvmf_transport *transport; 701 702 TAILQ_FOREACH(transport, &tgt->transports, link) { 703 if (!strncasecmp(transport->ops->name, transport_name, SPDK_NVMF_TRSTRING_MAX_LEN)) { 704 return transport; 705 } 706 } 707 return NULL; 708 } 709 710 void 711 spdk_nvmf_tgt_accept(struct spdk_nvmf_tgt *tgt, new_qpair_fn cb_fn, void *cb_arg) 712 { 713 struct spdk_nvmf_transport *transport, *tmp; 714 715 TAILQ_FOREACH_SAFE(transport, &tgt->transports, link, tmp) { 716 spdk_nvmf_transport_accept(transport, cb_fn, cb_arg); 717 } 718 } 719 720 struct spdk_nvmf_poll_group * 721 spdk_nvmf_poll_group_create(struct spdk_nvmf_tgt *tgt) 722 { 723 struct spdk_io_channel *ch; 724 725 ch = spdk_get_io_channel(tgt); 726 if (!ch) { 727 SPDK_ERRLOG("Unable to get I/O channel for target\n"); 728 return NULL; 729 } 730 731 return spdk_io_channel_get_ctx(ch); 732 } 733 734 void 735 spdk_nvmf_poll_group_destroy(struct spdk_nvmf_poll_group *group, 736 spdk_nvmf_poll_group_destroy_done_fn cb_fn, 737 void *cb_arg) 738 { 739 assert(group->destroy_cb_fn == NULL); 740 group->destroy_cb_fn = cb_fn; 741 group->destroy_cb_arg = cb_arg; 742 743 /* This function will put the io_channel associated with this poll group */ 744 spdk_nvmf_tgt_destroy_poll_group_qpairs(group); 745 } 746 747 int 748 spdk_nvmf_poll_group_add(struct spdk_nvmf_poll_group *group, 749 struct spdk_nvmf_qpair *qpair) 750 { 751 int rc = -1; 752 struct spdk_nvmf_transport_poll_group *tgroup; 753 754 TAILQ_INIT(&qpair->outstanding); 755 qpair->group = group; 756 757 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 758 if (tgroup->transport == qpair->transport) { 759 rc = spdk_nvmf_transport_poll_group_add(tgroup, qpair); 760 break; 761 } 762 } 763 764 /* We add the qpair to the group only it is succesfully added into the tgroup */ 765 if (rc == 0) { 766 TAILQ_INSERT_TAIL(&group->qpairs, qpair, link); 767 spdk_nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ACTIVE); 768 } 769 770 return rc; 771 } 772 773 static 774 void _nvmf_ctrlr_destruct(void *ctx) 775 { 776 struct spdk_nvmf_ctrlr *ctrlr = ctx; 777 778 spdk_nvmf_ctrlr_destruct(ctrlr); 779 } 780 781 static void 782 _nvmf_transport_qpair_fini(void *ctx) 783 { 784 struct spdk_nvmf_qpair *qpair = ctx; 785 786 spdk_nvmf_transport_qpair_fini(qpair); 787 } 788 789 static void 790 _spdk_nvmf_ctrlr_free_from_qpair(void *ctx) 791 { 792 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 793 struct spdk_nvmf_ctrlr *ctrlr = qpair_ctx->ctrlr; 794 uint32_t count; 795 796 spdk_bit_array_clear(ctrlr->qpair_mask, qpair_ctx->qid); 797 count = spdk_bit_array_count_set(ctrlr->qpair_mask); 798 if (count == 0) { 799 spdk_bit_array_free(&ctrlr->qpair_mask); 800 801 spdk_thread_send_msg(ctrlr->subsys->thread, _nvmf_ctrlr_destruct, ctrlr); 802 } 803 804 spdk_thread_send_msg(qpair_ctx->thread, _nvmf_transport_qpair_fini, qpair_ctx->qpair); 805 if (qpair_ctx->cb_fn) { 806 spdk_thread_send_msg(qpair_ctx->thread, qpair_ctx->cb_fn, qpair_ctx->ctx); 807 } 808 free(qpair_ctx); 809 } 810 811 static void 812 _spdk_nvmf_qpair_destroy(void *ctx, int status) 813 { 814 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 815 struct spdk_nvmf_qpair *qpair = qpair_ctx->qpair; 816 struct spdk_nvmf_ctrlr *ctrlr = qpair->ctrlr; 817 struct spdk_nvmf_transport_poll_group *tgroup; 818 struct spdk_nvmf_request *req, *tmp; 819 struct spdk_nvmf_subsystem_poll_group *sgroup; 820 int rc; 821 822 assert(qpair->state == SPDK_NVMF_QPAIR_DEACTIVATING); 823 spdk_nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ERROR); 824 qpair_ctx->qid = qpair->qid; 825 826 /* Find the tgroup and remove the qpair from the tgroup */ 827 TAILQ_FOREACH(tgroup, &qpair->group->tgroups, link) { 828 if (tgroup->transport == qpair->transport) { 829 rc = spdk_nvmf_transport_poll_group_remove(tgroup, qpair); 830 if (rc && (rc != ENOTSUP)) { 831 SPDK_ERRLOG("Cannot remove qpair=%p from transport group=%p\n", 832 qpair, tgroup); 833 } 834 break; 835 } 836 } 837 838 if (ctrlr) { 839 sgroup = &qpair->group->sgroups[ctrlr->subsys->id]; 840 TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) { 841 if (req->qpair == qpair) { 842 TAILQ_REMOVE(&sgroup->queued, req, link); 843 if (spdk_nvmf_transport_req_free(req)) { 844 SPDK_ERRLOG("Transport request free error!\n"); 845 } 846 } 847 } 848 } 849 850 TAILQ_REMOVE(&qpair->group->qpairs, qpair, link); 851 852 if (!ctrlr || !ctrlr->thread) { 853 spdk_nvmf_transport_qpair_fini(qpair); 854 if (qpair_ctx->cb_fn) { 855 spdk_thread_send_msg(qpair_ctx->thread, qpair_ctx->cb_fn, qpair_ctx->ctx); 856 } 857 free(qpair_ctx); 858 return; 859 } 860 861 qpair_ctx->ctrlr = ctrlr; 862 spdk_thread_send_msg(ctrlr->thread, _spdk_nvmf_ctrlr_free_from_qpair, qpair_ctx); 863 864 } 865 866 int 867 spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) 868 { 869 struct nvmf_qpair_disconnect_ctx *qpair_ctx; 870 871 /* If we get a qpair in the uninitialized state, we can just destroy it immediately */ 872 if (qpair->state == SPDK_NVMF_QPAIR_UNINITIALIZED) { 873 spdk_nvmf_transport_qpair_fini(qpair); 874 if (cb_fn) { 875 cb_fn(ctx); 876 } 877 return 0; 878 } 879 880 /* The queue pair must be disconnected from the thread that owns it */ 881 assert(qpair->group->thread == spdk_get_thread()); 882 883 if (qpair->state != SPDK_NVMF_QPAIR_ACTIVE) { 884 /* This can occur if the connection is killed by the target, 885 * which results in a notification that the connection 886 * died. Send a message to defer the processing of this 887 * callback. This allows the stack to unwind in the case 888 * where a bunch of connections are disconnected in 889 * a loop. */ 890 if (cb_fn) { 891 spdk_thread_send_msg(qpair->group->thread, cb_fn, ctx); 892 } 893 return 0; 894 } 895 896 assert(qpair->state == SPDK_NVMF_QPAIR_ACTIVE); 897 spdk_nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_DEACTIVATING); 898 899 qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx)); 900 if (!qpair_ctx) { 901 SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n"); 902 return -ENOMEM; 903 } 904 905 qpair_ctx->qpair = qpair; 906 qpair_ctx->cb_fn = cb_fn; 907 qpair_ctx->thread = qpair->group->thread; 908 qpair_ctx->ctx = ctx; 909 910 /* Check for outstanding I/O */ 911 if (!TAILQ_EMPTY(&qpair->outstanding)) { 912 qpair->state_cb = _spdk_nvmf_qpair_destroy; 913 qpair->state_cb_arg = qpair_ctx; 914 spdk_nvmf_qpair_free_aer(qpair); 915 return 0; 916 } 917 918 _spdk_nvmf_qpair_destroy(qpair_ctx, 0); 919 920 return 0; 921 } 922 923 int 924 spdk_nvmf_qpair_get_peer_trid(struct spdk_nvmf_qpair *qpair, 925 struct spdk_nvme_transport_id *trid) 926 { 927 return spdk_nvmf_transport_qpair_get_peer_trid(qpair, trid); 928 } 929 930 int 931 spdk_nvmf_qpair_get_local_trid(struct spdk_nvmf_qpair *qpair, 932 struct spdk_nvme_transport_id *trid) 933 { 934 return spdk_nvmf_transport_qpair_get_local_trid(qpair, trid); 935 } 936 937 int 938 spdk_nvmf_qpair_get_listen_trid(struct spdk_nvmf_qpair *qpair, 939 struct spdk_nvme_transport_id *trid) 940 { 941 return spdk_nvmf_transport_qpair_get_listen_trid(qpair, trid); 942 } 943 944 int 945 spdk_nvmf_poll_group_add_transport(struct spdk_nvmf_poll_group *group, 946 struct spdk_nvmf_transport *transport) 947 { 948 struct spdk_nvmf_transport_poll_group *tgroup; 949 950 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 951 if (tgroup->transport == transport) { 952 /* Transport already in the poll group */ 953 return 0; 954 } 955 } 956 957 tgroup = spdk_nvmf_transport_poll_group_create(transport); 958 if (!tgroup) { 959 SPDK_ERRLOG("Unable to create poll group for transport\n"); 960 return -1; 961 } 962 963 tgroup->group = group; 964 TAILQ_INSERT_TAIL(&group->tgroups, tgroup, link); 965 966 return 0; 967 } 968 969 static int 970 poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 971 struct spdk_nvmf_subsystem *subsystem) 972 { 973 struct spdk_nvmf_subsystem_poll_group *sgroup; 974 uint32_t new_num_ns, old_num_ns; 975 uint32_t i, j; 976 struct spdk_nvmf_ns *ns; 977 struct spdk_nvmf_registrant *reg, *tmp; 978 struct spdk_io_channel *ch; 979 struct spdk_nvmf_subsystem_pg_ns_info *ns_info; 980 struct spdk_nvmf_ctrlr *ctrlr; 981 bool ns_changed; 982 983 /* Make sure our poll group has memory for this subsystem allocated */ 984 if (subsystem->id >= group->num_sgroups) { 985 return -ENOMEM; 986 } 987 988 sgroup = &group->sgroups[subsystem->id]; 989 990 /* Make sure the array of namespace information is the correct size */ 991 new_num_ns = subsystem->max_nsid; 992 old_num_ns = sgroup->num_ns; 993 994 ns_changed = false; 995 996 if (old_num_ns == 0) { 997 if (new_num_ns > 0) { 998 /* First allocation */ 999 sgroup->ns_info = calloc(new_num_ns, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1000 if (!sgroup->ns_info) { 1001 return -ENOMEM; 1002 } 1003 } 1004 } else if (new_num_ns > old_num_ns) { 1005 void *buf; 1006 1007 /* Make the array larger */ 1008 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1009 if (!buf) { 1010 return -ENOMEM; 1011 } 1012 1013 sgroup->ns_info = buf; 1014 1015 /* Null out the new namespace information slots */ 1016 for (i = old_num_ns; i < new_num_ns; i++) { 1017 memset(&sgroup->ns_info[i], 0, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1018 } 1019 } else if (new_num_ns < old_num_ns) { 1020 void *buf; 1021 1022 /* Free the extra I/O channels */ 1023 for (i = new_num_ns; i < old_num_ns; i++) { 1024 ns_info = &sgroup->ns_info[i]; 1025 1026 if (ns_info->channel) { 1027 spdk_put_io_channel(ns_info->channel); 1028 ns_info->channel = NULL; 1029 } 1030 } 1031 1032 /* Make the array smaller */ 1033 if (new_num_ns > 0) { 1034 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1035 if (!buf) { 1036 return -ENOMEM; 1037 } 1038 sgroup->ns_info = buf; 1039 } else { 1040 free(sgroup->ns_info); 1041 sgroup->ns_info = NULL; 1042 } 1043 } 1044 1045 sgroup->num_ns = new_num_ns; 1046 1047 /* Detect bdevs that were added or removed */ 1048 for (i = 0; i < sgroup->num_ns; i++) { 1049 ns = subsystem->ns[i]; 1050 ns_info = &sgroup->ns_info[i]; 1051 ch = ns_info->channel; 1052 1053 if (ns == NULL && ch == NULL) { 1054 /* Both NULL. Leave empty */ 1055 } else if (ns == NULL && ch != NULL) { 1056 /* There was a channel here, but the namespace is gone. */ 1057 ns_changed = true; 1058 spdk_put_io_channel(ch); 1059 ns_info->channel = NULL; 1060 } else if (ns != NULL && ch == NULL) { 1061 /* A namespace appeared but there is no channel yet */ 1062 ns_changed = true; 1063 ch = spdk_bdev_get_io_channel(ns->desc); 1064 if (ch == NULL) { 1065 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1066 return -ENOMEM; 1067 } 1068 ns_info->channel = ch; 1069 } else if (spdk_uuid_compare(&ns_info->uuid, spdk_bdev_get_uuid(ns->bdev)) != 0) { 1070 /* A namespace was here before, but was replaced by a new one. */ 1071 ns_changed = true; 1072 spdk_put_io_channel(ns_info->channel); 1073 memset(ns_info, 0, sizeof(*ns_info)); 1074 1075 ch = spdk_bdev_get_io_channel(ns->desc); 1076 if (ch == NULL) { 1077 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1078 return -ENOMEM; 1079 } 1080 ns_info->channel = ch; 1081 } else if (ns_info->num_blocks != spdk_bdev_get_num_blocks(ns->bdev)) { 1082 /* Namespace is still there but size has changed */ 1083 SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Namespace resized: subsystem_id %d," 1084 " nsid %u, pg %p, old %lu, new %lu\n", 1085 subsystem->id, 1086 ns->nsid, 1087 group, 1088 ns_info->num_blocks, 1089 spdk_bdev_get_num_blocks(ns->bdev)); 1090 ns_changed = true; 1091 } 1092 1093 if (ns == NULL) { 1094 memset(ns_info, 0, sizeof(*ns_info)); 1095 } else { 1096 ns_info->uuid = *spdk_bdev_get_uuid(ns->bdev); 1097 ns_info->num_blocks = spdk_bdev_get_num_blocks(ns->bdev); 1098 ns_info->crkey = ns->crkey; 1099 ns_info->rtype = ns->rtype; 1100 if (ns->holder) { 1101 ns_info->holder_id = ns->holder->hostid; 1102 } 1103 1104 memset(&ns_info->reg_hostid, 0, SPDK_NVMF_MAX_NUM_REGISTRANTS * sizeof(struct spdk_uuid)); 1105 j = 0; 1106 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 1107 if (j >= SPDK_NVMF_MAX_NUM_REGISTRANTS) { 1108 SPDK_ERRLOG("Maximum %u registrants can support.\n", SPDK_NVMF_MAX_NUM_REGISTRANTS); 1109 return -EINVAL; 1110 } 1111 ns_info->reg_hostid[j++] = reg->hostid; 1112 } 1113 } 1114 } 1115 1116 if (ns_changed) { 1117 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1118 if (ctrlr->admin_qpair->group == group) { 1119 spdk_nvmf_ctrlr_async_event_ns_notice(ctrlr); 1120 } 1121 } 1122 } 1123 1124 return 0; 1125 } 1126 1127 int 1128 spdk_nvmf_poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 1129 struct spdk_nvmf_subsystem *subsystem) 1130 { 1131 return poll_group_update_subsystem(group, subsystem); 1132 } 1133 1134 int 1135 spdk_nvmf_poll_group_add_subsystem(struct spdk_nvmf_poll_group *group, 1136 struct spdk_nvmf_subsystem *subsystem, 1137 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1138 { 1139 int rc = 0; 1140 struct spdk_nvmf_subsystem_poll_group *sgroup = &group->sgroups[subsystem->id]; 1141 1142 TAILQ_INIT(&sgroup->queued); 1143 1144 rc = poll_group_update_subsystem(group, subsystem); 1145 if (rc) { 1146 spdk_nvmf_poll_group_remove_subsystem(group, subsystem, NULL, NULL); 1147 goto fini; 1148 } 1149 1150 sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1151 fini: 1152 if (cb_fn) { 1153 cb_fn(cb_arg, rc); 1154 } 1155 1156 return rc; 1157 } 1158 1159 static void 1160 _nvmf_poll_group_remove_subsystem_cb(void *ctx, int status) 1161 { 1162 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 1163 struct spdk_nvmf_subsystem *subsystem; 1164 struct spdk_nvmf_poll_group *group; 1165 struct spdk_nvmf_subsystem_poll_group *sgroup; 1166 spdk_nvmf_poll_group_mod_done cpl_fn = NULL; 1167 void *cpl_ctx = NULL; 1168 uint32_t nsid; 1169 1170 group = qpair_ctx->group; 1171 subsystem = qpair_ctx->subsystem; 1172 cpl_fn = qpair_ctx->cpl_fn; 1173 cpl_ctx = qpair_ctx->cpl_ctx; 1174 sgroup = &group->sgroups[subsystem->id]; 1175 1176 if (status) { 1177 goto fini; 1178 } 1179 1180 for (nsid = 0; nsid < sgroup->num_ns; nsid++) { 1181 if (sgroup->ns_info[nsid].channel) { 1182 spdk_put_io_channel(sgroup->ns_info[nsid].channel); 1183 sgroup->ns_info[nsid].channel = NULL; 1184 } 1185 } 1186 1187 sgroup->num_ns = 0; 1188 free(sgroup->ns_info); 1189 sgroup->ns_info = NULL; 1190 fini: 1191 free(qpair_ctx); 1192 if (cpl_fn) { 1193 cpl_fn(cpl_ctx, status); 1194 } 1195 } 1196 1197 static void 1198 _nvmf_subsystem_disconnect_next_qpair(void *ctx) 1199 { 1200 struct spdk_nvmf_qpair *qpair; 1201 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 1202 struct spdk_nvmf_subsystem *subsystem; 1203 struct spdk_nvmf_poll_group *group; 1204 int rc = 0; 1205 1206 group = qpair_ctx->group; 1207 subsystem = qpair_ctx->subsystem; 1208 1209 TAILQ_FOREACH(qpair, &group->qpairs, link) { 1210 if ((qpair->ctrlr != NULL) && (qpair->ctrlr->subsys == subsystem)) { 1211 break; 1212 } 1213 } 1214 1215 if (qpair) { 1216 rc = spdk_nvmf_qpair_disconnect(qpair, _nvmf_subsystem_disconnect_next_qpair, qpair_ctx); 1217 } 1218 1219 if (!qpair || rc != 0) { 1220 _nvmf_poll_group_remove_subsystem_cb(ctx, rc); 1221 } 1222 return; 1223 } 1224 1225 void 1226 spdk_nvmf_poll_group_remove_subsystem(struct spdk_nvmf_poll_group *group, 1227 struct spdk_nvmf_subsystem *subsystem, 1228 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1229 { 1230 struct spdk_nvmf_qpair *qpair; 1231 struct spdk_nvmf_subsystem_poll_group *sgroup; 1232 struct nvmf_qpair_disconnect_many_ctx *ctx; 1233 int rc = 0; 1234 1235 ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx)); 1236 1237 if (!ctx) { 1238 SPDK_ERRLOG("Unable to allocate memory for context to remove poll subsystem\n"); 1239 goto fini; 1240 } 1241 1242 ctx->group = group; 1243 ctx->subsystem = subsystem; 1244 ctx->cpl_fn = cb_fn; 1245 ctx->cpl_ctx = cb_arg; 1246 1247 sgroup = &group->sgroups[subsystem->id]; 1248 sgroup->state = SPDK_NVMF_SUBSYSTEM_INACTIVE; 1249 1250 TAILQ_FOREACH(qpair, &group->qpairs, link) { 1251 if ((qpair->ctrlr != NULL) && (qpair->ctrlr->subsys == subsystem)) { 1252 break; 1253 } 1254 } 1255 1256 if (qpair) { 1257 rc = spdk_nvmf_qpair_disconnect(qpair, _nvmf_subsystem_disconnect_next_qpair, ctx); 1258 } else { 1259 /* call the callback immediately. It will handle any channel iteration */ 1260 _nvmf_poll_group_remove_subsystem_cb(ctx, 0); 1261 } 1262 1263 if (rc != 0) { 1264 free(ctx); 1265 goto fini; 1266 } 1267 1268 return; 1269 fini: 1270 if (cb_fn) { 1271 cb_fn(cb_arg, rc); 1272 } 1273 } 1274 1275 void 1276 spdk_nvmf_poll_group_pause_subsystem(struct spdk_nvmf_poll_group *group, 1277 struct spdk_nvmf_subsystem *subsystem, 1278 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1279 { 1280 struct spdk_nvmf_subsystem_poll_group *sgroup; 1281 int rc = 0; 1282 1283 if (subsystem->id >= group->num_sgroups) { 1284 rc = -1; 1285 goto fini; 1286 } 1287 1288 sgroup = &group->sgroups[subsystem->id]; 1289 if (sgroup == NULL) { 1290 rc = -1; 1291 goto fini; 1292 } 1293 1294 assert(sgroup->state == SPDK_NVMF_SUBSYSTEM_ACTIVE); 1295 sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSING; 1296 1297 if (sgroup->io_outstanding > 0) { 1298 sgroup->cb_fn = cb_fn; 1299 sgroup->cb_arg = cb_arg; 1300 return; 1301 } 1302 1303 assert(sgroup->io_outstanding == 0); 1304 sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSED; 1305 fini: 1306 if (cb_fn) { 1307 cb_fn(cb_arg, rc); 1308 } 1309 } 1310 1311 void 1312 spdk_nvmf_poll_group_resume_subsystem(struct spdk_nvmf_poll_group *group, 1313 struct spdk_nvmf_subsystem *subsystem, 1314 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1315 { 1316 struct spdk_nvmf_request *req, *tmp; 1317 struct spdk_nvmf_subsystem_poll_group *sgroup; 1318 int rc = 0; 1319 1320 if (subsystem->id >= group->num_sgroups) { 1321 rc = -1; 1322 goto fini; 1323 } 1324 1325 sgroup = &group->sgroups[subsystem->id]; 1326 1327 assert(sgroup->state == SPDK_NVMF_SUBSYSTEM_PAUSED); 1328 1329 rc = poll_group_update_subsystem(group, subsystem); 1330 if (rc) { 1331 goto fini; 1332 } 1333 1334 sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1335 1336 /* Release all queued requests */ 1337 TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) { 1338 TAILQ_REMOVE(&sgroup->queued, req, link); 1339 spdk_nvmf_request_exec(req); 1340 } 1341 fini: 1342 if (cb_fn) { 1343 cb_fn(cb_arg, rc); 1344 } 1345 } 1346 1347 1348 struct spdk_nvmf_poll_group * 1349 spdk_nvmf_get_optimal_poll_group(struct spdk_nvmf_qpair *qpair) 1350 { 1351 struct spdk_nvmf_transport_poll_group *tgroup; 1352 1353 tgroup = spdk_nvmf_transport_get_optimal_poll_group(qpair->transport, qpair); 1354 1355 if (tgroup == NULL) { 1356 return NULL; 1357 } 1358 1359 return tgroup->group; 1360 } 1361 1362 int 1363 spdk_nvmf_poll_group_get_stat(struct spdk_nvmf_tgt *tgt, 1364 struct spdk_nvmf_poll_group_stat *stat) 1365 { 1366 struct spdk_io_channel *ch; 1367 struct spdk_nvmf_poll_group *group; 1368 1369 if (tgt == NULL || stat == NULL) { 1370 return -EINVAL; 1371 } 1372 1373 ch = spdk_get_io_channel(tgt); 1374 group = spdk_io_channel_get_ctx(ch); 1375 *stat = group->stat; 1376 spdk_put_io_channel(ch); 1377 return 0; 1378 } 1379