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_internal/log.h" 40 #include "spdk/env.h" 41 42 #define RPC_MAX_BASE_BDEVS 255 43 44 SPDK_LOG_REGISTER_COMPONENT("raidrpc", SPDK_LOG_RAID_RPC) 45 46 /* 47 * Input structure for bdev_raid_get_bdevs RPC 48 */ 49 struct rpc_bdev_raid_get_bdevs { 50 /* category - all or online or configuring or offline */ 51 char *category; 52 }; 53 54 /* 55 * brief: 56 * free_rpc_bdev_raid_get_bdevs function frees RPC bdev_raid_get_bdevs related parameters 57 * params: 58 * req - pointer to RPC request 59 * returns: 60 * none 61 */ 62 static void 63 free_rpc_bdev_raid_get_bdevs(struct rpc_bdev_raid_get_bdevs *req) 64 { 65 free(req->category); 66 } 67 68 /* 69 * Decoder object for RPC get_raids 70 */ 71 static const struct spdk_json_object_decoder rpc_bdev_raid_get_bdevs_decoders[] = { 72 {"category", offsetof(struct rpc_bdev_raid_get_bdevs, category), spdk_json_decode_string}, 73 }; 74 75 /* 76 * brief: 77 * spdk_rpc_bdev_raid_get_bdevs function is the RPC for spdk_rpc_bdev_raid_get_bdevs. This is used to list 78 * all the raid bdev names based on the input category requested. Category should be 79 * one of "all", "online", "configuring" or "offline". "all" means all the raids 80 * whether they are online or configuring or offline. "online" is the raid bdev which 81 * is registered with bdev layer. "configuring" is the raid bdev which does not have 82 * full configuration discovered yet. "offline" is the raid bdev which is not 83 * registered with bdev as of now and it has encountered any error or user has 84 * requested to offline the raid. 85 * params: 86 * requuest - pointer to json rpc request 87 * params - pointer to request parameters 88 * returns: 89 * none 90 */ 91 static void 92 spdk_rpc_bdev_raid_get_bdevs(struct spdk_jsonrpc_request *request, 93 const struct spdk_json_val *params) 94 { 95 struct rpc_bdev_raid_get_bdevs req = {}; 96 struct spdk_json_write_ctx *w; 97 struct raid_bdev *raid_bdev; 98 99 if (spdk_json_decode_object(params, rpc_bdev_raid_get_bdevs_decoders, 100 SPDK_COUNTOF(rpc_bdev_raid_get_bdevs_decoders), 101 &req)) { 102 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 103 "spdk_json_decode_object failed"); 104 goto cleanup; 105 } 106 107 if (!(strcmp(req.category, "all") == 0 || 108 strcmp(req.category, "online") == 0 || 109 strcmp(req.category, "configuring") == 0 || 110 strcmp(req.category, "offline") == 0)) { 111 spdk_jsonrpc_send_error_response(request, -EINVAL, spdk_strerror(EINVAL)); 112 goto cleanup; 113 } 114 115 w = spdk_jsonrpc_begin_result(request); 116 spdk_json_write_array_begin(w); 117 118 /* Get raid bdev list based on the category requested */ 119 if (strcmp(req.category, "all") == 0) { 120 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_list, global_link) { 121 spdk_json_write_string(w, raid_bdev->bdev.name); 122 } 123 } else if (strcmp(req.category, "online") == 0) { 124 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_configured_list, state_link) { 125 spdk_json_write_string(w, raid_bdev->bdev.name); 126 } 127 } else if (strcmp(req.category, "configuring") == 0) { 128 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_configuring_list, state_link) { 129 spdk_json_write_string(w, raid_bdev->bdev.name); 130 } 131 } else { 132 TAILQ_FOREACH(raid_bdev, &g_raid_bdev_offline_list, state_link) { 133 spdk_json_write_string(w, raid_bdev->bdev.name); 134 } 135 } 136 spdk_json_write_array_end(w); 137 spdk_jsonrpc_end_result(request, w); 138 139 cleanup: 140 free_rpc_bdev_raid_get_bdevs(&req); 141 } 142 SPDK_RPC_REGISTER("bdev_raid_get_bdevs", spdk_rpc_bdev_raid_get_bdevs, SPDK_RPC_RUNTIME) 143 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_get_bdevs, get_raid_bdevs) 144 145 /* 146 * Base bdevs in RPC bdev_raid_create 147 */ 148 struct rpc_bdev_raid_create_base_bdevs { 149 /* Number of base bdevs */ 150 size_t num_base_bdevs; 151 152 /* List of base bdevs names */ 153 char *base_bdevs[RPC_MAX_BASE_BDEVS]; 154 }; 155 156 /* 157 * Input structure for RPC rpc_bdev_raid_create 158 */ 159 struct rpc_bdev_raid_create { 160 /* Raid bdev name */ 161 char *name; 162 163 /* RAID strip size KB, 'strip_size' is deprecated. */ 164 uint32_t strip_size; 165 uint32_t strip_size_kb; 166 167 /* RAID raid level */ 168 uint8_t raid_level; 169 170 /* Base bdevs information */ 171 struct rpc_bdev_raid_create_base_bdevs base_bdevs; 172 }; 173 174 /* 175 * brief: 176 * free_rpc_bdev_raid_create function is to free RPC bdev_raid_create related parameters 177 * params: 178 * req - pointer to RPC request 179 * returns: 180 * none 181 */ 182 static void 183 free_rpc_bdev_raid_create(struct rpc_bdev_raid_create *req) 184 { 185 free(req->name); 186 for (size_t 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 base bdevs list 193 */ 194 static int 195 decode_base_bdevs(const struct spdk_json_val *val, void *out) 196 { 197 struct rpc_bdev_raid_create_base_bdevs *base_bdevs = out; 198 return spdk_json_decode_array(val, spdk_json_decode_string, base_bdevs->base_bdevs, 199 RPC_MAX_BASE_BDEVS, &base_bdevs->num_base_bdevs, sizeof(char *)); 200 } 201 202 /* 203 * Decoder object for RPC bdev_raid_create 204 */ 205 /* Note: strip_size is deprecated, one of the two options must be specified but not both. */ 206 static const struct spdk_json_object_decoder rpc_bdev_raid_create_decoders[] = { 207 {"name", offsetof(struct rpc_bdev_raid_create, name), spdk_json_decode_string}, 208 {"strip_size", offsetof(struct rpc_bdev_raid_create, strip_size), spdk_json_decode_uint32, true}, 209 {"strip_size_kb", offsetof(struct rpc_bdev_raid_create, strip_size_kb), spdk_json_decode_uint32, true}, 210 {"raid_level", offsetof(struct rpc_bdev_raid_create, raid_level), spdk_json_decode_uint32}, 211 {"base_bdevs", offsetof(struct rpc_bdev_raid_create, base_bdevs), decode_base_bdevs}, 212 }; 213 214 /* 215 * brief: 216 * spdk_rpc_bdev_raid_create function is the RPC for creating RAID bdevs. It takes 217 * input as raid bdev name, raid level, strip size in KB and list of base bdev names. 218 * params: 219 * requuest - pointer to json rpc request 220 * params - pointer to request parameters 221 * returns: 222 * none 223 */ 224 static void 225 spdk_rpc_bdev_raid_create(struct spdk_jsonrpc_request *request, 226 const struct spdk_json_val *params) 227 { 228 struct rpc_bdev_raid_create req = {}; 229 struct spdk_json_write_ctx *w; 230 struct raid_bdev_config *raid_cfg; 231 int rc; 232 233 if (spdk_json_decode_object(params, rpc_bdev_raid_create_decoders, 234 SPDK_COUNTOF(rpc_bdev_raid_create_decoders), 235 &req)) { 236 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 237 "spdk_json_decode_object failed"); 238 goto cleanup; 239 } 240 241 if (req.strip_size == 0 && req.strip_size_kb == 0) { 242 spdk_jsonrpc_send_error_response(request, EINVAL, "strip size not specified"); 243 goto cleanup; 244 } else if (req.strip_size > 0 && req.strip_size_kb > 0) { 245 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 246 "please use only one strip size option"); 247 goto cleanup; 248 } else if (req.strip_size > 0 && req.strip_size_kb == 0) { 249 SPDK_ERRLOG("the rpc param strip_size is deprecated.\n"); 250 req.strip_size_kb = req.strip_size; 251 } 252 253 rc = raid_bdev_config_add(req.name, req.strip_size_kb, req.base_bdevs.num_base_bdevs, 254 req.raid_level, 255 &raid_cfg); 256 if (rc != 0) { 257 spdk_jsonrpc_send_error_response_fmt(request, rc, 258 "Failed to add RAID bdev config %s: %s", 259 req.name, spdk_strerror(-rc)); 260 goto cleanup; 261 } 262 263 for (size_t i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 264 rc = raid_bdev_config_add_base_bdev(raid_cfg, req.base_bdevs.base_bdevs[i], i); 265 if (rc != 0) { 266 raid_bdev_config_cleanup(raid_cfg); 267 spdk_jsonrpc_send_error_response_fmt(request, rc, 268 "Failed to add base bdev %s to RAID bdev config %s: %s", 269 req.base_bdevs.base_bdevs[i], req.name, 270 spdk_strerror(-rc)); 271 goto cleanup; 272 } 273 } 274 275 rc = raid_bdev_create(raid_cfg); 276 if (rc != 0) { 277 raid_bdev_config_cleanup(raid_cfg); 278 spdk_jsonrpc_send_error_response_fmt(request, rc, 279 "Failed to create RAID bdev %s: %s", 280 req.name, spdk_strerror(-rc)); 281 goto cleanup; 282 } 283 284 rc = raid_bdev_add_base_devices(raid_cfg); 285 if (rc != 0) { 286 spdk_jsonrpc_send_error_response_fmt(request, rc, 287 "Failed to add any base bdev to RAID bdev %s: %s", 288 req.name, spdk_strerror(-rc)); 289 goto cleanup; 290 } 291 292 w = spdk_jsonrpc_begin_result(request); 293 spdk_json_write_bool(w, true); 294 spdk_jsonrpc_end_result(request, w); 295 296 cleanup: 297 free_rpc_bdev_raid_create(&req); 298 } 299 SPDK_RPC_REGISTER("bdev_raid_create", spdk_rpc_bdev_raid_create, SPDK_RPC_RUNTIME) 300 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_create, construct_raid_bdev) 301 302 /* 303 * Input structure for RPC deleting a raid bdev 304 */ 305 struct rpc_bdev_raid_delete { 306 /* raid bdev name */ 307 char *name; 308 }; 309 310 /* 311 * brief: 312 * free_rpc_bdev_raid_delete function is used to free RPC bdev_raid_delete related parameters 313 * params: 314 * req - pointer to RPC request 315 * params: 316 * none 317 */ 318 static void 319 free_rpc_bdev_raid_delete(struct rpc_bdev_raid_delete *req) 320 { 321 free(req->name); 322 } 323 324 /* 325 * Decoder object for RPC raid_bdev_delete 326 */ 327 static const struct spdk_json_object_decoder rpc_bdev_raid_delete_decoders[] = { 328 {"name", offsetof(struct rpc_bdev_raid_delete, name), spdk_json_decode_string}, 329 }; 330 331 struct rpc_bdev_raid_delete_ctx { 332 struct rpc_bdev_raid_delete req; 333 struct raid_bdev_config *raid_cfg; 334 struct spdk_jsonrpc_request *request; 335 }; 336 337 /* 338 * brief: 339 * params: 340 * cb_arg - pointer to the callback context. 341 * rc - return code of the deletion of the raid bdev. 342 * returns: 343 * none 344 */ 345 static void 346 bdev_raid_delete_done(void *cb_arg, int rc) 347 { 348 struct rpc_bdev_raid_delete_ctx *ctx = cb_arg; 349 struct raid_bdev_config *raid_cfg; 350 struct spdk_jsonrpc_request *request = ctx->request; 351 struct spdk_json_write_ctx *w; 352 353 if (rc != 0) { 354 SPDK_ERRLOG("Failed to delete raid bdev %s (%d): %s\n", 355 ctx->req.name, rc, spdk_strerror(-rc)); 356 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 357 spdk_strerror(-rc)); 358 goto exit; 359 } 360 361 raid_cfg = ctx->raid_cfg; 362 assert(raid_cfg->raid_bdev == NULL); 363 364 raid_bdev_config_cleanup(raid_cfg); 365 366 w = spdk_jsonrpc_begin_result(request); 367 spdk_json_write_bool(w, true); 368 spdk_jsonrpc_end_result(request, w); 369 exit: 370 free_rpc_bdev_raid_delete(&ctx->req); 371 free(ctx); 372 } 373 374 /* 375 * brief: 376 * spdk_rpc_bdev_raid_delete function is the RPC for deleting a raid bdev. It takes raid 377 * name as input and delete that raid bdev including freeing the base bdev 378 * resources. 379 * params: 380 * requuest - pointer to json rpc request 381 * params - pointer to request parameters 382 * returns: 383 * none 384 */ 385 static void 386 spdk_rpc_bdev_raid_delete(struct spdk_jsonrpc_request *request, 387 const struct spdk_json_val *params) 388 { 389 struct rpc_bdev_raid_delete_ctx *ctx; 390 391 ctx = calloc(1, sizeof(*ctx)); 392 if (!ctx) { 393 spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM)); 394 return; 395 } 396 397 if (spdk_json_decode_object(params, rpc_bdev_raid_delete_decoders, 398 SPDK_COUNTOF(rpc_bdev_raid_delete_decoders), 399 &ctx->req)) { 400 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 401 "spdk_json_decode_object failed"); 402 goto cleanup; 403 } 404 405 ctx->raid_cfg = raid_bdev_config_find_by_name(ctx->req.name); 406 if (ctx->raid_cfg == NULL) { 407 spdk_jsonrpc_send_error_response_fmt(request, ENODEV, 408 "raid bdev %s is not found in config", 409 ctx->req.name); 410 goto cleanup; 411 } 412 413 ctx->request = request; 414 415 /* Remove all the base bdevs from this raid bdev before deleting the raid bdev */ 416 raid_bdev_remove_base_devices(ctx->raid_cfg, bdev_raid_delete_done, ctx); 417 418 return; 419 420 cleanup: 421 free_rpc_bdev_raid_delete(&ctx->req); 422 free(ctx); 423 } 424 SPDK_RPC_REGISTER("bdev_raid_delete", spdk_rpc_bdev_raid_delete, SPDK_RPC_RUNTIME) 425 SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_delete, destroy_raid_bdev) 426