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