ceph/src/spdk/test/unit/lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c

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