1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "spdk/bdev.h" 7 8 #include "spdk/env.h" 9 #include "spdk/rpc.h" 10 #include "spdk/util.h" 11 #include "spdk/string.h" 12 #include "spdk/base64.h" 13 #include "spdk/bdev_module.h" 14 #include "spdk/dma.h" 15 16 #include "spdk/log.h" 17 18 static void 19 dummy_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *ctx) 20 { 21 } 22 23 struct spdk_rpc_set_bdev_opts { 24 uint32_t bdev_io_pool_size; 25 uint32_t bdev_io_cache_size; 26 bool bdev_auto_examine; 27 uint32_t small_buf_pool_size; 28 uint32_t large_buf_pool_size; 29 }; 30 31 static const struct spdk_json_object_decoder rpc_set_bdev_opts_decoders[] = { 32 {"bdev_io_pool_size", offsetof(struct spdk_rpc_set_bdev_opts, bdev_io_pool_size), spdk_json_decode_uint32, true}, 33 {"bdev_io_cache_size", offsetof(struct spdk_rpc_set_bdev_opts, bdev_io_cache_size), spdk_json_decode_uint32, true}, 34 {"bdev_auto_examine", offsetof(struct spdk_rpc_set_bdev_opts, bdev_auto_examine), spdk_json_decode_bool, true}, 35 {"small_buf_pool_size", offsetof(struct spdk_rpc_set_bdev_opts, small_buf_pool_size), spdk_json_decode_uint32, true}, 36 {"large_buf_pool_size", offsetof(struct spdk_rpc_set_bdev_opts, large_buf_pool_size), spdk_json_decode_uint32, true}, 37 }; 38 39 static void 40 rpc_bdev_set_options(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params) 41 { 42 struct spdk_rpc_set_bdev_opts rpc_opts; 43 struct spdk_bdev_opts bdev_opts; 44 int rc; 45 46 rpc_opts.bdev_io_pool_size = UINT32_MAX; 47 rpc_opts.bdev_io_cache_size = UINT32_MAX; 48 rpc_opts.small_buf_pool_size = UINT32_MAX; 49 rpc_opts.large_buf_pool_size = UINT32_MAX; 50 rpc_opts.bdev_auto_examine = true; 51 52 if (params != NULL) { 53 if (spdk_json_decode_object(params, rpc_set_bdev_opts_decoders, 54 SPDK_COUNTOF(rpc_set_bdev_opts_decoders), &rpc_opts)) { 55 SPDK_ERRLOG("spdk_json_decode_object() failed\n"); 56 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 57 "Invalid parameters"); 58 return; 59 } 60 } 61 62 spdk_bdev_get_opts(&bdev_opts, sizeof(bdev_opts)); 63 if (rpc_opts.bdev_io_pool_size != UINT32_MAX) { 64 bdev_opts.bdev_io_pool_size = rpc_opts.bdev_io_pool_size; 65 } 66 if (rpc_opts.bdev_io_cache_size != UINT32_MAX) { 67 bdev_opts.bdev_io_cache_size = rpc_opts.bdev_io_cache_size; 68 } 69 bdev_opts.bdev_auto_examine = rpc_opts.bdev_auto_examine; 70 if (rpc_opts.small_buf_pool_size != UINT32_MAX) { 71 bdev_opts.small_buf_pool_size = rpc_opts.small_buf_pool_size; 72 } 73 if (rpc_opts.large_buf_pool_size != UINT32_MAX) { 74 bdev_opts.large_buf_pool_size = rpc_opts.large_buf_pool_size; 75 } 76 77 rc = spdk_bdev_set_opts(&bdev_opts); 78 79 if (rc != 0) { 80 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 81 "Pool size %" PRIu32 " too small for cache size %" PRIu32, 82 bdev_opts.bdev_io_pool_size, bdev_opts.bdev_io_cache_size); 83 return; 84 } 85 86 spdk_jsonrpc_send_bool_response(request, true); 87 } 88 SPDK_RPC_REGISTER("bdev_set_options", rpc_bdev_set_options, SPDK_RPC_STARTUP) 89 90 static void 91 rpc_bdev_wait_for_examine_cpl(void *arg) 92 { 93 struct spdk_jsonrpc_request *request = arg; 94 95 spdk_jsonrpc_send_bool_response(request, true); 96 } 97 98 static void 99 rpc_bdev_wait_for_examine(struct spdk_jsonrpc_request *request, 100 const struct spdk_json_val *params) 101 { 102 int rc; 103 104 if (params != NULL) { 105 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 106 "bdev_wait_for_examine requires no parameters"); 107 return; 108 } 109 110 rc = spdk_bdev_wait_for_examine(rpc_bdev_wait_for_examine_cpl, request); 111 if (rc != 0) { 112 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 113 } 114 } 115 SPDK_RPC_REGISTER("bdev_wait_for_examine", rpc_bdev_wait_for_examine, SPDK_RPC_RUNTIME) 116 117 struct rpc_bdev_examine { 118 char *name; 119 }; 120 121 static void 122 free_rpc_bdev_examine(struct rpc_bdev_examine *r) 123 { 124 free(r->name); 125 } 126 127 static const struct spdk_json_object_decoder rpc_examine_bdev_decoders[] = { 128 {"name", offsetof(struct rpc_bdev_examine, name), spdk_json_decode_string}, 129 }; 130 131 static void 132 rpc_bdev_examine_bdev(struct spdk_jsonrpc_request *request, 133 const struct spdk_json_val *params) 134 { 135 struct rpc_bdev_examine req = {NULL}; 136 int rc; 137 138 if (spdk_json_decode_object(params, rpc_examine_bdev_decoders, 139 SPDK_COUNTOF(rpc_examine_bdev_decoders), 140 &req)) { 141 SPDK_ERRLOG("spdk_json_decode_object() failed\n"); 142 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 143 "spdk_json_decode_object failed"); 144 goto cleanup; 145 } 146 147 rc = spdk_bdev_examine(req.name); 148 if (rc != 0) { 149 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 150 goto cleanup; 151 } 152 153 spdk_jsonrpc_send_bool_response(request, true); 154 155 cleanup: 156 free_rpc_bdev_examine(&req); 157 } 158 SPDK_RPC_REGISTER("bdev_examine", rpc_bdev_examine_bdev, SPDK_RPC_RUNTIME) 159 160 struct rpc_bdev_get_iostat_ctx { 161 int bdev_count; 162 int rc; 163 struct spdk_jsonrpc_request *request; 164 struct spdk_json_write_ctx *w; 165 }; 166 167 struct rpc_bdev_iostat { 168 struct spdk_bdev_io_stat stat; 169 struct rpc_bdev_get_iostat_ctx *ctx; 170 struct spdk_bdev_desc *desc; 171 }; 172 173 static void 174 rpc_bdev_get_iostat_started(struct rpc_bdev_get_iostat_ctx *ctx) 175 { 176 ctx->w = spdk_jsonrpc_begin_result(ctx->request); 177 178 spdk_json_write_object_begin(ctx->w); 179 spdk_json_write_named_uint64(ctx->w, "tick_rate", spdk_get_ticks_hz()); 180 spdk_json_write_named_uint64(ctx->w, "ticks", spdk_get_ticks()); 181 182 spdk_json_write_named_array_begin(ctx->w, "bdevs"); 183 } 184 185 static void 186 rpc_bdev_get_iostat_done(struct rpc_bdev_get_iostat_ctx *ctx) 187 { 188 if (--ctx->bdev_count != 0) { 189 return; 190 } 191 192 if (ctx->rc == 0) { 193 spdk_json_write_array_end(ctx->w); 194 spdk_json_write_object_end(ctx->w); 195 spdk_jsonrpc_end_result(ctx->request, ctx->w); 196 } else { 197 /* Return error response after processing all specified bdevs 198 * completed or failed. 199 */ 200 spdk_jsonrpc_send_error_response(ctx->request, ctx->rc, 201 spdk_strerror(-ctx->rc)); 202 } 203 204 free(ctx); 205 } 206 207 static void 208 rpc_bdev_get_iostat_cb(struct spdk_bdev *bdev, 209 struct spdk_bdev_io_stat *stat, void *cb_arg, int rc) 210 { 211 struct rpc_bdev_iostat *_stat = cb_arg; 212 struct rpc_bdev_get_iostat_ctx *ctx = _stat->ctx; 213 struct spdk_json_write_ctx *w = ctx->w; 214 215 if (rc != 0 || ctx->rc != 0) { 216 if (ctx->rc == 0) { 217 ctx->rc = rc; 218 } 219 goto done; 220 } 221 222 assert(stat == &_stat->stat); 223 224 spdk_json_write_object_begin(w); 225 226 spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev)); 227 228 spdk_json_write_named_uint64(w, "bytes_read", stat->bytes_read); 229 230 spdk_json_write_named_uint64(w, "num_read_ops", stat->num_read_ops); 231 232 spdk_json_write_named_uint64(w, "bytes_written", stat->bytes_written); 233 234 spdk_json_write_named_uint64(w, "num_write_ops", stat->num_write_ops); 235 236 spdk_json_write_named_uint64(w, "bytes_unmapped", stat->bytes_unmapped); 237 238 spdk_json_write_named_uint64(w, "num_unmap_ops", stat->num_unmap_ops); 239 240 spdk_json_write_named_uint64(w, "read_latency_ticks", stat->read_latency_ticks); 241 242 spdk_json_write_named_uint64(w, "write_latency_ticks", stat->write_latency_ticks); 243 244 spdk_json_write_named_uint64(w, "unmap_latency_ticks", stat->unmap_latency_ticks); 245 246 if (spdk_bdev_get_qd_sampling_period(bdev)) { 247 spdk_json_write_named_uint64(w, "queue_depth_polling_period", 248 spdk_bdev_get_qd_sampling_period(bdev)); 249 250 spdk_json_write_named_uint64(w, "queue_depth", spdk_bdev_get_qd(bdev)); 251 252 spdk_json_write_named_uint64(w, "io_time", spdk_bdev_get_io_time(bdev)); 253 254 spdk_json_write_named_uint64(w, "weighted_io_time", 255 spdk_bdev_get_weighted_io_time(bdev)); 256 } 257 258 spdk_json_write_object_end(w); 259 260 done: 261 rpc_bdev_get_iostat_done(ctx); 262 263 spdk_bdev_close(_stat->desc); 264 free(_stat); 265 } 266 267 struct rpc_bdev_get_iostat { 268 char *name; 269 }; 270 271 static void 272 free_rpc_bdev_get_iostat(struct rpc_bdev_get_iostat *r) 273 { 274 free(r->name); 275 } 276 277 static const struct spdk_json_object_decoder rpc_bdev_get_iostat_decoders[] = { 278 {"name", offsetof(struct rpc_bdev_get_iostat, name), spdk_json_decode_string, true}, 279 }; 280 281 static int 282 _bdev_get_device_stat(void *_ctx, struct spdk_bdev *bdev) 283 { 284 struct rpc_bdev_get_iostat_ctx *ctx = _ctx; 285 struct rpc_bdev_iostat *_stat; 286 int rc; 287 288 _stat = calloc(1, sizeof(struct rpc_bdev_iostat)); 289 if (_stat == NULL) { 290 SPDK_ERRLOG("Failed to allocate rpc_bdev_iostat struct\n"); 291 return -ENOMEM; 292 } 293 294 rc = spdk_bdev_open_ext(spdk_bdev_get_name(bdev), false, dummy_bdev_event_cb, NULL, &_stat->desc); 295 if (rc != 0) { 296 free(_stat); 297 SPDK_ERRLOG("Failed to open bdev\n"); 298 return rc; 299 } 300 301 ctx->bdev_count++; 302 _stat->ctx = ctx; 303 spdk_bdev_get_device_stat(bdev, &_stat->stat, rpc_bdev_get_iostat_cb, _stat); 304 305 return 0; 306 } 307 308 static void 309 rpc_bdev_get_iostat(struct spdk_jsonrpc_request *request, 310 const struct spdk_json_val *params) 311 { 312 struct rpc_bdev_get_iostat req = {}; 313 struct spdk_bdev_desc *desc = NULL; 314 struct rpc_bdev_get_iostat_ctx *ctx; 315 struct rpc_bdev_iostat *_stat; 316 int rc; 317 318 if (params != NULL) { 319 if (spdk_json_decode_object(params, rpc_bdev_get_iostat_decoders, 320 SPDK_COUNTOF(rpc_bdev_get_iostat_decoders), 321 &req)) { 322 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 323 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 324 "spdk_json_decode_object failed"); 325 free_rpc_bdev_get_iostat(&req); 326 return; 327 } 328 329 if (req.name) { 330 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 331 if (rc != 0) { 332 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 333 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 334 free_rpc_bdev_get_iostat(&req); 335 return; 336 } 337 } 338 } 339 340 free_rpc_bdev_get_iostat(&req); 341 342 ctx = calloc(1, sizeof(struct rpc_bdev_get_iostat_ctx)); 343 if (ctx == NULL) { 344 SPDK_ERRLOG("Failed to allocate rpc_bdev_get_iostat_ctx struct\n"); 345 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 346 return; 347 } 348 349 /* 350 * Increment initial bdev_count so that it will never reach 0 in the middle 351 * of iterating. 352 */ 353 ctx->bdev_count++; 354 ctx->request = request; 355 356 if (desc != NULL) { 357 _stat = calloc(1, sizeof(struct rpc_bdev_iostat)); 358 if (_stat == NULL) { 359 SPDK_ERRLOG("Failed to allocate rpc_bdev_iostat struct\n"); 360 ctx->rc = -ENOMEM; 361 362 spdk_bdev_close(desc); 363 } else { 364 _stat->desc = desc; 365 366 ctx->bdev_count++; 367 _stat->ctx = ctx; 368 spdk_bdev_get_device_stat(spdk_bdev_desc_get_bdev(desc), &_stat->stat, 369 rpc_bdev_get_iostat_cb, _stat); 370 } 371 } else { 372 rc = spdk_for_each_bdev(ctx, _bdev_get_device_stat); 373 if (rc != 0 && ctx->rc == 0) { 374 ctx->rc = rc; 375 } 376 } 377 378 if (ctx->rc == 0) { 379 /* We want to fail the RPC for all failures. The callback function to 380 * spdk_bdev_get_device_stat() is executed after stack unwinding if successful. 381 * Hence defer starting RPC response until it is ensured that all 382 * spdk_bdev_get_device_stat() calls will succeed or there is no bdev. 383 */ 384 rpc_bdev_get_iostat_started(ctx); 385 } 386 387 rpc_bdev_get_iostat_done(ctx); 388 } 389 SPDK_RPC_REGISTER("bdev_get_iostat", rpc_bdev_get_iostat, SPDK_RPC_RUNTIME) 390 391 static int 392 rpc_dump_bdev_info(void *ctx, struct spdk_bdev *bdev) 393 { 394 struct spdk_json_write_ctx *w = ctx; 395 struct spdk_bdev_alias *tmp; 396 uint64_t qos_limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES]; 397 struct spdk_memory_domain **domains; 398 int i, rc; 399 400 spdk_json_write_object_begin(w); 401 402 spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev)); 403 404 spdk_json_write_named_array_begin(w, "aliases"); 405 406 TAILQ_FOREACH(tmp, spdk_bdev_get_aliases(bdev), tailq) { 407 spdk_json_write_string(w, tmp->alias.name); 408 } 409 410 spdk_json_write_array_end(w); 411 412 spdk_json_write_named_string(w, "product_name", spdk_bdev_get_product_name(bdev)); 413 414 spdk_json_write_named_uint32(w, "block_size", spdk_bdev_get_block_size(bdev)); 415 416 spdk_json_write_named_uint64(w, "num_blocks", spdk_bdev_get_num_blocks(bdev)); 417 418 if (!spdk_mem_all_zero(&bdev->uuid, sizeof(bdev->uuid))) { 419 char uuid_str[SPDK_UUID_STRING_LEN]; 420 421 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &bdev->uuid); 422 spdk_json_write_named_string(w, "uuid", uuid_str); 423 } 424 425 if (spdk_bdev_get_md_size(bdev) != 0) { 426 spdk_json_write_named_uint32(w, "md_size", spdk_bdev_get_md_size(bdev)); 427 spdk_json_write_named_bool(w, "md_interleave", spdk_bdev_is_md_interleaved(bdev)); 428 spdk_json_write_named_uint32(w, "dif_type", spdk_bdev_get_dif_type(bdev)); 429 if (spdk_bdev_get_dif_type(bdev) != SPDK_DIF_DISABLE) { 430 spdk_json_write_named_bool(w, "dif_is_head_of_md", spdk_bdev_is_dif_head_of_md(bdev)); 431 spdk_json_write_named_object_begin(w, "enabled_dif_check_types"); 432 spdk_json_write_named_bool(w, "reftag", 433 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG)); 434 spdk_json_write_named_bool(w, "apptag", 435 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_APPTAG)); 436 spdk_json_write_named_bool(w, "guard", 437 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD)); 438 spdk_json_write_object_end(w); 439 } 440 } 441 442 spdk_json_write_named_object_begin(w, "assigned_rate_limits"); 443 spdk_bdev_get_qos_rate_limits(bdev, qos_limits); 444 for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) { 445 spdk_json_write_named_uint64(w, spdk_bdev_get_qos_rpc_type(i), qos_limits[i]); 446 } 447 spdk_json_write_object_end(w); 448 449 spdk_json_write_named_bool(w, "claimed", (bdev->internal.claim_module != NULL)); 450 451 spdk_json_write_named_bool(w, "zoned", bdev->zoned); 452 if (bdev->zoned) { 453 spdk_json_write_named_uint64(w, "zone_size", bdev->zone_size); 454 spdk_json_write_named_uint64(w, "max_open_zones", bdev->max_open_zones); 455 spdk_json_write_named_uint64(w, "optimal_open_zones", bdev->optimal_open_zones); 456 } 457 458 spdk_json_write_named_object_begin(w, "supported_io_types"); 459 spdk_json_write_named_bool(w, "read", 460 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_READ)); 461 spdk_json_write_named_bool(w, "write", 462 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_WRITE)); 463 spdk_json_write_named_bool(w, "unmap", 464 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)); 465 spdk_json_write_named_bool(w, "write_zeroes", 466 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_WRITE_ZEROES)); 467 spdk_json_write_named_bool(w, "flush", 468 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_FLUSH)); 469 spdk_json_write_named_bool(w, "reset", 470 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_RESET)); 471 spdk_json_write_named_bool(w, "compare", 472 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_COMPARE)); 473 spdk_json_write_named_bool(w, "compare_and_write", 474 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_COMPARE_AND_WRITE)); 475 spdk_json_write_named_bool(w, "abort", 476 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_ABORT)); 477 spdk_json_write_named_bool(w, "nvme_admin", 478 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_NVME_ADMIN)); 479 spdk_json_write_named_bool(w, "nvme_io", 480 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_NVME_IO)); 481 spdk_json_write_object_end(w); 482 483 rc = spdk_bdev_get_memory_domains(bdev, NULL, 0); 484 if (rc > 0) { 485 domains = calloc(rc, sizeof(struct spdk_memory_domain *)); 486 if (domains) { 487 i = spdk_bdev_get_memory_domains(bdev, domains, rc); 488 if (i == rc) { 489 spdk_json_write_named_array_begin(w, "memory_domains"); 490 for (i = 0; i < rc; i++) { 491 spdk_json_write_object_begin(w); 492 spdk_json_write_named_string(w, "dma_device_id", spdk_memory_domain_get_dma_device_id(domains[i])); 493 spdk_json_write_named_int32(w, "dma_device_type", 494 spdk_memory_domain_get_dma_device_type(domains[i])); 495 spdk_json_write_object_end(w); 496 } 497 spdk_json_write_array_end(w); 498 } else { 499 SPDK_ERRLOG("Unexpected number of memory domains %d (should be %d)\n", i, rc); 500 } 501 502 free(domains); 503 } else { 504 SPDK_ERRLOG("Memory allocation failed\n"); 505 } 506 } 507 508 spdk_json_write_named_object_begin(w, "driver_specific"); 509 spdk_bdev_dump_info_json(bdev, w); 510 spdk_json_write_object_end(w); 511 512 spdk_json_write_object_end(w); 513 514 return 0; 515 } 516 517 struct rpc_bdev_get_bdevs { 518 char *name; 519 uint64_t timeout; 520 }; 521 522 struct rpc_bdev_get_bdevs_ctx { 523 struct rpc_bdev_get_bdevs rpc; 524 struct spdk_jsonrpc_request *request; 525 struct spdk_poller *poller; 526 uint64_t timeout_ticks; 527 }; 528 529 static void 530 free_rpc_bdev_get_bdevs(struct rpc_bdev_get_bdevs *r) 531 { 532 free(r->name); 533 } 534 535 static const struct spdk_json_object_decoder rpc_bdev_get_bdevs_decoders[] = { 536 {"name", offsetof(struct rpc_bdev_get_bdevs, name), spdk_json_decode_string, true}, 537 {"timeout", offsetof(struct rpc_bdev_get_bdevs, timeout), spdk_json_decode_uint64, true}, 538 }; 539 540 static int 541 get_bdevs_poller(void *_ctx) 542 { 543 struct rpc_bdev_get_bdevs_ctx *ctx = _ctx; 544 struct spdk_json_write_ctx *w; 545 struct spdk_bdev_desc *desc; 546 int rc; 547 548 rc = spdk_bdev_open_ext(ctx->rpc.name, false, dummy_bdev_event_cb, NULL, &desc); 549 if (rc != 0 && spdk_get_ticks() < ctx->timeout_ticks) { 550 return SPDK_POLLER_BUSY; 551 } 552 553 if (rc != 0) { 554 SPDK_ERRLOG("Timed out while waiting for bdev '%s' to appear\n", ctx->rpc.name); 555 spdk_jsonrpc_send_error_response(ctx->request, -ENODEV, spdk_strerror(ENODEV)); 556 } else { 557 w = spdk_jsonrpc_begin_result(ctx->request); 558 spdk_json_write_array_begin(w); 559 rpc_dump_bdev_info(w, spdk_bdev_desc_get_bdev(desc)); 560 spdk_json_write_array_end(w); 561 spdk_jsonrpc_end_result(ctx->request, w); 562 563 spdk_bdev_close(desc); 564 } 565 566 spdk_poller_unregister(&ctx->poller); 567 free_rpc_bdev_get_bdevs(&ctx->rpc); 568 free(ctx); 569 570 return SPDK_POLLER_BUSY; 571 } 572 573 static void 574 rpc_bdev_get_bdevs(struct spdk_jsonrpc_request *request, 575 const struct spdk_json_val *params) 576 { 577 struct rpc_bdev_get_bdevs req = {}; 578 struct rpc_bdev_get_bdevs_ctx *ctx; 579 struct spdk_json_write_ctx *w; 580 struct spdk_bdev_desc *desc = NULL; 581 int rc; 582 583 if (params && spdk_json_decode_object(params, rpc_bdev_get_bdevs_decoders, 584 SPDK_COUNTOF(rpc_bdev_get_bdevs_decoders), 585 &req)) { 586 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 587 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 588 "spdk_json_decode_object failed"); 589 free_rpc_bdev_get_bdevs(&req); 590 return; 591 } 592 593 if (req.name) { 594 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 595 if (rc != 0) { 596 if (req.timeout == 0) { 597 SPDK_ERRLOG("bdev '%s' does not exist\n", req.name); 598 spdk_jsonrpc_send_error_response(request, -ENODEV, spdk_strerror(ENODEV)); 599 free_rpc_bdev_get_bdevs(&req); 600 return; 601 } 602 603 ctx = calloc(1, sizeof(*ctx)); 604 if (ctx == NULL) { 605 SPDK_ERRLOG("Failed to allocate bdev_get_bdevs context\n"); 606 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 607 free_rpc_bdev_get_bdevs(&req); 608 return; 609 } 610 611 ctx->poller = SPDK_POLLER_REGISTER(get_bdevs_poller, ctx, 10 * 1000); 612 if (ctx->poller == NULL) { 613 SPDK_ERRLOG("Failed to register bdev_get_bdevs poller\n"); 614 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 615 free_rpc_bdev_get_bdevs(&req); 616 free(ctx); 617 return; 618 } 619 620 memcpy(&ctx->rpc, &req, sizeof(req)); 621 ctx->timeout_ticks = spdk_get_ticks() + req.timeout * 622 spdk_get_ticks_hz() / 1000ull; 623 ctx->request = request; 624 return; 625 } 626 } 627 628 free_rpc_bdev_get_bdevs(&req); 629 w = spdk_jsonrpc_begin_result(request); 630 spdk_json_write_array_begin(w); 631 632 if (desc != NULL) { 633 rpc_dump_bdev_info(w, spdk_bdev_desc_get_bdev(desc)); 634 spdk_bdev_close(desc); 635 } else { 636 spdk_for_each_bdev(w, rpc_dump_bdev_info); 637 } 638 639 spdk_json_write_array_end(w); 640 641 spdk_jsonrpc_end_result(request, w); 642 } 643 SPDK_RPC_REGISTER("bdev_get_bdevs", rpc_bdev_get_bdevs, SPDK_RPC_RUNTIME) 644 645 struct rpc_bdev_set_qd_sampling_period { 646 char *name; 647 uint64_t period; 648 }; 649 650 static void 651 free_rpc_bdev_set_qd_sampling_period(struct rpc_bdev_set_qd_sampling_period *r) 652 { 653 free(r->name); 654 } 655 656 static const struct spdk_json_object_decoder 657 rpc_bdev_set_qd_sampling_period_decoders[] = { 658 {"name", offsetof(struct rpc_bdev_set_qd_sampling_period, name), spdk_json_decode_string}, 659 {"period", offsetof(struct rpc_bdev_set_qd_sampling_period, period), spdk_json_decode_uint64}, 660 }; 661 662 static void 663 rpc_bdev_set_qd_sampling_period(struct spdk_jsonrpc_request *request, 664 const struct spdk_json_val *params) 665 { 666 struct rpc_bdev_set_qd_sampling_period req = {0}; 667 struct spdk_bdev_desc *desc; 668 int rc; 669 670 if (spdk_json_decode_object(params, rpc_bdev_set_qd_sampling_period_decoders, 671 SPDK_COUNTOF(rpc_bdev_set_qd_sampling_period_decoders), 672 &req)) { 673 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 674 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 675 "spdk_json_decode_object failed"); 676 goto cleanup; 677 } 678 679 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 680 if (rc != 0) { 681 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 682 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 683 goto cleanup; 684 } 685 686 spdk_bdev_set_qd_sampling_period(spdk_bdev_desc_get_bdev(desc), req.period); 687 spdk_jsonrpc_send_bool_response(request, true); 688 689 spdk_bdev_close(desc); 690 691 cleanup: 692 free_rpc_bdev_set_qd_sampling_period(&req); 693 } 694 SPDK_RPC_REGISTER("bdev_set_qd_sampling_period", 695 rpc_bdev_set_qd_sampling_period, 696 SPDK_RPC_RUNTIME) 697 698 struct rpc_bdev_set_qos_limit { 699 char *name; 700 uint64_t limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES]; 701 }; 702 703 static void 704 free_rpc_bdev_set_qos_limit(struct rpc_bdev_set_qos_limit *r) 705 { 706 free(r->name); 707 } 708 709 static const struct spdk_json_object_decoder rpc_bdev_set_qos_limit_decoders[] = { 710 {"name", offsetof(struct rpc_bdev_set_qos_limit, name), spdk_json_decode_string}, 711 { 712 "rw_ios_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 713 limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT]), 714 spdk_json_decode_uint64, true 715 }, 716 { 717 "rw_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 718 limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT]), 719 spdk_json_decode_uint64, true 720 }, 721 { 722 "r_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 723 limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT]), 724 spdk_json_decode_uint64, true 725 }, 726 { 727 "w_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 728 limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT]), 729 spdk_json_decode_uint64, true 730 }, 731 }; 732 733 static void 734 rpc_bdev_set_qos_limit_complete(void *cb_arg, int status) 735 { 736 struct spdk_jsonrpc_request *request = cb_arg; 737 738 if (status != 0) { 739 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 740 "Failed to configure rate limit: %s", 741 spdk_strerror(-status)); 742 return; 743 } 744 745 spdk_jsonrpc_send_bool_response(request, true); 746 } 747 748 static void 749 rpc_bdev_set_qos_limit(struct spdk_jsonrpc_request *request, 750 const struct spdk_json_val *params) 751 { 752 struct rpc_bdev_set_qos_limit req = {NULL, {UINT64_MAX, UINT64_MAX, UINT64_MAX, UINT64_MAX}}; 753 struct spdk_bdev_desc *desc; 754 int i, rc; 755 756 if (spdk_json_decode_object(params, rpc_bdev_set_qos_limit_decoders, 757 SPDK_COUNTOF(rpc_bdev_set_qos_limit_decoders), 758 &req)) { 759 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 760 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 761 "spdk_json_decode_object failed"); 762 goto cleanup; 763 } 764 765 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 766 if (rc != 0) { 767 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 768 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 769 goto cleanup; 770 } 771 772 for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) { 773 if (req.limits[i] != UINT64_MAX) { 774 break; 775 } 776 } 777 if (i == SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES) { 778 SPDK_ERRLOG("no rate limits specified\n"); 779 spdk_bdev_close(desc); 780 spdk_jsonrpc_send_error_response(request, -EINVAL, "No rate limits specified"); 781 goto cleanup; 782 } 783 784 spdk_bdev_set_qos_rate_limits(spdk_bdev_desc_get_bdev(desc), req.limits, 785 rpc_bdev_set_qos_limit_complete, request); 786 787 spdk_bdev_close(desc); 788 789 cleanup: 790 free_rpc_bdev_set_qos_limit(&req); 791 } 792 793 SPDK_RPC_REGISTER("bdev_set_qos_limit", rpc_bdev_set_qos_limit, SPDK_RPC_RUNTIME) 794 795 /* SPDK_RPC_ENABLE_BDEV_HISTOGRAM */ 796 797 struct rpc_bdev_enable_histogram_request { 798 char *name; 799 bool enable; 800 }; 801 802 static void 803 free_rpc_bdev_enable_histogram_request(struct rpc_bdev_enable_histogram_request *r) 804 { 805 free(r->name); 806 } 807 808 static const struct spdk_json_object_decoder rpc_bdev_enable_histogram_request_decoders[] = { 809 {"name", offsetof(struct rpc_bdev_enable_histogram_request, name), spdk_json_decode_string}, 810 {"enable", offsetof(struct rpc_bdev_enable_histogram_request, enable), spdk_json_decode_bool}, 811 }; 812 813 static void 814 bdev_histogram_status_cb(void *cb_arg, int status) 815 { 816 struct spdk_jsonrpc_request *request = cb_arg; 817 818 spdk_jsonrpc_send_bool_response(request, status == 0); 819 } 820 821 static void 822 rpc_bdev_enable_histogram(struct spdk_jsonrpc_request *request, 823 const struct spdk_json_val *params) 824 { 825 struct rpc_bdev_enable_histogram_request req = {NULL}; 826 struct spdk_bdev_desc *desc; 827 int rc; 828 829 if (spdk_json_decode_object(params, rpc_bdev_enable_histogram_request_decoders, 830 SPDK_COUNTOF(rpc_bdev_enable_histogram_request_decoders), 831 &req)) { 832 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 833 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 834 "spdk_json_decode_object failed"); 835 goto cleanup; 836 } 837 838 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 839 if (rc != 0) { 840 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 841 goto cleanup; 842 } 843 844 spdk_bdev_histogram_enable(spdk_bdev_desc_get_bdev(desc), bdev_histogram_status_cb, 845 request, req.enable); 846 847 spdk_bdev_close(desc); 848 849 cleanup: 850 free_rpc_bdev_enable_histogram_request(&req); 851 } 852 853 SPDK_RPC_REGISTER("bdev_enable_histogram", rpc_bdev_enable_histogram, SPDK_RPC_RUNTIME) 854 855 /* SPDK_RPC_GET_BDEV_HISTOGRAM */ 856 857 struct rpc_bdev_get_histogram_request { 858 char *name; 859 }; 860 861 static const struct spdk_json_object_decoder rpc_bdev_get_histogram_request_decoders[] = { 862 {"name", offsetof(struct rpc_bdev_get_histogram_request, name), spdk_json_decode_string} 863 }; 864 865 static void 866 free_rpc_bdev_get_histogram_request(struct rpc_bdev_get_histogram_request *r) 867 { 868 free(r->name); 869 } 870 871 static void 872 _rpc_bdev_histogram_data_cb(void *cb_arg, int status, struct spdk_histogram_data *histogram) 873 { 874 struct spdk_jsonrpc_request *request = cb_arg; 875 struct spdk_json_write_ctx *w; 876 int rc; 877 char *encoded_histogram; 878 size_t src_len, dst_len; 879 880 881 if (status != 0) { 882 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 883 spdk_strerror(-status)); 884 goto invalid; 885 } 886 887 src_len = SPDK_HISTOGRAM_NUM_BUCKETS(histogram) * sizeof(uint64_t); 888 dst_len = spdk_base64_get_encoded_strlen(src_len) + 1; 889 890 encoded_histogram = malloc(dst_len); 891 if (encoded_histogram == NULL) { 892 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 893 spdk_strerror(ENOMEM)); 894 goto invalid; 895 } 896 897 rc = spdk_base64_encode(encoded_histogram, histogram->bucket, src_len); 898 if (rc != 0) { 899 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 900 spdk_strerror(-rc)); 901 goto free_encoded_histogram; 902 } 903 904 w = spdk_jsonrpc_begin_result(request); 905 spdk_json_write_object_begin(w); 906 spdk_json_write_named_string(w, "histogram", encoded_histogram); 907 spdk_json_write_named_int64(w, "bucket_shift", histogram->bucket_shift); 908 spdk_json_write_named_int64(w, "tsc_rate", spdk_get_ticks_hz()); 909 spdk_json_write_object_end(w); 910 spdk_jsonrpc_end_result(request, w); 911 912 free_encoded_histogram: 913 free(encoded_histogram); 914 invalid: 915 spdk_histogram_data_free(histogram); 916 } 917 918 static void 919 rpc_bdev_get_histogram(struct spdk_jsonrpc_request *request, 920 const struct spdk_json_val *params) 921 { 922 struct rpc_bdev_get_histogram_request req = {NULL}; 923 struct spdk_histogram_data *histogram; 924 struct spdk_bdev_desc *desc; 925 int rc; 926 927 if (spdk_json_decode_object(params, rpc_bdev_get_histogram_request_decoders, 928 SPDK_COUNTOF(rpc_bdev_get_histogram_request_decoders), 929 &req)) { 930 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 931 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 932 "spdk_json_decode_object failed"); 933 goto cleanup; 934 } 935 936 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 937 if (rc != 0) { 938 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 939 goto cleanup; 940 } 941 942 histogram = spdk_histogram_data_alloc(); 943 if (histogram == NULL) { 944 spdk_bdev_close(desc); 945 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 946 goto cleanup; 947 } 948 949 spdk_bdev_histogram_get(spdk_bdev_desc_get_bdev(desc), histogram, 950 _rpc_bdev_histogram_data_cb, request); 951 952 spdk_bdev_close(desc); 953 954 cleanup: 955 free_rpc_bdev_get_histogram_request(&req); 956 } 957 958 SPDK_RPC_REGISTER("bdev_get_histogram", rpc_bdev_get_histogram, SPDK_RPC_RUNTIME) 959