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 free_rpc_bdev_raid_get_bdevs(struct rpc_bdev_raid_get_bdevs *req) 34 { 35 free(req->category); 36 } 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 rpc_bdev_raid_get_bdevs(struct spdk_jsonrpc_request *request, 63 const struct spdk_json_val *params) 64 { 65 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 if (spdk_json_decode_object(params, rpc_bdev_raid_get_bdevs_decoders, 71 SPDK_COUNTOF(rpc_bdev_raid_get_bdevs_decoders), 72 &req)) { 73 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR, 74 "spdk_json_decode_object failed"); 75 goto cleanup; 76 } 77 78 state = raid_bdev_str_to_state(req.category); 79 if (state == RAID_BDEV_STATE_MAX && strcmp(req.category, "all") != 0) { 80 spdk_jsonrpc_send_error_response(request, -EINVAL, spdk_strerror(EINVAL)); 81 goto cleanup; 82 } 83 84 w = spdk_jsonrpc_begin_result(request); 85 spdk_json_write_array_begin(w); 86 87 /* Get raid bdev list based on the category requested */ 88 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) { 89 if (raid_bdev->state == state || state == RAID_BDEV_STATE_MAX) { 90 spdk_json_write_object_begin(w); 91 spdk_json_write_named_string(w, "name", raid_bdev->bdev.name); 92 raid_bdev_write_info_json(raid_bdev, w); 93 spdk_json_write_object_end(w); 94 } 95 } 96 spdk_json_write_array_end(w); 97 spdk_jsonrpc_end_result(request, w); 98 99 cleanup: 100 free_rpc_bdev_raid_get_bdevs(&req); 101 } 102 SPDK_RPC_REGISTER("bdev_raid_get_bdevs", rpc_bdev_raid_get_bdevs, SPDK_RPC_RUNTIME) 103 104 /* 105 * Base bdevs in RPC bdev_raid_create 106 */ 107 struct rpc_bdev_raid_create_base_bdevs { 108 /* Number of base bdevs */ 109 size_t num_base_bdevs; 110 111 /* List of base bdevs names */ 112 char *base_bdevs[RPC_MAX_BASE_BDEVS]; 113 }; 114 115 /* 116 * Input structure for RPC rpc_bdev_raid_create 117 */ 118 struct rpc_bdev_raid_create { 119 /* Raid bdev name */ 120 char *name; 121 122 /* RAID strip size in KB */ 123 uint32_t strip_size_kb; 124 125 /* RAID raid level */ 126 enum raid_level level; 127 128 /* Base bdevs information */ 129 struct rpc_bdev_raid_create_base_bdevs base_bdevs; 130 131 /* UUID for this raid bdev */ 132 char *uuid; 133 }; 134 135 /* 136 * brief: 137 * free_rpc_bdev_raid_create function is to free RPC bdev_raid_create related parameters 138 * params: 139 * req - pointer to RPC request 140 * returns: 141 * none 142 */ 143 static void 144 free_rpc_bdev_raid_create(struct rpc_bdev_raid_create *req) 145 { 146 size_t i; 147 148 free(req->name); 149 free(req->uuid); 150 for (i = 0; i < req->base_bdevs.num_base_bdevs; i++) { 151 free(req->base_bdevs.base_bdevs[i]); 152 } 153 } 154 155 /* 156 * Decoder function for RPC bdev_raid_create to decode raid level 157 */ 158 static int 159 decode_raid_level(const struct spdk_json_val *val, void *out) 160 { 161 int ret; 162 char *str = NULL; 163 enum raid_level level; 164 165 ret = spdk_json_decode_string(val, &str); 166 if (ret == 0 && str != NULL) { 167 level = raid_bdev_str_to_level(str); 168 if (level == INVALID_RAID_LEVEL) { 169 ret = -EINVAL; 170 } else { 171 *(enum raid_level *)out = level; 172 } 173 } 174 175 free(str); 176 return ret; 177 } 178 179 /* 180 * Decoder function for RPC bdev_raid_create to decode base bdevs list 181 */ 182 static int 183 decode_base_bdevs(const struct spdk_json_val *val, void *out) 184 { 185 struct rpc_bdev_raid_create_base_bdevs *base_bdevs = out; 186 return spdk_json_decode_array(val, spdk_json_decode_string, base_bdevs->base_bdevs, 187 RPC_MAX_BASE_BDEVS, &base_bdevs->num_base_bdevs, sizeof(char *)); 188 } 189 190 /* 191 * Decoder object for RPC bdev_raid_create 192 */ 193 static const struct spdk_json_object_decoder rpc_bdev_raid_create_decoders[] = { 194 {"name", offsetof(struct rpc_bdev_raid_create, name), spdk_json_decode_string}, 195 {"strip_size_kb", offsetof(struct rpc_bdev_raid_create, strip_size_kb), spdk_json_decode_uint32, true}, 196 {"raid_level", offsetof(struct rpc_bdev_raid_create, level), decode_raid_level}, 197 {"base_bdevs", offsetof(struct rpc_bdev_raid_create, base_bdevs), decode_base_bdevs}, 198 {"uuid", offsetof(struct rpc_bdev_raid_create, uuid), spdk_json_decode_string, true}, 199 }; 200 201 /* 202 * brief: 203 * rpc_bdev_raid_create function is the RPC for creating RAID bdevs. It takes 204 * input as raid bdev name, raid level, strip size in KB and list of base bdev names. 205 * params: 206 * request - pointer to json rpc request 207 * params - pointer to request parameters 208 * returns: 209 * none 210 */ 211 static void 212 rpc_bdev_raid_create(struct spdk_jsonrpc_request *request, 213 const struct spdk_json_val *params) 214 { 215 struct rpc_bdev_raid_create req = {}; 216 struct raid_bdev *raid_bdev; 217 int rc; 218 size_t i; 219 struct spdk_uuid *uuid = NULL; 220 struct spdk_uuid decoded_uuid; 221 222 if (spdk_json_decode_object(params, rpc_bdev_raid_create_decoders, 223 SPDK_COUNTOF(rpc_bdev_raid_create_decoders), 224 &req)) { 225 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR, 226 "spdk_json_decode_object failed"); 227 goto cleanup; 228 } 229 230 if (req.uuid) { 231 if (spdk_uuid_parse(&decoded_uuid, req.uuid)) { 232 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 233 "Failed to parse bdev UUID"); 234 goto cleanup; 235 } 236 uuid = &decoded_uuid; 237 } 238 239 rc = raid_bdev_create(req.name, req.strip_size_kb, req.base_bdevs.num_base_bdevs, 240 req.level, &raid_bdev, uuid); 241 if (rc != 0) { 242 spdk_jsonrpc_send_error_response_fmt(request, rc, 243 "Failed to create RAID bdev %s: %s", 244 req.name, spdk_strerror(-rc)); 245 goto cleanup; 246 } 247 248 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 249 const char *base_bdev_name = req.base_bdevs.base_bdevs[i]; 250 251 rc = raid_bdev_add_base_device(raid_bdev, base_bdev_name, i); 252 if (rc == -ENODEV) { 253 SPDK_DEBUGLOG(bdev_raid, "base bdev %s doesn't exist now\n", base_bdev_name); 254 } else if (rc != 0) { 255 raid_bdev_delete(raid_bdev, NULL, NULL); 256 spdk_jsonrpc_send_error_response_fmt(request, rc, 257 "Failed to add base bdev %s to RAID bdev %s: %s", 258 base_bdev_name, req.name, 259 spdk_strerror(-rc)); 260 goto cleanup; 261 } 262 } 263 264 spdk_jsonrpc_send_bool_response(request, true); 265 266 cleanup: 267 free_rpc_bdev_raid_create(&req); 268 } 269 SPDK_RPC_REGISTER("bdev_raid_create", rpc_bdev_raid_create, SPDK_RPC_RUNTIME) 270 271 /* 272 * Input structure for RPC deleting a raid bdev 273 */ 274 struct rpc_bdev_raid_delete { 275 /* raid bdev name */ 276 char *name; 277 }; 278 279 /* 280 * brief: 281 * free_rpc_bdev_raid_delete function is used to free RPC bdev_raid_delete related parameters 282 * params: 283 * req - pointer to RPC request 284 * params: 285 * none 286 */ 287 static void 288 free_rpc_bdev_raid_delete(struct rpc_bdev_raid_delete *req) 289 { 290 free(req->name); 291 } 292 293 /* 294 * Decoder object for RPC raid_bdev_delete 295 */ 296 static const struct spdk_json_object_decoder rpc_bdev_raid_delete_decoders[] = { 297 {"name", offsetof(struct rpc_bdev_raid_delete, name), spdk_json_decode_string}, 298 }; 299 300 struct rpc_bdev_raid_delete_ctx { 301 struct rpc_bdev_raid_delete req; 302 struct spdk_jsonrpc_request *request; 303 }; 304 305 /* 306 * brief: 307 * params: 308 * cb_arg - pointer to the callback context. 309 * rc - return code of the deletion of the raid bdev. 310 * returns: 311 * none 312 */ 313 static void 314 bdev_raid_delete_done(void *cb_arg, int rc) 315 { 316 struct rpc_bdev_raid_delete_ctx *ctx = cb_arg; 317 struct spdk_jsonrpc_request *request = ctx->request; 318 319 if (rc != 0) { 320 SPDK_ERRLOG("Failed to delete raid bdev %s (%d): %s\n", 321 ctx->req.name, rc, spdk_strerror(-rc)); 322 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 323 spdk_strerror(-rc)); 324 goto exit; 325 } 326 327 spdk_jsonrpc_send_bool_response(request, true); 328 exit: 329 free_rpc_bdev_raid_delete(&ctx->req); 330 free(ctx); 331 } 332 333 /* 334 * brief: 335 * rpc_bdev_raid_delete function is the RPC for deleting a raid bdev. It takes raid 336 * name as input and delete that raid bdev including freeing the base bdev 337 * resources. 338 * params: 339 * request - pointer to json rpc request 340 * params - pointer to request parameters 341 * returns: 342 * none 343 */ 344 static void 345 rpc_bdev_raid_delete(struct spdk_jsonrpc_request *request, 346 const struct spdk_json_val *params) 347 { 348 struct rpc_bdev_raid_delete_ctx *ctx; 349 struct raid_bdev *raid_bdev; 350 351 ctx = calloc(1, sizeof(*ctx)); 352 if (!ctx) { 353 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 354 return; 355 } 356 357 if (spdk_json_decode_object(params, rpc_bdev_raid_delete_decoders, 358 SPDK_COUNTOF(rpc_bdev_raid_delete_decoders), 359 &ctx->req)) { 360 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR, 361 "spdk_json_decode_object failed"); 362 goto cleanup; 363 } 364 365 raid_bdev = raid_bdev_find_by_name(ctx->req.name); 366 if (raid_bdev == NULL) { 367 spdk_jsonrpc_send_error_response_fmt(request, -ENODEV, 368 "raid bdev %s not found", 369 ctx->req.name); 370 goto cleanup; 371 } 372 373 ctx->request = request; 374 375 raid_bdev_delete(raid_bdev, bdev_raid_delete_done, ctx); 376 377 return; 378 379 cleanup: 380 free_rpc_bdev_raid_delete(&ctx->req); 381 free(ctx); 382 } 383 SPDK_RPC_REGISTER("bdev_raid_delete", rpc_bdev_raid_delete, SPDK_RPC_RUNTIME) 384 385 /* 386 * Decoder object for RPC bdev_raid_remove_base_bdev 387 */ 388 static const struct spdk_json_object_decoder rpc_bdev_raid_remove_base_bdev_decoders[] = { 389 {"name", 0, spdk_json_decode_string}, 390 }; 391 392 static void 393 rpc_bdev_raid_remove_base_bdev_done(void *ctx, int status) 394 { 395 struct spdk_jsonrpc_request *request = ctx; 396 397 if (status != 0) { 398 spdk_jsonrpc_send_error_response_fmt(request, status, "Failed to remove base bdev from raid bdev"); 399 return; 400 } 401 402 spdk_jsonrpc_send_bool_response(request, true); 403 } 404 405 static void 406 rpc_bdev_raid_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx) 407 { 408 } 409 410 /* 411 * brief: 412 * bdev_raid_remove_base_bdev function is the RPC for removing base bdev from a raid bdev. 413 * It takes base bdev name as input. 414 * params: 415 * request - pointer to json rpc request 416 * params - pointer to request parameters 417 * returns: 418 * none 419 */ 420 static void 421 rpc_bdev_raid_remove_base_bdev(struct spdk_jsonrpc_request *request, 422 const struct spdk_json_val *params) 423 { 424 struct spdk_bdev_desc *desc; 425 char *name = NULL; 426 int rc; 427 428 if (spdk_json_decode_object(params, rpc_bdev_raid_remove_base_bdev_decoders, 429 SPDK_COUNTOF(rpc_bdev_raid_remove_base_bdev_decoders), 430 &name)) { 431 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR, 432 "spdk_json_decode_object failed"); 433 return; 434 } 435 436 rc = spdk_bdev_open_ext(name, false, rpc_bdev_raid_event_cb, NULL, &desc); 437 free(name); 438 if (rc != 0) { 439 goto err; 440 } 441 442 rc = raid_bdev_remove_base_bdev(spdk_bdev_desc_get_bdev(desc), rpc_bdev_raid_remove_base_bdev_done, 443 request); 444 spdk_bdev_close(desc); 445 if (rc != 0) { 446 goto err; 447 } 448 449 return; 450 err: 451 rpc_bdev_raid_remove_base_bdev_done(request, rc); 452 } 453 SPDK_RPC_REGISTER("bdev_raid_remove_base_bdev", rpc_bdev_raid_remove_base_bdev, SPDK_RPC_RUNTIME) 454