1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2017 Intel Corporation. 3 * All rights reserved. 4 * Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk_cunit.h" 8 #include "spdk/string.h" 9 10 #include "bdev/lvol/vbdev_lvol.c" 11 12 #include "unit/lib/json_mock.c" 13 14 #define SPDK_BS_PAGE_SIZE 0x1000 15 16 int g_lvolerrno; 17 int g_lvserrno; 18 int g_cluster_size; 19 int g_registered_bdevs; 20 int g_num_lvols = 0; 21 struct spdk_lvol_store *g_lvs = NULL; 22 struct spdk_lvol *g_lvol = NULL; 23 struct lvol_store_bdev *g_lvs_bdev = NULL; 24 struct spdk_bdev *g_base_bdev = NULL; 25 struct spdk_bdev_io *g_io = NULL; 26 struct spdk_io_channel *g_ch = NULL; 27 28 static struct spdk_bdev g_bdev = {}; 29 static struct spdk_lvol_store *g_lvol_store = NULL; 30 bool lvol_store_initialize_fail = false; 31 bool lvol_store_initialize_cb_fail = false; 32 bool lvol_already_opened = false; 33 bool g_examine_done = false; 34 bool g_bdev_alias_already_exists = false; 35 bool g_lvs_with_name_already_exists = false; 36 bool g_ext_api_called; 37 38 DEFINE_STUB_V(spdk_bdev_module_fini_start_done, (void)); 39 DEFINE_STUB(spdk_bdev_get_memory_domains, int, (struct spdk_bdev *bdev, 40 struct spdk_memory_domain **domains, int array_size), 0); 41 42 const struct spdk_bdev_aliases_list * 43 spdk_bdev_get_aliases(const struct spdk_bdev *bdev) 44 { 45 return &bdev->aliases; 46 } 47 48 uint32_t 49 spdk_bdev_get_md_size(const struct spdk_bdev *bdev) 50 { 51 return bdev->md_len; 52 } 53 54 int 55 spdk_bdev_alias_add(struct spdk_bdev *bdev, const char *alias) 56 { 57 struct spdk_bdev_alias *tmp; 58 59 CU_ASSERT(alias != NULL); 60 CU_ASSERT(bdev != NULL); 61 if (g_bdev_alias_already_exists) { 62 return -EEXIST; 63 } 64 65 tmp = calloc(1, sizeof(*tmp)); 66 SPDK_CU_ASSERT_FATAL(tmp != NULL); 67 68 tmp->alias.name = strdup(alias); 69 SPDK_CU_ASSERT_FATAL(tmp->alias.name != NULL); 70 71 TAILQ_INSERT_TAIL(&bdev->aliases, tmp, tailq); 72 73 return 0; 74 } 75 76 int 77 spdk_bdev_alias_del(struct spdk_bdev *bdev, const char *alias) 78 { 79 struct spdk_bdev_alias *tmp; 80 81 CU_ASSERT(bdev != NULL); 82 83 TAILQ_FOREACH(tmp, &bdev->aliases, tailq) { 84 SPDK_CU_ASSERT_FATAL(alias != NULL); 85 if (strncmp(alias, tmp->alias.name, SPDK_LVOL_NAME_MAX) == 0) { 86 TAILQ_REMOVE(&bdev->aliases, tmp, tailq); 87 free(tmp->alias.name); 88 free(tmp); 89 return 0; 90 } 91 } 92 93 return -ENOENT; 94 } 95 96 void 97 spdk_bdev_alias_del_all(struct spdk_bdev *bdev) 98 { 99 struct spdk_bdev_alias *p, *tmp; 100 101 TAILQ_FOREACH_SAFE(p, &bdev->aliases, tailq, tmp) { 102 TAILQ_REMOVE(&bdev->aliases, p, tailq); 103 free(p->alias.name); 104 free(p); 105 } 106 } 107 108 void 109 spdk_bdev_destruct_done(struct spdk_bdev *bdev, int bdeverrno) 110 { 111 CU_ASSERT(bdeverrno == 0); 112 SPDK_CU_ASSERT_FATAL(bdev->internal.unregister_cb != NULL); 113 bdev->internal.unregister_cb(bdev->internal.unregister_ctx, bdeverrno); 114 } 115 116 void 117 spdk_lvs_grow(struct spdk_bs_dev *bs_dev, spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 118 { 119 cb_fn(cb_arg, NULL, -EINVAL); 120 } 121 122 void 123 spdk_lvs_rename(struct spdk_lvol_store *lvs, const char *new_name, 124 spdk_lvs_op_complete cb_fn, void *cb_arg) 125 { 126 if (g_lvs_with_name_already_exists) { 127 g_lvolerrno = -EEXIST; 128 } else { 129 snprintf(lvs->name, sizeof(lvs->name), "%s", new_name); 130 g_lvolerrno = 0; 131 } 132 133 cb_fn(cb_arg, g_lvolerrno); 134 } 135 136 void 137 spdk_lvol_rename(struct spdk_lvol *lvol, const char *new_name, 138 spdk_lvol_op_complete cb_fn, void *cb_arg) 139 { 140 struct spdk_lvol *tmp; 141 142 if (strncmp(lvol->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 143 cb_fn(cb_arg, 0); 144 return; 145 } 146 147 TAILQ_FOREACH(tmp, &lvol->lvol_store->lvols, link) { 148 if (strncmp(tmp->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 149 SPDK_ERRLOG("Lvol %s already exists in lvol store %s\n", new_name, lvol->lvol_store->name); 150 cb_fn(cb_arg, -EEXIST); 151 return; 152 } 153 } 154 155 snprintf(lvol->name, sizeof(lvol->name), "%s", new_name); 156 157 cb_fn(cb_arg, g_lvolerrno); 158 } 159 160 void 161 spdk_lvol_open(struct spdk_lvol *lvol, spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 162 { 163 cb_fn(cb_arg, lvol, g_lvolerrno); 164 } 165 166 uint64_t 167 spdk_blob_get_num_clusters(struct spdk_blob *b) 168 { 169 return 0; 170 } 171 172 /* Simulation of a blob with: 173 * - 1 io_unit per cluster 174 * - 20 data cluster 175 * - only last cluster allocated 176 */ 177 uint64_t g_blob_allocated_io_unit_offset = 20; 178 179 uint64_t 180 spdk_blob_get_next_allocated_io_unit(struct spdk_blob *blob, uint64_t offset) 181 { 182 if (offset <= g_blob_allocated_io_unit_offset) { 183 return g_blob_allocated_io_unit_offset; 184 } else { 185 return UINT64_MAX; 186 } 187 } 188 189 uint64_t 190 spdk_blob_get_next_unallocated_io_unit(struct spdk_blob *blob, uint64_t offset) 191 { 192 if (offset < g_blob_allocated_io_unit_offset) { 193 return offset; 194 } else { 195 return UINT64_MAX; 196 } 197 } 198 199 int 200 spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_id *ids, 201 size_t *count) 202 { 203 *count = 0; 204 return 0; 205 } 206 207 spdk_blob_id 208 spdk_blob_get_parent_snapshot(struct spdk_blob_store *bs, spdk_blob_id blobid) 209 { 210 return 0; 211 } 212 213 bool g_blob_is_read_only = false; 214 215 bool 216 spdk_blob_is_read_only(struct spdk_blob *blob) 217 { 218 return g_blob_is_read_only; 219 } 220 221 bool 222 spdk_blob_is_snapshot(struct spdk_blob *blob) 223 { 224 return false; 225 } 226 227 bool 228 spdk_blob_is_clone(struct spdk_blob *blob) 229 { 230 return false; 231 } 232 233 bool 234 spdk_blob_is_thin_provisioned(struct spdk_blob *blob) 235 { 236 return false; 237 } 238 239 static struct spdk_lvol *_lvol_create(struct spdk_lvol_store *lvs); 240 241 void 242 spdk_lvs_load(struct spdk_bs_dev *dev, 243 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 244 { 245 struct spdk_lvol_store *lvs = NULL; 246 int i; 247 int lvserrno = g_lvserrno; 248 249 if (lvserrno != 0) { 250 /* On error blobstore destroys bs_dev itself, 251 * by puttin back io channels. 252 * This operation is asynchronous, and completed 253 * after calling the callback for lvol. */ 254 cb_fn(cb_arg, g_lvol_store, lvserrno); 255 dev->destroy(dev); 256 return; 257 } 258 259 lvs = calloc(1, sizeof(*lvs)); 260 SPDK_CU_ASSERT_FATAL(lvs != NULL); 261 TAILQ_INIT(&lvs->lvols); 262 TAILQ_INIT(&lvs->pending_lvols); 263 spdk_uuid_generate(&lvs->uuid); 264 lvs->bs_dev = dev; 265 for (i = 0; i < g_num_lvols; i++) { 266 _lvol_create(lvs); 267 } 268 269 cb_fn(cb_arg, lvs, lvserrno); 270 } 271 272 int 273 spdk_bs_bdev_claim(struct spdk_bs_dev *bs_dev, struct spdk_bdev_module *module) 274 { 275 if (lvol_already_opened == true) { 276 return -1; 277 } 278 279 lvol_already_opened = true; 280 281 return 0; 282 } 283 284 static void 285 _spdk_bdev_unregister_cb(void *cb_arg, int rc) 286 { 287 CU_ASSERT(rc == 0); 288 } 289 290 void 291 spdk_bdev_unregister(struct spdk_bdev *vbdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg) 292 { 293 int rc; 294 295 SPDK_CU_ASSERT_FATAL(vbdev != NULL); 296 vbdev->internal.unregister_cb = cb_fn; 297 vbdev->internal.unregister_ctx = cb_arg; 298 299 rc = vbdev->fn_table->destruct(vbdev->ctxt); 300 CU_ASSERT(rc == 1); 301 } 302 303 uint64_t 304 spdk_bs_get_page_size(struct spdk_blob_store *bs) 305 { 306 return SPDK_BS_PAGE_SIZE; 307 } 308 309 uint64_t 310 spdk_bs_get_io_unit_size(struct spdk_blob_store *bs) 311 { 312 return SPDK_BS_PAGE_SIZE; 313 } 314 315 static void 316 bdev_blob_destroy(struct spdk_bs_dev *bs_dev) 317 { 318 CU_ASSERT(bs_dev != NULL); 319 free(bs_dev); 320 lvol_already_opened = false; 321 } 322 323 static struct spdk_bdev * 324 bdev_blob_get_base_bdev(struct spdk_bs_dev *bs_dev) 325 { 326 CU_ASSERT(bs_dev != NULL); 327 return &g_bdev; 328 } 329 330 int 331 spdk_bdev_create_bs_dev_ext(const char *bdev_name, spdk_bdev_event_cb_t event_cb, 332 void *event_ctx, struct spdk_bs_dev **_bs_dev) 333 { 334 struct spdk_bs_dev *bs_dev; 335 336 if (lvol_already_opened == true) { 337 return -EINVAL; 338 } 339 340 bs_dev = calloc(1, sizeof(*bs_dev)); 341 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 342 bs_dev->blocklen = 4096; 343 bs_dev->blockcnt = 128; 344 bs_dev->destroy = bdev_blob_destroy; 345 bs_dev->get_base_bdev = bdev_blob_get_base_bdev; 346 347 *_bs_dev = bs_dev; 348 349 return 0; 350 } 351 352 void 353 spdk_lvs_opts_init(struct spdk_lvs_opts *opts) 354 { 355 opts->cluster_sz = SPDK_LVS_OPTS_CLUSTER_SZ; 356 opts->clear_method = LVS_CLEAR_WITH_UNMAP; 357 opts->num_md_pages_per_cluster_ratio = 100; 358 memset(opts->name, 0, sizeof(opts->name)); 359 } 360 361 int 362 spdk_lvs_init(struct spdk_bs_dev *bs_dev, struct spdk_lvs_opts *o, 363 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 364 { 365 struct spdk_lvol_store *lvs; 366 int error = 0; 367 368 if (lvol_store_initialize_fail) { 369 return -1; 370 } 371 372 if (lvol_store_initialize_cb_fail) { 373 bs_dev->destroy(bs_dev); 374 lvs = NULL; 375 error = -1; 376 } else { 377 lvs = calloc(1, sizeof(*lvs)); 378 SPDK_CU_ASSERT_FATAL(lvs != NULL); 379 TAILQ_INIT(&lvs->lvols); 380 TAILQ_INIT(&lvs->pending_lvols); 381 spdk_uuid_generate(&lvs->uuid); 382 snprintf(lvs->name, sizeof(lvs->name), "%s", o->name); 383 lvs->bs_dev = bs_dev; 384 error = 0; 385 } 386 cb_fn(cb_arg, lvs, error); 387 388 return 0; 389 } 390 391 int 392 spdk_lvs_unload(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, void *cb_arg) 393 { 394 struct spdk_lvol *lvol, *tmp; 395 396 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 397 TAILQ_REMOVE(&lvs->lvols, lvol, link); 398 free(lvol); 399 } 400 g_lvol_store = NULL; 401 402 lvs->bs_dev->destroy(lvs->bs_dev); 403 free(lvs); 404 405 if (cb_fn != NULL) { 406 cb_fn(cb_arg, 0); 407 } 408 409 return 0; 410 } 411 412 int 413 spdk_lvs_destroy(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, 414 void *cb_arg) 415 { 416 struct spdk_lvol *lvol, *tmp; 417 char *alias; 418 419 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 420 TAILQ_REMOVE(&lvs->lvols, lvol, link); 421 422 alias = spdk_sprintf_alloc("%s/%s", lvs->name, lvol->name); 423 if (alias == NULL) { 424 SPDK_ERRLOG("Cannot alloc memory for alias\n"); 425 return -1; 426 } 427 spdk_bdev_alias_del(lvol->bdev, alias); 428 429 free(alias); 430 free(lvol); 431 } 432 g_lvol_store = NULL; 433 434 lvs->bs_dev->destroy(lvs->bs_dev); 435 free(lvs); 436 437 if (cb_fn != NULL) { 438 cb_fn(cb_arg, 0); 439 } 440 441 return 0; 442 } 443 444 void 445 spdk_lvol_resize(struct spdk_lvol *lvol, size_t sz, spdk_lvol_op_complete cb_fn, void *cb_arg) 446 { 447 cb_fn(cb_arg, 0); 448 } 449 450 void 451 spdk_lvol_set_read_only(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 452 { 453 cb_fn(cb_arg, 0); 454 } 455 456 int 457 spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size) 458 { 459 bdev->blockcnt = size; 460 return 0; 461 } 462 463 uint64_t 464 spdk_bs_get_cluster_size(struct spdk_blob_store *bs) 465 { 466 return g_cluster_size; 467 } 468 469 struct spdk_bdev * 470 spdk_bdev_get_by_name(const char *bdev_name) 471 { 472 if (!strcmp(g_base_bdev->name, bdev_name)) { 473 return g_base_bdev; 474 } 475 476 return NULL; 477 } 478 479 void 480 spdk_lvol_close(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 481 { 482 lvol->ref_count--; 483 484 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 485 cb_fn(cb_arg, 0); 486 } 487 488 bool 489 spdk_lvol_deletable(struct spdk_lvol *lvol) 490 { 491 return true; 492 } 493 494 void 495 spdk_lvol_destroy(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 496 { 497 if (lvol->ref_count != 0) { 498 cb_fn(cb_arg, -ENODEV); 499 } 500 501 TAILQ_REMOVE(&lvol->lvol_store->lvols, lvol, link); 502 503 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 504 cb_fn(cb_arg, 0); 505 506 g_lvol = NULL; 507 free(lvol); 508 } 509 510 void 511 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 512 { 513 bdev_io->internal.status = status; 514 } 515 516 struct spdk_io_channel *spdk_lvol_get_io_channel(struct spdk_lvol *lvol) 517 { 518 CU_ASSERT(lvol == g_lvol); 519 return g_ch; 520 } 521 522 void 523 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 524 { 525 CU_ASSERT(cb == lvol_get_buf_cb); 526 } 527 528 void 529 spdk_blob_io_read(struct spdk_blob *blob, struct spdk_io_channel *channel, 530 void *payload, uint64_t offset, uint64_t length, 531 spdk_blob_op_complete cb_fn, void *cb_arg) 532 { 533 CU_ASSERT(blob == NULL); 534 CU_ASSERT(channel == g_ch); 535 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 536 CU_ASSERT(length == g_io->u.bdev.num_blocks); 537 cb_fn(cb_arg, 0); 538 } 539 540 void 541 spdk_blob_io_write(struct spdk_blob *blob, struct spdk_io_channel *channel, 542 void *payload, uint64_t offset, uint64_t length, 543 spdk_blob_op_complete cb_fn, void *cb_arg) 544 { 545 CU_ASSERT(blob == NULL); 546 CU_ASSERT(channel == g_ch); 547 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 548 CU_ASSERT(length == g_io->u.bdev.num_blocks); 549 cb_fn(cb_arg, 0); 550 } 551 552 void 553 spdk_blob_io_unmap(struct spdk_blob *blob, struct spdk_io_channel *channel, 554 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 555 { 556 CU_ASSERT(blob == NULL); 557 CU_ASSERT(channel == g_ch); 558 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 559 CU_ASSERT(length == g_io->u.bdev.num_blocks); 560 cb_fn(cb_arg, 0); 561 } 562 563 void 564 spdk_blob_io_write_zeroes(struct spdk_blob *blob, struct spdk_io_channel *channel, 565 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 566 { 567 CU_ASSERT(blob == NULL); 568 CU_ASSERT(channel == g_ch); 569 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 570 CU_ASSERT(length == g_io->u.bdev.num_blocks); 571 cb_fn(cb_arg, 0); 572 } 573 574 void 575 spdk_blob_io_writev(struct spdk_blob *blob, struct spdk_io_channel *channel, 576 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 577 spdk_blob_op_complete cb_fn, void *cb_arg) 578 { 579 CU_ASSERT(blob == NULL); 580 CU_ASSERT(channel == g_ch); 581 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 582 CU_ASSERT(length == g_io->u.bdev.num_blocks); 583 cb_fn(cb_arg, 0); 584 } 585 586 void 587 spdk_blob_io_writev_ext(struct spdk_blob *blob, struct spdk_io_channel *channel, 588 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 589 spdk_blob_op_complete cb_fn, void *cb_arg, 590 struct spdk_blob_ext_io_opts *io_opts) 591 { 592 struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx; 593 594 CU_ASSERT(blob == NULL); 595 CU_ASSERT(channel == g_ch); 596 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 597 CU_ASSERT(length == g_io->u.bdev.num_blocks); 598 CU_ASSERT(io_opts == &lvol_io->ext_io_opts); 599 g_ext_api_called = true; 600 cb_fn(cb_arg, 0); 601 } 602 603 void 604 spdk_blob_io_readv(struct spdk_blob *blob, struct spdk_io_channel *channel, 605 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 606 spdk_blob_op_complete cb_fn, void *cb_arg) 607 { 608 CU_ASSERT(blob == NULL); 609 CU_ASSERT(channel == g_ch); 610 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 611 CU_ASSERT(length == g_io->u.bdev.num_blocks); 612 cb_fn(cb_arg, 0); 613 } 614 615 void 616 spdk_blob_io_readv_ext(struct spdk_blob *blob, struct spdk_io_channel *channel, 617 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 618 spdk_blob_op_complete cb_fn, void *cb_arg, 619 struct spdk_blob_ext_io_opts *io_opts) 620 { 621 struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx; 622 623 CU_ASSERT(blob == NULL); 624 CU_ASSERT(channel == g_ch); 625 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 626 CU_ASSERT(length == g_io->u.bdev.num_blocks); 627 CU_ASSERT(io_opts == &lvol_io->ext_io_opts); 628 g_ext_api_called = true; 629 cb_fn(cb_arg, 0); 630 } 631 632 void 633 spdk_bdev_module_list_add(struct spdk_bdev_module *bdev_module) 634 { 635 } 636 637 const char * 638 spdk_bdev_get_name(const struct spdk_bdev *bdev) 639 { 640 return "test"; 641 } 642 643 int 644 spdk_bdev_register(struct spdk_bdev *vbdev) 645 { 646 TAILQ_INIT(&vbdev->aliases); 647 648 g_registered_bdevs++; 649 return 0; 650 } 651 652 void 653 spdk_bdev_module_examine_done(struct spdk_bdev_module *module) 654 { 655 SPDK_CU_ASSERT_FATAL(g_examine_done != true); 656 g_examine_done = true; 657 } 658 659 static struct spdk_lvol * 660 _lvol_create(struct spdk_lvol_store *lvs) 661 { 662 struct spdk_lvol *lvol = calloc(1, sizeof(*lvol)); 663 664 SPDK_CU_ASSERT_FATAL(lvol != NULL); 665 666 lvol->lvol_store = lvs; 667 lvol->ref_count++; 668 snprintf(lvol->unique_id, sizeof(lvol->unique_id), "%s", "UNIT_TEST_UUID"); 669 670 TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link); 671 672 return lvol; 673 } 674 675 int 676 spdk_lvol_create(struct spdk_lvol_store *lvs, const char *name, size_t sz, 677 bool thin_provision, enum lvol_clear_method clear_method, spdk_lvol_op_with_handle_complete cb_fn, 678 void *cb_arg) 679 { 680 struct spdk_lvol *lvol; 681 682 lvol = _lvol_create(lvs); 683 snprintf(lvol->name, sizeof(lvol->name), "%s", name); 684 cb_fn(cb_arg, lvol, 0); 685 686 return 0; 687 } 688 689 void 690 spdk_lvol_create_snapshot(struct spdk_lvol *lvol, const char *snapshot_name, 691 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 692 { 693 struct spdk_lvol *snap; 694 695 snap = _lvol_create(lvol->lvol_store); 696 snprintf(snap->name, sizeof(snap->name), "%s", snapshot_name); 697 cb_fn(cb_arg, snap, 0); 698 } 699 700 void 701 spdk_lvol_create_clone(struct spdk_lvol *lvol, const char *clone_name, 702 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 703 { 704 struct spdk_lvol *clone; 705 706 clone = _lvol_create(lvol->lvol_store); 707 snprintf(clone->name, sizeof(clone->name), "%s", clone_name); 708 cb_fn(cb_arg, clone, 0); 709 } 710 711 static void 712 lvol_store_op_complete(void *cb_arg, int lvserrno) 713 { 714 g_lvserrno = lvserrno; 715 return; 716 } 717 718 static void 719 lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno) 720 { 721 g_lvserrno = lvserrno; 722 g_lvol_store = lvs; 723 return; 724 } 725 726 static void 727 vbdev_lvol_create_complete(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) 728 { 729 g_lvolerrno = lvolerrno; 730 g_lvol = lvol; 731 } 732 733 static void 734 vbdev_lvol_resize_complete(void *cb_arg, int lvolerrno) 735 { 736 g_lvolerrno = lvolerrno; 737 } 738 739 static void 740 vbdev_lvol_set_read_only_complete(void *cb_arg, int lvolerrno) 741 { 742 g_lvolerrno = lvolerrno; 743 } 744 745 static void 746 vbdev_lvol_rename_complete(void *cb_arg, int lvolerrno) 747 { 748 g_lvolerrno = lvolerrno; 749 } 750 751 static void 752 ut_lvs_destroy(void) 753 { 754 int rc = 0; 755 int sz = 10; 756 struct spdk_lvol_store *lvs; 757 758 /* Lvol store is successfully created */ 759 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 760 lvol_store_op_with_handle_complete, NULL); 761 CU_ASSERT(rc == 0); 762 CU_ASSERT(g_lvserrno == 0); 763 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 764 CU_ASSERT(g_lvol_store->bs_dev != NULL); 765 766 lvs = g_lvol_store; 767 g_lvol_store = NULL; 768 769 spdk_uuid_generate(&lvs->uuid); 770 771 /* Successfully create lvol, which should be unloaded with lvs later */ 772 g_lvolerrno = -1; 773 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 774 NULL); 775 CU_ASSERT(rc == 0); 776 CU_ASSERT(g_lvolerrno == 0); 777 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 778 779 /* Unload lvol store */ 780 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 781 CU_ASSERT(g_lvserrno == 0); 782 CU_ASSERT(g_lvol_store == NULL); 783 } 784 785 static void 786 ut_lvol_init(void) 787 { 788 struct spdk_lvol_store *lvs; 789 int sz = 10; 790 int rc; 791 792 /* Lvol store is successfully created */ 793 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 794 lvol_store_op_with_handle_complete, NULL); 795 CU_ASSERT(rc == 0); 796 CU_ASSERT(g_lvserrno == 0); 797 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 798 CU_ASSERT(g_lvol_store->bs_dev != NULL); 799 lvs = g_lvol_store; 800 801 /* Successful lvol create */ 802 g_lvolerrno = -1; 803 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 804 NULL); 805 SPDK_CU_ASSERT_FATAL(rc == 0); 806 CU_ASSERT(g_lvol != NULL); 807 CU_ASSERT(g_lvolerrno == 0); 808 809 /* Successful lvol destroy */ 810 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 811 CU_ASSERT(g_lvol == NULL); 812 813 /* Destroy lvol store */ 814 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 815 CU_ASSERT(g_lvserrno == 0); 816 CU_ASSERT(g_lvol_store == NULL); 817 } 818 819 static void 820 ut_lvol_snapshot(void) 821 { 822 struct spdk_lvol_store *lvs; 823 int sz = 10; 824 int rc; 825 struct spdk_lvol *lvol = NULL; 826 827 /* Lvol store is successfully created */ 828 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 829 lvol_store_op_with_handle_complete, NULL); 830 CU_ASSERT(rc == 0); 831 CU_ASSERT(g_lvserrno == 0); 832 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 833 CU_ASSERT(g_lvol_store->bs_dev != NULL); 834 lvs = g_lvol_store; 835 836 /* Successful lvol create */ 837 g_lvolerrno = -1; 838 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 839 NULL); 840 SPDK_CU_ASSERT_FATAL(rc == 0); 841 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 842 CU_ASSERT(g_lvolerrno == 0); 843 844 lvol = g_lvol; 845 846 /* Successful snap create */ 847 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 848 SPDK_CU_ASSERT_FATAL(rc == 0); 849 CU_ASSERT(g_lvol != NULL); 850 CU_ASSERT(g_lvolerrno == 0); 851 852 /* Successful lvol destroy */ 853 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 854 CU_ASSERT(g_lvol == NULL); 855 856 /* Successful snap destroy */ 857 g_lvol = lvol; 858 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 859 CU_ASSERT(g_lvol == NULL); 860 861 /* Destroy lvol store */ 862 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 863 CU_ASSERT(g_lvserrno == 0); 864 CU_ASSERT(g_lvol_store == NULL); 865 } 866 867 static void 868 ut_lvol_clone(void) 869 { 870 struct spdk_lvol_store *lvs; 871 int sz = 10; 872 int rc; 873 struct spdk_lvol *lvol = NULL; 874 struct spdk_lvol *snap = NULL; 875 struct spdk_lvol *clone = NULL; 876 877 /* Lvol store is successfully created */ 878 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 879 lvol_store_op_with_handle_complete, NULL); 880 CU_ASSERT(rc == 0); 881 CU_ASSERT(g_lvserrno == 0); 882 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 883 CU_ASSERT(g_lvol_store->bs_dev != NULL); 884 lvs = g_lvol_store; 885 886 /* Successful lvol create */ 887 g_lvolerrno = -1; 888 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 889 NULL); 890 SPDK_CU_ASSERT_FATAL(rc == 0); 891 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 892 CU_ASSERT(g_lvolerrno == 0); 893 894 lvol = g_lvol; 895 896 /* Successful snap create */ 897 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 898 SPDK_CU_ASSERT_FATAL(rc == 0); 899 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 900 CU_ASSERT(g_lvolerrno == 0); 901 902 snap = g_lvol; 903 904 /* Successful clone create */ 905 vbdev_lvol_create_clone(snap, "clone", vbdev_lvol_create_complete, NULL); 906 907 SPDK_CU_ASSERT_FATAL(rc == 0); 908 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 909 CU_ASSERT(g_lvolerrno == 0); 910 911 clone = g_lvol; 912 913 /* Successful lvol destroy */ 914 g_lvol = lvol; 915 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 916 CU_ASSERT(g_lvol == NULL); 917 918 /* Successful clone destroy */ 919 g_lvol = clone; 920 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 921 CU_ASSERT(g_lvol == NULL); 922 923 /* Successful lvol destroy */ 924 g_lvol = snap; 925 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 926 CU_ASSERT(g_lvol == NULL); 927 928 /* Destroy lvol store */ 929 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 930 CU_ASSERT(g_lvserrno == 0); 931 CU_ASSERT(g_lvol_store == NULL); 932 } 933 934 static void 935 ut_lvol_hotremove(void) 936 { 937 int rc = 0; 938 939 lvol_store_initialize_fail = false; 940 lvol_store_initialize_cb_fail = false; 941 lvol_already_opened = false; 942 943 /* Lvol store is successfully created */ 944 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 945 lvol_store_op_with_handle_complete, NULL); 946 CU_ASSERT(rc == 0); 947 CU_ASSERT(g_lvserrno == 0); 948 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 949 CU_ASSERT(g_lvol_store->bs_dev != NULL); 950 951 /* Hot remove callback with NULL - stability check */ 952 vbdev_lvs_hotremove_cb(NULL); 953 954 /* Hot remove lvs on bdev removal */ 955 vbdev_lvs_hotremove_cb(&g_bdev); 956 957 CU_ASSERT(g_lvol_store == NULL); 958 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 959 960 } 961 962 static void 963 ut_lvs_examine_check(bool success) 964 { 965 struct lvol_store_bdev *lvs_bdev; 966 967 /* Examine was finished regardless of result */ 968 CU_ASSERT(g_examine_done == true); 969 g_examine_done = false; 970 971 if (success) { 972 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 973 lvs_bdev = TAILQ_FIRST(&g_spdk_lvol_pairs); 974 SPDK_CU_ASSERT_FATAL(lvs_bdev != NULL); 975 g_lvol_store = lvs_bdev->lvs; 976 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 977 CU_ASSERT(g_lvol_store->bs_dev != NULL); 978 } else { 979 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 980 g_lvol_store = NULL; 981 } 982 } 983 984 static void 985 ut_lvol_examine(void) 986 { 987 /* Examine unsuccessfully - bdev already opened */ 988 g_lvserrno = -1; 989 lvol_already_opened = true; 990 vbdev_lvs_examine(&g_bdev); 991 ut_lvs_examine_check(false); 992 993 /* Examine unsuccessfully - fail on lvol store */ 994 g_lvserrno = -1; 995 lvol_already_opened = false; 996 vbdev_lvs_examine(&g_bdev); 997 ut_lvs_examine_check(false); 998 999 /* Examine successfully 1000 * - one lvol fails to load 1001 * - lvs is loaded with no lvols present */ 1002 g_lvserrno = 0; 1003 g_lvolerrno = -1; 1004 g_num_lvols = 1; 1005 lvol_already_opened = false; 1006 g_registered_bdevs = 0; 1007 vbdev_lvs_examine(&g_bdev); 1008 ut_lvs_examine_check(true); 1009 CU_ASSERT(g_registered_bdevs == 0); 1010 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols)); 1011 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1012 CU_ASSERT(g_lvserrno == 0); 1013 CU_ASSERT(g_lvol_store == NULL); 1014 1015 /* Examine successfully */ 1016 g_lvserrno = 0; 1017 g_lvolerrno = 0; 1018 g_registered_bdevs = 0; 1019 lvol_already_opened = false; 1020 vbdev_lvs_examine(&g_bdev); 1021 ut_lvs_examine_check(true); 1022 CU_ASSERT(g_registered_bdevs != 0); 1023 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1024 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1025 CU_ASSERT(g_lvserrno == 0); 1026 } 1027 1028 static void 1029 ut_lvol_rename(void) 1030 { 1031 struct spdk_lvol_store *lvs; 1032 struct spdk_lvol *lvol; 1033 struct spdk_lvol *lvol2; 1034 int sz = 10; 1035 int rc; 1036 1037 /* Lvol store is successfully created */ 1038 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1039 lvol_store_op_with_handle_complete, NULL); 1040 CU_ASSERT(rc == 0); 1041 CU_ASSERT(g_lvserrno == 0); 1042 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1043 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1044 lvs = g_lvol_store; 1045 1046 /* Successful lvols create */ 1047 g_lvolerrno = -1; 1048 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1049 NULL); 1050 SPDK_CU_ASSERT_FATAL(rc == 0); 1051 CU_ASSERT(g_lvol != NULL); 1052 CU_ASSERT(g_lvolerrno == 0); 1053 lvol = g_lvol; 1054 1055 g_lvolerrno = -1; 1056 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1057 NULL); 1058 SPDK_CU_ASSERT_FATAL(rc == 0); 1059 CU_ASSERT(g_lvol != NULL); 1060 CU_ASSERT(g_lvolerrno == 0); 1061 lvol2 = g_lvol; 1062 1063 /* Successful rename lvol */ 1064 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1065 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1066 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1067 1068 /* Renaming lvol with name already existing */ 1069 g_bdev_alias_already_exists = true; 1070 vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1071 g_bdev_alias_already_exists = false; 1072 SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0); 1073 CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name"); 1074 1075 /* Renaming lvol with it's own name */ 1076 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1077 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1078 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1079 1080 /* Successful lvols destroy */ 1081 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1082 CU_ASSERT(g_lvol == NULL); 1083 1084 vbdev_lvol_destroy(lvol2, lvol_store_op_complete, NULL); 1085 CU_ASSERT(g_lvol == NULL); 1086 1087 /* Destroy lvol store */ 1088 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1089 CU_ASSERT(g_lvserrno == 0); 1090 CU_ASSERT(g_lvol_store == NULL); 1091 } 1092 1093 static void 1094 ut_bdev_finish(void) 1095 { 1096 struct spdk_lvol_store *lvs; 1097 struct spdk_lvol *lvol; 1098 struct spdk_lvol *lvol2; 1099 int sz = 10; 1100 int rc; 1101 1102 /* Scenario 1 1103 * Test unload of lvs with no lvols during bdev finish. */ 1104 1105 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1106 lvol_store_op_with_handle_complete, NULL); 1107 CU_ASSERT(rc == 0); 1108 CU_ASSERT(g_lvserrno == 0); 1109 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1110 lvs = g_lvol_store; 1111 1112 /* Start bdev finish */ 1113 vbdev_lvs_fini_start(); 1114 CU_ASSERT(g_shutdown_started == true); 1115 1116 /* During shutdown, lvs with no lvols should be unloaded */ 1117 CU_ASSERT(g_lvol_store == NULL); 1118 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1119 1120 /* Revert module state back to normal */ 1121 g_shutdown_started = false; 1122 1123 /* Scenario 2 1124 * Test creating lvs with two lvols. Delete first lvol explicitly, 1125 * then start bdev finish. This should unload the remaining lvol and 1126 * lvol store. */ 1127 1128 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1129 lvol_store_op_with_handle_complete, NULL); 1130 CU_ASSERT(rc == 0); 1131 CU_ASSERT(g_lvserrno == 0); 1132 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1133 lvs = g_lvol_store; 1134 1135 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1136 vbdev_lvol_create_complete, NULL); 1137 SPDK_CU_ASSERT_FATAL(rc == 0); 1138 CU_ASSERT(g_lvol != NULL); 1139 CU_ASSERT(g_lvolerrno == 0); 1140 lvol = g_lvol; 1141 1142 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1143 vbdev_lvol_create_complete, NULL); 1144 SPDK_CU_ASSERT_FATAL(rc == 0); 1145 CU_ASSERT(g_lvol != NULL); 1146 CU_ASSERT(g_lvolerrno == 0); 1147 lvol2 = g_lvol; 1148 1149 /* Destroy explicitly first lvol */ 1150 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1151 CU_ASSERT(g_lvol == NULL); 1152 CU_ASSERT(g_lvolerrno == 0); 1153 1154 /* Start bdev finish and unregister remaining lvol */ 1155 vbdev_lvs_fini_start(); 1156 CU_ASSERT(g_shutdown_started == true); 1157 spdk_bdev_unregister(lvol2->bdev, _spdk_bdev_unregister_cb, NULL); 1158 1159 /* During shutdown, removal of last lvol should unload lvs */ 1160 CU_ASSERT(g_lvol_store == NULL); 1161 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1162 1163 /* Revert module state back to normal */ 1164 g_shutdown_started = false; 1165 } 1166 1167 static void 1168 ut_lvol_resize(void) 1169 { 1170 struct spdk_lvol_store *lvs; 1171 struct spdk_lvol *lvol; 1172 int sz = 10; 1173 int rc = 0; 1174 1175 /* Lvol store is successfully created */ 1176 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1177 lvol_store_op_with_handle_complete, NULL); 1178 CU_ASSERT(rc == 0); 1179 CU_ASSERT(g_lvserrno == 0); 1180 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1181 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1182 lvs = g_lvol_store; 1183 1184 /* Successful lvol create */ 1185 g_lvolerrno = -1; 1186 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1187 NULL); 1188 CU_ASSERT(rc == 0); 1189 CU_ASSERT(g_lvolerrno == 0); 1190 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1191 lvol = g_lvol; 1192 1193 /* Successful lvol resize */ 1194 g_lvolerrno = -1; 1195 vbdev_lvol_resize(lvol, 20, vbdev_lvol_resize_complete, NULL); 1196 CU_ASSERT(g_lvolerrno == 0); 1197 CU_ASSERT(lvol->bdev->blockcnt == 20 * g_cluster_size / lvol->bdev->blocklen); 1198 1199 /* Resize with NULL lvol */ 1200 vbdev_lvol_resize(NULL, 20, vbdev_lvol_resize_complete, NULL); 1201 CU_ASSERT(g_lvolerrno != 0); 1202 1203 /* Successful lvol destroy */ 1204 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1205 CU_ASSERT(g_lvol == NULL); 1206 1207 /* Destroy lvol store */ 1208 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1209 CU_ASSERT(g_lvserrno == 0); 1210 CU_ASSERT(g_lvol_store == NULL); 1211 } 1212 1213 static void 1214 ut_lvol_set_read_only(void) 1215 { 1216 struct spdk_lvol_store *lvs; 1217 struct spdk_lvol *lvol; 1218 int sz = 10; 1219 int rc = 0; 1220 1221 /* Lvol store is successfully created */ 1222 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1223 lvol_store_op_with_handle_complete, NULL); 1224 CU_ASSERT(rc == 0); 1225 CU_ASSERT(g_lvserrno == 0); 1226 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1227 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1228 lvs = g_lvol_store; 1229 1230 /* Successful lvol create */ 1231 g_lvolerrno = -1; 1232 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1233 NULL); 1234 CU_ASSERT(rc == 0); 1235 CU_ASSERT(g_lvolerrno == 0); 1236 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1237 lvol = g_lvol; 1238 1239 /* Successful set lvol as read only */ 1240 g_lvolerrno = -1; 1241 vbdev_lvol_set_read_only(lvol, vbdev_lvol_set_read_only_complete, NULL); 1242 CU_ASSERT(g_lvolerrno == 0); 1243 1244 /* Successful lvol destroy */ 1245 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1246 CU_ASSERT(g_lvol == NULL); 1247 1248 /* Destroy lvol store */ 1249 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1250 CU_ASSERT(g_lvserrno == 0); 1251 CU_ASSERT(g_lvol_store == NULL); 1252 } 1253 1254 static void 1255 ut_lvs_unload(void) 1256 { 1257 int rc = 0; 1258 int sz = 10; 1259 struct spdk_lvol_store *lvs; 1260 1261 /* Lvol store is successfully created */ 1262 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1263 lvol_store_op_with_handle_complete, NULL); 1264 CU_ASSERT(rc == 0); 1265 CU_ASSERT(g_lvserrno == 0); 1266 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1267 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1268 1269 lvs = g_lvol_store; 1270 g_lvol_store = NULL; 1271 1272 spdk_uuid_generate(&lvs->uuid); 1273 1274 /* Successfully create lvol, which should be destroyed with lvs later */ 1275 g_lvolerrno = -1; 1276 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1277 NULL); 1278 CU_ASSERT(rc == 0); 1279 CU_ASSERT(g_lvolerrno == 0); 1280 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1281 1282 /* Unload lvol store */ 1283 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1284 CU_ASSERT(g_lvserrno == 0); 1285 CU_ASSERT(g_lvol_store == NULL); 1286 CU_ASSERT(g_lvol != NULL); 1287 } 1288 1289 static void 1290 ut_lvs_init(void) 1291 { 1292 int rc = 0; 1293 struct spdk_lvol_store *lvs; 1294 1295 /* spdk_lvs_init() fails */ 1296 lvol_store_initialize_fail = true; 1297 1298 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1299 lvol_store_op_with_handle_complete, NULL); 1300 CU_ASSERT(rc != 0); 1301 CU_ASSERT(g_lvserrno == 0); 1302 CU_ASSERT(g_lvol_store == NULL); 1303 1304 lvol_store_initialize_fail = false; 1305 1306 /* spdk_lvs_init_cb() fails */ 1307 lvol_store_initialize_cb_fail = true; 1308 1309 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1310 lvol_store_op_with_handle_complete, NULL); 1311 CU_ASSERT(rc == 0); 1312 CU_ASSERT(g_lvserrno != 0); 1313 CU_ASSERT(g_lvol_store == NULL); 1314 1315 lvol_store_initialize_cb_fail = false; 1316 1317 /* Lvol store is successfully created */ 1318 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1319 lvol_store_op_with_handle_complete, NULL); 1320 CU_ASSERT(rc == 0); 1321 CU_ASSERT(g_lvserrno == 0); 1322 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1323 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1324 1325 lvs = g_lvol_store; 1326 g_lvol_store = NULL; 1327 1328 /* Bdev with lvol store already claimed */ 1329 rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1330 lvol_store_op_with_handle_complete, NULL); 1331 CU_ASSERT(rc != 0); 1332 CU_ASSERT(g_lvserrno == 0); 1333 CU_ASSERT(g_lvol_store == NULL); 1334 1335 /* Destruct lvol store */ 1336 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1337 CU_ASSERT(g_lvserrno == 0); 1338 CU_ASSERT(g_lvol_store == NULL); 1339 } 1340 1341 static void 1342 ut_vbdev_lvol_get_io_channel(void) 1343 { 1344 struct spdk_io_channel *ch; 1345 1346 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1347 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1348 1349 ch = vbdev_lvol_get_io_channel(g_lvol); 1350 CU_ASSERT(ch == g_ch); 1351 1352 free(g_lvol); 1353 } 1354 1355 static void 1356 ut_vbdev_lvol_io_type_supported(void) 1357 { 1358 struct spdk_lvol *lvol; 1359 bool ret; 1360 1361 lvol = calloc(1, sizeof(struct spdk_lvol)); 1362 SPDK_CU_ASSERT_FATAL(lvol != NULL); 1363 1364 g_blob_is_read_only = false; 1365 1366 /* Supported types */ 1367 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1368 CU_ASSERT(ret == true); 1369 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1370 CU_ASSERT(ret == true); 1371 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1372 CU_ASSERT(ret == true); 1373 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1374 CU_ASSERT(ret == true); 1375 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1376 CU_ASSERT(ret == true); 1377 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1378 CU_ASSERT(ret == true); 1379 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1380 CU_ASSERT(ret == true); 1381 1382 /* Unsupported types */ 1383 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1384 CU_ASSERT(ret == false); 1385 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1386 CU_ASSERT(ret == false); 1387 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1388 CU_ASSERT(ret == false); 1389 1390 g_blob_is_read_only = true; 1391 1392 /* Supported types */ 1393 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1394 CU_ASSERT(ret == true); 1395 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1396 CU_ASSERT(ret == true); 1397 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1398 CU_ASSERT(ret == true); 1399 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1400 CU_ASSERT(ret == true); 1401 1402 /* Unsupported types */ 1403 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1404 CU_ASSERT(ret == false); 1405 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1406 CU_ASSERT(ret == false); 1407 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1408 CU_ASSERT(ret == false); 1409 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1410 CU_ASSERT(ret == false); 1411 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1412 CU_ASSERT(ret == false); 1413 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1414 CU_ASSERT(ret == false); 1415 1416 free(lvol); 1417 } 1418 1419 static void 1420 ut_lvol_read_write(void) 1421 { 1422 struct spdk_bdev_ext_io_opts bdev_ext_opts = {}; 1423 1424 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1425 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1426 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1427 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1428 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1429 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1430 1431 g_io->bdev = g_base_bdev; 1432 g_io->bdev->ctxt = g_lvol; 1433 g_io->u.bdev.offset_blocks = 20; 1434 g_io->u.bdev.num_blocks = 20; 1435 1436 lvol_read(g_ch, g_io); 1437 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1438 1439 lvol_write(g_lvol, g_ch, g_io); 1440 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1441 1442 g_ext_api_called = false; 1443 g_io->u.bdev.ext_opts = &bdev_ext_opts; 1444 1445 lvol_read(g_ch, g_io); 1446 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1447 CU_ASSERT(g_ext_api_called == true); 1448 g_ext_api_called = false; 1449 1450 lvol_write(g_lvol, g_ch, g_io); 1451 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1452 CU_ASSERT(g_ext_api_called == true); 1453 g_ext_api_called = false; 1454 1455 free(g_io); 1456 free(g_base_bdev); 1457 free(g_lvol); 1458 } 1459 1460 static void 1461 ut_vbdev_lvol_submit_request(void) 1462 { 1463 struct spdk_lvol request_lvol = {}; 1464 g_io = calloc(1, sizeof(struct spdk_bdev_io)); 1465 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1466 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1467 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1468 g_io->bdev = g_base_bdev; 1469 1470 g_io->type = SPDK_BDEV_IO_TYPE_READ; 1471 g_base_bdev->ctxt = &request_lvol; 1472 vbdev_lvol_submit_request(g_ch, g_io); 1473 1474 free(g_io); 1475 free(g_base_bdev); 1476 } 1477 1478 static void 1479 ut_lvs_rename(void) 1480 { 1481 int rc = 0; 1482 int sz = 10; 1483 struct spdk_lvol_store *lvs; 1484 1485 /* Lvol store is successfully created */ 1486 rc = vbdev_lvs_create("bdev", "old_lvs_name", 0, LVS_CLEAR_WITH_UNMAP, 0, 1487 lvol_store_op_with_handle_complete, NULL); 1488 CU_ASSERT(rc == 0); 1489 CU_ASSERT(g_lvserrno == 0); 1490 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1491 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1492 1493 lvs = g_lvol_store; 1494 g_lvol_store = NULL; 1495 1496 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1497 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1498 1499 /* Successfully create lvol, which should be destroyed with lvs later */ 1500 g_lvolerrno = -1; 1501 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1502 NULL); 1503 CU_ASSERT(rc == 0); 1504 CU_ASSERT(g_lvolerrno == 0); 1505 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1506 1507 /* Trying to rename lvs with lvols created */ 1508 vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL); 1509 CU_ASSERT(g_lvserrno == 0); 1510 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1511 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1512 1513 /* Trying to rename lvs with name already used by another lvs */ 1514 /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates 1515 * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */ 1516 g_lvs_with_name_already_exists = true; 1517 vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL); 1518 CU_ASSERT(g_lvserrno == -EEXIST); 1519 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1520 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1521 g_lvs_with_name_already_exists = false; 1522 1523 /* Unload lvol store */ 1524 g_lvol_store = lvs; 1525 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1526 CU_ASSERT(g_lvserrno == 0); 1527 CU_ASSERT(g_lvol_store == NULL); 1528 1529 free(g_base_bdev->name); 1530 free(g_base_bdev); 1531 } 1532 1533 static void 1534 ut_lvol_seek(void) 1535 { 1536 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1537 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1538 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1539 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1540 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1541 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1542 1543 g_io->bdev = g_base_bdev; 1544 g_io->bdev->ctxt = g_lvol; 1545 1546 /* Data found */ 1547 g_io->u.bdev.offset_blocks = 10; 1548 lvol_seek_data(g_lvol, g_io); 1549 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1550 CU_ASSERT(g_io->u.bdev.seek.offset == g_blob_allocated_io_unit_offset); 1551 1552 /* Data not found */ 1553 g_io->u.bdev.offset_blocks = 30; 1554 lvol_seek_data(g_lvol, g_io); 1555 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1556 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1557 1558 /* Hole found */ 1559 g_io->u.bdev.offset_blocks = 10; 1560 lvol_seek_hole(g_lvol, g_io); 1561 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1562 CU_ASSERT(g_io->u.bdev.seek.offset == 10); 1563 1564 /* Hole not found */ 1565 g_io->u.bdev.offset_blocks = 30; 1566 lvol_seek_hole(g_lvol, g_io); 1567 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1568 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1569 1570 free(g_io); 1571 free(g_base_bdev); 1572 free(g_lvol); 1573 } 1574 1575 int 1576 main(int argc, char **argv) 1577 { 1578 CU_pSuite suite = NULL; 1579 unsigned int num_failures; 1580 1581 CU_set_error_action(CUEA_ABORT); 1582 CU_initialize_registry(); 1583 1584 suite = CU_add_suite("lvol", NULL, NULL); 1585 1586 CU_ADD_TEST(suite, ut_lvs_init); 1587 CU_ADD_TEST(suite, ut_lvol_init); 1588 CU_ADD_TEST(suite, ut_lvol_snapshot); 1589 CU_ADD_TEST(suite, ut_lvol_clone); 1590 CU_ADD_TEST(suite, ut_lvs_destroy); 1591 CU_ADD_TEST(suite, ut_lvs_unload); 1592 CU_ADD_TEST(suite, ut_lvol_resize); 1593 CU_ADD_TEST(suite, ut_lvol_set_read_only); 1594 CU_ADD_TEST(suite, ut_lvol_hotremove); 1595 CU_ADD_TEST(suite, ut_vbdev_lvol_get_io_channel); 1596 CU_ADD_TEST(suite, ut_vbdev_lvol_io_type_supported); 1597 CU_ADD_TEST(suite, ut_lvol_read_write); 1598 CU_ADD_TEST(suite, ut_vbdev_lvol_submit_request); 1599 CU_ADD_TEST(suite, ut_lvol_examine); 1600 CU_ADD_TEST(suite, ut_lvol_rename); 1601 CU_ADD_TEST(suite, ut_bdev_finish); 1602 CU_ADD_TEST(suite, ut_lvs_rename); 1603 CU_ADD_TEST(suite, ut_lvol_seek); 1604 1605 CU_basic_set_mode(CU_BRM_VERBOSE); 1606 CU_basic_run_tests(); 1607 num_failures = CU_get_number_of_failures(); 1608 CU_cleanup_registry(); 1609 return num_failures; 1610 } 1611