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