1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. All rights reserved. 5 * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "bdev_nvme.h" 37 #include "common.h" 38 39 #include "spdk/config.h" 40 41 #include "spdk/string.h" 42 #include "spdk/rpc.h" 43 #include "spdk/util.h" 44 45 #include "spdk_internal/log.h" 46 #include "spdk/bdev_module.h" 47 48 struct open_descriptors { 49 void *desc; 50 struct spdk_bdev *bdev; 51 TAILQ_ENTRY(open_descriptors) tqlst; 52 struct spdk_thread *thread; 53 }; 54 typedef TAILQ_HEAD(, open_descriptors) open_descriptors_t; 55 56 static int 57 rpc_decode_action_on_timeout(const struct spdk_json_val *val, void *out) 58 { 59 enum spdk_bdev_timeout_action *action = out; 60 61 if (spdk_json_strequal(val, "none") == true) { 62 *action = SPDK_BDEV_NVME_TIMEOUT_ACTION_NONE; 63 } else if (spdk_json_strequal(val, "abort") == true) { 64 *action = SPDK_BDEV_NVME_TIMEOUT_ACTION_ABORT; 65 } else if (spdk_json_strequal(val, "reset") == true) { 66 *action = SPDK_BDEV_NVME_TIMEOUT_ACTION_RESET; 67 } else { 68 SPDK_NOTICELOG("Invalid parameter value: action_on_timeout\n"); 69 return -EINVAL; 70 } 71 72 return 0; 73 } 74 75 static const struct spdk_json_object_decoder rpc_bdev_nvme_options_decoders[] = { 76 {"action_on_timeout", offsetof(struct spdk_bdev_nvme_opts, action_on_timeout), rpc_decode_action_on_timeout, true}, 77 {"timeout_us", offsetof(struct spdk_bdev_nvme_opts, timeout_us), spdk_json_decode_uint64, true}, 78 {"retry_count", offsetof(struct spdk_bdev_nvme_opts, retry_count), spdk_json_decode_uint32, true}, 79 {"arbitration_burst", offsetof(struct spdk_bdev_nvme_opts, arbitration_burst), spdk_json_decode_uint32, true}, 80 {"low_priority_weight", offsetof(struct spdk_bdev_nvme_opts, low_priority_weight), spdk_json_decode_uint32, true}, 81 {"medium_priority_weight", offsetof(struct spdk_bdev_nvme_opts, medium_priority_weight), spdk_json_decode_uint32, true}, 82 {"high_priority_weight", offsetof(struct spdk_bdev_nvme_opts, high_priority_weight), spdk_json_decode_uint32, true}, 83 {"nvme_adminq_poll_period_us", offsetof(struct spdk_bdev_nvme_opts, nvme_adminq_poll_period_us), spdk_json_decode_uint64, true}, 84 {"nvme_ioq_poll_period_us", offsetof(struct spdk_bdev_nvme_opts, nvme_ioq_poll_period_us), spdk_json_decode_uint64, true}, 85 {"io_queue_requests", offsetof(struct spdk_bdev_nvme_opts, io_queue_requests), spdk_json_decode_uint32, true}, 86 {"delay_cmd_submit", offsetof(struct spdk_bdev_nvme_opts, delay_cmd_submit), spdk_json_decode_bool, true}, 87 }; 88 89 static void 90 rpc_bdev_nvme_set_options(struct spdk_jsonrpc_request *request, 91 const struct spdk_json_val *params) 92 { 93 struct spdk_bdev_nvme_opts opts; 94 struct spdk_json_write_ctx *w; 95 int rc; 96 97 bdev_nvme_get_opts(&opts); 98 if (params && spdk_json_decode_object(params, rpc_bdev_nvme_options_decoders, 99 SPDK_COUNTOF(rpc_bdev_nvme_options_decoders), 100 &opts)) { 101 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 102 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 103 "spdk_json_decode_object failed"); 104 return; 105 } 106 107 rc = bdev_nvme_set_opts(&opts); 108 if (rc) { 109 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 110 return; 111 } 112 113 w = spdk_jsonrpc_begin_result(request); 114 spdk_json_write_bool(w, true); 115 spdk_jsonrpc_end_result(request, w); 116 117 return; 118 } 119 SPDK_RPC_REGISTER("bdev_nvme_set_options", rpc_bdev_nvme_set_options, 120 SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) 121 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_set_options, set_bdev_nvme_options) 122 123 struct rpc_bdev_nvme_hotplug { 124 bool enabled; 125 uint64_t period_us; 126 }; 127 128 static const struct spdk_json_object_decoder rpc_bdev_nvme_hotplug_decoders[] = { 129 {"enable", offsetof(struct rpc_bdev_nvme_hotplug, enabled), spdk_json_decode_bool, false}, 130 {"period_us", offsetof(struct rpc_bdev_nvme_hotplug, period_us), spdk_json_decode_uint64, true}, 131 }; 132 133 static void 134 rpc_bdev_nvme_set_hotplug_done(void *ctx) 135 { 136 struct spdk_jsonrpc_request *request = ctx; 137 struct spdk_json_write_ctx *w = spdk_jsonrpc_begin_result(request); 138 139 spdk_json_write_bool(w, true); 140 spdk_jsonrpc_end_result(request, w); 141 } 142 143 static void 144 rpc_bdev_nvme_set_hotplug(struct spdk_jsonrpc_request *request, 145 const struct spdk_json_val *params) 146 { 147 struct rpc_bdev_nvme_hotplug req = {false, 0}; 148 int rc; 149 150 if (spdk_json_decode_object(params, rpc_bdev_nvme_hotplug_decoders, 151 SPDK_COUNTOF(rpc_bdev_nvme_hotplug_decoders), &req)) { 152 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 153 rc = -EINVAL; 154 goto invalid; 155 } 156 157 rc = bdev_nvme_set_hotplug(req.enabled, req.period_us, rpc_bdev_nvme_set_hotplug_done, 158 request); 159 if (rc) { 160 goto invalid; 161 } 162 163 return; 164 invalid: 165 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(-rc)); 166 } 167 SPDK_RPC_REGISTER("bdev_nvme_set_hotplug", rpc_bdev_nvme_set_hotplug, SPDK_RPC_RUNTIME) 168 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_set_hotplug, set_bdev_nvme_hotplug) 169 170 struct rpc_bdev_nvme_attach_controller { 171 char *name; 172 char *trtype; 173 char *adrfam; 174 char *traddr; 175 char *trsvcid; 176 char *priority; 177 char *subnqn; 178 char *hostnqn; 179 char *hostaddr; 180 char *hostsvcid; 181 bool prchk_reftag; 182 bool prchk_guard; 183 }; 184 185 static void 186 free_rpc_bdev_nvme_attach_controller(struct rpc_bdev_nvme_attach_controller *req) 187 { 188 free(req->name); 189 free(req->trtype); 190 free(req->adrfam); 191 free(req->traddr); 192 free(req->trsvcid); 193 free(req->priority); 194 free(req->subnqn); 195 free(req->hostnqn); 196 free(req->hostaddr); 197 free(req->hostsvcid); 198 } 199 200 static const struct spdk_json_object_decoder rpc_bdev_nvme_attach_controller_decoders[] = { 201 {"name", offsetof(struct rpc_bdev_nvme_attach_controller, name), spdk_json_decode_string}, 202 {"trtype", offsetof(struct rpc_bdev_nvme_attach_controller, trtype), spdk_json_decode_string}, 203 {"traddr", offsetof(struct rpc_bdev_nvme_attach_controller, traddr), spdk_json_decode_string}, 204 205 {"adrfam", offsetof(struct rpc_bdev_nvme_attach_controller, adrfam), spdk_json_decode_string, true}, 206 {"trsvcid", offsetof(struct rpc_bdev_nvme_attach_controller, trsvcid), spdk_json_decode_string, true}, 207 {"priority", offsetof(struct rpc_bdev_nvme_attach_controller, priority), spdk_json_decode_string, true}, 208 {"subnqn", offsetof(struct rpc_bdev_nvme_attach_controller, subnqn), spdk_json_decode_string, true}, 209 {"hostnqn", offsetof(struct rpc_bdev_nvme_attach_controller, hostnqn), spdk_json_decode_string, true}, 210 {"hostaddr", offsetof(struct rpc_bdev_nvme_attach_controller, hostaddr), spdk_json_decode_string, true}, 211 {"hostsvcid", offsetof(struct rpc_bdev_nvme_attach_controller, hostsvcid), spdk_json_decode_string, true}, 212 213 {"prchk_reftag", offsetof(struct rpc_bdev_nvme_attach_controller, prchk_reftag), spdk_json_decode_bool, true}, 214 {"prchk_guard", offsetof(struct rpc_bdev_nvme_attach_controller, prchk_guard), spdk_json_decode_bool, true} 215 }; 216 217 #define NVME_MAX_BDEVS_PER_RPC 128 218 219 struct rpc_bdev_nvme_attach_controller_ctx { 220 struct rpc_bdev_nvme_attach_controller req; 221 uint32_t count; 222 const char *names[NVME_MAX_BDEVS_PER_RPC]; 223 struct spdk_jsonrpc_request *request; 224 }; 225 226 static void 227 rpc_bdev_nvme_attach_controller_done(void *cb_ctx, size_t bdev_count, int rc) 228 { 229 struct rpc_bdev_nvme_attach_controller_ctx *ctx = cb_ctx; 230 struct spdk_jsonrpc_request *request = ctx->request; 231 struct spdk_json_write_ctx *w; 232 size_t i; 233 234 if (rc < 0) { 235 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); 236 goto exit; 237 } 238 239 w = spdk_jsonrpc_begin_result(request); 240 spdk_json_write_array_begin(w); 241 for (i = 0; i < bdev_count; i++) { 242 spdk_json_write_string(w, ctx->names[i]); 243 } 244 spdk_json_write_array_end(w); 245 spdk_jsonrpc_end_result(request, w); 246 247 exit: 248 free_rpc_bdev_nvme_attach_controller(&ctx->req); 249 free(ctx); 250 } 251 252 static void 253 rpc_bdev_nvme_attach_controller(struct spdk_jsonrpc_request *request, 254 const struct spdk_json_val *params) 255 { 256 struct rpc_bdev_nvme_attach_controller_ctx *ctx; 257 struct spdk_nvme_transport_id trid = {}; 258 struct spdk_nvme_host_id hostid = {}; 259 uint32_t prchk_flags = 0; 260 struct nvme_bdev_ctrlr *ctrlr = NULL; 261 size_t len, maxlen; 262 int rc; 263 264 ctx = calloc(1, sizeof(*ctx)); 265 if (!ctx) { 266 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 267 return; 268 } 269 270 if (spdk_json_decode_object(params, rpc_bdev_nvme_attach_controller_decoders, 271 SPDK_COUNTOF(rpc_bdev_nvme_attach_controller_decoders), 272 &ctx->req)) { 273 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 274 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 275 "spdk_json_decode_object failed"); 276 goto cleanup; 277 } 278 279 /* Parse trstring */ 280 rc = spdk_nvme_transport_id_populate_trstring(&trid, ctx->req.trtype); 281 if (rc < 0) { 282 SPDK_ERRLOG("Failed to parse trtype: %s\n", ctx->req.trtype); 283 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "Failed to parse trtype: %s", 284 ctx->req.trtype); 285 goto cleanup; 286 } 287 288 /* Parse trtype */ 289 rc = spdk_nvme_transport_id_parse_trtype(&trid.trtype, ctx->req.trtype); 290 assert(rc == 0); 291 292 ctrlr = nvme_bdev_ctrlr_get_by_name(ctx->req.name); 293 294 /* Parse traddr */ 295 maxlen = sizeof(trid.traddr); 296 len = strnlen(ctx->req.traddr, maxlen); 297 if (len == maxlen) { 298 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "traddr too long: %s", 299 ctx->req.traddr); 300 goto cleanup; 301 } 302 memcpy(trid.traddr, ctx->req.traddr, len + 1); 303 304 /* Parse adrfam */ 305 if (ctx->req.adrfam) { 306 rc = spdk_nvme_transport_id_parse_adrfam(&trid.adrfam, ctx->req.adrfam); 307 if (rc < 0) { 308 SPDK_ERRLOG("Failed to parse adrfam: %s\n", ctx->req.adrfam); 309 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "Failed to parse adrfam: %s", 310 ctx->req.adrfam); 311 goto cleanup; 312 } 313 } 314 315 /* Parse trsvcid */ 316 if (ctx->req.trsvcid) { 317 maxlen = sizeof(trid.trsvcid); 318 len = strnlen(ctx->req.trsvcid, maxlen); 319 if (len == maxlen) { 320 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "trsvcid too long: %s", 321 ctx->req.trsvcid); 322 goto cleanup; 323 } 324 memcpy(trid.trsvcid, ctx->req.trsvcid, len + 1); 325 } 326 327 /* Parse priority for the NVMe-oF transport connection */ 328 if (ctx->req.priority) { 329 trid.priority = spdk_strtol(ctx->req.priority, 10); 330 } 331 332 /* Parse subnqn */ 333 if (ctx->req.subnqn) { 334 maxlen = sizeof(trid.subnqn); 335 len = strnlen(ctx->req.subnqn, maxlen); 336 if (len == maxlen) { 337 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "subnqn too long: %s", 338 ctx->req.subnqn); 339 goto cleanup; 340 } 341 memcpy(trid.subnqn, ctx->req.subnqn, len + 1); 342 } 343 344 if (ctrlr && (ctx->req.hostaddr || ctx->req.hostnqn || ctx->req.hostsvcid || ctx->req.prchk_guard || 345 ctx->req.prchk_reftag)) { 346 goto conflicting_arguments; 347 } 348 349 if (ctx->req.hostaddr) { 350 maxlen = sizeof(hostid.hostaddr); 351 len = strnlen(ctx->req.hostaddr, maxlen); 352 if (len == maxlen) { 353 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "hostaddr too long: %s", 354 ctx->req.hostaddr); 355 goto cleanup; 356 } 357 memcpy(hostid.hostaddr, ctx->req.hostaddr, len + 1); 358 } 359 360 if (ctx->req.hostsvcid) { 361 maxlen = sizeof(hostid.hostsvcid); 362 len = strnlen(ctx->req.hostsvcid, maxlen); 363 if (len == maxlen) { 364 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "hostsvcid too long: %s", 365 ctx->req.hostsvcid); 366 goto cleanup; 367 } 368 memcpy(hostid.hostsvcid, ctx->req.hostsvcid, len + 1); 369 } 370 371 if (ctx->req.prchk_reftag) { 372 prchk_flags |= SPDK_NVME_IO_FLAGS_PRCHK_REFTAG; 373 } 374 375 if (ctx->req.prchk_guard) { 376 prchk_flags |= SPDK_NVME_IO_FLAGS_PRCHK_GUARD; 377 } 378 379 ctx->request = request; 380 ctx->count = NVME_MAX_BDEVS_PER_RPC; 381 rc = bdev_nvme_create(&trid, &hostid, ctx->req.name, ctx->names, ctx->count, ctx->req.hostnqn, 382 prchk_flags, rpc_bdev_nvme_attach_controller_done, ctx); 383 if (rc) { 384 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 385 goto cleanup; 386 } 387 388 return; 389 390 conflicting_arguments: 391 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, 392 "Invalid agrgument list. Existing controller name cannot be combined with host information or PI options.\n"); 393 cleanup: 394 free_rpc_bdev_nvme_attach_controller(&ctx->req); 395 free(ctx); 396 } 397 SPDK_RPC_REGISTER("bdev_nvme_attach_controller", rpc_bdev_nvme_attach_controller, 398 SPDK_RPC_RUNTIME) 399 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_attach_controller, construct_nvme_bdev) 400 401 static void 402 rpc_dump_nvme_controller_info(struct spdk_json_write_ctx *w, 403 struct nvme_bdev_ctrlr *nvme_bdev_ctrlr) 404 { 405 struct spdk_nvme_transport_id *trid; 406 407 trid = nvme_bdev_ctrlr->connected_trid; 408 409 spdk_json_write_object_begin(w); 410 spdk_json_write_named_string(w, "name", nvme_bdev_ctrlr->name); 411 412 #ifdef SPDK_CONFIG_NVME_CUSE 413 size_t cuse_name_size = 128; 414 char cuse_name[cuse_name_size]; 415 416 int rc = spdk_nvme_cuse_get_ctrlr_name(nvme_bdev_ctrlr->ctrlr, cuse_name, &cuse_name_size); 417 if (rc == 0) { 418 spdk_json_write_named_string(w, "cuse_device", cuse_name); 419 } 420 #endif 421 422 spdk_json_write_named_object_begin(w, "trid"); 423 nvme_bdev_dump_trid_json(trid, w); 424 spdk_json_write_object_end(w); 425 426 spdk_json_write_object_end(w); 427 } 428 429 struct rpc_bdev_nvme_get_controllers { 430 char *name; 431 }; 432 433 static void 434 free_rpc_bdev_nvme_get_controllers(struct rpc_bdev_nvme_get_controllers *r) 435 { 436 free(r->name); 437 } 438 439 static const struct spdk_json_object_decoder rpc_bdev_nvme_get_controllers_decoders[] = { 440 {"name", offsetof(struct rpc_bdev_nvme_get_controllers, name), spdk_json_decode_string, true}, 441 }; 442 443 static void 444 rpc_bdev_nvme_get_controllers(struct spdk_jsonrpc_request *request, 445 const struct spdk_json_val *params) 446 { 447 struct rpc_bdev_nvme_get_controllers req = {}; 448 struct spdk_json_write_ctx *w; 449 struct nvme_bdev_ctrlr *ctrlr = NULL; 450 451 if (params && spdk_json_decode_object(params, rpc_bdev_nvme_get_controllers_decoders, 452 SPDK_COUNTOF(rpc_bdev_nvme_get_controllers_decoders), 453 &req)) { 454 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 455 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 456 "spdk_json_decode_object failed"); 457 goto cleanup; 458 } 459 460 if (req.name) { 461 ctrlr = nvme_bdev_ctrlr_get_by_name(req.name); 462 if (ctrlr == NULL) { 463 SPDK_ERRLOG("ctrlr '%s' does not exist\n", req.name); 464 spdk_jsonrpc_send_error_response_fmt(request, EINVAL, "Controller %s does not exist", req.name); 465 goto cleanup; 466 } 467 } 468 469 w = spdk_jsonrpc_begin_result(request); 470 spdk_json_write_array_begin(w); 471 472 if (ctrlr != NULL) { 473 rpc_dump_nvme_controller_info(w, ctrlr); 474 } else { 475 for (ctrlr = nvme_bdev_first_ctrlr(); ctrlr; ctrlr = nvme_bdev_next_ctrlr(ctrlr)) { 476 rpc_dump_nvme_controller_info(w, ctrlr); 477 } 478 } 479 480 spdk_json_write_array_end(w); 481 482 spdk_jsonrpc_end_result(request, w); 483 484 cleanup: 485 free_rpc_bdev_nvme_get_controllers(&req); 486 } 487 SPDK_RPC_REGISTER("bdev_nvme_get_controllers", rpc_bdev_nvme_get_controllers, SPDK_RPC_RUNTIME) 488 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_get_controllers, get_nvme_controllers) 489 490 struct rpc_bdev_nvme_detach_controller { 491 char *name; 492 char *trtype; 493 char *adrfam; 494 char *traddr; 495 char *trsvcid; 496 char *subnqn; 497 }; 498 499 static void 500 free_rpc_bdev_nvme_detach_controller(struct rpc_bdev_nvme_detach_controller *req) 501 { 502 free(req->name); 503 free(req->trtype); 504 free(req->adrfam); 505 free(req->traddr); 506 free(req->trsvcid); 507 free(req->subnqn); 508 } 509 510 static const struct spdk_json_object_decoder rpc_bdev_nvme_detach_controller_decoders[] = { 511 {"name", offsetof(struct rpc_bdev_nvme_detach_controller, name), spdk_json_decode_string}, 512 {"trtype", offsetof(struct rpc_bdev_nvme_detach_controller, trtype), spdk_json_decode_string, true}, 513 {"traddr", offsetof(struct rpc_bdev_nvme_detach_controller, traddr), spdk_json_decode_string, true}, 514 {"adrfam", offsetof(struct rpc_bdev_nvme_detach_controller, adrfam), spdk_json_decode_string, true}, 515 {"trsvcid", offsetof(struct rpc_bdev_nvme_detach_controller, trsvcid), spdk_json_decode_string, true}, 516 {"subnqn", offsetof(struct rpc_bdev_nvme_detach_controller, subnqn), spdk_json_decode_string, true}, 517 }; 518 519 static void 520 rpc_bdev_nvme_detach_controller(struct spdk_jsonrpc_request *request, 521 const struct spdk_json_val *params) 522 { 523 struct rpc_bdev_nvme_detach_controller req = {NULL}; 524 struct spdk_nvme_transport_id trid = {}; 525 struct spdk_json_write_ctx *w; 526 size_t len, maxlen; 527 int rc = 0; 528 bool all_trid_entries, one_trid_entry; 529 530 if (spdk_json_decode_object(params, rpc_bdev_nvme_detach_controller_decoders, 531 SPDK_COUNTOF(rpc_bdev_nvme_detach_controller_decoders), 532 &req)) { 533 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 534 "spdk_json_decode_object failed"); 535 goto cleanup; 536 } 537 538 all_trid_entries = req.trtype && req.traddr && req.adrfam && req.trsvcid && req.subnqn; 539 one_trid_entry = req.trtype || req.traddr || req.adrfam || req.trsvcid || req.subnqn; 540 541 if (all_trid_entries ^ one_trid_entry) { 542 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 543 "trtype, traddr, adrfam, trsvcid, subnqn must all be provided together or not at all."); 544 goto cleanup; 545 } 546 547 if (all_trid_entries) { 548 /* Parse trtype */ 549 rc = spdk_nvme_transport_id_parse_trtype(&trid.trtype, req.trtype); 550 if (rc < 0) { 551 SPDK_ERRLOG("Failed to parse trtype: %s\n", req.trtype); 552 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "Failed to parse trtype: %s", 553 req.trtype); 554 goto cleanup; 555 } 556 557 /* Parse traddr */ 558 maxlen = sizeof(trid.traddr); 559 len = strnlen(req.traddr, maxlen); 560 if (len == maxlen) { 561 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "traddr too long: %s", 562 req.traddr); 563 goto cleanup; 564 } 565 memcpy(trid.traddr, req.traddr, len + 1); 566 567 rc = spdk_nvme_transport_id_parse_adrfam(&trid.adrfam, req.adrfam); 568 if (rc < 0) { 569 SPDK_ERRLOG("Failed to parse adrfam: %s\n", req.adrfam); 570 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "Failed to parse adrfam: %s", 571 req.adrfam); 572 goto cleanup; 573 } 574 575 maxlen = sizeof(trid.trsvcid); 576 len = strnlen(req.trsvcid, maxlen); 577 if (len == maxlen) { 578 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "trsvcid too long: %s", 579 req.trsvcid); 580 goto cleanup; 581 } 582 memcpy(trid.trsvcid, req.trsvcid, len + 1); 583 584 maxlen = sizeof(trid.subnqn); 585 len = strnlen(req.subnqn, maxlen); 586 if (len == maxlen) { 587 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "subnqn too long: %s", 588 req.subnqn); 589 goto cleanup; 590 } 591 memcpy(trid.subnqn, req.subnqn, len + 1); 592 rc = bdev_nvme_remove_trid(req.name, &trid); 593 } else { 594 rc = bdev_nvme_delete(req.name); 595 } 596 597 if (rc != 0) { 598 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 599 goto cleanup; 600 } 601 602 w = spdk_jsonrpc_begin_result(request); 603 spdk_json_write_bool(w, true); 604 spdk_jsonrpc_end_result(request, w); 605 606 cleanup: 607 free_rpc_bdev_nvme_detach_controller(&req); 608 } 609 SPDK_RPC_REGISTER("bdev_nvme_detach_controller", rpc_bdev_nvme_detach_controller, 610 SPDK_RPC_RUNTIME) 611 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_detach_controller, delete_nvme_controller) 612 613 struct rpc_apply_firmware { 614 char *filename; 615 char *bdev_name; 616 }; 617 618 static void 619 free_rpc_apply_firmware(struct rpc_apply_firmware *req) 620 { 621 free(req->filename); 622 free(req->bdev_name); 623 } 624 625 static const struct spdk_json_object_decoder rpc_apply_firmware_decoders[] = { 626 {"filename", offsetof(struct rpc_apply_firmware, filename), spdk_json_decode_string}, 627 {"bdev_name", offsetof(struct rpc_apply_firmware, bdev_name), spdk_json_decode_string}, 628 }; 629 630 struct firmware_update_info { 631 void *fw_image; 632 void *p; 633 unsigned int size; 634 unsigned int size_remaining; 635 unsigned int offset; 636 unsigned int transfer; 637 638 void *desc; 639 struct spdk_io_channel *ch; 640 struct spdk_jsonrpc_request *request; 641 struct spdk_nvme_ctrlr *ctrlr; 642 open_descriptors_t desc_head; 643 struct rpc_apply_firmware *req; 644 }; 645 646 static void 647 _apply_firmware_cleanup(void *ctx) 648 { 649 struct spdk_bdev_desc *desc = ctx; 650 651 spdk_bdev_close(desc); 652 } 653 654 static void 655 apply_firmware_cleanup(void *cb_arg) 656 { 657 struct open_descriptors *opt, *tmp; 658 struct firmware_update_info *firm_ctx = cb_arg; 659 660 if (!firm_ctx) { 661 return; 662 } 663 664 if (firm_ctx->fw_image) { 665 spdk_free(firm_ctx->fw_image); 666 } 667 668 if (firm_ctx->req) { 669 free_rpc_apply_firmware(firm_ctx->req); 670 free(firm_ctx->req); 671 } 672 673 if (firm_ctx->ch) { 674 spdk_put_io_channel(firm_ctx->ch); 675 } 676 677 TAILQ_FOREACH_SAFE(opt, &firm_ctx->desc_head, tqlst, tmp) { 678 TAILQ_REMOVE(&firm_ctx->desc_head, opt, tqlst); 679 /* Close the underlying bdev on its same opened thread. */ 680 if (opt->thread && opt->thread != spdk_get_thread()) { 681 spdk_thread_send_msg(opt->thread, _apply_firmware_cleanup, opt->desc); 682 } else { 683 spdk_bdev_close(opt->desc); 684 } 685 free(opt); 686 } 687 free(firm_ctx); 688 } 689 690 static void 691 apply_firmware_complete_reset(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 692 { 693 int rc; 694 struct spdk_json_write_ctx *w; 695 struct firmware_update_info *firm_ctx = cb_arg; 696 697 spdk_bdev_free_io(bdev_io); 698 699 if (!success) { 700 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 701 "firmware commit failed."); 702 apply_firmware_cleanup(firm_ctx); 703 return; 704 } 705 706 if ((rc = spdk_nvme_ctrlr_reset(firm_ctx->ctrlr)) != 0) { 707 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 708 "Controller reset failed."); 709 apply_firmware_cleanup(firm_ctx); 710 return; 711 } 712 713 w = spdk_jsonrpc_begin_result(firm_ctx->request); 714 spdk_json_write_string(w, "firmware commit succeeded. Controller reset in progress."); 715 spdk_jsonrpc_end_result(firm_ctx->request, w); 716 apply_firmware_cleanup(firm_ctx); 717 } 718 719 static void 720 apply_firmware_complete(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 721 { 722 struct spdk_nvme_cmd cmd = {}; 723 struct spdk_nvme_fw_commit fw_commit; 724 int slot = 0; 725 int rc; 726 struct firmware_update_info *firm_ctx = cb_arg; 727 enum spdk_nvme_fw_commit_action commit_action = SPDK_NVME_FW_COMMIT_REPLACE_AND_ENABLE_IMG; 728 729 if (!success) { 730 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 731 "firmware download failed ."); 732 spdk_bdev_free_io(bdev_io); 733 apply_firmware_cleanup(firm_ctx); 734 return; 735 } 736 737 firm_ctx->p += firm_ctx->transfer; 738 firm_ctx->offset += firm_ctx->transfer; 739 firm_ctx->size_remaining -= firm_ctx->transfer; 740 741 switch (firm_ctx->size_remaining) { 742 case 0: 743 /* firmware download completed. Commit firmware */ 744 memset(&fw_commit, 0, sizeof(struct spdk_nvme_fw_commit)); 745 fw_commit.fs = slot; 746 fw_commit.ca = commit_action; 747 748 cmd.opc = SPDK_NVME_OPC_FIRMWARE_COMMIT; 749 memcpy(&cmd.cdw10, &fw_commit, sizeof(uint32_t)); 750 rc = spdk_bdev_nvme_admin_passthru(firm_ctx->desc, firm_ctx->ch, &cmd, NULL, 0, 751 apply_firmware_complete_reset, firm_ctx); 752 if (rc) { 753 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 754 "firmware commit failed."); 755 spdk_bdev_free_io(bdev_io); 756 apply_firmware_cleanup(firm_ctx); 757 return; 758 } 759 break; 760 default: 761 firm_ctx->transfer = spdk_min(firm_ctx->size_remaining, 4096); 762 cmd.opc = SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD; 763 764 cmd.cdw10 = (firm_ctx->transfer >> 2) - 1; 765 cmd.cdw11 = firm_ctx->offset >> 2; 766 rc = spdk_bdev_nvme_admin_passthru(firm_ctx->desc, firm_ctx->ch, &cmd, firm_ctx->p, 767 firm_ctx->transfer, apply_firmware_complete, firm_ctx); 768 if (rc) { 769 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 770 "firmware download failed."); 771 spdk_bdev_free_io(bdev_io); 772 apply_firmware_cleanup(firm_ctx); 773 return; 774 } 775 break; 776 } 777 } 778 779 static void 780 rpc_bdev_nvme_apply_firmware(struct spdk_jsonrpc_request *request, 781 const struct spdk_json_val *params) 782 { 783 int rc; 784 int fd = -1; 785 struct stat fw_stat; 786 struct spdk_nvme_ctrlr *ctrlr; 787 char msg[1024]; 788 struct spdk_bdev *bdev; 789 struct spdk_bdev *bdev2; 790 struct open_descriptors *opt; 791 struct spdk_bdev_desc *desc; 792 struct spdk_nvme_cmd *cmd; 793 struct firmware_update_info *firm_ctx; 794 795 firm_ctx = calloc(1, sizeof(struct firmware_update_info)); 796 if (!firm_ctx) { 797 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 798 "Memory allocation error."); 799 return; 800 } 801 firm_ctx->fw_image = NULL; 802 TAILQ_INIT(&firm_ctx->desc_head); 803 firm_ctx->request = request; 804 805 firm_ctx->req = calloc(1, sizeof(struct rpc_apply_firmware)); 806 if (!firm_ctx->req) { 807 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 808 "Memory allocation error."); 809 free(firm_ctx); 810 return; 811 } 812 813 if (spdk_json_decode_object(params, rpc_apply_firmware_decoders, 814 SPDK_COUNTOF(rpc_apply_firmware_decoders), firm_ctx->req)) { 815 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 816 "spdk_json_decode_object failed."); 817 free(firm_ctx->req); 818 free(firm_ctx); 819 return; 820 } 821 822 if ((bdev = spdk_bdev_get_by_name(firm_ctx->req->bdev_name)) == NULL) { 823 snprintf(msg, sizeof(msg), "bdev %s were not found", firm_ctx->req->bdev_name); 824 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 825 apply_firmware_cleanup(firm_ctx); 826 return; 827 } 828 829 if ((ctrlr = bdev_nvme_get_ctrlr(bdev)) == NULL) { 830 snprintf(msg, sizeof(msg), "Controller information for %s were not found.", 831 firm_ctx->req->bdev_name); 832 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 833 apply_firmware_cleanup(firm_ctx); 834 return; 835 } 836 firm_ctx->ctrlr = ctrlr; 837 838 for (bdev2 = spdk_bdev_first(); bdev2; bdev2 = spdk_bdev_next(bdev2)) { 839 840 if (bdev_nvme_get_ctrlr(bdev2) != ctrlr) { 841 continue; 842 } 843 844 if (!(opt = malloc(sizeof(struct open_descriptors)))) { 845 snprintf(msg, sizeof(msg), "Memory allocation error."); 846 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 847 apply_firmware_cleanup(firm_ctx); 848 return; 849 } 850 851 if ((rc = spdk_bdev_open(bdev2, true, NULL, NULL, &desc)) != 0) { 852 snprintf(msg, sizeof(msg), "Device %s is in use.", firm_ctx->req->bdev_name); 853 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 854 free(opt); 855 apply_firmware_cleanup(firm_ctx); 856 return; 857 } 858 859 /* Save the thread where the base device is opened */ 860 opt->thread = spdk_get_thread(); 861 862 opt->desc = desc; 863 opt->bdev = bdev; 864 TAILQ_INSERT_TAIL(&firm_ctx->desc_head, opt, tqlst); 865 } 866 867 /* 868 * find a descriptor associated with our bdev 869 */ 870 firm_ctx->desc = NULL; 871 TAILQ_FOREACH(opt, &firm_ctx->desc_head, tqlst) { 872 if (opt->bdev == bdev) { 873 firm_ctx->desc = opt->desc; 874 break; 875 } 876 } 877 878 if (!firm_ctx->desc) { 879 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 880 "No descriptor were found."); 881 apply_firmware_cleanup(firm_ctx); 882 return; 883 } 884 885 firm_ctx->ch = spdk_bdev_get_io_channel(firm_ctx->desc); 886 if (!firm_ctx->ch) { 887 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 888 "No channels were found."); 889 apply_firmware_cleanup(firm_ctx); 890 return; 891 } 892 893 fd = open(firm_ctx->req->filename, O_RDONLY); 894 if (fd < 0) { 895 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "open file failed."); 896 apply_firmware_cleanup(firm_ctx); 897 return; 898 } 899 900 rc = fstat(fd, &fw_stat); 901 if (rc < 0) { 902 close(fd); 903 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "fstat failed."); 904 apply_firmware_cleanup(firm_ctx); 905 return; 906 } 907 908 firm_ctx->size = fw_stat.st_size; 909 if (fw_stat.st_size % 4) { 910 close(fd); 911 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 912 "Firmware image size is not multiple of 4."); 913 apply_firmware_cleanup(firm_ctx); 914 return; 915 } 916 917 firm_ctx->fw_image = spdk_zmalloc(firm_ctx->size, 4096, NULL, 918 SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); 919 if (!firm_ctx->fw_image) { 920 close(fd); 921 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 922 "Memory allocation error."); 923 apply_firmware_cleanup(firm_ctx); 924 return; 925 } 926 firm_ctx->p = firm_ctx->fw_image; 927 928 if (read(fd, firm_ctx->p, firm_ctx->size) != ((ssize_t)(firm_ctx->size))) { 929 close(fd); 930 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 931 "Read firmware image failed!"); 932 apply_firmware_cleanup(firm_ctx); 933 return; 934 } 935 close(fd); 936 937 firm_ctx->offset = 0; 938 firm_ctx->size_remaining = firm_ctx->size; 939 firm_ctx->transfer = spdk_min(firm_ctx->size_remaining, 4096); 940 941 cmd = malloc(sizeof(struct spdk_nvme_cmd)); 942 if (!cmd) { 943 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 944 "Memory allocation error."); 945 apply_firmware_cleanup(firm_ctx); 946 return; 947 } 948 memset(cmd, 0, sizeof(struct spdk_nvme_cmd)); 949 cmd->opc = SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD; 950 951 cmd->cdw10 = (firm_ctx->transfer >> 2) - 1; 952 cmd->cdw11 = firm_ctx->offset >> 2; 953 954 rc = spdk_bdev_nvme_admin_passthru(firm_ctx->desc, firm_ctx->ch, cmd, firm_ctx->p, 955 firm_ctx->transfer, apply_firmware_complete, firm_ctx); 956 if (rc) { 957 free(cmd); 958 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 959 "Read firmware image failed!"); 960 apply_firmware_cleanup(firm_ctx); 961 return; 962 } 963 } 964 SPDK_RPC_REGISTER("bdev_nvme_apply_firmware", rpc_bdev_nvme_apply_firmware, SPDK_RPC_RUNTIME) 965 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_apply_firmware, apply_nvme_firmware) 966