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_string(w, raid_bdev->bdev.name); 91 } 92 } 93 spdk_json_write_array_end(w); 94 spdk_jsonrpc_end_result(request, w); 95 96 cleanup: 97 free_rpc_bdev_raid_get_bdevs(&req); 98 } 99 SPDK_RPC_REGISTER("bdev_raid_get_bdevs", rpc_bdev_raid_get_bdevs, SPDK_RPC_RUNTIME) 100 101 /* 102 * Base bdevs in RPC bdev_raid_create 103 */ 104 struct rpc_bdev_raid_create_base_bdevs { 105 /* Number of base bdevs */ 106 size_t num_base_bdevs; 107 108 /* List of base bdevs names */ 109 char *base_bdevs[RPC_MAX_BASE_BDEVS]; 110 }; 111 112 /* 113 * Input structure for RPC rpc_bdev_raid_create 114 */ 115 struct rpc_bdev_raid_create { 116 /* Raid bdev name */ 117 char *name; 118 119 /* RAID strip size in KB */ 120 uint32_t strip_size_kb; 121 122 /* RAID raid level */ 123 enum raid_level level; 124 125 /* Base bdevs information */ 126 struct rpc_bdev_raid_create_base_bdevs base_bdevs; 127 }; 128 129 /* 130 * brief: 131 * free_rpc_bdev_raid_create function is to free RPC bdev_raid_create related parameters 132 * params: 133 * req - pointer to RPC request 134 * returns: 135 * none 136 */ 137 static void 138 free_rpc_bdev_raid_create(struct rpc_bdev_raid_create *req) 139 { 140 size_t i; 141 142 free(req->name); 143 for (i = 0; i < req->base_bdevs.num_base_bdevs; i++) { 144 free(req->base_bdevs.base_bdevs[i]); 145 } 146 } 147 148 /* 149 * Decoder function for RPC bdev_raid_create to decode raid level 150 */ 151 static int 152 decode_raid_level(const struct spdk_json_val *val, void *out) 153 { 154 int ret; 155 char *str = NULL; 156 enum raid_level level; 157 158 ret = spdk_json_decode_string(val, &str); 159 if (ret == 0 && str != NULL) { 160 level = raid_bdev_str_to_level(str); 161 if (level == INVALID_RAID_LEVEL) { 162 ret = -EINVAL; 163 } else { 164 *(enum raid_level *)out = level; 165 } 166 } 167 168 free(str); 169 return ret; 170 } 171 172 /* 173 * Decoder function for RPC bdev_raid_create to decode base bdevs list 174 */ 175 static int 176 decode_base_bdevs(const struct spdk_json_val *val, void *out) 177 { 178 struct rpc_bdev_raid_create_base_bdevs *base_bdevs = out; 179 return spdk_json_decode_array(val, spdk_json_decode_string, base_bdevs->base_bdevs, 180 RPC_MAX_BASE_BDEVS, &base_bdevs->num_base_bdevs, sizeof(char *)); 181 } 182 183 /* 184 * Decoder object for RPC bdev_raid_create 185 */ 186 static const struct spdk_json_object_decoder rpc_bdev_raid_create_decoders[] = { 187 {"name", offsetof(struct rpc_bdev_raid_create, name), spdk_json_decode_string}, 188 {"strip_size_kb", offsetof(struct rpc_bdev_raid_create, strip_size_kb), spdk_json_decode_uint32, true}, 189 {"raid_level", offsetof(struct rpc_bdev_raid_create, level), decode_raid_level}, 190 {"base_bdevs", offsetof(struct rpc_bdev_raid_create, base_bdevs), decode_base_bdevs}, 191 }; 192 193 /* 194 * brief: 195 * rpc_bdev_raid_create function is the RPC for creating RAID bdevs. It takes 196 * input as raid bdev name, raid level, strip size in KB and list of base bdev names. 197 * params: 198 * request - pointer to json rpc request 199 * params - pointer to request parameters 200 * returns: 201 * none 202 */ 203 static void 204 rpc_bdev_raid_create(struct spdk_jsonrpc_request *request, 205 const struct spdk_json_val *params) 206 { 207 struct rpc_bdev_raid_create req = {}; 208 struct raid_bdev *raid_bdev; 209 int rc; 210 size_t i; 211 212 if (spdk_json_decode_object(params, rpc_bdev_raid_create_decoders, 213 SPDK_COUNTOF(rpc_bdev_raid_create_decoders), 214 &req)) { 215 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR, 216 "spdk_json_decode_object failed"); 217 goto cleanup; 218 } 219 220 if (req.strip_size_kb == 0) { 221 spdk_jsonrpc_send_error_response(request, -EINVAL, "strip size not specified"); 222 goto cleanup; 223 } 224 225 rc = raid_bdev_create(req.name, req.strip_size_kb, req.base_bdevs.num_base_bdevs, 226 req.level, &raid_bdev); 227 if (rc != 0) { 228 spdk_jsonrpc_send_error_response_fmt(request, rc, 229 "Failed to create RAID bdev %s: %s", 230 req.name, spdk_strerror(-rc)); 231 goto cleanup; 232 } 233 234 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 235 const char *base_bdev_name = req.base_bdevs.base_bdevs[i]; 236 237 rc = raid_bdev_add_base_device(raid_bdev, base_bdev_name, i); 238 if (rc == -ENODEV) { 239 SPDK_DEBUGLOG(bdev_raid, "base bdev %s doesn't exist now\n", base_bdev_name); 240 } else if (rc != 0) { 241 raid_bdev_delete(raid_bdev, NULL, NULL); 242 spdk_jsonrpc_send_error_response_fmt(request, rc, 243 "Failed to add base bdev %s to RAID bdev %s: %s", 244 base_bdev_name, req.name, 245 spdk_strerror(-rc)); 246 goto cleanup; 247 } 248 } 249 250 spdk_jsonrpc_send_bool_response(request, true); 251 252 cleanup: 253 free_rpc_bdev_raid_create(&req); 254 } 255 SPDK_RPC_REGISTER("bdev_raid_create", rpc_bdev_raid_create, SPDK_RPC_RUNTIME) 256 257 /* 258 * Input structure for RPC deleting a raid bdev 259 */ 260 struct rpc_bdev_raid_delete { 261 /* raid bdev name */ 262 char *name; 263 }; 264 265 /* 266 * brief: 267 * free_rpc_bdev_raid_delete function is used to free RPC bdev_raid_delete related parameters 268 * params: 269 * req - pointer to RPC request 270 * params: 271 * none 272 */ 273 static void 274 free_rpc_bdev_raid_delete(struct rpc_bdev_raid_delete *req) 275 { 276 free(req->name); 277 } 278 279 /* 280 * Decoder object for RPC raid_bdev_delete 281 */ 282 static const struct spdk_json_object_decoder rpc_bdev_raid_delete_decoders[] = { 283 {"name", offsetof(struct rpc_bdev_raid_delete, name), spdk_json_decode_string}, 284 }; 285 286 struct rpc_bdev_raid_delete_ctx { 287 struct rpc_bdev_raid_delete req; 288 struct spdk_jsonrpc_request *request; 289 }; 290 291 /* 292 * brief: 293 * params: 294 * cb_arg - pointer to the callback context. 295 * rc - return code of the deletion of the raid bdev. 296 * returns: 297 * none 298 */ 299 static void 300 bdev_raid_delete_done(void *cb_arg, int rc) 301 { 302 struct rpc_bdev_raid_delete_ctx *ctx = cb_arg; 303 struct spdk_jsonrpc_request *request = ctx->request; 304 305 if (rc != 0) { 306 SPDK_ERRLOG("Failed to delete raid bdev %s (%d): %s\n", 307 ctx->req.name, rc, spdk_strerror(-rc)); 308 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 309 spdk_strerror(-rc)); 310 goto exit; 311 } 312 313 spdk_jsonrpc_send_bool_response(request, true); 314 exit: 315 free_rpc_bdev_raid_delete(&ctx->req); 316 free(ctx); 317 } 318 319 /* 320 * brief: 321 * rpc_bdev_raid_delete function is the RPC for deleting a raid bdev. It takes raid 322 * name as input and delete that raid bdev including freeing the base bdev 323 * resources. 324 * params: 325 * request - pointer to json rpc request 326 * params - pointer to request parameters 327 * returns: 328 * none 329 */ 330 static void 331 rpc_bdev_raid_delete(struct spdk_jsonrpc_request *request, 332 const struct spdk_json_val *params) 333 { 334 struct rpc_bdev_raid_delete_ctx *ctx; 335 struct raid_bdev *raid_bdev; 336 337 ctx = calloc(1, sizeof(*ctx)); 338 if (!ctx) { 339 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 340 return; 341 } 342 343 if (spdk_json_decode_object(params, rpc_bdev_raid_delete_decoders, 344 SPDK_COUNTOF(rpc_bdev_raid_delete_decoders), 345 &ctx->req)) { 346 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR, 347 "spdk_json_decode_object failed"); 348 goto cleanup; 349 } 350 351 raid_bdev = raid_bdev_find_by_name(ctx->req.name); 352 if (raid_bdev == NULL) { 353 spdk_jsonrpc_send_error_response_fmt(request, -ENODEV, 354 "raid bdev %s not found", 355 ctx->req.name); 356 goto cleanup; 357 } 358 359 ctx->request = request; 360 361 raid_bdev_delete(raid_bdev, bdev_raid_delete_done, ctx); 362 363 return; 364 365 cleanup: 366 free_rpc_bdev_raid_delete(&ctx->req); 367 free(ctx); 368 } 369 SPDK_RPC_REGISTER("bdev_raid_delete", rpc_bdev_raid_delete, SPDK_RPC_RUNTIME) 370