1
2
3
4
5#include <rte_common.h>
6#include <rte_hexdump.h>
7#include <rte_mbuf.h>
8#include <rte_malloc.h>
9#include <rte_memcpy.h>
10#include <rte_cycles.h>
11
12#include <rte_bus_vdev.h>
13
14#include <rte_bbdev.h>
15#include <rte_bbdev_op.h>
16#include <rte_bbdev_pmd.h>
17
18#include "main.h"
19
20
21#define BBDEV_NAME_NULL ("bbdev_null")
22
23struct bbdev_testsuite_params {
24 struct rte_bbdev_queue_conf qconf;
25};
26
27static struct bbdev_testsuite_params testsuite_params;
28
29static uint8_t null_dev_id;
30
31static int
32testsuite_setup(void)
33{
34 uint8_t nb_devs;
35 int ret;
36 char buf[RTE_BBDEV_NAME_MAX_LEN];
37
38
39 snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
40 ret = rte_vdev_init(buf, NULL);
41 TEST_ASSERT(ret == 0, "Failed to create instance of pmd: %s", buf);
42
43 nb_devs = rte_bbdev_count();
44 TEST_ASSERT(nb_devs != 0, "No devices found");
45
46
47 null_dev_id = nb_devs - 1;
48
49 return TEST_SUCCESS;
50}
51
52static void
53testsuite_teardown(void)
54{
55 char buf[RTE_BBDEV_NAME_MAX_LEN];
56
57 snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
58 rte_vdev_uninit(buf);
59}
60
61static int
62ut_setup(void)
63{
64 struct bbdev_testsuite_params *ts_params = &testsuite_params;
65 uint8_t num_queues;
66
67
68 ts_params->qconf.priority = 0;
69 ts_params->qconf.socket = SOCKET_ID_ANY;
70 ts_params->qconf.deferred_start = 1;
71
72 num_queues = 1;
73 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(null_dev_id, num_queues,
74 SOCKET_ID_ANY), "Failed to setup queues for bbdev %u",
75 0);
76
77
78 TEST_ASSERT_SUCCESS(rte_bbdev_start(null_dev_id),
79 "Failed to start bbdev %u", 0);
80
81 return TEST_SUCCESS;
82}
83
84static void
85ut_teardown(void)
86{
87 rte_bbdev_close(null_dev_id);
88}
89
90static int
91test_bbdev_configure_invalid_dev_id(void)
92{
93 uint8_t dev_id;
94 uint8_t num_queues;
95
96 num_queues = 1;
97 for (dev_id = 0; dev_id < RTE_BBDEV_MAX_DEVS; dev_id++) {
98 if (!rte_bbdev_is_valid(dev_id)) {
99 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
100 num_queues, SOCKET_ID_ANY),
101 "Failed test for rte_bbdev_setup_queues: "
102 "invalid dev_num %u", dev_id);
103 TEST_ASSERT(rte_bbdev_intr_enable(dev_id) == -ENODEV,
104 "Failed test for rte_bbdev_intr_enable: "
105 "invalid dev_num %u", dev_id);
106 break;
107 }
108 }
109
110 return TEST_SUCCESS;
111}
112
113static int
114test_bbdev_configure_invalid_num_queues(void)
115{
116 struct rte_bbdev_info info;
117 uint8_t dev_id, num_devs;
118 uint8_t num_queues;
119 int return_value;
120
121 TEST_ASSERT((num_devs = rte_bbdev_count()) >= 1,
122 "Need at least %d devices for test", 1);
123
124
125 num_queues = 8;
126
127
128 dev_id = null_dev_id;
129
130
131 rte_bbdev_stop(dev_id);
132
133 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 0, SOCKET_ID_ANY),
134 "Failed test for rte_bbdev_setup_queues: "
135 "invalid num_queues %d", 0);
136
137 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
138 SOCKET_ID_ANY),
139 "Failed test for rte_bbdev_setup_queues: "
140 "invalid dev_num %u", dev_id);
141
142 TEST_ASSERT_FAIL(return_value = rte_bbdev_info_get(dev_id, NULL),
143 "Failed test for rte_bbdev_info_get: "
144 "returned value:%i", return_value);
145
146 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
147 "Failed test for rte_bbdev_info_get: "
148 "invalid return value:%i", return_value);
149
150 TEST_ASSERT(info.num_queues == num_queues,
151 "Failed test for rte_bbdev_info_get: "
152 "invalid num_queues:%u", info.num_queues);
153
154 num_queues = info.drv.max_num_queues;
155 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
156 SOCKET_ID_ANY),
157 "Failed test for rte_bbdev_setup_queues: "
158 "invalid num_queues: %u", num_queues);
159
160 num_queues++;
161 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, num_queues,
162 SOCKET_ID_ANY),
163 "Failed test for rte_bbdev_setup_queues: "
164 "invalid num_queues: %u", num_queues);
165
166 return TEST_SUCCESS;
167}
168
169static int
170test_bbdev_configure_stop_device(void)
171{
172 struct rte_bbdev_info info;
173 uint8_t dev_id;
174 int return_value;
175
176
177 dev_id = null_dev_id;
178
179
180 rte_bbdev_stop(dev_id);
181
182 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
183 "Failed test for rte_bbdev_info_get: "
184 "invalid return value from "
185 "rte_bbdev_info_get function: %i", return_value);
186
187 TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
188 "started value: %u", info.started);
189
190 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
191 info.drv.max_num_queues, SOCKET_ID_ANY),
192 "Failed test for rte_bbdev_setup_queues: "
193 "device should be stopped, dev_id: %u", dev_id);
194
195 return_value = rte_bbdev_intr_enable(dev_id);
196 TEST_ASSERT(return_value != -EBUSY,
197 "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
198 dev_id);
199
200
201 TEST_ASSERT_FAIL(rte_bbdev_start(RTE_BBDEV_MAX_DEVS),
202 "Failed to start bbdev %u", dev_id);
203
204 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
205 "Failed to start bbdev %u", dev_id);
206
207 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
208 "Failed test for rte_bbdev_info_get: "
209 "invalid return value from "
210 "rte_bbdev_info_get function: %i", return_value);
211
212 TEST_ASSERT_FAIL(info.started, "Failed test for rte_bbdev_info_get: "
213 "started value: %u", info.started);
214
215 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
216 info.drv.max_num_queues, SOCKET_ID_ANY),
217 "Failed test for rte_bbdev_setup_queues: "
218 "device should be started, dev_id: %u", dev_id);
219
220 return_value = rte_bbdev_intr_enable(dev_id);
221 TEST_ASSERT(return_value == -EBUSY,
222 "Failed test for rte_bbdev_intr_enable: device should be started, dev_id: %u",
223 dev_id);
224
225
226 TEST_ASSERT_FAIL(rte_bbdev_stop(RTE_BBDEV_MAX_DEVS),
227 "Failed to start bbdev %u", dev_id);
228
229 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u",
230 dev_id);
231
232 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
233 "Failed test for rte_bbdev_info_get: "
234 "invalid return value from "
235 "rte_bbdev_info_get function: %i", return_value);
236
237 TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
238 "started value: %u", info.started);
239
240 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
241 info.drv.max_num_queues, SOCKET_ID_ANY),
242 "Failed test for rte_bbdev_setup_queues: "
243 "device should be stopped, dev_id: %u", dev_id);
244
245 return_value = rte_bbdev_intr_enable(dev_id);
246 TEST_ASSERT(return_value != -EBUSY,
247 "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
248 dev_id);
249
250 return TEST_SUCCESS;
251}
252
253static int
254test_bbdev_configure_stop_queue(void)
255{
256 struct bbdev_testsuite_params *ts_params = &testsuite_params;
257 struct rte_bbdev_info info;
258 struct rte_bbdev_queue_info qinfo;
259 uint8_t dev_id;
260 uint16_t queue_id;
261 int return_value;
262
263
264 dev_id = null_dev_id;
265
266
267 queue_id = 0;
268
269 rte_bbdev_stop(dev_id);
270 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
271 "Failed test for rte_bbdev_info_get: "
272 "invalid return value:%i", return_value);
273
274
275 ts_params->qconf.queue_size = info.drv.queue_size_lim;
276 ts_params->qconf.priority = info.drv.max_ul_queue_priority;
277
278
279 rte_bbdev_start(dev_id);
280
281 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
282 &ts_params->qconf),
283 "Failed test for rte_bbdev_queue_configure: "
284 "queue:%u on device:%u should be stopped",
285 queue_id, dev_id);
286
287
288 rte_bbdev_stop(dev_id);
289
290 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
291 &ts_params->qconf),
292 "Failed test for rte_bbdev_queue_configure: "
293 "queue:%u on device:%u should be stopped",
294 queue_id, dev_id);
295
296 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(RTE_BBDEV_MAX_DEVS, queue_id),
297 "Failed test for rte_bbdev_queue_stop "
298 "invalid dev_id ");
299
300 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, RTE_MAX_QUEUES_PER_PORT),
301 "Failed test for rte_bbdev_queue_stop "
302 "invalid queue_id ");
303
304
305 rte_bbdev_queue_stop(dev_id, queue_id);
306
307 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
308 &ts_params->qconf),
309 "Failed test for rte_bbdev_queue_configure: "
310 "queue:%u on device:%u should be stopped", queue_id,
311 dev_id);
312
313 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
314 queue_id, &qinfo),
315 "Failed test for rte_bbdev_info_get: "
316 "invalid return value from "
317 "rte_bbdev_queue_info_get function: %i", return_value);
318
319 TEST_ASSERT(qinfo.conf.socket == ts_params->qconf.socket,
320 "Failed test for rte_bbdev_queue_info_get: "
321 "invalid queue_size:%u", qinfo.conf.socket);
322
323 TEST_ASSERT(qinfo.conf.queue_size == ts_params->qconf.queue_size,
324 "Failed test for rte_bbdev_queue_info_get: "
325 "invalid queue_size:%u", qinfo.conf.queue_size);
326
327 TEST_ASSERT(qinfo.conf.priority == ts_params->qconf.priority,
328 "Failed test for rte_bbdev_queue_info_get: "
329 "invalid queue_size:%u", qinfo.conf.priority);
330
331 TEST_ASSERT(qinfo.conf.deferred_start ==
332 ts_params->qconf.deferred_start,
333 "Failed test for rte_bbdev_queue_info_get: "
334 "invalid queue_size:%u", qinfo.conf.deferred_start);
335
336
337 rte_bbdev_start(dev_id);
338 rte_bbdev_queue_stop(dev_id, queue_id);
339
340 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
341 &ts_params->qconf),
342 "Failed test for rte_bbdev_queue_configure: "
343 "queue:%u on device:%u should be stopped", queue_id,
344 dev_id);
345
346 rte_bbdev_stop(dev_id);
347
348
349
350
351 rte_bbdev_start(dev_id);
352
353 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
354 queue_id, &qinfo),
355 "Failed test for rte_bbdev_info_get: "
356 "invalid return value from "
357 "rte_bbdev_queue_info_get function: %i", return_value);
358
359 TEST_ASSERT(qinfo.started == 0,
360 "Failed test for rte_bbdev_queue_info_get: "
361 "invalid value for qinfo.started:%u", qinfo.started);
362
363 rte_bbdev_stop(dev_id);
364
365
366
367
368 ts_params->qconf.deferred_start = 0;
369 rte_bbdev_queue_configure(dev_id, queue_id, &ts_params->qconf);
370 rte_bbdev_start(dev_id);
371
372 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
373 queue_id, &qinfo),
374 "Failed test for rte_bbdev_info_get: "
375 "invalid return value from "
376 "rte_bbdev_queue_info_get function: %i", return_value);
377
378 TEST_ASSERT(qinfo.started == 1,
379 "Failed test for rte_bbdev_queue_info_get: "
380 "invalid value for qinfo.started:%u", qinfo.started);
381
382 return TEST_SUCCESS;
383}
384
385static int
386test_bbdev_configure_invalid_queue_configure(void)
387{
388 struct bbdev_testsuite_params *ts_params = &testsuite_params;
389 int return_value;
390 struct rte_bbdev_info info;
391 uint8_t dev_id;
392 uint16_t queue_id;
393
394
395 dev_id = null_dev_id;
396
397
398 queue_id = 0;
399
400 rte_bbdev_stop(dev_id);
401
402 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
403 "Failed test for rte_bbdev_info_get: "
404 "invalid return value:%i", return_value);
405
406 rte_bbdev_queue_stop(dev_id, queue_id);
407
408 ts_params->qconf.queue_size = info.drv.queue_size_lim + 1;
409 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
410 &ts_params->qconf),
411 "Failed test for rte_bbdev_queue_configure: "
412 "invalid value qconf.queue_size: %u",
413 ts_params->qconf.queue_size);
414
415 ts_params->qconf.queue_size = info.drv.queue_size_lim;
416 ts_params->qconf.priority = info.drv.max_ul_queue_priority;
417 queue_id = info.num_queues;
418 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
419 &ts_params->qconf),
420 "Failed test for rte_bbdev_queue_configure: "
421 "invalid value queue_id: %u", queue_id);
422
423 queue_id = 0;
424 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
425 "Failed test for rte_bbdev_queue_configure: "
426 "NULL qconf structure ");
427
428 ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
429 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
430 &ts_params->qconf),
431 "Failed test for rte_bbdev_queue_configure: "
432 "invalid socket number ");
433
434 ts_params->qconf.socket = SOCKET_ID_ANY;
435 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
436 &ts_params->qconf),
437 "Failed test for rte_bbdev_queue_configure: "
438 "invalid value qconf.queue_size: %u",
439 ts_params->qconf.queue_size);
440
441 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
442 &ts_params->qconf),
443 "Failed test for rte_bbdev_queue_configure: "
444 "invalid dev_id");
445
446 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
447 "Failed test for rte_bbdev_queue_configure: "
448 "invalid value qconf.queue_size: %u",
449 ts_params->qconf.queue_size);
450
451 return TEST_SUCCESS;
452}
453
454static int
455test_bbdev_op_pool(void)
456{
457 struct rte_mempool *mp;
458
459 unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
460 unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
461
462 const char *pool_dec = "Test_DEC";
463 const char *pool_enc = "Test_ENC";
464
465
466 uint32_t size = 256;
467 uint32_t cache_size = 128;
468
469 TEST_ASSERT(rte_bbdev_op_pool_create(NULL,
470 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL,
471 "Failed test for rte_bbdev_op_pool_create: "
472 "NULL name parameter");
473
474 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec,
475 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL,
476 "Failed test for rte_bbdev_op_pool_create: "
477 "returned value is empty");
478
479 TEST_ASSERT(mp->size == size,
480 "Failed test for rte_bbdev_op_pool_create: "
481 "invalid size of the mempool, mp->size: %u", mp->size);
482
483 TEST_ASSERT(mp->cache_size == cache_size,
484 "Failed test for rte_bbdev_op_pool_create: "
485 "invalid size of the mempool, mp->size: %u",
486 mp->cache_size);
487
488 TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec),
489 "Failed test for rte_bbdev_op_pool_create: "
490 "invalid name of mempool, mp->name: %s", mp->name);
491
492 TEST_ASSERT(mp->elt_size == dec_size,
493 "Failed test for rte_bbdev_op_pool_create: "
494 "invalid element size for RTE_BBDEV_OP_TURBO_DEC, "
495 "mp->elt_size: %u", mp->elt_size);
496
497 rte_mempool_free(mp);
498
499 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc,
500 RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL,
501 "Failed test for rte_bbdev_op_pool_create: "
502 "returned value is empty");
503
504 TEST_ASSERT(mp->elt_size == enc_size,
505 "Failed test for rte_bbdev_op_pool_create: "
506 "invalid element size for RTE_BBDEV_OP_TURBO_ENC, "
507 "mp->elt_size: %u", mp->elt_size);
508
509 rte_mempool_free(mp);
510
511 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE",
512 RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL,
513 "Failed test for rte_bbdev_op_pool_create: "
514 "returned value is empty for RTE_BBDEV_OP_NONE");
515
516 TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size),
517 "Failed test for rte_bbdev_op_pool_create: "
518 "invalid size for RTE_BBDEV_OP_NONE, mp->elt_size: %u",
519 mp->elt_size);
520
521 rte_mempool_free(mp);
522
523 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV",
524 RTE_BBDEV_OP_TYPE_COUNT, size, cache_size, 0)) == NULL,
525 "Failed test for rte_bbdev_op_pool_create: "
526 "returned value is not NULL for invalid type");
527
528
529 size = 128;
530 cache_size = 256;
531
532 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize",
533 RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL,
534 "Failed test for rte_bbdev_op_pool_create: "
535 "returned value should be empty "
536 "because size of per-lcore local cache "
537 "is greater than size of the mempool.");
538
539 return TEST_SUCCESS;
540}
541
542
543
544
545
546
547static int
548test_bbdev_op_type(void)
549{
550 struct rte_mempool *mp_dec;
551
552 const unsigned int OPS_COUNT = 32;
553 struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
554 struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT];
555
556 const char *pool_dec = "Test_op_dec";
557
558
559 uint32_t num_elements = 256;
560 uint32_t cache_size = 128;
561
562
563 mp_dec = rte_bbdev_op_pool_create(pool_dec,
564 RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0);
565 TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec);
566
567 TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0,
568 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
569 "OPs type: RTE_BBDEV_OP_TURBO_DEC");
570
571 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0,
572 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
573 "OPs type: RTE_BBDEV_OP_TURBO_ENC");
574
575 rte_mempool_free(mp_dec);
576
577 return TEST_SUCCESS;
578}
579
580static int
581test_bbdev_op_pool_size(void)
582{
583 struct rte_mempool *mp_none;
584
585 const unsigned int OPS_COUNT = 128;
586 struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
587 struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
588 struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
589
590 const char *pool_none = "Test_pool_size";
591
592
593 uint32_t num_elements = 256;
594 uint32_t cache_size = 0;
595
596
597 mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
598 num_elements, cache_size, 0);
599 TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
600
601
602 rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
603
604
605 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
606 OPS_COUNT) == 0,
607 "Failed test for allocating bbdev ops: "
608 "Mempool size: 256, Free : 128, Attempted to add: 128");
609
610
611 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
612 OPS_COUNT) != 0,
613 "Failed test for allocating bbdev ops: "
614 "Mempool size: 256, Free : 0, Attempted to add: 128");
615
616
617 rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
618
619
620
621 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
622 OPS_COUNT) == 0,
623 "Failed test for allocating ops after mempool freed: "
624 "Mempool size: 256, Free : 128, Attempted to add: 128");
625
626 rte_mempool_free(mp_none);
627
628 return TEST_SUCCESS;
629}
630
631static int
632test_bbdev_count(void)
633{
634 uint8_t num_devs, num_valid_devs = 0;
635
636 for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
637 if (rte_bbdev_is_valid(num_devs))
638 num_valid_devs++;
639 }
640
641 num_devs = rte_bbdev_count();
642 TEST_ASSERT(num_valid_devs == num_devs,
643 "Failed test for rte_bbdev_is_valid: "
644 "invalid num_devs %u ", num_devs);
645
646 return TEST_SUCCESS;
647}
648
649static int
650test_bbdev_stats(void)
651{
652 uint8_t dev_id = null_dev_id;
653 uint16_t queue_id = 0;
654 struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
655 struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
656 struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
657 struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
658 uint16_t num_ops = 236;
659 struct rte_bbdev_stats stats;
660 struct bbdev_testsuite_params *ts_params = &testsuite_params;
661
662 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
663 "Failed to stop queue %u on device %u ", queue_id,
664 dev_id);
665 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
666 "Failed to stop bbdev %u ", dev_id);
667
668 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
669 &ts_params->qconf),
670 "Failed to configure queue %u on device %u ",
671 queue_id, dev_id);
672
673 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
674 "Failed to start bbdev %u ", dev_id);
675
676 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
677 "Failed to start queue %u on device %u ", queue_id,
678 dev_id);
679
680 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
681 "Failed to start queue %u on device %u ", queue_id,
682 dev_id);
683
684
685 rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
686 rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
687
688 TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
689 "Failed test for rte_bbdev_stats_get on device %u ",
690 dev_id);
691
692 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
693 "Failed test for rte_bbdev_stats_get on device %u ",
694 dev_id);
695
696 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
697 "Failed test for rte_bbdev_stats_get on device %u ",
698 dev_id);
699
700 TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
701 "Failed test for rte_bbdev_enqueue_ops: "
702 "invalid enqueued_count %" PRIu64 " ",
703 stats.enqueued_count);
704
705 TEST_ASSERT(stats.dequeued_count == 0,
706 "Failed test for rte_bbdev_stats_reset: "
707 "invalid dequeued_count %" PRIu64 " ",
708 stats.dequeued_count);
709
710
711 rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
712 rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
713
714 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
715 "Failed test for rte_bbdev_stats_get on device %u ",
716 dev_id);
717
718 TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
719 "Failed test for rte_bbdev_dequeue_ops: "
720 "invalid enqueued_count %" PRIu64 " ",
721 stats.dequeued_count);
722
723 TEST_ASSERT(stats.enqueue_err_count == 0,
724 "Failed test for rte_bbdev_stats_reset: "
725 "invalid enqueue_err_count %" PRIu64 " ",
726 stats.enqueue_err_count);
727
728 TEST_ASSERT(stats.dequeue_err_count == 0,
729 "Failed test for rte_bbdev_stats_reset: "
730 "invalid dequeue_err_count %" PRIu64 " ",
731 stats.dequeue_err_count);
732
733
734 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
735 "Failed to reset statistic for device %u ", dev_id);
736
737 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
738 "Failed to reset statistic for device %u ", dev_id);
739 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
740 "Failed test for rte_bbdev_stats_get on device %u ",
741 dev_id);
742
743 TEST_ASSERT(stats.enqueued_count == 0,
744 "Failed test for rte_bbdev_stats_reset: "
745 "invalid enqueued_count %" PRIu64 " ",
746 stats.enqueued_count);
747
748 TEST_ASSERT(stats.dequeued_count == 0,
749 "Failed test for rte_bbdev_stats_reset: "
750 "invalid dequeued_count %" PRIu64 " ",
751 stats.dequeued_count);
752
753 TEST_ASSERT(stats.enqueue_err_count == 0,
754 "Failed test for rte_bbdev_stats_reset: "
755 "invalid enqueue_err_count %" PRIu64 " ",
756 stats.enqueue_err_count);
757
758 TEST_ASSERT(stats.dequeue_err_count == 0,
759 "Failed test for rte_bbdev_stats_reset: "
760 "invalid dequeue_err_count %" PRIu64 " ",
761 stats.dequeue_err_count);
762
763 return TEST_SUCCESS;
764}
765
766static int
767test_bbdev_driver_init(void)
768{
769 struct rte_bbdev *dev1, *dev2;
770 const char *name = "dev_name";
771 char name_tmp[32];
772 int num_devs, num_devs_tmp;
773
774 dev1 = rte_bbdev_allocate(NULL);
775 TEST_ASSERT(dev1 == NULL,
776 "Failed initialize bbdev driver with NULL name");
777
778 dev1 = rte_bbdev_allocate(name);
779 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
780
781 dev2 = rte_bbdev_allocate(name);
782 TEST_ASSERT(dev2 == NULL,
783 "Failed to initialize bbdev driver: "
784 "driver with the same name has been initialized before");
785
786 num_devs = rte_bbdev_count() - 1;
787 num_devs_tmp = num_devs;
788
789
790 do {
791 sprintf(name_tmp, "%s%i", "name_", num_devs);
792 dev2 = rte_bbdev_allocate(name_tmp);
793 TEST_ASSERT(dev2 != NULL,
794 "Failed to initialize bbdev driver");
795 ++num_devs;
796 } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
797
798 sprintf(name_tmp, "%s%i", "name_", num_devs);
799 dev2 = rte_bbdev_allocate(name_tmp);
800 TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
801 "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
802 RTE_BBDEV_MAX_DEVS);
803
804 num_devs--;
805
806 while (num_devs >= num_devs_tmp) {
807 sprintf(name_tmp, "%s%i", "name_", num_devs);
808 dev2 = rte_bbdev_get_named_dev(name_tmp);
809 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
810 "Failed to uninitialize bbdev driver %s ",
811 name_tmp);
812 num_devs--;
813 }
814
815 TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
816 "Failed test rte_bbdev_allocate: "
817 "invalid dev_id %" PRIu8 ", max number of devices %d ",
818 dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
819
820 TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
821 "Failed test rte_bbdev_allocate: "
822 "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
823 dev1->state);
824
825 TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
826 "Failed to uninitialize bbdev driver with NULL bbdev");
827
828 sprintf(name_tmp, "%s", "invalid_name");
829 dev2 = rte_bbdev_get_named_dev(name_tmp);
830 TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
831 "Failed to uninitialize bbdev driver with invalid name");
832
833 dev2 = rte_bbdev_get_named_dev(name);
834 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
835 "Failed to uninitialize bbdev driver: %s ", name);
836
837 return TEST_SUCCESS;
838}
839
840static void
841event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
842 void *ret_param)
843{
844 RTE_SET_USED(dev_id);
845 RTE_SET_USED(ret_param);
846
847 if (param == NULL)
848 return;
849
850 if (type == RTE_BBDEV_EVENT_UNKNOWN ||
851 type == RTE_BBDEV_EVENT_ERROR ||
852 type == RTE_BBDEV_EVENT_MAX)
853 *(int *)param = type;
854}
855
856static int
857test_bbdev_callback(void)
858{
859 struct rte_bbdev *dev1, *dev2;
860 const char *name = "dev_name1";
861 const char *name2 = "dev_name2";
862 int event_status;
863 uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
864 enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
865 uint8_t dev_id;
866
867 dev1 = rte_bbdev_allocate(name);
868 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
869
870
871
872
873
874 event_status = -1;
875 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
876 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
877 TEST_ASSERT(event_status == -1,
878 "Failed test for rte_bbdev_pmd_callback_process: "
879 "events were not registered ");
880
881 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
882 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
883 "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
884
885 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
886 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
887 "Failed to unregister RTE_BBDEV_EVENT_MAX ");
888
889
890
891
892
893 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
894 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
895 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
896
897 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
898 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
899 "Failed test for rte_bbdev_pmd_callback_process "
900 "for RTE_BBDEV_EVENT_UNKNOWN ");
901
902 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
903 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
904 "Failed test for rte_bbdev_pmd_callback_process: "
905 "event RTE_BBDEV_EVENT_ERROR was not registered ");
906
907
908
909
910
911 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
912 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
913 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
914
915 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
916 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
917 "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
918 "(re-registration) ");
919
920 event_status = -1;
921 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
922 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
923 "Failed test for rte_bbdev_pmd_callback_process "
924 "for RTE_BBDEV_EVENT_UNKNOWN ");
925
926 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
927 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
928 "Failed test for rte_bbdev_pmd_callback_process "
929 "for RTE_BBDEV_EVENT_ERROR ");
930
931
932
933
934
935 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
936 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
937 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
938
939 event_status = -1;
940 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
941 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
942 "Failed test for rte_bbdev_pmd_callback_process "
943 "for RTE_BBDEV_EVENT_UNKNOWN ");
944
945 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
946 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
947 "Failed test for rte_bbdev_pmd_callback_process: "
948 "event RTE_BBDEV_EVENT_ERROR was unregistered ");
949
950
951 TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
952 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
953 "Failed test for rte_bbdev_callback_register "
954 "for invalid_dev_id ");
955
956 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
957 invalid_event_type, event_callback, &event_status),
958 "Failed to callback register for invalid event type ");
959
960 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
961 RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
962 "Failed to callback register - no callback function ");
963
964
965 dev2 = rte_bbdev_allocate(name2);
966 TEST_ASSERT(dev2 != NULL,
967 "Failed to initialize bbdev driver");
968
969
970
971
972
973
974 event_status = -1;
975 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
976 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
977 TEST_ASSERT(event_status == -1,
978 "Failed test for rte_bbdev_pmd_callback_process: "
979 "events were not registered ");
980
981
982
983
984
985 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
986 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
987 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
988
989 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
990 TEST_ASSERT(event_status == -1,
991 "Failed test for rte_bbdev_pmd_callback_process in dev1 "
992 "for RTE_BBDEV_EVENT_ERROR ");
993
994 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
995 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
996 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
997 "for RTE_BBDEV_EVENT_ERROR ");
998
999
1000
1001
1002
1003 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1004 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1005 "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1006 "in dev 2 ");
1007
1008 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1009 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1010 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1011 " for RTE_BBDEV_EVENT_UNKNOWN ");
1012
1013 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1014 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1015 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1016
1017 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1018 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1019 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1020 "unregister function called once again ");
1021
1022 event_status = -1;
1023 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1024 TEST_ASSERT(event_status == -1,
1025 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1026 " for RTE_BBDEV_EVENT_UNKNOWN ");
1027
1028 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1029 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1030 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1031 "for RTE_BBDEV_EVENT_UNKNOWN ");
1032
1033
1034 rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1035
1036 event_status = -1;
1037 rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1038 TEST_ASSERT(event_status == -1,
1039 "Failed test for rte_bbdev_pmd_callback_process: "
1040 "for invalid event type ");
1041
1042
1043 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1044 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1045 "Failed test for rte_dev_callback_unregister "
1046 "for invalid_dev_id ");
1047
1048 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1049 invalid_event_type, event_callback, &event_status),
1050 "Failed rte_dev_callback_unregister "
1051 "for invalid event type ");
1052
1053 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1054 invalid_event_type, NULL, &event_status),
1055 "Failed rte_dev_callback_unregister "
1056 "when no callback function ");
1057
1058 dev_id = dev1->data->dev_id;
1059
1060 rte_bbdev_release(dev1);
1061 rte_bbdev_release(dev2);
1062
1063 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1064 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1065 "Failed test for rte_bbdev_callback_register: "
1066 "function called after rte_bbdev_driver_uninit .");
1067
1068 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1069 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1070 "Failed test for rte_dev_callback_unregister: "
1071 "function called after rte_bbdev_driver_uninit. ");
1072
1073 event_status = -1;
1074 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1075 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1076 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1077 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1078 TEST_ASSERT(event_status == -1,
1079 "Failed test for rte_bbdev_pmd_callback_process: "
1080 "callback function was called after rte_bbdev_driver_uninit");
1081
1082 return TEST_SUCCESS;
1083}
1084
1085static int
1086test_bbdev_invalid_driver(void)
1087{
1088 struct rte_bbdev dev1, *dev2;
1089 uint8_t dev_id = null_dev_id;
1090 uint16_t queue_id = 0;
1091 struct rte_bbdev_stats stats;
1092 struct bbdev_testsuite_params *ts_params = &testsuite_params;
1093 struct rte_bbdev_queue_info qinfo;
1094 struct rte_bbdev_ops dev_ops_tmp;
1095
1096 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1097 dev_id);
1098
1099 dev1 = rte_bbdev_devices[dev_id];
1100 dev2 = &rte_bbdev_devices[dev_id];
1101
1102
1103 dev2->dev_ops = NULL;
1104 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1105 "Failed test for rte_bbdev_setup_queues: "
1106 "NULL dev_ops structure ");
1107 dev2->dev_ops = dev1.dev_ops;
1108
1109 dev_ops_tmp = *dev2->dev_ops;
1110 dev_ops_tmp.info_get = NULL;
1111 dev2->dev_ops = &dev_ops_tmp;
1112 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1113 "Failed test for rte_bbdev_setup_queues: "
1114 "NULL info_get ");
1115 dev2->dev_ops = dev1.dev_ops;
1116
1117 dev_ops_tmp = *dev2->dev_ops;
1118 dev_ops_tmp.queue_release = NULL;
1119 dev2->dev_ops = &dev_ops_tmp;
1120 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1121 "Failed test for rte_bbdev_setup_queues: "
1122 "NULL queue_release ");
1123 dev2->dev_ops = dev1.dev_ops;
1124
1125 dev2->data->socket_id = SOCKET_ID_ANY;
1126 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1127 SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1128
1129
1130 dev2->dev_ops = NULL;
1131 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1132 &ts_params->qconf),
1133 "Failed to configure queue %u on device %u "
1134 "with NULL dev_ops structure ", queue_id, dev_id);
1135 dev2->dev_ops = dev1.dev_ops;
1136
1137 dev_ops_tmp = *dev2->dev_ops;
1138 dev_ops_tmp.queue_setup = NULL;
1139 dev2->dev_ops = &dev_ops_tmp;
1140 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1141 &ts_params->qconf),
1142 "Failed to configure queue %u on device %u "
1143 "with NULL queue_setup ", queue_id, dev_id);
1144 dev2->dev_ops = dev1.dev_ops;
1145
1146 dev_ops_tmp = *dev2->dev_ops;
1147 dev_ops_tmp.info_get = NULL;
1148 dev2->dev_ops = &dev_ops_tmp;
1149 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1150 &ts_params->qconf),
1151 "Failed to configure queue %u on device %u "
1152 "with NULL info_get ", queue_id, dev_id);
1153 dev2->dev_ops = dev1.dev_ops;
1154
1155 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1156 queue_id, &ts_params->qconf),
1157 "Failed to configure queue %u on device %u ",
1158 queue_id, dev_id);
1159
1160 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1161 &ts_params->qconf),
1162 "Failed to configure queue %u on device %u ",
1163 queue_id, dev_id);
1164
1165
1166 dev2->dev_ops = NULL;
1167 TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1168 "Failed test for rte_bbdev_info_get: "
1169 "NULL dev_ops structure ");
1170 dev2->dev_ops = dev1.dev_ops;
1171
1172 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1173 queue_id, &qinfo),
1174 "Failed test for rte_bbdev_info_get: "
1175 "invalid dev_id ");
1176
1177 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1178 RTE_MAX_QUEUES_PER_PORT, &qinfo),
1179 "Failed test for rte_bbdev_info_get: "
1180 "invalid queue_id ");
1181
1182 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1183 "Failed test for rte_bbdev_info_get: "
1184 "invalid dev_info ");
1185
1186
1187 dev2->dev_ops = NULL;
1188 TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1189 "Failed to start bbdev %u "
1190 "with NULL dev_ops structure ", dev_id);
1191 dev2->dev_ops = dev1.dev_ops;
1192
1193 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1194 "Failed to start bbdev %u ", dev_id);
1195
1196
1197 dev2->dev_ops = NULL;
1198 TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1199 "Failed to start queue %u on device %u: "
1200 "NULL dev_ops structure", queue_id, dev_id);
1201 dev2->dev_ops = dev1.dev_ops;
1202
1203 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1204 "Failed to start queue %u on device %u ", queue_id,
1205 dev_id);
1206
1207
1208 dev2->dev_ops = NULL;
1209 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1210 "Failed test for rte_bbdev_stats_get on device %u ",
1211 dev_id);
1212 dev2->dev_ops = dev1.dev_ops;
1213
1214 dev_ops_tmp = *dev2->dev_ops;
1215 dev_ops_tmp.stats_reset = NULL;
1216 dev2->dev_ops = &dev_ops_tmp;
1217 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1218 "Failed test for rte_bbdev_stats_get: "
1219 "NULL stats_get ");
1220 dev2->dev_ops = dev1.dev_ops;
1221
1222 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1223 "Failed test for rte_bbdev_stats_get on device %u ",
1224 dev_id);
1225
1226
1227
1228
1229
1230
1231
1232 dev2->dev_ops = NULL;
1233 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1234 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1235 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1236 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1237
1238 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1239 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1240 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1241 dev2->dev_ops = dev1.dev_ops;
1242
1243
1244 dev2->dev_ops = NULL;
1245 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id),
1246 "Failed to reset statistic for device %u ", dev_id);
1247 dev2->dev_ops = dev1.dev_ops;
1248
1249 dev_ops_tmp = *dev2->dev_ops;
1250 dev_ops_tmp.stats_reset = NULL;
1251 dev2->dev_ops = &dev_ops_tmp;
1252 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1253 "Failed test for rte_bbdev_stats_reset: "
1254 "NULL stats_reset ");
1255 dev2->dev_ops = dev1.dev_ops;
1256
1257 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1258 "Failed to reset statistic for device %u ", dev_id);
1259
1260
1261 dev2->dev_ops = NULL;
1262 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id),
1263 "Failed to stop queue %u on device %u: "
1264 "NULL dev_ops structure", queue_id, dev_id);
1265 dev2->dev_ops = dev1.dev_ops;
1266
1267 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1268 "Failed to stop queue %u on device %u ", queue_id,
1269 dev_id);
1270
1271
1272 dev2->dev_ops = NULL;
1273 TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id),
1274 "Failed to stop bbdev %u with NULL dev_ops structure ",
1275 dev_id);
1276 dev2->dev_ops = dev1.dev_ops;
1277
1278 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1279 "Failed to stop bbdev %u ", dev_id);
1280
1281
1282 TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS),
1283 "Failed to close bbdev with invalid dev_id");
1284
1285 dev2->dev_ops = NULL;
1286 TEST_ASSERT_FAIL(rte_bbdev_close(dev_id),
1287 "Failed to close bbdev %u with NULL dev_ops structure ",
1288 dev_id);
1289 dev2->dev_ops = dev1.dev_ops;
1290
1291 TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1292 "Failed to close bbdev %u ", dev_id);
1293
1294 return TEST_SUCCESS;
1295}
1296
1297static int
1298test_bbdev_get_named_dev(void)
1299{
1300 struct rte_bbdev *dev, *dev_tmp;
1301 const char *name = "name";
1302
1303 dev = rte_bbdev_allocate(name);
1304 TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1305
1306 dev_tmp = rte_bbdev_get_named_dev(NULL);
1307 TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: "
1308 "function called with NULL parameter");
1309
1310 dev_tmp = rte_bbdev_get_named_dev(name);
1311
1312 TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1313 "wrong device was returned ");
1314
1315 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1316 "Failed to uninitialize bbdev driver %s ", name);
1317
1318 return TEST_SUCCESS;
1319}
1320
1321static struct unit_test_suite bbdev_null_testsuite = {
1322 .suite_name = "BBDEV NULL Unit Test Suite",
1323 .setup = testsuite_setup,
1324 .teardown = testsuite_teardown,
1325 .unit_test_cases = {
1326
1327 TEST_CASE(test_bbdev_configure_invalid_dev_id),
1328
1329 TEST_CASE_ST(ut_setup, ut_teardown,
1330 test_bbdev_configure_invalid_num_queues),
1331
1332 TEST_CASE_ST(ut_setup, ut_teardown,
1333 test_bbdev_configure_stop_device),
1334
1335 TEST_CASE_ST(ut_setup, ut_teardown,
1336 test_bbdev_configure_stop_queue),
1337
1338 TEST_CASE_ST(ut_setup, ut_teardown,
1339 test_bbdev_configure_invalid_queue_configure),
1340
1341 TEST_CASE_ST(ut_setup, ut_teardown,
1342 test_bbdev_op_pool),
1343
1344 TEST_CASE_ST(ut_setup, ut_teardown,
1345 test_bbdev_op_type),
1346
1347 TEST_CASE_ST(ut_setup, ut_teardown,
1348 test_bbdev_op_pool_size),
1349
1350 TEST_CASE_ST(ut_setup, ut_teardown,
1351 test_bbdev_stats),
1352
1353 TEST_CASE_ST(ut_setup, ut_teardown,
1354 test_bbdev_driver_init),
1355
1356 TEST_CASE_ST(ut_setup, ut_teardown,
1357 test_bbdev_callback),
1358
1359 TEST_CASE_ST(ut_setup, ut_teardown,
1360 test_bbdev_invalid_driver),
1361
1362 TEST_CASE_ST(ut_setup, ut_teardown,
1363 test_bbdev_get_named_dev),
1364
1365 TEST_CASE(test_bbdev_count),
1366
1367 TEST_CASES_END()
1368 }
1369};
1370
1371REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);
1372
