1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/rpc.h" 35 #include "spdk/bdev.h" 36 #include "bdev_raid.h" 37 #include "spdk/util.h" 38 #include "spdk/string.h" 39 #include "spdk/log.h" 40 #include "spdk/env.h" 41 42 #define RPC_MAX_BASE_BDEVS 255 43 44 /* 45 * Input structure for bdev_raid_get_bdevs RPC 46 */ 47 struct rpc_bdev_raid_get_bdevs { 48 /* category - all or online or configuring or offline */ 49 char *category; 50 }; 51 52 /* 53 * brief: 54 * free_rpc_bdev_raid_get_bdevs function frees RPC bdev_raid_get_bdevs related parameters 55 * params: 56 * req - pointer to RPC request 57 * returns: 58 * none 59 */ 60 static void 61 free_rpc_bdev_raid_get_bdevs(struct rpc_bdev_raid_get_bdevs *req) 62 { 63 free(req->category); 64 } 65 66 /* 67 * Decoder object for RPC get_raids 68 */ 69 static const struct spdk_json_object_decoder rpc_bdev_raid_get_bdevs_decoders[] = { 70 {"category", offsetof(struct rpc_bdev_raid_get_bdevs, category), spdk_json_decode_string}, 71 }; 72 73 /* 74 * brief: 75 * rpc_bdev_raid_get_bdevs function is the RPC for rpc_bdev_raid_get_bdevs. This is used to list 76 * all the raid bdev names based on the input category requested. Category should be 77 * one of "all", "online", "configuring" or "offline". "all" means all the raids 78 * whether they are online or configuring or offline. "online" is the raid bdev which 79 * is registered with bdev layer. "configuring" is the raid bdev which does not have 80 * full configuration discovered yet. "offline" is the raid bdev which is not 81 * registered with bdev as of now and it has encountered any error or user has 82 * requested to offline the raid. 83 * params: 84 * request - pointer to json rpc request 85 * params - pointer to request parameters 86 * returns: 87 * none 88 */ 89 static void 90 rpc_bdev_raid_get_bdevs(struct spdk_jsonrpc_request *request, 91 const struct spdk_json_val *params) 92 { 93 struct rpc_bdev_raid_get_bdevs req = {}; 94 struct spdk_json_write_ctx *w; 95 struct raid_bdev *raid_bdev; 96 97 if (spdk_json_decode_object(params, rpc_bdev_raid_get_bdevs_decoders, 98 SPDK_COUNTOF(rpc_bdev_raid_get_bdevs_decoders), 99 &req)) { 100 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 101 "spdk_json_decode_object failed"); 102 goto cleanup; 103 } 104 105 if (!(strcmp(req.category, "all") == 0 || 106 strcmp(req.category, "online") == 0 || 107 strcmp(req.category, "configuring") == 0 || 108 strcmp(req.category, "offline") == 0)) { 109 spdk_jsonrpc_send_error_response(request, -EINVAL, spdk_strerror(EINVAL)); 110 goto cleanup; 111 } 112 113 w = spdk_jsonrpc_begin_result(request); 114 spdk_json_write_array_begin(w); 115 116 /* Get raid bdev list based on the category requested */ 117 if (strcmp(req.category, "all") == 0) { 118 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) { 119 spdk_json_write_string(w, raid_bdev->bdev.name); 120 } 121 } else if (strcmp(req.category, "online") == 0) { 122 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_configured_list, state_link) { 123 spdk_json_write_string(w, raid_bdev->bdev.name); 124 } 125 } else if (strcmp(req.category, "configuring") == 0) { 126 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_configuring_list, state_link) { 127 spdk_json_write_string(w, raid_bdev->bdev.name); 128 } 129 } else { 130 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_offline_list, state_link) { 131 spdk_json_write_string(w, raid_bdev->bdev.name); 132 } 133 } 134 spdk_json_write_array_end(w); 135 spdk_jsonrpc_end_result(request, w); 136 137 cleanup: 138 free_rpc_bdev_raid_get_bdevs(&req); 139 } 140 SPDK_RPC_REGISTER("bdev_raid_get_bdevs", rpc_bdev_raid_get_bdevs, SPDK_RPC_RUNTIME) 141 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_get_bdevs, get_raid_bdevs) 142 143 /* 144 * Base bdevs in RPC bdev_raid_create 145 */ 146 struct rpc_bdev_raid_create_base_bdevs { 147 /* Number of base bdevs */ 148 size_t num_base_bdevs; 149 150 /* List of base bdevs names */ 151 char *base_bdevs[RPC_MAX_BASE_BDEVS]; 152 }; 153 154 /* 155 * Input structure for RPC rpc_bdev_raid_create 156 */ 157 struct rpc_bdev_raid_create { 158 /* Raid bdev name */ 159 char *name; 160 161 /* RAID strip size KB, 'strip_size' is deprecated. */ 162 uint32_t strip_size; 163 uint32_t strip_size_kb; 164 165 /* RAID raid level */ 166 enum raid_level level; 167 168 /* Base bdevs information */ 169 struct rpc_bdev_raid_create_base_bdevs base_bdevs; 170 }; 171 172 /* 173 * brief: 174 * free_rpc_bdev_raid_create function is to free RPC bdev_raid_create related parameters 175 * params: 176 * req - pointer to RPC request 177 * returns: 178 * none 179 */ 180 static void 181 free_rpc_bdev_raid_create(struct rpc_bdev_raid_create *req) 182 { 183 size_t i; 184 185 free(req->name); 186 for (i = 0; i < req->base_bdevs.num_base_bdevs; i++) { 187 free(req->base_bdevs.base_bdevs[i]); 188 } 189 } 190 191 /* 192 * Decoder function for RPC bdev_raid_create to decode raid level 193 */ 194 static int 195 decode_raid_level(const struct spdk_json_val *val, void *out) 196 { 197 int ret; 198 char *str = NULL; 199 enum raid_level level; 200 201 ret = spdk_json_decode_string(val, &str); 202 if (ret == 0 && str != NULL) { 203 level = raid_bdev_parse_raid_level(str); 204 if (level == INVALID_RAID_LEVEL) { 205 ret = -EINVAL; 206 } else { 207 *(enum raid_level *)out = level; 208 } 209 } 210 211 free(str); 212 return ret; 213 } 214 215 /* 216 * Decoder function for RPC bdev_raid_create to decode base bdevs list 217 */ 218 static int 219 decode_base_bdevs(const struct spdk_json_val *val, void *out) 220 { 221 struct rpc_bdev_raid_create_base_bdevs *base_bdevs = out; 222 return spdk_json_decode_array(val, spdk_json_decode_string, base_bdevs->base_bdevs, 223 RPC_MAX_BASE_BDEVS, &base_bdevs->num_base_bdevs, sizeof(char *)); 224 } 225 226 /* 227 * Decoder object for RPC bdev_raid_create 228 */ 229 /* Note: strip_size is deprecated, one of the two options must be specified but not both. */ 230 static const struct spdk_json_object_decoder rpc_bdev_raid_create_decoders[] = { 231 {"name", offsetof(struct rpc_bdev_raid_create, name), spdk_json_decode_string}, 232 {"strip_size", offsetof(struct rpc_bdev_raid_create, strip_size), spdk_json_decode_uint32, true}, 233 {"strip_size_kb", offsetof(struct rpc_bdev_raid_create, strip_size_kb), spdk_json_decode_uint32, true}, 234 {"raid_level", offsetof(struct rpc_bdev_raid_create, level), decode_raid_level}, 235 {"base_bdevs", offsetof(struct rpc_bdev_raid_create, base_bdevs), decode_base_bdevs}, 236 }; 237 238 /* 239 * brief: 240 * rpc_bdev_raid_create function is the RPC for creating RAID bdevs. It takes 241 * input as raid bdev name, raid level, strip size in KB and list of base bdev names. 242 * params: 243 * request - pointer to json rpc request 244 * params - pointer to request parameters 245 * returns: 246 * none 247 */ 248 static void 249 rpc_bdev_raid_create(struct spdk_jsonrpc_request *request, 250 const struct spdk_json_val *params) 251 { 252 struct rpc_bdev_raid_create req = {}; 253 struct spdk_json_write_ctx *w; 254 struct raid_bdev_config *raid_cfg; 255 int rc; 256 size_t i; 257 258 if (spdk_json_decode_object(params, rpc_bdev_raid_create_decoders, 259 SPDK_COUNTOF(rpc_bdev_raid_create_decoders), 260 &req)) { 261 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 262 "spdk_json_decode_object failed"); 263 goto cleanup; 264 } 265 266 if (req.strip_size == 0 && req.strip_size_kb == 0) { 267 spdk_jsonrpc_send_error_response(request, EINVAL, "strip size not specified"); 268 goto cleanup; 269 } else if (req.strip_size > 0 && req.strip_size_kb > 0) { 270 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 271 "please use only one strip size option"); 272 goto cleanup; 273 } else if (req.strip_size > 0 && req.strip_size_kb == 0) { 274 SPDK_ERRLOG("the rpc param strip_size is deprecated.\n"); 275 req.strip_size_kb = req.strip_size; 276 } 277 278 rc = raid_bdev_config_add(req.name, req.strip_size_kb, req.base_bdevs.num_base_bdevs, 279 req.level, 280 &raid_cfg); 281 if (rc != 0) { 282 spdk_jsonrpc_send_error_response_fmt(request, rc, 283 "Failed to add RAID bdev config %s: %s", 284 req.name, spdk_strerror(-rc)); 285 goto cleanup; 286 } 287 288 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 289 rc = raid_bdev_config_add_base_bdev(raid_cfg, req.base_bdevs.base_bdevs[i], i); 290 if (rc != 0) { 291 raid_bdev_config_cleanup(raid_cfg); 292 spdk_jsonrpc_send_error_response_fmt(request, rc, 293 "Failed to add base bdev %s to RAID bdev config %s: %s", 294 req.base_bdevs.base_bdevs[i], req.name, 295 spdk_strerror(-rc)); 296 goto cleanup; 297 } 298 } 299 300 rc = raid_bdev_create(raid_cfg); 301 if (rc != 0) { 302 raid_bdev_config_cleanup(raid_cfg); 303 spdk_jsonrpc_send_error_response_fmt(request, rc, 304 "Failed to create RAID bdev %s: %s", 305 req.name, spdk_strerror(-rc)); 306 goto cleanup; 307 } 308 309 rc = raid_bdev_add_base_devices(raid_cfg); 310 if (rc != 0) { 311 spdk_jsonrpc_send_error_response_fmt(request, rc, 312 "Failed to add any base bdev to RAID bdev %s: %s", 313 req.name, spdk_strerror(-rc)); 314 goto cleanup; 315 } 316 317 w = spdk_jsonrpc_begin_result(request); 318 spdk_json_write_bool(w, true); 319 spdk_jsonrpc_end_result(request, w); 320 321 cleanup: 322 free_rpc_bdev_raid_create(&req); 323 } 324 SPDK_RPC_REGISTER("bdev_raid_create", rpc_bdev_raid_create, SPDK_RPC_RUNTIME) 325 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_create, construct_raid_bdev) 326 327 /* 328 * Input structure for RPC deleting a raid bdev 329 */ 330 struct rpc_bdev_raid_delete { 331 /* raid bdev name */ 332 char *name; 333 }; 334 335 /* 336 * brief: 337 * free_rpc_bdev_raid_delete function is used to free RPC bdev_raid_delete related parameters 338 * params: 339 * req - pointer to RPC request 340 * params: 341 * none 342 */ 343 static void 344 free_rpc_bdev_raid_delete(struct rpc_bdev_raid_delete *req) 345 { 346 free(req->name); 347 } 348 349 /* 350 * Decoder object for RPC raid_bdev_delete 351 */ 352 static const struct spdk_json_object_decoder rpc_bdev_raid_delete_decoders[] = { 353 {"name", offsetof(struct rpc_bdev_raid_delete, name), spdk_json_decode_string}, 354 }; 355 356 struct rpc_bdev_raid_delete_ctx { 357 struct rpc_bdev_raid_delete req; 358 struct raid_bdev_config *raid_cfg; 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 bdev_raid_delete_done(void *cb_arg, int rc) 372 { 373 struct rpc_bdev_raid_delete_ctx *ctx = cb_arg; 374 struct raid_bdev_config *raid_cfg; 375 struct spdk_jsonrpc_request *request = ctx->request; 376 struct spdk_json_write_ctx *w; 377 378 if (rc != 0) { 379 SPDK_ERRLOG("Failed to delete raid bdev %s (%d): %s\n", 380 ctx->req.name, rc, spdk_strerror(-rc)); 381 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 382 spdk_strerror(-rc)); 383 goto exit; 384 } 385 386 raid_cfg = ctx->raid_cfg; 387 assert(raid_cfg->raid_bdev == NULL); 388 389 raid_bdev_config_cleanup(raid_cfg); 390 391 w = spdk_jsonrpc_begin_result(request); 392 spdk_json_write_bool(w, true); 393 spdk_jsonrpc_end_result(request, w); 394 exit: 395 free_rpc_bdev_raid_delete(&ctx->req); 396 free(ctx); 397 } 398 399 /* 400 * brief: 401 * rpc_bdev_raid_delete function is the RPC for deleting a raid bdev. It takes raid 402 * name as input and delete that raid bdev including freeing the base bdev 403 * resources. 404 * params: 405 * request - pointer to json rpc request 406 * params - pointer to request parameters 407 * returns: 408 * none 409 */ 410 static void 411 rpc_bdev_raid_delete(struct spdk_jsonrpc_request *request, 412 const struct spdk_json_val *params) 413 { 414 struct rpc_bdev_raid_delete_ctx *ctx; 415 416 ctx = calloc(1, sizeof(*ctx)); 417 if (!ctx) { 418 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 419 return; 420 } 421 422 if (spdk_json_decode_object(params, rpc_bdev_raid_delete_decoders, 423 SPDK_COUNTOF(rpc_bdev_raid_delete_decoders), 424 &ctx->req)) { 425 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 426 "spdk_json_decode_object failed"); 427 goto cleanup; 428 } 429 430 ctx->raid_cfg = raid_bdev_config_find_by_name(ctx->req.name); 431 if (ctx->raid_cfg == NULL) { 432 spdk_jsonrpc_send_error_response_fmt(request, ENODEV, 433 "raid bdev %s is not found in config", 434 ctx->req.name); 435 goto cleanup; 436 } 437 438 ctx->request = request; 439 440 /* Remove all the base bdevs from this raid bdev before deleting the raid bdev */ 441 raid_bdev_remove_base_devices(ctx->raid_cfg, bdev_raid_delete_done, ctx); 442 443 return; 444 445 cleanup: 446 free_rpc_bdev_raid_delete(&ctx->req); 447 free(ctx); 448 } 449 SPDK_RPC_REGISTER("bdev_raid_delete", rpc_bdev_raid_delete, SPDK_RPC_RUNTIME) 450 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_delete, destroy_raid_bdev) 451