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 struct spdk_bs_dev * 297 spdk_bdev_create_bs_dev(struct spdk_bdev *bdev, spdk_bdev_remove_cb_t remove_cb, void *remove_ctx) 298 { 299 struct spdk_bs_dev *bs_dev; 300 301 if (lvol_already_opened == true || bdev == NULL) { 302 return NULL; 303 } 304 305 bs_dev = calloc(1, sizeof(*bs_dev)); 306 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 307 bs_dev->destroy = bdev_blob_destroy; 308 309 return bs_dev; 310 } 311 312 void 313 spdk_lvs_opts_init(struct spdk_lvs_opts *opts) 314 { 315 } 316 317 int 318 spdk_lvs_init(struct spdk_bs_dev *bs_dev, struct spdk_lvs_opts *o, 319 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 320 { 321 struct spdk_lvol_store *lvs; 322 int error = 0; 323 324 if (lvol_store_initialize_fail) { 325 return -1; 326 } 327 328 if (lvol_store_initialize_cb_fail) { 329 bs_dev->destroy(bs_dev); 330 lvs = NULL; 331 error = -1; 332 } else { 333 lvs = calloc(1, sizeof(*lvs)); 334 SPDK_CU_ASSERT_FATAL(lvs != NULL); 335 TAILQ_INIT(&lvs->lvols); 336 TAILQ_INIT(&lvs->pending_lvols); 337 spdk_uuid_generate(&lvs->uuid); 338 snprintf(lvs->name, sizeof(lvs->name), "%s", o->name); 339 lvs->bs_dev = bs_dev; 340 error = 0; 341 } 342 cb_fn(cb_arg, lvs, error); 343 344 return 0; 345 } 346 347 int 348 spdk_lvs_unload(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, void *cb_arg) 349 { 350 struct spdk_lvol *lvol, *tmp; 351 352 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 353 TAILQ_REMOVE(&lvs->lvols, lvol, link); 354 free(lvol); 355 } 356 g_lvol_store = NULL; 357 358 lvs->bs_dev->destroy(lvs->bs_dev); 359 free(lvs); 360 361 if (cb_fn != NULL) { 362 cb_fn(cb_arg, 0); 363 } 364 365 return 0; 366 } 367 368 int 369 spdk_lvs_destroy(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, 370 void *cb_arg) 371 { 372 struct spdk_lvol *lvol, *tmp; 373 char *alias; 374 375 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 376 TAILQ_REMOVE(&lvs->lvols, lvol, link); 377 378 alias = spdk_sprintf_alloc("%s/%s", lvs->name, lvol->name); 379 if (alias == NULL) { 380 SPDK_ERRLOG("Cannot alloc memory for alias\n"); 381 return -1; 382 } 383 spdk_bdev_alias_del(lvol->bdev, alias); 384 385 free(alias); 386 free(lvol); 387 } 388 g_lvol_store = NULL; 389 390 lvs->bs_dev->destroy(lvs->bs_dev); 391 free(lvs); 392 393 if (cb_fn != NULL) { 394 cb_fn(cb_arg, 0); 395 } 396 397 return 0; 398 } 399 400 void 401 spdk_lvol_resize(struct spdk_lvol *lvol, size_t sz, spdk_lvol_op_complete cb_fn, void *cb_arg) 402 { 403 cb_fn(cb_arg, 0); 404 } 405 406 void 407 spdk_lvol_set_read_only(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 408 { 409 cb_fn(cb_arg, 0); 410 } 411 412 int 413 spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size) 414 { 415 bdev->blockcnt = size; 416 return 0; 417 } 418 419 uint64_t 420 spdk_bs_get_cluster_size(struct spdk_blob_store *bs) 421 { 422 return g_cluster_size; 423 } 424 425 struct spdk_bdev * 426 spdk_bdev_get_by_name(const char *bdev_name) 427 { 428 if (!strcmp(g_base_bdev->name, bdev_name)) { 429 return g_base_bdev; 430 } 431 432 return NULL; 433 } 434 435 void 436 spdk_lvol_close(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 437 { 438 lvol->ref_count--; 439 440 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 441 cb_fn(cb_arg, 0); 442 } 443 444 bool 445 spdk_lvol_deletable(struct spdk_lvol *lvol) 446 { 447 return true; 448 } 449 450 void 451 spdk_lvol_destroy(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 452 { 453 if (lvol->ref_count != 0) { 454 cb_fn(cb_arg, -ENODEV); 455 } 456 457 TAILQ_REMOVE(&lvol->lvol_store->lvols, lvol, link); 458 459 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 460 cb_fn(cb_arg, 0); 461 462 g_lvol = NULL; 463 free(lvol); 464 } 465 466 void 467 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 468 { 469 bdev_io->internal.status = status; 470 } 471 472 struct spdk_io_channel *spdk_lvol_get_io_channel(struct spdk_lvol *lvol) 473 { 474 CU_ASSERT(lvol == g_lvol); 475 return g_ch; 476 } 477 478 void 479 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 480 { 481 CU_ASSERT(cb == lvol_get_buf_cb); 482 } 483 484 void 485 spdk_blob_io_read(struct spdk_blob *blob, struct spdk_io_channel *channel, 486 void *payload, uint64_t offset, uint64_t length, 487 spdk_blob_op_complete cb_fn, void *cb_arg) 488 { 489 CU_ASSERT(blob == NULL); 490 CU_ASSERT(channel == g_ch); 491 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 492 CU_ASSERT(length == g_io->u.bdev.num_blocks); 493 cb_fn(cb_arg, 0); 494 } 495 496 void 497 spdk_blob_io_write(struct spdk_blob *blob, struct spdk_io_channel *channel, 498 void *payload, uint64_t offset, uint64_t length, 499 spdk_blob_op_complete cb_fn, void *cb_arg) 500 { 501 CU_ASSERT(blob == NULL); 502 CU_ASSERT(channel == g_ch); 503 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 504 CU_ASSERT(length == g_io->u.bdev.num_blocks); 505 cb_fn(cb_arg, 0); 506 } 507 508 void 509 spdk_blob_io_unmap(struct spdk_blob *blob, struct spdk_io_channel *channel, 510 uint64_t offset, uint64_t length, 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_zeroes(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_writev(struct spdk_blob *blob, struct spdk_io_channel *channel, 532 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 533 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_readv(struct spdk_blob *blob, struct spdk_io_channel *channel, 544 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 545 spdk_blob_op_complete cb_fn, void *cb_arg) 546 { 547 CU_ASSERT(blob == NULL); 548 CU_ASSERT(channel == g_ch); 549 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 550 CU_ASSERT(length == g_io->u.bdev.num_blocks); 551 cb_fn(cb_arg, 0); 552 } 553 554 void 555 spdk_bdev_module_list_add(struct spdk_bdev_module *bdev_module) 556 { 557 } 558 559 const char * 560 spdk_bdev_get_name(const struct spdk_bdev *bdev) 561 { 562 return "test"; 563 } 564 565 int 566 spdk_bdev_register(struct spdk_bdev *vbdev) 567 { 568 TAILQ_INIT(&vbdev->aliases); 569 570 g_registered_bdevs++; 571 return 0; 572 } 573 574 void 575 spdk_bdev_module_examine_done(struct spdk_bdev_module *module) 576 { 577 SPDK_CU_ASSERT_FATAL(g_examine_done != true); 578 g_examine_done = true; 579 } 580 581 static struct spdk_lvol * 582 _lvol_create(struct spdk_lvol_store *lvs) 583 { 584 struct spdk_lvol *lvol = calloc(1, sizeof(*lvol)); 585 586 SPDK_CU_ASSERT_FATAL(lvol != NULL); 587 588 lvol->lvol_store = lvs; 589 lvol->ref_count++; 590 snprintf(lvol->unique_id, sizeof(lvol->unique_id), "%s", "UNIT_TEST_UUID"); 591 592 TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link); 593 594 return lvol; 595 } 596 597 int 598 spdk_lvol_create(struct spdk_lvol_store *lvs, const char *name, size_t sz, 599 bool thin_provision, enum lvol_clear_method clear_method, spdk_lvol_op_with_handle_complete cb_fn, 600 void *cb_arg) 601 { 602 struct spdk_lvol *lvol; 603 604 lvol = _lvol_create(lvs); 605 snprintf(lvol->name, sizeof(lvol->name), "%s", name); 606 cb_fn(cb_arg, lvol, 0); 607 608 return 0; 609 } 610 611 void 612 spdk_lvol_create_snapshot(struct spdk_lvol *lvol, const char *snapshot_name, 613 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 614 { 615 struct spdk_lvol *snap; 616 617 snap = _lvol_create(lvol->lvol_store); 618 snprintf(snap->name, sizeof(snap->name), "%s", snapshot_name); 619 cb_fn(cb_arg, snap, 0); 620 } 621 622 void 623 spdk_lvol_create_clone(struct spdk_lvol *lvol, const char *clone_name, 624 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 625 { 626 struct spdk_lvol *clone; 627 628 clone = _lvol_create(lvol->lvol_store); 629 snprintf(clone->name, sizeof(clone->name), "%s", clone_name); 630 cb_fn(cb_arg, clone, 0); 631 } 632 633 static void 634 lvol_store_op_complete(void *cb_arg, int lvserrno) 635 { 636 g_lvserrno = lvserrno; 637 return; 638 } 639 640 static void 641 lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno) 642 { 643 g_lvserrno = lvserrno; 644 g_lvol_store = lvs; 645 return; 646 } 647 648 static void 649 vbdev_lvol_create_complete(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) 650 { 651 g_lvolerrno = lvolerrno; 652 g_lvol = lvol; 653 } 654 655 static void 656 vbdev_lvol_resize_complete(void *cb_arg, int lvolerrno) 657 { 658 g_lvolerrno = lvolerrno; 659 } 660 661 static void 662 vbdev_lvol_set_read_only_complete(void *cb_arg, int lvolerrno) 663 { 664 g_lvolerrno = lvolerrno; 665 } 666 667 static void 668 vbdev_lvol_rename_complete(void *cb_arg, int lvolerrno) 669 { 670 g_lvolerrno = lvolerrno; 671 } 672 673 static void 674 ut_lvs_destroy(void) 675 { 676 int rc = 0; 677 int sz = 10; 678 struct spdk_lvol_store *lvs; 679 680 /* Lvol store is successfully created */ 681 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 682 NULL); 683 CU_ASSERT(rc == 0); 684 CU_ASSERT(g_lvserrno == 0); 685 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 686 CU_ASSERT(g_lvol_store->bs_dev != NULL); 687 688 lvs = g_lvol_store; 689 g_lvol_store = NULL; 690 691 spdk_uuid_generate(&lvs->uuid); 692 693 /* Successfully create lvol, which should be unloaded with lvs later */ 694 g_lvolerrno = -1; 695 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 696 NULL); 697 CU_ASSERT(rc == 0); 698 CU_ASSERT(g_lvolerrno == 0); 699 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 700 701 /* Unload lvol store */ 702 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 703 CU_ASSERT(g_lvserrno == 0); 704 CU_ASSERT(g_lvol_store == NULL); 705 } 706 707 static void 708 ut_lvol_init(void) 709 { 710 struct spdk_lvol_store *lvs; 711 int sz = 10; 712 int rc; 713 714 /* Lvol store is successfully created */ 715 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 716 NULL); 717 CU_ASSERT(rc == 0); 718 CU_ASSERT(g_lvserrno == 0); 719 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 720 CU_ASSERT(g_lvol_store->bs_dev != NULL); 721 lvs = g_lvol_store; 722 723 /* Successful lvol create */ 724 g_lvolerrno = -1; 725 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 726 NULL); 727 SPDK_CU_ASSERT_FATAL(rc == 0); 728 CU_ASSERT(g_lvol != NULL); 729 CU_ASSERT(g_lvolerrno == 0); 730 731 /* Successful lvol destroy */ 732 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 733 CU_ASSERT(g_lvol == NULL); 734 735 /* Destroy lvol store */ 736 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 737 CU_ASSERT(g_lvserrno == 0); 738 CU_ASSERT(g_lvol_store == NULL); 739 } 740 741 static void 742 ut_lvol_snapshot(void) 743 { 744 struct spdk_lvol_store *lvs; 745 int sz = 10; 746 int rc; 747 struct spdk_lvol *lvol = NULL; 748 749 /* Lvol store is successfully created */ 750 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 751 NULL); 752 CU_ASSERT(rc == 0); 753 CU_ASSERT(g_lvserrno == 0); 754 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 755 CU_ASSERT(g_lvol_store->bs_dev != NULL); 756 lvs = g_lvol_store; 757 758 /* Successful lvol create */ 759 g_lvolerrno = -1; 760 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 761 NULL); 762 SPDK_CU_ASSERT_FATAL(rc == 0); 763 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 764 CU_ASSERT(g_lvolerrno == 0); 765 766 lvol = g_lvol; 767 768 /* Successful snap create */ 769 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 770 SPDK_CU_ASSERT_FATAL(rc == 0); 771 CU_ASSERT(g_lvol != NULL); 772 CU_ASSERT(g_lvolerrno == 0); 773 774 /* Successful lvol destroy */ 775 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 776 CU_ASSERT(g_lvol == NULL); 777 778 /* Successful snap destroy */ 779 g_lvol = lvol; 780 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 781 CU_ASSERT(g_lvol == NULL); 782 783 /* Destroy lvol store */ 784 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 785 CU_ASSERT(g_lvserrno == 0); 786 CU_ASSERT(g_lvol_store == NULL); 787 } 788 789 static void 790 ut_lvol_clone(void) 791 { 792 struct spdk_lvol_store *lvs; 793 int sz = 10; 794 int rc; 795 struct spdk_lvol *lvol = NULL; 796 struct spdk_lvol *snap = NULL; 797 struct spdk_lvol *clone = NULL; 798 799 /* Lvol store is successfully created */ 800 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 801 NULL); 802 CU_ASSERT(rc == 0); 803 CU_ASSERT(g_lvserrno == 0); 804 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 805 CU_ASSERT(g_lvol_store->bs_dev != NULL); 806 lvs = g_lvol_store; 807 808 /* Successful lvol create */ 809 g_lvolerrno = -1; 810 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 811 NULL); 812 SPDK_CU_ASSERT_FATAL(rc == 0); 813 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 814 CU_ASSERT(g_lvolerrno == 0); 815 816 lvol = g_lvol; 817 818 /* Successful snap create */ 819 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 820 SPDK_CU_ASSERT_FATAL(rc == 0); 821 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 822 CU_ASSERT(g_lvolerrno == 0); 823 824 snap = g_lvol; 825 826 /* Successful clone create */ 827 vbdev_lvol_create_clone(snap, "clone", vbdev_lvol_create_complete, NULL); 828 829 SPDK_CU_ASSERT_FATAL(rc == 0); 830 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 831 CU_ASSERT(g_lvolerrno == 0); 832 833 clone = g_lvol; 834 835 /* Successful lvol destroy */ 836 g_lvol = lvol; 837 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 838 CU_ASSERT(g_lvol == NULL); 839 840 /* Successful clone destroy */ 841 g_lvol = clone; 842 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 843 CU_ASSERT(g_lvol == NULL); 844 845 /* Successful lvol destroy */ 846 g_lvol = snap; 847 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 848 CU_ASSERT(g_lvol == NULL); 849 850 /* Destroy lvol store */ 851 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 852 CU_ASSERT(g_lvserrno == 0); 853 CU_ASSERT(g_lvol_store == NULL); 854 } 855 856 static void 857 ut_lvol_hotremove(void) 858 { 859 int rc = 0; 860 861 lvol_store_initialize_fail = false; 862 lvol_store_initialize_cb_fail = false; 863 lvol_already_opened = false; 864 865 /* Lvol store is successfully created */ 866 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 867 NULL); 868 CU_ASSERT(rc == 0); 869 CU_ASSERT(g_lvserrno == 0); 870 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 871 CU_ASSERT(g_lvol_store->bs_dev != NULL); 872 873 /* Hot remove callback with NULL - stability check */ 874 vbdev_lvs_hotremove_cb(NULL); 875 876 /* Hot remove lvs on bdev removal */ 877 vbdev_lvs_hotremove_cb(&g_bdev); 878 879 CU_ASSERT(g_lvol_store == NULL); 880 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 881 882 } 883 884 static void 885 ut_lvs_examine_check(bool success) 886 { 887 struct lvol_store_bdev *lvs_bdev; 888 889 /* Examine was finished regardless of result */ 890 CU_ASSERT(g_examine_done == true); 891 g_examine_done = false; 892 893 if (success) { 894 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 895 lvs_bdev = TAILQ_FIRST(&g_spdk_lvol_pairs); 896 SPDK_CU_ASSERT_FATAL(lvs_bdev != NULL); 897 g_lvol_store = lvs_bdev->lvs; 898 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 899 CU_ASSERT(g_lvol_store->bs_dev != NULL); 900 } else { 901 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 902 g_lvol_store = NULL; 903 } 904 } 905 906 static void 907 ut_lvol_examine(void) 908 { 909 /* Examine unsuccessfully - bdev already opened */ 910 g_lvserrno = -1; 911 lvol_already_opened = true; 912 vbdev_lvs_examine(&g_bdev); 913 ut_lvs_examine_check(false); 914 915 /* Examine unsuccessfully - fail on lvol store */ 916 g_lvserrno = -1; 917 lvol_already_opened = false; 918 vbdev_lvs_examine(&g_bdev); 919 ut_lvs_examine_check(false); 920 921 /* Examine successfully 922 * - one lvol fails to load 923 * - lvs is loaded with no lvols present */ 924 g_lvserrno = 0; 925 g_lvolerrno = -1; 926 g_num_lvols = 1; 927 lvol_already_opened = false; 928 g_registered_bdevs = 0; 929 vbdev_lvs_examine(&g_bdev); 930 ut_lvs_examine_check(true); 931 CU_ASSERT(g_registered_bdevs == 0); 932 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols)); 933 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 934 CU_ASSERT(g_lvserrno == 0); 935 CU_ASSERT(g_lvol_store == NULL); 936 937 /* Examine successfully */ 938 g_lvserrno = 0; 939 g_lvolerrno = 0; 940 g_registered_bdevs = 0; 941 lvol_already_opened = false; 942 vbdev_lvs_examine(&g_bdev); 943 ut_lvs_examine_check(true); 944 CU_ASSERT(g_registered_bdevs != 0); 945 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 946 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 947 CU_ASSERT(g_lvserrno == 0); 948 } 949 950 static void 951 ut_lvol_rename(void) 952 { 953 struct spdk_lvol_store *lvs; 954 struct spdk_lvol *lvol; 955 struct spdk_lvol *lvol2; 956 int sz = 10; 957 int rc; 958 959 /* Lvol store is successfully created */ 960 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 961 NULL); 962 CU_ASSERT(rc == 0); 963 CU_ASSERT(g_lvserrno == 0); 964 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 965 CU_ASSERT(g_lvol_store->bs_dev != NULL); 966 lvs = g_lvol_store; 967 968 /* Successful lvols create */ 969 g_lvolerrno = -1; 970 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 971 NULL); 972 SPDK_CU_ASSERT_FATAL(rc == 0); 973 CU_ASSERT(g_lvol != NULL); 974 CU_ASSERT(g_lvolerrno == 0); 975 lvol = g_lvol; 976 977 g_lvolerrno = -1; 978 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 979 NULL); 980 SPDK_CU_ASSERT_FATAL(rc == 0); 981 CU_ASSERT(g_lvol != NULL); 982 CU_ASSERT(g_lvolerrno == 0); 983 lvol2 = g_lvol; 984 985 /* Successful rename lvol */ 986 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 987 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 988 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 989 990 /* Renaming lvol with name already existing */ 991 g_bdev_alias_already_exists = true; 992 vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 993 g_bdev_alias_already_exists = false; 994 SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0); 995 CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name"); 996 997 /* Renaming lvol with it's own name */ 998 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 999 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1000 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1001 1002 /* Successful lvols destroy */ 1003 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1004 CU_ASSERT(g_lvol == NULL); 1005 1006 vbdev_lvol_destroy(lvol2, lvol_store_op_complete, NULL); 1007 CU_ASSERT(g_lvol == NULL); 1008 1009 /* Destroy lvol store */ 1010 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1011 CU_ASSERT(g_lvserrno == 0); 1012 CU_ASSERT(g_lvol_store == NULL); 1013 } 1014 1015 static void 1016 ut_lvol_destroy(void) 1017 { 1018 struct spdk_lvol_store *lvs; 1019 struct spdk_lvol *lvol; 1020 struct spdk_lvol *lvol2; 1021 int sz = 10; 1022 int rc; 1023 1024 /* Lvol store is successfully created */ 1025 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 1026 NULL); 1027 CU_ASSERT(rc == 0); 1028 CU_ASSERT(g_lvserrno == 0); 1029 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1030 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1031 lvs = g_lvol_store; 1032 1033 /* Successful lvols create */ 1034 g_lvolerrno = -1; 1035 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1036 NULL); 1037 SPDK_CU_ASSERT_FATAL(rc == 0); 1038 CU_ASSERT(g_lvol != NULL); 1039 CU_ASSERT(g_lvolerrno == 0); 1040 lvol = g_lvol; 1041 1042 g_lvolerrno = -1; 1043 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1044 NULL); 1045 SPDK_CU_ASSERT_FATAL(rc == 0); 1046 CU_ASSERT(g_lvol != NULL); 1047 CU_ASSERT(g_lvolerrno == 0); 1048 lvol2 = g_lvol; 1049 1050 /* Successful lvols destroy */ 1051 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1052 CU_ASSERT(g_lvol == NULL); 1053 CU_ASSERT(g_lvolerrno == 0); 1054 1055 /* Hot remove lvol bdev */ 1056 vbdev_lvol_unregister(lvol2); 1057 1058 /* Unload lvol store */ 1059 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1060 CU_ASSERT(g_lvserrno == 0); 1061 CU_ASSERT(g_lvol_store == NULL); 1062 } 1063 1064 static void 1065 ut_lvol_resize(void) 1066 { 1067 struct spdk_lvol_store *lvs; 1068 struct spdk_lvol *lvol; 1069 int sz = 10; 1070 int rc = 0; 1071 1072 /* Lvol store is successfully created */ 1073 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 1074 NULL); 1075 CU_ASSERT(rc == 0); 1076 CU_ASSERT(g_lvserrno == 0); 1077 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1078 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1079 lvs = g_lvol_store; 1080 1081 /* Successful lvol create */ 1082 g_lvolerrno = -1; 1083 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1084 NULL); 1085 CU_ASSERT(rc == 0); 1086 CU_ASSERT(g_lvolerrno == 0); 1087 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1088 lvol = g_lvol; 1089 1090 /* Successful lvol resize */ 1091 g_lvolerrno = -1; 1092 vbdev_lvol_resize(lvol, 20, vbdev_lvol_resize_complete, NULL); 1093 CU_ASSERT(g_lvolerrno == 0); 1094 CU_ASSERT(lvol->bdev->blockcnt == 20 * g_cluster_size / lvol->bdev->blocklen); 1095 1096 /* Resize with NULL lvol */ 1097 vbdev_lvol_resize(NULL, 20, vbdev_lvol_resize_complete, NULL); 1098 CU_ASSERT(g_lvolerrno != 0); 1099 1100 /* Successful lvol destroy */ 1101 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1102 CU_ASSERT(g_lvol == NULL); 1103 1104 /* Destroy lvol store */ 1105 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1106 CU_ASSERT(g_lvserrno == 0); 1107 CU_ASSERT(g_lvol_store == NULL); 1108 } 1109 1110 static void 1111 ut_lvol_set_read_only(void) 1112 { 1113 struct spdk_lvol_store *lvs; 1114 struct spdk_lvol *lvol; 1115 int sz = 10; 1116 int rc = 0; 1117 1118 /* Lvol store is successfully created */ 1119 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 1120 NULL); 1121 CU_ASSERT(rc == 0); 1122 CU_ASSERT(g_lvserrno == 0); 1123 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1124 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1125 lvs = g_lvol_store; 1126 1127 /* Successful lvol create */ 1128 g_lvolerrno = -1; 1129 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1130 NULL); 1131 CU_ASSERT(rc == 0); 1132 CU_ASSERT(g_lvolerrno == 0); 1133 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1134 lvol = g_lvol; 1135 1136 /* Successful set lvol as read only */ 1137 g_lvolerrno = -1; 1138 vbdev_lvol_set_read_only(lvol, vbdev_lvol_set_read_only_complete, NULL); 1139 CU_ASSERT(g_lvolerrno == 0); 1140 1141 /* Successful lvol destroy */ 1142 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1143 CU_ASSERT(g_lvol == NULL); 1144 1145 /* Destroy lvol store */ 1146 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1147 CU_ASSERT(g_lvserrno == 0); 1148 CU_ASSERT(g_lvol_store == NULL); 1149 } 1150 1151 static void 1152 ut_lvs_unload(void) 1153 { 1154 int rc = 0; 1155 int sz = 10; 1156 struct spdk_lvol_store *lvs; 1157 1158 /* Lvol store is successfully created */ 1159 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 1160 NULL); 1161 CU_ASSERT(rc == 0); 1162 CU_ASSERT(g_lvserrno == 0); 1163 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1164 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1165 1166 lvs = g_lvol_store; 1167 g_lvol_store = NULL; 1168 1169 spdk_uuid_generate(&lvs->uuid); 1170 1171 /* Successfully create lvol, which should be destroyed with lvs later */ 1172 g_lvolerrno = -1; 1173 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1174 NULL); 1175 CU_ASSERT(rc == 0); 1176 CU_ASSERT(g_lvolerrno == 0); 1177 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1178 1179 /* Unload lvol store */ 1180 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1181 CU_ASSERT(g_lvserrno == 0); 1182 CU_ASSERT(g_lvol_store == NULL); 1183 CU_ASSERT(g_lvol != NULL); 1184 } 1185 1186 static void 1187 ut_lvs_init(void) 1188 { 1189 int rc = 0; 1190 struct spdk_lvol_store *lvs; 1191 1192 /* spdk_lvs_init() fails */ 1193 lvol_store_initialize_fail = true; 1194 1195 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 1196 NULL); 1197 CU_ASSERT(rc != 0); 1198 CU_ASSERT(g_lvserrno == 0); 1199 CU_ASSERT(g_lvol_store == NULL); 1200 1201 lvol_store_initialize_fail = false; 1202 1203 /* spdk_lvs_init_cb() fails */ 1204 lvol_store_initialize_cb_fail = true; 1205 1206 rc = vbdev_lvs_create(&g_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_cb_fail = false; 1213 1214 /* Lvol store is successfully created */ 1215 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, LVS_CLEAR_WITH_UNMAP, lvol_store_op_with_handle_complete, 1216 NULL); 1217 CU_ASSERT(rc == 0); 1218 CU_ASSERT(g_lvserrno == 0); 1219 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1220 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1221 1222 lvs = g_lvol_store; 1223 g_lvol_store = NULL; 1224 1225 /* Bdev with lvol store already claimed */ 1226 rc = vbdev_lvs_create(&g_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 CU_ASSERT(g_lvol_store == NULL); 1231 1232 /* Destruct lvol store */ 1233 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1234 CU_ASSERT(g_lvserrno == 0); 1235 CU_ASSERT(g_lvol_store == NULL); 1236 } 1237 1238 static void 1239 ut_vbdev_lvol_get_io_channel(void) 1240 { 1241 struct spdk_io_channel *ch; 1242 1243 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1244 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1245 1246 ch = vbdev_lvol_get_io_channel(g_lvol); 1247 CU_ASSERT(ch == g_ch); 1248 1249 free(g_lvol); 1250 } 1251 1252 static void 1253 ut_vbdev_lvol_io_type_supported(void) 1254 { 1255 struct spdk_lvol *lvol; 1256 bool ret; 1257 1258 lvol = calloc(1, sizeof(struct spdk_lvol)); 1259 SPDK_CU_ASSERT_FATAL(lvol != NULL); 1260 1261 g_blob_is_read_only = false; 1262 1263 /* Supported types */ 1264 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1265 CU_ASSERT(ret == true); 1266 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1267 CU_ASSERT(ret == true); 1268 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1269 CU_ASSERT(ret == true); 1270 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1271 CU_ASSERT(ret == true); 1272 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1273 CU_ASSERT(ret == true); 1274 1275 /* Unsupported types */ 1276 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1277 CU_ASSERT(ret == false); 1278 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1279 CU_ASSERT(ret == false); 1280 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1281 CU_ASSERT(ret == false); 1282 1283 g_blob_is_read_only = true; 1284 1285 /* Supported types */ 1286 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1287 CU_ASSERT(ret == true); 1288 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1289 CU_ASSERT(ret == true); 1290 1291 /* Unsupported types */ 1292 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1293 CU_ASSERT(ret == false); 1294 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1295 CU_ASSERT(ret == false); 1296 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1297 CU_ASSERT(ret == false); 1298 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1299 CU_ASSERT(ret == false); 1300 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1301 CU_ASSERT(ret == false); 1302 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1303 CU_ASSERT(ret == false); 1304 1305 free(lvol); 1306 } 1307 1308 static void 1309 ut_lvol_read_write(void) 1310 { 1311 g_io = calloc(1, sizeof(struct spdk_bdev_io)); 1312 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1313 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1314 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1315 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1316 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1317 1318 g_io->bdev = g_base_bdev; 1319 g_io->bdev->ctxt = g_lvol; 1320 g_io->u.bdev.offset_blocks = 20; 1321 g_io->u.bdev.num_blocks = 20; 1322 1323 lvol_read(g_ch, g_io); 1324 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1325 1326 lvol_write(g_lvol, g_ch, g_io); 1327 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1328 1329 free(g_io); 1330 free(g_base_bdev); 1331 free(g_lvol); 1332 } 1333 1334 static void 1335 ut_vbdev_lvol_submit_request(void) 1336 { 1337 struct spdk_lvol request_lvol = {}; 1338 g_io = calloc(1, sizeof(struct spdk_bdev_io)); 1339 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1340 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1341 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1342 g_io->bdev = g_base_bdev; 1343 1344 g_io->type = SPDK_BDEV_IO_TYPE_READ; 1345 g_base_bdev->ctxt = &request_lvol; 1346 vbdev_lvol_submit_request(g_ch, g_io); 1347 1348 free(g_io); 1349 free(g_base_bdev); 1350 } 1351 1352 static void 1353 ut_lvs_rename(void) 1354 { 1355 int rc = 0; 1356 int sz = 10; 1357 struct spdk_lvol_store *lvs; 1358 1359 /* Lvol store is successfully created */ 1360 rc = vbdev_lvs_create(&g_bdev, "old_lvs_name", 0, LVS_CLEAR_WITH_UNMAP, 1361 lvol_store_op_with_handle_complete, NULL); 1362 CU_ASSERT(rc == 0); 1363 CU_ASSERT(g_lvserrno == 0); 1364 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1365 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1366 1367 lvs = g_lvol_store; 1368 g_lvol_store = NULL; 1369 1370 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1371 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1372 1373 /* Successfully create lvol, which should be destroyed with lvs later */ 1374 g_lvolerrno = -1; 1375 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1376 NULL); 1377 CU_ASSERT(rc == 0); 1378 CU_ASSERT(g_lvolerrno == 0); 1379 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1380 1381 /* Trying to rename lvs with lvols created */ 1382 vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL); 1383 CU_ASSERT(g_lvserrno == 0); 1384 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1385 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias, "new_lvs_name/lvol"); 1386 1387 /* Trying to rename lvs with name already used by another lvs */ 1388 /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates 1389 * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */ 1390 g_lvs_with_name_already_exists = true; 1391 vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL); 1392 CU_ASSERT(g_lvserrno == -EEXIST); 1393 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1394 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias, "new_lvs_name/lvol"); 1395 g_lvs_with_name_already_exists = false; 1396 1397 /* Unload lvol store */ 1398 g_lvol_store = lvs; 1399 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1400 CU_ASSERT(g_lvserrno == 0); 1401 CU_ASSERT(g_lvol_store == NULL); 1402 1403 free(g_base_bdev->name); 1404 free(g_base_bdev); 1405 } 1406 1407 int main(int argc, char **argv) 1408 { 1409 CU_pSuite suite = NULL; 1410 unsigned int num_failures; 1411 1412 CU_set_error_action(CUEA_ABORT); 1413 CU_initialize_registry(); 1414 1415 suite = CU_add_suite("lvol", NULL, NULL); 1416 1417 CU_ADD_TEST(suite, ut_lvs_init); 1418 CU_ADD_TEST(suite, ut_lvol_init); 1419 CU_ADD_TEST(suite, ut_lvol_snapshot); 1420 CU_ADD_TEST(suite, ut_lvol_clone); 1421 CU_ADD_TEST(suite, ut_lvs_destroy); 1422 CU_ADD_TEST(suite, ut_lvs_unload); 1423 CU_ADD_TEST(suite, ut_lvol_resize); 1424 CU_ADD_TEST(suite, ut_lvol_set_read_only); 1425 CU_ADD_TEST(suite, ut_lvol_hotremove); 1426 CU_ADD_TEST(suite, ut_vbdev_lvol_get_io_channel); 1427 CU_ADD_TEST(suite, ut_vbdev_lvol_io_type_supported); 1428 CU_ADD_TEST(suite, ut_lvol_read_write); 1429 CU_ADD_TEST(suite, ut_vbdev_lvol_submit_request); 1430 CU_ADD_TEST(suite, ut_lvol_examine); 1431 CU_ADD_TEST(suite, ut_lvol_rename); 1432 CU_ADD_TEST(suite, ut_lvol_destroy); 1433 CU_ADD_TEST(suite, ut_lvs_rename); 1434 1435 CU_basic_set_mode(CU_BRM_VERBOSE); 1436 CU_basic_run_tests(); 1437 num_failures = CU_get_number_of_failures(); 1438 CU_cleanup_registry(); 1439 return num_failures; 1440 } 1441