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