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 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 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 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 85 ut_teardown(void) 86 { 87 rte_bbdev_close(null_dev_id); 88 } 89 90 static int 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 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 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 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_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 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 385 static int 386 test_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 /* Valid dev_id values */ 395 dev_id = null_dev_id; 396 397 /* Valid queue_id values */ 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_queue_priority + 1; 417 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id, 418 &ts_params->qconf), 419 "Failed test for rte_bbdev_queue_configure: " 420 "invalid value qconf.queue_size: %u", 421 ts_params->qconf.queue_size); 422 423 ts_params->qconf.priority = info.drv.max_queue_priority; 424 queue_id = info.num_queues; 425 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id, 426 &ts_params->qconf), 427 "Failed test for rte_bbdev_queue_configure: " 428 "invalid value queue_id: %u", queue_id); 429 430 queue_id = 0; 431 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL), 432 "Failed test for rte_bbdev_queue_configure: " 433 "NULL qconf structure "); 434 435 ts_params->qconf.socket = RTE_MAX_NUMA_NODES; 436 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id, 437 &ts_params->qconf), 438 "Failed test for rte_bbdev_queue_configure: " 439 "invalid socket number "); 440 441 ts_params->qconf.socket = SOCKET_ID_ANY; 442 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, 443 &ts_params->qconf), 444 "Failed test for rte_bbdev_queue_configure: " 445 "invalid value qconf.queue_size: %u", 446 ts_params->qconf.queue_size); 447 448 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id, 449 &ts_params->qconf), 450 "Failed test for rte_bbdev_queue_configure: " 451 "invalid dev_id"); 452 453 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL), 454 "Failed test for rte_bbdev_queue_configure: " 455 "invalid value qconf.queue_size: %u", 456 ts_params->qconf.queue_size); 457 458 return TEST_SUCCESS; 459 } 460 461 static int 462 test_bbdev_op_pool(void) 463 { 464 struct rte_mempool *mp; 465 466 unsigned int dec_size = sizeof(struct rte_bbdev_dec_op); 467 unsigned int enc_size = sizeof(struct rte_bbdev_enc_op); 468 469 const char *pool_dec = "Test_DEC"; 470 const char *pool_enc = "Test_ENC"; 471 472 /* Valid pool configuration */ 473 uint32_t size = 256; 474 uint32_t cache_size = 128; 475 476 TEST_ASSERT(rte_bbdev_op_pool_create(NULL, 477 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL, 478 "Failed test for rte_bbdev_op_pool_create: " 479 "NULL name parameter"); 480 481 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec, 482 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL, 483 "Failed test for rte_bbdev_op_pool_create: " 484 "returned value is empty"); 485 486 TEST_ASSERT(mp->size == size, 487 "Failed test for rte_bbdev_op_pool_create: " 488 "invalid size of the mempool, mp->size: %u", mp->size); 489 490 TEST_ASSERT(mp->cache_size == cache_size, 491 "Failed test for rte_bbdev_op_pool_create: " 492 "invalid size of the mempool, mp->size: %u", 493 mp->cache_size); 494 495 TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec), 496 "Failed test for rte_bbdev_op_pool_create: " 497 "invalid name of mempool, mp->name: %s", mp->name); 498 499 TEST_ASSERT(mp->elt_size == dec_size, 500 "Failed test for rte_bbdev_op_pool_create: " 501 "invalid element size for RTE_BBDEV_OP_TURBO_DEC, " 502 "mp->elt_size: %u", mp->elt_size); 503 504 rte_mempool_free(mp); 505 506 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc, 507 RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL, 508 "Failed test for rte_bbdev_op_pool_create: " 509 "returned value is empty"); 510 511 TEST_ASSERT(mp->elt_size == enc_size, 512 "Failed test for rte_bbdev_op_pool_create: " 513 "invalid element size for RTE_BBDEV_OP_TURBO_ENC, " 514 "mp->elt_size: %u", mp->elt_size); 515 516 rte_mempool_free(mp); 517 518 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE", 519 RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL, 520 "Failed test for rte_bbdev_op_pool_create: " 521 "returned value is empty for RTE_BBDEV_OP_NONE"); 522 523 TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size), 524 "Failed test for rte_bbdev_op_pool_create: " 525 "invalid size for RTE_BBDEV_OP_NONE, mp->elt_size: %u", 526 mp->elt_size); 527 528 rte_mempool_free(mp); 529 530 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV", 531 RTE_BBDEV_OP_TYPE_COUNT, size, cache_size, 0)) == NULL, 532 "Failed test for rte_bbdev_op_pool_create: " 533 "returned value is not NULL for invalid type"); 534 535 /* Invalid pool configuration */ 536 size = 128; 537 cache_size = 256; 538 539 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize", 540 RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL, 541 "Failed test for rte_bbdev_op_pool_create: " 542 "returned value should be empty " 543 "because size of per-lcore local cache " 544 "is greater than size of the mempool."); 545 546 return TEST_SUCCESS; 547 } 548 549 /** 550 * Create pool of OP types RTE_BBDEV_OP_NONE, RTE_BBDEV_OP_TURBO_DEC and 551 * RTE_BBDEV_OP_TURBO_ENC and check that only ops of that type can be 552 * allocated 553 */ 554 static int 555 test_bbdev_op_type(void) 556 { 557 struct rte_mempool *mp_dec; 558 559 const unsigned int OPS_COUNT = 32; 560 struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT]; 561 struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT]; 562 563 const char *pool_dec = "Test_op_dec"; 564 565 /* Valid pool configuration */ 566 uint32_t num_elements = 256; 567 uint32_t cache_size = 128; 568 569 /* mempool type : RTE_BBDEV_OP_TURBO_DEC */ 570 mp_dec = rte_bbdev_op_pool_create(pool_dec, 571 RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0); 572 TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec); 573 574 TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0, 575 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: " 576 "OPs type: RTE_BBDEV_OP_TURBO_DEC"); 577 578 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0, 579 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: " 580 "OPs type: RTE_BBDEV_OP_TURBO_ENC"); 581 582 rte_mempool_free(mp_dec); 583 584 return TEST_SUCCESS; 585 } 586 587 static int 588 test_bbdev_op_pool_size(void) 589 { 590 struct rte_mempool *mp_none; 591 592 const unsigned int OPS_COUNT = 128; 593 struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT]; 594 struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT]; 595 struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT]; 596 597 const char *pool_none = "Test_pool_size"; 598 599 /* Valid pool configuration */ 600 uint32_t num_elements = 256; 601 uint32_t cache_size = 0; 602 603 /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */ 604 mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC, 605 num_elements, cache_size, 0); 606 TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none); 607 608 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */ 609 rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT); 610 611 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */ 612 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr, 613 OPS_COUNT) == 0, 614 "Failed test for allocating bbdev ops: " 615 "Mempool size: 256, Free : 128, Attempted to add: 128"); 616 617 /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */ 618 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr, 619 OPS_COUNT) != 0, 620 "Failed test for allocating bbdev ops: " 621 "Mempool size: 256, Free : 0, Attempted to add: 128"); 622 623 /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */ 624 rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT); 625 626 /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */ 627 /* Cache size > 0 causes reallocation of ops size > 127 fail */ 628 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr, 629 OPS_COUNT) == 0, 630 "Failed test for allocating ops after mempool freed: " 631 "Mempool size: 256, Free : 128, Attempted to add: 128"); 632 633 rte_mempool_free(mp_none); 634 635 return TEST_SUCCESS; 636 } 637 638 static int 639 test_bbdev_count(void) 640 { 641 uint8_t num_devs, num_valid_devs = 0; 642 643 for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) { 644 if (rte_bbdev_is_valid(num_devs)) 645 num_valid_devs++; 646 } 647 648 num_devs = rte_bbdev_count(); 649 TEST_ASSERT(num_valid_devs == num_devs, 650 "Failed test for rte_bbdev_is_valid: " 651 "invalid num_devs %u ", num_devs); 652 653 return TEST_SUCCESS; 654 } 655 656 static int 657 test_bbdev_stats(void) 658 { 659 uint8_t dev_id = null_dev_id; 660 uint16_t queue_id = 0; 661 struct rte_bbdev_dec_op *dec_ops[4096] = { 0 }; 662 struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 }; 663 struct rte_bbdev_enc_op *enc_ops[4096] = { 0 }; 664 struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 }; 665 uint16_t num_ops = 236; 666 struct rte_bbdev_stats stats; 667 struct bbdev_testsuite_params *ts_params = &testsuite_params; 668 669 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id), 670 "Failed to stop queue %u on device %u ", queue_id, 671 dev_id); 672 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), 673 "Failed to stop bbdev %u ", dev_id); 674 675 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, 676 &ts_params->qconf), 677 "Failed to configure queue %u on device %u ", 678 queue_id, dev_id); 679 680 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id), 681 "Failed to start bbdev %u ", dev_id); 682 683 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id), 684 "Failed to start queue %u on device %u ", queue_id, 685 dev_id); 686 687 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id), 688 "Failed to start queue %u on device %u ", queue_id, 689 dev_id); 690 691 /* Tests after enqueue operation */ 692 rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops); 693 rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops); 694 695 TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats), 696 "Failed test for rte_bbdev_stats_get on device %u ", 697 dev_id); 698 699 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL), 700 "Failed test for rte_bbdev_stats_get on device %u ", 701 dev_id); 702 703 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats), 704 "Failed test for rte_bbdev_stats_get on device %u ", 705 dev_id); 706 707 TEST_ASSERT(stats.enqueued_count == 2 * num_ops, 708 "Failed test for rte_bbdev_enqueue_ops: " 709 "invalid enqueued_count %" PRIu64 " ", 710 stats.enqueued_count); 711 712 TEST_ASSERT(stats.dequeued_count == 0, 713 "Failed test for rte_bbdev_stats_reset: " 714 "invalid dequeued_count %" PRIu64 " ", 715 stats.dequeued_count); 716 717 /* Tests after dequeue operation */ 718 rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops); 719 rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops); 720 721 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats), 722 "Failed test for rte_bbdev_stats_get on device %u ", 723 dev_id); 724 725 TEST_ASSERT(stats.dequeued_count == 2 * num_ops, 726 "Failed test for rte_bbdev_dequeue_ops: " 727 "invalid enqueued_count %" PRIu64 " ", 728 stats.dequeued_count); 729 730 TEST_ASSERT(stats.enqueue_err_count == 0, 731 "Failed test for rte_bbdev_stats_reset: " 732 "invalid enqueue_err_count %" PRIu64 " ", 733 stats.enqueue_err_count); 734 735 TEST_ASSERT(stats.dequeue_err_count == 0, 736 "Failed test for rte_bbdev_stats_reset: " 737 "invalid dequeue_err_count %" PRIu64 " ", 738 stats.dequeue_err_count); 739 740 /* Tests after reset operation */ 741 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS), 742 "Failed to reset statistic for device %u ", dev_id); 743 744 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id), 745 "Failed to reset statistic for device %u ", dev_id); 746 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats), 747 "Failed test for rte_bbdev_stats_get on device %u ", 748 dev_id); 749 750 TEST_ASSERT(stats.enqueued_count == 0, 751 "Failed test for rte_bbdev_stats_reset: " 752 "invalid enqueued_count %" PRIu64 " ", 753 stats.enqueued_count); 754 755 TEST_ASSERT(stats.dequeued_count == 0, 756 "Failed test for rte_bbdev_stats_reset: " 757 "invalid dequeued_count %" PRIu64 " ", 758 stats.dequeued_count); 759 760 TEST_ASSERT(stats.enqueue_err_count == 0, 761 "Failed test for rte_bbdev_stats_reset: " 762 "invalid enqueue_err_count %" PRIu64 " ", 763 stats.enqueue_err_count); 764 765 TEST_ASSERT(stats.dequeue_err_count == 0, 766 "Failed test for rte_bbdev_stats_reset: " 767 "invalid dequeue_err_count %" PRIu64 " ", 768 stats.dequeue_err_count); 769 770 return TEST_SUCCESS; 771 } 772 773 static int 774 test_bbdev_driver_init(void) 775 { 776 struct rte_bbdev *dev1, *dev2; 777 const char *name = "dev_name"; 778 char name_tmp[16]; 779 int num_devs, num_devs_tmp; 780 781 dev1 = rte_bbdev_allocate(NULL); 782 TEST_ASSERT(dev1 == NULL, 783 "Failed initialize bbdev driver with NULL name"); 784 785 dev1 = rte_bbdev_allocate(name); 786 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver"); 787 788 dev2 = rte_bbdev_allocate(name); 789 TEST_ASSERT(dev2 == NULL, 790 "Failed to initialize bbdev driver: " 791 "driver with the same name has been initialized before"); 792 793 num_devs = rte_bbdev_count() - 1; 794 num_devs_tmp = num_devs; 795 796 /* Initialize the maximum amount of devices */ 797 do { 798 sprintf(name_tmp, "%s%i", "name_", num_devs); 799 dev2 = rte_bbdev_allocate(name_tmp); 800 TEST_ASSERT(dev2 != NULL, 801 "Failed to initialize bbdev driver"); 802 ++num_devs; 803 } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1)); 804 805 sprintf(name_tmp, "%s%i", "name_", num_devs); 806 dev2 = rte_bbdev_allocate(name_tmp); 807 TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d " 808 "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs, 809 RTE_BBDEV_MAX_DEVS); 810 811 num_devs--; 812 813 while (num_devs >= num_devs_tmp) { 814 sprintf(name_tmp, "%s%i", "name_", num_devs); 815 dev2 = rte_bbdev_get_named_dev(name_tmp); 816 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2), 817 "Failed to uninitialize bbdev driver %s ", 818 name_tmp); 819 num_devs--; 820 } 821 822 TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS, 823 "Failed test rte_bbdev_allocate: " 824 "invalid dev_id %" PRIu8 ", max number of devices %d ", 825 dev1->data->dev_id, RTE_BBDEV_MAX_DEVS); 826 827 TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED, 828 "Failed test rte_bbdev_allocate: " 829 "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED", 830 dev1->state); 831 832 TEST_ASSERT_FAIL(rte_bbdev_release(NULL), 833 "Failed to uninitialize bbdev driver with NULL bbdev"); 834 835 sprintf(name_tmp, "%s", "invalid_name"); 836 dev2 = rte_bbdev_get_named_dev(name_tmp); 837 TEST_ASSERT_FAIL(rte_bbdev_release(dev2), 838 "Failed to uninitialize bbdev driver with invalid name"); 839 840 dev2 = rte_bbdev_get_named_dev(name); 841 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2), 842 "Failed to uninitialize bbdev driver: %s ", name); 843 844 return TEST_SUCCESS; 845 } 846 847 static void 848 event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param, 849 void *ret_param) 850 { 851 RTE_SET_USED(dev_id); 852 RTE_SET_USED(ret_param); 853 854 if (param == NULL) 855 return; 856 857 if (type == RTE_BBDEV_EVENT_UNKNOWN || 858 type == RTE_BBDEV_EVENT_ERROR || 859 type == RTE_BBDEV_EVENT_MAX) 860 *(int *)param = type; 861 } 862 863 static int 864 test_bbdev_callback(void) 865 { 866 struct rte_bbdev *dev1, *dev2; 867 const char *name = "dev_name1"; 868 const char *name2 = "dev_name2"; 869 int event_status; 870 uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS; 871 enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX; 872 uint8_t dev_id; 873 874 dev1 = rte_bbdev_allocate(name); 875 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver"); 876 877 /* 878 * RTE_BBDEV_EVENT_UNKNOWN - unregistered 879 * RTE_BBDEV_EVENT_ERROR - unregistered 880 */ 881 event_status = -1; 882 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL); 883 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL); 884 TEST_ASSERT(event_status == -1, 885 "Failed test for rte_bbdev_pmd_callback_process: " 886 "events were not registered "); 887 888 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id, 889 RTE_BBDEV_EVENT_MAX, event_callback, NULL), 890 "Failed to callback register for RTE_BBDEV_EVENT_MAX "); 891 892 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id, 893 RTE_BBDEV_EVENT_MAX, event_callback, NULL), 894 "Failed to unregister RTE_BBDEV_EVENT_MAX "); 895 896 /* 897 * RTE_BBDEV_EVENT_UNKNOWN - registered 898 * RTE_BBDEV_EVENT_ERROR - unregistered 899 */ 900 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id, 901 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status), 902 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN"); 903 904 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL); 905 TEST_ASSERT(event_status == 0, 906 "Failed test for rte_bbdev_pmd_callback_process " 907 "for RTE_BBDEV_EVENT_UNKNOWN "); 908 909 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL); 910 TEST_ASSERT(event_status == 0, 911 "Failed test for rte_bbdev_pmd_callback_process: " 912 "event RTE_BBDEV_EVENT_ERROR was not registered "); 913 914 /* 915 * RTE_BBDEV_EVENT_UNKNOWN - registered 916 * RTE_BBDEV_EVENT_ERROR - registered 917 */ 918 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id, 919 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status), 920 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR "); 921 922 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id, 923 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status), 924 "Failed to callback register for RTE_BBDEV_EVENT_ERROR" 925 "(re-registration) "); 926 927 event_status = -1; 928 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL); 929 TEST_ASSERT(event_status == 0, 930 "Failed test for rte_bbdev_pmd_callback_process " 931 "for RTE_BBDEV_EVENT_UNKNOWN "); 932 933 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL); 934 TEST_ASSERT(event_status == 1, 935 "Failed test for rte_bbdev_pmd_callback_process " 936 "for RTE_BBDEV_EVENT_ERROR "); 937 938 /* 939 * RTE_BBDEV_EVENT_UNKNOWN - registered 940 * RTE_BBDEV_EVENT_ERROR - unregistered 941 */ 942 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id, 943 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status), 944 "Failed to unregister RTE_BBDEV_EVENT_ERROR "); 945 946 event_status = -1; 947 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL); 948 TEST_ASSERT(event_status == 0, 949 "Failed test for rte_bbdev_pmd_callback_process " 950 "for RTE_BBDEV_EVENT_UNKNOWN "); 951 952 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL); 953 TEST_ASSERT(event_status == 0, 954 "Failed test for rte_bbdev_pmd_callback_process: " 955 "event RTE_BBDEV_EVENT_ERROR was unregistered "); 956 957 /* rte_bbdev_callback_register with invalid inputs */ 958 TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id, 959 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status), 960 "Failed test for rte_bbdev_callback_register " 961 "for invalid_dev_id "); 962 963 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id, 964 invalid_event_type, event_callback, &event_status), 965 "Failed to callback register for invalid event type "); 966 967 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id, 968 RTE_BBDEV_EVENT_ERROR, NULL, &event_status), 969 "Failed to callback register - no callback function "); 970 971 /* The impact of devices on each other */ 972 dev2 = rte_bbdev_allocate(name2); 973 TEST_ASSERT(dev2 != NULL, 974 "Failed to initialize bbdev driver"); 975 976 /* 977 * dev2: 978 * RTE_BBDEV_EVENT_UNKNOWN - unregistered 979 * RTE_BBDEV_EVENT_ERROR - unregistered 980 */ 981 event_status = -1; 982 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL); 983 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL); 984 TEST_ASSERT(event_status == -1, 985 "Failed test for rte_bbdev_pmd_callback_process: " 986 "events were not registered "); 987 988 /* 989 * dev1: RTE_BBDEV_EVENT_ERROR - unregistered 990 * dev2: RTE_BBDEV_EVENT_ERROR - registered 991 */ 992 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id, 993 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status), 994 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR"); 995 996 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL); 997 TEST_ASSERT(event_status == -1, 998 "Failed test for rte_bbdev_pmd_callback_process in dev1 " 999 "for RTE_BBDEV_EVENT_ERROR "); 1000 1001 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL); 1002 TEST_ASSERT(event_status == 1, 1003 "Failed test for rte_bbdev_pmd_callback_process in dev2 " 1004 "for RTE_BBDEV_EVENT_ERROR "); 1005 1006 /* 1007 * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered 1008 * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered 1009 */ 1010 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id, 1011 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status), 1012 "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN " 1013 "in dev 2 "); 1014 1015 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL); 1016 TEST_ASSERT(event_status == 0, 1017 "Failed test for rte_bbdev_pmd_callback_process in dev2" 1018 " for RTE_BBDEV_EVENT_UNKNOWN "); 1019 1020 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id, 1021 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status), 1022 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN "); 1023 1024 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id, 1025 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status), 1026 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : " 1027 "unregister function called once again "); 1028 1029 event_status = -1; 1030 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL); 1031 TEST_ASSERT(event_status == -1, 1032 "Failed test for rte_bbdev_pmd_callback_process in dev2" 1033 " for RTE_BBDEV_EVENT_UNKNOWN "); 1034 1035 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL); 1036 TEST_ASSERT(event_status == 0, 1037 "Failed test for rte_bbdev_pmd_callback_process in dev2 " 1038 "for RTE_BBDEV_EVENT_UNKNOWN "); 1039 1040 /* rte_bbdev_pmd_callback_process with invalid inputs */ 1041 rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL); 1042 1043 event_status = -1; 1044 rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL); 1045 TEST_ASSERT(event_status == -1, 1046 "Failed test for rte_bbdev_pmd_callback_process: " 1047 "for invalid event type "); 1048 1049 /* rte_dev_callback_unregister with invalid inputs */ 1050 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id, 1051 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status), 1052 "Failed test for rte_dev_callback_unregister " 1053 "for invalid_dev_id "); 1054 1055 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id, 1056 invalid_event_type, event_callback, &event_status), 1057 "Failed rte_dev_callback_unregister " 1058 "for invalid event type "); 1059 1060 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id, 1061 invalid_event_type, NULL, &event_status), 1062 "Failed rte_dev_callback_unregister " 1063 "when no callback function "); 1064 1065 dev_id = dev1->data->dev_id; 1066 1067 rte_bbdev_release(dev1); 1068 rte_bbdev_release(dev2); 1069 1070 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id, 1071 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status), 1072 "Failed test for rte_bbdev_callback_register: " 1073 "function called after rte_bbdev_driver_uninit ."); 1074 1075 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id, 1076 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status), 1077 "Failed test for rte_dev_callback_unregister: " 1078 "function called after rte_bbdev_driver_uninit. "); 1079 1080 event_status = -1; 1081 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL); 1082 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL); 1083 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL); 1084 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL); 1085 TEST_ASSERT(event_status == -1, 1086 "Failed test for rte_bbdev_pmd_callback_process: " 1087 "callback function was called after rte_bbdev_driver_uninit"); 1088 1089 return TEST_SUCCESS; 1090 } 1091 1092 static int 1093 test_bbdev_invalid_driver(void) 1094 { 1095 struct rte_bbdev dev1, *dev2; 1096 uint8_t dev_id = null_dev_id; 1097 uint16_t queue_id = 0; 1098 struct rte_bbdev_stats stats; 1099 struct bbdev_testsuite_params *ts_params = &testsuite_params; 1100 struct rte_bbdev_queue_info qinfo; 1101 struct rte_bbdev_ops dev_ops_tmp; 1102 1103 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ", 1104 dev_id); 1105 1106 dev1 = rte_bbdev_devices[dev_id]; 1107 dev2 = &rte_bbdev_devices[dev_id]; 1108 1109 /* Tests for rte_bbdev_setup_queues */ 1110 dev2->dev_ops = NULL; 1111 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY), 1112 "Failed test for rte_bbdev_setup_queues: " 1113 "NULL dev_ops structure "); 1114 dev2->dev_ops = dev1.dev_ops; 1115 1116 dev_ops_tmp = *dev2->dev_ops; 1117 dev_ops_tmp.info_get = NULL; 1118 dev2->dev_ops = &dev_ops_tmp; 1119 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY), 1120 "Failed test for rte_bbdev_setup_queues: " 1121 "NULL info_get "); 1122 dev2->dev_ops = dev1.dev_ops; 1123 1124 dev_ops_tmp = *dev2->dev_ops; 1125 dev_ops_tmp.queue_release = NULL; 1126 dev2->dev_ops = &dev_ops_tmp; 1127 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY), 1128 "Failed test for rte_bbdev_setup_queues: " 1129 "NULL queue_release "); 1130 dev2->dev_ops = dev1.dev_ops; 1131 1132 dev2->data->socket_id = SOCKET_ID_ANY; 1133 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1, 1134 SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id); 1135 1136 /* Test for rte_bbdev_queue_configure */ 1137 dev2->dev_ops = NULL; 1138 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id, 1139 &ts_params->qconf), 1140 "Failed to configure queue %u on device %u " 1141 "with NULL dev_ops structure ", queue_id, dev_id); 1142 dev2->dev_ops = dev1.dev_ops; 1143 1144 dev_ops_tmp = *dev2->dev_ops; 1145 dev_ops_tmp.queue_setup = NULL; 1146 dev2->dev_ops = &dev_ops_tmp; 1147 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id, 1148 &ts_params->qconf), 1149 "Failed to configure queue %u on device %u " 1150 "with NULL queue_setup ", queue_id, dev_id); 1151 dev2->dev_ops = dev1.dev_ops; 1152 1153 dev_ops_tmp = *dev2->dev_ops; 1154 dev_ops_tmp.info_get = NULL; 1155 dev2->dev_ops = &dev_ops_tmp; 1156 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id, 1157 &ts_params->qconf), 1158 "Failed to configure queue %u on device %u " 1159 "with NULL info_get ", queue_id, dev_id); 1160 dev2->dev_ops = dev1.dev_ops; 1161 1162 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, 1163 queue_id, &ts_params->qconf), 1164 "Failed to configure queue %u on device %u ", 1165 queue_id, dev_id); 1166 1167 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, 1168 &ts_params->qconf), 1169 "Failed to configure queue %u on device %u ", 1170 queue_id, dev_id); 1171 1172 /* Test for rte_bbdev_queue_info_get */ 1173 dev2->dev_ops = NULL; 1174 TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo), 1175 "Failed test for rte_bbdev_info_get: " 1176 "NULL dev_ops structure "); 1177 dev2->dev_ops = dev1.dev_ops; 1178 1179 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS, 1180 queue_id, &qinfo), 1181 "Failed test for rte_bbdev_info_get: " 1182 "invalid dev_id "); 1183 1184 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, 1185 RTE_MAX_QUEUES_PER_PORT, &qinfo), 1186 "Failed test for rte_bbdev_info_get: " 1187 "invalid queue_id "); 1188 1189 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL), 1190 "Failed test for rte_bbdev_info_get: " 1191 "invalid dev_info "); 1192 1193 /* Test for rte_bbdev_start */ 1194 dev2->dev_ops = NULL; 1195 TEST_ASSERT_FAIL(rte_bbdev_start(dev_id), 1196 "Failed to start bbdev %u " 1197 "with NULL dev_ops structure ", dev_id); 1198 dev2->dev_ops = dev1.dev_ops; 1199 1200 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id), 1201 "Failed to start bbdev %u ", dev_id); 1202 1203 /* Test for rte_bbdev_queue_start */ 1204 dev2->dev_ops = NULL; 1205 TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id), 1206 "Failed to start queue %u on device %u: " 1207 "NULL dev_ops structure", queue_id, dev_id); 1208 dev2->dev_ops = dev1.dev_ops; 1209 1210 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id), 1211 "Failed to start queue %u on device %u ", queue_id, 1212 dev_id); 1213 1214 /* Tests for rte_bbdev_stats_get */ 1215 dev2->dev_ops = NULL; 1216 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats), 1217 "Failed test for rte_bbdev_stats_get on device %u ", 1218 dev_id); 1219 dev2->dev_ops = dev1.dev_ops; 1220 1221 dev_ops_tmp = *dev2->dev_ops; 1222 dev_ops_tmp.stats_reset = NULL; 1223 dev2->dev_ops = &dev_ops_tmp; 1224 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats), 1225 "Failed test for rte_bbdev_stats_get: " 1226 "NULL stats_get "); 1227 dev2->dev_ops = dev1.dev_ops; 1228 1229 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats), 1230 "Failed test for rte_bbdev_stats_get on device %u ", 1231 dev_id); 1232 1233 /* 1234 * Tests for: 1235 * rte_bbdev_callback_register, 1236 * rte_bbdev_pmd_callback_process, 1237 * rte_dev_callback_unregister 1238 */ 1239 dev2->dev_ops = NULL; 1240 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id, 1241 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL), 1242 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN"); 1243 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL); 1244 1245 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id, 1246 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL), 1247 "Failed to unregister RTE_BBDEV_EVENT_ERROR "); 1248 dev2->dev_ops = dev1.dev_ops; 1249 1250 /* Tests for rte_bbdev_stats_reset */ 1251 dev2->dev_ops = NULL; 1252 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id), 1253 "Failed to reset statistic for device %u ", dev_id); 1254 dev2->dev_ops = dev1.dev_ops; 1255 1256 dev_ops_tmp = *dev2->dev_ops; 1257 dev_ops_tmp.stats_reset = NULL; 1258 dev2->dev_ops = &dev_ops_tmp; 1259 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id), 1260 "Failed test for rte_bbdev_stats_reset: " 1261 "NULL stats_reset "); 1262 dev2->dev_ops = dev1.dev_ops; 1263 1264 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id), 1265 "Failed to reset statistic for device %u ", dev_id); 1266 1267 /* Tests for rte_bbdev_queue_stop */ 1268 dev2->dev_ops = NULL; 1269 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id), 1270 "Failed to stop queue %u on device %u: " 1271 "NULL dev_ops structure", queue_id, dev_id); 1272 dev2->dev_ops = dev1.dev_ops; 1273 1274 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id), 1275 "Failed to stop queue %u on device %u ", queue_id, 1276 dev_id); 1277 1278 /* Tests for rte_bbdev_stop */ 1279 dev2->dev_ops = NULL; 1280 TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id), 1281 "Failed to stop bbdev %u with NULL dev_ops structure ", 1282 dev_id); 1283 dev2->dev_ops = dev1.dev_ops; 1284 1285 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), 1286 "Failed to stop bbdev %u ", dev_id); 1287 1288 /* Tests for rte_bbdev_close */ 1289 TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS), 1290 "Failed to close bbdev with invalid dev_id"); 1291 1292 dev2->dev_ops = NULL; 1293 TEST_ASSERT_FAIL(rte_bbdev_close(dev_id), 1294 "Failed to close bbdev %u with NULL dev_ops structure ", 1295 dev_id); 1296 dev2->dev_ops = dev1.dev_ops; 1297 1298 TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id), 1299 "Failed to close bbdev %u ", dev_id); 1300 1301 return TEST_SUCCESS; 1302 } 1303 1304 static int 1305 test_bbdev_get_named_dev(void) 1306 { 1307 struct rte_bbdev *dev, *dev_tmp; 1308 const char *name = "name"; 1309 1310 dev = rte_bbdev_allocate(name); 1311 TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver"); 1312 1313 dev_tmp = rte_bbdev_get_named_dev(NULL); 1314 TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: " 1315 "function called with NULL parameter"); 1316 1317 dev_tmp = rte_bbdev_get_named_dev(name); 1318 1319 TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: " 1320 "wrong device was returned "); 1321 1322 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev), 1323 "Failed to uninitialize bbdev driver %s ", name); 1324 1325 return TEST_SUCCESS; 1326 } 1327 1328 static struct unit_test_suite bbdev_null_testsuite = { 1329 .suite_name = "BBDEV NULL Unit Test Suite", 1330 .setup = testsuite_setup, 1331 .teardown = testsuite_teardown, 1332 .unit_test_cases = { 1333 1334 TEST_CASE(test_bbdev_configure_invalid_dev_id), 1335 1336 TEST_CASE_ST(ut_setup, ut_teardown, 1337 test_bbdev_configure_invalid_num_queues), 1338 1339 TEST_CASE_ST(ut_setup, ut_teardown, 1340 test_bbdev_configure_stop_device), 1341 1342 TEST_CASE_ST(ut_setup, ut_teardown, 1343 test_bbdev_configure_stop_queue), 1344 1345 TEST_CASE_ST(ut_setup, ut_teardown, 1346 test_bbdev_configure_invalid_queue_configure), 1347 1348 TEST_CASE_ST(ut_setup, ut_teardown, 1349 test_bbdev_op_pool), 1350 1351 TEST_CASE_ST(ut_setup, ut_teardown, 1352 test_bbdev_op_type), 1353 1354 TEST_CASE_ST(ut_setup, ut_teardown, 1355 test_bbdev_op_pool_size), 1356 1357 TEST_CASE_ST(ut_setup, ut_teardown, 1358 test_bbdev_stats), 1359 1360 TEST_CASE_ST(ut_setup, ut_teardown, 1361 test_bbdev_driver_init), 1362 1363 TEST_CASE_ST(ut_setup, ut_teardown, 1364 test_bbdev_callback), 1365 1366 TEST_CASE_ST(ut_setup, ut_teardown, 1367 test_bbdev_invalid_driver), 1368 1369 TEST_CASE_ST(ut_setup, ut_teardown, 1370 test_bbdev_get_named_dev), 1371 1372 TEST_CASE(test_bbdev_count), 1373 1374 TEST_CASES_END() /**< NULL terminate unit test array */ 1375 } 1376 }; 1377 1378 REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite); 1379