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