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_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 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 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 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 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 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 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 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 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 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 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 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