ceph/src/spdk/test/unit/lib/lvol/lvol.c/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/blob.h"
  36 #include "spdk/thread.h"
  37 #include "spdk/util.h"
  38
  39 #include "common/lib/test_env.c"
  40
  41 #include "lvol/lvol.c"
  42
  43 #define DEV_BUFFER_SIZE (64 * 1024 * 1024)
  44 #define DEV_BUFFER_BLOCKLEN (4096)
  45 #define DEV_BUFFER_BLOCKCNT (DEV_BUFFER_SIZE / DEV_BUFFER_BLOCKLEN)
  46 #define BS_CLUSTER_SIZE (1024 * 1024)
  47 #define BS_FREE_CLUSTERS (DEV_BUFFER_SIZE / BS_CLUSTER_SIZE)
  48 #define BS_PAGE_SIZE (4096)
  49
  50 #define SPDK_BLOB_OPTS_CLUSTER_SZ (1024 * 1024)
  51 #define SPDK_BLOB_OPTS_NUM_MD_PAGES UINT32_MAX
  52 #define SPDK_BLOB_OPTS_MAX_MD_OPS 32
  53 #define SPDK_BLOB_OPTS_MAX_CHANNEL_OPS 512
  54
  55 #define SPDK_BLOB_THIN_PROV (1ULL << 0)
  56
  57 const char *uuid = "828d9766-ae50-11e7-bd8d-001e67edf350";
  58
  59 struct spdk_blob {
  60         spdk_blob_id            id;
  61         uint32_t                ref;
  62         struct spdk_blob_store *bs;
  63         int                     close_status;
  64         int                     open_status;
  65         int                     load_status;
  66         TAILQ_ENTRY(spdk_blob)  link;
  67         char                    uuid[SPDK_UUID_STRING_LEN];
  68         char                    name[SPDK_LVS_NAME_MAX];
  69         bool                    thin_provisioned;
  70 };
  71
  72 int g_lvolerrno;
  73 int g_lvserrno;
  74 int g_close_super_status;
  75 int g_resize_rc;
  76 int g_inflate_rc;
  77 bool g_lvs_rename_blob_open_error = false;
  78 struct spdk_lvol_store *g_lvol_store;
  79 struct spdk_lvol *g_lvol;
  80 spdk_blob_id g_blobid = 1;
  81 struct spdk_io_channel *g_io_channel;
  82
  83 struct spdk_blob_store {
  84         struct spdk_bs_opts     bs_opts;
  85         spdk_blob_id            super_blobid;
  86         TAILQ_HEAD(, spdk_blob) blobs;
  87         int                     get_super_status;
  88 };
  89
  90 struct lvol_ut_bs_dev {
  91         struct spdk_bs_dev      bs_dev;
  92         int                     init_status;
  93         int                     load_status;
  94         struct spdk_blob_store  *bs;
  95 };
  96
  97 void spdk_bs_inflate_blob(struct spdk_blob_store *bs, struct spdk_io_channel *channel,
  98                           spdk_blob_id blobid, spdk_blob_op_complete cb_fn, void *cb_arg)
  99 {
 100         cb_fn(cb_arg, g_inflate_rc);
 101 }
 102
 103 void spdk_bs_blob_decouple_parent(struct spdk_blob_store *bs, struct spdk_io_channel *channel,
 104                                   spdk_blob_id blobid, spdk_blob_op_complete cb_fn, void *cb_arg)
 105 {
 106         cb_fn(cb_arg, g_inflate_rc);
 107 }
 108
 109 void
 110 spdk_bs_iter_next(struct spdk_blob_store *bs, struct spdk_blob *b,
 111                   spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
 112 {
 113         struct spdk_blob *next;
 114         int _errno = 0;
 115
 116         next = TAILQ_NEXT(b, link);
 117         if (next == NULL) {
 118                 _errno = -ENOENT;
 119         } else if (next->load_status != 0) {
 120                 _errno = next->load_status;
 121         }
 122
 123         cb_fn(cb_arg, next, _errno);
 124 }
 125
 126 void
 127 spdk_bs_iter_first(struct spdk_blob_store *bs,
 128                    spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
 129 {
 130         struct spdk_blob *first;
 131         int _errno = 0;
 132
 133         first = TAILQ_FIRST(&bs->blobs);
 134         if (first == NULL) {
 135                 _errno = -ENOENT;
 136         } else if (first->load_status != 0) {
 137                 _errno = first->load_status;
 138         }
 139
 140         cb_fn(cb_arg, first, _errno);
 141 }
 142
 143 uint64_t spdk_blob_get_num_clusters(struct spdk_blob *blob)
 144 {
 145         return 0;
 146 }
 147
 148 void
 149 spdk_bs_get_super(struct spdk_blob_store *bs,
 150                   spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
 151 {
 152         if (bs->get_super_status != 0) {
 153                 cb_fn(cb_arg, 0, bs->get_super_status);
 154         } else {
 155                 cb_fn(cb_arg, bs->super_blobid, 0);
 156         }
 157 }
 158
 159 void
 160 spdk_bs_set_super(struct spdk_blob_store *bs, spdk_blob_id blobid,
 161                   spdk_bs_op_complete cb_fn, void *cb_arg)
 162 {
 163         bs->super_blobid = blobid;
 164         cb_fn(cb_arg, 0);
 165 }
 166
 167 void
 168 spdk_bs_load(struct spdk_bs_dev *dev, struct spdk_bs_opts *opts,
 169              spdk_bs_op_with_handle_complete cb_fn, void *cb_arg)
 170 {
 171         struct lvol_ut_bs_dev *ut_dev = SPDK_CONTAINEROF(dev, struct lvol_ut_bs_dev, bs_dev);
 172         struct spdk_blob_store *bs = NULL;
 173
 174         if (ut_dev->load_status == 0) {
 175                 bs = ut_dev->bs;
 176         }
 177
 178         cb_fn(cb_arg, bs, ut_dev->load_status);
 179 }
 180
 181 struct spdk_io_channel *spdk_bs_alloc_io_channel(struct spdk_blob_store *bs)
 182 {
 183         if (g_io_channel == NULL) {
 184                 g_io_channel = calloc(1, sizeof(struct spdk_io_channel));
 185                 SPDK_CU_ASSERT_FATAL(g_io_channel != NULL);
 186         }
 187         g_io_channel->ref++;
 188         return g_io_channel;
 189 }
 190
 191 void spdk_bs_free_io_channel(struct spdk_io_channel *channel)
 192 {
 193         g_io_channel->ref--;
 194         if (g_io_channel->ref == 0) {
 195                 free(g_io_channel);
 196                 g_io_channel = NULL;
 197         }
 198         return;
 199 }
 200
 201 int
 202 spdk_blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value,
 203                     uint16_t value_len)
 204 {
 205         if (!strcmp(name, "uuid")) {
 206                 CU_ASSERT(value_len == SPDK_UUID_STRING_LEN);
 207                 memcpy(blob->uuid, value, SPDK_UUID_STRING_LEN);
 208         } else if (!strcmp(name, "name")) {
 209                 CU_ASSERT(value_len <= SPDK_LVS_NAME_MAX);
 210                 memcpy(blob->name, value, value_len);
 211         }
 212
 213         return 0;
 214 }
 215
 216 int
 217 spdk_blob_get_xattr_value(struct spdk_blob *blob, const char *name,
 218                           const void **value, size_t *value_len)
 219 {
 220         if (!strcmp(name, "uuid") && strnlen(blob->uuid, SPDK_UUID_STRING_LEN) != 0) {
 221                 CU_ASSERT(strnlen(blob->uuid, SPDK_UUID_STRING_LEN) == (SPDK_UUID_STRING_LEN - 1));
 222                 *value = blob->uuid;
 223                 *value_len = SPDK_UUID_STRING_LEN;
 224                 return 0;
 225         } else if (!strcmp(name, "name") && strnlen(blob->name, SPDK_LVS_NAME_MAX) != 0) {
 226                 *value = blob->name;
 227                 *value_len = strnlen(blob->name, SPDK_LVS_NAME_MAX) + 1;
 228                 return 0;
 229         }
 230
 231         return -ENOENT;
 232 }
 233
 234 int
 235 spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_id *ids,
 236                      size_t *count)
 237 {
 238         return 0;
 239 }
 240
 241 uint64_t
 242 spdk_bs_get_page_size(struct spdk_blob_store *bs)
 243 {
 244         return BS_PAGE_SIZE;
 245 }
 246
 247 int
 248 spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size)
 249 {
 250         bdev->blockcnt = size;
 251         return 0;
 252 }
 253
 254 static void
 255 init_dev(struct lvol_ut_bs_dev *dev)
 256 {
 257         memset(dev, 0, sizeof(*dev));
 258         dev->bs_dev.blockcnt = DEV_BUFFER_BLOCKCNT;
 259         dev->bs_dev.blocklen = DEV_BUFFER_BLOCKLEN;
 260 }
 261
 262 static void
 263 free_dev(struct lvol_ut_bs_dev *dev)
 264 {
 265         struct spdk_blob_store *bs = dev->bs;
 266         struct spdk_blob *blob, *tmp;
 267
 268         if (bs == NULL) {
 269                 return;
 270         }
 271
 272         TAILQ_FOREACH_SAFE(blob, &bs->blobs, link, tmp) {
 273                 TAILQ_REMOVE(&bs->blobs, blob, link);
 274                 free(blob);
 275         }
 276
 277         free(bs);
 278         dev->bs = NULL;
 279 }
 280
 281 void
 282 spdk_bs_init(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
 283              spdk_bs_op_with_handle_complete cb_fn, void *cb_arg)
 284 {
 285         struct lvol_ut_bs_dev *ut_dev = SPDK_CONTAINEROF(dev, struct lvol_ut_bs_dev, bs_dev);
 286         struct spdk_blob_store *bs;
 287
 288         bs = calloc(1, sizeof(*bs));
 289         SPDK_CU_ASSERT_FATAL(bs != NULL);
 290
 291         TAILQ_INIT(&bs->blobs);
 292
 293         ut_dev->bs = bs;
 294
 295         memcpy(&bs->bs_opts, o, sizeof(struct spdk_bs_opts));
 296
 297         cb_fn(cb_arg, bs, 0);
 298 }
 299
 300 void
 301 spdk_bs_unload(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, void *cb_arg)
 302 {
 303         cb_fn(cb_arg, 0);
 304 }
 305
 306 void
 307 spdk_bs_destroy(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn,
 308                 void *cb_arg)
 309 {
 310         free(bs);
 311
 312         cb_fn(cb_arg, 0);
 313 }
 314
 315 void
 316 spdk_bs_delete_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
 317                     spdk_blob_op_complete cb_fn, void *cb_arg)
 318 {
 319         struct spdk_blob *blob;
 320
 321         TAILQ_FOREACH(blob, &bs->blobs, link) {
 322                 if (blob->id == blobid) {
 323                         TAILQ_REMOVE(&bs->blobs, blob, link);
 324                         free(blob);
 325                         break;
 326                 }
 327         }
 328
 329         cb_fn(cb_arg, 0);
 330 }
 331
 332 spdk_blob_id
 333 spdk_blob_get_id(struct spdk_blob *blob)
 334 {
 335         return blob->id;
 336 }
 337
 338 void
 339 spdk_bs_opts_init(struct spdk_bs_opts *opts)
 340 {
 341         opts->cluster_sz = SPDK_BLOB_OPTS_CLUSTER_SZ;
 342         opts->num_md_pages = SPDK_BLOB_OPTS_NUM_MD_PAGES;
 343         opts->max_md_ops = SPDK_BLOB_OPTS_MAX_MD_OPS;
 344         opts->max_channel_ops = SPDK_BLOB_OPTS_MAX_CHANNEL_OPS;
 345         memset(&opts->bstype, 0, sizeof(opts->bstype));
 346 }
 347
 348 uint64_t
 349 spdk_bs_get_cluster_size(struct spdk_blob_store *bs)
 350 {
 351         return BS_CLUSTER_SIZE;
 352 }
 353
 354 void spdk_blob_close(struct spdk_blob *b, spdk_blob_op_complete cb_fn, void *cb_arg)
 355 {
 356         b->ref--;
 357
 358         cb_fn(cb_arg, b->close_status);
 359 }
 360
 361 void
 362 spdk_blob_resize(struct spdk_blob *blob, uint64_t sz, spdk_blob_op_complete cb_fn, void *cb_arg)
 363 {
 364         if (g_resize_rc != 0) {
 365                 return cb_fn(cb_arg, g_resize_rc);
 366         } else if (sz > DEV_BUFFER_SIZE / BS_CLUSTER_SIZE) {
 367                 return cb_fn(cb_arg, -ENOMEM);
 368         }
 369         cb_fn(cb_arg, 0);
 370 }
 371
 372 void
 373 spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
 374 {
 375         cb_fn(cb_arg, 0);
 376 }
 377
 378 void
 379 spdk_bs_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
 380                   spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
 381 {
 382         struct spdk_blob *blob;
 383
 384         if (!g_lvs_rename_blob_open_error) {
 385                 TAILQ_FOREACH(blob, &bs->blobs, link) {
 386                         if (blob->id == blobid) {
 387                                 blob->ref++;
 388                                 cb_fn(cb_arg, blob, blob->open_status);
 389                                 return;
 390                         }
 391                 }
 392         }
 393
 394         cb_fn(cb_arg, NULL, -ENOENT);
 395 }
 396
 397 uint64_t
 398 spdk_bs_free_cluster_count(struct spdk_blob_store *bs)
 399 {
 400         return BS_FREE_CLUSTERS;
 401 }
 402
 403 void
 404 spdk_blob_opts_init(struct spdk_blob_opts *opts)
 405 {
 406         opts->num_clusters = 0;
 407         opts->thin_provision = false;
 408         opts->xattrs.count = 0;
 409         opts->xattrs.names = NULL;
 410         opts->xattrs.ctx = NULL;
 411         opts->xattrs.get_value = NULL;
 412 }
 413
 414 void
 415 spdk_bs_create_blob(struct spdk_blob_store *bs,
 416                     spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
 417 {
 418         spdk_bs_create_blob_ext(bs, NULL, cb_fn, cb_arg);
 419 }
 420
 421 void
 422 spdk_bs_create_blob_ext(struct spdk_blob_store *bs, const struct spdk_blob_opts *opts,
 423                         spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
 424 {
 425         struct spdk_blob *b;
 426
 427         if (opts && opts->num_clusters > DEV_BUFFER_SIZE / BS_CLUSTER_SIZE) {
 428                 cb_fn(cb_arg, 0, -1);
 429                 return;
 430         }
 431
 432         b = calloc(1, sizeof(*b));
 433         SPDK_CU_ASSERT_FATAL(b != NULL);
 434
 435         b->id = g_blobid++;
 436         if (opts != NULL && opts->thin_provision) {
 437                 b->thin_provisioned = true;
 438         }
 439         b->bs = bs;
 440
 441         TAILQ_INSERT_TAIL(&bs->blobs, b, link);
 442         cb_fn(cb_arg, b->id, 0);
 443 }
 444
 445 void
 446 spdk_bs_create_snapshot(struct spdk_blob_store *bs, spdk_blob_id blobid,
 447                         const struct spdk_blob_xattr_opts *snapshot_xattrs,
 448                         spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
 449 {
 450         spdk_bs_create_blob_ext(bs, NULL, cb_fn, cb_arg);
 451 }
 452
 453 void
 454 spdk_bs_create_clone(struct spdk_blob_store *bs, spdk_blob_id blobid,
 455                      const struct spdk_blob_xattr_opts *clone_xattrs,
 456                      spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
 457 {
 458         spdk_bs_create_blob_ext(bs, NULL, cb_fn, cb_arg);
 459 }
 460
 461 static void
 462 _lvol_send_msg(spdk_thread_fn fn, void *ctx, void *thread_ctx)
 463 {
 464         fn(ctx);
 465 }
 466
 467 static void
 468 lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvol_store, int lvserrno)
 469 {
 470         g_lvol_store = lvol_store;
 471         g_lvserrno = lvserrno;
 472 }
 473
 474 static void
 475 lvol_op_complete(void *cb_arg, int lvolerrno)
 476 {
 477         g_lvolerrno = lvolerrno;
 478 }
 479
 480 static void
 481 lvol_op_with_handle_complete(void *cb_arg, struct spdk_lvol *lvol, int lvserrno)
 482 {
 483         g_lvol = lvol;
 484         g_lvserrno = lvserrno;
 485 }
 486
 487 static void
 488 lvol_store_op_complete(void *cb_arg, int lvserrno)
 489 {
 490         g_lvserrno = lvserrno;
 491 }
 492
 493 static void
 494 close_cb(void *cb_arg, int lvolerrno)
 495 {
 496         g_lvserrno = lvolerrno;
 497 }
 498
 499 static void
 500 destroy_cb(void *cb_arg, int lvolerrno)
 501 {
 502         g_lvserrno = lvolerrno;
 503 }
 504
 505 static void
 506 lvs_init_unload_success(void)
 507 {
 508         struct lvol_ut_bs_dev dev;
 509         struct spdk_lvs_opts opts;
 510         int rc = 0;
 511
 512         init_dev(&dev);
 513
 514         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 515         spdk_lvs_opts_init(&opts);
 516         snprintf(opts.name, sizeof(opts.name), "lvs");
 517
 518         g_lvserrno = -1;
 519
 520         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
 521         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 522         CU_ASSERT(rc == 0);
 523         CU_ASSERT(g_lvserrno == 0);
 524         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 525         CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores));
 526
 527         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 528         CU_ASSERT(g_lvserrno == 0);
 529         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
 530
 531         /* Lvol store has an open lvol, this unload should fail. */
 532         g_lvserrno = -1;
 533         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 534         CU_ASSERT(rc == -EBUSY);
 535         CU_ASSERT(g_lvserrno == -EBUSY);
 536         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 537         CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores));
 538
 539         /* Lvol has to be closed (or destroyed) before unloading lvol store. */
 540         spdk_lvol_close(g_lvol, close_cb, NULL);
 541         CU_ASSERT(g_lvserrno == 0);
 542
 543         g_lvserrno = -1;
 544         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 545         CU_ASSERT(rc == 0);
 546         CU_ASSERT(g_lvserrno == 0);
 547         g_lvol_store = NULL;
 548         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
 549
 550         free_dev(&dev);
 551
 552         spdk_free_thread();
 553 }
 554
 555 static void
 556 lvs_init_destroy_success(void)
 557 {
 558         struct lvol_ut_bs_dev dev;
 559         struct spdk_lvs_opts opts;
 560         int rc = 0;
 561
 562         init_dev(&dev);
 563
 564         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 565         spdk_lvs_opts_init(&opts);
 566         snprintf(opts.name, sizeof(opts.name), "lvs");
 567
 568         g_lvserrno = -1;
 569
 570         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 571         CU_ASSERT(rc == 0);
 572         CU_ASSERT(g_lvserrno == 0);
 573         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 574
 575         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 576         CU_ASSERT(g_lvserrno == 0);
 577         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
 578
 579         /* Lvol store contains one lvol, this destroy should fail. */
 580         g_lvserrno = -1;
 581         rc = spdk_lvs_destroy(g_lvol_store, lvol_store_op_complete, NULL);
 582         CU_ASSERT(rc == -EBUSY);
 583         CU_ASSERT(g_lvserrno == -EBUSY);
 584         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 585
 586         spdk_lvol_close(g_lvol, close_cb, NULL);
 587         CU_ASSERT(g_lvserrno == 0);
 588
 589         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
 590
 591         g_lvserrno = -1;
 592         rc = spdk_lvs_destroy(g_lvol_store, lvol_store_op_complete, NULL);
 593         CU_ASSERT(rc == 0);
 594         CU_ASSERT(g_lvserrno == 0);
 595         g_lvol_store = NULL;
 596
 597         spdk_free_thread();
 598 }
 599
 600 static void
 601 lvs_init_opts_success(void)
 602 {
 603         struct lvol_ut_bs_dev dev;
 604         struct spdk_lvs_opts opts;
 605         int rc = 0;
 606
 607         init_dev(&dev);
 608
 609         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 610
 611         g_lvserrno = -1;
 612
 613         spdk_lvs_opts_init(&opts);
 614         snprintf(opts.name, sizeof(opts.name), "lvs");
 615         opts.cluster_sz = 8192;
 616         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 617         CU_ASSERT(rc == 0);
 618         CU_ASSERT(g_lvserrno == 0);
 619         CU_ASSERT(dev.bs->bs_opts.cluster_sz == opts.cluster_sz);
 620         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 621
 622         g_lvserrno = -1;
 623         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 624         CU_ASSERT(rc == 0);
 625         CU_ASSERT(g_lvserrno == 0);
 626         g_lvol_store = NULL;
 627
 628         free_dev(&dev);
 629
 630         spdk_free_thread();
 631 }
 632
 633 static void
 634 lvs_unload_lvs_is_null_fail(void)
 635 {
 636         int rc = 0;
 637
 638         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 639
 640         g_lvserrno = -1;
 641         rc = spdk_lvs_unload(NULL, lvol_store_op_complete, NULL);
 642         CU_ASSERT(rc == -ENODEV);
 643         CU_ASSERT(g_lvserrno == -1);
 644
 645         spdk_free_thread();
 646 }
 647
 648 static void
 649 lvs_names(void)
 650 {
 651         struct lvol_ut_bs_dev dev_x, dev_y, dev_x2;
 652         struct spdk_lvs_opts opts_none, opts_x, opts_y, opts_full;
 653         struct spdk_lvol_store *lvs_x, *lvs_y, *lvs_x2;
 654         int rc = 0;
 655
 656         init_dev(&dev_x);
 657         init_dev(&dev_y);
 658         init_dev(&dev_x2);
 659
 660         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 661
 662         spdk_lvs_opts_init(&opts_none);
 663         spdk_lvs_opts_init(&opts_x);
 664         opts_x.name[0] = 'x';
 665         spdk_lvs_opts_init(&opts_y);
 666         opts_y.name[0] = 'y';
 667         spdk_lvs_opts_init(&opts_full);
 668         memset(opts_full.name, 'a', sizeof(opts_full.name));
 669
 670         /* Test that opts with no name fails spdk_lvs_init(). */
 671         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
 672         rc = spdk_lvs_init(&dev_x.bs_dev, &opts_none, lvol_store_op_with_handle_complete, NULL);
 673         CU_ASSERT(rc != 0);
 674         CU_ASSERT(g_lvol_store == NULL);
 675         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
 676
 677         /* Test that opts with no null terminator for name fails spdk_lvs_init(). */
 678         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
 679         rc = spdk_lvs_init(&dev_x.bs_dev, &opts_full, lvol_store_op_with_handle_complete, NULL);
 680         CU_ASSERT(rc != 0);
 681         CU_ASSERT(g_lvol_store == NULL);
 682         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
 683
 684         /* Test that we can create an lvolstore with name 'x'. */
 685         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
 686         g_lvol_store = NULL;
 687         rc = spdk_lvs_init(&dev_x.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
 688         CU_ASSERT(rc == 0);
 689         CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores));
 690         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 691         lvs_x = g_lvol_store;
 692
 693         /* Test that we can create an lvolstore with name 'y'. */
 694         g_lvol_store = NULL;
 695         rc = spdk_lvs_init(&dev_y.bs_dev, &opts_y, lvol_store_op_with_handle_complete, NULL);
 696         CU_ASSERT(rc == 0);
 697         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 698         lvs_y = g_lvol_store;
 699
 700         /* Test that we cannot create another lvolstore with name 'x'. */
 701         rc = spdk_lvs_init(&dev_x2.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
 702         CU_ASSERT(rc == -EEXIST);
 703
 704         /* Now destroy lvolstore 'x' and then confirm we can create a new lvolstore with name 'x'. */
 705         g_lvserrno = -1;
 706         rc = spdk_lvs_destroy(lvs_x, lvol_store_op_complete, NULL);
 707         CU_ASSERT(rc == 0);
 708         CU_ASSERT(g_lvserrno == 0);
 709         g_lvol_store = NULL;
 710         rc = spdk_lvs_init(&dev_x.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
 711         CU_ASSERT(rc == 0);
 712         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 713         lvs_x = g_lvol_store;
 714
 715         /*
 716          * Unload lvolstore 'x'.  Then we should be able to create another lvolstore with name 'x'.
 717          */
 718         g_lvserrno = -1;
 719         rc = spdk_lvs_unload(lvs_x, lvol_store_op_complete, NULL);
 720         CU_ASSERT(rc == 0);
 721         CU_ASSERT(g_lvserrno == 0);
 722         g_lvol_store = NULL;
 723         rc = spdk_lvs_init(&dev_x2.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
 724         CU_ASSERT(rc == 0);
 725         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 726         lvs_x2 = g_lvol_store;
 727
 728         /* Confirm that we cannot load the first lvolstore 'x'. */
 729         g_lvserrno = 0;
 730         spdk_lvs_load(&dev_x.bs_dev, lvol_store_op_with_handle_complete, NULL);
 731         CU_ASSERT(g_lvserrno != 0);
 732
 733         /* Destroy the second lvolstore 'x'.  Then we should be able to load the first lvolstore 'x'. */
 734         g_lvserrno = -1;
 735         rc = spdk_lvs_destroy(lvs_x2, lvol_store_op_complete, NULL);
 736         CU_ASSERT(rc == 0);
 737         CU_ASSERT(g_lvserrno == 0);
 738         g_lvserrno = -1;
 739         spdk_lvs_load(&dev_x.bs_dev, lvol_store_op_with_handle_complete, NULL);
 740         CU_ASSERT(g_lvserrno == 0);
 741         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 742         lvs_x = g_lvol_store;
 743
 744         g_lvserrno = -1;
 745         rc = spdk_lvs_destroy(lvs_x, lvol_store_op_complete, NULL);
 746         CU_ASSERT(rc == 0);
 747         CU_ASSERT(g_lvserrno == 0);
 748
 749         g_lvserrno = -1;
 750         rc = spdk_lvs_destroy(lvs_y, lvol_store_op_complete, NULL);
 751         CU_ASSERT(rc == 0);
 752         CU_ASSERT(g_lvserrno == 0);
 753
 754         spdk_free_thread();
 755 }
 756
 757 static void
 758 lvol_create_destroy_success(void)
 759 {
 760         struct lvol_ut_bs_dev dev;
 761         struct spdk_lvs_opts opts;
 762         int rc = 0;
 763
 764         init_dev(&dev);
 765
 766         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 767
 768         spdk_lvs_opts_init(&opts);
 769         snprintf(opts.name, sizeof(opts.name), "lvs");
 770
 771         g_lvserrno = -1;
 772         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 773         CU_ASSERT(rc == 0);
 774         CU_ASSERT(g_lvserrno == 0);
 775         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 776
 777         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 778         CU_ASSERT(g_lvserrno == 0);
 779         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
 780
 781         spdk_lvol_close(g_lvol, close_cb, NULL);
 782         CU_ASSERT(g_lvserrno == 0);
 783         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
 784         CU_ASSERT(g_lvserrno == 0);
 785
 786         g_lvserrno = -1;
 787         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 788         CU_ASSERT(rc == 0);
 789         CU_ASSERT(g_lvserrno == 0);
 790         g_lvol_store = NULL;
 791
 792         free_dev(&dev);
 793
 794         spdk_free_thread();
 795 }
 796
 797 static void
 798 lvol_create_fail(void)
 799 {
 800         struct lvol_ut_bs_dev dev;
 801         struct spdk_lvs_opts opts;
 802         int rc = 0;
 803
 804         init_dev(&dev);
 805
 806         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 807
 808         spdk_lvs_opts_init(&opts);
 809         snprintf(opts.name, sizeof(opts.name), "lvs");
 810
 811         g_lvol_store = NULL;
 812         g_lvserrno = 0;
 813         rc = spdk_lvs_init(NULL, &opts, lvol_store_op_with_handle_complete, NULL);
 814         CU_ASSERT(rc != 0);
 815         CU_ASSERT(g_lvol_store == NULL);
 816
 817         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 818         CU_ASSERT(rc == 0);
 819         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 820
 821         g_lvol = NULL;
 822         rc = spdk_lvol_create(NULL, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 823         CU_ASSERT(rc != 0);
 824         CU_ASSERT(g_lvol == NULL);
 825
 826         g_lvol = NULL;
 827         rc = spdk_lvol_create(g_lvol_store, "lvol", DEV_BUFFER_SIZE + 1, false,
 828                               lvol_op_with_handle_complete, NULL);
 829         CU_ASSERT(rc == 0);
 830         CU_ASSERT(g_lvserrno != 0);
 831         CU_ASSERT(g_lvol == NULL);
 832
 833         g_lvserrno = -1;
 834         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 835         CU_ASSERT(rc == 0);
 836         CU_ASSERT(g_lvserrno == 0);
 837         g_lvol_store = NULL;
 838
 839         free_dev(&dev);
 840
 841         spdk_free_thread();
 842 }
 843
 844 static void
 845 lvol_destroy_fail(void)
 846 {
 847         struct lvol_ut_bs_dev dev;
 848         struct spdk_lvs_opts opts;
 849         int rc = 0;
 850
 851         init_dev(&dev);
 852
 853         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 854
 855         spdk_lvs_opts_init(&opts);
 856         snprintf(opts.name, sizeof(opts.name), "lvs");
 857
 858         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 859         CU_ASSERT(rc == 0);
 860         CU_ASSERT(g_lvserrno == 0);
 861         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 862
 863         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 864         CU_ASSERT(g_lvserrno == 0);
 865         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
 866
 867         spdk_lvol_close(g_lvol, close_cb, NULL);
 868         CU_ASSERT(g_lvserrno == 0);
 869         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
 870         CU_ASSERT(g_lvserrno == 0);
 871
 872         g_lvserrno = -1;
 873         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 874         CU_ASSERT(rc == 0);
 875         CU_ASSERT(g_lvserrno == 0);
 876         g_lvol_store = NULL;
 877
 878         free_dev(&dev);
 879
 880         spdk_free_thread();
 881 }
 882
 883 static void
 884 lvol_close_fail(void)
 885 {
 886         struct lvol_ut_bs_dev dev;
 887         struct spdk_lvs_opts opts;
 888         int rc = 0;
 889
 890         init_dev(&dev);
 891
 892         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 893
 894         spdk_lvs_opts_init(&opts);
 895         snprintf(opts.name, sizeof(opts.name), "lvs");
 896
 897         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 898         CU_ASSERT(rc == 0);
 899         CU_ASSERT(g_lvserrno == 0);
 900         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 901
 902         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 903         CU_ASSERT(g_lvserrno == 0);
 904         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
 905
 906         spdk_lvol_close(g_lvol, close_cb, NULL);
 907         CU_ASSERT(g_lvserrno == 0);
 908
 909         g_lvserrno = -1;
 910         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 911         CU_ASSERT(rc == 0);
 912         CU_ASSERT(g_lvserrno == 0);
 913         g_lvol_store = NULL;
 914
 915         free_dev(&dev);
 916
 917         spdk_free_thread();
 918 }
 919
 920 static void
 921 lvol_close_success(void)
 922 {
 923         struct lvol_ut_bs_dev dev;
 924         struct spdk_lvs_opts opts;
 925         int rc = 0;
 926
 927         init_dev(&dev);
 928
 929         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 930
 931         spdk_lvs_opts_init(&opts);
 932         snprintf(opts.name, sizeof(opts.name), "lvs");
 933
 934         g_lvserrno = -1;
 935         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 936         CU_ASSERT(rc == 0);
 937         CU_ASSERT(g_lvserrno == 0);
 938         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 939
 940         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 941         CU_ASSERT(g_lvserrno == 0);
 942         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
 943
 944         spdk_lvol_close(g_lvol, close_cb, NULL);
 945         CU_ASSERT(g_lvserrno == 0);
 946
 947         g_lvserrno = -1;
 948         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
 949         CU_ASSERT(rc == 0);
 950         CU_ASSERT(g_lvserrno == 0);
 951         g_lvol_store = NULL;
 952
 953         free_dev(&dev);
 954
 955         spdk_free_thread();
 956 }
 957
 958 static void
 959 lvol_resize(void)
 960 {
 961         struct lvol_ut_bs_dev dev;
 962         struct spdk_lvs_opts opts;
 963         int rc = 0;
 964
 965         init_dev(&dev);
 966
 967         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
 968
 969         spdk_lvs_opts_init(&opts);
 970         snprintf(opts.name, sizeof(opts.name), "lvs");
 971
 972         g_resize_rc = 0;
 973         g_lvserrno = -1;
 974         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
 975         CU_ASSERT(rc == 0);
 976         CU_ASSERT(g_lvserrno == 0);
 977         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
 978
 979         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
 980         CU_ASSERT(g_lvserrno == 0);
 981         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
 982
 983         /* Resize to same size */
 984         spdk_lvol_resize(g_lvol, 10, lvol_store_op_complete, NULL);
 985         CU_ASSERT(g_lvserrno == 0);
 986
 987         /* Resize to smaller size */
 988         spdk_lvol_resize(g_lvol, 5, lvol_store_op_complete, NULL);
 989         CU_ASSERT(g_lvserrno == 0);
 990
 991         /* Resize to bigger size */
 992         spdk_lvol_resize(g_lvol, 15, lvol_store_op_complete, NULL);
 993         CU_ASSERT(g_lvserrno == 0);
 994
 995         /* Resize to size = 0 */
 996         spdk_lvol_resize(g_lvol, 0, lvol_store_op_complete, NULL);
 997         CU_ASSERT(g_lvserrno == 0);
 998
 999         /* Resize to bigger size than available */
1000         g_lvserrno = 0;
1001         spdk_lvol_resize(g_lvol, 0xFFFFFFFF, lvol_store_op_complete, NULL);
1002         CU_ASSERT(g_lvserrno != 0);
1003
1004         /* Fail resize */
1005         g_resize_rc = -1;
1006         g_lvserrno = 0;
1007         spdk_lvol_resize(g_lvol, 10, lvol_store_op_complete, NULL);
1008         CU_ASSERT(g_lvserrno != 0);
1009         g_resize_rc = 0;
1010
1011         g_resize_rc = 0;
1012         spdk_lvol_close(g_lvol, close_cb, NULL);
1013         CU_ASSERT(g_lvserrno == 0);
1014         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
1015         CU_ASSERT(g_lvserrno == 0);
1016
1017         g_lvserrno = -1;
1018         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1019         CU_ASSERT(rc == 0);
1020         CU_ASSERT(g_lvserrno == 0);
1021         g_lvol_store = NULL;
1022
1023         free_dev(&dev);
1024
1025         spdk_free_thread();
1026 }
1027
1028 static void
1029 null_cb(void *ctx, struct spdk_blob_store *bs, int bserrno)
1030 {
1031         SPDK_CU_ASSERT_FATAL(bs != NULL);
1032 }
1033
1034 static void
1035 lvs_load(void)
1036 {
1037         int rc = -1;
1038         struct lvol_ut_bs_dev dev;
1039         struct spdk_lvs_with_handle_req *req;
1040         struct spdk_bs_opts bs_opts = {};
1041         struct spdk_blob *super_blob;
1042
1043         req = calloc(1, sizeof(*req));
1044         SPDK_CU_ASSERT_FATAL(req != NULL);
1045
1046         init_dev(&dev);
1047         spdk_bs_opts_init(&bs_opts);
1048         snprintf(bs_opts.bstype.bstype, sizeof(bs_opts.bstype.bstype), "LVOLSTORE");
1049         spdk_bs_init(&dev.bs_dev, &bs_opts, null_cb, NULL);
1050
1051         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1052
1053         /* Fail on bs load */
1054         dev.load_status = -1;
1055         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1056         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1057         CU_ASSERT(g_lvserrno != 0);
1058         CU_ASSERT(g_lvol_store == NULL);
1059         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1060
1061         /* Fail on getting super blob */
1062         dev.load_status = 0;
1063         dev.bs->get_super_status = -1;
1064         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1065         CU_ASSERT(g_lvserrno == -ENODEV);
1066         CU_ASSERT(g_lvol_store == NULL);
1067         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1068
1069         /* Fail on opening super blob */
1070         g_lvserrno = 0;
1071         super_blob = calloc(1, sizeof(*super_blob));
1072         super_blob->id = 0x100;
1073         super_blob->open_status = -1;
1074         TAILQ_INSERT_TAIL(&dev.bs->blobs, super_blob, link);
1075         dev.bs->super_blobid = 0x100;
1076         dev.bs->get_super_status = 0;
1077         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1078         CU_ASSERT(g_lvserrno == -ENODEV);
1079         CU_ASSERT(g_lvol_store == NULL);
1080         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1081
1082         /* Fail on getting uuid */
1083         g_lvserrno = 0;
1084         super_blob->open_status = 0;
1085         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1086         CU_ASSERT(g_lvserrno == -EINVAL);
1087         CU_ASSERT(g_lvol_store == NULL);
1088         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1089
1090         /* Fail on getting name */
1091         g_lvserrno = 0;
1092         spdk_blob_set_xattr(super_blob, "uuid", uuid, SPDK_UUID_STRING_LEN);
1093         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1094         CU_ASSERT(g_lvserrno == -EINVAL);
1095         CU_ASSERT(g_lvol_store == NULL);
1096         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1097
1098         /* Fail on closing super blob */
1099         g_lvserrno = 0;
1100         spdk_blob_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1);
1101         super_blob->close_status = -1;
1102         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1103         CU_ASSERT(g_lvserrno == -ENODEV);
1104         CU_ASSERT(g_lvol_store == NULL);
1105         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1106
1107         /* Load successfully */
1108         g_lvserrno = 0;
1109         super_blob->close_status = 0;
1110         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1111         CU_ASSERT(g_lvserrno == 0);
1112         CU_ASSERT(g_lvol_store != NULL);
1113         CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores));
1114
1115         g_lvserrno = -1;
1116         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1117         CU_ASSERT(rc == 0);
1118         CU_ASSERT(g_lvserrno == 0);
1119         CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1120
1121         free(req);
1122         free_dev(&dev);
1123
1124         spdk_free_thread();
1125 }
1126
1127 static void
1128 lvols_load(void)
1129 {
1130         int rc = -1;
1131         struct lvol_ut_bs_dev dev;
1132         struct spdk_lvs_with_handle_req *req;
1133         struct spdk_bs_opts bs_opts;
1134         struct spdk_blob *super_blob, *blob1, *blob2, *blob3;
1135
1136         req = calloc(1, sizeof(*req));
1137         SPDK_CU_ASSERT_FATAL(req != NULL);
1138
1139         init_dev(&dev);
1140         spdk_bs_opts_init(&bs_opts);
1141         snprintf(bs_opts.bstype.bstype, sizeof(bs_opts.bstype.bstype), "LVOLSTORE");
1142         spdk_bs_init(&dev.bs_dev, &bs_opts, null_cb, NULL);
1143         super_blob = calloc(1, sizeof(*super_blob));
1144         SPDK_CU_ASSERT_FATAL(super_blob != NULL);
1145         super_blob->id = 0x100;
1146         spdk_blob_set_xattr(super_blob, "uuid", uuid, SPDK_UUID_STRING_LEN);
1147         spdk_blob_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1);
1148         TAILQ_INSERT_TAIL(&dev.bs->blobs, super_blob, link);
1149         dev.bs->super_blobid = 0x100;
1150
1151         /*
1152          * Create 3 blobs, write different char values to the last char in the UUID
1153          *  to make sure they are unique.
1154          */
1155         blob1 = calloc(1, sizeof(*blob1));
1156         SPDK_CU_ASSERT_FATAL(blob1 != NULL);
1157         blob1->id = 0x1;
1158         spdk_blob_set_xattr(blob1, "uuid", uuid, SPDK_UUID_STRING_LEN);
1159         spdk_blob_set_xattr(blob1, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX) + 1);
1160         blob1->uuid[SPDK_UUID_STRING_LEN - 2] = '1';
1161
1162         blob2 = calloc(1, sizeof(*blob2));
1163         SPDK_CU_ASSERT_FATAL(blob2 != NULL);
1164         blob2->id = 0x2;
1165         spdk_blob_set_xattr(blob2, "uuid", uuid, SPDK_UUID_STRING_LEN);
1166         spdk_blob_set_xattr(blob2, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX) + 1);
1167         blob2->uuid[SPDK_UUID_STRING_LEN - 2] = '2';
1168
1169         blob3 = calloc(1, sizeof(*blob3));
1170         SPDK_CU_ASSERT_FATAL(blob3 != NULL);
1171         blob3->id = 0x2;
1172         spdk_blob_set_xattr(blob3, "uuid", uuid, SPDK_UUID_STRING_LEN);
1173         spdk_blob_set_xattr(blob3, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX) + 1);
1174         blob3->uuid[SPDK_UUID_STRING_LEN - 2] = '3';
1175
1176         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1177
1178         /* Load lvs with 0 blobs */
1179         g_lvserrno = 0;
1180         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1181         CU_ASSERT(g_lvserrno == 0);
1182         CU_ASSERT(g_lvol_store != NULL);
1183         CU_ASSERT(g_lvserrno == 0);
1184
1185         g_lvserrno = -1;
1186         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1187         CU_ASSERT(rc == 0);
1188         CU_ASSERT(g_lvserrno == 0);
1189
1190         TAILQ_INSERT_TAIL(&dev.bs->blobs, blob1, link);
1191         TAILQ_INSERT_TAIL(&dev.bs->blobs, blob2, link);
1192         TAILQ_INSERT_TAIL(&dev.bs->blobs, blob3, link);
1193
1194         /* Load lvs again with 3 blobs, but fail on 1st one */
1195         g_lvol_store = NULL;
1196         g_lvserrno = 0;
1197         blob1->load_status = -1;
1198         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1199         CU_ASSERT(g_lvserrno != 0);
1200         CU_ASSERT(g_lvol_store == NULL);
1201
1202         /* Load lvs again with 3 blobs, but fail on 3rd one */
1203         g_lvol_store = NULL;
1204         g_lvserrno = 0;
1205         blob1->load_status = 0;
1206         blob2->load_status = 0;
1207         blob3->load_status = -1;
1208         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1209         CU_ASSERT(g_lvserrno != 0);
1210         CU_ASSERT(g_lvol_store == NULL);
1211
1212         /* Load lvs again with 3 blobs, with success */
1213         g_lvol_store = NULL;
1214         g_lvserrno = 0;
1215         blob1->load_status = 0;
1216         blob2->load_status = 0;
1217         blob3->load_status = 0;
1218         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1219         CU_ASSERT(g_lvserrno == 0);
1220         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1221         CU_ASSERT(!TAILQ_EMPTY(&g_lvol_store->lvols));
1222
1223         g_lvserrno = -1;
1224         /* rc = */ spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1225         /*
1226          * Disable these two asserts for now.  lvolstore should allow unload as long
1227          *  as the lvols were not opened - but this is coming a future patch.
1228          */
1229         /* CU_ASSERT(rc == 0); */
1230         /* CU_ASSERT(g_lvserrno == 0); */
1231
1232         free(req);
1233         free_dev(&dev);
1234
1235         spdk_free_thread();
1236 }
1237
1238 static void
1239 lvol_open(void)
1240 {
1241         struct lvol_ut_bs_dev dev;
1242         struct spdk_lvs_with_handle_req *req;
1243         struct spdk_bs_opts bs_opts;
1244         struct spdk_blob *super_blob, *blob1, *blob2, *blob3;
1245         struct spdk_lvol *lvol, *tmp;
1246
1247         req = calloc(1, sizeof(*req));
1248         SPDK_CU_ASSERT_FATAL(req != NULL);
1249
1250         init_dev(&dev);
1251         spdk_bs_opts_init(&bs_opts);
1252         snprintf(bs_opts.bstype.bstype, sizeof(bs_opts.bstype.bstype), "LVOLSTORE");
1253         spdk_bs_init(&dev.bs_dev, &bs_opts, null_cb, NULL);
1254         super_blob = calloc(1, sizeof(*super_blob));
1255         SPDK_CU_ASSERT_FATAL(super_blob != NULL);
1256         super_blob->id = 0x100;
1257         spdk_blob_set_xattr(super_blob, "uuid", uuid, SPDK_UUID_STRING_LEN);
1258         spdk_blob_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1);
1259         TAILQ_INSERT_TAIL(&dev.bs->blobs, super_blob, link);
1260         dev.bs->super_blobid = 0x100;
1261
1262         /*
1263          * Create 3 blobs, write different char values to the last char in the UUID
1264          *  to make sure they are unique.
1265          */
1266         blob1 = calloc(1, sizeof(*blob1));
1267         SPDK_CU_ASSERT_FATAL(blob1 != NULL);
1268         blob1->id = 0x1;
1269         spdk_blob_set_xattr(blob1, "uuid", uuid, SPDK_UUID_STRING_LEN);
1270         spdk_blob_set_xattr(blob1, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX) + 1);
1271         blob1->uuid[SPDK_UUID_STRING_LEN - 2] = '1';
1272
1273         blob2 = calloc(1, sizeof(*blob2));
1274         SPDK_CU_ASSERT_FATAL(blob2 != NULL);
1275         blob2->id = 0x2;
1276         spdk_blob_set_xattr(blob2, "uuid", uuid, SPDK_UUID_STRING_LEN);
1277         spdk_blob_set_xattr(blob2, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX) + 1);
1278         blob2->uuid[SPDK_UUID_STRING_LEN - 2] = '2';
1279
1280         blob3 = calloc(1, sizeof(*blob3));
1281         SPDK_CU_ASSERT_FATAL(blob3 != NULL);
1282         blob3->id = 0x2;
1283         spdk_blob_set_xattr(blob3, "uuid", uuid, SPDK_UUID_STRING_LEN);
1284         spdk_blob_set_xattr(blob3, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX) + 1);
1285         blob3->uuid[SPDK_UUID_STRING_LEN - 2] = '3';
1286
1287         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1288
1289         TAILQ_INSERT_TAIL(&dev.bs->blobs, blob1, link);
1290         TAILQ_INSERT_TAIL(&dev.bs->blobs, blob2, link);
1291         TAILQ_INSERT_TAIL(&dev.bs->blobs, blob3, link);
1292
1293         /* Load lvs with 3 blobs */
1294         g_lvol_store = NULL;
1295         g_lvserrno = 0;
1296         spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req);
1297         CU_ASSERT(g_lvserrno == 0);
1298         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1299         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_stores));
1300
1301         blob1->open_status = -1;
1302         blob2->open_status = -1;
1303         blob3->open_status = -1;
1304
1305         /* Fail opening all lvols */
1306         TAILQ_FOREACH_SAFE(lvol, &g_lvol_store->lvols, link, tmp) {
1307                 spdk_lvol_open(lvol, lvol_op_with_handle_complete, NULL);
1308                 CU_ASSERT(g_lvserrno != 0);
1309         }
1310
1311         blob1->open_status = 0;
1312         blob2->open_status = 0;
1313         blob3->open_status = 0;
1314
1315         /* Open all lvols */
1316         TAILQ_FOREACH_SAFE(lvol, &g_lvol_store->lvols, link, tmp) {
1317                 spdk_lvol_open(lvol, lvol_op_with_handle_complete, NULL);
1318                 CU_ASSERT(g_lvserrno == 0);
1319         }
1320
1321         /* Close all lvols */
1322         TAILQ_FOREACH_SAFE(lvol, &g_lvol_store->lvols, link, tmp) {
1323                 spdk_lvol_close(lvol, lvol_op_complete, NULL);
1324                 CU_ASSERT(g_lvserrno == 0);
1325         }
1326
1327         g_lvserrno = -1;
1328         spdk_lvs_destroy(g_lvol_store, lvol_store_op_complete, NULL);
1329
1330         free(req);
1331         free(blob1);
1332         free(blob2);
1333         free(blob3);
1334
1335         spdk_free_thread();
1336 }
1337
1338 static void
1339 lvol_snapshot(void)
1340 {
1341         struct lvol_ut_bs_dev dev;
1342         struct spdk_lvol *lvol;
1343         struct spdk_lvs_opts opts;
1344         int rc = 0;
1345
1346         init_dev(&dev);
1347
1348         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1349
1350         spdk_lvs_opts_init(&opts);
1351         snprintf(opts.name, sizeof(opts.name), "lvs");
1352
1353         g_lvserrno = -1;
1354         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1355         CU_ASSERT(rc == 0);
1356         CU_ASSERT(g_lvserrno == 0);
1357         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1358
1359         spdk_lvol_create(g_lvol_store, "lvol", 10, true, lvol_op_with_handle_complete, NULL);
1360         CU_ASSERT(g_lvserrno == 0);
1361         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1362
1363         lvol = g_lvol;
1364
1365         spdk_lvol_create_snapshot(lvol, "snap", lvol_op_with_handle_complete, NULL);
1366         CU_ASSERT(g_lvserrno == 0);
1367         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1368         CU_ASSERT_STRING_EQUAL(g_lvol->name, "snap");
1369
1370         /* Lvol has to be closed (or destroyed) before unloading lvol store. */
1371         spdk_lvol_close(g_lvol, close_cb, NULL);
1372         CU_ASSERT(g_lvserrno == 0);
1373         g_lvserrno = -1;
1374
1375         spdk_lvol_close(lvol, close_cb, NULL);
1376         CU_ASSERT(g_lvserrno == 0);
1377         g_lvserrno = -1;
1378
1379         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1380         CU_ASSERT(rc == 0);
1381         CU_ASSERT(g_lvserrno == 0);
1382         g_lvol_store = NULL;
1383
1384         free_dev(&dev);
1385
1386         spdk_free_thread();
1387 }
1388
1389 static void
1390 lvol_snapshot_fail(void)
1391 {
1392         struct lvol_ut_bs_dev dev;
1393         struct spdk_lvol *lvol, *snap;
1394         struct spdk_lvs_opts opts;
1395         int rc = 0;
1396
1397         init_dev(&dev);
1398
1399         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1400
1401         spdk_lvs_opts_init(&opts);
1402         snprintf(opts.name, sizeof(opts.name), "lvs");
1403
1404         g_lvserrno = -1;
1405         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1406         CU_ASSERT(rc == 0);
1407         CU_ASSERT(g_lvserrno == 0);
1408         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1409
1410         spdk_lvol_create(g_lvol_store, "lvol", 10, true, lvol_op_with_handle_complete, NULL);
1411         CU_ASSERT(g_lvserrno == 0);
1412         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1413
1414         lvol = g_lvol;
1415
1416         spdk_lvol_create_snapshot(NULL, "snap", lvol_op_with_handle_complete, NULL);
1417         CU_ASSERT(g_lvserrno < 0);
1418         SPDK_CU_ASSERT_FATAL(g_lvol == NULL);
1419
1420         spdk_lvol_create_snapshot(lvol, "", lvol_op_with_handle_complete, NULL);
1421         CU_ASSERT(g_lvserrno < 0);
1422         SPDK_CU_ASSERT_FATAL(g_lvol == NULL);
1423
1424         spdk_lvol_create_snapshot(lvol, NULL, lvol_op_with_handle_complete, NULL);
1425         CU_ASSERT(g_lvserrno < 0);
1426         SPDK_CU_ASSERT_FATAL(g_lvol == NULL);
1427
1428         spdk_lvol_create_snapshot(lvol, "snap", lvol_op_with_handle_complete, NULL);
1429         CU_ASSERT(g_lvserrno == 0);
1430         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1431         CU_ASSERT_STRING_EQUAL(g_lvol->name, "snap");
1432
1433         snap = g_lvol;
1434
1435         spdk_lvol_create_snapshot(lvol, "snap", lvol_op_with_handle_complete, NULL);
1436         CU_ASSERT(g_lvserrno < 0);
1437
1438         spdk_lvol_close(lvol, close_cb, NULL);
1439         CU_ASSERT(g_lvserrno == 0);
1440         g_lvserrno = -1;
1441
1442         spdk_lvol_close(snap, close_cb, NULL);
1443         CU_ASSERT(g_lvserrno == 0);
1444         g_lvserrno = -1;
1445
1446         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1447         CU_ASSERT(rc == 0);
1448         CU_ASSERT(g_lvserrno == 0);
1449         g_lvol_store = NULL;
1450
1451         free_dev(&dev);
1452
1453         spdk_free_thread();
1454 }
1455
1456 static void
1457 lvol_clone(void)
1458 {
1459         struct lvol_ut_bs_dev dev;
1460         struct spdk_lvol *lvol;
1461         struct spdk_lvol *snap;
1462         struct spdk_lvs_opts opts;
1463         int rc = 0;
1464
1465         init_dev(&dev);
1466
1467         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1468
1469         spdk_lvs_opts_init(&opts);
1470         snprintf(opts.name, sizeof(opts.name), "lvs");
1471
1472         g_lvserrno = -1;
1473         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1474         CU_ASSERT(rc == 0);
1475         CU_ASSERT(g_lvserrno == 0);
1476         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1477
1478         spdk_lvol_create(g_lvol_store, "lvol", 10, true, lvol_op_with_handle_complete, NULL);
1479         CU_ASSERT(g_lvserrno == 0);
1480         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1481
1482         lvol = g_lvol;
1483
1484         spdk_lvol_create_snapshot(lvol, "snap", lvol_op_with_handle_complete, NULL);
1485         CU_ASSERT(g_lvserrno == 0);
1486         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1487         CU_ASSERT_STRING_EQUAL(g_lvol->name, "snap");
1488
1489         snap = g_lvol;
1490
1491         spdk_lvol_create_clone(snap, "clone", lvol_op_with_handle_complete, NULL);
1492         CU_ASSERT(g_lvserrno == 0);
1493         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1494         CU_ASSERT_STRING_EQUAL(g_lvol->name, "clone");
1495
1496         /* Lvol has to be closed (or destroyed) before unloading lvol store. */
1497         spdk_lvol_close(g_lvol, close_cb, NULL);
1498         CU_ASSERT(g_lvserrno == 0);
1499         g_lvserrno = -1;
1500
1501         spdk_lvol_close(snap, close_cb, NULL);
1502         CU_ASSERT(g_lvserrno == 0);
1503         g_lvserrno = -1;
1504
1505         spdk_lvol_close(lvol, close_cb, NULL);
1506         CU_ASSERT(g_lvserrno == 0);
1507         g_lvserrno = -1;
1508
1509         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1510         CU_ASSERT(rc == 0);
1511         CU_ASSERT(g_lvserrno == 0);
1512         g_lvol_store = NULL;
1513
1514         free_dev(&dev);
1515
1516         spdk_free_thread();
1517 }
1518
1519 static void
1520 lvol_clone_fail(void)
1521 {
1522         struct lvol_ut_bs_dev dev;
1523         struct spdk_lvol *lvol;
1524         struct spdk_lvol *snap;
1525         struct spdk_lvol *clone;
1526         struct spdk_lvs_opts opts;
1527         int rc = 0;
1528
1529         init_dev(&dev);
1530
1531         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1532
1533         spdk_lvs_opts_init(&opts);
1534         snprintf(opts.name, sizeof(opts.name), "lvs");
1535
1536         g_lvserrno = -1;
1537         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1538         CU_ASSERT(rc == 0);
1539         CU_ASSERT(g_lvserrno == 0);
1540         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1541
1542         spdk_lvol_create(g_lvol_store, "lvol", 10, true, lvol_op_with_handle_complete, NULL);
1543         CU_ASSERT(g_lvserrno == 0);
1544         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1545
1546         lvol = g_lvol;
1547
1548         spdk_lvol_create_snapshot(lvol, "snap", lvol_op_with_handle_complete, NULL);
1549         CU_ASSERT(g_lvserrno == 0);
1550         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1551         CU_ASSERT_STRING_EQUAL(g_lvol->name, "snap");
1552
1553         snap = g_lvol;
1554
1555         spdk_lvol_create_clone(NULL, "clone", lvol_op_with_handle_complete, NULL);
1556         CU_ASSERT(g_lvserrno < 0);
1557
1558         spdk_lvol_create_clone(snap, "", lvol_op_with_handle_complete, NULL);
1559         CU_ASSERT(g_lvserrno < 0);
1560
1561         spdk_lvol_create_clone(snap, NULL, lvol_op_with_handle_complete, NULL);
1562         CU_ASSERT(g_lvserrno < 0);
1563
1564         spdk_lvol_create_clone(snap, "clone", lvol_op_with_handle_complete, NULL);
1565         CU_ASSERT(g_lvserrno == 0);
1566         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1567         CU_ASSERT_STRING_EQUAL(g_lvol->name, "clone");
1568
1569         clone = g_lvol;
1570
1571         spdk_lvol_create_clone(snap, "clone", lvol_op_with_handle_complete, NULL);
1572         CU_ASSERT(g_lvserrno < 0);
1573
1574         /* Lvol has to be closed (or destroyed) before unloading lvol store. */
1575         spdk_lvol_close(clone, close_cb, NULL);
1576         CU_ASSERT(g_lvserrno == 0);
1577         g_lvserrno = -1;
1578
1579         spdk_lvol_close(snap, close_cb, NULL);
1580         CU_ASSERT(g_lvserrno == 0);
1581         g_lvserrno = -1;
1582
1583         spdk_lvol_close(lvol, close_cb, NULL);
1584         CU_ASSERT(g_lvserrno == 0);
1585         g_lvserrno = -1;
1586
1587         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1588         CU_ASSERT(rc == 0);
1589         CU_ASSERT(g_lvserrno == 0);
1590         g_lvol_store = NULL;
1591
1592         free_dev(&dev);
1593
1594         spdk_free_thread();
1595 }
1596
1597 static void
1598 lvol_names(void)
1599 {
1600         struct lvol_ut_bs_dev dev;
1601         struct spdk_lvs_opts opts;
1602         struct spdk_lvol_store *lvs;
1603         struct spdk_lvol *lvol, *lvol2;
1604         char fullname[SPDK_LVOL_NAME_MAX];
1605         int rc = 0;
1606
1607         init_dev(&dev);
1608
1609         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1610
1611         spdk_lvs_opts_init(&opts);
1612         snprintf(opts.name, sizeof(opts.name), "lvs");
1613
1614         g_lvserrno = -1;
1615         g_lvol_store = NULL;
1616         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1617         CU_ASSERT(rc == 0);
1618         CU_ASSERT(g_lvserrno == 0);
1619         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1620         lvs = g_lvol_store;
1621
1622         rc = spdk_lvol_create(lvs, NULL, 1, false, lvol_op_with_handle_complete, NULL);
1623         CU_ASSERT(rc == -EINVAL);
1624
1625         rc = spdk_lvol_create(lvs, "", 1, false, lvol_op_with_handle_complete, NULL);
1626         CU_ASSERT(rc == -EINVAL);
1627
1628         memset(fullname, 'x', sizeof(fullname));
1629         rc = spdk_lvol_create(lvs, fullname, 1, false, lvol_op_with_handle_complete, NULL);
1630         CU_ASSERT(rc == -EINVAL);
1631
1632         g_lvserrno = -1;
1633         rc = spdk_lvol_create(lvs, "lvol", 1, false, lvol_op_with_handle_complete, NULL);
1634         CU_ASSERT(rc == 0);
1635         CU_ASSERT(g_lvserrno == 0);
1636         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1637         lvol = g_lvol;
1638
1639         rc = spdk_lvol_create(lvs, "lvol", 1, false, lvol_op_with_handle_complete, NULL);
1640         CU_ASSERT(rc == -EEXIST);
1641
1642         g_lvserrno = -1;
1643         rc = spdk_lvol_create(lvs, "lvol2", 1, false, lvol_op_with_handle_complete, NULL);
1644         CU_ASSERT(rc == 0);
1645         CU_ASSERT(g_lvserrno == 0);
1646         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1647         lvol2 = g_lvol;
1648
1649         spdk_lvol_close(lvol, close_cb, NULL);
1650         spdk_lvol_destroy(lvol, lvol_op_complete, NULL);
1651
1652         g_lvserrno = -1;
1653         g_lvol = NULL;
1654         rc = spdk_lvol_create(lvs, "lvol", 1, false, lvol_op_with_handle_complete, NULL);
1655         CU_ASSERT(rc == 0);
1656         CU_ASSERT(g_lvserrno == 0);
1657         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1658         lvol = g_lvol;
1659
1660         spdk_lvol_close(lvol, close_cb, NULL);
1661         spdk_lvol_destroy(lvol, destroy_cb, NULL);
1662
1663         spdk_lvol_close(lvol2, close_cb, NULL);
1664         spdk_lvol_destroy(lvol2, destroy_cb, NULL);
1665
1666         /* Simulate creating two lvols with same name simultaneously. */
1667         lvol = calloc(1, sizeof(*lvol));
1668         SPDK_CU_ASSERT_FATAL(lvol != NULL);
1669         snprintf(lvol->name, sizeof(lvol->name), "tmp_name");
1670         TAILQ_INSERT_TAIL(&lvs->pending_lvols, lvol, link);
1671         rc = spdk_lvol_create(lvs, "tmp_name", 1, false, lvol_op_with_handle_complete, NULL);
1672         CU_ASSERT(rc == -EEXIST);
1673
1674         /* Remove name from temporary list and try again. */
1675         TAILQ_REMOVE(&lvs->pending_lvols, lvol, link);
1676         free(lvol);
1677
1678         rc = spdk_lvol_create(lvs, "tmp_name", 1, false, lvol_op_with_handle_complete, NULL);
1679         CU_ASSERT(rc == 0);
1680         CU_ASSERT(g_lvserrno == 0);
1681         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1682         lvol = g_lvol;
1683
1684         spdk_lvol_close(lvol, close_cb, NULL);
1685         spdk_lvol_destroy(lvol, destroy_cb, NULL);
1686
1687         g_lvserrno = -1;
1688         rc = spdk_lvs_destroy(lvs, lvol_store_op_complete, NULL);
1689         CU_ASSERT(rc == 0);
1690         CU_ASSERT(g_lvserrno == 0);
1691         g_lvol_store = NULL;
1692
1693         spdk_free_thread();
1694 }
1695
1696 static void
1697 lvol_rename(void)
1698 {
1699         struct lvol_ut_bs_dev dev;
1700         struct spdk_lvs_opts opts;
1701         struct spdk_lvol_store *lvs;
1702         struct spdk_lvol *lvol, *lvol2;
1703         int rc = 0;
1704
1705         init_dev(&dev);
1706
1707         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1708
1709         spdk_lvs_opts_init(&opts);
1710         snprintf(opts.name, sizeof(opts.name), "lvs");
1711
1712         g_lvserrno = -1;
1713         g_lvol_store = NULL;
1714         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1715         CU_ASSERT(rc == 0);
1716         CU_ASSERT(g_lvserrno == 0);
1717         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1718         lvs = g_lvol_store;
1719
1720         /* Trying to create new lvol */
1721         g_lvserrno = -1;
1722         rc = spdk_lvol_create(lvs, "lvol", 1, false, lvol_op_with_handle_complete, NULL);
1723         CU_ASSERT(rc == 0);
1724         CU_ASSERT(g_lvserrno == 0);
1725         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1726         lvol = g_lvol;
1727
1728         /* Trying to create second lvol with existing lvol name */
1729         g_lvserrno = -1;
1730         g_lvol = NULL;
1731         rc = spdk_lvol_create(lvs, "lvol", 1, false, lvol_op_with_handle_complete, NULL);
1732         CU_ASSERT(rc == -EEXIST);
1733         CU_ASSERT(g_lvserrno == -1);
1734         SPDK_CU_ASSERT_FATAL(g_lvol == NULL);
1735
1736         /* Trying to create second lvol with non existing name */
1737         g_lvserrno = -1;
1738         rc = spdk_lvol_create(lvs, "lvol2", 1, false, lvol_op_with_handle_complete, NULL);
1739         CU_ASSERT(rc == 0);
1740         CU_ASSERT(g_lvserrno == 0);
1741         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1742         lvol2 = g_lvol;
1743
1744         /* Trying to rename lvol with not existing name */
1745         spdk_lvol_rename(lvol, "lvol_new", lvol_op_complete, NULL);
1746         CU_ASSERT(g_lvolerrno == 0);
1747         CU_ASSERT_STRING_EQUAL(lvol->name, "lvol_new");
1748
1749         /* Trying to rename lvol with other lvol name */
1750         spdk_lvol_rename(lvol2, "lvol_new", lvol_op_complete, NULL);
1751         CU_ASSERT(g_lvolerrno == -EEXIST);
1752         CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "lvol_new");
1753
1754         spdk_lvol_close(lvol, close_cb, NULL);
1755         spdk_lvol_destroy(lvol, lvol_op_complete, NULL);
1756
1757         spdk_lvol_close(lvol2, close_cb, NULL);
1758         spdk_lvol_destroy(lvol2, lvol_op_complete, NULL);
1759
1760         g_lvserrno = -1;
1761         rc = spdk_lvs_destroy(lvs, lvol_store_op_complete, NULL);
1762         CU_ASSERT(rc == 0);
1763         CU_ASSERT(g_lvserrno == 0);
1764         g_lvol_store = NULL;
1765
1766         spdk_free_thread();
1767 }
1768
1769 static void
1770 lvs_rename(void)
1771 {
1772         struct lvol_ut_bs_dev dev;
1773         struct spdk_lvs_opts opts;
1774         struct spdk_lvol_store *lvs, *lvs2;
1775         int rc = 0;
1776
1777         init_dev(&dev);
1778
1779         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1780
1781         spdk_lvs_opts_init(&opts);
1782         snprintf(opts.name, sizeof(opts.name), "lvs");
1783         g_lvserrno = -1;
1784         g_lvol_store = NULL;
1785         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1786         CU_ASSERT(rc == 0);
1787         CU_ASSERT(g_lvserrno == 0);
1788         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1789         lvs = g_lvol_store;
1790
1791         spdk_lvs_opts_init(&opts);
1792         snprintf(opts.name, sizeof(opts.name), "unimportant_lvs_name");
1793         g_lvserrno = -1;
1794         g_lvol_store = NULL;
1795         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1796         CU_ASSERT(rc == 0);
1797         CU_ASSERT(g_lvserrno == 0);
1798         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1799         lvs2 = g_lvol_store;
1800
1801         /* Trying to rename lvs with new name */
1802         spdk_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL);
1803         CU_ASSERT(g_lvserrno == 0);
1804         CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name");
1805
1806         /* Trying to rename lvs with name lvs already has */
1807         spdk_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL);
1808         CU_ASSERT(g_lvserrno == 0);
1809         CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name");
1810
1811         /* Trying to rename lvs with name already existing */
1812         spdk_lvs_rename(lvs2, "new_lvs_name", lvol_store_op_complete, NULL);
1813         CU_ASSERT(g_lvserrno == -EEXIST);
1814         CU_ASSERT_STRING_EQUAL(lvs2->name, "unimportant_lvs_name");
1815
1816         /* Trying to rename lvs with another rename process started with the same name */
1817         /* Simulate renaming process in progress */
1818         snprintf(lvs2->new_name, sizeof(lvs2->new_name), "another_new_lvs_name");
1819         CU_ASSERT_STRING_EQUAL(lvs2->new_name, "another_new_lvs_name");
1820         /* Start second process */
1821         spdk_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL);
1822         CU_ASSERT(g_lvserrno == -EEXIST);
1823         CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name");
1824         /* reverting lvs2 new name to proper value */
1825         snprintf(lvs2->new_name, sizeof(lvs2->new_name), "unimportant_lvs_name");
1826         CU_ASSERT_STRING_EQUAL(lvs2->new_name, "unimportant_lvs_name");
1827
1828         /* Simulate error while lvs rename */
1829         g_lvs_rename_blob_open_error = true;
1830         spdk_lvs_rename(lvs, "complete_new_lvs_name", lvol_store_op_complete, NULL);
1831         CU_ASSERT(g_lvserrno != 0);
1832         CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name");
1833         CU_ASSERT_STRING_EQUAL(lvs->new_name, "new_lvs_name");
1834         g_lvs_rename_blob_open_error = false;
1835
1836         g_lvserrno = -1;
1837         rc = spdk_lvs_destroy(lvs, lvol_store_op_complete, NULL);
1838         CU_ASSERT(rc == 0);
1839         CU_ASSERT(g_lvserrno == 0);
1840         g_lvol_store = NULL;
1841
1842         g_lvserrno = -1;
1843         rc = spdk_lvs_destroy(lvs2, lvol_store_op_complete, NULL);
1844         CU_ASSERT(rc == 0);
1845         CU_ASSERT(g_lvserrno == 0);
1846         g_lvol_store = NULL;
1847
1848         spdk_free_thread();
1849 }
1850 static void lvol_refcnt(void)
1851 {
1852         struct lvol_ut_bs_dev dev;
1853         struct spdk_lvs_opts opts;
1854         struct spdk_lvol *lvol;
1855         int rc = 0;
1856
1857         init_dev(&dev);
1858
1859         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1860         spdk_lvs_opts_init(&opts);
1861         snprintf(opts.name, sizeof(opts.name), "lvs");
1862
1863         g_lvserrno = -1;
1864         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1865         CU_ASSERT(rc == 0);
1866         CU_ASSERT(g_lvserrno == 0);
1867         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1868
1869
1870         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
1871
1872         CU_ASSERT(g_lvserrno == 0);
1873         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1874         CU_ASSERT(g_lvol->ref_count == 1);
1875
1876         lvol = g_lvol;
1877         spdk_lvol_open(g_lvol, lvol_op_with_handle_complete, NULL);
1878         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1879         CU_ASSERT(lvol->ref_count == 2);
1880
1881         /* Trying to destroy lvol while its open should fail */
1882         spdk_lvol_destroy(lvol, lvol_op_complete, NULL);
1883         CU_ASSERT(g_lvolerrno != 0);
1884
1885         spdk_lvol_close(lvol, lvol_op_complete, NULL);
1886         CU_ASSERT(lvol->ref_count == 1);
1887         CU_ASSERT(g_lvolerrno == 0);
1888
1889         spdk_lvol_close(lvol, lvol_op_complete, NULL);
1890         CU_ASSERT(lvol->ref_count == 0);
1891         CU_ASSERT(g_lvolerrno == 0);
1892
1893         /* Try to close already closed lvol */
1894         spdk_lvol_close(lvol, lvol_op_complete, NULL);
1895         CU_ASSERT(lvol->ref_count == 0);
1896         CU_ASSERT(g_lvolerrno != 0);
1897
1898         g_lvserrno = -1;
1899         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1900         CU_ASSERT(rc == 0);
1901         CU_ASSERT(g_lvserrno == 0);
1902         g_lvol_store = NULL;
1903
1904         CU_ASSERT(rc == 0);
1905         CU_ASSERT(g_lvserrno == 0);
1906         g_lvol_store = NULL;
1907
1908         free_dev(&dev);
1909
1910         spdk_free_thread();
1911 }
1912
1913 static void
1914 lvol_create_thin_provisioned(void)
1915 {
1916         struct lvol_ut_bs_dev dev;
1917         struct spdk_lvs_opts opts;
1918         int rc = 0;
1919
1920         init_dev(&dev);
1921
1922         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1923
1924         spdk_lvs_opts_init(&opts);
1925         snprintf(opts.name, sizeof(opts.name), "lvs");
1926
1927         g_lvserrno = -1;
1928         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1929         CU_ASSERT(rc == 0);
1930         CU_ASSERT(g_lvserrno == 0);
1931         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1932
1933         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
1934         CU_ASSERT(g_lvserrno == 0);
1935         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1936
1937         CU_ASSERT(g_lvol->blob->thin_provisioned == false);
1938
1939         spdk_lvol_close(g_lvol, close_cb, NULL);
1940         CU_ASSERT(g_lvserrno == 0);
1941         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
1942         CU_ASSERT(g_lvserrno == 0);
1943
1944         spdk_lvol_create(g_lvol_store, "lvol", 10, true, lvol_op_with_handle_complete, NULL);
1945         CU_ASSERT(g_lvserrno == 0);
1946         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1947
1948         CU_ASSERT(g_lvol->blob->thin_provisioned == true);
1949
1950         spdk_lvol_close(g_lvol, close_cb, NULL);
1951         CU_ASSERT(g_lvserrno == 0);
1952         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
1953         CU_ASSERT(g_lvserrno == 0);
1954
1955         g_lvserrno = -1;
1956         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1957         CU_ASSERT(rc == 0);
1958         CU_ASSERT(g_lvserrno == 0);
1959         g_lvol_store = NULL;
1960
1961         free_dev(&dev);
1962
1963         spdk_free_thread();
1964 }
1965
1966 static void
1967 lvol_inflate(void)
1968 {
1969         struct lvol_ut_bs_dev dev;
1970         struct spdk_lvs_opts opts;
1971         int rc = 0;
1972
1973         init_dev(&dev);
1974
1975         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
1976
1977         spdk_lvs_opts_init(&opts);
1978         snprintf(opts.name, sizeof(opts.name), "lvs");
1979
1980         g_lvserrno = -1;
1981         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1982         CU_ASSERT(rc == 0);
1983         CU_ASSERT(g_lvserrno == 0);
1984         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1985
1986         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
1987         CU_ASSERT(g_lvserrno == 0);
1988         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1989
1990         g_inflate_rc = -1;
1991         spdk_lvol_inflate(g_lvol, lvol_op_complete, NULL);
1992         CU_ASSERT(g_lvolerrno != 0);
1993
1994         g_inflate_rc = 0;
1995         spdk_lvol_inflate(g_lvol, lvol_op_complete, NULL);
1996         CU_ASSERT(g_lvolerrno == 0);
1997
1998         spdk_lvol_close(g_lvol, close_cb, NULL);
1999         CU_ASSERT(g_lvserrno == 0);
2000         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
2001         CU_ASSERT(g_lvserrno == 0);
2002
2003         g_lvserrno = -1;
2004         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
2005         CU_ASSERT(rc == 0);
2006         CU_ASSERT(g_lvserrno == 0);
2007         g_lvol_store = NULL;
2008
2009         free_dev(&dev);
2010
2011         /* Make sure that all references to the io_channel was closed after
2012          * inflate call
2013          */
2014         CU_ASSERT(g_io_channel == NULL);
2015
2016         spdk_free_thread();
2017 }
2018
2019 static void
2020 lvol_decouple_parent(void)
2021 {
2022         struct lvol_ut_bs_dev dev;
2023         struct spdk_lvs_opts opts;
2024         int rc = 0;
2025
2026         init_dev(&dev);
2027
2028         spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);
2029
2030         spdk_lvs_opts_init(&opts);
2031         snprintf(opts.name, sizeof(opts.name), "lvs");
2032
2033         g_lvserrno = -1;
2034         rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
2035         CU_ASSERT(rc == 0);
2036         CU_ASSERT(g_lvserrno == 0);
2037         SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
2038
2039         spdk_lvol_create(g_lvol_store, "lvol", 10, false, lvol_op_with_handle_complete, NULL);
2040         CU_ASSERT(g_lvserrno == 0);
2041         SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
2042
2043         g_inflate_rc = -1;
2044         spdk_lvol_decouple_parent(g_lvol, lvol_op_complete, NULL);
2045         CU_ASSERT(g_lvolerrno != 0);
2046
2047         g_inflate_rc = 0;
2048         spdk_lvol_decouple_parent(g_lvol, lvol_op_complete, NULL);
2049         CU_ASSERT(g_lvolerrno == 0);
2050
2051         spdk_lvol_close(g_lvol, close_cb, NULL);
2052         CU_ASSERT(g_lvserrno == 0);
2053         spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
2054         CU_ASSERT(g_lvserrno == 0);
2055
2056         g_lvserrno = -1;
2057         rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
2058         CU_ASSERT(rc == 0);
2059         CU_ASSERT(g_lvserrno == 0);
2060         g_lvol_store = NULL;
2061
2062         free_dev(&dev);
2063
2064         /* Make sure that all references to the io_channel was closed after
2065          * inflate call
2066          */
2067         CU_ASSERT(g_io_channel == NULL);
2068
2069         spdk_free_thread();
2070 }
2071
2072 int main(int argc, char **argv)
2073 {
2074         CU_pSuite       suite = NULL;
2075         unsigned int    num_failures;
2076
2077         if (CU_initialize_registry() != CUE_SUCCESS) {
2078                 return CU_get_error();
2079         }
2080
2081         suite = CU_add_suite("lvol", NULL, NULL);
2082         if (suite == NULL) {
2083                 CU_cleanup_registry();
2084                 return CU_get_error();
2085         }
2086
2087         if (
2088                 CU_add_test(suite, "lvs_init_unload_success", lvs_init_unload_success) == NULL ||
2089                 CU_add_test(suite, "lvs_init_destroy_success", lvs_init_destroy_success) == NULL ||
2090                 CU_add_test(suite, "lvs_init_opts_success", lvs_init_opts_success) == NULL ||
2091                 CU_add_test(suite, "lvs_unload_lvs_is_null_fail", lvs_unload_lvs_is_null_fail) == NULL ||
2092                 CU_add_test(suite, "lvs_names", lvs_names) == NULL ||
2093                 CU_add_test(suite, "lvol_create_destroy_success", lvol_create_destroy_success) == NULL ||
2094                 CU_add_test(suite, "lvol_create_fail", lvol_create_fail) == NULL ||
2095                 CU_add_test(suite, "lvol_destroy_fail", lvol_destroy_fail) == NULL ||
2096                 CU_add_test(suite, "lvol_close_fail", lvol_close_fail) == NULL ||
2097                 CU_add_test(suite, "lvol_close_success", lvol_close_success) == NULL ||
2098                 CU_add_test(suite, "lvol_resize", lvol_resize) == NULL ||
2099                 CU_add_test(suite, "lvs_load", lvs_load) == NULL ||
2100                 CU_add_test(suite, "lvols_load", lvols_load) == NULL ||
2101                 CU_add_test(suite, "lvol_open", lvol_open) == NULL ||
2102                 CU_add_test(suite, "lvol_load", lvs_load) == NULL ||
2103                 CU_add_test(suite, "lvs_load", lvols_load) == NULL ||
2104                 CU_add_test(suite, "lvol_open", lvol_open) == NULL ||
2105                 CU_add_test(suite, "lvol_snapshot", lvol_snapshot) == NULL ||
2106                 CU_add_test(suite, "lvol_snapshot_fail", lvol_snapshot_fail) == NULL ||
2107                 CU_add_test(suite, "lvol_clone", lvol_clone) == NULL ||
2108                 CU_add_test(suite, "lvol_clone_fail", lvol_clone_fail) == NULL ||
2109                 CU_add_test(suite, "lvol_refcnt", lvol_refcnt) == NULL ||
2110                 CU_add_test(suite, "lvol_names", lvol_names) == NULL ||
2111                 CU_add_test(suite, "lvol_create_thin_provisioned", lvol_create_thin_provisioned) == NULL ||
2112                 CU_add_test(suite, "lvol_rename", lvol_rename) == NULL ||
2113                 CU_add_test(suite, "lvs_rename", lvs_rename) == NULL ||
2114                 CU_add_test(suite, "lvol_inflate", lvol_inflate) == NULL ||
2115                 CU_add_test(suite, "lvol_decouple_parent", lvol_decouple_parent) == NULL
2116         ) {
2117                 CU_cleanup_registry();
2118                 return CU_get_error();
2119         }
2120
2121         CU_basic_set_mode(CU_BRM_VERBOSE);
2122         CU_basic_run_tests();
2123         num_failures = CU_get_number_of_failures();
2124         CU_cleanup_registry();
2125
2126         return num_failures;
2127 }