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_dump(struct spdk_json_write_ctx *w, 209 struct spdk_bdev *bdev, 210 struct spdk_bdev_io_stat *stat) 211 { 212 spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev)); 213 spdk_json_write_named_uint64(w, "bytes_read", stat->bytes_read); 214 spdk_json_write_named_uint64(w, "num_read_ops", stat->num_read_ops); 215 spdk_json_write_named_uint64(w, "bytes_written", stat->bytes_written); 216 spdk_json_write_named_uint64(w, "num_write_ops", stat->num_write_ops); 217 spdk_json_write_named_uint64(w, "bytes_unmapped", stat->bytes_unmapped); 218 spdk_json_write_named_uint64(w, "num_unmap_ops", stat->num_unmap_ops); 219 spdk_json_write_named_uint64(w, "read_latency_ticks", stat->read_latency_ticks); 220 spdk_json_write_named_uint64(w, "write_latency_ticks", stat->write_latency_ticks); 221 spdk_json_write_named_uint64(w, "unmap_latency_ticks", stat->unmap_latency_ticks); 222 } 223 224 static void 225 rpc_bdev_get_iostat_cb(struct spdk_bdev *bdev, 226 struct spdk_bdev_io_stat *stat, void *cb_arg, int rc) 227 { 228 struct rpc_bdev_iostat *_stat = cb_arg; 229 struct rpc_bdev_get_iostat_ctx *ctx = _stat->ctx; 230 struct spdk_json_write_ctx *w = ctx->w; 231 232 if (rc != 0 || ctx->rc != 0) { 233 if (ctx->rc == 0) { 234 ctx->rc = rc; 235 } 236 goto done; 237 } 238 239 assert(stat == &_stat->stat); 240 241 spdk_json_write_object_begin(w); 242 243 rpc_bdev_get_iostat_dump(w, bdev, stat); 244 245 if (spdk_bdev_get_qd_sampling_period(bdev)) { 246 spdk_json_write_named_uint64(w, "queue_depth_polling_period", 247 spdk_bdev_get_qd_sampling_period(bdev)); 248 249 spdk_json_write_named_uint64(w, "queue_depth", spdk_bdev_get_qd(bdev)); 250 251 spdk_json_write_named_uint64(w, "io_time", spdk_bdev_get_io_time(bdev)); 252 253 spdk_json_write_named_uint64(w, "weighted_io_time", 254 spdk_bdev_get_weighted_io_time(bdev)); 255 } 256 257 spdk_json_write_object_end(w); 258 259 done: 260 rpc_bdev_get_iostat_done(ctx); 261 262 spdk_bdev_close(_stat->desc); 263 free(_stat); 264 } 265 266 struct rpc_bdev_get_iostat { 267 char *name; 268 }; 269 270 static void 271 free_rpc_bdev_get_iostat(struct rpc_bdev_get_iostat *r) 272 { 273 free(r->name); 274 } 275 276 static const struct spdk_json_object_decoder rpc_bdev_get_iostat_decoders[] = { 277 {"name", offsetof(struct rpc_bdev_get_iostat, name), spdk_json_decode_string, true}, 278 }; 279 280 static int 281 _bdev_get_device_stat(void *_ctx, struct spdk_bdev *bdev) 282 { 283 struct rpc_bdev_get_iostat_ctx *ctx = _ctx; 284 struct rpc_bdev_iostat *_stat; 285 int rc; 286 287 _stat = calloc(1, sizeof(struct rpc_bdev_iostat)); 288 if (_stat == NULL) { 289 SPDK_ERRLOG("Failed to allocate rpc_bdev_iostat struct\n"); 290 return -ENOMEM; 291 } 292 293 rc = spdk_bdev_open_ext(spdk_bdev_get_name(bdev), false, dummy_bdev_event_cb, NULL, &_stat->desc); 294 if (rc != 0) { 295 free(_stat); 296 SPDK_ERRLOG("Failed to open bdev\n"); 297 return rc; 298 } 299 300 ctx->bdev_count++; 301 _stat->ctx = ctx; 302 spdk_bdev_get_device_stat(bdev, &_stat->stat, rpc_bdev_get_iostat_cb, _stat); 303 304 return 0; 305 } 306 307 static void 308 rpc_bdev_get_iostat(struct spdk_jsonrpc_request *request, 309 const struct spdk_json_val *params) 310 { 311 struct rpc_bdev_get_iostat req = {}; 312 struct spdk_bdev_desc *desc = NULL; 313 struct rpc_bdev_get_iostat_ctx *ctx; 314 struct rpc_bdev_iostat *_stat; 315 int rc; 316 317 if (params != NULL) { 318 if (spdk_json_decode_object(params, rpc_bdev_get_iostat_decoders, 319 SPDK_COUNTOF(rpc_bdev_get_iostat_decoders), 320 &req)) { 321 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 322 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 323 "spdk_json_decode_object failed"); 324 free_rpc_bdev_get_iostat(&req); 325 return; 326 } 327 328 if (req.name) { 329 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 330 if (rc != 0) { 331 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 332 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 333 free_rpc_bdev_get_iostat(&req); 334 return; 335 } 336 } 337 } 338 339 free_rpc_bdev_get_iostat(&req); 340 341 ctx = calloc(1, sizeof(struct rpc_bdev_get_iostat_ctx)); 342 if (ctx == NULL) { 343 SPDK_ERRLOG("Failed to allocate rpc_bdev_get_iostat_ctx struct\n"); 344 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 345 return; 346 } 347 348 /* 349 * Increment initial bdev_count so that it will never reach 0 in the middle 350 * of iterating. 351 */ 352 ctx->bdev_count++; 353 ctx->request = request; 354 355 if (desc != NULL) { 356 _stat = calloc(1, sizeof(struct rpc_bdev_iostat)); 357 if (_stat == NULL) { 358 SPDK_ERRLOG("Failed to allocate rpc_bdev_iostat struct\n"); 359 ctx->rc = -ENOMEM; 360 361 spdk_bdev_close(desc); 362 } else { 363 _stat->desc = desc; 364 365 ctx->bdev_count++; 366 _stat->ctx = ctx; 367 spdk_bdev_get_device_stat(spdk_bdev_desc_get_bdev(desc), &_stat->stat, 368 rpc_bdev_get_iostat_cb, _stat); 369 } 370 } else { 371 rc = spdk_for_each_bdev(ctx, _bdev_get_device_stat); 372 if (rc != 0 && ctx->rc == 0) { 373 ctx->rc = rc; 374 } 375 } 376 377 if (ctx->rc == 0) { 378 /* We want to fail the RPC for all failures. The callback function to 379 * spdk_bdev_get_device_stat() is executed after stack unwinding if successful. 380 * Hence defer starting RPC response until it is ensured that all 381 * spdk_bdev_get_device_stat() calls will succeed or there is no bdev. 382 */ 383 rpc_bdev_get_iostat_started(ctx); 384 } 385 386 rpc_bdev_get_iostat_done(ctx); 387 } 388 SPDK_RPC_REGISTER("bdev_get_iostat", rpc_bdev_get_iostat, SPDK_RPC_RUNTIME) 389 390 static int 391 rpc_dump_bdev_info(void *ctx, struct spdk_bdev *bdev) 392 { 393 struct spdk_json_write_ctx *w = ctx; 394 struct spdk_bdev_alias *tmp; 395 uint64_t qos_limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES]; 396 struct spdk_memory_domain **domains; 397 int i, rc; 398 399 spdk_json_write_object_begin(w); 400 401 spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev)); 402 403 spdk_json_write_named_array_begin(w, "aliases"); 404 405 TAILQ_FOREACH(tmp, spdk_bdev_get_aliases(bdev), tailq) { 406 spdk_json_write_string(w, tmp->alias.name); 407 } 408 409 spdk_json_write_array_end(w); 410 411 spdk_json_write_named_string(w, "product_name", spdk_bdev_get_product_name(bdev)); 412 413 spdk_json_write_named_uint32(w, "block_size", spdk_bdev_get_block_size(bdev)); 414 415 spdk_json_write_named_uint64(w, "num_blocks", spdk_bdev_get_num_blocks(bdev)); 416 417 if (!spdk_mem_all_zero(&bdev->uuid, sizeof(bdev->uuid))) { 418 char uuid_str[SPDK_UUID_STRING_LEN]; 419 420 spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &bdev->uuid); 421 spdk_json_write_named_string(w, "uuid", uuid_str); 422 } 423 424 if (spdk_bdev_get_md_size(bdev) != 0) { 425 spdk_json_write_named_uint32(w, "md_size", spdk_bdev_get_md_size(bdev)); 426 spdk_json_write_named_bool(w, "md_interleave", spdk_bdev_is_md_interleaved(bdev)); 427 spdk_json_write_named_uint32(w, "dif_type", spdk_bdev_get_dif_type(bdev)); 428 if (spdk_bdev_get_dif_type(bdev) != SPDK_DIF_DISABLE) { 429 spdk_json_write_named_bool(w, "dif_is_head_of_md", spdk_bdev_is_dif_head_of_md(bdev)); 430 spdk_json_write_named_object_begin(w, "enabled_dif_check_types"); 431 spdk_json_write_named_bool(w, "reftag", 432 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG)); 433 spdk_json_write_named_bool(w, "apptag", 434 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_APPTAG)); 435 spdk_json_write_named_bool(w, "guard", 436 spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD)); 437 spdk_json_write_object_end(w); 438 } 439 } 440 441 spdk_json_write_named_object_begin(w, "assigned_rate_limits"); 442 spdk_bdev_get_qos_rate_limits(bdev, qos_limits); 443 for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) { 444 spdk_json_write_named_uint64(w, spdk_bdev_get_qos_rpc_type(i), qos_limits[i]); 445 } 446 spdk_json_write_object_end(w); 447 448 spdk_json_write_named_bool(w, "claimed", (bdev->internal.claim_module != NULL)); 449 450 spdk_json_write_named_bool(w, "zoned", bdev->zoned); 451 if (bdev->zoned) { 452 spdk_json_write_named_uint64(w, "zone_size", bdev->zone_size); 453 spdk_json_write_named_uint64(w, "max_open_zones", bdev->max_open_zones); 454 spdk_json_write_named_uint64(w, "optimal_open_zones", bdev->optimal_open_zones); 455 } 456 457 spdk_json_write_named_object_begin(w, "supported_io_types"); 458 spdk_json_write_named_bool(w, "read", 459 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_READ)); 460 spdk_json_write_named_bool(w, "write", 461 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_WRITE)); 462 spdk_json_write_named_bool(w, "unmap", 463 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)); 464 spdk_json_write_named_bool(w, "write_zeroes", 465 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_WRITE_ZEROES)); 466 spdk_json_write_named_bool(w, "flush", 467 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_FLUSH)); 468 spdk_json_write_named_bool(w, "reset", 469 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_RESET)); 470 spdk_json_write_named_bool(w, "compare", 471 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_COMPARE)); 472 spdk_json_write_named_bool(w, "compare_and_write", 473 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_COMPARE_AND_WRITE)); 474 spdk_json_write_named_bool(w, "abort", 475 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_ABORT)); 476 spdk_json_write_named_bool(w, "nvme_admin", 477 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_NVME_ADMIN)); 478 spdk_json_write_named_bool(w, "nvme_io", 479 spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_NVME_IO)); 480 spdk_json_write_object_end(w); 481 482 rc = spdk_bdev_get_memory_domains(bdev, NULL, 0); 483 if (rc > 0) { 484 domains = calloc(rc, sizeof(struct spdk_memory_domain *)); 485 if (domains) { 486 i = spdk_bdev_get_memory_domains(bdev, domains, rc); 487 if (i == rc) { 488 spdk_json_write_named_array_begin(w, "memory_domains"); 489 for (i = 0; i < rc; i++) { 490 spdk_json_write_object_begin(w); 491 spdk_json_write_named_string(w, "dma_device_id", spdk_memory_domain_get_dma_device_id(domains[i])); 492 spdk_json_write_named_int32(w, "dma_device_type", 493 spdk_memory_domain_get_dma_device_type(domains[i])); 494 spdk_json_write_object_end(w); 495 } 496 spdk_json_write_array_end(w); 497 } else { 498 SPDK_ERRLOG("Unexpected number of memory domains %d (should be %d)\n", i, rc); 499 } 500 501 free(domains); 502 } else { 503 SPDK_ERRLOG("Memory allocation failed\n"); 504 } 505 } 506 507 spdk_json_write_named_object_begin(w, "driver_specific"); 508 spdk_bdev_dump_info_json(bdev, w); 509 spdk_json_write_object_end(w); 510 511 spdk_json_write_object_end(w); 512 513 return 0; 514 } 515 516 struct rpc_bdev_get_bdevs { 517 char *name; 518 uint64_t timeout; 519 }; 520 521 struct rpc_bdev_get_bdevs_ctx { 522 struct rpc_bdev_get_bdevs rpc; 523 struct spdk_jsonrpc_request *request; 524 struct spdk_poller *poller; 525 uint64_t timeout_ticks; 526 }; 527 528 static void 529 free_rpc_bdev_get_bdevs(struct rpc_bdev_get_bdevs *r) 530 { 531 free(r->name); 532 } 533 534 static const struct spdk_json_object_decoder rpc_bdev_get_bdevs_decoders[] = { 535 {"name", offsetof(struct rpc_bdev_get_bdevs, name), spdk_json_decode_string, true}, 536 {"timeout", offsetof(struct rpc_bdev_get_bdevs, timeout), spdk_json_decode_uint64, true}, 537 }; 538 539 static int 540 get_bdevs_poller(void *_ctx) 541 { 542 struct rpc_bdev_get_bdevs_ctx *ctx = _ctx; 543 struct spdk_json_write_ctx *w; 544 struct spdk_bdev_desc *desc; 545 int rc; 546 547 rc = spdk_bdev_open_ext(ctx->rpc.name, false, dummy_bdev_event_cb, NULL, &desc); 548 if (rc != 0 && spdk_get_ticks() < ctx->timeout_ticks) { 549 return SPDK_POLLER_BUSY; 550 } 551 552 if (rc != 0) { 553 SPDK_ERRLOG("Timed out while waiting for bdev '%s' to appear\n", ctx->rpc.name); 554 spdk_jsonrpc_send_error_response(ctx->request, -ENODEV, spdk_strerror(ENODEV)); 555 } else { 556 w = spdk_jsonrpc_begin_result(ctx->request); 557 spdk_json_write_array_begin(w); 558 rpc_dump_bdev_info(w, spdk_bdev_desc_get_bdev(desc)); 559 spdk_json_write_array_end(w); 560 spdk_jsonrpc_end_result(ctx->request, w); 561 562 spdk_bdev_close(desc); 563 } 564 565 spdk_poller_unregister(&ctx->poller); 566 free_rpc_bdev_get_bdevs(&ctx->rpc); 567 free(ctx); 568 569 return SPDK_POLLER_BUSY; 570 } 571 572 static void 573 rpc_bdev_get_bdevs(struct spdk_jsonrpc_request *request, 574 const struct spdk_json_val *params) 575 { 576 struct rpc_bdev_get_bdevs req = {}; 577 struct rpc_bdev_get_bdevs_ctx *ctx; 578 struct spdk_json_write_ctx *w; 579 struct spdk_bdev_desc *desc = NULL; 580 int rc; 581 582 if (params && spdk_json_decode_object(params, rpc_bdev_get_bdevs_decoders, 583 SPDK_COUNTOF(rpc_bdev_get_bdevs_decoders), 584 &req)) { 585 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 586 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 587 "spdk_json_decode_object failed"); 588 free_rpc_bdev_get_bdevs(&req); 589 return; 590 } 591 592 if (req.name) { 593 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 594 if (rc != 0) { 595 if (req.timeout == 0) { 596 SPDK_ERRLOG("bdev '%s' does not exist\n", req.name); 597 spdk_jsonrpc_send_error_response(request, -ENODEV, spdk_strerror(ENODEV)); 598 free_rpc_bdev_get_bdevs(&req); 599 return; 600 } 601 602 ctx = calloc(1, sizeof(*ctx)); 603 if (ctx == NULL) { 604 SPDK_ERRLOG("Failed to allocate bdev_get_bdevs context\n"); 605 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 606 free_rpc_bdev_get_bdevs(&req); 607 return; 608 } 609 610 ctx->poller = SPDK_POLLER_REGISTER(get_bdevs_poller, ctx, 10 * 1000); 611 if (ctx->poller == NULL) { 612 SPDK_ERRLOG("Failed to register bdev_get_bdevs poller\n"); 613 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 614 free_rpc_bdev_get_bdevs(&req); 615 free(ctx); 616 return; 617 } 618 619 memcpy(&ctx->rpc, &req, sizeof(req)); 620 ctx->timeout_ticks = spdk_get_ticks() + req.timeout * 621 spdk_get_ticks_hz() / 1000ull; 622 ctx->request = request; 623 return; 624 } 625 } 626 627 free_rpc_bdev_get_bdevs(&req); 628 w = spdk_jsonrpc_begin_result(request); 629 spdk_json_write_array_begin(w); 630 631 if (desc != NULL) { 632 rpc_dump_bdev_info(w, spdk_bdev_desc_get_bdev(desc)); 633 spdk_bdev_close(desc); 634 } else { 635 spdk_for_each_bdev(w, rpc_dump_bdev_info); 636 } 637 638 spdk_json_write_array_end(w); 639 640 spdk_jsonrpc_end_result(request, w); 641 } 642 SPDK_RPC_REGISTER("bdev_get_bdevs", rpc_bdev_get_bdevs, SPDK_RPC_RUNTIME) 643 644 struct rpc_bdev_set_qd_sampling_period { 645 char *name; 646 uint64_t period; 647 }; 648 649 static void 650 free_rpc_bdev_set_qd_sampling_period(struct rpc_bdev_set_qd_sampling_period *r) 651 { 652 free(r->name); 653 } 654 655 static const struct spdk_json_object_decoder 656 rpc_bdev_set_qd_sampling_period_decoders[] = { 657 {"name", offsetof(struct rpc_bdev_set_qd_sampling_period, name), spdk_json_decode_string}, 658 {"period", offsetof(struct rpc_bdev_set_qd_sampling_period, period), spdk_json_decode_uint64}, 659 }; 660 661 static void 662 rpc_bdev_set_qd_sampling_period(struct spdk_jsonrpc_request *request, 663 const struct spdk_json_val *params) 664 { 665 struct rpc_bdev_set_qd_sampling_period req = {0}; 666 struct spdk_bdev_desc *desc; 667 int rc; 668 669 if (spdk_json_decode_object(params, rpc_bdev_set_qd_sampling_period_decoders, 670 SPDK_COUNTOF(rpc_bdev_set_qd_sampling_period_decoders), 671 &req)) { 672 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 673 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 674 "spdk_json_decode_object failed"); 675 goto cleanup; 676 } 677 678 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 679 if (rc != 0) { 680 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 681 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 682 goto cleanup; 683 } 684 685 spdk_bdev_set_qd_sampling_period(spdk_bdev_desc_get_bdev(desc), req.period); 686 spdk_jsonrpc_send_bool_response(request, true); 687 688 spdk_bdev_close(desc); 689 690 cleanup: 691 free_rpc_bdev_set_qd_sampling_period(&req); 692 } 693 SPDK_RPC_REGISTER("bdev_set_qd_sampling_period", 694 rpc_bdev_set_qd_sampling_period, 695 SPDK_RPC_RUNTIME) 696 697 struct rpc_bdev_set_qos_limit { 698 char *name; 699 uint64_t limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES]; 700 }; 701 702 static void 703 free_rpc_bdev_set_qos_limit(struct rpc_bdev_set_qos_limit *r) 704 { 705 free(r->name); 706 } 707 708 static const struct spdk_json_object_decoder rpc_bdev_set_qos_limit_decoders[] = { 709 {"name", offsetof(struct rpc_bdev_set_qos_limit, name), spdk_json_decode_string}, 710 { 711 "rw_ios_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 712 limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT]), 713 spdk_json_decode_uint64, true 714 }, 715 { 716 "rw_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 717 limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT]), 718 spdk_json_decode_uint64, true 719 }, 720 { 721 "r_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 722 limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT]), 723 spdk_json_decode_uint64, true 724 }, 725 { 726 "w_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit, 727 limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT]), 728 spdk_json_decode_uint64, true 729 }, 730 }; 731 732 static void 733 rpc_bdev_set_qos_limit_complete(void *cb_arg, int status) 734 { 735 struct spdk_jsonrpc_request *request = cb_arg; 736 737 if (status != 0) { 738 spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 739 "Failed to configure rate limit: %s", 740 spdk_strerror(-status)); 741 return; 742 } 743 744 spdk_jsonrpc_send_bool_response(request, true); 745 } 746 747 static void 748 rpc_bdev_set_qos_limit(struct spdk_jsonrpc_request *request, 749 const struct spdk_json_val *params) 750 { 751 struct rpc_bdev_set_qos_limit req = {NULL, {UINT64_MAX, UINT64_MAX, UINT64_MAX, UINT64_MAX}}; 752 struct spdk_bdev_desc *desc; 753 int i, rc; 754 755 if (spdk_json_decode_object(params, rpc_bdev_set_qos_limit_decoders, 756 SPDK_COUNTOF(rpc_bdev_set_qos_limit_decoders), 757 &req)) { 758 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 759 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 760 "spdk_json_decode_object failed"); 761 goto cleanup; 762 } 763 764 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 765 if (rc != 0) { 766 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc); 767 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 768 goto cleanup; 769 } 770 771 for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) { 772 if (req.limits[i] != UINT64_MAX) { 773 break; 774 } 775 } 776 if (i == SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES) { 777 SPDK_ERRLOG("no rate limits specified\n"); 778 spdk_bdev_close(desc); 779 spdk_jsonrpc_send_error_response(request, -EINVAL, "No rate limits specified"); 780 goto cleanup; 781 } 782 783 spdk_bdev_set_qos_rate_limits(spdk_bdev_desc_get_bdev(desc), req.limits, 784 rpc_bdev_set_qos_limit_complete, request); 785 786 spdk_bdev_close(desc); 787 788 cleanup: 789 free_rpc_bdev_set_qos_limit(&req); 790 } 791 792 SPDK_RPC_REGISTER("bdev_set_qos_limit", rpc_bdev_set_qos_limit, SPDK_RPC_RUNTIME) 793 794 /* SPDK_RPC_ENABLE_BDEV_HISTOGRAM */ 795 796 struct rpc_bdev_enable_histogram_request { 797 char *name; 798 bool enable; 799 }; 800 801 static void 802 free_rpc_bdev_enable_histogram_request(struct rpc_bdev_enable_histogram_request *r) 803 { 804 free(r->name); 805 } 806 807 static const struct spdk_json_object_decoder rpc_bdev_enable_histogram_request_decoders[] = { 808 {"name", offsetof(struct rpc_bdev_enable_histogram_request, name), spdk_json_decode_string}, 809 {"enable", offsetof(struct rpc_bdev_enable_histogram_request, enable), spdk_json_decode_bool}, 810 }; 811 812 static void 813 bdev_histogram_status_cb(void *cb_arg, int status) 814 { 815 struct spdk_jsonrpc_request *request = cb_arg; 816 817 spdk_jsonrpc_send_bool_response(request, status == 0); 818 } 819 820 static void 821 rpc_bdev_enable_histogram(struct spdk_jsonrpc_request *request, 822 const struct spdk_json_val *params) 823 { 824 struct rpc_bdev_enable_histogram_request req = {NULL}; 825 struct spdk_bdev_desc *desc; 826 int rc; 827 828 if (spdk_json_decode_object(params, rpc_bdev_enable_histogram_request_decoders, 829 SPDK_COUNTOF(rpc_bdev_enable_histogram_request_decoders), 830 &req)) { 831 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 832 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 833 "spdk_json_decode_object failed"); 834 goto cleanup; 835 } 836 837 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 838 if (rc != 0) { 839 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 840 goto cleanup; 841 } 842 843 spdk_bdev_histogram_enable(spdk_bdev_desc_get_bdev(desc), bdev_histogram_status_cb, 844 request, req.enable); 845 846 spdk_bdev_close(desc); 847 848 cleanup: 849 free_rpc_bdev_enable_histogram_request(&req); 850 } 851 852 SPDK_RPC_REGISTER("bdev_enable_histogram", rpc_bdev_enable_histogram, SPDK_RPC_RUNTIME) 853 854 /* SPDK_RPC_GET_BDEV_HISTOGRAM */ 855 856 struct rpc_bdev_get_histogram_request { 857 char *name; 858 }; 859 860 static const struct spdk_json_object_decoder rpc_bdev_get_histogram_request_decoders[] = { 861 {"name", offsetof(struct rpc_bdev_get_histogram_request, name), spdk_json_decode_string} 862 }; 863 864 static void 865 free_rpc_bdev_get_histogram_request(struct rpc_bdev_get_histogram_request *r) 866 { 867 free(r->name); 868 } 869 870 static void 871 _rpc_bdev_histogram_data_cb(void *cb_arg, int status, struct spdk_histogram_data *histogram) 872 { 873 struct spdk_jsonrpc_request *request = cb_arg; 874 struct spdk_json_write_ctx *w; 875 int rc; 876 char *encoded_histogram; 877 size_t src_len, dst_len; 878 879 880 if (status != 0) { 881 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 882 spdk_strerror(-status)); 883 goto invalid; 884 } 885 886 src_len = SPDK_HISTOGRAM_NUM_BUCKETS(histogram) * sizeof(uint64_t); 887 dst_len = spdk_base64_get_encoded_strlen(src_len) + 1; 888 889 encoded_histogram = malloc(dst_len); 890 if (encoded_histogram == NULL) { 891 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 892 spdk_strerror(ENOMEM)); 893 goto invalid; 894 } 895 896 rc = spdk_base64_encode(encoded_histogram, histogram->bucket, src_len); 897 if (rc != 0) { 898 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 899 spdk_strerror(-rc)); 900 goto free_encoded_histogram; 901 } 902 903 w = spdk_jsonrpc_begin_result(request); 904 spdk_json_write_object_begin(w); 905 spdk_json_write_named_string(w, "histogram", encoded_histogram); 906 spdk_json_write_named_int64(w, "bucket_shift", histogram->bucket_shift); 907 spdk_json_write_named_int64(w, "tsc_rate", spdk_get_ticks_hz()); 908 spdk_json_write_object_end(w); 909 spdk_jsonrpc_end_result(request, w); 910 911 free_encoded_histogram: 912 free(encoded_histogram); 913 invalid: 914 spdk_histogram_data_free(histogram); 915 } 916 917 static void 918 rpc_bdev_get_histogram(struct spdk_jsonrpc_request *request, 919 const struct spdk_json_val *params) 920 { 921 struct rpc_bdev_get_histogram_request req = {NULL}; 922 struct spdk_histogram_data *histogram; 923 struct spdk_bdev_desc *desc; 924 int rc; 925 926 if (spdk_json_decode_object(params, rpc_bdev_get_histogram_request_decoders, 927 SPDK_COUNTOF(rpc_bdev_get_histogram_request_decoders), 928 &req)) { 929 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 930 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 931 "spdk_json_decode_object failed"); 932 goto cleanup; 933 } 934 935 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc); 936 if (rc != 0) { 937 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 938 goto cleanup; 939 } 940 941 histogram = spdk_histogram_data_alloc(); 942 if (histogram == NULL) { 943 spdk_bdev_close(desc); 944 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 945 goto cleanup; 946 } 947 948 spdk_bdev_histogram_get(spdk_bdev_desc_get_bdev(desc), histogram, 949 _rpc_bdev_histogram_data_cb, request); 950 951 spdk_bdev_close(desc); 952 953 cleanup: 954 free_rpc_bdev_get_histogram_request(&req); 955 } 956 957 SPDK_RPC_REGISTER("bdev_get_histogram", rpc_bdev_get_histogram, SPDK_RPC_RUNTIME) 958