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