4 * Copyright (c) Intel Corporation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
34 #include "spdk_cunit.h"
35 #include "spdk/blob.h"
36 #include "spdk/thread.h"
37 #include "spdk/util.h"
39 #include "common/lib/ut_multithread.c"
41 #include "lvol/lvol.c"
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)
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
55 #define SPDK_BLOB_THIN_PROV (1ULL << 0)
57 const char *uuid
= "828d9766-ae50-11e7-bd8d-001e67edf350";
62 struct spdk_blob_store
*bs
;
66 TAILQ_ENTRY(spdk_blob
) link
;
67 char uuid
[SPDK_UUID_STRING_LEN
];
68 char name
[SPDK_LVS_NAME_MAX
];
69 bool thin_provisioned
;
74 int g_close_super_status
;
78 bool g_lvs_rename_blob_open_error
= false;
79 struct spdk_lvol_store
*g_lvol_store
;
80 struct spdk_lvol
*g_lvol
;
81 spdk_blob_id g_blobid
= 1;
82 struct spdk_io_channel
*g_io_channel
;
84 struct spdk_blob_store
{
85 struct spdk_bs_opts bs_opts
;
86 spdk_blob_id super_blobid
;
87 TAILQ_HEAD(, spdk_blob
) blobs
;
91 struct lvol_ut_bs_dev
{
92 struct spdk_bs_dev bs_dev
;
95 struct spdk_blob_store
*bs
;
98 void spdk_bs_inflate_blob(struct spdk_blob_store
*bs
, struct spdk_io_channel
*channel
,
99 spdk_blob_id blobid
, spdk_blob_op_complete cb_fn
, void *cb_arg
)
101 cb_fn(cb_arg
, g_inflate_rc
);
104 void spdk_bs_blob_decouple_parent(struct spdk_blob_store
*bs
, struct spdk_io_channel
*channel
,
105 spdk_blob_id blobid
, spdk_blob_op_complete cb_fn
, void *cb_arg
)
107 cb_fn(cb_arg
, g_inflate_rc
);
111 spdk_bs_iter_next(struct spdk_blob_store
*bs
, struct spdk_blob
*b
,
112 spdk_blob_op_with_handle_complete cb_fn
, void *cb_arg
)
114 struct spdk_blob
*next
;
117 next
= TAILQ_NEXT(b
, link
);
120 } else if (next
->load_status
!= 0) {
121 _errno
= next
->load_status
;
124 cb_fn(cb_arg
, next
, _errno
);
128 spdk_bs_iter_first(struct spdk_blob_store
*bs
,
129 spdk_blob_op_with_handle_complete cb_fn
, void *cb_arg
)
131 struct spdk_blob
*first
;
134 first
= TAILQ_FIRST(&bs
->blobs
);
137 } else if (first
->load_status
!= 0) {
138 _errno
= first
->load_status
;
141 cb_fn(cb_arg
, first
, _errno
);
144 uint64_t spdk_blob_get_num_clusters(struct spdk_blob
*blob
)
150 spdk_bs_get_super(struct spdk_blob_store
*bs
,
151 spdk_blob_op_with_id_complete cb_fn
, void *cb_arg
)
153 if (bs
->get_super_status
!= 0) {
154 cb_fn(cb_arg
, 0, bs
->get_super_status
);
156 cb_fn(cb_arg
, bs
->super_blobid
, 0);
161 spdk_bs_set_super(struct spdk_blob_store
*bs
, spdk_blob_id blobid
,
162 spdk_bs_op_complete cb_fn
, void *cb_arg
)
164 bs
->super_blobid
= blobid
;
169 spdk_bs_load(struct spdk_bs_dev
*dev
, struct spdk_bs_opts
*opts
,
170 spdk_bs_op_with_handle_complete cb_fn
, void *cb_arg
)
172 struct lvol_ut_bs_dev
*ut_dev
= SPDK_CONTAINEROF(dev
, struct lvol_ut_bs_dev
, bs_dev
);
173 struct spdk_blob_store
*bs
= NULL
;
175 if (ut_dev
->load_status
== 0) {
179 cb_fn(cb_arg
, bs
, ut_dev
->load_status
);
182 struct spdk_io_channel
*spdk_bs_alloc_io_channel(struct spdk_blob_store
*bs
)
184 if (g_io_channel
== NULL
) {
185 g_io_channel
= calloc(1, sizeof(struct spdk_io_channel
));
186 SPDK_CU_ASSERT_FATAL(g_io_channel
!= NULL
);
192 void spdk_bs_free_io_channel(struct spdk_io_channel
*channel
)
195 if (g_io_channel
->ref
== 0) {
203 spdk_blob_set_xattr(struct spdk_blob
*blob
, const char *name
, const void *value
,
206 if (!strcmp(name
, "uuid")) {
207 CU_ASSERT(value_len
== SPDK_UUID_STRING_LEN
);
208 memcpy(blob
->uuid
, value
, SPDK_UUID_STRING_LEN
);
209 } else if (!strcmp(name
, "name")) {
210 CU_ASSERT(value_len
<= SPDK_LVS_NAME_MAX
);
211 memcpy(blob
->name
, value
, value_len
);
218 spdk_blob_get_xattr_value(struct spdk_blob
*blob
, const char *name
,
219 const void **value
, size_t *value_len
)
221 if (!strcmp(name
, "uuid") && strnlen(blob
->uuid
, SPDK_UUID_STRING_LEN
) != 0) {
222 CU_ASSERT(strnlen(blob
->uuid
, SPDK_UUID_STRING_LEN
) == (SPDK_UUID_STRING_LEN
- 1));
224 *value_len
= SPDK_UUID_STRING_LEN
;
226 } else if (!strcmp(name
, "name") && strnlen(blob
->name
, SPDK_LVS_NAME_MAX
) != 0) {
228 *value_len
= strnlen(blob
->name
, SPDK_LVS_NAME_MAX
) + 1;
236 spdk_blob_get_clones(struct spdk_blob_store
*bs
, spdk_blob_id blobid
, spdk_blob_id
*ids
,
243 spdk_bs_get_page_size(struct spdk_blob_store
*bs
)
249 spdk_bdev_notify_blockcnt_change(struct spdk_bdev
*bdev
, uint64_t size
)
251 bdev
->blockcnt
= size
;
256 init_dev(struct lvol_ut_bs_dev
*dev
)
258 memset(dev
, 0, sizeof(*dev
));
259 dev
->bs_dev
.blockcnt
= DEV_BUFFER_BLOCKCNT
;
260 dev
->bs_dev
.blocklen
= DEV_BUFFER_BLOCKLEN
;
264 free_dev(struct lvol_ut_bs_dev
*dev
)
266 struct spdk_blob_store
*bs
= dev
->bs
;
267 struct spdk_blob
*blob
, *tmp
;
273 TAILQ_FOREACH_SAFE(blob
, &bs
->blobs
, link
, tmp
) {
274 TAILQ_REMOVE(&bs
->blobs
, blob
, link
);
283 spdk_bs_init(struct spdk_bs_dev
*dev
, struct spdk_bs_opts
*o
,
284 spdk_bs_op_with_handle_complete cb_fn
, void *cb_arg
)
286 struct lvol_ut_bs_dev
*ut_dev
= SPDK_CONTAINEROF(dev
, struct lvol_ut_bs_dev
, bs_dev
);
287 struct spdk_blob_store
*bs
;
289 bs
= calloc(1, sizeof(*bs
));
290 SPDK_CU_ASSERT_FATAL(bs
!= NULL
);
292 TAILQ_INIT(&bs
->blobs
);
296 memcpy(&bs
->bs_opts
, o
, sizeof(struct spdk_bs_opts
));
298 cb_fn(cb_arg
, bs
, 0);
302 spdk_bs_unload(struct spdk_blob_store
*bs
, spdk_bs_op_complete cb_fn
, void *cb_arg
)
308 spdk_bs_destroy(struct spdk_blob_store
*bs
, spdk_bs_op_complete cb_fn
,
317 spdk_bs_delete_blob(struct spdk_blob_store
*bs
, spdk_blob_id blobid
,
318 spdk_blob_op_complete cb_fn
, void *cb_arg
)
320 struct spdk_blob
*blob
;
322 TAILQ_FOREACH(blob
, &bs
->blobs
, link
) {
323 if (blob
->id
== blobid
) {
324 TAILQ_REMOVE(&bs
->blobs
, blob
, link
);
330 cb_fn(cb_arg
, g_remove_rc
);
334 spdk_blob_get_id(struct spdk_blob
*blob
)
340 spdk_bs_opts_init(struct spdk_bs_opts
*opts
)
342 opts
->cluster_sz
= SPDK_BLOB_OPTS_CLUSTER_SZ
;
343 opts
->num_md_pages
= SPDK_BLOB_OPTS_NUM_MD_PAGES
;
344 opts
->max_md_ops
= SPDK_BLOB_OPTS_MAX_MD_OPS
;
345 opts
->max_channel_ops
= SPDK_BLOB_OPTS_MAX_CHANNEL_OPS
;
346 memset(&opts
->bstype
, 0, sizeof(opts
->bstype
));
350 spdk_bs_get_cluster_size(struct spdk_blob_store
*bs
)
352 return BS_CLUSTER_SIZE
;
355 void spdk_blob_close(struct spdk_blob
*b
, spdk_blob_op_complete cb_fn
, void *cb_arg
)
359 cb_fn(cb_arg
, b
->close_status
);
363 spdk_blob_resize(struct spdk_blob
*blob
, uint64_t sz
, spdk_blob_op_complete cb_fn
, void *cb_arg
)
365 if (g_resize_rc
!= 0) {
366 return cb_fn(cb_arg
, g_resize_rc
);
367 } else if (sz
> DEV_BUFFER_SIZE
/ BS_CLUSTER_SIZE
) {
368 return cb_fn(cb_arg
, -ENOMEM
);
374 spdk_blob_set_read_only(struct spdk_blob
*blob
)
380 spdk_blob_sync_md(struct spdk_blob
*blob
, spdk_blob_op_complete cb_fn
, void *cb_arg
)
386 spdk_bs_open_blob_ext(struct spdk_blob_store
*bs
, spdk_blob_id blobid
,
387 struct spdk_blob_open_opts
*opts
, spdk_blob_op_with_handle_complete cb_fn
, void *cb_arg
)
389 spdk_bs_open_blob(bs
, blobid
, cb_fn
, cb_arg
);
393 spdk_bs_open_blob(struct spdk_blob_store
*bs
, spdk_blob_id blobid
,
394 spdk_blob_op_with_handle_complete cb_fn
, void *cb_arg
)
396 struct spdk_blob
*blob
;
398 if (!g_lvs_rename_blob_open_error
) {
399 TAILQ_FOREACH(blob
, &bs
->blobs
, link
) {
400 if (blob
->id
== blobid
) {
402 cb_fn(cb_arg
, blob
, blob
->open_status
);
408 cb_fn(cb_arg
, NULL
, -ENOENT
);
412 spdk_bs_free_cluster_count(struct spdk_blob_store
*bs
)
414 return BS_FREE_CLUSTERS
;
418 spdk_blob_opts_init(struct spdk_blob_opts
*opts
)
420 opts
->num_clusters
= 0;
421 opts
->thin_provision
= false;
422 opts
->xattrs
.count
= 0;
423 opts
->xattrs
.names
= NULL
;
424 opts
->xattrs
.ctx
= NULL
;
425 opts
->xattrs
.get_value
= NULL
;
429 spdk_blob_open_opts_init(struct spdk_blob_open_opts
*opts
)
431 opts
->clear_method
= BLOB_CLEAR_WITH_DEFAULT
;
435 spdk_bs_create_blob(struct spdk_blob_store
*bs
,
436 spdk_blob_op_with_id_complete cb_fn
, void *cb_arg
)
438 spdk_bs_create_blob_ext(bs
, NULL
, cb_fn
, cb_arg
);
442 spdk_bs_create_blob_ext(struct spdk_blob_store
*bs
, const struct spdk_blob_opts
*opts
,
443 spdk_blob_op_with_id_complete cb_fn
, void *cb_arg
)
447 if (opts
&& opts
->num_clusters
> DEV_BUFFER_SIZE
/ BS_CLUSTER_SIZE
) {
448 cb_fn(cb_arg
, 0, -1);
452 b
= calloc(1, sizeof(*b
));
453 SPDK_CU_ASSERT_FATAL(b
!= NULL
);
456 if (opts
!= NULL
&& opts
->thin_provision
) {
457 b
->thin_provisioned
= true;
461 TAILQ_INSERT_TAIL(&bs
->blobs
, b
, link
);
462 cb_fn(cb_arg
, b
->id
, 0);
466 spdk_bs_create_snapshot(struct spdk_blob_store
*bs
, spdk_blob_id blobid
,
467 const struct spdk_blob_xattr_opts
*snapshot_xattrs
,
468 spdk_blob_op_with_id_complete cb_fn
, void *cb_arg
)
470 spdk_bs_create_blob_ext(bs
, NULL
, cb_fn
, cb_arg
);
474 spdk_bs_create_clone(struct spdk_blob_store
*bs
, spdk_blob_id blobid
,
475 const struct spdk_blob_xattr_opts
*clone_xattrs
,
476 spdk_blob_op_with_id_complete cb_fn
, void *cb_arg
)
478 spdk_bs_create_blob_ext(bs
, NULL
, cb_fn
, cb_arg
);
482 lvol_store_op_with_handle_complete(void *cb_arg
, struct spdk_lvol_store
*lvol_store
, int lvserrno
)
484 g_lvol_store
= lvol_store
;
485 g_lvserrno
= lvserrno
;
489 lvol_op_complete(void *cb_arg
, int lvolerrno
)
491 g_lvolerrno
= lvolerrno
;
495 lvol_op_with_handle_complete(void *cb_arg
, struct spdk_lvol
*lvol
, int lvserrno
)
498 g_lvserrno
= lvserrno
;
502 lvol_store_op_complete(void *cb_arg
, int lvserrno
)
504 g_lvserrno
= lvserrno
;
508 close_cb(void *cb_arg
, int lvolerrno
)
510 g_lvserrno
= lvolerrno
;
514 destroy_cb(void *cb_arg
, int lvolerrno
)
516 g_lvserrno
= lvolerrno
;
520 lvs_init_unload_success(void)
522 struct lvol_ut_bs_dev dev
;
523 struct spdk_lvs_opts opts
;
528 spdk_lvs_opts_init(&opts
);
529 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
533 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
534 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
536 CU_ASSERT(g_lvserrno
== 0);
537 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
538 CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores
));
540 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
541 lvol_op_with_handle_complete
, NULL
);
542 CU_ASSERT(g_lvserrno
== 0);
543 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
545 /* Lvol store has an open lvol, this unload should fail. */
547 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
548 CU_ASSERT(rc
== -EBUSY
);
549 CU_ASSERT(g_lvserrno
== -EBUSY
);
550 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
551 CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores
));
553 /* Lvol has to be closed (or destroyed) before unloading lvol store. */
554 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
555 CU_ASSERT(g_lvserrno
== 0);
558 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
560 CU_ASSERT(g_lvserrno
== 0);
562 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
568 lvs_init_destroy_success(void)
570 struct lvol_ut_bs_dev dev
;
571 struct spdk_lvs_opts opts
;
576 spdk_lvs_opts_init(&opts
);
577 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
581 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
583 CU_ASSERT(g_lvserrno
== 0);
584 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
586 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
587 lvol_op_with_handle_complete
, NULL
);
588 CU_ASSERT(g_lvserrno
== 0);
589 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
591 /* Lvol store contains one lvol, this destroy should fail. */
593 rc
= spdk_lvs_destroy(g_lvol_store
, lvol_store_op_complete
, NULL
);
594 CU_ASSERT(rc
== -EBUSY
);
595 CU_ASSERT(g_lvserrno
== -EBUSY
);
596 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
598 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
599 CU_ASSERT(g_lvserrno
== 0);
601 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
604 rc
= spdk_lvs_destroy(g_lvol_store
, lvol_store_op_complete
, NULL
);
606 CU_ASSERT(g_lvserrno
== 0);
611 lvs_init_opts_success(void)
613 struct lvol_ut_bs_dev dev
;
614 struct spdk_lvs_opts opts
;
621 spdk_lvs_opts_init(&opts
);
622 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
623 opts
.cluster_sz
= 8192;
624 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
626 CU_ASSERT(g_lvserrno
== 0);
627 CU_ASSERT(dev
.bs
->bs_opts
.cluster_sz
== opts
.cluster_sz
);
628 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
631 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
633 CU_ASSERT(g_lvserrno
== 0);
640 lvs_unload_lvs_is_null_fail(void)
645 rc
= spdk_lvs_unload(NULL
, lvol_store_op_complete
, NULL
);
646 CU_ASSERT(rc
== -ENODEV
);
647 CU_ASSERT(g_lvserrno
== -1);
653 struct lvol_ut_bs_dev dev_x
, dev_y
, dev_x2
;
654 struct spdk_lvs_opts opts_none
, opts_x
, opts_y
, opts_full
;
655 struct spdk_lvol_store
*lvs_x
, *lvs_y
, *lvs_x2
;
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
));
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
);
674 CU_ASSERT(g_lvol_store
== NULL
);
675 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
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
);
681 CU_ASSERT(g_lvol_store
== NULL
);
682 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
684 /* Test that we can create an lvolstore with name 'x'. */
685 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
687 rc
= spdk_lvs_init(&dev_x
.bs_dev
, &opts_x
, lvol_store_op_with_handle_complete
, NULL
);
689 CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores
));
690 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
691 lvs_x
= g_lvol_store
;
693 /* Test that we can create an lvolstore with name 'y'. */
695 rc
= spdk_lvs_init(&dev_y
.bs_dev
, &opts_y
, lvol_store_op_with_handle_complete
, NULL
);
697 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
698 lvs_y
= g_lvol_store
;
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
);
704 /* Now destroy lvolstore 'x' and then confirm we can create a new lvolstore with name 'x'. */
706 rc
= spdk_lvs_destroy(lvs_x
, lvol_store_op_complete
, NULL
);
708 CU_ASSERT(g_lvserrno
== 0);
710 rc
= spdk_lvs_init(&dev_x
.bs_dev
, &opts_x
, lvol_store_op_with_handle_complete
, NULL
);
712 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
713 lvs_x
= g_lvol_store
;
716 * Unload lvolstore 'x'. Then we should be able to create another lvolstore with name 'x'.
719 rc
= spdk_lvs_unload(lvs_x
, lvol_store_op_complete
, NULL
);
721 CU_ASSERT(g_lvserrno
== 0);
723 rc
= spdk_lvs_init(&dev_x2
.bs_dev
, &opts_x
, lvol_store_op_with_handle_complete
, NULL
);
725 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
726 lvs_x2
= g_lvol_store
;
728 /* Confirm that we cannot load the first lvolstore 'x'. */
730 spdk_lvs_load(&dev_x
.bs_dev
, lvol_store_op_with_handle_complete
, NULL
);
731 CU_ASSERT(g_lvserrno
!= 0);
733 /* Destroy the second lvolstore 'x'. Then we should be able to load the first lvolstore 'x'. */
735 rc
= spdk_lvs_destroy(lvs_x2
, lvol_store_op_complete
, NULL
);
737 CU_ASSERT(g_lvserrno
== 0);
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
;
745 rc
= spdk_lvs_destroy(lvs_x
, lvol_store_op_complete
, NULL
);
747 CU_ASSERT(g_lvserrno
== 0);
750 rc
= spdk_lvs_destroy(lvs_y
, lvol_store_op_complete
, NULL
);
752 CU_ASSERT(g_lvserrno
== 0);
756 lvol_create_destroy_success(void)
758 struct lvol_ut_bs_dev dev
;
759 struct spdk_lvs_opts opts
;
764 spdk_lvs_opts_init(&opts
);
765 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
768 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
770 CU_ASSERT(g_lvserrno
== 0);
771 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
773 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
774 lvol_op_with_handle_complete
, NULL
);
775 CU_ASSERT(g_lvserrno
== 0);
776 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
778 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
779 CU_ASSERT(g_lvserrno
== 0);
780 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
781 CU_ASSERT(g_lvserrno
== 0);
784 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
786 CU_ASSERT(g_lvserrno
== 0);
793 lvol_create_fail(void)
795 struct lvol_ut_bs_dev dev
;
796 struct spdk_lvs_opts opts
;
801 spdk_lvs_opts_init(&opts
);
802 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
806 rc
= spdk_lvs_init(NULL
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
808 CU_ASSERT(g_lvol_store
== NULL
);
810 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
812 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
815 rc
= spdk_lvol_create(NULL
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
816 lvol_op_with_handle_complete
, NULL
);
818 CU_ASSERT(g_lvol
== NULL
);
821 rc
= spdk_lvol_create(g_lvol_store
, "lvol", DEV_BUFFER_SIZE
+ 1, false, LVOL_CLEAR_WITH_DEFAULT
,
822 lvol_op_with_handle_complete
, NULL
);
824 CU_ASSERT(g_lvserrno
!= 0);
825 CU_ASSERT(g_lvol
== NULL
);
828 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
830 CU_ASSERT(g_lvserrno
== 0);
837 lvol_destroy_fail(void)
839 struct lvol_ut_bs_dev dev
;
840 struct spdk_lvs_opts opts
;
845 spdk_lvs_opts_init(&opts
);
846 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
848 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
850 CU_ASSERT(g_lvserrno
== 0);
851 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
853 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
854 lvol_op_with_handle_complete
, NULL
);
855 CU_ASSERT(g_lvserrno
== 0);
856 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
858 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
859 CU_ASSERT(g_lvserrno
== 0);
860 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
861 CU_ASSERT(g_lvserrno
== 0);
863 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
864 lvol_op_with_handle_complete
, NULL
);
865 CU_ASSERT(g_lvserrno
== 0);
866 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
868 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
869 CU_ASSERT(g_lvserrno
== 0);
872 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
873 CU_ASSERT(g_lvserrno
!= 0);
874 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store
->lvols
));
878 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
880 CU_ASSERT(g_lvserrno
== 0);
887 lvol_close_fail(void)
889 struct lvol_ut_bs_dev dev
;
890 struct spdk_lvs_opts opts
;
895 spdk_lvs_opts_init(&opts
);
896 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
898 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
900 CU_ASSERT(g_lvserrno
== 0);
901 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
903 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
904 lvol_op_with_handle_complete
, NULL
);
905 CU_ASSERT(g_lvserrno
== 0);
906 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
908 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
909 CU_ASSERT(g_lvserrno
== 0);
912 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
914 CU_ASSERT(g_lvserrno
== 0);
921 lvol_close_success(void)
923 struct lvol_ut_bs_dev dev
;
924 struct spdk_lvs_opts opts
;
929 spdk_lvs_opts_init(&opts
);
930 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
933 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
935 CU_ASSERT(g_lvserrno
== 0);
936 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
938 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
939 lvol_op_with_handle_complete
, NULL
);
940 CU_ASSERT(g_lvserrno
== 0);
941 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
943 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
944 CU_ASSERT(g_lvserrno
== 0);
947 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
949 CU_ASSERT(g_lvserrno
== 0);
958 struct lvol_ut_bs_dev dev
;
959 struct spdk_lvs_opts opts
;
964 spdk_lvs_opts_init(&opts
);
965 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
969 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
971 CU_ASSERT(g_lvserrno
== 0);
972 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
974 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
975 lvol_op_with_handle_complete
, NULL
);
976 CU_ASSERT(g_lvserrno
== 0);
977 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
979 /* Resize to same size */
980 spdk_lvol_resize(g_lvol
, 10, lvol_store_op_complete
, NULL
);
981 CU_ASSERT(g_lvserrno
== 0);
983 /* Resize to smaller size */
984 spdk_lvol_resize(g_lvol
, 5, lvol_store_op_complete
, NULL
);
985 CU_ASSERT(g_lvserrno
== 0);
987 /* Resize to bigger size */
988 spdk_lvol_resize(g_lvol
, 15, lvol_store_op_complete
, NULL
);
989 CU_ASSERT(g_lvserrno
== 0);
991 /* Resize to size = 0 */
992 spdk_lvol_resize(g_lvol
, 0, lvol_store_op_complete
, NULL
);
993 CU_ASSERT(g_lvserrno
== 0);
995 /* Resize to bigger size than available */
997 spdk_lvol_resize(g_lvol
, 0xFFFFFFFF, lvol_store_op_complete
, NULL
);
998 CU_ASSERT(g_lvserrno
!= 0);
1003 spdk_lvol_resize(g_lvol
, 10, lvol_store_op_complete
, NULL
);
1004 CU_ASSERT(g_lvserrno
!= 0);
1008 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
1009 CU_ASSERT(g_lvserrno
== 0);
1010 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
1011 CU_ASSERT(g_lvserrno
== 0);
1014 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1016 CU_ASSERT(g_lvserrno
== 0);
1017 g_lvol_store
= NULL
;
1023 lvol_set_read_only(void)
1025 struct lvol_ut_bs_dev dev
;
1026 struct spdk_lvs_opts opts
;
1028 struct spdk_lvol
*lvol
, *clone
;
1032 spdk_lvs_opts_init(&opts
);
1033 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1036 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1038 CU_ASSERT(g_lvserrno
== 0);
1039 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1041 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
1042 lvol_op_with_handle_complete
, NULL
);
1043 CU_ASSERT(g_lvolerrno
== 0);
1044 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1047 /* Set lvol as read only */
1048 spdk_lvol_set_read_only(lvol
, lvol_op_complete
, NULL
);
1049 CU_ASSERT(g_lvolerrno
== 0);
1051 /* Create lvol clone from read only lvol */
1052 spdk_lvol_create_clone(lvol
, "clone", lvol_op_with_handle_complete
, NULL
);
1053 CU_ASSERT(g_lvolerrno
== 0);
1054 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1055 CU_ASSERT_STRING_EQUAL(g_lvol
->name
, "clone");
1058 spdk_lvol_close(lvol
, close_cb
, NULL
);
1059 CU_ASSERT(g_lvserrno
== 0);
1060 spdk_lvol_close(clone
, close_cb
, NULL
);
1061 CU_ASSERT(g_lvserrno
== 0);
1064 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1066 CU_ASSERT(g_lvserrno
== 0);
1067 g_lvol_store
= NULL
;
1073 null_cb(void *ctx
, struct spdk_blob_store
*bs
, int bserrno
)
1075 SPDK_CU_ASSERT_FATAL(bs
!= NULL
);
1082 struct lvol_ut_bs_dev dev
;
1083 struct spdk_lvs_with_handle_req
*req
;
1084 struct spdk_bs_opts bs_opts
= {};
1085 struct spdk_blob
*super_blob
;
1087 req
= calloc(1, sizeof(*req
));
1088 SPDK_CU_ASSERT_FATAL(req
!= NULL
);
1091 spdk_bs_opts_init(&bs_opts
);
1092 snprintf(bs_opts
.bstype
.bstype
, sizeof(bs_opts
.bstype
.bstype
), "LVOLSTORE");
1093 spdk_bs_init(&dev
.bs_dev
, &bs_opts
, null_cb
, NULL
);
1095 /* Fail on bs load */
1096 dev
.load_status
= -1;
1097 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1098 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1099 CU_ASSERT(g_lvserrno
!= 0);
1100 CU_ASSERT(g_lvol_store
== NULL
);
1101 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1103 /* Fail on getting super blob */
1104 dev
.load_status
= 0;
1105 dev
.bs
->get_super_status
= -1;
1106 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1107 CU_ASSERT(g_lvserrno
== -ENODEV
);
1108 CU_ASSERT(g_lvol_store
== NULL
);
1109 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1111 /* Fail on opening super blob */
1113 super_blob
= calloc(1, sizeof(*super_blob
));
1114 super_blob
->id
= 0x100;
1115 super_blob
->open_status
= -1;
1116 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, super_blob
, link
);
1117 dev
.bs
->super_blobid
= 0x100;
1118 dev
.bs
->get_super_status
= 0;
1119 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1120 CU_ASSERT(g_lvserrno
== -ENODEV
);
1121 CU_ASSERT(g_lvol_store
== NULL
);
1122 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1124 /* Fail on getting uuid */
1126 super_blob
->open_status
= 0;
1127 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1128 CU_ASSERT(g_lvserrno
== -EINVAL
);
1129 CU_ASSERT(g_lvol_store
== NULL
);
1130 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1132 /* Fail on getting name */
1134 spdk_blob_set_xattr(super_blob
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1135 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1136 CU_ASSERT(g_lvserrno
== -EINVAL
);
1137 CU_ASSERT(g_lvol_store
== NULL
);
1138 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1140 /* Fail on closing super blob */
1142 spdk_blob_set_xattr(super_blob
, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX
) + 1);
1143 super_blob
->close_status
= -1;
1144 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1145 CU_ASSERT(g_lvserrno
== -ENODEV
);
1146 CU_ASSERT(g_lvol_store
== NULL
);
1147 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1149 /* Load successfully */
1151 super_blob
->close_status
= 0;
1152 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1153 CU_ASSERT(g_lvserrno
== 0);
1154 CU_ASSERT(g_lvol_store
!= NULL
);
1155 CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores
));
1158 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1160 CU_ASSERT(g_lvserrno
== 0);
1161 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores
));
1171 struct lvol_ut_bs_dev dev
;
1172 struct spdk_lvs_with_handle_req
*req
;
1173 struct spdk_bs_opts bs_opts
;
1174 struct spdk_blob
*super_blob
, *blob1
, *blob2
, *blob3
;
1176 req
= calloc(1, sizeof(*req
));
1177 SPDK_CU_ASSERT_FATAL(req
!= NULL
);
1180 spdk_bs_opts_init(&bs_opts
);
1181 snprintf(bs_opts
.bstype
.bstype
, sizeof(bs_opts
.bstype
.bstype
), "LVOLSTORE");
1182 spdk_bs_init(&dev
.bs_dev
, &bs_opts
, null_cb
, NULL
);
1183 super_blob
= calloc(1, sizeof(*super_blob
));
1184 SPDK_CU_ASSERT_FATAL(super_blob
!= NULL
);
1185 super_blob
->id
= 0x100;
1186 spdk_blob_set_xattr(super_blob
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1187 spdk_blob_set_xattr(super_blob
, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX
) + 1);
1188 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, super_blob
, link
);
1189 dev
.bs
->super_blobid
= 0x100;
1192 * Create 3 blobs, write different char values to the last char in the UUID
1193 * to make sure they are unique.
1195 blob1
= calloc(1, sizeof(*blob1
));
1196 SPDK_CU_ASSERT_FATAL(blob1
!= NULL
);
1198 spdk_blob_set_xattr(blob1
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1199 spdk_blob_set_xattr(blob1
, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX
) + 1);
1200 blob1
->uuid
[SPDK_UUID_STRING_LEN
- 2] = '1';
1202 blob2
= calloc(1, sizeof(*blob2
));
1203 SPDK_CU_ASSERT_FATAL(blob2
!= NULL
);
1205 spdk_blob_set_xattr(blob2
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1206 spdk_blob_set_xattr(blob2
, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX
) + 1);
1207 blob2
->uuid
[SPDK_UUID_STRING_LEN
- 2] = '2';
1209 blob3
= calloc(1, sizeof(*blob3
));
1210 SPDK_CU_ASSERT_FATAL(blob3
!= NULL
);
1212 spdk_blob_set_xattr(blob3
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1213 spdk_blob_set_xattr(blob3
, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX
) + 1);
1214 blob3
->uuid
[SPDK_UUID_STRING_LEN
- 2] = '3';
1216 /* Load lvs with 0 blobs */
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 CU_ASSERT(g_lvserrno
== 0);
1224 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1226 CU_ASSERT(g_lvserrno
== 0);
1228 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, blob1
, link
);
1229 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, blob2
, link
);
1230 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, blob3
, link
);
1232 /* Load lvs again with 3 blobs, but fail on 1st one */
1233 g_lvol_store
= NULL
;
1235 blob1
->load_status
= -1;
1236 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1237 CU_ASSERT(g_lvserrno
!= 0);
1238 CU_ASSERT(g_lvol_store
== NULL
);
1240 /* Load lvs again with 3 blobs, but fail on 3rd one */
1241 g_lvol_store
= NULL
;
1243 blob1
->load_status
= 0;
1244 blob2
->load_status
= 0;
1245 blob3
->load_status
= -1;
1246 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1247 CU_ASSERT(g_lvserrno
!= 0);
1248 CU_ASSERT(g_lvol_store
== NULL
);
1250 /* Load lvs again with 3 blobs, with success */
1251 g_lvol_store
= NULL
;
1253 blob1
->load_status
= 0;
1254 blob2
->load_status
= 0;
1255 blob3
->load_status
= 0;
1256 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1257 CU_ASSERT(g_lvserrno
== 0);
1258 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1259 CU_ASSERT(!TAILQ_EMPTY(&g_lvol_store
->lvols
));
1262 /* rc = */ spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1264 * Disable these two asserts for now. lvolstore should allow unload as long
1265 * as the lvols were not opened - but this is coming a future patch.
1267 /* CU_ASSERT(rc == 0); */
1268 /* CU_ASSERT(g_lvserrno == 0); */
1277 struct lvol_ut_bs_dev dev
;
1278 struct spdk_lvs_with_handle_req
*req
;
1279 struct spdk_bs_opts bs_opts
;
1280 struct spdk_blob
*super_blob
, *blob1
, *blob2
, *blob3
;
1281 struct spdk_lvol
*lvol
, *tmp
;
1283 req
= calloc(1, sizeof(*req
));
1284 SPDK_CU_ASSERT_FATAL(req
!= NULL
);
1287 spdk_bs_opts_init(&bs_opts
);
1288 snprintf(bs_opts
.bstype
.bstype
, sizeof(bs_opts
.bstype
.bstype
), "LVOLSTORE");
1289 spdk_bs_init(&dev
.bs_dev
, &bs_opts
, null_cb
, NULL
);
1290 super_blob
= calloc(1, sizeof(*super_blob
));
1291 SPDK_CU_ASSERT_FATAL(super_blob
!= NULL
);
1292 super_blob
->id
= 0x100;
1293 spdk_blob_set_xattr(super_blob
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1294 spdk_blob_set_xattr(super_blob
, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX
) + 1);
1295 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, super_blob
, link
);
1296 dev
.bs
->super_blobid
= 0x100;
1299 * Create 3 blobs, write different char values to the last char in the UUID
1300 * to make sure they are unique.
1302 blob1
= calloc(1, sizeof(*blob1
));
1303 SPDK_CU_ASSERT_FATAL(blob1
!= NULL
);
1305 spdk_blob_set_xattr(blob1
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1306 spdk_blob_set_xattr(blob1
, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX
) + 1);
1307 blob1
->uuid
[SPDK_UUID_STRING_LEN
- 2] = '1';
1309 blob2
= calloc(1, sizeof(*blob2
));
1310 SPDK_CU_ASSERT_FATAL(blob2
!= NULL
);
1312 spdk_blob_set_xattr(blob2
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1313 spdk_blob_set_xattr(blob2
, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX
) + 1);
1314 blob2
->uuid
[SPDK_UUID_STRING_LEN
- 2] = '2';
1316 blob3
= calloc(1, sizeof(*blob3
));
1317 SPDK_CU_ASSERT_FATAL(blob3
!= NULL
);
1319 spdk_blob_set_xattr(blob3
, "uuid", uuid
, SPDK_UUID_STRING_LEN
);
1320 spdk_blob_set_xattr(blob3
, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX
) + 1);
1321 blob3
->uuid
[SPDK_UUID_STRING_LEN
- 2] = '3';
1323 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, blob1
, link
);
1324 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, blob2
, link
);
1325 TAILQ_INSERT_TAIL(&dev
.bs
->blobs
, blob3
, link
);
1327 /* Load lvs with 3 blobs */
1328 g_lvol_store
= NULL
;
1330 spdk_lvs_load(&dev
.bs_dev
, lvol_store_op_with_handle_complete
, req
);
1331 CU_ASSERT(g_lvserrno
== 0);
1332 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1333 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_stores
));
1335 blob1
->open_status
= -1;
1336 blob2
->open_status
= -1;
1337 blob3
->open_status
= -1;
1339 /* Fail opening all lvols */
1340 TAILQ_FOREACH_SAFE(lvol
, &g_lvol_store
->lvols
, link
, tmp
) {
1341 spdk_lvol_open(lvol
, lvol_op_with_handle_complete
, NULL
);
1342 CU_ASSERT(g_lvserrno
!= 0);
1345 blob1
->open_status
= 0;
1346 blob2
->open_status
= 0;
1347 blob3
->open_status
= 0;
1349 /* Open all lvols */
1350 TAILQ_FOREACH_SAFE(lvol
, &g_lvol_store
->lvols
, link
, tmp
) {
1351 spdk_lvol_open(lvol
, lvol_op_with_handle_complete
, NULL
);
1352 CU_ASSERT(g_lvserrno
== 0);
1355 /* Close all lvols */
1356 TAILQ_FOREACH_SAFE(lvol
, &g_lvol_store
->lvols
, link
, tmp
) {
1357 spdk_lvol_close(lvol
, lvol_op_complete
, NULL
);
1358 CU_ASSERT(g_lvserrno
== 0);
1362 spdk_lvs_destroy(g_lvol_store
, lvol_store_op_complete
, NULL
);
1373 struct lvol_ut_bs_dev dev
;
1374 struct spdk_lvol
*lvol
;
1375 struct spdk_lvs_opts opts
;
1380 spdk_lvs_opts_init(&opts
);
1381 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1384 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1386 CU_ASSERT(g_lvserrno
== 0);
1387 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1389 spdk_lvol_create(g_lvol_store
, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT
,
1390 lvol_op_with_handle_complete
, NULL
);
1391 CU_ASSERT(g_lvserrno
== 0);
1392 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1396 spdk_lvol_create_snapshot(lvol
, "snap", lvol_op_with_handle_complete
, NULL
);
1397 CU_ASSERT(g_lvserrno
== 0);
1398 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1399 CU_ASSERT_STRING_EQUAL(g_lvol
->name
, "snap");
1401 /* Lvol has to be closed (or destroyed) before unloading lvol store. */
1402 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
1403 CU_ASSERT(g_lvserrno
== 0);
1406 spdk_lvol_close(lvol
, close_cb
, NULL
);
1407 CU_ASSERT(g_lvserrno
== 0);
1410 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1412 CU_ASSERT(g_lvserrno
== 0);
1413 g_lvol_store
= NULL
;
1419 lvol_snapshot_fail(void)
1421 struct lvol_ut_bs_dev dev
;
1422 struct spdk_lvol
*lvol
, *snap
;
1423 struct spdk_lvs_opts opts
;
1428 spdk_lvs_opts_init(&opts
);
1429 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1432 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1434 CU_ASSERT(g_lvserrno
== 0);
1435 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1437 spdk_lvol_create(g_lvol_store
, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT
,
1438 lvol_op_with_handle_complete
, NULL
);
1439 CU_ASSERT(g_lvserrno
== 0);
1440 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1444 spdk_lvol_create_snapshot(NULL
, "snap", lvol_op_with_handle_complete
, NULL
);
1445 CU_ASSERT(g_lvserrno
< 0);
1446 SPDK_CU_ASSERT_FATAL(g_lvol
== NULL
);
1448 spdk_lvol_create_snapshot(lvol
, "", lvol_op_with_handle_complete
, NULL
);
1449 CU_ASSERT(g_lvserrno
< 0);
1450 SPDK_CU_ASSERT_FATAL(g_lvol
== NULL
);
1452 spdk_lvol_create_snapshot(lvol
, NULL
, lvol_op_with_handle_complete
, NULL
);
1453 CU_ASSERT(g_lvserrno
< 0);
1454 SPDK_CU_ASSERT_FATAL(g_lvol
== NULL
);
1456 spdk_lvol_create_snapshot(lvol
, "snap", lvol_op_with_handle_complete
, NULL
);
1457 CU_ASSERT(g_lvserrno
== 0);
1458 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1459 CU_ASSERT_STRING_EQUAL(g_lvol
->name
, "snap");
1463 spdk_lvol_create_snapshot(lvol
, "snap", lvol_op_with_handle_complete
, NULL
);
1464 CU_ASSERT(g_lvserrno
< 0);
1466 spdk_lvol_close(lvol
, close_cb
, NULL
);
1467 CU_ASSERT(g_lvserrno
== 0);
1470 spdk_lvol_close(snap
, close_cb
, NULL
);
1471 CU_ASSERT(g_lvserrno
== 0);
1474 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1476 CU_ASSERT(g_lvserrno
== 0);
1477 g_lvol_store
= NULL
;
1485 struct lvol_ut_bs_dev dev
;
1486 struct spdk_lvol
*lvol
;
1487 struct spdk_lvol
*snap
;
1488 struct spdk_lvs_opts opts
;
1493 spdk_lvs_opts_init(&opts
);
1494 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1497 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1499 CU_ASSERT(g_lvserrno
== 0);
1500 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1502 spdk_lvol_create(g_lvol_store
, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT
,
1503 lvol_op_with_handle_complete
, NULL
);
1504 CU_ASSERT(g_lvserrno
== 0);
1505 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1509 spdk_lvol_create_snapshot(lvol
, "snap", lvol_op_with_handle_complete
, NULL
);
1510 CU_ASSERT(g_lvserrno
== 0);
1511 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1512 CU_ASSERT_STRING_EQUAL(g_lvol
->name
, "snap");
1516 spdk_lvol_create_clone(snap
, "clone", lvol_op_with_handle_complete
, NULL
);
1517 CU_ASSERT(g_lvserrno
== 0);
1518 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1519 CU_ASSERT_STRING_EQUAL(g_lvol
->name
, "clone");
1521 /* Lvol has to be closed (or destroyed) before unloading lvol store. */
1522 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
1523 CU_ASSERT(g_lvserrno
== 0);
1526 spdk_lvol_close(snap
, close_cb
, NULL
);
1527 CU_ASSERT(g_lvserrno
== 0);
1530 spdk_lvol_close(lvol
, close_cb
, NULL
);
1531 CU_ASSERT(g_lvserrno
== 0);
1534 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1536 CU_ASSERT(g_lvserrno
== 0);
1537 g_lvol_store
= NULL
;
1543 lvol_clone_fail(void)
1545 struct lvol_ut_bs_dev dev
;
1546 struct spdk_lvol
*lvol
;
1547 struct spdk_lvol
*snap
;
1548 struct spdk_lvol
*clone
;
1549 struct spdk_lvs_opts opts
;
1554 spdk_lvs_opts_init(&opts
);
1555 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1558 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1560 CU_ASSERT(g_lvserrno
== 0);
1561 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1563 spdk_lvol_create(g_lvol_store
, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT
,
1564 lvol_op_with_handle_complete
, NULL
);
1565 CU_ASSERT(g_lvserrno
== 0);
1566 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1570 spdk_lvol_create_snapshot(lvol
, "snap", lvol_op_with_handle_complete
, NULL
);
1571 CU_ASSERT(g_lvserrno
== 0);
1572 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1573 CU_ASSERT_STRING_EQUAL(g_lvol
->name
, "snap");
1577 spdk_lvol_create_clone(NULL
, "clone", lvol_op_with_handle_complete
, NULL
);
1578 CU_ASSERT(g_lvserrno
< 0);
1580 spdk_lvol_create_clone(snap
, "", lvol_op_with_handle_complete
, NULL
);
1581 CU_ASSERT(g_lvserrno
< 0);
1583 spdk_lvol_create_clone(snap
, NULL
, lvol_op_with_handle_complete
, NULL
);
1584 CU_ASSERT(g_lvserrno
< 0);
1586 spdk_lvol_create_clone(snap
, "clone", lvol_op_with_handle_complete
, NULL
);
1587 CU_ASSERT(g_lvserrno
== 0);
1588 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1589 CU_ASSERT_STRING_EQUAL(g_lvol
->name
, "clone");
1593 spdk_lvol_create_clone(snap
, "clone", lvol_op_with_handle_complete
, NULL
);
1594 CU_ASSERT(g_lvserrno
< 0);
1596 /* Lvol has to be closed (or destroyed) before unloading lvol store. */
1597 spdk_lvol_close(clone
, close_cb
, NULL
);
1598 CU_ASSERT(g_lvserrno
== 0);
1601 spdk_lvol_close(snap
, close_cb
, NULL
);
1602 CU_ASSERT(g_lvserrno
== 0);
1605 spdk_lvol_close(lvol
, close_cb
, NULL
);
1606 CU_ASSERT(g_lvserrno
== 0);
1609 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1611 CU_ASSERT(g_lvserrno
== 0);
1612 g_lvol_store
= NULL
;
1620 struct lvol_ut_bs_dev dev
;
1621 struct spdk_lvs_opts opts
;
1622 struct spdk_lvol_store
*lvs
;
1623 struct spdk_lvol
*lvol
, *lvol2
;
1624 char fullname
[SPDK_LVOL_NAME_MAX
];
1629 spdk_lvs_opts_init(&opts
);
1630 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1633 g_lvol_store
= NULL
;
1634 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1636 CU_ASSERT(g_lvserrno
== 0);
1637 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1640 rc
= spdk_lvol_create(lvs
, NULL
, 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1642 CU_ASSERT(rc
== -EINVAL
);
1644 rc
= spdk_lvol_create(lvs
, "", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1646 CU_ASSERT(rc
== -EINVAL
);
1648 memset(fullname
, 'x', sizeof(fullname
));
1649 rc
= spdk_lvol_create(lvs
, fullname
, 1, false, LVOL_CLEAR_WITH_DEFAULT
,
1650 lvol_op_with_handle_complete
, NULL
);
1651 CU_ASSERT(rc
== -EINVAL
);
1654 rc
= spdk_lvol_create(lvs
, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1657 CU_ASSERT(g_lvserrno
== 0);
1658 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1661 rc
= spdk_lvol_create(lvs
, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1663 CU_ASSERT(rc
== -EEXIST
);
1666 rc
= spdk_lvol_create(lvs
, "lvol2", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1669 CU_ASSERT(g_lvserrno
== 0);
1670 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1673 spdk_lvol_close(lvol
, close_cb
, NULL
);
1674 spdk_lvol_destroy(lvol
, lvol_op_complete
, NULL
);
1678 rc
= spdk_lvol_create(lvs
, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1681 CU_ASSERT(g_lvserrno
== 0);
1682 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1685 spdk_lvol_close(lvol
, close_cb
, NULL
);
1686 spdk_lvol_destroy(lvol
, destroy_cb
, NULL
);
1688 spdk_lvol_close(lvol2
, close_cb
, NULL
);
1689 spdk_lvol_destroy(lvol2
, destroy_cb
, NULL
);
1691 /* Simulate creating two lvols with same name simultaneously. */
1692 lvol
= calloc(1, sizeof(*lvol
));
1693 SPDK_CU_ASSERT_FATAL(lvol
!= NULL
);
1694 snprintf(lvol
->name
, sizeof(lvol
->name
), "tmp_name");
1695 TAILQ_INSERT_TAIL(&lvs
->pending_lvols
, lvol
, link
);
1696 rc
= spdk_lvol_create(lvs
, "tmp_name", 1, false, LVOL_CLEAR_WITH_DEFAULT
,
1697 lvol_op_with_handle_complete
, NULL
);
1698 CU_ASSERT(rc
== -EEXIST
);
1700 /* Remove name from temporary list and try again. */
1701 TAILQ_REMOVE(&lvs
->pending_lvols
, lvol
, link
);
1704 rc
= spdk_lvol_create(lvs
, "tmp_name", 1, false, LVOL_CLEAR_WITH_DEFAULT
,
1705 lvol_op_with_handle_complete
, NULL
);
1707 CU_ASSERT(g_lvserrno
== 0);
1708 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1711 spdk_lvol_close(lvol
, close_cb
, NULL
);
1712 spdk_lvol_destroy(lvol
, destroy_cb
, NULL
);
1715 rc
= spdk_lvs_destroy(lvs
, lvol_store_op_complete
, NULL
);
1717 CU_ASSERT(g_lvserrno
== 0);
1718 g_lvol_store
= NULL
;
1724 struct lvol_ut_bs_dev dev
;
1725 struct spdk_lvs_opts opts
;
1726 struct spdk_lvol_store
*lvs
;
1727 struct spdk_lvol
*lvol
, *lvol2
;
1732 spdk_lvs_opts_init(&opts
);
1733 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1736 g_lvol_store
= NULL
;
1737 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1739 CU_ASSERT(g_lvserrno
== 0);
1740 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1743 /* Trying to create new lvol */
1745 rc
= spdk_lvol_create(lvs
, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1748 CU_ASSERT(g_lvserrno
== 0);
1749 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1752 /* Trying to create second lvol with existing lvol name */
1755 rc
= spdk_lvol_create(lvs
, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1757 CU_ASSERT(rc
== -EEXIST
);
1758 CU_ASSERT(g_lvserrno
== -1);
1759 SPDK_CU_ASSERT_FATAL(g_lvol
== NULL
);
1761 /* Trying to create second lvol with non existing name */
1763 rc
= spdk_lvol_create(lvs
, "lvol2", 1, false, LVOL_CLEAR_WITH_DEFAULT
, lvol_op_with_handle_complete
,
1766 CU_ASSERT(g_lvserrno
== 0);
1767 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1770 /* Trying to rename lvol with not existing name */
1771 spdk_lvol_rename(lvol
, "lvol_new", lvol_op_complete
, NULL
);
1772 CU_ASSERT(g_lvolerrno
== 0);
1773 CU_ASSERT_STRING_EQUAL(lvol
->name
, "lvol_new");
1775 /* Trying to rename lvol with other lvol name */
1776 spdk_lvol_rename(lvol2
, "lvol_new", lvol_op_complete
, NULL
);
1777 CU_ASSERT(g_lvolerrno
== -EEXIST
);
1778 CU_ASSERT_STRING_NOT_EQUAL(lvol2
->name
, "lvol_new");
1780 spdk_lvol_close(lvol
, close_cb
, NULL
);
1781 spdk_lvol_destroy(lvol
, lvol_op_complete
, NULL
);
1783 spdk_lvol_close(lvol2
, close_cb
, NULL
);
1784 spdk_lvol_destroy(lvol2
, lvol_op_complete
, NULL
);
1787 rc
= spdk_lvs_destroy(lvs
, lvol_store_op_complete
, NULL
);
1789 CU_ASSERT(g_lvserrno
== 0);
1790 g_lvol_store
= NULL
;
1796 struct lvol_ut_bs_dev dev
;
1797 struct spdk_lvs_opts opts
;
1798 struct spdk_lvol_store
*lvs
, *lvs2
;
1803 spdk_lvs_opts_init(&opts
);
1804 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1806 g_lvol_store
= NULL
;
1807 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1809 CU_ASSERT(g_lvserrno
== 0);
1810 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1813 spdk_lvs_opts_init(&opts
);
1814 snprintf(opts
.name
, sizeof(opts
.name
), "unimportant_lvs_name");
1816 g_lvol_store
= NULL
;
1817 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1819 CU_ASSERT(g_lvserrno
== 0);
1820 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1821 lvs2
= g_lvol_store
;
1823 /* Trying to rename lvs with new name */
1824 spdk_lvs_rename(lvs
, "new_lvs_name", lvol_store_op_complete
, NULL
);
1825 CU_ASSERT(g_lvserrno
== 0);
1826 CU_ASSERT_STRING_EQUAL(lvs
->name
, "new_lvs_name");
1828 /* Trying to rename lvs with name lvs already has */
1829 spdk_lvs_rename(lvs
, "new_lvs_name", lvol_store_op_complete
, NULL
);
1830 CU_ASSERT(g_lvserrno
== 0);
1831 CU_ASSERT_STRING_EQUAL(lvs
->name
, "new_lvs_name");
1833 /* Trying to rename lvs with name already existing */
1834 spdk_lvs_rename(lvs2
, "new_lvs_name", lvol_store_op_complete
, NULL
);
1835 CU_ASSERT(g_lvserrno
== -EEXIST
);
1836 CU_ASSERT_STRING_EQUAL(lvs2
->name
, "unimportant_lvs_name");
1838 /* Trying to rename lvs with another rename process started with the same name */
1839 /* Simulate renaming process in progress */
1840 snprintf(lvs2
->new_name
, sizeof(lvs2
->new_name
), "another_new_lvs_name");
1841 CU_ASSERT_STRING_EQUAL(lvs2
->new_name
, "another_new_lvs_name");
1842 /* Start second process */
1843 spdk_lvs_rename(lvs
, "another_new_lvs_name", lvol_store_op_complete
, NULL
);
1844 CU_ASSERT(g_lvserrno
== -EEXIST
);
1845 CU_ASSERT_STRING_EQUAL(lvs
->name
, "new_lvs_name");
1846 /* reverting lvs2 new name to proper value */
1847 snprintf(lvs2
->new_name
, sizeof(lvs2
->new_name
), "unimportant_lvs_name");
1848 CU_ASSERT_STRING_EQUAL(lvs2
->new_name
, "unimportant_lvs_name");
1850 /* Simulate error while lvs rename */
1851 g_lvs_rename_blob_open_error
= true;
1852 spdk_lvs_rename(lvs
, "complete_new_lvs_name", lvol_store_op_complete
, NULL
);
1853 CU_ASSERT(g_lvserrno
!= 0);
1854 CU_ASSERT_STRING_EQUAL(lvs
->name
, "new_lvs_name");
1855 CU_ASSERT_STRING_EQUAL(lvs
->new_name
, "new_lvs_name");
1856 g_lvs_rename_blob_open_error
= false;
1859 rc
= spdk_lvs_destroy(lvs
, lvol_store_op_complete
, NULL
);
1861 CU_ASSERT(g_lvserrno
== 0);
1862 g_lvol_store
= NULL
;
1865 rc
= spdk_lvs_destroy(lvs2
, lvol_store_op_complete
, NULL
);
1867 CU_ASSERT(g_lvserrno
== 0);
1868 g_lvol_store
= NULL
;
1870 static void lvol_refcnt(void)
1872 struct lvol_ut_bs_dev dev
;
1873 struct spdk_lvs_opts opts
;
1874 struct spdk_lvol
*lvol
;
1879 spdk_lvs_opts_init(&opts
);
1880 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1883 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1885 CU_ASSERT(g_lvserrno
== 0);
1886 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1889 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
1890 lvol_op_with_handle_complete
, NULL
);
1892 CU_ASSERT(g_lvserrno
== 0);
1893 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1894 CU_ASSERT(g_lvol
->ref_count
== 1);
1897 spdk_lvol_open(g_lvol
, lvol_op_with_handle_complete
, NULL
);
1898 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1899 CU_ASSERT(lvol
->ref_count
== 2);
1901 /* Trying to destroy lvol while its open should fail */
1902 spdk_lvol_destroy(lvol
, lvol_op_complete
, NULL
);
1903 CU_ASSERT(g_lvolerrno
!= 0);
1905 spdk_lvol_close(lvol
, lvol_op_complete
, NULL
);
1906 CU_ASSERT(lvol
->ref_count
== 1);
1907 CU_ASSERT(g_lvolerrno
== 0);
1909 spdk_lvol_close(lvol
, lvol_op_complete
, NULL
);
1910 CU_ASSERT(lvol
->ref_count
== 0);
1911 CU_ASSERT(g_lvolerrno
== 0);
1913 /* Try to close already closed lvol */
1914 spdk_lvol_close(lvol
, lvol_op_complete
, NULL
);
1915 CU_ASSERT(lvol
->ref_count
== 0);
1916 CU_ASSERT(g_lvolerrno
!= 0);
1919 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1921 CU_ASSERT(g_lvserrno
== 0);
1922 g_lvol_store
= NULL
;
1925 CU_ASSERT(g_lvserrno
== 0);
1926 g_lvol_store
= NULL
;
1932 lvol_create_thin_provisioned(void)
1934 struct lvol_ut_bs_dev dev
;
1935 struct spdk_lvs_opts opts
;
1940 spdk_lvs_opts_init(&opts
);
1941 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1944 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1946 CU_ASSERT(g_lvserrno
== 0);
1947 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
1949 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
1950 lvol_op_with_handle_complete
, NULL
);
1951 CU_ASSERT(g_lvserrno
== 0);
1952 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1954 CU_ASSERT(g_lvol
->blob
->thin_provisioned
== false);
1956 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
1957 CU_ASSERT(g_lvserrno
== 0);
1958 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
1959 CU_ASSERT(g_lvserrno
== 0);
1961 spdk_lvol_create(g_lvol_store
, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT
,
1962 lvol_op_with_handle_complete
, NULL
);
1963 CU_ASSERT(g_lvserrno
== 0);
1964 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
1966 CU_ASSERT(g_lvol
->blob
->thin_provisioned
== true);
1968 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
1969 CU_ASSERT(g_lvserrno
== 0);
1970 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
1971 CU_ASSERT(g_lvserrno
== 0);
1974 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
1976 CU_ASSERT(g_lvserrno
== 0);
1977 g_lvol_store
= NULL
;
1985 struct lvol_ut_bs_dev dev
;
1986 struct spdk_lvs_opts opts
;
1991 spdk_lvs_opts_init(&opts
);
1992 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
1995 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
1997 CU_ASSERT(g_lvserrno
== 0);
1998 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
2000 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
2001 lvol_op_with_handle_complete
, NULL
);
2002 CU_ASSERT(g_lvserrno
== 0);
2003 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
2006 spdk_lvol_inflate(g_lvol
, lvol_op_complete
, NULL
);
2007 CU_ASSERT(g_lvolerrno
!= 0);
2010 spdk_lvol_inflate(g_lvol
, lvol_op_complete
, NULL
);
2011 CU_ASSERT(g_lvolerrno
== 0);
2013 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
2014 CU_ASSERT(g_lvserrno
== 0);
2015 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
2016 CU_ASSERT(g_lvserrno
== 0);
2019 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
2021 CU_ASSERT(g_lvserrno
== 0);
2022 g_lvol_store
= NULL
;
2026 /* Make sure that all references to the io_channel was closed after
2029 CU_ASSERT(g_io_channel
== NULL
);
2033 lvol_decouple_parent(void)
2035 struct lvol_ut_bs_dev dev
;
2036 struct spdk_lvs_opts opts
;
2041 spdk_lvs_opts_init(&opts
);
2042 snprintf(opts
.name
, sizeof(opts
.name
), "lvs");
2045 rc
= spdk_lvs_init(&dev
.bs_dev
, &opts
, lvol_store_op_with_handle_complete
, NULL
);
2047 CU_ASSERT(g_lvserrno
== 0);
2048 SPDK_CU_ASSERT_FATAL(g_lvol_store
!= NULL
);
2050 spdk_lvol_create(g_lvol_store
, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT
,
2051 lvol_op_with_handle_complete
, NULL
);
2052 CU_ASSERT(g_lvserrno
== 0);
2053 SPDK_CU_ASSERT_FATAL(g_lvol
!= NULL
);
2056 spdk_lvol_decouple_parent(g_lvol
, lvol_op_complete
, NULL
);
2057 CU_ASSERT(g_lvolerrno
!= 0);
2060 spdk_lvol_decouple_parent(g_lvol
, lvol_op_complete
, NULL
);
2061 CU_ASSERT(g_lvolerrno
== 0);
2063 spdk_lvol_close(g_lvol
, close_cb
, NULL
);
2064 CU_ASSERT(g_lvserrno
== 0);
2065 spdk_lvol_destroy(g_lvol
, destroy_cb
, NULL
);
2066 CU_ASSERT(g_lvserrno
== 0);
2069 rc
= spdk_lvs_unload(g_lvol_store
, lvol_store_op_complete
, NULL
);
2071 CU_ASSERT(g_lvserrno
== 0);
2072 g_lvol_store
= NULL
;
2076 /* Make sure that all references to the io_channel was closed after
2079 CU_ASSERT(g_io_channel
== NULL
);
2082 int main(int argc
, char **argv
)
2084 CU_pSuite suite
= NULL
;
2085 unsigned int num_failures
;
2087 if (CU_initialize_registry() != CUE_SUCCESS
) {
2088 return CU_get_error();
2091 suite
= CU_add_suite("lvol", NULL
, NULL
);
2092 if (suite
== NULL
) {
2093 CU_cleanup_registry();
2094 return CU_get_error();
2098 CU_add_test(suite
, "lvs_init_unload_success", lvs_init_unload_success
) == NULL
||
2099 CU_add_test(suite
, "lvs_init_destroy_success", lvs_init_destroy_success
) == NULL
||
2100 CU_add_test(suite
, "lvs_init_opts_success", lvs_init_opts_success
) == NULL
||
2101 CU_add_test(suite
, "lvs_unload_lvs_is_null_fail", lvs_unload_lvs_is_null_fail
) == NULL
||
2102 CU_add_test(suite
, "lvs_names", lvs_names
) == NULL
||
2103 CU_add_test(suite
, "lvol_create_destroy_success", lvol_create_destroy_success
) == NULL
||
2104 CU_add_test(suite
, "lvol_create_fail", lvol_create_fail
) == NULL
||
2105 CU_add_test(suite
, "lvol_destroy_fail", lvol_destroy_fail
) == NULL
||
2106 CU_add_test(suite
, "lvol_close_fail", lvol_close_fail
) == NULL
||
2107 CU_add_test(suite
, "lvol_close_success", lvol_close_success
) == NULL
||
2108 CU_add_test(suite
, "lvol_resize", lvol_resize
) == NULL
||
2109 CU_add_test(suite
, "lvol_set_read_only", lvol_set_read_only
) == NULL
||
2110 CU_add_test(suite
, "lvs_load", lvs_load
) == NULL
||
2111 CU_add_test(suite
, "lvols_load", lvols_load
) == NULL
||
2112 CU_add_test(suite
, "lvol_open", lvol_open
) == NULL
||
2113 CU_add_test(suite
, "lvol_load", lvs_load
) == NULL
||
2114 CU_add_test(suite
, "lvs_load", lvols_load
) == NULL
||
2115 CU_add_test(suite
, "lvol_open", lvol_open
) == NULL
||
2116 CU_add_test(suite
, "lvol_snapshot", lvol_snapshot
) == NULL
||
2117 CU_add_test(suite
, "lvol_snapshot_fail", lvol_snapshot_fail
) == NULL
||
2118 CU_add_test(suite
, "lvol_clone", lvol_clone
) == NULL
||
2119 CU_add_test(suite
, "lvol_clone_fail", lvol_clone_fail
) == NULL
||
2120 CU_add_test(suite
, "lvol_refcnt", lvol_refcnt
) == NULL
||
2121 CU_add_test(suite
, "lvol_names", lvol_names
) == NULL
||
2122 CU_add_test(suite
, "lvol_create_thin_provisioned", lvol_create_thin_provisioned
) == NULL
||
2123 CU_add_test(suite
, "lvol_rename", lvol_rename
) == NULL
||
2124 CU_add_test(suite
, "lvs_rename", lvs_rename
) == NULL
||
2125 CU_add_test(suite
, "lvol_inflate", lvol_inflate
) == NULL
||
2126 CU_add_test(suite
, "lvol_decouple_parent", lvol_decouple_parent
) == NULL
2128 CU_cleanup_registry();
2129 return CU_get_error();
2132 allocate_threads(1);
2135 CU_basic_set_mode(CU_BRM_VERBOSE
);
2136 CU_basic_run_tests();
2137 num_failures
= CU_get_number_of_failures();
2138 CU_cleanup_registry();
2142 return num_failures
;