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