[PATCH v2 02/24] net/nfp: add the structures and functions for flow offload

[Chaoyong He <chaoyong.he@corigine.com>]

Add the structures and functions to process mask table, flow
table, and flow stats id, which are used in the rte_flow
offload logics.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower.c |  11 +-
 drivers/net/nfp/meson.build         |   3 +
 drivers/net/nfp/nfp_flow.c          | 507 ++++++++++++++++++++++++++++++++++++
 drivers/net/nfp/nfp_flow.h          |  81 ++++++
 4 files changed, 601 insertions(+), 1 deletion(-)
 create mode 100644 drivers/net/nfp/nfp_flow.c

diff --git a/drivers/net/nfp/flower/nfp_flower.c b/drivers/net/nfp/flower/nfp_flower.c
index 3e97f5c..3b16c12 100644
--- a/drivers/net/nfp/flower/nfp_flower.c
+++ b/drivers/net/nfp/flower/nfp_flower.c
@@ -15,6 +15,7 @@
 #include "../nfp_ctrl.h"
 #include "../nfp_cpp_bridge.h"
 #include "../nfp_rxtx.h"
+#include "../nfp_flow.h"
 #include "../nfpcore/nfp_mip.h"
 #include "../nfpcore/nfp_rtsym.h"
 #include "../nfpcore/nfp_nsp.h"
@@ -1089,13 +1090,19 @@
 
 	pf_dev->app_fw_priv = app_fw_flower;
 
+	ret = nfp_flow_priv_init(pf_dev);
+	if (ret) {
+		PMD_INIT_LOG(ERR, "init flow priv failed");
+		goto app_cleanup;
+	}
+
 	/* Allocate memory for the PF AND ctrl vNIC here (hence the * 2) */
 	pf_hw = rte_zmalloc_socket("nfp_pf_vnic", 2 * sizeof(struct nfp_net_adapter),
 			RTE_CACHE_LINE_SIZE, numa_node);
 	if (pf_hw == NULL) {
 		PMD_INIT_LOG(ERR, "Could not malloc nfp pf vnic");
 		ret = -ENOMEM;
-		goto app_cleanup;
+		goto flow_priv_cleanup;
 	}
 
 	/* Map the PF ctrl bar */
@@ -1173,6 +1180,8 @@
 	nfp_cpp_area_free(pf_dev->ctrl_area);
 vnic_cleanup:
 	rte_free(pf_hw);
+flow_priv_cleanup:
+	nfp_flow_priv_uninit(pf_dev);
 app_cleanup:
 	rte_free(app_fw_flower);
 
diff --git a/drivers/net/nfp/meson.build b/drivers/net/nfp/meson.build
index 8a63979..7416fd3 100644
--- a/drivers/net/nfp/meson.build
+++ b/drivers/net/nfp/meson.build
@@ -27,4 +27,7 @@ sources = files(
         'nfp_cpp_bridge.c',
         'nfp_ethdev_vf.c',
         'nfp_ethdev.c',
+        'nfp_flow.c',
 )
+
+deps += ['hash']
diff --git a/drivers/net/nfp/nfp_flow.c b/drivers/net/nfp/nfp_flow.c
new file mode 100644
index 0000000..97f5d1b
--- /dev/null
+++ b/drivers/net/nfp/nfp_flow.c
@@ -0,0 +1,507 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright (c) 2022 Corigine, Inc.
+ * All rights reserved.
+ */
+
+#include <rte_flow_driver.h>
+#include <rte_hash.h>
+#include <rte_jhash.h>
+#include <bus_pci_driver.h>
+
+#include "nfp_common.h"
+#include "nfp_flow.h"
+#include "nfp_logs.h"
+#include "flower/nfp_flower.h"
+#include "nfpcore/nfp_mip.h"
+#include "nfpcore/nfp_rtsym.h"
+
+struct nfp_mask_id_entry {
+	uint32_t hash_key;
+	uint32_t ref_cnt;
+	uint8_t mask_id;
+};
+
+static int
+nfp_mask_id_alloc(struct nfp_flow_priv *priv, uint8_t *mask_id)
+{
+	uint8_t temp_id;
+	uint8_t freed_id;
+	struct circ_buf *ring;
+
+	/* Checking for unallocated entries first. */
+	if (priv->mask_ids.init_unallocated > 0) {
+		*mask_id = priv->mask_ids.init_unallocated;
+		priv->mask_ids.init_unallocated--;
+		return 0;
+	}
+
+	/* Checking if buffer is empty. */
+	freed_id = NFP_FLOWER_MASK_ENTRY_RS - 1;
+	ring = &priv->mask_ids.free_list;
+	if (ring->head == ring->tail) {
+		*mask_id = freed_id;
+		return -ENOENT;
+	}
+
+	rte_memcpy(&temp_id, &ring->buf[ring->tail], NFP_FLOWER_MASK_ELEMENT_RS);
+	*mask_id = temp_id;
+
+	rte_memcpy(&ring->buf[ring->tail], &freed_id, NFP_FLOWER_MASK_ELEMENT_RS);
+	ring->tail = (ring->tail + NFP_FLOWER_MASK_ELEMENT_RS) %
+			(NFP_FLOWER_MASK_ENTRY_RS * NFP_FLOWER_MASK_ELEMENT_RS);
+
+	return 0;
+}
+
+static int
+nfp_mask_id_free(struct nfp_flow_priv *priv, uint8_t mask_id)
+{
+	struct circ_buf *ring;
+
+	ring = &priv->mask_ids.free_list;
+
+	/* Checking if buffer is full. */
+	if (CIRC_SPACE(ring->head, ring->tail, NFP_FLOWER_MASK_ENTRY_RS) == 0)
+		return -ENOBUFS;
+
+	rte_memcpy(&ring->buf[ring->head], &mask_id, NFP_FLOWER_MASK_ELEMENT_RS);
+	ring->head = (ring->head + NFP_FLOWER_MASK_ELEMENT_RS) %
+			(NFP_FLOWER_MASK_ENTRY_RS * NFP_FLOWER_MASK_ELEMENT_RS);
+
+	return 0;
+}
+
+static int
+nfp_mask_table_add(struct nfp_flow_priv *priv,
+		char *mask_data,
+		uint32_t mask_len,
+		uint8_t *id)
+{
+	int ret;
+	uint8_t mask_id;
+	uint32_t hash_key;
+	struct nfp_mask_id_entry *mask_entry;
+
+	mask_entry = rte_zmalloc("mask_entry", sizeof(struct nfp_mask_id_entry), 0);
+	if (mask_entry == NULL) {
+		ret = -ENOMEM;
+		goto exit;
+	}
+
+	ret = nfp_mask_id_alloc(priv, &mask_id);
+	if (ret != 0)
+		goto mask_entry_free;
+
+	hash_key = rte_jhash(mask_data, mask_len, priv->hash_seed);
+	mask_entry->mask_id  = mask_id;
+	mask_entry->hash_key = hash_key;
+	mask_entry->ref_cnt  = 1;
+	PMD_DRV_LOG(DEBUG, "hash_key=%#x id=%u ref=%u", hash_key,
+			mask_id, mask_entry->ref_cnt);
+
+	ret = rte_hash_add_key_data(priv->mask_table, &hash_key, mask_entry);
+	if (ret != 0) {
+		PMD_DRV_LOG(ERR, "Add to mask table failed.");
+		goto mask_id_free;
+	}
+
+	*id = mask_id;
+	return 0;
+
+mask_id_free:
+	nfp_mask_id_free(priv, mask_id);
+mask_entry_free:
+	rte_free(mask_entry);
+exit:
+	return ret;
+}
+
+static int
+nfp_mask_table_del(struct nfp_flow_priv *priv,
+		char *mask_data,
+		uint32_t mask_len,
+		uint8_t id)
+{
+	int ret;
+	uint32_t hash_key;
+
+	hash_key = rte_jhash(mask_data, mask_len, priv->hash_seed);
+	ret = rte_hash_del_key(priv->mask_table, &hash_key);
+	if (ret < 0) {
+		PMD_DRV_LOG(ERR, "Delete from mask table failed.");
+		return ret;
+	}
+
+	ret = nfp_mask_id_free(priv, id);
+	if (ret != 0) {
+		PMD_DRV_LOG(ERR, "Free mask id failed.");
+		return ret;
+	}
+
+	return 0;
+}
+
+static struct nfp_mask_id_entry *
+nfp_mask_table_search(struct nfp_flow_priv *priv,
+		char *mask_data,
+		uint32_t mask_len)
+{
+	int index;
+	uint32_t hash_key;
+	struct nfp_mask_id_entry *entry;
+
+	hash_key = rte_jhash(mask_data, mask_len, priv->hash_seed);
+	index = rte_hash_lookup_data(priv->mask_table, &hash_key, (void **)&entry);
+	if (index < 0) {
+		PMD_DRV_LOG(DEBUG, "Data NOT found in the mask table.");
+		return NULL;
+	}
+
+	return entry;
+}
+
+__rte_unused static bool
+nfp_check_mask_add(struct nfp_flow_priv *priv,
+		char *mask_data,
+		uint32_t mask_len,
+		uint8_t *meta_flags,
+		uint8_t *mask_id)
+{
+	int ret;
+	struct nfp_mask_id_entry *mask_entry;
+
+	mask_entry = nfp_mask_table_search(priv, mask_data, mask_len);
+	if (mask_entry == NULL) {
+		/* mask entry does not exist, let's create one */
+		ret = nfp_mask_table_add(priv, mask_data, mask_len, mask_id);
+		if (ret != 0)
+			return false;
+
+		*meta_flags |= NFP_FL_META_FLAG_MANAGE_MASK;
+	} else {
+		/* mask entry already exist */
+		mask_entry->ref_cnt++;
+		*mask_id = mask_entry->mask_id;
+	}
+
+	return true;
+}
+
+__rte_unused static bool
+nfp_check_mask_remove(struct nfp_flow_priv *priv,
+		char *mask_data,
+		uint32_t mask_len,
+		uint8_t *meta_flags)
+{
+	int ret;
+	struct nfp_mask_id_entry *mask_entry;
+
+	mask_entry = nfp_mask_table_search(priv, mask_data, mask_len);
+	if (mask_entry == NULL)
+		return false;
+
+	mask_entry->ref_cnt--;
+	if (mask_entry->ref_cnt == 0) {
+		ret = nfp_mask_table_del(priv, mask_data, mask_len,
+				mask_entry->mask_id);
+		if (ret != 0)
+			return false;
+
+		rte_free(mask_entry);
+		if (meta_flags)
+			*meta_flags &= ~NFP_FL_META_FLAG_MANAGE_MASK;
+	}
+
+	return true;
+}
+
+__rte_unused static int
+nfp_flow_table_add(struct nfp_flow_priv *priv,
+		struct rte_flow *nfp_flow)
+{
+	int ret;
+	char *hash_data;
+	uint32_t hash_key;
+
+	hash_data = (char *)(nfp_flow->payload.unmasked_data);
+	hash_key = rte_jhash(hash_data, nfp_flow->length, priv->hash_seed);
+	ret = rte_hash_add_key_data(priv->flow_table, &hash_key, nfp_flow);
+	if (ret != 0) {
+		PMD_DRV_LOG(ERR, "Add to flow table failed.");
+		return ret;
+	}
+
+	return 0;
+}
+
+__rte_unused static int
+nfp_flow_table_delete(struct nfp_flow_priv *priv,
+		struct rte_flow *nfp_flow)
+{
+	int ret;
+	char *hash_data;
+	uint32_t hash_key;
+
+	hash_data = (char *)(nfp_flow->payload.unmasked_data);
+	hash_key = rte_jhash(hash_data, nfp_flow->length, priv->hash_seed);
+	ret = rte_hash_del_key(priv->flow_table, &hash_key);
+	if (ret < 0) {
+		PMD_DRV_LOG(ERR, "Delete from flow table failed.");
+		return ret;
+	}
+
+	return 0;
+}
+
+__rte_unused static struct rte_flow *
+nfp_flow_table_search(struct nfp_flow_priv *priv,
+		struct rte_flow *nfp_flow)
+{
+	int index;
+	char *hash_data;
+	uint32_t hash_key;
+	struct rte_flow *flow_find;
+
+	hash_data = (char *)(nfp_flow->payload.unmasked_data);
+	hash_key = rte_jhash(hash_data, nfp_flow->length, priv->hash_seed);
+	index = rte_hash_lookup_data(priv->flow_table, &hash_key, (void **)&flow_find);
+	if (index < 0) {
+		PMD_DRV_LOG(DEBUG, "Data NOT found in the flow table.");
+		return NULL;
+	}
+
+	return flow_find;
+}
+
+__rte_unused static struct rte_flow *
+nfp_flow_alloc(struct nfp_fl_key_ls *key_layer)
+{
+	char *tmp;
+	size_t len;
+	struct rte_flow *nfp_flow;
+	struct nfp_fl_payload *payload;
+
+	nfp_flow = rte_zmalloc("nfp_flow", sizeof(struct rte_flow), 0);
+	if (nfp_flow == NULL)
+		goto exit;
+
+	len = key_layer->key_size + key_layer->key_size + key_layer->act_size;
+	tmp = rte_zmalloc("nfp_flow_payload", len + sizeof(struct nfp_fl_rule_metadata), 0);
+	if (tmp == NULL)
+		goto free_flow;
+
+	nfp_flow->length = len;
+
+	payload                = &nfp_flow->payload;
+	payload->meta          = (struct nfp_fl_rule_metadata *)tmp;
+	payload->unmasked_data = tmp + sizeof(struct nfp_fl_rule_metadata);
+	payload->mask_data     = payload->unmasked_data + key_layer->key_size;
+	payload->action_data   = payload->mask_data + key_layer->key_size;
+
+	return nfp_flow;
+
+free_flow:
+	rte_free(nfp_flow);
+exit:
+	return NULL;
+}
+
+__rte_unused static void
+nfp_flow_free(struct rte_flow *nfp_flow)
+{
+	rte_free(nfp_flow->payload.meta);
+	rte_free(nfp_flow);
+}
+
+__rte_unused static int
+nfp_stats_id_alloc(struct nfp_flow_priv *priv, uint32_t *ctx)
+{
+	struct circ_buf *ring;
+	uint32_t freed_stats_id;
+	uint32_t temp_stats_id;
+
+	/* Check for unallocated entries first. */
+	if (priv->stats_ids.init_unallocated > 0) {
+		*ctx = ((priv->stats_ids.init_unallocated - 1) & NFP_FL_STAT_ID_STAT) |
+				(priv->active_mem_unit & NFP_FL_STAT_ID_MU_NUM);
+		if (++priv->active_mem_unit == priv->total_mem_units) {
+			priv->stats_ids.init_unallocated--;
+			priv->active_mem_unit = 0;
+		}
+		return 0;
+	}
+
+	/* Check if buffer is empty */
+	ring = &priv->stats_ids.free_list;
+	freed_stats_id = priv->stats_ring_size;
+	if (ring->head == ring->tail) {
+		*ctx = freed_stats_id;
+		return -ENOENT;
+	}
+
+	memcpy(&temp_stats_id, &ring->buf[ring->tail], NFP_FL_STATS_ELEM_RS);
+	*ctx = temp_stats_id;
+	memcpy(&ring->buf[ring->tail], &freed_stats_id, NFP_FL_STATS_ELEM_RS);
+	ring->tail = (ring->tail + NFP_FL_STATS_ELEM_RS) %
+			(priv->stats_ring_size * NFP_FL_STATS_ELEM_RS);
+
+	return 0;
+}
+
+__rte_unused static int
+nfp_stats_id_free(struct nfp_flow_priv *priv, uint32_t ctx)
+{
+	struct circ_buf *ring;
+
+	/* Check if buffer is full */
+	ring = &priv->stats_ids.free_list;
+	if (!CIRC_SPACE(ring->head, ring->tail, priv->stats_ring_size *
+			NFP_FL_STATS_ELEM_RS - NFP_FL_STATS_ELEM_RS + 1))
+		return -ENOBUFS;
+
+	memcpy(&ring->buf[ring->head], &ctx, NFP_FL_STATS_ELEM_RS);
+	ring->head = (ring->head + NFP_FL_STATS_ELEM_RS) %
+			(priv->stats_ring_size * NFP_FL_STATS_ELEM_RS);
+
+	return 0;
+}
+
+int
+nfp_flow_priv_init(struct nfp_pf_dev *pf_dev)
+{
+	int ret = 0;
+	uint64_t ctx_count;
+	uint64_t ctx_split;
+	size_t stats_size;
+	struct nfp_flow_priv *priv;
+	struct nfp_app_fw_flower *app_fw_flower;
+
+	struct rte_hash_parameters mask_hash_params = {
+		.name       = "mask_hash_table",
+		.entries    = NFP_MASK_TABLE_ENTRIES,
+		.hash_func  = rte_jhash,
+		.socket_id  = rte_socket_id(),
+		.key_len    = sizeof(uint32_t),
+		.extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY,
+	};
+
+	struct rte_hash_parameters flow_hash_params = {
+		.name       = "flow_hash_table",
+		.hash_func  = rte_jhash,
+		.socket_id  = rte_socket_id(),
+		.key_len    = sizeof(uint32_t),
+		.extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY,
+	};
+
+	ctx_count = nfp_rtsym_read_le(pf_dev->sym_tbl,
+			"CONFIG_FC_HOST_CTX_COUNT", &ret);
+	if (ret < 0) {
+		PMD_INIT_LOG(ERR, "Read CTX_COUNT from symbol table failed");
+		goto exit;
+	}
+
+	ctx_split = nfp_rtsym_read_le(pf_dev->sym_tbl,
+			"CONFIG_FC_HOST_CTX_SPLIT", &ret);
+	if (ret < 0) {
+		PMD_INIT_LOG(ERR, "Read CTX_SPLIT from symbol table failed");
+		goto exit;
+	}
+
+	priv = rte_zmalloc("nfp_app_flow_priv", sizeof(struct nfp_flow_priv), 0);
+	if (priv == NULL) {
+		PMD_INIT_LOG(ERR, "nfp app flow priv creation failed");
+		ret = -ENOMEM;
+		goto exit;
+	}
+
+	app_fw_flower = NFP_PRIV_TO_APP_FW_FLOWER(pf_dev->app_fw_priv);
+	app_fw_flower->flow_priv = priv;
+	priv->hash_seed = (uint32_t)rte_rand();
+	priv->stats_ring_size = ctx_count;
+	priv->total_mem_units = ctx_split;
+
+	/* Init ring buffer and unallocated mask_ids. */
+	priv->mask_ids.init_unallocated = NFP_FLOWER_MASK_ENTRY_RS - 1;
+	priv->mask_ids.free_list.buf = rte_zmalloc("nfp_app_mask_ids",
+			NFP_FLOWER_MASK_ENTRY_RS * NFP_FLOWER_MASK_ELEMENT_RS, 0);
+	if (priv->mask_ids.free_list.buf == NULL) {
+		PMD_INIT_LOG(ERR, "mask id free list creation failed");
+		ret = -ENOMEM;
+		goto free_priv;
+	}
+
+	/* Init ring buffer and unallocated stats_ids. */
+	priv->stats_ids.init_unallocated = ctx_count / ctx_split;
+	priv->stats_ids.free_list.buf = rte_zmalloc("nfp_app_stats_ids",
+			priv->stats_ring_size * NFP_FL_STATS_ELEM_RS, 0);
+	if (priv->stats_ids.free_list.buf == NULL) {
+		PMD_INIT_LOG(ERR, "stats id free list creation failed");
+		ret = -ENOMEM;
+		goto free_mask_id;
+	}
+
+	/* flow stats */
+	rte_spinlock_init(&priv->stats_lock);
+	stats_size = (ctx_count & NFP_FL_STAT_ID_STAT) |
+			((ctx_split - 1) & NFP_FL_STAT_ID_MU_NUM);
+	PMD_INIT_LOG(INFO, "ctx_count:%0lx, ctx_split:%0lx, stats_size:%0lx ",
+			ctx_count, ctx_split, stats_size);
+	priv->stats = rte_zmalloc("nfp_flow_stats",
+			stats_size * sizeof(struct nfp_fl_stats), 0);
+	if (priv->stats == NULL) {
+		PMD_INIT_LOG(ERR, "flow stats creation failed");
+		ret = -ENOMEM;
+		goto free_stats_id;
+	}
+
+	/* mask table */
+	mask_hash_params.hash_func_init_val = priv->hash_seed;
+	priv->mask_table = rte_hash_create(&mask_hash_params);
+	if (priv->mask_table == NULL) {
+		PMD_INIT_LOG(ERR, "mask hash table creation failed");
+		ret = -ENOMEM;
+		goto free_stats;
+	}
+
+	/* flow table */
+	flow_hash_params.hash_func_init_val = priv->hash_seed;
+	flow_hash_params.entries = ctx_count;
+	priv->flow_table = rte_hash_create(&flow_hash_params);
+	if (priv->flow_table == NULL) {
+		PMD_INIT_LOG(ERR, "flow hash table creation failed");
+		ret = -ENOMEM;
+		goto free_mask_table;
+	}
+
+	return 0;
+
+free_mask_table:
+	rte_free(priv->mask_table);
+free_stats:
+	rte_free(priv->stats);
+free_stats_id:
+	rte_free(priv->stats_ids.free_list.buf);
+free_mask_id:
+	rte_free(priv->mask_ids.free_list.buf);
+free_priv:
+	rte_free(priv);
+exit:
+	return ret;
+}
+
+void
+nfp_flow_priv_uninit(struct nfp_pf_dev *pf_dev)
+{
+	struct nfp_app_fw_flower *app_fw_flower;
+	struct nfp_flow_priv *priv;
+
+	app_fw_flower = NFP_PRIV_TO_APP_FW_FLOWER(pf_dev->app_fw_priv);
+	priv = app_fw_flower->flow_priv;
+
+	rte_hash_free(priv->flow_table);
+	rte_hash_free(priv->mask_table);
+	rte_free(priv->stats);
+	rte_free(priv->stats_ids.free_list.buf);
+	rte_free(priv->mask_ids.free_list.buf);
+	rte_free(priv);
+}
diff --git a/drivers/net/nfp/nfp_flow.h b/drivers/net/nfp/nfp_flow.h
index 971ba69..142d7d5 100644
--- a/drivers/net/nfp/nfp_flow.h
+++ b/drivers/net/nfp/nfp_flow.h
@@ -6,15 +6,96 @@
 #ifndef _NFP_FLOW_H_
 #define _NFP_FLOW_H_
 
+#define NFP_FL_META_FLAG_MANAGE_MASK    (1 << 7)
+
+#define NFP_MASK_TABLE_ENTRIES          1024
+
+enum nfp_flower_tun_type {
+	NFP_FL_TUN_NONE   = 0,
+	NFP_FL_TUN_GRE    = 1,
+	NFP_FL_TUN_VXLAN  = 2,
+	NFP_FL_TUN_GENEVE = 4,
+};
+
+struct nfp_fl_key_ls {
+	uint32_t key_layer_two;
+	uint8_t key_layer;
+	int key_size;
+	int act_size;
+	uint32_t port;
+	uint16_t vlan;
+	enum nfp_flower_tun_type tun_type;
+};
+
+struct nfp_fl_rule_metadata {
+	uint8_t key_len;
+	uint8_t mask_len;
+	uint8_t act_len;
+	uint8_t flags;
+	rte_be32_t host_ctx_id;
+	rte_be64_t host_cookie __rte_packed;
+	rte_be64_t flow_version __rte_packed;
+	rte_be32_t shortcut;
+};
+
+struct nfp_fl_payload {
+	struct nfp_fl_rule_metadata *meta;
+	char *unmasked_data;
+	char *mask_data;
+	char *action_data;
+};
+
+#define CIRC_CNT(head, tail, size)     (((head) - (tail)) & ((size) - 1))
+#define CIRC_SPACE(head, tail, size)   CIRC_CNT((tail), ((head) + 1), (size))
+struct circ_buf {
+	uint32_t head;
+	uint32_t tail;
+	char *buf;
+};
+
+#define NFP_FLOWER_MASK_ENTRY_RS        256
+#define NFP_FLOWER_MASK_ELEMENT_RS      sizeof(uint8_t)
+struct nfp_fl_mask_id {
+	struct circ_buf free_list;
+	uint8_t init_unallocated;
+};
+
+#define NFP_FL_STATS_ELEM_RS            sizeof(uint32_t)
+struct nfp_fl_stats_id {
+	struct circ_buf free_list;
+	uint32_t init_unallocated;
+};
+
+#define NFP_FL_STAT_ID_MU_NUM           0xffc00000
+#define NFP_FL_STAT_ID_STAT             0x003fffff
 struct nfp_fl_stats {
 	uint64_t pkts;
 	uint64_t bytes;
 };
 
 struct nfp_flow_priv {
+	uint32_t hash_seed; /**< Hash seed for hash tables in this structure. */
+	/* mask hash table */
+	struct nfp_fl_mask_id mask_ids; /**< Entry for mask hash table */
+	struct rte_hash *mask_table; /**< Hash table to store mask ids. */
+	/* flow hash table */
+	struct rte_hash *flow_table; /**< Hash table to store flow rules. */
 	/* flow stats */
+	uint32_t active_mem_unit; /**< The size of active mem units. */
+	uint32_t total_mem_units; /**< The size of total mem units. */
+	uint32_t stats_ring_size; /**< The size of stats id ring. */
+	struct nfp_fl_stats_id stats_ids; /**< The stats id ring. */
 	struct nfp_fl_stats *stats; /**< Store stats of flow. */
 	rte_spinlock_t stats_lock; /** < Lock the update of 'stats' field. */
 };
 
+struct rte_flow {
+	struct nfp_fl_payload payload;
+	size_t length;
+	bool install_flag;
+};
+
+int nfp_flow_priv_init(struct nfp_pf_dev *pf_dev);
+void nfp_flow_priv_uninit(struct nfp_pf_dev *pf_dev);
+
 #endif /* _NFP_FLOW_H_ */
-- 
1.8.3.1