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