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