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