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