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