Replaces odp_cos_create() function with odp_cls_cos_create() function
Signed-off-by: Balasubramanian Manoharan <bala.manoha...@linaro.org>
---
test/validation/classification/classification.h | 1 +
.../classification/odp_classification_basic.c | 137 +++++++-
.../classification/odp_classification_common.c | 15 +-
.../classification/odp_classification_test_pmr.c | 386 +++++++++++++--------
.../classification/odp_classification_tests.c | 207 ++++-------
.../classification/odp_classification_testsuites.h | 3 +-
6 files changed, 453 insertions(+), 296 deletions(-)
diff --git a/test/validation/classification/classification.h
b/test/validation/classification/classification.h
index 6a7e8a5..e3fc081 100644
--- a/test/validation/classification/classification.h
+++ b/test/validation/classification/classification.h
@@ -59,6 +59,7 @@ void classification_test_destroy_cos(void);
void classification_test_create_pmr_match(void);
void classification_test_destroy_pmr(void);
void classification_test_cos_set_queue(void);
+void classification_test_cos_set_pool(void);
void classification_test_cos_set_drop(void);
void classification_test_pmr_match_set_create(void);
void classification_test_pmr_match_set_destroy(void);
diff --git a/test/validation/classification/odp_classification_basic.c
b/test/validation/classification/odp_classification_basic.c
index 20c157f..f0b7a42 100644
--- a/test/validation/classification/odp_classification_basic.c
+++ b/test/validation/classification/odp_classification_basic.c
@@ -13,26 +13,60 @@
void classification_test_create_cos(void)
{
odp_cos_t cos;
- char name[ODP_COS_NAME_LEN];
- sprintf(name, "ClassOfService");
- cos = odp_cos_create(name);
- CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+ odp_cls_cos_param_t cls_param;
+ odp_pool_t pool;
+ odp_queue_t queue;
+ char cosname[ODP_COS_NAME_LEN];
+
+ pool = pool_create("cls_basic_pool");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ queue = queue_create("cls_basic_queue", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ sprintf(cosname, "ClassOfService");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
CU_ASSERT(odp_cos_to_u64(cos) != odp_cos_to_u64(ODP_COS_INVALID));
odp_cos_destroy(cos);
+ odp_pool_destroy(pool);
+ odp_queue_destroy(queue);
}
void classification_test_destroy_cos(void)
{
odp_cos_t cos;
char name[ODP_COS_NAME_LEN];
+ odp_pool_t pool;
+ odp_queue_t queue;
+ odp_cls_cos_param_t cls_param;
int retval;
+
+ pool = pool_create("cls_basic_pool");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ queue = queue_create("cls_basic_queue", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
sprintf(name, "ClassOfService");
- cos = odp_cos_create(name);
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(name, &cls_param);
CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
retval = odp_cos_destroy(cos);
CU_ASSERT(retval == 0);
retval = odp_cos_destroy(ODP_COS_INVALID);
CU_ASSERT(retval < 0);
+
+ odp_pool_destroy(pool);
+ odp_queue_destroy(queue);
}
void classification_test_create_pmr_match(void)
@@ -82,35 +116,101 @@ void classification_test_cos_set_queue(void)
{
int retval;
char cosname[ODP_COS_NAME_LEN];
- char queuename[ODP_QUEUE_NAME_LEN];
- odp_queue_param_t qparam;
+ odp_cls_cos_param_t cls_param;
+ odp_pool_t pool;
+ odp_queue_t queue;
odp_queue_t queue_cos;
odp_cos_t cos_queue;
+ odp_queue_t recvqueue;
+
+ pool = pool_create("cls_basic_pool");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ queue = queue_create("cls_basic_queue", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
sprintf(cosname, "CoSQueue");
- cos_queue = odp_cos_create(cosname);
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_queue = odp_cls_cos_create(cosname, &cls_param);
CU_ASSERT_FATAL(cos_queue != ODP_COS_INVALID);
- odp_queue_param_init(&qparam);
- qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
- qparam.sched.sync = ODP_SCHED_SYNC_NONE;
- qparam.sched.group = ODP_SCHED_GROUP_ALL;
- sprintf(queuename, "%s", "QueueCoS");
+ queue_cos = queue_create("QueueCoS", true);
+ CU_ASSERT_FATAL(queue_cos != ODP_QUEUE_INVALID);
- queue_cos = odp_queue_create(queuename,
- ODP_QUEUE_TYPE_SCHED, &qparam);
retval = odp_cos_queue_set(cos_queue, queue_cos);
CU_ASSERT(retval == 0);
+ recvqueue = odp_cos_queue(cos_queue);
+ CU_ASSERT(recvqueue == queue_cos);
+
odp_cos_destroy(cos_queue);
odp_queue_destroy(queue_cos);
+ odp_queue_destroy(queue);
+ odp_pool_destroy(pool);
+}
+
+void classification_test_cos_set_pool(void)
+{
+ int retval;
+ char cosname[ODP_COS_NAME_LEN];
+ odp_cls_cos_param_t cls_param;
+ odp_pool_t pool;
+ odp_queue_t queue;
+ odp_pool_t cos_pool;
+ odp_cos_t cos;
+ odp_pool_t recvpool;
+
+ pool = pool_create("cls_basic_pool");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ queue = queue_create("cls_basic_queue", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ sprintf(cosname, "CoSQueue");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+ cos_pool = pool_create("PoolCoS");
+ CU_ASSERT_FATAL(cos_pool != ODP_POOL_INVALID);
+
+ retval = odp_cls_cos_pool_set(cos, cos_pool);
+ CU_ASSERT(retval == 0);
+ recvpool = odp_cls_cos_pool(cos);
+ CU_ASSERT(recvpool == cos_pool);
+
+ odp_cos_destroy(cos);
+ odp_queue_destroy(queue);
+ odp_pool_destroy(pool);
+ odp_pool_destroy(cos_pool);
}
void classification_test_cos_set_drop(void)
{
int retval;
char cosname[ODP_COS_NAME_LEN];
- sprintf(cosname, "CoSDrop");
odp_cos_t cos_drop;
- cos_drop = odp_cos_create(cosname);
+ odp_queue_t queue;
+ odp_pool_t pool;
+ odp_cls_cos_param_t cls_param;
+
+ pool = pool_create("cls_basic_pool");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ queue = queue_create("cls_basic_queue", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ sprintf(cosname, "CoSDrop");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_drop = odp_cls_cos_create(cosname, &cls_param);
CU_ASSERT_FATAL(cos_drop != ODP_COS_INVALID);
retval = odp_cos_drop_set(cos_drop, ODP_COS_DROP_POOL);
@@ -118,6 +218,8 @@ void classification_test_cos_set_drop(void)
retval = odp_cos_drop_set(cos_drop, ODP_COS_DROP_NEVER);
CU_ASSERT(retval == 0);
odp_cos_destroy(cos_drop);
+ odp_pool_destroy(pool);
+ odp_queue_destroy(queue);
}
void classification_test_pmr_match_set_create(void)
@@ -177,6 +279,7 @@ odp_testinfo_t classification_suite_basic[] = {
ODP_TEST_INFO(classification_test_destroy_pmr),
ODP_TEST_INFO(classification_test_cos_set_queue),
ODP_TEST_INFO(classification_test_cos_set_drop),
+ ODP_TEST_INFO(classification_test_cos_set_pool),
ODP_TEST_INFO(classification_test_pmr_match_set_create),
ODP_TEST_INFO(classification_test_pmr_match_set_destroy),
ODP_TEST_INFO_NULL,
diff --git a/test/validation/classification/odp_classification_common.c
b/test/validation/classification/odp_classification_common.c
index e2999ad..e0026c3 100644
--- a/test/validation/classification/odp_classification_common.c
+++ b/test/validation/classification/odp_classification_common.c
@@ -151,7 +151,7 @@ odp_packet_t receive_packet(odp_queue_t *queue, uint64_t ns)
return odp_packet_from_event(ev);
}
-odp_queue_t queue_create(char *queuename, bool sched)
+odp_queue_t queue_create(const char *queuename, bool sched)
{
odp_queue_t queue;
odp_queue_param_t qparam;
@@ -174,6 +174,19 @@ odp_queue_t queue_create(char *queuename, bool sched)
return queue;
}
+odp_pool_t pool_create(const char *poolname)
+{
+ odp_pool_param_t param;
+
+ odp_pool_param_init(¶m);
+ param.pkt.seg_len = SHM_PKT_BUF_SIZE;
+ param.pkt.len = SHM_PKT_BUF_SIZE;
+ param.pkt.num = SHM_PKT_NUM_BUFS;
+ param.type = ODP_POOL_PACKET;
+
+ return odp_pool_create(poolname, ¶m);
+}
+
odp_packet_t create_packet(odp_pool_t pool, bool vlan,
odp_atomic_u32_t *seq, bool flag_udp)
{
diff --git a/test/validation/classification/odp_classification_test_pmr.c
b/test/validation/classification/odp_classification_test_pmr.c
index 2fa524d..0c47999 100644
--- a/test/validation/classification/odp_classification_test_pmr.c
+++ b/test/validation/classification/odp_classification_test_pmr.c
@@ -19,15 +19,7 @@ odp_atomic_u32_t seq;
int classification_suite_pmr_init(void)
{
- odp_pool_param_t param;
-
- odp_pool_param_init(¶m);
- param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- param.pkt.len = SHM_PKT_BUF_SIZE;
- param.pkt.num = SHM_PKT_NUM_BUFS;
- param.type = ODP_POOL_PACKET;
-
- pkt_pool = odp_pool_create("classification_pmr_pool", ¶m);
+ pkt_pool = pool_create("classification_pmr_pool");
if (ODP_POOL_INVALID == pkt_pool) {
fprintf(stderr, "Packet pool creation failed.\n");
return -1;
@@ -100,38 +92,27 @@ int create_default_inq(odp_pktio_t pktio, odp_queue_type_t
qtype)
void configure_default_cos(odp_pktio_t pktio, odp_cos_t *cos,
odp_queue_t *queue, odp_pool_t *pool)
{
- odp_pool_param_t pool_param;
+ odp_cls_cos_param_t cls_param;
odp_pool_t default_pool;
odp_cos_t default_cos;
odp_queue_t default_queue;
int retval;
char cosname[ODP_COS_NAME_LEN];
- char poolname[ODP_POOL_NAME_LEN];
- char queuename[ODP_QUEUE_NAME_LEN];
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
- sprintf(poolname, "%s", "DefaultPool");
-
- default_pool = odp_pool_create(poolname, &pool_param);
+ default_pool = pool_create("DefaultPool");
CU_ASSERT(default_pool != ODP_POOL_INVALID);
- sprintf(queuename, "DefaultQueue");
- default_queue = queue_create(queuename, true);
+ default_queue = queue_create("DefaultQueue", true);
CU_ASSERT(default_queue != ODP_QUEUE_INVALID);
sprintf(cosname, "DefaultCos");
- default_cos = odp_cos_create(cosname);
- CU_ASSERT(default_cos != ODP_COS_INVALID);
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = default_pool;
+ cls_param.queue = default_queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
- retval = odp_cos_queue_set(default_cos, default_queue);
- CU_ASSERT(retval == 0);
-
- retval = odp_cls_cos_pool_set(default_cos, default_pool);
- CU_ASSERT(retval == 0);
+ default_cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT(default_cos != ODP_COS_INVALID);
retval = odp_pktio_default_cos_set(pktio, default_cos);
CU_ASSERT(retval == 0);
@@ -172,9 +153,7 @@ static void classification_test_pmr_term_tcp_dport(void)
odp_pmr_t pmr;
odp_cos_t cos;
char cosname[ODP_COS_NAME_LEN];
- char queuename[ODP_QUEUE_NAME_LEN];
- char poolname[ODP_POOL_NAME_LEN];
- odp_pool_param_t pool_param;
+ odp_cls_cos_param_t cls_param;
odp_pool_t pool;
odp_pool_t pool_recv;
odp_pmr_match_t match;
@@ -196,30 +175,21 @@ static void classification_test_pmr_term_tcp_dport(void)
pmr = odp_pmr_create(&match);
CU_ASSERT(pmr != ODP_PMR_INVAL);
- sprintf(cosname, "tcp_dport");
- cos = odp_cos_create(cosname);
- CU_ASSERT(cos != ODP_COS_INVALID);
-
- sprintf(queuename, "%s", "tcp_dport1");
- queue = queue_create(queuename, true);
+ queue = queue_create("tcp_dport1", true);
CU_ASSERT(queue != ODP_QUEUE_INVALID);
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
- sprintf(poolname, "%s", "tcp_dport1");
-
- pool = odp_pool_create(poolname, &pool_param);
+ pool = pool_create("tcp_dport1");
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos, pool);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "tcp_dport");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
- retval = odp_cos_queue_set(cos, queue);
- CU_ASSERT(retval == 0);
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT(cos != ODP_COS_INVALID);
retval = odp_pktio_pmr_cos(pmr, pktio, cos);
CU_ASSERT(retval == 0);
@@ -287,14 +257,12 @@ static void classification_test_pmr_term_tcp_sport(void)
odp_queue_t default_queue;
odp_cos_t default_cos;
odp_pool_t default_pool;
- odp_pool_param_t pool_param;
odp_pool_t pool;
odp_pool_t recvpool;
odp_pmr_t pmr;
odp_cos_t cos;
char cosname[ODP_COS_NAME_LEN];
- char poolname[ODP_POOL_NAME_LEN];
- char queuename[ODP_QUEUE_NAME_LEN];
+ odp_cls_cos_param_t cls_param;
odp_pmr_match_t match;
val = CLS_DEFAULT_SPORT;
@@ -313,30 +281,20 @@ static void classification_test_pmr_term_tcp_sport(void)
pmr = odp_pmr_create(&match);
CU_ASSERT(pmr != ODP_PMR_INVAL);
- sprintf(cosname, "tcp_sport");
- cos = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
-
- sprintf(queuename, "%s", "tcp_sport");
-
- queue = queue_create(queuename, true);
+ queue = queue_create("tcp_sport", true);
CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
- sprintf(poolname, "%s", "tcp_sport");
-
- pool = odp_pool_create(poolname, &pool_param);
+ pool = pool_create("tcp_sport");
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos, pool);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "tcp_sport");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
- retval = odp_cos_queue_set(cos, queue);
- CU_ASSERT(retval == 0);
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
retval = odp_pktio_pmr_cos(pmr, pktio, cos);
CU_ASSERT(retval == 0);
@@ -404,13 +362,11 @@ static void classification_test_pmr_term_udp_dport(void)
odp_queue_t default_queue;
odp_cos_t default_cos;
odp_pool_t default_pool;
- odp_pool_param_t pool_param;
odp_pmr_t pmr;
odp_cos_t cos;
char cosname[ODP_COS_NAME_LEN];
- char poolname[ODP_POOL_NAME_LEN];
- char queuename[ODP_QUEUE_NAME_LEN];
odp_pmr_match_t match;
+ odp_cls_cos_param_t cls_param;
val = CLS_DEFAULT_DPORT;
mask = 0xffff;
@@ -428,30 +384,20 @@ static void classification_test_pmr_term_udp_dport(void)
pmr = odp_pmr_create(&match);
CU_ASSERT(pmr != ODP_PMR_INVAL);
- sprintf(cosname, "udp_dport");
- cos = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
-
- sprintf(queuename, "%s", "udp_dport");
-
- queue = queue_create(queuename, true);
+ queue = queue_create("udp_dport", true);
CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
- retval = odp_cos_queue_set(cos, queue);
- CU_ASSERT(retval == 0);
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
- sprintf(poolname, "%s", "udp_dport");
-
- pool = odp_pool_create(poolname, &pool_param);
+ pool = pool_create("udp_dport");
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos, pool);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "udp_dport");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
retval = odp_pktio_pmr_cos(pmr, pktio, cos);
CU_ASSERT(retval == 0);
@@ -518,15 +464,13 @@ static void classification_test_pmr_term_udp_sport(void)
odp_queue_t default_queue;
odp_cos_t default_cos;
odp_pool_t default_pool;
- odp_pool_param_t pool_param;
odp_pool_t pool;
odp_pool_t recvpool;
odp_pmr_t pmr;
odp_cos_t cos;
char cosname[ODP_COS_NAME_LEN];
- char poolname[ODP_POOL_NAME_LEN];
- char queuename[ODP_QUEUE_NAME_LEN];
odp_pmr_match_t match;
+ odp_cls_cos_param_t cls_param;
val = CLS_DEFAULT_SPORT;
mask = 0xffff;
@@ -544,30 +488,20 @@ static void classification_test_pmr_term_udp_sport(void)
pmr = odp_pmr_create(&match);
CU_ASSERT(pmr != ODP_PMR_INVAL);
- sprintf(cosname, "udp_sport");
- cos = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
-
- sprintf(queuename, "%s", "udp_sport");
-
- queue = queue_create(queuename, true);
+ queue = queue_create("udp_sport", true);
CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
- retval = odp_cos_queue_set(cos, queue);
- CU_ASSERT(retval == 0);
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
- sprintf(poolname, "%s", "udp_sport");
-
- pool = odp_pool_create(poolname, &pool_param);
+ pool = pool_create("udp_sport");
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos, pool);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "udp_sport");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
retval = odp_pktio_pmr_cos(pmr, pktio, cos);
CU_ASSERT(retval == 0);
@@ -636,10 +570,8 @@ static void classification_test_pmr_term_ipproto(void)
odp_pool_t recvpool;
odp_pmr_t pmr;
odp_cos_t cos;
- odp_pool_param_t pool_param;
char cosname[ODP_COS_NAME_LEN];
- char poolname[ODP_POOL_NAME_LEN];
- char queuename[ODP_QUEUE_NAME_LEN];
+ odp_cls_cos_param_t cls_param;
odp_pmr_match_t match;
val = ODPH_IPPROTO_UDP;
@@ -658,29 +590,124 @@ static void classification_test_pmr_term_ipproto(void)
pmr = odp_pmr_create(&match);
CU_ASSERT(pmr != ODP_PMR_INVAL);
+ queue = queue_create("ipproto", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ pool = pool_create("ipproto");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
sprintf(cosname, "ipproto");
- cos = odp_cos_create(cosname);
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
- sprintf(queuename, "%s", "ipproto");
+ retval = odp_pktio_pmr_cos(pmr, pktio, cos);
+ CU_ASSERT(retval == 0);
- queue = queue_create(queuename, true);
- CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+ configure_default_cos(pktio, &default_cos,
+ &default_queue, &default_pool);
+ pkt = create_packet(pkt_pool, false, &seq, true);
+ seqno = cls_pkt_get_seq(pkt);
+ CU_ASSERT(seqno != TEST_SEQ_INVALID);
+
+ enqueue_pktio_interface(pkt, pktio);
+
+ pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+ CU_ASSERT(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+ recvpool = odp_packet_pool(pkt);
+ CU_ASSERT(recvpool == pool);
+ CU_ASSERT(retqueue == queue);
+ odp_packet_free(pkt);
+
+ /* Other packets delivered to default queue */
+ pkt = create_packet(pkt_pool, false, &seq, false);
+ seqno = cls_pkt_get_seq(pkt);
+ CU_ASSERT(seqno != TEST_SEQ_INVALID);
+
+ enqueue_pktio_interface(pkt, pktio);
+
+ pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+ CU_ASSERT(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+ recvpool = odp_packet_pool(pkt);
+ CU_ASSERT(recvpool == default_pool);
+ CU_ASSERT(retqueue == default_queue);
+
+ odp_cos_destroy(cos);
+ odp_cos_destroy(default_cos);
+ odp_pmr_destroy(pmr);
+ odp_packet_free(pkt);
+ destroy_inq(pktio);
+ odp_pool_destroy(default_pool);
+ odp_pool_destroy(pool);
+ odp_queue_destroy(queue);
+ odp_queue_destroy(default_queue);
+ odp_pktio_close(pktio);
+}
+
+static void classification_test_pmr_pool_set(void)
+{
+ odp_packet_t pkt;
+ uint32_t seqno;
+ uint8_t val;
+ uint8_t mask;
+ int retval;
+ odp_pktio_t pktio;
+ odp_queue_t queue;
+ odp_queue_t retqueue;
+ odp_queue_t default_queue;
+ odp_cos_t default_cos;
+ odp_pool_t default_pool;
+ odp_pool_t pool;
+ odp_pool_t pool_new;
+ odp_pool_t recvpool;
+ odp_pmr_t pmr;
+ odp_cos_t cos;
+ char cosname[ODP_COS_NAME_LEN];
+ odp_cls_cos_param_t cls_param;
+ odp_pmr_match_t match;
- retval = odp_cos_queue_set(cos, queue);
+ val = ODPH_IPPROTO_UDP;
+ mask = 0xff;
+ seqno = 0;
+
+ pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
+ retval = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED);
CU_ASSERT(retval == 0);
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
- sprintf(poolname, "%s", "ipproto");
+ match.term = ODP_PMR_IPPROTO;
+ match.val = &val;
+ match.mask = &mask;
+ match.val_sz = sizeof(val);
+
+ pmr = odp_pmr_create(&match);
+ CU_ASSERT(pmr != ODP_PMR_INVAL);
- pool = odp_pool_create(poolname, &pool_param);
+ queue = queue_create("ipproto1", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ pool = pool_create("ipproto1");
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos, pool);
+ sprintf(cosname, "ipproto1");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+ pool_new = pool_create("ipproto2");
+ CU_ASSERT_FATAL(pool_new != ODP_POOL_INVALID);
+
+ /* new pool is set on CoS */
+ retval = odp_cls_cos_pool_set(cos, pool_new);
CU_ASSERT(retval == 0);
retval = odp_pktio_pmr_cos(pmr, pktio, cos);
@@ -698,12 +725,89 @@ static void classification_test_pmr_term_ipproto(void)
CU_ASSERT(pkt != ODP_PACKET_INVALID);
CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
recvpool = odp_packet_pool(pkt);
- CU_ASSERT(recvpool == pool);
+ CU_ASSERT(recvpool == pool_new);
CU_ASSERT(retqueue == queue);
odp_packet_free(pkt);
- /* Other packets delivered to default queue */
- pkt = create_packet(pkt_pool, false, &seq, false);
+ odp_cos_destroy(cos);
+ odp_cos_destroy(default_cos);
+ odp_pmr_destroy(pmr);
+ odp_packet_free(pkt);
+ destroy_inq(pktio);
+ odp_pool_destroy(default_pool);
+ odp_pool_destroy(pool);
+ odp_pool_destroy(pool_new);
+ odp_queue_destroy(queue);
+ odp_queue_destroy(default_queue);
+ odp_pktio_close(pktio);
+}
+
+static void classification_test_pmr_queue_set(void)
+{
+ odp_packet_t pkt;
+ uint32_t seqno;
+ uint8_t val;
+ uint8_t mask;
+ int retval;
+ odp_pktio_t pktio;
+ odp_queue_t queue;
+ odp_queue_t retqueue;
+ odp_queue_t default_queue;
+ odp_cos_t default_cos;
+ odp_pool_t default_pool;
+ odp_pool_t pool;
+ odp_queue_t queue_new;
+ odp_pool_t recvpool;
+ odp_pmr_t pmr;
+ odp_cos_t cos;
+ char cosname[ODP_COS_NAME_LEN];
+ odp_cls_cos_param_t cls_param;
+ odp_pmr_match_t match;
+
+ val = ODPH_IPPROTO_UDP;
+ mask = 0xff;
+ seqno = 0;
+
+ pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
+ retval = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED);
+ CU_ASSERT(retval == 0);
+
+ match.term = ODP_PMR_IPPROTO;
+ match.val = &val;
+ match.mask = &mask;
+ match.val_sz = sizeof(val);
+
+ pmr = odp_pmr_create(&match);
+ CU_ASSERT(pmr != ODP_PMR_INVAL);
+
+ queue = queue_create("ipproto1", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ pool = pool_create("ipproto1");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ sprintf(cosname, "ipproto1");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+ queue_new = queue_create("ipproto2", true);
+ CU_ASSERT_FATAL(queue_new != ODP_QUEUE_INVALID);
+
+ /* new queue is set on CoS */
+ retval = odp_cos_queue_set(cos, queue_new);
+ CU_ASSERT(retval == 0);
+
+ retval = odp_pktio_pmr_cos(pmr, pktio, cos);
+ CU_ASSERT(retval == 0);
+
+ configure_default_cos(pktio, &default_cos,
+ &default_queue, &default_pool);
+ pkt = create_packet(pkt_pool, false, &seq, true);
seqno = cls_pkt_get_seq(pkt);
CU_ASSERT(seqno != TEST_SEQ_INVALID);
@@ -713,8 +817,9 @@ static void classification_test_pmr_term_ipproto(void)
CU_ASSERT(pkt != ODP_PACKET_INVALID);
CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
recvpool = odp_packet_pool(pkt);
- CU_ASSERT(recvpool == default_pool);
- CU_ASSERT(retqueue == default_queue);
+ CU_ASSERT(recvpool == pool);
+ CU_ASSERT(retqueue == queue_new);
+ odp_packet_free(pkt);
odp_cos_destroy(cos);
odp_cos_destroy(default_cos);
@@ -723,6 +828,7 @@ static void classification_test_pmr_term_ipproto(void)
destroy_inq(pktio);
odp_pool_destroy(default_pool);
odp_pool_destroy(pool);
+ odp_queue_destroy(queue_new);
odp_queue_destroy(queue);
odp_queue_destroy(default_queue);
odp_pktio_close(pktio);
@@ -734,5 +840,7 @@ odp_testinfo_t classification_suite_pmr[] = {
ODP_TEST_INFO(classification_test_pmr_term_udp_dport),
ODP_TEST_INFO(classification_test_pmr_term_udp_sport),
ODP_TEST_INFO(classification_test_pmr_term_ipproto),
+ ODP_TEST_INFO(classification_test_pmr_pool_set),
+ ODP_TEST_INFO(classification_test_pmr_queue_set),
ODP_TEST_INFO_NULL,
};
diff --git a/test/validation/classification/odp_classification_tests.c
b/test/validation/classification/odp_classification_tests.c
index b64d841..99242d0 100644
--- a/test/validation/classification/odp_classification_tests.c
+++ b/test/validation/classification/odp_classification_tests.c
@@ -25,7 +25,6 @@ odp_atomic_u32_t seq;
int classification_suite_init(void)
{
- odp_pool_param_t param;
odp_queue_t inq_def;
odp_queue_param_t qparam;
char queuename[ODP_QUEUE_NAME_LEN];
@@ -33,13 +32,7 @@ int classification_suite_init(void)
int ret;
odp_pktio_param_t pktio_param;
- odp_pool_param_init(¶m);
- param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- param.pkt.len = SHM_PKT_BUF_SIZE;
- param.pkt.num = SHM_PKT_NUM_BUFS;
- param.type = ODP_POOL_PACKET;
-
- pool_default = odp_pool_create("classification_pool", ¶m);
+ pool_default = pool_create("classification_pool");
if (ODP_POOL_INVALID == pool_default) {
fprintf(stderr, "Packet pool creation failed.\n");
return -1;
@@ -55,6 +48,7 @@ int classification_suite_init(void)
fprintf(stderr, "unable to destroy pool.\n");
return -1;
}
+
odp_queue_param_init(&qparam);
qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qparam.sched.sync = ODP_SCHED_SYNC_ATOMIC;
@@ -136,16 +130,13 @@ void configure_cls_pmr_chain(void)
int retval;
char cosname[ODP_QUEUE_NAME_LEN];
odp_queue_param_t qparam;
- odp_pool_param_t pool_param;
+ odp_cls_cos_param_t cls_param;
char queuename[ODP_QUEUE_NAME_LEN];
char poolname[ODP_POOL_NAME_LEN];
uint32_t addr;
uint32_t mask;
odp_pmr_match_t match;
- sprintf(cosname, "SrcCos");
- cos_list[CLS_PMR_CHAIN_SRC] = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_SRC] != ODP_COS_INVALID);
odp_queue_param_init(&qparam);
qparam.sched.prio = ODP_SCHED_PRIO_NORMAL;
@@ -160,27 +151,18 @@ void configure_cls_pmr_chain(void)
CU_ASSERT_FATAL(queue_list[CLS_PMR_CHAIN_SRC] != ODP_QUEUE_INVALID);
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
sprintf(poolname, "%s", "SrcPool");
-
- pool_list[CLS_PMR_CHAIN_SRC] = odp_pool_create(poolname, &pool_param);
+ pool_list[CLS_PMR_CHAIN_SRC] = pool_create(poolname);
CU_ASSERT_FATAL(pool_list[CLS_PMR_CHAIN_SRC] != ODP_POOL_INVALID);
- retval = odp_cos_queue_set(cos_list[CLS_PMR_CHAIN_SRC],
- queue_list[CLS_PMR_CHAIN_SRC]);
- CU_ASSERT(retval == 0);
-
- retval = odp_cls_cos_pool_set(cos_list[CLS_PMR_CHAIN_SRC],
- pool_list[CLS_PMR_CHAIN_SRC]);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "SrcCos");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool_list[CLS_PMR_CHAIN_SRC];
+ cls_param.queue = queue_list[CLS_PMR_CHAIN_SRC];
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_list[CLS_PMR_CHAIN_SRC] = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_SRC] != ODP_COS_INVALID);
- sprintf(cosname, "DstCos");
- cos_list[CLS_PMR_CHAIN_DST] = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_DST] != ODP_COS_INVALID);
odp_queue_param_init(&qparam);
qparam.sched.prio = ODP_SCHED_PRIO_NORMAL;
@@ -193,23 +175,17 @@ void configure_cls_pmr_chain(void)
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_PMR_CHAIN_DST] != ODP_QUEUE_INVALID);
- retval = odp_cos_queue_set(cos_list[CLS_PMR_CHAIN_DST],
- queue_list[CLS_PMR_CHAIN_DST]);
- CU_ASSERT(retval == 0);
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
sprintf(poolname, "%s", "DstPool");
-
- pool_list[CLS_PMR_CHAIN_DST] = odp_pool_create(poolname, &pool_param);
+ pool_list[CLS_PMR_CHAIN_DST] = pool_create(poolname);
CU_ASSERT_FATAL(pool_list[CLS_PMR_CHAIN_DST] != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos_list[CLS_PMR_CHAIN_DST],
- pool_list[CLS_PMR_CHAIN_DST]);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "DstCos");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool_list[CLS_PMR_CHAIN_DST];
+ cls_param.queue = queue_list[CLS_PMR_CHAIN_DST];
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_list[CLS_PMR_CHAIN_DST] = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_DST] != ODP_COS_INVALID);
parse_ipv4_string(CLS_PMR_CHAIN_SADDR, &addr, &mask);
match.term = ODP_PMR_SIP_ADDR;
@@ -296,15 +272,11 @@ void configure_pktio_default_cos(void)
{
int retval;
odp_queue_param_t qparam;
- odp_pool_param_t pool_param;
+ odp_cls_cos_param_t cls_param;
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
char poolname[ODP_POOL_NAME_LEN];
- sprintf(cosname, "DefaultCoS");
- cos_list[CLS_DEFAULT] = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos_list[CLS_DEFAULT] != ODP_COS_INVALID);
-
odp_queue_param_init(&qparam);
qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
@@ -314,23 +286,17 @@ void configure_pktio_default_cos(void)
ODP_QUEUE_TYPE_SCHED, &qparam);
CU_ASSERT_FATAL(queue_list[CLS_DEFAULT] != ODP_QUEUE_INVALID);
- retval = odp_cos_queue_set(cos_list[CLS_DEFAULT],
- queue_list[CLS_DEFAULT]);
- CU_ASSERT(retval == 0);
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
sprintf(poolname, "DefaultPool");
-
- pool_list[CLS_DEFAULT] = odp_pool_create(poolname, &pool_param);
+ pool_list[CLS_DEFAULT] = pool_create(poolname);
CU_ASSERT_FATAL(pool_list[CLS_DEFAULT] != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos_list[CLS_DEFAULT],
- pool_list[CLS_DEFAULT]);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "DefaultCoS");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool_list[CLS_DEFAULT];
+ cls_param.queue = queue_list[CLS_DEFAULT];
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_list[CLS_DEFAULT] = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos_list[CLS_DEFAULT] != ODP_COS_INVALID);
retval = odp_pktio_default_cos_set(pktio_loop, cos_list[CLS_DEFAULT]);
CU_ASSERT(retval == 0);
@@ -364,7 +330,7 @@ void configure_pktio_error_cos(void)
{
int retval;
odp_queue_param_t qparam;
- odp_pool_param_t pool_param;
+ odp_cls_cos_param_t cls_param;
char queuename[ODP_QUEUE_NAME_LEN];
char cosname[ODP_COS_NAME_LEN];
char poolname[ODP_POOL_NAME_LEN];
@@ -380,26 +346,17 @@ void configure_pktio_error_cos(void)
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_ERROR] != ODP_QUEUE_INVALID);
- sprintf(cosname, "%s", "ErrorCos");
- cos_list[CLS_ERROR] = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos_list[CLS_ERROR] != ODP_COS_INVALID);
-
- retval = odp_cos_queue_set(cos_list[CLS_ERROR], queue_list[CLS_ERROR]);
- CU_ASSERT(retval == 0);
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
sprintf(poolname, "ErrorPool");
-
- pool_list[CLS_ERROR] = odp_pool_create(poolname, &pool_param);
+ pool_list[CLS_ERROR] = pool_create(poolname);
CU_ASSERT_FATAL(pool_list[CLS_ERROR] != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos_list[CLS_ERROR],
- pool_list[CLS_ERROR]);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "%s", "ErrorCos");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool_list[CLS_ERROR];
+ cls_param.queue = queue_list[CLS_ERROR];
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_list[CLS_ERROR] = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos_list[CLS_ERROR] != ODP_COS_INVALID);
retval = odp_pktio_error_cos_set(pktio_loop, cos_list[CLS_ERROR]);
CU_ASSERT(retval == 0);
@@ -471,14 +428,7 @@ void configure_cos_with_l2_priority(void)
int retval;
int i;
odp_queue_param_t qparam;
- odp_pool_param_t pool_param;
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
-
+ odp_cls_cos_param_t cls_param;
/** Initialize scalar variable qos_tbl **/
for (i = 0; i < CLS_L2_QOS_MAX; i++)
@@ -489,32 +439,31 @@ void configure_cos_with_l2_priority(void)
qparam.sched.group = ODP_SCHED_GROUP_ALL;
for (i = 0; i < num_qos; i++) {
qparam.sched.prio = ODP_SCHED_PRIO_LOWEST - i;
- sprintf(cosname, "%s_%d", "L2_Cos", i);
- cos_tbl[i] = odp_cos_create(cosname);
- if (cos_tbl[i] == ODP_COS_INVALID)
- break;
-
- cos_list[CLS_L2_QOS_0 + i] = cos_tbl[i];
sprintf(queuename, "%s_%d", "L2_Queue", i);
queue_tbl[i] = odp_queue_create(queuename, ODP_QUEUE_TYPE_SCHED,
&qparam);
CU_ASSERT_FATAL(queue_tbl[i] != ODP_QUEUE_INVALID);
queue_list[CLS_L2_QOS_0 + i] = queue_tbl[i];
- retval = odp_cos_queue_set(cos_tbl[i], queue_tbl[i]);
- CU_ASSERT(retval == 0);
-
sprintf(poolname, "%s_%d", "L2_Pool", i);
- pool = odp_pool_create(poolname, &pool_param);
+ pool = pool_create(poolname);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
pool_list[CLS_L2_QOS_0 + i] = pool;
- retval = odp_cls_cos_pool_set(cos_tbl[i], pool);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "%s_%d", "L2_Cos", i);
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue_tbl[i];
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_tbl[i] = odp_cls_cos_create(cosname, &cls_param);
+ if (cos_tbl[i] == ODP_COS_INVALID)
+ break;
+
+ cos_list[CLS_L2_QOS_0 + i] = cos_tbl[i];
qos_tbl[i] = i;
}
/* count 'i' is passed instead of num_qos to handle the rare scenario
- if the odp_cos_create() failed in the middle*/
+ if the odp_cls_cos_create() failed in the middle*/
retval = odp_cos_with_l2_priority(pktio_loop, i, qos_tbl, cos_tbl);
CU_ASSERT(retval == 0);
}
@@ -554,10 +503,10 @@ void configure_pmr_cos(void)
int retval;
odp_pmr_match_t match;
odp_queue_param_t qparam;
+ odp_cls_cos_param_t cls_param;
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
char poolname[ODP_POOL_NAME_LEN];
- odp_pool_param_t pool_param;
val = CLS_PMR_SPORT;
mask = 0xffff;
@@ -569,10 +518,6 @@ void configure_pmr_cos(void)
pmr_list[CLS_PMR] = odp_pmr_create(&match);
CU_ASSERT(pmr_list[CLS_PMR] != ODP_PMR_INVAL);
- sprintf(cosname, "PMR_CoS");
- cos_list[CLS_PMR] = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos_list[CLS_PMR] != ODP_COS_INVALID);
-
odp_queue_param_init(&qparam);
qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
@@ -584,22 +529,17 @@ void configure_pmr_cos(void)
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_PMR] != ODP_QUEUE_INVALID);
- retval = odp_cos_queue_set(cos_list[CLS_PMR],
- queue_list[CLS_PMR]);
- CU_ASSERT(retval == 0);
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
sprintf(poolname, "PMR_Pool");
-
- pool_list[CLS_PMR] = odp_pool_create(poolname, &pool_param);
+ pool_list[CLS_PMR] = pool_create(poolname);
CU_ASSERT_FATAL(pool_list[CLS_PMR] != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos_list[CLS_PMR], pool_list[CLS_PMR]);
- CU_ASSERT(retval == 0);
+ sprintf(cosname, "PMR_CoS");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool_list[CLS_PMR];
+ cls_param.queue = queue_list[CLS_PMR];
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_list[CLS_PMR] = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos_list[CLS_PMR] != ODP_COS_INVALID);
retval = odp_pktio_pmr_cos(pmr_list[CLS_PMR], pktio_loop,
cos_list[CLS_PMR]);
@@ -637,10 +577,10 @@ void configure_pktio_pmr_match_set_cos(void)
uint16_t maskport;
int num_terms = 2; /* one pmr for each L3 and L4 */
odp_queue_param_t qparam;
+ odp_cls_cos_param_t cls_param;
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
char poolname[ODP_POOL_NAME_LEN];
- odp_pool_param_t pool_param;
uint32_t addr = 0;
uint32_t mask;
@@ -661,10 +601,6 @@ void configure_pktio_pmr_match_set_cos(void)
retval = odp_pmr_match_set_create(num_terms, pmr_terms, &pmr_set);
CU_ASSERT(retval > 0);
- sprintf(cosname, "cos_pmr_set");
- cos_list[CLS_PMR_SET] = odp_cos_create(cosname);
- CU_ASSERT_FATAL(cos_list[CLS_PMR_SET] != ODP_COS_INVALID);
-
odp_queue_param_init(&qparam);
qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
@@ -676,22 +612,17 @@ void configure_pktio_pmr_match_set_cos(void)
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_PMR_SET] != ODP_QUEUE_INVALID);
- retval = odp_cos_queue_set(cos_list[CLS_PMR_SET],
- queue_list[CLS_PMR_SET]);
- CU_ASSERT(retval == 0);
-
- odp_pool_param_init(&pool_param);
- pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.len = SHM_PKT_BUF_SIZE;
- pool_param.pkt.num = SHM_PKT_NUM_BUFS;
- pool_param.type = ODP_POOL_PACKET;
sprintf(poolname, "cos_pmr_set_pool");
-
- pool_list[CLS_PMR_SET] = odp_pool_create(poolname, &pool_param);
+ pool_list[CLS_PMR_SET] = pool_create(poolname);
CU_ASSERT_FATAL(pool_list[CLS_PMR_SET] != ODP_POOL_INVALID);
- retval = odp_cls_cos_pool_set(cos_list[CLS_PMR_SET],
- pool_list[CLS_PMR_SET]);
- CU_ASSERT(retval == 0);
+
+ sprintf(cosname, "cos_pmr_set");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool_list[CLS_PMR_SET];
+ cls_param.queue = queue_list[CLS_PMR_SET];
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+ cos_list[CLS_PMR_SET] = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos_list[CLS_PMR_SET] != ODP_COS_INVALID);
retval = odp_pktio_pmr_match_set_cos(pmr_set, pktio_loop,
cos_list[CLS_PMR_SET]);
diff --git a/test/validation/classification/odp_classification_testsuites.h
b/test/validation/classification/odp_classification_testsuites.h
index a09067c..02828e1 100644
--- a/test/validation/classification/odp_classification_testsuites.h
+++ b/test/validation/classification/odp_classification_testsuites.h
@@ -31,7 +31,8 @@ void configure_default_cos(odp_pktio_t pktio, odp_cos_t *cos,
int parse_ipv4_string(const char *ipaddress, uint32_t *addr, uint32_t *mask);
void enqueue_pktio_interface(odp_packet_t pkt, odp_pktio_t pktio);
odp_packet_t receive_packet(odp_queue_t *queue, uint64_t ns);
-odp_queue_t queue_create(char *queuename, bool sched);
+odp_pool_t pool_create(const char *poolname);
+odp_queue_t queue_create(const char *queuename, bool sched);
void configure_pktio_default_cos(void);
void test_pktio_default_cos(void);
void configure_pktio_error_cos(void);
--
1.9.1
_______________________________________________
lng-odp mailing list
lng-odp@lists.linaro.org
https://lists.linaro.org/mailman/listinfo/lng-odp
