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