Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2018 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/bdev.h"
8 : :
9 : : #include "spdk/env.h"
10 : : #include "spdk/rpc.h"
11 : : #include "spdk/util.h"
12 : : #include "spdk/string.h"
13 : : #include "spdk/base64.h"
14 : : #include "spdk/bdev_module.h"
15 : : #include "spdk/dma.h"
16 : :
17 : : #include "spdk/log.h"
18 : :
19 : : #include "bdev_internal.h"
20 : :
21 : : static void
22 : 0 : dummy_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *ctx)
23 : : {
24 : 0 : }
25 : :
26 : : static const struct spdk_json_object_decoder rpc_set_bdev_opts_decoders[] = {
27 : : {"bdev_io_pool_size", offsetof(struct spdk_bdev_opts, bdev_io_pool_size), spdk_json_decode_uint32, true},
28 : : {"bdev_io_cache_size", offsetof(struct spdk_bdev_opts, bdev_io_cache_size), spdk_json_decode_uint32, true},
29 : : {"bdev_auto_examine", offsetof(struct spdk_bdev_opts, bdev_auto_examine), spdk_json_decode_bool, true},
30 : : {"iobuf_small_cache_size", offsetof(struct spdk_bdev_opts, iobuf_small_cache_size), spdk_json_decode_uint32, true},
31 : : {"iobuf_large_cache_size", offsetof(struct spdk_bdev_opts, iobuf_large_cache_size), spdk_json_decode_uint32, true},
32 : : };
33 : :
34 : : static void
35 : 282 : rpc_bdev_set_options(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params)
36 : : {
37 : 146 : struct spdk_bdev_opts opts;
38 : : int rc;
39 : :
40 : 282 : spdk_bdev_get_opts(&opts, sizeof(opts));
41 [ + - ]: 282 : if (params != NULL) {
42 [ - + ]: 282 : if (spdk_json_decode_object(params, rpc_set_bdev_opts_decoders,
43 : : SPDK_COUNTOF(rpc_set_bdev_opts_decoders), &opts)) {
44 : 0 : SPDK_ERRLOG("spdk_json_decode_object() failed\n");
45 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
46 : : "Invalid parameters");
47 : 0 : return;
48 : : }
49 : : }
50 : :
51 : 282 : rc = spdk_bdev_set_opts(&opts);
52 [ - + ]: 282 : if (rc != 0) {
53 : 0 : spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
54 : : "Pool size %" PRIu32 " too small for cache size %" PRIu32,
55 : : opts.bdev_io_pool_size, opts.bdev_io_cache_size);
56 : 0 : return;
57 : : }
58 : :
59 : 282 : spdk_jsonrpc_send_bool_response(request, true);
60 : : }
61 : 2417 : SPDK_RPC_REGISTER("bdev_set_options", rpc_bdev_set_options, SPDK_RPC_STARTUP)
62 : :
63 : : static void
64 : 1337 : rpc_bdev_wait_for_examine_cpl(void *arg)
65 : : {
66 : 1337 : struct spdk_jsonrpc_request *request = arg;
67 : :
68 : 1337 : spdk_jsonrpc_send_bool_response(request, true);
69 : 1337 : }
70 : :
71 : : static void
72 : 1337 : rpc_bdev_wait_for_examine(struct spdk_jsonrpc_request *request,
73 : : const struct spdk_json_val *params)
74 : : {
75 : : int rc;
76 : :
77 [ - + ]: 1337 : if (params != NULL) {
78 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
79 : : "bdev_wait_for_examine requires no parameters");
80 : 0 : return;
81 : : }
82 : :
83 : 1337 : rc = spdk_bdev_wait_for_examine(rpc_bdev_wait_for_examine_cpl, request);
84 [ - + ]: 1337 : if (rc != 0) {
85 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
86 : : }
87 : : }
88 : 2417 : SPDK_RPC_REGISTER("bdev_wait_for_examine", rpc_bdev_wait_for_examine, SPDK_RPC_RUNTIME)
89 : :
90 : : struct rpc_bdev_examine {
91 : : char *name;
92 : : };
93 : :
94 : : static void
95 : 0 : free_rpc_bdev_examine(struct rpc_bdev_examine *r)
96 : : {
97 : 0 : free(r->name);
98 : 0 : }
99 : :
100 : : static const struct spdk_json_object_decoder rpc_examine_bdev_decoders[] = {
101 : : {"name", offsetof(struct rpc_bdev_examine, name), spdk_json_decode_string},
102 : : };
103 : :
104 : : static void
105 : 0 : rpc_bdev_examine_bdev(struct spdk_jsonrpc_request *request,
106 : : const struct spdk_json_val *params)
107 : : {
108 : 0 : struct rpc_bdev_examine req = {NULL};
109 : : int rc;
110 : :
111 [ # # ]: 0 : if (spdk_json_decode_object(params, rpc_examine_bdev_decoders,
112 : : SPDK_COUNTOF(rpc_examine_bdev_decoders),
113 : : &req)) {
114 : 0 : SPDK_ERRLOG("spdk_json_decode_object() failed\n");
115 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
116 : : "spdk_json_decode_object failed");
117 : 0 : goto cleanup;
118 : : }
119 : :
120 : 0 : rc = spdk_bdev_examine(req.name);
121 [ # # ]: 0 : if (rc != 0) {
122 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
123 : 0 : goto cleanup;
124 : : }
125 : :
126 : 0 : spdk_jsonrpc_send_bool_response(request, true);
127 : :
128 : 0 : cleanup:
129 : 0 : free_rpc_bdev_examine(&req);
130 : 0 : }
131 : 2417 : SPDK_RPC_REGISTER("bdev_examine", rpc_bdev_examine_bdev, SPDK_RPC_RUNTIME)
132 : :
133 : : struct rpc_get_iostat_ctx {
134 : : int bdev_count;
135 : : int rc;
136 : : struct spdk_jsonrpc_request *request;
137 : : struct spdk_json_write_ctx *w;
138 : : bool per_channel;
139 : : };
140 : :
141 : : struct bdev_get_iostat_ctx {
142 : : struct spdk_bdev_io_stat *stat;
143 : : struct rpc_get_iostat_ctx *rpc_ctx;
144 : : struct spdk_bdev_desc *desc;
145 : : };
146 : :
147 : : static void
148 : 197 : rpc_get_iostat_started(struct rpc_get_iostat_ctx *rpc_ctx)
149 : : {
150 : 197 : rpc_ctx->w = spdk_jsonrpc_begin_result(rpc_ctx->request);
151 : :
152 : 197 : spdk_json_write_object_begin(rpc_ctx->w);
153 : 197 : spdk_json_write_named_uint64(rpc_ctx->w, "tick_rate", spdk_get_ticks_hz());
154 : 197 : spdk_json_write_named_uint64(rpc_ctx->w, "ticks", spdk_get_ticks());
155 : 197 : }
156 : :
157 : : static void
158 : 519 : rpc_get_iostat_done(struct rpc_get_iostat_ctx *rpc_ctx)
159 : : {
160 [ + + ]: 519 : if (--rpc_ctx->bdev_count != 0) {
161 : 322 : return;
162 : : }
163 : :
164 [ + - ]: 197 : if (rpc_ctx->rc == 0) {
165 : 197 : spdk_json_write_array_end(rpc_ctx->w);
166 : 197 : spdk_json_write_object_end(rpc_ctx->w);
167 : 197 : spdk_jsonrpc_end_result(rpc_ctx->request, rpc_ctx->w);
168 : : } else {
169 : : /* Return error response after processing all specified bdevs
170 : : * completed or failed.
171 : : */
172 : 0 : spdk_jsonrpc_send_error_response(rpc_ctx->request, rpc_ctx->rc,
173 : 0 : spdk_strerror(-rpc_ctx->rc));
174 : : }
175 : :
176 : 197 : free(rpc_ctx);
177 : : }
178 : :
179 : : static struct bdev_get_iostat_ctx *
180 : 322 : bdev_iostat_ctx_alloc(bool iostat_ext)
181 : : {
182 : : struct bdev_get_iostat_ctx *ctx;
183 : :
184 : 322 : ctx = calloc(1, sizeof(struct bdev_get_iostat_ctx));
185 [ - + ]: 322 : if (ctx == NULL) {
186 : 0 : return NULL;
187 : : }
188 : :
189 : 322 : ctx->stat = bdev_alloc_io_stat(iostat_ext);
190 [ - + ]: 322 : if (ctx->stat == NULL) {
191 : 0 : free(ctx);
192 : 0 : return NULL;
193 : : }
194 : :
195 : 322 : return ctx;
196 : : }
197 : :
198 : : static void
199 : 322 : bdev_iostat_ctx_free(struct bdev_get_iostat_ctx *ctx)
200 : : {
201 : 322 : bdev_free_io_stat(ctx->stat);
202 : 322 : free(ctx);
203 : 322 : }
204 : :
205 : : static void
206 : 317 : bdev_get_iostat_done(struct spdk_bdev *bdev, struct spdk_bdev_io_stat *stat,
207 : : void *cb_arg, int rc)
208 : : {
209 : 317 : struct bdev_get_iostat_ctx *bdev_ctx = cb_arg;
210 : 317 : struct rpc_get_iostat_ctx *rpc_ctx = bdev_ctx->rpc_ctx;
211 : 317 : struct spdk_json_write_ctx *w = rpc_ctx->w;
212 : :
213 [ + - - + ]: 317 : if (rc != 0 || rpc_ctx->rc != 0) {
214 [ # # ]: 0 : if (rpc_ctx->rc == 0) {
215 : 0 : rpc_ctx->rc = rc;
216 : : }
217 : 0 : goto done;
218 : : }
219 : :
220 [ - + ]: 317 : assert(stat == bdev_ctx->stat);
221 : :
222 : 317 : spdk_json_write_object_begin(w);
223 : :
224 : 317 : spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev));
225 : :
226 : 317 : spdk_bdev_dump_io_stat_json(stat, w);
227 : :
228 [ + + ]: 317 : if (spdk_bdev_get_qd_sampling_period(bdev)) {
229 : 5 : spdk_json_write_named_uint64(w, "queue_depth_polling_period",
230 : : spdk_bdev_get_qd_sampling_period(bdev));
231 : :
232 : 5 : spdk_json_write_named_uint64(w, "queue_depth", spdk_bdev_get_qd(bdev));
233 : :
234 : 5 : spdk_json_write_named_uint64(w, "io_time", spdk_bdev_get_io_time(bdev));
235 : :
236 : 5 : spdk_json_write_named_uint64(w, "weighted_io_time",
237 : : spdk_bdev_get_weighted_io_time(bdev));
238 : : }
239 : :
240 [ + + ]: 317 : if (bdev->fn_table->dump_device_stat_json) {
241 : 24 : spdk_json_write_named_object_begin(w, "driver_specific");
242 : 24 : bdev->fn_table->dump_device_stat_json(bdev->ctxt, w);
243 : 24 : spdk_json_write_object_end(w);
244 : : }
245 : :
246 : 317 : spdk_json_write_object_end(w);
247 : :
248 : 317 : done:
249 : 317 : rpc_get_iostat_done(rpc_ctx);
250 : :
251 : 317 : spdk_bdev_close(bdev_ctx->desc);
252 : 317 : bdev_iostat_ctx_free(bdev_ctx);
253 : 317 : }
254 : :
255 : : static int
256 : 250 : bdev_get_iostat(void *ctx, struct spdk_bdev *bdev)
257 : : {
258 : 250 : struct rpc_get_iostat_ctx *rpc_ctx = ctx;
259 : : struct bdev_get_iostat_ctx *bdev_ctx;
260 : : int rc;
261 : :
262 : 250 : bdev_ctx = bdev_iostat_ctx_alloc(true);
263 [ - + ]: 250 : if (bdev_ctx == NULL) {
264 : 0 : SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n");
265 : 0 : return -ENOMEM;
266 : : }
267 : :
268 : 250 : rc = spdk_bdev_open_ext(spdk_bdev_get_name(bdev), false, dummy_bdev_event_cb, NULL,
269 : : &bdev_ctx->desc);
270 [ - + ]: 250 : if (rc != 0) {
271 : 0 : bdev_iostat_ctx_free(bdev_ctx);
272 : 0 : SPDK_ERRLOG("Failed to open bdev\n");
273 : 0 : return rc;
274 : : }
275 : :
276 : 250 : rpc_ctx->bdev_count++;
277 : 250 : bdev_ctx->rpc_ctx = rpc_ctx;
278 : 250 : spdk_bdev_get_device_stat(bdev, bdev_ctx->stat, bdev_get_iostat_done, bdev_ctx);
279 : :
280 : 250 : return 0;
281 : : }
282 : :
283 : : static void
284 : 5 : bdev_get_per_channel_stat_done(struct spdk_bdev *bdev, void *ctx, int status)
285 : : {
286 : 5 : struct bdev_get_iostat_ctx *bdev_ctx = ctx;
287 : :
288 : 5 : rpc_get_iostat_done(bdev_ctx->rpc_ctx);
289 : :
290 : 5 : spdk_bdev_close(bdev_ctx->desc);
291 : :
292 : 5 : bdev_iostat_ctx_free(bdev_ctx);
293 : 5 : }
294 : :
295 : : static void
296 : 10 : bdev_get_per_channel_stat(struct spdk_bdev_channel_iter *i, struct spdk_bdev *bdev,
297 : : struct spdk_io_channel *ch, void *ctx)
298 : : {
299 : 10 : struct bdev_get_iostat_ctx *bdev_ctx = ctx;
300 : 10 : struct spdk_json_write_ctx *w = bdev_ctx->rpc_ctx->w;
301 : :
302 : 10 : spdk_bdev_get_io_stat(bdev, ch, bdev_ctx->stat);
303 : :
304 : 10 : spdk_json_write_object_begin(w);
305 : 10 : spdk_json_write_named_uint64(w, "thread_id", spdk_thread_get_id(spdk_get_thread()));
306 : 10 : spdk_bdev_dump_io_stat_json(bdev_ctx->stat, w);
307 : 10 : spdk_json_write_object_end(w);
308 : :
309 : 10 : spdk_bdev_for_each_channel_continue(i, 0);
310 : 10 : }
311 : :
312 : : struct rpc_bdev_get_iostat {
313 : : char *name;
314 : : bool per_channel;
315 : : };
316 : :
317 : : static void
318 : 197 : free_rpc_bdev_get_iostat(struct rpc_bdev_get_iostat *r)
319 : : {
320 : 197 : free(r->name);
321 : 197 : }
322 : :
323 : : static const struct spdk_json_object_decoder rpc_bdev_get_iostat_decoders[] = {
324 : : {"name", offsetof(struct rpc_bdev_get_iostat, name), spdk_json_decode_string, true},
325 : : {"per_channel", offsetof(struct rpc_bdev_get_iostat, per_channel), spdk_json_decode_bool, true},
326 : : };
327 : :
328 : : static void
329 : 197 : rpc_bdev_get_iostat(struct spdk_jsonrpc_request *request,
330 : : const struct spdk_json_val *params)
331 : : {
332 : 197 : struct rpc_bdev_get_iostat req = {};
333 : 197 : struct spdk_bdev_desc *desc = NULL;
334 : : struct rpc_get_iostat_ctx *rpc_ctx;
335 : : struct bdev_get_iostat_ctx *bdev_ctx;
336 : : struct spdk_bdev *bdev;
337 : : int rc;
338 : :
339 [ + + ]: 197 : if (params != NULL) {
340 [ - + ]: 72 : if (spdk_json_decode_object(params, rpc_bdev_get_iostat_decoders,
341 : : SPDK_COUNTOF(rpc_bdev_get_iostat_decoders),
342 : : &req)) {
343 : 0 : SPDK_ERRLOG("spdk_json_decode_object failed\n");
344 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
345 : : "spdk_json_decode_object failed");
346 : 0 : free_rpc_bdev_get_iostat(&req);
347 : 1 : return;
348 : : }
349 : :
350 [ + + + + : 72 : if (req.per_channel == true && !req.name) {
- + ]
351 : 0 : SPDK_ERRLOG("Bdev name is required for per channel IO statistics\n");
352 : 0 : spdk_jsonrpc_send_error_response(request, -EINVAL, spdk_strerror(EINVAL));
353 : 0 : free_rpc_bdev_get_iostat(&req);
354 : 0 : return;
355 : : }
356 : :
357 [ + - ]: 72 : if (req.name) {
358 : 72 : rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc);
359 [ - + ]: 72 : if (rc != 0) {
360 : 0 : SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc);
361 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
362 : 0 : free_rpc_bdev_get_iostat(&req);
363 : 0 : return;
364 : : }
365 : : }
366 : : }
367 : :
368 : 197 : free_rpc_bdev_get_iostat(&req);
369 : :
370 : 197 : rpc_ctx = calloc(1, sizeof(struct rpc_get_iostat_ctx));
371 [ - + ]: 197 : if (rpc_ctx == NULL) {
372 : 0 : SPDK_ERRLOG("Failed to allocate rpc_iostat_ctx struct\n");
373 : 0 : spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM));
374 : 0 : return;
375 : : }
376 : :
377 : : /*
378 : : * Increment initial bdev_count so that it will never reach 0 in the middle
379 : : * of iterating.
380 : : */
381 : 197 : rpc_ctx->bdev_count++;
382 : 197 : rpc_ctx->request = request;
383 [ - + ]: 197 : rpc_ctx->per_channel = req.per_channel;
384 : :
385 [ + + ]: 197 : if (desc != NULL) {
386 : 72 : bdev = spdk_bdev_desc_get_bdev(desc);
387 : :
388 [ - + ]: 72 : bdev_ctx = bdev_iostat_ctx_alloc(req.per_channel == false);
389 [ - + ]: 72 : if (bdev_ctx == NULL) {
390 : 0 : SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n");
391 : 0 : rpc_ctx->rc = -ENOMEM;
392 : :
393 : 0 : spdk_bdev_close(desc);
394 : : } else {
395 : 72 : bdev_ctx->desc = desc;
396 : :
397 : 72 : rpc_ctx->bdev_count++;
398 : 72 : bdev_ctx->rpc_ctx = rpc_ctx;
399 [ + + + + ]: 72 : if (req.per_channel == false) {
400 : 67 : spdk_bdev_get_device_stat(bdev, bdev_ctx->stat, bdev_get_iostat_done,
401 : : bdev_ctx);
402 : : } else {
403 : : /* If per_channel is true, there is no failure after here and
404 : : * we have to start RPC response before executing
405 : : * spdk_bdev_for_each_channel().
406 : : */
407 : 5 : rpc_get_iostat_started(rpc_ctx);
408 : 5 : spdk_json_write_named_string(rpc_ctx->w, "name", spdk_bdev_get_name(bdev));
409 : 5 : spdk_json_write_named_array_begin(rpc_ctx->w, "channels");
410 : :
411 : 5 : spdk_bdev_for_each_channel(bdev,
412 : : bdev_get_per_channel_stat,
413 : : bdev_ctx,
414 : : bdev_get_per_channel_stat_done);
415 : :
416 : 5 : rpc_get_iostat_done(rpc_ctx);
417 : 5 : return;
418 : : }
419 : : }
420 : : } else {
421 : 125 : rc = spdk_for_each_bdev(rpc_ctx, bdev_get_iostat);
422 [ - + - - ]: 125 : if (rc != 0 && rpc_ctx->rc == 0) {
423 : 0 : rpc_ctx->rc = rc;
424 : : }
425 : : }
426 : :
427 [ + - ]: 192 : if (rpc_ctx->rc == 0) {
428 : : /* We want to fail the RPC for all failures. If per_channel is false,
429 : : * it is enough to defer starting RPC response until it is ensured that
430 : : * all spdk_bdev_for_each_channel() calls will succeed or there is no bdev.
431 : : */
432 : 192 : rpc_get_iostat_started(rpc_ctx);
433 : 192 : spdk_json_write_named_array_begin(rpc_ctx->w, "bdevs");
434 : : }
435 : :
436 : 192 : rpc_get_iostat_done(rpc_ctx);
437 : : }
438 : 2417 : SPDK_RPC_REGISTER("bdev_get_iostat", rpc_bdev_get_iostat, SPDK_RPC_RUNTIME)
439 : :
440 : : struct rpc_reset_iostat_ctx {
441 : : int bdev_count;
442 : : int rc;
443 : : struct spdk_jsonrpc_request *request;
444 : : struct spdk_json_write_ctx *w;
445 : : enum spdk_bdev_reset_stat_mode mode;
446 : : };
447 : :
448 : : struct bdev_reset_iostat_ctx {
449 : : struct rpc_reset_iostat_ctx *rpc_ctx;
450 : : struct spdk_bdev_desc *desc;
451 : : };
452 : :
453 : : static void
454 : 0 : rpc_reset_iostat_done(struct rpc_reset_iostat_ctx *rpc_ctx)
455 : : {
456 [ # # ]: 0 : if (--rpc_ctx->bdev_count != 0) {
457 : 0 : return;
458 : : }
459 : :
460 [ # # ]: 0 : if (rpc_ctx->rc == 0) {
461 : 0 : spdk_jsonrpc_send_bool_response(rpc_ctx->request, true);
462 : : } else {
463 : 0 : spdk_jsonrpc_send_error_response(rpc_ctx->request, rpc_ctx->rc,
464 : 0 : spdk_strerror(-rpc_ctx->rc));
465 : : }
466 : :
467 : 0 : free(rpc_ctx);
468 : : }
469 : :
470 : : static void
471 : 0 : bdev_reset_iostat_done(struct spdk_bdev *bdev, void *cb_arg, int rc)
472 : : {
473 : 0 : struct bdev_reset_iostat_ctx *bdev_ctx = cb_arg;
474 : 0 : struct rpc_reset_iostat_ctx *rpc_ctx = bdev_ctx->rpc_ctx;
475 : :
476 [ # # # # ]: 0 : if (rc != 0 || rpc_ctx->rc != 0) {
477 [ # # ]: 0 : if (rpc_ctx->rc == 0) {
478 : 0 : rpc_ctx->rc = rc;
479 : : }
480 : : }
481 : :
482 : 0 : rpc_reset_iostat_done(rpc_ctx);
483 : :
484 : 0 : spdk_bdev_close(bdev_ctx->desc);
485 : 0 : free(bdev_ctx);
486 : 0 : }
487 : :
488 : : static int
489 : 0 : bdev_reset_iostat(void *ctx, struct spdk_bdev *bdev)
490 : : {
491 : 0 : struct rpc_reset_iostat_ctx *rpc_ctx = ctx;
492 : : struct bdev_reset_iostat_ctx *bdev_ctx;
493 : : int rc;
494 : :
495 : 0 : bdev_ctx = calloc(1, sizeof(struct bdev_reset_iostat_ctx));
496 [ # # ]: 0 : if (bdev_ctx == NULL) {
497 : 0 : SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n");
498 : 0 : return -ENOMEM;
499 : : }
500 : :
501 : 0 : rc = spdk_bdev_open_ext(spdk_bdev_get_name(bdev), false, dummy_bdev_event_cb, NULL,
502 : : &bdev_ctx->desc);
503 [ # # ]: 0 : if (rc != 0) {
504 : 0 : free(bdev_ctx);
505 : 0 : SPDK_ERRLOG("Failed to open bdev\n");
506 : 0 : return rc;
507 : : }
508 : :
509 [ # # ]: 0 : if (bdev->fn_table->reset_device_stat) {
510 : 0 : bdev->fn_table->reset_device_stat(bdev->ctxt);
511 : : }
512 : :
513 : 0 : rpc_ctx->bdev_count++;
514 : 0 : bdev_ctx->rpc_ctx = rpc_ctx;
515 : 0 : bdev_reset_device_stat(bdev, rpc_ctx->mode, bdev_reset_iostat_done, bdev_ctx);
516 : :
517 : 0 : return 0;
518 : : }
519 : :
520 : : struct rpc_bdev_reset_iostat {
521 : : char *name;
522 : : enum spdk_bdev_reset_stat_mode mode;
523 : : };
524 : :
525 : : static void
526 : 0 : free_rpc_bdev_reset_iostat(struct rpc_bdev_reset_iostat *r)
527 : : {
528 : 0 : free(r->name);
529 : 0 : }
530 : :
531 : : static int
532 : 0 : rpc_decode_reset_iostat_mode(const struct spdk_json_val *val, void *out)
533 : : {
534 : 0 : enum spdk_bdev_reset_stat_mode *mode = out;
535 : :
536 [ # # ]: 0 : if (spdk_json_strequal(val, "all") == true) {
537 : 0 : *mode = SPDK_BDEV_RESET_STAT_ALL;
538 [ # # ]: 0 : } else if (spdk_json_strequal(val, "maxmin") == true) {
539 : 0 : *mode = SPDK_BDEV_RESET_STAT_MAXMIN;
540 : : } else {
541 : 0 : SPDK_NOTICELOG("Invalid parameter value: mode\n");
542 : 0 : return -EINVAL;
543 : : }
544 : :
545 : 0 : return 0;
546 : : }
547 : :
548 : : static const struct spdk_json_object_decoder rpc_bdev_reset_iostat_decoders[] = {
549 : : {"name", offsetof(struct rpc_bdev_reset_iostat, name), spdk_json_decode_string, true},
550 : : {"mode", offsetof(struct rpc_bdev_reset_iostat, mode), rpc_decode_reset_iostat_mode, true},
551 : : };
552 : :
553 : : static void
554 : 0 : rpc_bdev_reset_iostat(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params)
555 : : {
556 : 0 : struct rpc_bdev_reset_iostat req = { .mode = SPDK_BDEV_RESET_STAT_ALL, };
557 : 0 : struct spdk_bdev_desc *desc = NULL;
558 : : struct rpc_reset_iostat_ctx *rpc_ctx;
559 : : struct bdev_reset_iostat_ctx *bdev_ctx;
560 : : int rc;
561 : :
562 [ # # ]: 0 : if (params != NULL) {
563 [ # # ]: 0 : if (spdk_json_decode_object(params, rpc_bdev_reset_iostat_decoders,
564 : : SPDK_COUNTOF(rpc_bdev_reset_iostat_decoders),
565 : : &req)) {
566 : 0 : SPDK_ERRLOG("spdk_json_decode_object failed\n");
567 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
568 : : "spdk_json_decode_object failed");
569 : 0 : free_rpc_bdev_reset_iostat(&req);
570 : 0 : return;
571 : : }
572 : :
573 [ # # ]: 0 : if (req.name) {
574 : 0 : rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc);
575 [ # # ]: 0 : if (rc != 0) {
576 : 0 : SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc);
577 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
578 : 0 : free_rpc_bdev_reset_iostat(&req);
579 : 0 : return;
580 : : }
581 : : }
582 : : }
583 : :
584 : :
585 : 0 : rpc_ctx = calloc(1, sizeof(struct rpc_reset_iostat_ctx));
586 [ # # ]: 0 : if (rpc_ctx == NULL) {
587 : 0 : SPDK_ERRLOG("Failed to allocate rpc_iostat_ctx struct\n");
588 : 0 : spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM));
589 : 0 : free_rpc_bdev_reset_iostat(&req);
590 : 0 : return;
591 : : }
592 : :
593 : : /*
594 : : * Increment initial bdev_count so that it will never reach 0 in the middle
595 : : * of iterating.
596 : : */
597 : 0 : rpc_ctx->bdev_count++;
598 : 0 : rpc_ctx->request = request;
599 : 0 : rpc_ctx->mode = req.mode;
600 : :
601 : 0 : free_rpc_bdev_reset_iostat(&req);
602 : :
603 [ # # ]: 0 : if (desc != NULL) {
604 : 0 : bdev_ctx = calloc(1, sizeof(struct bdev_reset_iostat_ctx));
605 [ # # ]: 0 : if (bdev_ctx == NULL) {
606 : 0 : SPDK_ERRLOG("Failed to allocate bdev_iostat_ctx struct\n");
607 : 0 : rpc_ctx->rc = -ENOMEM;
608 : :
609 : 0 : spdk_bdev_close(desc);
610 : : } else {
611 : 0 : bdev_ctx->desc = desc;
612 : :
613 : 0 : rpc_ctx->bdev_count++;
614 : 0 : bdev_ctx->rpc_ctx = rpc_ctx;
615 : 0 : bdev_reset_device_stat(spdk_bdev_desc_get_bdev(desc), rpc_ctx->mode,
616 : : bdev_reset_iostat_done, bdev_ctx);
617 : : }
618 : : } else {
619 : 0 : rc = spdk_for_each_bdev(rpc_ctx, bdev_reset_iostat);
620 [ # # # # ]: 0 : if (rc != 0 && rpc_ctx->rc == 0) {
621 : 0 : rpc_ctx->rc = rc;
622 : : }
623 : : }
624 : :
625 : 0 : rpc_reset_iostat_done(rpc_ctx);
626 : : }
627 : 2417 : SPDK_RPC_REGISTER("bdev_reset_iostat", rpc_bdev_reset_iostat, SPDK_RPC_RUNTIME)
628 : :
629 : : static int
630 : 30053 : rpc_dump_bdev_info(void *ctx, struct spdk_bdev *bdev)
631 : : {
632 : 30053 : struct spdk_json_write_ctx *w = ctx;
633 : : struct spdk_bdev_alias *tmp;
634 : 16898 : uint64_t qos_limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES];
635 : : struct spdk_memory_domain **domains;
636 : : enum spdk_bdev_io_type io_type;
637 : 30053 : const char *name = NULL;
638 : : int i, rc;
639 : :
640 : 30053 : spdk_json_write_object_begin(w);
641 : :
642 : 30053 : spdk_json_write_named_string(w, "name", spdk_bdev_get_name(bdev));
643 : :
644 : 30053 : spdk_json_write_named_array_begin(w, "aliases");
645 : :
646 [ + + ]: 60106 : TAILQ_FOREACH(tmp, spdk_bdev_get_aliases(bdev), tailq) {
647 : 30053 : spdk_json_write_string(w, tmp->alias.name);
648 : : }
649 : :
650 : 30053 : spdk_json_write_array_end(w);
651 : :
652 : 30053 : spdk_json_write_named_string(w, "product_name", spdk_bdev_get_product_name(bdev));
653 : 30053 : spdk_json_write_named_uint32(w, "block_size", spdk_bdev_get_block_size(bdev));
654 : 30053 : spdk_json_write_named_uint64(w, "num_blocks", spdk_bdev_get_num_blocks(bdev));
655 : 30053 : spdk_json_write_named_uuid(w, "uuid", &bdev->uuid);
656 : :
657 [ + + ]: 30053 : if (spdk_bdev_get_md_size(bdev) != 0) {
658 : 187 : spdk_json_write_named_uint32(w, "md_size", spdk_bdev_get_md_size(bdev));
659 : 187 : spdk_json_write_named_bool(w, "md_interleave", spdk_bdev_is_md_interleaved(bdev));
660 : 187 : spdk_json_write_named_uint32(w, "dif_type", spdk_bdev_get_dif_type(bdev));
661 [ - + ]: 187 : if (spdk_bdev_get_dif_type(bdev) != SPDK_DIF_DISABLE) {
662 : 0 : spdk_json_write_named_bool(w, "dif_is_head_of_md", spdk_bdev_is_dif_head_of_md(bdev));
663 : 0 : spdk_json_write_named_object_begin(w, "enabled_dif_check_types");
664 : 0 : spdk_json_write_named_bool(w, "reftag",
665 : 0 : spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG));
666 : 0 : spdk_json_write_named_bool(w, "apptag",
667 : 0 : spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_APPTAG));
668 : 0 : spdk_json_write_named_bool(w, "guard",
669 : 0 : spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD));
670 : 0 : spdk_json_write_object_end(w);
671 : : }
672 : : }
673 : :
674 : 30053 : spdk_json_write_named_object_begin(w, "assigned_rate_limits");
675 : 30053 : spdk_bdev_get_qos_rate_limits(bdev, qos_limits);
676 [ + + ]: 150265 : for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) {
677 : 120212 : spdk_json_write_named_uint64(w, spdk_bdev_get_qos_rpc_type(i), qos_limits[i]);
678 : : }
679 : 30053 : spdk_json_write_object_end(w);
680 : :
681 : 30053 : spdk_json_write_named_bool(w, "claimed",
682 : 30053 : (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE));
683 [ + + ]: 30053 : if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE) {
684 : 8872 : spdk_json_write_named_string(w, "claim_type",
685 : : spdk_bdev_claim_get_name(bdev->internal.claim_type));
686 : : }
687 : :
688 [ - + ]: 30053 : spdk_json_write_named_bool(w, "zoned", bdev->zoned);
689 [ + + - + ]: 30053 : if (bdev->zoned) {
690 : 1 : spdk_json_write_named_uint64(w, "zone_size", bdev->zone_size);
691 : 1 : spdk_json_write_named_uint64(w, "max_open_zones", bdev->max_open_zones);
692 : 1 : spdk_json_write_named_uint64(w, "optimal_open_zones", bdev->optimal_open_zones);
693 : : }
694 : :
695 : 30053 : spdk_json_write_named_object_begin(w, "supported_io_types");
696 [ + + ]: 631113 : for (io_type = SPDK_BDEV_IO_TYPE_READ; io_type < SPDK_BDEV_NUM_IO_TYPES; ++io_type) {
697 : 601060 : name = spdk_bdev_get_io_type_name(io_type);
698 : 601060 : spdk_json_write_named_bool(w, name, spdk_bdev_io_type_supported(bdev, io_type));
699 : : }
700 : 30053 : spdk_json_write_object_end(w);
701 : :
702 : 30053 : rc = spdk_bdev_get_memory_domains(bdev, NULL, 0);
703 [ + + ]: 30053 : if (rc > 0) {
704 : 21644 : domains = calloc(rc, sizeof(struct spdk_memory_domain *));
705 [ + - ]: 21644 : if (domains) {
706 : 21644 : i = spdk_bdev_get_memory_domains(bdev, domains, rc);
707 [ + - ]: 21644 : if (i == rc) {
708 : 21644 : spdk_json_write_named_array_begin(w, "memory_domains");
709 [ + + ]: 66660 : for (i = 0; i < rc; i++) {
710 : 45016 : spdk_json_write_object_begin(w);
711 : 45016 : spdk_json_write_named_string(w, "dma_device_id", spdk_memory_domain_get_dma_device_id(domains[i]));
712 : 45016 : spdk_json_write_named_int32(w, "dma_device_type",
713 : 45016 : spdk_memory_domain_get_dma_device_type(domains[i]));
714 : 45016 : spdk_json_write_object_end(w);
715 : : }
716 : 21644 : spdk_json_write_array_end(w);
717 : : } else {
718 : 0 : SPDK_ERRLOG("Unexpected number of memory domains %d (should be %d)\n", i, rc);
719 : : }
720 : :
721 : 21644 : free(domains);
722 : : } else {
723 : 0 : SPDK_ERRLOG("Memory allocation failed\n");
724 : : }
725 : : }
726 : :
727 : 30053 : spdk_json_write_named_object_begin(w, "driver_specific");
728 : 30053 : spdk_bdev_dump_info_json(bdev, w);
729 : 30053 : spdk_json_write_object_end(w);
730 : :
731 : 30053 : spdk_json_write_object_end(w);
732 : :
733 : 30053 : return 0;
734 : : }
735 : :
736 : : struct rpc_bdev_get_bdevs {
737 : : char *name;
738 : : uint64_t timeout;
739 : : };
740 : :
741 : : struct rpc_bdev_get_bdevs_ctx {
742 : : struct rpc_bdev_get_bdevs rpc;
743 : : struct spdk_jsonrpc_request *request;
744 : : struct spdk_poller *poller;
745 : : uint64_t timeout_ticks;
746 : : };
747 : :
748 : : static void
749 : 7537 : free_rpc_bdev_get_bdevs(struct rpc_bdev_get_bdevs *r)
750 : : {
751 : 7537 : free(r->name);
752 : 7537 : }
753 : :
754 : : static const struct spdk_json_object_decoder rpc_bdev_get_bdevs_decoders[] = {
755 : : {"name", offsetof(struct rpc_bdev_get_bdevs, name), spdk_json_decode_string, true},
756 : : {"timeout", offsetof(struct rpc_bdev_get_bdevs, timeout), spdk_json_decode_uint64, true},
757 : : };
758 : :
759 : : static void
760 : 2599 : rpc_bdev_get_bdev_cb(struct spdk_bdev_desc *desc, int rc, void *cb_arg)
761 : : {
762 : 2599 : struct spdk_jsonrpc_request *request = cb_arg;
763 : : struct spdk_json_write_ctx *w;
764 : :
765 [ + + ]: 2599 : if (rc == 0) {
766 : 2549 : w = spdk_jsonrpc_begin_result(request);
767 : :
768 : 2549 : spdk_json_write_array_begin(w);
769 : 2549 : rpc_dump_bdev_info(w, spdk_bdev_desc_get_bdev(desc));
770 : 2549 : spdk_json_write_array_end(w);
771 : 2549 : spdk_jsonrpc_end_result(request, w);
772 : :
773 : 2549 : spdk_bdev_close(desc);
774 : : } else {
775 : 50 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
776 : : }
777 : 2599 : }
778 : :
779 : : static void
780 : 7537 : rpc_bdev_get_bdevs(struct spdk_jsonrpc_request *request,
781 : : const struct spdk_json_val *params)
782 : : {
783 : 7537 : struct rpc_bdev_get_bdevs req = {};
784 : 7537 : struct spdk_bdev_open_async_opts opts = {};
785 : : struct spdk_json_write_ctx *w;
786 : : int rc;
787 : :
788 [ + + - + ]: 7537 : if (params && spdk_json_decode_object(params, rpc_bdev_get_bdevs_decoders,
789 : : SPDK_COUNTOF(rpc_bdev_get_bdevs_decoders),
790 : : &req)) {
791 : 0 : SPDK_ERRLOG("spdk_json_decode_object failed\n");
792 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
793 : : "spdk_json_decode_object failed");
794 : 0 : free_rpc_bdev_get_bdevs(&req);
795 : 496 : return;
796 : : }
797 : :
798 [ + + ]: 7537 : if (req.name) {
799 : 2599 : opts.size = sizeof(opts);
800 : 2599 : opts.timeout_ms = req.timeout;
801 : :
802 : 2599 : rc = spdk_bdev_open_async(req.name, false, dummy_bdev_event_cb, NULL, &opts,
803 : : rpc_bdev_get_bdev_cb, request);
804 [ - + ]: 2599 : if (rc != 0) {
805 : 0 : SPDK_ERRLOG("spdk_bdev_open_async failed for '%s': rc=%d\n", req.name, rc);
806 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
807 : : }
808 : :
809 : 2599 : free_rpc_bdev_get_bdevs(&req);
810 : 2599 : return;
811 : : }
812 : :
813 : 4938 : free_rpc_bdev_get_bdevs(&req);
814 : :
815 : 4938 : w = spdk_jsonrpc_begin_result(request);
816 : 4938 : spdk_json_write_array_begin(w);
817 : :
818 : 4938 : spdk_for_each_bdev(w, rpc_dump_bdev_info);
819 : :
820 : 4938 : spdk_json_write_array_end(w);
821 : :
822 : 4938 : spdk_jsonrpc_end_result(request, w);
823 : : }
824 : 2417 : SPDK_RPC_REGISTER("bdev_get_bdevs", rpc_bdev_get_bdevs, SPDK_RPC_RUNTIME)
825 : :
826 : : struct rpc_bdev_set_qd_sampling_period {
827 : : char *name;
828 : : uint64_t period;
829 : : };
830 : :
831 : : static void
832 : 5 : free_rpc_bdev_set_qd_sampling_period(struct rpc_bdev_set_qd_sampling_period *r)
833 : : {
834 : 5 : free(r->name);
835 : 5 : }
836 : :
837 : : static const struct spdk_json_object_decoder
838 : : rpc_bdev_set_qd_sampling_period_decoders[] = {
839 : : {"name", offsetof(struct rpc_bdev_set_qd_sampling_period, name), spdk_json_decode_string},
840 : : {"period", offsetof(struct rpc_bdev_set_qd_sampling_period, period), spdk_json_decode_uint64},
841 : : };
842 : :
843 : : static void
844 : 5 : rpc_bdev_set_qd_sampling_period(struct spdk_jsonrpc_request *request,
845 : : const struct spdk_json_val *params)
846 : : {
847 : 5 : struct rpc_bdev_set_qd_sampling_period req = {0};
848 : 4 : struct spdk_bdev_desc *desc;
849 : : int rc;
850 : :
851 [ - + ]: 5 : if (spdk_json_decode_object(params, rpc_bdev_set_qd_sampling_period_decoders,
852 : : SPDK_COUNTOF(rpc_bdev_set_qd_sampling_period_decoders),
853 : : &req)) {
854 : 0 : SPDK_ERRLOG("spdk_json_decode_object failed\n");
855 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
856 : : "spdk_json_decode_object failed");
857 : 0 : goto cleanup;
858 : : }
859 : :
860 : 5 : rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc);
861 [ - + ]: 5 : if (rc != 0) {
862 : 0 : SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc);
863 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
864 : 0 : goto cleanup;
865 : : }
866 : :
867 : 5 : spdk_bdev_set_qd_sampling_period(spdk_bdev_desc_get_bdev(desc), req.period);
868 : 5 : spdk_jsonrpc_send_bool_response(request, true);
869 : :
870 : 5 : spdk_bdev_close(desc);
871 : :
872 : 5 : cleanup:
873 : 5 : free_rpc_bdev_set_qd_sampling_period(&req);
874 : 5 : }
875 : 2417 : SPDK_RPC_REGISTER("bdev_set_qd_sampling_period",
876 : : rpc_bdev_set_qd_sampling_period,
877 : : SPDK_RPC_RUNTIME)
878 : :
879 : : struct rpc_bdev_set_qos_limit {
880 : : char *name;
881 : : uint64_t limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES];
882 : : };
883 : :
884 : : static void
885 : 121 : free_rpc_bdev_set_qos_limit(struct rpc_bdev_set_qos_limit *r)
886 : : {
887 : 121 : free(r->name);
888 : 121 : }
889 : :
890 : : static const struct spdk_json_object_decoder rpc_bdev_set_qos_limit_decoders[] = {
891 : : {"name", offsetof(struct rpc_bdev_set_qos_limit, name), spdk_json_decode_string},
892 : : {
893 : : "rw_ios_per_sec", offsetof(struct rpc_bdev_set_qos_limit,
894 : : limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT]),
895 : : spdk_json_decode_uint64, true
896 : : },
897 : : {
898 : : "rw_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit,
899 : : limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT]),
900 : : spdk_json_decode_uint64, true
901 : : },
902 : : {
903 : : "r_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit,
904 : : limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT]),
905 : : spdk_json_decode_uint64, true
906 : : },
907 : : {
908 : : "w_mbytes_per_sec", offsetof(struct rpc_bdev_set_qos_limit,
909 : : limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT]),
910 : : spdk_json_decode_uint64, true
911 : : },
912 : : };
913 : :
914 : : static void
915 : 121 : rpc_bdev_set_qos_limit_complete(void *cb_arg, int status)
916 : : {
917 : 121 : struct spdk_jsonrpc_request *request = cb_arg;
918 : :
919 [ - + ]: 121 : if (status != 0) {
920 : 0 : spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
921 : : "Failed to configure rate limit: %s",
922 : : spdk_strerror(-status));
923 : 0 : return;
924 : : }
925 : :
926 : 121 : spdk_jsonrpc_send_bool_response(request, true);
927 : : }
928 : :
929 : : static void
930 : 121 : rpc_bdev_set_qos_limit(struct spdk_jsonrpc_request *request,
931 : : const struct spdk_json_val *params)
932 : : {
933 : 121 : struct rpc_bdev_set_qos_limit req = {NULL, {UINT64_MAX, UINT64_MAX, UINT64_MAX, UINT64_MAX}};
934 : 88 : struct spdk_bdev_desc *desc;
935 : : int i, rc;
936 : :
937 [ - + ]: 121 : if (spdk_json_decode_object(params, rpc_bdev_set_qos_limit_decoders,
938 : : SPDK_COUNTOF(rpc_bdev_set_qos_limit_decoders),
939 : : &req)) {
940 : 0 : SPDK_ERRLOG("spdk_json_decode_object failed\n");
941 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
942 : : "spdk_json_decode_object failed");
943 : 0 : goto cleanup;
944 : : }
945 : :
946 : 121 : rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc);
947 [ - + ]: 121 : if (rc != 0) {
948 : 0 : SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc);
949 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
950 : 0 : goto cleanup;
951 : : }
952 : :
953 [ + - ]: 185 : for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) {
954 [ + + ]: 185 : if (req.limits[i] != UINT64_MAX) {
955 : 121 : break;
956 : : }
957 : : }
958 [ - + ]: 121 : if (i == SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES) {
959 : 0 : SPDK_ERRLOG("no rate limits specified\n");
960 : 0 : spdk_bdev_close(desc);
961 : 0 : spdk_jsonrpc_send_error_response(request, -EINVAL, "No rate limits specified");
962 : 0 : goto cleanup;
963 : : }
964 : :
965 : 121 : spdk_bdev_set_qos_rate_limits(spdk_bdev_desc_get_bdev(desc), req.limits,
966 : : rpc_bdev_set_qos_limit_complete, request);
967 : :
968 : 121 : spdk_bdev_close(desc);
969 : :
970 : 121 : cleanup:
971 : 121 : free_rpc_bdev_set_qos_limit(&req);
972 : 121 : }
973 : :
974 : 2417 : SPDK_RPC_REGISTER("bdev_set_qos_limit", rpc_bdev_set_qos_limit, SPDK_RPC_RUNTIME)
975 : :
976 : : /* SPDK_RPC_ENABLE_BDEV_HISTOGRAM */
977 : :
978 : : struct rpc_bdev_enable_histogram_request {
979 : : char *name;
980 : : bool enable;
981 : : };
982 : :
983 : : static void
984 : 7 : free_rpc_bdev_enable_histogram_request(struct rpc_bdev_enable_histogram_request *r)
985 : : {
986 : 7 : free(r->name);
987 : 7 : }
988 : :
989 : : static const struct spdk_json_object_decoder rpc_bdev_enable_histogram_request_decoders[] = {
990 : : {"name", offsetof(struct rpc_bdev_enable_histogram_request, name), spdk_json_decode_string},
991 : : {"enable", offsetof(struct rpc_bdev_enable_histogram_request, enable), spdk_json_decode_bool},
992 : : };
993 : :
994 : : static void
995 : 7 : bdev_histogram_status_cb(void *cb_arg, int status)
996 : : {
997 : 7 : struct spdk_jsonrpc_request *request = cb_arg;
998 : :
999 [ + - ]: 7 : if (status == 0) {
1000 : 7 : spdk_jsonrpc_send_bool_response(request, true);
1001 : : } else {
1002 : 0 : spdk_jsonrpc_send_error_response(request, status, spdk_strerror(-status));
1003 : : }
1004 : 7 : }
1005 : :
1006 : : static void
1007 : 7 : rpc_bdev_enable_histogram(struct spdk_jsonrpc_request *request,
1008 : : const struct spdk_json_val *params)
1009 : : {
1010 : 7 : struct rpc_bdev_enable_histogram_request req = {NULL};
1011 : 4 : struct spdk_bdev_desc *desc;
1012 : : int rc;
1013 : :
1014 [ - + ]: 7 : if (spdk_json_decode_object(params, rpc_bdev_enable_histogram_request_decoders,
1015 : : SPDK_COUNTOF(rpc_bdev_enable_histogram_request_decoders),
1016 : : &req)) {
1017 : 0 : SPDK_ERRLOG("spdk_json_decode_object failed\n");
1018 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
1019 : : "spdk_json_decode_object failed");
1020 : 0 : goto cleanup;
1021 : : }
1022 : :
1023 : 7 : rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc);
1024 [ - + ]: 7 : if (rc != 0) {
1025 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
1026 : 0 : goto cleanup;
1027 : : }
1028 : :
1029 : 7 : spdk_bdev_histogram_enable(spdk_bdev_desc_get_bdev(desc), bdev_histogram_status_cb,
1030 [ - + ]: 7 : request, req.enable);
1031 : :
1032 : 7 : spdk_bdev_close(desc);
1033 : :
1034 : 7 : cleanup:
1035 : 7 : free_rpc_bdev_enable_histogram_request(&req);
1036 : 7 : }
1037 : :
1038 : 2417 : SPDK_RPC_REGISTER("bdev_enable_histogram", rpc_bdev_enable_histogram, SPDK_RPC_RUNTIME)
1039 : :
1040 : : /* SPDK_RPC_GET_BDEV_HISTOGRAM */
1041 : :
1042 : : struct rpc_bdev_get_histogram_request {
1043 : : char *name;
1044 : : };
1045 : :
1046 : : static const struct spdk_json_object_decoder rpc_bdev_get_histogram_request_decoders[] = {
1047 : : {"name", offsetof(struct rpc_bdev_get_histogram_request, name), spdk_json_decode_string}
1048 : : };
1049 : :
1050 : : static void
1051 : 2 : free_rpc_bdev_get_histogram_request(struct rpc_bdev_get_histogram_request *r)
1052 : : {
1053 : 2 : free(r->name);
1054 : 2 : }
1055 : :
1056 : : static void
1057 : 2 : _rpc_bdev_histogram_data_cb(void *cb_arg, int status, struct spdk_histogram_data *histogram)
1058 : : {
1059 : 2 : struct spdk_jsonrpc_request *request = cb_arg;
1060 : : struct spdk_json_write_ctx *w;
1061 : : int rc;
1062 : : char *encoded_histogram;
1063 : : size_t src_len, dst_len;
1064 : :
1065 : :
1066 [ - + ]: 2 : if (status != 0) {
1067 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
1068 : : spdk_strerror(-status));
1069 : 0 : goto invalid;
1070 : : }
1071 : :
1072 [ - + ]: 2 : src_len = SPDK_HISTOGRAM_NUM_BUCKETS(histogram) * sizeof(uint64_t);
1073 : 2 : dst_len = spdk_base64_get_encoded_strlen(src_len) + 1;
1074 : :
1075 : 2 : encoded_histogram = malloc(dst_len);
1076 [ - + ]: 2 : if (encoded_histogram == NULL) {
1077 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
1078 : : spdk_strerror(ENOMEM));
1079 : 0 : goto invalid;
1080 : : }
1081 : :
1082 : 2 : rc = spdk_base64_encode(encoded_histogram, histogram->bucket, src_len);
1083 [ - + ]: 2 : if (rc != 0) {
1084 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
1085 : : spdk_strerror(-rc));
1086 : 0 : goto free_encoded_histogram;
1087 : : }
1088 : :
1089 : 2 : w = spdk_jsonrpc_begin_result(request);
1090 : 2 : spdk_json_write_object_begin(w);
1091 : 2 : spdk_json_write_named_string(w, "histogram", encoded_histogram);
1092 : 2 : spdk_json_write_named_int64(w, "bucket_shift", histogram->bucket_shift);
1093 : 2 : spdk_json_write_named_int64(w, "tsc_rate", spdk_get_ticks_hz());
1094 : 2 : spdk_json_write_object_end(w);
1095 : 2 : spdk_jsonrpc_end_result(request, w);
1096 : :
1097 : 2 : free_encoded_histogram:
1098 : 2 : free(encoded_histogram);
1099 : 2 : invalid:
1100 : 2 : spdk_histogram_data_free(histogram);
1101 : 2 : }
1102 : :
1103 : : static void
1104 : 2 : rpc_bdev_get_histogram(struct spdk_jsonrpc_request *request,
1105 : : const struct spdk_json_val *params)
1106 : : {
1107 : 2 : struct rpc_bdev_get_histogram_request req = {NULL};
1108 : : struct spdk_histogram_data *histogram;
1109 : 2 : struct spdk_bdev_desc *desc;
1110 : : int rc;
1111 : :
1112 [ - + ]: 2 : if (spdk_json_decode_object(params, rpc_bdev_get_histogram_request_decoders,
1113 : : SPDK_COUNTOF(rpc_bdev_get_histogram_request_decoders),
1114 : : &req)) {
1115 : 0 : SPDK_ERRLOG("spdk_json_decode_object failed\n");
1116 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
1117 : : "spdk_json_decode_object failed");
1118 : 0 : goto cleanup;
1119 : : }
1120 : :
1121 : 2 : rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc);
1122 [ - + ]: 2 : if (rc != 0) {
1123 : 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
1124 : 0 : goto cleanup;
1125 : : }
1126 : :
1127 : 2 : histogram = spdk_histogram_data_alloc();
1128 [ - + ]: 2 : if (histogram == NULL) {
1129 : 0 : spdk_bdev_close(desc);
1130 : 0 : spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM));
1131 : 0 : goto cleanup;
1132 : : }
1133 : :
1134 : 2 : spdk_bdev_histogram_get(spdk_bdev_desc_get_bdev(desc), histogram,
1135 : : _rpc_bdev_histogram_data_cb, request);
1136 : :
1137 : 2 : spdk_bdev_close(desc);
1138 : :
1139 : 2 : cleanup:
1140 : 2 : free_rpc_bdev_get_histogram_request(&req);
1141 : 2 : }
1142 : :
1143 : 2417 : SPDK_RPC_REGISTER("bdev_get_histogram", rpc_bdev_get_histogram, SPDK_RPC_RUNTIME)
|