LCOV - code coverage report
Current view: top level - spdk/test/common/lib - test_env.c (source / functions) Hit Total Coverage
Test: Combined Lines: 254 338 75.1 %
Date: 2024-11-20 09:48:13 Functions: 41 94 43.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 202 2572 7.9 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2016 Intel Corporation.
       3                 :            :  *   Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES.
       4                 :            :  *   All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : #include "spdk/stdinc.h"
       8                 :            : 
       9                 :            : #include "spdk_internal/mock.h"
      10                 :            : 
      11                 :            : #include "spdk/env.h"
      12                 :            : #include "spdk/queue.h"
      13                 :            : #include "spdk/util.h"
      14                 :            : #include "spdk/string.h"
      15                 :            : 
      16                 :            : static uint32_t g_ut_num_cores;
      17                 :            : static bool *g_ut_cores;
      18                 :            : 
      19                 :            : void allocate_cores(uint32_t num_cores);
      20                 :            : void free_cores(void);
      21                 :            : 
      22   [ -  +  -  +  :        302 : DEFINE_STUB(spdk_process_is_primary, bool, (void), true)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
      23   [ -  +  #  #  :         72 : DEFINE_STUB(spdk_memzone_lookup, void *, (const char *name), NULL)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      24                 :          4 : DEFINE_STUB_V(spdk_pci_driver_register, (const char *name, struct spdk_pci_id *id_table,
      25                 :            :                 uint32_t flags));
      26   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_pci_nvme_get_driver, struct spdk_pci_driver *, (void), NULL)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      27   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_pci_ioat_get_driver, struct spdk_pci_driver *, (void), NULL)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      28   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_pci_virtio_get_driver, struct spdk_pci_driver *, (void), NULL)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      29   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_env_thread_launch_pinned, int, (uint32_t core, thread_start_fn fn, void *arg), 0);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      30                 :          0 : DEFINE_STUB_V(spdk_env_thread_wait_all, (void));
      31                 :          0 : DEFINE_STUB_V(spdk_env_opts_init, (struct spdk_env_opts *opts));
      32   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_env_init, int, (const struct spdk_env_opts *opts), 0);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      33                 :          0 : DEFINE_STUB_V(spdk_env_fini, (void));
      34   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_env_get_first_numa_id, int32_t, (void), 0);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      35   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_env_get_next_numa_id, int32_t, (int32_t prev_numa_id), INT32_MAX);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      36   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_env_get_last_numa_id, int32_t, (void), 0);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      37                 :            : 
      38                 :            : void
      39                 :        173 : allocate_cores(uint32_t num_cores)
      40                 :            : {
      41                 :            :         uint32_t i;
      42                 :            : 
      43                 :        173 :         g_ut_num_cores = num_cores;
      44                 :            : 
      45                 :        173 :         g_ut_cores = calloc(num_cores, sizeof(bool));
      46   [ +  +  #  # ]:        173 :         assert(g_ut_cores != NULL);
      47                 :            : 
      48         [ +  + ]:        609 :         for (i = 0; i < num_cores; i++) {
      49   [ #  #  #  # ]:        436 :                 g_ut_cores[i] = true;
      50                 :        106 :         }
      51                 :        173 : }
      52                 :            : 
      53                 :            : void
      54                 :        173 : free_cores(void)
      55                 :            : {
      56                 :        173 :         free(g_ut_cores);
      57                 :        173 :         g_ut_cores = NULL;
      58                 :        173 :         g_ut_num_cores = 0;
      59                 :        173 : }
      60                 :            : 
      61                 :            : static uint32_t
      62                 :       1530 : ut_get_next_core(uint32_t i)
      63                 :            : {
      64                 :       1530 :         i++;
      65                 :            : 
      66         [ +  + ]:       1530 :         while (i < g_ut_num_cores) {
      67   [ +  +  -  +  :       1108 :                 if (!g_ut_cores[i]) {
             #  #  #  # ]
      68                 :          0 :                         i++;
      69                 :          0 :                         continue;
      70                 :            :                 }
      71                 :       1108 :                 break;
      72                 :            :         }
      73                 :            : 
      74         [ +  + ]:       1530 :         if (i < g_ut_num_cores) {
      75                 :       1108 :                 return i;
      76                 :            :         } else {
      77                 :        422 :                 return UINT32_MAX;
      78                 :            :         }
      79                 :        306 : }
      80                 :            : 
      81                 :            : uint32_t
      82                 :        421 : spdk_env_get_first_core(void)
      83                 :            : {
      84                 :        421 :         return ut_get_next_core(-1);
      85                 :            : }
      86                 :            : 
      87                 :            : uint32_t
      88                 :       1109 : spdk_env_get_next_core(uint32_t prev_core)
      89                 :            : {
      90                 :       1109 :         return ut_get_next_core(prev_core);
      91                 :            : }
      92                 :            : 
      93                 :            : uint32_t
      94                 :         98 : spdk_env_get_core_count(void)
      95                 :            : {
      96                 :         98 :         return g_ut_num_cores;
      97                 :            : }
      98                 :            : 
      99                 :            : uint32_t
     100                 :         47 : spdk_env_get_last_core(void)
     101                 :            : {
     102                 :            :         uint32_t i;
     103                 :         47 :         uint32_t last_core = UINT32_MAX;
     104                 :            : 
     105         [ +  + ]:        177 :         SPDK_ENV_FOREACH_CORE(i) {
     106                 :        130 :                 last_core = i;
     107                 :         31 :         }
     108                 :            : 
     109                 :         47 :         return last_core;
     110                 :            : }
     111                 :            : 
     112   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_env_get_current_core, uint32_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     113                 :            : uint32_t
     114                 :        503 : spdk_env_get_current_core(void)
     115                 :            : {
     116   [ -  +  +  +  :        503 :         HANDLE_RETURN_MOCK(spdk_env_get_current_core);
                   +  - ]
     117                 :            : 
     118                 :          0 :         return UINT32_MAX;
     119                 :         92 : }
     120                 :            : 
     121   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_env_get_numa_id, int32_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     122                 :            : int32_t
     123                 :          0 : spdk_env_get_numa_id(uint32_t core)
     124                 :            : {
     125   [ #  #  #  #  :          0 :         HANDLE_RETURN_MOCK(spdk_env_get_numa_id);
                   #  # ]
     126                 :            : 
     127                 :          0 :         return SPDK_ENV_NUMA_ID_ANY;
     128                 :          0 : }
     129                 :            : 
     130                 :            : /*
     131                 :            :  * These mocks don't use the DEFINE_STUB macros because
     132                 :            :  * their default implementation is more complex.
     133                 :            :  */
     134                 :            : 
     135   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_memzone_reserve, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     136                 :            : void *
     137                 :         20 : spdk_memzone_reserve(const char *name, size_t len, int numa_id, unsigned flags)
     138                 :            : {
     139   [ -  +  +  +  :         20 :         HANDLE_RETURN_MOCK(spdk_memzone_reserve);
                   +  + ]
     140                 :            : 
     141                 :          4 :         return malloc(len);
     142                 :          5 : }
     143                 :            : 
     144   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_memzone_reserve_aligned, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     145                 :            : void *
     146                 :          0 : spdk_memzone_reserve_aligned(const char *name, size_t len, int numa_id,
     147                 :            :                              unsigned flags, unsigned align)
     148                 :            : {
     149   [ #  #  #  #  :          0 :         HANDLE_RETURN_MOCK(spdk_memzone_reserve_aligned);
                   #  # ]
     150                 :            : 
     151                 :          0 :         return malloc(len);
     152                 :          0 : }
     153                 :            : 
     154   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_malloc, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     155                 :            : void *
     156                 :      80011 : spdk_malloc(size_t size, size_t align, uint64_t *phys_addr, int numa_id, uint32_t flags)
     157                 :            : {
     158   [ -  +  -  +  :      80011 :         HANDLE_RETURN_MOCK(spdk_malloc);
                   -  + ]
     159                 :            : 
     160                 :      80011 :         void *buf = NULL;
     161                 :            : 
     162         [ +  + ]:      80011 :         if (size == 0) {
     163                 :            :                 /* Align how mock handles 0 size with rte functions - return NULL.
     164                 :            :                  * According to posix_memalig docs, if size is 0, then the
     165                 :            :                  * value placed in *memptr is either NULL or a unique pointer value. */
     166                 :          8 :                 return NULL;
     167                 :            :         }
     168                 :            : 
     169         [ +  + ]:      80003 :         if (align == 0) {
     170                 :      28597 :                 align = 8;
     171                 :       7132 :         }
     172                 :            : 
     173   [ -  +  -  + ]:      80003 :         if (posix_memalign(&buf, align, size)) {
     174                 :          0 :                 return NULL;
     175                 :            :         }
     176         [ +  + ]:      80003 :         if (phys_addr) {
     177         [ #  # ]:          0 :                 *phys_addr = (uint64_t)buf;
     178                 :          0 :         }
     179                 :            : 
     180                 :      80003 :         return buf;
     181                 :      19964 : }
     182                 :            : 
     183   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_zmalloc, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     184                 :            : void *
     185                 :      60722 : spdk_zmalloc(size_t size, size_t align, uint64_t *phys_addr, int numa_id, uint32_t flags)
     186                 :            : {
     187   [ -  +  +  +  :      60722 :         HANDLE_RETURN_MOCK(spdk_zmalloc);
                   +  + ]
     188                 :            : 
     189                 :      60718 :         void *buf = spdk_malloc(size, align, phys_addr, -1, 1);
     190                 :            : 
     191         [ +  + ]:      60718 :         if (buf != NULL) {
     192         [ -  + ]:      60710 :                 memset(buf, 0, size);
     193                 :      15148 :         }
     194                 :      60718 :         return buf;
     195                 :      15151 : }
     196                 :            : 
     197   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     198                 :            : void *
     199                 :        319 : spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)
     200                 :            : {
     201   [ -  +  -  +  :        319 :         HANDLE_RETURN_MOCK(spdk_dma_malloc);
                   -  + ]
     202                 :            : 
     203                 :        319 :         return spdk_malloc(size, align, phys_addr, -1, 1);
     204                 :         79 : }
     205                 :            : 
     206   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_realloc, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     207                 :            : void *
     208                 :      39403 : spdk_realloc(void *buf, size_t size, size_t align)
     209                 :            : {
     210   [ -  +  -  +  :      39403 :         HANDLE_RETURN_MOCK(spdk_realloc);
                   -  + ]
     211                 :            : 
     212                 :      39403 :         return realloc(buf, size);
     213                 :       9818 : }
     214                 :            : 
     215   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     216                 :            : void *
     217                 :         80 : spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)
     218                 :            : {
     219   [ -  +  -  +  :         80 :         HANDLE_RETURN_MOCK(spdk_dma_zmalloc);
                   -  + ]
     220                 :            : 
     221                 :         80 :         return spdk_zmalloc(size, align, phys_addr, -1, 1);
     222                 :         20 : }
     223                 :            : 
     224   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_dma_malloc_socket, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     225                 :            : void *
     226                 :          3 : spdk_dma_malloc_socket(size_t size, size_t align, uint64_t *phys_addr, int numa_id)
     227                 :            : {
     228   [ -  +  -  +  :          3 :         HANDLE_RETURN_MOCK(spdk_dma_malloc_socket);
                   -  + ]
     229                 :            : 
     230                 :          3 :         return spdk_dma_malloc(size, align, phys_addr);
     231                 :          0 : }
     232                 :            : 
     233   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_dma_zmalloc_socket, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     234                 :            : void *
     235                 :          0 : spdk_dma_zmalloc_socket(size_t size, size_t align, uint64_t *phys_addr, int numa_id)
     236                 :            : {
     237   [ #  #  #  #  :          0 :         HANDLE_RETURN_MOCK(spdk_dma_zmalloc_socket);
                   #  # ]
     238                 :            : 
     239                 :          0 :         return spdk_dma_zmalloc(size, align, phys_addr);
     240                 :          0 : }
     241                 :            : 
     242   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_dma_realloc, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     243                 :            : void *
     244                 :         24 : spdk_dma_realloc(void *buf, size_t size, size_t align, uint64_t *phys_addr)
     245                 :            : {
     246   [ -  +  -  +  :         24 :         HANDLE_RETURN_MOCK(spdk_dma_realloc);
                   -  + ]
     247                 :            : 
     248                 :         24 :         return realloc(buf, size);
     249                 :          6 : }
     250                 :            : 
     251                 :            : void
     252                 :     122380 : spdk_free(void *buf)
     253                 :            : {
     254                 :            :         /* fix for false-positives in *certain* static analysis tools. */
     255   [ +  +  #  # ]:     122380 :         assert((uintptr_t)buf != UINTPTR_MAX);
     256                 :     122380 :         free(buf);
     257                 :     122380 : }
     258                 :            : 
     259                 :            : void
     260                 :        450 : spdk_dma_free(void *buf)
     261                 :            : {
     262                 :        450 :         return spdk_free(buf);
     263                 :            : }
     264                 :            : 
     265                 :            : #ifndef UNIT_TEST_NO_VTOPHYS
     266   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_vtophys, uint64_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     267                 :            : uint64_t
     268                 :        160 : spdk_vtophys(const void *buf, uint64_t *size)
     269                 :            : {
     270   [ -  +  +  +  :        160 :         HANDLE_RETURN_MOCK(spdk_vtophys);
                   +  + ]
     271                 :            : 
     272                 :        148 :         return (uintptr_t)buf;
     273                 :         40 : }
     274                 :            : #endif
     275                 :            : 
     276                 :            : #ifndef UNIT_TEST_NO_ENV_MEMORY
     277   [ #  #  #  #  :          0 : DEFINE_STUB(spdk_mem_get_numa_id, int32_t, (const void *buf, uint64_t *size), 0);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     278                 :            : #endif
     279                 :            : 
     280                 :            : void
     281                 :          0 : spdk_memzone_dump(FILE *f)
     282                 :            : {
     283                 :          0 :         return;
     284                 :            : }
     285                 :            : 
     286   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_memzone_free, int);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     287                 :            : int
     288                 :          3 : spdk_memzone_free(const char *name)
     289                 :            : {
     290   [ -  +  -  +  :          3 :         HANDLE_RETURN_MOCK(spdk_memzone_free);
                   -  + ]
     291                 :            : 
     292                 :          3 :         return 0;
     293                 :          0 : }
     294                 :            : 
     295                 :            : struct test_mempool {
     296                 :            :         size_t  count;
     297                 :            :         size_t  ele_size;
     298                 :            : };
     299                 :            : 
     300   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_mempool_create, struct spdk_mempool *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     301                 :            : struct spdk_mempool *
     302                 :        781 : spdk_mempool_create(const char *name, size_t count,
     303                 :            :                     size_t ele_size, size_t cache_size, int numa_id)
     304                 :            : {
     305                 :            :         struct test_mempool *mp;
     306                 :            : 
     307   [ -  +  -  +  :        781 :         HANDLE_RETURN_MOCK(spdk_mempool_create);
                   -  + ]
     308                 :            : 
     309                 :        781 :         mp = calloc(1, sizeof(*mp));
     310         [ -  + ]:        781 :         if (mp == NULL) {
     311                 :          0 :                 return NULL;
     312                 :            :         }
     313                 :            : 
     314   [ #  #  #  # ]:        781 :         mp->count = count;
     315   [ #  #  #  # ]:        781 :         mp->ele_size = ele_size;
     316                 :            : 
     317                 :        781 :         return (struct spdk_mempool *)mp;
     318                 :        185 : }
     319                 :            : 
     320                 :            : void
     321                 :        777 : spdk_mempool_free(struct spdk_mempool *_mp)
     322                 :            : {
     323                 :        777 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     324                 :            : 
     325                 :        777 :         free(mp);
     326                 :        777 : }
     327                 :            : 
     328   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_mempool_get, void *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     329                 :            : void *
     330                 :     934368 : spdk_mempool_get(struct spdk_mempool *_mp)
     331                 :            : {
     332                 :     934368 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     333                 :     934368 :         size_t ele_size = 0x10000;
     334                 :     732608 :         void *buf;
     335                 :            : 
     336   [ -  +  +  +  :     934368 :         HANDLE_RETURN_MOCK(spdk_mempool_get);
                   +  + ]
     337                 :            : 
     338   [ +  +  +  +  :     934316 :         if (mp && mp->count == 0) {
             #  #  #  # ]
     339                 :         24 :                 return NULL;
     340                 :            :         }
     341                 :            : 
     342         [ +  + ]:     934292 :         if (mp) {
     343   [ #  #  #  # ]:     883074 :                 ele_size = mp->ele_size;
     344                 :     193549 :         }
     345                 :            : 
     346   [ -  +  -  + ]:     934292 :         if (posix_memalign(&buf, 64, spdk_align32pow2(ele_size))) {
     347                 :          0 :                 return NULL;
     348                 :            :         } else {
     349         [ +  + ]:     934292 :                 if (mp) {
     350         [ #  # ]:     883074 :                         mp->count--;
     351                 :     193549 :                 }
     352                 :     934292 :                 return buf;
     353                 :            :         }
     354                 :     201760 : }
     355                 :            : 
     356                 :            : int
     357                 :        837 : spdk_mempool_get_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
     358                 :            : {
     359                 :        837 :         struct test_mempool *test_mp = (struct test_mempool *)mp;
     360                 :            : 
     361   [ +  +  -  +  :        837 :         if (test_mp && test_mp->count < count) {
             #  #  #  # ]
     362                 :          0 :                 return -1;
     363                 :            :         }
     364                 :            : 
     365         [ +  + ]:     833373 :         for (size_t i = 0; i < count; i++) {
     366   [ #  #  #  # ]:     832536 :                 ele_arr[i] = spdk_mempool_get(mp);
     367   [ +  +  #  #  :     832536 :                 if (ele_arr[i] == NULL) {
                   #  # ]
     368                 :          0 :                         return -1;
     369                 :            :                 }
     370                 :     191494 :         }
     371                 :        837 :         return 0;
     372                 :        193 : }
     373                 :            : 
     374                 :            : void
     375                 :     797061 : spdk_mempool_put(struct spdk_mempool *_mp, void *ele)
     376                 :            : {
     377                 :     797061 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     378                 :            : 
     379         [ +  + ]:     797061 :         if (mp) {
     380         [ #  # ]:     761191 :                 mp->count++;
     381                 :     169997 :         }
     382                 :     797061 :         free(ele);
     383                 :     797061 : }
     384                 :            : 
     385                 :            : void
     386                 :        192 : spdk_mempool_put_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
     387                 :            : {
     388         [ +  + ]:        392 :         for (size_t i = 0; i < count; i++) {
     389   [ #  #  #  # ]:        200 :                 spdk_mempool_put(mp, ele_arr[i]);
     390                 :         35 :         }
     391                 :        192 : }
     392                 :            : 
     393   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_mempool_count, size_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     394                 :            : size_t
     395                 :        359 : spdk_mempool_count(const struct spdk_mempool *_mp)
     396                 :            : {
     397                 :        359 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     398                 :            : 
     399   [ -  +  -  +  :        359 :         HANDLE_RETURN_MOCK(spdk_mempool_count);
                   -  + ]
     400                 :            : 
     401         [ +  + ]:        359 :         if (mp) {
     402   [ #  #  #  # ]:        359 :                 return mp->count;
     403                 :            :         } else {
     404                 :          0 :                 return 1024;
     405                 :            :         }
     406                 :         88 : }
     407                 :            : 
     408                 :            : struct spdk_ring_ele {
     409                 :            :         void *ele;
     410                 :            :         TAILQ_ENTRY(spdk_ring_ele) link;
     411                 :            : };
     412                 :            : 
     413                 :            : struct spdk_ring {
     414                 :            :         TAILQ_HEAD(, spdk_ring_ele) elements;
     415                 :            :         pthread_mutex_t lock;
     416                 :            :         size_t count;
     417                 :            : };
     418                 :            : 
     419   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_ring_create, struct spdk_ring *);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     420                 :            : struct spdk_ring *
     421                 :       1515 : spdk_ring_create(enum spdk_ring_type type, size_t count, int numa_id)
     422                 :            : {
     423                 :            :         struct spdk_ring *ring;
     424                 :            : 
     425   [ -  +  -  +  :       1515 :         HANDLE_RETURN_MOCK(spdk_ring_create);
                   -  + ]
     426                 :            : 
     427                 :       1515 :         ring = calloc(1, sizeof(*ring));
     428         [ +  + ]:       1515 :         if (!ring) {
     429                 :          0 :                 return NULL;
     430                 :            :         }
     431                 :            : 
     432   [ +  +  -  +  :       1515 :         if (pthread_mutex_init(&ring->lock, NULL)) {
                   #  # ]
     433                 :          0 :                 free(ring);
     434                 :          0 :                 return NULL;
     435                 :            :         }
     436                 :            : 
     437   [ #  #  #  #  :       1515 :         TAILQ_INIT(&ring->elements);
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     438                 :       1515 :         return ring;
     439                 :        359 : }
     440                 :            : 
     441                 :            : void
     442                 :       1381 : spdk_ring_free(struct spdk_ring *ring)
     443                 :            : {
     444                 :            :         struct spdk_ring_ele *ele, *tmp;
     445                 :            : 
     446         [ -  + ]:       1381 :         if (!ring) {
     447                 :          0 :                 return;
     448                 :            :         }
     449                 :            : 
     450   [ +  +  +  +  :    2480549 :         TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     451                 :    2479168 :                 free(ele);
     452                 :     617488 :         }
     453                 :            : 
     454   [ -  +  #  # ]:       1381 :         pthread_mutex_destroy(&ring->lock);
     455                 :       1381 :         free(ring);
     456                 :        333 : }
     457                 :            : 
     458   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_ring_enqueue, size_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     459                 :            : size_t
     460                 :    2831746 : spdk_ring_enqueue(struct spdk_ring *ring, void **objs, size_t count,
     461                 :            :                   size_t *free_space)
     462                 :            : {
     463                 :            :         struct spdk_ring_ele *ele;
     464                 :            :         size_t i;
     465                 :            : 
     466   [ -  +  -  +  :    2831746 :         HANDLE_RETURN_MOCK(spdk_ring_enqueue);
                   -  + ]
     467                 :            : 
     468   [ -  +  #  # ]:    2831746 :         pthread_mutex_lock(&ring->lock);
     469                 :            : 
     470         [ +  + ]:    5663496 :         for (i = 0; i < count; i++) {
     471                 :    2831750 :                 ele = calloc(1, sizeof(*ele));
     472         [ -  + ]:    2831750 :                 if (!ele) {
     473                 :          0 :                         break;
     474                 :            :                 }
     475                 :            : 
     476   [ #  #  #  #  :    2831750 :                 ele->ele = objs[i];
             #  #  #  # ]
     477   [ #  #  #  #  :    2831750 :                 TAILQ_INSERT_TAIL(&ring->elements, ele, link);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     478         [ #  # ]:    2831750 :                 ring->count++;
     479                 :     704763 :         }
     480                 :            : 
     481   [ -  +  #  # ]:    2831746 :         pthread_mutex_unlock(&ring->lock);
     482                 :    2831746 :         return i;
     483                 :     704762 : }
     484                 :            : 
     485   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_ring_dequeue, size_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     486                 :            : size_t
     487                 :    1234983 : spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count)
     488                 :            : {
     489                 :            :         struct spdk_ring_ele *ele, *tmp;
     490                 :    1234983 :         size_t i = 0;
     491                 :            : 
     492   [ -  +  -  +  :    1234983 :         HANDLE_RETURN_MOCK(spdk_ring_dequeue);
                   -  + ]
     493                 :            : 
     494         [ +  + ]:    1234983 :         if (count == 0) {
     495                 :          0 :                 return 0;
     496                 :            :         }
     497                 :            : 
     498   [ -  +  #  # ]:    1234983 :         pthread_mutex_lock(&ring->lock);
     499                 :            : 
     500   [ +  +  +  +  :    1542292 :         TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     501   [ +  +  #  #  :     352555 :                 TAILQ_REMOVE(&ring->elements, ele, link);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     502         [ #  # ]:     352555 :                 ring->count--;
     503   [ #  #  #  #  :     352555 :                 objs[i] = ele->ele;
             #  #  #  # ]
     504                 :     352555 :                 free(ele);
     505                 :     352555 :                 i++;
     506         [ +  + ]:     352555 :                 if (i >= count) {
     507                 :      45246 :                         break;
     508                 :            :                 }
     509                 :      76613 :         }
     510                 :            : 
     511   [ -  +  #  # ]:    1234983 :         pthread_mutex_unlock(&ring->lock);
     512                 :    1234983 :         return i;
     513                 :            : 
     514                 :     351253 : }
     515                 :            : 
     516                 :            : 
     517   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_ring_count, size_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     518                 :            : size_t
     519                 :       1501 : spdk_ring_count(struct spdk_ring *ring)
     520                 :            : {
     521   [ -  +  -  +  :       1501 :         HANDLE_RETURN_MOCK(spdk_ring_count);
                   -  + ]
     522   [ #  #  #  # ]:       1501 :         return ring->count;
     523                 :        358 : }
     524                 :            : 
     525   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_get_ticks, uint64_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     526                 :            : uint64_t
     527                 :    2989678 : spdk_get_ticks(void)
     528                 :            : {
     529   [ -  +  +  +  :    2989678 :         HANDLE_RETURN_MOCK(spdk_get_ticks);
                   +  + ]
     530                 :            : 
     531                 :    2969436 :         return ut_spdk_get_ticks;
     532                 :     832294 : }
     533                 :            : 
     534   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_get_ticks_hz, uint64_t);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     535                 :            : uint64_t
     536                 :       3268 : spdk_get_ticks_hz(void)
     537                 :            : {
     538   [ -  +  +  +  :       3268 :         HANDLE_RETURN_MOCK(spdk_get_ticks_hz);
                   +  + ]
     539                 :            : 
     540                 :       3252 :         return 1000000;
     541                 :        762 : }
     542                 :            : 
     543                 :            : void
     544                 :      11266 : spdk_delay_us(unsigned int us)
     545                 :            : {
     546                 :            :         /* spdk_get_ticks_hz is 1000000, meaning 1 tick per us. */
     547                 :      11266 :         ut_spdk_get_ticks += us;
     548                 :      11266 : }
     549                 :            : 
     550   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_pci_addr_parse, int);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     551                 :            : int
     552                 :        202 : spdk_pci_addr_parse(struct spdk_pci_addr *addr, const char *bdf)
     553                 :            : {
     554                 :        156 :         unsigned domain, bus, dev, func;
     555                 :            : 
     556   [ -  +  -  +  :        202 :         HANDLE_RETURN_MOCK(spdk_pci_addr_parse);
                   -  + ]
     557                 :            : 
     558   [ +  -  -  + ]:        202 :         if (addr == NULL || bdf == NULL) {
     559                 :          0 :                 return -EINVAL;
     560                 :            :         }
     561                 :            : 
     562   [ +  +  +  + ]:        202 :         if ((sscanf(bdf, "%x:%x:%x.%x", &domain, &bus, &dev, &func) == 4) ||
     563   [ +  +  +  - ]:         22 :             (sscanf(bdf, "%x.%x.%x.%x", &domain, &bus, &dev, &func) == 4)) {
     564                 :            :                 /* Matched a full address - all variables are initialized */
     565   [ -  +  -  + ]:         64 :         } else if (sscanf(bdf, "%x:%x:%x", &domain, &bus, &dev) == 3) {
     566                 :          0 :                 func = 0;
     567   [ +  +  +  + ]:         22 :         } else if ((sscanf(bdf, "%x:%x.%x", &bus, &dev, &func) == 3) ||
     568   [ -  +  -  + ]:          6 :                    (sscanf(bdf, "%x.%x.%x", &bus, &dev, &func) == 3)) {
     569                 :         16 :                 domain = 0;
     570   [ +  +  +  - ]:         10 :         } else if ((sscanf(bdf, "%x:%x", &bus, &dev) == 2) ||
     571   [ -  +  -  + ]:          6 :                    (sscanf(bdf, "%x.%x", &bus, &dev) == 2)) {
     572                 :          0 :                 domain = 0;
     573                 :          0 :                 func = 0;
     574                 :          0 :         } else {
     575                 :          6 :                 return -EINVAL;
     576                 :            :         }
     577                 :            : 
     578   [ +  -  +  -  :        196 :         if (bus > 0xFF || dev > 0x1F || func > 7) {
                   -  + ]
     579                 :          0 :                 return -EINVAL;
     580                 :            :         }
     581                 :            : 
     582   [ #  #  #  # ]:        196 :         addr->domain = domain;
     583   [ #  #  #  # ]:        196 :         addr->bus = bus;
     584   [ #  #  #  # ]:        196 :         addr->dev = dev;
     585   [ #  #  #  # ]:        196 :         addr->func = func;
     586                 :            : 
     587                 :        196 :         return 0;
     588                 :         46 : }
     589                 :            : 
     590   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_pci_addr_fmt, int);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     591                 :            : int
     592                 :          4 : spdk_pci_addr_fmt(char *bdf, size_t sz, const struct spdk_pci_addr *addr)
     593                 :            : {
     594                 :            :         int rc;
     595                 :            : 
     596   [ -  +  -  +  :          4 :         HANDLE_RETURN_MOCK(spdk_pci_addr_fmt);
                   -  + ]
     597                 :            : 
     598                 :          3 :         rc = snprintf(bdf, sz, "%04x:%02x:%02x.%x",
     599   [ -  +  #  #  :          4 :                       addr->domain, addr->bus,
             #  #  #  # ]
     600   [ #  #  #  #  :          4 :                       addr->dev, addr->func);
             #  #  #  # ]
     601                 :            : 
     602   [ +  -  +  + ]:          4 :         if (rc > 0 && (size_t)rc < sz) {
     603                 :          4 :                 return 0;
     604                 :            :         }
     605                 :            : 
     606                 :          0 :         return -1;
     607                 :          1 : }
     608                 :            : 
     609   [ #  #  #  #  :          0 : DEFINE_RETURN_MOCK(spdk_pci_addr_compare, int);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     610                 :            : int
     611                 :         93 : spdk_pci_addr_compare(const struct spdk_pci_addr *a1, const struct spdk_pci_addr *a2)
     612                 :            : {
     613   [ -  +  -  +  :         93 :         HANDLE_RETURN_MOCK(spdk_pci_addr_compare);
                   -  + ]
     614                 :            : 
     615   [ -  +  #  #  :         93 :         if (a1->domain > a2->domain) {
          #  #  #  #  #  
                      # ]
     616                 :          0 :                 return 1;
     617   [ -  +  #  #  :         93 :         } else if (a1->domain < a2->domain) {
          #  #  #  #  #  
                      # ]
     618                 :          0 :                 return -1;
     619   [ +  +  #  #  :         93 :         } else if (a1->bus > a2->bus) {
          #  #  #  #  #  
                      # ]
     620                 :          4 :                 return 1;
     621   [ +  +  #  #  :         89 :         } else if (a1->bus < a2->bus) {
          #  #  #  #  #  
                      # ]
     622                 :          8 :                 return -1;
     623   [ -  +  #  #  :         81 :         } else if (a1->dev > a2->dev) {
          #  #  #  #  #  
                      # ]
     624                 :          0 :                 return 1;
     625   [ -  +  #  #  :         81 :         } else if (a1->dev < a2->dev) {
          #  #  #  #  #  
                      # ]
     626                 :          0 :                 return -1;
     627   [ -  +  #  #  :         81 :         } else if (a1->func > a2->func) {
          #  #  #  #  #  
                      # ]
     628                 :          0 :                 return 1;
     629   [ -  +  #  #  :         81 :         } else if (a1->func < a2->func) {
          #  #  #  #  #  
                      # ]
     630                 :          0 :                 return -1;
     631                 :            :         }
     632                 :            : 
     633                 :         81 :         return 0;
     634                 :         21 : }

Generated by: LCOV version 1.15