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 (128) 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; 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 TEST_ASSERT_SUCCESS(err, "Failed to get adapter capabilities\n"); 288 289 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 290 err = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 291 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 292 } else 293 err = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 294 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 295 296 TEST_ASSERT_SUCCESS(err, "Failed to add queue pair\n"); 297 298 err = rte_event_crypto_adapter_runtime_params_init(&in_params); 299 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 300 err = rte_event_crypto_adapter_runtime_params_init(&out_params); 301 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 302 303 /* Case 1: Get the default value of mbufs processed by adapter */ 304 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 305 &out_params); 306 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 307 308 /* Case 2: Set max_nb = 32 (=BATCH_SEIZE) */ 309 in_params.max_nb = 32; 310 311 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 312 &in_params); 313 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 314 315 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 316 &out_params); 317 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 318 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 319 in_params.max_nb, out_params.max_nb); 320 321 /* Case 3: Set max_nb = 192 */ 322 in_params.max_nb = 192; 323 324 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 325 &in_params); 326 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 327 328 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 329 &out_params); 330 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 331 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 332 in_params.max_nb, out_params.max_nb); 333 334 /* Case 4: Set max_nb = 256 */ 335 in_params.max_nb = 256; 336 337 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 338 &in_params); 339 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 340 341 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 342 &out_params); 343 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 344 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 345 in_params.max_nb, out_params.max_nb); 346 347 /* Case 5: Set max_nb = 30(<BATCH_SIZE) */ 348 in_params.max_nb = 30; 349 350 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 351 &in_params); 352 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 353 354 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 355 &out_params); 356 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 357 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 358 in_params.max_nb, out_params.max_nb); 359 360 /* Case 6: Set max_nb = 512 */ 361 in_params.max_nb = 512; 362 363 err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, 364 &in_params); 365 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 366 367 err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, 368 &out_params); 369 TEST_ASSERT(err == 0, "Expected 0 got %d", err); 370 TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", 371 in_params.max_nb, out_params.max_nb); 372 373 err = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 374 TEST_CDEV_ID, TEST_CDEV_QP_ID); 375 TEST_ASSERT_SUCCESS(err, "Failed to delete add queue pair\n"); 376 377 return TEST_SUCCESS; 378 } 379 380 static int 381 test_op_forward_mode(uint8_t session_less) 382 { 383 struct rte_crypto_sym_xform cipher_xform; 384 union rte_event_crypto_metadata m_data; 385 struct rte_crypto_sym_op *sym_op; 386 struct rte_crypto_op *op; 387 struct rte_mbuf *m; 388 struct rte_event ev; 389 uint32_t cap; 390 void *sess; 391 int ret; 392 393 memset(&m_data, 0, sizeof(m_data)); 394 395 m = alloc_fill_mbuf(params.mbuf_pool, text_64B, PACKET_LENGTH, 0); 396 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf!\n"); 397 #if PKT_TRACE 398 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 399 #endif 400 /* Setup Cipher Parameters */ 401 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 402 cipher_xform.next = NULL; 403 cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 404 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 405 406 op = rte_crypto_op_alloc(params.op_mpool, 407 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 408 TEST_ASSERT_NOT_NULL(op, 409 "Failed to allocate symmetric crypto operation struct\n"); 410 411 sym_op = op->sym; 412 413 if (!session_less) { 414 sess = rte_cryptodev_sym_session_create(TEST_CDEV_ID, 415 &cipher_xform, params.session_mpool); 416 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 417 418 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 419 &cap); 420 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 421 422 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 423 /* Fill in private user data information */ 424 m_data.request_info.cdev_id = request_info.cdev_id; 425 m_data.request_info.queue_pair_id = 426 request_info.queue_pair_id; 427 m_data.response_info.event = response_info.event; 428 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 429 sess, RTE_CRYPTO_OP_TYPE_SYMMETRIC, 430 RTE_CRYPTO_OP_WITH_SESSION, 431 &m_data, sizeof(m_data)); 432 } 433 434 rte_crypto_op_attach_sym_session(op, sess); 435 } else { 436 struct rte_crypto_sym_xform *first_xform; 437 438 rte_crypto_op_sym_xforms_alloc(op, NUM); 439 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 440 first_xform = &cipher_xform; 441 sym_op->xform = first_xform; 442 uint32_t len = IV_OFFSET + MAXIMUM_IV_LENGTH; 443 op->private_data_offset = len; 444 /* Fill in private data information */ 445 m_data.request_info.cdev_id = request_info.cdev_id; 446 m_data.request_info.queue_pair_id = request_info.queue_pair_id; 447 m_data.response_info.event = response_info.event; 448 rte_memcpy((uint8_t *)op + len, &m_data, sizeof(m_data)); 449 } 450 451 sym_op->m_src = m; 452 sym_op->cipher.data.offset = 0; 453 sym_op->cipher.data.length = PACKET_LENGTH; 454 455 /* Fill in event info and update event_ptr with rte_crypto_op */ 456 memset(&ev, 0, sizeof(ev)); 457 ev.queue_id = TEST_CRYPTO_EV_QUEUE_ID; 458 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 459 ev.flow_id = 0xAABB; 460 ev.event_ptr = op; 461 462 ret = send_recv_ev(&ev); 463 TEST_ASSERT_SUCCESS(ret, "Failed to send/receive event to " 464 "crypto adapter\n"); 465 466 test_crypto_adapter_stats(); 467 468 return TEST_SUCCESS; 469 } 470 471 static int 472 map_adapter_service_core(void) 473 { 474 uint32_t adapter_service_id; 475 int ret; 476 477 if (rte_event_crypto_adapter_service_id_get(TEST_ADAPTER_ID, 478 &adapter_service_id) == 0) { 479 uint32_t core_list[NUM_CORES]; 480 481 ret = rte_service_lcore_list(core_list, NUM_CORES); 482 TEST_ASSERT(ret >= 0, "Failed to get service core list!"); 483 484 if (core_list[0] != slcore_id) { 485 TEST_ASSERT_SUCCESS(rte_service_lcore_add(slcore_id), 486 "Failed to add service core"); 487 TEST_ASSERT_SUCCESS(rte_service_lcore_start(slcore_id), 488 "Failed to start service core"); 489 } 490 491 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set( 492 adapter_service_id, slcore_id, 1), 493 "Failed to map adapter service"); 494 } 495 496 return TEST_SUCCESS; 497 } 498 499 static int 500 test_sessionless_with_op_forward_mode(void) 501 { 502 uint32_t cap; 503 int ret; 504 505 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 506 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 507 508 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 509 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 510 map_adapter_service_core(); 511 else { 512 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 513 return TEST_SKIPPED; 514 } 515 516 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 517 "Failed to start event crypto adapter"); 518 519 ret = test_op_forward_mode(1); 520 TEST_ASSERT_SUCCESS(ret, "Sessionless - FORWARD mode test failed\n"); 521 return TEST_SUCCESS; 522 } 523 524 static int 525 test_session_with_op_forward_mode(void) 526 { 527 uint32_t cap; 528 int ret; 529 530 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 531 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 532 533 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 534 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 535 map_adapter_service_core(); 536 else { 537 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 538 return TEST_SKIPPED; 539 } 540 541 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID 542 ), "Failed to start event crypto adapter"); 543 544 ret = test_op_forward_mode(0); 545 TEST_ASSERT_SUCCESS(ret, "Session based - FORWARD mode test failed\n"); 546 return TEST_SUCCESS; 547 } 548 549 static int 550 test_asym_op_forward_mode(uint8_t session_less) 551 { 552 const struct rte_cryptodev_asymmetric_xform_capability *capability; 553 struct rte_cryptodev_asym_capability_idx cap_idx; 554 struct rte_crypto_asym_xform xform_tc; 555 union rte_event_crypto_metadata m_data; 556 struct rte_cryptodev_info dev_info; 557 struct rte_crypto_asym_op *asym_op; 558 struct rte_crypto_op *op; 559 uint8_t input[4096] = {0}; 560 uint8_t *result = NULL; 561 struct rte_event ev; 562 void *sess = NULL; 563 uint32_t cap; 564 int ret; 565 566 memset(&m_data, 0, sizeof(m_data)); 567 568 rte_cryptodev_info_get(TEST_CDEV_ID, &dev_info); 569 if (session_less && !(dev_info.feature_flags & 570 RTE_CRYPTODEV_FF_ASYM_SESSIONLESS)) { 571 RTE_LOG(INFO, USER1, 572 "Device doesn't support Asym sessionless ops. Test Skipped\n"); 573 return TEST_SKIPPED; 574 } 575 /* Setup Cipher Parameters */ 576 xform_tc.next = NULL; 577 xform_tc.xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX; 578 cap_idx.type = xform_tc.xform_type; 579 capability = rte_cryptodev_asym_capability_get(TEST_CDEV_ID, &cap_idx); 580 581 if (capability == NULL) { 582 RTE_LOG(INFO, USER1, 583 "Device doesn't support MODEX. Test Skipped\n"); 584 return TEST_SKIPPED; 585 } 586 587 op = rte_crypto_op_alloc(params.asym_op_mpool, 588 RTE_CRYPTO_OP_TYPE_ASYMMETRIC); 589 TEST_ASSERT_NOT_NULL(op, 590 "Failed to allocate asymmetric crypto operation struct\n"); 591 592 asym_op = op->asym; 593 594 result = rte_zmalloc(NULL, modex_test_case.result_len, 0); 595 xform_tc.modex.modulus.data = modex_test_case.modulus.data; 596 xform_tc.modex.modulus.length = modex_test_case.modulus.len; 597 xform_tc.modex.exponent.data = modex_test_case.exponent.data; 598 xform_tc.modex.exponent.length = modex_test_case.exponent.len; 599 memcpy(input, modex_test_case.base.data, 600 modex_test_case.base.len); 601 asym_op->modex.base.data = input; 602 asym_op->modex.base.length = modex_test_case.base.len; 603 asym_op->modex.result.data = result; 604 asym_op->modex.result.length = modex_test_case.result_len; 605 if (rte_cryptodev_asym_xform_capability_check_modlen(capability, 606 xform_tc.modex.modulus.length)) { 607 RTE_LOG(INFO, USER1, 608 "line %u FAILED: %s", __LINE__, 609 "Invalid MODULUS length specified"); 610 return TEST_FAILED; 611 } 612 613 if (!session_less) { 614 /* Create Crypto session*/ 615 ret = rte_cryptodev_asym_session_create(TEST_CDEV_ID, 616 &xform_tc, params.asym_sess_mpool, &sess); 617 TEST_ASSERT_SUCCESS(ret, "Failed to init session\n"); 618 619 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 620 &cap); 621 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 622 623 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 624 /* Fill in private user data information */ 625 m_data.request_info.cdev_id = request_info.cdev_id; 626 m_data.request_info.queue_pair_id = 627 request_info.queue_pair_id; 628 m_data.response_info.event = response_info.event; 629 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 630 sess, RTE_CRYPTO_OP_TYPE_ASYMMETRIC, 631 RTE_CRYPTO_OP_WITH_SESSION, 632 &m_data, sizeof(m_data)); 633 } 634 635 rte_crypto_op_attach_asym_session(op, sess); 636 } else { 637 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 638 asym_op->xform = &xform_tc; 639 op->private_data_offset = (sizeof(struct rte_crypto_op) + 640 sizeof(struct rte_crypto_asym_op) + 641 DEFAULT_NUM_XFORMS * 642 sizeof(struct rte_crypto_asym_xform)); 643 /* Fill in private data information */ 644 m_data.request_info.cdev_id = request_info.cdev_id; 645 m_data.request_info.queue_pair_id = request_info.queue_pair_id; 646 m_data.response_info.event = response_info.event; 647 rte_memcpy((uint8_t *)op + op->private_data_offset, 648 &m_data, sizeof(m_data)); 649 } 650 /* Fill in event info and update event_ptr with rte_crypto_op */ 651 memset(&ev, 0, sizeof(ev)); 652 ev.queue_id = TEST_CRYPTO_EV_QUEUE_ID; 653 ev.sched_type = RTE_SCHED_TYPE_ATOMIC; 654 ev.flow_id = 0xAABB; 655 ev.event_ptr = op; 656 657 ret = send_recv_ev(&ev); 658 TEST_ASSERT_SUCCESS(ret, "Failed to send/receive event to " 659 "crypto adapter\n"); 660 661 test_crypto_adapter_stats(); 662 663 return TEST_SUCCESS; 664 } 665 666 667 static int 668 test_asym_sessionless_with_op_forward_mode(void) 669 { 670 uint32_t cap; 671 int ret; 672 673 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 674 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 675 676 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 677 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 678 map_adapter_service_core(); 679 else { 680 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 681 return TEST_SKIPPED; 682 } 683 684 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 685 "Failed to start event crypto adapter"); 686 687 return test_asym_op_forward_mode(1); 688 } 689 690 static int 691 test_asym_session_with_op_forward_mode(void) 692 { 693 uint32_t cap; 694 int ret; 695 696 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 697 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 698 699 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 700 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 701 map_adapter_service_core(); 702 else { 703 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD)) 704 return TEST_SKIPPED; 705 } 706 707 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID 708 ), "Failed to start event crypto adapter"); 709 710 return test_asym_op_forward_mode(0); 711 } 712 713 static int 714 send_op_recv_ev(struct rte_crypto_op *op) 715 { 716 struct rte_crypto_op *recv_op; 717 struct rte_event ev; 718 int ret; 719 720 ret = rte_cryptodev_enqueue_burst(TEST_CDEV_ID, TEST_CDEV_QP_ID, 721 &op, NUM); 722 TEST_ASSERT_EQUAL(ret, NUM, "Failed to enqueue to cryptodev\n"); 723 memset(&ev, 0, sizeof(ev)); 724 725 while (rte_event_dequeue_burst(evdev, 726 TEST_APP_PORT_ID, &ev, NUM, 0) == 0) 727 rte_pause(); 728 729 recv_op = ev.event_ptr; 730 if (recv_op->type == RTE_CRYPTO_OP_TYPE_SYMMETRIC) { 731 #if PKT_TRACE 732 struct rte_mbuf *m = recv_op->sym->m_src; 733 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 734 #endif 735 rte_pktmbuf_free(recv_op->sym->m_src); 736 } else { 737 uint8_t *data_expected = NULL, *data_received = NULL; 738 uint32_t data_size; 739 740 data_expected = modex_test_case.reminder.data; 741 data_received = op->asym->modex.result.data; 742 data_size = op->asym->modex.result.length; 743 ret = memcmp(data_expected, data_received, data_size); 744 TEST_ASSERT_EQUAL(ret, 0, 745 "Data mismatch for asym crypto adapter\n"); 746 rte_free(op->asym->modex.result.data); 747 } 748 rte_crypto_op_free(recv_op); 749 750 return TEST_SUCCESS; 751 } 752 753 static int 754 test_op_new_mode(uint8_t session_less) 755 { 756 struct rte_crypto_sym_xform cipher_xform; 757 union rte_event_crypto_metadata m_data; 758 struct rte_crypto_sym_op *sym_op; 759 struct rte_crypto_op *op; 760 struct rte_mbuf *m; 761 uint32_t cap; 762 void *sess; 763 int ret; 764 765 memset(&m_data, 0, sizeof(m_data)); 766 767 m = alloc_fill_mbuf(params.mbuf_pool, text_64B, PACKET_LENGTH, 0); 768 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf!\n"); 769 #if PKT_TRACE 770 rte_pktmbuf_dump(stdout, m, rte_pktmbuf_pkt_len(m)); 771 #endif 772 /* Setup Cipher Parameters */ 773 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 774 cipher_xform.next = NULL; 775 cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 776 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 777 778 op = rte_crypto_op_alloc(params.op_mpool, 779 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 780 TEST_ASSERT_NOT_NULL(op, "Failed to allocate crypto_op!\n"); 781 782 sym_op = op->sym; 783 784 if (!session_less) { 785 sess = rte_cryptodev_sym_session_create(TEST_CDEV_ID, 786 &cipher_xform, params.session_mpool); 787 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 788 789 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 790 &cap); 791 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 792 793 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 794 /* Fill in private user data information */ 795 m_data.response_info.event = response_info.event; 796 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 797 sess, RTE_CRYPTO_OP_TYPE_SYMMETRIC, 798 RTE_CRYPTO_OP_WITH_SESSION, 799 &m_data, sizeof(m_data)); 800 } 801 802 rte_crypto_op_attach_sym_session(op, sess); 803 } else { 804 struct rte_crypto_sym_xform *first_xform; 805 806 rte_crypto_op_sym_xforms_alloc(op, NUM); 807 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 808 first_xform = &cipher_xform; 809 sym_op->xform = first_xform; 810 uint32_t len = IV_OFFSET + MAXIMUM_IV_LENGTH; 811 op->private_data_offset = len; 812 /* Fill in private data information */ 813 m_data.response_info.event = response_info.event; 814 rte_memcpy((uint8_t *)op + len, &m_data, sizeof(m_data)); 815 } 816 817 sym_op->m_src = m; 818 sym_op->cipher.data.offset = 0; 819 sym_op->cipher.data.length = PACKET_LENGTH; 820 821 ret = send_op_recv_ev(op); 822 TEST_ASSERT_SUCCESS(ret, "Failed to enqueue op to cryptodev\n"); 823 824 test_crypto_adapter_stats(); 825 826 return TEST_SUCCESS; 827 } 828 829 static int 830 test_sessionless_with_op_new_mode(void) 831 { 832 uint32_t cap; 833 int ret; 834 835 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 836 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 837 838 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 839 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 840 map_adapter_service_core(); 841 else { 842 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 843 return TEST_SKIPPED; 844 } 845 846 /* start the event crypto adapter */ 847 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 848 "Failed to start event crypto adapter"); 849 850 ret = test_op_new_mode(1); 851 TEST_ASSERT_SUCCESS(ret, "Sessionless - NEW mode test failed\n"); 852 return TEST_SUCCESS; 853 } 854 855 static int 856 test_session_with_op_new_mode(void) 857 { 858 uint32_t cap; 859 int ret; 860 861 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 862 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 863 864 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 865 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 866 map_adapter_service_core(); 867 else { 868 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 869 return TEST_SKIPPED; 870 } 871 872 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 873 "Failed to start event crypto adapter"); 874 875 ret = test_op_new_mode(0); 876 TEST_ASSERT_SUCCESS(ret, "Session based - NEW mode test failed\n"); 877 return TEST_SUCCESS; 878 } 879 880 static int 881 test_asym_op_new_mode(uint8_t session_less) 882 { 883 const struct rte_cryptodev_asymmetric_xform_capability *capability; 884 struct rte_cryptodev_asym_capability_idx cap_idx; 885 struct rte_crypto_asym_xform xform_tc; 886 union rte_event_crypto_metadata m_data; 887 struct rte_cryptodev_info dev_info; 888 struct rte_crypto_asym_op *asym_op; 889 struct rte_crypto_op *op; 890 uint8_t input[4096] = {0}; 891 uint8_t *result = NULL; 892 void *sess = NULL; 893 uint32_t cap; 894 int ret; 895 896 memset(&m_data, 0, sizeof(m_data)); 897 898 rte_cryptodev_info_get(TEST_CDEV_ID, &dev_info); 899 if (session_less && !(dev_info.feature_flags & 900 RTE_CRYPTODEV_FF_ASYM_SESSIONLESS)) { 901 RTE_LOG(INFO, USER1, 902 "Device doesn't support Asym sessionless ops. Test Skipped\n"); 903 return TEST_SKIPPED; 904 } 905 /* Setup Cipher Parameters */ 906 xform_tc.next = NULL; 907 xform_tc.xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX; 908 cap_idx.type = xform_tc.xform_type; 909 capability = rte_cryptodev_asym_capability_get(TEST_CDEV_ID, &cap_idx); 910 911 if (capability == NULL) { 912 RTE_LOG(INFO, USER1, 913 "Device doesn't support MODEX. Test Skipped\n"); 914 return TEST_SKIPPED; 915 } 916 917 op = rte_crypto_op_alloc(params.asym_op_mpool, 918 RTE_CRYPTO_OP_TYPE_ASYMMETRIC); 919 TEST_ASSERT_NOT_NULL(op, "Failed to allocate asym crypto_op!\n"); 920 921 asym_op = op->asym; 922 923 result = rte_zmalloc(NULL, modex_test_case.result_len, 0); 924 xform_tc.modex.modulus.data = modex_test_case.modulus.data; 925 xform_tc.modex.modulus.length = modex_test_case.modulus.len; 926 xform_tc.modex.exponent.data = modex_test_case.exponent.data; 927 xform_tc.modex.exponent.length = modex_test_case.exponent.len; 928 memcpy(input, modex_test_case.base.data, 929 modex_test_case.base.len); 930 asym_op->modex.base.data = input; 931 asym_op->modex.base.length = modex_test_case.base.len; 932 asym_op->modex.result.data = result; 933 asym_op->modex.result.length = modex_test_case.result_len; 934 if (rte_cryptodev_asym_xform_capability_check_modlen(capability, 935 xform_tc.modex.modulus.length)) { 936 RTE_LOG(INFO, USER1, 937 "line %u FAILED: %s", __LINE__, 938 "Invalid MODULUS length specified"); 939 return TEST_FAILED; 940 } 941 942 if (!session_less) { 943 ret = rte_cryptodev_asym_session_create(TEST_CDEV_ID, 944 &xform_tc, params.asym_sess_mpool, &sess); 945 TEST_ASSERT_NOT_NULL(sess, "Session creation failed\n"); 946 TEST_ASSERT_SUCCESS(ret, "Failed to init session\n"); 947 948 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, 949 &cap); 950 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 951 952 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA) { 953 /* Fill in private user data information */ 954 m_data.response_info.event = response_info.event; 955 rte_cryptodev_session_event_mdata_set(TEST_CDEV_ID, 956 sess, RTE_CRYPTO_OP_TYPE_ASYMMETRIC, 957 RTE_CRYPTO_OP_WITH_SESSION, 958 &m_data, sizeof(m_data)); 959 } 960 961 rte_crypto_op_attach_asym_session(op, sess); 962 } else { 963 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS; 964 asym_op->xform = &xform_tc; 965 op->private_data_offset = (sizeof(struct rte_crypto_op) + 966 sizeof(struct rte_crypto_asym_op) + 967 DEFAULT_NUM_XFORMS * 968 sizeof(struct rte_crypto_asym_xform)); 969 /* Fill in private data information */ 970 m_data.response_info.event = response_info.event; 971 rte_memcpy((uint8_t *)op + op->private_data_offset, 972 &m_data, sizeof(m_data)); 973 } 974 975 ret = send_op_recv_ev(op); 976 TEST_ASSERT_SUCCESS(ret, "Failed to enqueue op to cryptodev\n"); 977 978 test_crypto_adapter_stats(); 979 980 return TEST_SUCCESS; 981 } 982 983 static int 984 test_asym_sessionless_with_op_new_mode(void) 985 { 986 uint32_t cap; 987 int ret; 988 989 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 990 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 991 992 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 993 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 994 map_adapter_service_core(); 995 else { 996 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 997 return TEST_SKIPPED; 998 } 999 1000 /* start the event crypto adapter */ 1001 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 1002 "Failed to start event crypto adapter"); 1003 1004 return test_asym_op_new_mode(1); 1005 } 1006 1007 static int 1008 test_asym_session_with_op_new_mode(void) 1009 { 1010 uint32_t cap; 1011 int ret; 1012 1013 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1014 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1015 1016 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 1017 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1018 map_adapter_service_core(); 1019 else { 1020 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1021 return TEST_SKIPPED; 1022 } 1023 1024 TEST_ASSERT_SUCCESS(rte_event_crypto_adapter_start(TEST_ADAPTER_ID), 1025 "Failed to start event crypto adapter"); 1026 1027 return test_asym_op_new_mode(0); 1028 } 1029 1030 static int 1031 configure_cryptodev(void) 1032 { 1033 const struct rte_cryptodev_capabilities *capability; 1034 struct rte_cryptodev_qp_conf qp_conf; 1035 struct rte_cryptodev_config conf; 1036 struct rte_cryptodev_info info; 1037 unsigned int session_size; 1038 unsigned int i = 0; 1039 uint8_t nb_devs; 1040 int ret; 1041 1042 1043 params.mbuf_pool = rte_pktmbuf_pool_create( 1044 "CRYPTO_ADAPTER_MBUFPOOL", 1045 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 1046 rte_socket_id()); 1047 if (params.mbuf_pool == NULL) { 1048 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n"); 1049 return TEST_FAILED; 1050 } 1051 1052 params.op_mpool = rte_crypto_op_pool_create( 1053 "EVENT_CRYPTO_SYM_OP_POOL", 1054 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 1055 NUM_MBUFS, MBUF_CACHE_SIZE, 1056 DEFAULT_NUM_XFORMS * 1057 sizeof(struct rte_crypto_sym_xform) + 1058 MAXIMUM_IV_LENGTH + 1059 sizeof(union rte_event_crypto_metadata), 1060 rte_socket_id()); 1061 if (params.op_mpool == NULL) { 1062 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); 1063 return TEST_FAILED; 1064 } 1065 1066 /* Create a NULL crypto device */ 1067 nb_devs = rte_cryptodev_device_count_by_driver( 1068 rte_cryptodev_driver_id_get( 1069 RTE_STR(CRYPTODEV_NAME_NULL_PMD))); 1070 if (!nb_devs) { 1071 ret = rte_vdev_init( 1072 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); 1073 1074 TEST_ASSERT(ret == 0, "Failed to create pmd:%s instance\n", 1075 RTE_STR(CRYPTODEV_NAME_NULL_PMD)); 1076 } 1077 1078 nb_devs = rte_cryptodev_count(); 1079 if (!nb_devs) { 1080 RTE_LOG(ERR, USER1, "No crypto devices found!\n"); 1081 return TEST_FAILED; 1082 } 1083 1084 /* 1085 * Create mempool with maximum number of sessions * 2, 1086 * to include the session headers & private data 1087 */ 1088 session_size = rte_cryptodev_sym_get_private_session_size(TEST_CDEV_ID); 1089 session_size += sizeof(union rte_event_crypto_metadata); 1090 1091 params.session_mpool = rte_cryptodev_sym_session_pool_create( 1092 "CRYPTO_ADAPTER_SESSION_MP", 1093 MAX_NB_SESSIONS, session_size, 0, 1094 sizeof(union rte_event_crypto_metadata), 1095 SOCKET_ID_ANY); 1096 TEST_ASSERT_NOT_NULL(params.session_mpool, 1097 "session mempool allocation failed\n"); 1098 1099 rte_cryptodev_info_get(TEST_CDEV_ID, &info); 1100 1101 while ((capability = &info.capabilities[i++])->op != 1102 RTE_CRYPTO_OP_TYPE_UNDEFINED) { 1103 if (capability->op == RTE_CRYPTO_OP_TYPE_ASYMMETRIC) { 1104 params.asym_op_mpool = rte_crypto_op_pool_create( 1105 "EVENT_CRYPTO_ASYM_OP_POOL", 1106 RTE_CRYPTO_OP_TYPE_ASYMMETRIC, 1107 NUM_MBUFS, MBUF_CACHE_SIZE, 1108 (DEFAULT_NUM_XFORMS * 1109 sizeof(struct rte_crypto_asym_xform)) + 1110 sizeof(union rte_event_crypto_metadata), 1111 rte_socket_id()); 1112 TEST_ASSERT_NOT_NULL(params.asym_op_mpool, 1113 "Can't create CRYPTO_ASYM_OP_POOL\n"); 1114 1115 params.asym_sess_mpool = 1116 rte_cryptodev_asym_session_pool_create( 1117 "CRYPTO_AD_ASYM_SESS_MP", 1118 MAX_NB_SESSIONS, 0, 1119 sizeof(union rte_event_crypto_metadata), 1120 SOCKET_ID_ANY); 1121 TEST_ASSERT_NOT_NULL(params.asym_sess_mpool, 1122 "asym session mempool allocation failed\n"); 1123 break; 1124 } 1125 } 1126 1127 conf.nb_queue_pairs = info.max_nb_queue_pairs; 1128 conf.socket_id = SOCKET_ID_ANY; 1129 conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY; 1130 1131 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(TEST_CDEV_ID, &conf), 1132 "Failed to configure cryptodev %u with %u qps\n", 1133 TEST_CDEV_ID, conf.nb_queue_pairs); 1134 1135 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 1136 qp_conf.mp_session = params.session_mpool; 1137 1138 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 1139 TEST_CDEV_ID, TEST_CDEV_QP_ID, &qp_conf, 1140 rte_cryptodev_socket_id(TEST_CDEV_ID)), 1141 "Failed to setup queue pair %u on cryptodev %u\n", 1142 TEST_CDEV_QP_ID, TEST_CDEV_ID); 1143 1144 return TEST_SUCCESS; 1145 } 1146 1147 static inline void 1148 evdev_set_conf_values(struct rte_event_dev_config *dev_conf, 1149 struct rte_event_dev_info *info) 1150 { 1151 memset(dev_conf, 0, sizeof(struct rte_event_dev_config)); 1152 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns; 1153 dev_conf->nb_event_ports = NB_TEST_PORTS; 1154 dev_conf->nb_event_queues = NB_TEST_QUEUES; 1155 dev_conf->nb_event_queue_flows = info->max_event_queue_flows; 1156 dev_conf->nb_event_port_dequeue_depth = 1157 info->max_event_port_dequeue_depth; 1158 dev_conf->nb_event_port_enqueue_depth = 1159 info->max_event_port_enqueue_depth; 1160 dev_conf->nb_event_port_enqueue_depth = 1161 info->max_event_port_enqueue_depth; 1162 dev_conf->nb_events_limit = 1163 info->max_num_events; 1164 } 1165 1166 static int 1167 configure_eventdev(void) 1168 { 1169 struct rte_event_queue_conf queue_conf; 1170 struct rte_event_dev_config devconf; 1171 struct rte_event_dev_info info; 1172 uint32_t queue_count; 1173 uint32_t port_count; 1174 int ret; 1175 uint8_t qid; 1176 1177 if (!rte_event_dev_count()) { 1178 /* If there is no hardware eventdev, or no software vdev was 1179 * specified on the command line, create an instance of 1180 * event_sw. 1181 */ 1182 LOG_DBG("Failed to find a valid event device... " 1183 "testing with event_sw device\n"); 1184 TEST_ASSERT_SUCCESS(rte_vdev_init("event_sw0", NULL), 1185 "Error creating eventdev"); 1186 evdev = rte_event_dev_get_dev_id("event_sw0"); 1187 } 1188 1189 ret = rte_event_dev_info_get(evdev, &info); 1190 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info\n"); 1191 1192 evdev_set_conf_values(&devconf, &info); 1193 1194 ret = rte_event_dev_configure(evdev, &devconf); 1195 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev\n"); 1196 1197 /* Set up event queue */ 1198 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_QUEUE_COUNT, 1199 &queue_count); 1200 TEST_ASSERT_SUCCESS(ret, "Queue count get failed\n"); 1201 TEST_ASSERT_EQUAL(queue_count, 2, "Unexpected queue count\n"); 1202 1203 qid = TEST_APP_EV_QUEUE_ID; 1204 ret = rte_event_queue_setup(evdev, qid, NULL); 1205 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d\n", qid); 1206 1207 queue_conf.nb_atomic_flows = info.max_event_queue_flows; 1208 queue_conf.nb_atomic_order_sequences = 32; 1209 queue_conf.schedule_type = RTE_SCHED_TYPE_ATOMIC; 1210 queue_conf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST; 1211 queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK; 1212 1213 qid = TEST_CRYPTO_EV_QUEUE_ID; 1214 ret = rte_event_queue_setup(evdev, qid, &queue_conf); 1215 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%u\n", qid); 1216 1217 /* Set up event port */ 1218 ret = rte_event_dev_attr_get(evdev, RTE_EVENT_DEV_ATTR_PORT_COUNT, 1219 &port_count); 1220 TEST_ASSERT_SUCCESS(ret, "Port count get failed\n"); 1221 TEST_ASSERT_EQUAL(port_count, 1, "Unexpected port count\n"); 1222 1223 ret = rte_event_port_setup(evdev, TEST_APP_PORT_ID, NULL); 1224 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d\n", 1225 TEST_APP_PORT_ID); 1226 1227 qid = TEST_APP_EV_QUEUE_ID; 1228 ret = rte_event_port_link(evdev, TEST_APP_PORT_ID, &qid, NULL, 1); 1229 TEST_ASSERT(ret >= 0, "Failed to link queue port=%d\n", 1230 TEST_APP_PORT_ID); 1231 1232 return TEST_SUCCESS; 1233 } 1234 1235 static void 1236 test_crypto_adapter_free(void) 1237 { 1238 rte_event_crypto_adapter_free(TEST_ADAPTER_ID); 1239 } 1240 1241 static int 1242 test_crypto_adapter_create(void) 1243 { 1244 struct rte_event_port_conf conf = { 1245 .dequeue_depth = 8, 1246 .enqueue_depth = 8, 1247 .new_event_threshold = 1200, 1248 }; 1249 int ret; 1250 1251 /* Create adapter with default port creation callback */ 1252 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 1253 evdev, 1254 &conf, 0); 1255 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 1256 1257 return TEST_SUCCESS; 1258 } 1259 1260 static int 1261 test_crypto_adapter_qp_add_del(void) 1262 { 1263 struct rte_event_crypto_adapter_queue_conf queue_conf = { 1264 .ev = response_info, 1265 }; 1266 1267 uint32_t cap; 1268 int ret; 1269 1270 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1271 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1272 1273 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 1274 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1275 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 1276 } else 1277 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1278 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 1279 1280 TEST_ASSERT_SUCCESS(ret, "Failed to create add queue pair\n"); 1281 1282 ret = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 1283 TEST_CDEV_ID, TEST_CDEV_QP_ID); 1284 TEST_ASSERT_SUCCESS(ret, "Failed to delete add queue pair\n"); 1285 1286 return TEST_SUCCESS; 1287 } 1288 1289 static int 1290 configure_event_crypto_adapter(enum rte_event_crypto_adapter_mode mode) 1291 { 1292 struct rte_event_port_conf conf = { 1293 .dequeue_depth = 8, 1294 .enqueue_depth = 8, 1295 .new_event_threshold = 1200, 1296 }; 1297 1298 struct rte_event_crypto_adapter_queue_conf queue_conf = { 1299 .ev = response_info, 1300 }; 1301 1302 uint32_t cap; 1303 int ret; 1304 1305 ret = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); 1306 TEST_ASSERT_SUCCESS(ret, "Failed to get adapter capabilities\n"); 1307 1308 /* Skip mode and capability mismatch check for SW eventdev */ 1309 if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW) && 1310 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) && 1311 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND)) 1312 goto adapter_create; 1313 1314 if (mode == RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) { 1315 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) 1316 params.internal_port_op_fwd = 1; 1317 else 1318 return -ENOTSUP; 1319 } 1320 1321 if ((mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) && 1322 !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) 1323 return -ENOTSUP; 1324 1325 adapter_create: 1326 /* Create adapter with default port creation callback */ 1327 ret = rte_event_crypto_adapter_create(TEST_ADAPTER_ID, 1328 evdev, 1329 &conf, mode); 1330 TEST_ASSERT_SUCCESS(ret, "Failed to create event crypto adapter\n"); 1331 1332 if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { 1333 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1334 TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); 1335 } else 1336 ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, 1337 TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); 1338 1339 TEST_ASSERT_SUCCESS(ret, "Failed to add queue pair\n"); 1340 1341 if (!params.internal_port_op_fwd) { 1342 ret = rte_event_crypto_adapter_event_port_get(TEST_ADAPTER_ID, 1343 ¶ms.crypto_event_port_id); 1344 TEST_ASSERT_SUCCESS(ret, "Failed to get event port\n"); 1345 } 1346 1347 return TEST_SUCCESS; 1348 } 1349 1350 static void 1351 test_crypto_adapter_stop(void) 1352 { 1353 uint32_t evdev_service_id, adapter_service_id; 1354 1355 /* retrieve service ids & stop services */ 1356 if (rte_event_crypto_adapter_service_id_get(TEST_ADAPTER_ID, 1357 &adapter_service_id) == 0) { 1358 rte_service_runstate_set(adapter_service_id, 0); 1359 rte_service_lcore_stop(slcore_id); 1360 rte_service_lcore_del(slcore_id); 1361 rte_event_crypto_adapter_stop(TEST_ADAPTER_ID); 1362 } 1363 1364 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 1365 rte_service_runstate_set(evdev_service_id, 0); 1366 rte_service_lcore_stop(slcore_id); 1367 rte_service_lcore_del(slcore_id); 1368 rte_cryptodev_stop(TEST_CDEV_ID); 1369 rte_event_dev_stop(evdev); 1370 } else { 1371 rte_cryptodev_stop(TEST_CDEV_ID); 1372 rte_event_dev_stop(evdev); 1373 } 1374 } 1375 1376 static int 1377 test_crypto_adapter_conf(enum rte_event_crypto_adapter_mode mode) 1378 { 1379 uint32_t evdev_service_id; 1380 uint8_t qid; 1381 int ret; 1382 1383 if (!crypto_adapter_setup_done) { 1384 ret = configure_event_crypto_adapter(mode); 1385 if (ret) 1386 return ret; 1387 if (!params.internal_port_op_fwd) { 1388 qid = TEST_CRYPTO_EV_QUEUE_ID; 1389 ret = rte_event_port_link(evdev, 1390 params.crypto_event_port_id, &qid, NULL, 1); 1391 TEST_ASSERT(ret >= 0, "Failed to link queue %d " 1392 "port=%u\n", qid, 1393 params.crypto_event_port_id); 1394 } 1395 crypto_adapter_setup_done = 1; 1396 } 1397 1398 /* retrieve service ids */ 1399 if (rte_event_dev_service_id_get(evdev, &evdev_service_id) == 0) { 1400 /* add a service core and start it */ 1401 TEST_ASSERT_SUCCESS(rte_service_lcore_add(slcore_id), 1402 "Failed to add service core"); 1403 TEST_ASSERT_SUCCESS(rte_service_lcore_start(slcore_id), 1404 "Failed to start service core"); 1405 1406 /* map services to it */ 1407 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(evdev_service_id, 1408 slcore_id, 1), "Failed to map evdev service"); 1409 1410 /* set services to running */ 1411 TEST_ASSERT_SUCCESS(rte_service_runstate_set(evdev_service_id, 1412 1), "Failed to start evdev service"); 1413 } 1414 1415 /* start the eventdev */ 1416 TEST_ASSERT_SUCCESS(rte_event_dev_start(evdev), 1417 "Failed to start event device"); 1418 1419 /* start the cryptodev */ 1420 TEST_ASSERT_SUCCESS(rte_cryptodev_start(TEST_CDEV_ID), 1421 "Failed to start crypto device"); 1422 1423 return TEST_SUCCESS; 1424 } 1425 1426 static int 1427 test_crypto_adapter_conf_op_forward_mode(void) 1428 { 1429 enum rte_event_crypto_adapter_mode mode; 1430 1431 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD; 1432 1433 return test_crypto_adapter_conf(mode); 1434 } 1435 1436 static int 1437 test_crypto_adapter_conf_op_new_mode(void) 1438 { 1439 enum rte_event_crypto_adapter_mode mode; 1440 1441 mode = RTE_EVENT_CRYPTO_ADAPTER_OP_NEW; 1442 1443 return test_crypto_adapter_conf(mode); 1444 } 1445 1446 1447 static int 1448 testsuite_setup(void) 1449 { 1450 int ret; 1451 1452 slcore_id = rte_get_next_lcore(-1, 1, 0); 1453 TEST_ASSERT_NOT_EQUAL(slcore_id, RTE_MAX_LCORE, "At least 2 lcores " 1454 "are required to run this autotest\n"); 1455 1456 /* Setup and start event device. */ 1457 ret = configure_eventdev(); 1458 TEST_ASSERT_SUCCESS(ret, "Failed to setup eventdev\n"); 1459 1460 /* Setup and start crypto device. */ 1461 ret = configure_cryptodev(); 1462 TEST_ASSERT_SUCCESS(ret, "cryptodev initialization failed\n"); 1463 1464 return TEST_SUCCESS; 1465 } 1466 1467 static void 1468 crypto_adapter_teardown(void) 1469 { 1470 int ret; 1471 1472 ret = rte_event_crypto_adapter_stop(TEST_ADAPTER_ID); 1473 if (ret < 0) 1474 RTE_LOG(ERR, USER1, "Failed to stop adapter!"); 1475 1476 ret = rte_event_crypto_adapter_queue_pair_del(TEST_ADAPTER_ID, 1477 TEST_CDEV_ID, TEST_CDEV_QP_ID); 1478 if (ret < 0) 1479 RTE_LOG(ERR, USER1, "Failed to delete queue pair!"); 1480 1481 ret = rte_event_crypto_adapter_free(TEST_ADAPTER_ID); 1482 if (ret < 0) 1483 RTE_LOG(ERR, USER1, "Failed to free adapter!"); 1484 1485 crypto_adapter_setup_done = 0; 1486 } 1487 1488 static void 1489 crypto_teardown(void) 1490 { 1491 /* Free mbuf mempool */ 1492 if (params.mbuf_pool != NULL) { 1493 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_MBUFPOOL count %u\n", 1494 rte_mempool_avail_count(params.mbuf_pool)); 1495 rte_mempool_free(params.mbuf_pool); 1496 params.mbuf_pool = NULL; 1497 } 1498 1499 /* Free session mempool */ 1500 if (params.session_mpool != NULL) { 1501 RTE_LOG(DEBUG, USER1, "CRYPTO_ADAPTER_SESSION_MP count %u\n", 1502 rte_mempool_avail_count(params.session_mpool)); 1503 rte_mempool_free(params.session_mpool); 1504 params.session_mpool = NULL; 1505 } 1506 1507 /* Free asym session mempool */ 1508 if (params.asym_sess_mpool != NULL) { 1509 RTE_LOG(DEBUG, USER1, "CRYPTO_AD_ASYM_SESS_MP count %u\n", 1510 rte_mempool_avail_count(params.asym_sess_mpool)); 1511 rte_mempool_free(params.asym_sess_mpool); 1512 params.asym_sess_mpool = NULL; 1513 } 1514 /* Free asym ops mempool */ 1515 if (params.asym_op_mpool != NULL) { 1516 RTE_LOG(DEBUG, USER1, "EVENT_CRYPTO_ASYM_OP_POOL count %u\n", 1517 rte_mempool_avail_count(params.asym_op_mpool)); 1518 rte_mempool_free(params.asym_op_mpool); 1519 params.asym_op_mpool = NULL; 1520 } 1521 1522 /* Free ops mempool */ 1523 if (params.op_mpool != NULL) { 1524 RTE_LOG(DEBUG, USER1, "EVENT_CRYPTO_SYM_OP_POOL count %u\n", 1525 rte_mempool_avail_count(params.op_mpool)); 1526 rte_mempool_free(params.op_mpool); 1527 params.op_mpool = NULL; 1528 } 1529 } 1530 1531 static void 1532 eventdev_teardown(void) 1533 { 1534 rte_event_dev_stop(evdev); 1535 } 1536 1537 static void 1538 testsuite_teardown(void) 1539 { 1540 crypto_adapter_teardown(); 1541 crypto_teardown(); 1542 eventdev_teardown(); 1543 } 1544 1545 static struct unit_test_suite functional_testsuite = { 1546 .suite_name = "Event crypto adapter test suite", 1547 .setup = testsuite_setup, 1548 .teardown = testsuite_teardown, 1549 .unit_test_cases = { 1550 1551 TEST_CASE_ST(NULL, test_crypto_adapter_free, 1552 test_crypto_adapter_create), 1553 1554 TEST_CASE_ST(test_crypto_adapter_create, 1555 test_crypto_adapter_free, 1556 test_crypto_adapter_qp_add_del), 1557 1558 TEST_CASE_ST(test_crypto_adapter_create, 1559 test_crypto_adapter_free, 1560 test_crypto_adapter_stats), 1561 1562 TEST_CASE_ST(test_crypto_adapter_create, 1563 test_crypto_adapter_free, 1564 test_crypto_adapter_params), 1565 1566 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1567 test_crypto_adapter_stop, 1568 test_session_with_op_forward_mode), 1569 1570 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1571 test_crypto_adapter_stop, 1572 test_sessionless_with_op_forward_mode), 1573 1574 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1575 test_crypto_adapter_stop, 1576 test_session_with_op_new_mode), 1577 1578 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1579 test_crypto_adapter_stop, 1580 test_sessionless_with_op_new_mode), 1581 1582 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1583 test_crypto_adapter_stop, 1584 test_asym_session_with_op_forward_mode), 1585 1586 TEST_CASE_ST(test_crypto_adapter_conf_op_forward_mode, 1587 test_crypto_adapter_stop, 1588 test_asym_sessionless_with_op_forward_mode), 1589 1590 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1591 test_crypto_adapter_stop, 1592 test_asym_session_with_op_new_mode), 1593 1594 TEST_CASE_ST(test_crypto_adapter_conf_op_new_mode, 1595 test_crypto_adapter_stop, 1596 test_asym_sessionless_with_op_new_mode), 1597 1598 TEST_CASES_END() /**< NULL terminate unit test array */ 1599 } 1600 }; 1601 1602 static int 1603 test_event_crypto_adapter(void) 1604 { 1605 return unit_test_suite_runner(&functional_testsuite); 1606 } 1607 1608 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1609 1610 REGISTER_TEST_COMMAND(event_crypto_adapter_autotest, 1611 test_event_crypto_adapter); 1612