1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2017 Intel Corporation. 3 * All rights reserved. 4 * Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk_internal/cunit.h" 8 #include "spdk/string.h" 9 10 #include "common/lib/ut_multithread.c" 11 #include "bdev/lvol/vbdev_lvol.c" 12 13 #include "unit/lib/json_mock.c" 14 15 #define SPDK_BS_PAGE_SIZE 0x1000 16 17 int g_lvolerrno; 18 int g_lvserrno; 19 int g_cluster_size; 20 int g_registered_bdevs; 21 int g_num_lvols = 0; 22 int g_lvol_open_enomem = -1; 23 struct spdk_lvol_store *g_lvs = NULL; 24 struct spdk_lvol *g_lvol = NULL; 25 struct lvol_store_bdev *g_lvs_bdev = NULL; 26 struct spdk_bdev *g_base_bdev = NULL; 27 struct spdk_bdev_io *g_io = NULL; 28 struct spdk_io_channel *g_ch = NULL; 29 30 static struct spdk_bdev g_bdev = {}; 31 static struct spdk_lvol_store *g_lvol_store = NULL; 32 bool lvol_store_initialize_fail = false; 33 bool lvol_store_initialize_cb_fail = false; 34 bool lvol_already_opened = false; 35 bool g_examine_done = false; 36 bool g_bdev_alias_already_exists = false; 37 bool g_lvs_with_name_already_exists = false; 38 bool g_ext_api_called; 39 bool g_bdev_is_missing = false; 40 41 DEFINE_STUB_V(spdk_bdev_module_fini_start_done, (void)); 42 DEFINE_STUB(spdk_bdev_get_memory_domains, int, (struct spdk_bdev *bdev, 43 struct spdk_memory_domain **domains, int array_size), 0); 44 DEFINE_STUB(spdk_blob_get_esnap_id, int, 45 (struct spdk_blob *blob, const void **id, size_t *len), -ENOTSUP); 46 DEFINE_STUB(spdk_blob_is_esnap_clone, bool, (const struct spdk_blob *blob), false); 47 DEFINE_STUB(spdk_lvol_iter_immediate_clones, int, 48 (struct spdk_lvol *lvol, spdk_lvol_iter_cb cb_fn, void *cb_arg), -ENOTSUP); 49 DEFINE_STUB(spdk_lvs_esnap_missing_add, int, 50 (struct spdk_lvol_store *lvs, struct spdk_lvol *lvol, const void *esnap_id, 51 uint32_t id_len), -ENOTSUP); 52 DEFINE_STUB(spdk_blob_get_esnap_bs_dev, struct spdk_bs_dev *, (const struct spdk_blob *blob), NULL); 53 DEFINE_STUB(spdk_lvol_is_degraded, bool, (const struct spdk_lvol *lvol), false); 54 55 struct spdk_blob { 56 uint64_t id; 57 char name[32]; 58 }; 59 60 struct spdk_blob_store { 61 spdk_bs_esnap_dev_create esnap_bs_dev_create; 62 }; 63 64 const struct spdk_bdev_aliases_list * 65 spdk_bdev_get_aliases(const struct spdk_bdev *bdev) 66 { 67 return &bdev->aliases; 68 } 69 70 uint32_t 71 spdk_bdev_get_md_size(const struct spdk_bdev *bdev) 72 { 73 return bdev->md_len; 74 } 75 76 const struct spdk_uuid * 77 spdk_bdev_get_uuid(const struct spdk_bdev *bdev) 78 { 79 return &bdev->uuid; 80 } 81 82 int 83 spdk_bdev_alias_add(struct spdk_bdev *bdev, const char *alias) 84 { 85 struct spdk_bdev_alias *tmp; 86 87 CU_ASSERT(alias != NULL); 88 CU_ASSERT(bdev != NULL); 89 if (g_bdev_alias_already_exists) { 90 return -EEXIST; 91 } 92 93 tmp = calloc(1, sizeof(*tmp)); 94 SPDK_CU_ASSERT_FATAL(tmp != NULL); 95 96 tmp->alias.name = strdup(alias); 97 SPDK_CU_ASSERT_FATAL(tmp->alias.name != NULL); 98 99 TAILQ_INSERT_TAIL(&bdev->aliases, tmp, tailq); 100 101 return 0; 102 } 103 104 int 105 spdk_bdev_alias_del(struct spdk_bdev *bdev, const char *alias) 106 { 107 struct spdk_bdev_alias *tmp; 108 109 CU_ASSERT(bdev != NULL); 110 111 TAILQ_FOREACH(tmp, &bdev->aliases, tailq) { 112 SPDK_CU_ASSERT_FATAL(alias != NULL); 113 if (strncmp(alias, tmp->alias.name, SPDK_LVOL_NAME_MAX) == 0) { 114 TAILQ_REMOVE(&bdev->aliases, tmp, tailq); 115 free(tmp->alias.name); 116 free(tmp); 117 return 0; 118 } 119 } 120 121 return -ENOENT; 122 } 123 124 void 125 spdk_bdev_alias_del_all(struct spdk_bdev *bdev) 126 { 127 struct spdk_bdev_alias *p, *tmp; 128 129 TAILQ_FOREACH_SAFE(p, &bdev->aliases, tailq, tmp) { 130 TAILQ_REMOVE(&bdev->aliases, p, tailq); 131 free(p->alias.name); 132 free(p); 133 } 134 } 135 136 void 137 spdk_bdev_destruct_done(struct spdk_bdev *bdev, int bdeverrno) 138 { 139 CU_ASSERT(bdeverrno == 0); 140 SPDK_CU_ASSERT_FATAL(bdev->internal.unregister_cb != NULL); 141 bdev->internal.unregister_cb(bdev->internal.unregister_ctx, bdeverrno); 142 } 143 144 struct ut_bs_dev { 145 struct spdk_bs_dev bs_dev; 146 struct spdk_bdev *bdev; 147 }; 148 149 static void 150 ut_bs_dev_destroy(struct spdk_bs_dev *bs_dev) 151 { 152 struct ut_bs_dev *ut_bs_dev = SPDK_CONTAINEROF(bs_dev, struct ut_bs_dev, bs_dev); 153 154 free(ut_bs_dev); 155 } 156 157 int 158 spdk_bdev_create_bs_dev(const char *bdev_name, bool write, 159 struct spdk_bdev_bs_dev_opts *opts, size_t opts_size, 160 spdk_bdev_event_cb_t event_cb, void *event_ctx, 161 struct spdk_bs_dev **bs_dev) 162 { 163 struct spdk_bdev *bdev; 164 struct ut_bs_dev *ut_bs_dev; 165 166 bdev = spdk_bdev_get_by_name(bdev_name); 167 if (bdev == NULL) { 168 return -ENODEV; 169 } 170 171 ut_bs_dev = calloc(1, sizeof(*ut_bs_dev)); 172 SPDK_CU_ASSERT_FATAL(ut_bs_dev != NULL); 173 ut_bs_dev->bs_dev.destroy = ut_bs_dev_destroy; 174 ut_bs_dev->bdev = bdev; 175 *bs_dev = &ut_bs_dev->bs_dev; 176 177 return 0; 178 } 179 180 void 181 spdk_lvs_grow(struct spdk_bs_dev *bs_dev, spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 182 { 183 cb_fn(cb_arg, NULL, -EINVAL); 184 } 185 186 void 187 spdk_lvs_rename(struct spdk_lvol_store *lvs, const char *new_name, 188 spdk_lvs_op_complete cb_fn, void *cb_arg) 189 { 190 if (g_lvs_with_name_already_exists) { 191 g_lvolerrno = -EEXIST; 192 } else { 193 snprintf(lvs->name, sizeof(lvs->name), "%s", new_name); 194 g_lvolerrno = 0; 195 } 196 197 cb_fn(cb_arg, g_lvolerrno); 198 } 199 200 void 201 spdk_lvol_rename(struct spdk_lvol *lvol, const char *new_name, 202 spdk_lvol_op_complete cb_fn, void *cb_arg) 203 { 204 struct spdk_lvol *tmp; 205 206 if (strncmp(lvol->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 207 cb_fn(cb_arg, 0); 208 return; 209 } 210 211 TAILQ_FOREACH(tmp, &lvol->lvol_store->lvols, link) { 212 if (strncmp(tmp->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 213 SPDK_ERRLOG("Lvol %s already exists in lvol store %s\n", new_name, lvol->lvol_store->name); 214 cb_fn(cb_arg, -EEXIST); 215 return; 216 } 217 } 218 219 snprintf(lvol->name, sizeof(lvol->name), "%s", new_name); 220 221 cb_fn(cb_arg, g_lvolerrno); 222 } 223 224 void 225 spdk_lvol_open(struct spdk_lvol *lvol, spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 226 { 227 int lvolerrno; 228 229 if (g_lvol_open_enomem == lvol->lvol_store->lvols_opened) { 230 lvolerrno = -ENOMEM; 231 g_lvol_open_enomem = -1; 232 } else { 233 lvolerrno = g_lvolerrno; 234 } 235 236 cb_fn(cb_arg, lvol, lvolerrno); 237 } 238 239 uint64_t 240 spdk_blob_get_num_clusters(struct spdk_blob *b) 241 { 242 return 0; 243 } 244 245 /* Simulation of a blob with: 246 * - 1 io_unit per cluster 247 * - 20 data cluster 248 * - only last cluster allocated 249 */ 250 uint64_t g_blob_allocated_io_unit_offset = 20; 251 252 uint64_t 253 spdk_blob_get_next_allocated_io_unit(struct spdk_blob *blob, uint64_t offset) 254 { 255 if (offset <= g_blob_allocated_io_unit_offset) { 256 return g_blob_allocated_io_unit_offset; 257 } else { 258 return UINT64_MAX; 259 } 260 } 261 262 uint64_t 263 spdk_blob_get_next_unallocated_io_unit(struct spdk_blob *blob, uint64_t offset) 264 { 265 if (offset < g_blob_allocated_io_unit_offset) { 266 return offset; 267 } else { 268 return UINT64_MAX; 269 } 270 } 271 272 int 273 spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_id *ids, 274 size_t *count) 275 { 276 *count = 0; 277 return 0; 278 } 279 280 spdk_blob_id 281 spdk_blob_get_parent_snapshot(struct spdk_blob_store *bs, spdk_blob_id blobid) 282 { 283 return 0; 284 } 285 286 bool g_blob_is_read_only = false; 287 288 bool 289 spdk_blob_is_read_only(struct spdk_blob *blob) 290 { 291 return g_blob_is_read_only; 292 } 293 294 bool 295 spdk_blob_is_snapshot(struct spdk_blob *blob) 296 { 297 return false; 298 } 299 300 bool 301 spdk_blob_is_clone(struct spdk_blob *blob) 302 { 303 return false; 304 } 305 306 bool 307 spdk_blob_is_thin_provisioned(struct spdk_blob *blob) 308 { 309 return false; 310 } 311 312 static struct spdk_lvol *_lvol_create(struct spdk_lvol_store *lvs); 313 314 int 315 spdk_lvol_create_esnap_clone(const void *esnap_id, uint32_t id_len, uint64_t size_bytes, 316 struct spdk_lvol_store *lvs, const char *clone_name, 317 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 318 { 319 struct spdk_lvol *lvol; 320 321 lvol = _lvol_create(lvs); 322 snprintf(lvol->name, sizeof(lvol->name), "%s", clone_name); 323 324 cb_fn(cb_arg, lvol, 0); 325 return 0; 326 } 327 328 static void 329 lvs_load(struct spdk_bs_dev *dev, const struct spdk_lvs_opts *lvs_opts, 330 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 331 { 332 struct spdk_lvol_store *lvs = NULL; 333 int i; 334 int lvserrno = g_lvserrno; 335 336 if (lvserrno != 0) { 337 /* On error blobstore destroys bs_dev itself, 338 * by puttin back io channels. 339 * This operation is asynchronous, and completed 340 * after calling the callback for lvol. */ 341 cb_fn(cb_arg, g_lvol_store, lvserrno); 342 dev->destroy(dev); 343 return; 344 } 345 346 lvs = calloc(1, sizeof(*lvs)); 347 SPDK_CU_ASSERT_FATAL(lvs != NULL); 348 lvs->blobstore = calloc(1, sizeof(*lvs->blobstore)); 349 lvs->blobstore->esnap_bs_dev_create = lvs_opts->esnap_bs_dev_create; 350 SPDK_CU_ASSERT_FATAL(lvs->blobstore != NULL); 351 TAILQ_INIT(&lvs->lvols); 352 TAILQ_INIT(&lvs->pending_lvols); 353 TAILQ_INIT(&lvs->retry_open_lvols); 354 spdk_uuid_generate(&lvs->uuid); 355 lvs->bs_dev = dev; 356 for (i = 0; i < g_num_lvols; i++) { 357 _lvol_create(lvs); 358 lvs->lvol_count++; 359 } 360 361 cb_fn(cb_arg, lvs, lvserrno); 362 } 363 364 void 365 spdk_lvs_load(struct spdk_bs_dev *dev, 366 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 367 { 368 lvs_load(dev, NULL, cb_fn, cb_arg); 369 } 370 371 void 372 spdk_lvs_load_ext(struct spdk_bs_dev *bs_dev, const struct spdk_lvs_opts *lvs_opts, 373 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 374 { 375 lvs_load(bs_dev, lvs_opts, cb_fn, cb_arg); 376 } 377 378 int 379 spdk_bs_bdev_claim(struct spdk_bs_dev *bs_dev, struct spdk_bdev_module *module) 380 { 381 if (lvol_already_opened == true) { 382 return -EPERM; 383 } 384 385 lvol_already_opened = true; 386 387 return 0; 388 } 389 390 static void 391 _spdk_bdev_unregister_cb(void *cb_arg, int rc) 392 { 393 CU_ASSERT(rc == 0); 394 } 395 396 void 397 spdk_bdev_unregister(struct spdk_bdev *vbdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg) 398 { 399 int rc; 400 401 SPDK_CU_ASSERT_FATAL(vbdev != NULL); 402 vbdev->internal.unregister_cb = cb_fn; 403 vbdev->internal.unregister_ctx = cb_arg; 404 405 rc = vbdev->fn_table->destruct(vbdev->ctxt); 406 CU_ASSERT(rc == 1); 407 } 408 409 uint64_t 410 spdk_bs_get_page_size(struct spdk_blob_store *bs) 411 { 412 return SPDK_BS_PAGE_SIZE; 413 } 414 415 uint64_t 416 spdk_bs_get_io_unit_size(struct spdk_blob_store *bs) 417 { 418 return SPDK_BS_PAGE_SIZE; 419 } 420 421 static void 422 bdev_blob_destroy(struct spdk_bs_dev *bs_dev) 423 { 424 CU_ASSERT(bs_dev != NULL); 425 free(bs_dev); 426 lvol_already_opened = false; 427 } 428 429 static struct spdk_bdev * 430 bdev_blob_get_base_bdev(struct spdk_bs_dev *bs_dev) 431 { 432 CU_ASSERT(bs_dev != NULL); 433 return &g_bdev; 434 } 435 436 int 437 spdk_bdev_create_bs_dev_ext(const char *bdev_name, spdk_bdev_event_cb_t event_cb, 438 void *event_ctx, struct spdk_bs_dev **_bs_dev) 439 { 440 struct spdk_bs_dev *bs_dev; 441 442 if (lvol_already_opened == true) { 443 return -EINVAL; 444 } 445 446 bs_dev = calloc(1, sizeof(*bs_dev)); 447 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 448 bs_dev->blocklen = 4096; 449 bs_dev->blockcnt = 128; 450 bs_dev->destroy = bdev_blob_destroy; 451 bs_dev->get_base_bdev = bdev_blob_get_base_bdev; 452 453 *_bs_dev = bs_dev; 454 455 return 0; 456 } 457 458 void 459 spdk_lvs_opts_init(struct spdk_lvs_opts *opts) 460 { 461 opts->cluster_sz = SPDK_LVS_OPTS_CLUSTER_SZ; 462 opts->clear_method = LVS_CLEAR_WITH_UNMAP; 463 opts->num_md_pages_per_cluster_ratio = 100; 464 memset(opts->name, 0, sizeof(opts->name)); 465 } 466 467 int 468 spdk_lvs_init(struct spdk_bs_dev *bs_dev, struct spdk_lvs_opts *o, 469 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 470 { 471 struct spdk_lvol_store *lvs; 472 int error = 0; 473 474 if (lvol_store_initialize_fail) { 475 return -1; 476 } 477 478 if (lvol_store_initialize_cb_fail) { 479 bs_dev->destroy(bs_dev); 480 lvs = NULL; 481 error = -1; 482 } else { 483 lvs = calloc(1, sizeof(*lvs)); 484 SPDK_CU_ASSERT_FATAL(lvs != NULL); 485 TAILQ_INIT(&lvs->lvols); 486 TAILQ_INIT(&lvs->pending_lvols); 487 spdk_uuid_generate(&lvs->uuid); 488 snprintf(lvs->name, sizeof(lvs->name), "%s", o->name); 489 lvs->bs_dev = bs_dev; 490 error = 0; 491 } 492 cb_fn(cb_arg, lvs, error); 493 494 return 0; 495 } 496 497 int 498 spdk_lvs_unload(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, void *cb_arg) 499 { 500 struct spdk_lvol *lvol, *tmp; 501 502 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 503 TAILQ_REMOVE(&lvs->lvols, lvol, link); 504 free(lvol); 505 } 506 g_lvol_store = NULL; 507 508 lvs->bs_dev->destroy(lvs->bs_dev); 509 free(lvs->blobstore); 510 free(lvs); 511 512 if (cb_fn != NULL) { 513 cb_fn(cb_arg, 0); 514 } 515 516 return 0; 517 } 518 519 int 520 spdk_lvs_destroy(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, 521 void *cb_arg) 522 { 523 struct spdk_lvol *lvol, *tmp; 524 char *alias; 525 526 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 527 TAILQ_REMOVE(&lvs->lvols, lvol, link); 528 529 alias = spdk_sprintf_alloc("%s/%s", lvs->name, lvol->name); 530 if (alias == NULL) { 531 SPDK_ERRLOG("Cannot alloc memory for alias\n"); 532 return -1; 533 } 534 spdk_bdev_alias_del(lvol->bdev, alias); 535 536 free(alias); 537 free(lvol); 538 } 539 g_lvol_store = NULL; 540 541 lvs->bs_dev->destroy(lvs->bs_dev); 542 free(lvs->blobstore); 543 free(lvs); 544 545 if (cb_fn != NULL) { 546 cb_fn(cb_arg, 0); 547 } 548 549 return 0; 550 } 551 552 void 553 spdk_lvol_resize(struct spdk_lvol *lvol, size_t sz, spdk_lvol_op_complete cb_fn, void *cb_arg) 554 { 555 cb_fn(cb_arg, 0); 556 } 557 558 void 559 spdk_lvol_set_read_only(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 560 { 561 cb_fn(cb_arg, 0); 562 } 563 564 int 565 spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size) 566 { 567 bdev->blockcnt = size; 568 return 0; 569 } 570 571 uint64_t 572 spdk_bs_get_cluster_size(struct spdk_blob_store *bs) 573 { 574 return g_cluster_size; 575 } 576 577 struct spdk_bdev * 578 spdk_bdev_get_by_name(const char *bdev_name) 579 { 580 struct spdk_uuid uuid; 581 int rc; 582 583 if (g_base_bdev == NULL) { 584 return NULL; 585 } 586 587 if (!strcmp(g_base_bdev->name, bdev_name)) { 588 return g_base_bdev; 589 } 590 591 rc = spdk_uuid_parse(&uuid, bdev_name); 592 if (rc == 0 && spdk_uuid_compare(&uuid, &g_base_bdev->uuid) == 0) { 593 return g_base_bdev; 594 } 595 596 return NULL; 597 } 598 599 struct spdk_bdev_desc { 600 struct spdk_bdev *bdev; 601 }; 602 603 int 604 spdk_bdev_open_ext(const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb, 605 void *event_ctx, struct spdk_bdev_desc **_desc) 606 { 607 struct spdk_bdev_desc *desc; 608 struct spdk_bdev *bdev; 609 610 bdev = spdk_bdev_get_by_name(bdev_name); 611 if (bdev == NULL) { 612 return -ENODEV; 613 } 614 615 desc = calloc(1, sizeof(*desc)); 616 if (desc == NULL) { 617 return -ENOMEM; 618 } 619 620 desc->bdev = bdev; 621 *_desc = desc; 622 return 0; 623 } 624 625 void 626 spdk_bdev_close(struct spdk_bdev_desc *desc) 627 { 628 free(desc); 629 } 630 631 struct spdk_bdev * 632 spdk_bdev_desc_get_bdev(struct spdk_bdev_desc *desc) 633 { 634 return desc->bdev; 635 } 636 637 void 638 spdk_lvol_close(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 639 { 640 lvol->ref_count--; 641 642 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 643 cb_fn(cb_arg, 0); 644 } 645 646 bool 647 spdk_lvol_deletable(struct spdk_lvol *lvol) 648 { 649 return true; 650 } 651 652 void 653 spdk_lvol_destroy(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 654 { 655 if (lvol->ref_count != 0) { 656 cb_fn(cb_arg, -ENODEV); 657 } 658 659 TAILQ_REMOVE(&lvol->lvol_store->lvols, lvol, link); 660 661 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 662 cb_fn(cb_arg, 0); 663 664 g_lvol = NULL; 665 free(lvol); 666 } 667 668 void 669 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 670 { 671 bdev_io->internal.status = status; 672 } 673 674 struct spdk_io_channel *spdk_lvol_get_io_channel(struct spdk_lvol *lvol) 675 { 676 CU_ASSERT(lvol == g_lvol); 677 return g_ch; 678 } 679 680 void 681 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 682 { 683 CU_ASSERT(cb == lvol_get_buf_cb); 684 } 685 686 void 687 spdk_blob_io_read(struct spdk_blob *blob, struct spdk_io_channel *channel, 688 void *payload, uint64_t offset, uint64_t length, 689 spdk_blob_op_complete cb_fn, void *cb_arg) 690 { 691 CU_ASSERT(blob == NULL); 692 CU_ASSERT(channel == g_ch); 693 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 694 CU_ASSERT(length == g_io->u.bdev.num_blocks); 695 cb_fn(cb_arg, 0); 696 } 697 698 void 699 spdk_blob_io_write(struct spdk_blob *blob, struct spdk_io_channel *channel, 700 void *payload, uint64_t offset, uint64_t length, 701 spdk_blob_op_complete cb_fn, void *cb_arg) 702 { 703 CU_ASSERT(blob == NULL); 704 CU_ASSERT(channel == g_ch); 705 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 706 CU_ASSERT(length == g_io->u.bdev.num_blocks); 707 cb_fn(cb_arg, 0); 708 } 709 710 void 711 spdk_blob_io_unmap(struct spdk_blob *blob, struct spdk_io_channel *channel, 712 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 713 { 714 CU_ASSERT(blob == NULL); 715 CU_ASSERT(channel == g_ch); 716 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 717 CU_ASSERT(length == g_io->u.bdev.num_blocks); 718 cb_fn(cb_arg, 0); 719 } 720 721 void 722 spdk_blob_io_write_zeroes(struct spdk_blob *blob, struct spdk_io_channel *channel, 723 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 724 { 725 CU_ASSERT(blob == NULL); 726 CU_ASSERT(channel == g_ch); 727 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 728 CU_ASSERT(length == g_io->u.bdev.num_blocks); 729 cb_fn(cb_arg, 0); 730 } 731 732 void 733 spdk_blob_io_writev(struct spdk_blob *blob, struct spdk_io_channel *channel, 734 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 735 spdk_blob_op_complete cb_fn, void *cb_arg) 736 { 737 CU_ASSERT(blob == NULL); 738 CU_ASSERT(channel == g_ch); 739 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 740 CU_ASSERT(length == g_io->u.bdev.num_blocks); 741 cb_fn(cb_arg, 0); 742 } 743 744 void 745 spdk_blob_io_writev_ext(struct spdk_blob *blob, struct spdk_io_channel *channel, 746 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 747 spdk_blob_op_complete cb_fn, void *cb_arg, 748 struct spdk_blob_ext_io_opts *io_opts) 749 { 750 struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx; 751 752 CU_ASSERT(blob == NULL); 753 CU_ASSERT(channel == g_ch); 754 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 755 CU_ASSERT(length == g_io->u.bdev.num_blocks); 756 CU_ASSERT(io_opts == &lvol_io->ext_io_opts); 757 g_ext_api_called = true; 758 cb_fn(cb_arg, 0); 759 } 760 761 void 762 spdk_blob_io_readv(struct spdk_blob *blob, struct spdk_io_channel *channel, 763 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 764 spdk_blob_op_complete cb_fn, void *cb_arg) 765 { 766 CU_ASSERT(blob == NULL); 767 CU_ASSERT(channel == g_ch); 768 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 769 CU_ASSERT(length == g_io->u.bdev.num_blocks); 770 cb_fn(cb_arg, 0); 771 } 772 773 void 774 spdk_blob_io_readv_ext(struct spdk_blob *blob, struct spdk_io_channel *channel, 775 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 776 spdk_blob_op_complete cb_fn, void *cb_arg, 777 struct spdk_blob_ext_io_opts *io_opts) 778 { 779 struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx; 780 781 CU_ASSERT(blob == NULL); 782 CU_ASSERT(channel == g_ch); 783 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 784 CU_ASSERT(length == g_io->u.bdev.num_blocks); 785 CU_ASSERT(io_opts == &lvol_io->ext_io_opts); 786 g_ext_api_called = true; 787 cb_fn(cb_arg, 0); 788 } 789 790 void 791 spdk_bdev_module_list_add(struct spdk_bdev_module *bdev_module) 792 { 793 } 794 795 const char * 796 spdk_bdev_get_name(const struct spdk_bdev *bdev) 797 { 798 return bdev->name; 799 } 800 801 uint32_t 802 spdk_bdev_get_block_size(const struct spdk_bdev *bdev) 803 { 804 return bdev->blocklen; 805 } 806 807 uint64_t 808 spdk_bdev_get_num_blocks(const struct spdk_bdev *bdev) 809 { 810 return bdev->blockcnt; 811 } 812 813 int 814 spdk_bdev_register(struct spdk_bdev *vbdev) 815 { 816 TAILQ_INIT(&vbdev->aliases); 817 818 g_registered_bdevs++; 819 return 0; 820 } 821 822 void 823 spdk_bdev_module_examine_done(struct spdk_bdev_module *module) 824 { 825 SPDK_CU_ASSERT_FATAL(g_examine_done != true); 826 g_examine_done = true; 827 } 828 829 static struct spdk_lvol * 830 _lvol_create(struct spdk_lvol_store *lvs) 831 { 832 struct spdk_lvol *lvol = calloc(1, sizeof(*lvol)); 833 834 SPDK_CU_ASSERT_FATAL(lvol != NULL); 835 836 lvol->lvol_store = lvs; 837 lvol->ref_count++; 838 snprintf(lvol->unique_id, sizeof(lvol->unique_id), "%s", "UNIT_TEST_UUID"); 839 840 TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link); 841 842 return lvol; 843 } 844 845 int 846 spdk_lvol_create(struct spdk_lvol_store *lvs, const char *name, size_t sz, 847 bool thin_provision, enum lvol_clear_method clear_method, spdk_lvol_op_with_handle_complete cb_fn, 848 void *cb_arg) 849 { 850 struct spdk_lvol *lvol; 851 852 lvol = _lvol_create(lvs); 853 snprintf(lvol->name, sizeof(lvol->name), "%s", name); 854 cb_fn(cb_arg, lvol, 0); 855 856 return 0; 857 } 858 859 void 860 spdk_lvol_create_snapshot(struct spdk_lvol *lvol, const char *snapshot_name, 861 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 862 { 863 struct spdk_lvol *snap; 864 865 snap = _lvol_create(lvol->lvol_store); 866 snprintf(snap->name, sizeof(snap->name), "%s", snapshot_name); 867 cb_fn(cb_arg, snap, 0); 868 } 869 870 void 871 spdk_lvol_create_clone(struct spdk_lvol *lvol, const char *clone_name, 872 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 873 { 874 struct spdk_lvol *clone; 875 876 clone = _lvol_create(lvol->lvol_store); 877 snprintf(clone->name, sizeof(clone->name), "%s", clone_name); 878 cb_fn(cb_arg, clone, 0); 879 } 880 881 bool 882 spdk_lvs_notify_hotplug(const void *esnap_id, uint32_t id_len, 883 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 884 { 885 struct spdk_uuid uuid = { 0 }; 886 char uuid_str[SPDK_UUID_STRING_LEN] = "bad"; 887 888 CU_ASSERT(id_len == SPDK_UUID_STRING_LEN); 889 CU_ASSERT(spdk_uuid_parse(&uuid, esnap_id) == 0); 890 CU_ASSERT(spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &uuid) == 0); 891 CU_ASSERT(strcmp(esnap_id, uuid_str) == 0); 892 893 return g_bdev_is_missing; 894 } 895 896 static void 897 lvol_store_op_complete(void *cb_arg, int lvserrno) 898 { 899 g_lvserrno = lvserrno; 900 return; 901 } 902 903 static void 904 lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno) 905 { 906 g_lvserrno = lvserrno; 907 g_lvol_store = lvs; 908 return; 909 } 910 911 static void 912 vbdev_lvol_create_complete(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) 913 { 914 g_lvolerrno = lvolerrno; 915 g_lvol = lvol; 916 } 917 918 static void 919 vbdev_lvol_resize_complete(void *cb_arg, int lvolerrno) 920 { 921 g_lvolerrno = lvolerrno; 922 } 923 924 static void 925 vbdev_lvol_set_read_only_complete(void *cb_arg, int lvolerrno) 926 { 927 g_lvolerrno = lvolerrno; 928 } 929 930 static void 931 vbdev_lvol_rename_complete(void *cb_arg, int lvolerrno) 932 { 933 g_lvolerrno = lvolerrno; 934 } 935 936 static void 937 ut_lvs_destroy(void) 938 { 939 int rc = 0; 940 int sz = 10; 941 struct spdk_lvol_store *lvs; 942 943 /* Lvol store is successfully created */ 944 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 945 lvol_store_op_with_handle_complete, NULL); 946 CU_ASSERT(rc == 0); 947 CU_ASSERT(g_lvserrno == 0); 948 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 949 CU_ASSERT(g_lvol_store->bs_dev != NULL); 950 951 lvs = g_lvol_store; 952 g_lvol_store = NULL; 953 954 spdk_uuid_generate(&lvs->uuid); 955 956 /* Successfully create lvol, which should be unloaded with lvs later */ 957 g_lvolerrno = -1; 958 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 959 NULL); 960 CU_ASSERT(rc == 0); 961 CU_ASSERT(g_lvolerrno == 0); 962 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 963 964 /* Unload lvol store */ 965 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 966 CU_ASSERT(g_lvserrno == 0); 967 CU_ASSERT(g_lvol_store == NULL); 968 } 969 970 static void 971 ut_lvol_init(void) 972 { 973 struct spdk_lvol_store *lvs; 974 int sz = 10; 975 int rc; 976 977 /* Lvol store is successfully created */ 978 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 979 lvol_store_op_with_handle_complete, NULL); 980 CU_ASSERT(rc == 0); 981 CU_ASSERT(g_lvserrno == 0); 982 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 983 CU_ASSERT(g_lvol_store->bs_dev != NULL); 984 lvs = g_lvol_store; 985 986 /* Successful lvol create */ 987 g_lvolerrno = -1; 988 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 989 NULL); 990 SPDK_CU_ASSERT_FATAL(rc == 0); 991 CU_ASSERT(g_lvol != NULL); 992 CU_ASSERT(g_lvolerrno == 0); 993 994 /* Successful lvol destroy */ 995 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 996 CU_ASSERT(g_lvol == NULL); 997 998 /* Destroy lvol store */ 999 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1000 CU_ASSERT(g_lvserrno == 0); 1001 CU_ASSERT(g_lvol_store == NULL); 1002 } 1003 1004 static void 1005 ut_lvol_snapshot(void) 1006 { 1007 struct spdk_lvol_store *lvs; 1008 int sz = 10; 1009 int rc; 1010 struct spdk_lvol *lvol = NULL; 1011 1012 /* Lvol store is successfully created */ 1013 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1014 lvol_store_op_with_handle_complete, NULL); 1015 CU_ASSERT(rc == 0); 1016 CU_ASSERT(g_lvserrno == 0); 1017 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1018 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1019 lvs = g_lvol_store; 1020 1021 /* Successful lvol create */ 1022 g_lvolerrno = -1; 1023 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1024 NULL); 1025 SPDK_CU_ASSERT_FATAL(rc == 0); 1026 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1027 CU_ASSERT(g_lvolerrno == 0); 1028 1029 lvol = g_lvol; 1030 1031 /* Successful snap create */ 1032 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 1033 SPDK_CU_ASSERT_FATAL(rc == 0); 1034 CU_ASSERT(g_lvol != NULL); 1035 CU_ASSERT(g_lvolerrno == 0); 1036 1037 /* Successful lvol destroy */ 1038 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1039 CU_ASSERT(g_lvol == NULL); 1040 1041 /* Successful snap destroy */ 1042 g_lvol = lvol; 1043 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1044 CU_ASSERT(g_lvol == NULL); 1045 1046 /* Destroy lvol store */ 1047 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1048 CU_ASSERT(g_lvserrno == 0); 1049 CU_ASSERT(g_lvol_store == NULL); 1050 } 1051 1052 static void 1053 ut_lvol_clone(void) 1054 { 1055 struct spdk_lvol_store *lvs; 1056 int sz = 10; 1057 int rc; 1058 struct spdk_lvol *lvol = NULL; 1059 struct spdk_lvol *snap = NULL; 1060 struct spdk_lvol *clone = NULL; 1061 1062 /* Lvol store is successfully created */ 1063 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1064 lvol_store_op_with_handle_complete, NULL); 1065 CU_ASSERT(rc == 0); 1066 CU_ASSERT(g_lvserrno == 0); 1067 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1068 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1069 lvs = g_lvol_store; 1070 1071 /* Successful lvol create */ 1072 g_lvolerrno = -1; 1073 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1074 NULL); 1075 SPDK_CU_ASSERT_FATAL(rc == 0); 1076 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1077 CU_ASSERT(g_lvolerrno == 0); 1078 1079 lvol = g_lvol; 1080 1081 /* Successful snap create */ 1082 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 1083 SPDK_CU_ASSERT_FATAL(rc == 0); 1084 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1085 CU_ASSERT(g_lvolerrno == 0); 1086 1087 snap = g_lvol; 1088 1089 /* Successful clone create */ 1090 vbdev_lvol_create_clone(snap, "clone", vbdev_lvol_create_complete, NULL); 1091 1092 SPDK_CU_ASSERT_FATAL(rc == 0); 1093 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1094 CU_ASSERT(g_lvolerrno == 0); 1095 1096 clone = g_lvol; 1097 1098 /* Successful lvol destroy */ 1099 g_lvol = lvol; 1100 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1101 CU_ASSERT(g_lvol == NULL); 1102 1103 /* Successful clone destroy */ 1104 g_lvol = clone; 1105 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1106 CU_ASSERT(g_lvol == NULL); 1107 1108 /* Successful lvol destroy */ 1109 g_lvol = snap; 1110 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1111 CU_ASSERT(g_lvol == NULL); 1112 1113 /* Destroy lvol store */ 1114 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1115 CU_ASSERT(g_lvserrno == 0); 1116 CU_ASSERT(g_lvol_store == NULL); 1117 } 1118 1119 static void 1120 ut_lvol_hotremove(void) 1121 { 1122 int rc = 0; 1123 1124 lvol_store_initialize_fail = false; 1125 lvol_store_initialize_cb_fail = false; 1126 lvol_already_opened = false; 1127 1128 /* Lvol store is successfully created */ 1129 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1130 lvol_store_op_with_handle_complete, NULL); 1131 CU_ASSERT(rc == 0); 1132 CU_ASSERT(g_lvserrno == 0); 1133 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1134 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1135 1136 /* Hot remove callback with NULL - stability check */ 1137 vbdev_lvs_hotremove_cb(NULL); 1138 1139 /* Hot remove lvs on bdev removal */ 1140 vbdev_lvs_hotremove_cb(&g_bdev); 1141 1142 CU_ASSERT(g_lvol_store == NULL); 1143 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1144 1145 } 1146 1147 static void 1148 ut_lvol_examine_config(void) 1149 { 1150 /* No esnap clone needs the bdev. */ 1151 g_bdev_is_missing = false; 1152 g_examine_done = false; 1153 vbdev_lvs_examine_config(&g_bdev); 1154 CU_ASSERT(g_examine_done); 1155 1156 g_bdev_is_missing = true; 1157 g_examine_done = false; 1158 vbdev_lvs_examine_config(&g_bdev); 1159 CU_ASSERT(g_examine_done); 1160 1161 g_examine_done = false; 1162 } 1163 1164 static void 1165 ut_lvs_examine_check(bool success) 1166 { 1167 struct lvol_store_bdev *lvs_bdev; 1168 1169 /* Examine was finished regardless of result */ 1170 CU_ASSERT(g_examine_done == true); 1171 g_examine_done = false; 1172 1173 if (success) { 1174 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1175 lvs_bdev = TAILQ_FIRST(&g_spdk_lvol_pairs); 1176 SPDK_CU_ASSERT_FATAL(lvs_bdev != NULL); 1177 g_lvol_store = lvs_bdev->lvs; 1178 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1179 SPDK_CU_ASSERT_FATAL(g_lvol_store->blobstore != NULL); 1180 CU_ASSERT(g_lvol_store->blobstore->esnap_bs_dev_create != NULL); 1181 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1182 CU_ASSERT(g_lvol_store->lvols_opened == spdk_min(g_num_lvols, g_registered_bdevs)); 1183 } else { 1184 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1185 g_lvol_store = NULL; 1186 } 1187 } 1188 1189 static void 1190 ut_lvol_examine_disk(void) 1191 { 1192 /* Examine unsuccessfully - bdev already opened */ 1193 g_lvserrno = -1; 1194 lvol_already_opened = true; 1195 vbdev_lvs_examine_disk(&g_bdev); 1196 ut_lvs_examine_check(false); 1197 1198 /* Examine unsuccessfully - fail on lvol store */ 1199 g_lvserrno = -1; 1200 lvol_already_opened = false; 1201 vbdev_lvs_examine_disk(&g_bdev); 1202 ut_lvs_examine_check(false); 1203 1204 /* Examine successfully 1205 * - one lvol fails to load 1206 * - lvs is loaded with no lvols present */ 1207 g_lvserrno = 0; 1208 g_lvolerrno = -1; 1209 g_num_lvols = 1; 1210 lvol_already_opened = false; 1211 g_registered_bdevs = 0; 1212 vbdev_lvs_examine_disk(&g_bdev); 1213 ut_lvs_examine_check(true); 1214 CU_ASSERT(g_registered_bdevs == 0); 1215 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols)); 1216 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1217 CU_ASSERT(g_lvserrno == 0); 1218 CU_ASSERT(g_lvol_store == NULL); 1219 1220 /* Examine successfully */ 1221 g_lvserrno = 0; 1222 g_lvolerrno = 0; 1223 g_registered_bdevs = 0; 1224 lvol_already_opened = false; 1225 vbdev_lvs_examine_disk(&g_bdev); 1226 ut_lvs_examine_check(true); 1227 CU_ASSERT(g_registered_bdevs != 0); 1228 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1229 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1230 CU_ASSERT(g_lvserrno == 0); 1231 1232 /* Examine multiple lvols successfully */ 1233 g_num_lvols = 4; 1234 g_registered_bdevs = 0; 1235 lvol_already_opened = false; 1236 vbdev_lvs_examine_disk(&g_bdev); 1237 ut_lvs_examine_check(true); 1238 CU_ASSERT(g_registered_bdevs == g_num_lvols); 1239 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1240 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1241 CU_ASSERT(g_lvserrno == 0); 1242 1243 /* Examine multiple lvols successfully - fail one with -ENOMEM on lvol open */ 1244 g_num_lvols = 4; 1245 g_lvol_open_enomem = 2; 1246 g_registered_bdevs = 0; 1247 lvol_already_opened = false; 1248 vbdev_lvs_examine_disk(&g_bdev); 1249 ut_lvs_examine_check(true); 1250 CU_ASSERT(g_registered_bdevs == g_num_lvols); 1251 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1252 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1253 CU_ASSERT(g_lvserrno == 0); 1254 } 1255 1256 static void 1257 ut_lvol_rename(void) 1258 { 1259 struct spdk_lvol_store *lvs; 1260 struct spdk_lvol *lvol; 1261 struct spdk_lvol *lvol2; 1262 int sz = 10; 1263 int rc; 1264 1265 /* Lvol store is successfully created */ 1266 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1267 lvol_store_op_with_handle_complete, NULL); 1268 CU_ASSERT(rc == 0); 1269 CU_ASSERT(g_lvserrno == 0); 1270 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1271 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1272 lvs = g_lvol_store; 1273 1274 /* Successful lvols create */ 1275 g_lvolerrno = -1; 1276 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1277 NULL); 1278 SPDK_CU_ASSERT_FATAL(rc == 0); 1279 CU_ASSERT(g_lvol != NULL); 1280 CU_ASSERT(g_lvolerrno == 0); 1281 lvol = g_lvol; 1282 1283 g_lvolerrno = -1; 1284 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1285 NULL); 1286 SPDK_CU_ASSERT_FATAL(rc == 0); 1287 CU_ASSERT(g_lvol != NULL); 1288 CU_ASSERT(g_lvolerrno == 0); 1289 lvol2 = g_lvol; 1290 1291 /* Successful rename lvol */ 1292 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1293 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1294 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1295 1296 /* Renaming lvol with name already existing */ 1297 g_bdev_alias_already_exists = true; 1298 vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1299 g_bdev_alias_already_exists = false; 1300 SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0); 1301 CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name"); 1302 1303 /* Renaming lvol with it's own name */ 1304 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1305 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1306 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1307 1308 /* Successful lvols destroy */ 1309 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1310 CU_ASSERT(g_lvol == NULL); 1311 1312 vbdev_lvol_destroy(lvol2, lvol_store_op_complete, NULL); 1313 CU_ASSERT(g_lvol == NULL); 1314 1315 /* Destroy lvol store */ 1316 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1317 CU_ASSERT(g_lvserrno == 0); 1318 CU_ASSERT(g_lvol_store == NULL); 1319 } 1320 1321 static void 1322 ut_bdev_finish(void) 1323 { 1324 struct spdk_lvol_store *lvs; 1325 struct spdk_lvol *lvol; 1326 struct spdk_lvol *lvol2; 1327 int sz = 10; 1328 int rc; 1329 1330 /* Scenario 1 1331 * Test unload of lvs with no lvols during bdev finish. */ 1332 1333 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1334 lvol_store_op_with_handle_complete, NULL); 1335 CU_ASSERT(rc == 0); 1336 CU_ASSERT(g_lvserrno == 0); 1337 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1338 lvs = g_lvol_store; 1339 1340 /* Start bdev finish */ 1341 vbdev_lvs_fini_start(); 1342 CU_ASSERT(g_shutdown_started == true); 1343 1344 /* During shutdown, lvs with no lvols should be unloaded */ 1345 CU_ASSERT(g_lvol_store == NULL); 1346 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1347 1348 /* Revert module state back to normal */ 1349 g_shutdown_started = false; 1350 1351 /* Scenario 2 1352 * Test creating lvs with two lvols. Delete first lvol explicitly, 1353 * then start bdev finish. This should unload the remaining lvol and 1354 * lvol store. */ 1355 1356 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1357 lvol_store_op_with_handle_complete, NULL); 1358 CU_ASSERT(rc == 0); 1359 CU_ASSERT(g_lvserrno == 0); 1360 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1361 lvs = g_lvol_store; 1362 1363 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1364 vbdev_lvol_create_complete, NULL); 1365 SPDK_CU_ASSERT_FATAL(rc == 0); 1366 CU_ASSERT(g_lvol != NULL); 1367 CU_ASSERT(g_lvolerrno == 0); 1368 lvol = g_lvol; 1369 1370 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1371 vbdev_lvol_create_complete, NULL); 1372 SPDK_CU_ASSERT_FATAL(rc == 0); 1373 CU_ASSERT(g_lvol != NULL); 1374 CU_ASSERT(g_lvolerrno == 0); 1375 lvol2 = g_lvol; 1376 1377 /* Destroy explicitly first lvol */ 1378 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1379 CU_ASSERT(g_lvol == NULL); 1380 CU_ASSERT(g_lvolerrno == 0); 1381 1382 /* Start bdev finish and unregister remaining lvol */ 1383 vbdev_lvs_fini_start(); 1384 CU_ASSERT(g_shutdown_started == true); 1385 spdk_bdev_unregister(lvol2->bdev, _spdk_bdev_unregister_cb, NULL); 1386 1387 /* During shutdown, removal of last lvol should unload lvs */ 1388 CU_ASSERT(g_lvol_store == NULL); 1389 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1390 1391 /* Revert module state back to normal */ 1392 g_shutdown_started = false; 1393 } 1394 1395 static void 1396 ut_lvol_resize(void) 1397 { 1398 struct spdk_lvol_store *lvs; 1399 struct spdk_lvol *lvol; 1400 int sz = 10; 1401 int rc = 0; 1402 1403 /* Lvol store is successfully created */ 1404 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1405 lvol_store_op_with_handle_complete, NULL); 1406 CU_ASSERT(rc == 0); 1407 CU_ASSERT(g_lvserrno == 0); 1408 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1409 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1410 lvs = g_lvol_store; 1411 1412 /* Successful lvol create */ 1413 g_lvolerrno = -1; 1414 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1415 NULL); 1416 CU_ASSERT(rc == 0); 1417 CU_ASSERT(g_lvolerrno == 0); 1418 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1419 lvol = g_lvol; 1420 1421 /* Successful lvol resize */ 1422 g_lvolerrno = -1; 1423 vbdev_lvol_resize(lvol, 20, vbdev_lvol_resize_complete, NULL); 1424 CU_ASSERT(g_lvolerrno == 0); 1425 CU_ASSERT(lvol->bdev->blockcnt == 20 * g_cluster_size / lvol->bdev->blocklen); 1426 1427 /* Resize with NULL lvol */ 1428 vbdev_lvol_resize(NULL, 20, vbdev_lvol_resize_complete, NULL); 1429 CU_ASSERT(g_lvolerrno != 0); 1430 1431 /* Successful lvol destroy */ 1432 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1433 CU_ASSERT(g_lvol == NULL); 1434 1435 /* Destroy lvol store */ 1436 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1437 CU_ASSERT(g_lvserrno == 0); 1438 CU_ASSERT(g_lvol_store == NULL); 1439 } 1440 1441 static void 1442 ut_lvol_set_read_only(void) 1443 { 1444 struct spdk_lvol_store *lvs; 1445 struct spdk_lvol *lvol; 1446 int sz = 10; 1447 int rc = 0; 1448 1449 /* Lvol store is successfully created */ 1450 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1451 lvol_store_op_with_handle_complete, NULL); 1452 CU_ASSERT(rc == 0); 1453 CU_ASSERT(g_lvserrno == 0); 1454 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1455 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1456 lvs = g_lvol_store; 1457 1458 /* Successful lvol create */ 1459 g_lvolerrno = -1; 1460 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1461 NULL); 1462 CU_ASSERT(rc == 0); 1463 CU_ASSERT(g_lvolerrno == 0); 1464 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1465 lvol = g_lvol; 1466 1467 /* Successful set lvol as read only */ 1468 g_lvolerrno = -1; 1469 vbdev_lvol_set_read_only(lvol, vbdev_lvol_set_read_only_complete, NULL); 1470 CU_ASSERT(g_lvolerrno == 0); 1471 1472 /* Successful lvol destroy */ 1473 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1474 CU_ASSERT(g_lvol == NULL); 1475 1476 /* Destroy lvol store */ 1477 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1478 CU_ASSERT(g_lvserrno == 0); 1479 CU_ASSERT(g_lvol_store == NULL); 1480 } 1481 1482 static void 1483 ut_lvs_unload(void) 1484 { 1485 int rc = 0; 1486 int sz = 10; 1487 struct spdk_lvol_store *lvs; 1488 1489 /* Lvol store is successfully created */ 1490 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1491 lvol_store_op_with_handle_complete, NULL); 1492 CU_ASSERT(rc == 0); 1493 CU_ASSERT(g_lvserrno == 0); 1494 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1495 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1496 1497 lvs = g_lvol_store; 1498 g_lvol_store = NULL; 1499 1500 spdk_uuid_generate(&lvs->uuid); 1501 1502 /* Successfully create lvol, which should be destroyed with lvs later */ 1503 g_lvolerrno = -1; 1504 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1505 NULL); 1506 CU_ASSERT(rc == 0); 1507 CU_ASSERT(g_lvolerrno == 0); 1508 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1509 1510 /* Unload lvol store */ 1511 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1512 CU_ASSERT(g_lvserrno == 0); 1513 CU_ASSERT(g_lvol_store == NULL); 1514 CU_ASSERT(g_lvol != NULL); 1515 } 1516 1517 static void 1518 ut_lvs_init(void) 1519 { 1520 int rc = 0; 1521 struct spdk_lvol_store *lvs; 1522 1523 /* spdk_lvs_init() fails */ 1524 lvol_store_initialize_fail = true; 1525 1526 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1527 lvol_store_op_with_handle_complete, NULL); 1528 CU_ASSERT(rc != 0); 1529 CU_ASSERT(g_lvserrno == 0); 1530 CU_ASSERT(g_lvol_store == NULL); 1531 1532 lvol_store_initialize_fail = false; 1533 1534 /* spdk_lvs_init_cb() fails */ 1535 lvol_store_initialize_cb_fail = true; 1536 1537 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1538 lvol_store_op_with_handle_complete, NULL); 1539 CU_ASSERT(rc == 0); 1540 CU_ASSERT(g_lvserrno != 0); 1541 CU_ASSERT(g_lvol_store == NULL); 1542 1543 lvol_store_initialize_cb_fail = false; 1544 1545 /* Lvol store is successfully created */ 1546 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1547 lvol_store_op_with_handle_complete, NULL); 1548 CU_ASSERT(rc == 0); 1549 CU_ASSERT(g_lvserrno == 0); 1550 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1551 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1552 1553 lvs = g_lvol_store; 1554 g_lvol_store = NULL; 1555 1556 /* Bdev with lvol store already claimed */ 1557 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1558 lvol_store_op_with_handle_complete, NULL); 1559 CU_ASSERT(rc != 0); 1560 CU_ASSERT(g_lvserrno == 0); 1561 CU_ASSERT(g_lvol_store == NULL); 1562 1563 /* Destruct lvol store */ 1564 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1565 CU_ASSERT(g_lvserrno == 0); 1566 CU_ASSERT(g_lvol_store == NULL); 1567 } 1568 1569 static void 1570 ut_vbdev_lvol_get_io_channel(void) 1571 { 1572 struct spdk_io_channel *ch; 1573 1574 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1575 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1576 1577 ch = vbdev_lvol_get_io_channel(g_lvol); 1578 CU_ASSERT(ch == g_ch); 1579 1580 free(g_lvol); 1581 } 1582 1583 static void 1584 ut_vbdev_lvol_io_type_supported(void) 1585 { 1586 struct spdk_lvol *lvol; 1587 bool ret; 1588 1589 lvol = calloc(1, sizeof(struct spdk_lvol)); 1590 SPDK_CU_ASSERT_FATAL(lvol != NULL); 1591 1592 g_blob_is_read_only = false; 1593 1594 /* Supported types */ 1595 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1596 CU_ASSERT(ret == true); 1597 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1598 CU_ASSERT(ret == true); 1599 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1600 CU_ASSERT(ret == true); 1601 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1602 CU_ASSERT(ret == true); 1603 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1604 CU_ASSERT(ret == true); 1605 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1606 CU_ASSERT(ret == true); 1607 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1608 CU_ASSERT(ret == true); 1609 1610 /* Unsupported types */ 1611 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1612 CU_ASSERT(ret == false); 1613 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1614 CU_ASSERT(ret == false); 1615 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1616 CU_ASSERT(ret == false); 1617 1618 g_blob_is_read_only = true; 1619 1620 /* Supported types */ 1621 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1622 CU_ASSERT(ret == true); 1623 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1624 CU_ASSERT(ret == true); 1625 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1626 CU_ASSERT(ret == true); 1627 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1628 CU_ASSERT(ret == true); 1629 1630 /* Unsupported types */ 1631 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1632 CU_ASSERT(ret == false); 1633 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1634 CU_ASSERT(ret == false); 1635 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1636 CU_ASSERT(ret == false); 1637 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1638 CU_ASSERT(ret == false); 1639 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1640 CU_ASSERT(ret == false); 1641 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1642 CU_ASSERT(ret == false); 1643 1644 free(lvol); 1645 } 1646 1647 static void 1648 ut_lvol_read_write(void) 1649 { 1650 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1651 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1652 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1653 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1654 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1655 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1656 1657 g_io->bdev = g_base_bdev; 1658 g_io->bdev->ctxt = g_lvol; 1659 g_io->u.bdev.offset_blocks = 20; 1660 g_io->u.bdev.num_blocks = 20; 1661 1662 lvol_read(g_ch, g_io); 1663 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1664 1665 lvol_write(g_lvol, g_ch, g_io); 1666 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1667 1668 g_ext_api_called = false; 1669 lvol_read(g_ch, g_io); 1670 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1671 CU_ASSERT(g_ext_api_called == true); 1672 g_ext_api_called = false; 1673 1674 lvol_write(g_lvol, g_ch, g_io); 1675 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1676 CU_ASSERT(g_ext_api_called == true); 1677 g_ext_api_called = false; 1678 1679 free(g_io); 1680 free(g_base_bdev); 1681 free(g_lvol); 1682 } 1683 1684 static void 1685 ut_vbdev_lvol_submit_request(void) 1686 { 1687 struct spdk_lvol request_lvol = {}; 1688 g_io = calloc(1, sizeof(struct spdk_bdev_io)); 1689 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1690 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1691 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1692 g_io->bdev = g_base_bdev; 1693 1694 g_io->type = SPDK_BDEV_IO_TYPE_READ; 1695 g_base_bdev->ctxt = &request_lvol; 1696 vbdev_lvol_submit_request(g_ch, g_io); 1697 1698 free(g_io); 1699 free(g_base_bdev); 1700 } 1701 1702 static void 1703 ut_lvs_rename(void) 1704 { 1705 int rc = 0; 1706 int sz = 10; 1707 struct spdk_lvol_store *lvs; 1708 1709 /* Lvol store is successfully created */ 1710 rc = vbdev_lvs_create("bdev", "old_lvs_name", 0, LVS_CLEAR_WITH_UNMAP, 0, 1711 lvol_store_op_with_handle_complete, NULL); 1712 CU_ASSERT(rc == 0); 1713 CU_ASSERT(g_lvserrno == 0); 1714 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1715 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1716 1717 lvs = g_lvol_store; 1718 g_lvol_store = NULL; 1719 1720 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1721 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1722 1723 /* Successfully create lvol, which should be destroyed with lvs later */ 1724 g_lvolerrno = -1; 1725 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1726 NULL); 1727 CU_ASSERT(rc == 0); 1728 CU_ASSERT(g_lvolerrno == 0); 1729 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1730 1731 /* Trying to rename lvs with lvols created */ 1732 vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL); 1733 CU_ASSERT(g_lvserrno == 0); 1734 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1735 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1736 1737 /* Trying to rename lvs with name already used by another lvs */ 1738 /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates 1739 * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */ 1740 g_lvs_with_name_already_exists = true; 1741 vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL); 1742 CU_ASSERT(g_lvserrno == -EEXIST); 1743 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1744 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1745 g_lvs_with_name_already_exists = false; 1746 1747 /* Unload lvol store */ 1748 g_lvol_store = lvs; 1749 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1750 CU_ASSERT(g_lvserrno == 0); 1751 CU_ASSERT(g_lvol_store == NULL); 1752 1753 free(g_base_bdev->name); 1754 free(g_base_bdev); 1755 } 1756 1757 static void 1758 ut_lvol_seek(void) 1759 { 1760 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1761 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1762 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1763 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1764 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1765 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1766 1767 g_io->bdev = g_base_bdev; 1768 g_io->bdev->ctxt = g_lvol; 1769 1770 /* Data found */ 1771 g_io->u.bdev.offset_blocks = 10; 1772 lvol_seek_data(g_lvol, g_io); 1773 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1774 CU_ASSERT(g_io->u.bdev.seek.offset == g_blob_allocated_io_unit_offset); 1775 1776 /* Data not found */ 1777 g_io->u.bdev.offset_blocks = 30; 1778 lvol_seek_data(g_lvol, g_io); 1779 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1780 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1781 1782 /* Hole found */ 1783 g_io->u.bdev.offset_blocks = 10; 1784 lvol_seek_hole(g_lvol, g_io); 1785 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1786 CU_ASSERT(g_io->u.bdev.seek.offset == 10); 1787 1788 /* Hole not found */ 1789 g_io->u.bdev.offset_blocks = 30; 1790 lvol_seek_hole(g_lvol, g_io); 1791 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1792 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1793 1794 free(g_io); 1795 free(g_base_bdev); 1796 free(g_lvol); 1797 } 1798 1799 static void 1800 ut_esnap_dev_create(void) 1801 { 1802 struct spdk_lvol_store lvs = { 0 }; 1803 struct spdk_lvol lvol = { 0 }; 1804 struct spdk_blob blob = { 0 }; 1805 struct spdk_bdev bdev = { 0 }; 1806 const char uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4"; 1807 char bad_uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4"; 1808 char *unterminated; 1809 size_t len; 1810 struct spdk_bs_dev *bs_dev = NULL; 1811 int rc; 1812 1813 bdev.name = "bdev0"; 1814 spdk_uuid_parse(&bdev.uuid, uuid_str); 1815 1816 /* NULL esnap_id */ 1817 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, NULL, 0, &bs_dev); 1818 CU_ASSERT(rc == -EINVAL); 1819 CU_ASSERT(bs_dev == NULL); 1820 1821 /* Unterminated UUID: asan should catch reads past end of allocated buffer. */ 1822 len = strlen(uuid_str); 1823 unterminated = calloc(1, len); 1824 SPDK_CU_ASSERT_FATAL(unterminated != NULL); 1825 memcpy(unterminated, uuid_str, len); 1826 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, unterminated, len, &bs_dev); 1827 CU_ASSERT(rc == -EINVAL); 1828 CU_ASSERT(bs_dev == NULL); 1829 1830 /* Invaid UUID but the right length is invalid */ 1831 bad_uuid_str[2] = 'z'; 1832 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, bad_uuid_str, sizeof(uuid_str), 1833 &bs_dev); 1834 CU_ASSERT(rc == -EINVAL); 1835 CU_ASSERT(bs_dev == NULL); 1836 1837 /* Bdev not found */ 1838 g_base_bdev = NULL; 1839 MOCK_SET(spdk_lvol_is_degraded, true); 1840 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1841 CU_ASSERT(rc == 0); 1842 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1843 CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy); 1844 bs_dev->destroy(bs_dev); 1845 1846 /* Cannot get a claim */ 1847 /* TODO: This suggests we need a way to wait for a claim to be available. */ 1848 g_base_bdev = &bdev; 1849 lvol_already_opened = true; 1850 MOCK_SET(spdk_lvol_is_degraded, true); 1851 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1852 CU_ASSERT(rc == 0); 1853 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1854 CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy); 1855 bs_dev->destroy(bs_dev); 1856 1857 /* Happy path */ 1858 lvol_already_opened = false; 1859 MOCK_SET(spdk_lvol_is_degraded, false); 1860 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1861 CU_ASSERT(rc == 0); 1862 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1863 CU_ASSERT(bs_dev->destroy == ut_bs_dev_destroy); 1864 bs_dev->destroy(bs_dev); 1865 1866 g_base_bdev = NULL; 1867 lvol_already_opened = false; 1868 free(unterminated); 1869 MOCK_CLEAR(spdk_lvol_is_degraded); 1870 } 1871 1872 static void 1873 ut_lvol_esnap_clone_bad_args(void) 1874 { 1875 struct spdk_bdev bdev = { 0 }; 1876 struct spdk_lvol_store *lvs; 1877 const char *esnap_uuid = "255f4236-9427-42d0-a9d1-aa17f37dd8db"; 1878 const char *esnap_name = "esnap1"; 1879 int rc; 1880 1881 /* Lvol store is successfully created */ 1882 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1883 lvol_store_op_with_handle_complete, NULL); 1884 CU_ASSERT(rc == 0); 1885 CU_ASSERT(g_lvserrno == 0); 1886 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1887 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1888 lvs = g_lvol_store; 1889 1890 rc = spdk_uuid_parse(&bdev.uuid, esnap_uuid); 1891 CU_ASSERT(rc == 0); 1892 bdev.name = strdup(esnap_name); 1893 SPDK_CU_ASSERT_FATAL(bdev.name != NULL); 1894 bdev.blocklen = 512; 1895 bdev.blockcnt = 8192; 1896 1897 g_base_bdev = &bdev; 1898 1899 /* Error when lvs is NULL */ 1900 g_lvolerrno = 0xbad; 1901 vbdev_lvol_create_bdev_clone(esnap_uuid, NULL, "clone1", vbdev_lvol_create_complete, NULL); 1902 CU_ASSERT(g_lvolerrno == -EINVAL); 1903 1904 /* Error when the bdev does not exist */ 1905 g_base_bdev = NULL; 1906 g_lvolerrno = 0xbad; 1907 vbdev_lvol_create_bdev_clone(esnap_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL); 1908 CU_ASSERT(g_lvolerrno == -ENODEV); 1909 1910 /* Success when creating by bdev UUID */ 1911 g_base_bdev = &bdev; 1912 g_lvolerrno = 0xbad; 1913 vbdev_lvol_create_bdev_clone(esnap_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL); 1914 CU_ASSERT(g_lvolerrno == 0); 1915 1916 /* Success when creating by bdev name */ 1917 g_lvolerrno = 0xbad; 1918 vbdev_lvol_create_bdev_clone(esnap_name, lvs, "clone2", vbdev_lvol_create_complete, NULL); 1919 CU_ASSERT(g_lvolerrno == 0); 1920 1921 g_lvol_store = lvs; 1922 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1923 CU_ASSERT(g_lvserrno == 0); 1924 CU_ASSERT(g_lvol_store == NULL); 1925 1926 free(bdev.name); 1927 g_base_bdev = NULL; 1928 } 1929 1930 int 1931 main(int argc, char **argv) 1932 { 1933 CU_pSuite suite = NULL; 1934 unsigned int num_failures; 1935 1936 CU_initialize_registry(); 1937 1938 suite = CU_add_suite("lvol", NULL, NULL); 1939 1940 CU_ADD_TEST(suite, ut_lvs_init); 1941 CU_ADD_TEST(suite, ut_lvol_init); 1942 CU_ADD_TEST(suite, ut_lvol_snapshot); 1943 CU_ADD_TEST(suite, ut_lvol_clone); 1944 CU_ADD_TEST(suite, ut_lvs_destroy); 1945 CU_ADD_TEST(suite, ut_lvs_unload); 1946 CU_ADD_TEST(suite, ut_lvol_resize); 1947 CU_ADD_TEST(suite, ut_lvol_set_read_only); 1948 CU_ADD_TEST(suite, ut_lvol_hotremove); 1949 CU_ADD_TEST(suite, ut_vbdev_lvol_get_io_channel); 1950 CU_ADD_TEST(suite, ut_vbdev_lvol_io_type_supported); 1951 CU_ADD_TEST(suite, ut_lvol_read_write); 1952 CU_ADD_TEST(suite, ut_vbdev_lvol_submit_request); 1953 CU_ADD_TEST(suite, ut_lvol_examine_config); 1954 CU_ADD_TEST(suite, ut_lvol_examine_disk); 1955 CU_ADD_TEST(suite, ut_lvol_rename); 1956 CU_ADD_TEST(suite, ut_bdev_finish); 1957 CU_ADD_TEST(suite, ut_lvs_rename); 1958 CU_ADD_TEST(suite, ut_lvol_seek); 1959 CU_ADD_TEST(suite, ut_esnap_dev_create); 1960 CU_ADD_TEST(suite, ut_lvol_esnap_clone_bad_args); 1961 1962 allocate_threads(1); 1963 set_thread(0); 1964 1965 num_failures = spdk_ut_run_tests(argc, argv, NULL); 1966 CU_cleanup_registry(); 1967 1968 free_threads(); 1969 1970 return num_failures; 1971 } 1972