void odp_event_free(odp_event_t event)
{
switch (odp_event_type(event)) {
case ODP_EVENT_BUFFER:
odp_buffer_free(odp_buffer_from_event(event));
break;
case ODP_EVENT_PACKET:
odp_packet_free(odp_packet_from_event(event));
break;
case ODP_EVENT_TIMEOUT:
odp_timeout_free(odp_timeout_from_event(event));
break;
case ODP_EVENT_CRYPTO_COMPL:
odp_crypto_compl_free(odp_crypto_compl_from_event(event));
break;
default:
ODP_ABORT("Invalid event type: %d\n", odp_event_type(event));
}
}
static void schedule_shutdown(void)
{
odp_event_t evt;
odp_queue_t from;
while (1) {
evt = odp_schedule(&from, ODP_SCHED_NO_WAIT);
if (evt == ODP_EVENT_INVALID)
break;
switch (odp_event_type(evt)) {
case ODP_EVENT_TIMEOUT:
{
ofp_timer_evt_cleanup(evt);
break;
}
case ODP_EVENT_PACKET:
{
odp_packet_free(odp_packet_from_event(evt));
break;
}
case ODP_EVENT_BUFFER:
{
odp_buffer_free(odp_buffer_from_event(evt));
break;
}
case ODP_EVENT_CRYPTO_COMPL:
{
odp_crypto_compl_free(
odp_crypto_compl_from_event(evt));
break;
}
}
}
odp_schedule_pause();
}
/* Basic algorithm run function for async inplace mode.
* Creates a session from input parameters and runs one operation
* on input_vec. Checks the output of the crypto operation against
* output_vec. Operation completion event is dequeued polling the
* session output queue. Completion context pointer is retrieved
* and checked against the one set before the operation.
* Completion event can be a separate buffer or the input packet
* buffer can be used.
* */
static void alg_test(enum odp_crypto_op op,
enum odp_cipher_alg cipher_alg,
odp_crypto_iv_t ses_iv,
uint8_t *op_iv_ptr,
odp_crypto_key_t cipher_key,
enum odp_auth_alg auth_alg,
odp_crypto_key_t auth_key,
uint8_t *input_vec,
unsigned int input_vec_len,
uint8_t *output_vec,
unsigned int output_vec_len)
{
odp_crypto_session_t session;
int rc;
enum odp_crypto_ses_create_err status;
odp_bool_t posted;
odp_event_t event;
odp_crypto_compl_t compl_event;
odp_crypto_op_result_t result;
/* Create a crypto session */
odp_crypto_session_params_t ses_params;
memset(&ses_params, 0, sizeof(ses_params));
ses_params.op = op;
ses_params.auth_cipher_text = false;
ses_params.pref_mode = suite_context.pref_mode;
ses_params.cipher_alg = cipher_alg;
ses_params.auth_alg = auth_alg;
ses_params.compl_queue = suite_context.queue;
ses_params.output_pool = suite_context.pool;
ses_params.cipher_key = cipher_key;
ses_params.iv = ses_iv;
ses_params.auth_key = auth_key;
rc = odp_crypto_session_create(&ses_params, &session, &status);
CU_ASSERT(!rc);
CU_ASSERT(status == ODP_CRYPTO_SES_CREATE_ERR_NONE);
CU_ASSERT(odp_crypto_session_to_u64(session) !=
odp_crypto_session_to_u64(ODP_CRYPTO_SESSION_INVALID));
/* Prepare input data */
odp_packet_t pkt = odp_packet_alloc(suite_context.pool, input_vec_len);
CU_ASSERT(pkt != ODP_PACKET_INVALID);
uint8_t *data_addr = odp_packet_data(pkt);
memcpy(data_addr, input_vec, input_vec_len);
const int data_off = 0;
/* Prepare input/output params */
odp_crypto_op_params_t op_params;
memset(&op_params, 0, sizeof(op_params));
op_params.session = session;
op_params.pkt = pkt;
op_params.out_pkt = pkt;
op_params.ctx = (void *)0xdeadbeef;
if (cipher_alg != ODP_CIPHER_ALG_NULL &&
auth_alg == ODP_AUTH_ALG_NULL) {
op_params.cipher_range.offset = data_off;
op_params.cipher_range.length = input_vec_len;
if (op_iv_ptr)
op_params.override_iv_ptr = op_iv_ptr;
} else if (cipher_alg == ODP_CIPHER_ALG_NULL &&
auth_alg != ODP_AUTH_ALG_NULL) {
op_params.auth_range.offset = data_off;
op_params.auth_range.length = input_vec_len;
op_params.hash_result_offset = data_off;
} else {
CU_FAIL("%s : not implemented for combined alg mode\n");
}
rc = odp_crypto_operation(&op_params, &posted, &result);
if (rc < 0) {
CU_FAIL("Failed odp_crypto_operation()");
goto cleanup;
}
if (posted) {
/* Poll completion queue for results */
do {
event = odp_queue_deq(suite_context.queue);
} while (event == ODP_EVENT_INVALID);
compl_event = odp_crypto_compl_from_event(event);
CU_ASSERT(odp_crypto_compl_to_u64(compl_event) ==
odp_crypto_compl_to_u64(odp_crypto_compl_from_event(event)));
odp_crypto_compl_result(compl_event, &result);
odp_crypto_compl_free(compl_event);
}
CU_ASSERT(result.ok);
CU_ASSERT(result.pkt == pkt);
CU_ASSERT(!memcmp(data_addr, output_vec, output_vec_len));
CU_ASSERT(result.ctx == (void *)0xdeadbeef);
cleanup:
rc = odp_crypto_session_destroy(session);
CU_ASSERT(!rc);
odp_packet_free(pkt);
}
/* Basic algorithm run function for async inplace mode.
* Creates a session from input parameters and runs one operation
* on input_vec. Checks the output of the crypto operation against
* output_vec. Operation completion event is dequeued polling the
* session output queue. Completion context pointer is retrieved
* and checked against the one set before the operation.
* Completion event can be a separate buffer or the input packet
* buffer can be used.
* */
static void alg_test(odp_crypto_op_t op,
odp_cipher_alg_t cipher_alg,
odp_crypto_iv_t ses_iv,
uint8_t *op_iv_ptr,
odp_crypto_key_t cipher_key,
odp_auth_alg_t auth_alg,
odp_crypto_key_t auth_key,
odp_crypto_data_range_t *cipher_range,
odp_crypto_data_range_t *auth_range,
const uint8_t *plaintext,
unsigned int plaintext_len,
const uint8_t *ciphertext,
unsigned int ciphertext_len,
const uint8_t *digest,
unsigned int digest_len
)
{
odp_crypto_session_t session;
int rc;
odp_crypto_ses_create_err_t status;
odp_bool_t posted;
odp_event_t event;
odp_crypto_compl_t compl_event;
odp_crypto_op_result_t result;
/* Create a crypto session */
odp_crypto_session_params_t ses_params;
memset(&ses_params, 0, sizeof(ses_params));
ses_params.op = op;
ses_params.auth_cipher_text = false;
ses_params.pref_mode = suite_context.pref_mode;
ses_params.cipher_alg = cipher_alg;
ses_params.auth_alg = auth_alg;
ses_params.compl_queue = suite_context.queue;
ses_params.output_pool = suite_context.pool;
ses_params.cipher_key = cipher_key;
ses_params.iv = ses_iv;
ses_params.auth_key = auth_key;
rc = odp_crypto_session_create(&ses_params, &session, &status);
CU_ASSERT_FATAL(!rc);
CU_ASSERT(status == ODP_CRYPTO_SES_CREATE_ERR_NONE);
CU_ASSERT(odp_crypto_session_to_u64(session) !=
odp_crypto_session_to_u64(ODP_CRYPTO_SESSION_INVALID));
/* Prepare input data */
odp_packet_t pkt = odp_packet_alloc(suite_context.pool,
plaintext_len + digest_len);
CU_ASSERT(pkt != ODP_PACKET_INVALID);
uint8_t *data_addr = odp_packet_data(pkt);
memcpy(data_addr, plaintext, plaintext_len);
int data_off = 0;
/* Prepare input/output params */
odp_crypto_op_params_t op_params;
memset(&op_params, 0, sizeof(op_params));
op_params.session = session;
op_params.pkt = pkt;
op_params.out_pkt = pkt;
op_params.ctx = (void *)0xdeadbeef;
if (cipher_range) {
op_params.cipher_range = *cipher_range;
data_off = cipher_range->offset;
} else {
op_params.cipher_range.offset = data_off;
op_params.cipher_range.length = plaintext_len;
}
if (auth_range) {
op_params.auth_range = *auth_range;
} else {
op_params.auth_range.offset = data_off;
op_params.auth_range.length = plaintext_len;
}
if (op_iv_ptr)
op_params.override_iv_ptr = op_iv_ptr;
op_params.hash_result_offset = plaintext_len;
rc = odp_crypto_operation(&op_params, &posted, &result);
if (rc < 0) {
CU_FAIL("Failed odp_crypto_operation()");
goto cleanup;
}
if (posted) {
/* Poll completion queue for results */
do {
event = odp_queue_deq(suite_context.queue);
} while (event == ODP_EVENT_INVALID);
compl_event = odp_crypto_compl_from_event(event);
CU_ASSERT(odp_crypto_compl_to_u64(compl_event) ==
odp_crypto_compl_to_u64(odp_crypto_compl_from_event(event)));
odp_crypto_compl_result(compl_event, &result);
odp_crypto_compl_free(compl_event);
}
CU_ASSERT(result.ok);
CU_ASSERT(result.pkt == pkt);
if (cipher_alg != ODP_CIPHER_ALG_NULL) {
CU_ASSERT(!memcmp(data_addr, ciphertext, ciphertext_len));
if (memcmp(data_addr, ciphertext, ciphertext_len)) {
printf("data:\n");
unsigned j;
for (j = 0; j < ciphertext_len; ++j) printf("%02x ", data_addr[j]);
printf("\ncipher: \n");
for (j = 0; j < ciphertext_len; ++j) printf("%02x ", ciphertext[j]);
printf("\n\n");
};
};
if (op == ODP_CRYPTO_OP_ENCODE && auth_alg != ODP_AUTH_ALG_NULL)
CU_ASSERT(!memcmp(data_addr + op_params.hash_result_offset,
digest, digest_len));
CU_ASSERT(result.ctx == (void *)0xdeadbeef);
cleanup:
rc = odp_crypto_session_destroy(session);
CU_ASSERT(!rc);
odp_packet_free(pkt);
}
void *default_event_dispatcher(void *arg)
{
odp_event_t ev;
odp_packet_t pkt;
odp_queue_t in_queue;
odp_event_t events[OFP_EVT_RX_BURST_SIZE];
int event_idx = 0;
int event_cnt = 0;
ofp_pkt_processing_func pkt_func = (ofp_pkt_processing_func)arg;
odp_bool_t *is_running = NULL;
#if ODP_VERSION < 106
if (odp_init_local(ODP_THREAD_WORKER)) {
OFP_ERR("odp_init_local failed");
return NULL;
}
#endif
if (ofp_init_local()) {
OFP_ERR("ofp_init_local failed");
return NULL;
}
is_running = ofp_get_processing_state();
if (is_running == NULL) {
OFP_ERR("ofp_get_processing_state failed");
ofp_term_local();
return NULL;
}
/* PER CORE DISPATCHER */
while (*is_running) {
event_cnt = odp_schedule_multi(&in_queue, ODP_SCHED_WAIT,
events, OFP_EVT_RX_BURST_SIZE);
for (event_idx = 0; event_idx < event_cnt; event_idx++) {
ev = events[event_idx];
if (ev == ODP_EVENT_INVALID)
continue;
if (odp_event_type(ev) == ODP_EVENT_TIMEOUT) {
ofp_timer_handle(ev);
continue;
}
if (odp_event_type(ev) == ODP_EVENT_PACKET) {
pkt = odp_packet_from_event(ev);
#if 0
if (odp_unlikely(odp_packet_has_error(pkt))) {
OFP_DBG("Dropping packet with error");
odp_packet_free(pkt);
continue;
}
#endif
ofp_packet_input(pkt, in_queue, pkt_func);
continue;
}
OFP_ERR("Unexpected event type: %u", odp_event_type(ev));
/* Free events by type */
if (odp_event_type(ev) == ODP_EVENT_BUFFER) {
odp_buffer_free(odp_buffer_from_event(ev));
continue;
}
if (odp_event_type(ev) == ODP_EVENT_CRYPTO_COMPL) {
odp_crypto_compl_free(
odp_crypto_compl_from_event(ev));
continue;
}
}
ofp_send_pending_pkt();
}
if (ofp_term_local())
OFP_ERR("ofp_term_local failed");
return NULL;
}
