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