LCOV - code coverage report
Current view: top level - spdk/test/common/lib - test_env.c (source / functions) Hit Total Coverage
Test: Combined Lines: 243 336 72.3 %
Date: 2024-11-17 17:31:13 Functions: 39 94 41.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 132 318 41.5 %

           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   [ -  +  -  + ]:         71 : DEFINE_STUB(spdk_process_is_primary, bool, (void), true)
      23   [ -  +  #  # ]:         18 : DEFINE_STUB(spdk_memzone_lookup, void *, (const char *name), NULL)
      24                 :          1 : 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                 :         40 : allocate_cores(uint32_t num_cores)
      40                 :            : {
      41                 :            :         uint32_t i;
      42                 :            : 
      43                 :         40 :         g_ut_num_cores = num_cores;
      44                 :            : 
      45                 :         40 :         g_ut_cores = calloc(num_cores, sizeof(bool));
      46         [ +  - ]:         40 :         assert(g_ut_cores != NULL);
      47                 :            : 
      48         [ +  + ]:        143 :         for (i = 0; i < num_cores; i++) {
      49                 :        103 :                 g_ut_cores[i] = true;
      50                 :        103 :         }
      51                 :         40 : }
      52                 :            : 
      53                 :            : void
      54                 :         40 : free_cores(void)
      55                 :            : {
      56                 :         40 :         free(g_ut_cores);
      57                 :         40 :         g_ut_cores = NULL;
      58                 :         40 :         g_ut_num_cores = 0;
      59                 :         40 : }
      60                 :            : 
      61                 :            : static uint32_t
      62                 :        306 : ut_get_next_core(uint32_t i)
      63                 :            : {
      64                 :        306 :         i++;
      65                 :            : 
      66         [ +  + ]:        306 :         while (i < g_ut_num_cores) {
      67         [ +  - ]:        226 :                 if (!g_ut_cores[i]) {
      68                 :          0 :                         i++;
      69                 :          0 :                         continue;
      70                 :            :                 }
      71                 :        226 :                 break;
      72                 :            :         }
      73                 :            : 
      74         [ +  + ]:        306 :         if (i < g_ut_num_cores) {
      75                 :        226 :                 return i;
      76                 :            :         } else {
      77                 :         80 :                 return UINT32_MAX;
      78                 :            :         }
      79                 :        306 : }
      80                 :            : 
      81                 :            : uint32_t
      82                 :         79 : spdk_env_get_first_core(void)
      83                 :            : {
      84                 :         79 :         return ut_get_next_core(-1);
      85                 :            : }
      86                 :            : 
      87                 :            : uint32_t
      88                 :        227 : spdk_env_get_next_core(uint32_t prev_core)
      89                 :            : {
      90                 :        227 :         return ut_get_next_core(prev_core);
      91                 :            : }
      92                 :            : 
      93                 :            : uint32_t
      94                 :         23 : spdk_env_get_core_count(void)
      95                 :            : {
      96                 :         23 :         return g_ut_num_cores;
      97                 :            : }
      98                 :            : 
      99                 :            : uint32_t
     100                 :         11 : spdk_env_get_last_core(void)
     101                 :            : {
     102                 :            :         uint32_t i;
     103                 :         11 :         uint32_t last_core = UINT32_MAX;
     104                 :            : 
     105         [ +  + ]:         42 :         SPDK_ENV_FOREACH_CORE(i) {
     106                 :         31 :                 last_core = i;
     107                 :         31 :         }
     108                 :            : 
     109                 :         11 :         return last_core;
     110                 :            : }
     111                 :            : 
     112         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_env_get_current_core, uint32_t);
     113                 :            : uint32_t
     114                 :         92 : spdk_env_get_current_core(void)
     115                 :            : {
     116   [ -  +  +  - ]:         92 :         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                 :          5 : spdk_memzone_reserve(const char *name, size_t len, int numa_id, unsigned flags)
     138                 :            : {
     139   [ -  +  +  + ]:          5 :         HANDLE_RETURN_MOCK(spdk_memzone_reserve);
     140                 :            : 
     141                 :          1 :         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                 :      19955 : spdk_malloc(size_t size, size_t align, uint64_t *phys_addr, int numa_id, uint32_t flags)
     157                 :            : {
     158   [ -  +  -  + ]:      19955 :         HANDLE_RETURN_MOCK(spdk_malloc);
     159                 :            : 
     160                 :      19955 :         void *buf = NULL;
     161                 :            : 
     162         [ +  + ]:      19955 :         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                 :          2 :                 return NULL;
     167                 :            :         }
     168                 :            : 
     169         [ +  + ]:      19953 :         if (align == 0) {
     170                 :       7132 :                 align = 8;
     171                 :       7132 :         }
     172                 :            : 
     173         [ -  + ]:      19953 :         if (posix_memalign(&buf, align, size)) {
     174                 :          0 :                 return NULL;
     175                 :            :         }
     176         [ +  - ]:      19953 :         if (phys_addr) {
     177                 :          0 :                 *phys_addr = (uint64_t)buf;
     178                 :          0 :         }
     179                 :            : 
     180                 :      19953 :         return buf;
     181                 :      19955 : }
     182                 :            : 
     183         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_zmalloc, void *);
     184                 :            : void *
     185                 :      15148 : spdk_zmalloc(size_t size, size_t align, uint64_t *phys_addr, int numa_id, uint32_t flags)
     186                 :            : {
     187   [ -  +  +  + ]:      15148 :         HANDLE_RETURN_MOCK(spdk_zmalloc);
     188                 :            : 
     189                 :      15147 :         void *buf = spdk_malloc(size, align, phys_addr, -1, 1);
     190                 :            : 
     191         [ +  + ]:      15147 :         if (buf != NULL) {
     192                 :      15145 :                 memset(buf, 0, size);
     193                 :      15145 :         }
     194                 :      15147 :         return buf;
     195                 :      15148 : }
     196                 :            : 
     197         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);
     198                 :            : void *
     199                 :         79 : spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)
     200                 :            : {
     201   [ -  +  -  + ]:         79 :         HANDLE_RETURN_MOCK(spdk_dma_malloc);
     202                 :            : 
     203                 :         79 :         return spdk_malloc(size, align, phys_addr, -1, 1);
     204                 :         79 : }
     205                 :            : 
     206         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_realloc, void *);
     207                 :            : void *
     208                 :       9817 : spdk_realloc(void *buf, size_t size, size_t align)
     209                 :            : {
     210   [ -  +  -  + ]:       9817 :         HANDLE_RETURN_MOCK(spdk_realloc);
     211                 :            : 
     212                 :       9817 :         return realloc(buf, size);
     213                 :       9817 : }
     214                 :            : 
     215         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *);
     216                 :            : void *
     217                 :         20 : spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)
     218                 :            : {
     219   [ -  +  -  + ]:         20 :         HANDLE_RETURN_MOCK(spdk_dma_zmalloc);
     220                 :            : 
     221                 :         20 :         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                 :          0 : spdk_dma_malloc_socket(size_t size, size_t align, uint64_t *phys_addr, int numa_id)
     227                 :            : {
     228   [ #  #  #  # ]:          0 :         HANDLE_RETURN_MOCK(spdk_dma_malloc_socket);
     229                 :            : 
     230                 :          0 :         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                 :          6 : spdk_dma_realloc(void *buf, size_t size, size_t align, uint64_t *phys_addr)
     245                 :            : {
     246   [ -  +  -  + ]:          6 :         HANDLE_RETURN_MOCK(spdk_dma_realloc);
     247                 :            : 
     248                 :          6 :         return realloc(buf, size);
     249                 :          6 : }
     250                 :            : 
     251                 :            : void
     252                 :      30494 : spdk_free(void *buf)
     253                 :            : {
     254                 :            :         /* fix for false-positives in *certain* static analysis tools. */
     255         [ +  - ]:      30494 :         assert((uintptr_t)buf != UINTPTR_MAX);
     256                 :      30494 :         free(buf);
     257                 :      30494 : }
     258                 :            : 
     259                 :            : void
     260                 :         93 : spdk_dma_free(void *buf)
     261                 :            : {
     262                 :         93 :         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                 :         40 : spdk_vtophys(const void *buf, uint64_t *size)
     269                 :            : {
     270   [ -  +  +  + ]:         40 :         HANDLE_RETURN_MOCK(spdk_vtophys);
     271                 :            : 
     272                 :         37 :         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                 :          0 : spdk_memzone_free(const char *name)
     289                 :            : {
     290   [ #  #  #  # ]:          0 :         HANDLE_RETURN_MOCK(spdk_memzone_free);
     291                 :            : 
     292                 :          0 :         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                 :        181 : 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   [ -  +  -  + ]:        181 :         HANDLE_RETURN_MOCK(spdk_mempool_create);
     308                 :            : 
     309                 :        181 :         mp = calloc(1, sizeof(*mp));
     310         [ -  + ]:        181 :         if (mp == NULL) {
     311                 :          0 :                 return NULL;
     312                 :            :         }
     313                 :            : 
     314                 :        181 :         mp->count = count;
     315                 :        181 :         mp->ele_size = ele_size;
     316                 :            : 
     317                 :        181 :         return (struct spdk_mempool *)mp;
     318                 :        181 : }
     319                 :            : 
     320                 :            : void
     321                 :        180 : spdk_mempool_free(struct spdk_mempool *_mp)
     322                 :            : {
     323                 :        180 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     324                 :            : 
     325                 :        180 :         free(mp);
     326                 :        180 : }
     327                 :            : 
     328         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_mempool_get, void *);
     329                 :            : void *
     330                 :     198432 : spdk_mempool_get(struct spdk_mempool *_mp)
     331                 :            : {
     332                 :     198432 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     333                 :     198432 :         size_t ele_size = 0x10000;
     334                 :            :         void *buf;
     335                 :            : 
     336   [ -  +  +  + ]:     198432 :         HANDLE_RETURN_MOCK(spdk_mempool_get);
     337                 :            : 
     338   [ +  +  +  + ]:     198419 :         if (mp && mp->count == 0) {
     339                 :          6 :                 return NULL;
     340                 :            :         }
     341                 :            : 
     342         [ +  + ]:     198413 :         if (mp) {
     343                 :     190221 :                 ele_size = mp->ele_size;
     344                 :     190221 :         }
     345                 :            : 
     346         [ -  + ]:     198413 :         if (posix_memalign(&buf, 64, spdk_align32pow2(ele_size))) {
     347                 :          0 :                 return NULL;
     348                 :            :         } else {
     349         [ +  + ]:     198413 :                 if (mp) {
     350                 :     190221 :                         mp->count--;
     351                 :     190221 :                 }
     352                 :     198413 :                 return buf;
     353                 :            :         }
     354                 :     198432 : }
     355                 :            : 
     356                 :            : int
     357                 :        190 : spdk_mempool_get_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
     358                 :            : {
     359                 :        190 :         struct test_mempool *test_mp = (struct test_mempool *)mp;
     360                 :            : 
     361   [ +  +  -  + ]:        190 :         if (test_mp && test_mp->count < count) {
     362                 :          0 :                 return -1;
     363                 :            :         }
     364                 :            : 
     365         [ +  + ]:     188612 :         for (size_t i = 0; i < count; i++) {
     366                 :     188422 :                 ele_arr[i] = spdk_mempool_get(mp);
     367         [ +  - ]:     188422 :                 if (ele_arr[i] == NULL) {
     368                 :          0 :                         return -1;
     369                 :            :                 }
     370                 :     188422 :         }
     371                 :        190 :         return 0;
     372                 :        190 : }
     373                 :            : 
     374                 :            : void
     375                 :     171792 : spdk_mempool_put(struct spdk_mempool *_mp, void *ele)
     376                 :            : {
     377                 :     171792 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     378                 :            : 
     379         [ +  + ]:     171792 :         if (mp) {
     380                 :     166669 :                 mp->count++;
     381                 :     166669 :         }
     382                 :     171792 :         free(ele);
     383                 :     171792 : }
     384                 :            : 
     385                 :            : void
     386                 :         33 : spdk_mempool_put_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
     387                 :            : {
     388         [ +  + ]:         68 :         for (size_t i = 0; i < count; i++) {
     389                 :         35 :                 spdk_mempool_put(mp, ele_arr[i]);
     390                 :         35 :         }
     391                 :         33 : }
     392                 :            : 
     393         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_mempool_count, size_t);
     394                 :            : size_t
     395                 :         85 : spdk_mempool_count(const struct spdk_mempool *_mp)
     396                 :            : {
     397                 :         85 :         struct test_mempool *mp = (struct test_mempool *)_mp;
     398                 :            : 
     399   [ -  +  -  + ]:         85 :         HANDLE_RETURN_MOCK(spdk_mempool_count);
     400                 :            : 
     401         [ -  + ]:         85 :         if (mp) {
     402                 :         85 :                 return mp->count;
     403                 :            :         } else {
     404                 :          0 :                 return 1024;
     405                 :            :         }
     406                 :         85 : }
     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                 :        350 : spdk_ring_create(enum spdk_ring_type type, size_t count, int numa_id)
     422                 :            : {
     423                 :            :         struct spdk_ring *ring;
     424                 :            : 
     425   [ -  +  -  + ]:        350 :         HANDLE_RETURN_MOCK(spdk_ring_create);
     426                 :            : 
     427                 :        350 :         ring = calloc(1, sizeof(*ring));
     428         [ +  - ]:        350 :         if (!ring) {
     429                 :          0 :                 return NULL;
     430                 :            :         }
     431                 :            : 
     432         [ +  - ]:        350 :         if (pthread_mutex_init(&ring->lock, NULL)) {
     433                 :          0 :                 free(ring);
     434                 :          0 :                 return NULL;
     435                 :            :         }
     436                 :            : 
     437                 :        350 :         TAILQ_INIT(&ring->elements);
     438                 :        350 :         return ring;
     439                 :        350 : }
     440                 :            : 
     441                 :            : void
     442                 :        324 : spdk_ring_free(struct spdk_ring *ring)
     443                 :            : {
     444                 :            :         struct spdk_ring_ele *ele, *tmp;
     445                 :            : 
     446         [ -  + ]:        324 :         if (!ring) {
     447                 :          0 :                 return;
     448                 :            :         }
     449                 :            : 
     450   [ +  +  +  + ]:     590164 :         TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
     451                 :     589840 :                 free(ele);
     452                 :     589840 :         }
     453                 :            : 
     454                 :        324 :         pthread_mutex_destroy(&ring->lock);
     455                 :        324 :         free(ring);
     456                 :        324 : }
     457                 :            : 
     458         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_ring_enqueue, size_t);
     459                 :            : size_t
     460                 :     676941 : 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   [ -  +  -  + ]:     676941 :         HANDLE_RETURN_MOCK(spdk_ring_enqueue);
     467                 :            : 
     468                 :     676941 :         pthread_mutex_lock(&ring->lock);
     469                 :            : 
     470         [ +  + ]:    1353883 :         for (i = 0; i < count; i++) {
     471                 :     676942 :                 ele = calloc(1, sizeof(*ele));
     472         [ -  + ]:     676942 :                 if (!ele) {
     473                 :          0 :                         break;
     474                 :            :                 }
     475                 :            : 
     476                 :     676942 :                 ele->ele = objs[i];
     477                 :     676942 :                 TAILQ_INSERT_TAIL(&ring->elements, ele, link);
     478                 :     676942 :                 ring->count++;
     479                 :     676942 :         }
     480                 :            : 
     481                 :     676941 :         pthread_mutex_unlock(&ring->lock);
     482                 :     676941 :         return i;
     483                 :     676941 : }
     484                 :            : 
     485         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_ring_dequeue, size_t);
     486                 :            : size_t
     487                 :     326178 : spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count)
     488                 :            : {
     489                 :            :         struct spdk_ring_ele *ele, *tmp;
     490                 :     326178 :         size_t i = 0;
     491                 :            : 
     492   [ -  +  -  + ]:     326178 :         HANDLE_RETURN_MOCK(spdk_ring_dequeue);
     493                 :            : 
     494         [ +  - ]:     326178 :         if (count == 0) {
     495                 :          0 :                 return 0;
     496                 :            :         }
     497                 :            : 
     498                 :     326178 :         pthread_mutex_lock(&ring->lock);
     499                 :            : 
     500   [ +  +  +  + ]:     402762 :         TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
     501         [ +  + ]:      87102 :                 TAILQ_REMOVE(&ring->elements, ele, link);
     502                 :      87102 :                 ring->count--;
     503                 :      87102 :                 objs[i] = ele->ele;
     504                 :      87102 :                 free(ele);
     505                 :      87102 :                 i++;
     506         [ +  + ]:      87102 :                 if (i >= count) {
     507                 :      10518 :                         break;
     508                 :            :                 }
     509                 :      76584 :         }
     510                 :            : 
     511                 :     326178 :         pthread_mutex_unlock(&ring->lock);
     512                 :     326178 :         return i;
     513                 :            : 
     514                 :     326178 : }
     515                 :            : 
     516                 :            : 
     517         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_ring_count, size_t);
     518                 :            : size_t
     519                 :        349 : spdk_ring_count(struct spdk_ring *ring)
     520                 :            : {
     521   [ -  +  -  + ]:        349 :         HANDLE_RETURN_MOCK(spdk_ring_count);
     522                 :        349 :         return ring->count;
     523                 :        349 : }
     524                 :            : 
     525         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_get_ticks, uint64_t);
     526                 :            : uint64_t
     527                 :     782443 : spdk_get_ticks(void)
     528                 :            : {
     529   [ -  +  +  + ]:     782443 :         HANDLE_RETURN_MOCK(spdk_get_ticks);
     530                 :            : 
     531                 :     777474 :         return ut_spdk_get_ticks;
     532                 :     782443 : }
     533                 :            : 
     534         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_get_ticks_hz, uint64_t);
     535                 :            : uint64_t
     536                 :        758 : spdk_get_ticks_hz(void)
     537                 :            : {
     538   [ -  +  +  + ]:        758 :         HANDLE_RETURN_MOCK(spdk_get_ticks_hz);
     539                 :            : 
     540                 :        754 :         return 1000000;
     541                 :        758 : }
     542                 :            : 
     543                 :            : void
     544                 :       2812 : spdk_delay_us(unsigned int us)
     545                 :            : {
     546                 :            :         /* spdk_get_ticks_hz is 1000000, meaning 1 tick per us. */
     547                 :       2812 :         ut_spdk_get_ticks += us;
     548                 :       2812 : }
     549                 :            : 
     550         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_pci_addr_parse, int);
     551                 :            : int
     552                 :         46 : spdk_pci_addr_parse(struct spdk_pci_addr *addr, const char *bdf)
     553                 :            : {
     554                 :            :         unsigned domain, bus, dev, func;
     555                 :            : 
     556   [ -  +  -  + ]:         46 :         HANDLE_RETURN_MOCK(spdk_pci_addr_parse);
     557                 :            : 
     558   [ +  -  -  + ]:         46 :         if (addr == NULL || bdf == NULL) {
     559                 :          0 :                 return -EINVAL;
     560                 :            :         }
     561                 :            : 
     562   [ +  +  -  + ]:         46 :         if ((sscanf(bdf, "%x:%x:%x.%x", &domain, &bus, &dev, &func) == 4) ||
     563                 :          4 :             (sscanf(bdf, "%x.%x.%x.%x", &domain, &bus, &dev, &func) == 4)) {
     564                 :            :                 /* Matched a full address - all variables are initialized */
     565         [ -  + ]:         46 :         } else if (sscanf(bdf, "%x:%x:%x", &domain, &bus, &dev) == 3) {
     566                 :          0 :                 func = 0;
     567   [ -  +  #  # ]:          4 :         } else if ((sscanf(bdf, "%x:%x.%x", &bus, &dev, &func) == 3) ||
     568                 :          0 :                    (sscanf(bdf, "%x.%x.%x", &bus, &dev, &func) == 3)) {
     569                 :          4 :                 domain = 0;
     570   [ #  #  #  # ]:          4 :         } else if ((sscanf(bdf, "%x:%x", &bus, &dev) == 2) ||
     571                 :          0 :                    (sscanf(bdf, "%x.%x", &bus, &dev) == 2)) {
     572                 :          0 :                 domain = 0;
     573                 :          0 :                 func = 0;
     574                 :          0 :         } else {
     575                 :          0 :                 return -EINVAL;
     576                 :            :         }
     577                 :            : 
     578   [ +  -  +  -  :         46 :         if (bus > 0xFF || dev > 0x1F || func > 7) {
                   -  + ]
     579                 :          0 :                 return -EINVAL;
     580                 :            :         }
     581                 :            : 
     582                 :         46 :         addr->domain = domain;
     583                 :         46 :         addr->bus = bus;
     584                 :         46 :         addr->dev = dev;
     585                 :         46 :         addr->func = func;
     586                 :            : 
     587                 :         46 :         return 0;
     588                 :         46 : }
     589                 :            : 
     590         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_pci_addr_fmt, int);
     591                 :            : int
     592                 :          1 : spdk_pci_addr_fmt(char *bdf, size_t sz, const struct spdk_pci_addr *addr)
     593                 :            : {
     594                 :            :         int rc;
     595                 :            : 
     596   [ -  +  -  + ]:          1 :         HANDLE_RETURN_MOCK(spdk_pci_addr_fmt);
     597                 :            : 
     598                 :          2 :         rc = snprintf(bdf, sz, "%04x:%02x:%02x.%x",
     599                 :          1 :                       addr->domain, addr->bus,
     600                 :          1 :                       addr->dev, addr->func);
     601                 :            : 
     602   [ +  -  -  + ]:          1 :         if (rc > 0 && (size_t)rc < sz) {
     603                 :          1 :                 return 0;
     604                 :            :         }
     605                 :            : 
     606                 :          0 :         return -1;
     607                 :          1 : }
     608                 :            : 
     609         [ #  # ]:          0 : DEFINE_RETURN_MOCK(spdk_pci_addr_compare, int);
     610                 :            : int
     611                 :         21 : spdk_pci_addr_compare(const struct spdk_pci_addr *a1, const struct spdk_pci_addr *a2)
     612                 :            : {
     613   [ -  +  -  + ]:         21 :         HANDLE_RETURN_MOCK(spdk_pci_addr_compare);
     614                 :            : 
     615         [ -  + ]:         21 :         if (a1->domain > a2->domain) {
     616                 :          0 :                 return 1;
     617         [ -  + ]:         21 :         } else if (a1->domain < a2->domain) {
     618                 :          0 :                 return -1;
     619         [ +  + ]:         21 :         } else if (a1->bus > a2->bus) {
     620                 :          1 :                 return 1;
     621         [ +  + ]:         20 :         } else if (a1->bus < a2->bus) {
     622                 :          2 :                 return -1;
     623         [ -  + ]:         18 :         } else if (a1->dev > a2->dev) {
     624                 :          0 :                 return 1;
     625         [ -  + ]:         18 :         } else if (a1->dev < a2->dev) {
     626                 :          0 :                 return -1;
     627         [ -  + ]:         18 :         } else if (a1->func > a2->func) {
     628                 :          0 :                 return 1;
     629         [ -  + ]:         18 :         } else if (a1->func < a2->func) {
     630                 :          0 :                 return -1;
     631                 :            :         }
     632                 :            : 
     633                 :         18 :         return 0;
     634                 :         21 : }

Generated by: LCOV version 1.14