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