LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/bdev/vbdev_lvol.c - vbdev_lvol_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 1000 1080 92.6 %
Date: 2024-07-11 01:03:03 Functions: 90 110 81.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 181 308 58.8 %

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

Generated by: LCOV version 1.14