LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/nvme/nvme_cuse.c - nvme_cuse_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 382 405 94.3 %
Date: 2024-11-18 09:04:25 Functions: 23 45 51.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 566 1858 30.5 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2021 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : #include "spdk_internal/cunit.h"
       8                 :            : #include "nvme/nvme_cuse.c"
       9                 :            : #include "common/lib/nvme/common_stubs.h"
      10                 :            : 
      11                 :          6 : SPDK_LOG_REGISTER_COMPONENT(nvme)
      12                 :            : 
      13                 :          0 : DEFINE_STUB(spdk_nvme_ctrlr_cmd_admin_raw, int, (struct spdk_nvme_ctrlr *ctrlr,
      14                 :            :                 struct spdk_nvme_cmd *cmd, void *buf, uint32_t len,
      15                 :            :                 spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
      16                 :            : 
      17                 :          0 : DEFINE_STUB(spdk_nvme_ctrlr_cmd_io_raw_with_md, int, (struct spdk_nvme_ctrlr *ctrlr,
      18                 :            :                 struct spdk_nvme_qpair *qpair, struct spdk_nvme_cmd *cmd, void *buf, uint32_t len, void *md_buf,
      19                 :            :                 spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
      20                 :            : 
      21                 :          0 : DEFINE_STUB(spdk_nvme_ctrlr_reset, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
      22                 :            : 
      23                 :          0 : DEFINE_STUB(spdk_nvme_ctrlr_reset_subsystem, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
      24                 :            : 
      25                 :          0 : DEFINE_STUB(spdk_nvme_ns_cmd_read_with_md, int, (struct spdk_nvme_ns *ns,
      26                 :            :                 struct spdk_nvme_qpair *qpair,
      27                 :            :                 void *payload, void *metadata,
      28                 :            :                 uint64_t lba, uint32_t lba_count, spdk_nvme_cmd_cb cb_fn, void *cb_arg,
      29                 :            :                 uint32_t io_flags, uint16_t apptag_mask, uint16_t apptag), 0);
      30                 :            : 
      31                 :          0 : DEFINE_STUB(spdk_nvme_ns_cmd_write_with_md, int, (struct spdk_nvme_ns *ns,
      32                 :            :                 struct spdk_nvme_qpair *qpair,
      33                 :            :                 void *payload, void *metadata,
      34                 :            :                 uint64_t lba, uint32_t lba_count, spdk_nvme_cmd_cb cb_fn, void *cb_arg,
      35                 :            :                 uint32_t io_flags, uint16_t apptag_mask, uint16_t apptag), 0);
      36                 :            : 
      37                 :          0 : DEFINE_STUB(spdk_nvme_ns_get_num_sectors, uint64_t,
      38                 :            :             (struct spdk_nvme_ns *ns), 0);
      39                 :            : 
      40                 :         18 : DEFINE_STUB(spdk_nvme_ns_get_md_size, uint32_t, (struct spdk_nvme_ns *ns), 0);
      41                 :            : 
      42                 :          0 : DEFINE_STUB_V(spdk_unaffinitize_thread, (void));
      43                 :            : 
      44                 :          0 : DEFINE_STUB(nvme_io_msg_ctrlr_register, int,
      45                 :            :             (struct spdk_nvme_ctrlr *ctrlr,
      46                 :            :              struct nvme_io_msg_producer *io_msg_producer), 0);
      47                 :            : 
      48                 :          0 : DEFINE_STUB_V(nvme_io_msg_ctrlr_unregister,
      49                 :            :               (struct spdk_nvme_ctrlr *ctrlr,
      50                 :            :                struct nvme_io_msg_producer *io_msg_producer));
      51                 :            : 
      52         [ #  # ]:          0 : DEFINE_STUB(spdk_nvme_ctrlr_is_active_ns, bool,
      53                 :            :             (struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid), true);
      54                 :            : 
      55                 :         12 : DEFINE_STUB(fuse_reply_err, int, (fuse_req_t req, int err), 0);
      56                 :          6 : DEFINE_STUB_V(fuse_session_exit, (struct fuse_session *se));
      57                 :         18 : DEFINE_STUB(pthread_join, int, (pthread_t tid, void **val), 0);
      58                 :            : 
      59                 :          0 : DEFINE_STUB_V(nvme_ctrlr_update_namespaces, (struct spdk_nvme_ctrlr *ctrlr));
      60                 :            : 
      61                 :            : static int
      62                 :         18 : nvme_ns_cmp(struct spdk_nvme_ns *ns1, struct spdk_nvme_ns *ns2)
      63                 :            : {
      64   [ +  -  +  -  :         18 :         return ns1->id - ns2->id;
             +  -  +  - ]
      65                 :            : }
      66                 :            : 
      67   [ +  +  +  +  :         30 : RB_GENERATE_STATIC(nvme_ns_tree, spdk_nvme_ns, node, nvme_ns_cmp);
          +  +  +  -  -  
          -  +  -  -  -  
          -  +  -  -  -  
          -  -  -  +  -  
          +  -  -  +  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          +  -  +  +  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  +  
          +  -  +  -  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  -  +  
          +  -  +  -  +  
          -  +  -  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  -  + ]
      68                 :            : 
      69                 :            : struct cuse_io_ctx *g_ut_ctx;
      70                 :            : struct spdk_nvme_ctrlr *g_ut_ctrlr;
      71                 :            : uint32_t g_ut_nsid;
      72                 :            : 
      73                 :            : uint32_t
      74                 :          0 : spdk_nvme_ctrlr_get_num_ns(struct spdk_nvme_ctrlr *ctrlr)
      75                 :            : {
      76   [ #  #  #  #  :          0 :         return ctrlr->cdata.nn;
                   #  # ]
      77                 :            : }
      78                 :            : 
      79                 :            : uint32_t
      80                 :          0 : spdk_nvme_ctrlr_get_first_active_ns(struct spdk_nvme_ctrlr *ctrlr)
      81                 :            : {
      82                 :          0 :         return 1;
      83                 :            : }
      84                 :            : 
      85                 :            : uint32_t
      86                 :          0 : spdk_nvme_ctrlr_get_next_active_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid)
      87                 :            : {
      88   [ #  #  #  #  :          0 :         if (nsid > ctrlr->cdata.nn) {
             #  #  #  # ]
      89                 :          0 :                 return 0;
      90                 :            :         }
      91                 :            : 
      92                 :          0 :         return nsid + 1;
      93                 :          0 : }
      94                 :            : 
      95                 :            : DEFINE_RETURN_MOCK(nvme_io_msg_send, int);
      96                 :            : int
      97                 :         54 : nvme_io_msg_send(struct spdk_nvme_ctrlr *ctrlr,
      98                 :            :                  uint32_t nsid, spdk_nvme_io_msg_fn fn, void *arg)
      99                 :            : {
     100                 :         54 :         g_ut_ctx = arg;
     101                 :         54 :         g_ut_nsid = nsid;
     102                 :         54 :         g_ut_ctrlr = ctrlr;
     103                 :            : 
     104   [ +  +  -  + ]:         54 :         HANDLE_RETURN_MOCK(nvme_io_msg_send);
     105                 :         54 :         return 0;
     106                 :          9 : }
     107                 :            : 
     108                 :            : uint32_t
     109                 :         18 : spdk_nvme_ns_get_sector_size(struct spdk_nvme_ns *ns)
     110                 :            : {
     111   [ +  -  +  - ]:         18 :         return ns->sector_size;
     112                 :            : }
     113                 :            : 
     114                 :            : static struct spdk_nvme_ns g_inactive_ns = {};
     115                 :            : 
     116                 :            : struct spdk_nvme_ns *
     117                 :         18 : spdk_nvme_ctrlr_get_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid)
     118                 :            : {
     119                 :         15 :         struct spdk_nvme_ns tmp;
     120                 :          3 :         struct spdk_nvme_ns *ns;
     121                 :            : 
     122   [ +  -  +  +  :         18 :         if (nsid < 1 || nsid > ctrlr->cdata.nn) {
          +  -  +  -  -  
                      + ]
     123                 :          0 :                 return NULL;
     124                 :            :         }
     125                 :            : 
     126         [ +  - ]:         18 :         tmp.id = nsid;
     127         [ +  - ]:         18 :         ns = RB_FIND(nvme_ns_tree, &ctrlr->ns, &tmp);
     128                 :            : 
     129         [ +  + ]:         18 :         if (ns == NULL) {
     130                 :          0 :                 return &g_inactive_ns;
     131                 :            :         }
     132                 :            : 
     133                 :         18 :         return ns;
     134                 :          3 : }
     135                 :            : 
     136                 :            : struct cuse_device *g_cuse_device;
     137                 :            : DEFINE_RETURN_MOCK(fuse_req_userdata, void *);
     138                 :            : void *
     139                 :          7 : fuse_req_userdata(fuse_req_t req)
     140                 :            : {
     141                 :         42 :         return g_cuse_device;
     142                 :            : }
     143                 :            : 
     144                 :            : static void
     145                 :          6 : test_cuse_nvme_submit_io_read_write(void)
     146                 :            : {
     147                 :          6 :         struct cuse_device cuse_device = {};
     148                 :          6 :         struct fuse_file_info fi = {};
     149                 :          6 :         struct nvme_user_io *user_io = NULL;
     150                 :          6 :         char arg[1024] = {};
     151                 :          6 :         fuse_req_t req = (void *)0xDEEACDFF;
     152   [ -  +  +  - ]:          6 :         unsigned flags = FUSE_IOCTL_DIR;
     153                 :          6 :         uint32_t block_size = 4096;
     154                 :          6 :         uint32_t md_size = 0;
     155                 :          6 :         size_t in_bufsz = 4096;
     156                 :          6 :         size_t out_bufsz = 4096;
     157                 :            : 
     158                 :            :         /* Allocate memory to avoid stack buffer overflow */
     159                 :          6 :         user_io = calloc(3, 4096);
     160   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(user_io != NULL);
     161         [ +  - ]:          6 :         cuse_device.ctrlr = (void *)0xDEADBEEF;
     162         [ +  - ]:          6 :         cuse_device.nsid = 1;
     163   [ +  -  +  - ]:          6 :         user_io->slba = 1024;
     164   [ +  -  +  - ]:          6 :         user_io->nblocks = 1;
     165                 :          6 :         g_ut_ctx = NULL;
     166                 :            : 
     167                 :            :         /* Submit IO read */
     168                 :          7 :         cuse_nvme_submit_io_read(&cuse_device, req, 0, arg, &fi, flags,
     169                 :          1 :                                  block_size, md_size, user_io, in_bufsz, out_bufsz);
     170                 :          6 :         CU_ASSERT(g_ut_ctx != NULL);
     171   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req == req);
     172   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba = user_io->slba);
             +  -  +  - ]
     173   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
          +  -  +  -  +  
                      - ]
     174   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->data_len ==
          +  -  +  -  +  
                      - ]
     175                 :            :                   (int)((user_io->nblocks + 1) * block_size));
     176   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     177   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata_len == 0);
     178   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata == NULL);
     179   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->appmask == 0);
     180   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->apptag == 0);
     181                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     182                 :            : 
     183                 :            :         /* Submit IO write */
     184                 :          6 :         g_ut_ctx = NULL;
     185                 :            : 
     186                 :          7 :         cuse_nvme_submit_io_write(&cuse_device, req, 0, arg, &fi, flags,
     187                 :          1 :                                   block_size, md_size, user_io, in_bufsz, out_bufsz);
     188                 :          6 :         CU_ASSERT(g_ut_ctx != NULL);
     189   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req == req);
     190   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba = user_io->slba);
             +  -  +  - ]
     191   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
          +  -  +  -  +  
                      - ]
     192   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->data_len ==
          +  -  +  -  +  
                      - ]
     193                 :            :                   (int)((user_io->nblocks + 1) * block_size));
     194   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     195   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata_len == 0);
     196   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata == NULL);
     197   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->appmask == 0);
     198   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->apptag == 0);
     199                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     200                 :          6 :         free(user_io);
     201                 :          6 : }
     202                 :            : 
     203                 :            : static void
     204                 :          6 : test_cuse_nvme_submit_io_read_write_with_md(void)
     205                 :            : {
     206                 :          6 :         struct cuse_device cuse_device = {};
     207                 :          6 :         struct fuse_file_info fi = {};
     208                 :          6 :         struct nvme_user_io *user_io = NULL;
     209                 :          6 :         char arg[1024] = {};
     210                 :          6 :         fuse_req_t req = (void *)0xDEEACDFF;
     211   [ -  +  +  - ]:          6 :         unsigned flags = FUSE_IOCTL_DIR;
     212                 :          6 :         uint32_t block_size = 4096;
     213                 :          6 :         uint32_t md_size = 8;
     214                 :          6 :         size_t in_bufsz = 4096;
     215                 :          6 :         size_t out_bufsz = 4096;
     216                 :            : 
     217                 :            :         /* Allocate memory to avoid stack buffer overflow */
     218                 :          6 :         user_io = calloc(4, 4096);
     219   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(user_io != NULL);
     220         [ +  - ]:          6 :         cuse_device.ctrlr = (void *)0xDEADBEEF;
     221         [ +  - ]:          6 :         cuse_device.nsid = 1;
     222   [ +  -  +  - ]:          6 :         user_io->slba = 1024;
     223   [ +  -  +  - ]:          6 :         user_io->nblocks = 1;
     224   [ +  -  +  - ]:          6 :         user_io->appmask = 0xF00D;
     225   [ +  -  +  - ]:          6 :         user_io->apptag = 0xC0DE;
     226   [ +  -  +  - ]:          6 :         user_io->metadata = 0xDEADDEAD;
     227                 :          6 :         g_ut_ctx = NULL;
     228                 :            : 
     229                 :            :         /* Submit IO read */
     230                 :          7 :         cuse_nvme_submit_io_read(&cuse_device, req, 0, arg, &fi, flags,
     231                 :          1 :                                  block_size, md_size, user_io, in_bufsz, out_bufsz);
     232                 :          6 :         CU_ASSERT(g_ut_ctx != NULL);
     233   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req == req);
     234   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba = user_io->slba);
             +  -  +  - ]
     235   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
          +  -  +  -  +  
                      - ]
     236   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->data_len ==
          +  -  +  -  +  
                      - ]
     237                 :            :                   (int)((user_io->nblocks + 1) * block_size));
     238   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     239   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->metadata_len ==
          +  -  +  -  +  
                      - ]
     240                 :            :                   (int)((user_io->nblocks + 1) * md_size));
     241   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata != NULL);
     242   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->appmask == 0xF00D);
     243   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->apptag == 0xC0DE);
     244                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     245                 :            : 
     246                 :            :         /* Submit IO write */
     247                 :          6 :         g_ut_ctx = NULL;
     248                 :            : 
     249                 :          7 :         cuse_nvme_submit_io_write(&cuse_device, req, 0, arg, &fi, flags,
     250                 :          1 :                                   block_size, md_size, user_io, in_bufsz, out_bufsz);
     251                 :          6 :         CU_ASSERT(g_ut_ctx != NULL);
     252   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req == req);
     253   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba = user_io->slba);
             +  -  +  - ]
     254   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
          +  -  +  -  +  
                      - ]
     255   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->data_len ==
          +  -  +  -  +  
                      - ]
     256                 :            :                   (int)((user_io->nblocks + 1) * block_size));
     257   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     258   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->metadata_len ==
          +  -  +  -  +  
                      - ]
     259                 :            :                   (int)((user_io->nblocks + 1) * md_size));
     260   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata != NULL);
     261   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->appmask == 0xF00D);
     262   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->apptag == 0xC0DE);
     263                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     264                 :          6 :         free(user_io);
     265                 :          6 : }
     266                 :            : 
     267                 :            : static void
     268                 :          6 : test_cuse_nvme_submit_passthru_cmd(void)
     269                 :            : {
     270                 :          6 :         struct nvme_passthru_cmd *passthru_cmd = NULL;
     271                 :          6 :         fuse_req_t req = (void *)0xDEEACDFF;
     272                 :            : 
     273                 :          6 :         passthru_cmd = calloc(1, sizeof(struct nvme_passthru_cmd));
     274                 :          6 :         g_cuse_device = calloc(1, sizeof(struct cuse_device));
     275                 :            : 
     276                 :            :         /* Use fatal or we'll segfault if we didn't get memory */
     277   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(passthru_cmd != NULL);
     278   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_cuse_device != NULL);
     279   [ +  -  +  - ]:          6 :         g_cuse_device->ctrlr = (void *)0xDEADBEEF;
     280                 :            : 
     281                 :          6 :         g_ut_ctx = NULL;
     282                 :            :         /* Passthrough command */
     283   [ +  -  +  - ]:          6 :         passthru_cmd->opcode       = SPDK_NVME_DATA_CONTROLLER_TO_HOST;
     284   [ +  -  +  - ]:          6 :         passthru_cmd->nsid         = 1;
     285   [ +  -  +  - ]:          6 :         passthru_cmd->data_len     = 512;
     286   [ +  -  +  - ]:          6 :         passthru_cmd->metadata_len = 0;
     287   [ +  -  +  - ]:          6 :         passthru_cmd->cdw10        = 0xc0de1010;
     288   [ +  -  +  - ]:          6 :         passthru_cmd->cdw11        = 0xc0de1111;
     289   [ +  -  +  - ]:          6 :         passthru_cmd->cdw12        = 0xc0de1212;
     290   [ +  -  +  - ]:          6 :         passthru_cmd->cdw13        = 0xc0de1313;
     291   [ +  -  +  - ]:          6 :         passthru_cmd->cdw14        = 0xc0de1414;
     292   [ +  -  +  - ]:          6 :         passthru_cmd->cdw15        = 0xc0de1515;
     293                 :            : 
     294                 :            :         /* Send IO Command IOCTL */
     295   [ +  -  -  +  :          6 :         cuse_nvme_passthru_cmd_send(req, passthru_cmd, NULL, NULL, NVME_IOCTL_IO_CMD);
          +  -  -  +  +  
                -  +  - ]
     296   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
     297   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     298   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata == NULL);
     299   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req               == req);
     300   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data_len          == 512);
     301   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata_len      == 0);
     302   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.opc      == SPDK_NVME_DATA_CONTROLLER_TO_HOST);
     303   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.nsid     == 1);
                   +  - ]
     304   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw10    == 0xc0de1010);
             +  -  +  - ]
     305   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw11    == 0xc0de1111);
             +  -  +  - ]
     306   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw12    == 0xc0de1212);
             +  -  +  - ]
     307   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw13    == 0xc0de1313);
                   +  - ]
     308   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw14    == 0xc0de1414);
                   +  - ]
     309   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw15    == 0xc0de1515);
                   +  - ]
     310                 :            : 
     311                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     312                 :          6 :         free(passthru_cmd);
     313                 :          6 :         free(g_cuse_device);
     314                 :          6 : }
     315                 :            : 
     316                 :            : static void
     317                 :          6 : test_cuse_nvme_submit_passthru_cmd_with_md(void)
     318                 :            : {
     319                 :          6 :         struct nvme_passthru_cmd *passthru_cmd = NULL;
     320                 :          6 :         fuse_req_t req = (void *)0xDEEACDFF;
     321                 :            : 
     322                 :          6 :         passthru_cmd = calloc(1, sizeof(struct nvme_passthru_cmd));
     323                 :          6 :         g_cuse_device = calloc(1, sizeof(struct cuse_device));
     324                 :            : 
     325                 :            :         /* Use fatal or we'll segfault if we didn't get memory */
     326   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(passthru_cmd != NULL);
     327   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_cuse_device != NULL);
     328   [ +  -  +  - ]:          6 :         g_cuse_device->ctrlr = (void *)0xDEADBEEF;
     329                 :            : 
     330                 :          6 :         g_ut_ctx = NULL;
     331                 :            :         /* Passthrough command */
     332   [ +  -  +  - ]:          6 :         passthru_cmd->opcode       = SPDK_NVME_DATA_CONTROLLER_TO_HOST;
     333   [ +  -  +  - ]:          6 :         passthru_cmd->nsid         = 1;
     334   [ +  -  +  - ]:          6 :         passthru_cmd->data_len     = 512;
     335   [ +  -  +  - ]:          6 :         passthru_cmd->metadata_len = 8;
     336   [ +  -  +  - ]:          6 :         passthru_cmd->cdw10        = 0xc0de1010;
     337   [ +  -  +  - ]:          6 :         passthru_cmd->cdw11        = 0xc0de1111;
     338   [ +  -  +  - ]:          6 :         passthru_cmd->cdw12        = 0xc0de1212;
     339   [ +  -  +  - ]:          6 :         passthru_cmd->cdw13        = 0xc0de1313;
     340   [ +  -  +  - ]:          6 :         passthru_cmd->cdw14        = 0xc0de1414;
     341   [ +  -  +  - ]:          6 :         passthru_cmd->cdw15        = 0xc0de1515;
     342                 :            : 
     343                 :            :         /* Send IO Command IOCTL */
     344   [ +  -  -  +  :          6 :         cuse_nvme_passthru_cmd_send(req, passthru_cmd, NULL, NULL, NVME_IOCTL_IO_CMD);
          +  -  -  +  +  
                -  +  - ]
     345   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
     346   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     347   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata != NULL);
     348   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req               == req);
     349   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data_len          == 512);
     350   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata_len      == 8);
     351   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.opc      == SPDK_NVME_DATA_CONTROLLER_TO_HOST);
     352   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.nsid     == 1);
                   +  - ]
     353   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw10    == 0xc0de1010);
             +  -  +  - ]
     354   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw11    == 0xc0de1111);
             +  -  +  - ]
     355   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw12    == 0xc0de1212);
             +  -  +  - ]
     356   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw13    == 0xc0de1313);
                   +  - ]
     357   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw14    == 0xc0de1414);
                   +  - ]
     358   [ +  -  +  -  :          6 :         CU_ASSERT(g_ut_ctx->nvme_cmd.cdw15    == 0xc0de1515);
                   +  - ]
     359                 :            : 
     360                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     361                 :          6 :         free(passthru_cmd);
     362                 :          6 :         free(g_cuse_device);
     363                 :          6 : }
     364                 :            : 
     365                 :            : static void
     366                 :          6 : test_nvme_cuse_get_cuse_ns_device(void)
     367                 :            : {
     368                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     369                 :          6 :         struct cuse_device ctrlr_device = {};
     370                 :          6 :         struct cuse_device ns_device = { .nsid = 1 };
     371                 :          6 :         struct cuse_device *cuse_dev = NULL;
     372                 :            : 
     373   [ +  -  +  - ]:          6 :         ctrlr.cdata.nn = 3;
     374         [ +  - ]:          6 :         ctrlr_device.ctrlr = &ctrlr;
     375   [ +  -  +  -  :          6 :         TAILQ_INIT(&ctrlr_device.ns_devices);
          +  -  +  -  +  
                      - ]
     376   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&ctrlr_device.ns_devices, &ns_device, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     377                 :            : 
     378   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_ctrlr_ctx_head));
     379   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&g_ctrlr_ctx_head, &ctrlr_device, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
             +  -  +  - ]
     380                 :            : 
     381                 :          6 :         cuse_dev = nvme_cuse_get_cuse_ns_device(&ctrlr, 1);
     382                 :          6 :         CU_ASSERT(cuse_dev == &ns_device);
     383                 :            : 
     384                 :            :         /* nsid 2 was not started */
     385                 :          6 :         cuse_dev = nvme_cuse_get_cuse_ns_device(&ctrlr, 2);
     386                 :          6 :         CU_ASSERT(cuse_dev == NULL);
     387                 :            : 
     388                 :            :         /* nsid invalid */
     389                 :          6 :         cuse_dev = nvme_cuse_get_cuse_ns_device(&ctrlr, 0);
     390                 :          6 :         CU_ASSERT(cuse_dev == NULL);
     391                 :            : 
     392   [ +  +  +  -  :          6 :         TAILQ_REMOVE(&g_ctrlr_ctx_head, &ctrlr_device, tailq);
          -  +  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     393                 :          6 : }
     394                 :            : 
     395                 :            : static void
     396                 :          6 : test_cuse_nvme_submit_io(void)
     397                 :            : {
     398                 :          6 :         struct cuse_device cuse_device = {};
     399                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     400                 :          6 :         struct fuse_file_info fi = {};
     401                 :          6 :         struct spdk_nvme_ns ns = {};
     402                 :          6 :         struct nvme_user_io *user_io = NULL;
     403                 :          6 :         char arg[1024] = {};
     404                 :          6 :         fuse_req_t req = (void *)0xDEEACDFF;
     405                 :            : 
     406                 :            :         /* Allocate memory to avoid stack buffer overflow */
     407                 :          6 :         user_io = calloc(3, 4096);
     408   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(user_io != NULL);
     409                 :            : 
     410                 :          6 :         RB_INIT(&ctrlr.ns);
     411         [ +  - ]:          6 :         ns.id = 1;
     412                 :          6 :         RB_INSERT(nvme_ns_tree, &ctrlr.ns, &ns);
     413                 :            : 
     414         [ +  - ]:          6 :         cuse_device.ctrlr = &ctrlr;
     415   [ +  -  +  - ]:          6 :         ctrlr.cdata.nn = 1;
     416         [ +  - ]:          6 :         ns.sector_size = 4096;
     417         [ +  - ]:          6 :         ns.id = 1;
     418   [ +  -  +  - ]:          6 :         user_io->slba = 1024;
     419   [ +  -  +  - ]:          6 :         user_io->nblocks = 1;
     420         [ +  - ]:          6 :         cuse_device.nsid = 1;
     421                 :          6 :         g_cuse_device = &cuse_device;
     422                 :            : 
     423                 :            :         /* Read */
     424   [ +  -  +  - ]:          6 :         user_io->opcode = SPDK_NVME_OPC_READ;
     425                 :          6 :         g_ut_ctx = NULL;
     426                 :            : 
     427   [ -  +  +  - ]:          6 :         cuse_nvme_submit_io(req, 0, arg, &fi, FUSE_IOCTL_DIR, user_io, 4096, 4096);
     428   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
     429                 :          6 :         CU_ASSERT(g_ut_nsid == 1);
     430   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req == (void *)0xDEEACDFF);
     431   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->lba = 1024);
     432   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->lba_count == 2);
     433   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data_len == 2 * 4096);
     434   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     435   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata_len == 0);
     436   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata == NULL);
     437   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->appmask == 0);
     438   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->apptag == 0);
     439                 :            : 
     440                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     441                 :            : 
     442                 :            :         /* Write */
     443   [ +  -  +  - ]:          6 :         user_io->opcode = SPDK_NVME_OPC_WRITE;
     444                 :          6 :         g_ut_ctx = NULL;
     445                 :            : 
     446   [ -  +  +  - ]:          6 :         cuse_nvme_submit_io(req, 0, arg, &fi, FUSE_IOCTL_DIR, user_io, 4096, 4096);
     447   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
     448                 :          6 :         CU_ASSERT(g_ut_nsid == 1);
     449   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->req == req);
     450   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->lba = 1024);
     451   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->lba_count == 2);
     452   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data_len == 2 * 4096);
     453   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->data != NULL);
     454   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata_len == 0);
     455   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->metadata == NULL);
     456   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->appmask == 0);
     457   [ +  -  +  - ]:          6 :         CU_ASSERT(g_ut_ctx->apptag == 0);
     458                 :          6 :         cuse_io_ctx_free(g_ut_ctx);
     459                 :            : 
     460                 :            :         /* Invalid */
     461                 :          6 :         g_ut_ctx = NULL;
     462   [ +  -  +  - ]:          6 :         user_io->opcode = SPDK_NVME_OPC_FLUSH;
     463                 :            : 
     464   [ -  +  +  - ]:          6 :         cuse_nvme_submit_io(req, 0, arg, &fi, FUSE_IOCTL_DIR, user_io, 4096, 4096);
     465   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_ut_ctx == NULL);
     466                 :            : 
     467                 :          6 :         free(user_io);
     468                 :          6 : }
     469                 :            : 
     470                 :            : static void
     471                 :          6 : test_cuse_nvme_reset(void)
     472                 :            : {
     473                 :          6 :         struct cuse_device cuse_device = {};
     474                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     475                 :          6 :         fuse_req_t req = (void *)0xDEADBEEF;
     476                 :            : 
     477         [ +  - ]:          6 :         cuse_device.ctrlr = &ctrlr;
     478                 :          6 :         g_cuse_device = &cuse_device;
     479                 :            : 
     480                 :            :         /* Invalid nsid  */
     481         [ +  - ]:          6 :         cuse_device.nsid = 1;
     482                 :          6 :         g_ut_ctx = NULL;
     483                 :            : 
     484                 :          6 :         cuse_nvme_reset(req, 0, NULL, NULL, 0, NULL, 4096, 4096);
     485                 :          6 :         CU_ASSERT(g_ut_ctx == NULL);
     486                 :            : 
     487                 :            :         /* Valid nsid, check IO message sent value */
     488         [ +  - ]:          6 :         cuse_device.nsid = 0;
     489                 :            : 
     490                 :          6 :         cuse_nvme_reset(req, 0, NULL, NULL, 0, NULL, 4096, 4096);
     491                 :          6 :         CU_ASSERT(g_ut_ctx == (void *)0xDEADBEEF);
     492                 :          6 :         CU_ASSERT(g_ut_ctrlr == &ctrlr);
     493                 :          6 :         CU_ASSERT(g_ut_nsid == 0);
     494                 :          6 : }
     495                 :            : 
     496                 :            : static void
     497                 :          6 : test_nvme_cuse_stop(void)
     498                 :            : {
     499                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     500                 :          6 :         struct cuse_device *ctrlr_device = NULL;
     501                 :          1 :         struct cuse_device *ns_dev1, *ns_dev2;
     502                 :            : 
     503                 :            :         /* Allocate memory for nvme_cuse_stop() to free. */
     504                 :          6 :         ctrlr_device = calloc(1, sizeof(struct cuse_device));
     505   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(ctrlr_device != NULL);
     506                 :            : 
     507   [ +  -  +  -  :          6 :         TAILQ_INIT(&ctrlr_device->ns_devices);
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     508                 :          6 :         ns_dev1 = calloc(1, sizeof(struct cuse_device));
     509   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(ns_dev1 != NULL);
     510                 :          6 :         ns_dev2 = calloc(1, sizeof(struct cuse_device));
     511   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(ns_dev2 != NULL);
     512                 :            : 
     513                 :          6 :         g_ctrlr_started = spdk_bit_array_create(128);
     514   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(g_ctrlr_started != NULL);
     515                 :            : 
     516   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&ctrlr_device->ns_devices, ns_dev1, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     517   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&ctrlr_device->ns_devices, ns_dev2, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     518   [ +  -  +  - ]:          6 :         ctrlr.cdata.nn = 2;
     519   [ +  -  +  - ]:          6 :         ctrlr_device->ctrlr = &ctrlr;
     520         [ +  + ]:          6 :         pthread_mutex_init(&g_cuse_mtx, NULL);
     521   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&g_ctrlr_ctx_head, ctrlr_device, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     522                 :            : 
     523                 :          6 :         nvme_cuse_stop(&ctrlr);
     524                 :          6 :         CU_ASSERT(g_ctrlr_started == NULL);
     525                 :          6 :         CU_ASSERT(TAILQ_EMPTY(&g_ctrlr_ctx_head));
     526                 :          6 : }
     527                 :            : 
     528                 :            : static void
     529                 :          6 : test_spdk_nvme_cuse_get_ctrlr_name(void)
     530                 :            : {
     531                 :          6 :         int rc_ctrlr = 0;
     532                 :          6 :         int rc_ns = 0;
     533                 :          6 :         uint32_t nsid = 0;
     534                 :          6 :         const uint32_t NSID1 = 12;
     535                 :          6 :         const uint32_t NSID2 = 22;
     536                 :          6 :         size_t name_size = 0;
     537                 :            : 
     538                 :          6 :         char name_ctrlr[128] = "unit_test_ctrlr_dev_name";
     539                 :          6 :         char name_ns_1[128] = "unit_test_ns_dev_name_1";
     540                 :          6 :         char name_ns_2[128] = "unit_test_ns_dev_name_2";
     541                 :            : 
     542                 :          5 :         char rt_name_ctrlr[128];
     543                 :          5 :         char rt_name_ns[128];
     544                 :            : 
     545                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     546                 :          6 :         struct cuse_device ctrlr_device = {};
     547                 :          6 :         struct cuse_device ns_dev1 = {};
     548                 :          6 :         struct cuse_device ns_dev2 = {};
     549                 :            : 
     550         [ +  - ]:          6 :         ctrlr_device.ctrlr = &ctrlr;
     551   [ +  -  +  - ]:          6 :         memcpy(ctrlr_device.dev_name, name_ctrlr, sizeof(ctrlr_device.dev_name));
     552                 :            : 
     553   [ +  -  +  -  :          6 :         TAILQ_INIT(&ctrlr_device.ns_devices);
          +  -  +  -  +  
                      - ]
     554         [ +  - ]:          6 :         ns_dev1.nsid = NSID1;
     555         [ +  - ]:          6 :         ns_dev2.nsid = NSID2;
     556                 :            : 
     557   [ +  -  +  - ]:          6 :         memcpy(ns_dev1.dev_name, name_ns_1, sizeof(ns_dev1.dev_name));
     558   [ +  -  +  - ]:          6 :         memcpy(ns_dev2.dev_name, name_ns_2, sizeof(ns_dev2.dev_name));
     559         [ +  - ]:          6 :         TAILQ_INIT(&g_ctrlr_ctx_head);
     560   [ +  -  +  -  :          6 :         TAILQ_INIT(&ctrlr_device.ns_devices);
          +  -  +  -  +  
                      - ]
     561   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&g_ctrlr_ctx_head, &ctrlr_device, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
             +  -  +  - ]
     562   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&ctrlr_device.ns_devices, &ns_dev1, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     563   [ +  -  +  -  :          6 :         TAILQ_INSERT_TAIL(&ctrlr_device.ns_devices, &ns_dev2, tailq);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     564                 :            : 
     565                 :            :         /* Test case: Give a null spdk_nvme_ctrlr to find cuse_device. Expect: Return -ENODEV failed */
     566                 :          6 :         rc_ctrlr = spdk_nvme_cuse_get_ctrlr_name(NULL, rt_name_ctrlr, &name_size);
     567                 :          6 :         CU_ASSERT(rc_ctrlr == -ENODEV);
     568                 :          6 :         rc_ns = spdk_nvme_cuse_get_ns_name(NULL, nsid, rt_name_ctrlr, &name_size);
     569                 :          6 :         CU_ASSERT(rc_ns == -ENODEV);
     570                 :            : 
     571                 :            :         /* Test case: Give a wrong nsid to find cuse_device. Expect: Return -ENODEV failed */
     572                 :          6 :         rc_ns = spdk_nvme_cuse_get_ns_name(&ctrlr, nsid, rt_name_ns, &name_size);
     573                 :          6 :         CU_ASSERT(rc_ns == -ENODEV);
     574                 :            : 
     575                 :            :         /* Test case: Let parameter size<sizeof(dev_name). Expect: Return -ENOSPC failed */
     576                 :          6 :         name_size = 0;
     577                 :          6 :         rc_ctrlr = spdk_nvme_cuse_get_ctrlr_name(&ctrlr, rt_name_ctrlr, &name_size);
     578                 :          6 :         CU_ASSERT(rc_ctrlr == -ENOSPC);
     579                 :          6 :         name_size = 0;
     580                 :          6 :         rc_ns = spdk_nvme_cuse_get_ns_name(&ctrlr, NSID1, rt_name_ns, &name_size);
     581                 :          6 :         CU_ASSERT(rc_ns == -ENOSPC);
     582                 :            : 
     583                 :            :         /* Test case: All parameters is conformed to function. Expect: Success */
     584                 :          6 :         name_size = 128;
     585                 :          6 :         rc_ctrlr = spdk_nvme_cuse_get_ctrlr_name(&ctrlr, rt_name_ctrlr, &name_size);
     586                 :          6 :         CU_ASSERT(rc_ctrlr == 0);
     587                 :          6 :         rc_ns = spdk_nvme_cuse_get_ns_name(&ctrlr, NSID1, rt_name_ns, &name_size);
     588                 :          6 :         CU_ASSERT(rc_ns == 0);
     589   [ +  -  +  - ]:          6 :         CU_ASSERT(strncmp(rt_name_ctrlr, name_ctrlr, sizeof(name_ctrlr)) == 0);
     590   [ +  -  +  - ]:          6 :         CU_ASSERT(strncmp(rt_name_ns, name_ns_1, sizeof(name_ns_1)) == 0);
     591                 :          6 : }
     592                 :            : 
     593                 :            : int
     594                 :          6 : main(int argc, char **argv)
     595                 :            : {
     596                 :          6 :         CU_pSuite       suite = NULL;
     597                 :          1 :         unsigned int    num_failures;
     598                 :            : 
     599                 :          6 :         CU_initialize_registry();
     600                 :            : 
     601                 :          6 :         suite = CU_add_suite("nvme_cuse", NULL, NULL);
     602                 :          6 :         CU_ADD_TEST(suite, test_cuse_nvme_submit_io_read_write);
     603                 :          6 :         CU_ADD_TEST(suite, test_cuse_nvme_submit_io_read_write_with_md);
     604                 :          6 :         CU_ADD_TEST(suite, test_cuse_nvme_submit_passthru_cmd);
     605                 :          6 :         CU_ADD_TEST(suite, test_cuse_nvme_submit_passthru_cmd_with_md);
     606                 :          6 :         CU_ADD_TEST(suite, test_nvme_cuse_get_cuse_ns_device);
     607                 :          6 :         CU_ADD_TEST(suite, test_cuse_nvme_submit_io);
     608                 :          6 :         CU_ADD_TEST(suite, test_cuse_nvme_reset);
     609                 :          6 :         CU_ADD_TEST(suite, test_nvme_cuse_stop);
     610                 :          6 :         CU_ADD_TEST(suite, test_spdk_nvme_cuse_get_ctrlr_name);
     611                 :            : 
     612                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     613                 :          6 :         CU_cleanup_registry();
     614                 :          7 :         return num_failures;
     615                 :          1 : }

Generated by: LCOV version 1.15