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 [ - + - + ]: 450 : DEFINE_STUB(spdk_process_is_primary, bool, (void), true)
23 [ - + ]: 108 : DEFINE_STUB(spdk_memzone_lookup, void *, (const char *name), NULL)
24 : 6 : 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 : 234 : allocate_cores(uint32_t num_cores)
37 : : {
38 : : uint32_t i;
39 : :
40 : 234 : g_ut_num_cores = num_cores;
41 : :
42 : 234 : g_ut_cores = calloc(num_cores, sizeof(bool));
43 [ - + ]: 234 : assert(g_ut_cores != NULL);
44 : :
45 [ + + ]: 840 : for (i = 0; i < num_cores; i++) {
46 : 606 : g_ut_cores[i] = true;
47 : : }
48 : 234 : }
49 : :
50 : : void
51 : 234 : free_cores(void)
52 : : {
53 : 234 : free(g_ut_cores);
54 : 234 : g_ut_cores = NULL;
55 : 234 : g_ut_num_cores = 0;
56 : 234 : }
57 : :
58 : : static uint32_t
59 : 2316 : ut_get_next_core(uint32_t i)
60 : : {
61 : 2316 : i++;
62 : :
63 [ + + ]: 2316 : while (i < g_ut_num_cores) {
64 [ - + - + ]: 1680 : if (!g_ut_cores[i]) {
65 : 0 : i++;
66 : 0 : continue;
67 : : }
68 : 1680 : break;
69 : : }
70 : :
71 [ + + ]: 2316 : if (i < g_ut_num_cores) {
72 : 1680 : return i;
73 : : } else {
74 : 636 : return UINT32_MAX;
75 : : }
76 : : }
77 : :
78 : : uint32_t
79 : 636 : spdk_env_get_first_core(void)
80 : : {
81 : 636 : return ut_get_next_core(-1);
82 : : }
83 : :
84 : : uint32_t
85 : 1680 : spdk_env_get_next_core(uint32_t prev_core)
86 : : {
87 : 1680 : return ut_get_next_core(prev_core);
88 : : }
89 : :
90 : : uint32_t
91 : 144 : spdk_env_get_core_count(void)
92 : : {
93 : 144 : return g_ut_num_cores;
94 : : }
95 : :
96 : : uint32_t
97 : 60 : spdk_env_get_last_core(void)
98 : : {
99 : : uint32_t i;
100 : 60 : uint32_t last_core = UINT32_MAX;
101 : :
102 [ + + ]: 234 : SPDK_ENV_FOREACH_CORE(i) {
103 : 174 : last_core = i;
104 : : }
105 : :
106 : 60 : return last_core;
107 : : }
108 : :
109 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_env_get_current_core, uint32_t);
110 : : uint32_t
111 : 786 : spdk_env_get_current_core(void)
112 : : {
113 [ - + + + : 786 : HANDLE_RETURN_MOCK(spdk_env_get_current_core);
+ - ]
114 : :
115 : 0 : return UINT32_MAX;
116 : : }
117 : :
118 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_env_get_socket_id, uint32_t);
119 : : uint32_t
120 : 0 : spdk_env_get_socket_id(uint32_t core)
121 : : {
122 [ # # # # : 0 : HANDLE_RETURN_MOCK(spdk_env_get_socket_id);
# # ]
123 : :
124 : 0 : return SPDK_ENV_SOCKET_ID_ANY;
125 : : }
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 : 30 : spdk_memzone_reserve(const char *name, size_t len, int socket_id, unsigned flags)
135 : : {
136 [ - + + + : 30 : HANDLE_RETURN_MOCK(spdk_memzone_reserve);
+ + ]
137 : :
138 : 6 : return malloc(len);
139 : : }
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 socket_id,
144 : : unsigned flags, unsigned align)
145 : : {
146 [ # # # # : 0 : HANDLE_RETURN_MOCK(spdk_memzone_reserve_aligned);
# # ]
147 : :
148 : 0 : return malloc(len);
149 : : }
150 : :
151 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_malloc, void *);
152 : : void *
153 : 762705 : spdk_malloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
154 : : {
155 [ - + - + : 762705 : HANDLE_RETURN_MOCK(spdk_malloc);
- + ]
156 : :
157 : 762705 : void *buf = NULL;
158 : :
159 [ + + ]: 762705 : 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 : 12 : return NULL;
164 : : }
165 : :
166 [ + + ]: 762693 : if (align == 0) {
167 : 516341 : align = 8;
168 : : }
169 : :
170 [ - + - + ]: 762693 : if (posix_memalign(&buf, align, size)) {
171 : 0 : return NULL;
172 : : }
173 [ + + ]: 762693 : if (phys_addr) {
174 : 8 : *phys_addr = (uint64_t)buf;
175 : : }
176 : :
177 : 762693 : return buf;
178 : : }
179 : :
180 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_zmalloc, void *);
181 : : void *
182 : 91164 : spdk_zmalloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
183 : : {
184 [ - + + + : 91164 : HANDLE_RETURN_MOCK(spdk_zmalloc);
+ + ]
185 : :
186 : 91158 : void *buf = spdk_malloc(size, align, phys_addr, -1, 1);
187 : :
188 [ + + ]: 91158 : if (buf != NULL) {
189 [ - + ]: 91146 : memset(buf, 0, size);
190 : : }
191 : 91158 : return buf;
192 : : }
193 : :
194 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);
195 : : void *
196 : 643334 : spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)
197 : : {
198 [ - + - + : 643334 : HANDLE_RETURN_MOCK(spdk_dma_malloc);
- + ]
199 : :
200 : 643334 : return spdk_malloc(size, align, phys_addr, -1, 1);
201 : : }
202 : :
203 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_realloc, void *);
204 : : void *
205 : 59100 : spdk_realloc(void *buf, size_t size, size_t align)
206 : : {
207 [ - + - + : 59100 : HANDLE_RETURN_MOCK(spdk_realloc);
- + ]
208 : :
209 : 59100 : return realloc(buf, size);
210 : : }
211 : :
212 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *);
213 : : void *
214 : 120 : spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)
215 : : {
216 [ - + - + : 120 : HANDLE_RETURN_MOCK(spdk_dma_zmalloc);
- + ]
217 : :
218 : 120 : return spdk_zmalloc(size, align, phys_addr, -1, 1);
219 : : }
220 : :
221 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_dma_malloc_socket, void *);
222 : : void *
223 : 6 : spdk_dma_malloc_socket(size_t size, size_t align, uint64_t *phys_addr, int socket_id)
224 : : {
225 [ - + - + : 6 : HANDLE_RETURN_MOCK(spdk_dma_malloc_socket);
- + ]
226 : :
227 : 6 : return spdk_dma_malloc(size, align, phys_addr);
228 : : }
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 socket_id)
233 : : {
234 [ # # # # : 0 : HANDLE_RETURN_MOCK(spdk_dma_zmalloc_socket);
# # ]
235 : :
236 : 0 : return spdk_dma_zmalloc(size, align, phys_addr);
237 : : }
238 : :
239 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_dma_realloc, void *);
240 : : void *
241 : 36 : spdk_dma_realloc(void *buf, size_t size, size_t align, uint64_t *phys_addr)
242 : : {
243 [ - + - + : 36 : HANDLE_RETURN_MOCK(spdk_dma_realloc);
- + ]
244 : :
245 : 36 : return realloc(buf, size);
246 : : }
247 : :
248 : : void
249 : 716273 : spdk_free(void *buf)
250 : : {
251 : : /* fix for false-positives in *certain* static analysis tools. */
252 [ - + ]: 716273 : assert((uintptr_t)buf != UINTPTR_MAX);
253 : 716273 : free(buf);
254 : 716273 : }
255 : :
256 : : void
257 : 533538 : spdk_dma_free(void *buf)
258 : : {
259 : 533538 : 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 : 3412 : spdk_vtophys(const void *buf, uint64_t *size)
266 : : {
267 [ - + + + : 3412 : HANDLE_RETURN_MOCK(spdk_vtophys);
+ + ]
268 : :
269 : 3392 : return (uintptr_t)buf;
270 : : }
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 : 6 : spdk_memzone_free(const char *name)
282 : : {
283 [ - + - + : 6 : HANDLE_RETURN_MOCK(spdk_memzone_free);
- + ]
284 : :
285 : 6 : return 0;
286 : : }
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 : 1174 : spdk_mempool_create(const char *name, size_t count,
296 : : size_t ele_size, size_t cache_size, int socket_id)
297 : : {
298 : : struct test_mempool *mp;
299 : :
300 [ - + - + : 1174 : HANDLE_RETURN_MOCK(spdk_mempool_create);
+ + ]
301 : :
302 : 1172 : mp = calloc(1, sizeof(*mp));
303 [ - + ]: 1172 : if (mp == NULL) {
304 : 0 : return NULL;
305 : : }
306 : :
307 : 1172 : mp->count = count;
308 : 1172 : mp->ele_size = ele_size;
309 : :
310 : 1172 : return (struct spdk_mempool *)mp;
311 : : }
312 : :
313 : : void
314 : 1164 : spdk_mempool_free(struct spdk_mempool *_mp)
315 : : {
316 : 1164 : struct test_mempool *mp = (struct test_mempool *)_mp;
317 : :
318 : 1164 : free(mp);
319 : 1164 : }
320 : :
321 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_mempool_get, void *);
322 : : void *
323 : 1284268 : spdk_mempool_get(struct spdk_mempool *_mp)
324 : : {
325 : 1284268 : struct test_mempool *mp = (struct test_mempool *)_mp;
326 : 1284268 : size_t ele_size = 0x10000;
327 : 1066816 : void *buf;
328 : :
329 [ - + + + : 1284268 : HANDLE_RETURN_MOCK(spdk_mempool_get);
+ + ]
330 : :
331 [ + + + + ]: 1284188 : if (mp && mp->count == 0) {
332 : 36 : return NULL;
333 : : }
334 : :
335 [ + + ]: 1284152 : if (mp) {
336 : 1198100 : ele_size = mp->ele_size;
337 : : }
338 : :
339 [ - + - + ]: 1284152 : if (posix_memalign(&buf, 64, spdk_align32pow2(ele_size))) {
340 : 0 : return NULL;
341 : : } else {
342 [ + + ]: 1284152 : if (mp) {
343 : 1198100 : mp->count--;
344 : : }
345 : 1284152 : return buf;
346 : : }
347 : : }
348 : :
349 : : int
350 : 1328 : spdk_mempool_get_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
351 : : {
352 : 1328 : struct test_mempool *test_mp = (struct test_mempool *)mp;
353 : :
354 [ + + - + ]: 1328 : if (test_mp && test_mp->count < count) {
355 : 0 : return -1;
356 : : }
357 : :
358 [ + + ]: 1223104 : for (size_t i = 0; i < count; i++) {
359 : 1221778 : ele_arr[i] = spdk_mempool_get(mp);
360 [ + + ]: 1221778 : if (ele_arr[i] == NULL) {
361 : 2 : return -1;
362 : : }
363 : : }
364 : 1326 : return 0;
365 : : }
366 : :
367 : : void
368 : 1069076 : spdk_mempool_put(struct spdk_mempool *_mp, void *ele)
369 : : {
370 : 1069076 : struct test_mempool *mp = (struct test_mempool *)_mp;
371 : :
372 [ + + ]: 1069076 : if (mp) {
373 : 1007582 : mp->count++;
374 : : }
375 : 1069076 : free(ele);
376 : 1069076 : }
377 : :
378 : : void
379 : 320 : spdk_mempool_put_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
380 : : {
381 [ + + ]: 660 : for (size_t i = 0; i < count; i++) {
382 : 340 : spdk_mempool_put(mp, ele_arr[i]);
383 : : }
384 : 320 : }
385 : :
386 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_mempool_count, size_t);
387 : : size_t
388 : 505 : spdk_mempool_count(const struct spdk_mempool *_mp)
389 : : {
390 : 505 : struct test_mempool *mp = (struct test_mempool *)_mp;
391 : :
392 [ - + - + : 505 : HANDLE_RETURN_MOCK(spdk_mempool_count);
- + ]
393 : :
394 [ + - ]: 505 : if (mp) {
395 : 505 : return mp->count;
396 : : } else {
397 : 0 : return 1024;
398 : : }
399 : : }
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 : 2164 : spdk_ring_create(enum spdk_ring_type type, size_t count, int socket_id)
415 : : {
416 : : struct spdk_ring *ring;
417 : :
418 [ - + - + : 2164 : HANDLE_RETURN_MOCK(spdk_ring_create);
- + ]
419 : :
420 : 2164 : ring = calloc(1, sizeof(*ring));
421 [ - + ]: 2164 : if (!ring) {
422 : 0 : return NULL;
423 : : }
424 : :
425 [ - + - + ]: 2164 : if (pthread_mutex_init(&ring->lock, NULL)) {
426 : 0 : free(ring);
427 : 0 : return NULL;
428 : : }
429 : :
430 : 2164 : TAILQ_INIT(&ring->elements);
431 : 2164 : return ring;
432 : : }
433 : :
434 : : void
435 : 1954 : spdk_ring_free(struct spdk_ring *ring)
436 : : {
437 : : struct spdk_ring_ele *ele, *tmp;
438 : :
439 [ - + ]: 1954 : if (!ring) {
440 : 0 : return;
441 : : }
442 : :
443 [ + + ]: 3494890 : TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
444 : 3492936 : free(ele);
445 : : }
446 : :
447 [ - + ]: 1954 : pthread_mutex_destroy(&ring->lock);
448 : 1954 : free(ring);
449 : : }
450 : :
451 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_ring_enqueue, size_t);
452 : : size_t
453 : 4274546 : 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 [ - + - + : 4274546 : HANDLE_RETURN_MOCK(spdk_ring_enqueue);
- + ]
460 : :
461 [ - + ]: 4274546 : pthread_mutex_lock(&ring->lock);
462 : :
463 [ + + ]: 8549098 : for (i = 0; i < count; i++) {
464 : 4274552 : ele = calloc(1, sizeof(*ele));
465 [ - + ]: 4274552 : if (!ele) {
466 : 0 : break;
467 : : }
468 : :
469 : 4274552 : ele->ele = objs[i];
470 : 4274552 : TAILQ_INSERT_TAIL(&ring->elements, ele, link);
471 : 4274552 : ring->count++;
472 : : }
473 : :
474 [ - + ]: 4274546 : pthread_mutex_unlock(&ring->lock);
475 : 4274546 : return i;
476 : : }
477 : :
478 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_ring_dequeue, size_t);
479 : : size_t
480 : 2148460 : spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count)
481 : : {
482 : : struct spdk_ring_ele *ele, *tmp;
483 : 2148460 : size_t i = 0;
484 : :
485 [ - + - + : 2148460 : HANDLE_RETURN_MOCK(spdk_ring_dequeue);
- + ]
486 : :
487 [ - + ]: 2148460 : if (count == 0) {
488 : 0 : return 0;
489 : : }
490 : :
491 [ - + ]: 2148460 : pthread_mutex_lock(&ring->lock);
492 : :
493 [ + + ]: 2865336 : TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
494 [ + + ]: 781562 : TAILQ_REMOVE(&ring->elements, ele, link);
495 : 781562 : ring->count--;
496 : 781562 : objs[i] = ele->ele;
497 : 781562 : free(ele);
498 : 781562 : i++;
499 [ + + ]: 781562 : if (i >= count) {
500 : 64686 : break;
501 : : }
502 : : }
503 : :
504 [ - + ]: 2148460 : pthread_mutex_unlock(&ring->lock);
505 : 2148460 : return i;
506 : :
507 : : }
508 : :
509 : :
510 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_ring_count, size_t);
511 : : size_t
512 : 2148 : spdk_ring_count(struct spdk_ring *ring)
513 : : {
514 [ - + - + : 2148 : HANDLE_RETURN_MOCK(spdk_ring_count);
- + ]
515 : 2148 : return ring->count;
516 : : }
517 : :
518 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_get_ticks, uint64_t);
519 : : uint64_t
520 : 5185948 : spdk_get_ticks(void)
521 : : {
522 [ - + + + : 5185948 : HANDLE_RETURN_MOCK(spdk_get_ticks);
+ + ]
523 : :
524 : 5170126 : return ut_spdk_get_ticks;
525 : : }
526 : :
527 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_get_ticks_hz, uint64_t);
528 : : uint64_t
529 : 4705 : spdk_get_ticks_hz(void)
530 : : {
531 [ - + + + : 4705 : HANDLE_RETURN_MOCK(spdk_get_ticks_hz);
+ + ]
532 : :
533 : 4681 : return 1000000;
534 : : }
535 : :
536 : : void
537 : 1980 : spdk_delay_us(unsigned int us)
538 : : {
539 : : /* spdk_get_ticks_hz is 1000000, meaning 1 tick per us. */
540 : 1980 : ut_spdk_get_ticks += us;
541 : 1980 : }
542 : :
543 : : #ifndef UNIT_TEST_NO_PCI_ADDR
544 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_pci_addr_parse, int);
545 : : int
546 : 312 : spdk_pci_addr_parse(struct spdk_pci_addr *addr, const char *bdf)
547 : : {
548 : 260 : unsigned domain, bus, dev, func;
549 : :
550 [ - + - + : 312 : HANDLE_RETURN_MOCK(spdk_pci_addr_parse);
- + ]
551 : :
552 [ + - - + ]: 312 : if (addr == NULL || bdf == NULL) {
553 : 0 : return -EINVAL;
554 : : }
555 : :
556 [ + + + + ]: 312 : if ((sscanf(bdf, "%x:%x:%x.%x", &domain, &bus, &dev, &func) == 4) ||
557 [ + + + - ]: 36 : (sscanf(bdf, "%x.%x.%x.%x", &domain, &bus, &dev, &func) == 4)) {
558 : : /* Matched a full address - all variables are initialized */
559 [ - + - + ]: 36 : } else if (sscanf(bdf, "%x:%x:%x", &domain, &bus, &dev) == 3) {
560 : 0 : func = 0;
561 [ + + + + ]: 36 : } else if ((sscanf(bdf, "%x:%x.%x", &bus, &dev, &func) == 3) ||
562 [ - + - + ]: 12 : (sscanf(bdf, "%x.%x.%x", &bus, &dev, &func) == 3)) {
563 : 24 : domain = 0;
564 [ + + + - ]: 12 : } else if ((sscanf(bdf, "%x:%x", &bus, &dev) == 2) ||
565 [ - + - + ]: 12 : (sscanf(bdf, "%x.%x", &bus, &dev) == 2)) {
566 : 0 : domain = 0;
567 : 0 : func = 0;
568 : : } else {
569 : 12 : return -EINVAL;
570 : : }
571 : :
572 [ + - + - : 300 : if (bus > 0xFF || dev > 0x1F || func > 7) {
- + ]
573 : 0 : return -EINVAL;
574 : : }
575 : :
576 : 300 : addr->domain = domain;
577 : 300 : addr->bus = bus;
578 : 300 : addr->dev = dev;
579 : 300 : addr->func = func;
580 : :
581 : 300 : return 0;
582 : : }
583 : :
584 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_pci_addr_fmt, int);
585 : : int
586 : 6 : spdk_pci_addr_fmt(char *bdf, size_t sz, const struct spdk_pci_addr *addr)
587 : : {
588 : : int rc;
589 : :
590 [ - + - + : 6 : HANDLE_RETURN_MOCK(spdk_pci_addr_fmt);
- + ]
591 : :
592 [ - + ]: 3 : rc = snprintf(bdf, sz, "%04x:%02x:%02x.%x",
593 [ - + ]: 6 : addr->domain, addr->bus,
594 : 6 : addr->dev, addr->func);
595 : :
596 [ + - + - ]: 6 : if (rc > 0 && (size_t)rc < sz) {
597 : 6 : return 0;
598 : : }
599 : :
600 : 0 : return -1;
601 : : }
602 : :
603 [ # # ]: 0 : DEFINE_RETURN_MOCK(spdk_pci_addr_compare, int);
604 : : int
605 : 144 : spdk_pci_addr_compare(const struct spdk_pci_addr *a1, const struct spdk_pci_addr *a2)
606 : : {
607 [ - + - + : 144 : HANDLE_RETURN_MOCK(spdk_pci_addr_compare);
- + ]
608 : :
609 [ - + ]: 144 : if (a1->domain > a2->domain) {
610 : 0 : return 1;
611 [ - + ]: 144 : } else if (a1->domain < a2->domain) {
612 : 0 : return -1;
613 [ + + ]: 144 : } else if (a1->bus > a2->bus) {
614 : 6 : return 1;
615 [ + + ]: 138 : } else if (a1->bus < a2->bus) {
616 : 12 : return -1;
617 [ - + ]: 126 : } else if (a1->dev > a2->dev) {
618 : 0 : return 1;
619 [ - + ]: 126 : } else if (a1->dev < a2->dev) {
620 : 0 : return -1;
621 [ - + ]: 126 : } else if (a1->func > a2->func) {
622 : 0 : return 1;
623 [ - + ]: 126 : } else if (a1->func < a2->func) {
624 : 0 : return -1;
625 : : }
626 : :
627 : 126 : return 0;
628 : : }
629 : : #endif
|