1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. All rights reserved. 5 * Copyright (c) 2018-2020 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/bdev.h" 35 #include "spdk/log.h" 36 #include "spdk/rpc.h" 37 #include "spdk/env.h" 38 #include "spdk/nvme.h" 39 #include "spdk/nvmf.h" 40 #include "spdk/string.h" 41 #include "spdk/util.h" 42 #include "spdk/bit_array.h" 43 44 #include "spdk_internal/assert.h" 45 46 #include "nvmf_internal.h" 47 48 static int 49 json_write_hex_str(struct spdk_json_write_ctx *w, const void *data, size_t size) 50 { 51 static const char hex_char[16] = "0123456789ABCDEF"; 52 const uint8_t *buf = data; 53 char *str, *out; 54 int rc; 55 56 str = malloc(size * 2 + 1); 57 if (str == NULL) { 58 return -1; 59 } 60 61 out = str; 62 while (size--) { 63 unsigned byte = *buf++; 64 65 out[0] = hex_char[(byte >> 4) & 0xF]; 66 out[1] = hex_char[byte & 0xF]; 67 68 out += 2; 69 } 70 *out = '\0'; 71 72 rc = spdk_json_write_string(w, str); 73 free(str); 74 75 return rc; 76 } 77 78 static int 79 hex_nybble_to_num(char c) 80 { 81 if (c >= '0' && c <= '9') { 82 return c - '0'; 83 } 84 85 if (c >= 'a' && c <= 'f') { 86 return c - 'a' + 0xA; 87 } 88 89 if (c >= 'A' && c <= 'F') { 90 return c - 'A' + 0xA; 91 } 92 93 return -1; 94 } 95 96 static int 97 hex_byte_to_num(const char *str) 98 { 99 int hi, lo; 100 101 hi = hex_nybble_to_num(str[0]); 102 if (hi < 0) { 103 return hi; 104 } 105 106 lo = hex_nybble_to_num(str[1]); 107 if (lo < 0) { 108 return lo; 109 } 110 111 return hi * 16 + lo; 112 } 113 114 static int 115 decode_hex_string_be(const char *str, uint8_t *out, size_t size) 116 { 117 size_t i; 118 119 /* Decode a string in "ABCDEF012345" format to its binary representation */ 120 for (i = 0; i < size; i++) { 121 int num = hex_byte_to_num(str); 122 123 if (num < 0) { 124 /* Invalid hex byte or end of string */ 125 return -1; 126 } 127 128 out[i] = (uint8_t)num; 129 str += 2; 130 } 131 132 if (i != size || *str != '\0') { 133 /* Length mismatch */ 134 return -1; 135 } 136 137 return 0; 138 } 139 140 static int 141 decode_ns_nguid(const struct spdk_json_val *val, void *out) 142 { 143 char *str = NULL; 144 int rc; 145 146 rc = spdk_json_decode_string(val, &str); 147 if (rc == 0) { 148 /* 16-byte NGUID */ 149 rc = decode_hex_string_be(str, out, 16); 150 } 151 152 free(str); 153 return rc; 154 } 155 156 static int 157 decode_ns_eui64(const struct spdk_json_val *val, void *out) 158 { 159 char *str = NULL; 160 int rc; 161 162 rc = spdk_json_decode_string(val, &str); 163 if (rc == 0) { 164 /* 8-byte EUI-64 */ 165 rc = decode_hex_string_be(str, out, 8); 166 } 167 168 free(str); 169 return rc; 170 } 171 172 static int 173 decode_ns_uuid(const struct spdk_json_val *val, void *out) 174 { 175 char *str = NULL; 176 int rc; 177 178 rc = spdk_json_decode_string(val, &str); 179 if (rc == 0) { 180 rc = spdk_uuid_parse(out, str); 181 } 182 183 free(str); 184 return rc; 185 } 186 187 struct rpc_get_subsystem { 188 char *tgt_name; 189 }; 190 191 static const struct spdk_json_object_decoder rpc_get_subsystem_decoders[] = { 192 {"tgt_name", offsetof(struct rpc_get_subsystem, tgt_name), spdk_json_decode_string, true}, 193 }; 194 195 static void 196 dump_nvmf_subsystem(struct spdk_json_write_ctx *w, struct spdk_nvmf_subsystem *subsystem) 197 { 198 struct spdk_nvmf_host *host; 199 struct spdk_nvmf_subsystem_listener *listener; 200 201 spdk_json_write_object_begin(w); 202 203 spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem)); 204 spdk_json_write_name(w, "subtype"); 205 if (spdk_nvmf_subsystem_get_type(subsystem) == SPDK_NVMF_SUBTYPE_NVME) { 206 spdk_json_write_string(w, "NVMe"); 207 } else { 208 spdk_json_write_string(w, "Discovery"); 209 } 210 211 spdk_json_write_named_array_begin(w, "listen_addresses"); 212 213 for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL; 214 listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) { 215 const struct spdk_nvme_transport_id *trid; 216 const char *adrfam; 217 218 trid = spdk_nvmf_subsystem_listener_get_trid(listener); 219 220 spdk_json_write_object_begin(w); 221 adrfam = spdk_nvme_transport_id_adrfam_str(trid->adrfam); 222 if (adrfam == NULL) { 223 adrfam = "unknown"; 224 } 225 /* NOTE: "transport" is kept for compatibility; new code should use "trtype" */ 226 spdk_json_write_named_string(w, "transport", trid->trstring); 227 spdk_json_write_named_string(w, "trtype", trid->trstring); 228 spdk_json_write_named_string(w, "adrfam", adrfam); 229 spdk_json_write_named_string(w, "traddr", trid->traddr); 230 spdk_json_write_named_string(w, "trsvcid", trid->trsvcid); 231 spdk_json_write_object_end(w); 232 } 233 spdk_json_write_array_end(w); 234 235 spdk_json_write_named_bool(w, "allow_any_host", 236 spdk_nvmf_subsystem_get_allow_any_host(subsystem)); 237 238 spdk_json_write_named_array_begin(w, "hosts"); 239 240 for (host = spdk_nvmf_subsystem_get_first_host(subsystem); host != NULL; 241 host = spdk_nvmf_subsystem_get_next_host(subsystem, host)) { 242 spdk_json_write_object_begin(w); 243 spdk_json_write_named_string(w, "nqn", spdk_nvmf_host_get_nqn(host)); 244 spdk_json_write_object_end(w); 245 } 246 spdk_json_write_array_end(w); 247 248 if (spdk_nvmf_subsystem_get_type(subsystem) == SPDK_NVMF_SUBTYPE_NVME) { 249 struct spdk_nvmf_ns *ns; 250 struct spdk_nvmf_ns_opts ns_opts; 251 uint32_t max_namespaces; 252 253 spdk_json_write_named_string(w, "serial_number", spdk_nvmf_subsystem_get_sn(subsystem)); 254 255 spdk_json_write_named_string(w, "model_number", spdk_nvmf_subsystem_get_mn(subsystem)); 256 257 max_namespaces = spdk_nvmf_subsystem_get_max_namespaces(subsystem); 258 if (max_namespaces != 0) { 259 spdk_json_write_named_uint32(w, "max_namespaces", max_namespaces); 260 } 261 262 spdk_json_write_named_array_begin(w, "namespaces"); 263 for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); ns != NULL; 264 ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) { 265 spdk_nvmf_ns_get_opts(ns, &ns_opts, sizeof(ns_opts)); 266 spdk_json_write_object_begin(w); 267 spdk_json_write_named_int32(w, "nsid", spdk_nvmf_ns_get_id(ns)); 268 spdk_json_write_named_string(w, "bdev_name", 269 spdk_bdev_get_name(spdk_nvmf_ns_get_bdev(ns))); 270 /* NOTE: "name" is kept for compatibility only - new code should use bdev_name. */ 271 spdk_json_write_named_string(w, "name", 272 spdk_bdev_get_name(spdk_nvmf_ns_get_bdev(ns))); 273 274 if (!spdk_mem_all_zero(ns_opts.nguid, sizeof(ns_opts.nguid))) { 275 spdk_json_write_name(w, "nguid"); 276 json_write_hex_str(w, ns_opts.nguid, sizeof(ns_opts.nguid)); 277 } 278 279 if (!spdk_mem_all_zero(ns_opts.eui64, sizeof(ns_opts.eui64))) { 280 spdk_json_write_name(w, "eui64"); 281 json_write_hex_str(w, ns_opts.eui64, sizeof(ns_opts.eui64)); 282 } 283 284 if (!spdk_mem_all_zero(&ns_opts.uuid, sizeof(ns_opts.uuid))) { 285 char uuid_str[SPDK_UUID_STRING_LEN]; 286 287 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &ns_opts.uuid); 288 spdk_json_write_named_string(w, "uuid", uuid_str); 289 } 290 291 spdk_json_write_object_end(w); 292 } 293 spdk_json_write_array_end(w); 294 } 295 spdk_json_write_object_end(w); 296 } 297 298 static void 299 rpc_nvmf_get_subsystems(struct spdk_jsonrpc_request *request, 300 const struct spdk_json_val *params) 301 { 302 struct rpc_get_subsystem req = { 0 }; 303 struct spdk_json_write_ctx *w; 304 struct spdk_nvmf_subsystem *subsystem; 305 struct spdk_nvmf_tgt *tgt; 306 307 if (params) { 308 if (spdk_json_decode_object(params, rpc_get_subsystem_decoders, 309 SPDK_COUNTOF(rpc_get_subsystem_decoders), 310 &req)) { 311 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 312 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 313 return; 314 } 315 } 316 317 tgt = spdk_nvmf_get_tgt(req.tgt_name); 318 if (!tgt) { 319 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 320 "Unable to find a target."); 321 free(req.tgt_name); 322 return; 323 } 324 325 w = spdk_jsonrpc_begin_result(request); 326 spdk_json_write_array_begin(w); 327 subsystem = spdk_nvmf_subsystem_get_first(tgt); 328 while (subsystem) { 329 dump_nvmf_subsystem(w, subsystem); 330 subsystem = spdk_nvmf_subsystem_get_next(subsystem); 331 } 332 spdk_json_write_array_end(w); 333 spdk_jsonrpc_end_result(request, w); 334 free(req.tgt_name); 335 } 336 SPDK_RPC_REGISTER("nvmf_get_subsystems", rpc_nvmf_get_subsystems, SPDK_RPC_RUNTIME) 337 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nvmf_get_subsystems, get_nvmf_subsystems) 338 339 struct rpc_subsystem_create { 340 char *nqn; 341 char *serial_number; 342 char *model_number; 343 char *tgt_name; 344 uint32_t max_namespaces; 345 bool allow_any_host; 346 bool ana_reporting; 347 }; 348 349 static const struct spdk_json_object_decoder rpc_subsystem_create_decoders[] = { 350 {"nqn", offsetof(struct rpc_subsystem_create, nqn), spdk_json_decode_string}, 351 {"serial_number", offsetof(struct rpc_subsystem_create, serial_number), spdk_json_decode_string, true}, 352 {"model_number", offsetof(struct rpc_subsystem_create, model_number), spdk_json_decode_string, true}, 353 {"tgt_name", offsetof(struct rpc_subsystem_create, tgt_name), spdk_json_decode_string, true}, 354 {"max_namespaces", offsetof(struct rpc_subsystem_create, max_namespaces), spdk_json_decode_uint32, true}, 355 {"allow_any_host", offsetof(struct rpc_subsystem_create, allow_any_host), spdk_json_decode_bool, true}, 356 {"ana_reporting", offsetof(struct rpc_subsystem_create, ana_reporting), spdk_json_decode_bool, true}, 357 }; 358 359 static void 360 rpc_nvmf_subsystem_started(struct spdk_nvmf_subsystem *subsystem, 361 void *cb_arg, int status) 362 { 363 struct spdk_jsonrpc_request *request = cb_arg; 364 365 if (!status) { 366 struct spdk_json_write_ctx *w = spdk_jsonrpc_begin_result(request); 367 spdk_json_write_bool(w, true); 368 spdk_jsonrpc_end_result(request, w); 369 } else { 370 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 371 "Subsystem %s start failed", 372 subsystem->subnqn); 373 spdk_nvmf_subsystem_destroy(subsystem); 374 } 375 } 376 377 static void 378 rpc_nvmf_create_subsystem(struct spdk_jsonrpc_request *request, 379 const struct spdk_json_val *params) 380 { 381 struct rpc_subsystem_create *req; 382 struct spdk_nvmf_subsystem *subsystem = NULL; 383 struct spdk_nvmf_tgt *tgt; 384 int rc = -1; 385 386 req = calloc(1, sizeof(*req)); 387 if (!req) { 388 SPDK_ERRLOG("Memory allocation failed\n"); 389 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 390 "Memory allocation failed"); 391 return; 392 } 393 394 if (spdk_json_decode_object(params, rpc_subsystem_create_decoders, 395 SPDK_COUNTOF(rpc_subsystem_create_decoders), 396 req)) { 397 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 398 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 399 goto cleanup; 400 } 401 402 tgt = spdk_nvmf_get_tgt(req->tgt_name); 403 if (!tgt) { 404 SPDK_ERRLOG("Unable to find target %s\n", req->tgt_name); 405 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 406 "Unable to find target %s", req->tgt_name); 407 goto cleanup; 408 } 409 410 subsystem = spdk_nvmf_subsystem_create(tgt, req->nqn, SPDK_NVMF_SUBTYPE_NVME, 411 req->max_namespaces); 412 if (!subsystem) { 413 SPDK_ERRLOG("Unable to create subsystem %s\n", req->nqn); 414 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 415 "Unable to create subsystem %s", req->nqn); 416 goto cleanup; 417 } 418 419 if (req->serial_number) { 420 if (spdk_nvmf_subsystem_set_sn(subsystem, req->serial_number)) { 421 SPDK_ERRLOG("Subsystem %s: invalid serial number '%s'\n", req->nqn, req->serial_number); 422 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 423 "Invalid SN %s", req->serial_number); 424 goto cleanup; 425 } 426 } 427 428 if (req->model_number) { 429 if (spdk_nvmf_subsystem_set_mn(subsystem, req->model_number)) { 430 SPDK_ERRLOG("Subsystem %s: invalid model number '%s'\n", req->nqn, req->model_number); 431 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 432 "Invalid MN %s", req->model_number); 433 goto cleanup; 434 } 435 } 436 437 spdk_nvmf_subsystem_set_allow_any_host(subsystem, req->allow_any_host); 438 439 spdk_nvmf_subsystem_set_ana_reporting(subsystem, req->ana_reporting); 440 441 rc = spdk_nvmf_subsystem_start(subsystem, 442 rpc_nvmf_subsystem_started, 443 request); 444 445 cleanup: 446 free(req->nqn); 447 free(req->tgt_name); 448 free(req->serial_number); 449 free(req->model_number); 450 free(req); 451 452 if (rc && subsystem) { 453 spdk_nvmf_subsystem_destroy(subsystem); 454 } 455 } 456 SPDK_RPC_REGISTER("nvmf_create_subsystem", rpc_nvmf_create_subsystem, SPDK_RPC_RUNTIME) 457 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nvmf_create_subsystem, nvmf_subsystem_create) 458 459 struct rpc_subsystem_set_options { 460 char *nqn; 461 char *tgt_name; 462 char *trtype; 463 }; 464 465 static const struct spdk_json_object_decoder rpc_subsystem_set_options_decoders[] = { 466 {"nqn", offsetof(struct rpc_subsystem_set_options, nqn), spdk_json_decode_string}, 467 {"tgt_name", offsetof(struct rpc_subsystem_set_options, tgt_name), spdk_json_decode_string, true}, 468 {"trtype", offsetof(struct rpc_subsystem_set_options, trtype), spdk_json_decode_string}, 469 }; 470 471 static void 472 rpc_nvmf_subsystem_set_options(struct spdk_jsonrpc_request *request, 473 const struct spdk_json_val *params) 474 { 475 struct rpc_subsystem_set_options *req; 476 struct spdk_nvmf_subsystem *subsystem; 477 struct spdk_nvmf_transport *transport; 478 struct spdk_json_write_ctx *w; 479 struct spdk_nvmf_tgt *tgt; 480 int rc; 481 482 req = calloc(1, sizeof(*req)); 483 if (!req) { 484 SPDK_ERRLOG("Memory allocation failed\n"); 485 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 486 "Memory allocation failed"); 487 return; 488 } 489 490 if (spdk_json_decode_object_relaxed(params, rpc_subsystem_set_options_decoders, 491 SPDK_COUNTOF(rpc_subsystem_set_options_decoders), req)) { 492 SPDK_ERRLOG("spdk_json_decode_object_relaxed failed\n"); 493 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 494 goto cleanup; 495 } 496 497 tgt = spdk_nvmf_get_tgt(req->tgt_name); 498 if (!tgt) { 499 SPDK_ERRLOG("Unable to find target %s\n", req->tgt_name); 500 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 501 "Unable to find target %s", req->tgt_name); 502 goto cleanup; 503 } 504 505 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, req->nqn); 506 if (!subsystem) { 507 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", req->nqn); 508 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 509 "Unable to find subsystem with NQN %s", req->nqn); 510 goto cleanup; 511 } 512 513 transport = spdk_nvmf_tgt_get_transport(tgt, req->trtype); 514 if (!transport) { 515 SPDK_ERRLOG("Unable to find transport with trtype %s\n", req->trtype); 516 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 517 "Unable to find transport with trtype %s", req->trtype); 518 goto cleanup; 519 } 520 521 if (!transport->ops->subsystem_opts_parse) { 522 SPDK_ERRLOG("Unable to find transport ops\n"); 523 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 524 "Unable to find transport ops"); 525 goto cleanup; 526 } 527 528 rc = transport->ops->subsystem_opts_parse(transport, subsystem, params); 529 if (rc) { 530 SPDK_ERRLOG("Unable to parse opts %d\n", rc); 531 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 532 "Unable to parse opts %d", rc); 533 goto cleanup; 534 } 535 536 w = spdk_jsonrpc_begin_result(request); 537 spdk_json_write_bool(w, true); 538 spdk_jsonrpc_end_result(request, w); 539 540 cleanup: 541 free(req->nqn); 542 free(req->tgt_name); 543 free(req->trtype); 544 free(req); 545 } 546 SPDK_RPC_REGISTER("nvmf_subsystem_set_options", rpc_nvmf_subsystem_set_options, SPDK_RPC_RUNTIME) 547 548 struct rpc_delete_subsystem { 549 char *nqn; 550 char *tgt_name; 551 }; 552 553 static void 554 free_rpc_delete_subsystem(struct rpc_delete_subsystem *r) 555 { 556 free(r->nqn); 557 free(r->tgt_name); 558 } 559 560 static void 561 rpc_nvmf_subsystem_stopped(struct spdk_nvmf_subsystem *subsystem, 562 void *cb_arg, int status) 563 { 564 struct spdk_jsonrpc_request *request = cb_arg; 565 struct spdk_json_write_ctx *w; 566 567 nvmf_subsystem_remove_all_listeners(subsystem, true); 568 spdk_nvmf_subsystem_destroy(subsystem); 569 570 w = spdk_jsonrpc_begin_result(request); 571 spdk_json_write_bool(w, true); 572 spdk_jsonrpc_end_result(request, w); 573 } 574 575 static const struct spdk_json_object_decoder rpc_delete_subsystem_decoders[] = { 576 {"nqn", offsetof(struct rpc_delete_subsystem, nqn), spdk_json_decode_string}, 577 {"tgt_name", offsetof(struct rpc_delete_subsystem, tgt_name), spdk_json_decode_string, true}, 578 }; 579 580 static void 581 rpc_nvmf_delete_subsystem(struct spdk_jsonrpc_request *request, 582 const struct spdk_json_val *params) 583 { 584 struct rpc_delete_subsystem req = { 0 }; 585 struct spdk_nvmf_subsystem *subsystem; 586 struct spdk_nvmf_tgt *tgt; 587 int rc; 588 589 if (spdk_json_decode_object(params, rpc_delete_subsystem_decoders, 590 SPDK_COUNTOF(rpc_delete_subsystem_decoders), 591 &req)) { 592 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 593 goto invalid; 594 } 595 596 if (req.nqn == NULL) { 597 SPDK_ERRLOG("missing name param\n"); 598 goto invalid; 599 } 600 601 tgt = spdk_nvmf_get_tgt(req.tgt_name); 602 if (!tgt) { 603 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 604 "Unable to find a target."); 605 goto invalid_custom_response; 606 } 607 608 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, req.nqn); 609 if (!subsystem) { 610 goto invalid; 611 } 612 613 free_rpc_delete_subsystem(&req); 614 615 rc = spdk_nvmf_subsystem_stop(subsystem, 616 rpc_nvmf_subsystem_stopped, 617 request); 618 if (rc == -EBUSY) { 619 SPDK_ERRLOG("Subsystem currently in another state change try again later.\n"); 620 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 621 "Subsystem currently in another state change try again later."); 622 } else if (rc != 0) { 623 SPDK_ERRLOG("Unable to change state on subsystem. rc=%d\n", rc); 624 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 625 "Unable to change state on subsystem. rc=%d", rc); 626 } 627 628 return; 629 630 invalid: 631 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 632 invalid_custom_response: 633 free_rpc_delete_subsystem(&req); 634 } 635 SPDK_RPC_REGISTER("nvmf_delete_subsystem", rpc_nvmf_delete_subsystem, SPDK_RPC_RUNTIME) 636 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nvmf_delete_subsystem, delete_nvmf_subsystem) 637 638 struct rpc_listen_address { 639 char *transport; 640 char *adrfam; 641 char *traddr; 642 char *trsvcid; 643 }; 644 645 static const struct spdk_json_object_decoder rpc_listen_address_decoders[] = { 646 /* NOTE: "transport" is kept for compatibility; new code should use "trtype" */ 647 {"transport", offsetof(struct rpc_listen_address, transport), spdk_json_decode_string, true}, 648 {"trtype", offsetof(struct rpc_listen_address, transport), spdk_json_decode_string, true}, 649 {"adrfam", offsetof(struct rpc_listen_address, adrfam), spdk_json_decode_string, true}, 650 {"traddr", offsetof(struct rpc_listen_address, traddr), spdk_json_decode_string}, 651 {"trsvcid", offsetof(struct rpc_listen_address, trsvcid), spdk_json_decode_string}, 652 }; 653 654 static int 655 decode_rpc_listen_address(const struct spdk_json_val *val, void *out) 656 { 657 struct rpc_listen_address *req = (struct rpc_listen_address *)out; 658 if (spdk_json_decode_object(val, rpc_listen_address_decoders, 659 SPDK_COUNTOF(rpc_listen_address_decoders), 660 req)) { 661 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 662 return -1; 663 } 664 return 0; 665 } 666 667 static void 668 free_rpc_listen_address(struct rpc_listen_address *r) 669 { 670 free(r->transport); 671 free(r->adrfam); 672 free(r->traddr); 673 free(r->trsvcid); 674 } 675 676 enum nvmf_rpc_listen_op { 677 NVMF_RPC_LISTEN_ADD, 678 NVMF_RPC_LISTEN_REMOVE, 679 NVMF_RPC_LISTEN_SET_ANA_STATE, 680 }; 681 682 struct nvmf_rpc_listener_ctx { 683 char *nqn; 684 char *tgt_name; 685 struct spdk_nvmf_tgt *tgt; 686 struct spdk_nvmf_transport *transport; 687 struct spdk_nvmf_subsystem *subsystem; 688 struct rpc_listen_address address; 689 char *ana_state_str; 690 enum spdk_nvme_ana_state ana_state; 691 692 struct spdk_jsonrpc_request *request; 693 struct spdk_nvme_transport_id trid; 694 enum nvmf_rpc_listen_op op; 695 bool response_sent; 696 }; 697 698 static const struct spdk_json_object_decoder nvmf_rpc_listener_decoder[] = { 699 {"nqn", offsetof(struct nvmf_rpc_listener_ctx, nqn), spdk_json_decode_string}, 700 {"listen_address", offsetof(struct nvmf_rpc_listener_ctx, address), decode_rpc_listen_address}, 701 {"tgt_name", offsetof(struct nvmf_rpc_listener_ctx, tgt_name), spdk_json_decode_string, true}, 702 }; 703 704 static void 705 nvmf_rpc_listener_ctx_free(struct nvmf_rpc_listener_ctx *ctx) 706 { 707 free(ctx->nqn); 708 free(ctx->tgt_name); 709 free_rpc_listen_address(&ctx->address); 710 free(ctx->ana_state_str); 711 free(ctx); 712 } 713 714 static void 715 nvmf_rpc_listen_resumed(struct spdk_nvmf_subsystem *subsystem, 716 void *cb_arg, int status) 717 { 718 struct nvmf_rpc_listener_ctx *ctx = cb_arg; 719 struct spdk_jsonrpc_request *request; 720 struct spdk_json_write_ctx *w; 721 722 request = ctx->request; 723 if (ctx->response_sent) { 724 /* If an error occurred, the response has already been sent. */ 725 nvmf_rpc_listener_ctx_free(ctx); 726 return; 727 } 728 729 nvmf_rpc_listener_ctx_free(ctx); 730 731 w = spdk_jsonrpc_begin_result(request); 732 spdk_json_write_bool(w, true); 733 spdk_jsonrpc_end_result(request, w); 734 } 735 736 static void 737 nvmf_rpc_subsystem_listen(void *cb_arg, int status) 738 { 739 struct nvmf_rpc_listener_ctx *ctx = cb_arg; 740 741 if (status) { 742 /* Destroy the listener that we just created. Ignore the error code because 743 * the RPC is failing already anyway. */ 744 spdk_nvmf_tgt_stop_listen(ctx->tgt, &ctx->trid); 745 746 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 747 "Invalid parameters"); 748 ctx->response_sent = true; 749 } 750 751 if (spdk_nvmf_subsystem_resume(ctx->subsystem, nvmf_rpc_listen_resumed, ctx)) { 752 if (!ctx->response_sent) { 753 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 754 "Internal error"); 755 } 756 nvmf_rpc_listener_ctx_free(ctx); 757 /* Can't really do anything to recover here - subsystem will remain paused. */ 758 } 759 } 760 static void 761 nvmf_rpc_stop_listen_async_done(void *cb_arg, int status) 762 { 763 struct nvmf_rpc_listener_ctx *ctx = cb_arg; 764 765 if (status) { 766 SPDK_ERRLOG("Unable to stop listener.\n"); 767 spdk_jsonrpc_send_error_response_fmt(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 768 "error stopping listener: %d", status); 769 ctx->response_sent = true; 770 } 771 772 if (spdk_nvmf_subsystem_resume(ctx->subsystem, nvmf_rpc_listen_resumed, ctx)) { 773 if (!ctx->response_sent) { 774 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 775 "Internal error"); 776 } 777 nvmf_rpc_listener_ctx_free(ctx); 778 /* Can't really do anything to recover here - subsystem will remain paused. */ 779 } 780 } 781 782 static void 783 nvmf_rpc_set_ana_state_done(void *cb_arg, int status) 784 { 785 struct nvmf_rpc_listener_ctx *ctx = cb_arg; 786 787 if (status) { 788 SPDK_ERRLOG("Unable to set ANA state.\n"); 789 spdk_jsonrpc_send_error_response_fmt(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 790 "error setting ANA state: %d", status); 791 ctx->response_sent = true; 792 } 793 794 if (spdk_nvmf_subsystem_resume(ctx->subsystem, nvmf_rpc_listen_resumed, ctx)) { 795 if (!ctx->response_sent) { 796 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 797 "Internal error"); 798 } 799 nvmf_rpc_listener_ctx_free(ctx); 800 /* Can't really do anything to recover here - subsystem will remain paused. */ 801 } 802 } 803 804 static void 805 nvmf_rpc_listen_paused(struct spdk_nvmf_subsystem *subsystem, 806 void *cb_arg, int status) 807 { 808 struct nvmf_rpc_listener_ctx *ctx = cb_arg; 809 int rc; 810 811 if (ctx->op == NVMF_RPC_LISTEN_ADD) { 812 if (!nvmf_subsystem_find_listener(subsystem, &ctx->trid)) { 813 rc = spdk_nvmf_tgt_listen(ctx->tgt, &ctx->trid); 814 if (rc == 0) { 815 spdk_nvmf_subsystem_add_listener(ctx->subsystem, &ctx->trid, nvmf_rpc_subsystem_listen, ctx); 816 return; 817 } 818 819 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 820 "Invalid parameters"); 821 ctx->response_sent = true; 822 } 823 } else if (ctx->op == NVMF_RPC_LISTEN_REMOVE) { 824 if (spdk_nvmf_subsystem_remove_listener(subsystem, &ctx->trid)) { 825 SPDK_ERRLOG("Unable to remove listener.\n"); 826 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 827 "Invalid parameters"); 828 ctx->response_sent = true; 829 } 830 spdk_nvmf_transport_stop_listen_async(ctx->transport, &ctx->trid, nvmf_rpc_stop_listen_async_done, 831 ctx); 832 return; 833 } else if (ctx->op == NVMF_RPC_LISTEN_SET_ANA_STATE) { 834 nvmf_subsystem_set_ana_state(subsystem, &ctx->trid, ctx->ana_state, 835 nvmf_rpc_set_ana_state_done, ctx); 836 return; 837 } else { 838 SPDK_UNREACHABLE(); 839 } 840 841 if (spdk_nvmf_subsystem_resume(subsystem, nvmf_rpc_listen_resumed, ctx)) { 842 if (!ctx->response_sent) { 843 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 844 "Internal error"); 845 } 846 nvmf_rpc_listener_ctx_free(ctx); 847 /* Can't really do anything to recover here - subsystem will remain paused. */ 848 } 849 } 850 851 static int 852 rpc_listen_address_to_trid(const struct rpc_listen_address *address, 853 struct spdk_nvme_transport_id *trid) 854 { 855 size_t len; 856 857 memset(trid, 0, sizeof(*trid)); 858 859 if (spdk_nvme_transport_id_populate_trstring(trid, address->transport)) { 860 SPDK_ERRLOG("Invalid transport string: %s\n", address->transport); 861 return -EINVAL; 862 } 863 864 if (spdk_nvme_transport_id_parse_trtype(&trid->trtype, address->transport)) { 865 SPDK_ERRLOG("Invalid transport type: %s\n", address->transport); 866 return -EINVAL; 867 } 868 869 if (address->adrfam) { 870 if (spdk_nvme_transport_id_parse_adrfam(&trid->adrfam, address->adrfam)) { 871 SPDK_ERRLOG("Invalid adrfam: %s\n", address->adrfam); 872 return -EINVAL; 873 } 874 } else { 875 trid->adrfam = SPDK_NVMF_ADRFAM_IPV4; 876 } 877 878 len = strlen(address->traddr); 879 if (len > sizeof(trid->traddr) - 1) { 880 SPDK_ERRLOG("Transport address longer than %zu characters: %s\n", 881 sizeof(trid->traddr) - 1, address->traddr); 882 return -EINVAL; 883 } 884 memcpy(trid->traddr, address->traddr, len + 1); 885 886 len = strlen(address->trsvcid); 887 if (len > sizeof(trid->trsvcid) - 1) { 888 SPDK_ERRLOG("Transport service id longer than %zu characters: %s\n", 889 sizeof(trid->trsvcid) - 1, address->trsvcid); 890 return -EINVAL; 891 } 892 memcpy(trid->trsvcid, address->trsvcid, len + 1); 893 894 return 0; 895 } 896 897 static void 898 rpc_nvmf_subsystem_add_listener(struct spdk_jsonrpc_request *request, 899 const struct spdk_json_val *params) 900 { 901 struct nvmf_rpc_listener_ctx *ctx; 902 struct spdk_nvmf_subsystem *subsystem; 903 struct spdk_nvmf_tgt *tgt; 904 int rc; 905 906 ctx = calloc(1, sizeof(*ctx)); 907 if (!ctx) { 908 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 909 return; 910 } 911 912 ctx->request = request; 913 914 if (spdk_json_decode_object(params, nvmf_rpc_listener_decoder, 915 SPDK_COUNTOF(nvmf_rpc_listener_decoder), 916 ctx)) { 917 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 918 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 919 nvmf_rpc_listener_ctx_free(ctx); 920 return; 921 } 922 923 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 924 if (!tgt) { 925 SPDK_ERRLOG("Unable to find a target object.\n"); 926 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 927 "Unable to find a target."); 928 nvmf_rpc_listener_ctx_free(ctx); 929 return; 930 } 931 ctx->tgt = tgt; 932 933 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 934 if (!subsystem) { 935 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 936 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 937 nvmf_rpc_listener_ctx_free(ctx); 938 return; 939 } 940 941 ctx->subsystem = subsystem; 942 943 if (rpc_listen_address_to_trid(&ctx->address, &ctx->trid)) { 944 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 945 "Invalid parameters"); 946 nvmf_rpc_listener_ctx_free(ctx); 947 return; 948 } 949 950 ctx->op = NVMF_RPC_LISTEN_ADD; 951 952 rc = spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_listen_paused, ctx); 953 if (rc != 0) { 954 if (rc == -EBUSY) { 955 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 956 "subsystem busy, retry later.\n"); 957 } else { 958 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 959 } 960 nvmf_rpc_listener_ctx_free(ctx); 961 } 962 } 963 SPDK_RPC_REGISTER("nvmf_subsystem_add_listener", rpc_nvmf_subsystem_add_listener, 964 SPDK_RPC_RUNTIME); 965 966 static void 967 rpc_nvmf_subsystem_remove_listener(struct spdk_jsonrpc_request *request, 968 const struct spdk_json_val *params) 969 { 970 struct nvmf_rpc_listener_ctx *ctx; 971 struct spdk_nvmf_subsystem *subsystem; 972 struct spdk_nvmf_tgt *tgt; 973 int rc; 974 975 ctx = calloc(1, sizeof(*ctx)); 976 if (!ctx) { 977 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 978 return; 979 } 980 981 ctx->request = request; 982 983 if (spdk_json_decode_object(params, nvmf_rpc_listener_decoder, 984 SPDK_COUNTOF(nvmf_rpc_listener_decoder), 985 ctx)) { 986 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 987 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 988 nvmf_rpc_listener_ctx_free(ctx); 989 return; 990 } 991 992 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 993 if (!tgt) { 994 SPDK_ERRLOG("Unable to find a target object.\n"); 995 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 996 "Unable to find a target."); 997 nvmf_rpc_listener_ctx_free(ctx); 998 return; 999 } 1000 ctx->tgt = tgt; 1001 1002 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 1003 if (!subsystem) { 1004 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 1005 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1006 nvmf_rpc_listener_ctx_free(ctx); 1007 return; 1008 } 1009 1010 ctx->subsystem = subsystem; 1011 1012 if (rpc_listen_address_to_trid(&ctx->address, &ctx->trid)) { 1013 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1014 "Invalid parameters"); 1015 nvmf_rpc_listener_ctx_free(ctx); 1016 return; 1017 } 1018 1019 ctx->transport = spdk_nvmf_tgt_get_transport(tgt, ctx->trid.trstring); 1020 if (!ctx->transport) { 1021 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1022 "Invalid parameters"); 1023 nvmf_rpc_listener_ctx_free(ctx); 1024 return; 1025 } 1026 1027 ctx->op = NVMF_RPC_LISTEN_REMOVE; 1028 1029 rc = spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_listen_paused, ctx); 1030 if (rc != 0) { 1031 if (rc == -EBUSY) { 1032 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1033 "subsystem busy, retry later.\n"); 1034 } else { 1035 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1036 } 1037 nvmf_rpc_listener_ctx_free(ctx); 1038 } 1039 } 1040 SPDK_RPC_REGISTER("nvmf_subsystem_remove_listener", rpc_nvmf_subsystem_remove_listener, 1041 SPDK_RPC_RUNTIME); 1042 1043 static const struct spdk_json_object_decoder nvmf_rpc_set_ana_state_decoder[] = { 1044 {"nqn", offsetof(struct nvmf_rpc_listener_ctx, nqn), spdk_json_decode_string}, 1045 {"listen_address", offsetof(struct nvmf_rpc_listener_ctx, address), decode_rpc_listen_address}, 1046 {"ana_state", offsetof(struct nvmf_rpc_listener_ctx, ana_state_str), spdk_json_decode_string}, 1047 {"tgt_name", offsetof(struct nvmf_rpc_listener_ctx, tgt_name), spdk_json_decode_string, true}, 1048 }; 1049 1050 static int 1051 rpc_ana_state_parse(const char *str, enum spdk_nvme_ana_state *ana_state) 1052 { 1053 if (ana_state == NULL || str == NULL) { 1054 return -EINVAL; 1055 } 1056 1057 if (strcasecmp(str, "optimized") == 0) { 1058 *ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE; 1059 } else if (strcasecmp(str, "non_optimized") == 0) { 1060 *ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; 1061 } else if (strcasecmp(str, "inaccessible") == 0) { 1062 *ana_state = SPDK_NVME_ANA_INACCESSIBLE_STATE; 1063 } else { 1064 return -ENOENT; 1065 } 1066 1067 return 0; 1068 } 1069 1070 static void 1071 rpc_nvmf_subsystem_listener_set_ana_state(struct spdk_jsonrpc_request *request, 1072 const struct spdk_json_val *params) 1073 { 1074 struct nvmf_rpc_listener_ctx *ctx; 1075 struct spdk_nvmf_subsystem *subsystem; 1076 struct spdk_nvmf_tgt *tgt; 1077 1078 ctx = calloc(1, sizeof(*ctx)); 1079 if (!ctx) { 1080 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1081 "Out of memory"); 1082 return; 1083 } 1084 1085 ctx->request = request; 1086 1087 if (spdk_json_decode_object(params, nvmf_rpc_set_ana_state_decoder, 1088 SPDK_COUNTOF(nvmf_rpc_set_ana_state_decoder), 1089 ctx)) { 1090 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1091 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1092 "Invalid parameters"); 1093 nvmf_rpc_listener_ctx_free(ctx); 1094 return; 1095 } 1096 1097 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 1098 if (!tgt) { 1099 SPDK_ERRLOG("Unable to find a target object.\n"); 1100 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1101 "Unable to find a target.\n"); 1102 nvmf_rpc_listener_ctx_free(ctx); 1103 return; 1104 } 1105 1106 ctx->tgt = tgt; 1107 1108 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 1109 if (!subsystem) { 1110 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 1111 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1112 "Unable to find subsystem with NQN %s", 1113 ctx->nqn); 1114 nvmf_rpc_listener_ctx_free(ctx); 1115 return; 1116 } 1117 1118 ctx->subsystem = subsystem; 1119 1120 if (rpc_listen_address_to_trid(&ctx->address, &ctx->trid)) { 1121 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1122 "Invalid parameters"); 1123 nvmf_rpc_listener_ctx_free(ctx); 1124 return; 1125 } 1126 1127 if (rpc_ana_state_parse(ctx->ana_state_str, &ctx->ana_state)) { 1128 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1129 "Invalid parameters"); 1130 nvmf_rpc_listener_ctx_free(ctx); 1131 return; 1132 } 1133 1134 ctx->op = NVMF_RPC_LISTEN_SET_ANA_STATE; 1135 1136 if (spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_listen_paused, ctx)) { 1137 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1138 "Internal error"); 1139 nvmf_rpc_listener_ctx_free(ctx); 1140 } 1141 } 1142 SPDK_RPC_REGISTER("nvmf_subsystem_listener_set_ana_state", 1143 rpc_nvmf_subsystem_listener_set_ana_state, SPDK_RPC_RUNTIME); 1144 1145 struct spdk_nvmf_ns_params { 1146 char *bdev_name; 1147 char *ptpl_file; 1148 uint32_t nsid; 1149 char nguid[16]; 1150 char eui64[8]; 1151 struct spdk_uuid uuid; 1152 }; 1153 1154 static const struct spdk_json_object_decoder rpc_ns_params_decoders[] = { 1155 {"nsid", offsetof(struct spdk_nvmf_ns_params, nsid), spdk_json_decode_uint32, true}, 1156 {"bdev_name", offsetof(struct spdk_nvmf_ns_params, bdev_name), spdk_json_decode_string}, 1157 {"ptpl_file", offsetof(struct spdk_nvmf_ns_params, ptpl_file), spdk_json_decode_string, true}, 1158 {"nguid", offsetof(struct spdk_nvmf_ns_params, nguid), decode_ns_nguid, true}, 1159 {"eui64", offsetof(struct spdk_nvmf_ns_params, eui64), decode_ns_eui64, true}, 1160 {"uuid", offsetof(struct spdk_nvmf_ns_params, uuid), decode_ns_uuid, true}, 1161 }; 1162 1163 static int 1164 decode_rpc_ns_params(const struct spdk_json_val *val, void *out) 1165 { 1166 struct spdk_nvmf_ns_params *ns_params = out; 1167 1168 return spdk_json_decode_object(val, rpc_ns_params_decoders, 1169 SPDK_COUNTOF(rpc_ns_params_decoders), 1170 ns_params); 1171 } 1172 1173 struct nvmf_rpc_ns_ctx { 1174 char *nqn; 1175 char *tgt_name; 1176 struct spdk_nvmf_ns_params ns_params; 1177 1178 struct spdk_jsonrpc_request *request; 1179 bool response_sent; 1180 }; 1181 1182 static const struct spdk_json_object_decoder nvmf_rpc_subsystem_ns_decoder[] = { 1183 {"nqn", offsetof(struct nvmf_rpc_ns_ctx, nqn), spdk_json_decode_string}, 1184 {"namespace", offsetof(struct nvmf_rpc_ns_ctx, ns_params), decode_rpc_ns_params}, 1185 {"tgt_name", offsetof(struct nvmf_rpc_ns_ctx, tgt_name), spdk_json_decode_string, true}, 1186 }; 1187 1188 static void 1189 nvmf_rpc_ns_ctx_free(struct nvmf_rpc_ns_ctx *ctx) 1190 { 1191 free(ctx->nqn); 1192 free(ctx->tgt_name); 1193 free(ctx->ns_params.bdev_name); 1194 free(ctx->ns_params.ptpl_file); 1195 free(ctx); 1196 } 1197 1198 static void 1199 nvmf_rpc_ns_failback_resumed(struct spdk_nvmf_subsystem *subsystem, 1200 void *cb_arg, int status) 1201 { 1202 struct nvmf_rpc_ns_ctx *ctx = cb_arg; 1203 struct spdk_jsonrpc_request *request = ctx->request; 1204 1205 if (status) { 1206 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1207 "Unable to add ns, subsystem in invalid state"); 1208 } else { 1209 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1210 "Unable to add ns, subsystem in active state"); 1211 } 1212 1213 nvmf_rpc_ns_ctx_free(ctx); 1214 } 1215 1216 static void 1217 nvmf_rpc_ns_resumed(struct spdk_nvmf_subsystem *subsystem, 1218 void *cb_arg, int status) 1219 { 1220 struct nvmf_rpc_ns_ctx *ctx = cb_arg; 1221 struct spdk_jsonrpc_request *request = ctx->request; 1222 uint32_t nsid = ctx->ns_params.nsid; 1223 bool response_sent = ctx->response_sent; 1224 struct spdk_json_write_ctx *w; 1225 int rc; 1226 1227 /* The case where the call to add the namespace was successful, but the subsystem couldn't be resumed. */ 1228 if (status && !ctx->response_sent) { 1229 rc = spdk_nvmf_subsystem_remove_ns(subsystem, nsid); 1230 if (rc != 0) { 1231 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1232 "Unable to add ns, subsystem in invalid state"); 1233 nvmf_rpc_ns_ctx_free(ctx); 1234 return; 1235 } 1236 1237 rc = spdk_nvmf_subsystem_resume(subsystem, nvmf_rpc_ns_failback_resumed, ctx); 1238 if (rc != 0) { 1239 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1240 nvmf_rpc_ns_ctx_free(ctx); 1241 return; 1242 } 1243 1244 return; 1245 } 1246 1247 nvmf_rpc_ns_ctx_free(ctx); 1248 1249 if (response_sent) { 1250 return; 1251 } 1252 1253 w = spdk_jsonrpc_begin_result(request); 1254 spdk_json_write_uint32(w, nsid); 1255 spdk_jsonrpc_end_result(request, w); 1256 } 1257 1258 static void 1259 nvmf_rpc_ns_paused(struct spdk_nvmf_subsystem *subsystem, 1260 void *cb_arg, int status) 1261 { 1262 struct nvmf_rpc_ns_ctx *ctx = cb_arg; 1263 struct spdk_nvmf_ns_opts ns_opts; 1264 1265 spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); 1266 ns_opts.nsid = ctx->ns_params.nsid; 1267 1268 SPDK_STATIC_ASSERT(sizeof(ns_opts.nguid) == sizeof(ctx->ns_params.nguid), "size mismatch"); 1269 memcpy(ns_opts.nguid, ctx->ns_params.nguid, sizeof(ns_opts.nguid)); 1270 1271 SPDK_STATIC_ASSERT(sizeof(ns_opts.eui64) == sizeof(ctx->ns_params.eui64), "size mismatch"); 1272 memcpy(ns_opts.eui64, ctx->ns_params.eui64, sizeof(ns_opts.eui64)); 1273 1274 if (!spdk_mem_all_zero(&ctx->ns_params.uuid, sizeof(ctx->ns_params.uuid))) { 1275 ns_opts.uuid = ctx->ns_params.uuid; 1276 } 1277 1278 ctx->ns_params.nsid = spdk_nvmf_subsystem_add_ns_ext(subsystem, ctx->ns_params.bdev_name, 1279 &ns_opts, sizeof(ns_opts), 1280 ctx->ns_params.ptpl_file); 1281 if (ctx->ns_params.nsid == 0) { 1282 SPDK_ERRLOG("Unable to add namespace\n"); 1283 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1284 "Invalid parameters"); 1285 ctx->response_sent = true; 1286 goto resume; 1287 } 1288 1289 resume: 1290 if (spdk_nvmf_subsystem_resume(subsystem, nvmf_rpc_ns_resumed, ctx)) { 1291 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1292 nvmf_rpc_ns_ctx_free(ctx); 1293 } 1294 } 1295 1296 static void 1297 rpc_nvmf_subsystem_add_ns(struct spdk_jsonrpc_request *request, 1298 const struct spdk_json_val *params) 1299 { 1300 struct nvmf_rpc_ns_ctx *ctx; 1301 struct spdk_nvmf_subsystem *subsystem; 1302 struct spdk_nvmf_tgt *tgt; 1303 int rc; 1304 1305 ctx = calloc(1, sizeof(*ctx)); 1306 if (!ctx) { 1307 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 1308 return; 1309 } 1310 1311 if (spdk_json_decode_object(params, nvmf_rpc_subsystem_ns_decoder, 1312 SPDK_COUNTOF(nvmf_rpc_subsystem_ns_decoder), 1313 ctx)) { 1314 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1315 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1316 nvmf_rpc_ns_ctx_free(ctx); 1317 return; 1318 } 1319 1320 ctx->request = request; 1321 ctx->response_sent = false; 1322 1323 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 1324 if (!tgt) { 1325 SPDK_ERRLOG("Unable to find a target object.\n"); 1326 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1327 "Unable to find a target."); 1328 nvmf_rpc_ns_ctx_free(ctx); 1329 return; 1330 } 1331 1332 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 1333 if (!subsystem) { 1334 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 1335 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1336 nvmf_rpc_ns_ctx_free(ctx); 1337 return; 1338 } 1339 1340 rc = spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_ns_paused, ctx); 1341 if (rc != 0) { 1342 if (rc == -EBUSY) { 1343 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1344 "subsystem busy, retry later.\n"); 1345 } else { 1346 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1347 } 1348 nvmf_rpc_ns_ctx_free(ctx); 1349 } 1350 } 1351 SPDK_RPC_REGISTER("nvmf_subsystem_add_ns", rpc_nvmf_subsystem_add_ns, SPDK_RPC_RUNTIME) 1352 1353 struct nvmf_rpc_remove_ns_ctx { 1354 char *nqn; 1355 char *tgt_name; 1356 uint32_t nsid; 1357 1358 struct spdk_jsonrpc_request *request; 1359 bool response_sent; 1360 }; 1361 1362 static const struct spdk_json_object_decoder nvmf_rpc_subsystem_remove_ns_decoder[] = { 1363 {"nqn", offsetof(struct nvmf_rpc_remove_ns_ctx, nqn), spdk_json_decode_string}, 1364 {"nsid", offsetof(struct nvmf_rpc_remove_ns_ctx, nsid), spdk_json_decode_uint32}, 1365 {"tgt_name", offsetof(struct nvmf_rpc_remove_ns_ctx, tgt_name), spdk_json_decode_string, true}, 1366 }; 1367 1368 static void 1369 nvmf_rpc_remove_ns_ctx_free(struct nvmf_rpc_remove_ns_ctx *ctx) 1370 { 1371 free(ctx->nqn); 1372 free(ctx->tgt_name); 1373 free(ctx); 1374 } 1375 1376 static void 1377 nvmf_rpc_remove_ns_resumed(struct spdk_nvmf_subsystem *subsystem, 1378 void *cb_arg, int status) 1379 { 1380 struct nvmf_rpc_remove_ns_ctx *ctx = cb_arg; 1381 struct spdk_jsonrpc_request *request = ctx->request; 1382 bool response_sent = ctx->response_sent; 1383 struct spdk_json_write_ctx *w; 1384 1385 nvmf_rpc_remove_ns_ctx_free(ctx); 1386 1387 if (response_sent) { 1388 return; 1389 } 1390 1391 w = spdk_jsonrpc_begin_result(request); 1392 spdk_json_write_bool(w, true); 1393 spdk_jsonrpc_end_result(request, w); 1394 } 1395 1396 static void 1397 nvmf_rpc_remove_ns_paused(struct spdk_nvmf_subsystem *subsystem, 1398 void *cb_arg, int status) 1399 { 1400 struct nvmf_rpc_remove_ns_ctx *ctx = cb_arg; 1401 int ret; 1402 1403 ret = spdk_nvmf_subsystem_remove_ns(subsystem, ctx->nsid); 1404 if (ret < 0) { 1405 SPDK_ERRLOG("Unable to remove namespace ID %u\n", ctx->nsid); 1406 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1407 "Invalid parameters"); 1408 ctx->response_sent = true; 1409 } 1410 1411 if (spdk_nvmf_subsystem_resume(subsystem, nvmf_rpc_remove_ns_resumed, ctx)) { 1412 if (!ctx->response_sent) { 1413 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1414 } 1415 nvmf_rpc_remove_ns_ctx_free(ctx); 1416 } 1417 } 1418 1419 static void 1420 rpc_nvmf_subsystem_remove_ns(struct spdk_jsonrpc_request *request, 1421 const struct spdk_json_val *params) 1422 { 1423 struct nvmf_rpc_remove_ns_ctx *ctx; 1424 struct spdk_nvmf_subsystem *subsystem; 1425 struct spdk_nvmf_tgt *tgt; 1426 int rc; 1427 1428 ctx = calloc(1, sizeof(*ctx)); 1429 if (!ctx) { 1430 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 1431 return; 1432 } 1433 1434 if (spdk_json_decode_object(params, nvmf_rpc_subsystem_remove_ns_decoder, 1435 SPDK_COUNTOF(nvmf_rpc_subsystem_remove_ns_decoder), 1436 ctx)) { 1437 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1438 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1439 nvmf_rpc_remove_ns_ctx_free(ctx); 1440 return; 1441 } 1442 1443 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 1444 if (!tgt) { 1445 SPDK_ERRLOG("Unable to find a target object.\n"); 1446 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1447 "Unable to find a target."); 1448 nvmf_rpc_remove_ns_ctx_free(ctx); 1449 return; 1450 } 1451 1452 ctx->request = request; 1453 ctx->response_sent = false; 1454 1455 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 1456 if (!subsystem) { 1457 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 1458 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1459 nvmf_rpc_remove_ns_ctx_free(ctx); 1460 return; 1461 } 1462 1463 rc = spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_remove_ns_paused, ctx); 1464 if (rc != 0) { 1465 if (rc == -EBUSY) { 1466 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1467 "subsystem busy, retry later.\n"); 1468 } else { 1469 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1470 } 1471 nvmf_rpc_remove_ns_ctx_free(ctx); 1472 } 1473 } 1474 SPDK_RPC_REGISTER("nvmf_subsystem_remove_ns", rpc_nvmf_subsystem_remove_ns, SPDK_RPC_RUNTIME) 1475 1476 enum nvmf_rpc_host_op { 1477 NVMF_RPC_HOST_ADD, 1478 NVMF_RPC_HOST_REMOVE, 1479 NVMF_RPC_HOST_ALLOW_ANY, 1480 }; 1481 1482 struct nvmf_rpc_host_ctx { 1483 struct spdk_jsonrpc_request *request; 1484 1485 char *nqn; 1486 char *host; 1487 char *tgt_name; 1488 1489 enum nvmf_rpc_host_op op; 1490 1491 bool allow_any_host; 1492 1493 bool response_sent; 1494 }; 1495 1496 static const struct spdk_json_object_decoder nvmf_rpc_subsystem_host_decoder[] = { 1497 {"nqn", offsetof(struct nvmf_rpc_host_ctx, nqn), spdk_json_decode_string}, 1498 {"host", offsetof(struct nvmf_rpc_host_ctx, host), spdk_json_decode_string}, 1499 {"tgt_name", offsetof(struct nvmf_rpc_host_ctx, tgt_name), spdk_json_decode_string, true}, 1500 }; 1501 1502 static void 1503 nvmf_rpc_host_ctx_free(struct nvmf_rpc_host_ctx *ctx) 1504 { 1505 free(ctx->nqn); 1506 free(ctx->host); 1507 free(ctx->tgt_name); 1508 free(ctx); 1509 } 1510 1511 static void 1512 nvmf_rpc_host_resumed(struct spdk_nvmf_subsystem *subsystem, 1513 void *cb_arg, int status) 1514 { 1515 struct nvmf_rpc_host_ctx *ctx = cb_arg; 1516 struct spdk_jsonrpc_request *request; 1517 struct spdk_json_write_ctx *w; 1518 bool response_sent = ctx->response_sent; 1519 1520 request = ctx->request; 1521 nvmf_rpc_host_ctx_free(ctx); 1522 1523 if (response_sent) { 1524 return; 1525 } 1526 1527 w = spdk_jsonrpc_begin_result(request); 1528 spdk_json_write_bool(w, true); 1529 spdk_jsonrpc_end_result(request, w); 1530 } 1531 1532 static void 1533 nvmf_rpc_host_paused(struct spdk_nvmf_subsystem *subsystem, 1534 void *cb_arg, int status) 1535 { 1536 struct nvmf_rpc_host_ctx *ctx = cb_arg; 1537 int rc = -1; 1538 1539 switch (ctx->op) { 1540 case NVMF_RPC_HOST_ADD: 1541 rc = spdk_nvmf_subsystem_add_host(subsystem, ctx->host); 1542 break; 1543 case NVMF_RPC_HOST_REMOVE: 1544 rc = spdk_nvmf_subsystem_remove_host(subsystem, ctx->host); 1545 break; 1546 case NVMF_RPC_HOST_ALLOW_ANY: 1547 rc = spdk_nvmf_subsystem_set_allow_any_host(subsystem, ctx->allow_any_host); 1548 break; 1549 } 1550 1551 if (rc != 0) { 1552 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1553 ctx->response_sent = true; 1554 } 1555 1556 if (spdk_nvmf_subsystem_resume(subsystem, nvmf_rpc_host_resumed, ctx)) { 1557 if (!ctx->response_sent) { 1558 spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1559 } 1560 nvmf_rpc_host_ctx_free(ctx); 1561 } 1562 } 1563 1564 static void 1565 rpc_nvmf_subsystem_add_host(struct spdk_jsonrpc_request *request, 1566 const struct spdk_json_val *params) 1567 { 1568 struct nvmf_rpc_host_ctx *ctx; 1569 struct spdk_nvmf_subsystem *subsystem; 1570 struct spdk_nvmf_tgt *tgt; 1571 int rc; 1572 1573 ctx = calloc(1, sizeof(*ctx)); 1574 if (!ctx) { 1575 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 1576 return; 1577 } 1578 1579 if (spdk_json_decode_object(params, nvmf_rpc_subsystem_host_decoder, 1580 SPDK_COUNTOF(nvmf_rpc_subsystem_host_decoder), 1581 ctx)) { 1582 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1583 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1584 nvmf_rpc_host_ctx_free(ctx); 1585 return; 1586 } 1587 1588 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 1589 if (!tgt) { 1590 SPDK_ERRLOG("Unable to find a target object.\n"); 1591 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1592 "Unable to find a target."); 1593 nvmf_rpc_host_ctx_free(ctx); 1594 return; 1595 } 1596 1597 ctx->request = request; 1598 ctx->op = NVMF_RPC_HOST_ADD; 1599 ctx->response_sent = false; 1600 1601 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 1602 if (!subsystem) { 1603 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 1604 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1605 nvmf_rpc_host_ctx_free(ctx); 1606 return; 1607 } 1608 1609 rc = spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_host_paused, ctx); 1610 if (rc != 0) { 1611 if (rc == -EBUSY) { 1612 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1613 "subsystem busy, retry later.\n"); 1614 } else { 1615 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1616 } 1617 nvmf_rpc_host_ctx_free(ctx); 1618 } 1619 } 1620 SPDK_RPC_REGISTER("nvmf_subsystem_add_host", rpc_nvmf_subsystem_add_host, SPDK_RPC_RUNTIME) 1621 1622 static void 1623 rpc_nvmf_subsystem_remove_host(struct spdk_jsonrpc_request *request, 1624 const struct spdk_json_val *params) 1625 { 1626 struct nvmf_rpc_host_ctx *ctx; 1627 struct spdk_nvmf_subsystem *subsystem; 1628 struct spdk_nvmf_tgt *tgt; 1629 int rc; 1630 1631 ctx = calloc(1, sizeof(*ctx)); 1632 if (!ctx) { 1633 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 1634 return; 1635 } 1636 1637 if (spdk_json_decode_object(params, nvmf_rpc_subsystem_host_decoder, 1638 SPDK_COUNTOF(nvmf_rpc_subsystem_host_decoder), 1639 ctx)) { 1640 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1641 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1642 nvmf_rpc_host_ctx_free(ctx); 1643 return; 1644 } 1645 1646 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 1647 if (!tgt) { 1648 SPDK_ERRLOG("Unable to find a target object.\n"); 1649 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1650 "Unable to find a target."); 1651 nvmf_rpc_host_ctx_free(ctx); 1652 return; 1653 } 1654 1655 ctx->request = request; 1656 ctx->op = NVMF_RPC_HOST_REMOVE; 1657 ctx->response_sent = false; 1658 1659 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 1660 if (!subsystem) { 1661 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 1662 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1663 nvmf_rpc_host_ctx_free(ctx); 1664 return; 1665 } 1666 1667 rc = spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_host_paused, ctx); 1668 if (rc != 0) { 1669 if (rc == -EBUSY) { 1670 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1671 "subsystem busy, retry later.\n"); 1672 } else { 1673 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1674 } 1675 nvmf_rpc_host_ctx_free(ctx); 1676 } 1677 } 1678 SPDK_RPC_REGISTER("nvmf_subsystem_remove_host", rpc_nvmf_subsystem_remove_host, 1679 SPDK_RPC_RUNTIME) 1680 1681 1682 static const struct spdk_json_object_decoder nvmf_rpc_subsystem_any_host_decoder[] = { 1683 {"nqn", offsetof(struct nvmf_rpc_host_ctx, nqn), spdk_json_decode_string}, 1684 {"allow_any_host", offsetof(struct nvmf_rpc_host_ctx, allow_any_host), spdk_json_decode_bool}, 1685 {"tgt_name", offsetof(struct nvmf_rpc_host_ctx, tgt_name), spdk_json_decode_string, true}, 1686 }; 1687 1688 static void 1689 rpc_nvmf_subsystem_allow_any_host(struct spdk_jsonrpc_request *request, 1690 const struct spdk_json_val *params) 1691 { 1692 struct nvmf_rpc_host_ctx *ctx; 1693 struct spdk_nvmf_subsystem *subsystem; 1694 struct spdk_nvmf_tgt *tgt; 1695 int rc; 1696 1697 ctx = calloc(1, sizeof(*ctx)); 1698 if (!ctx) { 1699 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 1700 return; 1701 } 1702 1703 if (spdk_json_decode_object(params, nvmf_rpc_subsystem_any_host_decoder, 1704 SPDK_COUNTOF(nvmf_rpc_subsystem_any_host_decoder), 1705 ctx)) { 1706 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1707 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1708 nvmf_rpc_host_ctx_free(ctx); 1709 return; 1710 } 1711 1712 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 1713 if (!tgt) { 1714 SPDK_ERRLOG("Unable to find a target object.\n"); 1715 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1716 "Unable to find a target."); 1717 nvmf_rpc_host_ctx_free(ctx); 1718 return; 1719 } 1720 1721 ctx->request = request; 1722 ctx->op = NVMF_RPC_HOST_ALLOW_ANY; 1723 ctx->response_sent = false; 1724 1725 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 1726 if (!subsystem) { 1727 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 1728 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1729 nvmf_rpc_host_ctx_free(ctx); 1730 return; 1731 } 1732 1733 rc = spdk_nvmf_subsystem_pause(subsystem, nvmf_rpc_host_paused, ctx); 1734 if (rc != 0) { 1735 if (rc == -EBUSY) { 1736 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1737 "subsystem busy, retry later.\n"); 1738 } else { 1739 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); 1740 } 1741 nvmf_rpc_host_ctx_free(ctx); 1742 } 1743 } 1744 SPDK_RPC_REGISTER("nvmf_subsystem_allow_any_host", rpc_nvmf_subsystem_allow_any_host, 1745 SPDK_RPC_RUNTIME) 1746 1747 struct nvmf_rpc_target_ctx { 1748 char *name; 1749 uint32_t max_subsystems; 1750 }; 1751 1752 static const struct spdk_json_object_decoder nvmf_rpc_create_target_decoder[] = { 1753 {"name", offsetof(struct nvmf_rpc_target_ctx, name), spdk_json_decode_string}, 1754 {"max_subsystems", offsetof(struct nvmf_rpc_target_ctx, max_subsystems), spdk_json_decode_uint32, true}, 1755 }; 1756 1757 static void 1758 rpc_nvmf_create_target(struct spdk_jsonrpc_request *request, 1759 const struct spdk_json_val *params) 1760 { 1761 struct spdk_nvmf_target_opts opts; 1762 struct nvmf_rpc_target_ctx ctx = {0}; 1763 struct spdk_nvmf_tgt *tgt; 1764 struct spdk_json_write_ctx *w; 1765 1766 /* Decode parameters the first time to get the transport type */ 1767 if (spdk_json_decode_object(params, nvmf_rpc_create_target_decoder, 1768 SPDK_COUNTOF(nvmf_rpc_create_target_decoder), 1769 &ctx)) { 1770 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1771 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1772 free(ctx.name); 1773 return; 1774 } 1775 1776 snprintf(opts.name, NVMF_TGT_NAME_MAX_LENGTH, "%s", ctx.name); 1777 opts.max_subsystems = ctx.max_subsystems; 1778 1779 if (spdk_nvmf_get_tgt(opts.name) != NULL) { 1780 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1781 "Target already exists."); 1782 free(ctx.name); 1783 return; 1784 } 1785 1786 tgt = spdk_nvmf_tgt_create(&opts); 1787 1788 if (tgt == NULL) { 1789 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1790 "Unable to create the requested target."); 1791 free(ctx.name); 1792 return; 1793 } 1794 1795 w = spdk_jsonrpc_begin_result(request); 1796 spdk_json_write_string(w, spdk_nvmf_tgt_get_name(tgt)); 1797 spdk_jsonrpc_end_result(request, w); 1798 free(ctx.name); 1799 } 1800 SPDK_RPC_REGISTER("nvmf_create_target", rpc_nvmf_create_target, SPDK_RPC_RUNTIME); 1801 1802 static const struct spdk_json_object_decoder nvmf_rpc_destroy_target_decoder[] = { 1803 {"name", offsetof(struct nvmf_rpc_target_ctx, name), spdk_json_decode_string}, 1804 }; 1805 1806 static void 1807 nvmf_rpc_destroy_target_done(void *ctx, int status) 1808 { 1809 struct spdk_jsonrpc_request *request = ctx; 1810 struct spdk_json_write_ctx *w; 1811 1812 w = spdk_jsonrpc_begin_result(request); 1813 spdk_json_write_bool(w, true); 1814 spdk_jsonrpc_end_result(request, w); 1815 } 1816 1817 static void 1818 rpc_nvmf_delete_target(struct spdk_jsonrpc_request *request, 1819 const struct spdk_json_val *params) 1820 { 1821 struct nvmf_rpc_target_ctx ctx = {0}; 1822 struct spdk_nvmf_tgt *tgt; 1823 1824 /* Decode parameters the first time to get the transport type */ 1825 if (spdk_json_decode_object(params, nvmf_rpc_destroy_target_decoder, 1826 SPDK_COUNTOF(nvmf_rpc_destroy_target_decoder), 1827 &ctx)) { 1828 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1829 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 1830 free(ctx.name); 1831 return; 1832 } 1833 1834 tgt = spdk_nvmf_get_tgt(ctx.name); 1835 1836 if (tgt == NULL) { 1837 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1838 "The specified target doesn't exist, cannot delete it."); 1839 free(ctx.name); 1840 return; 1841 } 1842 1843 spdk_nvmf_tgt_destroy(tgt, nvmf_rpc_destroy_target_done, request); 1844 free(ctx.name); 1845 } 1846 SPDK_RPC_REGISTER("nvmf_delete_target", rpc_nvmf_delete_target, SPDK_RPC_RUNTIME); 1847 1848 static void 1849 rpc_nvmf_get_targets(struct spdk_jsonrpc_request *request, 1850 const struct spdk_json_val *params) 1851 { 1852 struct spdk_json_write_ctx *w; 1853 struct spdk_nvmf_tgt *tgt; 1854 const char *name; 1855 1856 if (params != NULL) { 1857 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1858 "nvmf_get_targets has no parameters."); 1859 return; 1860 } 1861 1862 w = spdk_jsonrpc_begin_result(request); 1863 spdk_json_write_array_begin(w); 1864 1865 tgt = spdk_nvmf_get_first_tgt(); 1866 1867 while (tgt != NULL) { 1868 name = spdk_nvmf_tgt_get_name(tgt); 1869 spdk_json_write_string(w, name); 1870 tgt = spdk_nvmf_get_next_tgt(tgt); 1871 } 1872 1873 spdk_json_write_array_end(w); 1874 spdk_jsonrpc_end_result(request, w); 1875 } 1876 SPDK_RPC_REGISTER("nvmf_get_targets", rpc_nvmf_get_targets, SPDK_RPC_RUNTIME); 1877 1878 struct nvmf_rpc_create_transport_ctx { 1879 char *trtype; 1880 char *tgt_name; 1881 struct spdk_nvmf_transport_opts opts; 1882 struct spdk_jsonrpc_request *request; 1883 }; 1884 1885 /** 1886 * `max_qpairs_per_ctrlr` represents both admin and IO qpairs, that confuses 1887 * users when they configure a transport using RPC. So it was decided to 1888 * deprecate `max_qpairs_per_ctrlr` RPC parameter and use `max_io_qpairs_per_ctrlr` 1889 * But internal logic remains unchanged and SPDK expects that 1890 * spdk_nvmf_transport_opts::max_qpairs_per_ctrlr includes an admin qpair. 1891 * This function parses the number of IO qpairs and adds +1 for admin qpair. 1892 */ 1893 static int 1894 nvmf_rpc_decode_max_io_qpairs(const struct spdk_json_val *val, void *out) 1895 { 1896 uint16_t *i = out; 1897 int rc; 1898 1899 rc = spdk_json_number_to_uint16(val, i); 1900 if (rc == 0) { 1901 (*i)++; 1902 } 1903 1904 return rc; 1905 } 1906 1907 /** 1908 * This function parses deprecated `max_qpairs_per_ctrlr` and warns the user to use 1909 * the new parameter `max_io_qpairs_per_ctrlr` 1910 */ 1911 static int 1912 nvmf_rpc_decode_max_qpairs(const struct spdk_json_val *val, void *out) 1913 { 1914 uint16_t *i = out; 1915 int rc; 1916 1917 rc = spdk_json_number_to_uint16(val, i); 1918 if (rc == 0) { 1919 SPDK_WARNLOG("Parameter max_qpairs_per_ctrlr is deprecated, use max_io_qpairs_per_ctrlr instead.\n"); 1920 } 1921 1922 return rc; 1923 } 1924 1925 static const struct spdk_json_object_decoder nvmf_rpc_create_transport_decoder[] = { 1926 { "trtype", offsetof(struct nvmf_rpc_create_transport_ctx, trtype), spdk_json_decode_string}, 1927 { 1928 "max_queue_depth", offsetof(struct nvmf_rpc_create_transport_ctx, opts.max_queue_depth), 1929 spdk_json_decode_uint16, true 1930 }, 1931 { 1932 "max_qpairs_per_ctrlr", offsetof(struct nvmf_rpc_create_transport_ctx, opts.max_qpairs_per_ctrlr), 1933 nvmf_rpc_decode_max_qpairs, true 1934 }, 1935 { 1936 "max_io_qpairs_per_ctrlr", offsetof(struct nvmf_rpc_create_transport_ctx, opts.max_qpairs_per_ctrlr), 1937 nvmf_rpc_decode_max_io_qpairs, true 1938 }, 1939 { 1940 "in_capsule_data_size", offsetof(struct nvmf_rpc_create_transport_ctx, opts.in_capsule_data_size), 1941 spdk_json_decode_uint32, true 1942 }, 1943 { 1944 "max_io_size", offsetof(struct nvmf_rpc_create_transport_ctx, opts.max_io_size), 1945 spdk_json_decode_uint32, true 1946 }, 1947 { 1948 "io_unit_size", offsetof(struct nvmf_rpc_create_transport_ctx, opts.io_unit_size), 1949 spdk_json_decode_uint32, true 1950 }, 1951 { 1952 "max_aq_depth", offsetof(struct nvmf_rpc_create_transport_ctx, opts.max_aq_depth), 1953 spdk_json_decode_uint32, true 1954 }, 1955 { 1956 "num_shared_buffers", offsetof(struct nvmf_rpc_create_transport_ctx, opts.num_shared_buffers), 1957 spdk_json_decode_uint32, true 1958 }, 1959 { 1960 "buf_cache_size", offsetof(struct nvmf_rpc_create_transport_ctx, opts.buf_cache_size), 1961 spdk_json_decode_uint32, true 1962 }, 1963 { 1964 "max_srq_depth", offsetof(struct nvmf_rpc_create_transport_ctx, opts.max_srq_depth), 1965 spdk_json_decode_uint32, true 1966 }, 1967 { 1968 "no_srq", offsetof(struct nvmf_rpc_create_transport_ctx, opts.no_srq), 1969 spdk_json_decode_bool, true 1970 }, 1971 { 1972 "c2h_success", offsetof(struct nvmf_rpc_create_transport_ctx, opts.c2h_success), 1973 spdk_json_decode_bool, true 1974 }, 1975 { 1976 "dif_insert_or_strip", offsetof(struct nvmf_rpc_create_transport_ctx, opts.dif_insert_or_strip), 1977 spdk_json_decode_bool, true 1978 }, 1979 { 1980 "sock_priority", offsetof(struct nvmf_rpc_create_transport_ctx, opts.sock_priority), 1981 spdk_json_decode_uint32, true 1982 }, 1983 { 1984 "acceptor_backlog", offsetof(struct nvmf_rpc_create_transport_ctx, opts.acceptor_backlog), 1985 spdk_json_decode_int32, true 1986 }, 1987 { 1988 "abort_timeout_sec", offsetof(struct nvmf_rpc_create_transport_ctx, opts.abort_timeout_sec), 1989 spdk_json_decode_uint32, true 1990 }, 1991 { 1992 "tgt_name", offsetof(struct nvmf_rpc_create_transport_ctx, tgt_name), 1993 spdk_json_decode_string, true 1994 }, 1995 }; 1996 1997 static void 1998 nvmf_rpc_create_transport_ctx_free(struct nvmf_rpc_create_transport_ctx *ctx) 1999 { 2000 free(ctx->trtype); 2001 free(ctx->tgt_name); 2002 free(ctx); 2003 } 2004 2005 static void 2006 nvmf_rpc_tgt_add_transport_done(void *cb_arg, int status) 2007 { 2008 struct nvmf_rpc_create_transport_ctx *ctx = cb_arg; 2009 struct spdk_jsonrpc_request *request; 2010 struct spdk_json_write_ctx *w; 2011 2012 request = ctx->request; 2013 nvmf_rpc_create_transport_ctx_free(ctx); 2014 2015 if (status) { 2016 SPDK_ERRLOG("Failed to add transport to tgt.(%d)\n", status); 2017 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2018 "Failed to add transport to tgt.(%d)\n", 2019 status); 2020 return; 2021 } 2022 2023 w = spdk_jsonrpc_begin_result(request); 2024 spdk_json_write_bool(w, true); 2025 spdk_jsonrpc_end_result(request, w); 2026 } 2027 2028 static void 2029 rpc_nvmf_create_transport(struct spdk_jsonrpc_request *request, 2030 const struct spdk_json_val *params) 2031 { 2032 struct nvmf_rpc_create_transport_ctx *ctx; 2033 enum spdk_nvme_transport_type trtype; 2034 struct spdk_nvmf_transport *transport; 2035 struct spdk_nvmf_tgt *tgt; 2036 2037 ctx = calloc(1, sizeof(*ctx)); 2038 if (!ctx) { 2039 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); 2040 return; 2041 } 2042 2043 /* Decode parameters the first time to get the transport type */ 2044 if (spdk_json_decode_object(params, nvmf_rpc_create_transport_decoder, 2045 SPDK_COUNTOF(nvmf_rpc_create_transport_decoder), 2046 ctx)) { 2047 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 2048 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 2049 nvmf_rpc_create_transport_ctx_free(ctx); 2050 return; 2051 } 2052 2053 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 2054 if (!tgt) { 2055 SPDK_ERRLOG("Unable to find a target object.\n"); 2056 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2057 "Unable to find a target."); 2058 nvmf_rpc_create_transport_ctx_free(ctx); 2059 return; 2060 } 2061 2062 if (spdk_nvme_transport_id_parse_trtype(&trtype, ctx->trtype)) { 2063 SPDK_ERRLOG("Invalid transport type '%s'\n", ctx->trtype); 2064 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 2065 "Invalid transport type '%s'\n", ctx->trtype); 2066 nvmf_rpc_create_transport_ctx_free(ctx); 2067 return; 2068 } 2069 2070 /* Initialize all the transport options (based on transport type) and decode the 2071 * parameters again to update any options passed in rpc create transport call. 2072 */ 2073 if (!spdk_nvmf_transport_opts_init(ctx->trtype, &ctx->opts)) { 2074 /* This can happen if user specifies PCIE transport type which isn't valid for 2075 * NVMe-oF. 2076 */ 2077 SPDK_ERRLOG("Invalid transport type '%s'\n", ctx->trtype); 2078 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 2079 "Invalid transport type '%s'\n", ctx->trtype); 2080 nvmf_rpc_create_transport_ctx_free(ctx); 2081 return; 2082 } 2083 2084 if (spdk_json_decode_object(params, nvmf_rpc_create_transport_decoder, 2085 SPDK_COUNTOF(nvmf_rpc_create_transport_decoder), 2086 ctx)) { 2087 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 2088 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 2089 nvmf_rpc_create_transport_ctx_free(ctx); 2090 return; 2091 } 2092 2093 if (spdk_nvmf_tgt_get_transport(tgt, ctx->trtype)) { 2094 SPDK_ERRLOG("Transport type '%s' already exists\n", ctx->trtype); 2095 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2096 "Transport type '%s' already exists\n", ctx->trtype); 2097 nvmf_rpc_create_transport_ctx_free(ctx); 2098 return; 2099 } 2100 2101 transport = spdk_nvmf_transport_create(ctx->trtype, &ctx->opts); 2102 2103 if (!transport) { 2104 SPDK_ERRLOG("Transport type '%s' create failed\n", ctx->trtype); 2105 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2106 "Transport type '%s' create failed\n", ctx->trtype); 2107 nvmf_rpc_create_transport_ctx_free(ctx); 2108 return; 2109 } 2110 2111 /* add transport to target */ 2112 ctx->request = request; 2113 spdk_nvmf_tgt_add_transport(tgt, transport, nvmf_rpc_tgt_add_transport_done, ctx); 2114 } 2115 SPDK_RPC_REGISTER("nvmf_create_transport", rpc_nvmf_create_transport, SPDK_RPC_RUNTIME) 2116 2117 static void 2118 dump_nvmf_transport(struct spdk_json_write_ctx *w, struct spdk_nvmf_transport *transport) 2119 { 2120 const struct spdk_nvmf_transport_opts *opts = spdk_nvmf_get_transport_opts(transport); 2121 spdk_nvme_transport_type_t type = spdk_nvmf_get_transport_type(transport); 2122 2123 spdk_json_write_object_begin(w); 2124 2125 spdk_json_write_named_string(w, "trtype", spdk_nvmf_get_transport_name(transport)); 2126 spdk_json_write_named_uint32(w, "max_queue_depth", opts->max_queue_depth); 2127 spdk_json_write_named_uint32(w, "max_io_qpairs_per_ctrlr", opts->max_qpairs_per_ctrlr - 1); 2128 spdk_json_write_named_uint32(w, "in_capsule_data_size", opts->in_capsule_data_size); 2129 spdk_json_write_named_uint32(w, "max_io_size", opts->max_io_size); 2130 spdk_json_write_named_uint32(w, "io_unit_size", opts->io_unit_size); 2131 spdk_json_write_named_uint32(w, "max_aq_depth", opts->max_aq_depth); 2132 spdk_json_write_named_uint32(w, "num_shared_buffers", opts->num_shared_buffers); 2133 spdk_json_write_named_uint32(w, "buf_cache_size", opts->buf_cache_size); 2134 spdk_json_write_named_bool(w, "dif_insert_or_strip", opts->dif_insert_or_strip); 2135 if (type == SPDK_NVME_TRANSPORT_RDMA) { 2136 spdk_json_write_named_uint32(w, "max_srq_depth", opts->max_srq_depth); 2137 spdk_json_write_named_bool(w, "no_srq", opts->no_srq); 2138 spdk_json_write_named_int32(w, "acceptor_backlog", opts->acceptor_backlog); 2139 } else if (type == SPDK_NVME_TRANSPORT_TCP) { 2140 spdk_json_write_named_bool(w, "c2h_success", opts->c2h_success); 2141 spdk_json_write_named_uint32(w, "sock_priority", opts->sock_priority); 2142 } 2143 spdk_json_write_named_uint32(w, "abort_timeout_sec", opts->abort_timeout_sec); 2144 2145 spdk_json_write_object_end(w); 2146 } 2147 2148 struct rpc_get_transport { 2149 char *tgt_name; 2150 }; 2151 2152 static const struct spdk_json_object_decoder rpc_get_transport_decoders[] = { 2153 {"tgt_name", offsetof(struct rpc_get_transport, tgt_name), spdk_json_decode_string, true}, 2154 }; 2155 2156 static void 2157 rpc_nvmf_get_transports(struct spdk_jsonrpc_request *request, 2158 const struct spdk_json_val *params) 2159 { 2160 struct rpc_get_transport req = { 0 }; 2161 struct spdk_json_write_ctx *w; 2162 struct spdk_nvmf_transport *transport; 2163 struct spdk_nvmf_tgt *tgt; 2164 2165 if (params) { 2166 if (spdk_json_decode_object(params, rpc_get_transport_decoders, 2167 SPDK_COUNTOF(rpc_get_transport_decoders), 2168 &req)) { 2169 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 2170 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 2171 return; 2172 } 2173 } 2174 2175 tgt = spdk_nvmf_get_tgt(req.tgt_name); 2176 if (!tgt) { 2177 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2178 "Unable to find a target."); 2179 free(req.tgt_name); 2180 return; 2181 } 2182 2183 w = spdk_jsonrpc_begin_result(request); 2184 spdk_json_write_array_begin(w); 2185 transport = spdk_nvmf_transport_get_first(tgt); 2186 while (transport) { 2187 dump_nvmf_transport(w, transport); 2188 transport = spdk_nvmf_transport_get_next(transport); 2189 } 2190 spdk_json_write_array_end(w); 2191 spdk_jsonrpc_end_result(request, w); 2192 free(req.tgt_name); 2193 } 2194 SPDK_RPC_REGISTER("nvmf_get_transports", rpc_nvmf_get_transports, SPDK_RPC_RUNTIME) 2195 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nvmf_get_transports, get_nvmf_transports) 2196 2197 struct rpc_nvmf_get_stats_ctx { 2198 char *tgt_name; 2199 struct spdk_nvmf_tgt *tgt; 2200 struct spdk_jsonrpc_request *request; 2201 struct spdk_json_write_ctx *w; 2202 }; 2203 2204 static const struct spdk_json_object_decoder rpc_get_stats_decoders[] = { 2205 {"tgt_name", offsetof(struct rpc_nvmf_get_stats_ctx, tgt_name), spdk_json_decode_string, true}, 2206 }; 2207 2208 static void 2209 free_get_stats_ctx(struct rpc_nvmf_get_stats_ctx *ctx) 2210 { 2211 free(ctx->tgt_name); 2212 free(ctx); 2213 } 2214 2215 static void 2216 rpc_nvmf_get_stats_done(struct spdk_io_channel_iter *i, int status) 2217 { 2218 struct rpc_nvmf_get_stats_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 2219 2220 spdk_json_write_array_end(ctx->w); 2221 spdk_json_write_object_end(ctx->w); 2222 spdk_jsonrpc_end_result(ctx->request, ctx->w); 2223 free_get_stats_ctx(ctx); 2224 } 2225 2226 static void 2227 write_nvmf_transport_stats(struct spdk_json_write_ctx *w, 2228 struct spdk_nvmf_transport_poll_group_stat *stat) 2229 { 2230 uint64_t i; 2231 2232 spdk_json_write_object_begin(w); 2233 spdk_json_write_named_string(w, "trtype", 2234 spdk_nvme_transport_id_trtype_str(stat->trtype)); 2235 switch (stat->trtype) { 2236 case SPDK_NVME_TRANSPORT_RDMA: 2237 spdk_json_write_named_uint64(w, "pending_data_buffer", stat->rdma.pending_data_buffer); 2238 spdk_json_write_named_array_begin(w, "devices"); 2239 for (i = 0; i < stat->rdma.num_devices; ++i) { 2240 spdk_json_write_object_begin(w); 2241 spdk_json_write_named_string(w, "name", stat->rdma.devices[i].name); 2242 spdk_json_write_named_uint64(w, "polls", stat->rdma.devices[i].polls); 2243 spdk_json_write_named_uint64(w, "completions", stat->rdma.devices[i].completions); 2244 spdk_json_write_named_uint64(w, "requests", 2245 stat->rdma.devices[i].requests); 2246 spdk_json_write_named_uint64(w, "request_latency", 2247 stat->rdma.devices[i].request_latency); 2248 spdk_json_write_named_uint64(w, "pending_free_request", 2249 stat->rdma.devices[i].pending_free_request); 2250 spdk_json_write_named_uint64(w, "pending_rdma_read", 2251 stat->rdma.devices[i].pending_rdma_read); 2252 spdk_json_write_named_uint64(w, "pending_rdma_write", 2253 stat->rdma.devices[i].pending_rdma_write); 2254 spdk_json_write_object_end(w); 2255 } 2256 spdk_json_write_array_end(w); 2257 break; 2258 default: 2259 break; 2260 } 2261 spdk_json_write_object_end(w); 2262 } 2263 2264 static void 2265 _rpc_nvmf_get_stats(struct spdk_io_channel_iter *i) 2266 { 2267 struct rpc_nvmf_get_stats_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 2268 struct spdk_nvmf_transport *transport; 2269 struct spdk_nvmf_poll_group_stat stat; 2270 struct spdk_nvmf_transport_poll_group_stat *trstat; 2271 int rc; 2272 2273 if (0 == spdk_nvmf_poll_group_get_stat(ctx->tgt, &stat)) { 2274 spdk_json_write_object_begin(ctx->w); 2275 spdk_json_write_named_string(ctx->w, "name", spdk_thread_get_name(spdk_get_thread())); 2276 spdk_json_write_named_uint32(ctx->w, "admin_qpairs", stat.admin_qpairs); 2277 spdk_json_write_named_uint32(ctx->w, "io_qpairs", stat.io_qpairs); 2278 spdk_json_write_named_uint64(ctx->w, "pending_bdev_io", stat.pending_bdev_io); 2279 2280 spdk_json_write_named_array_begin(ctx->w, "transports"); 2281 transport = spdk_nvmf_transport_get_first(ctx->tgt); 2282 while (transport) { 2283 rc = spdk_nvmf_transport_poll_group_get_stat(ctx->tgt, transport, &trstat); 2284 if (0 == rc) { 2285 write_nvmf_transport_stats(ctx->w, trstat); 2286 spdk_nvmf_transport_poll_group_free_stat(transport, trstat); 2287 } else if (-ENOTSUP != rc) { 2288 SPDK_ERRLOG("Failed to get poll group statistics for transport %s, errno %d\n", 2289 spdk_nvme_transport_id_trtype_str(spdk_nvmf_get_transport_type(transport)), 2290 rc); 2291 } 2292 transport = spdk_nvmf_transport_get_next(transport); 2293 } 2294 spdk_json_write_array_end(ctx->w); 2295 spdk_json_write_object_end(ctx->w); 2296 } 2297 2298 spdk_for_each_channel_continue(i, 0); 2299 } 2300 2301 2302 static void 2303 rpc_nvmf_get_stats(struct spdk_jsonrpc_request *request, 2304 const struct spdk_json_val *params) 2305 { 2306 struct rpc_nvmf_get_stats_ctx *ctx; 2307 2308 ctx = calloc(1, sizeof(*ctx)); 2309 if (!ctx) { 2310 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2311 "Memory allocation error"); 2312 return; 2313 } 2314 ctx->request = request; 2315 2316 if (params) { 2317 if (spdk_json_decode_object(params, rpc_get_stats_decoders, 2318 SPDK_COUNTOF(rpc_get_stats_decoders), 2319 ctx)) { 2320 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 2321 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 2322 free_get_stats_ctx(ctx); 2323 return; 2324 } 2325 } 2326 2327 ctx->tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 2328 if (!ctx->tgt) { 2329 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2330 "Unable to find a target."); 2331 free_get_stats_ctx(ctx); 2332 return; 2333 } 2334 2335 ctx->w = spdk_jsonrpc_begin_result(ctx->request); 2336 spdk_json_write_object_begin(ctx->w); 2337 spdk_json_write_named_uint64(ctx->w, "tick_rate", spdk_get_ticks_hz()); 2338 spdk_json_write_named_array_begin(ctx->w, "poll_groups"); 2339 2340 spdk_for_each_channel(ctx->tgt, 2341 _rpc_nvmf_get_stats, 2342 ctx, 2343 rpc_nvmf_get_stats_done); 2344 } 2345 2346 SPDK_RPC_REGISTER("nvmf_get_stats", rpc_nvmf_get_stats, SPDK_RPC_RUNTIME) 2347 2348 static void 2349 dump_nvmf_ctrlr(struct spdk_json_write_ctx *w, struct spdk_nvmf_ctrlr *ctrlr) 2350 { 2351 char uuid_str[SPDK_UUID_STRING_LEN] = {}; 2352 uint32_t count; 2353 2354 spdk_json_write_object_begin(w); 2355 2356 spdk_json_write_named_uint32(w, "cntlid", ctrlr->cntlid); 2357 2358 spdk_json_write_named_string(w, "hostnqn", ctrlr->hostnqn); 2359 2360 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &ctrlr->hostid); 2361 spdk_json_write_named_string(w, "hostid", uuid_str); 2362 2363 count = spdk_bit_array_count_set(ctrlr->qpair_mask); 2364 spdk_json_write_named_uint32(w, "num_io_qpairs", count); 2365 2366 spdk_json_write_object_end(w); 2367 } 2368 2369 static const char * 2370 nvmf_qpair_state_str(enum spdk_nvmf_qpair_state state) 2371 { 2372 switch (state) { 2373 case SPDK_NVMF_QPAIR_UNINITIALIZED: 2374 return "uninitialized"; 2375 case SPDK_NVMF_QPAIR_ACTIVE: 2376 return "active"; 2377 case SPDK_NVMF_QPAIR_DEACTIVATING: 2378 return "deactivating"; 2379 case SPDK_NVMF_QPAIR_ERROR: 2380 return "error"; 2381 default: 2382 return NULL; 2383 } 2384 } 2385 2386 static void 2387 dump_nvmf_qpair(struct spdk_json_write_ctx *w, struct spdk_nvmf_qpair *qpair) 2388 { 2389 const struct spdk_nvme_transport_id *trid = qpair->trid; 2390 const char *adrfam; 2391 2392 spdk_json_write_object_begin(w); 2393 2394 spdk_json_write_named_uint32(w, "cntlid", qpair->ctrlr->cntlid); 2395 spdk_json_write_named_uint32(w, "qid", qpair->qid); 2396 spdk_json_write_named_string(w, "state", nvmf_qpair_state_str(qpair->state)); 2397 2398 spdk_json_write_named_object_begin(w, "listen_address"); 2399 adrfam = spdk_nvme_transport_id_adrfam_str(trid->adrfam); 2400 if (adrfam == NULL) { 2401 adrfam = "unknown"; 2402 } 2403 spdk_json_write_named_string(w, "trtype", trid->trstring); 2404 spdk_json_write_named_string(w, "adrfam", adrfam); 2405 spdk_json_write_named_string(w, "traddr", trid->traddr); 2406 spdk_json_write_named_string(w, "trsvcid", trid->trsvcid); 2407 spdk_json_write_object_end(w); 2408 2409 spdk_json_write_object_end(w); 2410 } 2411 2412 static const char * 2413 nvme_ana_state_str(enum spdk_nvme_ana_state ana_state) 2414 { 2415 switch (ana_state) { 2416 case SPDK_NVME_ANA_OPTIMIZED_STATE: 2417 return "optimized"; 2418 case SPDK_NVME_ANA_NON_OPTIMIZED_STATE: 2419 return "non_optimized"; 2420 case SPDK_NVME_ANA_INACCESSIBLE_STATE: 2421 return "inaccessible"; 2422 case SPDK_NVME_ANA_PERSISTENT_LOSS_STATE: 2423 return "persistent_loss"; 2424 case SPDK_NVME_ANA_CHANGE_STATE: 2425 return "change"; 2426 default: 2427 return NULL; 2428 } 2429 } 2430 2431 static void 2432 dump_nvmf_subsystem_listener(struct spdk_json_write_ctx *w, 2433 struct spdk_nvmf_subsystem_listener *listener) 2434 { 2435 const struct spdk_nvme_transport_id *trid = listener->trid; 2436 const char *adrfam; 2437 2438 spdk_json_write_object_begin(w); 2439 2440 spdk_json_write_named_object_begin(w, "address"); 2441 adrfam = spdk_nvme_transport_id_adrfam_str(trid->adrfam); 2442 if (adrfam == NULL) { 2443 adrfam = "unknown"; 2444 } 2445 spdk_json_write_named_string(w, "trtype", trid->trstring); 2446 spdk_json_write_named_string(w, "adrfam", adrfam); 2447 spdk_json_write_named_string(w, "traddr", trid->traddr); 2448 spdk_json_write_named_string(w, "trsvcid", trid->trsvcid); 2449 spdk_json_write_object_end(w); 2450 2451 spdk_json_write_named_string(w, "ana_state", 2452 nvme_ana_state_str(listener->ana_state)); 2453 2454 spdk_json_write_object_end(w); 2455 } 2456 2457 struct rpc_subsystem_query_ctx { 2458 char *nqn; 2459 char *tgt_name; 2460 struct spdk_nvmf_subsystem *subsystem; 2461 struct spdk_jsonrpc_request *request; 2462 struct spdk_json_write_ctx *w; 2463 }; 2464 2465 static const struct spdk_json_object_decoder rpc_subsystem_query_decoders[] = { 2466 {"nqn", offsetof(struct rpc_subsystem_query_ctx, nqn), spdk_json_decode_string}, 2467 {"tgt_name", offsetof(struct rpc_subsystem_query_ctx, tgt_name), spdk_json_decode_string, true}, 2468 }; 2469 2470 static void 2471 free_rpc_subsystem_query_ctx(struct rpc_subsystem_query_ctx *ctx) 2472 { 2473 free(ctx->nqn); 2474 free(ctx->tgt_name); 2475 free(ctx); 2476 } 2477 2478 static void 2479 rpc_nvmf_get_controllers_paused(struct spdk_nvmf_subsystem *subsystem, 2480 void *cb_arg, int status) 2481 { 2482 struct rpc_subsystem_query_ctx *ctx = cb_arg; 2483 struct spdk_json_write_ctx *w; 2484 struct spdk_nvmf_ctrlr *ctrlr; 2485 2486 w = spdk_jsonrpc_begin_result(ctx->request); 2487 2488 spdk_json_write_array_begin(w); 2489 TAILQ_FOREACH(ctrlr, &ctx->subsystem->ctrlrs, link) { 2490 dump_nvmf_ctrlr(w, ctrlr); 2491 } 2492 spdk_json_write_array_end(w); 2493 2494 spdk_jsonrpc_end_result(ctx->request, w); 2495 2496 if (spdk_nvmf_subsystem_resume(ctx->subsystem, NULL, NULL)) { 2497 SPDK_ERRLOG("Resuming subsystem with NQN %s failed\n", ctx->nqn); 2498 /* FIXME: RPC should fail if resuming the subsystem failed. */ 2499 } 2500 2501 free_rpc_subsystem_query_ctx(ctx); 2502 } 2503 2504 static void 2505 rpc_nvmf_get_qpairs_done(struct spdk_io_channel_iter *i, int status) 2506 { 2507 struct rpc_subsystem_query_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 2508 2509 spdk_json_write_array_end(ctx->w); 2510 spdk_jsonrpc_end_result(ctx->request, ctx->w); 2511 2512 if (spdk_nvmf_subsystem_resume(ctx->subsystem, NULL, NULL)) { 2513 SPDK_ERRLOG("Resuming subsystem with NQN %s failed\n", ctx->nqn); 2514 /* FIXME: RPC should fail if resuming the subsystem failed. */ 2515 } 2516 2517 free_rpc_subsystem_query_ctx(ctx); 2518 } 2519 2520 static void 2521 rpc_nvmf_get_qpairs(struct spdk_io_channel_iter *i) 2522 { 2523 struct rpc_subsystem_query_ctx *ctx = spdk_io_channel_iter_get_ctx(i); 2524 struct spdk_io_channel *ch; 2525 struct spdk_nvmf_poll_group *group; 2526 struct spdk_nvmf_qpair *qpair; 2527 2528 ch = spdk_get_io_channel(ctx->subsystem->tgt); 2529 group = spdk_io_channel_get_ctx(ch); 2530 2531 TAILQ_FOREACH(qpair, &group->qpairs, link) { 2532 if (qpair->ctrlr->subsys == ctx->subsystem) { 2533 dump_nvmf_qpair(ctx->w, qpair); 2534 } 2535 } 2536 2537 spdk_for_each_channel_continue(i, 0); 2538 } 2539 2540 static void 2541 rpc_nvmf_get_qpairs_paused(struct spdk_nvmf_subsystem *subsystem, 2542 void *cb_arg, int status) 2543 { 2544 struct rpc_subsystem_query_ctx *ctx = cb_arg; 2545 2546 ctx->w = spdk_jsonrpc_begin_result(ctx->request); 2547 2548 spdk_json_write_array_begin(ctx->w); 2549 2550 spdk_for_each_channel(ctx->subsystem->tgt, 2551 rpc_nvmf_get_qpairs, 2552 ctx, 2553 rpc_nvmf_get_qpairs_done); 2554 } 2555 2556 static void 2557 rpc_nvmf_get_listeners_paused(struct spdk_nvmf_subsystem *subsystem, 2558 void *cb_arg, int status) 2559 { 2560 struct rpc_subsystem_query_ctx *ctx = cb_arg; 2561 struct spdk_json_write_ctx *w; 2562 struct spdk_nvmf_subsystem_listener *listener; 2563 2564 w = spdk_jsonrpc_begin_result(ctx->request); 2565 2566 spdk_json_write_array_begin(w); 2567 2568 for (listener = spdk_nvmf_subsystem_get_first_listener(ctx->subsystem); 2569 listener != NULL; 2570 listener = spdk_nvmf_subsystem_get_next_listener(ctx->subsystem, listener)) { 2571 dump_nvmf_subsystem_listener(w, listener); 2572 } 2573 spdk_json_write_array_end(w); 2574 2575 spdk_jsonrpc_end_result(ctx->request, w); 2576 2577 if (spdk_nvmf_subsystem_resume(ctx->subsystem, NULL, NULL)) { 2578 SPDK_ERRLOG("Resuming subsystem with NQN %s failed\n", ctx->nqn); 2579 /* FIXME: RPC should fail if resuming the subsystem failed. */ 2580 } 2581 2582 free_rpc_subsystem_query_ctx(ctx); 2583 } 2584 2585 static void 2586 _rpc_nvmf_subsystem_query(struct spdk_jsonrpc_request *request, 2587 const struct spdk_json_val *params, 2588 spdk_nvmf_subsystem_state_change_done cb_fn) 2589 { 2590 struct rpc_subsystem_query_ctx *ctx; 2591 struct spdk_nvmf_subsystem *subsystem; 2592 struct spdk_nvmf_tgt *tgt; 2593 2594 ctx = calloc(1, sizeof(*ctx)); 2595 if (!ctx) { 2596 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2597 "Out of memory"); 2598 return; 2599 } 2600 2601 ctx->request = request; 2602 2603 if (spdk_json_decode_object(params, rpc_subsystem_query_decoders, 2604 SPDK_COUNTOF(rpc_subsystem_query_decoders), 2605 ctx)) { 2606 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 2607 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 2608 "Invalid parameters"); 2609 free_rpc_subsystem_query_ctx(ctx); 2610 return; 2611 } 2612 2613 tgt = spdk_nvmf_get_tgt(ctx->tgt_name); 2614 if (!tgt) { 2615 SPDK_ERRLOG("Unable to find a target object.\n"); 2616 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2617 "Unable to find a target"); 2618 free_rpc_subsystem_query_ctx(ctx); 2619 return; 2620 } 2621 2622 subsystem = spdk_nvmf_tgt_find_subsystem(tgt, ctx->nqn); 2623 if (!subsystem) { 2624 SPDK_ERRLOG("Unable to find subsystem with NQN %s\n", ctx->nqn); 2625 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 2626 "Invalid parameters"); 2627 free_rpc_subsystem_query_ctx(ctx); 2628 return; 2629 } 2630 2631 ctx->subsystem = subsystem; 2632 2633 if (spdk_nvmf_subsystem_pause(subsystem, cb_fn, ctx)) { 2634 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 2635 "Internal error"); 2636 free_rpc_subsystem_query_ctx(ctx); 2637 return; 2638 } 2639 } 2640 2641 static void 2642 rpc_nvmf_subsystem_get_controllers(struct spdk_jsonrpc_request *request, 2643 const struct spdk_json_val *params) 2644 { 2645 _rpc_nvmf_subsystem_query(request, params, rpc_nvmf_get_controllers_paused); 2646 } 2647 SPDK_RPC_REGISTER("nvmf_subsystem_get_controllers", rpc_nvmf_subsystem_get_controllers, 2648 SPDK_RPC_RUNTIME); 2649 2650 static void 2651 rpc_nvmf_subsystem_get_qpairs(struct spdk_jsonrpc_request *request, 2652 const struct spdk_json_val *params) 2653 { 2654 _rpc_nvmf_subsystem_query(request, params, rpc_nvmf_get_qpairs_paused); 2655 } 2656 SPDK_RPC_REGISTER("nvmf_subsystem_get_qpairs", rpc_nvmf_subsystem_get_qpairs, SPDK_RPC_RUNTIME); 2657 2658 static void 2659 rpc_nvmf_subsystem_get_listeners(struct spdk_jsonrpc_request *request, 2660 const struct spdk_json_val *params) 2661 { 2662 _rpc_nvmf_subsystem_query(request, params, rpc_nvmf_get_listeners_paused); 2663 } 2664 SPDK_RPC_REGISTER("nvmf_subsystem_get_listeners", rpc_nvmf_subsystem_get_listeners, 2665 SPDK_RPC_RUNTIME); 2666