1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk_cunit.h" 35 #include "spdk/string.h" 36 37 #include "bdev/lvol/vbdev_lvol.c" 38 39 #define SPDK_BS_PAGE_SIZE 0x1000 40 41 int g_lvolerrno; 42 int g_lvserrno; 43 int g_cluster_size; 44 int g_registered_bdevs; 45 int g_num_lvols = 0; 46 struct spdk_lvol_store *g_lvs = NULL; 47 struct spdk_lvol *g_lvol = NULL; 48 struct lvol_store_bdev *g_lvs_bdev = NULL; 49 struct spdk_bdev *g_base_bdev = NULL; 50 struct spdk_bdev_io *g_io = NULL; 51 struct spdk_io_channel *g_ch = NULL; 52 struct lvol_task *g_task = NULL; 53 54 static struct spdk_bdev g_bdev = {}; 55 static struct spdk_bs_dev *g_bs_dev = NULL; 56 static struct spdk_lvol_store *g_lvol_store = NULL; 57 bool lvol_store_initialize_fail = false; 58 bool lvol_store_initialize_cb_fail = false; 59 bool lvol_already_opened = false; 60 bool g_examine_done = false; 61 bool g_bdev_alias_already_exists = false; 62 bool g_lvs_with_name_already_exists = false; 63 64 int 65 spdk_bdev_alias_add(struct spdk_bdev *bdev, const char *alias) 66 { 67 struct spdk_bdev_alias *tmp; 68 69 CU_ASSERT(alias != NULL); 70 CU_ASSERT(bdev != NULL); 71 if (g_bdev_alias_already_exists) { 72 return -EEXIST; 73 } 74 75 tmp = calloc(1, sizeof(*tmp)); 76 SPDK_CU_ASSERT_FATAL(tmp != NULL); 77 78 tmp->alias = strdup(alias); 79 SPDK_CU_ASSERT_FATAL(tmp->alias != NULL); 80 81 TAILQ_INSERT_TAIL(&bdev->aliases, tmp, tailq); 82 83 return 0; 84 } 85 86 int 87 spdk_bdev_alias_del(struct spdk_bdev *bdev, const char *alias) 88 { 89 struct spdk_bdev_alias *tmp; 90 91 CU_ASSERT(alias != NULL); 92 CU_ASSERT(bdev != NULL); 93 94 TAILQ_FOREACH(tmp, &bdev->aliases, tailq) { 95 if (strncmp(alias, tmp->alias, SPDK_LVOL_NAME_MAX) == 0) { 96 TAILQ_REMOVE(&bdev->aliases, tmp, tailq); 97 free(tmp->alias); 98 free(tmp); 99 return 0; 100 } 101 } 102 103 return -ENOENT; 104 } 105 106 void 107 spdk_bdev_destruct_done(struct spdk_bdev *bdev, int bdeverrno) 108 { 109 } 110 111 void 112 spdk_lvs_rename(struct spdk_lvol_store *lvs, const char *new_name, 113 spdk_lvs_op_complete cb_fn, void *cb_arg) 114 { 115 if (g_lvs_with_name_already_exists) { 116 g_lvolerrno = -EEXIST; 117 } else { 118 strncpy(lvs->name, new_name, SPDK_LVS_NAME_MAX); 119 g_lvolerrno = 0; 120 } 121 122 cb_fn(cb_arg, g_lvolerrno); 123 } 124 125 void 126 spdk_lvol_rename(struct spdk_lvol *lvol, const char *new_name, 127 spdk_lvol_op_complete cb_fn, void *cb_arg) 128 { 129 struct spdk_lvol *tmp; 130 131 if (strncmp(lvol->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 132 cb_fn(cb_arg, 0); 133 return; 134 } 135 136 TAILQ_FOREACH(tmp, &lvol->lvol_store->lvols, link) { 137 if (strncmp(tmp->name, new_name, SPDK_LVOL_NAME_MAX) == 0) { 138 SPDK_ERRLOG("Lvol %s already exists in lvol store %s\n", new_name, lvol->lvol_store->name); 139 cb_fn(cb_arg, -EEXIST); 140 return; 141 } 142 } 143 144 strncpy(lvol->name, new_name, SPDK_LVOL_NAME_MAX); 145 146 cb_fn(cb_arg, g_lvolerrno); 147 } 148 149 void 150 spdk_lvol_open(struct spdk_lvol *lvol, spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 151 { 152 cb_fn(cb_arg, lvol, g_lvolerrno); 153 } 154 155 void 156 spdk_blob_close(struct spdk_blob *b, spdk_blob_op_complete cb_fn, void *cb_arg) 157 { 158 } 159 160 uint64_t 161 spdk_blob_get_num_clusters(struct spdk_blob *b) 162 { 163 return 0; 164 } 165 166 static struct spdk_lvol *_lvol_create(struct spdk_lvol_store *lvs); 167 168 void 169 spdk_lvs_load(struct spdk_bs_dev *dev, 170 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 171 { 172 struct spdk_lvol_store *lvs; 173 int i; 174 175 if (g_lvserrno == 0) { 176 lvs = calloc(1, sizeof(*lvs)); 177 SPDK_CU_ASSERT_FATAL(lvs != NULL); 178 TAILQ_INIT(&lvs->lvols); 179 g_lvol_store = lvs; 180 for (i = 0; i < g_num_lvols; i++) { 181 _lvol_create(lvs); 182 } 183 } 184 185 cb_fn(cb_arg, g_lvol_store, g_lvserrno); 186 } 187 188 int 189 spdk_bs_bdev_claim(struct spdk_bs_dev *bs_dev, struct spdk_bdev_module *module) 190 { 191 if (lvol_already_opened == true) { 192 return -1; 193 } 194 195 lvol_already_opened = true; 196 197 return 0; 198 } 199 200 void 201 spdk_bdev_unregister(struct spdk_bdev *vbdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg) 202 { 203 SPDK_CU_ASSERT_FATAL(vbdev != NULL); 204 vbdev->fn_table->destruct(vbdev->ctxt); 205 } 206 207 void 208 spdk_bdev_module_finish_done(void) 209 { 210 return; 211 } 212 213 uint64_t 214 spdk_bs_get_page_size(struct spdk_blob_store *bs) 215 { 216 return SPDK_BS_PAGE_SIZE; 217 } 218 219 static void 220 bdev_blob_destroy(struct spdk_bs_dev *bs_dev) 221 { 222 CU_ASSERT(g_bs_dev != NULL); 223 CU_ASSERT(bs_dev != NULL); 224 CU_ASSERT(g_bs_dev == bs_dev); 225 free(bs_dev); 226 g_bs_dev = NULL; 227 lvol_already_opened = false; 228 } 229 230 struct spdk_bs_dev * 231 spdk_bdev_create_bs_dev(struct spdk_bdev *bdev, spdk_bdev_remove_cb_t remove_cb, void *remove_ctx) 232 { 233 struct spdk_bs_dev *bs_dev; 234 235 if (lvol_already_opened == true || bdev == NULL) { 236 return NULL; 237 } 238 239 bs_dev = calloc(1, sizeof(*bs_dev)); 240 SPDK_CU_ASSERT_FATAL(bs_dev != NULL); 241 bs_dev->destroy = bdev_blob_destroy; 242 243 CU_ASSERT(g_bs_dev == NULL); 244 g_bs_dev = bs_dev; 245 return bs_dev; 246 } 247 248 void 249 spdk_lvs_opts_init(struct spdk_lvs_opts *opts) 250 { 251 } 252 253 int 254 spdk_lvs_init(struct spdk_bs_dev *bs_dev, struct spdk_lvs_opts *o, 255 spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg) 256 { 257 struct spdk_lvol_store *lvs; 258 int error = 0; 259 260 if (lvol_store_initialize_fail) { 261 return -1; 262 } 263 264 if (lvol_store_initialize_cb_fail) { 265 bs_dev->destroy(bs_dev); 266 lvs = NULL; 267 error = -1; 268 } else { 269 lvs = calloc(1, sizeof(*lvs)); 270 SPDK_CU_ASSERT_FATAL(lvs != NULL); 271 TAILQ_INIT(&lvs->lvols); 272 spdk_uuid_generate(&lvs->uuid); 273 strncpy(lvs->name, o->name, SPDK_LVS_NAME_MAX); 274 lvs->bs_dev = bs_dev; 275 error = 0; 276 } 277 cb_fn(cb_arg, lvs, error); 278 279 return 0; 280 } 281 282 int 283 spdk_lvs_unload(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, void *cb_arg) 284 { 285 struct spdk_lvol *lvol, *tmp; 286 287 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 288 TAILQ_REMOVE(&lvs->lvols, lvol, link); 289 free(lvol->unique_id); 290 free(lvol); 291 } 292 g_lvol_store = NULL; 293 free(lvs); 294 295 g_bs_dev->destroy(g_bs_dev); 296 297 if (cb_fn != NULL) { 298 cb_fn(cb_arg, 0); 299 } 300 301 return 0; 302 } 303 304 int 305 spdk_lvs_destroy(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, 306 void *cb_arg) 307 { 308 struct spdk_lvol *lvol, *tmp; 309 char *alias; 310 311 TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) { 312 TAILQ_REMOVE(&lvs->lvols, lvol, link); 313 314 alias = spdk_sprintf_alloc("%s/%s", lvs->name, lvol->name); 315 if (alias == NULL) { 316 SPDK_ERRLOG("Cannot alloc memory for alias\n"); 317 return -1; 318 } 319 spdk_bdev_alias_del(lvol->bdev, alias); 320 321 free(alias); 322 free(lvol->unique_id); 323 free(lvol); 324 } 325 g_lvol_store = NULL; 326 free(lvs); 327 328 g_bs_dev->destroy(g_bs_dev); 329 330 if (cb_fn != NULL) { 331 cb_fn(cb_arg, 0); 332 } 333 334 return 0; 335 } 336 337 void 338 spdk_lvol_resize(struct spdk_lvol *lvol, size_t sz, spdk_lvol_op_complete cb_fn, void *cb_arg) 339 { 340 cb_fn(cb_arg, 0); 341 } 342 343 int 344 spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size) 345 { 346 bdev->blockcnt = size; 347 return 0; 348 } 349 350 uint64_t 351 spdk_bs_get_cluster_size(struct spdk_blob_store *bs) 352 { 353 return g_cluster_size; 354 } 355 356 struct spdk_bdev * 357 spdk_bdev_get_by_name(const char *bdev_name) 358 { 359 if (!strcmp(g_base_bdev->name, bdev_name)) { 360 return g_base_bdev; 361 } 362 363 return NULL; 364 } 365 366 void 367 spdk_lvol_close(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 368 { 369 struct spdk_lvs_req *destruct_req; 370 struct spdk_lvol *iter_lvol, *tmp; 371 bool all_lvols_closed = true; 372 373 lvol->ref_count--; 374 375 TAILQ_FOREACH_SAFE(iter_lvol, &lvol->lvol_store->lvols, link, tmp) { 376 if (iter_lvol->ref_count != 0) { 377 all_lvols_closed = false; 378 } 379 } 380 381 destruct_req = lvol->lvol_store->destruct_req; 382 if (destruct_req && all_lvols_closed == true) { 383 if (!lvol->lvol_store->destruct) { 384 spdk_lvs_unload(lvol->lvol_store, destruct_req->cb_fn, destruct_req->cb_arg); 385 free(destruct_req); 386 } 387 } 388 389 cb_fn(cb_arg, 0); 390 } 391 392 void 393 spdk_lvol_destroy(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg) 394 { 395 struct spdk_lvs_req *destruct_req; 396 397 SPDK_CU_ASSERT_FATAL(lvol == g_lvol); 398 399 if (lvol->ref_count != 0) { 400 cb_fn(cb_arg, -ENODEV); 401 } 402 403 TAILQ_REMOVE(&lvol->lvol_store->lvols, lvol, link); 404 405 destruct_req = lvol->lvol_store->destruct_req; 406 if (destruct_req && TAILQ_EMPTY(&lvol->lvol_store->lvols)) { 407 if (!lvol->lvol_store->destruct) { 408 spdk_lvs_unload(lvol->lvol_store, destruct_req->cb_fn, destruct_req->cb_arg); 409 } else { 410 spdk_lvs_destroy(lvol->lvol_store, destruct_req->cb_fn, destruct_req->cb_arg); 411 free(destruct_req); 412 } 413 } 414 g_lvol = NULL; 415 free(lvol->unique_id); 416 free(lvol); 417 418 cb_fn(cb_arg, 0); 419 } 420 421 void 422 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 423 { 424 } 425 426 struct spdk_io_channel *spdk_lvol_get_io_channel(struct spdk_lvol *lvol) 427 { 428 CU_ASSERT(lvol == g_lvol); 429 return g_ch; 430 } 431 432 void 433 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 434 { 435 CU_ASSERT(cb == lvol_read); 436 } 437 438 void 439 spdk_blob_io_read(struct spdk_blob *blob, struct spdk_io_channel *channel, 440 void *payload, uint64_t offset, uint64_t length, 441 spdk_blob_op_complete cb_fn, void *cb_arg) 442 { 443 } 444 445 void 446 spdk_blob_io_write(struct spdk_blob *blob, struct spdk_io_channel *channel, 447 void *payload, uint64_t offset, uint64_t length, 448 spdk_blob_op_complete cb_fn, void *cb_arg) 449 { 450 } 451 452 void 453 spdk_blob_io_unmap(struct spdk_blob *blob, struct spdk_io_channel *channel, 454 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 455 { 456 CU_ASSERT(blob == NULL); 457 CU_ASSERT(channel == g_ch); 458 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 459 CU_ASSERT(length == g_io->u.bdev.num_blocks); 460 } 461 462 void 463 spdk_blob_io_write_zeroes(struct spdk_blob *blob, struct spdk_io_channel *channel, 464 uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg) 465 { 466 CU_ASSERT(blob == NULL); 467 CU_ASSERT(channel == g_ch); 468 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 469 CU_ASSERT(length == g_io->u.bdev.num_blocks); 470 } 471 472 void 473 spdk_blob_io_writev(struct spdk_blob *blob, struct spdk_io_channel *channel, 474 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 475 spdk_blob_op_complete cb_fn, void *cb_arg) 476 { 477 CU_ASSERT(blob == NULL); 478 CU_ASSERT(channel == g_ch); 479 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 480 CU_ASSERT(length == g_io->u.bdev.num_blocks); 481 } 482 483 void 484 spdk_blob_io_readv(struct spdk_blob *blob, struct spdk_io_channel *channel, 485 struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length, 486 spdk_blob_op_complete cb_fn, void *cb_arg) 487 { 488 CU_ASSERT(blob == NULL); 489 CU_ASSERT(channel == g_ch); 490 CU_ASSERT(offset == g_io->u.bdev.offset_blocks); 491 CU_ASSERT(length == g_io->u.bdev.num_blocks); 492 } 493 494 void 495 spdk_bdev_module_list_add(struct spdk_bdev_module *bdev_module) 496 { 497 } 498 499 int 500 spdk_json_write_name(struct spdk_json_write_ctx *w, const char *name) 501 { 502 return 0; 503 } 504 505 int 506 spdk_json_write_string(struct spdk_json_write_ctx *w, const char *val) 507 { 508 return 0; 509 } 510 511 int 512 spdk_json_write_bool(struct spdk_json_write_ctx *w, bool val) 513 { 514 return 0; 515 } 516 517 int 518 spdk_json_write_object_begin(struct spdk_json_write_ctx *w) 519 { 520 return 0; 521 } 522 523 int 524 spdk_json_write_object_end(struct spdk_json_write_ctx *w) 525 { 526 return 0; 527 } 528 529 const char * 530 spdk_bdev_get_name(const struct spdk_bdev *bdev) 531 { 532 return "test"; 533 } 534 535 int 536 spdk_vbdev_register(struct spdk_bdev *vbdev, struct spdk_bdev **base_bdevs, int base_bdev_count) 537 { 538 TAILQ_INIT(&vbdev->aliases); 539 540 g_registered_bdevs++; 541 return 0; 542 } 543 544 void 545 spdk_bdev_module_examine_done(struct spdk_bdev_module *module) 546 { 547 g_examine_done = true; 548 } 549 550 static struct spdk_lvol * 551 _lvol_create(struct spdk_lvol_store *lvs) 552 { 553 struct spdk_lvol *lvol = calloc(1, sizeof(*lvol)); 554 555 SPDK_CU_ASSERT_FATAL(lvol != NULL); 556 557 lvol->lvol_store = lvs; 558 lvol->ref_count++; 559 lvol->unique_id = spdk_sprintf_alloc("%s", "UNIT_TEST_UUID"); 560 SPDK_CU_ASSERT_FATAL(lvol->unique_id != NULL); 561 562 TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link); 563 564 return lvol; 565 } 566 567 int 568 spdk_lvol_create(struct spdk_lvol_store *lvs, const char *name, size_t sz, 569 bool thin_provision, spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 570 { 571 struct spdk_lvol *lvol; 572 573 lvol = _lvol_create(lvs); 574 strncpy(lvol->name, name, SPDK_LVS_NAME_MAX); 575 cb_fn(cb_arg, lvol, 0); 576 577 return 0; 578 } 579 580 void 581 spdk_lvol_create_snapshot(struct spdk_lvol *lvol, const char *snapshot_name, 582 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 583 { 584 struct spdk_lvol *snap; 585 586 snap = _lvol_create(lvol->lvol_store); 587 strncpy(snap->name, snapshot_name, SPDK_LVOL_NAME_MAX); 588 cb_fn(cb_arg, snap, 0); 589 } 590 591 void 592 spdk_lvol_create_clone(struct spdk_lvol *lvol, const char *clone_name, 593 spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg) 594 { 595 struct spdk_lvol *clone; 596 597 clone = _lvol_create(lvol->lvol_store); 598 strncpy(clone->name, clone_name, SPDK_LVS_NAME_MAX); 599 cb_fn(cb_arg, clone, 0); 600 } 601 602 static void 603 lvol_store_op_complete(void *cb_arg, int lvserrno) 604 { 605 g_lvserrno = lvserrno; 606 return; 607 } 608 609 static void 610 lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno) 611 { 612 g_lvserrno = lvserrno; 613 g_lvol_store = lvs; 614 return; 615 } 616 617 static void 618 vbdev_lvol_create_complete(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) 619 { 620 g_lvolerrno = lvolerrno; 621 g_lvol = lvol; 622 } 623 624 static void 625 vbdev_lvol_resize_complete(void *cb_arg, int lvolerrno) 626 { 627 g_lvolerrno = lvolerrno; 628 } 629 630 static void 631 vbdev_lvol_rename_complete(void *cb_arg, int lvolerrno) 632 { 633 g_lvolerrno = lvolerrno; 634 } 635 636 static void 637 ut_lvs_destroy(void) 638 { 639 int rc = 0; 640 int sz = 10; 641 struct spdk_lvol_store *lvs; 642 643 /* Lvol store is succesfully created */ 644 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 645 CU_ASSERT(rc == 0); 646 CU_ASSERT(g_lvserrno == 0); 647 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 648 CU_ASSERT(g_bs_dev != NULL); 649 650 /* Create g_base_dev */ 651 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 652 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 653 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 654 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 655 g_lvs_bdev->bdev = g_base_bdev; 656 657 lvs = g_lvol_store; 658 g_lvol_store = NULL; 659 660 spdk_uuid_generate(&lvs->uuid); 661 662 /* Suuccessfully create lvol, which should be unloaded with lvs later */ 663 g_lvolerrno = -1; 664 rc = vbdev_lvol_create(lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 665 CU_ASSERT(rc == 0); 666 CU_ASSERT(g_lvolerrno == 0); 667 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 668 669 /* Unload lvol store */ 670 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 671 CU_ASSERT(g_lvserrno == 0); 672 CU_ASSERT(g_lvol_store == NULL); 673 674 free(g_lvs_bdev); 675 free(g_base_bdev); 676 } 677 678 static void 679 ut_lvol_init(void) 680 { 681 int sz = 10; 682 int rc; 683 684 g_lvs = calloc(1, sizeof(*g_lvs)); 685 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 686 TAILQ_INIT(&g_lvs->lvols); 687 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 688 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 689 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 690 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 691 692 /* Assign name to lvs */ 693 strncpy(g_lvs->name, "UNIT_TEST_LVS_NAME", SPDK_LVS_NAME_MAX); 694 SPDK_CU_ASSERT_FATAL(g_lvs->name != NULL); 695 696 g_lvs_bdev->lvs = g_lvs; 697 g_lvs_bdev->bdev = g_base_bdev; 698 699 spdk_uuid_generate(&g_lvs->uuid); 700 701 TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 702 703 /* Successful lvol create */ 704 g_lvolerrno = -1; 705 rc = vbdev_lvol_create(g_lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 706 SPDK_CU_ASSERT_FATAL(rc == 0); 707 CU_ASSERT(g_lvol != NULL); 708 CU_ASSERT(g_lvolerrno == 0); 709 710 /* Successful lvol destruct */ 711 vbdev_lvol_destruct(g_lvol); 712 CU_ASSERT(g_lvol == NULL); 713 714 TAILQ_REMOVE(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 715 716 free(g_lvs); 717 free(g_lvs_bdev); 718 free(g_base_bdev); 719 } 720 721 static void 722 ut_lvol_snapshot(void) 723 { 724 int sz = 10; 725 int rc; 726 struct spdk_lvol *lvol = NULL; 727 728 g_lvs = calloc(1, sizeof(*g_lvs)); 729 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 730 TAILQ_INIT(&g_lvs->lvols); 731 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 732 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 733 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 734 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 735 736 /* Assign name to lvs */ 737 strncpy(g_lvs->name, "UNIT_TEST_LVS_NAME", SPDK_LVS_NAME_MAX); 738 SPDK_CU_ASSERT_FATAL(g_lvs->name != NULL); 739 740 g_lvs_bdev->lvs = g_lvs; 741 g_lvs_bdev->bdev = g_base_bdev; 742 743 spdk_uuid_generate(&g_lvs->uuid); 744 745 TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 746 747 /* Successful lvol create */ 748 g_lvolerrno = -1; 749 rc = vbdev_lvol_create(g_lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 750 SPDK_CU_ASSERT_FATAL(rc == 0); 751 CU_ASSERT(g_lvol != NULL); 752 CU_ASSERT(g_lvolerrno == 0); 753 754 lvol = g_lvol; 755 756 /* Successful snap create */ 757 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 758 SPDK_CU_ASSERT_FATAL(rc == 0); 759 CU_ASSERT(g_lvol != NULL); 760 CU_ASSERT(g_lvolerrno == 0); 761 762 /* Successful lvol destruct */ 763 vbdev_lvol_destruct(g_lvol); 764 CU_ASSERT(g_lvol == NULL); 765 766 /* Successful snap destruct */ 767 g_lvol = lvol; 768 vbdev_lvol_destruct(g_lvol); 769 CU_ASSERT(g_lvol == NULL); 770 771 TAILQ_REMOVE(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 772 773 free(g_lvs); 774 free(g_lvs_bdev); 775 free(g_base_bdev); 776 } 777 778 static void 779 ut_lvol_clone(void) 780 { 781 int sz = 10; 782 int rc; 783 struct spdk_lvol *lvol = NULL; 784 struct spdk_lvol *snap = NULL; 785 struct spdk_lvol *clone = NULL; 786 787 g_lvs = calloc(1, sizeof(*g_lvs)); 788 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 789 TAILQ_INIT(&g_lvs->lvols); 790 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 791 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 792 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 793 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 794 795 /* Assign name to lvs */ 796 strncpy(g_lvs->name, "UNIT_TEST_LVS_NAME", SPDK_LVS_NAME_MAX); 797 SPDK_CU_ASSERT_FATAL(g_lvs->name != NULL); 798 799 g_lvs_bdev->lvs = g_lvs; 800 g_lvs_bdev->bdev = g_base_bdev; 801 802 spdk_uuid_generate(&g_lvs->uuid); 803 804 TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 805 806 /* Successful lvol create */ 807 g_lvolerrno = -1; 808 rc = vbdev_lvol_create(g_lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 809 SPDK_CU_ASSERT_FATAL(rc == 0); 810 CU_ASSERT(g_lvol != NULL); 811 CU_ASSERT(g_lvolerrno == 0); 812 813 lvol = g_lvol; 814 815 /* Successful snap create */ 816 vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL); 817 SPDK_CU_ASSERT_FATAL(rc == 0); 818 CU_ASSERT(g_lvol != NULL); 819 CU_ASSERT(g_lvolerrno == 0); 820 821 snap = g_lvol; 822 823 /* Successful clone create */ 824 vbdev_lvol_create_clone(snap, "clone", vbdev_lvol_create_complete, NULL); 825 826 SPDK_CU_ASSERT_FATAL(rc == 0); 827 CU_ASSERT(g_lvol != NULL); 828 CU_ASSERT(g_lvolerrno == 0); 829 830 clone = g_lvol; 831 832 /* Successful lvol destruct */ 833 g_lvol = lvol; 834 vbdev_lvol_destruct(g_lvol); 835 CU_ASSERT(g_lvol == NULL); 836 837 /* Successful clone destruct */ 838 g_lvol = clone; 839 vbdev_lvol_destruct(g_lvol); 840 CU_ASSERT(g_lvol == NULL); 841 842 /* Successful snap destruct */ 843 g_lvol = snap; 844 vbdev_lvol_destruct(g_lvol); 845 CU_ASSERT(g_lvol == NULL); 846 847 TAILQ_REMOVE(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 848 849 free(g_lvs); 850 free(g_lvs_bdev); 851 free(g_base_bdev); 852 } 853 854 static void 855 ut_lvol_hotremove(void) 856 { 857 int rc = 0; 858 859 lvol_store_initialize_fail = false; 860 lvol_store_initialize_cb_fail = false; 861 lvol_already_opened = false; 862 g_bs_dev = NULL; 863 864 /* Lvol store is succesfully created */ 865 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 866 CU_ASSERT(rc == 0); 867 CU_ASSERT(g_lvserrno == 0); 868 CU_ASSERT(g_lvol_store != NULL); 869 CU_ASSERT(g_bs_dev != NULL); 870 871 /* Hot remove callback with NULL - stability check */ 872 vbdev_lvs_hotremove_cb(NULL); 873 874 /* Hot remove lvs on bdev removal */ 875 vbdev_lvs_hotremove_cb(&g_bdev); 876 877 CU_ASSERT(g_lvol_store == NULL); 878 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 879 880 } 881 882 static void 883 ut_lvol_examine(void) 884 { 885 struct spdk_bdev *bdev; 886 887 lvol_already_opened = false; 888 g_bs_dev = NULL; 889 g_lvserrno = 0; 890 g_examine_done = false; 891 892 /* Examine with NULL bdev */ 893 vbdev_lvs_examine(NULL); 894 CU_ASSERT(g_bs_dev == NULL); 895 CU_ASSERT(g_lvol_store == NULL); 896 CU_ASSERT(g_examine_done == true); 897 898 /* Examine unsuccessfully - bdev already opened */ 899 g_bs_dev = NULL; 900 g_examine_done = false; 901 g_lvserrno = -1; 902 lvol_already_opened = true; 903 vbdev_lvs_examine(&g_bdev); 904 CU_ASSERT(g_bs_dev == NULL); 905 CU_ASSERT(g_lvol_store == NULL); 906 CU_ASSERT(g_examine_done == true); 907 908 /* Examine unsuccessfully - fail on lvol store */ 909 g_bs_dev = NULL; 910 g_examine_done = false; 911 g_lvserrno = -1; 912 lvol_already_opened = false; 913 vbdev_lvs_examine(&g_bdev); 914 CU_ASSERT(g_bs_dev != NULL); 915 CU_ASSERT(g_lvol_store == NULL); 916 CU_ASSERT(g_examine_done == true); 917 CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs)); 918 free(g_bs_dev); 919 920 /* Examine unsuccesfully - fail on lvol load */ 921 g_bs_dev = NULL; 922 g_lvserrno = 0; 923 g_lvolerrno = -1; 924 g_num_lvols = 1; 925 g_examine_done = false; 926 lvol_already_opened = false; 927 g_registered_bdevs = 0; 928 vbdev_lvs_examine(&g_bdev); 929 CU_ASSERT(g_bs_dev != NULL); 930 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 931 CU_ASSERT(g_examine_done == true); 932 CU_ASSERT(g_registered_bdevs == 0); 933 CU_ASSERT(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 934 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols)); 935 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 936 free(g_bs_dev); 937 938 /* Examine succesfully */ 939 g_lvs = calloc(1, sizeof(*g_lvs)); 940 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 941 TAILQ_INIT(&g_lvs->lvols); 942 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 943 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 944 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 945 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 946 947 /* Assign name to lvs */ 948 strncpy(g_lvs->name, "UNIT_TEST_LVS_NAME", SPDK_LVS_NAME_MAX); 949 SPDK_CU_ASSERT_FATAL(g_lvs->name != NULL); 950 951 g_bs_dev = NULL; 952 g_lvserrno = 0; 953 g_lvolerrno = 0; 954 g_examine_done = false; 955 g_registered_bdevs = 0; 956 lvol_already_opened = false; 957 vbdev_lvs_examine(&g_bdev); 958 CU_ASSERT(g_bs_dev != NULL); 959 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 960 CU_ASSERT(g_examine_done == true); 961 CU_ASSERT(g_registered_bdevs != 0); 962 CU_ASSERT(!TAILQ_EMPTY(&g_spdk_lvol_pairs)); 963 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols)); 964 TAILQ_FIRST(&g_lvol_store->lvols)->ref_count--; 965 bdev = TAILQ_FIRST(&g_lvol_store->lvols)->bdev; 966 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 967 free(bdev->name); 968 free(bdev); 969 free(g_bs_dev); 970 free(g_lvol_store); 971 972 free(g_lvs); 973 free(g_lvs_bdev); 974 free(g_base_bdev); 975 } 976 977 static void 978 ut_lvol_rename(void) 979 { 980 struct spdk_lvol *lvol; 981 struct spdk_lvol *lvol2; 982 int sz = 10; 983 int rc; 984 985 g_lvs = calloc(1, sizeof(*g_lvs)); 986 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 987 TAILQ_INIT(&g_lvs->lvols); 988 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 989 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 990 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 991 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 992 993 /* Assign name to lvs */ 994 strncpy(g_lvs->name, "UNIT_TEST_LVS_NAME", SPDK_LVS_NAME_MAX); 995 SPDK_CU_ASSERT_FATAL(g_lvs->name != NULL); 996 997 g_lvs_bdev->lvs = g_lvs; 998 g_lvs_bdev->bdev = g_base_bdev; 999 1000 spdk_uuid_generate(&g_lvs->uuid); 1001 1002 TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1003 1004 /* Successful lvols create */ 1005 g_lvolerrno = -1; 1006 rc = vbdev_lvol_create(g_lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1007 SPDK_CU_ASSERT_FATAL(rc == 0); 1008 CU_ASSERT(g_lvol != NULL); 1009 CU_ASSERT(g_lvolerrno == 0); 1010 lvol = g_lvol; 1011 1012 g_lvolerrno = -1; 1013 rc = vbdev_lvol_create(g_lvs, "lvol2", sz, false, vbdev_lvol_create_complete, NULL); 1014 SPDK_CU_ASSERT_FATAL(rc == 0); 1015 CU_ASSERT(g_lvol != NULL); 1016 CU_ASSERT(g_lvolerrno == 0); 1017 lvol2 = g_lvol; 1018 1019 /* Successful rename lvol */ 1020 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1021 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1022 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1023 1024 /* Renaming lvol with name already existing */ 1025 g_bdev_alias_already_exists = true; 1026 vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1027 g_bdev_alias_already_exists = false; 1028 SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0); 1029 CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name"); 1030 1031 /* Renaming lvol with it's own name */ 1032 vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL); 1033 SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0); 1034 CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name"); 1035 1036 /* Successful lvols destruct */ 1037 g_lvol = lvol; 1038 vbdev_lvol_destruct(g_lvol); 1039 CU_ASSERT(g_lvol == NULL); 1040 1041 g_lvol = lvol2; 1042 vbdev_lvol_destruct(g_lvol); 1043 CU_ASSERT(g_lvol == NULL); 1044 1045 TAILQ_REMOVE(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1046 1047 free(g_lvs); 1048 free(g_lvs_bdev); 1049 free(g_base_bdev); 1050 } 1051 1052 static void 1053 ut_lvol_resize(void) 1054 { 1055 int sz = 10; 1056 int rc = 0; 1057 1058 g_lvs = calloc(1, sizeof(*g_lvs)); 1059 SPDK_CU_ASSERT_FATAL(g_lvs != NULL); 1060 1061 TAILQ_INIT(&g_lvs->lvols); 1062 1063 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 1064 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 1065 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1066 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1067 1068 /* Assign name to bdev */ 1069 g_base_bdev->name = strdup("UNIT_TEST_LVS_NAME/old_lvol"); 1070 SPDK_CU_ASSERT_FATAL(g_base_bdev->name != NULL); 1071 1072 g_lvs_bdev->lvs = g_lvs; 1073 g_lvs_bdev->bdev = g_base_bdev; 1074 1075 spdk_uuid_generate(&g_lvs->uuid); 1076 g_base_bdev->blocklen = 4096; 1077 TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1078 1079 /* Successful lvol create */ 1080 g_lvolerrno = -1; 1081 rc = vbdev_lvol_create(g_lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1082 CU_ASSERT(rc == 0); 1083 CU_ASSERT(g_lvolerrno == 0); 1084 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1085 1086 g_base_bdev->ctxt = g_lvol; 1087 1088 free(g_base_bdev->name); 1089 g_base_bdev->name = spdk_sprintf_alloc("%s", g_lvol->unique_id); 1090 SPDK_CU_ASSERT_FATAL(g_base_bdev->name != NULL); 1091 1092 g_lvolerrno = -1; 1093 /* Successful lvol resize */ 1094 vbdev_lvol_resize(g_lvol, 20, vbdev_lvol_resize_complete, NULL); 1095 CU_ASSERT(g_lvolerrno == 0); 1096 CU_ASSERT(g_base_bdev->blockcnt == 20 * g_cluster_size / g_base_bdev->blocklen); 1097 1098 /* Resize with NULL lvol */ 1099 vbdev_lvol_resize(NULL, 20, vbdev_lvol_resize_complete, NULL); 1100 CU_ASSERT(g_lvolerrno != 0); 1101 1102 /* Successful lvol destruct */ 1103 vbdev_lvol_destruct(g_lvol); 1104 CU_ASSERT(g_lvol == NULL); 1105 1106 TAILQ_REMOVE(&g_spdk_lvol_pairs, g_lvs_bdev, lvol_stores); 1107 free(g_lvs); 1108 free(g_lvs_bdev); 1109 free(g_base_bdev->name); 1110 free(g_base_bdev); 1111 } 1112 1113 static void 1114 ut_lvs_unload(void) 1115 { 1116 int rc = 0; 1117 int sz = 10; 1118 struct spdk_lvol_store *lvs; 1119 1120 /* Lvol store is succesfully created */ 1121 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1122 CU_ASSERT(rc == 0); 1123 CU_ASSERT(g_lvserrno == 0); 1124 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1125 CU_ASSERT(g_bs_dev != NULL); 1126 1127 /* Create g_base_dev */ 1128 g_lvs_bdev = calloc(1, sizeof(*g_lvs_bdev)); 1129 SPDK_CU_ASSERT_FATAL(g_lvs_bdev != NULL); 1130 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1131 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1132 g_lvs_bdev->bdev = g_base_bdev; 1133 1134 lvs = g_lvol_store; 1135 g_lvol_store = NULL; 1136 1137 spdk_uuid_generate(&lvs->uuid); 1138 1139 /* Suuccessfully create lvol, which should be destroyed with lvs later */ 1140 g_lvolerrno = -1; 1141 rc = vbdev_lvol_create(lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1142 CU_ASSERT(rc == 0); 1143 CU_ASSERT(g_lvolerrno == 0); 1144 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1145 1146 /* Unload lvol store */ 1147 vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL); 1148 CU_ASSERT(g_lvserrno == 0); 1149 CU_ASSERT(g_lvol_store == NULL); 1150 CU_ASSERT(g_lvol != NULL); 1151 1152 free(g_lvs_bdev); 1153 free(g_base_bdev); 1154 } 1155 1156 static void 1157 ut_lvs_init(void) 1158 { 1159 int rc = 0; 1160 struct spdk_lvol_store *lvs; 1161 struct spdk_bs_dev *bs_dev_temp; 1162 1163 /* spdk_lvs_init() fails */ 1164 lvol_store_initialize_fail = true; 1165 1166 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1167 CU_ASSERT(rc != 0); 1168 CU_ASSERT(g_lvserrno == 0); 1169 CU_ASSERT(g_lvol_store == NULL); 1170 CU_ASSERT(g_bs_dev == NULL); 1171 1172 lvol_store_initialize_fail = false; 1173 1174 /* spdk_lvs_init_cb() fails */ 1175 lvol_store_initialize_cb_fail = true; 1176 1177 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1178 CU_ASSERT(rc == 0); 1179 CU_ASSERT(g_lvserrno != 0); 1180 CU_ASSERT(g_lvol_store == NULL); 1181 CU_ASSERT(g_bs_dev == NULL); 1182 1183 lvol_store_initialize_cb_fail = false; 1184 1185 /* Lvol store is succesfully created */ 1186 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1187 CU_ASSERT(rc == 0); 1188 CU_ASSERT(g_lvserrno == 0); 1189 CU_ASSERT(g_lvol_store != NULL); 1190 CU_ASSERT(g_bs_dev != NULL); 1191 1192 lvs = g_lvol_store; 1193 g_lvol_store = NULL; 1194 bs_dev_temp = g_bs_dev; 1195 g_bs_dev = NULL; 1196 1197 /* Bdev with lvol store already claimed */ 1198 rc = vbdev_lvs_create(&g_bdev, "lvs", 0, lvol_store_op_with_handle_complete, NULL); 1199 CU_ASSERT(rc != 0); 1200 CU_ASSERT(g_lvserrno == 0); 1201 CU_ASSERT(g_lvol_store == NULL); 1202 CU_ASSERT(g_bs_dev == NULL); 1203 1204 /* Destruct lvol store */ 1205 g_bs_dev = bs_dev_temp; 1206 1207 vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL); 1208 CU_ASSERT(g_lvserrno == 0); 1209 CU_ASSERT(g_lvol_store == NULL); 1210 CU_ASSERT(g_bs_dev == NULL); 1211 free(g_bs_dev); 1212 1213 } 1214 1215 static void 1216 ut_vbdev_lvol_get_io_channel(void) 1217 { 1218 struct spdk_io_channel *ch; 1219 1220 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1221 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1222 1223 ch = vbdev_lvol_get_io_channel(g_lvol); 1224 CU_ASSERT(ch == g_ch); 1225 1226 free(g_lvol); 1227 1228 } 1229 1230 static void 1231 ut_vbdev_lvol_io_type_supported(void) 1232 { 1233 struct spdk_lvol *lvol = g_lvol; 1234 bool ret; 1235 /* Supported types */ 1236 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ); 1237 CU_ASSERT(ret == true); 1238 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE); 1239 CU_ASSERT(ret == true); 1240 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET); 1241 CU_ASSERT(ret == true); 1242 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP); 1243 CU_ASSERT(ret == true); 1244 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1245 CU_ASSERT(ret == true); 1246 1247 /* Unsupported types */ 1248 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH); 1249 CU_ASSERT(ret == false); 1250 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN); 1251 CU_ASSERT(ret == false); 1252 ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO); 1253 CU_ASSERT(ret == false); 1254 } 1255 1256 static void 1257 ut_lvol_op_comp(void) 1258 { 1259 struct lvol_task task; 1260 1261 lvol_op_comp(&task, 1); 1262 CU_ASSERT(task.status == SPDK_BDEV_IO_STATUS_FAILED); 1263 } 1264 1265 static void 1266 ut_lvol_read_write(void) 1267 { 1268 g_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct lvol_task)); 1269 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1270 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1271 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1272 g_lvol = calloc(1, sizeof(struct spdk_lvol)); 1273 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1274 1275 g_task = (struct lvol_task *)g_io->driver_ctx; 1276 g_io->bdev = g_base_bdev; 1277 g_io->bdev->ctxt = g_lvol; 1278 g_io->u.bdev.offset_blocks = 20; 1279 g_io->u.bdev.num_blocks = 20; 1280 1281 lvol_read(g_ch, g_io); 1282 CU_ASSERT(g_task->status == SPDK_BDEV_IO_STATUS_SUCCESS); 1283 1284 lvol_write(g_lvol, g_ch, g_io); 1285 CU_ASSERT(g_task->status == SPDK_BDEV_IO_STATUS_SUCCESS); 1286 1287 free(g_io); 1288 free(g_base_bdev); 1289 free(g_lvol); 1290 } 1291 1292 static void 1293 ut_vbdev_lvol_submit_request(void) 1294 { 1295 g_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct lvol_task)); 1296 SPDK_CU_ASSERT_FATAL(g_io != NULL); 1297 g_base_bdev = calloc(1, sizeof(struct spdk_bdev)); 1298 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1299 g_task = (struct lvol_task *)g_io->driver_ctx; 1300 1301 g_io->bdev = g_base_bdev; 1302 1303 g_io->type = SPDK_BDEV_IO_TYPE_READ; 1304 vbdev_lvol_submit_request(g_ch, g_io); 1305 1306 free(g_io); 1307 free(g_base_bdev); 1308 } 1309 1310 static void 1311 ut_lvs_rename(void) 1312 { 1313 int rc = 0; 1314 int sz = 10; 1315 struct spdk_lvol_store *lvs; 1316 struct spdk_bs_dev *b_bdev; 1317 1318 /* Lvol store is succesfully created */ 1319 rc = vbdev_lvs_create(&g_bdev, "old_lvs_name", 0, lvol_store_op_with_handle_complete, NULL); 1320 CU_ASSERT(rc == 0); 1321 CU_ASSERT(g_lvserrno == 0); 1322 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL); 1323 CU_ASSERT(g_bs_dev != NULL); 1324 b_bdev = g_bs_dev; 1325 1326 g_bs_dev = NULL; 1327 lvs = g_lvol_store; 1328 g_lvol_store = NULL; 1329 1330 g_base_bdev = calloc(1, sizeof(*g_base_bdev)); 1331 SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL); 1332 1333 /* Successfully create lvol, which should be destroyed with lvs later */ 1334 g_lvolerrno = -1; 1335 rc = vbdev_lvol_create(lvs, "lvol", sz, false, vbdev_lvol_create_complete, NULL); 1336 CU_ASSERT(rc == 0); 1337 CU_ASSERT(g_lvolerrno == 0); 1338 SPDK_CU_ASSERT_FATAL(g_lvol != NULL); 1339 1340 /* Trying to rename lvs with lvols created */ 1341 vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL); 1342 CU_ASSERT(g_lvserrno == 0); 1343 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1344 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias, "new_lvs_name/lvol"); 1345 1346 /* Trying to rename lvs with name already used by another lvs */ 1347 /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates 1348 * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */ 1349 g_lvs_with_name_already_exists = true; 1350 vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL); 1351 CU_ASSERT(g_lvserrno == -EEXIST); 1352 CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name"); 1353 CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias, "new_lvs_name/lvol"); 1354 g_lvs_with_name_already_exists = false; 1355 1356 /* Unload lvol store */ 1357 g_lvol_store = lvs; 1358 g_bs_dev = b_bdev; 1359 vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL); 1360 CU_ASSERT(g_lvserrno == 0); 1361 CU_ASSERT(g_lvol_store == NULL); 1362 1363 free(g_base_bdev->name); 1364 free(g_base_bdev); 1365 } 1366 1367 int main(int argc, char **argv) 1368 { 1369 CU_pSuite suite = NULL; 1370 unsigned int num_failures; 1371 1372 if (CU_initialize_registry() != CUE_SUCCESS) { 1373 return CU_get_error(); 1374 } 1375 1376 suite = CU_add_suite("lvol", NULL, NULL); 1377 if (suite == NULL) { 1378 CU_cleanup_registry(); 1379 return CU_get_error(); 1380 } 1381 1382 if ( 1383 CU_add_test(suite, "ut_lvs_init", ut_lvs_init) == NULL || 1384 CU_add_test(suite, "ut_lvol_init", ut_lvol_init) == NULL || 1385 CU_add_test(suite, "ut_lvol_snapshot", ut_lvol_snapshot) == NULL || 1386 CU_add_test(suite, "ut_lvol_clone", ut_lvol_clone) == NULL || 1387 CU_add_test(suite, "ut_lvs_destroy", ut_lvs_destroy) == NULL || 1388 CU_add_test(suite, "ut_lvs_unload", ut_lvs_unload) == NULL || 1389 CU_add_test(suite, "ut_lvol_resize", ut_lvol_resize) == NULL || 1390 CU_add_test(suite, "lvol_hotremove", ut_lvol_hotremove) == NULL || 1391 CU_add_test(suite, "ut_vbdev_lvol_get_io_channel", ut_vbdev_lvol_get_io_channel) == NULL || 1392 CU_add_test(suite, "ut_vbdev_lvol_io_type_supported", ut_vbdev_lvol_io_type_supported) == NULL || 1393 CU_add_test(suite, "ut_lvol_op_comp", ut_lvol_op_comp) == NULL || 1394 CU_add_test(suite, "ut_lvol_read_write", ut_lvol_read_write) == NULL || 1395 CU_add_test(suite, "ut_vbdev_lvol_submit_request", ut_vbdev_lvol_submit_request) == NULL || 1396 CU_add_test(suite, "lvol_examine", ut_lvol_examine) == NULL || 1397 CU_add_test(suite, "ut_lvol_rename", ut_lvol_rename) == NULL || 1398 CU_add_test(suite, "ut_lvs_rename", ut_lvs_rename) == NULL 1399 ) { 1400 CU_cleanup_registry(); 1401 return CU_get_error(); 1402 } 1403 1404 CU_basic_set_mode(CU_BRM_VERBOSE); 1405 CU_basic_run_tests(); 1406 num_failures = CU_get_number_of_failures(); 1407 CU_cleanup_registry(); 1408 return num_failures; 1409 } 1410