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