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 int rc; 262 263 ctx = calloc(1, sizeof(*ctx)); 264 if (!ctx) { 265 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 266 return; 267 } 268 269 if (spdk_json_decode_object(params, rpc_bdev_nvme_attach_controller_decoders, 270 SPDK_COUNTOF(rpc_bdev_nvme_attach_controller_decoders), 271 &ctx->req)) { 272 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 273 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 274 "spdk_json_decode_object failed"); 275 goto cleanup; 276 } 277 278 /* Parse trstring */ 279 rc = spdk_nvme_transport_id_populate_trstring(&trid, ctx->req.trtype); 280 if (rc < 0) { 281 SPDK_ERRLOG("Failed to parse trtype: %s\n", ctx->req.trtype); 282 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "Failed to parse trtype: %s", 283 ctx->req.trtype); 284 goto cleanup; 285 } 286 287 /* Parse trtype */ 288 rc = spdk_nvme_transport_id_parse_trtype(&trid.trtype, ctx->req.trtype); 289 assert(rc == 0); 290 291 ctrlr = nvme_bdev_ctrlr_get_by_name(ctx->req.name); 292 293 /* Parse traddr */ 294 snprintf(trid.traddr, sizeof(trid.traddr), "%s", ctx->req.traddr); 295 296 /* Parse adrfam */ 297 if (ctx->req.adrfam) { 298 rc = spdk_nvme_transport_id_parse_adrfam(&trid.adrfam, ctx->req.adrfam); 299 if (rc < 0) { 300 SPDK_ERRLOG("Failed to parse adrfam: %s\n", ctx->req.adrfam); 301 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, "Failed to parse adrfam: %s", 302 ctx->req.adrfam); 303 goto cleanup; 304 } 305 } 306 307 /* Parse trsvcid */ 308 if (ctx->req.trsvcid) { 309 snprintf(trid.trsvcid, sizeof(trid.trsvcid), "%s", ctx->req.trsvcid); 310 } 311 312 /* Parse priority for the NVMe-oF transport connection */ 313 if (ctx->req.priority) { 314 trid.priority = spdk_strtol(ctx->req.priority, 10); 315 } 316 317 /* Parse subnqn */ 318 if (ctx->req.subnqn) { 319 snprintf(trid.subnqn, sizeof(trid.subnqn), "%s", ctx->req.subnqn); 320 } 321 322 if (ctrlr && (ctx->req.hostaddr || ctx->req.hostnqn || ctx->req.hostsvcid || ctx->req.prchk_guard || 323 ctx->req.prchk_reftag)) { 324 goto conflicting_arguments; 325 } 326 327 if (ctx->req.hostaddr) { 328 snprintf(hostid.hostaddr, sizeof(hostid.hostaddr), "%s", ctx->req.hostaddr); 329 } 330 331 if (ctx->req.hostsvcid) { 332 snprintf(hostid.hostsvcid, sizeof(hostid.hostsvcid), "%s", ctx->req.hostsvcid); 333 } 334 335 if (ctx->req.prchk_reftag) { 336 prchk_flags |= SPDK_NVME_IO_FLAGS_PRCHK_REFTAG; 337 } 338 339 if (ctx->req.prchk_guard) { 340 prchk_flags |= SPDK_NVME_IO_FLAGS_PRCHK_GUARD; 341 } 342 343 ctx->request = request; 344 ctx->count = NVME_MAX_BDEVS_PER_RPC; 345 rc = bdev_nvme_create(&trid, &hostid, ctx->req.name, ctx->names, ctx->count, ctx->req.hostnqn, 346 prchk_flags, rpc_bdev_nvme_attach_controller_done, ctx); 347 if (rc) { 348 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 349 goto cleanup; 350 } 351 352 return; 353 354 conflicting_arguments: 355 spdk_jsonrpc_send_error_response_fmt(request, -EINVAL, 356 "Invalid agrgument list. Existing controller name cannot be combined with host information or PI options.\n"); 357 cleanup: 358 free_rpc_bdev_nvme_attach_controller(&ctx->req); 359 free(ctx); 360 } 361 SPDK_RPC_REGISTER("bdev_nvme_attach_controller", rpc_bdev_nvme_attach_controller, 362 SPDK_RPC_RUNTIME) 363 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_attach_controller, construct_nvme_bdev) 364 365 static void 366 rpc_dump_nvme_controller_info(struct spdk_json_write_ctx *w, 367 struct nvme_bdev_ctrlr *nvme_bdev_ctrlr) 368 { 369 struct spdk_nvme_transport_id *trid; 370 371 trid = nvme_bdev_ctrlr->connected_trid; 372 373 spdk_json_write_object_begin(w); 374 spdk_json_write_named_string(w, "name", nvme_bdev_ctrlr->name); 375 376 #ifdef SPDK_CONFIG_NVME_CUSE 377 size_t cuse_name_size = 128; 378 char cuse_name[cuse_name_size]; 379 380 int rc = spdk_nvme_cuse_get_ctrlr_name(nvme_bdev_ctrlr->ctrlr, cuse_name, &cuse_name_size); 381 if (rc == 0) { 382 spdk_json_write_named_string(w, "cuse_device", cuse_name); 383 } 384 #endif 385 386 spdk_json_write_named_object_begin(w, "trid"); 387 nvme_bdev_dump_trid_json(trid, w); 388 spdk_json_write_object_end(w); 389 390 spdk_json_write_object_end(w); 391 } 392 393 struct rpc_bdev_nvme_get_controllers { 394 char *name; 395 }; 396 397 static void 398 free_rpc_bdev_nvme_get_controllers(struct rpc_bdev_nvme_get_controllers *r) 399 { 400 free(r->name); 401 } 402 403 static const struct spdk_json_object_decoder rpc_bdev_nvme_get_controllers_decoders[] = { 404 {"name", offsetof(struct rpc_bdev_nvme_get_controllers, name), spdk_json_decode_string, true}, 405 }; 406 407 static void 408 rpc_bdev_nvme_get_controllers(struct spdk_jsonrpc_request *request, 409 const struct spdk_json_val *params) 410 { 411 struct rpc_bdev_nvme_get_controllers req = {}; 412 struct spdk_json_write_ctx *w; 413 struct nvme_bdev_ctrlr *ctrlr = NULL; 414 415 if (params && spdk_json_decode_object(params, rpc_bdev_nvme_get_controllers_decoders, 416 SPDK_COUNTOF(rpc_bdev_nvme_get_controllers_decoders), 417 &req)) { 418 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 419 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 420 "spdk_json_decode_object failed"); 421 goto cleanup; 422 } 423 424 if (req.name) { 425 ctrlr = nvme_bdev_ctrlr_get_by_name(req.name); 426 if (ctrlr == NULL) { 427 SPDK_ERRLOG("ctrlr '%s' does not exist\n", req.name); 428 spdk_jsonrpc_send_error_response_fmt(request, EINVAL, "Controller %s does not exist", req.name); 429 goto cleanup; 430 } 431 } 432 433 w = spdk_jsonrpc_begin_result(request); 434 spdk_json_write_array_begin(w); 435 436 if (ctrlr != NULL) { 437 rpc_dump_nvme_controller_info(w, ctrlr); 438 } else { 439 for (ctrlr = nvme_bdev_first_ctrlr(); ctrlr; ctrlr = nvme_bdev_next_ctrlr(ctrlr)) { 440 rpc_dump_nvme_controller_info(w, ctrlr); 441 } 442 } 443 444 spdk_json_write_array_end(w); 445 446 spdk_jsonrpc_end_result(request, w); 447 448 cleanup: 449 free_rpc_bdev_nvme_get_controllers(&req); 450 } 451 SPDK_RPC_REGISTER("bdev_nvme_get_controllers", rpc_bdev_nvme_get_controllers, SPDK_RPC_RUNTIME) 452 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_get_controllers, get_nvme_controllers) 453 454 struct rpc_bdev_nvme_detach_controller { 455 char *name; 456 }; 457 458 static void 459 free_rpc_bdev_nvme_detach_controller(struct rpc_bdev_nvme_detach_controller *req) 460 { 461 free(req->name); 462 } 463 464 static const struct spdk_json_object_decoder rpc_bdev_nvme_detach_controller_decoders[] = { 465 {"name", offsetof(struct rpc_bdev_nvme_detach_controller, name), spdk_json_decode_string}, 466 }; 467 468 static void 469 rpc_bdev_nvme_detach_controller(struct spdk_jsonrpc_request *request, 470 const struct spdk_json_val *params) 471 { 472 struct rpc_bdev_nvme_detach_controller req = {NULL}; 473 struct spdk_json_write_ctx *w; 474 int rc = 0; 475 476 if (spdk_json_decode_object(params, rpc_bdev_nvme_detach_controller_decoders, 477 SPDK_COUNTOF(rpc_bdev_nvme_detach_controller_decoders), 478 &req)) { 479 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 480 "spdk_json_decode_object failed"); 481 goto cleanup; 482 } 483 484 rc = bdev_nvme_delete(req.name); 485 if (rc != 0) { 486 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 487 goto cleanup; 488 } 489 490 w = spdk_jsonrpc_begin_result(request); 491 spdk_json_write_bool(w, true); 492 spdk_jsonrpc_end_result(request, w); 493 494 cleanup: 495 free_rpc_bdev_nvme_detach_controller(&req); 496 } 497 SPDK_RPC_REGISTER("bdev_nvme_detach_controller", rpc_bdev_nvme_detach_controller, 498 SPDK_RPC_RUNTIME) 499 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_detach_controller, delete_nvme_controller) 500 501 struct rpc_apply_firmware { 502 char *filename; 503 char *bdev_name; 504 }; 505 506 static void 507 free_rpc_apply_firmware(struct rpc_apply_firmware *req) 508 { 509 free(req->filename); 510 free(req->bdev_name); 511 } 512 513 static const struct spdk_json_object_decoder rpc_apply_firmware_decoders[] = { 514 {"filename", offsetof(struct rpc_apply_firmware, filename), spdk_json_decode_string}, 515 {"bdev_name", offsetof(struct rpc_apply_firmware, bdev_name), spdk_json_decode_string}, 516 }; 517 518 struct firmware_update_info { 519 void *fw_image; 520 void *p; 521 unsigned int size; 522 unsigned int size_remaining; 523 unsigned int offset; 524 unsigned int transfer; 525 526 void *desc; 527 struct spdk_io_channel *ch; 528 struct spdk_jsonrpc_request *request; 529 struct spdk_nvme_ctrlr *ctrlr; 530 open_descriptors_t desc_head; 531 struct rpc_apply_firmware *req; 532 }; 533 534 static void 535 _apply_firmware_cleanup(void *ctx) 536 { 537 struct spdk_bdev_desc *desc = ctx; 538 539 spdk_bdev_close(desc); 540 } 541 542 static void 543 apply_firmware_cleanup(void *cb_arg) 544 { 545 struct open_descriptors *opt, *tmp; 546 struct firmware_update_info *firm_ctx = cb_arg; 547 548 if (!firm_ctx) { 549 return; 550 } 551 552 if (firm_ctx->fw_image) { 553 spdk_free(firm_ctx->fw_image); 554 } 555 556 if (firm_ctx->req) { 557 free_rpc_apply_firmware(firm_ctx->req); 558 free(firm_ctx->req); 559 } 560 561 if (firm_ctx->ch) { 562 spdk_put_io_channel(firm_ctx->ch); 563 } 564 565 TAILQ_FOREACH_SAFE(opt, &firm_ctx->desc_head, tqlst, tmp) { 566 TAILQ_REMOVE(&firm_ctx->desc_head, opt, tqlst); 567 /* Close the underlying bdev on its same opened thread. */ 568 if (opt->thread && opt->thread != spdk_get_thread()) { 569 spdk_thread_send_msg(opt->thread, _apply_firmware_cleanup, opt->desc); 570 } else { 571 spdk_bdev_close(opt->desc); 572 } 573 free(opt); 574 } 575 free(firm_ctx); 576 } 577 578 static void 579 apply_firmware_complete_reset(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 580 { 581 int rc; 582 struct spdk_json_write_ctx *w; 583 struct firmware_update_info *firm_ctx = cb_arg; 584 585 spdk_bdev_free_io(bdev_io); 586 587 if (!success) { 588 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 589 "firmware commit failed."); 590 apply_firmware_cleanup(firm_ctx); 591 return; 592 } 593 594 if ((rc = spdk_nvme_ctrlr_reset(firm_ctx->ctrlr)) != 0) { 595 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 596 "Controller reset failed."); 597 apply_firmware_cleanup(firm_ctx); 598 return; 599 } 600 601 w = spdk_jsonrpc_begin_result(firm_ctx->request); 602 spdk_json_write_string(w, "firmware commit succeeded. Controller reset in progress."); 603 spdk_jsonrpc_end_result(firm_ctx->request, w); 604 apply_firmware_cleanup(firm_ctx); 605 } 606 607 static void 608 apply_firmware_complete(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 609 { 610 struct spdk_nvme_cmd cmd = {}; 611 struct spdk_nvme_fw_commit fw_commit; 612 int slot = 0; 613 int rc; 614 struct firmware_update_info *firm_ctx = cb_arg; 615 enum spdk_nvme_fw_commit_action commit_action = SPDK_NVME_FW_COMMIT_REPLACE_AND_ENABLE_IMG; 616 617 if (!success) { 618 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 619 "firmware download failed ."); 620 spdk_bdev_free_io(bdev_io); 621 apply_firmware_cleanup(firm_ctx); 622 return; 623 } 624 625 firm_ctx->p += firm_ctx->transfer; 626 firm_ctx->offset += firm_ctx->transfer; 627 firm_ctx->size_remaining -= firm_ctx->transfer; 628 629 switch (firm_ctx->size_remaining) { 630 case 0: 631 /* firmware download completed. Commit firmware */ 632 memset(&fw_commit, 0, sizeof(struct spdk_nvme_fw_commit)); 633 fw_commit.fs = slot; 634 fw_commit.ca = commit_action; 635 636 cmd.opc = SPDK_NVME_OPC_FIRMWARE_COMMIT; 637 memcpy(&cmd.cdw10, &fw_commit, sizeof(uint32_t)); 638 rc = spdk_bdev_nvme_admin_passthru(firm_ctx->desc, firm_ctx->ch, &cmd, NULL, 0, 639 apply_firmware_complete_reset, firm_ctx); 640 if (rc) { 641 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 642 "firmware commit failed."); 643 spdk_bdev_free_io(bdev_io); 644 apply_firmware_cleanup(firm_ctx); 645 return; 646 } 647 break; 648 default: 649 firm_ctx->transfer = spdk_min(firm_ctx->size_remaining, 4096); 650 cmd.opc = SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD; 651 652 cmd.cdw10 = (firm_ctx->transfer >> 2) - 1; 653 cmd.cdw11 = firm_ctx->offset >> 2; 654 rc = spdk_bdev_nvme_admin_passthru(firm_ctx->desc, firm_ctx->ch, &cmd, firm_ctx->p, 655 firm_ctx->transfer, apply_firmware_complete, firm_ctx); 656 if (rc) { 657 spdk_jsonrpc_send_error_response(firm_ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 658 "firmware download failed."); 659 spdk_bdev_free_io(bdev_io); 660 apply_firmware_cleanup(firm_ctx); 661 return; 662 } 663 break; 664 } 665 } 666 667 static void 668 rpc_bdev_nvme_apply_firmware(struct spdk_jsonrpc_request *request, 669 const struct spdk_json_val *params) 670 { 671 int rc; 672 int fd = -1; 673 struct stat fw_stat; 674 struct spdk_nvme_ctrlr *ctrlr; 675 char msg[1024]; 676 struct spdk_bdev *bdev; 677 struct spdk_bdev *bdev2; 678 struct open_descriptors *opt; 679 struct spdk_bdev_desc *desc; 680 struct spdk_nvme_cmd *cmd; 681 struct firmware_update_info *firm_ctx; 682 683 firm_ctx = calloc(1, sizeof(struct firmware_update_info)); 684 if (!firm_ctx) { 685 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 686 "Memory allocation error."); 687 return; 688 } 689 firm_ctx->fw_image = NULL; 690 TAILQ_INIT(&firm_ctx->desc_head); 691 firm_ctx->request = request; 692 693 firm_ctx->req = calloc(1, sizeof(struct rpc_apply_firmware)); 694 if (!firm_ctx->req) { 695 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 696 "Memory allocation error."); 697 free(firm_ctx); 698 return; 699 } 700 701 if (spdk_json_decode_object(params, rpc_apply_firmware_decoders, 702 SPDK_COUNTOF(rpc_apply_firmware_decoders), firm_ctx->req)) { 703 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 704 "spdk_json_decode_object failed."); 705 free(firm_ctx->req); 706 free(firm_ctx); 707 return; 708 } 709 710 if ((bdev = spdk_bdev_get_by_name(firm_ctx->req->bdev_name)) == NULL) { 711 snprintf(msg, sizeof(msg), "bdev %s were not found", firm_ctx->req->bdev_name); 712 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 713 apply_firmware_cleanup(firm_ctx); 714 return; 715 } 716 717 if ((ctrlr = bdev_nvme_get_ctrlr(bdev)) == NULL) { 718 snprintf(msg, sizeof(msg), "Controller information for %s were not found.", 719 firm_ctx->req->bdev_name); 720 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 721 apply_firmware_cleanup(firm_ctx); 722 return; 723 } 724 firm_ctx->ctrlr = ctrlr; 725 726 for (bdev2 = spdk_bdev_first(); bdev2; bdev2 = spdk_bdev_next(bdev2)) { 727 728 if (bdev_nvme_get_ctrlr(bdev2) != ctrlr) { 729 continue; 730 } 731 732 if (!(opt = malloc(sizeof(struct open_descriptors)))) { 733 snprintf(msg, sizeof(msg), "Memory allocation error."); 734 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 735 apply_firmware_cleanup(firm_ctx); 736 return; 737 } 738 739 if ((rc = spdk_bdev_open(bdev2, true, NULL, NULL, &desc)) != 0) { 740 snprintf(msg, sizeof(msg), "Device %s is in use.", firm_ctx->req->bdev_name); 741 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, msg); 742 free(opt); 743 apply_firmware_cleanup(firm_ctx); 744 return; 745 } 746 747 /* Save the thread where the base device is opened */ 748 opt->thread = spdk_get_thread(); 749 750 opt->desc = desc; 751 opt->bdev = bdev; 752 TAILQ_INSERT_TAIL(&firm_ctx->desc_head, opt, tqlst); 753 } 754 755 /* 756 * find a descriptor associated with our bdev 757 */ 758 firm_ctx->desc = NULL; 759 TAILQ_FOREACH(opt, &firm_ctx->desc_head, tqlst) { 760 if (opt->bdev == bdev) { 761 firm_ctx->desc = opt->desc; 762 break; 763 } 764 } 765 766 if (!firm_ctx->desc) { 767 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 768 "No descriptor were found."); 769 apply_firmware_cleanup(firm_ctx); 770 return; 771 } 772 773 firm_ctx->ch = spdk_bdev_get_io_channel(firm_ctx->desc); 774 if (!firm_ctx->ch) { 775 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 776 "No channels were found."); 777 apply_firmware_cleanup(firm_ctx); 778 return; 779 } 780 781 fd = open(firm_ctx->req->filename, O_RDONLY); 782 if (fd < 0) { 783 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "open file failed."); 784 apply_firmware_cleanup(firm_ctx); 785 return; 786 } 787 788 rc = fstat(fd, &fw_stat); 789 if (rc < 0) { 790 close(fd); 791 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "fstat failed."); 792 apply_firmware_cleanup(firm_ctx); 793 return; 794 } 795 796 firm_ctx->size = fw_stat.st_size; 797 if (fw_stat.st_size % 4) { 798 close(fd); 799 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 800 "Firmware image size is not multiple of 4."); 801 apply_firmware_cleanup(firm_ctx); 802 return; 803 } 804 805 firm_ctx->fw_image = spdk_zmalloc(firm_ctx->size, 4096, NULL, 806 SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); 807 if (!firm_ctx->fw_image) { 808 close(fd); 809 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 810 "Memory allocation error."); 811 apply_firmware_cleanup(firm_ctx); 812 return; 813 } 814 firm_ctx->p = firm_ctx->fw_image; 815 816 if (read(fd, firm_ctx->p, firm_ctx->size) != ((ssize_t)(firm_ctx->size))) { 817 close(fd); 818 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 819 "Read firmware image failed!"); 820 apply_firmware_cleanup(firm_ctx); 821 return; 822 } 823 close(fd); 824 825 firm_ctx->offset = 0; 826 firm_ctx->size_remaining = firm_ctx->size; 827 firm_ctx->transfer = spdk_min(firm_ctx->size_remaining, 4096); 828 829 cmd = malloc(sizeof(struct spdk_nvme_cmd)); 830 if (!cmd) { 831 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 832 "Memory allocation error."); 833 apply_firmware_cleanup(firm_ctx); 834 return; 835 } 836 memset(cmd, 0, sizeof(struct spdk_nvme_cmd)); 837 cmd->opc = SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD; 838 839 cmd->cdw10 = (firm_ctx->transfer >> 2) - 1; 840 cmd->cdw11 = firm_ctx->offset >> 2; 841 842 rc = spdk_bdev_nvme_admin_passthru(firm_ctx->desc, firm_ctx->ch, cmd, firm_ctx->p, 843 firm_ctx->transfer, apply_firmware_complete, firm_ctx); 844 if (rc) { 845 free(cmd); 846 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 847 "Read firmware image failed!"); 848 apply_firmware_cleanup(firm_ctx); 849 return; 850 } 851 } 852 SPDK_RPC_REGISTER("bdev_nvme_apply_firmware", rpc_bdev_nvme_apply_firmware, SPDK_RPC_RUNTIME) 853 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_apply_firmware, apply_nvme_firmware) 854