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 const struct rte_event_dev_info *info) 1158 { 1159 *dev_conf = (struct rte_event_dev_config) { 1160 .dequeue_timeout_ns = info->min_dequeue_timeout_ns, 1161 .nb_event_ports = NB_TEST_PORTS, 1162 .nb_event_queues = NB_TEST_QUEUES, 1163 .nb_event_queue_flows = info->max_event_queue_flows, 1164 .nb_event_port_dequeue_depth = info->max_event_port_dequeue_depth, 1165 .nb_event_port_enqueue_depth = info->max_event_port_enqueue_depth, 1166 .nb_events_limit = info->max_num_events, 1167 }; 1168 } 1169 1170 static int 1171 configure_eventdev(void) 1172 { 1173 struct rte_event_queue_conf queue_conf; 1174 struct rte_event_dev_config devconf; 1175 struct rte_event_dev_info info; 1176 uint32_t queue_count; 1177 uint32_t port_count; 1178 int ret; 1179 uint8_t qid; 1180 1181 if (!rte_event_dev_count()) { 1182 /* If there is no hardware eventdev, or no software vdev was 1183 * specified on the command line, create an instance of 1184 * event_sw. 1185 */ 1186 LOG_DBG("Failed to find a valid event device... " 1187 "testing with event_sw device\n"); 1188 TEST_ASSERT_SUCCESS(rte_vdev_init("event_sw0", NULL), 1189 "Error creating eventdev"); 1190 evdev = rte_event_dev_get_dev_id("event_sw0"); 1191 } 1192 1193 ret = rte_event_dev_info_get(evdev, &info); 1194 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info\n"); 1195 1196 evdev_set_conf_values(&devconf, &info); 1197 1198 ret = rte_event_dev_configure(evdev, &devconf); 1199 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev\n"); 1200 1201 /* Set up event queue */ 1202 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_QUEUE_COUNT, 1203 &queue_count); 1204 TEST_ASSERT_SUCCESS(ret, "Queue count get failed\n"); 1205 TEST_ASSERT_EQUAL(queue_count, 2, "Unexpected queue count\n"); 1206 1207 qid = TEST_APP_EV_QUEUE_ID; 1208 ret = rte_event_queue_setup(evdev, qid, NULL); 1209 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d\n", qid); 1210 1211 queue_conf.nb_atomic_flows = info.max_event_queue_flows; 1212 queue_conf.nb_atomic_order_sequences = 32; 1213 queue_conf.schedule_type = RTE_SCHED_TYPE_ATOMIC; 1214 queue_conf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST; 1215 queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK; 1216 1217 qid = TEST_CRYPTO_EV_QUEUE_ID; 1218 ret = rte_event_queue_setup(evdev, qid, &queue_conf); 1219 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%u\n", qid); 1220 1221 /* Set up event port */ 1222 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_PORT_COUNT, 1223 &port_count); 1224 TEST_ASSERT_SUCCESS(ret, "Port count get failed\n"); 1225 TEST_ASSERT_EQUAL(port_count, 1, "Unexpected port count\n"); 1226 1227 ret = rte_event_port_setup(evdev, TEST_APP_PORT_ID, NULL); 1228 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d\n", 1229 TEST_APP_PORT_ID); 1230 1231 qid = TEST_APP_EV_QUEUE_ID; 1232 ret = rte_event_port_link(evdev, TEST_APP_PORT_ID, &qid, NULL, 1); 1233 TEST_ASSERT(ret >= 0, "Failed to link queue port=%d\n", 1234 TEST_APP_PORT_ID); 1235 1236 return TEST_SUCCESS; 1237 } 1238 1239 static void 1240 test_crypto_adapter_free(void) 1241 { 1242 rte_event_crypto_adapter_free(TEST_ADAPTER_ID); 1243 } 1244 1245 static int 1246 test_crypto_adapter_create(void) 1247 { 1248 struct rte_event_port_conf conf = { 1249 .dequeue_depth = 8, 1250 .enqueue_depth = 8, 1251 .new_event_threshold = 1200, 1252 }; 1253 uint32_t cap; 1254 int ret; 1255 1256 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1257 if (ret == -ENOTSUP) 1258 return ret; 1259 1260 /* Create adapter with default port creation callback */ 1261 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 1262 evdev, 1263 &conf, 0); 1264 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 1265 1266 return TEST_SUCCESS; 1267 } 1268 1269 static int 1270 test_crypto_adapter_qp_add_del(void) 1271 { 1272 struct rte_event_crypto_adapter_queue_conf queue_conf = { 1273 .ev = response_info, 1274 }; 1275 1276 uint32_t cap; 1277 int ret; 1278 1279 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1280 if (ret == -ENOTSUP) 1281 return TEST_SKIPPED; 1282 1283 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1284 1285 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 1286 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1287 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 1288 } else 1289 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1290 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 1291 1292 TEST_ASSERT_SUCCESS(ret, "Failed to create add queue pair\n"); 1293 1294 ret = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 1295 TEST_CDEV_ID, TEST_CDEV_QP_ID); 1296 TEST_ASSERT_SUCCESS(ret, "Failed to delete add queue pair\n"); 1297 1298 return TEST_SUCCESS; 1299 } 1300 1301 static int 1302 configure_event_crypto_adapter(enum rte_event_crypto_adapter_mode mode) 1303 { 1304 struct rte_event_port_conf conf = { 1305 .dequeue_depth = 8, 1306 .enqueue_depth = 8, 1307 .new_event_threshold = 1200, 1308 }; 1309 1310 struct rte_event_crypto_adapter_queue_conf queue_conf = { 1311 .ev = response_info, 1312 }; 1313 1314 uint32_t cap; 1315 int ret; 1316 1317 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1318 if (ret == -ENOTSUP) 1319 return ret; 1320 1321 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1322 1323 /* Skip mode and capability mismatch check for SW eventdev */ 1324 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW) && 1325 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 1326 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND)) 1327 goto adapter_create; 1328 1329 if (mode == RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) { 1330 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) 1331 params.internal_port_op_fwd = 1; 1332 else 1333 return -ENOTSUP; 1334 } 1335 1336 if ((mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) && 1337 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1338 return -ENOTSUP; 1339 1340 adapter_create: 1341 /* Create adapter with default port creation callback */ 1342 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 1343 evdev, 1344 &conf, mode); 1345 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 1346 1347 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 1348 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1349 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 1350 } else 1351 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1352 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 1353 1354 TEST_ASSERT_SUCCESS(ret, "Failed to add queue pair\n"); 1355 1356 if (!params.internal_port_op_fwd) { 1357 ret = rte_event_crypto_adapter_event_port_get(TEST_ADAPTER_ID, 1358 ¶ms.crypto_event_port_id); 1359 TEST_ASSERT_SUCCESS(ret, "Failed to get event port\n"); 1360 } 1361 1362 return TEST_SUCCESS; 1363 } 1364 1365 static void 1366 test_crypto_adapter_stop(void) 1367 { 1368 uint32_t evdev_service_id, adapter_service_id; 1369 1370 /* retrieve service ids & stop services */ 1371 if (rte_event_crypto_adapter_service_id_get(TEST_ADAPTER_ID, 1372 &adapter_service_id) == 0) { 1373 rte_service_runstate_set(adapter_service_id, 0); 1374 rte_service_lcore_stop(slcore_id); 1375 rte_service_lcore_del(slcore_id); 1376 rte_event_crypto_adapter_stop(TEST_ADAPTER_ID); 1377 } 1378 1379 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 1380 rte_service_runstate_set(evdev_service_id, 0); 1381 rte_service_lcore_stop(slcore_id); 1382 rte_service_lcore_del(slcore_id); 1383 rte_cryptodev_stop(TEST_CDEV_ID); 1384 rte_event_dev_stop(evdev); 1385 } else { 1386 rte_cryptodev_stop(TEST_CDEV_ID); 1387 rte_event_dev_stop(evdev); 1388 } 1389 } 1390 1391 static int 1392 test_crypto_adapter_conf(enum rte_event_crypto_adapter_mode mode) 1393 { 1394 uint32_t evdev_service_id; 1395 uint8_t qid; 1396 int ret; 1397 1398 if (!crypto_adapter_setup_done) { 1399 ret = configure_event_crypto_adapter(mode); 1400 if (ret) 1401 return ret; 1402 if (!params.internal_port_op_fwd) { 1403 qid = TEST_CRYPTO_EV_QUEUE_ID; 1404 ret = rte_event_port_link(evdev, 1405 params.crypto_event_port_id, &qid, NULL, 1); 1406 TEST_ASSERT(ret >= 0, "Failed to link queue %d " 1407 "port=%u\n", qid, 1408 params.crypto_event_port_id); 1409 } 1410 crypto_adapter_setup_done = 1; 1411 } 1412 1413 /* retrieve service ids */ 1414 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 1415 /* add a service core and start it */ 1416 TEST_ASSERT_SUCCESS(rte_service_lcore_add(slcore_id), 1417 "Failed to add service core"); 1418 TEST_ASSERT_SUCCESS(rte_service_lcore_start(slcore_id), 1419 "Failed to start service core"); 1420 1421 /* map services to it */ 1422 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(evdev_service_id, 1423 slcore_id, 1), "Failed to map evdev service"); 1424 1425 /* set services to running */ 1426 TEST_ASSERT_SUCCESS(rte_service_runstate_set(evdev_service_id, 1427 1), "Failed to start evdev service"); 1428 } 1429 1430 /* start the eventdev */ 1431 TEST_ASSERT_SUCCESS(rte_event_dev_start(evdev), 1432 "Failed to start event device"); 1433 1434 /* start the cryptodev */ 1435 TEST_ASSERT_SUCCESS(rte_cryptodev_start(TEST_CDEV_ID), 1436 "Failed to start crypto device"); 1437 1438 return TEST_SUCCESS; 1439 } 1440 1441 static int 1442 test_crypto_adapter_conf_op_forward_mode(void) 1443 { 1444 enum rte_event_crypto_adapter_mode mode; 1445 1446 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD; 1447 1448 return test_crypto_adapter_conf(mode); 1449 } 1450 1451 static int 1452 test_crypto_adapter_conf_op_new_mode(void) 1453 { 1454 enum rte_event_crypto_adapter_mode mode; 1455 1456 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_NEW; 1457 1458 return test_crypto_adapter_conf(mode); 1459 } 1460 1461 1462 static int 1463 testsuite_setup(void) 1464 { 1465 int ret; 1466 1467 slcore_id = rte_get_next_lcore(-1, 1, 0); 1468 TEST_ASSERT_NOT_EQUAL(slcore_id, RTE_MAX_LCORE, "At least 2 lcores " 1469 "are required to run this autotest\n"); 1470 1471 /* Setup and start event device. */ 1472 ret = configure_eventdev(); 1473 TEST_ASSERT_SUCCESS(ret, "Failed to setup eventdev\n"); 1474 1475 /* Setup and start crypto device. */ 1476 ret = configure_cryptodev(); 1477 TEST_ASSERT_SUCCESS(ret, "cryptodev initialization failed\n"); 1478 1479 return TEST_SUCCESS; 1480 } 1481 1482 static void 1483 crypto_adapter_teardown(void) 1484 { 1485 int ret; 1486 1487 if (!crypto_adapter_setup_done) 1488 return; 1489 1490 ret = rte_event_crypto_adapter_stop(TEST_ADAPTER_ID); 1491 if (ret < 0) 1492 RTE_LOG(ERR, USER1, "Failed to stop adapter!"); 1493 1494 ret = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 1495 TEST_CDEV_ID, TEST_CDEV_QP_ID); 1496 if (ret < 0) 1497 RTE_LOG(ERR, USER1, "Failed to delete queue pair!"); 1498 1499 ret = rte_event_crypto_adapter_free(TEST_ADAPTER_ID); 1500 if (ret < 0) 1501 RTE_LOG(ERR, USER1, "Failed to free adapter!"); 1502 1503 crypto_adapter_setup_done = 0; 1504 } 1505 1506 static void 1507 crypto_teardown(void) 1508 { 1509 /* Free mbuf mempool */ 1510 if (params.mbuf_pool != NULL) { 1511 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_MBUFPOOL count %u\n", 1512 rte_mempool_avail_count(params.mbuf_pool)); 1513 rte_mempool_free(params.mbuf_pool); 1514 params.mbuf_pool = NULL; 1515 } 1516 1517 /* Free session mempool */ 1518 if (params.session_mpool != NULL) { 1519 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_SESSION_MP count %u\n", 1520 rte_mempool_avail_count(params.session_mpool)); 1521 rte_mempool_free(params.session_mpool); 1522 params.session_mpool = NULL; 1523 } 1524 1525 /* Free asym session mempool */ 1526 if (params.asym_sess_mpool != NULL) { 1527 RTE_LOG(DEBUG, USER1, "CRYPTO_AD_ASYM_SESS_MP count %u\n", 1528 rte_mempool_avail_count(params.asym_sess_mpool)); 1529 rte_mempool_free(params.asym_sess_mpool); 1530 params.asym_sess_mpool = NULL; 1531 } 1532 /* Free asym ops mempool */ 1533 if (params.asym_op_mpool != NULL) { 1534 RTE_LOG(DEBUG, USER1, "EVENT_CRYPTO_ASYM_OP_POOL count %u\n", 1535 rte_mempool_avail_count(params.asym_op_mpool)); 1536 rte_mempool_free(params.asym_op_mpool); 1537 params.asym_op_mpool = NULL; 1538 } 1539 1540 /* Free ops mempool */ 1541 if (params.op_mpool != NULL) { 1542 RTE_LOG(DEBUG, USER1, "EVENT_CRYPTO_SYM_OP_POOL count %u\n", 1543 rte_mempool_avail_count(params.op_mpool)); 1544 rte_mempool_free(params.op_mpool); 1545 params.op_mpool = NULL; 1546 } 1547 } 1548 1549 static void 1550 eventdev_teardown(void) 1551 { 1552 rte_event_dev_stop(evdev); 1553 } 1554 1555 static void 1556 testsuite_teardown(void) 1557 { 1558 crypto_adapter_teardown(); 1559 crypto_teardown(); 1560 eventdev_teardown(); 1561 } 1562 1563 static struct unit_test_suite functional_testsuite = { 1564 .suite_name = "Event crypto adapter test suite", 1565 .setup = testsuite_setup, 1566 .teardown = testsuite_teardown, 1567 .unit_test_cases = { 1568 1569 TEST_CASE_ST(NULL, test_crypto_adapter_free, 1570 test_crypto_adapter_create), 1571 1572 TEST_CASE_ST(test_crypto_adapter_create, 1573 test_crypto_adapter_free, 1574 test_crypto_adapter_qp_add_del), 1575 1576 TEST_CASE_ST(test_crypto_adapter_create, 1577 test_crypto_adapter_free, 1578 test_crypto_adapter_stats), 1579 1580 TEST_CASE_ST(test_crypto_adapter_create, 1581 test_crypto_adapter_free, 1582 test_crypto_adapter_params), 1583 1584 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1585 test_crypto_adapter_stop, 1586 test_session_with_op_forward_mode), 1587 1588 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1589 test_crypto_adapter_stop, 1590 test_sessionless_with_op_forward_mode), 1591 1592 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1593 test_crypto_adapter_stop, 1594 test_session_with_op_new_mode), 1595 1596 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1597 test_crypto_adapter_stop, 1598 test_sessionless_with_op_new_mode), 1599 1600 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1601 test_crypto_adapter_stop, 1602 test_asym_session_with_op_forward_mode), 1603 1604 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1605 test_crypto_adapter_stop, 1606 test_asym_sessionless_with_op_forward_mode), 1607 1608 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1609 test_crypto_adapter_stop, 1610 test_asym_session_with_op_new_mode), 1611 1612 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1613 test_crypto_adapter_stop, 1614 test_asym_sessionless_with_op_new_mode), 1615 1616 TEST_CASES_END() /**< NULL terminate unit test array */ 1617 } 1618 }; 1619 1620 static int 1621 test_event_crypto_adapter(void) 1622 { 1623 return unit_test_suite_runner(&functional_testsuite); 1624 } 1625 1626 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1627 1628 REGISTER_TEST_COMMAND(event_crypto_adapter_autotest, 1629 test_event_crypto_adapter); 1630