LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/nvme/nvme_ctrlr_cmd.c - nvme_ctrlr_cmd_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 534 570 93.7 %
Date: 2024-07-15 18:44:07 Functions: 67 90 74.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 112 311 36.0 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *
       3                 :            :  *   Copyright (C) 2015 Intel Corporation. All rights reserved.
       4                 :            :  *   Copyright (c) 2021 Mellanox Technologies LTD. All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : #include "spdk_internal/cunit.h"
       8                 :            : 
       9                 :            : #include "nvme/nvme_ctrlr_cmd.c"
      10                 :            : 
      11                 :            : #include "spdk_internal/mock.h"
      12                 :            : 
      13                 :            : #define CTRLR_CDATA_ELPE   5
      14                 :            : 
      15                 :            : pid_t g_spdk_nvme_pid;
      16                 :            : 
      17                 :            : struct nvme_request g_req;
      18                 :            : 
      19                 :            : uint32_t error_num_entries;
      20                 :            : uint32_t health_log_nsid = 1;
      21                 :            : uint8_t feature = 1;
      22                 :            : uint32_t feature_cdw11 = 1;
      23                 :            : uint32_t feature_cdw12 = 1;
      24                 :            : uint8_t get_feature = 1;
      25                 :            : uint32_t get_feature_cdw11 = 1;
      26                 :            : uint32_t fw_img_size = 1024;
      27                 :            : uint32_t fw_img_offset = 0;
      28                 :            : uint16_t abort_cid = 1;
      29                 :            : uint16_t abort_sqid = 1;
      30                 :            : uint32_t namespace_management_nsid = 1;
      31                 :            : uint64_t PRP_ENTRY_1 = 4096;
      32                 :            : uint64_t PRP_ENTRY_2 = 4096;
      33                 :            : uint32_t format_nvme_nsid = 1;
      34                 :            : uint32_t sanitize_nvme_nsid = 1;
      35                 :            : uint32_t expected_host_id_size = 0xFF;
      36                 :            : uint32_t directive_nsid = 1;
      37                 :            : 
      38                 :            : uint32_t expected_feature_ns = 2;
      39                 :            : uint32_t expected_feature_cdw10 = SPDK_NVME_FEAT_LBA_RANGE_TYPE;
      40                 :            : uint32_t expected_feature_cdw11 = 1;
      41                 :            : uint32_t expected_feature_cdw12 = 1;
      42                 :            : 
      43                 :            : typedef void (*verify_request_fn_t)(struct nvme_request *req);
      44                 :            : verify_request_fn_t verify_fn;
      45                 :            : 
      46         [ #  # ]:          0 : DEFINE_STUB(nvme_transport_qpair_iterate_requests, int,
      47                 :            :             (struct spdk_nvme_qpair *qpair,
      48                 :            :              int (*iter_fn)(struct nvme_request *req, void *arg),
      49                 :            :              void *arg), 0);
      50                 :            : 
      51         [ #  # ]:          0 : DEFINE_STUB(nvme_qpair_abort_queued_reqs_with_cbarg, uint32_t,
      52                 :            :             (struct spdk_nvme_qpair *qpair, void *cmd_cb_arg), 0);
      53                 :            : 
      54         [ #  # ]:          0 : DEFINE_STUB(spdk_nvme_ctrlr_get_admin_qp_failure_reason, spdk_nvme_qp_failure_reason,
      55                 :            :             (struct spdk_nvme_ctrlr *ctrlr), 0);
      56                 :            : 
      57                 :            : static int
      58                 :          0 : nvme_ns_cmp(struct spdk_nvme_ns *ns1, struct spdk_nvme_ns *ns2)
      59                 :            : {
      60                 :          0 :         return ns1->id - ns2->id;
      61                 :            : }
      62                 :            : 
      63   [ #  #  #  #  :          0 : RB_GENERATE_STATIC(nvme_ns_tree, spdk_nvme_ns, node, nvme_ns_cmp);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
      64                 :            : 
      65                 :            : static void
      66                 :          3 : verify_firmware_log_page(struct nvme_request *req)
      67                 :            : {
      68                 :            :         uint32_t temp_cdw10;
      69                 :            : 
      70                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
      71                 :          3 :         CU_ASSERT(req->cmd.nsid == SPDK_NVME_GLOBAL_NS_TAG);
      72                 :            : 
      73                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_firmware_page) / sizeof(uint32_t) - 1) << 16) |
      74                 :            :                      SPDK_NVME_LOG_FIRMWARE_SLOT;
      75                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
      76                 :          3 : }
      77                 :            : 
      78                 :            : static void
      79                 :          3 : verify_health_log_page(struct nvme_request *req)
      80                 :            : {
      81                 :            :         uint32_t temp_cdw10;
      82                 :            : 
      83                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
      84                 :          3 :         CU_ASSERT(req->cmd.nsid == health_log_nsid);
      85                 :            : 
      86                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_health_information_page) / sizeof(uint32_t) - 1) << 16) |
      87                 :            :                      SPDK_NVME_LOG_HEALTH_INFORMATION;
      88                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
      89                 :          3 : }
      90                 :            : 
      91                 :            : static void
      92                 :          3 : verify_error_log_page(struct nvme_request *req)
      93                 :            : {
      94                 :            :         uint32_t temp_cdw10;
      95                 :            : 
      96                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
      97                 :          3 :         CU_ASSERT(req->cmd.nsid == SPDK_NVME_GLOBAL_NS_TAG);
      98                 :            : 
      99                 :          3 :         temp_cdw10 = (((sizeof(struct spdk_nvme_error_information_entry) * error_num_entries) /
     100                 :          3 :                        sizeof(uint32_t) - 1) << 16) | SPDK_NVME_LOG_ERROR;
     101                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
     102                 :          3 : }
     103                 :            : 
     104                 :            : static void
     105                 :          3 : verify_set_feature_cmd(struct nvme_request *req)
     106                 :            : {
     107                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_SET_FEATURES);
     108                 :          3 :         CU_ASSERT(req->cmd.cdw10 == feature);
     109                 :          3 :         CU_ASSERT(req->cmd.cdw11 == feature_cdw11);
     110                 :          3 :         CU_ASSERT(req->cmd.cdw12 == feature_cdw12);
     111                 :          3 : }
     112                 :            : 
     113                 :            : static void
     114                 :          3 : verify_set_feature_ns_cmd(struct nvme_request *req)
     115                 :            : {
     116                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_SET_FEATURES);
     117                 :          3 :         CU_ASSERT(req->cmd.cdw10 == expected_feature_cdw10);
     118                 :          3 :         CU_ASSERT(req->cmd.cdw11 == expected_feature_cdw11);
     119                 :          3 :         CU_ASSERT(req->cmd.cdw12 == expected_feature_cdw12);
     120                 :          3 :         CU_ASSERT(req->cmd.nsid == expected_feature_ns);
     121                 :          3 : }
     122                 :            : 
     123                 :            : static void
     124                 :          3 : verify_get_feature_cmd(struct nvme_request *req)
     125                 :            : {
     126                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_FEATURES);
     127                 :          3 :         CU_ASSERT(req->cmd.cdw10 == get_feature);
     128                 :          3 :         CU_ASSERT(req->cmd.cdw11 == get_feature_cdw11);
     129                 :          3 : }
     130                 :            : 
     131                 :            : static void
     132                 :          3 : verify_get_feature_ns_cmd(struct nvme_request *req)
     133                 :            : {
     134                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_FEATURES);
     135                 :          3 :         CU_ASSERT(req->cmd.cdw10 == expected_feature_cdw10);
     136                 :          3 :         CU_ASSERT(req->cmd.cdw11 == expected_feature_cdw11);
     137                 :          3 :         CU_ASSERT(req->cmd.nsid == expected_feature_ns);
     138                 :          3 : }
     139                 :            : 
     140                 :            : static void
     141                 :          3 : verify_abort_cmd(struct nvme_request *req)
     142                 :            : {
     143                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_ABORT);
     144                 :          3 :         CU_ASSERT(req->cmd.cdw10 == (((uint32_t)abort_cid << 16) | abort_sqid));
     145                 :          3 : }
     146                 :            : 
     147                 :            : static void
     148                 :          0 : verify_io_cmd_raw_no_payload_build(struct nvme_request *req)
     149                 :            : {
     150                 :          0 :         struct spdk_nvme_cmd    command = {};
     151                 :          0 :         struct nvme_payload     payload = {};
     152                 :            : 
     153         [ #  # ]:          0 :         CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);
     154         [ #  # ]:          0 :         CU_ASSERT(memcmp(&req->payload, &payload, sizeof(req->payload)) == 0);
     155                 :          0 : }
     156                 :            : 
     157                 :            : static void
     158                 :          0 : verify_io_raw_cmd(struct nvme_request *req)
     159                 :            : {
     160                 :          0 :         struct spdk_nvme_cmd    command = {};
     161                 :            : 
     162         [ #  # ]:          0 :         CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);
     163                 :          0 : }
     164                 :            : 
     165                 :            : static void
     166                 :          0 : verify_io_raw_cmd_with_md(struct nvme_request *req)
     167                 :            : {
     168                 :          0 :         struct spdk_nvme_cmd    command = {};
     169                 :            : 
     170         [ #  # ]:          0 :         CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);
     171                 :          0 : }
     172                 :            : 
     173                 :            : static void
     174                 :          6 : verify_set_host_id_cmd(struct nvme_request *req)
     175                 :            : {
     176      [ +  +  - ]:          6 :         switch (expected_host_id_size) {
     177                 :          3 :         case 8:
     178                 :          3 :                 CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_FEAT_HOST_IDENTIFIER);
     179                 :          3 :                 CU_ASSERT(req->cmd.cdw11 == 0);
     180                 :          3 :                 CU_ASSERT(req->cmd.cdw12 == 0);
     181                 :          3 :                 break;
     182                 :          3 :         case 16:
     183                 :          3 :                 CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_FEAT_HOST_IDENTIFIER);
     184                 :          3 :                 CU_ASSERT(req->cmd.cdw11 == 1);
     185                 :          3 :                 CU_ASSERT(req->cmd.cdw12 == 0);
     186                 :          3 :                 break;
     187                 :          0 :         default:
     188                 :          0 :                 CU_ASSERT(0);
     189                 :            :         }
     190                 :          6 : }
     191                 :            : 
     192                 :            : static void
     193                 :          3 : verify_intel_smart_log_page(struct nvme_request *req)
     194                 :            : {
     195                 :            :         uint32_t temp_cdw10;
     196                 :            : 
     197                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
     198                 :          3 :         CU_ASSERT(req->cmd.nsid == health_log_nsid);
     199                 :            : 
     200                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_intel_smart_information_page) /
     201                 :            :                        sizeof(uint32_t) - 1) << 16) |
     202                 :            :                      SPDK_NVME_INTEL_LOG_SMART;
     203                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
     204                 :          3 : }
     205                 :            : 
     206                 :            : static void
     207                 :          3 : verify_intel_temperature_log_page(struct nvme_request *req)
     208                 :            : {
     209                 :            :         uint32_t temp_cdw10;
     210                 :            : 
     211                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
     212                 :            : 
     213                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_intel_temperature_page) / sizeof(uint32_t) - 1) << 16) |
     214                 :            :                      SPDK_NVME_INTEL_LOG_TEMPERATURE;
     215                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
     216                 :          3 : }
     217                 :            : 
     218                 :            : static void
     219                 :          3 : verify_intel_read_latency_log_page(struct nvme_request *req)
     220                 :            : {
     221                 :            :         uint32_t temp_cdw10;
     222                 :            : 
     223                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
     224                 :            : 
     225                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_intel_rw_latency_page) / sizeof(uint32_t) - 1) << 16) |
     226                 :            :                      SPDK_NVME_INTEL_LOG_READ_CMD_LATENCY;
     227                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
     228                 :          3 : }
     229                 :            : 
     230                 :            : static void
     231                 :          3 : verify_intel_write_latency_log_page(struct nvme_request *req)
     232                 :            : {
     233                 :            :         uint32_t temp_cdw10;
     234                 :            : 
     235                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
     236                 :            : 
     237                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_intel_rw_latency_page) / sizeof(uint32_t) - 1) << 16) |
     238                 :            :                      SPDK_NVME_INTEL_LOG_WRITE_CMD_LATENCY;
     239                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
     240                 :          3 : }
     241                 :            : 
     242                 :            : static void
     243                 :          3 : verify_intel_get_log_page_directory(struct nvme_request *req)
     244                 :            : {
     245                 :            :         uint32_t temp_cdw10;
     246                 :            : 
     247                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
     248                 :            : 
     249                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_intel_log_page_directory) / sizeof(uint32_t) - 1) << 16) |
     250                 :            :                      SPDK_NVME_INTEL_LOG_PAGE_DIRECTORY;
     251                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
     252                 :          3 : }
     253                 :            : 
     254                 :            : static void
     255                 :          3 : verify_intel_marketing_description_log_page(struct nvme_request *req)
     256                 :            : {
     257                 :            :         uint32_t temp_cdw10;
     258                 :            : 
     259                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
     260                 :            : 
     261                 :          3 :         temp_cdw10 = ((sizeof(struct spdk_nvme_intel_marketing_description_page) / sizeof(
     262                 :            :                                uint32_t) - 1) << 16) |
     263                 :            :                      SPDK_NVME_INTEL_MARKETING_DESCRIPTION;
     264                 :          3 :         CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
     265                 :          3 : }
     266                 :            : 
     267                 :            : static void
     268                 :          3 : verify_namespace_attach(struct nvme_request *req)
     269                 :            : {
     270                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_ATTACHMENT);
     271                 :          3 :         CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_CTRLR_ATTACH);
     272                 :          3 :         CU_ASSERT(req->cmd.nsid == namespace_management_nsid);
     273                 :          3 : }
     274                 :            : 
     275                 :            : static void
     276                 :          3 : verify_namespace_detach(struct nvme_request *req)
     277                 :            : {
     278                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_ATTACHMENT);
     279                 :          3 :         CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_CTRLR_DETACH);
     280                 :          3 :         CU_ASSERT(req->cmd.nsid == namespace_management_nsid);
     281                 :          3 : }
     282                 :            : 
     283                 :            : static void
     284                 :          3 : verify_namespace_create(struct nvme_request *req)
     285                 :            : {
     286                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_MANAGEMENT);
     287                 :          3 :         CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_MANAGEMENT_CREATE);
     288                 :          3 :         CU_ASSERT(req->cmd.nsid == 0);
     289                 :          3 : }
     290                 :            : 
     291                 :            : static void
     292                 :          3 : verify_namespace_delete(struct nvme_request *req)
     293                 :            : {
     294                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_MANAGEMENT);
     295                 :          3 :         CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_MANAGEMENT_DELETE);
     296                 :          3 :         CU_ASSERT(req->cmd.nsid == namespace_management_nsid);
     297                 :          3 : }
     298                 :            : 
     299                 :            : static void
     300                 :          3 : verify_doorbell_buffer_config(struct nvme_request *req)
     301                 :            : {
     302                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_DOORBELL_BUFFER_CONFIG);
     303                 :          3 :         CU_ASSERT(req->cmd.dptr.prp.prp1 == PRP_ENTRY_1);
     304                 :          3 :         CU_ASSERT(req->cmd.dptr.prp.prp2 == PRP_ENTRY_2);
     305                 :          3 : }
     306                 :            : 
     307                 :            : static void
     308                 :          3 : verify_format_nvme(struct nvme_request *req)
     309                 :            : {
     310                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_FORMAT_NVM);
     311                 :          3 :         CU_ASSERT(req->cmd.cdw10 == 0);
     312                 :          3 :         CU_ASSERT(req->cmd.nsid == format_nvme_nsid);
     313                 :          3 : }
     314                 :            : 
     315                 :            : static void
     316                 :          3 : verify_fw_commit(struct nvme_request *req)
     317                 :            : {
     318                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_FIRMWARE_COMMIT);
     319                 :          3 :         CU_ASSERT(req->cmd.cdw10 == 0x09);
     320                 :          3 : }
     321                 :            : 
     322                 :            : static void
     323                 :          3 : verify_fw_image_download(struct nvme_request *req)
     324                 :            : {
     325                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD);
     326                 :          3 :         CU_ASSERT(req->cmd.cdw10 == spdk_nvme_bytes_to_numd(fw_img_size));
     327                 :          3 :         CU_ASSERT(req->cmd.cdw11 == fw_img_offset >> 2);
     328                 :          3 : }
     329                 :            : 
     330                 :            : static void
     331                 :          3 : verify_nvme_sanitize(struct nvme_request *req)
     332                 :            : {
     333                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_SANITIZE);
     334                 :          3 :         CU_ASSERT(req->cmd.cdw10 == 0x309);
     335                 :          3 :         CU_ASSERT(req->cmd.cdw11 == 0);
     336                 :          3 :         CU_ASSERT(req->cmd.nsid == sanitize_nvme_nsid);
     337                 :          3 : }
     338                 :            : 
     339                 :            : static void
     340                 :          3 : verify_directive_receive(struct nvme_request *req)
     341                 :            : {
     342                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_DIRECTIVE_RECEIVE);
     343                 :          3 :         CU_ASSERT(req->cmd.nsid == directive_nsid);
     344                 :          3 : }
     345                 :            : 
     346                 :            : static void
     347                 :          3 : verify_directive_send(struct nvme_request *req)
     348                 :            : {
     349                 :          3 :         CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_DIRECTIVE_SEND);
     350                 :          3 :         CU_ASSERT(req->cmd.nsid == directive_nsid);
     351                 :          3 : }
     352                 :            : 
     353                 :            : struct nvme_request *
     354                 :         78 : nvme_allocate_request_user_copy(struct spdk_nvme_qpair *qpair, void *buffer, uint32_t payload_size,
     355                 :            :                                 spdk_nvme_cmd_cb cb_fn, void *cb_arg, bool host_to_controller)
     356                 :            : {
     357                 :            :         /* For the unit test, we don't actually need to copy the buffer */
     358                 :         78 :         return nvme_allocate_request_contig(qpair, buffer, payload_size, cb_fn, cb_arg);
     359                 :            : }
     360                 :            : 
     361                 :            : int
     362                 :          0 : nvme_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_request *req)
     363                 :            : {
     364                 :          0 :         verify_fn(req);
     365                 :            :         /* stop analyzer from thinking stack variable addresses are stored in a global */
     366         [ #  # ]:          0 :         memset(req, 0, sizeof(*req));
     367                 :            : 
     368                 :          0 :         return 0;
     369                 :            : }
     370                 :            : 
     371         [ #  # ]:          0 : DEFINE_RETURN_MOCK(nvme_ctrlr_submit_admin_request, int);
     372                 :            : int
     373                 :         93 : nvme_ctrlr_submit_admin_request(struct spdk_nvme_ctrlr *ctrlr, struct nvme_request *req)
     374                 :            : {
     375   [ -  +  +  +  :         93 :         HANDLE_RETURN_MOCK(nvme_ctrlr_submit_admin_request);
                   +  + ]
     376                 :         81 :         verify_fn(req);
     377                 :            :         /* stop analyzer from thinking stack variable addresses are stored in a global */
     378         [ -  + ]:         81 :         memset(req, 0, sizeof(*req));
     379                 :            : 
     380                 :         81 :         return 0;
     381                 :            : }
     382                 :            : 
     383                 :            : static struct spdk_nvme_ns g_inactive_ns = {};
     384                 :            : 
     385                 :            : struct spdk_nvme_ns *
     386                 :          0 : spdk_nvme_ctrlr_get_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid)
     387                 :            : {
     388                 :          0 :         struct spdk_nvme_ns tmp;
     389                 :            :         struct spdk_nvme_ns *ns;
     390                 :            : 
     391   [ #  #  #  # ]:          0 :         if (nsid < 1 || nsid > ctrlr->cdata.nn) {
     392                 :          0 :                 return NULL;
     393                 :            :         }
     394                 :            : 
     395                 :          0 :         tmp.id = nsid;
     396                 :          0 :         ns = RB_FIND(nvme_ns_tree, &ctrlr->ns, &tmp);
     397                 :            : 
     398         [ #  # ]:          0 :         if (ns == NULL) {
     399                 :          0 :                 return &g_inactive_ns;
     400                 :            :         }
     401                 :            : 
     402                 :          0 :         return ns;
     403                 :            : }
     404                 :            : 
     405                 :            : #define DECLARE_AND_CONSTRUCT_CTRLR()           \
     406                 :            :         struct spdk_nvme_ctrlr  ctrlr = {};     \
     407                 :            :         struct spdk_nvme_qpair  adminq = {};    \
     408                 :            :         struct nvme_request     req;            \
     409                 :            :                                                 \
     410                 :            :         STAILQ_INIT(&adminq.free_req);              \
     411                 :            :         STAILQ_INSERT_HEAD(&adminq.free_req, &req, stailq);     \
     412                 :            :         ctrlr.adminq = &adminq;     \
     413                 :            :         CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0);
     414                 :            : 
     415                 :            : #define DECONSTRUCT_CTRLR() \
     416                 :            :         CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0);
     417                 :            : 
     418                 :            : static void
     419                 :          3 : test_firmware_get_log_page(void)
     420                 :            : {
     421   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     422                 :          3 :         struct spdk_nvme_firmware_page          payload = {};
     423                 :            : 
     424                 :          3 :         verify_fn = verify_firmware_log_page;
     425                 :            : 
     426                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_LOG_FIRMWARE_SLOT, SPDK_NVME_GLOBAL_NS_TAG,
     427                 :            :                                          &payload,
     428                 :            :                                          sizeof(payload), 0, NULL, NULL);
     429                 :            : 
     430         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     431                 :          3 : }
     432                 :            : 
     433                 :            : static void
     434                 :          3 : test_health_get_log_page(void)
     435                 :            : {
     436   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     437                 :          3 :         struct spdk_nvme_health_information_page        payload = {};
     438                 :            : 
     439                 :          3 :         verify_fn = verify_health_log_page;
     440                 :            : 
     441                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_LOG_HEALTH_INFORMATION, health_log_nsid,
     442                 :            :                                          &payload,
     443                 :            :                                          sizeof(payload), 0, NULL, NULL);
     444                 :            : 
     445         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     446                 :          3 : }
     447                 :            : 
     448                 :            : static void
     449                 :          3 : test_error_get_log_page(void)
     450                 :            : {
     451   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     452                 :          3 :         struct spdk_nvme_error_information_entry        payload = {};
     453                 :            : 
     454                 :          3 :         ctrlr.cdata.elpe = CTRLR_CDATA_ELPE;
     455                 :            : 
     456                 :          3 :         verify_fn = verify_error_log_page;
     457                 :            : 
     458                 :            :         /* valid page */
     459                 :          3 :         error_num_entries = 1;
     460                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_LOG_ERROR, SPDK_NVME_GLOBAL_NS_TAG, &payload,
     461                 :            :                                          sizeof(payload), 0, NULL, NULL);
     462                 :            : 
     463         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     464                 :          3 : }
     465                 :            : 
     466                 :            : static void
     467                 :          3 : test_intel_smart_get_log_page(void)
     468                 :            : {
     469   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     470                 :          3 :         struct spdk_nvme_intel_smart_information_page   payload = {};
     471                 :            : 
     472                 :          3 :         verify_fn = verify_intel_smart_log_page;
     473                 :            : 
     474                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_SMART, health_log_nsid, &payload,
     475                 :            :                                          sizeof(payload), 0, NULL, NULL);
     476                 :            : 
     477         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     478                 :          3 : }
     479                 :            : 
     480                 :            : static void
     481                 :          3 : test_intel_temperature_get_log_page(void)
     482                 :            : {
     483   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     484                 :          3 :         struct spdk_nvme_intel_temperature_page payload = {};
     485                 :            : 
     486                 :          3 :         verify_fn = verify_intel_temperature_log_page;
     487                 :            : 
     488                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_TEMPERATURE, SPDK_NVME_GLOBAL_NS_TAG,
     489                 :            :                                          &payload, sizeof(payload), 0, NULL, NULL);
     490                 :            : 
     491         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     492                 :          3 : }
     493                 :            : 
     494                 :            : static void
     495                 :          3 : test_intel_read_latency_get_log_page(void)
     496                 :            : {
     497   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     498                 :          3 :         struct spdk_nvme_intel_rw_latency_page  payload = {};
     499                 :            : 
     500                 :          3 :         verify_fn = verify_intel_read_latency_log_page;
     501                 :            : 
     502                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_READ_CMD_LATENCY,
     503                 :            :                                          SPDK_NVME_GLOBAL_NS_TAG,
     504                 :            :                                          &payload, sizeof(payload), 0, NULL, NULL);
     505                 :            : 
     506         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     507                 :          3 : }
     508                 :            : 
     509                 :            : static void
     510                 :          3 : test_intel_write_latency_get_log_page(void)
     511                 :            : {
     512   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     513                 :          3 :         struct spdk_nvme_intel_rw_latency_page  payload = {};
     514                 :            : 
     515                 :          3 :         verify_fn = verify_intel_write_latency_log_page;
     516                 :            : 
     517                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_WRITE_CMD_LATENCY,
     518                 :            :                                          SPDK_NVME_GLOBAL_NS_TAG,
     519                 :            :                                          &payload, sizeof(payload), 0, NULL, NULL);
     520                 :            : 
     521         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     522                 :          3 : }
     523                 :            : 
     524                 :            : static void
     525                 :          3 : test_intel_get_log_page_directory(void)
     526                 :            : {
     527   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     528                 :          3 :         struct spdk_nvme_intel_log_page_directory       payload = {};
     529                 :            : 
     530                 :          3 :         verify_fn = verify_intel_get_log_page_directory;
     531                 :            : 
     532                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_PAGE_DIRECTORY,
     533                 :            :                                          SPDK_NVME_GLOBAL_NS_TAG,
     534                 :            :                                          &payload, sizeof(payload), 0, NULL, NULL);
     535                 :            : 
     536         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     537                 :          3 : }
     538                 :            : 
     539                 :            : static void
     540                 :          3 : test_intel_marketing_description_get_log_page(void)
     541                 :            : {
     542   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     543                 :          3 :         struct spdk_nvme_intel_marketing_description_page       payload = {};
     544                 :            : 
     545                 :          3 :         verify_fn = verify_intel_marketing_description_log_page;
     546                 :            : 
     547                 :          3 :         spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_MARKETING_DESCRIPTION,
     548                 :            :                                          SPDK_NVME_GLOBAL_NS_TAG,
     549                 :            :                                          &payload, sizeof(payload), 0, NULL, NULL);
     550                 :            : 
     551         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     552                 :          3 : }
     553                 :            : 
     554                 :            : static void
     555                 :          3 : test_generic_get_log_pages(void)
     556                 :            : {
     557                 :          3 :         test_error_get_log_page();
     558                 :          3 :         test_health_get_log_page();
     559                 :          3 :         test_firmware_get_log_page();
     560                 :          3 : }
     561                 :            : 
     562                 :            : static void
     563                 :          3 : test_intel_get_log_pages(void)
     564                 :            : {
     565                 :          3 :         test_intel_get_log_page_directory();
     566                 :          3 :         test_intel_smart_get_log_page();
     567                 :          3 :         test_intel_temperature_get_log_page();
     568                 :          3 :         test_intel_read_latency_get_log_page();
     569                 :          3 :         test_intel_write_latency_get_log_page();
     570                 :          3 :         test_intel_marketing_description_get_log_page();
     571                 :          3 : }
     572                 :            : 
     573                 :            : static void
     574                 :          3 : test_set_feature_cmd(void)
     575                 :            : {
     576   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     577                 :            : 
     578                 :          3 :         verify_fn = verify_set_feature_cmd;
     579                 :            : 
     580                 :          3 :         spdk_nvme_ctrlr_cmd_set_feature(&ctrlr, feature, feature_cdw11, feature_cdw12, NULL, 0, NULL, NULL);
     581                 :            : 
     582         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     583                 :          3 : }
     584                 :            : 
     585                 :            : static void
     586                 :          3 : test_get_feature_ns_cmd(void)
     587                 :            : {
     588   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     589                 :            : 
     590                 :          3 :         verify_fn = verify_get_feature_ns_cmd;
     591                 :            : 
     592                 :          3 :         spdk_nvme_ctrlr_cmd_get_feature_ns(&ctrlr, expected_feature_cdw10,
     593                 :            :                                            expected_feature_cdw11, NULL, 0,
     594                 :            :                                            NULL, NULL, expected_feature_ns);
     595                 :            : 
     596         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     597                 :          3 : }
     598                 :            : 
     599                 :            : static void
     600                 :          3 : test_set_feature_ns_cmd(void)
     601                 :            : {
     602   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     603                 :            : 
     604                 :          3 :         verify_fn = verify_set_feature_ns_cmd;
     605                 :            : 
     606                 :          3 :         spdk_nvme_ctrlr_cmd_set_feature_ns(&ctrlr, expected_feature_cdw10,
     607                 :            :                                            expected_feature_cdw11, expected_feature_cdw12,
     608                 :            :                                            NULL, 0, NULL, NULL, expected_feature_ns);
     609                 :            : 
     610         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     611                 :          3 : }
     612                 :            : 
     613                 :            : static void
     614                 :          3 : test_get_feature_cmd(void)
     615                 :            : {
     616   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     617                 :            : 
     618                 :          3 :         verify_fn = verify_get_feature_cmd;
     619                 :            : 
     620                 :          3 :         spdk_nvme_ctrlr_cmd_get_feature(&ctrlr, get_feature, get_feature_cdw11, NULL, 0, NULL, NULL);
     621                 :            : 
     622         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     623                 :          3 : }
     624                 :            : 
     625                 :            : static void
     626                 :          3 : test_abort_cmd(void)
     627                 :            : {
     628   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     629                 :          3 :         struct spdk_nvme_qpair  qpair = {};
     630                 :            : 
     631                 :          3 :         STAILQ_INIT(&ctrlr.queued_aborts);
     632                 :            : 
     633                 :          3 :         verify_fn = verify_abort_cmd;
     634                 :            : 
     635                 :          3 :         qpair.id = abort_sqid;
     636                 :          3 :         spdk_nvme_ctrlr_cmd_abort(&ctrlr, &qpair, abort_cid, NULL, NULL);
     637                 :            : 
     638         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     639                 :          3 : }
     640                 :            : 
     641                 :            : static void
     642                 :          3 : test_io_cmd_raw_no_payload_build(void)
     643                 :            : {
     644   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     645                 :          3 :         struct spdk_nvme_qpair  qpair = {};
     646                 :          3 :         struct spdk_nvme_cmd    cmd = {};
     647                 :            : 
     648                 :          3 :         verify_fn = verify_io_cmd_raw_no_payload_build;
     649                 :            : 
     650                 :          3 :         spdk_nvme_ctrlr_io_cmd_raw_no_payload_build(&ctrlr, &qpair, &cmd, NULL, NULL);
     651                 :            : 
     652         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     653                 :          3 : }
     654                 :            : 
     655                 :            : static void
     656                 :          3 : test_io_raw_cmd(void)
     657                 :            : {
     658   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     659                 :          3 :         struct spdk_nvme_qpair  qpair = {};
     660                 :          3 :         struct spdk_nvme_cmd    cmd = {};
     661                 :            : 
     662                 :          3 :         verify_fn = verify_io_raw_cmd;
     663                 :            : 
     664                 :          3 :         spdk_nvme_ctrlr_cmd_io_raw(&ctrlr, &qpair, &cmd, NULL, 1, NULL, NULL);
     665                 :            : 
     666         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     667                 :          3 : }
     668                 :            : 
     669                 :            : static void
     670                 :          3 : test_io_raw_cmd_with_md(void)
     671                 :            : {
     672   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     673                 :          3 :         struct spdk_nvme_qpair  qpair = {};
     674                 :          3 :         struct spdk_nvme_cmd    cmd = {};
     675                 :            : 
     676                 :          3 :         verify_fn = verify_io_raw_cmd_with_md;
     677                 :            : 
     678                 :          3 :         spdk_nvme_ctrlr_cmd_io_raw_with_md(&ctrlr, &qpair, &cmd, NULL, 1, NULL, NULL, NULL);
     679                 :            : 
     680         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     681                 :          3 : }
     682                 :            : 
     683                 :            : static int
     684                 :          9 : test_set_host_id_by_case(uint32_t host_id_size)
     685                 :            : {
     686   [ +  -  -  + ]:          9 :         DECLARE_AND_CONSTRUCT_CTRLR();
     687                 :          9 :         int rc = 0;
     688                 :            : 
     689                 :          9 :         expected_host_id_size = host_id_size;
     690                 :          9 :         verify_fn = verify_set_host_id_cmd;
     691                 :            : 
     692                 :          9 :         rc = nvme_ctrlr_cmd_set_host_id(&ctrlr, NULL, expected_host_id_size, NULL, NULL);
     693                 :            : 
     694         [ -  + ]:          9 :         DECONSTRUCT_CTRLR();
     695                 :          9 :         return rc;
     696                 :            : }
     697                 :            : 
     698                 :            : static void
     699                 :          3 : test_set_host_id_cmds(void)
     700                 :            : {
     701                 :          3 :         int rc = 0;
     702                 :            : 
     703                 :          3 :         rc = test_set_host_id_by_case(8);
     704                 :          3 :         CU_ASSERT(rc == 0);
     705                 :          3 :         rc = test_set_host_id_by_case(16);
     706                 :          3 :         CU_ASSERT(rc == 0);
     707                 :          3 :         rc = test_set_host_id_by_case(1024);
     708                 :          3 :         CU_ASSERT(rc == -EINVAL);
     709                 :          3 : }
     710                 :            : 
     711                 :            : static void
     712                 :          3 : test_get_log_pages(void)
     713                 :            : {
     714                 :          3 :         test_generic_get_log_pages();
     715                 :          3 :         test_intel_get_log_pages();
     716                 :          3 : }
     717                 :            : 
     718                 :            : static void
     719                 :          3 : test_namespace_attach(void)
     720                 :            : {
     721   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     722                 :          3 :         struct spdk_nvme_ctrlr_list             payload = {};
     723                 :            : 
     724                 :          3 :         verify_fn = verify_namespace_attach;
     725                 :            : 
     726                 :          3 :         nvme_ctrlr_cmd_attach_ns(&ctrlr, namespace_management_nsid, &payload, NULL, NULL);
     727                 :            : 
     728         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     729                 :          3 : }
     730                 :            : 
     731                 :            : static void
     732                 :          3 : test_namespace_detach(void)
     733                 :            : {
     734   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     735                 :          3 :         struct spdk_nvme_ctrlr_list             payload = {};
     736                 :            : 
     737                 :          3 :         verify_fn = verify_namespace_detach;
     738                 :            : 
     739                 :          3 :         nvme_ctrlr_cmd_detach_ns(&ctrlr, namespace_management_nsid, &payload, NULL, NULL);
     740                 :            : 
     741         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     742                 :          3 : }
     743                 :            : 
     744                 :            : static void
     745                 :          3 : test_namespace_create(void)
     746                 :            : {
     747   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     748                 :          3 :         struct spdk_nvme_ns_data                payload = {};
     749                 :            : 
     750                 :          3 :         verify_fn = verify_namespace_create;
     751                 :          3 :         nvme_ctrlr_cmd_create_ns(&ctrlr, &payload, NULL, NULL);
     752                 :            : 
     753         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     754                 :          3 : }
     755                 :            : 
     756                 :            : static void
     757                 :          3 : test_namespace_delete(void)
     758                 :            : {
     759   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     760                 :            : 
     761                 :          3 :         verify_fn = verify_namespace_delete;
     762                 :          3 :         nvme_ctrlr_cmd_delete_ns(&ctrlr, namespace_management_nsid, NULL, NULL);
     763                 :            : 
     764         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     765                 :          3 : }
     766                 :            : 
     767                 :            : static void
     768                 :          3 : test_doorbell_buffer_config(void)
     769                 :            : {
     770   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     771                 :            : 
     772                 :          3 :         verify_fn = verify_doorbell_buffer_config;
     773                 :            : 
     774                 :          3 :         nvme_ctrlr_cmd_doorbell_buffer_config(&ctrlr, PRP_ENTRY_1, PRP_ENTRY_2, NULL, NULL);
     775                 :            : 
     776         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     777                 :          3 : }
     778                 :            : 
     779                 :            : static void
     780                 :          3 : test_format_nvme(void)
     781                 :            : {
     782   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     783                 :          3 :         struct spdk_nvme_format format = {};
     784                 :            : 
     785                 :          3 :         verify_fn = verify_format_nvme;
     786                 :            : 
     787                 :          3 :         nvme_ctrlr_cmd_format(&ctrlr, format_nvme_nsid, &format, NULL, NULL);
     788                 :            : 
     789         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     790                 :          3 : }
     791                 :            : 
     792                 :            : static void
     793                 :          3 : test_fw_commit(void)
     794                 :            : {
     795   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     796                 :          3 :         struct spdk_nvme_fw_commit fw_commit = {};
     797                 :            : 
     798                 :          3 :         fw_commit.ca = SPDK_NVME_FW_COMMIT_REPLACE_AND_ENABLE_IMG;
     799                 :          3 :         fw_commit.fs = 1;
     800                 :            : 
     801                 :          3 :         verify_fn = verify_fw_commit;
     802                 :            : 
     803                 :          3 :         nvme_ctrlr_cmd_fw_commit(&ctrlr, &fw_commit, NULL, NULL);
     804                 :            : 
     805         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     806                 :          3 : }
     807                 :            : 
     808                 :            : static void
     809                 :          3 : test_fw_image_download(void)
     810                 :            : {
     811   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     812                 :            : 
     813                 :          3 :         verify_fn = verify_fw_image_download;
     814                 :            : 
     815                 :          3 :         nvme_ctrlr_cmd_fw_image_download(&ctrlr, fw_img_size, fw_img_offset, NULL,
     816                 :            :                                          NULL, NULL);
     817                 :            : 
     818         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     819                 :          3 : }
     820                 :            : 
     821                 :            : static void
     822                 :          3 : test_sanitize(void)
     823                 :            : {
     824   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     825                 :          3 :         struct spdk_nvme_sanitize sanitize = {};
     826                 :            : 
     827                 :          3 :         sanitize.sanact = 1;
     828                 :          3 :         sanitize.ause   = 1;
     829                 :          3 :         sanitize.oipbp  = 1;
     830                 :          3 :         sanitize.ndas   = 1;
     831                 :            : 
     832                 :          3 :         verify_fn = verify_nvme_sanitize;
     833                 :            : 
     834                 :          3 :         nvme_ctrlr_cmd_sanitize(&ctrlr, sanitize_nvme_nsid, &sanitize, 0, NULL, NULL);
     835                 :            : 
     836         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     837                 :          3 : }
     838                 :            : 
     839                 :            : static void
     840                 :          3 : test_directive_receive(void)
     841                 :            : {
     842   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     843                 :          3 :         verify_fn = verify_directive_receive;
     844                 :            : 
     845                 :          3 :         spdk_nvme_ctrlr_cmd_directive_receive(&ctrlr, directive_nsid, 0, 0, 0, NULL, 0,
     846                 :            :                                               0, 0, NULL, NULL);
     847                 :            : 
     848         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     849                 :          3 : }
     850                 :            : 
     851                 :            : static void
     852                 :          3 : test_directive_send(void)
     853                 :            : {
     854   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     855                 :          3 :         verify_fn = verify_directive_send;
     856                 :            : 
     857                 :          3 :         spdk_nvme_ctrlr_cmd_directive_send(&ctrlr, directive_nsid, 0, 0, 0, NULL, 0,
     858                 :            :                                            0, 0, NULL, NULL);
     859                 :            : 
     860         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     861                 :          3 : }
     862                 :            : 
     863                 :            : static void
     864                 :          3 : test_directive(void)
     865                 :            : {
     866                 :          3 :         test_directive_receive();
     867                 :          3 :         test_directive_send();
     868                 :          3 : }
     869                 :            : 
     870                 :            : static void
     871                 :          3 : test_nvme_request_add_abort(void)
     872                 :            : {
     873                 :            :         int rc;
     874                 :          3 :         struct nvme_request req = {};
     875                 :          3 :         struct nvme_request parent = {};
     876                 :          3 :         struct nvme_request child = {};
     877                 :          3 :         struct spdk_nvme_qpair qpair = {};
     878                 :          3 :         struct spdk_nvme_qpair admin_qpair = {};
     879                 :          3 :         struct spdk_nvme_ctrlr ctrlr = {};
     880                 :            : 
     881                 :          3 :         parent.qpair = &qpair;
     882                 :          3 :         qpair.ctrlr = &ctrlr;
     883                 :          3 :         ctrlr.adminq = &admin_qpair;
     884                 :            : 
     885                 :          3 :         parent.user_cb_arg = req.cb_arg;
     886                 :          3 :         parent.cmd.cdw10_bits.abort.sqid = 1;
     887                 :          3 :         req.cmd.cid = 2;
     888                 :            : 
     889                 :            :         /* For allocating request */
     890                 :          3 :         TAILQ_INIT(&parent.children);
     891                 :          3 :         STAILQ_INIT(&admin_qpair.free_req);
     892         [ +  - ]:          3 :         STAILQ_INSERT_HEAD(&admin_qpair.free_req, &child, stailq);
     893                 :            : 
     894                 :          3 :         rc = nvme_request_add_abort(&req, &parent);
     895                 :          3 :         CU_ASSERT(rc == 0);
     896         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(&child == TAILQ_FIRST(&parent.children));
     897                 :          3 :         CU_ASSERT(child.cb_arg == &child);
     898                 :          3 :         CU_ASSERT(child.cmd.opc == SPDK_NVME_OPC_ABORT);
     899                 :          3 :         CU_ASSERT(child.parent == &parent);
     900                 :          3 :         CU_ASSERT(child.cmd.cdw10_bits.abort.sqid == 1);
     901                 :          3 :         CU_ASSERT(child.cmd.cdw10_bits.abort.cid == 2);
     902                 :          3 :         CU_ASSERT(parent.num_children == 1);
     903                 :            : 
     904                 :          3 :         nvme_request_remove_child(&parent, &child);
     905                 :          3 :         CU_ASSERT(STAILQ_EMPTY(&admin_qpair.free_req));
     906                 :          3 :         CU_ASSERT(TAILQ_EMPTY(&parent.children));
     907                 :          3 :         CU_ASSERT(parent.num_children == 0);
     908                 :          3 :         CU_ASSERT(child.parent == NULL);
     909                 :            : 
     910                 :            :         /* Parent invalid */
     911                 :          3 :         req.cb_arg = (void *)0xDEADBEEF;
     912                 :          3 :         req.parent = NULL;
     913                 :          3 :         parent.user_cb_arg = (void *)0xDDADBEEF;
     914         [ +  - ]:          3 :         STAILQ_INSERT_HEAD(&admin_qpair.free_req, &child, stailq);
     915                 :            : 
     916                 :          3 :         rc = nvme_request_add_abort(&req, &parent);
     917                 :          3 :         CU_ASSERT(rc == 0);
     918                 :          3 :         CU_ASSERT(!STAILQ_EMPTY(&admin_qpair.free_req));
     919         [ +  - ]:          3 :         STAILQ_REMOVE_HEAD(&admin_qpair.free_req, stailq);
     920                 :          3 :         CU_ASSERT(STAILQ_EMPTY(&admin_qpair.free_req));
     921                 :            : 
     922                 :            :         /* Child request empty */
     923                 :          3 :         parent.user_cb_arg = req.cb_arg;
     924                 :            : 
     925                 :          3 :         rc = nvme_request_add_abort(&req, &parent);
     926                 :          3 :         CU_ASSERT(rc == -ENOMEM);
     927                 :          3 : }
     928                 :            : 
     929                 :            : static void
     930                 :          3 : test_spdk_nvme_ctrlr_cmd_abort(void)
     931                 :            : {
     932                 :            :         int rc;
     933                 :          3 :         struct spdk_nvme_ctrlr ctrlr = {};
     934                 :          3 :         struct spdk_nvme_qpair admin_qpair = {};
     935                 :          3 :         struct spdk_nvme_qpair *qpair = NULL;
     936                 :          3 :         struct nvme_request req = {};
     937                 :            : 
     938                 :            :         /* For allocating request */
     939                 :          3 :         STAILQ_INIT(&admin_qpair.free_req);
     940         [ +  - ]:          3 :         STAILQ_INSERT_HEAD(&admin_qpair.free_req, &req, stailq);
     941                 :          3 :         ctrlr.adminq = &admin_qpair;
     942                 :          3 :         admin_qpair.id = 0;
     943                 :          3 :         MOCK_SET(nvme_ctrlr_submit_admin_request, 0);
     944         [ -  + ]:          3 :         CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0);
     945                 :            : 
     946                 :          3 :         rc = spdk_nvme_ctrlr_cmd_abort(&ctrlr, qpair, 2, (void *)0xDEADBEEF, (void *)0xDCADBEEF);
     947                 :          3 :         CU_ASSERT(rc == 0);
     948                 :          3 :         CU_ASSERT(req.cb_arg == &req);
     949                 :          3 :         CU_ASSERT(req.user_cb_fn == (void *)0xDEADBEEF);
     950                 :          3 :         CU_ASSERT(req.user_cb_arg == (void *)0xDCADBEEF);
     951                 :          3 :         CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_ABORT);
     952                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.abort.sqid == 0);
     953                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.abort.cid == 2);
     954                 :          3 :         CU_ASSERT(STAILQ_EMPTY(&admin_qpair.free_req));
     955                 :            : 
     956                 :            :         /* Request empty */
     957                 :          3 :         rc = spdk_nvme_ctrlr_cmd_abort(&ctrlr, qpair, 2, (void *)0xDEADBEEF, (void *)0xDCADBEEF);
     958                 :          3 :         CU_ASSERT(rc == -ENOMEM);
     959   [ -  -  -  + ]:          3 :         MOCK_CLEAR(nvme_ctrlr_submit_admin_request);
     960         [ -  + ]:          3 :         CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0);
     961                 :          3 : }
     962                 :            : 
     963                 :            : static void
     964                 :          3 : test_nvme_ctrlr_cmd_identify(void)
     965                 :            : {
     966   [ +  -  -  + ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     967                 :          3 :         struct nvme_payload payload = {};
     968                 :            :         int rc;
     969                 :          3 :         MOCK_SET(nvme_ctrlr_submit_admin_request, 0);
     970                 :            : 
     971                 :          3 :         rc = nvme_ctrlr_cmd_identify(&ctrlr, SPDK_NVME_IDENTIFY_NS, 2, 1, 0, &payload,
     972                 :            :                                      SPDK_NVME_IDENTIFY_BUFLEN, NULL, NULL);
     973                 :          3 :         CU_ASSERT(rc == 0);
     974                 :          3 :         CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_IDENTIFY);
     975                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.identify.cns == SPDK_NVME_IDENTIFY_NS);
     976                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.identify.cntid == 2);
     977                 :          3 :         CU_ASSERT(req.cmd.cdw11_bits.identify.csi == 0);
     978                 :          3 :         CU_ASSERT(req.cmd.nsid == 1);
     979                 :          3 :         CU_ASSERT(STAILQ_EMPTY(&ctrlr.adminq->free_req));
     980         [ -  + ]:          3 :         DECONSTRUCT_CTRLR();
     981   [ -  -  -  + ]:          3 :         MOCK_CLEAR(nvme_ctrlr_submit_admin_request);
     982                 :          3 : }
     983                 :            : 
     984                 :            : static void
     985                 :          3 : test_spdk_nvme_ctrlr_cmd_security_receive_send(void)
     986                 :            : {
     987         [ +  - ]:          3 :         DECLARE_AND_CONSTRUCT_CTRLR();
     988                 :          3 :         struct nvme_payload payload = {};
     989                 :            :         int rc;
     990                 :          3 :         MOCK_SET(nvme_ctrlr_submit_admin_request, 0);
     991                 :            : 
     992                 :          3 :         rc = spdk_nvme_ctrlr_cmd_security_send(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
     993                 :          3 :         CU_ASSERT(rc == 0);
     994                 :          3 :         CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_SECURITY_SEND);
     995                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.nssf == 0xcc);
     996                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp0 == 0xbb);
     997                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp1 == 0xaa);
     998                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.secp == 0xea);
     999                 :          3 :         CU_ASSERT(req.cmd.cdw11 == 4096);
    1000         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(STAILQ_EMPTY(&ctrlr.adminq->free_req));
    1001                 :            : 
    1002                 :          3 :         memset(&req, 0, sizeof(req));
    1003         [ +  - ]:          3 :         STAILQ_INSERT_HEAD(&ctrlr.adminq->free_req, &req, stailq);
    1004                 :          3 :         rc = spdk_nvme_ctrlr_cmd_security_receive(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
    1005                 :          3 :         CU_ASSERT(rc == 0);
    1006                 :          3 :         CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_SECURITY_RECEIVE);
    1007                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.nssf == 0xcc);
    1008                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp0 == 0xbb);
    1009                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp1 == 0xaa);
    1010                 :          3 :         CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.secp == 0xea);
    1011                 :          3 :         CU_ASSERT(req.cmd.cdw11 == 4096);
    1012         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(STAILQ_EMPTY(&ctrlr.adminq->free_req));
    1013   [ -  -  -  + ]:          3 :         MOCK_CLEAR(nvme_ctrlr_submit_admin_request);
    1014                 :            : 
    1015                 :            :         /* Without request valid. */
    1016                 :          3 :         rc = spdk_nvme_ctrlr_cmd_security_send(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
    1017                 :          3 :         CU_ASSERT(rc == -ENOMEM);
    1018                 :            : 
    1019                 :          3 :         rc = spdk_nvme_ctrlr_cmd_security_receive(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
    1020                 :          3 :         CU_ASSERT(rc == -ENOMEM);
    1021                 :          3 :         DECONSTRUCT_CTRLR();
    1022                 :          3 : }
    1023                 :            : 
    1024                 :            : int
    1025                 :          3 : main(int argc, char **argv)
    1026                 :            : {
    1027                 :          3 :         CU_pSuite       suite = NULL;
    1028                 :            :         unsigned int    num_failures;
    1029                 :            : 
    1030                 :          3 :         CU_initialize_registry();
    1031                 :            : 
    1032                 :          3 :         suite = CU_add_suite("nvme_ctrlr_cmd", NULL, NULL);
    1033                 :            : 
    1034                 :          3 :         CU_ADD_TEST(suite, test_get_log_pages);
    1035                 :          3 :         CU_ADD_TEST(suite, test_set_feature_cmd);
    1036                 :          3 :         CU_ADD_TEST(suite, test_set_feature_ns_cmd);
    1037                 :          3 :         CU_ADD_TEST(suite, test_get_feature_cmd);
    1038                 :          3 :         CU_ADD_TEST(suite, test_get_feature_ns_cmd);
    1039                 :          3 :         CU_ADD_TEST(suite, test_abort_cmd);
    1040                 :          3 :         CU_ADD_TEST(suite, test_set_host_id_cmds);
    1041                 :          3 :         CU_ADD_TEST(suite, test_io_cmd_raw_no_payload_build);
    1042                 :          3 :         CU_ADD_TEST(suite, test_io_raw_cmd);
    1043                 :          3 :         CU_ADD_TEST(suite, test_io_raw_cmd_with_md);
    1044                 :          3 :         CU_ADD_TEST(suite, test_namespace_attach);
    1045                 :          3 :         CU_ADD_TEST(suite, test_namespace_detach);
    1046                 :          3 :         CU_ADD_TEST(suite, test_namespace_create);
    1047                 :          3 :         CU_ADD_TEST(suite, test_namespace_delete);
    1048                 :          3 :         CU_ADD_TEST(suite, test_doorbell_buffer_config);
    1049                 :          3 :         CU_ADD_TEST(suite, test_format_nvme);
    1050                 :          3 :         CU_ADD_TEST(suite, test_fw_commit);
    1051                 :          3 :         CU_ADD_TEST(suite, test_fw_image_download);
    1052                 :          3 :         CU_ADD_TEST(suite, test_sanitize);
    1053                 :          3 :         CU_ADD_TEST(suite, test_directive);
    1054                 :          3 :         CU_ADD_TEST(suite, test_nvme_request_add_abort);
    1055                 :          3 :         CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_cmd_abort);
    1056                 :          3 :         CU_ADD_TEST(suite, test_nvme_ctrlr_cmd_identify);
    1057                 :          3 :         CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_cmd_security_receive_send);
    1058                 :            : 
    1059                 :          3 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
    1060                 :          3 :         CU_cleanup_registry();
    1061                 :          3 :         return num_failures;
    1062                 :            : }

Generated by: LCOV version 1.14