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