net/i40e: store flow director filter

Currently there's no flow director filter stored in SW. This
patch stores flow director filters in SW with cuckoo hash,
also adds protection if a flow director filter has been added.

Signed-off-by: Beilei Xing <beilei.xing@intel.com>
Acked-by: Jingjing Wu <jingjing.wu@intel.com>

diff --git a/drivers/net/i40e/i40e_ethdev.c b/drivers/net/i40e/i40e_ethdev.c
index 51b59d4..64ceed6 100644 (file)
--- a/drivers/net/i40e/i40e_ethdev.c
+++ b/drivers/net/i40e/i40e_ethdev.c
@@ -1029,6 +1029,48 @@ err_tunnel_hash_map_alloc:
        return ret;
 }
 
+static int
+i40e_init_fdir_filter_list(struct rte_eth_dev *dev)
+{
+       struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
+       struct i40e_fdir_info *fdir_info = &pf->fdir;
+       char fdir_hash_name[RTE_HASH_NAMESIZE];
+       int ret;
+
+       struct rte_hash_parameters fdir_hash_params = {
+               .name = fdir_hash_name,
+               .entries = I40E_MAX_FDIR_FILTER_NUM,
+               .key_len = sizeof(struct rte_eth_fdir_input),
+               .hash_func = rte_hash_crc,
+       };
+
+       /* Initialize flow director filter rule list and hash */
+       TAILQ_INIT(&fdir_info->fdir_list);
+       snprintf(fdir_hash_name, RTE_HASH_NAMESIZE,
+                "fdir_%s", dev->data->name);
+       fdir_info->hash_table = rte_hash_create(&fdir_hash_params);
+       if (!fdir_info->hash_table) {
+               PMD_INIT_LOG(ERR, "Failed to create fdir hash table!");
+               return -EINVAL;
+       }
+       fdir_info->hash_map = rte_zmalloc("i40e_fdir_hash_map",
+                                         sizeof(struct i40e_fdir_filter *) *
+                                         I40E_MAX_FDIR_FILTER_NUM,
+                                         0);
+       if (!fdir_info->hash_map) {
+               PMD_INIT_LOG(ERR,
+                            "Failed to allocate memory for fdir hash map!");
+               ret = -ENOMEM;
+               goto err_fdir_hash_map_alloc;
+       }
+       return 0;
+
+err_fdir_hash_map_alloc:
+       rte_hash_free(fdir_info->hash_table);
+
+       return ret;
+}
+
 static int
 eth_i40e_dev_init(struct rte_eth_dev *dev)
 {
@@ -1291,9 +1333,15 @@ eth_i40e_dev_init(struct rte_eth_dev *dev)
        ret = i40e_init_tunnel_filter_list(dev);
        if (ret < 0)
                goto err_init_tunnel_filter_list;
+       ret = i40e_init_fdir_filter_list(dev);
+       if (ret < 0)
+               goto err_init_fdir_filter_list;
 
        return 0;
 
+err_init_fdir_filter_list:
+       rte_free(pf->tunnel.hash_table);
+       rte_free(pf->tunnel.hash_map);
 err_init_tunnel_filter_list:
        rte_free(pf->ethertype.hash_table);
        rte_free(pf->ethertype.hash_map);
@@ -1357,6 +1405,25 @@ i40e_rm_tunnel_filter_list(struct i40e_pf *pf)
        }
 }
 
+static void
+i40e_rm_fdir_filter_list(struct i40e_pf *pf)
+{
+       struct i40e_fdir_filter *p_fdir;
+       struct i40e_fdir_info *fdir_info;
+
+       fdir_info = &pf->fdir;
+       /* Remove all flow director rules and hash */
+       if (fdir_info->hash_map)
+               rte_free(fdir_info->hash_map);
+       if (fdir_info->hash_table)
+               rte_hash_free(fdir_info->hash_table);
+
+       while ((p_fdir = TAILQ_FIRST(&fdir_info->fdir_list))) {
+               TAILQ_REMOVE(&fdir_info->fdir_list, p_fdir, rules);
+               rte_free(p_fdir);
+       }
+}
+
 static int
 eth_i40e_dev_uninit(struct rte_eth_dev *dev)
 {
@@ -1414,6 +1481,7 @@ eth_i40e_dev_uninit(struct rte_eth_dev *dev)
 
        i40e_rm_ethtype_filter_list(pf);
        i40e_rm_tunnel_filter_list(pf);
+       i40e_rm_fdir_filter_list(pf);
 
        return 0;
 }

diff --git a/drivers/net/i40e/i40e_ethdev.h b/drivers/net/i40e/i40e_ethdev.h
index 349e865..43a3dbb 100644 (file)
--- a/drivers/net/i40e/i40e_ethdev.h
+++ b/drivers/net/i40e/i40e_ethdev.h
@@ -377,6 +377,14 @@ struct i40e_fdir_flex_mask {
 };
 
 #define I40E_FILTER_PCTYPE_MAX 64
+#define I40E_MAX_FDIR_FILTER_NUM (1024 * 8)
+
+struct i40e_fdir_filter {
+       TAILQ_ENTRY(i40e_fdir_filter) rules;
+       struct rte_eth_fdir_filter fdir;
+};
+
+TAILQ_HEAD(i40e_fdir_filter_list, i40e_fdir_filter);
 /*
  *  A structure used to define fields of a FDIR related info.
  */
@@ -395,6 +403,10 @@ struct i40e_fdir_info {
         */
        struct i40e_fdir_flex_pit flex_set[I40E_MAX_FLXPLD_LAYER * I40E_MAX_FLXPLD_FIED];
        struct i40e_fdir_flex_mask flex_mask[I40E_FILTER_PCTYPE_MAX];
+
+       struct i40e_fdir_filter_list fdir_list;
+       struct i40e_fdir_filter **hash_map;
+       struct rte_hash *hash_table;
 };
 
 /* Ethertype filter number HW supports */
@@ -674,6 +686,8 @@ i40e_sw_ethertype_filter_lookup(struct i40e_ethertype_rule *ethertype_rule,
                        const struct i40e_ethertype_filter_input *input);
 int i40e_sw_ethertype_filter_del(struct i40e_pf *pf,
                                 struct i40e_ethertype_filter_input *input);
+int i40e_sw_fdir_filter_del(struct i40e_pf *pf,
+                           struct rte_eth_fdir_input *input);
 struct i40e_tunnel_filter *
 i40e_sw_tunnel_filter_lookup(struct i40e_tunnel_rule *tunnel_rule,
                             const struct i40e_tunnel_filter_input *input);

diff --git a/drivers/net/i40e/i40e_fdir.c b/drivers/net/i40e/i40e_fdir.c
index 335bf15..4a29b37 100644 (file)
--- a/drivers/net/i40e/i40e_fdir.c
+++ b/drivers/net/i40e/i40e_fdir.c
@@ -121,6 +121,14 @@ static int i40e_fdir_filter_programming(struct i40e_pf *pf,
                        bool add);
 static int i40e_fdir_flush(struct rte_eth_dev *dev);
 
+static int i40e_fdir_filter_convert(const struct rte_eth_fdir_filter *input,
+                        struct i40e_fdir_filter *filter);
+static struct i40e_fdir_filter *
+i40e_sw_fdir_filter_lookup(struct i40e_fdir_info *fdir_info,
+                       const struct rte_eth_fdir_input *input);
+static int i40e_sw_fdir_filter_insert(struct i40e_pf *pf,
+                                  struct i40e_fdir_filter *filter);
+
 static int
 i40e_fdir_rx_queue_init(struct i40e_rx_queue *rxq)
 {
@@ -1017,6 +1025,74 @@ i40e_check_fdir_programming_status(struct i40e_rx_queue *rxq)
        return ret;
 }
 
+static int
+i40e_fdir_filter_convert(const struct rte_eth_fdir_filter *input,
+                        struct i40e_fdir_filter *filter)
+{
+       rte_memcpy(&filter->fdir, input, sizeof(struct rte_eth_fdir_filter));
+       return 0;
+}
+
+/* Check if there exists the flow director filter */
+static struct i40e_fdir_filter *
+i40e_sw_fdir_filter_lookup(struct i40e_fdir_info *fdir_info,
+                       const struct rte_eth_fdir_input *input)
+{
+       int ret;
+
+       ret = rte_hash_lookup(fdir_info->hash_table, (const void *)input);
+       if (ret < 0)
+               return NULL;
+
+       return fdir_info->hash_map[ret];
+}
+
+/* Add a flow director filter into the SW list */
+static int
+i40e_sw_fdir_filter_insert(struct i40e_pf *pf, struct i40e_fdir_filter *filter)
+{
+       struct i40e_fdir_info *fdir_info = &pf->fdir;
+       int ret;
+
+       ret = rte_hash_add_key(fdir_info->hash_table,
+                              &filter->fdir.input);
+       if (ret < 0) {
+               PMD_DRV_LOG(ERR,
+                           "Failed to insert fdir filter to hash table %d!",
+                           ret);
+               return ret;
+       }
+       fdir_info->hash_map[ret] = filter;
+
+       TAILQ_INSERT_TAIL(&fdir_info->fdir_list, filter, rules);
+
+       return 0;
+}
+
+/* Delete a flow director filter from the SW list */
+int
+i40e_sw_fdir_filter_del(struct i40e_pf *pf, struct rte_eth_fdir_input *input)
+{
+       struct i40e_fdir_info *fdir_info = &pf->fdir;
+       struct i40e_fdir_filter *filter;
+       int ret;
+
+       ret = rte_hash_del_key(fdir_info->hash_table, input);
+       if (ret < 0) {
+               PMD_DRV_LOG(ERR,
+                           "Failed to delete fdir filter to hash table %d!",
+                           ret);
+               return ret;
+       }
+       filter = fdir_info->hash_map[ret];
+       fdir_info->hash_map[ret] = NULL;
+
+       TAILQ_REMOVE(&fdir_info->fdir_list, filter, rules);
+       rte_free(filter);
+
+       return 0;
+}
+
 /*
  * i40e_add_del_fdir_filter - add or remove a flow director filter.
  * @pf: board private structure
@@ -1032,6 +1108,9 @@ i40e_add_del_fdir_filter(struct rte_eth_dev *dev,
        struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
        unsigned char *pkt = (unsigned char *)pf->fdir.prg_pkt;
        enum i40e_filter_pctype pctype;
+       struct i40e_fdir_info *fdir_info = &pf->fdir;
+       struct i40e_fdir_filter *fdir_filter, *node;
+       struct i40e_fdir_filter check_filter; /* Check if the filter exists */
        int ret = 0;
 
        if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_PERFECT) {
@@ -1054,6 +1133,22 @@ i40e_add_del_fdir_filter(struct rte_eth_dev *dev,
                return -EINVAL;
        }
 
+       /* Check if there is the filter in SW list */
+       memset(&check_filter, 0, sizeof(check_filter));
+       i40e_fdir_filter_convert(filter, &check_filter);
+       node = i40e_sw_fdir_filter_lookup(fdir_info, &check_filter.fdir.input);
+       if (add && node) {
+               PMD_DRV_LOG(ERR,
+                           "Conflict with existing flow director rules!");
+               return -EINVAL;
+       }
+
+       if (!add && !node) {
+               PMD_DRV_LOG(ERR,
+                           "There's no corresponding flow firector filter!");
+               return -EINVAL;
+       }
+
        memset(pkt, 0, I40E_FDIR_PKT_LEN);
 
        ret = i40e_fdir_construct_pkt(pf, &filter->input, pkt);
@@ -1077,6 +1172,16 @@ i40e_add_del_fdir_filter(struct rte_eth_dev *dev,
                            pctype);
                return ret;
        }
+
+       if (add) {
+               fdir_filter = rte_zmalloc("fdir_filter",
+                                         sizeof(*fdir_filter), 0);
+               rte_memcpy(fdir_filter, &check_filter, sizeof(check_filter));
+               ret = i40e_sw_fdir_filter_insert(pf, fdir_filter);
+       } else {
+               ret = i40e_sw_fdir_filter_del(pf, &node->fdir.input);
+       }
+
        return ret;
 }