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