Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk_internal/cunit.h"
8 : : #include "spdk/string.h"
9 : :
10 : : #include "common/lib/ut_multithread.c"
11 : : #include "bdev/lvol/vbdev_lvol.c"
12 : :
13 : : #include "unit/lib/json_mock.c"
14 : :
15 : : #define SPDK_BS_PAGE_SIZE 0x1000
16 : :
17 : : int g_lvolerrno;
18 : : int g_lvserrno;
19 : : int g_cluster_size;
20 : : int g_registered_bdevs;
21 : : int g_num_lvols = 0;
22 : : int g_lvol_open_enomem = -1;
23 : : struct spdk_lvol_store *g_lvs = NULL;
24 : : struct spdk_lvol *g_lvol = NULL;
25 : : struct lvol_store_bdev *g_lvs_bdev = NULL;
26 : : struct spdk_bdev *g_base_bdev = NULL;
27 : : struct spdk_bdev_io *g_io = NULL;
28 : : struct spdk_io_channel *g_ch = NULL;
29 : :
30 : : static struct spdk_bdev g_bdev = {};
31 : : static struct spdk_lvol_store *g_lvol_store = NULL;
32 : : bool lvol_store_initialize_fail = false;
33 : : bool lvol_store_initialize_cb_fail = false;
34 : : bool lvol_already_opened = false;
35 : : bool g_examine_done = false;
36 : : bool g_bdev_alias_already_exists = false;
37 : : bool g_lvs_with_name_already_exists = false;
38 : : bool g_ext_api_called;
39 : : bool g_bdev_is_missing = false;
40 : :
41 : 12 : DEFINE_STUB_V(spdk_bdev_module_fini_start_done, (void));
42 : 0 : DEFINE_STUB_V(spdk_bdev_update_bs_blockcnt, (struct spdk_bs_dev *bs_dev));
43 : 0 : DEFINE_STUB_V(spdk_lvs_grow_live, (struct spdk_lvol_store *lvs,
44 : : spdk_lvs_op_complete cb_fn, void *cb_arg));
45 : 0 : DEFINE_STUB(spdk_bdev_get_memory_domains, int, (struct spdk_bdev *bdev,
46 : : struct spdk_memory_domain **domains, int array_size), 0);
47 : 0 : DEFINE_STUB(spdk_blob_get_esnap_id, int,
48 : : (struct spdk_blob *blob, const void **id, size_t *len), -ENOTSUP);
49 [ # # ]: 0 : DEFINE_STUB(spdk_blob_is_esnap_clone, bool, (const struct spdk_blob *blob), false);
50 : 0 : DEFINE_STUB(spdk_lvol_iter_immediate_clones, int,
51 : : (struct spdk_lvol *lvol, spdk_lvol_iter_cb cb_fn, void *cb_arg), -ENOTSUP);
52 : 12 : DEFINE_STUB(spdk_lvs_esnap_missing_add, int,
53 : : (struct spdk_lvol_store *lvs, struct spdk_lvol *lvol, const void *esnap_id,
54 : : uint32_t id_len), -ENOTSUP);
55 : 0 : DEFINE_STUB(spdk_blob_get_esnap_bs_dev, struct spdk_bs_dev *, (const struct spdk_blob *blob), NULL);
56 [ - + ]: 300 : DEFINE_STUB(spdk_lvol_is_degraded, bool, (const struct spdk_lvol *lvol), false);
57 : :
58 : : struct spdk_blob {
59 : : uint64_t id;
60 : : char name[32];
61 : : };
62 : :
63 : : struct spdk_blob_store {
64 : : spdk_bs_esnap_dev_create esnap_bs_dev_create;
65 : : };
66 : :
67 : : const struct spdk_bdev_aliases_list *
68 : 24 : spdk_bdev_get_aliases(const struct spdk_bdev *bdev)
69 : : {
70 : 24 : return &bdev->aliases;
71 : : }
72 : :
73 : : uint32_t
74 : 36 : spdk_bdev_get_md_size(const struct spdk_bdev *bdev)
75 : : {
76 : 36 : return bdev->md_len;
77 : : }
78 : :
79 : : const struct spdk_uuid *
80 : 12 : spdk_bdev_get_uuid(const struct spdk_bdev *bdev)
81 : : {
82 : 12 : return &bdev->uuid;
83 : : }
84 : :
85 : : int
86 : 180 : spdk_bdev_alias_add(struct spdk_bdev *bdev, const char *alias)
87 : : {
88 : : struct spdk_bdev_alias *tmp;
89 : :
90 : 180 : CU_ASSERT(alias != NULL);
91 : 180 : CU_ASSERT(bdev != NULL);
92 [ + + + + ]: 180 : if (g_bdev_alias_already_exists) {
93 : 6 : return -EEXIST;
94 : : }
95 : :
96 : 174 : tmp = calloc(1, sizeof(*tmp));
97 [ - + ]: 174 : SPDK_CU_ASSERT_FATAL(tmp != NULL);
98 : :
99 [ - + ]: 174 : tmp->alias.name = strdup(alias);
100 [ - + ]: 174 : SPDK_CU_ASSERT_FATAL(tmp->alias.name != NULL);
101 : :
102 : 174 : TAILQ_INSERT_TAIL(&bdev->aliases, tmp, tailq);
103 : :
104 : 174 : return 0;
105 : : }
106 : :
107 : : int
108 : 18 : spdk_bdev_alias_del(struct spdk_bdev *bdev, const char *alias)
109 : : {
110 : : struct spdk_bdev_alias *tmp;
111 : :
112 : 18 : CU_ASSERT(bdev != NULL);
113 : :
114 [ + - ]: 18 : TAILQ_FOREACH(tmp, &bdev->aliases, tailq) {
115 [ - + ]: 18 : SPDK_CU_ASSERT_FATAL(alias != NULL);
116 [ + + - + : 18 : if (strncmp(alias, tmp->alias.name, SPDK_LVOL_NAME_MAX) == 0) {
+ - ]
117 [ + - ]: 18 : TAILQ_REMOVE(&bdev->aliases, tmp, tailq);
118 : 18 : free(tmp->alias.name);
119 : 18 : free(tmp);
120 : 18 : return 0;
121 : : }
122 : : }
123 : :
124 : 0 : return -ENOENT;
125 : : }
126 : :
127 : : void
128 : 156 : spdk_bdev_alias_del_all(struct spdk_bdev *bdev)
129 : : {
130 : : struct spdk_bdev_alias *p, *tmp;
131 : :
132 [ + + ]: 312 : TAILQ_FOREACH_SAFE(p, &bdev->aliases, tailq, tmp) {
133 [ - + ]: 156 : TAILQ_REMOVE(&bdev->aliases, p, tailq);
134 : 156 : free(p->alias.name);
135 : 156 : free(p);
136 : : }
137 : 156 : }
138 : :
139 : : void
140 : 156 : spdk_bdev_destruct_done(struct spdk_bdev *bdev, int bdeverrno)
141 : : {
142 : 156 : CU_ASSERT(bdeverrno == 0);
143 [ - + ]: 156 : SPDK_CU_ASSERT_FATAL(bdev->internal.unregister_cb != NULL);
144 : 156 : bdev->internal.unregister_cb(bdev->internal.unregister_ctx, bdeverrno);
145 : 156 : }
146 : :
147 : : struct ut_bs_dev {
148 : : struct spdk_bs_dev bs_dev;
149 : : struct spdk_bdev *bdev;
150 : : };
151 : :
152 : : static void
153 : 12 : ut_bs_dev_destroy(struct spdk_bs_dev *bs_dev)
154 : : {
155 : 12 : struct ut_bs_dev *ut_bs_dev = SPDK_CONTAINEROF(bs_dev, struct ut_bs_dev, bs_dev);
156 : :
157 : 12 : free(ut_bs_dev);
158 : 12 : }
159 : :
160 : : int
161 : 18 : spdk_bdev_create_bs_dev(const char *bdev_name, bool write,
162 : : struct spdk_bdev_bs_dev_opts *opts, size_t opts_size,
163 : : spdk_bdev_event_cb_t event_cb, void *event_ctx,
164 : : struct spdk_bs_dev **bs_dev)
165 : : {
166 : : struct spdk_bdev *bdev;
167 : : struct ut_bs_dev *ut_bs_dev;
168 : :
169 : 18 : bdev = spdk_bdev_get_by_name(bdev_name);
170 [ + + ]: 18 : if (bdev == NULL) {
171 : 6 : return -ENODEV;
172 : : }
173 : :
174 : 12 : ut_bs_dev = calloc(1, sizeof(*ut_bs_dev));
175 [ - + ]: 12 : SPDK_CU_ASSERT_FATAL(ut_bs_dev != NULL);
176 : 12 : ut_bs_dev->bs_dev.destroy = ut_bs_dev_destroy;
177 : 12 : ut_bs_dev->bdev = bdev;
178 : 12 : *bs_dev = &ut_bs_dev->bs_dev;
179 : :
180 : 12 : return 0;
181 : : }
182 : :
183 : : void
184 : 0 : spdk_lvs_grow(struct spdk_bs_dev *bs_dev, spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg)
185 : : {
186 : 0 : cb_fn(cb_arg, NULL, -EINVAL);
187 : 0 : }
188 : :
189 : : void
190 : 12 : spdk_lvs_rename(struct spdk_lvol_store *lvs, const char *new_name,
191 : : spdk_lvs_op_complete cb_fn, void *cb_arg)
192 : : {
193 [ + + + + ]: 12 : if (g_lvs_with_name_already_exists) {
194 : 6 : g_lvolerrno = -EEXIST;
195 : : } else {
196 [ - + ]: 6 : snprintf(lvs->name, sizeof(lvs->name), "%s", new_name);
197 : 6 : g_lvolerrno = 0;
198 : : }
199 : :
200 : 12 : cb_fn(cb_arg, g_lvolerrno);
201 : 12 : }
202 : :
203 : : void
204 : 12 : spdk_lvol_rename(struct spdk_lvol *lvol, const char *new_name,
205 : : spdk_lvol_op_complete cb_fn, void *cb_arg)
206 : : {
207 : : struct spdk_lvol *tmp;
208 : :
209 [ + + - + : 12 : if (strncmp(lvol->name, new_name, SPDK_LVOL_NAME_MAX) == 0) {
+ + ]
210 : 6 : cb_fn(cb_arg, 0);
211 : 6 : return;
212 : : }
213 : :
214 [ + + ]: 18 : TAILQ_FOREACH(tmp, &lvol->lvol_store->lvols, link) {
215 [ - + - + : 12 : if (strncmp(tmp->name, new_name, SPDK_LVOL_NAME_MAX) == 0) {
- + ]
216 : 0 : SPDK_ERRLOG("Lvol %s already exists in lvol store %s\n", new_name, lvol->lvol_store->name);
217 : 0 : cb_fn(cb_arg, -EEXIST);
218 : 0 : return;
219 : : }
220 : : }
221 : :
222 : 6 : snprintf(lvol->name, sizeof(lvol->name), "%s", new_name);
223 : :
224 : 6 : cb_fn(cb_arg, g_lvolerrno);
225 : : }
226 : :
227 : : void
228 : 66 : spdk_lvol_open(struct spdk_lvol *lvol, spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg)
229 : : {
230 : : int lvolerrno;
231 : :
232 [ + + ]: 66 : if (g_lvol_open_enomem == lvol->lvol_store->lvols_opened) {
233 : 6 : lvolerrno = -ENOMEM;
234 : 6 : g_lvol_open_enomem = -1;
235 : : } else {
236 : 60 : lvolerrno = g_lvolerrno;
237 : : }
238 : :
239 : 66 : cb_fn(cb_arg, lvol, lvolerrno);
240 : 66 : }
241 : :
242 : : uint64_t
243 : 162 : spdk_blob_get_num_clusters(struct spdk_blob *b)
244 : : {
245 : 162 : return 0;
246 : : }
247 : :
248 : : /* Simulation of a blob with:
249 : : * - 1 io_unit per cluster
250 : : * - 20 data cluster
251 : : * - only last cluster allocated
252 : : */
253 : : uint64_t g_blob_allocated_io_unit_offset = 20;
254 : :
255 : : uint64_t
256 : 12 : spdk_blob_get_next_allocated_io_unit(struct spdk_blob *blob, uint64_t offset)
257 : : {
258 [ + + ]: 12 : if (offset <= g_blob_allocated_io_unit_offset) {
259 : 6 : return g_blob_allocated_io_unit_offset;
260 : : } else {
261 : 6 : return UINT64_MAX;
262 : : }
263 : : }
264 : :
265 : : uint64_t
266 : 12 : spdk_blob_get_next_unallocated_io_unit(struct spdk_blob *blob, uint64_t offset)
267 : : {
268 [ + + ]: 12 : if (offset < g_blob_allocated_io_unit_offset) {
269 : 6 : return offset;
270 : : } else {
271 : 6 : return UINT64_MAX;
272 : : }
273 : : }
274 : :
275 : : int
276 : 144 : spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_id *ids,
277 : : size_t *count)
278 : : {
279 : 144 : *count = 0;
280 : 144 : return 0;
281 : : }
282 : :
283 : : spdk_blob_id
284 : 0 : spdk_blob_get_parent_snapshot(struct spdk_blob_store *bs, spdk_blob_id blobid)
285 : : {
286 : 0 : return 0;
287 : : }
288 : :
289 : : bool g_blob_is_read_only = false;
290 : :
291 : : bool
292 : 36 : spdk_blob_is_read_only(struct spdk_blob *blob)
293 : : {
294 [ - + ]: 36 : return g_blob_is_read_only;
295 : : }
296 : :
297 : : bool
298 : 0 : spdk_blob_is_snapshot(struct spdk_blob *blob)
299 : : {
300 : 0 : return false;
301 : : }
302 : :
303 : : bool
304 : 0 : spdk_blob_is_clone(struct spdk_blob *blob)
305 : : {
306 : 0 : return false;
307 : : }
308 : :
309 : : bool
310 : 0 : spdk_blob_is_thin_provisioned(struct spdk_blob *blob)
311 : : {
312 : 0 : return false;
313 : : }
314 : :
315 : : static struct spdk_lvol *_lvol_create(struct spdk_lvol_store *lvs);
316 : :
317 : : int
318 : 12 : spdk_lvol_create_esnap_clone(const void *esnap_id, uint32_t id_len, uint64_t size_bytes,
319 : : struct spdk_lvol_store *lvs, const char *clone_name,
320 : : spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg)
321 : : {
322 : : struct spdk_lvol *lvol;
323 : :
324 : 12 : lvol = _lvol_create(lvs);
325 [ - + ]: 12 : snprintf(lvol->name, sizeof(lvol->name), "%s", clone_name);
326 : :
327 : 12 : cb_fn(cb_arg, lvol, 0);
328 : 12 : return 0;
329 : : }
330 : :
331 : : static void
332 : 30 : lvs_load(struct spdk_bs_dev *dev, const struct spdk_lvs_opts *lvs_opts,
333 : : spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg)
334 : : {
335 : 30 : struct spdk_lvol_store *lvs = NULL;
336 : : int i;
337 : 30 : int lvserrno = g_lvserrno;
338 : :
339 [ + + ]: 30 : if (lvserrno != 0) {
340 : : /* On error blobstore destroys bs_dev itself,
341 : : * by puttin back io channels.
342 : : * This operation is asynchronous, and completed
343 : : * after calling the callback for lvol. */
344 : 6 : cb_fn(cb_arg, g_lvol_store, lvserrno);
345 : 6 : dev->destroy(dev);
346 : 6 : return;
347 : : }
348 : :
349 : 24 : lvs = calloc(1, sizeof(*lvs));
350 [ - + ]: 24 : SPDK_CU_ASSERT_FATAL(lvs != NULL);
351 : 24 : lvs->blobstore = calloc(1, sizeof(*lvs->blobstore));
352 : 24 : lvs->blobstore->esnap_bs_dev_create = lvs_opts->esnap_bs_dev_create;
353 [ - + ]: 24 : SPDK_CU_ASSERT_FATAL(lvs->blobstore != NULL);
354 : 24 : TAILQ_INIT(&lvs->lvols);
355 : 24 : TAILQ_INIT(&lvs->pending_lvols);
356 : 24 : TAILQ_INIT(&lvs->retry_open_lvols);
357 : 24 : spdk_uuid_generate(&lvs->uuid);
358 : 24 : lvs->bs_dev = dev;
359 [ + + ]: 84 : for (i = 0; i < g_num_lvols; i++) {
360 : 60 : _lvol_create(lvs);
361 : 60 : lvs->lvol_count++;
362 : : }
363 : :
364 : 24 : cb_fn(cb_arg, lvs, lvserrno);
365 : : }
366 : :
367 : : void
368 : 0 : spdk_lvs_load(struct spdk_bs_dev *dev,
369 : : spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg)
370 : : {
371 : 0 : lvs_load(dev, NULL, cb_fn, cb_arg);
372 : 0 : }
373 : :
374 : : void
375 : 30 : spdk_lvs_load_ext(struct spdk_bs_dev *bs_dev, const struct spdk_lvs_opts *lvs_opts,
376 : : spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg)
377 : : {
378 : 30 : lvs_load(bs_dev, lvs_opts, cb_fn, cb_arg);
379 : 30 : }
380 : :
381 : : int
382 : 120 : spdk_bs_bdev_claim(struct spdk_bs_dev *bs_dev, struct spdk_bdev_module *module)
383 : : {
384 [ + + + + ]: 120 : if (lvol_already_opened == true) {
385 : 6 : return -EPERM;
386 : : }
387 : :
388 : 114 : lvol_already_opened = true;
389 : :
390 : 114 : return 0;
391 : : }
392 : :
393 : : static void
394 : 6 : _spdk_bdev_unregister_cb(void *cb_arg, int rc)
395 : : {
396 : 6 : CU_ASSERT(rc == 0);
397 : 6 : }
398 : :
399 : : void
400 : 156 : spdk_bdev_unregister(struct spdk_bdev *vbdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg)
401 : : {
402 : : int rc;
403 : :
404 [ - + ]: 156 : SPDK_CU_ASSERT_FATAL(vbdev != NULL);
405 : 156 : vbdev->internal.unregister_cb = cb_fn;
406 : 156 : vbdev->internal.unregister_ctx = cb_arg;
407 : :
408 : 156 : rc = vbdev->fn_table->destruct(vbdev->ctxt);
409 : 156 : CU_ASSERT(rc == 1);
410 : 156 : }
411 : :
412 : : uint64_t
413 : 0 : spdk_bs_get_page_size(struct spdk_blob_store *bs)
414 : : {
415 : 0 : return SPDK_BS_PAGE_SIZE;
416 : : }
417 : :
418 : : uint64_t
419 : 156 : spdk_bs_get_io_unit_size(struct spdk_blob_store *bs)
420 : : {
421 : 156 : return SPDK_BS_PAGE_SIZE;
422 : : }
423 : :
424 : : static void
425 : 126 : bdev_blob_destroy(struct spdk_bs_dev *bs_dev)
426 : : {
427 : 126 : CU_ASSERT(bs_dev != NULL);
428 : 126 : free(bs_dev);
429 : 126 : lvol_already_opened = false;
430 : 126 : }
431 : :
432 : : static struct spdk_bdev *
433 : 96 : bdev_blob_get_base_bdev(struct spdk_bs_dev *bs_dev)
434 : : {
435 : 96 : CU_ASSERT(bs_dev != NULL);
436 : 96 : return &g_bdev;
437 : : }
438 : :
439 : : int
440 : 138 : spdk_bdev_create_bs_dev_ext(const char *bdev_name, spdk_bdev_event_cb_t event_cb,
441 : : void *event_ctx, struct spdk_bs_dev **_bs_dev)
442 : : {
443 : : struct spdk_bs_dev *bs_dev;
444 : :
445 [ + + + + ]: 138 : if (lvol_already_opened == true) {
446 : 12 : return -EINVAL;
447 : : }
448 : :
449 : 126 : bs_dev = calloc(1, sizeof(*bs_dev));
450 [ - + ]: 126 : SPDK_CU_ASSERT_FATAL(bs_dev != NULL);
451 : 126 : bs_dev->blocklen = 4096;
452 : 126 : bs_dev->blockcnt = 128;
453 : 126 : bs_dev->destroy = bdev_blob_destroy;
454 : 126 : bs_dev->get_base_bdev = bdev_blob_get_base_bdev;
455 : :
456 : 126 : *_bs_dev = bs_dev;
457 : :
458 : 126 : return 0;
459 : : }
460 : :
461 : : void
462 : 132 : spdk_lvs_opts_init(struct spdk_lvs_opts *opts)
463 : : {
464 : 132 : opts->cluster_sz = SPDK_LVS_OPTS_CLUSTER_SZ;
465 : 132 : opts->clear_method = LVS_CLEAR_WITH_UNMAP;
466 : 132 : opts->num_md_pages_per_cluster_ratio = 100;
467 [ - + ]: 132 : memset(opts->name, 0, sizeof(opts->name));
468 : 132 : }
469 : :
470 : : int
471 : 96 : spdk_lvs_init(struct spdk_bs_dev *bs_dev, struct spdk_lvs_opts *o,
472 : : spdk_lvs_op_with_handle_complete cb_fn, void *cb_arg)
473 : : {
474 : : struct spdk_lvol_store *lvs;
475 : 96 : int error = 0;
476 : :
477 [ + + + + ]: 96 : if (lvol_store_initialize_fail) {
478 : 6 : return -1;
479 : : }
480 : :
481 [ + + + + ]: 90 : if (lvol_store_initialize_cb_fail) {
482 : 6 : bs_dev->destroy(bs_dev);
483 : 6 : lvs = NULL;
484 : 6 : error = -1;
485 : : } else {
486 : 84 : lvs = calloc(1, sizeof(*lvs));
487 [ - + ]: 84 : SPDK_CU_ASSERT_FATAL(lvs != NULL);
488 : 84 : TAILQ_INIT(&lvs->lvols);
489 : 84 : TAILQ_INIT(&lvs->pending_lvols);
490 : 84 : spdk_uuid_generate(&lvs->uuid);
491 [ - + ]: 84 : snprintf(lvs->name, sizeof(lvs->name), "%s", o->name);
492 : 84 : lvs->bs_dev = bs_dev;
493 : 84 : error = 0;
494 : : }
495 : 90 : cb_fn(cb_arg, lvs, error);
496 : :
497 : 90 : return 0;
498 : : }
499 : :
500 : : int
501 : 24 : spdk_lvs_unload(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn, void *cb_arg)
502 : : {
503 : : struct spdk_lvol *lvol, *tmp;
504 : :
505 [ + + ]: 36 : TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) {
506 [ - + ]: 12 : TAILQ_REMOVE(&lvs->lvols, lvol, link);
507 : 12 : free(lvol);
508 : : }
509 : 24 : g_lvol_store = NULL;
510 : :
511 : 24 : lvs->bs_dev->destroy(lvs->bs_dev);
512 : 24 : free(lvs->blobstore);
513 : 24 : free(lvs);
514 : :
515 [ + - ]: 24 : if (cb_fn != NULL) {
516 : 24 : cb_fn(cb_arg, 0);
517 : : }
518 : :
519 : 24 : return 0;
520 : : }
521 : :
522 : : int
523 : 84 : spdk_lvs_destroy(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn,
524 : : void *cb_arg)
525 : : {
526 : : struct spdk_lvol *lvol, *tmp;
527 : : char *alias;
528 : :
529 [ - + ]: 84 : TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) {
530 [ # # ]: 0 : TAILQ_REMOVE(&lvs->lvols, lvol, link);
531 : :
532 : 0 : alias = spdk_sprintf_alloc("%s/%s", lvs->name, lvol->name);
533 [ # # ]: 0 : if (alias == NULL) {
534 : 0 : SPDK_ERRLOG("Cannot alloc memory for alias\n");
535 : 0 : return -1;
536 : : }
537 : 0 : spdk_bdev_alias_del(lvol->bdev, alias);
538 : :
539 : 0 : free(alias);
540 : 0 : free(lvol);
541 : : }
542 : 84 : g_lvol_store = NULL;
543 : :
544 : 84 : lvs->bs_dev->destroy(lvs->bs_dev);
545 : 84 : free(lvs->blobstore);
546 : 84 : free(lvs);
547 : :
548 [ + - ]: 84 : if (cb_fn != NULL) {
549 : 84 : cb_fn(cb_arg, 0);
550 : : }
551 : :
552 : 84 : return 0;
553 : : }
554 : :
555 : : void
556 : 6 : spdk_lvol_resize(struct spdk_lvol *lvol, size_t sz, spdk_lvol_op_complete cb_fn, void *cb_arg)
557 : : {
558 : 6 : cb_fn(cb_arg, 0);
559 : 6 : }
560 : :
561 : : void
562 : 6 : spdk_lvol_set_read_only(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg)
563 : : {
564 : 6 : cb_fn(cb_arg, 0);
565 : 6 : }
566 : :
567 : : int
568 : 6 : spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size)
569 : : {
570 : 6 : bdev->blockcnt = size;
571 : 6 : return 0;
572 : : }
573 : :
574 : : uint64_t
575 : 318 : spdk_bs_get_cluster_size(struct spdk_blob_store *bs)
576 : : {
577 : 318 : return g_cluster_size;
578 : : }
579 : :
580 : : struct spdk_bdev *
581 : 36 : spdk_bdev_get_by_name(const char *bdev_name)
582 : : {
583 : 30 : struct spdk_uuid uuid;
584 : : int rc;
585 : :
586 [ + + ]: 36 : if (g_base_bdev == NULL) {
587 : 12 : return NULL;
588 : : }
589 : :
590 [ + + - + : 24 : if (!strcmp(g_base_bdev->name, bdev_name)) {
+ + ]
591 : 6 : return g_base_bdev;
592 : : }
593 : :
594 : 18 : rc = spdk_uuid_parse(&uuid, bdev_name);
595 [ + - + - ]: 18 : if (rc == 0 && spdk_uuid_compare(&uuid, &g_base_bdev->uuid) == 0) {
596 : 18 : return g_base_bdev;
597 : : }
598 : :
599 : 0 : return NULL;
600 : : }
601 : :
602 : : struct spdk_bdev_desc {
603 : : struct spdk_bdev *bdev;
604 : : };
605 : :
606 : : int
607 : 18 : spdk_bdev_open_ext(const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb,
608 : : void *event_ctx, struct spdk_bdev_desc **_desc)
609 : : {
610 : : struct spdk_bdev_desc *desc;
611 : : struct spdk_bdev *bdev;
612 : :
613 : 18 : bdev = spdk_bdev_get_by_name(bdev_name);
614 [ + + ]: 18 : if (bdev == NULL) {
615 : 6 : return -ENODEV;
616 : : }
617 : :
618 : 12 : desc = calloc(1, sizeof(*desc));
619 [ - + ]: 12 : if (desc == NULL) {
620 : 0 : return -ENOMEM;
621 : : }
622 : :
623 : 12 : desc->bdev = bdev;
624 : 12 : *_desc = desc;
625 : 12 : return 0;
626 : : }
627 : :
628 : : void
629 : 12 : spdk_bdev_close(struct spdk_bdev_desc *desc)
630 : : {
631 : 12 : free(desc);
632 : 12 : }
633 : :
634 : : struct spdk_bdev *
635 : 12 : spdk_bdev_desc_get_bdev(struct spdk_bdev_desc *desc)
636 : : {
637 : 12 : return desc->bdev;
638 : : }
639 : :
640 : : void
641 : 156 : spdk_lvol_close(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg)
642 : : {
643 : 156 : lvol->ref_count--;
644 : :
645 [ - + ]: 156 : SPDK_CU_ASSERT_FATAL(cb_fn != NULL);
646 : 156 : cb_fn(cb_arg, 0);
647 : 156 : }
648 : :
649 : : bool
650 : 78 : spdk_lvol_deletable(struct spdk_lvol *lvol)
651 : : {
652 : 78 : return true;
653 : : }
654 : :
655 : : void
656 : 144 : spdk_lvol_destroy(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_arg)
657 : : {
658 [ - + ]: 144 : if (lvol->ref_count != 0) {
659 : 0 : cb_fn(cb_arg, -ENODEV);
660 : : }
661 : :
662 [ + + ]: 144 : TAILQ_REMOVE(&lvol->lvol_store->lvols, lvol, link);
663 : :
664 [ - + ]: 144 : SPDK_CU_ASSERT_FATAL(cb_fn != NULL);
665 : 144 : cb_fn(cb_arg, 0);
666 : :
667 : 144 : g_lvol = NULL;
668 : 144 : free(lvol);
669 : 144 : }
670 : :
671 : : void
672 : 48 : spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status)
673 : : {
674 : 48 : bdev_io->internal.status = status;
675 : 48 : }
676 : :
677 : 6 : struct spdk_io_channel *spdk_lvol_get_io_channel(struct spdk_lvol *lvol)
678 : : {
679 : 6 : CU_ASSERT(lvol == g_lvol);
680 : 6 : return g_ch;
681 : : }
682 : :
683 : : void
684 : 6 : spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len)
685 : : {
686 : 6 : CU_ASSERT(cb == lvol_get_buf_cb);
687 : 6 : }
688 : :
689 : : void
690 : 0 : spdk_blob_io_read(struct spdk_blob *blob, struct spdk_io_channel *channel,
691 : : void *payload, uint64_t offset, uint64_t length,
692 : : spdk_blob_op_complete cb_fn, void *cb_arg)
693 : : {
694 : 0 : CU_ASSERT(blob == NULL);
695 : 0 : CU_ASSERT(channel == g_ch);
696 : 0 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
697 : 0 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
698 : 0 : cb_fn(cb_arg, 0);
699 : 0 : }
700 : :
701 : : void
702 : 0 : spdk_blob_io_write(struct spdk_blob *blob, struct spdk_io_channel *channel,
703 : : void *payload, uint64_t offset, uint64_t length,
704 : : spdk_blob_op_complete cb_fn, void *cb_arg)
705 : : {
706 : 0 : CU_ASSERT(blob == NULL);
707 : 0 : CU_ASSERT(channel == g_ch);
708 : 0 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
709 : 0 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
710 : 0 : cb_fn(cb_arg, 0);
711 : 0 : }
712 : :
713 : : void
714 : 0 : spdk_blob_io_unmap(struct spdk_blob *blob, struct spdk_io_channel *channel,
715 : : uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg)
716 : : {
717 : 0 : CU_ASSERT(blob == NULL);
718 : 0 : CU_ASSERT(channel == g_ch);
719 : 0 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
720 : 0 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
721 : 0 : cb_fn(cb_arg, 0);
722 : 0 : }
723 : :
724 : : void
725 : 0 : spdk_blob_io_write_zeroes(struct spdk_blob *blob, struct spdk_io_channel *channel,
726 : : uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg)
727 : : {
728 : 0 : CU_ASSERT(blob == NULL);
729 : 0 : CU_ASSERT(channel == g_ch);
730 : 0 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
731 : 0 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
732 : 0 : cb_fn(cb_arg, 0);
733 : 0 : }
734 : :
735 : : void
736 : 0 : spdk_blob_io_writev(struct spdk_blob *blob, struct spdk_io_channel *channel,
737 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
738 : : spdk_blob_op_complete cb_fn, void *cb_arg)
739 : : {
740 : 0 : CU_ASSERT(blob == NULL);
741 : 0 : CU_ASSERT(channel == g_ch);
742 : 0 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
743 : 0 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
744 : 0 : cb_fn(cb_arg, 0);
745 : 0 : }
746 : :
747 : : void
748 : 12 : spdk_blob_io_writev_ext(struct spdk_blob *blob, struct spdk_io_channel *channel,
749 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
750 : : spdk_blob_op_complete cb_fn, void *cb_arg,
751 : : struct spdk_blob_ext_io_opts *io_opts)
752 : : {
753 : 12 : struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx;
754 : :
755 : 12 : CU_ASSERT(blob == NULL);
756 : 12 : CU_ASSERT(channel == g_ch);
757 : 12 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
758 : 12 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
759 : 12 : CU_ASSERT(io_opts == &lvol_io->ext_io_opts);
760 : 12 : g_ext_api_called = true;
761 : 12 : cb_fn(cb_arg, 0);
762 : 12 : }
763 : :
764 : : void
765 : 0 : spdk_blob_io_readv(struct spdk_blob *blob, struct spdk_io_channel *channel,
766 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
767 : : spdk_blob_op_complete cb_fn, void *cb_arg)
768 : : {
769 : 0 : CU_ASSERT(blob == NULL);
770 : 0 : CU_ASSERT(channel == g_ch);
771 : 0 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
772 : 0 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
773 : 0 : cb_fn(cb_arg, 0);
774 : 0 : }
775 : :
776 : : void
777 : 12 : spdk_blob_io_readv_ext(struct spdk_blob *blob, struct spdk_io_channel *channel,
778 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
779 : : spdk_blob_op_complete cb_fn, void *cb_arg,
780 : : struct spdk_blob_ext_io_opts *io_opts)
781 : : {
782 : 12 : struct vbdev_lvol_io *lvol_io = (struct vbdev_lvol_io *)g_io->driver_ctx;
783 : :
784 : 12 : CU_ASSERT(blob == NULL);
785 : 12 : CU_ASSERT(channel == g_ch);
786 : 12 : CU_ASSERT(offset == g_io->u.bdev.offset_blocks);
787 : 12 : CU_ASSERT(length == g_io->u.bdev.num_blocks);
788 : 12 : CU_ASSERT(io_opts == &lvol_io->ext_io_opts);
789 : 12 : g_ext_api_called = true;
790 : 12 : cb_fn(cb_arg, 0);
791 : 12 : }
792 : :
793 : : void
794 : 6 : spdk_bdev_module_list_add(struct spdk_bdev_module *bdev_module)
795 : : {
796 : 6 : }
797 : :
798 : : const char *
799 : 6 : spdk_bdev_get_name(const struct spdk_bdev *bdev)
800 : : {
801 : 6 : return bdev->name;
802 : : }
803 : :
804 : : uint32_t
805 : 12 : spdk_bdev_get_block_size(const struct spdk_bdev *bdev)
806 : : {
807 : 12 : return bdev->blocklen;
808 : : }
809 : :
810 : : uint64_t
811 : 12 : spdk_bdev_get_num_blocks(const struct spdk_bdev *bdev)
812 : : {
813 : 12 : return bdev->blockcnt;
814 : : }
815 : :
816 : : int
817 : 156 : spdk_bdev_register(struct spdk_bdev *vbdev)
818 : : {
819 : 156 : TAILQ_INIT(&vbdev->aliases);
820 : :
821 : 156 : g_registered_bdevs++;
822 : 156 : return 0;
823 : : }
824 : :
825 : : void
826 : 48 : spdk_bdev_module_examine_done(struct spdk_bdev_module *module)
827 : : {
828 [ - + - + ]: 48 : SPDK_CU_ASSERT_FATAL(g_examine_done != true);
829 : 48 : g_examine_done = true;
830 : 48 : }
831 : :
832 : : static struct spdk_lvol *
833 : 162 : _lvol_create(struct spdk_lvol_store *lvs)
834 : : {
835 : 162 : struct spdk_lvol *lvol = calloc(1, sizeof(*lvol));
836 : :
837 [ - + ]: 162 : SPDK_CU_ASSERT_FATAL(lvol != NULL);
838 : :
839 : 162 : lvol->lvol_store = lvs;
840 : 162 : lvol->ref_count++;
841 [ - + ]: 162 : snprintf(lvol->unique_id, sizeof(lvol->unique_id), "%s", "UNIT_TEST_UUID");
842 : :
843 : 162 : TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link);
844 : :
845 : 162 : return lvol;
846 : : }
847 : :
848 : : int
849 : 72 : spdk_lvol_create(struct spdk_lvol_store *lvs, const char *name, size_t sz,
850 : : bool thin_provision, enum lvol_clear_method clear_method, spdk_lvol_op_with_handle_complete cb_fn,
851 : : void *cb_arg)
852 : : {
853 : : struct spdk_lvol *lvol;
854 : :
855 : 72 : lvol = _lvol_create(lvs);
856 [ - + ]: 72 : snprintf(lvol->name, sizeof(lvol->name), "%s", name);
857 : 72 : cb_fn(cb_arg, lvol, 0);
858 : :
859 : 72 : return 0;
860 : : }
861 : :
862 : : void
863 : 12 : spdk_lvol_create_snapshot(struct spdk_lvol *lvol, const char *snapshot_name,
864 : : spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg)
865 : : {
866 : : struct spdk_lvol *snap;
867 : :
868 : 12 : snap = _lvol_create(lvol->lvol_store);
869 [ - + ]: 12 : snprintf(snap->name, sizeof(snap->name), "%s", snapshot_name);
870 : 12 : cb_fn(cb_arg, snap, 0);
871 : 12 : }
872 : :
873 : : void
874 : 6 : spdk_lvol_create_clone(struct spdk_lvol *lvol, const char *clone_name,
875 : : spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg)
876 : : {
877 : : struct spdk_lvol *clone;
878 : :
879 : 6 : clone = _lvol_create(lvol->lvol_store);
880 [ - + ]: 6 : snprintf(clone->name, sizeof(clone->name), "%s", clone_name);
881 : 6 : cb_fn(cb_arg, clone, 0);
882 : 6 : }
883 : :
884 : : bool
885 : 12 : spdk_lvs_notify_hotplug(const void *esnap_id, uint32_t id_len,
886 : : spdk_lvol_op_with_handle_complete cb_fn, void *cb_arg)
887 : : {
888 : 12 : struct spdk_uuid uuid = { 0 };
889 : 12 : char uuid_str[SPDK_UUID_STRING_LEN] = "bad";
890 : :
891 : 12 : CU_ASSERT(id_len == SPDK_UUID_STRING_LEN);
892 : 12 : CU_ASSERT(spdk_uuid_parse(&uuid, esnap_id) == 0);
893 : 12 : CU_ASSERT(spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), &uuid) == 0);
894 [ - + ]: 12 : CU_ASSERT(strcmp(esnap_id, uuid_str) == 0);
895 : :
896 [ - + ]: 12 : return g_bdev_is_missing;
897 : : }
898 : :
899 : : static void
900 : 168 : lvol_store_op_complete(void *cb_arg, int lvserrno)
901 : : {
902 : 168 : g_lvserrno = lvserrno;
903 : 168 : return;
904 : : }
905 : :
906 : : static void
907 : 90 : lvol_store_op_with_handle_complete(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno)
908 : : {
909 : 90 : g_lvserrno = lvserrno;
910 : 90 : g_lvol_store = lvs;
911 : 90 : return;
912 : : }
913 : :
914 : : static void
915 : 114 : vbdev_lvol_create_complete(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno)
916 : : {
917 : 114 : g_lvolerrno = lvolerrno;
918 : 114 : g_lvol = lvol;
919 : 114 : }
920 : :
921 : : static void
922 : 12 : vbdev_lvol_resize_complete(void *cb_arg, int lvolerrno)
923 : : {
924 : 12 : g_lvolerrno = lvolerrno;
925 : 12 : }
926 : :
927 : : static void
928 : 6 : vbdev_lvol_set_read_only_complete(void *cb_arg, int lvolerrno)
929 : : {
930 : 6 : g_lvolerrno = lvolerrno;
931 : 6 : }
932 : :
933 : : static void
934 : 18 : vbdev_lvol_rename_complete(void *cb_arg, int lvolerrno)
935 : : {
936 : 18 : g_lvolerrno = lvolerrno;
937 : 18 : }
938 : :
939 : : static void
940 : 6 : ut_lvs_destroy(void)
941 : : {
942 : 6 : int rc = 0;
943 : 6 : int sz = 10;
944 : : struct spdk_lvol_store *lvs;
945 : :
946 : : /* Lvol store is successfully created */
947 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
948 : : lvol_store_op_with_handle_complete, NULL);
949 : 6 : CU_ASSERT(rc == 0);
950 : 6 : CU_ASSERT(g_lvserrno == 0);
951 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
952 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
953 : :
954 : 6 : lvs = g_lvol_store;
955 : 6 : g_lvol_store = NULL;
956 : :
957 : 6 : spdk_uuid_generate(&lvs->uuid);
958 : :
959 : : /* Successfully create lvol, which should be unloaded with lvs later */
960 : 6 : g_lvolerrno = -1;
961 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
962 : : NULL);
963 : 6 : CU_ASSERT(rc == 0);
964 : 6 : CU_ASSERT(g_lvolerrno == 0);
965 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
966 : :
967 : : /* Unload lvol store */
968 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
969 : 6 : CU_ASSERT(g_lvserrno == 0);
970 : 6 : CU_ASSERT(g_lvol_store == NULL);
971 : 6 : }
972 : :
973 : : static void
974 : 6 : ut_lvol_init(void)
975 : : {
976 : : struct spdk_lvol_store *lvs;
977 : 6 : int sz = 10;
978 : : int rc;
979 : :
980 : : /* Lvol store is successfully created */
981 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
982 : : lvol_store_op_with_handle_complete, NULL);
983 : 6 : CU_ASSERT(rc == 0);
984 : 6 : CU_ASSERT(g_lvserrno == 0);
985 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
986 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
987 : 6 : lvs = g_lvol_store;
988 : :
989 : : /* Successful lvol create */
990 : 6 : g_lvolerrno = -1;
991 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
992 : : NULL);
993 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
994 : 6 : CU_ASSERT(g_lvol != NULL);
995 : 6 : CU_ASSERT(g_lvolerrno == 0);
996 : :
997 : : /* Successful lvol destroy */
998 : 6 : vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL);
999 : 6 : CU_ASSERT(g_lvol == NULL);
1000 : :
1001 : : /* Destroy lvol store */
1002 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
1003 : 6 : CU_ASSERT(g_lvserrno == 0);
1004 : 6 : CU_ASSERT(g_lvol_store == NULL);
1005 : 6 : }
1006 : :
1007 : : static void
1008 : 6 : ut_lvol_snapshot(void)
1009 : : {
1010 : : struct spdk_lvol_store *lvs;
1011 : 6 : int sz = 10;
1012 : : int rc;
1013 : 6 : struct spdk_lvol *lvol = NULL;
1014 : :
1015 : : /* Lvol store is successfully created */
1016 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1017 : : lvol_store_op_with_handle_complete, NULL);
1018 : 6 : CU_ASSERT(rc == 0);
1019 : 6 : CU_ASSERT(g_lvserrno == 0);
1020 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1021 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1022 : 6 : lvs = g_lvol_store;
1023 : :
1024 : : /* Successful lvol create */
1025 : 6 : g_lvolerrno = -1;
1026 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1027 : : NULL);
1028 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1029 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1030 : 6 : CU_ASSERT(g_lvolerrno == 0);
1031 : :
1032 : 6 : lvol = g_lvol;
1033 : :
1034 : : /* Successful snap create */
1035 : 6 : vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL);
1036 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1037 : 6 : CU_ASSERT(g_lvol != NULL);
1038 : 6 : CU_ASSERT(g_lvolerrno == 0);
1039 : :
1040 : : /* Successful lvol destroy */
1041 : 6 : vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL);
1042 : 6 : CU_ASSERT(g_lvol == NULL);
1043 : :
1044 : : /* Successful snap destroy */
1045 : 6 : g_lvol = lvol;
1046 : 6 : vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL);
1047 : 6 : CU_ASSERT(g_lvol == NULL);
1048 : :
1049 : : /* Destroy lvol store */
1050 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
1051 : 6 : CU_ASSERT(g_lvserrno == 0);
1052 : 6 : CU_ASSERT(g_lvol_store == NULL);
1053 : 6 : }
1054 : :
1055 : : static void
1056 : 6 : ut_lvol_clone(void)
1057 : : {
1058 : : struct spdk_lvol_store *lvs;
1059 : 6 : int sz = 10;
1060 : : int rc;
1061 : 6 : struct spdk_lvol *lvol = NULL;
1062 : 6 : struct spdk_lvol *snap = NULL;
1063 : 6 : struct spdk_lvol *clone = NULL;
1064 : :
1065 : : /* Lvol store is successfully created */
1066 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1067 : : lvol_store_op_with_handle_complete, NULL);
1068 : 6 : CU_ASSERT(rc == 0);
1069 : 6 : CU_ASSERT(g_lvserrno == 0);
1070 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1071 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1072 : 6 : lvs = g_lvol_store;
1073 : :
1074 : : /* Successful lvol create */
1075 : 6 : g_lvolerrno = -1;
1076 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1077 : : NULL);
1078 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1079 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1080 : 6 : CU_ASSERT(g_lvolerrno == 0);
1081 : :
1082 : 6 : lvol = g_lvol;
1083 : :
1084 : : /* Successful snap create */
1085 : 6 : vbdev_lvol_create_snapshot(lvol, "snap", vbdev_lvol_create_complete, NULL);
1086 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1087 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1088 : 6 : CU_ASSERT(g_lvolerrno == 0);
1089 : :
1090 : 6 : snap = g_lvol;
1091 : :
1092 : : /* Successful clone create */
1093 : 6 : vbdev_lvol_create_clone(snap, "clone", vbdev_lvol_create_complete, NULL);
1094 : :
1095 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1096 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1097 : 6 : CU_ASSERT(g_lvolerrno == 0);
1098 : :
1099 : 6 : clone = g_lvol;
1100 : :
1101 : : /* Successful lvol destroy */
1102 : 6 : g_lvol = lvol;
1103 : 6 : vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL);
1104 : 6 : CU_ASSERT(g_lvol == NULL);
1105 : :
1106 : : /* Successful clone destroy */
1107 : 6 : g_lvol = clone;
1108 : 6 : vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL);
1109 : 6 : CU_ASSERT(g_lvol == NULL);
1110 : :
1111 : : /* Successful lvol destroy */
1112 : 6 : g_lvol = snap;
1113 : 6 : vbdev_lvol_destroy(g_lvol, lvol_store_op_complete, NULL);
1114 : 6 : CU_ASSERT(g_lvol == NULL);
1115 : :
1116 : : /* Destroy lvol store */
1117 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
1118 : 6 : CU_ASSERT(g_lvserrno == 0);
1119 : 6 : CU_ASSERT(g_lvol_store == NULL);
1120 : 6 : }
1121 : :
1122 : : static void
1123 : 6 : ut_lvol_hotremove(void)
1124 : : {
1125 : 6 : int rc = 0;
1126 : :
1127 : 6 : lvol_store_initialize_fail = false;
1128 : 6 : lvol_store_initialize_cb_fail = false;
1129 : 6 : lvol_already_opened = false;
1130 : :
1131 : : /* Lvol store is successfully created */
1132 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1133 : : lvol_store_op_with_handle_complete, NULL);
1134 : 6 : CU_ASSERT(rc == 0);
1135 : 6 : CU_ASSERT(g_lvserrno == 0);
1136 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1137 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1138 : :
1139 : : /* Hot remove callback with NULL - stability check */
1140 : 6 : vbdev_lvs_hotremove_cb(NULL);
1141 : :
1142 : : /* Hot remove lvs on bdev removal */
1143 : 6 : vbdev_lvs_hotremove_cb(&g_bdev);
1144 : :
1145 : 6 : CU_ASSERT(g_lvol_store == NULL);
1146 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs));
1147 : :
1148 : 6 : }
1149 : :
1150 : : static void
1151 : 6 : ut_lvol_examine_config(void)
1152 : : {
1153 : : /* No esnap clone needs the bdev. */
1154 : 6 : g_bdev_is_missing = false;
1155 : 6 : g_examine_done = false;
1156 : 6 : vbdev_lvs_examine_config(&g_bdev);
1157 [ - + ]: 6 : CU_ASSERT(g_examine_done);
1158 : :
1159 : 6 : g_bdev_is_missing = true;
1160 : 6 : g_examine_done = false;
1161 : 6 : vbdev_lvs_examine_config(&g_bdev);
1162 [ - + ]: 6 : CU_ASSERT(g_examine_done);
1163 : :
1164 : 6 : g_examine_done = false;
1165 : 6 : }
1166 : :
1167 : : static void
1168 : 36 : ut_lvs_examine_check(bool success)
1169 : : {
1170 : : struct lvol_store_bdev *lvs_bdev;
1171 : :
1172 : : /* Examine was finished regardless of result */
1173 [ - + ]: 36 : CU_ASSERT(g_examine_done == true);
1174 : 36 : g_examine_done = false;
1175 : :
1176 [ + + ]: 36 : if (success) {
1177 [ - + ]: 24 : SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_spdk_lvol_pairs));
1178 : 24 : lvs_bdev = TAILQ_FIRST(&g_spdk_lvol_pairs);
1179 [ - + ]: 24 : SPDK_CU_ASSERT_FATAL(lvs_bdev != NULL);
1180 : 24 : g_lvol_store = lvs_bdev->lvs;
1181 [ - + ]: 24 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1182 [ - + ]: 24 : SPDK_CU_ASSERT_FATAL(g_lvol_store->blobstore != NULL);
1183 : 24 : CU_ASSERT(g_lvol_store->blobstore->esnap_bs_dev_create != NULL);
1184 : 24 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1185 : 24 : CU_ASSERT(g_lvol_store->lvols_opened == spdk_min(g_num_lvols, g_registered_bdevs));
1186 : : } else {
1187 [ - + ]: 12 : SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_spdk_lvol_pairs));
1188 : 12 : g_lvol_store = NULL;
1189 : : }
1190 : 36 : }
1191 : :
1192 : : static void
1193 : 6 : ut_lvol_examine_disk(void)
1194 : : {
1195 : : /* Examine unsuccessfully - bdev already opened */
1196 : 6 : g_lvserrno = -1;
1197 : 6 : lvol_already_opened = true;
1198 : 6 : vbdev_lvs_examine_disk(&g_bdev);
1199 : 6 : ut_lvs_examine_check(false);
1200 : :
1201 : : /* Examine unsuccessfully - fail on lvol store */
1202 : 6 : g_lvserrno = -1;
1203 : 6 : lvol_already_opened = false;
1204 : 6 : vbdev_lvs_examine_disk(&g_bdev);
1205 : 6 : ut_lvs_examine_check(false);
1206 : :
1207 : : /* Examine successfully
1208 : : * - one lvol fails to load
1209 : : * - lvs is loaded with no lvols present */
1210 : 6 : g_lvserrno = 0;
1211 : 6 : g_lvolerrno = -1;
1212 : 6 : g_num_lvols = 1;
1213 : 6 : lvol_already_opened = false;
1214 : 6 : g_registered_bdevs = 0;
1215 : 6 : vbdev_lvs_examine_disk(&g_bdev);
1216 : 6 : ut_lvs_examine_check(true);
1217 : 6 : CU_ASSERT(g_registered_bdevs == 0);
1218 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_lvol_store->lvols));
1219 : 6 : vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL);
1220 : 6 : CU_ASSERT(g_lvserrno == 0);
1221 : 6 : CU_ASSERT(g_lvol_store == NULL);
1222 : :
1223 : : /* Examine successfully */
1224 : 6 : g_lvserrno = 0;
1225 : 6 : g_lvolerrno = 0;
1226 : 6 : g_registered_bdevs = 0;
1227 : 6 : lvol_already_opened = false;
1228 : 6 : vbdev_lvs_examine_disk(&g_bdev);
1229 : 6 : ut_lvs_examine_check(true);
1230 : 6 : CU_ASSERT(g_registered_bdevs != 0);
1231 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols));
1232 : 6 : vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL);
1233 : 6 : CU_ASSERT(g_lvserrno == 0);
1234 : :
1235 : : /* Examine multiple lvols successfully */
1236 : 6 : g_num_lvols = 4;
1237 : 6 : g_registered_bdevs = 0;
1238 : 6 : lvol_already_opened = false;
1239 : 6 : vbdev_lvs_examine_disk(&g_bdev);
1240 : 6 : ut_lvs_examine_check(true);
1241 : 6 : CU_ASSERT(g_registered_bdevs == g_num_lvols);
1242 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols));
1243 : 6 : vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL);
1244 : 6 : CU_ASSERT(g_lvserrno == 0);
1245 : :
1246 : : /* Examine multiple lvols successfully - fail one with -ENOMEM on lvol open */
1247 : 6 : g_num_lvols = 4;
1248 : 6 : g_lvol_open_enomem = 2;
1249 : 6 : g_registered_bdevs = 0;
1250 : 6 : lvol_already_opened = false;
1251 : 6 : vbdev_lvs_examine_disk(&g_bdev);
1252 : 6 : ut_lvs_examine_check(true);
1253 : 6 : CU_ASSERT(g_registered_bdevs == g_num_lvols);
1254 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_lvol_store->lvols));
1255 : 6 : vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL);
1256 : 6 : CU_ASSERT(g_lvserrno == 0);
1257 : 6 : }
1258 : :
1259 : : static void
1260 : 6 : ut_lvol_rename(void)
1261 : : {
1262 : : struct spdk_lvol_store *lvs;
1263 : : struct spdk_lvol *lvol;
1264 : : struct spdk_lvol *lvol2;
1265 : 6 : int sz = 10;
1266 : : int rc;
1267 : :
1268 : : /* Lvol store is successfully created */
1269 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1270 : : lvol_store_op_with_handle_complete, NULL);
1271 : 6 : CU_ASSERT(rc == 0);
1272 : 6 : CU_ASSERT(g_lvserrno == 0);
1273 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1274 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1275 : 6 : lvs = g_lvol_store;
1276 : :
1277 : : /* Successful lvols create */
1278 : 6 : g_lvolerrno = -1;
1279 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1280 : : NULL);
1281 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1282 : 6 : CU_ASSERT(g_lvol != NULL);
1283 : 6 : CU_ASSERT(g_lvolerrno == 0);
1284 : 6 : lvol = g_lvol;
1285 : :
1286 : 6 : g_lvolerrno = -1;
1287 : 6 : rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1288 : : NULL);
1289 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1290 : 6 : CU_ASSERT(g_lvol != NULL);
1291 : 6 : CU_ASSERT(g_lvolerrno == 0);
1292 : 6 : lvol2 = g_lvol;
1293 : :
1294 : : /* Successful rename lvol */
1295 : 6 : vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL);
1296 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0);
1297 [ - + ]: 6 : CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name");
1298 : :
1299 : : /* Renaming lvol with name already existing */
1300 : 6 : g_bdev_alias_already_exists = true;
1301 : 6 : vbdev_lvol_rename(lvol2, "new_lvol_name", vbdev_lvol_rename_complete, NULL);
1302 : 6 : g_bdev_alias_already_exists = false;
1303 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvolerrno != 0);
1304 [ - + ]: 6 : CU_ASSERT_STRING_NOT_EQUAL(lvol2->name, "new_lvol_name");
1305 : :
1306 : : /* Renaming lvol with it's own name */
1307 : 6 : vbdev_lvol_rename(lvol, "new_lvol_name", vbdev_lvol_rename_complete, NULL);
1308 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvolerrno == 0);
1309 [ - + ]: 6 : CU_ASSERT_STRING_EQUAL(lvol->name, "new_lvol_name");
1310 : :
1311 : : /* Successful lvols destroy */
1312 : 6 : vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL);
1313 : 6 : CU_ASSERT(g_lvol == NULL);
1314 : :
1315 : 6 : vbdev_lvol_destroy(lvol2, lvol_store_op_complete, NULL);
1316 : 6 : CU_ASSERT(g_lvol == NULL);
1317 : :
1318 : : /* Destroy lvol store */
1319 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
1320 : 6 : CU_ASSERT(g_lvserrno == 0);
1321 : 6 : CU_ASSERT(g_lvol_store == NULL);
1322 : 6 : }
1323 : :
1324 : : static void
1325 : 6 : ut_bdev_finish(void)
1326 : : {
1327 : : struct spdk_lvol_store *lvs;
1328 : : struct spdk_lvol *lvol;
1329 : : struct spdk_lvol *lvol2;
1330 : 6 : int sz = 10;
1331 : : int rc;
1332 : :
1333 : : /* Scenario 1
1334 : : * Test unload of lvs with no lvols during bdev finish. */
1335 : :
1336 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1337 : : lvol_store_op_with_handle_complete, NULL);
1338 : 6 : CU_ASSERT(rc == 0);
1339 : 6 : CU_ASSERT(g_lvserrno == 0);
1340 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1341 : 6 : lvs = g_lvol_store;
1342 : :
1343 : : /* Start bdev finish */
1344 : 6 : vbdev_lvs_fini_start();
1345 [ - + ]: 6 : CU_ASSERT(g_shutdown_started == true);
1346 : :
1347 : : /* During shutdown, lvs with no lvols should be unloaded */
1348 : 6 : CU_ASSERT(g_lvol_store == NULL);
1349 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs));
1350 : :
1351 : : /* Revert module state back to normal */
1352 : 6 : g_shutdown_started = false;
1353 : :
1354 : : /* Scenario 2
1355 : : * Test creating lvs with two lvols. Delete first lvol explicitly,
1356 : : * then start bdev finish. This should unload the remaining lvol and
1357 : : * lvol store. */
1358 : :
1359 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1360 : : lvol_store_op_with_handle_complete, NULL);
1361 : 6 : CU_ASSERT(rc == 0);
1362 : 6 : CU_ASSERT(g_lvserrno == 0);
1363 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1364 : 6 : lvs = g_lvol_store;
1365 : :
1366 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT,
1367 : : vbdev_lvol_create_complete, NULL);
1368 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1369 : 6 : CU_ASSERT(g_lvol != NULL);
1370 : 6 : CU_ASSERT(g_lvolerrno == 0);
1371 : 6 : lvol = g_lvol;
1372 : :
1373 : 6 : rc = vbdev_lvol_create(lvs, "lvol2", sz, false, LVOL_CLEAR_WITH_DEFAULT,
1374 : : vbdev_lvol_create_complete, NULL);
1375 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(rc == 0);
1376 : 6 : CU_ASSERT(g_lvol != NULL);
1377 : 6 : CU_ASSERT(g_lvolerrno == 0);
1378 : 6 : lvol2 = g_lvol;
1379 : :
1380 : : /* Destroy explicitly first lvol */
1381 : 6 : vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL);
1382 : 6 : CU_ASSERT(g_lvol == NULL);
1383 : 6 : CU_ASSERT(g_lvolerrno == 0);
1384 : :
1385 : : /* Start bdev finish and unregister remaining lvol */
1386 : 6 : vbdev_lvs_fini_start();
1387 [ - + ]: 6 : CU_ASSERT(g_shutdown_started == true);
1388 : 6 : spdk_bdev_unregister(lvol2->bdev, _spdk_bdev_unregister_cb, NULL);
1389 : :
1390 : : /* During shutdown, removal of last lvol should unload lvs */
1391 : 6 : CU_ASSERT(g_lvol_store == NULL);
1392 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_spdk_lvol_pairs));
1393 : :
1394 : : /* Revert module state back to normal */
1395 : 6 : g_shutdown_started = false;
1396 : 6 : }
1397 : :
1398 : : static void
1399 : 6 : ut_lvol_resize(void)
1400 : : {
1401 : : struct spdk_lvol_store *lvs;
1402 : : struct spdk_lvol *lvol;
1403 : 6 : int sz = 10;
1404 : 6 : int rc = 0;
1405 : :
1406 : : /* Lvol store is successfully created */
1407 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1408 : : lvol_store_op_with_handle_complete, NULL);
1409 : 6 : CU_ASSERT(rc == 0);
1410 : 6 : CU_ASSERT(g_lvserrno == 0);
1411 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1412 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1413 : 6 : lvs = g_lvol_store;
1414 : :
1415 : : /* Successful lvol create */
1416 : 6 : g_lvolerrno = -1;
1417 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1418 : : NULL);
1419 : 6 : CU_ASSERT(rc == 0);
1420 : 6 : CU_ASSERT(g_lvolerrno == 0);
1421 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1422 : 6 : lvol = g_lvol;
1423 : :
1424 : : /* Successful lvol resize */
1425 : 6 : g_lvolerrno = -1;
1426 : 6 : vbdev_lvol_resize(lvol, 20, vbdev_lvol_resize_complete, NULL);
1427 : 6 : CU_ASSERT(g_lvolerrno == 0);
1428 [ - + ]: 6 : CU_ASSERT(lvol->bdev->blockcnt == 20 * g_cluster_size / lvol->bdev->blocklen);
1429 : :
1430 : : /* Resize with NULL lvol */
1431 : 6 : vbdev_lvol_resize(NULL, 20, vbdev_lvol_resize_complete, NULL);
1432 : 6 : CU_ASSERT(g_lvolerrno != 0);
1433 : :
1434 : : /* Successful lvol destroy */
1435 : 6 : vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL);
1436 : 6 : CU_ASSERT(g_lvol == NULL);
1437 : :
1438 : : /* Destroy lvol store */
1439 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
1440 : 6 : CU_ASSERT(g_lvserrno == 0);
1441 : 6 : CU_ASSERT(g_lvol_store == NULL);
1442 : 6 : }
1443 : :
1444 : : static void
1445 : 6 : ut_lvol_set_read_only(void)
1446 : : {
1447 : : struct spdk_lvol_store *lvs;
1448 : : struct spdk_lvol *lvol;
1449 : 6 : int sz = 10;
1450 : 6 : int rc = 0;
1451 : :
1452 : : /* Lvol store is successfully created */
1453 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1454 : : lvol_store_op_with_handle_complete, NULL);
1455 : 6 : CU_ASSERT(rc == 0);
1456 : 6 : CU_ASSERT(g_lvserrno == 0);
1457 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1458 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1459 : 6 : lvs = g_lvol_store;
1460 : :
1461 : : /* Successful lvol create */
1462 : 6 : g_lvolerrno = -1;
1463 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1464 : : NULL);
1465 : 6 : CU_ASSERT(rc == 0);
1466 : 6 : CU_ASSERT(g_lvolerrno == 0);
1467 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1468 : 6 : lvol = g_lvol;
1469 : :
1470 : : /* Successful set lvol as read only */
1471 : 6 : g_lvolerrno = -1;
1472 : 6 : vbdev_lvol_set_read_only(lvol, vbdev_lvol_set_read_only_complete, NULL);
1473 : 6 : CU_ASSERT(g_lvolerrno == 0);
1474 : :
1475 : : /* Successful lvol destroy */
1476 : 6 : vbdev_lvol_destroy(lvol, lvol_store_op_complete, NULL);
1477 : 6 : CU_ASSERT(g_lvol == NULL);
1478 : :
1479 : : /* Destroy lvol store */
1480 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
1481 : 6 : CU_ASSERT(g_lvserrno == 0);
1482 : 6 : CU_ASSERT(g_lvol_store == NULL);
1483 : 6 : }
1484 : :
1485 : : static void
1486 : 6 : ut_lvs_unload(void)
1487 : : {
1488 : 6 : int rc = 0;
1489 : 6 : int sz = 10;
1490 : : struct spdk_lvol_store *lvs;
1491 : :
1492 : : /* Lvol store is successfully created */
1493 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1494 : : lvol_store_op_with_handle_complete, NULL);
1495 : 6 : CU_ASSERT(rc == 0);
1496 : 6 : CU_ASSERT(g_lvserrno == 0);
1497 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1498 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1499 : :
1500 : 6 : lvs = g_lvol_store;
1501 : 6 : g_lvol_store = NULL;
1502 : :
1503 : 6 : spdk_uuid_generate(&lvs->uuid);
1504 : :
1505 : : /* Successfully create lvol, which should be destroyed with lvs later */
1506 : 6 : g_lvolerrno = -1;
1507 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1508 : : NULL);
1509 : 6 : CU_ASSERT(rc == 0);
1510 : 6 : CU_ASSERT(g_lvolerrno == 0);
1511 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1512 : :
1513 : : /* Unload lvol store */
1514 : 6 : vbdev_lvs_unload(lvs, lvol_store_op_complete, NULL);
1515 : 6 : CU_ASSERT(g_lvserrno == 0);
1516 : 6 : CU_ASSERT(g_lvol_store == NULL);
1517 : 6 : CU_ASSERT(g_lvol != NULL);
1518 : 6 : }
1519 : :
1520 : : static void
1521 : 6 : ut_lvs_init(void)
1522 : : {
1523 : 6 : int rc = 0;
1524 : : struct spdk_lvol_store *lvs;
1525 : :
1526 : : /* spdk_lvs_init() fails */
1527 : 6 : lvol_store_initialize_fail = true;
1528 : :
1529 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1530 : : lvol_store_op_with_handle_complete, NULL);
1531 : 6 : CU_ASSERT(rc != 0);
1532 : 6 : CU_ASSERT(g_lvserrno == 0);
1533 : 6 : CU_ASSERT(g_lvol_store == NULL);
1534 : :
1535 : 6 : lvol_store_initialize_fail = false;
1536 : :
1537 : : /* spdk_lvs_init_cb() fails */
1538 : 6 : lvol_store_initialize_cb_fail = true;
1539 : :
1540 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1541 : : lvol_store_op_with_handle_complete, NULL);
1542 : 6 : CU_ASSERT(rc == 0);
1543 : 6 : CU_ASSERT(g_lvserrno != 0);
1544 : 6 : CU_ASSERT(g_lvol_store == NULL);
1545 : :
1546 : 6 : lvol_store_initialize_cb_fail = false;
1547 : :
1548 : : /* Lvol store is successfully created */
1549 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1550 : : lvol_store_op_with_handle_complete, NULL);
1551 : 6 : CU_ASSERT(rc == 0);
1552 : 6 : CU_ASSERT(g_lvserrno == 0);
1553 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1554 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1555 : :
1556 : 6 : lvs = g_lvol_store;
1557 : 6 : g_lvol_store = NULL;
1558 : :
1559 : : /* Bdev with lvol store already claimed */
1560 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1561 : : lvol_store_op_with_handle_complete, NULL);
1562 : 6 : CU_ASSERT(rc != 0);
1563 : 6 : CU_ASSERT(g_lvserrno == 0);
1564 : 6 : CU_ASSERT(g_lvol_store == NULL);
1565 : :
1566 : : /* Destruct lvol store */
1567 : 6 : vbdev_lvs_destruct(lvs, lvol_store_op_complete, NULL);
1568 : 6 : CU_ASSERT(g_lvserrno == 0);
1569 : 6 : CU_ASSERT(g_lvol_store == NULL);
1570 : 6 : }
1571 : :
1572 : : static void
1573 : 6 : ut_vbdev_lvol_get_io_channel(void)
1574 : : {
1575 : : struct spdk_io_channel *ch;
1576 : :
1577 : 6 : g_lvol = calloc(1, sizeof(struct spdk_lvol));
1578 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1579 : :
1580 : 6 : ch = vbdev_lvol_get_io_channel(g_lvol);
1581 : 6 : CU_ASSERT(ch == g_ch);
1582 : :
1583 : 6 : free(g_lvol);
1584 : 6 : }
1585 : :
1586 : : static void
1587 : 6 : ut_vbdev_lvol_io_type_supported(void)
1588 : : {
1589 : : struct spdk_lvol *lvol;
1590 : : bool ret;
1591 : :
1592 : 6 : lvol = calloc(1, sizeof(struct spdk_lvol));
1593 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(lvol != NULL);
1594 : :
1595 : 6 : g_blob_is_read_only = false;
1596 : :
1597 : : /* Supported types */
1598 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ);
1599 : 6 : CU_ASSERT(ret == true);
1600 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE);
1601 : 6 : CU_ASSERT(ret == true);
1602 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET);
1603 : 6 : CU_ASSERT(ret == true);
1604 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP);
1605 : 6 : CU_ASSERT(ret == true);
1606 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES);
1607 : 6 : CU_ASSERT(ret == true);
1608 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA);
1609 : 6 : CU_ASSERT(ret == true);
1610 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE);
1611 : 6 : CU_ASSERT(ret == true);
1612 : :
1613 : : /* Unsupported types */
1614 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH);
1615 : 6 : CU_ASSERT(ret == false);
1616 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN);
1617 : 6 : CU_ASSERT(ret == false);
1618 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO);
1619 : 6 : CU_ASSERT(ret == false);
1620 : :
1621 : 6 : g_blob_is_read_only = true;
1622 : :
1623 : : /* Supported types */
1624 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_READ);
1625 : 6 : CU_ASSERT(ret == true);
1626 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_RESET);
1627 : 6 : CU_ASSERT(ret == true);
1628 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_DATA);
1629 : 6 : CU_ASSERT(ret == true);
1630 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_SEEK_HOLE);
1631 : 6 : CU_ASSERT(ret == true);
1632 : :
1633 : : /* Unsupported types */
1634 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE);
1635 : 6 : CU_ASSERT(ret == false);
1636 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_UNMAP);
1637 : 6 : CU_ASSERT(ret == false);
1638 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_WRITE_ZEROES);
1639 : 6 : CU_ASSERT(ret == false);
1640 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_FLUSH);
1641 : 6 : CU_ASSERT(ret == false);
1642 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_ADMIN);
1643 : 6 : CU_ASSERT(ret == false);
1644 : 6 : ret = vbdev_lvol_io_type_supported(lvol, SPDK_BDEV_IO_TYPE_NVME_IO);
1645 : 6 : CU_ASSERT(ret == false);
1646 : :
1647 : 6 : free(lvol);
1648 : 6 : }
1649 : :
1650 : : static void
1651 : 6 : ut_lvol_read_write(void)
1652 : : {
1653 : 6 : g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size());
1654 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_io != NULL);
1655 : 6 : g_base_bdev = calloc(1, sizeof(struct spdk_bdev));
1656 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL);
1657 : 6 : g_lvol = calloc(1, sizeof(struct spdk_lvol));
1658 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1659 : :
1660 : 6 : g_io->bdev = g_base_bdev;
1661 : 6 : g_io->bdev->ctxt = g_lvol;
1662 : 6 : g_io->u.bdev.offset_blocks = 20;
1663 : 6 : g_io->u.bdev.num_blocks = 20;
1664 : :
1665 : 6 : lvol_read(g_ch, g_io);
1666 : 6 : CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS);
1667 : :
1668 : 6 : lvol_write(g_lvol, g_ch, g_io);
1669 : 6 : CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS);
1670 : :
1671 : 6 : g_ext_api_called = false;
1672 : 6 : lvol_read(g_ch, g_io);
1673 : 6 : CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS);
1674 [ - + ]: 6 : CU_ASSERT(g_ext_api_called == true);
1675 : 6 : g_ext_api_called = false;
1676 : :
1677 : 6 : lvol_write(g_lvol, g_ch, g_io);
1678 : 6 : CU_ASSERT(g_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS);
1679 [ - + ]: 6 : CU_ASSERT(g_ext_api_called == true);
1680 : 6 : g_ext_api_called = false;
1681 : :
1682 : 6 : free(g_io);
1683 : 6 : free(g_base_bdev);
1684 : 6 : free(g_lvol);
1685 : 6 : }
1686 : :
1687 : : static void
1688 : 6 : ut_vbdev_lvol_submit_request(void)
1689 : : {
1690 : 6 : struct spdk_lvol request_lvol = {};
1691 : 6 : g_io = calloc(1, sizeof(struct spdk_bdev_io));
1692 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_io != NULL);
1693 : 6 : g_base_bdev = calloc(1, sizeof(struct spdk_bdev));
1694 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL);
1695 : 6 : g_io->bdev = g_base_bdev;
1696 : :
1697 : 6 : g_io->type = SPDK_BDEV_IO_TYPE_READ;
1698 : 6 : g_base_bdev->ctxt = &request_lvol;
1699 : 6 : vbdev_lvol_submit_request(g_ch, g_io);
1700 : :
1701 : 6 : free(g_io);
1702 : 6 : free(g_base_bdev);
1703 : 6 : }
1704 : :
1705 : : static void
1706 : 6 : ut_lvs_rename(void)
1707 : : {
1708 : 6 : int rc = 0;
1709 : 6 : int sz = 10;
1710 : : struct spdk_lvol_store *lvs;
1711 : :
1712 : : /* Lvol store is successfully created */
1713 : 6 : rc = vbdev_lvs_create("bdev", "old_lvs_name", 0, LVS_CLEAR_WITH_UNMAP, 0,
1714 : : lvol_store_op_with_handle_complete, NULL);
1715 : 6 : CU_ASSERT(rc == 0);
1716 : 6 : CU_ASSERT(g_lvserrno == 0);
1717 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1718 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1719 : :
1720 : 6 : lvs = g_lvol_store;
1721 : 6 : g_lvol_store = NULL;
1722 : :
1723 : 6 : g_base_bdev = calloc(1, sizeof(*g_base_bdev));
1724 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL);
1725 : :
1726 : : /* Successfully create lvol, which should be destroyed with lvs later */
1727 : 6 : g_lvolerrno = -1;
1728 : 6 : rc = vbdev_lvol_create(lvs, "lvol", sz, false, LVOL_CLEAR_WITH_DEFAULT, vbdev_lvol_create_complete,
1729 : : NULL);
1730 : 6 : CU_ASSERT(rc == 0);
1731 : 6 : CU_ASSERT(g_lvolerrno == 0);
1732 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1733 : :
1734 : : /* Trying to rename lvs with lvols created */
1735 : 6 : vbdev_lvs_rename(lvs, "new_lvs_name", lvol_store_op_complete, NULL);
1736 : 6 : CU_ASSERT(g_lvserrno == 0);
1737 [ - + ]: 6 : CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name");
1738 [ - + ]: 6 : CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol");
1739 : :
1740 : : /* Trying to rename lvs with name already used by another lvs */
1741 : : /* This is a bdev_lvol test, so g_lvs_with_name_already_exists simulates
1742 : : * existing lvs with name 'another_new_lvs_name' and this name in fact is not compared */
1743 : 6 : g_lvs_with_name_already_exists = true;
1744 : 6 : vbdev_lvs_rename(lvs, "another_new_lvs_name", lvol_store_op_complete, NULL);
1745 : 6 : CU_ASSERT(g_lvserrno == -EEXIST);
1746 [ - + ]: 6 : CU_ASSERT_STRING_EQUAL(lvs->name, "new_lvs_name");
1747 [ - + ]: 6 : CU_ASSERT_STRING_EQUAL(TAILQ_FIRST(&g_lvol->bdev->aliases)->alias.name, "new_lvs_name/lvol");
1748 : 6 : g_lvs_with_name_already_exists = false;
1749 : :
1750 : : /* Unload lvol store */
1751 : 6 : g_lvol_store = lvs;
1752 : 6 : vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL);
1753 : 6 : CU_ASSERT(g_lvserrno == 0);
1754 : 6 : CU_ASSERT(g_lvol_store == NULL);
1755 : :
1756 : 6 : free(g_base_bdev->name);
1757 : 6 : free(g_base_bdev);
1758 : 6 : }
1759 : :
1760 : : static void
1761 : 6 : ut_lvol_seek(void)
1762 : : {
1763 : 6 : g_io = calloc(1, sizeof(struct spdk_bdev_io) + vbdev_lvs_get_ctx_size());
1764 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_io != NULL);
1765 : 6 : g_base_bdev = calloc(1, sizeof(struct spdk_bdev));
1766 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_base_bdev != NULL);
1767 : 6 : g_lvol = calloc(1, sizeof(struct spdk_lvol));
1768 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol != NULL);
1769 : :
1770 : 6 : g_io->bdev = g_base_bdev;
1771 : 6 : g_io->bdev->ctxt = g_lvol;
1772 : :
1773 : : /* Data found */
1774 : 6 : g_io->u.bdev.offset_blocks = 10;
1775 : 6 : lvol_seek_data(g_lvol, g_io);
1776 : 6 : CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS);
1777 : 6 : CU_ASSERT(g_io->u.bdev.seek.offset == g_blob_allocated_io_unit_offset);
1778 : :
1779 : : /* Data not found */
1780 : 6 : g_io->u.bdev.offset_blocks = 30;
1781 : 6 : lvol_seek_data(g_lvol, g_io);
1782 : 6 : CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS);
1783 : 6 : CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX);
1784 : :
1785 : : /* Hole found */
1786 : 6 : g_io->u.bdev.offset_blocks = 10;
1787 : 6 : lvol_seek_hole(g_lvol, g_io);
1788 : 6 : CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS);
1789 : 6 : CU_ASSERT(g_io->u.bdev.seek.offset == 10);
1790 : :
1791 : : /* Hole not found */
1792 : 6 : g_io->u.bdev.offset_blocks = 30;
1793 : 6 : lvol_seek_hole(g_lvol, g_io);
1794 : 6 : CU_ASSERT(g_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS);
1795 : 6 : CU_ASSERT(g_io->u.bdev.seek.offset == UINT64_MAX);
1796 : :
1797 : 6 : free(g_io);
1798 : 6 : free(g_base_bdev);
1799 : 6 : free(g_lvol);
1800 : 6 : }
1801 : :
1802 : : static void
1803 : 6 : ut_esnap_dev_create(void)
1804 : : {
1805 : 6 : struct spdk_lvol_store lvs = { 0 };
1806 : 6 : struct spdk_lvol lvol = { 0 };
1807 : 6 : struct spdk_blob blob = { 0 };
1808 : 6 : struct spdk_bdev bdev = { 0 };
1809 : 6 : const char uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4";
1810 : 6 : char bad_uuid_str[SPDK_UUID_STRING_LEN] = "a27fd8fe-d4b9-431e-a044-271016228ce4";
1811 : : char *unterminated;
1812 : : size_t len;
1813 : 6 : struct spdk_bs_dev *bs_dev = NULL;
1814 : : int rc;
1815 : :
1816 : 6 : bdev.name = "bdev0";
1817 : 6 : spdk_uuid_parse(&bdev.uuid, uuid_str);
1818 : :
1819 : : /* NULL esnap_id */
1820 : 6 : rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, NULL, 0, &bs_dev);
1821 : 6 : CU_ASSERT(rc == -EINVAL);
1822 : 6 : CU_ASSERT(bs_dev == NULL);
1823 : :
1824 : : /* Unterminated UUID: asan should catch reads past end of allocated buffer. */
1825 : 6 : len = strlen(uuid_str);
1826 : 6 : unterminated = calloc(1, len);
1827 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(unterminated != NULL);
1828 [ - + - + ]: 6 : memcpy(unterminated, uuid_str, len);
1829 : 6 : rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, unterminated, len, &bs_dev);
1830 : 6 : CU_ASSERT(rc == -EINVAL);
1831 : 6 : CU_ASSERT(bs_dev == NULL);
1832 : :
1833 : : /* Invaid UUID but the right length is invalid */
1834 : 6 : bad_uuid_str[2] = 'z';
1835 : 6 : rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, bad_uuid_str, sizeof(uuid_str),
1836 : : &bs_dev);
1837 : 6 : CU_ASSERT(rc == -EINVAL);
1838 : 6 : CU_ASSERT(bs_dev == NULL);
1839 : :
1840 : : /* Bdev not found */
1841 : 6 : g_base_bdev = NULL;
1842 : 6 : MOCK_SET(spdk_lvol_is_degraded, true);
1843 : 6 : rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev);
1844 : 6 : CU_ASSERT(rc == 0);
1845 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(bs_dev != NULL);
1846 : 6 : CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy);
1847 : 6 : bs_dev->destroy(bs_dev);
1848 : :
1849 : : /* Cannot get a claim */
1850 : : /* TODO: This suggests we need a way to wait for a claim to be available. */
1851 : 6 : g_base_bdev = &bdev;
1852 : 6 : lvol_already_opened = true;
1853 : 6 : MOCK_SET(spdk_lvol_is_degraded, true);
1854 : 6 : rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev);
1855 : 6 : CU_ASSERT(rc == 0);
1856 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(bs_dev != NULL);
1857 : 6 : CU_ASSERT(bs_dev->destroy == bs_dev_degraded_destroy);
1858 : 6 : bs_dev->destroy(bs_dev);
1859 : :
1860 : : /* Happy path */
1861 : 6 : lvol_already_opened = false;
1862 : 6 : MOCK_SET(spdk_lvol_is_degraded, false);
1863 : 6 : rc = vbdev_lvol_esnap_dev_create(&lvs, &lvol, &blob, uuid_str, sizeof(uuid_str), &bs_dev);
1864 : 6 : CU_ASSERT(rc == 0);
1865 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(bs_dev != NULL);
1866 : 6 : CU_ASSERT(bs_dev->destroy == ut_bs_dev_destroy);
1867 : 6 : bs_dev->destroy(bs_dev);
1868 : :
1869 : 6 : g_base_bdev = NULL;
1870 : 6 : lvol_already_opened = false;
1871 : 6 : free(unterminated);
1872 : 6 : MOCK_CLEAR(spdk_lvol_is_degraded);
1873 : 6 : }
1874 : :
1875 : : static void
1876 : 6 : ut_lvol_esnap_clone_bad_args(void)
1877 : : {
1878 : 6 : struct spdk_bdev bdev = { 0 };
1879 : : struct spdk_lvol_store *lvs;
1880 : 6 : const char *esnap_uuid = "255f4236-9427-42d0-a9d1-aa17f37dd8db";
1881 : 6 : const char *esnap_name = "esnap1";
1882 : : int rc;
1883 : :
1884 : : /* Lvol store is successfully created */
1885 : 6 : rc = vbdev_lvs_create("bdev", "lvs", 0, LVS_CLEAR_WITH_UNMAP, 0,
1886 : : lvol_store_op_with_handle_complete, NULL);
1887 : 6 : CU_ASSERT(rc == 0);
1888 : 6 : CU_ASSERT(g_lvserrno == 0);
1889 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_lvol_store != NULL);
1890 : 6 : CU_ASSERT(g_lvol_store->bs_dev != NULL);
1891 : 6 : lvs = g_lvol_store;
1892 : :
1893 : 6 : rc = spdk_uuid_parse(&bdev.uuid, esnap_uuid);
1894 : 6 : CU_ASSERT(rc == 0);
1895 [ - + ]: 6 : bdev.name = strdup(esnap_name);
1896 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(bdev.name != NULL);
1897 : 6 : bdev.blocklen = 512;
1898 : 6 : bdev.blockcnt = 8192;
1899 : :
1900 : 6 : g_base_bdev = &bdev;
1901 : :
1902 : : /* Error when lvs is NULL */
1903 : 6 : g_lvolerrno = 0xbad;
1904 : 6 : vbdev_lvol_create_bdev_clone(esnap_uuid, NULL, "clone1", vbdev_lvol_create_complete, NULL);
1905 : 6 : CU_ASSERT(g_lvolerrno == -EINVAL);
1906 : :
1907 : : /* Error when the bdev does not exist */
1908 : 6 : g_base_bdev = NULL;
1909 : 6 : g_lvolerrno = 0xbad;
1910 : 6 : vbdev_lvol_create_bdev_clone(esnap_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL);
1911 : 6 : CU_ASSERT(g_lvolerrno == -ENODEV);
1912 : :
1913 : : /* Success when creating by bdev UUID */
1914 : 6 : g_base_bdev = &bdev;
1915 : 6 : g_lvolerrno = 0xbad;
1916 : 6 : vbdev_lvol_create_bdev_clone(esnap_uuid, lvs, "clone1", vbdev_lvol_create_complete, NULL);
1917 : 6 : CU_ASSERT(g_lvolerrno == 0);
1918 : :
1919 : : /* Success when creating by bdev name */
1920 : 6 : g_lvolerrno = 0xbad;
1921 : 6 : vbdev_lvol_create_bdev_clone(esnap_name, lvs, "clone2", vbdev_lvol_create_complete, NULL);
1922 : 6 : CU_ASSERT(g_lvolerrno == 0);
1923 : :
1924 : 6 : g_lvol_store = lvs;
1925 : 6 : vbdev_lvs_destruct(g_lvol_store, lvol_store_op_complete, NULL);
1926 : 6 : CU_ASSERT(g_lvserrno == 0);
1927 : 6 : CU_ASSERT(g_lvol_store == NULL);
1928 : :
1929 : 6 : free(bdev.name);
1930 : 6 : g_base_bdev = NULL;
1931 : 6 : }
1932 : :
1933 : : int
1934 : 6 : main(int argc, char **argv)
1935 : : {
1936 : 6 : CU_pSuite suite = NULL;
1937 : : unsigned int num_failures;
1938 : :
1939 : 6 : CU_initialize_registry();
1940 : :
1941 : 6 : suite = CU_add_suite("lvol", NULL, NULL);
1942 : :
1943 : 6 : CU_ADD_TEST(suite, ut_lvs_init);
1944 : 6 : CU_ADD_TEST(suite, ut_lvol_init);
1945 : 6 : CU_ADD_TEST(suite, ut_lvol_snapshot);
1946 : 6 : CU_ADD_TEST(suite, ut_lvol_clone);
1947 : 6 : CU_ADD_TEST(suite, ut_lvs_destroy);
1948 : 6 : CU_ADD_TEST(suite, ut_lvs_unload);
1949 : 6 : CU_ADD_TEST(suite, ut_lvol_resize);
1950 : 6 : CU_ADD_TEST(suite, ut_lvol_set_read_only);
1951 : 6 : CU_ADD_TEST(suite, ut_lvol_hotremove);
1952 : 6 : CU_ADD_TEST(suite, ut_vbdev_lvol_get_io_channel);
1953 : 6 : CU_ADD_TEST(suite, ut_vbdev_lvol_io_type_supported);
1954 : 6 : CU_ADD_TEST(suite, ut_lvol_read_write);
1955 : 6 : CU_ADD_TEST(suite, ut_vbdev_lvol_submit_request);
1956 : 6 : CU_ADD_TEST(suite, ut_lvol_examine_config);
1957 : 6 : CU_ADD_TEST(suite, ut_lvol_examine_disk);
1958 : 6 : CU_ADD_TEST(suite, ut_lvol_rename);
1959 : 6 : CU_ADD_TEST(suite, ut_bdev_finish);
1960 : 6 : CU_ADD_TEST(suite, ut_lvs_rename);
1961 : 6 : CU_ADD_TEST(suite, ut_lvol_seek);
1962 : 6 : CU_ADD_TEST(suite, ut_esnap_dev_create);
1963 : 6 : CU_ADD_TEST(suite, ut_lvol_esnap_clone_bad_args);
1964 : :
1965 : 6 : allocate_threads(1);
1966 : 6 : set_thread(0);
1967 : :
1968 : 6 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
1969 : 6 : CU_cleanup_registry();
1970 : :
1971 : 6 : free_threads();
1972 : :
1973 : 6 : return num_failures;
1974 : : }
|