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 : 341114 : spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count)
488 : : {
489 : : struct spdk_ring_ele *ele, *tmp;
490 : 341114 : size_t i = 0;
491 : :
492 [ - + - + ]: 341114 : HANDLE_RETURN_MOCK(spdk_ring_dequeue);
493 : :
494 [ + - ]: 341114 : if (count == 0) {
495 : 0 : return 0;
496 : : }
497 : :
498 : 341114 : pthread_mutex_lock(&ring->lock);
499 : :
500 [ + + + + ]: 417698 : 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 : 341114 : pthread_mutex_unlock(&ring->lock);
512 : 341114 : return i;
513 : :
514 : 341114 : }
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 : 812315 : spdk_get_ticks(void)
528 : : {
529 [ - + + + ]: 812315 : HANDLE_RETURN_MOCK(spdk_get_ticks);
530 : :
531 : 807346 : return ut_spdk_get_ticks;
532 : 812315 : }
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 : }
|