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