Scheduled for 0.10.0 to be applied after Events
On 20 January 2015 at 12:22, Maxim Uvarov <maxim.uva...@linaro.org> wrote:
> Need review-by to include it.
>
> Maxim.
>
>
> On 01/15/2015 06:55 PM, Robbie King wrote:
>
>> Crypto completion event is now sole responsibility of the
>> implementation when API is operating asynchrnously. Synchronous
>> mode can now return results directly without involving completion
>> event at all.
>>
>> Signed-off-by: Robbie King <robk...@cisco.com>
>> ---
>> example/ipsec/odp_ipsec.c | 81
>> ++++++++++-------
>> platform/linux-generic/include/api/odp_crypto.h | 91
>> +++++++++----------
>> .../linux-generic/include/odp_crypto_internal.h | 6 +-
>> platform/linux-generic/odp_crypto.c | 95
>> +++++++++-----------
>> test/validation/crypto/odp_crypto_test_async_inp.c | 100
>> +++++----------------
>> test/validation/crypto/odp_crypto_test_sync_inp.c | 13 ++-
>> 6 files changed, 164 insertions(+), 222 deletions(-)
>>
>> diff --git a/example/ipsec/odp_ipsec.c b/example/ipsec/odp_ipsec.c
>> index 7a0fbef..036f6b2 100644
>> --- a/example/ipsec/odp_ipsec.c
>> +++ b/example/ipsec/odp_ipsec.c
>> @@ -674,7 +674,8 @@ pkt_disposition_e do_route_fwd_db(odp_packet_t pkt,
>> pkt_ctx_t *ctx)
>> static
>> pkt_disposition_e do_ipsec_in_classify(odp_packet_t pkt,
>> pkt_ctx_t *ctx,
>> - bool *skip)
>> + bool *skip,
>> + odp_crypto_op_result_t *result)
>> {
>> uint8_t *buf = odp_packet_data(pkt);
>> odph_ipv4hdr_t *ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt,
>> NULL);
>> @@ -704,6 +705,7 @@ pkt_disposition_e do_ipsec_in_classify(odp_packet_t
>> pkt,
>> /* Initialize parameters block */
>> memset(¶ms, 0, sizeof(params));
>> + params.ctx = ctx;
>> params.session = entry->state.session;
>> params.pkt = pkt;
>> params.out_pkt = entry->in_place ? pkt : ODP_PACKET_INVALID;
>> @@ -740,7 +742,7 @@ pkt_disposition_e do_ipsec_in_classify(odp_packet_t
>> pkt,
>> *skip = FALSE;
>> if (odp_crypto_operation(¶ms,
>> &posted,
>> - odp_packet_to_buffer(pkt))) {
>> + result)) {
>> abort();
>> }
>> return (posted) ? PKT_POSTED : PKT_CONTINUE;
>> @@ -756,22 +758,20 @@ pkt_disposition_e do_ipsec_in_classify(odp_packet_t
>> pkt,
>> */
>> static
>> pkt_disposition_e do_ipsec_in_finish(odp_packet_t pkt,
>> - pkt_ctx_t *ctx)
>> + pkt_ctx_t *ctx,
>> + odp_crypto_op_result_t *result)
>> {
>> - odp_buffer_t event;
>> - odp_crypto_compl_status_t cipher_rc;
>> - odp_crypto_compl_status_t auth_rc;
>> odph_ipv4hdr_t *ip;
>> int hdr_len = ctx->ipsec.hdr_len;
>> int trl_len = 0;
>> /* Check crypto result */
>> - event = odp_packet_to_buffer(pkt);
>> - odp_crypto_get_operation_compl_status(event, &auth_rc,
>> &cipher_rc);
>> - if (!is_crypto_compl_status_ok(&cipher_rc))
>> - return PKT_DROP;
>> - if (!is_crypto_compl_status_ok(&auth_rc))
>> - return PKT_DROP;
>> + if (!result->ok) {
>> + if (!is_crypto_compl_status_ok(&result->cipher_status))
>> + return PKT_DROP;
>> + if (!is_crypto_compl_status_ok(&result->auth_status))
>> + return PKT_DROP;
>> + }
>> ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL);
>> /*
>> @@ -865,6 +865,7 @@ pkt_disposition_e do_ipsec_out_classify(odp_packet_t
>> pkt,
>> /* Initialize parameters block */
>> memset(¶ms, 0, sizeof(params));
>> params.session = entry->state.session;
>> + params.ctx = ctx;
>> params.pkt = pkt;
>> params.out_pkt = entry->in_place ? pkt : ODP_PACKET_INVALID;
>> @@ -952,7 +953,8 @@ pkt_disposition_e do_ipsec_out_classify(odp_packet_t
>> pkt,
>> */
>> static
>> pkt_disposition_e do_ipsec_out_seq(odp_packet_t pkt,
>> - pkt_ctx_t *ctx)
>> + pkt_ctx_t *ctx,
>> + odp_crypto_op_result_t *result)
>> {
>> uint8_t *buf = odp_packet_data(pkt);
>> bool posted = 0;
>> @@ -974,7 +976,7 @@ pkt_disposition_e do_ipsec_out_seq(odp_packet_t pkt,
>> /* Issue crypto request */
>> if (odp_crypto_operation(&ctx->ipsec.params,
>> &posted,
>> - odp_packet_to_buffer(pkt))) {
>> + result)) {
>> abort();
>> }
>> return (posted) ? PKT_POSTED : PKT_CONTINUE;
>> @@ -990,20 +992,18 @@ pkt_disposition_e do_ipsec_out_seq(odp_packet_t pkt,
>> */
>> static
>> pkt_disposition_e do_ipsec_out_finish(odp_packet_t pkt,
>> - pkt_ctx_t *ctx)
>> + pkt_ctx_t *ctx,
>> + odp_crypto_op_result_t *result)
>> {
>> - odp_buffer_t event;
>> - odp_crypto_compl_status_t cipher_rc;
>> - odp_crypto_compl_status_t auth_rc;
>> odph_ipv4hdr_t *ip;
>> /* Check crypto result */
>> - event = odp_packet_to_buffer(pkt);
>> - odp_crypto_get_operation_compl_status(event, &auth_rc,
>> &cipher_rc);
>> - if (!is_crypto_compl_status_ok(&cipher_rc))
>> - return PKT_DROP;
>> - if (!is_crypto_compl_status_ok(&auth_rc))
>> - return PKT_DROP;
>> + if (!result->ok) {
>> + if (!is_crypto_compl_status_ok(&result->cipher_status))
>> + return PKT_DROP;
>> + if (!is_crypto_compl_status_ok(&result->auth_status))
>> + return PKT_DROP;
>> + }
>> ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL);
>> /* Finalize the IPv4 header */
>> @@ -1051,17 +1051,27 @@ void *pktio_thread(void *arg EXAMPLE_UNUSED)
>> pkt_disposition_e rc;
>> pkt_ctx_t *ctx;
>> odp_queue_t dispatchq;
>> + odp_crypto_op_result_t result;
>> /* Use schedule to get buf from any input queue */
>> buf = SCHEDULE(&dispatchq, ODP_SCHED_WAIT);
>> - pkt = odp_packet_from_buffer(buf);
>> /* Determine new work versus completion or sequence
>> number */
>> - if ((completionq != dispatchq) && (seqnumq != dispatchq))
>> {
>> + if (seqnumq == dispatchq) {
>> + pkt = odp_packet_from_buffer(buf);
>> + ctx = get_pkt_ctx_from_pkt(pkt);
>> + } else if (completionq == dispatchq) {
>> + odp_crypto_compl_event_t compl_event;
>> +
>> + compl_event = odp_crypto_compl_event_from_
>> buffer(buf);
>> + odp_crypto_get_compl_event_result(compl_event,
>> &result);
>> + odp_crypto_release_compl_event(compl_event);
>> + pkt = result.pkt;
>> + ctx = result.ctx;
>> + } else {
>> + pkt = odp_packet_from_buffer(buf);
>> ctx = alloc_pkt_ctx(pkt);
>> ctx->state = PKT_STATE_INPUT_VERIFY;
>> - } else {
>> - ctx = get_pkt_ctx_from_pkt(pkt);
>> }
>> /*
>> @@ -1088,7 +1098,10 @@ void *pktio_thread(void *arg EXAMPLE_UNUSED)
>> case PKT_STATE_IPSEC_IN_CLASSIFY:
>> - rc = do_ipsec_in_classify(pkt, ctx,
>> &skip);
>> + rc = do_ipsec_in_classify(pkt,
>> + ctx,
>> + &skip,
>> + &result);
>> ctx->state = (skip) ?
>> PKT_STATE_ROUTE_LOOKUP :
>> PKT_STATE_IPSEC_IN_FINISH;
>> @@ -1096,7 +1109,7 @@ void *pktio_thread(void *arg EXAMPLE_UNUSED)
>> case PKT_STATE_IPSEC_IN_FINISH:
>> - rc = do_ipsec_in_finish(pkt, ctx);
>> + rc = do_ipsec_in_finish(pkt, ctx,
>> &result);
>> ctx->state = PKT_STATE_ROUTE_LOOKUP;
>> break;
>> @@ -1108,7 +1121,9 @@ void *pktio_thread(void *arg EXAMPLE_UNUSED)
>> case PKT_STATE_IPSEC_OUT_CLASSIFY:
>> - rc = do_ipsec_out_classify(pkt, ctx,
>> &skip);
>> + rc = do_ipsec_out_classify(pkt,
>> + ctx,
>> + &skip);
>> if (odp_unlikely(skip)) {
>> ctx->state = PKT_STATE_TRANSMIT;
>> } else {
>> @@ -1119,13 +1134,13 @@ void *pktio_thread(void *arg EXAMPLE_UNUSED)
>> case PKT_STATE_IPSEC_OUT_SEQ:
>> - rc = do_ipsec_out_seq(pkt, ctx);
>> + rc = do_ipsec_out_seq(pkt, ctx, &result);
>> ctx->state = PKT_STATE_IPSEC_OUT_FINISH;
>> break;
>> case PKT_STATE_IPSEC_OUT_FINISH:
>> - rc = do_ipsec_out_finish(pkt, ctx);
>> + rc = do_ipsec_out_finish(pkt, ctx,
>> &result);
>> ctx->state = PKT_STATE_TRANSMIT;
>> break;
>> diff --git a/platform/linux-generic/include/api/odp_crypto.h
>> b/platform/linux-generic/include/api/odp_crypto.h
>> index 337e7cf..3815dee 100644
>> --- a/platform/linux-generic/include/api/odp_crypto.h
>> +++ b/platform/linux-generic/include/api/odp_crypto.h
>> @@ -141,6 +141,7 @@ typedef struct odp_crypto_session_params {
>> */
>> typedef struct odp_crypto_op_params {
>> odp_crypto_session_t session; /**< Session handle from creation
>> */
>> + void *ctx; /**< User context */
>> odp_packet_t pkt; /**< Input packet buffer */
>> odp_packet_t out_pkt; /**< Output packet buffer */
>> uint8_t *override_iv_ptr; /**< Override session IV pointer
>> */
>> @@ -210,6 +211,21 @@ typedef struct odp_crypto_compl_status {
>> enum crypto_hw_err hw_err; /**< Hardware specific return code
>> */
>> } odp_crypto_compl_status_t;
>> +/**
>> + * Cryto API completion event
>> + */
>> +typedef odp_buffer_t odp_crypto_compl_event_t;
>> +
>> +/**
>> + * Crypto API operation result
>> + */
>> +typedef struct odp_crypto_op_result {
>> + odp_bool_t ok; /**< Request completed
>> successfully */
>> + void *ctx; /**< User context from request */
>> + odp_packet_t pkt; /**< Output packet */
>> + odp_crypto_compl_status_t cipher_status; /**< Cipher status */
>> + odp_crypto_compl_status_t auth_status; /**< Authentication
>> status */
>> +} odp_crypto_op_result_t;
>> /**
>> * Crypto session creation (synchronous)
>> @@ -225,76 +241,53 @@ odp_crypto_session_create(odp_crypto_session_params_t
>> *params,
>> odp_crypto_session_t *session,
>> enum odp_crypto_ses_create_err *status);
>> +/**
>> + * Release crypto completion event
>> + *
>> + * @param completion_event Completion event we are done accessing
>> + */
>> +void
>> +odp_crypto_release_compl_event(odp_crypto_compl_event_t
>> completion_event);
>> +
>> +/**
>> + * Convert buffer to completion event
>> + *
>> + * @param buffer Generic ODP buffer
>> + *
>> + * @return Completion event
>> + */
>> +odp_crypto_compl_event_t
>> +odp_crypto_compl_event_from_buffer(odp_buffer_t buffer);
>> /**
>> * Crypto per packet operation
>> *
>> * Performs the cryptographic operations specified during session
>> creation
>> * on the packet. If the operation is performed synchronously, "posted"
>> - * will return FALSE and the result of the operation is immediately
>> available
>> - * in the completion event. If "posted" returns TRUE the result will be
>> - * delivered via the completion queue specified when the session was
>> created.
>> - *
>> - * @todo Resolve if completion_event is necessary, can/should the output
>> - * packet buffer always be used instead.
>> + * will return FALSE and the result of the operation is immediately
>> available.
>> + * If "posted" returns TRUE the result will be delivered via the
>> completion
>> + * queue specified when the session was created.
>> *
>> * @param params Operation parameters
>> * @param posted Pointer to return posted, TRUE for async
>> operation
>> - * @param completion_event Event by which the operation results are
>> delivered.
>> + * @param result Results of operation (when posted returns
>> FALSE)
>> *
>> * @return 0 if successful else -1
>> */
>> int
>> odp_crypto_operation(odp_crypto_op_params_t *params,
>> bool *posted,
>> - odp_buffer_t completion_event);
>> + odp_crypto_op_result_t *result);
>> /**
>> - * Crypto per packet operation set user context in completion event
>> + * Crypto per packet operation query result from completion event
>> *
>> * @param completion_event Event containing operation results
>> - * @param ctx User data
>> + * @param result Pointer to result structure
>> */
>> void
>> -odp_crypto_set_operation_compl_ctx(odp_buffer_t completion_event,
>> - void *ctx);
>> -
>> -/**
>> - * Crypto per packet operation completion status
>> - *
>> - * Accessor function for obtaining operation status from the completion
>> event.
>> - *
>> - * @param completion_event Event containing operation results
>> - * @param auth Pointer to store authentication results
>> - * @param cipher Pointer to store cipher results
>> - */
>> -void
>> -odp_crypto_get_operation_compl_status(odp_buffer_t completion_event,
>> - odp_crypto_compl_status_t *auth,
>> - odp_crypto_compl_status_t *cipher);
>> -
>> -/**
>> - * Crypto per packet operation query completed operation packet
>> - *
>> - * Accessor function for obtaining current packet buffer, can be
>> - * different from input packet buffer on some systems
>> - *
>> - * @param completion_event Event containing operation results
>> - *
>> - * @return Packet structure where data now resides
>> - */
>> -odp_packet_t
>> -odp_crypto_get_operation_compl_packet(odp_buffer_t completion_event);
>> -
>> -/**
>> - * Crypto per packet operation query user context in completion event
>> - *
>> - * @param completion_event Event containing operation results
>> - *
>> - * @return User data
>> - */
>> -void *
>> -odp_crypto_get_operation_compl_ctx(odp_buffer_t completion_event);
>> +odp_crypto_get_compl_event_result(odp_crypto_compl_event_t
>> completion_event,
>> + odp_crypto_op_result_t *result);
>> /**
>> * Generate random byte string
>> diff --git a/platform/linux-generic/include/odp_crypto_internal.h
>> b/platform/linux-generic/include/odp_crypto_internal.h
>> index 2e5a71c..237b1e8 100644
>> --- a/platform/linux-generic/include/odp_crypto_internal.h
>> +++ b/platform/linux-generic/include/odp_crypto_internal.h
>> @@ -59,7 +59,6 @@ struct odp_crypto_generic_session {
>> } data;
>> crypto_func_t func;
>> } auth;
>> -
>> };
>> /**
>> @@ -67,10 +66,7 @@ struct odp_crypto_generic_session {
>> */
>> typedef struct odp_crypto_generic_op_result {
>> uint32_t magic;
>> - odp_crypto_compl_status_t cipher;
>> - odp_crypto_compl_status_t auth;
>> - void *op_context;
>> - odp_packet_t out_pkt;
>> + odp_crypto_op_result_t result;
>> } odp_crypto_generic_op_result_t;
>> /**
>> diff --git a/platform/linux-generic/odp_crypto.c
>> b/platform/linux-generic/odp_crypto.c
>> index 2f95cbe..f18fa3c 100644
>> --- a/platform/linux-generic/odp_crypto.c
>> +++ b/platform/linux-generic/odp_crypto.c
>> @@ -340,18 +340,16 @@ odp_crypto_session_create(odp_crypto_session_params_t
>> *params,
>> return 0;
>> }
>> -
>> int
>> odp_crypto_operation(odp_crypto_op_params_t *params,
>> bool *posted,
>> - odp_buffer_t completion_event)
>> + odp_crypto_op_result_t *result)
>> {
>> enum crypto_alg_err rc_cipher = ODP_CRYPTO_ALG_ERR_NONE;
>> enum crypto_alg_err rc_auth = ODP_CRYPTO_ALG_ERR_NONE;
>> odp_crypto_generic_session_t *session;
>> - odp_crypto_generic_op_result_t *result;
>> + odp_crypto_op_result_t local_result;
>> - *posted = 0;
>> session = (odp_crypto_generic_session_t
>> *)(intptr_t)params->session;
>> /* Resolve output buffer */
>> @@ -364,9 +362,6 @@ odp_crypto_operation(odp_crypto_op_params_t *params,
>> ODP_ABORT();
>> _odp_packet_copy_to_packet(params->pkt, 0,
>> params->out_pkt, 0,
>> odp_packet_len(params->pkt));
>> - if (completion_event == odp_packet_to_buffer(params->
>> pkt))
>> - completion_event =
>> - odp_packet_to_buffer(params->out_pkt);
>> odp_packet_free(params->pkt);
>> params->pkt = ODP_PACKET_INVALID;
>> }
>> @@ -380,19 +375,39 @@ odp_crypto_operation(odp_crypto_op_params_t
>> *params,
>> rc_cipher = session->cipher.func(params, session);
>> }
>> - /* Build Result (no HW so no errors) */
>> - result = get_op_result_from_buffer(completion_event);
>> - result->magic = OP_RESULT_MAGIC;
>> - result->cipher.alg_err = rc_cipher;
>> - result->cipher.hw_err = ODP_CRYPTO_HW_ERR_NONE;
>> - result->auth.alg_err = rc_auth;
>> - result->auth.hw_err = ODP_CRYPTO_HW_ERR_NONE;
>> - result->out_pkt = params->out_pkt;
>> + /* Fill in result */
>> + local_result.ctx = params->ctx;
>> + local_result.pkt = params->out_pkt;
>> + local_result.cipher_status.alg_err = rc_cipher;
>> + local_result.cipher_status.hw_err = ODP_CRYPTO_HW_ERR_NONE;
>> + local_result.auth_status.alg_err = rc_auth;
>> + local_result.auth_status.hw_err = ODP_CRYPTO_HW_ERR_NONE;
>> + local_result.ok =
>> + (rc_cipher == ODP_CRYPTO_ALG_ERR_NONE) &&
>> + (rc_auth == ODP_CRYPTO_ALG_ERR_NONE);
>> /* If specified during creation post event to completion queue */
>> if (ODP_QUEUE_INVALID != session->compl_queue) {
>> + odp_crypto_compl_event_t completion_event;
>> + odp_crypto_generic_op_result_t *op_result;
>> +
>> + /* Linux generic will always use packet for completion
>> event */
>> + completion_event = odp_packet_to_buffer(params->out_pkt);
>> +
>> + /* Asynchronous, build result (no HW so no errors) and
>> send it*/
>> + op_result = get_op_result_from_buffer(completion_event);
>> + op_result->magic = OP_RESULT_MAGIC;
>> + op_result->result = local_result;
>> odp_queue_enq(session->compl_queue, completion_event);
>> +
>> + /* Indicate to caller operation was async */
>> *posted = 1;
>> + } else {
>> + /* Synchronous, simply return results */
>> + *result = local_result;
>> +
>> + /* Indicate to caller operation was sync */
>> + *posted = 0;
>> }
>> return 0;
>> }
>> @@ -431,55 +446,27 @@ odp_hw_random_get(uint8_t *buf, size_t *len, bool
>> use_entropy ODP_UNUSED)
>> }
>> void
>> -odp_crypto_get_operation_compl_status(odp_buffer_t completion_event,
>> - odp_crypto_compl_status_t *auth,
>> - odp_crypto_compl_status_t *cipher)
>> +odp_crypto_get_compl_event_result(odp_crypto_compl_event_t
>> completion_event,
>> + odp_crypto_op_result_t *result)
>> {
>> - odp_crypto_generic_op_result_t *result;
>> + odp_crypto_generic_op_result_t *op_result;
>> - result = get_op_result_from_buffer(completion_event);
>> + op_result = get_op_result_from_buffer(completion_event);
>> - if (OP_RESULT_MAGIC != result->magic)
>> + if (OP_RESULT_MAGIC != op_result->magic)
>> ODP_ABORT();
>> - memcpy(auth, &result->auth, sizeof(*auth));
>> - memcpy(cipher, &result->cipher, sizeof(*cipher));
>> -}
>> -
>> -
>> -void
>> -odp_crypto_set_operation_compl_ctx(odp_buffer_t completion_event,
>> - void *ctx)
>> -{
>> - odp_crypto_generic_op_result_t *result;
>> -
>> - result = get_op_result_from_buffer(completion_event);
>> - /*
>> - * Completion event magic can't be checked here, because it is
>> filled
>> - * later in odp_crypto_operation() function.
>> - */
>> -
>> - result->op_context = ctx;
>> + memcpy(result, &op_result->result, sizeof(*result));
>> }
>> void
>> -*odp_crypto_get_operation_compl_ctx(odp_buffer_t completion_event)
>> +odp_crypto_release_compl_event(odp_crypto_compl_event_t compl_event
>> ODP_UNUSED)
>> {
>> - odp_crypto_generic_op_result_t *result;
>> -
>> - result = get_op_result_from_buffer(completion_event);
>> - ODP_ASSERT(OP_RESULT_MAGIC == result->magic, "Bad completion
>> magic");
>> -
>> - return result->op_context;
>> + /* We use the packet as the completion event so nothing to do
>> here */
>> }
>> -odp_packet_t
>> -odp_crypto_get_operation_compl_packet(odp_buffer_t completion_event)
>> +odp_crypto_compl_event_t
>> +odp_crypto_compl_event_from_buffer(odp_buffer_t buffer)
>> {
>> - odp_crypto_generic_op_result_t *result;
>> -
>> - result = get_op_result_from_buffer(completion_event);
>> - ODP_ASSERT(OP_RESULT_MAGIC == result->magic, "Bad completion
>> magic");
>> -
>> - return result->out_pkt;
>> + return (odp_crypto_compl_event_t)buffer;
>> }
>> diff --git a/test/validation/crypto/odp_crypto_test_async_inp.c
>> b/test/validation/crypto/odp_crypto_test_async_inp.c
>> index 96d4c3f..588592c 100644
>> --- a/test/validation/crypto/odp_crypto_test_async_inp.c
>> +++ b/test/validation/crypto/odp_crypto_test_async_inp.c
>> @@ -25,7 +25,6 @@ static void alg_test(enum odp_crypto_op op,
>> odp_crypto_key_t cipher_key,
>> enum odp_auth_alg auth_alg,
>> odp_crypto_key_t auth_key,
>> - odp_buffer_t compl_new,
>> uint8_t *input_vec,
>> unsigned int input_vec_len,
>> uint8_t *output_vec,
>> @@ -35,7 +34,8 @@ static void alg_test(enum odp_crypto_op op,
>> int rc;
>> enum odp_crypto_ses_create_err status;
>> bool posted;
>> - odp_buffer_t compl_event;
>> + odp_buffer_t compl_buff;
>> + odp_crypto_op_result_t result;
>> odp_queue_t compl_queue = odp_queue_lookup("crypto-out");
>> CU_ASSERT(compl_queue != ODP_QUEUE_INVALID);
>> @@ -75,6 +75,7 @@ static void alg_test(enum odp_crypto_op op,
>> 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;
>> @@ -90,42 +91,30 @@ static void alg_test(enum odp_crypto_op op,
>> CU_FAIL("%s : not implemented for combined alg mode\n");
>> }
>> - if (compl_new == ODP_BUFFER_INVALID) {
>> - odp_crypto_set_operation_compl_ctx(buf, (void
>> *)0xdeadbeef);
>> - rc = odp_crypto_operation(&op_params, &posted, buf);
>> - } else {
>> - odp_crypto_set_operation_compl_ctx(compl_new,
>> - (void *)0xdeadbeef);
>> - rc = odp_crypto_operation(&op_params, &posted,
>> compl_new);
>> - }
>> + rc = odp_crypto_operation(&op_params, &posted, NULL);
>> CU_ASSERT(posted);
>> /* Poll completion queue for results */
>> + odp_crypto_compl_event_t compl_event;
>> do {
>> - compl_event = odp_queue_deq(compl_queue);
>> - } while (compl_event == ODP_BUFFER_INVALID);
>> -
>> - if (compl_new == ODP_BUFFER_INVALID)
>> - CU_ASSERT(compl_event == buf)
>> - else
>> - CU_ASSERT(compl_event == compl_new)
>> -
>> - struct odp_crypto_compl_status auth_status, cipher_status;
>> - odp_crypto_get_operation_compl_status(compl_event,
>> - &auth_status,
>> &cipher_status);
>> - CU_ASSERT(auth_status.alg_err == ODP_CRYPTO_ALG_ERR_NONE);
>> - CU_ASSERT(auth_status.hw_err == ODP_CRYPTO_HW_ERR_NONE);
>> - CU_ASSERT(cipher_status.alg_err == ODP_CRYPTO_ALG_ERR_NONE);
>> - CU_ASSERT(cipher_status.hw_err == ODP_CRYPTO_HW_ERR_NONE);
>> -
>> - odp_packet_t out_pkt;
>> - out_pkt = odp_crypto_get_operation_compl_packet(compl_event);
>> - CU_ASSERT(out_pkt == pkt);
>> + compl_buff = odp_queue_deq(compl_queue);
>> + } while (compl_buff == ODP_BUFFER_INVALID);
>> +
>> + compl_event = odp_crypto_compl_event_from_buffer(compl_buff);
>> + odp_crypto_get_compl_event_result(compl_event, &result);
>> + odp_crypto_release_compl_event(compl_event);
>> +
>> + CU_ASSERT(result.ok);
>> + CU_ASSERT(result.auth_status.alg_err == ODP_CRYPTO_ALG_ERR_NONE);
>> + CU_ASSERT(result.auth_status.hw_err == ODP_CRYPTO_HW_ERR_NONE);
>> + CU_ASSERT(result.cipher_status.alg_err ==
>> ODP_CRYPTO_ALG_ERR_NONE);
>> + CU_ASSERT(result.cipher_status.hw_err == ODP_CRYPTO_HW_ERR_NONE);
>> +
>> + CU_ASSERT(result.pkt == pkt);
>> CU_ASSERT(!memcmp(data_addr, output_vec, output_vec_len));
>> - void *ctx = odp_crypto_get_operation_compl_ctx(compl_event);
>> - CU_ASSERT(ctx == (void *)0xdeadbeef);
>> + CU_ASSERT(result.ctx == (void *)0xdeadbeef);
>> odp_buffer_free(buf);
>> }
>> @@ -157,7 +146,6 @@ static void enc_alg_3des_cbc(void)
>> cipher_key,
>> ODP_AUTH_ALG_NULL,
>> auth_key,
>> - ODP_BUFFER_INVALID,
>> tdes_cbc_reference_plaintext[i],
>> tdes_cbc_reference_length[i],
>> tdes_cbc_reference_ciphertext[i],
>> @@ -189,7 +177,6 @@ static void enc_alg_3des_cbc_ovr_iv(void)
>> cipher_key,
>> ODP_AUTH_ALG_NULL,
>> auth_key,
>> - ODP_BUFFER_INVALID,
>> tdes_cbc_reference_plaintext[i],
>> tdes_cbc_reference_length[i],
>> tdes_cbc_reference_ciphertext[i],
>> @@ -226,7 +213,6 @@ static void dec_alg_3des_cbc(void)
>> cipher_key,
>> ODP_AUTH_ALG_NULL,
>> auth_key,
>> - ODP_BUFFER_INVALID,
>> tdes_cbc_reference_ciphertext[i],
>> tdes_cbc_reference_length[i],
>> tdes_cbc_reference_plaintext[i],
>> @@ -260,7 +246,6 @@ static void dec_alg_3des_cbc_ovr_iv(void)
>> cipher_key,
>> ODP_AUTH_ALG_NULL,
>> auth_key,
>> - ODP_BUFFER_INVALID,
>> tdes_cbc_reference_ciphertext[i],
>> tdes_cbc_reference_length[i],
>> tdes_cbc_reference_plaintext[i],
>> @@ -298,7 +283,6 @@ static void alg_hmac_md5(void)
>> cipher_key,
>> ODP_AUTH_ALG_MD5_96,
>> auth_key,
>> - ODP_BUFFER_INVALID,
>> hmac_md5_reference_plaintext[i],
>> hmac_md5_reference_length[i],
>> hmac_md5_reference_digest[i],
>> @@ -306,55 +290,11 @@ static void alg_hmac_md5(void)
>> }
>> }
>> -/* This test verifies the correctness of encode (plaintext ->
>> ciphertext)
>> - * operation for 3DES_CBC algorithm. IV for the operation is the session
>> IV.
>> - * Uses a separate buffer for completion event
>> - * */
>> -#define ASYNC_INP_ENC_ALG_3DES_CBC_COMPL_NEW
>> "ENC_ALG_3DES_CBC_COMPL_NEW"
>> -static void enc_alg_3des_cbc_compl_new(void)
>> -{
>> - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
>> - auth_key = { .data = NULL, .length = 0 };
>> - odp_crypto_iv_t iv;
>> - unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length)/
>> - sizeof(tdes_cbc_reference_
>> length[0]));
>> -
>> - odp_buffer_pool_t pool = odp_buffer_pool_lookup("compl_pool");
>> - CU_ASSERT(pool != ODP_BUFFER_POOL_INVALID);
>> -
>> - unsigned int i;
>> - odp_buffer_t compl_new;
>> - for (i = 0; i < test_vec_num; i++) {
>> - compl_new = odp_buffer_alloc(pool);
>> - CU_ASSERT(compl_new != ODP_BUFFER_INVALID);
>> -
>> - cipher_key.data = tdes_cbc_reference_key[i];
>> - cipher_key.length = sizeof(tdes_cbc_reference_key[i]);
>> - iv.data = tdes_cbc_reference_iv[i];
>> - iv.length = sizeof(tdes_cbc_reference_iv[i]);
>> -
>> - alg_test(ODP_CRYPTO_OP_ENCODE,
>> - ODP_CIPHER_ALG_3DES_CBC,
>> - iv,
>> - NULL,
>> - cipher_key,
>> - ODP_AUTH_ALG_NULL,
>> - auth_key,
>> - compl_new,
>> - tdes_cbc_reference_plaintext[i],
>> - tdes_cbc_reference_length[i],
>> - tdes_cbc_reference_ciphertext[i],
>> - tdes_cbc_reference_length[i]);
>> - odp_buffer_free(compl_new);
>> - }
>> -}
>> -
>> CU_TestInfo test_array_async[] = {
>> {ASYNC_INP_ENC_ALG_3DES_CBC, enc_alg_3des_cbc },
>> {ASYNC_INP_DEC_ALG_3DES_CBC, dec_alg_3des_cbc },
>> {ASYNC_INP_ENC_ALG_3DES_CBC_OVR_IV, enc_alg_3des_cbc_ovr_iv },
>> {ASYNC_INP_DEC_ALG_3DES_CBC_OVR_IV, dec_alg_3des_cbc_ovr_iv },
>> {ASYNC_INP_ALG_HMAC_MD5, alg_hmac_md5 },
>> - {ASYNC_INP_ENC_ALG_3DES_CBC_COMPL_NEW,
>> enc_alg_3des_cbc_compl_new },
>> CU_TEST_INFO_NULL,
>> };
>> diff --git a/test/validation/crypto/odp_crypto_test_sync_inp.c
>> b/test/validation/crypto/odp_crypto_test_sync_inp.c
>> index f37ad54..0215b6f 100644
>> --- a/test/validation/crypto/odp_crypto_test_sync_inp.c
>> +++ b/test/validation/crypto/odp_crypto_test_sync_inp.c
>> @@ -24,6 +24,7 @@ static void alg_test(enum odp_crypto_op op,
>> int rc;
>> enum odp_crypto_ses_create_err status;
>> bool posted;
>> + odp_crypto_op_result_t result;
>> odp_queue_t compl_queue = odp_queue_lookup("crypto-out");
>> CU_ASSERT(compl_queue != ODP_QUEUE_INVALID);
>> @@ -64,6 +65,7 @@ static void alg_test(enum odp_crypto_op op,
>> 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;
>> @@ -80,13 +82,22 @@ static void alg_test(enum odp_crypto_op op,
>> }
>> /* TEST : odp_crypto_operation */
>> - rc = odp_crypto_operation(&op_params, &posted, buf);
>> + rc = odp_crypto_operation(&op_params, &posted, &result);
>> CU_ASSERT(!rc);
>> /* indication that the operation completed */
>> CU_ASSERT(!posted);
>> + /* TEST: results were ok */
>> + CU_ASSERT(result.ok);
>> + CU_ASSERT(result.auth_status.alg_err == ODP_CRYPTO_ALG_ERR_NONE);
>> + CU_ASSERT(result.auth_status.hw_err == ODP_CRYPTO_HW_ERR_NONE);
>> + CU_ASSERT(result.cipher_status.alg_err ==
>> ODP_CRYPTO_ALG_ERR_NONE);
>> + CU_ASSERT(result.cipher_status.hw_err == ODP_CRYPTO_HW_ERR_NONE);
>> +
>> /* TEST : operation output was correct */
>> CU_ASSERT(!memcmp(data_addr, output_vec, output_vec_len));
>> +
>> + CU_ASSERT(result.ctx == (void *)0xdeadbeef);
>> }
>> #define SYNC_INP_ENC_ALG_3DES_CBC "ENC_ALG_3DES_CBC"
>>
>
>
> _______________________________________________
> lng-odp mailing list
> lng-odp@lists.linaro.org
> http://lists.linaro.org/mailman/listinfo/lng-odp
>
--
*Mike Holmes*
Linaro Sr Technical Manager
LNG - ODP
_______________________________________________
lng-odp mailing list
lng-odp@lists.linaro.org
http://lists.linaro.org/mailman/listinfo/lng-odp
