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