1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2016 Intel Corporation. All rights reserved. 3 * Copyright (c) 2018-2019, 2021 Mellanox Technologies LTD. All rights reserved. 4 * Copyright (c) 2021, 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk/stdinc.h" 8 9 #include "spdk/bdev.h" 10 #include "spdk/bit_array.h" 11 #include "spdk/thread.h" 12 #include "spdk/nvmf.h" 13 #include "spdk/endian.h" 14 #include "spdk/string.h" 15 #include "spdk/log.h" 16 #include "spdk_internal/usdt.h" 17 18 #include "nvmf_internal.h" 19 #include "transport.h" 20 21 SPDK_LOG_REGISTER_COMPONENT(nvmf) 22 23 #define SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS 1024 24 25 static TAILQ_HEAD(, spdk_nvmf_tgt) g_nvmf_tgts = TAILQ_HEAD_INITIALIZER(g_nvmf_tgts); 26 27 typedef void (*nvmf_qpair_disconnect_cpl)(void *ctx, int status); 28 29 /* supplied to a single call to nvmf_qpair_disconnect */ 30 struct nvmf_qpair_disconnect_ctx { 31 struct spdk_nvmf_qpair *qpair; 32 struct spdk_nvmf_ctrlr *ctrlr; 33 nvmf_qpair_disconnect_cb cb_fn; 34 struct spdk_thread *thread; 35 void *ctx; 36 uint16_t qid; 37 }; 38 39 /* 40 * There are several times when we need to iterate through the list of all qpairs and selectively delete them. 41 * In order to do this sequentially without overlap, we must provide a context to recover the next qpair from 42 * to enable calling nvmf_qpair_disconnect on the next desired qpair. 43 */ 44 struct nvmf_qpair_disconnect_many_ctx { 45 struct spdk_nvmf_subsystem *subsystem; 46 struct spdk_nvmf_poll_group *group; 47 spdk_nvmf_poll_group_mod_done cpl_fn; 48 void *cpl_ctx; 49 }; 50 51 static void 52 nvmf_qpair_set_state(struct spdk_nvmf_qpair *qpair, 53 enum spdk_nvmf_qpair_state state) 54 { 55 assert(qpair != NULL); 56 assert(qpair->group->thread == spdk_get_thread()); 57 58 qpair->state = state; 59 } 60 61 static int 62 nvmf_poll_group_poll(void *ctx) 63 { 64 struct spdk_nvmf_poll_group *group = ctx; 65 int rc; 66 int count = 0; 67 struct spdk_nvmf_transport_poll_group *tgroup; 68 69 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 70 rc = nvmf_transport_poll_group_poll(tgroup); 71 if (rc < 0) { 72 return SPDK_POLLER_BUSY; 73 } 74 count += rc; 75 } 76 77 return count > 0 ? SPDK_POLLER_BUSY : SPDK_POLLER_IDLE; 78 } 79 80 /* 81 * Reset and clean up the poll group (I/O channel code will actually free the 82 * group). 83 */ 84 static void 85 nvmf_tgt_cleanup_poll_group(struct spdk_nvmf_poll_group *group) 86 { 87 struct spdk_nvmf_transport_poll_group *tgroup, *tmp; 88 struct spdk_nvmf_subsystem_poll_group *sgroup; 89 uint32_t sid, nsid; 90 91 TAILQ_FOREACH_SAFE(tgroup, &group->tgroups, link, tmp) { 92 TAILQ_REMOVE(&group->tgroups, tgroup, link); 93 nvmf_transport_poll_group_destroy(tgroup); 94 } 95 96 for (sid = 0; sid < group->num_sgroups; sid++) { 97 sgroup = &group->sgroups[sid]; 98 99 assert(sgroup != NULL); 100 101 for (nsid = 0; nsid < sgroup->num_ns; nsid++) { 102 if (sgroup->ns_info[nsid].channel) { 103 spdk_put_io_channel(sgroup->ns_info[nsid].channel); 104 sgroup->ns_info[nsid].channel = NULL; 105 } 106 } 107 108 free(sgroup->ns_info); 109 } 110 111 free(group->sgroups); 112 113 spdk_poller_unregister(&group->poller); 114 115 if (group->destroy_cb_fn) { 116 group->destroy_cb_fn(group->destroy_cb_arg, 0); 117 } 118 } 119 120 /* 121 * Callback to unregister a poll group from the target, and clean up its state. 122 */ 123 static void 124 nvmf_tgt_destroy_poll_group(void *io_device, void *ctx_buf) 125 { 126 struct spdk_nvmf_tgt *tgt = io_device; 127 struct spdk_nvmf_poll_group *group = ctx_buf; 128 129 SPDK_DTRACE_PROBE1_TICKS(nvmf_destroy_poll_group, spdk_thread_get_id(group->thread)); 130 131 pthread_mutex_lock(&tgt->mutex); 132 TAILQ_REMOVE(&tgt->poll_groups, group, link); 133 tgt->num_poll_groups--; 134 pthread_mutex_unlock(&tgt->mutex); 135 136 assert(!(tgt->state == NVMF_TGT_PAUSING || tgt->state == NVMF_TGT_RESUMING)); 137 nvmf_tgt_cleanup_poll_group(group); 138 } 139 140 static int 141 nvmf_poll_group_add_transport(struct spdk_nvmf_poll_group *group, 142 struct spdk_nvmf_transport *transport) 143 { 144 struct spdk_nvmf_transport_poll_group *tgroup; 145 146 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 147 if (tgroup->transport == transport) { 148 /* Transport already in the poll group */ 149 return 0; 150 } 151 } 152 153 tgroup = nvmf_transport_poll_group_create(transport, group); 154 if (!tgroup) { 155 SPDK_ERRLOG("Unable to create poll group for transport\n"); 156 return -1; 157 } 158 SPDK_DTRACE_PROBE2_TICKS(nvmf_transport_poll_group_create, transport, 159 spdk_thread_get_id(group->thread)); 160 161 tgroup->group = group; 162 TAILQ_INSERT_TAIL(&group->tgroups, tgroup, link); 163 164 return 0; 165 } 166 167 static int 168 nvmf_tgt_create_poll_group(void *io_device, void *ctx_buf) 169 { 170 struct spdk_nvmf_tgt *tgt = io_device; 171 struct spdk_nvmf_poll_group *group = ctx_buf; 172 struct spdk_nvmf_transport *transport; 173 struct spdk_nvmf_subsystem *subsystem; 174 struct spdk_thread *thread = spdk_get_thread(); 175 int rc; 176 177 group->tgt = tgt; 178 TAILQ_INIT(&group->tgroups); 179 TAILQ_INIT(&group->qpairs); 180 group->thread = thread; 181 pthread_mutex_init(&group->mutex, NULL); 182 183 group->poller = SPDK_POLLER_REGISTER(nvmf_poll_group_poll, group, 0); 184 185 SPDK_DTRACE_PROBE1_TICKS(nvmf_create_poll_group, spdk_thread_get_id(thread)); 186 187 TAILQ_FOREACH(transport, &tgt->transports, link) { 188 rc = nvmf_poll_group_add_transport(group, transport); 189 if (rc != 0) { 190 nvmf_tgt_cleanup_poll_group(group); 191 return rc; 192 } 193 } 194 195 group->num_sgroups = tgt->max_subsystems; 196 group->sgroups = calloc(tgt->max_subsystems, sizeof(struct spdk_nvmf_subsystem_poll_group)); 197 if (!group->sgroups) { 198 nvmf_tgt_cleanup_poll_group(group); 199 return -ENOMEM; 200 } 201 202 for (subsystem = spdk_nvmf_subsystem_get_first(tgt); 203 subsystem != NULL; 204 subsystem = spdk_nvmf_subsystem_get_next(subsystem)) { 205 if (nvmf_poll_group_add_subsystem(group, subsystem, NULL, NULL) != 0) { 206 nvmf_tgt_cleanup_poll_group(group); 207 return -1; 208 } 209 } 210 211 pthread_mutex_lock(&tgt->mutex); 212 tgt->num_poll_groups++; 213 TAILQ_INSERT_TAIL(&tgt->poll_groups, group, link); 214 pthread_mutex_unlock(&tgt->mutex); 215 216 return 0; 217 } 218 219 static void 220 _nvmf_tgt_disconnect_qpairs(void *ctx) 221 { 222 struct spdk_nvmf_qpair *qpair, *qpair_tmp; 223 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 224 struct spdk_nvmf_poll_group *group = qpair_ctx->group; 225 struct spdk_io_channel *ch; 226 int rc; 227 228 TAILQ_FOREACH_SAFE(qpair, &group->qpairs, link, qpair_tmp) { 229 rc = spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 230 if (rc && rc != -EINPROGRESS) { 231 break; 232 } 233 } 234 235 if (TAILQ_EMPTY(&group->qpairs)) { 236 /* When the refcount from the channels reaches 0, nvmf_tgt_destroy_poll_group will be called. */ 237 ch = spdk_io_channel_from_ctx(group); 238 spdk_put_io_channel(ch); 239 free(qpair_ctx); 240 return; 241 } 242 243 /* Some qpairs are in process of being disconnected. Send a message and try to remove them again */ 244 spdk_thread_send_msg(spdk_get_thread(), _nvmf_tgt_disconnect_qpairs, ctx); 245 } 246 247 static void 248 nvmf_tgt_destroy_poll_group_qpairs(struct spdk_nvmf_poll_group *group) 249 { 250 struct nvmf_qpair_disconnect_many_ctx *ctx; 251 252 SPDK_DTRACE_PROBE1_TICKS(nvmf_destroy_poll_group_qpairs, spdk_thread_get_id(group->thread)); 253 254 ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx)); 255 if (!ctx) { 256 SPDK_ERRLOG("Failed to allocate memory for destroy poll group ctx\n"); 257 return; 258 } 259 260 ctx->group = group; 261 _nvmf_tgt_disconnect_qpairs(ctx); 262 } 263 264 struct spdk_nvmf_tgt * 265 spdk_nvmf_tgt_create(struct spdk_nvmf_target_opts *opts) 266 { 267 struct spdk_nvmf_tgt *tgt, *tmp_tgt; 268 269 if (strnlen(opts->name, NVMF_TGT_NAME_MAX_LENGTH) == NVMF_TGT_NAME_MAX_LENGTH) { 270 SPDK_ERRLOG("Provided target name exceeds the max length of %u.\n", NVMF_TGT_NAME_MAX_LENGTH); 271 return NULL; 272 } 273 274 TAILQ_FOREACH(tmp_tgt, &g_nvmf_tgts, link) { 275 if (!strncmp(opts->name, tmp_tgt->name, NVMF_TGT_NAME_MAX_LENGTH)) { 276 SPDK_ERRLOG("Provided target name must be unique.\n"); 277 return NULL; 278 } 279 } 280 281 tgt = calloc(1, sizeof(*tgt)); 282 if (!tgt) { 283 return NULL; 284 } 285 286 snprintf(tgt->name, NVMF_TGT_NAME_MAX_LENGTH, "%s", opts->name); 287 288 if (!opts || !opts->max_subsystems) { 289 tgt->max_subsystems = SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS; 290 } else { 291 tgt->max_subsystems = opts->max_subsystems; 292 } 293 294 if (!opts) { 295 tgt->crdt[0] = 0; 296 tgt->crdt[1] = 0; 297 tgt->crdt[2] = 0; 298 } else { 299 tgt->crdt[0] = opts->crdt[0]; 300 tgt->crdt[1] = opts->crdt[1]; 301 tgt->crdt[2] = opts->crdt[2]; 302 } 303 304 if (!opts) { 305 tgt->discovery_filter = SPDK_NVMF_TGT_DISCOVERY_MATCH_ANY; 306 } else { 307 tgt->discovery_filter = opts->discovery_filter; 308 } 309 310 tgt->discovery_genctr = 0; 311 TAILQ_INIT(&tgt->transports); 312 TAILQ_INIT(&tgt->poll_groups); 313 tgt->num_poll_groups = 0; 314 315 tgt->subsystem_ids = spdk_bit_array_create(tgt->max_subsystems); 316 if (tgt->subsystem_ids == NULL) { 317 free(tgt); 318 return NULL; 319 } 320 321 RB_INIT(&tgt->subsystems); 322 323 pthread_mutex_init(&tgt->mutex, NULL); 324 325 spdk_io_device_register(tgt, 326 nvmf_tgt_create_poll_group, 327 nvmf_tgt_destroy_poll_group, 328 sizeof(struct spdk_nvmf_poll_group), 329 tgt->name); 330 331 tgt->state = NVMF_TGT_RUNNING; 332 333 TAILQ_INSERT_HEAD(&g_nvmf_tgts, tgt, link); 334 335 return tgt; 336 } 337 338 static void 339 _nvmf_tgt_destroy_next_transport(void *ctx) 340 { 341 struct spdk_nvmf_tgt *tgt = ctx; 342 struct spdk_nvmf_transport *transport; 343 344 if (!TAILQ_EMPTY(&tgt->transports)) { 345 transport = TAILQ_FIRST(&tgt->transports); 346 TAILQ_REMOVE(&tgt->transports, transport, link); 347 spdk_nvmf_transport_destroy(transport, _nvmf_tgt_destroy_next_transport, tgt); 348 } else { 349 spdk_nvmf_tgt_destroy_done_fn *destroy_cb_fn = tgt->destroy_cb_fn; 350 void *destroy_cb_arg = tgt->destroy_cb_arg; 351 352 pthread_mutex_destroy(&tgt->mutex); 353 free(tgt); 354 355 if (destroy_cb_fn) { 356 destroy_cb_fn(destroy_cb_arg, 0); 357 } 358 } 359 } 360 361 static void 362 nvmf_tgt_destroy_cb(void *io_device) 363 { 364 struct spdk_nvmf_tgt *tgt = io_device; 365 struct spdk_nvmf_subsystem *subsystem, *subsystem_next; 366 int rc; 367 368 /* We will be freeing subsystems in this loop, so we always need to get the next one 369 * ahead of time, since we can't call get_next() on a subsystem that's been freed. 370 */ 371 for (subsystem = spdk_nvmf_subsystem_get_first(tgt), 372 subsystem_next = spdk_nvmf_subsystem_get_next(subsystem); 373 subsystem != NULL; 374 subsystem = subsystem_next, 375 subsystem_next = spdk_nvmf_subsystem_get_next(subsystem_next)) { 376 nvmf_subsystem_remove_all_listeners(subsystem, true); 377 378 rc = spdk_nvmf_subsystem_destroy(subsystem, nvmf_tgt_destroy_cb, tgt); 379 if (rc) { 380 if (rc == -EINPROGRESS) { 381 /* If rc is -EINPROGRESS, nvmf_tgt_destroy_cb will be called again when subsystem #i 382 * is destroyed, nvmf_tgt_destroy_cb will continue to destroy other subsystems if any */ 383 return; 384 } else { 385 SPDK_ERRLOG("Failed to destroy subsystem %s, rc %d\n", subsystem->subnqn, rc); 386 } 387 } 388 } 389 spdk_bit_array_free(&tgt->subsystem_ids); 390 _nvmf_tgt_destroy_next_transport(tgt); 391 } 392 393 void 394 spdk_nvmf_tgt_destroy(struct spdk_nvmf_tgt *tgt, 395 spdk_nvmf_tgt_destroy_done_fn cb_fn, 396 void *cb_arg) 397 { 398 assert(!(tgt->state == NVMF_TGT_PAUSING || tgt->state == NVMF_TGT_RESUMING)); 399 400 tgt->destroy_cb_fn = cb_fn; 401 tgt->destroy_cb_arg = cb_arg; 402 403 TAILQ_REMOVE(&g_nvmf_tgts, tgt, link); 404 405 spdk_io_device_unregister(tgt, nvmf_tgt_destroy_cb); 406 } 407 408 const char * 409 spdk_nvmf_tgt_get_name(struct spdk_nvmf_tgt *tgt) 410 { 411 return tgt->name; 412 } 413 414 struct spdk_nvmf_tgt * 415 spdk_nvmf_get_tgt(const char *name) 416 { 417 struct spdk_nvmf_tgt *tgt; 418 uint32_t num_targets = 0; 419 420 TAILQ_FOREACH(tgt, &g_nvmf_tgts, link) { 421 if (name) { 422 if (!strncmp(tgt->name, name, NVMF_TGT_NAME_MAX_LENGTH)) { 423 return tgt; 424 } 425 } 426 num_targets++; 427 } 428 429 /* 430 * special case. If there is only one target and 431 * no name was specified, return the only available 432 * target. If there is more than one target, name must 433 * be specified. 434 */ 435 if (!name && num_targets == 1) { 436 return TAILQ_FIRST(&g_nvmf_tgts); 437 } 438 439 return NULL; 440 } 441 442 struct spdk_nvmf_tgt * 443 spdk_nvmf_get_first_tgt(void) 444 { 445 return TAILQ_FIRST(&g_nvmf_tgts); 446 } 447 448 struct spdk_nvmf_tgt * 449 spdk_nvmf_get_next_tgt(struct spdk_nvmf_tgt *prev) 450 { 451 return TAILQ_NEXT(prev, link); 452 } 453 454 static void 455 nvmf_write_subsystem_config_json(struct spdk_json_write_ctx *w, 456 struct spdk_nvmf_subsystem *subsystem) 457 { 458 struct spdk_nvmf_host *host; 459 struct spdk_nvmf_subsystem_listener *listener; 460 const struct spdk_nvme_transport_id *trid; 461 struct spdk_nvmf_ns *ns; 462 struct spdk_nvmf_ns_opts ns_opts; 463 uint32_t max_namespaces; 464 char uuid_str[SPDK_UUID_STRING_LEN]; 465 struct spdk_nvmf_transport *transport; 466 467 if (spdk_nvmf_subsystem_get_type(subsystem) != SPDK_NVMF_SUBTYPE_NVME) { 468 return; 469 } 470 471 /* { */ 472 spdk_json_write_object_begin(w); 473 spdk_json_write_named_string(w, "method", "nvmf_create_subsystem"); 474 475 /* "params" : { */ 476 spdk_json_write_named_object_begin(w, "params"); 477 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 478 spdk_json_write_named_bool(w, "allow_any_host", spdk_nvmf_subsystem_get_allow_any_host(subsystem)); 479 spdk_json_write_named_string(w, "serial_number", spdk_nvmf_subsystem_get_sn(subsystem)); 480 spdk_json_write_named_string(w, "model_number", spdk_nvmf_subsystem_get_mn(subsystem)); 481 482 max_namespaces = spdk_nvmf_subsystem_get_max_namespaces(subsystem); 483 if (max_namespaces != 0) { 484 spdk_json_write_named_uint32(w, "max_namespaces", max_namespaces); 485 } 486 487 spdk_json_write_named_uint32(w, "min_cntlid", spdk_nvmf_subsystem_get_min_cntlid(subsystem)); 488 spdk_json_write_named_uint32(w, "max_cntlid", spdk_nvmf_subsystem_get_max_cntlid(subsystem)); 489 spdk_json_write_named_bool(w, "ana_reporting", nvmf_subsystem_get_ana_reporting(subsystem)); 490 491 /* } "params" */ 492 spdk_json_write_object_end(w); 493 494 /* } */ 495 spdk_json_write_object_end(w); 496 497 for (host = spdk_nvmf_subsystem_get_first_host(subsystem); host != NULL; 498 host = spdk_nvmf_subsystem_get_next_host(subsystem, host)) { 499 500 spdk_json_write_object_begin(w); 501 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_host"); 502 503 /* "params" : { */ 504 spdk_json_write_named_object_begin(w, "params"); 505 506 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 507 spdk_json_write_named_string(w, "host", spdk_nvmf_host_get_nqn(host)); 508 509 TAILQ_FOREACH(transport, &subsystem->tgt->transports, link) { 510 if (transport->ops->subsystem_dump_host != NULL) { 511 transport->ops->subsystem_dump_host(transport, subsystem, host->nqn, w); 512 } 513 } 514 515 /* } "params" */ 516 spdk_json_write_object_end(w); 517 518 /* } */ 519 spdk_json_write_object_end(w); 520 } 521 522 for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); ns != NULL; 523 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) { 524 spdk_nvmf_ns_get_opts(ns, &ns_opts, sizeof(ns_opts)); 525 526 spdk_json_write_object_begin(w); 527 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_ns"); 528 529 /* "params" : { */ 530 spdk_json_write_named_object_begin(w, "params"); 531 532 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 533 534 /* "namespace" : { */ 535 spdk_json_write_named_object_begin(w, "namespace"); 536 537 spdk_json_write_named_uint32(w, "nsid", spdk_nvmf_ns_get_id(ns)); 538 spdk_json_write_named_string(w, "bdev_name", spdk_bdev_get_name(spdk_nvmf_ns_get_bdev(ns))); 539 540 if (!spdk_mem_all_zero(ns_opts.nguid, sizeof(ns_opts.nguid))) { 541 SPDK_STATIC_ASSERT(sizeof(ns_opts.nguid) == sizeof(uint64_t) * 2, "size mismatch"); 542 spdk_json_write_named_string_fmt(w, "nguid", "%016"PRIX64"%016"PRIX64, from_be64(&ns_opts.nguid[0]), 543 from_be64(&ns_opts.nguid[8])); 544 } 545 546 if (!spdk_mem_all_zero(ns_opts.eui64, sizeof(ns_opts.eui64))) { 547 SPDK_STATIC_ASSERT(sizeof(ns_opts.eui64) == sizeof(uint64_t), "size mismatch"); 548 spdk_json_write_named_string_fmt(w, "eui64", "%016"PRIX64, from_be64(&ns_opts.eui64)); 549 } 550 551 if (!spdk_uuid_is_null(&ns_opts.uuid)) { 552 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &ns_opts.uuid); 553 spdk_json_write_named_string(w, "uuid", uuid_str); 554 } 555 556 if (nvmf_subsystem_get_ana_reporting(subsystem)) { 557 spdk_json_write_named_uint32(w, "anagrpid", ns_opts.anagrpid); 558 } 559 560 /* "namespace" */ 561 spdk_json_write_object_end(w); 562 563 /* } "params" */ 564 spdk_json_write_object_end(w); 565 566 /* } */ 567 spdk_json_write_object_end(w); 568 } 569 570 for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL; 571 listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) { 572 transport = listener->transport; 573 trid = spdk_nvmf_subsystem_listener_get_trid(listener); 574 575 spdk_json_write_object_begin(w); 576 spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_listener"); 577 578 /* "params" : { */ 579 spdk_json_write_named_object_begin(w, "params"); 580 581 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 582 583 spdk_json_write_named_object_begin(w, "listen_address"); 584 nvmf_transport_listen_dump_trid(trid, w); 585 spdk_json_write_object_end(w); 586 if (transport->ops->listen_dump_opts) { 587 transport->ops->listen_dump_opts(transport, trid, w); 588 } 589 590 spdk_json_write_named_bool(w, "secure_channel", listener->opts.secure_channel); 591 592 /* } "params" */ 593 spdk_json_write_object_end(w); 594 595 /* } */ 596 spdk_json_write_object_end(w); 597 } 598 599 } 600 601 void 602 spdk_nvmf_tgt_write_config_json(struct spdk_json_write_ctx *w, struct spdk_nvmf_tgt *tgt) 603 { 604 struct spdk_nvmf_subsystem *subsystem; 605 struct spdk_nvmf_transport *transport; 606 607 spdk_json_write_object_begin(w); 608 spdk_json_write_named_string(w, "method", "nvmf_set_max_subsystems"); 609 610 spdk_json_write_named_object_begin(w, "params"); 611 spdk_json_write_named_uint32(w, "max_subsystems", tgt->max_subsystems); 612 spdk_json_write_object_end(w); 613 614 spdk_json_write_object_end(w); 615 616 spdk_json_write_object_begin(w); 617 spdk_json_write_named_string(w, "method", "nvmf_set_crdt"); 618 spdk_json_write_named_object_begin(w, "params"); 619 spdk_json_write_named_uint32(w, "crdt1", tgt->crdt[0]); 620 spdk_json_write_named_uint32(w, "crdt2", tgt->crdt[1]); 621 spdk_json_write_named_uint32(w, "crdt3", tgt->crdt[2]); 622 spdk_json_write_object_end(w); 623 spdk_json_write_object_end(w); 624 625 /* write transports */ 626 TAILQ_FOREACH(transport, &tgt->transports, link) { 627 spdk_json_write_object_begin(w); 628 spdk_json_write_named_string(w, "method", "nvmf_create_transport"); 629 nvmf_transport_dump_opts(transport, w, true); 630 spdk_json_write_object_end(w); 631 } 632 633 subsystem = spdk_nvmf_subsystem_get_first(tgt); 634 while (subsystem) { 635 nvmf_write_subsystem_config_json(w, subsystem); 636 subsystem = spdk_nvmf_subsystem_get_next(subsystem); 637 } 638 } 639 640 static void 641 nvmf_listen_opts_copy(struct spdk_nvmf_listen_opts *opts, 642 const struct spdk_nvmf_listen_opts *opts_src, size_t opts_size) 643 { 644 assert(opts); 645 assert(opts_src); 646 647 opts->opts_size = opts_size; 648 649 #define SET_FIELD(field) \ 650 if (offsetof(struct spdk_nvmf_listen_opts, field) + sizeof(opts->field) <= opts_size) { \ 651 opts->field = opts_src->field; \ 652 } \ 653 654 SET_FIELD(transport_specific); 655 SET_FIELD(secure_channel); 656 #undef SET_FIELD 657 658 /* Do not remove this statement, you should always update this statement when you adding a new field, 659 * and do not forget to add the SET_FIELD statement for your added field. */ 660 SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_listen_opts) == 17, "Incorrect size"); 661 } 662 663 void 664 spdk_nvmf_listen_opts_init(struct spdk_nvmf_listen_opts *opts, size_t opts_size) 665 { 666 struct spdk_nvmf_listen_opts opts_local = {}; 667 668 /* local version of opts should have defaults set here */ 669 670 nvmf_listen_opts_copy(opts, &opts_local, opts_size); 671 } 672 673 int 674 spdk_nvmf_tgt_listen_ext(struct spdk_nvmf_tgt *tgt, const struct spdk_nvme_transport_id *trid, 675 struct spdk_nvmf_listen_opts *opts) 676 { 677 struct spdk_nvmf_transport *transport; 678 int rc; 679 struct spdk_nvmf_listen_opts opts_local = {}; 680 681 if (!opts) { 682 SPDK_ERRLOG("opts should not be NULL\n"); 683 return -EINVAL; 684 } 685 686 if (!opts->opts_size) { 687 SPDK_ERRLOG("The opts_size in opts structure should not be zero\n"); 688 return -EINVAL; 689 } 690 691 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 692 if (!transport) { 693 SPDK_ERRLOG("Unable to find %s transport. The transport must be created first also make sure it is properly registered.\n", 694 trid->trstring); 695 return -EINVAL; 696 } 697 698 nvmf_listen_opts_copy(&opts_local, opts, opts->opts_size); 699 rc = spdk_nvmf_transport_listen(transport, trid, &opts_local); 700 if (rc < 0) { 701 SPDK_ERRLOG("Unable to listen on address '%s'\n", trid->traddr); 702 } 703 704 return rc; 705 } 706 707 int 708 spdk_nvmf_tgt_stop_listen(struct spdk_nvmf_tgt *tgt, 709 struct spdk_nvme_transport_id *trid) 710 { 711 struct spdk_nvmf_transport *transport; 712 int rc; 713 714 transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring); 715 if (!transport) { 716 SPDK_ERRLOG("Unable to find %s transport. The transport must be created first also make sure it is properly registered.\n", 717 trid->trstring); 718 return -EINVAL; 719 } 720 721 rc = spdk_nvmf_transport_stop_listen(transport, trid); 722 if (rc < 0) { 723 SPDK_ERRLOG("Failed to stop listening on address '%s'\n", trid->traddr); 724 return rc; 725 } 726 return 0; 727 } 728 729 struct spdk_nvmf_tgt_add_transport_ctx { 730 struct spdk_nvmf_tgt *tgt; 731 struct spdk_nvmf_transport *transport; 732 spdk_nvmf_tgt_add_transport_done_fn cb_fn; 733 void *cb_arg; 734 int status; 735 }; 736 737 static void 738 _nvmf_tgt_remove_transport_done(struct spdk_io_channel_iter *i, int status) 739 { 740 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 741 742 ctx->cb_fn(ctx->cb_arg, ctx->status); 743 free(ctx); 744 } 745 746 static void 747 _nvmf_tgt_remove_transport(struct spdk_io_channel_iter *i) 748 { 749 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 750 struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i); 751 struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch); 752 struct spdk_nvmf_transport_poll_group *tgroup, *tmp; 753 754 TAILQ_FOREACH_SAFE(tgroup, &group->tgroups, link, tmp) { 755 if (tgroup->transport == ctx->transport) { 756 TAILQ_REMOVE(&group->tgroups, tgroup, link); 757 nvmf_transport_poll_group_destroy(tgroup); 758 } 759 } 760 761 spdk_for_each_channel_continue(i, 0); 762 } 763 764 static void 765 _nvmf_tgt_add_transport_done(struct spdk_io_channel_iter *i, int status) 766 { 767 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 768 769 if (status) { 770 ctx->status = status; 771 spdk_for_each_channel(ctx->tgt, 772 _nvmf_tgt_remove_transport, 773 ctx, 774 _nvmf_tgt_remove_transport_done); 775 return; 776 } 777 778 ctx->transport->tgt = ctx->tgt; 779 TAILQ_INSERT_TAIL(&ctx->tgt->transports, ctx->transport, link); 780 ctx->cb_fn(ctx->cb_arg, status); 781 free(ctx); 782 } 783 784 static void 785 _nvmf_tgt_add_transport(struct spdk_io_channel_iter *i) 786 { 787 struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 788 struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i); 789 struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch); 790 int rc; 791 792 rc = nvmf_poll_group_add_transport(group, ctx->transport); 793 spdk_for_each_channel_continue(i, rc); 794 } 795 796 void 797 spdk_nvmf_tgt_add_transport(struct spdk_nvmf_tgt *tgt, 798 struct spdk_nvmf_transport *transport, 799 spdk_nvmf_tgt_add_transport_done_fn cb_fn, 800 void *cb_arg) 801 { 802 struct spdk_nvmf_tgt_add_transport_ctx *ctx; 803 804 SPDK_DTRACE_PROBE2_TICKS(nvmf_tgt_add_transport, transport, tgt->name); 805 806 if (spdk_nvmf_tgt_get_transport(tgt, transport->ops->name)) { 807 cb_fn(cb_arg, -EEXIST); 808 return; /* transport already created */ 809 } 810 811 ctx = calloc(1, sizeof(*ctx)); 812 if (!ctx) { 813 cb_fn(cb_arg, -ENOMEM); 814 return; 815 } 816 817 ctx->tgt = tgt; 818 ctx->transport = transport; 819 ctx->cb_fn = cb_fn; 820 ctx->cb_arg = cb_arg; 821 822 spdk_for_each_channel(tgt, 823 _nvmf_tgt_add_transport, 824 ctx, 825 _nvmf_tgt_add_transport_done); 826 } 827 828 struct nvmf_tgt_pause_ctx { 829 struct spdk_nvmf_tgt *tgt; 830 spdk_nvmf_tgt_pause_polling_cb_fn cb_fn; 831 void *cb_arg; 832 }; 833 834 static void 835 _nvmf_tgt_pause_polling_done(struct spdk_io_channel_iter *i, int status) 836 { 837 struct nvmf_tgt_pause_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 838 839 ctx->tgt->state = NVMF_TGT_PAUSED; 840 841 ctx->cb_fn(ctx->cb_arg, status); 842 free(ctx); 843 } 844 845 static void 846 _nvmf_tgt_pause_polling(struct spdk_io_channel_iter *i) 847 { 848 struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i); 849 struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch); 850 851 spdk_poller_unregister(&group->poller); 852 853 spdk_for_each_channel_continue(i, 0); 854 } 855 856 int 857 spdk_nvmf_tgt_pause_polling(struct spdk_nvmf_tgt *tgt, spdk_nvmf_tgt_pause_polling_cb_fn cb_fn, 858 void *cb_arg) 859 { 860 struct nvmf_tgt_pause_ctx *ctx; 861 862 SPDK_DTRACE_PROBE2_TICKS(nvmf_tgt_pause_polling, tgt, tgt->name); 863 864 switch (tgt->state) { 865 case NVMF_TGT_PAUSING: 866 case NVMF_TGT_RESUMING: 867 return -EBUSY; 868 case NVMF_TGT_RUNNING: 869 break; 870 default: 871 return -EINVAL; 872 } 873 874 ctx = calloc(1, sizeof(*ctx)); 875 if (!ctx) { 876 return -ENOMEM; 877 } 878 879 880 tgt->state = NVMF_TGT_PAUSING; 881 882 ctx->tgt = tgt; 883 ctx->cb_fn = cb_fn; 884 ctx->cb_arg = cb_arg; 885 886 spdk_for_each_channel(tgt, 887 _nvmf_tgt_pause_polling, 888 ctx, 889 _nvmf_tgt_pause_polling_done); 890 return 0; 891 } 892 893 static void 894 _nvmf_tgt_resume_polling_done(struct spdk_io_channel_iter *i, int status) 895 { 896 struct nvmf_tgt_pause_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 897 898 ctx->tgt->state = NVMF_TGT_RUNNING; 899 900 ctx->cb_fn(ctx->cb_arg, status); 901 free(ctx); 902 } 903 904 static void 905 _nvmf_tgt_resume_polling(struct spdk_io_channel_iter *i) 906 { 907 struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i); 908 struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch); 909 910 assert(group->poller == NULL); 911 group->poller = SPDK_POLLER_REGISTER(nvmf_poll_group_poll, group, 0); 912 913 spdk_for_each_channel_continue(i, 0); 914 } 915 916 int 917 spdk_nvmf_tgt_resume_polling(struct spdk_nvmf_tgt *tgt, spdk_nvmf_tgt_resume_polling_cb_fn cb_fn, 918 void *cb_arg) 919 { 920 struct nvmf_tgt_pause_ctx *ctx; 921 922 SPDK_DTRACE_PROBE2_TICKS(nvmf_tgt_resume_polling, tgt, tgt->name); 923 924 switch (tgt->state) { 925 case NVMF_TGT_PAUSING: 926 case NVMF_TGT_RESUMING: 927 return -EBUSY; 928 case NVMF_TGT_PAUSED: 929 break; 930 default: 931 return -EINVAL; 932 } 933 934 ctx = calloc(1, sizeof(*ctx)); 935 if (!ctx) { 936 return -ENOMEM; 937 } 938 939 tgt->state = NVMF_TGT_RESUMING; 940 941 ctx->tgt = tgt; 942 ctx->cb_fn = cb_fn; 943 ctx->cb_arg = cb_arg; 944 945 spdk_for_each_channel(tgt, 946 _nvmf_tgt_resume_polling, 947 ctx, 948 _nvmf_tgt_resume_polling_done); 949 return 0; 950 } 951 952 struct spdk_nvmf_subsystem * 953 spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) 954 { 955 struct spdk_nvmf_subsystem subsystem; 956 957 if (!subnqn) { 958 return NULL; 959 } 960 961 /* Ensure that subnqn is null terminated */ 962 if (!memchr(subnqn, '\0', SPDK_NVMF_NQN_MAX_LEN + 1)) { 963 SPDK_ERRLOG("Connect SUBNQN is not null terminated\n"); 964 return NULL; 965 } 966 967 snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn); 968 return RB_FIND(subsystem_tree, &tgt->subsystems, &subsystem); 969 } 970 971 struct spdk_nvmf_transport * 972 spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name) 973 { 974 struct spdk_nvmf_transport *transport; 975 976 TAILQ_FOREACH(transport, &tgt->transports, link) { 977 if (!strncasecmp(transport->ops->name, transport_name, SPDK_NVMF_TRSTRING_MAX_LEN)) { 978 return transport; 979 } 980 } 981 return NULL; 982 } 983 984 struct nvmf_new_qpair_ctx { 985 struct spdk_nvmf_qpair *qpair; 986 struct spdk_nvmf_poll_group *group; 987 }; 988 989 static void 990 _nvmf_poll_group_add(void *_ctx) 991 { 992 struct nvmf_new_qpair_ctx *ctx = _ctx; 993 struct spdk_nvmf_qpair *qpair = ctx->qpair; 994 struct spdk_nvmf_poll_group *group = ctx->group; 995 996 free(_ctx); 997 998 if (spdk_nvmf_poll_group_add(group, qpair) != 0) { 999 SPDK_ERRLOG("Unable to add the qpair to a poll group.\n"); 1000 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 1001 } 1002 } 1003 1004 void 1005 spdk_nvmf_tgt_new_qpair(struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair) 1006 { 1007 struct spdk_nvmf_poll_group *group; 1008 struct nvmf_new_qpair_ctx *ctx; 1009 1010 group = spdk_nvmf_get_optimal_poll_group(qpair); 1011 if (group == NULL) { 1012 if (tgt->next_poll_group == NULL) { 1013 tgt->next_poll_group = TAILQ_FIRST(&tgt->poll_groups); 1014 if (tgt->next_poll_group == NULL) { 1015 SPDK_ERRLOG("No poll groups exist.\n"); 1016 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 1017 return; 1018 } 1019 } 1020 group = tgt->next_poll_group; 1021 tgt->next_poll_group = TAILQ_NEXT(group, link); 1022 } 1023 1024 ctx = calloc(1, sizeof(*ctx)); 1025 if (!ctx) { 1026 SPDK_ERRLOG("Unable to send message to poll group.\n"); 1027 spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 1028 return; 1029 } 1030 1031 ctx->qpair = qpair; 1032 ctx->group = group; 1033 1034 pthread_mutex_lock(&group->mutex); 1035 group->current_unassociated_qpairs++; 1036 pthread_mutex_unlock(&group->mutex); 1037 1038 spdk_thread_send_msg(group->thread, _nvmf_poll_group_add, ctx); 1039 } 1040 1041 struct spdk_nvmf_poll_group * 1042 spdk_nvmf_poll_group_create(struct spdk_nvmf_tgt *tgt) 1043 { 1044 struct spdk_io_channel *ch; 1045 1046 ch = spdk_get_io_channel(tgt); 1047 if (!ch) { 1048 SPDK_ERRLOG("Unable to get I/O channel for target\n"); 1049 return NULL; 1050 } 1051 1052 return spdk_io_channel_get_ctx(ch); 1053 } 1054 1055 void 1056 spdk_nvmf_poll_group_destroy(struct spdk_nvmf_poll_group *group, 1057 spdk_nvmf_poll_group_destroy_done_fn cb_fn, 1058 void *cb_arg) 1059 { 1060 assert(group->destroy_cb_fn == NULL); 1061 group->destroy_cb_fn = cb_fn; 1062 group->destroy_cb_arg = cb_arg; 1063 1064 /* This function will put the io_channel associated with this poll group */ 1065 nvmf_tgt_destroy_poll_group_qpairs(group); 1066 } 1067 1068 int 1069 spdk_nvmf_poll_group_add(struct spdk_nvmf_poll_group *group, 1070 struct spdk_nvmf_qpair *qpair) 1071 { 1072 int rc = -1; 1073 struct spdk_nvmf_transport_poll_group *tgroup; 1074 1075 TAILQ_INIT(&qpair->outstanding); 1076 qpair->group = group; 1077 qpair->ctrlr = NULL; 1078 qpair->disconnect_started = false; 1079 1080 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 1081 if (tgroup->transport == qpair->transport) { 1082 rc = nvmf_transport_poll_group_add(tgroup, qpair); 1083 break; 1084 } 1085 } 1086 1087 /* We add the qpair to the group only it is successfully added into the tgroup */ 1088 if (rc == 0) { 1089 SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_add_qpair, qpair, spdk_thread_get_id(group->thread)); 1090 TAILQ_INSERT_TAIL(&group->qpairs, qpair, link); 1091 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ACTIVE); 1092 } 1093 1094 return rc; 1095 } 1096 1097 static void 1098 _nvmf_ctrlr_destruct(void *ctx) 1099 { 1100 struct spdk_nvmf_ctrlr *ctrlr = ctx; 1101 1102 nvmf_ctrlr_destruct(ctrlr); 1103 } 1104 1105 static void 1106 _nvmf_ctrlr_free_from_qpair(void *ctx) 1107 { 1108 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 1109 struct spdk_nvmf_ctrlr *ctrlr = qpair_ctx->ctrlr; 1110 uint32_t count; 1111 1112 spdk_bit_array_clear(ctrlr->qpair_mask, qpair_ctx->qid); 1113 count = spdk_bit_array_count_set(ctrlr->qpair_mask); 1114 if (count == 0) { 1115 assert(!ctrlr->in_destruct); 1116 SPDK_DEBUGLOG(nvmf, "Last qpair %u, destroy ctrlr 0x%hx\n", qpair_ctx->qid, ctrlr->cntlid); 1117 ctrlr->in_destruct = true; 1118 spdk_thread_send_msg(ctrlr->subsys->thread, _nvmf_ctrlr_destruct, ctrlr); 1119 } 1120 free(qpair_ctx); 1121 } 1122 1123 static void 1124 _nvmf_transport_qpair_fini_complete(void *cb_ctx) 1125 { 1126 struct nvmf_qpair_disconnect_ctx *qpair_ctx = cb_ctx; 1127 struct spdk_nvmf_ctrlr *ctrlr; 1128 /* Store cb args since cb_ctx can be freed in _nvmf_ctrlr_free_from_qpair */ 1129 nvmf_qpair_disconnect_cb cb_fn = qpair_ctx->cb_fn; 1130 void *cb_arg = qpair_ctx->ctx; 1131 struct spdk_thread *cb_thread = qpair_ctx->thread; 1132 1133 ctrlr = qpair_ctx->ctrlr; 1134 SPDK_DEBUGLOG(nvmf, "Finish destroying qid %u\n", qpair_ctx->qid); 1135 1136 if (ctrlr) { 1137 if (qpair_ctx->qid == 0) { 1138 /* Admin qpair is removed, so set the pointer to NULL. 1139 * This operation is safe since we are on ctrlr thread now, admin qpair's thread is the same 1140 * as controller's thread */ 1141 assert(ctrlr->thread == spdk_get_thread()); 1142 ctrlr->admin_qpair = NULL; 1143 } 1144 /* Free qpair id from controller's bit mask and destroy the controller if it is the last qpair */ 1145 if (ctrlr->thread) { 1146 spdk_thread_send_msg(ctrlr->thread, _nvmf_ctrlr_free_from_qpair, qpair_ctx); 1147 } else { 1148 _nvmf_ctrlr_free_from_qpair(qpair_ctx); 1149 } 1150 } else { 1151 free(qpair_ctx); 1152 } 1153 1154 if (cb_fn) { 1155 spdk_thread_send_msg(cb_thread, cb_fn, cb_arg); 1156 } 1157 } 1158 1159 void 1160 spdk_nvmf_poll_group_remove(struct spdk_nvmf_qpair *qpair) 1161 { 1162 struct spdk_nvmf_transport_poll_group *tgroup; 1163 int rc; 1164 1165 SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_remove_qpair, qpair, 1166 spdk_thread_get_id(qpair->group->thread)); 1167 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ERROR); 1168 1169 /* Find the tgroup and remove the qpair from the tgroup */ 1170 TAILQ_FOREACH(tgroup, &qpair->group->tgroups, link) { 1171 if (tgroup->transport == qpair->transport) { 1172 rc = nvmf_transport_poll_group_remove(tgroup, qpair); 1173 if (rc && (rc != ENOTSUP)) { 1174 SPDK_ERRLOG("Cannot remove qpair=%p from transport group=%p\n", 1175 qpair, tgroup); 1176 } 1177 break; 1178 } 1179 } 1180 1181 TAILQ_REMOVE(&qpair->group->qpairs, qpair, link); 1182 qpair->group = NULL; 1183 } 1184 1185 static void 1186 _nvmf_qpair_sgroup_req_clean(struct spdk_nvmf_subsystem_poll_group *sgroup, 1187 const struct spdk_nvmf_qpair *qpair) 1188 { 1189 struct spdk_nvmf_request *req, *tmp; 1190 TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) { 1191 if (req->qpair == qpair) { 1192 TAILQ_REMOVE(&sgroup->queued, req, link); 1193 if (nvmf_transport_req_free(req)) { 1194 SPDK_ERRLOG("Transport request free error!\n"); 1195 } 1196 } 1197 } 1198 } 1199 1200 static void 1201 _nvmf_qpair_destroy(void *ctx, int status) 1202 { 1203 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 1204 struct spdk_nvmf_qpair *qpair = qpair_ctx->qpair; 1205 struct spdk_nvmf_ctrlr *ctrlr = qpair->ctrlr; 1206 struct spdk_nvmf_subsystem_poll_group *sgroup; 1207 uint32_t sid; 1208 1209 assert(qpair->state == SPDK_NVMF_QPAIR_DEACTIVATING); 1210 qpair_ctx->qid = qpair->qid; 1211 1212 if (qpair->connect_received) { 1213 if (0 == qpair->qid) { 1214 assert(qpair->group->stat.current_admin_qpairs > 0); 1215 qpair->group->stat.current_admin_qpairs--; 1216 } else { 1217 assert(qpair->group->stat.current_io_qpairs > 0); 1218 qpair->group->stat.current_io_qpairs--; 1219 } 1220 } else { 1221 pthread_mutex_lock(&qpair->group->mutex); 1222 qpair->group->current_unassociated_qpairs--; 1223 pthread_mutex_unlock(&qpair->group->mutex); 1224 } 1225 1226 if (ctrlr) { 1227 sgroup = &qpair->group->sgroups[ctrlr->subsys->id]; 1228 _nvmf_qpair_sgroup_req_clean(sgroup, qpair); 1229 } else { 1230 for (sid = 0; sid < qpair->group->num_sgroups; sid++) { 1231 sgroup = &qpair->group->sgroups[sid]; 1232 assert(sgroup != NULL); 1233 _nvmf_qpair_sgroup_req_clean(sgroup, qpair); 1234 } 1235 } 1236 1237 qpair_ctx->ctrlr = ctrlr; 1238 spdk_nvmf_poll_group_remove(qpair); 1239 nvmf_transport_qpair_fini(qpair, _nvmf_transport_qpair_fini_complete, qpair_ctx); 1240 } 1241 1242 static void 1243 _nvmf_qpair_disconnect_msg(void *ctx) 1244 { 1245 struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx; 1246 1247 spdk_nvmf_qpair_disconnect(qpair_ctx->qpair, qpair_ctx->cb_fn, qpair_ctx->ctx); 1248 free(ctx); 1249 } 1250 1251 SPDK_LOG_DEPRECATION_REGISTER(spdk_nvmf_qpair_disconnect, "cb_fn and ctx are deprecated", "v24.01", 1252 0); 1253 1254 int 1255 spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) 1256 { 1257 struct spdk_nvmf_poll_group *group = qpair->group; 1258 struct nvmf_qpair_disconnect_ctx *qpair_ctx; 1259 1260 if (__atomic_test_and_set(&qpair->disconnect_started, __ATOMIC_RELAXED)) { 1261 return -EINPROGRESS; 1262 } 1263 1264 if (cb_fn || ctx) { 1265 SPDK_LOG_DEPRECATED(spdk_nvmf_qpair_disconnect); 1266 } 1267 1268 /* If we get a qpair in the uninitialized state, we can just destroy it immediately */ 1269 if (qpair->state == SPDK_NVMF_QPAIR_UNINITIALIZED) { 1270 nvmf_transport_qpair_fini(qpair, NULL, NULL); 1271 if (cb_fn) { 1272 cb_fn(ctx); 1273 } 1274 return 0; 1275 } 1276 1277 assert(group != NULL); 1278 if (spdk_get_thread() != group->thread) { 1279 /* clear the atomic so we can set it on the next call on the proper thread. */ 1280 __atomic_clear(&qpair->disconnect_started, __ATOMIC_RELAXED); 1281 qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx)); 1282 if (!qpair_ctx) { 1283 SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n"); 1284 return -ENOMEM; 1285 } 1286 qpair_ctx->qpair = qpair; 1287 qpair_ctx->cb_fn = cb_fn; 1288 qpair_ctx->thread = group->thread; 1289 qpair_ctx->ctx = ctx; 1290 spdk_thread_send_msg(group->thread, _nvmf_qpair_disconnect_msg, qpair_ctx); 1291 return 0; 1292 } 1293 1294 SPDK_DTRACE_PROBE2_TICKS(nvmf_qpair_disconnect, qpair, spdk_thread_get_id(group->thread)); 1295 assert(qpair->state == SPDK_NVMF_QPAIR_ACTIVE); 1296 nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_DEACTIVATING); 1297 1298 qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx)); 1299 if (!qpair_ctx) { 1300 SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n"); 1301 return -ENOMEM; 1302 } 1303 1304 qpair_ctx->qpair = qpair; 1305 qpair_ctx->cb_fn = cb_fn; 1306 qpair_ctx->thread = group->thread; 1307 qpair_ctx->ctx = ctx; 1308 1309 /* Check for outstanding I/O */ 1310 if (!TAILQ_EMPTY(&qpair->outstanding)) { 1311 SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_drain_qpair, qpair, spdk_thread_get_id(group->thread)); 1312 qpair->state_cb = _nvmf_qpair_destroy; 1313 qpair->state_cb_arg = qpair_ctx; 1314 nvmf_qpair_abort_pending_zcopy_reqs(qpair); 1315 nvmf_qpair_free_aer(qpair); 1316 return 0; 1317 } 1318 1319 _nvmf_qpair_destroy(qpair_ctx, 0); 1320 1321 return 0; 1322 } 1323 1324 int 1325 spdk_nvmf_qpair_get_peer_trid(struct spdk_nvmf_qpair *qpair, 1326 struct spdk_nvme_transport_id *trid) 1327 { 1328 memset(trid, 0, sizeof(*trid)); 1329 return nvmf_transport_qpair_get_peer_trid(qpair, trid); 1330 } 1331 1332 int 1333 spdk_nvmf_qpair_get_local_trid(struct spdk_nvmf_qpair *qpair, 1334 struct spdk_nvme_transport_id *trid) 1335 { 1336 memset(trid, 0, sizeof(*trid)); 1337 return nvmf_transport_qpair_get_local_trid(qpair, trid); 1338 } 1339 1340 int 1341 spdk_nvmf_qpair_get_listen_trid(struct spdk_nvmf_qpair *qpair, 1342 struct spdk_nvme_transport_id *trid) 1343 { 1344 memset(trid, 0, sizeof(*trid)); 1345 return nvmf_transport_qpair_get_listen_trid(qpair, trid); 1346 } 1347 1348 static int 1349 poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 1350 struct spdk_nvmf_subsystem *subsystem) 1351 { 1352 struct spdk_nvmf_subsystem_poll_group *sgroup; 1353 uint32_t new_num_ns, old_num_ns; 1354 uint32_t i, j; 1355 struct spdk_nvmf_ns *ns; 1356 struct spdk_nvmf_registrant *reg, *tmp; 1357 struct spdk_io_channel *ch; 1358 struct spdk_nvmf_subsystem_pg_ns_info *ns_info; 1359 struct spdk_nvmf_ctrlr *ctrlr; 1360 bool ns_changed; 1361 1362 /* Make sure our poll group has memory for this subsystem allocated */ 1363 if (subsystem->id >= group->num_sgroups) { 1364 return -ENOMEM; 1365 } 1366 1367 sgroup = &group->sgroups[subsystem->id]; 1368 1369 /* Make sure the array of namespace information is the correct size */ 1370 new_num_ns = subsystem->max_nsid; 1371 old_num_ns = sgroup->num_ns; 1372 1373 ns_changed = false; 1374 1375 if (old_num_ns == 0) { 1376 if (new_num_ns > 0) { 1377 /* First allocation */ 1378 sgroup->ns_info = calloc(new_num_ns, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1379 if (!sgroup->ns_info) { 1380 return -ENOMEM; 1381 } 1382 } 1383 } else if (new_num_ns > old_num_ns) { 1384 void *buf; 1385 1386 /* Make the array larger */ 1387 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1388 if (!buf) { 1389 return -ENOMEM; 1390 } 1391 1392 sgroup->ns_info = buf; 1393 1394 /* Null out the new namespace information slots */ 1395 for (i = old_num_ns; i < new_num_ns; i++) { 1396 memset(&sgroup->ns_info[i], 0, sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1397 } 1398 } else if (new_num_ns < old_num_ns) { 1399 void *buf; 1400 1401 /* Free the extra I/O channels */ 1402 for (i = new_num_ns; i < old_num_ns; i++) { 1403 ns_info = &sgroup->ns_info[i]; 1404 1405 if (ns_info->channel) { 1406 spdk_put_io_channel(ns_info->channel); 1407 ns_info->channel = NULL; 1408 } 1409 } 1410 1411 /* Make the array smaller */ 1412 if (new_num_ns > 0) { 1413 buf = realloc(sgroup->ns_info, new_num_ns * sizeof(struct spdk_nvmf_subsystem_pg_ns_info)); 1414 if (!buf) { 1415 return -ENOMEM; 1416 } 1417 sgroup->ns_info = buf; 1418 } else { 1419 free(sgroup->ns_info); 1420 sgroup->ns_info = NULL; 1421 } 1422 } 1423 1424 sgroup->num_ns = new_num_ns; 1425 1426 /* Detect bdevs that were added or removed */ 1427 for (i = 0; i < sgroup->num_ns; i++) { 1428 ns = subsystem->ns[i]; 1429 ns_info = &sgroup->ns_info[i]; 1430 ch = ns_info->channel; 1431 1432 if (ns == NULL && ch == NULL) { 1433 /* Both NULL. Leave empty */ 1434 } else if (ns == NULL && ch != NULL) { 1435 /* There was a channel here, but the namespace is gone. */ 1436 ns_changed = true; 1437 spdk_put_io_channel(ch); 1438 ns_info->channel = NULL; 1439 } else if (ns != NULL && ch == NULL) { 1440 /* A namespace appeared but there is no channel yet */ 1441 ns_changed = true; 1442 ch = spdk_bdev_get_io_channel(ns->desc); 1443 if (ch == NULL) { 1444 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1445 return -ENOMEM; 1446 } 1447 ns_info->channel = ch; 1448 } else if (spdk_uuid_compare(&ns_info->uuid, spdk_bdev_get_uuid(ns->bdev)) != 0) { 1449 /* A namespace was here before, but was replaced by a new one. */ 1450 ns_changed = true; 1451 spdk_put_io_channel(ns_info->channel); 1452 memset(ns_info, 0, sizeof(*ns_info)); 1453 1454 ch = spdk_bdev_get_io_channel(ns->desc); 1455 if (ch == NULL) { 1456 SPDK_ERRLOG("Could not allocate I/O channel.\n"); 1457 return -ENOMEM; 1458 } 1459 ns_info->channel = ch; 1460 } else if (ns_info->num_blocks != spdk_bdev_get_num_blocks(ns->bdev)) { 1461 /* Namespace is still there but size has changed */ 1462 SPDK_DEBUGLOG(nvmf, "Namespace resized: subsystem_id %u," 1463 " nsid %u, pg %p, old %" PRIu64 ", new %" PRIu64 "\n", 1464 subsystem->id, 1465 ns->nsid, 1466 group, 1467 ns_info->num_blocks, 1468 spdk_bdev_get_num_blocks(ns->bdev)); 1469 ns_changed = true; 1470 } 1471 1472 if (ns == NULL) { 1473 memset(ns_info, 0, sizeof(*ns_info)); 1474 } else { 1475 ns_info->uuid = *spdk_bdev_get_uuid(ns->bdev); 1476 ns_info->num_blocks = spdk_bdev_get_num_blocks(ns->bdev); 1477 ns_info->crkey = ns->crkey; 1478 ns_info->rtype = ns->rtype; 1479 if (ns->holder) { 1480 ns_info->holder_id = ns->holder->hostid; 1481 } 1482 1483 memset(&ns_info->reg_hostid, 0, SPDK_NVMF_MAX_NUM_REGISTRANTS * sizeof(struct spdk_uuid)); 1484 j = 0; 1485 TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) { 1486 if (j >= SPDK_NVMF_MAX_NUM_REGISTRANTS) { 1487 SPDK_ERRLOG("Maximum %u registrants can support.\n", SPDK_NVMF_MAX_NUM_REGISTRANTS); 1488 return -EINVAL; 1489 } 1490 ns_info->reg_hostid[j++] = reg->hostid; 1491 } 1492 } 1493 } 1494 1495 if (ns_changed) { 1496 TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) { 1497 if (ctrlr->thread != spdk_get_thread()) { 1498 continue; 1499 } 1500 /* It is possible that a ctrlr was added but the admin_qpair hasn't been 1501 * assigned yet. 1502 */ 1503 if (!ctrlr->admin_qpair) { 1504 continue; 1505 } 1506 if (ctrlr->admin_qpair->group == group) { 1507 nvmf_ctrlr_async_event_ns_notice(ctrlr); 1508 nvmf_ctrlr_async_event_ana_change_notice(ctrlr); 1509 } 1510 } 1511 } 1512 1513 return 0; 1514 } 1515 1516 int 1517 nvmf_poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, 1518 struct spdk_nvmf_subsystem *subsystem) 1519 { 1520 return poll_group_update_subsystem(group, subsystem); 1521 } 1522 1523 int 1524 nvmf_poll_group_add_subsystem(struct spdk_nvmf_poll_group *group, 1525 struct spdk_nvmf_subsystem *subsystem, 1526 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1527 { 1528 int rc = 0; 1529 struct spdk_nvmf_subsystem_poll_group *sgroup = &group->sgroups[subsystem->id]; 1530 uint32_t i; 1531 1532 TAILQ_INIT(&sgroup->queued); 1533 1534 rc = poll_group_update_subsystem(group, subsystem); 1535 if (rc) { 1536 nvmf_poll_group_remove_subsystem(group, subsystem, NULL, NULL); 1537 goto fini; 1538 } 1539 1540 sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1541 1542 for (i = 0; i < sgroup->num_ns; i++) { 1543 sgroup->ns_info[i].state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1544 } 1545 1546 fini: 1547 if (cb_fn) { 1548 cb_fn(cb_arg, rc); 1549 } 1550 1551 SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_add_subsystem, spdk_thread_get_id(group->thread), 1552 subsystem->subnqn); 1553 1554 return rc; 1555 } 1556 1557 static void 1558 _nvmf_poll_group_remove_subsystem_cb(void *ctx, int status) 1559 { 1560 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 1561 struct spdk_nvmf_subsystem *subsystem; 1562 struct spdk_nvmf_poll_group *group; 1563 struct spdk_nvmf_subsystem_poll_group *sgroup; 1564 spdk_nvmf_poll_group_mod_done cpl_fn = NULL; 1565 void *cpl_ctx = NULL; 1566 uint32_t nsid; 1567 1568 group = qpair_ctx->group; 1569 subsystem = qpair_ctx->subsystem; 1570 cpl_fn = qpair_ctx->cpl_fn; 1571 cpl_ctx = qpair_ctx->cpl_ctx; 1572 sgroup = &group->sgroups[subsystem->id]; 1573 1574 if (status) { 1575 goto fini; 1576 } 1577 1578 for (nsid = 0; nsid < sgroup->num_ns; nsid++) { 1579 if (sgroup->ns_info[nsid].channel) { 1580 spdk_put_io_channel(sgroup->ns_info[nsid].channel); 1581 sgroup->ns_info[nsid].channel = NULL; 1582 } 1583 } 1584 1585 sgroup->num_ns = 0; 1586 free(sgroup->ns_info); 1587 sgroup->ns_info = NULL; 1588 fini: 1589 free(qpair_ctx); 1590 if (cpl_fn) { 1591 cpl_fn(cpl_ctx, status); 1592 } 1593 } 1594 1595 static void nvmf_poll_group_remove_subsystem_msg(void *ctx); 1596 1597 static void 1598 nvmf_poll_group_remove_subsystem_msg(void *ctx) 1599 { 1600 struct spdk_nvmf_qpair *qpair, *qpair_tmp; 1601 struct spdk_nvmf_subsystem *subsystem; 1602 struct spdk_nvmf_poll_group *group; 1603 struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx; 1604 bool qpairs_found = false; 1605 int rc = 0; 1606 1607 group = qpair_ctx->group; 1608 subsystem = qpair_ctx->subsystem; 1609 1610 TAILQ_FOREACH_SAFE(qpair, &group->qpairs, link, qpair_tmp) { 1611 if ((qpair->ctrlr != NULL) && (qpair->ctrlr->subsys == subsystem)) { 1612 qpairs_found = true; 1613 rc = spdk_nvmf_qpair_disconnect(qpair, NULL, NULL); 1614 if (rc && rc != -EINPROGRESS) { 1615 break; 1616 } 1617 } 1618 } 1619 1620 if (!qpairs_found) { 1621 _nvmf_poll_group_remove_subsystem_cb(ctx, 0); 1622 return; 1623 } 1624 1625 /* Some qpairs are in process of being disconnected. Send a message and try to remove them again */ 1626 spdk_thread_send_msg(spdk_get_thread(), nvmf_poll_group_remove_subsystem_msg, ctx); 1627 } 1628 1629 void 1630 nvmf_poll_group_remove_subsystem(struct spdk_nvmf_poll_group *group, 1631 struct spdk_nvmf_subsystem *subsystem, 1632 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1633 { 1634 struct spdk_nvmf_subsystem_poll_group *sgroup; 1635 struct nvmf_qpair_disconnect_many_ctx *ctx; 1636 uint32_t i; 1637 1638 SPDK_DTRACE_PROBE3_TICKS(nvmf_poll_group_remove_subsystem, group, spdk_thread_get_id(group->thread), 1639 subsystem->subnqn); 1640 1641 ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx)); 1642 if (!ctx) { 1643 SPDK_ERRLOG("Unable to allocate memory for context to remove poll subsystem\n"); 1644 if (cb_fn) { 1645 cb_fn(cb_arg, -1); 1646 } 1647 return; 1648 } 1649 1650 ctx->group = group; 1651 ctx->subsystem = subsystem; 1652 ctx->cpl_fn = cb_fn; 1653 ctx->cpl_ctx = cb_arg; 1654 1655 sgroup = &group->sgroups[subsystem->id]; 1656 sgroup->state = SPDK_NVMF_SUBSYSTEM_INACTIVE; 1657 1658 for (i = 0; i < sgroup->num_ns; i++) { 1659 sgroup->ns_info[i].state = SPDK_NVMF_SUBSYSTEM_INACTIVE; 1660 } 1661 1662 nvmf_poll_group_remove_subsystem_msg(ctx); 1663 } 1664 1665 void 1666 nvmf_poll_group_pause_subsystem(struct spdk_nvmf_poll_group *group, 1667 struct spdk_nvmf_subsystem *subsystem, 1668 uint32_t nsid, 1669 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1670 { 1671 struct spdk_nvmf_subsystem_poll_group *sgroup; 1672 struct spdk_nvmf_subsystem_pg_ns_info *ns_info = NULL; 1673 int rc = 0; 1674 uint32_t i; 1675 1676 if (subsystem->id >= group->num_sgroups) { 1677 rc = -1; 1678 goto fini; 1679 } 1680 1681 sgroup = &group->sgroups[subsystem->id]; 1682 if (sgroup->state == SPDK_NVMF_SUBSYSTEM_PAUSED) { 1683 goto fini; 1684 } 1685 sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSING; 1686 1687 if (nsid == SPDK_NVME_GLOBAL_NS_TAG) { 1688 for (i = 0; i < sgroup->num_ns; i++) { 1689 ns_info = &sgroup->ns_info[i]; 1690 ns_info->state = SPDK_NVMF_SUBSYSTEM_PAUSING; 1691 } 1692 } else { 1693 /* NOTE: This implicitly also checks for 0, since 0 - 1 wraps around to UINT32_MAX. */ 1694 if (nsid - 1 < sgroup->num_ns) { 1695 ns_info = &sgroup->ns_info[nsid - 1]; 1696 ns_info->state = SPDK_NVMF_SUBSYSTEM_PAUSING; 1697 } 1698 } 1699 1700 if (sgroup->mgmt_io_outstanding > 0) { 1701 assert(sgroup->cb_fn == NULL); 1702 sgroup->cb_fn = cb_fn; 1703 assert(sgroup->cb_arg == NULL); 1704 sgroup->cb_arg = cb_arg; 1705 return; 1706 } 1707 1708 if (nsid == SPDK_NVME_GLOBAL_NS_TAG) { 1709 for (i = 0; i < sgroup->num_ns; i++) { 1710 ns_info = &sgroup->ns_info[i]; 1711 1712 if (ns_info->io_outstanding > 0) { 1713 assert(sgroup->cb_fn == NULL); 1714 sgroup->cb_fn = cb_fn; 1715 assert(sgroup->cb_arg == NULL); 1716 sgroup->cb_arg = cb_arg; 1717 return; 1718 } 1719 } 1720 } else { 1721 if (ns_info != NULL && ns_info->io_outstanding > 0) { 1722 assert(sgroup->cb_fn == NULL); 1723 sgroup->cb_fn = cb_fn; 1724 assert(sgroup->cb_arg == NULL); 1725 sgroup->cb_arg = cb_arg; 1726 return; 1727 } 1728 } 1729 1730 assert(sgroup->mgmt_io_outstanding == 0); 1731 sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSED; 1732 fini: 1733 if (cb_fn) { 1734 cb_fn(cb_arg, rc); 1735 } 1736 } 1737 1738 void 1739 nvmf_poll_group_resume_subsystem(struct spdk_nvmf_poll_group *group, 1740 struct spdk_nvmf_subsystem *subsystem, 1741 spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) 1742 { 1743 struct spdk_nvmf_request *req, *tmp; 1744 struct spdk_nvmf_subsystem_poll_group *sgroup; 1745 int rc = 0; 1746 uint32_t i; 1747 1748 if (subsystem->id >= group->num_sgroups) { 1749 rc = -1; 1750 goto fini; 1751 } 1752 1753 sgroup = &group->sgroups[subsystem->id]; 1754 1755 if (sgroup->state == SPDK_NVMF_SUBSYSTEM_ACTIVE) { 1756 goto fini; 1757 } 1758 1759 rc = poll_group_update_subsystem(group, subsystem); 1760 if (rc) { 1761 goto fini; 1762 } 1763 1764 for (i = 0; i < sgroup->num_ns; i++) { 1765 sgroup->ns_info[i].state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1766 } 1767 1768 sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE; 1769 1770 /* Release all queued requests */ 1771 TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) { 1772 TAILQ_REMOVE(&sgroup->queued, req, link); 1773 if (spdk_nvmf_request_using_zcopy(req)) { 1774 spdk_nvmf_request_zcopy_start(req); 1775 } else { 1776 spdk_nvmf_request_exec(req); 1777 } 1778 1779 } 1780 fini: 1781 if (cb_fn) { 1782 cb_fn(cb_arg, rc); 1783 } 1784 } 1785 1786 1787 struct spdk_nvmf_poll_group * 1788 spdk_nvmf_get_optimal_poll_group(struct spdk_nvmf_qpair *qpair) 1789 { 1790 struct spdk_nvmf_transport_poll_group *tgroup; 1791 1792 tgroup = nvmf_transport_get_optimal_poll_group(qpair->transport, qpair); 1793 1794 if (tgroup == NULL) { 1795 return NULL; 1796 } 1797 1798 return tgroup->group; 1799 } 1800 1801 void 1802 spdk_nvmf_poll_group_dump_stat(struct spdk_nvmf_poll_group *group, struct spdk_json_write_ctx *w) 1803 { 1804 struct spdk_nvmf_transport_poll_group *tgroup; 1805 1806 spdk_json_write_object_begin(w); 1807 1808 spdk_json_write_named_string(w, "name", spdk_thread_get_name(spdk_get_thread())); 1809 spdk_json_write_named_uint32(w, "admin_qpairs", group->stat.admin_qpairs); 1810 spdk_json_write_named_uint32(w, "io_qpairs", group->stat.io_qpairs); 1811 spdk_json_write_named_uint32(w, "current_admin_qpairs", group->stat.current_admin_qpairs); 1812 spdk_json_write_named_uint32(w, "current_io_qpairs", group->stat.current_io_qpairs); 1813 spdk_json_write_named_uint64(w, "pending_bdev_io", group->stat.pending_bdev_io); 1814 spdk_json_write_named_uint64(w, "completed_nvme_io", group->stat.completed_nvme_io); 1815 1816 spdk_json_write_named_array_begin(w, "transports"); 1817 1818 TAILQ_FOREACH(tgroup, &group->tgroups, link) { 1819 spdk_json_write_object_begin(w); 1820 /* 1821 * The trtype field intentionally contains a transport name as this is more informative. 1822 * The field has not been renamed for backward compatibility. 1823 */ 1824 spdk_json_write_named_string(w, "trtype", spdk_nvmf_get_transport_name(tgroup->transport)); 1825 1826 if (tgroup->transport->ops->poll_group_dump_stat) { 1827 tgroup->transport->ops->poll_group_dump_stat(tgroup, w); 1828 } 1829 1830 spdk_json_write_object_end(w); 1831 } 1832 1833 spdk_json_write_array_end(w); 1834 spdk_json_write_object_end(w); 1835 } 1836