1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "test.h" 7 #include <string.h> 8 #include <rte_common.h> 9 #include <rte_malloc.h> 10 #include <rte_mempool.h> 11 #include <rte_mbuf.h> 12 #include <rte_cryptodev.h> 13 14 #ifdef RTE_EXEC_ENV_WINDOWS 15 static int 16 test_event_crypto_adapter(void) 17 { 18 printf("event_crypto_adapter not supported on Windows, skipping test\n"); 19 return TEST_SKIPPED; 20 } 21 22 #else 23 24 #include <rte_eventdev.h> 25 #include <rte_bus_vdev.h> 26 #include <rte_service.h> 27 #include <rte_event_crypto_adapter.h> 28 29 #define PKT_TRACE 0 30 #define NUM 1 31 #define DEFAULT_NUM_XFORMS (2) 32 #define NUM_MBUFS (8191) 33 #define MBUF_CACHE_SIZE (256) 34 #define MAXIMUM_IV_LENGTH (16) 35 #define DEFAULT_NUM_OPS_INFLIGHT 1024 36 #define MAX_NB_SESSIONS 4 37 #define TEST_APP_PORT_ID 0 38 #define TEST_APP_EV_QUEUE_ID 0 39 #define TEST_APP_EV_PRIORITY 0 40 #define TEST_APP_EV_FLOWID 0xAABB 41 #define TEST_CRYPTO_EV_QUEUE_ID 1 42 #define TEST_ADAPTER_ID 0 43 #define TEST_CDEV_ID 0 44 #define TEST_CDEV_QP_ID 0 45 #define PACKET_LENGTH 64 46 #define NB_TEST_PORTS 1 47 #define NB_TEST_QUEUES 2 48 #define NUM_CORES 1 49 #define CRYPTODEV_NAME_NULL_PMD crypto_null 50 51 #define MBUF_SIZE (sizeof(struct rte_mbuf) + \ 52 RTE_PKTMBUF_HEADROOM + PACKET_LENGTH) 53 #define IV_OFFSET (sizeof(struct rte_crypto_op) + \ 54 sizeof(struct rte_crypto_sym_op) + \ 55 DEFAULT_NUM_XFORMS * \ 56 sizeof(struct rte_crypto_sym_xform)) 57 58 /* Handle log statements in same manner as test macros */ 59 #define LOG_DBG(...) RTE_LOG(DEBUG, EAL, __VA_ARGS__) 60 61 static const uint8_t text_64B[] = { 62 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50, 63 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0, 64 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36, 65 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e, 66 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c, 67 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e, 68 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6, 69 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c 70 }; 71 #define DATA_SIZE 512 72 struct modex_test_data { 73 enum rte_crypto_asym_xform_type xform_type; 74 struct { 75 uint8_t data[DATA_SIZE]; 76 uint16_t len; 77 } base; 78 struct { 79 uint8_t data[DATA_SIZE]; 80 uint16_t len; 81 } exponent; 82 struct { 83 uint8_t data[DATA_SIZE]; 84 uint16_t len; 85 } modulus; 86 struct { 87 uint8_t data[DATA_SIZE]; 88 uint16_t len; 89 } reminder; 90 uint16_t result_len; 91 }; 92 93 static struct 94 modex_test_data modex_test_case = { 95 .xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX, 96 .base = { 97 .data = { 98 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 99 0xAE, 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 100 0xA8, 0xEB, 0x7E, 0x78, 0xA0, 0x50 101 }, 102 .len = 20, 103 }, 104 .exponent = { 105 .data = { 106 0x01, 0x00, 0x01 107 }, 108 .len = 3, 109 }, 110 .reminder = { 111 .data = { 112 0x2C, 0x60, 0x75, 0x45, 0x98, 0x9D, 0xE0, 0x72, 113 0xA0, 0x9D, 0x3A, 0x9E, 0x03, 0x38, 0x73, 0x3C, 114 0x31, 0x83, 0x04, 0xFE, 0x75, 0x43, 0xE6, 0x17, 115 0x5C, 0x01, 0x29, 0x51, 0x69, 0x33, 0x62, 0x2D, 116 0x78, 0xBE, 0xAE, 0xC4, 0xBC, 0xDE, 0x7E, 0x2C, 117 0x77, 0x84, 0xF2, 0xC5, 0x14, 0xB5, 0x2F, 0xF7, 118 0xC5, 0x94, 0xEF, 0x86, 0x75, 0x75, 0xB5, 0x11, 119 0xE5, 0x0E, 0x0A, 0x29, 0x76, 0xE2, 0xEA, 0x32, 120 0x0E, 0x43, 0x77, 0x7E, 0x2C, 0x27, 0xAC, 0x3B, 121 0x86, 0xA5, 0xDB, 0xC9, 0x48, 0x40, 0xE8, 0x99, 122 0x9A, 0x0A, 0x3D, 0xD6, 0x74, 0xFA, 0x2E, 0x2E, 123 0x5B, 0xAF, 0x8C, 0x99, 0x44, 0x2A, 0x67, 0x38, 124 0x27, 0x41, 0x59, 0x9D, 0xB8, 0x51, 0xC9, 0xF7, 125 0x43, 0x61, 0x31, 0x6E, 0xF1, 0x25, 0x38, 0x7F, 126 0xAE, 0xC6, 0xD0, 0xBB, 0x29, 0x76, 0x3F, 0x46, 127 0x2E, 0x1B, 0xE4, 0x67, 0x71, 0xE3, 0x87, 0x5A 128 }, 129 .len = 128, 130 }, 131 .modulus = { 132 .data = { 133 0xb3, 0xa1, 0xaf, 0xb7, 0x13, 0x08, 0x00, 0x0a, 134 0x35, 0xdc, 0x2b, 0x20, 0x8d, 0xa1, 0xb5, 0xce, 135 0x47, 0x8a, 0xc3, 0x80, 0xf4, 0x7d, 0x4a, 0xa2, 136 0x62, 0xfd, 0x61, 0x7f, 0xb5, 0xa8, 0xde, 0x0a, 137 0x17, 0x97, 0xa0, 0xbf, 0xdf, 0x56, 0x5a, 0x3d, 138 0x51, 0x56, 0x4f, 0x70, 0x70, 0x3f, 0x63, 0x6a, 139 0x44, 0x5b, 0xad, 0x84, 0x0d, 0x3f, 0x27, 0x6e, 140 0x3b, 0x34, 0x91, 0x60, 0x14, 0xb9, 0xaa, 0x72, 141 0xfd, 0xa3, 0x64, 0xd2, 0x03, 0xa7, 0x53, 0x87, 142 0x9e, 0x88, 0x0b, 0xc1, 0x14, 0x93, 0x1a, 0x62, 143 0xff, 0xb1, 0x5d, 0x74, 0xcd, 0x59, 0x63, 0x18, 144 0x11, 0x3d, 0x4f, 0xba, 0x75, 0xd4, 0x33, 0x4e, 145 0x23, 0x6b, 0x7b, 0x57, 0x44, 0xe1, 0xd3, 0x03, 146 0x13, 0xa6, 0xf0, 0x8b, 0x60, 0xb0, 0x9e, 0xee, 147 0x75, 0x08, 0x9d, 0x71, 0x63, 0x13, 0xcb, 0xa6, 148 0x81, 0x92, 0x14, 0x03, 0x22, 0x2d, 0xde, 0x55 149 }, 150 .len = 128, 151 }, 152 .result_len = 128, 153 }; 154 155 struct event_crypto_adapter_test_params { 156 struct rte_mempool *mbuf_pool; 157 struct rte_mempool *op_mpool; 158 struct rte_mempool *asym_op_mpool; 159 struct rte_mempool *session_mpool; 160 struct rte_mempool *asym_sess_mpool; 161 struct rte_cryptodev_config *config; 162 uint8_t crypto_event_port_id; 163 uint8_t internal_port_op_fwd; 164 }; 165 166 struct rte_event response_info = { 167 .queue_id = TEST_APP_EV_QUEUE_ID, 168 .sched_type = RTE_SCHED_TYPE_ATOMIC, 169 .flow_id = TEST_APP_EV_FLOWID, 170 .priority = TEST_APP_EV_PRIORITY 171 }; 172 173 struct rte_event_crypto_request request_info = { 174 .cdev_id = TEST_CDEV_ID, 175 .queue_pair_id = TEST_CDEV_QP_ID 176 }; 177 178 static struct event_crypto_adapter_test_params params; 179 static uint8_t crypto_adapter_setup_done; 180 static uint32_t slcore_id; 181 static int evdev; 182 183 static struct rte_mbuf * 184 alloc_fill_mbuf(struct rte_mempool *mpool, const uint8_t *data, 185 size_t len, uint8_t blocksize) 186 { 187 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); 188 size_t t_len = len - (blocksize ? (len % blocksize) : 0); 189 190 if (m) { 191 char *dst = rte_pktmbuf_append(m, t_len); 192 193 if (!dst) { 194 rte_pktmbuf_free(m); 195 return NULL; 196 } 197 198 rte_memcpy(dst, (const void *)data, t_len); 199 } 200 return m; 201 } 202 203 static int 204 send_recv_ev(struct rte_event *ev) 205 { 206 struct rte_crypto_op *op; 207 struct rte_event recv_ev; 208 int ret; 209 210 if (params.internal_port_op_fwd) 211 ret = rte_event_crypto_adapter_enqueue(evdev, TEST_APP_PORT_ID, 212 ev, NUM); 213 else 214 ret = rte_event_enqueue_burst(evdev, TEST_APP_PORT_ID, ev, NUM); 215 TEST_ASSERT_EQUAL(ret, NUM, "Failed to send event to crypto adapter\n"); 216 217 while (rte_event_dequeue_burst(evdev, 218 TEST_APP_PORT_ID, &recv_ev, NUM, 0) == 0) 219 rte_pause(); 220 221 op = recv_ev.event_ptr; 222 if (op->type == RTE_CRYPTO_OP_TYPE_SYMMETRIC) { 223 #if PKT_TRACE 224 struct rte_mbuf *m = op->sym->m_src; 225 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 226 #endif 227 rte_pktmbuf_free(op->sym->m_src); 228 } else { 229 uint8_t *data_expected = NULL, *data_received = NULL; 230 uint32_t data_size; 231 232 data_expected = modex_test_case.reminder.data; 233 data_received = op->asym->modex.result.data; 234 data_size = op->asym->modex.result.length; 235 ret = memcmp(data_expected, data_received, data_size); 236 TEST_ASSERT_EQUAL(ret, 0, 237 "Data mismatch for asym crypto adapter\n"); 238 rte_free(op->asym->modex.result.data); 239 } 240 rte_crypto_op_free(op); 241 242 return TEST_SUCCESS; 243 } 244 245 static int 246 test_crypto_adapter_stats(void) 247 { 248 struct rte_event_crypto_adapter_stats stats; 249 250 rte_event_crypto_adapter_stats_get(TEST_ADAPTER_ID, &stats); 251 printf(" +------------------------------------------------------+\n"); 252 printf(" + Crypto adapter stats for instance %u:\n", TEST_ADAPTER_ID); 253 printf(" + Event port poll count %" PRIx64 "\n", 254 stats.event_poll_count); 255 printf(" + Event dequeue count %" PRIx64 "\n", 256 stats.event_deq_count); 257 printf(" + Cryptodev enqueue count %" PRIx64 "\n", 258 stats.crypto_enq_count); 259 printf(" + Cryptodev enqueue failed count %" PRIx64 "\n", 260 stats.crypto_enq_fail); 261 printf(" + Cryptodev dequeue count %" PRIx64 "\n", 262 stats.crypto_deq_count); 263 printf(" + Event enqueue count %" PRIx64 "\n", 264 stats.event_enq_count); 265 printf(" + Event enqueue retry count %" PRIx64 "\n", 266 stats.event_enq_retry_count); 267 printf(" + Event enqueue fail count %" PRIx64 "\n", 268 stats.event_enq_fail_count); 269 printf(" +------------------------------------------------------+\n"); 270 271 rte_event_crypto_adapter_stats_reset(TEST_ADAPTER_ID); 272 return TEST_SUCCESS; 273 } 274 275 static int 276 test_crypto_adapter_params(void) 277 { 278 int err, rc; 279 struct rte_event_crypto_adapter_runtime_params in_params; 280 struct rte_event_crypto_adapter_runtime_params out_params; 281 uint32_t cap; 282 struct rte_event_crypto_adapter_queue_conf queue_conf = { 283 .ev = response_info, 284 }; 285 286 err = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 287 if (err == -ENOTSUP) 288 return TEST_SKIPPED; 289 290 TEST_ASSERT_SUCCESS(err, "Failed to get adapter capabilities\n"); 291 292 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 293 err = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 294 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 295 } else 296 err = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 297 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 298 299 TEST_ASSERT_SUCCESS(err, "Failed to add queue pair\n"); 300 301 err = rte_event_crypto_adapter_runtime_params_init(&in_params); 302 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 303 err = rte_event_crypto_adapter_runtime_params_init(&out_params); 304 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 305 306 /* Case 1: Get the default value of mbufs processed by adapter */ 307 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 308 &out_params); 309 if (err == -ENOTSUP) { 310 rc = TEST_SKIPPED; 311 goto queue_pair_del; 312 } 313 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 314 315 /* Case 2: Set max_nb = 32 (=BATCH_SEIZE) */ 316 in_params.max_nb = 32; 317 318 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 319 &in_params); 320 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 321 322 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 323 &out_params); 324 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 325 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 326 in_params.max_nb, out_params.max_nb); 327 328 /* Case 3: Set max_nb = 192 */ 329 in_params.max_nb = 192; 330 331 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 332 &in_params); 333 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 334 335 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 336 &out_params); 337 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 338 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 339 in_params.max_nb, out_params.max_nb); 340 341 /* Case 4: Set max_nb = 256 */ 342 in_params.max_nb = 256; 343 344 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 345 &in_params); 346 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 347 348 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 349 &out_params); 350 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 351 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 352 in_params.max_nb, out_params.max_nb); 353 354 /* Case 5: Set max_nb = 30(<BATCH_SIZE) */ 355 in_params.max_nb = 30; 356 357 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 358 &in_params); 359 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 360 361 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 362 &out_params); 363 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 364 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 365 in_params.max_nb, out_params.max_nb); 366 367 /* Case 6: Set max_nb = 512 */ 368 in_params.max_nb = 512; 369 370 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 371 &in_params); 372 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 373 374 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 375 &out_params); 376 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 377 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 378 in_params.max_nb, out_params.max_nb); 379 380 rc = TEST_SUCCESS; 381 queue_pair_del: 382 err = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 383 TEST_CDEV_ID, TEST_CDEV_QP_ID); 384 TEST_ASSERT_SUCCESS(err, "Failed to delete add queue pair\n"); 385 386 return rc; 387 } 388 389 static int 390 test_op_forward_mode(uint8_t session_less) 391 { 392 struct rte_crypto_sym_xform cipher_xform; 393 union rte_event_crypto_metadata m_data; 394 struct rte_crypto_sym_op *sym_op; 395 struct rte_crypto_op *op; 396 struct rte_mbuf *m; 397 struct rte_event ev; 398 uint32_t cap; 399 void *sess; 400 int ret; 401 402 memset(&m_data, 0, sizeof(m_data)); 403 404 m = alloc_fill_mbuf(params.mbuf_pool, text_64B, PACKET_LENGTH, 0); 405 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf!\n"); 406 #if PKT_TRACE 407 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 408 #endif 409 /* Setup Cipher Parameters */ 410 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 411 cipher_xform.next = NULL; 412 cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 413 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 414 415 op = rte_crypto_op_alloc(params.op_mpool, 416 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 417 TEST_ASSERT_NOT_NULL(op, 418 "Failed to allocate symmetric crypto operation struct\n"); 419 420 sym_op = op->sym; 421 422 if (!session_less) { 423 sess = rte_cryptodev_sym_session_create(TEST_CDEV_ID, 424 &cipher_xform, params.session_mpool); 425 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 426 427 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 428 &cap); 429 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 430 431 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 432 /* Fill in private user data information */ 433 m_data.request_info.cdev_id = request_info.cdev_id; 434 m_data.request_info.queue_pair_id = 435 request_info.queue_pair_id; 436 m_data.response_info.event = response_info.event; 437 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 438 sess, RTE_CRYPTO_OP_TYPE_SYMMETRIC, 439 RTE_CRYPTO_OP_WITH_SESSION, 440 &m_data, sizeof(m_data)); 441 } 442 443 rte_crypto_op_attach_sym_session(op, sess); 444 } else { 445 struct rte_crypto_sym_xform *first_xform; 446 447 rte_crypto_op_sym_xforms_alloc(op, NUM); 448 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 449 first_xform = &cipher_xform; 450 sym_op->xform = first_xform; 451 uint32_t len = IV_OFFSET + MAXIMUM_IV_LENGTH; 452 op->private_data_offset = len; 453 /* Fill in private data information */ 454 m_data.request_info.cdev_id = request_info.cdev_id; 455 m_data.request_info.queue_pair_id = request_info.queue_pair_id; 456 m_data.response_info.event = response_info.event; 457 rte_memcpy((uint8_t *)op + len, &m_data, sizeof(m_data)); 458 } 459 460 sym_op->m_src = m; 461 sym_op->cipher.data.offset = 0; 462 sym_op->cipher.data.length = PACKET_LENGTH; 463 464 /* Fill in event info and update event_ptr with rte_crypto_op */ 465 memset(&ev, 0, sizeof(ev)); 466 ev.queue_id = TEST_CRYPTO_EV_QUEUE_ID; 467 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 468 ev.flow_id = 0xAABB; 469 ev.event_ptr = op; 470 471 ret = send_recv_ev(&ev); 472 TEST_ASSERT_SUCCESS(ret, "Failed to send/receive event to " 473 "crypto adapter\n"); 474 475 test_crypto_adapter_stats(); 476 477 return TEST_SUCCESS; 478 } 479 480 static int 481 map_adapter_service_core(void) 482 { 483 uint32_t adapter_service_id; 484 int ret; 485 486 if (rte_event_crypto_adapter_service_id_get(TEST_ADAPTER_ID, 487 &adapter_service_id) == 0) { 488 uint32_t core_list[NUM_CORES]; 489 490 ret = rte_service_lcore_list(core_list, NUM_CORES); 491 TEST_ASSERT(ret >= 0, "Failed to get service core list!"); 492 493 if (core_list[0] != slcore_id) { 494 TEST_ASSERT_SUCCESS(rte_service_lcore_add(slcore_id), 495 "Failed to add service core"); 496 TEST_ASSERT_SUCCESS(rte_service_lcore_start(slcore_id), 497 "Failed to start service core"); 498 } 499 500 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set( 501 adapter_service_id, slcore_id, 1), 502 "Failed to map adapter service"); 503 } 504 505 return TEST_SUCCESS; 506 } 507 508 static int 509 test_sessionless_with_op_forward_mode(void) 510 { 511 uint32_t cap; 512 int ret; 513 514 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 515 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 516 517 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 518 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 519 map_adapter_service_core(); 520 else { 521 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 522 return TEST_SKIPPED; 523 } 524 525 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 526 "Failed to start event crypto adapter"); 527 528 ret = test_op_forward_mode(1); 529 TEST_ASSERT_SUCCESS(ret, "Sessionless - FORWARD mode test failed\n"); 530 return TEST_SUCCESS; 531 } 532 533 static int 534 test_session_with_op_forward_mode(void) 535 { 536 uint32_t cap; 537 int ret; 538 539 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 540 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 541 542 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 543 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 544 map_adapter_service_core(); 545 else { 546 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 547 return TEST_SKIPPED; 548 } 549 550 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID 551 ), "Failed to start event crypto adapter"); 552 553 ret = test_op_forward_mode(0); 554 TEST_ASSERT_SUCCESS(ret, "Session based - FORWARD mode test failed\n"); 555 return TEST_SUCCESS; 556 } 557 558 static int 559 test_asym_op_forward_mode(uint8_t session_less) 560 { 561 const struct rte_cryptodev_asymmetric_xform_capability *capability; 562 struct rte_cryptodev_asym_capability_idx cap_idx; 563 struct rte_crypto_asym_xform xform_tc; 564 union rte_event_crypto_metadata m_data; 565 struct rte_cryptodev_info dev_info; 566 struct rte_crypto_asym_op *asym_op; 567 struct rte_crypto_op *op; 568 uint8_t input[4096] = {0}; 569 uint8_t *result = NULL; 570 struct rte_event ev; 571 void *sess = NULL; 572 uint32_t cap; 573 int ret; 574 575 memset(&m_data, 0, sizeof(m_data)); 576 577 rte_cryptodev_info_get(TEST_CDEV_ID, &dev_info); 578 if (session_less && !(dev_info.feature_flags & 579 RTE_CRYPTODEV_FF_ASYM_SESSIONLESS)) { 580 RTE_LOG(INFO, USER1, 581 "Device doesn't support Asym sessionless ops. Test Skipped\n"); 582 return TEST_SKIPPED; 583 } 584 /* Setup Cipher Parameters */ 585 xform_tc.next = NULL; 586 xform_tc.xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX; 587 cap_idx.type = xform_tc.xform_type; 588 capability = rte_cryptodev_asym_capability_get(TEST_CDEV_ID, &cap_idx); 589 590 if (capability == NULL) { 591 RTE_LOG(INFO, USER1, 592 "Device doesn't support MODEX. Test Skipped\n"); 593 return TEST_SKIPPED; 594 } 595 596 op = rte_crypto_op_alloc(params.asym_op_mpool, 597 RTE_CRYPTO_OP_TYPE_ASYMMETRIC); 598 TEST_ASSERT_NOT_NULL(op, 599 "Failed to allocate asymmetric crypto operation struct\n"); 600 601 asym_op = op->asym; 602 603 result = rte_zmalloc(NULL, modex_test_case.result_len, 0); 604 xform_tc.modex.modulus.data = modex_test_case.modulus.data; 605 xform_tc.modex.modulus.length = modex_test_case.modulus.len; 606 xform_tc.modex.exponent.data = modex_test_case.exponent.data; 607 xform_tc.modex.exponent.length = modex_test_case.exponent.len; 608 memcpy(input, modex_test_case.base.data, 609 modex_test_case.base.len); 610 asym_op->modex.base.data = input; 611 asym_op->modex.base.length = modex_test_case.base.len; 612 asym_op->modex.result.data = result; 613 asym_op->modex.result.length = modex_test_case.result_len; 614 if (rte_cryptodev_asym_xform_capability_check_modlen(capability, 615 xform_tc.modex.modulus.length)) { 616 RTE_LOG(INFO, USER1, 617 "line %u FAILED: %s", __LINE__, 618 "Invalid MODULUS length specified"); 619 return TEST_FAILED; 620 } 621 622 if (!session_less) { 623 /* Create Crypto session*/ 624 ret = rte_cryptodev_asym_session_create(TEST_CDEV_ID, 625 &xform_tc, params.asym_sess_mpool, &sess); 626 TEST_ASSERT_SUCCESS(ret, "Failed to init session\n"); 627 628 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 629 &cap); 630 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 631 632 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 633 /* Fill in private user data information */ 634 m_data.request_info.cdev_id = request_info.cdev_id; 635 m_data.request_info.queue_pair_id = 636 request_info.queue_pair_id; 637 m_data.response_info.event = response_info.event; 638 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 639 sess, RTE_CRYPTO_OP_TYPE_ASYMMETRIC, 640 RTE_CRYPTO_OP_WITH_SESSION, 641 &m_data, sizeof(m_data)); 642 } 643 644 rte_crypto_op_attach_asym_session(op, sess); 645 } else { 646 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 647 asym_op->xform = &xform_tc; 648 op->private_data_offset = (sizeof(struct rte_crypto_op) + 649 sizeof(struct rte_crypto_asym_op) + 650 DEFAULT_NUM_XFORMS * 651 sizeof(struct rte_crypto_asym_xform)); 652 /* Fill in private data information */ 653 m_data.request_info.cdev_id = request_info.cdev_id; 654 m_data.request_info.queue_pair_id = request_info.queue_pair_id; 655 m_data.response_info.event = response_info.event; 656 rte_memcpy((uint8_t *)op + op->private_data_offset, 657 &m_data, sizeof(m_data)); 658 } 659 /* Fill in event info and update event_ptr with rte_crypto_op */ 660 memset(&ev, 0, sizeof(ev)); 661 ev.queue_id = TEST_CRYPTO_EV_QUEUE_ID; 662 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 663 ev.flow_id = 0xAABB; 664 ev.event_ptr = op; 665 666 ret = send_recv_ev(&ev); 667 TEST_ASSERT_SUCCESS(ret, "Failed to send/receive event to " 668 "crypto adapter\n"); 669 670 test_crypto_adapter_stats(); 671 672 return TEST_SUCCESS; 673 } 674 675 676 static int 677 test_asym_sessionless_with_op_forward_mode(void) 678 { 679 uint32_t cap; 680 int ret; 681 682 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 683 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 684 685 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 686 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 687 map_adapter_service_core(); 688 else { 689 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 690 return TEST_SKIPPED; 691 } 692 693 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 694 "Failed to start event crypto adapter"); 695 696 return test_asym_op_forward_mode(1); 697 } 698 699 static int 700 test_asym_session_with_op_forward_mode(void) 701 { 702 uint32_t cap; 703 int ret; 704 705 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 706 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 707 708 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 709 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 710 map_adapter_service_core(); 711 else { 712 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 713 return TEST_SKIPPED; 714 } 715 716 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID 717 ), "Failed to start event crypto adapter"); 718 719 return test_asym_op_forward_mode(0); 720 } 721 722 static int 723 send_op_recv_ev(struct rte_crypto_op *op) 724 { 725 struct rte_crypto_op *recv_op; 726 struct rte_event ev; 727 int ret; 728 729 ret = rte_cryptodev_enqueue_burst(TEST_CDEV_ID, TEST_CDEV_QP_ID, 730 &op, NUM); 731 TEST_ASSERT_EQUAL(ret, NUM, "Failed to enqueue to cryptodev\n"); 732 memset(&ev, 0, sizeof(ev)); 733 734 while (rte_event_dequeue_burst(evdev, 735 TEST_APP_PORT_ID, &ev, NUM, 0) == 0) 736 rte_pause(); 737 738 recv_op = ev.event_ptr; 739 if (recv_op->type == RTE_CRYPTO_OP_TYPE_SYMMETRIC) { 740 #if PKT_TRACE 741 struct rte_mbuf *m = recv_op->sym->m_src; 742 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 743 #endif 744 rte_pktmbuf_free(recv_op->sym->m_src); 745 } else { 746 uint8_t *data_expected = NULL, *data_received = NULL; 747 uint32_t data_size; 748 749 data_expected = modex_test_case.reminder.data; 750 data_received = op->asym->modex.result.data; 751 data_size = op->asym->modex.result.length; 752 ret = memcmp(data_expected, data_received, data_size); 753 TEST_ASSERT_EQUAL(ret, 0, 754 "Data mismatch for asym crypto adapter\n"); 755 rte_free(op->asym->modex.result.data); 756 } 757 rte_crypto_op_free(recv_op); 758 759 return TEST_SUCCESS; 760 } 761 762 static int 763 test_op_new_mode(uint8_t session_less) 764 { 765 struct rte_crypto_sym_xform cipher_xform; 766 union rte_event_crypto_metadata m_data; 767 struct rte_crypto_sym_op *sym_op; 768 struct rte_crypto_op *op; 769 struct rte_mbuf *m; 770 uint32_t cap; 771 void *sess; 772 int ret; 773 774 memset(&m_data, 0, sizeof(m_data)); 775 776 m = alloc_fill_mbuf(params.mbuf_pool, text_64B, PACKET_LENGTH, 0); 777 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf!\n"); 778 #if PKT_TRACE 779 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 780 #endif 781 /* Setup Cipher Parameters */ 782 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 783 cipher_xform.next = NULL; 784 cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 785 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 786 787 op = rte_crypto_op_alloc(params.op_mpool, 788 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 789 TEST_ASSERT_NOT_NULL(op, "Failed to allocate crypto_op!\n"); 790 791 sym_op = op->sym; 792 793 if (!session_less) { 794 sess = rte_cryptodev_sym_session_create(TEST_CDEV_ID, 795 &cipher_xform, params.session_mpool); 796 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 797 798 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 799 &cap); 800 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 801 802 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 803 /* Fill in private user data information */ 804 m_data.response_info.event = response_info.event; 805 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 806 sess, RTE_CRYPTO_OP_TYPE_SYMMETRIC, 807 RTE_CRYPTO_OP_WITH_SESSION, 808 &m_data, sizeof(m_data)); 809 } 810 811 rte_crypto_op_attach_sym_session(op, sess); 812 } else { 813 struct rte_crypto_sym_xform *first_xform; 814 815 rte_crypto_op_sym_xforms_alloc(op, NUM); 816 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 817 first_xform = &cipher_xform; 818 sym_op->xform = first_xform; 819 uint32_t len = IV_OFFSET + MAXIMUM_IV_LENGTH; 820 op->private_data_offset = len; 821 /* Fill in private data information */ 822 m_data.response_info.event = response_info.event; 823 rte_memcpy((uint8_t *)op + len, &m_data, sizeof(m_data)); 824 } 825 826 sym_op->m_src = m; 827 sym_op->cipher.data.offset = 0; 828 sym_op->cipher.data.length = PACKET_LENGTH; 829 830 ret = send_op_recv_ev(op); 831 TEST_ASSERT_SUCCESS(ret, "Failed to enqueue op to cryptodev\n"); 832 833 test_crypto_adapter_stats(); 834 835 return TEST_SUCCESS; 836 } 837 838 static int 839 test_sessionless_with_op_new_mode(void) 840 { 841 uint32_t cap; 842 int ret; 843 844 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 845 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 846 847 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 848 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 849 map_adapter_service_core(); 850 else { 851 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 852 return TEST_SKIPPED; 853 } 854 855 /* start the event crypto adapter */ 856 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 857 "Failed to start event crypto adapter"); 858 859 ret = test_op_new_mode(1); 860 TEST_ASSERT_SUCCESS(ret, "Sessionless - NEW mode test failed\n"); 861 return TEST_SUCCESS; 862 } 863 864 static int 865 test_session_with_op_new_mode(void) 866 { 867 uint32_t cap; 868 int ret; 869 870 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 871 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 872 873 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 874 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 875 map_adapter_service_core(); 876 else { 877 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 878 return TEST_SKIPPED; 879 } 880 881 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 882 "Failed to start event crypto adapter"); 883 884 ret = test_op_new_mode(0); 885 TEST_ASSERT_SUCCESS(ret, "Session based - NEW mode test failed\n"); 886 return TEST_SUCCESS; 887 } 888 889 static int 890 test_asym_op_new_mode(uint8_t session_less) 891 { 892 const struct rte_cryptodev_asymmetric_xform_capability *capability; 893 struct rte_cryptodev_asym_capability_idx cap_idx; 894 struct rte_crypto_asym_xform xform_tc; 895 union rte_event_crypto_metadata m_data; 896 struct rte_cryptodev_info dev_info; 897 struct rte_crypto_asym_op *asym_op; 898 struct rte_crypto_op *op; 899 uint8_t input[4096] = {0}; 900 uint8_t *result = NULL; 901 void *sess = NULL; 902 uint32_t cap; 903 int ret; 904 905 memset(&m_data, 0, sizeof(m_data)); 906 907 rte_cryptodev_info_get(TEST_CDEV_ID, &dev_info); 908 if (session_less && !(dev_info.feature_flags & 909 RTE_CRYPTODEV_FF_ASYM_SESSIONLESS)) { 910 RTE_LOG(INFO, USER1, 911 "Device doesn't support Asym sessionless ops. Test Skipped\n"); 912 return TEST_SKIPPED; 913 } 914 /* Setup Cipher Parameters */ 915 xform_tc.next = NULL; 916 xform_tc.xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX; 917 cap_idx.type = xform_tc.xform_type; 918 capability = rte_cryptodev_asym_capability_get(TEST_CDEV_ID, &cap_idx); 919 920 if (capability == NULL) { 921 RTE_LOG(INFO, USER1, 922 "Device doesn't support MODEX. Test Skipped\n"); 923 return TEST_SKIPPED; 924 } 925 926 op = rte_crypto_op_alloc(params.asym_op_mpool, 927 RTE_CRYPTO_OP_TYPE_ASYMMETRIC); 928 TEST_ASSERT_NOT_NULL(op, "Failed to allocate asym crypto_op!\n"); 929 930 asym_op = op->asym; 931 932 result = rte_zmalloc(NULL, modex_test_case.result_len, 0); 933 xform_tc.modex.modulus.data = modex_test_case.modulus.data; 934 xform_tc.modex.modulus.length = modex_test_case.modulus.len; 935 xform_tc.modex.exponent.data = modex_test_case.exponent.data; 936 xform_tc.modex.exponent.length = modex_test_case.exponent.len; 937 memcpy(input, modex_test_case.base.data, 938 modex_test_case.base.len); 939 asym_op->modex.base.data = input; 940 asym_op->modex.base.length = modex_test_case.base.len; 941 asym_op->modex.result.data = result; 942 asym_op->modex.result.length = modex_test_case.result_len; 943 if (rte_cryptodev_asym_xform_capability_check_modlen(capability, 944 xform_tc.modex.modulus.length)) { 945 RTE_LOG(INFO, USER1, 946 "line %u FAILED: %s", __LINE__, 947 "Invalid MODULUS length specified"); 948 return TEST_FAILED; 949 } 950 951 if (!session_less) { 952 ret = rte_cryptodev_asym_session_create(TEST_CDEV_ID, 953 &xform_tc, params.asym_sess_mpool, &sess); 954 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 955 TEST_ASSERT_SUCCESS(ret, "Failed to init session\n"); 956 957 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 958 &cap); 959 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 960 961 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 962 /* Fill in private user data information */ 963 m_data.response_info.event = response_info.event; 964 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 965 sess, RTE_CRYPTO_OP_TYPE_ASYMMETRIC, 966 RTE_CRYPTO_OP_WITH_SESSION, 967 &m_data, sizeof(m_data)); 968 } 969 970 rte_crypto_op_attach_asym_session(op, sess); 971 } else { 972 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 973 asym_op->xform = &xform_tc; 974 op->private_data_offset = (sizeof(struct rte_crypto_op) + 975 sizeof(struct rte_crypto_asym_op) + 976 DEFAULT_NUM_XFORMS * 977 sizeof(struct rte_crypto_asym_xform)); 978 /* Fill in private data information */ 979 m_data.response_info.event = response_info.event; 980 rte_memcpy((uint8_t *)op + op->private_data_offset, 981 &m_data, sizeof(m_data)); 982 } 983 984 ret = send_op_recv_ev(op); 985 TEST_ASSERT_SUCCESS(ret, "Failed to enqueue op to cryptodev\n"); 986 987 test_crypto_adapter_stats(); 988 989 return TEST_SUCCESS; 990 } 991 992 static int 993 test_asym_sessionless_with_op_new_mode(void) 994 { 995 uint32_t cap; 996 int ret; 997 998 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 999 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1000 1001 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 1002 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1003 map_adapter_service_core(); 1004 else { 1005 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1006 return TEST_SKIPPED; 1007 } 1008 1009 /* start the event crypto adapter */ 1010 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 1011 "Failed to start event crypto adapter"); 1012 1013 return test_asym_op_new_mode(1); 1014 } 1015 1016 static int 1017 test_asym_session_with_op_new_mode(void) 1018 { 1019 uint32_t cap; 1020 int ret; 1021 1022 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1023 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1024 1025 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 1026 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1027 map_adapter_service_core(); 1028 else { 1029 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1030 return TEST_SKIPPED; 1031 } 1032 1033 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 1034 "Failed to start event crypto adapter"); 1035 1036 return test_asym_op_new_mode(0); 1037 } 1038 1039 static int 1040 configure_cryptodev(void) 1041 { 1042 const struct rte_cryptodev_capabilities *capability; 1043 struct rte_cryptodev_qp_conf qp_conf; 1044 struct rte_cryptodev_config conf; 1045 struct rte_cryptodev_info info; 1046 unsigned int session_size; 1047 unsigned int i = 0; 1048 uint8_t nb_devs; 1049 int ret; 1050 1051 1052 params.mbuf_pool = rte_pktmbuf_pool_create( 1053 "CRYPTO_ADAPTER_MBUFPOOL", 1054 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 1055 rte_socket_id()); 1056 if (params.mbuf_pool == NULL) { 1057 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n"); 1058 return TEST_FAILED; 1059 } 1060 1061 params.op_mpool = rte_crypto_op_pool_create( 1062 "EVENT_CRYPTO_SYM_OP_POOL", 1063 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 1064 NUM_MBUFS, MBUF_CACHE_SIZE, 1065 DEFAULT_NUM_XFORMS * 1066 sizeof(struct rte_crypto_sym_xform) + 1067 MAXIMUM_IV_LENGTH + 1068 sizeof(union rte_event_crypto_metadata), 1069 rte_socket_id()); 1070 if (params.op_mpool == NULL) { 1071 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); 1072 return TEST_FAILED; 1073 } 1074 1075 1076 nb_devs = rte_cryptodev_count(); 1077 if (!nb_devs) { 1078 /* Create a NULL crypto device */ 1079 ret = rte_vdev_init( 1080 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); 1081 1082 TEST_ASSERT(ret == 0, "Failed to create pmd:%s instance\n", 1083 RTE_STR(CRYPTODEV_NAME_NULL_PMD)); 1084 } 1085 1086 nb_devs = rte_cryptodev_count(); 1087 if (!nb_devs) { 1088 RTE_LOG(ERR, USER1, "No crypto devices found!\n"); 1089 return TEST_FAILED; 1090 } 1091 1092 /* 1093 * Create mempool with maximum number of sessions * 2, 1094 * to include the session headers & private data 1095 */ 1096 session_size = rte_cryptodev_sym_get_private_session_size(TEST_CDEV_ID); 1097 session_size += sizeof(union rte_event_crypto_metadata); 1098 1099 params.session_mpool = rte_cryptodev_sym_session_pool_create( 1100 "CRYPTO_ADAPTER_SESSION_MP", 1101 MAX_NB_SESSIONS, session_size, 0, 1102 sizeof(union rte_event_crypto_metadata), 1103 SOCKET_ID_ANY); 1104 TEST_ASSERT_NOT_NULL(params.session_mpool, 1105 "session mempool allocation failed\n"); 1106 1107 rte_cryptodev_info_get(TEST_CDEV_ID, &info); 1108 1109 while ((capability = &info.capabilities[i++])->op != 1110 RTE_CRYPTO_OP_TYPE_UNDEFINED) { 1111 if (capability->op == RTE_CRYPTO_OP_TYPE_ASYMMETRIC) { 1112 params.asym_op_mpool = rte_crypto_op_pool_create( 1113 "EVENT_CRYPTO_ASYM_OP_POOL", 1114 RTE_CRYPTO_OP_TYPE_ASYMMETRIC, 1115 NUM_MBUFS, MBUF_CACHE_SIZE, 1116 (DEFAULT_NUM_XFORMS * 1117 sizeof(struct rte_crypto_asym_xform)) + 1118 sizeof(union rte_event_crypto_metadata), 1119 rte_socket_id()); 1120 TEST_ASSERT_NOT_NULL(params.asym_op_mpool, 1121 "Can't create CRYPTO_ASYM_OP_POOL\n"); 1122 1123 params.asym_sess_mpool = 1124 rte_cryptodev_asym_session_pool_create( 1125 "CRYPTO_AD_ASYM_SESS_MP", 1126 MAX_NB_SESSIONS, 0, 1127 sizeof(union rte_event_crypto_metadata), 1128 SOCKET_ID_ANY); 1129 TEST_ASSERT_NOT_NULL(params.asym_sess_mpool, 1130 "asym session mempool allocation failed\n"); 1131 break; 1132 } 1133 } 1134 1135 conf.nb_queue_pairs = info.max_nb_queue_pairs; 1136 conf.socket_id = SOCKET_ID_ANY; 1137 conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY; 1138 1139 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(TEST_CDEV_ID, &conf), 1140 "Failed to configure cryptodev %u with %u qps\n", 1141 TEST_CDEV_ID, conf.nb_queue_pairs); 1142 1143 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 1144 qp_conf.mp_session = params.session_mpool; 1145 1146 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 1147 TEST_CDEV_ID, TEST_CDEV_QP_ID, &qp_conf, 1148 rte_cryptodev_socket_id(TEST_CDEV_ID)), 1149 "Failed to setup queue pair %u on cryptodev %u\n", 1150 TEST_CDEV_QP_ID, TEST_CDEV_ID); 1151 1152 return TEST_SUCCESS; 1153 } 1154 1155 static inline void 1156 evdev_set_conf_values(struct rte_event_dev_config *dev_conf, 1157 struct rte_event_dev_info *info) 1158 { 1159 memset(dev_conf, 0, sizeof(struct rte_event_dev_config)); 1160 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns; 1161 dev_conf->nb_event_ports = NB_TEST_PORTS; 1162 dev_conf->nb_event_queues = NB_TEST_QUEUES; 1163 dev_conf->nb_event_queue_flows = info->max_event_queue_flows; 1164 dev_conf->nb_event_port_dequeue_depth = 1165 info->max_event_port_dequeue_depth; 1166 dev_conf->nb_event_port_enqueue_depth = 1167 info->max_event_port_enqueue_depth; 1168 dev_conf->nb_event_port_enqueue_depth = 1169 info->max_event_port_enqueue_depth; 1170 dev_conf->nb_events_limit = 1171 info->max_num_events; 1172 } 1173 1174 static int 1175 configure_eventdev(void) 1176 { 1177 struct rte_event_queue_conf queue_conf; 1178 struct rte_event_dev_config devconf; 1179 struct rte_event_dev_info info; 1180 uint32_t queue_count; 1181 uint32_t port_count; 1182 int ret; 1183 uint8_t qid; 1184 1185 if (!rte_event_dev_count()) { 1186 /* If there is no hardware eventdev, or no software vdev was 1187 * specified on the command line, create an instance of 1188 * event_sw. 1189 */ 1190 LOG_DBG("Failed to find a valid event device... " 1191 "testing with event_sw device\n"); 1192 TEST_ASSERT_SUCCESS(rte_vdev_init("event_sw0", NULL), 1193 "Error creating eventdev"); 1194 evdev = rte_event_dev_get_dev_id("event_sw0"); 1195 } 1196 1197 ret = rte_event_dev_info_get(evdev, &info); 1198 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info\n"); 1199 1200 evdev_set_conf_values(&devconf, &info); 1201 1202 ret = rte_event_dev_configure(evdev, &devconf); 1203 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev\n"); 1204 1205 /* Set up event queue */ 1206 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_QUEUE_COUNT, 1207 &queue_count); 1208 TEST_ASSERT_SUCCESS(ret, "Queue count get failed\n"); 1209 TEST_ASSERT_EQUAL(queue_count, 2, "Unexpected queue count\n"); 1210 1211 qid = TEST_APP_EV_QUEUE_ID; 1212 ret = rte_event_queue_setup(evdev, qid, NULL); 1213 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d\n", qid); 1214 1215 queue_conf.nb_atomic_flows = info.max_event_queue_flows; 1216 queue_conf.nb_atomic_order_sequences = 32; 1217 queue_conf.schedule_type = RTE_SCHED_TYPE_ATOMIC; 1218 queue_conf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST; 1219 queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK; 1220 1221 qid = TEST_CRYPTO_EV_QUEUE_ID; 1222 ret = rte_event_queue_setup(evdev, qid, &queue_conf); 1223 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%u\n", qid); 1224 1225 /* Set up event port */ 1226 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_PORT_COUNT, 1227 &port_count); 1228 TEST_ASSERT_SUCCESS(ret, "Port count get failed\n"); 1229 TEST_ASSERT_EQUAL(port_count, 1, "Unexpected port count\n"); 1230 1231 ret = rte_event_port_setup(evdev, TEST_APP_PORT_ID, NULL); 1232 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d\n", 1233 TEST_APP_PORT_ID); 1234 1235 qid = TEST_APP_EV_QUEUE_ID; 1236 ret = rte_event_port_link(evdev, TEST_APP_PORT_ID, &qid, NULL, 1); 1237 TEST_ASSERT(ret >= 0, "Failed to link queue port=%d\n", 1238 TEST_APP_PORT_ID); 1239 1240 return TEST_SUCCESS; 1241 } 1242 1243 static void 1244 test_crypto_adapter_free(void) 1245 { 1246 rte_event_crypto_adapter_free(TEST_ADAPTER_ID); 1247 } 1248 1249 static int 1250 test_crypto_adapter_create(void) 1251 { 1252 struct rte_event_port_conf conf = { 1253 .dequeue_depth = 8, 1254 .enqueue_depth = 8, 1255 .new_event_threshold = 1200, 1256 }; 1257 uint32_t cap; 1258 int ret; 1259 1260 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1261 if (ret == -ENOTSUP) 1262 return ret; 1263 1264 /* Create adapter with default port creation callback */ 1265 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 1266 evdev, 1267 &conf, 0); 1268 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 1269 1270 return TEST_SUCCESS; 1271 } 1272 1273 static int 1274 test_crypto_adapter_qp_add_del(void) 1275 { 1276 struct rte_event_crypto_adapter_queue_conf queue_conf = { 1277 .ev = response_info, 1278 }; 1279 1280 uint32_t cap; 1281 int ret; 1282 1283 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1284 if (ret == -ENOTSUP) 1285 return TEST_SKIPPED; 1286 1287 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1288 1289 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 1290 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1291 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 1292 } else 1293 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1294 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 1295 1296 TEST_ASSERT_SUCCESS(ret, "Failed to create add queue pair\n"); 1297 1298 ret = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 1299 TEST_CDEV_ID, TEST_CDEV_QP_ID); 1300 TEST_ASSERT_SUCCESS(ret, "Failed to delete add queue pair\n"); 1301 1302 return TEST_SUCCESS; 1303 } 1304 1305 static int 1306 configure_event_crypto_adapter(enum rte_event_crypto_adapter_mode mode) 1307 { 1308 struct rte_event_port_conf conf = { 1309 .dequeue_depth = 8, 1310 .enqueue_depth = 8, 1311 .new_event_threshold = 1200, 1312 }; 1313 1314 struct rte_event_crypto_adapter_queue_conf queue_conf = { 1315 .ev = response_info, 1316 }; 1317 1318 uint32_t cap; 1319 int ret; 1320 1321 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1322 if (ret == -ENOTSUP) 1323 return ret; 1324 1325 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1326 1327 /* Skip mode and capability mismatch check for SW eventdev */ 1328 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW) && 1329 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 1330 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND)) 1331 goto adapter_create; 1332 1333 if (mode == RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) { 1334 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) 1335 params.internal_port_op_fwd = 1; 1336 else 1337 return -ENOTSUP; 1338 } 1339 1340 if ((mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) && 1341 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1342 return -ENOTSUP; 1343 1344 adapter_create: 1345 /* Create adapter with default port creation callback */ 1346 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 1347 evdev, 1348 &conf, mode); 1349 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 1350 1351 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 1352 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1353 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 1354 } else 1355 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1356 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 1357 1358 TEST_ASSERT_SUCCESS(ret, "Failed to add queue pair\n"); 1359 1360 if (!params.internal_port_op_fwd) { 1361 ret = rte_event_crypto_adapter_event_port_get(TEST_ADAPTER_ID, 1362 ¶ms.crypto_event_port_id); 1363 TEST_ASSERT_SUCCESS(ret, "Failed to get event port\n"); 1364 } 1365 1366 return TEST_SUCCESS; 1367 } 1368 1369 static void 1370 test_crypto_adapter_stop(void) 1371 { 1372 uint32_t evdev_service_id, adapter_service_id; 1373 1374 /* retrieve service ids & stop services */ 1375 if (rte_event_crypto_adapter_service_id_get(TEST_ADAPTER_ID, 1376 &adapter_service_id) == 0) { 1377 rte_service_runstate_set(adapter_service_id, 0); 1378 rte_service_lcore_stop(slcore_id); 1379 rte_service_lcore_del(slcore_id); 1380 rte_event_crypto_adapter_stop(TEST_ADAPTER_ID); 1381 } 1382 1383 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 1384 rte_service_runstate_set(evdev_service_id, 0); 1385 rte_service_lcore_stop(slcore_id); 1386 rte_service_lcore_del(slcore_id); 1387 rte_cryptodev_stop(TEST_CDEV_ID); 1388 rte_event_dev_stop(evdev); 1389 } else { 1390 rte_cryptodev_stop(TEST_CDEV_ID); 1391 rte_event_dev_stop(evdev); 1392 } 1393 } 1394 1395 static int 1396 test_crypto_adapter_conf(enum rte_event_crypto_adapter_mode mode) 1397 { 1398 uint32_t evdev_service_id; 1399 uint8_t qid; 1400 int ret; 1401 1402 if (!crypto_adapter_setup_done) { 1403 ret = configure_event_crypto_adapter(mode); 1404 if (ret) 1405 return ret; 1406 if (!params.internal_port_op_fwd) { 1407 qid = TEST_CRYPTO_EV_QUEUE_ID; 1408 ret = rte_event_port_link(evdev, 1409 params.crypto_event_port_id, &qid, NULL, 1); 1410 TEST_ASSERT(ret >= 0, "Failed to link queue %d " 1411 "port=%u\n", qid, 1412 params.crypto_event_port_id); 1413 } 1414 crypto_adapter_setup_done = 1; 1415 } 1416 1417 /* retrieve service ids */ 1418 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 1419 /* add a service core and start it */ 1420 TEST_ASSERT_SUCCESS(rte_service_lcore_add(slcore_id), 1421 "Failed to add service core"); 1422 TEST_ASSERT_SUCCESS(rte_service_lcore_start(slcore_id), 1423 "Failed to start service core"); 1424 1425 /* map services to it */ 1426 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(evdev_service_id, 1427 slcore_id, 1), "Failed to map evdev service"); 1428 1429 /* set services to running */ 1430 TEST_ASSERT_SUCCESS(rte_service_runstate_set(evdev_service_id, 1431 1), "Failed to start evdev service"); 1432 } 1433 1434 /* start the eventdev */ 1435 TEST_ASSERT_SUCCESS(rte_event_dev_start(evdev), 1436 "Failed to start event device"); 1437 1438 /* start the cryptodev */ 1439 TEST_ASSERT_SUCCESS(rte_cryptodev_start(TEST_CDEV_ID), 1440 "Failed to start crypto device"); 1441 1442 return TEST_SUCCESS; 1443 } 1444 1445 static int 1446 test_crypto_adapter_conf_op_forward_mode(void) 1447 { 1448 enum rte_event_crypto_adapter_mode mode; 1449 1450 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD; 1451 1452 return test_crypto_adapter_conf(mode); 1453 } 1454 1455 static int 1456 test_crypto_adapter_conf_op_new_mode(void) 1457 { 1458 enum rte_event_crypto_adapter_mode mode; 1459 1460 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_NEW; 1461 1462 return test_crypto_adapter_conf(mode); 1463 } 1464 1465 1466 static int 1467 testsuite_setup(void) 1468 { 1469 int ret; 1470 1471 slcore_id = rte_get_next_lcore(-1, 1, 0); 1472 TEST_ASSERT_NOT_EQUAL(slcore_id, RTE_MAX_LCORE, "At least 2 lcores " 1473 "are required to run this autotest\n"); 1474 1475 /* Setup and start event device. */ 1476 ret = configure_eventdev(); 1477 TEST_ASSERT_SUCCESS(ret, "Failed to setup eventdev\n"); 1478 1479 /* Setup and start crypto device. */ 1480 ret = configure_cryptodev(); 1481 TEST_ASSERT_SUCCESS(ret, "cryptodev initialization failed\n"); 1482 1483 return TEST_SUCCESS; 1484 } 1485 1486 static void 1487 crypto_adapter_teardown(void) 1488 { 1489 int ret; 1490 1491 if (!crypto_adapter_setup_done) 1492 return; 1493 1494 ret = rte_event_crypto_adapter_stop(TEST_ADAPTER_ID); 1495 if (ret < 0) 1496 RTE_LOG(ERR, USER1, "Failed to stop adapter!"); 1497 1498 ret = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 1499 TEST_CDEV_ID, TEST_CDEV_QP_ID); 1500 if (ret < 0) 1501 RTE_LOG(ERR, USER1, "Failed to delete queue pair!"); 1502 1503 ret = rte_event_crypto_adapter_free(TEST_ADAPTER_ID); 1504 if (ret < 0) 1505 RTE_LOG(ERR, USER1, "Failed to free adapter!"); 1506 1507 crypto_adapter_setup_done = 0; 1508 } 1509 1510 static void 1511 crypto_teardown(void) 1512 { 1513 /* Free mbuf mempool */ 1514 if (params.mbuf_pool != NULL) { 1515 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_MBUFPOOL count %u\n", 1516 rte_mempool_avail_count(params.mbuf_pool)); 1517 rte_mempool_free(params.mbuf_pool); 1518 params.mbuf_pool = NULL; 1519 } 1520 1521 /* Free session mempool */ 1522 if (params.session_mpool != NULL) { 1523 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_SESSION_MP count %u\n", 1524 rte_mempool_avail_count(params.session_mpool)); 1525 rte_mempool_free(params.session_mpool); 1526 params.session_mpool = NULL; 1527 } 1528 1529 /* Free asym session mempool */ 1530 if (params.asym_sess_mpool != NULL) { 1531 RTE_LOG(DEBUG, USER1, "CRYPTO_AD_ASYM_SESS_MP count %u\n", 1532 rte_mempool_avail_count(params.asym_sess_mpool)); 1533 rte_mempool_free(params.asym_sess_mpool); 1534 params.asym_sess_mpool = NULL; 1535 } 1536 /* Free asym ops mempool */ 1537 if (params.asym_op_mpool != NULL) { 1538 RTE_LOG(DEBUG, USER1, "EVENT_CRYPTO_ASYM_OP_POOL count %u\n", 1539 rte_mempool_avail_count(params.asym_op_mpool)); 1540 rte_mempool_free(params.asym_op_mpool); 1541 params.asym_op_mpool = NULL; 1542 } 1543 1544 /* Free ops mempool */ 1545 if (params.op_mpool != NULL) { 1546 RTE_LOG(DEBUG, USER1, "EVENT_CRYPTO_SYM_OP_POOL count %u\n", 1547 rte_mempool_avail_count(params.op_mpool)); 1548 rte_mempool_free(params.op_mpool); 1549 params.op_mpool = NULL; 1550 } 1551 } 1552 1553 static void 1554 eventdev_teardown(void) 1555 { 1556 rte_event_dev_stop(evdev); 1557 } 1558 1559 static void 1560 testsuite_teardown(void) 1561 { 1562 crypto_adapter_teardown(); 1563 crypto_teardown(); 1564 eventdev_teardown(); 1565 } 1566 1567 static struct unit_test_suite functional_testsuite = { 1568 .suite_name = "Event crypto adapter test suite", 1569 .setup = testsuite_setup, 1570 .teardown = testsuite_teardown, 1571 .unit_test_cases = { 1572 1573 TEST_CASE_ST(NULL, test_crypto_adapter_free, 1574 test_crypto_adapter_create), 1575 1576 TEST_CASE_ST(test_crypto_adapter_create, 1577 test_crypto_adapter_free, 1578 test_crypto_adapter_qp_add_del), 1579 1580 TEST_CASE_ST(test_crypto_adapter_create, 1581 test_crypto_adapter_free, 1582 test_crypto_adapter_stats), 1583 1584 TEST_CASE_ST(test_crypto_adapter_create, 1585 test_crypto_adapter_free, 1586 test_crypto_adapter_params), 1587 1588 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1589 test_crypto_adapter_stop, 1590 test_session_with_op_forward_mode), 1591 1592 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1593 test_crypto_adapter_stop, 1594 test_sessionless_with_op_forward_mode), 1595 1596 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1597 test_crypto_adapter_stop, 1598 test_session_with_op_new_mode), 1599 1600 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1601 test_crypto_adapter_stop, 1602 test_sessionless_with_op_new_mode), 1603 1604 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1605 test_crypto_adapter_stop, 1606 test_asym_session_with_op_forward_mode), 1607 1608 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1609 test_crypto_adapter_stop, 1610 test_asym_sessionless_with_op_forward_mode), 1611 1612 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1613 test_crypto_adapter_stop, 1614 test_asym_session_with_op_new_mode), 1615 1616 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1617 test_crypto_adapter_stop, 1618 test_asym_sessionless_with_op_new_mode), 1619 1620 TEST_CASES_END() /**< NULL terminate unit test array */ 1621 } 1622 }; 1623 1624 static int 1625 test_event_crypto_adapter(void) 1626 { 1627 return unit_test_suite_runner(&functional_testsuite); 1628 } 1629 1630 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1631 1632 REGISTER_TEST_COMMAND(event_crypto_adapter_autotest, 1633 test_event_crypto_adapter); 1634