LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/nvme/nvme_fabric.c - nvme_fabric_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 221 247 89.5 %
Date: 2024-07-11 20:05:01 Functions: 20 43 46.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 41 101 40.6 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2021 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  *   Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : #include "spdk/stdinc.h"
       8                 :            : #include "spdk_internal/cunit.h"
       9                 :            : #include "nvme/nvme_fabric.c"
      10                 :            : #include "common/lib/test_env.c"
      11                 :            : 
      12                 :          6 : SPDK_LOG_REGISTER_COMPONENT(nvme)
      13                 :            : 
      14                 :            : pid_t g_spdk_nvme_pid;
      15                 :            : struct spdk_nvmf_fabric_prop_set_cmd g_ut_cmd = {};
      16                 :            : struct spdk_nvmf_fabric_prop_get_rsp g_ut_response = {};
      17                 :            : 
      18                 :          0 : DEFINE_STUB_V(spdk_nvme_ctrlr_get_default_ctrlr_opts,
      19                 :            :               (struct spdk_nvme_ctrlr_opts *opts, size_t opts_size));
      20                 :            : 
      21         [ #  # ]:          0 : DEFINE_STUB(nvme_transport_ctrlr_set_reg_4, int,
      22                 :            :             (struct spdk_nvme_ctrlr *ctrlr,
      23                 :            :              uint32_t offset, uint32_t value), 0);
      24                 :            : 
      25                 :          0 : DEFINE_STUB_V(nvme_ctrlr_destruct, (struct spdk_nvme_ctrlr *ctrlr));
      26                 :            : 
      27         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_cmd_identify, int,
      28                 :            :             (struct spdk_nvme_ctrlr *ctrlr, uint8_t cns, uint16_t cntid,
      29                 :            :              uint32_t nsid, uint8_t csi, void *payload, size_t payload_size,
      30                 :            :              spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
      31                 :            : 
      32                 :          0 : DEFINE_STUB_V(nvme_ctrlr_connected, (struct spdk_nvme_probe_ctx *probe_ctx,
      33                 :            :                                      struct spdk_nvme_ctrlr *ctrlr));
      34         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_add_process, int,
      35                 :            :             (struct spdk_nvme_ctrlr *ctrlr, void *devhandle), 0);
      36                 :            : 
      37         [ -  + ]:         18 : DEFINE_STUB(spdk_nvme_ctrlr_cmd_get_log_page, int,
      38                 :            :             (struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page,
      39                 :            :              uint32_t nsid, void *payload, uint32_t payload_size,
      40                 :            :              uint64_t offset, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
      41                 :            : 
      42   [ -  +  -  + ]:          6 : DEFINE_STUB(spdk_nvme_transport_available_by_name, bool,
      43                 :            :             (const char *transport_name), true);
      44                 :            : 
      45         [ #  # ]:          0 : DEFINE_STUB(nvme_transport_ctrlr_construct, struct spdk_nvme_ctrlr *,
      46                 :            :             (const struct spdk_nvme_transport_id *trid,
      47                 :            :              const struct spdk_nvme_ctrlr_opts *opts,
      48                 :            :              void *devhandle), NULL);
      49                 :            : 
      50         [ -  + ]:          6 : DEFINE_STUB(spdk_nvme_transport_id_adrfam_str, const char *,
      51                 :            :             (enum spdk_nvmf_adrfam adrfam), NULL);
      52                 :            : 
      53         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_process_init, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
      54         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_qpair_authenticate_async, int, (struct spdk_nvme_qpair *qpair), 0);
      55         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_qpair_authenticate_poll, int, (struct spdk_nvme_qpair *qpair), 0);
      56                 :            : 
      57                 :            : static struct spdk_nvmf_fabric_connect_data g_nvmf_data;
      58                 :            : static struct nvme_request *g_request;
      59                 :            : 
      60                 :            : int
      61                 :         18 : nvme_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_request *req)
      62                 :            : {
      63                 :         18 :         CU_ASSERT(nvme_payload_type(&req->payload) == NVME_PAYLOAD_TYPE_CONTIG);
      64                 :            : 
      65                 :         18 :         g_request = req;
      66                 :         18 :         memcpy(&g_nvmf_data, req->payload.contig_or_cb_arg, sizeof(g_nvmf_data));
      67                 :            : 
      68                 :         18 :         return 0;
      69                 :            : }
      70                 :            : 
      71                 :            : void
      72                 :          6 : nvme_completion_poll_cb(void *arg, const struct spdk_nvme_cpl *cpl)
      73                 :            : {
      74                 :          6 :         struct nvme_completion_poll_status *status = arg;
      75                 :            : 
      76   [ +  +  +  - ]:          6 :         if (status->timed_out) {
      77                 :          6 :                 spdk_free(status->dma_data);
      78                 :          6 :                 free(status);
      79                 :            :         }
      80                 :            : 
      81                 :          6 :         g_request = NULL;
      82                 :          6 : }
      83                 :            : 
      84                 :            : static bool g_nvme_wait_for_completion_timeout;
      85                 :            : 
      86                 :            : int
      87                 :         18 : nvme_wait_for_completion_robust_lock_timeout_poll(struct spdk_nvme_qpair *qpair,
      88                 :            :                 struct nvme_completion_poll_status *status,
      89                 :            :                 pthread_mutex_t *robust_mutex)
      90                 :            : {
      91                 :         18 :         struct spdk_nvmf_fabric_connect_rsp *rsp = (void *)&status->cpl;
      92                 :            : 
      93         [ +  + ]:         18 :         if (nvme_qpair_is_admin_queue(qpair)) {
      94                 :         12 :                 rsp->status_code_specific.success.cntlid = 1;
      95                 :            :         }
      96                 :            : 
      97         [ -  + ]:         18 :         status->timed_out = g_nvme_wait_for_completion_timeout;
      98                 :            : 
      99                 :         18 :         return 0;
     100                 :            : }
     101                 :            : 
     102                 :            : int
     103                 :          6 : spdk_nvme_transport_id_populate_trstring(struct spdk_nvme_transport_id *trid, const char *trstring)
     104                 :            : {
     105                 :            :         int len, i, rc;
     106                 :            : 
     107         [ -  + ]:          6 :         if (trstring == NULL) {
     108                 :          0 :                 return -EINVAL;
     109                 :            :         }
     110                 :            : 
     111         [ -  + ]:          6 :         len = strnlen(trstring, SPDK_NVMF_TRSTRING_MAX_LEN);
     112         [ -  + ]:          6 :         if (len == SPDK_NVMF_TRSTRING_MAX_LEN) {
     113                 :          0 :                 return -EINVAL;
     114                 :            :         }
     115                 :            : 
     116                 :          6 :         rc = snprintf(trid->trstring, SPDK_NVMF_TRSTRING_MAX_LEN, "%s", trstring);
     117         [ -  + ]:          6 :         if (rc < 0) {
     118                 :          0 :                 return rc;
     119                 :            :         }
     120                 :            : 
     121                 :            :         /* cast official trstring to uppercase version of input. */
     122         [ +  + ]:         30 :         for (i = 0; i < len; i++) {
     123                 :         24 :                 trid->trstring[i] = toupper(trid->trstring[i]);
     124                 :            :         }
     125                 :          6 :         return 0;
     126                 :            : }
     127                 :            : 
     128                 :            : static struct spdk_nvme_transport_id g_ut_trid;
     129                 :            : static bool g_ut_ctrlr_is_probed;
     130                 :            : 
     131                 :            : int
     132                 :          6 : nvme_ctrlr_probe(const struct spdk_nvme_transport_id *trid,
     133                 :            :                  struct spdk_nvme_probe_ctx *probe_ctx, void *devhandle)
     134                 :            : {
     135                 :          6 :         g_ut_trid = *trid;
     136                 :          6 :         g_ut_ctrlr_is_probed = true;
     137                 :            : 
     138                 :          6 :         return 0;
     139                 :            : }
     140                 :            : 
     141                 :            : const char *
     142                 :         12 : spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype)
     143                 :            : {
     144   [ -  +  -  -  :         12 :         switch (trtype) {
                -  -  + ]
     145                 :          0 :         case SPDK_NVME_TRANSPORT_PCIE:
     146                 :          0 :                 return "PCIe";
     147                 :          6 :         case SPDK_NVME_TRANSPORT_RDMA:
     148                 :          6 :                 return "RDMA";
     149                 :          0 :         case SPDK_NVME_TRANSPORT_FC:
     150                 :          0 :                 return "FC";
     151                 :          0 :         case SPDK_NVME_TRANSPORT_TCP:
     152                 :          0 :                 return "TCP";
     153                 :          0 :         case SPDK_NVME_TRANSPORT_VFIOUSER:
     154                 :          0 :                 return "VFIOUSER";
     155                 :          0 :         case SPDK_NVME_TRANSPORT_CUSTOM:
     156                 :          0 :                 return "CUSTOM";
     157                 :          6 :         default:
     158                 :          6 :                 return NULL;
     159                 :            :         }
     160                 :            : }
     161                 :            : 
     162         [ #  # ]:          0 : DEFINE_RETURN_MOCK(nvme_wait_for_completion, int);
     163                 :            : int
     164                 :          6 : nvme_wait_for_completion(struct spdk_nvme_qpair *qpair,
     165                 :            :                          struct nvme_completion_poll_status *status)
     166                 :            : {
     167                 :          6 :         status->timed_out = false;
     168   [ -  +  -  +  :          6 :         HANDLE_RETURN_MOCK(nvme_wait_for_completion);
                   -  + ]
     169                 :          6 :         return 0;
     170                 :            : }
     171                 :            : 
     172         [ #  # ]:          0 : DEFINE_RETURN_MOCK(nvme_wait_for_completion_robust_lock, int);
     173                 :            : int
     174                 :         18 : nvme_wait_for_completion_robust_lock(struct spdk_nvme_qpair *qpair,
     175                 :            :                                      struct nvme_completion_poll_status *status,
     176                 :            :                                      pthread_mutex_t *robust_mutex)
     177                 :            : {
     178                 :         18 :         status->timed_out = false;
     179   [ -  +  -  +  :         18 :         HANDLE_RETURN_MOCK(nvme_wait_for_completion_robust_lock);
                   -  + ]
     180                 :         18 :         return 0;
     181                 :            : }
     182                 :            : 
     183         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_nvme_ctrlr_cmd_admin_raw, int);
     184                 :            : int
     185                 :         18 : spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr *ctrlr,
     186                 :            :                               struct spdk_nvme_cmd *cmd,
     187                 :            :                               void *buf, uint32_t len,
     188                 :            :                               spdk_nvme_cmd_cb cb_fn, void *cb_arg)
     189                 :            : {
     190                 :         18 :         struct spdk_nvmf_fabric_prop_set_cmd *cmd_tmp = (void *)cmd;
     191                 :         18 :         struct nvme_completion_poll_status *status = cb_arg;
     192                 :         18 :         struct spdk_nvmf_fabric_prop_get_rsp *response = (void *)&status->cpl;
     193                 :            : 
     194                 :         18 :         g_ut_cmd.opcode = cmd_tmp->opcode;
     195                 :         18 :         g_ut_cmd.fctype = cmd_tmp->fctype;
     196                 :         18 :         g_ut_cmd.ofst = cmd_tmp->ofst;
     197                 :         18 :         g_ut_cmd.attrib.size = cmd_tmp->attrib.size;
     198                 :            : 
     199         [ +  + ]:         18 :         if (cmd_tmp->fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_SET) {
     200                 :          6 :                 g_ut_cmd.value.u64 = cmd_tmp->value.u64;
     201         [ +  - ]:         12 :         } else if (cmd_tmp->fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET) {
     202                 :         12 :                 memcpy(&g_ut_response, response, sizeof(g_ut_response));
     203                 :            :         }
     204                 :            : 
     205   [ -  +  -  +  :         18 :         HANDLE_RETURN_MOCK(spdk_nvme_ctrlr_cmd_admin_raw);
                   -  + ]
     206                 :         18 :         return 0;
     207                 :            : }
     208                 :            : 
     209                 :            : static void
     210                 :          6 : abort_request(struct nvme_request *request)
     211                 :            : {
     212                 :          6 :         struct spdk_nvme_cpl cpl = {
     213                 :            :                 .status = {
     214                 :            :                         .sct = SPDK_NVME_SCT_GENERIC,
     215                 :            :                         .sc = SPDK_NVME_SC_ABORTED_SQ_DELETION,
     216                 :            :                 }
     217                 :            :         };
     218                 :            : 
     219                 :          6 :         request->cb_fn(request->cb_arg, &cpl);
     220                 :          6 : }
     221                 :            : 
     222                 :            : static void
     223                 :          6 : test_nvme_fabric_prop_set_cmd(void)
     224                 :            : {
     225                 :            :         int rc;
     226                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     227                 :            : 
     228         [ -  + ]:          6 :         memset(&g_ut_cmd, 0, sizeof(g_ut_cmd));
     229                 :            : 
     230                 :          6 :         rc = nvme_fabric_prop_set_cmd_sync(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_8, 4096);
     231                 :          6 :         CU_ASSERT(rc == 0);
     232                 :          6 :         CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC);
     233                 :          6 :         CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_SET);
     234                 :          6 :         CU_ASSERT(g_ut_cmd.ofst == 1024);
     235                 :          6 :         CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_8);
     236                 :          6 :         CU_ASSERT(g_ut_cmd.value.u64 == 4096);
     237                 :          6 : }
     238                 :            : 
     239                 :            : static void
     240                 :          6 : test_nvme_fabric_prop_get_cmd(void)
     241                 :            : {
     242                 :            :         int rc;
     243                 :          5 :         uint64_t value;
     244                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     245                 :            : 
     246         [ -  + ]:          6 :         memset(&g_ut_cmd, 0, sizeof(g_ut_cmd));
     247         [ -  + ]:          6 :         memset(&g_ut_response, 0, sizeof(g_ut_response));
     248                 :          6 :         value = 0xFFDEADBEEF;
     249                 :            : 
     250                 :            :         /* Case 1: size is SPDK_NVMF_PROP_SIZE_4 */
     251                 :          6 :         rc = nvme_fabric_prop_get_cmd_sync(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_4, &value);
     252                 :          6 :         CU_ASSERT(rc == 0);
     253                 :          6 :         CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC);
     254                 :          6 :         CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET);
     255                 :          6 :         CU_ASSERT(g_ut_cmd.ofst == 1024);
     256                 :          6 :         CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_4);
     257                 :          6 :         CU_ASSERT(g_ut_response.value.u32.low == (value & 0xFFFFFFFF));
     258                 :            : 
     259                 :            :         /* Case 2: size is SPDK_NVMF_PROP_SIZE_8 */
     260         [ -  + ]:          6 :         memset(&g_ut_cmd, 0, sizeof(g_ut_cmd));
     261         [ -  + ]:          6 :         memset(&g_ut_response, 0, sizeof(g_ut_response));
     262                 :            : 
     263                 :          6 :         rc = nvme_fabric_prop_get_cmd_sync(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_8, &value);
     264                 :          6 :         CU_ASSERT(rc == 0);
     265                 :          6 :         CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC);
     266                 :          6 :         CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET);
     267                 :          6 :         CU_ASSERT(g_ut_cmd.ofst == 1024);
     268                 :          6 :         CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_8);
     269                 :          6 :         CU_ASSERT(g_ut_response.value.u64 == value);
     270                 :          6 : }
     271                 :            : 
     272                 :            : static void
     273                 :          6 : test_nvme_fabric_get_discovery_log_page(void)
     274                 :            : {
     275                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     276                 :          6 :         char buffer[4096] = {};
     277                 :          6 :         uint64_t offset = 0;
     278                 :            :         int rc;
     279                 :            : 
     280                 :          6 :         rc = nvme_fabric_get_discovery_log_page(&ctrlr, buffer, sizeof(buffer), offset);
     281                 :          6 :         CU_ASSERT(rc == 0);
     282                 :            : 
     283                 :            :         /* Get log page fail */
     284                 :          6 :         MOCK_SET(spdk_nvme_ctrlr_cmd_get_log_page, -EINVAL);
     285                 :            : 
     286                 :          6 :         rc = nvme_fabric_get_discovery_log_page(&ctrlr, buffer, sizeof(buffer), offset);
     287                 :          6 :         CU_ASSERT(rc == -1);
     288   [ -  -  -  + ]:          6 :         MOCK_CLEAR(spdk_nvme_ctrlr_cmd_get_log_page);
     289                 :            : 
     290                 :            :         /* Completion time out */
     291                 :          6 :         MOCK_SET(nvme_wait_for_completion, -1);
     292                 :            : 
     293                 :          6 :         rc = nvme_fabric_get_discovery_log_page(&ctrlr, buffer, sizeof(buffer), offset);
     294                 :          6 :         CU_ASSERT(rc == -1);
     295   [ -  -  -  + ]:          6 :         MOCK_CLEAR(nvme_wait_for_completion);
     296                 :          6 : }
     297                 :            : 
     298                 :            : static void
     299                 :          6 : test_nvme_fabric_discover_probe(void)
     300                 :            : {
     301                 :          6 :         struct spdk_nvmf_discovery_log_page_entry entry = {};
     302                 :          6 :         struct spdk_nvme_probe_ctx probe_ctx = {};
     303                 :          6 :         char hostnqn[256] = "nqn.2016-06.io.spdk:cnode1";
     304                 :          6 :         char traddr[SPDK_NVMF_TRADDR_MAX_LEN] = "192.168.100.8";
     305                 :          6 :         char trsvcid[SPDK_NVMF_TRSVCID_MAX_LEN] = "4420";
     306                 :          6 :         char trstring[SPDK_NVMF_TRSTRING_MAX_LEN + 1] = "RDMA";
     307                 :            : 
     308                 :          6 :         entry.trtype = SPDK_NVME_TRANSPORT_RDMA;
     309                 :          6 :         entry.subtype = SPDK_NVMF_SUBTYPE_NVME;
     310                 :          6 :         entry.adrfam = SPDK_NVMF_ADRFAM_IPV4;
     311                 :            : 
     312                 :          6 :         memcpy(entry.subnqn, hostnqn, 256);
     313                 :          6 :         memcpy(entry.traddr, traddr, SPDK_NVMF_TRADDR_MAX_LEN);
     314                 :          6 :         memcpy(entry.trsvcid, trsvcid, SPDK_NVMF_TRSVCID_MAX_LEN);
     315                 :          6 :         memcpy(probe_ctx.trid.trstring, trstring, sizeof(probe_ctx.trid.trstring));
     316                 :            : 
     317                 :          6 :         nvme_fabric_discover_probe(&entry, &probe_ctx, 1);
     318         [ -  + ]:          6 :         CU_ASSERT(g_ut_ctrlr_is_probed == true);
     319                 :          6 :         CU_ASSERT(g_ut_trid.trtype == SPDK_NVME_TRANSPORT_RDMA);
     320                 :          6 :         CU_ASSERT(g_ut_trid.adrfam == SPDK_NVMF_ADRFAM_IPV4);
     321                 :          6 :         CU_ASSERT(!strncmp(g_ut_trid.trstring, trstring, sizeof(trstring)));
     322                 :          6 :         CU_ASSERT(!strncmp(g_ut_trid.subnqn, hostnqn, sizeof(hostnqn)));
     323                 :          6 :         CU_ASSERT(!strncmp(g_ut_trid.traddr, traddr, sizeof(traddr)));
     324                 :          6 :         CU_ASSERT(!strncmp(g_ut_trid.trsvcid, trsvcid, sizeof(trsvcid)));
     325                 :            : 
     326                 :          6 :         g_ut_ctrlr_is_probed = false;
     327                 :          6 :         memset(&g_ut_trid, 0, sizeof(g_ut_trid));
     328                 :            : 
     329                 :            :         /* Entry type unsupported */
     330                 :          6 :         entry.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT;
     331                 :            : 
     332                 :          6 :         nvme_fabric_discover_probe(&entry, &probe_ctx, 1);
     333         [ -  + ]:          6 :         CU_ASSERT(g_ut_ctrlr_is_probed == false);
     334                 :            : 
     335                 :            :         /* Entry type invalid */
     336                 :          6 :         entry.subtype = 3;
     337                 :            : 
     338                 :          6 :         nvme_fabric_discover_probe(&entry, &probe_ctx, 1);
     339         [ -  + ]:          6 :         CU_ASSERT(g_ut_ctrlr_is_probed == false);
     340                 :          6 : }
     341                 :            : 
     342                 :            : static void
     343                 :          6 : test_nvme_fabric_qpair_connect(void)
     344                 :            : {
     345                 :          6 :         struct spdk_nvme_qpair qpair = {};
     346                 :          6 :         struct nvme_request     reserved_req = {};
     347                 :          6 :         struct nvme_request     req = {};
     348                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     349                 :          6 :         struct spdk_nvmf_fabric_connect_cmd *cmd = NULL;
     350                 :            :         int rc;
     351                 :          6 :         char hostnqn[SPDK_NVMF_NQN_MAX_LEN + 1] = "nqn.2016-06.io.spdk:host1";
     352                 :          6 :         char subnqn[SPDK_NVMF_NQN_MAX_LEN + 1] = "nqn.2016-06.io.spdk:subsystem1";
     353                 :          6 :         const uint8_t hostid[16] = {
     354                 :            :                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
     355                 :            :                 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
     356                 :            :         };
     357                 :            : 
     358                 :          6 :         cmd = (void *)&reserved_req.cmd;
     359                 :          6 :         qpair.ctrlr = &ctrlr;
     360                 :          6 :         req.qpair = &qpair;
     361                 :          6 :         reserved_req.qpair = &qpair;
     362                 :          6 :         STAILQ_INIT(&qpair.free_req);
     363         [ +  - ]:          6 :         STAILQ_INSERT_HEAD(&qpair.free_req, &req, stailq);
     364                 :          6 :         qpair.reserved_req = &reserved_req;
     365                 :          6 :         memset(&g_nvmf_data, 0, sizeof(g_nvmf_data));
     366                 :            : 
     367                 :          6 :         qpair.id = 1;
     368                 :          6 :         ctrlr.opts.keep_alive_timeout_ms = 100;
     369                 :          6 :         ctrlr.cntlid = 2;
     370                 :          6 :         memcpy(ctrlr.opts.extended_host_id, hostid, sizeof(hostid));
     371                 :          6 :         memcpy(ctrlr.opts.hostnqn, hostnqn, sizeof(hostnqn));
     372                 :          6 :         memcpy(ctrlr.trid.subnqn, subnqn, sizeof(subnqn));
     373                 :            : 
     374                 :          6 :         rc = nvme_fabric_qpair_connect(&qpair, 1);
     375                 :          6 :         CU_ASSERT(rc == 0);
     376                 :          6 :         CU_ASSERT(cmd->opcode == SPDK_NVME_OPC_FABRIC);
     377                 :          6 :         CU_ASSERT(cmd->fctype == SPDK_NVMF_FABRIC_COMMAND_CONNECT);
     378                 :          6 :         CU_ASSERT(cmd->qid == 1);
     379                 :          6 :         CU_ASSERT(cmd->sqsize == 0);
     380                 :          6 :         CU_ASSERT(cmd->kato == 100);
     381                 :          6 :         CU_ASSERT(g_nvmf_data.cntlid == 2);
     382                 :          6 :         CU_ASSERT(!strncmp(g_nvmf_data.hostid, ctrlr.opts.extended_host_id, sizeof(g_nvmf_data.hostid)));
     383                 :          6 :         CU_ASSERT(!strncmp(g_nvmf_data.hostnqn, ctrlr.opts.hostnqn, sizeof(ctrlr.opts.hostnqn)));
     384                 :          6 :         CU_ASSERT(!strncmp(g_nvmf_data.subnqn, ctrlr.trid.subnqn, sizeof(ctrlr.trid.subnqn)));
     385                 :            :         /* Make sure we used the qpair's reserved_req, and not one from the STAILQ */
     386                 :          6 :         CU_ASSERT(g_request == qpair.reserved_req);
     387                 :          6 :         CU_ASSERT(!STAILQ_EMPTY(&qpair.free_req));
     388                 :            : 
     389                 :            :         /* qid is adminq */
     390                 :          6 :         memset(&g_nvmf_data, 0, sizeof(g_nvmf_data));
     391                 :          6 :         memset(&reserved_req, 0, sizeof(reserved_req));
     392                 :          6 :         qpair.id = 0;
     393                 :          6 :         ctrlr.cntlid = 0;
     394                 :            : 
     395                 :          6 :         rc = nvme_fabric_qpair_connect(&qpair, 1);
     396                 :          6 :         CU_ASSERT(rc == 0);
     397                 :          6 :         CU_ASSERT(cmd->opcode == SPDK_NVME_OPC_FABRIC);
     398                 :          6 :         CU_ASSERT(cmd->fctype == SPDK_NVMF_FABRIC_COMMAND_CONNECT);
     399                 :          6 :         CU_ASSERT(cmd->qid == 0);
     400                 :          6 :         CU_ASSERT(cmd->sqsize == 0);
     401                 :          6 :         CU_ASSERT(cmd->kato == 100);
     402                 :          6 :         CU_ASSERT(ctrlr.cntlid == 1);
     403                 :          6 :         CU_ASSERT(g_nvmf_data.cntlid == 0xffff);
     404                 :          6 :         CU_ASSERT(!strncmp(g_nvmf_data.hostid, ctrlr.opts.extended_host_id, sizeof(g_nvmf_data.hostid)));
     405                 :          6 :         CU_ASSERT(!strncmp(g_nvmf_data.hostnqn, ctrlr.opts.hostnqn, sizeof(ctrlr.opts.hostnqn)));
     406                 :          6 :         CU_ASSERT(!strncmp(g_nvmf_data.subnqn, ctrlr.trid.subnqn, sizeof(ctrlr.trid.subnqn)));
     407                 :            :         /* Make sure we used the qpair's reserved_req, and not one from the STAILQ */
     408                 :          6 :         CU_ASSERT(g_request == qpair.reserved_req);
     409                 :          6 :         CU_ASSERT(!STAILQ_EMPTY(&qpair.free_req));
     410                 :            : 
     411                 :            :         /* Wait_for completion timeout */
     412                 :          6 :         g_nvme_wait_for_completion_timeout = true;
     413                 :            : 
     414                 :          6 :         rc = nvme_fabric_qpair_connect(&qpair, 1);
     415                 :          6 :         CU_ASSERT(rc == -ECANCELED);
     416                 :          6 :         g_nvme_wait_for_completion_timeout = false;
     417                 :          6 :         abort_request(g_request);
     418                 :            : 
     419                 :            :         /* Input parameters invalid */
     420                 :          6 :         rc = nvme_fabric_qpair_connect(&qpair, 0);
     421                 :          6 :         CU_ASSERT(rc == -EINVAL);
     422                 :          6 : }
     423                 :            : 
     424                 :            : int
     425                 :          6 : main(int argc, char **argv)
     426                 :            : {
     427                 :          6 :         CU_pSuite       suite = NULL;
     428                 :            :         unsigned int    num_failures;
     429                 :            : 
     430                 :          6 :         CU_initialize_registry();
     431                 :            : 
     432                 :          6 :         suite = CU_add_suite("nvme_fabric", NULL, NULL);
     433                 :          6 :         CU_ADD_TEST(suite, test_nvme_fabric_prop_set_cmd);
     434                 :          6 :         CU_ADD_TEST(suite, test_nvme_fabric_prop_get_cmd);
     435                 :          6 :         CU_ADD_TEST(suite, test_nvme_fabric_get_discovery_log_page);
     436                 :          6 :         CU_ADD_TEST(suite, test_nvme_fabric_discover_probe);
     437                 :          6 :         CU_ADD_TEST(suite, test_nvme_fabric_qpair_connect);
     438                 :            : 
     439                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     440                 :          6 :         CU_cleanup_registry();
     441                 :          6 :         return num_failures;
     442                 :            : }

Generated by: LCOV version 1.14