DPDK patches and discussions
 help / color / mirror / Atom feed
* [dpdk-dev] [PATCH 1/3] lib/librte_flow_classify: remove table id parameter from apis
@ 2017-11-23 11:32 Jasvinder Singh
  2017-11-23 11:32 ` [dpdk-dev] [PATCH 2/3] lib/librte_flow_classy: add run api for flow classification Jasvinder Singh
                   ` (3 more replies)
  0 siblings, 4 replies; 41+ messages in thread
From: Jasvinder Singh @ 2017-11-23 11:32 UTC (permalink / raw)
  To: dev; +Cc: bernard.iremonger

This patch removes table id parameter from all the flow
classify apis to reduce the complexity and and does some
cleanup of the code.

The validate api has been exposed as public api to allows
user to validate the flow before adding it to the
classifier.

The sample app and unit tests have been updated to accomodate
the apis changes.

Signed-off-by: Jasvinder Singh <jasvinder.singh@intel.com>
---
 examples/flow_classify/flow_classify.c             |  27 +-
 lib/librte_flow_classify/rte_flow_classify.c       | 320 +++++++++++----------
 lib/librte_flow_classify/rte_flow_classify.h       |  74 +++--
 lib/librte_flow_classify/rte_flow_classify_parse.c | 118 ++++----
 lib/librte_flow_classify/rte_flow_classify_parse.h |  16 +-
 .../rte_flow_classify_version.map                  |   1 +
 test/test/test_flow_classify.c                     |  86 +++---
 test/test/test_flow_classify.h                     |  10 +-
 8 files changed, 365 insertions(+), 287 deletions(-)

diff --git a/examples/flow_classify/flow_classify.c b/examples/flow_classify/flow_classify.c
index 766f1dd..37e6904 100644
--- a/examples/flow_classify/flow_classify.c
+++ b/examples/flow_classify/flow_classify.c
@@ -94,7 +94,6 @@ static const struct rte_eth_conf port_conf_default = {
 
 struct flow_classifier {
 	struct rte_flow_classifier *cls;
-	uint32_t table_id[RTE_FLOW_CLASSIFY_TABLE_MAX];
 };
 
 struct flow_classifier_acl {
@@ -195,7 +194,15 @@ static struct rte_flow_item  end_item = { RTE_FLOW_ITEM_TYPE_END,
 /* sample actions:
  * "actions count / end"
  */
-static struct rte_flow_action count_action = { RTE_FLOW_ACTION_TYPE_COUNT, 0};
+struct rte_flow_query_count count = {
+	.reset = 1,
+	.hits_set = 1,
+	.bytes_set = 1,
+	.hits = 0,
+	.bytes = 0,
+};
+static struct rte_flow_action count_action = { RTE_FLOW_ACTION_TYPE_COUNT,
+	&count};
 static struct rte_flow_action end_action = { RTE_FLOW_ACTION_TYPE_END, 0};
 static struct rte_flow_action actions[2];
 
@@ -274,7 +281,7 @@ lcore_main(struct flow_classifier *cls_app)
 	int i = 0;
 
 	ret = rte_flow_classify_table_entry_delete(cls_app->cls,
-			cls_app->table_id[0], rules[7]);
+			rules[7]);
 	if (ret)
 		printf("table_entry_delete failed [7] %d\n\n", ret);
 	else
@@ -317,7 +324,6 @@ lcore_main(struct flow_classifier *cls_app)
 				if (rules[i]) {
 					ret = rte_flow_classifier_query(
 						cls_app->cls,
-						cls_app->table_id[0],
 						bufs, nb_rx, rules[i],
 						&classify_stats);
 					if (ret)
@@ -635,8 +641,8 @@ add_classify_rule(struct rte_eth_ntuple_filter *ntuple_filter,
 	actions[1] = end_action;
 
 	rule = rte_flow_classify_table_entry_add(
-			cls_app->cls, cls_app->table_id[0], &key_found,
-			&attr, pattern_ipv4_5tuple, actions, &error);
+			cls_app->cls, &attr, pattern_ipv4_5tuple,
+			actions, &key_found, &error);
 	if (rule == NULL) {
 		printf("table entry add failed ipv4_proto = %u\n",
 			ipv4_proto);
@@ -809,7 +815,6 @@ main(int argc, char *argv[])
 
 	cls_params.name = "flow_classifier";
 	cls_params.socket_id = socket_id;
-	cls_params.type = RTE_FLOW_CLASSIFY_TABLE_TYPE_ACL;
 
 	cls_app->cls = rte_flow_classifier_create(&cls_params);
 	if (cls_app->cls == NULL) {
@@ -824,11 +829,11 @@ main(int argc, char *argv[])
 	memcpy(table_acl_params.field_format, ipv4_defs, sizeof(ipv4_defs));
 
 	/* initialise table create params */
-	cls_table_params.ops = &rte_table_acl_ops,
-	cls_table_params.arg_create = &table_acl_params,
+	cls_table_params.ops = &rte_table_acl_ops;
+	cls_table_params.arg_create = &table_acl_params;
+	cls_table_params.type = RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE;
 
-	ret = rte_flow_classify_table_create(cls_app->cls, &cls_table_params,
-			&cls_app->table_id[0]);
+	ret = rte_flow_classify_table_create(cls_app->cls, &cls_table_params);
 	if (ret) {
 		rte_flow_classifier_free(cls_app->cls);
 		rte_free(cls_app);
diff --git a/lib/librte_flow_classify/rte_flow_classify.c b/lib/librte_flow_classify/rte_flow_classify.c
index e6f4486..ff1bc86 100644
--- a/lib/librte_flow_classify/rte_flow_classify.c
+++ b/lib/librte_flow_classify/rte_flow_classify.c
@@ -39,16 +39,20 @@
 
 int librte_flow_classify_logtype;
 
-static struct rte_eth_ntuple_filter ntuple_filter;
 static uint32_t unique_id = 1;
 
+enum rte_flow_classify_table_type table_type
+	= RTE_FLOW_CLASSIFY_TABLE_TYPE_NONE;
 
 struct rte_flow_classify_table_entry {
 	/* meta-data for classify rule */
 	uint32_t rule_id;
+
+	/* Flow action */
+	struct classify_action action;
 };
 
-struct rte_table {
+struct rte_cls_table {
 	/* Input parameters */
 	struct rte_table_ops ops;
 	uint32_t entry_size;
@@ -64,11 +68,16 @@ struct rte_flow_classifier {
 	/* Input parameters */
 	char name[RTE_FLOW_CLASSIFIER_MAX_NAME_SZ];
 	int socket_id;
-	enum rte_flow_classify_table_type type;
 
-	/* Internal tables */
-	struct rte_table tables[RTE_FLOW_CLASSIFY_TABLE_MAX];
+	/* Internal */
+	/* ntuple_fliter */
+	struct rte_eth_ntuple_filter ntuple_filter;
+
+	/* clasifier tables */
+	struct rte_cls_table tables[RTE_FLOW_CLASSIFY_TABLE_MAX];
+	uint32_t table_mask;
 	uint32_t num_tables;
+
 	uint16_t nb_pkts;
 	struct rte_flow_classify_table_entry
 		*entries[RTE_PORT_IN_BURST_SIZE_MAX];
@@ -97,18 +106,19 @@ struct classify_rules {
 
 struct rte_flow_classify_rule {
 	uint32_t id; /* unique ID of classify rule */
-	struct rte_flow_action action; /* action when match found */
+	enum rte_flow_classify_table_type tbl_type; /* rule table */
 	struct classify_rules rules; /* union of rules */
 	union {
 		struct acl_keys key;
 	} u;
 	int key_found;   /* rule key found in table */
-	void *entry;     /* pointer to buffer to hold rule meta data */
+	struct rte_flow_classify_table_entry entry;  /* rule meta data */
 	void *entry_ptr; /* handle to the table entry for rule meta data */
 };
 
-static int
-flow_classify_parse_flow(
+int
+rte_flow_classify_validate(
+		   struct rte_flow_classifier *cls,
 		   const struct rte_flow_attr *attr,
 		   const struct rte_flow_item pattern[],
 		   const struct rte_flow_action actions[],
@@ -120,7 +130,42 @@ flow_classify_parse_flow(
 	uint32_t i = 0;
 	int ret;
 
-	memset(&ntuple_filter, 0, sizeof(ntuple_filter));
+	if (cls == NULL) {
+		RTE_FLOW_CLASSIFY_LOG(ERR,
+			"%s: rte_flow_classifier parameter is NULL\n",
+			__func__);
+		return -EINVAL;
+	}
+
+	if (!attr) {
+		rte_flow_error_set(error, EINVAL,
+				   RTE_FLOW_ERROR_TYPE_ATTR,
+				   NULL, "NULL attribute.");
+		return -EINVAL;
+	}
+
+	if (!pattern) {
+		rte_flow_error_set(error,
+			EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
+			NULL, "NULL pattern.");
+		return -EINVAL;
+	}
+
+	if (!actions) {
+		rte_flow_error_set(error, EINVAL,
+				   RTE_FLOW_ERROR_TYPE_ACTION_NUM,
+				   NULL, "NULL action.");
+		return -EINVAL;
+	}
+
+	if (!error) {
+		rte_flow_error_set(error, EINVAL,
+				   RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
+				   NULL, "NULL error.");
+		return -EINVAL;
+	}
+
+	memset(&cls->ntuple_filter, 0, sizeof(cls->ntuple_filter));
 
 	/* Get the non-void item number of pattern */
 	while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
@@ -150,7 +195,7 @@ flow_classify_parse_flow(
 		return -EINVAL;
 	}
 
-	ret = parse_filter(attr, items, actions, &ntuple_filter, error);
+	ret = parse_filter(attr, items, actions, &cls->ntuple_filter, error);
 	free(items);
 	return ret;
 }
@@ -275,17 +320,14 @@ rte_flow_classifier_create(struct rte_flow_classifier_params *params)
 	/* Save input parameters */
 	snprintf(cls->name, RTE_FLOW_CLASSIFIER_MAX_NAME_SZ, "%s",
 			params->name);
-	cls->socket_id = params->socket_id;
-	cls->type = params->type;
 
-	/* Initialize flow classifier internal data structure */
-	cls->num_tables = 0;
+	cls->socket_id = params->socket_id;
 
 	return cls;
 }
 
 static void
-rte_flow_classify_table_free(struct rte_table *table)
+rte_flow_classify_table_free(struct rte_cls_table *table)
 {
 	if (table->ops.f_free != NULL)
 		table->ops.f_free(table->h_table);
@@ -306,7 +348,7 @@ rte_flow_classifier_free(struct rte_flow_classifier *cls)
 
 	/* Free tables */
 	for (i = 0; i < cls->num_tables; i++) {
-		struct rte_table *table = &cls->tables[i];
+		struct rte_cls_table *table = &cls->tables[i];
 
 		rte_flow_classify_table_free(table);
 	}
@@ -319,8 +361,7 @@ rte_flow_classifier_free(struct rte_flow_classifier *cls)
 
 static int
 rte_table_check_params(struct rte_flow_classifier *cls,
-		struct rte_flow_classify_table_params *params,
-		uint32_t *table_id)
+		struct rte_flow_classify_table_params *params)
 {
 	if (cls == NULL) {
 		RTE_FLOW_CLASSIFY_LOG(ERR,
@@ -333,11 +374,6 @@ rte_table_check_params(struct rte_flow_classifier *cls,
 			__func__);
 		return -EINVAL;
 	}
-	if (table_id == NULL) {
-		RTE_FLOW_CLASSIFY_LOG(ERR, "%s: table_id parameter is NULL\n",
-			__func__);
-		return -EINVAL;
-	}
 
 	/* ops */
 	if (params->ops == NULL) {
@@ -371,22 +407,18 @@ rte_table_check_params(struct rte_flow_classifier *cls,
 
 int
 rte_flow_classify_table_create(struct rte_flow_classifier *cls,
-	struct rte_flow_classify_table_params *params,
-	uint32_t *table_id)
+	struct rte_flow_classify_table_params *params)
 {
-	struct rte_table *table;
+	struct rte_cls_table *table;
 	void *h_table;
-	uint32_t entry_size, id;
+	uint32_t entry_size;
 	int ret;
 
 	/* Check input arguments */
-	ret = rte_table_check_params(cls, params, table_id);
+	ret = rte_table_check_params(cls, params);
 	if (ret != 0)
 		return ret;
 
-	id = cls->num_tables;
-	table = &cls->tables[id];
-
 	/* calculate table entry size */
 	entry_size = sizeof(struct rte_flow_classify_table_entry);
 
@@ -400,8 +432,9 @@ rte_flow_classify_table_create(struct rte_flow_classifier *cls,
 	}
 
 	/* Commit current table to the classifier */
+	table = &cls->tables[cls->num_tables];
+	table->type = params->type;
 	cls->num_tables++;
-	*table_id = id;
 
 	/* Save input parameters */
 	memcpy(&table->ops, params->ops, sizeof(struct rte_table_ops));
@@ -414,7 +447,7 @@ rte_flow_classify_table_create(struct rte_flow_classifier *cls,
 }
 
 static struct rte_flow_classify_rule *
-allocate_acl_ipv4_5tuple_rule(void)
+allocate_acl_ipv4_5tuple_rule(struct rte_flow_classifier *cls)
 {
 	struct rte_flow_classify_rule *rule;
 	int log_level;
@@ -427,45 +460,44 @@ allocate_acl_ipv4_5tuple_rule(void)
 	rule->id = unique_id++;
 	rule->rules.type = RTE_FLOW_CLASSIFY_RULE_TYPE_IPV4_5TUPLE;
 
-	memcpy(&rule->action, classify_get_flow_action(),
-	       sizeof(struct rte_flow_action));
-
 	/* key add values */
-	rule->u.key.key_add.priority = ntuple_filter.priority;
+	rule->u.key.key_add.priority = cls->ntuple_filter.priority;
 	rule->u.key.key_add.field_value[PROTO_FIELD_IPV4].mask_range.u8 =
-			ntuple_filter.proto_mask;
+			cls->ntuple_filter.proto_mask;
 	rule->u.key.key_add.field_value[PROTO_FIELD_IPV4].value.u8 =
-			ntuple_filter.proto;
-	rule->rules.u.ipv4_5tuple.proto = ntuple_filter.proto;
-	rule->rules.u.ipv4_5tuple.proto_mask = ntuple_filter.proto_mask;
+			cls->ntuple_filter.proto;
+	rule->rules.u.ipv4_5tuple.proto = cls->ntuple_filter.proto;
+	rule->rules.u.ipv4_5tuple.proto_mask = cls->ntuple_filter.proto_mask;
 
 	rule->u.key.key_add.field_value[SRC_FIELD_IPV4].mask_range.u32 =
-			ntuple_filter.src_ip_mask;
+			cls->ntuple_filter.src_ip_mask;
 	rule->u.key.key_add.field_value[SRC_FIELD_IPV4].value.u32 =
-			ntuple_filter.src_ip;
-	rule->rules.u.ipv4_5tuple.src_ip_mask = ntuple_filter.src_ip_mask;
-	rule->rules.u.ipv4_5tuple.src_ip = ntuple_filter.src_ip;
+			cls->ntuple_filter.src_ip;
+	rule->rules.u.ipv4_5tuple.src_ip_mask = cls->ntuple_filter.src_ip_mask;
+	rule->rules.u.ipv4_5tuple.src_ip = cls->ntuple_filter.src_ip;
 
 	rule->u.key.key_add.field_value[DST_FIELD_IPV4].mask_range.u32 =
-			ntuple_filter.dst_ip_mask;
+			cls->ntuple_filter.dst_ip_mask;
 	rule->u.key.key_add.field_value[DST_FIELD_IPV4].value.u32 =
-			ntuple_filter.dst_ip;
-	rule->rules.u.ipv4_5tuple.dst_ip_mask = ntuple_filter.dst_ip_mask;
-	rule->rules.u.ipv4_5tuple.dst_ip = ntuple_filter.dst_ip;
+			cls->ntuple_filter.dst_ip;
+	rule->rules.u.ipv4_5tuple.dst_ip_mask = cls->ntuple_filter.dst_ip_mask;
+	rule->rules.u.ipv4_5tuple.dst_ip = cls->ntuple_filter.dst_ip;
 
 	rule->u.key.key_add.field_value[SRCP_FIELD_IPV4].mask_range.u16 =
-			ntuple_filter.src_port_mask;
+			cls->ntuple_filter.src_port_mask;
 	rule->u.key.key_add.field_value[SRCP_FIELD_IPV4].value.u16 =
-			ntuple_filter.src_port;
-	rule->rules.u.ipv4_5tuple.src_port_mask = ntuple_filter.src_port_mask;
-	rule->rules.u.ipv4_5tuple.src_port = ntuple_filter.src_port;
+			cls->ntuple_filter.src_port;
+	rule->rules.u.ipv4_5tuple.src_port_mask =
+			cls->ntuple_filter.src_port_mask;
+	rule->rules.u.ipv4_5tuple.src_port = cls->ntuple_filter.src_port;
 
 	rule->u.key.key_add.field_value[DSTP_FIELD_IPV4].mask_range.u16 =
-			ntuple_filter.dst_port_mask;
+			cls->ntuple_filter.dst_port_mask;
 	rule->u.key.key_add.field_value[DSTP_FIELD_IPV4].value.u16 =
-			ntuple_filter.dst_port;
-	rule->rules.u.ipv4_5tuple.dst_port_mask = ntuple_filter.dst_port_mask;
-	rule->rules.u.ipv4_5tuple.dst_port = ntuple_filter.dst_port;
+			cls->ntuple_filter.dst_port;
+	rule->rules.u.ipv4_5tuple.dst_port_mask =
+			cls->ntuple_filter.dst_port_mask;
+	rule->rules.u.ipv4_5tuple.dst_port = cls->ntuple_filter.dst_port;
 
 	log_level = rte_log_get_level(librte_flow_classify_logtype);
 
@@ -485,34 +517,18 @@ allocate_acl_ipv4_5tuple_rule(void)
 
 struct rte_flow_classify_rule *
 rte_flow_classify_table_entry_add(struct rte_flow_classifier *cls,
-		uint32_t table_id,
-		int *key_found,
 		const struct rte_flow_attr *attr,
 		const struct rte_flow_item pattern[],
 		const struct rte_flow_action actions[],
+		int *key_found,
 		struct rte_flow_error *error)
 {
 	struct rte_flow_classify_rule *rule;
 	struct rte_flow_classify_table_entry *table_entry;
+	struct classify_action *action;
+	uint32_t i;
 	int ret;
 
-	if (!error)
-		return NULL;
-
-	if (!cls) {
-		rte_flow_error_set(error, EINVAL,
-				RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
-				NULL, "NULL classifier.");
-		return NULL;
-	}
-
-	if (table_id >= cls->num_tables) {
-		rte_flow_error_set(error, EINVAL,
-				RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
-				NULL, "invalid table_id.");
-		return NULL;
-	}
-
 	if (key_found == NULL) {
 		rte_flow_error_set(error, EINVAL,
 				RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
@@ -520,91 +536,95 @@ rte_flow_classify_table_entry_add(struct rte_flow_classifier *cls,
 		return NULL;
 	}
 
-	if (!pattern) {
-		rte_flow_error_set(error, EINVAL,
-				RTE_FLOW_ERROR_TYPE_ITEM_NUM,
-				NULL, "NULL pattern.");
-		return NULL;
-	}
-
-	if (!actions) {
-		rte_flow_error_set(error, EINVAL,
-				RTE_FLOW_ERROR_TYPE_ACTION_NUM,
-				NULL, "NULL action.");
-		return NULL;
-	}
-
-	if (!attr) {
-		rte_flow_error_set(error, EINVAL,
-				RTE_FLOW_ERROR_TYPE_ATTR,
-				NULL, "NULL attribute.");
-		return NULL;
-	}
-
 	/* parse attr, pattern and actions */
-	ret = flow_classify_parse_flow(attr, pattern, actions, error);
+	ret = rte_flow_classify_validate(cls, attr, pattern, actions, error);
 	if (ret < 0)
 		return NULL;
 
-	switch (cls->type) {
-	case RTE_FLOW_CLASSIFY_TABLE_TYPE_ACL:
-		rule = allocate_acl_ipv4_5tuple_rule();
+	switch (table_type) {
+	case RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE:
+		rule = allocate_acl_ipv4_5tuple_rule(cls);
 		if (!rule)
 			return NULL;
+		rule->tbl_type = table_type;
+		cls->table_mask |= table_type;
 		break;
 	default:
 		return NULL;
 	}
 
-	rule->entry = malloc(sizeof(struct rte_flow_classify_table_entry));
-	if (!rule->entry) {
-		free(rule);
-		return NULL;
-	}
-
-	table_entry = rule->entry;
+	action = classify_get_flow_action();
+	table_entry = &rule->entry;
 	table_entry->rule_id = rule->id;
+	table_entry->action.action_mask = action->action_mask;
 
-	if (cls->tables[table_id].ops.f_add != NULL) {
-		ret = cls->tables[table_id].ops.f_add(
-			cls->tables[table_id].h_table,
-			&rule->u.key.key_add,
-			rule->entry,
-			&rule->key_found,
-			&rule->entry_ptr);
-		if (ret) {
-			free(rule->entry);
-			free(rule);
-			return NULL;
+	/* Copy actions */
+	if (action->action_mask & (1LLU << RTE_FLOW_ACTION_TYPE_COUNT)) {
+		memcpy(&table_entry->action.act.counter, &action->act.counter,
+				sizeof(table_entry->action.act.counter));
+	}
+	if (action->action_mask & (1LLU << RTE_FLOW_ACTION_TYPE_MARK)) {
+		memcpy(&table_entry->action.act.mark, &action->act.mark,
+				sizeof(table_entry->action.act.mark));
+	}
+
+	for (i = 0; i < cls->num_tables; i++) {
+		struct rte_cls_table *table = &cls->tables[i];
+
+		if (table->type == table_type) {
+			if (table->ops.f_add != NULL) {
+				ret = table->ops.f_add(
+					table->h_table,
+					&rule->u.key.key_add,
+					&rule->entry,
+					&rule->key_found,
+					&rule->entry_ptr);
+				if (ret) {
+					free(rule);
+					return NULL;
+				}
+
+			*key_found = rule->key_found;
+			}
+
+			return rule;
 		}
-		*key_found = rule->key_found;
 	}
-	return rule;
+	return NULL;
 }
 
 int
 rte_flow_classify_table_entry_delete(struct rte_flow_classifier *cls,
-		uint32_t table_id,
 		struct rte_flow_classify_rule *rule)
 {
+	uint32_t i;
 	int ret = -EINVAL;
 
-	if (!cls || !rule || table_id >= cls->num_tables)
+	if (!cls || !rule)
 		return ret;
+	enum rte_flow_classify_table_type tbl_type = rule->tbl_type;
 
-	if (cls->tables[table_id].ops.f_delete != NULL)
-		ret = cls->tables[table_id].ops.f_delete(
-			cls->tables[table_id].h_table,
-			&rule->u.key.key_del,
-			&rule->key_found,
-			&rule->entry);
+	for (i = 0; i < cls->num_tables; i++) {
+		struct rte_cls_table *table = &cls->tables[i];
 
+		if (table->type == tbl_type) {
+			if (table->ops.f_delete != NULL) {
+				ret = table->ops.f_delete(table->h_table,
+						&rule->u.key.key_del,
+						&rule->key_found,
+						&rule->entry);
+
+				return ret;
+			}
+		}
+	}
+	free(rule);
 	return ret;
 }
 
 static int
 flow_classifier_lookup(struct rte_flow_classifier *cls,
-		uint32_t table_id,
+		struct rte_cls_table *table,
 		struct rte_mbuf **pkts,
 		const uint16_t nb_pkts)
 {
@@ -613,8 +633,7 @@ flow_classifier_lookup(struct rte_flow_classifier *cls,
 	uint64_t lookup_hit_mask;
 
 	pkts_mask = RTE_LEN2MASK(nb_pkts, uint64_t);
-	ret = cls->tables[table_id].ops.f_lookup(
-		cls->tables[table_id].h_table,
+	ret = table->ops.f_lookup(table->h_table,
 		pkts, pkts_mask, &lookup_hit_mask,
 		(void **)cls->entries);
 
@@ -632,12 +651,12 @@ action_apply(struct rte_flow_classifier *cls,
 		struct rte_flow_classify_stats *stats)
 {
 	struct rte_flow_classify_ipv4_5tuple_stats *ntuple_stats;
+	struct rte_flow_classify_table_entry *entry = &rule->entry;
 	uint64_t count = 0;
-	int i;
-	int ret = -EINVAL;
+	uint32_t action_mask = entry->action.action_mask;
+	int i, ret = -EINVAL;
 
-	switch (rule->action.type) {
-	case RTE_FLOW_ACTION_TYPE_COUNT:
+	if (action_mask & (1LLU << RTE_FLOW_ACTION_TYPE_COUNT)) {
 		for (i = 0; i < cls->nb_pkts; i++) {
 			if (rule->id == cls->entries[i]->rule_id)
 				count++;
@@ -650,32 +669,37 @@ action_apply(struct rte_flow_classifier *cls,
 			ntuple_stats->counter1 = count;
 			ntuple_stats->ipv4_5tuple = rule->rules.u.ipv4_5tuple;
 		}
-		break;
-	default:
-		ret = -ENOTSUP;
-		break;
 	}
-
 	return ret;
 }
 
 int
 rte_flow_classifier_query(struct rte_flow_classifier *cls,
-		uint32_t table_id,
 		struct rte_mbuf **pkts,
 		const uint16_t nb_pkts,
 		struct rte_flow_classify_rule *rule,
 		struct rte_flow_classify_stats *stats)
 {
+	enum rte_flow_classify_table_type tbl_type;
+	uint32_t i;
 	int ret = -EINVAL;
 
-	if (!cls || !rule || !stats || !pkts  || nb_pkts == 0 ||
-		table_id >= cls->num_tables)
+	if (!cls || !rule || !stats || !pkts  || nb_pkts == 0)
 		return ret;
 
-	ret = flow_classifier_lookup(cls, table_id, pkts, nb_pkts);
-	if (!ret)
-		ret = action_apply(cls, rule, stats);
+	tbl_type = rule->tbl_type;
+	for (i = 0; i < cls->num_tables; i++) {
+		struct rte_cls_table *table = &cls->tables[i];
+
+			if (table->type == tbl_type) {
+				ret = flow_classifier_lookup(cls, table,
+						pkts, nb_pkts);
+				if (!ret) {
+					ret = action_apply(cls, rule, stats);
+					return ret;
+				}
+			}
+	}
 	return ret;
 }
 
diff --git a/lib/librte_flow_classify/rte_flow_classify.h b/lib/librte_flow_classify/rte_flow_classify.h
index 1211873..b9b669f 100644
--- a/lib/librte_flow_classify/rte_flow_classify.h
+++ b/lib/librte_flow_classify/rte_flow_classify.h
@@ -86,6 +86,10 @@ extern int librte_flow_classify_logtype;
 rte_log(RTE_LOG_ ## level, librte_flow_classify_logtype, "%s(): " fmt, \
 	__func__, ## args)
 
+#ifndef RTE_FLOW_CLASSIFY_TABLE_MAX
+#define RTE_FLOW_CLASSIFY_TABLE_MAX		32
+#endif
+
 /** Opaque data type for flow classifier */
 struct rte_flow_classifier;
 
@@ -102,17 +106,16 @@ enum rte_flow_classify_rule_type {
 
 /** Flow classify table type */
 enum rte_flow_classify_table_type {
-	/** no type */
-	RTE_FLOW_CLASSIFY_TABLE_TYPE_NONE,
-	/** ACL type */
-	RTE_FLOW_CLASSIFY_TABLE_TYPE_ACL,
-};
+	/** No type */
+	RTE_FLOW_CLASSIFY_TABLE_TYPE_NONE = 1 << 0,
+	/** ACL IP4 5TUPLE */
+	RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE = 1 << 1,
+	/** ACL VLAN IP4 5TUPLE */
+	RTE_FLOW_CLASSIFY_TABLE_ACL_VLAN_IP4_5TUPLE = 1 << 2,
+	/** ACL QinQ IP4 5TUPLE */
+	RTE_FLOW_CLASSIFY_TABLE_ACL_QINQ_IP4_5TUPLE = 1 << 3,
 
-/**
- * Maximum number of tables allowed for any Flow Classifier instance.
- * The value of this parameter cannot be changed.
- */
-#define RTE_FLOW_CLASSIFY_TABLE_MAX  64
+};
 
 /** Parameters for flow classifier creation */
 struct rte_flow_classifier_params {
@@ -122,9 +125,6 @@ struct rte_flow_classifier_params {
 	/** CPU socket ID where memory for the flow classifier and its */
 	/** elements (tables) should be allocated */
 	int socket_id;
-
-	/** Table type */
-	enum rte_flow_classify_table_type type;
 };
 
 /** Parameters for table creation */
@@ -134,6 +134,9 @@ struct rte_flow_classify_table_params {
 
 	/** Opaque param to be passed to the table create operation */
 	void *arg_create;
+
+	/** Classifier table type */
+	enum rte_flow_classify_table_type type;
 };
 
 /** IPv4 5-tuple data */
@@ -197,32 +200,50 @@ rte_flow_classifier_free(struct rte_flow_classifier *cls);
  *   Handle to flow classifier instance
  * @param params
  *   Parameters for flow_classify table creation
- * @param table_id
- *   Table ID. Valid only within the scope of table IDs of the current
- *   classifier. Only returned after a successful invocation.
  * @return
  *   0 on success, error code otherwise
  */
 int
 rte_flow_classify_table_create(struct rte_flow_classifier *cls,
-		struct rte_flow_classify_table_params *params,
-		uint32_t *table_id);
+		struct rte_flow_classify_table_params *params);
+
+/**
+ * Flow classify validate
+ *
+ * @param cls
+ *   Handle to flow classifier instance
+ * @param[in] attr
+ *   Flow rule attributes
+ * @param[in] pattern
+ *   Pattern specification (list terminated by the END pattern item).
+ * @param[in] actions
+ *   Associated actions (list terminated by the END pattern item).
+ * @param[out] error
+ *   Perform verbose error reporting if not NULL. Structure
+ *   initialised in case of error only.
+ * @return
+ *   0 on success, error code otherwise
+ */
+int
+rte_flow_classify_validate(struct rte_flow_classifier *cls,
+		const struct rte_flow_attr *attr,
+		const struct rte_flow_item pattern[],
+		const struct rte_flow_action actions[],
+		struct rte_flow_error *error);
 
 /**
  * Add a flow classify rule to the flow_classifer table.
  *
  * @param[in] cls
  *   Flow classifier handle
- * @param[in] table_id
- *   id of table
- * @param[out] key_found
- *  returns 1 if key present already, 0 otherwise.
  * @param[in] attr
  *   Flow rule attributes
  * @param[in] pattern
  *   Pattern specification (list terminated by the END pattern item).
  * @param[in] actions
  *   Associated actions (list terminated by the END pattern item).
+ * @param[out] key_found
+ *  returns 1 if rule present already, 0 otherwise.
  * @param[out] error
  *   Perform verbose error reporting if not NULL. Structure
  *   initialised in case of error only.
@@ -231,11 +252,10 @@ rte_flow_classify_table_create(struct rte_flow_classifier *cls,
  */
 struct rte_flow_classify_rule *
 rte_flow_classify_table_entry_add(struct rte_flow_classifier *cls,
-		uint32_t table_id,
-		int *key_found,
 		const struct rte_flow_attr *attr,
 		const struct rte_flow_item pattern[],
 		const struct rte_flow_action actions[],
+		int *key_found,
 		struct rte_flow_error *error);
 
 /**
@@ -243,8 +263,6 @@ rte_flow_classify_table_entry_add(struct rte_flow_classifier *cls,
  *
  * @param[in] cls
  *   Flow classifier handle
- * @param[in] table_id
- *   id of table
  * @param[in] rule
  *   Flow classify rule
  * @return
@@ -252,7 +270,6 @@ rte_flow_classify_table_entry_add(struct rte_flow_classifier *cls,
  */
 int
 rte_flow_classify_table_entry_delete(struct rte_flow_classifier *cls,
-		uint32_t table_id,
 		struct rte_flow_classify_rule *rule);
 
 /**
@@ -260,8 +277,6 @@ rte_flow_classify_table_entry_delete(struct rte_flow_classifier *cls,
  *
  * @param[in] cls
  *   Flow classifier handle
- * @param[in] table_id
- *   id of table
  * @param[in] pkts
  *   Pointer to packets to process
  * @param[in] nb_pkts
@@ -276,7 +291,6 @@ rte_flow_classify_table_entry_delete(struct rte_flow_classifier *cls,
  */
 int
 rte_flow_classifier_query(struct rte_flow_classifier *cls,
-		uint32_t table_id,
 		struct rte_mbuf **pkts,
 		const uint16_t nb_pkts,
 		struct rte_flow_classify_rule *rule,
diff --git a/lib/librte_flow_classify/rte_flow_classify_parse.c b/lib/librte_flow_classify/rte_flow_classify_parse.c
index dbfa111..9fb3e51 100644
--- a/lib/librte_flow_classify/rte_flow_classify_parse.c
+++ b/lib/librte_flow_classify/rte_flow_classify_parse.c
@@ -40,7 +40,7 @@ struct classify_valid_pattern {
 	parse_filter_t parse_filter;
 };
 
-static struct rte_flow_action action;
+static struct classify_action action;
 
 /* Pattern for IPv4 5-tuple UDP filter */
 static enum rte_flow_item_type pattern_ntuple_1[] = {
@@ -80,7 +80,7 @@ static struct classify_valid_pattern classify_supported_patterns[] = {
 	{ pattern_ntuple_3, classify_parse_ntuple_filter },
 };
 
-struct rte_flow_action *
+struct classify_action *
 classify_get_flow_action(void)
 {
 	return &action;
@@ -244,28 +244,10 @@ classify_parse_ntuple_filter(const struct rte_flow_attr *attr,
 	const struct rte_flow_item_udp *udp_mask;
 	const struct rte_flow_item_sctp *sctp_spec;
 	const struct rte_flow_item_sctp *sctp_mask;
+	const struct rte_flow_action_count *count;
+	const struct rte_flow_action_mark *mark_spec;
 	uint32_t index;
 
-	if (!pattern) {
-		rte_flow_error_set(error,
-			EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
-			NULL, "NULL pattern.");
-		return -EINVAL;
-	}
-
-	if (!actions) {
-		rte_flow_error_set(error, EINVAL,
-				   RTE_FLOW_ERROR_TYPE_ACTION_NUM,
-				   NULL, "NULL action.");
-		return -EINVAL;
-	}
-	if (!attr) {
-		rte_flow_error_set(error, EINVAL,
-				   RTE_FLOW_ERROR_TYPE_ATTR,
-				   NULL, "NULL attribute.");
-		return -EINVAL;
-	}
-
 	/* parse pattern */
 	index = 0;
 
@@ -483,34 +465,7 @@ classify_parse_ntuple_filter(const struct rte_flow_attr *attr,
 		return -EINVAL;
 	}
 
-	/* parse action */
-	index = 0;
-
-	/**
-	 * n-tuple only supports count,
-	 * check if the first not void action is COUNT.
-	 */
-	memset(&action, 0, sizeof(action));
-	NEXT_ITEM_OF_ACTION(act, actions, index);
-	if (act->type != RTE_FLOW_ACTION_TYPE_COUNT) {
-		memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
-		rte_flow_error_set(error, EINVAL,
-			RTE_FLOW_ERROR_TYPE_ACTION,
-			item, "Not supported action.");
-		return -EINVAL;
-	}
-	action.type = RTE_FLOW_ACTION_TYPE_COUNT;
-
-	/* check if the next not void item is END */
-	index++;
-	NEXT_ITEM_OF_ACTION(act, actions, index);
-	if (act->type != RTE_FLOW_ACTION_TYPE_END) {
-		memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
-		rte_flow_error_set(error, EINVAL,
-			RTE_FLOW_ERROR_TYPE_ACTION,
-			act, "Not supported action.");
-		return -EINVAL;
-	}
+	table_type = RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE;
 
 	/* parse attr */
 	/* must be input direction */
@@ -542,5 +497,68 @@ classify_parse_ntuple_filter(const struct rte_flow_attr *attr,
 	if (attr->priority >  FLOW_RULE_MIN_PRIORITY)
 		filter->priority = FLOW_RULE_MAX_PRIORITY;
 
+	/* parse action */
+	index = 0;
+
+	/**
+	 * n-tuple only supports count and Mark,
+	 * check if the first not void action is COUNT or MARK.
+	 */
+	memset(&action, 0, sizeof(action));
+	NEXT_ITEM_OF_ACTION(act, actions, index);
+	switch (act->type) {
+	case RTE_FLOW_ACTION_TYPE_COUNT:
+		action.action_mask |= 1LLU << RTE_FLOW_ACTION_TYPE_COUNT;
+		count = (const struct rte_flow_action_count *)act->conf;
+		memcpy(&action.act.counter, count, sizeof(action.act.counter));
+		break;
+	case RTE_FLOW_ACTION_TYPE_MARK:
+		action.action_mask |= 1LLU << RTE_FLOW_ACTION_TYPE_MARK;
+		mark_spec = (const struct rte_flow_action_mark *)act->conf;
+		memcpy(&action.act.mark, mark_spec, sizeof(action.act.mark));
+		break;
+	default:
+		memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
+		rte_flow_error_set(error, EINVAL,
+		   RTE_FLOW_ERROR_TYPE_ACTION, act,
+		   "Invalid action.");
+		return -EINVAL;
+	}
+
+	/* check if the next not void item is MARK or COUNT or END */
+	index++;
+	NEXT_ITEM_OF_ACTION(act, actions, index);
+	switch (act->type) {
+	case RTE_FLOW_ACTION_TYPE_COUNT:
+		action.action_mask |= 1LLU << RTE_FLOW_ACTION_TYPE_COUNT;
+		count = (const struct rte_flow_action_count *)act->conf;
+		memcpy(&action.act.counter, count, sizeof(action.act.counter));
+		break;
+	case RTE_FLOW_ACTION_TYPE_MARK:
+		action.action_mask |= 1LLU << RTE_FLOW_ACTION_TYPE_MARK;
+		mark_spec = (const struct rte_flow_action_mark *)act->conf;
+		memcpy(&action.act.mark, mark_spec, sizeof(action.act.mark));
+		break;
+	case RTE_FLOW_ACTION_TYPE_END:
+		return 0;
+	default:
+		memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
+		rte_flow_error_set(error, EINVAL,
+		   RTE_FLOW_ERROR_TYPE_ACTION, act,
+		   "Invalid action.");
+		return -EINVAL;
+	}
+
+	/* check if the next not void item is END */
+	index++;
+	NEXT_ITEM_OF_ACTION(act, actions, index);
+	if (act->type != RTE_FLOW_ACTION_TYPE_END) {
+		memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
+		rte_flow_error_set(error, EINVAL,
+		   RTE_FLOW_ERROR_TYPE_ACTION, act,
+		   "Invalid action.");
+		return -EINVAL;
+	}
+
 	return 0;
 }
diff --git a/lib/librte_flow_classify/rte_flow_classify_parse.h b/lib/librte_flow_classify/rte_flow_classify_parse.h
index 1d4708a..9c1de72 100644
--- a/lib/librte_flow_classify/rte_flow_classify_parse.h
+++ b/lib/librte_flow_classify/rte_flow_classify_parse.h
@@ -43,6 +43,20 @@
 extern "C" {
 #endif
 
+extern enum rte_flow_classify_table_type table_type;
+
+struct classify_action {
+	/* Flow action mask */
+	uint64_t action_mask;
+
+	struct action {
+		/** Integer value to return with packets */
+		struct rte_flow_action_mark mark;
+		/** Flow rule counter */
+		struct rte_flow_query_count counter;
+	} act;
+};
+
 typedef int (*parse_filter_t)(const struct rte_flow_attr *attr,
 			      const struct rte_flow_item pattern[],
 			      const struct rte_flow_action actions[],
@@ -64,7 +78,7 @@ parse_filter_t
 classify_find_parse_filter_func(struct rte_flow_item *pattern);
 
 /* get action data */
-struct rte_flow_action *
+struct classify_action *
 classify_get_flow_action(void);
 
 #ifdef __cplusplus
diff --git a/lib/librte_flow_classify/rte_flow_classify_version.map b/lib/librte_flow_classify/rte_flow_classify_version.map
index f7695cb..49bc25c 100644
--- a/lib/librte_flow_classify/rte_flow_classify_version.map
+++ b/lib/librte_flow_classify/rte_flow_classify_version.map
@@ -7,6 +7,7 @@ EXPERIMENTAL {
 	rte_flow_classify_table_create;
 	rte_flow_classify_table_entry_add;
 	rte_flow_classify_table_entry_delete;
+	rte_flow_classify_validate;
 
 	local: *;
 };
diff --git a/test/test/test_flow_classify.c b/test/test/test_flow_classify.c
index 9f331cd..4ddf4c0 100644
--- a/test/test/test_flow_classify.c
+++ b/test/test/test_flow_classify.c
@@ -51,16 +51,10 @@
 
 
 #define FLOW_CLASSIFY_MAX_RULE_NUM 100
-struct flow_classifier *cls;
-
-struct flow_classifier {
-	struct rte_flow_classifier *cls;
-	uint32_t table_id[RTE_FLOW_CLASSIFY_TABLE_MAX];
-	uint32_t n_tables;
-};
+struct flow_classifier_acl *cls;
 
 struct flow_classifier_acl {
-	struct flow_classifier cls;
+	struct rte_flow_classifier *cls;
 } __rte_cache_aligned;
 
 /*
@@ -73,7 +67,7 @@ test_invalid_parameters(void)
 	struct rte_flow_classify_rule *rule;
 	int ret;
 
-	rule = rte_flow_classify_table_entry_add(NULL, 1, NULL, NULL, NULL,
+	rule = rte_flow_classify_table_entry_add(NULL, NULL, NULL, NULL,
 			NULL, NULL);
 	if (rule) {
 		printf("Line %i: flow_classifier_table_entry_add", __LINE__);
@@ -81,7 +75,7 @@ test_invalid_parameters(void)
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(NULL, 1, NULL);
+	ret = rte_flow_classify_table_entry_delete(NULL, NULL);
 	if (!ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -89,14 +83,14 @@ test_invalid_parameters(void)
 		return -1;
 	}
 
-	ret = rte_flow_classifier_query(NULL, 1, NULL, 0, NULL, NULL);
+	ret = rte_flow_classifier_query(NULL, NULL, 0, NULL, NULL);
 	if (!ret) {
 		printf("Line %i: flow_classifier_query", __LINE__);
 		printf(" with NULL param should have failed!\n");
 		return -1;
 	}
 
-	rule = rte_flow_classify_table_entry_add(NULL, 1, NULL, NULL, NULL,
+	rule = rte_flow_classify_table_entry_add(NULL, NULL, NULL, NULL,
 		NULL, &error);
 	if (rule) {
 		printf("Line %i: flow_classify_table_entry_add ", __LINE__);
@@ -104,7 +98,7 @@ test_invalid_parameters(void)
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(NULL, 1, NULL);
+	ret = rte_flow_classify_table_entry_delete(NULL, NULL);
 	if (!ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -112,7 +106,7 @@ test_invalid_parameters(void)
 		return -1;
 	}
 
-	ret = rte_flow_classifier_query(NULL, 1, NULL, 0, NULL, NULL);
+	ret = rte_flow_classifier_query(NULL, NULL, 0, NULL, NULL);
 	if (!ret) {
 		printf("Line %i: flow_classifier_query", __LINE__);
 		printf(" with NULL param should have failed!\n");
@@ -142,15 +136,16 @@ test_valid_parameters(void)
 	actions[0] = count_action;
 	actions[1] = end_action;
 
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
+
 	if (!rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should not have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -183,15 +178,15 @@ test_invalid_patterns(void)
 
 	pattern[0] = eth_item;
 	pattern[1] = ipv4_udp_item_bad;
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
 	if (rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (!ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -202,15 +197,15 @@ test_invalid_patterns(void)
 	pattern[1] = ipv4_udp_item_1;
 	pattern[2] = udp_item_bad;
 	pattern[3] = end_item_bad;
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
 	if (rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (!ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -241,15 +236,15 @@ test_invalid_actions(void)
 	actions[0] = count_action_bad;
 	actions[1] = end_action;
 
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
 	if (rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (!ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -260,15 +255,15 @@ test_invalid_actions(void)
 	actions[0] = count_action;
 	actions[1] = end_action_bad;
 
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
 	if (rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (!ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -462,15 +457,15 @@ test_query_udp(void)
 	actions[0] = count_action;
 	actions[1] = end_action;
 
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
 	if (!rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should not have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classifier_query(cls->cls, 0, bufs, MAX_PKT_BURST,
+	ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 			rule, &udp_classify_stats);
 	if (ret) {
 		printf("Line %i: flow_classifier_query", __LINE__);
@@ -478,7 +473,7 @@ test_query_udp(void)
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -520,15 +515,15 @@ test_query_tcp(void)
 	actions[0] = count_action;
 	actions[1] = end_action;
 
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
 	if (!rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should not have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classifier_query(cls->cls, 0, bufs, MAX_PKT_BURST,
+	ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 			rule, &tcp_classify_stats);
 	if (ret) {
 		printf("Line %i: flow_classifier_query", __LINE__);
@@ -536,7 +531,7 @@ test_query_tcp(void)
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -578,15 +573,15 @@ test_query_sctp(void)
 	actions[0] = count_action;
 	actions[1] = end_action;
 
-	rule = rte_flow_classify_table_entry_add(cls->cls, 0, &key_found,
-			&attr, pattern, actions, &error);
+	rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
+			actions, &key_found, &error);
 	if (!rule) {
 		printf("Line %i: flow_classify_table_entry_add", __LINE__);
 		printf(" should not have failed!\n");
 		return -1;
 	}
 
-	ret = rte_flow_classifier_query(cls->cls, 0, bufs, MAX_PKT_BURST,
+	ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 			rule, &sctp_classify_stats);
 	if (ret) {
 		printf("Line %i: flow_classifier_query", __LINE__);
@@ -594,7 +589,7 @@ test_query_sctp(void)
 		return -1;
 	}
 
-	ret = rte_flow_classify_table_entry_delete(cls->cls, 0, rule);
+	ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 	if (ret) {
 		printf("Line %i: rte_flow_classify_table_entry_delete",
 			__LINE__);
@@ -622,7 +617,6 @@ test_flow_classify(void)
 
 	cls_params.name = "flow_classifier";
 	cls_params.socket_id = socket_id;
-	cls_params.type = RTE_FLOW_CLASSIFY_TABLE_TYPE_ACL;
 	cls->cls = rte_flow_classifier_create(&cls_params);
 
 	/* initialise ACL table params */
@@ -632,11 +626,11 @@ test_flow_classify(void)
 	memcpy(table_acl_params.field_format, ipv4_defs, sizeof(ipv4_defs));
 
 	/* initialise table create params */
-	cls_table_params.ops = &rte_table_acl_ops,
-	cls_table_params.arg_create = &table_acl_params,
+	cls_table_params.ops = &rte_table_acl_ops;
+	cls_table_params.arg_create = &table_acl_params;
+	cls_table_params.type = RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE;
 
-	ret = rte_flow_classify_table_create(cls->cls, &cls_table_params,
-			&cls->table_id[0]);
+	ret = rte_flow_classify_table_create(cls->cls, &cls_table_params);
 	if (ret) {
 		printf("Line %i: f_create has failed!\n", __LINE__);
 		rte_flow_classifier_free(cls->cls);
diff --git a/test/test/test_flow_classify.h b/test/test/test_flow_classify.h
index 39535cf..af293ed 100644
--- a/test/test/test_flow_classify.h
+++ b/test/test/test_flow_classify.h
@@ -197,7 +197,15 @@ static struct rte_flow_item  sctp_item_1 = { RTE_FLOW_ITEM_TYPE_SCTP,
 /* test actions:
  * "actions count / end"
  */
-static struct rte_flow_action count_action = { RTE_FLOW_ACTION_TYPE_COUNT, 0};
+struct rte_flow_query_count count = {
+	.reset = 1,
+	.hits_set = 1,
+	.bytes_set = 1,
+	.hits = 0,
+	.bytes = 0,
+};
+static struct rte_flow_action count_action = { RTE_FLOW_ACTION_TYPE_COUNT,
+	&count};
 static struct rte_flow_action count_action_bad = { -1, 0};
 
 static struct rte_flow_action end_action = { RTE_FLOW_ACTION_TYPE_END, 0};
-- 
2.9.3

^ permalink raw reply	[flat|nested] 41+ messages in thread

end of thread, other threads:[~2018-01-11 18:21 UTC | newest]

Thread overview: 41+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2017-11-23 11:32 [dpdk-dev] [PATCH 1/3] lib/librte_flow_classify: remove table id parameter from apis Jasvinder Singh
2017-11-23 11:32 ` [dpdk-dev] [PATCH 2/3] lib/librte_flow_classy: add run api for flow classification Jasvinder Singh
2017-12-04 16:46   ` Iremonger, Bernard
2017-12-05 11:01     ` Iremonger, Bernard
2017-12-06 12:41       ` Iremonger, Bernard
2017-12-11 15:52         ` Singh, Jasvinder
2017-11-23 11:32 ` [dpdk-dev] [PATCH 3/3] doc: update documentation for flow classify lib Jasvinder Singh
2017-12-06 12:04   ` Iremonger, Bernard
2017-12-11 14:54   ` Mcnamara, John
2017-12-11 15:53     ` Singh, Jasvinder
2017-12-04 16:45 ` [dpdk-dev] [PATCH 1/3] lib/librte_flow_classify: remove table id parameter from apis Iremonger, Bernard
2017-12-05 10:59   ` Iremonger, Bernard
2017-12-06 12:34     ` Iremonger, Bernard
2017-12-11 15:51       ` Singh, Jasvinder
2017-12-11 16:26 ` [dpdk-dev] [PATCH v2 1/4] " Jasvinder Singh
2017-12-11 16:26   ` [dpdk-dev] [PATCH v2 2/4] test/test_flow_classify: update test to accomodate changes Jasvinder Singh
2017-12-11 16:26   ` [dpdk-dev] [PATCH v2 3/4] examples/flow_classify: update sample application Jasvinder Singh
2017-12-14 14:42     ` Iremonger, Bernard
2017-12-11 16:26   ` [dpdk-dev] [PATCH v2 4/4] doc: update documentation for flow classify lib Jasvinder Singh
2017-12-14 14:49     ` Iremonger, Bernard
2017-12-15 10:39   ` [dpdk-dev] [PATCH v3 1/4] lib/librte_flow_classify: remove table id parameter from apis Jasvinder Singh
2017-12-15 10:39     ` [dpdk-dev] [PATCH v3 2/4] test/test_flow_classify: update test to accommodate changes Jasvinder Singh
2017-12-19 12:06       ` Iremonger, Bernard
2017-12-15 10:39     ` [dpdk-dev] [PATCH v3 3/4] examples/flow_classify: update sample application Jasvinder Singh
2017-12-19 12:09       ` Iremonger, Bernard
2017-12-15 10:39     ` [dpdk-dev] [PATCH v3 4/4] doc: update documentation for flow classify lib Jasvinder Singh
2017-12-18 11:04       ` Kovacevic, Marko
2017-12-18 13:40         ` Singh, Jasvinder
2017-12-19 12:13           ` Iremonger, Bernard
2017-12-19 12:03     ` [dpdk-dev] [PATCH v3 1/4] lib/librte_flow_classify: remove table id parameter from apis Iremonger, Bernard
2017-12-19 14:29     ` [dpdk-dev] [PATCH v4 " Jasvinder Singh
2017-12-19 14:29       ` [dpdk-dev] [PATCH v4 2/4] test/test_flow_classify: update test to accommodate changes Jasvinder Singh
2017-12-19 14:29       ` [dpdk-dev] [PATCH v4 3/4] examples/flow_classify: update sample application Jasvinder Singh
2017-12-19 14:29       ` [dpdk-dev] [PATCH v4 4/4] doc: update documentation for flow classify lib Jasvinder Singh
2018-01-10  0:19       ` [dpdk-dev] [PATCH v4 1/4] lib/librte_flow_classify: remove table id parameter from apis Thomas Monjalon
2018-01-10  9:54         ` Singh, Jasvinder
2018-01-10 10:52           ` Thomas Monjalon
2018-01-10 10:59             ` Singh, Jasvinder
2018-01-10 11:07               ` Thomas Monjalon
2018-01-10 11:12                 ` Singh, Jasvinder
2018-01-11 18:20       ` Thomas Monjalon

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).