[PATCH v2 4/4] net/ice: implement flow dump

[Anatoly Burakov]

Implement flow dumping API.

Signed-off-by: Anatoly Burakov <anatoly.burakov at intel.com>
---
 drivers/net/intel/ice/ice_acl_filter.c    |  2 +
 drivers/net/intel/ice/ice_fdir_filter.c   |  2 +
 drivers/net/intel/ice/ice_generic_flow.c  | 77 +++++++++++++++++++++++
 drivers/net/intel/ice/ice_generic_flow.h  |  2 +
 drivers/net/intel/ice/ice_hash.c          |  2 +
 drivers/net/intel/ice/ice_switch_filter.c |  2 +
 6 files changed, 87 insertions(+)

diff --git a/drivers/net/intel/ice/ice_acl_filter.c b/drivers/net/intel/ice/ice_acl_filter.c
index 6754a40044..3939579598 100644
--- a/drivers/net/intel/ice/ice_acl_filter.c
+++ b/drivers/net/intel/ice/ice_acl_filter.c
@@ -1099,7 +1099,9 @@ ice_flow_engine ice_acl_engine = {
 	.create = ice_acl_create_filter,
 	.destroy = ice_acl_destroy_filter,
 	.free = ice_acl_filter_free,
+	.name = "acl",
 	.type = ICE_FLOW_ENGINE_ACL,
+	.rule_size = sizeof(struct acl_rule),
 };
 
 struct
diff --git a/drivers/net/intel/ice/ice_fdir_filter.c b/drivers/net/intel/ice/ice_fdir_filter.c
index ce80213429..f2b1a3a841 100644
--- a/drivers/net/intel/ice/ice_fdir_filter.c
+++ b/drivers/net/intel/ice/ice_fdir_filter.c
@@ -1688,7 +1688,9 @@ static struct ice_flow_engine ice_fdir_engine = {
 	.create = ice_fdir_create_filter,
 	.destroy = ice_fdir_destroy_filter,
 	.query_count = ice_fdir_query_count,
+	.name = "fdir",
 	.type = ICE_FLOW_ENGINE_FDIR,
+	.rule_size = sizeof(struct ice_fdir_filter_conf),
 };
 
 static int
diff --git a/drivers/net/intel/ice/ice_generic_flow.c b/drivers/net/intel/ice/ice_generic_flow.c
index 62f0c334a1..924caca94b 100644
--- a/drivers/net/intel/ice/ice_generic_flow.c
+++ b/drivers/net/intel/ice/ice_generic_flow.c
@@ -13,6 +13,7 @@
 
 #include <rte_ether.h>
 #include <ethdev_driver.h>
+#include <rte_hexdump.h>
 #include <rte_malloc.h>
 #include <rte_tailq.h>
 
@@ -46,6 +47,10 @@ static int ice_flow_query(struct rte_eth_dev *dev,
 		const struct rte_flow_action *actions,
 		void *data,
 		struct rte_flow_error *error);
+static int ice_flow_dev_dump(struct rte_eth_dev *dev,
+		struct rte_flow *flow,
+		FILE *file,
+		struct rte_flow_error *error);
 
 const struct rte_flow_ops ice_flow_ops = {
 	.validate = ice_flow_validate,
@@ -53,6 +58,7 @@ const struct rte_flow_ops ice_flow_ops = {
 	.destroy = ice_flow_destroy,
 	.flush = ice_flow_flush,
 	.query = ice_flow_query,
+	.dev_dump = ice_flow_dev_dump,
 };
 
 /* empty */
@@ -2649,6 +2655,77 @@ ice_flow_query(struct rte_eth_dev *dev,
 	return ret;
 }
 
+#define ICE_FLOW_DUMP_CHUNK_BYTES 32
+
+static void
+ice_flow_dump_blob(FILE *file, const char *engine,
+		   const void *data, size_t data_len)
+{
+	const uint8_t *raw = (const uint8_t *)data;
+	const size_t nchunks =
+		(data_len + ICE_FLOW_DUMP_CHUNK_BYTES - 1) /
+		ICE_FLOW_DUMP_CHUNK_BYTES;
+	char title[64];
+	size_t ci;
+
+	fprintf(file, "FLOW DUMP: driver=ice engine=%s\n", engine);
+	fprintf(file, "FLOW DUMP: DATA size=%zu chunks=%zu chunk_bytes=%d\n",
+		data_len, nchunks, ICE_FLOW_DUMP_CHUNK_BYTES);
+
+	for (ci = 0; ci < nchunks; ci++) {
+		const size_t off = ci * ICE_FLOW_DUMP_CHUNK_BYTES;
+		const size_t clen =
+			RTE_MIN((size_t)ICE_FLOW_DUMP_CHUNK_BYTES, data_len - off);
+
+		snprintf(title, sizeof(title), "FLOW DUMP: chunk %03zu/%03zu",
+			 ci + 1, nchunks);
+		rte_memdump(file, title, raw + off, clen);
+	}
+}
+
+static int
+ice_flow_dev_dump(struct rte_eth_dev *dev,
+		  struct rte_flow *flow,
+		  FILE *file,
+		  struct rte_flow_error *error)
+{
+	struct ice_adapter *ad =
+		ICE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
+	struct ice_pf *pf = &ad->pf;
+	struct rte_flow *p_flow;
+	bool found = false;
+
+	rte_spinlock_lock(&pf->flow_ops_lock);
+	TAILQ_FOREACH(p_flow, &pf->flow_list, node) {
+		size_t rule_size = 0;
+		const void *rule_data = NULL;
+
+		if (flow != NULL && p_flow != flow)
+			continue;
+
+		found = true;
+		if (p_flow->engine != NULL) {
+			rule_size = p_flow->engine->rule_size;
+			if (p_flow->rule != NULL)
+				rule_data = p_flow->rule;
+		}
+
+		if (p_flow->engine != NULL)
+			ice_flow_dump_blob(file,
+				p_flow->engine->name != NULL ?
+				p_flow->engine->name : "unknown",
+				rule_data, rule_size);
+	}
+	rte_spinlock_unlock(&pf->flow_ops_lock);
+
+	if (flow != NULL && !found)
+		return rte_flow_error_set(error, ENOENT,
+			RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+			"Flow not found");
+
+	return 0;
+}
+
 int
 ice_flow_redirect(struct ice_adapter *ad,
 		  struct ice_flow_redirect *rd)
diff --git a/drivers/net/intel/ice/ice_generic_flow.h b/drivers/net/intel/ice/ice_generic_flow.h
index c0eed84610..dbb21c47ab 100644
--- a/drivers/net/intel/ice/ice_generic_flow.h
+++ b/drivers/net/intel/ice/ice_generic_flow.h
@@ -539,7 +539,9 @@ struct ice_flow_engine {
 	engine_query_t query_count;
 	engine_redirect_t redirect;
 	engine_free_t free;
+	const char *name;
 	enum ice_flow_engine_type type;
+	size_t rule_size;
 };
 TAILQ_HEAD(ice_engine_list, ice_flow_engine);
 
diff --git a/drivers/net/intel/ice/ice_hash.c b/drivers/net/intel/ice/ice_hash.c
index 77829e607b..835f113e82 100644
--- a/drivers/net/intel/ice/ice_hash.c
+++ b/drivers/net/intel/ice/ice_hash.c
@@ -589,7 +589,9 @@ static struct ice_flow_engine ice_hash_engine = {
 	.destroy = ice_hash_destroy,
 	.uninit = ice_hash_uninit,
 	.free = ice_hash_free,
+	.name = "hash",
 	.type = ICE_FLOW_ENGINE_HASH,
+	.rule_size = sizeof(struct ice_hash_flow_cfg),
 };
 
 /* Register parser for os package. */
diff --git a/drivers/net/intel/ice/ice_switch_filter.c b/drivers/net/intel/ice/ice_switch_filter.c
index b25e5eaad3..2da8c5c3c8 100644
--- a/drivers/net/intel/ice/ice_switch_filter.c
+++ b/drivers/net/intel/ice/ice_switch_filter.c
@@ -2070,7 +2070,9 @@ ice_flow_engine ice_switch_engine = {
 	.query_count = ice_switch_query,
 	.redirect = ice_switch_redirect,
 	.free = ice_switch_filter_rule_free,
+	.name = "switch",
 	.type = ICE_FLOW_ENGINE_SWITCH,
+	.rule_size = sizeof(struct ice_switch_filter_conf),
 };
 
 struct
-- 
2.47.3