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 show
Series net: add txgbe PMD part 2 | expand

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;
+}
+