Hi, Zhao Wei Please correct build error show in http://dpdk.org/ml/archives/test-report/2017-November/035129.html
> -----Original Message----- > From: dev [mailto:dev-boun...@dpdk.org] On Behalf Of Wei Zhao > Sent: Friday, November 24, 2017 4:05 PM > To: dev@dpdk.org > Cc: Zhao1, Wei <wei.zh...@intel.com> > Subject: [dpdk-dev] [PATCH v3 1/2] net/e1000: move RSS to flow API > > Rte_flow actually defined to include RSS, but till now, RSS is out of > rte_flow. > This patch is to move igb existing RSS to rte_flow. > > Signed-off-by: Wei Zhao <wei.zh...@intel.com> > --- > drivers/net/e1000/e1000_ethdev.h | 20 +++++ > drivers/net/e1000/igb_ethdev.c | 17 +++++ > drivers/net/e1000/igb_flow.c | 160 > +++++++++++++++++++++++++++++++++++++++ > drivers/net/e1000/igb_rxtx.c | 61 +++++++++++++++ > 4 files changed, 258 insertions(+) > > diff --git a/drivers/net/e1000/e1000_ethdev.h > b/drivers/net/e1000/e1000_ethdev.h > index 5668910..0731766 100644 > --- a/drivers/net/e1000/e1000_ethdev.h > +++ b/drivers/net/e1000/e1000_ethdev.h > @@ -257,6 +257,12 @@ struct igb_ethertype_filter { > uint32_t etqf; > }; > > +struct igb_rte_flow_rss_conf { > + struct rte_eth_rss_conf rss_conf; /**< RSS parameters. */ > + uint16_t num; /**< Number of entries in queue[]. */ > + uint16_t queue[IGB_MAX_RX_QUEUE_NUM]; /**< Queues indices to > use. */ > +}; > + > /* > * Structure to store filters'info. > */ > @@ -274,6 +280,8 @@ struct e1000_filter_info { > struct e1000_2tuple_filter_list twotuple_list; > /* store the SYN filter info */ > uint32_t syn_info; > + /* store the rss filter info */ > + struct igb_rte_flow_rss_conf rss_info; > }; > > /* > @@ -342,6 +350,12 @@ struct igb_flex_filter_ele { > struct rte_eth_flex_filter filter_info; }; > > +/* rss filter list structure */ > +struct igb_rss_conf_ele { > + TAILQ_ENTRY(igb_rss_conf_ele) entries; > + struct igb_rte_flow_rss_conf filter_info; }; > + > /* igb_flow memory list structure */ > struct igb_flow_mem { > TAILQ_ENTRY(igb_flow_mem) entries; > @@ -357,6 +371,8 @@ TAILQ_HEAD(igb_syn_filter_list, > igb_eth_syn_filter_ele); struct igb_syn_filter_list igb_filter_syn_list; > TAILQ_HEAD(igb_flex_filter_list, igb_flex_filter_ele); struct > igb_flex_filter_list igb_filter_flex_list; > +TAILQ_HEAD(igb_rss_filter_list, igb_rss_conf_ele); struct > +igb_rss_filter_list igb_filter_rss_list; > TAILQ_HEAD(igb_flow_mem_list, igb_flow_mem); struct > igb_flow_mem_list igb_flow_list; > > @@ -500,4 +516,8 @@ int eth_igb_syn_filter_set(struct rte_eth_dev *dev, > int eth_igb_add_del_flex_filter(struct rte_eth_dev *dev, > struct rte_eth_flex_filter *filter, > bool add); > +int igb_config_rss_filter(struct rte_eth_dev *dev, > + struct igb_rte_flow_rss_conf *conf, > + bool add); > + > #endif /* _E1000_ETHDEV_H_ */ > diff --git a/drivers/net/e1000/igb_ethdev.c > b/drivers/net/e1000/igb_ethdev.c index fdc139f..275fa02 100644 > --- a/drivers/net/e1000/igb_ethdev.c > +++ b/drivers/net/e1000/igb_ethdev.c > @@ -948,6 +948,7 @@ eth_igb_dev_init(struct rte_eth_dev *eth_dev) > TAILQ_INIT(&igb_filter_ethertype_list); > TAILQ_INIT(&igb_filter_syn_list); > TAILQ_INIT(&igb_filter_flex_list); > + TAILQ_INIT(&igb_filter_rss_list); > TAILQ_INIT(&igb_flow_list); > > return 0; > @@ -1007,6 +1008,10 @@ eth_igb_dev_uninit(struct rte_eth_dev *eth_dev) > memset(filter_info->ethertype_filters, 0, > E1000_MAX_ETQF_FILTERS * sizeof(struct igb_ethertype_filter)); > > + /* clear the rss filter info */ > + memset(&filter_info->rss_info, 0, > + sizeof(struct igb_rte_flow_rss_conf)); > + > /* remove all ntuple filters of the device */ > igb_ntuple_filter_uninit(eth_dev); > > @@ -5628,6 +5633,17 @@ igb_flex_filter_restore(struct rte_eth_dev *dev) > } > } > > +/* restore rss filter */ > +static inline void > +igb_rss_filter_restore(struct rte_eth_dev *dev) { > + struct e1000_filter_info *filter_info = > + E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private); > + > + if (filter_info->rss_info.num) > + igb_config_rss_filter(dev, &filter_info->rss_info, TRUE); } > + > /* restore all types filter */ > static int > igb_filter_restore(struct rte_eth_dev *dev) @@ -5636,6 +5652,7 @@ > igb_filter_restore(struct rte_eth_dev *dev) > igb_ethertype_filter_restore(dev); > igb_syn_filter_restore(dev); > igb_flex_filter_restore(dev); > + igb_rss_filter_restore(dev); > > return 0; > } > diff --git a/drivers/net/e1000/igb_flow.c b/drivers/net/e1000/igb_flow.c > index 22bad26..bf5cfac 100644 > --- a/drivers/net/e1000/igb_flow.c > +++ b/drivers/net/e1000/igb_flow.c > @@ -1295,6 +1295,101 @@ igb_parse_flex_filter(struct rte_eth_dev *dev, > return 0; > } > > +static int > +igb_parse_rss_filter(struct rte_eth_dev *dev, > + const struct rte_flow_attr *attr, > + const struct rte_flow_action actions[], > + struct igb_rte_flow_rss_conf *rss_conf, > + struct rte_flow_error *error) > +{ > + const struct rte_flow_action *act; > + const struct rte_flow_action_rss *rss; > + uint16_t n, index; > + > + /** > + * rss only supports forwarding, > + * check if the first not void action is RSS. > + */ > + index = 0; > + NEXT_ITEM_OF_ACTION(act, actions, index); > + if (act->type != RTE_FLOW_ACTION_TYPE_RSS) { > + memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf)); > + rte_flow_error_set(error, EINVAL, > + RTE_FLOW_ERROR_TYPE_ACTION, > + act, "Not supported action."); > + return -rte_errno; > + } > + > + rss = (const struct rte_flow_action_rss *)act->conf; > + > + if (!rss || !rss->num) { > + rte_flow_error_set(error, EINVAL, > + RTE_FLOW_ERROR_TYPE_ACTION, > + act, > + "no valid queues"); > + return -rte_errno; > + } > + > + for (n = 0; n < rss->num; n++) { > + if (rss->queue[n] >= dev->data->nb_rx_queues) { > + rte_flow_error_set(error, EINVAL, > + RTE_FLOW_ERROR_TYPE_ACTION, > + act, > + "queue id > max number of queues"); > + return -rte_errno; > + } > + } > + > + if (rss->rss_conf) > + rss_conf->rss_conf = *rss->rss_conf; > + else > + rss_conf->rss_conf.rss_hf = IXGBE_RSS_OFFLOAD_ALL; > + > + for (n = 0; n < rss->num; ++n) > + rss_conf->queue[n] = rss->queue[n]; > + rss_conf->num = rss->num; > + > + /* 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(rss_conf, 0, sizeof(struct rte_eth_rss_conf)); > + rte_flow_error_set(error, EINVAL, > + RTE_FLOW_ERROR_TYPE_ACTION, > + act, "Not supported action."); > + return -rte_errno; > + } > + > + /* parse attr */ > + /* must be input direction */ > + if (!attr->ingress) { > + memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf)); > + rte_flow_error_set(error, EINVAL, > + RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, > + attr, "Only support ingress."); > + return -rte_errno; > + } > + > + /* not supported */ > + if (attr->egress) { > + memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf)); > + rte_flow_error_set(error, EINVAL, > + RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, > + attr, "Not support egress."); > + return -rte_errno; > + } > + > + if (attr->priority > 0xFFFF) { > + memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf)); > + rte_flow_error_set(error, EINVAL, > + RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, > + attr, "Error priority."); > + return -rte_errno; > + } > + > + return 0; > +} > + > /** > * Create a flow rule. > * Theorically one rule can match more than one filters. > @@ -1313,11 +1408,13 @@ igb_flow_create(struct rte_eth_dev *dev, > struct rte_eth_ethertype_filter ethertype_filter; > struct rte_eth_syn_filter syn_filter; > struct rte_eth_flex_filter flex_filter; > + struct igb_rte_flow_rss_conf rss_conf; > struct rte_flow *flow = NULL; > struct igb_ntuple_filter_ele *ntuple_filter_ptr; > struct igb_ethertype_filter_ele *ethertype_filter_ptr; > struct igb_eth_syn_filter_ele *syn_filter_ptr; > struct igb_flex_filter_ele *flex_filter_ptr; > + struct igb_rss_conf_ele *rss_filter_ptr; > struct igb_flow_mem *igb_flow_mem_ptr; > > flow = rte_zmalloc("igb_rte_flow", sizeof(struct rte_flow), 0); @@ > -1419,6 +1516,29 @@ igb_flow_create(struct rte_eth_dev *dev, > } > } > > + memset(&rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf)); > + ret = igb_parse_rss_filter(dev, attr, > + actions, &rss_conf, error); > + if (!ret) { > + ret = igb_config_rss_filter(dev, &rss_conf, TRUE); > + if (!ret) { > + rss_filter_ptr = rte_zmalloc("igb_rss_filter", > + sizeof(struct igb_rss_conf_ele), 0); > + if (!rss_filter_ptr) { > + PMD_DRV_LOG(ERR, "failed to allocate memory"); > + goto out; > + } > + rte_memcpy(&rss_filter_ptr->filter_info, > + &rss_conf, > + sizeof(struct igb_rte_flow_rss_conf)); > + TAILQ_INSERT_TAIL(&igb_filter_rss_list, > + rss_filter_ptr, entries); > + flow->rule = rss_filter_ptr; > + flow->filter_type = RTE_ETH_FILTER_HASH; > + return flow; > + } > + } > + > out: > TAILQ_REMOVE(&igb_flow_list, > igb_flow_mem_ptr, entries); > @@ -1446,6 +1566,7 @@ igb_flow_validate(__rte_unused struct > rte_eth_dev *dev, > struct rte_eth_ethertype_filter ethertype_filter; > struct rte_eth_syn_filter syn_filter; > struct rte_eth_flex_filter flex_filter; > + struct igb_rte_flow_rss_conf rss_conf; > int ret; > > memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter)); @@ > -1469,6 +1590,12 @@ igb_flow_validate(__rte_unused struct rte_eth_dev > *dev, > memset(&flex_filter, 0, sizeof(struct rte_eth_flex_filter)); > ret = igb_parse_flex_filter(dev, attr, pattern, > actions, &flex_filter, error); > + if (!ret) > + return 0; > + > + memset(&rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf)); > + ret = igb_parse_rss_filter(dev, attr, > + actions, &rss_conf, error); > > return ret; > } > @@ -1487,6 +1614,7 @@ igb_flow_destroy(struct rte_eth_dev *dev, > struct igb_eth_syn_filter_ele *syn_filter_ptr; > struct igb_flex_filter_ele *flex_filter_ptr; > struct igb_flow_mem *igb_flow_mem_ptr; > + struct igb_rss_conf_ele *rss_filter_ptr; > > switch (filter_type) { > case RTE_ETH_FILTER_NTUPLE: > @@ -1533,6 +1661,17 @@ igb_flow_destroy(struct rte_eth_dev *dev, > rte_free(flex_filter_ptr); > } > break; > + case RTE_ETH_FILTER_HASH: > + rss_filter_ptr = (struct igb_rss_conf_ele *) > + pmd_flow->rule; > + ret = igb_config_rss_filter(dev, > + &rss_filter_ptr->filter_info, FALSE); > + if (!ret) { > + TAILQ_REMOVE(&igb_filter_rss_list, > + rss_filter_ptr, entries); > + rte_free(rss_filter_ptr); > + } > + break; > default: > PMD_DRV_LOG(WARNING, "Filter type (%d) not supported", > filter_type); > @@ -1621,6 +1760,17 @@ igb_clear_all_flex_filter(struct rte_eth_dev *dev) > igb_remove_flex_filter(dev, flex_filter); } > > +/* remove the rss filter */ > +static void > +igb_clear_rss_filter(struct rte_eth_dev *dev) { > + struct e1000_filter_info *filter = > + E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private); > + > + if (filter->rss_info.num) > + igb_config_rss_filter(dev, &filter->rss_info, FALSE); } > + > void > igb_filterlist_flush(struct rte_eth_dev *dev) { @@ -1628,6 +1778,7 @@ > igb_filterlist_flush(struct rte_eth_dev *dev) > struct igb_ethertype_filter_ele *ethertype_filter_ptr; > struct igb_eth_syn_filter_ele *syn_filter_ptr; > struct igb_flex_filter_ele *flex_filter_ptr; > + struct igb_rss_conf_ele *rss_filter_ptr; > struct igb_flow_mem *igb_flow_mem_ptr; > enum rte_filter_type filter_type; > struct rte_flow *pmd_flow; > @@ -1670,6 +1821,14 @@ igb_filterlist_flush(struct rte_eth_dev *dev) > flex_filter_ptr, entries); > rte_free(flex_filter_ptr); > break; > + case RTE_ETH_FILTER_HASH: > + rss_filter_ptr = > + (struct igb_rss_conf_ele *) > + pmd_flow->rule; > + TAILQ_REMOVE(&igb_filter_rss_list, > + rss_filter_ptr, entries); > + rte_free(rss_filter_ptr); > + break; > default: > PMD_DRV_LOG(WARNING, "Filter type" > "(%d) not supported", filter_type); @@ > -1693,6 > +1852,7 @@ igb_flow_flush(struct rte_eth_dev *dev, > igb_clear_all_ethertype_filter(dev); > igb_clear_syn_filter(dev); > igb_clear_all_flex_filter(dev); > + igb_clear_rss_filter(dev); > igb_filterlist_flush(dev); > > return 0; > diff --git a/drivers/net/e1000/igb_rxtx.c b/drivers/net/e1000/igb_rxtx.c > index 4ee12e9..af86726 100644 > --- a/drivers/net/e1000/igb_rxtx.c > +++ b/drivers/net/e1000/igb_rxtx.c > @@ -2786,3 +2786,64 @@ igb_txq_info_get(struct rte_eth_dev *dev, > uint16_t queue_id, > qinfo->conf.tx_thresh.hthresh = txq->hthresh; > qinfo->conf.tx_thresh.wthresh = txq->wthresh; } > + > +int > +igb_config_rss_filter(struct rte_eth_dev *dev, > + struct igb_rte_flow_rss_conf *conf, bool add) { > + uint32_t shift; > + uint16_t i, j; > + struct rte_eth_rss_conf rss_conf = conf->rss_conf; > + struct e1000_filter_info *filter_info = > + E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private); > + struct e1000_hw *hw = > E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private); > + > + hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private); > + > + if (!add) { > + if (memcmp(conf, &filter_info->rss_info, > + sizeof(struct igb_rte_flow_rss_conf)) == 0) { > + igb_rss_disable(dev); > + memset(&filter_info->rss_info, 0, > + sizeof(struct igb_rte_flow_rss_conf)); > + return 0; > + } > + return -EINVAL; > + } > + > + if (filter_info->rss_info.num) > + return -EINVAL; > + > + /* Fill in redirection table. */ > + shift = (hw->mac.type == e1000_82575) ? 6 : 0; > + for (i = 0, j = 0; i < 128; i++, j++) { > + union e1000_reta { > + uint32_t dword; > + uint8_t bytes[4]; > + } reta; > + uint8_t q_idx; > + > + q_idx = conf->queue[j]; > + if (j == conf->num) > + j = 0; > + reta.bytes[i & 3] = (uint8_t)(q_idx << shift); > + if ((i & 3) == 3) > + E1000_WRITE_REG(hw, E1000_RETA(i >> 2), reta.dword); > + } > + > + /* Configure the RSS key and the RSS protocols used to compute > + * the RSS hash of input packets. > + */ > + if ((rss_conf.rss_hf & IGB_RSS_OFFLOAD_ALL) == 0) { > + igb_rss_disable(dev); > + return 0; > + } > + if (rss_conf.rss_key == NULL) > + rss_conf.rss_key = rss_intel_key; /* Default hash key */ > + igb_hw_rss_hash_set(hw, &rss_conf); > + > + rte_memcpy(&filter_info->rss_info, > + conf, sizeof(struct igb_rte_flow_rss_conf)); > + > + return 0; > +} > -- > 2.9.3
