1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2018 Intel Corporation. 3 * All rights reserved. 4 * Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk/stdinc.h" 8 #include "spdk_internal/cunit.h" 9 #include "spdk/env.h" 10 #include "spdk_internal/mock.h" 11 #include "thread/thread_internal.h" 12 #include "bdev/raid/bdev_raid.c" 13 #include "bdev/raid/bdev_raid_rpc.c" 14 #include "bdev/raid/raid0.c" 15 #include "common/lib/ut_multithread.c" 16 17 #define MAX_BASE_DRIVES 32 18 #define MAX_RAIDS 2 19 #define INVALID_IO_SUBMIT 0xFFFF 20 #define MAX_TEST_IO_RANGE (3 * 3 * 3 * (MAX_BASE_DRIVES + 5)) 21 #define BLOCK_CNT (1024ul * 1024ul * 1024ul * 1024ul) 22 23 struct spdk_bdev_channel { 24 struct spdk_io_channel *channel; 25 }; 26 27 struct spdk_bdev_desc { 28 struct spdk_bdev *bdev; 29 }; 30 31 /* Data structure to capture the output of IO for verification */ 32 struct io_output { 33 struct spdk_bdev_desc *desc; 34 struct spdk_io_channel *ch; 35 uint64_t offset_blocks; 36 uint64_t num_blocks; 37 spdk_bdev_io_completion_cb cb; 38 void *cb_arg; 39 enum spdk_bdev_io_type iotype; 40 }; 41 42 struct raid_io_ranges { 43 uint64_t lba; 44 uint64_t nblocks; 45 }; 46 47 /* Globals */ 48 int g_bdev_io_submit_status; 49 struct io_output *g_io_output = NULL; 50 uint32_t g_io_output_index; 51 uint32_t g_io_comp_status; 52 bool g_child_io_status_flag; 53 void *g_rpc_req; 54 uint32_t g_rpc_req_size; 55 TAILQ_HEAD(bdev, spdk_bdev); 56 struct bdev g_bdev_list; 57 TAILQ_HEAD(waitq, spdk_bdev_io_wait_entry); 58 struct waitq g_io_waitq; 59 uint32_t g_block_len; 60 uint32_t g_strip_size; 61 uint32_t g_max_io_size; 62 uint8_t g_max_base_drives; 63 uint8_t g_max_raids; 64 uint8_t g_ignore_io_output; 65 uint8_t g_rpc_err; 66 char *g_get_raids_output[MAX_RAIDS]; 67 uint32_t g_get_raids_count; 68 uint8_t g_json_decode_obj_err; 69 uint8_t g_json_decode_obj_create; 70 uint8_t g_config_level_create = 0; 71 uint8_t g_test_multi_raids; 72 struct raid_io_ranges g_io_ranges[MAX_TEST_IO_RANGE]; 73 uint32_t g_io_range_idx; 74 uint64_t g_lba_offset; 75 struct spdk_io_channel g_io_channel; 76 77 DEFINE_STUB_V(spdk_bdev_module_examine_done, (struct spdk_bdev_module *module)); 78 DEFINE_STUB_V(spdk_bdev_module_list_add, (struct spdk_bdev_module *bdev_module)); 79 DEFINE_STUB(spdk_bdev_register, int, (struct spdk_bdev *bdev), 0); 80 DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev, 81 enum spdk_bdev_io_type io_type), true); 82 DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); 83 DEFINE_STUB(spdk_bdev_flush_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 84 uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb, 85 void *cb_arg), 0); 86 DEFINE_STUB(spdk_conf_next_section, struct spdk_conf_section *, (struct spdk_conf_section *sp), 87 NULL); 88 DEFINE_STUB_V(spdk_rpc_register_method, (const char *method, spdk_rpc_method_handler func, 89 uint32_t state_mask)); 90 DEFINE_STUB_V(spdk_rpc_register_alias_deprecated, (const char *method, const char *alias)); 91 DEFINE_STUB_V(spdk_jsonrpc_end_result, (struct spdk_jsonrpc_request *request, 92 struct spdk_json_write_ctx *w)); 93 DEFINE_STUB_V(spdk_jsonrpc_send_bool_response, (struct spdk_jsonrpc_request *request, 94 bool value)); 95 DEFINE_STUB(spdk_json_decode_string, int, (const struct spdk_json_val *val, void *out), 0); 96 DEFINE_STUB(spdk_json_decode_uint32, int, (const struct spdk_json_val *val, void *out), 0); 97 DEFINE_STUB(spdk_json_decode_array, int, (const struct spdk_json_val *values, 98 spdk_json_decode_fn decode_func, 99 void *out, size_t max_size, size_t *out_size, size_t stride), 0); 100 DEFINE_STUB(spdk_json_write_name, int, (struct spdk_json_write_ctx *w, const char *name), 0); 101 DEFINE_STUB(spdk_json_write_object_begin, int, (struct spdk_json_write_ctx *w), 0); 102 DEFINE_STUB(spdk_json_write_named_object_begin, int, (struct spdk_json_write_ctx *w, 103 const char *name), 0); 104 DEFINE_STUB(spdk_json_write_string, int, (struct spdk_json_write_ctx *w, const char *val), 0); 105 DEFINE_STUB(spdk_json_write_object_end, int, (struct spdk_json_write_ctx *w), 0); 106 DEFINE_STUB(spdk_json_write_array_begin, int, (struct spdk_json_write_ctx *w), 0); 107 DEFINE_STUB(spdk_json_write_array_end, int, (struct spdk_json_write_ctx *w), 0); 108 DEFINE_STUB(spdk_json_write_named_array_begin, int, (struct spdk_json_write_ctx *w, 109 const char *name), 0); 110 DEFINE_STUB(spdk_json_write_bool, int, (struct spdk_json_write_ctx *w, bool val), 0); 111 DEFINE_STUB(spdk_json_write_null, int, (struct spdk_json_write_ctx *w), 0); 112 DEFINE_STUB(spdk_strerror, const char *, (int errnum), NULL); 113 DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch, 114 struct spdk_bdev_io_wait_entry *entry), 0); 115 DEFINE_STUB(spdk_bdev_get_memory_domains, int, (struct spdk_bdev *bdev, 116 struct spdk_memory_domain **domains, int array_size), 0); 117 DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test_bdev"); 118 DEFINE_STUB(spdk_bdev_get_md_size, uint32_t, (const struct spdk_bdev *bdev), 0); 119 DEFINE_STUB(spdk_bdev_is_md_interleaved, bool, (const struct spdk_bdev *bdev), false); 120 DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type, (const struct spdk_bdev *bdev), 121 SPDK_DIF_DISABLE); 122 DEFINE_STUB(spdk_bdev_is_dif_head_of_md, bool, (const struct spdk_bdev *bdev), false); 123 DEFINE_STUB(spdk_bdev_notify_blockcnt_change, int, (struct spdk_bdev *bdev, uint64_t size), 0); 124 125 struct spdk_io_channel * 126 spdk_bdev_get_io_channel(struct spdk_bdev_desc *desc) 127 { 128 g_io_channel.thread = spdk_get_thread(); 129 130 return &g_io_channel; 131 } 132 133 static void 134 set_test_opts(void) 135 { 136 137 g_max_base_drives = MAX_BASE_DRIVES; 138 g_max_raids = MAX_RAIDS; 139 g_block_len = 4096; 140 g_strip_size = 64; 141 g_max_io_size = 1024; 142 143 printf("Test Options\n"); 144 printf("blocklen = %u, strip_size = %u, max_io_size = %u, g_max_base_drives = %u, " 145 "g_max_raids = %u\n", 146 g_block_len, g_strip_size, g_max_io_size, g_max_base_drives, g_max_raids); 147 } 148 149 /* Set globals before every test run */ 150 static void 151 set_globals(void) 152 { 153 uint32_t max_splits; 154 155 g_bdev_io_submit_status = 0; 156 if (g_max_io_size < g_strip_size) { 157 max_splits = 2; 158 } else { 159 max_splits = (g_max_io_size / g_strip_size) + 1; 160 } 161 if (max_splits < g_max_base_drives) { 162 max_splits = g_max_base_drives; 163 } 164 165 g_io_output = calloc(max_splits, sizeof(struct io_output)); 166 SPDK_CU_ASSERT_FATAL(g_io_output != NULL); 167 g_io_output_index = 0; 168 memset(g_get_raids_output, 0, sizeof(g_get_raids_output)); 169 g_get_raids_count = 0; 170 g_io_comp_status = 0; 171 g_ignore_io_output = 0; 172 g_config_level_create = 0; 173 g_rpc_err = 0; 174 g_test_multi_raids = 0; 175 g_child_io_status_flag = true; 176 TAILQ_INIT(&g_bdev_list); 177 TAILQ_INIT(&g_io_waitq); 178 g_rpc_req = NULL; 179 g_rpc_req_size = 0; 180 g_json_decode_obj_err = 0; 181 g_json_decode_obj_create = 0; 182 g_lba_offset = 0; 183 } 184 185 static void 186 base_bdevs_cleanup(void) 187 { 188 struct spdk_bdev *bdev; 189 struct spdk_bdev *bdev_next; 190 191 if (!TAILQ_EMPTY(&g_bdev_list)) { 192 TAILQ_FOREACH_SAFE(bdev, &g_bdev_list, internal.link, bdev_next) { 193 free(bdev->name); 194 TAILQ_REMOVE(&g_bdev_list, bdev, internal.link); 195 free(bdev); 196 } 197 } 198 } 199 200 static void 201 check_and_remove_raid_bdev(struct raid_bdev *raid_bdev) 202 { 203 struct raid_base_bdev_info *base_info; 204 205 assert(raid_bdev != NULL); 206 assert(raid_bdev->base_bdev_info != NULL); 207 208 RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) { 209 if (base_info->desc) { 210 raid_bdev_free_base_bdev_resource(base_info); 211 } 212 } 213 assert(raid_bdev->num_base_bdevs_discovered == 0); 214 raid_bdev_cleanup_and_free(raid_bdev); 215 } 216 217 /* Reset globals */ 218 static void 219 reset_globals(void) 220 { 221 if (g_io_output) { 222 free(g_io_output); 223 g_io_output = NULL; 224 } 225 g_rpc_req = NULL; 226 g_rpc_req_size = 0; 227 } 228 229 void 230 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, 231 uint64_t len) 232 { 233 cb(bdev_io->internal.ch->channel, bdev_io, true); 234 } 235 236 /* Store the IO completion status in global variable to verify by various tests */ 237 void 238 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 239 { 240 g_io_comp_status = ((status == SPDK_BDEV_IO_STATUS_SUCCESS) ? true : false); 241 } 242 243 static void 244 set_io_output(struct io_output *output, 245 struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 246 uint64_t offset_blocks, uint64_t num_blocks, 247 spdk_bdev_io_completion_cb cb, void *cb_arg, 248 enum spdk_bdev_io_type iotype) 249 { 250 output->desc = desc; 251 output->ch = ch; 252 output->offset_blocks = offset_blocks; 253 output->num_blocks = num_blocks; 254 output->cb = cb; 255 output->cb_arg = cb_arg; 256 output->iotype = iotype; 257 } 258 259 /* It will cache the split IOs for verification */ 260 int 261 spdk_bdev_writev_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 262 struct iovec *iov, int iovcnt, 263 uint64_t offset_blocks, uint64_t num_blocks, 264 spdk_bdev_io_completion_cb cb, void *cb_arg) 265 { 266 struct io_output *output = &g_io_output[g_io_output_index]; 267 struct spdk_bdev_io *child_io; 268 269 if (g_ignore_io_output) { 270 return 0; 271 } 272 273 if (g_max_io_size < g_strip_size) { 274 SPDK_CU_ASSERT_FATAL(g_io_output_index < 2); 275 } else { 276 SPDK_CU_ASSERT_FATAL(g_io_output_index < (g_max_io_size / g_strip_size) + 1); 277 } 278 if (g_bdev_io_submit_status == 0) { 279 set_io_output(output, desc, ch, offset_blocks, num_blocks, cb, cb_arg, 280 SPDK_BDEV_IO_TYPE_WRITE); 281 g_io_output_index++; 282 283 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 284 SPDK_CU_ASSERT_FATAL(child_io != NULL); 285 cb(child_io, g_child_io_status_flag, cb_arg); 286 } 287 288 return g_bdev_io_submit_status; 289 } 290 291 int 292 spdk_bdev_writev_blocks_ext(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 293 struct iovec *iov, int iovcnt, 294 uint64_t offset_blocks, uint64_t num_blocks, 295 spdk_bdev_io_completion_cb cb, void *cb_arg, 296 struct spdk_bdev_ext_io_opts *opts) 297 { 298 return spdk_bdev_writev_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 299 } 300 301 int 302 spdk_bdev_writev_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 303 struct iovec *iov, int iovcnt, void *md, 304 uint64_t offset_blocks, uint64_t num_blocks, 305 spdk_bdev_io_completion_cb cb, void *cb_arg) 306 { 307 return spdk_bdev_writev_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 308 } 309 310 int 311 spdk_bdev_reset(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 312 spdk_bdev_io_completion_cb cb, void *cb_arg) 313 { 314 struct io_output *output = &g_io_output[g_io_output_index]; 315 struct spdk_bdev_io *child_io; 316 317 if (g_ignore_io_output) { 318 return 0; 319 } 320 321 if (g_bdev_io_submit_status == 0) { 322 set_io_output(output, desc, ch, 0, 0, cb, cb_arg, SPDK_BDEV_IO_TYPE_RESET); 323 g_io_output_index++; 324 325 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 326 SPDK_CU_ASSERT_FATAL(child_io != NULL); 327 cb(child_io, g_child_io_status_flag, cb_arg); 328 } 329 330 return g_bdev_io_submit_status; 331 } 332 333 int 334 spdk_bdev_unmap_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 335 uint64_t offset_blocks, uint64_t num_blocks, 336 spdk_bdev_io_completion_cb cb, void *cb_arg) 337 { 338 struct io_output *output = &g_io_output[g_io_output_index]; 339 struct spdk_bdev_io *child_io; 340 341 if (g_ignore_io_output) { 342 return 0; 343 } 344 345 if (g_bdev_io_submit_status == 0) { 346 set_io_output(output, desc, ch, offset_blocks, num_blocks, cb, cb_arg, 347 SPDK_BDEV_IO_TYPE_UNMAP); 348 g_io_output_index++; 349 350 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 351 SPDK_CU_ASSERT_FATAL(child_io != NULL); 352 cb(child_io, g_child_io_status_flag, cb_arg); 353 } 354 355 return g_bdev_io_submit_status; 356 } 357 358 void 359 spdk_bdev_destruct_done(struct spdk_bdev *bdev, int bdeverrno) 360 { 361 CU_ASSERT(bdeverrno == 0); 362 SPDK_CU_ASSERT_FATAL(bdev->internal.unregister_cb != NULL); 363 bdev->internal.unregister_cb(bdev->internal.unregister_ctx, bdeverrno); 364 } 365 366 void 367 spdk_bdev_unregister(struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg) 368 { 369 int ret; 370 371 bdev->internal.unregister_cb = cb_fn; 372 bdev->internal.unregister_ctx = cb_arg; 373 374 ret = bdev->fn_table->destruct(bdev->ctxt); 375 CU_ASSERT(ret == 1); 376 377 poll_threads(); 378 } 379 380 int 381 spdk_bdev_open_ext(const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb, 382 void *event_ctx, struct spdk_bdev_desc **_desc) 383 { 384 struct spdk_bdev *bdev; 385 386 bdev = spdk_bdev_get_by_name(bdev_name); 387 if (bdev == NULL) { 388 return -ENODEV; 389 } 390 391 *_desc = (void *)bdev; 392 return 0; 393 } 394 395 struct spdk_bdev * 396 spdk_bdev_desc_get_bdev(struct spdk_bdev_desc *desc) 397 { 398 return (void *)desc; 399 } 400 401 char * 402 spdk_sprintf_alloc(const char *format, ...) 403 { 404 return strdup(format); 405 } 406 407 int 408 spdk_json_write_named_uint32(struct spdk_json_write_ctx *w, const char *name, uint32_t val) 409 { 410 if (!g_test_multi_raids) { 411 struct rpc_bdev_raid_create *req = g_rpc_req; 412 if (strcmp(name, "strip_size_kb") == 0) { 413 CU_ASSERT(req->strip_size_kb == val); 414 } else if (strcmp(name, "blocklen_shift") == 0) { 415 CU_ASSERT(spdk_u32log2(g_block_len) == val); 416 } else if (strcmp(name, "num_base_bdevs") == 0) { 417 CU_ASSERT(req->base_bdevs.num_base_bdevs == val); 418 } else if (strcmp(name, "state") == 0) { 419 CU_ASSERT(val == RAID_BDEV_STATE_ONLINE); 420 } else if (strcmp(name, "destruct_called") == 0) { 421 CU_ASSERT(val == 0); 422 } else if (strcmp(name, "num_base_bdevs_discovered") == 0) { 423 CU_ASSERT(req->base_bdevs.num_base_bdevs == val); 424 } 425 } 426 return 0; 427 } 428 429 int 430 spdk_json_write_named_string(struct spdk_json_write_ctx *w, const char *name, const char *val) 431 { 432 if (g_test_multi_raids) { 433 if (strcmp(name, "name") == 0) { 434 g_get_raids_output[g_get_raids_count] = strdup(val); 435 SPDK_CU_ASSERT_FATAL(g_get_raids_output[g_get_raids_count] != NULL); 436 g_get_raids_count++; 437 } 438 } else { 439 struct rpc_bdev_raid_create *req = g_rpc_req; 440 if (strcmp(name, "raid_level") == 0) { 441 CU_ASSERT(strcmp(val, raid_bdev_level_to_str(req->level)) == 0); 442 } 443 } 444 return 0; 445 } 446 447 void 448 spdk_bdev_free_io(struct spdk_bdev_io *bdev_io) 449 { 450 if (bdev_io) { 451 free(bdev_io); 452 } 453 } 454 455 /* It will cache split IOs for verification */ 456 int 457 spdk_bdev_readv_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 458 struct iovec *iov, int iovcnt, 459 uint64_t offset_blocks, uint64_t num_blocks, 460 spdk_bdev_io_completion_cb cb, void *cb_arg) 461 { 462 struct io_output *output = &g_io_output[g_io_output_index]; 463 struct spdk_bdev_io *child_io; 464 465 if (g_ignore_io_output) { 466 return 0; 467 } 468 469 SPDK_CU_ASSERT_FATAL(g_io_output_index <= (g_max_io_size / g_strip_size) + 1); 470 if (g_bdev_io_submit_status == 0) { 471 set_io_output(output, desc, ch, offset_blocks, num_blocks, cb, cb_arg, 472 SPDK_BDEV_IO_TYPE_READ); 473 g_io_output_index++; 474 475 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 476 SPDK_CU_ASSERT_FATAL(child_io != NULL); 477 cb(child_io, g_child_io_status_flag, cb_arg); 478 } 479 480 return g_bdev_io_submit_status; 481 } 482 483 int 484 spdk_bdev_readv_blocks_ext(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 485 struct iovec *iov, int iovcnt, 486 uint64_t offset_blocks, uint64_t num_blocks, 487 spdk_bdev_io_completion_cb cb, void *cb_arg, 488 struct spdk_bdev_ext_io_opts *opts) 489 { 490 return spdk_bdev_readv_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 491 } 492 493 int 494 spdk_bdev_readv_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 495 struct iovec *iov, int iovcnt, void *md, 496 uint64_t offset_blocks, uint64_t num_blocks, 497 spdk_bdev_io_completion_cb cb, void *cb_arg) 498 { 499 return spdk_bdev_readv_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 500 } 501 502 503 void 504 spdk_bdev_module_release_bdev(struct spdk_bdev *bdev) 505 { 506 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_EXCL_WRITE); 507 CU_ASSERT(bdev->internal.claim.v1.module != NULL); 508 bdev->internal.claim_type = SPDK_BDEV_CLAIM_NONE; 509 bdev->internal.claim.v1.module = NULL; 510 } 511 512 int 513 spdk_bdev_module_claim_bdev(struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, 514 struct spdk_bdev_module *module) 515 { 516 if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE) { 517 CU_ASSERT(bdev->internal.claim.v1.module != NULL); 518 return -1; 519 } 520 CU_ASSERT(bdev->internal.claim.v1.module == NULL); 521 bdev->internal.claim_type = SPDK_BDEV_CLAIM_EXCL_WRITE; 522 bdev->internal.claim.v1.module = module; 523 return 0; 524 } 525 526 int 527 spdk_json_decode_object(const struct spdk_json_val *values, 528 const struct spdk_json_object_decoder *decoders, size_t num_decoders, 529 void *out) 530 { 531 struct rpc_bdev_raid_create *req, *_out; 532 size_t i; 533 534 if (g_json_decode_obj_err) { 535 return -1; 536 } else if (g_json_decode_obj_create) { 537 req = g_rpc_req; 538 _out = out; 539 540 _out->name = strdup(req->name); 541 SPDK_CU_ASSERT_FATAL(_out->name != NULL); 542 _out->strip_size_kb = req->strip_size_kb; 543 _out->level = req->level; 544 _out->base_bdevs.num_base_bdevs = req->base_bdevs.num_base_bdevs; 545 for (i = 0; i < req->base_bdevs.num_base_bdevs; i++) { 546 _out->base_bdevs.base_bdevs[i] = strdup(req->base_bdevs.base_bdevs[i]); 547 SPDK_CU_ASSERT_FATAL(_out->base_bdevs.base_bdevs[i]); 548 } 549 } else { 550 memcpy(out, g_rpc_req, g_rpc_req_size); 551 } 552 553 return 0; 554 } 555 556 struct spdk_json_write_ctx * 557 spdk_jsonrpc_begin_result(struct spdk_jsonrpc_request *request) 558 { 559 return (void *)1; 560 } 561 562 void 563 spdk_jsonrpc_send_error_response(struct spdk_jsonrpc_request *request, 564 int error_code, const char *msg) 565 { 566 g_rpc_err = 1; 567 } 568 569 void 570 spdk_jsonrpc_send_error_response_fmt(struct spdk_jsonrpc_request *request, 571 int error_code, const char *fmt, ...) 572 { 573 g_rpc_err = 1; 574 } 575 576 struct spdk_bdev * 577 spdk_bdev_get_by_name(const char *bdev_name) 578 { 579 struct spdk_bdev *bdev; 580 581 if (!TAILQ_EMPTY(&g_bdev_list)) { 582 TAILQ_FOREACH(bdev, &g_bdev_list, internal.link) { 583 if (strcmp(bdev_name, bdev->name) == 0) { 584 return bdev; 585 } 586 } 587 } 588 589 return NULL; 590 } 591 592 int 593 spdk_bdev_quiesce(struct spdk_bdev *bdev, struct spdk_bdev_module *module, 594 spdk_bdev_quiesce_cb cb_fn, void *cb_arg) 595 { 596 if (cb_fn) { 597 cb_fn(cb_arg, 0); 598 } 599 600 return 0; 601 } 602 603 int 604 spdk_bdev_unquiesce(struct spdk_bdev *bdev, struct spdk_bdev_module *module, 605 spdk_bdev_quiesce_cb cb_fn, void *cb_arg) 606 { 607 if (cb_fn) { 608 cb_fn(cb_arg, 0); 609 } 610 611 return 0; 612 } 613 614 static void 615 bdev_io_cleanup(struct spdk_bdev_io *bdev_io) 616 { 617 if (bdev_io->u.bdev.iovs) { 618 if (bdev_io->u.bdev.iovs->iov_base) { 619 free(bdev_io->u.bdev.iovs->iov_base); 620 } 621 free(bdev_io->u.bdev.iovs); 622 } 623 free(bdev_io); 624 } 625 626 static void 627 bdev_io_initialize(struct spdk_bdev_io *bdev_io, struct spdk_io_channel *ch, struct spdk_bdev *bdev, 628 uint64_t lba, uint64_t blocks, int16_t iotype) 629 { 630 struct spdk_bdev_channel *channel = spdk_io_channel_get_ctx(ch); 631 632 bdev_io->bdev = bdev; 633 bdev_io->u.bdev.offset_blocks = lba; 634 bdev_io->u.bdev.num_blocks = blocks; 635 bdev_io->type = iotype; 636 637 if (bdev_io->type == SPDK_BDEV_IO_TYPE_UNMAP || bdev_io->type == SPDK_BDEV_IO_TYPE_FLUSH) { 638 return; 639 } 640 641 bdev_io->u.bdev.iovcnt = 1; 642 bdev_io->u.bdev.iovs = calloc(1, sizeof(struct iovec)); 643 SPDK_CU_ASSERT_FATAL(bdev_io->u.bdev.iovs != NULL); 644 bdev_io->u.bdev.iovs->iov_base = calloc(1, bdev_io->u.bdev.num_blocks * g_block_len); 645 SPDK_CU_ASSERT_FATAL(bdev_io->u.bdev.iovs->iov_base != NULL); 646 bdev_io->u.bdev.iovs->iov_len = bdev_io->u.bdev.num_blocks * g_block_len; 647 bdev_io->internal.ch = channel; 648 } 649 650 static void 651 verify_reset_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives, 652 struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, uint32_t io_status) 653 { 654 uint8_t index = 0; 655 struct io_output *output; 656 657 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 658 SPDK_CU_ASSERT_FATAL(num_base_drives != 0); 659 SPDK_CU_ASSERT_FATAL(io_status != INVALID_IO_SUBMIT); 660 SPDK_CU_ASSERT_FATAL(ch_ctx->base_channel != NULL); 661 662 CU_ASSERT(g_io_output_index == num_base_drives); 663 for (index = 0; index < g_io_output_index; index++) { 664 output = &g_io_output[index]; 665 CU_ASSERT(ch_ctx->base_channel[index] == output->ch); 666 CU_ASSERT(raid_bdev->base_bdev_info[index].desc == output->desc); 667 CU_ASSERT(bdev_io->type == output->iotype); 668 } 669 CU_ASSERT(g_io_comp_status == io_status); 670 } 671 672 static void 673 verify_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives, 674 struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, uint32_t io_status) 675 { 676 uint32_t strip_shift = spdk_u32log2(g_strip_size); 677 uint64_t start_strip = bdev_io->u.bdev.offset_blocks >> strip_shift; 678 uint64_t end_strip = (bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) >> 679 strip_shift; 680 uint32_t splits_reqd = (end_strip - start_strip + 1); 681 uint32_t strip; 682 uint64_t pd_strip; 683 uint8_t pd_idx; 684 uint32_t offset_in_strip; 685 uint64_t pd_lba; 686 uint64_t pd_blocks; 687 uint32_t index = 0; 688 struct io_output *output; 689 690 if (io_status == INVALID_IO_SUBMIT) { 691 CU_ASSERT(g_io_comp_status == false); 692 return; 693 } 694 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 695 SPDK_CU_ASSERT_FATAL(num_base_drives != 0); 696 697 CU_ASSERT(splits_reqd == g_io_output_index); 698 for (strip = start_strip; strip <= end_strip; strip++, index++) { 699 pd_strip = strip / num_base_drives; 700 pd_idx = strip % num_base_drives; 701 if (strip == start_strip) { 702 offset_in_strip = bdev_io->u.bdev.offset_blocks & (g_strip_size - 1); 703 pd_lba = (pd_strip << strip_shift) + offset_in_strip; 704 if (strip == end_strip) { 705 pd_blocks = bdev_io->u.bdev.num_blocks; 706 } else { 707 pd_blocks = g_strip_size - offset_in_strip; 708 } 709 } else if (strip == end_strip) { 710 pd_lba = pd_strip << strip_shift; 711 pd_blocks = ((bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) & 712 (g_strip_size - 1)) + 1; 713 } else { 714 pd_lba = pd_strip << raid_bdev->strip_size_shift; 715 pd_blocks = raid_bdev->strip_size; 716 } 717 output = &g_io_output[index]; 718 CU_ASSERT(pd_lba == output->offset_blocks); 719 CU_ASSERT(pd_blocks == output->num_blocks); 720 CU_ASSERT(ch_ctx->base_channel[pd_idx] == output->ch); 721 CU_ASSERT(raid_bdev->base_bdev_info[pd_idx].desc == output->desc); 722 CU_ASSERT(bdev_io->type == output->iotype); 723 } 724 CU_ASSERT(g_io_comp_status == io_status); 725 } 726 727 static void 728 verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives, 729 struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, 730 uint32_t io_status) 731 { 732 uint32_t strip_shift = spdk_u32log2(g_strip_size); 733 uint64_t start_offset_in_strip = bdev_io->u.bdev.offset_blocks % g_strip_size; 734 uint64_t end_offset_in_strip = (bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) % 735 g_strip_size; 736 uint64_t start_strip = bdev_io->u.bdev.offset_blocks >> strip_shift; 737 uint64_t end_strip = (bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) >> 738 strip_shift; 739 uint8_t n_disks_involved; 740 uint64_t start_strip_disk_idx; 741 uint64_t end_strip_disk_idx; 742 uint64_t nblocks_in_start_disk; 743 uint64_t offset_in_start_disk; 744 uint8_t disk_idx; 745 uint64_t base_io_idx; 746 uint64_t sum_nblocks = 0; 747 struct io_output *output; 748 749 if (io_status == INVALID_IO_SUBMIT) { 750 CU_ASSERT(g_io_comp_status == false); 751 return; 752 } 753 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 754 SPDK_CU_ASSERT_FATAL(num_base_drives != 0); 755 SPDK_CU_ASSERT_FATAL(bdev_io->type != SPDK_BDEV_IO_TYPE_READ); 756 SPDK_CU_ASSERT_FATAL(bdev_io->type != SPDK_BDEV_IO_TYPE_WRITE); 757 758 n_disks_involved = spdk_min(end_strip - start_strip + 1, num_base_drives); 759 CU_ASSERT(n_disks_involved == g_io_output_index); 760 761 start_strip_disk_idx = start_strip % num_base_drives; 762 end_strip_disk_idx = end_strip % num_base_drives; 763 764 offset_in_start_disk = g_io_output[0].offset_blocks; 765 nblocks_in_start_disk = g_io_output[0].num_blocks; 766 767 for (base_io_idx = 0, disk_idx = start_strip_disk_idx; base_io_idx < n_disks_involved; 768 base_io_idx++, disk_idx++) { 769 uint64_t start_offset_in_disk; 770 uint64_t end_offset_in_disk; 771 772 output = &g_io_output[base_io_idx]; 773 774 /* round disk_idx */ 775 if (disk_idx >= num_base_drives) { 776 disk_idx %= num_base_drives; 777 } 778 779 /* start_offset_in_disk aligned in strip check: 780 * The first base io has a same start_offset_in_strip with the whole raid io. 781 * Other base io should have aligned start_offset_in_strip which is 0. 782 */ 783 start_offset_in_disk = output->offset_blocks; 784 if (base_io_idx == 0) { 785 CU_ASSERT(start_offset_in_disk % g_strip_size == start_offset_in_strip); 786 } else { 787 CU_ASSERT(start_offset_in_disk % g_strip_size == 0); 788 } 789 790 /* end_offset_in_disk aligned in strip check: 791 * Base io on disk at which end_strip is located, has a same end_offset_in_strip 792 * with the whole raid io. 793 * Other base io should have aligned end_offset_in_strip. 794 */ 795 end_offset_in_disk = output->offset_blocks + output->num_blocks - 1; 796 if (disk_idx == end_strip_disk_idx) { 797 CU_ASSERT(end_offset_in_disk % g_strip_size == end_offset_in_strip); 798 } else { 799 CU_ASSERT(end_offset_in_disk % g_strip_size == g_strip_size - 1); 800 } 801 802 /* start_offset_in_disk compared with start_disk. 803 * 1. For disk_idx which is larger than start_strip_disk_idx: Its start_offset_in_disk 804 * mustn't be larger than the start offset of start_offset_in_disk; And the gap 805 * must be less than strip size. 806 * 2. For disk_idx which is less than start_strip_disk_idx, Its start_offset_in_disk 807 * must be larger than the start offset of start_offset_in_disk; And the gap mustn't 808 * be less than strip size. 809 */ 810 if (disk_idx > start_strip_disk_idx) { 811 CU_ASSERT(start_offset_in_disk <= offset_in_start_disk); 812 CU_ASSERT(offset_in_start_disk - start_offset_in_disk < g_strip_size); 813 } else if (disk_idx < start_strip_disk_idx) { 814 CU_ASSERT(start_offset_in_disk > offset_in_start_disk); 815 CU_ASSERT(output->offset_blocks - offset_in_start_disk <= g_strip_size); 816 } 817 818 /* nblocks compared with start_disk: 819 * The gap between them must be within a strip size. 820 */ 821 if (output->num_blocks <= nblocks_in_start_disk) { 822 CU_ASSERT(nblocks_in_start_disk - output->num_blocks <= g_strip_size); 823 } else { 824 CU_ASSERT(output->num_blocks - nblocks_in_start_disk < g_strip_size); 825 } 826 827 sum_nblocks += output->num_blocks; 828 829 CU_ASSERT(ch_ctx->base_channel[disk_idx] == output->ch); 830 CU_ASSERT(raid_bdev->base_bdev_info[disk_idx].desc == output->desc); 831 CU_ASSERT(bdev_io->type == output->iotype); 832 } 833 834 /* Sum of each nblocks should be same with raid bdev_io */ 835 CU_ASSERT(bdev_io->u.bdev.num_blocks == sum_nblocks); 836 837 CU_ASSERT(g_io_comp_status == io_status); 838 } 839 840 static void 841 verify_raid_bdev_present(const char *name, bool presence) 842 { 843 struct raid_bdev *pbdev; 844 bool pbdev_found; 845 846 pbdev_found = false; 847 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 848 if (strcmp(pbdev->bdev.name, name) == 0) { 849 pbdev_found = true; 850 break; 851 } 852 } 853 if (presence == true) { 854 CU_ASSERT(pbdev_found == true); 855 } else { 856 CU_ASSERT(pbdev_found == false); 857 } 858 } 859 860 static void 861 verify_raid_bdev(struct rpc_bdev_raid_create *r, bool presence, uint32_t raid_state) 862 { 863 struct raid_bdev *pbdev; 864 struct raid_base_bdev_info *base_info; 865 struct spdk_bdev *bdev = NULL; 866 bool pbdev_found; 867 uint64_t min_blockcnt = 0xFFFFFFFFFFFFFFFF; 868 869 pbdev_found = false; 870 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 871 if (strcmp(pbdev->bdev.name, r->name) == 0) { 872 pbdev_found = true; 873 if (presence == false) { 874 break; 875 } 876 CU_ASSERT(pbdev->base_bdev_info != NULL); 877 CU_ASSERT(pbdev->strip_size == ((r->strip_size_kb * 1024) / g_block_len)); 878 CU_ASSERT(pbdev->strip_size_shift == spdk_u32log2(((r->strip_size_kb * 1024) / 879 g_block_len))); 880 CU_ASSERT(pbdev->blocklen_shift == spdk_u32log2(g_block_len)); 881 CU_ASSERT((uint32_t)pbdev->state == raid_state); 882 CU_ASSERT(pbdev->num_base_bdevs == r->base_bdevs.num_base_bdevs); 883 CU_ASSERT(pbdev->num_base_bdevs_discovered == r->base_bdevs.num_base_bdevs); 884 CU_ASSERT(pbdev->level == r->level); 885 CU_ASSERT(pbdev->base_bdev_info != NULL); 886 RAID_FOR_EACH_BASE_BDEV(pbdev, base_info) { 887 CU_ASSERT(base_info->desc != NULL); 888 bdev = spdk_bdev_desc_get_bdev(base_info->desc); 889 CU_ASSERT(bdev != NULL); 890 CU_ASSERT(base_info->remove_scheduled == false); 891 892 if (bdev && bdev->blockcnt < min_blockcnt) { 893 min_blockcnt = bdev->blockcnt; 894 } 895 } 896 CU_ASSERT((((min_blockcnt / (r->strip_size_kb * 1024 / g_block_len)) * 897 (r->strip_size_kb * 1024 / g_block_len)) * 898 r->base_bdevs.num_base_bdevs) == pbdev->bdev.blockcnt); 899 CU_ASSERT(strcmp(pbdev->bdev.product_name, "Raid Volume") == 0); 900 CU_ASSERT(pbdev->bdev.write_cache == 0); 901 CU_ASSERT(pbdev->bdev.blocklen == g_block_len); 902 if (pbdev->num_base_bdevs > 1) { 903 CU_ASSERT(pbdev->bdev.optimal_io_boundary == pbdev->strip_size); 904 CU_ASSERT(pbdev->bdev.split_on_optimal_io_boundary == true); 905 } else { 906 CU_ASSERT(pbdev->bdev.optimal_io_boundary == 0); 907 CU_ASSERT(pbdev->bdev.split_on_optimal_io_boundary == false); 908 } 909 CU_ASSERT(pbdev->bdev.ctxt == pbdev); 910 CU_ASSERT(pbdev->bdev.fn_table == &g_raid_bdev_fn_table); 911 CU_ASSERT(pbdev->bdev.module == &g_raid_if); 912 break; 913 } 914 } 915 if (presence == true) { 916 CU_ASSERT(pbdev_found == true); 917 } else { 918 CU_ASSERT(pbdev_found == false); 919 } 920 } 921 922 static void 923 verify_get_raids(struct rpc_bdev_raid_create *construct_req, 924 uint8_t g_max_raids, 925 char **g_get_raids_output, uint32_t g_get_raids_count) 926 { 927 uint8_t i, j; 928 bool found; 929 930 CU_ASSERT(g_max_raids == g_get_raids_count); 931 if (g_max_raids == g_get_raids_count) { 932 for (i = 0; i < g_max_raids; i++) { 933 found = false; 934 for (j = 0; j < g_max_raids; j++) { 935 if (construct_req[i].name && 936 strcmp(construct_req[i].name, g_get_raids_output[i]) == 0) { 937 found = true; 938 break; 939 } 940 } 941 CU_ASSERT(found == true); 942 } 943 } 944 } 945 946 static void 947 create_base_bdevs(uint32_t bbdev_start_idx) 948 { 949 uint8_t i; 950 struct spdk_bdev *base_bdev; 951 char name[16]; 952 953 for (i = 0; i < g_max_base_drives; i++, bbdev_start_idx++) { 954 snprintf(name, 16, "%s%u%s", "Nvme", bbdev_start_idx, "n1"); 955 base_bdev = calloc(1, sizeof(struct spdk_bdev)); 956 SPDK_CU_ASSERT_FATAL(base_bdev != NULL); 957 base_bdev->name = strdup(name); 958 SPDK_CU_ASSERT_FATAL(base_bdev->name != NULL); 959 base_bdev->blocklen = g_block_len; 960 base_bdev->blockcnt = BLOCK_CNT; 961 TAILQ_INSERT_TAIL(&g_bdev_list, base_bdev, internal.link); 962 } 963 } 964 965 static void 966 create_test_req(struct rpc_bdev_raid_create *r, const char *raid_name, 967 uint8_t bbdev_start_idx, bool create_base_bdev) 968 { 969 uint8_t i; 970 char name[16]; 971 uint8_t bbdev_idx = bbdev_start_idx; 972 973 r->name = strdup(raid_name); 974 SPDK_CU_ASSERT_FATAL(r->name != NULL); 975 r->strip_size_kb = (g_strip_size * g_block_len) / 1024; 976 r->level = RAID0; 977 r->base_bdevs.num_base_bdevs = g_max_base_drives; 978 for (i = 0; i < g_max_base_drives; i++, bbdev_idx++) { 979 snprintf(name, 16, "%s%u%s", "Nvme", bbdev_idx, "n1"); 980 r->base_bdevs.base_bdevs[i] = strdup(name); 981 SPDK_CU_ASSERT_FATAL(r->base_bdevs.base_bdevs[i] != NULL); 982 } 983 if (create_base_bdev == true) { 984 create_base_bdevs(bbdev_start_idx); 985 } 986 g_rpc_req = r; 987 g_rpc_req_size = sizeof(*r); 988 } 989 990 static void 991 create_raid_bdev_create_req(struct rpc_bdev_raid_create *r, const char *raid_name, 992 uint8_t bbdev_start_idx, bool create_base_bdev, 993 uint8_t json_decode_obj_err) 994 { 995 create_test_req(r, raid_name, bbdev_start_idx, create_base_bdev); 996 997 g_rpc_err = 0; 998 g_json_decode_obj_create = 1; 999 g_json_decode_obj_err = json_decode_obj_err; 1000 g_config_level_create = 0; 1001 g_test_multi_raids = 0; 1002 } 1003 1004 static void 1005 free_test_req(struct rpc_bdev_raid_create *r) 1006 { 1007 uint8_t i; 1008 1009 free(r->name); 1010 for (i = 0; i < r->base_bdevs.num_base_bdevs; i++) { 1011 free(r->base_bdevs.base_bdevs[i]); 1012 } 1013 } 1014 1015 static void 1016 create_raid_bdev_delete_req(struct rpc_bdev_raid_delete *r, const char *raid_name, 1017 uint8_t json_decode_obj_err) 1018 { 1019 r->name = strdup(raid_name); 1020 SPDK_CU_ASSERT_FATAL(r->name != NULL); 1021 1022 g_rpc_req = r; 1023 g_rpc_req_size = sizeof(*r); 1024 g_rpc_err = 0; 1025 g_json_decode_obj_create = 0; 1026 g_json_decode_obj_err = json_decode_obj_err; 1027 g_config_level_create = 0; 1028 g_test_multi_raids = 0; 1029 } 1030 1031 static void 1032 create_get_raids_req(struct rpc_bdev_raid_get_bdevs *r, const char *category, 1033 uint8_t json_decode_obj_err) 1034 { 1035 r->category = strdup(category); 1036 SPDK_CU_ASSERT_FATAL(r->category != NULL); 1037 1038 g_rpc_req = r; 1039 g_rpc_req_size = sizeof(*r); 1040 g_rpc_err = 0; 1041 g_json_decode_obj_create = 0; 1042 g_json_decode_obj_err = json_decode_obj_err; 1043 g_config_level_create = 0; 1044 g_test_multi_raids = 1; 1045 g_get_raids_count = 0; 1046 } 1047 1048 static void 1049 test_create_raid(void) 1050 { 1051 struct rpc_bdev_raid_create req; 1052 struct rpc_bdev_raid_delete delete_req; 1053 1054 set_globals(); 1055 CU_ASSERT(raid_bdev_init() == 0); 1056 1057 verify_raid_bdev_present("raid1", false); 1058 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1059 rpc_bdev_raid_create(NULL, NULL); 1060 CU_ASSERT(g_rpc_err == 0); 1061 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1062 free_test_req(&req); 1063 1064 create_raid_bdev_delete_req(&delete_req, "raid1", 0); 1065 rpc_bdev_raid_delete(NULL, NULL); 1066 CU_ASSERT(g_rpc_err == 0); 1067 raid_bdev_exit(); 1068 base_bdevs_cleanup(); 1069 reset_globals(); 1070 } 1071 1072 static void 1073 test_delete_raid(void) 1074 { 1075 struct rpc_bdev_raid_create construct_req; 1076 struct rpc_bdev_raid_delete delete_req; 1077 1078 set_globals(); 1079 CU_ASSERT(raid_bdev_init() == 0); 1080 1081 verify_raid_bdev_present("raid1", false); 1082 create_raid_bdev_create_req(&construct_req, "raid1", 0, true, 0); 1083 rpc_bdev_raid_create(NULL, NULL); 1084 CU_ASSERT(g_rpc_err == 0); 1085 verify_raid_bdev(&construct_req, true, RAID_BDEV_STATE_ONLINE); 1086 free_test_req(&construct_req); 1087 1088 create_raid_bdev_delete_req(&delete_req, "raid1", 0); 1089 rpc_bdev_raid_delete(NULL, NULL); 1090 CU_ASSERT(g_rpc_err == 0); 1091 verify_raid_bdev_present("raid1", false); 1092 1093 raid_bdev_exit(); 1094 base_bdevs_cleanup(); 1095 reset_globals(); 1096 } 1097 1098 static void 1099 test_create_raid_invalid_args(void) 1100 { 1101 struct rpc_bdev_raid_create req; 1102 struct rpc_bdev_raid_delete destroy_req; 1103 struct raid_bdev *raid_bdev; 1104 1105 set_globals(); 1106 CU_ASSERT(raid_bdev_init() == 0); 1107 1108 verify_raid_bdev_present("raid1", false); 1109 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1110 req.level = INVALID_RAID_LEVEL; 1111 rpc_bdev_raid_create(NULL, NULL); 1112 CU_ASSERT(g_rpc_err == 1); 1113 free_test_req(&req); 1114 verify_raid_bdev_present("raid1", false); 1115 1116 create_raid_bdev_create_req(&req, "raid1", 0, false, 1); 1117 rpc_bdev_raid_create(NULL, NULL); 1118 CU_ASSERT(g_rpc_err == 1); 1119 free_test_req(&req); 1120 verify_raid_bdev_present("raid1", false); 1121 1122 create_raid_bdev_create_req(&req, "raid1", 0, false, 0); 1123 req.strip_size_kb = 1231; 1124 rpc_bdev_raid_create(NULL, NULL); 1125 CU_ASSERT(g_rpc_err == 1); 1126 free_test_req(&req); 1127 verify_raid_bdev_present("raid1", false); 1128 1129 create_raid_bdev_create_req(&req, "raid1", 0, false, 0); 1130 rpc_bdev_raid_create(NULL, NULL); 1131 CU_ASSERT(g_rpc_err == 0); 1132 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1133 free_test_req(&req); 1134 1135 create_raid_bdev_create_req(&req, "raid1", 0, false, 0); 1136 rpc_bdev_raid_create(NULL, NULL); 1137 CU_ASSERT(g_rpc_err == 1); 1138 free_test_req(&req); 1139 1140 create_raid_bdev_create_req(&req, "raid2", 0, false, 0); 1141 rpc_bdev_raid_create(NULL, NULL); 1142 CU_ASSERT(g_rpc_err == 1); 1143 free_test_req(&req); 1144 verify_raid_bdev_present("raid2", false); 1145 1146 create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, true, 0); 1147 free(req.base_bdevs.base_bdevs[g_max_base_drives - 1]); 1148 req.base_bdevs.base_bdevs[g_max_base_drives - 1] = strdup("Nvme0n1"); 1149 SPDK_CU_ASSERT_FATAL(req.base_bdevs.base_bdevs[g_max_base_drives - 1] != NULL); 1150 rpc_bdev_raid_create(NULL, NULL); 1151 CU_ASSERT(g_rpc_err == 1); 1152 free_test_req(&req); 1153 verify_raid_bdev_present("raid2", false); 1154 1155 create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, true, 0); 1156 free(req.base_bdevs.base_bdevs[g_max_base_drives - 1]); 1157 req.base_bdevs.base_bdevs[g_max_base_drives - 1] = strdup("Nvme100000n1"); 1158 SPDK_CU_ASSERT_FATAL(req.base_bdevs.base_bdevs[g_max_base_drives - 1] != NULL); 1159 rpc_bdev_raid_create(NULL, NULL); 1160 CU_ASSERT(g_rpc_err == 0); 1161 free_test_req(&req); 1162 verify_raid_bdev_present("raid2", true); 1163 raid_bdev = raid_bdev_find_by_name("raid2"); 1164 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 1165 check_and_remove_raid_bdev(raid_bdev); 1166 1167 create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, false, 0); 1168 rpc_bdev_raid_create(NULL, NULL); 1169 CU_ASSERT(g_rpc_err == 0); 1170 free_test_req(&req); 1171 verify_raid_bdev_present("raid2", true); 1172 verify_raid_bdev_present("raid1", true); 1173 1174 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1175 rpc_bdev_raid_delete(NULL, NULL); 1176 create_raid_bdev_delete_req(&destroy_req, "raid2", 0); 1177 rpc_bdev_raid_delete(NULL, NULL); 1178 raid_bdev_exit(); 1179 base_bdevs_cleanup(); 1180 reset_globals(); 1181 } 1182 1183 static void 1184 test_delete_raid_invalid_args(void) 1185 { 1186 struct rpc_bdev_raid_create construct_req; 1187 struct rpc_bdev_raid_delete destroy_req; 1188 1189 set_globals(); 1190 CU_ASSERT(raid_bdev_init() == 0); 1191 1192 verify_raid_bdev_present("raid1", false); 1193 create_raid_bdev_create_req(&construct_req, "raid1", 0, true, 0); 1194 rpc_bdev_raid_create(NULL, NULL); 1195 CU_ASSERT(g_rpc_err == 0); 1196 verify_raid_bdev(&construct_req, true, RAID_BDEV_STATE_ONLINE); 1197 free_test_req(&construct_req); 1198 1199 create_raid_bdev_delete_req(&destroy_req, "raid2", 0); 1200 rpc_bdev_raid_delete(NULL, NULL); 1201 CU_ASSERT(g_rpc_err == 1); 1202 1203 create_raid_bdev_delete_req(&destroy_req, "raid1", 1); 1204 rpc_bdev_raid_delete(NULL, NULL); 1205 CU_ASSERT(g_rpc_err == 1); 1206 free(destroy_req.name); 1207 verify_raid_bdev_present("raid1", true); 1208 1209 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1210 rpc_bdev_raid_delete(NULL, NULL); 1211 CU_ASSERT(g_rpc_err == 0); 1212 verify_raid_bdev_present("raid1", false); 1213 1214 raid_bdev_exit(); 1215 base_bdevs_cleanup(); 1216 reset_globals(); 1217 } 1218 1219 static void 1220 test_io_channel(void) 1221 { 1222 struct rpc_bdev_raid_create req; 1223 struct rpc_bdev_raid_delete destroy_req; 1224 struct raid_bdev *pbdev; 1225 struct raid_bdev_io_channel *ch_ctx; 1226 uint8_t i; 1227 1228 set_globals(); 1229 CU_ASSERT(raid_bdev_init() == 0); 1230 1231 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1232 verify_raid_bdev_present("raid1", false); 1233 rpc_bdev_raid_create(NULL, NULL); 1234 CU_ASSERT(g_rpc_err == 0); 1235 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1236 1237 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1238 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1239 break; 1240 } 1241 } 1242 CU_ASSERT(pbdev != NULL); 1243 ch_ctx = calloc(1, sizeof(struct raid_bdev_io_channel)); 1244 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1245 1246 CU_ASSERT(raid_bdev_create_cb(pbdev, ch_ctx) == 0); 1247 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 1248 CU_ASSERT(ch_ctx->base_channel && ch_ctx->base_channel[i] == &g_io_channel); 1249 } 1250 raid_bdev_destroy_cb(pbdev, ch_ctx); 1251 CU_ASSERT(ch_ctx->base_channel == NULL); 1252 free_test_req(&req); 1253 1254 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1255 rpc_bdev_raid_delete(NULL, NULL); 1256 CU_ASSERT(g_rpc_err == 0); 1257 verify_raid_bdev_present("raid1", false); 1258 1259 free(ch_ctx); 1260 raid_bdev_exit(); 1261 base_bdevs_cleanup(); 1262 reset_globals(); 1263 } 1264 1265 static void 1266 test_write_io(void) 1267 { 1268 struct rpc_bdev_raid_create req; 1269 struct rpc_bdev_raid_delete destroy_req; 1270 struct raid_bdev *pbdev; 1271 struct spdk_io_channel *ch; 1272 struct raid_bdev_io_channel *ch_ctx; 1273 uint8_t i; 1274 struct spdk_bdev_io *bdev_io; 1275 uint64_t io_len; 1276 uint64_t lba = 0; 1277 struct spdk_io_channel *ch_b; 1278 struct spdk_bdev_channel *ch_b_ctx; 1279 1280 set_globals(); 1281 CU_ASSERT(raid_bdev_init() == 0); 1282 1283 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1284 verify_raid_bdev_present("raid1", false); 1285 rpc_bdev_raid_create(NULL, NULL); 1286 CU_ASSERT(g_rpc_err == 0); 1287 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1288 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1289 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1290 break; 1291 } 1292 } 1293 CU_ASSERT(pbdev != NULL); 1294 ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel)); 1295 SPDK_CU_ASSERT_FATAL(ch != NULL); 1296 1297 ch_b = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct spdk_bdev_channel)); 1298 SPDK_CU_ASSERT_FATAL(ch_b != NULL); 1299 ch_b_ctx = spdk_io_channel_get_ctx(ch_b); 1300 ch_b_ctx->channel = ch; 1301 1302 ch_ctx = spdk_io_channel_get_ctx(ch); 1303 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1304 1305 CU_ASSERT(raid_bdev_create_cb(pbdev, ch_ctx) == 0); 1306 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 1307 CU_ASSERT(ch_ctx->base_channel && ch_ctx->base_channel[i] == &g_io_channel); 1308 } 1309 1310 /* test 2 IO sizes based on global strip size set earlier */ 1311 for (i = 0; i < 2; i++) { 1312 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1313 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1314 io_len = (g_strip_size / 2) << i; 1315 bdev_io_initialize(bdev_io, ch_b, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_WRITE); 1316 lba += g_strip_size; 1317 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1318 g_io_output_index = 0; 1319 raid_bdev_submit_request(ch, bdev_io); 1320 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1321 g_child_io_status_flag); 1322 bdev_io_cleanup(bdev_io); 1323 } 1324 1325 free_test_req(&req); 1326 raid_bdev_destroy_cb(pbdev, ch_ctx); 1327 CU_ASSERT(ch_ctx->base_channel == NULL); 1328 free(ch); 1329 free(ch_b); 1330 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1331 rpc_bdev_raid_delete(NULL, NULL); 1332 CU_ASSERT(g_rpc_err == 0); 1333 verify_raid_bdev_present("raid1", false); 1334 1335 raid_bdev_exit(); 1336 base_bdevs_cleanup(); 1337 reset_globals(); 1338 } 1339 1340 static void 1341 test_read_io(void) 1342 { 1343 struct rpc_bdev_raid_create req; 1344 struct rpc_bdev_raid_delete destroy_req; 1345 struct raid_bdev *pbdev; 1346 struct spdk_io_channel *ch; 1347 struct raid_bdev_io_channel *ch_ctx; 1348 uint8_t i; 1349 struct spdk_bdev_io *bdev_io; 1350 uint64_t io_len; 1351 uint64_t lba; 1352 struct spdk_io_channel *ch_b; 1353 struct spdk_bdev_channel *ch_b_ctx; 1354 1355 set_globals(); 1356 CU_ASSERT(raid_bdev_init() == 0); 1357 1358 verify_raid_bdev_present("raid1", false); 1359 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1360 rpc_bdev_raid_create(NULL, NULL); 1361 CU_ASSERT(g_rpc_err == 0); 1362 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1363 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1364 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1365 break; 1366 } 1367 } 1368 CU_ASSERT(pbdev != NULL); 1369 ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel)); 1370 SPDK_CU_ASSERT_FATAL(ch != NULL); 1371 1372 ch_b = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct spdk_bdev_channel)); 1373 SPDK_CU_ASSERT_FATAL(ch_b != NULL); 1374 ch_b_ctx = spdk_io_channel_get_ctx(ch_b); 1375 ch_b_ctx->channel = ch; 1376 1377 ch_ctx = spdk_io_channel_get_ctx(ch); 1378 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1379 1380 CU_ASSERT(raid_bdev_create_cb(pbdev, ch_ctx) == 0); 1381 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 1382 CU_ASSERT(ch_ctx->base_channel && ch_ctx->base_channel[i] == &g_io_channel); 1383 } 1384 free_test_req(&req); 1385 1386 /* test 2 IO sizes based on global strip size set earlier */ 1387 lba = 0; 1388 for (i = 0; i < 2; i++) { 1389 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1390 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1391 io_len = (g_strip_size / 2) << i; 1392 bdev_io_initialize(bdev_io, ch_b, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_READ); 1393 lba += g_strip_size; 1394 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1395 g_io_output_index = 0; 1396 raid_bdev_submit_request(ch, bdev_io); 1397 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1398 g_child_io_status_flag); 1399 bdev_io_cleanup(bdev_io); 1400 } 1401 1402 raid_bdev_destroy_cb(pbdev, ch_ctx); 1403 CU_ASSERT(ch_ctx->base_channel == NULL); 1404 free(ch); 1405 free(ch_b); 1406 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1407 rpc_bdev_raid_delete(NULL, NULL); 1408 CU_ASSERT(g_rpc_err == 0); 1409 verify_raid_bdev_present("raid1", false); 1410 1411 raid_bdev_exit(); 1412 base_bdevs_cleanup(); 1413 reset_globals(); 1414 } 1415 1416 static void 1417 raid_bdev_io_generate_by_strips(uint64_t n_strips) 1418 { 1419 uint64_t lba; 1420 uint64_t nblocks; 1421 uint64_t start_offset; 1422 uint64_t end_offset; 1423 uint64_t offsets_in_strip[3]; 1424 uint64_t start_bdev_idx; 1425 uint64_t start_bdev_offset; 1426 uint64_t start_bdev_idxs[3]; 1427 int i, j, l; 1428 1429 /* 3 different situations of offset in strip */ 1430 offsets_in_strip[0] = 0; 1431 offsets_in_strip[1] = g_strip_size >> 1; 1432 offsets_in_strip[2] = g_strip_size - 1; 1433 1434 /* 3 different situations of start_bdev_idx */ 1435 start_bdev_idxs[0] = 0; 1436 start_bdev_idxs[1] = g_max_base_drives >> 1; 1437 start_bdev_idxs[2] = g_max_base_drives - 1; 1438 1439 /* consider different offset in strip */ 1440 for (i = 0; i < 3; i++) { 1441 start_offset = offsets_in_strip[i]; 1442 for (j = 0; j < 3; j++) { 1443 end_offset = offsets_in_strip[j]; 1444 if (n_strips == 1 && start_offset > end_offset) { 1445 continue; 1446 } 1447 1448 /* consider at which base_bdev lba is started. */ 1449 for (l = 0; l < 3; l++) { 1450 start_bdev_idx = start_bdev_idxs[l]; 1451 start_bdev_offset = start_bdev_idx * g_strip_size; 1452 lba = g_lba_offset + start_bdev_offset + start_offset; 1453 nblocks = (n_strips - 1) * g_strip_size + end_offset - start_offset + 1; 1454 1455 g_io_ranges[g_io_range_idx].lba = lba; 1456 g_io_ranges[g_io_range_idx].nblocks = nblocks; 1457 1458 SPDK_CU_ASSERT_FATAL(g_io_range_idx < MAX_TEST_IO_RANGE); 1459 g_io_range_idx++; 1460 } 1461 } 1462 } 1463 } 1464 1465 static void 1466 raid_bdev_io_generate(void) 1467 { 1468 uint64_t n_strips; 1469 uint64_t n_strips_span = g_max_base_drives; 1470 uint64_t n_strips_times[5] = {g_max_base_drives + 1, g_max_base_drives * 2 - 1, 1471 g_max_base_drives * 2, g_max_base_drives * 3, 1472 g_max_base_drives * 4 1473 }; 1474 uint32_t i; 1475 1476 g_io_range_idx = 0; 1477 1478 /* consider different number of strips from 1 to strips spanned base bdevs, 1479 * and even to times of strips spanned base bdevs 1480 */ 1481 for (n_strips = 1; n_strips < n_strips_span; n_strips++) { 1482 raid_bdev_io_generate_by_strips(n_strips); 1483 } 1484 1485 for (i = 0; i < SPDK_COUNTOF(n_strips_times); i++) { 1486 n_strips = n_strips_times[i]; 1487 raid_bdev_io_generate_by_strips(n_strips); 1488 } 1489 } 1490 1491 static void 1492 test_unmap_io(void) 1493 { 1494 struct rpc_bdev_raid_create req; 1495 struct rpc_bdev_raid_delete destroy_req; 1496 struct raid_bdev *pbdev; 1497 struct spdk_io_channel *ch; 1498 struct raid_bdev_io_channel *ch_ctx; 1499 uint8_t i; 1500 struct spdk_bdev_io *bdev_io; 1501 uint32_t count; 1502 uint64_t io_len; 1503 uint64_t lba; 1504 1505 set_globals(); 1506 CU_ASSERT(raid_bdev_init() == 0); 1507 1508 verify_raid_bdev_present("raid1", false); 1509 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1510 rpc_bdev_raid_create(NULL, NULL); 1511 CU_ASSERT(g_rpc_err == 0); 1512 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1513 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1514 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1515 break; 1516 } 1517 } 1518 CU_ASSERT(pbdev != NULL); 1519 ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel)); 1520 SPDK_CU_ASSERT_FATAL(ch != NULL); 1521 ch_ctx = spdk_io_channel_get_ctx(ch); 1522 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1523 1524 CU_ASSERT(raid_bdev_create_cb(pbdev, ch_ctx) == 0); 1525 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 1526 SPDK_CU_ASSERT_FATAL(ch_ctx->base_channel && ch_ctx->base_channel[i] == &g_io_channel); 1527 } 1528 1529 CU_ASSERT(raid_bdev_io_type_supported(pbdev, SPDK_BDEV_IO_TYPE_UNMAP) == true); 1530 CU_ASSERT(raid_bdev_io_type_supported(pbdev, SPDK_BDEV_IO_TYPE_FLUSH) == true); 1531 1532 raid_bdev_io_generate(); 1533 for (count = 0; count < g_io_range_idx; count++) { 1534 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1535 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1536 io_len = g_io_ranges[count].nblocks; 1537 lba = g_io_ranges[count].lba; 1538 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_UNMAP); 1539 memset(g_io_output, 0, g_max_base_drives * sizeof(struct io_output)); 1540 g_io_output_index = 0; 1541 raid_bdev_submit_request(ch, bdev_io); 1542 verify_io_without_payload(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1543 g_child_io_status_flag); 1544 bdev_io_cleanup(bdev_io); 1545 } 1546 free_test_req(&req); 1547 1548 raid_bdev_destroy_cb(pbdev, ch_ctx); 1549 CU_ASSERT(ch_ctx->base_channel == NULL); 1550 free(ch); 1551 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1552 rpc_bdev_raid_delete(NULL, NULL); 1553 CU_ASSERT(g_rpc_err == 0); 1554 verify_raid_bdev_present("raid1", false); 1555 1556 raid_bdev_exit(); 1557 base_bdevs_cleanup(); 1558 reset_globals(); 1559 } 1560 1561 /* Test IO failures */ 1562 static void 1563 test_io_failure(void) 1564 { 1565 struct rpc_bdev_raid_create req; 1566 struct rpc_bdev_raid_delete destroy_req; 1567 struct raid_bdev *pbdev; 1568 struct spdk_io_channel *ch; 1569 struct raid_bdev_io_channel *ch_ctx; 1570 uint8_t i; 1571 struct spdk_bdev_io *bdev_io; 1572 uint32_t count; 1573 uint64_t io_len; 1574 uint64_t lba; 1575 1576 set_globals(); 1577 CU_ASSERT(raid_bdev_init() == 0); 1578 1579 verify_raid_bdev_present("raid1", false); 1580 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1581 rpc_bdev_raid_create(NULL, NULL); 1582 CU_ASSERT(g_rpc_err == 0); 1583 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1584 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1585 if (strcmp(pbdev->bdev.name, req.name) == 0) { 1586 break; 1587 } 1588 } 1589 CU_ASSERT(pbdev != NULL); 1590 ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel)); 1591 SPDK_CU_ASSERT_FATAL(ch != NULL); 1592 ch_ctx = spdk_io_channel_get_ctx(ch); 1593 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1594 1595 CU_ASSERT(raid_bdev_create_cb(pbdev, ch_ctx) == 0); 1596 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 1597 CU_ASSERT(ch_ctx->base_channel && ch_ctx->base_channel[i] == &g_io_channel); 1598 } 1599 free_test_req(&req); 1600 1601 lba = 0; 1602 for (count = 0; count < 1; count++) { 1603 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1604 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1605 io_len = (g_strip_size / 2) << count; 1606 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_INVALID); 1607 lba += g_strip_size; 1608 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1609 g_io_output_index = 0; 1610 raid_bdev_submit_request(ch, bdev_io); 1611 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1612 INVALID_IO_SUBMIT); 1613 bdev_io_cleanup(bdev_io); 1614 } 1615 1616 1617 lba = 0; 1618 g_child_io_status_flag = false; 1619 for (count = 0; count < 1; count++) { 1620 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1621 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1622 io_len = (g_strip_size / 2) << count; 1623 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_WRITE); 1624 lba += g_strip_size; 1625 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1626 g_io_output_index = 0; 1627 raid_bdev_submit_request(ch, bdev_io); 1628 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1629 g_child_io_status_flag); 1630 bdev_io_cleanup(bdev_io); 1631 } 1632 1633 raid_bdev_destroy_cb(pbdev, ch_ctx); 1634 CU_ASSERT(ch_ctx->base_channel == NULL); 1635 free(ch); 1636 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1637 rpc_bdev_raid_delete(NULL, NULL); 1638 CU_ASSERT(g_rpc_err == 0); 1639 verify_raid_bdev_present("raid1", false); 1640 1641 raid_bdev_exit(); 1642 base_bdevs_cleanup(); 1643 reset_globals(); 1644 } 1645 1646 /* Test reset IO */ 1647 static void 1648 test_reset_io(void) 1649 { 1650 struct rpc_bdev_raid_create req; 1651 struct rpc_bdev_raid_delete destroy_req; 1652 struct raid_bdev *pbdev; 1653 struct spdk_io_channel *ch; 1654 struct raid_bdev_io_channel *ch_ctx; 1655 uint8_t i; 1656 struct spdk_bdev_io *bdev_io; 1657 1658 set_globals(); 1659 CU_ASSERT(raid_bdev_init() == 0); 1660 1661 verify_raid_bdev_present("raid1", false); 1662 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1663 rpc_bdev_raid_create(NULL, NULL); 1664 CU_ASSERT(g_rpc_err == 0); 1665 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1666 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1667 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1668 break; 1669 } 1670 } 1671 CU_ASSERT(pbdev != NULL); 1672 ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel)); 1673 SPDK_CU_ASSERT_FATAL(ch != NULL); 1674 ch_ctx = spdk_io_channel_get_ctx(ch); 1675 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1676 1677 SPDK_CU_ASSERT_FATAL(raid_bdev_create_cb(pbdev, ch_ctx) == 0); 1678 for (i = 0; i < req.base_bdevs.num_base_bdevs; i++) { 1679 CU_ASSERT(ch_ctx->base_channel && ch_ctx->base_channel[i] == &g_io_channel); 1680 } 1681 free_test_req(&req); 1682 1683 g_bdev_io_submit_status = 0; 1684 g_child_io_status_flag = true; 1685 1686 CU_ASSERT(raid_bdev_io_type_supported(pbdev, SPDK_BDEV_IO_TYPE_RESET) == true); 1687 1688 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1689 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1690 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, 0, 1, SPDK_BDEV_IO_TYPE_RESET); 1691 memset(g_io_output, 0, g_max_base_drives * sizeof(struct io_output)); 1692 g_io_output_index = 0; 1693 raid_bdev_submit_request(ch, bdev_io); 1694 verify_reset_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1695 true); 1696 bdev_io_cleanup(bdev_io); 1697 1698 raid_bdev_destroy_cb(pbdev, ch_ctx); 1699 CU_ASSERT(ch_ctx->base_channel == NULL); 1700 free(ch); 1701 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1702 rpc_bdev_raid_delete(NULL, NULL); 1703 CU_ASSERT(g_rpc_err == 0); 1704 verify_raid_bdev_present("raid1", false); 1705 1706 raid_bdev_exit(); 1707 base_bdevs_cleanup(); 1708 reset_globals(); 1709 } 1710 1711 /* Create multiple raids, destroy raids without IO, get_raids related tests */ 1712 static void 1713 test_multi_raid_no_io(void) 1714 { 1715 struct rpc_bdev_raid_create *construct_req; 1716 struct rpc_bdev_raid_delete destroy_req; 1717 struct rpc_bdev_raid_get_bdevs get_raids_req; 1718 uint8_t i; 1719 char name[16]; 1720 uint8_t bbdev_idx = 0; 1721 1722 set_globals(); 1723 construct_req = calloc(MAX_RAIDS, sizeof(struct rpc_bdev_raid_create)); 1724 SPDK_CU_ASSERT_FATAL(construct_req != NULL); 1725 CU_ASSERT(raid_bdev_init() == 0); 1726 for (i = 0; i < g_max_raids; i++) { 1727 snprintf(name, 16, "%s%u", "raid", i); 1728 verify_raid_bdev_present(name, false); 1729 create_raid_bdev_create_req(&construct_req[i], name, bbdev_idx, true, 0); 1730 bbdev_idx += g_max_base_drives; 1731 rpc_bdev_raid_create(NULL, NULL); 1732 CU_ASSERT(g_rpc_err == 0); 1733 verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE); 1734 } 1735 1736 create_get_raids_req(&get_raids_req, "all", 0); 1737 rpc_bdev_raid_get_bdevs(NULL, NULL); 1738 CU_ASSERT(g_rpc_err == 0); 1739 verify_get_raids(construct_req, g_max_raids, g_get_raids_output, g_get_raids_count); 1740 for (i = 0; i < g_get_raids_count; i++) { 1741 free(g_get_raids_output[i]); 1742 } 1743 1744 create_get_raids_req(&get_raids_req, "online", 0); 1745 rpc_bdev_raid_get_bdevs(NULL, NULL); 1746 CU_ASSERT(g_rpc_err == 0); 1747 verify_get_raids(construct_req, g_max_raids, g_get_raids_output, g_get_raids_count); 1748 for (i = 0; i < g_get_raids_count; i++) { 1749 free(g_get_raids_output[i]); 1750 } 1751 1752 create_get_raids_req(&get_raids_req, "configuring", 0); 1753 rpc_bdev_raid_get_bdevs(NULL, NULL); 1754 CU_ASSERT(g_rpc_err == 0); 1755 CU_ASSERT(g_get_raids_count == 0); 1756 1757 create_get_raids_req(&get_raids_req, "offline", 0); 1758 rpc_bdev_raid_get_bdevs(NULL, NULL); 1759 CU_ASSERT(g_rpc_err == 0); 1760 CU_ASSERT(g_get_raids_count == 0); 1761 1762 create_get_raids_req(&get_raids_req, "invalid_category", 0); 1763 rpc_bdev_raid_get_bdevs(NULL, NULL); 1764 CU_ASSERT(g_rpc_err == 1); 1765 CU_ASSERT(g_get_raids_count == 0); 1766 1767 create_get_raids_req(&get_raids_req, "all", 1); 1768 rpc_bdev_raid_get_bdevs(NULL, NULL); 1769 CU_ASSERT(g_rpc_err == 1); 1770 free(get_raids_req.category); 1771 CU_ASSERT(g_get_raids_count == 0); 1772 1773 create_get_raids_req(&get_raids_req, "all", 0); 1774 rpc_bdev_raid_get_bdevs(NULL, NULL); 1775 CU_ASSERT(g_rpc_err == 0); 1776 CU_ASSERT(g_get_raids_count == g_max_raids); 1777 for (i = 0; i < g_get_raids_count; i++) { 1778 free(g_get_raids_output[i]); 1779 } 1780 1781 for (i = 0; i < g_max_raids; i++) { 1782 SPDK_CU_ASSERT_FATAL(construct_req[i].name != NULL); 1783 snprintf(name, 16, "%s", construct_req[i].name); 1784 create_raid_bdev_delete_req(&destroy_req, name, 0); 1785 rpc_bdev_raid_delete(NULL, NULL); 1786 CU_ASSERT(g_rpc_err == 0); 1787 verify_raid_bdev_present(name, false); 1788 } 1789 raid_bdev_exit(); 1790 for (i = 0; i < g_max_raids; i++) { 1791 free_test_req(&construct_req[i]); 1792 } 1793 free(construct_req); 1794 base_bdevs_cleanup(); 1795 reset_globals(); 1796 } 1797 1798 /* Create multiple raids, fire IOs on raids */ 1799 static void 1800 test_multi_raid_with_io(void) 1801 { 1802 struct rpc_bdev_raid_create *construct_req; 1803 struct rpc_bdev_raid_delete destroy_req; 1804 uint8_t i, j; 1805 char name[16]; 1806 uint8_t bbdev_idx = 0; 1807 struct raid_bdev *pbdev; 1808 struct spdk_io_channel *ch; 1809 struct raid_bdev_io_channel *ch_ctx = NULL; 1810 struct spdk_bdev_io *bdev_io; 1811 uint64_t io_len; 1812 uint64_t lba = 0; 1813 int16_t iotype; 1814 struct spdk_io_channel *ch_b; 1815 struct spdk_bdev_channel *ch_b_ctx; 1816 1817 set_globals(); 1818 construct_req = calloc(g_max_raids, sizeof(struct rpc_bdev_raid_create)); 1819 SPDK_CU_ASSERT_FATAL(construct_req != NULL); 1820 CU_ASSERT(raid_bdev_init() == 0); 1821 ch = calloc(g_max_raids, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel)); 1822 SPDK_CU_ASSERT_FATAL(ch != NULL); 1823 1824 ch_b = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct spdk_bdev_channel)); 1825 SPDK_CU_ASSERT_FATAL(ch_b != NULL); 1826 ch_b_ctx = spdk_io_channel_get_ctx(ch_b); 1827 ch_b_ctx->channel = ch; 1828 1829 for (i = 0; i < g_max_raids; i++) { 1830 snprintf(name, 16, "%s%u", "raid", i); 1831 verify_raid_bdev_present(name, false); 1832 create_raid_bdev_create_req(&construct_req[i], name, bbdev_idx, true, 0); 1833 bbdev_idx += g_max_base_drives; 1834 rpc_bdev_raid_create(NULL, NULL); 1835 CU_ASSERT(g_rpc_err == 0); 1836 verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE); 1837 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1838 if (strcmp(pbdev->bdev.name, construct_req[i].name) == 0) { 1839 break; 1840 } 1841 } 1842 CU_ASSERT(pbdev != NULL); 1843 ch_ctx = spdk_io_channel_get_ctx(&ch[i]); 1844 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1845 CU_ASSERT(raid_bdev_create_cb(pbdev, ch_ctx) == 0); 1846 SPDK_CU_ASSERT_FATAL(ch_ctx->base_channel != NULL); 1847 for (j = 0; j < construct_req[i].base_bdevs.num_base_bdevs; j++) { 1848 CU_ASSERT(ch_ctx->base_channel[j] == &g_io_channel); 1849 } 1850 } 1851 1852 /* This will perform a write on the first raid and a read on the second. It can be 1853 * expanded in the future to perform r/w on each raid device in the event that 1854 * multiple raid levels are supported. 1855 */ 1856 for (i = 0; i < g_max_raids; i++) { 1857 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1858 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1859 io_len = g_strip_size; 1860 iotype = (i) ? SPDK_BDEV_IO_TYPE_WRITE : SPDK_BDEV_IO_TYPE_READ; 1861 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1862 g_io_output_index = 0; 1863 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1864 if (strcmp(pbdev->bdev.name, construct_req[i].name) == 0) { 1865 break; 1866 } 1867 } 1868 bdev_io_initialize(bdev_io, ch_b, &pbdev->bdev, lba, io_len, iotype); 1869 CU_ASSERT(pbdev != NULL); 1870 raid_bdev_submit_request(ch, bdev_io); 1871 verify_io(bdev_io, g_max_base_drives, ch_ctx, pbdev, 1872 g_child_io_status_flag); 1873 bdev_io_cleanup(bdev_io); 1874 } 1875 1876 for (i = 0; i < g_max_raids; i++) { 1877 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1878 if (strcmp(pbdev->bdev.name, construct_req[i].name) == 0) { 1879 break; 1880 } 1881 } 1882 CU_ASSERT(pbdev != NULL); 1883 ch_ctx = spdk_io_channel_get_ctx(&ch[i]); 1884 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1885 raid_bdev_destroy_cb(pbdev, ch_ctx); 1886 CU_ASSERT(ch_ctx->base_channel == NULL); 1887 snprintf(name, 16, "%s", construct_req[i].name); 1888 create_raid_bdev_delete_req(&destroy_req, name, 0); 1889 rpc_bdev_raid_delete(NULL, NULL); 1890 CU_ASSERT(g_rpc_err == 0); 1891 verify_raid_bdev_present(name, false); 1892 } 1893 raid_bdev_exit(); 1894 for (i = 0; i < g_max_raids; i++) { 1895 free_test_req(&construct_req[i]); 1896 } 1897 free(construct_req); 1898 free(ch); 1899 free(ch_b); 1900 base_bdevs_cleanup(); 1901 reset_globals(); 1902 } 1903 1904 static void 1905 test_io_type_supported(void) 1906 { 1907 CU_ASSERT(raid_bdev_io_type_supported(NULL, SPDK_BDEV_IO_TYPE_READ) == true); 1908 CU_ASSERT(raid_bdev_io_type_supported(NULL, SPDK_BDEV_IO_TYPE_WRITE) == true); 1909 CU_ASSERT(raid_bdev_io_type_supported(NULL, SPDK_BDEV_IO_TYPE_INVALID) == false); 1910 } 1911 1912 static void 1913 test_raid_json_dump_info(void) 1914 { 1915 struct rpc_bdev_raid_create req; 1916 struct rpc_bdev_raid_delete destroy_req; 1917 struct raid_bdev *pbdev; 1918 1919 set_globals(); 1920 CU_ASSERT(raid_bdev_init() == 0); 1921 1922 verify_raid_bdev_present("raid1", false); 1923 create_raid_bdev_create_req(&req, "raid1", 0, true, 0); 1924 rpc_bdev_raid_create(NULL, NULL); 1925 CU_ASSERT(g_rpc_err == 0); 1926 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1927 1928 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1929 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1930 break; 1931 } 1932 } 1933 CU_ASSERT(pbdev != NULL); 1934 1935 CU_ASSERT(raid_bdev_dump_info_json(pbdev, NULL) == 0); 1936 1937 free_test_req(&req); 1938 1939 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1940 rpc_bdev_raid_delete(NULL, NULL); 1941 CU_ASSERT(g_rpc_err == 0); 1942 verify_raid_bdev_present("raid1", false); 1943 1944 raid_bdev_exit(); 1945 base_bdevs_cleanup(); 1946 reset_globals(); 1947 } 1948 1949 static void 1950 test_context_size(void) 1951 { 1952 CU_ASSERT(raid_bdev_get_ctx_size() == sizeof(struct raid_bdev_io)); 1953 } 1954 1955 static void 1956 test_raid_level_conversions(void) 1957 { 1958 const char *raid_str; 1959 1960 CU_ASSERT(raid_bdev_str_to_level("abcd123") == INVALID_RAID_LEVEL); 1961 CU_ASSERT(raid_bdev_str_to_level("0") == RAID0); 1962 CU_ASSERT(raid_bdev_str_to_level("raid0") == RAID0); 1963 CU_ASSERT(raid_bdev_str_to_level("RAID0") == RAID0); 1964 1965 raid_str = raid_bdev_level_to_str(INVALID_RAID_LEVEL); 1966 CU_ASSERT(raid_str != NULL && strlen(raid_str) == 0); 1967 raid_str = raid_bdev_level_to_str(1234); 1968 CU_ASSERT(raid_str != NULL && strlen(raid_str) == 0); 1969 raid_str = raid_bdev_level_to_str(RAID0); 1970 CU_ASSERT(raid_str != NULL && strcmp(raid_str, "raid0") == 0); 1971 } 1972 1973 int 1974 main(int argc, char **argv) 1975 { 1976 CU_pSuite suite = NULL; 1977 unsigned int num_failures; 1978 1979 CU_initialize_registry(); 1980 1981 suite = CU_add_suite("raid", NULL, NULL); 1982 1983 CU_ADD_TEST(suite, test_create_raid); 1984 CU_ADD_TEST(suite, test_delete_raid); 1985 CU_ADD_TEST(suite, test_create_raid_invalid_args); 1986 CU_ADD_TEST(suite, test_delete_raid_invalid_args); 1987 CU_ADD_TEST(suite, test_io_channel); 1988 CU_ADD_TEST(suite, test_reset_io); 1989 CU_ADD_TEST(suite, test_write_io); 1990 CU_ADD_TEST(suite, test_read_io); 1991 CU_ADD_TEST(suite, test_unmap_io); 1992 CU_ADD_TEST(suite, test_io_failure); 1993 CU_ADD_TEST(suite, test_multi_raid_no_io); 1994 CU_ADD_TEST(suite, test_multi_raid_with_io); 1995 CU_ADD_TEST(suite, test_io_type_supported); 1996 CU_ADD_TEST(suite, test_raid_json_dump_info); 1997 CU_ADD_TEST(suite, test_context_size); 1998 CU_ADD_TEST(suite, test_raid_level_conversions); 1999 2000 allocate_threads(1); 2001 set_thread(0); 2002 2003 set_test_opts(); 2004 num_failures = spdk_ut_run_tests(argc, argv, NULL); 2005 CU_cleanup_registry(); 2006 2007 free_threads(); 2008 2009 return num_failures; 2010 } 2011