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