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