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