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 static void 910 lvol_store_op_complete(void *cb_arg, int lvserrno) 911 { 912 g_lvserrno = lvserrno; 913 return; 914 } 915 916 static void 917 lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno) 918 { 919 g_lvserrno = lvserrno; 920 g_lvol_store = lvs; 921 return; 922 } 923 924 static void 925 vbdev_lvol_create_complete(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) 926 { 927 g_lvolerrno = lvolerrno; 928 g_lvol = lvol; 929 } 930 931 static void 932 vbdev_lvol_resize_complete(void *cb_arg, int lvolerrno) 933 { 934 g_lvolerrno = lvolerrno; 935 } 936 937 static void 938 vbdev_lvol_set_read_only_complete(void *cb_arg, int lvolerrno) 939 { 940 g_lvolerrno = lvolerrno; 941 } 942 943 static void 944 vbdev_lvol_rename_complete(void *cb_arg, int lvolerrno) 945 { 946 g_lvolerrno = lvolerrno; 947 } 948 949 static void 950 ut_lvs_destroy(void) 951 { 952 int rc = 0; 953 int sz = 10; 954 struct spdk_lvol_store *lvs; 955 956 /* Lvol store is successfully created */ 957 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 958 lvol_store_op_with_handle_complete, NULL); 959 CU_ASSERT(rc == 0); 960 CU_ASSERT(g_lvserrno == 0); 961 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 962 CU_ASSERT(g_lvol_store->bs_dev != NULL); 963 964 lvs = g_lvol_store; 965 g_lvol_store = NULL; 966 967 spdk_uuid_generate(&lvs->uuid); 968 969 /* Successfully create lvol, which should be unloaded with lvs later */ 970 g_lvolerrno = -1; 971 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 972 NULL); 973 CU_ASSERT(rc == 0); 974 CU_ASSERT(g_lvolerrno == 0); 975 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 976 977 /* Unload lvol store */ 978 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 979 CU_ASSERT(g_lvserrno == 0); 980 CU_ASSERT(g_lvol_store == NULL); 981 } 982 983 static void 984 assert_blockcnt(struct spdk_lvol *lvol, int sz) 985 { 986 CU_ASSERT(lvol->bdev->blockcnt == spdk_divide_round_up(sz, g_cluster_size) * 987 (g_cluster_size / lvol->bdev->blocklen)); 988 } 989 990 static void 991 ut_lvol_init(void) 992 { 993 struct spdk_lvol_store *lvs; 994 int sz = 10; 995 int rc; 996 997 /* Lvol store is successfully created */ 998 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 999 lvol_store_op_with_handle_complete, NULL); 1000 CU_ASSERT(rc == 0); 1001 CU_ASSERT(g_lvserrno == 0); 1002 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1003 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1004 lvs = g_lvol_store; 1005 1006 /* Successful lvol create */ 1007 g_lvolerrno = -1; 1008 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1009 NULL); 1010 SPDK_CU_ASSERT_FATAL(rc == 0); 1011 CU_ASSERT(g_lvol != NULL); 1012 CU_ASSERT(g_lvol->bdev != NULL); 1013 CU_ASSERT(g_lvolerrno == 0); 1014 assert_blockcnt(g_lvol, sz); 1015 1016 /* Successful lvol destroy */ 1017 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1018 CU_ASSERT(g_lvol == NULL); 1019 1020 /* Destroy lvol store */ 1021 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1022 CU_ASSERT(g_lvserrno == 0); 1023 CU_ASSERT(g_lvol_store == NULL); 1024 } 1025 1026 static void 1027 ut_lvol_snapshot(void) 1028 { 1029 struct spdk_lvol_store *lvs; 1030 int sz = 10; 1031 int rc; 1032 struct spdk_lvol *lvol = NULL; 1033 1034 /* Lvol store is successfully created */ 1035 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1036 lvol_store_op_with_handle_complete, NULL); 1037 CU_ASSERT(rc == 0); 1038 CU_ASSERT(g_lvserrno == 0); 1039 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1040 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1041 lvs = g_lvol_store; 1042 1043 /* Successful lvol create */ 1044 g_lvolerrno = -1; 1045 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1046 NULL); 1047 SPDK_CU_ASSERT_FATAL(rc == 0); 1048 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1049 CU_ASSERT(g_lvolerrno == 0); 1050 1051 lvol = g_lvol; 1052 1053 /* Successful snap create */ 1054 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 1055 SPDK_CU_ASSERT_FATAL(rc == 0); 1056 CU_ASSERT(g_lvol != NULL); 1057 CU_ASSERT(g_lvolerrno == 0); 1058 1059 /* Successful lvol destroy */ 1060 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1061 CU_ASSERT(g_lvol == NULL); 1062 1063 /* Successful snap destroy */ 1064 g_lvol = lvol; 1065 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1066 CU_ASSERT(g_lvol == NULL); 1067 1068 /* Destroy lvol store */ 1069 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1070 CU_ASSERT(g_lvserrno == 0); 1071 CU_ASSERT(g_lvol_store == NULL); 1072 } 1073 1074 static void 1075 ut_lvol_clone(void) 1076 { 1077 struct spdk_lvol_store *lvs; 1078 int sz = 10; 1079 int rc; 1080 struct spdk_lvol *lvol = NULL; 1081 struct spdk_lvol *snap = NULL; 1082 struct spdk_lvol *clone = NULL; 1083 1084 /* Lvol store is successfully created */ 1085 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1086 lvol_store_op_with_handle_complete, NULL); 1087 CU_ASSERT(rc == 0); 1088 CU_ASSERT(g_lvserrno == 0); 1089 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1090 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1091 lvs = g_lvol_store; 1092 1093 /* Successful lvol create */ 1094 g_lvolerrno = -1; 1095 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1096 NULL); 1097 SPDK_CU_ASSERT_FATAL(rc == 0); 1098 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1099 CU_ASSERT(g_lvolerrno == 0); 1100 1101 lvol = g_lvol; 1102 1103 /* Successful snap create */ 1104 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 1105 SPDK_CU_ASSERT_FATAL(rc == 0); 1106 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1107 CU_ASSERT(g_lvolerrno == 0); 1108 1109 snap = g_lvol; 1110 1111 /* Successful clone create */ 1112 vbdev_lvol_create_clone(snap, "clone", vbdev_lvol_create_complete, NULL); 1113 1114 SPDK_CU_ASSERT_FATAL(rc == 0); 1115 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1116 CU_ASSERT(g_lvolerrno == 0); 1117 1118 clone = g_lvol; 1119 1120 /* Successful lvol destroy */ 1121 g_lvol = lvol; 1122 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1123 CU_ASSERT(g_lvol == NULL); 1124 1125 /* Successful clone destroy */ 1126 g_lvol = clone; 1127 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1128 CU_ASSERT(g_lvol == NULL); 1129 1130 /* Successful lvol destroy */ 1131 g_lvol = snap; 1132 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1133 CU_ASSERT(g_lvol == NULL); 1134 1135 /* Destroy lvol store */ 1136 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1137 CU_ASSERT(g_lvserrno == 0); 1138 CU_ASSERT(g_lvol_store == NULL); 1139 } 1140 1141 static void 1142 ut_lvol_hotremove(void) 1143 { 1144 int rc = 0; 1145 1146 lvol_store_initialize_fail = false; 1147 lvol_store_initialize_cb_fail = false; 1148 lvol_already_opened = false; 1149 1150 /* Lvol store is successfully created */ 1151 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1152 lvol_store_op_with_handle_complete, NULL); 1153 CU_ASSERT(rc == 0); 1154 CU_ASSERT(g_lvserrno == 0); 1155 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1156 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1157 1158 /* Hot remove callback with NULL - stability check */ 1159 vbdev_lvs_hotremove_cb(NULL); 1160 1161 /* Hot remove lvs on bdev removal */ 1162 vbdev_lvs_hotremove_cb(&g_bdev); 1163 1164 CU_ASSERT(g_lvol_store == NULL); 1165 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1166 1167 } 1168 1169 static void 1170 ut_lvol_examine_config(void) 1171 { 1172 /* No esnap clone needs the bdev. */ 1173 g_bdev_is_missing = false; 1174 g_examine_done = false; 1175 vbdev_lvs_examine_config(&g_bdev); 1176 CU_ASSERT(g_examine_done); 1177 1178 g_bdev_is_missing = true; 1179 g_examine_done = false; 1180 vbdev_lvs_examine_config(&g_bdev); 1181 CU_ASSERT(g_examine_done); 1182 1183 g_examine_done = false; 1184 } 1185 1186 static void 1187 ut_lvs_examine_check(bool success) 1188 { 1189 struct lvol_store_bdev *lvs_bdev; 1190 1191 /* Examine was finished regardless of result */ 1192 CU_ASSERT(g_examine_done == true); 1193 g_examine_done = false; 1194 1195 if (success) { 1196 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1197 lvs_bdev = TAILQ_FIRST(&g_spdk_lvol_pairs); 1198 SPDK_CU_ASSERT_FATAL(lvs_bdev != NULL); 1199 g_lvol_store = lvs_bdev->lvs; 1200 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1201 SPDK_CU_ASSERT_FATAL(g_lvol_store->blobstore != NULL); 1202 CU_ASSERT(g_lvol_store->blobstore->esnap_bs_dev_create != NULL); 1203 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1204 CU_ASSERT(g_lvol_store->lvols_opened == spdk_min(g_num_lvols, g_registered_bdevs)); 1205 } else { 1206 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1207 g_lvol_store = NULL; 1208 } 1209 } 1210 1211 static void 1212 ut_lvol_examine_disk(void) 1213 { 1214 /* Examine unsuccessfully - bdev already opened */ 1215 g_lvserrno = -1; 1216 lvol_already_opened = true; 1217 vbdev_lvs_examine_disk(&g_bdev); 1218 ut_lvs_examine_check(false); 1219 1220 /* Examine unsuccessfully - fail on lvol store */ 1221 g_lvserrno = -1; 1222 lvol_already_opened = false; 1223 vbdev_lvs_examine_disk(&g_bdev); 1224 ut_lvs_examine_check(false); 1225 1226 /* Examine successfully 1227 * - one lvol fails to load 1228 * - lvs is loaded with no lvols present */ 1229 g_lvserrno = 0; 1230 g_lvolerrno = -1; 1231 g_num_lvols = 1; 1232 lvol_already_opened = false; 1233 g_registered_bdevs = 0; 1234 vbdev_lvs_examine_disk(&g_bdev); 1235 ut_lvs_examine_check(true); 1236 CU_ASSERT(g_registered_bdevs == 0); 1237 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols)); 1238 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1239 CU_ASSERT(g_lvserrno == 0); 1240 CU_ASSERT(g_lvol_store == NULL); 1241 1242 /* Examine successfully */ 1243 g_lvserrno = 0; 1244 g_lvolerrno = 0; 1245 g_registered_bdevs = 0; 1246 lvol_already_opened = false; 1247 vbdev_lvs_examine_disk(&g_bdev); 1248 ut_lvs_examine_check(true); 1249 CU_ASSERT(g_registered_bdevs != 0); 1250 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1251 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1252 CU_ASSERT(g_lvserrno == 0); 1253 1254 /* Examine multiple lvols successfully */ 1255 g_num_lvols = 4; 1256 g_registered_bdevs = 0; 1257 lvol_already_opened = false; 1258 vbdev_lvs_examine_disk(&g_bdev); 1259 ut_lvs_examine_check(true); 1260 CU_ASSERT(g_registered_bdevs == g_num_lvols); 1261 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1262 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1263 CU_ASSERT(g_lvserrno == 0); 1264 1265 /* Examine multiple lvols successfully - fail one with -ENOMEM on lvol open */ 1266 g_num_lvols = 4; 1267 g_lvol_open_enomem = 2; 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 == g_num_lvols); 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 1278 static void 1279 ut_lvol_rename(void) 1280 { 1281 struct spdk_lvol_store *lvs; 1282 struct spdk_lvol *lvol; 1283 struct spdk_lvol *lvol2; 1284 int sz = 10; 1285 int rc; 1286 1287 /* Lvol store is successfully created */ 1288 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1289 lvol_store_op_with_handle_complete, NULL); 1290 CU_ASSERT(rc == 0); 1291 CU_ASSERT(g_lvserrno == 0); 1292 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1293 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1294 lvs = g_lvol_store; 1295 1296 /* Successful lvols create */ 1297 g_lvolerrno = -1; 1298 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1299 NULL); 1300 SPDK_CU_ASSERT_FATAL(rc == 0); 1301 CU_ASSERT(g_lvol != NULL); 1302 CU_ASSERT(g_lvolerrno == 0); 1303 lvol = g_lvol; 1304 1305 g_lvolerrno = -1; 1306 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1307 NULL); 1308 SPDK_CU_ASSERT_FATAL(rc == 0); 1309 CU_ASSERT(g_lvol != NULL); 1310 CU_ASSERT(g_lvolerrno == 0); 1311 lvol2 = g_lvol; 1312 1313 /* Successful rename lvol */ 1314 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1315 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1316 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1317 1318 /* Renaming lvol with name already existing */ 1319 g_bdev_alias_already_exists = true; 1320 vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1321 g_bdev_alias_already_exists = false; 1322 SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0); 1323 CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name"); 1324 1325 /* Renaming lvol with it's own name */ 1326 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1327 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1328 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1329 1330 /* Successful lvols destroy */ 1331 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1332 CU_ASSERT(g_lvol == NULL); 1333 1334 vbdev_lvol_destroy(lvol2, lvol_store_op_complete, NULL); 1335 CU_ASSERT(g_lvol == NULL); 1336 1337 /* Destroy lvol store */ 1338 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1339 CU_ASSERT(g_lvserrno == 0); 1340 CU_ASSERT(g_lvol_store == NULL); 1341 } 1342 1343 static void 1344 ut_bdev_finish(void) 1345 { 1346 struct spdk_lvol_store *lvs; 1347 struct spdk_lvol *lvol; 1348 struct spdk_lvol *lvol2; 1349 int sz = 10; 1350 int rc; 1351 1352 /* Scenario 1 1353 * Test unload of lvs with no lvols during bdev finish. */ 1354 1355 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1356 lvol_store_op_with_handle_complete, NULL); 1357 CU_ASSERT(rc == 0); 1358 CU_ASSERT(g_lvserrno == 0); 1359 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1360 lvs = g_lvol_store; 1361 1362 /* Start bdev finish */ 1363 vbdev_lvs_fini_start(); 1364 CU_ASSERT(g_shutdown_started == true); 1365 1366 /* During shutdown, lvs with no lvols should be unloaded */ 1367 CU_ASSERT(g_lvol_store == NULL); 1368 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1369 1370 /* Revert module state back to normal */ 1371 g_shutdown_started = false; 1372 1373 /* Scenario 2 1374 * Test creating lvs with two lvols. Delete first lvol explicitly, 1375 * then start bdev finish. This should unload the remaining lvol and 1376 * lvol store. */ 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 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1386 vbdev_lvol_create_complete, NULL); 1387 SPDK_CU_ASSERT_FATAL(rc == 0); 1388 CU_ASSERT(g_lvol != NULL); 1389 CU_ASSERT(g_lvolerrno == 0); 1390 lvol = g_lvol; 1391 1392 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1393 vbdev_lvol_create_complete, NULL); 1394 SPDK_CU_ASSERT_FATAL(rc == 0); 1395 CU_ASSERT(g_lvol != NULL); 1396 CU_ASSERT(g_lvolerrno == 0); 1397 lvol2 = g_lvol; 1398 1399 /* Destroy explicitly first lvol */ 1400 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1401 CU_ASSERT(g_lvol == NULL); 1402 CU_ASSERT(g_lvolerrno == 0); 1403 1404 /* Start bdev finish and unregister remaining lvol */ 1405 vbdev_lvs_fini_start(); 1406 CU_ASSERT(g_shutdown_started == true); 1407 spdk_bdev_unregister(lvol2->bdev, _spdk_bdev_unregister_cb, NULL); 1408 1409 /* During shutdown, removal of last lvol should unload lvs */ 1410 CU_ASSERT(g_lvol_store == NULL); 1411 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1412 1413 /* Revert module state back to normal */ 1414 g_shutdown_started = false; 1415 } 1416 1417 static void 1418 ut_lvol_resize(void) 1419 { 1420 struct spdk_lvol_store *lvs; 1421 struct spdk_lvol *lvol; 1422 int sz = 10; 1423 int rc = 0; 1424 1425 /* Lvol store is successfully created */ 1426 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1427 lvol_store_op_with_handle_complete, NULL); 1428 CU_ASSERT(rc == 0); 1429 CU_ASSERT(g_lvserrno == 0); 1430 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1431 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1432 lvs = g_lvol_store; 1433 1434 /* Successful lvol create */ 1435 g_lvolerrno = -1; 1436 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1437 NULL); 1438 CU_ASSERT(rc == 0); 1439 CU_ASSERT(g_lvolerrno == 0); 1440 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1441 lvol = g_lvol; 1442 1443 /* Successful lvol resize */ 1444 g_lvolerrno = -1; 1445 sz = 20 * g_cluster_size; 1446 vbdev_lvol_resize(lvol, sz, vbdev_lvol_resize_complete, NULL); 1447 CU_ASSERT(g_lvolerrno == 0); 1448 assert_blockcnt(g_lvol, sz); 1449 1450 /* Resize with NULL lvol */ 1451 vbdev_lvol_resize(NULL, 34 * g_cluster_size, vbdev_lvol_resize_complete, NULL); 1452 CU_ASSERT(g_lvolerrno != 0); 1453 assert_blockcnt(g_lvol, sz); 1454 1455 /* Successful lvol destroy */ 1456 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1457 CU_ASSERT(g_lvol == NULL); 1458 1459 /* Destroy lvol store */ 1460 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1461 CU_ASSERT(g_lvserrno == 0); 1462 CU_ASSERT(g_lvol_store == NULL); 1463 } 1464 1465 static void 1466 ut_lvol_set_read_only(void) 1467 { 1468 struct spdk_lvol_store *lvs; 1469 struct spdk_lvol *lvol; 1470 int sz = 10; 1471 int rc = 0; 1472 1473 /* Lvol store is successfully created */ 1474 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1475 lvol_store_op_with_handle_complete, NULL); 1476 CU_ASSERT(rc == 0); 1477 CU_ASSERT(g_lvserrno == 0); 1478 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1479 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1480 lvs = g_lvol_store; 1481 1482 /* Successful lvol create */ 1483 g_lvolerrno = -1; 1484 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1485 NULL); 1486 CU_ASSERT(rc == 0); 1487 CU_ASSERT(g_lvolerrno == 0); 1488 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1489 lvol = g_lvol; 1490 1491 /* Successful set lvol as read only */ 1492 g_lvolerrno = -1; 1493 vbdev_lvol_set_read_only(lvol, vbdev_lvol_set_read_only_complete, NULL); 1494 CU_ASSERT(g_lvolerrno == 0); 1495 1496 /* Successful lvol destroy */ 1497 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1498 CU_ASSERT(g_lvol == NULL); 1499 1500 /* Destroy lvol store */ 1501 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1502 CU_ASSERT(g_lvserrno == 0); 1503 CU_ASSERT(g_lvol_store == NULL); 1504 } 1505 1506 static void 1507 ut_lvs_unload(void) 1508 { 1509 int rc = 0; 1510 int sz = 10; 1511 struct spdk_lvol_store *lvs; 1512 1513 /* Lvol store is successfully created */ 1514 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1515 lvol_store_op_with_handle_complete, NULL); 1516 CU_ASSERT(rc == 0); 1517 CU_ASSERT(g_lvserrno == 0); 1518 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1519 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1520 1521 lvs = g_lvol_store; 1522 g_lvol_store = NULL; 1523 1524 spdk_uuid_generate(&lvs->uuid); 1525 1526 /* Successfully create lvol, which should be destroyed with lvs later */ 1527 g_lvolerrno = -1; 1528 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1529 NULL); 1530 CU_ASSERT(rc == 0); 1531 CU_ASSERT(g_lvolerrno == 0); 1532 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1533 1534 /* Unload lvol store */ 1535 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1536 CU_ASSERT(g_lvserrno == 0); 1537 CU_ASSERT(g_lvol_store == NULL); 1538 CU_ASSERT(g_lvol != NULL); 1539 } 1540 1541 static void 1542 ut_lvs_init(void) 1543 { 1544 int rc = 0; 1545 struct spdk_lvol_store *lvs; 1546 1547 /* spdk_lvs_init() fails */ 1548 lvol_store_initialize_fail = true; 1549 1550 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1551 lvol_store_op_with_handle_complete, NULL); 1552 CU_ASSERT(rc != 0); 1553 CU_ASSERT(g_lvserrno == 0); 1554 CU_ASSERT(g_lvol_store == NULL); 1555 1556 lvol_store_initialize_fail = false; 1557 1558 /* spdk_lvs_init_cb() fails */ 1559 lvol_store_initialize_cb_fail = true; 1560 1561 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1562 lvol_store_op_with_handle_complete, NULL); 1563 CU_ASSERT(rc == 0); 1564 CU_ASSERT(g_lvserrno != 0); 1565 CU_ASSERT(g_lvol_store == NULL); 1566 1567 lvol_store_initialize_cb_fail = false; 1568 1569 /* Lvol store is successfully created */ 1570 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1571 lvol_store_op_with_handle_complete, NULL); 1572 CU_ASSERT(rc == 0); 1573 CU_ASSERT(g_lvserrno == 0); 1574 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1575 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1576 1577 lvs = g_lvol_store; 1578 g_lvol_store = NULL; 1579 1580 /* Bdev with lvol store already claimed */ 1581 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1582 lvol_store_op_with_handle_complete, NULL); 1583 CU_ASSERT(rc != 0); 1584 CU_ASSERT(g_lvserrno == 0); 1585 CU_ASSERT(g_lvol_store == NULL); 1586 1587 /* Destruct lvol store */ 1588 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1589 CU_ASSERT(g_lvserrno == 0); 1590 CU_ASSERT(g_lvol_store == NULL); 1591 } 1592 1593 static void 1594 ut_vbdev_lvol_get_io_channel(void) 1595 { 1596 struct spdk_io_channel *ch; 1597 1598 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1599 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1600 1601 ch = vbdev_lvol_get_io_channel(g_lvol); 1602 CU_ASSERT(ch == g_ch); 1603 1604 free(g_lvol); 1605 } 1606 1607 static void 1608 ut_vbdev_lvol_io_type_supported(void) 1609 { 1610 struct spdk_lvol *lvol; 1611 bool ret; 1612 1613 lvol = calloc(1, sizeof(struct spdk_lvol)); 1614 SPDK_CU_ASSERT_FATAL(lvol != NULL); 1615 1616 g_blob_is_read_only = false; 1617 1618 /* Supported types */ 1619 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1620 CU_ASSERT(ret == true); 1621 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 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_UNMAP); 1626 CU_ASSERT(ret == true); 1627 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1628 CU_ASSERT(ret == true); 1629 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1630 CU_ASSERT(ret == true); 1631 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1632 CU_ASSERT(ret == true); 1633 1634 /* Unsupported types */ 1635 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1636 CU_ASSERT(ret == false); 1637 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1638 CU_ASSERT(ret == false); 1639 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1640 CU_ASSERT(ret == false); 1641 1642 g_blob_is_read_only = true; 1643 1644 /* Supported types */ 1645 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1646 CU_ASSERT(ret == true); 1647 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1648 CU_ASSERT(ret == true); 1649 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1650 CU_ASSERT(ret == true); 1651 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1652 CU_ASSERT(ret == true); 1653 1654 /* Unsupported types */ 1655 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1656 CU_ASSERT(ret == false); 1657 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1658 CU_ASSERT(ret == false); 1659 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1660 CU_ASSERT(ret == false); 1661 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1662 CU_ASSERT(ret == false); 1663 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1664 CU_ASSERT(ret == false); 1665 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1666 CU_ASSERT(ret == false); 1667 1668 free(lvol); 1669 } 1670 1671 static void 1672 ut_lvol_read_write(void) 1673 { 1674 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1675 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1676 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1677 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1678 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1679 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1680 1681 g_io->bdev = g_base_bdev; 1682 g_io->bdev->ctxt = g_lvol; 1683 g_io->u.bdev.offset_blocks = 20; 1684 g_io->u.bdev.num_blocks = 20; 1685 1686 lvol_read(g_ch, g_io); 1687 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1688 1689 lvol_write(g_lvol, g_ch, g_io); 1690 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1691 1692 g_ext_api_called = false; 1693 lvol_read(g_ch, g_io); 1694 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1695 CU_ASSERT(g_ext_api_called == true); 1696 g_ext_api_called = false; 1697 1698 lvol_write(g_lvol, g_ch, g_io); 1699 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1700 CU_ASSERT(g_ext_api_called == true); 1701 g_ext_api_called = false; 1702 1703 free(g_io); 1704 free(g_base_bdev); 1705 free(g_lvol); 1706 } 1707 1708 static void 1709 ut_vbdev_lvol_submit_request(void) 1710 { 1711 struct spdk_lvol request_lvol = {}; 1712 g_io = calloc(1, sizeof(struct spdk_bdev_io)); 1713 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1714 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1715 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1716 g_io->bdev = g_base_bdev; 1717 1718 g_io->type = SPDK_BDEV_IO_TYPE_READ; 1719 g_base_bdev->ctxt = &request_lvol; 1720 vbdev_lvol_submit_request(g_ch, g_io); 1721 1722 free(g_io); 1723 free(g_base_bdev); 1724 } 1725 1726 static void 1727 ut_lvs_rename(void) 1728 { 1729 int rc = 0; 1730 int sz = 10; 1731 struct spdk_lvol_store *lvs; 1732 1733 /* Lvol store is successfully created */ 1734 rc = vbdev_lvs_create("bdev", "old_lvs_name", 0, LVS_CLEAR_WITH_UNMAP, 0, 1735 lvol_store_op_with_handle_complete, NULL); 1736 CU_ASSERT(rc == 0); 1737 CU_ASSERT(g_lvserrno == 0); 1738 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1739 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1740 1741 lvs = g_lvol_store; 1742 g_lvol_store = NULL; 1743 1744 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1745 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1746 1747 /* Successfully create lvol, which should be destroyed with lvs later */ 1748 g_lvolerrno = -1; 1749 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1750 NULL); 1751 CU_ASSERT(rc == 0); 1752 CU_ASSERT(g_lvolerrno == 0); 1753 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1754 1755 /* Trying to rename lvs with lvols created */ 1756 vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL); 1757 CU_ASSERT(g_lvserrno == 0); 1758 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1759 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1760 1761 /* Trying to rename lvs with name already used by another lvs */ 1762 /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates 1763 * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */ 1764 g_lvs_with_name_already_exists = true; 1765 vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL); 1766 CU_ASSERT(g_lvserrno == -EEXIST); 1767 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1768 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1769 g_lvs_with_name_already_exists = false; 1770 1771 /* Unload lvol store */ 1772 g_lvol_store = lvs; 1773 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1774 CU_ASSERT(g_lvserrno == 0); 1775 CU_ASSERT(g_lvol_store == NULL); 1776 1777 free(g_base_bdev->name); 1778 free(g_base_bdev); 1779 } 1780 1781 static void 1782 ut_lvol_seek(void) 1783 { 1784 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1785 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1786 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1787 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1788 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1789 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1790 1791 g_io->bdev = g_base_bdev; 1792 g_io->bdev->ctxt = g_lvol; 1793 1794 /* Data found */ 1795 g_io->u.bdev.offset_blocks = 10; 1796 lvol_seek_data(g_lvol, g_io); 1797 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1798 CU_ASSERT(g_io->u.bdev.seek.offset == g_blob_allocated_io_unit_offset); 1799 1800 /* Data not found */ 1801 g_io->u.bdev.offset_blocks = 30; 1802 lvol_seek_data(g_lvol, g_io); 1803 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1804 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1805 1806 /* Hole found */ 1807 g_io->u.bdev.offset_blocks = 10; 1808 lvol_seek_hole(g_lvol, g_io); 1809 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1810 CU_ASSERT(g_io->u.bdev.seek.offset == 10); 1811 1812 /* Hole not found */ 1813 g_io->u.bdev.offset_blocks = 30; 1814 lvol_seek_hole(g_lvol, g_io); 1815 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1816 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1817 1818 free(g_io); 1819 free(g_base_bdev); 1820 free(g_lvol); 1821 } 1822 1823 static void 1824 ut_esnap_dev_create(void) 1825 { 1826 struct spdk_lvol_store lvs = { 0 }; 1827 struct spdk_lvol lvol = { 0 }; 1828 struct spdk_blob blob = { 0 }; 1829 struct spdk_bdev bdev = { 0 }; 1830 const char uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4"; 1831 char bad_uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4"; 1832 char *unterminated; 1833 size_t len; 1834 struct spdk_bs_dev *bs_dev = NULL; 1835 int rc; 1836 1837 bdev.name = "bdev0"; 1838 spdk_uuid_parse(&bdev.uuid, uuid_str); 1839 1840 /* NULL esnap_id */ 1841 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, NULL, 0, &bs_dev); 1842 CU_ASSERT(rc == -EINVAL); 1843 CU_ASSERT(bs_dev == NULL); 1844 1845 /* Unterminated UUID: asan should catch reads past end of allocated buffer. */ 1846 len = strlen(uuid_str); 1847 unterminated = calloc(1, len); 1848 SPDK_CU_ASSERT_FATAL(unterminated != NULL); 1849 memcpy(unterminated, uuid_str, len); 1850 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, unterminated, len, &bs_dev); 1851 CU_ASSERT(rc == -EINVAL); 1852 CU_ASSERT(bs_dev == NULL); 1853 1854 /* Invaid UUID but the right length is invalid */ 1855 bad_uuid_str[2] = 'z'; 1856 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, bad_uuid_str, sizeof(uuid_str), 1857 &bs_dev); 1858 CU_ASSERT(rc == -EINVAL); 1859 CU_ASSERT(bs_dev == NULL); 1860 1861 /* Bdev not found */ 1862 g_base_bdev = NULL; 1863 MOCK_SET(spdk_lvol_is_degraded, true); 1864 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1865 CU_ASSERT(rc == 0); 1866 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1867 CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy); 1868 bs_dev->destroy(bs_dev); 1869 1870 /* Cannot get a claim */ 1871 /* TODO: This suggests we need a way to wait for a claim to be available. */ 1872 g_base_bdev = &bdev; 1873 lvol_already_opened = true; 1874 MOCK_SET(spdk_lvol_is_degraded, true); 1875 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1876 CU_ASSERT(rc == 0); 1877 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1878 CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy); 1879 bs_dev->destroy(bs_dev); 1880 1881 /* Happy path */ 1882 lvol_already_opened = false; 1883 MOCK_SET(spdk_lvol_is_degraded, false); 1884 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1885 CU_ASSERT(rc == 0); 1886 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1887 CU_ASSERT(bs_dev->destroy == ut_bs_dev_destroy); 1888 bs_dev->destroy(bs_dev); 1889 1890 g_base_bdev = NULL; 1891 lvol_already_opened = false; 1892 free(unterminated); 1893 MOCK_CLEAR(spdk_lvol_is_degraded); 1894 } 1895 1896 static void 1897 ut_lvol_esnap_clone_bad_args(void) 1898 { 1899 struct spdk_bdev bdev = { 0 }; 1900 struct spdk_lvol_store *lvs; 1901 const char *esnap_uuid = "255f4236-9427-42d0-a9d1-aa17f37dd8db"; 1902 const char *esnap_name = "esnap1"; 1903 int rc; 1904 1905 /* Lvol store is successfully created */ 1906 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1907 lvol_store_op_with_handle_complete, NULL); 1908 CU_ASSERT(rc == 0); 1909 CU_ASSERT(g_lvserrno == 0); 1910 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1911 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1912 lvs = g_lvol_store; 1913 1914 rc = spdk_uuid_parse(&bdev.uuid, esnap_uuid); 1915 CU_ASSERT(rc == 0); 1916 bdev.name = strdup(esnap_name); 1917 SPDK_CU_ASSERT_FATAL(bdev.name != NULL); 1918 bdev.blocklen = 512; 1919 SPDK_CU_ASSERT_FATAL(SPDK_BS_PAGE_SIZE % bdev.blocklen == 0); 1920 bdev.blockcnt = 8192; 1921 1922 g_base_bdev = &bdev; 1923 1924 /* Error when lvs is NULL */ 1925 g_lvolerrno = 0xbad; 1926 vbdev_lvol_create_bdev_clone(esnap_uuid, NULL, "clone1", vbdev_lvol_create_complete, NULL); 1927 CU_ASSERT(g_lvolerrno == -EINVAL); 1928 1929 /* Error when the bdev does not exist */ 1930 g_base_bdev = NULL; 1931 g_lvolerrno = 0xbad; 1932 vbdev_lvol_create_bdev_clone(esnap_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL); 1933 CU_ASSERT(g_lvolerrno == -ENODEV); 1934 1935 /* Success when creating by bdev UUID */ 1936 g_base_bdev = &bdev; 1937 g_lvolerrno = 0xbad; 1938 vbdev_lvol_create_bdev_clone(esnap_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL); 1939 CU_ASSERT(g_lvolerrno == 0); 1940 1941 /* Success when creating by bdev name */ 1942 g_lvolerrno = 0xbad; 1943 vbdev_lvol_create_bdev_clone(esnap_name, lvs, "clone2", vbdev_lvol_create_complete, NULL); 1944 CU_ASSERT(g_lvolerrno == 0); 1945 1946 g_lvol_store = lvs; 1947 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1948 CU_ASSERT(g_lvserrno == 0); 1949 CU_ASSERT(g_lvol_store == NULL); 1950 1951 free(bdev.name); 1952 g_base_bdev = NULL; 1953 } 1954 1955 int 1956 main(int argc, char **argv) 1957 { 1958 CU_pSuite suite = NULL; 1959 unsigned int num_failures; 1960 1961 CU_initialize_registry(); 1962 1963 suite = CU_add_suite("lvol", NULL, NULL); 1964 1965 CU_ADD_TEST(suite, ut_lvs_init); 1966 CU_ADD_TEST(suite, ut_lvol_init); 1967 CU_ADD_TEST(suite, ut_lvol_snapshot); 1968 CU_ADD_TEST(suite, ut_lvol_clone); 1969 CU_ADD_TEST(suite, ut_lvs_destroy); 1970 CU_ADD_TEST(suite, ut_lvs_unload); 1971 CU_ADD_TEST(suite, ut_lvol_resize); 1972 CU_ADD_TEST(suite, ut_lvol_set_read_only); 1973 CU_ADD_TEST(suite, ut_lvol_hotremove); 1974 CU_ADD_TEST(suite, ut_vbdev_lvol_get_io_channel); 1975 CU_ADD_TEST(suite, ut_vbdev_lvol_io_type_supported); 1976 CU_ADD_TEST(suite, ut_lvol_read_write); 1977 CU_ADD_TEST(suite, ut_vbdev_lvol_submit_request); 1978 CU_ADD_TEST(suite, ut_lvol_examine_config); 1979 CU_ADD_TEST(suite, ut_lvol_examine_disk); 1980 CU_ADD_TEST(suite, ut_lvol_rename); 1981 CU_ADD_TEST(suite, ut_bdev_finish); 1982 CU_ADD_TEST(suite, ut_lvs_rename); 1983 CU_ADD_TEST(suite, ut_lvol_seek); 1984 CU_ADD_TEST(suite, ut_esnap_dev_create); 1985 CU_ADD_TEST(suite, ut_lvol_esnap_clone_bad_args); 1986 1987 allocate_threads(1); 1988 set_thread(0); 1989 1990 num_failures = spdk_ut_run_tests(argc, argv, NULL); 1991 CU_cleanup_registry(); 1992 1993 free_threads(); 1994 1995 return num_failures; 1996 } 1997