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 : 79987 : spdk_malloc(size_t size, size_t align, uint64_t *phys_addr, int numa_id, uint32_t flags)
157 : : {
158 [ - + - + : 79987 : HANDLE_RETURN_MOCK(spdk_malloc);
- + ]
159 : :
160 : 79987 : void *buf = NULL;
161 : :
162 [ + + ]: 79987 : 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 [ + + ]: 79979 : if (align == 0) {
170 : 28597 : align = 8;
171 : 7132 : }
172 : :
173 [ - + - + ]: 79979 : if (posix_memalign(&buf, align, size)) {
174 : 0 : return NULL;
175 : : }
176 [ + + ]: 79979 : if (phys_addr) {
177 [ # # ]: 0 : *phys_addr = (uint64_t)buf;
178 : 0 : }
179 : :
180 : 79979 : return buf;
181 : 19958 : }
182 : :
183 [ # # # # : 0 : DEFINE_RETURN_MOCK(spdk_zmalloc, void *);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
184 : : void *
185 : 60714 : spdk_zmalloc(size_t size, size_t align, uint64_t *phys_addr, int numa_id, uint32_t flags)
186 : : {
187 [ - + + + : 60714 : HANDLE_RETURN_MOCK(spdk_zmalloc);
+ + ]
188 : :
189 : 60710 : void *buf = spdk_malloc(size, align, phys_addr, -1, 1);
190 : :
191 [ + + ]: 60710 : if (buf != NULL) {
192 [ - + ]: 60702 : memset(buf, 0, size);
193 : 15146 : }
194 : 60710 : return buf;
195 : 15149 : }
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 : 39404 : spdk_realloc(void *buf, size_t size, size_t align)
209 : : {
210 [ - + - + : 39404 : HANDLE_RETURN_MOCK(spdk_realloc);
- + ]
211 : :
212 : 39404 : 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 : 122357 : spdk_free(void *buf)
253 : : {
254 : : /* fix for false-positives in *certain* static analysis tools. */
255 [ + + # # ]: 122357 : assert((uintptr_t)buf != UINTPTR_MAX);
256 : 122357 : free(buf);
257 : 122357 : }
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 : 773 : 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 [ - + - + : 773 : HANDLE_RETURN_MOCK(spdk_mempool_create);
- + ]
308 : :
309 : 773 : mp = calloc(1, sizeof(*mp));
310 [ - + ]: 773 : if (mp == NULL) {
311 : 0 : return NULL;
312 : : }
313 : :
314 [ # # # # ]: 773 : mp->count = count;
315 [ # # # # ]: 773 : mp->ele_size = ele_size;
316 : :
317 : 773 : return (struct spdk_mempool *)mp;
318 : 183 : }
319 : :
320 : : void
321 : 769 : spdk_mempool_free(struct spdk_mempool *_mp)
322 : : {
323 : 769 : struct test_mempool *mp = (struct test_mempool *)_mp;
324 : :
325 : 769 : free(mp);
326 : 769 : }
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 : 351 : spdk_mempool_count(const struct spdk_mempool *_mp)
396 : : {
397 : 351 : struct test_mempool *mp = (struct test_mempool *)_mp;
398 : :
399 [ - + - + : 351 : HANDLE_RETURN_MOCK(spdk_mempool_count);
- + ]
400 : :
401 [ + + ]: 351 : if (mp) {
402 [ # # # # ]: 351 : return mp->count;
403 : : } else {
404 : 0 : return 1024;
405 : : }
406 : 86 : }
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 : 1499 : spdk_ring_create(enum spdk_ring_type type, size_t count, int numa_id)
422 : : {
423 : : struct spdk_ring *ring;
424 : :
425 [ - + - + : 1499 : HANDLE_RETURN_MOCK(spdk_ring_create);
- + ]
426 : :
427 : 1499 : ring = calloc(1, sizeof(*ring));
428 [ + + ]: 1499 : if (!ring) {
429 : 0 : return NULL;
430 : : }
431 : :
432 [ + + - + : 1499 : if (pthread_mutex_init(&ring->lock, NULL)) {
# # ]
433 : 0 : free(ring);
434 : 0 : return NULL;
435 : : }
436 : :
437 [ # # # # : 1499 : TAILQ_INIT(&ring->elements);
# # # # #
# # # # #
# # ]
438 : 1499 : return ring;
439 : 355 : }
440 : :
441 : : void
442 : 1365 : spdk_ring_free(struct spdk_ring *ring)
443 : : {
444 : : struct spdk_ring_ele *ele, *tmp;
445 : :
446 [ - + ]: 1365 : if (!ring) {
447 : 0 : return;
448 : : }
449 : :
450 [ + + + + : 2406805 : TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
# # # # #
# # # # #
# # ]
451 : 2405440 : free(ele);
452 : 599056 : }
453 : :
454 [ - + # # ]: 1365 : pthread_mutex_destroy(&ring->lock);
455 : 1365 : free(ring);
456 : 329 : }
457 : :
458 [ # # # # : 0 : DEFINE_RETURN_MOCK(spdk_ring_enqueue, size_t);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
459 : : size_t
460 : 2757970 : 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 [ - + - + : 2757970 : HANDLE_RETURN_MOCK(spdk_ring_enqueue);
- + ]
467 : :
468 [ - + # # ]: 2757970 : pthread_mutex_lock(&ring->lock);
469 : :
470 [ + + ]: 5515944 : for (i = 0; i < count; i++) {
471 : 2757974 : ele = calloc(1, sizeof(*ele));
472 [ - + ]: 2757974 : if (!ele) {
473 : 0 : break;
474 : : }
475 : :
476 [ # # # # : 2757974 : ele->ele = objs[i];
# # # # ]
477 [ # # # # : 2757974 : TAILQ_INSERT_TAIL(&ring->elements, ele, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
478 [ # # ]: 2757974 : ring->count++;
479 : 686319 : }
480 : :
481 [ - + # # ]: 2757970 : pthread_mutex_unlock(&ring->lock);
482 : 2757970 : return i;
483 : 686318 : }
484 : :
485 [ # # # # : 0 : DEFINE_RETURN_MOCK(spdk_ring_dequeue, size_t);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
486 : : size_t
487 : 1223222 : spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count)
488 : : {
489 : : struct spdk_ring_ele *ele, *tmp;
490 : 1223222 : size_t i = 0;
491 : :
492 [ - + - + : 1223222 : HANDLE_RETURN_MOCK(spdk_ring_dequeue);
- + ]
493 : :
494 [ + + ]: 1223222 : if (count == 0) {
495 : 0 : return 0;
496 : : }
497 : :
498 [ - + # # ]: 1223222 : pthread_mutex_lock(&ring->lock);
499 : :
500 [ + + + + : 1530483 : TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
# # # # #
# # # # #
# # ]
501 [ + + # # : 352507 : TAILQ_REMOVE(&ring->elements, ele, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
502 [ # # ]: 352507 : ring->count--;
503 [ # # # # : 352507 : objs[i] = ele->ele;
# # # # ]
504 : 352507 : free(ele);
505 : 352507 : i++;
506 [ + + ]: 352507 : if (i >= count) {
507 : 45246 : break;
508 : : }
509 : 76601 : }
510 : :
511 [ - + # # ]: 1223222 : pthread_mutex_unlock(&ring->lock);
512 : 1223222 : return i;
513 : :
514 : 277670 : }
515 : :
516 : :
517 [ # # # # : 0 : DEFINE_RETURN_MOCK(spdk_ring_count, size_t);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
518 : : size_t
519 : 1485 : spdk_ring_count(struct spdk_ring *ring)
520 : : {
521 [ - + - + : 1485 : HANDLE_RETURN_MOCK(spdk_ring_count);
- + ]
522 [ # # # # ]: 1485 : return ring->count;
523 : 354 : }
524 : :
525 [ # # # # : 0 : DEFINE_RETURN_MOCK(spdk_get_ticks, uint64_t);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
526 : : uint64_t
527 : 2971458 : spdk_get_ticks(void)
528 : : {
529 [ - + + + : 2971458 : HANDLE_RETURN_MOCK(spdk_get_ticks);
+ + ]
530 : :
531 : 2951216 : return ut_spdk_get_ticks;
532 : 685142 : }
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 : }
|