LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/nvme/nvme_qpair.c - nvme_qpair_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 470 483 97.3 %
Date: 2024-07-12 01:16:03 Functions: 24 34 70.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 48 122 39.3 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2015 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  *   Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : #include "spdk/stdinc.h"
       8                 :            : 
       9                 :            : #include "spdk_internal/cunit.h"
      10                 :            : 
      11                 :            : #include "common/lib/test_env.c"
      12                 :            : 
      13                 :            : pid_t g_spdk_nvme_pid;
      14                 :            : 
      15                 :            : bool trace_flag = false;
      16                 :            : #define SPDK_LOG_NVME trace_flag
      17                 :            : 
      18                 :            : #include "nvme/nvme_qpair.c"
      19                 :            : 
      20                 :          6 : SPDK_LOG_REGISTER_COMPONENT(nvme)
      21                 :            : 
      22                 :            : struct nvme_driver _g_nvme_driver = {
      23                 :            :         .lock = PTHREAD_MUTEX_INITIALIZER,
      24                 :            : };
      25                 :            : 
      26                 :          6 : DEFINE_STUB_V(nvme_transport_qpair_abort_reqs, (struct spdk_nvme_qpair *qpair));
      27         [ -  + ]:         24 : DEFINE_STUB(nvme_transport_qpair_submit_request, int,
      28                 :            :             (struct spdk_nvme_qpair *qpair, struct nvme_request *req), 0);
      29         [ #  # ]:          0 : DEFINE_STUB(spdk_nvme_ctrlr_free_io_qpair, int, (struct spdk_nvme_qpair *qpair), 0);
      30                 :          0 : DEFINE_STUB_V(nvme_transport_ctrlr_disconnect_qpair, (struct spdk_nvme_ctrlr *ctrlr,
      31                 :            :                 struct spdk_nvme_qpair *qpair));
      32                 :          0 : DEFINE_STUB_V(nvme_ctrlr_disconnect_qpair, (struct spdk_nvme_qpair *qpair));
      33                 :            : 
      34                 :          0 : DEFINE_STUB_V(nvme_ctrlr_abort_queued_aborts, (struct spdk_nvme_ctrlr *ctrlr));
      35         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_reinitialize_io_qpair, int,
      36                 :            :             (struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair), 0);
      37                 :            : 
      38                 :            : void
      39                 :          6 : nvme_ctrlr_fail(struct spdk_nvme_ctrlr *ctrlr, bool hot_remove)
      40                 :            : {
      41         [ -  + ]:          6 :         if (hot_remove) {
      42                 :          0 :                 ctrlr->is_removed = true;
      43                 :            :         }
      44                 :          6 :         ctrlr->is_failed = true;
      45                 :          6 : }
      46                 :            : 
      47                 :            : static bool g_called_transport_process_completions = false;
      48                 :            : static int32_t g_transport_process_completions_rc = 0;
      49                 :            : int32_t
      50                 :         30 : nvme_transport_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_completions)
      51                 :            : {
      52                 :         30 :         g_called_transport_process_completions = true;
      53                 :         30 :         return g_transport_process_completions_rc;
      54                 :            : }
      55                 :            : 
      56                 :            : static void
      57                 :         30 : prepare_submit_request_test(struct spdk_nvme_qpair *qpair,
      58                 :            :                             struct spdk_nvme_ctrlr *ctrlr)
      59                 :            : {
      60         [ -  + ]:         30 :         memset(ctrlr, 0, sizeof(*ctrlr));
      61                 :         30 :         ctrlr->free_io_qids = NULL;
      62                 :         30 :         TAILQ_INIT(&ctrlr->active_io_qpairs);
      63                 :         30 :         TAILQ_INIT(&ctrlr->active_procs);
      64   [ -  -  -  + ]:         30 :         MOCK_CLEAR(spdk_zmalloc);
      65                 :         30 :         nvme_qpair_init(qpair, 1, ctrlr, 0, 32, false);
      66                 :         30 : }
      67                 :            : 
      68                 :            : static void
      69                 :         30 : cleanup_submit_request_test(struct spdk_nvme_qpair *qpair)
      70                 :            : {
      71                 :         30 :         free(qpair->req_buf);
      72                 :         30 : }
      73                 :            : 
      74                 :            : static void
      75                 :          0 : expected_success_callback(void *arg, const struct spdk_nvme_cpl *cpl)
      76                 :            : {
      77   [ #  #  #  # ]:          0 :         CU_ASSERT(!spdk_nvme_cpl_is_error(cpl));
      78                 :          0 : }
      79                 :            : 
      80                 :            : static void
      81                 :          0 : expected_failure_callback(void *arg, const struct spdk_nvme_cpl *cpl)
      82                 :            : {
      83   [ #  #  #  # ]:          0 :         CU_ASSERT(spdk_nvme_cpl_is_error(cpl));
      84                 :          0 : }
      85                 :            : 
      86                 :            : static void
      87                 :          6 : test3(void)
      88                 :            : {
      89                 :          6 :         struct spdk_nvme_qpair          qpair = {};
      90                 :            :         struct nvme_request             *req;
      91                 :          6 :         struct spdk_nvme_ctrlr          ctrlr = {};
      92                 :            : 
      93                 :          6 :         qpair.state = NVME_QPAIR_ENABLED;
      94                 :          6 :         prepare_submit_request_test(&qpair, &ctrlr);
      95                 :            : 
      96                 :          6 :         req = nvme_allocate_request_null(&qpair, expected_success_callback, NULL);
      97         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(req != NULL);
      98                 :            : 
      99                 :          6 :         CU_ASSERT(nvme_qpair_submit_request(&qpair, req) == 0);
     100                 :            : 
     101                 :          6 :         nvme_free_request(req);
     102                 :            : 
     103                 :          6 :         cleanup_submit_request_test(&qpair);
     104                 :          6 : }
     105                 :            : 
     106                 :            : static void
     107                 :          6 : test_ctrlr_failed(void)
     108                 :            : {
     109                 :          6 :         struct spdk_nvme_qpair          qpair = {};
     110                 :            :         struct nvme_request             *req;
     111                 :          6 :         struct spdk_nvme_ctrlr          ctrlr = {};
     112                 :          5 :         char                            payload[4096];
     113                 :            : 
     114                 :          6 :         prepare_submit_request_test(&qpair, &ctrlr);
     115                 :            : 
     116                 :          6 :         req = nvme_allocate_request_contig(&qpair, payload, sizeof(payload), expected_failure_callback,
     117                 :            :                                            NULL);
     118         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(req != NULL);
     119                 :            : 
     120                 :            :         /* Set the controller to failed.
     121                 :            :          * Set the controller to resetting so that the qpair won't get re-enabled.
     122                 :            :          */
     123                 :          6 :         ctrlr.is_failed = true;
     124                 :          6 :         ctrlr.is_resetting = true;
     125                 :            : 
     126                 :          6 :         CU_ASSERT(nvme_qpair_submit_request(&qpair, req) != 0);
     127                 :            : 
     128                 :          6 :         cleanup_submit_request_test(&qpair);
     129                 :          6 : }
     130                 :            : 
     131                 :            : static void
     132                 :          6 : struct_packing(void)
     133                 :            : {
     134                 :            :         /* ctrlr is the first field in nvme_qpair after the fields
     135                 :            :          * that are used in the I/O path. Make sure the I/O path fields
     136                 :            :          * all fit into two cache lines.
     137                 :            :          */
     138                 :          6 :         CU_ASSERT(offsetof(struct spdk_nvme_qpair, ctrlr) <= 128);
     139                 :          6 : }
     140                 :            : 
     141                 :            : static int g_num_cb_failed = 0;
     142                 :            : static int g_num_cb_passed = 0;
     143                 :            : 
     144                 :            : static void
     145                 :         18 : dummy_cb_fn(void *cb_arg, const struct spdk_nvme_cpl *cpl)
     146                 :            : {
     147         [ -  + ]:         18 :         if (cpl->status.sc == SPDK_NVME_SC_SUCCESS) {
     148                 :          0 :                 g_num_cb_passed++;
     149                 :            :         } else {
     150                 :         18 :                 g_num_cb_failed++;
     151                 :            :         }
     152                 :         18 : }
     153                 :            : 
     154                 :            : static void
     155                 :          6 : test_nvme_qpair_process_completions(void)
     156                 :            : {
     157                 :          6 :         struct spdk_nvme_qpair          admin_qp = {0};
     158                 :          6 :         struct spdk_nvme_qpair          qpair = {0};
     159                 :          6 :         struct spdk_nvme_ctrlr          ctrlr = {{0}};
     160                 :          6 :         struct nvme_request             dummy_1 = {{0}};
     161                 :          6 :         struct nvme_request             dummy_2 = {{0}};
     162                 :            :         int                             rc;
     163                 :            : 
     164                 :          6 :         dummy_1.cb_fn = dummy_cb_fn;
     165                 :          6 :         dummy_2.cb_fn = dummy_cb_fn;
     166                 :          6 :         dummy_1.qpair = &qpair;
     167                 :          6 :         dummy_2.qpair = &qpair;
     168                 :            : 
     169                 :          6 :         TAILQ_INIT(&ctrlr.active_io_qpairs);
     170                 :          6 :         TAILQ_INIT(&ctrlr.active_procs);
     171         [ -  + ]:          6 :         CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0);
     172                 :          6 :         nvme_qpair_init(&qpair, 1, &ctrlr, 0, 32, false);
     173                 :          6 :         nvme_qpair_init(&admin_qp, 0, &ctrlr, 0, 32, false);
     174                 :            : 
     175                 :          6 :         ctrlr.adminq = &admin_qp;
     176                 :            : 
     177                 :          6 :         STAILQ_INIT(&qpair.queued_req);
     178                 :          6 :         STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_1, stailq);
     179                 :          6 :         STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_2, stailq);
     180                 :          6 :         qpair.num_outstanding_reqs = 2;
     181                 :            : 
     182                 :            :         /* If the controller is failed, return -ENXIO */
     183                 :          6 :         ctrlr.is_failed = true;
     184                 :          6 :         ctrlr.is_removed = false;
     185                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 0);
     186                 :          6 :         CU_ASSERT(rc == -ENXIO);
     187                 :          6 :         CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
     188                 :          6 :         CU_ASSERT(g_num_cb_passed == 0);
     189                 :          6 :         CU_ASSERT(g_num_cb_failed == 0);
     190                 :          6 :         CU_ASSERT(qpair.num_outstanding_reqs == 2);
     191                 :            : 
     192                 :            :         /* Same if the qpair is failed at the transport layer. */
     193                 :          6 :         ctrlr.is_failed = false;
     194                 :          6 :         ctrlr.is_removed = false;
     195                 :          6 :         qpair.state = NVME_QPAIR_DISCONNECTED;
     196                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 0);
     197                 :          6 :         CU_ASSERT(rc == -ENXIO);
     198                 :          6 :         CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
     199                 :          6 :         CU_ASSERT(g_num_cb_passed == 0);
     200                 :          6 :         CU_ASSERT(g_num_cb_failed == 0);
     201                 :          6 :         CU_ASSERT(qpair.num_outstanding_reqs == 2);
     202                 :            : 
     203                 :            :         /* If the controller is removed, make sure we abort the requests. */
     204                 :          6 :         ctrlr.is_failed = true;
     205                 :          6 :         ctrlr.is_removed = true;
     206                 :          6 :         qpair.state = NVME_QPAIR_CONNECTED;
     207                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 0);
     208                 :          6 :         CU_ASSERT(rc == -ENXIO);
     209                 :          6 :         CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
     210                 :          6 :         CU_ASSERT(g_num_cb_passed == 0);
     211                 :          6 :         CU_ASSERT(g_num_cb_failed == 2);
     212                 :          6 :         CU_ASSERT(qpair.num_outstanding_reqs == 0);
     213                 :            : 
     214                 :            :         /* If we are resetting, make sure that we don't call into the transport. */
     215                 :          6 :         STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_1, stailq);
     216                 :          6 :         dummy_1.queued = true;
     217                 :          6 :         STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_2, stailq);
     218                 :          6 :         dummy_2.queued = true;
     219                 :          6 :         g_num_cb_failed = 0;
     220                 :          6 :         ctrlr.is_failed = false;
     221                 :          6 :         ctrlr.is_removed = false;
     222                 :          6 :         ctrlr.is_resetting = true;
     223                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 0);
     224                 :          6 :         CU_ASSERT(rc == -ENXIO);
     225         [ -  + ]:          6 :         CU_ASSERT(g_called_transport_process_completions == false);
     226                 :            :         /* We also need to make sure we didn't abort the requests. */
     227                 :          6 :         CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
     228                 :          6 :         CU_ASSERT(g_num_cb_passed == 0);
     229                 :          6 :         CU_ASSERT(g_num_cb_failed == 0);
     230                 :            : 
     231                 :            :         /* The case where we aren't resetting, but are enabling the qpair is the same as above. */
     232                 :          6 :         ctrlr.is_resetting = false;
     233                 :          6 :         qpair.state = NVME_QPAIR_ENABLING;
     234                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 0);
     235                 :          6 :         CU_ASSERT(rc == -ENXIO);
     236         [ -  + ]:          6 :         CU_ASSERT(g_called_transport_process_completions == false);
     237                 :          6 :         CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
     238                 :          6 :         CU_ASSERT(g_num_cb_passed == 0);
     239                 :          6 :         CU_ASSERT(g_num_cb_failed == 0);
     240                 :            : 
     241                 :            :         /* For other qpair states, we want to enable the qpair. */
     242                 :          6 :         qpair.state = NVME_QPAIR_CONNECTED;
     243                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 1);
     244                 :          6 :         CU_ASSERT(rc == 0);
     245         [ -  + ]:          6 :         CU_ASSERT(g_called_transport_process_completions == true);
     246                 :            :         /* These should have been submitted to the lower layer. */
     247                 :          6 :         CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
     248                 :          6 :         CU_ASSERT(g_num_cb_passed == 0);
     249                 :          6 :         CU_ASSERT(g_num_cb_failed == 0);
     250                 :          6 :         CU_ASSERT(nvme_qpair_get_state(&qpair) == NVME_QPAIR_ENABLED);
     251                 :            : 
     252                 :          6 :         g_called_transport_process_completions = false;
     253                 :          6 :         g_transport_process_completions_rc = -ENXIO;
     254                 :            : 
     255                 :            :         /* Fail the controller if we get an error from the transport on admin qpair. */
     256                 :          6 :         admin_qp.state = NVME_QPAIR_ENABLED;
     257                 :          6 :         rc = spdk_nvme_qpair_process_completions(&admin_qp, 0);
     258                 :          6 :         CU_ASSERT(rc == -ENXIO);
     259         [ -  + ]:          6 :         CU_ASSERT(g_called_transport_process_completions == true);
     260         [ -  + ]:          6 :         CU_ASSERT(ctrlr.is_failed == true);
     261                 :            : 
     262                 :            :         /* Don't fail the controller for regular qpairs. */
     263                 :          6 :         ctrlr.is_failed = false;
     264                 :          6 :         g_called_transport_process_completions = false;
     265                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 0);
     266                 :          6 :         CU_ASSERT(rc == -ENXIO);
     267         [ -  + ]:          6 :         CU_ASSERT(g_called_transport_process_completions == true);
     268         [ -  + ]:          6 :         CU_ASSERT(ctrlr.is_failed == false);
     269                 :            : 
     270                 :            :         /* Make sure we don't modify the return value from the transport. */
     271                 :          6 :         ctrlr.is_failed = false;
     272                 :          6 :         g_called_transport_process_completions = false;
     273                 :          6 :         g_transport_process_completions_rc = 23;
     274                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, 0);
     275                 :          6 :         CU_ASSERT(rc == 23);
     276         [ -  + ]:          6 :         CU_ASSERT(g_called_transport_process_completions == true);
     277         [ -  + ]:          6 :         CU_ASSERT(ctrlr.is_failed == false);
     278                 :            : 
     279                 :          6 :         free(qpair.req_buf);
     280                 :          6 :         free(admin_qp.req_buf);
     281                 :          6 : }
     282                 :            : 
     283                 :            : static void
     284                 :          6 : test_nvme_completion_is_retry(void)
     285                 :            : {
     286                 :          6 :         struct spdk_nvme_cpl    cpl = {};
     287                 :            : 
     288                 :          6 :         cpl.status.sct = SPDK_NVME_SCT_GENERIC;
     289                 :          6 :         cpl.status.sc = SPDK_NVME_SC_NAMESPACE_NOT_READY;
     290                 :          6 :         cpl.status.dnr = 0;
     291                 :          6 :         CU_ASSERT_TRUE(nvme_completion_is_retry(&cpl));
     292                 :            : 
     293                 :          6 :         cpl.status.sc = SPDK_NVME_SC_FORMAT_IN_PROGRESS;
     294                 :          6 :         cpl.status.dnr = 1;
     295                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     296                 :          6 :         cpl.status.dnr = 0;
     297                 :          6 :         CU_ASSERT_TRUE(nvme_completion_is_retry(&cpl));
     298                 :            : 
     299                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INVALID_OPCODE;
     300                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     301                 :            : 
     302                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INVALID_FIELD;
     303                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     304                 :            : 
     305                 :          6 :         cpl.status.sc = SPDK_NVME_SC_COMMAND_ID_CONFLICT;
     306                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     307                 :            : 
     308                 :          6 :         cpl.status.sc = SPDK_NVME_SC_DATA_TRANSFER_ERROR;
     309                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     310                 :            : 
     311                 :          6 :         cpl.status.sc = SPDK_NVME_SC_ABORTED_POWER_LOSS;
     312                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     313                 :            : 
     314                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
     315                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     316                 :            : 
     317                 :          6 :         cpl.status.sc = SPDK_NVME_SC_ABORTED_BY_REQUEST;
     318                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     319                 :            : 
     320                 :          6 :         cpl.status.sc = SPDK_NVME_SC_ABORTED_FAILED_FUSED;
     321                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     322                 :            : 
     323                 :          6 :         cpl.status.sc = SPDK_NVME_SC_ABORTED_MISSING_FUSED;
     324                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     325                 :            : 
     326                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
     327                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     328                 :            : 
     329                 :          6 :         cpl.status.sc = SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR;
     330                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     331                 :            : 
     332                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INVALID_SGL_SEG_DESCRIPTOR;
     333                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     334                 :            : 
     335                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INVALID_NUM_SGL_DESCIRPTORS;
     336                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     337                 :            : 
     338                 :          6 :         cpl.status.sc = SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID;
     339                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     340                 :            : 
     341                 :          6 :         cpl.status.sc = SPDK_NVME_SC_METADATA_SGL_LENGTH_INVALID;
     342                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     343                 :            : 
     344                 :          6 :         cpl.status.sc = SPDK_NVME_SC_SGL_DESCRIPTOR_TYPE_INVALID;
     345                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     346                 :            : 
     347                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INVALID_CONTROLLER_MEM_BUF;
     348                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     349                 :            : 
     350                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INVALID_PRP_OFFSET;
     351                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     352                 :            : 
     353                 :          6 :         cpl.status.sc = SPDK_NVME_SC_ATOMIC_WRITE_UNIT_EXCEEDED;
     354                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     355                 :            : 
     356                 :          6 :         cpl.status.sc = SPDK_NVME_SC_LBA_OUT_OF_RANGE;
     357                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     358                 :            : 
     359                 :          6 :         cpl.status.sc = SPDK_NVME_SC_CAPACITY_EXCEEDED;
     360                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     361                 :            : 
     362                 :          6 :         cpl.status.sc = SPDK_NVME_SC_RESERVATION_CONFLICT;
     363                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     364                 :            : 
     365                 :          6 :         cpl.status.sc = 0x70;
     366                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     367                 :            : 
     368                 :          6 :         cpl.status.sct = SPDK_NVME_SCT_COMMAND_SPECIFIC;
     369                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     370                 :            : 
     371                 :          6 :         cpl.status.sct = SPDK_NVME_SCT_MEDIA_ERROR;
     372                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     373                 :            : 
     374                 :          6 :         cpl.status.sct = SPDK_NVME_SCT_PATH;
     375                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR;
     376                 :          6 :         cpl.status.dnr = 0;
     377                 :          6 :         CU_ASSERT_TRUE(nvme_completion_is_retry(&cpl));
     378                 :            : 
     379                 :          6 :         cpl.status.sct = SPDK_NVME_SCT_PATH;
     380                 :          6 :         cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR;
     381                 :          6 :         cpl.status.dnr = 1;
     382                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     383                 :            : 
     384                 :          6 :         cpl.status.sct = SPDK_NVME_SCT_VENDOR_SPECIFIC;
     385                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     386                 :            : 
     387                 :          6 :         cpl.status.sct = 0x4;
     388                 :          6 :         CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
     389                 :          6 : }
     390                 :            : 
     391                 :            : #ifdef DEBUG
     392                 :            : static void
     393                 :          6 : test_get_status_string(void)
     394                 :            : {
     395                 :            :         const char      *status_string;
     396                 :          5 :         struct spdk_nvme_status status;
     397                 :            : 
     398                 :          6 :         status.sct = SPDK_NVME_SCT_GENERIC;
     399                 :          6 :         status.sc = SPDK_NVME_SC_SUCCESS;
     400                 :          6 :         status_string = spdk_nvme_cpl_get_status_string(&status);
     401         [ -  + ]:          6 :         CU_ASSERT(strcmp(status_string, "SUCCESS") == 0);
     402                 :            : 
     403                 :          6 :         status.sct = SPDK_NVME_SCT_COMMAND_SPECIFIC;
     404                 :          6 :         status.sc = SPDK_NVME_SC_COMPLETION_QUEUE_INVALID;
     405                 :          6 :         status_string = spdk_nvme_cpl_get_status_string(&status);
     406         [ -  + ]:          6 :         CU_ASSERT(strcmp(status_string, "INVALID COMPLETION QUEUE") == 0);
     407                 :            : 
     408                 :          6 :         status.sct = SPDK_NVME_SCT_MEDIA_ERROR;
     409                 :          6 :         status.sc = SPDK_NVME_SC_UNRECOVERED_READ_ERROR;
     410                 :          6 :         status_string = spdk_nvme_cpl_get_status_string(&status);
     411         [ -  + ]:          6 :         CU_ASSERT(strcmp(status_string, "UNRECOVERED READ ERROR") == 0);
     412                 :            : 
     413                 :          6 :         status.sct = SPDK_NVME_SCT_VENDOR_SPECIFIC;
     414                 :          6 :         status.sc = 0;
     415                 :          6 :         status_string = spdk_nvme_cpl_get_status_string(&status);
     416         [ -  + ]:          6 :         CU_ASSERT(strcmp(status_string, "VENDOR SPECIFIC") == 0);
     417                 :            : 
     418                 :          6 :         status.sct = 0x4;
     419                 :          6 :         status.sc = 0;
     420                 :          6 :         status_string = spdk_nvme_cpl_get_status_string(&status);
     421         [ -  + ]:          6 :         CU_ASSERT(strcmp(status_string, "RESERVED") == 0);
     422                 :          6 : }
     423                 :            : #endif
     424                 :            : 
     425                 :            : static void
     426                 :          6 : test_nvme_qpair_add_cmd_error_injection(void)
     427                 :            : {
     428                 :          6 :         struct spdk_nvme_qpair qpair = {};
     429                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     430                 :          5 :         pthread_mutexattr_t attr;
     431                 :            :         int rc;
     432                 :            : 
     433                 :          6 :         prepare_submit_request_test(&qpair, &ctrlr);
     434                 :          6 :         ctrlr.adminq = &qpair;
     435                 :            : 
     436   [ -  +  -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pthread_mutexattr_init(&attr) == 0);
     437   [ -  +  -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0);
     438   [ -  +  -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pthread_mutex_init(&ctrlr.ctrlr_lock, &attr) == 0);
     439         [ -  + ]:          6 :         pthread_mutexattr_destroy(&attr);
     440                 :            : 
     441                 :            :         /* Admin error injection at submission path */
     442   [ -  -  -  + ]:          6 :         MOCK_CLEAR(spdk_zmalloc);
     443                 :          6 :         rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, NULL,
     444                 :            :                         SPDK_NVME_OPC_GET_FEATURES, true, 5000, 1,
     445                 :            :                         SPDK_NVME_SCT_GENERIC, SPDK_NVME_SC_INVALID_FIELD);
     446                 :            : 
     447                 :          6 :         CU_ASSERT(rc == 0);
     448                 :          6 :         CU_ASSERT(!TAILQ_EMPTY(&qpair.err_cmd_head));
     449                 :            : 
     450                 :            :         /* Remove cmd error injection */
     451                 :          6 :         spdk_nvme_qpair_remove_cmd_error_injection(&ctrlr, NULL, SPDK_NVME_OPC_GET_FEATURES);
     452                 :            : 
     453                 :          6 :         CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
     454                 :            : 
     455                 :            :         /* IO error injection at completion path */
     456                 :          6 :         rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, &qpair,
     457                 :            :                         SPDK_NVME_OPC_READ, false, 0, 1,
     458                 :            :                         SPDK_NVME_SCT_MEDIA_ERROR, SPDK_NVME_SC_UNRECOVERED_READ_ERROR);
     459                 :            : 
     460                 :          6 :         CU_ASSERT(rc == 0);
     461                 :          6 :         CU_ASSERT(!TAILQ_EMPTY(&qpair.err_cmd_head));
     462                 :            : 
     463                 :            :         /* Provide the same opc, and check whether allocate a new entry */
     464                 :          6 :         rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, &qpair,
     465                 :            :                         SPDK_NVME_OPC_READ, false, 0, 1,
     466                 :            :                         SPDK_NVME_SCT_MEDIA_ERROR, SPDK_NVME_SC_UNRECOVERED_READ_ERROR);
     467                 :            : 
     468                 :          6 :         CU_ASSERT(rc == 0);
     469         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&qpair.err_cmd_head));
     470                 :          6 :         CU_ASSERT(TAILQ_NEXT(TAILQ_FIRST(&qpair.err_cmd_head), link) == NULL);
     471                 :            : 
     472                 :            :         /* Remove cmd error injection */
     473                 :          6 :         spdk_nvme_qpair_remove_cmd_error_injection(&ctrlr, &qpair, SPDK_NVME_OPC_READ);
     474                 :            : 
     475                 :          6 :         CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
     476                 :            : 
     477                 :          6 :         rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, &qpair,
     478                 :            :                         SPDK_NVME_OPC_COMPARE, true, 0, 5,
     479                 :            :                         SPDK_NVME_SCT_GENERIC, SPDK_NVME_SC_COMPARE_FAILURE);
     480                 :            : 
     481                 :          6 :         CU_ASSERT(rc == 0);
     482                 :          6 :         CU_ASSERT(!TAILQ_EMPTY(&qpair.err_cmd_head));
     483                 :            : 
     484                 :            :         /* Remove cmd error injection */
     485                 :          6 :         spdk_nvme_qpair_remove_cmd_error_injection(&ctrlr, &qpair, SPDK_NVME_OPC_COMPARE);
     486                 :            : 
     487                 :          6 :         CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
     488                 :            : 
     489         [ -  + ]:          6 :         pthread_mutex_destroy(&ctrlr.ctrlr_lock);
     490                 :          6 :         cleanup_submit_request_test(&qpair);
     491                 :          6 : }
     492                 :            : 
     493                 :            : static struct nvme_request *
     494                 :         12 : allocate_request_tree(struct spdk_nvme_qpair *qpair)
     495                 :            : {
     496                 :            :         struct nvme_request     *req, *req1, *req2, *req3, *req2_1, *req2_2, *req2_3;
     497                 :            : 
     498                 :            :         /*
     499                 :            :          *  Build a request chain like the following:
     500                 :            :          *            req
     501                 :            :          *             |
     502                 :            :          *      ---------------
     503                 :            :          *     |       |       |
     504                 :            :          *    req1    req2    req3
     505                 :            :          *             |
     506                 :            :          *      ---------------
     507                 :            :          *     |       |       |
     508                 :            :          *   req2_1  req2_2  req2_3
     509                 :            :          */
     510                 :         12 :         req = nvme_allocate_request_null(qpair, NULL, NULL);
     511                 :         12 :         CU_ASSERT(req != NULL);
     512                 :         12 :         TAILQ_INIT(&req->children);
     513                 :            : 
     514                 :         12 :         req1 = nvme_allocate_request_null(qpair, NULL, NULL);
     515                 :         12 :         CU_ASSERT(req1 != NULL);
     516                 :         12 :         req->num_children++;
     517                 :         12 :         TAILQ_INSERT_TAIL(&req->children, req1, child_tailq);
     518                 :         12 :         req1->parent = req;
     519                 :            : 
     520                 :         12 :         req2 = nvme_allocate_request_null(qpair, NULL, NULL);
     521                 :         12 :         CU_ASSERT(req2 != NULL);
     522                 :         12 :         TAILQ_INIT(&req2->children);
     523                 :         12 :         req->num_children++;
     524                 :         12 :         TAILQ_INSERT_TAIL(&req->children, req2, child_tailq);
     525                 :         12 :         req2->parent = req;
     526                 :            : 
     527                 :         12 :         req3 = nvme_allocate_request_null(qpair, NULL, NULL);
     528                 :         12 :         CU_ASSERT(req3 != NULL);
     529                 :         12 :         req->num_children++;
     530                 :         12 :         TAILQ_INSERT_TAIL(&req->children, req3, child_tailq);
     531                 :         12 :         req3->parent = req;
     532                 :            : 
     533                 :         12 :         req2_1 = nvme_allocate_request_null(qpair, NULL, NULL);
     534                 :         12 :         CU_ASSERT(req2_1 != NULL);
     535                 :         12 :         req2->num_children++;
     536                 :         12 :         TAILQ_INSERT_TAIL(&req2->children, req2_1, child_tailq);
     537                 :         12 :         req2_1->parent = req2;
     538                 :            : 
     539                 :         12 :         req2_2 = nvme_allocate_request_null(qpair, NULL, NULL);
     540                 :         12 :         CU_ASSERT(req2_2 != NULL);
     541                 :         12 :         req2->num_children++;
     542                 :         12 :         TAILQ_INSERT_TAIL(&req2->children, req2_2, child_tailq);
     543                 :         12 :         req2_2->parent = req2;
     544                 :            : 
     545                 :         12 :         req2_3 = nvme_allocate_request_null(qpair, NULL, NULL);
     546                 :         12 :         CU_ASSERT(req2_3 != NULL);
     547                 :         12 :         req2->num_children++;
     548                 :         12 :         TAILQ_INSERT_TAIL(&req2->children, req2_3, child_tailq);
     549                 :         12 :         req2_3->parent = req2;
     550                 :            : 
     551                 :         12 :         return req;
     552                 :            : }
     553                 :            : 
     554                 :            : static void
     555                 :          6 : test_nvme_qpair_submit_request(void)
     556                 :            : {
     557                 :            :         int                             rc;
     558                 :          6 :         struct spdk_nvme_qpair          qpair = {};
     559                 :          6 :         struct spdk_nvme_ctrlr          ctrlr = {};
     560                 :            :         struct nvme_request             *req;
     561                 :            : 
     562                 :          6 :         prepare_submit_request_test(&qpair, &ctrlr);
     563                 :            : 
     564                 :          6 :         req = allocate_request_tree(&qpair);
     565                 :          6 :         ctrlr.is_failed = true;
     566                 :          6 :         rc = nvme_qpair_submit_request(&qpair, req);
     567         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(rc == -ENXIO);
     568                 :            : 
     569                 :          6 :         req = allocate_request_tree(&qpair);
     570                 :          6 :         ctrlr.is_failed = false;
     571                 :          6 :         qpair.state = NVME_QPAIR_DISCONNECTING;
     572                 :          6 :         rc = nvme_qpair_submit_request(&qpair, req);
     573         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(rc == -ENXIO);
     574                 :            : 
     575                 :          6 :         cleanup_submit_request_test(&qpair);
     576                 :          6 : }
     577                 :            : 
     578                 :            : static void
     579                 :          6 : test_nvme_qpair_resubmit_request_with_transport_failed(void)
     580                 :            : {
     581                 :            :         int                             rc;
     582                 :          6 :         struct spdk_nvme_qpair          qpair = {};
     583                 :          6 :         struct spdk_nvme_ctrlr          ctrlr = {};
     584                 :            :         struct nvme_request             *req;
     585                 :            : 
     586                 :          6 :         prepare_submit_request_test(&qpair, &ctrlr);
     587                 :            : 
     588                 :          6 :         req = nvme_allocate_request_null(&qpair, dummy_cb_fn, NULL);
     589                 :          6 :         CU_ASSERT(req != NULL);
     590                 :          6 :         TAILQ_INIT(&req->children);
     591                 :            : 
     592                 :          6 :         STAILQ_INSERT_TAIL(&qpair.queued_req, req, stailq);
     593                 :          6 :         req->queued = true;
     594                 :            : 
     595                 :          6 :         g_transport_process_completions_rc = 1;
     596                 :          6 :         qpair.state = NVME_QPAIR_ENABLED;
     597                 :          6 :         g_num_cb_failed = 0;
     598                 :          6 :         MOCK_SET(nvme_transport_qpair_submit_request, -EINVAL);
     599                 :          6 :         rc = spdk_nvme_qpair_process_completions(&qpair, g_transport_process_completions_rc);
     600   [ -  -  -  + ]:          6 :         MOCK_CLEAR(nvme_transport_qpair_submit_request);
     601                 :          6 :         CU_ASSERT(rc == g_transport_process_completions_rc);
     602                 :          6 :         CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
     603                 :          6 :         CU_ASSERT(g_num_cb_failed == 1);
     604                 :            : 
     605                 :          6 :         cleanup_submit_request_test(&qpair);
     606                 :          6 : }
     607                 :            : 
     608                 :            : static void
     609                 :          6 : ut_spdk_nvme_cmd_cb(void *cb_arg, const struct spdk_nvme_cpl *cpl)
     610                 :            : {
     611                 :          6 :         CU_ASSERT(cb_arg == (void *)0xDEADBEEF);
     612                 :          6 :         CU_ASSERT(cpl->sqid == 1);
     613                 :          6 :         CU_ASSERT(cpl->status.sct == SPDK_NVME_SCT_GENERIC);
     614                 :          6 :         CU_ASSERT(cpl->status.sc == SPDK_NVME_SC_SUCCESS);
     615                 :          6 :         CU_ASSERT(cpl->status.dnr == 1);
     616                 :          6 : }
     617                 :            : 
     618                 :            : static void
     619                 :          6 : test_nvme_qpair_manual_complete_request(void)
     620                 :            : {
     621                 :          6 :         struct spdk_nvme_qpair qpair = {};
     622                 :          6 :         struct nvme_request req = {};
     623                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     624                 :            : 
     625                 :          6 :         qpair.ctrlr = &ctrlr;
     626                 :          6 :         qpair.id = 1;
     627                 :          6 :         req.cb_fn = ut_spdk_nvme_cmd_cb;
     628                 :          6 :         req.cb_arg = (void *) 0xDEADBEEF;
     629                 :          6 :         req.qpair = &qpair;
     630                 :          6 :         req.num_children = 0;
     631                 :          6 :         qpair.ctrlr->opts.disable_error_logging = false;
     632                 :          6 :         STAILQ_INIT(&qpair.free_req);
     633         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(STAILQ_EMPTY(&qpair.free_req));
     634                 :          6 :         qpair.num_outstanding_reqs = 1;
     635                 :            : 
     636                 :          6 :         nvme_qpair_manual_complete_request(&qpair, &req, SPDK_NVME_SCT_GENERIC,
     637                 :            :                                            SPDK_NVME_SC_SUCCESS, 1, true);
     638                 :          6 :         CU_ASSERT(!STAILQ_EMPTY(&qpair.free_req));
     639                 :          6 :         CU_ASSERT(qpair.num_outstanding_reqs == 0);
     640                 :          6 : }
     641                 :            : 
     642                 :            : static void
     643                 :         18 : ut_spdk_nvme_cmd_cb_empty(void *cb_arg, const struct spdk_nvme_cpl *cpl)
     644                 :            : {
     645                 :            : 
     646                 :         18 : }
     647                 :            : 
     648                 :            : static void
     649                 :          6 : test_nvme_qpair_init_deinit(void)
     650                 :            : {
     651                 :          6 :         struct spdk_nvme_qpair qpair = {};
     652                 :          6 :         struct nvme_request *reqs[3] = {};
     653                 :          6 :         struct spdk_nvme_ctrlr ctrlr = {};
     654                 :          6 :         struct nvme_error_cmd *cmd = NULL;
     655                 :          6 :         struct nvme_request *var_req = NULL;
     656                 :          6 :         int rc, i = 0;
     657                 :            : 
     658                 :          6 :         ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
     659                 :            : 
     660                 :          6 :         rc = nvme_qpair_init(&qpair, 1, &ctrlr, SPDK_NVME_QPRIO_HIGH, 3, false);
     661                 :          6 :         CU_ASSERT(rc == 0);
     662                 :          6 :         CU_ASSERT(qpair.id == 1);
     663                 :          6 :         CU_ASSERT(qpair.qprio == SPDK_NVME_QPRIO_HIGH);
     664                 :          6 :         CU_ASSERT(qpair.in_completion_context == 0);
     665                 :          6 :         CU_ASSERT(qpair.delete_after_completion_context == 0);
     666                 :          6 :         CU_ASSERT(qpair.no_deletion_notification_needed == 0);
     667                 :          6 :         CU_ASSERT(qpair.ctrlr == &ctrlr);
     668                 :          6 :         CU_ASSERT(qpair.trtype == SPDK_NVME_TRANSPORT_PCIE);
     669                 :          6 :         CU_ASSERT(qpair.req_buf != NULL);
     670                 :            : 
     671         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(!STAILQ_EMPTY(&qpair.free_req));
     672         [ +  + ]:         24 :         STAILQ_FOREACH(var_req, &qpair.free_req, stailq) {
     673                 :            :                 /* Check requests address alignment */
     674                 :         18 :                 CU_ASSERT((uint64_t)var_req % 64 == 0);
     675                 :         18 :                 CU_ASSERT(var_req->qpair == &qpair);
     676                 :         18 :                 reqs[i++] = var_req;
     677                 :            :         }
     678                 :          6 :         CU_ASSERT(i == 3);
     679                 :            : 
     680                 :            :         /* Allocate cmd memory for deinit using */
     681                 :          6 :         cmd = spdk_zmalloc(sizeof(*cmd), 64, NULL, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
     682         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(cmd != NULL);
     683                 :          6 :         TAILQ_INSERT_TAIL(&qpair.err_cmd_head, cmd, link);
     684         [ +  + ]:         24 :         for (int i = 0; i < 3; i++) {
     685                 :         18 :                 reqs[i]->cb_fn = ut_spdk_nvme_cmd_cb_empty;
     686                 :         18 :                 reqs[i]->cb_arg = (void *) 0xDEADBEEF;
     687                 :         18 :                 reqs[i]->num_children = 0;
     688                 :            :         }
     689                 :            : 
     690                 :            :         /* Emulate requests into various type queues */
     691   [ +  -  -  +  :          6 :         STAILQ_REMOVE(&qpair.free_req, reqs[0], nvme_request, stailq);
             -  -  -  - ]
     692                 :          6 :         STAILQ_INSERT_TAIL(&qpair.queued_req, reqs[0], stailq);
     693   [ +  -  -  +  :          6 :         STAILQ_REMOVE(&qpair.free_req, reqs[1], nvme_request, stailq);
             -  -  -  - ]
     694                 :          6 :         STAILQ_INSERT_TAIL(&qpair.aborting_queued_req, reqs[1], stailq);
     695   [ +  -  +  -  :          6 :         STAILQ_REMOVE(&qpair.free_req, reqs[2], nvme_request, stailq);
             -  -  -  - ]
     696                 :          6 :         STAILQ_INSERT_TAIL(&qpair.err_req_head, reqs[2], stailq);
     697                 :          6 :         CU_ASSERT(STAILQ_EMPTY(&qpair.free_req));
     698                 :          6 :         qpair.num_outstanding_reqs = 3;
     699                 :            : 
     700                 :          6 :         nvme_qpair_deinit(&qpair);
     701                 :          6 :         CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
     702                 :          6 :         CU_ASSERT(STAILQ_EMPTY(&qpair.aborting_queued_req));
     703                 :          6 :         CU_ASSERT(STAILQ_EMPTY(&qpair.err_req_head));
     704                 :          6 :         CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
     705                 :          6 :         CU_ASSERT(qpair.num_outstanding_reqs == 0);
     706                 :          6 : }
     707                 :            : 
     708                 :            : static void
     709                 :          6 : test_nvme_get_sgl_print_info(void)
     710                 :            : {
     711                 :          6 :         char buf[NVME_CMD_DPTR_STR_SIZE] = {};
     712                 :          6 :         struct spdk_nvme_cmd cmd = {};
     713                 :            : 
     714                 :          6 :         cmd.dptr.sgl1.keyed.length = 0x1000;
     715                 :          6 :         cmd.dptr.sgl1.keyed.key = 0xababccdd;
     716                 :            : 
     717                 :          6 :         nvme_get_sgl_keyed(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
     718                 :          6 :         CU_ASSERT(!strncmp(buf, " len:0x1000 key:0xababccdd", NVME_CMD_DPTR_STR_SIZE));
     719                 :            : 
     720                 :          6 :         memset(&cmd.dptr.sgl1, 0, sizeof(cmd.dptr.sgl1));
     721                 :          6 :         cmd.dptr.sgl1.unkeyed.length = 0x1000;
     722                 :            : 
     723                 :          6 :         nvme_get_sgl_unkeyed(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
     724                 :          6 :         CU_ASSERT(!strncmp(buf, " len:0x1000", NVME_CMD_DPTR_STR_SIZE));
     725                 :            : 
     726                 :          6 :         memset(&cmd.dptr.sgl1, 0, sizeof(cmd.dptr.sgl1));
     727                 :          6 :         cmd.dptr.sgl1.generic.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK;
     728                 :          6 :         cmd.dptr.sgl1.generic.subtype = 0;
     729                 :          6 :         cmd.dptr.sgl1.address = 0xdeadbeef;
     730                 :          6 :         cmd.dptr.sgl1.unkeyed.length = 0x1000;
     731                 :            : 
     732                 :          6 :         nvme_get_sgl(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
     733                 :          6 :         CU_ASSERT(!strncmp(buf, "SGL DATA BLOCK ADDRESS 0xdeadbeef len:0x1000",
     734                 :            :                            NVME_CMD_DPTR_STR_SIZE));
     735                 :            : 
     736                 :          6 :         memset(&cmd.dptr.sgl1, 0, sizeof(cmd.dptr.sgl1));
     737                 :          6 :         cmd.dptr.sgl1.generic.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK;
     738                 :          6 :         cmd.dptr.sgl1.generic.subtype = 0;
     739                 :          6 :         cmd.dptr.sgl1.address = 0xdeadbeef;
     740                 :          6 :         cmd.dptr.sgl1.keyed.length = 0x1000;
     741                 :          6 :         cmd.dptr.sgl1.keyed.key = 0xababccdd;
     742                 :            : 
     743                 :          6 :         nvme_get_sgl(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
     744                 :          6 :         CU_ASSERT(!strncmp(buf, "SGL KEYED DATA BLOCK ADDRESS 0xdeadbeef len:0x1000 key:0xababccdd",
     745                 :            :                            NVME_CMD_DPTR_STR_SIZE));
     746                 :          6 : }
     747                 :            : 
     748                 :            : int
     749                 :          6 : main(int argc, char **argv)
     750                 :            : {
     751                 :          6 :         CU_pSuite       suite = NULL;
     752                 :            :         unsigned int    num_failures;
     753                 :            : 
     754                 :          6 :         CU_initialize_registry();
     755                 :            : 
     756                 :          6 :         suite = CU_add_suite("nvme_qpair", NULL, NULL);
     757                 :            : 
     758                 :          6 :         CU_ADD_TEST(suite, test3);
     759                 :          6 :         CU_ADD_TEST(suite, test_ctrlr_failed);
     760                 :          6 :         CU_ADD_TEST(suite, struct_packing);
     761                 :          6 :         CU_ADD_TEST(suite, test_nvme_qpair_process_completions);
     762                 :          6 :         CU_ADD_TEST(suite, test_nvme_completion_is_retry);
     763                 :            : #ifdef DEBUG
     764                 :          6 :         CU_ADD_TEST(suite, test_get_status_string);
     765                 :            : #endif
     766                 :          6 :         CU_ADD_TEST(suite, test_nvme_qpair_add_cmd_error_injection);
     767                 :          6 :         CU_ADD_TEST(suite, test_nvme_qpair_submit_request);
     768                 :          6 :         CU_ADD_TEST(suite, test_nvme_qpair_resubmit_request_with_transport_failed);
     769                 :          6 :         CU_ADD_TEST(suite, test_nvme_qpair_manual_complete_request);
     770                 :          6 :         CU_ADD_TEST(suite, test_nvme_qpair_init_deinit);
     771                 :          6 :         CU_ADD_TEST(suite, test_nvme_get_sgl_print_info);
     772                 :            : 
     773                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     774                 :          6 :         CU_cleanup_registry();
     775                 :          6 :         return num_failures;
     776                 :            : }

Generated by: LCOV version 1.14