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 CU_ASSERT(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 CU_ASSERT(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 CU_ASSERT(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 with NULL bdev */ 947 vbdev_lvs_examine(NULL); 948 CU_ASSERT(g_bs_dev == NULL); 949 CU_ASSERT(g_lvol_store == NULL); 950 CU_ASSERT(g_examine_done == true); 951 952 /* Examine unsuccessfully - bdev already opened */ 953 g_bs_dev = NULL; 954 g_examine_done = false; 955 g_lvserrno = -1; 956 lvol_already_opened = true; 957 vbdev_lvs_examine(&g_bdev); 958 CU_ASSERT(g_bs_dev == NULL); 959 CU_ASSERT(g_lvol_store == NULL); 960 CU_ASSERT(g_examine_done == true); 961 962 /* Examine unsuccessfully - fail on lvol store */ 963 g_bs_dev = NULL; 964 g_examine_done = false; 965 g_lvserrno = -1; 966 lvol_already_opened = false; 967 vbdev_lvs_examine(&g_bdev); 968 CU_ASSERT(g_bs_dev != NULL); 969 CU_ASSERT(g_lvol_store == NULL); 970 CU_ASSERT(g_examine_done == true); 971 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 972 free(g_bs_dev); 973 974 /* Examine unsuccesfully - fail on lvol load */ 975 g_bs_dev = NULL; 976 g_lvserrno = 0; 977 g_lvolerrno = -1; 978 g_num_lvols = 1; 979 g_examine_done = false; 980 lvol_already_opened = false; 981 g_registered_bdevs = 0; 982 vbdev_lvs_examine(&g_bdev); 983 CU_ASSERT(g_bs_dev != NULL); 984 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 985 CU_ASSERT(g_examine_done == true); 986 CU_ASSERT(g_registered_bdevs == 0); 987 CU_ASSERT(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 988 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols)); 989 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 990 free(g_bs_dev); 991 992 /* Examine succesfully */ 993 g_lvs = calloc(1, sizeof(*g_lvs)); 994 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 995 TAILQ_INIT(&g_lvs->lvols); 996 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 997 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 998 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 999 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1000 1001 /* Assign name to lvs */ 1002 snprintf(g_lvs->name, sizeof(g_lvs->name), "UNIT_TEST_LVS_NAME"); 1003 SPDK_CU_ASSERT_FATAL(g_lvs->name != NULL); 1004 1005 g_bs_dev = NULL; 1006 g_lvserrno = 0; 1007 g_lvolerrno = 0; 1008 g_examine_done = false; 1009 g_registered_bdevs = 0; 1010 lvol_already_opened = false; 1011 vbdev_lvs_examine(&g_bdev); 1012 CU_ASSERT(g_bs_dev != NULL); 1013 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1014 CU_ASSERT(g_examine_done == true); 1015 CU_ASSERT(g_registered_bdevs != 0); 1016 CU_ASSERT(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1017 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1018 TAILQ_FIRST(&g_lvol_store->lvols)->ref_count--; 1019 bdev = TAILQ_FIRST(&g_lvol_store->lvols)->bdev; 1020 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1021 free(bdev->name); 1022 free(bdev); 1023 free(g_bs_dev); 1024 free(g_lvol_store); 1025 1026 free(g_lvs); 1027 free(g_lvs_bdev); 1028 free(g_base_bdev); 1029 } 1030 1031 static void 1032 ut_lvol_rename(void) 1033 { 1034 struct spdk_lvol *lvol; 1035 struct spdk_lvol *lvol2; 1036 int sz = 10; 1037 int rc; 1038 1039 g_lvs = calloc(1, sizeof(*g_lvs)); 1040 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 1041 TAILQ_INIT(&g_lvs->lvols); 1042 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 1043 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 1044 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1045 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1046 1047 /* Assign name to lvs */ 1048 snprintf(g_lvs->name, sizeof(g_lvs->name), "UNIT_TEST_LVS_NAME"); 1049 SPDK_CU_ASSERT_FATAL(g_lvs->name != NULL); 1050 1051 g_lvs_bdev->lvs = g_lvs; 1052 g_lvs_bdev->bdev = g_base_bdev; 1053 1054 spdk_uuid_generate(&g_lvs->uuid); 1055 1056 TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1057 1058 /* Successful lvols create */ 1059 g_lvolerrno = -1; 1060 rc = vbdev_lvol_create(g_lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1061 SPDK_CU_ASSERT_FATAL(rc == 0); 1062 CU_ASSERT(g_lvol != NULL); 1063 CU_ASSERT(g_lvolerrno == 0); 1064 lvol = g_lvol; 1065 1066 g_lvolerrno = -1; 1067 rc = vbdev_lvol_create(g_lvs, "lvol2", sz, false, vbdev_lvol_create_complete, NULL); 1068 SPDK_CU_ASSERT_FATAL(rc == 0); 1069 CU_ASSERT(g_lvol != NULL); 1070 CU_ASSERT(g_lvolerrno == 0); 1071 lvol2 = g_lvol; 1072 1073 /* Successful rename lvol */ 1074 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1075 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1076 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1077 1078 /* Renaming lvol with name already existing */ 1079 g_bdev_alias_already_exists = true; 1080 vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1081 g_bdev_alias_already_exists = false; 1082 SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0); 1083 CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name"); 1084 1085 /* Renaming lvol with it's own name */ 1086 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1087 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1088 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1089 1090 /* Successful lvols destruct */ 1091 g_lvol = lvol; 1092 vbdev_lvol_destruct(g_lvol); 1093 CU_ASSERT(g_lvol == NULL); 1094 1095 g_lvol = lvol2; 1096 vbdev_lvol_destruct(g_lvol); 1097 CU_ASSERT(g_lvol == NULL); 1098 1099 TAILQ_REMOVE(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1100 1101 free(g_lvs); 1102 free(g_lvs_bdev); 1103 free(g_base_bdev); 1104 } 1105 1106 static void 1107 ut_lvol_resize(void) 1108 { 1109 int sz = 10; 1110 int rc = 0; 1111 1112 g_lvs = calloc(1, sizeof(*g_lvs)); 1113 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 1114 1115 TAILQ_INIT(&g_lvs->lvols); 1116 1117 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 1118 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 1119 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1120 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1121 1122 /* Assign name to bdev */ 1123 g_base_bdev->name = strdup("UNIT_TEST_LVS_NAME/old_lvol"); 1124 SPDK_CU_ASSERT_FATAL(g_base_bdev->name != NULL); 1125 1126 g_lvs_bdev->lvs = g_lvs; 1127 g_lvs_bdev->bdev = g_base_bdev; 1128 1129 spdk_uuid_generate(&g_lvs->uuid); 1130 g_base_bdev->blocklen = 4096; 1131 TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1132 1133 /* Successful lvol create */ 1134 g_lvolerrno = -1; 1135 rc = vbdev_lvol_create(g_lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1136 CU_ASSERT(rc == 0); 1137 CU_ASSERT(g_lvolerrno == 0); 1138 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1139 1140 g_base_bdev->ctxt = g_lvol; 1141 1142 free(g_base_bdev->name); 1143 g_base_bdev->name = spdk_sprintf_alloc("%s", g_lvol->unique_id); 1144 SPDK_CU_ASSERT_FATAL(g_base_bdev->name != NULL); 1145 1146 g_lvolerrno = -1; 1147 /* Successful lvol resize */ 1148 vbdev_lvol_resize(g_lvol, 20, vbdev_lvol_resize_complete, NULL); 1149 CU_ASSERT(g_lvolerrno == 0); 1150 CU_ASSERT(g_base_bdev->blockcnt == 20 * g_cluster_size / g_base_bdev->blocklen); 1151 1152 /* Resize with NULL lvol */ 1153 vbdev_lvol_resize(NULL, 20, vbdev_lvol_resize_complete, NULL); 1154 CU_ASSERT(g_lvolerrno != 0); 1155 1156 /* Successful lvol destruct */ 1157 vbdev_lvol_destruct(g_lvol); 1158 CU_ASSERT(g_lvol == NULL); 1159 1160 TAILQ_REMOVE(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1161 free(g_lvs); 1162 free(g_lvs_bdev); 1163 free(g_base_bdev->name); 1164 free(g_base_bdev); 1165 } 1166 1167 static void 1168 ut_lvs_unload(void) 1169 { 1170 int rc = 0; 1171 int sz = 10; 1172 struct spdk_lvol_store *lvs; 1173 1174 /* Lvol store is succesfully created */ 1175 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1176 CU_ASSERT(rc == 0); 1177 CU_ASSERT(g_lvserrno == 0); 1178 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1179 CU_ASSERT(g_bs_dev != NULL); 1180 1181 /* Create g_base_dev */ 1182 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 1183 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 1184 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1185 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1186 g_lvs_bdev->bdev = g_base_bdev; 1187 1188 lvs = g_lvol_store; 1189 g_lvol_store = NULL; 1190 1191 spdk_uuid_generate(&lvs->uuid); 1192 1193 /* Suuccessfully create lvol, which should be destroyed with lvs later */ 1194 g_lvolerrno = -1; 1195 rc = vbdev_lvol_create(lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1196 CU_ASSERT(rc == 0); 1197 CU_ASSERT(g_lvolerrno == 0); 1198 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1199 1200 /* Unload lvol store */ 1201 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1202 CU_ASSERT(g_lvserrno == 0); 1203 CU_ASSERT(g_lvol_store == NULL); 1204 CU_ASSERT(g_lvol != NULL); 1205 1206 free(g_lvs_bdev); 1207 free(g_base_bdev); 1208 } 1209 1210 static void 1211 ut_lvs_init(void) 1212 { 1213 int rc = 0; 1214 struct spdk_lvol_store *lvs; 1215 struct spdk_bs_dev *bs_dev_temp; 1216 1217 /* spdk_lvs_init() fails */ 1218 lvol_store_initialize_fail = true; 1219 1220 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1221 CU_ASSERT(rc != 0); 1222 CU_ASSERT(g_lvserrno == 0); 1223 CU_ASSERT(g_lvol_store == NULL); 1224 CU_ASSERT(g_bs_dev == NULL); 1225 1226 lvol_store_initialize_fail = false; 1227 1228 /* spdk_lvs_init_cb() fails */ 1229 lvol_store_initialize_cb_fail = true; 1230 1231 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1232 CU_ASSERT(rc == 0); 1233 CU_ASSERT(g_lvserrno != 0); 1234 CU_ASSERT(g_lvol_store == NULL); 1235 CU_ASSERT(g_bs_dev == NULL); 1236 1237 lvol_store_initialize_cb_fail = false; 1238 1239 /* Lvol store is succesfully created */ 1240 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1241 CU_ASSERT(rc == 0); 1242 CU_ASSERT(g_lvserrno == 0); 1243 CU_ASSERT(g_lvol_store != NULL); 1244 CU_ASSERT(g_bs_dev != NULL); 1245 1246 lvs = g_lvol_store; 1247 g_lvol_store = NULL; 1248 bs_dev_temp = g_bs_dev; 1249 g_bs_dev = NULL; 1250 1251 /* Bdev with lvol store already claimed */ 1252 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1253 CU_ASSERT(rc != 0); 1254 CU_ASSERT(g_lvserrno == 0); 1255 CU_ASSERT(g_lvol_store == NULL); 1256 CU_ASSERT(g_bs_dev == NULL); 1257 1258 /* Destruct lvol store */ 1259 g_bs_dev = bs_dev_temp; 1260 1261 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1262 CU_ASSERT(g_lvserrno == 0); 1263 CU_ASSERT(g_lvol_store == NULL); 1264 CU_ASSERT(g_bs_dev == NULL); 1265 free(g_bs_dev); 1266 1267 } 1268 1269 static void 1270 ut_vbdev_lvol_get_io_channel(void) 1271 { 1272 struct spdk_io_channel *ch; 1273 1274 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1275 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1276 1277 ch = vbdev_lvol_get_io_channel(g_lvol); 1278 CU_ASSERT(ch == g_ch); 1279 1280 free(g_lvol); 1281 } 1282 1283 static void 1284 ut_vbdev_lvol_io_type_supported(void) 1285 { 1286 struct spdk_lvol *lvol; 1287 bool ret; 1288 1289 lvol = calloc(1, sizeof(struct spdk_lvol)); 1290 SPDK_CU_ASSERT_FATAL(lvol != NULL); 1291 1292 g_blob_is_read_only = false; 1293 1294 /* Supported types */ 1295 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1296 CU_ASSERT(ret == true); 1297 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1298 CU_ASSERT(ret == true); 1299 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1300 CU_ASSERT(ret == true); 1301 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1302 CU_ASSERT(ret == true); 1303 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1304 CU_ASSERT(ret == true); 1305 1306 /* Unsupported types */ 1307 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1308 CU_ASSERT(ret == false); 1309 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1310 CU_ASSERT(ret == false); 1311 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1312 CU_ASSERT(ret == false); 1313 1314 g_blob_is_read_only = true; 1315 1316 /* Supported types */ 1317 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1318 CU_ASSERT(ret == true); 1319 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1320 CU_ASSERT(ret == true); 1321 1322 /* Unsupported types */ 1323 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1324 CU_ASSERT(ret == false); 1325 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1326 CU_ASSERT(ret == false); 1327 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1328 CU_ASSERT(ret == false); 1329 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1330 CU_ASSERT(ret == false); 1331 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1332 CU_ASSERT(ret == false); 1333 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1334 CU_ASSERT(ret == false); 1335 1336 free(lvol); 1337 } 1338 1339 static void 1340 ut_lvol_op_comp(void) 1341 { 1342 struct lvol_task task; 1343 1344 lvol_op_comp(&task, 1); 1345 CU_ASSERT(task.status == SPDK_BDEV_IO_STATUS_FAILED); 1346 } 1347 1348 static void 1349 ut_lvol_read_write(void) 1350 { 1351 g_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct lvol_task)); 1352 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1353 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1354 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1355 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1356 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1357 1358 g_task = (struct lvol_task *)g_io->driver_ctx; 1359 g_io->bdev = g_base_bdev; 1360 g_io->bdev->ctxt = g_lvol; 1361 g_io->u.bdev.offset_blocks = 20; 1362 g_io->u.bdev.num_blocks = 20; 1363 1364 lvol_read(g_ch, g_io); 1365 CU_ASSERT(g_task->status == SPDK_BDEV_IO_STATUS_SUCCESS); 1366 1367 lvol_write(g_lvol, g_ch, g_io); 1368 CU_ASSERT(g_task->status == SPDK_BDEV_IO_STATUS_SUCCESS); 1369 1370 free(g_io); 1371 free(g_base_bdev); 1372 free(g_lvol); 1373 } 1374 1375 static void 1376 ut_vbdev_lvol_submit_request(void) 1377 { 1378 g_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct lvol_task)); 1379 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1380 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1381 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1382 g_task = (struct lvol_task *)g_io->driver_ctx; 1383 1384 g_io->bdev = g_base_bdev; 1385 1386 g_io->type = SPDK_BDEV_IO_TYPE_READ; 1387 vbdev_lvol_submit_request(g_ch, g_io); 1388 1389 free(g_io); 1390 free(g_base_bdev); 1391 } 1392 1393 static void 1394 ut_lvs_rename(void) 1395 { 1396 int rc = 0; 1397 int sz = 10; 1398 struct spdk_lvol_store *lvs; 1399 struct spdk_bs_dev *b_bdev; 1400 1401 /* Lvol store is succesfully created */ 1402 rc = vbdev_lvs_create(&g_bdev, "old_lvs_name", 0, lvol_store_op_with_handle_complete, NULL); 1403 CU_ASSERT(rc == 0); 1404 CU_ASSERT(g_lvserrno == 0); 1405 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1406 CU_ASSERT(g_bs_dev != NULL); 1407 b_bdev = g_bs_dev; 1408 1409 g_bs_dev = NULL; 1410 lvs = g_lvol_store; 1411 g_lvol_store = NULL; 1412 1413 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1414 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1415 1416 /* Successfully create lvol, which should be destroyed with lvs later */ 1417 g_lvolerrno = -1; 1418 rc = vbdev_lvol_create(lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1419 CU_ASSERT(rc == 0); 1420 CU_ASSERT(g_lvolerrno == 0); 1421 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1422 1423 /* Trying to rename lvs with lvols created */ 1424 vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL); 1425 CU_ASSERT(g_lvserrno == 0); 1426 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1427 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias, "new_lvs_name/lvol"); 1428 1429 /* Trying to rename lvs with name already used by another lvs */ 1430 /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates 1431 * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */ 1432 g_lvs_with_name_already_exists = true; 1433 vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL); 1434 CU_ASSERT(g_lvserrno == -EEXIST); 1435 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1436 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias, "new_lvs_name/lvol"); 1437 g_lvs_with_name_already_exists = false; 1438 1439 /* Unload lvol store */ 1440 g_lvol_store = lvs; 1441 g_bs_dev = b_bdev; 1442 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1443 CU_ASSERT(g_lvserrno == 0); 1444 CU_ASSERT(g_lvol_store == NULL); 1445 1446 free(g_base_bdev->name); 1447 free(g_base_bdev); 1448 } 1449 1450 int main(int argc, char **argv) 1451 { 1452 CU_pSuite suite = NULL; 1453 unsigned int num_failures; 1454 1455 if (CU_initialize_registry() != CUE_SUCCESS) { 1456 return CU_get_error(); 1457 } 1458 1459 suite = CU_add_suite("lvol", NULL, NULL); 1460 if (suite == NULL) { 1461 CU_cleanup_registry(); 1462 return CU_get_error(); 1463 } 1464 1465 if ( 1466 CU_add_test(suite, "ut_lvs_init", ut_lvs_init) == NULL || 1467 CU_add_test(suite, "ut_lvol_init", ut_lvol_init) == NULL || 1468 CU_add_test(suite, "ut_lvol_snapshot", ut_lvol_snapshot) == NULL || 1469 CU_add_test(suite, "ut_lvol_clone", ut_lvol_clone) == NULL || 1470 CU_add_test(suite, "ut_lvs_destroy", ut_lvs_destroy) == NULL || 1471 CU_add_test(suite, "ut_lvs_unload", ut_lvs_unload) == NULL || 1472 CU_add_test(suite, "ut_lvol_resize", ut_lvol_resize) == NULL || 1473 CU_add_test(suite, "lvol_hotremove", ut_lvol_hotremove) == NULL || 1474 CU_add_test(suite, "ut_vbdev_lvol_get_io_channel", ut_vbdev_lvol_get_io_channel) == NULL || 1475 CU_add_test(suite, "ut_vbdev_lvol_io_type_supported", ut_vbdev_lvol_io_type_supported) == NULL || 1476 CU_add_test(suite, "ut_lvol_op_comp", ut_lvol_op_comp) == NULL || 1477 CU_add_test(suite, "ut_lvol_read_write", ut_lvol_read_write) == NULL || 1478 CU_add_test(suite, "ut_vbdev_lvol_submit_request", ut_vbdev_lvol_submit_request) == NULL || 1479 CU_add_test(suite, "lvol_examine", ut_lvol_examine) == NULL || 1480 CU_add_test(suite, "ut_lvol_rename", ut_lvol_rename) == NULL || 1481 CU_add_test(suite, "ut_lvs_rename", ut_lvs_rename) == NULL 1482 ) { 1483 CU_cleanup_registry(); 1484 return CU_get_error(); 1485 } 1486 1487 CU_basic_set_mode(CU_BRM_VERBOSE); 1488 CU_basic_run_tests(); 1489 num_failures = CU_get_number_of_failures(); 1490 CU_cleanup_registry(); 1491 return num_failures; 1492 } 1493