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