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