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