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