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