diff options
Diffstat (limited to 'test')
-rw-r--r-- | test/performance/Makefile.am | 1 | ||||
-rw-r--r-- | test/performance/odp_crypto.c | 8 | ||||
-rw-r--r-- | test/performance/odp_stress.c | 2 | ||||
-rw-r--r-- | test/validation/api/barrier/barrier.c | 11 | ||||
-rw-r--r-- | test/validation/api/buffer/buffer.c | 3 | ||||
-rw-r--r-- | test/validation/api/crypto/crypto_op_test.c | 94 | ||||
-rw-r--r-- | test/validation/api/crypto/crypto_op_test.h | 10 | ||||
-rw-r--r-- | test/validation/api/crypto/odp_crypto_test_inp.c | 233 | ||||
-rw-r--r-- | test/validation/api/dma/dma.c | 76 | ||||
-rw-r--r-- | test/validation/api/event/event.c | 46 | ||||
-rw-r--r-- | test/validation/api/ipsec/ipsec.c | 3 | ||||
-rw-r--r-- | test/validation/api/packet/packet.c | 11 | ||||
-rw-r--r-- | test/validation/api/pktio/pktio.c | 6 | ||||
-rw-r--r-- | test/validation/api/pool/pool.c | 293 | ||||
-rw-r--r-- | test/validation/api/shmem/shmem.c | 2 | ||||
-rw-r--r-- | test/validation/api/time/time.c | 145 | ||||
-rw-r--r-- | test/validation/api/timer/timer.c | 398 |
17 files changed, 1012 insertions, 330 deletions
diff --git a/test/performance/Makefile.am b/test/performance/Makefile.am index 67d57590a..6e20ec07c 100644 --- a/test/performance/Makefile.am +++ b/test/performance/Makefile.am @@ -84,6 +84,7 @@ odp_timer_perf_SOURCES = odp_timer_perf.c if LIBCONFIG odp_ipsecfwd_SOURCES = odp_ipsecfwd.c +AM_CFLAGS += $(LIBCONFIG_CFLAGS) endif # l2fwd test depends on generator example diff --git a/test/performance/odp_crypto.c b/test/performance/odp_crypto.c index 52af6d2fc..fed3ebad8 100644 --- a/test/performance/odp_crypto.c +++ b/test/performance/odp_crypto.c @@ -1,5 +1,5 @@ /* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2022, Nokia + * Copyright (c) 2023, Nokia * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -1170,6 +1170,12 @@ static int run_measure_one_config(test_run_arg_t *arg) rc = 1; } +#if ODP_VERSION_API >= ODP_VERSION_API_NUM(1, 42, 0) + /* Bit mode ciphers can now be used in byte mode. */ + config->cipher_in_bit_mode = 0; + config->auth_in_bit_mode = 0; +#endif + if (rc == 0) rc = create_session_from_config(&session, config, cargs); if (rc) { diff --git a/test/performance/odp_stress.c b/test/performance/odp_stress.c index 15b44c113..d5e3142f6 100644 --- a/test/performance/odp_stress.c +++ b/test/performance/odp_stress.c @@ -213,7 +213,7 @@ static int worker_thread(void *arg) odp_timer_start_t start_param; odp_time_t t1, t2, max_time; odp_time_t work_t1, work_t2; - uint8_t *src, *dst; + uint8_t *src = NULL, *dst = NULL; thread_arg_t *thread_arg = arg; int worker_idx = thread_arg->worker_idx; test_global_t *global = thread_arg->global; diff --git a/test/validation/api/barrier/barrier.c b/test/validation/api/barrier/barrier.c index 610b5db70..e4fba770f 100644 --- a/test/validation/api/barrier/barrier.c +++ b/test/validation/api/barrier/barrier.c @@ -283,6 +283,9 @@ static void barrier_test_memory_barrier(void) volatile int b = 0; volatile int c = 0; volatile int d = 0; + volatile int e = 0; + volatile int f = 0; + volatile int g = 0; /* Call all memory barriers to verify that those are implemented */ a = 1; @@ -292,9 +295,15 @@ static void barrier_test_memory_barrier(void) c = 1; odp_mb_full(); d = 1; + odp_mb_sync(); + e = 1; + odp_mb_sync_load(); + f = 1; + odp_mb_sync_store(); + g = 1; /* Avoid "variable set but not used" warning */ - temp_result = a + b + c + d; + temp_result = a + b + c + d + e + f + g; } static int barrier_init(odp_instance_t *inst) diff --git a/test/validation/api/buffer/buffer.c b/test/validation/api/buffer/buffer.c index ef26ea6e0..1d0cc9d01 100644 --- a/test/validation/api/buffer/buffer.c +++ b/test/validation/api/buffer/buffer.c @@ -537,6 +537,7 @@ static void buffer_test_user_area(void) for (i = 0; i < num; i++) { odp_event_t ev; + int flag; buffer[i] = odp_buffer_alloc(pool); @@ -550,6 +551,8 @@ static void buffer_test_user_area(void) ev = odp_buffer_to_event(buffer[i]); CU_ASSERT(odp_event_user_area(ev) == addr); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); + CU_ASSERT(flag < 0); prev = addr; memset(addr, 0, size); diff --git a/test/validation/api/crypto/crypto_op_test.c b/test/validation/api/crypto/crypto_op_test.c index 4ad333488..1d883f6b8 100644 --- a/test/validation/api/crypto/crypto_op_test.c +++ b/test/validation/api/crypto/crypto_op_test.c @@ -178,19 +178,13 @@ static void prepare_crypto_ranges(const crypto_op_test_param_t *param, odp_packet_data_range_t *cipher_range, odp_packet_data_range_t *auth_range) { - odp_packet_data_range_t zero_range = {.offset = 0, .length = 0}; - uint32_t c_scale = param->is_bit_mode_cipher ? 8 : 1; - uint32_t a_scale = param->is_bit_mode_auth ? 8 : 1; + uint32_t c_scale = param->session.cipher_range_in_bits ? 8 : 1; + uint32_t a_scale = param->session.auth_range_in_bits ? 8 : 1; *cipher_range = param->cipher_range; *auth_range = param->auth_range; cipher_range->offset += c_scale * param->header_len; auth_range->offset += a_scale * param->header_len; - - if (param->ref->cipher == ODP_CIPHER_ALG_NULL) - *cipher_range = zero_range; - if (param->ref->auth == ODP_AUTH_ALG_NULL) - *auth_range = zero_range; } static int prepare_input_packet(const crypto_op_test_param_t *param, @@ -217,7 +211,7 @@ static int prepare_input_packet(const crypto_op_test_param_t *param, write_header_and_trailer(pkt, param->header_len, param->trailer_len); - if (param->op == ODP_CRYPTO_OP_ENCODE) { + if (param->session.op == ODP_CRYPTO_OP_ENCODE) { odp_packet_copy_from_mem(pkt, param->header_len, reflength, ref->plaintext); } else { @@ -322,7 +316,7 @@ static void prepare_ignore_info(const crypto_op_test_param_t *param, * Leftover bits in the last byte of the cipher range of bit mode * ciphers have undefined values. */ - if (param->is_bit_mode_cipher && + if (param->session.cipher_range_in_bits && param->ref->cipher != ODP_CIPHER_ALG_NULL) { uint8_t leftover_bits = ref_length_in_bits(param->ref) % 8; @@ -338,10 +332,10 @@ static void prepare_ignore_info(const crypto_op_test_param_t *param, * undefined values. */ if (param->ref->auth != ODP_AUTH_ALG_NULL && - param->op == ODP_CRYPTO_OP_DECODE) { + param->session.op == ODP_CRYPTO_OP_DECODE) { uint32_t offs = param->digest_offset; - if (param->op_type != ODP_CRYPTO_OP_TYPE_OOP || + if (param->session.op_type != ODP_CRYPTO_OP_TYPE_OOP || is_in_range(offs, cipher_offset, cipher_len) || is_in_range(offs, auth_offset, auth_len)) { add_ignored_range(ignore, @@ -351,11 +345,11 @@ static void prepare_ignore_info(const crypto_op_test_param_t *param, } /* Decrypted bytes are undefined if authentication fails. */ - if (param->op == ODP_CRYPTO_OP_DECODE && + if (param->session.op == ODP_CRYPTO_OP_DECODE && param->wrong_digest) { add_ignored_range(ignore, cipher_offset + shift, cipher_len); /* In OOP case, auth range may not get copied */ - if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP) + if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP) add_ignored_range(ignore, auth_offset + shift, auth_len); } } @@ -372,30 +366,29 @@ static void prepare_expected_data(const crypto_op_test_param_t *param, uint32_t cipher_len = cipher_range->length; uint32_t auth_offset = auth_range->offset; uint32_t auth_len = auth_range->length; - const int32_t shift = param->op_type == ODP_CRYPTO_OP_TYPE_OOP ? param->oop_shift : 0; - const odp_packet_t base_pkt = param->op_type == ODP_CRYPTO_OP_TYPE_OOP ? pkt_out : pkt_in; + const int32_t shift = param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP ? param->oop_shift + : 0; + const odp_packet_t base_pkt = param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP ? pkt_out + : pkt_in; int rc; uint32_t cipher_offset_in_ref = param->cipher_range.offset; - if (param->op == ODP_CRYPTO_OP_ENCODE) + if (param->session.op == ODP_CRYPTO_OP_ENCODE) digest_offset += shift; - if (param->is_bit_mode_cipher) { + if (param->session.cipher_range_in_bits) { cipher_offset_in_ref /= 8; cipher_offset /= 8; cipher_len = (cipher_len + 7) / 8; } - if (param->is_bit_mode_auth) { + if (param->session.auth_range_in_bits) { auth_offset /= 8; auth_len = (auth_len + 7) / 8; } - if (param->ref->cipher == ODP_CIPHER_ALG_NULL) - cipher_len = 0; - if (param->ref->auth == ODP_AUTH_ALG_NULL || - param->ref->auth == ODP_AUTH_ALG_AES_GCM || + if (param->ref->auth == ODP_AUTH_ALG_AES_GCM || param->ref->auth == ODP_AUTH_ALG_AES_CCM || param->ref->auth == ODP_AUTH_ALG_CHACHA20_POLY1305) { - /* auth range is ignored with null and AEAD algorithms */ + /* auth range is ignored with AEAD algorithms */ auth_len = 0; } @@ -405,14 +398,14 @@ static void prepare_expected_data(const crypto_op_test_param_t *param, rc = odp_packet_copy_to_mem(base_pkt, 0, ex->len, ex->data); CU_ASSERT(rc == 0); - if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP && auth_len > 0) { + if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP && auth_len > 0) { /* copy auth range from input packet */ rc = odp_packet_copy_to_mem(pkt_in, auth_offset, auth_len, ex->data + auth_offset + shift); CU_ASSERT(rc == 0); } - if (param->op == ODP_CRYPTO_OP_ENCODE) { + if (param->session.op == ODP_CRYPTO_OP_ENCODE) { /* copy hash first */ memcpy(ex->data + digest_offset, param->ref->digest, @@ -472,6 +465,23 @@ static void check_output_packet_data(odp_packet_t pkt, expected_t *ex) } } +static int is_digest_in_cipher_range(const crypto_op_test_param_t *param, + const odp_crypto_packet_op_param_t *op_params) +{ + /* + * Do not use op_params.hash_result_offset here as it refers to + * the output packet which (in the OOP case) might be shifted + * relative to the input packet. + */ + uint32_t d_offset = param->digest_offset; + + if (param->session.cipher_range_in_bits) + d_offset *= 8; + + return d_offset >= op_params->cipher_range.offset && + d_offset < op_params->cipher_range.offset + op_params->cipher_range.length; +} + void test_crypto_op(const crypto_op_test_param_t *param) { odp_bool_t ok = false; @@ -481,13 +491,14 @@ void test_crypto_op(const crypto_op_test_param_t *param) test_packet_md_t md_in, md_out, md_out_orig; expected_t expected; odp_crypto_packet_op_param_t op_params = { - .session = param->session, + .session = param->session.session, .cipher_iv_ptr = param->ref->cipher_iv, .auth_iv_ptr = param->ref->auth_iv, .hash_result_offset = param->digest_offset, .aad_ptr = param->ref->aad, .dst_offset_shift = param->oop_shift, }; + odp_bool_t failure_allowed = false; /* * Test detection of wrong digest value in input packet @@ -495,26 +506,34 @@ void test_crypto_op(const crypto_op_test_param_t *param) */ if (param->wrong_digest && (param->ref->auth == ODP_AUTH_ALG_NULL || - param->op == ODP_CRYPTO_OP_ENCODE)) + param->session.op == ODP_CRYPTO_OP_ENCODE)) return; prepare_crypto_ranges(param, &op_params.cipher_range, &op_params.auth_range); if (prepare_input_packet(param, &pkt)) return; - if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP) { + if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP) { prepare_oop_output_packet(param, &pkt_out, odp_packet_len(pkt)); pkt_copy = odp_packet_copy(pkt, suite_context.pool); CU_ASSERT_FATAL(pkt_copy != ODP_PACKET_INVALID); test_packet_get_md(pkt_out, &md_out_orig); + + /* Non-zero-length ranges do not have to be supported. */ + if ((param->ref->cipher == ODP_CIPHER_ALG_NULL && + op_params.cipher_range.length != 0)) + failure_allowed = true; + if ((param->ref->auth == ODP_AUTH_ALG_NULL && + op_params.auth_range.length != 0)) + failure_allowed = true; } prepare_expected_data(param, &op_params.cipher_range, &op_params.auth_range, pkt, pkt_out, &expected); - if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP && - param->op == ODP_CRYPTO_OP_ENCODE) { + if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP && + param->session.op == ODP_CRYPTO_OP_ENCODE) { /* * In this type of sessions digest offset is an offset to the output * packet, so apply the shift. @@ -525,12 +544,12 @@ void test_crypto_op(const crypto_op_test_param_t *param) test_packet_set_md(pkt); test_packet_get_md(pkt, &md_in); - if (crypto_op(pkt, &pkt_out, &ok, &op_params, param->op_type)) + if (crypto_op(pkt, &pkt_out, &ok, &op_params, param->session.op_type)) return; test_packet_get_md(pkt_out, &md_out); - if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP) { + if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP) { test_packet_md_t md; /* check that input packet has not changed */ @@ -548,17 +567,18 @@ void test_crypto_op(const crypto_op_test_param_t *param) if (param->ref->cipher != ODP_CIPHER_ALG_NULL && param->ref->auth != ODP_AUTH_ALG_NULL && - param->digest_offset >= op_params.cipher_range.offset && - param->digest_offset < op_params.cipher_range.offset + op_params.cipher_range.length) { + is_digest_in_cipher_range(param, &op_params)) { /* * Not all implementations support digest offset in cipher * range, so allow crypto op failure without further checks * in this case. */ - if (!ok) - goto out; + failure_allowed = true; } + if (!ok && failure_allowed) + goto out; + if (param->wrong_digest) { CU_ASSERT(!ok); } else { diff --git a/test/validation/api/crypto/crypto_op_test.h b/test/validation/api/crypto/crypto_op_test.h index 4b2f66c47..4f5957820 100644 --- a/test/validation/api/crypto/crypto_op_test.h +++ b/test/validation/api/crypto/crypto_op_test.h @@ -12,17 +12,21 @@ #include <stdint.h> #include "test_vectors.h" -typedef struct crypto_op_test_param_t { +typedef struct crypto_session_t { odp_crypto_session_t session; odp_crypto_op_t op; odp_crypto_op_type_t op_type; + odp_bool_t cipher_range_in_bits; + odp_bool_t auth_range_in_bits; +} crypto_session_t; + +typedef struct crypto_op_test_param_t { + crypto_session_t session; int32_t oop_shift; crypto_test_reference_t *ref; odp_packet_data_range_t cipher_range; odp_packet_data_range_t auth_range; uint32_t digest_offset; - odp_bool_t is_bit_mode_cipher; - odp_bool_t is_bit_mode_auth; odp_bool_t adjust_segmentation; odp_bool_t wrong_digest; uint32_t first_seg_len; diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c index d7e2bd16b..0cc01b8e4 100644 --- a/test/validation/api/crypto/odp_crypto_test_inp.c +++ b/test/validation/api/crypto/odp_crypto_test_inp.c @@ -36,6 +36,8 @@ static void test_defaults(uint8_t fill) CU_ASSERT_EQUAL(param.op, ODP_CRYPTO_OP_ENCODE); CU_ASSERT_EQUAL(param.op_type, ODP_CRYPTO_OP_TYPE_LEGACY); + CU_ASSERT_EQUAL(param.cipher_range_in_bits, false); + CU_ASSERT_EQUAL(param.auth_range_in_bits, false); CU_ASSERT_EQUAL(param.auth_cipher_text, false); CU_ASSERT_EQUAL(param.op_mode, ODP_CRYPTO_SYNC); CU_ASSERT_EQUAL(param.cipher_alg, ODP_CIPHER_ALG_NULL); @@ -53,15 +55,10 @@ static void test_default_values(void) static void print_alg_test_param(const crypto_op_test_param_t *p) { - const char *cipher_mode = p->is_bit_mode_cipher ? "bit" : "byte"; + const char *cipher_mode = p->session.cipher_range_in_bits ? "bit" : "byte"; + const char *auth_mode = p->session.auth_range_in_bits ? "bit" : "byte"; - - - - - const char *auth_mode = p->is_bit_mode_auth ? "bit" : "byte"; - - switch (p->op_type) { + switch (p->session.op_type) { case ODP_CRYPTO_OP_TYPE_LEGACY: printf("legacy "); break; @@ -72,7 +69,7 @@ static void print_alg_test_param(const crypto_op_test_param_t *p) printf("out-of-place "); break; } - printf("%s\n", p->op == ODP_CRYPTO_OP_ENCODE ? "encode" : "decode"); + printf("%s\n", p->session.op == ODP_CRYPTO_OP_ENCODE ? "encode" : "decode"); printf("cipher: %s, %s mode\n", cipher_alg_name(p->ref->cipher), cipher_mode); printf(" key length: %d, iv length: %d\n", @@ -93,7 +90,7 @@ static void print_alg_test_param(const crypto_op_test_param_t *p) printf("header length: %d, trailer length: %d\n", p->header_len, p->trailer_len); if (p->adjust_segmentation) printf("segmentation adjusted, first_seg_len: %d\n", p->first_seg_len); - if (p->op_type == ODP_CRYPTO_OP_TYPE_OOP) + if (p->session.op_type == ODP_CRYPTO_OP_TYPE_OOP) printf("oop_shift: %d\n", p->oop_shift); } @@ -122,7 +119,7 @@ static void alg_test_op(crypto_op_test_param_t *param) for (uint32_t n = 0; n < ARRAY_SIZE(oop_shifts); n++) { if (oop_shifts[n] != 0 && - param->op_type != ODP_CRYPTO_OP_TYPE_OOP) + param->session.op_type != ODP_CRYPTO_OP_TYPE_OOP) continue; if ((int32_t)param->header_len + oop_shifts[n] < 0) continue; @@ -150,13 +147,11 @@ typedef enum { AUTH_PLAINTEXT } alg_order_t; -static odp_crypto_session_t session_create(odp_crypto_op_t op, - odp_crypto_op_type_t op_type, - alg_order_t order, - crypto_test_reference_t *ref, - hash_test_mode_t hash_mode) +static int session_create(crypto_session_t *session, + alg_order_t order, + crypto_test_reference_t *ref, + hash_test_mode_t hash_mode) { - odp_crypto_session_t session = ODP_CRYPTO_SESSION_INVALID; int rc; odp_crypto_ses_create_err_t status; odp_crypto_session_param_t ses_params; @@ -176,8 +171,10 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op, /* Create a crypto session */ odp_crypto_session_param_init(&ses_params); - ses_params.op = op; - ses_params.op_type = op_type; + ses_params.op = session->op; + ses_params.op_type = session->op_type; + ses_params.cipher_range_in_bits = session->cipher_range_in_bits; + ses_params.auth_range_in_bits = session->auth_range_in_bits; ses_params.auth_cipher_text = (order == AUTH_CIPHERTEXT); ses_params.op_mode = suite_context.op_mode; ses_params.cipher_alg = ref->cipher; @@ -191,7 +188,7 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op, ses_params.auth_digest_len = ref->digest_length; ses_params.auth_aad_len = ref->aad_length; ses_params.hash_result_in_auth_range = (hash_mode == HASH_OVERLAP); - rc = odp_crypto_session_create(&ses_params, &session, &status); + rc = odp_crypto_session_create(&ses_params, &session->session, &status); if (rc < 0 && status == ODP_CRYPTO_SES_ERR_ALG_COMBO) { if (!combo_warning_shown) { @@ -200,7 +197,7 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op, cipher_alg_name(ref->cipher), auth_alg_name(ref->auth)); } - return ODP_CRYPTO_SESSION_INVALID; + return -1; } /* @@ -214,21 +211,21 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op, cipher_alg_name(ref->cipher), auth_alg_name(ref->auth), ses_params.auth_cipher_text); - return ODP_CRYPTO_SESSION_INVALID; + return -1; } /* For now, allow out-of-place sessions not to be supported. */ if (rc < 0 && status == ODP_CRYPTO_SES_ERR_PARAMS && - op_type == ODP_CRYPTO_OP_TYPE_OOP) { + ses_params.op_type == ODP_CRYPTO_OP_TYPE_OOP) { if (!oop_warning_shown) printf("\n Skipping ODP_CRYPTO_OP_TYPE_OOP tests\n"); oop_warning_shown = 1; - return ODP_CRYPTO_SESSION_INVALID; + return -1; } CU_ASSERT_FATAL(!rc); CU_ASSERT(status == ODP_CRYPTO_SES_ERR_NONE); - CU_ASSERT(odp_crypto_session_to_u64(session) != + CU_ASSERT(odp_crypto_session_to_u64(session->session) != odp_crypto_session_to_u64(ODP_CRYPTO_SESSION_INVALID)); /* @@ -239,7 +236,7 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op, memset(auth_key_data, 0, sizeof(auth_key_data)); memset(&ses_params, 0, sizeof(ses_params)); - return session; + return 0; } static void alg_test_ses(odp_crypto_op_t op, @@ -249,35 +246,32 @@ static void alg_test_ses(odp_crypto_op_t op, odp_packet_data_range_t cipher_range, odp_packet_data_range_t auth_range, uint32_t digest_offset, - odp_bool_t is_bit_mode_cipher, - odp_bool_t is_bit_mode_auth) + odp_bool_t cipher_range_in_bits, + odp_bool_t auth_range_in_bits) { unsigned int initial_num_failures = CU_get_number_of_failures(); const uint32_t reflength = ref_length_in_bytes(ref); + const uint32_t auth_scale = auth_range_in_bits ? 8 : 1; hash_test_mode_t hash_mode = HASH_NO_OVERLAP; - odp_crypto_session_t session; int rc; uint32_t seg_len; uint32_t max_shift; crypto_op_test_param_t test_param; - if (digest_offset >= auth_range.offset && - digest_offset < auth_range.offset + auth_range.length) + if (digest_offset * auth_scale >= auth_range.offset && + digest_offset * auth_scale < auth_range.offset + auth_range.length) hash_mode = HASH_OVERLAP; - session = session_create(op, op_type, order, ref, hash_mode); - if (session == ODP_CRYPTO_SESSION_INVALID) - return; - memset(&test_param, 0, sizeof(test_param)); - test_param.session = session; - test_param.op = op; - test_param.op_type = op_type; + test_param.session.op = op; + test_param.session.op_type = op_type; + test_param.session.cipher_range_in_bits = cipher_range_in_bits; + test_param.session.auth_range_in_bits = auth_range_in_bits; + if (session_create(&test_param.session, order, ref, hash_mode)) + return; test_param.ref = ref; test_param.cipher_range = cipher_range; test_param.auth_range = auth_range; - test_param.is_bit_mode_cipher = is_bit_mode_cipher; - test_param.is_bit_mode_auth = is_bit_mode_auth; test_param.digest_offset = digest_offset; alg_test_op(&test_param); @@ -319,18 +313,18 @@ static void alg_test_ses(odp_crypto_op_t op, alg_test_op(&test_param); } - rc = odp_crypto_session_destroy(session); + rc = odp_crypto_session_destroy(test_param.session.session); CU_ASSERT(!rc); } -static void alg_test(odp_crypto_op_t op, - alg_order_t order, - crypto_test_reference_t *ref, - odp_packet_data_range_t cipher_range, - odp_packet_data_range_t auth_range, - uint32_t digest_offset, - odp_bool_t is_bit_mode_cipher, - odp_bool_t is_bit_mode_auth) +static void alg_test_op_types(odp_crypto_op_t op, + alg_order_t order, + crypto_test_reference_t *ref, + odp_packet_data_range_t cipher_range, + odp_packet_data_range_t auth_range, + uint32_t digest_offset, + odp_bool_t cipher_range_in_bits, + odp_bool_t auth_range_in_bits) { odp_crypto_op_type_t op_types[] = { ODP_CRYPTO_OP_TYPE_LEGACY, @@ -346,8 +340,47 @@ static void alg_test(odp_crypto_op_t op, cipher_range, auth_range, digest_offset, - is_bit_mode_cipher, - is_bit_mode_auth); + cipher_range_in_bits, + auth_range_in_bits); + } +} + +static void alg_test(odp_crypto_op_t op, + alg_order_t order, + crypto_test_reference_t *ref, + odp_packet_data_range_t cipher_bit_range, + odp_packet_data_range_t auth_bit_range, + uint32_t digest_offset, + odp_bool_t is_bit_mode_cipher, + odp_bool_t is_bit_mode_auth) +{ + odp_packet_data_range_t cipher_range; + odp_packet_data_range_t auth_range; + + for (int cr_in_bits = 0; cr_in_bits <= 1; cr_in_bits++) { + if (!cr_in_bits && cipher_bit_range.length % 8 != 0) + continue; + if (cr_in_bits && !is_bit_mode_cipher) + continue; + for (int ar_in_bits = 0; ar_in_bits <= 1; ar_in_bits++) { + if (!ar_in_bits && auth_bit_range.length % 8 != 0) + continue; + if (ar_in_bits && !is_bit_mode_auth) + continue; + + cipher_range = cipher_bit_range; + auth_range = auth_bit_range; + if (!cr_in_bits) { + cipher_range.offset /= 8; + cipher_range.length /= 8; + } + if (!ar_in_bits) { + auth_range.offset /= 8; + auth_range.length /= 8; + } + alg_test_op_types(op, order, ref, cipher_range, auth_range, + digest_offset, cr_in_bits, ar_in_bits); + } } } @@ -404,8 +437,8 @@ static void check_alg(odp_crypto_op_t op, odp_bool_t is_bit_mode_cipher = false; odp_bool_t is_bit_mode_auth = false; uint32_t digest_offs = ref_length_in_bytes(&ref[idx]); - odp_packet_data_range_t cipher_range = {.offset = 0}; - odp_packet_data_range_t auth_range = {.offset = 0}; + odp_packet_data_range_t cipher_bit_range = {.offset = 0}; + odp_packet_data_range_t auth_bit_range = {.offset = 0}; if (ref_length_in_bits(&ref[idx]) % 8 != 0) bit_mode_needed = true; @@ -465,18 +498,14 @@ static void check_alg(odp_crypto_op_t op, continue; } - cipher_range.length = is_bit_mode_cipher ? - ref_length_in_bits(&ref[idx]) : - ref_length_in_bytes(&ref[idx]); - auth_range.length = is_bit_mode_auth ? - ref_length_in_bits(&ref[idx]) : - ref_length_in_bytes(&ref[idx]); + cipher_bit_range.length = ref_length_in_bits(&ref[idx]); + auth_bit_range.length = ref_length_in_bits(&ref[idx]); alg_test(op, AUTH_PLAINTEXT, &ref[idx], - cipher_range, auth_range, digest_offs, + cipher_bit_range, auth_bit_range, digest_offs, is_bit_mode_cipher, is_bit_mode_auth); alg_test(op, AUTH_CIPHERTEXT, &ref[idx], - cipher_range, auth_range, digest_offs, + cipher_bit_range, auth_bit_range, digest_offs, is_bit_mode_cipher, is_bit_mode_auth); cipher_tested[cipher_idx] = true; @@ -537,7 +566,7 @@ static int create_hash_test_reference(odp_auth_alg_t auth, uint32_t digest_offset, uint8_t digest_fill) { - odp_crypto_session_t session; + crypto_session_t session; int rc; odp_packet_t pkt; odp_bool_t ok; @@ -570,33 +599,33 @@ static int create_hash_test_reference(odp_auth_alg_t auth, rc = odp_packet_copy_from_mem(pkt, 0, auth_bytes, ref->plaintext); CU_ASSERT(rc == 0); - session = session_create(ODP_CRYPTO_OP_ENCODE, - ODP_CRYPTO_OP_TYPE_LEGACY, - AUTH_PLAINTEXT, ref, HASH_NO_OVERLAP); - if (session == ODP_CRYPTO_SESSION_INVALID) + session.op = ODP_CRYPTO_OP_ENCODE; + session.op_type = ODP_CRYPTO_OP_TYPE_LEGACY; + session.cipher_range_in_bits = false; + session.auth_range_in_bits = false; + if (session_create(&session, AUTH_PLAINTEXT, ref, HASH_NO_OVERLAP)) return -1; odp_crypto_packet_op_param_t op_params = { - .session = session, + .session = session.session, .cipher_iv_ptr = ref->cipher_iv, .auth_iv_ptr = ref->auth_iv, .hash_result_offset = enc_digest_offset, .aad_ptr = ref->aad, .cipher_range = {.offset = 0, .length = 0}, - .auth_range = { .offset = 0, - .length = capa->bit_mode ? auth_bytes * 8 : auth_bytes }, + .auth_range = { .offset = 0, .length = auth_bytes }, .dst_offset_shift = 0, }; rc = crypto_op(pkt, &pkt, &ok, &op_params, ODP_CRYPTO_OP_TYPE_LEGACY); CU_ASSERT(rc == 0); if (rc) { - (void)odp_crypto_session_destroy(session); + (void)odp_crypto_session_destroy(session.session); return -1; } CU_ASSERT(ok); - rc = odp_crypto_session_destroy(session); + rc = odp_crypto_session_destroy(session.session); CU_ASSERT(rc == 0); /* copy the processed packet to the ciphertext packet in ref */ @@ -624,8 +653,8 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth, { static crypto_test_reference_t ref = {.length = 0}; uint32_t digest_offset = 13; - const odp_packet_data_range_t cipher_range = {.offset = 0, .length = 0}; - odp_packet_data_range_t auth_range; + const odp_packet_data_range_t cipher_bit_range = {.offset = 0, .length = 0}; + odp_packet_data_range_t auth_bit_range; if (!full_test && capa->digest_len % 4 != 0) return; @@ -637,10 +666,8 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth, if (create_hash_test_reference(auth, capa, &ref, digest_offset, 0)) return; - auth_range.offset = 0; - auth_range.length = capa->bit_mode ? - ref_length_in_bits(&ref) : - ref_length_in_bytes(&ref); + auth_bit_range.offset = 0; + auth_bit_range.length = ref_length_in_bits(&ref); /* * Decode the ciphertext packet. @@ -652,7 +679,7 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth, alg_test(ODP_CRYPTO_OP_DECODE, order, &ref, - cipher_range, auth_range, + cipher_bit_range, auth_bit_range, digest_offset, false, capa->bit_mode); @@ -664,10 +691,8 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth, if (create_hash_test_reference(auth, capa, &ref, digest_offset, 1)) return; - auth_range.offset = 0; - auth_range.length = capa->bit_mode ? - ref_length_in_bits(&ref) : - ref_length_in_bytes(&ref); + auth_bit_range.offset = 0; + auth_bit_range.length = ref_length_in_bits(&ref); /* * Encode the plaintext packet. @@ -679,7 +704,7 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth, alg_test(ODP_CRYPTO_OP_ENCODE, order, &ref, - cipher_range, auth_range, + cipher_bit_range, auth_bit_range, digest_offset, false, capa->bit_mode); @@ -689,6 +714,7 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth, * Cipher algorithms that are not AEAD algorithms */ static odp_cipher_alg_t cipher_algs[] = { + ODP_CIPHER_ALG_NULL, ODP_CIPHER_ALG_DES, ODP_CIPHER_ALG_3DES_CBC, ODP_CIPHER_ALG_3DES_ECB, @@ -704,10 +730,11 @@ static odp_cipher_alg_t cipher_algs[] = { }; /* - * Authentication algorithms and hashes that use auth_range + * Authentication algorithms and hashes that may use auth_range * parameter. AEAD algorithms are excluded. */ static odp_auth_alg_t auth_algs[] = { + ODP_AUTH_ALG_NULL, ODP_AUTH_ALG_MD5_HMAC, ODP_AUTH_ALG_SHA1_HMAC, ODP_AUTH_ALG_SHA224_HMAC, @@ -763,7 +790,7 @@ static int crypto_encode_ref(crypto_test_reference_t *ref, odp_packet_data_range_t zero_range = {.offset = 0, .length = 0}; odp_packet_t pkt; int rc; - odp_crypto_session_t session; + crypto_session_t session; odp_bool_t ok; pkt = odp_packet_alloc(suite_context.pool, ref->length); @@ -772,13 +799,11 @@ static int crypto_encode_ref(crypto_test_reference_t *ref, rc = odp_packet_copy_from_mem(pkt, 0, ref->length, ref->plaintext); CU_ASSERT(rc == 0); - session = session_create(ODP_CRYPTO_OP_ENCODE, - ODP_CRYPTO_OP_TYPE_LEGACY, - AUTH_PLAINTEXT, - ref, - HASH_OVERLAP); - - if (session == ODP_CRYPTO_SESSION_INVALID) { + session.op = ODP_CRYPTO_OP_ENCODE; + session.op_type = ODP_CRYPTO_OP_TYPE_LEGACY; + session.cipher_range_in_bits = false; + session.auth_range_in_bits = false; + if (session_create(&session, AUTH_PLAINTEXT, ref, HASH_OVERLAP)) { odp_packet_free(pkt); return 1; } @@ -793,7 +818,7 @@ static int crypto_encode_ref(crypto_test_reference_t *ref, CU_ASSERT_FATAL(hash_result_offset + ref->digest_length <= ref->length); odp_crypto_packet_op_param_t op_params = { - .session = session, + .session = session.session, .cipher_iv_ptr = ref->cipher_iv, .auth_iv_ptr = ref->auth_iv, .hash_result_offset = hash_result_offset, @@ -805,12 +830,12 @@ static int crypto_encode_ref(crypto_test_reference_t *ref, rc = crypto_op(pkt, &pkt, &ok, &op_params, ODP_CRYPTO_OP_TYPE_LEGACY); CU_ASSERT(rc == 0); if (rc) { - (void)odp_crypto_session_destroy(session); + (void)odp_crypto_session_destroy(session.session); return -1; } CU_ASSERT(ok); - rc = odp_crypto_session_destroy(session); + rc = odp_crypto_session_destroy(session.session); CU_ASSERT(rc == 0); rc = odp_packet_copy_to_mem(pkt, 0, ref->length, ref->ciphertext); @@ -834,8 +859,8 @@ typedef struct crypto_suite_t { */ static int create_combined_ref(const crypto_suite_t *suite, crypto_test_reference_t *ref, - odp_packet_data_range_t *cipher_range, - odp_packet_data_range_t *auth_range, + const odp_packet_data_range_t *cipher_range, + const odp_packet_data_range_t *auth_range, uint32_t digest_offset) { uint32_t total_len; @@ -861,15 +886,6 @@ static int create_combined_ref(const crypto_suite_t *suite, ref->is_length_in_bits = false; ref->length = total_len; - if (suite->cipher_capa->bit_mode) { - cipher_range->offset *= 8; - cipher_range->length *= 8; - } - if (suite->auth_capa->bit_mode) { - auth_range->offset *= 8; - auth_range->length *= 8; - } - if (ref->auth_key_length > MAX_KEY_LEN || ref->auth_iv_length > MAX_IV_LEN || total_len > MAX_DATA_LEN || @@ -1189,6 +1205,11 @@ static void test_combo(const crypto_suite_t *suite, if (rc) return; + cipher_range.offset *= 8; + cipher_range.length *= 8; + auth_range.offset *= 8; + auth_range.length *= 8; + alg_test(ODP_CRYPTO_OP_ENCODE, suite->order, &ref, diff --git a/test/validation/api/dma/dma.c b/test/validation/api/dma/dma.c index 6c8eeb00c..05771e3cb 100644 --- a/test/validation/api/dma/dma.c +++ b/test/validation/api/dma/dma.c @@ -19,6 +19,8 @@ #define MULTI 1 #define RESULT 1 #define USER_DATA 0xdeadbeef +#define ELEM_NUM 10 +#define UAREA 0xaa #define MIN(a, b) (a < b ? a : b) @@ -39,6 +41,11 @@ typedef struct global_t { } global_t; +typedef struct { + uint32_t count; + uint8_t mark[ELEM_NUM]; +} uarea_init_t; + static global_t global; static int dma_suite_init(void) @@ -234,6 +241,8 @@ static void test_dma_param(uint8_t fill) memset(&dma_pool_param, fill, sizeof(dma_pool_param)); odp_dma_pool_param_init(&dma_pool_param); + CU_ASSERT(dma_pool_param.uarea_init.init_fn == NULL); + CU_ASSERT(dma_pool_param.uarea_init.args == NULL); CU_ASSERT(dma_pool_param.uarea_size == 0); CU_ASSERT(dma_pool_param.cache_size <= global.dma_capa.pool.max_cache_size); CU_ASSERT(dma_pool_param.cache_size >= global.dma_capa.pool.min_cache_size); @@ -417,7 +426,7 @@ static void test_dma_compl_pool_max_pools(void) static void test_dma_compl_user_area(void) { odp_dma_pool_param_t dma_pool_param; - uint32_t num = MIN(10, global.dma_capa.pool.max_num), + uint32_t num = MIN(ELEM_NUM, global.dma_capa.pool.max_num), size = global.dma_capa.pool.max_uarea_size, i; odp_pool_t pool; odp_dma_compl_t compl_evs[num]; @@ -432,6 +441,7 @@ static void test_dma_compl_user_area(void) for (i = 0; i < num; i++) { odp_event_t ev; + int flag; compl_evs[i] = odp_dma_compl_alloc(pool); @@ -445,6 +455,8 @@ static void test_dma_compl_user_area(void) ev = odp_dma_compl_to_event(compl_evs[i]); CU_ASSERT(odp_event_user_area(ev) == addr); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); + CU_ASSERT(flag < 0); prev = addr; memset(addr, 0, size); @@ -458,6 +470,56 @@ static void test_dma_compl_user_area(void) CU_ASSERT(odp_pool_destroy(pool) == 0); } +static void init_event_uarea(void *uarea, uint32_t size, void *args, uint32_t index) +{ + uarea_init_t *data = args; + + data->count++; + data->mark[index] = 1; + memset(uarea, UAREA, size); +} + +static void test_dma_compl_user_area_init(void) +{ + odp_dma_pool_param_t dma_pool_param; + uint32_t num = MIN(ELEM_NUM, global.dma_capa.pool.max_num), i; + odp_pool_t pool; + uarea_init_t data; + odp_dma_compl_t compl_evs[num]; + uint8_t *uarea; + + memset(&data, 0, sizeof(uarea_init_t)); + odp_dma_pool_param_init(&dma_pool_param); + dma_pool_param.uarea_init.init_fn = init_event_uarea; + dma_pool_param.uarea_init.args = &data; + dma_pool_param.num = num; + dma_pool_param.uarea_size = 1; + pool = odp_dma_pool_create(NULL, &dma_pool_param); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + CU_ASSERT(data.count == num); + + for (i = 0; i < num; i++) { + CU_ASSERT(data.mark[i] == 1); + + compl_evs[i] = odp_dma_compl_alloc(pool); + + CU_ASSERT(compl_evs[i] != ODP_DMA_COMPL_INVALID); + + if (compl_evs[i] == ODP_DMA_COMPL_INVALID) + break; + + uarea = odp_dma_compl_user_area(compl_evs[i]); + + CU_ASSERT(*uarea == UAREA); + } + + for (uint32_t j = 0; j < i; j++) + odp_dma_compl_free(compl_evs[j]); + + odp_pool_destroy(pool); +} + static void init_source(uint8_t *src, uint32_t len) { uint32_t i; @@ -1171,6 +1233,17 @@ static int check_event_user_area(void) return ODP_TEST_INACTIVE; } +static int check_event_user_area_init(void) +{ + if (global.disabled) + return ODP_TEST_INACTIVE; + + if (global.dma_capa.pool.max_uarea_size > 0 && global.dma_capa.pool.uarea_persistence) + return ODP_TEST_ACTIVE; + + return ODP_TEST_INACTIVE; +} + static int check_scheduled(void) { if (global.disabled) @@ -1568,6 +1641,7 @@ odp_testinfo_t dma_suite[] = { ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool_same_name, check_event), ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool_max_pools, check_event), ODP_TEST_INFO_CONDITIONAL(test_dma_compl_user_area, check_event_user_area), + ODP_TEST_INFO_CONDITIONAL(test_dma_compl_user_area_init, check_event_user_area_init), ODP_TEST_INFO_CONDITIONAL(test_dma_addr_to_addr_sync, check_sync), ODP_TEST_INFO_CONDITIONAL(test_dma_addr_to_addr_sync_mtrs, check_sync), ODP_TEST_INFO_CONDITIONAL(test_dma_addr_to_addr_sync_mseg, check_sync), diff --git a/test/validation/api/event/event.c b/test/validation/api/event/event.c index 1d6422f96..f6ad86365 100644 --- a/test/validation/api/event/event.c +++ b/test/validation/api/event/event.c @@ -1,4 +1,5 @@ /* Copyright (c) 2017-2018, Linaro Limited + * Copyright (c) 2023, Nokia * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -349,6 +350,50 @@ static void event_test_type_multi(void) CU_ASSERT(odp_pool_destroy(pkt_pool) == 0); } +static void event_test_types_multi(void) +{ + odp_pool_t buf_pool, pkt_pool; + odp_event_t buf_event[NUM_TYPE_TEST]; + odp_event_t pkt_event[NUM_TYPE_TEST]; + odp_event_t event[2 * NUM_TYPE_TEST]; + odp_event_type_t event_types[2 * NUM_TYPE_TEST]; + odp_event_subtype_t event_subtypes[2 * NUM_TYPE_TEST]; + int i; + + type_test_init(&buf_pool, &pkt_pool, buf_event, pkt_event, event); + + /* Only buffers */ + odp_event_types_multi(buf_event, event_types, event_subtypes, NUM_TYPE_TEST); + for (i = 0; i < NUM_TYPE_TEST; i++) { + CU_ASSERT(event_types[i] == ODP_EVENT_BUFFER); + CU_ASSERT(event_subtypes[i] == ODP_EVENT_NO_SUBTYPE); + } + + /* Only packets */ + odp_event_types_multi(pkt_event, event_types, event_subtypes, NUM_TYPE_TEST); + for (i = 0; i < NUM_TYPE_TEST; i++) { + CU_ASSERT(event_types[i] == ODP_EVENT_PACKET); + CU_ASSERT(event_subtypes[i] == ODP_EVENT_PACKET_BASIC); + } + + /* Mixed events: B P BB PP BBB PPP */ + odp_event_types_multi(event, event_types, NULL, 2 * NUM_TYPE_TEST); + for (i = 0; i < 2 * NUM_TYPE_TEST; i++) { + if (i == 0 || i == 2 || i == 3 || i == 6 || i == 7 || i == 8) { + /* CU_ASSERT requires extra brackets */ + CU_ASSERT(event_types[i] == ODP_EVENT_BUFFER); + } else { + CU_ASSERT(event_types[i] == ODP_EVENT_PACKET); + } + } + + odp_event_free_multi(buf_event, NUM_TYPE_TEST); + odp_event_free_multi(pkt_event, NUM_TYPE_TEST); + + CU_ASSERT(odp_pool_destroy(buf_pool) == 0); + CU_ASSERT(odp_pool_destroy(pkt_pool) == 0); +} + static void event_test_filter_packet(void) { odp_pool_t buf_pool, pkt_pool; @@ -400,6 +445,7 @@ odp_testinfo_t event_suite[] = { ODP_TEST_INFO(event_test_free_multi), ODP_TEST_INFO(event_test_free_multi_mixed), ODP_TEST_INFO(event_test_type_multi), + ODP_TEST_INFO(event_test_types_multi), ODP_TEST_INFO(event_test_filter_packet), ODP_TEST_INFO(event_test_is_valid), ODP_TEST_INFO_NULL, diff --git a/test/validation/api/ipsec/ipsec.c b/test/validation/api/ipsec/ipsec.c index ea2685666..87688838b 100644 --- a/test/validation/api/ipsec/ipsec.c +++ b/test/validation/api/ipsec/ipsec.c @@ -447,6 +447,7 @@ static void ipsec_status_event_handle(odp_event_t ev_status, odp_ipsec_sa_t sa, enum ipsec_test_sa_expiry sa_expiry) { + int flag; odp_ipsec_status_t status = { .id = 0, .sa = ODP_IPSEC_SA_INVALID, @@ -460,6 +461,8 @@ static void ipsec_status_event_handle(odp_event_t ev_status, /* No user area for IPsec status events */ CU_ASSERT(odp_event_user_area(ev_status) == NULL); + CU_ASSERT(odp_event_user_area_and_flag(ev_status, &flag) == NULL); + CU_ASSERT(flag < 0); CU_ASSERT_EQUAL(0, odp_ipsec_status(&status, ev_status)); CU_ASSERT_EQUAL(ODP_IPSEC_STATUS_WARN, status.id); diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index a7631d47c..43530220e 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -3262,6 +3262,7 @@ static void packet_vector_test_user_area(void) for (i = 0; i < num; i++) { odp_event_t ev; + int flag; pktv[i] = odp_packet_vector_alloc(pool); @@ -3275,6 +3276,8 @@ static void packet_vector_test_user_area(void) ev = odp_packet_vector_to_event(pktv[i]); CU_ASSERT(odp_event_user_area(ev) == addr); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); + CU_ASSERT(flag == 0); prev = addr; memset(addr, 0, size); @@ -3448,6 +3451,7 @@ static void packet_test_user_area(void) odp_packet_t pkt; odp_pool_t pool; odp_event_t ev; + int flag; memcpy(¶m, &default_param, sizeof(odp_pool_param_t)); @@ -3465,6 +3469,8 @@ static void packet_test_user_area(void) } ev = odp_packet_to_event(pkt); CU_ASSERT(odp_event_user_area(ev) == odp_packet_user_area(pkt)); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt)); + CU_ASSERT(flag == 0); odp_packet_free(pkt); CU_ASSERT(odp_pool_destroy(pool) == 0); @@ -3480,6 +3486,8 @@ static void packet_test_user_area(void) CU_ASSERT_FATAL(odp_packet_user_area(pkt) != NULL); ev = odp_packet_to_event(pkt); CU_ASSERT(odp_event_user_area(ev) == odp_packet_user_area(pkt)); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt)); + CU_ASSERT(flag == 0); CU_ASSERT(odp_packet_user_area_size(pkt) >= 1); *(char *)odp_packet_user_area(pkt) = 0; CU_ASSERT_FATAL(odp_packet_is_valid(pkt) == 1); @@ -3491,9 +3499,12 @@ static void packet_test_user_area(void) CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); pkt = odp_packet_alloc(pool, param.pkt.len); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + odp_packet_user_flag_set(pkt, 1); CU_ASSERT_FATAL(odp_packet_user_area(pkt) != NULL); ev = odp_packet_to_event(pkt); CU_ASSERT(odp_event_user_area(ev) == odp_packet_user_area(pkt)); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt)); + CU_ASSERT(flag > 0); CU_ASSERT(odp_packet_user_area_size(pkt) == param.pkt.uarea_size); memset(odp_packet_user_area(pkt), 0, param.pkt.uarea_size); CU_ASSERT_FATAL(odp_packet_is_valid(pkt) == 1); diff --git a/test/validation/api/pktio/pktio.c b/test/validation/api/pktio/pktio.c index f412a01c4..fa752c0a2 100644 --- a/test/validation/api/pktio/pktio.c +++ b/test/validation/api/pktio/pktio.c @@ -3513,7 +3513,7 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue) pktio_info_t pktio_rx_info; odp_pktio_config_t config; odp_queue_param_t qparam; - int ret, i, num_rx = 0; + int flag, ret, i, num_rx = 0; odp_event_t ev; uint64_t wait; @@ -3647,6 +3647,8 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue) /* No user area for TX completion events */ CU_ASSERT(odp_event_user_area(ev) == NULL); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == NULL); + CU_ASSERT(flag < 0); /* Alternatively call event free / compl free */ if (i % 2) @@ -3685,6 +3687,8 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue) /* No user area for TX completion events */ CU_ASSERT(odp_event_user_area(ev) == NULL); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == NULL); + CU_ASSERT(flag < 0); /* Check that sequence number is found */ CU_ASSERT(j < TX_BATCH_LEN); diff --git a/test/validation/api/pool/pool.c b/test/validation/api/pool/pool.c index b335f194c..5176bb96f 100644 --- a/test/validation/api/pool/pool.c +++ b/test/validation/api/pool/pool.c @@ -20,8 +20,11 @@ #define VEC_LEN 32 #define PKT_LEN 400 #define PKT_NUM 500 +#define ELEM_NUM 10 +#define ELEM_SIZE 128 #define CACHE_SIZE 32 #define MAX_NUM_DEFAULT (10 * 1024 * 1024) +#define UAREA 0xaa #define EXT_NUM_BUF 10 #define EXT_BUF_SIZE 2048 @@ -31,6 +34,8 @@ #define EXT_HEADROOM 16 #define MAGIC_U8 0x7a +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) + typedef struct { odp_barrier_t init_barrier; odp_atomic_u32_t index; @@ -38,6 +43,11 @@ typedef struct { odp_pool_t pool; } global_shared_mem_t; +typedef struct { + uint32_t count; + uint8_t mark[ELEM_NUM]; +} uarea_init_t; + static global_shared_mem_t *global_mem; static odp_pool_capability_t global_pool_capa; @@ -51,6 +61,9 @@ static void test_param_init(uint8_t fill) memset(¶m, fill, sizeof(param)); odp_pool_param_init(¶m); + CU_ASSERT(param.uarea_init.init_fn == NULL); + CU_ASSERT(param.uarea_init.args == NULL); + CU_ASSERT(param.buf.uarea_size == 0); CU_ASSERT(param.buf.cache_size >= global_pool_capa.buf.min_cache_size && param.buf.cache_size <= global_pool_capa.buf.max_cache_size); @@ -146,6 +159,218 @@ static void pool_test_create_destroy_vector(void) pool_create_destroy(¶m); } +static int pool_check_buffer_uarea_init(void) +{ + if (global_pool_capa.buf.max_uarea_size == 0 || !global_pool_capa.buf.uarea_persistence) + return ODP_TEST_INACTIVE; + + return ODP_TEST_ACTIVE; +} + +static int pool_check_packet_uarea_init(void) +{ + if (global_pool_capa.pkt.max_uarea_size == 0 || !global_pool_capa.pkt.uarea_persistence) + return ODP_TEST_INACTIVE; + + return ODP_TEST_ACTIVE; +} + +static int pool_check_vector_uarea_init(void) +{ + if (global_pool_capa.vector.max_uarea_size == 0 || + !global_pool_capa.vector.uarea_persistence) + return ODP_TEST_INACTIVE; + + return ODP_TEST_ACTIVE; +} + +static int pool_check_timeout_uarea_init(void) +{ + if (global_pool_capa.tmo.max_uarea_size == 0 || !global_pool_capa.tmo.uarea_persistence) + return ODP_TEST_INACTIVE; + + return ODP_TEST_ACTIVE; +} + +static void init_event_uarea(void *uarea, uint32_t size, void *args, uint32_t index) +{ + uarea_init_t *data = args; + + data->count++; + data->mark[index] = 1; + memset(uarea, UAREA, size); +} + +static void pool_test_buffer_uarea_init(void) +{ + odp_pool_param_t param; + uint32_t num = MIN(global_pool_capa.buf.max_num, ELEM_NUM), + size = MIN(global_pool_capa.buf.max_size, ELEM_SIZE), i; + odp_pool_t pool; + uarea_init_t data; + odp_buffer_t bufs[num]; + uint8_t *uarea; + + memset(&data, 0, sizeof(uarea_init_t)); + odp_pool_param_init(¶m); + param.type = ODP_POOL_BUFFER; + param.uarea_init.init_fn = init_event_uarea; + param.uarea_init.args = &data; + param.buf.num = num; + param.buf.size = size; + param.buf.uarea_size = 1; + pool = odp_pool_create(NULL, ¶m); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + CU_ASSERT(data.count == num); + + for (i = 0; i < num; i++) { + CU_ASSERT(data.mark[i] == 1); + + bufs[i] = odp_buffer_alloc(pool); + + CU_ASSERT(bufs[i] != ODP_BUFFER_INVALID); + + if (bufs[i] == ODP_BUFFER_INVALID) + break; + + uarea = odp_buffer_user_area(bufs[i]); + + CU_ASSERT(*uarea == UAREA); + } + + odp_buffer_free_multi(bufs, i); + odp_pool_destroy(pool); +} + +static void pool_test_packet_uarea_init(void) +{ + odp_pool_param_t param; + uint32_t num = MIN(global_pool_capa.pkt.max_num, ELEM_NUM), + size = MIN(global_pool_capa.pkt.max_len, ELEM_SIZE), i; + odp_pool_t pool; + uarea_init_t data; + odp_packet_t pkts[num]; + uint8_t *uarea; + + memset(&data, 0, sizeof(uarea_init_t)); + odp_pool_param_init(¶m); + param.type = ODP_POOL_PACKET; + param.uarea_init.init_fn = init_event_uarea; + param.uarea_init.args = &data; + param.pkt.num = num; + param.pkt.len = size; + param.pkt.uarea_size = 1; + pool = odp_pool_create(NULL, ¶m); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + CU_ASSERT(data.count == num); + + for (i = 0; i < num; i++) { + CU_ASSERT(data.mark[i] == 1); + + pkts[i] = odp_packet_alloc(pool, ELEM_SIZE); + + CU_ASSERT(pkts[i] != ODP_PACKET_INVALID); + + if (pkts[i] == ODP_PACKET_INVALID) + break; + + uarea = odp_packet_user_area(pkts[i]); + + CU_ASSERT(*uarea == UAREA); + } + + odp_packet_free_multi(pkts, i); + odp_pool_destroy(pool); +} + +static void pool_test_vector_uarea_init(void) +{ + odp_pool_param_t param; + uint32_t num = MIN(global_pool_capa.vector.max_num, ELEM_NUM), + size = MIN(global_pool_capa.vector.max_size, ELEM_NUM), i; + odp_pool_t pool; + uarea_init_t data; + odp_packet_vector_t vecs[num]; + uint8_t *uarea; + + memset(&data, 0, sizeof(uarea_init_t)); + odp_pool_param_init(¶m); + param.type = ODP_POOL_VECTOR; + param.uarea_init.init_fn = init_event_uarea; + param.uarea_init.args = &data; + param.vector.num = num; + param.vector.max_size = size; + param.vector.uarea_size = 1; + pool = odp_pool_create(NULL, ¶m); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + CU_ASSERT(data.count == num); + + for (i = 0; i < num; i++) { + CU_ASSERT(data.mark[i] == 1); + + vecs[i] = odp_packet_vector_alloc(pool); + + CU_ASSERT(vecs[i] != ODP_PACKET_VECTOR_INVALID); + + if (vecs[i] == ODP_PACKET_VECTOR_INVALID) + break; + + uarea = odp_packet_vector_user_area(vecs[i]); + + CU_ASSERT(*uarea == UAREA); + } + + for (uint32_t j = 0; j < i; j++) + odp_packet_vector_free(vecs[j]); + + odp_pool_destroy(pool); +} + +static void pool_test_timeout_uarea_init(void) +{ + odp_pool_param_t param; + uint32_t num = MIN(global_pool_capa.tmo.max_num, ELEM_NUM), i; + odp_pool_t pool; + uarea_init_t data; + odp_timeout_t tmos[num]; + uint8_t *uarea; + + memset(&data, 0, sizeof(uarea_init_t)); + odp_pool_param_init(¶m); + param.type = ODP_POOL_TIMEOUT; + param.uarea_init.init_fn = init_event_uarea; + param.uarea_init.args = &data; + param.tmo.num = num; + param.tmo.uarea_size = 1; + pool = odp_pool_create(NULL, ¶m); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + CU_ASSERT(data.count == num); + + for (i = 0; i < num; i++) { + CU_ASSERT(data.mark[i] == 1); + + tmos[i] = odp_timeout_alloc(pool); + + CU_ASSERT(tmos[i] != ODP_TIMEOUT_INVALID); + + if (tmos[i] == ODP_TIMEOUT_INVALID) + break; + + uarea = odp_timeout_user_area(tmos[i]); + + CU_ASSERT(*uarea == UAREA); + } + + for (uint32_t j = 0; j < i; j++) + odp_timeout_free(tmos[j]); + + odp_pool_destroy(pool); +} + static void pool_test_lookup_info_print(void) { odp_pool_t pool; @@ -1505,6 +1730,8 @@ static void test_ext_param_init(uint8_t fill) odp_pool_ext_param_init(ODP_POOL_PACKET, ¶m); CU_ASSERT(param.type == ODP_POOL_PACKET); + CU_ASSERT(param.uarea_init.init_fn == NULL); + CU_ASSERT(param.uarea_init.args == NULL); CU_ASSERT(param.cache_size >= global_pool_ext_capa.min_cache_size && param.cache_size <= global_pool_ext_capa.max_cache_size); CU_ASSERT(param.stats.all == 0); @@ -1791,6 +2018,57 @@ static void test_packet_pool_ext_alloc(void) packet_pool_ext_alloc(PKT_LEN_NORMAL); } +static void test_packet_pool_ext_uarea_init(void) +{ + odp_pool_ext_capability_t capa; + odp_pool_ext_param_t param; + uint32_t num = ELEM_NUM, i; + odp_pool_t pool; + uarea_init_t data; + odp_shm_t shm; + uint8_t *uarea; + + CU_ASSERT_FATAL(odp_pool_ext_capability(ODP_POOL_PACKET, &capa) == 0); + + memset(&data, 0, sizeof(uarea_init_t)); + pool_ext_init_packet_pool_param(¶m); + param.uarea_init.init_fn = init_event_uarea; + param.uarea_init.args = &data; + num = MIN(num, param.pkt.num_buf); + param.pkt.num_buf = num; + param.pkt.uarea_size = 1; + pool = odp_pool_ext_create(NULL, ¶m); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + + void *buf[num]; + odp_packet_t pkts[num]; + + shm = populate_pool(pool, &capa, buf, num, param.pkt.buf_size); + + CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); + CU_ASSERT(data.count == num); + + for (i = 0; i < num; i++) { + CU_ASSERT(data.mark[i] == 1); + + pkts[i] = odp_packet_alloc(pool, (param.pkt.buf_size - param.pkt.headroom) / 2); + + CU_ASSERT(pkts[i] != ODP_PACKET_INVALID); + + if (pkts[i] == ODP_PACKET_INVALID) + break; + + uarea = odp_packet_user_area(pkts[i]); + + CU_ASSERT(*uarea == UAREA); + } + + odp_packet_free_multi(pkts, i); + odp_pool_destroy(pool); + odp_shm_free(shm); +} + static void test_packet_pool_ext_alloc_max(void) { packet_pool_ext_alloc(PKT_LEN_MAX); @@ -1961,6 +2239,15 @@ static int check_pool_ext_support(void) return ODP_TEST_ACTIVE; } +static int check_pool_ext_uarea_init_support(void) +{ + if (global_pool_ext_capa.max_pools == 0 || !global_pool_ext_capa.pkt.uarea_persistence || + global_pool_ext_capa.pkt.max_uarea_size == 0) + return ODP_TEST_INACTIVE; + + return ODP_TEST_ACTIVE; +} + static int check_pool_ext_segment_support(void) { if (global_pool_ext_capa.max_pools == 0 || global_pool_ext_capa.pkt.max_segs_per_pkt < 2) @@ -1975,6 +2262,10 @@ odp_testinfo_t pool_suite[] = { ODP_TEST_INFO(pool_test_create_destroy_packet), ODP_TEST_INFO(pool_test_create_destroy_timeout), ODP_TEST_INFO(pool_test_create_destroy_vector), + ODP_TEST_INFO_CONDITIONAL(pool_test_buffer_uarea_init, pool_check_buffer_uarea_init), + ODP_TEST_INFO_CONDITIONAL(pool_test_packet_uarea_init, pool_check_packet_uarea_init), + ODP_TEST_INFO_CONDITIONAL(pool_test_vector_uarea_init, pool_check_vector_uarea_init), + ODP_TEST_INFO_CONDITIONAL(pool_test_timeout_uarea_init, pool_check_timeout_uarea_init), ODP_TEST_INFO(pool_test_lookup_info_print), ODP_TEST_INFO(pool_test_same_name_buf), ODP_TEST_INFO(pool_test_same_name_pkt), @@ -2022,6 +2313,8 @@ odp_testinfo_t pool_ext_suite[] = { ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_info, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_populate, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_alloc, check_pool_ext_support), + ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_uarea_init, + check_pool_ext_uarea_init_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_alloc_max, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_alloc_seg, check_pool_ext_segment_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_disassemble, check_pool_ext_segment_support), diff --git a/test/validation/api/shmem/shmem.c b/test/validation/api/shmem/shmem.c index 86d070a4a..257e0214e 100644 --- a/test/validation/api/shmem/shmem.c +++ b/test/validation/api/shmem/shmem.c @@ -99,7 +99,7 @@ static int run_test_basic_thread(void *arg ODP_UNUSED) odp_shm_print_all(); CU_ASSERT(TEST_SHARE_FOO == shared_test_data->foo); CU_ASSERT(TEST_SHARE_BAR == shared_test_data->bar); - CU_ASSERT(0 == odp_shm_info(shm, &info)); + CU_ASSERT_FATAL(0 == odp_shm_info(shm, &info)); CU_ASSERT(0 == strcmp(MEM_NAME, info.name)); CU_ASSERT(0 == info.flags); CU_ASSERT(shared_test_data == info.addr); diff --git a/test/validation/api/time/time.c b/test/validation/api/time/time.c index 22189ce03..7664ec542 100644 --- a/test/validation/api/time/time.c +++ b/test/validation/api/time/time.c @@ -216,58 +216,157 @@ static void time_test_monotony(void) { volatile uint64_t count = 0; odp_time_t l_t1, l_t2, l_t3; + odp_time_t ls_t1, ls_t2, ls_t3; odp_time_t g_t1, g_t2, g_t3; - uint64_t lns_t1, lns_t2, lns_t3; - uint64_t gns_t1, gns_t2, gns_t3; + odp_time_t gs_t1, gs_t2, gs_t3; + uint64_t l_ns1, l_ns2, l_ns3; + uint64_t ls_ns1, ls_ns2, ls_ns3; + uint64_t g_ns1, g_ns2, g_ns3; + uint64_t gs_ns1, gs_ns2, gs_ns3; uint64_t ns1, ns2, ns3; + uint64_t s_ns1, s_ns2, s_ns3; - l_t1 = odp_time_local(); - g_t1 = odp_time_global(); - lns_t1 = odp_time_local_ns(); - gns_t1 = odp_time_global_ns(); + l_t1 = odp_time_local(); + ls_t1 = odp_time_local_strict(); + l_ns1 = odp_time_local_ns(); + ls_ns1 = odp_time_local_strict_ns(); + + g_t1 = odp_time_global(); + gs_t1 = odp_time_global_strict(); + g_ns1 = odp_time_global_ns(); + gs_ns1 = odp_time_global_strict_ns(); while (count < BUSY_LOOP_CNT) { count++; }; - l_t2 = odp_time_local(); - g_t2 = odp_time_global(); - lns_t2 = odp_time_local_ns(); - gns_t2 = odp_time_global_ns(); + l_t2 = odp_time_local(); + ls_t2 = odp_time_local_strict(); + l_ns2 = odp_time_local_ns(); + ls_ns2 = odp_time_local_strict_ns(); + + g_t2 = odp_time_global(); + gs_t2 = odp_time_global_strict(); + g_ns2 = odp_time_global_ns(); + gs_ns2 = odp_time_global_strict_ns(); count = 0; while (count < BUSY_LOOP_CNT) { count++; }; - l_t3 = odp_time_local(); - g_t3 = odp_time_global(); - lns_t3 = odp_time_local_ns(); - gns_t3 = odp_time_global_ns(); + l_t3 = odp_time_local(); + ls_t3 = odp_time_local_strict(); + l_ns3 = odp_time_local_ns(); + ls_ns3 = odp_time_local_strict_ns(); + + g_t3 = odp_time_global(); + gs_t3 = odp_time_global_strict(); + g_ns3 = odp_time_global_ns(); + gs_ns3 = odp_time_global_strict_ns(); + + /* Local time tests + * ---------------- */ ns1 = odp_time_to_ns(l_t1); ns2 = odp_time_to_ns(l_t2); ns3 = odp_time_to_ns(l_t3); - /* Local time assertions */ + s_ns1 = odp_time_to_ns(ls_t1); + s_ns2 = odp_time_to_ns(ls_t2); + s_ns3 = odp_time_to_ns(ls_t3); + + /* Time counting starts from zero. Assuming that the ODP instance has run + * less than 10 minutes before running this test case. */ + CU_ASSERT(ns1 < 10 * ODP_TIME_MIN_IN_NS); + CU_ASSERT(s_ns1 < 10 * ODP_TIME_MIN_IN_NS); + CU_ASSERT(l_ns1 < 10 * ODP_TIME_MIN_IN_NS); + CU_ASSERT(ls_ns1 < 10 * ODP_TIME_MIN_IN_NS); + + /* Time stamp */ CU_ASSERT(ns2 > ns1); CU_ASSERT(ns3 > ns2); + /* Strict time stamp */ + CU_ASSERT(s_ns2 > s_ns1); + CU_ASSERT(s_ns3 > s_ns2); + + /* Nsec time */ + CU_ASSERT(l_ns2 > l_ns1); + CU_ASSERT(l_ns3 > l_ns2); + + /* Strict nsec time */ + CU_ASSERT(ls_ns2 > ls_ns1); + CU_ASSERT(ls_ns3 > ls_ns2); + + /* Strict time stamp order is maintained */ + CU_ASSERT(ls_ns1 >= s_ns1); + CU_ASSERT(ls_ns2 >= s_ns2); + CU_ASSERT(ls_ns3 >= s_ns3); + + /* Time in nanoseconds have the same time base. Allow less than 100 msec error + * between time stamp converted to nsec and nsec time. */ + CU_ASSERT((ls_ns1 - s_ns1) < (100 * ODP_TIME_MSEC_IN_NS)); + CU_ASSERT((ls_ns2 - s_ns2) < (100 * ODP_TIME_MSEC_IN_NS)); + CU_ASSERT((ls_ns3 - s_ns3) < (100 * ODP_TIME_MSEC_IN_NS)); + + /* Global time tests + * ----------------- */ + ns1 = odp_time_to_ns(g_t1); ns2 = odp_time_to_ns(g_t2); ns3 = odp_time_to_ns(g_t3); - /* Global time assertions */ + s_ns1 = odp_time_to_ns(gs_t1); + s_ns2 = odp_time_to_ns(gs_t2); + s_ns3 = odp_time_to_ns(gs_t3); + + /* Time counting starts from zero. Assuming that the ODP instance has run + * less than 10 minutes before running this test case. */ + CU_ASSERT(ns1 < 10 * ODP_TIME_MIN_IN_NS); + CU_ASSERT(s_ns1 < 10 * ODP_TIME_MIN_IN_NS); + CU_ASSERT(g_ns1 < 10 * ODP_TIME_MIN_IN_NS); + CU_ASSERT(gs_ns1 < 10 * ODP_TIME_MIN_IN_NS); + + /* Time stamp */ CU_ASSERT(ns2 > ns1); CU_ASSERT(ns3 > ns2); - /* Local time in nsec */ - CU_ASSERT(lns_t2 > lns_t1); - CU_ASSERT(lns_t3 > lns_t2); - - /* Global time in nsec */ - CU_ASSERT(gns_t2 > gns_t1); - CU_ASSERT(gns_t3 > gns_t2); + /* Strict time stamp */ + CU_ASSERT(s_ns2 > s_ns1); + CU_ASSERT(s_ns3 > s_ns2); + + /* Nsec time */ + CU_ASSERT(g_ns2 > g_ns1); + CU_ASSERT(g_ns3 > g_ns2); + + /* Strict nsec time */ + CU_ASSERT(gs_ns2 > gs_ns1); + CU_ASSERT(gs_ns3 > gs_ns2); + + /* Strict time stamp order is maintained */ + CU_ASSERT(gs_ns1 >= s_ns1); + CU_ASSERT(gs_ns2 >= s_ns2); + CU_ASSERT(gs_ns3 >= s_ns3); + + /* Time in nanoseconds have the same time base. Allow less than 100 msec error + * between time stamp converted to nsec and nsec time. */ + CU_ASSERT((gs_ns1 - s_ns1) < (100 * ODP_TIME_MSEC_IN_NS)); + CU_ASSERT((gs_ns2 - s_ns2) < (100 * ODP_TIME_MSEC_IN_NS)); + CU_ASSERT((gs_ns3 - s_ns3) < (100 * ODP_TIME_MSEC_IN_NS)); + + /* Tight error margin cannot be used due to possible OS interrupts during the test. + * Record all time stamp values into the log to help debugging their relative order and + * accuracy. */ + printf("\n Time stamp values in nsec:\n"); + printf(" odp_time_local(): %" PRIu64 "\n", odp_time_to_ns(l_t1)); + printf(" odp_time_local_strict(): %" PRIu64 "\n", odp_time_to_ns(ls_t1)); + printf(" odp_time_local_ns(): %" PRIu64 "\n", l_ns1); + printf(" odp_time_local_strict_ns(): %" PRIu64 "\n", ls_ns1); + printf(" odp_time_global(): %" PRIu64 "\n", odp_time_to_ns(g_t1)); + printf(" odp_time_global_strict(): %" PRIu64 "\n", odp_time_to_ns(gs_t1)); + printf(" odp_time_global_ns(): %" PRIu64 "\n", g_ns1); + printf(" odp_time_global_strict_ns(): %" PRIu64 "\n\n", gs_ns1); } static void time_test_cmp(time_cb time_cur, time_from_ns_cb time_from_ns) diff --git a/test/validation/api/timer/timer.c b/test/validation/api/timer/timer.c index dad99ab41..1927156ba 100644 --- a/test/validation/api/timer/timer.c +++ b/test/validation/api/timer/timer.c @@ -453,6 +453,50 @@ static void timer_test_timeout_pool_alloc(void) CU_ASSERT(odp_pool_destroy(pool) == 0); } +static void timer_test_timeout_from_event(void) +{ + odp_pool_t pool; + odp_pool_param_t param; + uint32_t i; + const uint32_t num = 10; + uint32_t num_alloc = 0; + odp_timeout_t tmo_tbl[num]; + odp_timeout_t tmo2_tbl[num]; + odp_event_t ev_tbl[num]; + + odp_pool_param_init(¶m); + param.type = ODP_POOL_TIMEOUT; + param.tmo.num = num; + + pool = odp_pool_create("test_timeout_from_event", ¶m); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + + for (i = 0; i < num; i++) { + tmo_tbl[i] = odp_timeout_alloc(pool); + if (tmo_tbl[i] == ODP_TIMEOUT_INVALID) + break; + ev_tbl[i] = odp_timeout_to_event(tmo_tbl[i]); + num_alloc++; + } + + CU_ASSERT(num_alloc == num); + + for (i = 0; i < num_alloc; i++) { + odp_timeout_t tmo = odp_timeout_from_event(ev_tbl[i]); + + CU_ASSERT(odp_timeout_to_u64(tmo) == odp_timeout_to_u64(tmo_tbl[i])); + } + + odp_timeout_from_event_multi(tmo2_tbl, ev_tbl, num_alloc); + for (i = 0; i < num_alloc; i++) + CU_ASSERT(odp_timeout_to_u64(tmo2_tbl[i]) == odp_timeout_to_u64(tmo_tbl[i])); + + for (i = 0; i < num_alloc; i++) + odp_timeout_free(tmo_tbl[i]); + + CU_ASSERT_FATAL(odp_pool_destroy(pool) == 0); +} + static void timer_test_timeout_pool_free(void) { odp_pool_t pool; @@ -518,6 +562,7 @@ static void timer_test_timeout_user_area(void) for (i = 0; i < num; i++) { odp_event_t ev; + int flag; tmo[i] = odp_timeout_alloc(pool); @@ -532,6 +577,8 @@ static void timer_test_timeout_user_area(void) ev = odp_timeout_to_event(tmo[i]); CU_ASSERT(odp_event_user_area(ev) == addr); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); + CU_ASSERT(flag < 0); prev = addr; memset(addr, 0, size); @@ -1323,7 +1370,7 @@ static void timer_pool_tick_info(void) } static void timer_test_event_type(odp_queue_type_t queue_type, - odp_event_type_t event_type) + odp_event_type_t event_type, int rounds) { odp_pool_t pool; odp_pool_param_t pool_param; @@ -1401,79 +1448,83 @@ static void timer_test_event_type(odp_queue_type_t queue_type, ODPH_DBG(" user_ptr %p\n\n", (const void *)user_ctx); for (i = 0; i < num; i++) { - if (event_type == ODP_EVENT_BUFFER) { - buf = odp_buffer_alloc(pool); - ev = odp_buffer_to_event(buf); - } else if (event_type == ODP_EVENT_PACKET) { - pkt = odp_packet_alloc(pool, 10); - ev = odp_packet_to_event(pkt); - } else { - tmo = odp_timeout_alloc(pool); - ev = odp_timeout_to_event(tmo); - } - - CU_ASSERT(ev != ODP_EVENT_INVALID); - timer[i] = odp_timer_alloc(timer_pool, queue, user_ctx); CU_ASSERT_FATAL(timer[i] != ODP_TIMER_INVALID); - - start_param.tick_type = ODP_TIMER_TICK_REL; - start_param.tick = (i + 1) * period_tick; - start_param.tmo_ev = ev; - - ret = odp_timer_start(timer[i], &start_param); - - if (ret == ODP_TIMER_TOO_NEAR) - ODPH_DBG("Timer set failed. Too near %i.\n", i); - else if (ret == ODP_TIMER_TOO_FAR) - ODPH_DBG("Timer set failed. Too far %i.\n", i); - else if (ret == ODP_TIMER_FAIL) - ODPH_DBG("Timer set failed %i\n", i); - - CU_ASSERT(ret == ODP_TIMER_SUCCESS); } - if (test_print) { - printf("\n"); - odp_timer_pool_print(timer_pool); - odp_timer_print(timer[0]); - } + for (int round = 0; round < rounds; round++) { + for (i = 0; i < num; i++) { + if (event_type == ODP_EVENT_BUFFER) { + buf = odp_buffer_alloc(pool); + ev = odp_buffer_to_event(buf); + } else if (event_type == ODP_EVENT_PACKET) { + pkt = odp_packet_alloc(pool, 10); + ev = odp_packet_to_event(pkt); + } else { + tmo = odp_timeout_alloc(pool); + ev = odp_timeout_to_event(tmo); + } - ev = ODP_EVENT_INVALID; - num_tmo = 0; - t1 = odp_time_local(); + CU_ASSERT(ev != ODP_EVENT_INVALID); - /* Wait for timers. Make sure that scheduler context is not held when - * exiting the loop. */ - do { - if (queue_type == ODP_QUEUE_TYPE_SCHED) - ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT); - else - ev = odp_queue_deq(queue); + start_param.tick_type = ODP_TIMER_TICK_REL; + start_param.tick = (i + 1) * period_tick; + start_param.tmo_ev = ev; - if (ev == ODP_EVENT_INVALID) { - t2 = odp_time_local(); - if (odp_time_diff_ns(t2, t1) > (10 * duration_ns)) - break; + ret = odp_timer_start(timer[i], &start_param); - continue; - } + if (ret == ODP_TIMER_TOO_NEAR) + ODPH_DBG("Timer set failed. Too near %i.\n", i); + else if (ret == ODP_TIMER_TOO_FAR) + ODPH_DBG("Timer set failed. Too far %i.\n", i); + else if (ret == ODP_TIMER_FAIL) + ODPH_DBG("Timer set failed %i\n", i); - CU_ASSERT(odp_event_type(ev) == event_type); + CU_ASSERT(ret == ODP_TIMER_SUCCESS); + } if (test_print) { - test_print = 0; - tmo = odp_timeout_from_event(ev); - odp_timeout_print(tmo); printf("\n"); + odp_timer_pool_print(timer_pool); + odp_timer_print(timer[0]); } - odp_event_free(ev); - num_tmo++; + ev = ODP_EVENT_INVALID; + num_tmo = 0; + t1 = odp_time_local(); - } while (num_tmo < num || ev != ODP_EVENT_INVALID); + /* Wait for timers. Make sure that scheduler context is not held when + * exiting the loop. */ + do { + if (queue_type == ODP_QUEUE_TYPE_SCHED) + ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT); + else + ev = odp_queue_deq(queue); - CU_ASSERT(num_tmo == num); + if (ev == ODP_EVENT_INVALID) { + t2 = odp_time_local(); + if (odp_time_diff_ns(t2, t1) > (10 * duration_ns)) + break; + + continue; + } + + CU_ASSERT(odp_event_type(ev) == event_type); + + if (test_print) { + test_print = 0; + tmo = odp_timeout_from_event(ev); + odp_timeout_print(tmo); + printf("\n"); + } + + odp_event_free(ev); + num_tmo++; + + } while (num_tmo < num || ev != ODP_EVENT_INVALID); + + CU_ASSERT(num_tmo == num); + } for (i = 0; i < num; i++) CU_ASSERT(odp_timer_free(timer[i]) == ODP_EVENT_INVALID); @@ -1485,32 +1536,47 @@ static void timer_test_event_type(odp_queue_type_t queue_type, static void timer_test_tmo_event_plain(void) { - timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_TIMEOUT); + timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_TIMEOUT, 1); } static void timer_test_tmo_event_sched(void) { - timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_TIMEOUT); + timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_TIMEOUT, 1); } static void timer_test_buf_event_plain(void) { - timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_BUFFER); + timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_BUFFER, 1); } static void timer_test_buf_event_sched(void) { - timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_BUFFER); + timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_BUFFER, 1); } static void timer_test_pkt_event_plain(void) { - timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_PACKET); + timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_PACKET, 1); } static void timer_test_pkt_event_sched(void) { - timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_PACKET); + timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_PACKET, 1); +} + +static void timer_test_tmo_event_reuse(void) +{ + timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_TIMEOUT, 2); +} + +static void timer_test_buf_event_reuse(void) +{ + timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_BUFFER, 2); +} + +static void timer_test_pkt_event_reuse(void) +{ + timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_PACKET, 2); } static void timer_test_queue_type(odp_queue_type_t queue_type, int priv, int exp_relax) @@ -2701,7 +2767,7 @@ static void timer_test_periodic_capa(void) } } -static void timer_test_periodic(odp_queue_type_t queue_type, int use_first) +static void timer_test_periodic(odp_queue_type_t queue_type, int use_first, int rounds) { odp_timer_capability_t timer_capa; odp_timer_periodic_capability_t periodic_capa; @@ -2720,8 +2786,8 @@ static void timer_test_periodic(odp_queue_type_t queue_type, int use_first) double freq, freq_out, min_freq, max_freq; int ret; const char *user_ctx = "User context"; - int num_tmo = 0; - int done = 0; + int num_tmo; + int done; const int num = 200; /* Test frequency: 1x 100Hz, or 1x min/max_base_freq */ const uint64_t multiplier = 1; @@ -2829,127 +2895,135 @@ static void timer_test_periodic(odp_queue_type_t queue_type, int use_first) queue = odp_queue_create("timeout_queue", &queue_param); CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID); - tmo = odp_timeout_alloc(pool); - ev = odp_timeout_to_event(tmo); - CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID); - timer = odp_timer_alloc(timer_pool, queue, user_ctx); CU_ASSERT_FATAL(timer != ODP_TIMER_INVALID); memset(&start_param, 0, sizeof(odp_timer_periodic_start_t)); - cur_tick = odp_timer_current_tick(timer_pool); offset_ns = period_ns / 2; - tick = cur_tick + odp_timer_ns_to_tick(timer_pool, offset_ns); if (use_first) { /* First tick moves timer to start before the first period */ duration_ns -= (period_ns - offset_ns); - start_param.first_tick = tick; } - start_param.freq_multiplier = multiplier; - start_param.tmo_ev = ev; + for (int round = 0; round < rounds; round++) { + num_tmo = 0; + done = 0; - ODPH_DBG("Periodic timer start:\n"); - ODPH_DBG(" Current tick: %" PRIu64 "\n", cur_tick); - ODPH_DBG(" First tick: %" PRIu64 "\n", start_param.first_tick); - ODPH_DBG(" Multiplier: %" PRIu64 "\n", start_param.freq_multiplier); - ODPH_DBG(" Period: %" PRIu64 " nsec\n", period_ns); - ODPH_DBG("Expected duration: %" PRIu64 " nsec\n", duration_ns); + tmo = odp_timeout_alloc(pool); + ev = odp_timeout_to_event(tmo); + CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID); - ret = odp_timer_periodic_start(timer, &start_param); + cur_tick = odp_timer_current_tick(timer_pool); + tick = cur_tick + odp_timer_ns_to_tick(timer_pool, offset_ns); - if (ret == ODP_TIMER_TOO_NEAR) - ODPH_ERR("First tick too near\n"); - else if (ret == ODP_TIMER_TOO_FAR) - ODPH_ERR("First tick too far\n"); - else if (ret == ODP_TIMER_FAIL) - ODPH_ERR("Periodic timer start failed\n"); + if (use_first) + start_param.first_tick = tick; - CU_ASSERT_FATAL(ret == ODP_TIMER_SUCCESS); + start_param.freq_multiplier = multiplier; + start_param.tmo_ev = ev; - t1 = odp_time_local(); + ODPH_DBG("Periodic timer start:\n"); + ODPH_DBG(" Current tick: %" PRIu64 "\n", cur_tick); + ODPH_DBG(" First tick: %" PRIu64 "\n", start_param.first_tick); + ODPH_DBG(" Multiplier: %" PRIu64 "\n", start_param.freq_multiplier); + ODPH_DBG(" Period: %" PRIu64 " nsec\n", period_ns); + ODPH_DBG("Expected duration: %" PRIu64 " nsec\n", duration_ns); - /* Wait for timeouts. Make sure that scheduler context is not held when - * exiting the loop. */ - while (1) { - if (queue_type == ODP_QUEUE_TYPE_SCHED) - ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT); - else - ev = odp_queue_deq(queue); + ret = odp_timer_periodic_start(timer, &start_param); - if (ev == ODP_EVENT_INVALID) { - t2 = odp_time_local(); - diff_ns = odp_time_diff_ns(t2, t1); - if (diff_ns > (10 * duration_ns)) - break; + if (ret == ODP_TIMER_TOO_NEAR) + ODPH_ERR("First tick too near\n"); + else if (ret == ODP_TIMER_TOO_FAR) + ODPH_ERR("First tick too far\n"); + else if (ret == ODP_TIMER_FAIL) + ODPH_ERR("Periodic timer start failed\n"); - if (num_tmo >= num) - break; + CU_ASSERT_FATAL(ret == ODP_TIMER_SUCCESS); - continue; - } + t1 = odp_time_local(); - CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT); + /* Wait for timeouts. Make sure that scheduler context is not held when + * exiting the loop. */ + while (1) { + if (queue_type == ODP_QUEUE_TYPE_SCHED) + ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT); + else + ev = odp_queue_deq(queue); - if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) { - odp_event_free(ev); - continue; - } + if (ev == ODP_EVENT_INVALID) { + t2 = odp_time_local(); + diff_ns = odp_time_diff_ns(t2, t1); + if (diff_ns > (10 * duration_ns)) + break; - CU_ASSERT(odp_timer_periodic_ack(timer, ev) == 0); - num_tmo++; - } + if (num_tmo >= num) + break; - CU_ASSERT(num_tmo == num); + continue; + } - /* Allow +-30% error on test duration */ - CU_ASSERT((diff_ns > 0.7 * duration_ns) && (diff_ns < 1.3 * duration_ns)); + CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT); - /* Stop periodic timer */ - ret = odp_timer_periodic_cancel(timer); - CU_ASSERT_FATAL(ret == 0); + if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) { + odp_event_free(ev); + continue; + } - ODPH_DBG("Measured duration: %" PRIu64 " nsec\n", diff_ns); + CU_ASSERT(odp_timer_periodic_ack(timer, ev) == 0); + num_tmo++; + } - t1 = odp_time_local(); - while (1) { - if (queue_type == ODP_QUEUE_TYPE_SCHED) - ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT); - else - ev = odp_queue_deq(queue); + CU_ASSERT(num_tmo == num); - if (ev == ODP_EVENT_INVALID) { - t2 = odp_time_local(); - diff_ns = odp_time_diff_ns(t2, t1); - if (diff_ns > (10 * duration_ns)) - break; + /* Allow +-30% error on test duration */ + CU_ASSERT((diff_ns > 0.7 * duration_ns) && (diff_ns < 1.3 * duration_ns)); - if (done) - break; + /* Stop periodic timer */ + ret = odp_timer_periodic_cancel(timer); + CU_ASSERT_FATAL(ret == 0); - continue; - } + ODPH_DBG("Measured duration: %" PRIu64 " nsec\n", diff_ns); - CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT); + t1 = odp_time_local(); + while (1) { + if (queue_type == ODP_QUEUE_TYPE_SCHED) + ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT); + else + ev = odp_queue_deq(queue); - if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) { - odp_event_free(ev); - continue; - } + if (ev == ODP_EVENT_INVALID) { + t2 = odp_time_local(); + diff_ns = odp_time_diff_ns(t2, t1); + if (diff_ns > (10 * duration_ns)) + break; + + if (done) + break; - ret = odp_timer_periodic_ack(timer, ev); - CU_ASSERT(ret == 1 || ret == 2); + continue; + } - if (ret == 2) { - odp_event_free(ev); - done = 1; + CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT); + + if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) { + odp_event_free(ev); + continue; + } + + ret = odp_timer_periodic_ack(timer, ev); + CU_ASSERT(ret == 1 || ret == 2); + + if (ret == 2) { + odp_event_free(ev); + done = 1; + } } - } - /* Check that ack() returned 2 on the last event */ - CU_ASSERT(done); - CU_ASSERT(ret == 2); + /* Check that ack() returned 2 on the last event */ + CU_ASSERT(done); + CU_ASSERT(ret == 2); + } CU_ASSERT(odp_timer_free(timer) == ODP_EVENT_INVALID); odp_timer_pool_destroy(timer_pool); @@ -2959,28 +3033,34 @@ static void timer_test_periodic(odp_queue_type_t queue_type, int use_first) static void timer_test_periodic_sched(void) { - timer_test_periodic(ODP_QUEUE_TYPE_SCHED, 0); + timer_test_periodic(ODP_QUEUE_TYPE_SCHED, 0, 1); } static void timer_test_periodic_plain(void) { - timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, 0); + timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, 0, 1); } static void timer_test_periodic_sched_first(void) { - timer_test_periodic(ODP_QUEUE_TYPE_SCHED, FIRST_TICK); + timer_test_periodic(ODP_QUEUE_TYPE_SCHED, FIRST_TICK, 1); } static void timer_test_periodic_plain_first(void) { - timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, FIRST_TICK); + timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, FIRST_TICK, 1); +} + +static void timer_test_periodic_reuse(void) +{ + timer_test_periodic(ODP_QUEUE_TYPE_SCHED, 0, 2); } odp_testinfo_t timer_suite[] = { ODP_TEST_INFO(timer_test_capa), ODP_TEST_INFO(timer_test_param_init), ODP_TEST_INFO(timer_test_timeout_pool_alloc), + ODP_TEST_INFO(timer_test_timeout_from_event), ODP_TEST_INFO(timer_test_timeout_pool_free), ODP_TEST_INFO(timer_test_timeout_user_area), ODP_TEST_INFO(timer_pool_create_destroy), @@ -3019,6 +3099,12 @@ odp_testinfo_t timer_suite[] = { check_plain_queue_support), ODP_TEST_INFO_CONDITIONAL(timer_test_pkt_event_sched, check_sched_queue_support), + ODP_TEST_INFO_CONDITIONAL(timer_test_tmo_event_reuse, + check_sched_queue_support), + ODP_TEST_INFO_CONDITIONAL(timer_test_buf_event_reuse, + check_sched_queue_support), + ODP_TEST_INFO_CONDITIONAL(timer_test_pkt_event_reuse, + check_sched_queue_support), ODP_TEST_INFO(timer_test_cancel), ODP_TEST_INFO_CONDITIONAL(timer_test_max_res_min_tmo_plain, check_plain_queue_support), @@ -3062,6 +3148,8 @@ odp_testinfo_t timer_suite[] = { check_periodic_plain_support), ODP_TEST_INFO_CONDITIONAL(timer_test_periodic_plain_first, check_periodic_plain_support), + ODP_TEST_INFO_CONDITIONAL(timer_test_periodic_reuse, + check_periodic_sched_support), ODP_TEST_INFO_NULL, }; |