1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2018 Intel Corporation. 3 * All rights reserved. 4 * Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk/bdev.h" 8 9 #include "spdk/env.h" 10 #include "spdk/rpc.h" 11 #include "spdk/util.h" 12 #include "spdk/string.h" 13 #include "spdk/base64.h" 14 #include "spdk/bdev_module.h" 15 #include "spdk/dma.h" 16 17 #include "spdk/log.h" 18 19 #include "bdev_internal.h" 20 21 static void 22 dummy_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *ctx) 23 { 24 } 25 26 static const struct spdk_json_object_decoder rpc_set_bdev_opts_decoders[] = { 27 {"bdev_io_pool_size", offsetof(struct spdk_bdev_opts, bdev_io_pool_size), spdk_json_decode_uint32, true}, 28 {"bdev_io_cache_size", offsetof(struct spdk_bdev_opts, bdev_io_cache_size), spdk_json_decode_uint32, true}, 29 {"bdev_auto_examine", offsetof(struct spdk_bdev_opts, bdev_auto_examine), spdk_json_decode_bool, true}, 30 {"iobuf_small_cache_size", offsetof(struct spdk_bdev_opts, iobuf_small_cache_size), spdk_json_decode_uint32, true}, 31 {"iobuf_large_cache_size", offsetof(struct spdk_bdev_opts, iobuf_large_cache_size), spdk_json_decode_uint32, true}, 32 }; 33 34 static void 35 rpc_bdev_set_options(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params) 36 { 37 struct spdk_bdev_opts opts; 38 int rc; 39 40 spdk_bdev_get_opts(&opts, sizeof(opts)); 41 if (params != NULL) { 42 if (spdk_json_decode_object(params, rpc_set_bdev_opts_decoders, 43 SPDK_COUNTOF(rpc_set_bdev_opts_decoders), &opts)) { 44 SPDK_ERRLOG("spdk_json_decode_object() failed\n"); 45 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 46 "Invalid parameters"); 47 return; 48 } 49 } 50 51 rc = spdk_bdev_set_opts(&opts); 52 if (rc != 0) { 53 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 54 "Pool size %" PRIu32 " too small for cache size %" PRIu32, 55 opts.bdev_io_pool_size, opts.bdev_io_cache_size); 56 return; 57 } 58 59 spdk_jsonrpc_send_bool_response(request, true); 60 } 61 SPDK_RPC_REGISTER("bdev_set_options", rpc_bdev_set_options, SPDK_RPC_STARTUP) 62 63 static void 64 rpc_bdev_wait_for_examine_cpl(void *arg) 65 { 66 struct spdk_jsonrpc_request *request = arg; 67 68 spdk_jsonrpc_send_bool_response(request, true); 69 } 70 71 static void 72 rpc_bdev_wait_for_examine(struct spdk_jsonrpc_request *request, 73 const struct spdk_json_val *params) 74 { 75 int rc; 76 77 if (params != NULL) { 78 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 79 "bdev_wait_for_examine requires no parameters"); 80 return; 81 } 82 83 rc = spdk_bdev_wait_for_examine(rpc_bdev_wait_for_examine_cpl, request); 84 if (rc != 0) { 85 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 86 } 87 } 88 SPDK_RPC_REGISTER("bdev_wait_for_examine", rpc_bdev_wait_for_examine, SPDK_RPC_RUNTIME) 89 90 struct rpc_bdev_examine { 91 char *name; 92 }; 93 94 static void 95 free_rpc_bdev_examine(struct rpc_bdev_examine *r) 96 { 97 free(r->name); 98 } 99 100 static const struct spdk_json_object_decoder rpc_examine_bdev_decoders[] = { 101 {"name", offsetof(struct rpc_bdev_examine, name), spdk_json_decode_string}, 102 }; 103 104 static void 105 rpc_bdev_examine_bdev(struct spdk_jsonrpc_request *request, 106 const struct spdk_json_val *params) 107 { 108 struct rpc_bdev_examine req = {NULL}; 109 int rc; 110 111 if (spdk_json_decode_object(params, rpc_examine_bdev_decoders, 112 SPDK_COUNTOF(rpc_examine_bdev_decoders), 113 &req)) { 114 SPDK_ERRLOG("spdk_json_decode_object() failed\n"); 115 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 116 "spdk_json_decode_object failed"); 117 goto cleanup; 118 } 119 120 rc = spdk_bdev_examine(req.name); 121 if (rc != 0) { 122 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 123 goto cleanup; 124 } 125 126 spdk_jsonrpc_send_bool_response(request, true); 127 128 cleanup: 129 free_rpc_bdev_examine(&req); 130 } 131 SPDK_RPC_REGISTER("bdev_examine", rpc_bdev_examine_bdev, SPDK_RPC_RUNTIME) 132 133 struct rpc_get_iostat_ctx { 134 int bdev_count; 135 int rc; 136 struct spdk_jsonrpc_request *request; 137 struct spdk_json_write_ctx *w; 138 bool per_channel; 139 }; 140 141 struct bdev_get_iostat_ctx { 142 struct spdk_bdev_io_stat *stat; 143 struct rpc_get_iostat_ctx *rpc_ctx; 144 struct spdk_bdev_desc *desc; 145 }; 146 147 static void 148 rpc_get_iostat_started(struct rpc_get_iostat_ctx *rpc_ctx) 149 { 150 rpc_ctx->w = spdk_jsonrpc_begin_result(rpc_ctx->request); 151 152 spdk_json_write_object_begin(rpc_ctx->w); 153 spdk_json_write_named_uint64(rpc_ctx->w, "tick_rate", spdk_get_ticks_hz()); 154 spdk_json_write_named_uint64(rpc_ctx->w, "ticks", spdk_get_ticks()); 155 } 156 157 static void 158 rpc_get_iostat_done(struct rpc_get_iostat_ctx *rpc_ctx) 159 { 160 if (--rpc_ctx->bdev_count != 0) { 161 return; 162 } 163 164 if (rpc_ctx->rc == 0) { 165 spdk_json_write_array_end(rpc_ctx->w); 166 spdk_json_write_object_end(rpc_ctx->w); 167 spdk_jsonrpc_end_result(rpc_ctx->request, rpc_ctx->w); 168 } else { 169 /* Return error response after processing all specified bdevs 170 * completed or failed. 171 */ 172 spdk_jsonrpc_send_error_response(rpc_ctx->request, rpc_ctx->rc, 173 spdk_strerror(-rpc_ctx->rc)); 174 } 175 176 free(rpc_ctx); 177 } 178 179 static struct bdev_get_iostat_ctx * 180 bdev_iostat_ctx_alloc(bool iostat_ext) 181 { 182 struct bdev_get_iostat_ctx *ctx; 183 184 ctx = calloc(1, sizeof(struct bdev_get_iostat_ctx)); 185 if (ctx == NULL) { 186 return NULL; 187 } 188 189 ctx->stat = bdev_alloc_io_stat(iostat_ext); 190 if (ctx->stat == NULL) { 191 free(ctx); 192 return NULL; 193 } 194 195 return ctx; 196 } 197 198 static void 199 bdev_iostat_ctx_free(struct bdev_get_iostat_ctx *ctx) 200 { 201 bdev_free_io_stat(ctx->stat); 202 free(ctx); 203 } 204 205 static void 206 bdev_get_iostat_done(struct spdk_bdev *bdev, struct spdk_bdev_io_stat *stat, 207 void *cb_arg, int rc) 208 { 209 struct bdev_get_iostat_ctx *bdev_ctx = cb_arg; 210 struct rpc_get_iostat_ctx *rpc_ctx = bdev_ctx->rpc_ctx; 211 struct spdk_json_write_ctx *w = rpc_ctx->w; 212 213 if (rc != 0 || rpc_ctx->rc != 0) { 214 if (rpc_ctx->rc == 0) { 215 rpc_ctx->rc = rc; 216 } 217 goto done; 218 } 219 220 assert(stat == bdev_ctx->stat); 221 222 spdk_json_write_object_begin(w); 223 224 spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev)); 225 226 spdk_bdev_dump_io_stat_json(stat, w); 227 228 if (spdk_bdev_get_qd_sampling_period(bdev)) { 229 spdk_json_write_named_uint64(w, "queue_depth_polling_period", 230 spdk_bdev_get_qd_sampling_period(bdev)); 231 232 spdk_json_write_named_uint64(w, "queue_depth", spdk_bdev_get_qd(bdev)); 233 234 spdk_json_write_named_uint64(w, "io_time", spdk_bdev_get_io_time(bdev)); 235 236 spdk_json_write_named_uint64(w, "weighted_io_time", 237 spdk_bdev_get_weighted_io_time(bdev)); 238 } 239 240 if (bdev->fn_table->dump_device_stat_json) { 241 spdk_json_write_named_object_begin(w, "driver_specific"); 242 bdev->fn_table->dump_device_stat_json(bdev->ctxt, w); 243 spdk_json_write_object_end(w); 244 } 245 246 spdk_json_write_object_end(w); 247 248 done: 249 rpc_get_iostat_done(rpc_ctx); 250 251 spdk_bdev_close(bdev_ctx->desc); 252 bdev_iostat_ctx_free(bdev_ctx); 253 } 254 255 static int 256 bdev_get_iostat(void *ctx, struct spdk_bdev *bdev) 257 { 258 struct rpc_get_iostat_ctx *rpc_ctx = ctx; 259 struct bdev_get_iostat_ctx *bdev_ctx; 260 int rc; 261 262 bdev_ctx = bdev_iostat_ctx_alloc(true); 263 if (bdev_ctx == NULL) { 264 SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n"); 265 return -ENOMEM; 266 } 267 268 rc = spdk_bdev_open_ext(spdk_bdev_get_name(bdev), false, dummy_bdev_event_cb, NULL, 269 &bdev_ctx->desc); 270 if (rc != 0) { 271 bdev_iostat_ctx_free(bdev_ctx); 272 SPDK_ERRLOG("Failed to open bdev\n"); 273 return rc; 274 } 275 276 rpc_ctx->bdev_count++; 277 bdev_ctx->rpc_ctx = rpc_ctx; 278 spdk_bdev_get_device_stat(bdev, bdev_ctx->stat, bdev_get_iostat_done, bdev_ctx); 279 280 return 0; 281 } 282 283 static void 284 bdev_get_per_channel_stat_done(struct spdk_bdev *bdev, void *ctx, int status) 285 { 286 struct bdev_get_iostat_ctx *bdev_ctx = ctx; 287 288 rpc_get_iostat_done(bdev_ctx->rpc_ctx); 289 290 spdk_bdev_close(bdev_ctx->desc); 291 292 bdev_iostat_ctx_free(bdev_ctx); 293 } 294 295 static void 296 bdev_get_per_channel_stat(struct spdk_bdev_channel_iter *i, struct spdk_bdev *bdev, 297 struct spdk_io_channel *ch, void *ctx) 298 { 299 struct bdev_get_iostat_ctx *bdev_ctx = ctx; 300 struct spdk_json_write_ctx *w = bdev_ctx->rpc_ctx->w; 301 302 spdk_bdev_get_io_stat(bdev, ch, bdev_ctx->stat); 303 304 spdk_json_write_object_begin(w); 305 spdk_json_write_named_uint64(w, "thread_id", spdk_thread_get_id(spdk_get_thread())); 306 spdk_bdev_dump_io_stat_json(bdev_ctx->stat, w); 307 spdk_json_write_object_end(w); 308 309 spdk_bdev_for_each_channel_continue(i, 0); 310 } 311 312 struct rpc_bdev_get_iostat { 313 char *name; 314 bool per_channel; 315 }; 316 317 static void 318 free_rpc_bdev_get_iostat(struct rpc_bdev_get_iostat *r) 319 { 320 free(r->name); 321 } 322 323 static const struct spdk_json_object_decoder rpc_bdev_get_iostat_decoders[] = { 324 {"name", offsetof(struct rpc_bdev_get_iostat, name), spdk_json_decode_string, true}, 325 {"per_channel", offsetof(struct rpc_bdev_get_iostat, per_channel), spdk_json_decode_bool, true}, 326 }; 327 328 static void 329 rpc_bdev_get_iostat(struct spdk_jsonrpc_request *request, 330 const struct spdk_json_val *params) 331 { 332 struct rpc_bdev_get_iostat req = {}; 333 struct spdk_bdev_desc *desc = NULL; 334 struct rpc_get_iostat_ctx *rpc_ctx; 335 struct bdev_get_iostat_ctx *bdev_ctx; 336 struct spdk_bdev *bdev; 337 int rc; 338 339 if (params != NULL) { 340 if (spdk_json_decode_object(params, rpc_bdev_get_iostat_decoders, 341 SPDK_COUNTOF(rpc_bdev_get_iostat_decoders), 342 &req)) { 343 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 344 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 345 "spdk_json_decode_object failed"); 346 free_rpc_bdev_get_iostat(&req); 347 return; 348 } 349 350 if (req.per_channel == true && !req.name) { 351 SPDK_ERRLOG("Bdev name is required for per channel IO statistics\n"); 352 spdk_jsonrpc_send_error_response(request, -EINVAL, spdk_strerror(EINVAL)); 353 free_rpc_bdev_get_iostat(&req); 354 return; 355 } 356 357 if (req.name) { 358 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 359 if (rc != 0) { 360 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 361 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 362 free_rpc_bdev_get_iostat(&req); 363 return; 364 } 365 } 366 } 367 368 free_rpc_bdev_get_iostat(&req); 369 370 rpc_ctx = calloc(1, sizeof(struct rpc_get_iostat_ctx)); 371 if (rpc_ctx == NULL) { 372 SPDK_ERRLOG("Failed to allocate rpc_iostat_ctx struct\n"); 373 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 374 return; 375 } 376 377 /* 378 * Increment initial bdev_count so that it will never reach 0 in the middle 379 * of iterating. 380 */ 381 rpc_ctx->bdev_count++; 382 rpc_ctx->request = request; 383 rpc_ctx->per_channel = req.per_channel; 384 385 if (desc != NULL) { 386 bdev = spdk_bdev_desc_get_bdev(desc); 387 388 bdev_ctx = bdev_iostat_ctx_alloc(req.per_channel == false); 389 if (bdev_ctx == NULL) { 390 SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n"); 391 rpc_ctx->rc = -ENOMEM; 392 393 spdk_bdev_close(desc); 394 } else { 395 bdev_ctx->desc = desc; 396 397 rpc_ctx->bdev_count++; 398 bdev_ctx->rpc_ctx = rpc_ctx; 399 if (req.per_channel == false) { 400 spdk_bdev_get_device_stat(bdev, bdev_ctx->stat, bdev_get_iostat_done, 401 bdev_ctx); 402 } else { 403 /* If per_channel is true, there is no failure after here and 404 * we have to start RPC response before executing 405 * spdk_bdev_for_each_channel(). 406 */ 407 rpc_get_iostat_started(rpc_ctx); 408 spdk_json_write_named_string(rpc_ctx->w, "name", spdk_bdev_get_name(bdev)); 409 spdk_json_write_named_array_begin(rpc_ctx->w, "channels"); 410 411 spdk_bdev_for_each_channel(bdev, 412 bdev_get_per_channel_stat, 413 bdev_ctx, 414 bdev_get_per_channel_stat_done); 415 416 rpc_get_iostat_done(rpc_ctx); 417 return; 418 } 419 } 420 } else { 421 rc = spdk_for_each_bdev(rpc_ctx, bdev_get_iostat); 422 if (rc != 0 && rpc_ctx->rc == 0) { 423 rpc_ctx->rc = rc; 424 } 425 } 426 427 if (rpc_ctx->rc == 0) { 428 /* We want to fail the RPC for all failures. If per_channel is false, 429 * it is enough to defer starting RPC response until it is ensured that 430 * all spdk_bdev_for_each_channel() calls will succeed or there is no bdev. 431 */ 432 rpc_get_iostat_started(rpc_ctx); 433 spdk_json_write_named_array_begin(rpc_ctx->w, "bdevs"); 434 } 435 436 rpc_get_iostat_done(rpc_ctx); 437 } 438 SPDK_RPC_REGISTER("bdev_get_iostat", rpc_bdev_get_iostat, SPDK_RPC_RUNTIME) 439 440 struct rpc_reset_iostat_ctx { 441 int bdev_count; 442 int rc; 443 struct spdk_jsonrpc_request *request; 444 struct spdk_json_write_ctx *w; 445 enum spdk_bdev_reset_stat_mode mode; 446 }; 447 448 struct bdev_reset_iostat_ctx { 449 struct rpc_reset_iostat_ctx *rpc_ctx; 450 struct spdk_bdev_desc *desc; 451 }; 452 453 static void 454 rpc_reset_iostat_done(struct rpc_reset_iostat_ctx *rpc_ctx) 455 { 456 if (--rpc_ctx->bdev_count != 0) { 457 return; 458 } 459 460 if (rpc_ctx->rc == 0) { 461 spdk_jsonrpc_send_bool_response(rpc_ctx->request, true); 462 } else { 463 spdk_jsonrpc_send_error_response(rpc_ctx->request, rpc_ctx->rc, 464 spdk_strerror(-rpc_ctx->rc)); 465 } 466 467 free(rpc_ctx); 468 } 469 470 static void 471 bdev_reset_iostat_done(struct spdk_bdev *bdev, void *cb_arg, int rc) 472 { 473 struct bdev_reset_iostat_ctx *bdev_ctx = cb_arg; 474 struct rpc_reset_iostat_ctx *rpc_ctx = bdev_ctx->rpc_ctx; 475 476 if (rc != 0 || rpc_ctx->rc != 0) { 477 if (rpc_ctx->rc == 0) { 478 rpc_ctx->rc = rc; 479 } 480 } 481 482 rpc_reset_iostat_done(rpc_ctx); 483 484 spdk_bdev_close(bdev_ctx->desc); 485 free(bdev_ctx); 486 } 487 488 static int 489 bdev_reset_iostat(void *ctx, struct spdk_bdev *bdev) 490 { 491 struct rpc_reset_iostat_ctx *rpc_ctx = ctx; 492 struct bdev_reset_iostat_ctx *bdev_ctx; 493 int rc; 494 495 bdev_ctx = calloc(1, sizeof(struct bdev_reset_iostat_ctx)); 496 if (bdev_ctx == NULL) { 497 SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n"); 498 return -ENOMEM; 499 } 500 501 rc = spdk_bdev_open_ext(spdk_bdev_get_name(bdev), false, dummy_bdev_event_cb, NULL, 502 &bdev_ctx->desc); 503 if (rc != 0) { 504 free(bdev_ctx); 505 SPDK_ERRLOG("Failed to open bdev\n"); 506 return rc; 507 } 508 509 if (bdev->fn_table->reset_device_stat) { 510 bdev->fn_table->reset_device_stat(bdev->ctxt); 511 } 512 513 rpc_ctx->bdev_count++; 514 bdev_ctx->rpc_ctx = rpc_ctx; 515 bdev_reset_device_stat(bdev, rpc_ctx->mode, bdev_reset_iostat_done, bdev_ctx); 516 517 return 0; 518 } 519 520 struct rpc_bdev_reset_iostat { 521 char *name; 522 enum spdk_bdev_reset_stat_mode mode; 523 }; 524 525 static void 526 free_rpc_bdev_reset_iostat(struct rpc_bdev_reset_iostat *r) 527 { 528 free(r->name); 529 } 530 531 static int 532 rpc_decode_reset_iostat_mode(const struct spdk_json_val *val, void *out) 533 { 534 enum spdk_bdev_reset_stat_mode *mode = out; 535 536 if (spdk_json_strequal(val, "all") == true) { 537 *mode = SPDK_BDEV_RESET_STAT_ALL; 538 } else if (spdk_json_strequal(val, "maxmin") == true) { 539 *mode = SPDK_BDEV_RESET_STAT_MAXMIN; 540 } else { 541 SPDK_NOTICELOG("Invalid parameter value: mode\n"); 542 return -EINVAL; 543 } 544 545 return 0; 546 } 547 548 static const struct spdk_json_object_decoder rpc_bdev_reset_iostat_decoders[] = { 549 {"name", offsetof(struct rpc_bdev_reset_iostat, name), spdk_json_decode_string, true}, 550 {"mode", offsetof(struct rpc_bdev_reset_iostat, mode), rpc_decode_reset_iostat_mode, true}, 551 }; 552 553 static void 554 rpc_bdev_reset_iostat(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params) 555 { 556 struct rpc_bdev_reset_iostat req = { .mode = SPDK_BDEV_RESET_STAT_ALL, }; 557 struct spdk_bdev_desc *desc = NULL; 558 struct rpc_reset_iostat_ctx *rpc_ctx; 559 struct bdev_reset_iostat_ctx *bdev_ctx; 560 int rc; 561 562 if (params != NULL) { 563 if (spdk_json_decode_object(params, rpc_bdev_reset_iostat_decoders, 564 SPDK_COUNTOF(rpc_bdev_reset_iostat_decoders), 565 &req)) { 566 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 567 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 568 "spdk_json_decode_object failed"); 569 free_rpc_bdev_reset_iostat(&req); 570 return; 571 } 572 573 if (req.name) { 574 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 575 if (rc != 0) { 576 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 577 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 578 free_rpc_bdev_reset_iostat(&req); 579 return; 580 } 581 } 582 } 583 584 585 rpc_ctx = calloc(1, sizeof(struct rpc_reset_iostat_ctx)); 586 if (rpc_ctx == NULL) { 587 SPDK_ERRLOG("Failed to allocate rpc_iostat_ctx struct\n"); 588 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 589 free_rpc_bdev_reset_iostat(&req); 590 return; 591 } 592 593 /* 594 * Increment initial bdev_count so that it will never reach 0 in the middle 595 * of iterating. 596 */ 597 rpc_ctx->bdev_count++; 598 rpc_ctx->request = request; 599 rpc_ctx->mode = req.mode; 600 601 free_rpc_bdev_reset_iostat(&req); 602 603 if (desc != NULL) { 604 bdev_ctx = calloc(1, sizeof(struct bdev_reset_iostat_ctx)); 605 if (bdev_ctx == NULL) { 606 SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n"); 607 rpc_ctx->rc = -ENOMEM; 608 609 spdk_bdev_close(desc); 610 } else { 611 bdev_ctx->desc = desc; 612 613 rpc_ctx->bdev_count++; 614 bdev_ctx->rpc_ctx = rpc_ctx; 615 bdev_reset_device_stat(spdk_bdev_desc_get_bdev(desc), rpc_ctx->mode, 616 bdev_reset_iostat_done, bdev_ctx); 617 } 618 } else { 619 rc = spdk_for_each_bdev(rpc_ctx, bdev_reset_iostat); 620 if (rc != 0 && rpc_ctx->rc == 0) { 621 rpc_ctx->rc = rc; 622 } 623 } 624 625 rpc_reset_iostat_done(rpc_ctx); 626 } 627 SPDK_RPC_REGISTER("bdev_reset_iostat", rpc_bdev_reset_iostat, SPDK_RPC_RUNTIME) 628 629 static int 630 rpc_dump_bdev_info(void *ctx, struct spdk_bdev *bdev) 631 { 632 struct spdk_json_write_ctx *w = ctx; 633 struct spdk_bdev_alias *tmp; 634 uint64_t qos_limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES]; 635 struct spdk_memory_domain **domains; 636 int i, rc; 637 638 spdk_json_write_object_begin(w); 639 640 spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev)); 641 642 spdk_json_write_named_array_begin(w, "aliases"); 643 644 TAILQ_FOREACH(tmp, spdk_bdev_get_aliases(bdev), tailq) { 645 spdk_json_write_string(w, tmp->alias.name); 646 } 647 648 spdk_json_write_array_end(w); 649 650 spdk_json_write_named_string(w, "product_name", spdk_bdev_get_product_name(bdev)); 651 spdk_json_write_named_uint32(w, "block_size", spdk_bdev_get_block_size(bdev)); 652 spdk_json_write_named_uint64(w, "num_blocks", spdk_bdev_get_num_blocks(bdev)); 653 spdk_json_write_named_uuid(w, "uuid", &bdev->uuid); 654 655 if (spdk_bdev_get_md_size(bdev) != 0) { 656 spdk_json_write_named_uint32(w, "md_size", spdk_bdev_get_md_size(bdev)); 657 spdk_json_write_named_bool(w, "md_interleave", spdk_bdev_is_md_interleaved(bdev)); 658 spdk_json_write_named_uint32(w, "dif_type", spdk_bdev_get_dif_type(bdev)); 659 if (spdk_bdev_get_dif_type(bdev) != SPDK_DIF_DISABLE) { 660 spdk_json_write_named_bool(w, "dif_is_head_of_md", spdk_bdev_is_dif_head_of_md(bdev)); 661 spdk_json_write_named_object_begin(w, "enabled_dif_check_types"); 662 spdk_json_write_named_bool(w, "reftag", 663 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG)); 664 spdk_json_write_named_bool(w, "apptag", 665 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_APPTAG)); 666 spdk_json_write_named_bool(w, "guard", 667 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD)); 668 spdk_json_write_object_end(w); 669 } 670 } 671 672 spdk_json_write_named_object_begin(w, "assigned_rate_limits"); 673 spdk_bdev_get_qos_rate_limits(bdev, qos_limits); 674 for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) { 675 spdk_json_write_named_uint64(w, spdk_bdev_get_qos_rpc_type(i), qos_limits[i]); 676 } 677 spdk_json_write_object_end(w); 678 679 spdk_json_write_named_bool(w, "claimed", 680 (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE)); 681 if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE) { 682 spdk_json_write_named_string(w, "claim_type", 683 spdk_bdev_claim_get_name(bdev->internal.claim_type)); 684 } 685 686 spdk_json_write_named_bool(w, "zoned", bdev->zoned); 687 if (bdev->zoned) { 688 spdk_json_write_named_uint64(w, "zone_size", bdev->zone_size); 689 spdk_json_write_named_uint64(w, "max_open_zones", bdev->max_open_zones); 690 spdk_json_write_named_uint64(w, "optimal_open_zones", bdev->optimal_open_zones); 691 } 692 693 spdk_json_write_named_object_begin(w, "supported_io_types"); 694 spdk_json_write_named_bool(w, "read", 695 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_READ)); 696 spdk_json_write_named_bool(w, "write", 697 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_WRITE)); 698 spdk_json_write_named_bool(w, "unmap", 699 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)); 700 spdk_json_write_named_bool(w, "write_zeroes", 701 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_WRITE_ZEROES)); 702 spdk_json_write_named_bool(w, "flush", 703 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_FLUSH)); 704 spdk_json_write_named_bool(w, "reset", 705 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_RESET)); 706 spdk_json_write_named_bool(w, "compare", 707 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_COMPARE)); 708 spdk_json_write_named_bool(w, "compare_and_write", 709 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_COMPARE_AND_WRITE)); 710 spdk_json_write_named_bool(w, "abort", 711 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_ABORT)); 712 spdk_json_write_named_bool(w, "nvme_admin", 713 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_NVME_ADMIN)); 714 spdk_json_write_named_bool(w, "nvme_io", 715 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_NVME_IO)); 716 spdk_json_write_object_end(w); 717 718 rc = spdk_bdev_get_memory_domains(bdev, NULL, 0); 719 if (rc > 0) { 720 domains = calloc(rc, sizeof(struct spdk_memory_domain *)); 721 if (domains) { 722 i = spdk_bdev_get_memory_domains(bdev, domains, rc); 723 if (i == rc) { 724 spdk_json_write_named_array_begin(w, "memory_domains"); 725 for (i = 0; i < rc; i++) { 726 spdk_json_write_object_begin(w); 727 spdk_json_write_named_string(w, "dma_device_id", spdk_memory_domain_get_dma_device_id(domains[i])); 728 spdk_json_write_named_int32(w, "dma_device_type", 729 spdk_memory_domain_get_dma_device_type(domains[i])); 730 spdk_json_write_object_end(w); 731 } 732 spdk_json_write_array_end(w); 733 } else { 734 SPDK_ERRLOG("Unexpected number of memory domains %d (should be %d)\n", i, rc); 735 } 736 737 free(domains); 738 } else { 739 SPDK_ERRLOG("Memory allocation failed\n"); 740 } 741 } 742 743 spdk_json_write_named_object_begin(w, "driver_specific"); 744 spdk_bdev_dump_info_json(bdev, w); 745 spdk_json_write_object_end(w); 746 747 spdk_json_write_object_end(w); 748 749 return 0; 750 } 751 752 struct rpc_bdev_get_bdevs { 753 char *name; 754 uint64_t timeout; 755 }; 756 757 struct rpc_bdev_get_bdevs_ctx { 758 struct rpc_bdev_get_bdevs rpc; 759 struct spdk_jsonrpc_request *request; 760 struct spdk_poller *poller; 761 uint64_t timeout_ticks; 762 }; 763 764 static void 765 free_rpc_bdev_get_bdevs(struct rpc_bdev_get_bdevs *r) 766 { 767 free(r->name); 768 } 769 770 static const struct spdk_json_object_decoder rpc_bdev_get_bdevs_decoders[] = { 771 {"name", offsetof(struct rpc_bdev_get_bdevs, name), spdk_json_decode_string, true}, 772 {"timeout", offsetof(struct rpc_bdev_get_bdevs, timeout), spdk_json_decode_uint64, true}, 773 }; 774 775 static void 776 rpc_bdev_get_bdev_cb(struct spdk_bdev_desc *desc, int rc, void *cb_arg) 777 { 778 struct spdk_jsonrpc_request *request = cb_arg; 779 struct spdk_json_write_ctx *w; 780 781 if (rc == 0) { 782 w = spdk_jsonrpc_begin_result(request); 783 784 spdk_json_write_array_begin(w); 785 rpc_dump_bdev_info(w, spdk_bdev_desc_get_bdev(desc)); 786 spdk_json_write_array_end(w); 787 spdk_jsonrpc_end_result(request, w); 788 789 spdk_bdev_close(desc); 790 } else { 791 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 792 } 793 } 794 795 static void 796 rpc_bdev_get_bdevs(struct spdk_jsonrpc_request *request, 797 const struct spdk_json_val *params) 798 { 799 struct rpc_bdev_get_bdevs req = {}; 800 struct spdk_bdev_open_async_opts opts = {}; 801 struct spdk_json_write_ctx *w; 802 int rc; 803 804 if (params && spdk_json_decode_object(params, rpc_bdev_get_bdevs_decoders, 805 SPDK_COUNTOF(rpc_bdev_get_bdevs_decoders), 806 &req)) { 807 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 808 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 809 "spdk_json_decode_object failed"); 810 free_rpc_bdev_get_bdevs(&req); 811 return; 812 } 813 814 if (req.name) { 815 opts.size = sizeof(opts); 816 opts.timeout_ms = req.timeout; 817 818 rc = spdk_bdev_open_async(req.name, false, dummy_bdev_event_cb, NULL, &opts, 819 rpc_bdev_get_bdev_cb, request); 820 if (rc != 0) { 821 SPDK_ERRLOG("spdk_bdev_open_async failed for '%s': rc=%d\n", req.name, rc); 822 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 823 } 824 825 free_rpc_bdev_get_bdevs(&req); 826 return; 827 } 828 829 free_rpc_bdev_get_bdevs(&req); 830 831 w = spdk_jsonrpc_begin_result(request); 832 spdk_json_write_array_begin(w); 833 834 spdk_for_each_bdev(w, rpc_dump_bdev_info); 835 836 spdk_json_write_array_end(w); 837 838 spdk_jsonrpc_end_result(request, w); 839 } 840 SPDK_RPC_REGISTER("bdev_get_bdevs", rpc_bdev_get_bdevs, SPDK_RPC_RUNTIME) 841 842 struct rpc_bdev_set_qd_sampling_period { 843 char *name; 844 uint64_t period; 845 }; 846 847 static void 848 free_rpc_bdev_set_qd_sampling_period(struct rpc_bdev_set_qd_sampling_period *r) 849 { 850 free(r->name); 851 } 852 853 static const struct spdk_json_object_decoder 854 rpc_bdev_set_qd_sampling_period_decoders[] = { 855 {"name", offsetof(struct rpc_bdev_set_qd_sampling_period, name), spdk_json_decode_string}, 856 {"period", offsetof(struct rpc_bdev_set_qd_sampling_period, period), spdk_json_decode_uint64}, 857 }; 858 859 static void 860 rpc_bdev_set_qd_sampling_period(struct spdk_jsonrpc_request *request, 861 const struct spdk_json_val *params) 862 { 863 struct rpc_bdev_set_qd_sampling_period req = {0}; 864 struct spdk_bdev_desc *desc; 865 int rc; 866 867 if (spdk_json_decode_object(params, rpc_bdev_set_qd_sampling_period_decoders, 868 SPDK_COUNTOF(rpc_bdev_set_qd_sampling_period_decoders), 869 &req)) { 870 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 871 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 872 "spdk_json_decode_object failed"); 873 goto cleanup; 874 } 875 876 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 877 if (rc != 0) { 878 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 879 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 880 goto cleanup; 881 } 882 883 spdk_bdev_set_qd_sampling_period(spdk_bdev_desc_get_bdev(desc), req.period); 884 spdk_jsonrpc_send_bool_response(request, true); 885 886 spdk_bdev_close(desc); 887 888 cleanup: 889 free_rpc_bdev_set_qd_sampling_period(&req); 890 } 891 SPDK_RPC_REGISTER("bdev_set_qd_sampling_period", 892 rpc_bdev_set_qd_sampling_period, 893 SPDK_RPC_RUNTIME) 894 895 struct rpc_bdev_set_qos_limit { 896 char *name; 897 uint64_t limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES]; 898 }; 899 900 static void 901 free_rpc_bdev_set_qos_limit(struct rpc_bdev_set_qos_limit *r) 902 { 903 free(r->name); 904 } 905 906 static const struct spdk_json_object_decoder rpc_bdev_set_qos_limit_decoders[] = { 907 {"name", offsetof(struct rpc_bdev_set_qos_limit, name), spdk_json_decode_string}, 908 { 909 "rw_ios_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 910 limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT]), 911 spdk_json_decode_uint64, true 912 }, 913 { 914 "rw_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 915 limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT]), 916 spdk_json_decode_uint64, true 917 }, 918 { 919 "r_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 920 limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT]), 921 spdk_json_decode_uint64, true 922 }, 923 { 924 "w_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 925 limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT]), 926 spdk_json_decode_uint64, true 927 }, 928 }; 929 930 static void 931 rpc_bdev_set_qos_limit_complete(void *cb_arg, int status) 932 { 933 struct spdk_jsonrpc_request *request = cb_arg; 934 935 if (status != 0) { 936 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 937 "Failed to configure rate limit: %s", 938 spdk_strerror(-status)); 939 return; 940 } 941 942 spdk_jsonrpc_send_bool_response(request, true); 943 } 944 945 static void 946 rpc_bdev_set_qos_limit(struct spdk_jsonrpc_request *request, 947 const struct spdk_json_val *params) 948 { 949 struct rpc_bdev_set_qos_limit req = {NULL, {UINT64_MAX, UINT64_MAX, UINT64_MAX, UINT64_MAX}}; 950 struct spdk_bdev_desc *desc; 951 int i, rc; 952 953 if (spdk_json_decode_object(params, rpc_bdev_set_qos_limit_decoders, 954 SPDK_COUNTOF(rpc_bdev_set_qos_limit_decoders), 955 &req)) { 956 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 957 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 958 "spdk_json_decode_object failed"); 959 goto cleanup; 960 } 961 962 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 963 if (rc != 0) { 964 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 965 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 966 goto cleanup; 967 } 968 969 for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) { 970 if (req.limits[i] != UINT64_MAX) { 971 break; 972 } 973 } 974 if (i == SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES) { 975 SPDK_ERRLOG("no rate limits specified\n"); 976 spdk_bdev_close(desc); 977 spdk_jsonrpc_send_error_response(request, -EINVAL, "No rate limits specified"); 978 goto cleanup; 979 } 980 981 spdk_bdev_set_qos_rate_limits(spdk_bdev_desc_get_bdev(desc), req.limits, 982 rpc_bdev_set_qos_limit_complete, request); 983 984 spdk_bdev_close(desc); 985 986 cleanup: 987 free_rpc_bdev_set_qos_limit(&req); 988 } 989 990 SPDK_RPC_REGISTER("bdev_set_qos_limit", rpc_bdev_set_qos_limit, SPDK_RPC_RUNTIME) 991 992 /* SPDK_RPC_ENABLE_BDEV_HISTOGRAM */ 993 994 struct rpc_bdev_enable_histogram_request { 995 char *name; 996 bool enable; 997 }; 998 999 static void 1000 free_rpc_bdev_enable_histogram_request(struct rpc_bdev_enable_histogram_request *r) 1001 { 1002 free(r->name); 1003 } 1004 1005 static const struct spdk_json_object_decoder rpc_bdev_enable_histogram_request_decoders[] = { 1006 {"name", offsetof(struct rpc_bdev_enable_histogram_request, name), spdk_json_decode_string}, 1007 {"enable", offsetof(struct rpc_bdev_enable_histogram_request, enable), spdk_json_decode_bool}, 1008 }; 1009 1010 static void 1011 bdev_histogram_status_cb(void *cb_arg, int status) 1012 { 1013 struct spdk_jsonrpc_request *request = cb_arg; 1014 1015 if (status == 0) { 1016 spdk_jsonrpc_send_bool_response(request, true); 1017 } else { 1018 spdk_jsonrpc_send_error_response(request, status, spdk_strerror(-status)); 1019 } 1020 } 1021 1022 static void 1023 rpc_bdev_enable_histogram(struct spdk_jsonrpc_request *request, 1024 const struct spdk_json_val *params) 1025 { 1026 struct rpc_bdev_enable_histogram_request req = {NULL}; 1027 struct spdk_bdev_desc *desc; 1028 int rc; 1029 1030 if (spdk_json_decode_object(params, rpc_bdev_enable_histogram_request_decoders, 1031 SPDK_COUNTOF(rpc_bdev_enable_histogram_request_decoders), 1032 &req)) { 1033 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1034 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1035 "spdk_json_decode_object failed"); 1036 goto cleanup; 1037 } 1038 1039 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 1040 if (rc != 0) { 1041 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 1042 goto cleanup; 1043 } 1044 1045 spdk_bdev_histogram_enable(spdk_bdev_desc_get_bdev(desc), bdev_histogram_status_cb, 1046 request, req.enable); 1047 1048 spdk_bdev_close(desc); 1049 1050 cleanup: 1051 free_rpc_bdev_enable_histogram_request(&req); 1052 } 1053 1054 SPDK_RPC_REGISTER("bdev_enable_histogram", rpc_bdev_enable_histogram, SPDK_RPC_RUNTIME) 1055 1056 /* SPDK_RPC_GET_BDEV_HISTOGRAM */ 1057 1058 struct rpc_bdev_get_histogram_request { 1059 char *name; 1060 }; 1061 1062 static const struct spdk_json_object_decoder rpc_bdev_get_histogram_request_decoders[] = { 1063 {"name", offsetof(struct rpc_bdev_get_histogram_request, name), spdk_json_decode_string} 1064 }; 1065 1066 static void 1067 free_rpc_bdev_get_histogram_request(struct rpc_bdev_get_histogram_request *r) 1068 { 1069 free(r->name); 1070 } 1071 1072 static void 1073 _rpc_bdev_histogram_data_cb(void *cb_arg, int status, struct spdk_histogram_data *histogram) 1074 { 1075 struct spdk_jsonrpc_request *request = cb_arg; 1076 struct spdk_json_write_ctx *w; 1077 int rc; 1078 char *encoded_histogram; 1079 size_t src_len, dst_len; 1080 1081 1082 if (status != 0) { 1083 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1084 spdk_strerror(-status)); 1085 goto invalid; 1086 } 1087 1088 src_len = SPDK_HISTOGRAM_NUM_BUCKETS(histogram) * sizeof(uint64_t); 1089 dst_len = spdk_base64_get_encoded_strlen(src_len) + 1; 1090 1091 encoded_histogram = malloc(dst_len); 1092 if (encoded_histogram == NULL) { 1093 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1094 spdk_strerror(ENOMEM)); 1095 goto invalid; 1096 } 1097 1098 rc = spdk_base64_encode(encoded_histogram, histogram->bucket, src_len); 1099 if (rc != 0) { 1100 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1101 spdk_strerror(-rc)); 1102 goto free_encoded_histogram; 1103 } 1104 1105 w = spdk_jsonrpc_begin_result(request); 1106 spdk_json_write_object_begin(w); 1107 spdk_json_write_named_string(w, "histogram", encoded_histogram); 1108 spdk_json_write_named_int64(w, "bucket_shift", histogram->bucket_shift); 1109 spdk_json_write_named_int64(w, "tsc_rate", spdk_get_ticks_hz()); 1110 spdk_json_write_object_end(w); 1111 spdk_jsonrpc_end_result(request, w); 1112 1113 free_encoded_histogram: 1114 free(encoded_histogram); 1115 invalid: 1116 spdk_histogram_data_free(histogram); 1117 } 1118 1119 static void 1120 rpc_bdev_get_histogram(struct spdk_jsonrpc_request *request, 1121 const struct spdk_json_val *params) 1122 { 1123 struct rpc_bdev_get_histogram_request req = {NULL}; 1124 struct spdk_histogram_data *histogram; 1125 struct spdk_bdev_desc *desc; 1126 int rc; 1127 1128 if (spdk_json_decode_object(params, rpc_bdev_get_histogram_request_decoders, 1129 SPDK_COUNTOF(rpc_bdev_get_histogram_request_decoders), 1130 &req)) { 1131 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 1132 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1133 "spdk_json_decode_object failed"); 1134 goto cleanup; 1135 } 1136 1137 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 1138 if (rc != 0) { 1139 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 1140 goto cleanup; 1141 } 1142 1143 histogram = spdk_histogram_data_alloc(); 1144 if (histogram == NULL) { 1145 spdk_bdev_close(desc); 1146 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 1147 goto cleanup; 1148 } 1149 1150 spdk_bdev_histogram_get(spdk_bdev_desc_get_bdev(desc), histogram, 1151 _rpc_bdev_histogram_data_cb, request); 1152 1153 spdk_bdev_close(desc); 1154 1155 cleanup: 1156 free_rpc_bdev_get_histogram_request(&req); 1157 } 1158 1159 SPDK_RPC_REGISTER("bdev_get_histogram", rpc_bdev_get_histogram, SPDK_RPC_RUNTIME) 1160