aboutsummaryrefslogtreecommitdiff
path: root/test/validation/api
diff options
context:
space:
mode:
Diffstat (limited to 'test/validation/api')
-rw-r--r--test/validation/api/atomic/atomic.c2
-rw-r--r--test/validation/api/barrier/barrier.c4
-rw-r--r--test/validation/api/buffer/buffer.c56
-rw-r--r--test/validation/api/classification/odp_classification_basic.c50
-rw-r--r--test/validation/api/classification/odp_classification_common.c24
-rw-r--r--test/validation/api/classification/odp_classification_test_pmr.c105
-rw-r--r--test/validation/api/classification/odp_classification_testsuites.h2
-rw-r--r--test/validation/api/crypto/odp_crypto_test_inp.c5
-rw-r--r--test/validation/api/crypto/test_vectors.h267
-rw-r--r--test/validation/api/crypto/test_vectors_len.h10
-rw-r--r--test/validation/api/ipsec/ipsec.c1
-rw-r--r--test/validation/api/lock/lock.c22
-rw-r--r--test/validation/api/packet/packet.c499
-rw-r--r--test/validation/api/pktio/pktio.c2
-rw-r--r--test/validation/api/pool/pool.c12
-rw-r--r--test/validation/api/queue/queue.c4
-rw-r--r--test/validation/api/scheduler/scheduler.c12
-rw-r--r--test/validation/api/shmem/shmem.c8
-rw-r--r--test/validation/api/stash/stash.c423
-rw-r--r--test/validation/api/thread/thread.c40
-rw-r--r--test/validation/api/timer/timer.c250
21 files changed, 1417 insertions, 381 deletions
diff --git a/test/validation/api/atomic/atomic.c b/test/validation/api/atomic/atomic.c
index 5a1fdf11b..d4329bc6b 100644
--- a/test/validation/api/atomic/atomic.c
+++ b/test/validation/api/atomic/atomic.c
@@ -1276,7 +1276,7 @@ static void test_atomic_functional(int test_fn(void *), void validate_fn(void))
test_atomic_init();
test_atomic_store();
- odp_cunit_thread_create(num, test_fn, NULL, 0);
+ odp_cunit_thread_create(num, test_fn, NULL, 0, 0);
odp_cunit_thread_join(num);
validate_fn();
}
diff --git a/test/validation/api/barrier/barrier.c b/test/validation/api/barrier/barrier.c
index 710947997..ce52fd2d7 100644
--- a/test/validation/api/barrier/barrier.c
+++ b/test/validation/api/barrier/barrier.c
@@ -404,7 +404,7 @@ static void barrier_test_no_barrier_functional(void)
int num = global_mem->g_num_threads;
barrier_test_init();
- odp_cunit_thread_create(num, no_barrier_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, no_barrier_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -413,7 +413,7 @@ static void barrier_test_barrier_functional(void)
int num = global_mem->g_num_threads;
barrier_test_init();
- odp_cunit_thread_create(num, barrier_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, barrier_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
diff --git a/test/validation/api/buffer/buffer.c b/test/validation/api/buffer/buffer.c
index 19f39e1d3..c3484e14a 100644
--- a/test/validation/api/buffer/buffer.c
+++ b/test/validation/api/buffer/buffer.c
@@ -1,5 +1,5 @@
/* Copyright (c) 2014-2018, Linaro Limited
- * Copyright (c) 2019, Nokia
+ * Copyright (c) 2019-2022, Nokia
* Copyright (c) 2022, Marvell
* All rights reserved.
*
@@ -7,6 +7,7 @@
*/
#include <odp_api.h>
+#include <odp/helper/odph_debug.h>
#include "odp_cunit_common.h"
#define BUF_ALIGN ODP_CACHE_LINE_SIZE
@@ -491,6 +492,58 @@ static void buffer_test_pool_max_pools_max_cache(void)
test_pool_max_pools(&param);
}
+static void buffer_test_user_area(void)
+{
+ odp_pool_t pool;
+ odp_pool_param_t param;
+ uint32_t i, num;
+ void *addr;
+ void *prev = NULL;
+ uint32_t num_alloc = 0;
+ uint32_t size = 1024;
+ const uint32_t max_size = pool_capa.buf.max_uarea_size;
+
+ if (max_size == 0) {
+ ODPH_DBG("Buffer user area not supported\n");
+ return;
+ }
+
+ if (size > max_size)
+ size = max_size;
+
+ memcpy(&param, &default_param, sizeof(odp_pool_param_t));
+ param.buf.uarea_size = size;
+
+ num = param.buf.num;
+
+ odp_buffer_t buffer[num];
+
+ pool = odp_pool_create("test_user_area", &param);
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ for (i = 0; i < num; i++) {
+ buffer[i] = odp_buffer_alloc(pool);
+
+ if (buffer[i] == ODP_BUFFER_INVALID)
+ break;
+ num_alloc++;
+
+ addr = odp_buffer_user_area(buffer[i]);
+ CU_ASSERT_FATAL(addr != NULL);
+ CU_ASSERT(prev != addr);
+
+ prev = addr;
+ memset(addr, 0, size);
+ }
+
+ CU_ASSERT(i == num);
+
+ if (num_alloc)
+ odp_buffer_free_multi(buffer, num_alloc);
+
+ CU_ASSERT_FATAL(odp_pool_destroy(pool) == 0);
+}
+
odp_testinfo_t buffer_suite[] = {
ODP_TEST_INFO(buffer_test_pool_alloc_free),
ODP_TEST_INFO(buffer_test_pool_alloc_free_min_cache),
@@ -507,6 +560,7 @@ odp_testinfo_t buffer_suite[] = {
ODP_TEST_INFO(buffer_test_pool_max_pools),
ODP_TEST_INFO(buffer_test_pool_max_pools_min_cache),
ODP_TEST_INFO(buffer_test_pool_max_pools_max_cache),
+ ODP_TEST_INFO(buffer_test_user_area),
ODP_TEST_INFO_NULL,
};
diff --git a/test/validation/api/classification/odp_classification_basic.c b/test/validation/api/classification/odp_classification_basic.c
index 4fecba1e2..f914ea2ec 100644
--- a/test/validation/api/classification/odp_classification_basic.c
+++ b/test/validation/api/classification/odp_classification_basic.c
@@ -18,7 +18,10 @@ static void test_defaults(uint8_t fill)
memset(&cos_param, fill, sizeof(cos_param));
odp_cls_cos_param_init(&cos_param);
- CU_ASSERT_EQUAL(cos_param.num_queue, 1);
+
+ CU_ASSERT(cos_param.action == ODP_COS_ACTION_ENQUEUE);
+ CU_ASSERT(cos_param.num_queue == 1);
+ CU_ASSERT_EQUAL(cos_param.stats_enable, false);
CU_ASSERT_EQUAL(cos_param.red.enable, false);
CU_ASSERT_EQUAL(cos_param.bp.enable, false);
CU_ASSERT_EQUAL(cos_param.vector.enable, false);
@@ -392,6 +395,49 @@ static void classification_test_pmr_composite_create(void)
odp_pktio_close(pktio);
}
+static void classification_test_create_cos_with_hash_queues(void)
+{
+ odp_pool_t pool;
+ odp_cls_capability_t capa;
+ int ret;
+ odp_queue_param_t q_param;
+ odp_cls_cos_param_t cls_param;
+ odp_cos_t cos;
+
+ pool = pool_create("cls_basic_pool");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ ret = odp_cls_capability(&capa);
+ CU_ASSERT_FATAL(ret == 0);
+ CU_ASSERT_FATAL(capa.hash_protocols.all_bits != 0);
+
+ odp_queue_param_init(&q_param);
+ q_param.type = ODP_QUEUE_TYPE_SCHED;
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.num_queue = capa.max_hash_queues;
+ cls_param.queue_param = q_param;
+ cls_param.hash_proto.all_bits = capa.hash_protocols.all_bits;
+ cls_param.pool = pool;
+
+ cos = odp_cls_cos_create(NULL, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+ ret = odp_cos_destroy(cos);
+ CU_ASSERT(ret == 0);
+
+ odp_pool_destroy(pool);
+}
+
+static int check_capa_cos_hashing(void)
+{
+ odp_cls_capability_t capa;
+
+ if (odp_cls_capability(&capa) < 0)
+ return ODP_TEST_INACTIVE;
+
+ return capa.max_hash_queues > 1 ? ODP_TEST_ACTIVE : ODP_TEST_INACTIVE;
+}
+
odp_testinfo_t classification_suite_basic[] = {
ODP_TEST_INFO(classification_test_default_values),
ODP_TEST_INFO(classification_test_create_cos),
@@ -403,5 +449,7 @@ odp_testinfo_t classification_suite_basic[] = {
ODP_TEST_INFO(classification_test_cos_set_drop),
ODP_TEST_INFO(classification_test_cos_set_pool),
ODP_TEST_INFO(classification_test_pmr_composite_create),
+ ODP_TEST_INFO_CONDITIONAL(classification_test_create_cos_with_hash_queues,
+ check_capa_cos_hashing),
ODP_TEST_INFO_NULL,
};
diff --git a/test/validation/api/classification/odp_classification_common.c b/test/validation/api/classification/odp_classification_common.c
index 8eac41a1e..4c24099a5 100644
--- a/test/validation/api/classification/odp_classification_common.c
+++ b/test/validation/api/classification/odp_classification_common.c
@@ -26,6 +26,7 @@ static uint8_t IPV6_DST_ADDR[ODPH_IPV6ADDR_LEN] = {
};
#define ODP_GTPU_UDP_PORT 2152
+#define AH_HDR_LEN 24
odp_pktio_t create_pktio(odp_queue_type_t q_type, odp_pool_t pool,
odp_bool_t cls_enable)
@@ -306,6 +307,8 @@ odp_packet_t create_packet(cls_packet_info_t pkt_info)
odph_ipv6hdr_t *ipv6;
odph_gtphdr_t *gtpu;
odph_igmphdr_t *igmp;
+ odph_ahhdr_t *ah;
+ odph_esphdr_t *esp;
uint8_t *hlen = 0;
uint16_t payload_len;
uint32_t addr = 0;
@@ -359,6 +362,14 @@ odp_packet_t create_packet(cls_packet_info_t pkt_info)
next_hdr = ODPH_IPPROTO_IGMP;
l4_hdr_len = ODP_IGMP_HLEN;
break;
+ case CLS_PKT_L4_AH:
+ next_hdr = ODPH_IPPROTO_AH;
+ l4_hdr_len = AH_HDR_LEN;
+ break;
+ case CLS_PKT_L4_ESP:
+ next_hdr = ODPH_IPPROTO_ESP;
+ l4_hdr_len = ODPH_ESPHDR_LEN;
+ break;
default:
ODPH_ASSERT(0);
}
@@ -444,9 +455,11 @@ odp_packet_t create_packet(cls_packet_info_t pkt_info)
udp = (odph_udphdr_t *)(buf + l4_offset);
sctp = (odph_sctphdr_t *)(buf + l4_offset);
icmp = (odph_icmphdr_t *)(buf + l4_offset);
+ igmp = (odph_igmphdr_t *)(buf + l4_offset);
+ ah = (odph_ahhdr_t *)(buf + l4_offset);
+ esp = (odph_esphdr_t *)(buf + l4_offset);
if (pkt_info.l4_type == CLS_PKT_L4_IGMP) {
- igmp = (odph_igmphdr_t *)odp_packet_l4_ptr(pkt, NULL);
igmp->group = odp_cpu_to_be_32(CLS_MAGIC_VAL);
igmp->type = 0x12;
igmp->code = 0;
@@ -496,6 +509,15 @@ odp_packet_t create_packet(cls_packet_info_t pkt_info)
ODPH_ERR("odph_udp_tcp_chksum failed\n");
return ODP_PACKET_INVALID;
}
+ } else if (pkt_info.l4_type == CLS_PKT_L4_AH) {
+ ah->next_header = ODPH_IPV4;
+ ah->ah_len = AH_HDR_LEN / 4 - 2;
+ ah->pad = 0;
+ ah->spi = 256;
+ ah->seq_no = 1;
+ } else if (pkt_info.l4_type == CLS_PKT_L4_ESP) {
+ esp->spi = 256;
+ esp->seq_no = 1;
} else {
tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT);
tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT);
diff --git a/test/validation/api/classification/odp_classification_test_pmr.c b/test/validation/api/classification/odp_classification_test_pmr.c
index e69f077a2..9a2e32f4b 100644
--- a/test/validation/api/classification/odp_classification_test_pmr.c
+++ b/test/validation/api/classification/odp_classification_test_pmr.c
@@ -1873,6 +1873,98 @@ static void classification_test_pmr_term_custom_l3(void)
test_pmr_term_custom(1);
}
+static void test_pmr_term_ipsec_spi_ah(odp_bool_t is_ipv6)
+{
+ uint32_t val;
+ uint32_t mask;
+ odp_pmr_param_t pmr_param;
+ cls_packet_info_t pkt_info;
+ odp_packet_t pkt;
+ odph_ahhdr_t *ah;
+
+ val = odp_cpu_to_be_32(0x11223344);
+ mask = odp_cpu_to_be_32(0xffffffff);
+
+ odp_cls_pmr_param_init(&pmr_param);
+ pmr_param.term = ODP_PMR_IPSEC_SPI;
+ pmr_param.match.value = &val;
+ pmr_param.match.mask = &mask;
+ pmr_param.val_sz = sizeof(val);
+
+ pkt_info = default_pkt_info;
+ pkt_info.l4_type = CLS_PKT_L4_AH;
+ pkt_info.ipv6 = is_ipv6;
+ pkt = create_packet(pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ ah = (odph_ahhdr_t *)odp_packet_l4_ptr(pkt, NULL);
+ ah->spi = val;
+
+ test_pmr(&pmr_param, pkt, MATCH);
+
+ pkt = create_packet(pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ ah = (odph_ahhdr_t *)odp_packet_l4_ptr(pkt, NULL);
+ ah->spi = val + 1;
+
+ test_pmr(&pmr_param, pkt, NO_MATCH);
+}
+
+static void classification_test_pmr_term_ipsec_spi_ah_ipv4(void)
+{
+ test_pmr_term_ipsec_spi_ah(TEST_IPV4);
+}
+
+static void test_pmr_term_ipsec_spi_esp(odp_bool_t is_ipv6)
+{
+ uint32_t val;
+ uint32_t mask;
+ odp_pmr_param_t pmr_param;
+ cls_packet_info_t pkt_info;
+ odp_packet_t pkt;
+ odph_esphdr_t *esp;
+
+ val = odp_cpu_to_be_32(0x11223344);
+ mask = odp_cpu_to_be_32(0xffffffff);
+
+ odp_cls_pmr_param_init(&pmr_param);
+ pmr_param.term = ODP_PMR_IPSEC_SPI;
+ pmr_param.match.value = &val;
+ pmr_param.match.mask = &mask;
+ pmr_param.val_sz = sizeof(val);
+
+ pkt_info = default_pkt_info;
+ pkt_info.l4_type = CLS_PKT_L4_ESP;
+ pkt_info.ipv6 = is_ipv6;
+ pkt = create_packet(pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ esp = (odph_esphdr_t *)odp_packet_l4_ptr(pkt, NULL);
+ esp->spi = val;
+
+ test_pmr(&pmr_param, pkt, MATCH);
+
+ pkt = create_packet(pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ esp = (odph_esphdr_t *)odp_packet_l4_ptr(pkt, NULL);
+ esp->spi = val + 1;
+
+ test_pmr(&pmr_param, pkt, NO_MATCH);
+}
+
+static void classification_test_pmr_term_ipsec_spi_esp_ipv4(void)
+{
+ test_pmr_term_ipsec_spi_esp(TEST_IPV4);
+}
+
+static void classification_test_pmr_term_ipsec_spi_ah_ipv6(void)
+{
+ test_pmr_term_ipsec_spi_ah(TEST_IPV6);
+}
+
+static void classification_test_pmr_term_ipsec_spi_esp_ipv6(void)
+{
+ test_pmr_term_ipsec_spi_esp(TEST_IPV6);
+}
+
static int check_capa_tcp_dport(void)
{
return cls_capa.supported_terms.bit.tcp_dport;
@@ -1968,6 +2060,11 @@ static int check_capa_custom_l3(void)
return cls_capa.supported_terms.bit.custom_l3;
}
+static int check_capa_ipsec_spi(void)
+{
+ return cls_capa.supported_terms.bit.ipsec_spi;
+}
+
static int check_capa_pmr_series(void)
{
uint64_t support;
@@ -2088,6 +2185,14 @@ odp_testinfo_t classification_suite_pmr[] = {
check_capa_custom_frame),
ODP_TEST_INFO_CONDITIONAL(classification_test_pmr_term_custom_l3,
check_capa_custom_l3),
+ ODP_TEST_INFO_CONDITIONAL(classification_test_pmr_term_ipsec_spi_ah_ipv4,
+ check_capa_ipsec_spi),
+ ODP_TEST_INFO_CONDITIONAL(classification_test_pmr_term_ipsec_spi_esp_ipv4,
+ check_capa_ipsec_spi),
+ ODP_TEST_INFO_CONDITIONAL(classification_test_pmr_term_ipsec_spi_ah_ipv6,
+ check_capa_ipsec_spi),
+ ODP_TEST_INFO_CONDITIONAL(classification_test_pmr_term_ipsec_spi_esp_ipv6,
+ check_capa_ipsec_spi),
ODP_TEST_INFO_CONDITIONAL(classification_test_pmr_serial,
check_capa_pmr_series),
ODP_TEST_INFO_CONDITIONAL(classification_test_pmr_parallel,
diff --git a/test/validation/api/classification/odp_classification_testsuites.h b/test/validation/api/classification/odp_classification_testsuites.h
index 592f37cd6..8fa43099d 100644
--- a/test/validation/api/classification/odp_classification_testsuites.h
+++ b/test/validation/api/classification/odp_classification_testsuites.h
@@ -19,6 +19,8 @@ typedef enum cls_packet_l4_info {
CLS_PKT_L4_ICMP,
CLS_PKT_L4_GTP,
CLS_PKT_L4_IGMP,
+ CLS_PKT_L4_AH,
+ CLS_PKT_L4_ESP
} cls_packet_l4_info;
typedef struct cls_packet_info {
diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c
index 0112bf27a..150a470ec 100644
--- a/test/validation/api/crypto/odp_crypto_test_inp.c
+++ b/test/validation/api/crypto/odp_crypto_test_inp.c
@@ -1342,12 +1342,11 @@ static void test_auth_hashes_in_auth_range(void)
odp_auth_alg_t auth = auth_algs[n];
int num;
- if (check_alg_support(ODP_CIPHER_ALG_NULL, auth)
- == ODP_TEST_INACTIVE)
+ if (check_alg_support(ODP_CIPHER_ALG_NULL, auth) == ODP_TEST_INACTIVE)
continue;
num = odp_crypto_auth_capability(auth, NULL, 0);
- CU_ASSERT(num > 0);
+ CU_ASSERT_FATAL(num > 0);
odp_crypto_auth_capability_t capa[num];
diff --git a/test/validation/api/crypto/test_vectors.h b/test/validation/api/crypto/test_vectors.h
index c07be12f7..b9a9c2f06 100644
--- a/test/validation/api/crypto/test_vectors.h
+++ b/test/validation/api/crypto/test_vectors.h
@@ -2493,7 +2493,7 @@ static crypto_test_reference_t aes_eia2_reference[] = {
*/
static crypto_test_reference_t zuc_eea3_reference[] = {
{
- .cipher_key_length = ZUC_EIA3_KEY_LEN,
+ .cipher_key_length = ZUC_EEA3_KEY_LEN,
.cipher_key = { 0xe5, 0xbd, 0x3e, 0xa0, 0xeb, 0x55, 0xad, 0xe8,
0x66, 0xc6, 0xac, 0x58, 0xbd, 0x54, 0x30, 0x2a},
.cipher_iv_length = ZUC_EEA3_IV_LEN,
@@ -2527,7 +2527,132 @@ static crypto_test_reference_t zuc_eea3_reference[] = {
0xdf, 0x5a, 0x47, 0x3a, 0x57, 0xa4, 0xa0, 0x0d,
0x98, 0x5e, 0xba, 0xd8, 0x80, 0xd6, 0xf2, 0x38,
0x64, 0xa0, 0x7b, 0x01 }
- }
+ },
+
+ /* Privately generated test data */
+ {
+ .cipher_key_length = ZUC_EEA3_256_KEY_LEN,
+ .cipher_key = { 0xf7, 0xb4, 0x04, 0x5a, 0x81, 0x5c, 0x1b, 0x01,
+ 0x82, 0xf9, 0xf4, 0x26, 0x80, 0xd4, 0x56, 0x26,
+ 0xd5, 0xf7, 0x4b, 0x68, 0x48, 0x6b, 0x92, 0x6a,
+ 0x34, 0x1f, 0x86, 0x66, 0x60, 0x0a, 0xfc, 0x57},
+ .cipher_iv_length = ZUC_EEA3_256_IV_LEN,
+ .cipher_iv = { 0x8e, 0x5d, 0xbc, 0x3f, 0xb9, 0xae, 0x66, 0xa3,
+ 0xb9, 0x5c, 0x12, 0x14, 0xdb, 0xc5, 0xbc, 0x18,
+ 0x48, 0x12, 0x09, 0x06, 0x25, 0x33, 0x2e, 0x12,
+ 0x12 },
+ .length = 1024,
+ .is_length_in_bits = true,
+ .plaintext = { 0x36, 0xdb, 0x63, 0x68, 0xb5, 0x1f, 0x4e, 0x92,
+ 0x46, 0x1f, 0xde, 0xdb, 0xc2, 0xec, 0xfa, 0x7e,
+ 0x49, 0x85, 0x77, 0xaa, 0x46, 0x98, 0x30, 0x2d,
+ 0x3b, 0xc4, 0x11, 0x24, 0x98, 0x20, 0xa9, 0xce,
+ 0xfb, 0x0d, 0x36, 0xb0, 0x2c, 0x85, 0x42, 0x72,
+ 0xa4, 0x21, 0x4e, 0x66, 0x0d, 0x48, 0xe4, 0x57,
+ 0xce, 0x5b, 0x01, 0x14, 0xf3, 0x31, 0x42, 0x2e,
+ 0xf5, 0x53, 0x52, 0x8d, 0x73, 0xfc, 0x5c, 0x6e,
+ 0x09, 0x92, 0x1e, 0x35, 0x17, 0x60, 0xa8, 0xbb,
+ 0x81, 0xf6, 0x21, 0x8f, 0x3e, 0x05, 0xe6, 0x0c,
+ 0x60, 0xe7, 0x21, 0x53, 0x18, 0x63, 0x81, 0x0d,
+ 0xb6, 0xd4, 0x9a, 0x29, 0xd0, 0xf6, 0x97, 0xd9,
+ 0x89, 0xb5, 0x0e, 0xa0, 0x15, 0xb6, 0x5c, 0x97,
+ 0xac, 0x7d, 0x26, 0xeb, 0x83, 0x0c, 0xf7, 0xe3,
+ 0xf3, 0x18, 0x37, 0x0b, 0x7b, 0xb8, 0x18, 0x31,
+ 0x8c, 0xb2, 0x5a, 0x5c, 0xa9, 0xf1, 0x35, 0x32 },
+ .ciphertext = { 0xa6, 0xe5, 0x71, 0x58, 0x5c, 0xcf, 0x5d, 0x0d,
+ 0x59, 0xb5, 0x51, 0xab, 0xf5, 0xfa, 0x31, 0xf9,
+ 0x8d, 0x4f, 0xf0, 0x3c, 0x7d, 0x61, 0x8d, 0x7a,
+ 0x6b, 0xcb, 0x2c, 0x79, 0xca, 0x99, 0x06, 0x6f,
+ 0xff, 0x5d, 0x12, 0x5f, 0x0e, 0x7a, 0x33, 0x6b,
+ 0x51, 0xbc, 0x58, 0x53, 0xff, 0xbd, 0x85, 0xc9,
+ 0xac, 0x5f, 0x33, 0xc2, 0xa2, 0xf1, 0x17, 0x7a,
+ 0xd9, 0x3f, 0x81, 0x82, 0x2f, 0x0a, 0xb0, 0xaf,
+ 0xb9, 0x19, 0x3b, 0xfa, 0xcd, 0xa4, 0x06, 0x81,
+ 0x2a, 0x7a, 0xbf, 0x2c, 0x07, 0xde, 0xc1, 0xa4,
+ 0x8c, 0x15, 0x85, 0x81, 0xa6, 0xd3, 0x73, 0x1c,
+ 0x29, 0x0b, 0xee, 0x3c, 0x57, 0xfa, 0x82, 0xad,
+ 0x6f, 0xe0, 0xa1, 0x54, 0x8d, 0xa4, 0x92, 0x29,
+ 0xf4, 0xfa, 0x6d, 0x01, 0xe3, 0x6c, 0xb9, 0x76,
+ 0x80, 0x53, 0xbb, 0x27, 0xb8, 0x18, 0x47, 0x6c,
+ 0xae, 0xb5, 0x44, 0x60, 0x43, 0x9d, 0xa7, 0x3f }
+ },
+ /* Privately generated test data */
+ {
+ .cipher_key_length = ZUC_EEA3_256_KEY_LEN,
+ .cipher_key = { 0x1d, 0x0f, 0x0e, 0x75, 0x86, 0xb3, 0xfc, 0x65,
+ 0x94, 0xbf, 0xaa, 0xa8, 0xf5, 0xd0, 0x0f, 0xe8,
+ 0x14, 0x7a, 0x96, 0x61, 0x15, 0x49, 0x79, 0x71,
+ 0x13, 0x82, 0xb4, 0xae, 0x34, 0x04, 0x75, 0x51 },
+ .cipher_iv_length = ZUC_EEA3_256_IV_LEN,
+ .cipher_iv = { 0x98, 0xcc, 0x89, 0x9f, 0xaf, 0x6d, 0x64, 0xb6,
+ 0xb1, 0xe8, 0x21, 0x72, 0xee, 0xb6, 0xcc, 0xe3,
+ 0xcf, 0x32, 0x28, 0x21, 0x21, 0x0d, 0x1e, 0x1c,
+ 0x34 },
+ .length = 1928,
+ .is_length_in_bits = true,
+ .plaintext = { 0xa4, 0xcb, 0x6e, 0x76, 0x99, 0xfb, 0x0c, 0xab,
+ 0x6d, 0x57, 0xb1, 0x69, 0xc0, 0x47, 0x80, 0x63,
+ 0x00, 0xe1, 0xf9, 0x51, 0x10, 0xbe, 0xc0, 0x0f,
+ 0x99, 0x62, 0x2d, 0x71, 0xca, 0x75, 0xa0, 0x6e,
+ 0x41, 0x0e, 0xe4, 0xda, 0x09, 0xf1, 0x86, 0x76,
+ 0x48, 0x37, 0xe0, 0x08, 0x7e, 0x60, 0x6c, 0x7f,
+ 0x41, 0x65, 0xd0, 0x51, 0x24, 0x91, 0x61, 0xbd,
+ 0xf3, 0x8e, 0x2e, 0xbd, 0x04, 0xce, 0x2b, 0x45,
+ 0xdc, 0x0f, 0x1f, 0xe5, 0x00, 0xa5, 0x5c, 0x48,
+ 0xdd, 0x3c, 0x51, 0x5b, 0x9c, 0xbd, 0xda, 0xde,
+ 0x22, 0xab, 0x2f, 0x46, 0x3c, 0x90, 0x03, 0x2f,
+ 0x1f, 0x31, 0xec, 0x23, 0xff, 0x17, 0x68, 0xdb,
+ 0x26, 0x87, 0xc1, 0x27, 0x2d, 0x1d, 0x6f, 0x0a,
+ 0x59, 0xc0, 0x65, 0xf5, 0x7d, 0x40, 0xd3, 0xa0,
+ 0xeb, 0x03, 0xe6, 0x27, 0x93, 0xea, 0x56, 0xb2,
+ 0x1b, 0x42, 0xd5, 0x1b, 0x59, 0x3d, 0xf6, 0x7f,
+ 0xc5, 0xb7, 0xa6, 0xf2, 0xd4, 0x16, 0xfc, 0x2d,
+ 0xd6, 0x61, 0x23, 0x54, 0xa1, 0xf6, 0xf4, 0x8c,
+ 0xf9, 0xda, 0xb3, 0x8d, 0xc4, 0x09, 0x3f, 0xe0,
+ 0x4b, 0x15, 0xfb, 0xa4, 0x52, 0xf1, 0x24, 0x17,
+ 0xa9, 0xca, 0x09, 0x7d, 0xe0, 0x05, 0xab, 0xb7,
+ 0x67, 0xce, 0x0b, 0x08, 0xc4, 0xff, 0x95, 0xbe,
+ 0xd9, 0x48, 0x4b, 0x9e, 0x52, 0x8a, 0x7e, 0x9d,
+ 0x9f, 0x79, 0x42, 0xf2, 0x6a, 0x66, 0x09, 0x13,
+ 0x30, 0x13, 0x91, 0x11, 0x18, 0x3c, 0xc8, 0x7f,
+ 0x0a, 0xd3, 0x88, 0xce, 0xd2, 0x1d, 0x8c, 0xab,
+ 0x65, 0xd7, 0x49, 0xb7, 0x62, 0xc7, 0x55, 0x01,
+ 0x40, 0x97, 0xf3, 0xab, 0xfd, 0xfd, 0xbe, 0x2d,
+ 0x10, 0x4f, 0x3e, 0x28, 0x8b, 0x06, 0xa8, 0x95,
+ 0xd9, 0x30, 0x64, 0xab, 0x4d, 0xf0, 0x57, 0xb2,
+ 0xc8 },
+ .ciphertext = { 0xd0, 0xf9, 0xff, 0xce, 0x03, 0x81, 0x14, 0x9c,
+ 0xd5, 0xf2, 0xbf, 0xe5, 0xff, 0xc8, 0x15, 0x4a,
+ 0x9c, 0x06, 0x2b, 0x17, 0x99, 0xe3, 0x48, 0x70,
+ 0x37, 0x01, 0x5e, 0x24, 0x80, 0x9a, 0x46, 0x4e,
+ 0xa8, 0xc0, 0x59, 0xd7, 0x03, 0x74, 0x28, 0x91,
+ 0x79, 0xb4, 0xb5, 0xd6, 0x52, 0x92, 0x04, 0x77,
+ 0x5b, 0x4f, 0x34, 0xd1, 0xbe, 0xaa, 0x74, 0xd9,
+ 0x01, 0x40, 0x24, 0xc7, 0x8c, 0x62, 0x2a, 0x51,
+ 0x5a, 0x58, 0x0e, 0xc8, 0x70, 0x12, 0x06, 0x1c,
+ 0x62, 0x7f, 0xf5, 0x23, 0xcb, 0x3c, 0xc1, 0xbe,
+ 0x8b, 0x7f, 0x9d, 0x12, 0xb8, 0x26, 0xc8, 0xa3,
+ 0x77, 0x7e, 0x83, 0xda, 0x83, 0xe1, 0x9f, 0xef,
+ 0x33, 0x62, 0x17, 0xa7, 0x74, 0x68, 0x34, 0x5e,
+ 0x16, 0xcc, 0xbc, 0x6c, 0x33, 0x2f, 0x73, 0xf0,
+ 0xfc, 0xe5, 0x2c, 0x2d, 0xfb, 0x81, 0xbe, 0x1e,
+ 0x6e, 0x4f, 0xf4, 0x14, 0x37, 0x7c, 0x97, 0xac,
+ 0xa9, 0xac, 0x68, 0x95, 0xf3, 0x55, 0xb3, 0xfb,
+ 0xf6, 0x64, 0xd9, 0x1b, 0xe1, 0x54, 0x79, 0x6e,
+ 0xfa, 0x21, 0xa4, 0x19, 0x9f, 0xb4, 0x4b, 0xb7,
+ 0xef, 0x52, 0xd8, 0x44, 0x75, 0x99, 0x07, 0x6d,
+ 0xa9, 0xcf, 0x32, 0xc5, 0xc1, 0x31, 0x0c, 0xa8,
+ 0x86, 0x40, 0x75, 0xeb, 0x12, 0xcf, 0x26, 0x5c,
+ 0x5f, 0xa3, 0x3c, 0xb6, 0x12, 0x45, 0xf3, 0x0a,
+ 0x38, 0x09, 0xa8, 0x36, 0x32, 0x4a, 0x2f, 0xad,
+ 0x50, 0x11, 0x38, 0xba, 0x8f, 0xdd, 0xd1, 0x58,
+ 0xd7, 0x3d, 0x3a, 0x40, 0x7c, 0x3f, 0xa7, 0x98,
+ 0xf3, 0x12, 0x7f, 0x9f, 0x89, 0xcf, 0x48, 0x58,
+ 0x01, 0xeb, 0x98, 0x7c, 0x59, 0x11, 0x9f, 0x57,
+ 0x74, 0x5f, 0x70, 0x72, 0x74, 0xa4, 0x82, 0x3c,
+ 0x36, 0xe6, 0x31, 0x9e, 0xba, 0x7b, 0x53, 0xfc,
+ 0x56 }
+ },
};
static crypto_test_reference_t zuc_eia3_reference[] = {
@@ -2562,7 +2687,143 @@ static crypto_test_reference_t zuc_eia3_reference[] = {
0x00, 0x00, 0x00, 0x00 },
.digest_length = ZUC_EIA3_DIGEST_LEN,
.digest = { 0x24, 0xa8, 0x42, 0xb3 }
- }
+ },
+ /* Privately generated test data */
+ {
+ .auth_key_length = ZUC_EIA3_256_KEY_LEN,
+ .auth_key = { 0xe3, 0x8e, 0xaf, 0x08, 0xde, 0x8c, 0x08, 0x41,
+ 0x7f, 0x2b, 0x97, 0x20, 0x10, 0x87, 0xc7, 0xf7,
+ 0xbe, 0x3c, 0xd2, 0x68, 0x80, 0x10, 0x1e, 0x71,
+ 0xfd, 0xb2, 0xbb, 0xad, 0x25, 0x0f, 0x06, 0x08 },
+ .auth_iv_length = ZUC_EIA3_256_IV_LEN,
+ .auth_iv = { 0xf5, 0x8d, 0x08, 0x26, 0x94, 0x14, 0xc7, 0x4d,
+ 0xf5, 0x7c, 0x9c, 0xaa, 0x45, 0x53, 0xfd, 0x85,
+ 0x23, 0x0b, 0x00, 0x0e, 0x26, 0x2b, 0x0f, 0x01,
+ 0x26 },
+ .length = 360,
+ .is_length_in_bits = true,
+ .plaintext = { 0x08, 0xba, 0x8d, 0xf1, 0xf8, 0x62, 0xa6, 0xaf,
+ 0xf9, 0x03, 0x88, 0x9c, 0xa3, 0x68, 0x6b, 0x87,
+ 0xb6, 0x92, 0xd1, 0x47, 0x3e, 0x54, 0xaf, 0x46,
+ 0x07, 0x8f, 0x89, 0xea, 0x26, 0x9d, 0x0e, 0x2f,
+ 0x57, 0x9b, 0x20, 0x4f, 0xfe, 0xc7, 0xfe, 0xf7,
+ 0xca, 0x86, 0x93, 0x6d, 0xee },
+ .ciphertext = { 0x08, 0xba, 0x8d, 0xf1, 0xf8, 0x62, 0xa6, 0xaf,
+ 0xf9, 0x03, 0x88, 0x9c, 0xa3, 0x68, 0x6b, 0x87,
+ 0xb6, 0x92, 0xd1, 0x47, 0x3e, 0x54, 0xaf, 0x46,
+ 0x07, 0x8f, 0x89, 0xea, 0x26, 0x9d, 0x0e, 0x2f,
+ 0x57, 0x9b, 0x20, 0x4f, 0xfe, 0xc7, 0xfe, 0xf7,
+ 0xca, 0x86, 0x93, 0x6d, 0xee },
+ .digest_length = ZUC_EIA3_DIGEST_LEN,
+ .digest = {0x58, 0x19, 0xab, 0xa5}
+ },
+ /* Privately generated test data */
+ {
+ .auth_key_length = ZUC_EIA3_256_KEY_LEN,
+ .auth_key = { 0x6a, 0x7e, 0x4c, 0x7e, 0x51, 0x25, 0xb3, 0x48,
+ 0x84, 0x53, 0x3a, 0x94, 0xfb, 0x31, 0x99, 0x90,
+ 0x32, 0x57, 0x44, 0xee, 0x9b, 0xbc, 0xe9, 0xe5,
+ 0x25, 0xcf, 0x08, 0xf5, 0xe9, 0xe2, 0x5e, 0x53 },
+ .auth_iv_length = ZUC_EIA3_256_IV_LEN,
+ .auth_iv = { 0x60, 0xaa, 0xd2, 0xb2, 0xd0, 0x85, 0xfa, 0x54,
+ 0xd8, 0x35, 0xe8, 0xd4, 0x66, 0x82, 0x64, 0x98,
+ 0xd9, 0x2a, 0x08, 0x1d, 0x35, 0x19, 0x17, 0x01,
+ 0x1A },
+ .length = 2872,
+ .is_length_in_bits = true,
+ .plaintext = { 0xc6, 0x69, 0x73, 0x51, 0xff, 0x4a, 0xec, 0x29,
+ 0xcd, 0xba, 0xab, 0xf2, 0xfb, 0xe3, 0x46, 0x7c,
+ 0xc2, 0x54, 0xf8, 0x1b, 0xe8, 0xe7, 0x8d, 0x76,
+ 0x5a, 0x2e, 0x63, 0x33, 0x9f, 0xc9, 0x9a, 0x66,
+ 0x32, 0x0d, 0xb7, 0x31, 0x58, 0xa3, 0x5a, 0x25,
+ 0x5d, 0x05, 0x17, 0x58, 0xe9, 0x5e, 0xd4, 0xab,
+ 0xb2, 0xcd, 0xc6, 0x9b, 0xb4, 0x54, 0x11, 0x0e,
+ 0x82, 0x74, 0x41, 0x21, 0x3d, 0xdc, 0x87, 0x70,
+ 0xe9, 0x3e, 0xa1, 0x41, 0xe1, 0xfc, 0x67, 0x3e,
+ 0x01, 0x7e, 0x97, 0xea, 0xdc, 0x6b, 0x96, 0x8f,
+ 0x38, 0x5c, 0x2a, 0xec, 0xb0, 0x3b, 0xfb, 0x32,
+ 0xaf, 0x3c, 0x54, 0xec, 0x18, 0xdb, 0x5c, 0x02,
+ 0x1a, 0xfe, 0x43, 0xfb, 0xfa, 0xaa, 0x3a, 0xfb,
+ 0x29, 0xd1, 0xe6, 0x05, 0x3c, 0x7c, 0x94, 0x75,
+ 0xd8, 0xbe, 0x61, 0x89, 0xf9, 0x5c, 0xbb, 0xa8,
+ 0x99, 0x0f, 0x95, 0xb1, 0xeb, 0xf1, 0xb3, 0x05,
+ 0xef, 0xf7, 0x00, 0xe9, 0xa1, 0x3a, 0xe5, 0xca,
+ 0x0b, 0xcb, 0xd0, 0x48, 0x47, 0x64, 0xbd, 0x1f,
+ 0x23, 0x1e, 0xa8, 0x1c, 0x7b, 0x64, 0xc5, 0x14,
+ 0x73, 0x5a, 0xc5, 0x5e, 0x4b, 0x79, 0x63, 0x3b,
+ 0x70, 0x64, 0x24, 0x11, 0x9e, 0x09, 0xdc, 0xaa,
+ 0xd4, 0xac, 0xf2, 0x1b, 0x10, 0xaf, 0x3b, 0x33,
+ 0xcd, 0xe3, 0x50, 0x48, 0x47, 0x15, 0x5c, 0xbb,
+ 0x6f, 0x22, 0x19, 0xba, 0x9b, 0x7d, 0xf5, 0x0b,
+ 0xe1, 0x1a, 0x1c, 0x7f, 0x23, 0xf8, 0x29, 0xf8,
+ 0xa4, 0x1b, 0x13, 0xb5, 0xca, 0x4e, 0xe8, 0x98,
+ 0x32, 0x38, 0xe0, 0x79, 0x4d, 0x3d, 0x34, 0xbc,
+ 0x5f, 0x4e, 0x77, 0xfa, 0xcb, 0x6c, 0x05, 0xac,
+ 0x86, 0x21, 0x2b, 0xaa, 0x1a, 0x55, 0xa2, 0xbe,
+ 0x70, 0xb5, 0x73, 0x3b, 0x04, 0x5c, 0xd3, 0x36,
+ 0x94, 0xb3, 0xaf, 0xe2, 0xf0, 0xe4, 0x9e, 0x4f,
+ 0x32, 0x15, 0x49, 0xfd, 0x82, 0x4e, 0xa9, 0x08,
+ 0x70, 0xd4, 0xb2, 0x8a, 0x29, 0x54, 0x48, 0x9a,
+ 0x0a, 0xbc, 0xd5, 0x0e, 0x18, 0xa8, 0x44, 0xac,
+ 0x5b, 0xf3, 0x8e, 0x4c, 0xd7, 0x2d, 0x9b, 0x09,
+ 0x42, 0xe5, 0x06, 0xc4, 0x33, 0xaf, 0xcd, 0xa3,
+ 0x84, 0x7f, 0x2d, 0xad, 0xd4, 0x76, 0x47, 0xde,
+ 0x32, 0x1c, 0xec, 0x4a, 0xc4, 0x30, 0xf6, 0x20,
+ 0x23, 0x85, 0x6c, 0xfb, 0xb2, 0x07, 0x04, 0xf4,
+ 0xec, 0x0b, 0xb9, 0x20, 0xba, 0x86, 0xc3, 0x3e,
+ 0x05, 0xf1, 0xec, 0xd9, 0x67, 0x33, 0xb7, 0x99,
+ 0x50, 0xa3, 0xe3, 0x14, 0xd3, 0xd9, 0x34, 0xf7,
+ 0x5e, 0xa0, 0xf2, 0x10, 0xa8, 0xf6, 0x05, 0x94,
+ 0x01, 0xbe, 0xb4, 0xbc, 0x44, 0x78, 0xfa, 0x49,
+ 0x69, 0xe6, 0x23, 0xd0, 0x1a, 0xda, 0x69 },
+ .ciphertext = { 0xc6, 0x69, 0x73, 0x51, 0xff, 0x4a, 0xec, 0x29,
+ 0xcd, 0xba, 0xab, 0xf2, 0xfb, 0xe3, 0x46, 0x7c,
+ 0xc2, 0x54, 0xf8, 0x1b, 0xe8, 0xe7, 0x8d, 0x76,
+ 0x5a, 0x2e, 0x63, 0x33, 0x9f, 0xc9, 0x9a, 0x66,
+ 0x32, 0x0d, 0xb7, 0x31, 0x58, 0xa3, 0x5a, 0x25,
+ 0x5d, 0x05, 0x17, 0x58, 0xe9, 0x5e, 0xd4, 0xab,
+ 0xb2, 0xcd, 0xc6, 0x9b, 0xb4, 0x54, 0x11, 0x0e,
+ 0x82, 0x74, 0x41, 0x21, 0x3d, 0xdc, 0x87, 0x70,
+ 0xe9, 0x3e, 0xa1, 0x41, 0xe1, 0xfc, 0x67, 0x3e,
+ 0x01, 0x7e, 0x97, 0xea, 0xdc, 0x6b, 0x96, 0x8f,
+ 0x38, 0x5c, 0x2a, 0xec, 0xb0, 0x3b, 0xfb, 0x32,
+ 0xaf, 0x3c, 0x54, 0xec, 0x18, 0xdb, 0x5c, 0x02,
+ 0x1a, 0xfe, 0x43, 0xfb, 0xfa, 0xaa, 0x3a, 0xfb,
+ 0x29, 0xd1, 0xe6, 0x05, 0x3c, 0x7c, 0x94, 0x75,
+ 0xd8, 0xbe, 0x61, 0x89, 0xf9, 0x5c, 0xbb, 0xa8,
+ 0x99, 0x0f, 0x95, 0xb1, 0xeb, 0xf1, 0xb3, 0x05,
+ 0xef, 0xf7, 0x00, 0xe9, 0xa1, 0x3a, 0xe5, 0xca,
+ 0x0b, 0xcb, 0xd0, 0x48, 0x47, 0x64, 0xbd, 0x1f,
+ 0x23, 0x1e, 0xa8, 0x1c, 0x7b, 0x64, 0xc5, 0x14,
+ 0x73, 0x5a, 0xc5, 0x5e, 0x4b, 0x79, 0x63, 0x3b,
+ 0x70, 0x64, 0x24, 0x11, 0x9e, 0x09, 0xdc, 0xaa,
+ 0xd4, 0xac, 0xf2, 0x1b, 0x10, 0xaf, 0x3b, 0x33,
+ 0xcd, 0xe3, 0x50, 0x48, 0x47, 0x15, 0x5c, 0xbb,
+ 0x6f, 0x22, 0x19, 0xba, 0x9b, 0x7d, 0xf5, 0x0b,
+ 0xe1, 0x1a, 0x1c, 0x7f, 0x23, 0xf8, 0x29, 0xf8,
+ 0xa4, 0x1b, 0x13, 0xb5, 0xca, 0x4e, 0xe8, 0x98,
+ 0x32, 0x38, 0xe0, 0x79, 0x4d, 0x3d, 0x34, 0xbc,
+ 0x5f, 0x4e, 0x77, 0xfa, 0xcb, 0x6c, 0x05, 0xac,
+ 0x86, 0x21, 0x2b, 0xaa, 0x1a, 0x55, 0xa2, 0xbe,
+ 0x70, 0xb5, 0x73, 0x3b, 0x04, 0x5c, 0xd3, 0x36,
+ 0x94, 0xb3, 0xaf, 0xe2, 0xf0, 0xe4, 0x9e, 0x4f,
+ 0x32, 0x15, 0x49, 0xfd, 0x82, 0x4e, 0xa9, 0x08,
+ 0x70, 0xd4, 0xb2, 0x8a, 0x29, 0x54, 0x48, 0x9a,
+ 0x0a, 0xbc, 0xd5, 0x0e, 0x18, 0xa8, 0x44, 0xac,
+ 0x5b, 0xf3, 0x8e, 0x4c, 0xd7, 0x2d, 0x9b, 0x09,
+ 0x42, 0xe5, 0x06, 0xc4, 0x33, 0xaf, 0xcd, 0xa3,
+ 0x84, 0x7f, 0x2d, 0xad, 0xd4, 0x76, 0x47, 0xde,
+ 0x32, 0x1c, 0xec, 0x4a, 0xc4, 0x30, 0xf6, 0x20,
+ 0x23, 0x85, 0x6c, 0xfb, 0xb2, 0x07, 0x04, 0xf4,
+ 0xec, 0x0b, 0xb9, 0x20, 0xba, 0x86, 0xc3, 0x3e,
+ 0x05, 0xf1, 0xec, 0xd9, 0x67, 0x33, 0xb7, 0x99,
+ 0x50, 0xa3, 0xe3, 0x14, 0xd3, 0xd9, 0x34, 0xf7,
+ 0x5e, 0xa0, 0xf2, 0x10, 0xa8, 0xf6, 0x05, 0x94,
+ 0x01, 0xbe, 0xb4, 0xbc, 0x44, 0x78, 0xfa, 0x49,
+ 0x69, 0xe6, 0x23, 0xd0, 0x1a, 0xda, 0x69 },
+ .digest_length = ZUC_EIA3_DIGEST_LEN,
+ .digest = {0xd1, 0x1e, 0x33, 0xf6}
+ },
};
/*
diff --git a/test/validation/api/crypto/test_vectors_len.h b/test/validation/api/crypto/test_vectors_len.h
index 9edf2999e..3818b57a0 100644
--- a/test/validation/api/crypto/test_vectors_len.h
+++ b/test/validation/api/crypto/test_vectors_len.h
@@ -8,7 +8,7 @@
/* Maximum */
#define MAX_KEY_LEN 64
-#define MAX_IV_LEN 16
+#define MAX_IV_LEN 32
#define MAX_DATA_LEN 1000
#define MAX_AAD_LEN 12
#define MAX_DIGEST_LEN 64
@@ -101,6 +101,10 @@
#define ZUC_EEA3_KEY_LEN 16
#define ZUC_EEA3_IV_LEN 16
+/* ZUC_EEA3_256 */
+#define ZUC_EEA3_256_KEY_LEN 32
+#define ZUC_EEA3_256_IV_LEN 25
+
/* KASUMI_F9 */
#define KASUMI_F9_KEY_LEN 16
#define KASUMI_F9_IV_LEN 9
@@ -121,6 +125,10 @@
#define ZUC_EIA3_IV_LEN 16
#define ZUC_EIA3_DIGEST_LEN 4
+/* ZUC_EIA3_256 */
+#define ZUC_EIA3_256_KEY_LEN 32
+#define ZUC_EIA3_256_IV_LEN 25
+
/* MD5 */
#define MD5_DIGEST_LEN 16
diff --git a/test/validation/api/ipsec/ipsec.c b/test/validation/api/ipsec/ipsec.c
index d12234a5a..c98afae4e 100644
--- a/test/validation/api/ipsec/ipsec.c
+++ b/test/validation/api/ipsec/ipsec.c
@@ -614,6 +614,7 @@ static int recv_pkts_inline(const ipsec_test_part *part,
num_pkts = 1;
break;
case ODP_PACKET_REASS_INCOMPLETE:
+ reass_state.num_frags = 0;
CU_ASSERT(0 ==
odp_packet_reass_partial_state(pkt, frags, &reass_state));
num_pkts = reass_state.num_frags;
diff --git a/test/validation/api/lock/lock.c b/test/validation/api/lock/lock.c
index c5e07c776..bf9318e76 100644
--- a/test/validation/api/lock/lock.c
+++ b/test/validation/api/lock/lock.c
@@ -1007,7 +1007,7 @@ static void lock_test_no_lock_functional(void)
{
int num = global_mem->g_num_threads;
- odp_cunit_thread_create(num, no_lock_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, no_lock_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1021,7 +1021,7 @@ static void lock_test_spinlock_api(void)
{
int num = global_mem->g_num_threads;
- odp_cunit_thread_create(num, spinlock_api_tests, NULL, 0);
+ odp_cunit_thread_create(num, spinlock_api_tests, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1030,7 +1030,7 @@ static void lock_test_spinlock_functional(void)
int num = global_mem->g_num_threads;
odp_spinlock_init(&global_mem->global_spinlock);
- odp_cunit_thread_create(num, spinlock_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, spinlock_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1038,7 +1038,7 @@ static void lock_test_spinlock_recursive_api(void)
{
int num = global_mem->g_num_threads;
- odp_cunit_thread_create(num, spinlock_recursive_api_tests, NULL, 0);
+ odp_cunit_thread_create(num, spinlock_recursive_api_tests, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1047,7 +1047,7 @@ static void lock_test_spinlock_recursive_functional(void)
int num = global_mem->g_num_threads;
odp_spinlock_recursive_init(&global_mem->global_recursive_spinlock);
- odp_cunit_thread_create(num, spinlock_recursive_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, spinlock_recursive_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1068,7 +1068,7 @@ static void lock_test_ticketlock_api(void)
{
int num = global_mem->g_num_threads;
- odp_cunit_thread_create(num, ticketlock_api_tests, NULL, 0);
+ odp_cunit_thread_create(num, ticketlock_api_tests, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1077,7 +1077,7 @@ static void lock_test_ticketlock_functional(void)
int num = global_mem->g_num_threads;
odp_ticketlock_init(&global_mem->global_ticketlock);
- odp_cunit_thread_create(num, ticketlock_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, ticketlock_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1092,7 +1092,7 @@ static void lock_test_rwlock_api(void)
{
int num = global_mem->g_num_threads;
- odp_cunit_thread_create(num, rwlock_api_tests, NULL, 0);
+ odp_cunit_thread_create(num, rwlock_api_tests, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1101,7 +1101,7 @@ static void lock_test_rwlock_functional(void)
int num = global_mem->g_num_threads;
odp_rwlock_init(&global_mem->global_rwlock);
- odp_cunit_thread_create(num, rwlock_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, rwlock_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1115,7 +1115,7 @@ static void lock_test_rwlock_recursive_api(void)
{
int num = global_mem->g_num_threads;
- odp_cunit_thread_create(num, rwlock_recursive_api_tests, NULL, 0);
+ odp_cunit_thread_create(num, rwlock_recursive_api_tests, NULL, 0, 0);
odp_cunit_thread_join(num);
}
@@ -1124,7 +1124,7 @@ static void lock_test_rwlock_recursive_functional(void)
int num = global_mem->g_num_threads;
odp_rwlock_recursive_init(&global_mem->global_recursive_rwlock);
- odp_cunit_thread_create(num, rwlock_recursive_functional_test, NULL, 0);
+ odp_cunit_thread_create(num, rwlock_recursive_functional_test, NULL, 0, 0);
odp_cunit_thread_join(num);
}
diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c
index 1ddff1ae1..d81fba3de 100644
--- a/test/validation/api/packet/packet.c
+++ b/test/validation/api/packet/packet.c
@@ -1,5 +1,5 @@
/* Copyright (c) 2014-2018, Linaro Limited
- * Copyright (c) 2019-2020, Nokia
+ * Copyright (c) 2019-2022, Nokia
* Copyright (c) 2020, Marvell
* All rights reserved.
*
@@ -189,7 +189,7 @@ static int packet_suite_init(void)
odp_pool_param_t params;
odp_packet_t pkt_tbl[PACKET_POOL_NUM_SEG];
struct udata_struct *udat;
- uint32_t udat_size;
+ uint32_t uarea_size;
uint8_t data = 0;
uint32_t i;
uint32_t num = PACKET_POOL_NUM;
@@ -201,6 +201,10 @@ static int packet_suite_init(void)
printf("pool_capability failed\n");
return -1;
}
+
+ if (pool_capa.pkt.max_uarea_size == 0)
+ printf("Warning: Packet user area not supported\n");
+
if (pool_capa.pkt.max_segs_per_pkt == 0)
pool_capa.pkt.max_segs_per_pkt = 10;
@@ -232,6 +236,10 @@ static int packet_suite_init(void)
params.pkt.num = num;
params.pkt.uarea_size = sizeof(struct udata_struct);
+ if (params.pkt.uarea_size > pool_capa.pkt.max_uarea_size)
+ params.pkt.uarea_size = pool_capa.pkt.max_uarea_size;
+
+ uarea_size = params.pkt.uarea_size;
memcpy(&default_param, &params, sizeof(odp_pool_param_t));
default_pool = odp_pool_create("default_pool", &params);
@@ -288,23 +296,22 @@ static int packet_suite_init(void)
}
udat = odp_packet_user_area(test_packet);
- udat_size = odp_packet_user_area_size(test_packet);
- if (!udat || udat_size != sizeof(struct udata_struct)) {
- printf("packet_user_area failed: 1\n");
+ if (odp_packet_user_area_size(test_packet) < uarea_size) {
+ printf("Bad packet user area size %u\n", odp_packet_user_area_size(test_packet));
return -1;
}
odp_pool_print(default_pool);
- memcpy(udat, &test_packet_udata, sizeof(struct udata_struct));
+ memcpy(udat, &test_packet_udata, uarea_size);
udat = odp_packet_user_area(segmented_test_packet);
- udat_size = odp_packet_user_area_size(segmented_test_packet);
- if (udat == NULL || udat_size != sizeof(struct udata_struct)) {
- printf("packet_user_area failed: 2\n");
+ if (odp_packet_user_area_size(segmented_test_packet) < uarea_size) {
+ printf("Bad segmented packet user area size %u\n",
+ odp_packet_user_area_size(segmented_test_packet));
return -1;
}
- memcpy(udat, &test_packet_udata, sizeof(struct udata_struct));
+ memcpy(udat, &test_packet_udata, uarea_size);
return 0;
}
@@ -320,6 +327,58 @@ static int packet_suite_term(void)
return 0;
}
+static void packet_set_inflags(odp_packet_t pkt, int val)
+{
+ odp_packet_has_l2_set(pkt, val);
+ odp_packet_has_l3_set(pkt, val);
+ odp_packet_has_l4_set(pkt, val);
+ odp_packet_has_eth_set(pkt, val);
+ odp_packet_has_eth_bcast_set(pkt, val);
+ odp_packet_has_eth_mcast_set(pkt, val);
+ odp_packet_has_jumbo_set(pkt, val);
+ odp_packet_has_vlan_set(pkt, val);
+ odp_packet_has_vlan_qinq_set(pkt, val);
+ odp_packet_has_arp_set(pkt, val);
+ odp_packet_has_ipv4_set(pkt, val);
+ odp_packet_has_ipv6_set(pkt, val);
+ odp_packet_has_ip_bcast_set(pkt, val);
+ odp_packet_has_ip_mcast_set(pkt, val);
+ odp_packet_has_ipfrag_set(pkt, val);
+ odp_packet_has_ipopt_set(pkt, val);
+ odp_packet_has_ipsec_set(pkt, val);
+ odp_packet_has_udp_set(pkt, val);
+ odp_packet_has_tcp_set(pkt, val);
+ odp_packet_has_sctp_set(pkt, val);
+ odp_packet_has_icmp_set(pkt, val);
+ odp_packet_user_flag_set(pkt, val);
+}
+
+static void packet_check_inflags(odp_packet_t pkt, int val)
+{
+ CU_ASSERT(odp_packet_has_l2(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_l3(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_l4(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_eth(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_eth_bcast(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_eth_mcast(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_jumbo(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_vlan(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_vlan_qinq(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_arp(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_ipv4(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_ipv6(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_ip_bcast(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_ip_mcast(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_ipfrag(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_ipopt(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_ipsec(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_udp(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_tcp(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_sctp(pkt) == !!val);
+ CU_ASSERT(odp_packet_has_icmp(pkt) == !!val);
+ CU_ASSERT(odp_packet_user_flag(pkt) == !!val);
+}
+
static void packet_test_alloc_free(void)
{
odp_pool_t pool;
@@ -356,6 +415,9 @@ static void packet_test_alloc_free(void)
/* User pointer should be NULL after alloc */
CU_ASSERT(odp_packet_user_ptr(packet) == NULL);
+ /* Packet flags should be zero */
+ packet_check_inflags(packet, 0);
+
/* Pool should have only one packet */
CU_ASSERT_FATAL(odp_packet_alloc(pool, packet_len)
== ODP_PACKET_INVALID);
@@ -873,11 +935,10 @@ static void packet_test_reset(void)
CU_ASSERT(odp_packet_reset(pkt, len) == 0);
CU_ASSERT(odp_packet_len(pkt) == len);
- CU_ASSERT(odp_packet_has_udp(pkt) == 0);
- odp_packet_has_udp_set(pkt, 1);
- CU_ASSERT(odp_packet_has_udp(pkt) != 0);
+ packet_set_inflags(pkt, 1);
+ packet_check_inflags(pkt, 1);
CU_ASSERT(odp_packet_reset(pkt, len) == 0);
- CU_ASSERT(odp_packet_has_udp(pkt) == 0);
+ packet_check_inflags(pkt, 0);
CU_ASSERT(odp_packet_reset(pkt, len - 1) == 0);
CU_ASSERT(odp_packet_len(pkt) == (len - 1));
@@ -906,10 +967,11 @@ static void packet_test_debug(void)
static void packet_test_context(void)
{
- odp_packet_t pkt = test_packet;
- char ptr_test_value = 2;
void *prev_ptr;
struct udata_struct *udat;
+ uint32_t uarea_size;
+ odp_packet_t pkt = test_packet;
+ char ptr_test_value = 2;
prev_ptr = odp_packet_user_ptr(pkt);
odp_packet_user_ptr_set(pkt, &ptr_test_value);
@@ -917,11 +979,15 @@ static void packet_test_context(void)
odp_packet_user_ptr_set(pkt, prev_ptr);
udat = odp_packet_user_area(pkt);
- CU_ASSERT_PTR_NOT_NULL(udat);
- CU_ASSERT(odp_packet_user_area_size(pkt) ==
- sizeof(struct udata_struct));
- CU_ASSERT(memcmp(udat, &test_packet_udata, sizeof(struct udata_struct))
- == 0);
+ uarea_size = odp_packet_user_area_size(pkt);
+ CU_ASSERT(uarea_size >= default_param.pkt.uarea_size);
+
+ if (uarea_size) {
+ CU_ASSERT(udat != NULL);
+ CU_ASSERT(memcmp(udat, &test_packet_udata, default_param.pkt.uarea_size) == 0);
+ } else {
+ CU_ASSERT(udat == NULL);
+ }
odp_packet_user_ptr_set(pkt, NULL);
CU_ASSERT(odp_packet_user_ptr(pkt) == NULL);
@@ -1296,37 +1362,46 @@ static void packet_test_segment_last(void)
#define TEST_INFLAG(packet, flag) \
do { \
- odp_packet_has_##flag##_set(packet, 0); \
- CU_ASSERT(odp_packet_has_##flag(packet) == 0); \
- odp_packet_has_##flag##_set(packet, 1); \
- CU_ASSERT(odp_packet_has_##flag(packet) != 0); \
+ odp_packet_##flag##_set(packet, 0); \
+ CU_ASSERT(odp_packet_##flag(packet) == 0); \
+ odp_packet_##flag##_set(packet, 1); \
+ CU_ASSERT(odp_packet_##flag(packet) != 0); \
} while (0)
static void packet_test_in_flags(void)
{
odp_packet_t pkt = test_packet;
- TEST_INFLAG(pkt, l2);
- TEST_INFLAG(pkt, l3);
- TEST_INFLAG(pkt, l4);
- TEST_INFLAG(pkt, eth);
- TEST_INFLAG(pkt, eth_bcast);
- TEST_INFLAG(pkt, eth_mcast);
- TEST_INFLAG(pkt, jumbo);
- TEST_INFLAG(pkt, vlan);
- TEST_INFLAG(pkt, vlan_qinq);
- TEST_INFLAG(pkt, arp);
- TEST_INFLAG(pkt, ipv4);
- TEST_INFLAG(pkt, ipv6);
- TEST_INFLAG(pkt, ip_bcast);
- TEST_INFLAG(pkt, ip_mcast);
- TEST_INFLAG(pkt, ipfrag);
- TEST_INFLAG(pkt, ipopt);
- TEST_INFLAG(pkt, ipsec);
- TEST_INFLAG(pkt, udp);
- TEST_INFLAG(pkt, tcp);
- TEST_INFLAG(pkt, sctp);
- TEST_INFLAG(pkt, icmp);
+ packet_set_inflags(pkt, 0);
+ packet_check_inflags(pkt, 0);
+ packet_set_inflags(pkt, 1);
+ packet_check_inflags(pkt, 1);
+
+ TEST_INFLAG(pkt, has_l2);
+ TEST_INFLAG(pkt, has_l3);
+ TEST_INFLAG(pkt, has_l4);
+ TEST_INFLAG(pkt, has_eth);
+ TEST_INFLAG(pkt, has_eth_bcast);
+ TEST_INFLAG(pkt, has_eth_mcast);
+ TEST_INFLAG(pkt, has_jumbo);
+ TEST_INFLAG(pkt, has_vlan);
+ TEST_INFLAG(pkt, has_vlan_qinq);
+ TEST_INFLAG(pkt, has_arp);
+ TEST_INFLAG(pkt, has_ipv4);
+ TEST_INFLAG(pkt, has_ipv6);
+ TEST_INFLAG(pkt, has_ip_bcast);
+ TEST_INFLAG(pkt, has_ip_mcast);
+ TEST_INFLAG(pkt, has_ipfrag);
+ TEST_INFLAG(pkt, has_ipopt);
+ TEST_INFLAG(pkt, has_ipsec);
+ TEST_INFLAG(pkt, has_udp);
+ TEST_INFLAG(pkt, has_tcp);
+ TEST_INFLAG(pkt, has_sctp);
+ TEST_INFLAG(pkt, has_icmp);
+ TEST_INFLAG(pkt, user_flag);
+
+ packet_set_inflags(pkt, 0);
+ packet_check_inflags(pkt, 0);
}
static void packet_test_error_flags(void)
@@ -1364,9 +1439,10 @@ static void packet_test_add_rem_data(void)
odp_packet_t pkt, new_pkt;
uint32_t pkt_len, offset, add_len;
void *usr_ptr;
- struct udata_struct *udat, *new_udat;
+ struct udata_struct *udat;
int ret;
uint32_t min_seg_len;
+ uint32_t uarea_size = default_param.pkt.uarea_size;
min_seg_len = pool_capa.pkt.min_seg_len;
@@ -1375,10 +1451,14 @@ static void packet_test_add_rem_data(void)
pkt_len = odp_packet_len(pkt);
usr_ptr = odp_packet_user_ptr(pkt);
- udat = odp_packet_user_area(pkt);
- CU_ASSERT(odp_packet_user_area_size(pkt) ==
- sizeof(struct udata_struct));
- memcpy(udat, &test_packet_udata, sizeof(struct udata_struct));
+
+ if (uarea_size) {
+ udat = odp_packet_user_area(pkt);
+
+ CU_ASSERT_FATAL(udat != NULL);
+ CU_ASSERT_FATAL(odp_packet_user_area_size(pkt) >= uarea_size);
+ memcpy(udat, &test_packet_udata, uarea_size);
+ }
offset = pkt_len / 2;
@@ -1401,13 +1481,14 @@ static void packet_test_add_rem_data(void)
/* Verify that user metadata is preserved */
CU_ASSERT(odp_packet_user_ptr(new_pkt) == usr_ptr);
- /* Verify that user metadata has been preserved */
- new_udat = odp_packet_user_area(new_pkt);
- CU_ASSERT_PTR_NOT_NULL(new_udat);
- CU_ASSERT(odp_packet_user_area_size(new_pkt) ==
- sizeof(struct udata_struct));
- CU_ASSERT(memcmp(new_udat, &test_packet_udata,
- sizeof(struct udata_struct)) == 0);
+ if (uarea_size) {
+ /* Verify that user metadata has been preserved */
+ udat = odp_packet_user_area(new_pkt);
+
+ CU_ASSERT_FATAL(udat != NULL);
+ CU_ASSERT(odp_packet_user_area_size(new_pkt) >= uarea_size);
+ CU_ASSERT(memcmp(udat, &test_packet_udata, uarea_size) == 0);
+ }
pkt = new_pkt;
@@ -1422,13 +1503,14 @@ static void packet_test_add_rem_data(void)
CU_ASSERT(odp_packet_len(new_pkt) == pkt_len - add_len);
CU_ASSERT(odp_packet_user_ptr(new_pkt) == usr_ptr);
- /* Verify that user metadata has been preserved */
- new_udat = odp_packet_user_area(new_pkt);
- CU_ASSERT_PTR_NOT_NULL(new_udat);
- CU_ASSERT(odp_packet_user_area_size(new_pkt) ==
- sizeof(struct udata_struct));
- CU_ASSERT(memcmp(new_udat, &test_packet_udata,
- sizeof(struct udata_struct)) == 0);
+ if (uarea_size) {
+ /* Verify that user metadata has been preserved */
+ udat = odp_packet_user_area(new_pkt);
+
+ CU_ASSERT(udat != NULL);
+ CU_ASSERT(odp_packet_user_area_size(new_pkt) >= uarea_size);
+ CU_ASSERT(memcmp(udat, &test_packet_udata, uarea_size) == 0);
+ }
pkt = new_pkt;
@@ -1436,44 +1518,42 @@ free_packet:
odp_packet_free(pkt);
}
-#define COMPARE_HAS_INFLAG(p1, p2, flag) \
- CU_ASSERT(odp_packet_has_##flag(p1) == odp_packet_has_##flag(p2))
-
#define COMPARE_INFLAG(p1, p2, flag) \
CU_ASSERT(odp_packet_##flag(p1) == odp_packet_##flag(p2))
-static void _packet_compare_inflags(odp_packet_t pkt1, odp_packet_t pkt2)
+static void packet_compare_inflags(odp_packet_t pkt1, odp_packet_t pkt2)
{
- COMPARE_HAS_INFLAG(pkt1, pkt2, l2);
- COMPARE_HAS_INFLAG(pkt1, pkt2, l3);
- COMPARE_HAS_INFLAG(pkt1, pkt2, l4);
- COMPARE_HAS_INFLAG(pkt1, pkt2, eth);
- COMPARE_HAS_INFLAG(pkt1, pkt2, eth_bcast);
- COMPARE_HAS_INFLAG(pkt1, pkt2, eth_mcast);
- COMPARE_HAS_INFLAG(pkt1, pkt2, jumbo);
- COMPARE_HAS_INFLAG(pkt1, pkt2, vlan);
- COMPARE_HAS_INFLAG(pkt1, pkt2, vlan_qinq);
- COMPARE_HAS_INFLAG(pkt1, pkt2, arp);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ipv4);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ipv6);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ip_bcast);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ip_mcast);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ipfrag);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ipopt);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ipsec);
- COMPARE_HAS_INFLAG(pkt1, pkt2, udp);
- COMPARE_HAS_INFLAG(pkt1, pkt2, tcp);
- COMPARE_HAS_INFLAG(pkt1, pkt2, sctp);
- COMPARE_HAS_INFLAG(pkt1, pkt2, icmp);
- COMPARE_HAS_INFLAG(pkt1, pkt2, flow_hash);
- COMPARE_HAS_INFLAG(pkt1, pkt2, ts);
+ COMPARE_INFLAG(pkt1, pkt2, has_l2);
+ COMPARE_INFLAG(pkt1, pkt2, has_l3);
+ COMPARE_INFLAG(pkt1, pkt2, has_l4);
+ COMPARE_INFLAG(pkt1, pkt2, has_eth);
+ COMPARE_INFLAG(pkt1, pkt2, has_eth_bcast);
+ COMPARE_INFLAG(pkt1, pkt2, has_eth_mcast);
+ COMPARE_INFLAG(pkt1, pkt2, has_jumbo);
+ COMPARE_INFLAG(pkt1, pkt2, has_vlan);
+ COMPARE_INFLAG(pkt1, pkt2, has_vlan_qinq);
+ COMPARE_INFLAG(pkt1, pkt2, has_arp);
+ COMPARE_INFLAG(pkt1, pkt2, has_ipv4);
+ COMPARE_INFLAG(pkt1, pkt2, has_ipv6);
+ COMPARE_INFLAG(pkt1, pkt2, has_ip_bcast);
+ COMPARE_INFLAG(pkt1, pkt2, has_ip_mcast);
+ COMPARE_INFLAG(pkt1, pkt2, has_ipfrag);
+ COMPARE_INFLAG(pkt1, pkt2, has_ipopt);
+ COMPARE_INFLAG(pkt1, pkt2, has_ipsec);
+ COMPARE_INFLAG(pkt1, pkt2, has_udp);
+ COMPARE_INFLAG(pkt1, pkt2, has_tcp);
+ COMPARE_INFLAG(pkt1, pkt2, has_sctp);
+ COMPARE_INFLAG(pkt1, pkt2, has_icmp);
+ COMPARE_INFLAG(pkt1, pkt2, user_flag);
+ COMPARE_INFLAG(pkt1, pkt2, has_flow_hash);
+ COMPARE_INFLAG(pkt1, pkt2, has_ts);
COMPARE_INFLAG(pkt1, pkt2, color);
COMPARE_INFLAG(pkt1, pkt2, drop_eligible);
COMPARE_INFLAG(pkt1, pkt2, shaper_len_adjust);
}
-static void _packet_compare_udata(odp_packet_t pkt1, odp_packet_t pkt2)
+static void packet_compare_udata(odp_packet_t pkt1, odp_packet_t pkt2)
{
uint32_t usize1 = odp_packet_user_area_size(pkt1);
uint32_t usize2 = odp_packet_user_area_size(pkt2);
@@ -1545,53 +1625,16 @@ static void packet_test_meta_data_copy(void)
pkt = odp_packet_alloc(pool, packet_len);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_l2(pkt) == 0);
- CU_ASSERT(odp_packet_has_l3(pkt) == 0);
- CU_ASSERT(odp_packet_has_l4(pkt) == 0);
- CU_ASSERT(odp_packet_has_eth(pkt) == 0);
- CU_ASSERT(odp_packet_has_eth_bcast(pkt) == 0);
- CU_ASSERT(odp_packet_has_eth_mcast(pkt) == 0);
- CU_ASSERT(odp_packet_has_jumbo(pkt) == 0);
- CU_ASSERT(odp_packet_has_vlan(pkt) == 0);
- CU_ASSERT(odp_packet_has_vlan_qinq(pkt) == 0);
- CU_ASSERT(odp_packet_has_arp(pkt) == 0);
- CU_ASSERT(odp_packet_has_ipv4(pkt) == 0);
- CU_ASSERT(odp_packet_has_ipv6(pkt) == 0);
- CU_ASSERT(odp_packet_has_ip_bcast(pkt) == 0);
- CU_ASSERT(odp_packet_has_ip_mcast(pkt) == 0);
- CU_ASSERT(odp_packet_has_ipfrag(pkt) == 0);
- CU_ASSERT(odp_packet_has_ipopt(pkt) == 0);
- CU_ASSERT(odp_packet_has_ipsec(pkt) == 0);
- CU_ASSERT(odp_packet_has_udp(pkt) == 0);
- CU_ASSERT(odp_packet_has_tcp(pkt) == 0);
- CU_ASSERT(odp_packet_has_sctp(pkt) == 0);
- CU_ASSERT(odp_packet_has_icmp(pkt) == 0);
+
+ packet_check_inflags(pkt, 0);
+
CU_ASSERT(odp_packet_input(pkt) == ODP_PKTIO_INVALID);
CU_ASSERT(odp_packet_l3_offset(pkt) == ODP_PACKET_OFFSET_INVALID);
CU_ASSERT(odp_packet_l4_offset(pkt) == ODP_PACKET_OFFSET_INVALID);
CU_ASSERT(odp_packet_payload_offset(pkt) == ODP_PACKET_OFFSET_INVALID);
- odp_packet_has_l2_set(pkt, 1);
- odp_packet_has_l3_set(pkt, 1);
- odp_packet_has_l4_set(pkt, 1);
- odp_packet_has_eth_set(pkt, 1);
- odp_packet_has_eth_bcast_set(pkt, 1);
- odp_packet_has_eth_mcast_set(pkt, 1);
- odp_packet_has_jumbo_set(pkt, 1);
- odp_packet_has_vlan_set(pkt, 1);
- odp_packet_has_vlan_qinq_set(pkt, 1);
- odp_packet_has_arp_set(pkt, 1);
- odp_packet_has_ipv4_set(pkt, 1);
- odp_packet_has_ipv6_set(pkt, 1);
- odp_packet_has_ip_bcast_set(pkt, 1);
- odp_packet_has_ip_mcast_set(pkt, 1);
- odp_packet_has_ipfrag_set(pkt, 1);
- odp_packet_has_ipopt_set(pkt, 1);
- odp_packet_has_ipsec_set(pkt, 1);
- odp_packet_has_udp_set(pkt, 1);
- odp_packet_has_tcp_set(pkt, 1);
- odp_packet_has_sctp_set(pkt, 1);
- odp_packet_has_icmp_set(pkt, 1);
+ packet_set_inflags(pkt, 1);
+ packet_check_inflags(pkt, 1);
odp_packet_input_set(pkt, pktio);
odp_packet_user_ptr_set(pkt, (void *)(uintptr_t)0xdeadbeef);
@@ -1609,7 +1652,7 @@ static void packet_test_meta_data_copy(void)
copy = odp_packet_copy(pkt, pool);
CU_ASSERT_FATAL(copy != ODP_PACKET_INVALID);
- _packet_compare_inflags(pkt, copy);
+ packet_compare_inflags(pkt, copy);
CU_ASSERT(odp_packet_input(copy) == pktio);
CU_ASSERT(odp_packet_user_ptr(copy) == (void *)(uintptr_t)0xdeadbeef);
CU_ASSERT(odp_packet_l2_offset(copy) == 20);
@@ -1633,69 +1676,73 @@ static void packet_test_meta_data_copy(void)
static void packet_test_copy(void)
{
odp_packet_t pkt;
- odp_packet_t pkt_copy, pkt_part;
+ odp_packet_t pkt_part;
odp_pool_param_t param;
- odp_pool_t pool, pool_double_uarea, pool_no_uarea;
- uint32_t i, plen, src_offset, dst_offset;
- uint32_t seg_len = 0;
+ odp_pool_t pool, pool_min_uarea, pool_large_uarea;
void *pkt_data;
+ uint32_t i, plen, src_offset, dst_offset, uarea_size;
+ uint32_t seg_len = 0;
memcpy(&param, &default_param, sizeof(odp_pool_param_t));
param.pkt.uarea_size = 0;
- pool_no_uarea = odp_pool_create("no_uarea", &param);
- CU_ASSERT_FATAL(pool_no_uarea != ODP_POOL_INVALID);
+ pool_min_uarea = odp_pool_create("min_uarea", &param);
+ CU_ASSERT_FATAL(pool_min_uarea != ODP_POOL_INVALID);
+
+ uarea_size = 2 * sizeof(struct udata_struct);
+ if (uarea_size > pool_capa.pkt.max_uarea_size)
+ uarea_size = pool_capa.pkt.max_uarea_size;
+
+ param.pkt.uarea_size = uarea_size;
+
+ pool_large_uarea = odp_pool_create("large_uarea", &param);
+ CU_ASSERT_FATAL(pool_large_uarea != ODP_POOL_INVALID);
+
+ /* Pool with minimal user area */
+ pkt = odp_packet_copy(test_packet, pool_min_uarea);
+ if (pkt != ODP_PACKET_INVALID) {
+ /* Pool has enough user area also when zero was requested */
+ CU_ASSERT(odp_packet_user_area_size(pkt) >= sizeof(struct udata_struct));
- param.pkt.uarea_size = 2 * sizeof(struct udata_struct);
- pool_double_uarea = odp_pool_create("double_uarea", &param);
- CU_ASSERT_FATAL(pool_double_uarea != ODP_POOL_INVALID);
+ packet_compare_inflags(pkt, test_packet);
+ packet_compare_udata(pkt, test_packet);
+ packet_compare_data(pkt, test_packet);
- pkt = odp_packet_copy(test_packet, pool_no_uarea);
- CU_ASSERT(pkt == ODP_PACKET_INVALID);
- if (pkt != ODP_PACKET_INVALID)
odp_packet_free(pkt);
+ }
+ /* The same pool */
pkt = odp_packet_copy(test_packet, odp_packet_pool(test_packet));
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(pkt != test_packet);
+ CU_ASSERT(odp_packet_pool(pkt) == odp_packet_pool(test_packet));
+ CU_ASSERT(odp_packet_user_area(pkt) != odp_packet_user_area(test_packet));
+ CU_ASSERT(odp_packet_user_area_size(pkt) == odp_packet_user_area_size(test_packet));
+ CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(test_packet));
+ CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(test_packet));
+
+ packet_compare_inflags(pkt, test_packet);
+ packet_compare_udata(pkt, test_packet);
packet_compare_data(pkt, test_packet);
- pool = odp_packet_pool(pkt);
- CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- pkt_copy = odp_packet_copy(pkt, pool);
- CU_ASSERT_FATAL(pkt_copy != ODP_PACKET_INVALID);
-
- CU_ASSERT(pkt != pkt_copy);
- CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(pkt_copy));
- CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(pkt_copy));
-
- _packet_compare_inflags(pkt, pkt_copy);
- packet_compare_data(pkt, pkt_copy);
- CU_ASSERT(odp_packet_user_area_size(pkt) ==
- odp_packet_user_area_size(test_packet));
- _packet_compare_udata(pkt, pkt_copy);
- odp_packet_free(pkt_copy);
+
odp_packet_free(pkt);
- pkt = odp_packet_copy(test_packet, pool_double_uarea);
+ /* Pool with larger user area */
+ pkt = odp_packet_copy(test_packet, pool_large_uarea);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(pkt != test_packet);
+ CU_ASSERT(odp_packet_pool(pkt) == pool_large_uarea);
+ CU_ASSERT(odp_packet_user_area(pkt) != odp_packet_user_area(test_packet));
+ CU_ASSERT(odp_packet_user_area_size(pkt) >= uarea_size);
+ CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(test_packet));
+ CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(test_packet));
+
+ packet_compare_inflags(pkt, test_packet);
+ packet_compare_udata(pkt, test_packet);
packet_compare_data(pkt, test_packet);
- pool = odp_packet_pool(pkt);
- CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- pkt_copy = odp_packet_copy(pkt, pool);
- CU_ASSERT_FATAL(pkt_copy != ODP_PACKET_INVALID);
-
- CU_ASSERT(pkt != pkt_copy);
- CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(pkt_copy));
- CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(pkt_copy));
-
- _packet_compare_inflags(pkt, pkt_copy);
- packet_compare_data(pkt, pkt_copy);
- CU_ASSERT(odp_packet_user_area_size(pkt) ==
- 2 * odp_packet_user_area_size(test_packet));
- _packet_compare_udata(pkt, pkt_copy);
- _packet_compare_udata(pkt, test_packet);
- odp_packet_free(pkt_copy);
/* Now test copy_part */
+ pool = pool_large_uarea;
pkt_part = odp_packet_copy_part(pkt, 0, odp_packet_len(pkt) + 1, pool);
CU_ASSERT(pkt_part == ODP_PACKET_INVALID);
pkt_part = odp_packet_copy_part(pkt, odp_packet_len(pkt), 1, pool);
@@ -1743,8 +1790,8 @@ static void packet_test_copy(void)
odp_packet_free(pkt_part);
odp_packet_free(pkt);
- CU_ASSERT(odp_pool_destroy(pool_no_uarea) == 0);
- CU_ASSERT(odp_pool_destroy(pool_double_uarea) == 0);
+ CU_ASSERT(odp_pool_destroy(pool_min_uarea) == 0);
+ CU_ASSERT(odp_pool_destroy(pool_large_uarea) == 0);
}
static void packet_test_copydata(void)
@@ -3049,6 +3096,19 @@ static void packet_vector_test_alloc_free(void)
CU_ASSERT(odp_packet_vector_to_u64(pktv) !=
odp_packet_vector_to_u64(ODP_PACKET_VECTOR_INVALID));
+ /* User flag should be initially zero */
+ CU_ASSERT(odp_packet_vector_user_flag(pktv) == 0);
+ odp_packet_vector_user_flag_set(pktv, 1);
+ CU_ASSERT(odp_packet_vector_user_flag(pktv) != 0);
+ odp_packet_vector_user_flag_set(pktv, 0);
+ CU_ASSERT(odp_packet_vector_user_flag(pktv) == 0);
+
+ /* Free with flag still set, alloc should clear it. */
+ odp_packet_vector_user_flag_set(pktv, 1);
+ odp_packet_vector_free(pktv);
+ pktv = odp_packet_vector_alloc(pool);
+ CU_ASSERT(odp_packet_vector_user_flag(pktv) == 0);
+
/* Since it was only one buffer pool, more vector packets can't be
* allocated.
*/
@@ -3111,6 +3171,60 @@ static void packet_vector_basic_test(void)
CU_ASSERT(odp_packet_vector_valid(pktv_default) == 1);
}
+static void packet_vector_test_user_area(void)
+{
+ odp_pool_param_t param;
+ odp_pool_t pool;
+ uint32_t i;
+ void *addr;
+ uint32_t num = 10;
+ void *prev = NULL;
+ uint32_t num_alloc = 0;
+ uint32_t size = 1024;
+ const uint32_t max_size = pool_capa.vector.max_uarea_size;
+
+ if (max_size == 0) {
+ ODPH_DBG("Packet vector user area not supported\n");
+ return;
+ }
+
+ if (size > max_size)
+ size = max_size;
+
+ odp_pool_param_init(&param);
+ param.type = ODP_POOL_VECTOR;
+ param.vector.num = num;
+ param.vector.max_size = pool_capa.vector.max_size;
+ param.vector.uarea_size = size;
+
+ odp_packet_vector_t pktv[num];
+
+ pool = odp_pool_create("test_user_area", &param);
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ for (i = 0; i < num; i++) {
+ pktv[i] = odp_packet_vector_alloc(pool);
+
+ if (pktv[i] == ODP_PACKET_VECTOR_INVALID)
+ break;
+ num_alloc++;
+
+ addr = odp_packet_vector_user_area(pktv[i]);
+ CU_ASSERT_FATAL(addr != NULL);
+ CU_ASSERT(prev != addr);
+
+ prev = addr;
+ memset(addr, 0, size);
+ }
+
+ CU_ASSERT(i == num);
+
+ for (i = 0; i < num_alloc; i++)
+ odp_packet_vector_free(pktv[i]);
+
+ CU_ASSERT_FATAL(odp_pool_destroy(pool) == 0);
+}
+
static int packet_vector_suite_init(void)
{
uint32_t num_pkt = PKT_VEC_PACKET_NUM;
@@ -3278,27 +3392,33 @@ 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);
- CU_ASSERT(odp_packet_user_area(pkt) == NULL);
- CU_ASSERT(odp_packet_user_area_size(pkt) == 0);
+ CU_ASSERT(odp_packet_user_area_size(pkt) <= pool_capa.pkt.max_uarea_size);
+ if (odp_packet_user_area_size(pkt)) {
+ /* CU_ASSERT needs these extra bracets */
+ CU_ASSERT(odp_packet_user_area(pkt) != NULL);
+ } else {
+ CU_ASSERT(odp_packet_user_area(pkt) == NULL);
+ }
+
odp_packet_free(pkt);
CU_ASSERT(odp_pool_destroy(pool) == 0);
+ if (pool_capa.pkt.max_uarea_size == 0)
+ return;
+
param.pkt.uarea_size = 1;
pool = odp_pool_create("one_uarea", &param);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
pkt = odp_packet_alloc(pool, param.pkt.len);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
CU_ASSERT_FATAL(odp_packet_user_area(pkt) != NULL);
- CU_ASSERT(odp_packet_user_area_size(pkt) == 1);
+ 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);
odp_packet_free(pkt);
CU_ASSERT(odp_pool_destroy(pool) == 0);
- if (pool_capa.pkt.max_uarea_size)
- param.pkt.uarea_size = pool_capa.pkt.max_uarea_size;
- else
- param.pkt.uarea_size = 512;
+ param.pkt.uarea_size = pool_capa.pkt.max_uarea_size;
pool = odp_pool_create("max_uarea", &param);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
pkt = odp_packet_alloc(pool, param.pkt.len);
@@ -4309,6 +4429,7 @@ odp_testinfo_t packet_vector_parse_suite[] = {
ODP_TEST_INFO(packet_vector_basic_test),
ODP_TEST_INFO(packet_vector_test_alloc_free),
ODP_TEST_INFO(packet_vector_test_tbl),
+ ODP_TEST_INFO(packet_vector_test_user_area),
ODP_TEST_INFO(packet_vector_test_event_conversion),
ODP_TEST_INFO_NULL,
};
diff --git a/test/validation/api/pktio/pktio.c b/test/validation/api/pktio/pktio.c
index 84fad32b6..2eb1a5a28 100644
--- a/test/validation/api/pktio/pktio.c
+++ b/test/validation/api/pktio/pktio.c
@@ -695,6 +695,7 @@ static int get_packets(pktio_info_t *pktio_rx, odp_packet_t pkt_tbl[],
pktv = odp_packet_vector_from_event(evt_tbl[i]);
pktv_len = odp_packet_vector_tbl(pktv, &pkts);
+ CU_ASSERT(odp_packet_vector_user_flag(pktv) == 0);
/* Make sure too many packets are not received */
if (num_pkts + pktv_len > num) {
@@ -996,6 +997,7 @@ static void pktio_txrx_multi(pktio_info_t *pktio_info_a,
CU_ASSERT(odp_packet_has_udp(pkt));
}
+ CU_ASSERT(odp_packet_user_flag(pkt) == 0);
CU_ASSERT(odp_packet_user_ptr(pkt) == NULL);
CU_ASSERT(odp_packet_cls_mark(pkt) == 0);
diff --git a/test/validation/api/pool/pool.c b/test/validation/api/pool/pool.c
index c5f57d17f..e8bf38c9d 100644
--- a/test/validation/api/pool/pool.c
+++ b/test/validation/api/pool/pool.c
@@ -51,17 +51,21 @@ static void test_param_init(uint8_t fill)
memset(&param, fill, sizeof(param));
odp_pool_param_init(&param);
+ 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);
CU_ASSERT(param.pkt.max_num == 0);
CU_ASSERT(param.pkt.num_subparam == 0);
+ CU_ASSERT(param.pkt.uarea_size == 0);
CU_ASSERT(param.pkt.cache_size >= global_pool_capa.pkt.min_cache_size &&
param.pkt.cache_size <= global_pool_capa.pkt.max_cache_size);
+ CU_ASSERT(param.tmo.uarea_size == 0);
CU_ASSERT(param.tmo.cache_size >= global_pool_capa.tmo.min_cache_size &&
param.tmo.cache_size <= global_pool_capa.tmo.max_cache_size);
+ CU_ASSERT(param.vector.uarea_size == 0);
CU_ASSERT(param.vector.cache_size >= global_pool_capa.vector.min_cache_size &&
param.vector.cache_size <= global_pool_capa.vector.max_cache_size);
}
@@ -915,7 +919,7 @@ static void pool_test_create_after_fork(void)
odp_atomic_init_u32(&global_mem->index, 0);
/* Fork here */
- odp_cunit_thread_create(num, run_pool_test_create_after_fork, NULL, 0);
+ odp_cunit_thread_create(num, run_pool_test_create_after_fork, NULL, 0, 0);
/* Wait until thread 0 has created the test pool */
odp_barrier_wait(&global_mem->init_barrier);
@@ -1027,7 +1031,7 @@ static void pool_test_create_max_pkt_pools(void)
CU_ASSERT(num_shm == shm_capa.max_blocks);
/* Create maximum number of packet pools */
- if (global_pool_capa.pkt.max_uarea_size && global_pool_capa.pkt.max_uarea_size < uarea_size)
+ if (uarea_size > global_pool_capa.pkt.max_uarea_size)
uarea_size = global_pool_capa.pkt.max_uarea_size;
odp_pool_param_init(&param);
@@ -1656,6 +1660,8 @@ static void packet_pool_ext_alloc(int len_test)
if (pkt[i] == ODP_PACKET_INVALID)
break;
+ CU_ASSERT(odp_packet_is_valid(pkt[i]) == 1);
+ CU_ASSERT(odp_event_is_valid(odp_packet_to_event(pkt[i])) == 1);
CU_ASSERT(odp_packet_len(pkt[i]) == pkt_len);
CU_ASSERT(odp_packet_headroom(pkt[i]) >= headroom);
buf_index = find_buf(pkt[i], buf, num_buf, head_offset);
@@ -1683,7 +1689,7 @@ static void packet_pool_ext_alloc(int len_test)
if (uarea_size) {
CU_ASSERT(odp_packet_user_area(pkt[i]) != NULL);
- CU_ASSERT(odp_packet_user_area_size(pkt[i]) == uarea_size);
+ CU_ASSERT(odp_packet_user_area_size(pkt[i]) >= uarea_size);
}
/* Check that application header content has not changed */
diff --git a/test/validation/api/queue/queue.c b/test/validation/api/queue/queue.c
index 8f1278f61..f661da075 100644
--- a/test/validation/api/queue/queue.c
+++ b/test/validation/api/queue/queue.c
@@ -547,7 +547,7 @@ static void test_pair(odp_nonblocking_t nonblocking,
/* Create one worker thread */
arg = globals;
- odp_cunit_thread_create(1, queue_pair_work_loop, &arg, 0);
+ odp_cunit_thread_create(1, queue_pair_work_loop, &arg, 0, 0);
/* Run this thread as the second thread */
CU_ASSERT(queue_pair_work_loop(globals) == 0);
@@ -1018,7 +1018,7 @@ static void multithread_test(odp_nonblocking_t nonblocking)
CU_ASSERT(alloc_and_enqueue(queue, pool, num) == num);
arg = globals;
- odp_cunit_thread_create(num_workers, queue_test_worker, &arg, 0);
+ odp_cunit_thread_create(num_workers, queue_test_worker, &arg, 0, 0);
/* Wait for worker threads to terminate */
odp_cunit_thread_join(num_workers);
diff --git a/test/validation/api/scheduler/scheduler.c b/test/validation/api/scheduler/scheduler.c
index 878e99e07..cd9ad1ac1 100644
--- a/test/validation/api/scheduler/scheduler.c
+++ b/test/validation/api/scheduler/scheduler.c
@@ -1422,7 +1422,7 @@ static void chaos_run(unsigned int qtype)
num_thr = globals->num_workers - 1;
arg_ptr = args;
if (num_thr > 0)
- odp_cunit_thread_create(num_thr, chaos_thread, &arg_ptr, 0);
+ odp_cunit_thread_create(num_thr, chaos_thread, &arg_ptr, 0, 0);
chaos_thread(args);
@@ -1865,7 +1865,7 @@ static void parallel_execute(odp_schedule_sync_t sync, int num_queues,
num = globals->num_workers - 1;
arg_ptr = args;
if (num > 0)
- odp_cunit_thread_create(num, schedule_common_, &arg_ptr, 0);
+ odp_cunit_thread_create(num, schedule_common_, &arg_ptr, 0, 0);
schedule_common_(args);
@@ -2426,7 +2426,7 @@ static void scheduler_test_order_wait_2_threads(void)
odp_atomic_init_u32(&globals->order_wait.helper_ready, 0);
odp_atomic_init_u32(&globals->order_wait.helper_active, 0);
- ret = odp_cunit_thread_create(num, order_wait_helper, NULL, 0);
+ ret = odp_cunit_thread_create(num, order_wait_helper, NULL, 0, 0);
CU_ASSERT_FATAL(ret == num);
/* Send an event to the helper thread */
@@ -2677,7 +2677,7 @@ static void scheduler_test_sched_and_plain(odp_schedule_sync_t sync)
num = globals->num_workers - 1;
arg_ptr = args;
if (num > 0)
- odp_cunit_thread_create(num, sched_and_plain_thread, &arg_ptr, 0);
+ odp_cunit_thread_create(num, sched_and_plain_thread, &arg_ptr, 0, 0);
sched_and_plain_thread(args);
@@ -2980,7 +2980,7 @@ static void scheduler_fifo_mt(odp_schedule_sync_t sync, int multi)
arg[i] = i;
if (num_thr > 1)
- odp_cunit_thread_create(num_thr - 1, scheduler_fifo_test, (void **)&arg[1], 1);
+ odp_cunit_thread_create(num_thr - 1, scheduler_fifo_test, (void **)&arg[1], 1, 0);
/* Main thread runs as thread 0 */
scheduler_fifo_test(0);
@@ -3126,7 +3126,7 @@ static void scheduler_test_atomicity(void)
num = globals->num_workers - 1;
arg_ptr = args;
if (num > 0)
- odp_cunit_thread_create(num, atomicity_test_run, &arg_ptr, 0);
+ odp_cunit_thread_create(num, atomicity_test_run, &arg_ptr, 0, 0);
atomicity_test_run(args);
diff --git a/test/validation/api/shmem/shmem.c b/test/validation/api/shmem/shmem.c
index f68021310..a10e7d1d9 100644
--- a/test/validation/api/shmem/shmem.c
+++ b/test/validation/api/shmem/shmem.c
@@ -207,7 +207,7 @@ static void shmem_test_multi_thread(void)
num = MAX_WORKERS;
odp_barrier_init(&shared_test_data->test_barrier1, num);
- odp_cunit_thread_create(num, run_test_basic_thread, NULL, 0);
+ odp_cunit_thread_create(num, run_test_basic_thread, NULL, 0, 0);
CU_ASSERT(odp_cunit_thread_join(num) >= 0);
odp_shm_print(shm);
@@ -561,7 +561,7 @@ static void shmem_test_reserve_after_fork(void)
odp_barrier_init(&glob_data->test_barrier2, num + 1);
odp_atomic_store_u32(&glob_data->index, 0);
- odp_cunit_thread_create(num, run_test_reserve_after_fork, NULL, 0);
+ odp_cunit_thread_create(num, run_test_reserve_after_fork, NULL, 0, 0);
/* wait until all threads have made their shm_reserve: */
odp_barrier_wait(&glob_data->test_barrier1);
@@ -756,7 +756,7 @@ static void shmem_test_singleva_after_fork(void)
odp_barrier_init(&glob_data->test_barrier4, num + 1);
odp_atomic_store_u32(&glob_data->index, 0);
- odp_cunit_thread_create(num, run_test_singleva_after_fork, NULL, 0);
+ odp_cunit_thread_create(num, run_test_singleva_after_fork, NULL, 0, 0);
/* wait until all threads have made their shm_reserve: */
odp_barrier_wait(&glob_data->test_barrier1);
@@ -994,7 +994,7 @@ static void shmem_test_stress(void)
glob_data->stress[i].state = STRESS_FREE;
/* create threads */
- odp_cunit_thread_create(num, run_test_stress, NULL, 0);
+ odp_cunit_thread_create(num, run_test_stress, NULL, 0, 0);
/* wait for all thread endings: */
CU_ASSERT(odp_cunit_thread_join(num) >= 0);
diff --git a/test/validation/api/stash/stash.c b/test/validation/api/stash/stash.c
index f1de7ec00..f4ddfa2e1 100644
--- a/test/validation/api/stash/stash.c
+++ b/test/validation/api/stash/stash.c
@@ -24,6 +24,7 @@
#define CACHE_SIZE 8
#define BURST 32
+#define BATCH 16
#define MAX_RETRY 1024
#define RETRY_MSEC 100
@@ -118,6 +119,8 @@ static void stash_capability(void)
CU_ASSERT(capa.max_stashes > 0);
CU_ASSERT(capa.max_num_obj > 0);
CU_ASSERT(capa.max_obj_size >= sizeof(uint32_t));
+ CU_ASSERT(capa.max_get_batch >= 1);
+ CU_ASSERT(capa.max_put_batch >= 1);
memset(&capa, 0, sizeof(odp_stash_capability_t));
ret = odp_stash_capability(&capa, ODP_STASH_TYPE_FIFO);
@@ -126,6 +129,8 @@ static void stash_capability(void)
if (ret == 0 && capa.max_stashes) {
CU_ASSERT(capa.max_num_obj > 0);
CU_ASSERT(capa.max_obj_size >= sizeof(uint32_t));
+ CU_ASSERT(capa.max_get_batch >= 1);
+ CU_ASSERT(capa.max_put_batch >= 1);
}
}
@@ -444,13 +449,24 @@ static void stash_stats_u32(void)
CU_ASSERT_FATAL(odp_stash_destroy(stash) == 0);
}
-static void stash_default_put(uint32_t size, int32_t burst, stash_op_t op)
+static void stash_default_put(uint32_t size, int32_t burst, stash_op_t op, int batch)
{
odp_stash_t stash;
odp_stash_param_t param;
int32_t i, ret, retry, num_left;
- int32_t num;
+ int32_t num, max_burst;
void *input, *output;
+
+ if (batch) {
+ CU_ASSERT_FATAL(global.capa_default.max_get_batch >= 1);
+ CU_ASSERT_FATAL(global.capa_default.max_put_batch >= 1);
+
+ if (burst > (int32_t)global.capa_default.max_get_batch)
+ burst = global.capa_default.max_get_batch;
+ if (burst > (int32_t)global.capa_default.max_put_batch)
+ burst = global.capa_default.max_put_batch;
+ }
+
uint64_t input_u64[burst];
uint64_t output_u64[burst + 2];
uint32_t input_u32[burst];
@@ -499,19 +515,38 @@ static void stash_default_put(uint32_t size, int32_t burst, stash_op_t op)
retry = MAX_RETRY;
num_left = num;
- while (num_left) {
- if (op == STASH_GEN)
- ret = odp_stash_put(stash, input, burst);
- else if (op == STASH_U32)
- ret = odp_stash_put_u32(stash, input_u32, burst);
- else if (op == STASH_U64)
- ret = odp_stash_put_u64(stash, input_u64, burst);
- else if (op == STASH_PTR)
- ret = odp_stash_put_ptr(stash, input, burst);
- else
+ max_burst = burst;
+ while (num_left > 0) {
+ if (op == STASH_GEN) {
+ if (batch)
+ ret = odp_stash_put_batch(stash, input, burst);
+ else
+ ret = odp_stash_put(stash, input, burst);
+ } else if (op == STASH_U32) {
+ if (batch)
+ ret = odp_stash_put_u32_batch(stash, input_u32, burst);
+ else
+ ret = odp_stash_put_u32(stash, input_u32, burst);
+ } else if (op == STASH_U64) {
+ if (batch)
+ ret = odp_stash_put_u64_batch(stash, input_u64, burst);
+ else
+ ret = odp_stash_put_u64(stash, input_u64, burst);
+ } else if (op == STASH_PTR) {
+ if (batch)
+ ret = odp_stash_put_ptr_batch(stash, input, burst);
+ else
+ ret = odp_stash_put_ptr(stash, input, burst);
+ } else {
ret = -1;
+ }
CU_ASSERT_FATAL(ret >= 0);
CU_ASSERT_FATAL(ret <= burst);
+ if (batch) {
+ CU_ASSERT(ret == 0 || ret == burst);
+ if (num_left - ret < burst)
+ burst = num_left - ret;
+ }
if (ret) {
num_left -= ret;
@@ -522,9 +557,10 @@ static void stash_default_put(uint32_t size, int32_t burst, stash_op_t op)
}
}
+ burst = max_burst;
retry = MAX_RETRY;
num_left = num;
- while (num_left) {
+ while (num_left > 0) {
memset(output, 0, burst * size);
/* Init first and last array element for under-/overflow checking */
@@ -541,16 +577,29 @@ static void stash_default_put(uint32_t size, int32_t burst, stash_op_t op)
output_u8[0] = MAGIC_U8;
output_u8[burst + 1] = MAGIC_U8;
}
- if (op == STASH_GEN)
- ret = odp_stash_get(stash, output, burst);
- else if (op == STASH_U32)
- ret = odp_stash_get_u32(stash, &output_u32[1], burst);
- else if (op == STASH_U64)
- ret = odp_stash_get_u64(stash, &output_u64[1], burst);
- else if (op == STASH_PTR)
- ret = odp_stash_get_ptr(stash, output, burst);
- else
+ if (op == STASH_GEN) {
+ if (batch)
+ ret = odp_stash_get_batch(stash, output, burst);
+ else
+ ret = odp_stash_get(stash, output, burst);
+ } else if (op == STASH_U32) {
+ if (batch)
+ ret = odp_stash_get_u32_batch(stash, &output_u32[1], burst);
+ else
+ ret = odp_stash_get_u32(stash, &output_u32[1], burst);
+ } else if (op == STASH_U64) {
+ if (batch)
+ ret = odp_stash_get_u64_batch(stash, &output_u64[1], burst);
+ else
+ ret = odp_stash_get_u64(stash, &output_u64[1], burst);
+ } else if (op == STASH_PTR) {
+ if (batch)
+ ret = odp_stash_get_ptr_batch(stash, output, burst);
+ else
+ ret = odp_stash_get_ptr(stash, output, burst);
+ } else {
ret = -1;
+ }
CU_ASSERT_FATAL(ret >= 0);
CU_ASSERT_FATAL(ret <= burst);
@@ -568,6 +617,12 @@ static void stash_default_put(uint32_t size, int32_t burst, stash_op_t op)
CU_ASSERT_FATAL(output_u8[burst + 1] == MAGIC_U8);
}
+ if (batch) {
+ CU_ASSERT(ret == 0 || ret == burst);
+ if (num_left - ret < burst)
+ burst = num_left - ret;
+ }
+
if (ret) {
for (i = 0; i < ret; i++) {
if (size == sizeof(uint64_t)) {
@@ -597,13 +652,24 @@ static void stash_default_put(uint32_t size, int32_t burst, stash_op_t op)
CU_ASSERT_FATAL(odp_stash_destroy(stash) == 0);
}
-static void stash_fifo_put(uint32_t size, int32_t burst, stash_op_t op)
+static void stash_fifo_put(uint32_t size, int32_t burst, stash_op_t op, int batch)
{
odp_stash_t stash;
odp_stash_param_t param;
int32_t i, ret, retry, num_left;
- int32_t num;
+ int32_t num, max_burst;
void *input, *output;
+
+ if (batch) {
+ CU_ASSERT_FATAL(global.capa_fifo.max_get_batch >= 1);
+ CU_ASSERT_FATAL(global.capa_fifo.max_put_batch >= 1);
+
+ if (burst > (int32_t)global.capa_fifo.max_get_batch)
+ burst = global.capa_fifo.max_get_batch;
+ if (burst > (int32_t)global.capa_fifo.max_put_batch)
+ burst = global.capa_fifo.max_put_batch;
+ }
+
uint64_t input_u64[burst];
uint64_t output_u64[burst + 2];
uint32_t input_u32[burst];
@@ -645,7 +711,8 @@ static void stash_fifo_put(uint32_t size, int32_t burst, stash_op_t op)
retry = MAX_RETRY;
num_left = num;
- while (num_left) {
+ max_burst = burst;
+ while (num_left > 0) {
for (i = 0; i < burst; i++) {
if (size == sizeof(uint64_t))
input_u64[i] = VAL_U64 + num_left - i;
@@ -656,20 +723,40 @@ static void stash_fifo_put(uint32_t size, int32_t burst, stash_op_t op)
else
input_u8[i] = VAL_U8 + num_left - i;
}
- if (op == STASH_GEN)
- ret = odp_stash_put(stash, input, burst);
- else if (op == STASH_U32)
- ret = odp_stash_put_u32(stash, input_u32, burst);
- else if (op == STASH_U64)
- ret = odp_stash_put_u64(stash, input_u64, burst);
- else if (op == STASH_PTR)
- ret = odp_stash_put_ptr(stash, input, burst);
- else
+ if (op == STASH_GEN) {
+ if (batch)
+ ret = odp_stash_put_batch(stash, input, burst);
+ else
+ ret = odp_stash_put(stash, input, burst);
+ } else if (op == STASH_U32) {
+ if (batch)
+ ret = odp_stash_put_u32_batch(stash, input_u32, burst);
+ else
+ ret = odp_stash_put_u32(stash, input_u32, burst);
+ } else if (op == STASH_U64) {
+ if (batch)
+ ret = odp_stash_put_u64_batch(stash, input_u64, burst);
+ else
+ ret = odp_stash_put_u64(stash, input_u64, burst);
+
+ } else if (op == STASH_PTR) {
+ if (batch)
+ ret = odp_stash_put_ptr_batch(stash, input, burst);
+ else
+ ret = odp_stash_put_ptr(stash, input, burst);
+ } else {
ret = -1;
+ }
CU_ASSERT_FATAL(ret >= 0);
+ CU_ASSERT_FATAL(ret <= burst);
+
+ if (batch) {
+ CU_ASSERT(ret == 0 || ret == burst);
+ if (num_left - ret < burst)
+ burst = num_left - ret;
+ }
if (ret) {
- CU_ASSERT_FATAL(ret <= burst);
num_left -= ret;
retry = MAX_RETRY;
} else {
@@ -678,9 +765,10 @@ static void stash_fifo_put(uint32_t size, int32_t burst, stash_op_t op)
}
}
+ burst = max_burst;
retry = MAX_RETRY;
num_left = num;
- while (num_left) {
+ while (num_left > 0) {
memset(output, 0, burst * size);
/* Init first and last array element for under-/overflow checking */
@@ -698,17 +786,31 @@ static void stash_fifo_put(uint32_t size, int32_t burst, stash_op_t op)
output_u8[burst + 1] = MAGIC_U8;
}
- if (op == STASH_GEN)
- ret = odp_stash_get(stash, output, burst);
- else if (op == STASH_U32)
- ret = odp_stash_get_u32(stash, &output_u32[1], burst);
- else if (op == STASH_U64)
- ret = odp_stash_get_u64(stash, &output_u64[1], burst);
- else if (op == STASH_PTR)
- ret = odp_stash_get_ptr(stash, output, burst);
- else
+ if (op == STASH_GEN) {
+ if (batch)
+ ret = odp_stash_get_batch(stash, output, burst);
+ else
+ ret = odp_stash_get(stash, output, burst);
+ } else if (op == STASH_U32) {
+ if (batch)
+ ret = odp_stash_get_u32_batch(stash, &output_u32[1], burst);
+ else
+ ret = odp_stash_get_u32(stash, &output_u32[1], burst);
+ } else if (op == STASH_U64) {
+ if (batch)
+ ret = odp_stash_get_u64_batch(stash, &output_u64[1], burst);
+ else
+ ret = odp_stash_get_u64(stash, &output_u64[1], burst);
+ } else if (op == STASH_PTR) {
+ if (batch)
+ ret = odp_stash_get_ptr_batch(stash, output, burst);
+ else
+ ret = odp_stash_get_ptr(stash, output, burst);
+ } else {
ret = -1;
+ }
CU_ASSERT_FATAL(ret >= 0);
+ CU_ASSERT_FATAL(ret <= burst);
if (size == sizeof(uint64_t)) {
CU_ASSERT_FATAL(output_u64[0] == MAGIC_U64);
@@ -724,8 +826,13 @@ static void stash_fifo_put(uint32_t size, int32_t burst, stash_op_t op)
CU_ASSERT_FATAL(output_u8[burst + 1] == MAGIC_U8);
}
+ if (batch) {
+ CU_ASSERT(ret == 0 || ret == burst);
+ if (num_left - ret < burst)
+ burst = num_left - ret;
+ }
+
if (ret) {
- CU_ASSERT_FATAL(ret <= burst);
for (i = 0; i < ret; i++) {
if (size == sizeof(uint64_t)) {
uint64_t val = VAL_U64 + num_left - i;
@@ -805,142 +912,282 @@ static int check_support_fifo(void)
static void stash_default_put_u64_1(void)
{
- stash_default_put(sizeof(uint64_t), 1, STASH_GEN);
+ stash_default_put(sizeof(uint64_t), 1, STASH_GEN, 0);
}
static void stash_default_put_u64_n(void)
{
- stash_default_put(sizeof(uint64_t), BURST, STASH_GEN);
+ stash_default_put(sizeof(uint64_t), BURST, STASH_GEN, 0);
}
static void stash_default_u64_put_u64_1(void)
{
- stash_default_put(sizeof(uint64_t), 1, STASH_U64);
+ stash_default_put(sizeof(uint64_t), 1, STASH_U64, 0);
}
static void stash_default_u64_put_u64_n(void)
{
- stash_default_put(sizeof(uint64_t), BURST, STASH_U64);
+ stash_default_put(sizeof(uint64_t), BURST, STASH_U64, 0);
}
static void stash_default_put_ptr_1(void)
{
- stash_default_put(sizeof(uintptr_t), 1, STASH_PTR);
+ stash_default_put(sizeof(uintptr_t), 1, STASH_PTR, 0);
}
static void stash_default_put_ptr_n(void)
{
- stash_default_put(sizeof(uintptr_t), BURST, STASH_PTR);
+ stash_default_put(sizeof(uintptr_t), BURST, STASH_PTR, 0);
+}
+
+static void stash_default_put_u64_1_batch(void)
+{
+ stash_default_put(sizeof(uint64_t), 1, STASH_GEN, 1);
+}
+
+static void stash_default_put_u64_n_batch(void)
+{
+ stash_default_put(sizeof(uint64_t), BATCH, STASH_GEN, 1);
+}
+
+static void stash_default_u64_put_u64_1_batch(void)
+{
+ stash_default_put(sizeof(uint64_t), 1, STASH_U64, 1);
+}
+
+static void stash_default_u64_put_u64_n_batch(void)
+{
+ stash_default_put(sizeof(uint64_t), BATCH, STASH_U64, 1);
+}
+
+static void stash_default_put_ptr_1_batch(void)
+{
+ stash_default_put(sizeof(uintptr_t), 1, STASH_PTR, 1);
+}
+
+static void stash_default_put_ptr_n_batch(void)
+{
+ stash_default_put(sizeof(uintptr_t), BATCH, STASH_PTR, 1);
}
static void stash_default_put_u32_1(void)
{
- stash_default_put(sizeof(uint32_t), 1, STASH_GEN);
+ stash_default_put(sizeof(uint32_t), 1, STASH_GEN, 0);
}
static void stash_default_put_u32_n(void)
{
- stash_default_put(sizeof(uint32_t), BURST, STASH_GEN);
+ stash_default_put(sizeof(uint32_t), BURST, STASH_GEN, 0);
}
static void stash_default_u32_put_u32_1(void)
{
- stash_default_put(sizeof(uint32_t), 1, STASH_U32);
+ stash_default_put(sizeof(uint32_t), 1, STASH_U32, 0);
}
static void stash_default_u32_put_u32_n(void)
{
- stash_default_put(sizeof(uint32_t), BURST, STASH_U32);
+ stash_default_put(sizeof(uint32_t), BURST, STASH_U32, 0);
}
static void stash_default_put_u16_1(void)
{
- stash_default_put(sizeof(uint16_t), 1, STASH_GEN);
+ stash_default_put(sizeof(uint16_t), 1, STASH_GEN, 0);
}
static void stash_default_put_u16_n(void)
{
- stash_default_put(sizeof(uint16_t), BURST, STASH_GEN);
+ stash_default_put(sizeof(uint16_t), BURST, STASH_GEN, 0);
}
static void stash_default_put_u8_1(void)
{
- stash_default_put(sizeof(uint8_t), 1, STASH_GEN);
+ stash_default_put(sizeof(uint8_t), 1, STASH_GEN, 0);
}
static void stash_default_put_u8_n(void)
{
- stash_default_put(sizeof(uint8_t), BURST, STASH_GEN);
+ stash_default_put(sizeof(uint8_t), BURST, STASH_GEN, 0);
+}
+
+static void stash_default_put_u32_1_batch(void)
+{
+ stash_default_put(sizeof(uint32_t), 1, STASH_GEN, 1);
+}
+
+static void stash_default_put_u32_n_batch(void)
+{
+ stash_default_put(sizeof(uint32_t), BATCH, STASH_GEN, 1);
+}
+
+static void stash_default_u32_put_u32_1_batch(void)
+{
+ stash_default_put(sizeof(uint32_t), 1, STASH_U32, 1);
+}
+
+static void stash_default_u32_put_u32_n_batch(void)
+{
+ stash_default_put(sizeof(uint32_t), BATCH, STASH_U32, 1);
+}
+
+static void stash_default_put_u16_1_batch(void)
+{
+ stash_default_put(sizeof(uint16_t), 1, STASH_GEN, 1);
+}
+
+static void stash_default_put_u16_n_batch(void)
+{
+ stash_default_put(sizeof(uint16_t), BATCH, STASH_GEN, 1);
+}
+
+static void stash_default_put_u8_1_batch(void)
+{
+ stash_default_put(sizeof(uint8_t), 1, STASH_GEN, 1);
+}
+
+static void stash_default_put_u8_n_batch(void)
+{
+ stash_default_put(sizeof(uint8_t), BATCH, STASH_GEN, 1);
}
static void stash_fifo_put_u64_1(void)
{
- stash_fifo_put(sizeof(uint64_t), 1, STASH_GEN);
+ stash_fifo_put(sizeof(uint64_t), 1, STASH_GEN, 0);
}
static void stash_fifo_put_u64_n(void)
{
- stash_fifo_put(sizeof(uint64_t), BURST, STASH_GEN);
+ stash_fifo_put(sizeof(uint64_t), BURST, STASH_GEN, 0);
}
static void stash_fifo_u64_put_u64_1(void)
{
- stash_fifo_put(sizeof(uint64_t), 1, STASH_U64);
+ stash_fifo_put(sizeof(uint64_t), 1, STASH_U64, 0);
}
static void stash_fifo_u64_put_u64_n(void)
{
- stash_fifo_put(sizeof(uint64_t), BURST, STASH_U64);
+ stash_fifo_put(sizeof(uint64_t), BURST, STASH_U64, 0);
}
static void stash_fifo_put_ptr_1(void)
{
- stash_fifo_put(sizeof(uintptr_t), 1, STASH_PTR);
+ stash_fifo_put(sizeof(uintptr_t), 1, STASH_PTR, 0);
}
static void stash_fifo_put_ptr_n(void)
{
- stash_fifo_put(sizeof(uintptr_t), BURST, STASH_PTR);
+ stash_fifo_put(sizeof(uintptr_t), BURST, STASH_PTR, 0);
}
static void stash_fifo_put_u32_1(void)
{
- stash_fifo_put(sizeof(uint32_t), 1, STASH_GEN);
+ stash_fifo_put(sizeof(uint32_t), 1, STASH_GEN, 0);
}
static void stash_fifo_put_u32_n(void)
{
- stash_fifo_put(sizeof(uint32_t), BURST, STASH_GEN);
+ stash_fifo_put(sizeof(uint32_t), BURST, STASH_GEN, 0);
}
static void stash_fifo_u32_put_u32_1(void)
{
- stash_fifo_put(sizeof(uint32_t), 1, STASH_U32);
+ stash_fifo_put(sizeof(uint32_t), 1, STASH_U32, 0);
}
static void stash_fifo_u32_put_u32_n(void)
{
- stash_fifo_put(sizeof(uint32_t), BURST, STASH_U32);
+ stash_fifo_put(sizeof(uint32_t), BURST, STASH_U32, 0);
}
static void stash_fifo_put_u16_1(void)
{
- stash_fifo_put(sizeof(uint16_t), 1, STASH_GEN);
+ stash_fifo_put(sizeof(uint16_t), 1, STASH_GEN, 0);
}
static void stash_fifo_put_u16_n(void)
{
- stash_fifo_put(sizeof(uint16_t), BURST, STASH_GEN);
+ stash_fifo_put(sizeof(uint16_t), BURST, STASH_GEN, 0);
}
static void stash_fifo_put_u8_1(void)
{
- stash_fifo_put(sizeof(uint8_t), 1, STASH_GEN);
+ stash_fifo_put(sizeof(uint8_t), 1, STASH_GEN, 0);
}
static void stash_fifo_put_u8_n(void)
{
- stash_fifo_put(sizeof(uint8_t), BURST, STASH_GEN);
+ stash_fifo_put(sizeof(uint8_t), BURST, STASH_GEN, 0);
+}
+
+static void stash_fifo_put_u64_1_batch(void)
+{
+ stash_fifo_put(sizeof(uint64_t), 1, STASH_GEN, 1);
+}
+
+static void stash_fifo_put_u64_n_batch(void)
+{
+ stash_fifo_put(sizeof(uint64_t), BATCH, STASH_GEN, 1);
+}
+
+static void stash_fifo_u64_put_u64_1_batch(void)
+{
+ stash_fifo_put(sizeof(uint64_t), 1, STASH_U64, 1);
+}
+
+static void stash_fifo_u64_put_u64_n_batch(void)
+{
+ stash_fifo_put(sizeof(uint64_t), BATCH, STASH_U64, 1);
+}
+
+static void stash_fifo_put_ptr_1_batch(void)
+{
+ stash_fifo_put(sizeof(uintptr_t), 1, STASH_PTR, 1);
+}
+
+static void stash_fifo_put_ptr_n_batch(void)
+{
+ stash_fifo_put(sizeof(uintptr_t), BATCH, STASH_PTR, 1);
+}
+
+static void stash_fifo_put_u32_1_batch(void)
+{
+ stash_fifo_put(sizeof(uint32_t), 1, STASH_GEN, 1);
+}
+
+static void stash_fifo_put_u32_n_batch(void)
+{
+ stash_fifo_put(sizeof(uint32_t), BATCH, STASH_GEN, 1);
+}
+
+static void stash_fifo_u32_put_u32_1_batch(void)
+{
+ stash_fifo_put(sizeof(uint32_t), 1, STASH_U32, 1);
+}
+
+static void stash_fifo_u32_put_u32_n_batch(void)
+{
+ stash_fifo_put(sizeof(uint32_t), BATCH, STASH_U32, 1);
+}
+
+static void stash_fifo_put_u16_1_batch(void)
+{
+ stash_fifo_put(sizeof(uint16_t), 1, STASH_GEN, 1);
+}
+
+static void stash_fifo_put_u16_n_batch(void)
+{
+ stash_fifo_put(sizeof(uint16_t), BATCH, STASH_GEN, 1);
+}
+
+static void stash_fifo_put_u8_1_batch(void)
+{
+ stash_fifo_put(sizeof(uint8_t), 1, STASH_GEN, 1);
+}
+
+static void stash_fifo_put_u8_n_batch(void)
+{
+ stash_fifo_put(sizeof(uint8_t), BATCH, STASH_GEN, 1);
}
odp_testinfo_t stash_suite[] = {
@@ -954,6 +1201,12 @@ odp_testinfo_t stash_suite[] = {
ODP_TEST_INFO_CONDITIONAL(stash_default_u64_put_u64_n, check_support_64),
ODP_TEST_INFO_CONDITIONAL(stash_default_put_ptr_1, check_support_ptr),
ODP_TEST_INFO_CONDITIONAL(stash_default_put_ptr_n, check_support_ptr),
+ ODP_TEST_INFO_CONDITIONAL(stash_default_put_u64_1_batch, check_support_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_default_put_u64_n_batch, check_support_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_default_u64_put_u64_1_batch, check_support_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_default_u64_put_u64_n_batch, check_support_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_default_put_ptr_1_batch, check_support_ptr),
+ ODP_TEST_INFO_CONDITIONAL(stash_default_put_ptr_n_batch, check_support_ptr),
ODP_TEST_INFO(stash_default_put_u32_1),
ODP_TEST_INFO(stash_default_put_u32_n),
ODP_TEST_INFO(stash_default_u32_put_u32_1),
@@ -962,6 +1215,14 @@ odp_testinfo_t stash_suite[] = {
ODP_TEST_INFO(stash_default_put_u16_n),
ODP_TEST_INFO(stash_default_put_u8_1),
ODP_TEST_INFO(stash_default_put_u8_n),
+ ODP_TEST_INFO(stash_default_put_u32_1_batch),
+ ODP_TEST_INFO(stash_default_put_u32_n_batch),
+ ODP_TEST_INFO(stash_default_u32_put_u32_1_batch),
+ ODP_TEST_INFO(stash_default_u32_put_u32_n_batch),
+ ODP_TEST_INFO(stash_default_put_u16_1_batch),
+ ODP_TEST_INFO(stash_default_put_u16_n_batch),
+ ODP_TEST_INFO(stash_default_put_u8_1_batch),
+ ODP_TEST_INFO(stash_default_put_u8_n_batch),
ODP_TEST_INFO_CONDITIONAL(stash_create_u64_all, check_support_64),
ODP_TEST_INFO(stash_create_u32_all),
ODP_TEST_INFO(stash_stats_u32),
@@ -979,6 +1240,20 @@ odp_testinfo_t stash_suite[] = {
ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u16_n, check_support_fifo),
ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u8_1, check_support_fifo),
ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u8_n, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u64_1_batch, check_support_fifo_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u64_n_batch, check_support_fifo_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_u64_put_u64_1_batch, check_support_fifo_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_u64_put_u64_n_batch, check_support_fifo_64),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_ptr_1_batch, check_support_fifo_ptr),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_ptr_n_batch, check_support_fifo_ptr),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u32_1_batch, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u32_n_batch, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_u32_put_u32_1_batch, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_u32_put_u32_n_batch, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u16_1_batch, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u16_n_batch, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u8_1_batch, check_support_fifo),
+ ODP_TEST_INFO_CONDITIONAL(stash_fifo_put_u8_n_batch, check_support_fifo),
ODP_TEST_INFO_CONDITIONAL(stash_create_fifo_u64_all,
check_support_fifo_64),
ODP_TEST_INFO_CONDITIONAL(stash_create_fifo_u32_all,
diff --git a/test/validation/api/thread/thread.c b/test/validation/api/thread/thread.c
index f279dd16f..2dc799c2a 100644
--- a/test/validation/api/thread/thread.c
+++ b/test/validation/api/thread/thread.c
@@ -16,6 +16,9 @@ typedef struct {
/* Test thread entry and exit synchronization barriers */
odp_barrier_t bar_entry;
odp_barrier_t bar_exit;
+
+ /* Storage for thread ID assignment order test */
+ int thread_id[ODP_THREAD_COUNT_MAX];
} global_shared_mem_t;
static global_shared_mem_t *global_mem;
@@ -89,6 +92,9 @@ static void thread_test_odp_thread_id(void)
{
int id = odp_thread_id();
+ /* First thread which called odp_init_local() */
+ CU_ASSERT(id == 0);
+
CU_ASSERT(id >= 0);
CU_ASSERT(id < odp_thread_count_max());
CU_ASSERT(id < ODP_THREAD_COUNT_MAX);
@@ -107,14 +113,22 @@ static void thread_test_odp_thread_count(void)
CU_ASSERT(odp_thread_count_max() <= ODP_THREAD_COUNT_MAX);
}
-static int thread_func(void *arg ODP_UNUSED)
+static int thread_func(void *arg)
{
- /* indicate that thread has started */
+ int *id_ptr = arg;
+
+ /* Indicate that thread has started */
odp_barrier_wait(&global_mem->bar_entry);
+ /* Record thread identifier for ID assignment order check */
+ *id_ptr = odp_thread_id();
+
+ CU_ASSERT(*id_ptr > 0);
+ CU_ASSERT(*id_ptr < odp_thread_count_max());
+
CU_ASSERT(odp_thread_type() == ODP_THREAD_WORKER);
- /* wait for indication that we can exit */
+ /* Wait for indication that we can exit */
odp_barrier_wait(&global_mem->bar_exit);
return CU_get_number_of_failures();
@@ -124,10 +138,22 @@ static void thread_test_odp_thrmask_worker(void)
{
odp_thrmask_t mask;
int ret;
- int num = 1;
+ int num = odp_cpumask_default_worker(NULL, 0);
+ CU_ASSERT_FATAL(num > 0);
CU_ASSERT_FATAL(odp_thread_type() == ODP_THREAD_CONTROL);
+ /* Control and worker threads may share CPUs */
+ if (num > 1)
+ num--;
+
+ void *args[num];
+
+ for (int i = 0; i < num; i++) {
+ global_mem->thread_id[i] = -1;
+ args[i] = &global_mem->thread_id[i];
+ }
+
odp_barrier_init(&global_mem->bar_entry, num + 1);
odp_barrier_init(&global_mem->bar_exit, num + 1);
@@ -137,7 +163,7 @@ static void thread_test_odp_thrmask_worker(void)
CU_ASSERT(ret == 0);
/* start the test thread(s) */
- ret = odp_cunit_thread_create(num, thread_func, NULL, 0);
+ ret = odp_cunit_thread_create(num, thread_func, args, 1, 1);
CU_ASSERT(ret == num);
if (ret != num)
@@ -154,6 +180,10 @@ static void thread_test_odp_thrmask_worker(void)
/* allow thread(s) to exit */
odp_barrier_wait(&global_mem->bar_exit);
+ /* Thread ID 0 is used by this control thread */
+ for (int i = 0; i < num; i++)
+ CU_ASSERT(global_mem->thread_id[i] == i + 1);
+
odp_cunit_thread_join(num);
}
diff --git a/test/validation/api/timer/timer.c b/test/validation/api/timer/timer.c
index bf0fd3baf..1c0a16349 100644
--- a/test/validation/api/timer/timer.c
+++ b/test/validation/api/timer/timer.c
@@ -33,6 +33,7 @@
#define EXTRA_TIMERS 256
#define NAME "timer_pool"
+#define MSEC ODP_TIME_MSEC_IN_NS
#define THREE_POINT_THREE_MSEC (10 * ODP_TIME_MSEC_IN_NS / 3)
#define USER_PTR ((void *)0xdead)
#define TICK_INVALID (~(uint64_t)0)
@@ -40,10 +41,19 @@
/* Test case options */
#define PRIV 1
#define EXP_RELAX 1
-#define WAIT 0
-#define CANCEL 1
-#define RESTART 1
#define FIRST_TICK 1
+#define RELATIVE ODP_TIMER_TICK_REL
+#define ABSOLUTE ODP_TIMER_TICK_ABS
+
+enum {
+ TIMEOUT = 0,
+ CANCEL
+};
+
+enum {
+ START = 0,
+ RESTART
+};
/* Timer helper structure */
struct test_timer {
@@ -441,6 +451,62 @@ static void timer_test_timeout_pool_free(void)
CU_ASSERT(odp_pool_destroy(pool) == 0);
}
+static void timer_test_timeout_user_area(void)
+{
+ odp_pool_t pool;
+ odp_pool_capability_t pool_capa;
+ odp_pool_param_t param;
+ uint32_t i, max_size;
+ void *addr;
+ void *prev = NULL;
+ const uint32_t num = 10;
+ uint32_t num_alloc = 0;
+ uint32_t size = 1024;
+ odp_timeout_t tmo[num];
+
+ CU_ASSERT_FATAL(!odp_pool_capability(&pool_capa));
+ max_size = pool_capa.tmo.max_uarea_size;
+
+ if (max_size == 0) {
+ ODPH_DBG("Timeout user area not supported\n");
+ return;
+ }
+
+ if (size > max_size)
+ size = max_size;
+
+ odp_pool_param_init(&param);
+ param.type = ODP_POOL_TIMEOUT;
+ param.tmo.num = num;
+ param.tmo.uarea_size = size;
+
+ pool = odp_pool_create("test_user_area", &param);
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ for (i = 0; i < num; i++) {
+ tmo[i] = odp_timeout_alloc(pool);
+
+ if (tmo[i] == ODP_TIMEOUT_INVALID)
+ break;
+
+ num_alloc++;
+
+ addr = odp_timeout_user_area(tmo[i]);
+ CU_ASSERT_FATAL(addr != NULL);
+ CU_ASSERT(prev != addr);
+
+ prev = addr;
+ memset(addr, 0, size);
+ }
+
+ CU_ASSERT(i == num);
+
+ for (i = 0; i < num_alloc; i++)
+ odp_timeout_free(tmo[i]);
+
+ CU_ASSERT_FATAL(odp_pool_destroy(pool) == 0);
+}
+
static void timer_pool_create_destroy(void)
{
odp_timer_pool_param_t tparam;
@@ -729,9 +795,10 @@ static void free_schedule_context(odp_queue_type_t queue_type)
}
static void timer_single_shot(odp_queue_type_t queue_type, odp_timer_tick_type_t tick_type,
- int restart, int cancel)
+ int restart, int cancel, int rounds, uint64_t tmo_ns)
{
odp_timer_capability_t capa;
+ odp_timer_res_capability_t res_capa;
odp_timer_pool_param_t tp_param;
odp_queue_param_t queue_param;
odp_pool_param_t pool_param;
@@ -743,20 +810,36 @@ static void timer_single_shot(odp_queue_type_t queue_type, odp_timer_tick_type_t
odp_timeout_t tmo;
odp_event_t ev;
odp_time_t t1, t2;
- uint64_t tick, nsec;
- int ret;
- uint64_t tmo_ns = ODP_TIME_SEC_IN_NS;
- uint64_t res_ns = ODP_TIME_SEC_IN_NS / 10;
+ uint64_t tick, nsec, res_ns, min_tmo;
+ int ret, i;
memset(&capa, 0, sizeof(capa));
ret = odp_timer_capability(ODP_CLOCK_DEFAULT, &capa);
CU_ASSERT_FATAL(ret == 0);
CU_ASSERT_FATAL(capa.max_tmo.max_tmo > 0);
- if (capa.max_tmo.max_tmo < tmo_ns) {
+ /* Use timeout and resolution values that are within capability limits */
+ if (capa.max_tmo.max_tmo < tmo_ns)
tmo_ns = capa.max_tmo.max_tmo;
- res_ns = capa.max_tmo.res_ns;
- }
+
+ memset(&res_capa, 0, sizeof(res_capa));
+ res_capa.max_tmo = tmo_ns;
+
+ ret = odp_timer_res_capability(ODP_CLOCK_DEFAULT, &res_capa);
+ CU_ASSERT_FATAL(ret == 0);
+ CU_ASSERT_FATAL(res_capa.res_ns > 0);
+
+ res_ns = tmo_ns / 10;
+
+ if (res_ns < res_capa.res_ns)
+ res_ns = res_capa.res_ns;
+
+ /* Test expects better resolution than 0.5x timeout */
+ CU_ASSERT_FATAL(res_ns < tmo_ns / 2);
+
+ min_tmo = tmo_ns / 4;
+ if (min_tmo < res_capa.min_tmo)
+ min_tmo = res_capa.min_tmo;
odp_pool_param_init(&pool_param);
pool_param.type = ODP_POOL_TIMEOUT;
@@ -776,7 +859,7 @@ static void timer_single_shot(odp_queue_type_t queue_type, odp_timer_tick_type_t
odp_timer_pool_param_init(&tp_param);
tp_param.res_ns = res_ns;
- tp_param.min_tmo = tmo_ns / 4;
+ tp_param.min_tmo = min_tmo;
tp_param.max_tmo = tmo_ns;
tp_param.num_timers = 1;
@@ -796,67 +879,73 @@ static void timer_single_shot(odp_queue_type_t queue_type, odp_timer_tick_type_t
if (restart)
nsec = tmo_ns / 2;
- tick = odp_timer_ns_to_tick(tp, nsec);
- if (tick_type == ODP_TIMER_TICK_ABS)
- tick += odp_timer_current_tick(tp);
-
- start_param.tick_type = tick_type;
- start_param.tick = tick;
- start_param.tmo_ev = ev;
-
- ret = odp_timer_start(timer, &start_param);
- CU_ASSERT_FATAL(ret == ODP_TIMER_SUCCESS);
-
- if (restart) {
- tick = odp_timer_ns_to_tick(tp, tmo_ns);
+ for (i = 0; i < rounds; i++) {
+ tick = odp_timer_ns_to_tick(tp, nsec);
if (tick_type == ODP_TIMER_TICK_ABS)
tick += odp_timer_current_tick(tp);
- start_param.tick = tick;
- start_param.tmo_ev = ODP_EVENT_INVALID;
+ start_param.tick_type = tick_type;
+ start_param.tick = tick;
+ start_param.tmo_ev = ev;
- ret = odp_timer_restart(timer, &start_param);
+ ret = odp_timer_start(timer, &start_param);
CU_ASSERT_FATAL(ret == ODP_TIMER_SUCCESS);
- }
- ev = ODP_EVENT_INVALID;
+ if (restart) {
+ tick = odp_timer_ns_to_tick(tp, tmo_ns);
+ if (tick_type == ODP_TIMER_TICK_ABS)
+ tick += odp_timer_current_tick(tp);
- if (cancel) {
- ret = odp_timer_cancel(timer, &ev);
- CU_ASSERT(ret == 0);
+ start_param.tick = tick;
+ start_param.tmo_ev = ODP_EVENT_INVALID;
- if (ret == 0)
- CU_ASSERT(ev != ODP_EVENT_INVALID);
- } else {
- uint64_t diff_ns;
+ ret = odp_timer_restart(timer, &start_param);
+ CU_ASSERT_FATAL(ret == ODP_TIMER_SUCCESS);
+ }
- t1 = odp_time_global();
- ev = wait_event(queue_type, queue, t1, 10 * tmo_ns);
- t2 = odp_time_global();
- diff_ns = odp_time_diff_ns(t2, t1);
+ ev = ODP_EVENT_INVALID;
- CU_ASSERT(ev != ODP_EVENT_INVALID);
- CU_ASSERT(diff_ns < 2 * tmo_ns);
- CU_ASSERT((double)diff_ns > 0.5 * tmo_ns);
- }
+ if (cancel) {
+ ret = odp_timer_cancel(timer, &ev);
+ CU_ASSERT(ret == 0);
- if (ev != ODP_EVENT_INVALID) {
- CU_ASSERT_FATAL(odp_event_type(ev) == ODP_EVENT_TIMEOUT);
- tmo = odp_timeout_from_event(ev);
- CU_ASSERT(odp_timeout_user_ptr(tmo) == USER_PTR);
- CU_ASSERT(odp_timeout_timer(tmo) == timer);
+ if (ret == 0)
+ CU_ASSERT(ev != ODP_EVENT_INVALID);
+ } else {
+ uint64_t diff_ns;
- if (!cancel) {
- if (tick_type == ODP_TIMER_TICK_ABS) {
- /* CU_ASSERT needs these extra brackets */
- CU_ASSERT(odp_timeout_tick(tmo) == tick);
- } else {
- CU_ASSERT(odp_timeout_tick(tmo) > tick);
+ t1 = odp_time_global();
+ ev = wait_event(queue_type, queue, t1, 10 * tmo_ns);
+ t2 = odp_time_global();
+ diff_ns = odp_time_diff_ns(t2, t1);
+
+ CU_ASSERT(ev != ODP_EVENT_INVALID);
+ CU_ASSERT(diff_ns < 2 * tmo_ns);
+ CU_ASSERT((double)diff_ns > 0.5 * tmo_ns);
+ }
+
+ if (ev != ODP_EVENT_INVALID) {
+ CU_ASSERT_FATAL(odp_event_type(ev) == ODP_EVENT_TIMEOUT);
+ tmo = odp_timeout_from_event(ev);
+ CU_ASSERT(odp_timeout_user_ptr(tmo) == USER_PTR);
+ CU_ASSERT(odp_timeout_timer(tmo) == timer);
+
+ if (!cancel) {
+ if (tick_type == ODP_TIMER_TICK_ABS) {
+ /* CU_ASSERT needs these extra brackets */
+ CU_ASSERT(odp_timeout_tick(tmo) == tick);
+ } else {
+ CU_ASSERT(odp_timeout_tick(tmo) > tick);
+ }
}
+ } else {
+ ODPH_DBG("Event missing\n");
+ break;
}
+ }
+ if (ev != ODP_EVENT_INVALID)
odp_event_free(ev);
- }
free_schedule_context(queue_type);
@@ -869,82 +958,92 @@ static void timer_single_shot(odp_queue_type_t queue_type, odp_timer_tick_type_t
static void timer_plain_rel_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_REL, 0, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, RELATIVE, START, TIMEOUT, 2, 500 * MSEC);
}
static void timer_plain_abs_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_ABS, 0, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ABSOLUTE, START, TIMEOUT, 2, 500 * MSEC);
}
static void timer_plain_rel_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_REL, 0, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, RELATIVE, START, CANCEL, 5, 1000 * MSEC);
}
static void timer_plain_abs_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_ABS, 0, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ABSOLUTE, START, CANCEL, 5, 1000 * MSEC);
}
static void timer_plain_rel_restart_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_REL, RESTART, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, RELATIVE, RESTART, TIMEOUT, 2, 600 * MSEC);
}
static void timer_plain_abs_restart_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_ABS, RESTART, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ABSOLUTE, RESTART, TIMEOUT, 2, 600 * MSEC);
}
static void timer_plain_rel_restart_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_REL, RESTART, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, RELATIVE, RESTART, CANCEL, 5, 1000 * MSEC);
}
static void timer_plain_abs_restart_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ODP_TIMER_TICK_ABS, RESTART, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ABSOLUTE, RESTART, CANCEL, 5, 1000 * MSEC);
+}
+
+static void timer_plain_abs_wait_3sec(void)
+{
+ timer_single_shot(ODP_QUEUE_TYPE_PLAIN, ABSOLUTE, START, TIMEOUT, 30, 110 * MSEC);
}
static void timer_sched_rel_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_REL, 0, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, RELATIVE, START, TIMEOUT, 2, 500 * MSEC);
}
static void timer_sched_abs_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_ABS, 0, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, ABSOLUTE, START, TIMEOUT, 2, 500 * MSEC);
}
static void timer_sched_rel_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_REL, 0, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, RELATIVE, START, CANCEL, 5, 1000 * MSEC);
}
static void timer_sched_abs_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_ABS, 0, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, ABSOLUTE, START, CANCEL, 5, 1000 * MSEC);
}
static void timer_sched_rel_restart_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_REL, RESTART, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, RELATIVE, RESTART, TIMEOUT, 2, 600 * MSEC);
}
static void timer_sched_abs_restart_wait(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_ABS, RESTART, WAIT);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, ABSOLUTE, RESTART, TIMEOUT, 2, 600 * MSEC);
}
static void timer_sched_rel_restart_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_REL, RESTART, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, RELATIVE, RESTART, CANCEL, 5, 1000 * MSEC);
}
static void timer_sched_abs_restart_cancel(void)
{
- timer_single_shot(ODP_QUEUE_TYPE_SCHED, ODP_TIMER_TICK_ABS, RESTART, CANCEL);
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, ABSOLUTE, RESTART, CANCEL, 5, 1000 * MSEC);
+}
+
+static void timer_sched_abs_wait_3sec(void)
+{
+ timer_single_shot(ODP_QUEUE_TYPE_SCHED, ABSOLUTE, START, TIMEOUT, 30, 110 * MSEC);
}
static void timer_pool_tick_info_run(odp_timer_clk_src_t clk_src)
@@ -2200,7 +2299,7 @@ static void timer_test_all(odp_queue_type_t queue_type)
/* Create and start worker threads */
global_mem->test_queue_type = queue_type;
- odp_cunit_thread_create(num_workers, worker_entrypoint, NULL, 0);
+ odp_cunit_thread_create(num_workers, worker_entrypoint, NULL, 0, 0);
/* Wait for worker threads to exit */
odp_cunit_thread_join(num_workers);
@@ -2503,6 +2602,7 @@ odp_testinfo_t timer_suite[] = {
ODP_TEST_INFO(timer_test_param_init),
ODP_TEST_INFO(timer_test_timeout_pool_alloc),
ODP_TEST_INFO(timer_test_timeout_pool_free),
+ ODP_TEST_INFO(timer_test_timeout_user_area),
ODP_TEST_INFO(timer_pool_create_destroy),
ODP_TEST_INFO(timer_pool_create_max),
ODP_TEST_INFO(timer_pool_max_res),
@@ -2515,6 +2615,7 @@ odp_testinfo_t timer_suite[] = {
ODP_TEST_INFO_CONDITIONAL(timer_plain_abs_restart_wait, check_plain_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_plain_rel_restart_cancel, check_plain_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_plain_abs_restart_cancel, check_plain_queue_support),
+ ODP_TEST_INFO_CONDITIONAL(timer_plain_abs_wait_3sec, check_plain_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_sched_rel_wait, check_sched_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_sched_abs_wait, check_sched_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_sched_rel_cancel, check_sched_queue_support),
@@ -2523,6 +2624,7 @@ odp_testinfo_t timer_suite[] = {
ODP_TEST_INFO_CONDITIONAL(timer_sched_abs_restart_wait, check_sched_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_sched_rel_restart_cancel, check_sched_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_sched_abs_restart_cancel, check_sched_queue_support),
+ ODP_TEST_INFO_CONDITIONAL(timer_sched_abs_wait_3sec, check_sched_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_test_tmo_event_plain,
check_plain_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_test_tmo_event_sched,
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-05 04:03:12 +0000