diff mbox series

[v2,06/37] net/txgbe: add ethertype parse rule

Message ID	20201111064936.768604-7-jiawenwu@trustnetic.com (mailing list archive)
State	Changes Requested, archived
Delegated to:	Ferruh Yigit
Headers	From: Jiawen Wu <jiawenwu@trustnetic.com> To: dev@dpdk.org Cc: Jiawen Wu <jiawenwu@trustnetic.com> Date: Wed, 11 Nov 2020 14:49:05 +0800 Message-Id: <20201111064936.768604-7-jiawenwu@trustnetic.com> In-Reply-To: <20201111064936.768604-1-jiawenwu@trustnetic.com> References: <20201111064936.768604-1-jiawenwu@trustnetic.com> Feedback-ID: bizesmtp:trustnetic.com:qybgforeign:qybgforeign6 Subject: [dpdk-dev] [PATCH v2 06/37] net/txgbe: add ethertype parse rule Precedence: list Errors-To: dev-bounces@dpdk.org Sender: "dev" <dev-bounces@dpdk.org>
Series	net: add txgbe PMD part 2 \| [v2,00/37] net: add txgbe PMD part 2 [v2,01/37] net/txgbe: add ntuple filter init and uninit [v2,02/37] net/txgbe: support ntuple filter add and delete [v2,03/37] net/txgbe: add ntuple parse rule [v2,04/37] net/txgbe: support ntuple filter remove operaion [v2,05/37] net/txgbe: support ethertype filter add and delete [v2,06/37] net/txgbe: add ethertype parse rule [v2,07/37] net/txgbe: support syn filter add and delete [v2,08/37] net/txgbe: add syn filter parse rule [v2,09/37] net/txgbe: add L2 tunnel filter init and uninit [v2,10/37] net/txgbe: config L2 tunnel filter with e-tag [v2,11/37] net/txgbe: support L2 tunnel filter add and delete [v2,12/37] net/txgbe: add L2 tunnel filter parse rule [v2,13/37] net/txgbe: add FDIR filter init and uninit [v2,14/37] net/txgbe: configure FDIR filter [v2,15/37] net/txgbe: support FDIR add and delete operations [v2,16/37] net/txgbe: add FDIR parse normal rule [v2,17/37] net/txgbe: add FDIR parse tunnel rule [v2,18/37] net/txgbe: add FDIR restore operation [v2,19/37] net/txgbe: add RSS filter parse rule [v2,20/37] net/txgbe: add RSS filter restore operation [v2,21/37] net/txgbe: add filter list init and uninit [v2,22/37] net/txgbe: add generic flow API [v2,23/37] net/txgbe: add flow API create function [v2,24/37] net/txgbe: add flow API destroy function [v2,25/37] net/txgbe: add flow API flush function [v2,26/37] net/txgbe: support UDP tunnel port add and delete [v2,27/37] net/txgbe: add TM configuration init and uninit [v2,28/37] net/txgbe: add TM capabilities get operation [v2,29/37] net/txgbe: support TM shaper profile add and delete [v2,30/37] net/txgbe: support TM node add and delete [v2,31/37] net/txgbe: add TM hierarchy commit [v2,32/37] net/txgbe: add macsec setting [v2,33/37] net/txgbe: add IPsec context creation [v2,34/37] net/txgbe: add security session create operation [v2,35/37] net/txgbe: support security session destroy [v2,36/37] net/txgbe: add security offload in Rx and Tx process [v2,37/37] net/txgbe: add security type in flow action

Checks

Context	Check	Description
ci/checkpatch	success	coding style OK

Commit Message

Jiawen Wu Nov. 11, 2020, 6:49 a.m. UTC

  Add support to parse flow for ethertype filter.

Signed-off-by: Jiawen Wu <jiawenwu@trustnetic.com>
---
 drivers/net/txgbe/txgbe_flow.c | 250 +++++++++++++++++++++++++++++++++
 1 file changed, 250 insertions(+)

Comments

Ferruh Yigit Nov. 11, 2020, 4:02 p.m. UTC | #1

On 11/11/2020 6:49 AM, Jiawen Wu wrote:
> Add support to parse flow for ethertype filter.
> 
> Signed-off-by: Jiawen Wu <jiawenwu@trustnetic.com>

<...>

> +static int
> +txgbe_parse_ethertype_filter(struct rte_eth_dev *dev,
> +			     const struct rte_flow_attr *attr,
> +			     const struct rte_flow_item pattern[],
> +			     const struct rte_flow_action actions[],
> +			     struct rte_eth_ethertype_filter *filter,
> +			     struct rte_flow_error *error)
> +{
> +	int ret;
> +
> +	ret = cons_parse_ethertype_filter(attr, pattern,
> +					actions, filter, error);
> +
> +	if (ret)
> +		return ret;
> +
> +	/* txgbe doesn't support MAC address. */
> +	if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
> +		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> +		rte_flow_error_set(error, EINVAL,
> +			RTE_FLOW_ERROR_TYPE_ITEM,
> +			NULL, "Not supported by ethertype filter");
> +		return -rte_errno;
> +	}
> +
> +	if (filter->queue >= dev->data->nb_rx_queues) {
> +		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> +		rte_flow_error_set(error, EINVAL,
> +			RTE_FLOW_ERROR_TYPE_ITEM,
> +			NULL, "queue index much too big");
> +		return -rte_errno;
> +	}
> +
> +	if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
> +		filter->ether_type == RTE_ETHER_TYPE_IPV6) {
> +		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> +		rte_flow_error_set(error, EINVAL,
> +			RTE_FLOW_ERROR_TYPE_ITEM,
> +			NULL, "IPv4/IPv6 not supported by ethertype filter");
> +		return -rte_errno;
> +	}
> +
> +	if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
> +		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> +		rte_flow_error_set(error, EINVAL,
> +			RTE_FLOW_ERROR_TYPE_ITEM,
> +			NULL, "mac compare is unsupported");
> +		return -rte_errno;
> +	}

Isn't 'RTE_ETHTYPE_FLAGS_MAC' already checked a few blocks above, that time 
error message was ""Not supported by ethertype filter"

> +
> +	if (filter->flags & RTE_ETHTYPE_FLAGS_DROP) {
> +		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> +		rte_flow_error_set(error, EINVAL,
> +			RTE_FLOW_ERROR_TYPE_ITEM,
> +			NULL, "drop option is unsupported");
> +		return -rte_errno;
> +	}
> +
> +	return 0;
> +}
> +
>

Ferruh Yigit Nov. 11, 2020, 4:04 p.m. UTC | #2

On 11/11/2020 4:02 PM, Ferruh Yigit wrote:
> On 11/11/2020 6:49 AM, Jiawen Wu wrote:
>> Add support to parse flow for ethertype filter.
>>
>> Signed-off-by: Jiawen Wu <jiawenwu@trustnetic.com>
> 
> <...>
> 
>> +static int
>> +txgbe_parse_ethertype_filter(struct rte_eth_dev *dev,
>> +                 const struct rte_flow_attr *attr,
>> +                 const struct rte_flow_item pattern[],
>> +                 const struct rte_flow_action actions[],
>> +                 struct rte_eth_ethertype_filter *filter,
>> +                 struct rte_flow_error *error)
>> +{
>> +    int ret;
>> +
>> +    ret = cons_parse_ethertype_filter(attr, pattern,
>> +                    actions, filter, error);
>> +
>> +    if (ret)
>> +        return ret;
>> +
>> +    /* txgbe doesn't support MAC address. */
>> +    if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
>> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
>> +        rte_flow_error_set(error, EINVAL,
>> +            RTE_FLOW_ERROR_TYPE_ITEM,
>> +            NULL, "Not supported by ethertype filter");
>> +        return -rte_errno;
>> +    }
>> +
>> +    if (filter->queue >= dev->data->nb_rx_queues) {
>> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
>> +        rte_flow_error_set(error, EINVAL,
>> +            RTE_FLOW_ERROR_TYPE_ITEM,
>> +            NULL, "queue index much too big");
>> +        return -rte_errno;
>> +    }
>> +
>> +    if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
>> +        filter->ether_type == RTE_ETHER_TYPE_IPV6) {
>> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
>> +        rte_flow_error_set(error, EINVAL,
>> +            RTE_FLOW_ERROR_TYPE_ITEM,
>> +            NULL, "IPv4/IPv6 not supported by ethertype filter");
>> +        return -rte_errno;
>> +    }
>> +
>> +    if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
>> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
>> +        rte_flow_error_set(error, EINVAL,
>> +            RTE_FLOW_ERROR_TYPE_ITEM,
>> +            NULL, "mac compare is unsupported");
>> +        return -rte_errno;
>> +    }
> 
> Isn't 'RTE_ETHTYPE_FLAGS_MAC' already checked a few blocks above, that time 
> error message was ""Not supported by ethertype filter"
> 

Hi Jia, Haiyue,

Same exists in the ixgbe driver, this how end up in the txgbe, can you please check?

Wang, Haiyue Nov. 12, 2020, 1:57 a.m. UTC | #3

> -----Original Message-----
> From: Ferruh Yigit <ferruh.yigit@intel.com>
> Sent: Thursday, November 12, 2020 00:04
> To: Guo, Jia <jia.guo@intel.com>; Wang, Haiyue <haiyue.wang@intel.com>
> Cc: Jiawen Wu <jiawenwu@trustnetic.com>; dev@dpdk.org
> Subject: Re: [dpdk-dev] [PATCH v2 06/37] net/txgbe: add ethertype parse rule
> 
> On 11/11/2020 4:02 PM, Ferruh Yigit wrote:
> > On 11/11/2020 6:49 AM, Jiawen Wu wrote:
> >> Add support to parse flow for ethertype filter.
> >>
> >> Signed-off-by: Jiawen Wu <jiawenwu@trustnetic.com>
> >
> > <...>
> >
> >> +static int
> >> +txgbe_parse_ethertype_filter(struct rte_eth_dev *dev,
> >> +                 const struct rte_flow_attr *attr,
> >> +                 const struct rte_flow_item pattern[],
> >> +                 const struct rte_flow_action actions[],
> >> +                 struct rte_eth_ethertype_filter *filter,
> >> +                 struct rte_flow_error *error)
> >> +{
> >> +    int ret;
> >> +
> >> +    ret = cons_parse_ethertype_filter(attr, pattern,
> >> +                    actions, filter, error);
> >> +
> >> +    if (ret)
> >> +        return ret;
> >> +
> >> +    /* txgbe doesn't support MAC address. */
> >> +    if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
> >> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> >> +        rte_flow_error_set(error, EINVAL,
> >> +            RTE_FLOW_ERROR_TYPE_ITEM,
> >> +            NULL, "Not supported by ethertype filter");
> >> +        return -rte_errno;
> >> +    }
> >> +
> >> +    if (filter->queue >= dev->data->nb_rx_queues) {
> >> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> >> +        rte_flow_error_set(error, EINVAL,
> >> +            RTE_FLOW_ERROR_TYPE_ITEM,
> >> +            NULL, "queue index much too big");
> >> +        return -rte_errno;
> >> +    }
> >> +
> >> +    if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
> >> +        filter->ether_type == RTE_ETHER_TYPE_IPV6) {
> >> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> >> +        rte_flow_error_set(error, EINVAL,
> >> +            RTE_FLOW_ERROR_TYPE_ITEM,
> >> +            NULL, "IPv4/IPv6 not supported by ethertype filter");
> >> +        return -rte_errno;
> >> +    }
> >> +
> >> +    if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
> >> +        memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
> >> +        rte_flow_error_set(error, EINVAL,
> >> +            RTE_FLOW_ERROR_TYPE_ITEM,
> >> +            NULL, "mac compare is unsupported");
> >> +        return -rte_errno;
> >> +    }
> >
> > Isn't 'RTE_ETHTYPE_FLAGS_MAC' already checked a few blocks above, that time
> > error message was ""Not supported by ethertype filter"
> >
> 
> Hi Jia, Haiyue,
> 
> Same exists in the ixgbe driver, this how end up in the txgbe, can you please check?

Yes, I think "mac compare is unsupported" should be kept, the "ethertype filter" should
be removed, to align to 'RTE_ETHTYPE_FLAGS_MAC' definition:

#define RTE_ETHTYPE_FLAGS_MAC    0x0001 /**< If set, compare mac */

diff mbox series

Patch

diff --git a/drivers/net/txgbe/txgbe_flow.c b/drivers/net/txgbe/txgbe_flow.c
index 6f8be3b7f..fc2505ddc 100644
--- a/drivers/net/txgbe/txgbe_flow.c
+++ b/drivers/net/txgbe/txgbe_flow.c
@@ -534,3 +534,253 @@  txgbe_parse_ntuple_filter(struct rte_eth_dev *dev,
 	return 0;
 }
 
+/**
+ * Parse the rule to see if it is a ethertype rule.
+ * And get the ethertype filter info BTW.
+ * pattern:
+ * The first not void item can be ETH.
+ * The next not void item must be END.
+ * action:
+ * The first not void action should be QUEUE.
+ * The next not void action should be END.
+ * pattern example:
+ * ITEM		Spec			Mask
+ * ETH		type	0x0807		0xFFFF
+ * END
+ * other members in mask and spec should set to 0x00.
+ * item->last should be NULL.
+ */
+static int
+cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
+			    const struct rte_flow_item *pattern,
+			    const struct rte_flow_action *actions,
+			    struct rte_eth_ethertype_filter *filter,
+			    struct rte_flow_error *error)
+{
+	const struct rte_flow_item *item;
+	const struct rte_flow_action *act;
+	const struct rte_flow_item_eth *eth_spec;
+	const struct rte_flow_item_eth *eth_mask;
+	const struct rte_flow_action_queue *act_q;
+
+	if (!pattern) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ITEM_NUM,
+				NULL, "NULL pattern.");
+		return -rte_errno;
+	}
+
+	if (!actions) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ACTION_NUM,
+				NULL, "NULL action.");
+		return -rte_errno;
+	}
+
+	if (!attr) {
+		rte_flow_error_set(error, EINVAL,
+				   RTE_FLOW_ERROR_TYPE_ATTR,
+				   NULL, "NULL attribute.");
+		return -rte_errno;
+	}
+
+	item = next_no_void_pattern(pattern, NULL);
+	/* The first non-void item should be MAC. */
+	if (item->type != RTE_FLOW_ITEM_TYPE_ETH) {
+		rte_flow_error_set(error, EINVAL,
+			RTE_FLOW_ERROR_TYPE_ITEM,
+			item, "Not supported by ethertype filter");
+		return -rte_errno;
+	}
+
+	/*Not supported last point for range*/
+	if (item->last) {
+		rte_flow_error_set(error, EINVAL,
+			RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
+			item, "Not supported last point for range");
+		return -rte_errno;
+	}
+
+	/* Get the MAC info. */
+	if (!item->spec || !item->mask) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ITEM,
+				item, "Not supported by ethertype filter");
+		return -rte_errno;
+	}
+
+	eth_spec = item->spec;
+	eth_mask = item->mask;
+
+	/* Mask bits of source MAC address must be full of 0.
+	 * Mask bits of destination MAC address must be full
+	 * of 1 or full of 0.
+	 */
+	if (!rte_is_zero_ether_addr(&eth_mask->src) ||
+	    (!rte_is_zero_ether_addr(&eth_mask->dst) &&
+	     !rte_is_broadcast_ether_addr(&eth_mask->dst))) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ITEM,
+				item, "Invalid ether address mask");
+		return -rte_errno;
+	}
+
+	if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ITEM,
+				item, "Invalid ethertype mask");
+		return -rte_errno;
+	}
+
+	/* If mask bits of destination MAC address
+	 * are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
+	 */
+	if (rte_is_broadcast_ether_addr(&eth_mask->dst)) {
+		filter->mac_addr = eth_spec->dst;
+		filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
+	} else {
+		filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC;
+	}
+	filter->ether_type = rte_be_to_cpu_16(eth_spec->type);
+
+	/* Check if the next non-void item is END. */
+	item = next_no_void_pattern(pattern, item);
+	if (item->type != RTE_FLOW_ITEM_TYPE_END) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ITEM,
+				item, "Not supported by ethertype filter.");
+		return -rte_errno;
+	}
+
+	/* Parse action */
+
+	act = next_no_void_action(actions, NULL);
+	if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
+	    act->type != RTE_FLOW_ACTION_TYPE_DROP) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ACTION,
+				act, "Not supported action.");
+		return -rte_errno;
+	}
+
+	if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
+		act_q = (const struct rte_flow_action_queue *)act->conf;
+		filter->queue = act_q->index;
+	} else {
+		filter->flags |= RTE_ETHTYPE_FLAGS_DROP;
+	}
+
+	/* Check if the next non-void item is END */
+	act = next_no_void_action(actions, act);
+	if (act->type != RTE_FLOW_ACTION_TYPE_END) {
+		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) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
+				attr, "Only support ingress.");
+		return -rte_errno;
+	}
+
+	/* Not supported */
+	if (attr->egress) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
+				attr, "Not support egress.");
+		return -rte_errno;
+	}
+
+	/* Not supported */
+	if (attr->transfer) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
+				attr, "No support for transfer.");
+		return -rte_errno;
+	}
+
+	/* Not supported */
+	if (attr->priority) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
+				attr, "Not support priority.");
+		return -rte_errno;
+	}
+
+	/* Not supported */
+	if (attr->group) {
+		rte_flow_error_set(error, EINVAL,
+				RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
+				attr, "Not support group.");
+		return -rte_errno;
+	}
+
+	return 0;
+}
+
+static int
+txgbe_parse_ethertype_filter(struct rte_eth_dev *dev,
+			     const struct rte_flow_attr *attr,
+			     const struct rte_flow_item pattern[],
+			     const struct rte_flow_action actions[],
+			     struct rte_eth_ethertype_filter *filter,
+			     struct rte_flow_error *error)
+{
+	int ret;
+
+	ret = cons_parse_ethertype_filter(attr, pattern,
+					actions, filter, error);
+
+	if (ret)
+		return ret;
+
+	/* txgbe doesn't support MAC address. */
+	if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
+		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
+		rte_flow_error_set(error, EINVAL,
+			RTE_FLOW_ERROR_TYPE_ITEM,
+			NULL, "Not supported by ethertype filter");
+		return -rte_errno;
+	}
+
+	if (filter->queue >= dev->data->nb_rx_queues) {
+		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
+		rte_flow_error_set(error, EINVAL,
+			RTE_FLOW_ERROR_TYPE_ITEM,
+			NULL, "queue index much too big");
+		return -rte_errno;
+	}
+
+	if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
+		filter->ether_type == RTE_ETHER_TYPE_IPV6) {
+		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
+		rte_flow_error_set(error, EINVAL,
+			RTE_FLOW_ERROR_TYPE_ITEM,
+			NULL, "IPv4/IPv6 not supported by ethertype filter");
+		return -rte_errno;
+	}
+
+	if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
+		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
+		rte_flow_error_set(error, EINVAL,
+			RTE_FLOW_ERROR_TYPE_ITEM,
+			NULL, "mac compare is unsupported");
+		return -rte_errno;
+	}
+
+	if (filter->flags & RTE_ETHTYPE_FLAGS_DROP) {
+		memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
+		rte_flow_error_set(error, EINVAL,
+			RTE_FLOW_ERROR_TYPE_ITEM,
+			NULL, "drop option is unsupported");
+		return -rte_errno;
+	}
+
+	return 0;
+}
+