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