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