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