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 uint64_t g_bdev_ch_io_device; 76 bool g_bdev_io_defer_completion; 77 TAILQ_HEAD(, spdk_bdev_io) g_deferred_ios = TAILQ_HEAD_INITIALIZER(g_deferred_ios); 78 79 DEFINE_STUB_V(spdk_bdev_module_examine_done, (struct spdk_bdev_module *module)); 80 DEFINE_STUB_V(spdk_bdev_module_list_add, (struct spdk_bdev_module *bdev_module)); 81 DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev, 82 enum spdk_bdev_io_type io_type), true); 83 DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); 84 DEFINE_STUB(spdk_bdev_flush_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 85 uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb, 86 void *cb_arg), 0); 87 DEFINE_STUB(spdk_conf_next_section, struct spdk_conf_section *, (struct spdk_conf_section *sp), 88 NULL); 89 DEFINE_STUB_V(spdk_rpc_register_method, (const char *method, spdk_rpc_method_handler func, 90 uint32_t state_mask)); 91 DEFINE_STUB_V(spdk_rpc_register_alias_deprecated, (const char *method, const char *alias)); 92 DEFINE_STUB_V(spdk_jsonrpc_end_result, (struct spdk_jsonrpc_request *request, 93 struct spdk_json_write_ctx *w)); 94 DEFINE_STUB_V(spdk_jsonrpc_send_bool_response, (struct spdk_jsonrpc_request *request, 95 bool value)); 96 DEFINE_STUB(spdk_json_decode_string, int, (const struct spdk_json_val *val, void *out), 0); 97 DEFINE_STUB(spdk_json_decode_uint32, int, (const struct spdk_json_val *val, void *out), 0); 98 DEFINE_STUB(spdk_json_decode_uuid, int, (const struct spdk_json_val *val, void *out), 0); 99 DEFINE_STUB(spdk_json_decode_array, int, (const struct spdk_json_val *values, 100 spdk_json_decode_fn decode_func, 101 void *out, size_t max_size, size_t *out_size, size_t stride), 0); 102 DEFINE_STUB(spdk_json_decode_bool, int, (const struct spdk_json_val *val, void *out), 0); 103 DEFINE_STUB(spdk_json_write_name, int, (struct spdk_json_write_ctx *w, const char *name), 0); 104 DEFINE_STUB(spdk_json_write_object_begin, int, (struct spdk_json_write_ctx *w), 0); 105 DEFINE_STUB(spdk_json_write_named_object_begin, int, (struct spdk_json_write_ctx *w, 106 const char *name), 0); 107 DEFINE_STUB(spdk_json_write_string, int, (struct spdk_json_write_ctx *w, const char *val), 0); 108 DEFINE_STUB(spdk_json_write_object_end, int, (struct spdk_json_write_ctx *w), 0); 109 DEFINE_STUB(spdk_json_write_array_begin, int, (struct spdk_json_write_ctx *w), 0); 110 DEFINE_STUB(spdk_json_write_array_end, int, (struct spdk_json_write_ctx *w), 0); 111 DEFINE_STUB(spdk_json_write_named_array_begin, int, (struct spdk_json_write_ctx *w, 112 const char *name), 0); 113 DEFINE_STUB(spdk_json_write_bool, int, (struct spdk_json_write_ctx *w, bool val), 0); 114 DEFINE_STUB(spdk_json_write_null, int, (struct spdk_json_write_ctx *w), 0); 115 DEFINE_STUB(spdk_json_write_named_uint64, int, (struct spdk_json_write_ctx *w, const char *name, 116 uint64_t val), 0); 117 DEFINE_STUB(spdk_strerror, const char *, (int errnum), NULL); 118 DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch, 119 struct spdk_bdev_io_wait_entry *entry), 0); 120 DEFINE_STUB(spdk_bdev_get_memory_domains, int, (struct spdk_bdev *bdev, 121 struct spdk_memory_domain **domains, int array_size), 0); 122 DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test_bdev"); 123 DEFINE_STUB(spdk_bdev_get_md_size, uint32_t, (const struct spdk_bdev *bdev), 0); 124 DEFINE_STUB(spdk_bdev_is_md_interleaved, bool, (const struct spdk_bdev *bdev), false); 125 DEFINE_STUB(spdk_bdev_is_md_separate, bool, (const struct spdk_bdev *bdev), false); 126 DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type, (const struct spdk_bdev *bdev), 127 SPDK_DIF_DISABLE); 128 DEFINE_STUB(spdk_bdev_is_dif_head_of_md, bool, (const struct spdk_bdev *bdev), false); 129 DEFINE_STUB(spdk_bdev_notify_blockcnt_change, int, (struct spdk_bdev *bdev, uint64_t size), 0); 130 DEFINE_STUB_V(raid_bdev_init_superblock, (struct raid_bdev *raid_bdev)); 131 DEFINE_STUB(raid_bdev_alloc_superblock, int, (struct raid_bdev *raid_bdev, uint32_t block_size), 0); 132 DEFINE_STUB_V(raid_bdev_free_superblock, (struct raid_bdev *raid_bdev)); 133 134 uint32_t 135 spdk_bdev_get_data_block_size(const struct spdk_bdev *bdev) 136 { 137 return g_block_len; 138 } 139 140 int 141 raid_bdev_load_base_bdev_superblock(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 142 raid_bdev_load_sb_cb cb, void *cb_ctx) 143 { 144 cb(NULL, -EINVAL, cb_ctx); 145 146 return 0; 147 } 148 149 void 150 raid_bdev_write_superblock(struct raid_bdev *raid_bdev, raid_bdev_write_sb_cb cb, void *cb_ctx) 151 { 152 cb(0, raid_bdev, cb_ctx); 153 } 154 155 const struct spdk_uuid * 156 spdk_bdev_get_uuid(const struct spdk_bdev *bdev) 157 { 158 return &bdev->uuid; 159 } 160 161 struct spdk_io_channel * 162 spdk_bdev_get_io_channel(struct spdk_bdev_desc *desc) 163 { 164 return spdk_get_io_channel(&g_bdev_ch_io_device); 165 } 166 167 static void 168 set_test_opts(void) 169 { 170 171 g_max_base_drives = MAX_BASE_DRIVES; 172 g_max_raids = MAX_RAIDS; 173 g_block_len = 4096; 174 g_strip_size = 64; 175 g_max_io_size = 1024; 176 177 printf("Test Options\n"); 178 printf("blocklen = %u, strip_size = %u, max_io_size = %u, g_max_base_drives = %u, " 179 "g_max_raids = %u\n", 180 g_block_len, g_strip_size, g_max_io_size, g_max_base_drives, g_max_raids); 181 } 182 183 /* Set globals before every test run */ 184 static void 185 set_globals(void) 186 { 187 uint32_t max_splits; 188 189 g_bdev_io_submit_status = 0; 190 if (g_max_io_size < g_strip_size) { 191 max_splits = 2; 192 } else { 193 max_splits = (g_max_io_size / g_strip_size) + 1; 194 } 195 if (max_splits < g_max_base_drives) { 196 max_splits = g_max_base_drives; 197 } 198 199 g_io_output = calloc(max_splits, sizeof(struct io_output)); 200 SPDK_CU_ASSERT_FATAL(g_io_output != NULL); 201 g_io_output_index = 0; 202 memset(g_get_raids_output, 0, sizeof(g_get_raids_output)); 203 g_get_raids_count = 0; 204 g_io_comp_status = 0; 205 g_ignore_io_output = 0; 206 g_config_level_create = 0; 207 g_rpc_err = 0; 208 g_test_multi_raids = 0; 209 g_child_io_status_flag = true; 210 TAILQ_INIT(&g_bdev_list); 211 TAILQ_INIT(&g_io_waitq); 212 g_rpc_req = NULL; 213 g_rpc_req_size = 0; 214 g_json_decode_obj_err = 0; 215 g_json_decode_obj_create = 0; 216 g_lba_offset = 0; 217 g_bdev_io_defer_completion = false; 218 } 219 220 static void 221 base_bdevs_cleanup(void) 222 { 223 struct spdk_bdev *bdev; 224 struct spdk_bdev *bdev_next; 225 226 if (!TAILQ_EMPTY(&g_bdev_list)) { 227 TAILQ_FOREACH_SAFE(bdev, &g_bdev_list, internal.link, bdev_next) { 228 free(bdev->name); 229 TAILQ_REMOVE(&g_bdev_list, bdev, internal.link); 230 free(bdev); 231 } 232 } 233 } 234 235 static void 236 check_and_remove_raid_bdev(struct raid_bdev *raid_bdev) 237 { 238 struct raid_base_bdev_info *base_info; 239 240 assert(raid_bdev != NULL); 241 assert(raid_bdev->base_bdev_info != NULL); 242 243 RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) { 244 if (base_info->desc) { 245 raid_bdev_free_base_bdev_resource(base_info); 246 } 247 } 248 assert(raid_bdev->num_base_bdevs_discovered == 0); 249 raid_bdev_cleanup_and_free(raid_bdev); 250 } 251 252 /* Reset globals */ 253 static void 254 reset_globals(void) 255 { 256 if (g_io_output) { 257 free(g_io_output); 258 g_io_output = NULL; 259 } 260 g_rpc_req = NULL; 261 g_rpc_req_size = 0; 262 } 263 264 void 265 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, 266 uint64_t len) 267 { 268 cb(bdev_io->internal.ch->channel, bdev_io, true); 269 } 270 271 /* Store the IO completion status in global variable to verify by various tests */ 272 void 273 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 274 { 275 g_io_comp_status = ((status == SPDK_BDEV_IO_STATUS_SUCCESS) ? true : false); 276 } 277 278 static void 279 set_io_output(struct io_output *output, 280 struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 281 uint64_t offset_blocks, uint64_t num_blocks, 282 spdk_bdev_io_completion_cb cb, void *cb_arg, 283 enum spdk_bdev_io_type iotype) 284 { 285 output->desc = desc; 286 output->ch = ch; 287 output->offset_blocks = offset_blocks; 288 output->num_blocks = num_blocks; 289 output->cb = cb; 290 output->cb_arg = cb_arg; 291 output->iotype = iotype; 292 } 293 294 static void 295 child_io_complete(struct spdk_bdev_io *child_io, spdk_bdev_io_completion_cb cb, void *cb_arg) 296 { 297 if (g_bdev_io_defer_completion) { 298 child_io->internal.cb = cb; 299 child_io->internal.caller_ctx = cb_arg; 300 TAILQ_INSERT_TAIL(&g_deferred_ios, child_io, internal.link); 301 } else { 302 cb(child_io, g_child_io_status_flag, cb_arg); 303 } 304 } 305 306 static void 307 complete_deferred_ios(void) 308 { 309 struct spdk_bdev_io *child_io, *tmp; 310 311 TAILQ_FOREACH_SAFE(child_io, &g_deferred_ios, internal.link, tmp) { 312 TAILQ_REMOVE(&g_deferred_ios, child_io, internal.link); 313 child_io->internal.cb(child_io, g_child_io_status_flag, child_io->internal.caller_ctx); 314 } 315 } 316 317 /* It will cache the split IOs for verification */ 318 int 319 spdk_bdev_writev_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 320 struct iovec *iov, int iovcnt, 321 uint64_t offset_blocks, uint64_t num_blocks, 322 spdk_bdev_io_completion_cb cb, void *cb_arg) 323 { 324 struct io_output *output = &g_io_output[g_io_output_index]; 325 struct spdk_bdev_io *child_io; 326 327 if (g_ignore_io_output) { 328 return 0; 329 } 330 331 if (g_max_io_size < g_strip_size) { 332 SPDK_CU_ASSERT_FATAL(g_io_output_index < 2); 333 } else { 334 SPDK_CU_ASSERT_FATAL(g_io_output_index < (g_max_io_size / g_strip_size) + 1); 335 } 336 if (g_bdev_io_submit_status == 0) { 337 set_io_output(output, desc, ch, offset_blocks, num_blocks, cb, cb_arg, 338 SPDK_BDEV_IO_TYPE_WRITE); 339 g_io_output_index++; 340 341 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 342 SPDK_CU_ASSERT_FATAL(child_io != NULL); 343 child_io_complete(child_io, cb, cb_arg); 344 } 345 346 return g_bdev_io_submit_status; 347 } 348 349 int 350 spdk_bdev_writev_blocks_ext(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 351 struct iovec *iov, int iovcnt, 352 uint64_t offset_blocks, uint64_t num_blocks, 353 spdk_bdev_io_completion_cb cb, void *cb_arg, 354 struct spdk_bdev_ext_io_opts *opts) 355 { 356 return spdk_bdev_writev_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 357 } 358 359 int 360 spdk_bdev_writev_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 361 struct iovec *iov, int iovcnt, void *md, 362 uint64_t offset_blocks, uint64_t num_blocks, 363 spdk_bdev_io_completion_cb cb, void *cb_arg) 364 { 365 return spdk_bdev_writev_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 366 } 367 368 int 369 spdk_bdev_reset(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 370 spdk_bdev_io_completion_cb cb, void *cb_arg) 371 { 372 struct io_output *output = &g_io_output[g_io_output_index]; 373 struct spdk_bdev_io *child_io; 374 375 if (g_ignore_io_output) { 376 return 0; 377 } 378 379 if (g_bdev_io_submit_status == 0) { 380 set_io_output(output, desc, ch, 0, 0, cb, cb_arg, SPDK_BDEV_IO_TYPE_RESET); 381 g_io_output_index++; 382 383 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 384 SPDK_CU_ASSERT_FATAL(child_io != NULL); 385 child_io_complete(child_io, cb, cb_arg); 386 } 387 388 return g_bdev_io_submit_status; 389 } 390 391 int 392 spdk_bdev_unmap_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 393 uint64_t offset_blocks, uint64_t num_blocks, 394 spdk_bdev_io_completion_cb cb, void *cb_arg) 395 { 396 struct io_output *output = &g_io_output[g_io_output_index]; 397 struct spdk_bdev_io *child_io; 398 399 if (g_ignore_io_output) { 400 return 0; 401 } 402 403 if (g_bdev_io_submit_status == 0) { 404 set_io_output(output, desc, ch, offset_blocks, num_blocks, cb, cb_arg, 405 SPDK_BDEV_IO_TYPE_UNMAP); 406 g_io_output_index++; 407 408 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 409 SPDK_CU_ASSERT_FATAL(child_io != NULL); 410 child_io_complete(child_io, cb, cb_arg); 411 } 412 413 return g_bdev_io_submit_status; 414 } 415 416 void 417 spdk_bdev_destruct_done(struct spdk_bdev *bdev, int bdeverrno) 418 { 419 CU_ASSERT(bdeverrno == 0); 420 SPDK_CU_ASSERT_FATAL(bdev->internal.unregister_cb != NULL); 421 bdev->internal.unregister_cb(bdev->internal.unregister_ctx, bdeverrno); 422 } 423 424 int 425 spdk_bdev_register(struct spdk_bdev *bdev) 426 { 427 TAILQ_INSERT_TAIL(&g_bdev_list, bdev, internal.link); 428 return 0; 429 } 430 431 void 432 spdk_bdev_unregister(struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg) 433 { 434 int ret; 435 436 SPDK_CU_ASSERT_FATAL(spdk_bdev_get_by_name(bdev->name) == bdev); 437 TAILQ_REMOVE(&g_bdev_list, bdev, internal.link); 438 439 bdev->internal.unregister_cb = cb_fn; 440 bdev->internal.unregister_ctx = cb_arg; 441 442 ret = bdev->fn_table->destruct(bdev->ctxt); 443 CU_ASSERT(ret == 1); 444 445 poll_threads(); 446 } 447 448 int 449 spdk_bdev_open_ext(const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb, 450 void *event_ctx, struct spdk_bdev_desc **_desc) 451 { 452 struct spdk_bdev *bdev; 453 454 bdev = spdk_bdev_get_by_name(bdev_name); 455 if (bdev == NULL) { 456 return -ENODEV; 457 } 458 459 *_desc = (void *)bdev; 460 return 0; 461 } 462 463 struct spdk_bdev * 464 spdk_bdev_desc_get_bdev(struct spdk_bdev_desc *desc) 465 { 466 return (void *)desc; 467 } 468 469 int 470 spdk_json_write_named_uint32(struct spdk_json_write_ctx *w, const char *name, uint32_t val) 471 { 472 if (!g_test_multi_raids) { 473 struct rpc_bdev_raid_create *req = g_rpc_req; 474 if (strcmp(name, "strip_size_kb") == 0) { 475 CU_ASSERT(req->strip_size_kb == val); 476 } else if (strcmp(name, "blocklen_shift") == 0) { 477 CU_ASSERT(spdk_u32log2(g_block_len) == val); 478 } else if (strcmp(name, "num_base_bdevs") == 0) { 479 CU_ASSERT(req->base_bdevs.num_base_bdevs == val); 480 } else if (strcmp(name, "state") == 0) { 481 CU_ASSERT(val == RAID_BDEV_STATE_ONLINE); 482 } else if (strcmp(name, "destruct_called") == 0) { 483 CU_ASSERT(val == 0); 484 } else if (strcmp(name, "num_base_bdevs_discovered") == 0) { 485 CU_ASSERT(req->base_bdevs.num_base_bdevs == val); 486 } 487 } 488 return 0; 489 } 490 491 int 492 spdk_json_write_named_string(struct spdk_json_write_ctx *w, const char *name, const char *val) 493 { 494 if (g_test_multi_raids) { 495 if (strcmp(name, "name") == 0) { 496 g_get_raids_output[g_get_raids_count] = strdup(val); 497 SPDK_CU_ASSERT_FATAL(g_get_raids_output[g_get_raids_count] != NULL); 498 g_get_raids_count++; 499 } 500 } else { 501 struct rpc_bdev_raid_create *req = g_rpc_req; 502 if (strcmp(name, "raid_level") == 0) { 503 CU_ASSERT(strcmp(val, raid_bdev_level_to_str(req->level)) == 0); 504 } 505 } 506 return 0; 507 } 508 509 int 510 spdk_json_write_named_bool(struct spdk_json_write_ctx *w, const char *name, bool val) 511 { 512 if (!g_test_multi_raids) { 513 struct rpc_bdev_raid_create *req = g_rpc_req; 514 if (strcmp(name, "superblock") == 0) { 515 CU_ASSERT(val == req->superblock_enabled); 516 } 517 } 518 return 0; 519 } 520 521 void 522 spdk_bdev_free_io(struct spdk_bdev_io *bdev_io) 523 { 524 if (bdev_io) { 525 free(bdev_io); 526 } 527 } 528 529 /* It will cache split IOs for verification */ 530 int 531 spdk_bdev_readv_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 532 struct iovec *iov, int iovcnt, 533 uint64_t offset_blocks, uint64_t num_blocks, 534 spdk_bdev_io_completion_cb cb, void *cb_arg) 535 { 536 struct io_output *output = &g_io_output[g_io_output_index]; 537 struct spdk_bdev_io *child_io; 538 539 if (g_ignore_io_output) { 540 return 0; 541 } 542 543 SPDK_CU_ASSERT_FATAL(g_io_output_index <= (g_max_io_size / g_strip_size) + 1); 544 if (g_bdev_io_submit_status == 0) { 545 set_io_output(output, desc, ch, offset_blocks, num_blocks, cb, cb_arg, 546 SPDK_BDEV_IO_TYPE_READ); 547 g_io_output_index++; 548 549 child_io = calloc(1, sizeof(struct spdk_bdev_io)); 550 SPDK_CU_ASSERT_FATAL(child_io != NULL); 551 child_io_complete(child_io, cb, cb_arg); 552 } 553 554 return g_bdev_io_submit_status; 555 } 556 557 int 558 spdk_bdev_readv_blocks_ext(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 559 struct iovec *iov, int iovcnt, 560 uint64_t offset_blocks, uint64_t num_blocks, 561 spdk_bdev_io_completion_cb cb, void *cb_arg, 562 struct spdk_bdev_ext_io_opts *opts) 563 { 564 return spdk_bdev_readv_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 565 } 566 567 int 568 spdk_bdev_readv_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 569 struct iovec *iov, int iovcnt, void *md, 570 uint64_t offset_blocks, uint64_t num_blocks, 571 spdk_bdev_io_completion_cb cb, void *cb_arg) 572 { 573 return spdk_bdev_readv_blocks(desc, ch, iov, iovcnt, offset_blocks, num_blocks, cb, cb_arg); 574 } 575 576 577 void 578 spdk_bdev_module_release_bdev(struct spdk_bdev *bdev) 579 { 580 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_EXCL_WRITE); 581 CU_ASSERT(bdev->internal.claim.v1.module != NULL); 582 bdev->internal.claim_type = SPDK_BDEV_CLAIM_NONE; 583 bdev->internal.claim.v1.module = NULL; 584 } 585 586 int 587 spdk_bdev_module_claim_bdev(struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, 588 struct spdk_bdev_module *module) 589 { 590 if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE) { 591 CU_ASSERT(bdev->internal.claim.v1.module != NULL); 592 return -1; 593 } 594 CU_ASSERT(bdev->internal.claim.v1.module == NULL); 595 bdev->internal.claim_type = SPDK_BDEV_CLAIM_EXCL_WRITE; 596 bdev->internal.claim.v1.module = module; 597 return 0; 598 } 599 600 int 601 spdk_json_decode_object(const struct spdk_json_val *values, 602 const struct spdk_json_object_decoder *decoders, size_t num_decoders, 603 void *out) 604 { 605 struct rpc_bdev_raid_create *req, *_out; 606 size_t i; 607 608 if (g_json_decode_obj_err) { 609 return -1; 610 } else if (g_json_decode_obj_create) { 611 req = g_rpc_req; 612 _out = out; 613 614 _out->name = strdup(req->name); 615 SPDK_CU_ASSERT_FATAL(_out->name != NULL); 616 _out->strip_size_kb = req->strip_size_kb; 617 _out->level = req->level; 618 _out->superblock_enabled = req->superblock_enabled; 619 _out->base_bdevs.num_base_bdevs = req->base_bdevs.num_base_bdevs; 620 for (i = 0; i < req->base_bdevs.num_base_bdevs; i++) { 621 _out->base_bdevs.base_bdevs[i] = strdup(req->base_bdevs.base_bdevs[i]); 622 SPDK_CU_ASSERT_FATAL(_out->base_bdevs.base_bdevs[i]); 623 } 624 } else { 625 memcpy(out, g_rpc_req, g_rpc_req_size); 626 } 627 628 return 0; 629 } 630 631 struct spdk_json_write_ctx * 632 spdk_jsonrpc_begin_result(struct spdk_jsonrpc_request *request) 633 { 634 return (void *)1; 635 } 636 637 void 638 spdk_jsonrpc_send_error_response(struct spdk_jsonrpc_request *request, 639 int error_code, const char *msg) 640 { 641 g_rpc_err = 1; 642 } 643 644 void 645 spdk_jsonrpc_send_error_response_fmt(struct spdk_jsonrpc_request *request, 646 int error_code, const char *fmt, ...) 647 { 648 g_rpc_err = 1; 649 } 650 651 struct spdk_bdev * 652 spdk_bdev_get_by_name(const char *bdev_name) 653 { 654 struct spdk_bdev *bdev; 655 656 if (!TAILQ_EMPTY(&g_bdev_list)) { 657 TAILQ_FOREACH(bdev, &g_bdev_list, internal.link) { 658 if (strcmp(bdev_name, bdev->name) == 0) { 659 return bdev; 660 } 661 } 662 } 663 664 return NULL; 665 } 666 667 int 668 spdk_bdev_quiesce(struct spdk_bdev *bdev, struct spdk_bdev_module *module, 669 spdk_bdev_quiesce_cb cb_fn, void *cb_arg) 670 { 671 if (cb_fn) { 672 cb_fn(cb_arg, 0); 673 } 674 675 return 0; 676 } 677 678 int 679 spdk_bdev_unquiesce(struct spdk_bdev *bdev, struct spdk_bdev_module *module, 680 spdk_bdev_quiesce_cb cb_fn, void *cb_arg) 681 { 682 if (cb_fn) { 683 cb_fn(cb_arg, 0); 684 } 685 686 return 0; 687 } 688 689 int 690 spdk_bdev_quiesce_range(struct spdk_bdev *bdev, struct spdk_bdev_module *module, 691 uint64_t offset, uint64_t length, 692 spdk_bdev_quiesce_cb cb_fn, void *cb_arg) 693 { 694 if (cb_fn) { 695 cb_fn(cb_arg, 0); 696 } 697 698 return 0; 699 } 700 701 int 702 spdk_bdev_unquiesce_range(struct spdk_bdev *bdev, struct spdk_bdev_module *module, 703 uint64_t offset, uint64_t length, 704 spdk_bdev_quiesce_cb cb_fn, void *cb_arg) 705 { 706 if (cb_fn) { 707 cb_fn(cb_arg, 0); 708 } 709 710 return 0; 711 } 712 713 static void 714 bdev_io_cleanup(struct spdk_bdev_io *bdev_io) 715 { 716 if (bdev_io->u.bdev.iovs) { 717 int i; 718 719 for (i = 0; i < bdev_io->u.bdev.iovcnt; i++) { 720 free(bdev_io->u.bdev.iovs[i].iov_base); 721 } 722 free(bdev_io->u.bdev.iovs); 723 } 724 free(bdev_io); 725 } 726 727 static void 728 _bdev_io_initialize(struct spdk_bdev_io *bdev_io, struct spdk_io_channel *ch, 729 struct spdk_bdev *bdev, uint64_t lba, uint64_t blocks, int16_t iotype, 730 int iovcnt, size_t iov_len) 731 { 732 struct spdk_bdev_channel *channel = spdk_io_channel_get_ctx(ch); 733 int i; 734 735 bdev_io->bdev = bdev; 736 bdev_io->u.bdev.offset_blocks = lba; 737 bdev_io->u.bdev.num_blocks = blocks; 738 bdev_io->type = iotype; 739 bdev_io->internal.ch = channel; 740 bdev_io->u.bdev.iovcnt = iovcnt; 741 742 if (iovcnt == 0) { 743 bdev_io->u.bdev.iovs = NULL; 744 return; 745 } 746 747 SPDK_CU_ASSERT_FATAL(iov_len * iovcnt == blocks * g_block_len); 748 749 bdev_io->u.bdev.iovs = calloc(iovcnt, sizeof(struct iovec)); 750 SPDK_CU_ASSERT_FATAL(bdev_io->u.bdev.iovs != NULL); 751 752 for (i = 0; i < iovcnt; i++) { 753 struct iovec *iov = &bdev_io->u.bdev.iovs[i]; 754 755 iov->iov_base = calloc(1, iov_len); 756 SPDK_CU_ASSERT_FATAL(iov->iov_base != NULL); 757 iov->iov_len = iov_len; 758 } 759 } 760 761 static void 762 bdev_io_initialize(struct spdk_bdev_io *bdev_io, struct spdk_io_channel *ch, struct spdk_bdev *bdev, 763 uint64_t lba, uint64_t blocks, int16_t iotype) 764 { 765 int iovcnt; 766 size_t iov_len; 767 768 if (bdev_io->type == SPDK_BDEV_IO_TYPE_UNMAP || bdev_io->type == SPDK_BDEV_IO_TYPE_FLUSH) { 769 iovcnt = 0; 770 iov_len = 0; 771 } else { 772 iovcnt = 1; 773 iov_len = blocks * g_block_len; 774 } 775 776 _bdev_io_initialize(bdev_io, ch, bdev, lba, blocks, iotype, iovcnt, iov_len); 777 } 778 779 static void 780 verify_reset_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives, 781 struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, uint32_t io_status) 782 { 783 uint8_t index = 0; 784 struct io_output *output; 785 786 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 787 SPDK_CU_ASSERT_FATAL(num_base_drives != 0); 788 SPDK_CU_ASSERT_FATAL(io_status != INVALID_IO_SUBMIT); 789 SPDK_CU_ASSERT_FATAL(ch_ctx->base_channel != NULL); 790 791 CU_ASSERT(g_io_output_index == num_base_drives); 792 for (index = 0; index < g_io_output_index; index++) { 793 output = &g_io_output[index]; 794 CU_ASSERT(ch_ctx->base_channel[index] == output->ch); 795 CU_ASSERT(raid_bdev->base_bdev_info[index].desc == output->desc); 796 CU_ASSERT(bdev_io->type == output->iotype); 797 } 798 CU_ASSERT(g_io_comp_status == io_status); 799 } 800 801 static void 802 verify_io(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives, 803 struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, uint32_t io_status) 804 { 805 uint32_t strip_shift = spdk_u32log2(g_strip_size); 806 uint64_t start_strip = bdev_io->u.bdev.offset_blocks >> strip_shift; 807 uint64_t end_strip = (bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) >> 808 strip_shift; 809 uint32_t splits_reqd = (end_strip - start_strip + 1); 810 uint32_t strip; 811 uint64_t pd_strip; 812 uint8_t pd_idx; 813 uint32_t offset_in_strip; 814 uint64_t pd_lba; 815 uint64_t pd_blocks; 816 uint32_t index = 0; 817 struct io_output *output; 818 819 if (io_status == INVALID_IO_SUBMIT) { 820 CU_ASSERT(g_io_comp_status == false); 821 return; 822 } 823 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 824 SPDK_CU_ASSERT_FATAL(num_base_drives != 0); 825 826 CU_ASSERT(splits_reqd == g_io_output_index); 827 for (strip = start_strip; strip <= end_strip; strip++, index++) { 828 pd_strip = strip / num_base_drives; 829 pd_idx = strip % num_base_drives; 830 if (strip == start_strip) { 831 offset_in_strip = bdev_io->u.bdev.offset_blocks & (g_strip_size - 1); 832 pd_lba = (pd_strip << strip_shift) + offset_in_strip; 833 if (strip == end_strip) { 834 pd_blocks = bdev_io->u.bdev.num_blocks; 835 } else { 836 pd_blocks = g_strip_size - offset_in_strip; 837 } 838 } else if (strip == end_strip) { 839 pd_lba = pd_strip << strip_shift; 840 pd_blocks = ((bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) & 841 (g_strip_size - 1)) + 1; 842 } else { 843 pd_lba = pd_strip << raid_bdev->strip_size_shift; 844 pd_blocks = raid_bdev->strip_size; 845 } 846 output = &g_io_output[index]; 847 CU_ASSERT(pd_lba == output->offset_blocks); 848 CU_ASSERT(pd_blocks == output->num_blocks); 849 CU_ASSERT(ch_ctx->base_channel[pd_idx] == output->ch); 850 CU_ASSERT(raid_bdev->base_bdev_info[pd_idx].desc == output->desc); 851 CU_ASSERT(bdev_io->type == output->iotype); 852 } 853 CU_ASSERT(g_io_comp_status == io_status); 854 } 855 856 static void 857 verify_io_without_payload(struct spdk_bdev_io *bdev_io, uint8_t num_base_drives, 858 struct raid_bdev_io_channel *ch_ctx, struct raid_bdev *raid_bdev, 859 uint32_t io_status) 860 { 861 uint32_t strip_shift = spdk_u32log2(g_strip_size); 862 uint64_t start_offset_in_strip = bdev_io->u.bdev.offset_blocks % g_strip_size; 863 uint64_t end_offset_in_strip = (bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) % 864 g_strip_size; 865 uint64_t start_strip = bdev_io->u.bdev.offset_blocks >> strip_shift; 866 uint64_t end_strip = (bdev_io->u.bdev.offset_blocks + bdev_io->u.bdev.num_blocks - 1) >> 867 strip_shift; 868 uint8_t n_disks_involved; 869 uint64_t start_strip_disk_idx; 870 uint64_t end_strip_disk_idx; 871 uint64_t nblocks_in_start_disk; 872 uint64_t offset_in_start_disk; 873 uint8_t disk_idx; 874 uint64_t base_io_idx; 875 uint64_t sum_nblocks = 0; 876 struct io_output *output; 877 878 if (io_status == INVALID_IO_SUBMIT) { 879 CU_ASSERT(g_io_comp_status == false); 880 return; 881 } 882 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 883 SPDK_CU_ASSERT_FATAL(num_base_drives != 0); 884 SPDK_CU_ASSERT_FATAL(bdev_io->type != SPDK_BDEV_IO_TYPE_READ); 885 SPDK_CU_ASSERT_FATAL(bdev_io->type != SPDK_BDEV_IO_TYPE_WRITE); 886 887 n_disks_involved = spdk_min(end_strip - start_strip + 1, num_base_drives); 888 CU_ASSERT(n_disks_involved == g_io_output_index); 889 890 start_strip_disk_idx = start_strip % num_base_drives; 891 end_strip_disk_idx = end_strip % num_base_drives; 892 893 offset_in_start_disk = g_io_output[0].offset_blocks; 894 nblocks_in_start_disk = g_io_output[0].num_blocks; 895 896 for (base_io_idx = 0, disk_idx = start_strip_disk_idx; base_io_idx < n_disks_involved; 897 base_io_idx++, disk_idx++) { 898 uint64_t start_offset_in_disk; 899 uint64_t end_offset_in_disk; 900 901 output = &g_io_output[base_io_idx]; 902 903 /* round disk_idx */ 904 if (disk_idx >= num_base_drives) { 905 disk_idx %= num_base_drives; 906 } 907 908 /* start_offset_in_disk aligned in strip check: 909 * The first base io has a same start_offset_in_strip with the whole raid io. 910 * Other base io should have aligned start_offset_in_strip which is 0. 911 */ 912 start_offset_in_disk = output->offset_blocks; 913 if (base_io_idx == 0) { 914 CU_ASSERT(start_offset_in_disk % g_strip_size == start_offset_in_strip); 915 } else { 916 CU_ASSERT(start_offset_in_disk % g_strip_size == 0); 917 } 918 919 /* end_offset_in_disk aligned in strip check: 920 * Base io on disk at which end_strip is located, has a same end_offset_in_strip 921 * with the whole raid io. 922 * Other base io should have aligned end_offset_in_strip. 923 */ 924 end_offset_in_disk = output->offset_blocks + output->num_blocks - 1; 925 if (disk_idx == end_strip_disk_idx) { 926 CU_ASSERT(end_offset_in_disk % g_strip_size == end_offset_in_strip); 927 } else { 928 CU_ASSERT(end_offset_in_disk % g_strip_size == g_strip_size - 1); 929 } 930 931 /* start_offset_in_disk compared with start_disk. 932 * 1. For disk_idx which is larger than start_strip_disk_idx: Its start_offset_in_disk 933 * mustn't be larger than the start offset of start_offset_in_disk; And the gap 934 * must be less than strip size. 935 * 2. For disk_idx which is less than start_strip_disk_idx, Its start_offset_in_disk 936 * must be larger than the start offset of start_offset_in_disk; And the gap mustn't 937 * be less than strip size. 938 */ 939 if (disk_idx > start_strip_disk_idx) { 940 CU_ASSERT(start_offset_in_disk <= offset_in_start_disk); 941 CU_ASSERT(offset_in_start_disk - start_offset_in_disk < g_strip_size); 942 } else if (disk_idx < start_strip_disk_idx) { 943 CU_ASSERT(start_offset_in_disk > offset_in_start_disk); 944 CU_ASSERT(output->offset_blocks - offset_in_start_disk <= g_strip_size); 945 } 946 947 /* nblocks compared with start_disk: 948 * The gap between them must be within a strip size. 949 */ 950 if (output->num_blocks <= nblocks_in_start_disk) { 951 CU_ASSERT(nblocks_in_start_disk - output->num_blocks <= g_strip_size); 952 } else { 953 CU_ASSERT(output->num_blocks - nblocks_in_start_disk < g_strip_size); 954 } 955 956 sum_nblocks += output->num_blocks; 957 958 CU_ASSERT(ch_ctx->base_channel[disk_idx] == output->ch); 959 CU_ASSERT(raid_bdev->base_bdev_info[disk_idx].desc == output->desc); 960 CU_ASSERT(bdev_io->type == output->iotype); 961 } 962 963 /* Sum of each nblocks should be same with raid bdev_io */ 964 CU_ASSERT(bdev_io->u.bdev.num_blocks == sum_nblocks); 965 966 CU_ASSERT(g_io_comp_status == io_status); 967 } 968 969 static void 970 verify_raid_bdev_present(const char *name, bool presence) 971 { 972 struct raid_bdev *pbdev; 973 bool pbdev_found; 974 975 pbdev_found = false; 976 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 977 if (strcmp(pbdev->bdev.name, name) == 0) { 978 pbdev_found = true; 979 break; 980 } 981 } 982 if (presence == true) { 983 CU_ASSERT(pbdev_found == true); 984 } else { 985 CU_ASSERT(pbdev_found == false); 986 } 987 } 988 989 static void 990 verify_raid_bdev(struct rpc_bdev_raid_create *r, bool presence, uint32_t raid_state) 991 { 992 struct raid_bdev *pbdev; 993 struct raid_base_bdev_info *base_info; 994 struct spdk_bdev *bdev = NULL; 995 bool pbdev_found; 996 uint64_t min_blockcnt = 0xFFFFFFFFFFFFFFFF; 997 998 pbdev_found = false; 999 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1000 if (strcmp(pbdev->bdev.name, r->name) == 0) { 1001 pbdev_found = true; 1002 if (presence == false) { 1003 break; 1004 } 1005 CU_ASSERT(pbdev->base_bdev_info != NULL); 1006 CU_ASSERT(pbdev->strip_size == ((r->strip_size_kb * 1024) / g_block_len)); 1007 CU_ASSERT(pbdev->strip_size_shift == spdk_u32log2(((r->strip_size_kb * 1024) / 1008 g_block_len))); 1009 CU_ASSERT(pbdev->blocklen_shift == spdk_u32log2(g_block_len)); 1010 CU_ASSERT((uint32_t)pbdev->state == raid_state); 1011 CU_ASSERT(pbdev->num_base_bdevs == r->base_bdevs.num_base_bdevs); 1012 CU_ASSERT(pbdev->num_base_bdevs_discovered == r->base_bdevs.num_base_bdevs); 1013 CU_ASSERT(pbdev->level == r->level); 1014 CU_ASSERT(pbdev->base_bdev_info != NULL); 1015 RAID_FOR_EACH_BASE_BDEV(pbdev, base_info) { 1016 CU_ASSERT(base_info->desc != NULL); 1017 bdev = spdk_bdev_desc_get_bdev(base_info->desc); 1018 CU_ASSERT(bdev != NULL); 1019 CU_ASSERT(base_info->remove_scheduled == false); 1020 CU_ASSERT((pbdev->superblock_enabled && base_info->data_offset != 0) || 1021 (!pbdev->superblock_enabled && base_info->data_offset == 0)); 1022 CU_ASSERT(base_info->data_offset + base_info->data_size == bdev->blockcnt); 1023 1024 if (bdev && base_info->data_size < min_blockcnt) { 1025 min_blockcnt = base_info->data_size; 1026 } 1027 } 1028 CU_ASSERT((((min_blockcnt / (r->strip_size_kb * 1024 / g_block_len)) * 1029 (r->strip_size_kb * 1024 / g_block_len)) * 1030 r->base_bdevs.num_base_bdevs) == pbdev->bdev.blockcnt); 1031 CU_ASSERT(strcmp(pbdev->bdev.product_name, "Raid Volume") == 0); 1032 CU_ASSERT(pbdev->bdev.write_cache == 0); 1033 CU_ASSERT(pbdev->bdev.blocklen == g_block_len); 1034 if (pbdev->num_base_bdevs > 1) { 1035 CU_ASSERT(pbdev->bdev.optimal_io_boundary == pbdev->strip_size); 1036 CU_ASSERT(pbdev->bdev.split_on_optimal_io_boundary == true); 1037 } else { 1038 CU_ASSERT(pbdev->bdev.optimal_io_boundary == 0); 1039 CU_ASSERT(pbdev->bdev.split_on_optimal_io_boundary == false); 1040 } 1041 CU_ASSERT(pbdev->bdev.ctxt == pbdev); 1042 CU_ASSERT(pbdev->bdev.fn_table == &g_raid_bdev_fn_table); 1043 CU_ASSERT(pbdev->bdev.module == &g_raid_if); 1044 break; 1045 } 1046 } 1047 if (presence == true) { 1048 CU_ASSERT(pbdev_found == true); 1049 } else { 1050 CU_ASSERT(pbdev_found == false); 1051 } 1052 } 1053 1054 static void 1055 verify_get_raids(struct rpc_bdev_raid_create *construct_req, 1056 uint8_t g_max_raids, 1057 char **g_get_raids_output, uint32_t g_get_raids_count) 1058 { 1059 uint8_t i, j; 1060 bool found; 1061 1062 CU_ASSERT(g_max_raids == g_get_raids_count); 1063 if (g_max_raids == g_get_raids_count) { 1064 for (i = 0; i < g_max_raids; i++) { 1065 found = false; 1066 for (j = 0; j < g_max_raids; j++) { 1067 if (construct_req[i].name && 1068 strcmp(construct_req[i].name, g_get_raids_output[i]) == 0) { 1069 found = true; 1070 break; 1071 } 1072 } 1073 CU_ASSERT(found == true); 1074 } 1075 } 1076 } 1077 1078 static void 1079 create_base_bdevs(uint32_t bbdev_start_idx) 1080 { 1081 uint8_t i; 1082 struct spdk_bdev *base_bdev; 1083 char name[16]; 1084 1085 for (i = 0; i < g_max_base_drives; i++, bbdev_start_idx++) { 1086 snprintf(name, 16, "%s%u%s", "Nvme", bbdev_start_idx, "n1"); 1087 base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1088 SPDK_CU_ASSERT_FATAL(base_bdev != NULL); 1089 base_bdev->name = strdup(name); 1090 spdk_uuid_generate(&base_bdev->uuid); 1091 SPDK_CU_ASSERT_FATAL(base_bdev->name != NULL); 1092 base_bdev->blocklen = g_block_len; 1093 base_bdev->blockcnt = BLOCK_CNT; 1094 TAILQ_INSERT_TAIL(&g_bdev_list, base_bdev, internal.link); 1095 } 1096 } 1097 1098 static void 1099 create_test_req(struct rpc_bdev_raid_create *r, const char *raid_name, 1100 uint8_t bbdev_start_idx, bool create_base_bdev, bool superblock_enabled) 1101 { 1102 uint8_t i; 1103 char name[16]; 1104 uint8_t bbdev_idx = bbdev_start_idx; 1105 1106 r->name = strdup(raid_name); 1107 SPDK_CU_ASSERT_FATAL(r->name != NULL); 1108 r->strip_size_kb = (g_strip_size * g_block_len) / 1024; 1109 r->level = RAID0; 1110 r->superblock_enabled = superblock_enabled; 1111 r->base_bdevs.num_base_bdevs = g_max_base_drives; 1112 for (i = 0; i < g_max_base_drives; i++, bbdev_idx++) { 1113 snprintf(name, 16, "%s%u%s", "Nvme", bbdev_idx, "n1"); 1114 r->base_bdevs.base_bdevs[i] = strdup(name); 1115 SPDK_CU_ASSERT_FATAL(r->base_bdevs.base_bdevs[i] != NULL); 1116 } 1117 if (create_base_bdev == true) { 1118 create_base_bdevs(bbdev_start_idx); 1119 } 1120 g_rpc_req = r; 1121 g_rpc_req_size = sizeof(*r); 1122 } 1123 1124 static void 1125 create_raid_bdev_create_req(struct rpc_bdev_raid_create *r, const char *raid_name, 1126 uint8_t bbdev_start_idx, bool create_base_bdev, 1127 uint8_t json_decode_obj_err, bool superblock_enabled) 1128 { 1129 create_test_req(r, raid_name, bbdev_start_idx, create_base_bdev, superblock_enabled); 1130 1131 g_rpc_err = 0; 1132 g_json_decode_obj_create = 1; 1133 g_json_decode_obj_err = json_decode_obj_err; 1134 g_config_level_create = 0; 1135 g_test_multi_raids = 0; 1136 } 1137 1138 static void 1139 free_test_req(struct rpc_bdev_raid_create *r) 1140 { 1141 uint8_t i; 1142 1143 free(r->name); 1144 for (i = 0; i < r->base_bdevs.num_base_bdevs; i++) { 1145 free(r->base_bdevs.base_bdevs[i]); 1146 } 1147 } 1148 1149 static void 1150 create_raid_bdev_delete_req(struct rpc_bdev_raid_delete *r, const char *raid_name, 1151 uint8_t json_decode_obj_err) 1152 { 1153 r->name = strdup(raid_name); 1154 SPDK_CU_ASSERT_FATAL(r->name != NULL); 1155 1156 g_rpc_req = r; 1157 g_rpc_req_size = sizeof(*r); 1158 g_rpc_err = 0; 1159 g_json_decode_obj_create = 0; 1160 g_json_decode_obj_err = json_decode_obj_err; 1161 g_config_level_create = 0; 1162 g_test_multi_raids = 0; 1163 } 1164 1165 static void 1166 create_get_raids_req(struct rpc_bdev_raid_get_bdevs *r, const char *category, 1167 uint8_t json_decode_obj_err) 1168 { 1169 r->category = strdup(category); 1170 SPDK_CU_ASSERT_FATAL(r->category != NULL); 1171 1172 g_rpc_req = r; 1173 g_rpc_req_size = sizeof(*r); 1174 g_rpc_err = 0; 1175 g_json_decode_obj_create = 0; 1176 g_json_decode_obj_err = json_decode_obj_err; 1177 g_config_level_create = 0; 1178 g_test_multi_raids = 1; 1179 g_get_raids_count = 0; 1180 } 1181 1182 static void 1183 test_create_raid(void) 1184 { 1185 struct rpc_bdev_raid_create req; 1186 struct rpc_bdev_raid_delete delete_req; 1187 1188 set_globals(); 1189 CU_ASSERT(raid_bdev_init() == 0); 1190 1191 verify_raid_bdev_present("raid1", false); 1192 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1193 rpc_bdev_raid_create(NULL, NULL); 1194 CU_ASSERT(g_rpc_err == 0); 1195 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1196 free_test_req(&req); 1197 1198 create_raid_bdev_delete_req(&delete_req, "raid1", 0); 1199 rpc_bdev_raid_delete(NULL, NULL); 1200 CU_ASSERT(g_rpc_err == 0); 1201 raid_bdev_exit(); 1202 base_bdevs_cleanup(); 1203 reset_globals(); 1204 } 1205 1206 static void 1207 test_delete_raid(void) 1208 { 1209 struct rpc_bdev_raid_create construct_req; 1210 struct rpc_bdev_raid_delete delete_req; 1211 1212 set_globals(); 1213 CU_ASSERT(raid_bdev_init() == 0); 1214 1215 verify_raid_bdev_present("raid1", false); 1216 create_raid_bdev_create_req(&construct_req, "raid1", 0, true, 0, false); 1217 rpc_bdev_raid_create(NULL, NULL); 1218 CU_ASSERT(g_rpc_err == 0); 1219 verify_raid_bdev(&construct_req, true, RAID_BDEV_STATE_ONLINE); 1220 free_test_req(&construct_req); 1221 1222 create_raid_bdev_delete_req(&delete_req, "raid1", 0); 1223 rpc_bdev_raid_delete(NULL, NULL); 1224 CU_ASSERT(g_rpc_err == 0); 1225 verify_raid_bdev_present("raid1", false); 1226 1227 raid_bdev_exit(); 1228 base_bdevs_cleanup(); 1229 reset_globals(); 1230 } 1231 1232 static void 1233 test_create_raid_invalid_args(void) 1234 { 1235 struct rpc_bdev_raid_create req; 1236 struct rpc_bdev_raid_delete destroy_req; 1237 struct raid_bdev *raid_bdev; 1238 1239 set_globals(); 1240 CU_ASSERT(raid_bdev_init() == 0); 1241 1242 verify_raid_bdev_present("raid1", false); 1243 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1244 req.level = INVALID_RAID_LEVEL; 1245 rpc_bdev_raid_create(NULL, NULL); 1246 CU_ASSERT(g_rpc_err == 1); 1247 free_test_req(&req); 1248 verify_raid_bdev_present("raid1", false); 1249 1250 create_raid_bdev_create_req(&req, "raid1", 0, false, 1, false); 1251 rpc_bdev_raid_create(NULL, NULL); 1252 CU_ASSERT(g_rpc_err == 1); 1253 free_test_req(&req); 1254 verify_raid_bdev_present("raid1", false); 1255 1256 create_raid_bdev_create_req(&req, "raid1", 0, false, 0, false); 1257 req.strip_size_kb = 1231; 1258 rpc_bdev_raid_create(NULL, NULL); 1259 CU_ASSERT(g_rpc_err == 1); 1260 free_test_req(&req); 1261 verify_raid_bdev_present("raid1", false); 1262 1263 create_raid_bdev_create_req(&req, "raid1", 0, false, 0, false); 1264 rpc_bdev_raid_create(NULL, NULL); 1265 CU_ASSERT(g_rpc_err == 0); 1266 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1267 free_test_req(&req); 1268 1269 create_raid_bdev_create_req(&req, "raid1", 0, false, 0, false); 1270 rpc_bdev_raid_create(NULL, NULL); 1271 CU_ASSERT(g_rpc_err == 1); 1272 free_test_req(&req); 1273 1274 create_raid_bdev_create_req(&req, "raid2", 0, false, 0, false); 1275 rpc_bdev_raid_create(NULL, NULL); 1276 CU_ASSERT(g_rpc_err == 1); 1277 free_test_req(&req); 1278 verify_raid_bdev_present("raid2", false); 1279 1280 create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, true, 0, false); 1281 free(req.base_bdevs.base_bdevs[g_max_base_drives - 1]); 1282 req.base_bdevs.base_bdevs[g_max_base_drives - 1] = strdup("Nvme0n1"); 1283 SPDK_CU_ASSERT_FATAL(req.base_bdevs.base_bdevs[g_max_base_drives - 1] != NULL); 1284 rpc_bdev_raid_create(NULL, NULL); 1285 CU_ASSERT(g_rpc_err == 1); 1286 free_test_req(&req); 1287 verify_raid_bdev_present("raid2", false); 1288 1289 create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, true, 0, false); 1290 free(req.base_bdevs.base_bdevs[g_max_base_drives - 1]); 1291 req.base_bdevs.base_bdevs[g_max_base_drives - 1] = strdup("Nvme100000n1"); 1292 SPDK_CU_ASSERT_FATAL(req.base_bdevs.base_bdevs[g_max_base_drives - 1] != NULL); 1293 rpc_bdev_raid_create(NULL, NULL); 1294 CU_ASSERT(g_rpc_err == 0); 1295 free_test_req(&req); 1296 verify_raid_bdev_present("raid2", true); 1297 raid_bdev = raid_bdev_find_by_name("raid2"); 1298 SPDK_CU_ASSERT_FATAL(raid_bdev != NULL); 1299 check_and_remove_raid_bdev(raid_bdev); 1300 1301 create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, false, 0, false); 1302 rpc_bdev_raid_create(NULL, NULL); 1303 CU_ASSERT(g_rpc_err == 0); 1304 free_test_req(&req); 1305 verify_raid_bdev_present("raid2", true); 1306 verify_raid_bdev_present("raid1", true); 1307 1308 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1309 rpc_bdev_raid_delete(NULL, NULL); 1310 create_raid_bdev_delete_req(&destroy_req, "raid2", 0); 1311 rpc_bdev_raid_delete(NULL, NULL); 1312 raid_bdev_exit(); 1313 base_bdevs_cleanup(); 1314 reset_globals(); 1315 } 1316 1317 static void 1318 test_delete_raid_invalid_args(void) 1319 { 1320 struct rpc_bdev_raid_create construct_req; 1321 struct rpc_bdev_raid_delete destroy_req; 1322 1323 set_globals(); 1324 CU_ASSERT(raid_bdev_init() == 0); 1325 1326 verify_raid_bdev_present("raid1", false); 1327 create_raid_bdev_create_req(&construct_req, "raid1", 0, true, 0, false); 1328 rpc_bdev_raid_create(NULL, NULL); 1329 CU_ASSERT(g_rpc_err == 0); 1330 verify_raid_bdev(&construct_req, true, RAID_BDEV_STATE_ONLINE); 1331 free_test_req(&construct_req); 1332 1333 create_raid_bdev_delete_req(&destroy_req, "raid2", 0); 1334 rpc_bdev_raid_delete(NULL, NULL); 1335 CU_ASSERT(g_rpc_err == 1); 1336 1337 create_raid_bdev_delete_req(&destroy_req, "raid1", 1); 1338 rpc_bdev_raid_delete(NULL, NULL); 1339 CU_ASSERT(g_rpc_err == 1); 1340 free(destroy_req.name); 1341 verify_raid_bdev_present("raid1", true); 1342 1343 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1344 rpc_bdev_raid_delete(NULL, NULL); 1345 CU_ASSERT(g_rpc_err == 0); 1346 verify_raid_bdev_present("raid1", false); 1347 1348 raid_bdev_exit(); 1349 base_bdevs_cleanup(); 1350 reset_globals(); 1351 } 1352 1353 static void 1354 test_io_channel(void) 1355 { 1356 struct rpc_bdev_raid_create req; 1357 struct rpc_bdev_raid_delete destroy_req; 1358 struct raid_bdev *pbdev; 1359 struct spdk_io_channel *ch; 1360 struct raid_bdev_io_channel *ch_ctx; 1361 1362 set_globals(); 1363 CU_ASSERT(raid_bdev_init() == 0); 1364 1365 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1366 verify_raid_bdev_present("raid1", false); 1367 rpc_bdev_raid_create(NULL, NULL); 1368 CU_ASSERT(g_rpc_err == 0); 1369 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1370 1371 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1372 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1373 break; 1374 } 1375 } 1376 CU_ASSERT(pbdev != NULL); 1377 1378 ch = spdk_get_io_channel(pbdev); 1379 SPDK_CU_ASSERT_FATAL(ch != NULL); 1380 1381 ch_ctx = spdk_io_channel_get_ctx(ch); 1382 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1383 1384 free_test_req(&req); 1385 1386 spdk_put_io_channel(ch); 1387 1388 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1389 rpc_bdev_raid_delete(NULL, NULL); 1390 CU_ASSERT(g_rpc_err == 0); 1391 verify_raid_bdev_present("raid1", false); 1392 1393 raid_bdev_exit(); 1394 base_bdevs_cleanup(); 1395 reset_globals(); 1396 } 1397 1398 static void 1399 test_write_io(void) 1400 { 1401 struct rpc_bdev_raid_create req; 1402 struct rpc_bdev_raid_delete destroy_req; 1403 struct raid_bdev *pbdev; 1404 struct spdk_io_channel *ch; 1405 struct raid_bdev_io_channel *ch_ctx; 1406 uint8_t i; 1407 struct spdk_bdev_io *bdev_io; 1408 uint64_t io_len; 1409 uint64_t lba = 0; 1410 1411 set_globals(); 1412 CU_ASSERT(raid_bdev_init() == 0); 1413 1414 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1415 verify_raid_bdev_present("raid1", false); 1416 rpc_bdev_raid_create(NULL, NULL); 1417 CU_ASSERT(g_rpc_err == 0); 1418 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1419 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1420 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1421 break; 1422 } 1423 } 1424 CU_ASSERT(pbdev != NULL); 1425 1426 ch = spdk_get_io_channel(pbdev); 1427 SPDK_CU_ASSERT_FATAL(ch != NULL); 1428 1429 ch_ctx = spdk_io_channel_get_ctx(ch); 1430 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1431 1432 /* test 2 IO sizes based on global strip size set earlier */ 1433 for (i = 0; i < 2; i++) { 1434 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1435 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1436 io_len = (g_strip_size / 2) << i; 1437 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_WRITE); 1438 lba += g_strip_size; 1439 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1440 g_io_output_index = 0; 1441 raid_bdev_submit_request(ch, bdev_io); 1442 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1443 g_child_io_status_flag); 1444 bdev_io_cleanup(bdev_io); 1445 } 1446 1447 free_test_req(&req); 1448 spdk_put_io_channel(ch); 1449 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1450 rpc_bdev_raid_delete(NULL, NULL); 1451 CU_ASSERT(g_rpc_err == 0); 1452 verify_raid_bdev_present("raid1", false); 1453 1454 raid_bdev_exit(); 1455 base_bdevs_cleanup(); 1456 reset_globals(); 1457 } 1458 1459 static void 1460 test_read_io(void) 1461 { 1462 struct rpc_bdev_raid_create req; 1463 struct rpc_bdev_raid_delete destroy_req; 1464 struct raid_bdev *pbdev; 1465 struct spdk_io_channel *ch; 1466 struct raid_bdev_io_channel *ch_ctx; 1467 uint8_t i; 1468 struct spdk_bdev_io *bdev_io; 1469 uint64_t io_len; 1470 uint64_t lba; 1471 1472 set_globals(); 1473 CU_ASSERT(raid_bdev_init() == 0); 1474 1475 verify_raid_bdev_present("raid1", false); 1476 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1477 rpc_bdev_raid_create(NULL, NULL); 1478 CU_ASSERT(g_rpc_err == 0); 1479 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1480 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1481 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1482 break; 1483 } 1484 } 1485 CU_ASSERT(pbdev != NULL); 1486 1487 ch = spdk_get_io_channel(pbdev); 1488 SPDK_CU_ASSERT_FATAL(ch != NULL); 1489 1490 ch_ctx = spdk_io_channel_get_ctx(ch); 1491 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1492 1493 /* test 2 IO sizes based on global strip size set earlier */ 1494 lba = 0; 1495 for (i = 0; i < 2; i++) { 1496 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1497 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1498 io_len = (g_strip_size / 2) << i; 1499 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_READ); 1500 lba += g_strip_size; 1501 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1502 g_io_output_index = 0; 1503 raid_bdev_submit_request(ch, bdev_io); 1504 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1505 g_child_io_status_flag); 1506 bdev_io_cleanup(bdev_io); 1507 } 1508 1509 free_test_req(&req); 1510 spdk_put_io_channel(ch); 1511 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1512 rpc_bdev_raid_delete(NULL, NULL); 1513 CU_ASSERT(g_rpc_err == 0); 1514 verify_raid_bdev_present("raid1", false); 1515 1516 raid_bdev_exit(); 1517 base_bdevs_cleanup(); 1518 reset_globals(); 1519 } 1520 1521 static void 1522 raid_bdev_io_generate_by_strips(uint64_t n_strips) 1523 { 1524 uint64_t lba; 1525 uint64_t nblocks; 1526 uint64_t start_offset; 1527 uint64_t end_offset; 1528 uint64_t offsets_in_strip[3]; 1529 uint64_t start_bdev_idx; 1530 uint64_t start_bdev_offset; 1531 uint64_t start_bdev_idxs[3]; 1532 int i, j, l; 1533 1534 /* 3 different situations of offset in strip */ 1535 offsets_in_strip[0] = 0; 1536 offsets_in_strip[1] = g_strip_size >> 1; 1537 offsets_in_strip[2] = g_strip_size - 1; 1538 1539 /* 3 different situations of start_bdev_idx */ 1540 start_bdev_idxs[0] = 0; 1541 start_bdev_idxs[1] = g_max_base_drives >> 1; 1542 start_bdev_idxs[2] = g_max_base_drives - 1; 1543 1544 /* consider different offset in strip */ 1545 for (i = 0; i < 3; i++) { 1546 start_offset = offsets_in_strip[i]; 1547 for (j = 0; j < 3; j++) { 1548 end_offset = offsets_in_strip[j]; 1549 if (n_strips == 1 && start_offset > end_offset) { 1550 continue; 1551 } 1552 1553 /* consider at which base_bdev lba is started. */ 1554 for (l = 0; l < 3; l++) { 1555 start_bdev_idx = start_bdev_idxs[l]; 1556 start_bdev_offset = start_bdev_idx * g_strip_size; 1557 lba = g_lba_offset + start_bdev_offset + start_offset; 1558 nblocks = (n_strips - 1) * g_strip_size + end_offset - start_offset + 1; 1559 1560 g_io_ranges[g_io_range_idx].lba = lba; 1561 g_io_ranges[g_io_range_idx].nblocks = nblocks; 1562 1563 SPDK_CU_ASSERT_FATAL(g_io_range_idx < MAX_TEST_IO_RANGE); 1564 g_io_range_idx++; 1565 } 1566 } 1567 } 1568 } 1569 1570 static void 1571 raid_bdev_io_generate(void) 1572 { 1573 uint64_t n_strips; 1574 uint64_t n_strips_span = g_max_base_drives; 1575 uint64_t n_strips_times[5] = {g_max_base_drives + 1, g_max_base_drives * 2 - 1, 1576 g_max_base_drives * 2, g_max_base_drives * 3, 1577 g_max_base_drives * 4 1578 }; 1579 uint32_t i; 1580 1581 g_io_range_idx = 0; 1582 1583 /* consider different number of strips from 1 to strips spanned base bdevs, 1584 * and even to times of strips spanned base bdevs 1585 */ 1586 for (n_strips = 1; n_strips < n_strips_span; n_strips++) { 1587 raid_bdev_io_generate_by_strips(n_strips); 1588 } 1589 1590 for (i = 0; i < SPDK_COUNTOF(n_strips_times); i++) { 1591 n_strips = n_strips_times[i]; 1592 raid_bdev_io_generate_by_strips(n_strips); 1593 } 1594 } 1595 1596 static void 1597 test_unmap_io(void) 1598 { 1599 struct rpc_bdev_raid_create req; 1600 struct rpc_bdev_raid_delete destroy_req; 1601 struct raid_bdev *pbdev; 1602 struct spdk_io_channel *ch; 1603 struct raid_bdev_io_channel *ch_ctx; 1604 struct spdk_bdev_io *bdev_io; 1605 uint32_t count; 1606 uint64_t io_len; 1607 uint64_t lba; 1608 1609 set_globals(); 1610 CU_ASSERT(raid_bdev_init() == 0); 1611 1612 verify_raid_bdev_present("raid1", false); 1613 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1614 rpc_bdev_raid_create(NULL, NULL); 1615 CU_ASSERT(g_rpc_err == 0); 1616 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1617 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1618 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1619 break; 1620 } 1621 } 1622 CU_ASSERT(pbdev != NULL); 1623 1624 ch = spdk_get_io_channel(pbdev); 1625 SPDK_CU_ASSERT_FATAL(ch != NULL); 1626 1627 ch_ctx = spdk_io_channel_get_ctx(ch); 1628 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1629 1630 CU_ASSERT(raid_bdev_io_type_supported(pbdev, SPDK_BDEV_IO_TYPE_UNMAP) == true); 1631 CU_ASSERT(raid_bdev_io_type_supported(pbdev, SPDK_BDEV_IO_TYPE_FLUSH) == true); 1632 1633 raid_bdev_io_generate(); 1634 for (count = 0; count < g_io_range_idx; count++) { 1635 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1636 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1637 io_len = g_io_ranges[count].nblocks; 1638 lba = g_io_ranges[count].lba; 1639 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_UNMAP); 1640 memset(g_io_output, 0, g_max_base_drives * sizeof(struct io_output)); 1641 g_io_output_index = 0; 1642 raid_bdev_submit_request(ch, bdev_io); 1643 verify_io_without_payload(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1644 g_child_io_status_flag); 1645 bdev_io_cleanup(bdev_io); 1646 } 1647 1648 free_test_req(&req); 1649 spdk_put_io_channel(ch); 1650 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1651 rpc_bdev_raid_delete(NULL, NULL); 1652 CU_ASSERT(g_rpc_err == 0); 1653 verify_raid_bdev_present("raid1", false); 1654 1655 raid_bdev_exit(); 1656 base_bdevs_cleanup(); 1657 reset_globals(); 1658 } 1659 1660 /* Test IO failures */ 1661 static void 1662 test_io_failure(void) 1663 { 1664 struct rpc_bdev_raid_create req; 1665 struct rpc_bdev_raid_delete destroy_req; 1666 struct raid_bdev *pbdev; 1667 struct spdk_io_channel *ch; 1668 struct raid_bdev_io_channel *ch_ctx; 1669 struct spdk_bdev_io *bdev_io; 1670 uint32_t count; 1671 uint64_t io_len; 1672 uint64_t lba; 1673 1674 set_globals(); 1675 CU_ASSERT(raid_bdev_init() == 0); 1676 1677 verify_raid_bdev_present("raid1", false); 1678 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1679 rpc_bdev_raid_create(NULL, NULL); 1680 CU_ASSERT(g_rpc_err == 0); 1681 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1682 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1683 if (strcmp(pbdev->bdev.name, req.name) == 0) { 1684 break; 1685 } 1686 } 1687 CU_ASSERT(pbdev != NULL); 1688 1689 ch = spdk_get_io_channel(pbdev); 1690 SPDK_CU_ASSERT_FATAL(ch != NULL); 1691 1692 ch_ctx = spdk_io_channel_get_ctx(ch); 1693 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1694 1695 lba = 0; 1696 for (count = 0; count < 1; count++) { 1697 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1698 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1699 io_len = (g_strip_size / 2) << count; 1700 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_INVALID); 1701 lba += g_strip_size; 1702 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1703 g_io_output_index = 0; 1704 raid_bdev_submit_request(ch, bdev_io); 1705 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1706 INVALID_IO_SUBMIT); 1707 bdev_io_cleanup(bdev_io); 1708 } 1709 1710 1711 lba = 0; 1712 g_child_io_status_flag = false; 1713 for (count = 0; count < 1; count++) { 1714 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1715 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1716 io_len = (g_strip_size / 2) << count; 1717 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, SPDK_BDEV_IO_TYPE_WRITE); 1718 lba += g_strip_size; 1719 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1720 g_io_output_index = 0; 1721 raid_bdev_submit_request(ch, bdev_io); 1722 verify_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1723 g_child_io_status_flag); 1724 bdev_io_cleanup(bdev_io); 1725 } 1726 1727 free_test_req(&req); 1728 spdk_put_io_channel(ch); 1729 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1730 rpc_bdev_raid_delete(NULL, NULL); 1731 CU_ASSERT(g_rpc_err == 0); 1732 verify_raid_bdev_present("raid1", false); 1733 1734 raid_bdev_exit(); 1735 base_bdevs_cleanup(); 1736 reset_globals(); 1737 } 1738 1739 /* Test reset IO */ 1740 static void 1741 test_reset_io(void) 1742 { 1743 struct rpc_bdev_raid_create req; 1744 struct rpc_bdev_raid_delete destroy_req; 1745 struct raid_bdev *pbdev; 1746 struct spdk_io_channel *ch; 1747 struct raid_bdev_io_channel *ch_ctx; 1748 struct spdk_bdev_io *bdev_io; 1749 1750 set_globals(); 1751 CU_ASSERT(raid_bdev_init() == 0); 1752 1753 verify_raid_bdev_present("raid1", false); 1754 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1755 rpc_bdev_raid_create(NULL, NULL); 1756 CU_ASSERT(g_rpc_err == 0); 1757 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1758 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1759 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1760 break; 1761 } 1762 } 1763 CU_ASSERT(pbdev != NULL); 1764 1765 ch = spdk_get_io_channel(pbdev); 1766 SPDK_CU_ASSERT_FATAL(ch != NULL); 1767 1768 ch_ctx = spdk_io_channel_get_ctx(ch); 1769 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1770 1771 g_bdev_io_submit_status = 0; 1772 g_child_io_status_flag = true; 1773 1774 CU_ASSERT(raid_bdev_io_type_supported(pbdev, SPDK_BDEV_IO_TYPE_RESET) == true); 1775 1776 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1777 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1778 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, 0, 1, SPDK_BDEV_IO_TYPE_RESET); 1779 memset(g_io_output, 0, g_max_base_drives * sizeof(struct io_output)); 1780 g_io_output_index = 0; 1781 raid_bdev_submit_request(ch, bdev_io); 1782 verify_reset_io(bdev_io, req.base_bdevs.num_base_bdevs, ch_ctx, pbdev, 1783 true); 1784 bdev_io_cleanup(bdev_io); 1785 1786 free_test_req(&req); 1787 spdk_put_io_channel(ch); 1788 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 1789 rpc_bdev_raid_delete(NULL, NULL); 1790 CU_ASSERT(g_rpc_err == 0); 1791 verify_raid_bdev_present("raid1", false); 1792 1793 raid_bdev_exit(); 1794 base_bdevs_cleanup(); 1795 reset_globals(); 1796 } 1797 1798 /* Create multiple raids, destroy raids without IO, get_raids related tests */ 1799 static void 1800 test_multi_raid_no_io(void) 1801 { 1802 struct rpc_bdev_raid_create *construct_req; 1803 struct rpc_bdev_raid_delete destroy_req; 1804 struct rpc_bdev_raid_get_bdevs get_raids_req; 1805 uint8_t i; 1806 char name[16]; 1807 uint8_t bbdev_idx = 0; 1808 1809 set_globals(); 1810 construct_req = calloc(MAX_RAIDS, sizeof(struct rpc_bdev_raid_create)); 1811 SPDK_CU_ASSERT_FATAL(construct_req != NULL); 1812 CU_ASSERT(raid_bdev_init() == 0); 1813 for (i = 0; i < g_max_raids; i++) { 1814 snprintf(name, 16, "%s%u", "raid", i); 1815 verify_raid_bdev_present(name, false); 1816 create_raid_bdev_create_req(&construct_req[i], name, bbdev_idx, true, 0, false); 1817 bbdev_idx += g_max_base_drives; 1818 rpc_bdev_raid_create(NULL, NULL); 1819 CU_ASSERT(g_rpc_err == 0); 1820 verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE); 1821 } 1822 1823 create_get_raids_req(&get_raids_req, "all", 0); 1824 rpc_bdev_raid_get_bdevs(NULL, NULL); 1825 CU_ASSERT(g_rpc_err == 0); 1826 verify_get_raids(construct_req, g_max_raids, g_get_raids_output, g_get_raids_count); 1827 for (i = 0; i < g_get_raids_count; i++) { 1828 free(g_get_raids_output[i]); 1829 } 1830 1831 create_get_raids_req(&get_raids_req, "online", 0); 1832 rpc_bdev_raid_get_bdevs(NULL, NULL); 1833 CU_ASSERT(g_rpc_err == 0); 1834 verify_get_raids(construct_req, g_max_raids, g_get_raids_output, g_get_raids_count); 1835 for (i = 0; i < g_get_raids_count; i++) { 1836 free(g_get_raids_output[i]); 1837 } 1838 1839 create_get_raids_req(&get_raids_req, "configuring", 0); 1840 rpc_bdev_raid_get_bdevs(NULL, NULL); 1841 CU_ASSERT(g_rpc_err == 0); 1842 CU_ASSERT(g_get_raids_count == 0); 1843 1844 create_get_raids_req(&get_raids_req, "offline", 0); 1845 rpc_bdev_raid_get_bdevs(NULL, NULL); 1846 CU_ASSERT(g_rpc_err == 0); 1847 CU_ASSERT(g_get_raids_count == 0); 1848 1849 create_get_raids_req(&get_raids_req, "invalid_category", 0); 1850 rpc_bdev_raid_get_bdevs(NULL, NULL); 1851 CU_ASSERT(g_rpc_err == 1); 1852 CU_ASSERT(g_get_raids_count == 0); 1853 1854 create_get_raids_req(&get_raids_req, "all", 1); 1855 rpc_bdev_raid_get_bdevs(NULL, NULL); 1856 CU_ASSERT(g_rpc_err == 1); 1857 free(get_raids_req.category); 1858 CU_ASSERT(g_get_raids_count == 0); 1859 1860 create_get_raids_req(&get_raids_req, "all", 0); 1861 rpc_bdev_raid_get_bdevs(NULL, NULL); 1862 CU_ASSERT(g_rpc_err == 0); 1863 CU_ASSERT(g_get_raids_count == g_max_raids); 1864 for (i = 0; i < g_get_raids_count; i++) { 1865 free(g_get_raids_output[i]); 1866 } 1867 1868 for (i = 0; i < g_max_raids; i++) { 1869 SPDK_CU_ASSERT_FATAL(construct_req[i].name != NULL); 1870 snprintf(name, 16, "%s", construct_req[i].name); 1871 create_raid_bdev_delete_req(&destroy_req, name, 0); 1872 rpc_bdev_raid_delete(NULL, NULL); 1873 CU_ASSERT(g_rpc_err == 0); 1874 verify_raid_bdev_present(name, false); 1875 } 1876 raid_bdev_exit(); 1877 for (i = 0; i < g_max_raids; i++) { 1878 free_test_req(&construct_req[i]); 1879 } 1880 free(construct_req); 1881 base_bdevs_cleanup(); 1882 reset_globals(); 1883 } 1884 1885 /* Create multiple raids, fire IOs on raids */ 1886 static void 1887 test_multi_raid_with_io(void) 1888 { 1889 struct rpc_bdev_raid_create *construct_req; 1890 struct rpc_bdev_raid_delete destroy_req; 1891 uint8_t i; 1892 char name[16]; 1893 uint8_t bbdev_idx = 0; 1894 struct raid_bdev *pbdev; 1895 struct spdk_io_channel **channels; 1896 struct spdk_bdev_io *bdev_io; 1897 uint64_t io_len; 1898 uint64_t lba = 0; 1899 int16_t iotype; 1900 1901 set_globals(); 1902 construct_req = calloc(g_max_raids, sizeof(struct rpc_bdev_raid_create)); 1903 SPDK_CU_ASSERT_FATAL(construct_req != NULL); 1904 CU_ASSERT(raid_bdev_init() == 0); 1905 channels = calloc(g_max_raids, sizeof(*channels)); 1906 SPDK_CU_ASSERT_FATAL(channels != NULL); 1907 1908 for (i = 0; i < g_max_raids; i++) { 1909 snprintf(name, 16, "%s%u", "raid", i); 1910 verify_raid_bdev_present(name, false); 1911 create_raid_bdev_create_req(&construct_req[i], name, bbdev_idx, true, 0, false); 1912 bbdev_idx += g_max_base_drives; 1913 rpc_bdev_raid_create(NULL, NULL); 1914 CU_ASSERT(g_rpc_err == 0); 1915 verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE); 1916 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1917 if (strcmp(pbdev->bdev.name, construct_req[i].name) == 0) { 1918 break; 1919 } 1920 } 1921 CU_ASSERT(pbdev != NULL); 1922 1923 channels[i] = spdk_get_io_channel(pbdev); 1924 SPDK_CU_ASSERT_FATAL(channels[i] != NULL); 1925 } 1926 1927 /* This will perform a write on the first raid and a read on the second. It can be 1928 * expanded in the future to perform r/w on each raid device in the event that 1929 * multiple raid levels are supported. 1930 */ 1931 for (i = 0; i < g_max_raids; i++) { 1932 struct spdk_io_channel *ch = channels[i]; 1933 struct raid_bdev_io_channel *ch_ctx = spdk_io_channel_get_ctx(ch); 1934 1935 SPDK_CU_ASSERT_FATAL(ch_ctx != NULL); 1936 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 1937 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 1938 io_len = g_strip_size; 1939 iotype = (i) ? SPDK_BDEV_IO_TYPE_WRITE : SPDK_BDEV_IO_TYPE_READ; 1940 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 1941 g_io_output_index = 0; 1942 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1943 if (strcmp(pbdev->bdev.name, construct_req[i].name) == 0) { 1944 break; 1945 } 1946 } 1947 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, lba, io_len, iotype); 1948 CU_ASSERT(pbdev != NULL); 1949 raid_bdev_submit_request(ch, bdev_io); 1950 verify_io(bdev_io, g_max_base_drives, ch_ctx, pbdev, 1951 g_child_io_status_flag); 1952 bdev_io_cleanup(bdev_io); 1953 } 1954 1955 for (i = 0; i < g_max_raids; i++) { 1956 spdk_put_io_channel(channels[i]); 1957 snprintf(name, 16, "%s", construct_req[i].name); 1958 create_raid_bdev_delete_req(&destroy_req, name, 0); 1959 rpc_bdev_raid_delete(NULL, NULL); 1960 CU_ASSERT(g_rpc_err == 0); 1961 verify_raid_bdev_present(name, false); 1962 } 1963 raid_bdev_exit(); 1964 for (i = 0; i < g_max_raids; i++) { 1965 free_test_req(&construct_req[i]); 1966 } 1967 free(construct_req); 1968 free(channels); 1969 base_bdevs_cleanup(); 1970 reset_globals(); 1971 } 1972 1973 static void 1974 test_io_type_supported(void) 1975 { 1976 CU_ASSERT(raid_bdev_io_type_supported(NULL, SPDK_BDEV_IO_TYPE_READ) == true); 1977 CU_ASSERT(raid_bdev_io_type_supported(NULL, SPDK_BDEV_IO_TYPE_WRITE) == true); 1978 CU_ASSERT(raid_bdev_io_type_supported(NULL, SPDK_BDEV_IO_TYPE_INVALID) == false); 1979 } 1980 1981 static void 1982 test_raid_json_dump_info(void) 1983 { 1984 struct rpc_bdev_raid_create req; 1985 struct rpc_bdev_raid_delete destroy_req; 1986 struct raid_bdev *pbdev; 1987 1988 set_globals(); 1989 CU_ASSERT(raid_bdev_init() == 0); 1990 1991 verify_raid_bdev_present("raid1", false); 1992 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 1993 rpc_bdev_raid_create(NULL, NULL); 1994 CU_ASSERT(g_rpc_err == 0); 1995 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 1996 1997 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 1998 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 1999 break; 2000 } 2001 } 2002 CU_ASSERT(pbdev != NULL); 2003 2004 CU_ASSERT(raid_bdev_dump_info_json(pbdev, NULL) == 0); 2005 2006 free_test_req(&req); 2007 2008 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 2009 rpc_bdev_raid_delete(NULL, NULL); 2010 CU_ASSERT(g_rpc_err == 0); 2011 verify_raid_bdev_present("raid1", false); 2012 2013 raid_bdev_exit(); 2014 base_bdevs_cleanup(); 2015 reset_globals(); 2016 } 2017 2018 static void 2019 test_context_size(void) 2020 { 2021 CU_ASSERT(raid_bdev_get_ctx_size() == sizeof(struct raid_bdev_io)); 2022 } 2023 2024 static void 2025 test_raid_level_conversions(void) 2026 { 2027 const char *raid_str; 2028 2029 CU_ASSERT(raid_bdev_str_to_level("abcd123") == INVALID_RAID_LEVEL); 2030 CU_ASSERT(raid_bdev_str_to_level("0") == RAID0); 2031 CU_ASSERT(raid_bdev_str_to_level("raid0") == RAID0); 2032 CU_ASSERT(raid_bdev_str_to_level("RAID0") == RAID0); 2033 2034 raid_str = raid_bdev_level_to_str(INVALID_RAID_LEVEL); 2035 CU_ASSERT(raid_str != NULL && strlen(raid_str) == 0); 2036 raid_str = raid_bdev_level_to_str(1234); 2037 CU_ASSERT(raid_str != NULL && strlen(raid_str) == 0); 2038 raid_str = raid_bdev_level_to_str(RAID0); 2039 CU_ASSERT(raid_str != NULL && strcmp(raid_str, "raid0") == 0); 2040 } 2041 2042 static void 2043 test_create_raid_superblock(void) 2044 { 2045 struct rpc_bdev_raid_create req; 2046 struct rpc_bdev_raid_delete delete_req; 2047 2048 set_globals(); 2049 CU_ASSERT(raid_bdev_init() == 0); 2050 2051 verify_raid_bdev_present("raid1", false); 2052 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, true); 2053 rpc_bdev_raid_create(NULL, NULL); 2054 CU_ASSERT(g_rpc_err == 0); 2055 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 2056 free_test_req(&req); 2057 2058 create_raid_bdev_delete_req(&delete_req, "raid1", 0); 2059 rpc_bdev_raid_delete(NULL, NULL); 2060 CU_ASSERT(g_rpc_err == 0); 2061 raid_bdev_exit(); 2062 base_bdevs_cleanup(); 2063 reset_globals(); 2064 } 2065 2066 static void 2067 complete_process_request(void *ctx) 2068 { 2069 struct raid_bdev_process_request *process_req = ctx; 2070 2071 raid_bdev_process_request_complete(process_req, 0); 2072 } 2073 2074 static int 2075 submit_process_request(struct raid_bdev_process_request *process_req, 2076 struct raid_bdev_io_channel *raid_ch) 2077 { 2078 struct raid_bdev *raid_bdev = spdk_io_channel_get_io_device(spdk_io_channel_from_ctx(raid_ch)); 2079 2080 *(uint64_t *)raid_bdev->module_private += process_req->num_blocks; 2081 2082 spdk_thread_send_msg(spdk_get_thread(), complete_process_request, process_req); 2083 2084 return process_req->num_blocks; 2085 } 2086 2087 static void 2088 test_raid_process(void) 2089 { 2090 struct rpc_bdev_raid_create req; 2091 struct rpc_bdev_raid_delete destroy_req; 2092 struct raid_bdev *pbdev; 2093 struct spdk_bdev *base_bdev; 2094 struct spdk_thread *process_thread; 2095 uint64_t num_blocks_processed = 0; 2096 2097 set_globals(); 2098 CU_ASSERT(raid_bdev_init() == 0); 2099 2100 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 2101 verify_raid_bdev_present("raid1", false); 2102 TAILQ_FOREACH(base_bdev, &g_bdev_list, internal.link) { 2103 base_bdev->blockcnt = 128; 2104 } 2105 rpc_bdev_raid_create(NULL, NULL); 2106 CU_ASSERT(g_rpc_err == 0); 2107 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 2108 free_test_req(&req); 2109 2110 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 2111 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 2112 break; 2113 } 2114 } 2115 CU_ASSERT(pbdev != NULL); 2116 2117 pbdev->module->submit_process_request = submit_process_request; 2118 pbdev->module_private = &num_blocks_processed; 2119 2120 CU_ASSERT(raid_bdev_start_rebuild(&pbdev->base_bdev_info[0]) == 0); 2121 poll_threads(); 2122 2123 SPDK_CU_ASSERT_FATAL(pbdev->process != NULL); 2124 2125 process_thread = spdk_thread_get_by_id(spdk_thread_get_id(spdk_get_thread()) + 1); 2126 2127 while (spdk_thread_poll(process_thread, 0, 0) > 0) { 2128 poll_threads(); 2129 } 2130 2131 CU_ASSERT(pbdev->process == NULL); 2132 CU_ASSERT(num_blocks_processed == pbdev->bdev.blockcnt); 2133 2134 poll_threads(); 2135 2136 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 2137 rpc_bdev_raid_delete(NULL, NULL); 2138 CU_ASSERT(g_rpc_err == 0); 2139 verify_raid_bdev_present("raid1", false); 2140 2141 raid_bdev_exit(); 2142 base_bdevs_cleanup(); 2143 reset_globals(); 2144 } 2145 2146 static void 2147 test_raid_io_split(void) 2148 { 2149 struct rpc_bdev_raid_create req; 2150 struct rpc_bdev_raid_delete destroy_req; 2151 struct raid_bdev *pbdev; 2152 struct spdk_io_channel *ch; 2153 struct raid_bdev_io_channel *raid_ch; 2154 struct spdk_bdev_io *bdev_io; 2155 struct raid_bdev_io *raid_io; 2156 uint64_t split_offset; 2157 struct iovec iovs_orig[4]; 2158 struct raid_bdev_process process = { }; 2159 2160 set_globals(); 2161 CU_ASSERT(raid_bdev_init() == 0); 2162 2163 verify_raid_bdev_present("raid1", false); 2164 create_raid_bdev_create_req(&req, "raid1", 0, true, 0, false); 2165 rpc_bdev_raid_create(NULL, NULL); 2166 CU_ASSERT(g_rpc_err == 0); 2167 verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE); 2168 2169 TAILQ_FOREACH(pbdev, &g_raid_bdev_list, global_link) { 2170 if (strcmp(pbdev->bdev.name, "raid1") == 0) { 2171 break; 2172 } 2173 } 2174 CU_ASSERT(pbdev != NULL); 2175 pbdev->bdev.md_len = 8; 2176 2177 process.raid_bdev = pbdev; 2178 process.target = &pbdev->base_bdev_info[0]; 2179 pbdev->process = &process; 2180 ch = spdk_get_io_channel(pbdev); 2181 SPDK_CU_ASSERT_FATAL(ch != NULL); 2182 raid_ch = spdk_io_channel_get_ctx(ch); 2183 g_bdev_io_defer_completion = true; 2184 2185 /* test split of bdev_io with 1 iovec */ 2186 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 2187 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 2188 raid_io = (struct raid_bdev_io *)bdev_io->driver_ctx; 2189 bdev_io_initialize(bdev_io, ch, &pbdev->bdev, 0, g_strip_size, SPDK_BDEV_IO_TYPE_WRITE); 2190 memcpy(iovs_orig, bdev_io->u.bdev.iovs, sizeof(*iovs_orig) * bdev_io->u.bdev.iovcnt); 2191 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 2192 bdev_io->u.bdev.md_buf = (void *)0x1000000; 2193 g_io_output_index = 0; 2194 2195 split_offset = 1; 2196 raid_ch->process.offset = split_offset; 2197 raid_bdev_submit_request(ch, bdev_io); 2198 CU_ASSERT(raid_io->num_blocks == g_strip_size - split_offset); 2199 CU_ASSERT(raid_io->offset_blocks == split_offset); 2200 CU_ASSERT(raid_io->iovcnt == 1); 2201 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2202 CU_ASSERT(raid_io->iovs == raid_io->split.iov); 2203 CU_ASSERT(raid_io->iovs[0].iov_base == iovs_orig->iov_base + split_offset * g_block_len); 2204 CU_ASSERT(raid_io->iovs[0].iov_len == iovs_orig->iov_len - split_offset * g_block_len); 2205 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf + split_offset * pbdev->bdev.md_len); 2206 complete_deferred_ios(); 2207 CU_ASSERT(raid_io->num_blocks == split_offset); 2208 CU_ASSERT(raid_io->offset_blocks == 0); 2209 CU_ASSERT(raid_io->iovcnt == 1); 2210 CU_ASSERT(raid_io->iovs[0].iov_base == iovs_orig->iov_base); 2211 CU_ASSERT(raid_io->iovs[0].iov_len == split_offset * g_block_len); 2212 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2213 complete_deferred_ios(); 2214 CU_ASSERT(raid_io->num_blocks == g_strip_size); 2215 CU_ASSERT(raid_io->offset_blocks == 0); 2216 CU_ASSERT(raid_io->iovcnt == 1); 2217 CU_ASSERT(raid_io->iovs[0].iov_base == iovs_orig->iov_base); 2218 CU_ASSERT(raid_io->iovs[0].iov_len == iovs_orig->iov_len); 2219 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2220 2221 CU_ASSERT(g_io_comp_status == g_child_io_status_flag); 2222 CU_ASSERT(g_io_output_index == 2); 2223 CU_ASSERT(g_io_output[0].offset_blocks == split_offset); 2224 CU_ASSERT(g_io_output[0].num_blocks == g_strip_size - split_offset); 2225 CU_ASSERT(g_io_output[1].offset_blocks == 0); 2226 CU_ASSERT(g_io_output[1].num_blocks == split_offset); 2227 bdev_io_cleanup(bdev_io); 2228 2229 /* test split of bdev_io with 4 iovecs */ 2230 bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct raid_bdev_io)); 2231 SPDK_CU_ASSERT_FATAL(bdev_io != NULL); 2232 raid_io = (struct raid_bdev_io *)bdev_io->driver_ctx; 2233 _bdev_io_initialize(bdev_io, ch, &pbdev->bdev, 0, g_strip_size, SPDK_BDEV_IO_TYPE_WRITE, 2234 4, g_strip_size / 4 * g_block_len); 2235 memcpy(iovs_orig, bdev_io->u.bdev.iovs, sizeof(*iovs_orig) * bdev_io->u.bdev.iovcnt); 2236 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 2237 bdev_io->u.bdev.md_buf = (void *)0x1000000; 2238 g_io_output_index = 0; 2239 2240 split_offset = 1; /* split at the first iovec */ 2241 raid_ch->process.offset = split_offset; 2242 raid_bdev_submit_request(ch, bdev_io); 2243 CU_ASSERT(raid_io->num_blocks == g_strip_size - split_offset); 2244 CU_ASSERT(raid_io->offset_blocks == split_offset); 2245 CU_ASSERT(raid_io->iovcnt == 4); 2246 CU_ASSERT(raid_io->split.iov == &bdev_io->u.bdev.iovs[0]); 2247 CU_ASSERT(raid_io->iovs == &bdev_io->u.bdev.iovs[0]); 2248 CU_ASSERT(raid_io->iovs[0].iov_base == iovs_orig[0].iov_base + g_block_len); 2249 CU_ASSERT(raid_io->iovs[0].iov_len == iovs_orig[0].iov_len - g_block_len); 2250 CU_ASSERT(memcmp(raid_io->iovs + 1, iovs_orig + 1, sizeof(*iovs_orig) * 3) == 0); 2251 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf + split_offset * pbdev->bdev.md_len); 2252 complete_deferred_ios(); 2253 CU_ASSERT(raid_io->num_blocks == split_offset); 2254 CU_ASSERT(raid_io->offset_blocks == 0); 2255 CU_ASSERT(raid_io->iovcnt == 1); 2256 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2257 CU_ASSERT(raid_io->iovs[0].iov_base == iovs_orig[0].iov_base); 2258 CU_ASSERT(raid_io->iovs[0].iov_len == g_block_len); 2259 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2260 complete_deferred_ios(); 2261 CU_ASSERT(raid_io->num_blocks == g_strip_size); 2262 CU_ASSERT(raid_io->offset_blocks == 0); 2263 CU_ASSERT(raid_io->iovcnt == 4); 2264 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2265 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig, sizeof(*iovs_orig) * raid_io->iovcnt) == 0); 2266 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2267 2268 CU_ASSERT(g_io_comp_status == g_child_io_status_flag); 2269 CU_ASSERT(g_io_output_index == 2); 2270 CU_ASSERT(g_io_output[0].offset_blocks == split_offset); 2271 CU_ASSERT(g_io_output[0].num_blocks == g_strip_size - split_offset); 2272 CU_ASSERT(g_io_output[1].offset_blocks == 0); 2273 CU_ASSERT(g_io_output[1].num_blocks == split_offset); 2274 2275 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 2276 g_io_output_index = 0; 2277 2278 split_offset = g_strip_size / 2; /* split exactly between second and third iovec */ 2279 raid_ch->process.offset = split_offset; 2280 raid_bdev_submit_request(ch, bdev_io); 2281 CU_ASSERT(raid_io->num_blocks == g_strip_size - split_offset); 2282 CU_ASSERT(raid_io->offset_blocks == split_offset); 2283 CU_ASSERT(raid_io->iovcnt == 2); 2284 CU_ASSERT(raid_io->split.iov == NULL); 2285 CU_ASSERT(raid_io->iovs == &bdev_io->u.bdev.iovs[2]); 2286 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig + 2, sizeof(*iovs_orig) * raid_io->iovcnt) == 0); 2287 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf + split_offset * pbdev->bdev.md_len); 2288 complete_deferred_ios(); 2289 CU_ASSERT(raid_io->num_blocks == split_offset); 2290 CU_ASSERT(raid_io->offset_blocks == 0); 2291 CU_ASSERT(raid_io->iovcnt == 2); 2292 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2293 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig, sizeof(*iovs_orig) * raid_io->iovcnt) == 0); 2294 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2295 complete_deferred_ios(); 2296 CU_ASSERT(raid_io->num_blocks == g_strip_size); 2297 CU_ASSERT(raid_io->offset_blocks == 0); 2298 CU_ASSERT(raid_io->iovcnt == 4); 2299 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2300 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig, sizeof(*iovs_orig) * raid_io->iovcnt) == 0); 2301 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2302 2303 CU_ASSERT(g_io_comp_status == g_child_io_status_flag); 2304 CU_ASSERT(g_io_output_index == 2); 2305 CU_ASSERT(g_io_output[0].offset_blocks == split_offset); 2306 CU_ASSERT(g_io_output[0].num_blocks == g_strip_size - split_offset); 2307 CU_ASSERT(g_io_output[1].offset_blocks == 0); 2308 CU_ASSERT(g_io_output[1].num_blocks == split_offset); 2309 2310 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 2311 g_io_output_index = 0; 2312 2313 split_offset = g_strip_size / 2 + 1; /* split at the third iovec */ 2314 raid_ch->process.offset = split_offset; 2315 raid_bdev_submit_request(ch, bdev_io); 2316 CU_ASSERT(raid_io->num_blocks == g_strip_size - split_offset); 2317 CU_ASSERT(raid_io->offset_blocks == split_offset); 2318 CU_ASSERT(raid_io->iovcnt == 2); 2319 CU_ASSERT(raid_io->split.iov == &bdev_io->u.bdev.iovs[2]); 2320 CU_ASSERT(raid_io->iovs == &bdev_io->u.bdev.iovs[2]); 2321 CU_ASSERT(raid_io->iovs[0].iov_base == iovs_orig[2].iov_base + g_block_len); 2322 CU_ASSERT(raid_io->iovs[0].iov_len == iovs_orig[2].iov_len - g_block_len); 2323 CU_ASSERT(raid_io->iovs[1].iov_base == iovs_orig[3].iov_base); 2324 CU_ASSERT(raid_io->iovs[1].iov_len == iovs_orig[3].iov_len); 2325 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf + split_offset * pbdev->bdev.md_len); 2326 complete_deferred_ios(); 2327 CU_ASSERT(raid_io->num_blocks == split_offset); 2328 CU_ASSERT(raid_io->offset_blocks == 0); 2329 CU_ASSERT(raid_io->iovcnt == 3); 2330 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2331 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig, sizeof(*iovs_orig) * 2) == 0); 2332 CU_ASSERT(raid_io->iovs[2].iov_base == iovs_orig[2].iov_base); 2333 CU_ASSERT(raid_io->iovs[2].iov_len == g_block_len); 2334 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2335 complete_deferred_ios(); 2336 CU_ASSERT(raid_io->num_blocks == g_strip_size); 2337 CU_ASSERT(raid_io->offset_blocks == 0); 2338 CU_ASSERT(raid_io->iovcnt == 4); 2339 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2340 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig, sizeof(*iovs_orig) * raid_io->iovcnt) == 0); 2341 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2342 2343 CU_ASSERT(g_io_comp_status == g_child_io_status_flag); 2344 CU_ASSERT(g_io_output_index == 2); 2345 CU_ASSERT(g_io_output[0].offset_blocks == split_offset); 2346 CU_ASSERT(g_io_output[0].num_blocks == g_strip_size - split_offset); 2347 CU_ASSERT(g_io_output[1].offset_blocks == 0); 2348 CU_ASSERT(g_io_output[1].num_blocks == split_offset); 2349 2350 memset(g_io_output, 0, ((g_max_io_size / g_strip_size) + 1) * sizeof(struct io_output)); 2351 g_io_output_index = 0; 2352 2353 split_offset = g_strip_size - 1; /* split at the last iovec */ 2354 raid_ch->process.offset = split_offset; 2355 raid_bdev_submit_request(ch, bdev_io); 2356 CU_ASSERT(raid_io->num_blocks == g_strip_size - split_offset); 2357 CU_ASSERT(raid_io->offset_blocks == split_offset); 2358 CU_ASSERT(raid_io->iovcnt == 1); 2359 CU_ASSERT(raid_io->split.iov == &bdev_io->u.bdev.iovs[3]); 2360 CU_ASSERT(raid_io->iovs == &bdev_io->u.bdev.iovs[3]); 2361 CU_ASSERT(raid_io->iovs[0].iov_base == iovs_orig[3].iov_base + iovs_orig[3].iov_len - g_block_len); 2362 CU_ASSERT(raid_io->iovs[0].iov_len == g_block_len); 2363 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf + split_offset * pbdev->bdev.md_len); 2364 complete_deferred_ios(); 2365 CU_ASSERT(raid_io->num_blocks == split_offset); 2366 CU_ASSERT(raid_io->offset_blocks == 0); 2367 CU_ASSERT(raid_io->iovcnt == 4); 2368 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2369 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig, sizeof(*iovs_orig) * 3) == 0); 2370 CU_ASSERT(raid_io->iovs[3].iov_base == iovs_orig[3].iov_base); 2371 CU_ASSERT(raid_io->iovs[3].iov_len == iovs_orig[3].iov_len - g_block_len); 2372 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2373 complete_deferred_ios(); 2374 CU_ASSERT(raid_io->num_blocks == g_strip_size); 2375 CU_ASSERT(raid_io->offset_blocks == 0); 2376 CU_ASSERT(raid_io->iovcnt == 4); 2377 CU_ASSERT(raid_io->iovs == bdev_io->u.bdev.iovs); 2378 CU_ASSERT(memcmp(raid_io->iovs, iovs_orig, sizeof(*iovs_orig) * raid_io->iovcnt) == 0); 2379 CU_ASSERT(raid_io->md_buf == bdev_io->u.bdev.md_buf); 2380 2381 CU_ASSERT(g_io_comp_status == g_child_io_status_flag); 2382 CU_ASSERT(g_io_output_index == 2); 2383 CU_ASSERT(g_io_output[0].offset_blocks == split_offset); 2384 CU_ASSERT(g_io_output[0].num_blocks == g_strip_size - split_offset); 2385 CU_ASSERT(g_io_output[1].offset_blocks == 0); 2386 CU_ASSERT(g_io_output[1].num_blocks == split_offset); 2387 bdev_io_cleanup(bdev_io); 2388 2389 spdk_put_io_channel(ch); 2390 free_test_req(&req); 2391 pbdev->process = NULL; 2392 2393 create_raid_bdev_delete_req(&destroy_req, "raid1", 0); 2394 rpc_bdev_raid_delete(NULL, NULL); 2395 CU_ASSERT(g_rpc_err == 0); 2396 verify_raid_bdev_present("raid1", false); 2397 2398 raid_bdev_exit(); 2399 base_bdevs_cleanup(); 2400 reset_globals(); 2401 } 2402 2403 static int 2404 test_bdev_ioch_create(void *io_device, void *ctx_buf) 2405 { 2406 return 0; 2407 } 2408 2409 static void 2410 test_bdev_ioch_destroy(void *io_device, void *ctx_buf) 2411 { 2412 } 2413 2414 int 2415 main(int argc, char **argv) 2416 { 2417 CU_pSuite suite = NULL; 2418 unsigned int num_failures; 2419 2420 CU_initialize_registry(); 2421 2422 suite = CU_add_suite("raid", NULL, NULL); 2423 2424 CU_ADD_TEST(suite, test_create_raid); 2425 CU_ADD_TEST(suite, test_create_raid_superblock); 2426 CU_ADD_TEST(suite, test_delete_raid); 2427 CU_ADD_TEST(suite, test_create_raid_invalid_args); 2428 CU_ADD_TEST(suite, test_delete_raid_invalid_args); 2429 CU_ADD_TEST(suite, test_io_channel); 2430 CU_ADD_TEST(suite, test_reset_io); 2431 CU_ADD_TEST(suite, test_write_io); 2432 CU_ADD_TEST(suite, test_read_io); 2433 CU_ADD_TEST(suite, test_unmap_io); 2434 CU_ADD_TEST(suite, test_io_failure); 2435 CU_ADD_TEST(suite, test_multi_raid_no_io); 2436 CU_ADD_TEST(suite, test_multi_raid_with_io); 2437 CU_ADD_TEST(suite, test_io_type_supported); 2438 CU_ADD_TEST(suite, test_raid_json_dump_info); 2439 CU_ADD_TEST(suite, test_context_size); 2440 CU_ADD_TEST(suite, test_raid_level_conversions); 2441 CU_ADD_TEST(suite, test_raid_process); 2442 CU_ADD_TEST(suite, test_raid_io_split); 2443 2444 allocate_threads(1); 2445 set_thread(0); 2446 spdk_io_device_register(&g_bdev_ch_io_device, test_bdev_ioch_create, test_bdev_ioch_destroy, 0, 2447 NULL); 2448 2449 set_test_opts(); 2450 num_failures = spdk_ut_run_tests(argc, argv, NULL); 2451 CU_cleanup_registry(); 2452 2453 spdk_io_device_unregister(&g_bdev_ch_io_device, NULL); 2454 free_threads(); 2455 2456 return num_failures; 2457 } 2458