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