1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Intel Corporation
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
23 struct bbdev_testsuite_params {
24 struct rte_bbdev_queue_conf qconf;
25 };
26
27 static struct bbdev_testsuite_params testsuite_params;
28
29 static uint8_t null_dev_id;
30
31 static int
testsuite_setup(void)32 testsuite_setup(void)
33 {
34 uint8_t nb_devs;
35 int ret;
36 char buf[RTE_BBDEV_NAME_MAX_LEN];
37
38 /* Create test device */
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 /* Most recently created device is our device */
47 null_dev_id = nb_devs - 1;
48
49 return TEST_SUCCESS;
50 }
51
52 static void
testsuite_teardown(void)53 testsuite_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
61 static int
ut_setup(void)62 ut_setup(void)
63 {
64 struct bbdev_testsuite_params *ts_params = &testsuite_params;
65 uint8_t num_queues;
66
67 /* Valid queue configuration */
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 /* Start the device */
78 TEST_ASSERT_SUCCESS(rte_bbdev_start(null_dev_id),
79 "Failed to start bbdev %u", 0);
80
81 return TEST_SUCCESS;
82 }
83
84 static void
ut_teardown(void)85 ut_teardown(void)
86 {
87 rte_bbdev_close(null_dev_id);
88 }
89
90 static int
test_bbdev_configure_invalid_dev_id(void)91 test_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
113 static int
test_bbdev_configure_invalid_num_queues(void)114 test_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 /* valid num_queues values */
125 num_queues = 8;
126
127 /* valid dev_id values */
128 dev_id = null_dev_id;
129
130 /* Stop the device in case it's started so it can be configured */
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
169 static int
test_bbdev_configure_stop_device(void)170 test_bbdev_configure_stop_device(void)
171 {
172 struct rte_bbdev_info info;
173 uint8_t dev_id;
174 int return_value;
175
176 /* valid dev_id values */
177 dev_id = null_dev_id;
178
179 /* Stop the device so it can be configured */
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 /* Start the device so it cannot be configured */
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 /* Stop again the device so it can be once again configured */
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
253 static int
test_bbdev_configure_stop_queue(void)254 test_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 /* Valid dev_id values */
264 dev_id = null_dev_id;
265
266 /* Valid queue_id values */
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 /* Valid queue configuration */
275 ts_params->qconf.queue_size = info.drv.queue_size_lim;
276 ts_params->qconf.priority = info.drv.max_ul_queue_priority;
277
278 /* Device - started; queue - started */
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 /* Device - stopped; queue - started */
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 /* Device - stopped; queue - stopped */
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 /* Device - started; queue - stopped */
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 /* After rte_bbdev_start(dev_id):
349 * - queue should be still stopped if deferred_start ==
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 /* After rte_bbdev_start(dev_id):
366 * - queue should be started if deferred_start ==
367 */
368 ts_params->qconf.deferred_start = 0;
369 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, &ts_params->qconf),
370 "Failed test for rte_bbdev_queue_configure");
371 rte_bbdev_start(dev_id);
372
373 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
374 queue_id, &qinfo),
375 "Failed test for rte_bbdev_info_get: "
376 "invalid return value from "
377 "rte_bbdev_queue_info_get function: %i", return_value);
378
379 TEST_ASSERT(qinfo.started == 1,
380 "Failed test for rte_bbdev_queue_info_get: "
381 "invalid value for qinfo.started:%u", qinfo.started);
382
383 return TEST_SUCCESS;
384 }
385
386 static int
test_bbdev_configure_invalid_queue_configure(void)387 test_bbdev_configure_invalid_queue_configure(void)
388 {
389 struct bbdev_testsuite_params *ts_params = &testsuite_params;
390 int return_value;
391 struct rte_bbdev_info info;
392 uint8_t dev_id;
393 uint16_t queue_id;
394
395 /* Valid dev_id values */
396 dev_id = null_dev_id;
397
398 /* Valid queue_id values */
399 queue_id = 0;
400
401 rte_bbdev_stop(dev_id);
402
403 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
404 "Failed test for rte_bbdev_info_get: "
405 "invalid return value:%i", return_value);
406
407 rte_bbdev_queue_stop(dev_id, queue_id);
408
409 ts_params->qconf.queue_size = info.drv.queue_size_lim + 1;
410 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
411 &ts_params->qconf),
412 "Failed test for rte_bbdev_queue_configure: "
413 "invalid value qconf.queue_size: %u",
414 ts_params->qconf.queue_size);
415
416 ts_params->qconf.queue_size = info.drv.queue_size_lim;
417 ts_params->qconf.priority = info.drv.max_ul_queue_priority;
418 queue_id = info.num_queues;
419 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
420 &ts_params->qconf),
421 "Failed test for rte_bbdev_queue_configure: "
422 "invalid value queue_id: %u", queue_id);
423
424 queue_id = 0;
425 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
426 "Failed test for rte_bbdev_queue_configure: "
427 "NULL qconf structure ");
428
429 ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
430 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
431 &ts_params->qconf),
432 "Failed test for rte_bbdev_queue_configure: "
433 "invalid socket number ");
434
435 ts_params->qconf.socket = SOCKET_ID_ANY;
436 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
437 &ts_params->qconf),
438 "Failed test for rte_bbdev_queue_configure: "
439 "invalid value qconf.queue_size: %u",
440 ts_params->qconf.queue_size);
441
442 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
443 &ts_params->qconf),
444 "Failed test for rte_bbdev_queue_configure: "
445 "invalid dev_id");
446
447 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
448 "Failed test for rte_bbdev_queue_configure: "
449 "invalid value qconf.queue_size: %u",
450 ts_params->qconf.queue_size);
451
452 return TEST_SUCCESS;
453 }
454
455 static int
test_bbdev_op_pool(void)456 test_bbdev_op_pool(void)
457 {
458 struct rte_mempool *mp;
459
460 unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
461 unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
462
463 const char *pool_dec = "Test_DEC";
464 const char *pool_enc = "Test_ENC";
465
466 /* Valid pool configuration */
467 uint32_t size = 256;
468 uint32_t cache_size = 128;
469
470 TEST_ASSERT(rte_bbdev_op_pool_create(NULL,
471 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL,
472 "Failed test for rte_bbdev_op_pool_create: "
473 "NULL name parameter");
474
475 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec,
476 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL,
477 "Failed test for rte_bbdev_op_pool_create: "
478 "returned value is empty");
479
480 TEST_ASSERT(mp->size == size,
481 "Failed test for rte_bbdev_op_pool_create: "
482 "invalid size of the mempool, mp->size: %u", mp->size);
483
484 TEST_ASSERT(mp->cache_size == cache_size,
485 "Failed test for rte_bbdev_op_pool_create: "
486 "invalid size of the mempool, mp->size: %u",
487 mp->cache_size);
488
489 TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec),
490 "Failed test for rte_bbdev_op_pool_create: "
491 "invalid name of mempool, mp->name: %s", mp->name);
492
493 TEST_ASSERT(mp->elt_size == dec_size,
494 "Failed test for rte_bbdev_op_pool_create: "
495 "invalid element size for RTE_BBDEV_OP_TURBO_DEC, "
496 "mp->elt_size: %u", mp->elt_size);
497
498 rte_mempool_free(mp);
499
500 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc,
501 RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL,
502 "Failed test for rte_bbdev_op_pool_create: "
503 "returned value is empty");
504
505 TEST_ASSERT(mp->elt_size == enc_size,
506 "Failed test for rte_bbdev_op_pool_create: "
507 "invalid element size for RTE_BBDEV_OP_TURBO_ENC, "
508 "mp->elt_size: %u", mp->elt_size);
509
510 rte_mempool_free(mp);
511
512 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE",
513 RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL,
514 "Failed test for rte_bbdev_op_pool_create: "
515 "returned value is empty for RTE_BBDEV_OP_NONE");
516
517 TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size),
518 "Failed test for rte_bbdev_op_pool_create: "
519 "invalid size for RTE_BBDEV_OP_NONE, mp->elt_size: %u",
520 mp->elt_size);
521
522 rte_mempool_free(mp);
523
524 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV",
525 RTE_BBDEV_OP_TYPE_SIZE_MAX, size, cache_size, 0)) == NULL,
526 "Failed test for rte_bbdev_op_pool_create: "
527 "returned value is not NULL for invalid type");
528
529 /* Invalid pool configuration */
530 size = 128;
531 cache_size = 256;
532
533 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize",
534 RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL,
535 "Failed test for rte_bbdev_op_pool_create: "
536 "returned value should be empty "
537 "because size of per-lcore local cache "
538 "is greater than size of the mempool.");
539
540 return TEST_SUCCESS;
541 }
542
543 /**
544 * Create pool of OP types RTE_BBDEV_OP_NONE, RTE_BBDEV_OP_TURBO_DEC and
545 * RTE_BBDEV_OP_TURBO_ENC and check that only ops of that type can be
546 * allocated
547 */
548 static int
test_bbdev_op_type(void)549 test_bbdev_op_type(void)
550 {
551 struct rte_mempool *mp_dec;
552
553 const unsigned int OPS_COUNT = 32;
554 struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
555 struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT];
556
557 const char *pool_dec = "Test_op_dec";
558
559 /* Valid pool configuration */
560 uint32_t num_elements = 256;
561 uint32_t cache_size = 128;
562
563 /* mempool type : RTE_BBDEV_OP_TURBO_DEC */
564 mp_dec = rte_bbdev_op_pool_create(pool_dec,
565 RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0);
566 TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec);
567
568 TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0,
569 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
570 "OPs type: RTE_BBDEV_OP_TURBO_DEC");
571
572 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0,
573 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
574 "OPs type: RTE_BBDEV_OP_TURBO_ENC");
575
576 rte_mempool_free(mp_dec);
577
578 return TEST_SUCCESS;
579 }
580
581 static int
test_bbdev_op_pool_size(void)582 test_bbdev_op_pool_size(void)
583 {
584 struct rte_mempool *mp_none;
585
586 const unsigned int OPS_COUNT = 128;
587 struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
588 struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
589 struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
590
591 const char *pool_none = "Test_pool_size";
592
593 /* Valid pool configuration */
594 uint32_t num_elements = 256;
595 uint32_t cache_size = 0;
596
597 /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */
598 mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
599 num_elements, cache_size, 0);
600 TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
601
602 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
603 rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
604
605 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
606 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
607 OPS_COUNT) == 0,
608 "Failed test for allocating bbdev ops: "
609 "Mempool size: 256, Free : 128, Attempted to add: 128");
610
611 /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */
612 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
613 OPS_COUNT) != 0,
614 "Failed test for allocating bbdev ops: "
615 "Mempool size: 256, Free : 0, Attempted to add: 128");
616
617 /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
618 rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
619
620 /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */
621 /* Cache size > 0 causes reallocation of ops size > 127 fail */
622 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
623 OPS_COUNT) == 0,
624 "Failed test for allocating ops after mempool freed: "
625 "Mempool size: 256, Free : 128, Attempted to add: 128");
626
627 rte_mempool_free(mp_none);
628
629 return TEST_SUCCESS;
630 }
631
632 static int
test_bbdev_count(void)633 test_bbdev_count(void)
634 {
635 uint8_t num_devs, num_valid_devs = 0;
636
637 for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
638 if (rte_bbdev_is_valid(num_devs))
639 num_valid_devs++;
640 }
641
642 num_devs = rte_bbdev_count();
643 TEST_ASSERT(num_valid_devs == num_devs,
644 "Failed test for rte_bbdev_is_valid: "
645 "invalid num_devs %u ", num_devs);
646
647 return TEST_SUCCESS;
648 }
649
650 static int
test_bbdev_stats(void)651 test_bbdev_stats(void)
652 {
653 uint8_t dev_id = null_dev_id;
654 uint16_t queue_id = 0;
655 struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
656 struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
657 struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
658 struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
659 uint16_t num_ops = 236;
660 struct rte_bbdev_stats stats;
661 struct bbdev_testsuite_params *ts_params = &testsuite_params;
662
663 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
664 "Failed to stop queue %u on device %u ", queue_id,
665 dev_id);
666 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
667 "Failed to stop bbdev %u ", dev_id);
668
669 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
670 &ts_params->qconf),
671 "Failed to configure queue %u on device %u ",
672 queue_id, dev_id);
673
674 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
675 "Failed to start bbdev %u ", dev_id);
676
677 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
678 "Failed to start queue %u on device %u ", queue_id,
679 dev_id);
680
681 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
682 "Failed to start queue %u on device %u ", queue_id,
683 dev_id);
684
685 /* Tests after enqueue operation */
686 rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
687 rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
688
689 TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
690 "Failed test for rte_bbdev_stats_get on device %u ",
691 dev_id);
692
693 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
694 "Failed test for rte_bbdev_stats_get on device %u ",
695 dev_id);
696
697 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
698 "Failed test for rte_bbdev_stats_get on device %u ",
699 dev_id);
700
701 TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
702 "Failed test for rte_bbdev_enqueue_ops: "
703 "invalid enqueued_count %" PRIu64 " ",
704 stats.enqueued_count);
705
706 TEST_ASSERT(stats.dequeued_count == 0,
707 "Failed test for rte_bbdev_stats_reset: "
708 "invalid dequeued_count %" PRIu64 " ",
709 stats.dequeued_count);
710
711 /* Tests after dequeue operation */
712 rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
713 rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
714
715 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
716 "Failed test for rte_bbdev_stats_get on device %u ",
717 dev_id);
718
719 TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
720 "Failed test for rte_bbdev_dequeue_ops: "
721 "invalid enqueued_count %" PRIu64 " ",
722 stats.dequeued_count);
723
724 TEST_ASSERT(stats.enqueue_err_count == 0,
725 "Failed test for rte_bbdev_stats_reset: "
726 "invalid enqueue_err_count %" PRIu64 " ",
727 stats.enqueue_err_count);
728
729 TEST_ASSERT(stats.dequeue_err_count == 0,
730 "Failed test for rte_bbdev_stats_reset: "
731 "invalid dequeue_err_count %" PRIu64 " ",
732 stats.dequeue_err_count);
733
734 /* Tests after reset operation */
735 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
736 "Failed to reset statistic for device %u ", dev_id);
737
738 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
739 "Failed to reset statistic for device %u ", dev_id);
740 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
741 "Failed test for rte_bbdev_stats_get on device %u ",
742 dev_id);
743
744 TEST_ASSERT(stats.enqueued_count == 0,
745 "Failed test for rte_bbdev_stats_reset: "
746 "invalid enqueued_count %" PRIu64 " ",
747 stats.enqueued_count);
748
749 TEST_ASSERT(stats.dequeued_count == 0,
750 "Failed test for rte_bbdev_stats_reset: "
751 "invalid dequeued_count %" PRIu64 " ",
752 stats.dequeued_count);
753
754 TEST_ASSERT(stats.enqueue_err_count == 0,
755 "Failed test for rte_bbdev_stats_reset: "
756 "invalid enqueue_err_count %" PRIu64 " ",
757 stats.enqueue_err_count);
758
759 TEST_ASSERT(stats.dequeue_err_count == 0,
760 "Failed test for rte_bbdev_stats_reset: "
761 "invalid dequeue_err_count %" PRIu64 " ",
762 stats.dequeue_err_count);
763
764 return TEST_SUCCESS;
765 }
766
767 static int
test_bbdev_driver_init(void)768 test_bbdev_driver_init(void)
769 {
770 struct rte_bbdev *dev1, *dev2;
771 const char *name = "dev_name";
772 char name_tmp[32];
773 int num_devs, num_devs_tmp;
774
775 dev1 = rte_bbdev_allocate(NULL);
776 TEST_ASSERT(dev1 == NULL,
777 "Failed initialize bbdev driver with NULL name");
778
779 dev1 = rte_bbdev_allocate(name);
780 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
781
782 dev2 = rte_bbdev_allocate(name);
783 TEST_ASSERT(dev2 == NULL,
784 "Failed to initialize bbdev driver: "
785 "driver with the same name has been initialized before");
786
787 num_devs = rte_bbdev_count() - 1;
788 num_devs_tmp = num_devs;
789
790 /* Initialize the maximum amount of devices */
791 do {
792 sprintf(name_tmp, "%s%i", "name_", num_devs);
793 dev2 = rte_bbdev_allocate(name_tmp);
794 TEST_ASSERT(dev2 != NULL,
795 "Failed to initialize bbdev driver");
796 ++num_devs;
797 } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
798
799 sprintf(name_tmp, "%s%i", "name_", num_devs);
800 dev2 = rte_bbdev_allocate(name_tmp);
801 TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
802 "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
803 RTE_BBDEV_MAX_DEVS);
804
805 num_devs--;
806
807 while (num_devs >= num_devs_tmp) {
808 sprintf(name_tmp, "%s%i", "name_", num_devs);
809 dev2 = rte_bbdev_get_named_dev(name_tmp);
810 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
811 "Failed to uninitialize bbdev driver %s ",
812 name_tmp);
813 num_devs--;
814 }
815
816 TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
817 "Failed test rte_bbdev_allocate: "
818 "invalid dev_id %" PRIu8 ", max number of devices %d ",
819 dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
820
821 TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
822 "Failed test rte_bbdev_allocate: "
823 "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
824 dev1->state);
825
826 TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
827 "Failed to uninitialize bbdev driver with NULL bbdev");
828
829 sprintf(name_tmp, "%s", "invalid_name");
830 dev2 = rte_bbdev_get_named_dev(name_tmp);
831 TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
832 "Failed to uninitialize bbdev driver with invalid name");
833
834 dev2 = rte_bbdev_get_named_dev(name);
835 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
836 "Failed to uninitialize bbdev driver: %s ", name);
837
838 return TEST_SUCCESS;
839 }
840
841 static void
event_callback(uint16_t dev_id,enum rte_bbdev_event_type type,void * param,void * ret_param)842 event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
843 void *ret_param)
844 {
845 RTE_SET_USED(dev_id);
846 RTE_SET_USED(ret_param);
847
848 if (param == NULL)
849 return;
850
851 if (type == RTE_BBDEV_EVENT_UNKNOWN ||
852 type == RTE_BBDEV_EVENT_ERROR ||
853 type == RTE_BBDEV_EVENT_MAX)
854 *(int *)param = type;
855 }
856
857 static int
test_bbdev_callback(void)858 test_bbdev_callback(void)
859 {
860 struct rte_bbdev *dev1, *dev2;
861 const char *name = "dev_name1";
862 const char *name2 = "dev_name2";
863 int event_status;
864 uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
865 enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
866 uint8_t dev_id;
867
868 dev1 = rte_bbdev_allocate(name);
869 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
870
871 /*
872 * RTE_BBDEV_EVENT_UNKNOWN - unregistered
873 * RTE_BBDEV_EVENT_ERROR - unregistered
874 */
875 event_status = -1;
876 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
877 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
878 TEST_ASSERT(event_status == -1,
879 "Failed test for rte_bbdev_pmd_callback_process: "
880 "events were not registered ");
881
882 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
883 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
884 "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
885
886 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
887 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
888 "Failed to unregister RTE_BBDEV_EVENT_MAX ");
889
890 /*
891 * RTE_BBDEV_EVENT_UNKNOWN - registered
892 * RTE_BBDEV_EVENT_ERROR - unregistered
893 */
894 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
895 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
896 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
897
898 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
899 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
900 "Failed test for rte_bbdev_pmd_callback_process "
901 "for RTE_BBDEV_EVENT_UNKNOWN ");
902
903 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
904 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
905 "Failed test for rte_bbdev_pmd_callback_process: "
906 "event RTE_BBDEV_EVENT_ERROR was not registered ");
907
908 /*
909 * RTE_BBDEV_EVENT_UNKNOWN - registered
910 * RTE_BBDEV_EVENT_ERROR - registered
911 */
912 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
913 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
914 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
915
916 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
917 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
918 "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
919 "(re-registration) ");
920
921 event_status = -1;
922 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
923 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
924 "Failed test for rte_bbdev_pmd_callback_process "
925 "for RTE_BBDEV_EVENT_UNKNOWN ");
926
927 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
928 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
929 "Failed test for rte_bbdev_pmd_callback_process "
930 "for RTE_BBDEV_EVENT_ERROR ");
931
932 /*
933 * RTE_BBDEV_EVENT_UNKNOWN - registered
934 * RTE_BBDEV_EVENT_ERROR - unregistered
935 */
936 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
937 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
938 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
939
940 event_status = -1;
941 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
942 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
943 "Failed test for rte_bbdev_pmd_callback_process "
944 "for RTE_BBDEV_EVENT_UNKNOWN ");
945
946 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
947 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
948 "Failed test for rte_bbdev_pmd_callback_process: "
949 "event RTE_BBDEV_EVENT_ERROR was unregistered ");
950
951 /* rte_bbdev_callback_register with invalid inputs */
952 TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
953 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
954 "Failed test for rte_bbdev_callback_register "
955 "for invalid_dev_id ");
956
957 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
958 invalid_event_type, event_callback, &event_status),
959 "Failed to callback register for invalid event type ");
960
961 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
962 RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
963 "Failed to callback register - no callback function ");
964
965 /* The impact of devices on each other */
966 dev2 = rte_bbdev_allocate(name2);
967 TEST_ASSERT(dev2 != NULL,
968 "Failed to initialize bbdev driver");
969
970 /*
971 * dev2:
972 * RTE_BBDEV_EVENT_UNKNOWN - unregistered
973 * RTE_BBDEV_EVENT_ERROR - unregistered
974 */
975 event_status = -1;
976 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
977 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
978 TEST_ASSERT(event_status == -1,
979 "Failed test for rte_bbdev_pmd_callback_process: "
980 "events were not registered ");
981
982 /*
983 * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
984 * dev2: RTE_BBDEV_EVENT_ERROR - registered
985 */
986 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
987 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
988 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
989
990 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
991 TEST_ASSERT(event_status == -1,
992 "Failed test for rte_bbdev_pmd_callback_process in dev1 "
993 "for RTE_BBDEV_EVENT_ERROR ");
994
995 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
996 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
997 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
998 "for RTE_BBDEV_EVENT_ERROR ");
999
1000 /*
1001 * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1002 * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1003 */
1004 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1005 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1006 "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1007 "in dev 2 ");
1008
1009 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1010 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1011 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1012 " for RTE_BBDEV_EVENT_UNKNOWN ");
1013
1014 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1015 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1016 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1017
1018 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1019 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1020 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1021 "unregister function called once again ");
1022
1023 event_status = -1;
1024 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1025 TEST_ASSERT(event_status == -1,
1026 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1027 " for RTE_BBDEV_EVENT_UNKNOWN ");
1028
1029 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1030 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1031 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1032 "for RTE_BBDEV_EVENT_UNKNOWN ");
1033
1034 /* rte_bbdev_pmd_callback_process with invalid inputs */
1035 rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1036
1037 event_status = -1;
1038 rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1039 TEST_ASSERT(event_status == -1,
1040 "Failed test for rte_bbdev_pmd_callback_process: "
1041 "for invalid event type ");
1042
1043 /* rte_dev_callback_unregister with invalid inputs */
1044 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1045 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1046 "Failed test for rte_dev_callback_unregister "
1047 "for invalid_dev_id ");
1048
1049 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1050 invalid_event_type, event_callback, &event_status),
1051 "Failed rte_dev_callback_unregister "
1052 "for invalid event type ");
1053
1054 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1055 invalid_event_type, NULL, &event_status),
1056 "Failed rte_dev_callback_unregister "
1057 "when no callback function ");
1058
1059 dev_id = dev1->data->dev_id;
1060
1061 rte_bbdev_release(dev1);
1062 rte_bbdev_release(dev2);
1063
1064 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1065 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1066 "Failed test for rte_bbdev_callback_register: "
1067 "function called after rte_bbdev_driver_uninit .");
1068
1069 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1070 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1071 "Failed test for rte_dev_callback_unregister: "
1072 "function called after rte_bbdev_driver_uninit. ");
1073
1074 event_status = -1;
1075 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1076 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1077 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1078 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1079 TEST_ASSERT(event_status == -1,
1080 "Failed test for rte_bbdev_pmd_callback_process: "
1081 "callback function was called after rte_bbdev_driver_uninit");
1082
1083 return TEST_SUCCESS;
1084 }
1085
1086 static int
test_bbdev_invalid_driver(void)1087 test_bbdev_invalid_driver(void)
1088 {
1089 struct rte_bbdev dev1, *dev2;
1090 uint8_t dev_id = null_dev_id;
1091 uint16_t queue_id = 0;
1092 struct rte_bbdev_stats stats;
1093 struct bbdev_testsuite_params *ts_params = &testsuite_params;
1094 struct rte_bbdev_queue_info qinfo;
1095 struct rte_bbdev_ops dev_ops_tmp;
1096
1097 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1098 dev_id);
1099
1100 dev1 = rte_bbdev_devices[dev_id];
1101 dev2 = &rte_bbdev_devices[dev_id];
1102
1103 /* Tests for rte_bbdev_setup_queues */
1104 dev2->dev_ops = NULL;
1105 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1106 "Failed test for rte_bbdev_setup_queues: "
1107 "NULL dev_ops structure ");
1108 dev2->dev_ops = dev1.dev_ops;
1109
1110 dev_ops_tmp = *dev2->dev_ops;
1111 dev_ops_tmp.info_get = NULL;
1112 dev2->dev_ops = &dev_ops_tmp;
1113 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1114 "Failed test for rte_bbdev_setup_queues: "
1115 "NULL info_get ");
1116 dev2->dev_ops = dev1.dev_ops;
1117
1118 dev_ops_tmp = *dev2->dev_ops;
1119 dev_ops_tmp.queue_release = NULL;
1120 dev2->dev_ops = &dev_ops_tmp;
1121 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1122 "Failed test for rte_bbdev_setup_queues: "
1123 "NULL queue_release ");
1124 dev2->dev_ops = dev1.dev_ops;
1125
1126 dev2->data->socket_id = SOCKET_ID_ANY;
1127 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1128 SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1129
1130 /* Test for rte_bbdev_queue_configure */
1131 dev2->dev_ops = NULL;
1132 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1133 &ts_params->qconf),
1134 "Failed to configure queue %u on device %u "
1135 "with NULL dev_ops structure ", queue_id, dev_id);
1136 dev2->dev_ops = dev1.dev_ops;
1137
1138 dev_ops_tmp = *dev2->dev_ops;
1139 dev_ops_tmp.queue_setup = NULL;
1140 dev2->dev_ops = &dev_ops_tmp;
1141 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1142 &ts_params->qconf),
1143 "Failed to configure queue %u on device %u "
1144 "with NULL queue_setup ", queue_id, dev_id);
1145 dev2->dev_ops = dev1.dev_ops;
1146
1147 dev_ops_tmp = *dev2->dev_ops;
1148 dev_ops_tmp.info_get = NULL;
1149 dev2->dev_ops = &dev_ops_tmp;
1150 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1151 &ts_params->qconf),
1152 "Failed to configure queue %u on device %u "
1153 "with NULL info_get ", queue_id, dev_id);
1154 dev2->dev_ops = dev1.dev_ops;
1155
1156 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1157 queue_id, &ts_params->qconf),
1158 "Failed to configure queue %u on device %u ",
1159 queue_id, dev_id);
1160
1161 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1162 &ts_params->qconf),
1163 "Failed to configure queue %u on device %u ",
1164 queue_id, dev_id);
1165
1166 /* Test for rte_bbdev_queue_info_get */
1167 dev2->dev_ops = NULL;
1168 TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1169 "Failed test for rte_bbdev_info_get: "
1170 "NULL dev_ops structure ");
1171 dev2->dev_ops = dev1.dev_ops;
1172
1173 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1174 queue_id, &qinfo),
1175 "Failed test for rte_bbdev_info_get: "
1176 "invalid dev_id ");
1177
1178 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1179 RTE_MAX_QUEUES_PER_PORT, &qinfo),
1180 "Failed test for rte_bbdev_info_get: "
1181 "invalid queue_id ");
1182
1183 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1184 "Failed test for rte_bbdev_info_get: "
1185 "invalid dev_info ");
1186
1187 /* Test for rte_bbdev_start */
1188 dev2->dev_ops = NULL;
1189 TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1190 "Failed to start bbdev %u "
1191 "with NULL dev_ops structure ", dev_id);
1192 dev2->dev_ops = dev1.dev_ops;
1193
1194 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1195 "Failed to start bbdev %u ", dev_id);
1196
1197 /* Test for rte_bbdev_queue_start */
1198 dev2->dev_ops = NULL;
1199 TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1200 "Failed to start queue %u on device %u: "
1201 "NULL dev_ops structure", queue_id, dev_id);
1202 dev2->dev_ops = dev1.dev_ops;
1203
1204 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1205 "Failed to start queue %u on device %u ", queue_id,
1206 dev_id);
1207
1208 /* Tests for rte_bbdev_stats_get */
1209 dev2->dev_ops = NULL;
1210 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1211 "Failed test for rte_bbdev_stats_get on device %u ",
1212 dev_id);
1213 dev2->dev_ops = dev1.dev_ops;
1214
1215 dev_ops_tmp = *dev2->dev_ops;
1216 dev_ops_tmp.stats_reset = NULL;
1217 dev2->dev_ops = &dev_ops_tmp;
1218 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1219 "Failed test for rte_bbdev_stats_get: "
1220 "NULL stats_get ");
1221 dev2->dev_ops = dev1.dev_ops;
1222
1223 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1224 "Failed test for rte_bbdev_stats_get on device %u ",
1225 dev_id);
1226
1227 /*
1228 * Tests for:
1229 * rte_bbdev_callback_register,
1230 * rte_bbdev_pmd_callback_process,
1231 * rte_dev_callback_unregister
1232 */
1233 dev2->dev_ops = NULL;
1234 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1235 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1236 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1237 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1238
1239 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1240 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1241 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1242
1243 /* Tests for rte_bbdev_stats_reset */
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 /* Tests for rte_bbdev_queue_stop */
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 /* Tests for rte_bbdev_stop */
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 /* Tests for rte_bbdev_close */
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
1297 static int
test_bbdev_get_named_dev(void)1298 test_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
1321 static 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() /**< NULL terminate unit test array */
1368 }
1369 };
1370
1371 REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);
1372