[dpdk-dev] [PATCH v3 5/7] lib/librte_ether: support new l2 tunnel operation

[Wenzhuo Lu <wenzhuo.lu@intel.com>]

Add functions to support the new l2 tunnel operation.
1, Insertion and stripping for l2 tunnel tag.
2, Forwarding the packets to a pool based on l2 tunnel tag.

Signed-off-by: Wenzhuo Lu <wenzhuo.lu@intel.com>
---
 lib/librte_ether/rte_ethdev.c | 183 ++++++++++++++++++++++++++++++++++++
 lib/librte_ether/rte_ethdev.h | 214 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 397 insertions(+)

diff --git a/lib/librte_ether/rte_ethdev.c b/lib/librte_ether/rte_ethdev.c
index 1b90e09..4ab3fd3 100644
--- a/lib/librte_ether/rte_ethdev.c
+++ b/lib/librte_ether/rte_ethdev.c
@@ -3300,3 +3300,186 @@ rte_eth_dev_l2_tunnel_disable(uint8_t port_id,
 				-ENOTSUP);
 	return (*dev->dev_ops->l2_tunnel_disable)(dev, l2_tunnel_type);
 }
+
+int
+rte_eth_dev_l2_tunnel_insertion_enable(uint8_t port_id,
+				       struct rte_eth_l2_tunnel *l2_tunnel,
+				       uint16_t vf_id)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+	if (l2_tunnel == NULL) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2_tunnel parameter\n");
+		return -EINVAL;
+	}
+
+	if (l2_tunnel->l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_insertion_enable,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_insertion_enable)(dev,
+							   l2_tunnel,
+							   vf_id);
+}
+
+int
+rte_eth_dev_l2_tunnel_insertion_disable(uint8_t port_id,
+					enum rte_eth_l2_tunnel_type
+						l2_tunnel_type,
+					uint16_t vf_id)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+
+	if (l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_insertion_disable,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_insertion_disable)(dev,
+							    l2_tunnel_type,
+							    vf_id);
+}
+
+int
+rte_eth_dev_l2_tunnel_stripping_enable(uint8_t port_id,
+				       enum rte_eth_l2_tunnel_type
+					       l2_tunnel_type)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+
+	if (l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_stripping_enable,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_stripping_enable)(dev,
+							   l2_tunnel_type);
+}
+
+int
+rte_eth_dev_l2_tunnel_stripping_disable(uint8_t port_id,
+					 enum rte_eth_l2_tunnel_type
+						 l2_tunnel_type)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+
+	if (l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_stripping_disable,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_stripping_disable)(dev,
+							    l2_tunnel_type);
+}
+
+int
+rte_eth_dev_l2_tunnel_forwarding_enable(uint8_t port_id,
+					 enum rte_eth_l2_tunnel_type
+						 l2_tunnel_type)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+
+	if (l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_forwarding_enable,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_forwarding_enable)(dev,
+							    l2_tunnel_type);
+}
+
+int
+rte_eth_dev_l2_tunnel_forwarding_disable(uint8_t port_id,
+					 enum rte_eth_l2_tunnel_type
+						 l2_tunnel_type)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+
+	if (l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_forwarding_disable,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_forwarding_disable)(dev,
+							     l2_tunnel_type);
+}
+
+int
+rte_eth_dev_l2_tunnel_filter_add(uint8_t port_id,
+				 struct rte_eth_l2_tunnel *l2_tunnel,
+				 uint32_t pool)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+	if (l2_tunnel == NULL) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2_tunnel parameter\n");
+		return -EINVAL;
+	}
+
+	if (l2_tunnel->l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_filter_add,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_filter_add)(dev,
+						     l2_tunnel,
+						     pool);
+}
+
+int
+rte_eth_dev_l2_tunnel_filter_del(uint8_t port_id,
+				 struct rte_eth_l2_tunnel *l2_tunnel)
+{
+	struct rte_eth_dev *dev;
+
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+	if (l2_tunnel == NULL) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2_tunnel parameter\n");
+		return -EINVAL;
+	}
+
+	if (l2_tunnel->l2_tunnel_type >= RTE_L2_TUNNEL_TYPE_MAX) {
+		RTE_PMD_DEBUG_TRACE("Invalid l2 tunnel type\n");
+		return -EINVAL;
+	}
+
+	dev = &rte_eth_devices[port_id];
+	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_filter_del,
+				-ENOTSUP);
+	return (*dev->dev_ops->l2_tunnel_filter_del)(dev,
+						     l2_tunnel);
+}
diff --git a/lib/librte_ether/rte_ethdev.h b/lib/librte_ether/rte_ethdev.h
index 9b594b8..70fe632 100644
--- a/lib/librte_ether/rte_ethdev.h
+++ b/lib/librte_ether/rte_ethdev.h
@@ -963,6 +963,7 @@ TAILQ_HEAD(rte_eth_dev_cb_list, rte_eth_dev_callback);
 struct rte_eth_l2_tunnel {
 	enum rte_eth_l2_tunnel_type l2_tunnel_type;
 	uint16_t ether_type;
+	uint32_t tunnel_id; /* port tag id for e-tag */
 };
 
 /*
@@ -1283,6 +1284,45 @@ typedef int (*eth_l2_tunnel_disable_t)
 	 enum rte_eth_l2_tunnel_type l2_tunnel_type);
 /**< @internal disable a type of l2 tunnel */
 
+typedef int (*eth_l2_tunnel_insertion_enable_t)
+	(struct rte_eth_dev *dev,
+	 struct rte_eth_l2_tunnel *l2_tunnel,
+	 uint16_t vf_id);
+/**< @internal enable insertion of l2 tunnel tag */
+
+typedef int (*eth_l2_tunnel_insertion_disable_t)
+	(struct rte_eth_dev *dev,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type,
+	 uint16_t vf_id);
+/**< @internal disable insertion of l2 tunnel tag */
+
+typedef int (*eth_l2_tunnel_stripping_enable_t)
+	(struct rte_eth_dev *dev, enum rte_eth_l2_tunnel_type l2_tunnel_type);
+/**< @internal enable stripping of l2 tunnel tag */
+
+typedef int (*eth_l2_tunnel_stripping_disable_t)
+	(struct rte_eth_dev *dev, enum rte_eth_l2_tunnel_type l2_tunnel_type);
+/**< @internal disable stripping of l2 tunnel tag */
+
+typedef int (*eth_l2_tunnel_forwarding_enable_t)
+	(struct rte_eth_dev *dev,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type);
+/**< @internal enable forwarding of l2 tunnel packets */
+
+typedef int (*eth_l2_tunnel_forwarding_disable_t)
+	(struct rte_eth_dev *dev,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type);
+/**< @internal disable forwarding of l2 tunnel packets */
+
+typedef int (*eth_l2_tunnel_filter_add_t)(struct rte_eth_dev *dev,
+					  struct rte_eth_l2_tunnel *l2_tunnel,
+					  uint32_t pool);
+/**< @internal add filter of l2 tunnel packets */
+
+typedef int (*eth_l2_tunnel_filter_del_t)(struct rte_eth_dev *dev,
+					  struct rte_eth_l2_tunnel *l2_tunnel);
+/**< @internal delete filter of l2 tunnel packets */
+
 #ifdef RTE_NIC_BYPASS
 
 enum {
@@ -1471,6 +1511,22 @@ struct eth_dev_ops {
 	eth_l2_tunnel_enable_t l2_tunnel_enable;
 	/** Disable a type of l2 tunnel */
 	eth_l2_tunnel_disable_t l2_tunnel_disable;
+	/** Enable insertion of l2 tunnel tag */
+	eth_l2_tunnel_insertion_enable_t l2_tunnel_insertion_enable;
+	/** Disable insertion of l2 tunnel tag */
+	eth_l2_tunnel_insertion_disable_t l2_tunnel_insertion_disable;
+	/** Enable stripping of l2 tunnel tag */
+	eth_l2_tunnel_stripping_enable_t l2_tunnel_stripping_enable;
+	/** Disable stripping of l2 tunnel tag */
+	eth_l2_tunnel_stripping_disable_t l2_tunnel_stripping_disable;
+	/** Enable forwarding of l2 tunnel packets */
+	eth_l2_tunnel_forwarding_enable_t l2_tunnel_forwarding_enable;
+	/** Disable forwarding of l2 tunnel packets */
+	eth_l2_tunnel_forwarding_disable_t l2_tunnel_forwarding_disable;
+	/** Add filter of l2 tunnel packets */
+	eth_l2_tunnel_filter_add_t l2_tunnel_filter_add;
+	/** Delete filter of l2 tunnel packets */
+	eth_l2_tunnel_filter_del_t l2_tunnel_filter_del;
 };
 
 /**
@@ -3971,6 +4027,164 @@ int
 rte_eth_dev_l2_tunnel_disable(uint8_t port_id,
 			      enum rte_eth_l2_tunnel_type l2_tunnel_type);
 
+ /**
+ * Enable l2 tunnel tag insertion of an Ethernet device for specific
+ * tunnel packets by ether type.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel
+ *   l2 tunnel configuration.
+ * @param vf_id
+ *   vf id.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_insertion_enable(uint8_t port_id,
+				       struct rte_eth_l2_tunnel *l2_tunnel,
+				       uint16_t vf_id);
+
+ /**
+ * Disable l2 tunnel tag insertion of an Ethernet device for specific
+ * tunnel packets by ether type.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel_type
+ *   l2 tunnel type.
+ * @param vf_id
+ *   vf id.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_insertion_disable
+	(uint8_t port_id,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type,
+	 uint16_t vf_id);
+
+ /**
+ * Enable l2 tunnel tag stripping of an Ethernet device for specific
+ * tunnel packets by ether type.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel_type
+ *   l2 tunnel type.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_stripping_enable
+	(uint8_t port_id,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type);
+
+ /**
+ * Disable l2 tunnel tag stripping of an Ethernet device for specific
+ * tunnel packets by ether type.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel_type
+ *   l2 tunnel type.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_stripping_disable
+	(uint8_t port_id,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type);
+
+ /**
+ * Enable l2 tunnel tag forwarding of an Ethernet device for specific
+ * tunnel packets by ether type.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel_type
+ *   l2 tunnel type.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_forwarding_enable
+	(uint8_t port_id,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type);
+
+ /**
+ * Disable l2 tunnel tag forwarding of an Ethernet device for specific
+ * tunnel packets by ether type.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel_type
+ *   l2 tunnel type.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_forwarding_disable
+	(uint8_t port_id,
+	 enum rte_eth_l2_tunnel_type l2_tunnel_type);
+
+ /**
+ * Add a filter for packet forwarding based on l2 tunnel tag of an Ethernet
+ * device for specific tunnel packets.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel
+ *   l2 tunnel configuration.
+ * @param pool
+ *   Destination pool.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_filter_add(uint8_t port_id,
+				 struct rte_eth_l2_tunnel *l2_tunnel,
+				 uint32_t pool);
+
+ /**
+ * Delete a filter for packet forwarding based on l2 tunnel tag of an Ethernet
+ * device for specific tunnel packets.
+ *
+ * @param port_id
+ *   The port identifier of the Ethernet device.
+ * @param l2_tunnel
+ *   l2 tunnel configuration.
+ *
+ * @return
+ *   - (0) if successful.
+ *   - (-ENODEV) if port identifier is invalid.
+ *   - (-ENOTSUP) if hardware doesn't support tunnel type.
+ */
+int
+rte_eth_dev_l2_tunnel_filter_del(uint8_t port_id,
+				 struct rte_eth_l2_tunnel *l2_tunnel);
+
 #ifdef __cplusplus
 }
 #endif
-- 
1.9.3