]> git.proxmox.com Git - ceph.git/blame - ceph/src/spdk/test/unit/lib/lvol/lvol.c/lvol_ut.c
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import 15.2.0 Octopus source
[ceph.git] / ceph / src / spdk / test / unit / lib / lvol / lvol.c / lvol_ut.c
CommitLineData
11fdf7f2
TL		 1/*-
2 * BSD LICENSE
3 *
4 * Copyright (c) Intel Corporation.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include "spdk_cunit.h"
35#include "spdk/blob.h"
36#include "spdk/thread.h"
37#include "spdk/util.h"
38
9f95a23c 39#include "common/lib/ut_multithread.c"
11fdf7f2
TL		 40
41#include "lvol/lvol.c"
42
43#define DEV_BUFFER_SIZE (64 * 1024 * 1024)
44#define DEV_BUFFER_BLOCKLEN (4096)
45#define DEV_BUFFER_BLOCKCNT (DEV_BUFFER_SIZE / DEV_BUFFER_BLOCKLEN)
46#define BS_CLUSTER_SIZE (1024 * 1024)
47#define BS_FREE_CLUSTERS (DEV_BUFFER_SIZE / BS_CLUSTER_SIZE)
48#define BS_PAGE_SIZE (4096)
49
50#define SPDK_BLOB_OPTS_CLUSTER_SZ (1024 * 1024)
51#define SPDK_BLOB_OPTS_NUM_MD_PAGES UINT32_MAX
52#define SPDK_BLOB_OPTS_MAX_MD_OPS 32
53#define SPDK_BLOB_OPTS_MAX_CHANNEL_OPS 512
54
55#define SPDK_BLOB_THIN_PROV (1ULL << 0)
56
57const char *uuid = "828d9766-ae50-11e7-bd8d-001e67edf350";
58
59struct spdk_blob {
60 spdk_blob_id id;
61 uint32_t ref;
62 struct spdk_blob_store *bs;
63 int close_status;
64 int open_status;
65 int load_status;
66 TAILQ_ENTRY(spdk_blob) link;
67 char uuid[SPDK_UUID_STRING_LEN];
68 char name[SPDK_LVS_NAME_MAX];
69 bool thin_provisioned;
70};
71
72int g_lvolerrno;
73int g_lvserrno;
74int g_close_super_status;
75int g_resize_rc;
76int g_inflate_rc;
9f95a23c 77int g_remove_rc;
11fdf7f2
TL		 78bool g_lvs_rename_blob_open_error = false;
79struct spdk_lvol_store *g_lvol_store;
80struct spdk_lvol *g_lvol;
81spdk_blob_id g_blobid = 1;
82struct spdk_io_channel *g_io_channel;
83
84struct spdk_blob_store {
85 struct spdk_bs_opts bs_opts;
86 spdk_blob_id super_blobid;
87 TAILQ_HEAD(, spdk_blob) blobs;
88 int get_super_status;
89};
90
91struct lvol_ut_bs_dev {
92 struct spdk_bs_dev bs_dev;
93 int init_status;
94 int load_status;
95 struct spdk_blob_store *bs;
96};
97
98void 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)
100{
101 cb_fn(cb_arg, g_inflate_rc);
102}
103
104void 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)
106{
107 cb_fn(cb_arg, g_inflate_rc);
108}
109
110void
111spdk_bs_iter_next(struct spdk_blob_store *bs, struct spdk_blob *b,
112 spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
113{
114 struct spdk_blob *next;
115 int _errno = 0;
116
117 next = TAILQ_NEXT(b, link);
118 if (next == NULL) {
119 _errno = -ENOENT;
120 } else if (next->load_status != 0) {
121 _errno = next->load_status;
122 }
123
124 cb_fn(cb_arg, next, _errno);
125}
126
127void
128spdk_bs_iter_first(struct spdk_blob_store *bs,
129 spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
130{
131 struct spdk_blob *first;
132 int _errno = 0;
133
134 first = TAILQ_FIRST(&bs->blobs);
135 if (first == NULL) {
136 _errno = -ENOENT;
137 } else if (first->load_status != 0) {
138 _errno = first->load_status;
139 }
140
141 cb_fn(cb_arg, first, _errno);
142}
143
144uint64_t spdk_blob_get_num_clusters(struct spdk_blob *blob)
145{
146 return 0;
147}
148
149void
150spdk_bs_get_super(struct spdk_blob_store *bs,
151 spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
152{
153 if (bs->get_super_status != 0) {
154 cb_fn(cb_arg, 0, bs->get_super_status);
155 } else {
156 cb_fn(cb_arg, bs->super_blobid, 0);
157 }
158}
159
160void
161spdk_bs_set_super(struct spdk_blob_store *bs, spdk_blob_id blobid,
162 spdk_bs_op_complete cb_fn, void *cb_arg)
163{
164 bs->super_blobid = blobid;
165 cb_fn(cb_arg, 0);
166}
167
168void
169spdk_bs_load(struct spdk_bs_dev *dev, struct spdk_bs_opts *opts,
170 spdk_bs_op_with_handle_complete cb_fn, void *cb_arg)
171{
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;
174
175 if (ut_dev->load_status == 0) {
176 bs = ut_dev->bs;
177 }
178
179 cb_fn(cb_arg, bs, ut_dev->load_status);
180}
181
182struct spdk_io_channel *spdk_bs_alloc_io_channel(struct spdk_blob_store *bs)
183{
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);
187 }
188 g_io_channel->ref++;
189 return g_io_channel;
190}
191
192void spdk_bs_free_io_channel(struct spdk_io_channel *channel)
193{
194 g_io_channel->ref--;
195 if (g_io_channel->ref == 0) {
196 free(g_io_channel);
197 g_io_channel = NULL;
198 }
199 return;
200}
201
202int
203spdk_blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value,
204 uint16_t value_len)
205{
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);
212 }
213
214 return 0;
215}
216
217int
218spdk_blob_get_xattr_value(struct spdk_blob *blob, const char *name,
219 const void **value, size_t *value_len)
220{
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));
223 *value = blob->uuid;
224 *value_len = SPDK_UUID_STRING_LEN;
225 return 0;
226 } else if (!strcmp(name, "name") && strnlen(blob->name, SPDK_LVS_NAME_MAX) != 0) {
227 *value = blob->name;
228 *value_len = strnlen(blob->name, SPDK_LVS_NAME_MAX) + 1;
229 return 0;
230 }
231
232 return -ENOENT;
233}
234
235int
236spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_id *ids,
237 size_t *count)
238{
239 return 0;
240}
241
242uint64_t
243spdk_bs_get_page_size(struct spdk_blob_store *bs)
244{
245 return BS_PAGE_SIZE;
246}
247
248int
249spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size)
250{
251 bdev->blockcnt = size;
252 return 0;
253}
254
255static void
256init_dev(struct lvol_ut_bs_dev *dev)
257{
258 memset(dev, 0, sizeof(*dev));
259 dev->bs_dev.blockcnt = DEV_BUFFER_BLOCKCNT;
260 dev->bs_dev.blocklen = DEV_BUFFER_BLOCKLEN;
261}
262
263static void
264free_dev(struct lvol_ut_bs_dev *dev)
265{
266 struct spdk_blob_store *bs = dev->bs;
267 struct spdk_blob *blob, *tmp;
268
269 if (bs == NULL) {
270 return;
271 }
272
273 TAILQ_FOREACH_SAFE(blob, &bs->blobs, link, tmp) {
274 TAILQ_REMOVE(&bs->blobs, blob, link);
275 free(blob);
276 }
277
278 free(bs);
279 dev->bs = NULL;
280}
281
282void
283spdk_bs_init(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
284 spdk_bs_op_with_handle_complete cb_fn, void *cb_arg)
285{
286 struct lvol_ut_bs_dev *ut_dev = SPDK_CONTAINEROF(dev, struct lvol_ut_bs_dev, bs_dev);
287 struct spdk_blob_store *bs;
288
289 bs = calloc(1, sizeof(*bs));
290 SPDK_CU_ASSERT_FATAL(bs != NULL);
291
292 TAILQ_INIT(&bs->blobs);
293
294 ut_dev->bs = bs;
295
296 memcpy(&bs->bs_opts, o, sizeof(struct spdk_bs_opts));
297
298 cb_fn(cb_arg, bs, 0);
299}
300
301void
302spdk_bs_unload(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, void *cb_arg)
303{
304 cb_fn(cb_arg, 0);
305}
306
307void
308spdk_bs_destroy(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn,
309 void *cb_arg)
310{
311 free(bs);
312
313 cb_fn(cb_arg, 0);
314}
315
316void
317spdk_bs_delete_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
318 spdk_blob_op_complete cb_fn, void *cb_arg)
319{
320 struct spdk_blob *blob;
321
322 TAILQ_FOREACH(blob, &bs->blobs, link) {
323 if (blob->id == blobid) {
324 TAILQ_REMOVE(&bs->blobs, blob, link);
325 free(blob);
326 break;
327 }
328 }
329
9f95a23c 330 cb_fn(cb_arg, g_remove_rc);
11fdf7f2
TL		 331}
332
333spdk_blob_id
334spdk_blob_get_id(struct spdk_blob *blob)
335{
336 return blob->id;
337}
338
339void
340spdk_bs_opts_init(struct spdk_bs_opts *opts)
341{
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));
347}
348
349uint64_t
350spdk_bs_get_cluster_size(struct spdk_blob_store *bs)
351{
352 return BS_CLUSTER_SIZE;
353}
354
355void spdk_blob_close(struct spdk_blob *b, spdk_blob_op_complete cb_fn, void *cb_arg)
356{
357 b->ref--;
358
359 cb_fn(cb_arg, b->close_status);
360}
361
362void
363spdk_blob_resize(struct spdk_blob *blob, uint64_t sz, spdk_blob_op_complete cb_fn, void *cb_arg)
364{
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);
369 }
370 cb_fn(cb_arg, 0);
371}
372
9f95a23c
TL		 373int
374spdk_blob_set_read_only(struct spdk_blob *blob)
375{
376 return 0;
377}
378
11fdf7f2
TL		 379void
380spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
381{
382 cb_fn(cb_arg, 0);
383}
384
9f95a23c
TL		 385void
386spdk_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)
388{
389 spdk_bs_open_blob(bs, blobid, cb_fn, cb_arg);
390}
391
11fdf7f2
TL		 392void
393spdk_bs_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
394 spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
395{
396 struct spdk_blob *blob;
397
398 if (!g_lvs_rename_blob_open_error) {
399 TAILQ_FOREACH(blob, &bs->blobs, link) {
400 if (blob->id == blobid) {
401 blob->ref++;
402 cb_fn(cb_arg, blob, blob->open_status);
403 return;
404 }
405 }
406 }
407
408 cb_fn(cb_arg, NULL, -ENOENT);
409}
410
411uint64_t
412spdk_bs_free_cluster_count(struct spdk_blob_store *bs)
413{
414 return BS_FREE_CLUSTERS;
415}
416
417void
418spdk_blob_opts_init(struct spdk_blob_opts *opts)
419{
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;
426}
427
9f95a23c
TL		 428void
429spdk_blob_open_opts_init(struct spdk_blob_open_opts *opts)
430{
431 opts->clear_method = BLOB_CLEAR_WITH_DEFAULT;
432}
433
11fdf7f2
TL		 434void
435spdk_bs_create_blob(struct spdk_blob_store *bs,
436 spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
437{
438 spdk_bs_create_blob_ext(bs, NULL, cb_fn, cb_arg);
439}
440
441void
442spdk_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)
444{
445 struct spdk_blob *b;
446
447 if (opts && opts->num_clusters > DEV_BUFFER_SIZE / BS_CLUSTER_SIZE) {
448 cb_fn(cb_arg, 0, -1);
449 return;
450 }
451
452 b = calloc(1, sizeof(*b));
453 SPDK_CU_ASSERT_FATAL(b != NULL);
454
455 b->id = g_blobid++;
456 if (opts != NULL && opts->thin_provision) {
457 b->thin_provisioned = true;
458 }
459 b->bs = bs;
460
461 TAILQ_INSERT_TAIL(&bs->blobs, b, link);
462 cb_fn(cb_arg, b->id, 0);
463}
464
465void
466spdk_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)
469{
470 spdk_bs_create_blob_ext(bs, NULL, cb_fn, cb_arg);
471}
472
473void
474spdk_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)
477{
478 spdk_bs_create_blob_ext(bs, NULL, cb_fn, cb_arg);
479}
480
11fdf7f2
TL		 481static void
482lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvol_store, int lvserrno)
483{
484 g_lvol_store = lvol_store;
485 g_lvserrno = lvserrno;
486}
487
488static void
489lvol_op_complete(void *cb_arg, int lvolerrno)
490{
491 g_lvolerrno = lvolerrno;
492}
493
494static void
495lvol_op_with_handle_complete(void *cb_arg, struct spdk_lvol *lvol, int lvserrno)
496{
497 g_lvol = lvol;
498 g_lvserrno = lvserrno;
499}
500
501static void
502lvol_store_op_complete(void *cb_arg, int lvserrno)
503{
504 g_lvserrno = lvserrno;
505}
506
507static void
508close_cb(void *cb_arg, int lvolerrno)
509{
510 g_lvserrno = lvolerrno;
511}
512
513static void
514destroy_cb(void *cb_arg, int lvolerrno)
515{
516 g_lvserrno = lvolerrno;
517}
518
519static void
520lvs_init_unload_success(void)
521{
522 struct lvol_ut_bs_dev dev;
523 struct spdk_lvs_opts opts;
524 int rc = 0;
525
526 init_dev(&dev);
527
11fdf7f2
TL		 528 spdk_lvs_opts_init(&opts);
529 snprintf(opts.name, sizeof(opts.name), "lvs");
530
531 g_lvserrno = -1;
532
533 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
534 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
535 CU_ASSERT(rc == 0);
536 CU_ASSERT(g_lvserrno == 0);
537 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
538 CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores));
539
9f95a23c
TL		 540 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
541 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 542 CU_ASSERT(g_lvserrno == 0);
543 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
544
545 /* Lvol store has an open lvol, this unload should fail. */
546 g_lvserrno = -1;
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));
552
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);
556
557 g_lvserrno = -1;
558 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
559 CU_ASSERT(rc == 0);
560 CU_ASSERT(g_lvserrno == 0);
561 g_lvol_store = NULL;
562 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
563
564 free_dev(&dev);
11fdf7f2
TL		 565}
566
567static void
568lvs_init_destroy_success(void)
569{
570 struct lvol_ut_bs_dev dev;
571 struct spdk_lvs_opts opts;
572 int rc = 0;
573
574 init_dev(&dev);
575
11fdf7f2
TL		 576 spdk_lvs_opts_init(&opts);
577 snprintf(opts.name, sizeof(opts.name), "lvs");
578
579 g_lvserrno = -1;
580
581 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
582 CU_ASSERT(rc == 0);
583 CU_ASSERT(g_lvserrno == 0);
584 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
585
9f95a23c
TL		 586 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
587 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 588 CU_ASSERT(g_lvserrno == 0);
589 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
590
591 /* Lvol store contains one lvol, this destroy should fail. */
592 g_lvserrno = -1;
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);
597
598 spdk_lvol_close(g_lvol, close_cb, NULL);
599 CU_ASSERT(g_lvserrno == 0);
600
601 spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
602
603 g_lvserrno = -1;
604 rc = spdk_lvs_destroy(g_lvol_store, lvol_store_op_complete, NULL);
605 CU_ASSERT(rc == 0);
606 CU_ASSERT(g_lvserrno == 0);
607 g_lvol_store = NULL;
11fdf7f2
TL		 608}
609
610static void
611lvs_init_opts_success(void)
612{
613 struct lvol_ut_bs_dev dev;
614 struct spdk_lvs_opts opts;
615 int rc = 0;
616
617 init_dev(&dev);
618
11fdf7f2
TL		 619 g_lvserrno = -1;
620
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);
625 CU_ASSERT(rc == 0);
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);
629
630 g_lvserrno = -1;
631 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
632 CU_ASSERT(rc == 0);
633 CU_ASSERT(g_lvserrno == 0);
634 g_lvol_store = NULL;
635
636 free_dev(&dev);
11fdf7f2
TL		 637}
638
639static void
640lvs_unload_lvs_is_null_fail(void)
641{
642 int rc = 0;
643
11fdf7f2
TL		 644 g_lvserrno = -1;
645 rc = spdk_lvs_unload(NULL, lvol_store_op_complete, NULL);
646 CU_ASSERT(rc == -ENODEV);
647 CU_ASSERT(g_lvserrno == -1);
11fdf7f2
TL		 648}
649
650static void
651lvs_names(void)
652{
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;
656 int rc = 0;
657
658 init_dev(&dev_x);
659 init_dev(&dev_y);
660 init_dev(&dev_x2);
661
11fdf7f2
TL		 662 spdk_lvs_opts_init(&opts_none);
663 spdk_lvs_opts_init(&opts_x);
664 opts_x.name[0] = 'x';
665 spdk_lvs_opts_init(&opts_y);
666 opts_y.name[0] = 'y';
667 spdk_lvs_opts_init(&opts_full);
668 memset(opts_full.name, 'a', sizeof(opts_full.name));
669
670 /* Test that opts with no name fails spdk_lvs_init(). */
671 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
672 rc = spdk_lvs_init(&dev_x.bs_dev, &opts_none, lvol_store_op_with_handle_complete, NULL);
673 CU_ASSERT(rc != 0);
674 CU_ASSERT(g_lvol_store == NULL);
675 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
676
677 /* Test that opts with no null terminator for name fails spdk_lvs_init(). */
678 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
679 rc = spdk_lvs_init(&dev_x.bs_dev, &opts_full, lvol_store_op_with_handle_complete, NULL);
680 CU_ASSERT(rc != 0);
681 CU_ASSERT(g_lvol_store == NULL);
682 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
683
684 /* Test that we can create an lvolstore with name 'x'. */
685 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
686 g_lvol_store = NULL;
687 rc = spdk_lvs_init(&dev_x.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
688 CU_ASSERT(rc == 0);
689 CU_ASSERT(!TAILQ_EMPTY(&g_lvol_stores));
690 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
691 lvs_x = g_lvol_store;
692
693 /* Test that we can create an lvolstore with name 'y'. */
694 g_lvol_store = NULL;
695 rc = spdk_lvs_init(&dev_y.bs_dev, &opts_y, lvol_store_op_with_handle_complete, NULL);
696 CU_ASSERT(rc == 0);
697 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
698 lvs_y = g_lvol_store;
699
700 /* Test that we cannot create another lvolstore with name 'x'. */
701 rc = spdk_lvs_init(&dev_x2.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
702 CU_ASSERT(rc == -EEXIST);
703
704 /* Now destroy lvolstore 'x' and then confirm we can create a new lvolstore with name 'x'. */
705 g_lvserrno = -1;
706 rc = spdk_lvs_destroy(lvs_x, lvol_store_op_complete, NULL);
707 CU_ASSERT(rc == 0);
708 CU_ASSERT(g_lvserrno == 0);
709 g_lvol_store = NULL;
710 rc = spdk_lvs_init(&dev_x.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
711 CU_ASSERT(rc == 0);
712 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
713 lvs_x = g_lvol_store;
714
715 /*
716 * Unload lvolstore 'x'. Then we should be able to create another lvolstore with name 'x'.
717 */
718 g_lvserrno = -1;
719 rc = spdk_lvs_unload(lvs_x, lvol_store_op_complete, NULL);
720 CU_ASSERT(rc == 0);
721 CU_ASSERT(g_lvserrno == 0);
722 g_lvol_store = NULL;
723 rc = spdk_lvs_init(&dev_x2.bs_dev, &opts_x, lvol_store_op_with_handle_complete, NULL);
724 CU_ASSERT(rc == 0);
725 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
726 lvs_x2 = g_lvol_store;
727
728 /* Confirm that we cannot load the first lvolstore 'x'. */
729 g_lvserrno = 0;
730 spdk_lvs_load(&dev_x.bs_dev, lvol_store_op_with_handle_complete, NULL);
731 CU_ASSERT(g_lvserrno != 0);
732
733 /* Destroy the second lvolstore 'x'. Then we should be able to load the first lvolstore 'x'. */
734 g_lvserrno = -1;
735 rc = spdk_lvs_destroy(lvs_x2, lvol_store_op_complete, NULL);
736 CU_ASSERT(rc == 0);
737 CU_ASSERT(g_lvserrno == 0);
738 g_lvserrno = -1;
739 spdk_lvs_load(&dev_x.bs_dev, lvol_store_op_with_handle_complete, NULL);
740 CU_ASSERT(g_lvserrno == 0);
741 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
742 lvs_x = g_lvol_store;
743
744 g_lvserrno = -1;
745 rc = spdk_lvs_destroy(lvs_x, lvol_store_op_complete, NULL);
746 CU_ASSERT(rc == 0);
747 CU_ASSERT(g_lvserrno == 0);
748
749 g_lvserrno = -1;
750 rc = spdk_lvs_destroy(lvs_y, lvol_store_op_complete, NULL);
751 CU_ASSERT(rc == 0);
752 CU_ASSERT(g_lvserrno == 0);
11fdf7f2
TL		 753}
754
755static void
756lvol_create_destroy_success(void)
757{
758 struct lvol_ut_bs_dev dev;
759 struct spdk_lvs_opts opts;
760 int rc = 0;
761
762 init_dev(&dev);
763
11fdf7f2
TL		 764 spdk_lvs_opts_init(&opts);
765 snprintf(opts.name, sizeof(opts.name), "lvs");
766
767 g_lvserrno = -1;
768 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
769 CU_ASSERT(rc == 0);
770 CU_ASSERT(g_lvserrno == 0);
771 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
772
9f95a23c
TL		 773 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
774 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 775 CU_ASSERT(g_lvserrno == 0);
776 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
777
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);
782
783 g_lvserrno = -1;
784 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
785 CU_ASSERT(rc == 0);
786 CU_ASSERT(g_lvserrno == 0);
787 g_lvol_store = NULL;
788
789 free_dev(&dev);
11fdf7f2
TL		 790}
791
792static void
793lvol_create_fail(void)
794{
795 struct lvol_ut_bs_dev dev;
796 struct spdk_lvs_opts opts;
797 int rc = 0;
798
799 init_dev(&dev);
800
11fdf7f2
TL		 801 spdk_lvs_opts_init(&opts);
802 snprintf(opts.name, sizeof(opts.name), "lvs");
803
804 g_lvol_store = NULL;
805 g_lvserrno = 0;
806 rc = spdk_lvs_init(NULL, &opts, lvol_store_op_with_handle_complete, NULL);
807 CU_ASSERT(rc != 0);
808 CU_ASSERT(g_lvol_store == NULL);
809
810 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
811 CU_ASSERT(rc == 0);
812 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
813
814 g_lvol = NULL;
9f95a23c
TL		 815 rc = spdk_lvol_create(NULL, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
816 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 817 CU_ASSERT(rc != 0);
818 CU_ASSERT(g_lvol == NULL);
819
820 g_lvol = NULL;
9f95a23c 821 rc = spdk_lvol_create(g_lvol_store, "lvol", DEV_BUFFER_SIZE + 1, false, LVOL_CLEAR_WITH_DEFAULT,
11fdf7f2
TL		 822 lvol_op_with_handle_complete, NULL);
823 CU_ASSERT(rc == 0);
824 CU_ASSERT(g_lvserrno != 0);
825 CU_ASSERT(g_lvol == NULL);
826
827 g_lvserrno = -1;
828 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
829 CU_ASSERT(rc == 0);
830 CU_ASSERT(g_lvserrno == 0);
831 g_lvol_store = NULL;
832
833 free_dev(&dev);
11fdf7f2
TL		 834}
835
836static void
837lvol_destroy_fail(void)
838{
839 struct lvol_ut_bs_dev dev;
840 struct spdk_lvs_opts opts;
841 int rc = 0;
842
843 init_dev(&dev);
844
11fdf7f2
TL		 845 spdk_lvs_opts_init(&opts);
846 snprintf(opts.name, sizeof(opts.name), "lvs");
847
848 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
849 CU_ASSERT(rc == 0);
850 CU_ASSERT(g_lvserrno == 0);
851 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
852
9f95a23c
TL		 853 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
854 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 855 CU_ASSERT(g_lvserrno == 0);
856 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
857
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);
862
9f95a23c
TL		 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);
867
868 spdk_lvol_close(g_lvol, close_cb, NULL);
869 CU_ASSERT(g_lvserrno == 0);
870
871 g_remove_rc = -1;
872 spdk_lvol_destroy(g_lvol, destroy_cb, NULL);
873 CU_ASSERT(g_lvserrno != 0);
874 CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols));
875 g_remove_rc = 0;
876
11fdf7f2
TL		 877 g_lvserrno = -1;
878 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
879 CU_ASSERT(rc == 0);
880 CU_ASSERT(g_lvserrno == 0);
881 g_lvol_store = NULL;
882
883 free_dev(&dev);
11fdf7f2
TL		 884}
885
886static void
887lvol_close_fail(void)
888{
889 struct lvol_ut_bs_dev dev;
890 struct spdk_lvs_opts opts;
891 int rc = 0;
892
893 init_dev(&dev);
894
11fdf7f2
TL		 895 spdk_lvs_opts_init(&opts);
896 snprintf(opts.name, sizeof(opts.name), "lvs");
897
898 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
899 CU_ASSERT(rc == 0);
900 CU_ASSERT(g_lvserrno == 0);
901 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
902
9f95a23c
TL		 903 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
904 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 905 CU_ASSERT(g_lvserrno == 0);
906 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
907
908 spdk_lvol_close(g_lvol, close_cb, NULL);
909 CU_ASSERT(g_lvserrno == 0);
910
911 g_lvserrno = -1;
912 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
913 CU_ASSERT(rc == 0);
914 CU_ASSERT(g_lvserrno == 0);
915 g_lvol_store = NULL;
916
917 free_dev(&dev);
11fdf7f2
TL		 918}
919
920static void
921lvol_close_success(void)
922{
923 struct lvol_ut_bs_dev dev;
924 struct spdk_lvs_opts opts;
925 int rc = 0;
926
927 init_dev(&dev);
928
11fdf7f2
TL		 929 spdk_lvs_opts_init(&opts);
930 snprintf(opts.name, sizeof(opts.name), "lvs");
931
932 g_lvserrno = -1;
933 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
934 CU_ASSERT(rc == 0);
935 CU_ASSERT(g_lvserrno == 0);
936 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
937
9f95a23c
TL		 938 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
939 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 940 CU_ASSERT(g_lvserrno == 0);
941 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
942
943 spdk_lvol_close(g_lvol, close_cb, NULL);
944 CU_ASSERT(g_lvserrno == 0);
945
946 g_lvserrno = -1;
947 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
948 CU_ASSERT(rc == 0);
949 CU_ASSERT(g_lvserrno == 0);
950 g_lvol_store = NULL;
951
952 free_dev(&dev);
11fdf7f2
TL		 953}
954
955static void
956lvol_resize(void)
957{
958 struct lvol_ut_bs_dev dev;
959 struct spdk_lvs_opts opts;
960 int rc = 0;
961
962 init_dev(&dev);
963
11fdf7f2
TL		 964 spdk_lvs_opts_init(&opts);
965 snprintf(opts.name, sizeof(opts.name), "lvs");
966
967 g_resize_rc = 0;
968 g_lvserrno = -1;
969 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
970 CU_ASSERT(rc == 0);
971 CU_ASSERT(g_lvserrno == 0);
972 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
973
9f95a23c
TL		 974 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
975 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 976 CU_ASSERT(g_lvserrno == 0);
977 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
978
979 /* Resize to same size */
980 spdk_lvol_resize(g_lvol, 10, lvol_store_op_complete, NULL);
981 CU_ASSERT(g_lvserrno == 0);
982
983 /* Resize to smaller size */
984 spdk_lvol_resize(g_lvol, 5, lvol_store_op_complete, NULL);
985 CU_ASSERT(g_lvserrno == 0);
986
987 /* Resize to bigger size */
988 spdk_lvol_resize(g_lvol, 15, lvol_store_op_complete, NULL);
989 CU_ASSERT(g_lvserrno == 0);
990
991 /* Resize to size = 0 */
992 spdk_lvol_resize(g_lvol, 0, lvol_store_op_complete, NULL);
993 CU_ASSERT(g_lvserrno == 0);
994
995 /* Resize to bigger size than available */
996 g_lvserrno = 0;
997 spdk_lvol_resize(g_lvol, 0xFFFFFFFF, lvol_store_op_complete, NULL);
998 CU_ASSERT(g_lvserrno != 0);
999
1000 /* Fail resize */
1001 g_resize_rc = -1;
1002 g_lvserrno = 0;
1003 spdk_lvol_resize(g_lvol, 10, lvol_store_op_complete, NULL);
1004 CU_ASSERT(g_lvserrno != 0);
1005 g_resize_rc = 0;
1006
1007 g_resize_rc = 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);
1012
1013 g_lvserrno = -1;
1014 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1015 CU_ASSERT(rc == 0);
1016 CU_ASSERT(g_lvserrno == 0);
1017 g_lvol_store = NULL;
1018
1019 free_dev(&dev);
9f95a23c
TL		 1020}
1021
1022static void
1023lvol_set_read_only(void)
1024{
1025 struct lvol_ut_bs_dev dev;
1026 struct spdk_lvs_opts opts;
1027 int rc = 0;
1028 struct spdk_lvol *lvol, *clone;
1029
1030 init_dev(&dev);
1031
1032 spdk_lvs_opts_init(&opts);
1033 snprintf(opts.name, sizeof(opts.name), "lvs");
1034
1035 g_lvserrno = -1;
1036 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1037 CU_ASSERT(rc == 0);
1038 CU_ASSERT(g_lvserrno == 0);
1039 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1040
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);
1045 lvol = g_lvol;
1046
1047 /* Set lvol as read only */
1048 spdk_lvol_set_read_only(lvol, lvol_op_complete, NULL);
1049 CU_ASSERT(g_lvolerrno == 0);
1050
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");
1056 clone = g_lvol;
1057
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);
11fdf7f2 1062
9f95a23c
TL		 1063 g_lvserrno = -1;
1064 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1065 CU_ASSERT(rc == 0);
1066 CU_ASSERT(g_lvserrno == 0);
1067 g_lvol_store = NULL;
1068
1069 free_dev(&dev);
11fdf7f2
TL		 1070}
1071
1072static void
1073null_cb(void *ctx, struct spdk_blob_store *bs, int bserrno)
1074{
1075 SPDK_CU_ASSERT_FATAL(bs != NULL);
1076}
1077
1078static void
1079lvs_load(void)
1080{
1081 int rc = -1;
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;
1086
1087 req = calloc(1, sizeof(*req));
1088 SPDK_CU_ASSERT_FATAL(req != NULL);
1089
1090 init_dev(&dev);
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);
1094
11fdf7f2
TL		 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));
1102
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));
1110
1111 /* Fail on opening super blob */
1112 g_lvserrno = 0;
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));
1123
1124 /* Fail on getting uuid */
1125 g_lvserrno = 0;
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));
1131
1132 /* Fail on getting name */
1133 g_lvserrno = 0;
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));
1139
1140 /* Fail on closing super blob */
1141 g_lvserrno = 0;
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));
1148
1149 /* Load successfully */
1150 g_lvserrno = 0;
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));
1156
1157 g_lvserrno = -1;
1158 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1159 CU_ASSERT(rc == 0);
1160 CU_ASSERT(g_lvserrno == 0);
1161 CU_ASSERT(TAILQ_EMPTY(&g_lvol_stores));
1162
1163 free(req);
1164 free_dev(&dev);
11fdf7f2
TL		 1165}
1166
1167static void
1168lvols_load(void)
1169{
1170 int rc = -1;
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;
1175
1176 req = calloc(1, sizeof(*req));
1177 SPDK_CU_ASSERT_FATAL(req != NULL);
1178
1179 init_dev(&dev);
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;
1190
1191 /*
1192 * Create 3 blobs, write different char values to the last char in the UUID
1193 * to make sure they are unique.
1194 */
1195 blob1 = calloc(1, sizeof(*blob1));
1196 SPDK_CU_ASSERT_FATAL(blob1 != NULL);
1197 blob1->id = 0x1;
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';
1201
1202 blob2 = calloc(1, sizeof(*blob2));
1203 SPDK_CU_ASSERT_FATAL(blob2 != NULL);
1204 blob2->id = 0x2;
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';
1208
1209 blob3 = calloc(1, sizeof(*blob3));
1210 SPDK_CU_ASSERT_FATAL(blob3 != NULL);
1211 blob3->id = 0x2;
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';
1215
11fdf7f2
TL		 1216 /* Load lvs with 0 blobs */
1217 g_lvserrno = 0;
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);
1222
1223 g_lvserrno = -1;
1224 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1225 CU_ASSERT(rc == 0);
1226 CU_ASSERT(g_lvserrno == 0);
1227
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);
1231
1232 /* Load lvs again with 3 blobs, but fail on 1st one */
1233 g_lvol_store = NULL;
1234 g_lvserrno = 0;
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);
1239
1240 /* Load lvs again with 3 blobs, but fail on 3rd one */
1241 g_lvol_store = NULL;
1242 g_lvserrno = 0;
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);
1249
1250 /* Load lvs again with 3 blobs, with success */
1251 g_lvol_store = NULL;
1252 g_lvserrno = 0;
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));
1260
1261 g_lvserrno = -1;
1262 /* rc = */ spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1263 /*
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.
1266 */
1267 /* CU_ASSERT(rc == 0); */
1268 /* CU_ASSERT(g_lvserrno == 0); */
1269
1270 free(req);
1271 free_dev(&dev);
11fdf7f2
TL		 1272}
1273
1274static void
1275lvol_open(void)
1276{
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;
1282
1283 req = calloc(1, sizeof(*req));
1284 SPDK_CU_ASSERT_FATAL(req != NULL);
1285
1286 init_dev(&dev);
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;
1297
1298 /*
1299 * Create 3 blobs, write different char values to the last char in the UUID
1300 * to make sure they are unique.
1301 */
1302 blob1 = calloc(1, sizeof(*blob1));
1303 SPDK_CU_ASSERT_FATAL(blob1 != NULL);
1304 blob1->id = 0x1;
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';
1308
1309 blob2 = calloc(1, sizeof(*blob2));
1310 SPDK_CU_ASSERT_FATAL(blob2 != NULL);
1311 blob2->id = 0x2;
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';
1315
1316 blob3 = calloc(1, sizeof(*blob3));
1317 SPDK_CU_ASSERT_FATAL(blob3 != NULL);
1318 blob3->id = 0x2;
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';
1322
11fdf7f2
TL		 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);
1326
1327 /* Load lvs with 3 blobs */
1328 g_lvol_store = NULL;
1329 g_lvserrno = 0;
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));
1334
1335 blob1->open_status = -1;
1336 blob2->open_status = -1;
1337 blob3->open_status = -1;
1338
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);
1343 }
1344
1345 blob1->open_status = 0;
1346 blob2->open_status = 0;
1347 blob3->open_status = 0;
1348
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);
1353 }
1354
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);
1359 }
1360
1361 g_lvserrno = -1;
1362 spdk_lvs_destroy(g_lvol_store, lvol_store_op_complete, NULL);
1363
1364 free(req);
1365 free(blob1);
1366 free(blob2);
1367 free(blob3);
11fdf7f2
TL		 1368}
1369
1370static void
1371lvol_snapshot(void)
1372{
1373 struct lvol_ut_bs_dev dev;
1374 struct spdk_lvol *lvol;
1375 struct spdk_lvs_opts opts;
1376 int rc = 0;
1377
1378 init_dev(&dev);
1379
11fdf7f2
TL		 1380 spdk_lvs_opts_init(&opts);
1381 snprintf(opts.name, sizeof(opts.name), "lvs");
1382
1383 g_lvserrno = -1;
1384 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1385 CU_ASSERT(rc == 0);
1386 CU_ASSERT(g_lvserrno == 0);
1387 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1388
9f95a23c
TL		 1389 spdk_lvol_create(g_lvol_store, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT,
1390 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1391 CU_ASSERT(g_lvserrno == 0);
1392 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1393
1394 lvol = g_lvol;
1395
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");
1400
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);
1404 g_lvserrno = -1;
1405
1406 spdk_lvol_close(lvol, close_cb, NULL);
1407 CU_ASSERT(g_lvserrno == 0);
1408 g_lvserrno = -1;
1409
1410 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1411 CU_ASSERT(rc == 0);
1412 CU_ASSERT(g_lvserrno == 0);
1413 g_lvol_store = NULL;
1414
1415 free_dev(&dev);
11fdf7f2
TL		 1416}
1417
1418static void
1419lvol_snapshot_fail(void)
1420{
1421 struct lvol_ut_bs_dev dev;
1422 struct spdk_lvol *lvol, *snap;
1423 struct spdk_lvs_opts opts;
1424 int rc = 0;
1425
1426 init_dev(&dev);
1427
11fdf7f2
TL		 1428 spdk_lvs_opts_init(&opts);
1429 snprintf(opts.name, sizeof(opts.name), "lvs");
1430
1431 g_lvserrno = -1;
1432 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1433 CU_ASSERT(rc == 0);
1434 CU_ASSERT(g_lvserrno == 0);
1435 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1436
9f95a23c
TL		 1437 spdk_lvol_create(g_lvol_store, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT,
1438 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1439 CU_ASSERT(g_lvserrno == 0);
1440 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1441
1442 lvol = g_lvol;
1443
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);
1447
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);
1451
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);
1455
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");
1460
1461 snap = g_lvol;
1462
1463 spdk_lvol_create_snapshot(lvol, "snap", lvol_op_with_handle_complete, NULL);
1464 CU_ASSERT(g_lvserrno < 0);
1465
1466 spdk_lvol_close(lvol, close_cb, NULL);
1467 CU_ASSERT(g_lvserrno == 0);
1468 g_lvserrno = -1;
1469
1470 spdk_lvol_close(snap, close_cb, NULL);
1471 CU_ASSERT(g_lvserrno == 0);
1472 g_lvserrno = -1;
1473
1474 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1475 CU_ASSERT(rc == 0);
1476 CU_ASSERT(g_lvserrno == 0);
1477 g_lvol_store = NULL;
1478
1479 free_dev(&dev);
11fdf7f2
TL		 1480}
1481
1482static void
1483lvol_clone(void)
1484{
1485 struct lvol_ut_bs_dev dev;
1486 struct spdk_lvol *lvol;
1487 struct spdk_lvol *snap;
1488 struct spdk_lvs_opts opts;
1489 int rc = 0;
1490
1491 init_dev(&dev);
1492
11fdf7f2
TL		 1493 spdk_lvs_opts_init(&opts);
1494 snprintf(opts.name, sizeof(opts.name), "lvs");
1495
1496 g_lvserrno = -1;
1497 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1498 CU_ASSERT(rc == 0);
1499 CU_ASSERT(g_lvserrno == 0);
1500 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1501
9f95a23c
TL		 1502 spdk_lvol_create(g_lvol_store, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT,
1503 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1504 CU_ASSERT(g_lvserrno == 0);
1505 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1506
1507 lvol = g_lvol;
1508
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");
1513
1514 snap = g_lvol;
1515
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");
1520
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);
1524 g_lvserrno = -1;
1525
1526 spdk_lvol_close(snap, close_cb, NULL);
1527 CU_ASSERT(g_lvserrno == 0);
1528 g_lvserrno = -1;
1529
1530 spdk_lvol_close(lvol, close_cb, NULL);
1531 CU_ASSERT(g_lvserrno == 0);
1532 g_lvserrno = -1;
1533
1534 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1535 CU_ASSERT(rc == 0);
1536 CU_ASSERT(g_lvserrno == 0);
1537 g_lvol_store = NULL;
1538
1539 free_dev(&dev);
11fdf7f2
TL		 1540}
1541
1542static void
1543lvol_clone_fail(void)
1544{
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;
1550 int rc = 0;
1551
1552 init_dev(&dev);
1553
11fdf7f2
TL		 1554 spdk_lvs_opts_init(&opts);
1555 snprintf(opts.name, sizeof(opts.name), "lvs");
1556
1557 g_lvserrno = -1;
1558 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1559 CU_ASSERT(rc == 0);
1560 CU_ASSERT(g_lvserrno == 0);
1561 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1562
9f95a23c
TL		 1563 spdk_lvol_create(g_lvol_store, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT,
1564 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1565 CU_ASSERT(g_lvserrno == 0);
1566 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1567
1568 lvol = g_lvol;
1569
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");
1574
1575 snap = g_lvol;
1576
1577 spdk_lvol_create_clone(NULL, "clone", lvol_op_with_handle_complete, NULL);
1578 CU_ASSERT(g_lvserrno < 0);
1579
1580 spdk_lvol_create_clone(snap, "", lvol_op_with_handle_complete, NULL);
1581 CU_ASSERT(g_lvserrno < 0);
1582
1583 spdk_lvol_create_clone(snap, NULL, lvol_op_with_handle_complete, NULL);
1584 CU_ASSERT(g_lvserrno < 0);
1585
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");
1590
1591 clone = g_lvol;
1592
1593 spdk_lvol_create_clone(snap, "clone", lvol_op_with_handle_complete, NULL);
1594 CU_ASSERT(g_lvserrno < 0);
1595
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);
1599 g_lvserrno = -1;
1600
1601 spdk_lvol_close(snap, close_cb, NULL);
1602 CU_ASSERT(g_lvserrno == 0);
1603 g_lvserrno = -1;
1604
1605 spdk_lvol_close(lvol, close_cb, NULL);
1606 CU_ASSERT(g_lvserrno == 0);
1607 g_lvserrno = -1;
1608
1609 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1610 CU_ASSERT(rc == 0);
1611 CU_ASSERT(g_lvserrno == 0);
1612 g_lvol_store = NULL;
1613
1614 free_dev(&dev);
11fdf7f2
TL		 1615}
1616
1617static void
1618lvol_names(void)
1619{
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];
1625 int rc = 0;
1626
1627 init_dev(&dev);
1628
11fdf7f2
TL		 1629 spdk_lvs_opts_init(&opts);
1630 snprintf(opts.name, sizeof(opts.name), "lvs");
1631
1632 g_lvserrno = -1;
1633 g_lvol_store = NULL;
1634 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1635 CU_ASSERT(rc == 0);
1636 CU_ASSERT(g_lvserrno == 0);
1637 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1638 lvs = g_lvol_store;
1639
9f95a23c
TL		 1640 rc = spdk_lvol_create(lvs, NULL, 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1641 NULL);
11fdf7f2
TL		 1642 CU_ASSERT(rc == -EINVAL);
1643
9f95a23c
TL		 1644 rc = spdk_lvol_create(lvs, "", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1645 NULL);
11fdf7f2
TL		 1646 CU_ASSERT(rc == -EINVAL);
1647
1648 memset(fullname, 'x', sizeof(fullname));
9f95a23c
TL		 1649 rc = spdk_lvol_create(lvs, fullname, 1, false, LVOL_CLEAR_WITH_DEFAULT,
1650 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1651 CU_ASSERT(rc == -EINVAL);
1652
1653 g_lvserrno = -1;
9f95a23c
TL		 1654 rc = spdk_lvol_create(lvs, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1655 NULL);
11fdf7f2
TL		 1656 CU_ASSERT(rc == 0);
1657 CU_ASSERT(g_lvserrno == 0);
1658 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1659 lvol = g_lvol;
1660
9f95a23c
TL		 1661 rc = spdk_lvol_create(lvs, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1662 NULL);
11fdf7f2
TL		 1663 CU_ASSERT(rc == -EEXIST);
1664
1665 g_lvserrno = -1;
9f95a23c
TL		 1666 rc = spdk_lvol_create(lvs, "lvol2", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1667 NULL);
11fdf7f2
TL		 1668 CU_ASSERT(rc == 0);
1669 CU_ASSERT(g_lvserrno == 0);
1670 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1671 lvol2 = g_lvol;
1672
1673 spdk_lvol_close(lvol, close_cb, NULL);
1674 spdk_lvol_destroy(lvol, lvol_op_complete, NULL);
1675
1676 g_lvserrno = -1;
1677 g_lvol = NULL;
9f95a23c
TL		 1678 rc = spdk_lvol_create(lvs, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1679 NULL);
11fdf7f2
TL		 1680 CU_ASSERT(rc == 0);
1681 CU_ASSERT(g_lvserrno == 0);
1682 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1683 lvol = g_lvol;
1684
1685 spdk_lvol_close(lvol, close_cb, NULL);
1686 spdk_lvol_destroy(lvol, destroy_cb, NULL);
1687
1688 spdk_lvol_close(lvol2, close_cb, NULL);
1689 spdk_lvol_destroy(lvol2, destroy_cb, NULL);
1690
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);
9f95a23c
TL		 1696 rc = spdk_lvol_create(lvs, "tmp_name", 1, false, LVOL_CLEAR_WITH_DEFAULT,
1697 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1698 CU_ASSERT(rc == -EEXIST);
1699
1700 /* Remove name from temporary list and try again. */
1701 TAILQ_REMOVE(&lvs->pending_lvols, lvol, link);
1702 free(lvol);
1703
9f95a23c
TL		 1704 rc = spdk_lvol_create(lvs, "tmp_name", 1, false, LVOL_CLEAR_WITH_DEFAULT,
1705 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1706 CU_ASSERT(rc == 0);
1707 CU_ASSERT(g_lvserrno == 0);
1708 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1709 lvol = g_lvol;
1710
1711 spdk_lvol_close(lvol, close_cb, NULL);
1712 spdk_lvol_destroy(lvol, destroy_cb, NULL);
1713
1714 g_lvserrno = -1;
1715 rc = spdk_lvs_destroy(lvs, lvol_store_op_complete, NULL);
1716 CU_ASSERT(rc == 0);
1717 CU_ASSERT(g_lvserrno == 0);
1718 g_lvol_store = NULL;
11fdf7f2
TL		 1719}
1720
1721static void
1722lvol_rename(void)
1723{
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;
1728 int rc = 0;
1729
1730 init_dev(&dev);
1731
11fdf7f2
TL		 1732 spdk_lvs_opts_init(&opts);
1733 snprintf(opts.name, sizeof(opts.name), "lvs");
1734
1735 g_lvserrno = -1;
1736 g_lvol_store = NULL;
1737 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1738 CU_ASSERT(rc == 0);
1739 CU_ASSERT(g_lvserrno == 0);
1740 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1741 lvs = g_lvol_store;
1742
1743 /* Trying to create new lvol */
1744 g_lvserrno = -1;
9f95a23c
TL		 1745 rc = spdk_lvol_create(lvs, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1746 NULL);
11fdf7f2
TL		 1747 CU_ASSERT(rc == 0);
1748 CU_ASSERT(g_lvserrno == 0);
1749 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1750 lvol = g_lvol;
1751
1752 /* Trying to create second lvol with existing lvol name */
1753 g_lvserrno = -1;
1754 g_lvol = NULL;
9f95a23c
TL		 1755 rc = spdk_lvol_create(lvs, "lvol", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1756 NULL);
11fdf7f2
TL		 1757 CU_ASSERT(rc == -EEXIST);
1758 CU_ASSERT(g_lvserrno == -1);
1759 SPDK_CU_ASSERT_FATAL(g_lvol == NULL);
1760
1761 /* Trying to create second lvol with non existing name */
1762 g_lvserrno = -1;
9f95a23c
TL		 1763 rc = spdk_lvol_create(lvs, "lvol2", 1, false, LVOL_CLEAR_WITH_DEFAULT, lvol_op_with_handle_complete,
1764 NULL);
11fdf7f2
TL		 1765 CU_ASSERT(rc == 0);
1766 CU_ASSERT(g_lvserrno == 0);
1767 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1768 lvol2 = g_lvol;
1769
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");
1774
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");
1779
1780 spdk_lvol_close(lvol, close_cb, NULL);
1781 spdk_lvol_destroy(lvol, lvol_op_complete, NULL);
1782
1783 spdk_lvol_close(lvol2, close_cb, NULL);
1784 spdk_lvol_destroy(lvol2, lvol_op_complete, NULL);
1785
1786 g_lvserrno = -1;
1787 rc = spdk_lvs_destroy(lvs, lvol_store_op_complete, NULL);
1788 CU_ASSERT(rc == 0);
1789 CU_ASSERT(g_lvserrno == 0);
1790 g_lvol_store = NULL;
11fdf7f2
TL		 1791}
1792
1793static void
1794lvs_rename(void)
1795{
1796 struct lvol_ut_bs_dev dev;
1797 struct spdk_lvs_opts opts;
1798 struct spdk_lvol_store *lvs, *lvs2;
1799 int rc = 0;
1800
1801 init_dev(&dev);
1802
11fdf7f2
TL		 1803 spdk_lvs_opts_init(&opts);
1804 snprintf(opts.name, sizeof(opts.name), "lvs");
1805 g_lvserrno = -1;
1806 g_lvol_store = NULL;
1807 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1808 CU_ASSERT(rc == 0);
1809 CU_ASSERT(g_lvserrno == 0);
1810 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1811 lvs = g_lvol_store;
1812
1813 spdk_lvs_opts_init(&opts);
1814 snprintf(opts.name, sizeof(opts.name), "unimportant_lvs_name");
1815 g_lvserrno = -1;
1816 g_lvol_store = NULL;
1817 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1818 CU_ASSERT(rc == 0);
1819 CU_ASSERT(g_lvserrno == 0);
1820 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1821 lvs2 = g_lvol_store;
1822
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");
1827
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");
1832
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");
1837
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");
1849
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;
1857
1858 g_lvserrno = -1;
1859 rc = spdk_lvs_destroy(lvs, lvol_store_op_complete, NULL);
1860 CU_ASSERT(rc == 0);
1861 CU_ASSERT(g_lvserrno == 0);
1862 g_lvol_store = NULL;
1863
1864 g_lvserrno = -1;
1865 rc = spdk_lvs_destroy(lvs2, lvol_store_op_complete, NULL);
1866 CU_ASSERT(rc == 0);
1867 CU_ASSERT(g_lvserrno == 0);
1868 g_lvol_store = NULL;
11fdf7f2
TL		 1869}
1870static void lvol_refcnt(void)
1871{
1872 struct lvol_ut_bs_dev dev;
1873 struct spdk_lvs_opts opts;
1874 struct spdk_lvol *lvol;
1875 int rc = 0;
1876
1877 init_dev(&dev);
1878
11fdf7f2
TL		 1879 spdk_lvs_opts_init(&opts);
1880 snprintf(opts.name, sizeof(opts.name), "lvs");
1881
1882 g_lvserrno = -1;
1883 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1884 CU_ASSERT(rc == 0);
1885 CU_ASSERT(g_lvserrno == 0);
1886 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1887
1888
9f95a23c
TL		 1889 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
1890 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1891
1892 CU_ASSERT(g_lvserrno == 0);
1893 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1894 CU_ASSERT(g_lvol->ref_count == 1);
1895
1896 lvol = g_lvol;
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);
1900
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);
1904
1905 spdk_lvol_close(lvol, lvol_op_complete, NULL);
1906 CU_ASSERT(lvol->ref_count == 1);
1907 CU_ASSERT(g_lvolerrno == 0);
1908
1909 spdk_lvol_close(lvol, lvol_op_complete, NULL);
1910 CU_ASSERT(lvol->ref_count == 0);
1911 CU_ASSERT(g_lvolerrno == 0);
1912
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);
1917
1918 g_lvserrno = -1;
1919 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1920 CU_ASSERT(rc == 0);
1921 CU_ASSERT(g_lvserrno == 0);
1922 g_lvol_store = NULL;
1923
1924 CU_ASSERT(rc == 0);
1925 CU_ASSERT(g_lvserrno == 0);
1926 g_lvol_store = NULL;
1927
1928 free_dev(&dev);
11fdf7f2
TL		 1929}
1930
1931static void
1932lvol_create_thin_provisioned(void)
1933{
1934 struct lvol_ut_bs_dev dev;
1935 struct spdk_lvs_opts opts;
1936 int rc = 0;
1937
1938 init_dev(&dev);
1939
11fdf7f2
TL		 1940 spdk_lvs_opts_init(&opts);
1941 snprintf(opts.name, sizeof(opts.name), "lvs");
1942
1943 g_lvserrno = -1;
1944 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1945 CU_ASSERT(rc == 0);
1946 CU_ASSERT(g_lvserrno == 0);
1947 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1948
9f95a23c
TL		 1949 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
1950 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1951 CU_ASSERT(g_lvserrno == 0);
1952 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1953
1954 CU_ASSERT(g_lvol->blob->thin_provisioned == false);
1955
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);
1960
9f95a23c
TL		 1961 spdk_lvol_create(g_lvol_store, "lvol", 10, true, LVOL_CLEAR_WITH_DEFAULT,
1962 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 1963 CU_ASSERT(g_lvserrno == 0);
1964 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1965
1966 CU_ASSERT(g_lvol->blob->thin_provisioned == true);
1967
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);
1972
1973 g_lvserrno = -1;
1974 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
1975 CU_ASSERT(rc == 0);
1976 CU_ASSERT(g_lvserrno == 0);
1977 g_lvol_store = NULL;
1978
1979 free_dev(&dev);
11fdf7f2
TL		 1980}
1981
1982static void
1983lvol_inflate(void)
1984{
1985 struct lvol_ut_bs_dev dev;
1986 struct spdk_lvs_opts opts;
1987 int rc = 0;
1988
1989 init_dev(&dev);
1990
11fdf7f2
TL		 1991 spdk_lvs_opts_init(&opts);
1992 snprintf(opts.name, sizeof(opts.name), "lvs");
1993
1994 g_lvserrno = -1;
1995 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
1996 CU_ASSERT(rc == 0);
1997 CU_ASSERT(g_lvserrno == 0);
1998 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1999
9f95a23c
TL		 2000 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
2001 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 2002 CU_ASSERT(g_lvserrno == 0);
2003 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
2004
2005 g_inflate_rc = -1;
2006 spdk_lvol_inflate(g_lvol, lvol_op_complete, NULL);
2007 CU_ASSERT(g_lvolerrno != 0);
2008
2009 g_inflate_rc = 0;
2010 spdk_lvol_inflate(g_lvol, lvol_op_complete, NULL);
2011 CU_ASSERT(g_lvolerrno == 0);
2012
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);
2017
2018 g_lvserrno = -1;
2019 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
2020 CU_ASSERT(rc == 0);
2021 CU_ASSERT(g_lvserrno == 0);
2022 g_lvol_store = NULL;
2023
2024 free_dev(&dev);
2025
2026 /* Make sure that all references to the io_channel was closed after
2027 * inflate call
2028 */
2029 CU_ASSERT(g_io_channel == NULL);
11fdf7f2
TL		 2030}
2031
2032static void
2033lvol_decouple_parent(void)
2034{
2035 struct lvol_ut_bs_dev dev;
2036 struct spdk_lvs_opts opts;
2037 int rc = 0;
2038
2039 init_dev(&dev);
2040
11fdf7f2
TL		 2041 spdk_lvs_opts_init(&opts);
2042 snprintf(opts.name, sizeof(opts.name), "lvs");
2043
2044 g_lvserrno = -1;
2045 rc = spdk_lvs_init(&dev.bs_dev, &opts, lvol_store_op_with_handle_complete, NULL);
2046 CU_ASSERT(rc == 0);
2047 CU_ASSERT(g_lvserrno == 0);
2048 SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
2049
9f95a23c
TL		 2050 spdk_lvol_create(g_lvol_store, "lvol", 10, false, LVOL_CLEAR_WITH_DEFAULT,
2051 lvol_op_with_handle_complete, NULL);
11fdf7f2
TL		 2052 CU_ASSERT(g_lvserrno == 0);
2053 SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
2054
2055 g_inflate_rc = -1;
2056 spdk_lvol_decouple_parent(g_lvol, lvol_op_complete, NULL);
2057 CU_ASSERT(g_lvolerrno != 0);
2058
2059 g_inflate_rc = 0;
2060 spdk_lvol_decouple_parent(g_lvol, lvol_op_complete, NULL);
2061 CU_ASSERT(g_lvolerrno == 0);
2062
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);
2067
2068 g_lvserrno = -1;
2069 rc = spdk_lvs_unload(g_lvol_store, lvol_store_op_complete, NULL);
2070 CU_ASSERT(rc == 0);
2071 CU_ASSERT(g_lvserrno == 0);
2072 g_lvol_store = NULL;
2073
2074 free_dev(&dev);
2075
2076 /* Make sure that all references to the io_channel was closed after
2077 * inflate call
2078 */
2079 CU_ASSERT(g_io_channel == NULL);
11fdf7f2
TL		 2080}
2081
2082int main(int argc, char **argv)
2083{
2084 CU_pSuite suite = NULL;
2085 unsigned int num_failures;
2086
2087 if (CU_initialize_registry() != CUE_SUCCESS) {
2088 return CU_get_error();
2089 }
2090
2091 suite = CU_add_suite("lvol", NULL, NULL);
2092 if (suite == NULL) {
2093 CU_cleanup_registry();
2094 return CU_get_error();
2095 }
2096
2097 if (
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 ||
9f95a23c 2109 CU_add_test(suite, "lvol_set_read_only", lvol_set_read_only) == NULL ||
11fdf7f2
TL		 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
2127 ) {
2128 CU_cleanup_registry();
2129 return CU_get_error();
2130 }
2131
9f95a23c
TL		 2132 allocate_threads(1);
2133 set_thread(0);
2134
11fdf7f2
TL		 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();
2139
9f95a23c
TL		 2140 free_threads();
2141
11fdf7f2
TL		 2142 return num_failures;
2143}
Ceph