LCOV - code coverage report
Current view: top level - spdk/test/common/lib/nvme - common_stubs.h (source / functions) Hit Total Coverage
Test: Combined Lines: 33 73 45.2 %
Date: 2024-07-15 19:03:29 Functions: 13 59 22.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 11 66 16.7 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2020 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  *   Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : #include "common/lib/test_env.c"
       8                 :            : 
       9                 :            : const char *
      10                 :          0 : spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype)
      11                 :            : {
      12   [ #  #  #  # ]:          0 :         switch (trtype) {
      13                 :          0 :         case SPDK_NVME_TRANSPORT_PCIE:
      14                 :          0 :                 return "PCIe";
      15                 :          0 :         case SPDK_NVME_TRANSPORT_RDMA:
      16                 :          0 :                 return "RDMA";
      17                 :          0 :         case SPDK_NVME_TRANSPORT_FC:
      18                 :          0 :                 return "FC";
      19                 :          0 :         default:
      20                 :          0 :                 return NULL;
      21                 :            :         }
      22                 :            : }
      23                 :            : 
      24                 :            : int
      25                 :          0 : spdk_nvme_transport_id_populate_trstring(struct spdk_nvme_transport_id *trid, const char *trstring)
      26                 :            : {
      27                 :            :         int len, i;
      28                 :            : 
      29         [ #  # ]:          0 :         if (trstring == NULL) {
      30                 :          0 :                 return -EINVAL;
      31                 :            :         }
      32                 :            : 
      33         [ #  # ]:          0 :         len = strnlen(trstring, SPDK_NVMF_TRSTRING_MAX_LEN);
      34         [ #  # ]:          0 :         if (len == SPDK_NVMF_TRSTRING_MAX_LEN) {
      35                 :          0 :                 return -EINVAL;
      36                 :            :         }
      37                 :            : 
      38                 :            :         /* cast official trstring to uppercase version of input. */
      39         [ #  # ]:          0 :         for (i = 0; i < len; i++) {
      40                 :          0 :                 trid->trstring[i] = toupper(trstring[i]);
      41                 :            :         }
      42                 :          0 :         return 0;
      43                 :            : }
      44                 :            : 
      45         [ #  # ]:          0 : DEFINE_STUB(nvme_request_check_timeout, int, (struct nvme_request *req, uint16_t cid,
      46                 :            :                 struct spdk_nvme_ctrlr_process *active_proc, uint64_t now_tick), 0);
      47                 :         12 : DEFINE_STUB_V(nvme_ctrlr_destruct_finish, (struct spdk_nvme_ctrlr *ctrlr));
      48         [ -  + ]:         18 : DEFINE_STUB(nvme_ctrlr_construct, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
      49                 :          0 : DEFINE_STUB_V(nvme_ctrlr_destruct, (struct spdk_nvme_ctrlr *ctrlr));
      50         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_get_vs, int, (struct spdk_nvme_ctrlr *ctrlr,
      51                 :            :                                      union spdk_nvme_vs_register *vs), 0);
      52         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_get_cap, int, (struct spdk_nvme_ctrlr *ctrlr,
      53                 :            :                                       union spdk_nvme_cap_register *cap), 0);
      54                 :         15 : DEFINE_STUB_V(nvme_qpair_deinit, (struct spdk_nvme_qpair *qpair));
      55                 :          9 : DEFINE_STUB_V(spdk_nvme_transport_register, (const struct spdk_nvme_transport_ops *ops));
      56         [ #  # ]:          0 : DEFINE_STUB(nvme_transport_ctrlr_connect_qpair, int, (struct spdk_nvme_ctrlr *ctrlr,
      57                 :            :                 struct spdk_nvme_qpair *qpair), 0);
      58                 :          3 : DEFINE_STUB_V(nvme_transport_ctrlr_disconnect_qpair_done, (struct spdk_nvme_qpair *qpair));
      59         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_get_current_process, struct spdk_nvme_ctrlr_process *,
      60                 :            :             (struct spdk_nvme_ctrlr *ctrlr), (struct spdk_nvme_ctrlr_process *)(uintptr_t)0x1);
      61         [ -  + ]:          9 : DEFINE_STUB(nvme_ctrlr_add_process, int, (struct spdk_nvme_ctrlr *ctrlr, void *devhandle), 0);
      62                 :          3 : DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid,
      63                 :            :                 enum spdk_nvme_transport_type trtype));
      64         [ #  # ]:          0 : DEFINE_STUB(nvme_get_transport, const struct spdk_nvme_transport *, (const char *transport_name),
      65                 :            :             NULL);
      66         [ -  + ]:          3 : DEFINE_STUB(spdk_nvme_qpair_process_completions, int32_t, (struct spdk_nvme_qpair *qpair,
      67                 :            :                 uint32_t max_completions), 0);
      68                 :          0 : DEFINE_STUB_V(nvme_ctrlr_disable, (struct spdk_nvme_ctrlr *ctrlr));
      69         [ #  # ]:          0 : DEFINE_STUB(nvme_ctrlr_disable_poll, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
      70                 :            : 
      71                 :            : /* Fabric transports only */
      72                 :          0 : DEFINE_STUB_V(nvme_ctrlr_disconnect_qpair, (struct spdk_nvme_qpair *qpair));
      73         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_set_reg_4, int, (struct spdk_nvme_ctrlr *ctrlr, uint32_t offset,
      74                 :            :                 uint32_t value), 0);
      75         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_set_reg_8, int, (struct spdk_nvme_ctrlr *ctrlr, uint32_t offset,
      76                 :            :                 uint64_t value), 0);
      77         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_get_reg_4, int, (struct spdk_nvme_ctrlr *ctrlr, uint32_t offset,
      78                 :            :                 uint32_t *value), 0);
      79         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_get_reg_8, int, (struct spdk_nvme_ctrlr *ctrlr, uint32_t offset,
      80                 :            :                 uint64_t *value), 0);
      81         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_set_reg_4_async, int, (struct spdk_nvme_ctrlr *ctrlr, uint32_t offset,
      82                 :            :                 uint32_t value, spdk_nvme_reg_cb cb, void *ctx), 0);
      83         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_set_reg_8_async, int, (struct spdk_nvme_ctrlr *ctrlr, uint32_t offset,
      84                 :            :                 uint64_t value, spdk_nvme_reg_cb cb, void *ctx), 0);
      85         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_get_reg_4_async, int, (struct spdk_nvme_ctrlr *ctrlr,
      86                 :            :                 uint32_t offset, spdk_nvme_reg_cb cb, void *ctx), 0);
      87         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_get_reg_8_async, int, (struct spdk_nvme_ctrlr *ctrlr,
      88                 :            :                 uint32_t offset, spdk_nvme_reg_cb cb, void *ctx), 0);
      89         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_ctrlr_scan, int, (struct spdk_nvme_probe_ctx *probe_ctx,
      90                 :            :                 bool direct_connect), 0);
      91         [ #  # ]:          0 : DEFINE_STUB(nvme_fabric_qpair_connect, int, (struct spdk_nvme_qpair *qpair, uint32_t num_entries),
      92                 :            :             0);
      93         [ -  + ]:          3 : DEFINE_STUB(nvme_fabric_qpair_connect_async, int, (struct spdk_nvme_qpair *qpair,
      94                 :            :                 uint32_t num_entries), 0);
      95         [ -  + ]:          3 : DEFINE_STUB(nvme_fabric_qpair_connect_poll, int, (struct spdk_nvme_qpair *qpair), 0);
      96                 :          6 : DEFINE_STUB_V(nvme_transport_ctrlr_disconnect_qpair, (struct spdk_nvme_ctrlr *ctrlr,
      97                 :            :                 struct spdk_nvme_qpair *qpair));
      98         [ #  # ]:          0 : DEFINE_STUB(nvme_poll_group_disconnect_qpair, int, (struct spdk_nvme_qpair *qpair), 0);
      99                 :            : 
     100                 :            : int
     101                 :         27 : nvme_qpair_init(struct spdk_nvme_qpair *qpair, uint16_t id,
     102                 :            :                 struct spdk_nvme_ctrlr *ctrlr,
     103                 :            :                 enum spdk_nvme_qprio qprio,
     104                 :            :                 uint32_t num_requests, bool async)
     105                 :            : {
     106                 :         27 :         qpair->ctrlr = ctrlr;
     107                 :         27 :         qpair->id = id;
     108                 :         27 :         qpair->qprio = qprio;
     109                 :         27 :         qpair->async = async;
     110                 :         27 :         qpair->trtype = SPDK_NVME_TRANSPORT_TCP;
     111                 :         27 :         qpair->poll_group = (void *)0xDEADBEEF;
     112                 :            : 
     113                 :         27 :         return 0;
     114                 :            : }
     115                 :            : 
     116                 :            : int
     117                 :         42 : nvme_parse_addr(struct sockaddr_storage *sa, int family, const char *addr, const char *service,
     118                 :            :                 long int *port)
     119                 :            : {
     120                 :         42 :         struct addrinfo *res;
     121                 :         42 :         struct addrinfo hints;
     122                 :            :         int rc;
     123                 :            : 
     124         [ -  + ]:         42 :         SPDK_CU_ASSERT_FATAL(service != NULL);
     125                 :         42 :         *port = spdk_strtol(service, 10);
     126   [ +  -  +  + ]:         42 :         if (*port <= 0 || *port >= 65536) {
     127                 :          3 :                 return -EINVAL;
     128                 :            :         }
     129                 :            : 
     130                 :         39 :         memset(&hints, 0, sizeof(hints));
     131                 :         39 :         hints.ai_family = family;
     132                 :         39 :         hints.ai_socktype = SOCK_STREAM;
     133                 :            : 
     134                 :         39 :         rc = getaddrinfo(addr, service, &hints, &res);
     135         [ +  + ]:         39 :         if (rc == 0) {
     136                 :         36 :                 freeaddrinfo(res);
     137                 :            :         }
     138                 :         39 :         return rc;
     139                 :            : }

Generated by: LCOV version 1.14