Line data Source code
1 : /* SPDX-License-Identifier: BSD-3-Clause
2 : * Copyright (C) 2018 Intel Corporation.
3 : * All rights reserved.
4 : */
5 :
6 : #include "spdk/rpc.h"
7 : #include "spdk/bdev.h"
8 : #include "bdev_raid.h"
9 : #include "spdk/util.h"
10 : #include "spdk/string.h"
11 : #include "spdk/log.h"
12 : #include "spdk/env.h"
13 :
14 : #define RPC_MAX_BASE_BDEVS 255
15 :
16 : /*
17 : * Input structure for bdev_raid_get_bdevs RPC
18 : */
19 : struct rpc_bdev_raid_get_bdevs {
20 : /* category - all or online or configuring or offline */
21 : char *category;
22 : };
23 :
24 : /*
25 : * brief:
26 : * free_rpc_bdev_raid_get_bdevs function frees RPC bdev_raid_get_bdevs related parameters
27 : * params:
28 : * req - pointer to RPC request
29 : * returns:
30 : * none
31 : */
32 : static void
33 7 : free_rpc_bdev_raid_get_bdevs(struct rpc_bdev_raid_get_bdevs *req)
34 : {
35 7 : free(req->category);
36 7 : }
37 :
38 : /*
39 : * Decoder object for RPC get_raids
40 : */
41 : static const struct spdk_json_object_decoder rpc_bdev_raid_get_bdevs_decoders[] = {
42 : {"category", offsetof(struct rpc_bdev_raid_get_bdevs, category), spdk_json_decode_string},
43 : };
44 :
45 : /*
46 : * brief:
47 : * rpc_bdev_raid_get_bdevs function is the RPC for rpc_bdev_raid_get_bdevs. This is used to list
48 : * all the raid bdev names based on the input category requested. Category should be
49 : * one of "all", "online", "configuring" or "offline". "all" means all the raids
50 : * whether they are online or configuring or offline. "online" is the raid bdev which
51 : * is registered with bdev layer. "configuring" is the raid bdev which does not have
52 : * full configuration discovered yet. "offline" is the raid bdev which is not
53 : * registered with bdev as of now and it has encountered any error or user has
54 : * requested to offline the raid.
55 : * params:
56 : * request - pointer to json rpc request
57 : * params - pointer to request parameters
58 : * returns:
59 : * none
60 : */
61 : static void
62 7 : rpc_bdev_raid_get_bdevs(struct spdk_jsonrpc_request *request,
63 : const struct spdk_json_val *params)
64 : {
65 7 : struct rpc_bdev_raid_get_bdevs req = {};
66 : struct spdk_json_write_ctx *w;
67 : struct raid_bdev *raid_bdev;
68 : enum raid_bdev_state state;
69 :
70 7 : if (spdk_json_decode_object(params, rpc_bdev_raid_get_bdevs_decoders,
71 : SPDK_COUNTOF(rpc_bdev_raid_get_bdevs_decoders),
72 : &req)) {
73 1 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR,
74 : "spdk_json_decode_object failed");
75 1 : goto cleanup;
76 : }
77 :
78 6 : state = raid_bdev_str_to_state(req.category);
79 6 : if (state == RAID_BDEV_STATE_MAX && strcmp(req.category, "all") != 0) {
80 1 : spdk_jsonrpc_send_error_response(request, -EINVAL, spdk_strerror(EINVAL));
81 1 : goto cleanup;
82 : }
83 :
84 5 : w = spdk_jsonrpc_begin_result(request);
85 5 : spdk_json_write_array_begin(w);
86 :
87 : /* Get raid bdev list based on the category requested */
88 15 : TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) {
89 10 : if (raid_bdev->state == state || state == RAID_BDEV_STATE_MAX) {
90 6 : char uuid_str[SPDK_UUID_STRING_LEN];
91 :
92 6 : spdk_json_write_object_begin(w);
93 6 : spdk_json_write_named_string(w, "name", raid_bdev->bdev.name);
94 6 : spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &raid_bdev->bdev.uuid);
95 6 : spdk_json_write_named_string(w, "uuid", uuid_str);
96 6 : raid_bdev_write_info_json(raid_bdev, w);
97 6 : spdk_json_write_object_end(w);
98 : }
99 : }
100 5 : spdk_json_write_array_end(w);
101 5 : spdk_jsonrpc_end_result(request, w);
102 :
103 7 : cleanup:
104 7 : free_rpc_bdev_raid_get_bdevs(&req);
105 7 : }
106 1 : SPDK_RPC_REGISTER("bdev_raid_get_bdevs", rpc_bdev_raid_get_bdevs, SPDK_RPC_RUNTIME)
107 :
108 : /*
109 : * Base bdevs in RPC bdev_raid_create
110 : */
111 : struct rpc_bdev_raid_create_base_bdevs {
112 : /* Number of base bdevs */
113 : size_t num_base_bdevs;
114 :
115 : /* List of base bdevs names */
116 : char *base_bdevs[RPC_MAX_BASE_BDEVS];
117 : };
118 :
119 : /*
120 : * Input structure for RPC rpc_bdev_raid_create
121 : */
122 : struct rpc_bdev_raid_create {
123 : /* Raid bdev name */
124 : char *name;
125 :
126 : /* RAID strip size in KB */
127 : uint32_t strip_size_kb;
128 :
129 : /* RAID raid level */
130 : enum raid_level level;
131 :
132 : /* Base bdevs information */
133 : struct rpc_bdev_raid_create_base_bdevs base_bdevs;
134 :
135 : /* UUID for this raid bdev */
136 : struct spdk_uuid uuid;
137 :
138 : /* If set, information about raid bdev will be stored in superblock on each base bdev */
139 : bool superblock_enabled;
140 : };
141 :
142 : /*
143 : * Decoder function for RPC bdev_raid_create to decode raid level
144 : */
145 : static int
146 0 : decode_raid_level(const struct spdk_json_val *val, void *out)
147 : {
148 : int ret;
149 0 : char *str = NULL;
150 : enum raid_level level;
151 :
152 0 : ret = spdk_json_decode_string(val, &str);
153 0 : if (ret == 0 && str != NULL) {
154 0 : level = raid_bdev_str_to_level(str);
155 0 : if (level == INVALID_RAID_LEVEL) {
156 0 : ret = -EINVAL;
157 : } else {
158 0 : *(enum raid_level *)out = level;
159 : }
160 : }
161 :
162 0 : free(str);
163 0 : return ret;
164 : }
165 :
166 : /*
167 : * Decoder function for RPC bdev_raid_create to decode base bdevs list
168 : */
169 : static int
170 0 : decode_base_bdevs(const struct spdk_json_val *val, void *out)
171 : {
172 0 : struct rpc_bdev_raid_create_base_bdevs *base_bdevs = out;
173 0 : return spdk_json_decode_array(val, spdk_json_decode_string, base_bdevs->base_bdevs,
174 : RPC_MAX_BASE_BDEVS, &base_bdevs->num_base_bdevs, sizeof(char *));
175 : }
176 :
177 : /*
178 : * Decoder object for RPC bdev_raid_create
179 : */
180 : static const struct spdk_json_object_decoder rpc_bdev_raid_create_decoders[] = {
181 : {"name", offsetof(struct rpc_bdev_raid_create, name), spdk_json_decode_string},
182 : {"strip_size_kb", offsetof(struct rpc_bdev_raid_create, strip_size_kb), spdk_json_decode_uint32, true},
183 : {"raid_level", offsetof(struct rpc_bdev_raid_create, level), decode_raid_level},
184 : {"base_bdevs", offsetof(struct rpc_bdev_raid_create, base_bdevs), decode_base_bdevs},
185 : {"uuid", offsetof(struct rpc_bdev_raid_create, uuid), spdk_json_decode_uuid, true},
186 : {"superblock", offsetof(struct rpc_bdev_raid_create, superblock_enabled), spdk_json_decode_bool, true},
187 : };
188 :
189 : struct rpc_bdev_raid_create_ctx {
190 : struct rpc_bdev_raid_create req;
191 : struct raid_bdev *raid_bdev;
192 : struct spdk_jsonrpc_request *request;
193 : uint8_t remaining;
194 : int status;
195 : };
196 :
197 : static void
198 21 : free_rpc_bdev_raid_create_ctx(struct rpc_bdev_raid_create_ctx *ctx)
199 : {
200 : struct rpc_bdev_raid_create *req;
201 : size_t i;
202 :
203 21 : if (!ctx) {
204 0 : return;
205 : }
206 :
207 21 : req = &ctx->req;
208 :
209 21 : free(req->name);
210 661 : for (i = 0; i < req->base_bdevs.num_base_bdevs; i++) {
211 640 : free(req->base_bdevs.base_bdevs[i]);
212 : }
213 :
214 21 : free(ctx);
215 : }
216 :
217 : static void
218 513 : rpc_bdev_raid_create_add_base_bdev_cb(void *_ctx, int status)
219 : {
220 513 : struct rpc_bdev_raid_create_ctx *ctx = _ctx;
221 :
222 513 : if (status != 0) {
223 2 : ctx->status = status;
224 : }
225 :
226 513 : assert(ctx->remaining != 0);
227 513 : if (--ctx->remaining > 0) {
228 496 : return;
229 : }
230 :
231 17 : if (ctx->status != 0) {
232 2 : raid_bdev_delete(ctx->raid_bdev, NULL, NULL);
233 2 : spdk_jsonrpc_send_error_response_fmt(ctx->request, ctx->status,
234 : "Failed to create RAID bdev %s: %s",
235 : ctx->req.name,
236 2 : spdk_strerror(-ctx->status));
237 : } else {
238 15 : spdk_jsonrpc_send_bool_response(ctx->request, true);
239 : }
240 :
241 17 : free_rpc_bdev_raid_create_ctx(ctx);
242 : }
243 :
244 : /*
245 : * brief:
246 : * rpc_bdev_raid_create function is the RPC for creating RAID bdevs. It takes
247 : * input as raid bdev name, raid level, strip size in KB and list of base bdev names.
248 : * params:
249 : * request - pointer to json rpc request
250 : * params - pointer to request parameters
251 : * returns:
252 : * none
253 : */
254 : static void
255 21 : rpc_bdev_raid_create(struct spdk_jsonrpc_request *request,
256 : const struct spdk_json_val *params)
257 : {
258 : struct rpc_bdev_raid_create *req;
259 21 : struct raid_bdev *raid_bdev;
260 : int rc;
261 : size_t i;
262 : struct rpc_bdev_raid_create_ctx *ctx;
263 : uint8_t num_base_bdevs;
264 :
265 21 : ctx = calloc(1, sizeof(*ctx));
266 21 : if (ctx == NULL) {
267 0 : spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM));
268 0 : goto cleanup;
269 : }
270 21 : req = &ctx->req;
271 :
272 21 : if (spdk_json_decode_object(params, rpc_bdev_raid_create_decoders,
273 : SPDK_COUNTOF(rpc_bdev_raid_create_decoders),
274 : req)) {
275 1 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR,
276 : "spdk_json_decode_object failed");
277 1 : goto cleanup;
278 : }
279 20 : num_base_bdevs = req->base_bdevs.num_base_bdevs;
280 :
281 660 : for (i = 0; i < num_base_bdevs; i++) {
282 640 : if (strlen(req->base_bdevs.base_bdevs[i]) == 0) {
283 0 : spdk_jsonrpc_send_error_response_fmt(request, -EINVAL,
284 : "The base bdev name cannot be empty: %s",
285 : spdk_strerror(EINVAL));
286 0 : goto cleanup;
287 : }
288 : }
289 :
290 20 : rc = raid_bdev_create(req->name, req->strip_size_kb, num_base_bdevs,
291 20 : req->level, req->superblock_enabled, &req->uuid, &raid_bdev);
292 20 : if (rc != 0) {
293 3 : spdk_jsonrpc_send_error_response_fmt(request, rc,
294 : "Failed to create RAID bdev %s: %s",
295 : req->name, spdk_strerror(-rc));
296 3 : goto cleanup;
297 : }
298 :
299 17 : ctx->raid_bdev = raid_bdev;
300 17 : ctx->request = request;
301 17 : ctx->remaining = num_base_bdevs;
302 :
303 17 : assert(num_base_bdevs > 0);
304 :
305 528 : for (i = 0; i < num_base_bdevs; i++) {
306 513 : const char *base_bdev_name = req->base_bdevs.base_bdevs[i];
307 :
308 513 : rc = raid_bdev_add_base_bdev(raid_bdev, base_bdev_name,
309 : rpc_bdev_raid_create_add_base_bdev_cb, ctx);
310 513 : if (rc == -ENODEV) {
311 1 : SPDK_DEBUGLOG(bdev_raid, "base bdev %s doesn't exist now\n", base_bdev_name);
312 1 : assert(ctx->remaining > 1 || i + 1 == num_base_bdevs);
313 1 : rpc_bdev_raid_create_add_base_bdev_cb(ctx, 0);
314 512 : } else if (rc != 0) {
315 2 : SPDK_DEBUGLOG(bdev_raid, "Failed to add base bdev %s to RAID bdev %s: %s",
316 : base_bdev_name, req->name, spdk_strerror(-rc));
317 2 : ctx->remaining -= (num_base_bdevs - i - 1);
318 2 : rpc_bdev_raid_create_add_base_bdev_cb(ctx, rc);
319 2 : break;
320 : }
321 : }
322 17 : return;
323 4 : cleanup:
324 4 : free_rpc_bdev_raid_create_ctx(ctx);
325 : }
326 1 : SPDK_RPC_REGISTER("bdev_raid_create", rpc_bdev_raid_create, SPDK_RPC_RUNTIME)
327 :
328 : /*
329 : * Input structure for RPC deleting a raid bdev
330 : */
331 : struct rpc_bdev_raid_delete {
332 : /* raid bdev name */
333 : char *name;
334 : };
335 :
336 : /*
337 : * brief:
338 : * free_rpc_bdev_raid_delete function is used to free RPC bdev_raid_delete related parameters
339 : * params:
340 : * req - pointer to RPC request
341 : * params:
342 : * none
343 : */
344 : static void
345 16 : free_rpc_bdev_raid_delete(struct rpc_bdev_raid_delete *req)
346 : {
347 16 : free(req->name);
348 16 : }
349 :
350 : /*
351 : * Decoder object for RPC raid_bdev_delete
352 : */
353 : static const struct spdk_json_object_decoder rpc_bdev_raid_delete_decoders[] = {
354 : {"name", offsetof(struct rpc_bdev_raid_delete, name), spdk_json_decode_string},
355 : };
356 :
357 : struct rpc_bdev_raid_delete_ctx {
358 : struct rpc_bdev_raid_delete req;
359 : struct spdk_jsonrpc_request *request;
360 : };
361 :
362 : /*
363 : * brief:
364 : * params:
365 : * cb_arg - pointer to the callback context.
366 : * rc - return code of the deletion of the raid bdev.
367 : * returns:
368 : * none
369 : */
370 : static void
371 14 : bdev_raid_delete_done(void *cb_arg, int rc)
372 : {
373 14 : struct rpc_bdev_raid_delete_ctx *ctx = cb_arg;
374 14 : struct spdk_jsonrpc_request *request = ctx->request;
375 :
376 14 : if (rc != 0) {
377 0 : SPDK_ERRLOG("Failed to delete raid bdev %s (%d): %s\n",
378 : ctx->req.name, rc, spdk_strerror(-rc));
379 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
380 : spdk_strerror(-rc));
381 0 : goto exit;
382 : }
383 :
384 14 : spdk_jsonrpc_send_bool_response(request, true);
385 14 : exit:
386 14 : free_rpc_bdev_raid_delete(&ctx->req);
387 14 : free(ctx);
388 14 : }
389 :
390 : /*
391 : * brief:
392 : * rpc_bdev_raid_delete function is the RPC for deleting a raid bdev. It takes raid
393 : * name as input and delete that raid bdev including freeing the base bdev
394 : * resources.
395 : * params:
396 : * request - pointer to json rpc request
397 : * params - pointer to request parameters
398 : * returns:
399 : * none
400 : */
401 : static void
402 16 : rpc_bdev_raid_delete(struct spdk_jsonrpc_request *request,
403 : const struct spdk_json_val *params)
404 : {
405 : struct rpc_bdev_raid_delete_ctx *ctx;
406 : struct raid_bdev *raid_bdev;
407 :
408 16 : ctx = calloc(1, sizeof(*ctx));
409 16 : if (!ctx) {
410 0 : spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM));
411 0 : return;
412 : }
413 :
414 16 : if (spdk_json_decode_object(params, rpc_bdev_raid_delete_decoders,
415 : SPDK_COUNTOF(rpc_bdev_raid_delete_decoders),
416 16 : &ctx->req)) {
417 1 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR,
418 : "spdk_json_decode_object failed");
419 1 : goto cleanup;
420 : }
421 :
422 15 : raid_bdev = raid_bdev_find_by_name(ctx->req.name);
423 15 : if (raid_bdev == NULL) {
424 1 : spdk_jsonrpc_send_error_response_fmt(request, -ENODEV,
425 : "raid bdev %s not found",
426 : ctx->req.name);
427 1 : goto cleanup;
428 : }
429 :
430 14 : ctx->request = request;
431 :
432 14 : raid_bdev_delete(raid_bdev, bdev_raid_delete_done, ctx);
433 :
434 14 : return;
435 :
436 2 : cleanup:
437 2 : free_rpc_bdev_raid_delete(&ctx->req);
438 2 : free(ctx);
439 : }
440 1 : SPDK_RPC_REGISTER("bdev_raid_delete", rpc_bdev_raid_delete, SPDK_RPC_RUNTIME)
441 :
442 : /*
443 : * Base bdevs in RPC bdev_raid_add_base_bdev
444 : */
445 : struct rpc_bdev_raid_add_base_bdev {
446 : /* Base bdev name */
447 : char *base_bdev;
448 :
449 : /* Raid bdev name */
450 : char *raid_bdev;
451 : };
452 :
453 : /*
454 : * brief:
455 : * free_rpc_bdev_raid_add_base_bdev function is to free RPC
456 : * bdev_raid_add_base_bdev related parameters.
457 : * params:
458 : * req - pointer to RPC request
459 : * returns:
460 : * none
461 : */
462 : static void
463 0 : free_rpc_bdev_raid_add_base_bdev(struct rpc_bdev_raid_add_base_bdev *req)
464 : {
465 0 : free(req->base_bdev);
466 0 : free(req->raid_bdev);
467 0 : }
468 :
469 : /*
470 : * Decoder object for RPC bdev_raid_add_base_bdev
471 : */
472 : static const struct spdk_json_object_decoder rpc_bdev_raid_add_base_bdev_decoders[] = {
473 : {"base_bdev", offsetof(struct rpc_bdev_raid_add_base_bdev, base_bdev), spdk_json_decode_string},
474 : {"raid_bdev", offsetof(struct rpc_bdev_raid_add_base_bdev, raid_bdev), spdk_json_decode_string},
475 : };
476 :
477 : static void
478 0 : rpc_bdev_raid_add_base_bdev_done(void *ctx, int status)
479 : {
480 0 : struct spdk_jsonrpc_request *request = ctx;
481 :
482 0 : if (status != 0) {
483 0 : spdk_jsonrpc_send_error_response_fmt(request, status, "Failed to add base bdev to RAID bdev: %s",
484 : spdk_strerror(-status));
485 0 : return;
486 : }
487 :
488 0 : spdk_jsonrpc_send_bool_response(request, true);
489 : }
490 :
491 : static void
492 0 : rpc_bdev_raid_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx)
493 : {
494 0 : }
495 :
496 : /*
497 : * brief:
498 : * bdev_raid_add_base_bdev function is the RPC for adding base bdev to a raid bdev.
499 : * It takes base bdev and raid bdev names as input.
500 : * params:
501 : * request - pointer to json rpc request
502 : * params - pointer to request parameters
503 : * returns:
504 : * none
505 : */
506 : static void
507 0 : rpc_bdev_raid_add_base_bdev(struct spdk_jsonrpc_request *request,
508 : const struct spdk_json_val *params)
509 : {
510 0 : struct rpc_bdev_raid_add_base_bdev req = {};
511 : struct raid_bdev *raid_bdev;
512 : int rc;
513 :
514 0 : if (spdk_json_decode_object(params, rpc_bdev_raid_add_base_bdev_decoders,
515 : SPDK_COUNTOF(rpc_bdev_raid_add_base_bdev_decoders),
516 : &req)) {
517 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
518 : "spdk_json_decode_object failed");
519 0 : goto cleanup;
520 : }
521 :
522 0 : raid_bdev = raid_bdev_find_by_name(req.raid_bdev);
523 0 : if (raid_bdev == NULL) {
524 0 : spdk_jsonrpc_send_error_response_fmt(request, -ENODEV, "raid bdev %s is not found in config",
525 : req.raid_bdev);
526 0 : goto cleanup;
527 : }
528 :
529 0 : rc = raid_bdev_add_base_bdev(raid_bdev, req.base_bdev, rpc_bdev_raid_add_base_bdev_done, request);
530 0 : if (rc != 0) {
531 0 : spdk_jsonrpc_send_error_response_fmt(request, rc,
532 : "Failed to add base bdev %s to RAID bdev %s: %s",
533 : req.base_bdev, req.raid_bdev,
534 : spdk_strerror(-rc));
535 0 : goto cleanup;
536 : }
537 :
538 0 : cleanup:
539 0 : free_rpc_bdev_raid_add_base_bdev(&req);
540 0 : }
541 1 : SPDK_RPC_REGISTER("bdev_raid_add_base_bdev", rpc_bdev_raid_add_base_bdev, SPDK_RPC_RUNTIME)
542 :
543 : /*
544 : * Decoder object for RPC bdev_raid_remove_base_bdev
545 : */
546 : static const struct spdk_json_object_decoder rpc_bdev_raid_remove_base_bdev_decoders[] = {
547 : {"name", 0, spdk_json_decode_string},
548 : };
549 :
550 : static void
551 0 : rpc_bdev_raid_remove_base_bdev_done(void *ctx, int status)
552 : {
553 0 : struct spdk_jsonrpc_request *request = ctx;
554 :
555 0 : if (status != 0) {
556 0 : spdk_jsonrpc_send_error_response_fmt(request, status, "Failed to remove base bdev from raid bdev");
557 0 : return;
558 : }
559 :
560 0 : spdk_jsonrpc_send_bool_response(request, true);
561 : }
562 :
563 : /*
564 : * brief:
565 : * bdev_raid_remove_base_bdev function is the RPC for removing base bdev from a raid bdev.
566 : * It takes base bdev name as input.
567 : * params:
568 : * request - pointer to json rpc request
569 : * params - pointer to request parameters
570 : * returns:
571 : * none
572 : */
573 : static void
574 0 : rpc_bdev_raid_remove_base_bdev(struct spdk_jsonrpc_request *request,
575 : const struct spdk_json_val *params)
576 : {
577 0 : struct spdk_bdev_desc *desc;
578 0 : char *name = NULL;
579 : int rc;
580 :
581 0 : if (spdk_json_decode_object(params, rpc_bdev_raid_remove_base_bdev_decoders,
582 : SPDK_COUNTOF(rpc_bdev_raid_remove_base_bdev_decoders),
583 : &name)) {
584 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR,
585 : "spdk_json_decode_object failed");
586 0 : return;
587 : }
588 :
589 0 : rc = spdk_bdev_open_ext(name, false, rpc_bdev_raid_event_cb, NULL, &desc);
590 0 : free(name);
591 0 : if (rc != 0) {
592 0 : goto err;
593 : }
594 :
595 0 : rc = raid_bdev_remove_base_bdev(spdk_bdev_desc_get_bdev(desc), rpc_bdev_raid_remove_base_bdev_done,
596 : request);
597 0 : spdk_bdev_close(desc);
598 0 : if (rc != 0) {
599 0 : goto err;
600 : }
601 :
602 0 : return;
603 0 : err:
604 0 : rpc_bdev_raid_remove_base_bdev_done(request, rc);
605 : }
606 1 : SPDK_RPC_REGISTER("bdev_raid_remove_base_bdev", rpc_bdev_raid_remove_base_bdev, SPDK_RPC_RUNTIME)
607 :
608 : static const struct spdk_json_object_decoder rpc_bdev_raid_options_decoders[] = {
609 : {"process_window_size_kb", offsetof(struct spdk_raid_bdev_opts, process_window_size_kb), spdk_json_decode_uint32, true},
610 : {"process_max_bandwidth_mb_sec", offsetof(struct spdk_raid_bdev_opts, process_max_bandwidth_mb_sec), spdk_json_decode_uint32, true},
611 : };
612 :
613 : static void
614 0 : rpc_bdev_raid_set_options(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params)
615 : {
616 0 : struct spdk_raid_bdev_opts opts;
617 : int rc;
618 :
619 0 : raid_bdev_get_opts(&opts);
620 0 : if (params && spdk_json_decode_object(params, rpc_bdev_raid_options_decoders,
621 : SPDK_COUNTOF(rpc_bdev_raid_options_decoders),
622 : &opts)) {
623 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR,
624 : "spdk_json_decode_object failed");
625 0 : return;
626 : }
627 :
628 0 : rc = raid_bdev_set_opts(&opts);
629 0 : if (rc) {
630 0 : spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
631 : } else {
632 0 : spdk_jsonrpc_send_bool_response(request, true);
633 : }
634 :
635 0 : return;
636 : }
637 1 : SPDK_RPC_REGISTER("bdev_raid_set_options", rpc_bdev_raid_set_options,
638 : SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
|