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