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