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