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 242 91.3 %
Date: 2024-07-15 04:45:37 Functions: 20 28 71.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 33 61 54.1 %

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

Generated by: LCOV version 1.14