1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include <string.h> 7 #include <rte_common.h> 8 #include <rte_mempool.h> 9 #include <rte_mbuf.h> 10 #include <rte_cryptodev.h> 11 #include <rte_eventdev.h> 12 #include <rte_bus_vdev.h> 13 #include <rte_service.h> 14 #include <rte_event_crypto_adapter.h> 15 #include "test.h" 16 17 #define PKT_TRACE 0 18 #define NUM 1 19 #define DEFAULT_NUM_XFORMS (2) 20 #define NUM_MBUFS (8191) 21 #define MBUF_CACHE_SIZE (256) 22 #define MAXIMUM_IV_LENGTH (16) 23 #define DEFAULT_NUM_OPS_INFLIGHT (128) 24 #define MAX_NB_SESSIONS 4 25 #define TEST_APP_PORT_ID 0 26 #define TEST_APP_EV_QUEUE_ID 0 27 #define TEST_APP_EV_PRIORITY 0 28 #define TEST_APP_EV_FLOWID 0xAABB 29 #define TEST_CRYPTO_EV_QUEUE_ID 1 30 #define TEST_ADAPTER_ID 0 31 #define TEST_CDEV_ID 0 32 #define TEST_CDEV_QP_ID 0 33 #define PACKET_LENGTH 64 34 #define NB_TEST_PORTS 1 35 #define NB_TEST_QUEUES 2 36 #define NUM_CORES 1 37 #define CRYPTODEV_NAME_NULL_PMD crypto_null 38 39 #define MBUF_SIZE (sizeof(struct rte_mbuf) + \ 40 RTE_PKTMBUF_HEADROOM + PACKET_LENGTH) 41 #define IV_OFFSET (sizeof(struct rte_crypto_op) + \ 42 sizeof(struct rte_crypto_sym_op) + \ 43 DEFAULT_NUM_XFORMS * \ 44 sizeof(struct rte_crypto_sym_xform)) 45 46 /* Handle log statements in same manner as test macros */ 47 #define LOG_DBG(...) RTE_LOG(DEBUG, EAL, __VA_ARGS__) 48 49 static const uint8_t text_64B[] = { 50 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50, 51 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0, 52 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36, 53 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e, 54 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c, 55 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e, 56 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6, 57 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c 58 }; 59 60 struct event_crypto_adapter_test_params { 61 struct rte_mempool *mbuf_pool; 62 struct rte_mempool *op_mpool; 63 struct rte_mempool *session_mpool; 64 struct rte_mempool *session_priv_mpool; 65 struct rte_cryptodev_config *config; 66 uint8_t crypto_event_port_id; 67 }; 68 69 struct rte_event response_info = { 70 .queue_id = TEST_APP_EV_QUEUE_ID, 71 .sched_type = RTE_SCHED_TYPE_ATOMIC, 72 .flow_id = TEST_APP_EV_FLOWID, 73 .priority = TEST_APP_EV_PRIORITY 74 }; 75 76 struct rte_event_crypto_request request_info = { 77 .cdev_id = TEST_CDEV_ID, 78 .queue_pair_id = TEST_CDEV_QP_ID 79 }; 80 81 static struct event_crypto_adapter_test_params params; 82 static uint8_t crypto_adapter_setup_done; 83 static uint32_t slcore_id; 84 static int evdev; 85 86 static struct rte_mbuf * 87 alloc_fill_mbuf(struct rte_mempool *mpool, const uint8_t *data, 88 size_t len, uint8_t blocksize) 89 { 90 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); 91 size_t t_len = len - (blocksize ? (len % blocksize) : 0); 92 93 if (m) { 94 char *dst = rte_pktmbuf_append(m, t_len); 95 96 if (!dst) { 97 rte_pktmbuf_free(m); 98 return NULL; 99 } 100 101 rte_memcpy(dst, (const void *)data, t_len); 102 } 103 return m; 104 } 105 106 static int 107 send_recv_ev(struct rte_event *ev) 108 { 109 struct rte_crypto_op *op; 110 struct rte_event recv_ev; 111 int ret; 112 113 ret = rte_event_enqueue_burst(evdev, TEST_APP_PORT_ID, ev, NUM); 114 TEST_ASSERT_EQUAL(ret, NUM, 115 "Failed to send event to crypto adapter\n"); 116 117 while (rte_event_dequeue_burst(evdev, 118 TEST_APP_PORT_ID, &recv_ev, NUM, 0) == 0) 119 rte_pause(); 120 121 op = recv_ev.event_ptr; 122 #if PKT_TRACE 123 struct rte_mbuf *m = op->sym->m_src; 124 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 125 #endif 126 rte_pktmbuf_free(op->sym->m_src); 127 rte_crypto_op_free(op); 128 129 return TEST_SUCCESS; 130 } 131 132 static int 133 test_crypto_adapter_stats(void) 134 { 135 struct rte_event_crypto_adapter_stats stats; 136 137 rte_event_crypto_adapter_stats_get(TEST_ADAPTER_ID, &stats); 138 printf(" +------------------------------------------------------+\n"); 139 printf(" + Crypto adapter stats for instance %u:\n", TEST_ADAPTER_ID); 140 printf(" + Event port poll count %" PRIx64 "\n", 141 stats.event_poll_count); 142 printf(" + Event dequeue count %" PRIx64 "\n", 143 stats.event_deq_count); 144 printf(" + Cryptodev enqueue count %" PRIx64 "\n", 145 stats.crypto_enq_count); 146 printf(" + Cryptodev enqueue failed count %" PRIx64 "\n", 147 stats.crypto_enq_fail); 148 printf(" + Cryptodev dequeue count %" PRIx64 "\n", 149 stats.crypto_deq_count); 150 printf(" + Event enqueue count %" PRIx64 "\n", 151 stats.event_enq_count); 152 printf(" + Event enqueue retry count %" PRIx64 "\n", 153 stats.event_enq_retry_count); 154 printf(" + Event enqueue fail count %" PRIx64 "\n", 155 stats.event_enq_fail_count); 156 printf(" +------------------------------------------------------+\n"); 157 158 rte_event_crypto_adapter_stats_reset(TEST_ADAPTER_ID); 159 return TEST_SUCCESS; 160 } 161 162 static int 163 test_op_forward_mode(uint8_t session_less) 164 { 165 struct rte_crypto_sym_xform cipher_xform; 166 struct rte_cryptodev_sym_session *sess; 167 union rte_event_crypto_metadata m_data; 168 struct rte_crypto_sym_op *sym_op; 169 struct rte_crypto_op *op; 170 struct rte_mbuf *m; 171 struct rte_event ev; 172 uint32_t cap; 173 int ret; 174 175 memset(&m_data, 0, sizeof(m_data)); 176 177 m = alloc_fill_mbuf(params.mbuf_pool, text_64B, PACKET_LENGTH, 0); 178 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf!\n"); 179 #if PKT_TRACE 180 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 181 #endif 182 /* Setup Cipher Parameters */ 183 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 184 cipher_xform.next = NULL; 185 186 cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 187 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 188 189 op = rte_crypto_op_alloc(params.op_mpool, 190 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 191 TEST_ASSERT_NOT_NULL(op, 192 "Failed to allocate symmetric crypto operation struct\n"); 193 194 sym_op = op->sym; 195 196 if (!session_less) { 197 sess = rte_cryptodev_sym_session_create( 198 params.session_mpool); 199 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 200 201 /* Create Crypto session*/ 202 rte_cryptodev_sym_session_init(TEST_CDEV_ID, sess, 203 &cipher_xform, params.session_priv_mpool); 204 205 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, 206 evdev, &cap); 207 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 208 209 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 210 /* Fill in private user data information */ 211 rte_memcpy(&m_data.response_info, &response_info, 212 sizeof(response_info)); 213 rte_memcpy(&m_data.request_info, &request_info, 214 sizeof(request_info)); 215 rte_cryptodev_sym_session_set_user_data(sess, 216 &m_data, sizeof(m_data)); 217 } 218 219 rte_crypto_op_attach_sym_session(op, sess); 220 } else { 221 struct rte_crypto_sym_xform *first_xform; 222 223 rte_crypto_op_sym_xforms_alloc(op, NUM); 224 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 225 first_xform = &cipher_xform; 226 sym_op->xform = first_xform; 227 uint32_t len = IV_OFFSET + MAXIMUM_IV_LENGTH + 228 (sizeof(struct rte_crypto_sym_xform) * 2); 229 op->private_data_offset = len; 230 /* Fill in private data information */ 231 rte_memcpy(&m_data.response_info, &response_info, 232 sizeof(response_info)); 233 rte_memcpy(&m_data.request_info, &request_info, 234 sizeof(request_info)); 235 rte_memcpy((uint8_t *)op + len, &m_data, sizeof(m_data)); 236 } 237 238 sym_op->m_src = m; 239 sym_op->cipher.data.offset = 0; 240 sym_op->cipher.data.length = PACKET_LENGTH; 241 242 /* Fill in event info and update event_ptr with rte_crypto_op */ 243 memset(&ev, 0, sizeof(ev)); 244 ev.queue_id = TEST_CRYPTO_EV_QUEUE_ID; 245 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 246 ev.flow_id = 0xAABB; 247 ev.event_ptr = op; 248 249 ret = send_recv_ev(&ev); 250 TEST_ASSERT_SUCCESS(ret, "Failed to send/receive event to " 251 "crypto adapter\n"); 252 253 test_crypto_adapter_stats(); 254 255 return TEST_SUCCESS; 256 } 257 258 static int 259 map_adapter_service_core(void) 260 { 261 uint32_t adapter_service_id; 262 int ret; 263 264 if (rte_event_crypto_adapter_service_id_get(TEST_ADAPTER_ID, 265 &adapter_service_id) == 0) { 266 uint32_t core_list[NUM_CORES]; 267 268 ret = rte_service_lcore_list(core_list, NUM_CORES); 269 TEST_ASSERT(ret >= 0, "Failed to get service core list!"); 270 271 if (core_list[0] != slcore_id) { 272 TEST_ASSERT_SUCCESS(rte_service_lcore_add(slcore_id), 273 "Failed to add service core"); 274 TEST_ASSERT_SUCCESS(rte_service_lcore_start(slcore_id), 275 "Failed to start service core"); 276 } 277 278 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set( 279 adapter_service_id, slcore_id, 1), 280 "Failed to map adapter service"); 281 } 282 283 return TEST_SUCCESS; 284 } 285 286 static int 287 test_sessionless_with_op_forward_mode(void) 288 { 289 uint32_t cap; 290 int ret; 291 292 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, evdev, &cap); 293 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 294 295 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 296 map_adapter_service_core(); 297 298 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 299 "Failed to start event crypto adapter"); 300 301 ret = test_op_forward_mode(1); 302 TEST_ASSERT_SUCCESS(ret, "Sessionless - FORWARD mode test failed\n"); 303 return TEST_SUCCESS; 304 } 305 306 static int 307 test_session_with_op_forward_mode(void) 308 { 309 uint32_t cap; 310 int ret; 311 312 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, evdev, &cap); 313 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 314 315 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 316 map_adapter_service_core(); 317 318 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID 319 ), "Failed to start event crypto adapter"); 320 321 ret = test_op_forward_mode(0); 322 TEST_ASSERT_SUCCESS(ret, "Session based - FORWARD mode test failed\n"); 323 return TEST_SUCCESS; 324 } 325 326 static int 327 send_op_recv_ev(struct rte_crypto_op *op) 328 { 329 struct rte_crypto_op *recv_op; 330 struct rte_event ev; 331 int ret; 332 333 ret = rte_cryptodev_enqueue_burst(TEST_CDEV_ID, TEST_CDEV_QP_ID, 334 &op, NUM); 335 TEST_ASSERT_EQUAL(ret, NUM, "Failed to enqueue to cryptodev\n"); 336 memset(&ev, 0, sizeof(ev)); 337 338 while (rte_event_dequeue_burst(evdev, 339 TEST_APP_PORT_ID, &ev, NUM, 0) == 0) 340 rte_pause(); 341 342 recv_op = ev.event_ptr; 343 #if PKT_TRACE 344 struct rte_mbuf *m = recv_op->sym->m_src; 345 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 346 #endif 347 rte_pktmbuf_free(recv_op->sym->m_src); 348 rte_crypto_op_free(recv_op); 349 350 return TEST_SUCCESS; 351 } 352 353 static int 354 test_op_new_mode(uint8_t session_less) 355 { 356 struct rte_crypto_sym_xform cipher_xform; 357 struct rte_cryptodev_sym_session *sess; 358 union rte_event_crypto_metadata m_data; 359 struct rte_crypto_sym_op *sym_op; 360 struct rte_crypto_op *op; 361 struct rte_mbuf *m; 362 uint32_t cap; 363 int ret; 364 365 memset(&m_data, 0, sizeof(m_data)); 366 367 m = alloc_fill_mbuf(params.mbuf_pool, text_64B, PACKET_LENGTH, 0); 368 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf!\n"); 369 #if PKT_TRACE 370 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 371 #endif 372 /* Setup Cipher Parameters */ 373 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 374 cipher_xform.next = NULL; 375 376 cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 377 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 378 379 op = rte_crypto_op_alloc(params.op_mpool, 380 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 381 TEST_ASSERT_NOT_NULL(op, "Failed to allocate crypto_op!\n"); 382 383 sym_op = op->sym; 384 385 if (!session_less) { 386 sess = rte_cryptodev_sym_session_create( 387 params.session_mpool); 388 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 389 390 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, 391 evdev, &cap); 392 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 393 394 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 395 /* Fill in private user data information */ 396 rte_memcpy(&m_data.response_info, &response_info, 397 sizeof(m_data)); 398 rte_cryptodev_sym_session_set_user_data(sess, 399 &m_data, sizeof(m_data)); 400 } 401 rte_cryptodev_sym_session_init(TEST_CDEV_ID, sess, 402 &cipher_xform, params.session_priv_mpool); 403 rte_crypto_op_attach_sym_session(op, sess); 404 } else { 405 struct rte_crypto_sym_xform *first_xform; 406 407 rte_crypto_op_sym_xforms_alloc(op, NUM); 408 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 409 first_xform = &cipher_xform; 410 sym_op->xform = first_xform; 411 uint32_t len = IV_OFFSET + MAXIMUM_IV_LENGTH + 412 (sizeof(struct rte_crypto_sym_xform) * 2); 413 op->private_data_offset = len; 414 /* Fill in private data information */ 415 rte_memcpy(&m_data.response_info, &response_info, 416 sizeof(m_data)); 417 rte_memcpy((uint8_t *)op + len, &m_data, sizeof(m_data)); 418 } 419 420 sym_op->m_src = m; 421 sym_op->cipher.data.offset = 0; 422 sym_op->cipher.data.length = PACKET_LENGTH; 423 424 ret = send_op_recv_ev(op); 425 TEST_ASSERT_SUCCESS(ret, "Failed to enqueue op to cryptodev\n"); 426 427 test_crypto_adapter_stats(); 428 429 return TEST_SUCCESS; 430 } 431 432 static int 433 test_sessionless_with_op_new_mode(void) 434 { 435 uint32_t cap; 436 int ret; 437 438 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, evdev, &cap); 439 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 440 441 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) || 442 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 443 map_adapter_service_core(); 444 445 /* start the event crypto adapter */ 446 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 447 "Failed to start event crypto adapter"); 448 449 ret = test_op_new_mode(1); 450 TEST_ASSERT_SUCCESS(ret, "Sessionless - NEW mode test failed\n"); 451 return TEST_SUCCESS; 452 } 453 454 static int 455 test_session_with_op_new_mode(void) 456 { 457 uint32_t cap; 458 int ret; 459 460 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, evdev, &cap); 461 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 462 463 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) || 464 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 465 map_adapter_service_core(); 466 467 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 468 "Failed to start event crypto adapter"); 469 470 ret = test_op_new_mode(0); 471 TEST_ASSERT_SUCCESS(ret, "Session based - NEW mode test failed\n"); 472 return TEST_SUCCESS; 473 } 474 475 static int 476 configure_cryptodev(void) 477 { 478 struct rte_cryptodev_qp_conf qp_conf; 479 struct rte_cryptodev_config conf; 480 struct rte_cryptodev_info info; 481 unsigned int session_size; 482 uint8_t nb_devs; 483 int ret; 484 485 params.mbuf_pool = rte_pktmbuf_pool_create( 486 "CRYPTO_ADAPTER_MBUFPOOL", 487 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 488 rte_socket_id()); 489 if (params.mbuf_pool == NULL) { 490 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n"); 491 return TEST_FAILED; 492 } 493 494 params.op_mpool = rte_crypto_op_pool_create( 495 "EVENT_CRYPTO_SYM_OP_POOL", 496 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 497 NUM_MBUFS, MBUF_CACHE_SIZE, 498 DEFAULT_NUM_XFORMS * 499 sizeof(struct rte_crypto_sym_xform) + 500 MAXIMUM_IV_LENGTH, 501 rte_socket_id()); 502 if (params.op_mpool == NULL) { 503 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); 504 return TEST_FAILED; 505 } 506 507 /* Create a NULL crypto device */ 508 nb_devs = rte_cryptodev_device_count_by_driver( 509 rte_cryptodev_driver_id_get( 510 RTE_STR(CRYPTODEV_NAME_NULL_PMD))); 511 if (!nb_devs) { 512 ret = rte_vdev_init( 513 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); 514 515 TEST_ASSERT(ret == 0, "Failed to create pmd:%s instance\n", 516 RTE_STR(CRYPTODEV_NAME_NULL_PMD)); 517 } 518 519 nb_devs = rte_cryptodev_count(); 520 if (!nb_devs) { 521 RTE_LOG(ERR, USER1, "No crypto devices found!\n"); 522 return TEST_FAILED; 523 } 524 525 /* 526 * Create mempool with maximum number of sessions * 2, 527 * to include the session headers & private data 528 */ 529 session_size = rte_cryptodev_sym_get_private_session_size(TEST_CDEV_ID); 530 session_size += sizeof(union rte_event_crypto_metadata); 531 532 params.session_mpool = rte_cryptodev_sym_session_pool_create( 533 "CRYPTO_ADAPTER_SESSION_MP", 534 MAX_NB_SESSIONS, 0, 0, 0, SOCKET_ID_ANY); 535 TEST_ASSERT_NOT_NULL(params.session_mpool, 536 "session mempool allocation failed\n"); 537 538 params.session_priv_mpool = rte_mempool_create( 539 "CRYPTO_ADAPTER_SESSION_MP_PRIV", 540 MAX_NB_SESSIONS, 541 session_size, 542 0, 0, NULL, NULL, NULL, 543 NULL, SOCKET_ID_ANY, 544 0); 545 TEST_ASSERT_NOT_NULL(params.session_priv_mpool, 546 "session mempool allocation failed\n"); 547 548 rte_cryptodev_info_get(TEST_CDEV_ID, &info); 549 conf.nb_queue_pairs = info.max_nb_queue_pairs; 550 conf.socket_id = SOCKET_ID_ANY; 551 conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY; 552 553 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(TEST_CDEV_ID, &conf), 554 "Failed to configure cryptodev %u with %u qps\n", 555 TEST_CDEV_ID, conf.nb_queue_pairs); 556 557 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 558 qp_conf.mp_session = params.session_mpool; 559 qp_conf.mp_session_private = params.session_priv_mpool; 560 561 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 562 TEST_CDEV_ID, TEST_CDEV_QP_ID, &qp_conf, 563 rte_cryptodev_socket_id(TEST_CDEV_ID)), 564 "Failed to setup queue pair %u on cryptodev %u\n", 565 TEST_CDEV_QP_ID, TEST_CDEV_ID); 566 567 return TEST_SUCCESS; 568 } 569 570 static inline void 571 evdev_set_conf_values(struct rte_event_dev_config *dev_conf, 572 struct rte_event_dev_info *info) 573 { 574 memset(dev_conf, 0, sizeof(struct rte_event_dev_config)); 575 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns; 576 dev_conf->nb_event_ports = NB_TEST_PORTS; 577 dev_conf->nb_event_queues = NB_TEST_QUEUES; 578 dev_conf->nb_event_queue_flows = info->max_event_queue_flows; 579 dev_conf->nb_event_port_dequeue_depth = 580 info->max_event_port_dequeue_depth; 581 dev_conf->nb_event_port_enqueue_depth = 582 info->max_event_port_enqueue_depth; 583 dev_conf->nb_event_port_enqueue_depth = 584 info->max_event_port_enqueue_depth; 585 dev_conf->nb_events_limit = 586 info->max_num_events; 587 } 588 589 static int 590 configure_eventdev(void) 591 { 592 struct rte_event_queue_conf queue_conf; 593 struct rte_event_dev_config devconf; 594 struct rte_event_dev_info info; 595 uint32_t queue_count; 596 uint32_t port_count; 597 int ret; 598 uint8_t qid; 599 600 if (!rte_event_dev_count()) { 601 /* If there is no hardware eventdev, or no software vdev was 602 * specified on the command line, create an instance of 603 * event_sw. 604 */ 605 LOG_DBG("Failed to find a valid event device... " 606 "testing with event_sw device\n"); 607 TEST_ASSERT_SUCCESS(rte_vdev_init("event_sw0", NULL), 608 "Error creating eventdev"); 609 evdev = rte_event_dev_get_dev_id("event_sw0"); 610 } 611 612 ret = rte_event_dev_info_get(evdev, &info); 613 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info\n"); 614 615 evdev_set_conf_values(&devconf, &info); 616 617 ret = rte_event_dev_configure(evdev, &devconf); 618 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev\n"); 619 620 /* Set up event queue */ 621 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_QUEUE_COUNT, 622 &queue_count); 623 TEST_ASSERT_SUCCESS(ret, "Queue count get failed\n"); 624 TEST_ASSERT_EQUAL(queue_count, 2, "Unexpected queue count\n"); 625 626 qid = TEST_APP_EV_QUEUE_ID; 627 ret = rte_event_queue_setup(evdev, qid, NULL); 628 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d\n", qid); 629 630 queue_conf.nb_atomic_flows = info.max_event_queue_flows; 631 queue_conf.nb_atomic_order_sequences = 32; 632 queue_conf.schedule_type = RTE_SCHED_TYPE_ATOMIC; 633 queue_conf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST; 634 queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK; 635 636 qid = TEST_CRYPTO_EV_QUEUE_ID; 637 ret = rte_event_queue_setup(evdev, qid, &queue_conf); 638 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%u\n", qid); 639 640 /* Set up event port */ 641 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_PORT_COUNT, 642 &port_count); 643 TEST_ASSERT_SUCCESS(ret, "Port count get failed\n"); 644 TEST_ASSERT_EQUAL(port_count, 1, "Unexpected port count\n"); 645 646 ret = rte_event_port_setup(evdev, TEST_APP_PORT_ID, NULL); 647 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d\n", 648 TEST_APP_PORT_ID); 649 650 qid = TEST_APP_EV_QUEUE_ID; 651 ret = rte_event_port_link(evdev, TEST_APP_PORT_ID, &qid, NULL, 1); 652 TEST_ASSERT(ret >= 0, "Failed to link queue port=%d\n", 653 TEST_APP_PORT_ID); 654 655 return TEST_SUCCESS; 656 } 657 658 static void 659 test_crypto_adapter_free(void) 660 { 661 rte_event_crypto_adapter_free(TEST_ADAPTER_ID); 662 } 663 664 static int 665 test_crypto_adapter_create(void) 666 { 667 struct rte_event_port_conf conf = { 668 .dequeue_depth = 8, 669 .enqueue_depth = 8, 670 .new_event_threshold = 1200, 671 }; 672 int ret; 673 674 /* Create adapter with default port creation callback */ 675 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 676 TEST_CDEV_ID, 677 &conf, 0); 678 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 679 680 return TEST_SUCCESS; 681 } 682 683 static int 684 test_crypto_adapter_qp_add_del(void) 685 { 686 uint32_t cap; 687 int ret; 688 689 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, evdev, &cap); 690 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 691 692 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 693 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 694 TEST_CDEV_ID, TEST_CDEV_QP_ID, &response_info); 695 } else 696 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 697 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 698 699 TEST_ASSERT_SUCCESS(ret, "Failed to create add queue pair\n"); 700 701 ret = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 702 TEST_CDEV_ID, TEST_CDEV_QP_ID); 703 TEST_ASSERT_SUCCESS(ret, "Failed to delete add queue pair\n"); 704 705 return TEST_SUCCESS; 706 } 707 708 static int 709 configure_event_crypto_adapter(enum rte_event_crypto_adapter_mode mode) 710 { 711 struct rte_event_port_conf conf = { 712 .dequeue_depth = 8, 713 .enqueue_depth = 8, 714 .new_event_threshold = 1200, 715 }; 716 717 uint32_t cap; 718 int ret; 719 720 /* Create adapter with default port creation callback */ 721 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 722 TEST_CDEV_ID, 723 &conf, mode); 724 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 725 726 ret = rte_event_crypto_adapter_caps_get(TEST_ADAPTER_ID, evdev, &cap); 727 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 728 729 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 730 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 731 TEST_CDEV_ID, TEST_CDEV_QP_ID, &response_info); 732 } else 733 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 734 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 735 736 TEST_ASSERT_SUCCESS(ret, "Failed to add queue pair\n"); 737 738 ret = rte_event_crypto_adapter_event_port_get(TEST_ADAPTER_ID, 739 ¶ms.crypto_event_port_id); 740 TEST_ASSERT_SUCCESS(ret, "Failed to get event port\n"); 741 742 return TEST_SUCCESS; 743 } 744 745 static void 746 test_crypto_adapter_stop(void) 747 { 748 uint32_t evdev_service_id, adapter_service_id; 749 750 /* retrieve service ids & stop services */ 751 if (rte_event_crypto_adapter_service_id_get(TEST_ADAPTER_ID, 752 &adapter_service_id) == 0) { 753 rte_service_runstate_set(adapter_service_id, 0); 754 rte_service_lcore_stop(slcore_id); 755 rte_service_lcore_del(slcore_id); 756 rte_event_crypto_adapter_stop(TEST_ADAPTER_ID); 757 } 758 759 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 760 rte_service_runstate_set(evdev_service_id, 0); 761 rte_service_lcore_stop(slcore_id); 762 rte_service_lcore_del(slcore_id); 763 rte_event_dev_stop(evdev); 764 } 765 } 766 767 static int 768 test_crypto_adapter_conf(enum rte_event_crypto_adapter_mode mode) 769 { 770 uint32_t evdev_service_id; 771 uint8_t qid; 772 int ret; 773 774 if (!crypto_adapter_setup_done) { 775 ret = configure_event_crypto_adapter(mode); 776 if (!ret) { 777 qid = TEST_CRYPTO_EV_QUEUE_ID; 778 ret = rte_event_port_link(evdev, 779 params.crypto_event_port_id, &qid, NULL, 1); 780 TEST_ASSERT(ret >= 0, "Failed to link queue %d " 781 "port=%u\n", qid, 782 params.crypto_event_port_id); 783 } 784 crypto_adapter_setup_done = 1; 785 } 786 787 /* retrieve service ids */ 788 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 789 /* add a service core and start it */ 790 TEST_ASSERT_SUCCESS(rte_service_lcore_add(slcore_id), 791 "Failed to add service core"); 792 TEST_ASSERT_SUCCESS(rte_service_lcore_start(slcore_id), 793 "Failed to start service core"); 794 795 /* map services to it */ 796 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(evdev_service_id, 797 slcore_id, 1), "Failed to map evdev service"); 798 799 /* set services to running */ 800 TEST_ASSERT_SUCCESS(rte_service_runstate_set(evdev_service_id, 801 1), "Failed to start evdev service"); 802 } 803 804 /* start the eventdev */ 805 TEST_ASSERT_SUCCESS(rte_event_dev_start(evdev), 806 "Failed to start event device"); 807 808 return TEST_SUCCESS; 809 } 810 811 static int 812 test_crypto_adapter_conf_op_forward_mode(void) 813 { 814 enum rte_event_crypto_adapter_mode mode; 815 816 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD; 817 test_crypto_adapter_conf(mode); 818 819 return TEST_SUCCESS; 820 } 821 822 static int 823 test_crypto_adapter_conf_op_new_mode(void) 824 { 825 enum rte_event_crypto_adapter_mode mode; 826 827 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_NEW; 828 test_crypto_adapter_conf(mode); 829 return TEST_SUCCESS; 830 } 831 832 833 static int 834 testsuite_setup(void) 835 { 836 int ret; 837 838 slcore_id = rte_get_next_lcore(-1, 1, 0); 839 TEST_ASSERT_NOT_EQUAL(slcore_id, RTE_MAX_LCORE, "At least 2 lcores " 840 "are required to run this autotest\n"); 841 842 /* Setup and start event device. */ 843 ret = configure_eventdev(); 844 TEST_ASSERT_SUCCESS(ret, "Failed to setup eventdev\n"); 845 846 /* Setup and start crypto device. */ 847 ret = configure_cryptodev(); 848 TEST_ASSERT_SUCCESS(ret, "cryptodev initialization failed\n"); 849 850 return TEST_SUCCESS; 851 } 852 853 static void 854 crypto_teardown(void) 855 { 856 /* Free mbuf mempool */ 857 if (params.mbuf_pool != NULL) { 858 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_MBUFPOOL count %u\n", 859 rte_mempool_avail_count(params.mbuf_pool)); 860 rte_mempool_free(params.mbuf_pool); 861 params.mbuf_pool = NULL; 862 } 863 864 /* Free session mempool */ 865 if (params.session_mpool != NULL) { 866 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_SESSION_MP count %u\n", 867 rte_mempool_avail_count(params.session_mpool)); 868 rte_mempool_free(params.session_mpool); 869 params.session_mpool = NULL; 870 } 871 if (params.session_priv_mpool != NULL) { 872 rte_mempool_free(params.session_priv_mpool); 873 params.session_priv_mpool = NULL; 874 } 875 876 /* Free ops mempool */ 877 if (params.op_mpool != NULL) { 878 RTE_LOG(DEBUG, USER1, "EVENT_CRYPTO_SYM_OP_POOL count %u\n", 879 rte_mempool_avail_count(params.op_mpool)); 880 rte_mempool_free(params.op_mpool); 881 params.op_mpool = NULL; 882 } 883 } 884 885 static void 886 eventdev_teardown(void) 887 { 888 rte_event_dev_stop(evdev); 889 } 890 891 static void 892 testsuite_teardown(void) 893 { 894 crypto_teardown(); 895 eventdev_teardown(); 896 } 897 898 static struct unit_test_suite functional_testsuite = { 899 .suite_name = "Event crypto adapter test suite", 900 .setup = testsuite_setup, 901 .teardown = testsuite_teardown, 902 .unit_test_cases = { 903 904 TEST_CASE_ST(NULL, test_crypto_adapter_free, 905 test_crypto_adapter_create), 906 907 TEST_CASE_ST(test_crypto_adapter_create, 908 test_crypto_adapter_free, 909 test_crypto_adapter_qp_add_del), 910 911 TEST_CASE_ST(test_crypto_adapter_create, 912 test_crypto_adapter_free, 913 test_crypto_adapter_stats), 914 915 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 916 test_crypto_adapter_stop, 917 test_session_with_op_forward_mode), 918 919 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 920 test_crypto_adapter_stop, 921 test_sessionless_with_op_forward_mode), 922 923 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 924 test_crypto_adapter_stop, 925 test_session_with_op_new_mode), 926 927 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 928 test_crypto_adapter_stop, 929 test_sessionless_with_op_new_mode), 930 931 TEST_CASES_END() /**< NULL terminate unit test array */ 932 } 933 }; 934 935 static int 936 test_event_crypto_adapter(void) 937 { 938 return unit_test_suite_runner(&functional_testsuite); 939 } 940 941 REGISTER_TEST_COMMAND(event_crypto_adapter_autotest, 942 test_event_crypto_adapter); 943