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_internal/cunit.h" 8 #include "spdk/string.h" 9 10 #include "common/lib/ut_multithread.c" 11 #include "bdev/lvol/vbdev_lvol.c" 12 13 #include "unit/lib/json_mock.c" 14 15 #define SPDK_BS_PAGE_SIZE 0x1000 16 17 int g_lvolerrno; 18 int g_lvserrno; 19 int g_cluster_size; 20 int g_num_clusters = 0; 21 int g_registered_bdevs; 22 int g_num_lvols = 0; 23 int g_lvol_open_enomem = -1; 24 struct spdk_lvol_store *g_lvs = NULL; 25 struct spdk_lvol *g_lvol = NULL; 26 struct lvol_store_bdev *g_lvs_bdev = NULL; 27 struct spdk_bdev_io *g_io = NULL; 28 struct spdk_io_channel *g_ch = NULL; 29 30 #define DEFAULT_BDEV_NAME "bdev" 31 #define DEFAULT_BDEV_UUID "a27fd8fe-d4b9-431e-a044-271016228ce4" 32 static struct spdk_bdev g_bdev = {}; 33 static struct spdk_lvol_store *g_lvol_store = NULL; 34 bool lvol_store_initialize_fail = false; 35 bool lvol_store_initialize_cb_fail = false; 36 bool lvol_already_opened = false; 37 bool g_examine_done = false; 38 bool g_bdev_alias_already_exists = false; 39 bool g_lvs_with_name_already_exists = false; 40 bool g_ext_api_called; 41 bool g_bdev_is_missing = false; 42 43 DEFINE_STUB_V(spdk_bdev_module_fini_start_done, (void)); 44 DEFINE_STUB_V(spdk_bdev_update_bs_blockcnt, (struct spdk_bs_dev *bs_dev)); 45 DEFINE_STUB_V(spdk_lvs_grow_live, (struct spdk_lvol_store *lvs, 46 spdk_lvs_op_complete cb_fn, void *cb_arg)); 47 DEFINE_STUB(spdk_bdev_get_memory_domains, int, (struct spdk_bdev *bdev, 48 struct spdk_memory_domain **domains, int array_size), 0); 49 DEFINE_STUB(spdk_blob_get_esnap_id, int, 50 (struct spdk_blob *blob, const void **id, size_t *len), -ENOTSUP); 51 DEFINE_STUB(spdk_blob_is_esnap_clone, bool, (const struct spdk_blob *blob), false); 52 DEFINE_STUB(spdk_lvol_iter_immediate_clones, int, 53 (struct spdk_lvol *lvol, spdk_lvol_iter_cb cb_fn, void *cb_arg), -ENOTSUP); 54 DEFINE_STUB(spdk_lvs_esnap_missing_add, int, 55 (struct spdk_lvol_store *lvs, struct spdk_lvol *lvol, const void *esnap_id, 56 uint32_t id_len), -ENOTSUP); 57 DEFINE_STUB(spdk_blob_get_esnap_bs_dev, struct spdk_bs_dev *, (const struct spdk_blob *blob), NULL); 58 DEFINE_STUB(spdk_lvol_is_degraded, bool, (const struct spdk_lvol *lvol), false); 59 DEFINE_STUB(spdk_blob_get_num_allocated_clusters, uint64_t, (struct spdk_blob *blob), 0); 60 61 struct spdk_blob { 62 uint64_t id; 63 char name[32]; 64 }; 65 66 struct spdk_blob_store { 67 spdk_bs_esnap_dev_create esnap_bs_dev_create; 68 }; 69 70 const struct spdk_bdev_aliases_list * 71 spdk_bdev_get_aliases(const struct spdk_bdev *bdev) 72 { 73 return &bdev->aliases; 74 } 75 76 uint32_t 77 spdk_bdev_get_md_size(const struct spdk_bdev *bdev) 78 { 79 return bdev->md_len; 80 } 81 82 const struct spdk_uuid * 83 spdk_bdev_get_uuid(const struct spdk_bdev *bdev) 84 { 85 return &bdev->uuid; 86 } 87 88 int 89 spdk_bdev_alias_add(struct spdk_bdev *bdev, const char *alias) 90 { 91 struct spdk_bdev_alias *tmp; 92 93 CU_ASSERT(alias != NULL); 94 CU_ASSERT(bdev != NULL); 95 if (g_bdev_alias_already_exists) { 96 return -EEXIST; 97 } 98 99 tmp = calloc(1, sizeof(*tmp)); 100 SPDK_CU_ASSERT_FATAL(tmp != NULL); 101 102 tmp->alias.name = strdup(alias); 103 SPDK_CU_ASSERT_FATAL(tmp->alias.name != NULL); 104 105 TAILQ_INSERT_TAIL(&bdev->aliases, tmp, tailq); 106 107 return 0; 108 } 109 110 int 111 spdk_bdev_alias_del(struct spdk_bdev *bdev, const char *alias) 112 { 113 struct spdk_bdev_alias *tmp; 114 115 CU_ASSERT(bdev != NULL); 116 117 TAILQ_FOREACH(tmp, &bdev->aliases, tailq) { 118 SPDK_CU_ASSERT_FATAL(alias != NULL); 119 if (strncmp(alias, tmp->alias.name, SPDK_LVOL_NAME_MAX) == 0) { 120 TAILQ_REMOVE(&bdev->aliases, tmp, tailq); 121 free(tmp->alias.name); 122 free(tmp); 123 return 0; 124 } 125 } 126 127 return -ENOENT; 128 } 129 130 void 131 spdk_bdev_alias_del_all(struct spdk_bdev *bdev) 132 { 133 struct spdk_bdev_alias *p, *tmp; 134 135 TAILQ_FOREACH_SAFE(p, &bdev->aliases, tailq, tmp) { 136 TAILQ_REMOVE(&bdev->aliases, p, tailq); 137 free(p->alias.name); 138 free(p); 139 } 140 } 141 142 void 143 spdk_bdev_destruct_done(struct spdk_bdev *bdev, int bdeverrno) 144 { 145 CU_ASSERT(bdeverrno == 0); 146 SPDK_CU_ASSERT_FATAL(bdev->internal.unregister_cb != NULL); 147 bdev->internal.unregister_cb(bdev->internal.unregister_ctx, bdeverrno); 148 } 149 150 struct ut_bs_dev { 151 struct spdk_bs_dev bs_dev; 152 struct spdk_bdev *bdev; 153 }; 154 155 static void 156 ut_bs_dev_destroy(struct spdk_bs_dev *bs_dev) 157 { 158 struct ut_bs_dev *ut_bs_dev = SPDK_CONTAINEROF(bs_dev, struct ut_bs_dev, bs_dev); 159 160 free(ut_bs_dev); 161 } 162 163 static struct spdk_bdev * 164 ut_bs_dev_get_base_bdev(struct spdk_bs_dev *bs_dev) 165 { 166 struct ut_bs_dev *ut_bs_dev = SPDK_CONTAINEROF(bs_dev, struct ut_bs_dev, bs_dev); 167 return ut_bs_dev->bdev; 168 } 169 170 int 171 spdk_bdev_create_bs_dev(const char *bdev_name, bool write, 172 struct spdk_bdev_bs_dev_opts *opts, size_t opts_size, 173 spdk_bdev_event_cb_t event_cb, void *event_ctx, 174 struct spdk_bs_dev **bs_dev) 175 { 176 struct spdk_bdev *bdev; 177 struct ut_bs_dev *ut_bs_dev; 178 179 bdev = spdk_bdev_get_by_name(bdev_name); 180 if (bdev == NULL) { 181 return -ENODEV; 182 } 183 184 if (lvol_already_opened) { 185 return -EINVAL; 186 } 187 188 ut_bs_dev = calloc(1, sizeof(*ut_bs_dev)); 189 SPDK_CU_ASSERT_FATAL(ut_bs_dev != NULL); 190 191 ut_bs_dev->bs_dev.blocklen = 4096; 192 SPDK_CU_ASSERT_FATAL(SPDK_BS_PAGE_SIZE % ut_bs_dev->bs_dev.blocklen == 0); 193 ut_bs_dev->bs_dev.blockcnt = 128; 194 ut_bs_dev->bdev = bdev; 195 ut_bs_dev->bs_dev.destroy = ut_bs_dev_destroy; 196 ut_bs_dev->bs_dev.get_base_bdev = ut_bs_dev_get_base_bdev; 197 *bs_dev = &ut_bs_dev->bs_dev; 198 199 g_cluster_size = SPDK_LVS_OPTS_CLUSTER_SZ; 200 SPDK_CU_ASSERT_FATAL(g_cluster_size % SPDK_BS_PAGE_SIZE == 0); 201 g_num_clusters = spdk_divide_round_up(ut_bs_dev->bs_dev.blockcnt, g_cluster_size); 202 203 return 0; 204 } 205 206 void 207 spdk_lvs_grow(struct spdk_bs_dev *bs_dev, spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 208 { 209 cb_fn(cb_arg, NULL, -EINVAL); 210 } 211 212 void 213 spdk_lvs_rename(struct spdk_lvol_store *lvs, const char *new_name, 214 spdk_lvs_op_complete cb_fn, void *cb_arg) 215 { 216 if (g_lvs_with_name_already_exists) { 217 g_lvolerrno = -EEXIST; 218 } else { 219 snprintf(lvs->name, sizeof(lvs->name), "%s", new_name); 220 g_lvolerrno = 0; 221 } 222 223 cb_fn(cb_arg, g_lvolerrno); 224 } 225 226 void 227 spdk_lvol_rename(struct spdk_lvol *lvol, const char *new_name, 228 spdk_lvol_op_complete cb_fn, void *cb_arg) 229 { 230 struct spdk_lvol *tmp; 231 232 if (strncmp(lvol->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 233 cb_fn(cb_arg, 0); 234 return; 235 } 236 237 TAILQ_FOREACH(tmp, &lvol->lvol_store->lvols, link) { 238 if (strncmp(tmp->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 239 SPDK_ERRLOG("Lvol %s already exists in lvol store %s\n", new_name, lvol->lvol_store->name); 240 cb_fn(cb_arg, -EEXIST); 241 return; 242 } 243 } 244 245 snprintf(lvol->name, sizeof(lvol->name), "%s", new_name); 246 247 cb_fn(cb_arg, g_lvolerrno); 248 } 249 250 void 251 spdk_lvol_open(struct spdk_lvol *lvol, spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 252 { 253 int lvolerrno; 254 255 if (g_lvol_open_enomem == lvol->lvol_store->lvols_opened) { 256 lvolerrno = -ENOMEM; 257 g_lvol_open_enomem = -1; 258 } else { 259 lvolerrno = g_lvolerrno; 260 } 261 262 cb_fn(cb_arg, lvol, lvolerrno); 263 } 264 265 uint64_t 266 spdk_blob_get_num_clusters(struct spdk_blob *b) 267 { 268 return g_num_clusters; 269 } 270 271 /* Simulation of a blob with: 272 * - 1 io_unit per cluster 273 * - 20 data cluster 274 * - only last cluster allocated 275 */ 276 uint64_t g_blob_allocated_io_unit_offset = 20; 277 278 uint64_t 279 spdk_blob_get_next_allocated_io_unit(struct spdk_blob *blob, uint64_t offset) 280 { 281 if (offset <= g_blob_allocated_io_unit_offset) { 282 return g_blob_allocated_io_unit_offset; 283 } else { 284 return UINT64_MAX; 285 } 286 } 287 288 uint64_t 289 spdk_blob_get_next_unallocated_io_unit(struct spdk_blob *blob, uint64_t offset) 290 { 291 if (offset < g_blob_allocated_io_unit_offset) { 292 return offset; 293 } else { 294 return UINT64_MAX; 295 } 296 } 297 298 int 299 spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_id *ids, 300 size_t *count) 301 { 302 *count = 0; 303 return 0; 304 } 305 306 spdk_blob_id 307 spdk_blob_get_parent_snapshot(struct spdk_blob_store *bs, spdk_blob_id blobid) 308 { 309 return 0; 310 } 311 312 bool g_blob_is_read_only = false; 313 314 bool 315 spdk_blob_is_read_only(struct spdk_blob *blob) 316 { 317 return g_blob_is_read_only; 318 } 319 320 bool 321 spdk_blob_is_snapshot(struct spdk_blob *blob) 322 { 323 return false; 324 } 325 326 bool 327 spdk_blob_is_clone(struct spdk_blob *blob) 328 { 329 return false; 330 } 331 332 bool 333 spdk_blob_is_thin_provisioned(struct spdk_blob *blob) 334 { 335 return false; 336 } 337 338 static struct spdk_lvol *_lvol_create(struct spdk_lvol_store *lvs); 339 340 int 341 spdk_lvol_create_esnap_clone(const void *esnap_id, uint32_t id_len, uint64_t size_bytes, 342 struct spdk_lvol_store *lvs, const char *clone_name, 343 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 344 { 345 struct spdk_lvol *lvol; 346 347 lvol = _lvol_create(lvs); 348 snprintf(lvol->name, sizeof(lvol->name), "%s", clone_name); 349 350 cb_fn(cb_arg, lvol, 0); 351 return 0; 352 } 353 354 static void 355 lvs_load(struct spdk_bs_dev *dev, const struct spdk_lvs_opts *lvs_opts, 356 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 357 { 358 struct spdk_lvol_store *lvs = NULL; 359 int i; 360 int lvserrno = g_lvserrno; 361 362 if (lvserrno != 0) { 363 /* On error blobstore destroys bs_dev itself, 364 * by puttin back io channels. 365 * This operation is asynchronous, and completed 366 * after calling the callback for lvol. */ 367 cb_fn(cb_arg, g_lvol_store, lvserrno); 368 dev->destroy(dev); 369 return; 370 } 371 372 lvs = calloc(1, sizeof(*lvs)); 373 SPDK_CU_ASSERT_FATAL(lvs != NULL); 374 lvs->blobstore = calloc(1, sizeof(*lvs->blobstore)); 375 lvs->blobstore->esnap_bs_dev_create = lvs_opts->esnap_bs_dev_create; 376 SPDK_CU_ASSERT_FATAL(lvs->blobstore != NULL); 377 TAILQ_INIT(&lvs->lvols); 378 TAILQ_INIT(&lvs->pending_lvols); 379 TAILQ_INIT(&lvs->retry_open_lvols); 380 spdk_uuid_generate(&lvs->uuid); 381 lvs->bs_dev = dev; 382 for (i = 0; i < g_num_lvols; i++) { 383 _lvol_create(lvs); 384 lvs->lvol_count++; 385 } 386 387 cb_fn(cb_arg, lvs, lvserrno); 388 } 389 390 void 391 spdk_lvs_load(struct spdk_bs_dev *dev, 392 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 393 { 394 lvs_load(dev, NULL, cb_fn, cb_arg); 395 } 396 397 void 398 spdk_lvs_load_ext(struct spdk_bs_dev *bs_dev, const struct spdk_lvs_opts *lvs_opts, 399 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 400 { 401 lvs_load(bs_dev, lvs_opts, cb_fn, cb_arg); 402 } 403 404 int 405 spdk_bs_bdev_claim(struct spdk_bs_dev *bs_dev, struct spdk_bdev_module *module) 406 { 407 if (lvol_already_opened == true) { 408 return -EPERM; 409 } 410 411 lvol_already_opened = true; 412 413 return 0; 414 } 415 416 static void 417 _spdk_bdev_unregister_cb(void *cb_arg, int rc) 418 { 419 CU_ASSERT(rc == 0); 420 } 421 422 void 423 spdk_bdev_unregister(struct spdk_bdev *vbdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg) 424 { 425 int rc; 426 427 SPDK_CU_ASSERT_FATAL(vbdev != NULL); 428 vbdev->internal.unregister_cb = cb_fn; 429 vbdev->internal.unregister_ctx = cb_arg; 430 431 rc = vbdev->fn_table->destruct(vbdev->ctxt); 432 CU_ASSERT(rc == 1); 433 } 434 435 uint64_t 436 spdk_bs_get_page_size(struct spdk_blob_store *bs) 437 { 438 return SPDK_BS_PAGE_SIZE; 439 } 440 441 uint64_t 442 spdk_bs_get_io_unit_size(struct spdk_blob_store *bs) 443 { 444 return SPDK_BS_PAGE_SIZE; 445 } 446 447 int 448 spdk_bdev_create_bs_dev_ext(const char *bdev_name, spdk_bdev_event_cb_t event_cb, 449 void *event_ctx, struct spdk_bs_dev **_bs_dev) 450 { 451 struct spdk_bdev_bs_dev_opts opts = {}; 452 453 return spdk_bdev_create_bs_dev(bdev_name, true, &opts, sizeof(opts), event_cb, event_ctx, _bs_dev); 454 } 455 456 void 457 spdk_lvs_opts_init(struct spdk_lvs_opts *opts) 458 { 459 opts->cluster_sz = SPDK_LVS_OPTS_CLUSTER_SZ; 460 opts->clear_method = LVS_CLEAR_WITH_UNMAP; 461 opts->num_md_pages_per_cluster_ratio = 100; 462 memset(opts->name, 0, sizeof(opts->name)); 463 } 464 465 int 466 spdk_lvs_init(struct spdk_bs_dev *bs_dev, struct spdk_lvs_opts *o, 467 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 468 { 469 struct spdk_lvol_store *lvs; 470 int error = 0; 471 472 if (lvol_store_initialize_fail) { 473 return -1; 474 } 475 476 if (lvol_store_initialize_cb_fail) { 477 bs_dev->destroy(bs_dev); 478 lvs = NULL; 479 error = -1; 480 } else { 481 lvs = calloc(1, sizeof(*lvs)); 482 SPDK_CU_ASSERT_FATAL(lvs != NULL); 483 TAILQ_INIT(&lvs->lvols); 484 TAILQ_INIT(&lvs->pending_lvols); 485 spdk_uuid_generate(&lvs->uuid); 486 snprintf(lvs->name, sizeof(lvs->name), "%s", o->name); 487 lvs->bs_dev = bs_dev; 488 error = 0; 489 } 490 cb_fn(cb_arg, lvs, error); 491 492 return 0; 493 } 494 495 int 496 spdk_lvs_unload(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, void *cb_arg) 497 { 498 struct spdk_lvol *lvol, *tmp; 499 500 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 501 TAILQ_REMOVE(&lvs->lvols, lvol, link); 502 free(lvol); 503 } 504 g_lvol_store = NULL; 505 506 lvs->bs_dev->destroy(lvs->bs_dev); 507 free(lvs->blobstore); 508 free(lvs); 509 510 if (cb_fn != NULL) { 511 cb_fn(cb_arg, 0); 512 } 513 514 return 0; 515 } 516 517 int 518 spdk_lvs_destroy(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, 519 void *cb_arg) 520 { 521 struct spdk_lvol *lvol, *tmp; 522 char *alias; 523 524 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 525 TAILQ_REMOVE(&lvs->lvols, lvol, link); 526 527 alias = spdk_sprintf_alloc("%s/%s", lvs->name, lvol->name); 528 if (alias == NULL) { 529 SPDK_ERRLOG("Cannot alloc memory for alias\n"); 530 return -1; 531 } 532 spdk_bdev_alias_del(lvol->bdev, alias); 533 534 free(alias); 535 free(lvol); 536 } 537 g_lvol_store = NULL; 538 539 lvs->bs_dev->destroy(lvs->bs_dev); 540 free(lvs->blobstore); 541 free(lvs); 542 543 if (cb_fn != NULL) { 544 cb_fn(cb_arg, 0); 545 } 546 547 return 0; 548 } 549 550 void 551 spdk_lvol_resize(struct spdk_lvol *lvol, size_t sz, spdk_lvol_op_complete cb_fn, void *cb_arg) 552 { 553 g_num_clusters = spdk_divide_round_up(sz, spdk_bs_get_cluster_size(lvol->lvol_store->blobstore)); 554 cb_fn(cb_arg, 0); 555 } 556 557 void 558 spdk_lvol_set_read_only(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 559 { 560 cb_fn(cb_arg, 0); 561 } 562 563 int 564 spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size) 565 { 566 bdev->blockcnt = size; 567 return 0; 568 } 569 570 uint64_t 571 spdk_bs_get_cluster_size(struct spdk_blob_store *bs) 572 { 573 return g_cluster_size; 574 } 575 576 struct spdk_bdev * 577 spdk_bdev_get_by_name(const char *bdev_name) 578 { 579 struct spdk_uuid uuid; 580 int rc; 581 582 if (g_bdev.name != NULL && !strcmp(g_bdev.name, bdev_name)) { 583 return &g_bdev; 584 } 585 586 rc = spdk_uuid_parse(&uuid, bdev_name); 587 if (rc == 0 && spdk_uuid_compare(&uuid, &g_bdev.uuid) == 0) { 588 return &g_bdev; 589 } 590 591 return NULL; 592 } 593 594 struct spdk_bdev_desc { 595 struct spdk_bdev *bdev; 596 }; 597 598 int 599 spdk_bdev_open_ext(const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb, 600 void *event_ctx, struct spdk_bdev_desc **_desc) 601 { 602 struct spdk_bdev_desc *desc; 603 struct spdk_bdev *bdev; 604 605 bdev = spdk_bdev_get_by_name(bdev_name); 606 if (bdev == NULL) { 607 return -ENODEV; 608 } 609 610 desc = calloc(1, sizeof(*desc)); 611 if (desc == NULL) { 612 return -ENOMEM; 613 } 614 615 desc->bdev = bdev; 616 *_desc = desc; 617 return 0; 618 } 619 620 void 621 spdk_bdev_close(struct spdk_bdev_desc *desc) 622 { 623 free(desc); 624 } 625 626 struct spdk_bdev * 627 spdk_bdev_desc_get_bdev(struct spdk_bdev_desc *desc) 628 { 629 return desc->bdev; 630 } 631 632 void 633 spdk_lvol_close(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 634 { 635 lvol->ref_count--; 636 637 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 638 cb_fn(cb_arg, 0); 639 } 640 641 bool 642 spdk_lvol_deletable(struct spdk_lvol *lvol) 643 { 644 return true; 645 } 646 647 void 648 spdk_lvol_destroy(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 649 { 650 if (lvol->ref_count != 0) { 651 cb_fn(cb_arg, -ENODEV); 652 } 653 654 TAILQ_REMOVE(&lvol->lvol_store->lvols, lvol, link); 655 656 SPDK_CU_ASSERT_FATAL(cb_fn != NULL); 657 cb_fn(cb_arg, 0); 658 659 g_lvol = NULL; 660 free(lvol); 661 } 662 663 void 664 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 665 { 666 bdev_io->internal.status = status; 667 } 668 669 struct spdk_io_channel *spdk_lvol_get_io_channel(struct spdk_lvol *lvol) 670 { 671 CU_ASSERT(lvol == g_lvol); 672 return g_ch; 673 } 674 675 void 676 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 677 { 678 CU_ASSERT(cb == lvol_get_buf_cb); 679 } 680 681 void 682 spdk_blob_io_read(struct spdk_blob *blob, struct spdk_io_channel *channel, 683 void *payload, uint64_t offset, uint64_t length, 684 spdk_blob_op_complete cb_fn, void *cb_arg) 685 { 686 CU_ASSERT(blob == NULL); 687 CU_ASSERT(channel == g_ch); 688 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 689 CU_ASSERT(length == g_io->u.bdev.num_blocks); 690 cb_fn(cb_arg, 0); 691 } 692 693 void 694 spdk_blob_io_write(struct spdk_blob *blob, struct spdk_io_channel *channel, 695 void *payload, uint64_t offset, uint64_t length, 696 spdk_blob_op_complete cb_fn, void *cb_arg) 697 { 698 CU_ASSERT(blob == NULL); 699 CU_ASSERT(channel == g_ch); 700 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 701 CU_ASSERT(length == g_io->u.bdev.num_blocks); 702 cb_fn(cb_arg, 0); 703 } 704 705 void 706 spdk_blob_io_unmap(struct spdk_blob *blob, struct spdk_io_channel *channel, 707 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 708 { 709 CU_ASSERT(blob == NULL); 710 CU_ASSERT(channel == g_ch); 711 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 712 CU_ASSERT(length == g_io->u.bdev.num_blocks); 713 cb_fn(cb_arg, 0); 714 } 715 716 void 717 spdk_blob_io_write_zeroes(struct spdk_blob *blob, struct spdk_io_channel *channel, 718 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 719 { 720 CU_ASSERT(blob == NULL); 721 CU_ASSERT(channel == g_ch); 722 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 723 CU_ASSERT(length == g_io->u.bdev.num_blocks); 724 cb_fn(cb_arg, 0); 725 } 726 727 void 728 spdk_blob_io_writev(struct spdk_blob *blob, struct spdk_io_channel *channel, 729 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 730 spdk_blob_op_complete cb_fn, void *cb_arg) 731 { 732 CU_ASSERT(blob == NULL); 733 CU_ASSERT(channel == g_ch); 734 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 735 CU_ASSERT(length == g_io->u.bdev.num_blocks); 736 cb_fn(cb_arg, 0); 737 } 738 739 void 740 spdk_blob_io_writev_ext(struct spdk_blob *blob, struct spdk_io_channel *channel, 741 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 742 spdk_blob_op_complete cb_fn, void *cb_arg, 743 struct spdk_blob_ext_io_opts *io_opts) 744 { 745 struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx; 746 747 CU_ASSERT(blob == NULL); 748 CU_ASSERT(channel == g_ch); 749 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 750 CU_ASSERT(length == g_io->u.bdev.num_blocks); 751 CU_ASSERT(io_opts == &lvol_io->ext_io_opts); 752 g_ext_api_called = true; 753 cb_fn(cb_arg, 0); 754 } 755 756 void 757 spdk_blob_io_readv(struct spdk_blob *blob, struct spdk_io_channel *channel, 758 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 759 spdk_blob_op_complete cb_fn, void *cb_arg) 760 { 761 CU_ASSERT(blob == NULL); 762 CU_ASSERT(channel == g_ch); 763 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 764 CU_ASSERT(length == g_io->u.bdev.num_blocks); 765 cb_fn(cb_arg, 0); 766 } 767 768 void 769 spdk_blob_io_readv_ext(struct spdk_blob *blob, struct spdk_io_channel *channel, 770 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 771 spdk_blob_op_complete cb_fn, void *cb_arg, 772 struct spdk_blob_ext_io_opts *io_opts) 773 { 774 struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx; 775 776 CU_ASSERT(blob == NULL); 777 CU_ASSERT(channel == g_ch); 778 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 779 CU_ASSERT(length == g_io->u.bdev.num_blocks); 780 CU_ASSERT(io_opts == &lvol_io->ext_io_opts); 781 g_ext_api_called = true; 782 cb_fn(cb_arg, 0); 783 } 784 785 void 786 spdk_bdev_module_list_add(struct spdk_bdev_module *bdev_module) 787 { 788 } 789 790 const char * 791 spdk_bdev_get_name(const struct spdk_bdev *bdev) 792 { 793 return bdev->name; 794 } 795 796 uint32_t 797 spdk_bdev_get_block_size(const struct spdk_bdev *bdev) 798 { 799 return bdev->blocklen; 800 } 801 802 uint64_t 803 spdk_bdev_get_num_blocks(const struct spdk_bdev *bdev) 804 { 805 return bdev->blockcnt; 806 } 807 808 int 809 spdk_bdev_register(struct spdk_bdev *vbdev) 810 { 811 TAILQ_INIT(&vbdev->aliases); 812 813 g_registered_bdevs++; 814 return 0; 815 } 816 817 void 818 spdk_bdev_module_examine_done(struct spdk_bdev_module *module) 819 { 820 SPDK_CU_ASSERT_FATAL(g_examine_done != true); 821 g_examine_done = true; 822 } 823 824 static struct spdk_lvol * 825 _lvol_create(struct spdk_lvol_store *lvs) 826 { 827 struct spdk_lvol *lvol = calloc(1, sizeof(*lvol)); 828 829 SPDK_CU_ASSERT_FATAL(lvol != NULL); 830 831 lvol->lvol_store = lvs; 832 lvol->ref_count++; 833 snprintf(lvol->unique_id, sizeof(lvol->unique_id), "%s", "UNIT_TEST_UUID"); 834 835 TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link); 836 837 return lvol; 838 } 839 840 int 841 spdk_lvol_create(struct spdk_lvol_store *lvs, const char *name, size_t sz, 842 bool thin_provision, enum lvol_clear_method clear_method, spdk_lvol_op_with_handle_complete cb_fn, 843 void *cb_arg) 844 { 845 struct spdk_lvol *lvol; 846 847 lvol = _lvol_create(lvs); 848 snprintf(lvol->name, sizeof(lvol->name), "%s", name); 849 g_num_clusters = spdk_divide_round_up(sz, spdk_bs_get_cluster_size(lvol->lvol_store->blobstore)); 850 cb_fn(cb_arg, lvol, 0); 851 852 return 0; 853 } 854 855 void 856 spdk_lvol_create_snapshot(struct spdk_lvol *lvol, const char *snapshot_name, 857 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 858 { 859 struct spdk_lvol *snap; 860 861 snap = _lvol_create(lvol->lvol_store); 862 snprintf(snap->name, sizeof(snap->name), "%s", snapshot_name); 863 cb_fn(cb_arg, snap, 0); 864 } 865 866 void 867 spdk_lvol_create_clone(struct spdk_lvol *lvol, const char *clone_name, 868 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 869 { 870 struct spdk_lvol *clone; 871 872 clone = _lvol_create(lvol->lvol_store); 873 snprintf(clone->name, sizeof(clone->name), "%s", clone_name); 874 cb_fn(cb_arg, clone, 0); 875 } 876 877 bool 878 spdk_lvs_notify_hotplug(const void *esnap_id, uint32_t id_len, 879 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 880 { 881 struct spdk_uuid uuid = { 0 }; 882 char uuid_str[SPDK_UUID_STRING_LEN] = "bad"; 883 884 CU_ASSERT(id_len == SPDK_UUID_STRING_LEN); 885 CU_ASSERT(spdk_uuid_parse(&uuid, esnap_id) == 0); 886 CU_ASSERT(spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &uuid) == 0); 887 CU_ASSERT(strcmp(esnap_id, uuid_str) == 0); 888 889 return g_bdev_is_missing; 890 } 891 892 int 893 spdk_lvol_shallow_copy(struct spdk_lvol *lvol, struct spdk_bs_dev *ext_dev, 894 spdk_blob_shallow_copy_status status_cb_fn, void *status_cb_arg, 895 spdk_lvol_op_complete cb_fn, void *cb_arg) 896 { 897 if (lvol == NULL) { 898 return -ENODEV; 899 } 900 901 if (ext_dev == NULL) { 902 return -ENODEV; 903 } 904 905 cb_fn(cb_arg, 0); 906 return 0; 907 } 908 909 void 910 spdk_lvol_set_external_parent(struct spdk_lvol *lvol, const void *esnap_id, uint32_t id_len, 911 spdk_lvol_op_complete cb_fn, void *cb_arg) 912 { 913 cb_fn(cb_arg, 0); 914 } 915 916 static void 917 lvol_store_op_complete(void *cb_arg, int lvserrno) 918 { 919 g_lvserrno = lvserrno; 920 return; 921 } 922 923 static void 924 lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno) 925 { 926 g_lvserrno = lvserrno; 927 g_lvol_store = lvs; 928 return; 929 } 930 931 static void 932 vbdev_lvol_create_complete(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) 933 { 934 g_lvolerrno = lvolerrno; 935 g_lvol = lvol; 936 } 937 938 static void 939 vbdev_lvol_resize_complete(void *cb_arg, int lvolerrno) 940 { 941 g_lvolerrno = lvolerrno; 942 } 943 944 static void 945 vbdev_lvol_set_read_only_complete(void *cb_arg, int lvolerrno) 946 { 947 g_lvolerrno = lvolerrno; 948 } 949 950 static void 951 vbdev_lvol_rename_complete(void *cb_arg, int lvolerrno) 952 { 953 g_lvolerrno = lvolerrno; 954 } 955 956 static int 957 ut_init_bdev(char *bdev_name, const char *uuid_str) 958 { 959 memset(&g_bdev, 0, sizeof(g_bdev)); 960 g_bdev.name = bdev_name; 961 SPDK_CU_ASSERT_FATAL(spdk_uuid_parse(&g_bdev.uuid, uuid_str) == 0); 962 lvol_already_opened = false; 963 return 0; 964 } 965 966 static void 967 vbdev_lvol_shallow_copy_complete(void *cb_arg, int lvolerrno) 968 { 969 g_lvolerrno = lvolerrno; 970 } 971 972 static void 973 vbdev_lvol_op_complete(void *cb_arg, int lvolerrno) 974 { 975 g_lvolerrno = lvolerrno; 976 } 977 978 static void 979 ut_lvs_destroy(void) 980 { 981 int rc = 0; 982 int sz = 10; 983 struct spdk_lvol_store *lvs; 984 985 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 986 987 /* Lvol store is successfully created */ 988 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 989 lvol_store_op_with_handle_complete, NULL); 990 CU_ASSERT(rc == 0); 991 CU_ASSERT(g_lvserrno == 0); 992 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 993 CU_ASSERT(g_lvol_store->bs_dev != NULL); 994 995 lvs = g_lvol_store; 996 g_lvol_store = NULL; 997 998 spdk_uuid_generate(&lvs->uuid); 999 1000 /* Successfully create lvol, which should be unloaded with lvs later */ 1001 g_lvolerrno = -1; 1002 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1003 NULL); 1004 CU_ASSERT(rc == 0); 1005 CU_ASSERT(g_lvolerrno == 0); 1006 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1007 1008 /* Unload lvol store */ 1009 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1010 CU_ASSERT(g_lvserrno == 0); 1011 CU_ASSERT(g_lvol_store == NULL); 1012 } 1013 1014 static void 1015 assert_blockcnt(struct spdk_lvol *lvol, int sz) 1016 { 1017 CU_ASSERT(lvol->bdev->blockcnt == spdk_divide_round_up(sz, g_cluster_size) * 1018 (g_cluster_size / lvol->bdev->blocklen)); 1019 } 1020 1021 static void 1022 ut_lvol_init(void) 1023 { 1024 struct spdk_lvol_store *lvs; 1025 int sz = 10; 1026 int rc; 1027 1028 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1029 1030 /* Lvol store is successfully created */ 1031 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1032 lvol_store_op_with_handle_complete, NULL); 1033 CU_ASSERT(rc == 0); 1034 CU_ASSERT(g_lvserrno == 0); 1035 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1036 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1037 lvs = g_lvol_store; 1038 1039 /* Successful lvol create */ 1040 g_lvolerrno = -1; 1041 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1042 NULL); 1043 SPDK_CU_ASSERT_FATAL(rc == 0); 1044 CU_ASSERT(g_lvol != NULL); 1045 CU_ASSERT(g_lvol->bdev != NULL); 1046 CU_ASSERT(g_lvolerrno == 0); 1047 assert_blockcnt(g_lvol, sz); 1048 1049 /* Successful lvol destroy */ 1050 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1051 CU_ASSERT(g_lvol == NULL); 1052 1053 /* Destroy lvol store */ 1054 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1055 CU_ASSERT(g_lvserrno == 0); 1056 CU_ASSERT(g_lvol_store == NULL); 1057 } 1058 1059 static void 1060 ut_lvol_snapshot(void) 1061 { 1062 struct spdk_lvol_store *lvs; 1063 int sz = 10; 1064 int rc; 1065 struct spdk_lvol *lvol = NULL; 1066 1067 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1068 1069 /* Lvol store is successfully created */ 1070 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1071 lvol_store_op_with_handle_complete, NULL); 1072 CU_ASSERT(rc == 0); 1073 CU_ASSERT(g_lvserrno == 0); 1074 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1075 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1076 lvs = g_lvol_store; 1077 1078 /* Successful lvol create */ 1079 g_lvolerrno = -1; 1080 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1081 NULL); 1082 SPDK_CU_ASSERT_FATAL(rc == 0); 1083 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1084 CU_ASSERT(g_lvolerrno == 0); 1085 1086 lvol = g_lvol; 1087 1088 /* Successful snap create */ 1089 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 1090 SPDK_CU_ASSERT_FATAL(rc == 0); 1091 CU_ASSERT(g_lvol != NULL); 1092 CU_ASSERT(g_lvolerrno == 0); 1093 1094 /* Successful lvol destroy */ 1095 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1096 CU_ASSERT(g_lvol == NULL); 1097 1098 /* Successful snap destroy */ 1099 g_lvol = lvol; 1100 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1101 CU_ASSERT(g_lvol == NULL); 1102 1103 /* Destroy lvol store */ 1104 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1105 CU_ASSERT(g_lvserrno == 0); 1106 CU_ASSERT(g_lvol_store == NULL); 1107 } 1108 1109 static void 1110 ut_lvol_clone(void) 1111 { 1112 struct spdk_lvol_store *lvs; 1113 int sz = 10; 1114 int rc; 1115 struct spdk_lvol *lvol = NULL; 1116 struct spdk_lvol *snap = NULL; 1117 struct spdk_lvol *clone = NULL; 1118 1119 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1120 1121 /* Lvol store is successfully created */ 1122 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1123 lvol_store_op_with_handle_complete, NULL); 1124 CU_ASSERT(rc == 0); 1125 CU_ASSERT(g_lvserrno == 0); 1126 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1127 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1128 lvs = g_lvol_store; 1129 1130 /* Successful lvol create */ 1131 g_lvolerrno = -1; 1132 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1133 NULL); 1134 SPDK_CU_ASSERT_FATAL(rc == 0); 1135 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1136 CU_ASSERT(g_lvolerrno == 0); 1137 1138 lvol = g_lvol; 1139 1140 /* Successful snap create */ 1141 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 1142 SPDK_CU_ASSERT_FATAL(rc == 0); 1143 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1144 CU_ASSERT(g_lvolerrno == 0); 1145 1146 snap = g_lvol; 1147 1148 /* Successful clone create */ 1149 vbdev_lvol_create_clone(snap, "clone", vbdev_lvol_create_complete, NULL); 1150 1151 SPDK_CU_ASSERT_FATAL(rc == 0); 1152 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1153 CU_ASSERT(g_lvolerrno == 0); 1154 1155 clone = g_lvol; 1156 1157 /* Successful lvol destroy */ 1158 g_lvol = lvol; 1159 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1160 CU_ASSERT(g_lvol == NULL); 1161 1162 /* Successful clone destroy */ 1163 g_lvol = clone; 1164 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1165 CU_ASSERT(g_lvol == NULL); 1166 1167 /* Successful lvol destroy */ 1168 g_lvol = snap; 1169 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 1170 CU_ASSERT(g_lvol == NULL); 1171 1172 /* Destroy lvol store */ 1173 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1174 CU_ASSERT(g_lvserrno == 0); 1175 CU_ASSERT(g_lvol_store == NULL); 1176 } 1177 1178 static void 1179 ut_lvol_hotremove(void) 1180 { 1181 int rc = 0; 1182 1183 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1184 1185 lvol_store_initialize_fail = false; 1186 lvol_store_initialize_cb_fail = false; 1187 lvol_already_opened = false; 1188 1189 /* Lvol store is successfully created */ 1190 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1191 lvol_store_op_with_handle_complete, NULL); 1192 CU_ASSERT(rc == 0); 1193 CU_ASSERT(g_lvserrno == 0); 1194 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1195 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1196 1197 /* Hot remove callback with NULL - stability check */ 1198 vbdev_lvs_hotremove_cb(NULL); 1199 1200 /* Hot remove lvs on bdev removal */ 1201 vbdev_lvs_hotremove_cb(&g_bdev); 1202 1203 CU_ASSERT(g_lvol_store == NULL); 1204 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1205 1206 } 1207 1208 static void 1209 ut_lvol_examine_config(void) 1210 { 1211 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1212 1213 /* No esnap clone needs the bdev. */ 1214 g_bdev_is_missing = false; 1215 g_examine_done = false; 1216 vbdev_lvs_examine_config(&g_bdev); 1217 CU_ASSERT(g_examine_done); 1218 1219 g_bdev_is_missing = true; 1220 g_examine_done = false; 1221 vbdev_lvs_examine_config(&g_bdev); 1222 CU_ASSERT(g_examine_done); 1223 1224 g_examine_done = false; 1225 } 1226 1227 static void 1228 ut_lvs_examine_check(bool success) 1229 { 1230 struct lvol_store_bdev *lvs_bdev; 1231 1232 /* Examine was finished regardless of result */ 1233 CU_ASSERT(g_examine_done == true); 1234 g_examine_done = false; 1235 1236 if (success) { 1237 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1238 lvs_bdev = TAILQ_FIRST(&g_spdk_lvol_pairs); 1239 SPDK_CU_ASSERT_FATAL(lvs_bdev != NULL); 1240 g_lvol_store = lvs_bdev->lvs; 1241 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1242 SPDK_CU_ASSERT_FATAL(g_lvol_store->blobstore != NULL); 1243 CU_ASSERT(g_lvol_store->blobstore->esnap_bs_dev_create != NULL); 1244 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1245 CU_ASSERT(g_lvol_store->lvols_opened == spdk_min(g_num_lvols, g_registered_bdevs)); 1246 } else { 1247 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1248 g_lvol_store = NULL; 1249 } 1250 } 1251 1252 static void 1253 ut_lvol_examine_disk(void) 1254 { 1255 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1256 1257 /* Examine unsuccessfully - bdev already opened */ 1258 g_lvserrno = -1; 1259 lvol_already_opened = true; 1260 vbdev_lvs_examine_disk(&g_bdev); 1261 ut_lvs_examine_check(false); 1262 1263 /* Examine unsuccessfully - fail on lvol store */ 1264 g_lvserrno = -1; 1265 lvol_already_opened = false; 1266 vbdev_lvs_examine_disk(&g_bdev); 1267 ut_lvs_examine_check(false); 1268 1269 /* Examine successfully 1270 * - one lvol fails to load 1271 * - lvs is loaded with no lvols present */ 1272 g_lvserrno = 0; 1273 g_lvolerrno = -1; 1274 g_num_lvols = 1; 1275 lvol_already_opened = false; 1276 g_registered_bdevs = 0; 1277 vbdev_lvs_examine_disk(&g_bdev); 1278 ut_lvs_examine_check(true); 1279 CU_ASSERT(g_registered_bdevs == 0); 1280 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols)); 1281 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1282 CU_ASSERT(g_lvserrno == 0); 1283 CU_ASSERT(g_lvol_store == NULL); 1284 1285 /* Examine successfully */ 1286 g_lvserrno = 0; 1287 g_lvolerrno = 0; 1288 g_registered_bdevs = 0; 1289 lvol_already_opened = false; 1290 vbdev_lvs_examine_disk(&g_bdev); 1291 ut_lvs_examine_check(true); 1292 CU_ASSERT(g_registered_bdevs != 0); 1293 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1294 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1295 CU_ASSERT(g_lvserrno == 0); 1296 1297 /* Examine multiple lvols successfully */ 1298 g_num_lvols = 4; 1299 g_registered_bdevs = 0; 1300 lvol_already_opened = false; 1301 vbdev_lvs_examine_disk(&g_bdev); 1302 ut_lvs_examine_check(true); 1303 CU_ASSERT(g_registered_bdevs == g_num_lvols); 1304 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1305 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1306 CU_ASSERT(g_lvserrno == 0); 1307 1308 /* Examine multiple lvols successfully - fail one with -ENOMEM on lvol open */ 1309 g_num_lvols = 4; 1310 g_lvol_open_enomem = 2; 1311 g_registered_bdevs = 0; 1312 lvol_already_opened = false; 1313 vbdev_lvs_examine_disk(&g_bdev); 1314 ut_lvs_examine_check(true); 1315 CU_ASSERT(g_registered_bdevs == g_num_lvols); 1316 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 1317 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1318 CU_ASSERT(g_lvserrno == 0); 1319 } 1320 1321 static void 1322 ut_lvol_rename(void) 1323 { 1324 struct spdk_lvol_store *lvs; 1325 struct spdk_lvol *lvol; 1326 struct spdk_lvol *lvol2; 1327 int sz = 10; 1328 int rc; 1329 1330 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1331 1332 /* Lvol store is successfully created */ 1333 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1334 lvol_store_op_with_handle_complete, NULL); 1335 CU_ASSERT(rc == 0); 1336 CU_ASSERT(g_lvserrno == 0); 1337 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1338 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1339 lvs = g_lvol_store; 1340 1341 /* Successful lvols create */ 1342 g_lvolerrno = -1; 1343 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1344 NULL); 1345 SPDK_CU_ASSERT_FATAL(rc == 0); 1346 CU_ASSERT(g_lvol != NULL); 1347 CU_ASSERT(g_lvolerrno == 0); 1348 lvol = g_lvol; 1349 1350 g_lvolerrno = -1; 1351 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1352 NULL); 1353 SPDK_CU_ASSERT_FATAL(rc == 0); 1354 CU_ASSERT(g_lvol != NULL); 1355 CU_ASSERT(g_lvolerrno == 0); 1356 lvol2 = g_lvol; 1357 1358 /* Successful rename lvol */ 1359 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1360 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1361 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1362 1363 /* Renaming lvol with name already existing */ 1364 g_bdev_alias_already_exists = true; 1365 vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1366 g_bdev_alias_already_exists = false; 1367 SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0); 1368 CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name"); 1369 1370 /* Renaming lvol with it's own name */ 1371 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1372 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1373 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1374 1375 /* Successful lvols destroy */ 1376 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1377 CU_ASSERT(g_lvol == NULL); 1378 1379 vbdev_lvol_destroy(lvol2, lvol_store_op_complete, NULL); 1380 CU_ASSERT(g_lvol == NULL); 1381 1382 /* Destroy lvol store */ 1383 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1384 CU_ASSERT(g_lvserrno == 0); 1385 CU_ASSERT(g_lvol_store == NULL); 1386 } 1387 1388 static void 1389 ut_bdev_finish(void) 1390 { 1391 struct spdk_lvol_store *lvs; 1392 struct spdk_lvol *lvol; 1393 struct spdk_lvol *lvol2; 1394 int sz = 10; 1395 int rc; 1396 1397 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1398 1399 /* Scenario 1 1400 * Test unload of lvs with no lvols during bdev finish. */ 1401 1402 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1403 lvol_store_op_with_handle_complete, NULL); 1404 CU_ASSERT(rc == 0); 1405 CU_ASSERT(g_lvserrno == 0); 1406 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1407 lvs = g_lvol_store; 1408 1409 /* Start bdev finish */ 1410 vbdev_lvs_fini_start(); 1411 CU_ASSERT(g_shutdown_started == true); 1412 1413 /* During shutdown, lvs with no lvols should be unloaded */ 1414 CU_ASSERT(g_lvol_store == NULL); 1415 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1416 1417 /* Revert module state back to normal */ 1418 g_shutdown_started = false; 1419 lvol_already_opened = false; 1420 1421 /* Scenario 2 1422 * Test creating lvs with two lvols. Delete first lvol explicitly, 1423 * then start bdev finish. This should unload the remaining lvol and 1424 * lvol store. */ 1425 1426 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1427 lvol_store_op_with_handle_complete, NULL); 1428 CU_ASSERT(rc == 0); 1429 CU_ASSERT(g_lvserrno == 0); 1430 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1431 lvs = g_lvol_store; 1432 1433 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1434 vbdev_lvol_create_complete, NULL); 1435 SPDK_CU_ASSERT_FATAL(rc == 0); 1436 CU_ASSERT(g_lvol != NULL); 1437 CU_ASSERT(g_lvolerrno == 0); 1438 lvol = g_lvol; 1439 1440 rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, 1441 vbdev_lvol_create_complete, NULL); 1442 SPDK_CU_ASSERT_FATAL(rc == 0); 1443 CU_ASSERT(g_lvol != NULL); 1444 CU_ASSERT(g_lvolerrno == 0); 1445 lvol2 = g_lvol; 1446 1447 /* Destroy explicitly first lvol */ 1448 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1449 CU_ASSERT(g_lvol == NULL); 1450 CU_ASSERT(g_lvolerrno == 0); 1451 1452 /* Start bdev finish and unregister remaining lvol */ 1453 vbdev_lvs_fini_start(); 1454 CU_ASSERT(g_shutdown_started == true); 1455 spdk_bdev_unregister(lvol2->bdev, _spdk_bdev_unregister_cb, NULL); 1456 1457 /* During shutdown, removal of last lvol should unload lvs */ 1458 CU_ASSERT(g_lvol_store == NULL); 1459 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 1460 1461 /* Revert module state back to normal */ 1462 g_shutdown_started = false; 1463 } 1464 1465 static void 1466 ut_lvol_resize(void) 1467 { 1468 struct spdk_lvol_store *lvs; 1469 struct spdk_lvol *lvol; 1470 int sz = 10; 1471 int rc = 0; 1472 1473 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1474 1475 /* Lvol store is successfully created */ 1476 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1477 lvol_store_op_with_handle_complete, NULL); 1478 CU_ASSERT(rc == 0); 1479 CU_ASSERT(g_lvserrno == 0); 1480 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1481 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1482 lvs = g_lvol_store; 1483 1484 /* Successful lvol create */ 1485 g_lvolerrno = -1; 1486 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1487 NULL); 1488 CU_ASSERT(rc == 0); 1489 CU_ASSERT(g_lvolerrno == 0); 1490 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1491 lvol = g_lvol; 1492 1493 /* Successful lvol resize */ 1494 g_lvolerrno = -1; 1495 sz = 20 * g_cluster_size; 1496 vbdev_lvol_resize(lvol, sz, vbdev_lvol_resize_complete, NULL); 1497 CU_ASSERT(g_lvolerrno == 0); 1498 assert_blockcnt(g_lvol, sz); 1499 1500 /* Resize with NULL lvol */ 1501 vbdev_lvol_resize(NULL, 34 * g_cluster_size, vbdev_lvol_resize_complete, NULL); 1502 CU_ASSERT(g_lvolerrno != 0); 1503 assert_blockcnt(g_lvol, sz); 1504 1505 /* Successful lvol destroy */ 1506 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1507 CU_ASSERT(g_lvol == NULL); 1508 1509 /* Destroy lvol store */ 1510 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1511 CU_ASSERT(g_lvserrno == 0); 1512 CU_ASSERT(g_lvol_store == NULL); 1513 } 1514 1515 static void 1516 ut_lvol_set_read_only(void) 1517 { 1518 struct spdk_lvol_store *lvs; 1519 struct spdk_lvol *lvol; 1520 int sz = 10; 1521 int rc = 0; 1522 1523 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1524 1525 /* Lvol store is successfully created */ 1526 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1527 lvol_store_op_with_handle_complete, NULL); 1528 CU_ASSERT(rc == 0); 1529 CU_ASSERT(g_lvserrno == 0); 1530 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1531 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1532 lvs = g_lvol_store; 1533 1534 /* Successful lvol create */ 1535 g_lvolerrno = -1; 1536 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1537 NULL); 1538 CU_ASSERT(rc == 0); 1539 CU_ASSERT(g_lvolerrno == 0); 1540 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1541 lvol = g_lvol; 1542 1543 /* Successful set lvol as read only */ 1544 g_lvolerrno = -1; 1545 vbdev_lvol_set_read_only(lvol, vbdev_lvol_set_read_only_complete, NULL); 1546 CU_ASSERT(g_lvolerrno == 0); 1547 1548 /* Successful lvol destroy */ 1549 vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL); 1550 CU_ASSERT(g_lvol == NULL); 1551 1552 /* Destroy lvol store */ 1553 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1554 CU_ASSERT(g_lvserrno == 0); 1555 CU_ASSERT(g_lvol_store == NULL); 1556 } 1557 1558 static void 1559 ut_lvs_unload(void) 1560 { 1561 int rc = 0; 1562 int sz = 10; 1563 struct spdk_lvol_store *lvs; 1564 1565 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1566 1567 /* Lvol store is successfully created */ 1568 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1569 lvol_store_op_with_handle_complete, NULL); 1570 CU_ASSERT(rc == 0); 1571 CU_ASSERT(g_lvserrno == 0); 1572 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1573 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1574 1575 lvs = g_lvol_store; 1576 g_lvol_store = NULL; 1577 1578 spdk_uuid_generate(&lvs->uuid); 1579 1580 /* Successfully create lvol, which should be destroyed with lvs later */ 1581 g_lvolerrno = -1; 1582 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1583 NULL); 1584 CU_ASSERT(rc == 0); 1585 CU_ASSERT(g_lvolerrno == 0); 1586 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1587 1588 /* Unload lvol store */ 1589 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1590 CU_ASSERT(g_lvserrno == 0); 1591 CU_ASSERT(g_lvol_store == NULL); 1592 CU_ASSERT(g_lvol != NULL); 1593 } 1594 1595 static void 1596 ut_lvs_init(void) 1597 { 1598 int rc = 0; 1599 struct spdk_lvol_store *lvs; 1600 1601 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1602 1603 /* spdk_lvs_init() fails */ 1604 lvol_store_initialize_fail = true; 1605 1606 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1607 lvol_store_op_with_handle_complete, NULL); 1608 CU_ASSERT(rc != 0); 1609 CU_ASSERT(g_lvserrno == 0); 1610 CU_ASSERT(g_lvol_store == NULL); 1611 1612 lvol_store_initialize_fail = false; 1613 1614 /* spdk_lvs_init_cb() fails */ 1615 lvol_store_initialize_cb_fail = true; 1616 1617 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1618 lvol_store_op_with_handle_complete, NULL); 1619 CU_ASSERT(rc == 0); 1620 CU_ASSERT(g_lvserrno != 0); 1621 CU_ASSERT(g_lvol_store == NULL); 1622 1623 lvol_store_initialize_cb_fail = false; 1624 1625 /* Lvol store is successfully created */ 1626 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1627 lvol_store_op_with_handle_complete, NULL); 1628 CU_ASSERT(rc == 0); 1629 CU_ASSERT(g_lvserrno == 0); 1630 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1631 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1632 1633 lvs = g_lvol_store; 1634 g_lvol_store = NULL; 1635 1636 /* Bdev with lvol store already claimed */ 1637 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1638 lvol_store_op_with_handle_complete, NULL); 1639 CU_ASSERT(rc != 0); 1640 CU_ASSERT(g_lvserrno == 0); 1641 CU_ASSERT(g_lvol_store == NULL); 1642 1643 /* Destruct lvol store */ 1644 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1645 CU_ASSERT(g_lvserrno == 0); 1646 CU_ASSERT(g_lvol_store == NULL); 1647 } 1648 1649 static void 1650 ut_vbdev_lvol_get_io_channel(void) 1651 { 1652 struct spdk_io_channel *ch; 1653 1654 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1655 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1656 1657 ch = vbdev_lvol_get_io_channel(g_lvol); 1658 CU_ASSERT(ch == g_ch); 1659 1660 free(g_lvol); 1661 } 1662 1663 static void 1664 ut_vbdev_lvol_io_type_supported(void) 1665 { 1666 struct spdk_lvol *lvol; 1667 bool ret; 1668 1669 lvol = calloc(1, sizeof(struct spdk_lvol)); 1670 SPDK_CU_ASSERT_FATAL(lvol != NULL); 1671 1672 g_blob_is_read_only = false; 1673 1674 /* Supported types */ 1675 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1676 CU_ASSERT(ret == true); 1677 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1678 CU_ASSERT(ret == true); 1679 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1680 CU_ASSERT(ret == true); 1681 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1682 CU_ASSERT(ret == true); 1683 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1684 CU_ASSERT(ret == true); 1685 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1686 CU_ASSERT(ret == true); 1687 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1688 CU_ASSERT(ret == true); 1689 1690 /* Unsupported types */ 1691 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1692 CU_ASSERT(ret == false); 1693 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1694 CU_ASSERT(ret == false); 1695 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1696 CU_ASSERT(ret == false); 1697 1698 g_blob_is_read_only = true; 1699 1700 /* Supported types */ 1701 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1702 CU_ASSERT(ret == true); 1703 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1704 CU_ASSERT(ret == true); 1705 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA); 1706 CU_ASSERT(ret == true); 1707 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE); 1708 CU_ASSERT(ret == true); 1709 1710 /* Unsupported types */ 1711 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1712 CU_ASSERT(ret == false); 1713 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1714 CU_ASSERT(ret == false); 1715 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1716 CU_ASSERT(ret == false); 1717 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1718 CU_ASSERT(ret == false); 1719 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1720 CU_ASSERT(ret == false); 1721 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1722 CU_ASSERT(ret == false); 1723 1724 free(lvol); 1725 } 1726 1727 static void 1728 ut_lvol_read_write(void) 1729 { 1730 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1731 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1732 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1733 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1734 1735 g_io->bdev = &g_bdev; 1736 g_io->bdev->ctxt = g_lvol; 1737 g_io->u.bdev.offset_blocks = 20; 1738 g_io->u.bdev.num_blocks = 20; 1739 1740 lvol_read(g_ch, g_io); 1741 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1742 1743 lvol_write(g_lvol, g_ch, g_io); 1744 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1745 1746 g_ext_api_called = false; 1747 lvol_read(g_ch, g_io); 1748 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1749 CU_ASSERT(g_ext_api_called == true); 1750 g_ext_api_called = false; 1751 1752 lvol_write(g_lvol, g_ch, g_io); 1753 CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS); 1754 CU_ASSERT(g_ext_api_called == true); 1755 g_ext_api_called = false; 1756 1757 free(g_io); 1758 free(g_lvol); 1759 } 1760 1761 static void 1762 ut_vbdev_lvol_submit_request(void) 1763 { 1764 struct spdk_lvol request_lvol = {}; 1765 g_io = calloc(1, sizeof(struct spdk_bdev_io)); 1766 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1767 g_io->bdev = &g_bdev; 1768 1769 g_io->type = SPDK_BDEV_IO_TYPE_READ; 1770 g_bdev.ctxt = &request_lvol; 1771 vbdev_lvol_submit_request(g_ch, g_io); 1772 1773 free(g_io); 1774 } 1775 1776 static void 1777 ut_lvs_rename(void) 1778 { 1779 int rc = 0; 1780 int sz = 10; 1781 struct spdk_lvol_store *lvs; 1782 1783 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1784 1785 /* Lvol store is successfully created */ 1786 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "old_lvs_name", 0, LVS_CLEAR_WITH_UNMAP, 0, 1787 lvol_store_op_with_handle_complete, NULL); 1788 CU_ASSERT(rc == 0); 1789 CU_ASSERT(g_lvserrno == 0); 1790 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1791 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1792 1793 lvs = g_lvol_store; 1794 g_lvol_store = NULL; 1795 1796 /* Successfully create lvol, which should be destroyed with lvs later */ 1797 g_lvolerrno = -1; 1798 rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete, 1799 NULL); 1800 CU_ASSERT(rc == 0); 1801 CU_ASSERT(g_lvolerrno == 0); 1802 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1803 1804 /* Trying to rename lvs with lvols created */ 1805 vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL); 1806 CU_ASSERT(g_lvserrno == 0); 1807 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1808 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1809 1810 /* Trying to rename lvs with name already used by another lvs */ 1811 /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates 1812 * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */ 1813 g_lvs_with_name_already_exists = true; 1814 vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL); 1815 CU_ASSERT(g_lvserrno == -EEXIST); 1816 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1817 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol"); 1818 g_lvs_with_name_already_exists = false; 1819 1820 /* Unload lvol store */ 1821 g_lvol_store = lvs; 1822 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1823 CU_ASSERT(g_lvserrno == 0); 1824 CU_ASSERT(g_lvol_store == NULL); 1825 } 1826 1827 static void 1828 ut_lvol_seek(void) 1829 { 1830 g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size()); 1831 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1832 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1833 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1834 1835 g_io->bdev = &g_bdev; 1836 g_io->bdev->ctxt = g_lvol; 1837 1838 /* Data found */ 1839 g_io->u.bdev.offset_blocks = 10; 1840 lvol_seek_data(g_lvol, g_io); 1841 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1842 CU_ASSERT(g_io->u.bdev.seek.offset == g_blob_allocated_io_unit_offset); 1843 1844 /* Data not found */ 1845 g_io->u.bdev.offset_blocks = 30; 1846 lvol_seek_data(g_lvol, g_io); 1847 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1848 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1849 1850 /* Hole found */ 1851 g_io->u.bdev.offset_blocks = 10; 1852 lvol_seek_hole(g_lvol, g_io); 1853 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1854 CU_ASSERT(g_io->u.bdev.seek.offset == 10); 1855 1856 /* Hole not found */ 1857 g_io->u.bdev.offset_blocks = 30; 1858 lvol_seek_hole(g_lvol, g_io); 1859 CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1860 CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX); 1861 1862 free(g_io); 1863 free(g_lvol); 1864 } 1865 1866 static void 1867 ut_esnap_dev_create(void) 1868 { 1869 struct spdk_lvol_store lvs = { 0 }; 1870 struct spdk_lvol lvol = { 0 }; 1871 struct spdk_blob blob = { 0 }; 1872 const char uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4"; 1873 char bad_uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4"; 1874 char *unterminated; 1875 size_t len; 1876 struct spdk_bs_dev *bs_dev = NULL; 1877 int rc; 1878 1879 ut_init_bdev("bdev0", uuid_str); 1880 1881 /* NULL esnap_id */ 1882 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, NULL, 0, &bs_dev); 1883 CU_ASSERT(rc == -EINVAL); 1884 CU_ASSERT(bs_dev == NULL); 1885 1886 /* Unterminated UUID: asan should catch reads past end of allocated buffer. */ 1887 len = strlen(uuid_str); 1888 unterminated = calloc(1, len); 1889 SPDK_CU_ASSERT_FATAL(unterminated != NULL); 1890 memcpy(unterminated, uuid_str, len); 1891 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, unterminated, len, &bs_dev); 1892 CU_ASSERT(rc == -EINVAL); 1893 CU_ASSERT(bs_dev == NULL); 1894 1895 /* Invalid UUID but the right length is invalid */ 1896 bad_uuid_str[2] = 'z'; 1897 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, bad_uuid_str, sizeof(uuid_str), 1898 &bs_dev); 1899 CU_ASSERT(rc == -EINVAL); 1900 CU_ASSERT(bs_dev == NULL); 1901 1902 /* Bdev not found */ 1903 bad_uuid_str[2] = 'c'; 1904 MOCK_SET(spdk_lvol_is_degraded, true); 1905 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, bad_uuid_str, sizeof(uuid_str), &bs_dev); 1906 CU_ASSERT(rc == 0); 1907 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1908 CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy); 1909 bs_dev->destroy(bs_dev); 1910 1911 /* Cannot get a claim */ 1912 /* TODO: This suggests we need a way to wait for a claim to be available. */ 1913 lvol_already_opened = true; 1914 MOCK_SET(spdk_lvol_is_degraded, true); 1915 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1916 CU_ASSERT(rc == 0); 1917 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1918 CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy); 1919 bs_dev->destroy(bs_dev); 1920 1921 /* Happy path */ 1922 lvol_already_opened = false; 1923 MOCK_SET(spdk_lvol_is_degraded, false); 1924 rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev); 1925 CU_ASSERT(rc == 0); 1926 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 1927 CU_ASSERT(bs_dev->destroy == ut_bs_dev_destroy); 1928 bs_dev->destroy(bs_dev); 1929 1930 lvol_already_opened = false; 1931 free(unterminated); 1932 MOCK_CLEAR(spdk_lvol_is_degraded); 1933 } 1934 1935 static void 1936 ut_lvol_esnap_clone_bad_args(void) 1937 { 1938 struct spdk_lvol_store *lvs; 1939 const char *esnap_uuid = "255f4236-9427-42d0-a9d1-aa17f37dd8db"; 1940 const char *other_uuid = "255f4236-9427-42d0-a9f1-aa17f37dd8db"; 1941 char *esnap_name = "esnap1"; 1942 int rc; 1943 1944 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1945 1946 /* Lvol store is successfully created */ 1947 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1948 lvol_store_op_with_handle_complete, NULL); 1949 CU_ASSERT(rc == 0); 1950 CU_ASSERT(g_lvserrno == 0); 1951 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1952 CU_ASSERT(g_lvol_store->bs_dev != NULL); 1953 lvs = g_lvol_store; 1954 1955 rc = spdk_uuid_parse(&g_bdev.uuid, esnap_uuid); 1956 CU_ASSERT(rc == 0); 1957 g_bdev.name = esnap_name; 1958 g_bdev.blocklen = 512; 1959 SPDK_CU_ASSERT_FATAL(SPDK_BS_PAGE_SIZE % g_bdev.blocklen == 0); 1960 g_bdev.blockcnt = 8192; 1961 1962 /* Error when lvs is NULL */ 1963 g_lvolerrno = 0xbad; 1964 vbdev_lvol_create_bdev_clone(esnap_uuid, NULL, "clone1", vbdev_lvol_create_complete, NULL); 1965 CU_ASSERT(g_lvolerrno == -EINVAL); 1966 1967 /* Error when the bdev does not exist */ 1968 g_lvolerrno = 0xbad; 1969 vbdev_lvol_create_bdev_clone(other_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL); 1970 CU_ASSERT(g_lvolerrno == -ENODEV); 1971 1972 /* Success when creating by bdev UUID */ 1973 g_lvolerrno = 0xbad; 1974 vbdev_lvol_create_bdev_clone(esnap_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL); 1975 CU_ASSERT(g_lvolerrno == 0); 1976 1977 /* Success when creating by bdev name */ 1978 g_lvolerrno = 0xbad; 1979 vbdev_lvol_create_bdev_clone(esnap_name, lvs, "clone2", vbdev_lvol_create_complete, NULL); 1980 CU_ASSERT(g_lvolerrno == 0); 1981 1982 g_lvol_store = lvs; 1983 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1984 CU_ASSERT(g_lvserrno == 0); 1985 CU_ASSERT(g_lvol_store == NULL); 1986 } 1987 1988 static void 1989 ut_lvol_shallow_copy(void) 1990 { 1991 struct spdk_lvol_store *lvs; 1992 int sz = 10; 1993 int rc; 1994 1995 ut_init_bdev(DEFAULT_BDEV_NAME, DEFAULT_BDEV_UUID); 1996 1997 /* Lvol store is successfully created */ 1998 rc = vbdev_lvs_create(DEFAULT_BDEV_NAME, "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0, 1999 lvol_store_op_with_handle_complete, NULL); 2000 CU_ASSERT(rc == 0); 2001 CU_ASSERT(g_lvserrno == 0); 2002 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 2003 CU_ASSERT(g_lvol_store->bs_dev != NULL); 2004 lvs = g_lvol_store; 2005 2006 /* Successful lvol create */ 2007 g_lvolerrno = -1; 2008 rc = vbdev_lvol_create(lvs, "lvol_sc", sz, false, LVOL_CLEAR_WITH_DEFAULT, 2009 vbdev_lvol_create_complete, 2010 NULL); 2011 SPDK_CU_ASSERT_FATAL(rc == 0); 2012 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 2013 CU_ASSERT(g_lvolerrno == 0); 2014 2015 /* Shallow copy error with NULL lvol */ 2016 rc = vbdev_lvol_shallow_copy(NULL, "", NULL, NULL, vbdev_lvol_shallow_copy_complete, NULL); 2017 CU_ASSERT(rc == -EINVAL); 2018 2019 /* Shallow copy error with NULL bdev name */ 2020 rc = vbdev_lvol_shallow_copy(g_lvol, NULL, NULL, NULL, vbdev_lvol_shallow_copy_complete, NULL); 2021 CU_ASSERT(rc == -EINVAL); 2022 2023 /* Successful shallow copy */ 2024 g_lvolerrno = -1; 2025 lvol_already_opened = false; 2026 rc = vbdev_lvol_shallow_copy(g_lvol, DEFAULT_BDEV_NAME, NULL, NULL, 2027 vbdev_lvol_shallow_copy_complete, NULL); 2028 CU_ASSERT(rc == 0); 2029 CU_ASSERT(g_lvolerrno == 0); 2030 2031 /* Successful lvol destroy */ 2032 vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL); 2033 CU_ASSERT(g_lvol == NULL); 2034 2035 /* Destroy lvol store */ 2036 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 2037 CU_ASSERT(g_lvserrno == 0); 2038 CU_ASSERT(g_lvol_store == NULL); 2039 } 2040 2041 static void 2042 ut_lvol_set_external_parent(void) 2043 { 2044 struct spdk_lvol_store lvs = { 0 }; 2045 struct spdk_lvol lvol = { 0 }; 2046 const char *esnap_uuid = "255f4236-9427-42d0-a9d1-aa17f37dd8db"; 2047 const char *other_uuid = "255f4236-9427-42d0-a9f1-aa17f37dd8db"; 2048 char *esnap_name = "esnap1"; 2049 2050 lvol.lvol_store = &lvs; 2051 2052 ut_init_bdev(esnap_name, esnap_uuid); 2053 g_bdev.blocklen = 512; 2054 g_bdev.blockcnt = 8192; 2055 2056 /* Error when the bdev does not exist */ 2057 g_lvolerrno = 0xbad; 2058 vbdev_lvol_set_external_parent(&lvol, other_uuid, vbdev_lvol_op_complete, NULL); 2059 CU_ASSERT(g_lvolerrno == -ENODEV); 2060 2061 /* Success when setting parent by bdev UUID */ 2062 g_lvolerrno = 0xbad; 2063 vbdev_lvol_set_external_parent(&lvol, esnap_uuid, vbdev_lvol_op_complete, NULL); 2064 CU_ASSERT(g_lvolerrno == 0); 2065 2066 /* Success when setting parent by bdev name */ 2067 g_lvolerrno = 0xbad; 2068 vbdev_lvol_set_external_parent(&lvol, esnap_name, vbdev_lvol_op_complete, NULL); 2069 CU_ASSERT(g_lvolerrno == 0); 2070 } 2071 2072 int 2073 main(int argc, char **argv) 2074 { 2075 CU_pSuite suite = NULL; 2076 unsigned int num_failures; 2077 2078 CU_initialize_registry(); 2079 2080 suite = CU_add_suite("lvol", NULL, NULL); 2081 2082 CU_ADD_TEST(suite, ut_lvs_init); 2083 CU_ADD_TEST(suite, ut_lvol_init); 2084 CU_ADD_TEST(suite, ut_lvol_snapshot); 2085 CU_ADD_TEST(suite, ut_lvol_clone); 2086 CU_ADD_TEST(suite, ut_lvs_destroy); 2087 CU_ADD_TEST(suite, ut_lvs_unload); 2088 CU_ADD_TEST(suite, ut_lvol_resize); 2089 CU_ADD_TEST(suite, ut_lvol_set_read_only); 2090 CU_ADD_TEST(suite, ut_lvol_hotremove); 2091 CU_ADD_TEST(suite, ut_vbdev_lvol_get_io_channel); 2092 CU_ADD_TEST(suite, ut_vbdev_lvol_io_type_supported); 2093 CU_ADD_TEST(suite, ut_lvol_read_write); 2094 CU_ADD_TEST(suite, ut_vbdev_lvol_submit_request); 2095 CU_ADD_TEST(suite, ut_lvol_examine_config); 2096 CU_ADD_TEST(suite, ut_lvol_examine_disk); 2097 CU_ADD_TEST(suite, ut_lvol_rename); 2098 CU_ADD_TEST(suite, ut_bdev_finish); 2099 CU_ADD_TEST(suite, ut_lvs_rename); 2100 CU_ADD_TEST(suite, ut_lvol_seek); 2101 CU_ADD_TEST(suite, ut_esnap_dev_create); 2102 CU_ADD_TEST(suite, ut_lvol_esnap_clone_bad_args); 2103 CU_ADD_TEST(suite, ut_lvol_shallow_copy); 2104 CU_ADD_TEST(suite, ut_lvol_set_external_parent); 2105 2106 allocate_threads(1); 2107 set_thread(0); 2108 2109 num_failures = spdk_ut_run_tests(argc, argv, NULL); 2110 CU_cleanup_registry(); 2111 2112 free_threads(); 2113 2114 return num_failures; 2115 } 2116